diff --git a/Audio_Captioning.ipynb b/Audio_Captioning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d61f9ca8a390f6bf6081cd21a8ed5a7b5c529f3c --- /dev/null +++ b/Audio_Captioning.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55df6d0d-71cf-4110-81ed-7c0d3ce58e43", + "metadata": {}, + "source": [ + "## Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0abe9574-05f7-4684-b586-033827b89c32", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "74e70729-b658-4ffd-9d8b-ae42a2d1b212", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks.caption import CaptionTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "\n", + "import random\n", + "from torchvision.transforms import functional as F\n", + "from torchvision.transforms import InterpolationMode\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ce03a870-2852-410e-97c4-59461d08f60a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register refcoco task\n", + "tasks.register_task('audio_caption', CaptionTask)" + ] + }, + { + "cell_type": "markdown", + "id": "58361680-3e90-4fff-962e-2ff67c1e7289", + "metadata": {}, + "source": [ + "### Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "adb79611-7563-4fb6-a576-f31050f8438e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.sample_patch_num 784\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "Loading: all_resnext101\n", + "use bn: \n", + "load pretrained_model /data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth\n", + "_IncompatibleKeys(missing_keys=[], unexpected_keys=['fc.weight', 'fc.bias'])\n", + "Loading: pann_cnn14\n", + "load pretrained_model /data/mshukor/logs/ofa/best_models/Cnn14_mAP_0.431.pth\n", + "_IncompatibleKeys(missing_keys=[], unexpected_keys=['fc1.weight', 'fc1.bias', 'fc_audioset.weight', 'fc_audioset.bias'])\n", + "load resnet /data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth\n", + "\n", + "unival\n", + "task\n", + "getattr(args, \"stop_on_max_len\", False) False\n" + ] + } + ], + "source": [ + "# Load pretrained ckpt & config\n", + "\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_audio_caption/checkpoint_best.pt'\n", + "\n", + "video_model_path = '/data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth'\n", + "audio_model_path = '/data/mshukor/logs/ofa/best_models/Cnn14_mAP_0.431.pth'\n", + "resnet_model_path = '/data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth'\n", + "\n", + "\n", + "\n", + "overrides={\"eval_cider\":False, \"beam\":5, \"max_len_b\":22, \"no_repeat_ngram_size\":3, \"seed\":7, \"unnormalized\": False,\n", + " \"bpe_dir\":\"utils/BPE\", \"video_model_path\": video_model_path, \"audio_model_path\": audio_model_path, \"resnet_model_path\": resnet_model_path,}\n", + "\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths(checkpoint_path),\n", + " arg_overrides=overrides\n", + " )\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "markdown", + "id": "e79aad39-1424-47d5-8cd4-6ab77ea46fb4", + "metadata": {}, + "source": [ + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "576a3e84-a6aa-446d-adab-fef9499318fc", + "metadata": {}, + "outputs": [], + "source": [ + "# Image transform\n", + "from torchvision import transforms\n", + "import torchaudio\n", + "\n", + "from data.audio_utils import get_audio_features, int16_to_float32, float32_to_int16, AUDIO_CFG\n", + "\n", + "\n", + "mean = [0.5, 0.5, 0.5]\n", + "std = [0.5, 0.5, 0.5]\n", + "\n", + "\n", + "\n", + "def process_audio(audio_path, sample_rate=48000, max_audio_len=480000, audio_cfg=AUDIO_CFG):\n", + "\n", + " # audio \n", + " data_path = audio_path\n", + "\n", + "\n", + "\n", + " audio_data, orig_sr = torchaudio.load(data_path)\n", + " audio_data = torchaudio.transforms.Resample(orig_sr, sample_rate)(audio_data[0])\n", + "\n", + " sample = {}\n", + "\n", + " sample = get_audio_features(\n", + " sample, audio_data, max_audio_len, \n", + " data_truncating='rand_trunc', \n", + " data_filling='repeatpad',\n", + " audio_cfg=audio_cfg\n", + " )\n", + "\n", + "\n", + " waveform = sample['waveform']\n", + " patch_audio = waveform\n", + " \n", + " return patch_audio.unsqueeze(0)\n", + "\n", + " \n", + " \n", + " \n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()\n", + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "\n", + "# Construct input for caption task\n", + "def construct_sample(audio_path):\n", + " \n", + " \n", + " patch_audio = process_audio(audio_path, sample_rate=48000, max_audio_len=480000, audio_cfg=AUDIO_CFG)\n", + " patch_image = torch.zeros((3, cfg.task.patch_image_size, cfg.task.patch_image_size)) \n", + " \n", + " patch_type = torch.tensor([2])\n", + " patch_mask = torch.tensor([True])\n", + " src_text = encode_text(\" what does the image describe?\", append_bos=True, append_eos=True).unsqueeze(0)\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " sample = {\n", + " \"id\":np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"patch_images\": patch_image,\n", + " \"patch_audios\": patch_audio,\n", + " \"patch_masks\": patch_mask,\n", + " \"patch_types\": patch_type,\n", + " }\n", + " }\n", + " return sample\n", + " \n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t" + ] + }, + { + "cell_type": "markdown", + "id": "f96f776e-9aa0-4271-b881-311851cc033c", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "6f8ddf8c-82e2-411c-baa3-850da02f1996", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 480000])\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "save_dir = '/home/mshukor/ofa_adastra'\n", + "\n", + "\n", + "\n", + "audio_path = '/data/mshukor/data/audiocaps/test/KSHpYhuTotY.wav' # A man talks while bees fly\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/6cS0FsUM-cQ.wav' # A cat is meowing and a man is speaking\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/6CDl4CqOgMg.wav' # A dog pants and whimpers\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/_BSmz3SEW1w.wav' # Pigeons coo and flap their wings\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/ZsTZ7jqbd9M.wav' # A man speaking with birds chirping in the background\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/5OM3tJh51pE.wav' # A woman giving a speech\n", + "\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/AJtNitYMa1I.wav' # Food sizzling in a pan\n", + "\n", + "audio_path = '/data/mshukor/data/audiocaps/test/3MoF8myFs8Y.wav' # Wind blows hard and waves crash against a shoreline\n", + "audio_path = '/data/mshukor/data/audiocaps/test/350OCezayrk.wav' # A motor vehicle engine is idling and vibrating\n", + "\n", + "\n", + "## limitations\n", + "# audio_path = '/data/mshukor/data/audiocaps/test/EBCH7TPgiPc.wav' # A motor vehicle engine is running and revving and an adult male speaks in the background\n", + "\n", + "\n", + "sample = construct_sample(audio_path)\n", + "sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + "sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample\n", + "print(sample['net_input']['patch_audios'].shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "4651039c-b8c0-4687-871e-b42cb13b2984", + "metadata": {}, + "outputs": [], + "source": [ + "from utils.eval_utils import eval_caption\n", + "\n", + "with torch.no_grad():\n", + " result, scores = eval_caption(task, generator, models, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "712150d4-f28c-4538-870f-b33f775725d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A motor vehicle engine is idling and vibrating\n" + ] + } + ], + "source": [ + "caption = result[0]['caption']\n", + "print(caption)\n", + "\n", + "from IPython.display import Audio\n", + "Audio(audio_path, embed=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "303d531f-dba3-40b9-a1ff-1be92d8c188a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8c5eb1f0-bca3-4b9a-a8f1-2f4468c54025", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Captioning.ipynb b/Captioning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dd29e39d33cf0be0d7e9f329836a6158b879e929 --- /dev/null +++ b/Captioning.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55df6d0d-71cf-4110-81ed-7c0d3ce58e43", + "metadata": {}, + "source": [ + "## Import" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0abe9574-05f7-4684-b586-033827b89c32", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "74e70729-b658-4ffd-9d8b-ae42a2d1b212", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks.caption import CaptionTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "\n", + "import random\n", + "from torchvision.transforms import functional as F\n", + "from torchvision.transforms import InterpolationMode\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ce03a870-2852-410e-97c4-59461d08f60a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register refcoco task\n", + "tasks.register_task('caption', CaptionTask)" + ] + }, + { + "cell_type": "markdown", + "id": "58361680-3e90-4fff-962e-2ff67c1e7289", + "metadata": {}, + "source": [ + "### Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "adb79611-7563-4fb6-a576-f31050f8438e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[autoreload of tasks.ofa_task failed: Traceback (most recent call last):\n", + " File \"/data/mshukor/envs/ofa/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 245, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"/data/mshukor/envs/ofa/lib/python3.7/site-packages/IPython/extensions/autoreload.py\", line 394, in superreload\n", + " module = reload(module)\n", + " File \"/data/mshukor/envs/ofa/lib/python3.7/imp.py\", line 314, in reload\n", + " return importlib.reload(module)\n", + " File \"/data/mshukor/envs/ofa/lib/python3.7/importlib/__init__.py\", line 169, in reload\n", + " _bootstrap._exec(spec, module)\n", + " File \"\", line 630, in _exec\n", + " File \"\", line 728, in exec_module\n", + " File \"\", line 219, in _call_with_frames_removed\n", + " File \"/home/mshukor/unival/tasks/ofa_task.py\", line 144, in \n", + " class OFATask(FairseqTask):\n", + " File \"/home/mshukor/ofa_ours/fairseq/fairseq/tasks/__init__.py\", line 71, in register_task_cls\n", + " raise ValueError(\"Cannot register duplicate task ({})\".format(name))\n", + "ValueError: Cannot register duplicate task (unival)\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.sample_patch_num 784\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "Loading: all_resnext101\n", + "use bn: \n", + "unival\n", + "getattr(args, \"stop_on_max_len\", False) False\n" + ] + } + ], + "source": [ + "# Load pretrained ckpt & config\n", + "\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_caption_stage_1/checkpoint_best_test.pt'\n", + "video_model_path = '/data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth'\n", + "\n", + "overrides={\"eval_cider\":False, \"beam\":5, \"max_len_b\":22, \"no_repeat_ngram_size\":3, \"seed\":7, \"unnormalized\": False,\n", + " \"bpe_dir\":\"utils/BPE\", \"video_model_path\": None,}\n", + "\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths(checkpoint_path),\n", + " arg_overrides=overrides\n", + " )\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "markdown", + "id": "e79aad39-1424-47d5-8cd4-6ab77ea46fb4", + "metadata": {}, + "source": [ + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "576a3e84-a6aa-446d-adab-fef9499318fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/ipykernel_launcher.py:9: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n", + " if __name__ == \"__main__\":\n", + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/torchvision/transforms/transforms.py:330: UserWarning: Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. Please use InterpolationMode enum.\n", + " \"Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. \"\n" + ] + } + ], + "source": [ + "# Image transform\n", + "from torchvision import transforms\n", + "mean = [0.5, 0.5, 0.5]\n", + "std = [0.5, 0.5, 0.5]\n", + "\n", + "patch_resize_transform = transforms.Compose(\n", + " [\n", + " lambda image: image.convert(\"RGB\"),\n", + " transforms.Resize((cfg.task.patch_image_size, cfg.task.patch_image_size), interpolation=Image.BICUBIC),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=mean, std=std),\n", + " ]\n", + ")\n", + "\n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()\n", + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "# Construct input for caption task\n", + "def construct_sample(image: Image):\n", + " patch_image = patch_resize_transform(image).unsqueeze(0)\n", + " patch_mask = torch.tensor([True])\n", + " src_text = encode_text(\" what does the image describe?\", append_bos=True, append_eos=True).unsqueeze(0)\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " sample = {\n", + " \"id\":np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"patch_images\": patch_image,\n", + " \"patch_masks\": patch_mask\n", + " }\n", + " }\n", + " return sample\n", + " \n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t" + ] + }, + { + "cell_type": "markdown", + "id": "f96f776e-9aa0-4271-b881-311851cc033c", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6f8ddf8c-82e2-411c-baa3-850da02f1996", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "save_dir = '/home/mshukor/ofa_adastra'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002153.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002587.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002532.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002434.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002346.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002164.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002142.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000001960.jpg'\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000001561.jpg'\n", + "\n", + "\n", + "# Limitations good results\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000010211.jpg'\n", + "# img_path = 'results/images/mirror.png'\n", + "# img_path = 'results/images/garbage.png'\n", + "# img_path = 'results/images/stade.png'\n", + "# img_path = 'results/images/gello.png'\n", + "# img_path = 'results/images/door.png'\n", + "# img_path = 'results/images/bag.png'\n", + "# img_path = 'results/images/woman.png'\n", + "# img_path = 'results/images/pizza.jpeg'\n", + "# img_path = 'results/images/street.jpg'\n", + "# img_path = 'results/images/street2.jpg'\n", + "\n", + "\n", + "# Limitations bad results\n", + "# img_path = 'results/images/guitar.png'\n", + "img_path = save_dir + '/results/images/muffin.png'\n", + "# img_path = save_dir +'/results/images/hydrant.png'\n", + "\n", + "\n", + "\n", + "image = Image.open(img_path)\n", + "sample = construct_sample(image)\n", + "sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + "sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4651039c-b8c0-4687-871e-b42cb13b2984", + "metadata": {}, + "outputs": [], + "source": [ + "from utils.eval_utils import eval_caption\n", + "\n", + "with torch.no_grad():\n", + " result, scores = eval_caption(task, generator, models, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "712150d4-f28c-4538-870f-b33f775725d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a close up of a doughnut with ketchup on it\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "caption = result[0]['caption']\n", + "print(caption)\n", + "plt.figure(figsize=(15, 15))\n", + "plt.axis('off')\n", + "\n", + "plt.imshow(image)\n", + "\n", + "save_path = save_dir+'/results/caption/'+\"_\".join(caption.split(' '))+\".jpg\"\n", + "plt.savefig(save_path, bbox_inches='tight')\n", + "\n", + "\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "303d531f-dba3-40b9-a1ff-1be92d8c188a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Image_gen.ipynb b/Image_gen.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..572e8d34bccb291b418b0c324b5c38540bc0c348 --- /dev/null +++ b/Image_gen.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "399f2fcf-9241-4910-a30d-6ca19880d0ad", + "metadata": {}, + "source": [ + "## Import" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "97e68340-0096-475e-8ed8-22f5d627e3ad", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks import ImageGenTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "from torchvision import transforms\n", + "import time\n", + "\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = True if use_cuda else False" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "719cef65-c00c-4c9c-90b2-e660b386c3d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register caption task\n", + "tasks.register_task('image_gen', ImageGenTask)\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc9c1d7b-898b-4ac4-adf3-832891d9e4be", + "metadata": {}, + "source": [ + "### Load model " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "568bb6ea-eef9-4024-98e6-35e74b5ffeec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.sample_patch_num 784\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "Frozen image bn \n", + "Loading: all_resnext101\n", + "use bn: \n", + "load pretrained_model /data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth\n", + "_IncompatibleKeys(missing_keys=[], unexpected_keys=['fc.weight', 'fc.bias'])\n", + "load resnet /data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth\n", + "\n", + "RAM memory % used: 10.5\n", + "RAM Used (GB): 19.574349824\n", + "encoder\n", + "RAM memory % used: 10.5\n", + "decoder\n", + "RAM memory % used: 10.5\n", + "ofa\n", + "Working with z of shape (1, 256, 32, 32) = 262144 dimensions.\n" + ] + } + ], + "source": [ + "# Load pretrained ckpt & config\n", + "clip_model_path='/data/mshukor/data/ofa/clip/ViT-B-16.pt'\n", + "vqgan_model_path='/data/mshukor/data/ofa/vqgan/last.ckpt'\n", + "vqgan_config_path='/data/mshukor/data/ofa/vqgan/model.yaml'\n", + "\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_ofa_stage_1_base_s2_hsep1_long/checkpoint_best.pt'\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_ofaplus_stage_1_base_s2_long/checkpoint_best.pt'\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_base_best.pt'\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_large_best.pt'\n", + "\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_ofaplus_stage_1_base_s2_hsep1_long/checkpoint_best.pt'\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/image_gen_ofaplus_stage_2_base_s2_hsep1_long/checkpoint_best.pt'\n", + "\n", + "\n", + "\n", + "video_model_path = '/data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth'\n", + "resnet_model_path = '/data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth'\n", + "\n", + "gen_images_path='results/image_gen/'\n", + "\n", + "overrides = {\"bpe_dir\": \"utils/BPE\",\n", + " \"eval_cider\": False,\n", + " \"beam\": 24,\n", + " \"max_len_b\": 1024,\n", + " \"max_len_a\": 0,\n", + " \"min_len\": 1024,\n", + " \"sampling_topk\": 256,\n", + " \"constraint_range\": \"50265,58457\",\n", + " \"clip_model_path\": clip_model_path,\n", + " \"vqgan_model_path\": vqgan_model_path,\n", + " \"vqgan_config_path\": vqgan_config_path,\n", + " \"seed\": 42,\n", + " \"video_model_path\": video_model_path, \n", + " \"resnet_model_path\": resnet_model_path,\n", + " \"gen_images_path\":gen_images_path,\n", + " \"patch_image_size\": 256,\n", + " \"temperature\": 1.5,\n", + " }\n", + "\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths(checkpoint_path),\n", + " arg_overrides=overrides\n", + ")\n", + "\n", + "task.cfg.sampling_times = 2\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)\n", + "\n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()" + ] + }, + { + "cell_type": "markdown", + "id": "5e4a45ec-bce1-495b-8033-3b574367b360", + "metadata": {}, + "source": [ + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9f2e7e32-c9a0-43b3-bf86-2419d9f7dfe0", + "metadata": {}, + "outputs": [], + "source": [ + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "\n", + "# Construct input for image generation task\n", + "def construct_sample(query: str):\n", + " code_mask = torch.tensor([True])\n", + " src_text = encode_text(\" what is the complete image? caption: {}\".format(query), append_bos=True,\n", + " append_eos=True).unsqueeze(0)\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " sample = {\n", + " \"id\": np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"code_masks\": code_mask\n", + " }\n", + " }\n", + " return sample\n", + "\n", + "\n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t\n", + "\n", + "\n", + "# Function for image generation\n", + "def image_generation(caption):\n", + " sample = construct_sample(caption)\n", + " sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + " sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample\n", + " print('|Start|', time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime()), caption)\n", + " with torch.no_grad():\n", + " result, scores = eval_step(task, generator, models, sample)\n", + "\n", + " # return top-4 results (ranked by clip)\n", + " images = [result[i]['image'] for i in range(4)]\n", + " pic_size = 256\n", + " retImage = Image.new('RGB', (pic_size * 2, pic_size * 2))\n", + " print('|FINISHED|', time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime()), caption)\n", + " for i in range(4):\n", + " loc = ((i % 2) * pic_size, int(i / 2) * pic_size)\n", + " retImage.paste(images[i], loc)\n", + " return retImage" + ] + }, + { + "cell_type": "markdown", + "id": "44dec799-c5c2-4d22-8b08-7a7ca2cdf3c9", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "02d5cd7a-8d63-4fa4-9da1-d4b79ec01445", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "|Start| 2023-06-29 12:57:39 A brown horse in the street\n", + "|FINISHED| 2023-06-29 12:59:03 A brown horse in the street\n" + ] + } + ], + "source": [ + "query = \"A brown horse in the street\"\n", + "# query = \"Cattle grazing on grass near a lake surrounded by mountain.\"\n", + "# query = 'A street scene with a double-decker bus on the road.'\n", + "# query = 'A path.'\n", + "\n", + "\n", + "retImage = image_generation(query)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a8a1654-1f17-41c7-b410-c7491a96dcee", + "metadata": {}, + "outputs": [], + "source": [ + "retImage.save(f'{query}.png')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..a7767b63a8d61b2622642ccc9012f06af5053e17 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 1999-2022 Alibaba Group Holding Ltd. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index c08115d2e840e7406f6d3df559ba45d334bd3017..f0f500e2181fdd93a7108690942debfbeec2f5c2 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,618 @@ ---- -title: UnIVAL -emoji: 🌖 -colorFrom: green -colorTo: green -sdk: gradio -sdk_version: 3.35.2 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference + + +todo: +models +data +all readme +animation + +readme of: +rewarded soups +and others + +

+
+ +
+

+
+ +

+ ModelScope  ｜  Checkpoints  ｜  Colab  ｜  Demo  ｜  Paper   ｜  Blog +

+ +

+
+ +
+

+ +[colab]: + +OFA is a unified sequence-to-sequence pretrained model (support **English** and **Chinese**) that unifies modalities (i.e., cross-modality, vision, language) and tasks (**finetuning** and **prompt tuning** are supported): image captioning (1st at the [MSCOCO Leaderboard](https://competitions.codalab.org/competitions/3221#results)), VQA ([link](https://eval.ai/web/challenges/challenge-page/830/leaderboard/2278)), visual grounding, text-to-image generation, text classification, text generation, image classification, etc. We provide **step-by-step** instructions for pretraining and finetuning and corresponding checkpoints (check official ckpt \[[EN](checkpoints.md)|[CN](checkpoints_cn.md)\] or [huggingface ckpt](https://huggingface.co/OFA-Sys)). + +We sincerely welcome contributions to our project. Feel free to contact us or send us issues / PRs! +

+ +# Our installation + +after installling pycocoevalcap, donwload needed models: +``` +python -c "from pycocoevalcap.spice.spice import Spice; tmp = Spice()" + +``` + +# Online Demos +We provide online demo via Hugging Face Spaces for you to interact with our pretrained and finetuned models. Below are the links to the demos: +* Image Captioning \[[ModelScope](https://modelscope.cn/#/models/damo/ofa_image-caption_coco_large_en/summary) | [Spaces](https://huggingface.co/spaces/OFA-Sys/OFA-Image_Caption)\] +* Visual Grounding \[[ModelScope](https://modelscope.cn/#/models/damo/ofa_visual-grounding_refcoco_large_en/summary) | [Spaces](https://huggingface.co/spaces/OFA-Sys/OFA-Visual_Grounding)\] +* Visual Question Answering \[[ModelScope](https://modelscope.cn/#/models/damo/ofa_visual-question-answering_pretrain_large_en/summary) | [Spaces](https://huggingface.co/spaces/OFA-Sys/OFA-Visual_Question_Answering)\] +* Text-to-Image Generation \[[ModelScope](https://modelscope.cn/#/models/damo/ofa_text-to-image-synthesis_coco_large_en/summary) | [Spaces](https://huggingface.co/spaces/OFA-Sys/OFA-Text2Image_Generation)\] +* Generic Interface \[[Spaces](https://huggingface.co/spaces/OFA-Sys/OFA-Generic_Interface)\] + +Also we provide Colab notebooks for you to better perceive the procedures. Click [here](colab.md) to check them out! +

+ +# Use in Huggingface Transformers +We support the inference of OFA in Huggingface Transformers. Check the [README](transformers.md) and [Colab Notebook](https://colab.research.google.com/drive/1Ho81RBV8jysZ7e0FhsSCk_v938QeDuy3?usp=sharing) for more information. Codes are released in this branch https://github.com/OFA-Sys/OFA/tree/feature/add_transformers +

+ + +# News +* 2022.8.22: Released checkpoints and demos of **OFA** and **Chinese CLIP** on [ModelScope](https://modelscope.cn/). Check the [README](modelscope.md) for more details! +* 2022.8.16: Released the **Chinese** version of OFA. **OFA-CN** needs only switching to `bpe_dir=../../utils/BERT_CN_dict` and `bpe=bert` and using our provided Chinese checkpoints in [checkpoints_cn.md](checkpoints_cn.md). Temporarily, we only provide base-size and large-size pretrained checkpoints and finetuned checkpoints on [MUGE Caption](https://tianchi.aliyun.com/muge) and the Chinese version of RefCOCO(-/+/g) (to release soon). +* 2022.8.5: Released support of **prompt tuning** for OFA. Check our paper [here](https://arxiv.org/abs/2208.02532)! Please see the [prompt_tuning.md](prompt_tuning.md) for further details. +* 2022.7.7: Updated support of OFA on **huggingface transformers** (fixed bugs in forward, add sequence generator from Fairseq to ensure performance, etc.). Refer to the doc [transformers.md](transformers.md) and the branch `feature/add_transformers`. +* 2022.6.17: Released the pretrained checkpoint of **OFA-Huge**. To use it, set `--arch=ofa_huge` in the script. +* 2022.5.15: OFA was accepted by **ICML 2022** +* 2022.4.28: Add support of inference on **huggingface transformers**. For how to use it, please refer to the doc [transformers.md](transformers.md) and our [huggingface models](https://huggingface.co/OFA-Sys). +* 2022.4.16: Released lightweight pretrained models **OFA-Medium** (~93M params) and **OFA-Tiny** (~33M params) in [checkpoints.md](checkpoints.md). To use them, you just need to load the corresponding checkpoint and set `--arch=ofa_medium` or `--arch=ofa_tiny` in the scripts. + +

+ More News +

+

    +
  • 2022.3.23: Added [Encouraging Loss](https://arxiv.org/pdf/2110.06537.pdf) as a feature. See [README_EncouragingLoss.md](README_EncouragingLoss.md). Leveraging this feature, OFA-Large has achieved improved results in both VQA (**test-std acc: 80.67**) and Image Classification (**test acc: 85.6**) recently.
    • +
  • 2022.3.21: Released codes for pretraining OFA.
    • +
  • 2022.3.18: Released the finetuned OFA-Base (~180M parameters) checkpoints and running scripts for vision & language tasks, including: Caption (146.4 CIDEr), VQA (78.07 on test-std), SNLI-VE (89.3 on dev), RefCOCO (90.67 on testA), RefCOCO+ (87.15 on testA) and RefCOCOg (82.31 on test-u).
    • +
  • 2022.3.11: Released the finetuning & inference code/checkpoints for Gigaword.
    • +
  • 2022.3.08: Released the pretrained checkpoint of OFA-Base in checkpoints.md. To use OFA-Base, you just need to load ofa_base.pt and change --arch=ofa_large to --arch=ofa_base in the training scripts.
    • +
  • 2022.3.07: Released the finetuning & inference code/checkpoints for Image Classification, which achieves 85.0 accuracy on ImageNet-1K, slightly better than reported in OFA paper.
    • +
  • 2022.3.04: Released the finetuning & inference code/checkpoints for Text-to-Image Generation.
    • +
  • 2022.3.03: Released the finetuning & inference code/checkpoints for SNLI-VE and GLUE.
    • +
  • 2022.2.22: Released the finetuning & inference code/checkpoints for Visual Question Answering, which can reproduce the reported VQA accuracy in OFA paper (80.02 on test-std). Check our results on the VQA Challenge.
    • +
  • 2022.2.15: Released finetuning & inference code/checkpoints for Referring Expression Comprehension
    • +
  • 2022.2.10: Released the inference code & finetuned checkpoint for Image captioning, which can reproduce the results on COCO Karparthy test split (149.6 CIDEr). OFA also achieves No.1 on the COCO image captioning online leaderboard Link (marked as M6-Team).
    • +
+

+
+

+ + +# Model Card +We list the parameters and pretrained checkpoints of OFAs below. For finetuned checkpoints, please refer to [checkpoints.md](checkpoints.md). + + + + + + + + + + + + + + + + + + + + +
ModelCkptParamsBackboneHidden sizeIntermediate sizeNum. of headsEnc layersDec layers
OFATinyDownload33MResNet502561024444
OFAMediumDownload93MResNet1015122048844
OFABaseDownload180MResNet10176830721266
OFALargeDownload470MResNet15210244096161212
OFAHugeDownload930MResNet15212805120162412
+

+ +# Results +Below we demonstrate the results of OFAs on cross-modal understanding and generation. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TaskImage CaptioningVQAVisual EntailmentReferring Expression Comprehension
DatasetCOCOVQA v2SNLI-VERefCOCORefCOCO+RefCOCOg
SplitKarpathy test (CE/CIDEr)test-dev/test-stdval/testval/test-a/test-bval/test-a/test-bval-u/test-u
MetricCIDErAcc.Acc.Acc.
OFATiny119.0 / 128.770.3 / 70.485.3 / 85.280.20 / 84.07 / 75.0068.22 / 75.13 / 57.6672.02 / 69.74
OFAMedium130.4 / 140.375.4 / 75.586.6 / 87.085.34 / 87.68 / 77.9276.09 / 83.04 / 66.2578.76 / 78.58
OFABase138.2 / 146.778.0 / 78.189.3 / 89.288.48 / 90.67 / 83.3081.39 / 87.15 / 74.2982.29 / 82.31
OFALarge142.2 / 150.780.4 / 80.790.3 / 90.290.05 / 92.93 / 85.2685.80 / 89.87 / 79.2285.89 / 86.55
OFAHuge145.3 / 154.982.0 / 82.091.0 / 91.292.04 / 94.03 / 88.4487.86 / 91.70 / 80.7188.07 / 88.78
+

+ +# Requirements +* python 3.7.4 +* pytorch 1.8.1 +* torchvision 0.9.1 +* JAVA 1.8 (for COCO evaluation) +

+ +# Installation +```bash +git clone https://github.com/OFA-Sys/OFA +pip install -r requirements.txt +``` +

+ +# Datasets and Checkpoints +See [datasets.md](datasets.md) and [checkpoints.md](checkpoints.md). +

+ +# Training & Inference +Below we provide methods for training and inference on different tasks. We provide both pretrained OFA-Large and OFA-Base in [checkpoints.md](checkpoints.md). The scripts mentioned in this section are prepared for OFA-Large. For reproducing the downstreaming results of OFA-Base, we have also provided the corresponding finetuning and inference scripts for OFA-Base in the `run_scripts/` folder. + +We recommend that your workspace directory should be organized like this: +``` +OFA/ +├── checkpoints/ +│   ├── ofa_base.pt +│   ├── ofa_large.pt +│   ├── caption_large_best_clean.pt +│   └── ... +├── criterions/ +├── data/ +├── dataset/ +│   ├── caption_data/ +│   ├── gigaword_data/ +│   └── ... +├── fairseq/ +├── models/ +├── run_scripts/ +├── tasks/ +├── train.py +├── trainer.py +└── utils/ +``` + + +## Image Processing +To ensure the efficiency of processing data, we did not store images with small files, but instead we encode them to base64 strings. +Transforming image files to base64 strings is simple. Run the following code: +```python +from PIL import Image +from io import BytesIO +import base64 + +img = Image.open(file_name) # path to file +img_buffer = BytesIO() +img.save(img_buffer, format=img.format) +byte_data = img_buffer.getvalue() +base64_str = base64.b64encode(byte_data) # bytes +base64_str = base64_str.decode("utf-8") # str +``` + +## Pretraining +Below we provide methods for pretraining OFA. + +
+ 1. Prepare the Dataset +

+ To pretrain OFA, you should first download the dataset we provide (pretrain_data_examples.zip, a small subset of the original pretraining data). For your customed pretraining datasets, please prepare your training samples into the same format. pretrain_data_examples.zip contains 4 TSV files: vision_language_examples.tsv, text_examples.tsv, image_examples.tsv and detection_examples.tsv. Details of these files are as follows: +
+

    +
  • vision_language_examples.tsv: + Each line contains uniq-id, image (base64 string), caption, question, answer, ground-truth objects (objects appearing in the caption or question), dataset name (source of the data) and task type (caption, qa or visual gronunding). Prepared for the pretraining tasks of visual grounding, grounded captioning, image-text matching, image captioning and visual question answering.
    • +
  • text_examples.tsv: Each line contains uniq-id and text. Prepared for the pretraining task of text infilling.
    • +
  • image_examples.tsv: Each line contains uniq-id, image (base64 string, should be resized to 256*256 resolution) and image-code (generate the sparse codes for the central part of image through VQ-GAN). Prepared for the pretraining task of image infilling.
    • +
  • detection_examples.tsv: Each line contains uniq-id, image (base64 string) and bounding box annotations (contains the top-left and bottom-right coordinates of the bounding box, object_id and object_name, seperated by commas). Prepared for the pretraining task of detection.
    • +
+ In addition, the folder negative_sample in pretrain_data_examples.zip contains three files all_captions.txt, object.txt and type2ans.json. The data in these files are used as negative samples for the image-text matching (ITM) task. +

+
+
+ 2. Pretraining +

+ By default, the pretraining script will attempt to restore the released pretrained checkpoints of OFA-Base or OFA-Large and perform continuous pretraining. Continuous pretraining is more recommended, which achieves much better results compared with pretraining from scratch. For continuous pretraining, please download the pretrained weights in advance (see checkpoints.md) and put them in the correct directory OFA/checkpoints/. If not, the pretraining will begin from scratch. +

+
+cd run_scripts/pretraining
+bash pretrain_ofa_large.sh # Pretrain OFA-Large. For OFA-Base, use pretrain_ofa_base.sh
+
+

+ If the pretrained OFA checkpoint is restored successfully, you will see the following information in the log: +

+
+INFO: Loaded checkpoint ../../checkpoints/ofa_large.pt
+
+
+ +## Image Captioning +We provide procedures to reproduce our results of image captioning on our paper below. +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. The dataset zipfile caption_data.zip contains caption_stage1_train.tsv, caption_stage2_train.tsv, caption_val.tsv and caption_test.tsv. Each image corresponds to only 1 caption in caption_stage1_train.tsv and corresponds to multiple captions in other TSV files (about 5 captions per image). Each line of the dataset represents a caption sample with the following format. The information of uniq-id, image-id, caption, predicted object labels (taken from VinVL, not used), image base64 string are separated by tabs. +

+
+162365  12455   the sun sets over the trees beyond some docks.  sky&&water&&dock&&pole  /9j/4AAQSkZJ....UCP/2Q==
+
+
+
+ 2. Finetuning +

+ Following previous standard practice, we divide the finetuning process of image captioning into two stages. In stage 1, we finetune OFA with cross-entropy loss on 4 NVIDIA-V100 GPUs with 32GB memory (expected to obtain ~139.5 CIDEr on the validation set at this stage). In stage 2, we select the best checkpoint of stage 1 and train with CIDEr optimization on 8 NVIDIA-V100 GPUs. Note that CIDEr optimization is very unstable and requires careful hyperparameter tuning. If you encounter training errors in the stage2 finetuning, you can increase the batch size or reduce the learning rate. If neither of these works, you can directly set --freeze-resnet to freeze the inner states of batch normalization. +

+
+cd run_scripts/caption
+nohup sh train_caption_stage1.sh > train_stage1.out &  # stage 1, train with cross-entropy loss
+nohup sh train_caption_stage2.sh > train_stage2.out &  # stage 2, load the best ckpt of stage1 and train with CIDEr optimization 
+
+
+
+ 3. Inference +

+ Run the following commands to get your results and evaluate your model. +

+
+cd run_scripts/caption ; sh evaluate_caption.sh  # inference & evaluate
+
+
+ +## Text-to-Image Generation +This part provides procedures for the finetuning and inference of text-to-image generation. See below. + +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. The dataset zipfile coco_image_gen.zip contains coco_vqgan_train.tsv, coco_vqgan_dev.tsv and coco_vqgan_full_test.tsv. Each line of the dataset represents a sample with the following format. The information of uniq-id, image-code (produced by vqgan, a list of integers separated by single-whitespaces), lowercased caption are separated by tabs. +

+
+1	6674 4336 4532 5334 3251 5461 3615 2469 ...4965 4190 1846	the people are posing for a group photo.
+
+

+ The checkpoint zipfile image_gen_large_best.zip contains image_gen_large_best.pt, vqgan/last.ckpt, vqgan/model.yaml and clip/Vit-B-16.pt. +

+
+
+ 2. Shuffle the Training Data +

+ (Optional, but achieves better result): If the disk storage is sufficient, we recommend to prepare the shuffled training data for each epoch in advance. +

+
+cd dataset/image_gen
+ln coco_vqgan_train.tsv coco_vqgan_train_1.tsv
+for idx in `seq 1 9`;do shuf coco_vqgan_train_${idx}.tsv > coco_vqgan_train_$[${idx}+1].tsv;done # each file is used for an epoch
+
+
+
+ 3. Finetuning +

+ Following previous practice, we divide the finetuning process of image generating into two stages. In stage 1, we finetune OFA with cross-entropy loss on 4 8-V100-32G-GPU servers (expected to obtain ~32.5+ CLIP Score on the validation set at this stage). In stage 2, we select the last checkpoint of stage 1 and train with CLIP Score optimization on 4 8-V100-32G-GPU servers (expected to obtain ~34.0+ CLIP Score on the validation set at this stage). During the validation, the generated image will be dumped into _GEN_IMAGE_PATH_. +

+
+# run on each worker after the distributed and data configs have been correctly set following the guide in train_image_gen_stage1_distributed.sh 
+cd run_scripts/image_gen
+nohup sh train_image_gen_stage1_distributed.sh # stage 1, train with cross-entropy loss
+nohup sh train_image_gen_stage2_distributed.sh # stage 2, load the last ckpt of stage1 and train with CLIP Score optimization 
+
+
+
+ 4. Inference +

+ Run the command below to generate your images. +

+
+cd run_scripts/image_gen ; sh evaluate_image_gen.sh  # inference & evaluate (FID, IS and CLIP Score)
+
+
+ +## Visual Question Answering +Here we provide the finetuning and inference codes to reproduce the VQAv2 result reported in our paper (**test-std 80.02**). We believe much improvement on accuracy can still be achieved based on this codebase :) +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. The dataset zipfile vqa_data.zip is around 100G and the decompressed data costs around 135G disk storage, which contains the training, validation and testing samples together with other necessary data resources. (Since vqa_data.zip is large in size, we have also provided chunked parts of the dataset files for more convenient and stable downloading. Please refer to issue #68.) Following common practice, VG-QA samples are also included in the training data. To adapt to the seq2seq paradigm of OFA, we transform original VQA training questions with multiple golden answers into multiple training samples. For the original VQA validation set, we keep around 10k samples for our validation and utilize the other samples for training. Each line of the dataset represents a VQA sample with the following format. The information of question-id, image-id, question, answer (with confidence), predicted object labels (taken from VinVL, slightly brings around +0.1 accuracy improvement), image base64 string are separated by tabs. +

+
+79459   79459   is this person wearing shorts?  0.6|!+no    house&&short&&...&&sky  /9j/4AAQS...tigZ/9k=
+
+

+ For fine-tuning on customed VQA-formulated tasks, please refer to issue #76, #105 and #73 for more information. +

+
+
+ 2. Shuffle the Training Data +

+ (Optional, but achieves better finetuning accuracy): If the disk storage is sufficient, we recommend to prepare the shuffled training data for each epoch in advance. In our experiments, we use shuffling which brings around +0.3 improvement on VQA accuracy. +

+
+cd dataset/vqa_data
+ln vqa_train.tsv vqa_train_1.tsv
+for idx in `seq 1 9`;do shuf vqa_train_${idx}.tsv > vqa_train_$[${idx}+1].tsv;done # each file is used for an epoch
+
+
+
+ 3. Finetuning +

+ In our experiments, the VQA finetuning is performed on 4 8-A100-GPU servers (with RDMA). Here provides the finetuning script train_vqa_distributed.sh, which supports multi-server distributed training (as well as single-server training). Please refer to the comments in the beginning of the script and set the configs correctly according to your distribution environment. If you have shuffled the training data in the previous step, please correctly specify the training data path following the guide in the script comments. The command should be run on each worker. +

+
+# run on each worker after the distributed and data configs have been correctly set following the guide in train_vqa_distributed.sh 
+cd run_scripts/vqa
+bash train_vqa_distributed.sh 
+
+

+ In our experiments, the finetuning costs around 36 hours (for 12 epochs). After each epoch, an evaluation on validation set is performed. The best validation accuracy during finetuning will be around 80.8. The log is saved in ${log_dir}. +

+

+ (Update on validation time-cost) As will be mentioned in the 4. Inference section, we prepare 2 types of inference: beam-search and all-candidate inference. By default, all-candidate inference is used for validation during fine-tuning, which achieves better accuracy but costs much time. Now we have added a new option in the training scripts called --val-inference-type to switch the validation inference type during fine-tuning. If you feel the validation takes too long, you can refer to PR #79 to activate beam-search validation, which significantly takes much less time, with around 0.5-0.6 validation score degradation compared with all-candidate validation. +

+
+
+ 4. Inference +

+ We provide 2 types of inference, beam-search (much faster but gets sub-optimal accuracy) and all-candidate evaluation (slower but best accuracy).

+ For beam-search inference, use the script evaluate_vqa_beam.sh. Refer to the command below. The inference on test set costs around 16 GPU hours. After inference on test set, the result JSON file will be dumped in the ${result_path} defined in the shell script. You can submit the result test_predict.json to EvalAI. Using our released finetuned checkpoint, beam-search inference will get 80.15 validation accuracy, 79.36 test-dev accuracy and 79.48 test-std accuracy (around 0.6 lower than all-candidate evaluation). +

+
+cd run_scripts/vqa
+bash evaluate_vqa_beam.sh val # specify 'val' or 'test'
+
+

+ For all-candidate evaluation, we recommend to use the distributed script evaluate_vqa_allcand_distributed.sh. Please refer to the guide in the script to set the distributed configs before running. The result JSON file will be dumped in the ${result_path} defined in the shell script of rank-0 server. All-candidate evaluation computes scores on all the candidate answers in the VQA dataset, which achieves 80.82 validation accuracy, 79.87 test-dev accuracy and 80.02 test-std accuracy, reproducing our reported results in the paper. However, the inference on test set costs around 1k GPU hours, which is much slower. +

+
+# run on each worker after the distributed configs have been correctly set following the guide in evaluate_vqa_allcand_distributed.sh
+cd run_scripts/vqa
+bash evaluate_vqa_allcand_distributed.sh val # specify 'val' or 'test'
+
+
+ +## Referring Expression Comprehension +Here provides procedures for you to prepare data, train, and evaluate your model on visual grounding. +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. We provide RefCOCO (split by UNC), RefCOCO+ (split by UNC) and RefCOCOg (split by UMD) datasets. See RefCOCO and Refer for more details. Note that in the original dataset, each region-coord (or bounding box) may corresponds to multiple descriptive texts. We split these texts into multiple samples so that the region-coord in each sample corresponds to only one text. Each line of the processed dataset represents a sample with the following format. The information of uniq-id, image-id, text, region-coord (separated by commas), image base64 string are separated by tabs. +

+
+79_1    237367  A woman in a white blouse holding a glass of wine.  230.79,121.75,423.66,463.06 9j/4AAQ...1pAz/9k=
+
+
+
+ 2. Finetuning +

+ Unlike the original paper, we finetune OFA with a drop-path rate of 0.2, and found that training with this hyper-parameter achieves better results. We will update the reported results of the paper later. +

+
+cd run_scripts/refcoco
+nohup sh train_refcoco.sh > train_refcoco.out &  # finetune for refcoco
+nohup sh train_refcocoplus.sh > train_refcocoplus.out &  # finetune for refcoco+
+nohup sh train_refcocog.sh > train_refcocog.out &  # finetune for refcocog
+
+
+
+ 3. Inference +

+ Run the following commands for the evaluation. +

+
+cd run_scripts/refcoco ; sh evaluate_refcoco.sh  # inference & evaluate for refcoco/refcoco+/refcocog
+
+
+ +## Visual Entailment +We provide steps for you to reproduce our results in visual entailment. See the details below. + +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. Each line of the processed dataset represents a sample with the following format. The information of uniq-id, image-id, image base64 string, hypothesis, caption (or text premise), label are separated by tabs. +

+
+252244149.jpg#1r1n  252244149   /9j/4AAQ...MD/2Q==   a man in pink and gold is chewing on a wooden toothpick.   a man in pink is chewing a toothpick on the subway.   neutral 
+
+
+
+ 2. Finetuning +

+ In our experiments, the SNLI-VE finetuning is performed on 8 NVIDIA-V100 GPUs with 32GB memory. In this task, we experimented with only a few sets of hyperparameters. We believe that proper hyperparameter tuning can lead to further accuracy improvement. +

+
+cd run_scripts/snli_ve
+nohup sh train_snli_ve.sh > train_snli_ve.out &  # finetune for snli_ve
+
+
+
+ 3. Inference +

+ Run the following command to obtain the results. +

+
+cd run_scripts/snli_ve ; sh evaluate_snli_ve.sh dev  # specify 'dev' or 'test'
+
+
+ +## GLUE +Here we provide steps for you to finetune and evaluate our model on language understanding tasks. We demonstrate our practice for the GLUE benchmark. + +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. we provide 7 language understanding datasets from GLUE benchmark, including COLA, MNLI, MRPC, QNLI, QQP, RTE and SST2. More details about these datasets can be found in this link. +

+
+
+ 2. Finetuning +

+ For each task, we have tried multiple sets of hyperparameters (including learning rate, batch size, training epochs). The results under different sets of hyperparameters can be found in ${log_dir}. +

+
+cd run_scripts/glue
+nohup sh train_cola.sh > train_cola.out &  # finetune for cola
+nohup sh train_mnli.sh > train_mnli.out &  # finetune for mnli
+nohup sh train_mrpc.sh > train_mrpc.out &  # finetune for mrpc
+nohup sh train_qnli.sh > train_qnli.out &  # finetune for qnli
+nohup sh train_qqp.sh > train_qqp.out &  # finetune for qqp
+nohup sh train_rte.sh > train_rte.out &  # finetune for rte
+nohup sh train_sst2.sh > train_sst2.out &  # finetune for sst2
+
+
+ +## Image Classification on ImageNet-1K +We provide the finetuning and inference codes which reproduce **85.0 ImageNet-1K accuracy**, slightly better than reported in our paper. + +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. Our provided data is derived from the original ImageNet-1K (ILSVRC2012 train & validation) dataset and shares the same data split with it. To formulate the classification task into seq2seq paradigm, we use the synset words provided by Caffe as the generation target for each image class. Each line of the processed dataset represents a sample with the following format. The information of image base64 string, classification label (1-indexed, conform to the order in synset_words.txt), synset words of the label are separated by tabs. +

+
+_9j_4AAQS...fzX__Z  769 rugby ball
+
+
+
+ 2. Shuffle the Training Data +

+ (Optional, but achieves better finetuning accuracy): If the disk storage is sufficient, we recommend to prepare the shuffled training data for each epoch in advance. In our experiments, we use shuffling which brings around +0.2 improvement on ImageNet-1K accuracy. +

+
+cd dataset/imagenet_1k_data
+ln imagenet_1k_train.tsv imagenet_1k_train_1.tsv
+for idx in `seq 1 9`;do shuf imagenet_1k_train_${idx}.tsv > imagenet_1k_train_$[${idx}+1].tsv;done # each file is used for an epoch one by one
+
+
+
+ 3. Finetuning +

+ In our experiments, the ImageNet-1K finetuning is performed on 2 8-A100-GPU servers (with RDMA). Here provides the finetuning script train_imagenet_distributed.sh, which supports multi-server distributed training (as well as single-server training). Please refer to the comments in the beginning of the script and set the configs correctly according to your distribution environment. If you have shuffled the training data in the previous step, please correctly specify the training data path following the guide in the script comments. The command should be run on each worker. For quick evaluation during finetuning, by default we sample 20% of the original validation split and report accuracy on this subset after each epoch. The accuracy on the validation subset is generally ±0.1 relative to accuracy on the whole validation split. +

+
+# run on each worker after the distributed and data configs have been correctly set following the guide in train_imagenet_distributed.sh
+cd run_scripts/image_classify
+bash train_imagenet_distributed.sh
+
+

+ In our experiments, the finetuning costs around 80 hours (for 32 epochs). The best accuracy on validation subset during finetuning will be around 85.0. The log is saved in ${log_dir}. +

+
+
+ 4. Inference +

+ To get the validation accuracy on the whole ImageNet-1K validation set, run the following command. The evaluation costs around 10 GPU hours. The accuracy will be reported in the stdout (expected to be around 85.0). +

+
+cd run_scripts/image_classify ; sh evaluate_imagenet.sh  # inference & evaluate for imagenet-1k
+
+
+ +## Gigaword +We provide steps for you to reproduce our results in Gigaword. See the details below. + +
+ 1. Prepare the Dataset & Checkpoints +

+ Download data (see datasets.md) and models (see checkpoints.md) and put them in the correct directory. The original dataset is taken from UniLM and we organized the data into the tsv format. Each line of the processed dataset represents a sample with the following format. The information of source and target texts are separated by tabs. +

+
+factory orders for manufactured goods rose #.# percent in september...  us september factory orders up #.# percent
+
+
+
+ 2. Finetuning +

+ Run the following command to train the model. +

+
+cd run_scripts/gigaword
+nohup sh train_gigaword.sh > train_gigaword.out &  # finetune for gigaword
+
+
+
+ 3. Inference +

+ Run the following command to obtain the results (~36.43 rougeL). +

+
+cd run_scripts/gigaword ; sh evaluate_gigaword.sh  # inference & evaluate for gigaword
+
+
+ +

+ +# Gallery +Below we provide examples of OFA in text-to-image generation and open-ended VQA. Also, we demonstrate its performance in unseen task (Grounded QA) as well as unseen domain (Visual Grounding on images from unseen domains). + +## Text-to-Image Generation + +![case1](examples/case1.png) + + +## Open-Ended VQA +![open_vqa](examples/open_vqa.png) + +## Grounded QA (unseen task) +![grounded_qa](examples/grounded_qa.png) + +## Visual Grounding (unseen domain) +![vg](examples/viusal_grounding.png) +

+ +# Related Codebase +* [Fairseq](https://github.com/pytorch/fairseq) +* [taming-transformers](https://github.com/CompVis/taming-transformers) +

+ + +# Getting Involved +Feel free to submit Github issues or pull requests. Welcome to contribute to our project! + +To contact us, never hestitate to send an email to `zheluo.wp@alibaba-inc.com` or `junyang.ljy@alibaba-inc.com`! +

+ + +# Citation +Please cite our paper if you find it helpful :) + +``` +@article{wang2022ofa, + author = {Peng Wang and + An Yang and + Rui Men and + Junyang Lin and + Shuai Bai and + Zhikang Li and + Jianxin Ma and + Chang Zhou and + Jingren Zhou and + Hongxia Yang}, + title = {OFA: Unifying Architectures, Tasks, and Modalities Through a Simple Sequence-to-Sequence + Learning Framework}, + journal = {CoRR}, + volume = {abs/2202.03052}, + year = {2022} +} +``` +

diff --git a/README_EncouragingLoss.md b/README_EncouragingLoss.md new file mode 100644 index 0000000000000000000000000000000000000000..430b45ee0720084347539901909e8222152ab99d --- /dev/null +++ b/README_EncouragingLoss.md @@ -0,0 +1,34 @@ +# Finetuning with Encouraging Loss (EL) +Below we provide methods for finetuning with label smoothed encouraging loss proposed in [_Well-classified Examples are Underestimated in Classification with Deep Neural Networks_](https://arxiv.org/pdf/2110.06537.pdf) on different downstream tasks. +The implementation is in [label_smoothed_encouraging_loss.py](criterions/label_smoothed_encouraging_loss.py). +You can set the `--criterion` to `adjust_label_smoothed_encouraging_loss` to use it. This criterion has a hyper-parameter `--log-end`. +`--log-end < 1` results in a approximated and conservative version of the full encouraging loss. +A high log_end will more strongly weaken the gradient vanishing, enhance the modeling of the data, and increase the growth rate of the margin, but it will also bring a larger gradient norm, which will bring challenges to the existing optimization system. +We recommend higher log_end for cases with higher performance, and 0.75 or 0.5 as your first try. +## Image Captioning +We provide procedures for image captioning with EL below. The preprocessing is identical to default setting. + +
+ Finetuning +

+ We propose two scripts for stage1. +

+
+cd run_scripts/caption
+nohup sh train_caption_stage1_el.sh > train_stage1_el.out &  # stage 1, train with encouraging loss, expected cider 1.403
+nohup sh train_caption_stage1_el_db.sh > train_stage1_el.out &  # stage 1, train with encouraging loss, and drop best examples, expected cider 1.404
+
+
+ +## Referring Expression Comprehension +We provide procedures for image captioning with EL below. The preprocessing is identical to default setting. +
+ Finetuning +
+cd run_scripts/refcoco
+nohup sh train_refcoco_el.sh > train_refcoco_el.out &  # finetune for refcoco
+nohup sh train_refcocoplus_el.sh > train_refcocoplus_el.out &  # finetune for refcoco+
+nohup sh train_refcocog_el.sh > train_refcocog_el.out &  # finetune for refcocog
+
+
+Evaluation is also the same as the default setting. diff --git a/VG.ipynb b/VG.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5ffe98ab2d8a9758c6b39afafb6e133182154224 --- /dev/null +++ b/VG.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e41f4047-63eb-4a2e-9d32-c4f948dc93c6", + "metadata": {}, + "source": [ + "## Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9f2a1f74-c39a-4b9f-95e4-93c6aa56819b", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e3b96baa-e717-48ac-bfd2-2bfd28ebf198", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "\n", + "# import sys \n", + "# sys.path.append('~/ofa_ours')\n", + "\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks.refcoco import RefcocoTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False\n", + "\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c3e98948-295a-4511-85c6-aecc9c54b5b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register refcoco task\n", + "tasks.register_task('refcoco', RefcocoTask)" + ] + }, + { + "cell_type": "markdown", + "id": "bd7532c0-a88b-45e5-af3f-3d7b64119bfd", + "metadata": {}, + "source": [ + "### Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb36d81f-1c5c-4a71-ac0f-7bd811da0d3e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5 acc None None\n", + "self.sample_patch_num 784\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "unival\n", + "getattr(args, \"stop_on_max_len\", False) False\n", + "getattr(args, \"stop_on_max_len\", False) False\n" + ] + } + ], + "source": [ + "# Load pretrained ckpt & config\n", + "\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_refcocog/checkpoint_best.pt'\n", + "\n", + "overrides={\"bpe_dir\":\"utils/BPE\"}\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths(checkpoint_path),\n", + " arg_overrides=overrides\n", + " )\n", + "\n", + "cfg.common.seed = 7\n", + "cfg.generation.beam = 5\n", + "cfg.generation.min_len = 4\n", + "cfg.generation.max_len_a = 0\n", + "cfg.generation.max_len_b = 4\n", + "cfg.generation.no_repeat_ngram_size = 3\n", + "\n", + "# Fix seed for stochastic decoding\n", + "if cfg.common.seed is not None and not cfg.generation.no_seed_provided:\n", + " np.random.seed(cfg.common.seed)\n", + " utils.set_torch_seed(cfg.common.seed)\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "markdown", + "id": "d7099688-d23f-46ce-aa5a-a35a745d387b", + "metadata": {}, + "source": [ + "\n", + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f1c1d8f6-ad15-4965-9cb1-a4cfb7b31393", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/ipykernel_launcher.py:8: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n", + " \n", + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/torchvision/transforms/transforms.py:330: UserWarning: Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. Please use InterpolationMode enum.\n", + " \"Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. \"\n" + ] + } + ], + "source": [ + "# Image transform\n", + "from torchvision import transforms\n", + "mean = [0.5, 0.5, 0.5]\n", + "std = [0.5, 0.5, 0.5]\n", + "\n", + "patch_resize_transform = transforms.Compose([\n", + " lambda image: image.convert(\"RGB\"),\n", + " transforms.Resize((cfg.task.patch_image_size, cfg.task.patch_image_size), interpolation=Image.BICUBIC),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=mean, std=std),\n", + "])\n", + "\n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()\n", + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text.lower()),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "# Construct input for refcoco task\n", + "patch_image_size = cfg.task.patch_image_size\n", + "def construct_sample(image: Image, text: str):\n", + " w, h = image.size\n", + " w_resize_ratio = torch.tensor(patch_image_size / w).unsqueeze(0)\n", + " h_resize_ratio = torch.tensor(patch_image_size / h).unsqueeze(0)\n", + " patch_image = patch_resize_transform(image).unsqueeze(0)\n", + " patch_mask = torch.tensor([True])\n", + " src_text = encode_text(' which region does the text \" {} \" describe?'.format(text), append_bos=True, append_eos=True).unsqueeze(0)\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " sample = {\n", + " \"id\":np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"patch_images\": patch_image,\n", + " \"patch_masks\": patch_mask,\n", + " },\n", + " \"w_resize_ratios\": w_resize_ratio,\n", + " \"h_resize_ratios\": h_resize_ratio,\n", + " \"region_coords\": torch.randn(1, 4),\n", + " \"target\": None,\n", + " }\n", + " return sample\n", + " \n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t" + ] + }, + { + "cell_type": "markdown", + "id": "742c41de-fc34-4932-9bce-782f8cbe9fca", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d6072ec3-df2b-4da4-88a8-877c5639d53f", + "metadata": {}, + "outputs": [], + "source": [ + "def inference_refcoco(task, generator, models, sample):\n", + " hyps_ = []\n", + " gen_out = task.inference_step(generator, models, sample)\n", + " for i in range(len(gen_out)):\n", + " hyps_.append(gen_out[i][0][\"tokens\"][:-1] - len(task.src_dict) + task.cfg.num_bins)\n", + " \n", + " hyps_ = torch.stack(hyps_, dim=0)\n", + " hyps = hyps_ / (task.cfg.num_bins - 1) * task.cfg.max_image_size\n", + " hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1)\n", + " hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1)\n", + " \n", + " results = [\n", + " {\"box\": [hyps[i][0].item(), hyps[i][1].item(), hyps[i][2].item(), hyps[i][3].item()]}\n", + " for i, sample_id in enumerate(sample[\"id\"].tolist())\n", + " ]\n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d26045cb-0980-4589-b93a-519453aaf799", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000257236.jpg'\n", + "# text = \"a bicycle behind the bench\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000000536.jpg'\n", + "# text = \"the girl with blonde hair\"\n", + "# text = \"two girls with talking on the phone\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000001153.jpg'\n", + "# text = \"the detached banana\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002529.jpg'\n", + "# text = \"the red vehicule\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002164.jpg'\n", + "# text = \"the snow on the mountain\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002153.jpg'\n", + "# text = \"the man standing on one leg\"\n", + "\n", + "# limitations\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000012946.jpg'\n", + "# text = \"the woman wearing blue\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000012706.jpg'\n", + "# text = \"the Tokyo Skytree\"\n", + "\n", + "\n", + "img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002434.jpg'\n", + "text = \"the family photo\"\n", + "\n", + "\n", + "image = Image.open(img_path)\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "edfc638e-7624-411f-88da-9009c777a543", + "metadata": {}, + "outputs": [], + "source": [ + "# Construct input sample & preprocess for GPU if cuda available\n", + "sample = construct_sample(image, text)\n", + "sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + "sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample\n", + "\n", + "# Run eval step for refcoco\n", + "\n", + "with torch.no_grad():\n", + " results = inference_refcoco(task, generator, models, sample)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "99c89b2c-4eb7-4a12-ac71-c72290f11497", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cv2\n", + "import numpy\n", + "# from google.colab.patches import cv2_imshow\n", + "\n", + "save_dir = '/home/mshukor/ofa_adastra'\n", + "\n", + "img = cv2.cvtColor(numpy.asarray(image), cv2.COLOR_RGB2BGR)\n", + "cv2.rectangle(\n", + " img,\n", + " (int(results[0][\"box\"][0]), int(results[0][\"box\"][1])),\n", + " (int(results[0][\"box\"][2]), int(results[0][\"box\"][3])),\n", + " (0, 255, 0),\n", + " 3\n", + ")\n", + "\n", + "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + "plt.figure(figsize=(15, 15))\n", + "plt.axis('off')\n", + "\n", + "plt.imshow(img)\n", + "\n", + "save_path = save_dir + '/results/vg/'+\"_\".join(text.split(' '))+\".jpg\"\n", + "plt.savefig(save_path, bbox_inches='tight')\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2d00b2e-87fd-41f4-a6fd-535c9785519c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a165db86-23b6-40db-a2ba-daf62db6b8df", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/VQA.ipynb b/VQA.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..12eaa40f04d0c059a0adb90b0b2008164d53f421 --- /dev/null +++ b/VQA.ipynb @@ -0,0 +1,449 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "51af39e5-c289-48a2-beeb-48da7a783b35", + "metadata": {}, + "source": [ + "### Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "60f00b1a-8270-4baf-b619-954e0fa66b53", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import re\n", + "from fairseq import utils,tasks\n", + "from fairseq import checkpoint_utils\n", + "from fairseq import distributed_utils, options, tasks, utils\n", + "from fairseq.dataclass.utils import convert_namespace_to_omegaconf\n", + "from utils.zero_shot_utils import zero_shot_step\n", + "from tasks.mm_tasks.vqa_gen import VqaGenTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3d4175e4-6371-4d33-854d-edb3cbf7baee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register VQA task\n", + "tasks.register_task('vqa_gen',VqaGenTask)" + ] + }, + { + "cell_type": "markdown", + "id": "1c08f39f-5dca-4b9e-9351-acf62760e9fc", + "metadata": {}, + "source": [ + "### Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "42ecfa8e-8a4c-4bde-b462-dc101818bc00", + "metadata": {}, + "outputs": [], + "source": [ + "# specify some options for evaluation\n", + "# checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_vqa/checkpoint_best.pt'\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_s2_hs/checkpoint1.pt'\n", + "\n", + "\n", + "video_model_path = '/data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth'\n", + "resnet_model_path = '/data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth'\n", + "\n", + "\n", + "\n", + "parser = options.get_generation_parser()\n", + "input_args = [\"\", \"--task=vqa_gen\", \"--beam=100\", \"--unnormalized\", \"--path=\"+checkpoint_path, \"--bpe-dir=utils/BPE\"]\n", + "args = options.parse_args_and_arch(parser, input_args)\n", + "cfg = convert_namespace_to_omegaconf(args)\n", + "\n", + "overrides={\"video_model_path\": video_model_path, \"resnet_model_path\": resnet_model_path}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4aff0dc6-1069-4619-890b-499a056bf2b1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.sample_patch_num 225\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "Frozen image bn \n", + "Frozen video bn \n", + "Loading: all_resnext101\n", + "use bn: \n", + "load pretrained_model /data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth\n", + "_IncompatibleKeys(missing_keys=[], unexpected_keys=['fc.weight', 'fc.bias'])\n", + "load resnet /data/mshukor/logs/ofa/best_models/resnet101-5d3b4d8f.pth\n", + "\n", + "unival\n", + "getattr(args, \"stop_on_max_len\", False) False\n" + ] + } + ], + "source": [ + "\n", + "\n", + "# Load pretrained ckpt & config\n", + "task = tasks.setup_task(cfg.task)\n", + "models, cfg = checkpoint_utils.load_model_ensemble(\n", + " utils.split_paths(cfg.common_eval.path),\n", + " task=task,\n", + " arg_overrides=overrides\n", + ")\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "markdown", + "id": "38cb01bf-0c77-4a8c-a46c-3f8d02944847", + "metadata": {}, + "source": [ + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "95e9105f-4435-46f8-8204-a80802361f6a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/ipykernel_launcher.py:8: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n", + " \n", + "/data/mshukor/envs/ofa/lib/python3.7/site-packages/torchvision/transforms/transforms.py:330: UserWarning: Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. Please use InterpolationMode enum.\n", + " \"Argument 'interpolation' of type int is deprecated since 0.13 and will be removed in 0.15. \"\n" + ] + } + ], + "source": [ + "# Image transform\n", + "from torchvision import transforms\n", + "mean = [0.5, 0.5, 0.5]\n", + "std = [0.5, 0.5, 0.5]\n", + "\n", + "patch_resize_transform = transforms.Compose([\n", + " lambda image: image.convert(\"RGB\"),\n", + " transforms.Resize((cfg.task.patch_image_size, cfg.task.patch_image_size), interpolation=Image.BICUBIC),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=mean, std=std),\n", + "])\n", + "\n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()\n", + "\n", + "# Normalize the question\n", + "def pre_question(question, max_ques_words):\n", + " question = question.lower().lstrip(\",.!?*#:;~\").replace('-', ' ').replace('/', ' ')\n", + " question = re.sub(\n", + " r\"\\s{2,}\",\n", + " ' ',\n", + " question,\n", + " )\n", + " question = question.rstrip('\\n')\n", + " question = question.strip(' ')\n", + " # truncate question\n", + " question_words = question.split(' ')\n", + " if len(question_words) > max_ques_words:\n", + " question = ' '.join(question_words[:max_ques_words])\n", + " return question\n", + "\n", + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "# Construct input for open-domain VQA task\n", + "def construct_sample(image: Image, question: str):\n", + " patch_image = patch_resize_transform(image).unsqueeze(0)\n", + " patch_mask = torch.tensor([True])\n", + "\n", + " question = pre_question(question, task.cfg.max_src_length)\n", + " question = question + '?' if not question.endswith('?') else question\n", + " src_text = encode_text(' {}'.format(question), append_bos=True, append_eos=True).unsqueeze(0)\n", + "\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " ref_dict = np.array([{'yes': 1.0}]) # just placeholder\n", + " sample = {\n", + " \"id\":np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"patch_images\": patch_image,\n", + " \"patch_masks\": patch_mask,\n", + " },\n", + " \"ref_dict\": ref_dict,\n", + " }\n", + " return sample\n", + " \n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t" + ] + }, + { + "cell_type": "markdown", + "id": "1719562e-a17e-406a-8232-fe401b5031f4", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "824359d0-eaa3-4aa1-a35f-32d011ed2225", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000004227.jpg'\n", + "# question = \"what is the colour of the man's shirt\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000004175.jpg'\n", + "# question = \"how many players are in the court?\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000003694.jpg'\n", + "# question = \"is there a basketball hoop in the image?\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002890.jpg'\n", + "# question = \"what is the woman wearing black doing?\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002621.jpg'\n", + "# question = \"what does the street sign say?\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000005540.jpg'\n", + "# question = \"is this a vegetarian plate?\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000004975.jpg'\n", + "# question = \"why the people are happy?\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000007816.jpg'\n", + "# question = \"what is the man doing?\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000006748.jpg'\n", + "# question = \"what is the animal doing?\"\n", + "\n", + "\n", + "# img_path = 'results/images//phone2.png'\n", + "# question = \"What is on the phone screen?\"\n", + "\n", + "# img_path = 'results/images//plate.png'\n", + "# question = \"What can you see out the window?\"\n", + "\n", + "\n", + "# img_path = 'results/images//driver.png'\n", + "# question = \"Whom is the person texting?\"\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000003694.jpg'\n", + "# question = \"how many people are playing basketball?\"\n", + "\n", + "\n", + "\n", + "## Limitations \n", + "# img_path = 'results/images//driver.png'\n", + "# question = \"Whom is the person texting?\"\n", + "\n", + "\n", + "# img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002890.jpg'\n", + "# question = \"Is the woman wearing green happy?\"\n", + "\n", + "# img_path = 'results/images//plate.png'\n", + "# question = \"Where people are eating?\"\n", + "\n", + "\n", + "# instruction following \n", + "\n", + "# img_path = 'results/images/monaliza.png'\n", + "# question = \"Do you know who drew this painting?\"\n", + "\n", + "# img_path = 'results/images/taxi_car.png'\n", + "# # question = \"What is unusual about this image?\"\n", + "# question = \"what does the image describe?\"\n", + "\n", + "\n", + "# img_path = 'results/images/nuggets.png'\n", + "# question = \"what does the image describe?\"\n", + "\n", + "\n", + "img_path = '/data/mshukor/data/coco/val2014/COCO_val2014_000000002890.jpg'\n", + "question = \"What does the image describe in details?\"\n", + "\n", + "\n", + "image = Image.open(img_path)\n", + "\n", + "sample = construct_sample(image, question)\n", + "sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + "sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "887adb84-15a5-4366-965b-f5226bd59985", + "metadata": {}, + "outputs": [], + "source": [ + "# Run eval step for open-domain VQA\n", + "with torch.no_grad():\n", + " result, scores = zero_shot_step(task, generator, models, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e5b01324-7880-4677-b33a-11c785c23065", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What does the image describe in details? a group of people riding skis down a snow covered street\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "save_dir = '/home/mshukor/ofa_adastra'\n", + "\n", + "text = question+\" \"+result[0]['answer']\n", + "print(text)\n", + "plt.figure(figsize=(15, 15))\n", + "plt.axis('off')\n", + "\n", + "plt.imshow(image)\n", + "\n", + "save_path = save_dir + '/results/vqa/'+\"_\".join(text.split(' '))+\".jpg\"\n", + "plt.savefig(save_path, bbox_inches='tight')\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86526b6d-a2e5-4d18-b147-3357299d6819", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1c5e4ba-50f8-422f-9392-192aeef0da0f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Video_Captioning.ipynb b/Video_Captioning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..2faefba5a48f8ba761888fddbe905f18b7aed0ab --- /dev/null +++ b/Video_Captioning.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55df6d0d-71cf-4110-81ed-7c0d3ce58e43", + "metadata": {}, + "source": [ + "## Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0abe9574-05f7-4684-b586-033827b89c32", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "74e70729-b658-4ffd-9d8b-ae42a2d1b212", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks.caption import CaptionTask\n", + "from models.unival import UnIVALModel\n", + "from PIL import Image\n", + "\n", + "import random\n", + "from torchvision.transforms import functional as F\n", + "from torchvision.transforms import InterpolationMode\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False\n", + "import os " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ce03a870-2852-410e-97c4-59461d08f60a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ".register_task_cls(cls)>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Register refcoco task\n", + "tasks.register_task('video_caption', CaptionTask)" + ] + }, + { + "cell_type": "markdown", + "id": "58361680-3e90-4fff-962e-2ff67c1e7289", + "metadata": {}, + "source": [ + "### Load model" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "adb79611-7563-4fb6-a576-f31050f8438e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "self.sample_patch_num 784\n", + "self.sample_audio_patch_num None\n", + "self.sample_video_patch_num None\n", + "self.with_cls False\n", + "Loading: all_resnext101\n", + "use bn: \n", + "load pretrained_model /data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth\n", + "_IncompatibleKeys(missing_keys=[], unexpected_keys=['fc.weight', 'fc.bias'])\n", + "unival\n", + "getattr(args, \"stop_on_max_len\", False) False\n" + ] + } + ], + "source": [ + "# Load pretrained ckpt & config\n", + "\n", + "checkpoint_path = '/data/mshukor/logs/ofa/best_models/unival_video_caption_stage_1/checkpoint_best.pt'\n", + "video_model_path = '/data/mshukor/logs/ofa/best_models/resnext-101-kinetics.pth'\n", + "\n", + "overrides={\"eval_cider\":False, \"beam\":5, \"max_len_b\":22, \"no_repeat_ngram_size\":3, \"seed\":7, \"unnormalized\": False,\n", + " \"bpe_dir\":\"utils/BPE\", \"video_model_path\": video_model_path,}\n", + "\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths(checkpoint_path),\n", + " arg_overrides=overrides\n", + " )\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "markdown", + "id": "e79aad39-1424-47d5-8cd4-6ab77ea46fb4", + "metadata": {}, + "source": [ + "### Preprocess" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "576a3e84-a6aa-446d-adab-fef9499318fc", + "metadata": {}, + "outputs": [], + "source": [ + "# Image transform\n", + "from torchvision import transforms\n", + "mean = [0.5, 0.5, 0.5]\n", + "std = [0.5, 0.5, 0.5]\n", + "\n", + "\n", + "\n", + "type_transform = transforms.Lambda(lambda x: x.float().div(255.0))\n", + "patch_video_resize_transform = transforms.Compose([\n", + " transforms.CenterCrop(cfg.task.patch_frame_size),\n", + " type_transform, \n", + " transforms.Normalize(mean=mean, std=std),\n", + " ])\n", + "\n", + "# video process\n", + "from data.video_utils import VIDEO_READER_FUNCS\n", + "\n", + "video_reader = VIDEO_READER_FUNCS['decord'] \n", + "\n", + "def process_video(video_path, max_num_frames=16, num_frames=16, sample_type='rand',):\n", + " \n", + " # video \n", + " data_path = os.path.join(video_path)\n", + "\n", + " frames, frame_indices, video_duration = video_reader(\n", + " data_path, num_frames, sample_type, max_num_frames=max_num_frames\n", + " )\n", + "\n", + " patch_video = patch_video_resize_transform(frames)\n", + " patch_video = patch_video.permute(1, 0, 2, 3) # -> (C, T, h, w)\n", + "\n", + " return patch_video.unsqueeze(0)\n", + " \n", + "\n", + "# Text preprocess\n", + "bos_item = torch.LongTensor([task.src_dict.bos()])\n", + "eos_item = torch.LongTensor([task.src_dict.eos()])\n", + "pad_idx = task.src_dict.pad()\n", + "def encode_text(text, length=None, append_bos=False, append_eos=False):\n", + " s = task.tgt_dict.encode_line(\n", + " line=task.bpe.encode(text),\n", + " add_if_not_exist=False,\n", + " append_eos=False\n", + " ).long()\n", + " if length is not None:\n", + " s = s[:length]\n", + " if append_bos:\n", + " s = torch.cat([bos_item, s])\n", + " if append_eos:\n", + " s = torch.cat([s, eos_item])\n", + " return s\n", + "\n", + "# Construct input for caption task\n", + "def construct_sample(video_path):\n", + " \n", + " patch_video = process_video(video_path, max_num_frames=16, num_frames=cfg.task.num_frames, sample_type=cfg.task.sample_type,)\n", + " patch_image = torch.zeros((3, cfg.task.patch_image_size, cfg.task.patch_image_size)) \n", + " \n", + " patch_type = torch.tensor([1])\n", + " patch_mask = torch.tensor([True])\n", + " src_text = encode_text(\" what does the video describe?\", append_bos=True, append_eos=True).unsqueeze(0)\n", + " src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text])\n", + " sample = {\n", + " \"id\":np.array(['42']),\n", + " \"net_input\": {\n", + " \"src_tokens\": src_text,\n", + " \"src_lengths\": src_length,\n", + " \"patch_videos\": patch_video,\n", + " \"patch_images\": patch_image,\n", + " \"patch_masks\": patch_mask,\n", + " \"patch_types\": patch_type,\n", + " }\n", + " }\n", + " return sample\n", + " \n", + "# Function to turn FP32 to FP16\n", + "def apply_half(t):\n", + " if t.dtype is torch.float32:\n", + " return t.to(dtype=torch.half)\n", + " return t" + ] + }, + { + "cell_type": "markdown", + "id": "f96f776e-9aa0-4271-b881-311851cc033c", + "metadata": {}, + "source": [ + "### Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "6f8ddf8c-82e2-411c-baa3-850da02f1996", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 3, 16, 384, 384])\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "save_dir = '/home/mshukor/ofa_adastra'\n", + "\n", + "\n", + "\n", + "\n", + "video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7019.mp4' # a man is sitting in a chair and talking\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7038.mp4' # a person is cooking something in a pan\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7021.mp4' # a group of people are playing baseball\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7068.mp4' # a man and a woman are talking to each other\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7017.mp4' # a person is playing a video game\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7014.mp4' # a girl is singing on the voice\n", + "\n", + "\n", + "\n", + "# video_path = '/data/mshukor/data/video/msrvtt/examples/video1065.mp4'\n", + "\n", + "# limitations\n", + "video_path = '/data/mshukor/data/video/msrvtt/examples/test/video7055.mp4' # a man is driving a car\n", + "\n", + "\n", + "sample = construct_sample(video_path)\n", + "sample = utils.move_to_cuda(sample) if use_cuda else sample\n", + "sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3690f53b-3594-4d8f-81c8-c8ed0931c00b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "4651039c-b8c0-4687-871e-b42cb13b2984", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([1], device='cuda:0')\n", + "torch.Size([1, 2048, 1, 12, 12])\n" + ] + } + ], + "source": [ + "from utils.eval_utils import eval_caption\n", + "\n", + "with torch.no_grad():\n", + " result, scores = eval_caption(task, generator, models, sample)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "712150d4-f28c-4538-870f-b33f775725d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a man is driving a car\n" + ] + } + ], + "source": [ + "caption = result[0]['caption']\n", + "print(caption)\n", + "\n", + "from IPython.display import Video\n", + "Video(video_path, embed=True)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "303d531f-dba3-40b9-a1ff-1be92d8c188a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2db0cc0-5cd2-48dd-b900-56331d53b1df", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/__pycache__/trainer.cpython-37.pyc b/__pycache__/trainer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d45408c7d97a4a9b9412b31fe83d5e2247d6516d Binary files /dev/null and b/__pycache__/trainer.cpython-37.pyc differ diff --git a/__pycache__/trainer.cpython-38.pyc b/__pycache__/trainer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e5e412ca3de6fc55b83791850ff5b56c902775d Binary files /dev/null and b/__pycache__/trainer.cpython-38.pyc differ diff --git a/__pycache__/trainer.cpython-39.pyc b/__pycache__/trainer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d036bb3ccd694958b0692301b503ef3e3448362 Binary files /dev/null and b/__pycache__/trainer.cpython-39.pyc differ diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..e5c8b3737584fc5d200078924aaa29dc76343148 --- /dev/null +++ b/app.py @@ -0,0 +1,297 @@ +import os + +os.system('cd fairseq;' + 'pip install ./; cd ..') +os.system('ls -l') + +import torch +import numpy as np +import gradio as gr +import cv2 +from PIL import Image +from torchvision import transforms + +from fairseq import utils, tasks, options +from fairseq import checkpoint_utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf + +from tasks.mm_tasks.caption import CaptionTask +from tasks.mm_tasks.refcoco import RefcocoTask +from tasks.mm_tasks.vqa_gen import VqaGenTask + + +def move2gpu(models, cfg): + for model in models: + model.eval() + if use_fp16: + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + + +def construct_transform(patch_image_size): + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((patch_image_size, patch_image_size), interpolation=Image.BICUBIC), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ]) + + return patch_resize_transform + + +# Register tasks +tasks.register_task('caption', CaptionTask) +tasks.register_task('refcoco', RefcocoTask) +tasks.register_task('vqa_gen', VqaGenTask) +# turn on cuda if GPU is available +use_cuda = torch.cuda.is_available() +# use fp16 only when GPU is available +use_fp16 = False + +# # download checkpoints +# os.system('wget https://ofa-silicon.oss-us-west-1.aliyuncs.com/checkpoints/caption_demo.pt; ' +# 'mkdir -p checkpoints; mv caption_demo.pt checkpoints/caption_demo.pt') +# os.system('wget https://ofa-silicon.oss-us-west-1.aliyuncs.com/checkpoints/refcoco_demo.pt; ' +# 'mkdir -p checkpoints; mv refcoco_demo.pt checkpoints/refcoco_demo.pt') +# os.system('wget https://ofa-silicon.oss-us-west-1.aliyuncs.com/checkpoints/general_demo.pt; ' +# 'mkdir -p checkpoints; mv general_demo.pt checkpoints/general_demo.pt') + + +checkpoint_path = 'checkpoints/unival_s2_hs/checkpoint1.pt' + +# Load ckpt & config for Image Captioning +caption_overrides={"eval_cider":False, "beam":5, "max_len_b":22, "no_repeat_ngram_size":3, "seed":7, "unnormalized": False, + "bpe_dir":"utils/BPE", "video_model_path": None,} + +caption_models, caption_cfg, caption_task = checkpoint_utils.load_model_ensemble_and_task( + utils.split_paths(checkpoint_path), + arg_overrides=caption_overrides +) + +# Load ckpt & config for Refcoco +refcoco_overrides = {"bpe_dir":"utils/BPE", "video_model_path": None} + +refcoco_models, refcoco_cfg, refcoco_task = checkpoint_utils.load_model_ensemble_and_task( + utils.split_paths(checkpoint_path), + arg_overrides=refcoco_overrides +) +refcoco_cfg.common.seed = 7 +refcoco_cfg.generation.beam = 5 +refcoco_cfg.generation.min_len = 4 +refcoco_cfg.generation.max_len_a = 0 +refcoco_cfg.generation.max_len_b = 4 +refcoco_cfg.generation.no_repeat_ngram_size = 3 + +# Load pretrained ckpt & config for VQA +parser = options.get_generation_parser() +input_args = ["", "--task=vqa_gen", "--beam=100", "--unnormalized", f"--path={checkpoint_path}", "--bpe-dir=utils/BPE"] +args = options.parse_args_and_arch(parser, input_args) +vqa_cfg = convert_namespace_to_omegaconf(args) +vqa_task = tasks.setup_task(vqa_cfg.task) +vqa_models, vqa_cfg = checkpoint_utils.load_model_ensemble( + utils.split_paths(vqa_cfg.common_eval.path), + task=vqa_task +) + +# Load pretrained ckpt & config for Generic Interface +parser = options.get_generation_parser() +input_args = ["", "--task=refcoco", "--beam=10", f"--path={checkpoint_path}", "--bpe-dir=utils/BPE", "--no-repeat-ngram-size=3", "--patch-image-size=384"] +args = options.parse_args_and_arch(parser, input_args) +general_cfg = convert_namespace_to_omegaconf(args) +general_task = tasks.setup_task(general_cfg.task) +general_models, general_cfg = checkpoint_utils.load_model_ensemble( + utils.split_paths(general_cfg.common_eval.path), + task=general_task +) + +# move models to gpu +move2gpu(caption_models, caption_cfg) +move2gpu(refcoco_models, refcoco_cfg) +move2gpu(vqa_models, vqa_cfg) +move2gpu(general_models, general_cfg) + +# Initialize generator +caption_generator = caption_task.build_generator(caption_models, caption_cfg.generation) +refcoco_generator = refcoco_task.build_generator(refcoco_models, refcoco_cfg.generation) +vqa_generator = vqa_task.build_generator(vqa_models, vqa_cfg.generation) +vqa_generator.zero_shot = True +vqa_generator.constraint_trie = None +general_generator = general_task.build_generator(general_models, general_cfg.generation) + +# Construct image transforms +caption_transform = construct_transform(caption_cfg.task.patch_image_size) +refcoco_transform = construct_transform(refcoco_cfg.task.patch_image_size) +vqa_transform = construct_transform(vqa_cfg.task.patch_image_size) +general_transform = construct_transform(general_cfg.task.patch_image_size) + +# Text preprocess +bos_item = torch.LongTensor([caption_task.src_dict.bos()]) +eos_item = torch.LongTensor([caption_task.src_dict.eos()]) +pad_idx = caption_task.src_dict.pad() + + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.bos, generator.eos} + + +def decode_fn(x, tgt_dict, bpe, generator, tokenizer=None): + x = tgt_dict.string(x.int().cpu(), extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator)) + token_result = [] + bin_result = [] + img_result = [] + for token in x.strip().split(): + if token.startswith(' Pre-trained checkpoint (OFA-Huge) (~930M parameters) +* Pre-trained checkpoint (OFA-Large) (~470M parameters) +* Pre-trained checkpoint (OFA-Base) (~180M parameters) +* Pre-trained checkpoint (OFA-Medium) (~93M parameters) +* Pre-trained checkpoint (OFA-Tiny) (~33M parameters) + +## Finetuning (OFA-Huge) +* Finetuned checkpoint for Caption on COCO + +## Finetuning (OFA-Large) + +* Finetuned checkpoint for Caption on COCO +* Finetuned checkpoint for Caption on COCO During Stage1 Finetuning +* Finetuned checkpoint for RefCOCO +* Finetuned checkpoint for RefCOCO+ +* Finetuned checkpoint for RefCOCOg +* Finetuned checkpoint for VQAv2 +* Finetuned checkpoint for SNLI-VE +* Finetuned checkpoint for Text-to-Image Generation on COCO && CLIP checkpoint && VQGAN checkpoint +* Finetuned checkpoint for ImageNet-1K +* Finetuned checkpoint for Gigaword + + +## Finetuning (OFA-Base) +* Finetuned base checkpoint for Caption on COCO +* Finetuned base checkpoint for RefCOCO +* Finetuned base checkpoint for RefCOCO+ +* Finetuned base checkpoint for RefCOCOg +* Finetuned base checkpoint for VQAv2 +* Finetuned base checkpoint for SNLI-VE +* Finetuned base checkpoint for Text-to-Image Generation on COCO diff --git a/checkpoints/unival_s2_hs/checkpoint1.pt b/checkpoints/unival_s2_hs/checkpoint1.pt new file mode 100644 index 0000000000000000000000000000000000000000..8ab9c28a7789d4e2544ef9fe935885c2cd7eb031 --- /dev/null +++ b/checkpoints/unival_s2_hs/checkpoint1.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b062bb0fa7c45266ee36326391e355724cccaee3119a9d3ee55d93488838a33 +size 2570641445 diff --git a/checkpoints_cn.md b/checkpoints_cn.md new file mode 100644 index 0000000000000000000000000000000000000000..c77173e4f10cdd5ed8d55f7b67c1a32c1f39c9fb --- /dev/null +++ b/checkpoints_cn.md @@ -0,0 +1,82 @@ +# Checkpoints (OFA-CN) + +We provide checkpoints of OFA-CN, which is the Chinese version of OFA. We provide Base-size and Large-size models, including pretrained and finetuned models on image captioning and referring expression comprehension. Note that we translated the texts in the RefCOCO(-/+/g) datasets and finetuned OFA-CN on them. We plan to release the related new datasets in the near future. +
+ +## Checkpoints +Below we provide the links for downloading the Chinese OFA checkpoints. + +### Pretraining +* Pretrained checkpoint (OFA-CN-Large) (~443M parameters) +* Pretrained checkpoint (OFA-CN-Base) (~160M parameters) + +### Finetuning (OFA-Large) +* Finetuned checkpoint for MUGE Caption (Stage 1) +* Finetuned checkpoint for RefCOCO-CN +* Finetuned checkpoint for RefCOCO+-CN +* Finetuned checkpoint for RefCOCOg-CN + +### Finetuning (OFA-Base) +* Finetuned checkpoint for MUGE Caption (Stage 1) +* Finetuned checkpoint for RefCOCO-CN +* Finetuned checkpoint for RefCOCO+-CN +* Finetuned checkpoint for RefCOCOg-CN +
+ +## Model Card +Below we provide the basic information of the base-size and large-size OFA-CN. + + + + + + + + + + + + +
Model#ParamsBackboneHidden SizeIntermediate Size#Heads#Enc. Layers#Dec. Layers
OFABase160MResNet10176830721266
OFALarge443MResNet15210244096161212
+
+ +## Results +Below we provide the results of OFA-CN and the baselines for comparison. + +### [MUGE Caption]("https://tianchi.aliyun.com/muge") + + + + + + + + + + + + + + + + +
ModelBLEU@4ROUGE-LCIDEr-D
Trm 7.3351.5111.00
M616.1955.0630.75
OFABase26.2358.9550.70
OFALarge27.3259.2053.51
+ +### RefCOCO-CN Series + + + + + + + + + + + + + +
ModelRefCOCO(val/testA/testB)RefCOCO+(val/testA/testB)RefCOCOg(val/test-u)
OFABase(random-init)30.13/35.07/25.0317.89/20.90/15.8320.30/20.45
OFABase82.18/86.07/76.6869.38/77.26/60.1473.57/72.53
OFALarge82.84/86.54/76.5071.30/78.56/61.8571.96/71.30
+
+ + diff --git a/colab.md b/colab.md new file mode 100644 index 0000000000000000000000000000000000000000..9529d9f7542a4da12e3b638fd3833d7d9ed16d93 --- /dev/null +++ b/colab.md @@ -0,0 +1,9 @@ +# Colab Notebooks + +We provide Colab notebooks of different downstream tasks for you guys to enjoy OFA. See below. + +* [Image Captioning in Huggingface Transformers](https://colab.research.google.com/drive/1Ho81RBV8jysZ7e0FhsSCk_v938QeDuy3?usp=sharing) +* [Generic Interface](https://colab.research.google.com/drive/1jogyZ-2rdHU3XxZOf3TBfhex1XHqX-1m?usp=sharing#scrollTo=s9Vni6YUZOpC) (using different instructions to perform various tasks with just one model.) +* [Image Captioning](https://colab.research.google.com/drive/1Q4eNhhhLcgOP4hHqwZwU1ijOlabgve1W?usp=sharing) +* [Referring Expression Comprehension](https://colab.research.google.com/drive/1AHQNRdaUpRTgr3XySHSlba8aXwBAjwPB?usp=sharing) +* [Open-Domain Visual Question Answering](https://colab.research.google.com/drive/14v6OQe_MxV_HMnsiKfnEeMR1UMqhzZNb?usp=sharing) diff --git a/criterions/__init__.py b/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..433122bf77581a752ec8c0069d402d0ecc72d7de --- /dev/null +++ b/criterions/__init__.py @@ -0,0 +1,5 @@ +from .label_smoothed_cross_entropy import AdjustLabelSmoothedCrossEntropyCriterion +from .clip_scst_loss import ClipScstRewardCriterion +from .label_smoothed_encouraging_loss import AdjustLabelSmoothedEncouragingLossCriterion +from .label_smoothed_cross_entropy_scst import AdjustLabelSmoothedCrossEntropySCSTCriterion +from .refcoco_scst_loss import RefCOCOScstRewardCriterion \ No newline at end of file diff --git a/criterions/__pycache__/__init__.cpython-37.pyc b/criterions/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d56e6da6ddfe75c381f1ed07c962b6bf659a7626 Binary files /dev/null and b/criterions/__pycache__/__init__.cpython-37.pyc differ diff --git a/criterions/__pycache__/__init__.cpython-38.pyc b/criterions/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab3872c940ae4f363259aebbee3668e0465b164b Binary files /dev/null and b/criterions/__pycache__/__init__.cpython-38.pyc differ diff --git a/criterions/__pycache__/__init__.cpython-39.pyc b/criterions/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..056acfcce62a8de4328bedb5d90c4f536e91fd8f Binary files /dev/null and b/criterions/__pycache__/__init__.cpython-39.pyc differ diff --git a/criterions/__pycache__/clip_scst_loss.cpython-37.pyc b/criterions/__pycache__/clip_scst_loss.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5e4c8f86d87fc2d344d001ec7323e380e908896 Binary files /dev/null and b/criterions/__pycache__/clip_scst_loss.cpython-37.pyc differ diff --git a/criterions/__pycache__/clip_scst_loss.cpython-38.pyc b/criterions/__pycache__/clip_scst_loss.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c375c17948a21d5e30b04cb22058ba3fd3f98a73 Binary files /dev/null and b/criterions/__pycache__/clip_scst_loss.cpython-38.pyc differ diff --git a/criterions/__pycache__/clip_scst_loss.cpython-39.pyc b/criterions/__pycache__/clip_scst_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e8d9b81cbcdf315b35d4572cf2088404f0a513e Binary files /dev/null and b/criterions/__pycache__/clip_scst_loss.cpython-39.pyc differ diff --git a/criterions/__pycache__/label_smoothed_cross_entropy.cpython-37.pyc b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d83f3373456a46a5178a6841d602a9f0722ee5ff Binary files /dev/null and b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-37.pyc differ diff --git a/criterions/__pycache__/label_smoothed_cross_entropy.cpython-38.pyc b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ed2fc31e8e8a18100d7215b32fd71dccc66cb0d Binary files /dev/null and b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-38.pyc differ diff --git a/criterions/__pycache__/label_smoothed_cross_entropy.cpython-39.pyc b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1bdb45cef4b8580d1c538f697b828072bd80b37 Binary files /dev/null and b/criterions/__pycache__/label_smoothed_cross_entropy.cpython-39.pyc differ diff --git a/criterions/__pycache__/label_smoothed_cross_entropy_scst.cpython-39.pyc b/criterions/__pycache__/label_smoothed_cross_entropy_scst.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cba30ead44f37b8e2617ec3d9215df3b7fdfb71c Binary files /dev/null and b/criterions/__pycache__/label_smoothed_cross_entropy_scst.cpython-39.pyc differ diff --git a/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-37.pyc b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e959325cc45f1f8e998db6de35c2eea3d32b64e5 Binary files /dev/null and b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-37.pyc differ diff --git a/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-38.pyc b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1fcb4bf4551126fabc509897993b4b0882e67e5 Binary files /dev/null and b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-38.pyc differ diff --git a/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-39.pyc b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ea2295960179cb1f8d54352c69315e2f0bc354f Binary files /dev/null and b/criterions/__pycache__/label_smoothed_encouraging_loss.cpython-39.pyc differ diff --git a/criterions/__pycache__/refcoco_scst_loss.cpython-39.pyc b/criterions/__pycache__/refcoco_scst_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5521a9ebea9523ed53754c0248eddf30dd2bea48 Binary files /dev/null and b/criterions/__pycache__/refcoco_scst_loss.cpython-39.pyc differ diff --git a/criterions/__pycache__/scst_loss.cpython-37.pyc b/criterions/__pycache__/scst_loss.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d0329cb28ae598fc7fff04ec5c8d277067aa395 Binary files /dev/null and b/criterions/__pycache__/scst_loss.cpython-37.pyc differ diff --git a/criterions/__pycache__/scst_loss.cpython-38.pyc b/criterions/__pycache__/scst_loss.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a3f7e26dc012295a6db8ca087b117bcb53752a6 Binary files /dev/null and b/criterions/__pycache__/scst_loss.cpython-38.pyc differ diff --git a/criterions/__pycache__/scst_loss.cpython-39.pyc b/criterions/__pycache__/scst_loss.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1e1d3bc1495447a6831a880872595a52c40316e Binary files /dev/null and b/criterions/__pycache__/scst_loss.cpython-39.pyc differ diff --git a/criterions/clip_scst_loss.py b/criterions/clip_scst_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..5e2c5bbd804e55cb7f4e51ba1a6a1c0e5392c1a7 --- /dev/null +++ b/criterions/clip_scst_loss.py @@ -0,0 +1,277 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from dataclasses import dataclass, field +from typing import Optional +from PIL import Image +from torchvision import transforms + +import torch +import numpy as np +from fairseq import metrics +from fairseq.data import data_utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq import utils +from omegaconf import II + +from models import clip + + +def custom_to_pil(x): + x = x.detach().cpu() + x = torch.clamp(x, -1., 1.) + x = (x + 1.) / 2. + x = x.permute(1, 2, 0).numpy() + x = (255 * x).astype(np.uint8) + x = Image.fromarray(x) + if not x.mode == "RGB": + x = x.convert("RGB") + return x + + +def scst_loss(lprobs, target, reward, ignore_index=None, reduce=True): + loss = -lprobs.gather(dim=-1, index=target.unsqueeze(-1)).squeeze() * reward.unsqueeze(-1) + if ignore_index is not None: + pad_mask = target.eq(ignore_index) + loss.masked_fill_(pad_mask, 0.0) + ntokens = (~pad_mask).sum() + else: + loss = loss.squeeze(-1) + ntokens = target.numel() + if reduce: + loss = loss.sum() + return loss, ntokens + + +@dataclass +class ClipScstRewardCriterionConfig(FairseqDataclass): + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + + +@register_criterion( + "clip_scst_reward_criterion", dataclass=ClipScstRewardCriterionConfig +) +class ClipScstRewardCriterion(FairseqCriterion): + CLIP_REWARD_WEIGHT = 2.5 + + def __init__( + self, + task, + sentence_avg, + ignore_prefix_size=0, + constraint_range=None + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.ignore_prefix_size = ignore_prefix_size + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + + def forward(self, model, sample, update_num=0, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + loss, score, ntokens, nsentences = self.compute_loss(model, sample, reduce=reduce) + + sample_size = ( + nsentences if self.sentence_avg else ntokens + ) + logging_output = { + "loss": loss.data, + "score": score, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + def _calculate_clip_scores(self, gen_res, gt_text, device): + ''' + gen_res: generated images, list of Image + gt_text: input captions. + device: device for clip model + ''' + batch_size = len(gt_text) + gen_res_size = len(gen_res) + img_per_seq = gen_res_size // batch_size + + hyp_images = torch.stack( + [self.task.clip_preprocess(gen_image) for gen_image in gen_res], dim=0 + ).to(device) + + clip_input = clip.tokenize([text for text in gt_text]).to(device) + with torch.no_grad(): + image_features = self.task.clip_model.encode_image(hyp_images) + text_features = self.task.clip_model.encode_text(clip_input) + image_features /= image_features.norm(dim=-1, keepdim=True) + text_features /= text_features.norm(dim=-1, keepdim=True) + image_features = image_features.view(batch_size, img_per_seq, -1) + text_features = text_features.view(batch_size, 1, -1) + ti_similarity = image_features @ text_features.transpose(1, 2) + ti_similarity = ti_similarity.view(-1) + + scores = self.CLIP_REWARD_WEIGHT * ti_similarity + return scores + + def get_generator_out(self, model, sample): + model.eval() + with torch.no_grad(): + self.task.scst_generator.model.eval() + gen_out = self.task.scst_generator.generate([model], sample) + + gen_target = [] + gen_res = [] + gt_text = [] + for i in range(len(gen_out)): + with torch.no_grad(): + tokens = torch.stack([item['tokens'][:-1] for item in gen_out[i]], dim=0) + tokens += -len(self.task.src_dict) + self.task.cfg.code_dict_size + self.task.cfg.num_bins + images = self.task.image_tokenizer.decode_code( + tokens.view(-1, self.task.cfg.code_image_size // 8, self.task.cfg.code_image_size // 8) + ) + images = [custom_to_pil(image) for image in images] + + gen_target += [item['tokens'] for item in gen_out[i]] + gen_res += images + gt_text.append( + self.task.bpe.decode( + self.task.tgt_dict.string( + utils.strip_pad(sample['net_input']['src_tokens'][i], self.padding_idx).cpu().int() + ) + )[38:] # remove task instruction. + ) + + return gen_target, gen_res, gt_text + + def get_reward_and_scores(self, gen_res, gt_text, device): + batch_size = len(gt_text) + gen_res_size = len(gen_res) + img_per_sample = gen_res_size // batch_size + + scores = self._calculate_clip_scores(gen_res, gt_text, device) + sc_ = scores.reshape(batch_size, img_per_sample) + baseline = (sc_.sum(1, keepdim=True) - sc_) / (sc_.shape[1] - 1) + # sample - baseline + reward = scores.reshape(batch_size, img_per_sample) + reward = reward - baseline + reward = reward.view(-1) + + return reward, scores + + def get_net_output(self, model, sample, gen_target): + def merge(sample_list, eos=self.task.tgt_dict.eos(), move_eos_to_beginning=False): + return data_utils.collate_tokens( + sample_list, + pad_idx=self.padding_idx, + eos_idx=eos, + left_pad=False, + move_eos_to_beginning=move_eos_to_beginning, + ) + + batch_size = len(sample["target"]) + gen_target_size = len(gen_target) + img_per_sample = gen_target_size // batch_size + + model.train() + sample_src_tokens = torch.repeat_interleave( + sample['net_input']['src_tokens'], img_per_sample, dim=0 + ) + sample_src_lengths = torch.repeat_interleave( + sample['net_input']['src_lengths'], img_per_sample, dim=0 + ) + sample_code_masks = torch.repeat_interleave( + sample['net_input']['code_masks'], img_per_sample, dim=0 + ) + gen_prev_output_tokens = torch.as_tensor( + merge(gen_target, eos=self.task.tgt_dict.bos(), move_eos_to_beginning=True), + device=sample["target"].device, dtype=torch.int64 + ) + gen_target_tokens = torch.as_tensor( + merge(gen_target), device=sample["target"].device, dtype=torch.int64 + ) + net_output = model( + src_tokens=sample_src_tokens, src_lengths=sample_src_lengths, + code_masks=sample_code_masks, prev_output_tokens=gen_prev_output_tokens + ) + + return net_output, gen_target_tokens + + def get_lprobs_and_target(self, model, net_output, gen_target): + if self.constraint_start is not None and self.constraint_end is not None: + net_output[0][:, :, 4:self.constraint_start] = -math.inf + net_output[0][:, :, self.constraint_end:] = -math.inf + lprobs = model.get_normalized_probs(net_output, log_probs=True) + if self.ignore_prefix_size > 0: + if getattr(lprobs, "batch_first", False): + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + gen_target = gen_target[:, self.ignore_prefix_size :].contiguous() + else: + lprobs = lprobs[self.ignore_prefix_size :, :, :].contiguous() + gen_target = gen_target[self.ignore_prefix_size :, :].contiguous() + return lprobs, gen_target + + def compute_loss(self, model, sample, reduce=True): + gen_target, gen_res, gt_text = self.get_generator_out(model, sample) + reward, scores = self.get_reward_and_scores(gen_res, gt_text, device=sample["target"].device) + net_output, gen_target_tokens = self.get_net_output(model, sample, gen_target) + gen_lprobs, gen_target_tokens = self.get_lprobs_and_target(model, net_output, gen_target_tokens) + loss, ntokens = scst_loss(gen_lprobs, gen_target_tokens, reward, ignore_index=self.padding_idx, reduce=reduce) + nsentences = gen_target_tokens.size(0) + + return loss, scores.sum(), ntokens, nsentences + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + score_sum = sum(log.get("score", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size, sample_size, round=3 + ) + metrics.log_scalar( + "score", score_sum / nsentences, nsentences, round=3 + ) + + metrics.log_scalar( + "ntokens", ntokens, 1, round=3 + ) + metrics.log_scalar( + "nsentences", nsentences, 1, round=3 + ) + metrics.log_scalar( + "sample_size", sample_size, 1, round=3 + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/criterions/label_smoothed_cross_entropy.py b/criterions/label_smoothed_cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..d88e91e402b05b316e0677cc9f7bca6260def794 --- /dev/null +++ b/criterions/label_smoothed_cross_entropy.py @@ -0,0 +1,346 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from dataclasses import dataclass, field +from typing import Optional + +import torch +import torch.nn.functional as F +import numpy as np +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +@dataclass +class AdjustLabelSmoothedCrossEntropyCriterionConfig(FairseqDataclass): + label_smoothing: float = field( + default=0.0, + metadata={"help": "epsilon for label smoothing, 0 means no label smoothing"}, + ) + report_accuracy: bool = field( + default=False, + metadata={"help": "report accuracy metric"}, + ) + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + ignore_eos: bool = field( + default=False, + metadata={"help": "Ignore eos token"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + drop_worst_ratio: float = field( + default=0.0, + metadata={"help": "ratio for discarding bad samples"}, + ) + drop_worst_after: int = field( + default=0, + metadata={"help": "steps for discarding bad samples"}, + ) + use_rdrop: bool = field( + default=False, metadata={"help": "use R-Drop"} + ) + reg_alpha: float = field( + default=1.0, metadata={"help": "weight for R-Drop"} + ) + sample_patch_num: int = field( + default=196, metadata={"help": "sample patches for v1"} + ) + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + + +def construct_rdrop_sample(x): + if isinstance(x, dict): + for key in x: + x[key] = construct_rdrop_sample(x[key]) + return x + elif isinstance(x, torch.Tensor): + return x.repeat(2, *([1] * (x.dim()-1))) + elif isinstance(x, int): + return x * 2 + elif isinstance(x, np.ndarray): + return x.repeat(2) + else: + raise NotImplementedError + + +def kl_loss(p, q): + p_loss = F.kl_div(p, torch.exp(q), reduction='sum') + q_loss = F.kl_div(q, torch.exp(p), reduction='sum') + loss = (p_loss + q_loss) / 2 + return loss + + +def label_smoothed_nll_loss( + lprobs, target, epsilon, update_num, reduce=True, + drop_worst_ratio=0.0, drop_worst_after=0, use_rdrop=False, reg_alpha=1.0, + constraint_masks=None, constraint_start=None, constraint_end=None +): + if target.dim() == lprobs.dim() - 1: + target = target.unsqueeze(-1) + nll_loss = -lprobs.gather(dim=-1, index=target).squeeze(-1) + if constraint_masks is not None: + smooth_loss = -lprobs.masked_fill(~constraint_masks, 0).sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (constraint_masks.sum(1) - 1 + 1e-6) + elif constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + smooth_loss = -lprobs[:, constraint_range].sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (len(constraint_range) - 1 + 1e-6) + else: + smooth_loss = -lprobs.sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (lprobs.size(-1) - 1) + loss = (1.0 - epsilon - eps_i) * nll_loss + eps_i * smooth_loss + if drop_worst_ratio > 0 and update_num > drop_worst_after: + if use_rdrop: + true_batch_size = loss.size(0) // 2 + _, indices = torch.topk(loss[:true_batch_size], k=int(true_batch_size * (1 - drop_worst_ratio)), largest=False) + loss = torch.cat([loss[indices], loss[indices+true_batch_size]]) + nll_loss = torch.cat([nll_loss[indices], nll_loss[indices+true_batch_size]]) + lprobs = torch.cat([lprobs[indices], lprobs[indices+true_batch_size]]) + else: + loss, indices = torch.topk(loss, k=int(loss.shape[0] * (1 - drop_worst_ratio)), largest=False) + nll_loss = nll_loss[indices] + lprobs = lprobs[indices] + + ntokens = loss.numel() + nll_loss = nll_loss.sum() + loss = loss.sum() + if use_rdrop: + true_batch_size = lprobs.size(0) // 2 + p = lprobs[:true_batch_size] + q = lprobs[true_batch_size:] + if constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + p = p[:, constraint_range] + q = q[:, constraint_range] + loss += kl_loss(p, q) * reg_alpha + + return loss, nll_loss, ntokens + + +@register_criterion( + "adjust_label_smoothed_cross_entropy", dataclass=AdjustLabelSmoothedCrossEntropyCriterionConfig +) +class AdjustLabelSmoothedCrossEntropyCriterion(FairseqCriterion): + def __init__( + self, + task, + sentence_avg, + label_smoothing, + ignore_prefix_size=0, + ignore_eos=False, + report_accuracy=False, + drop_worst_ratio=0, + drop_worst_after=0, + use_rdrop=False, + reg_alpha=1.0, + sample_patch_num=196, + constraint_range=None + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.eps = label_smoothing + self.ignore_prefix_size = ignore_prefix_size + self.ignore_eos = ignore_eos + self.report_accuracy = report_accuracy + self.drop_worst_ratio = drop_worst_ratio + self.drop_worst_after = drop_worst_after + self.use_rdrop = use_rdrop + self.reg_alpha = reg_alpha + self.sample_patch_num = sample_patch_num + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + + def forward(self, model, sample, update_num=0, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + if isinstance(sample, list): + if self.sample_patch_num > 0: + sample[0]['net_input']['sample_patch_num'] = self.sample_patch_num + # change to support len(samples) > 2 + loss_v1, sample_size_v1, logging_output_v1 = self.forward(model, sample[0], update_num, reduce) + loss_v2, sample_size_v2, logging_output_v2 = self.forward(model, sample[1], update_num, reduce) + loss = loss_v1 / sample_size_v1 + loss_v2 / sample_size_v2 + sample_size = 1 + logging_output = { + "loss": loss.data, + "loss_v1": loss_v1.data, + "loss_v2": loss_v2.data, + "nll_loss": logging_output_v1["nll_loss"].data / sample_size_v1 + logging_output_v2["nll_loss"].data / sample_size_v2, + "ntokens": logging_output_v1["ntokens"] + logging_output_v2["ntokens"], + "nsentences": logging_output_v1["nsentences"] + logging_output_v2["nsentences"], + "sample_size": 1, + "sample_size_v1": sample_size_v1, + "sample_size_v2": sample_size_v2, + } + return loss, sample_size, logging_output + + if self.use_rdrop: + construct_rdrop_sample(sample) + + net_output = model(**sample["net_input"]) + loss, nll_loss, ntokens = self.compute_loss(model, net_output, sample, update_num, reduce=reduce) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else ntokens + ) + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + } + if self.report_accuracy: + n_correct, total = self.compute_accuracy(model, net_output, sample) + logging_output["n_correct"] = utils.item(n_correct.data) + logging_output["total"] = utils.item(total.data) + + return loss, sample_size, logging_output + + def get_lprobs_and_target(self, model, net_output, sample): + conf = sample['conf'][:, None, None] if 'conf' in sample and sample['conf'] is not None else 1 + constraint_masks = None + if "constraint_masks" in sample and sample["constraint_masks"] is not None: + constraint_masks = sample["constraint_masks"] + net_output[0].masked_fill_(~constraint_masks, -math.inf) + if self.constraint_start is not None and self.constraint_end is not None: + net_output[0][:, :, 4:self.constraint_start] = -math.inf + net_output[0][:, :, self.constraint_end:] = -math.inf + lprobs = model.get_normalized_probs(net_output, log_probs=True) * conf + target = model.get_targets(sample, net_output) + if self.ignore_prefix_size > 0: + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + target = target[:, self.ignore_prefix_size :].contiguous() + if constraint_masks is not None: + constraint_masks = constraint_masks[:, self.ignore_prefix_size :, :].contiguous() + if self.ignore_eos: + bsz, seq_len, embed_dim = lprobs.size() + eos_indices = target.eq(self.task.tgt_dict.eos()) + lprobs = lprobs[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + target = target[~eos_indices].reshape(bsz, seq_len-1) + if constraint_masks is not None: + constraint_masks = constraint_masks[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + if constraint_masks is not None: + constraint_masks = constraint_masks.view(-1, constraint_masks.size(-1)) + return lprobs.view(-1, lprobs.size(-1)), target.view(-1), constraint_masks + + def compute_loss(self, model, net_output, sample, update_num, reduce=True): + lprobs, target, constraint_masks = self.get_lprobs_and_target(model, net_output, sample) + if constraint_masks is not None: + constraint_masks = constraint_masks[target != self.padding_idx] + # print(target.shape, self.padding_idx, lprobs.shape, target, lprobs) + lprobs = lprobs[target != self.padding_idx] + target = target[target != self.padding_idx] + loss, nll_loss, ntokens = label_smoothed_nll_loss( + lprobs, + target, + self.eps, + update_num, + reduce=reduce, + drop_worst_ratio=self.drop_worst_ratio, + drop_worst_after=self.drop_worst_after, + use_rdrop=self.use_rdrop, + reg_alpha=self.reg_alpha, + constraint_masks=constraint_masks, + constraint_start=self.constraint_start, + constraint_end=self.constraint_end + ) + return loss, nll_loss, ntokens + + def compute_accuracy(self, model, net_output, sample): + lprobs, target = self.get_lprobs_and_target(model, net_output, sample) + mask = target.ne(self.padding_idx) + n_correct = torch.sum( + lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask)) + ) + total = torch.sum(mask) + return n_correct, total + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + loss_sum_v1 = sum(log.get("loss_v1", 0) for log in logging_outputs) + loss_sum_v2 = sum(log.get("loss_v2", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + sample_size_v1 = sum(log.get("sample_size_v1", 0) for log in logging_outputs) + sample_size_v2 = sum(log.get("sample_size_v2", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size, sample_size, round=3 + ) + metrics.log_scalar( + "loss_v1", loss_sum_v1 / max(sample_size_v1, 1), max(sample_size_v1, 1), round=3 + ) + metrics.log_scalar( + "loss_v2", loss_sum_v2 / max(sample_size_v2, 1), max(sample_size_v2, 1), round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / sample_size, ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + metrics.log_scalar( + "ntokens", ntokens, 1, round=3 + ) + metrics.log_scalar( + "nsentences", nsentences, 1, round=3 + ) + metrics.log_scalar( + "sample_size", sample_size, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v1", sample_size_v1, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v2", sample_size_v2, 1, round=3 + ) + + total = utils.item(sum(log.get("total", 0) for log in logging_outputs)) + if total > 0: + metrics.log_scalar("total", total) + n_correct = utils.item( + sum(log.get("n_correct", 0) for log in logging_outputs) + ) + metrics.log_scalar("n_correct", n_correct) + metrics.log_derived( + "accuracy", + lambda meters: round( + meters["n_correct"].sum * 100.0 / meters["total"].sum, 3 + ) + if meters["total"].sum > 0 + else float("nan"), + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/criterions/label_smoothed_cross_entropy_scst.py b/criterions/label_smoothed_cross_entropy_scst.py new file mode 100644 index 0000000000000000000000000000000000000000..083a8e49de6e360b42700a0cd48ca595302ea834 --- /dev/null +++ b/criterions/label_smoothed_cross_entropy_scst.py @@ -0,0 +1,555 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from dataclasses import dataclass, field +from typing import Optional + +import torch +import torch.nn.functional as F +import numpy as np +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +from mapcalc import calculate_map, calculate_map_range + +@dataclass +class AdjustLabelSmoothedCrossEntropySCSTCriterionConfig(FairseqDataclass): + label_smoothing: float = field( + default=0.0, + metadata={"help": "epsilon for label smoothing, 0 means no label smoothing"}, + ) + report_accuracy: bool = field( + default=False, + metadata={"help": "report accuracy metric"}, + ) + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + ignore_eos: bool = field( + default=False, + metadata={"help": "Ignore eos token"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + drop_worst_ratio: float = field( + default=0.0, + metadata={"help": "ratio for discarding bad samples"}, + ) + drop_worst_after: int = field( + default=0, + metadata={"help": "steps for discarding bad samples"}, + ) + use_rdrop: bool = field( + default=False, metadata={"help": "use R-Drop"} + ) + reg_alpha: float = field( + default=1.0, metadata={"help": "weight for R-Drop"} + ) + sample_patch_num: int = field( + default=196, metadata={"help": "sample patches for v1"} + ) + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + acc_thresh: Optional[float] = field( + default=None, metadata={"help": "acc thresh for refcoco"} + ) + metric: Optional[str] = field( + default='acc', + metadata={"help": "metric"} + ) + + max_area_size: Optional[float] = field( + default=None, metadata={"help": "max_area_size"} + ) + + min_area_size: Optional[float] = field( + default=None, metadata={"help": "min_area_size"} + ) + logprob: Optional[bool] = field( + default=False, metadata={"help": "maximise log prob"} + ) + + pos_reward: Optional[float] = field( + default=None, metadata={"help": "pos_reward"} + ) + + neg_reward: Optional[float] = field( + default=None, metadata={"help": "neg_reward"} + ) + + reinforce: Optional[bool] = field( + default=False, metadata={"help": "reinforce"} + ) + + lambda_reinforce: Optional[float] = field( + default=0, metadata={"help": "lambda_reinforce"} + ) + + + +def construct_rdrop_sample(x): + if isinstance(x, dict): + for key in x: + x[key] = construct_rdrop_sample(x[key]) + return x + elif isinstance(x, torch.Tensor): + return x.repeat(2, *([1] * (x.dim()-1))) + elif isinstance(x, int): + return x * 2 + elif isinstance(x, np.ndarray): + return x.repeat(2) + else: + raise NotImplementedError + + +def kl_loss(p, q): + p_loss = F.kl_div(p, torch.exp(q), reduction='sum') + q_loss = F.kl_div(q, torch.exp(p), reduction='sum') + loss = (p_loss + q_loss) / 2 + return loss + + +def label_smoothed_nll_loss( + lprobs, target, epsilon, update_num, reduce=True, + drop_worst_ratio=0.0, drop_worst_after=0, use_rdrop=False, reg_alpha=1.0, + constraint_masks=None, constraint_start=None, constraint_end=None +): + if target.dim() == lprobs.dim() - 1: + target = target.unsqueeze(-1) + nll_loss = -lprobs.gather(dim=-1, index=target).squeeze(-1) + if constraint_masks is not None: + smooth_loss = -lprobs.masked_fill(~constraint_masks, 0).sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (constraint_masks.sum(1) - 1 + 1e-6) + elif constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + smooth_loss = -lprobs[:, constraint_range].sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (len(constraint_range) - 1 + 1e-6) + else: + smooth_loss = -lprobs.sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (lprobs.size(-1) - 1) + loss = (1.0 - epsilon - eps_i) * nll_loss + eps_i * smooth_loss + if drop_worst_ratio > 0 and update_num > drop_worst_after: + if use_rdrop: + true_batch_size = loss.size(0) // 2 + _, indices = torch.topk(loss[:true_batch_size], k=int(true_batch_size * (1 - drop_worst_ratio)), largest=False) + loss = torch.cat([loss[indices], loss[indices+true_batch_size]]) + nll_loss = torch.cat([nll_loss[indices], nll_loss[indices+true_batch_size]]) + lprobs = torch.cat([lprobs[indices], lprobs[indices+true_batch_size]]) + else: + loss, indices = torch.topk(loss, k=int(loss.shape[0] * (1 - drop_worst_ratio)), largest=False) + nll_loss = nll_loss[indices] + lprobs = lprobs[indices] + + ntokens = loss.numel() + nll_loss = nll_loss.sum() + # loss = loss.sum() + if use_rdrop: + true_batch_size = lprobs.size(0) // 2 + p = lprobs[:true_batch_size] + q = lprobs[true_batch_size:] + if constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + p = p[:, constraint_range] + q = q[:, constraint_range] + loss = loss + ((kl_loss(p, q) * reg_alpha)/loss.shape[0]) + + return loss, nll_loss, ntokens + + +@register_criterion( + "adjust_label_smoothed_cross_entropy_scst", dataclass=AdjustLabelSmoothedCrossEntropySCSTCriterionConfig +) +class AdjustLabelSmoothedCrossEntropySCSTCriterion(FairseqCriterion): + def __init__( + self, + task, + sentence_avg, + label_smoothing, + ignore_prefix_size=0, + ignore_eos=False, + report_accuracy=False, + drop_worst_ratio=0, + drop_worst_after=0, + use_rdrop=False, + reg_alpha=1.0, + sample_patch_num=196, + constraint_range=None, + acc_thresh=None, + metric='acc', + max_area_size=None, + min_area_size=None, + logprob=False, + pos_reward=None, + neg_reward=None, + reinforce=False, + lambda_reinforce=0, + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.eps = label_smoothing + self.ignore_prefix_size = ignore_prefix_size + self.ignore_eos = ignore_eos + self.report_accuracy = report_accuracy + self.drop_worst_ratio = drop_worst_ratio + self.drop_worst_after = drop_worst_after + self.use_rdrop = use_rdrop + self.reg_alpha = reg_alpha + self.sample_patch_num = sample_patch_num + + + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + + self.acc_thresh = acc_thresh + self.metric = metric + self.min_area_size = min_area_size + self.max_area_size = max_area_size + self.logprob = logprob + + self.pos_reward = pos_reward + self.neg_reward = neg_reward + + self.reinforce = reinforce + self.lambda_reinforce = lambda_reinforce + + def get_generator_out(self, model, sample): + + model.eval() + with torch.no_grad(): + self.task.scst_generator.model.eval() + gen_out = self.task.scst_generator.generate([model], sample) + + hyps, refs = [], [] + for i in range(len(gen_out)): + hyps.append(gen_out[i][0]["tokens"][:-1] - len(self.task.src_dict) + self.task.cfg.num_bins) + refs.append(sample["target"][i][:-1] - len(self.task.src_dict) + self.task.cfg.num_bins) + + return torch.stack(hyps, dim=0), torch.stack(refs, dim=0) + + def _calculate_map_score(self, hyps, refs, thresh=0.5): + + + ground_truth = { + 'boxes': refs.cpu().numpy().tolist(), + + 'labels': [1 for i in range(refs.shape[0])] + } + + result_dict = { + 'boxes': hyps.cpu().numpy().tolist(), + + 'labels': [1 for i in range(hyps.shape[0])], + } + + score = calculate_map(ground_truth, result_dict, thresh) + + score = torch.tensor(score).unsqueeze(0).repeat(refs.shape[0]).to(hyps.device) + return score + + def _calculate_ap_score(self, hyps, refs, thresh=0.5, min_area_size=None, max_area_size=None): + interacts = torch.cat( + [torch.where(hyps[:, :2] < refs[:, :2], refs[:, :2], hyps[:, :2]), + torch.where(hyps[:, 2:] < refs[:, 2:], hyps[:, 2:], refs[:, 2:])], + dim=1 + ) + area_predictions = (hyps[:, 2] - hyps[:, 0]) * (hyps[:, 3] - hyps[:, 1]) ## x1, y1, x2, y2, x1 < x2 + area_targets = (refs[:, 2] - refs[:, 0]) * (refs[:, 3] - refs[:, 1]) + interacts_w = interacts[:, 2] - interacts[:, 0] + interacts_h = interacts[:, 3] - interacts[:, 1] + area_interacts = interacts_w * interacts_h + ious = area_interacts / (area_predictions + area_targets - area_interacts + 1e-6) + + + if max_area_size is not None and min_area_size is not None: + ious = ious * (torch.logical_or(area_targets < max_area_size, area_targets > min_area_size).float()) + + elif min_area_size is not None: + ious = ious * (area_targets > min_area_size).float() + + elif max_area_size is not None: + ious = ious * (area_targets < max_area_size).float() + + if thresh is None: + return ious + else: + return ((ious >= thresh) & (interacts_w > 0) & (interacts_h > 0)).float() + + def reward_step(self, sample, model): + + hyps, refs = self.get_generator_out(model, sample) + hyps = hyps / (self.task.cfg.num_bins - 1) * self.task.cfg.max_image_size + refs = refs / (self.task.cfg.num_bins - 1) * self.task.cfg.max_image_size + hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + refs[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + refs[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + + # scores = self._calculate_ap_score(hyps, refs) + if self.metric == 'acc': + scores = self._calculate_ap_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh, + min_area_size=self.min_area_size, max_area_size=self.max_area_size) + elif self.metric == 'map': + scores = self._calculate_map_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh) + else: + raise NotImplemented + + # logging_output["_score_sum"] = scores.sum().item() + # logging_output["_score_cnt"] = scores.size(0) + + if self.pos_reward: + scores = torch.where(scores > 0, self.pos_reward, scores) + if self.neg_reward: + scores = torch.where(scores == 0, self.neg_reward, scores) + + + return scores + + def forward(self, model, sample, update_num=0, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + if isinstance(sample, list): + if self.sample_patch_num > 0: + sample[0]['net_input']['sample_patch_num'] = self.sample_patch_num + # change to support len(samples) > 2 + loss_v1, sample_size_v1, logging_output_v1 = self.forward(model, sample[0], update_num, reduce) + loss_v2, sample_size_v2, logging_output_v2 = self.forward(model, sample[1], update_num, reduce) + loss = loss_v1 / sample_size_v1 + loss_v2 / sample_size_v2 + sample_size = 1 + logging_output = { + "loss": loss.data, + "loss_v1": loss_v1.data, + "loss_v2": loss_v2.data, + "nll_loss": logging_output_v1["nll_loss"].data / sample_size_v1 + logging_output_v2["nll_loss"].data / sample_size_v2, + "ntokens": logging_output_v1["ntokens"] + logging_output_v2["ntokens"], + "nsentences": logging_output_v1["nsentences"] + logging_output_v2["nsentences"], + "sample_size": 1, + "sample_size_v1": sample_size_v1, + "sample_size_v2": sample_size_v2, + "reward": (logging_output_v1["reward"] + logging_output_v2["reward"])/2, + } + return loss, sample_size, logging_output + + if self.use_rdrop: + construct_rdrop_sample(sample) + + ### scst + reward = self.reward_step(sample, model) # shape = bs + model.train() + net_output = model(**sample["net_input"]) + loss, nll_loss, ntokens = self.compute_loss(model, net_output, sample, update_num, reduce=reduce, reward=reward) + + + + + # loss = loss*reward + + loss = loss.sum() + sample_size = ( + sample["target"].size(0) if self.sentence_avg else ntokens + ) + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + "reward": reward.mean(), + } + if self.report_accuracy: + n_correct, total = self.compute_accuracy(model, net_output, sample) + logging_output["n_correct"] = utils.item(n_correct.data) + logging_output["total"] = utils.item(total.data) + + return loss, sample_size, logging_output + + def get_lprobs_and_target(self, model, net_output, sample, reward=None): + conf = sample['conf'][:, None, None] if 'conf' in sample and sample['conf'] is not None else 1 + constraint_masks = None + if "constraint_masks" in sample and sample["constraint_masks"] is not None: + constraint_masks = sample["constraint_masks"] + net_output[0].masked_fill_(~constraint_masks, -math.inf) + if self.constraint_start is not None and self.constraint_end is not None: + net_output[0][:, :, 4:self.constraint_start] = -math.inf + net_output[0][:, :, self.constraint_end:] = -math.inf + lprobs = model.get_normalized_probs(net_output, log_probs=True) * conf + target = model.get_targets(sample, net_output) + if self.ignore_prefix_size > 0: + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + target = target[:, self.ignore_prefix_size :].contiguous() + if constraint_masks is not None: + constraint_masks = constraint_masks[:, self.ignore_prefix_size :, :].contiguous() + if self.ignore_eos: + bsz, seq_len, embed_dim = lprobs.size() + eos_indices = target.eq(self.task.tgt_dict.eos()) + lprobs = lprobs[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + target = target[~eos_indices].reshape(bsz, seq_len-1) + if constraint_masks is not None: + constraint_masks = constraint_masks[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + if constraint_masks is not None: + constraint_masks = constraint_masks.view(-1, constraint_masks.size(-1)) + + if reward is not None: + reward = reward.unsqueeze(1).unsqueeze(1) + lprobs = lprobs*reward + return lprobs.view(-1, lprobs.size(-1)), target.view(-1), constraint_masks + + def compute_loss(self, model, net_output, sample, update_num, reduce=True, reward=None): + lprobs, target, constraint_masks = self.get_lprobs_and_target(model, net_output, sample, reward=reward) + + if constraint_masks is not None: + constraint_masks = constraint_masks[target != self.padding_idx] + # print(target.shape, self.padding_idx, lprobs.shape, target, lprobs) + lprobs = lprobs[target != self.padding_idx] + target = target[target != self.padding_idx] + + + loss, nll_loss, ntokens = label_smoothed_nll_loss( + lprobs, + target, + self.eps, + update_num, + reduce=reduce, + drop_worst_ratio=self.drop_worst_ratio, + drop_worst_after=self.drop_worst_after, + use_rdrop=self.use_rdrop, + reg_alpha=self.reg_alpha, + constraint_masks=constraint_masks, + constraint_start=self.constraint_start, + constraint_end=self.constraint_end + ) + + if self.logprob and self.reinforce: + # print(-lprobs.max(dim=-1)[0].squeeze(-1).sum(), loss) + if self.lambda_reinforce > 0: + lprobs_, target_, constraint_masks_ = self.get_lprobs_and_target(model, net_output, sample, reward=None) + + loss_, _, ntokens = label_smoothed_nll_loss( + lprobs_, + target_, + self.eps, + update_num, + reduce=reduce, + drop_worst_ratio=self.drop_worst_ratio, + drop_worst_after=self.drop_worst_after, + use_rdrop=self.use_rdrop, + reg_alpha=self.reg_alpha, + constraint_masks=constraint_masks_, + constraint_start=self.constraint_start, + constraint_end=self.constraint_end + ) + # print(-lprobs.max(dim=-1)[0].squeeze(-1).sum(), loss_) + # loss = -lprobs.max(dim=-1)[0].squeeze(-1).sum()*self.lambda_reinforce + loss_ + + loss = loss*self.lambda_reinforce + loss_ # only supervised with more weights via reward + + else: + loss = -lprobs.max(dim=-1)[0].squeeze(-1).sum() + + elif self.logprob: + loss = nll_loss + + return loss, nll_loss, ntokens + + def compute_accuracy(self, model, net_output, sample): + lprobs, target = self.get_lprobs_and_target(model, net_output, sample) + mask = target.ne(self.padding_idx) + n_correct = torch.sum( + lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask)) + ) + total = torch.sum(mask) + return n_correct, total + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + loss_sum_v1 = sum(log.get("loss_v1", 0) for log in logging_outputs) + loss_sum_v2 = sum(log.get("loss_v2", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + sample_size_v1 = sum(log.get("sample_size_v1", 0) for log in logging_outputs) + sample_size_v2 = sum(log.get("sample_size_v2", 0) for log in logging_outputs) + + + reward = sum(log.get("reward", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size, sample_size, round=3 + ) + metrics.log_scalar( + "loss_v1", loss_sum_v1 / max(sample_size_v1, 1), max(sample_size_v1, 1), round=3 + ) + metrics.log_scalar( + "loss_v2", loss_sum_v2 / max(sample_size_v2, 1), max(sample_size_v2, 1), round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / sample_size, ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + metrics.log_scalar( + "ntokens", ntokens, 1, round=3 + ) + metrics.log_scalar( + "nsentences", nsentences, 1, round=3 + ) + metrics.log_scalar( + "sample_size", sample_size, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v1", sample_size_v1, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v2", sample_size_v2, 1, round=3 + ) + + metrics.log_scalar( + "reward", reward / sample_size, sample_size, round=3 + ) + + total = utils.item(sum(log.get("total", 0) for log in logging_outputs)) + if total > 0: + metrics.log_scalar("total", total) + n_correct = utils.item( + sum(log.get("n_correct", 0) for log in logging_outputs) + ) + metrics.log_scalar("n_correct", n_correct) + metrics.log_derived( + "accuracy", + lambda meters: round( + meters["n_correct"].sum * 100.0 / meters["total"].sum, 3 + ) + if meters["total"].sum > 0 + else float("nan"), + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/criterions/label_smoothed_encouraging_loss.py b/criterions/label_smoothed_encouraging_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..c55ea9eb93bc57356fe0be78c74b4d5233744548 --- /dev/null +++ b/criterions/label_smoothed_encouraging_loss.py @@ -0,0 +1,395 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import Optional + +import torch +import torch.nn.functional as F +import numpy as np +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +@dataclass +class AdjustLabelSmoothedEncouragingLossConfig(FairseqDataclass): + label_smoothing: float = field( + default=0.0, + metadata={"help": "epsilon for label smoothing, 0 means no label smoothing"}, + ) + report_accuracy: bool = field( + default=False, + metadata={"help": "report accuracy metric"}, + ) + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + ignore_eos: bool = field( + default=False, + metadata={"help": "Ignore eos token"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + drop_worst_ratio: float = field( + default=0.0, + metadata={"help": "ratio for discarding bad samples"}, + ) + drop_worst_after: int = field( + default=0, + metadata={"help": "steps for discarding bad samples"}, + ) + use_rdrop: bool = field( + default=False, metadata={"help": "use R-Drop"} + ) + reg_alpha: float = field( + default=1.0, metadata={"help": "weight for R-Drop"} + ) + sample_patch_num: int = field( + default=196, metadata={"help": "sample patchs for v1"} + ) + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + log_end: float = field( + default=0.75, + metadata={"help": "higher log_end is for cases with higher performance," + " we recommend 0.75 or 0.5 as your first try."} + ) + drop_best_ratio: float = field( + default=0.0, + metadata={"help": "ratio for discarding best samples"}, + ) + drop_best_after: int = field( + default=0, + metadata={"help": "steps for discarding best samples"}, + ) + + + +def construct_rdrop_sample(x): + if isinstance(x, dict): + for key in x: + x[key] = construct_rdrop_sample(x[key]) + return x + elif isinstance(x, torch.Tensor): + return x.repeat(2, *([1] * (x.dim()-1))) + elif isinstance(x, int): + return x * 2 + elif isinstance(x, np.ndarray): + return x.repeat(2) + else: + raise NotImplementedError + + +def kl_loss(p, q): + p_loss = F.kl_div(p, torch.exp(q), reduction='sum') + q_loss = F.kl_div(q, torch.exp(p), reduction='sum') + loss = (p_loss + q_loss) / 2 + return loss + + +def label_smoothed_nll_loss( + lprobs, target, epsilon, update_num, reduce=True, + drop_worst_ratio=0.0, drop_worst_after=0, use_rdrop=False, reg_alpha=1.0, + constraint_masks=None, constraint_start=None, constraint_end=None, drop_best_ratio=0.0, + drop_best_after=0, +): + if target.dim() == lprobs.dim() - 1: + target = target.unsqueeze(-1) + nll_loss = -lprobs.gather(dim=-1, index=target).squeeze(-1) + if constraint_masks is not None: + smooth_loss = -lprobs.masked_fill(~constraint_masks, 0).sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (constraint_masks.sum(1) - 1 + 1e-6) + elif constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + smooth_loss = -lprobs[:, constraint_range].sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (len(constraint_range) - 1 + 1e-6) + else: + smooth_loss = -lprobs.sum(dim=-1, keepdim=True).squeeze(-1) + eps_i = epsilon / (lprobs.size(-1) - 1) + loss = (1.0 - epsilon - eps_i) * nll_loss + eps_i * smooth_loss + if drop_worst_ratio > 0 and update_num > drop_worst_after: + if use_rdrop: + true_batch_size = loss.size(0) // 2 + _, indices = torch.topk(loss[:true_batch_size], k=int(true_batch_size * (1 - drop_worst_ratio)), largest=False) + loss = torch.cat([loss[indices], loss[indices+true_batch_size]]) + nll_loss = torch.cat([nll_loss[indices], nll_loss[indices+true_batch_size]]) + lprobs = torch.cat([lprobs[indices], lprobs[indices+true_batch_size]]) + else: + loss, indices = torch.topk(loss, k=int(loss.shape[0] * (1 - drop_worst_ratio)), largest=False) + nll_loss = nll_loss[indices] + lprobs = lprobs[indices] + target = target[indices] + if update_num > drop_best_after: + loss, indices = torch.topk(loss, k=int(loss.shape[0] * (1 - drop_best_ratio)), largest=True) + nll_loss = nll_loss[indices] + lprobs = lprobs[indices] + target = target[indices] + + ntokens = loss.numel() + nll_loss = nll_loss.sum() + loss = loss.sum() + if use_rdrop: + true_batch_size = lprobs.size(0) // 2 + p = lprobs[:true_batch_size] + q = lprobs[true_batch_size:] + if constraint_start is not None and constraint_end is not None: + constraint_range = [0, 1, 2, 3] + list(range(constraint_start, constraint_end)) + p = p[:, constraint_range] + q = q[:, constraint_range] + loss += kl_loss(p, q) * reg_alpha + + return loss, nll_loss, ntokens,lprobs,target + + +@register_criterion( + "adjust_label_smoothed_encouraging_loss", dataclass=AdjustLabelSmoothedEncouragingLossConfig +) +class AdjustLabelSmoothedEncouragingLossCriterion(FairseqCriterion): + def __init__( + self, + task, + sentence_avg, + label_smoothing, + ignore_prefix_size=0, + ignore_eos=False, + report_accuracy=False, + drop_worst_ratio=0, + drop_worst_after=0, + use_rdrop=False, + reg_alpha=1.0, + sample_patch_num=196, + constraint_range=None, + log_end=0.75, + drop_best_ratio=0.0, + drop_best_after=0, + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.eps = label_smoothing + self.ignore_prefix_size = ignore_prefix_size + self.ignore_eos = ignore_eos + self.report_accuracy = report_accuracy + self.drop_worst_ratio = drop_worst_ratio + self.drop_worst_after = drop_worst_after + self.use_rdrop = use_rdrop + self.reg_alpha = reg_alpha + self.sample_patch_num = sample_patch_num + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + self.log_end = log_end + self.drop_best_ratio = drop_best_ratio + self.drop_best_after = drop_best_after + print('el, self.log_end=', self.log_end) + # @staticmethod + # def add_args(parser): + # """Add criterion-specific arguments to the parser.""" + # # fmt: off + # parser.add_argument('--log_end', type=float, default=1.0) + + def forward(self, model, sample, update_num=0, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + if isinstance(sample, list): + if self.sample_patch_num > 0: + sample[0]['net_input']['sample_patch_num'] = self.sample_patch_num + loss_v1, sample_size_v1, logging_output_v1 = self.forward(model, sample[0], update_num, reduce) + loss_v2, sample_size_v2, logging_output_v2 = self.forward(model, sample[1], update_num, reduce) + loss = loss_v1 / sample_size_v1 + loss_v2 / sample_size_v2 + sample_size = 1 + logging_output = { + "loss": loss.data, + "loss_v1": loss_v1.data, + "loss_v2": loss_v2.data, + "nll_loss": logging_output_v1["nll_loss"].data / sample_size_v1 + logging_output_v2["nll_loss"].data / sample_size_v2, + "ntokens": logging_output_v1["ntokens"] + logging_output_v2["ntokens"], + "nsentences": logging_output_v1["nsentences"] + logging_output_v2["nsentences"], + "sample_size": 1, + "sample_size_v1": sample_size_v1, + "sample_size_v2": sample_size_v2, + } + return loss, sample_size, logging_output + + if self.use_rdrop: + construct_rdrop_sample(sample) + + net_output = model(**sample["net_input"]) + loss, nll_loss, ntokens = self.compute_loss(model, net_output, sample, update_num, reduce=reduce) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else ntokens + ) + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + } + if self.report_accuracy: + n_correct, total = self.compute_accuracy(model, net_output, sample) + logging_output["n_correct"] = utils.item(n_correct.data) + logging_output["total"] = utils.item(total.data) + return loss, sample_size, logging_output + + def get_lprobs_and_target(self, model, net_output, sample): + conf = sample['conf'][:, None, None] if 'conf' in sample and sample['conf'] is not None else 1 + constraint_masks = None + if "constraint_masks" in sample and sample["constraint_masks"] is not None: + constraint_masks = sample["constraint_masks"] + net_output[0].masked_fill_(~constraint_masks, -math.inf) + if self.constraint_start is not None and self.constraint_end is not None: + net_output[0][:, :, 4:self.constraint_start] = -math.inf + net_output[0][:, :, self.constraint_end:] = -math.inf + lprobs = model.get_normalized_probs(net_output, log_probs=True) * conf + target = model.get_targets(sample, net_output) + if self.ignore_prefix_size > 0: + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + target = target[:, self.ignore_prefix_size :].contiguous() + if constraint_masks is not None: + constraint_masks = constraint_masks[:, self.ignore_prefix_size :, :].contiguous() + if self.ignore_eos: + bsz, seq_len, embed_dim = lprobs.size() + eos_indices = target.eq(self.task.tgt_dict.eos()) + lprobs = lprobs[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + target = target[~eos_indices].reshape(bsz, seq_len-1) + if constraint_masks is not None: + constraint_masks = constraint_masks[~eos_indices].reshape(bsz, seq_len-1, embed_dim) + if constraint_masks is not None: + constraint_masks = constraint_masks.view(-1, constraint_masks.size(-1)) + return lprobs.view(-1, lprobs.size(-1)), target.view(-1), constraint_masks + + def compute_loss(self, model, net_output, sample, update_num, reduce=True): + lprobs, target, constraint_masks = self.get_lprobs_and_target(model, net_output, sample) + if constraint_masks is not None: + constraint_masks = constraint_masks[target != self.padding_idx] + lprobs = lprobs[target != self.padding_idx] + target = target[target != self.padding_idx] + loss, nll_loss, ntokens, lprobs, target = label_smoothed_nll_loss( + lprobs, + target, + self.eps, + update_num, + reduce=reduce, + drop_worst_ratio=self.drop_worst_ratio, + drop_worst_after=self.drop_worst_after, + use_rdrop=self.use_rdrop, + reg_alpha=self.reg_alpha, + constraint_masks=constraint_masks, + constraint_start=self.constraint_start, + constraint_end=self.constraint_end + ) + # for encouraging loss + probs = torch.exp(lprobs) + bonus = torch.log(torch.clamp((torch.ones_like(probs) - probs), min=1e-5)) # likelihood bonus + log_end = self.log_end + if log_end != 1.0: # e.g. 0.9 + y_log_end = torch.log(torch.ones_like(probs) - log_end) + bonus_after_log_end = 1 / (log_end - torch.ones_like(probs)) * (probs - log_end) + y_log_end + # x:log_end, y torch.log(torch.clamp((torch.ones_like(probs) - probs), min=self.cl_eps)) + bonus = torch.where(probs > log_end, bonus_after_log_end, bonus) + c_loss = F.nll_loss( + -bonus, + target.view(-1), + reduction='sum', + ) + smoothing_c_loss = bonus.sum(dim=-1) + smoothing_c_loss = smoothing_c_loss.sum() + c_loss = c_loss * (1 - self.eps) + (self.eps / lprobs.size(-1)) * smoothing_c_loss + loss = loss + c_loss + # end for encouraging loss + return loss, nll_loss, ntokens + + def compute_accuracy(self, model, net_output, sample): + lprobs, target = self.get_lprobs_and_target(model, net_output, sample) + mask = target.ne(self.padding_idx) + n_correct = torch.sum( + lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask)) + ) + total = torch.sum(mask) + return n_correct, total + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + loss_sum_v1 = sum(log.get("loss_v1", 0) for log in logging_outputs) + loss_sum_v2 = sum(log.get("loss_v2", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + sample_size_v1 = sum(log.get("sample_size_v1", 0) for log in logging_outputs) + sample_size_v2 = sum(log.get("sample_size_v2", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size, sample_size, round=3 + ) + metrics.log_scalar( + "loss_v1", loss_sum_v1 / max(sample_size_v1, 1), max(sample_size_v1, 1), round=3 + ) + metrics.log_scalar( + "loss_v2", loss_sum_v2 / max(sample_size_v2, 1), max(sample_size_v2, 1), round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / sample_size, ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + metrics.log_scalar( + "ntokens", ntokens, 1, round=3 + ) + metrics.log_scalar( + "nsentences", nsentences, 1, round=3 + ) + metrics.log_scalar( + "sample_size", sample_size, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v1", sample_size_v1, 1, round=3 + ) + metrics.log_scalar( + "sample_size_v2", sample_size_v2, 1, round=3 + ) + + total = utils.item(sum(log.get("total", 0) for log in logging_outputs)) + if total > 0: + metrics.log_scalar("total", total) + n_correct = utils.item( + sum(log.get("n_correct", 0) for log in logging_outputs) + ) + metrics.log_scalar("n_correct", n_correct) + metrics.log_derived( + "accuracy", + lambda meters: round( + meters["n_correct"].sum * 100.0 / meters["total"].sum, 3 + ) + if meters["total"].sum > 0 + else float("nan"), + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/criterions/refcoco_scst_loss.py b/criterions/refcoco_scst_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..28001a7d626a68ea80990809bea493b3e279617c --- /dev/null +++ b/criterions/refcoco_scst_loss.py @@ -0,0 +1,427 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +import string +from dataclasses import dataclass, field +from collections import OrderedDict +from typing import Optional + +import torch +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + +from data import data_utils +from utils.cider.pyciderevalcap.ciderD.ciderD import CiderD + + + +def scst_loss(lprobs, target, reward, ignore_index=None, reduce=True, ce=False): + + if ce: + loss = -lprobs.gather(dim=-1, index=target.unsqueeze(-1)).squeeze(-1) + elif isinstance(reward, float): + loss = -lprobs.gather(dim=-1, index=target.unsqueeze(-1)).squeeze() * reward + else: + loss = -lprobs.gather(dim=-1, index=target.unsqueeze(-1)).squeeze() * reward.unsqueeze(-1) + + if ignore_index is not None: + pad_mask = target.eq(ignore_index) + loss.masked_fill_(pad_mask, 0.0) + ntokens = (~pad_mask).sum() + else: + loss = loss.squeeze(-1) + ntokens = target.numel() + if reduce: + loss = loss.sum() + return loss, ntokens + + +@dataclass +class RefCOCOScstRewardCriterionConfig(FairseqDataclass): + scst_cider_cached_tokens: Optional[str] = field( + default="coco-train-words.p", + metadata={"help": "path to cached cPickle file used to calculate CIDEr scores"}, + ) + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + + + acc_thresh: Optional[float] = field( + default=None, metadata={"help": "acc thresh for refcoco"} + ) + metric: Optional[str] = field( + default='acc', + metadata={"help": "metric"} + ) + + max_area_size: Optional[float] = field( + default=None, metadata={"help": "max_area_size"} + ) + + min_area_size: Optional[float] = field( + default=None, metadata={"help": "min_area_size"} + ) + logprob: Optional[bool] = field( + default=False, metadata={"help": "maximise log prob"} + ) + + pos_reward: Optional[float] = field( + default=None, metadata={"help": "pos_reward"} + ) + + neg_reward: Optional[float] = field( + default=None, metadata={"help": "neg_reward"} + ) + + reinforce: Optional[bool] = field( + default=False, metadata={"help": "reinforce"} + ) + + lambda_reinforce: Optional[float] = field( + default=0, metadata={"help": "lambda_reinforce"} + ) + + medium_area: Optional[bool] = field( + default=False, metadata={"help": "reinforce"} + ) + +@register_criterion( + "refcoco_scst_reward_criterion", dataclass=RefCOCOScstRewardCriterionConfig +) +class RefCOCOScstRewardCriterion(FairseqCriterion): + CIDER_REWARD_WEIGHT = 1 + + def __init__( + self, + task, + scst_cider_cached_tokens, + sentence_avg, + ignore_prefix_size=0, + constraint_range=None, + acc_thresh=None, + metric='acc', + max_area_size=None, + min_area_size=None, + logprob=False, + pos_reward=None, + neg_reward=None, + reinforce=False, + lambda_reinforce=0, + medium_area=False, + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.ignore_prefix_size = ignore_prefix_size + self.transtab = str.maketrans({key: None for key in string.punctuation}) + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + + self.metric = metric + print("metric", metric) + + self.acc_thresh = acc_thresh + self.metric = metric + self.min_area_size = min_area_size + self.max_area_size = max_area_size + self.logprob = logprob + + self.pos_reward = pos_reward + self.neg_reward = neg_reward + + self.reinforce = reinforce + self.lambda_reinforce = lambda_reinforce + + self.medium_area = medium_area + + + + + def forward(self, model, sample, update_num=0, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + loss, score, ntokens, nsentences = self.compute_loss(model, sample, reduce=reduce) + + sample_size = ( + nsentences if self.sentence_avg else ntokens + ) + logging_output = { + "loss": loss.data, + "score": score, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + def _calculate_eval_scores(self, gen_res, gt_idx, gt_res): + ''' + gen_res: generated captions, list of str + gt_idx: list of int, of the same length as gen_res + gt_res: ground truth captions, list of list of str. + gen_res[i] corresponds to gt_res[gt_idx[i]] + Each image can have multiple ground truth captions + ''' + + gen_res_size = len(gen_res) + + res = OrderedDict() + for i in range(gen_res_size): + res[i] = [self._wrap_sentence(gen_res[i].strip().translate(self.transtab))] + + gts = OrderedDict() + gt_res_ = [ + [self._wrap_sentence(gt_res[i][j].strip().translate(self.transtab)) for j in range(len(gt_res[i]))] + for i in range(len(gt_res)) + ] + for i in range(gen_res_size): + gts[i] = gt_res_[gt_idx[i]] + + res_ = [{'image_id':i, 'caption': res[i]} for i in range(len(res))] + + # replace with other metrics + if self.metric != 'cider': + predicts = [res[i][0] if isinstance(res[i], list) else res[i] for i in range(len(res))] + + answers = [gts[i] for i in range(gen_res_size)] + + results = self.evaluator.run_evaluation(predicts, answers) + batch_cider_scores = results[self.metric] + + batch_cider_scores = torch.tensor(batch_cider_scores).repeat(gen_res_size) + else: + _, batch_cider_scores = self.scst_cider_scorer.compute_score(gts, res_) + + scores = self.CIDER_REWARD_WEIGHT * batch_cider_scores + return scores + + @classmethod + def _wrap_sentence(self, s): + # ensure the sentence ends with token + # in order to keep consisitent with cider_cached_tokens + r = s.strip() + if r.endswith('.'): + r = r[:-1] + r += ' ' + return r + + + def get_generator_out(self, model, sample): + + + model.eval() + with torch.no_grad(): + self.task.scst_generator.model.eval() + gen_out = self.task.scst_generator.generate([model], sample) + + gen_target = [] + gen_res = [] + gt_res = [] + for i in range(len(gen_out)): + gen_res.append(gen_out[i][0]["tokens"][:-1] - len(self.task.src_dict) + self.task.cfg.num_bins) + gt_res.append(sample["target"][i][:-1] - len(self.task.src_dict) + self.task.cfg.num_bins) + gen_target.append(gen_out[i][0]["tokens"][:-1].int().cpu()) + + return gen_target, gen_res, gt_res + + def _calculate_ap_score(self, hyps, refs, thresh=0.5, min_area_size=None, max_area_size=None, medium_area=False): + interacts = torch.cat( + [torch.where(hyps[:, :2] < refs[:, :2], refs[:, :2], hyps[:, :2]), + torch.where(hyps[:, 2:] < refs[:, 2:], hyps[:, 2:], refs[:, 2:])], + dim=1 + ) + area_predictions = (hyps[:, 2] - hyps[:, 0]) * (hyps[:, 3] - hyps[:, 1]) ## x1, y1, x2, y2, x1 < x2 + area_targets = (refs[:, 2] - refs[:, 0]) * (refs[:, 3] - refs[:, 1]) + interacts_w = interacts[:, 2] - interacts[:, 0] + interacts_h = interacts[:, 3] - interacts[:, 1] + area_interacts = interacts_w * interacts_h + ious = area_interacts / (area_predictions + area_targets - area_interacts + 1e-6) + + + if max_area_size is not None and min_area_size is not None: + if medium_area: + ious = ious * (torch.logical_and(area_targets > max_area_size, area_targets < min_area_size).float()) + + else: + ious = ious * (torch.logical_or(area_targets < max_area_size, area_targets > min_area_size).float()) + + elif min_area_size is not None: + if medium_area: + ious = ious * (area_targets < min_area_size).float() # as max areas + else: + ious = ious * (area_targets > min_area_size).float() + + elif max_area_size is not None: + if medium_area: + ious = ious * (area_targets > max_area_size).float() + else: + ious = ious * (area_targets < max_area_size).float() + + if thresh is None: + return ious + else: + return ((ious >= thresh) & (interacts_w > 0) & (interacts_h > 0)).float() + + + def get_reward_and_scores(self, gen_res, gt_res, device, sample): + + + hyps_, refs_ = torch.stack(gen_res, dim=0), torch.stack(gt_res, dim=0) + + hyps = hyps_ / (self.task.cfg.num_bins - 1) * self.task.cfg.max_image_size + refs = refs_ / (self.task.cfg.num_bins - 1) * self.task.cfg.max_image_size + + hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + refs[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + refs[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + + if self.metric == 'acc': + scores = self._calculate_ap_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh, + min_area_size=self.min_area_size, max_area_size=self.max_area_size, medium_area=self.medium_area) + else: + raise NotImplemented + + + if self.pos_reward: + scores = torch.where(scores > 0, self.pos_reward, scores) + if self.neg_reward: + scores = torch.where(scores == 0, self.neg_reward, scores) + + return scores, scores + + + def get_net_output(self, model, sample, gen_target): + def merge(sample_list, eos=self.task.tgt_dict.eos(), move_eos_to_beginning=False): + return data_utils.collate_tokens( + sample_list, + pad_idx=self.padding_idx, + eos_idx=eos, + left_pad=False, + move_eos_to_beginning=move_eos_to_beginning, + ) + + batch_size = len(sample["target"]) + gen_target_size = len(gen_target) + seq_per_img = gen_target_size // batch_size + + model.train() + sample_src_tokens = torch.repeat_interleave( + sample['net_input']['src_tokens'], seq_per_img, dim=0 + ) + sample_src_lengths = torch.repeat_interleave( + sample['net_input']['src_lengths'], seq_per_img, dim=0 + ) + sample_patch_images = torch.repeat_interleave( + sample['net_input']['patch_images'], seq_per_img, dim=0 + ) + sample_patch_masks = torch.repeat_interleave( + sample['net_input']['patch_masks'], seq_per_img, dim=0 + ) + gen_prev_output_tokens = torch.as_tensor( + merge(gen_target, eos=self.task.tgt_dict.bos(), move_eos_to_beginning=True), + device=sample["target"].device, dtype=torch.int64 + ) + gen_target_tokens = torch.as_tensor( + merge(gen_target), device=sample["target"].device, dtype=torch.int64 + ) + + net_output = model( + src_tokens=sample_src_tokens, src_lengths=sample_src_lengths, + patch_images=sample_patch_images, patch_masks=sample_patch_masks, + prev_output_tokens=gen_prev_output_tokens + ) + + return net_output, gen_target_tokens + + def get_lprobs_and_target(self, model, net_output, gen_target): + if self.constraint_start is not None and self.constraint_end is not None: + net_output[0][:, :, 4:self.constraint_start] = -math.inf + net_output[0][:, :, self.constraint_end:] = -math.inf + lprobs = model.get_normalized_probs(net_output, log_probs=True) + if self.ignore_prefix_size > 0: + if getattr(lprobs, "batch_first", False): + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + gen_target = gen_target[:, self.ignore_prefix_size :].contiguous() + else: + lprobs = lprobs[self.ignore_prefix_size :, :, :].contiguous() + gen_target = gen_target[self.ignore_prefix_size :, :].contiguous() + return lprobs, gen_target + + def compute_loss(self, model, sample, reduce=True): + gen_target, gen_res, gt_res = self.get_generator_out(model, sample) + reward, scores = self.get_reward_and_scores(gen_res, gt_res, device=sample["target"].device, sample=sample) + + net_output, gen_target_tokens = self.get_net_output(model, sample, gen_target) + + gen_lprobs, gen_target_tokens = self.get_lprobs_and_target(model, net_output, gen_target_tokens) + loss, ntokens = scst_loss(gen_lprobs, gen_target_tokens, reward, ignore_index=self.padding_idx, reduce=reduce) + nsentences = gen_target_tokens.size(0) + + if self.lambda_reinforce > 0: + target = model.get_targets(sample, net_output)[:, :-1] # ignore eos token + if self.ignore_prefix_size > 0: + target = target[:, self.ignore_prefix_size :].contiguous() + + loss_ce, ntokens_ = scst_loss(gen_lprobs, target, reward=1, ignore_index=self.padding_idx, reduce=reduce, ce=True) + + loss = loss_ce + self.lambda_reinforce*loss + + return loss, scores.sum(), ntokens, nsentences + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + score_sum = sum(log.get("score", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size, sample_size, round=3 + ) + metrics.log_scalar( + "score", score_sum / nsentences, nsentences, round=3 + ) + + metrics.log_scalar( + "ntokens", ntokens, 1, round=3 + ) + metrics.log_scalar( + "nsentences", nsentences, 1, round=3 + ) + metrics.log_scalar( + "sample_size", sample_size, 1, round=3 + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/data/.ipynb_checkpoints/file_dataset-checkpoint.py b/data/.ipynb_checkpoints/file_dataset-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..c42f5d82b01b3982404cd72171cf108bebcfa779 --- /dev/null +++ b/data/.ipynb_checkpoints/file_dataset-checkpoint.py @@ -0,0 +1,107 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import os +import torch +import pickle + + +class FileDataset: + def __init__(self, file_path, selected_col_ids=None, dtypes=None, separator="\t", cached_index=False): + self.file_path = file_path + assert os.path.exists(self.file_path), "Error: The local datafile {} not exists!".format(self.file_path) + + self.separator = separator + if selected_col_ids is None: + # default to all fields + self.selected_col_ids = list( + range(len(open(self.file_path).readline().rstrip("\n").split(self.separator)))) + else: + self.selected_col_ids = [int(col_id) for col_id in selected_col_ids.split(",")] + if dtypes is None: + # default to str + self.dtypes = [str for col_id in self.selected_col_ids] + else: + self.dtypes = [eval(col_dtype) for col_dtype in dtypes.split(",")] + assert len(self.dtypes) == len(self.selected_col_ids) + + self.data_cnt = 0 + try: + self.slice_id = torch.distributed.get_rank() + self.slice_count = torch.distributed.get_world_size() + except Exception: + self.slice_id = 0 + self.slice_count = 1 + self.cached_index = cached_index + self._init_seek_index() + self._reader = self._get_reader() + print("file {} slice_id {} row count {} total row count {}".format( + self.file_path, self.slice_id, self.row_count, self.total_row_count) + ) + + def _init_seek_index(self): + if self.cached_index: + cache_path = "{}.index".format(self.file_path) + assert os.path.exists(cache_path), "cache file {} not exists!".format(cache_path) + self.total_row_count, self.lineid_to_offset = pickle.load(open(cache_path, "rb")) + print("local datafile {} slice_id {} use cached row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + else: + # make an iteration over the file to get row_count and line_idx-to-offset mapping + fp = open(self.file_path, "r") + print("local datafile {} slice_id {} begin to initialize row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + self.total_row_count = 0 + offset = 0 + self.lineid_to_offset = [] + for line in fp: + self.lineid_to_offset.append(offset) + self.total_row_count += 1 + offset += len(line.encode('utf-8')) + self._compute_start_pos_and_row_count() + print("local datafile {} slice_id {} finished initializing row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + + def _compute_start_pos_and_row_count(self): + self.row_count = self.total_row_count // self.slice_count + if self.slice_id < self.total_row_count - self.row_count * self.slice_count: + self.row_count += 1 + self.start_pos = self.row_count * self.slice_id + else: + self.start_pos = self.row_count * self.slice_id + (self.total_row_count - self.row_count * self.slice_count) + + def _get_reader(self): + fp = open(self.file_path, "r") + fp.seek(self.lineid_to_offset[self.start_pos]) + return fp + + def _seek(self, offset=0): + try: + print("slice_id {} seek offset {}".format(self.slice_id, self.start_pos + offset)) + self._reader.seek(self.lineid_to_offset[self.start_pos + offset]) + self.data_cnt = offset + except Exception: + print("slice_id {} seek offset {}".format(self.slice_id, offset)) + self._reader.seek(self.lineid_to_offset[offset]) + self.data_cnt = offset + + def __del__(self): + self._reader.close() + + def __len__(self): + return self.row_count + + def get_total_row_count(self): + return self.total_row_count + + def __getitem__(self, index): + if self.data_cnt == self.row_count: + print("reach the end of datafile, start a new reader") + self.data_cnt = 0 + self._reader = self._get_reader() + column_l = self._reader.readline().rstrip("\n").split(self.separator) + self.data_cnt += 1 + column_l = [dtype(column_l[col_id]) for col_id, dtype in zip(self.selected_col_ids, self.dtypes)] + return column_l diff --git a/data/__init__.py b/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/data/__pycache__/__init__.cpython-37.pyc b/data/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b05ed4e7640fb8ff578c1a33f41f97c7571118c Binary files /dev/null and b/data/__pycache__/__init__.cpython-37.pyc differ diff --git a/data/__pycache__/__init__.cpython-38.pyc b/data/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bcdc42675567249d0c398930f6315cc983ce66d Binary files /dev/null and b/data/__pycache__/__init__.cpython-38.pyc differ diff --git a/data/__pycache__/__init__.cpython-39.pyc b/data/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f76d1ba6dee423dbc68be6dec6d827c01de0f94c Binary files /dev/null and b/data/__pycache__/__init__.cpython-39.pyc differ diff --git a/data/__pycache__/audio_utils.cpython-37.pyc b/data/__pycache__/audio_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3dbf691206ac24f7d367c1962a29ae6ffc9b0f56 Binary files /dev/null and b/data/__pycache__/audio_utils.cpython-37.pyc differ diff --git a/data/__pycache__/audio_utils.cpython-39.pyc b/data/__pycache__/audio_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..401ef7e024e2f6f5c2e194f3dcb75faf6b2875a4 Binary files /dev/null and b/data/__pycache__/audio_utils.cpython-39.pyc differ diff --git a/data/__pycache__/data_utils.cpython-37.pyc b/data/__pycache__/data_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cddc4dcaceccf3a91fe304c59bb6a06ea258f565 Binary files /dev/null and b/data/__pycache__/data_utils.cpython-37.pyc differ diff --git a/data/__pycache__/data_utils.cpython-38.pyc b/data/__pycache__/data_utils.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d427680e033242eb922026eb6681d1a317587f6 Binary files /dev/null and b/data/__pycache__/data_utils.cpython-38.pyc differ diff --git a/data/__pycache__/data_utils.cpython-39.pyc b/data/__pycache__/data_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..27cc8e0992f8ada898938d36a3b54d9b0f3225bf Binary files /dev/null and b/data/__pycache__/data_utils.cpython-39.pyc differ diff --git a/data/__pycache__/file_dataset.cpython-37.pyc b/data/__pycache__/file_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2111eef5c2f1e64e2bab1f45a4b6073c4000457 Binary files /dev/null and b/data/__pycache__/file_dataset.cpython-37.pyc differ diff --git a/data/__pycache__/file_dataset.cpython-38.pyc b/data/__pycache__/file_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0035548105d63fa449b2c59c9c898de5b1099a27 Binary files /dev/null and b/data/__pycache__/file_dataset.cpython-38.pyc differ diff --git a/data/__pycache__/file_dataset.cpython-39.pyc b/data/__pycache__/file_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8140dc03925eb1813ab09eb5c6ed97206fae291c Binary files /dev/null and b/data/__pycache__/file_dataset.cpython-39.pyc differ diff --git a/data/__pycache__/ofa_dataset.cpython-37.pyc b/data/__pycache__/ofa_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5868256a7de3a92d785537c760ac000830a1e2ca Binary files /dev/null and b/data/__pycache__/ofa_dataset.cpython-37.pyc differ diff --git a/data/__pycache__/ofa_dataset.cpython-38.pyc b/data/__pycache__/ofa_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..381603dd3e05b962e2e188ba09bf2f6f8102fbec Binary files /dev/null and b/data/__pycache__/ofa_dataset.cpython-38.pyc differ diff --git a/data/__pycache__/ofa_dataset.cpython-39.pyc b/data/__pycache__/ofa_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b42ef36a258eadaa5051b4856e1588eff512643 Binary files /dev/null and b/data/__pycache__/ofa_dataset.cpython-39.pyc differ diff --git a/data/__pycache__/video_utils.cpython-37.pyc b/data/__pycache__/video_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd56360f979d041f4aa8a403873cb2d0e1011837 Binary files /dev/null and b/data/__pycache__/video_utils.cpython-37.pyc differ diff --git a/data/__pycache__/video_utils.cpython-39.pyc b/data/__pycache__/video_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..548972d07354df5133623c5331e501244f7a0a4a Binary files /dev/null and b/data/__pycache__/video_utils.cpython-39.pyc differ diff --git a/data/audio_utils.py b/data/audio_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..841513b517616922ce3a55eef1fd099b306d3f26 --- /dev/null +++ b/data/audio_utils.py @@ -0,0 +1,199 @@ +# https://github.com/LAION-AI/CLAP/blob/df65ca0f6c3062dc554132cb40e74f4915084b21/src/training/data.py#L469 + +from functools import partial +import soundfile as sf +import io +import numpy as np +import torch + +import torchaudio +import torchvision + +import torch.nn.functional as F + + +AUDIO_CFG = { + "sample_rate": 48000, + "audio_length": 1024, + "clip_samples": 480000, + "mel_bins": 64, + "window_size": 1024, + "hop_size": 480, + "fmin": 50, + "fmax": 14000, + "class_num": 527, + } + +class dotdict(dict): + """dot.notation access to dictionary attributes""" + __getattr__ = dict.get + __setattr__ = dict.__setitem__ + __delattr__ = dict.__delitem__ + +class Map(dict): + """ + Example: + m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer']) + """ + def __init__(self, *args, **kwargs): + super(Map, self).__init__(*args, **kwargs) + for arg in args: + if isinstance(arg, dict): + for k, v in arg.iteritems(): + self[k] = v + + if kwargs: + for k, v in kwargs.iteritems(): + self[k] = v + + def __getattr__(self, attr): + return self.get(attr) + + def __setattr__(self, key, value): + self.__setitem__(key, value) + + def __setitem__(self, key, value): + super(Map, self).__setitem__(key, value) + self.__dict__.update({key: value}) + + def __delattr__(self, item): + self.__delitem__(item) + + def __delitem__(self, key): + super(Map, self).__delitem__(key) + del self.__dict__[key] + + +def int16_to_float32(x): + return (x / 32767.0).astype(np.float32) + + +def float32_to_int16(x): + x = np.clip(x, a_min=-1., a_max=1.) + return (x * 32767.).astype(np.int16) + + +def get_mel(audio_data,audio_cfg): + # mel shape: (n_mels, T) + mel = torchaudio.transforms.MelSpectrogram( + sample_rate=audio_cfg['sample_rate'], + n_fft=audio_cfg['window_size'], + win_length=audio_cfg['window_size'], + hop_length=audio_cfg['hop_size'], + center=True, + pad_mode="reflect", + power=2.0, + norm=None, + onesided=True, + n_mels=audio_cfg['mel_bins'], + f_min=audio_cfg['fmin'], + f_max=audio_cfg['fmax'] + )(audio_data) + + # we use log mel spectrogram as input + mel = torchaudio.transforms.AmplitudeToDB(top_db=None)(mel) + return mel.T # (T, n_mels) + + +def get_audio_features(sample, audio_data, max_len, data_truncating, data_filling, audio_cfg): + """ + Calculate and add audio features to sample. + Sample: a dict containing all the data of current sample. + audio_data: a tensor of shape (T) containing audio data. + max_len: the maximum length of audio data. + data_truncating: the method of truncating data. + data_filling: the method of filling data. + audio_cfg: a dict containing audio configuration. Comes from model_cfg['audio_cfg']. + """ + with torch.no_grad(): + if len(audio_data) > max_len: + if data_truncating == "rand_trunc": + longer = torch.tensor([True]) + elif data_truncating == "fusion": + # fusion + mel = get_mel(audio_data, audio_cfg) + # split to three parts + chunk_frames = max_len // audio_cfg['hop_size']+1 # the +1 related to how the spectrogram is computed + total_frames = mel.shape[0] + if chunk_frames == total_frames: + # there is a corner case where the audio length is + # larger than max_len but smaller than max_len+hop_size. + # In this case, we just use the whole audio. + mel_fusion = torch.stack([mel, mel, mel, mel], dim=0) + sample["mel_fusion"] = mel_fusion + longer = torch.tensor([False]) + else: + ranges = np.array_split(list(range(0, total_frames-chunk_frames+1)), 3) + # print('total_frames-chunk_frames:', total_frames-chunk_frames, + # 'len(audio_data):', len(audio_data), + # 'chunk_frames:', chunk_frames, + # 'total_frames:', total_frames) + if len(ranges[1]) == 0: + # if the audio is too short, we just use the first chunk + ranges[1] = [0] + if len(ranges[2]) == 0: + # if the audio is too short, we just use the first chunk + ranges[2] = [0] + # randomly choose index for each part + idx_front = np.random.choice(ranges[0]) + idx_middle = np.random.choice(ranges[1]) + idx_back = np.random.choice(ranges[2]) + # select mel + mel_chunk_front = mel[idx_front:idx_front+chunk_frames, :] + mel_chunk_middle = mel[idx_middle:idx_middle+chunk_frames, :] + mel_chunk_back = mel[idx_back:idx_back+chunk_frames, :] + + # shrink the mel + mel_shrink = torchvision.transforms.Resize(size=[chunk_frames, 64])(mel[None])[0] + # logging.info(f"mel_shrink.shape: {mel_shrink.shape}") + + # stack + mel_fusion = torch.stack([mel_chunk_front, mel_chunk_middle, mel_chunk_back, mel_shrink], dim=0) + sample["mel_fusion"] = mel_fusion + longer = torch.tensor([True]) + else: + raise NotImplementedError( + f"data_truncating {data_truncating} not implemented" + ) + # random crop to max_len (for compatibility) + overflow = len(audio_data) - max_len + idx = np.random.randint(0, overflow + 1) + audio_data = audio_data[idx: idx + max_len] + + else: # padding if too short + if len(audio_data) < max_len: # do nothing if equal + if data_filling == "repeatpad": + n_repeat = int(max_len/len(audio_data)) + audio_data = audio_data.repeat(n_repeat) + # audio_data = audio_data.unsqueeze(0).unsqueeze(0).unsqueeze(0) + # audio_data = F.interpolate(audio_data,size=max_len,mode="bicubic")[0,0,0] + audio_data = F.pad( + audio_data, + (0, max_len - len(audio_data)), + mode="constant", + value=0, + ) + elif data_filling == "pad": + audio_data = F.pad( + audio_data, + (0, max_len - len(audio_data)), + mode="constant", + value=0, + ) + elif data_filling == "repeat": + n_repeat = int(max_len/len(audio_data)) + audio_data = audio_data.repeat(n_repeat+1)[:max_len] + else: + raise NotImplementedError( + f"data_filling {data_filling} not implemented" + ) + if data_truncating == 'fusion': + mel = get_mel(audio_data, audio_cfg) + mel_fusion = torch.stack([mel, mel, mel, mel], dim=0) + sample["mel_fusion"] = mel_fusion + longer = torch.tensor([False]) + + sample["longer"] = longer + sample["waveform"] = audio_data + + return sample \ No newline at end of file diff --git a/data/data_utils.py b/data/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d45beb1aca2e55b1ca9b2c01ce1a869ad9a2121d --- /dev/null +++ b/data/data_utils.py @@ -0,0 +1,601 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +try: + from collections.abc import Iterable +except ImportError: + from collections import Iterable +import contextlib +import itertools +import logging +import re +import warnings +from typing import Optional, Tuple + +import numpy as np +import torch + +from fairseq.file_io import PathManager +from fairseq import utils +import os + +logger = logging.getLogger(__name__) + + +def infer_language_pair(path): + """Infer language pair from filename: .-.(...).idx""" + src, dst = None, None + for filename in PathManager.ls(path): + parts = filename.split(".") + if len(parts) >= 3 and len(parts[1].split("-")) == 2: + return parts[1].split("-") + return src, dst + + +def collate_tokens( + values, + pad_idx, + eos_idx=None, + left_pad=False, + move_eos_to_beginning=False, + pad_to_length=None, + pad_to_multiple=1, + pad_to_bsz=None, +): + """Convert a list of 1d tensors into a padded 2d tensor.""" + size = max(v.size(0) for v in values) + size = size if pad_to_length is None else max(size, pad_to_length) + if pad_to_multiple != 1 and size % pad_to_multiple != 0: + size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple) + + def copy_tensor(src, dst): + assert dst.numel() == src.numel() + if move_eos_to_beginning: + if eos_idx is None: + # if no eos_idx is specified, then use the last token in src + dst[0] = src[-1] + else: + dst[0] = eos_idx + dst[1:] = src[:-1] + else: + dst.copy_(src) + + if values[0].dim() == 1: + res = values[0].new(len(values), size).fill_(pad_idx) + elif values[0].dim() == 2: + assert move_eos_to_beginning is False + res = values[0].new(len(values), size, values[0].size(1)).fill_(pad_idx) + else: + raise NotImplementedError + + for i, v in enumerate(values): + copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)]) + return res + + +def load_indexed_dataset( + path, dictionary=None, dataset_impl=None, combine=False, default="cached" +): + """A helper function for loading indexed datasets. + + Args: + path (str): path to indexed dataset (e.g., 'data-bin/train') + dictionary (~fairseq.data.Dictionary): data dictionary + dataset_impl (str, optional): which dataset implementation to use. If + not provided, it will be inferred automatically. For legacy indexed + data we use the 'cached' implementation by default. + combine (bool, optional): automatically load and combine multiple + datasets. For example, if *path* is 'data-bin/train', then we will + combine 'data-bin/train', 'data-bin/train1', ... and return a + single ConcatDataset instance. + """ + import fairseq.data.indexed_dataset as indexed_dataset + from fairseq.data.concat_dataset import ConcatDataset + + datasets = [] + for k in itertools.count(): + path_k = path + (str(k) if k > 0 else "") + try: + path_k = indexed_dataset.get_indexed_dataset_to_local(path_k) + except Exception as e: + if "StorageException: [404] Path not found" in str(e): + logger.warning(f"path_k: {e} not found") + else: + raise e + + dataset_impl_k = dataset_impl + if dataset_impl_k is None: + dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k) + dataset = indexed_dataset.make_dataset( + path_k, + impl=dataset_impl_k or default, + fix_lua_indexing=True, + dictionary=dictionary, + ) + if dataset is None: + break + logger.info("loaded {:,} examples from: {}".format(len(dataset), path_k)) + datasets.append(dataset) + if not combine: + break + if len(datasets) == 0: + return None + elif len(datasets) == 1: + return datasets[0] + else: + return ConcatDataset(datasets) + + +@contextlib.contextmanager +def numpy_seed(seed, *addl_seeds): + """Context manager which seeds the NumPy PRNG with the specified seed and + restores the state afterward""" + if seed is None: + yield + return + if len(addl_seeds) > 0: + seed = int(hash((seed, *addl_seeds)) % 1e6) + state = np.random.get_state() + np.random.seed(seed) + try: + yield + finally: + np.random.set_state(state) + + +def collect_filtered(function, iterable, filtered): + """ + Similar to :func:`filter` but collects filtered elements in ``filtered``. + + Args: + function (callable): function that returns ``False`` for elements that + should be filtered + iterable (iterable): iterable to filter + filtered (list): list to store filtered elements + """ + for el in iterable: + if function(el): + yield el + else: + filtered.append(el) + + +def _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False): + def compare_leq(a, b): + return a <= b if not isinstance(a, tuple) else max(a) <= b + + def check_size(idx): + if isinstance(max_positions, float) or isinstance(max_positions, int): + return size_fn(idx) <= max_positions + elif isinstance(max_positions, dict): + idx_size = size_fn(idx) + assert isinstance(idx_size, dict) + intersect_keys = set(max_positions.keys()) & set(idx_size.keys()) + return all( + all( + a is None or b is None or a <= b + for a, b in zip(idx_size[key], max_positions[key]) + ) + for key in intersect_keys + ) + else: + # For MultiCorpusSampledDataset, will generalize it later + if not isinstance(size_fn(idx), Iterable): + return all(size_fn(idx) <= b for b in max_positions) + return all( + a is None or b is None or a <= b + for a, b in zip(size_fn(idx), max_positions) + ) + + ignored = [] + itr = collect_filtered(check_size, indices, ignored) + indices = np.fromiter(itr, dtype=np.int64, count=-1) + return indices, ignored + + +def filter_by_size(indices, dataset, max_positions, raise_exception=False): + """ + [deprecated] Filter indices based on their size. + Use `FairseqDataset::filter_indices_by_size` instead. + + Args: + indices (List[int]): ordered list of dataset indices + dataset (FairseqDataset): fairseq dataset instance + max_positions (tuple): filter elements larger than this size. + Comparisons are done component-wise. + raise_exception (bool, optional): if ``True``, raise an exception if + any elements are filtered (default: False). + """ + warnings.warn( + "data_utils.filter_by_size is deprecated. " + "Use `FairseqDataset::filter_indices_by_size` instead.", + stacklevel=2, + ) + if isinstance(max_positions, float) or isinstance(max_positions, int): + if hasattr(dataset, "sizes") and isinstance(dataset.sizes, np.ndarray): + ignored = indices[dataset.sizes[indices] > max_positions].tolist() + indices = indices[dataset.sizes[indices] <= max_positions] + elif ( + hasattr(dataset, "sizes") + and isinstance(dataset.sizes, list) + and len(dataset.sizes) == 1 + ): + ignored = indices[dataset.sizes[0][indices] > max_positions].tolist() + indices = indices[dataset.sizes[0][indices] <= max_positions] + else: + indices, ignored = _filter_by_size_dynamic( + indices, dataset.size, max_positions + ) + else: + indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions) + + if len(ignored) > 0 and raise_exception: + raise Exception( + ( + "Size of sample #{} is invalid (={}) since max_positions={}, " + "skip this example with --skip-invalid-size-inputs-valid-test" + ).format(ignored[0], dataset.size(ignored[0]), max_positions) + ) + if len(ignored) > 0: + logger.warning( + ( + "{} samples have invalid sizes and will be skipped, " + "max_positions={}, first few sample ids={}" + ).format(len(ignored), max_positions, ignored[:10]) + ) + return indices + + +def filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes): + """Filter a list of sample indices. Remove those that are longer + than specified in max_sizes. + + Args: + indices (np.array): original array of sample indices + max_sizes (int or list[int] or tuple[int]): max sample size, + can be defined separately for src and tgt (then list or tuple) + + Returns: + np.array: filtered sample array + list: list of removed indices + """ + if max_sizes is None: + return indices, [] + if type(max_sizes) in (int, float): + max_src_size, max_tgt_size = max_sizes, max_sizes + else: + max_src_size, max_tgt_size = max_sizes + if tgt_sizes is None: + ignored = indices[src_sizes[indices] > max_src_size] + else: + ignored = indices[ + (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size) + ] + if len(ignored) > 0: + if tgt_sizes is None: + indices = indices[src_sizes[indices] <= max_src_size] + else: + indices = indices[ + (src_sizes[indices] <= max_src_size) + & (tgt_sizes[indices] <= max_tgt_size) + ] + return indices, ignored.tolist() + + +def batch_by_size( + indices, + num_tokens_fn, + num_tokens_vec=None, + max_tokens=None, + max_sentences=None, + required_batch_size_multiple=1, + fixed_shapes=None, +): + """ + Yield mini-batches of indices bucketed by size. Batches may contain + sequences of different lengths. + + Args: + indices (List[int]): ordered list of dataset indices + num_tokens_fn (callable): function that returns the number of tokens at + a given index + num_tokens_vec (List[int], optional): precomputed vector of the number + of tokens for each index in indices (to enable faster batch generation) + max_tokens (int, optional): max number of tokens in each batch + (default: None). + max_sentences (int, optional): max number of sentences in each + batch (default: None). + required_batch_size_multiple (int, optional): require batch size to + be less than N or a multiple of N (default: 1). + fixed_shapes (List[Tuple[int, int]], optional): if given, batches will + only be created with the given shapes. *max_sentences* and + *required_batch_size_multiple* will be ignored (default: None). + """ + try: + from fairseq.data.data_utils_fast import ( + batch_by_size_fn, + batch_by_size_vec, + batch_fixed_shapes_fast, + ) + except ImportError: + raise ImportError( + "Please build Cython components with: " + "`python setup.py build_ext --inplace`" + ) + except ValueError: + raise ValueError( + "Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`." + ) + + # added int() to avoid TypeError: an integer is required + max_tokens = ( + int(max_tokens) if max_tokens is not None else -1 + ) + max_sentences = max_sentences if max_sentences is not None else -1 + bsz_mult = required_batch_size_multiple + + if not isinstance(indices, np.ndarray): + indices = np.fromiter(indices, dtype=np.int64, count=-1) + + if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray): + num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1) + + if fixed_shapes is None: + if num_tokens_vec is None: + return batch_by_size_fn( + indices, + num_tokens_fn, + max_tokens, + max_sentences, + bsz_mult, + ) + else: + return batch_by_size_vec( + indices, + num_tokens_vec, + max_tokens, + max_sentences, + bsz_mult, + ) + + else: + fixed_shapes = np.array(fixed_shapes, dtype=np.int64) + sort_order = np.lexsort( + [ + fixed_shapes[:, 1].argsort(), # length + fixed_shapes[:, 0].argsort(), # bsz + ] + ) + fixed_shapes_sorted = fixed_shapes[sort_order] + return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted) + + +def post_process(sentence: str, symbol: str): + if symbol == "sentencepiece": + sentence = sentence.replace(" ", "").replace("\u2581", " ").strip() + elif symbol == "wordpiece": + sentence = sentence.replace(" ", "").replace("_", " ").strip() + elif symbol == "letter": + sentence = sentence.replace(" ", "").replace("|", " ").strip() + elif symbol == "silence": + import re + sentence = sentence.replace("", "") + sentence = re.sub(' +', ' ', sentence).strip() + elif symbol == "_EOW": + sentence = sentence.replace(" ", "").replace("_EOW", " ").strip() + elif symbol in {"subword_nmt", "@@ ", "@@"}: + if symbol == "subword_nmt": + symbol = "@@ " + sentence = (sentence + " ").replace(symbol, "").rstrip() + elif symbol == "none": + pass + elif symbol is not None: + raise NotImplementedError(f"Unknown post_process option: {symbol}") + return sentence + + +def compute_mask_indices( + shape: Tuple[int, int], + padding_mask: Optional[torch.Tensor], + mask_prob: float, + mask_length: int, + mask_type: str = "static", + mask_other: float = 0.0, + min_masks: int = 0, + no_overlap: bool = False, + min_space: int = 0, +) -> np.ndarray: + """ + Computes random mask spans for a given shape + + Args: + shape: the the shape for which to compute masks. + should be of size 2 where first element is batch size and 2nd is timesteps + padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements + mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by + number of timesteps divided by length of mask span to mask approximately this percentage of all elements. + however due to overlaps, the actual number will be smaller (unless no_overlap is True) + mask_type: how to compute mask lengths + static = fixed size + uniform = sample from uniform distribution [mask_other, mask_length*2] + normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element + poisson = sample from possion distribution with lambda = mask length + min_masks: minimum number of masked spans + no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping + min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans + """ + + bsz, all_sz = shape + mask = np.full((bsz, all_sz), False) + + all_num_mask = int( + # add a random number for probabilistic rounding + mask_prob * all_sz / float(mask_length) + + np.random.rand() + ) + + all_num_mask = max(min_masks, all_num_mask) + + mask_idcs = [] + for i in range(bsz): + if padding_mask is not None: + sz = all_sz - padding_mask[i].long().sum().item() + num_mask = int( + # add a random number for probabilistic rounding + mask_prob * sz / float(mask_length) + + np.random.rand() + ) + num_mask = max(min_masks, num_mask) + else: + sz = all_sz + num_mask = all_num_mask + + if mask_type == "static": + lengths = np.full(num_mask, mask_length) + elif mask_type == "uniform": + lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask) + elif mask_type == "normal": + lengths = np.random.normal(mask_length, mask_other, size=num_mask) + lengths = [max(1, int(round(x))) for x in lengths] + elif mask_type == "poisson": + lengths = np.random.poisson(mask_length, size=num_mask) + lengths = [int(round(x)) for x in lengths] + else: + raise Exception("unknown mask selection " + mask_type) + + if sum(lengths) == 0: + lengths[0] = min(mask_length, sz - 1) + + if no_overlap: + mask_idc = [] + + def arrange(s, e, length, keep_length): + span_start = np.random.randint(s, e - length) + mask_idc.extend(span_start + i for i in range(length)) + + new_parts = [] + if span_start - s - min_space >= keep_length: + new_parts.append((s, span_start - min_space + 1)) + if e - span_start - keep_length - min_space > keep_length: + new_parts.append((span_start + length + min_space, e)) + return new_parts + + parts = [(0, sz)] + min_length = min(lengths) + for length in sorted(lengths, reverse=True): + lens = np.fromiter( + (e - s if e - s >= length + min_space else 0 for s, e in parts), + np.int, + ) + l_sum = np.sum(lens) + if l_sum == 0: + break + probs = lens / np.sum(lens) + c = np.random.choice(len(parts), p=probs) + s, e = parts.pop(c) + parts.extend(arrange(s, e, length, min_length)) + mask_idc = np.asarray(mask_idc) + else: + min_len = min(lengths) + if sz - min_len <= num_mask: + min_len = sz - num_mask - 1 + + mask_idc = np.random.choice(sz - min_len, num_mask, replace=False) + + mask_idc = np.asarray( + [ + mask_idc[j] + offset + for j in range(len(mask_idc)) + for offset in range(lengths[j]) + ] + ) + + mask_idcs.append(np.unique(mask_idc[mask_idc < sz])) + + min_len = min([len(m) for m in mask_idcs]) + for i, mask_idc in enumerate(mask_idcs): + if len(mask_idc) > min_len: + mask_idc = np.random.choice(mask_idc, min_len, replace=False) + mask[i, mask_idc] = True + + return mask + + +def get_mem_usage(): + try: + import psutil + + mb = 1024 * 1024 + return f"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb" + except ImportError: + return "N/A" + + +# lens: torch.LongTensor +# returns: torch.BoolTensor +def lengths_to_padding_mask(lens): + bsz, max_lens = lens.size(0), torch.max(lens).item() + mask = torch.arange(max_lens).to(lens.device).view(1, max_lens) + mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens) + return mask + + +# lens: torch.LongTensor +# returns: torch.BoolTensor +def lengths_to_mask(lens): + return ~lengths_to_padding_mask(lens) + + +def get_buckets(sizes, num_buckets): + buckets = np.unique( + np.percentile( + sizes, + np.linspace(0, 100, num_buckets + 1), + interpolation='lower', + )[1:] + ) + return buckets + + +def get_bucketed_sizes(orig_sizes, buckets): + sizes = np.copy(orig_sizes) + assert np.min(sizes) >= 0 + start_val = -1 + for end_val in buckets: + mask = (sizes > start_val) & (sizes <= end_val) + sizes[mask] = end_val + start_val = end_val + return sizes + + + +def _find_extra_valid_paths(dataset_path: str) -> set: + paths = utils.split_paths(dataset_path) + all_valid_paths = set() + for sub_dir in paths: + contents = PathManager.ls(sub_dir) + valid_paths = [c for c in contents if re.match("valid*[0-9].*", c) is not None] + all_valid_paths |= {os.path.basename(p) for p in valid_paths} + # Remove .bin, .idx etc + roots = {os.path.splitext(p)[0] for p in all_valid_paths} + return roots + + +def raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None: + """Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.""" + if ( + train_cfg.dataset.ignore_unused_valid_subsets + or train_cfg.dataset.combine_valid_subsets + or train_cfg.dataset.disable_validation + or not hasattr(train_cfg.task, "data") + ): + return + other_paths = _find_extra_valid_paths(train_cfg.task.data) + specified_subsets = train_cfg.dataset.valid_subset.split(",") + ignored_paths = [p for p in other_paths if p not in specified_subsets] + if ignored_paths: + advice = "Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them." + msg = f"Valid paths {ignored_paths} will be ignored. {advice}" + raise ValueError(msg) diff --git a/data/file_dataset.py b/data/file_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..785e3abc951ee1c5346f6799daeab46682d2569a --- /dev/null +++ b/data/file_dataset.py @@ -0,0 +1,113 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import os +import torch +import pickle + + +class FileDataset: + def __init__(self, file_path, selected_col_ids=None, dtypes=None, separator="\t", cached_index=False): + self.file_path = file_path + assert os.path.exists(self.file_path), "Error: The local datafile {} not exists!".format(self.file_path) + + self.separator = separator + if selected_col_ids is None: + # default to all fields + self.selected_col_ids = list( + range(len(open(self.file_path).readline().rstrip("\n").split(self.separator)))) + else: + self.selected_col_ids = [int(col_id) for col_id in selected_col_ids.split(",")] + if dtypes is None: + # default to str + self.dtypes = [str for col_id in self.selected_col_ids] + else: + self.dtypes = [eval(col_dtype) for col_dtype in dtypes.split(",")] + assert len(self.dtypes) == len(self.selected_col_ids) + + self.data_cnt = 0 + try: + self.slice_id = torch.distributed.get_rank() + self.slice_count = torch.distributed.get_world_size() + except Exception: + self.slice_id = 0 + self.slice_count = 1 + self.cached_index = cached_index + self._init_seek_index() + self._reader = self._get_reader() + print("file {} slice_id {} row count {} total row count {}".format( + self.file_path, self.slice_id, self.row_count, self.total_row_count) + ) + + def _init_seek_index(self): + if self.cached_index: + cache_path = "{}.index".format(self.file_path) + assert os.path.exists(cache_path), "cache file {} not exists!".format(cache_path) + self.total_row_count, self.lineid_to_offset = pickle.load(open(cache_path, "rb")) + print("local datafile {} slice_id {} use cached row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + else: + # make an iteration over the file to get row_count and line_idx-to-offset mapping + fp = open(self.file_path, "rb") + print("local datafile {} slice_id {} begin to initialize row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + self.total_row_count = 0 + offset = 0 + self.lineid_to_offset = [] + for line in fp: + self.lineid_to_offset.append(offset) + self.total_row_count += 1 + # offset += len(line.encode('utf-8')) + offset += len(line) #fp.tell() #len(line) + self._compute_start_pos_and_row_count() + print("local datafile {} slice_id {} finished initializing row_count and line_idx-to-offset mapping".format( + self.file_path, self.slice_id)) + + def _compute_start_pos_and_row_count(self): + self.row_count = self.total_row_count // self.slice_count + if self.slice_id < self.total_row_count - self.row_count * self.slice_count: + self.row_count += 1 + self.start_pos = self.row_count * self.slice_id + else: + self.start_pos = self.row_count * self.slice_id + (self.total_row_count - self.row_count * self.slice_count) + + def _get_reader(self): + fp = open(self.file_path, "r") + fp.seek(self.lineid_to_offset[self.start_pos]) + return fp + + def _seek(self, offset=0): + try: + print("slice_id {} seek offset {}".format(self.slice_id, self.start_pos + offset)) + self._reader.seek(self.lineid_to_offset[self.start_pos + offset]) + self.data_cnt = offset + except Exception: + print("slice_id {} seek offset {}".format(self.slice_id, offset)) + self._reader.seek(self.lineid_to_offset[offset]) + self.data_cnt = offset + + def __del__(self): + self._reader.close() + + def __len__(self): + return self.row_count + + def get_total_row_count(self): + return self.total_row_count + + def __getitem__(self, index): + if self.data_cnt == self.row_count: + print("reach the end of datafile, start a new reader") + self.data_cnt = 0 + self._reader = self._get_reader() + column_l = self._reader.readline().rstrip("\n").split(self.separator) + + self.data_cnt += 1 + # try: + column_l = [dtype(column_l[col_id]) for col_id, dtype in zip(self.selected_col_ids, self.dtypes)] + # except: + # print(column_l, self.data_cnt, self.start_pos, self.slice_id) + # print(self._reader.readline().rstrip("\n").split(self.separator)) + return column_l diff --git a/data/mm_data/__init__.py b/data/mm_data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/data/mm_data/__pycache__/__init__.cpython-37.pyc b/data/mm_data/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9cc96a919a52349508b0418b24a37ec845fa2e4e Binary files /dev/null and b/data/mm_data/__pycache__/__init__.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/__init__.cpython-38.pyc b/data/mm_data/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3f80c5c42fc1db7fbe333cab6ea538ed2f1f04d Binary files /dev/null and b/data/mm_data/__pycache__/__init__.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/__init__.cpython-39.pyc b/data/mm_data/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea34f6f80defd44f6fdb624dfb6fdd6386c588d1 Binary files /dev/null and b/data/mm_data/__pycache__/__init__.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/audio_caption_dataset.cpython-37.pyc b/data/mm_data/__pycache__/audio_caption_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..408a8101e91bb4f79b10c86fd32adb2d54d5889b Binary files /dev/null and b/data/mm_data/__pycache__/audio_caption_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/audio_caption_dataset.cpython-39.pyc b/data/mm_data/__pycache__/audio_caption_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61ebf49f606f037ae7975ed5a818449f7bf2010e Binary files /dev/null and b/data/mm_data/__pycache__/audio_caption_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/caption_dataset.cpython-37.pyc b/data/mm_data/__pycache__/caption_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f67c6aac8feff7c88cd5b63918eda0f19d93a307 Binary files /dev/null and b/data/mm_data/__pycache__/caption_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/caption_dataset.cpython-38.pyc b/data/mm_data/__pycache__/caption_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37124af1221e6ed911791e0bfe176bf84757ac19 Binary files /dev/null and b/data/mm_data/__pycache__/caption_dataset.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/caption_dataset.cpython-39.pyc b/data/mm_data/__pycache__/caption_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b85aee3dd701d53b0357e55ac66950279f7f9213 Binary files /dev/null and b/data/mm_data/__pycache__/caption_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/image_gen_dataset.cpython-37.pyc b/data/mm_data/__pycache__/image_gen_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f281d2dfd2903dddcb3caf4531f2ce1a4cfed006 Binary files /dev/null and b/data/mm_data/__pycache__/image_gen_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/image_gen_dataset.cpython-38.pyc b/data/mm_data/__pycache__/image_gen_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a07f3184fee42b55f7eeff2ba657a7d6225e5d5b Binary files /dev/null and b/data/mm_data/__pycache__/image_gen_dataset.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/image_gen_dataset.cpython-39.pyc b/data/mm_data/__pycache__/image_gen_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..618e6d912165c3b67fb5b44332a44c008a035707 Binary files /dev/null and b/data/mm_data/__pycache__/image_gen_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/refcoco_dataset.cpython-37.pyc b/data/mm_data/__pycache__/refcoco_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8915b158ed164820216f16023cc50744490ed9c Binary files /dev/null and b/data/mm_data/__pycache__/refcoco_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/refcoco_dataset.cpython-38.pyc b/data/mm_data/__pycache__/refcoco_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..171d1ef131763c53719aed13651dfd276bcdb0e8 Binary files /dev/null and b/data/mm_data/__pycache__/refcoco_dataset.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/refcoco_dataset.cpython-39.pyc b/data/mm_data/__pycache__/refcoco_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0a74358520145fbe043e90d2f41ae7f9f24f934 Binary files /dev/null and b/data/mm_data/__pycache__/refcoco_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/snli_ve_dataset.cpython-37.pyc b/data/mm_data/__pycache__/snli_ve_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e86e9c93a00494d3f7e221853393a0eb15cb63f Binary files /dev/null and b/data/mm_data/__pycache__/snli_ve_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/snli_ve_dataset.cpython-38.pyc b/data/mm_data/__pycache__/snli_ve_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6473259b100bd2735f47b8e48ff3b1abf07d1cf1 Binary files /dev/null and b/data/mm_data/__pycache__/snli_ve_dataset.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/snli_ve_dataset.cpython-39.pyc b/data/mm_data/__pycache__/snli_ve_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c5934a7d67c4168480659c176f87396cb4a69e7 Binary files /dev/null and b/data/mm_data/__pycache__/snli_ve_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/video_caption_dataset.cpython-37.pyc b/data/mm_data/__pycache__/video_caption_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..455ae64ce50e75cf5696a96281b98d62f7c1196c Binary files /dev/null and b/data/mm_data/__pycache__/video_caption_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/video_caption_dataset.cpython-39.pyc b/data/mm_data/__pycache__/video_caption_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a13a8b39a2e3c61edf3c75da828cfcee06a48150 Binary files /dev/null and b/data/mm_data/__pycache__/video_caption_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-37.pyc b/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24def918d420e373bacf49ec981c43586dda689e Binary files /dev/null and b/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-39.pyc b/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0eb079847f4856a64c354fd48fdd8b011bd80e41 Binary files /dev/null and b/data/mm_data/__pycache__/video_vqa_gen_dataset.cpython-39.pyc differ diff --git a/data/mm_data/__pycache__/vqa_gen_dataset.cpython-37.pyc b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6b507f7ac6f75a0905793423be808500752e42c Binary files /dev/null and b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-37.pyc differ diff --git a/data/mm_data/__pycache__/vqa_gen_dataset.cpython-38.pyc b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7634670548700371efa3a52c4b2faf515d1dcec3 Binary files /dev/null and b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-38.pyc differ diff --git a/data/mm_data/__pycache__/vqa_gen_dataset.cpython-39.pyc b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bcb558f22cf11c56f4ec0839cd8b95180dcf43d6 Binary files /dev/null and b/data/mm_data/__pycache__/vqa_gen_dataset.cpython-39.pyc differ diff --git a/data/mm_data/audio_caption_dataset.py b/data/mm_data/audio_caption_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..bbb0b53180b6790b2abbe51ebed03119f1e3188c --- /dev/null +++ b/data/mm_data/audio_caption_dataset.py @@ -0,0 +1,254 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings +import string + +import numpy as np +import torch + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + + +import os +import random + +import soundfile as sf + +import torchaudio + + +from data.audio_utils import get_audio_features, int16_to_float32, float32_to_int16, AUDIO_CFG + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + + + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + patch_videos = torch.stack([sample['patch_video'] for sample in samples], dim=0) + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + patch_audios = torch.stack([sample['patch_audio'] for sample in samples], dim=0) + + + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + "patch_videos": patch_videos, + "patch_types": patch_types, + "patch_audios": patch_audios, + }, + "target": target, + } + + return batch + + +class CaptionDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_tgt_length=30, + patch_image_size=224, + imagenet_default_mean_and_std=False, + scst=False, + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + audio_cfg=AUDIO_CFG, + max_audio_len = 480000, + num_frames=4, + sample_rate = 48000, + audio_sample_rate=False, + ast=False, + mode='train', + mel_bins=64, + + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + self.scst = scst + + self.image_dir = image_dir + + self.sample_rate = sample_rate + + self.transtab = str.maketrans({key: None for key in string.punctuation}) + + + # video + self.num_frames = num_frames + + # audio + self.audio_cfg = audio_cfg + self.max_audio_len = max_audio_len + + self.audio_sample_rate = audio_sample_rate + + + + if type(bpe).__name__ == 'GPT2BPE': + self.prompt = " what does the video describe?" + else: + raise NotImplemented + + # for AST encoder + self.ast = ast + self.target_length = 1024 # 1024 + self.mode = split # train + self.freqm_p = 24 + self.timem_p = 96 + self.skip_norm = False + self.noise = False + self.norm_mean = -4.2677393 + self.norm_std = 4.5689974 + self.freqm = torchaudio.transforms.FrequencyMasking(self.freqm_p) + self.timem = torchaudio.transforms.TimeMasking(self.timem_p) + self.mel_bins = mel_bins + + def __getitem__(self, index): + uniq_id, image, caption = self.dataset[index] + + + # audio + image_path = os.path.join(self.image_dir, image) + data_path = image_path + + + try: + + # load the waveform of the shape (T,), should resample to 48000 + if not self.audio_sample_rate: + audio_data, orig_sr = sf.read(data_path) # no sample rate + if audio_data.ndim>1: + audio_data = np.mean(audio_data,axis=1) + audio_data = int16_to_float32(float32_to_int16(audio_data)) + audio_data = torch.tensor(audio_data).float() # (T) + else: + audio_data, orig_sr = torchaudio.load(data_path) + audio_data = torchaudio.transforms.Resample(orig_sr, self.sample_rate)(audio_data[0]) + + sample = {} + + sample = get_audio_features( + sample, audio_data, self.max_audio_len, + data_truncating='rand_trunc', + data_filling='repeatpad', + audio_cfg=self.audio_cfg + ) + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading video {data_path}, " + f"randomly sample a new video as replacement" + ) + return self.__getitem__(new_index) + + waveform = sample['waveform'] + patch_audio = waveform + + + patch_type = torch.tensor([2]) + + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_video = torch.zeros((3, self.num_frames, self.patch_image_size, self.patch_image_size)) + + + patch_mask = torch.tensor([True]) + + if self.split == 'train' and not self.scst: + caption = caption.translate(self.transtab).strip() + caption_token_list = caption.strip().split() + tgt_caption = ' '.join(caption_token_list[:self.max_tgt_length]) + else: + caption = ' '.join(caption.strip().split()) + caption_list = [cap.translate(self.transtab).strip() for cap in caption.strip().split('&&')] + tgt_caption = '&&'.join(caption_list) + src_item = self.encode_text(self.prompt) + tgt_item = self.encode_text(" {}".format(tgt_caption)) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "patch_type": patch_type, + "patch_video": patch_video, + "patch_audio": patch_audio, + } + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/caption_dataset.py b/data/mm_data/caption_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..cb95b6b6d766103556c1ccd0ea458edc7dfe740d --- /dev/null +++ b/data/mm_data/caption_dataset.py @@ -0,0 +1,195 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings +import string + +import numpy as np +import torch +import base64 +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + +from utils.vision_helper import RandomAugment +import utils.transforms as T + +import os + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + "patch_types": patch_types, + }, + "target": target, + } + + + return batch + + +class CaptionDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_tgt_length=30, + patch_image_size=224, + imagenet_default_mean_and_std=False, + scst=False, + use_dataaug=False, + read_from_img_path=False, + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + self.scst = scst + + self.transtab = str.maketrans({key: None for key in string.punctuation}) + + self.read_from_img_path = read_from_img_path + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + self.split = split + if self.split != 'train' or not use_dataaug: + self.patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((patch_image_size, patch_image_size), interpolation=Image.BICUBIC), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ]) + else: + scales = np.arange(patch_image_size, 481).tolist() + self.patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + T.RandomResize(scales, max_size=672), + transforms.CenterCrop(patch_image_size), + RandomAugment(2, 7, isPIL=True, augs=['Identity', 'AutoContrast', 'Equalize', 'Brightness', 'Sharpness', + 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ]) + + if type(bpe).__name__ == 'GPT2BPE': + self.prompt = " what does the image describe?" + elif type(bpe).__name__ == 'BertBPE': + self.prompt = "图片描述了什么内容?" + + self.image_dir = image_dir + + def __getitem__(self, index): + uniq_id, image, caption = self.dataset[index] + + if self.read_from_img_path or '.jpg' in image: + image_path = os.path.join(self.image_dir, image) + image = Image.open(image_path).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))) + + patch_image = self.patch_resize_transform(image) + patch_mask = torch.tensor([True]) + + if self.split == 'train' and not self.scst: + caption = caption.translate(self.transtab).strip() + caption_token_list = caption.strip().split() + tgt_caption = ' '.join(caption_token_list[:self.max_tgt_length]) + else: + caption = ' '.join(caption.strip().split()) + caption_list = [cap.translate(self.transtab).strip() for cap in caption.strip().split('&&')] + tgt_caption = '&&'.join(caption_list) + src_item = self.encode_text(self.prompt) + tgt_item = self.encode_text(" {}".format(tgt_caption)) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + patch_type = torch.tensor([0]) + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "patch_type": patch_type, + } + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/image_gen_dataset.py b/data/mm_data/image_gen_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..c78b7358fe3c4a1b7b401c5718f898e9c57732ce --- /dev/null +++ b/data/mm_data/image_gen_dataset.py @@ -0,0 +1,171 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings +import base64 +import random + +import numpy as np +import torch + +from PIL import Image, ImageFile +from itertools import chain +from data.ofa_dataset import OFADataset +from data import data_utils + +from PIL import Image +from io import BytesIO +import base64 + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + + +def collate( + samples, + pad_idx, + eos_idx, + left_pad_source=False, + left_pad_target=False, +): + if len(samples) == 0: + return {} + + def merge(key, left_pad, move_eos_to_beginning=False): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx, + left_pad, + move_eos_to_beginning, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source", left_pad=left_pad_source) + # sort by descending source length + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + code_images = np.array([s["code_image"] for s in samples]) + code_masks = torch.cat([sample['code_mask'] for sample in samples]) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target", left_pad=left_pad_target) + tgt_lengths = torch.LongTensor( + [s["target"].ne(pad_idx).long().sum() for s in samples] + ) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens", left_pad=left_pad_target) + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "code_masks": code_masks, + "prev_output_tokens": prev_output_tokens + }, + "code_images": code_images, + "target": target + } + + return batch + + +def preprocess_vqgan(x): + x = 2. * x - 1. + return x + + +class ImageGenDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + code_dict_size=8192, + code_image_size=256, + num_bins=1000 + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + + self.code_dict_size = code_dict_size + self.num_codes = (code_image_size // 8) ** 2 + self.num_bins = num_bins + + slice_id = self.dataset.slice_id + empty_img = Image.new('RGB', (code_image_size, code_image_size)) + empty_img.save(f'temp_{slice_id}.png') + img = Image.open(f'temp_{slice_id}.png') + img_buffer = BytesIO() + img.save(img_buffer, format=img.format) + byte_data = img_buffer.getvalue() + self.empty_image_base64 = base64.urlsafe_b64encode(byte_data) + + def __getitem__(self, index): + + data = self.dataset[index] + if len(data) == 2: + uniq_id, text = data + image_code = [0] * 1024 + image = self.empty_image_base64 + elif len(data) == 3: + uniq_id, text, image_code = data + image_code = [int(num) for num in image_code.strip().split()] + image = self.empty_image_base64 + elif len(data) == 4: + uniq_id, image, text, image_code = data + image_code = [int(num) for num in image_code.strip().split()] + else: + raise NotImplementedError + code_mask = torch.tensor([True]) + image_code = torch.LongTensor(image_code) + tgt_item = image_code + len(self.src_dict) - self.code_dict_size - self.num_bins + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + caption_token_list = text.strip().split() + caption = ' '.join(caption_token_list[:self.max_src_length]) + src_item = self.encode_text( + " what is the complete image? caption: {}".format(caption), + append_bos=True, + append_eos=True + ) + example = { + "id": uniq_id, + "source": src_item, + "code_mask": code_mask, + "code_image": image, + "target": target_item, + "prev_output_tokens": prev_output_item + } + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/refcoco_dataset.py b/data/mm_data/refcoco_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..b9484c4c17c8f5264c159b43980ff8b6070b66e8 --- /dev/null +++ b/data/mm_data/refcoco_dataset.py @@ -0,0 +1,174 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings + +import numpy as np +import torch +import base64 +import utils.transforms as T + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + w_resize_ratios = torch.stack([s["w_resize_ratio"] for s in samples], dim=0) + h_resize_ratios = torch.stack([s["h_resize_ratio"] for s in samples], dim=0) + region_coords = torch.stack([s['region_coord'] for s in samples], dim=0) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + }, + "target": target, + "w_resize_ratios": w_resize_ratios, + "h_resize_ratios": h_resize_ratios, + "region_coords": region_coords + } + + return batch + + +class RefcocoDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=80, + max_tgt_length=30, + patch_image_size=512, + imagenet_default_mean_and_std=False, + num_bins=1000, + max_image_size=512 + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + self.num_bins = num_bins + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + # for positioning + self.positioning_transform = T.Compose([ + T.RandomResize([patch_image_size], max_size=patch_image_size), + T.ToTensor(), + T.Normalize(mean=mean, std=std, max_image_size=max_image_size) + ]) + + if type(bpe).__name__ == 'GPT2BPE': + self.prompt = ' which region does the text " {} " describe?' + elif type(bpe).__name__ == 'BertBPE': + self.prompt = '这段文字" {} "描述的是哪个区域？' + + def __getitem__(self, index): + uniq_id, base64_str, text, region_coord = self.dataset[index] + + image = Image.open(BytesIO(base64.urlsafe_b64decode(base64_str))).convert("RGB") + w, h = image.size + boxes_target = {"boxes": [], "labels": [], "area": [], "size": torch.tensor([h, w])} + x0, y0, x1, y1 = region_coord.strip().split(',') + region = torch.tensor([float(x0), float(y0), float(x1), float(y1)]) + boxes_target["boxes"] = torch.tensor([[float(x0), float(y0), float(x1), float(y1)]]) + boxes_target["labels"] = np.array([0]) + boxes_target["area"] = torch.tensor([(float(x1) - float(x0)) * (float(y1) - float(y0))]) + + patch_image, patch_boxes = self.positioning_transform(image, boxes_target) + resize_h, resize_w = patch_boxes["size"][0], patch_boxes["size"][1] + patch_mask = torch.tensor([True]) + quant_x0 = "".format(int((patch_boxes["boxes"][0][0] * (self.num_bins - 1)).round())) + quant_y0 = "".format(int((patch_boxes["boxes"][0][1] * (self.num_bins - 1)).round())) + quant_x1 = "".format(int((patch_boxes["boxes"][0][2] * (self.num_bins - 1)).round())) + quant_y1 = "".format(int((patch_boxes["boxes"][0][3] * (self.num_bins - 1)).round())) + region_coord = "{} {} {} {}".format(quant_x0, quant_y0, quant_x1, quant_y1) + src_caption = self.pre_caption(text, self.max_src_length) + src_item = self.encode_text(self.prompt.format(src_caption)) + tgt_item = self.encode_text(region_coord, use_bpe=False) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "w_resize_ratio": resize_w / w, + "h_resize_ratio": resize_h / h, + "region_coord": region + } + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/snli_ve_dataset.py b/data/mm_data/snli_ve_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..b086340835e99268f25acf060e5d8c12856d3bce --- /dev/null +++ b/data/mm_data/snli_ve_dataset.py @@ -0,0 +1,204 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings + +import numpy as np +import torch +import base64 +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + ref_dict = None + if samples[0].get("ref_dict", None) is not None: + ref_dict = np.array([s['ref_dict'] for s in samples]) + + constraint_masks = None + if samples[0].get("constraint_mask", None) is not None: + constraint_masks = merge("constraint_mask") + + decoder_prompts = None + if samples[0].get("decoder_prompt", None) is not None: + decoder_prompts = np.array([s['decoder_prompt'].tolist() for s in samples]) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor( + [s["target"].ne(pad_idx).long().sum() for s in samples] + ) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens + }, + "ref_dict": ref_dict, + "constraint_masks": constraint_masks, + "decoder_prompts": decoder_prompts, + "target": target + } + + return batch + + +class SnliVeDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=80, + max_tgt_length=30, + patch_image_size=224, + add_caption=False, + constraint_trie=None, + imagenet_default_mean_and_std=False, + prompt_type="none" + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + + self.add_caption = add_caption + self.constraint_trie = constraint_trie + self.prompt_type = prompt_type + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + self.patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((patch_image_size, patch_image_size), interpolation=Image.BICUBIC), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ]) + + def __getitem__(self, index): + uniq_id, image, hypothesis, caption, label = self.dataset[index] + if label == 'contradiction': + label = 'no' + elif label == 'entailment': + label = 'yes' + elif label == 'neutral': + label = 'maybe' + else: + raise NotImplementedError + + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))) + patch_image = self.patch_resize_transform(image) + patch_mask = torch.tensor([True]) + + hypothesis = self.pre_caption(hypothesis, self.max_src_length) + src_item = self.encode_text(' does the image describe " {} "?'.format(hypothesis)) + tgt_item = self.encode_text(" {}".format(label)) + ref_dict = {label: 1.0} + + # print(self.add_caption) + if self.add_caption: + caption = self.pre_caption(caption, self.max_src_length) + src_item = self.encode_text(' can image and text1 " {} " imply text2 " {} "?'.format(caption, hypothesis)) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + if self.prompt_type == 'none': + prev_output_item = torch.cat([self.bos_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = self.bos_item + elif self.prompt_type == 'src': + prev_output_item = torch.cat([src_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item + elif self.prompt_type == 'prev_output': + prev_output_item = torch.cat([src_item[:-1], tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item[:-1] + else: + raise NotImplementedError + target_item[:-len(tgt_item)-1] = self.tgt_dict.pad() + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "decoder_prompt": decoder_prompt, + "ref_dict": ref_dict, + } + if self.constraint_trie is not None: + constraint_mask = torch.zeros((len(target_item), len(self.tgt_dict))).bool() + start_idx = len(target_item) - len(tgt_item) - 1 + for i in range(len(target_item)-len(tgt_item)-1, len(target_item)): + constraint_prefix_token = [self.tgt_dict.bos()] + target_item[start_idx:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + example["constraint_mask"] = constraint_mask + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/video_caption_dataset.py b/data/mm_data/video_caption_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..da0567003293658a5b3c3686b6f43f0e7a1cdc24 --- /dev/null +++ b/data/mm_data/video_caption_dataset.py @@ -0,0 +1,248 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + + +import logging +import warnings +import string + +import numpy as np +import torch +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +from data.video_utils import VIDEO_READER_FUNCS + +import os +import random + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + patch_videos = torch.stack([sample['patch_video'] for sample in samples], dim=0) + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + "patch_videos": patch_videos, + "patch_types": patch_types, + }, + "target": target, + } + + return batch + + +class CaptionDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_tgt_length=30, + patch_image_size=224, + imagenet_default_mean_and_std=False, + scst=False, + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + patch_frame_size=224, + num_frames=4, + sample_type='rand', + use_dataaug=False, + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + self.scst = scst + + self.image_dir = image_dir + + self.transtab = str.maketrans({key: None for key in string.punctuation}) + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + + + self.split = split + type_transform = transforms.Lambda(lambda x: x.float().div(255.0)) + if self.split != 'train' or not use_dataaug: + self.patch_video_resize_transform = transforms.Compose([ + transforms.CenterCrop(patch_frame_size), + type_transform, + transforms.Normalize(mean=mean, std=std), + ]) + logger.info("val split, do not use random augmentation.") + else: + aug_transform = transforms.RandAugment() + self.patch_video_resize_transform = transforms.Compose( + [ + aug_transform, + transforms.RandomResizedCrop( + patch_frame_size, + scale=(0.5, 1.0), + interpolation=transforms.InterpolationMode.BICUBIC, + ), + transforms.RandomHorizontalFlip(), + type_transform, + transforms.Normalize(mean=mean, std=std), + ] + ) + + + logger.info("train split, use random augmentation.") + + + # video + self.num_frames = num_frames + self.sample_type = sample_type + self.video_reader = VIDEO_READER_FUNCS['decord'] + self.max_num_frames = num_frames + if type(bpe).__name__ == 'GPT2BPE': + self.prompt = " what does the video describe?" + else: + raise NotImplemented + + self.num_tries = 4 + + def __getitem__(self, index, tries=0, other_dataset=None): + uniq_id, image, caption = self.dataset[index] + + + # video + image_path = os.path.join(self.image_dir, image) + data_path = image_path + + max_num_frames = self.max_num_frames + + + try: + + frames, frame_indices, video_duration = self.video_reader( + data_path, self.num_frames, self.sample_type, max_num_frames=max_num_frames + ) + + + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading video {data_path}, " + f"randomly sample a new video as replacement" + ) + if tries < self.num_tries: + return self.__getitem__(new_index, tries=tries+1, other_dataset=other_dataset) + else: + print("Videos are too corrupted, try increase the num_tries") + raise + + + + + + patch_video = self.patch_video_resize_transform(frames) + patch_video = patch_video.permute(1, 0, 2, 3) # -> (C, T, h, w) + + + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_type = torch.tensor([1]) + + + + + patch_mask = torch.tensor([True]) + + if self.split == 'train' and not self.scst: + caption = caption.translate(self.transtab).strip() + caption_token_list = caption.strip().split() + tgt_caption = ' '.join(caption_token_list[:self.max_tgt_length]) + else: + caption = ' '.join(caption.strip().split()) + caption_list = [cap.translate(self.transtab).strip() for cap in caption.strip().split('&&')] + tgt_caption = '&&'.join(caption_list) + src_item = self.encode_text(self.prompt) + tgt_item = self.encode_text(" {}".format(tgt_caption)) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "patch_type": patch_type, + "patch_video": patch_video, + } + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/video_vqa_gen_dataset.py b/data/mm_data/video_vqa_gen_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..1a32ad2ba2942b15f8b78da540fe9d3bab67a752 --- /dev/null +++ b/data/mm_data/video_vqa_gen_dataset.py @@ -0,0 +1,286 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings + +import numpy as np +import torch +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + + +import os + +from data.video_utils import VIDEO_READER_FUNCS + + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + patch_videos = torch.stack([sample['patch_video'] for sample in samples], dim=0) + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + + conf = None + if samples[0].get("conf", None) is not None: + conf = torch.cat([s['conf'] for s in samples], dim=0) + + ref_dict = None + if samples[0].get("ref_dict", None) is not None: + ref_dict = np.array([s['ref_dict'] for s in samples]) + + constraint_masks = None + if samples[0].get("constraint_mask", None) is not None: + constraint_masks = merge("constraint_mask") + + decoder_prompts = None + if samples[0].get("decoder_prompt", None) is not None: + decoder_prompts = np.array([s['decoder_prompt'].tolist() for s in samples]) + + prefix_tokens = None + if samples[0].get("decoder_prompt", None) is not None: + prefix_tokens = merge("decoder_prompt") + prefix_tokens = prefix_tokens[:, 1:] + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor( + [s["target"].ne(pad_idx).long().sum() for s in samples] + ) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + "patch_videos": patch_videos, + "patch_types": patch_types, + }, + "conf": conf, + "ref_dict": ref_dict, + "constraint_masks": constraint_masks, + "decoder_prompts": decoder_prompts, + "target": target, + "prefix_tokens": prefix_tokens + } + + return batch + + +class VidVqaGenDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_object_length=30, + max_tgt_length=30, + patch_image_size=224, + add_object=False, + constraint_trie=None, + imagenet_default_mean_and_std=False, + prompt_type="none", + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + patch_frame_size=224, + num_frames=4, + sample_type='rand', + use_dataaug=False, + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_object_length = max_object_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + + self.add_object = add_object + self.constraint_trie = constraint_trie + self.prompt_type = prompt_type + + self.image_dir = image_dir + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + self.split = split + type_transform = transforms.Lambda(lambda x: x.float().div(255.0)) + + if self.split != 'train' or not use_dataaug: + self.patch_video_resize_transform = transforms.Compose([ + transforms.CenterCrop(patch_frame_size), + type_transform, + transforms.Normalize(mean=mean, std=std), + ]) + logger.info("val split, do not use random augmentation.") + else: + aug_transform = transforms.RandAugment() + self.patch_video_resize_transform = transforms.Compose( + [ + aug_transform, + transforms.RandomResizedCrop( + patch_frame_size, + scale=(0.5, 1.0), + interpolation=transforms.InterpolationMode.BICUBIC, + ), + transforms.RandomHorizontalFlip(), + type_transform, + transforms.Normalize(mean=mean, std=std), + ] + ) + + + logger.info("train split, use random augmentation.") + + # video + self.num_frames = num_frames + self.sample_type = sample_type + self.video_reader = VIDEO_READER_FUNCS['decord'] + self.max_num_frames = num_frames + + + def __getitem__(self, index): + item = self.dataset[index] + if len(item) == 5: + uniq_id, image, question, ref, predict_objects = item + else: + uniq_id, image, question, ref, predict_objects, caption = item + + # video + image_path = os.path.join(self.image_dir, image) + data_path = image_path + max_num_frames = self.max_num_frames + frames, frame_indices, video_duration = self.video_reader( + data_path, self.num_frames, self.sample_type, max_num_frames=max_num_frames + ) + + + + patch_video = self.patch_video_resize_transform(frames) + + patch_video = patch_video.permute(1, 0, 2, 3) # -> (C, T, h, w) + + + + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_type = torch.tensor([1]) + patch_mask = torch.tensor([True]) + + question = self.pre_question(question, self.max_src_length) + question = question + '?' if not question.endswith('?') else question + src_item = self.encode_text(' {}'.format(question)) + + ref_dict = {item.split('|!+')[1]: float(item.split('|!+')[0]) for item in ref.split('&&')} + answer = max(ref_dict, key=ref_dict.get) + conf = torch.tensor([ref_dict[answer]]) + tgt_item = self.encode_text(" {}".format(answer)) + + if self.add_object and predict_objects is not None: + predict_object_seq = ' '.join(predict_objects.strip().split('&&')[:self.max_object_length]) + predict_object_item = self.encode_text(" object: {}".format(predict_object_seq)) + src_item = torch.cat([src_item, predict_object_item]) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + if self.prompt_type == 'none': + prev_output_item = torch.cat([self.bos_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = self.bos_item + elif self.prompt_type == 'src': + prev_output_item = torch.cat([src_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item + elif self.prompt_type == 'prev_output': + prev_output_item = torch.cat([src_item[:-1], tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item[:-1] + else: + raise NotImplementedError + target_item[:-len(tgt_item)-1] = self.tgt_dict.pad() + + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_video": patch_video, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "decoder_prompt": decoder_prompt, + "ref_dict": ref_dict, + "conf": conf, + "patch_type": patch_type, + } + + if self.constraint_trie is not None: + constraint_mask = torch.zeros((len(target_item), len(self.tgt_dict))).bool() + start_idx = len(target_item) - len(tgt_item) - 1 + for i in range(len(target_item)-len(tgt_item)-1, len(target_item)): + constraint_prefix_token = [self.tgt_dict.bos()] + target_item[start_idx:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + example["constraint_mask"] = constraint_mask + + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/mm_data/vqa_gen_dataset.py b/data/mm_data/vqa_gen_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..8dba6361891dc863d9b522ab20575f2dee075a9b --- /dev/null +++ b/data/mm_data/vqa_gen_dataset.py @@ -0,0 +1,241 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import logging +import warnings + +import numpy as np +import torch +import base64 +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + +IMAGENET_DEFAULT_MEAN = (0.485, 0.456, 0.406) +IMAGENET_DEFAULT_STD = (0.229, 0.224, 0.225) + +import os + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + + + conf = None + if samples[0].get("conf", None) is not None: + conf = torch.cat([s['conf'] for s in samples], dim=0) + + ref_dict = None + if samples[0].get("ref_dict", None) is not None: + ref_dict = np.array([s['ref_dict'] for s in samples]) + + constraint_masks = None + if samples[0].get("constraint_mask", None) is not None: + constraint_masks = merge("constraint_mask") + + decoder_prompts = None + if samples[0].get("decoder_prompt", None) is not None: + decoder_prompts = np.array([s['decoder_prompt'].tolist() for s in samples]) + + prefix_tokens = None + if samples[0].get("decoder_prompt", None) is not None: + prefix_tokens = merge("decoder_prompt") + prefix_tokens = prefix_tokens[:, 1:] + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor( + [s["target"].ne(pad_idx).long().sum() for s in samples] + ) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "prev_output_tokens": prev_output_tokens, + "patch_types": patch_types, + }, + "conf": conf, + "ref_dict": ref_dict, + "constraint_masks": constraint_masks, + "decoder_prompts": decoder_prompts, + "target": target, + "prefix_tokens": prefix_tokens + } + + return batch + + +class VqaGenDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_object_length=30, + max_tgt_length=30, + patch_image_size=224, + add_object=False, + constraint_trie=None, + imagenet_default_mean_and_std=False, + prompt_type="none", + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + read_from_img_path=False, + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_object_length = max_object_length + self.max_tgt_length = max_tgt_length + self.patch_image_size = patch_image_size + + self.add_object = add_object + self.constraint_trie = constraint_trie + self.prompt_type = prompt_type + + if imagenet_default_mean_and_std: + mean = IMAGENET_DEFAULT_MEAN + std = IMAGENET_DEFAULT_STD + else: + mean = [0.5, 0.5, 0.5] + std = [0.5, 0.5, 0.5] + + self.patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((patch_image_size, patch_image_size), interpolation=Image.BICUBIC), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std), + ]) + + self.image_dir = image_dir + self.read_from_img_path = read_from_img_path + + + def __getitem__(self, index): + item = self.dataset[index] + if len(item) == 5: + uniq_id, image, question, ref, predict_objects = item + else: + uniq_id, image, question, ref, predict_objects, caption = item + + # print(self.image_dir, image, item) + if self.read_from_img_path or '.jpg' in image: + + image_path = os.path.join(self.image_dir, image) + + image = Image.open(image_path).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))) + + + patch_image = self.patch_resize_transform(image) + patch_mask = torch.tensor([True]) + + question = self.pre_question(question, self.max_src_length) + question = question + '?' if not question.endswith('?') else question + src_item = self.encode_text(' {}'.format(question)) + + ref_dict = {item.split('|!+')[1]: float(item.split('|!+')[0]) for item in ref.split('&&')} + answer = max(ref_dict, key=ref_dict.get) + conf = torch.tensor([ref_dict[answer]]) + tgt_item = self.encode_text(" {}".format(answer)) + + if self.add_object and predict_objects is not None: + predict_object_seq = ' '.join(predict_objects.strip().split('&&')[:self.max_object_length]) + predict_object_item = self.encode_text(" object: {}".format(predict_object_seq)) + src_item = torch.cat([src_item, predict_object_item]) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + if self.prompt_type == 'none': + prev_output_item = torch.cat([self.bos_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = self.bos_item + elif self.prompt_type == 'src': + prev_output_item = torch.cat([src_item, tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item + elif self.prompt_type == 'prev_output': + prev_output_item = torch.cat([src_item[:-1], tgt_item]) + target_item = torch.cat([prev_output_item[1:], self.eos_item]) + decoder_prompt = src_item[:-1] + else: + raise NotImplementedError + target_item[:-len(tgt_item)-1] = self.tgt_dict.pad() + + patch_type = torch.tensor([0]) + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "decoder_prompt": decoder_prompt, + "ref_dict": ref_dict, + "conf": conf, + "patch_type": patch_type, + } + if self.constraint_trie is not None: + constraint_mask = torch.zeros((len(target_item), len(self.tgt_dict))).bool() + start_idx = len(target_item) - len(tgt_item) - 1 + for i in range(len(target_item)-len(tgt_item)-1, len(target_item)): + constraint_prefix_token = [self.tgt_dict.bos()] + target_item[start_idx:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + example["constraint_mask"] = constraint_mask + return example + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch containing the data of the task + """ + return collate(samples, pad_idx=self.pad, eos_idx=self.eos) diff --git a/data/ofa_dataset.py b/data/ofa_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..fa30b24c858bb36da1179a53aef717b54d6b22f3 --- /dev/null +++ b/data/ofa_dataset.py @@ -0,0 +1,79 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import logging +import re +import torch.utils.data +from fairseq.data import FairseqDataset + +logger = logging.getLogger(__name__) + + +class OFADataset(FairseqDataset): + def __init__(self, split, dataset, bpe, src_dict, tgt_dict): + self.split = split + self.dataset = dataset + self.bpe = bpe + self.src_dict = src_dict + self.tgt_dict = tgt_dict + + self.bos = src_dict.bos() + self.eos = src_dict.eos() + self.pad = src_dict.pad() + self.bos_item = torch.LongTensor([self.bos]) + self.eos_item = torch.LongTensor([self.eos]) + + def __len__(self): + return len(self.dataset) + + def encode_text(self, text, length=None, append_bos=False, append_eos=False, use_bpe=True): + s = self.tgt_dict.encode_line( + line=self.bpe.encode(text) if use_bpe else text, + add_if_not_exist=False, + append_eos=False + ).long() + if length is not None: + s = s[:length] + if append_bos: + s = torch.cat([self.bos_item, s]) + if append_eos: + s = torch.cat([s, self.eos_item]) + return s + + def pre_question(self, question, max_ques_words=None): + question = question.lower().lstrip(",.!?*#:;~").replace('-', ' ').replace('/', ' ') + + question = re.sub( + r"\s{2,}", + ' ', + question, + ) + question = question.rstrip('\n') + question = question.strip(' ') + + # truncate question + question_words = question.split(' ') + if max_ques_words is not None and len(question_words) > max_ques_words: + question = ' '.join(question_words[:max_ques_words]) + + return question + + def pre_caption(self, caption, max_words=None): + caption = caption.lower().lstrip(",.!?*#:;~").replace('-', ' ').replace('/', ' ').replace('', 'person') + + caption = re.sub( + r"\s{2,}", + ' ', + caption, + ) + caption = caption.rstrip('\n') + caption = caption.strip(' ') + + # truncate caption + caption_words = caption.split(' ') + if max_words is not None and len(caption_words) > max_words: + caption = ' '.join(caption_words[:max_words]) + + return caption diff --git a/data/pretrain_data/.ipynb_checkpoints/unify_dataset-checkpoint.py b/data/pretrain_data/.ipynb_checkpoints/unify_dataset-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..8b9929e11369f99700ff9006d89515f524269fd3 --- /dev/null +++ b/data/pretrain_data/.ipynb_checkpoints/unify_dataset-checkpoint.py @@ -0,0 +1,650 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import math +import logging +import random +import warnings + +import numpy as np +import torch +import base64 +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset +from utils.vision_helper import RandomAugment +import utils.transforms as T + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + + +def get_whole_word_mask(bpe, dictionary): + if bpe is not None: + + def is_beginning_of_word(i): + if i < dictionary.nspecial: + # special elements are always considered beginnings + return True + tok = dictionary[i] + if tok.startswith("madeupword"): + return True + try: + return bpe.is_beginning_of_word(tok) + except ValueError: + return True + + mask_whole_words = torch.ByteTensor( + list(map(is_beginning_of_word, range(len(dictionary)))) + ) + return mask_whole_words + return None + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + code_masks = None + if samples[0].get("code_mask", None) is not None: + code_masks = torch.cat([sample['code_mask'] for sample in samples]) + + conf = torch.cat([s['conf'] for s in samples], dim=0) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_masks": patch_masks, + "code_masks": code_masks, + "prev_output_tokens": prev_output_tokens + }, + "target": target, + "conf": conf + } + + return batch + + +class UnifyDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_tgt_length=30, + seed=7, + code_dict_size=8192, + num_bins=1000, + patch_image_size=384, + code_image_size=128, + pure_text_dataset=None, + pure_image_dataset=None, + detection_dataset=None, + all_object_list=None, + all_caption_list=None, + type2ans_dict=None, + ans2type_dict=None, + max_image_size=512, + mask_ratio=0.3, + random_ratio=0.0, + keep_ratio=0.0, + mask_length="span-poisson", + poisson_lambda=3.0, + replace_length=1, + read_from_img_path=False, + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.seed = seed + self.code_dict_size = code_dict_size + self.num_bins = num_bins + self.patch_image_size = patch_image_size + self.code_image_size = code_image_size + + self.pure_text_dataset = pure_text_dataset + self.pure_image_dataset = pure_image_dataset + self.detection_dataset = detection_dataset + self.epoch = 0 + + self.all_object_list = all_object_list + self.all_caption_list = all_caption_list + self.type2ans_dict = type2ans_dict + self.ans2type_dict = ans2type_dict + + self.mask_ratio = mask_ratio + self.random_ratio = random_ratio + self.keep_ratio = keep_ratio + self.mask_length = mask_length + self.poisson_lambda = poisson_lambda + self.replace_length = replace_length + if self.replace_length not in [-1, 0, 1]: + raise ValueError(f"invalid arg: replace_length={self.replace_length}") + if self.mask_length not in ["subword", "word", "span-poisson"]: + raise ValueError(f"invalid arg: mask-length={self.mask_length}") + if self.mask_length == "subword" and self.replace_length not in [0, 1]: + raise ValueError(f"if using subwords, use replace-length=1 or 0") + + self.mask_idx = src_dict.index("") + self.mask_whole_word = ( + get_whole_word_mask(self.bpe, self.src_dict) + if self.mask_length != "subword" + else None + ) + self.mask_span_distribution = None + if self.mask_length == "span-poisson": + _lambda = self.poisson_lambda + lambda_to_the_k = 1 + e_to_the_minus_lambda = math.exp(-_lambda) + k_factorial = 1 + ps = [] + for k in range(0, 128): + ps.append(e_to_the_minus_lambda * lambda_to_the_k / k_factorial) + lambda_to_the_k *= _lambda + k_factorial *= k + 1 + if ps[-1] < 0.0000001: + break + ps = torch.FloatTensor(ps) + self.mask_span_distribution = torch.distributions.Categorical(ps) + + self.pos_tgt_item = self.encode_text(" yes") + self.neg_tgt_item = self.encode_text(" no") + + self.mask_left = self.mask_top = int(0.5 * self.code_image_size) + self.mask_right = self.mask_bottom = int(1.5 * self.code_image_size) + self.mask_ids = [ + i*self.code_image_size*2+j + for i in range(self.code_image_size*2) for j in range(self.code_image_size*2) + if not (self.mask_left <= i < self.mask_right and self.mask_top <= j < self.mask_bottom) + ] + + scales = np.arange(patch_image_size, 481).tolist() + + # for image-text pair + self.patch_resize_transform = transforms.Compose([ + T.RandomResize(scales, max_size=672), + transforms.CenterCrop(patch_image_size), + RandomAugment(2, 7, isPIL=True, augs=['Identity', 'AutoContrast', 'Equalize', 'Brightness', 'Sharpness', + 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), + transforms.ToTensor(), + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + # for pure image + self.patch_crop_transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + # for detection + self.detection_transform = T.Compose([ + T.RandomHorizontalFlip(), + T.LargeScaleJitter(output_size=self.code_image_size*2, aug_scale_min=1.0, aug_scale_max=1.5), + T.ToTensor(), + T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], max_image_size=max_image_size) + ]) + # for visual grounding + self.visual_grounding_transform = T.Compose([ + T.RandomResize(scales, max_size=672), + T.ObjectCenterCrop((patch_image_size, patch_image_size)), + T.ToTensor(), + T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], max_image_size=max_image_size) + ]) + + self.read_from_img_path = read_from_img_path + + def set_epoch(self, epoch, **unused): + self.epoch = epoch + + def get_negative_caption(self, caption, gt_objects): + prob = random.random() + if gt_objects is not None and gt_objects != '' and prob > 0.6: + gt_object = random.choice(gt_objects.strip().split('&&')) + negative_object = random.choice(self.all_object_list[:-1]) + negative_object = self.all_object_list[-1] if negative_object == gt_object else negative_object + negative_caption = caption.replace(gt_object, negative_object) + else: + negative_caption = random.choice(self.all_caption_list) + return negative_caption + + def get_negative_answer(self, answer, conf): + prob = random.random() + if conf > (prob + 0.1) and answer in self.ans2type_dict: + negative_answer_type = self.ans2type_dict[answer] + if negative_answer_type == 'how many' and answer.isdigit() and prob > 0.5: + negative_answer = int(answer) + random.choice([-1, 1]) if answer != 0 else 1 + else: + negative_answer_list = self.type2ans_dict[negative_answer_type] + negative_answer = random.choice(negative_answer_list[:-1]) + negative_answer = negative_answer_list[-1] if negative_answer == answer else negative_answer + return negative_answer + + negative_answer_list = self.type2ans_dict['other'] + negative_answer = random.choice(negative_answer_list[:-1]) + negative_answer = negative_answer_list[-1] if negative_answer == answer else negative_answer + return negative_answer + + def process_image_text_pair(self, index): + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = self.dataset[index] + if self.read_from_img_path: + image = Image.open(image).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))).convert("RGB") + patch_image = self.patch_resize_transform(image) if type != 'visual_grounding' else None + patch_mask = torch.tensor([True]) + conf = torch.tensor([1.0]) + if type == 'caption': + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + neg_src_caption = self.pre_caption(self.get_negative_caption(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the image describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the image describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the image describe " {} "?'.format(neg_src_caption)) + elif type == 'qa': + question = self.pre_question(question, self.max_src_length) + ref_dict = {item.split('|!+')[1]: float(item.split('|!+')[0]) for item in refs.split('&&')} + answer = max(ref_dict, key=ref_dict.get) + conf = ref_dict[answer] + src_item = self.encode_text(" {}".format(question)) + tgt_item = self.encode_text(" {}".format(answer)) + conf = torch.tensor([conf]) + pos_src_item = self.encode_text(' what is the answer to question " {} ". is " {} "?'.format(question, answer)) + neg_src_item = self.encode_text( + ' what is the answer to question " {} ". is " {} "?'.format(question, self.get_negative_answer(answer, conf)) + ) + elif type == 'visual_grounding': + conf = torch.tensor([1.0]) + w, h = image.size + boxes_target = {"boxes": [], "labels": [], "area": [], "size": torch.tensor([h, w])} + x0, y0, x1, y1 = refs.strip().split(',') + boxes_target["boxes"] = torch.tensor([[float(x0), float(y0), float(x1), float(y1)]]) + boxes_target["labels"] = np.array([0]) + boxes_target["area"] = torch.tensor([(float(x1) - float(x0)) * (float(y1) - float(y0))]) + patch_image, boxes_target = self.visual_grounding_transform(image, boxes_target) + quant_x0 = "".format(int((boxes_target["boxes"][0][0] * (self.num_bins - 1)).round())) + quant_y0 = "".format(int((boxes_target["boxes"][0][1] * (self.num_bins - 1)).round())) + quant_x1 = "".format(int((boxes_target["boxes"][0][2] * (self.num_bins - 1)).round())) + quant_y1 = "".format(int((boxes_target["boxes"][0][3] * (self.num_bins - 1)).round())) + region_coord = "{} {} {} {}".format(quant_x0, quant_y0, quant_x1, quant_y1) + src_caption = self.pre_caption(caption, self.max_src_length) + src_item = self.encode_text(' which region does the text " {} " describe?'.format(src_caption)) + tgt_item = self.encode_text(region_coord, use_bpe=False) + else: + logger.info('type {} is not implemented'.format(type)) + raise NotImplementedError + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + pos_src_item = torch.cat([self.bos_item, pos_src_item, self.eos_item]) if type != 'visual_grounding' else None + neg_src_item = torch.cat([self.bos_item, neg_src_item, self.eos_item]) if type != 'visual_grounding' else None + + if type == 'caption' and dataset_name == 'cc12m': + target_item[:2] = self.src_dict.pad() + target_item[-1] = self.eos_item + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + } + + examples = [example] + prob = random.random() + if type == 'visual_grounding': + region_example = example.copy() + region_prefix_item = self.encode_text(' what does the region describe? region:') + region_coord_item = self.encode_text('{}'.format(region_coord), use_bpe=False) + region_src_item = torch.cat([region_prefix_item, region_coord_item]) + region_tgt_item = self.encode_text(' {}'.format(self.pre_caption(caption, self.max_tgt_length))) + region_example["source"] = torch.cat([self.bos_item, region_src_item, self.eos_item]) + region_example["target"] = torch.cat([region_tgt_item, self.eos_item]) + region_example["prev_output_tokens"] = torch.cat([self.bos_item, region_tgt_item]) + region_example["conf"] = torch.tensor([1.0]) + examples.append(region_example) + elif prob >= 0.5 and self.split == 'train': + pos_example = example.copy() + pos_example["source"] = pos_src_item + pos_example["target"] = torch.cat([self.pos_tgt_item, self.eos_item]) + pos_example["prev_output_tokens"] = torch.cat([self.bos_item, self.pos_tgt_item]) + examples.append(pos_example) + elif self.split == 'train': + neg_example = example.copy() + neg_example["source"] = neg_src_item + neg_example["target"] = torch.cat([self.neg_tgt_item, self.eos_item]) + neg_example["prev_output_tokens"] = torch.cat([self.bos_item, self.neg_tgt_item]) + examples.append(neg_example) + return examples + + def process_pure_text(self, index): + patch_image = torch.zeros((3, self.code_image_size*2, self.code_image_size*2)) + patch_mask = torch.tensor([False]) + code_mask = torch.tensor([False]) + conf = torch.tensor([2.0]) + + examples = [] + for _ in range(2): + uniq_id, text = self.pure_text_dataset[index] + text = text.strip().lower() + text_item = self.encode_text(" {}".format(text), length=512) + text_item = text_item[-256:] + text_item = torch.cat([self.bos_item, text_item, self.eos_item]) + mask_text_item = self.add_whole_word_mask(text_item.clone(), self.mask_ratio) + prefix_item = self.encode_text(' what is the complete text of " "?') + src_item = torch.cat([prefix_item[:-2], mask_text_item[1:-1], prefix_item[-2:]]) + tgt_item = text_item[1:-1] + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "code_mask": code_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + } + examples.append(example) + + return examples + + def process_pure_image(self, index): + image_id, image, code = self.pure_image_dataset[index] + + if self.read_from_img_path: + image = Image.open(image).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))).convert("RGB") + + patch_image = self.patch_crop_transform(image) + patch_image[:, self.mask_top:self.mask_bottom, self.mask_left:self.mask_right] = 0 + patch_mask = torch.tensor([True]) + src_item = self.encode_text(" what is the image in the middle part?") + image_code = torch.LongTensor([int(num) for num in code.strip().split()]) + tgt_item = image_code + len(self.src_dict) - self.code_dict_size - self.num_bins + code_mask = torch.tensor([True]) + conf = torch.tensor([2.0]) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + example = { + "id": image_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "code_mask": code_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + } + return [example] + + def process_detection(self, index): + image_id, image, label = self.detection_dataset[index] + + if self.read_from_img_path: + image = Image.open(image).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))).convert("RGB") + + w, h = image.size + boxes_target = {"boxes": [], "labels": [], "area": [], "size": torch.tensor([h, w])} + label_list = label.strip().split('&&') + for label in label_list: + x0, y0, x1, y1, cat_id, cat = label.strip().split(',', 5) + boxes_target["boxes"].append([float(x0), float(y0), float(x1), float(y1)]) + boxes_target["labels"].append(cat) + boxes_target["area"].append((float(x1) - float(x0)) * (float(y1) - float(y0))) + boxes_target["boxes"] = torch.tensor(boxes_target["boxes"]) + boxes_target["labels"] = np.array(boxes_target["labels"]) + boxes_target["area"] = torch.tensor(boxes_target["area"]) + + patch_image, boxes_target = self.detection_transform(image, boxes_target) + patch_mask = torch.tensor([True]) + code_mask = torch.tensor([False]) + conf = torch.tensor([2.0]) + + quant_boxes = [] + for i, box in enumerate(boxes_target["boxes"]): + quant_boxes.extend(["".format(int((pos * (self.num_bins - 1)).round())) for pos in box[:4]]) + quant_boxes.append(self.bpe.encode(' {}'.format(boxes_target["labels"][i]))) + src_item = self.encode_text(' what are the objects in the image?') + tgt_item = self.encode_text(' '.join(quant_boxes), use_bpe=False) + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + + example = { + "id": image_id, + "source": src_item, + "patch_image": patch_image, + "patch_mask": patch_mask, + "code_mask": code_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + } + return [example] + + def __getitem__(self, index): + with data_utils.numpy_seed(self.seed, self.epoch): + pair_samples = self.process_image_text_pair(index) + extra_samples = [] + if self.split == 'train' and self.dataset.data_cnt % 8 == 0: + extra_samples += self.process_pure_text(0) if self.pure_text_dataset else [] + extra_samples += self.process_pure_image(0) if self.pure_image_dataset else [] + extra_samples += self.process_detection(0) if self.detection_dataset else [] + return pair_samples, extra_samples + + def word_starts(self, source): + if self.mask_whole_word is not None: + is_word_start = self.mask_whole_word.gather(0, source) + else: + is_word_start = torch.ones(source.size()) + is_word_start[0] = 0 + is_word_start[-1] = 0 + return is_word_start + + def add_whole_word_mask(self, source, p): + is_word_start = self.word_starts(source) + num_to_mask = int(math.ceil(is_word_start.float().sum() * p)) + num_inserts = 0 + if num_to_mask == 0: + return source + + if self.mask_span_distribution is not None: + lengths = self.mask_span_distribution.sample(sample_shape=(num_to_mask,)) + + # Make sure we have enough to mask + cum_length = torch.cumsum(lengths, 0) + while cum_length[-1] < num_to_mask: + lengths = torch.cat( + [ + lengths, + self.mask_span_distribution.sample(sample_shape=(num_to_mask,)), + ], + dim=0, + ) + cum_length = torch.cumsum(lengths, 0) + + # Trim to masking budget + i = 0 + while cum_length[i] < num_to_mask: + i += 1 + lengths[i] = num_to_mask - (0 if i == 0 else cum_length[i - 1]) + num_to_mask = i + 1 + lengths = lengths[:num_to_mask] + + # Handle 0-length mask (inserts) separately + lengths = lengths[lengths > 0] + num_inserts = num_to_mask - lengths.size(0) + num_to_mask -= num_inserts + if num_to_mask == 0: + return self.add_insertion_noise(source, num_inserts / source.size(0)) + + assert (lengths > 0).all() + else: + lengths = torch.ones((num_to_mask,)).long() + assert is_word_start[-1] == 0 + word_starts = is_word_start.nonzero(as_tuple=False) + indices = word_starts[ + torch.randperm(word_starts.size(0))[:num_to_mask] + ].squeeze(1) + mask_random = torch.FloatTensor(num_to_mask).uniform_() < self.random_ratio + + source_length = source.size(0) + assert source_length - 1 not in indices + to_keep = torch.ones(source_length, dtype=torch.bool) + is_word_start[ + -1 + ] = 255 # acts as a long length, so spans don't go over the end of doc + if self.replace_length == 0: + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + + if self.mask_span_distribution is not None: + assert len(lengths.size()) == 1 + assert lengths.size() == indices.size() + lengths -= 1 + while indices.size(0) > 0: + assert lengths.size() == indices.size() + lengths -= is_word_start[indices + 1].long() + uncompleted = lengths >= 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + lengths = lengths[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + else: + # A bit faster when all lengths are 1 + while indices.size(0) > 0: + uncompleted = is_word_start[indices + 1] == 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + + assert source_length - 1 not in indices + + source = source[to_keep] + + if num_inserts > 0: + source = self.add_insertion_noise(source, num_inserts / source.size(0)) + + return source + + def add_insertion_noise(self, tokens, p): + if p == 0.0: + return tokens + + num_tokens = len(tokens) + n = int(math.ceil(num_tokens * p)) + + noise_indices = torch.randperm(num_tokens + n - 2)[:n] + 1 + noise_mask = torch.zeros(size=(num_tokens + n,), dtype=torch.bool) + noise_mask[noise_indices] = 1 + result = torch.LongTensor(n + len(tokens)).fill_(-1) + + num_random = int(math.ceil(n * self.random_ratio)) + result[noise_indices[num_random:]] = self.mask_idx + result[noise_indices[:num_random]] = torch.randint( + low=4, high=len(self.tgt_dict)-self.code_dict_size-self.num_bins, size=(num_random,) + ) + + result[~noise_mask] = tokens + + assert (result >= 0).all() + return result + + def collater(self, samples, pad_to_length=None): + """Merge samples of different tasks to form two mini-batches. + Args: + samples (List[Tuple]): samples to collate + Returns: + Tuple[dict]: two mini-batch containing the data of different tasks + """ + + samples_v1 = [] # containing image-text pairs + samples_v2 = [] # containing detection data, text data and image data + for sample_tuple in samples: + samples_v1 += sample_tuple[0] + samples_v2 += sample_tuple[1] + if samples_v2 != []: + res_v1 = collate(samples_v1, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + res_v2 = collate(samples_v2, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + return res_v1, res_v2 + else: + res_v1 = collate(samples_v1, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + return res_v1 diff --git a/data/pretrain_data/__pycache__/unify_dataset.cpython-37.pyc b/data/pretrain_data/__pycache__/unify_dataset.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88f23e503dd57bbb4e1d7f6d43b25f1fb0f38c4b Binary files /dev/null and b/data/pretrain_data/__pycache__/unify_dataset.cpython-37.pyc differ diff --git a/data/pretrain_data/__pycache__/unify_dataset.cpython-38.pyc b/data/pretrain_data/__pycache__/unify_dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f46057fd6ccf05c9a4d676bcb4ee4ef2a58ac6f6 Binary files /dev/null and b/data/pretrain_data/__pycache__/unify_dataset.cpython-38.pyc differ diff --git a/data/pretrain_data/__pycache__/unify_dataset.cpython-39.pyc b/data/pretrain_data/__pycache__/unify_dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55cc94deb0ee02404a461ab308f8cfd479222309 Binary files /dev/null and b/data/pretrain_data/__pycache__/unify_dataset.cpython-39.pyc differ diff --git a/data/pretrain_data/unify_dataset.py b/data/pretrain_data/unify_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a7a4f4cc87af62864a2bd055b4d3de96ae7e0579 --- /dev/null +++ b/data/pretrain_data/unify_dataset.py @@ -0,0 +1,1087 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from io import BytesIO + +import math +import logging +import random +import warnings + +import numpy as np +import torch +import base64 +from torchvision import transforms + +from PIL import Image, ImageFile + +from data import data_utils +from data.ofa_dataset import OFADataset +from utils.vision_helper import RandomAugment +import utils.transforms as T + +import os + +from data.video_utils import VIDEO_READER_FUNCS +from torchvision.transforms import InterpolationMode + +# audio +from data.audio_utils import get_audio_features, int16_to_float32, float32_to_int16, AUDIO_CFG +import soundfile as sf +import librosa + +from decord.bridge import to_torch +import decord + + +import random + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +logger = logging.getLogger(__name__) +warnings.filterwarnings("ignore", "(Possibly )?corrupt EXIF data", UserWarning) + + +def get_whole_word_mask(bpe, dictionary): + if bpe is not None: + + def is_beginning_of_word(i): + if i < dictionary.nspecial: + # special elements are always considered beginnings + return True + tok = dictionary[i] + if tok.startswith("madeupword"): + return True + try: + return bpe.is_beginning_of_word(tok) + except ValueError: + return True + + mask_whole_words = torch.ByteTensor( + list(map(is_beginning_of_word, range(len(dictionary)))) + ) + return mask_whole_words + return None + + +def collate(samples, pad_idx, eos_idx): + if len(samples) == 0: + return {} + + def merge(key, samples=samples): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=eos_idx, + ) + + + id = np.array([s["id"] for s in samples]) + src_tokens = merge("source") + src_lengths = torch.LongTensor([s["source"].ne(pad_idx).long().sum() for s in samples]) + + patch_images = torch.stack([sample['patch_image'] for sample in samples], dim=0) + patch_masks = torch.cat([sample['patch_mask'] for sample in samples]) + + + + patch_videos = torch.stack([sample['patch_video'] for sample in samples], dim=0) + patch_types = torch.cat([sample['patch_type'] for sample in samples]) + + patch_audios = torch.stack([sample['patch_audio'] for sample in samples], dim=0) + + + code_masks = None + if samples[0].get("code_mask", None) is not None: + code_masks = torch.cat([sample['code_mask'] for sample in samples]) + + conf = torch.cat([s['conf'] for s in samples], dim=0) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge("target") + tgt_lengths = torch.LongTensor([s["target"].ne(pad_idx).long().sum() for s in samples]) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens") + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "patch_images": patch_images, + "patch_videos": patch_videos, + "patch_masks": patch_masks, + "code_masks": code_masks, + "prev_output_tokens": prev_output_tokens, + "patch_types": patch_types, + "patch_audios": patch_audios, + }, + "target": target, + "conf": conf + } + + + return batch + + +class UnifyDataset(OFADataset): + def __init__( + self, + split, + dataset, + bpe, + src_dict, + tgt_dict=None, + max_src_length=128, + max_tgt_length=30, + seed=7, + code_dict_size=8192, + num_bins=1000, + patch_image_size=384, + code_image_size=128, + all_object_list=None, + all_caption_list=None, + type2ans_dict=None, + ans2type_dict=None, + max_image_size=512, + mask_ratio=0.3, + random_ratio=0.0, + keep_ratio=0.0, + mask_length="span-poisson", + poisson_lambda=3.0, + replace_length=1, + read_from_img_path=False, + image_dir='/gpfsscratch/rech/dyf/ugz83ue/data', + no_image_transform=False, + patch_frame_size=224, + num_frames=4, + num_tries=2, + video_cnt=2, + all_caption_video_list=None, + audio_cfg=AUDIO_CFG, + max_audio_len = 480000, + sample_rate=48000, + audio_cnt=2, + all_caption_audio_list=None, + audio_dataset=None, + video_dataset=None, + sample_type='rand', + image_text_dataset=None, + image_text_cnt=1, + other_data_cnt=8, + init_image_text_dataset=None, + init_text_dataset=None, + init_dataset_epoch=0, + image_text_vqa_dataset=None, + image_text_vqa_cnt=1, + image_text_ground_dataset=None, + image_text_ground_cnt=1, + only_video_data=None, + only_audio_data=None, + video_text_dataset=None, + video_text_cnt=1, + audio_text_dataset=None, + audio_text_cnt=1, + audio_with_video=False, + ): + super().__init__(split, dataset, bpe, src_dict, tgt_dict) + self.max_src_length = max_src_length + self.max_tgt_length = max_tgt_length + self.seed = seed + self.code_dict_size = code_dict_size + self.num_bins = num_bins + self.patch_image_size = patch_image_size + self.code_image_size = code_image_size + self.patch_frame_size = patch_frame_size + + + + self.image_text_dataset = image_text_dataset + self.image_text_cnt = image_text_cnt + + self.image_text_ground_dataset = image_text_ground_dataset + self.image_text_ground_cnt = image_text_ground_cnt + + self.image_text_vqa_dataset = image_text_vqa_dataset + self.image_text_vqa_cnt = image_text_vqa_cnt + + self.other_data_cnt = other_data_cnt + # audio + self.audio_dataset = audio_dataset + self.audio_cnt=audio_cnt + self.epoch = 0 + self.audio_with_video = audio_with_video + + ## video + self.video_text_dataset = video_text_dataset + self.video_text_cnt = video_text_cnt + + self.audio_text_dataset = audio_text_dataset + self.audio_text_cnt = audio_text_cnt + + + # init dataset + self.init_image_text_dataset = init_image_text_dataset + self.init_dataset_epoch = init_dataset_epoch + + self.init_text_dataset = init_text_dataset + + self.sample_rate = sample_rate + + + self.all_object_list = all_object_list + self.all_caption_list = all_caption_list + self.type2ans_dict = type2ans_dict + self.ans2type_dict = ans2type_dict + + self.mask_ratio = mask_ratio + self.random_ratio = random_ratio + self.keep_ratio = keep_ratio + self.mask_length = mask_length + self.poisson_lambda = poisson_lambda + self.replace_length = replace_length + if self.replace_length not in [-1, 0, 1]: + raise ValueError(f"invalid arg: replace_length={self.replace_length}") + if self.mask_length not in ["subword", "word", "span-poisson"]: + raise ValueError(f"invalid arg: mask-length={self.mask_length}") + if self.mask_length == "subword" and self.replace_length not in [0, 1]: + raise ValueError(f"if using subwords, use replace-length=1 or 0") + + self.mask_idx = src_dict.index("") + self.mask_whole_word = ( + get_whole_word_mask(self.bpe, self.src_dict) + if self.mask_length != "subword" + else None + ) + self.mask_span_distribution = None + if self.mask_length == "span-poisson": + _lambda = self.poisson_lambda + lambda_to_the_k = 1 + e_to_the_minus_lambda = math.exp(-_lambda) + k_factorial = 1 + ps = [] + for k in range(0, 128): + ps.append(e_to_the_minus_lambda * lambda_to_the_k / k_factorial) + lambda_to_the_k *= _lambda + k_factorial *= k + 1 + if ps[-1] < 0.0000001: + break + ps = torch.FloatTensor(ps) + self.mask_span_distribution = torch.distributions.Categorical(ps) + + self.pos_tgt_item = self.encode_text(" yes") + self.neg_tgt_item = self.encode_text(" no") + + self.mask_left = self.mask_top = int(0.5 * self.code_image_size) + self.mask_right = self.mask_bottom = int(1.5 * self.code_image_size) + self.mask_ids = [ + i*self.code_image_size*2+j + for i in range(self.code_image_size*2) for j in range(self.code_image_size*2) + if not (self.mask_left <= i < self.mask_right and self.mask_top <= j < self.mask_bottom) + ] + + scales = np.arange(patch_image_size, 481).tolist() + + # video + self.video_cnt = video_cnt + self.video_dataset = video_dataset + self.num_tries = num_tries + type_transform = transforms.Lambda(lambda x: x.float().div(255.0)) + + # for image-text pair + if no_image_transform: + self.patch_resize_transform = transforms.Compose([ + transforms.CenterCrop(patch_image_size), + transforms.ToTensor(), + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + self.patch_video_resize_transform = transforms.Compose([ + transforms.CenterCrop(patch_frame_size), + type_transform, + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + else: + self.patch_resize_transform = transforms.Compose([ + T.RandomResize(scales, max_size=672), + transforms.CenterCrop(patch_image_size), + RandomAugment(2, 7, isPIL=True, augs=['Identity', 'AutoContrast', 'Equalize', 'Brightness', 'Sharpness', + 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), + transforms.ToTensor(), + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + + self.patch_video_resize_transform = transforms.Compose([ + transforms.RandomResizedCrop(patch_frame_size, scale=(0.5, 1.0), + interpolation=InterpolationMode.BICUBIC,), + transforms.RandomHorizontalFlip(), + transforms.RandAugment(), + type_transform, + transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), + ]) + + + + # for visual grounding + self.visual_grounding_transform = T.Compose([ + T.RandomResize(scales, max_size=672), + T.ObjectCenterCrop((patch_image_size, patch_image_size)), + T.ToTensor(), + T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], max_image_size=max_image_size) + ]) + + self.read_from_img_path = read_from_img_path + self.image_dir = image_dir + + # video + self.num_frames = num_frames + self.sample_type = sample_type # fps1 rand + self.video_reader = VIDEO_READER_FUNCS['decord'] + self.all_caption_video_list = all_caption_video_list + + + + + # audio + self.audio_cfg = audio_cfg + self.max_audio_len = max_audio_len + self.all_caption_audio_list = all_caption_audio_list + + + self.only_video_data = only_video_data + self.only_audio_data = only_audio_data + + def set_epoch(self, epoch, **unused): + self.epoch = epoch + + def get_negative_caption(self, caption, gt_objects): + prob = random.random() + if gt_objects is not None and gt_objects != '' and prob > 0.6: + gt_object = random.choice(gt_objects.strip().split('&&')) + negative_object = random.choice(self.all_object_list[:-1]) + negative_object = self.all_object_list[-1] if negative_object == gt_object else negative_object + negative_caption = caption.replace(gt_object, negative_object) + else: + negative_caption = random.choice(self.all_caption_list) + return negative_caption + + def get_negative_caption_video(self, caption, gt_objects): + prob = random.random() + if gt_objects is not None and gt_objects != '' and prob > 0.6: + gt_object = random.choice(gt_objects.strip().split('&&')) + negative_object = random.choice(self.all_object_list[:-1]) + negative_object = self.all_object_list[-1] if negative_object == gt_object else negative_object + negative_caption = caption.replace(gt_object, negative_object) + else: + negative_caption = random.choice(self.all_caption_video_list) + return negative_caption + + def get_negative_caption_audio(self, caption, gt_objects): + prob = random.random() + if gt_objects is not None and gt_objects != '' and prob > 0.6: + gt_object = random.choice(gt_objects.strip().split('&&')) + negative_object = random.choice(self.all_object_list[:-1]) + negative_object = self.all_object_list[-1] if negative_object == gt_object else negative_object + negative_caption = caption.replace(gt_object, negative_object) + else: + negative_caption = random.choice(self.all_caption_audio_list) + return negative_caption + + def get_negative_answer(self, answer, conf): + prob = random.random() + if conf > (prob + 0.1) and answer in self.ans2type_dict: + negative_answer_type = self.ans2type_dict[answer] + if negative_answer_type == 'how many' and answer.isdigit() and prob > 0.5: + negative_answer = int(answer) + random.choice([-1, 1]) if answer != 0 else 1 + else: + negative_answer_list = self.type2ans_dict[negative_answer_type] + negative_answer = random.choice(negative_answer_list[:-1]) + negative_answer = negative_answer_list[-1] if negative_answer == answer else negative_answer + return negative_answer + + negative_answer_list = self.type2ans_dict['other'] + negative_answer = random.choice(negative_answer_list[:-1]) + negative_answer = negative_answer_list[-1] if negative_answer == answer else negative_answer + return negative_answer + + def process_image_text_pair(self, index, other_dataset=None): + + if other_dataset is None: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = self.dataset[index] + else: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = other_dataset[index] + + if 'video' in type: + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_audio = torch.zeros(self.max_audio_len) + patch_mask = torch.tensor([True]) + patch_type = torch.tensor([1]) + + image_path = os.path.join(self.image_dir, image) + data_path = image_path + try: + max_num_frames = self.max_num_frames if hasattr(self, "max_num_frames") else -1 + frames, frame_indices, video_duration = self.video_reader( + data_path, self.num_frames, self.sample_type, max_num_frames=max_num_frames + ) + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading video {data_path}, " + f"randomly sample a new video as replacement" + ) + return self.process_image_text_pair(new_index, other_dataset=other_dataset) + + patch_video = self.patch_video_resize_transform(frames) + + patch_video = patch_video.permute(1, 0, 2, 3) # -> (C, T, h, w) + + + conf = torch.tensor([1.0]) + + if type == 'video_caption': + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + # assume the same negative samples as in for images, to test if distribution os video captions are different + neg_src_caption = self.pre_caption(self.get_negative_caption_video(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the video describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the video describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the video describe " {} "?'.format(neg_src_caption)) + else: + print(type, "not implemented") + assert NotImplemented + elif 'audio' in type: + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_video = torch.zeros((3, self.num_frames, self.patch_image_size, self.patch_image_size)) + patch_mask = torch.tensor([True]) + patch_type = torch.tensor([2]) + + image_path = os.path.join(self.image_dir, image) + data_path = image_path + + + try: + audio_data, orig_sr = librosa.load(data_path, sr=self.audio_cfg['sample_rate']) #sf.read(io.BytesIO(data_path)) + audio_data = int16_to_float32(float32_to_int16(audio_data)) + audio_data = torch.tensor(audio_data).float() # (T) + # the 'fusion' truncate mode can be changed to 'rand_trunc' if run in unfusion mode + if len(audio_data) == 0: + logger.warning( + f"Caught exception {e} when loading audio {data_path}, " + f"randomly sample a new audio as replacement" + ) + return self.process_image_text_pair(new_index) + + sample = {} + + sample = get_audio_features( + sample, audio_data, self.max_audio_len, + data_truncating='fusion', + data_filling='repeatpad', + audio_cfg=self.audio_cfg + ) + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading audio {data_path}, " + f"randomly sample a new audio as replacement" + ) + return self.process_image_text_pair(new_index) + + + + patch_audio = sample['waveform'] + + + + conf = torch.tensor([1.0]) + + if type == 'audio_caption': + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + # assume the same negative samples as in for images, to test if distribution os video captions are different + neg_src_caption = self.pre_caption(self.get_negative_caption_audio(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the audio describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the audio describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the audio describe " {} "?'.format(neg_src_caption)) + else: + print(type, "not implemented") + assert NotImplemented + + + else: + # dummy video + patch_video = torch.zeros((3, self.num_frames, self.patch_frame_size, self.patch_frame_size)) + patch_audio = torch.zeros(self.max_audio_len) + patch_type = torch.tensor([0]) + try: + if self.read_from_img_path: + image_path = os.path.join(self.image_dir, image) + image = Image.open(image_path).convert("RGB") + else: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))).convert("RGB") + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading image {image_path}, " + f"randomly sample a new image as replacement" + ) + return self.process_image_text_pair(new_index) + + patch_image = self.patch_resize_transform(image) if type != 'visual_grounding' else None + patch_mask = torch.tensor([True]) + conf = torch.tensor([1.0]) + if type == 'caption': + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + neg_src_caption = self.pre_caption(self.get_negative_caption(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the image describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the image describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the image describe " {} "?'.format(neg_src_caption)) + elif type == 'qa': + question = self.pre_question(question, self.max_src_length) + ref_dict = {item.split('|!+')[1]: float(item.split('|!+')[0]) for item in refs.split('&&')} + answer = max(ref_dict, key=ref_dict.get) + conf = ref_dict[answer] + src_item = self.encode_text(" {}".format(question)) + tgt_item = self.encode_text(" {}".format(answer)) + conf = torch.tensor([conf]) + pos_src_item = self.encode_text(' what is the answer to question " {} ". is " {} "?'.format(question, answer)) + neg_src_item = self.encode_text( + ' what is the answer to question " {} ". is " {} "?'.format(question, self.get_negative_answer(answer, conf)) + ) + elif type == 'visual_grounding': + conf = torch.tensor([1.0]) + w, h = image.size + boxes_target = {"boxes": [], "labels": [], "area": [], "size": torch.tensor([h, w])} + x0, y0, x1, y1 = refs.strip().split(',') + boxes_target["boxes"] = torch.tensor([[float(x0), float(y0), float(x1), float(y1)]]) + boxes_target["labels"] = np.array([0]) + boxes_target["area"] = torch.tensor([(float(x1) - float(x0)) * (float(y1) - float(y0))]) + patch_image, boxes_target = self.visual_grounding_transform(image, boxes_target) + quant_x0 = "".format(int((boxes_target["boxes"][0][0] * (self.num_bins - 1)).round())) + quant_y0 = "".format(int((boxes_target["boxes"][0][1] * (self.num_bins - 1)).round())) + quant_x1 = "".format(int((boxes_target["boxes"][0][2] * (self.num_bins - 1)).round())) + quant_y1 = "".format(int((boxes_target["boxes"][0][3] * (self.num_bins - 1)).round())) + region_coord = "{} {} {} {}".format(quant_x0, quant_y0, quant_x1, quant_y1) + src_caption = self.pre_caption(caption, self.max_src_length) + src_item = self.encode_text(' which region does the text " {} " describe?'.format(src_caption)) + tgt_item = self.encode_text(region_coord, use_bpe=False) + else: + logger.info('type {} is not implemented'.format(type)) + raise NotImplementedError + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + pos_src_item = torch.cat([self.bos_item, pos_src_item, self.eos_item]) if type != 'visual_grounding' else None + neg_src_item = torch.cat([self.bos_item, neg_src_item, self.eos_item]) if type != 'visual_grounding' else None + + if type == 'caption' and dataset_name == 'cc12m': + target_item[:2] = self.src_dict.pad() + target_item[-1] = self.eos_item + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_video": patch_video, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + "patch_type": patch_type, + "patch_audio": patch_audio, + } + + examples = [example] + prob = random.random() + if type == 'visual_grounding': + region_example = example.copy() + region_prefix_item = self.encode_text(' what does the region describe? region:') + region_coord_item = self.encode_text('{}'.format(region_coord), use_bpe=False) + region_src_item = torch.cat([region_prefix_item, region_coord_item]) + region_tgt_item = self.encode_text(' {}'.format(self.pre_caption(caption, self.max_tgt_length))) + region_example["source"] = torch.cat([self.bos_item, region_src_item, self.eos_item]) + region_example["target"] = torch.cat([region_tgt_item, self.eos_item]) + region_example["prev_output_tokens"] = torch.cat([self.bos_item, region_tgt_item]) + region_example["conf"] = torch.tensor([1.0]) + examples.append(region_example) + elif prob >= 0.5 and self.split == 'train': + pos_example = example.copy() + pos_example["source"] = pos_src_item + pos_example["target"] = torch.cat([self.pos_tgt_item, self.eos_item]) + pos_example["prev_output_tokens"] = torch.cat([self.bos_item, self.pos_tgt_item]) + examples.append(pos_example) + elif self.split == 'train': + neg_example = example.copy() + neg_example["source"] = neg_src_item + neg_example["target"] = torch.cat([self.neg_tgt_item, self.eos_item]) + neg_example["prev_output_tokens"] = torch.cat([self.bos_item, self.neg_tgt_item]) + examples.append(neg_example) + + + + return examples + + def process_video_text_pair(self, index, tries=0, other_dataset=None): + + if other_dataset is not None: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = other_dataset[index] + else: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = self.video_dataset[index] + + + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_audio = torch.zeros(self.max_audio_len) + patch_mask = torch.tensor([True]) + patch_type = torch.tensor([1]) + + image_path = os.path.join(self.image_dir, image) + data_path = image_path + try: + max_num_frames = self.max_num_frames if hasattr(self, "max_num_frames") else -1 + frames, frame_indices, video_duration = self.video_reader( + data_path, self.num_frames, self.sample_type, max_num_frames=max_num_frames + ) + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading video {data_path}, " + f"randomly sample a new video as replacement" + ) + if tries < self.num_tries: + return self.process_video_text_pair(new_index, tries=tries+1, other_dataset=other_dataset) + else: + print("Videos are too corrupted, try increase the num_tries") + raise + + patch_video = self.patch_video_resize_transform(frames) + + patch_video = patch_video.permute(1, 0, 2, 3) # -> (C, T, h, w) + + + conf = torch.tensor([1.0]) + + if type == 'video_caption': + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + # assume the same negative samples as in for images, to test if distribution os video captions are different + neg_src_caption = self.pre_caption(self.get_negative_caption_video(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the video describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the video describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the video describe " {} "?'.format(neg_src_caption)) + + elif type == 'video_qa': + + question = self.pre_question(question, self.max_src_length) + ref_dict = {item.split('|!+')[1]: float(item.split('|!+')[0]) for item in refs.split('&&')} + answer = max(ref_dict, key=ref_dict.get) + conf = ref_dict[answer] + src_item = self.encode_text(" {}".format(question)) + tgt_item = self.encode_text(" {}".format(answer)) + conf = torch.tensor([conf]) + pos_src_item = self.encode_text(' what is the answer to question " {} ". is " {} "?'.format(question, answer)) + neg_src_item = self.encode_text( + ' what is the answer to question " {} ". is " {} "?'.format(question, self.get_negative_answer(answer, conf)) + ) + else: + print(type, "not implemented") + assert NotImplemented + + + + + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + pos_src_item = torch.cat([self.bos_item, pos_src_item, self.eos_item]) if type != 'visual_grounding' else None + neg_src_item = torch.cat([self.bos_item, neg_src_item, self.eos_item]) if type != 'visual_grounding' else None + + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_video": patch_video, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + "patch_type": patch_type, + "patch_audio": patch_audio, + } + + examples = [example] + prob = random.random() + if prob >= 0.5 and self.split == 'train': + pos_example = example.copy() + pos_example["source"] = pos_src_item + pos_example["target"] = torch.cat([self.pos_tgt_item, self.eos_item]) + pos_example["prev_output_tokens"] = torch.cat([self.bos_item, self.pos_tgt_item]) + examples.append(pos_example) + elif self.split == 'train': + neg_example = example.copy() + neg_example["source"] = neg_src_item + neg_example["target"] = torch.cat([self.neg_tgt_item, self.eos_item]) + neg_example["prev_output_tokens"] = torch.cat([self.bos_item, self.neg_tgt_item]) + examples.append(neg_example) + + + + + return examples + + def process_audio_text_pair(self, index, other_dataset=None): + + if other_dataset is not None: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = other_dataset[index] + else: + uniq_id, image, caption, question, refs, gt_objects, dataset_name, type = self.audio_dataset[index] + + + + + image_path = os.path.join(self.image_dir, image) + data_path = image_path + + try: + if '.mp4' in data_path: # extract audio from video + audio_reader = decord.AudioReader(data_path, sample_rate=self.audio_cfg['sample_rate'], mono=True,) + audio_data = to_torch(audio_reader[:]).squeeze(0) + # audio_reader.seek(0) + else: + audio_data, orig_sr = sf.read(data_path) + if audio_data.ndim>1: + audio_data = np.mean(audio_data,axis=1) + audio_data = int16_to_float32(float32_to_int16(audio_data)) # can we skip it? + audio_data = torch.tensor(audio_data).float() # (T) + + + if len(audio_data) == 0: + logger.warning( + f"Caught exception {e} when loading audio {data_path}, " + f"randomly sample a new audio as replacement" + ) + return self.process_audio_text_pair(new_index) + + sample = {} + + sample = get_audio_features( + sample, audio_data, self.max_audio_len, + data_truncating='rand_trunc', + data_filling='repeatpad', + audio_cfg=self.audio_cfg + ) + + + except Exception as e: + new_index = random.randint(0, len(self) - 1) + logger.warning( + f"Caught exception {e} when loading audio {data_path}, " + f"randomly sample a new audio as replacement" + ) + return self.process_audio_text_pair(new_index, other_dataset=other_dataset) + + + patch_audio = sample['waveform'] + + patch_image = torch.zeros((3, self.patch_image_size, self.patch_image_size)) + patch_video = torch.zeros((3, self.num_frames, self.patch_frame_size, self.patch_frame_size)) + + patch_mask = torch.tensor([True]) + + patch_type = torch.tensor([2]) + + + + conf = torch.tensor([1.0]) + + if 'caption' in type: + tgt_caption = self.pre_caption(caption, self.max_tgt_length) + pos_src_caption = self.pre_caption(caption, self.max_src_length) + # assume the same negative samples as in for images, to test if distribution os video captions are different + neg_src_caption = self.pre_caption(self.get_negative_caption_audio(caption, gt_objects), self.max_src_length) + src_item = self.encode_text(" what does the audio describe?") + tgt_item = self.encode_text(" {}".format(tgt_caption)) + pos_src_item = self.encode_text(' does the audio describe " {} "?'.format(pos_src_caption)) + neg_src_item = self.encode_text(' does the audio describe " {} "?'.format(neg_src_caption)) + else: + print(type, "not implemented") + assert NotImplemented + + + + src_item = torch.cat([self.bos_item, src_item, self.eos_item]) + target_item = torch.cat([tgt_item, self.eos_item]) + prev_output_item = torch.cat([self.bos_item, tgt_item]) + pos_src_item = torch.cat([self.bos_item, pos_src_item, self.eos_item]) if type != 'visual_grounding' else None + neg_src_item = torch.cat([self.bos_item, neg_src_item, self.eos_item]) if type != 'visual_grounding' else None + + + example = { + "id": uniq_id, + "source": src_item, + "patch_image": patch_image, + "patch_video": patch_video, + "patch_mask": patch_mask, + "target": target_item, + "prev_output_tokens": prev_output_item, + "conf": conf, + "patch_type": patch_type, + "patch_audio": patch_audio, + } + + examples = [example] + prob = random.random() + if prob >= 0.5 and self.split == 'train': + pos_example = example.copy() + pos_example["source"] = pos_src_item + pos_example["target"] = torch.cat([self.pos_tgt_item, self.eos_item]) + pos_example["prev_output_tokens"] = torch.cat([self.bos_item, self.pos_tgt_item]) + examples.append(pos_example) + elif self.split == 'train': + neg_example = example.copy() + neg_example["source"] = neg_src_item + neg_example["target"] = torch.cat([self.neg_tgt_item, self.eos_item]) + neg_example["prev_output_tokens"] = torch.cat([self.bos_item, self.neg_tgt_item]) + examples.append(neg_example) + + + + + return examples + + + def __getitem__(self, index): + with data_utils.numpy_seed(self.seed, self.epoch): + + extra_samples = [] + + + + + if self.only_video_data is not None: + pair_samples = self.process_video_text_pair(index, other_dataset=self.dataset) + + elif self.only_audio_data is not None: + pair_samples = self.process_audio_text_pair(index, other_dataset=self.dataset) + else: + pair_samples = self.process_image_text_pair(index) + + + if self.split == 'train' and self.dataset.data_cnt % self.image_text_vqa_cnt == 0: + if self.image_text_vqa_dataset: + pair_samples += self.process_image_text_pair(0, other_dataset=self.image_text_vqa_dataset) + + if self.split == 'train' and self.dataset.data_cnt % self.image_text_ground_cnt == 0: + if self.image_text_ground_dataset: + pair_samples += self.process_image_text_pair(0, other_dataset=self.image_text_ground_dataset) + + + if self.split == 'train' and self.dataset.data_cnt % self.image_text_cnt == 0: + if self.image_text_dataset: + pair_samples += self.process_image_text_pair(0, other_dataset=self.image_text_dataset) + + + + if self.split == 'train' and self.dataset.data_cnt % self.audio_cnt == 0: + if self.audio_with_video: + extra_samples += self.process_audio_text_pair(0) if self.audio_dataset else [] + else: + pair_samples += self.process_audio_text_pair(0) if self.audio_dataset else [] + + if self.split == 'train' and self.dataset.data_cnt % self.audio_text_cnt == 0: + if self.audio_text_dataset: + if self.audio_with_video: + extra_samples += self.process_audio_text_pair(0, other_dataset=self.audio_text_dataset) + else: + pair_samples += self.process_audio_text_pair(0, other_dataset=self.audio_text_dataset) + + + if self.split == 'train' and self.dataset.data_cnt % self.video_cnt == 0: + extra_samples += self.process_video_text_pair(0) if self.video_dataset else [] + + if self.split == 'train' and self.dataset.data_cnt % self.video_text_cnt == 0: + if self.video_text_dataset: + extra_samples += self.process_video_text_pair(0, other_dataset=self.video_text_dataset) + + + return pair_samples, extra_samples + + def word_starts(self, source): + if self.mask_whole_word is not None: + is_word_start = self.mask_whole_word.gather(0, source) + else: + is_word_start = torch.ones(source.size()) + is_word_start[0] = 0 + is_word_start[-1] = 0 + return is_word_start + + def add_whole_word_mask(self, source, p): + is_word_start = self.word_starts(source) + num_to_mask = int(math.ceil(is_word_start.float().sum() * p)) + num_inserts = 0 + if num_to_mask == 0: + return source + + if self.mask_span_distribution is not None: + lengths = self.mask_span_distribution.sample(sample_shape=(num_to_mask,)) + + # Make sure we have enough to mask + cum_length = torch.cumsum(lengths, 0) + while cum_length[-1] < num_to_mask: + lengths = torch.cat( + [ + lengths, + self.mask_span_distribution.sample(sample_shape=(num_to_mask,)), + ], + dim=0, + ) + cum_length = torch.cumsum(lengths, 0) + + # Trim to masking budget + i = 0 + while cum_length[i] < num_to_mask: + i += 1 + lengths[i] = num_to_mask - (0 if i == 0 else cum_length[i - 1]) + num_to_mask = i + 1 + lengths = lengths[:num_to_mask] + + # Handle 0-length mask (inserts) separately + lengths = lengths[lengths > 0] + num_inserts = num_to_mask - lengths.size(0) + num_to_mask -= num_inserts + if num_to_mask == 0: + return self.add_insertion_noise(source, num_inserts / source.size(0)) + + assert (lengths > 0).all() + else: + lengths = torch.ones((num_to_mask,)).long() + assert is_word_start[-1] == 0 + word_starts = is_word_start.nonzero(as_tuple=False) + indices = word_starts[ + torch.randperm(word_starts.size(0))[:num_to_mask] + ].squeeze(1) + mask_random = torch.FloatTensor(num_to_mask).uniform_() < self.random_ratio + + source_length = source.size(0) + assert source_length - 1 not in indices + to_keep = torch.ones(source_length, dtype=torch.bool) + is_word_start[ + -1 + ] = 255 # acts as a long length, so spans don't go over the end of doc + if self.replace_length == 0: + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + + if self.mask_span_distribution is not None: + assert len(lengths.size()) == 1 + assert lengths.size() == indices.size() + lengths -= 1 + while indices.size(0) > 0: + assert lengths.size() == indices.size() + lengths -= is_word_start[indices + 1].long() + uncompleted = lengths >= 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + lengths = lengths[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + else: + # A bit faster when all lengths are 1 + while indices.size(0) > 0: + uncompleted = is_word_start[indices + 1] == 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 4, len(self.tgt_dict) - self.code_dict_size - self.num_bins, size=(mask_random.sum(),) + ) + + assert source_length - 1 not in indices + + source = source[to_keep] + + if num_inserts > 0: + source = self.add_insertion_noise(source, num_inserts / source.size(0)) + + return source + + def add_insertion_noise(self, tokens, p): + if p == 0.0: + return tokens + + num_tokens = len(tokens) + n = int(math.ceil(num_tokens * p)) + + noise_indices = torch.randperm(num_tokens + n - 2)[:n] + 1 + noise_mask = torch.zeros(size=(num_tokens + n,), dtype=torch.bool) + noise_mask[noise_indices] = 1 + result = torch.LongTensor(n + len(tokens)).fill_(-1) + + num_random = int(math.ceil(n * self.random_ratio)) + result[noise_indices[num_random:]] = self.mask_idx + result[noise_indices[:num_random]] = torch.randint( + low=4, high=len(self.tgt_dict)-self.code_dict_size-self.num_bins, size=(num_random,) + ) + + result[~noise_mask] = tokens + + assert (result >= 0).all() + return result + + def collater(self, samples, pad_to_length=None): + """Merge samples of different tasks to form two mini-batches. + Args: + samples (List[Tuple]): samples to collate + Returns: + Tuple[dict]: two mini-batch containing the data of different tasks + """ + + samples_v1 = [] # containing image-text pairs + samples_v2 = [] # containing detection data, text data and image data + for sample_tuple in samples: + samples_v1 += sample_tuple[0] + samples_v2 += sample_tuple[1] + if samples_v2 != []: + res_v1 = collate(samples_v1, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + res_v2 = collate(samples_v2, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + return res_v1, res_v2 + else: + res_v1 = collate(samples_v1, pad_idx=self.src_dict.pad(), eos_idx=self.eos) + return res_v1 diff --git a/data/video_utils.py b/data/video_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e7b613e5bafe964865863d55389f9acbf9d60160 --- /dev/null +++ b/data/video_utils.py @@ -0,0 +1,125 @@ +""" +Modified from https://github.com/m-bain/frozen-in-time/blob/22a91d78405ec6032fdf521ae1ff5573358e632f/base/base_dataset.py +""" +import random +import av +import decord +import torch +import numpy as np +import math +# decord.bridge.set_bridge("torch") + +from decord.bridge import to_torch + +def pts_to_secs(pts: int, time_base: float, start_pts: int) -> float: + """ + Converts a present time with the given time base and start_pts offset to seconds. + + Returns: + time_in_seconds (float): The corresponding time in seconds. + + https://github.com/facebookresearch/pytorchvideo/blob/main/pytorchvideo/data/utils.py#L54-L64 + """ + if pts == math.inf: + return math.inf + + return int(pts - start_pts) * time_base + + +def get_pyav_video_duration(video_reader): + video_stream = video_reader.streams.video[0] + video_duration = pts_to_secs( + video_stream.duration, + video_stream.time_base, + video_stream.start_time + ) + return float(video_duration) + + +def get_frame_indices_by_fps(): + pass + + +def get_frame_indices(num_frames, vlen, sample='rand', fix_start=None, input_fps=1, max_num_frames=-1): + if sample in ["rand", "middle"]: + acc_samples = min(num_frames, vlen) + # split the video into `acc_samples` intervals, and sample from each interval. + intervals = np.linspace(start=0, stop=vlen, num=acc_samples + 1).astype(int) + ranges = [] + for idx, interv in enumerate(intervals[:-1]): + ranges.append((interv, intervals[idx + 1] - 1)) + if sample == 'rand': + try: + frame_indices = [random.choice(range(x[0], x[1])) for x in ranges] + except: + frame_indices = np.random.permutation(vlen)[:acc_samples] + frame_indices.sort() + frame_indices = list(frame_indices) + elif fix_start is not None: + frame_indices = [x[0] + fix_start for x in ranges] + elif sample == 'middle': + frame_indices = [(x[0] + x[1]) // 2 for x in ranges] + else: + raise NotImplementedError + + if len(frame_indices) < num_frames: # padded with last frame + padded_frame_indices = [frame_indices[-1]] * num_frames + padded_frame_indices[:len(frame_indices)] = frame_indices + frame_indices = padded_frame_indices + elif "fps" in sample: # fps0.5, sequentially sample frames at 0.5 fps + output_fps = float(sample[3:]) + duration = float(vlen) / input_fps + delta = 1 / output_fps # gap between frames, this is also the clip length each frame represents + frame_seconds = np.arange(0 + delta / 2, duration + delta / 2, delta) + frame_indices = np.around(frame_seconds * input_fps).astype(int) + frame_indices = [e for e in frame_indices if e < vlen] + + if max_num_frames > 0 and len(frame_indices) > max_num_frames: + frame_indices = frame_indices[:max_num_frames] + # frame_indices = np.linspace(0 + delta / 2, duration + delta / 2, endpoint=False, num=max_num_frames) + else: + raise ValueError + return frame_indices + + +def read_frames_av(video_path, num_frames, sample='rand', fix_start=None, max_num_frames=-1): + reader = av.open(video_path) + frames = [torch.from_numpy(f.to_rgb().to_ndarray()) for f in reader.decode(video=0)] + vlen = len(frames) + duration = get_pyav_video_duration(reader) + fps = vlen / float(duration) + frame_indices = get_frame_indices( + num_frames, vlen, sample=sample, fix_start=fix_start, + input_fps=fps, max_num_frames=max_num_frames + ) + frames = torch.stack([frames[idx] for idx in frame_indices]) # (T, H, W, C), torch.uint8 + frames = frames.permute(0, 3, 1, 2) # (T, C, H, W), torch.uint8 + return frames, frame_indices, duration + +# decord.bridge.set_bridge("torch") +def read_frames_decord(video_path, num_frames, sample='rand', fix_start=None, max_num_frames=-1): + video_reader = decord.VideoReader(video_path, num_threads=1) + vlen = len(video_reader) + fps = video_reader.get_avg_fps() + duration = vlen / float(fps) + frame_indices = get_frame_indices( + num_frames, vlen, sample=sample, fix_start=fix_start, + input_fps=fps, max_num_frames=max_num_frames + ) + frames = video_reader.get_batch(frame_indices) # (T, H, W, C), torch.uint8 + frames = to_torch(frames) + # try: + # print(type(frames)) + # frames = frames.asnumpy() + # frames = torch.from_numpy(frames) + # except: + # print("expt", type(frames)) + # pass + frames = frames.permute(0, 3, 1, 2) # (T, C, H, W), torch.uint8 + return frames, frame_indices, duration + + +VIDEO_READER_FUNCS = { + 'av': read_frames_av, + 'decord': read_frames_decord +} diff --git a/datasets.md b/datasets.md new file mode 100644 index 0000000000000000000000000000000000000000..58eb16a511fbeb10240423d6ec8577da446700fa --- /dev/null +++ b/datasets.md @@ -0,0 +1,44 @@ +# Datasets + +We provide links to download our preprocessed dataset. If you would like to process the data on your own, we will soon provide scripts for you to do so. + +## Pretraining + * A small subset of the pretraining data + + The pretraining datasets used in OFA are all publicly available. Here we provide the public links to these data, it is recommended that you download the data from the links first, and then process the downloaded dataset into a similar format as the examples we provided. +- _CC12M_: https://github.com/google-research-datasets/conceptual-12m +- _CC3M_: https://github.com/google-research-datasets/conceptual-captions +- _SBU_: https://www.cs.virginia.edu/~vicente/sbucaptions +- _COCO_: https://cocodataset.org/#home +- _VG_: https://visualgenome.org/ +- _VQAv2_: https://visualqa.org/ +- _GQA_: https://cs.stanford.edu/people/dorarad/gqa/about.html +- _RefCOCO_/_RefCOCO+_/RefCOCOg: https://github.com/lichengunc/refer +- _OpenImages_: https://storage.googleapis.com/openimages/web/index.html +- _Object365_: https://www.objects365.org/overview.html +- _YFCC100M (subset)_: https://github.com/openai/CLIP/blob/main/data/yfcc100m.md +- _ImageNet-21K_: https://image-net.org/index.php +- _Pile_: https://pile.eleuther.ai + +## Vision & Language Tasks + * Dataset for Caption + * Dataset for RefCOCO + * Dataset for RefCOCO+ + * Dataset for RefCOCOg + * Dataset for VQAv2 (we have also provided chunked parts of the dataset files for more convenient downloading, please refer to issue #68) + * Dataset for SNLI-VE + * Dataset for Text-to-Image Genearion + * Dataset for Text-to-Image Genearion (with original id) + +## Vision Tasks + * Dataset for ImageNet-1K + +## Language Tasks + * Dataset for COLA + * Dataset for MNLI + * Dataset for MRPC + * Dataset for QNLI + * Dataset for QQP + * Dataset for RTE + * Dataset for SST2 + * Dataset for Gigaword diff --git a/evaluate.py b/evaluate.py new file mode 100644 index 0000000000000000000000000000000000000000..a67400d9520d10bb331c1d1c26d94404cdbbf631 --- /dev/null +++ b/evaluate.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 -u +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import logging +import os +import sys + +import numpy as np +import torch +from fairseq import distributed_utils, options, tasks, utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.logging import progress_bar +from fairseq.utils import reset_logging +from omegaconf import DictConfig + +from utils import checkpoint_utils +from utils.eval_utils import eval_step, merge_results +from utils.zero_shot_utils import zero_shot_step + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("ofa.evaluate") + +from utils.utils import print_trainable_params_percentage, setup_for_distributed + +def apply_half(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.half) + return t + + +def main(cfg: DictConfig, **kwargs): + utils.import_user_module(cfg.common) + + setup_for_distributed(distributed_utils.is_master(cfg.distributed_training)) + + reset_logging() + # logger.info(cfg) + + assert ( + cfg.dataset.max_tokens is not None or cfg.dataset.batch_size is not None + ), "Must specify batch size either with --max-tokens or --batch-size" + + # Fix seed for stochastic decoding + if cfg.common.seed is not None and not cfg.generation.no_seed_provided: + np.random.seed(cfg.common.seed) + utils.set_torch_seed(cfg.common.seed) + + use_fp16 = cfg.common.fp16 + use_cuda = torch.cuda.is_available() and not cfg.common.cpu + + if use_cuda: + torch.cuda.set_device(cfg.distributed_training.device_id) + + # Load ensemble + overrides = eval(cfg.common_eval.model_overrides) + # Deal with beam-search / all-candidate VQA eval + if cfg.task._name == "vqa_gen": + overrides['val_inference_type'] = "beamsearch" if kwargs['beam_search_vqa_eval'] else "allcand" + + logger.info("loading model(s) from {}".format(cfg.common_eval.path)) + + # print("cfg", cfg) + # print(kwargs) + # cfg.model.num_frames = kwargs["num_frames"] + # cfg.model.patch_frame_size = kwargs["patch_frame_size"] + # print("cfg.model", cfg.model) + # strict = getattr(kwargs, 'strict', True) + strict = kwargs['strict'] + logger.info('load checkpoint, strict:{}'.format(strict)) + + if kwargs["zero_shot"]: + for arg_name, arg_val in overrides.items(): + cfg.task[arg_name] = arg_val + # print("Zero-shot eval", cfg.task, cfg) + + if hasattr(cfg.task, "add_caption"): + cfg.task.add_caption = False + print("cfg.task", cfg.task) + task = tasks.setup_task(cfg.task) + # cfg.criterion.sample_patch_num = 776 + + + models, saved_cfg = checkpoint_utils.load_model_ensemble( + utils.split_paths(cfg.common_eval.path), + arg_overrides=overrides, + task=task, + suffix=cfg.checkpoint.checkpoint_suffix, + strict=((cfg.checkpoint.checkpoint_shard_count == 1) and strict), + num_shards=cfg.checkpoint.checkpoint_shard_count, + ) + for m in models: + m.encoder.sample_patch_num = 776 + saved_cfg.task = cfg.task + # print("saved_cfg", saved_cfg) + else: + models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task( + utils.split_paths(cfg.common_eval.path), + arg_overrides=overrides, + suffix=cfg.checkpoint.checkpoint_suffix, + strict=((cfg.checkpoint.checkpoint_shard_count == 1) and strict), + num_shards=cfg.checkpoint.checkpoint_shard_count, + ) + + + + # task.cfg['evaluate_cfg'] = cfg.task + # print(task.cfg) + kwargs['evaluate_cfg'] = cfg.task + # print(kwargs) + # loading the dataset should happen after the checkpoint has been loaded so we can give it the saved task config + task.load_dataset(cfg.dataset.gen_subset, task_cfg=saved_cfg.task) + + # Move models to GPU + for model, ckpt_path in zip(models, utils.split_paths(cfg.common_eval.path)): + if kwargs['ema_eval']: + logger.info("loading EMA weights from {}".format(ckpt_path)) + model.load_state_dict(checkpoint_utils.load_ema_from_checkpoint(ckpt_path)['model']) + model.eval() + print("use fp16", use_fp16) + if use_fp16: + + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + + # Load dataset (possibly sharded) + itr = task.get_batch_iterator( + dataset=task.dataset(cfg.dataset.gen_subset), + max_tokens=cfg.dataset.max_tokens, + max_sentences=cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + task.max_positions(), *[m.max_positions() for m in models] + ), + ignore_invalid_inputs=cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=cfg.dataset.required_batch_size_multiple, + seed=cfg.common.seed, + num_shards=cfg.distributed_training.distributed_world_size, + shard_id=cfg.distributed_training.distributed_rank, + num_workers=cfg.dataset.num_workers, + data_buffer_size=cfg.dataset.data_buffer_size, + ).next_epoch_itr(shuffle=False) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + ) + + # Initialize generator + generator = task.build_generator(models, cfg.generation) + + results = [] + score_sum = torch.FloatTensor([0]).cuda() + score_cnt = torch.FloatTensor([0]).cuda() + + score_sum_list = [] + score_cnt_list = [] + for sample in progress: + if "net_input" not in sample: + continue + sample = utils.move_to_cuda(sample) if use_cuda else sample + sample = utils.apply_to_sample(apply_half, sample) if cfg.common.fp16 else sample + with torch.no_grad(): + if kwargs["zero_shot"] and kwargs['noconstraints']: + result, scores = zero_shot_step(task, generator, models, sample) + else: + result, scores = eval_step(task, generator, models, sample, **kwargs) + ### else refcoco res, score, other_scores + + # print(scores) + scalar = False + if isinstance(scores, list): + if not isinstance(scores[0], list): + try: + tmp = sum(scores[0]) + scalar=False + except: + scalar=True + # print(scalar) + # print(sum(scores[0])) + if isinstance(scores, list) and not scalar: + names = result[0] + result = result[1] + if len(score_sum_list) == 0: + score_sum_list = [torch.FloatTensor([0]).cuda() for i in range(len(scores))] + score_cnt_list = [torch.FloatTensor([0]).cuda() for i in range(len(scores))] + + for i in range(len(scores)): + + + score_sum_list[i] += sum(scores[i]) if scores[i] is not None else 0 + score_cnt_list[i] += len(scores[i]) if scores[i] is not None else 0 + else: + for i in range(len(scores)): + score_sum_list[i] += sum(scores[i]) if scores[i] is not None else 0 + score_cnt_list[i] += len(scores[i]) if scores[i] is not None else 0 + else: + score_sum += sum(scores) if scores is not None else 0 + score_cnt += len(scores) if scores is not None else 0 + results += result + progress.log({"sentences": sample["nsentences"]}) + + + ### merge per metric + if len(score_sum_list) > 0: + print(names, len(score_sum_list)) + for i in range(len(score_sum_list)): + print(names[i]) + merge_results(task, cfg, logger, score_cnt_list[i], score_sum_list[i], results) + else: + merge_results(task, cfg, logger, score_cnt, score_sum, results) + + +def cli_main(): + parser = options.get_generation_parser() + parser.add_argument("--ema-eval", action='store_true', help="Use EMA weights to make evaluation.") + parser.add_argument("--beam-search-vqa-eval", action='store_true', help="Use beam search for vqa evaluation (faster inference speed but sub-optimal result), if not specified, we compute scores for each answer in the candidate set, which is slower but can obtain best result.") + parser.add_argument("--zero-shot", action='store_true') + parser.add_argument("--strict", action='store_false') + parser.add_argument("--noconstraints", action='store_true') + args = options.parse_args_and_arch(parser) + cfg = convert_namespace_to_omegaconf(args) + distributed_utils.call_main( + cfg, main, ema_eval=args.ema_eval, beam_search_vqa_eval=args.beam_search_vqa_eval, + zero_shot=args.zero_shot, strict=args.strict, noconstraints=args.noconstraints + ) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/.github/ISSUE_TEMPLATE.md b/fairseq/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000000000000000000000000000000000000..5c4c4493e4a8e5386b927e4f4554df925955d129 --- /dev/null +++ b/fairseq/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,3 @@ +## 👉 [Please follow one of these issue templates](https://github.com/pytorch/fairseq/issues/new/choose) 👈 + +Note: to keep the backlog clean and actionable, issues may be immediately closed if they do not follow one of the above issue templates. diff --git a/fairseq/.github/ISSUE_TEMPLATE/bug_report.md b/fairseq/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000000000000000000000000000000000000..aa15123d8ef25c2de745572563505cf0ddc4e351 --- /dev/null +++ b/fairseq/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,43 @@ +--- +name: 🐛 Bug Report +about: Submit a bug report to help us improve +labels: 'bug, needs triage' +--- + +## 🐛 Bug + + + +### To Reproduce + +Steps to reproduce the behavior (**always include the command you ran**): + +1. Run cmd '....' +2. See error + + + + +#### Code sample + + +### Expected behavior + + + +### Environment + + - fairseq Version (e.g., 1.0 or main): + - PyTorch Version (e.g., 1.0) + - OS (e.g., Linux): + - How you installed fairseq (`pip`, source): + - Build command you used (if compiling from source): + - Python version: + - CUDA/cuDNN version: + - GPU models and configuration: + - Any other relevant information: + +### Additional context + + diff --git a/fairseq/.github/ISSUE_TEMPLATE/documentation.md b/fairseq/.github/ISSUE_TEMPLATE/documentation.md new file mode 100644 index 0000000000000000000000000000000000000000..3a6e2e9ea4bb71102122c17ff53051eb3770cb5e --- /dev/null +++ b/fairseq/.github/ISSUE_TEMPLATE/documentation.md @@ -0,0 +1,15 @@ +--- +name: 📚 Documentation/Typos +about: Report an issue related to documentation or a typo +labels: 'documentation, needs triage' +--- + +## 📚 Documentation + +For typos and doc fixes, please go ahead and: + +1. Create an issue. +2. Fix the typo. +3. Submit a PR. + +Thanks! diff --git a/fairseq/.github/ISSUE_TEMPLATE/feature_request.md b/fairseq/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000000000000000000000000000000000000..93c8668041f8a7af29e4c11e905d8b56b946dd51 --- /dev/null +++ b/fairseq/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,24 @@ +--- +name: 🚀 Feature Request +about: Submit a proposal/request for a new feature +labels: 'enhancement, help wanted, needs triage' +--- + +## 🚀 Feature Request + + +### Motivation + + + +### Pitch + + + +### Alternatives + + + +### Additional context + + diff --git a/fairseq/.github/ISSUE_TEMPLATE/how-to-question.md b/fairseq/.github/ISSUE_TEMPLATE/how-to-question.md new file mode 100644 index 0000000000000000000000000000000000000000..04f3f15d3ed391e26ca87f726ae88f30d1d414ab --- /dev/null +++ b/fairseq/.github/ISSUE_TEMPLATE/how-to-question.md @@ -0,0 +1,33 @@ +--- +name: ❓ Questions/Help +about: If you have questions, please first search existing issues and docs +labels: 'question, needs triage' +--- + +## ❓ Questions and Help + +### Before asking: +1. search the issues. +2. search the docs. + + + +#### What is your question? + +#### Code + + + +#### What have you tried? + +#### What's your environment? + + - fairseq Version (e.g., 1.0 or main): + - PyTorch Version (e.g., 1.0) + - OS (e.g., Linux): + - How you installed fairseq (`pip`, source): + - Build command you used (if compiling from source): + - Python version: + - CUDA/cuDNN version: + - GPU models and configuration: + - Any other relevant information: diff --git a/fairseq/.github/PULL_REQUEST_TEMPLATE.md b/fairseq/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000000000000000000000000000000000000..d005e2df4f717ea4844a8320981d77d96e425a52 --- /dev/null +++ b/fairseq/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,16 @@ +# Before submitting + +- [ ] Was this discussed/approved via a Github issue? (no need for typos, doc improvements) +- [ ] Did you read the [contributor guideline](https://github.com/pytorch/fairseq/blob/main/CONTRIBUTING.md)? +- [ ] Did you make sure to update the docs? +- [ ] Did you write any new necessary tests? + +## What does this PR do? +Fixes # (issue). + +## PR review +Anyone in the community is free to review the PR once the tests have passed. +If we didn't discuss your PR in Github issues there's a high chance it will not be merged. + +## Did you have fun? +Make sure you had fun coding 🙃 diff --git a/fairseq/.github/stale.yml b/fairseq/.github/stale.yml new file mode 100644 index 0000000000000000000000000000000000000000..b12867dab005e7a7608d4c7138a67d409c76f7ae --- /dev/null +++ b/fairseq/.github/stale.yml @@ -0,0 +1,30 @@ +# Configuration for probot-stale - https://github.com/probot/stale +# Mostly copied from github.com/facebook/react/blob/master/.github/stale.yml +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 90 +# Number of days of inactivity before a stale issue is closed +daysUntilClose: 7 +# Issues with these labels will never be considered stale +exemptLabels: + - bug +# Label to use when marking an issue as stale +staleLabel: stale +issues: + # Comment to post when marking an issue as stale. + markComment: > + This issue has been automatically marked as stale. + **If this issue is still affecting you, please leave any comment** (for example, "bump"), and we'll keep it open. + We are sorry that we haven't been able to prioritize it yet. If you have any new additional information, please include it with your comment! + # Comment to post when closing a stale issue. + closeComment: > + Closing this issue after a prolonged period of inactivity. If this issue is still present in the latest release, please create a new issue with up-to-date information. Thank you! +pulls: + # Comment to post when marking a pull request as stale. + markComment: > + This pull request has been automatically marked as stale. + **If this pull request is still relevant, please leave any comment** (for example, "bump"), and we'll keep it open. + We are sorry that we haven't been able to prioritize reviewing it yet. Your contribution is very much appreciated. + # Comment to post when closing a stale pull request. + closeComment: > + Closing this pull request after a prolonged period of inactivity. If this issue is still present in the latest release, please ask for this pull request to be reopened. Thank you! + diff --git a/fairseq/.github/workflows/build.yml b/fairseq/.github/workflows/build.yml new file mode 100644 index 0000000000000000000000000000000000000000..981b59416f176121eded2aedfc1af6ea9ee19c84 --- /dev/null +++ b/fairseq/.github/workflows/build.yml @@ -0,0 +1,55 @@ +name: build + +on: + # Trigger the workflow on push to main or any pull request + push: + branches: + - main + pull_request: + +jobs: + build: + + strategy: + max-parallel: 4 + matrix: + platform: [ubuntu-latest, macos-latest] + python-version: [3.6, 3.7] + + runs-on: ${{ matrix.platform }} + + steps: + - uses: actions/checkout@v2 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + - name: Conditionally install pytorch + if: matrix.platform == 'windows-latest' + run: pip3 install torch -f https://download.pytorch.org/whl/torch_stable.html + + - name: Install locally + run: | + python -m pip install --upgrade pip + git submodule update --init --recursive + python setup.py build_ext --inplace + python -m pip install --editable . + + - name: Install optional test requirements + run: | + python -m pip install iopath transformers pyarrow + python -m pip install git+https://github.com/facebookresearch/fairscale.git@main + + - name: Lint with flake8 + run: | + pip install flake8 + # stop the build if there are Python syntax errors or undefined names + flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics --extend-exclude fairseq/model_parallel/megatron + # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide + flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics --extend-exclude fairseq/model_parallel/megatron + + - name: Run tests + run: | + python setup.py test diff --git a/fairseq/.github/workflows/build_wheels.yml b/fairseq/.github/workflows/build_wheels.yml new file mode 100644 index 0000000000000000000000000000000000000000..7261708596f0c781cf670119cb63c811f9c0d50c --- /dev/null +++ b/fairseq/.github/workflows/build_wheels.yml @@ -0,0 +1,41 @@ +name: build_wheels + +on: + push: + branches: + - v[0-9]+.[0-9]+.[x0-9]+ + tags: + - v* + +jobs: + build_wheels: + name: Build wheels on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, macos-latest] + + steps: + - uses: actions/checkout@v2 + + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: '3.7' + + - name: Install cibuildwheel + run: | + python -m pip install cibuildwheel + + - name: Build wheels for CPython + run: | + python -m cibuildwheel --output-dir dist + env: + CIBW_BUILD: "cp36-*64 cp37-*64 cp38-*64" + CIBW_MANYLINUX_X86_64_IMAGE: manylinux1 + CIBW_BEFORE_BUILD: git submodule update --init --recursive && pip install . + + - uses: actions/upload-artifact@v2 + with: + name: wheels + path: ./dist/*.whl diff --git a/fairseq/.gitignore b/fairseq/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..4112804793c441354e6a2e6398075eea72ab6c0a --- /dev/null +++ b/fairseq/.gitignore @@ -0,0 +1,136 @@ +# JetBrains PyCharm IDE +.idea/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# macOS dir files +.DS_Store + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# Checkpoints +checkpoints + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# dotenv +.env + +# virtualenv +.venv +venv/ +ENV/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# Generated files +/fairseq/temporal_convolution_tbc +/fairseq/modules/*_layer/*_forward.cu +/fairseq/modules/*_layer/*_backward.cu +/fairseq/version.py + +# data +data-bin/ + +# reranking +/examples/reranking/rerank_data + +# Cython-generated C++ source files +/fairseq/data/data_utils_fast.cpp +/fairseq/data/token_block_utils_fast.cpp + +# VSCODE +.vscode/ftp-sync.json +.vscode/settings.json + +# Experimental Folder +experimental/* + +# Weights and Biases logs +wandb/ diff --git a/fairseq/.gitmodules b/fairseq/.gitmodules new file mode 100644 index 0000000000000000000000000000000000000000..07a55d45d4f0bed755dbfc1f440f214ed43d206a --- /dev/null +++ b/fairseq/.gitmodules @@ -0,0 +1,4 @@ +[submodule "fairseq/model_parallel/megatron"] + path = fairseq/model_parallel/megatron + url = https://github.com/ngoyal2707/Megatron-LM + branch = fairseq diff --git a/fairseq/CODE_OF_CONDUCT.md b/fairseq/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000000000000000000000000000000000..a0cbeaab7650bf08267fbdbc9bb54e845c88f392 --- /dev/null +++ b/fairseq/CODE_OF_CONDUCT.md @@ -0,0 +1,77 @@ +# Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to make participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies within all project spaces, and it also applies when +an individual is representing the project or its community in public spaces. +Examples of representing a project or community include using an official +project e-mail address, posting via an official social media account, or acting +as an appointed representative at an online or offline event. Representation of +a project may be further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at . All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq + diff --git a/fairseq/CONTRIBUTING.md b/fairseq/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..3930c46196b7b6082cacc76fd5808b49677ae805 --- /dev/null +++ b/fairseq/CONTRIBUTING.md @@ -0,0 +1,28 @@ +# Contributing to Facebook AI Research Sequence-to-Sequence Toolkit (fairseq) +We want to make contributing to this project as easy and transparent as +possible. + +## Pull Requests +We actively welcome your pull requests. + +1. Fork the repo and create your branch from `main`. +2. If you've added code that should be tested, add tests. +3. If you've changed APIs, update the documentation. +4. Ensure the test suite passes. +5. Make sure your code lints. +6. If you haven't already, complete the Contributor License Agreement ("CLA"). + +## Contributor License Agreement ("CLA") +In order to accept your pull request, we need you to submit a CLA. You only need +to do this once to work on any of Facebook's open source projects. + +Complete your CLA here: + +## Issues +We use GitHub issues to track public bugs. Please ensure your description is +clear and has sufficient instructions to be able to reproduce the issue. + +## License +By contributing to Facebook AI Research Sequence-to-Sequence Toolkit (fairseq), +you agree that your contributions will be licensed under the LICENSE file in +the root directory of this source tree. diff --git a/fairseq/LICENSE b/fairseq/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b96dcb0480a0b0be0727976e5202a1e7b23edc3f --- /dev/null +++ b/fairseq/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/fairseq/README.md b/fairseq/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dd687174808a6ff341f597eb6a4cc9a1687d74a1 --- /dev/null +++ b/fairseq/README.md @@ -0,0 +1,229 @@ +

+ +
+
+ MIT License + Latest Release + Build Status + Documentation Status +

+ +-------------------------------------------------------------------------------- + +Fairseq(-py) is a sequence modeling toolkit that allows researchers and +developers to train custom models for translation, summarization, language +modeling and other text generation tasks. + +We provide reference implementations of various sequence modeling papers: + +
List of implemented papers

+ +* **Convolutional Neural Networks (CNN)** + + [Language Modeling with Gated Convolutional Networks (Dauphin et al., 2017)](examples/language_model/conv_lm/README.md) + + [Convolutional Sequence to Sequence Learning (Gehring et al., 2017)](examples/conv_seq2seq/README.md) + + [Classical Structured Prediction Losses for Sequence to Sequence Learning (Edunov et al., 2018)](https://github.com/pytorch/fairseq/tree/classic_seqlevel) + + [Hierarchical Neural Story Generation (Fan et al., 2018)](examples/stories/README.md) + + [wav2vec: Unsupervised Pre-training for Speech Recognition (Schneider et al., 2019)](examples/wav2vec/README.md) +* **LightConv and DynamicConv models** + + [Pay Less Attention with Lightweight and Dynamic Convolutions (Wu et al., 2019)](examples/pay_less_attention_paper/README.md) +* **Long Short-Term Memory (LSTM) networks** + + Effective Approaches to Attention-based Neural Machine Translation (Luong et al., 2015) +* **Transformer (self-attention) networks** + + Attention Is All You Need (Vaswani et al., 2017) + + [Scaling Neural Machine Translation (Ott et al., 2018)](examples/scaling_nmt/README.md) + + [Understanding Back-Translation at Scale (Edunov et al., 2018)](examples/backtranslation/README.md) + + [Adaptive Input Representations for Neural Language Modeling (Baevski and Auli, 2018)](examples/language_model/README.adaptive_inputs.md) + + [Lexically constrained decoding with dynamic beam allocation (Post & Vilar, 2018)](examples/constrained_decoding/README.md) + + [Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context (Dai et al., 2019)](examples/truncated_bptt/README.md) + + [Adaptive Attention Span in Transformers (Sukhbaatar et al., 2019)](examples/adaptive_span/README.md) + + [Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019)](examples/translation_moe/README.md) + + [RoBERTa: A Robustly Optimized BERT Pretraining Approach (Liu et al., 2019)](examples/roberta/README.md) + + [Facebook FAIR's WMT19 News Translation Task Submission (Ng et al., 2019)](examples/wmt19/README.md) + + [Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019)](examples/joint_alignment_translation/README.md ) + + [Multilingual Denoising Pre-training for Neural Machine Translation (Liu et at., 2020)](examples/mbart/README.md) + + [Neural Machine Translation with Byte-Level Subwords (Wang et al., 2020)](examples/byte_level_bpe/README.md) + + [Unsupervised Quality Estimation for Neural Machine Translation (Fomicheva et al., 2020)](examples/unsupervised_quality_estimation/README.md) + + [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations (Baevski et al., 2020)](examples/wav2vec/README.md) + + [Generating Medical Reports from Patient-Doctor Conversations Using Sequence-to-Sequence Models (Enarvi et al., 2020)](examples/pointer_generator/README.md) + + [Linformer: Self-Attention with Linear Complexity (Wang et al., 2020)](examples/linformer/README.md) + + [Cross-lingual Retrieval for Iterative Self-Supervised Training (Tran et al., 2020)](examples/criss/README.md) + + [Deep Transformers with Latent Depth (Li et al., 2020)](examples/latent_depth/README.md) + + [Unsupervised Cross-lingual Representation Learning for Speech Recognition (Conneau et al., 2020)](https://arxiv.org/abs/2006.13979) + + [Robust wav2vec 2.0: Analyzing Domain Shift in Self-Supervised Pre-Training (Hsu, et al., 2021)](https://arxiv.org/abs/2104.01027) + + [Unsupervised Speech Recognition (Baevski, et al., 2021)](https://arxiv.org/abs/2105.11084) +* **Non-autoregressive Transformers** + + Non-Autoregressive Neural Machine Translation (Gu et al., 2017) + + Deterministic Non-Autoregressive Neural Sequence Modeling by Iterative Refinement (Lee et al. 2018) + + Insertion Transformer: Flexible Sequence Generation via Insertion Operations (Stern et al. 2019) + + Mask-Predict: Parallel Decoding of Conditional Masked Language Models (Ghazvininejad et al., 2019) + + [Levenshtein Transformer (Gu et al., 2019)](examples/nonautoregressive_translation/README.md) +* **Finetuning** + + [Better Fine-Tuning by Reducing Representational Collapse (Aghajanyan et al. 2020)](examples/rxf/README.md) + +

+ +### What's New: + +* September 2021 [`master` branch renamed to `main`](https://github.com/github/renaming). +* July 2021 [Released DrNMT code](examples/discriminative_reranking_nmt/README.md) +* July 2021 [Released Robust wav2vec 2.0 model](examples/wav2vec/README.md) +* June 2021 [Released XLMR-XL and XLMR-XXL models](examples/xlmr/README.md) +* May 2021 [Released Unsupervised Speech Recognition code](examples/wav2vec/unsupervised/README.md) +* March 2021 [Added full parameter and optimizer state sharding + CPU offloading](examples/fully_sharded_data_parallel/README.md) +* February 2021 [Added LASER training code](examples/laser/README.md) +* December 2020: [Added Adaptive Attention Span code](examples/adaptive_span/README.md) +* December 2020: [GottBERT model and code released](examples/gottbert/README.md) +* November 2020: Adopted the [Hydra](https://github.com/facebookresearch/hydra) configuration framework + * [see documentation explaining how to use it for new and existing projects](docs/hydra_integration.md) +* November 2020: [fairseq 0.10.0 released](https://github.com/pytorch/fairseq/releases/tag/v0.10.0) +* October 2020: [Added R3F/R4F (Better Fine-Tuning) code](examples/rxf/README.md) +* October 2020: [Deep Transformer with Latent Depth code released](examples/latent_depth/README.md) +* October 2020: [Added CRISS models and code](examples/criss/README.md) + +
Previous updates

+ +* September 2020: [Added Linformer code](examples/linformer/README.md) +* September 2020: [Added pointer-generator networks](examples/pointer_generator/README.md) +* August 2020: [Added lexically constrained decoding](examples/constrained_decoding/README.md) +* August 2020: [wav2vec2 models and code released](examples/wav2vec/README.md) +* July 2020: [Unsupervised Quality Estimation code released](examples/unsupervised_quality_estimation/README.md) +* May 2020: [Follow fairseq on Twitter](https://twitter.com/fairseq) +* April 2020: [Monotonic Multihead Attention code released](examples/simultaneous_translation/README.md) +* April 2020: [Quant-Noise code released](examples/quant_noise/README.md) +* April 2020: [Initial model parallel support and 11B parameters unidirectional LM released](examples/megatron_11b/README.md) +* March 2020: [Byte-level BPE code released](examples/byte_level_bpe/README.md) +* February 2020: [mBART model and code released](examples/mbart/README.md) +* February 2020: [Added tutorial for back-translation](https://github.com/pytorch/fairseq/tree/main/examples/backtranslation#training-your-own-model-wmt18-english-german) +* December 2019: [fairseq 0.9.0 released](https://github.com/pytorch/fairseq/releases/tag/v0.9.0) +* November 2019: [VizSeq released (a visual analysis toolkit for evaluating fairseq models)](https://facebookresearch.github.io/vizseq/docs/getting_started/fairseq_example) +* November 2019: [CamemBERT model and code released](examples/camembert/README.md) +* November 2019: [BART model and code released](examples/bart/README.md) +* November 2019: [XLM-R models and code released](examples/xlmr/README.md) +* September 2019: [Nonautoregressive translation code released](examples/nonautoregressive_translation/README.md) +* August 2019: [WMT'19 models released](examples/wmt19/README.md) +* July 2019: fairseq relicensed under MIT license +* July 2019: [RoBERTa models and code released](examples/roberta/README.md) +* June 2019: [wav2vec models and code released](examples/wav2vec/README.md) + +

+ +### Features: + +* multi-GPU training on one machine or across multiple machines (data and model parallel) +* fast generation on both CPU and GPU with multiple search algorithms implemented: + + beam search + + Diverse Beam Search ([Vijayakumar et al., 2016](https://arxiv.org/abs/1610.02424)) + + sampling (unconstrained, top-k and top-p/nucleus) + + [lexically constrained decoding](examples/constrained_decoding/README.md) (Post & Vilar, 2018) +* [gradient accumulation](https://fairseq.readthedocs.io/en/latest/getting_started.html#large-mini-batch-training-with-delayed-updates) enables training with large mini-batches even on a single GPU +* [mixed precision training](https://fairseq.readthedocs.io/en/latest/getting_started.html#training-with-half-precision-floating-point-fp16) (trains faster with less GPU memory on [NVIDIA tensor cores](https://developer.nvidia.com/tensor-cores)) +* [extensible](https://fairseq.readthedocs.io/en/latest/overview.html): easily register new models, criterions, tasks, optimizers and learning rate schedulers +* [flexible configuration](docs/hydra_integration.md) based on [Hydra](https://github.com/facebookresearch/hydra) allowing a combination of code, command-line and file based configuration +* [full parameter and optimizer state sharding](examples/fully_sharded_data_parallel/README.md) +* [offloading parameters to CPU](examples/fully_sharded_data_parallel/README.md) + +We also provide [pre-trained models for translation and language modeling](#pre-trained-models-and-examples) +with a convenient `torch.hub` interface: + +``` python +en2de = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-de.single_model') +en2de.translate('Hello world', beam=5) +# 'Hallo Welt' +``` + +See the PyTorch Hub tutorials for [translation](https://pytorch.org/hub/pytorch_fairseq_translation/) +and [RoBERTa](https://pytorch.org/hub/pytorch_fairseq_roberta/) for more examples. + +# Requirements and Installation + +* [PyTorch](http://pytorch.org/) version >= 1.5.0 +* Python version >= 3.6 +* For training new models, you'll also need an NVIDIA GPU and [NCCL](https://github.com/NVIDIA/nccl) +* **To install fairseq** and develop locally: + +``` bash +git clone https://github.com/pytorch/fairseq +cd fairseq +pip install --editable ./ + +# on MacOS: +# CFLAGS="-stdlib=libc++" pip install --editable ./ + +# to install the latest stable release (0.10.x) +# pip install fairseq +``` + +* **For faster training** install NVIDIA's [apex](https://github.com/NVIDIA/apex) library: + +``` bash +git clone https://github.com/NVIDIA/apex +cd apex +pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" \ + --global-option="--deprecated_fused_adam" --global-option="--xentropy" \ + --global-option="--fast_multihead_attn" ./ +``` + +* **For large datasets** install [PyArrow](https://arrow.apache.org/docs/python/install.html#using-pip): `pip install pyarrow` +* If you use Docker make sure to increase the shared memory size either with `--ipc=host` or `--shm-size` + as command line options to `nvidia-docker run` . + +# Getting Started + +The [full documentation](https://fairseq.readthedocs.io/) contains instructions +for getting started, training new models and extending fairseq with new model +types and tasks. + +# Pre-trained models and examples + +We provide pre-trained models and pre-processed, binarized test sets for several tasks listed below, +as well as example training and evaluation commands. + +* [Translation](examples/translation/README.md): convolutional and transformer models are available +* [Language Modeling](examples/language_model/README.md): convolutional and transformer models are available + +We also have more detailed READMEs to reproduce results from specific papers: + +* [Cross-lingual Retrieval for Iterative Self-Supervised Training (Tran et al., 2020)](examples/criss/README.md) +* [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations (Baevski et al., 2020)](examples/wav2vec/README.md) +* [Unsupervised Quality Estimation for Neural Machine Translation (Fomicheva et al., 2020)](examples/unsupervised_quality_estimation/README.md) +* [Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020)](examples/quant_noise/README.md) +* [Neural Machine Translation with Byte-Level Subwords (Wang et al., 2020)](examples/byte_level_bpe/README.md) +* [Multilingual Denoising Pre-training for Neural Machine Translation (Liu et at., 2020)](examples/mbart/README.md) +* [Reducing Transformer Depth on Demand with Structured Dropout (Fan et al., 2019)](examples/layerdrop/README.md) +* [Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019)](examples/joint_alignment_translation/README.md) +* [Levenshtein Transformer (Gu et al., 2019)](examples/nonautoregressive_translation/README.md) +* [Facebook FAIR's WMT19 News Translation Task Submission (Ng et al., 2019)](examples/wmt19/README.md) +* [RoBERTa: A Robustly Optimized BERT Pretraining Approach (Liu et al., 2019)](examples/roberta/README.md) +* [wav2vec: Unsupervised Pre-training for Speech Recognition (Schneider et al., 2019)](examples/wav2vec/README.md) +* [Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019)](examples/translation_moe/README.md) +* [Pay Less Attention with Lightweight and Dynamic Convolutions (Wu et al., 2019)](examples/pay_less_attention_paper/README.md) +* [Understanding Back-Translation at Scale (Edunov et al., 2018)](examples/backtranslation/README.md) +* [Classical Structured Prediction Losses for Sequence to Sequence Learning (Edunov et al., 2018)](https://github.com/pytorch/fairseq/tree/classic_seqlevel) +* [Hierarchical Neural Story Generation (Fan et al., 2018)](examples/stories/README.md) +* [Scaling Neural Machine Translation (Ott et al., 2018)](examples/scaling_nmt/README.md) +* [Convolutional Sequence to Sequence Learning (Gehring et al., 2017)](examples/conv_seq2seq/README.md) +* [Language Modeling with Gated Convolutional Networks (Dauphin et al., 2017)](examples/language_model/README.conv.md) + +# Join the fairseq community + +* Twitter: https://twitter.com/fairseq +* Facebook page: https://www.facebook.com/groups/fairseq.users +* Google group: https://groups.google.com/forum/#!forum/fairseq-users + +# License + +fairseq(-py) is MIT-licensed. +The license applies to the pre-trained models as well. + +# Citation + +Please cite as: + +``` bibtex +@inproceedings{ott2019fairseq, + title = {fairseq: A Fast, Extensible Toolkit for Sequence Modeling}, + author = {Myle Ott and Sergey Edunov and Alexei Baevski and Angela Fan and Sam Gross and Nathan Ng and David Grangier and Michael Auli}, + booktitle = {Proceedings of NAACL-HLT 2019: Demonstrations}, + year = {2019}, +} +``` diff --git a/fairseq/docs/Makefile b/fairseq/docs/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..c2f5b1a89cfc9e02d1bb09027d9e1e520ba53d53 --- /dev/null +++ b/fairseq/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = python -msphinx +SPHINXPROJ = fairseq +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file diff --git a/fairseq/docs/_static/theme_overrides.css b/fairseq/docs/_static/theme_overrides.css new file mode 100644 index 0000000000000000000000000000000000000000..2a0764193625e1a6fd66ff8af2ccdd0ad6369188 --- /dev/null +++ b/fairseq/docs/_static/theme_overrides.css @@ -0,0 +1,9 @@ +.wy-table-responsive table td kbd { + white-space: nowrap; +} +.wy-table-responsive table td { + white-space: normal !important; +} +.wy-table-responsive { + overflow: visible !important; +} diff --git a/fairseq/docs/command_line_tools.rst b/fairseq/docs/command_line_tools.rst new file mode 100644 index 0000000000000000000000000000000000000000..c16300ff5cd42d9a6c0070c2d9bec3a802eacfad --- /dev/null +++ b/fairseq/docs/command_line_tools.rst @@ -0,0 +1,85 @@ +.. _Command-line Tools: + +Command-line Tools +================== + +Fairseq provides several command-line tools for training and evaluating models: + +- :ref:`fairseq-preprocess`: Data pre-processing: build vocabularies and binarize training data +- :ref:`fairseq-train`: Train a new model on one or multiple GPUs +- :ref:`fairseq-generate`: Translate pre-processed data with a trained model +- :ref:`fairseq-interactive`: Translate raw text with a trained model +- :ref:`fairseq-score`: BLEU scoring of generated translations against reference translations +- :ref:`fairseq-eval-lm`: Language model evaluation + + +.. _fairseq-preprocess: + +fairseq-preprocess +~~~~~~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.preprocess + + .. argparse:: + :module: fairseq.options + :func: get_preprocessing_parser + :prog: fairseq-preprocess + + +.. _fairseq-train: + +fairseq-train +~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.train + + .. argparse:: + :module: fairseq.options + :func: get_training_parser + :prog: fairseq-train + + +.. _fairseq-generate: + +fairseq-generate +~~~~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.generate + + .. argparse:: + :module: fairseq.options + :func: get_generation_parser + :prog: fairseq-generate + + +.. _fairseq-interactive: + +fairseq-interactive +~~~~~~~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.interactive + + .. argparse:: + :module: fairseq.options + :func: get_interactive_generation_parser + :prog: fairseq-interactive + + +.. _fairseq-score: + +fairseq-score +~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.score + + .. argparse:: + :module: fairseq_cli.score + :func: get_parser + :prog: fairseq-score + + +.. _fairseq-eval-lm: + +fairseq-eval-lm +~~~~~~~~~~~~~~~ +.. automodule:: fairseq_cli.eval_lm + + .. argparse:: + :module: fairseq.options + :func: get_eval_lm_parser + :prog: fairseq-eval-lm diff --git a/fairseq/docs/conf.py b/fairseq/docs/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..87b0db98c77d0c240c030a0b48354c86b84358d1 --- /dev/null +++ b/fairseq/docs/conf.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# +# fairseq documentation build configuration file, created by +# sphinx-quickstart on Fri Aug 17 21:45:30 2018. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. + +import os +import sys +from fairseq import __version__ + + +# source code directory, relative to this file, for sphinx-autobuild +sys.path.insert(0, os.path.abspath("..")) + +source_suffix = [".rst"] + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +# +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.intersphinx", + "sphinx.ext.viewcode", + "sphinx.ext.napoleon", + "sphinxarg.ext", +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# The master toctree document. +master_doc = "index" + +# General information about the project. +project = "fairseq" +copyright = "Facebook AI Research (FAIR)" +author = "Facebook AI Research (FAIR)" + +github_doc_root = "https://github.com/pytorch/fairseq/tree/main/docs/" + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The short X.Y version. +version = __version__ +# The full version, including alpha/beta/rc tags. +release = __version__ + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = None + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = "sphinx" +highlight_language = "python" + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = False + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = "sphinx_rtd_theme" + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# +# html_theme_options = {} + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] + +html_context = { + "css_files": [ + "_static/theme_overrides.css", # override wide tables in RTD theme + ], +} + +# Custom sidebar templates, must be a dictionary that maps document names +# to template names. +# +# This is required for the alabaster theme +# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars +# html_sidebars = { +# '**': [ +# 'about.html', +# 'navigation.html', +# 'relations.html', # needs 'show_related': True theme option to display +# 'searchbox.html', +# 'donate.html', +# ] +# } + + +# Example configuration for intersphinx: refer to the Python standard library. +intersphinx_mapping = { + "numpy": ("http://docs.scipy.org/doc/numpy/", None), + "python": ("https://docs.python.org/", None), + "torch": ("https://pytorch.org/docs/master/", None), +} diff --git a/fairseq/docs/criterions.rst b/fairseq/docs/criterions.rst new file mode 100644 index 0000000000000000000000000000000000000000..d6b8ca6b671a32d0da4aca7b18626e0df58a7258 --- /dev/null +++ b/fairseq/docs/criterions.rst @@ -0,0 +1,31 @@ +.. role:: hidden + :class: hidden-section + +.. _Criterions: + +Criterions +========== + +Criterions compute the loss function given the model and batch, roughly:: + + loss = criterion(model, batch) + +.. automodule:: fairseq.criterions + :members: + +.. autoclass:: fairseq.criterions.FairseqCriterion + :members: + :undoc-members: + +.. autoclass:: fairseq.criterions.adaptive_loss.AdaptiveLoss + :members: + :undoc-members: +.. autoclass:: fairseq.criterions.composite_loss.CompositeLoss + :members: + :undoc-members: +.. autoclass:: fairseq.criterions.cross_entropy.CrossEntropyCriterion + :members: + :undoc-members: +.. autoclass:: fairseq.criterions.label_smoothed_cross_entropy.LabelSmoothedCrossEntropyCriterion + :members: + :undoc-members: diff --git a/fairseq/docs/data.rst b/fairseq/docs/data.rst new file mode 100644 index 0000000000000000000000000000000000000000..6a390cb336ab3c5fb28edec7448abc35a8e22bbb --- /dev/null +++ b/fairseq/docs/data.rst @@ -0,0 +1,58 @@ +.. role:: hidden + :class: hidden-section + +.. module:: fairseq.data + +Data Loading and Utilities +========================== + +.. _datasets: + +Datasets +-------- + +**Datasets** define the data format and provide helpers for creating +mini-batches. + +.. autoclass:: fairseq.data.FairseqDataset + :members: +.. autoclass:: fairseq.data.LanguagePairDataset + :members: +.. autoclass:: fairseq.data.MonolingualDataset + :members: + +**Helper Datasets** + +These datasets wrap other :class:`fairseq.data.FairseqDataset` instances and +provide additional functionality: + +.. autoclass:: fairseq.data.BacktranslationDataset + :members: +.. autoclass:: fairseq.data.ConcatDataset + :members: +.. autoclass:: fairseq.data.ResamplingDataset + :members: +.. autoclass:: fairseq.data.RoundRobinZipDatasets + :members: +.. autoclass:: fairseq.data.TransformEosDataset + :members: + + +Dictionary +---------- + +.. autoclass:: fairseq.data.Dictionary + :members: + + +Iterators +--------- + +.. autoclass:: fairseq.data.CountingIterator + :members: +.. autoclass:: fairseq.data.EpochBatchIterator + :members: +.. autoclass:: fairseq.data.GroupedIterator + :members: +.. autoclass:: fairseq.data.ShardedIterator + :members: diff --git a/fairseq/docs/docutils.conf b/fairseq/docs/docutils.conf new file mode 100644 index 0000000000000000000000000000000000000000..526acffd32d16217160aee917db2b120354f20f0 --- /dev/null +++ b/fairseq/docs/docutils.conf @@ -0,0 +1,2 @@ +[writers] +option-limit=0 diff --git a/fairseq/docs/fairseq_logo.png b/fairseq/docs/fairseq_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..75472cbb5ff78acc8716ad9121ed421f17f96c9a Binary files /dev/null and b/fairseq/docs/fairseq_logo.png differ diff --git a/fairseq/docs/getting_started.rst b/fairseq/docs/getting_started.rst new file mode 100644 index 0000000000000000000000000000000000000000..745ad7763cee67a8dec25bdd7ba7b79cbe0b7754 --- /dev/null +++ b/fairseq/docs/getting_started.rst @@ -0,0 +1,216 @@ +Evaluating Pre-trained Models +============================= + +First, download a pre-trained model along with its vocabularies: + +.. code-block:: console + + > curl https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2 | tar xvjf - + +This model uses a `Byte Pair Encoding (BPE) +vocabulary `__, so we'll have to apply +the encoding to the source text before it can be translated. This can be +done with the +`apply\_bpe.py `__ +script using the ``wmt14.en-fr.fconv-cuda/bpecodes`` file. ``@@`` is +used as a continuation marker and the original text can be easily +recovered with e.g. ``sed s/@@ //g`` or by passing the ``--remove-bpe`` +flag to :ref:`fairseq-generate`. Prior to BPE, input text needs to be tokenized +using ``tokenizer.perl`` from +`mosesdecoder `__. + +Let's use :ref:`fairseq-interactive` to generate translations interactively. +Here, we use a beam size of 5 and preprocess the input with the Moses +tokenizer and the given Byte-Pair Encoding vocabulary. It will automatically +remove the BPE continuation markers and detokenize the output. + +.. code-block:: console + + > MODEL_DIR=wmt14.en-fr.fconv-py + > fairseq-interactive \ + --path $MODEL_DIR/model.pt $MODEL_DIR \ + --beam 5 --source-lang en --target-lang fr \ + --tokenizer moses \ + --bpe subword_nmt --bpe-codes $MODEL_DIR/bpecodes + | loading model(s) from wmt14.en-fr.fconv-py/model.pt + | [en] dictionary: 44206 types + | [fr] dictionary: 44463 types + | Type the input sentence and press return: + Why is it rare to discover new marine mammal species? + S-0 Why is it rare to discover new marine mam@@ mal species ? + H-0 -0.0643349438905716 Pourquoi est-il rare de découvrir de nouvelles espèces de mammifères marins? + P-0 -0.0763 -0.1849 -0.0956 -0.0946 -0.0735 -0.1150 -0.1301 -0.0042 -0.0321 -0.0171 -0.0052 -0.0062 -0.0015 + +This generation script produces three types of outputs: a line prefixed +with *O* is a copy of the original source sentence; *H* is the +hypothesis along with an average log-likelihood; and *P* is the +positional score per token position, including the +end-of-sentence marker which is omitted from the text. + +Other types of output lines you might see are *D*, the detokenized hypothesis, +*T*, the reference target, *A*, alignment info, *E* the history of generation steps. + +See the `README `__ for a +full list of pre-trained models available. + +Training a New Model +==================== + +The following tutorial is for machine translation. For an example of how +to use Fairseq for other tasks, such as :ref:`language modeling`, please see the +``examples/`` directory. + +Data Pre-processing +------------------- + +Fairseq contains example pre-processing scripts for several translation +datasets: IWSLT 2014 (German-English), WMT 2014 (English-French) and WMT +2014 (English-German). To pre-process and binarize the IWSLT dataset: + +.. code-block:: console + + > cd examples/translation/ + > bash prepare-iwslt14.sh + > cd ../.. + > TEXT=examples/translation/iwslt14.tokenized.de-en + > fairseq-preprocess --source-lang de --target-lang en \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/iwslt14.tokenized.de-en + +This will write binarized data that can be used for model training to +``data-bin/iwslt14.tokenized.de-en``. + +Training +-------- + +Use :ref:`fairseq-train` to train a new model. Here a few example settings that work +well for the IWSLT 2014 dataset: + +.. code-block:: console + + > mkdir -p checkpoints/fconv + > CUDA_VISIBLE_DEVICES=0 fairseq-train data-bin/iwslt14.tokenized.de-en \ + --optimizer nag --lr 0.25 --clip-norm 0.1 --dropout 0.2 --max-tokens 4000 \ + --arch fconv_iwslt_de_en --save-dir checkpoints/fconv + +By default, :ref:`fairseq-train` will use all available GPUs on your machine. Use the +``CUDA_VISIBLE_DEVICES`` environment variable to select specific GPUs and/or to +change the number of GPU devices that will be used. + +Also note that the batch size is specified in terms of the maximum +number of tokens per batch (``--max-tokens``). You may need to use a +smaller value depending on the available GPU memory on your system. + +Generation +---------- + +Once your model is trained, you can generate translations using +:ref:`fairseq-generate` **(for binarized data)** or +:ref:`fairseq-interactive` **(for raw text)**: + +.. code-block:: console + + > fairseq-generate data-bin/iwslt14.tokenized.de-en \ + --path checkpoints/fconv/checkpoint_best.pt \ + --batch-size 128 --beam 5 + | [de] dictionary: 35475 types + | [en] dictionary: 24739 types + | data-bin/iwslt14.tokenized.de-en test 6750 examples + | model fconv + | loaded checkpoint trainings/fconv/checkpoint_best.pt + S-721 danke . + T-721 thank you . + ... + +To generate translations with only a CPU, use the ``--cpu`` flag. BPE +continuation markers can be removed with the ``--remove-bpe`` flag. + +Advanced Training Options +========================= + +Large mini-batch training with delayed updates +---------------------------------------------- + +The ``--update-freq`` option can be used to accumulate gradients from +multiple mini-batches and delay updating, creating a larger effective +batch size. Delayed updates can also improve training speed by reducing +inter-GPU communication costs and by saving idle time caused by variance +in workload across GPUs. See `Ott et al. +(2018) `__ for more details. + +To train on a single GPU with an effective batch size that is equivalent +to training on 8 GPUs: + +.. code-block:: console + + > CUDA_VISIBLE_DEVICES=0 fairseq-train --update-freq 8 (...) + +Training with half precision floating point (FP16) +-------------------------------------------------- + +.. note:: + + FP16 training requires a Volta GPU and CUDA 9.1 or greater + +Recent GPUs enable efficient half precision floating point computation, +e.g., using `Nvidia Tensor Cores +`__. +Fairseq supports FP16 training with the ``--fp16`` flag: + +.. code-block:: console + + > fairseq-train --fp16 (...) + +Distributed training +-------------------- + +Distributed training in fairseq is implemented on top of ``torch.distributed``. +The easiest way to launch jobs is with the `torch.distributed.launch +`__ tool. + +For example, to train a large English-German Transformer model on 2 nodes each +with 8 GPUs (in total 16 GPUs), run the following command on each node, +replacing ``node_rank=0`` with ``node_rank=1`` on the second node and making +sure to update ``--master_addr`` to the IP address of the first node: + +.. code-block:: console + + > python -m torch.distributed.launch --nproc_per_node=8 \ + --nnodes=2 --node_rank=0 --master_addr="192.168.1.1" \ + --master_port=12345 \ + $(which fairseq-train) data-bin/wmt16_en_de_bpe32k \ + --arch transformer_vaswani_wmt_en_de_big --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr-scheduler inverse_sqrt --warmup-init-lr 1e-07 --warmup-updates 4000 \ + --lr 0.0005 \ + --dropout 0.3 --weight-decay 0.0 --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --max-tokens 3584 \ + --max-epoch 70 \ + --fp16 + +On SLURM clusters, fairseq will automatically detect the number of nodes and +GPUs, but a port number must be provided: + +.. code-block:: console + + > salloc --gpus=16 --nodes 2 (...) + > srun fairseq-train --distributed-port 12345 (...). + +Sharding very large datasets +---------------------------- + +It can be challenging to train over very large datasets, particularly if your +machine does not have much system RAM. Most tasks in fairseq support training +over "sharded" datasets, in which the original dataset has been preprocessed +into non-overlapping chunks (or "shards"). + +For example, instead of preprocessing all your data into a single "data-bin" +directory, you can split the data and create "data-bin1", "data-bin2", etc. +Then you can adapt your training command like so: + +.. code-block:: console + + > fairseq-train data-bin1:data-bin2:data-bin3 (...) + +Training will now iterate over each shard, one by one, with each shard +corresponding to an "epoch", thus reducing system memory usage. diff --git a/fairseq/docs/hydra_integration.md b/fairseq/docs/hydra_integration.md new file mode 100644 index 0000000000000000000000000000000000000000..6a15298382a6a16dfc4c5a4a812ea1cd0477ed52 --- /dev/null +++ b/fairseq/docs/hydra_integration.md @@ -0,0 +1,284 @@ +## Hydra + +[Hydra](https://github.com/facebookresearch/hydra) is an open-source Python +framework that simplifies the development of research and other complex +applications. The key feature is the ability to dynamically create a +hierarchical configuration by composition and override it through config files +and the command line. The name Hydra comes from its ability to run multiple +similar jobs - much like a Hydra with multiple heads. + +## Motivation + +Until recently, all components in fairseq were configured through a shared +`args` namespace that was created at application startup. Components declared +their own `add_args` method to update the argparse parser, hoping that the names +would not clash with arguments from other components. While this model works for +smaller applications, as fairseq grew and became integrated into other +applications, this became problematic. In order to determine how to configure +each component, one needed to a) examine what args were added by this component, +and b) read the code to figure out what shared arguments it is using that were +added in other places. Reproducing models involved sharing commands that often +contained dozens of command line switches. + +The model described above is still supported by fairseq for backward +compatibility, but will be deprecated some time in the future. + +New components in fairseq should now create a dataclass that encapsulates all +parameters required to configure this component. The dataclass is registered +along with the component, and fairseq takes care of constructing and providing +this configuration object to the component's constructor. Note that sharing +parameters can optionally still work, but one has to explicitly point to the +"source of truth" (see inheritance example below). These changes make components +in fairseq more independent and re-usable by other applications: all that is +needed to create a component is to initialize its dataclass and overwrite some +of the defaults. + +While configuring fairseq through command line (using either the legacy argparse +based or the new Hydra based entry points) is still fully supported, you can now +take advantage of configuring fairseq completely or piece-by-piece through +hierarchical YAML configuration files. These files can also be shipped as +examples that others can use to run an identically configured job. + +Additionally, Hydra has a rich and growing [library of +plugins](https://github.com/facebookresearch/hydra/tree/master/plugins) that +provide functionality such as hyperparameter sweeping (including using bayesian +optimization through the [Ax](https://github.com/facebook/Ax) library), job +launching across various platforms, and more. + +## Creating or migrating components + +In general, each new (or updated) component should provide a companion +[dataclass](https://www.python.org/dev/peps/pep-0557/). These dataclass are +typically located in the same file as the component and are passed as arguments +to the `register_*()` functions. Top-level configs that should be present in +every fairseq application are placed in the +[global](fairseq/dataclass/configs.py) config file and added to the +`FairseqConfig` object. + +Each dataclass is a plain-old-data object, similar to a `NamedTuple`. These +classes are decorated with a `@dataclass` decorator, and typically inherit from +`FairseqDataclass` (which adds some functionality for backward compatibility). +Each field must have a type, and generally has metadata (such as a help string) +and a default value. Only primitive types or other config objects are allowed as +data types for each field. + +#### Example: + +```python +from dataclasses import dataclass, field +from fairseq.dataclass import FairseqDataclass + +@dataclass +class InteractiveConfig(FairseqDataclass): + buffer_size: int = field( + default=0, + metadata={ + "help": "read this many sentences into a buffer before processing them" + }, + ) + input: str = field( + default="-", + metadata={"help": "file to read from; use - for stdin"}, + ) +``` + +### Inherting values + +Some components require sharing a value. For example, a learning rate scheduler +and an optimizer may both need to know the initial learning rate value. One can +declare a field that, by default, will inherit its value from another config +node in the same hierarchy: + +```python +@dataclass +FairseqAdamConfig(FairseqDataclass): + ... + lr: List[float] = II("optimization.lr") + ... +``` + +`II("optimization.lr")` is syntactic sugar for `"${optimization.lr}"`, which is +the value one can use in a YAML config file or through command line to achieve +the same effect. Note that this assumes that there is an "optimization" config +object in the root config and it has a field called "lr". + +### Tasks and Models + +Creating Tasks and Models works same as before, except that legacy +implementations now inherit from `LegacyFairseq*` base classes, while new +components inherit from `FairseqTask` and `FairseqModel` and provide a dataclass +to the `register_*()` functions. + +#### Task example: + +```python +@dataclass +class LanguageModelingConfig(FairseqDataclass): + data: Optional[str] = field( + default=None, metadata={"help": "path to data directory"} + ) + ... + +@register_task("language_modeling", dataclass=LanguageModelingConfig) +class LanguageModelingTask(FairseqTask): + ... + @classmethod + def setup_task(cls, cfg: LanguageModelingConfig): + ... +``` + +#### Model example: + +```python +@dataclass +class TransformerLanguageModelConfig(FairseqDataclass): + activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field( + default="relu", metadata={"help": "activation function to use"} + ) + dropout: float = field(default=0.1, metadata={"help": "dropout probability"}) + ... + +@register_model("transformer_lm", dataclass=TransformerLanguageModelConfig) +class TransformerLanguageModel(FairseqLanguageModel): + ... + @classmethod + def build_model(cls, cfg: TransformerLanguageModelConfig, task: FairseqTask): + ... +``` + +### Other components + +Other components work as before, but they now take their configuration dataclass +as the only constructor argument: + +```python +@dataclass +class MosesTokenizerConfig(FairseqDataclass): + source_lang: str = field(default="en", metadata={"help": "source language"}) + ... + +@register_tokenizer("moses", dataclass=MosesTokenizerConfig) +class MosesTokenizer(object): + def __init__(self, cfg: MosesTokenizerConfig): + ... +``` + +Note that if you are adding a new registry for a new set of components, you need +to add it to the `FairseqConfig` object in `fairseq/dataclass/configs.py`: + +```python +@dataclass +class FairseqConfig(object): + ... + my_new_registry: Any = None +``` + +## Training with `fairseq-hydra-train` + +To fully take advantage of configuration flexibility offered by Hydra, you may +want to train new models using the `fairseq-hydra-train` entry point. Legacy CLI +tools such as `fairseq-train` will remain supported for the foreseeable future +but will be deprecated eventually. + +On startup, Hydra will create a configuration object that contains a hierarchy +of all the necessary dataclasses populated with their default values in the +code. The default values are overwritten by values found in YAML files in +`fairseq/config` directory (which currently sets minimal defaults) and then +further overwritten by values provided through command line arguments. + +Some of the most common use cases are shown below: + +### 1. Override default values through command line: + +```shell script +$ fairseq-hydra-train \ + distributed_training.distributed_world_size=1 \ + dataset.batch_size=2 \ + task.data=data-bin \ + model=transformer_lm/transformer_lm_gpt \ + task=language_modeling \ + optimization.max_update=5000 +``` + +Note that along with explicitly providing values for parameters such as +`dataset.batch_size`, this also tells Hydra to overlay configuration found in +`fairseq/config/model/transformer_lm/transformer_lm_gpt.yaml` over the default +values in the dataclass. If you want to train a model without specifying a +particular architecture you can simply specify `model=transformer_lm`. This only +works for migrated tasks and models. + +### 2. Replace bundled configs with an external config: + +```shell script +$ fairseq-hydra-train \ + --config-dir /path/to/external/configs \ + --config-name wiki103 +``` + +where `/path/to/external/configs/wiki103.yaml` contains: + +```yaml +# @package _group_ + +model: + _name: transformer_lm +distributed_training: + distributed_world_size: 1 +dataset: + batch_size: 2 +task: + _name: language_modeling + data: /path/to/data + add_bos_token: false + max_target_positions: 1024 +optimization: + max_update: 50000 + lr: [ 0.25 ] +criterion: cross_entropy +optimizer: adam +lr_scheduler: + _name: cosine +``` + +Note that here bundled configs from `fairseq/config` directory are not used, +however the defaults from each dataclass will still be used (unless overwritten +by your external config). + +Additionally you can choose to break up your configs by creating a directory +structure in the same location as your main config file, with the names of the +top-level fields (such as "model", "dataset", etc), and placing config files +with meaningful names that would populate that specific section of your +top-level config file (for example, you might have +`model/small_transformer_lm.yaml`, `model/big_transformer_lm.yaml`, etc). You +can then specify the correct configuration via command line, defaults in the +main config, or even launch all of them as a sweep (see Hydra documentation on +how to do this). + +### 3. Add an external config directory to Hydra search path: + +This allows combining default configuration (including using any bundled config +files), while specifying your own config files for some parts of the +configuration. + +```shell script +$ fairseq-hydra-train \ + distributed_training.distributed_world_size=1 \ + dataset.batch_size=2 \ + task.data=/path/to/data/ \ + model=transformer_lm/2_layers \ + task=language_modeling \ + optimization.max_update=5000 \ + --config-dir /path/to/external/configs +``` + +where `/path/to/external/configs` has the following structure: +``` +. ++-- model +| +-- transformer_lm +| | +-- 2_layers.yaml +``` + +and `2_layers.yaml` contains a copy of `transformer_lm_gpt.yaml` but with +`decoder_layers` set to 2. You can add other configs to configure other +components as well. diff --git a/fairseq/docs/index.rst b/fairseq/docs/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..591db86cdf49e6f0a7a6686df2150f11418e90d0 --- /dev/null +++ b/fairseq/docs/index.rst @@ -0,0 +1,49 @@ +.. fairseq documentation master file, created by + sphinx-quickstart on Fri Aug 17 21:45:30 2018. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +:github_url: https://github.com/pytorch/fairseq + + +fairseq documentation +===================== + +Fairseq is a sequence modeling toolkit written in `PyTorch +`_ that allows researchers and developers to +train custom models for translation, summarization, language modeling and other +text generation tasks. + +.. toctree:: + :maxdepth: 1 + :caption: Getting Started + + getting_started + command_line_tools + +.. toctree:: + :maxdepth: 1 + :caption: Extending Fairseq + + overview + tutorial_simple_lstm + tutorial_classifying_names + +.. toctree:: + :maxdepth: 2 + :caption: Library Reference + + tasks + models + criterions + optim + lr_scheduler + data + modules + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`search` diff --git a/fairseq/docs/lr_scheduler.rst b/fairseq/docs/lr_scheduler.rst new file mode 100644 index 0000000000000000000000000000000000000000..bbc09dc22e6a7ac05137954e0b9c80ca030f62f4 --- /dev/null +++ b/fairseq/docs/lr_scheduler.rst @@ -0,0 +1,34 @@ +.. role:: hidden + :class: hidden-section + +.. _Learning Rate Schedulers: + +Learning Rate Schedulers +======================== + +Learning Rate Schedulers update the learning rate over the course of training. +Learning rates can be updated after each update via :func:`step_update` or at +epoch boundaries via :func:`step`. + +.. automodule:: fairseq.optim.lr_scheduler + :members: + +.. autoclass:: fairseq.optim.lr_scheduler.FairseqLRScheduler + :members: + :undoc-members: + +.. autoclass:: fairseq.optim.lr_scheduler.cosine_lr_scheduler.CosineSchedule + :members: + :undoc-members: +.. autoclass:: fairseq.optim.lr_scheduler.fixed_schedule.FixedSchedule + :members: + :undoc-members: +.. autoclass:: fairseq.optim.lr_scheduler.inverse_square_root_schedule.InverseSquareRootSchedule + :members: + :undoc-members: +.. autoclass:: fairseq.optim.lr_scheduler.reduce_lr_on_plateau.ReduceLROnPlateau + :members: + :undoc-members: +.. autoclass:: fairseq.optim.lr_scheduler.triangular_lr_scheduler.TriangularSchedule + :members: + :undoc-members: diff --git a/fairseq/docs/make.bat b/fairseq/docs/make.bat new file mode 100644 index 0000000000000000000000000000000000000000..35c5085de318190514ee3b48d10060aa57a4fa50 --- /dev/null +++ b/fairseq/docs/make.bat @@ -0,0 +1,36 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=python -msphinx +) +set SOURCEDIR=. +set BUILDDIR=_build +set SPHINXPROJ=fairseq + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The Sphinx module was not found. Make sure you have Sphinx installed, + echo.then set the SPHINXBUILD environment variable to point to the full + echo.path of the 'sphinx-build' executable. Alternatively you may add the + echo.Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% + +:end +popd diff --git a/fairseq/docs/models.rst b/fairseq/docs/models.rst new file mode 100644 index 0000000000000000000000000000000000000000..054622d587c3b7f01f17f442919140755acd8f9e --- /dev/null +++ b/fairseq/docs/models.rst @@ -0,0 +1,104 @@ +.. role:: hidden + :class: hidden-section + +.. module:: fairseq.models + +.. _Models: + +Models +====== + +A Model defines the neural network's ``forward()`` method and encapsulates all +of the learnable parameters in the network. Each model also provides a set of +named *architectures* that define the precise network configuration (e.g., +embedding dimension, number of layers, etc.). + +Both the model type and architecture are selected via the ``--arch`` +command-line argument. Once selected, a model may expose additional command-line +arguments for further configuration. + +.. note:: + + All fairseq Models extend :class:`BaseFairseqModel`, which in turn extends + :class:`torch.nn.Module`. Thus any fairseq Model can be used as a + stand-alone Module in other PyTorch code. + + +Convolutional Neural Networks (CNN) +----------------------------------- + +.. module:: fairseq.models.fconv +.. autoclass:: fairseq.models.fconv.FConvModel + :members: +.. autoclass:: fairseq.models.fconv.FConvEncoder + :members: + :undoc-members: +.. autoclass:: fairseq.models.fconv.FConvDecoder + :members: + + +Long Short-Term Memory (LSTM) networks +-------------------------------------- + +.. module:: fairseq.models.lstm +.. autoclass:: fairseq.models.lstm.LSTMModel + :members: +.. autoclass:: fairseq.models.lstm.LSTMEncoder + :members: +.. autoclass:: fairseq.models.lstm.LSTMDecoder + :members: + + +Transformer (self-attention) networks +------------------------------------- + +.. module:: fairseq.models.transformer +.. autoclass:: fairseq.models.transformer.TransformerModel + :members: +.. autoclass:: fairseq.models.transformer.TransformerEncoder + :members: +.. autoclass:: fairseq.models.transformer.TransformerEncoderLayer + :members: +.. autoclass:: fairseq.models.transformer.TransformerDecoder + :members: +.. autoclass:: fairseq.models.transformer.TransformerDecoderLayer + :members: + + +Adding new models +----------------- + +.. currentmodule:: fairseq.models +.. autofunction:: fairseq.models.register_model +.. autofunction:: fairseq.models.register_model_architecture +.. autoclass:: fairseq.models.BaseFairseqModel + :members: + :undoc-members: +.. autoclass:: fairseq.models.FairseqEncoderDecoderModel + :members: + :undoc-members: +.. autoclass:: fairseq.models.FairseqEncoderModel + :members: + :undoc-members: +.. autoclass:: fairseq.models.FairseqLanguageModel + :members: + :undoc-members: +.. autoclass:: fairseq.models.FairseqMultiModel + :members: + :undoc-members: +.. autoclass:: fairseq.models.FairseqEncoder + :members: +.. autoclass:: fairseq.models.CompositeEncoder + :members: +.. autoclass:: fairseq.models.FairseqDecoder + :members: + + +.. _Incremental decoding: + +Incremental decoding +-------------------- + +.. autoclass:: fairseq.models.FairseqIncrementalDecoder + :members: + :undoc-members: diff --git a/fairseq/docs/modules.rst b/fairseq/docs/modules.rst new file mode 100644 index 0000000000000000000000000000000000000000..9631c93d4682286e1cea1ddd961d3f6ab06f2589 --- /dev/null +++ b/fairseq/docs/modules.rst @@ -0,0 +1,9 @@ +Modules +======= + +Fairseq provides several stand-alone :class:`torch.nn.Module` classes that may +be helpful when implementing a new :class:`~fairseq.models.BaseFairseqModel`. + +.. automodule:: fairseq.modules + :members: + :undoc-members: diff --git a/fairseq/docs/optim.rst b/fairseq/docs/optim.rst new file mode 100644 index 0000000000000000000000000000000000000000..c3326456bd9291a1d05bd3316bef5c9fb25c6c49 --- /dev/null +++ b/fairseq/docs/optim.rst @@ -0,0 +1,38 @@ +.. role:: hidden + :class: hidden-section + +.. _optimizers: + +Optimizers +========== + +Optimizers update the Model parameters based on the gradients. + +.. automodule:: fairseq.optim + :members: + +.. autoclass:: fairseq.optim.FairseqOptimizer + :members: + :undoc-members: + +.. autoclass:: fairseq.optim.adadelta.Adadelta + :members: + :undoc-members: +.. autoclass:: fairseq.optim.adagrad.Adagrad + :members: + :undoc-members: +.. autoclass:: fairseq.optim.adafactor.FairseqAdafactor + :members: + :undoc-members: +.. autoclass:: fairseq.optim.adam.FairseqAdam + :members: + :undoc-members: +.. autoclass:: fairseq.optim.fp16_optimizer.FP16Optimizer + :members: + :undoc-members: +.. autoclass:: fairseq.optim.nag.FairseqNAG + :members: + :undoc-members: +.. autoclass:: fairseq.optim.sgd.SGD + :members: + :undoc-members: diff --git a/fairseq/docs/overview.rst b/fairseq/docs/overview.rst new file mode 100644 index 0000000000000000000000000000000000000000..026b3b5c7b21d071d8b8a3405898977c760d05b8 --- /dev/null +++ b/fairseq/docs/overview.rst @@ -0,0 +1,74 @@ +Overview +======== + +Fairseq can be extended through user-supplied `plug-ins +`_. We support five kinds of +plug-ins: + +- :ref:`Models` define the neural network architecture and encapsulate all of the + learnable parameters. +- :ref:`Criterions` compute the loss function given the model outputs and targets. +- :ref:`Tasks` store dictionaries and provide helpers for loading/iterating over + Datasets, initializing the Model/Criterion and calculating the loss. +- :ref:`Optimizers` update the Model parameters based on the gradients. +- :ref:`Learning Rate Schedulers` update the learning rate over the course of + training. + +**Training Flow** + +Given a ``model``, ``criterion``, ``task``, ``optimizer`` and ``lr_scheduler``, +fairseq implements the following high-level training flow:: + + for epoch in range(num_epochs): + itr = task.get_batch_iterator(task.dataset('train')) + for num_updates, batch in enumerate(itr): + task.train_step(batch, model, criterion, optimizer) + average_and_clip_gradients() + optimizer.step() + lr_scheduler.step_update(num_updates) + lr_scheduler.step(epoch) + +where the default implementation for ``task.train_step`` is roughly:: + + def train_step(self, batch, model, criterion, optimizer, **unused): + loss = criterion(model, batch) + optimizer.backward(loss) + return loss + +**Registering new plug-ins** + +New plug-ins are *registered* through a set of ``@register`` function +decorators, for example:: + + @register_model('my_lstm') + class MyLSTM(FairseqEncoderDecoderModel): + (...) + +Once registered, new plug-ins can be used with the existing :ref:`Command-line +Tools`. See the Tutorial sections for more detailed walkthroughs of how to add +new plug-ins. + +**Loading plug-ins from another directory** + +New plug-ins can be defined in a custom module stored in the user system. In +order to import the module, and make the plugin available to *fairseq*, the +command line supports the ``--user-dir`` flag that can be used to specify a +custom location for additional modules to load into *fairseq*. + +For example, assuming this directory tree:: + + /home/user/my-module/ + └── __init__.py + +with ``__init__.py``:: + + from fairseq.models import register_model_architecture + from fairseq.models.transformer import transformer_vaswani_wmt_en_de_big + + @register_model_architecture('transformer', 'my_transformer') + def transformer_mmt_big(args): + transformer_vaswani_wmt_en_de_big(args) + +it is possible to invoke the :ref:`fairseq-train` script with the new architecture with:: + + fairseq-train ... --user-dir /home/user/my-module -a my_transformer --task translation diff --git a/fairseq/docs/requirements.txt b/fairseq/docs/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..c734a1f04f1c108d84d3a07643ac93adf6485f13 --- /dev/null +++ b/fairseq/docs/requirements.txt @@ -0,0 +1,2 @@ +sphinx<2.0 +sphinx-argparse diff --git a/fairseq/docs/tasks.rst b/fairseq/docs/tasks.rst new file mode 100644 index 0000000000000000000000000000000000000000..5f65c3c866865e50332d8e6ca012a4a81e7bea74 --- /dev/null +++ b/fairseq/docs/tasks.rst @@ -0,0 +1,61 @@ +.. role:: hidden + :class: hidden-section + +.. module:: fairseq.tasks + +.. _Tasks: + +Tasks +===== + +Tasks store dictionaries and provide helpers for loading/iterating over +Datasets, initializing the Model/Criterion and calculating the loss. + +Tasks can be selected via the ``--task`` command-line argument. Once selected, a +task may expose additional command-line arguments for further configuration. + +Example usage:: + + # setup the task (e.g., load dictionaries) + task = fairseq.tasks.setup_task(args) + + # build model and criterion + model = task.build_model(args) + criterion = task.build_criterion(args) + + # load datasets + task.load_dataset('train') + task.load_dataset('valid') + + # iterate over mini-batches of data + batch_itr = task.get_batch_iterator( + task.dataset('train'), max_tokens=4096, + ) + for batch in batch_itr: + # compute the loss + loss, sample_size, logging_output = task.get_loss( + model, criterion, batch, + ) + loss.backward() + + +Translation +----------- + +.. autoclass:: fairseq.tasks.translation.TranslationTask + +.. _language modeling: + +Language Modeling +----------------- + +.. autoclass:: fairseq.tasks.language_modeling.LanguageModelingTask + + +Adding new tasks +---------------- + +.. autofunction:: fairseq.tasks.register_task +.. autoclass:: fairseq.tasks.FairseqTask + :members: + :undoc-members: diff --git a/fairseq/docs/tutorial_classifying_names.rst b/fairseq/docs/tutorial_classifying_names.rst new file mode 100644 index 0000000000000000000000000000000000000000..b02fec0489a86e7b1ccec481342fa4fbd93a80ae --- /dev/null +++ b/fairseq/docs/tutorial_classifying_names.rst @@ -0,0 +1,415 @@ +Tutorial: Classifying Names with a Character-Level RNN +====================================================== + +In this tutorial we will extend fairseq to support *classification* tasks. In +particular we will re-implement the PyTorch tutorial for `Classifying Names with +a Character-Level RNN `_ +in fairseq. It is recommended to quickly skim that tutorial before beginning +this one. + +This tutorial covers: + +1. **Preprocessing the data** to create dictionaries. +2. **Registering a new Model** that encodes an input sentence with a simple RNN + and predicts the output label. +3. **Registering a new Task** that loads our dictionaries and dataset. +4. **Training the Model** using the existing command-line tools. +5. **Writing an evaluation script** that imports fairseq and allows us to + interactively evaluate our model on new inputs. + + +1. Preprocessing the data +------------------------- + +The original tutorial provides raw data, but we'll work with a modified version +of the data that is already tokenized into characters and split into separate +train, valid and test sets. + +Download and extract the data from here: +`tutorial_names.tar.gz `_ + +Once extracted, let's preprocess the data using the :ref:`fairseq-preprocess` +command-line tool to create the dictionaries. While this tool is primarily +intended for sequence-to-sequence problems, we're able to reuse it here by +treating the label as a "target" sequence of length 1. We'll also output the +preprocessed files in "raw" format using the ``--dataset-impl`` option to +enhance readability: + +.. code-block:: console + + > fairseq-preprocess \ + --trainpref names/train --validpref names/valid --testpref names/test \ + --source-lang input --target-lang label \ + --destdir names-bin --dataset-impl raw + +After running the above command you should see a new directory, +:file:`names-bin/`, containing the dictionaries for *inputs* and *labels*. + + +2. Registering a new Model +-------------------------- + +Next we'll register a new model in fairseq that will encode an input sentence +with a simple RNN and predict the output label. Compared to the original PyTorch +tutorial, our version will also work with batches of data and GPU Tensors. + +First let's copy the simple RNN module implemented in the `PyTorch tutorial +`_. +Create a new file named :file:`fairseq/models/rnn_classifier.py` with the +following contents:: + + import torch + import torch.nn as nn + + class RNN(nn.Module): + + def __init__(self, input_size, hidden_size, output_size): + super(RNN, self).__init__() + + self.hidden_size = hidden_size + + self.i2h = nn.Linear(input_size + hidden_size, hidden_size) + self.i2o = nn.Linear(input_size + hidden_size, output_size) + self.softmax = nn.LogSoftmax(dim=1) + + def forward(self, input, hidden): + combined = torch.cat((input, hidden), 1) + hidden = self.i2h(combined) + output = self.i2o(combined) + output = self.softmax(output) + return output, hidden + + def initHidden(self): + return torch.zeros(1, self.hidden_size) + +We must also *register* this model with fairseq using the +:func:`~fairseq.models.register_model` function decorator. Once the model is +registered we'll be able to use it with the existing :ref:`Command-line Tools`. + +All registered models must implement the :class:`~fairseq.models.BaseFairseqModel` +interface, so we'll create a small wrapper class in the same file and register +it in fairseq with the name ``'rnn_classifier'``:: + + from fairseq.models import BaseFairseqModel, register_model + + # Note: the register_model "decorator" should immediately precede the + # definition of the Model class. + + @register_model('rnn_classifier') + class FairseqRNNClassifier(BaseFairseqModel): + + @staticmethod + def add_args(parser): + # Models can override this method to add new command-line arguments. + # Here we'll add a new command-line argument to configure the + # dimensionality of the hidden state. + parser.add_argument( + '--hidden-dim', type=int, metavar='N', + help='dimensionality of the hidden state', + ) + + @classmethod + def build_model(cls, args, task): + # Fairseq initializes models by calling the ``build_model()`` + # function. This provides more flexibility, since the returned model + # instance can be of a different type than the one that was called. + # In this case we'll just return a FairseqRNNClassifier instance. + + # Initialize our RNN module + rnn = RNN( + # We'll define the Task in the next section, but for now just + # notice that the task holds the dictionaries for the "source" + # (i.e., the input sentence) and "target" (i.e., the label). + input_size=len(task.source_dictionary), + hidden_size=args.hidden_dim, + output_size=len(task.target_dictionary), + ) + + # Return the wrapped version of the module + return FairseqRNNClassifier( + rnn=rnn, + input_vocab=task.source_dictionary, + ) + + def __init__(self, rnn, input_vocab): + super(FairseqRNNClassifier, self).__init__() + + self.rnn = rnn + self.input_vocab = input_vocab + + # The RNN module in the tutorial expects one-hot inputs, so we can + # precompute the identity matrix to help convert from indices to + # one-hot vectors. We register it as a buffer so that it is moved to + # the GPU when ``cuda()`` is called. + self.register_buffer('one_hot_inputs', torch.eye(len(input_vocab))) + + def forward(self, src_tokens, src_lengths): + # The inputs to the ``forward()`` function are determined by the + # Task, and in particular the ``'net_input'`` key in each + # mini-batch. We'll define the Task in the next section, but for + # now just know that *src_tokens* has shape `(batch, src_len)` and + # *src_lengths* has shape `(batch)`. + bsz, max_src_len = src_tokens.size() + + # Initialize the RNN hidden state. Compared to the original PyTorch + # tutorial we'll also handle batched inputs and work on the GPU. + hidden = self.rnn.initHidden() + hidden = hidden.repeat(bsz, 1) # expand for batched inputs + hidden = hidden.to(src_tokens.device) # move to GPU + + for i in range(max_src_len): + # WARNING: The inputs have padding, so we should mask those + # elements here so that padding doesn't affect the results. + # This is left as an exercise for the reader. The padding symbol + # is given by ``self.input_vocab.pad()`` and the unpadded length + # of each input is given by *src_lengths*. + + # One-hot encode a batch of input characters. + input = self.one_hot_inputs[src_tokens[:, i].long()] + + # Feed the input to our RNN. + output, hidden = self.rnn(input, hidden) + + # Return the final output state for making a prediction + return output + +Finally let's define a *named architecture* with the configuration for our +model. This is done with the :func:`~fairseq.models.register_model_architecture` +function decorator. Thereafter this named architecture can be used with the +``--arch`` command-line argument, e.g., ``--arch pytorch_tutorial_rnn``:: + + from fairseq.models import register_model_architecture + + # The first argument to ``register_model_architecture()`` should be the name + # of the model we registered above (i.e., 'rnn_classifier'). The function we + # register here should take a single argument *args* and modify it in-place + # to match the desired architecture. + + @register_model_architecture('rnn_classifier', 'pytorch_tutorial_rnn') + def pytorch_tutorial_rnn(args): + # We use ``getattr()`` to prioritize arguments that are explicitly given + # on the command-line, so that the defaults defined below are only used + # when no other value has been specified. + args.hidden_dim = getattr(args, 'hidden_dim', 128) + + +3. Registering a new Task +------------------------- + +Now we'll register a new :class:`~fairseq.tasks.FairseqTask` that will load our +dictionaries and dataset. Tasks can also control how the data is batched into +mini-batches, but in this tutorial we'll reuse the batching provided by +:class:`fairseq.data.LanguagePairDataset`. + +Create a new file named :file:`fairseq/tasks/simple_classification.py` with the +following contents:: + + import os + import torch + + from fairseq.data import Dictionary, LanguagePairDataset + from fairseq.tasks import FairseqTask, register_task + + + @register_task('simple_classification') + class SimpleClassificationTask(LegacyFairseqTask): + + @staticmethod + def add_args(parser): + # Add some command-line arguments for specifying where the data is + # located and the maximum supported input length. + parser.add_argument('data', metavar='FILE', + help='file prefix for data') + parser.add_argument('--max-positions', default=1024, type=int, + help='max input length') + + @classmethod + def setup_task(cls, args, **kwargs): + # Here we can perform any setup required for the task. This may include + # loading Dictionaries, initializing shared Embedding layers, etc. + # In this case we'll just load the Dictionaries. + input_vocab = Dictionary.load(os.path.join(args.data, 'dict.input.txt')) + label_vocab = Dictionary.load(os.path.join(args.data, 'dict.label.txt')) + print('| [input] dictionary: {} types'.format(len(input_vocab))) + print('| [label] dictionary: {} types'.format(len(label_vocab))) + + return SimpleClassificationTask(args, input_vocab, label_vocab) + + def __init__(self, args, input_vocab, label_vocab): + super().__init__(args) + self.input_vocab = input_vocab + self.label_vocab = label_vocab + + def load_dataset(self, split, **kwargs): + """Load a given dataset split (e.g., train, valid, test).""" + + prefix = os.path.join(self.args.data, '{}.input-label'.format(split)) + + # Read input sentences. + sentences, lengths = [], [] + with open(prefix + '.input', encoding='utf-8') as file: + for line in file: + sentence = line.strip() + + # Tokenize the sentence, splitting on spaces + tokens = self.input_vocab.encode_line( + sentence, add_if_not_exist=False, + ) + + sentences.append(tokens) + lengths.append(tokens.numel()) + + # Read labels. + labels = [] + with open(prefix + '.label', encoding='utf-8') as file: + for line in file: + label = line.strip() + labels.append( + # Convert label to a numeric ID. + torch.LongTensor([self.label_vocab.add_symbol(label)]) + ) + + assert len(sentences) == len(labels) + print('| {} {} {} examples'.format(self.args.data, split, len(sentences))) + + # We reuse LanguagePairDataset since classification can be modeled as a + # sequence-to-sequence task where the target sequence has length 1. + self.datasets[split] = LanguagePairDataset( + src=sentences, + src_sizes=lengths, + src_dict=self.input_vocab, + tgt=labels, + tgt_sizes=torch.ones(len(labels)), # targets have length 1 + tgt_dict=self.label_vocab, + left_pad_source=False, + # Since our target is a single class label, there's no need for + # teacher forcing. If we set this to ``True`` then our Model's + # ``forward()`` method would receive an additional argument called + # *prev_output_tokens* that would contain a shifted version of the + # target sequence. + input_feeding=False, + ) + + def max_positions(self): + """Return the max input length allowed by the task.""" + # The source should be less than *args.max_positions* and the "target" + # has max length 1. + return (self.args.max_positions, 1) + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.input_vocab + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary`.""" + return self.label_vocab + + # We could override this method if we wanted more control over how batches + # are constructed, but it's not necessary for this tutorial since we can + # reuse the batching provided by LanguagePairDataset. + # + # def get_batch_iterator( + # self, dataset, max_tokens=None, max_sentences=None, max_positions=None, + # ignore_invalid_inputs=False, required_batch_size_multiple=1, + # seed=1, num_shards=1, shard_id=0, num_workers=0, epoch=1, + # data_buffer_size=0, disable_iterator_cache=False, + # ): + # (...) + + +4. Training the Model +--------------------- + +Now we're ready to train the model. We can use the existing :ref:`fairseq-train` +command-line tool for this, making sure to specify our new Task (``--task +simple_classification``) and Model architecture (``--arch +pytorch_tutorial_rnn``): + +.. note:: + + You can also configure the dimensionality of the hidden state by passing the + ``--hidden-dim`` argument to :ref:`fairseq-train`. + +.. code-block:: console + + > fairseq-train names-bin \ + --task simple_classification \ + --arch pytorch_tutorial_rnn \ + --optimizer adam --lr 0.001 --lr-shrink 0.5 \ + --max-tokens 1000 + (...) + | epoch 027 | loss 1.200 | ppl 2.30 | wps 15728 | ups 119.4 | wpb 116 | bsz 116 | num_updates 3726 | lr 1.5625e-05 | gnorm 1.290 | clip 0% | oom 0 | wall 32 | train_wall 21 + | epoch 027 | valid on 'valid' subset | valid_loss 1.41304 | valid_ppl 2.66 | num_updates 3726 | best 1.41208 + | done training in 31.6 seconds + +The model files should appear in the :file:`checkpoints/` directory. + + +5. Writing an evaluation script +------------------------------- + +Finally we can write a short script to evaluate our model on new inputs. Create +a new file named :file:`eval_classifier.py` with the following contents:: + + from fairseq import checkpoint_utils, data, options, tasks + + # Parse command-line arguments for generation + parser = options.get_generation_parser(default_task='simple_classification') + args = options.parse_args_and_arch(parser) + + # Setup task + task = tasks.setup_task(args) + + # Load model + print('| loading model from {}'.format(args.path)) + models, _model_args = checkpoint_utils.load_model_ensemble([args.path], task=task) + model = models[0] + + while True: + sentence = input('\nInput: ') + + # Tokenize into characters + chars = ' '.join(list(sentence.strip())) + tokens = task.source_dictionary.encode_line( + chars, add_if_not_exist=False, + ) + + # Build mini-batch to feed to the model + batch = data.language_pair_dataset.collate( + samples=[{'id': -1, 'source': tokens}], # bsz = 1 + pad_idx=task.source_dictionary.pad(), + eos_idx=task.source_dictionary.eos(), + left_pad_source=False, + input_feeding=False, + ) + + # Feed batch to the model and get predictions + preds = model(**batch['net_input']) + + # Print top 3 predictions and their log-probabilities + top_scores, top_labels = preds[0].topk(k=3) + for score, label_idx in zip(top_scores, top_labels): + label_name = task.target_dictionary.string([label_idx]) + print('({:.2f})\t{}'.format(score, label_name)) + +Now we can evaluate our model interactively. Note that we have included the +original data path (:file:`names-bin/`) so that the dictionaries can be loaded: + +.. code-block:: console + + > python eval_classifier.py names-bin --path checkpoints/checkpoint_best.pt + | [input] dictionary: 64 types + | [label] dictionary: 24 types + | loading model from checkpoints/checkpoint_best.pt + + Input: Satoshi + (-0.61) Japanese + (-1.20) Arabic + (-2.86) Italian + + Input: Sinbad + (-0.30) Arabic + (-1.76) English + (-4.08) Russian diff --git a/fairseq/docs/tutorial_simple_lstm.rst b/fairseq/docs/tutorial_simple_lstm.rst new file mode 100644 index 0000000000000000000000000000000000000000..f52988507c5da5125668e143bd2bfe4df117b41c --- /dev/null +++ b/fairseq/docs/tutorial_simple_lstm.rst @@ -0,0 +1,518 @@ +Tutorial: Simple LSTM +===================== + +In this tutorial we will extend fairseq by adding a new +:class:`~fairseq.models.FairseqEncoderDecoderModel` that encodes a source +sentence with an LSTM and then passes the final hidden state to a second LSTM +that decodes the target sentence (without attention). + +This tutorial covers: + +1. **Writing an Encoder and Decoder** to encode/decode the source/target + sentence, respectively. +2. **Registering a new Model** so that it can be used with the existing + :ref:`Command-line tools`. +3. **Training the Model** using the existing command-line tools. +4. **Making generation faster** by modifying the Decoder to use + :ref:`Incremental decoding`. + + +1. Building an Encoder and Decoder +---------------------------------- + +In this section we'll define a simple LSTM Encoder and Decoder. All Encoders +should implement the :class:`~fairseq.models.FairseqEncoder` interface and +Decoders should implement the :class:`~fairseq.models.FairseqDecoder` interface. +These interfaces themselves extend :class:`torch.nn.Module`, so FairseqEncoders +and FairseqDecoders can be written and used in the same ways as ordinary PyTorch +Modules. + + +Encoder +~~~~~~~ + +Our Encoder will embed the tokens in the source sentence, feed them to a +:class:`torch.nn.LSTM` and return the final hidden state. To create our encoder +save the following in a new file named :file:`fairseq/models/simple_lstm.py`:: + + import torch.nn as nn + from fairseq import utils + from fairseq.models import FairseqEncoder + + class SimpleLSTMEncoder(FairseqEncoder): + + def __init__( + self, args, dictionary, embed_dim=128, hidden_dim=128, dropout=0.1, + ): + super().__init__(dictionary) + self.args = args + + # Our encoder will embed the inputs before feeding them to the LSTM. + self.embed_tokens = nn.Embedding( + num_embeddings=len(dictionary), + embedding_dim=embed_dim, + padding_idx=dictionary.pad(), + ) + self.dropout = nn.Dropout(p=dropout) + + # We'll use a single-layer, unidirectional LSTM for simplicity. + self.lstm = nn.LSTM( + input_size=embed_dim, + hidden_size=hidden_dim, + num_layers=1, + bidirectional=False, + batch_first=True, + ) + + def forward(self, src_tokens, src_lengths): + # The inputs to the ``forward()`` function are determined by the + # Task, and in particular the ``'net_input'`` key in each + # mini-batch. We discuss Tasks in the next tutorial, but for now just + # know that *src_tokens* has shape `(batch, src_len)` and *src_lengths* + # has shape `(batch)`. + + # Note that the source is typically padded on the left. This can be + # configured by adding the `--left-pad-source "False"` command-line + # argument, but here we'll make the Encoder handle either kind of + # padding by converting everything to be right-padded. + if self.args.left_pad_source: + # Convert left-padding to right-padding. + src_tokens = utils.convert_padding_direction( + src_tokens, + padding_idx=self.dictionary.pad(), + left_to_right=True + ) + + # Embed the source. + x = self.embed_tokens(src_tokens) + + # Apply dropout. + x = self.dropout(x) + + # Pack the sequence into a PackedSequence object to feed to the LSTM. + x = nn.utils.rnn.pack_padded_sequence(x, src_lengths, batch_first=True) + + # Get the output from the LSTM. + _outputs, (final_hidden, _final_cell) = self.lstm(x) + + # Return the Encoder's output. This can be any object and will be + # passed directly to the Decoder. + return { + # this will have shape `(bsz, hidden_dim)` + 'final_hidden': final_hidden.squeeze(0), + } + + # Encoders are required to implement this method so that we can rearrange + # the order of the batch elements during inference (e.g., beam search). + def reorder_encoder_out(self, encoder_out, new_order): + """ + Reorder encoder output according to `new_order`. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + `encoder_out` rearranged according to `new_order` + """ + final_hidden = encoder_out['final_hidden'] + return { + 'final_hidden': final_hidden.index_select(0, new_order), + } + + +Decoder +~~~~~~~ + +Our Decoder will predict the next word, conditioned on the Encoder's final +hidden state and an embedded representation of the previous target word -- which +is sometimes called *teacher forcing*. More specifically, we'll use a +:class:`torch.nn.LSTM` to produce a sequence of hidden states that we'll project +to the size of the output vocabulary to predict each target word. + +:: + + import torch + from fairseq.models import FairseqDecoder + + class SimpleLSTMDecoder(FairseqDecoder): + + def __init__( + self, dictionary, encoder_hidden_dim=128, embed_dim=128, hidden_dim=128, + dropout=0.1, + ): + super().__init__(dictionary) + + # Our decoder will embed the inputs before feeding them to the LSTM. + self.embed_tokens = nn.Embedding( + num_embeddings=len(dictionary), + embedding_dim=embed_dim, + padding_idx=dictionary.pad(), + ) + self.dropout = nn.Dropout(p=dropout) + + # We'll use a single-layer, unidirectional LSTM for simplicity. + self.lstm = nn.LSTM( + # For the first layer we'll concatenate the Encoder's final hidden + # state with the embedded target tokens. + input_size=encoder_hidden_dim + embed_dim, + hidden_size=hidden_dim, + num_layers=1, + bidirectional=False, + ) + + # Define the output projection. + self.output_projection = nn.Linear(hidden_dim, len(dictionary)) + + # During training Decoders are expected to take the entire target sequence + # (shifted right by one position) and produce logits over the vocabulary. + # The *prev_output_tokens* tensor begins with the end-of-sentence symbol, + # ``dictionary.eos()``, followed by the target sequence. + def forward(self, prev_output_tokens, encoder_out): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (Tensor, optional): output from the encoder, used for + encoder-side attention + + Returns: + tuple: + - the last decoder layer's output of shape + `(batch, tgt_len, vocab)` + - the last decoder layer's attention weights of shape + `(batch, tgt_len, src_len)` + """ + bsz, tgt_len = prev_output_tokens.size() + + # Extract the final hidden state from the Encoder. + final_encoder_hidden = encoder_out['final_hidden'] + + # Embed the target sequence, which has been shifted right by one + # position and now starts with the end-of-sentence symbol. + x = self.embed_tokens(prev_output_tokens) + + # Apply dropout. + x = self.dropout(x) + + # Concatenate the Encoder's final hidden state to *every* embedded + # target token. + x = torch.cat( + [x, final_encoder_hidden.unsqueeze(1).expand(bsz, tgt_len, -1)], + dim=2, + ) + + # Using PackedSequence objects in the Decoder is harder than in the + # Encoder, since the targets are not sorted in descending length order, + # which is a requirement of ``pack_padded_sequence()``. Instead we'll + # feed nn.LSTM directly. + initial_state = ( + final_encoder_hidden.unsqueeze(0), # hidden + torch.zeros_like(final_encoder_hidden).unsqueeze(0), # cell + ) + output, _ = self.lstm( + x.transpose(0, 1), # convert to shape `(tgt_len, bsz, dim)` + initial_state, + ) + x = output.transpose(0, 1) # convert to shape `(bsz, tgt_len, hidden)` + + # Project the outputs to the size of the vocabulary. + x = self.output_projection(x) + + # Return the logits and ``None`` for the attention weights + return x, None + + +2. Registering the Model +------------------------ + +Now that we've defined our Encoder and Decoder we must *register* our model with +fairseq using the :func:`~fairseq.models.register_model` function decorator. +Once the model is registered we'll be able to use it with the existing +:ref:`Command-line Tools`. + +All registered models must implement the +:class:`~fairseq.models.BaseFairseqModel` interface. For sequence-to-sequence +models (i.e., any model with a single Encoder and Decoder), we can instead +implement the :class:`~fairseq.models.FairseqEncoderDecoderModel` interface. + +Create a small wrapper class in the same file and register it in fairseq with +the name ``'simple_lstm'``:: + + from fairseq.models import FairseqEncoderDecoderModel, register_model + + # Note: the register_model "decorator" should immediately precede the + # definition of the Model class. + + @register_model('simple_lstm') + class SimpleLSTMModel(FairseqEncoderDecoderModel): + + @staticmethod + def add_args(parser): + # Models can override this method to add new command-line arguments. + # Here we'll add some new command-line arguments to configure dropout + # and the dimensionality of the embeddings and hidden states. + parser.add_argument( + '--encoder-embed-dim', type=int, metavar='N', + help='dimensionality of the encoder embeddings', + ) + parser.add_argument( + '--encoder-hidden-dim', type=int, metavar='N', + help='dimensionality of the encoder hidden state', + ) + parser.add_argument( + '--encoder-dropout', type=float, default=0.1, + help='encoder dropout probability', + ) + parser.add_argument( + '--decoder-embed-dim', type=int, metavar='N', + help='dimensionality of the decoder embeddings', + ) + parser.add_argument( + '--decoder-hidden-dim', type=int, metavar='N', + help='dimensionality of the decoder hidden state', + ) + parser.add_argument( + '--decoder-dropout', type=float, default=0.1, + help='decoder dropout probability', + ) + + @classmethod + def build_model(cls, args, task): + # Fairseq initializes models by calling the ``build_model()`` + # function. This provides more flexibility, since the returned model + # instance can be of a different type than the one that was called. + # In this case we'll just return a SimpleLSTMModel instance. + + # Initialize our Encoder and Decoder. + encoder = SimpleLSTMEncoder( + args=args, + dictionary=task.source_dictionary, + embed_dim=args.encoder_embed_dim, + hidden_dim=args.encoder_hidden_dim, + dropout=args.encoder_dropout, + ) + decoder = SimpleLSTMDecoder( + dictionary=task.target_dictionary, + encoder_hidden_dim=args.encoder_hidden_dim, + embed_dim=args.decoder_embed_dim, + hidden_dim=args.decoder_hidden_dim, + dropout=args.decoder_dropout, + ) + model = SimpleLSTMModel(encoder, decoder) + + # Print the model architecture. + print(model) + + return model + + # We could override the ``forward()`` if we wanted more control over how + # the encoder and decoder interact, but it's not necessary for this + # tutorial since we can inherit the default implementation provided by + # the FairseqEncoderDecoderModel base class, which looks like: + # + # def forward(self, src_tokens, src_lengths, prev_output_tokens): + # encoder_out = self.encoder(src_tokens, src_lengths) + # decoder_out = self.decoder(prev_output_tokens, encoder_out) + # return decoder_out + +Finally let's define a *named architecture* with the configuration for our +model. This is done with the :func:`~fairseq.models.register_model_architecture` +function decorator. Thereafter this named architecture can be used with the +``--arch`` command-line argument, e.g., ``--arch tutorial_simple_lstm``:: + + from fairseq.models import register_model_architecture + + # The first argument to ``register_model_architecture()`` should be the name + # of the model we registered above (i.e., 'simple_lstm'). The function we + # register here should take a single argument *args* and modify it in-place + # to match the desired architecture. + + @register_model_architecture('simple_lstm', 'tutorial_simple_lstm') + def tutorial_simple_lstm(args): + # We use ``getattr()`` to prioritize arguments that are explicitly given + # on the command-line, so that the defaults defined below are only used + # when no other value has been specified. + args.encoder_embed_dim = getattr(args, 'encoder_embed_dim', 256) + args.encoder_hidden_dim = getattr(args, 'encoder_hidden_dim', 256) + args.decoder_embed_dim = getattr(args, 'decoder_embed_dim', 256) + args.decoder_hidden_dim = getattr(args, 'decoder_hidden_dim', 256) + + +3. Training the Model +--------------------- + +Now we're ready to train the model. We can use the existing :ref:`fairseq-train` +command-line tool for this, making sure to specify our new Model architecture +(``--arch tutorial_simple_lstm``). + +.. note:: + + Make sure you've already preprocessed the data from the IWSLT example in the + :file:`examples/translation/` directory. + +.. code-block:: console + + > fairseq-train data-bin/iwslt14.tokenized.de-en \ + --arch tutorial_simple_lstm \ + --encoder-dropout 0.2 --decoder-dropout 0.2 \ + --optimizer adam --lr 0.005 --lr-shrink 0.5 \ + --max-tokens 12000 + (...) + | epoch 052 | loss 4.027 | ppl 16.30 | wps 420805 | ups 39.7 | wpb 9841 | bsz 400 | num_updates 20852 | lr 1.95313e-05 | gnorm 0.218 | clip 0% | oom 0 | wall 529 | train_wall 396 + | epoch 052 | valid on 'valid' subset | valid_loss 4.74989 | valid_ppl 26.91 | num_updates 20852 | best 4.74954 + +The model files should appear in the :file:`checkpoints/` directory. While this +model architecture is not very good, we can use the :ref:`fairseq-generate` script to +generate translations and compute our BLEU score over the test set: + +.. code-block:: console + + > fairseq-generate data-bin/iwslt14.tokenized.de-en \ + --path checkpoints/checkpoint_best.pt \ + --beam 5 \ + --remove-bpe + (...) + | Translated 6750 sentences (153132 tokens) in 17.3s (389.12 sentences/s, 8827.68 tokens/s) + | Generate test with beam=5: BLEU4 = 8.18, 38.8/12.1/4.7/2.0 (BP=1.000, ratio=1.066, syslen=139865, reflen=131146) + + +4. Making generation faster +--------------------------- + +While autoregressive generation from sequence-to-sequence models is inherently +slow, our implementation above is especially slow because it recomputes the +entire sequence of Decoder hidden states for every output token (i.e., it is +``O(n^2)``). We can make this significantly faster by instead caching the +previous hidden states. + +In fairseq this is called :ref:`Incremental decoding`. Incremental decoding is a +special mode at inference time where the Model only receives a single timestep +of input corresponding to the immediately previous output token (for teacher +forcing) and must produce the next output incrementally. Thus the model must +cache any long-term state that is needed about the sequence, e.g., hidden +states, convolutional states, etc. + +To implement incremental decoding we will modify our model to implement the +:class:`~fairseq.models.FairseqIncrementalDecoder` interface. Compared to the +standard :class:`~fairseq.models.FairseqDecoder` interface, the incremental +decoder interface allows ``forward()`` methods to take an extra keyword argument +(*incremental_state*) that can be used to cache state across time-steps. + +Let's replace our ``SimpleLSTMDecoder`` with an incremental one:: + + import torch + from fairseq.models import FairseqIncrementalDecoder + + class SimpleLSTMDecoder(FairseqIncrementalDecoder): + + def __init__( + self, dictionary, encoder_hidden_dim=128, embed_dim=128, hidden_dim=128, + dropout=0.1, + ): + # This remains the same as before. + super().__init__(dictionary) + self.embed_tokens = nn.Embedding( + num_embeddings=len(dictionary), + embedding_dim=embed_dim, + padding_idx=dictionary.pad(), + ) + self.dropout = nn.Dropout(p=dropout) + self.lstm = nn.LSTM( + input_size=encoder_hidden_dim + embed_dim, + hidden_size=hidden_dim, + num_layers=1, + bidirectional=False, + ) + self.output_projection = nn.Linear(hidden_dim, len(dictionary)) + + # We now take an additional kwarg (*incremental_state*) for caching the + # previous hidden and cell states. + def forward(self, prev_output_tokens, encoder_out, incremental_state=None): + if incremental_state is not None: + # If the *incremental_state* argument is not ``None`` then we are + # in incremental inference mode. While *prev_output_tokens* will + # still contain the entire decoded prefix, we will only use the + # last step and assume that the rest of the state is cached. + prev_output_tokens = prev_output_tokens[:, -1:] + + # This remains the same as before. + bsz, tgt_len = prev_output_tokens.size() + final_encoder_hidden = encoder_out['final_hidden'] + x = self.embed_tokens(prev_output_tokens) + x = self.dropout(x) + x = torch.cat( + [x, final_encoder_hidden.unsqueeze(1).expand(bsz, tgt_len, -1)], + dim=2, + ) + + # We will now check the cache and load the cached previous hidden and + # cell states, if they exist, otherwise we will initialize them to + # zeros (as before). We will use the ``utils.get_incremental_state()`` + # and ``utils.set_incremental_state()`` helpers. + initial_state = utils.get_incremental_state( + self, incremental_state, 'prev_state', + ) + if initial_state is None: + # first time initialization, same as the original version + initial_state = ( + final_encoder_hidden.unsqueeze(0), # hidden + torch.zeros_like(final_encoder_hidden).unsqueeze(0), # cell + ) + + # Run one step of our LSTM. + output, latest_state = self.lstm(x.transpose(0, 1), initial_state) + + # Update the cache with the latest hidden and cell states. + utils.set_incremental_state( + self, incremental_state, 'prev_state', latest_state, + ) + + # This remains the same as before + x = output.transpose(0, 1) + x = self.output_projection(x) + return x, None + + # The ``FairseqIncrementalDecoder`` interface also requires implementing a + # ``reorder_incremental_state()`` method, which is used during beam search + # to select and reorder the incremental state. + def reorder_incremental_state(self, incremental_state, new_order): + # Load the cached state. + prev_state = utils.get_incremental_state( + self, incremental_state, 'prev_state', + ) + + # Reorder batches according to *new_order*. + reordered_state = ( + prev_state[0].index_select(1, new_order), # hidden + prev_state[1].index_select(1, new_order), # cell + ) + + # Update the cached state. + utils.set_incremental_state( + self, incremental_state, 'prev_state', reordered_state, + ) + +Finally, we can rerun generation and observe the speedup: + +.. code-block:: console + + # Before + + > fairseq-generate data-bin/iwslt14.tokenized.de-en \ + --path checkpoints/checkpoint_best.pt \ + --beam 5 \ + --remove-bpe + (...) + | Translated 6750 sentences (153132 tokens) in 17.3s (389.12 sentences/s, 8827.68 tokens/s) + | Generate test with beam=5: BLEU4 = 8.18, 38.8/12.1/4.7/2.0 (BP=1.000, ratio=1.066, syslen=139865, reflen=131146) + + # After + + > fairseq-generate data-bin/iwslt14.tokenized.de-en \ + --path checkpoints/checkpoint_best.pt \ + --beam 5 \ + --remove-bpe + (...) + | Translated 6750 sentences (153132 tokens) in 5.5s (1225.54 sentences/s, 27802.94 tokens/s) + | Generate test with beam=5: BLEU4 = 8.18, 38.8/12.1/4.7/2.0 (BP=1.000, ratio=1.066, syslen=139865, reflen=131146) diff --git a/fairseq/examples/.gitignore b/fairseq/examples/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..1ef816f2cd7b4a9aa7adf8bd5635a644834738f1 --- /dev/null +++ b/fairseq/examples/.gitignore @@ -0,0 +1,2 @@ +!*/*.sh +!*/*.md diff --git a/fairseq/examples/__init__.py b/fairseq/examples/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..44bb24ae614941f23fea29c56d60167650c39bcb --- /dev/null +++ b/fairseq/examples/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +try: + from fairseq.version import __version__ # noqa +except ImportError: + pass diff --git a/fairseq/examples/adaptive_span/README.md b/fairseq/examples/adaptive_span/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d5224fb2894606a2a8027e01e224be190776ecfe --- /dev/null +++ b/fairseq/examples/adaptive_span/README.md @@ -0,0 +1,90 @@ +# Adaptive Span + +Adaptive Span is a novel self-attention mechanism that can learn its optimal +attention span. This allows us to extend significantly the maximum context size +used in Transformer, while maintaining control over their memory footprint +and computational time. It uses the Truncated BPTT technique for training, +as in [transformerXL](https://github.com/pytorch/fairseq/blob/main/examples/truncated_bptt/README.md). + +Adaptive Span was introduced by paper: +[Adaptive Attention Span in Transformers](https://arxiv.org/abs/1905.07799), +which achieved state-of-the-art language modeling results at the time of publication. + +We manage to reproduce their result in fairseq and keep most of the +[original implementation](https://github.com/facebookresearch/adaptive-span) untouched. +You can refer to the their sweep file as well if any combination of hyperparameter is not clear. + +##### 0. Setup + +First you need to process the Enwik8 dataset, we use the pre-tokenized dataset +from [adaptive span paper](https://github.com/facebookresearch/adaptive-span/blob/master/get_data.sh). +You can download the dataset, and then run: +```bash +fairseq-preprocess --only-source --trainpref ~/data/enwik8/train.txt \ + --validpref ~/data/enwik8/valid.txt --testpref ~/data/enwik8/test.txt \ + --destdir ~/data/enwik8/data-bin/ --joined-dictionary --workers 20 +``` + +##### 1. Train a Adaptive Span model on Enwik8 + +We will train a 12-layer Adaptive Span model following the [hyperparameters +used in the original +paper](https://github.com/facebookresearch/adaptive-span/blob/master/experiments/enwik8.sh). + +The following command assumes 4 GPUs, so that the total batch size is 64 +sequences (4 x 16). Training should take 2-3 days on 4 V100 GPUs: +```bash +CUDA_VISIBLE_DEVICES=0,1,2,3 fairseq-train \ + --user-dir examples/adaptive_span \ + --data ~/data/enwik8/data-bin/ \ + --fp16 --fp16-no-flatten-grads --max-update 600000 \ + --task truncated_bptt_lm --tokens-per-sample 512 --arch adaptive_span \ + --n-layer 12 --d-model 512 --n-head 8 --d-inner 2048 --dropout 0.3 \ + --attn-span 8192 --optimizer adagrad_with_grad_clip --adagrad-clip 0.03 \ + --validate-interval-updates 1000 \ + --lr-scheduler fixed --warmup-updates 32000 --batch-size-valid 32 \ + --lr 0.07 --criterion adaptive_span_loss --batch-size 16 --update-freq 1 \ + --seed 2 --log-format json --log-interval 25 --aux-loss-scaler 5e-07 +``` +This should land around 1.05 on validation, 1.03 on test. You can lower the +--aux-loss-scaler for better performance (longer span). It gives ~0.03 bpc +improvement to the transformerXL baseline here. +If training on a single GPU, set `--update-freq=4` to accumulate 4x gradients +and simulate training on 4 GPUs. +You can also reproduce the transformerXL result on enwik8 using this code base. +It should land around 1.06 on test,matching the [original paper](https://github.com/kimiyoung/transformer-xl/blob/master/pytorch/run_enwik8_base.sh). +You can try by +```bash +CUDA_VISIBLE_DEVICES=0,1,2,3 fairseq-train \ + --user-dir examples/truncated_bptt \ + ~/data/enwik8/data-bin/ \ + --task truncated_bptt_lm --fp16 --max-update 400000 \ + --tokens-per-sample 512 --arch transformer_xl --n-layer 12 \ + --d-model 512 --n-head 8 --d-head 64 --d-inner 2048 --dropout 0.1 \ + --dropatt 0.0 --mem-len 512 --optimizer adam --clip-norm 0.25 \ + --lr-scheduler cosine --warmup-updates 0 \ + --lr 0.0 --lr 0.00025 --batch-size 15 \ + --update-freq 1 --seed 2 --log-format json --log-interval 25 \ + --fp16 +``` + +##### 2. Evaluate +For Adaptive Span: +```bash +fairseq-eval-lm ~/data/enwik8/data-bin/ --path model/checkpoint_best.pt \ + --user-dir examples/adaptive_span \ + --task truncated_bptt_lm --batch-size 8 --tokens-per-sample 512 --gen-subset test +``` +For Transformer-XL evaluation: +```bash +fairseq-eval-lm ~/data/enwik8/data-bin/ --path model/checkpoint_best.pt \ + --user-dir examples/truncated_bptt/ --task truncated_bptt_lm --batch-size 8 \ + --tokens-per-sample 80 \ + --model-overrides '{"mem_len":2100,"clamp_len":820,"same_length":True}' \ + --gen-subset valid +``` + +*Note:* During training the model saw 512 tokens of context +(``--tokens-per-sample=512``), with batch size 8. These settings match the evaluation +settings from [the original +paper](https://github.com/facebookresearch/adaptive-span/blob/master/experiments/enwik8.sh). diff --git a/fairseq/examples/adaptive_span/__init__.py b/fairseq/examples/adaptive_span/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e0a142a769360e1140bf814c532eaf841f1d52d8 --- /dev/null +++ b/fairseq/examples/adaptive_span/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + +# automatically import any Python files in the current directory +cur_dir = os.path.dirname(__file__) +for file in os.listdir(cur_dir): + path = os.path.join(cur_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + mod_name = file[: file.find(".py")] if file.endswith(".py") else file + module = importlib.import_module(__name__ + "." + mod_name) diff --git a/fairseq/examples/adaptive_span/adagrad_with_grad_clip.py b/fairseq/examples/adaptive_span/adagrad_with_grad_clip.py new file mode 100644 index 0000000000000000000000000000000000000000..585ce184ab2d6bbde0d2f7fcafd6536fa8f6d8b6 --- /dev/null +++ b/fairseq/examples/adaptive_span/adagrad_with_grad_clip.py @@ -0,0 +1,128 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from torch.optim import Adagrad + +from fairseq.optim import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("adagrad_with_grad_clip") +class FairseqAdagradWithGradClip(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = AdagradWithGradClip(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + parser.add_argument('--adagrad-clip', default=0.0, type=float, metavar='D', + help='internal grad clip') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "weight_decay": self.args.weight_decay, + "grad_clip": self.args.adagrad_clip, + } + + @property + def supports_flat_params(self): + return False + + +def _clip_grad(clr, grad, group_grad_clip): + if group_grad_clip > 0: + norm = grad.norm(2).item() + if norm > group_grad_clip: + clr *= group_grad_clip / (norm + 1e-10) + return clr + + +class AdagradWithGradClip(Adagrad): + """Adagrad algorithm with custom gradient clipping""" + + def __init__( + self, + params, + lr=1e-2, + lr_decay=0, + weight_decay=0, + initial_accumulator_value=0, + grad_clip=0, + ): + Adagrad.__init__( + self, + params, + lr=lr, + lr_decay=lr_decay, + weight_decay=weight_decay, + initial_accumulator_value=initial_accumulator_value, + ) + self.defaults["grad_clip"] = grad_clip + self.param_groups[0].setdefault("grad_clip", grad_clip) + + def step(self, closure=None): + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None: + continue + + grad = p.grad.data + state = self.state[p] + + state["step"] += 1 + + if group["weight_decay"] != 0: + if p.grad.data.is_sparse: + raise RuntimeError( + "weight_decay option is " + "not compatible with sparse " + "gradients" + ) + grad = grad.add(group["weight_decay"], p.data) + + clr = group["lr"] / (1 + (state["step"] - 1) * group["lr_decay"]) + + # clip + clr = _clip_grad(clr=clr, grad=grad, group_grad_clip=group["grad_clip"]) + + if grad.is_sparse: + # the update is non-linear so indices must be unique + grad = grad.coalesce() + grad_indices = grad._indices() + grad_values = grad._values() + size = grad.size() + + def make_sparse(values): + constructor = grad.new + if grad_indices.dim() == 0 or values.dim() == 0: + return constructor().resize_as_(grad) + return constructor(grad_indices, values, size) + + state["sum"].add_(make_sparse(grad_values.pow(2))) + std = state["sum"]._sparse_mask(grad) + std_values = std._values().sqrt_().add_(1e-10) + p.data.add_(-clr, make_sparse(grad_values / std_values)) + else: + state["sum"].addcmul_(1, grad, grad) + std = state["sum"].sqrt().add_(1e-10) + p.data.addcdiv_(-clr, grad, std) + + return loss diff --git a/fairseq/examples/adaptive_span/adaptive_span_attention.py b/fairseq/examples/adaptive_span/adaptive_span_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..07f757bb8e1a8a67b1124175ee338c8735aa8d65 --- /dev/null +++ b/fairseq/examples/adaptive_span/adaptive_span_attention.py @@ -0,0 +1,160 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class AdaptiveMask(nn.Module): + """Soft masking function for adaptive size. + It masks out the last K values of an input. The masking value + goes from 1 to 0 gradually, so K can be learned with + back-propagation. + Args: + max_size: maximum size (i.e. input dimension) + ramp_size: size of the ramp going from 0 to 1 + init_val: initial size proportion not to be masked out + shape: learn multiple sizes independent of each other + """ + + def __init__(self, max_size, ramp_size, init_val=0, shape=(1,)): + nn.Module.__init__(self) + self._max_size = max_size + self._ramp_size = ramp_size + self.current_val = nn.Parameter(torch.zeros(*shape) + init_val) + mask_template = torch.linspace(1 - max_size, 0, steps=max_size) + self.register_buffer("mask_template", mask_template) + + def forward(self, x): + mask = self.mask_template.float() + self.current_val.float() * self._max_size + mask = mask / self._ramp_size + 1 + mask = mask.clamp(0, 1) + if x.size(-1) < self._max_size: + # the input could have been trimmed beforehand to save computation + mask = mask.narrow(-1, self._max_size - x.size(-1), x.size(-1)) + x = (x * mask).type_as(x) + return x + + def get_current_max_size(self, include_ramp=True): + current_size = math.ceil(self.current_val.max().item() * self._max_size) + if include_ramp: + current_size += self._ramp_size + current_size = max(0, min(self._max_size, current_size)) + return current_size + + def get_current_avg_size(self, include_ramp=True): + current_size = math.ceil( + self.current_val.float().mean().item() * self._max_size + ) + if include_ramp: + current_size += self._ramp_size + current_size = max(0, min(self._max_size, current_size)) + return current_size + + def clamp_param(self): + """this need to be called after each update""" + self.current_val.data.clamp_(0, 1) + + +class AdaptiveSpan(nn.Module): + """Adaptive attention span for Transformerself. + This module learns an attention span length from data for each + self-attention head. + Args: + attn_span: maximum attention span + adapt_span_loss: loss coefficient for the span length + adapt_span_ramp: length of the masking ramp + adapt_span_init: initial size ratio + adapt_span_cache: adapt cache size to reduce memory usage + """ + + def __init__( + self, + attn_span, + adapt_span_ramp, + adapt_span_init, + n_head, + adapt_span_layer, + **kargs + ): + nn.Module.__init__(self) + self._max_span = attn_span + self._n_head = n_head + self._adapt_span_layer = adapt_span_layer + if self._adapt_span_layer: + self._mask = AdaptiveMask( + max_size=self._max_span, + ramp_size=adapt_span_ramp, + init_val=adapt_span_init, + ) + else: + self._mask = AdaptiveMask( + max_size=self._max_span, + ramp_size=adapt_span_ramp, + init_val=adapt_span_init, + shape=(n_head, 1, 1), + ) + + def forward(self, attn, normalize=True): + """mask attention with the right span""" + # batch and head dimensions are merged together, so separate them first + self.clamp_param() + if self._adapt_span_layer: + attn = self._mask(attn) + else: + B = attn.size(0) # batch size + M = attn.size(1) # block size + attn = attn.reshape(B // self._n_head, self._n_head, M, -1) + attn = self._mask(attn) + attn = attn.view(B, M, -1) + return attn + + def get_trim_len(self): + """how much of memory can be trimmed to reduce computation""" + L = self._max_span + trim_len = min(L - 1, L - self._mask.get_current_max_size()) + # too fine granularity might be bad for the memory management + trim_len = math.floor(trim_len / 64) * 64 + return trim_len + + def trim_memory(self, query, key, value, key_pe): + """trim out unnecessary memory beforehand to reduce computation""" + trim_len = self.get_trim_len() + cache_size = key.size(1) - query.size(1) + trim_len_cache = trim_len - (self._max_span - cache_size) + if trim_len_cache > 0: + key = key[:, trim_len_cache:, :] + value = value[:, trim_len_cache:, :] + elif trim_len_cache < 0: + # cache is too short! this happens when validation resumes + # after a lot of updates. + key = F.pad(key, [0, 0, -trim_len_cache, 0]) + value = F.pad(value, [0, 0, -trim_len_cache, 0]) + if trim_len > 0: + if key_pe is not None: + key_pe = key_pe[:, :, trim_len:] + return key, value, key_pe + + def get_cache_size(self): + """determine how long the cache should be""" + trim_len = self.get_trim_len() + # give a buffer of 64 steps since a span might increase + # in future updates + return min(self._max_span, self._max_span - trim_len + 64) + + def get_loss(self): + """a loss term for regularizing the span length""" + return self._max_span * self._mask.current_val.float().mean() + + def get_current_max_span(self): + return self._mask.get_current_max_size() + + def get_current_avg_span(self): + return self._mask.get_current_avg_size() + + def clamp_param(self): + self._mask.clamp_param() diff --git a/fairseq/examples/adaptive_span/adaptive_span_loss.py b/fairseq/examples/adaptive_span/adaptive_span_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..056245807e5f8d313a8ad5be68aea4e285f4f580 --- /dev/null +++ b/fairseq/examples/adaptive_span/adaptive_span_loss.py @@ -0,0 +1,106 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass + +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import register_criterion +from fairseq.criterions.cross_entropy import CrossEntropyCriterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +@dataclass +class AdaptiveSpanCriterionConfig(FairseqDataclass): + sentence_avg: bool = II("optimization.sentence_avg") + + +@register_criterion("adaptive_span_loss", dataclass=AdaptiveSpanCriterionConfig) +class AdaptiveSpanCriterion(CrossEntropyCriterion): + def __init__(self, task, sentence_avg): + super().__init__(task, sentence_avg) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss here is summed, different from the adaptive span code + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + loss, aux_loss, avg_span, max_span = self.compute_loss( + model, net_output, sample, reduce=reduce + ) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + loss /= sample_size + total_loss = loss + aux_loss + sample_size = 1 + + logging_output = { + "loss": loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + "total_loss": total_loss.data, + "avg_span": avg_span * sample_size, + "max_span": max_span * sample_size, + } + return total_loss, sample_size, logging_output + + def compute_loss(self, model, net_output, sample, reduce=True): + loss, _ = super().compute_loss(model, net_output, sample, reduce) + aux_loss = model.get_aux_loss() + avg_span = model.get_current_avg_span() + max_span = model.get_current_max_span() + return loss, aux_loss, avg_span, max_span + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + total_loss_sum = sum(log.get("total_loss", 0) for log in logging_outputs) + avg_span_sum = sum(log.get("avg_span", 0) for log in logging_outputs) + max_span_sum = sum(log.get("max_span", 0) for log in logging_outputs) + + # we divide by log(2) to convert the loss from base e to base 2 + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar("avg_span", avg_span_sum / sample_size, sample_size, round=3) + metrics.log_scalar("max_span", max_span_sum / sample_size, sample_size, round=3) + # total loss contains the L1 norm on adaptive-span + metrics.log_scalar( + "total_loss", + total_loss_sum / sample_size / math.log(2), + sample_size, + round=3, + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + else: + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/examples/adaptive_span/adaptive_span_model.py b/fairseq/examples/adaptive_span/adaptive_span_model.py new file mode 100644 index 0000000000000000000000000000000000000000..d96c95b85dbcf29e9384cc6d8d9630d2489991b2 --- /dev/null +++ b/fairseq/examples/adaptive_span/adaptive_span_model.py @@ -0,0 +1,263 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from fairseq.modules.layer_norm import LayerNorm + +from .adaptive_span_attention import AdaptiveSpan + +# Size notations: +# B = batch_size, H = d_model, M = block_size, L = attn_span + + +def _skew(X, pad_value): + """shift every row 1 step to right""" + # X = B x M x L + B, M, L = X.size() + X = F.pad(X, (0, M + 1), value=pad_value) # B x M x (L+M+1) + X = X.view(B, -1) # B x ML+MM+M + X = X[:, :-M] # B x ML+MM + X = X.view(B, M, M + L) # B x M x L+M + return X + + +def _unskew(X): + """reverse _skew operation""" + # X = B x M x L+M + B, M, L = X.size() + L -= M + X = X.view(B, -1) # B x ML+MM + X = F.pad(X, (0, M)) # B x ML+MM+M + X = X.view(B, M, M + L + 1) # B x M x L+M+1 + X = X[:, :, :L] # B x M x L + return X + + +class SeqAttention(nn.Module): + """Sequential self-attention layer. + Each token will attend to its previous fixed number of steps. + Note that attention doesn't include the current step itself. + """ + + def __init__(self, d_model, n_head, attn_span, dropout, adapt_span_layer, **kargs): + nn.Module.__init__(self) + self.dropout = nn.Dropout(dropout) + self.d_model = d_model # size of a single head + self.attn_span = attn_span + self.adaptive_span = AdaptiveSpan( + attn_span=attn_span, + n_head=n_head, + adapt_span_layer=adapt_span_layer, + **kargs + ) + + def forward(self, query, key, value, key_pe): + # query size = B x M x H + # key, value sizes = B x (M+L) x H + + key, value, key_pe = self.adaptive_span.trim_memory(query, key, value, key_pe) + + # compute attention from context + # B x M (dest) x (M+L) (src) + attn_cont = torch.matmul(query, key.transpose(-1, -2)) + attn_cont = _unskew(attn_cont) # B x M x L + + # compute the effect of position embedding + attn_pos = torch.matmul(query, key_pe) # B x M x L_pos + attn = attn_cont + attn_pos + + attn = attn / math.sqrt(self.d_model) # B x M X L_pos + + attn = F.softmax(attn.float(), dim=-1).type_as(attn) + + # trim attention lengths according to the learned span + attn = self.adaptive_span(attn) + + attn = self.dropout(attn) # B x M X L_pos + + attn_cont = _skew(attn, 0) # B x M X (L+M) + out = torch.matmul(attn_cont, value) # B x M x H + return out + + def get_cache_size(self): + return self.adaptive_span.get_cache_size() + + +class MultiHeadSeqAttention(nn.Module): + def __init__(self, d_model, n_head, **kargs): + nn.Module.__init__(self) + assert d_model % n_head == 0 + self.n_head = n_head + self.head_dim = d_model // n_head + self.attn = SeqAttention(d_model=self.head_dim, n_head=n_head, **kargs) + self.proj_query = nn.Linear(d_model, d_model, bias=False) + nn.init.xavier_normal_(self.proj_query.weight) + self.proj_out = nn.Linear(d_model, d_model, bias=False) + nn.init.xavier_normal_(self.proj_out.weight) + self.proj_val = nn.Linear(d_model, d_model, bias=False) + nn.init.xavier_normal_(self.proj_val.weight) + self.proj_key = nn.Linear(d_model, d_model, bias=False) + nn.init.xavier_normal_(self.proj_key.weight) + + def head_reshape(self, x): + K = self.n_head + D = self.head_dim + x = x.view(x.size()[:-1] + (K, D)) # B x (M+L) x K x D + x = x.transpose(1, 2).contiguous() # B x K x (M+L) x D + x = x.view(-1, x.size(-2), x.size(-1)) # B_K x (M+L) x D + return x + + def forward(self, query, key, value, key_pe): + B = query.size(0) + K = self.n_head + D = self.head_dim + M = query.size(1) + + query = self.proj_query(query) + query = self.head_reshape(query) + value = self.proj_val(value) + value = self.head_reshape(value) + key = self.proj_key(key) + key = self.head_reshape(key) + + out = self.attn(query, key, value, key_pe) # B_K x M x D + out = out.view(B, K, M, D) # B x K x M x D + out = out.transpose(1, 2).contiguous() # B x M x K x D + out = out.view(B, M, -1) # B x M x K_D + out = self.proj_out(out) + return out + + +class FeedForwardLayer(nn.Module): + def __init__(self, d_model, d_inner, dropout, **kargs): + nn.Module.__init__(self) + self.fc1 = nn.Linear(d_model, d_inner) + self.fc2 = nn.Linear(d_inner, d_model) + nn.init.xavier_uniform_(self.fc1.weight) + nn.init.xavier_uniform_(self.fc2.weight) + self.dropout = nn.Dropout(dropout) + + def forward(self, h): + h1 = F.relu(self.fc1(h)) + h1 = self.dropout(h1) + h2 = self.fc2(h1) + return h2 + + +class TransformerSeqLayer(nn.Module): + def __init__(self, d_model, **kargs): + nn.Module.__init__(self) + self.attn = MultiHeadSeqAttention(d_model=d_model, **kargs) + self.norm1 = LayerNorm(d_model) + self.ff = FeedForwardLayer(d_model=d_model, **kargs) + self.norm2 = LayerNorm(d_model) + + def forward(self, h, h_cache, key_pe): + # h = B x M x H + # h_cache = B x L x H + h_all = torch.cat([h_cache, h], dim=1) # B x (M+L) x H + attn_out = self.attn(h, h_all, h_all, key_pe) + h = self.norm1(h + attn_out) # B x M x H + if self.ff is not None: + ff_out = self.ff(h) + out = self.norm2(h + ff_out) # B x M x H + else: + out = h + return out + + def get_cache_size(self): + return self.attn.attn.get_cache_size() + + +class TransformerSeq(nn.Module): + def __init__( + self, + vocab_size, + d_model, + n_head, + n_layer, + attn_span, + emb_dropout, + aux_loss_scaler, + adapt_span_layer, + **kargs + ): + nn.Module.__init__(self) + # token embeddings + self.in_emb = nn.Embedding(vocab_size, d_model) + nn.init.normal_(self.in_emb.weight, mean=0, std=d_model ** -0.5) + self.out_emb = nn.Linear(d_model, vocab_size) + self.aux_loss_scaler = aux_loss_scaler + if emb_dropout > 0: + self.emb_dropout = nn.Dropout(emb_dropout) + else: + self.emb_dropout = None + # position embeddings + self.key_pe = nn.Parameter(torch.randn(1, d_model // n_head, attn_span)) + + self.layers = nn.ModuleList() + self.layers.extend( + TransformerSeqLayer( + d_model=d_model, + n_head=n_head, + attn_span=attn_span, + adapt_span_layer=adapt_span_layer, + **kargs + ) + for _ in range(n_layer) + ) + + def forward(self, x, h_cache, target=None): + # x size = B x M + block_size = x.size(1) + h = self.in_emb(x) # B x M x H + if self.emb_dropout is not None: + h = self.emb_dropout(h) + + h_cache_next = [] + for l, layer in enumerate(self.layers): + cache_size = layer.attn.attn.get_cache_size() + if cache_size > block_size: + h_cache_next_l = torch.cat( + [h_cache[l][:, -cache_size + block_size :, :], h], dim=1 + ).detach() + else: + h_cache_next_l = h[:, -cache_size:, :].detach() + h_cache_next.append(h_cache_next_l) + h = layer(h, h_cache[l], self.key_pe) # B x M x H + + if self.emb_dropout is not None: + h = self.emb_dropout(h) + + out = F.log_softmax(self.out_emb(h).float(), dim=-1).type_as(h) + dummy_loss = None + + return out, h_cache_next, dummy_loss + + def get_aux_loss(self): + loss = 0.0 + for layer in self.layers: + loss += layer.attn.attn.adaptive_span.get_loss() + return self.aux_loss_scaler * loss + + def get_current_max_span(self): + max_span = 0.0 + for layer in self.layers: + max_span = max( + max_span, layer.attn.attn.adaptive_span.get_current_max_span() + ) + return max_span + + def get_current_avg_span(self): + avg_span = 0.0 + for layer in self.layers: + avg_span += layer.attn.attn.adaptive_span.get_current_avg_span() + return avg_span / len(self.layers) diff --git a/fairseq/examples/adaptive_span/adaptive_span_model_wrapper.py b/fairseq/examples/adaptive_span/adaptive_span_model_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..5b147fe11f9d730438d036321a2d4a5d776efaa2 --- /dev/null +++ b/fairseq/examples/adaptive_span/adaptive_span_model_wrapper.py @@ -0,0 +1,145 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from dataclasses import dataclass +from typing import Dict, List, Optional + +import torch +from fairseq.dataclass import FairseqDataclass +from fairseq.models import ( + FairseqIncrementalDecoder, + FairseqLanguageModel, + register_model, +) +from .adaptive_span_model import TransformerSeq as AdaptiveSpanTransformerModel + + +logger = logging.getLogger(__name__) + + +@dataclass +class AdaptiveSpanSmallConfig(FairseqDataclass): + # defaults come from https://github.com/facebookresearch/adaptive-span/blob/master/experiments/enwik8_small.sh + vocab_size: int = 50 + d_model: int = 256 + n_head: int = 4 + d_inner: int = 1024 + n_layer: int = 8 + attn_span: int = 1024 + dropout: float = 0.0 + emb_dropout: float = 0.0 + adapt_span_ramp: int = 32 + adapt_span_init: float = 0.0 + aux_loss_scaler: float = 0.000002 + adapt_span_layer: bool = False + + +@register_model("adaptive_span", dataclass=AdaptiveSpanSmallConfig) +class AdaptiveSpanTransformer(FairseqLanguageModel): + @classmethod + def build_model(cls, cfg: AdaptiveSpanSmallConfig, task): + return cls(AdaptiveSpanDecoder(cfg, task)) + + def get_aux_loss(self): + return self.decoder.get_aux_loss() + + def get_current_max_span(self): + return self.decoder.get_current_max_span() + + def get_current_avg_span(self): + return self.decoder.get_current_avg_span() + + +class AdaptiveSpanDecoder(FairseqIncrementalDecoder): + def __init__(self, cfg, task): + + super().__init__(task.target_dictionary) + + self.config = cfg + config = AdaptiveSpanSmallConfig( + vocab_size=len(task.target_dictionary), + d_model=cfg.d_model, + n_head=cfg.n_head, + d_inner=cfg.d_inner, + n_layer=cfg.n_layer, + attn_span=cfg.attn_span, + dropout=cfg.dropout, + emb_dropout=cfg.emb_dropout, + adapt_span_ramp=cfg.adapt_span_ramp, + adapt_span_init=cfg.adapt_span_init, + aux_loss_scaler=cfg.aux_loss_scaler, + adapt_span_layer=cfg.adapt_span_layer, + ) + logger.info(config) + self.model = AdaptiveSpanTransformerModel(**config.__dict__) + + self._mems = None + + def forward( + self, + src_tokens, + incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None, + encoder_out=None, + ): + bsz = src_tokens.size(0) + if incremental_state is not None: # used during inference + mems = self.get_incremental_state("mems") + src_tokens = src_tokens[:, -1:] # only keep the most recent token + else: + mems = self._mems + + if mems is None: + # first time init + mems = self.init_hid_cache(bsz) + output = self.model(x=src_tokens, h_cache=mems,) + if incremental_state is not None: + self.set_incremental_state(incremental_state, "mems", output[1]) + else: + self._mems = output[1] + return (output[0],) + + def max_positions(self): + return self.config.attn_span + + def init_hid_cache(self, batch_sz): + hid = [] + for layer in self.model.layers: + param = next(self.model.parameters()) + h = torch.zeros( + batch_sz, + layer.get_cache_size(), + self.config.d_model, + dtype=param.dtype, + device=param.device, + ) + hid.append(h) + return hid + + def get_aux_loss(self): + return self.model.get_aux_loss() + + def get_current_max_span(self): + return self.model.get_current_max_span() + + def get_current_avg_span(self): + return self.model.get_current_avg_span() + + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[torch.Tensor]]], + new_order: torch.Tensor, + ): + """Reorder incremental state. + + This will be called when the order of the input has changed from the + previous time step. A typical use case is beam search, where the input + order changes between time steps based on the selection of beams. + """ + raise NotImplementedError("This is required for generation/beam search") + # mems = self.get_incremental_state(incremental_state, "mems") + # if mems is not None: + # new_mems = [mems_i.index_select(1, new_order) for mems_i in mems] + # self.set_incremental_state(incremental_state, "mems", new_mems) diff --git a/fairseq/examples/adaptive_span/truncated_bptt_lm_task.py b/fairseq/examples/adaptive_span/truncated_bptt_lm_task.py new file mode 100644 index 0000000000000000000000000000000000000000..02be0e7fb4213b98798c85b79e9046e9990b97fc --- /dev/null +++ b/fairseq/examples/adaptive_span/truncated_bptt_lm_task.py @@ -0,0 +1,281 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +from dataclasses import dataclass, field +from typing import List, Optional, Tuple + +import torch +from fairseq import utils +from fairseq.data import ( + Dictionary, + TokenBlockDataset, + data_utils, + iterators, +) +from fairseq.dataclass import FairseqDataclass +from fairseq.distributed import utils as dist_utils +from fairseq.tasks import FairseqTask, register_task +from omegaconf import II + + +logger = logging.getLogger(__name__) + + +@dataclass +class TruncatedBPTTLMConfig(FairseqDataclass): + data: str = field(default="???", metadata={"help": "path to data directory"}) + tokens_per_sample: int = field( + default=1024, + metadata={"help": "max number of tokens per sequence"}, + ) + batch_size: int = II("dataset.batch_size") + # Some models use *max_target_positions* to know how many positional + # embeddings to learn. We use II(...) to make it default to + # *tokens_per_sample*, but in principle there could be more positional + # embeddings than tokens in a single batch. This may also be irrelevant for + # custom model implementations. + max_target_positions: int = II("task.tokens_per_sample") + # these will be populated automatically if not provided + data_parallel_rank: Optional[int] = None + data_parallel_size: Optional[int] = None + + +@register_task("truncated_bptt_lm", dataclass=TruncatedBPTTLMConfig) +class TruncatedBPTTLMTask(FairseqTask): + def __init__(self, cfg: TruncatedBPTTLMConfig): + super().__init__(cfg) + + if cfg.data_parallel_rank is None or cfg.data_parallel_size is None: + if torch.distributed.is_initialized(): + cfg.data_parallel_rank = dist_utils.get_data_parallel_rank() + cfg.data_parallel_size = dist_utils.get_data_parallel_world_size() + else: + cfg.data_parallel_rank = 0 + cfg.data_parallel_size = 1 + + # load the dictionary + paths = utils.split_paths(cfg.data) + assert len(paths) > 0 + self.dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(self.dictionary))) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split (e.g., train, valid, test)""" + + # support sharded datasets + paths = utils.split_paths(self.cfg.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + # each element of *data* will be a tensorized line from the original + # text dataset, similar to ``open(split_path).readlines()`` + data = data_utils.load_indexed_dataset( + split_path, self.dictionary, combine=combine + ) + if data is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + # this is similar to ``data.view(-1).split(tokens_per_sample)`` + data = TokenBlockDataset( + data, + data.sizes, + block_size=self.cfg.tokens_per_sample, + pad=None, # unused + eos=None, # unused + break_mode="none", + ) + + self.datasets[split] = TruncatedBPTTDataset( + data=data, + bsz_per_shard=self.cfg.batch_size, + shard_id=self.cfg.data_parallel_rank, + num_shards=self.cfg.data_parallel_size, + ) + + def dataset(self, split): + return self.datasets[split] + + def get_batch_iterator( + self, dataset, num_workers=0, epoch=1, data_buffer_size=0, **kwargs + ): + return iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=self._collate_fn, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size, + # we don't use the batching functionality from EpochBatchIterator; + # instead every item in *dataset* is a whole batch + batch_sampler=[[i] for i in range(len(dataset))], + disable_shuffling=True, + ) + + def _collate_fn(self, items: List[List[torch.Tensor]]): + # we don't use fairseq's batching functionality, so we expect a single + # Tensor of type List[torch.Tensor] + assert len(items) == 1 + + # item will have shape B x T (the last batch may have length < T) + id, item = items[0] + item = data_utils.collate_tokens(item, pad_idx=self.source_dictionary.pad()) + B, T = item.size() + + # shift item one position over and append a padding token for the target + target = torch.nn.functional.pad( + item[:, 1:], (0, 1, 0, 0), value=self.target_dictionary.pad() + ) + + # fairseq expects batches to have the following structure + return { + "id": torch.tensor([id]*item.size(0)), + "net_input": { + "src_tokens": item, + }, + "target": target, + "nsentences": item.size(0), + "ntokens": item.numel(), + } + + def build_dataset_for_inference( + self, src_tokens: List[torch.Tensor], src_lengths: List[int], **kwargs + ) -> torch.utils.data.Dataset: + eos = self.source_dictionary.eos() + dataset = TokenBlockDataset( + src_tokens, + src_lengths, + block_size=None, # ignored for "eos" break mode + pad=self.source_dictionary.pad(), + eos=eos, + break_mode="eos", + ) + + class Dataset(torch.utils.data.Dataset): + def __getitem__(self, i): + item = dataset[i] + if item[-1] == eos: + # remove eos to support generating with a prefix + item = item[:-1] + return (i, [item]) + + def __len__(self): + return len(dataset) + + return Dataset() + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + if constraints is not None: + raise NotImplementedError + + # SequenceGenerator doesn't use *src_tokens* directly, we need to + # pass the *prefix_tokens* argument instead. + if prefix_tokens is None and sample["net_input"]["src_tokens"].nelement(): + prefix_tokens = sample["net_input"]["src_tokens"] + + # begin generation with the end-of-sentence token + bos_token = self.source_dictionary.eos() + + return generator.generate( + models, sample, prefix_tokens=prefix_tokens, bos_token=bos_token + ) + + def eval_lm_dataloader( + self, + dataset, + max_tokens: Optional[int] = 36000, + batch_size: Optional[int] = None, + max_positions: Optional[int] = None, + num_shards: int = 1, + shard_id: int = 0, + num_workers: int = 1, + data_buffer_size: int = 10, + context_window: int = 0, + ): + if context_window > 0: + raise NotImplementedError( + "Transformer-XL doesn't need --context-window, try " + "--model-overrides '{\"mem_len\":42}' instead " + ) + return self.get_batch_iterator( + dataset=dataset, + max_tokens=max_tokens, + max_sentences=batch_size, + max_positions=max_positions, + ignore_invalid_inputs=True, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + data_buffer_size=data_buffer_size, + ).next_epoch_itr(shuffle=False) + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + +class TruncatedBPTTDataset(torch.utils.data.Dataset): + def __init__( + self, + data: List[torch.Tensor], # ordered list of items + bsz_per_shard, # number of items processed per GPUs per forward + shard_id, # current GPU ID + num_shards, # number of GPUs + ): + super().__init__() + self.data = data + + def batchify(data, bsz): + # Work out how cleanly we can divide the dataset into bsz parts. + nbatch = data.size(0) // bsz + # Trim off any extra elements that wouldn't cleanly fit (remainders). + data = data.narrow(0, 0, nbatch * bsz) + # Evenly divide the data across the bsz batches. + data = data.view(bsz, -1).contiguous() + return data + + # total number of sequences processed by all GPUs in each forward pass + global_batch_size = bsz_per_shard * num_shards + + """ + With a 16 item dataset, bsz_per_shard=2 and num_shards=3, + *indices* might look like: + + indices = [[0, 1], + [2, 3], + [4, 5], + [6, 7], + [8, 9], + [10, 11]] + + The size of the TruncatedBPTTDataset instance will be 2, + and shard 1 will see items: + + [(0, [data[4], data[6]]), + (1, [data[5], data[7]])] + """ + indices = batchify(torch.arange(len(data)), global_batch_size) + assert indices.size(0) == global_batch_size + + self.my_indices = indices[ + shard_id * bsz_per_shard : (shard_id + 1) * bsz_per_shard + ] + assert self.my_indices.size(0) == bsz_per_shard + + def __len__(self): + return self.my_indices.size(1) + + def __getitem__(self, i) -> Tuple[int, List[torch.Tensor]]: + return (i, [self.data[idx] for idx in self.my_indices[:, i]]) diff --git a/fairseq/examples/backtranslation/README.md b/fairseq/examples/backtranslation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..73675f1125d80f58aa824db67d8970504d4d6b2a --- /dev/null +++ b/fairseq/examples/backtranslation/README.md @@ -0,0 +1,297 @@ +# Understanding Back-Translation at Scale (Edunov et al., 2018) + +This page includes pre-trained models from the paper [Understanding Back-Translation at Scale (Edunov et al., 2018)](https://arxiv.org/abs/1808.09381). + +## Pre-trained models + +Model | Description | Dataset | Download +---|---|---|--- +`transformer.wmt18.en-de` | Transformer
([Edunov et al., 2018](https://arxiv.org/abs/1808.09381))
WMT'18 winner | [WMT'18 English-German](http://www.statmt.org/wmt18/translation-task.html) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt18.en-de.ensemble.tar.gz)
See NOTE in the archive + +## Example usage (torch.hub) + +We require a few additional Python dependencies for preprocessing: +```bash +pip install subword_nmt sacremoses +``` + +Then to generate translations from the full model ensemble: +```python +import torch + +# List available models +torch.hub.list('pytorch/fairseq') # [..., 'transformer.wmt18.en-de', ... ] + +# Load the WMT'18 En-De ensemble +en2de_ensemble = torch.hub.load( + 'pytorch/fairseq', 'transformer.wmt18.en-de', + checkpoint_file='wmt18.model1.pt:wmt18.model2.pt:wmt18.model3.pt:wmt18.model4.pt:wmt18.model5.pt', + tokenizer='moses', bpe='subword_nmt') + +# The ensemble contains 5 models +len(en2de_ensemble.models) +# 5 + +# Translate +en2de_ensemble.translate('Hello world!') +# 'Hallo Welt!' +``` + +## Training your own model (WMT'18 English-German) + +The following instructions can be adapted to reproduce the models from the paper. + + +#### Step 1. Prepare parallel data and optionally train a baseline (English-German) model + +First download and preprocess the data: +```bash +# Download and prepare the data +cd examples/backtranslation/ +bash prepare-wmt18en2de.sh +cd ../.. + +# Binarize the data +TEXT=examples/backtranslation/wmt18_en_de +fairseq-preprocess \ + --joined-dictionary \ + --source-lang en --target-lang de \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/wmt18_en_de --thresholdtgt 0 --thresholdsrc 0 \ + --workers 20 + +# Copy the BPE code into the data-bin directory for future use +cp examples/backtranslation/wmt18_en_de/code data-bin/wmt18_en_de/code +``` + +(Optionally) Train a baseline model (English-German) using just the parallel data: +```bash +CHECKPOINT_DIR=checkpoints_en_de_parallel +fairseq-train --fp16 \ + data-bin/wmt18_en_de \ + --source-lang en --target-lang de \ + --arch transformer_wmt_en_de_big --share-all-embeddings \ + --dropout 0.3 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr 0.001 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --max-tokens 3584 --update-freq 16 \ + --max-update 30000 \ + --save-dir $CHECKPOINT_DIR +# Note: the above command assumes 8 GPUs. Adjust `--update-freq` if you have a +# different number of GPUs. +``` + +Average the last 10 checkpoints: +```bash +python scripts/average_checkpoints.py \ + --inputs $CHECKPOINT_DIR \ + --num-epoch-checkpoints 10 \ + --output $CHECKPOINT_DIR/checkpoint.avg10.pt +``` + +Evaluate BLEU: +```bash +# tokenized BLEU on newstest2017: +bash examples/backtranslation/tokenized_bleu.sh \ + wmt17 \ + en-de \ + data-bin/wmt18_en_de \ + data-bin/wmt18_en_de/code \ + $CHECKPOINT_DIR/checkpoint.avg10.pt +# BLEU4 = 29.57, 60.9/35.4/22.9/15.5 (BP=1.000, ratio=1.014, syslen=63049, reflen=62152) +# compare to 29.46 in Table 1, which is also for tokenized BLEU + +# generally it's better to report (detokenized) sacrebleu though: +bash examples/backtranslation/sacrebleu.sh \ + wmt17 \ + en-de \ + data-bin/wmt18_en_de \ + data-bin/wmt18_en_de/code \ + $CHECKPOINT_DIR/checkpoint.avg10.pt +# BLEU+case.mixed+lang.en-de+numrefs.1+smooth.exp+test.wmt17+tok.13a+version.1.4.3 = 29.0 60.6/34.7/22.4/14.9 (BP = 1.000 ratio = 1.013 hyp_len = 62099 ref_len = 61287) +``` + + +#### Step 2. Back-translate monolingual German data + +Train a reverse model (German-English) to do the back-translation: +```bash +CHECKPOINT_DIR=checkpoints_de_en_parallel +fairseq-train --fp16 \ + data-bin/wmt18_en_de \ + --source-lang de --target-lang en \ + --arch transformer_wmt_en_de_big --share-all-embeddings \ + --dropout 0.3 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr 0.001 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --max-tokens 3584 --update-freq 16 \ + --max-update 30000 \ + --save-dir $CHECKPOINT_DIR +# Note: the above command assumes 8 GPUs. Adjust `--update-freq` if you have a +# different number of GPUs. +``` + +Let's evaluate the back-translation (BT) model to make sure it is well trained: +```bash +bash examples/backtranslation/sacrebleu.sh \ + wmt17 \ + de-en \ + data-bin/wmt18_en_de \ + data-bin/wmt18_en_de/code \ + $CHECKPOINT_DIR/checkpoint_best.py +# BLEU+case.mixed+lang.de-en+numrefs.1+smooth.exp+test.wmt17+tok.13a+version.1.4.3 = 34.9 66.9/41.8/28.5/19.9 (BP = 0.983 ratio = 0.984 hyp_len = 63342 ref_len = 64399) +# compare to the best system from WMT'17 which scored 35.1: http://matrix.statmt.org/matrix/systems_list/1868 +``` + +Next prepare the monolingual data: +```bash +# Download and prepare the monolingual data +# By default the script samples 25M monolingual sentences, which after +# deduplication should be just over 24M sentences. These are split into 25 +# shards, each with 1M sentences (except for the last shard). +cd examples/backtranslation/ +bash prepare-de-monolingual.sh +cd ../.. + +# Binarize each shard of the monolingual data +TEXT=examples/backtranslation/wmt18_de_mono +for SHARD in $(seq -f "%02g" 0 24); do \ + fairseq-preprocess \ + --only-source \ + --source-lang de --target-lang en \ + --joined-dictionary \ + --srcdict data-bin/wmt18_en_de/dict.de.txt \ + --testpref $TEXT/bpe.monolingual.dedup.${SHARD} \ + --destdir data-bin/wmt18_de_mono/shard${SHARD} \ + --workers 20; \ + cp data-bin/wmt18_en_de/dict.en.txt data-bin/wmt18_de_mono/shard${SHARD}/; \ +done +``` + +Now we're ready to perform back-translation over the monolingual data. The +following command generates via sampling, but it's possible to use greedy +decoding (`--beam 1`), beam search (`--beam 5`), +top-k sampling (`--sampling --beam 1 --sampling-topk 10`), etc.: +```bash +mkdir backtranslation_output +for SHARD in $(seq -f "%02g" 0 24); do \ + fairseq-generate --fp16 \ + data-bin/wmt18_de_mono/shard${SHARD} \ + --path $CHECKPOINT_DIR/checkpoint_best.pt \ + --skip-invalid-size-inputs-valid-test \ + --max-tokens 4096 \ + --sampling --beam 1 \ + > backtranslation_output/sampling.shard${SHARD}.out; \ +done +``` + +After BT, use the `extract_bt_data.py` script to re-combine the shards, extract +the back-translations and apply length ratio filters: +```bash +python examples/backtranslation/extract_bt_data.py \ + --minlen 1 --maxlen 250 --ratio 1.5 \ + --output backtranslation_output/bt_data --srclang en --tgtlang de \ + backtranslation_output/sampling.shard*.out + +# Ensure lengths are the same: +# wc -l backtranslation_output/bt_data.{en,de} +# 21795614 backtranslation_output/bt_data.en +# 21795614 backtranslation_output/bt_data.de +# 43591228 total +``` + +Binarize the filtered BT data and combine it with the parallel data: +```bash +TEXT=backtranslation_output +fairseq-preprocess \ + --source-lang en --target-lang de \ + --joined-dictionary \ + --srcdict data-bin/wmt18_en_de/dict.en.txt \ + --trainpref $TEXT/bt_data \ + --destdir data-bin/wmt18_en_de_bt \ + --workers 20 + +# We want to train on the combined data, so we'll symlink the parallel + BT data +# in the wmt18_en_de_para_plus_bt directory. We link the parallel data as "train" +# and the BT data as "train1", so that fairseq will combine them automatically +# and so that we can use the `--upsample-primary` option to upsample the +# parallel data (if desired). +PARA_DATA=$(readlink -f data-bin/wmt18_en_de) +BT_DATA=$(readlink -f data-bin/wmt18_en_de_bt) +COMB_DATA=data-bin/wmt18_en_de_para_plus_bt +mkdir -p $COMB_DATA +for LANG in en de; do \ + ln -s ${PARA_DATA}/dict.$LANG.txt ${COMB_DATA}/dict.$LANG.txt; \ + for EXT in bin idx; do \ + ln -s ${PARA_DATA}/train.en-de.$LANG.$EXT ${COMB_DATA}/train.en-de.$LANG.$EXT; \ + ln -s ${BT_DATA}/train.en-de.$LANG.$EXT ${COMB_DATA}/train1.en-de.$LANG.$EXT; \ + ln -s ${PARA_DATA}/valid.en-de.$LANG.$EXT ${COMB_DATA}/valid.en-de.$LANG.$EXT; \ + ln -s ${PARA_DATA}/test.en-de.$LANG.$EXT ${COMB_DATA}/test.en-de.$LANG.$EXT; \ + done; \ +done +``` + + +#### 3. Train an English-German model over the combined parallel + BT data + +Finally we can train a model over the parallel + BT data: +```bash +CHECKPOINT_DIR=checkpoints_en_de_parallel_plus_bt +fairseq-train --fp16 \ + data-bin/wmt18_en_de_para_plus_bt \ + --upsample-primary 16 \ + --source-lang en --target-lang de \ + --arch transformer_wmt_en_de_big --share-all-embeddings \ + --dropout 0.3 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr 0.0007 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --max-tokens 3584 --update-freq 16 \ + --max-update 100000 \ + --save-dir $CHECKPOINT_DIR +# Note: the above command assumes 8 GPUs. Adjust `--update-freq` if you have a +# different number of GPUs. +``` + +Average the last 10 checkpoints: +```bash +python scripts/average_checkpoints.py \ + --inputs $CHECKPOINT_DIR \ + --num-epoch-checkpoints 10 \ + --output $CHECKPOINT_DIR/checkpoint.avg10.pt +``` + +Evaluate BLEU: +```bash +# tokenized BLEU on newstest2017: +bash examples/backtranslation/tokenized_bleu.sh \ + wmt17 \ + en-de \ + data-bin/wmt18_en_de \ + data-bin/wmt18_en_de/code \ + $CHECKPOINT_DIR/checkpoint.avg10.pt +# BLEU4 = 32.35, 64.4/38.9/26.2/18.3 (BP=0.977, ratio=0.977, syslen=60729, reflen=62152) +# compare to 32.35 in Table 1, which is also for tokenized BLEU + +# generally it's better to report (detokenized) sacrebleu: +bash examples/backtranslation/sacrebleu.sh \ + wmt17 \ + en-de \ + data-bin/wmt18_en_de \ + data-bin/wmt18_en_de/code \ + $CHECKPOINT_DIR/checkpoint.avg10.pt +# BLEU+case.mixed+lang.en-de+numrefs.1+smooth.exp+test.wmt17+tok.13a+version.1.4.3 = 31.5 64.3/38.2/25.6/17.6 (BP = 0.971 ratio = 0.971 hyp_len = 59515 ref_len = 61287) +``` + + +## Citation +```bibtex +@inproceedings{edunov2018backtranslation, + title = {Understanding Back-Translation at Scale}, + author = {Edunov, Sergey and Ott, Myle and Auli, Michael and Grangier, David}, + booktitle = {Conference of the Association for Computational Linguistics (ACL)}, + year = 2018, +} +``` diff --git a/fairseq/examples/backtranslation/deduplicate_lines.py b/fairseq/examples/backtranslation/deduplicate_lines.py new file mode 100644 index 0000000000000000000000000000000000000000..50e458328c80b71c42a66d473381ca7e98d294da --- /dev/null +++ b/fairseq/examples/backtranslation/deduplicate_lines.py @@ -0,0 +1,41 @@ +#!/usr/bin/python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import fileinput +import hashlib +import sys +from multiprocessing import Pool + + +def get_hashes_and_lines(raw_line): + hash = hashlib.md5(raw_line).hexdigest() + return hash, raw_line + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--workers", type=int, default=10) + parser.add_argument("files", nargs="*", help="input files") + args = parser.parse_args() + + seen = set() + with fileinput.input(args.files, mode="rb") as h: + pool = Pool(args.workers) + results = pool.imap_unordered(get_hashes_and_lines, h, 1000) + for i, (hash, raw_line) in enumerate(results): + if hash not in seen: + seen.add(hash) + sys.stdout.buffer.write(raw_line) + if i % 1000000 == 0: + print(i, file=sys.stderr, end="", flush=True) + elif i % 100000 == 0: + print(".", file=sys.stderr, end="", flush=True) + print(file=sys.stderr, flush=True) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/backtranslation/extract_bt_data.py b/fairseq/examples/backtranslation/extract_bt_data.py new file mode 100644 index 0000000000000000000000000000000000000000..e766391e873d0d9a9561d67d5864934b2fad0681 --- /dev/null +++ b/fairseq/examples/backtranslation/extract_bt_data.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import fileinput + +from tqdm import tqdm + + +def main(): + parser = argparse.ArgumentParser( + description=( + "Extract back-translations from the stdout of fairseq-generate. " + "If there are multiply hypotheses for a source, we only keep the first one. " + ) + ) + parser.add_argument("--output", required=True, help="output prefix") + parser.add_argument( + "--srclang", required=True, help="source language (extracted from H-* lines)" + ) + parser.add_argument( + "--tgtlang", required=True, help="target language (extracted from S-* lines)" + ) + parser.add_argument("--minlen", type=int, help="min length filter") + parser.add_argument("--maxlen", type=int, help="max length filter") + parser.add_argument("--ratio", type=float, help="ratio filter") + parser.add_argument("files", nargs="*", help="input files") + args = parser.parse_args() + + def validate(src, tgt): + srclen = len(src.split(" ")) if src != "" else 0 + tgtlen = len(tgt.split(" ")) if tgt != "" else 0 + if ( + (args.minlen is not None and (srclen < args.minlen or tgtlen < args.minlen)) + or ( + args.maxlen is not None + and (srclen > args.maxlen or tgtlen > args.maxlen) + ) + or ( + args.ratio is not None + and (max(srclen, tgtlen) / float(min(srclen, tgtlen)) > args.ratio) + ) + ): + return False + return True + + def safe_index(toks, index, default): + try: + return toks[index] + except IndexError: + return default + + with open(args.output + "." + args.srclang, "w") as src_h, open( + args.output + "." + args.tgtlang, "w" + ) as tgt_h: + for line in tqdm(fileinput.input(args.files)): + if line.startswith("S-"): + tgt = safe_index(line.rstrip().split("\t"), 1, "") + elif line.startswith("H-"): + if tgt is not None: + src = safe_index(line.rstrip().split("\t"), 2, "") + if validate(src, tgt): + print(src, file=src_h) + print(tgt, file=tgt_h) + tgt = None + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/backtranslation/prepare-de-monolingual.sh b/fairseq/examples/backtranslation/prepare-de-monolingual.sh new file mode 100644 index 0000000000000000000000000000000000000000..5e67b2b3bcf27d3436031453e796e58a0ae79ec4 --- /dev/null +++ b/fairseq/examples/backtranslation/prepare-de-monolingual.sh @@ -0,0 +1,98 @@ +#!/bin/bash + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +NORM_PUNC=$SCRIPTS/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl +BPEROOT=subword-nmt/subword_nmt + + +BPE_CODE=wmt18_en_de/code +SUBSAMPLE_SIZE=25000000 +LANG=de + + +OUTDIR=wmt18_${LANG}_mono +orig=orig +tmp=$OUTDIR/tmp +mkdir -p $OUTDIR $tmp + + +URLS=( + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2007.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2008.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2009.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2010.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2011.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2012.de.shuffled.gz" + "http://www.statmt.org/wmt14/training-monolingual-news-crawl/news.2013.de.shuffled.gz" + "http://www.statmt.org/wmt15/training-monolingual-news-crawl-v2/news.2014.de.shuffled.v2.gz" + "http://data.statmt.org/wmt16/translation-task/news.2015.de.shuffled.gz" + "http://data.statmt.org/wmt17/translation-task/news.2016.de.shuffled.gz" + "http://data.statmt.org/wmt18/translation-task/news.2017.de.shuffled.deduped.gz" +) +FILES=( + "news.2007.de.shuffled.gz" + "news.2008.de.shuffled.gz" + "news.2009.de.shuffled.gz" + "news.2010.de.shuffled.gz" + "news.2011.de.shuffled.gz" + "news.2012.de.shuffled.gz" + "news.2013.de.shuffled.gz" + "news.2014.de.shuffled.v2.gz" + "news.2015.de.shuffled.gz" + "news.2016.de.shuffled.gz" + "news.2017.de.shuffled.deduped.gz" +) + + +cd $orig +for ((i=0;i<${#URLS[@]};++i)); do + file=${FILES[i]} + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + url=${URLS[i]} + wget "$url" + fi +done +cd .. + + +if [ -f $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG} ]; then + echo "found monolingual sample, skipping shuffle/sample/tokenize" +else + gzip -c -d -k $(for FILE in "${FILES[@]}"; do echo $orig/$FILE; done) \ + | shuf -n $SUBSAMPLE_SIZE \ + | perl $NORM_PUNC $LANG \ + | perl $REM_NON_PRINT_CHAR \ + | perl $TOKENIZER -threads 8 -a -l $LANG \ + > $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG} +fi + + +if [ -f $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG} ]; then + echo "found BPE monolingual sample, skipping BPE step" +else + python $BPEROOT/apply_bpe.py -c $BPE_CODE \ + < $tmp/monolingual.${SUBSAMPLE_SIZE}.${LANG} \ + > $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG} +fi + + +if [ -f $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG} ]; then + echo "found deduplicated monolingual sample, skipping deduplication step" +else + python deduplicate_lines.py $tmp/bpe.monolingual.${SUBSAMPLE_SIZE}.${LANG} \ + > $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG} +fi + + +if [ -f $OUTDIR/bpe.monolingual.dedup.00.de ]; then + echo "found sharded data, skipping sharding step" +else + split --lines 1000000 --numeric-suffixes \ + --additional-suffix .${LANG} \ + $tmp/bpe.monolingual.dedup.${SUBSAMPLE_SIZE}.${LANG} \ + $OUTDIR/bpe.monolingual.dedup. +fi diff --git a/fairseq/examples/backtranslation/prepare-wmt18en2de.sh b/fairseq/examples/backtranslation/prepare-wmt18en2de.sh new file mode 100644 index 0000000000000000000000000000000000000000..f6fd275307db50ca84c299440ae02dce49064030 --- /dev/null +++ b/fairseq/examples/backtranslation/prepare-wmt18en2de.sh @@ -0,0 +1,135 @@ +#!/bin/bash +# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh + +echo 'Cloning Moses github repository (for tokenization scripts)...' +git clone https://github.com/moses-smt/mosesdecoder.git + +echo 'Cloning Subword NMT repository (for BPE pre-processing)...' +git clone https://github.com/rsennrich/subword-nmt.git + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +CLEAN=$SCRIPTS/training/clean-corpus-n.perl +NORM_PUNC=$SCRIPTS/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl +BPEROOT=subword-nmt/subword_nmt +BPE_TOKENS=32000 + +URLS=( + "http://statmt.org/wmt13/training-parallel-europarl-v7.tgz" + "http://statmt.org/wmt13/training-parallel-commoncrawl.tgz" + "http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz" + "http://data.statmt.org/wmt18/translation-task/rapid2016.tgz" + "http://data.statmt.org/wmt17/translation-task/dev.tgz" + "http://statmt.org/wmt14/test-full.tgz" +) +FILES=( + "training-parallel-europarl-v7.tgz" + "training-parallel-commoncrawl.tgz" + "training-parallel-nc-v13.tgz" + "rapid2016.tgz" + "dev.tgz" + "test-full.tgz" +) +CORPORA=( + "training/europarl-v7.de-en" + "commoncrawl.de-en" + "training-parallel-nc-v13/news-commentary-v13.de-en" + "rapid2016.de-en" +) + +if [ ! -d "$SCRIPTS" ]; then + echo "Please set SCRIPTS variable correctly to point to Moses scripts." + exit 1 +fi + +OUTDIR=wmt18_en_de + +src=en +tgt=de +lang=en-de +prep=$OUTDIR +tmp=$prep/tmp +orig=orig + +mkdir -p $orig $tmp $prep + +cd $orig + +for ((i=0;i<${#URLS[@]};++i)); do + file=${FILES[i]} + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + url=${URLS[i]} + wget "$url" + if [ -f $file ]; then + echo "$url successfully downloaded." + else + echo "$url not successfully downloaded." + exit 1 + fi + if [ ${file: -4} == ".tgz" ]; then + tar zxvf $file + elif [ ${file: -4} == ".tar" ]; then + tar xvf $file + fi + fi +done +cd .. + +echo "pre-processing train data..." +for l in $src $tgt; do + rm $tmp/train.tags.$lang.tok.$l + for f in "${CORPORA[@]}"; do + cat $orig/$f.$l | \ + perl $NORM_PUNC $l | \ + perl $REM_NON_PRINT_CHAR | \ + perl $TOKENIZER -threads 8 -a -l $l >> $tmp/train.tags.$lang.tok.$l + done +done + +echo "pre-processing test data..." +for l in $src $tgt; do + if [ "$l" == "$src" ]; then + t="src" + else + t="ref" + fi + grep '\s*//g' | \ + sed -e 's/\s*<\/seg>\s*//g' | \ + sed -e "s/\’/\'/g" | \ + perl $TOKENIZER -threads 8 -a -l $l > $tmp/test.$l + echo "" +done + +echo "splitting train and valid..." +for l in $src $tgt; do + awk '{if (NR%100 == 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/valid.$l + awk '{if (NR%100 != 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/train.$l +done + +TRAIN=$tmp/train.de-en +BPE_CODE=$prep/code +rm -f $TRAIN +for l in $src $tgt; do + cat $tmp/train.$l >> $TRAIN +done + +echo "learn_bpe.py on ${TRAIN}..." +python $BPEROOT/learn_bpe.py -s $BPE_TOKENS < $TRAIN > $BPE_CODE + +for L in $src $tgt; do + for f in train.$L valid.$L test.$L; do + echo "apply_bpe.py to ${f}..." + python $BPEROOT/apply_bpe.py -c $BPE_CODE < $tmp/$f > $tmp/bpe.$f + done +done + +perl $CLEAN -ratio 1.5 $tmp/bpe.train $src $tgt $prep/train 1 250 +perl $CLEAN -ratio 1.5 $tmp/bpe.valid $src $tgt $prep/valid 1 250 + +for L in $src $tgt; do + cp $tmp/bpe.test.$L $prep/test.$L +done diff --git a/fairseq/examples/backtranslation/sacrebleu.sh b/fairseq/examples/backtranslation/sacrebleu.sh new file mode 100644 index 0000000000000000000000000000000000000000..a70da23f48e2699297799611412783d4560dc45a --- /dev/null +++ b/fairseq/examples/backtranslation/sacrebleu.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +if [ $# -ne 5 ]; then + echo "usage: $0 [dataset=wmt14/full] [langpair=en-de] [databin] [bpecode] [model]" + exit +fi + + +DATASET=$1 +LANGPAIR=$2 +DATABIN=$3 +BPECODE=$4 +MODEL=$5 + +SRCLANG=$(echo $LANGPAIR | cut -d '-' -f 1) +TGTLANG=$(echo $LANGPAIR | cut -d '-' -f 2) + + +BPEROOT=examples/backtranslation/subword-nmt/subword_nmt +if [ ! -e $BPEROOT ]; then + BPEROOT=subword-nmt/subword_nmt + if [ ! -e $BPEROOT ]; then + echo 'Cloning Subword NMT repository (for BPE pre-processing)...' + git clone https://github.com/rsennrich/subword-nmt.git + fi +fi + + +sacrebleu -t $DATASET -l $LANGPAIR --echo src \ +| sacremoses tokenize -a -l $SRCLANG -q \ +| python $BPEROOT/apply_bpe.py -c $BPECODE \ +| fairseq-interactive $DATABIN --path $MODEL \ + -s $SRCLANG -t $TGTLANG \ + --beam 5 --remove-bpe --buffer-size 1024 --max-tokens 8000 \ +| grep ^H- | cut -f 3- \ +| sacremoses detokenize -l $TGTLANG -q \ +| sacrebleu -t $DATASET -l $LANGPAIR diff --git a/fairseq/examples/backtranslation/tokenized_bleu.sh b/fairseq/examples/backtranslation/tokenized_bleu.sh new file mode 100644 index 0000000000000000000000000000000000000000..c6d6aaa193f6059299bc98909324fe4b9b060372 --- /dev/null +++ b/fairseq/examples/backtranslation/tokenized_bleu.sh @@ -0,0 +1,46 @@ +#!/bin/bash + +if [ $# -ne 5 ]; then + echo "usage: $0 [dataset=wmt14/full] [langpair=en-de] [databin] [bpecode] [model]" + exit +fi + + +DATASET=$1 +LANGPAIR=$2 +DATABIN=$3 +BPECODE=$4 +MODEL=$5 + +SRCLANG=$(echo $LANGPAIR | cut -d '-' -f 1) +TGTLANG=$(echo $LANGPAIR | cut -d '-' -f 2) + + +BPEROOT=examples/backtranslation/subword-nmt/subword_nmt +if [ ! -e $BPEROOT ]; then + BPEROOT=subword-nmt/subword_nmt + if [ ! -e $BPEROOT ]; then + echo 'Cloning Subword NMT repository (for BPE pre-processing)...' + git clone https://github.com/rsennrich/subword-nmt.git + fi +fi + + +TMP_REF=$(mktemp) + +sacrebleu -t $DATASET -l $LANGPAIR --echo ref -q \ +| sacremoses normalize -l $TGTLANG -q \ +| sacremoses tokenize -a -l $TGTLANG -q \ +> $TMP_REF + +sacrebleu -t $DATASET -l $LANGPAIR --echo src -q \ +| sacremoses normalize -l $SRCLANG -q \ +| sacremoses tokenize -a -l $SRCLANG -q \ +| python $BPEROOT/apply_bpe.py -c $BPECODE \ +| fairseq-interactive $DATABIN --path $MODEL \ + -s $SRCLANG -t $TGTLANG \ + --beam 5 --remove-bpe --buffer-size 1024 --max-tokens 8000 \ +| grep ^H- | cut -f 3- \ +| fairseq-score --ref $TMP_REF + +rm -f $TMP_REF diff --git a/fairseq/examples/bart/README.glue.md b/fairseq/examples/bart/README.glue.md new file mode 100644 index 0000000000000000000000000000000000000000..a010934e1e6dec491eb1c704ec02ba7405760510 --- /dev/null +++ b/fairseq/examples/bart/README.glue.md @@ -0,0 +1,99 @@ +# Fine-tuning BART on GLUE tasks + +### 1) Download the data from GLUE website (https://gluebenchmark.com/tasks) using following commands: +```bash +wget https://gist.githubusercontent.com/W4ngatang/60c2bdb54d156a41194446737ce03e2e/raw/17b8dd0d724281ed7c3b2aeeda662b92809aadd5/download_glue_data.py +python download_glue_data.py --data_dir glue_data --tasks all +``` + +### 2) Preprocess GLUE task data (same as RoBERTa): +```bash +./examples/roberta/preprocess_GLUE_tasks.sh glue_data +``` +`glue_task_name` is one of the following: +`{ALL, QQP, MNLI, QNLI, MRPC, RTE, STS-B, SST-2, CoLA}` +Use `ALL` for preprocessing all the glue tasks. + +### 3) Fine-tuning on GLUE task: +Example fine-tuning cmd for `RTE` task +```bash +TOTAL_NUM_UPDATES=2036 # 10 epochs through RTE for bsz 16 +WARMUP_UPDATES=61 # 6 percent of the number of updates +LR=1e-05 # Peak LR for polynomial LR scheduler. +NUM_CLASSES=2 +MAX_SENTENCES=16 # Batch size. +BART_PATH=/path/to/bart/model.pt + +CUDA_VISIBLE_DEVICES=0,1 fairseq-train RTE-bin/ \ + --restore-file $BART_PATH \ + --batch-size $MAX_SENTENCES \ + --max-tokens 4400 \ + --task sentence_prediction \ + --add-prev-output-tokens \ + --layernorm-embedding \ + --share-all-embeddings \ + --share-decoder-input-output-embed \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --init-token 0 \ + --arch bart_large \ + --criterion sentence_prediction \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.01 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-08 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --max-epoch 10 \ + --find-unused-parameters \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric; +``` + +For each of the GLUE task, you will need to use following cmd-line arguments: + +Model | MNLI | QNLI | QQP | RTE | SST-2 | MRPC | CoLA | STS-B +---|---|---|---|---|---|---|---|--- +`--num-classes` | 3 | 2 | 2 | 2 | 2 | 2 | 2 | 1 +`--lr` | 5e-6 | 1e-5 | 1e-5 | 1e-5 | 5e-6 | 2e-5 | 2e-5 | 2e-5 +`bsz` | 128 | 32 | 32 | 32 | 128 | 64 | 64 | 32 +`--total-num-update` | 30968 | 33112 | 113272 | 1018 | 5233 | 1148 | 1334 | 1799 +`--warmup-updates` | 1858 | 1986 | 6796 | 61 | 314 | 68 | 80 | 107 + +For `STS-B` additionally add `--regression-target --best-checkpoint-metric loss` and remove `--maximize-best-checkpoint-metric`. + +**Note:** + +a) `--total-num-updates` is used by `--polynomial_decay` scheduler and is calculated for `--max-epoch=10` and `--batch-size=32/64/128` depending on the task. + +b) Above cmd-args and hyperparams are tested on Nvidia `V100` GPU with `32gb` of memory for each task. Depending on the GPU memory resources available to you, you can use increase `--update-freq` and reduce `--batch-size`. + +### Inference on GLUE task +After training the model as mentioned in previous step, you can perform inference with checkpoints in `checkpoints/` directory using following python code snippet: + +```python +from fairseq.models.bart import BARTModel + +bart = BARTModel.from_pretrained( + 'checkpoints/', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='RTE-bin' +) + +label_fn = lambda label: bart.task.label_dictionary.string( + [label + bart.task.label_dictionary.nspecial] +) +ncorrect, nsamples = 0, 0 +bart.cuda() +bart.eval() +with open('glue_data/RTE/dev.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[1], tokens[2], tokens[3] + tokens = bart.encode(sent1, sent2) + prediction = bart.predict('sentence_classification_head', tokens).argmax().item() + prediction_label = label_fn(prediction) + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) +``` diff --git a/fairseq/examples/bart/README.md b/fairseq/examples/bart/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4050a724ee6a2f20c9998a95df48c58b64764ab1 --- /dev/null +++ b/fairseq/examples/bart/README.md @@ -0,0 +1,228 @@ +# BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension + +[https://arxiv.org/abs/1910.13461](https://arxiv.org/abs/1910.13461) + +## Introduction + +BART is sequence-to-sequence model trained with denoising as pretraining objective. We show that this pretraining objective is more generic and show that we can match [RoBERTa](../roberta) results on SQuAD and GLUE and gain state-of-the-art results on summarization (XSum, CNN dataset), long form generative question answering (ELI5) and dialog response genration (ConvAI2). See the associated paper for more details. + +## Pre-trained models + +Model | Description | # params | Download +---|---|---|--- +`bart.base` | BART model with 6 encoder and decoder layers | 140M | [bart.base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/bart.base.tar.gz) +`bart.large` | BART model with 12 encoder and decoder layers | 400M | [bart.large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/bart.large.tar.gz) +`bart.large.mnli` | `bart.large` finetuned on `MNLI` | 400M | [bart.large.mnli.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/bart.large.mnli.tar.gz) +`bart.large.cnn` | `bart.large` finetuned on `CNN-DM` | 400M | [bart.large.cnn.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/bart.large.cnn.tar.gz) +`bart.large.xsum` | `bart.large` finetuned on `Xsum` | 400M | [bart.large.xsum.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/bart.large.xsum.tar.gz) + +## Results + +**[GLUE (Wang et al., 2019)](https://gluebenchmark.com/)** +_(dev set, single model, single-task finetuning)_ + +Model | MNLI | QNLI | QQP | RTE | SST-2 | MRPC | CoLA | STS-B +---|---|---|---|---|---|---|---|--- +`roberta.large` | 90.2 | 94.7 | 92.2 | 86.6 | 96.4 | 90.9 | 68.0 | 92.4 +`bart.large` | 89.9 | 94.9 | 92.5 | 87.0 | 96.6 | 90.4 | 62.8 | 91.2 + +**[SQuAD (Rajpurkar et al., 2018)](https://rajpurkar.github.io/SQuAD-explorer/)** +_(dev set, no additional data used)_ + +Model | SQuAD 1.1 EM/F1 | SQuAD 2.0 EM/F1 +---|---|--- +`roberta.large` | 88.9/94.6 | 86.5/89.4 +`bart.large` | 88.8/94.6 | 86.1/89.2 + +**[CNN/Daily Mail](http://nlpprogress.com/english/summarization.html)** +_(test set, no additional data used)_ + +Model | R1 | R2 | RL +---|---|---|--- +`BERTSUMEXTABS` | 42.13 | 19.60 | 39.18 +`bart.large` | 44.16 | 21.28 | 40.90 + +## Example usage + +##### Load BART from torch.hub (PyTorch >= 1.1): +```python +import torch +bart = torch.hub.load('pytorch/fairseq', 'bart.large') +bart.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Load BART (for PyTorch 1.0 or custom models): +```python +# Download bart.large model +wget https://dl.fbaipublicfiles.com/fairseq/models/bart.large.tar.gz +tar -xzvf bart.large.tar.gz + +# Load the model in fairseq +from fairseq.models.bart import BARTModel +bart = BARTModel.from_pretrained('/path/to/bart.large', checkpoint_file='model.pt') +bart.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Apply Byte-Pair Encoding (BPE) to input text: +```python +tokens = bart.encode('Hello world!') +assert tokens.tolist() == [0, 31414, 232, 328, 2] +bart.decode(tokens) # 'Hello world!' +``` + +##### Extract features from BART: +```python +# Extract the last layer's features +last_layer_features = bart.extract_features(tokens) +assert last_layer_features.size() == torch.Size([1, 5, 1024]) + +# Extract all layer's features from decoder (layer 0 is the embedding layer) +all_layers = bart.extract_features(tokens, return_all_hiddens=True) +assert len(all_layers) == 13 +assert torch.all(all_layers[-1] == last_layer_features) +``` + +##### Use BART for sentence-pair classification tasks: +```python +# Download BART already finetuned for MNLI +bart = torch.hub.load('pytorch/fairseq', 'bart.large.mnli') +bart.eval() # disable dropout for evaluation + +# Encode a pair of sentences and make a prediction +tokens = bart.encode('BART is a seq2seq model.', 'BART is not sequence to sequence.') +bart.predict('mnli', tokens).argmax() # 0: contradiction + +# Encode another pair of sentences +tokens = bart.encode('BART is denoising autoencoder.', 'BART is version of autoencoder.') +bart.predict('mnli', tokens).argmax() # 2: entailment +``` + +##### Register a new (randomly initialized) classification head: +```python +bart.register_classification_head('new_task', num_classes=3) +logprobs = bart.predict('new_task', tokens) +``` + +##### Batched prediction: +```python +import torch +from fairseq.data.data_utils import collate_tokens + +bart = torch.hub.load('pytorch/fairseq', 'bart.large.mnli') +bart.eval() + +batch_of_pairs = [ + ['BART is a seq2seq model.', 'BART is not sequence to sequence.'], + ['BART is denoising autoencoder.', 'BART is version of autoencoder.'], +] + +batch = collate_tokens( + [bart.encode(pair[0], pair[1]) for pair in batch_of_pairs], pad_idx=1 +) + +logprobs = bart.predict('mnli', batch) +print(logprobs.argmax(dim=1)) +# tensor([0, 2]) +``` + +##### Using the GPU: +```python +bart.cuda() +bart.predict('new_task', tokens) +``` + +#### Filling masks: + +BART can be used to fill multiple `` tokens in the input. +```python +bart = torch.hub.load('pytorch/fairseq', 'bart.base') +bart.eval() +bart.fill_mask(['The cat on the .'], topk=3, beam=10) +# [[('The cat was on the ground.', tensor(-0.6183)), ('The cat was on the floor.', tensor(-0.6798)), ('The cat sleeps on the couch.', tensor(-0.6830))]] +``` + +Note that by default we enforce the output length to match the input length. +This can be disabled by setting ``match_source_len=False``: +``` +bart.fill_mask(['The cat on the .'], topk=3, beam=10, match_source_len=False) +# [[('The cat was on the ground.', tensor(-0.6185)), ('The cat was asleep on the couch.', tensor(-0.6276)), ('The cat was on the floor.', tensor(-0.6800))]] +``` + +Example code to fill masks for a batch of sentences using GPU +``` +bart.cuda() +bart.fill_mask(['The cat on the .', 'The dog on the .'], topk=3, beam=10) +# [[('The cat was on the ground.', tensor(-0.6183)), ('The cat was on the floor.', tensor(-0.6798)), ('The cat sleeps on the couch.', tensor(-0.6830))], [('The dog was on the ground.', tensor(-0.6190)), ('The dog lay on the ground.', tensor(-0.6711)), +('The dog was asleep on the couch', tensor(-0.6796))]] +``` + +#### Evaluating the `bart.large.mnli` model: + +Example python code snippet to evaluate accuracy on the MNLI `dev_matched` set. +```python +label_map = {0: 'contradiction', 1: 'neutral', 2: 'entailment'} +ncorrect, nsamples = 0, 0 +bart.cuda() +bart.eval() +with open('glue_data/MNLI/dev_matched.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[8], tokens[9], tokens[-1] + tokens = bart.encode(sent1, sent2) + prediction = bart.predict('mnli', tokens).argmax().item() + prediction_label = label_map[prediction] + ncorrect += int(prediction_label == target) + nsamples += 1 + print('| Accuracy: ', float(ncorrect)/float(nsamples)) +# Expected output: 0.9010 +``` + +#### Evaluating the `bart.large.cnn` model: +- Follow instructions [here](https://github.com/abisee/cnn-dailymail) to download and process into data-files such that `test.source` and `test.target` has one line for each non-tokenized sample. +- For simpler preprocessing, you can also `wget https://cdn-datasets.huggingface.co/summarization/cnn_dm_v2.tgz`, although there is no guarantee of identical scores +- `huggingface/transformers` has a simpler interface that supports [single-gpu](https://github.com/huggingface/transformers/blob/master/examples/legacy/seq2seq/run_eval.py) and [multi-gpu](https://github.com/huggingface/transformers/blob/master/examples/legacy/seq2seq/run_distributed_eval.py) beam search. + In `huggingface/transformers`, the BART models' paths are `facebook/bart-large-cnn` and `facebook/bart-large-xsum`. + +In `fairseq`, summaries can be generated using: + +```bash +cp data-bin/cnn_dm/dict.source.txt checkpoints/ +python examples/bart/summarize.py \ + --model-dir pytorch/fairseq \ + --model-file bart.large.cnn \ + --src cnn_dm/test.source \ + --out cnn_dm/test.hypo +``` + +For calculating rouge, install `files2rouge` from [here](https://github.com/pltrdy/files2rouge). + +```bash +export CLASSPATH=/path/to/stanford-corenlp-full-2016-10-31/stanford-corenlp-3.7.0.jar + +# Tokenize hypothesis and target files. +cat test.hypo | java edu.stanford.nlp.process.PTBTokenizer -ioFileList -preserveLines > test.hypo.tokenized +cat test.target | java edu.stanford.nlp.process.PTBTokenizer -ioFileList -preserveLines > test.hypo.target +files2rouge test.hypo.tokenized test.hypo.target +# Expected output: (ROUGE-2 Average_F: 0.21238) +``` + + +## Finetuning + +- [Finetuning on GLUE](README.glue.md) +- [Finetuning on CNN-DM](README.summarization.md) + +## Citation + +```bibtex +@article{lewis2019bart, + title = {BART: Denoising Sequence-to-Sequence Pre-training for Natural +Language Generation, Translation, and Comprehension}, + author = {Mike Lewis and Yinhan Liu and Naman Goyal and Marjan Ghazvininejad and + Abdelrahman Mohamed and Omer Levy and Veselin Stoyanov + and Luke Zettlemoyer }, + journal={arXiv preprint arXiv:1910.13461}, + year = {2019}, +} +``` diff --git a/fairseq/examples/bart/README.summarization.md b/fairseq/examples/bart/README.summarization.md new file mode 100644 index 0000000000000000000000000000000000000000..8727584f2b2bdd880c6cd3abbf39b75dfbf4a67c --- /dev/null +++ b/fairseq/examples/bart/README.summarization.md @@ -0,0 +1,102 @@ +# Fine-tuning BART on CNN-Dailymail summarization task + +### 1) Download the CNN and Daily Mail data and preprocess it into data files with non-tokenized cased samples. + +Follow the instructions [here](https://github.com/abisee/cnn-dailymail) to download the original CNN and Daily Mail datasets. To preprocess the data, refer to the pointers in [this issue](https://github.com/pytorch/fairseq/issues/1391) or check out the code [here](https://github.com/artmatsak/cnn-dailymail). + +Follow the instructions [here](https://github.com/EdinburghNLP/XSum) to download the original Extreme Summarization datasets, or check out the code [here](https://github.com/EdinburghNLP/XSum/tree/master/XSum-Dataset), Please keep the raw dataset and make sure no tokenization nor BPE on the dataset. + +### 2) BPE preprocess: + +```bash +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt' + +TASK=cnn_dm +for SPLIT in train val +do + for LANG in source target + do + python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json encoder.json \ + --vocab-bpe vocab.bpe \ + --inputs "$TASK/$SPLIT.$LANG" \ + --outputs "$TASK/$SPLIT.bpe.$LANG" \ + --workers 60 \ + --keep-empty; + done +done +``` + +### 3) Binarize dataset: +```bash +fairseq-preprocess \ + --source-lang "source" \ + --target-lang "target" \ + --trainpref "${TASK}/train.bpe" \ + --validpref "${TASK}/val.bpe" \ + --destdir "${TASK}-bin/" \ + --workers 60 \ + --srcdict dict.txt \ + --tgtdict dict.txt; +``` + +### 4) Fine-tuning on CNN-DM summarization task: +Example fine-tuning CNN-DM +```bash +TOTAL_NUM_UPDATES=20000 +WARMUP_UPDATES=500 +LR=3e-05 +MAX_TOKENS=2048 +UPDATE_FREQ=4 +BART_PATH=/path/to/bart/model.pt + +CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 fairseq-train cnn_dm-bin \ + --restore-file $BART_PATH \ + --max-tokens $MAX_TOKENS \ + --task translation \ + --source-lang source --target-lang target \ + --truncate-source \ + --layernorm-embedding \ + --share-all-embeddings \ + --share-decoder-input-output-embed \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --arch bart_large \ + --criterion label_smoothed_cross_entropy \ + --label-smoothing 0.1 \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.01 --optimizer adam --adam-betas "(0.9, 0.999)" --adam-eps 1e-08 \ + --clip-norm 0.1 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --update-freq $UPDATE_FREQ \ + --skip-invalid-size-inputs-valid-test \ + --find-unused-parameters; +``` +Above is expected to run on `1` node with `8 32gb-V100`. +Expected training time is about `5 hours`. Training time can be reduced with distributed training on `4` nodes and `--update-freq 1`. + +Use TOTAL_NUM_UPDATES=15000 UPDATE_FREQ=2 for Xsum task + +### Inference for CNN-DM test data using above trained checkpoint. +After training the model as mentioned in previous step, you can perform inference with checkpoints in `checkpoints/` directory using `eval_cnn.py`, for example + +```bash +cp data-bin/cnn_dm/dict.source.txt checkpoints/ +python examples/bart/summarize.py \ + --model-dir checkpoints \ + --model-file checkpoint_best.pt \ + --src cnn_dm/test.source \ + --out cnn_dm/test.hypo +``` +For XSUM, which uses beam=6, lenpen=1.0, max_len_b=60, min_len=10: +```bash +cp data-bin/cnn_dm/dict.source.txt checkpoints/ +python examples/bart/summarize.py \ + --model-dir checkpoints \ + --model-file checkpoint_best.pt \ + --src cnn_dm/test.source \ + --out cnn_dm/test.hypo \ + --xsum-kwargs +``` diff --git a/fairseq/examples/bart/summarize.py b/fairseq/examples/bart/summarize.py new file mode 100644 index 0000000000000000000000000000000000000000..04435f80e39c2d9d894696dae7cba5b381e13da9 --- /dev/null +++ b/fairseq/examples/bart/summarize.py @@ -0,0 +1,100 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq.models.bart import BARTModel +import argparse + +XSUM_KWARGS = dict(beam=6, lenpen=1.0, max_len_b=60, min_len=10, no_repeat_ngram_size=3) +CNN_KWARGS = dict(beam=4, lenpen=2.0, max_len_b=140, min_len=55, no_repeat_ngram_size=3) + + +@torch.no_grad() +def generate(bart, infile, outfile="bart_hypo.txt", bsz=32, n_obs=None, **eval_kwargs): + count = 1 + + # if n_obs is not None: bsz = min(bsz, n_obs) + + with open(infile) as source, open(outfile, "w") as fout: + sline = source.readline().strip() + slines = [sline] + for sline in source: + if n_obs is not None and count > n_obs: + break + if count % bsz == 0: + hypotheses_batch = bart.sample(slines, **eval_kwargs) + for hypothesis in hypotheses_batch: + fout.write(hypothesis + "\n") + fout.flush() + slines = [] + + slines.append(sline.strip()) + count += 1 + + if slines != []: + hypotheses_batch = bart.sample(slines, **eval_kwargs) + for hypothesis in hypotheses_batch: + fout.write(hypothesis + "\n") + fout.flush() + + +def main(): + """ + Usage:: + + python examples/bart/summarize.py \ + --model-dir $HOME/bart.large.cnn \ + --model-file model.pt \ + --src $HOME/data-bin/cnn_dm/test.source + """ + parser = argparse.ArgumentParser() + parser.add_argument( + "--model-dir", + required=True, + type=str, + default="bart.large.cnn/", + help="path containing model file and src_dict.txt", + ) + parser.add_argument( + "--model-file", + default="checkpoint_best.pt", + help="where in model_dir are weights saved", + ) + parser.add_argument( + "--src", default="test.source", help="text to summarize", type=str + ) + parser.add_argument( + "--out", default="test.hypo", help="where to save summaries", type=str + ) + parser.add_argument("--bsz", default=32, help="where to save summaries", type=int) + parser.add_argument( + "--n", default=None, help="how many examples to summarize", type=int + ) + parser.add_argument( + "--xsum-kwargs", + action="store_true", + default=False, + help="if true use XSUM_KWARGS else CNN_KWARGS", + ) + args = parser.parse_args() + eval_kwargs = XSUM_KWARGS if args.xsum_kwargs else CNN_KWARGS + if args.model_dir == "pytorch/fairseq": + bart = torch.hub.load("pytorch/fairseq", args.model_file) + else: + bart = BARTModel.from_pretrained( + args.model_dir, + checkpoint_file=args.model_file, + data_name_or_path=args.model_dir, + ) + bart = bart.eval() + if torch.cuda.is_available(): + bart = bart.cuda().half() + generate( + bart, args.src, bsz=args.bsz, n_obs=args.n, outfile=args.out, **eval_kwargs + ) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/byte_level_bpe/README.md b/fairseq/examples/byte_level_bpe/README.md new file mode 100644 index 0000000000000000000000000000000000000000..657092660eae42d20f67647417623b8b8cb7b66c --- /dev/null +++ b/fairseq/examples/byte_level_bpe/README.md @@ -0,0 +1,88 @@ +# Neural Machine Translation with Byte-Level Subwords + +https://arxiv.org/abs/1909.03341 + +We provide an implementation of byte-level byte-pair encoding (BBPE), taking IWSLT 2017 Fr-En translation as +example. + +## Data +Get data and generate fairseq binary dataset: +```bash +bash ./get_data.sh +``` + +## Model Training +Train Transformer model with Bi-GRU embedding contextualization (implemented in `gru_transformer.py`): +```bash +# VOCAB=bytes +# VOCAB=chars +VOCAB=bbpe2048 +# VOCAB=bpe2048 +# VOCAB=bbpe4096 +# VOCAB=bpe4096 +# VOCAB=bpe16384 +``` +```bash +fairseq-train "data/bin_${VOCAB}" --task translation --user-dir examples/byte_level_bpe/gru_transformer \ + --arch gru_transformer --encoder-layers 2 --decoder-layers 2 --dropout 0.3 --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9, 0.98)' \ + --lr 5e-4 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --log-format 'simple' --log-interval 100 --save-dir "checkpoints/${VOCAB}" \ + --batch-size 100 --max-update 100000 --update-freq 2 +``` + +## Generation +`fairseq-generate` requires bytes (BBPE) decoder to convert byte-level representation back to characters: +```bash +# BPE=--bpe bytes +# BPE=--bpe characters +BPE=--bpe byte_bpe --sentencepiece-model-path data/spm_bbpe2048.model +# BPE=--bpe sentencepiece --sentencepiece-model data/spm_bpe2048.model +# BPE=--bpe byte_bpe --sentencepiece-model-path data/spm_bbpe4096.model +# BPE=--bpe sentencepiece --sentencepiece-model data/spm_bpe4096.model +# BPE=--bpe sentencepiece --sentencepiece-model data/spm_bpe16384.model +``` + +```bash +fairseq-generate "data/bin_${VOCAB}" --task translation --user-dir examples/byte_level_bpe/gru_transformer \ + --source-lang fr --gen-subset test --sacrebleu --path "checkpoints/${VOCAB}/checkpoint_last.pt" \ + --tokenizer moses --moses-target-lang en ${BPE} +``` +When using `fairseq-interactive`, bytes (BBPE) encoder/decoder is required to tokenize input data and detokenize model predictions: +```bash +fairseq-interactive "data/bin_${VOCAB}" --task translation --user-dir examples/byte_level_bpe/gru_transformer \ + --path "checkpoints/${VOCAB}/checkpoint_last.pt" --input data/test.fr --tokenizer moses --moses-source-lang fr \ + --moses-target-lang en ${BPE} --buffer-size 1000 --max-tokens 10000 +``` + +## Results +| Vocabulary | Model | BLEU | +|:-------------:|:-------------:|:-------------:| +| Joint BPE 16k ([Kudo, 2018](https://arxiv.org/abs/1804.10959)) | 512d LSTM 2+2 | 33.81 | +| Joint BPE 16k | Transformer base 2+2 (w/ GRU) | 36.64 (36.72) | +| Joint BPE 4k | Transformer base 2+2 (w/ GRU) | 35.49 (36.10) | +| Joint BBPE 4k | Transformer base 2+2 (w/ GRU) | 35.61 (35.82) | +| Joint BPE 2k | Transformer base 2+2 (w/ GRU) | 34.87 (36.13) | +| Joint BBPE 2k | Transformer base 2+2 (w/ GRU) | 34.98 (35.43) | +| Characters | Transformer base 2+2 (w/ GRU) | 31.78 (33.30) | +| Bytes | Transformer base 2+2 (w/ GRU) | 31.57 (33.62) | + + +## Citation +``` +@misc{wang2019neural, + title={Neural Machine Translation with Byte-Level Subwords}, + author={Changhan Wang and Kyunghyun Cho and Jiatao Gu}, + year={2019}, + eprint={1909.03341}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` + + +## Contact +Changhan Wang ([changhan@fb.com](mailto:changhan@fb.com)), +Kyunghyun Cho ([kyunghyuncho@fb.com](mailto:kyunghyuncho@fb.com)), +Jiatao Gu ([jgu@fb.com](mailto:jgu@fb.com)) diff --git a/fairseq/examples/byte_level_bpe/get_bitext.py b/fairseq/examples/byte_level_bpe/get_bitext.py new file mode 100644 index 0000000000000000000000000000000000000000..6ac1eeec1e6167ec6bafd76b37173ee6987cae7e --- /dev/null +++ b/fairseq/examples/byte_level_bpe/get_bitext.py @@ -0,0 +1,254 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import argparse +import os +import os.path as op +from collections import namedtuple +from multiprocessing import cpu_count +from typing import List, Optional + +import sentencepiece as sp +from fairseq.data.encoders.byte_bpe import ByteBPE +from fairseq.data.encoders.byte_utils import byte_encode +from fairseq.data.encoders.bytes import Bytes +from fairseq.data.encoders.characters import Characters +from fairseq.data.encoders.moses_tokenizer import MosesTokenizer +from fairseq.data.encoders.sentencepiece_bpe import SentencepieceBPE + + +SPLITS = ["train", "valid", "test"] + + +def _convert_xml(in_path: str, out_path: str): + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + ss = s.strip() + if not ss.startswith("", "").split('">') + assert len(ss) == 2 + f_o.write(ss[1].strip() + "\n") + + +def _convert_train(in_path: str, out_path: str): + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + ss = s.strip() + if ss.startswith("<"): + continue + f_o.write(ss.strip() + "\n") + + +def _get_bytes(in_path: str, out_path: str): + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + f_o.write(Bytes.encode(s.strip()) + "\n") + + +def _get_chars(in_path: str, out_path: str): + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + f_o.write(Characters.encode(s.strip()) + "\n") + + +def pretokenize(in_path: str, out_path: str, src: str, tgt: str): + Args = namedtuple( + "Args", + [ + "moses_source_lang", + "moses_target_lang", + "moses_no_dash_splits", + "moses_no_escape", + ], + ) + args = Args( + moses_source_lang=src, + moses_target_lang=tgt, + moses_no_dash_splits=False, + moses_no_escape=False, + ) + pretokenizer = MosesTokenizer(args) + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + f_o.write(pretokenizer.encode(s.strip()) + "\n") + + +def _convert_to_bchar(in_path_prefix: str, src: str, tgt: str, out_path: str): + with open(out_path, "w") as f_o: + for lang in [src, tgt]: + with open(f"{in_path_prefix}.{lang}") as f: + for s in f: + f_o.write(byte_encode(s.strip()) + "\n") + + +def _get_bpe(in_path: str, model_prefix: str, vocab_size: int): + arguments = [ + f"--input={in_path}", + f"--model_prefix={model_prefix}", + f"--model_type=bpe", + f"--vocab_size={vocab_size}", + "--character_coverage=1.0", + "--normalization_rule_name=identity", + f"--num_threads={cpu_count()}", + ] + sp.SentencePieceTrainer.Train(" ".join(arguments)) + + +def _apply_bbpe(model_path: str, in_path: str, out_path: str): + Args = namedtuple("Args", ["sentencepiece_model_path"]) + args = Args(sentencepiece_model_path=model_path) + tokenizer = ByteBPE(args) + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + f_o.write(tokenizer.encode(s.strip()) + "\n") + + +def _apply_bpe(model_path: str, in_path: str, out_path: str): + Args = namedtuple("Args", ["sentencepiece_model"]) + args = Args(sentencepiece_model=model_path) + tokenizer = SentencepieceBPE(args) + with open(in_path) as f, open(out_path, "w") as f_o: + for s in f: + f_o.write(tokenizer.encode(s.strip()) + "\n") + + +def _concat_files(in_paths: List[str], out_path: str): + with open(out_path, "w") as f_o: + for p in in_paths: + with open(p) as f: + for r in f: + f_o.write(r) + + +def preprocess_iwslt17( + root: str, + src: str, + tgt: str, + bpe_size: Optional[int], + need_chars: bool, + bbpe_size: Optional[int], + need_bytes: bool, +): + # extract bitext + in_root = op.join(root, f"{src}-{tgt}") + for lang in [src, tgt]: + _convert_train( + op.join(in_root, f"train.tags.{src}-{tgt}.{lang}"), + op.join(root, f"train.{lang}"), + ) + _convert_xml( + op.join(in_root, f"IWSLT17.TED.dev2010.{src}-{tgt}.{lang}.xml"), + op.join(root, f"valid.{lang}"), + ) + _convert_xml( + op.join(in_root, f"IWSLT17.TED.tst2015.{src}-{tgt}.{lang}.xml"), + op.join(root, f"test.{lang}"), + ) + # pre-tokenize + for lang in [src, tgt]: + for split in SPLITS: + pretokenize( + op.join(root, f"{split}.{lang}"), + op.join(root, f"{split}.moses.{lang}"), + src, + tgt, + ) + # tokenize with BPE vocabulary + if bpe_size is not None: + # learn vocabulary + concated_train_path = op.join(root, "train.all") + _concat_files( + [op.join(root, "train.moses.fr"), op.join(root, "train.moses.en")], + concated_train_path, + ) + bpe_model_prefix = op.join(root, f"spm_bpe{bpe_size}") + _get_bpe(concated_train_path, bpe_model_prefix, bpe_size) + os.remove(concated_train_path) + # apply + for lang in [src, tgt]: + for split in SPLITS: + _apply_bpe( + bpe_model_prefix + ".model", + op.join(root, f"{split}.moses.{lang}"), + op.join(root, f"{split}.moses.bpe{bpe_size}.{lang}"), + ) + # tokenize with bytes vocabulary + if need_bytes: + for lang in [src, tgt]: + for split in SPLITS: + _get_bytes( + op.join(root, f"{split}.moses.{lang}"), + op.join(root, f"{split}.moses.bytes.{lang}"), + ) + # tokenize with characters vocabulary + if need_chars: + for lang in [src, tgt]: + for split in SPLITS: + _get_chars( + op.join(root, f"{split}.moses.{lang}"), + op.join(root, f"{split}.moses.chars.{lang}"), + ) + # tokenize with byte-level BPE vocabulary + if bbpe_size is not None: + # learn vocabulary + bchar_path = op.join(root, "train.bchar") + _convert_to_bchar(op.join(root, "train.moses"), src, tgt, bchar_path) + bbpe_model_prefix = op.join(root, f"spm_bbpe{bbpe_size}") + _get_bpe(bchar_path, bbpe_model_prefix, bbpe_size) + os.remove(bchar_path) + # apply + for lang in [src, tgt]: + for split in SPLITS: + _apply_bbpe( + bbpe_model_prefix + ".model", + op.join(root, f"{split}.moses.{lang}"), + op.join(root, f"{split}.moses.bbpe{bbpe_size}.{lang}"), + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--root", type=str, default="data") + parser.add_argument( + "--bpe-vocab", + default=None, + type=int, + help="Generate tokenized bitext with BPE of size K." + "Default to None (disabled).", + ) + parser.add_argument( + "--bbpe-vocab", + default=None, + type=int, + help="Generate tokenized bitext with BBPE of size K." + "Default to None (disabled).", + ) + parser.add_argument( + "--byte-vocab", + action="store_true", + help="Generate tokenized bitext with bytes vocabulary", + ) + parser.add_argument( + "--char-vocab", + action="store_true", + help="Generate tokenized bitext with chars vocabulary", + ) + args = parser.parse_args() + + preprocess_iwslt17( + args.root, + "fr", + "en", + args.bpe_vocab, + args.char_vocab, + args.bbpe_vocab, + args.byte_vocab, + ) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/byte_level_bpe/get_data.sh b/fairseq/examples/byte_level_bpe/get_data.sh new file mode 100644 index 0000000000000000000000000000000000000000..c3d55d4925a6e6e23d12d293f093c1ae14acf76e --- /dev/null +++ b/fairseq/examples/byte_level_bpe/get_data.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +PY_BIN_ROOT= + +# PyPI dependency +${PY_BIN_ROOT}pip install sentencepiece sacremoses + +# Get data +if [ ! -d "data" ]; then + mkdir data +fi + +if [ ! -f "data/fr-en.tgz" ]; then + wget https://wit3.fbk.eu/archive/2017-01-trnted/texts/fr/en/fr-en.tgz -P data + tar xvf data/fr-en.tgz -C data +fi +${PY_BIN_ROOT}python get_bitext.py --bpe-vocab 16384 --byte-vocab --char-vocab +for VOCAB_SIZE in 2048 4096; do + ${PY_BIN_ROOT}python get_bitext.py --bpe-vocab ${VOCAB_SIZE} --bbpe-vocab ${VOCAB_SIZE} +done +rm -r data/fr-en data/fr-en.tgz + +# Generate binary dataset +${PY_BIN_ROOT}/fairseq-preprocess --source-lang fr --target-lang en --destdir data/bin_bpe16384 --joined-dictionary \ + --workers "$(nproc)" --trainpref data/train.moses.bpe16384 --validpref data/valid.moses.bpe16384 \ + --testpref data/test.moses.bpe16384 + +${PY_BIN_ROOT}/fairseq-preprocess --source-lang fr --target-lang en --destdir data/bin_bytes --joined-dictionary \ + --workers "$(nproc)" --trainpref data/train.moses.bytes --validpref data/valid.moses.bytes \ + --testpref data/test.moses.bytes + +${PY_BIN_ROOT}/fairseq-preprocess --source-lang fr --target-lang en --destdir data/bin_chars --joined-dictionary \ + --workers "$(nproc)" --trainpref data/train.moses.chars --validpref data/valid.moses.chars \ + --testpref data/test.moses.chars + +for VOCAB_SIZE in 2048 4096; do + for TYPE in bbpe bpe; do + ${PY_BIN_ROOT}/fairseq-preprocess --source-lang fr --target-lang en --destdir "data/bin_${TYPE}${VOCAB_SIZE}" \ + --joined-dictionary --workers "$(nproc)" --trainpref "data/train.moses.${TYPE}${VOCAB_SIZE}" \ + --validpref "data/valid.moses.${TYPE}${VOCAB_SIZE}" --testpref "data/test.moses.${TYPE}${VOCAB_SIZE}" + done +done diff --git a/fairseq/examples/byte_level_bpe/gru_transformer.py b/fairseq/examples/byte_level_bpe/gru_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..d4efa93a4d75da71c78e786d7f62101ef3266af4 --- /dev/null +++ b/fairseq/examples/byte_level_bpe/gru_transformer.py @@ -0,0 +1,107 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +import torch.nn.functional as F +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer import TransformerEncoder, TransformerModel + + +@register_model("gru_transformer") +class GRUTransformerModel(TransformerModel): + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return GRUTransformerEncoder(args, src_dict, embed_tokens) + + +class GRUTransformerEncoder(TransformerEncoder): + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens) + self.emb_ctx = nn.GRU( + input_size=embed_tokens.embedding_dim, + hidden_size=embed_tokens.embedding_dim // 2, + num_layers=1, + bidirectional=True, + ) + + def forward_embedding(self, src_tokens): + # embed tokens and positions + x = embed = self.embed_scale * self.embed_tokens(src_tokens) + if self.embed_positions is not None: + x = embed + self.embed_positions(src_tokens) + + # contextualize embeddings + x = x.transpose(0, 1) + x = self.dropout_module(x) + x, _ = self.emb_ctx.forward(x) + x = x.transpose(0, 1) + + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + x = self.dropout_module(x) + return x, embed + + +@register_model_architecture("gru_transformer", "gru_transformer") +def gru_transformer_base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.no_cross_attention = getattr(args, "no_cross_attention", False) + args.cross_self_attention = getattr(args, "cross_self_attention", False) + args.layer_wise_attention = getattr(args, "layer_wise_attention", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + + +@register_model_architecture("gru_transformer", "gru_transformer_big") +def gru_transformer_big(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.3) + gru_transformer_base_architecture(args) diff --git a/fairseq/examples/camembert/README.md b/fairseq/examples/camembert/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5ef4fe3f151bb468712f3be935ea5bb1b1360bf7 --- /dev/null +++ b/fairseq/examples/camembert/README.md @@ -0,0 +1,75 @@ +# CamemBERT: a Tasty French Language Model + +## Introduction + +[CamemBERT](https://arxiv.org/abs/1911.03894) is a pretrained language model trained on 138GB of French text based on RoBERTa. + +Also available in [github.com/huggingface/transformers](https://github.com/huggingface/transformers/). + +## Pre-trained models + +| Model | #params | Download | Arch. | Training data | +|--------------------------------|---------|--------------------------------------------------------------------------------------------------------------------------|-------|-----------------------------------| +| `camembert` / `camembert-base` | 110M | [camembert-base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz) | Base | OSCAR (138 GB of text) | +| `camembert-large` | 335M | [camembert-large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-large.tar.gz) | Large | CCNet (135 GB of text) | +| `camembert-base-ccnet` | 110M | [camembert-base-ccnet.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet.tar.gz) | Base | CCNet (135 GB of text) | +| `camembert-base-wikipedia-4gb` | 110M | [camembert-base-wikipedia-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-wikipedia-4gb.tar.gz) | Base | Wikipedia (4 GB of text) | +| `camembert-base-oscar-4gb` | 110M | [camembert-base-oscar-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-oscar-4gb.tar.gz) | Base | Subsample of OSCAR (4 GB of text) | +| `camembert-base-ccnet-4gb` | 110M | [camembert-base-ccnet-4gb.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet-4gb.tar.gz) | Base | Subsample of CCNet (4 GB of text) | + +## Example usage + +### fairseq +##### Load CamemBERT from torch.hub (PyTorch >= 1.1): +```python +import torch +camembert = torch.hub.load('pytorch/fairseq', 'camembert') +camembert.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Load CamemBERT (for PyTorch 1.0 or custom models): +```python +# Download camembert model +wget https://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz +tar -xzvf camembert.tar.gz + +# Load the model in fairseq +from fairseq.models.roberta import CamembertModel +camembert = CamembertModel.from_pretrained('/path/to/camembert') +camembert.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Filling masks: +```python +masked_line = 'Le camembert est :)' +camembert.fill_mask(masked_line, topk=3) +# [('Le camembert est délicieux :)', 0.4909118115901947, ' délicieux'), +# ('Le camembert est excellent :)', 0.10556942224502563, ' excellent'), +# ('Le camembert est succulent :)', 0.03453322499990463, ' succulent')] +``` + +##### Extract features from Camembert: +```python +# Extract the last layer's features +line = "J'aime le camembert !" +tokens = camembert.encode(line) +last_layer_features = camembert.extract_features(tokens) +assert last_layer_features.size() == torch.Size([1, 10, 768]) + +# Extract all layer's features (layer 0 is the embedding layer) +all_layers = camembert.extract_features(tokens, return_all_hiddens=True) +assert len(all_layers) == 13 +assert torch.all(all_layers[-1] == last_layer_features) +``` + +## Citation +If you use our work, please cite: + +```bibtex +@inproceedings{martin2020camembert, + title={CamemBERT: a Tasty French Language Model}, + author={Martin, Louis and Muller, Benjamin and Su{\'a}rez, Pedro Javier Ortiz and Dupont, Yoann and Romary, Laurent and de la Clergerie, {\'E}ric Villemonte and Seddah, Djam{\'e} and Sagot, Beno{\^\i}t}, + booktitle={Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics}, + year={2020} +} +``` diff --git a/fairseq/examples/constrained_decoding/README.md b/fairseq/examples/constrained_decoding/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e04b8b6a018214c8233fa87fd91d46a6dd1519d4 --- /dev/null +++ b/fairseq/examples/constrained_decoding/README.md @@ -0,0 +1,123 @@ +# (Vectorized) Lexically constrained decoding with dynamic beam allocation + +This page provides instructions for how to use lexically constrained decoding in Fairseq. +Fairseq implements the code described in the following papers: + +* [Fast Lexically Constrained Decoding With Dynamic Beam Allocation](https://www.aclweb.org/anthology/N18-1119/) (Post & Vilar, 2018) +* [Improved Lexically Constrained Decoding for Translation and Monolingual Rewriting](https://www.aclweb.org/anthology/N19-1090/) (Hu et al., 2019) + +## Quick start + +Constrained search is enabled by adding the command-line argument `--constraints` to `fairseq-interactive`. +Constraints are appended to each line of input, separated by tabs. Each constraint (one or more tokens) +is a separate field. + +The following command, using [Fairseq's WMT19 German--English model](https://github.com/pytorch/fairseq/blob/main/examples/wmt19/README.md), +translates the sentence *Die maschinelle Übersetzung ist schwer zu kontrollieren.* with the constraints +"hard" and "to influence". + + echo -e "Die maschinelle Übersetzung ist schwer zu kontrollieren.\thard\ttoinfluence" \ + | normalize.py | tok.py \ + | fairseq-interactive /path/to/model \ + --path /path/to/model/model1.pt \ + --bpe fastbpe \ + --bpe-codes /path/to/model/bpecodes \ + --constraints \ + -s de -t en \ + --beam 10 + +(tok.py and normalize.py can be found in the same directory as this README; they are just shortcuts around Fairseq's WMT19 preprocessing). +This will generate the following output: + + [snip] + S-0 Die masch@@ in@@ elle Über@@ setzung ist schwer zu kontrollieren . + W-0 1.844 seconds + C-0 hard + C-0 influence + H-0 -1.5333266258239746 Mach@@ ine trans@@ lation is hard to influence . + D-0 -1.5333266258239746 Machine translation is hard to influence . + P-0 -0.5434 -0.1423 -0.1930 -0.1415 -0.2346 -1.8031 -0.1701 -11.7727 -0.1815 -0.1511 + +By default, constraints are generated in the order supplied, with any number (zero or more) of tokens generated +between constraints. If you wish for the decoder to order the constraints, then use `--constraints unordered`. +Note that you may want to use a larger beam. + +## Implementation details + +The heart of the implementation is in `fairseq/search.py`, which adds a `LexicallyConstrainedBeamSearch` instance. +This instance of beam search tracks the progress of each hypothesis in the beam through the set of constraints +provided for each input sentence. It does this using one of two classes, both found in `fairseq/token_generation_contstraints.py`: + +* OrderedConstraintState: assumes the `C` input constraints will be generated in the provided order +* UnorderedConstraintState: tries to apply `C` (phrasal) constraints in all `C!` orders + +## Differences from Sockeye + +There are a number of [differences from Sockeye's implementation](https://awslabs.github.io/sockeye/inference.html#lexical-constraints). + +* Generating constraints in the order supplied (the default option here) is not available in Sockeye. +* Due to an improved beam allocation method, there is no need to prune the beam. +* Again due to better allocation, beam sizes as low as 10 or even 5 are often sufficient. +* [The vector extensions described in Hu et al.](https://github.com/edwardjhu/sockeye/tree/trie_constraints) (NAACL 2019) were never merged + into the main Sockeye branch. + +## Citation + +The paper first describing lexical constraints for seq2seq decoding is: + +```bibtex +@inproceedings{hokamp-liu-2017-lexically, + title = "Lexically Constrained Decoding for Sequence Generation Using Grid Beam Search", + author = "Hokamp, Chris and + Liu, Qun", + booktitle = "Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)", + month = jul, + year = "2017", + address = "Vancouver, Canada", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/P17-1141", + doi = "10.18653/v1/P17-1141", + pages = "1535--1546", +} +``` + +The fairseq implementation uses the extensions described in + +```bibtex +@inproceedings{post-vilar-2018-fast, + title = "Fast Lexically Constrained Decoding with Dynamic Beam Allocation for Neural Machine Translation", + author = "Post, Matt and + Vilar, David", + booktitle = "Proceedings of the 2018 Conference of the North {A}merican Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers)", + month = jun, + year = "2018", + address = "New Orleans, Louisiana", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/N18-1119", + doi = "10.18653/v1/N18-1119", + pages = "1314--1324", +} +``` + +and + +```bibtex +@inproceedings{hu-etal-2019-improved, + title = "Improved Lexically Constrained Decoding for Translation and Monolingual Rewriting", + author = "Hu, J. Edward and + Khayrallah, Huda and + Culkin, Ryan and + Xia, Patrick and + Chen, Tongfei and + Post, Matt and + Van Durme, Benjamin", + booktitle = "Proceedings of the 2019 Conference of the North {A}merican Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers)", + month = jun, + year = "2019", + address = "Minneapolis, Minnesota", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/N19-1090", + doi = "10.18653/v1/N19-1090", + pages = "839--850", +} +``` diff --git a/fairseq/examples/constrained_decoding/normalize.py b/fairseq/examples/constrained_decoding/normalize.py new file mode 100755 index 0000000000000000000000000000000000000000..4ae2b5111ba025acb9e1613865c92fdc339a58d5 --- /dev/null +++ b/fairseq/examples/constrained_decoding/normalize.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +# +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + +from sacremoses.normalize import MosesPunctNormalizer + + +def main(args): + normalizer = MosesPunctNormalizer(lang=args.lang, penn=args.penn) + for line in sys.stdin: + print(normalizer.normalize(line.rstrip()), flush=True) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--lang", "-l", default="en") + parser.add_argument("--penn", "-p", action="store_true") + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/constrained_decoding/tok.py b/fairseq/examples/constrained_decoding/tok.py new file mode 100755 index 0000000000000000000000000000000000000000..b1f888a8c0d1b8ec7174859476cc3222456e0d2c --- /dev/null +++ b/fairseq/examples/constrained_decoding/tok.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +# +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + +import sacremoses + + +def main(args): + """Tokenizes, preserving tabs""" + mt = sacremoses.MosesTokenizer(lang=args.lang) + + def tok(s): + return mt.tokenize(s, return_str=True) + + for line in sys.stdin: + parts = list(map(tok, line.split("\t"))) + print(*parts, sep="\t", flush=True) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--lang", "-l", default="en") + parser.add_argument("--penn", "-p", action="store_true") + parser.add_argument("--fields", "-f", help="fields to tokenize") + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/conv_seq2seq/README.md b/fairseq/examples/conv_seq2seq/README.md new file mode 100644 index 0000000000000000000000000000000000000000..95fe7e7909a77ee0e50fe31d4b8be38daa8f3be7 --- /dev/null +++ b/fairseq/examples/conv_seq2seq/README.md @@ -0,0 +1,25 @@ +# Convolutional Sequence to Sequence Learning (Gehring et al., 2017) + +## Pre-trained models + +Description | Dataset | Model | Test set(s) +---|---|---|--- +Convolutional
([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2) | newstest2014:
[download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.newstest2014.tar.bz2)
newstest2012/2013:
[download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.ntst1213.tar.bz2) +Convolutional
([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-German](http://statmt.org/wmt14/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-de.fconv-py.tar.bz2) | newstest2014:
[download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-de.newstest2014.tar.bz2) +Convolutional
([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT17 English-German](http://statmt.org/wmt17/translation-task.html#Download) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt17.v2.en-de.fconv-py.tar.bz2) | newstest2014:
[download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt17.v2.en-de.newstest2014.tar.bz2) + +## Example usage + +See the [translation README](../translation/README.md) for instructions on reproducing results for WMT'14 En-De and +WMT'14 En-Fr using the `fconv_wmt_en_de` and `fconv_wmt_en_fr` model architectures. + +## Citation + +```bibtex +@inproceedings{gehring2017convs2s, + title = {Convolutional Sequence to Sequence Learning}, + author = {Gehring, Jonas, and Auli, Michael and Grangier, David and Yarats, Denis and Dauphin, Yann N}, + booktitle = {Proc. of ICML}, + year = 2017, +} +``` diff --git a/fairseq/examples/criss/README.md b/fairseq/examples/criss/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4689ed7c10497a5100b28fe6d6801a7c089da569 --- /dev/null +++ b/fairseq/examples/criss/README.md @@ -0,0 +1,61 @@ +# Cross-lingual Retrieval for Iterative Self-Supervised Training + +https://arxiv.org/pdf/2006.09526.pdf + +## Introduction + +CRISS is a multilingual sequence-to-sequnce pretraining method where mining and training processes are applied iteratively, improving cross-lingual alignment and translation ability at the same time. + +## Requirements: + +* faiss: https://github.com/facebookresearch/faiss +* mosesdecoder: https://github.com/moses-smt/mosesdecoder +* flores: https://github.com/facebookresearch/flores +* LASER: https://github.com/facebookresearch/LASER + +## Unsupervised Machine Translation +##### 1. Download and decompress CRISS checkpoints +``` +cd examples/criss +wget https://dl.fbaipublicfiles.com/criss/criss_3rd_checkpoints.tar.gz +tar -xf criss_checkpoints.tar.gz +``` +##### 2. Download and preprocess Flores test dataset +Make sure to run all scripts from examples/criss directory +``` +bash download_and_preprocess_flores_test.sh +``` + +##### 3. Run Evaluation on Sinhala-English +``` +bash unsupervised_mt/eval.sh +``` + +## Sentence Retrieval +##### 1. Download and preprocess Tatoeba dataset +``` +bash download_and_preprocess_tatoeba.sh +``` + +##### 2. Run Sentence Retrieval on Tatoeba Kazakh-English +``` +bash sentence_retrieval/sentence_retrieval_tatoeba.sh +``` + +## Mining +##### 1. Install faiss +Follow instructions on https://github.com/facebookresearch/faiss/blob/master/INSTALL.md +##### 2. Mine pseudo-parallel data between Kazakh and English +``` +bash mining/mine_example.sh +``` + +## Citation +```bibtex +@article{tran2020cross, + title={Cross-lingual retrieval for iterative self-supervised training}, + author={Tran, Chau and Tang, Yuqing and Li, Xian and Gu, Jiatao}, + journal={arXiv preprint arXiv:2006.09526}, + year={2020} +} +``` diff --git a/fairseq/examples/criss/download_and_preprocess_flores_test.sh b/fairseq/examples/criss/download_and_preprocess_flores_test.sh new file mode 100644 index 0000000000000000000000000000000000000000..ed4b390fbdee3991efeb298050e12065d7fe605b --- /dev/null +++ b/fairseq/examples/criss/download_and_preprocess_flores_test.sh @@ -0,0 +1,64 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +SPM_ENCODE=flores/scripts/spm_encode.py +DATA=data_tmp +SPM_MODEL=criss_checkpoints/sentence.bpe.model +DICT=criss_checkpoints/dict.txt + +download_data() { + CORPORA=$1 + URL=$2 + + if [ -f $CORPORA ]; then + echo "$CORPORA already exists, skipping download" + else + echo "Downloading $URL" + wget $URL -O $CORPORA --no-check-certificate || rm -f $CORPORA + if [ -f $CORPORA ]; then + echo "$URL successfully downloaded." + else + echo "$URL not successfully downloaded." + rm -f $CORPORA + fi + fi +} + +if [[ -f flores ]]; then + echo "flores already cloned" +else + git clone https://github.com/facebookresearch/flores +fi + +mkdir -p $DATA +download_data $DATA/wikipedia_en_ne_si_test_sets.tgz "https://github.com/facebookresearch/flores/raw/master/data/wikipedia_en_ne_si_test_sets.tgz" +pushd $DATA +pwd +tar -vxf wikipedia_en_ne_si_test_sets.tgz +popd + + +for lang in ne_NP si_LK; do + datadir=$DATA/${lang}-en_XX-flores + rm -rf $datadir + mkdir -p $datadir + TEST_PREFIX=$DATA/wikipedia_en_ne_si_test_sets/wikipedia.test + python $SPM_ENCODE \ + --model ${SPM_MODEL} \ + --output_format=piece \ + --inputs ${TEST_PREFIX}.${lang:0:2}-en.${lang:0:2} ${TEST_PREFIX}.${lang:0:2}-en.en \ + --outputs $datadir/test.bpe.${lang}-en_XX.${lang} $datadir/test.bpe.${lang}-en_XX.en_XX + + # binarize data + fairseq-preprocess \ + --source-lang ${lang} --target-lang en_XX \ + --testpref $datadir/test.bpe.${lang}-en_XX \ + --destdir $datadir \ + --srcdict ${DICT} \ + --joined-dictionary \ + --workers 4 +done diff --git a/fairseq/examples/criss/download_and_preprocess_tatoeba.sh b/fairseq/examples/criss/download_and_preprocess_tatoeba.sh new file mode 100644 index 0000000000000000000000000000000000000000..7ed64f017d5e62695ba73745c840507b994abc0f --- /dev/null +++ b/fairseq/examples/criss/download_and_preprocess_tatoeba.sh @@ -0,0 +1,46 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +SPM_ENCODE=flores/scripts/spm_encode.py +DATA=data_tmp +SPM_MODEL=criss_checkpoints/sentence.bpe.model +DICT=criss_checkpoints/dict.txt + +if [[ -f flores ]]; then + echo "flores already cloned" +else + git clone https://github.com/facebookresearch/flores +fi +if [[ -f LASER ]]; then + echo "LASER already cloned" +else + git clone https://github.com/facebookresearch/LASER +fi +mkdir -p data_tmp +declare -A lang_tatoeba_map=( ["ar_AR"]="ara" ["de_DE"]="deu" ["es_XX"]="spa" ["et_EE"]="est" ["fi_FI"]="fin" ["fr_XX"]="fra" ["hi_IN"]="hin" ["it_IT"]="ita" ["ja_XX"]="jpn" ["ko_KR"]="kor" ["kk_KZ"]="kaz" ["nl_XX"]="nld" ["ru_RU"]="rus" ["tr_TR"]="tur" ["vi_VN"]="vie" ["zh_CN"]="cmn") +for lang in ar_AR de_DE es_XX et_EE fi_FI fr_XX hi_IN it_IT ja_XX kk_KZ ko_KR nl_XX ru_RU tr_TR vi_VN zh_CN; do + lang_tatoeba=${lang_tatoeba_map[$lang]} + echo $lang_tatoeba + datadir=$DATA/${lang}-en_XX-tatoeba + rm -rf $datadir + mkdir -p $datadir + TEST_PREFIX=LASER/data/tatoeba/v1/tatoeba + python $SPM_ENCODE \ + --model ${SPM_MODEL} \ + --output_format=piece \ + --inputs ${TEST_PREFIX}.${lang_tatoeba}-eng.${lang_tatoeba} ${TEST_PREFIX}.${lang_tatoeba}-eng.eng \ + --outputs $datadir/test.bpe.${lang}-en_XX.${lang} $datadir/test.bpe.${lang}-en_XX.en_XX + + # binarize data + fairseq-preprocess \ + --source-lang ${lang} --target-lang en_XX \ + --testpref $datadir/test.bpe.${lang}-en_XX \ + --destdir $datadir \ + --srcdict ${DICT} \ + --joined-dictionary \ + --workers 4 +done diff --git a/fairseq/examples/criss/mining/mine.py b/fairseq/examples/criss/mining/mine.py new file mode 100644 index 0000000000000000000000000000000000000000..c872da196fe0df776622365748ad7963fee1f0a0 --- /dev/null +++ b/fairseq/examples/criss/mining/mine.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import argparse +import glob +from subprocess import check_call + +try: + import faiss + + has_faiss = True +except ImportError: + has_faiss = False +import numpy as np + + +GB = 1024 * 1024 * 1024 + + +def call(cmd): + print(cmd) + check_call(cmd, shell=True) + + +def get_batches(directory, lang, prefix="all_avg_pool"): + print(f"Finding in {directory}/{prefix}.{lang}*") + files = glob.glob(f"{directory}/{prefix}.{lang}*") + emb_files = [] + txt_files = [] + for emb_fi in files: + emb_files.append(emb_fi) + txt_fi = emb_fi.replace(prefix, "sentences") + txt_files.append(txt_fi) + return emb_files, txt_files + + +def load_batch(emb_file, dim): + embeddings = np.fromfile(emb_file, dtype=np.float32) + num_rows = int(embeddings.shape[0] / dim) + embeddings = embeddings.reshape((num_rows, dim)) + faiss.normalize_L2(embeddings) + return embeddings + + +def knnGPU_sharded(x_batches_f, y_batches_f, dim, k, direction="x2y"): + if not has_faiss: + raise ImportError("Please install Faiss") + sims = [] + inds = [] + xfrom = 0 + xto = 0 + for x_batch_f in x_batches_f: + yfrom = 0 + yto = 0 + x_batch = load_batch(x_batch_f, dim) + xto = xfrom + x_batch.shape[0] + bsims, binds = [], [] + for y_batch_f in y_batches_f: + y_batch = load_batch(y_batch_f, dim) + neighbor_size = min(k, y_batch.shape[0]) + yto = yfrom + y_batch.shape[0] + print("{}-{} -> {}-{}".format(xfrom, xto, yfrom, yto)) + idx = faiss.IndexFlatIP(dim) + idx = faiss.index_cpu_to_all_gpus(idx) + idx.add(y_batch) + bsim, bind = idx.search(x_batch, neighbor_size) + + bsims.append(bsim) + binds.append(bind + yfrom) + yfrom += y_batch.shape[0] + del idx + del y_batch + bsims = np.concatenate(bsims, axis=1) + binds = np.concatenate(binds, axis=1) + aux = np.argsort(-bsims, axis=1) + sim_batch = np.zeros((x_batch.shape[0], k), dtype=np.float32) + ind_batch = np.zeros((x_batch.shape[0], k), dtype=np.int64) + for i in range(x_batch.shape[0]): + for j in range(k): + sim_batch[i, j] = bsims[i, aux[i, j]] + ind_batch[i, j] = binds[i, aux[i, j]] + sims.append(sim_batch) + inds.append(ind_batch) + xfrom += x_batch.shape[0] + del x_batch + sim = np.concatenate(sims, axis=0) + ind = np.concatenate(inds, axis=0) + return sim, ind + + +def score(sim, fwd_mean, bwd_mean, margin): + return margin(sim, (fwd_mean + bwd_mean) / 2) + + +def score_candidates( + sim_mat, candidate_inds, fwd_mean, bwd_mean, margin, verbose=False +): + print(" - scoring {:d} candidates".format(sim_mat.shape[0])) + scores = np.zeros(candidate_inds.shape) + for i in range(scores.shape[0]): + for j in range(scores.shape[1]): + k = int(candidate_inds[i, j]) + scores[i, j] = score(sim_mat[i, j], fwd_mean[i], bwd_mean[k], margin) + return scores + + +def load_text(files): + all_sentences = [] + for fi in files: + with open(fi) as sentence_fi: + for line in sentence_fi: + all_sentences.append(line.strip()) + print(f"Read {len(all_sentences)} sentences") + return all_sentences + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Mine bitext") + parser.add_argument("--src-lang", help="Source language") + parser.add_argument("--tgt-lang", help="Target language") + parser.add_argument( + "--dict-path", help="Path to dictionary file", default="dict.txt" + ) + parser.add_argument( + "--spm-path", help="Path to SPM model file", default="sentence.bpe.model" + ) + parser.add_argument("--dim", type=int, default=1024, help="Embedding dimension") + parser.add_argument("--mem", type=int, default=5, help="Memory in GB") + parser.add_argument("--src-dir", help="Source directory") + parser.add_argument("--tgt-dir", help="Target directory") + parser.add_argument("--output", help="Output path") + parser.add_argument( + "--neighborhood", type=int, default=4, help="Embedding dimension" + ) + parser.add_argument( + "--threshold", type=float, default=1.06, help="Threshold on mined bitext" + ) + parser.add_argument( + "--valid-size", + type=int, + default=2000, + help="Number of sentences used for validation set", + ) + parser.add_argument( + "--min-count", + type=int, + default=50000, + help="Min num sentences used for each language", + ) + args = parser.parse_args() + + x_batches_f, x_sents_f = get_batches(args.src_dir, args.src_lang) + y_batches_f, y_sents_f = get_batches(args.tgt_dir, args.tgt_lang) + margin = lambda a, b: a / b + y2x_sim, y2x_ind = knnGPU_sharded( + y_batches_f, x_batches_f, args.dim, args.neighborhood, direction="y2x" + ) + x2y_sim, x2y_ind = knnGPU_sharded( + x_batches_f, y_batches_f, args.dim, args.neighborhood, direction="x2y" + ) + + x2y_mean = x2y_sim.mean(axis=1) + y2x_mean = y2x_sim.mean(axis=1) + fwd_scores = score_candidates(x2y_sim, x2y_ind, x2y_mean, y2x_mean, margin) + bwd_scores = score_candidates(y2x_sim, y2x_ind, y2x_mean, x2y_mean, margin) + fwd_best = x2y_ind[np.arange(x2y_sim.shape[0]), fwd_scores.argmax(axis=1)] + bwd_best = y2x_ind[np.arange(y2x_sim.shape[0]), bwd_scores.argmax(axis=1)] + indices = np.stack( + ( + np.concatenate((np.arange(x2y_ind.shape[0]), bwd_best)), + np.concatenate((fwd_best, np.arange(y2x_ind.shape[0]))), + ), + axis=1, + ) + scores = np.concatenate((fwd_scores.max(axis=1), bwd_scores.max(axis=1))) + + x_sentences = load_text(x_sents_f) + y_sentences = load_text(y_sents_f) + + threshold = args.threshold + min_count = args.min_count + seen_src, seen_trg = set(), set() + directory = args.output + call(f"mkdir -p {directory}") + src_out = open( + f"{directory}/all.{args.src_lang}", + mode="w", + encoding="utf-8", + errors="surrogateescape", + ) + tgt_out = open( + f"{directory}/all.{args.tgt_lang}", + mode="w", + encoding="utf-8", + errors="surrogateescape", + ) + scores_out = open( + f"{directory}/all.scores", mode="w", encoding="utf-8", errors="surrogateescape" + ) + count = 0 + for i in np.argsort(-scores): + src_ind, trg_ind = indices[i] + if src_ind not in seen_src and trg_ind not in seen_trg: + seen_src.add(src_ind) + seen_trg.add(trg_ind) + if scores[i] > threshold or count < min_count: + if x_sentences[src_ind]: + print(scores[i], file=scores_out) + print(x_sentences[src_ind], file=src_out) + print(y_sentences[trg_ind], file=tgt_out) + count += 1 + else: + print(f"Ignoring sentence: {x_sentences[src_ind]}") + src_out.close() + tgt_out.close() + scores_out.close() + + print(f"Found {count} pairs for threshold={threshold}") + with open(f"{directory}/all.{args.src_lang}") as all_s, open( + f"{directory}/all.{args.tgt_lang}" + ) as all_t, open(f"{directory}/valid.{args.src_lang}", "w") as valid_s, open( + f"{directory}/valid.{args.tgt_lang}", "w" + ) as valid_t, open( + f"{directory}/train.{args.src_lang}", "w" + ) as train_s, open( + f"{directory}/train.{args.tgt_lang}", "w" + ) as train_t: + count = 0 + for s_line, t_line in zip(all_s, all_t): + s_line = s_line.split("\t")[1] + t_line = t_line.split("\t")[1] + if count >= args.valid_size: + train_s.write(s_line) + train_t.write(t_line) + else: + valid_s.write(s_line) + valid_t.write(t_line) + count += 1 diff --git a/fairseq/examples/criss/mining/mine_example.sh b/fairseq/examples/criss/mining/mine_example.sh new file mode 100644 index 0000000000000000000000000000000000000000..ace995ac44665f99d904b6a89d7fbbce24103afe --- /dev/null +++ b/fairseq/examples/criss/mining/mine_example.sh @@ -0,0 +1,103 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +source_lang=kk_KZ +target_lang=en_XX +MODEL=criss_checkpoints/criss.3rd.pt +SPM=criss_checkpoints/sentence.bpe.model +SPLIT=test +LANG_DICT=criss_checkpoints/lang_dict.txt +SPM_ENCODE=flores/scripts/spm_encode.py +SAVE_ENCODER=save_encoder.py +ENCODER_SAVE_ROOT=sentence_embeddings/$MODEL +DICT=criss_checkpoints/dict.txt +THRESHOLD=1.02 +MIN_COUNT=500 + +DATA_DIR=data_tmp +SAVE_DIR=mining/${source_lang}_${target_lang}_mined +ENCODER_SAVE_DIR=${ENCODER_SAVE_ROOT}/${source_lang}-${target_lang} +INPUT_DIR=$DATA_DIR/${source_lang}-${target_lang}-tatoeba + +mkdir -p $ENCODER_SAVE_DIR/${target_lang} +mkdir -p $ENCODER_SAVE_DIR/${source_lang} +mkdir -p $SAVE_DIR + +## Save encoder outputs + +# Save encoder outputs for source sentences +python $SAVE_ENCODER \ + ${INPUT_DIR} \ + --path ${MODEL} \ + --task translation_multi_simple_epoch \ + --lang-pairs ${source_lang}-${target_lang} \ + --lang-dict ${LANG_DICT} \ + --gen-subset ${SPLIT} \ + --bpe 'sentencepiece' \ + -s ${source_lang} -t ${target_lang} \ + --sentencepiece-model ${SPM} \ + --remove-bpe 'sentencepiece' \ + --beam 1 \ + --lang-tok-style mbart \ + --encoder-save-dir ${ENCODER_SAVE_DIR}/${source_lang} + +## Save encoder outputs for target sentences +python $SAVE_ENCODER \ + ${INPUT_DIR} \ + --path ${MODEL} \ + --lang-pairs ${source_lang}-${target_lang} \ + --lang-dict ${LANG_DICT} \ + --task translation_multi_simple_epoch \ + --gen-subset ${SPLIT} \ + --bpe 'sentencepiece' \ + -t ${source_lang} -s ${target_lang} \ + --sentencepiece-model ${SPM} \ + --remove-bpe 'sentencepiece' \ + --beam 1 \ + --lang-tok-style mbart \ + --encoder-save-dir ${ENCODER_SAVE_DIR}/${target_lang} + +## Mining +python mining/mine.py \ + --src-lang ${source_lang} \ + --tgt-lang ${target_lang} \ + --dim 1024 \ + --mem 10 \ + --neighborhood 4 \ + --src-dir ${ENCODER_SAVE_DIR}/${source_lang} \ + --tgt-dir ${ENCODER_SAVE_DIR}/${target_lang} \ + --output $SAVE_DIR \ + --threshold ${THRESHOLD} \ + --min-count ${MIN_COUNT} \ + --valid-size 100 \ + --dict-path ${DICT} \ + --spm-path ${SPM} \ + + +## Process and binarize mined data +python $SPM_ENCODE \ + --model ${SPM} \ + --output_format=piece \ + --inputs mining/${source_lang}_${target_lang}_mined/train.${source_lang} mining/${source_lang}_${target_lang}_mined/train.${target_lang} \ + --outputs mining/${source_lang}_${target_lang}_mined/train.bpe.${source_lang} mining/${source_lang}_${target_lang}_mined/train.bpe.${target_lang} + +python $SPM_ENCODE \ + --model ${SPM} \ + --output_format=piece \ + --inputs mining/${source_lang}_${target_lang}_mined/valid.${source_lang} mining/${source_lang}_${target_lang}_mined/valid.${target_lang} \ + --outputs mining/${source_lang}_${target_lang}_mined/valid.bpe.${source_lang} mining/${source_lang}_${target_lang}_mined/valid.bpe.${target_lang} + + +fairseq-preprocess \ + --source-lang ${source_lang} \ + --target-lang ${target_lang} \ + --trainpref mining/${source_lang}_${target_lang}_mined/train.bpe \ + --validpref mining/${source_lang}_${target_lang}_mined/valid.bpe \ + --destdir mining/${source_lang}_${target_lang}_mined \ + --srcdict ${DICT} \ + --joined-dictionary \ + --workers 8 diff --git a/fairseq/examples/criss/save_encoder.py b/fairseq/examples/criss/save_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..24a842e4092663c79c92a299fa85747b7c0bed64 --- /dev/null +++ b/fairseq/examples/criss/save_encoder.py @@ -0,0 +1,214 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Translate pre-processed data with a trained model. +""" + +import numpy as np +import torch +from fairseq import checkpoint_utils, options, progress_bar, tasks, utils +from fairseq.sequence_generator import EnsembleModel +from fairseq.utils import safe_hasattr + + +def get_avg_pool( + models, sample, prefix_tokens, src_dict, remove_bpe, has_langtok=False +): + model = EnsembleModel(models) + + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in sample["net_input"].items() if k != "prev_output_tokens" + } + + # compute the encoder output for each beam + encoder_outs = model.forward_encoder(encoder_input) + np_encoder_outs = encoder_outs[0].encoder_out.cpu().numpy().astype(np.float32) + encoder_mask = 1 - encoder_outs[0].encoder_padding_mask.cpu().numpy().astype( + np.float32 + ) + encoder_mask = np.expand_dims(encoder_mask.T, axis=2) + if has_langtok: + encoder_mask = encoder_mask[1:, :, :] + np_encoder_outs = np_encoder_outs[1, :, :] + masked_encoder_outs = encoder_mask * np_encoder_outs + avg_pool = (masked_encoder_outs / encoder_mask.sum(axis=0)).sum(axis=0) + return avg_pool + + +def main(args): + assert args.path is not None, "--path required for generation!" + assert ( + not args.sampling or args.nbest == args.beam + ), "--sampling requires --nbest to be equal to --beam" + assert ( + args.replace_unk is None or args.raw_text + ), "--replace-unk requires a raw text dataset (--raw-text)" + + args.beam = 1 + utils.import_user_module(args) + + if args.max_tokens is None: + args.max_tokens = 12000 + print(args) + use_cuda = torch.cuda.is_available() and not args.cpu + + # Load dataset splits + task = tasks.setup_task(args) + task.load_dataset(args.gen_subset) + + # Set dictionaries + try: + src_dict = getattr(task, "source_dictionary", None) + except NotImplementedError: + src_dict = None + tgt_dict = task.target_dictionary + + # Load ensemble + print("| loading model(s) from {}".format(args.path)) + models, _model_args = checkpoint_utils.load_model_ensemble( + args.path.split(":"), + arg_overrides=eval(args.model_overrides), + task=task, + ) + + # Optimize ensemble for generation + for model in models: + model.make_generation_fast_( + beamable_mm_beam_size=None if args.no_beamable_mm else args.beam, + need_attn=args.print_alignment, + ) + if args.fp16: + model.half() + if use_cuda: + model.cuda() + + # Load alignment dictionary for unknown word replacement + # (None if no unknown word replacement, empty if no path to align dictionary) + align_dict = utils.load_align_dict(args.replace_unk) + + # Load dataset (possibly sharded) + itr = task.get_batch_iterator( + dataset=task.dataset(args.gen_subset), + max_tokens=args.max_tokens, + max_positions=utils.resolve_max_positions( + task.max_positions(), + ), + ignore_invalid_inputs=args.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=args.required_batch_size_multiple, + num_shards=args.num_shards, + shard_id=args.shard_id, + num_workers=args.num_workers, + ).next_epoch_itr(shuffle=False) + + num_sentences = 0 + source_sentences = [] + shard_id = 0 + all_avg_pool = None + encoder_has_langtok = ( + safe_hasattr(task.args, "encoder_langtok") + and task.args.encoder_langtok is not None + and safe_hasattr(task.args, "lang_tok_replacing_bos_eos") + and not task.args.lang_tok_replacing_bos_eos + ) + with progress_bar.build_progress_bar(args, itr) as t: + for sample in t: + if sample is None: + print("Skipping None") + continue + sample = utils.move_to_cuda(sample) if use_cuda else sample + if "net_input" not in sample: + continue + + prefix_tokens = None + if args.prefix_size > 0: + prefix_tokens = sample["target"][:, : args.prefix_size] + + with torch.no_grad(): + avg_pool = get_avg_pool( + models, + sample, + prefix_tokens, + src_dict, + args.post_process, + has_langtok=encoder_has_langtok, + ) + if all_avg_pool is not None: + all_avg_pool = np.concatenate((all_avg_pool, avg_pool)) + else: + all_avg_pool = avg_pool + + if not isinstance(sample["id"], list): + sample_ids = sample["id"].tolist() + else: + sample_ids = sample["id"] + for i, sample_id in enumerate(sample_ids): + # Remove padding + src_tokens = utils.strip_pad( + sample["net_input"]["src_tokens"][i, :], tgt_dict.pad() + ) + + # Either retrieve the original sentences or regenerate them from tokens. + if align_dict is not None: + src_str = task.dataset(args.gen_subset).src.get_original_text( + sample_id + ) + else: + if src_dict is not None: + src_str = src_dict.string(src_tokens, args.post_process) + else: + src_str = "" + + if not args.quiet: + if src_dict is not None: + print("S-{}\t{}".format(sample_id, src_str)) + + source_sentences.append(f"{sample_id}\t{src_str}") + + num_sentences += sample["nsentences"] + if all_avg_pool.shape[0] >= 1000000: + with open( + f"{args.encoder_save_dir}/all_avg_pool.{args.source_lang}.{shard_id}", + "w", + ) as avg_pool_file: + all_avg_pool.tofile(avg_pool_file) + with open( + f"{args.encoder_save_dir}/sentences.{args.source_lang}.{shard_id}", + "w", + ) as sentence_file: + sentence_file.writelines(f"{line}\n" for line in source_sentences) + all_avg_pool = None + source_sentences = [] + shard_id += 1 + + if all_avg_pool is not None: + with open( + f"{args.encoder_save_dir}/all_avg_pool.{args.source_lang}.{shard_id}", "w" + ) as avg_pool_file: + all_avg_pool.tofile(avg_pool_file) + with open( + f"{args.encoder_save_dir}/sentences.{args.source_lang}.{shard_id}", "w" + ) as sentence_file: + sentence_file.writelines(f"{line}\n" for line in source_sentences) + return None + + +def cli_main(): + parser = options.get_generation_parser() + parser.add_argument( + "--encoder-save-dir", + default="", + type=str, + metavar="N", + help="directory to save encoder outputs", + ) + args = options.parse_args_and_arch(parser) + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/criss/sentence_retrieval/encoder_analysis.py b/fairseq/examples/criss/sentence_retrieval/encoder_analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..b41bfbe38789ba14e6a5ea938c75d761424c00ab --- /dev/null +++ b/fairseq/examples/criss/sentence_retrieval/encoder_analysis.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import argparse +import glob + +import numpy as np + + +DIM = 1024 + + +def compute_dist(source_embs, target_embs, k=5, return_sim_mat=False): + target_ids = [tid for tid in target_embs] + source_mat = np.stack(source_embs.values(), axis=0) + normalized_source_mat = source_mat / np.linalg.norm( + source_mat, axis=1, keepdims=True + ) + target_mat = np.stack(target_embs.values(), axis=0) + normalized_target_mat = target_mat / np.linalg.norm( + target_mat, axis=1, keepdims=True + ) + sim_mat = normalized_source_mat.dot(normalized_target_mat.T) + if return_sim_mat: + return sim_mat + neighbors_map = {} + for i, sentence_id in enumerate(source_embs): + idx = np.argsort(sim_mat[i, :])[::-1][:k] + neighbors_map[sentence_id] = [target_ids[tid] for tid in idx] + return neighbors_map + + +def load_embeddings(directory, LANGS): + sentence_embeddings = {} + sentence_texts = {} + for lang in LANGS: + sentence_embeddings[lang] = {} + sentence_texts[lang] = {} + lang_dir = f"{directory}/{lang}" + embedding_files = glob.glob(f"{lang_dir}/all_avg_pool.{lang}.*") + for embed_file in embedding_files: + shard_id = embed_file.split(".")[-1] + embeddings = np.fromfile(embed_file, dtype=np.float32) + num_rows = embeddings.shape[0] // DIM + embeddings = embeddings.reshape((num_rows, DIM)) + + with open(f"{lang_dir}/sentences.{lang}.{shard_id}") as sentence_file: + for idx, line in enumerate(sentence_file): + sentence_id, sentence = line.strip().split("\t") + sentence_texts[lang][sentence_id] = sentence + sentence_embeddings[lang][sentence_id] = embeddings[idx, :] + + return sentence_embeddings, sentence_texts + + +def compute_accuracy(directory, LANGS): + sentence_embeddings, sentence_texts = load_embeddings(directory, LANGS) + + top_1_accuracy = {} + + top1_str = " ".join(LANGS) + "\n" + for source_lang in LANGS: + top_1_accuracy[source_lang] = {} + top1_str += f"{source_lang} " + for target_lang in LANGS: + top1 = 0 + top5 = 0 + neighbors_map = compute_dist( + sentence_embeddings[source_lang], sentence_embeddings[target_lang] + ) + for sentence_id, neighbors in neighbors_map.items(): + if sentence_id == neighbors[0]: + top1 += 1 + if sentence_id in neighbors[:5]: + top5 += 1 + n = len(sentence_embeddings[target_lang]) + top1_str += f"{top1/n} " + top1_str += "\n" + + print(top1_str) + print(top1_str, file=open(f"{directory}/accuracy", "w")) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Analyze encoder outputs") + parser.add_argument("directory", help="Source language corpus") + parser.add_argument("--langs", help="List of langs") + args = parser.parse_args() + langs = args.langs.split(",") + compute_accuracy(args.directory, langs) diff --git a/fairseq/examples/criss/sentence_retrieval/sentence_retrieval_tatoeba.sh b/fairseq/examples/criss/sentence_retrieval/sentence_retrieval_tatoeba.sh new file mode 100644 index 0000000000000000000000000000000000000000..0428d8bef9d426ac3e664cd281ce0b688f5f580f --- /dev/null +++ b/fairseq/examples/criss/sentence_retrieval/sentence_retrieval_tatoeba.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +source_lang=kk_KZ +target_lang=en_XX +MODEL=criss_checkpoints/criss.3rd.pt +SPM=criss_checkpoints/sentence.bpe.model +SPLIT=test +LANG_DICT=criss_checkpoints/lang_dict.txt +ENCODER_ANALYSIS=sentence_retrieval/encoder_analysis.py +SAVE_ENCODER=save_encoder.py +ENCODER_SAVE_ROOT=sentence_embeddings/$MODEL + + + +DATA_DIR=data_tmp +INPUT_DIR=$DATA_DIR/${source_lang}-${target_lang}-tatoeba +ENCODER_SAVE_DIR=${ENCODER_SAVE_ROOT}/${source_lang}-${target_lang} +mkdir -p $ENCODER_SAVE_DIR/${target_lang} +mkdir -p $ENCODER_SAVE_DIR/${source_lang} + +# Save encoder outputs for source sentences +python $SAVE_ENCODER \ + ${INPUT_DIR} \ + --path ${MODEL} \ + --task translation_multi_simple_epoch \ + --lang-dict ${LANG_DICT} \ + --gen-subset ${SPLIT} \ + --bpe 'sentencepiece' \ + --lang-pairs ${source_lang}-${target_lang} \ + -s ${source_lang} -t ${target_lang} \ + --sentencepiece-model ${SPM} \ + --remove-bpe 'sentencepiece' \ + --beam 1 \ + --lang-tok-style mbart \ + --encoder-save-dir ${ENCODER_SAVE_DIR}/${source_lang} + +# Save encoder outputs for target sentences +python $SAVE_ENCODER \ + ${INPUT_DIR} \ + --path ${MODEL} \ + --lang-dict ${LANG_DICT} \ + --task translation_multi_simple_epoch \ + --gen-subset ${SPLIT} \ + --bpe 'sentencepiece' \ + --lang-pairs ${target_lang}-${source_lang} \ + -t ${source_lang} -s ${target_lang} \ + --sentencepiece-model ${SPM} \ + --remove-bpe 'sentencepiece' \ + --beam 1 \ + --lang-tok-style mbart \ + --encoder-save-dir ${ENCODER_SAVE_DIR}/${target_lang} + +# Analyze sentence retrieval accuracy +python $ENCODER_ANALYSIS --langs "${source_lang},${target_lang}" ${ENCODER_SAVE_DIR} diff --git a/fairseq/examples/criss/unsupervised_mt/eval.sh b/fairseq/examples/criss/unsupervised_mt/eval.sh new file mode 100644 index 0000000000000000000000000000000000000000..03b773ed5a522eb82186fea8ffbb6c557e14b6d3 --- /dev/null +++ b/fairseq/examples/criss/unsupervised_mt/eval.sh @@ -0,0 +1,37 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# +SRC=si_LK +TGT=en_XX +MODEL=criss_checkpoints/criss.3rd.pt + +MULTIBLEU=mosesdecoder/scripts/generic/multi-bleu.perl +MOSES=mosesdecoder +REPLACE_UNICODE_PUNCT=$MOSES/scripts/tokenizer/replace-unicode-punctuation.perl +NORM_PUNC=$MOSES/scripts/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$MOSES/scripts/tokenizer/remove-non-printing-char.perl +TOKENIZER=$MOSES/scripts/tokenizer/tokenizer.perl +GEN_TMP_DIR=gen_tmp +LANG_DICT=criss_checkpoints/lang_dict.txt + +if [ ! -d "mosesdecoder" ]; then + git clone https://github.com/moses-smt/mosesdecoder +fi +mkdir -p $GEN_TMP_DIR +fairseq-generate data_tmp/${SRC}-${TGT}-flores \ + --task translation_multi_simple_epoch \ + --max-tokens 2000 \ + --path ${MODEL} \ + --skip-invalid-size-inputs-valid-test \ + --beam 5 --lenpen 1.0 --gen-subset test \ + --remove-bpe=sentencepiece \ + --source-lang ${SRC} --target-lang ${TGT} \ + --decoder-langtok --lang-pairs 'en_XX-ar_AR,en_XX-de_DE,en_XX-es_XX,en_XX-fr_XX,en_XX-hi_IN,en_XX-it_IT,en_XX-ja_XX,en_XX-ko_KR,en_XX-nl_XX,en_XX-ru_RU,en_XX-zh_CN,en_XX-tr_TR,en_XX-vi_VN,en_XX-ro_RO,en_XX-my_MM,en_XX-ne_NP,en_XX-si_LK,en_XX-cs_CZ,en_XX-lt_LT,en_XX-kk_KZ,en_XX-gu_IN,en_XX-fi_FI,en_XX-et_EE,en_XX-lv_LV,ar_AR-en_XX,cs_CZ-en_XX,de_DE-en_XX,es_XX-en_XX,et_EE-en_XX,fi_FI-en_XX,fr_XX-en_XX,gu_IN-en_XX,hi_IN-en_XX,it_IT-en_XX,ja_XX-en_XX,kk_KZ-en_XX,ko_KR-en_XX,lt_LT-en_XX,lv_LV-en_XX,my_MM-en_XX,ne_NP-en_XX,nl_XX-en_XX,ro_RO-en_XX,ru_RU-en_XX,si_LK-en_XX,tr_TR-en_XX,vi_VN-en_XX,zh_CN-en_XX,ar_AR-es_XX,es_XX-ar_AR,ar_AR-hi_IN,hi_IN-ar_AR,ar_AR-zh_CN,zh_CN-ar_AR,cs_CZ-es_XX,es_XX-cs_CZ,cs_CZ-hi_IN,hi_IN-cs_CZ,cs_CZ-zh_CN,zh_CN-cs_CZ,de_DE-es_XX,es_XX-de_DE,de_DE-hi_IN,hi_IN-de_DE,de_DE-zh_CN,zh_CN-de_DE,es_XX-hi_IN,hi_IN-es_XX,es_XX-zh_CN,zh_CN-es_XX,et_EE-es_XX,es_XX-et_EE,et_EE-hi_IN,hi_IN-et_EE,et_EE-zh_CN,zh_CN-et_EE,fi_FI-es_XX,es_XX-fi_FI,fi_FI-hi_IN,hi_IN-fi_FI,fi_FI-zh_CN,zh_CN-fi_FI,fr_XX-es_XX,es_XX-fr_XX,fr_XX-hi_IN,hi_IN-fr_XX,fr_XX-zh_CN,zh_CN-fr_XX,gu_IN-es_XX,es_XX-gu_IN,gu_IN-hi_IN,hi_IN-gu_IN,gu_IN-zh_CN,zh_CN-gu_IN,hi_IN-zh_CN,zh_CN-hi_IN,it_IT-es_XX,es_XX-it_IT,it_IT-hi_IN,hi_IN-it_IT,it_IT-zh_CN,zh_CN-it_IT,ja_XX-es_XX,es_XX-ja_XX,ja_XX-hi_IN,hi_IN-ja_XX,ja_XX-zh_CN,zh_CN-ja_XX,kk_KZ-es_XX,es_XX-kk_KZ,kk_KZ-hi_IN,hi_IN-kk_KZ,kk_KZ-zh_CN,zh_CN-kk_KZ,ko_KR-es_XX,es_XX-ko_KR,ko_KR-hi_IN,hi_IN-ko_KR,ko_KR-zh_CN,zh_CN-ko_KR,lt_LT-es_XX,es_XX-lt_LT,lt_LT-hi_IN,hi_IN-lt_LT,lt_LT-zh_CN,zh_CN-lt_LT,lv_LV-es_XX,es_XX-lv_LV,lv_LV-hi_IN,hi_IN-lv_LV,lv_LV-zh_CN,zh_CN-lv_LV,my_MM-es_XX,es_XX-my_MM,my_MM-hi_IN,hi_IN-my_MM,my_MM-zh_CN,zh_CN-my_MM,ne_NP-es_XX,es_XX-ne_NP,ne_NP-hi_IN,hi_IN-ne_NP,ne_NP-zh_CN,zh_CN-ne_NP,nl_XX-es_XX,es_XX-nl_XX,nl_XX-hi_IN,hi_IN-nl_XX,nl_XX-zh_CN,zh_CN-nl_XX,ro_RO-es_XX,es_XX-ro_RO,ro_RO-hi_IN,hi_IN-ro_RO,ro_RO-zh_CN,zh_CN-ro_RO,ru_RU-es_XX,es_XX-ru_RU,ru_RU-hi_IN,hi_IN-ru_RU,ru_RU-zh_CN,zh_CN-ru_RU,si_LK-es_XX,es_XX-si_LK,si_LK-hi_IN,hi_IN-si_LK,si_LK-zh_CN,zh_CN-si_LK,tr_TR-es_XX,es_XX-tr_TR,tr_TR-hi_IN,hi_IN-tr_TR,tr_TR-zh_CN,zh_CN-tr_TR,vi_VN-es_XX,es_XX-vi_VN,vi_VN-hi_IN,hi_IN-vi_VN,vi_VN-zh_CN,zh_CN-vi_VN' \ + --lang-dict ${LANG_DICT} --lang-tok-style 'mbart' --sampling-method 'temperature' --sampling-temperature '1.0' > $GEN_TMP_DIR/${SRC}_${TGT}.gen +cat $GEN_TMP_DIR/${SRC}_${TGT}.gen | grep -P "^T-" | cut -f2 | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l ${TGT:0:2} | $REM_NON_PRINT_CHAR | $TOKENIZER -no-escape ${TGT:0:2} > $GEN_TMP_DIR/${SRC}_${TGT}.hyp +cat $GEN_TMP_DIR/${SRC}_${TGT}.gen | grep -P "^H-" | cut -f3 | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l ${TGT:0:2} | $REM_NON_PRINT_CHAR | $TOKENIZER -no-escape ${TGT:0:2} > $GEN_TMP_DIR/${SRC}_${TGT}.ref +${MULTIBLEU} $GEN_TMP_DIR/${SRC}_${TGT}.ref < $GEN_TMP_DIR/${SRC}_${TGT}.hyp diff --git a/fairseq/examples/cross_lingual_language_model/README.md b/fairseq/examples/cross_lingual_language_model/README.md new file mode 100644 index 0000000000000000000000000000000000000000..af9128e39e5925e9411d162c2f24a19e4532d618 --- /dev/null +++ b/fairseq/examples/cross_lingual_language_model/README.md @@ -0,0 +1,77 @@ +# Cross-Lingual Language Model Pre-training + +Below are some details for training Cross-Lingual Language Models (XLM) - similar to the ones presented in [Lample & Conneau, 2019](https://arxiv.org/pdf/1901.07291.pdf) - in Fairseq. The current implementation only supports the Masked Language Model (MLM) from the paper above. + +## Downloading and Tokenizing Monolingual Data + +Pointers to the monolingual data from wikipedia, used for training the XLM-style MLM model as well as details on processing (tokenization and BPE) it can be found in the [XLM Github Repository](https://github.com/facebookresearch/XLM#download--preprocess-monolingual-data). + +Let's assume the following for the code snippets in later sections to work +- Processed data is in the folder: monolingual_data/processed +- Each language has 3 files for train, test and validation. For example we have the following files for English: + train.en, valid.en +- We are training a model for 5 languages: Arabic (ar), German (de), English (en), Hindi (hi) and French (fr) +- The vocabulary file is monolingual_data/processed/vocab_mlm + + +## Fairseq Pre-processing and Binarization + +Pre-process and binarize the data with the MaskedLMDictionary and cross_lingual_lm task + +```bash +# Ensure the output directory exists +DATA_DIR=monolingual_data/fairseq_processed +mkdir -p "$DATA_DIR" + +for lg in ar de en hi fr +do + + fairseq-preprocess \ + --task cross_lingual_lm \ + --srcdict monolingual_data/processed/vocab_mlm \ + --only-source \ + --trainpref monolingual_data/processed/train \ + --validpref monolingual_data/processed/valid \ + --testpref monolingual_data/processed/test \ + --destdir monolingual_data/fairseq_processed \ + --workers 20 \ + --source-lang $lg + + # Since we only have a source language, the output file has a None for the + # target language. Remove this + + for stage in train test valid + + sudo mv "$DATA_DIR/$stage.$lg-None.$lg.bin" "$stage.$lg.bin" + sudo mv "$DATA_DIR/$stage.$lg-None.$lg.idx" "$stage.$lg.idx" + + done + +done +``` + +## Train a Cross-lingual Language Model similar to the XLM MLM model + +Use the following command to train the model on 5 languages. + +``` +fairseq-train \ +--task cross_lingual_lm monolingual_data/fairseq_processed \ +--save-dir checkpoints/mlm \ +--max-update 2400000 --save-interval 1 --no-epoch-checkpoints \ +--arch xlm_base \ +--optimizer adam --lr-scheduler reduce_lr_on_plateau \ +--lr-shrink 0.5 --lr 0.0001 --stop-min-lr 1e-09 \ +--dropout 0.1 \ +--criterion legacy_masked_lm_loss \ +--max-tokens 2048 --tokens-per-sample 256 --attention-dropout 0.1 \ +--dataset-impl lazy --seed 0 \ +--masked-lm-only \ +--monolingual-langs 'ar,de,en,hi,fr' --num-segment 5 \ +--ddp-backend=legacy_ddp +``` + +Some Notes: +- Using tokens_per_sample greater than 256 can cause OOM (out-of-memory) issues. Usually since MLM packs in streams of text, this parameter doesn't need much tuning. +- The Evaluation workflow for computing MLM Perplexity on test data is in progress. +- Finetuning this model on a downstream task is something which is not currently available. diff --git a/fairseq/examples/discriminative_reranking_nmt/README.md b/fairseq/examples/discriminative_reranking_nmt/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b155e855f2f94e30ad22262f260008fda8ac1804 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/README.md @@ -0,0 +1,202 @@ +# Discriminative Reranking for Neural Machine Translation +https://aclanthology.org/2021.acl-long.563/ + +This folder contains source code for training DrNMT, a discriminatively trained reranker for neural machine translation. + +## Data preparation +1. Follow the instructions under `examples/translation` to build a base MT model. Prepare three files, one with source sentences, one with ground truth target sentences, and one with hypotheses generated from the base MT model. Each line in the file contains one sentence in raw text (i.e. no sentencepiece, etc.). Below is an example of the files with _N_ hypotheses for each source sentence. + +``` +# Example of the source sentence file: (The file should contain L lines.) + +source_sentence_1 +source_sentence_2 +source_sentence_3 +... +source_sentence_L + +# Example of the target sentence file: (The file should contain L lines.) + +target_sentence_1 +target_sentence_2 +target_sentence_3 +... +target_sentence_L + +# Example of the hypotheses file: (The file should contain L*N lines.) + +source_sentence_1_hypo_1 +source_sentence_1_hypo_2 +... +source_sentence_1_hypo_N +source_sentence_2_hypo_1 +... +source_sentence_2_hypo_N +... +source_sentence_L_hypo_1 +... +source_sentence_L_hypo_N +``` + +2. Download the [XLMR model](https://github.com/fairinternal/fairseq-py/tree/main/examples/xlmr#pre-trained-models). +``` +wget https://dl.fbaipublicfiles.com/fairseq/models/xlmr.base.tar.gz +tar zxvf xlmr.base.tar.gz + +# The folder should contain dict.txt, model.pt and sentencepiece.bpe.model. +``` + +3. Prepare scores and BPE data. +* `N`: Number of hypotheses per each source sentence. We use 50 in the paper. +* `SPLIT`: Name of the data split, i.e. train, valid, test. Use split_name, split_name1, split_name2, ..., if there are multiple datasets for a split, e.g. train, train1, valid, valid1. +* `NUM_SHARDS`: Number of shards. Set this to 1 for non-train splits. +* `METRIC`: The metric for DrNMT to optimize for. We support either `bleu` or `ter`. +``` +# For each data split, e.g. train, valid, test, etc., run the following: + +SOURCE_FILE=/path/to/source_sentence_file +TARGET_FILE=/path/to/target_sentence_file +HYPO_FILE=/path/to/hypo_file +XLMR_DIR=/path/to/xlmr +OUTPUT_DIR=/path/to/output + +python scripts/prep_data.py \ + --input-source ${SOURCE_FILE} \ + --input-target ${TARGET_FILE} \ + --input-hypo ${HYPO_FILE} \ + --output-dir ${OUTPUT_DIR} \ + --split $SPLIT + --beam $N \ + --sentencepiece-model ${XLMR_DIR}/sentencepiece.bpe.model \ + --metric $METRIC \ + --num-shards ${NUM_SHARDS} + +# The script will create ${OUTPUT_DIR}/$METRIC with ${NUM_SHARDS} splits. +# Under split*/input_src, split*/input_tgt and split*/$METRIC, there will be $SPLIT.bpe and $SPLIT.$METRIC files, respectively. + +``` + +4. Pre-process the data into fairseq format. +``` +# use comma to separate if there are more than one train or valid set +for suffix in src tgt ; do + fairseq-preprocess --only-source \ + --trainpref ${OUTPUT_DIR}/$METRIC/split1/input_${suffix}/train.bpe \ + --validpref ${OUTPUT_DIR}/$METRIC/split1/input_${suffix}/valid.bpe \ + --destdir ${OUTPUT_DIR}/$METRIC/split1/input_${suffix} \ + --workers 60 \ + --srcdict ${XLMR_DIR}/dict.txt +done + +for i in `seq 2 ${NUM_SHARDS}`; do + for suffix in src tgt ; do + fairseq-preprocess --only-source \ + --trainpref ${OUTPUT_DIR}/$METRIC/split${i}/input_${suffix}/train.bpe \ + --destdir ${OUTPUT_DIR}/$METRIC/split${i}/input_${suffix} \ + --workers 60 \ + --srcdict ${XLMR_DIR}/dict.txt + + ln -s ${OUTPUT_DIR}/$METRIC/split1/input_${suffix}/valid* ${OUTPUT_DIR}/$METRIC/split${i}/input_${suffix}/. + done + + ln -s ${OUTPUT_DIR}/$METRIC/split1/$METRIC/valid* ${OUTPUT_DIR}/$METRIC/split${i}/$METRIC/. +done +``` + +## Training + +``` +EXP_DIR=/path/to/exp + +# An example of training the model with the config for De-En experiment in the paper. +# The config uses 16 GPUs and 50 hypotheses. +# For training with fewer number of GPUs, set +# distributed_training.distributed_world_size=k +optimization.update_freq='[x]' where x = 16/k +# For training with fewer number of hypotheses, set +# task.mt_beam=N dataset.batch_size=N dataset.required_batch_size_multiple=N + +fairseq-hydra-train -m \ + --config-dir config/ --config-name deen \ + task.data=${OUTPUT_DIR}/$METRIC/split1/ \ + task.num_data_splits=${NUM_SHARDS} \ + model.pretrained_model=${XLMR_DIR}/model.pt \ + common.user_dir=${FAIRSEQ_ROOT}/examples/discriminative_reranking_nmt \ + checkpoint.save_dir=${EXP_DIR} + +``` + +## Inference & scoring +Perform DrNMT reranking (fw + reranker score) +1. Tune weights on valid sets. +``` +# genrate N hypotheses with the base MT model (fw score) +VALID_SOURCE_FILE=/path/to/source_sentences # one sentence per line, converted to the sentencepiece used by the base MT model +VALID_TARGET_FILE=/path/to/target_sentences # one sentence per line in raw text, i.e. no sentencepiece and tokenization +MT_MODEL=/path/to/mt_model +MT_DATA_PATH=/path/to/mt_data + +cat ${VALID_SOURCE_FILE} | \ + fairseq-interactive ${MT_DATA_PATH} \ + --max-tokens 4000 --buffer-size 16 \ + --num-workers 32 --path ${MT_MODEL} \ + --beam $N --nbest $N \ + --post-process sentencepiece &> valid-hypo.out + +# replace "bleu" with "ter" to optimize for TER +python drnmt_rerank.py \ + ${OUTPUT_DIR}/$METRIC/split1/ \ + --path ${EXP_DIR}/checkpoint_best.pt \ + --in-text valid-hypo.out \ + --results-path ${EXP_DIR} \ + --gen-subset valid \ + --target-text ${VALID_TARGET_FILE} \ + --user-dir ${FAIRSEQ_ROOT}/examples/discriminative_reranking_nmt \ + --bpe sentencepiece \ + --sentencepiece-model ${XLMR_DIR}/sentencepiece.bpe.model \ + --beam $N \ + --batch-size $N \ + --metric bleu \ + --tune + +``` + +2. Apply best weights on test sets +``` +# genrate N hypotheses with the base MT model (fw score) +TEST_SOURCE_FILE=/path/to/source_sentences # one sentence per line, converted to the sentencepiece used by the base MT model + +cat ${TEST_SOURCE_FILE} | \ + fairseq-interactive ${MT_DATA_PATH} \ + --max-tokens 4000 --buffer-size 16 \ + --num-workers 32 --path ${MT_MODEL} \ + --beam $N --nbest $N \ + --post-process sentencepiece &> test-hypo.out + +# replace "bleu" with "ter" to evaluate TER +# Add --target-text for evaluating BLEU/TER, +# otherwise the script will only generate the hypotheses with the highest scores only. +python drnmt_rerank.py \ + ${OUTPUT_DIR}/$METRIC/split1/ \ + --path ${EXP_DIR}/checkpoint_best.pt \ + --in-text test-hypo.out \ + --results-path ${EXP_DIR} \ + --gen-subset test \ + --user-dir ${FAIRSEQ_ROOT}/examples/discriminative_reranking_nmt \ + --bpe sentencepiece \ + --sentencepiece-model ${XLMR_DIR}/sentencepiece.bpe.model \ + --beam $N \ + --batch-size $N \ + --metric bleu \ + --fw-weight ${BEST_FW_WEIGHT} \ + --lenpen ${BEST_LENPEN} +``` + +## Citation +```bibtex +@inproceedings{lee2021discriminative, + title={Discriminative Reranking for Neural Machine Translation}, + author={Lee, Ann and Auli, Michael and Ranzato, Marc'Aurelio}, + booktitle={ACL}, + year={2021} +} +``` diff --git a/fairseq/examples/discriminative_reranking_nmt/__init__.py b/fairseq/examples/discriminative_reranking_nmt/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0278f6a27340c7ff7e207d09348483d1b0d3a100 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/__init__.py @@ -0,0 +1 @@ +from . import criterions, models, tasks # noqa diff --git a/fairseq/examples/discriminative_reranking_nmt/config/deen.yaml b/fairseq/examples/discriminative_reranking_nmt/config/deen.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3fc2d5fcf5bacbb842d181fcfcde80e55331fed7 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/config/deen.yaml @@ -0,0 +1,56 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 50 + seed: 2 + +checkpoint: + no_epoch_checkpoints: true + best_checkpoint_metric: bleu + maximize_best_checkpoint_metric: true + +task: + _name: discriminative_reranking_nmt + data: ??? + num_data_splits: ??? + include_src: true + mt_beam: 50 + eval_target_metric: true + target_metric: bleu + +dataset: + batch_size: 50 + num_workers: 6 + required_batch_size_multiple: 50 + valid_subset: ??? + +criterion: + _name: kl_divergence_rereanking + target_dist_norm: minmax + temperature: 0.5 + +optimization: + max_epoch: 200 + lr: [0.00005] + update_freq: [32] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 8000 + total_num_update: 320000 + +model: + _name: discriminative_nmt_reranker + pretrained_model: ??? + classifier_dropout: 0.2 + +distributed_training: + ddp_backend: no_c10d + distributed_world_size: 16 diff --git a/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py b/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c257c2700f015cb123a976584aef72f0429eb0c --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/criterions/__init__.py @@ -0,0 +1,6 @@ +from .discriminative_reranking_criterion import KLDivergenceRerankingCriterion + + +__all__ = [ + "KLDivergenceRerankingCriterion", +] diff --git a/fairseq/examples/discriminative_reranking_nmt/criterions/discriminative_reranking_criterion.py b/fairseq/examples/discriminative_reranking_nmt/criterions/discriminative_reranking_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..0b02ce18772454697e61f827d96d76ad361b9cd1 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/criterions/discriminative_reranking_criterion.py @@ -0,0 +1,138 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field + +import torch +import torch.nn.functional as F + +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import ChoiceEnum, FairseqDataclass + + +_EPSILON = torch.finfo(torch.float32).eps +TARGET_DIST_NORM_CHOICES = ChoiceEnum(["none", "minmax"]) + + +@dataclass +class KLDivergenceRerankingCriterionConfig(FairseqDataclass): + target_dist_norm: TARGET_DIST_NORM_CHOICES = field( + default="none", + metadata={"help": "method to normalize the range of target scores"}, + ) + temperature: float = field( + default=1.0, + metadata={"help": "temperature in softmax for target distributions"}, + ) + forward_batch_size: int = field( + default=32, + metadata={ + "help": "number of hypotheses per batch for model forward (set a value smaller than --mt-beam to avoid OOM when training with a large beam size)" + }, + ) + + +@register_criterion( + "kl_divergence_rereanking", dataclass=KLDivergenceRerankingCriterionConfig +) +class KLDivergenceRerankingCriterion(FairseqCriterion): + def __init__( + self, task, target_dist_norm, temperature, forward_batch_size, + ): + super().__init__(task) + self.target_dist_norm = target_dist_norm + self.temperature = temperature + self.forward_batch_size = forward_batch_size + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + + sample_size = sample["id"].numel() + assert sample_size % self.task.cfg.mt_beam == 0, ( + f"sample_size ({sample_size}) cannot be divided by beam size ({self.task.cfg.mt_beam})." + f"Please set --required-batch-size-multiple={self.task.cfg.mt_beam}." + ) + + # split into smaller batches for model forward + batch_out = [] + for i in range(0, sample_size, self.forward_batch_size): + j = min(i + self.forward_batch_size, sample_size) + + out = model( + src_tokens=sample["net_input"]["src_tokens"][i:j, :], + src_lengths=sample["net_input"]["src_lengths"][i:j], + ) + + batch_out.append( + model.sentence_forward(out, sample["net_input"]["src_tokens"][i:j, :]) + ) + + batch_out = torch.cat(batch_out, dim=0).view( + self.task.cfg.mt_beam, sample_size // self.task.cfg.mt_beam, -1 + ) # T x B x C + if model.joint_classification == "sent": + batch_out = model.joint_forward(batch_out) + scores = model.classification_forward(batch_out.view(sample_size, 1, -1)).view( + -1, self.task.cfg.mt_beam + ) # input: B x T x C + + loss = self.compute_kl_loss( + scores, sample["target"][:, 0].view(-1, self.task.cfg.mt_beam) + ) + + sample_size = sample_size // self.task.cfg.mt_beam + + logging_output = { + "loss": loss.detach(), + "ntokens": sample["ntokens"], + "nsentences": sample_size * self.task.cfg.mt_beam, + "sample_size": sample_size, + "scores": scores.detach(), + } + + return loss, sample_size, logging_output + + def compute_kl_loss(self, logits, target): + norm_target = target + if self.target_dist_norm == "minmax": + min_v = torch.min(target, 1, keepdim=True).values + max_v = torch.max(target, 1, keepdim=True).values + norm_target = (target - min_v) / (max_v - min_v + _EPSILON) + + target_dist = F.softmax( + norm_target / self.temperature, dim=-1, dtype=torch.float32 + ) + model_dist = F.log_softmax(logits, dim=-1, dtype=torch.float32) + loss = -(target_dist * model_dist - target_dist * target_dist.log()).sum() + return loss + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + loss = loss_sum / sample_size / math.log(2) + metrics.log_scalar("loss", loss, sample_size, round=3) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/examples/discriminative_reranking_nmt/drnmt_rerank.py b/fairseq/examples/discriminative_reranking_nmt/drnmt_rerank.py new file mode 100644 index 0000000000000000000000000000000000000000..2e0fc2bd29aedb0b477b7cc8e2c3b606acdd454a --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/drnmt_rerank.py @@ -0,0 +1,364 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Score raw text with a trained model. +""" + +from collections import namedtuple +import logging +from multiprocessing import Pool +import sys +import os +import random + +import numpy as np +import sacrebleu +import torch + +from fairseq import checkpoint_utils, options, utils + + +logger = logging.getLogger("fairseq_cli.drnmt_rerank") +logger.setLevel(logging.INFO) + +Batch = namedtuple("Batch", "ids src_tokens src_lengths") + + +pool_init_variables = {} + + +def init_loaded_scores(mt_scores, model_scores, hyp, ref): + global pool_init_variables + pool_init_variables["mt_scores"] = mt_scores + pool_init_variables["model_scores"] = model_scores + pool_init_variables["hyp"] = hyp + pool_init_variables["ref"] = ref + + +def parse_fairseq_gen(filename, task): + source = {} + hypos = {} + scores = {} + with open(filename, "r", encoding="utf-8") as f: + for line in f: + line = line.strip() + if line.startswith("S-"): # source + uid, text = line.split("\t", 1) + uid = int(uid[2:]) + source[uid] = text + elif line.startswith("D-"): # hypo + uid, score, text = line.split("\t", 2) + uid = int(uid[2:]) + if uid not in hypos: + hypos[uid] = [] + scores[uid] = [] + hypos[uid].append(text) + scores[uid].append(float(score)) + else: + continue + + source_out = [source[i] for i in range(len(hypos))] + hypos_out = [h for i in range(len(hypos)) for h in hypos[i]] + scores_out = [s for i in range(len(scores)) for s in scores[i]] + + return source_out, hypos_out, scores_out + + +def read_target(filename): + with open(filename, "r", encoding="utf-8") as f: + output = [line.strip() for line in f] + return output + + +def make_batches(args, src, hyp, task, max_positions, encode_fn): + assert len(src) * args.beam == len( + hyp + ), f"Expect {len(src) * args.beam} hypotheses for {len(src)} source sentences with beam size {args.beam}. Got {len(hyp)} hypotheses intead." + hyp_encode = [ + task.source_dictionary.encode_line(encode_fn(h), add_if_not_exist=False).long() + for h in hyp + ] + if task.cfg.include_src: + src_encode = [ + task.source_dictionary.encode_line( + encode_fn(s), add_if_not_exist=False + ).long() + for s in src + ] + tokens = [(src_encode[i // args.beam], h) for i, h in enumerate(hyp_encode)] + lengths = [(t1.numel(), t2.numel()) for t1, t2 in tokens] + else: + tokens = [(h,) for h in hyp_encode] + lengths = [(h.numel(),) for h in hyp_encode] + + itr = task.get_batch_iterator( + dataset=task.build_dataset_for_inference(tokens, lengths), + max_tokens=args.max_tokens, + max_sentences=args.batch_size, + max_positions=max_positions, + ignore_invalid_inputs=args.skip_invalid_size_inputs_valid_test, + ).next_epoch_itr(shuffle=False) + + for batch in itr: + yield Batch( + ids=batch["id"], + src_tokens=batch["net_input"]["src_tokens"], + src_lengths=batch["net_input"]["src_lengths"], + ) + + +def decode_rerank_scores(args): + if args.max_tokens is None and args.batch_size is None: + args.batch_size = 1 + + logger.info(args) + + use_cuda = torch.cuda.is_available() and not args.cpu + + # Load ensemble + logger.info("loading model(s) from {}".format(args.path)) + models, _model_args, task = checkpoint_utils.load_model_ensemble_and_task( + [args.path], arg_overrides=eval(args.model_overrides), + ) + + for model in models: + if args.fp16: + model.half() + if use_cuda: + model.cuda() + + # Initialize generator + generator = task.build_generator(args) + + # Handle tokenization and BPE + tokenizer = task.build_tokenizer(args) + bpe = task.build_bpe(args) + + def encode_fn(x): + if tokenizer is not None: + x = tokenizer.encode(x) + if bpe is not None: + x = bpe.encode(x) + return x + + max_positions = utils.resolve_max_positions( + task.max_positions(), *[model.max_positions() for model in models] + ) + + src, hyp, mt_scores = parse_fairseq_gen(args.in_text, task) + model_scores = {} + logger.info("decode reranker score") + for batch in make_batches(args, src, hyp, task, max_positions, encode_fn): + src_tokens = batch.src_tokens + src_lengths = batch.src_lengths + if use_cuda: + src_tokens = src_tokens.cuda() + src_lengths = src_lengths.cuda() + + sample = { + "net_input": {"src_tokens": src_tokens, "src_lengths": src_lengths}, + } + scores = task.inference_step(generator, models, sample) + + for id, sc in zip(batch.ids.tolist(), scores.tolist()): + model_scores[id] = sc[0] + + model_scores = [model_scores[i] for i in range(len(model_scores))] + + return src, hyp, mt_scores, model_scores + + +def get_score(mt_s, md_s, w1, lp, tgt_len): + return mt_s / (tgt_len ** lp) * w1 + md_s + + +def get_best_hyps(mt_scores, md_scores, hypos, fw_weight, lenpen, beam): + assert len(mt_scores) == len(md_scores) and len(mt_scores) == len(hypos) + hypo_scores = [] + best_hypos = [] + best_scores = [] + offset = 0 + for i in range(len(hypos)): + tgt_len = len(hypos[i].split()) + hypo_scores.append( + get_score(mt_scores[i], md_scores[i], fw_weight, lenpen, tgt_len) + ) + + if (i + 1) % beam == 0: + max_i = np.argmax(hypo_scores) + best_hypos.append(hypos[offset + max_i]) + best_scores.append(hypo_scores[max_i]) + hypo_scores = [] + offset += beam + return best_hypos, best_scores + + +def eval_metric(args, hypos, ref): + if args.metric == "bleu": + score = sacrebleu.corpus_bleu(hypos, [ref]).score + else: + score = sacrebleu.corpus_ter(hypos, [ref]).score + + return score + + +def score_target_hypo(args, fw_weight, lp): + mt_scores = pool_init_variables["mt_scores"] + model_scores = pool_init_variables["model_scores"] + hyp = pool_init_variables["hyp"] + ref = pool_init_variables["ref"] + best_hypos, _ = get_best_hyps( + mt_scores, model_scores, hyp, fw_weight, lp, args.beam + ) + rerank_eval = None + if ref: + rerank_eval = eval_metric(args, best_hypos, ref) + print(f"fw_weight {fw_weight}, lenpen {lp}, eval {rerank_eval}") + + return rerank_eval + + +def print_result(best_scores, best_hypos, output_file): + for i, (s, h) in enumerate(zip(best_scores, best_hypos)): + print(f"{i}\t{s}\t{h}", file=output_file) + + +def main(args): + utils.import_user_module(args) + + src, hyp, mt_scores, model_scores = decode_rerank_scores(args) + + assert ( + not args.tune or args.target_text is not None + ), "--target-text has to be set when tuning weights" + if args.target_text: + ref = read_target(args.target_text) + assert len(src) == len( + ref + ), f"different numbers of source and target sentences ({len(src)} vs. {len(ref)})" + + orig_best_hypos = [hyp[i] for i in range(0, len(hyp), args.beam)] + orig_eval = eval_metric(args, orig_best_hypos, ref) + + if args.tune: + logger.info("tune weights for reranking") + + random_params = np.array( + [ + [ + random.uniform( + args.lower_bound_fw_weight, args.upper_bound_fw_weight + ), + random.uniform(args.lower_bound_lenpen, args.upper_bound_lenpen), + ] + for k in range(args.num_trials) + ] + ) + + logger.info("launching pool") + with Pool( + 32, + initializer=init_loaded_scores, + initargs=(mt_scores, model_scores, hyp, ref), + ) as p: + rerank_scores = p.starmap( + score_target_hypo, + [ + (args, random_params[i][0], random_params[i][1],) + for i in range(args.num_trials) + ], + ) + if args.metric == "bleu": + best_index = np.argmax(rerank_scores) + else: + best_index = np.argmin(rerank_scores) + best_fw_weight = random_params[best_index][0] + best_lenpen = random_params[best_index][1] + else: + assert ( + args.lenpen is not None and args.fw_weight is not None + ), "--lenpen and --fw-weight should be set" + best_fw_weight, best_lenpen = args.fw_weight, args.lenpen + + best_hypos, best_scores = get_best_hyps( + mt_scores, model_scores, hyp, best_fw_weight, best_lenpen, args.beam + ) + + if args.results_path is not None: + os.makedirs(args.results_path, exist_ok=True) + output_path = os.path.join( + args.results_path, "generate-{}.txt".format(args.gen_subset), + ) + with open(output_path, "w", buffering=1, encoding="utf-8") as o: + print_result(best_scores, best_hypos, o) + else: + print_result(best_scores, best_hypos, sys.stdout) + + if args.target_text: + rerank_eval = eval_metric(args, best_hypos, ref) + print(f"before reranking, {args.metric.upper()}:", orig_eval) + print( + f"after reranking with fw_weight={best_fw_weight}, lenpen={best_lenpen}, {args.metric.upper()}:", + rerank_eval, + ) + + +def cli_main(): + parser = options.get_generation_parser(interactive=True) + + parser.add_argument( + "--in-text", + default=None, + required=True, + help="text from fairseq-interactive output, containing source sentences and hypotheses", + ) + parser.add_argument("--target-text", default=None, help="reference text") + parser.add_argument("--metric", type=str, choices=["bleu", "ter"], default="bleu") + parser.add_argument( + "--tune", + action="store_true", + help="if set, tune weights on fw scores and lenpen instead of applying fixed weights for reranking", + ) + parser.add_argument( + "--lower-bound-fw-weight", + default=0.0, + type=float, + help="lower bound of search space", + ) + parser.add_argument( + "--upper-bound-fw-weight", + default=3, + type=float, + help="upper bound of search space", + ) + parser.add_argument( + "--lower-bound-lenpen", + default=0.0, + type=float, + help="lower bound of search space", + ) + parser.add_argument( + "--upper-bound-lenpen", + default=3, + type=float, + help="upper bound of search space", + ) + parser.add_argument( + "--fw-weight", type=float, default=None, help="weight on the fw model score" + ) + parser.add_argument( + "--num-trials", + default=1000, + type=int, + help="number of trials to do for random search", + ) + + args = options.parse_args_and_arch(parser) + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/discriminative_reranking_nmt/models/__init__.py b/fairseq/examples/discriminative_reranking_nmt/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c593ea5f1842794bfcc952fc93c679a5f16aeb98 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/models/__init__.py @@ -0,0 +1,6 @@ +from .discriminative_reranking_model import DiscriminativeNMTReranker + + +__all__ = [ + "DiscriminativeNMTReranker", +] diff --git a/fairseq/examples/discriminative_reranking_nmt/models/discriminative_reranking_model.py b/fairseq/examples/discriminative_reranking_nmt/models/discriminative_reranking_model.py new file mode 100644 index 0000000000000000000000000000000000000000..e4b5887f825df36f4e1e0384f38fefe790e485e6 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/models/discriminative_reranking_model.py @@ -0,0 +1,365 @@ +from dataclasses import dataclass, field +import os + +import torch +import torch.nn as nn + +from fairseq import utils +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.models import ( + BaseFairseqModel, + register_model, +) + +from fairseq.models.roberta.model import RobertaClassificationHead + +from fairseq.modules import ( + LayerNorm, + TransformerSentenceEncoder, + TransformerSentenceEncoderLayer, +) + + +ACTIVATION_FN_CHOICES = ChoiceEnum(utils.get_available_activation_fns()) +JOINT_CLASSIFICATION_CHOICES = ChoiceEnum(["none", "sent"]) +SENTENCE_REP_CHOICES = ChoiceEnum(["head", "meanpool", "maxpool"]) + + +def update_init_roberta_model_state(state): + """ + update the state_dict of a Roberta model for initializing + weights of the BertRanker + """ + for k in list(state.keys()): + if ".lm_head." in k or "version" in k: + del state[k] + continue + # remove 'encoder/decoder.sentence_encoder.' from the key + assert k.startswith("encoder.sentence_encoder.") or k.startswith( + "decoder.sentence_encoder." + ), f"Cannot recognize parameter name {k}" + if "layernorm_embedding" in k: + new_k = k.replace(".layernorm_embedding.", ".emb_layer_norm.") + state[new_k[25:]] = state[k] + else: + state[k[25:]] = state[k] + del state[k] + + +class BaseRanker(nn.Module): + def __init__(self, args, task): + super().__init__() + + self.separator_token = task.dictionary.eos() + self.padding_idx = task.dictionary.pad() + + def forward(self, src_tokens): + raise NotImplementedError + + def get_segment_labels(self, src_tokens): + segment_boundary = (src_tokens == self.separator_token).long() + segment_labels = ( + segment_boundary.cumsum(dim=1) + - segment_boundary + - (src_tokens == self.padding_idx).long() + ) + + return segment_labels + + def get_positions(self, src_tokens, segment_labels): + segment_positions = ( + torch.arange(src_tokens.shape[1]) + .to(src_tokens.device) + .repeat(src_tokens.shape[0], 1) + ) + segment_boundary = (src_tokens == self.separator_token).long() + _, col_idx = (segment_positions * segment_boundary).nonzero(as_tuple=True) + col_idx = torch.cat([torch.zeros(1).type_as(col_idx), col_idx]) + offset = torch.cat( + [ + torch.zeros(1).type_as(segment_boundary), + segment_boundary.sum(dim=1).cumsum(dim=0)[:-1], + ] + ) + segment_positions -= col_idx[segment_labels + offset.unsqueeze(1)] * ( + segment_labels != 0 + ) + + padding_mask = src_tokens.ne(self.padding_idx) + segment_positions = (segment_positions + 1) * padding_mask.type_as( + segment_positions + ) + self.padding_idx + + return segment_positions + + +class BertRanker(BaseRanker): + def __init__(self, args, task): + super(BertRanker, self).__init__(args, task) + + init_model = getattr(args, "pretrained_model", "") + self.joint_layers = nn.ModuleList() + if os.path.isfile(init_model): + print(f"initialize weight from {init_model}") + + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + os.path.dirname(init_model), + checkpoint_file=os.path.basename(init_model), + ) + + in_state_dict = x["models"][0].state_dict() + init_args = x["args"].model + + num_positional_emb = init_args.max_positions + task.dictionary.pad() + 1 + + # follow the setup in roberta + self.model = TransformerSentenceEncoder( + padding_idx=task.dictionary.pad(), + vocab_size=len(task.dictionary), + num_encoder_layers=getattr( + args, "encoder_layers", init_args.encoder_layers + ), + embedding_dim=init_args.encoder_embed_dim, + ffn_embedding_dim=init_args.encoder_ffn_embed_dim, + num_attention_heads=init_args.encoder_attention_heads, + dropout=init_args.dropout, + attention_dropout=init_args.attention_dropout, + activation_dropout=init_args.activation_dropout, + num_segments=2, # add language embeddings + max_seq_len=num_positional_emb, + offset_positions_by_padding=False, + encoder_normalize_before=True, + apply_bert_init=True, + activation_fn=init_args.activation_fn, + freeze_embeddings=args.freeze_embeddings, + n_trans_layers_to_freeze=args.n_trans_layers_to_freeze, + ) + + # still need to learn segment embeddings as we added a second language embedding + if args.freeze_embeddings: + for p in self.model.segment_embeddings.parameters(): + p.requires_grad = False + + update_init_roberta_model_state(in_state_dict) + print("loading weights from the pretrained model") + self.model.load_state_dict( + in_state_dict, strict=False + ) # ignore mismatch in language embeddings + + ffn_embedding_dim = init_args.encoder_ffn_embed_dim + num_attention_heads = init_args.encoder_attention_heads + dropout = init_args.dropout + attention_dropout = init_args.attention_dropout + activation_dropout = init_args.activation_dropout + activation_fn = init_args.activation_fn + + classifier_embed_dim = getattr( + args, "embed_dim", init_args.encoder_embed_dim + ) + if classifier_embed_dim != init_args.encoder_embed_dim: + self.transform_layer = nn.Linear( + init_args.encoder_embed_dim, classifier_embed_dim + ) + else: + self.model = TransformerSentenceEncoder( + padding_idx=task.dictionary.pad(), + vocab_size=len(task.dictionary), + num_encoder_layers=args.encoder_layers, + embedding_dim=args.embed_dim, + ffn_embedding_dim=args.ffn_embed_dim, + num_attention_heads=args.attention_heads, + dropout=args.dropout, + attention_dropout=args.attention_dropout, + activation_dropout=args.activation_dropout, + max_seq_len=task.max_positions() + if task.max_positions() + else args.tokens_per_sample, + num_segments=2, + offset_positions_by_padding=False, + encoder_normalize_before=args.encoder_normalize_before, + apply_bert_init=args.apply_bert_init, + activation_fn=args.activation_fn, + ) + + classifier_embed_dim = args.embed_dim + ffn_embedding_dim = args.ffn_embed_dim + num_attention_heads = args.attention_heads + dropout = args.dropout + attention_dropout = args.attention_dropout + activation_dropout = args.activation_dropout + activation_fn = args.activation_fn + + self.joint_classification = args.joint_classification + if args.joint_classification == "sent": + if args.joint_normalize_before: + self.joint_layer_norm = LayerNorm(classifier_embed_dim) + else: + self.joint_layer_norm = None + + self.joint_layers = nn.ModuleList( + [ + TransformerSentenceEncoderLayer( + embedding_dim=classifier_embed_dim, + ffn_embedding_dim=ffn_embedding_dim, + num_attention_heads=num_attention_heads, + dropout=dropout, + attention_dropout=attention_dropout, + activation_dropout=activation_dropout, + activation_fn=activation_fn, + ) + for _ in range(args.num_joint_layers) + ] + ) + + self.classifier = RobertaClassificationHead( + classifier_embed_dim, + classifier_embed_dim, + 1, # num_classes + "tanh", + args.classifier_dropout, + ) + + def forward(self, src_tokens, src_lengths): + segment_labels = self.get_segment_labels(src_tokens) + positions = self.get_positions(src_tokens, segment_labels) + + inner_states, _ = self.model( + tokens=src_tokens, + segment_labels=segment_labels, + last_state_only=True, + positions=positions, + ) + + return inner_states[-1].transpose(0, 1) # T x B x C -> B x T x C + + def sentence_forward(self, encoder_out, src_tokens=None, sentence_rep="head"): + # encoder_out: B x T x C + if sentence_rep == "head": + x = encoder_out[:, :1, :] + else: # 'meanpool', 'maxpool' + assert src_tokens is not None, "meanpool requires src_tokens input" + segment_labels = self.get_segment_labels(src_tokens) + padding_mask = src_tokens.ne(self.padding_idx) + encoder_mask = segment_labels * padding_mask.type_as(segment_labels) + + if sentence_rep == "meanpool": + ntokens = torch.sum(encoder_mask, dim=1, keepdim=True) + x = torch.sum( + encoder_out * encoder_mask.unsqueeze(2), dim=1, keepdim=True + ) / ntokens.unsqueeze(2).type_as(encoder_out) + else: # 'maxpool' + encoder_out[ + (encoder_mask == 0).unsqueeze(2).repeat(1, 1, encoder_out.shape[-1]) + ] = -float("inf") + x, _ = torch.max(encoder_out, dim=1, keepdim=True) + + if hasattr(self, "transform_layer"): + x = self.transform_layer(x) + + return x # B x 1 x C + + def joint_forward(self, x): + # x: T x B x C + if self.joint_layer_norm: + x = self.joint_layer_norm(x.transpose(0, 1)) + x = x.transpose(0, 1) + + for layer in self.joint_layers: + x, _ = layer(x, self_attn_padding_mask=None) + return x + + def classification_forward(self, x): + # x: B x T x C + return self.classifier(x) + + +@dataclass +class DiscriminativeNMTRerankerConfig(FairseqDataclass): + pretrained_model: str = field( + default="", metadata={"help": "pretrained model to load"} + ) + sentence_rep: SENTENCE_REP_CHOICES = field( + default="head", + metadata={ + "help": "method to transform the output of the transformer stack to a sentence-level representation" + }, + ) + + dropout: float = field(default=0.1, metadata={"help": "dropout probability"}) + attention_dropout: float = field( + default=0.0, metadata={"help": "dropout probability for attention weights"} + ) + activation_dropout: float = field( + default=0.0, metadata={"help": "dropout probability after activation in FFN"} + ) + classifier_dropout: float = field( + default=0.0, metadata={"help": "classifier dropout probability"} + ) + embed_dim: int = field(default=768, metadata={"help": "embedding dimension"}) + ffn_embed_dim: int = field( + default=2048, metadata={"help": "embedding dimension for FFN"} + ) + encoder_layers: int = field(default=12, metadata={"help": "num encoder layers"}) + attention_heads: int = field(default=8, metadata={"help": "num attention heads"}) + encoder_normalize_before: bool = field( + default=False, metadata={"help": "apply layernorm before each encoder block"} + ) + apply_bert_init: bool = field( + default=False, metadata={"help": "use custom param initialization for BERT"} + ) + activation_fn: ACTIVATION_FN_CHOICES = field( + default="relu", metadata={"help": "activation function to use"} + ) + freeze_embeddings: bool = field( + default=False, metadata={"help": "freeze embeddings in the pretrained model"} + ) + n_trans_layers_to_freeze: int = field( + default=0, + metadata={ + "help": "number of layers to freeze in the pretrained transformer model" + }, + ) + + # joint classfication + joint_classification: JOINT_CLASSIFICATION_CHOICES = field( + default="none", + metadata={"help": "method to compute joint features for classification"}, + ) + num_joint_layers: int = field( + default=1, metadata={"help": "number of joint layers"} + ) + joint_normalize_before: bool = field( + default=False, + metadata={"help": "apply layer norm on the input to the joint layer"}, + ) + + +@register_model( + "discriminative_nmt_reranker", dataclass=DiscriminativeNMTRerankerConfig +) +class DiscriminativeNMTReranker(BaseFairseqModel): + @classmethod + def build_model(cls, args, task): + model = BertRanker(args, task) + return DiscriminativeNMTReranker(args, model) + + def __init__(self, args, model): + super().__init__() + + self.model = model + self.sentence_rep = args.sentence_rep + self.joint_classification = args.joint_classification + + def forward(self, src_tokens, src_lengths, **kwargs): + return self.model(src_tokens, src_lengths) + + def sentence_forward(self, encoder_out, src_tokens): + return self.model.sentence_forward(encoder_out, src_tokens, self.sentence_rep) + + def joint_forward(self, x): + return self.model.joint_forward(x) + + def classification_forward(self, x): + return self.model.classification_forward(x) diff --git a/fairseq/examples/discriminative_reranking_nmt/scripts/prep_data.py b/fairseq/examples/discriminative_reranking_nmt/scripts/prep_data.py new file mode 100755 index 0000000000000000000000000000000000000000..7aa7d37edc2c3e4c1d293911b753abf2ef597a7e --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/scripts/prep_data.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python + +import argparse +from multiprocessing import Pool +from pathlib import Path + +import sacrebleu +import sentencepiece as spm + + +def read_text_file(filename): + with open(filename, "r") as f: + output = [line.strip() for line in f] + + return output + + +def get_bleu(in_sent, target_sent): + bleu = sacrebleu.corpus_bleu([in_sent], [[target_sent]]) + out = " ".join( + map(str, [bleu.score, bleu.sys_len, bleu.ref_len] + bleu.counts + bleu.totals) + ) + return out + + +def get_ter(in_sent, target_sent): + ter = sacrebleu.corpus_ter([in_sent], [[target_sent]]) + out = " ".join(map(str, [ter.score, ter.num_edits, ter.ref_length])) + return out + + +def init(sp_model): + global sp + sp = spm.SentencePieceProcessor() + sp.Load(sp_model) + + +def process(source_sent, target_sent, hypo_sent, metric): + source_bpe = " ".join(sp.EncodeAsPieces(source_sent)) + hypo_bpe = [" ".join(sp.EncodeAsPieces(h)) for h in hypo_sent] + + if metric == "bleu": + score_str = [get_bleu(h, target_sent) for h in hypo_sent] + else: # ter + score_str = [get_ter(h, target_sent) for h in hypo_sent] + + return source_bpe, hypo_bpe, score_str + + +def main(args): + assert ( + args.split.startswith("train") or args.num_shards == 1 + ), "--num-shards should be set to 1 for valid and test sets" + assert ( + args.split.startswith("train") + or args.split.startswith("valid") + or args.split.startswith("test") + ), "--split should be set to train[n]/valid[n]/test[n]" + + source_sents = read_text_file(args.input_source) + target_sents = read_text_file(args.input_target) + + num_sents = len(source_sents) + assert num_sents == len( + target_sents + ), f"{args.input_source} and {args.input_target} should have the same number of sentences." + + hypo_sents = read_text_file(args.input_hypo) + assert ( + len(hypo_sents) % args.beam == 0 + ), f"Number of hypotheses ({len(hypo_sents)}) cannot be divided by beam size ({args.beam})." + + hypo_sents = [ + hypo_sents[i : i + args.beam] for i in range(0, len(hypo_sents), args.beam) + ] + assert num_sents == len( + hypo_sents + ), f"{args.input_hypo} should contain {num_sents * args.beam} hypotheses but only has {len(hypo_sents) * args.beam}. (--beam={args.beam})" + + output_dir = args.output_dir / args.metric + for ns in range(args.num_shards): + print(f"processing shard {ns+1}/{args.num_shards}") + shard_output_dir = output_dir / f"split{ns+1}" + source_output_dir = shard_output_dir / "input_src" + hypo_output_dir = shard_output_dir / "input_tgt" + metric_output_dir = shard_output_dir / args.metric + + source_output_dir.mkdir(parents=True, exist_ok=True) + hypo_output_dir.mkdir(parents=True, exist_ok=True) + metric_output_dir.mkdir(parents=True, exist_ok=True) + + if args.n_proc > 1: + with Pool( + args.n_proc, initializer=init, initargs=(args.sentencepiece_model,) + ) as p: + output = p.starmap( + process, + [ + (source_sents[i], target_sents[i], hypo_sents[i], args.metric) + for i in range(ns, num_sents, args.num_shards) + ], + ) + else: + init(args.sentencepiece_model) + output = [ + process(source_sents[i], target_sents[i], hypo_sents[i], args.metric) + for i in range(ns, num_sents, args.num_shards) + ] + + with open(source_output_dir / f"{args.split}.bpe", "w") as s_o, open( + hypo_output_dir / f"{args.split}.bpe", "w" + ) as h_o, open(metric_output_dir / f"{args.split}.{args.metric}", "w") as m_o: + for source_bpe, hypo_bpe, score_str in output: + assert len(hypo_bpe) == len(score_str) + for h, m in zip(hypo_bpe, score_str): + s_o.write(f"{source_bpe}\n") + h_o.write(f"{h}\n") + m_o.write(f"{m}\n") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--input-source", type=Path, required=True) + parser.add_argument("--input-target", type=Path, required=True) + parser.add_argument("--input-hypo", type=Path, required=True) + parser.add_argument("--output-dir", type=Path, required=True) + parser.add_argument("--split", type=str, required=True) + parser.add_argument("--beam", type=int, required=True) + parser.add_argument("--sentencepiece-model", type=str, required=True) + parser.add_argument("--metric", type=str, choices=["bleu", "ter"], default="bleu") + parser.add_argument("--num-shards", type=int, default=1) + parser.add_argument("--n-proc", type=int, default=8) + + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/discriminative_reranking_nmt/tasks/__init__.py b/fairseq/examples/discriminative_reranking_nmt/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d78ca98708121261aa365738a65c051b5b40626 --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/tasks/__init__.py @@ -0,0 +1,6 @@ +from .discriminative_reranking_task import DiscriminativeRerankingNMTTask + + +__all__ = [ + "DiscriminativeRerankingNMTTask", +] diff --git a/fairseq/examples/discriminative_reranking_nmt/tasks/discriminative_reranking_task.py b/fairseq/examples/discriminative_reranking_nmt/tasks/discriminative_reranking_task.py new file mode 100644 index 0000000000000000000000000000000000000000..0e7fbba888c1ddd118da8238d644b4ab571177ff --- /dev/null +++ b/fairseq/examples/discriminative_reranking_nmt/tasks/discriminative_reranking_task.py @@ -0,0 +1,475 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +import itertools +import logging +import os + +import numpy as np +import torch + +from fairseq import metrics +from fairseq.data import ( + ConcatDataset, + ConcatSentencesDataset, + data_utils, + Dictionary, + IdDataset, + indexed_dataset, + NestedDictionaryDataset, + NumSamplesDataset, + NumelDataset, + PrependTokenDataset, + RawLabelDataset, + RightPadDataset, + SortDataset, + TruncateDataset, + TokenBlockDataset, +) +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.tasks import FairseqTask, register_task +from omegaconf import II, MISSING + + +EVAL_BLEU_ORDER = 4 +TARGET_METRIC_CHOICES = ChoiceEnum(["bleu", "ter"]) + +logger = logging.getLogger(__name__) + + +@dataclass +class DiscriminativeRerankingNMTConfig(FairseqDataclass): + data: str = field(default=MISSING, metadata={"help": "path to data directory"}) + num_data_splits: int = field( + default=1, metadata={"help": "total number of data splits"} + ) + no_shuffle: bool = field( + default=False, metadata={"help": "do not shuffle training data"} + ) + max_positions: int = field( + default=512, metadata={"help": "number of positional embeddings to learn"} + ) + include_src: bool = field( + default=False, metadata={"help": "include source sentence"} + ) + mt_beam: int = field(default=50, metadata={"help": "beam size of input hypotheses"}) + eval_target_metric: bool = field( + default=False, + metadata={"help": "evaluation with the target metric during validation"}, + ) + target_metric: TARGET_METRIC_CHOICES = field( + default="bleu", metadata={"help": "name of the target metric to optimize for"} + ) + train_subset: str = field( + default=II("dataset.train_subset"), + metadata={"help": "data subset to use for training (e.g. train, valid, test)"}, + ) + seed: int = field( + default=II("common.seed"), + metadata={"help": "pseudo random number generator seed"}, + ) + + +class RerankerScorer(object): + """Scores the target for a given (source (optional), target) input.""" + + def __init__(self, args, mt_beam): + self.mt_beam = mt_beam + + @torch.no_grad() + def generate(self, models, sample, **kwargs): + """Score a batch of translations.""" + net_input = sample["net_input"] + + assert len(models) == 1, "does not support model ensemble" + model = models[0] + + bs = net_input["src_tokens"].shape[0] + assert ( + model.joint_classification == "none" or bs % self.mt_beam == 0 + ), f"invalid batch size ({bs}) for joint classification with beam size ({self.mt_beam})" + + model.eval() + logits = model(**net_input) + + batch_out = model.sentence_forward(logits, net_input["src_tokens"]) + if model.joint_classification == "sent": + batch_out = model.joint_forward( + batch_out.view(self.mt_beam, bs // self.mt_beam, -1) + ) + scores = model.classification_forward( + batch_out.view(bs, 1, -1) + ) # input: B x T x C + + return scores + + +@register_task( + "discriminative_reranking_nmt", dataclass=DiscriminativeRerankingNMTConfig +) +class DiscriminativeRerankingNMTTask(FairseqTask): + """ + Translation rerank task. + The input can be either (src, tgt) sentence pairs or tgt sentence only. + """ + + cfg: DiscriminativeRerankingNMTConfig + + def __init__(self, cfg: DiscriminativeRerankingNMTConfig, data_dictionary=None): + super().__init__(cfg) + self.dictionary = data_dictionary + self._max_positions = cfg.max_positions + # args.tokens_per_sample = self._max_positions + # self.num_classes = 1 # for model + + @classmethod + def load_dictionary(cls, cfg, filename): + """Load the dictionary from the filename""" + dictionary = Dictionary.load(filename) + dictionary.add_symbol("") # for loading pretrained XLMR model + + return dictionary + + @classmethod + def setup_task(cls, cfg: DiscriminativeRerankingNMTConfig, **kwargs): + # load data dictionary (assume joint dictionary) + data_path = cfg.data + data_dict = cls.load_dictionary( + cfg, os.path.join(data_path, "input_src/dict.txt") + ) + + logger.info("[input] src dictionary: {} types".format(len(data_dict))) + + return DiscriminativeRerankingNMTTask(cfg, data_dict) + + def load_dataset(self, split, epoch=0, combine=False, **kwargs): + """Load a given dataset split (e.g., train, valid, test).""" + if self.cfg.data.endswith("1"): + data_shard = (epoch - 1) % self.cfg.num_data_splits + 1 + data_path = self.cfg.data[:-1] + str(data_shard) + else: + data_path = self.cfg.data + + def get_path(type, data_split): + return os.path.join(data_path, str(type), data_split) + + def make_dataset(type, dictionary, data_split, combine): + split_path = get_path(type, data_split) + + dataset = data_utils.load_indexed_dataset( + split_path, dictionary, combine=combine, + ) + return dataset + + def load_split(data_split, metric): + input_src = None + if self.cfg.include_src: + input_src = make_dataset( + "input_src", self.dictionary, data_split, combine=False + ) + assert input_src is not None, "could not find dataset: {}".format( + get_path("input_src", data_split) + ) + + input_tgt = make_dataset( + "input_tgt", self.dictionary, data_split, combine=False + ) + assert input_tgt is not None, "could not find dataset: {}".format( + get_path("input_tgt", data_split) + ) + + label_path = f"{get_path(metric, data_split)}.{metric}" + assert os.path.exists(label_path), f"could not find dataset: {label_path}" + + np_labels = np.loadtxt(label_path) + if self.cfg.target_metric == "ter": + np_labels = -np_labels + label = RawLabelDataset(np_labels) + + return input_src, input_tgt, label + + src_datasets = [] + tgt_datasets = [] + label_datasets = [] + + if split == self.cfg.train_subset: + for k in itertools.count(): + split_k = "train" + (str(k) if k > 0 else "") + prefix = os.path.join(data_path, "input_tgt", split_k) + if not indexed_dataset.dataset_exists(prefix, impl=None): + if k > 0: + break + else: + raise FileNotFoundError(f"Dataset not found: {prefix}") + input_src, input_tgt, label = load_split( + split_k, self.cfg.target_metric + ) + src_datasets.append(input_src) + tgt_datasets.append(input_tgt) + label_datasets.append(label) + else: + input_src, input_tgt, label = load_split(split, self.cfg.target_metric) + src_datasets.append(input_src) + tgt_datasets.append(input_tgt) + label_datasets.append(label) + + if len(tgt_datasets) == 1: + input_tgt, label = tgt_datasets[0], label_datasets[0] + if self.cfg.include_src: + input_src = src_datasets[0] + else: + input_tgt = ConcatDataset(tgt_datasets) + label = ConcatDataset(label_datasets) + if self.cfg.include_src: + input_src = ConcatDataset(src_datasets) + + input_tgt = TruncateDataset(input_tgt, self.cfg.max_positions) + if self.cfg.include_src: + input_src = PrependTokenDataset(input_src, self.dictionary.bos()) + input_src = TruncateDataset(input_src, self.cfg.max_positions) + src_lengths = NumelDataset(input_src, reduce=False) + src_tokens = ConcatSentencesDataset(input_src, input_tgt) + else: + src_tokens = PrependTokenDataset(input_tgt, self.dictionary.bos()) + src_lengths = NumelDataset(src_tokens, reduce=False) + + dataset = { + "id": IdDataset(), + "net_input": { + "src_tokens": RightPadDataset( + src_tokens, pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": src_lengths, + }, + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_tokens, reduce=True), + "target": label, + } + + dataset = NestedDictionaryDataset(dataset, sizes=[src_tokens.sizes],) + + assert len(dataset) % self.cfg.mt_beam == 0, ( + "dataset size (%d) is not a multiple of beam size (%d)" + % (len(dataset), self.cfg.mt_beam) + ) + + # no need to shuffle valid/test sets + if not self.cfg.no_shuffle and split == self.cfg.train_subset: + + # need to keep all hypothese together + start_idx = np.arange(0, len(dataset), self.cfg.mt_beam) + with data_utils.numpy_seed(self.cfg.seed + epoch): + np.random.shuffle(start_idx) + + idx = np.arange(0, self.cfg.mt_beam) + shuffle = np.tile(idx, (len(start_idx), 1)).reshape(-1) + np.tile( + start_idx, (self.cfg.mt_beam, 1) + ).transpose().reshape(-1) + + dataset = SortDataset(dataset, sort_order=[shuffle],) + + logger.info(f"Loaded {split} with #samples: {len(dataset)}") + + self.datasets[split] = dataset + return self.datasets[split] + + def build_dataset_for_inference(self, src_tokens, src_lengths, **kwargs): + assert not self.cfg.include_src or len(src_tokens[0]) == 2 + input_src = None + if self.cfg.include_src: + input_src = TokenBlockDataset( + [t[0] for t in src_tokens], + [l[0] for l in src_lengths], + block_size=None, # ignored for "eos" break mode + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode="eos", + ) + input_src = PrependTokenDataset(input_src, self.dictionary.bos()) + input_src = TruncateDataset(input_src, self.cfg.max_positions) + + input_tgt = TokenBlockDataset( + [t[-1] for t in src_tokens], + [l[-1] for l in src_lengths], + block_size=None, # ignored for "eos" break mode + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode="eos", + ) + input_tgt = TruncateDataset(input_tgt, self.cfg.max_positions) + if self.cfg.include_src: + src_tokens = ConcatSentencesDataset(input_src, input_tgt) + src_lengths = NumelDataset(input_src, reduce=False) + else: + input_tgt = PrependTokenDataset(input_tgt, self.dictionary.bos()) + src_tokens = input_tgt + src_lengths = NumelDataset(src_tokens, reduce=False) + + dataset = { + "id": IdDataset(), + "net_input": { + "src_tokens": RightPadDataset( + src_tokens, pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": src_lengths, + }, + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_tokens, reduce=True), + } + + return NestedDictionaryDataset(dataset, sizes=[src_tokens.sizes],) + + def build_model(self, cfg: FairseqDataclass): + return super().build_model(cfg) + + def build_generator(self, args): + return RerankerScorer(args, mt_beam=self.cfg.mt_beam) + + def max_positions(self): + return self._max_positions + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + def create_dummy_batch(self, device): + dummy_target = ( + torch.zeros(self.cfg.mt_beam, EVAL_BLEU_ORDER * 2 + 3).long().to(device) + if not self.cfg.eval_ter + else torch.zeros(self.cfg.mt_beam, 3).long().to(device) + ) + + return { + "id": torch.zeros(self.cfg.mt_beam, 1).long().to(device), + "net_input": { + "src_tokens": torch.zeros(self.cfg.mt_beam, 4).long().to(device), + "src_lengths": torch.ones(self.cfg.mt_beam, 1).long().to(device), + }, + "nsentences": 0, + "ntokens": 0, + "target": dummy_target, + } + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + if ignore_grad and sample is None: + sample = self.create_dummy_batch(model.device) + + return super().train_step( + sample, model, criterion, optimizer, update_num, ignore_grad + ) + + def valid_step(self, sample, model, criterion): + if sample is None: + sample = self.create_dummy_batch(model.device) + + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + + if not self.cfg.eval_target_metric: + return loss, sample_size, logging_output + + scores = logging_output["scores"] + + if self.cfg.target_metric == "bleu": + assert sample["target"].shape[1] == EVAL_BLEU_ORDER * 2 + 3, ( + "target does not contain enough information (" + + str(sample["target"].shape[1]) + + "for evaluating BLEU" + ) + + max_id = torch.argmax(scores, dim=1) + select_id = max_id + torch.arange( + 0, sample_size * self.cfg.mt_beam, self.cfg.mt_beam + ).to(max_id.device) + bleu_data = sample["target"][select_id, 1:].sum(0).data + + logging_output["_bleu_sys_len"] = bleu_data[0] + logging_output["_bleu_ref_len"] = bleu_data[1] + + for i in range(EVAL_BLEU_ORDER): + logging_output["_bleu_counts_" + str(i)] = bleu_data[2 + i] + logging_output["_bleu_totals_" + str(i)] = bleu_data[ + 2 + EVAL_BLEU_ORDER + i + ] + + elif self.cfg.target_metric == "ter": + assert sample["target"].shape[1] == 3, ( + "target does not contain enough information (" + + str(sample["target"].shape[1]) + + "for evaluating TER" + ) + + max_id = torch.argmax(scores, dim=1) + select_id = max_id + torch.arange( + 0, sample_size * self.cfg.mt_beam, self.cfg.mt_beam + ).to(max_id.device) + ter_data = sample["target"][select_id, 1:].sum(0).data + + logging_output["_ter_num_edits"] = -ter_data[0] + logging_output["_ter_ref_len"] = -ter_data[1] + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + if not self.cfg.eval_target_metric: + return + + def sum_logs(key): + return sum(log.get(key, 0) for log in logging_outputs) + + if self.cfg.target_metric == "bleu": + counts, totals = [], [] + for i in range(EVAL_BLEU_ORDER): + counts.append(sum_logs("_bleu_counts_" + str(i))) + totals.append(sum_logs("_bleu_totals_" + str(i))) + + if max(totals) > 0: + # log counts as numpy arrays -- log_scalar will sum them correctly + metrics.log_scalar("_bleu_counts", np.array(counts)) + metrics.log_scalar("_bleu_totals", np.array(totals)) + metrics.log_scalar("_bleu_sys_len", sum_logs("_bleu_sys_len")) + metrics.log_scalar("_bleu_ref_len", sum_logs("_bleu_ref_len")) + + def compute_bleu(meters): + import inspect + import sacrebleu + + fn_sig = inspect.getfullargspec(sacrebleu.compute_bleu)[0] + if "smooth_method" in fn_sig: + smooth = {"smooth_method": "exp"} + else: + smooth = {"smooth": "exp"} + bleu = sacrebleu.compute_bleu( + correct=meters["_bleu_counts"].sum, + total=meters["_bleu_totals"].sum, + sys_len=meters["_bleu_sys_len"].sum, + ref_len=meters["_bleu_ref_len"].sum, + **smooth, + ) + return round(bleu.score, 2) + + metrics.log_derived("bleu", compute_bleu) + elif self.cfg.target_metric == "ter": + num_edits = sum_logs("_ter_num_edits") + ref_len = sum_logs("_ter_ref_len") + + if ref_len > 0: + metrics.log_scalar("_ter_num_edits", num_edits) + metrics.log_scalar("_ter_ref_len", ref_len) + + def compute_ter(meters): + score = meters["_ter_num_edits"].sum / meters["_ter_ref_len"].sum + return round(score.item(), 2) + + metrics.log_derived("ter", compute_ter) diff --git a/fairseq/examples/fast_noisy_channel/README.md b/fairseq/examples/fast_noisy_channel/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f2631a8c34d11bdf7d351c6807b6fe415f5715e1 --- /dev/null +++ b/fairseq/examples/fast_noisy_channel/README.md @@ -0,0 +1,345 @@ +# Language Models not just for Pre-training: Fast Online Neural Noisy Channel Modeling + +## Introduction +- [Yee et al. (2019)](https://www.aclweb.org/anthology/D19-1571.pdf) introduce a simple and effective noisy channel modeling approach for neural machine translation. However, the noisy channel online decoding approach introduced in this paper is too slow to be practical. +- To address this, [Bhosale et al. (2020)](http://www.statmt.org/wmt20/pdf/2020.wmt-1.68.pdf) introduces 3 simple approximations to make this approach very fast and practical without much loss in accuracy. +- This README provides intructions on how to run online decoding or generation with the noisy channel modeling approach, including ways to make it very fast without much loss in accuracy. + +## Noisy Channel Modeling + +[Yee et al. (2019)](https://www.aclweb.org/anthology/D19-1571.pdf) applies the Bayes Rule to predict `P(y|x)`, the probability of the target `y` given the source `x`. +```P(y|x) = P(x|y) * P(y) / P(x)``` +- `P(x|y)` predicts the source `x` given the target `y` and is referred to as the **channel model** +- `P(y)` is a **language model** over the target `y` +- `P(x)` is generally not modeled since it is constant for all `y`. + +We use Transformer models to parameterize the direct model `P(y|x)`, the channel model `P(x|y)` and the language model `P(y)`. + +During online decoding with beam search, we generate the top `K2` candidates per beam and score them with the following linear combination of the channel model, the language model as well as the direct model scores. + +```(1 / t) * log(P(y|x) + (1 / s) * ( λ1 * log(P(x|y)) + λ2 * log(P(y) ) )``` +- `t` - Target Prefix Length +- `s` - Source Length +- `λ1` - Channel Model Weight +- `λ2` - Language Model Weight + +The top `beam_size` candidates based on the above combined scores are chosen to continue the beams in beam search. In beam search with a direct model alone, the scores from the direct model `P(y|x)` are used to choose the top candidates in beam search. + +This framework provides a great way to utlize strong target language models trained on large amounts of unlabeled data. Language models can prefer targets unrelated to the source, so we also need a channel model whose role is to ensure that the target preferred by the language model also translates back to the source. + +### Training Translation Models and Language Models + +For training Transformer models in fairseq for machine translation, refer to instructions [here](https://github.com/pytorch/fairseq/tree/main/examples/translation) + +For training Transformer models in fairseq for language modeling, refer to instructions [here](https://github.com/pytorch/fairseq/tree/main/examples/language_model) + +### Generation with Language Model for German-English translation with fairseq + +Here are instructions to generate using a direct model and a target-side language model. + +Note: +- Download and install fairseq as per instructions [here](https://github.com/pytorch/fairseq) +- Preprocess and binarize the dataset as per instructions in section [Test Data Preprocessing](#test-data-preprocessing) + +```sh +binarized_data=data_dir/binarized +direct_model=de_en_seed4.pt +lm_model=en_lm.pt +lm_data=lm_data +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed4.pt -O ${direct_model} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/transformer_lm.pt -O ${lm_model} +mkdir -p ${lm_data} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/lm_dict/dict.txt -O ${lm_data}/dict.txt + +k2=10 +lenpen=0.16 +lm_wt=0.14 +fairseq-generate ${binarized_data} \ + --user-dir examples/fast_noisy_channel \ + --beam 5 \ + --path ${direct_model} \ + --lm-model ${lm_model} \ + --lm-data ${lm_data} \ + --k2 ${k2} \ + --combine-method lm_only \ + --task noisy_channel_translation \ + --lenpen ${lenpen} \ + --lm-wt ${lm_wt} \ + --gen-subset valid \ + --remove-bpe \ + --fp16 \ + --batch-size 10 +``` +### Noisy Channel Generation for German-English translation with fairseq + +Here are instructions for noisy channel generation with a direct model, channel model and language model as explained in section [Noisy Channel Modeling](#noisy-channel-modeling). + +Note: +- Download and install fairseq as per instructions [here](https://github.com/pytorch/fairseq) +- Preprocess and binarize the dataset as per instructions in section [Test Data Preprocessing](#test-data-preprocessing) + +```sh +binarized_data=data_dir/binarized +direct_model=de_en_seed4.pt +lm_model=en_lm.pt +lm_data=lm_data +ch_model=en_de.big.seed4.pt +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed4.pt -O ${direct_model} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/transformer_lm.pt -O ${lm_model} +mkdir -p ${lm_data} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/lm_dict/dict.txt -O ${lm_data}/dict.txt +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big.seed4.pt -O ${ch_model} + +k2=10 +lenpen=0.21 +lm_wt=0.50 +bw_wt=0.30 +fairseq-generate ${binarized_data} \ + --user-dir examples/fast_noisy_channel \ + --beam 5 \ + --path ${direct_model} \ + --lm-model ${lm_model} \ + --lm-data ${lm_data} \ + --channel-model ${ch_model} \ + --k2 ${k2} \ + --combine-method noisy_channel \ + --task noisy_channel_translation \ + --lenpen ${lenpen} \ + --lm-wt ${lm_wt} \ + --ch-wt ${bw_wt} \ + --gen-subset test \ + --remove-bpe \ + --fp16 \ + --batch-size 1 +``` +## Fast Noisy Channel Modeling + +[Bhosale et al. (2020)](http://www.statmt.org/wmt20/pdf/2020.wmt-1.68.pdf) introduces 3 approximations that speed up online noisy channel decoding - +- Smaller channel models (`Tranformer Base` with 1 encoder and decoder layer each vs. `Transformer Big`) + - This involves training a channel model that is possibly smaller and less accurate in terms of BLEU than a channel model of the same size as the direct model. + - Since the role of the channel model is mainly to assign low scores to generations from the language model if they don't translate back to the source, we may not need the most accurate channel model for this purpose. +- Smaller output vocabulary size for the channel model (~30,000 -> ~1000) + - The channel model doesn't need to score the full output vocabulary, it just needs to score the source tokens, which are completely known. + - This is specified using the arguments `--channel-scoring-type src_vocab --top-k-vocab 500` + - This means that the output vocabulary for the channel model will be the source tokens for all examples in the batch and the top-K most frequent tokens in the vocabulary + - This reduces the memory consumption needed to store channel model scores significantly +- Smaller number of candidates (`k2`) scored per beam + - This is specified by reducing the argument `--k2` + + +### Fast Noisy Channel Generation for German-English translation with fairseq + +Here are instructions for **fast** noisy channel generation with a direct model, channel model and language model as explained in section [Fast Noisy Channel Modeling](#fast-noisy-channel-modeling). The main differences are that we use a smaller channel model, reduce `--k2`, set `--channel-scoring-type src_vocab --top-k-vocab 500` and increase the `--batch-size`. + +Note: +- Download and install fairseq as per instructions [here](https://github.com/pytorch/fairseq) +- Preprocess and binarize the dataset as per instructions in section [Test Data Preprocessing](#test-data-preprocessing) + +```sh +binarized_data=data_dir/binarized +direct_model=de_en_seed4.pt +lm_model=en_lm.pt +lm_data=lm_data +small_ch_model=en_de.base_1_1.seed4.pt +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed4.pt -O ${direct_model} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/transformer_lm.pt -O ${lm_model} +mkdir -p ${lm_data} +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/lm_dict/dict.txt -O ${lm_data}/dict.txt +wget https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base_1_1.seed4.pt -O ${small_ch_model} + +k2=3 +lenpen=0.23 +lm_wt=0.58 +bw_wt=0.26 +fairseq-generate ${binarized_data} \ + --user-dir examples/fast_noisy_channel \ + --beam 5 \ + --path ${direct_model} \ + --lm-model ${lm_model} \ + --lm-data ${lm_data} \ + --channel-model ${small_ch_model} \ + --k2 ${k2} \ + --combine-method noisy_channel \ + --task noisy_channel_translation \ + --lenpen ${lenpen} \ + --lm-wt ${lm_wt} \ + --ch-wt ${bw_wt} \ + --gen-subset test \ + --remove-bpe \ + --fp16 \ + --batch-size 50 \ + --channel-scoring-type src_vocab --top-k-vocab 500 +``` + +## Test Data Preprocessing + +For preprocessing and binarizing the test sets for Romanian-English and German-English translation, we use the following script - + +```sh +FAIRSEQ=/path/to/fairseq +cd $FAIRSEQ +SCRIPTS=$FAIRSEQ/mosesdecoder/scripts +if [ ! -d "${SCRIPTS}" ]; then + echo 'Cloning Moses github repository (for tokenization scripts)...' + git clone https://github.com/moses-smt/mosesdecoder.git +fi +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +NORMALIZE=$SCRIPTS/tokenizer/normalize-punctuation.perl + +s=de +t=en +test=wmt18 + +mkdir -p data_dir + +# Tokenization +if [ $s == "ro" ] ; then + # Note: Get normalise-romanian.py and remove-diacritics.py from + # https://github.com/rsennrich/wmt16-scripts/tree/master/preprocess + sacrebleu -t $test -l $s-$t --echo src | \ + $NORMALIZE -l $s | \ + python normalise-romanian.py | \ + python remove-diacritics.py | \ + $TOKENIZER -l $s -a -q > data_dir/$test.$s-$t.$s +else + sacrebleu -t $test -l $s-$t --echo src | perl $NORMALIZE -l $s | perl $TOKENIZER -threads 8 -a -l $s > data_dir/$test.$s-$t.$s +fi + +sacrebleu -t $test -l $s-$t --echo ref | perl $NORMALIZE -l $t | perl $TOKENIZER -threads 8 -a -l $t > data_dir/$test.$s-$t.$t + + +# Applying BPE +src_bpe_code=/path/to/source/language/bpe/code +tgt_bpe_code=/path/to/target/language/bpe/code +src_dict=/path/to/source/language/dict +tgt_dict=/path/to/target/language/dict + +FASTBPE=$FAIRSEQ/fastBPE +if [ ! -d "${FASTBPE}" ] ; then + git clone https://github.com/glample/fastBPE.git + # Follow compilation instructions at https://github.com/glample/fastBPE + g++ -std=c++11 -pthread -O3 fastBPE/main.cc -IfastBPE -o fast +fi + +${FASTBPE}/fast applybpe data_dir/bpe.$test.$s-$t.$s data_dir/$test.$s-$t.$s ${src_bpe_code} +${FASTBPE}/fast applybpe data_dir/bpe.$test.$s-$t.$s data_dir/$test.$s-$t.$s ${tgt_bpe_code} + +fairseq-preprocess -s $s -t $t \ + --testpref data_dir/bpe.$test.$s-$t \ + --destdir data_dir/binarized \ + --srcdict ${src_dict} \ + --tgtdict ${tgt_dict} +``` + +## Calculating BLEU + +```sh +DETOKENIZER=$SCRIPTS/tokenizer/detokenizer.perl +cat ${generation_output} | grep -P "^H" | sort -V | cut -f 3- | $DETOKENIZER -l $t -q -a | sacrebleu -t $test -l $s-$t +``` + + +## Romanian-English Translation + +The direct and channel models are trained using bitext data (WMT16) combined with backtranslated data (The monolingual data used for backtranslation comes from http://data.statmt.org/rsennrich/wmt16_backtranslations/ (Sennrich et al., 2016c)) + +The backtranslated data is generated using an ensemble of 3 English-Romanian models trained on bitext training data (WMT16) with unrestricted sampling. + +### BPE Codes and Dictionary + +We learn a joint BPE vocabulary of 18K types on the bitext training data which is used for both the source and target. +||Path| +|----------|------| +| BPE Code | [joint_bpe_18k](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/bpe_18k) | +| Dictionary | [dict](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/dict) | + +### Direct Models +For Ro-En with backtranslation, the direct and channel models use a Transformer-Big architecture. + +| Seed | Model | +|----|----| +| 2 | [ro_en_seed2.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/direct_models/seed2.pt) +| 4 | [ro_en_seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/direct_models/seed4.pt) +| 6 | [ro_en_seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/direct_models/seed6.pt) + +### Channel Models +For channel models, we follow the same steps as for the direct models. But backtranslated data is generated in the opposite direction using [this Romanian monolingual data](http://data.statmt.org/rsennrich/wmt16_backtranslations/). +The best lenpen, LM weight and CH weight are obtained by sweeping over the validation set (wmt16/dev) using beam 5. +| Model Size | Lenpen | LM Weight | CH Weight | Seed 2 | Seed 4 | Seed 6 | +|----|----|----|----|----|----|----| +| `big` | 0.84 | 0.64 | 0.56 | [big.seed2.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/big.seed2.pt) | [big.seed2.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/big.seed2.pt) | [big.seed2.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/big.seed2.pt) | +| `base_1_1` | 0.63 | 0.40 | 0.37 | [base_1_1.seed2.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/base_1_1.seed2.pt) | [base_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/base_1_1.seed4.pt) | [base_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/channel_models/base_1_1.seed6.pt) | + +### Language Model +The model is trained on de-duplicated English Newscrawl data from 2007-2018 comprising 186 million sentences or 4.5B words after normalization and tokenization. +| | Path | +|----|----| +| `--lm-model` | [transformer_en_lm](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/lm_model/transformer_lm.pt) | +| `--lm-data` | [lm_data](https://dl.fbaipublicfiles.com/fast_noisy_channel/ro_en/lm_model/lm_dict) + +## German-English Translation + +### BPE Codes and Dictionaries + +| | Path| +|----------|------| +| Source BPE Code | [de_bpe_code_24K](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/de_bpe_code_24K) | +| Target BPE Code | [en_bpe_code_24K](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/en_bpe_code_24K) +| Source Dictionary | [de_dict](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/de_dict) | +| Target Dictionary | [en_dict](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/en_dict) | + +### Direct Models +We train on WMT’19 training data. Following [Ng et al., 2019](http://statmt.org/wmt19/pdf/53/WMT33.pdf), we apply language identification filtering and remove sentences longer than 250 tokens as well as sentence pairs with a source/target length ratio exceeding 1.5. This results in 26.8M sentence pairs. +We use the Transformer-Big architecture for the direct model. + +| Seed | Model | +|:----:|----| +| 4 | [de_en_seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed4.pt) +| 5 | [de_en_seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed5.pt) +| 6 | [de_en_seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/direct_models/seed6.pt) + +### Channel Models + +We train on WMT’19 training data. Following [Ng et al., 2019](http://statmt.org/wmt19/pdf/53/WMT33.pdf), we apply language identification filtering and remove sentences longer than 250 tokens as well as sentence pairs with a source/target length ratio exceeding 1.5. This results in 26.8M sentence pairs. + +| Model Size | Seed 4 | Seed 5 | Seed 6 | +|----|----|----|----| +| `big` | [big.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big.seed4.pt) | [big.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big.seed5.pt) | [big.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big.seed6.pt) | +| `big_1_1` | [big_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big_1_1.seed4.pt) | [big_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big_1_1.seed5.pt) | [big_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/big_1_1.seed6.pt) | +| `base` | [base.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base.seed4.pt) | [base.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base.seed5.pt) | [base.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base.seed6.pt) | +| `base_1_1` | [base_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base_1_1.seed4.pt) | [base_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base_1_1.seed5.pt) | [base_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/base_1_1.seed6.pt) | +| `half` | [half.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half.seed4.pt) | [half.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half.seed5.pt) | [half.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half.seed6.pt) | +| `half_1_1` | [half_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half_1_1.seed4.pt) | [half_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half_1_1.seed5.pt) | [half_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/half_1_1.seed6.pt) | +| `quarter` | [quarter.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter.seed4.pt) | [quarter.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter.seed5.pt) | [quarter.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter.seed6.pt) | +| `quarter_1_1` | [quarter_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter_1_1.seed4.pt) | [quarter_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter_1_1.seed5.pt) | [quarter_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/quarter_1_1.seed6.pt) | +| `8th` | [8th.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th.seed4.pt) | [8th.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th.seed5.pt) | [8th.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th.seed6.pt) | +| `8th_1_1` | [8th_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th_1_1.seed4.pt) | [8th_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th_1_1.seed5.pt) | [8th_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/8th_1_1.seed6.pt) | +| `16th` | [16th.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th.seed4.pt) | [16th.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th.seed5.pt) | [16th.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th.seed6.pt) | +| `16th_1_1` | [16th_1_1.seed4.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th_1_1.seed4.pt) | [16th_1_1.seed5.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th_1_1.seed5.pt) | [16th_1_1.seed6.pt](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/channel_models/16th_1_1.seed6.pt) | + +### Language Model +The model is trained on de-duplicated English Newscrawl data from 2007-2018 comprising 186 million sentences or 4.5B words after normalization and tokenization. +| | Path | +|----|----| +| `--lm-model` | [transformer_en_lm](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/transformer_lm.pt) | +| `--lm-data` | [lm_data](https://dl.fbaipublicfiles.com/fast_noisy_channel/de_en/lm_model/lm_dict/) + + +## Citation + +```bibtex +@inproceedings{bhosale2020language, + title={Language Models not just for Pre-training: Fast Online Neural Noisy Channel Modeling}, + author={Shruti Bhosale and Kyra Yee and Sergey Edunov and Michael Auli}, + booktitle={Proceedings of the Fifth Conference on Machine Translation (WMT)}, + year={2020}, +} + +@inproceedings{yee2019simple, + title={Simple and Effective Noisy Channel Modeling for Neural Machine Translation}, + author={Yee, Kyra and Dauphin, Yann and Auli, Michael}, + booktitle={Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)}, + pages={5700--5705}, + year={2019} +} +``` diff --git a/fairseq/examples/fast_noisy_channel/__init__.py b/fairseq/examples/fast_noisy_channel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b248c3a24e12ad3da885a7f328c714942de2e6b --- /dev/null +++ b/fairseq/examples/fast_noisy_channel/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import noisy_channel_translation # noqa +from . import noisy_channel_sequence_generator # noqa +from . import noisy_channel_beam_search # noqa diff --git a/fairseq/examples/fast_noisy_channel/noisy_channel_beam_search.py b/fairseq/examples/fast_noisy_channel/noisy_channel_beam_search.py new file mode 100644 index 0000000000000000000000000000000000000000..23869ebcd0c438f36e310c8ccddd3b5c07a71182 --- /dev/null +++ b/fairseq/examples/fast_noisy_channel/noisy_channel_beam_search.py @@ -0,0 +1,71 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq.search import Search + + +class NoisyChannelBeamSearch(Search): + + def __init__(self, tgt_dict): + super().__init__(tgt_dict) + self.fw_scores_buf = None + self.lm_scores_buf = None + + def _init_buffers(self, t): + # super()._init_buffers(t) + if self.fw_scores_buf is None: + self.scores_buf = t.new() + self.indices_buf = torch.LongTensor().to(device=t.device) + self.beams_buf = torch.LongTensor().to(device=t.device) + self.fw_scores_buf = t.new() + self.lm_scores_buf = t.new() + + def combine_fw_bw(self, combine_method, fw_cum, bw, step): + if combine_method == "noisy_channel": + fw_norm = fw_cum.div(step + 1) + lprobs = bw + fw_norm + elif combine_method == "lm_only": + lprobs = bw + fw_cum + + return lprobs + + def step(self, step, fw_lprobs, scores, bw_lprobs, lm_lprobs, combine_method): + self._init_buffers(fw_lprobs) + bsz, beam_size, vocab_size = fw_lprobs.size() + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + fw_lprobs = fw_lprobs[:, ::beam_size, :].contiguous() + bw_lprobs = bw_lprobs[:, ::beam_size, :].contiguous() + # nothing to add since we are at the first step + fw_lprobs_cum = fw_lprobs + + else: + # make probs contain cumulative scores for each hypothesis + raw_scores = (scores[:, :, step - 1].unsqueeze(-1)) + fw_lprobs_cum = (fw_lprobs.add(raw_scores)) + + combined_lprobs = self.combine_fw_bw(combine_method, fw_lprobs_cum, bw_lprobs, step) + + # choose the top k according to the combined noisy channel model score + torch.topk( + combined_lprobs.view(bsz, -1), + k=min( + # Take the best 2 x beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size * 2, + combined_lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ), + out=(self.scores_buf, self.indices_buf), + ) + # save corresponding fw and lm scores + self.fw_scores_buf = torch.gather(fw_lprobs_cum.view(bsz, -1), 1, self.indices_buf) + self.lm_scores_buf = torch.gather(lm_lprobs.view(bsz, -1), 1, self.indices_buf) + # Project back into relative indices and beams + self.beams_buf = self.indices_buf // vocab_size + self.indices_buf.fmod_(vocab_size) + return self.scores_buf, self.fw_scores_buf, self.lm_scores_buf, self.indices_buf, self.beams_buf diff --git a/fairseq/examples/fast_noisy_channel/noisy_channel_sequence_generator.py b/fairseq/examples/fast_noisy_channel/noisy_channel_sequence_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..ea8fae98e87e9f3e69bc51987703a6429eb0c92a --- /dev/null +++ b/fairseq/examples/fast_noisy_channel/noisy_channel_sequence_generator.py @@ -0,0 +1,842 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, Optional + +import math +import numpy as np + +import torch +import torch.nn.functional as F +from torch import Tensor + +from .noisy_channel_beam_search import NoisyChannelBeamSearch +from fairseq.sequence_generator import EnsembleModel + + +class NoisyChannelSequenceGenerator(object): + def __init__( + self, + combine_method, + tgt_dict, + src_dict=None, + beam_size=1, + max_len_a=0, + max_len_b=200, + min_len=1, + len_penalty=1.0, + unk_penalty=0.0, + retain_dropout=False, + temperature=1.0, + match_source_len=False, + no_repeat_ngram_size=0, + normalize_scores=True, + channel_models=None, + k2=10, + ch_weight=1.0, + channel_scoring_type='log_norm', + top_k_vocab=0, + lm_models=None, + lm_dict=None, + lm_weight=1.0, + normalize_lm_scores_by_tgt_len=False, + ): + """Generates translations of a given source sentence, + using beam search with noisy channel decoding. + + Args: + combine_method (string, optional): Method to combine direct, LM and + channel model scores (default: None) + tgt_dict (~fairseq.data.Dictionary): target dictionary + src_dict (~fairseq.data.Dictionary): source dictionary + beam_size (int, optional): beam width (default: 1) + max_len_a/b (int, optional): generate sequences of maximum length + ax + b, where x is the source length + min_len (int, optional): the minimum length of the generated output + (not including end-of-sentence) + len_penalty (float, optional): length penalty, where <1.0 favors + shorter, >1.0 favors longer sentences (default: 1.0) + unk_penalty (float, optional): unknown word penalty, where <0 + produces more unks, >0 produces fewer (default: 0.0) + retain_dropout (bool, optional): use dropout when generating + (default: False) + temperature (float, optional): temperature, where values + >1.0 produce more uniform samples and values <1.0 produce + sharper samples (default: 1.0) + match_source_len (bool, optional): outputs should match the source + length (default: False) + no_repeat_ngram_size (int, optional): Size of n-grams that we avoid + repeating in the generation (default: 0) + normalize_scores (bool, optional): normalize scores by the length + of the output (default: True) + channel_models (List[~fairseq.models.FairseqModel]): ensemble of models + translating from the target to the source + k2 (int, optional): Top K2 candidates to score per beam at each step (default:10) + ch_weight (int, optional): Weight associated with the channel model score + assuming that the direct model score has weight 1.0 (default: 1.0) + channel_scoring_type (str, optional): String specifying how to score + the channel model (default: 'log_norm') + top_k_vocab (int, optional): If `channel_scoring_type` is `'src_vocab'` or + `'src_vocab_batched'`, then this parameter specifies the number of + most frequent tokens to include in the channel model output vocabulary, + in addition to the source tokens in the input batch (default: 0) + lm_models (List[~fairseq.models.FairseqModel]): ensemble of models + generating text in the target language + lm_dict (~fairseq.data.Dictionary): LM Model dictionary + lm_weight (int, optional): Weight associated with the LM model score + assuming that the direct model score has weight 1.0 (default: 1.0) + normalize_lm_scores_by_tgt_len (bool, optional): Should we normalize LM scores + by the target length? By default, we normalize the combination of + LM and channel model scores by the source length + """ + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.eos = tgt_dict.eos() + self.vocab_size = len(tgt_dict) + self.beam_size = beam_size + # the max beam size is the dictionary size - 1, since we never select pad + self.beam_size = min(beam_size, self.vocab_size - 1) + self.max_len_a = max_len_a + self.max_len_b = max_len_b + self.min_len = min_len + self.normalize_scores = normalize_scores + self.len_penalty = len_penalty + self.unk_penalty = unk_penalty + self.retain_dropout = retain_dropout + self.temperature = temperature + self.match_source_len = match_source_len + self.no_repeat_ngram_size = no_repeat_ngram_size + self.channel_models = channel_models + self.src_dict = src_dict + self.tgt_dict = tgt_dict + self.combine_method = combine_method + self.k2 = k2 + self.ch_weight = ch_weight + self.channel_scoring_type = channel_scoring_type + self.top_k_vocab = top_k_vocab + self.lm_models = lm_models + self.lm_dict = lm_dict + self.lm_weight = lm_weight + self.log_softmax_fn = torch.nn.LogSoftmax(dim=1) + self.normalize_lm_scores_by_tgt_len = normalize_lm_scores_by_tgt_len + + self.share_tgt_dict = (self.lm_dict == self.tgt_dict) + self.tgt_to_lm = make_dict2dict(tgt_dict, lm_dict) + + self.ch_scoring_bsz = 3072 + + assert temperature > 0, '--temperature must be greater than 0' + + self.search = NoisyChannelBeamSearch(tgt_dict) + + @torch.no_grad() + def generate( + self, + models, + sample, + prefix_tokens=None, + bos_token=None, + **kwargs + ): + """Generate a batch of translations. + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + sample (dict): batch + prefix_tokens (torch.LongTensor, optional): force decoder to begin + with these tokens + """ + model = EnsembleModel(models) + incremental_states = torch.jit.annotate( + List[Dict[str, Dict[str, Optional[Tensor]]]], + [ + torch.jit.annotate(Dict[str, Dict[str, Optional[Tensor]]], {}) + for i in range(model.models_size) + ], + ) + if not self.retain_dropout: + model.eval() + + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in sample['net_input'].items() + if k != 'prev_output_tokens' + } + src_tokens = encoder_input['src_tokens'] + src_lengths_no_eos = (src_tokens.ne(self.eos) & src_tokens.ne(self.pad)).long().sum(dim=1) + input_size = src_tokens.size() + # batch dimension goes first followed by source lengths + bsz = input_size[0] + src_len = input_size[1] + beam_size = self.beam_size + + if self.match_source_len: + max_len = src_lengths_no_eos.max().item() + else: + max_len = min( + int(self.max_len_a * src_len + self.max_len_b), + # exclude the EOS marker + model.max_decoder_positions() - 1, + ) + + # compute the encoder output for each beam + encoder_outs = model.forward_encoder(encoder_input) + new_order = torch.arange(bsz).view(-1, 1).repeat(1, beam_size).view(-1) + new_order = new_order.to(src_tokens.device).long() + encoder_outs = model.reorder_encoder_out(encoder_outs, new_order) + + src_lengths = encoder_input['src_lengths'] + # initialize buffers + scores = src_tokens.new(bsz * beam_size, max_len + 1).float().fill_(0) + lm_prefix_scores = src_tokens.new(bsz * beam_size).float().fill_(0) + + scores_buf = scores.clone() + tokens = src_tokens.new(bsz * beam_size, max_len + 2).long().fill_(self.pad) + tokens_buf = tokens.clone() + tokens[:, 0] = self.eos if bos_token is None else bos_token + + # reorder source tokens so they may be used as a reference in generating P(S|T) + src_tokens = reorder_all_tokens(src_tokens, src_lengths, self.src_dict.eos_index) + + src_tokens = src_tokens.repeat(1, beam_size).view(-1, src_len) + src_lengths = src_lengths.view(bsz, -1).repeat(1, beam_size).view(bsz*beam_size, -1) + + attn, attn_buf = None, None + nonpad_idxs = None + + # The cands_to_ignore indicates candidates that should be ignored. + # For example, suppose we're sampling and have already finalized 2/5 + # samples. Then the cands_to_ignore would mark 2 positions as being ignored, + # so that we only finalize the remaining 3 samples. + cands_to_ignore = src_tokens.new_zeros(bsz, beam_size).eq(-1) # forward and backward-compatible False mask + + # list of completed sentences + finalized = [[] for i in range(bsz)] + finished = [False for i in range(bsz)] + num_remaining_sent = bsz + + # number of candidate hypos per step + cand_size = 2 * beam_size # 2 x beam size in case half are EOS + + # offset arrays for converting between different indexing schemes + bbsz_offsets = (torch.arange(0, bsz) * beam_size).unsqueeze(1).type_as(tokens) + cand_offsets = torch.arange(0, cand_size).type_as(tokens) + + # helper function for allocating buffers on the fly + buffers = {} + + def buffer(name, type_of=tokens): # noqa + if name not in buffers: + buffers[name] = type_of.new() + return buffers[name] + + def is_finished(sent, step, unfin_idx): + """ + Check whether we've finished generation for a given sentence, by + comparing the worst score among finalized hypotheses to the best + possible score among unfinalized hypotheses. + """ + assert len(finalized[sent]) <= beam_size + if len(finalized[sent]) == beam_size: + return True + return False + + def finalize_hypos(step, bbsz_idx, eos_scores, combined_noisy_channel_eos_scores): + """ + Finalize the given hypotheses at this step, while keeping the total + number of finalized hypotheses per sentence <= beam_size. + + Note: the input must be in the desired finalization order, so that + hypotheses that appear earlier in the input are preferred to those + that appear later. + + Args: + step: current time step + bbsz_idx: A vector of indices in the range [0, bsz*beam_size), + indicating which hypotheses to finalize + eos_scores: A vector of the same size as bbsz_idx containing + fw scores for each hypothesis + combined_noisy_channel_eos_scores: A vector of the same size as bbsz_idx containing + combined noisy channel scores for each hypothesis + """ + assert bbsz_idx.numel() == eos_scores.numel() + + # clone relevant token and attention tensors + tokens_clone = tokens.index_select(0, bbsz_idx) + tokens_clone = tokens_clone[:, 1:step + 2] # skip the first index, which is EOS + assert not tokens_clone.eq(self.eos).any() + tokens_clone[:, step] = self.eos + attn_clone = attn.index_select(0, bbsz_idx)[:, :, 1:step+2] if attn is not None else None + + # compute scores per token position + pos_scores = scores.index_select(0, bbsz_idx)[:, :step+1] + pos_scores[:, step] = eos_scores + # convert from cumulative to per-position scores + pos_scores[:, 1:] = pos_scores[:, 1:] - pos_scores[:, :-1] + + # normalize sentence-level scores + if self.normalize_scores: + combined_noisy_channel_eos_scores /= (step + 1) ** self.len_penalty + + cum_unfin = [] + prev = 0 + for f in finished: + if f: + prev += 1 + else: + cum_unfin.append(prev) + + sents_seen = set() + for i, (idx, score) in enumerate(zip(bbsz_idx.tolist(), combined_noisy_channel_eos_scores.tolist())): + unfin_idx = idx // beam_size + sent = unfin_idx + cum_unfin[unfin_idx] + + sents_seen.add((sent, unfin_idx)) + + if self.match_source_len and step > src_lengths_no_eos[unfin_idx]: + score = -math.inf + + def get_hypo(): + + if attn_clone is not None: + # remove padding tokens from attn scores + hypo_attn = attn_clone[i][nonpad_idxs[sent]] + _, alignment = hypo_attn.max(dim=0) + else: + hypo_attn = None + alignment = None + + return { + 'tokens': tokens_clone[i], + 'score': score, + 'attention': hypo_attn, # src_len x tgt_len + 'alignment': alignment, + 'positional_scores': pos_scores[i], + } + + if len(finalized[sent]) < beam_size: + finalized[sent].append(get_hypo()) + + newly_finished = [] + for sent, unfin_idx in sents_seen: + # check termination conditions for this sentence + if not finished[sent] and is_finished(sent, step, unfin_idx): + finished[sent] = True + newly_finished.append(unfin_idx) + return newly_finished + + def noisy_channel_rescoring(lprobs, beam_size, bsz, src_tokens, tokens, k): + """Rescore the top k hypothesis from each beam using noisy channel modeling + Returns: + new_fw_lprobs: the direct model probabilities after pruning the top k + new_ch_lm_lprobs: the combined channel and language model probabilities + new_lm_lprobs: the language model probabilities after pruning the top k + """ + with torch.no_grad(): + lprobs_size = lprobs.size() + if prefix_tokens is not None and step < prefix_tokens.size(1): + probs_slice = lprobs.view(bsz, -1, lprobs.size(-1))[:, 0, :] + cand_scores = torch.gather( + probs_slice, dim=1, + index=prefix_tokens[:, step].view(-1, 1).data + ).expand(-1, beam_size).contiguous().view(bsz*beam_size, 1) + cand_indices = prefix_tokens[:, step].view(-1, 1).expand(bsz, beam_size).data.contiguous().view(bsz*beam_size, 1) + + # need to calculate and save fw and lm probs for prefix tokens + fw_top_k = cand_scores + fw_top_k_idx = cand_indices + k = 1 + else: + # take the top k best words for every sentence in batch*beam + fw_top_k, fw_top_k_idx = torch.topk(lprobs.view(beam_size*bsz, -1), k=k) + eos_idx = torch.nonzero(fw_top_k_idx.view(bsz*beam_size*k, -1) == self.eos)[:, 0] + ch_scores = fw_top_k.new_full((beam_size*bsz*k, ), 0) + src_size = torch.sum(src_tokens[:, :] != self.src_dict.pad_index, dim=1, keepdim=True, dtype=fw_top_k.dtype) + + if self.combine_method != "lm_only": + temp_src_tokens_full = src_tokens[:, :].repeat(1, k).view(bsz*beam_size*k, -1) + not_padding = temp_src_tokens_full[:, 1:] != self.src_dict.pad_index + cur_tgt_size = step+2 + + # add eos to all candidate sentences except those that already end in eos + eos_tokens = tokens[:, 0].repeat(1, k).view(-1, 1) + eos_tokens[eos_idx] = self.tgt_dict.pad_index + + if step == 0: + channel_input = torch.cat((fw_top_k_idx.view(-1, 1), eos_tokens), 1) + else: + # move eos from beginning to end of target sentence + channel_input = torch.cat((tokens[:, 1:step + 1].repeat(1, k).view(-1, step), fw_top_k_idx.view(-1, 1), eos_tokens), 1) + + ch_input_lengths = torch.tensor(np.full(channel_input.size(0), cur_tgt_size)) + ch_input_lengths[eos_idx] = cur_tgt_size-1 + if self.channel_scoring_type == "unnormalized": + ch_encoder_output = channel_model.encoder(channel_input, src_lengths=ch_input_lengths) + ch_decoder_output, _ = channel_model.decoder(temp_src_tokens_full, encoder_out=ch_encoder_output, features_only=True) + del ch_encoder_output + ch_intermed_scores = channel_model.decoder.unnormalized_scores_given_target(ch_decoder_output, target_ids=temp_src_tokens_full[:, 1:]) + ch_intermed_scores = ch_intermed_scores.float() + ch_intermed_scores *= not_padding.float() + ch_scores = torch.sum(ch_intermed_scores, dim=1) + elif self.channel_scoring_type == "k2_separate": + for k_idx in range(k): + k_eos_tokens = eos_tokens[k_idx::k, :] + if step == 0: + k_ch_input = torch.cat((fw_top_k_idx[:, k_idx:k_idx+1], k_eos_tokens), 1) + else: + # move eos from beginning to end of target sentence + k_ch_input = torch.cat((tokens[:, 1:step + 1], fw_top_k_idx[:, k_idx:k_idx+1], k_eos_tokens), 1) + k_ch_input_lengths = ch_input_lengths[k_idx::k] + k_ch_output = channel_model(k_ch_input, k_ch_input_lengths, src_tokens) + k_ch_lprobs = channel_model.get_normalized_probs(k_ch_output, log_probs=True) + k_ch_intermed_scores = torch.gather(k_ch_lprobs[:, :-1, :], 2, src_tokens[:, 1:].unsqueeze(2)).squeeze(2) + k_ch_intermed_scores *= not_padding.float() + ch_scores[k_idx::k] = torch.sum(k_ch_intermed_scores, dim=1) + elif self.channel_scoring_type == "src_vocab": + ch_encoder_output = channel_model.encoder(channel_input, src_lengths=ch_input_lengths) + ch_decoder_output, _ = channel_model.decoder(temp_src_tokens_full, encoder_out=ch_encoder_output, features_only=True) + + del ch_encoder_output + ch_lprobs = normalized_scores_with_batch_vocab( + channel_model.decoder, + ch_decoder_output, src_tokens, k, bsz, beam_size, + self.src_dict.pad_index, top_k=self.top_k_vocab) + ch_scores = torch.sum(ch_lprobs, dim=1) + elif self.channel_scoring_type == "src_vocab_batched": + ch_bsz_size = temp_src_tokens_full.shape[0] + ch_lprobs_list = [None] * len(range(0, ch_bsz_size, self.ch_scoring_bsz)) + for i, start_idx in enumerate(range(0, ch_bsz_size, self.ch_scoring_bsz)): + end_idx = min(start_idx + self.ch_scoring_bsz, ch_bsz_size) + temp_src_tokens_full_batch = temp_src_tokens_full[start_idx:end_idx, :] + channel_input_batch = channel_input[start_idx:end_idx, :] + ch_input_lengths_batch = ch_input_lengths[start_idx:end_idx] + ch_encoder_output_batch = channel_model.encoder(channel_input_batch, src_lengths=ch_input_lengths_batch) + ch_decoder_output_batch, _ = channel_model.decoder(temp_src_tokens_full_batch, encoder_out=ch_encoder_output_batch, features_only=True) + ch_lprobs_list[i] = normalized_scores_with_batch_vocab( + channel_model.decoder, + ch_decoder_output_batch, src_tokens, k, bsz, beam_size, + self.src_dict.pad_index, top_k=self.top_k_vocab, + start_idx=start_idx, end_idx=end_idx) + ch_lprobs = torch.cat(ch_lprobs_list, dim=0) + ch_scores = torch.sum(ch_lprobs, dim=1) + else: + ch_output = channel_model(channel_input, ch_input_lengths, temp_src_tokens_full) + ch_lprobs = channel_model.get_normalized_probs(ch_output, log_probs=True) + ch_intermed_scores = torch.gather(ch_lprobs[:, :-1, :], 2, temp_src_tokens_full[:, 1:].unsqueeze(2)).squeeze().view(bsz*beam_size*k, -1) + ch_intermed_scores *= not_padding.float() + ch_scores = torch.sum(ch_intermed_scores, dim=1) + + else: + cur_tgt_size = 0 + ch_scores = ch_scores.view(bsz*beam_size, k) + expanded_lm_prefix_scores = lm_prefix_scores.unsqueeze(1).expand(-1, k).flatten() + + if self.share_tgt_dict: + lm_scores = get_lm_scores(lm, tokens[:, :step + 1].view(-1, step+1), lm_incremental_states, fw_top_k_idx.view(-1, 1), torch.tensor(np.full(tokens.size(0), step+1)), k) + else: + new_lm_input = dict2dict(tokens[:, :step + 1].view(-1, step+1), self.tgt_to_lm) + new_cands = dict2dict(fw_top_k_idx.view(-1, 1), self.tgt_to_lm) + lm_scores = get_lm_scores(lm, new_lm_input, lm_incremental_states, new_cands, torch.tensor(np.full(tokens.size(0), step+1)), k) + + lm_scores.add_(expanded_lm_prefix_scores) + ch_lm_scores = combine_ch_lm(self.combine_method, ch_scores, lm_scores, src_size, cur_tgt_size) + # initialize all as min value + new_fw_lprobs = ch_scores.new(lprobs_size).fill_(-1e17).view(bsz*beam_size, -1) + new_ch_lm_lprobs = ch_scores.new(lprobs_size).fill_(-1e17).view(bsz*beam_size, -1) + new_lm_lprobs = ch_scores.new(lprobs_size).fill_(-1e17).view(bsz*beam_size, -1) + new_fw_lprobs[:, self.pad] = -math.inf + new_ch_lm_lprobs[:, self.pad] = -math.inf + new_lm_lprobs[:, self.pad] = -math.inf + + new_fw_lprobs.scatter_(1, fw_top_k_idx, fw_top_k) + new_ch_lm_lprobs.scatter_(1, fw_top_k_idx, ch_lm_scores) + new_lm_lprobs.scatter_(1, fw_top_k_idx, lm_scores.view(-1, k)) + return new_fw_lprobs, new_ch_lm_lprobs, new_lm_lprobs + + def combine_ch_lm(combine_type, ch_scores, lm_scores1, src_size, tgt_size): + if self.channel_scoring_type == "unnormalized": + ch_scores = self.log_softmax_fn( + ch_scores.view(-1, self.beam_size * self.k2) + ).view(ch_scores.shape) + ch_scores = ch_scores * self.ch_weight + lm_scores1 = lm_scores1 * self.lm_weight + + if combine_type == "lm_only": + # log P(T|S) + log P(T) + ch_scores = lm_scores1.view(ch_scores.size()) + elif combine_type == "noisy_channel": + # 1/t log P(T|S) + 1/s log P(S|T) + 1/t log P(T) + if self.normalize_lm_scores_by_tgt_len: + ch_scores.div_(src_size) + lm_scores_norm = lm_scores1.view(ch_scores.size()).div(tgt_size) + ch_scores.add_(lm_scores_norm) + # 1/t log P(T|S) + 1/s log P(S|T) + 1/s log P(T) + else: + ch_scores.add_(lm_scores1.view(ch_scores.size())) + ch_scores.div_(src_size) + + return ch_scores + + if self.channel_models is not None: + channel_model = self.channel_models[0] # assume only one channel_model model + else: + channel_model = None + + lm = EnsembleModel(self.lm_models) + lm_incremental_states = torch.jit.annotate( + List[Dict[str, Dict[str, Optional[Tensor]]]], + [ + torch.jit.annotate(Dict[str, Dict[str, Optional[Tensor]]], {}) + for i in range(lm.models_size) + ], + ) + + reorder_state = None + batch_idxs = None + for step in range(max_len + 1): # one extra step for EOS marker + # reorder decoder internal states based on the prev choice of beams + if reorder_state is not None: + if batch_idxs is not None: + # update beam indices to take into account removed sentences + corr = batch_idxs - torch.arange(batch_idxs.numel()).type_as(batch_idxs) + reorder_state.view(-1, beam_size).add_(corr.unsqueeze(-1) * beam_size) + model.reorder_incremental_state(incremental_states, reorder_state) + encoder_outs = model.reorder_encoder_out(encoder_outs, reorder_state) + + lm.reorder_incremental_state(lm_incremental_states, reorder_state) + + fw_lprobs, avg_attn_scores = model.forward_decoder( + tokens[:, :step + 1], encoder_outs, incremental_states, temperature=self.temperature, + ) + + fw_lprobs[:, self.pad] = -math.inf # never select pad + fw_lprobs[:, self.unk] -= self.unk_penalty # apply unk penalty + fw_lprobs, ch_lm_lprobs, lm_lprobs = noisy_channel_rescoring(fw_lprobs, beam_size, bsz, src_tokens, tokens, self.k2) + + # handle min and max length constraints + if step >= max_len: + fw_lprobs[:, :self.eos] = -math.inf + fw_lprobs[:, self.eos + 1:] = -math.inf + elif step < self.min_len: + fw_lprobs[:, self.eos] = -math.inf + + # handle prefix tokens (possibly with different lengths) + if prefix_tokens is not None and step < prefix_tokens.size(1): + prefix_toks = prefix_tokens[:, step].unsqueeze(-1).repeat(1, beam_size).view(-1) + prefix_mask = prefix_toks.ne(self.pad) + + prefix_fw_lprobs = fw_lprobs.gather(-1, prefix_toks.unsqueeze(-1)) + fw_lprobs[prefix_mask] = -math.inf + fw_lprobs[prefix_mask] = fw_lprobs[prefix_mask].scatter_( + -1, prefix_toks[prefix_mask].unsqueeze(-1), prefix_fw_lprobs + ) + + prefix_ch_lm_lprobs = ch_lm_lprobs.gather(-1, prefix_toks.unsqueeze(-1)) + ch_lm_lprobs[prefix_mask] = -math.inf + ch_lm_lprobs[prefix_mask] = ch_lm_lprobs[prefix_mask].scatter_( + -1, prefix_toks[prefix_mask].unsqueeze(-1), prefix_ch_lm_lprobs + ) + + prefix_lm_lprobs = lm_lprobs.gather(-1, prefix_toks.unsqueeze(-1)) + lm_lprobs[prefix_mask] = -math.inf + lm_lprobs[prefix_mask] = lm_lprobs[prefix_mask].scatter_( + -1, prefix_toks[prefix_mask].unsqueeze(-1), prefix_lm_lprobs + ) + + # if prefix includes eos, then we should make sure tokens and + # scores are the same across all beams + eos_mask = prefix_toks.eq(self.eos) + if eos_mask.any(): + # validate that the first beam matches the prefix + first_beam = tokens[eos_mask].view(-1, beam_size, tokens.size(-1))[:, 0, 1:step + 1] + eos_mask_batch_dim = eos_mask.view(-1, beam_size)[:, 0] + target_prefix = prefix_tokens[eos_mask_batch_dim][:, :step] + assert (first_beam == target_prefix).all() + + def replicate_first_beam(tensor, mask): + tensor = tensor.view(-1, beam_size, tensor.size(-1)) + tensor[mask] = tensor[mask][:, :1, :] + return tensor.view(-1, tensor.size(-1)) + + # copy tokens, scores and lprobs from the first beam to all beams + tokens = replicate_first_beam(tokens, eos_mask_batch_dim) + scores = replicate_first_beam(scores, eos_mask_batch_dim) + + fw_lprobs = replicate_first_beam(fw_lprobs, eos_mask_batch_dim) + ch_lm_lprobs = replicate_first_beam(ch_lm_lprobs, eos_mask_batch_dim) + lm_lprobs = replicate_first_beam(lm_lprobs, eos_mask_batch_dim) + + if self.no_repeat_ngram_size > 0: + # for each beam and batch sentence, generate a list of previous ngrams + gen_ngrams = [{} for bbsz_idx in range(bsz * beam_size)] + for bbsz_idx in range(bsz * beam_size): + gen_tokens = tokens[bbsz_idx].tolist() + for ngram in zip(*[gen_tokens[i:] for i in range(self.no_repeat_ngram_size)]): + gen_ngrams[bbsz_idx][tuple(ngram[:-1])] = \ + gen_ngrams[bbsz_idx].get(tuple(ngram[:-1]), []) + [ngram[-1]] + + # Record attention scores + if avg_attn_scores is not None: + if attn is None: + attn = scores.new(bsz * beam_size, src_tokens.size(1), max_len + 2) + attn_buf = attn.clone() + nonpad_idxs = src_tokens.ne(self.pad) + attn[:, :, step + 1].copy_(avg_attn_scores) + + scores = scores.type_as(fw_lprobs) + scores_buf = scores_buf.type_as(fw_lprobs) + + self.search.set_src_lengths(src_lengths_no_eos) + + if self.no_repeat_ngram_size > 0: + def calculate_banned_tokens(bbsz_idx): + # before decoding the next token, prevent decoding of ngrams that have already appeared + ngram_index = tuple(tokens[bbsz_idx, step + 2 - self.no_repeat_ngram_size:step + 1].tolist()) + return gen_ngrams[bbsz_idx].get(ngram_index, []) + + if step + 2 - self.no_repeat_ngram_size >= 0: + # no banned tokens if we haven't generated no_repeat_ngram_size tokens yet + banned_tokens = [calculate_banned_tokens(bbsz_idx) for bbsz_idx in range(bsz * beam_size)] + else: + banned_tokens = [[] for bbsz_idx in range(bsz * beam_size)] + + for bbsz_idx in range(bsz * beam_size): + fw_lprobs[bbsz_idx, banned_tokens[bbsz_idx]] = -math.inf + + combined_noisy_channel_scores, fw_lprobs_top_k, lm_lprobs_top_k, cand_indices, cand_beams = self.search.step( + step, + fw_lprobs.view(bsz, -1, self.vocab_size), + scores.view(bsz, beam_size, -1)[:, :, :step], ch_lm_lprobs.view(bsz, -1, self.vocab_size), + lm_lprobs.view(bsz, -1, self.vocab_size), self.combine_method + ) + + # cand_bbsz_idx contains beam indices for the top candidate + # hypotheses, with a range of values: [0, bsz*beam_size), + # and dimensions: [bsz, cand_size] + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + + # finalize hypotheses that end in eos (except for candidates to be ignored) + eos_mask = cand_indices.eq(self.eos) + eos_mask[:, :beam_size] &= ~cands_to_ignore + + # only consider eos when it's among the top beam_size indices + eos_bbsz_idx = torch.masked_select( + cand_bbsz_idx[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + + finalized_sents = set() + if eos_bbsz_idx.numel() > 0: + eos_scores = torch.masked_select( + fw_lprobs_top_k[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + combined_noisy_channel_eos_scores = torch.masked_select( + combined_noisy_channel_scores[:, :beam_size], + mask=eos_mask[:, :beam_size], + ) + + # finalize hypo using channel model score + finalized_sents = finalize_hypos( + step, eos_bbsz_idx, eos_scores, combined_noisy_channel_eos_scores) + + num_remaining_sent -= len(finalized_sents) + + assert num_remaining_sent >= 0 + if num_remaining_sent == 0: + break + + if len(finalized_sents) > 0: + new_bsz = bsz - len(finalized_sents) + + # construct batch_idxs which holds indices of batches to keep for the next pass + batch_mask = cand_indices.new_ones(bsz) + batch_mask[cand_indices.new(finalized_sents)] = 0 + batch_idxs = torch.nonzero(batch_mask).squeeze(-1) + + eos_mask = eos_mask[batch_idxs] + cand_beams = cand_beams[batch_idxs] + bbsz_offsets.resize_(new_bsz, 1) + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + + lm_lprobs_top_k = lm_lprobs_top_k[batch_idxs] + + fw_lprobs_top_k = fw_lprobs_top_k[batch_idxs] + cand_indices = cand_indices[batch_idxs] + if prefix_tokens is not None: + prefix_tokens = prefix_tokens[batch_idxs] + src_lengths_no_eos = src_lengths_no_eos[batch_idxs] + cands_to_ignore = cands_to_ignore[batch_idxs] + + scores = scores.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + scores_buf.resize_as_(scores) + tokens = tokens.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + tokens_buf.resize_as_(tokens) + src_tokens = src_tokens.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + src_lengths = src_lengths.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + lm_prefix_scores = lm_prefix_scores.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1).squeeze() + + if attn is not None: + attn = attn.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, attn.size(1), -1) + attn_buf.resize_as_(attn) + bsz = new_bsz + else: + batch_idxs = None + + # Set active_mask so that values > cand_size indicate eos or + # ignored hypos and values < cand_size indicate candidate + # active hypos. After this, the min values per row are the top + # candidate active hypos. + eos_mask[:, :beam_size] |= cands_to_ignore + active_mask = torch.add( + eos_mask.type_as(cand_offsets) * cand_size, + cand_offsets[: eos_mask.size(1)], + ) + + # get the top beam_size active hypotheses, which are just the hypos + # with the smallest values in active_mask + active_hypos, new_cands_to_ignore = buffer('active_hypos'), buffer('new_cands_to_ignore') + torch.topk( + active_mask, k=beam_size, dim=1, largest=False, + out=(new_cands_to_ignore, active_hypos) + ) + + # update cands_to_ignore to ignore any finalized hypos + cands_to_ignore = new_cands_to_ignore.ge(cand_size)[:, :beam_size] + assert (~cands_to_ignore).any(dim=1).all() + + active_bbsz_idx = buffer('active_bbsz_idx') + torch.gather( + cand_bbsz_idx, dim=1, index=active_hypos, + out=active_bbsz_idx, + ) + active_scores = torch.gather( + fw_lprobs_top_k, dim=1, index=active_hypos, + out=scores[:, step].view(bsz, beam_size), + ) + + active_bbsz_idx = active_bbsz_idx.view(-1) + active_scores = active_scores.view(-1) + + # copy tokens and scores for active hypotheses + torch.index_select( + tokens[:, :step + 1], dim=0, index=active_bbsz_idx, + out=tokens_buf[:, :step + 1], + ) + torch.gather( + cand_indices, dim=1, index=active_hypos, + out=tokens_buf.view(bsz, beam_size, -1)[:, :, step + 1], + ) + if step > 0: + torch.index_select( + scores[:, :step], dim=0, index=active_bbsz_idx, + out=scores_buf[:, :step], + ) + torch.gather( + fw_lprobs_top_k, dim=1, index=active_hypos, + out=scores_buf.view(bsz, beam_size, -1)[:, :, step], + ) + torch.gather( + lm_lprobs_top_k, dim=1, index=active_hypos, + out=lm_prefix_scores.view(bsz, beam_size) + ) + + # copy attention for active hypotheses + if attn is not None: + torch.index_select( + attn[:, :, :step + 2], dim=0, index=active_bbsz_idx, + out=attn_buf[:, :, :step + 2], + ) + + # swap buffers + tokens, tokens_buf = tokens_buf, tokens + scores, scores_buf = scores_buf, scores + if attn is not None: + attn, attn_buf = attn_buf, attn + + # reorder incremental state in decoder + reorder_state = active_bbsz_idx + + # sort by score descending + for sent in range(len(finalized)): + finalized[sent] = sorted(finalized[sent], key=lambda r: r['score'], reverse=True) + + return finalized + + +def get_lm_scores(model, input_tokens, incremental_states, cand_tokens, input_len, k): + with torch.no_grad(): + lm_lprobs, avg_attn_scores = model.forward_decoder( + input_tokens, encoder_outs=None, incremental_states=incremental_states, + ) + + lm_lprobs_size = lm_lprobs.size(0) + probs_next_wrd = torch.gather(lm_lprobs.repeat(1, k).view(lm_lprobs_size*k, -1), 1, cand_tokens).squeeze().view(-1) + + return probs_next_wrd + + +def make_dict2dict(old_dict, new_dict): + dict2dict_map = {} + for sym in old_dict.symbols: + dict2dict_map[old_dict.index(sym)] = new_dict.index(sym) + return dict2dict_map + + +def dict2dict(tokens, dict2dict_map): + if tokens.device == torch.device('cpu'): + tokens_tmp = tokens + else: + tokens_tmp = tokens.cpu() + return tokens_tmp.map_( + tokens_tmp, + lambda _, val, dict2dict_map=dict2dict_map : dict2dict_map[float(val)] + ).to(tokens.device) + + +def reorder_tokens(tokens, lengths, eos): + # reorder source tokens so they may be used as reference for P(S|T) + return torch.cat((tokens.new([eos]), tokens[-lengths:-1], tokens[:-lengths]), 0) + + +def reorder_all_tokens(tokens, lengths, eos): + # used to reorder src tokens from [ .. ] to [ ...] + # so source tokens can be used to predict P(S|T) + return torch.stack([reorder_tokens(token, length, eos) for token, length in zip(tokens, lengths)]) + + +def normalized_scores_with_batch_vocab( + model_decoder, features, target_ids, k, bsz, beam_size, + pad_idx, top_k=0, vocab_size_meter=None, start_idx=None, + end_idx=None, **kwargs): + """ + Get normalized probabilities (or log probs) from a net's output + w.r.t. vocab consisting of target IDs in the batch + """ + if model_decoder.adaptive_softmax is None: + weight = model_decoder.output_projection.weight + vocab_ids = torch.unique( + torch.cat( + (torch.unique(target_ids), torch.arange(top_k, device=target_ids.device)) + ) + ) + id_map = dict(zip(vocab_ids.tolist(), range(len(vocab_ids)))) + mapped_target_ids = target_ids.cpu().apply_( + lambda x, id_map=id_map: id_map[x] + ).to(target_ids.device) + expanded_target_ids = mapped_target_ids[:, :].repeat(1, k).view(bsz*beam_size*k, -1) + if start_idx is not None and end_idx is not None: + expanded_target_ids = expanded_target_ids[start_idx:end_idx, :] + logits = F.linear(features, weight[vocab_ids, :]) + log_softmax = F.log_softmax(logits, dim=-1, dtype=torch.float32) + intermed_scores = torch.gather( + log_softmax[:, :-1, :], + 2, + expanded_target_ids[:, 1:].unsqueeze(2), + ).squeeze() + not_padding = expanded_target_ids[:, 1:] != pad_idx + intermed_scores *= not_padding.float() + return intermed_scores + else: + raise ValueError("adaptive softmax doesn't work with " + + "`normalized_scores_with_batch_vocab()`") diff --git a/fairseq/examples/fast_noisy_channel/noisy_channel_translation.py b/fairseq/examples/fast_noisy_channel/noisy_channel_translation.py new file mode 100644 index 0000000000000000000000000000000000000000..b74bdfd456f9b7c546ce528173c77431b4f57ac1 --- /dev/null +++ b/fairseq/examples/fast_noisy_channel/noisy_channel_translation.py @@ -0,0 +1,127 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.tasks.translation import TranslationTask +from fairseq.tasks.language_modeling import LanguageModelingTask +from fairseq import checkpoint_utils +import argparse +from fairseq.tasks import register_task +import torch + + +@register_task("noisy_channel_translation") +class NoisyChannelTranslation(TranslationTask): + """ + Rescore the top k candidates from each beam using noisy channel modeling + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + TranslationTask.add_args(parser) + # fmt: off + parser.add_argument('--channel-model', metavar='FILE', + help='path to P(S|T) model. P(S|T) and P(T|S) must share source and target dictionaries.') + parser.add_argument('--combine-method', default='lm_only', + choices=['lm_only', 'noisy_channel'], + help="""method for combining direct and channel model scores. + lm_only: decode with P(T|S)P(T) + noisy_channel: decode with 1/t P(T|S) + 1/s(P(S|T)P(T))""") + parser.add_argument('--normalize-lm-scores-by-tgt-len', action='store_true', default=False, + help='normalize lm score by target length instead of source length') + parser.add_argument('--channel-scoring-type', default='log_norm', choices=['unnormalized', 'log_norm', 'k2_separate', 'src_vocab', 'src_vocab_batched'], + help="Normalize bw scores with log softmax or return bw scores without log softmax") + parser.add_argument('--top-k-vocab', default=0, type=int, + help='top k vocab IDs to use with `src_vocab` in channel model scoring') + parser.add_argument('--k2', default=50, type=int, + help='the top k2 candidates to rescore with the noisy channel model for each beam') + parser.add_argument('--ch-wt', default=1, type=float, + help='weight for the channel model') + parser.add_argument('--lm-model', metavar='FILE', + help='path to lm model file, to model P(T). P(T) must share the same vocab as the direct model on the target side') + parser.add_argument('--lm-data', metavar='FILE', + help='path to lm model training data for target language, used to properly load LM with correct dictionary') + parser.add_argument('--lm-wt', default=1, type=float, + help='the weight of the lm in joint decoding') + # fmt: on + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None + ): + if getattr(args, "score_reference", False): + raise NotImplementedError() + else: + from .noisy_channel_sequence_generator import NoisyChannelSequenceGenerator + use_cuda = torch.cuda.is_available() and not self.args.cpu + assert self.args.lm_model is not None, '--lm-model required for noisy channel generation!' + assert self.args.lm_data is not None, '--lm-data required for noisy channel generation to map between LM and bitext vocabs' + if self.args.channel_model is not None: + import copy + ch_args_task = copy.deepcopy(self.args) + tmp = ch_args_task.source_lang + ch_args_task.source_lang = ch_args_task.target_lang + ch_args_task.target_lang = tmp + ch_args_task._name = 'translation' + channel_task = TranslationTask.setup_task(ch_args_task) + + arg_dict = {} + arg_dict['task'] = 'language_modeling' + arg_dict['sample_break_mode'] = 'eos' + arg_dict['data'] = self.args.lm_data + arg_dict['output_dictionary_size'] = -1 + lm_args = argparse.Namespace(**arg_dict) + lm_task = LanguageModelingTask.setup_task(lm_args) + lm_dict = lm_task.output_dictionary + + if self.args.channel_model is not None: + channel_models, _ = checkpoint_utils.load_model_ensemble(self.args.channel_model.split(':'), task=channel_task) + + for model in channel_models: + model.make_generation_fast_( + beamable_mm_beam_size=None if args.no_beamable_mm else args.beam, + need_attn=args.print_alignment, + ) + if self.args.fp16: + model.half() + if use_cuda: + model.cuda() + else: + channel_models = None + + lm_models, _ = checkpoint_utils.load_model_ensemble(self.args.lm_model.split(':'), task=lm_task) + + for model in lm_models: + model.make_generation_fast_( + beamable_mm_beam_size=None if args.no_beamable_mm else args.beam, + need_attn=args.print_alignment, + ) + if self.args.fp16: + model.half() + if use_cuda: + model.cuda() + return NoisyChannelSequenceGenerator( + combine_method=self.args.combine_method, + tgt_dict=self.target_dictionary, + src_dict=self.source_dictionary, + beam_size=getattr(args, 'beam', 5), + max_len_a=getattr(args, 'max_len_a', 0), + max_len_b=getattr(args, 'max_len_b', 200), + min_len=getattr(args, 'min_len', 1), + len_penalty=getattr(args, 'lenpen', 1), + unk_penalty=getattr(args, 'unkpen', 0), + temperature=getattr(args, 'temperature', 1.), + match_source_len=getattr(args, 'match_source_len', False), + no_repeat_ngram_size=getattr(args, 'no_repeat_ngram_size', 0), + normalize_scores=(not getattr(args, 'unnormalized', False)), + channel_models=channel_models, + k2=getattr(self.args, 'k2', 50), + ch_weight=getattr(self.args, 'ch_wt', 1), + channel_scoring_type=self.args.channel_scoring_type, + top_k_vocab=self.args.top_k_vocab, + lm_models=lm_models, + lm_dict=lm_dict, + lm_weight=getattr(self.args, 'lm_wt', 1), + normalize_lm_scores_by_tgt_len=getattr(self.args, 'normalize_lm_scores_by_tgt_len', False), + ) diff --git a/fairseq/examples/flores101/README.md b/fairseq/examples/flores101/README.md new file mode 100644 index 0000000000000000000000000000000000000000..635c13f40bd0ccab704735bc5c26ea0192ea98cd --- /dev/null +++ b/fairseq/examples/flores101/README.md @@ -0,0 +1,223 @@ +

+ +

+ +# Flores101: Large-Scale Multilingual Machine Translation + +## Introduction + +Baseline pretrained models for small and large tracks of WMT 21 Large-Scale Multilingual Machine Translation competition. + +Flores Task at WMT 21: http://www.statmt.org/wmt21/large-scale-multilingual-translation-task.html + +Flores announement blog post: https://ai.facebook.com/blog/flores-researchers-kick-off-multilingual-translation-challenge-at-wmt-and-call-for-compute-grants/ + + + +## Pretrained models + +Model | Num layers | Embed dimension | FFN dimension| Vocab Size | #params | Download +---|---|---|---|---|---|--- +`flores101_mm100_615M` | 12 | 1024 | 4096 | 256,000 | 615M | https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_615M.tar.gz +`flores101_mm100_175M` | 6 | 512 | 2048 | 256,000 | 175M | https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_175M.tar.gz + + +These models are trained similar to [M2M-100](https://arxiv.org/abs/2010.11125) with additional support for the languages that are part of the WMT Large-Scale Multilingual Machine Translation track. Full list of languages can be found at the bottom. + + +## Example Generation code + +### Download model, sentencepiece vocab + +```bash +fairseq=/path/to/fairseq +cd $fairseq + +# Download 615M param model. +wget https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_615M.tar.gz + +# Extract +tar -xvzf flores101_mm100_615M.tar.gz +``` + +### Encode using our SentencePiece Model +Note: Install SentencePiece from [here](https://github.com/google/sentencepiece) + + +```bash +fairseq=/path/to/fairseq +cd $fairseq + +# Download example dataset From German to French +sacrebleu --echo src -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.de +sacrebleu --echo ref -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.fr + +for lang in de fr ; do + python scripts/spm_encode.py \ + --model flores101_mm100_615M/sentencepiece.bpe.model \ + --output_format=piece \ + --inputs=raw_input.de-fr.${lang} \ + --outputs=spm.de-fr.${lang} +done +``` + +### Binarization + +```bash +fairseq-preprocess \ + --source-lang de --target-lang fr \ + --testpref spm.de-fr \ + --thresholdsrc 0 --thresholdtgt 0 \ + --destdir data_bin \ + --srcdict flores101_mm100_615M/dict.txt --tgtdict flores101_mm100_615M/dict.txt +``` + +### Generation + + +```bash +fairseq-generate \ + data_bin \ + --batch-size 1 \ + --path flores101_mm100_615M/model.pt \ + --fixed-dictionary flores101_mm100_615M/dict.txt \ + -s de -t fr \ + --remove-bpe 'sentencepiece' \ + --beam 5 \ + --task translation_multi_simple_epoch \ + --lang-pairs flores101_mm100_615M/language_pairs.txt \ + --decoder-langtok --encoder-langtok src \ + --gen-subset test \ + --fp16 \ + --dataset-impl mmap \ + --distributed-world-size 1 --distributed-no-spawn +``` + +### Supported Languages and lang code + +Language | lang code +---|--- +Akrikaans | af +Amharic | am +Arabic | ar +Assamese | as +Asturian | ast +Aymara | ay +Azerbaijani | az +Bashkir | ba +Belarusian | be +Bulgarian | bg +Bengali | bn +Breton | br +Bosnian | bs +Catalan | ca +Cebuano | ceb +Chokwe | cjk +Czech | cs +Welsh | cy +Danish | da +German | de +Dyula| dyu +Greek | el +English | en +Spanish | es +Estonian | et +Persian | fa +Fulah | ff +Finnish | fi +French | fr +Western Frisian | fy +Irish | ga +Scottish Gaelic | gd +Galician | gl +Gujarati | gu +Hausa | ha +Hebrew | he +Hindi | hi +Croatian | hr +Haitian Creole | ht +Hungarian | hu +Armenian | hy +Indonesian | id +Igbo | ig +Iloko | ilo +Icelandic | is +Italian | it +Japanese | ja +Javanese | jv +Georgian | ka +Kachin | kac +Kamba | kam +Kabuverdianu | kea +Kongo | kg +Kazakh | kk +Central Khmer | km +Kimbundu | kmb +Northern Kurdish | kmr +Kannada | kn +Korean | ko +Kurdish | ku +Kyrgyz | ky +Luxembourgish | lb +Ganda | lg +Lingala | ln +Lao | lo +Lithuanian | lt +Luo | luo +Latvian | lv +Malagasy | mg +Maori | mi +Macedonian | mk +Malayalam | ml +Mongolian | mn +Marathi | mr +Malay | ms +Maltese | mt +Burmese | my +Nepali | ne +Dutch | nl +Norwegian | no +Northern Sotho | ns +Nyanja | ny +Occitan | oc +Oromo | om +Oriya | or +Punjabi | pa +Polish | pl +Pashto | ps +Portuguese | pt +Quechua | qu +Romanian | ro +Russian | ru +Sindhi | sd +Shan | shn +Sinhala | si +Slovak | sk +Slovenian | sl +Shona | sn +Somali | so +Albanian | sq +Serbian | sr +Swati | ss +Sundanese | su +Swedish | sv +Swahili | sw +Tamil | ta +Telugu | te +Tajik | tg +Thai | th +Tigrinya | ti +Tagalog | tl +Tswana | tn +Turkish | tr +Ukrainian | uk +Umbundu | umb +Urdu | ur +Uzbek | uz +Vietnamese | vi +Wolof | wo +Xhosa | xh +Yiddish | yi +Yoruba | yo +Chinese| zh +Zulu | zu diff --git a/fairseq/examples/flores101/flores_logo.png b/fairseq/examples/flores101/flores_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..d4d1455c6eab608ff5317ce885183cd213564273 Binary files /dev/null and b/fairseq/examples/flores101/flores_logo.png differ diff --git a/fairseq/examples/fully_sharded_data_parallel/README.md b/fairseq/examples/fully_sharded_data_parallel/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b9e44fef48bee5faeee27b3d1d1b1eb96b6a477f --- /dev/null +++ b/fairseq/examples/fully_sharded_data_parallel/README.md @@ -0,0 +1,177 @@ +# Fully Sharded Data Parallel (FSDP) + +## Overview +Recent work by [Microsoft](https://arxiv.org/abs/1910.02054) and +[Google](https://arxiv.org/abs/2004.13336) has shown that data parallel +training can be made significantly more efficient by sharding the model +parameters and optimizer state across data parallel workers. These ideas are +encapsulated in the new **`FullyShardedDataParallel` (FSDP)** wrapper provided +by [fairscale](https://github.com/facebookresearch/fairscale/). + +Compared to PyTorch DDP: +* FSDP produces identical results as PyTorch DDP (it's still synchronous data parallel training) +* FSDP shards parameters (FP16 + FP32) and optimizer state across data parallel GPUs +* FSDP is faster than PyTorch DDP because the optimizer step is sharded, and the communication can be overlapped with the forward pass +* FSDP enables training 13B parameter models on 8 GPUs and 175B parameter models on 128 GPUs + +FSDP is fully supported in fairseq via the following new arguments: +* `--ddp-backend=fully_sharded`: enables full sharding via FSDP +* `--cpu-offload`: offloads the optimizer state and FP32 model copy to CPU (combine with `--optimizer=cpu_adam`) +* `--no-reshard-after-forward`: increases training speed for large models (1B+ params) and is similar to ZeRO stage 2 +* other popular options (`--fp16`, `--update-freq`, `--checkpoint-activations`, `--offload-activations`, etc.) continue to work as normal + +
Limitations

+ +FSDP currently has several limitations compared to fairseq's default DDP backend (PyTorch DDP): +* while FSDP is full compatible with pointwise Optimizers (e.g., Adam, AdamW, Adadelta, Adamax, SGD, etc.), it is not currently compatible with non-pointwise Optimizers (e.g., Adagrad, Adafactor, LAMB, etc.) +* FSDP depends on flattening the parameters, so models that currently require `--fp16-no-flatten-grads` may not be supported + +See the [fairscale docs](https://fairscale.readthedocs.io/en/latest/api/nn/fsdp_tips.html) for a more detailed +explanation of these and other limitations. + +

+ +
How it works

+ +Fully Sharded Data Parallel + +See the [fairscale docs](https://fairscale.readthedocs.io/en/latest/api/nn/fsdp_tips.html) for a more detailed +explanation of how FSDP works. + +

+ +## Example usage + +The following examples illustrate how to train a very large language model with +13 billion parameters on 1 GPU by offloading parameters and optimizer states to +CPU, or on 8 GPUs by fully sharding the params and optimizer states across GPUs. + +These examples use the WikiText-103 dataset for demonstration purposes, but +in practice a much larger dataset will be needed to achieve good results. +Follow the [instructions here](https://github.com/pytorch/fairseq/blob/main/examples/roberta/README.pretraining.md#1-preprocess-the-data) +to preprocess the WikiText-103 dataset using the GPT-2/RoBERTa vocabulary. + +### 13B params on 1 V100 GPU (with CPU offloading) + +The following command trains a 13B parameter GPT-3 model on a single V100 GPU +using the `--cpu-offload` feature to offload parameters and optimizer states to +CPU. In this setting, the optimizer step (Adam) happens on CPU. We also use the +`--checkpoint-activations` feature (sometimes called [gradient checkpointing](https://pytorch.org/docs/stable/checkpoint.html)), +which further saves memory in exchange for a small increase in computation. + +**Requirements:** +- Install the latest master version of fairscale: `pip install git+https://github.com/facebookresearch/fairscale.git@master` +- You'll need 32GB of GPU memory and ~256GB of system memory to train the 13B param model. +- If you have less system memory, the 6.7B param model can be trained with ~128GB of system memory, just set `--arch transformer_lm_gpt3_6_7` +- We use the CPU Adam optimizer from [DeepSpeed](https://github.com/microsoft/DeepSpeed), so you'll need to `pip install deepspeed` before running the command. + +**Notes:** +- The command will take ~5 minutes to start training, during which time it will appear to be hung, since randomly initializing 13B weights can be slow. +- The `--cpu-offload` feature requires training in mixed precision (`--fp16`). +- Tune the `OMP_NUM_THREADS` env variable for best performance with CPU offloading. +- The example command below stops training after 10 steps (`--max-update 10`) and does not save checkpoints (`--no-save`). + +```bash +OMP_NUM_THREADS=20 CUDA_VISIBLE_DEVICES=0 \ + fairseq-train data-bin/wikitext-103-roberta-bpe-bin \ + --ddp-backend fully_sharded --fp16 --fp16-init-scale 4 \ + --cpu-offload --checkpoint-activations \ + --task language_modeling --tokens-per-sample 2048 --batch-size 8 \ + --arch transformer_lm_gpt3_13 \ + --optimizer cpu_adam --adam-betas "(0.9,0.98)" \ + --lr 0.0001 --lr-scheduler polynomial_decay --warmup-updates 5 --total-num-update 10 \ + --max-update 10 --no-save --log-format json --log-interval 1 +``` + +
Example output

+ +``` +(...) +2021-03-08 12:29:51 | INFO | fairseq_cli.train | num. model params: 13,110,865,920 (num. trained: 13,110,865,920) +(...) +2021-03-08 12:29:51 | INFO | fairseq_cli.train | training on 1 devices (GPUs/TPUs) +2021-03-08 12:29:51 | INFO | fairseq_cli.train | max tokens per GPU = None and batch size per GPU = 8 +(...) +Adam Optimizer #0 is created with AVX2 arithmetic capability. +Config: alpha=0.000100, betas=(0.900000, 0.980000), weight_decay=0.000000, adam_w=1 +(...) +2021-03-08 12:31:36 | INFO | train_inner | {"epoch": 1, "update": 0.0, "loss": "16.475", "ppl": "91120.8", "wps": "0", "ups": "0", "wpb": "16384", "bsz": "8", "num_updates": "1", "lr": "2e-05", "gnorm": "20.751", "loss_scale": "4", "train_wall": "99", "gb_free": "9.3", "wall": "105"} +2021-03-08 12:32:33 | INFO | train_inner | {"epoch": 1, "update": 0.0, "loss": "16.446", "ppl": "89281.6", "wps": "288.7", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "2", "lr": "4e-05", "gnorm": "19.777", "loss_scale": "4", "train_wall": "57", "gb_free": "9.3", "wall": "161"} +2021-03-08 12:33:12 | INFO | fairseq.trainer | NOTE: gradient overflow detected, ignoring gradient, setting loss scale to: 2.0 +2021-03-08 12:33:51 | INFO | fairseq.trainer | NOTE: gradient overflow detected, ignoring gradient, setting loss scale to: 1.0 +2021-03-08 12:34:45 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "25.22", "ppl": "3.90691e+07", "wps": "123.4", "ups": "0.01", "wpb": "16384", "bsz": "8", "num_updates": "3", "lr": "6e-05", "gnorm": "131.281", "loss_scale": "1", "train_wall": "133", "gb_free": "9.3", "wall": "294"} +2021-03-08 12:35:43 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "18.079", "ppl": "276809", "wps": "285.5", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "4", "lr": "8e-05", "gnorm": "13.776", "loss_scale": "1", "train_wall": "57", "gb_free": "9.3", "wall": "351"} +2021-03-08 12:36:35 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "23.729", "ppl": "1.39088e+07", "wps": "316.7", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "5", "lr": "0.0001", "gnorm": "72.774", "loss_scale": "1", "train_wall": "52", "gb_free": "9.3", "wall": "403"} +2021-03-08 12:37:28 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "20.429", "ppl": "1.41203e+06", "wps": "307.6", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "6", "lr": "8e-05", "gnorm": "60.846", "loss_scale": "1", "train_wall": "53", "gb_free": "9.3", "wall": "456"} +2021-03-08 12:38:27 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "18.965", "ppl": "511684", "wps": "279.4", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "7", "lr": "6e-05", "gnorm": "22.687", "loss_scale": "1", "train_wall": "59", "gb_free": "9.3", "wall": "515"} +2021-03-08 12:39:18 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "18.345", "ppl": "332887", "wps": "319.1", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "8", "lr": "4e-05", "gnorm": "8.451", "loss_scale": "1", "train_wall": "51", "gb_free": "9.3", "wall": "566"} +2021-03-08 12:40:11 | INFO | train_inner | {"epoch": 1, "update": 0.002, "loss": "18.262", "ppl": "314336", "wps": "305.9", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "9", "lr": "2e-05", "gnorm": "6.457", "loss_scale": "1", "train_wall": "54", "gb_free": "9.3", "wall": "620"} +2021-03-08 12:41:04 | INFO | train_inner | {"epoch": 1, "update": 0.002, "loss": "17.556", "ppl": "192686", "wps": "311.8", "ups": "0.02", "wpb": "16384", "bsz": "8", "num_updates": "10", "lr": "0", "gnorm": "5.796", "loss_scale": "1", "train_wall": "53", "gb_free": "9.3", "wall": "673"} +2021-03-08 12:41:04 | INFO | fairseq_cli.train | Stopping training due to num_updates: 10 >= max_update: 10 +2021-03-08 12:41:04 | INFO | fairseq_cli.train | begin validation on "valid" subset +2021-03-08 12:43:15 | INFO | valid | {"epoch": 1, "valid_loss": "17.953", "valid_ppl": "253807", "valid_wps": "1868.4", "valid_wpb": "15400.2", "valid_bsz": "7.6", "valid_num_updates": "10"} +2021-03-08 12:43:15 | INFO | fairseq_cli.train | end of epoch 1 (average epoch stats below) +2021-03-08 12:43:15 | INFO | train | {"epoch": 1, "train_loss": "19.351", "train_ppl": "668509", "train_wps": "210.9", "train_ups": "0.01", "train_wpb": "16384", "train_bsz": "8", "train_num_updates": "10", "train_lr": "0", "train_gnorm": "36.26", "train_loss_scale": "1", "train_train_wall": "667", "train_gb_free": "9.3", "train_wall": "804"} +2021-03-08 12:43:15 | INFO | fairseq_cli.train | done training in 798.6 seconds +``` + +

+ +### 13B params on 8 V100 GPUs (with full parameter + optimizer state sharding) + +FSDP can also shard the parameters and optimizer states across multiple GPUs, +reducing memory requirements significantly. On 8 x 32GB GPUs, sharding enables +training the same 13B parameter model *without offloading the parameters to +CPU*. However, without CPU offloading we'd only be able to fit a batch size of +1 per GPU, which would cause training speed to suffer. + +We obtain the best performance on 8 GPUs by combining full sharding and CPU +offloading. The following command trains the same 13B parameter GPT-3 model as +before on 8 x 32GB V100 GPUs; training speed increases superlinearly from ~310 +words per second to ~3200 words per second. + +```bash +OMP_NUM_THREADS=20 CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 \ + fairseq-train data-bin/wikitext-103-roberta-bpe-bin \ + --ddp-backend fully_sharded --fp16 --fp16-init-scale 4 \ + --cpu-offload --checkpoint-activations \ + --task language_modeling --tokens-per-sample 2048 --batch-size 8 \ + --arch transformer_lm_gpt3_13 \ + --optimizer cpu_adam --adam-betas "(0.9,0.98)" \ + --lr 0.0001 --lr-scheduler polynomial_decay --warmup-updates 5 --total-num-update 10 \ + --max-update 10 --no-save --log-format json --log-interval 1 +``` + +
Example output

+ +``` +(...) +2021-03-08 18:04:09 | INFO | fairseq_cli.train | num. model params: 13,110,865,920 (num. trained: 13,110,865,920) +(...) +2021-03-08 18:04:09 | INFO | fairseq_cli.train | training on 8 devices (GPUs/TPUs) +2021-03-08 18:04:09 | INFO | fairseq_cli.train | max tokens per GPU = None and batch size per GPU = 8 +(...) +Adam Optimizer #0 is created with AVX2 arithmetic capability. +Config: alpha=0.000100, betas=(0.900000, 0.980000), weight_decay=0.000000, adam_w=1 +(...) +2021-03-08 18:05:06 | INFO | train_inner | {"epoch": 1, "update": 0.001, "loss": "16.408", "ppl": "86945.6", "wps": "0", "ups": "0", "wpb": "131072", "bsz": "64", "num_updates": "1", "lr": "2e-05", "gnorm": "18.27", "loss_scale": "4", "train_wall": "47", "gb_free": "9.3", "wall": "56"} +2021-03-08 18:05:45 | INFO | train_inner | {"epoch": 1, "update": 0.002, "loss": "16.352", "ppl": "83644.3", "wps": "3283.4", "ups": "0.03", "wpb": "131072", "bsz": "64", "num_updates": "2", "lr": "4e-05", "gnorm": "18.411", "loss_scale": "4", "train_wall": "40", "gb_free": "9.3", "wall": "96"} +2021-03-08 18:06:21 | INFO | fairseq.trainer | NOTE: gradient overflow detected, ignoring gradient, setting loss scale to: 2.0 +2021-03-08 18:06:56 | INFO | fairseq.trainer | NOTE: gradient overflow detected, ignoring gradient, setting loss scale to: 1.0 +2021-03-08 18:07:37 | INFO | train_inner | {"epoch": 1, "update": 0.006, "loss": "23.682", "ppl": "1.34537e+07", "wps": "1176.6", "ups": "0.01", "wpb": "131072", "bsz": "64", "num_updates": "3", "lr": "6e-05", "gnorm": "119.682", "loss_scale": "1", "train_wall": "111", "gb_free": "9.3", "wall": "208"} +2021-03-08 18:08:18 | INFO | train_inner | {"epoch": 1, "update": 0.007, "loss": "18.988", "ppl": "519921", "wps": "3189.1", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "4", "lr": "8e-05", "gnorm": "14.934", "loss_scale": "1", "train_wall": "41", "gb_free": "9.3", "wall": "249"} +2021-03-08 18:08:59 | INFO | train_inner | {"epoch": 1, "update": 0.008, "loss": "20.08", "ppl": "1.10798e+06", "wps": "3223.1", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "5", "lr": "0.0001", "gnorm": "59.92", "loss_scale": "1", "train_wall": "41", "gb_free": "9.3", "wall": "289"} +2021-03-08 18:09:39 | INFO | train_inner | {"epoch": 1, "update": 0.009, "loss": "18.323", "ppl": "327980", "wps": "3256.6", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "6", "lr": "8e-05", "gnorm": "37.425", "loss_scale": "1", "train_wall": "40", "gb_free": "9.3", "wall": "330"} +2021-03-08 18:10:20 | INFO | train_inner | {"epoch": 1, "update": 0.01, "loss": "17.264", "ppl": "157354", "wps": "3188.7", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "7", "lr": "6e-05", "gnorm": "10.824", "loss_scale": "1", "train_wall": "41", "gb_free": "9.3", "wall": "371"} +2021-03-08 18:11:01 | INFO | train_inner | {"epoch": 1, "update": 0.011, "loss": "16.794", "ppl": "113647", "wps": "3230", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "8", "lr": "4e-05", "gnorm": "5.616", "loss_scale": "1", "train_wall": "41", "gb_free": "9.3", "wall": "411"} +2021-03-08 18:11:39 | INFO | train_inner | {"epoch": 1, "update": 0.012, "loss": "16.706", "ppl": "106938", "wps": "3384", "ups": "0.03", "wpb": "131072", "bsz": "64", "num_updates": "9", "lr": "2e-05", "gnorm": "5.318", "loss_scale": "1", "train_wall": "39", "gb_free": "9.3", "wall": "450"} +2021-03-08 18:12:19 | INFO | train_inner | {"epoch": 1, "update": 0.013, "loss": "16.548", "ppl": "95796.2", "wps": "3274.4", "ups": "0.02", "wpb": "131072", "bsz": "64", "num_updates": "10", "lr": "0", "gnorm": "5.22", "loss_scale": "1", "train_wall": "40", "gb_free": "9.3", "wall": "490"} +2021-03-08 18:12:19 | INFO | fairseq_cli.train | Stopping training due to num_updates: 10 >= max_update: 10 +2021-03-08 18:12:19 | INFO | fairseq_cli.train | begin validation on "valid" subset +2021-03-08 18:12:45 | INFO | valid | {"epoch": 1, "valid_loss": "16.624", "valid_ppl": "101000", "valid_wps": "10855.9", "valid_wpb": "123202", "valid_bsz": "60.5", "valid_num_updates": "10"} +2021-03-08 18:12:45 | INFO | fairseq_cli.train | end of epoch 1 (average epoch stats below) +2021-03-08 18:12:45 | INFO | train | {"epoch": 1, "train_loss": "18.114", "train_ppl": "283776", "train_wps": "2567.8", "train_ups": "0.02", "train_wpb": "131072", "train_bsz": "64", "train_num_updates": "10", "train_lr": "0", "train_gnorm": "29.562", "train_loss_scale": "1", "train_train_wall": "480", "train_gb_free": "9.3", "train_wall": "516"} +2021-03-08 18:12:45 | INFO | fairseq_cli.train | done training in 509.9 seconds +``` + +

diff --git a/fairseq/examples/gottbert/README.md b/fairseq/examples/gottbert/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1d58feb279a4a50222290546c3bb285d3cea98e6 --- /dev/null +++ b/fairseq/examples/gottbert/README.md @@ -0,0 +1,64 @@ +# GottBERT: a pure German language model + +## Introduction + +[GottBERT](http://arxiv.org/abs/2012.02110) is a pretrained language model trained on 145GB of German text based on RoBERTa. + +## Example usage + +### fairseq +##### Load GottBERT from torch.hub (PyTorch >= 1.1): +```python +import torch +gottbert = torch.hub.load('pytorch/fairseq', 'gottbert-base') +gottbert.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Load GottBERT (for PyTorch 1.0 or custom models): +```python +# Download gottbert model +wget https://dl.gottbert.de/fairseq/models/gottbert-base.tar.gz +tar -xzvf gottbert.tar.gz + +# Load the model in fairseq +from fairseq.models.roberta import GottbertModel +gottbert = GottbertModel.from_pretrained('/path/to/gottbert') +gottbert.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Filling masks: +```python +masked_line = 'Gott ist ! :)' +gottbert.fill_mask(masked_line, topk=3) +# [('Gott ist gut ! :)', 0.3642110526561737, ' gut'), +# ('Gott ist überall ! :)', 0.06009674072265625, ' überall'), +# ('Gott ist großartig ! :)', 0.0370681993663311, ' großartig')] +``` + +##### Extract features from GottBERT + +```python +# Extract the last layer's features +line = "Der erste Schluck aus dem Becher der Naturwissenschaft macht atheistisch , aber auf dem Grunde des Bechers wartet Gott !" +tokens = gottbert.encode(line) +last_layer_features = gottbert.extract_features(tokens) +assert last_layer_features.size() == torch.Size([1, 27, 768]) + +# Extract all layer's features (layer 0 is the embedding layer) +all_layers = gottbert.extract_features(tokens, return_all_hiddens=True) +assert len(all_layers) == 13 +assert torch.all(all_layers[-1] == last_layer_features) +``` +## Citation +If you use our work, please cite: + +```bibtex +@misc{scheible2020gottbert, + title={GottBERT: a pure German Language Model}, + author={Raphael Scheible and Fabian Thomczyk and Patric Tippmann and Victor Jaravine and Martin Boeker}, + year={2020}, + eprint={2012.02110}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` diff --git a/fairseq/examples/hubert/README.md b/fairseq/examples/hubert/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b501a6eb2a047d4adb6f297436c1c002c926a09f --- /dev/null +++ b/fairseq/examples/hubert/README.md @@ -0,0 +1,115 @@ +# HuBERT + +## Pre-trained and fine-tuned (ASR) models +Model | Pretraining Data | Finetuning Dataset | Model +|---|---|---|--- +HuBERT Base (~95M params) | [Librispeech](http://www.openslr.org/12) 960 hr | No finetuning (Pretrained Model) | [download](https://dl.fbaipublicfiles.com/hubert/hubert_base_ls960.pt) +HuBERT Large (~316M params) | [Libri-Light](https://github.com/facebookresearch/libri-light) 60k hr | No finetuning (Pretrained Model) | [download](https://dl.fbaipublicfiles.com/hubert/hubert_large_ll60k.pt) +HuBERT Extra Large (~1B params) | [Libri-Light](https://github.com/facebookresearch/libri-light) 60k hr | No finetuning (Pretrained Model) | [download](https://dl.fbaipublicfiles.com/hubert/hubert_xtralarge_ll60k.pt) +HuBERT Large | [Libri-Light](https://github.com/facebookresearch/libri-light) 60k hr | [Librispeech](http://www.openslr.org/12) 960 hr | [download](https://dl.fbaipublicfiles.com/hubert/hubert_large_ll60k_finetune_ls960.pt) +HuBERT Extra Large | [Libri-Light](https://github.com/facebookresearch/libri-light) 60k hr | [Librispeech](http://www.openslr.org/12) 960 hr | [download](https://dl.fbaipublicfiles.com/hubert/hubert_xtralarge_ll60k_finetune_ls960.pt) + +## Load a model +``` +ckpt_path = "/path/to/the/checkpoint.pt" +models, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([ckpt_path]) +model = models[0] +``` + +## Train a new model + +### Data preparation + +Follow the steps in `./simple_kmeans` to create: +- `{train,valid}.tsv` waveform list files +- `{train,valid}.km` frame-aligned pseudo label files. +The `label_rate` is the same as the feature frame rate used for clustering, +which is 100Hz for MFCC features and 50Hz for HuBERT features by default. + +### Pre-train a HuBERT model + +Suppose `{train,valid}.tsv` are saved at `/path/to/data`, `{train,valid}.km` +are saved at `/path/to/labels`, and the label rate is 100Hz. + +To train a base model (12 layer transformer), run: +```sh +$ python fairseq_cli/hydra_train.py \ + --config-dir /path/to/fairseq-py/examples/hubert/config/pretrain \ + --config-name hubert_base_librispeech \ + task.data=/path/to/data task.label_dir=/path/to/labels model.label_rate=100 +``` + +### Fine-tune a HuBERT model with a CTC loss + +Suppose `{train,valid}.tsv` are saved at `/path/to/data`, and their +corresponding character transcripts `{train,valid}.ltr` are saved at +`/path/to/trans`. + +To fine-tune a pre-trained HuBERT model at `/path/to/checkpoint`, run +```sh +$ python fairseq_cli/hydra_train.py \ + --config-dir /path/to/fairseq-py/examples/hubert/config/finetune \ + --config-name base_10h \ + task.data=/path/to/data task.label_dir=/path/to/trans \ + model.w2v_path=/path/to/checkpoint +``` + +### Decode a HuBERT model + +Suppose the `test.tsv` and `test.ltr` are the waveform list and transcripts of +the split to be decoded, saved at `/path/to/data`, and the fine-tuned model is +saved at `/path/to/checkpoint`. We support three decoding modes: +- Viterbi decoding: greedy decoding without a language model +- KenLM decoding: decoding with an arpa-format KenLM n-gram language model +- Fairseq-LM deocding: decoding with a Fairseq neural language model + + +#### Viterbi decoding + +`task.normalize` needs to be consistent with the value used during fine-tuning. +Decoding results will be saved at +`/path/to/experiment/directory/decode/viterbi/test`. + +```sh +$ python examples/speech_recognition/new/infer.py \ + --config-dir /path/to/fairseq-py/examples/hubert/config/decode \ + --config-name infer_viterbi \ + task.data=/path/to/data \ + task.normalize=[true|false] \ + decoding.exp_dir=/path/to/experiment/directory \ + common_eval.path=/path/to/checkpoint + dataset.gen_subset=test \ +``` + +#### KenLM / Fairseq-LM decoding + +Suppose the pronunciation lexicon and the n-gram LM are saved at +`/path/to/lexicon` and `/path/to/arpa`, respectively. Decoding results will be +saved at `/path/to/experiment/directory/decode/kenlm/test`. + +```sh +$ python examples/speech_recognition/new/infer.py \ + --config-dir /path/to/fairseq-py/examples/hubert/config/decode \ + --config-name infer_kenlm \ + task.data=/path/to/data \ + task.normalize=[true|false] \ + decoding.exp_dir=/path/to/experiment/directory \ + common_eval.path=/path/to/checkpoint + dataset.gen_subset=test \ + decoding.decoder.lexicon=/path/to/lexicon \ + decoding.decoder.lmpath=/path/to/arpa +``` + +The command above uses the default decoding hyperparameter, which can be found +in `examples/speech_recognition/hydra/decoder.py`. These parameters can be +configured from the command line. For example, to search with a beam size of +500, we can append the command above with `decoding.decoder.beam=500`. +Important parameters include: +- decoding.decoder.beam +- decoding.decoder.beamthreshold +- decoding.decoder.lmweight +- decoding.decoder.wordscore +- decoding.decoder.silweight + +To decode with a Fairseq LM, use `--config-name infer_fsqlm` instead, and +change the path of lexicon and LM accordingly. diff --git a/fairseq/examples/hubert/config/decode/ax_sweep/ngram.yaml b/fairseq/examples/hubert/config/decode/ax_sweep/ngram.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5a02df1f7da7eebfebe4018ef2758a716fbab646 --- /dev/null +++ b/fairseq/examples/hubert/config/decode/ax_sweep/ngram.yaml @@ -0,0 +1,33 @@ +# @package _global_ + +common_eval: + results_path: ${decoding.exp_dir}/decode/${decoding.decoder.name}_ax/${dataset.gen_subset} + +hydra: + sweeper: + ax_config: + max_trials: 60 + early_stop: + minimize: true + max_epochs_without_improvement: 10 + epsilon: 0.025 + experiment: + name: ${dataset.gen_subset} + objective_name: wer + minimize: true + parameter_constraints: null + outcome_constraints: null + status_quo: null + client: + verbose_logging: false + random_seed: null + params: + decoding.decoder.lmweight: + type: range + bounds: [0.0, 8.0] + decoding.decoder.wordscore: + type: range + bounds: [-5.0, 5.0] + decoding.decoder.silweight: + type: range + bounds: [-10.0, 0.0] diff --git a/fairseq/examples/hubert/config/decode/ax_sweep/transformer.yaml b/fairseq/examples/hubert/config/decode/ax_sweep/transformer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..85ed3bd1a5a44871260f572786044c28f441add6 --- /dev/null +++ b/fairseq/examples/hubert/config/decode/ax_sweep/transformer.yaml @@ -0,0 +1,33 @@ +# @package _global_ + +common_eval: + results_path: ${decoding.exp_dir}/decode/${decoding.decoder.name}_ax/${dataset.gen_subset} + +hydra: + sweeper: + ax_config: + max_trials: 60 + early_stop: + minimize: true + max_epochs_without_improvement: 10 + epsilon: 0.025 + experiment: + name: ${dataset.gen_subset} + objective_name: wer + minimize: true + parameter_constraints: null + outcome_constraints: null + status_quo: null + client: + verbose_logging: false + random_seed: null + params: + decoding.decoder.lmweight: + type: range + bounds: [0.0, 4.0] + decoding.decoder.wordscore: + type: range + bounds: [-5.0, 5.0] + decoding.decoder.silweight: + type: range + bounds: [-8.0, 0.0] diff --git a/fairseq/examples/hubert/config/decode/infer_fsqlm.yaml b/fairseq/examples/hubert/config/decode/infer_fsqlm.yaml new file mode 100644 index 0000000000000000000000000000000000000000..026ad8db89a0673969a99fed6e1e84fc41fc7a1a --- /dev/null +++ b/fairseq/examples/hubert/config/decode/infer_fsqlm.yaml @@ -0,0 +1,36 @@ +# @package _group_ + +defaults: + - model: null + +hydra: + run: + dir: ${common_eval.results_path}/beam${decoding.beam}_th${decoding.beamthreshold}_lmw${decoding.lmweight}_wrd${decoding.wordscore}_sil${decoding.silweight} + sweep: + dir: ${common_eval.results_path} + subdir: beam${decoding.beam}_th${decoding.beamthreshold}_lmw${decoding.lmweight}_wrd${decoding.wordscore}_sil${decoding.silweight} + +task: + _name: hubert_pretraining + single_target: true + fine_tuning: true + data: ??? + normalize: ??? + +decoding: + type: fairseqlm + lexicon: ??? + lmpath: ??? + beamthreshold: 25 + beam: 500 + lmweight: 2 + wordscore: -1 + silweight: 0 + unique_wer_file: true +common_eval: + results_path: ??? + path: ??? + post_process: letter +dataset: + max_tokens: 1100000 + gen_subset: ??? diff --git a/fairseq/examples/hubert/config/decode/infer_kenlm.yaml b/fairseq/examples/hubert/config/decode/infer_kenlm.yaml new file mode 100644 index 0000000000000000000000000000000000000000..04642aeb6530133ab44e12e11e3d1661e3b9c32c --- /dev/null +++ b/fairseq/examples/hubert/config/decode/infer_kenlm.yaml @@ -0,0 +1,36 @@ +# @package _group_ + +defaults: + - model: null + +hydra: + run: + dir: ${common_eval.results_path}/beam${decoding.beam}_th${decoding.beamthreshold}_lmw${decoding.lmweight}_wrd${decoding.wordscore}_sil${decoding.silweight} + sweep: + dir: ${common_eval.results_path} + subdir: beam${decoding.beam}_th${decoding.beamthreshold}_lmw${decoding.lmweight}_wrd${decoding.wordscore}_sil${decoding.silweight} + +task: + _name: hubert_pretraining + single_target: true + fine_tuning: true + data: ??? + normalize: ??? + +decoding: + type: kenlm + lexicon: ??? + lmpath: ??? + beamthreshold: 100 + beam: 500 + lmweight: 2 + wordscore: -1 + silweight: 0 + unique_wer_file: true +common_eval: + results_path: ??? + path: ??? + post_process: letter +dataset: + max_tokens: 1100000 + gen_subset: ??? diff --git a/fairseq/examples/hubert/config/decode/infer_viterbi.yaml b/fairseq/examples/hubert/config/decode/infer_viterbi.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4afc74c18ca890e1a20c6beabeb9059dd0f480f4 --- /dev/null +++ b/fairseq/examples/hubert/config/decode/infer_viterbi.yaml @@ -0,0 +1,29 @@ +# @package _group_ + +defaults: + - model: null + +hydra: + run: + dir: ${common_eval.results_path}/viterbi + sweep: + dir: ${common_eval.results_path} + subdir: viterbi + +task: + _name: hubert_pretraining + single_target: true + fine_tuning: true + data: ??? + normalize: ??? + +decoding: + type: viterbi + unique_wer_file: true +common_eval: + results_path: ??? + path: ??? + post_process: letter +dataset: + max_tokens: 1100000 + gen_subset: ??? diff --git a/fairseq/examples/hubert/config/decode/run/submitit_slurm.yaml b/fairseq/examples/hubert/config/decode/run/submitit_slurm.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0b8065832ecacf9dd4fe4e99c87941e00fb3ef7f --- /dev/null +++ b/fairseq/examples/hubert/config/decode/run/submitit_slurm.yaml @@ -0,0 +1,17 @@ +# @package _global_ +hydra: + launcher: + cpus_per_task: ${distributed_training.distributed_world_size} + gpus_per_node: ${distributed_training.distributed_world_size} + tasks_per_node: ${hydra.launcher.gpus_per_node} + nodes: 1 + mem_gb: 200 + timeout_min: 4320 + max_num_timeout: 50 + name: ${hydra.job.config_name} + submitit_folder: ${hydra.sweep.dir}/submitit + +distributed_training: + distributed_world_size: 1 + distributed_no_spawn: true + distributed_port: 29761 diff --git a/fairseq/examples/hubert/config/decode/run/submitit_slurm_8gpu.yaml b/fairseq/examples/hubert/config/decode/run/submitit_slurm_8gpu.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2f669f376312dbfe4611cc08f4996a314155fb87 --- /dev/null +++ b/fairseq/examples/hubert/config/decode/run/submitit_slurm_8gpu.yaml @@ -0,0 +1,17 @@ +# @package _global_ +hydra: + launcher: + cpus_per_task: ${distributed_training.distributed_world_size} + gpus_per_node: ${distributed_training.distributed_world_size} + tasks_per_node: ${hydra.launcher.gpus_per_node} + nodes: 1 + mem_gb: 200 + timeout_min: 4320 + max_num_timeout: 50 + name: ${hydra.job.config_name} + submitit_folder: ${hydra.sweep.dir}/submitit + +distributed_training: + distributed_world_size: 8 + distributed_no_spawn: true + distributed_port: 29761 diff --git a/fairseq/examples/hubert/config/finetune/base_10h.yaml b/fairseq/examples/hubert/config/finetune/base_10h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a22c7c0347f792221f209bcfba7ba380a69f90a8 --- /dev/null +++ b/fairseq/examples/hubert/config/finetune/base_10h.yaml @@ -0,0 +1,100 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + tensorboard_logdir: tblog + seed: 1337 + +checkpoint: + save_interval: 5 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +distributed_training: + ddp_backend: c10d + find_unused_parameters: true + distributed_world_size: 1 + distributed_port: 29671 + nprocs_per_node: 8 + +task: + _name: hubert_pretraining + data: ??? + fine_tuning: true + label_dir: ??? + normalize: false # must be consistent with pre-training + labels: ["ltr"] + single_target: true + +dataset: + num_workers: 0 + max_tokens: 3200000 + validate_after_updates: ${model.freeze_finetune_updates} + validate_interval: 5 + train_subset: train + valid_subset: valid + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 25000 + lr: [2e-5] + sentence_avg: true + update_freq: [1] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + warmup_steps: 8000 + hold_steps: 0 + decay_steps: 72000 + final_lr_scale: 0.05 + +model: + _name: hubert_ctc + w2v_path: ??? + apply_mask: true + mask_selection: static + mask_length: 10 + mask_other: 0 + mask_prob: 0.75 + mask_channel_selection: static + mask_channel_length: 64 + mask_channel_other: 0 + mask_channel_prob: 0.5 + layerdrop: 0.1 + dropout: 0.0 + activation_dropout: 0.1 + attention_dropout: 0.0 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 + +hydra: + job: + config: + override_dirname: + kv_sep: '-' + item_sep: '__' + exclude_keys: + - run + - task.data + - task.label_dir + - model.w2v_path + - dataset.train_subset + - dataset.valid_subset + - criterion.wer_kenlm_model + - criterion.wer_lexicon + run: + dir: ??? + sweep: + dir: ??? + subdir: ${hydra.job.config_name}__${hydra.job.override_dirname} diff --git a/fairseq/examples/hubert/config/finetune/ckpt/it1.yaml b/fairseq/examples/hubert/config/finetune/ckpt/it1.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2af96b3f72746f85feb13e7efcbdab6602b293de --- /dev/null +++ b/fairseq/examples/hubert/config/finetune/ckpt/it1.yaml @@ -0,0 +1,7 @@ +# @package _global_ + +task: + normalize: false + +model: + w2v_path: /checkpoint/wnhsu/w2v/hubert_final/iter1/hubert.km.randcrop.pmw1_0.puw0_0.grpnorm.ml10.mp0_8.untie.mxsz250000.ufreq1.maxtok1400000.MU400k.s1337.ngpu32/checkpoint_last.pt diff --git a/fairseq/examples/hubert/config/finetune/lm/ls_4gram.yaml b/fairseq/examples/hubert/config/finetune/lm/ls_4gram.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8c7728ad29965d3cf18605808a893bc442afd56b --- /dev/null +++ b/fairseq/examples/hubert/config/finetune/lm/ls_4gram.yaml @@ -0,0 +1,7 @@ +# @package _global_ + +criterion: + wer_kenlm_model: /checkpoint/abdo/old_checkpoint02/datasets/librispeech/4-gram.bin + wer_lexicon: /checkpoint/abdo/old_checkpoint02/datasets/librispeech/10h/raw/lexicon_ltr.lst + wer_lm_weight: 2.0 + wer_word_score: -1.0 diff --git a/fairseq/examples/hubert/config/finetune/run/submitit_reg.yaml b/fairseq/examples/hubert/config/finetune/run/submitit_reg.yaml new file mode 100644 index 0000000000000000000000000000000000000000..27509503e7b306c07742fbed2fc5726d001bb7df --- /dev/null +++ b/fairseq/examples/hubert/config/finetune/run/submitit_reg.yaml @@ -0,0 +1,20 @@ +# @package _global_ + +hydra: + launcher: + cpus_per_task: 8 + gpus_per_node: 8 + tasks_per_node: ${hydra.launcher.gpus_per_node} + nodes: 1 + comment: null + mem_gb: 384 + timeout_min: 4320 + max_num_timeout: 100 + constraint: volta32gb + name: ${hydra.job.config_name}/${hydra.job.override_dirname} + submitit_folder: ${hydra.sweep.dir}/submitit/%j + +distributed_training: + distributed_world_size: 8 + distributed_port: 29671 + nprocs_per_node: 8 diff --git a/fairseq/examples/hubert/config/pretrain/data/iter1.yaml b/fairseq/examples/hubert/config/pretrain/data/iter1.yaml new file mode 100644 index 0000000000000000000000000000000000000000..0a1b65d802c83128c53f32b21807fa5e51da6cc9 --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/data/iter1.yaml @@ -0,0 +1,8 @@ +# @package _global_ + +task: + label_dir: ??? + labels: ["km"] + +model: + label_rate: 100 diff --git a/fairseq/examples/hubert/config/pretrain/data/iter2.yaml b/fairseq/examples/hubert/config/pretrain/data/iter2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d4bfe61cc638af9de48e92c58994e435fba2abf --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/data/iter2.yaml @@ -0,0 +1,8 @@ +# @package _global_ + +task: + label_dir: ??? + labels: ["km"] + +model: + label_rate: 50 diff --git a/fairseq/examples/hubert/config/pretrain/hubert_base_librispeech.yaml b/fairseq/examples/hubert/config/pretrain/hubert_base_librispeech.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bd84461a163866f622b01bf6d36b4de6215f3d97 --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/hubert_base_librispeech.yaml @@ -0,0 +1,97 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + seed: 1337 + tensorboard_logdir: tblog + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + + +distributed_training: + ddp_backend: no_c10d + distributed_backend: 'nccl' + distributed_world_size: 32 + distributed_port: 29671 + nprocs_per_node: 8 + find_unused_parameters: true + +task: + _name: hubert_pretraining + data: ??? + label_dir: ??? + labels: ??? + label_rate: ${model.label_rate} + sample_rate: 16000 + max_sample_size: 250000 + min_sample_size: 32000 + pad_audio: false + random_crop: true + normalize: false # must be consistent with extractor + +dataset: + num_workers: 6 + max_tokens: 1400000 + skip_invalid_size_inputs_valid_test: true + validate_interval: 5 + validate_interval_updates: 10000 + +criterion: + _name: hubert + pred_masked_weight: 1.0 + pred_nomask_weight: 0.0 + loss_weights: [10,] + +optimization: + max_update: 400000 + lr: [0.0005] + clip_norm: 10.0 + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: hubert + label_rate: ??? + skip_masked: false + skip_nomask: false + mask_prob: 0.80 + extractor_mode: default + conv_feature_layers: '[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2' + final_dim: 256 + encoder_layerdrop: 0.05 + dropout_input: 0.1 + dropout_features: 0.1 + dropout: 0.1 + attention_dropout: 0.1 + feature_grad_mult: 0.1 + untie_final_proj: true + activation_dropout: 0.0 + +hydra: + job: + config: + override_dirname: + kv_sep: '-' + item_sep: '__' + exclude_keys: + - run + - task.data + - task.label_dir + run: + dir: ??? + sweep: + dir: ??? + subdir: ${hydra.job.config_name}__${hydra.job.override_dirname} diff --git a/fairseq/examples/hubert/config/pretrain/hubert_large_librivox.yaml b/fairseq/examples/hubert/config/pretrain/hubert_large_librivox.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a5192b5f29b53aa8391a0ab67b6238c0d0b4985e --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/hubert_large_librivox.yaml @@ -0,0 +1,101 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + seed: 1337 + tensorboard_logdir: tblog + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + + +distributed_training: + ddp_backend: no_c10d + distributed_backend: 'nccl' + distributed_world_size: 128 + distributed_port: 29671 + nprocs_per_node: 8 + find_unused_parameters: true + +task: + _name: hubert_pretraining + data: ??? + label_dir: ??? + labels: ??? + label_rate: ${model.label_rate} + sample_rate: 16000 + max_sample_size: 250000 + min_sample_size: 32000 + pad_audio: false + random_crop: true + normalize: true # must be consistent with extractor + +dataset: + num_workers: 6 + max_tokens: 900000 + skip_invalid_size_inputs_valid_test: true + validate_interval: 5 + validate_interval_updates: 10000 + +criterion: + _name: hubert + pred_masked_weight: 1.0 + pred_nomask_weight: 0.0 + loss_weights: [10,] + +optimization: + max_update: 400000 + lr: [0.0015] + clip_norm: 1.0 + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: hubert + label_rate: ??? + encoder_layers: 24 + encoder_embed_dim: 1024 + encoder_ffn_embed_dim: 4096 + encoder_attention_heads: 16 + final_dim: 768 + skip_masked: false + skip_nomask: false + mask_prob: 0.80 + extractor_mode: layer_norm + conv_feature_layers: '[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2' + encoder_layerdrop: 0.0 + dropout_input: 0.0 + dropout_features: 0.0 + dropout: 0.0 + attention_dropout: 0.0 + layer_norm_first: true + feature_grad_mult: 1.0 + untie_final_proj: true + activation_dropout: 0.0 + +hydra: + job: + config: + override_dirname: + kv_sep: '-' + item_sep: '__' + exclude_keys: + - run + - task.data + run: + dir: /checkpoint/wnhsu/w2v/hubert_final/hydra_pt + sweep: + dir: /checkpoint/wnhsu/w2v/hubert_final/hydra_pt + subdir: ${hydra.job.config_name}__${hydra.job.override_dirname} diff --git a/fairseq/examples/hubert/config/pretrain/hubert_xlarge_librivox.yaml b/fairseq/examples/hubert/config/pretrain/hubert_xlarge_librivox.yaml new file mode 100644 index 0000000000000000000000000000000000000000..34e8f2bfb93863db122f694785b80857713ceb05 --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/hubert_xlarge_librivox.yaml @@ -0,0 +1,101 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + seed: 1337 + tensorboard_logdir: tblog + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + + +distributed_training: + ddp_backend: no_c10d + distributed_backend: 'nccl' + distributed_world_size: 256 + distributed_port: 29671 + nprocs_per_node: 8 + find_unused_parameters: true + +task: + _name: hubert_pretraining + data: ??? + label_dir: ??? + labels: ??? + label_rate: ${model.label_rate} + sample_rate: 16000 + max_sample_size: 250000 + min_sample_size: 32000 + pad_audio: false + random_crop: true + normalize: true # must be consistent with extractor + +dataset: + num_workers: 6 + max_tokens: 360000 + skip_invalid_size_inputs_valid_test: true + validate_interval: 5 + validate_interval_updates: 10000 + +criterion: + _name: hubert + pred_masked_weight: 1.0 + pred_nomask_weight: 0.0 + loss_weights: [10,] + +optimization: + max_update: 400000 + lr: [0.003] + clip_norm: 1.0 + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: hubert + label_rate: ??? + encoder_layers: 48 + encoder_embed_dim: 1280 + encoder_ffn_embed_dim: 5120 + encoder_attention_heads: 16 + final_dim: 1024 + skip_masked: false + skip_nomask: false + mask_prob: 0.80 + extractor_mode: layer_norm + conv_feature_layers: '[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2' + encoder_layerdrop: 0.0 + dropout_input: 0.0 + dropout_features: 0.0 + dropout: 0.0 + attention_dropout: 0.0 + layer_norm_first: true + feature_grad_mult: 1.0 + untie_final_proj: true + activation_dropout: 0.0 + +hydra: + job: + config: + override_dirname: + kv_sep: '-' + item_sep: '__' + exclude_keys: + - run + - task.data + run: + dir: /checkpoint/wnhsu/w2v/hubert_final/hydra_pt + sweep: + dir: /checkpoint/wnhsu/w2v/hubert_final/hydra_pt + subdir: ${hydra.job.config_name}__${hydra.job.override_dirname} diff --git a/fairseq/examples/hubert/config/pretrain/run/submitit_reg.yaml b/fairseq/examples/hubert/config/pretrain/run/submitit_reg.yaml new file mode 100644 index 0000000000000000000000000000000000000000..46c979cd2835fe026b0a532a54533904d1001e54 --- /dev/null +++ b/fairseq/examples/hubert/config/pretrain/run/submitit_reg.yaml @@ -0,0 +1,20 @@ +# @package _global_ + +hydra: + launcher: + cpus_per_task: 8 + gpus_per_node: 8 + tasks_per_node: ${hydra.launcher.gpus_per_node} + nodes: 4 + comment: null + mem_gb: 384 + timeout_min: 4320 + max_num_timeout: 100 + constraint: volta32gb + name: ${hydra.job.config_name}/${hydra.job.override_dirname} + submitit_folder: ${hydra.sweep.dir}/submitit/%j + +distributed_training: + distributed_world_size: 32 + distributed_port: 29671 + nprocs_per_node: 8 diff --git a/fairseq/examples/hubert/measure_teacher_quality.py b/fairseq/examples/hubert/measure_teacher_quality.py new file mode 100644 index 0000000000000000000000000000000000000000..92279b2214bb2ba4a99aea92098907ef4f55821b --- /dev/null +++ b/fairseq/examples/hubert/measure_teacher_quality.py @@ -0,0 +1,241 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import os.path as op +import re +from tabulate import tabulate +from collections import Counter + + +def comp_purity(p_xy, axis): + max_p = p_xy.max(axis=axis) + marg_p = p_xy.sum(axis=axis) + indv_pur = max_p / marg_p + aggr_pur = max_p.sum() + return indv_pur, aggr_pur + + +def comp_entropy(p): + return (-p * np.log(p + 1e-8)).sum() + + +def comp_norm_mutual_info(p_xy): + p_x = p_xy.sum(axis=1, keepdims=True) + p_y = p_xy.sum(axis=0, keepdims=True) + pmi = np.log(p_xy / np.matmul(p_x, p_y) + 1e-8) + mi = (p_xy * pmi).sum() + h_x = comp_entropy(p_x) + h_y = comp_entropy(p_y) + return mi, mi / h_x, mi / h_y, h_x, h_y + + +def pad(labs, n): + if n == 0: + return np.array(labs) + return np.concatenate([[labs[0]] * n, labs, [labs[-1]] * n]) + + +def comp_avg_seg_dur(labs_list): + n_frms = 0 + n_segs = 0 + for labs in labs_list: + labs = np.array(labs) + edges = np.zeros(len(labs)).astype(bool) + edges[0] = True + edges[1:] = labs[1:] != labs[:-1] + n_frms += len(edges) + n_segs += edges.astype(int).sum() + return n_frms / n_segs + + +def comp_joint_prob(uid2refs, uid2hyps): + """ + Args: + pad: padding for spliced-feature derived labels + """ + cnts = Counter() + skipped = [] + abs_frmdiff = 0 + for uid in uid2refs: + if uid not in uid2hyps: + skipped.append(uid) + continue + refs = uid2refs[uid] + hyps = uid2hyps[uid] + abs_frmdiff += abs(len(refs) - len(hyps)) + min_len = min(len(refs), len(hyps)) + refs = refs[:min_len] + hyps = hyps[:min_len] + cnts.update(zip(refs, hyps)) + tot = sum(cnts.values()) + + ref_set = sorted({ref for ref, _ in cnts.keys()}) + hyp_set = sorted({hyp for _, hyp in cnts.keys()}) + ref2pid = dict(zip(ref_set, range(len(ref_set)))) + hyp2lid = dict(zip(hyp_set, range(len(hyp_set)))) + # print(hyp_set) + p_xy = np.zeros((len(ref2pid), len(hyp2lid)), dtype=float) + for (ref, hyp), cnt in cnts.items(): + p_xy[ref2pid[ref], hyp2lid[hyp]] = cnt + p_xy /= p_xy.sum() + return p_xy, ref2pid, hyp2lid, tot, abs_frmdiff, skipped + + +def read_phn(tsv_path, rm_stress=True): + uid2phns = {} + with open(tsv_path) as f: + for line in f: + uid, phns = line.rstrip().split("\t") + phns = phns.split(",") + if rm_stress: + phns = [re.sub("[0-9]", "", phn) for phn in phns] + uid2phns[uid] = phns + return uid2phns + + +def read_lab(tsv_path, lab_path, pad_len=0, upsample=1): + """ + tsv is needed to retrieve the uids for the labels + """ + with open(tsv_path) as f: + f.readline() + uids = [op.splitext(op.basename(line.rstrip().split()[0]))[0] for line in f] + with open(lab_path) as f: + labs_list = [pad(line.rstrip().split(), pad_len).repeat(upsample) for line in f] + assert len(uids) == len(labs_list) + return dict(zip(uids, labs_list)) + + +def main_lab_lab( + tsv_dir, + lab_dir, + lab_name, + lab_sets, + ref_dir, + ref_name, + pad_len=0, + upsample=1, + verbose=False, +): + # assume tsv_dir is the same for both the reference and the hypotheses + tsv_dir = lab_dir if tsv_dir is None else tsv_dir + + uid2refs = {} + for s in lab_sets: + uid2refs.update(read_lab(f"{tsv_dir}/{s}.tsv", f"{ref_dir}/{s}.{ref_name}")) + + uid2hyps = {} + for s in lab_sets: + uid2hyps.update( + read_lab( + f"{tsv_dir}/{s}.tsv", f"{lab_dir}/{s}.{lab_name}", pad_len, upsample + ) + ) + _main(uid2refs, uid2hyps, verbose) + + +def main_phn_lab( + tsv_dir, + lab_dir, + lab_name, + lab_sets, + phn_dir, + phn_sets, + pad_len=0, + upsample=1, + verbose=False, +): + uid2refs = {} + for s in phn_sets: + uid2refs.update(read_phn(f"{phn_dir}/{s}.tsv")) + + uid2hyps = {} + tsv_dir = lab_dir if tsv_dir is None else tsv_dir + for s in lab_sets: + uid2hyps.update( + read_lab( + f"{tsv_dir}/{s}.tsv", f"{lab_dir}/{s}.{lab_name}", pad_len, upsample + ) + ) + _main(uid2refs, uid2hyps, verbose) + + +def _main(uid2refs, uid2hyps, verbose): + (p_xy, ref2pid, hyp2lid, tot, frmdiff, skipped) = comp_joint_prob( + uid2refs, uid2hyps + ) + ref_pur_by_hyp, ref_pur = comp_purity(p_xy, axis=0) + hyp_pur_by_ref, hyp_pur = comp_purity(p_xy, axis=1) + (mi, mi_norm_by_ref, mi_norm_by_hyp, h_ref, h_hyp) = comp_norm_mutual_info(p_xy) + outputs = { + "ref pur": ref_pur, + "hyp pur": hyp_pur, + "H(ref)": h_ref, + "H(hyp)": h_hyp, + "MI": mi, + "MI/H(ref)": mi_norm_by_ref, + "ref segL": comp_avg_seg_dur(uid2refs.values()), + "hyp segL": comp_avg_seg_dur(uid2hyps.values()), + "p_xy shape": p_xy.shape, + "frm tot": tot, + "frm diff": frmdiff, + "utt tot": len(uid2refs), + "utt miss": len(skipped), + } + print(tabulate([outputs.values()], outputs.keys(), floatfmt=".4f")) + + +if __name__ == "__main__": + """ + compute quality of labels with respect to phone or another labels if set + """ + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("tsv_dir") + parser.add_argument("lab_dir") + parser.add_argument("lab_name") + parser.add_argument("--lab_sets", default=["valid"], type=str, nargs="+") + parser.add_argument( + "--phn_dir", + default="/checkpoint/wnhsu/data/librispeech/960h/fa/raw_phn/phone_frame_align_v1", + ) + parser.add_argument( + "--phn_sets", default=["dev-clean", "dev-other"], type=str, nargs="+" + ) + parser.add_argument("--pad_len", default=0, type=int, help="padding for hypotheses") + parser.add_argument( + "--upsample", default=1, type=int, help="upsample factor for hypotheses" + ) + parser.add_argument("--ref_lab_dir", default="") + parser.add_argument("--ref_lab_name", default="") + parser.add_argument("--verbose", action="store_true") + args = parser.parse_args() + + if args.ref_lab_dir and args.ref_lab_name: + main_lab_lab( + args.tsv_dir, + args.lab_dir, + args.lab_name, + args.lab_sets, + args.ref_lab_dir, + args.ref_lab_name, + args.pad_len, + args.upsample, + args.verbose, + ) + else: + main_phn_lab( + args.tsv_dir, + args.lab_dir, + args.lab_name, + args.lab_sets, + args.phn_dir, + args.phn_sets, + args.pad_len, + args.upsample, + args.verbose, + ) diff --git a/fairseq/examples/hubert/simple_kmeans/README.md b/fairseq/examples/hubert/simple_kmeans/README.md new file mode 100644 index 0000000000000000000000000000000000000000..cd17da3b3e6f3e39083f7a76a56ff46c3a63b929 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/README.md @@ -0,0 +1,71 @@ +# Sharded Feature Extraction and K-means Application + +This folder contains scripts for preparing HUBERT labels from tsv files, the +steps are: +1. feature extraction +2. k-means clustering +3. k-means application + + +## Data preparation + +`*.tsv` files contains a list of audio, where each line is the root, and +following lines are the subpath for each audio: +``` + + + +... +``` + + +## Feature extraction + +### MFCC feature +Suppose the tsv file is at `${tsv_dir}/${split}.tsv`. To extract 39-D +mfcc+delta+ddelta features for the 1st iteration HUBERT training, run: +```sh +python dump_mfcc_feature.py ${tsv_dir} ${split} ${nshard} ${rank} ${feat_dir} +``` +This would shard the tsv file into `${nshard}` and extract features for the +`${rank}`-th shard, where rank is an integer in `[0, nshard-1]`. Features would +be saved at `${feat_dir}/${split}_${rank}_${nshard}.{npy,len}`. + + +### HUBERT feature +To extract features from the `${layer}`-th transformer layer of a trained +HUBERT model saved at `${ckpt_path}`, run: +```sh +python dump_hubert_feature.py ${tsv_dir} ${split} ${ckpt_path} ${layer} ${nshard} ${rank} ${feat_dir} +``` +Features would also be saved at `${feat_dir}/${split}_${rank}_${nshard}.{npy,len}`. + +- if out-of-memory, decrease the chunk size with `--max_chunk` + + +## K-means clustering +To fit a k-means model with `${n_clusters}` clusters on 10% of the `${split}` data, run +```sh +python learn_kmeans.py ${feat_dir} ${split} ${nshard} ${km_path} ${n_cluster} --percent 0.1 +``` +This saves the k-means model to `${km_path}`. + +- set `--precent -1` to use all data +- more kmeans options can be found with `-h` flag + + +## K-means application +To apply a trained k-means model `${km_path}` to obtain labels for `${split}`, run +```sh +python dump_km_label.py ${feat_dir} ${split} ${km_path} ${nshard} ${rank} ${lab_dir} +``` +This would extract labels for the `${rank}`-th shard out of `${nshard}` shards +and dump them to `${lab_dir}/${split}_${rank}_${shard}.km` + + +Finally, merge shards for `${split}` by running +```sh +for rank in $(seq 0 $((nshard - 1))); do + cat $lab_dir/${split}_${rank}_${nshard}.km +done > $lab_dir/${split}.km +``` diff --git a/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature.py b/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature.py new file mode 100644 index 0000000000000000000000000000000000000000..5c7b67f8b1967ca515c5f7606253b46f903ea37e --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature.py @@ -0,0 +1,93 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import fairseq +import soundfile as sf +import torch +import torch.nn.functional as F + +from feature_utils import get_path_iterator, dump_feature + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("dump_hubert_feature") + + +class HubertFeatureReader(object): + def __init__(self, ckpt_path, layer, max_chunk=1600000): + ( + model, + cfg, + task, + ) = fairseq.checkpoint_utils.load_model_ensemble_and_task([ckpt_path]) + self.model = model[0].eval().cuda() + self.task = task + self.layer = layer + self.max_chunk = max_chunk + logger.info(f"TASK CONFIG:\n{self.task.cfg}") + logger.info(f" max_chunk = {self.max_chunk}") + + def read_audio(self, path, ref_len=None): + wav, sr = sf.read(path) + assert sr == self.task.cfg.sample_rate, sr + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + if ref_len is not None and abs(ref_len - len(wav)) > 160: + logging.warning(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + def get_feats(self, path, ref_len=None): + x = self.read_audio(path, ref_len) + with torch.no_grad(): + x = torch.from_numpy(x).float().cuda() + if self.task.cfg.normalize: + x = F.layer_norm(x, x.shape) + x = x.view(1, -1) + + feat = [] + for start in range(0, x.size(1), self.max_chunk): + x_chunk = x[:, start: start + self.max_chunk] + feat_chunk, _ = self.model.extract_features( + source=x_chunk, + padding_mask=None, + mask=False, + output_layer=self.layer, + ) + feat.append(feat_chunk) + return torch.cat(feat, 1).squeeze(0) + + +def main(tsv_dir, split, ckpt_path, layer, nshard, rank, feat_dir, max_chunk): + reader = HubertFeatureReader(ckpt_path, layer, max_chunk) + generator, num = get_path_iterator(f"{tsv_dir}/{split}.tsv", nshard, rank) + dump_feature(reader, generator, num, split, nshard, rank, feat_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("tsv_dir") + parser.add_argument("split") + parser.add_argument("ckpt_path") + parser.add_argument("layer", type=int) + parser.add_argument("nshard", type=int) + parser.add_argument("rank", type=int) + parser.add_argument("feat_dir") + parser.add_argument("--max_chunk", type=int, default=1600000) + args = parser.parse_args() + logger.info(args) + + main(**vars(args)) diff --git a/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py b/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py new file mode 100644 index 0000000000000000000000000000000000000000..6fff4faf44a92d42504559ecea8ec1047d2e5f14 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/dump_hubert_feature_s2t.py @@ -0,0 +1,92 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import csv +import io +import logging +import os +import os.path as op +import sys + +from dump_hubert_feature import HubertFeatureReader +from feature_utils import get_shard_range, dump_feature +from fairseq.data.audio.audio_utils import get_waveform +from fairseq.data.audio.speech_to_text_dataset import ( + read_from_uncompressed_zip, +) + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("dump_hubert_feature_s2t") + + +class HubertFeatureReaderS2T(HubertFeatureReader): + def read_audio(self, path, ref_len=None): + path, *extra = path.split(":") + assert len(extra) == 2 + assert path.endswith(".zip") + + data = read_from_uncompressed_zip(path, int(extra[0]), int(extra[1])) + f = io.BytesIO(data) + wav, sr = get_waveform(f) + assert sr == self.task.cfg.sample_rate, sr + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + if ref_len is not None and abs(ref_len - len(wav)) > 160: + logging.warning(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + +def get_path_iterator(root, tsv, nshard, rank): + with open(tsv) as f: + reader = csv.DictReader( + f, + delimiter="\t", + quotechar=None, + doublequote=False, + lineterminator="\n", + quoting=csv.QUOTE_NONE, + ) + subpaths = [op.join(root, e["audio"]) for e in reader] + start, end = get_shard_range(len(subpaths), nshard, rank) + subpaths = subpaths[start:end] + def iterate(): + for subpath in subpaths: + yield op.join(root, subpath), None + return iterate, len(subpaths) + + +def main( + root, tsv_path, ckpt_path, layer, nshard, rank, feat_dir, split, max_chunk +): + reader = HubertFeatureReaderS2T(ckpt_path, layer, max_chunk) + generator, num = get_path_iterator(root, tsv_path, nshard, rank) + dump_feature(reader, generator, num, split, nshard, rank, feat_dir) + + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("root") + parser.add_argument("tsv_path") + parser.add_argument("ckpt_path") + parser.add_argument("layer", type=int) + parser.add_argument("nshard", type=int) + parser.add_argument("rank", type=int) + parser.add_argument("feat_dir") + parser.add_argument("split") + parser.add_argument("--max_chunk", type=int, default=1600000) + args = parser.parse_args() + logger.info(args) + + main(**vars(args)) diff --git a/fairseq/examples/hubert/simple_kmeans/dump_km_label.py b/fairseq/examples/hubert/simple_kmeans/dump_km_label.py new file mode 100644 index 0000000000000000000000000000000000000000..8871307804d3f1e5c7cc49061614c69df26ab1ee --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/dump_km_label.py @@ -0,0 +1,98 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import numpy as np + +import joblib +import torch +import tqdm + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("dump_km_label") + + +class ApplyKmeans(object): + def __init__(self, km_path): + self.km_model = joblib.load(km_path) + self.C_np = self.km_model.cluster_centers_.transpose() + self.Cnorm_np = (self.C_np ** 2).sum(0, keepdims=True) + + self.C = torch.from_numpy(self.C_np) + self.Cnorm = torch.from_numpy(self.Cnorm_np) + if torch.cuda.is_available(): + self.C = self.C.cuda() + self.Cnorm = self.Cnorm.cuda() + + def __call__(self, x): + if isinstance(x, torch.Tensor): + dist = ( + x.pow(2).sum(1, keepdim=True) + - 2 * torch.matmul(x, self.C) + + self.Cnorm + ) + return dist.argmin(dim=1).cpu().numpy() + else: + dist = ( + (x ** 2).sum(1, keepdims=True) + - 2 * np.matmul(x, self.C_np) + + self.Cnorm_np + ) + return np.argmin(dist, axis=1) + + +def get_feat_iterator(feat_dir, split, nshard, rank): + feat_path = f"{feat_dir}/{split}_{rank}_{nshard}.npy" + leng_path = f"{feat_dir}/{split}_{rank}_{nshard}.len" + with open(leng_path, "r") as f: + lengs = [int(line.rstrip()) for line in f] + offsets = [0] + np.cumsum(lengs[:-1]).tolist() + + def iterate(): + feat = np.load(feat_path, mmap_mode="r") + assert feat.shape[0] == (offsets[-1] + lengs[-1]) + for offset, leng in zip(offsets, lengs): + yield feat[offset: offset + leng] + + return iterate, len(lengs) + + +def dump_label(feat_dir, split, km_path, nshard, rank, lab_dir): + apply_kmeans = ApplyKmeans(km_path) + generator, num = get_feat_iterator(feat_dir, split, nshard, rank) + iterator = generator() + + lab_path = f"{lab_dir}/{split}_{rank}_{nshard}.km" + os.makedirs(lab_dir, exist_ok=True) + with open(lab_path, "w") as f: + for feat in tqdm.tqdm(iterator, total=num): + # feat = torch.from_numpy(feat).cuda() + lab = apply_kmeans(feat).tolist() + f.write(" ".join(map(str, lab)) + "\n") + logger.info("finished successfully") + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("feat_dir") + parser.add_argument("split") + parser.add_argument("km_path") + parser.add_argument("nshard", type=int) + parser.add_argument("rank", type=int) + parser.add_argument("lab_dir") + args = parser.parse_args() + logging.info(str(args)) + + dump_label(**vars(args)) diff --git a/fairseq/examples/hubert/simple_kmeans/dump_mfcc_feature.py b/fairseq/examples/hubert/simple_kmeans/dump_mfcc_feature.py new file mode 100644 index 0000000000000000000000000000000000000000..70d0016663b7d0b90033f4eb301b527f2c92a3f8 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/dump_mfcc_feature.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import soundfile as sf +import torch +import torchaudio + +from feature_utils import get_path_iterator, dump_feature + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("dump_mfcc_feature") + + +class MfccFeatureReader(object): + def __init__(self, sample_rate): + self.sample_rate = sample_rate + + def read_audio(self, path, ref_len=None): + wav, sr = sf.read(path) + assert sr == self.sample_rate, sr + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + if ref_len is not None and abs(ref_len - len(wav)) > 160: + logging.warning(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + def get_feats(self, path, ref_len=None): + x = self.read_audio(path, ref_len) + with torch.no_grad(): + x = torch.from_numpy(x).float() + x = x.view(1, -1) + + mfccs = torchaudio.compliance.kaldi.mfcc( + waveform=x, + sample_frequency=self.sample_rate, + use_energy=False, + ) # (time, freq) + mfccs = mfccs.transpose(0, 1) # (freq, time) + deltas = torchaudio.functional.compute_deltas(mfccs) + ddeltas = torchaudio.functional.compute_deltas(deltas) + concat = torch.cat([mfccs, deltas, ddeltas], dim=0) + concat = concat.transpose(0, 1).contiguous() # (freq, time) + return concat + + +def main(tsv_dir, split, nshard, rank, feat_dir, sample_rate): + reader = MfccFeatureReader(sample_rate) + generator, num = get_path_iterator(f"{tsv_dir}/{split}.tsv", nshard, rank) + dump_feature(reader, generator, num, split, nshard, rank, feat_dir) + + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("tsv_dir") + parser.add_argument("split") + parser.add_argument("nshard", type=int) + parser.add_argument("rank", type=int) + parser.add_argument("feat_dir") + parser.add_argument("--sample_rate", type=int, default=16000) + args = parser.parse_args() + logger.info(args) + + main(**vars(args)) diff --git a/fairseq/examples/hubert/simple_kmeans/dump_w2v2_feature.py b/fairseq/examples/hubert/simple_kmeans/dump_w2v2_feature.py new file mode 100644 index 0000000000000000000000000000000000000000..a1f0d902acf0756580a1f4604feee8fc499a9a63 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/dump_w2v2_feature.py @@ -0,0 +1,95 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import fairseq +import soundfile as sf +import torch +import torch.nn.functional as F + +from feature_utils import get_path_iterator, dump_feature + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("dump_w2v2_feature") + + +class Wav2Vec2FeatureReader(object): + def __init__(self, ckpt_path, layer, max_chunk=1600000): + ( + model, + cfg, + task, + ) = fairseq.checkpoint_utils.load_model_ensemble_and_task([ckpt_path]) + self.model = model[0].eval().cuda() + self.task = task + self.layer = layer # assume this is 1-based like HuBERT + self.max_chunk = max_chunk + logger.info(f"TASK CONFIG:\n{self.task.cfg}") + logger.info(f" max_chunk = {self.max_chunk}") + logger.info(f" model:\n{self.model}") + + def read_audio(self, path, ref_len=None): + wav, sr = sf.read(path) + assert sr == self.task.cfg.sample_rate, sr + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + if ref_len is not None and abs(ref_len - len(wav)) > 160: + logging.warning(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + def get_feats(self, path, ref_len=None): + x = self.read_audio(path, ref_len) + with torch.no_grad(): + x = torch.from_numpy(x).float().cuda() + if self.task.cfg.normalize: + x = F.layer_norm(x, x.shape) + x = x.view(1, -1) + + feat = [] + for start in range(0, x.size(1), self.max_chunk): + x_chunk = x[:, start: start + self.max_chunk] + res = self.model.extract_features( + source=x_chunk, + padding_mask=None, + mask=False, + layer=self.layer - 1, + ) + feat_chunk = res["x"] + feat.append(feat_chunk) + return torch.cat(feat, 1).squeeze(0) + + +def main(tsv_dir, split, ckpt_path, layer, nshard, rank, feat_dir, max_chunk): + reader = Wav2Vec2FeatureReader(ckpt_path, layer, max_chunk) + generator, num = get_path_iterator(f"{tsv_dir}/{split}.tsv", nshard, rank) + dump_feature(reader, generator, num, split, nshard, rank, feat_dir) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("tsv_dir") + parser.add_argument("split") + parser.add_argument("ckpt_path") + parser.add_argument("layer", type=int) + parser.add_argument("nshard", type=int) + parser.add_argument("rank", type=int) + parser.add_argument("feat_dir") + parser.add_argument("--max_chunk", type=int, default=1600000) + args = parser.parse_args() + logger.info(args) + + main(**vars(args)) diff --git a/fairseq/examples/hubert/simple_kmeans/feature_utils.py b/fairseq/examples/hubert/simple_kmeans/feature_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f80bc4569768fac181133cdc8f76d1230e03bff6 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/feature_utils.py @@ -0,0 +1,66 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import tqdm +from npy_append_array import NpyAppendArray + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("feature_utils") + + +def get_shard_range(tot, nshard, rank): + assert rank < nshard and rank >= 0, f"invaid rank/nshard {rank}/{nshard}" + start = round(tot / nshard * rank) + end = round(tot / nshard * (rank + 1)) + assert start < end, f"start={start}, end={end}" + logger.info( + f"rank {rank} of {nshard}, process {end-start} " + f"({start}-{end}) out of {tot}" + ) + return start, end + + +def get_path_iterator(tsv, nshard, rank): + with open(tsv, "r") as f: + root = f.readline().rstrip() + lines = [line.rstrip() for line in f] + start, end = get_shard_range(len(lines), nshard, rank) + lines = lines[start:end] + def iterate(): + for line in lines: + subpath, nsample = line.split("\t") + yield f"{root}/{subpath}", int(nsample) + return iterate, len(lines) + + +def dump_feature(reader, generator, num, split, nshard, rank, feat_dir): + iterator = generator() + + feat_path = f"{feat_dir}/{split}_{rank}_{nshard}.npy" + leng_path = f"{feat_dir}/{split}_{rank}_{nshard}.len" + + os.makedirs(feat_dir, exist_ok=True) + if os.path.exists(feat_path): + os.remove(feat_path) + + feat_f = NpyAppendArray(feat_path) + with open(leng_path, "w") as leng_f: + for path, nsample in tqdm.tqdm(iterator, total=num): + feat = reader.get_feats(path, nsample) + feat_f.append(feat.cpu().numpy()) + leng_f.write(f"{len(feat)}\n") + logger.info("finished successfully") + + diff --git a/fairseq/examples/hubert/simple_kmeans/learn_kmeans.py b/fairseq/examples/hubert/simple_kmeans/learn_kmeans.py new file mode 100644 index 0000000000000000000000000000000000000000..113ac655b8c0a585fe43797e99674e445098edd0 --- /dev/null +++ b/fairseq/examples/hubert/simple_kmeans/learn_kmeans.py @@ -0,0 +1,146 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys + +import numpy as np +from sklearn.cluster import MiniBatchKMeans + +import joblib + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("learn_kmeans") + + +def get_km_model( + n_clusters, + init, + max_iter, + batch_size, + tol, + max_no_improvement, + n_init, + reassignment_ratio, +): + return MiniBatchKMeans( + n_clusters=n_clusters, + init=init, + max_iter=max_iter, + batch_size=batch_size, + verbose=1, + compute_labels=False, + tol=tol, + max_no_improvement=max_no_improvement, + init_size=None, + n_init=n_init, + reassignment_ratio=reassignment_ratio, + ) + + +def load_feature_shard(feat_dir, split, nshard, rank, percent): + feat_path = f"{feat_dir}/{split}_{rank}_{nshard}.npy" + leng_path = f"{feat_dir}/{split}_{rank}_{nshard}.len" + with open(leng_path, "r") as f: + lengs = [int(line.rstrip()) for line in f] + offsets = [0] + np.cumsum(lengs[:-1]).tolist() + + if percent < 0: + return np.load(feat_path, mmap_mode="r") + else: + nsample = int(np.ceil(len(lengs) * percent)) + indices = np.random.choice(len(lengs), nsample, replace=False) + feat = np.load(feat_path, mmap_mode="r") + sampled_feat = np.concatenate( + [feat[offsets[i]: offsets[i] + lengs[i]] for i in indices], axis=0 + ) + logger.info( + ( + f"sampled {nsample} utterances, {len(sampled_feat)} frames " + f"from shard {rank}/{nshard}" + ) + ) + return sampled_feat + + +def load_feature(feat_dir, split, nshard, seed, percent): + assert percent <= 1.0 + feat = np.concatenate( + [ + load_feature_shard(feat_dir, split, nshard, r, percent) + for r in range(nshard) + ], + axis=0, + ) + logging.info(f"loaded feature with dimension {feat.shape}") + return feat + + +def learn_kmeans( + feat_dir, + split, + nshard, + km_path, + n_clusters, + seed, + percent, + init, + max_iter, + batch_size, + tol, + n_init, + reassignment_ratio, + max_no_improvement, +): + np.random.seed(seed) + feat = load_feature(feat_dir, split, nshard, seed, percent) + km_model = get_km_model( + n_clusters, + init, + max_iter, + batch_size, + tol, + max_no_improvement, + n_init, + reassignment_ratio, + ) + km_model.fit(feat) + joblib.dump(km_model, km_path) + + inertia = -km_model.score(feat) / len(feat) + logger.info("total intertia: %.5f", inertia) + logger.info("finished successfully") + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("feat_dir", type=str) + parser.add_argument("split", type=str) + parser.add_argument("nshard", type=int) + parser.add_argument("km_path", type=str) + parser.add_argument("n_clusters", type=int) + parser.add_argument("--seed", default=0, type=int) + parser.add_argument( + "--percent", default=-1, type=float, help="sample a subset; -1 for all" + ) + parser.add_argument("--init", default="k-means++") + parser.add_argument("--max_iter", default=100, type=int) + parser.add_argument("--batch_size", default=10000, type=int) + parser.add_argument("--tol", default=0.0, type=float) + parser.add_argument("--max_no_improvement", default=100, type=int) + parser.add_argument("--n_init", default=20, type=int) + parser.add_argument("--reassignment_ratio", default=0.0, type=float) + args = parser.parse_args() + logging.info(str(args)) + + learn_kmeans(**vars(args)) diff --git a/fairseq/examples/hubert/update_ckpt.py b/fairseq/examples/hubert/update_ckpt.py new file mode 100644 index 0000000000000000000000000000000000000000..53c9e74ea613e30aa5c22614e658f2b7272bac0c --- /dev/null +++ b/fairseq/examples/hubert/update_ckpt.py @@ -0,0 +1,22 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +src_ckpt = "/checkpoint/wnhsu/w2v/archived/hubert_base_ls960_it2.pt" +ref_ckpt = "/checkpoint/wnhsu/w2v/hubert_icassp_oss_v3/iter2_km100-400k-grp-L6/oss.km500_p0_1_s334.pmw1_0.puw0_0.grpnorm.ml10.mp0_8.untie.mxsz250000.ufreq1.maxtok1400000.MU100k.s1337.ngpu32/checkpoint_last.pt" +new_ckpt = "/checkpoint/wnhsu/w2v/archived/hubert_base_ls960_it2_updated.pt" + + +def update_state(state): + state["model"]["label_embs_concat"] = state["model"].pop("label_embs") + state["args"].task = "hubert_pretraining" + state["args"].labels = f"['{state['args'].labels}']" + return state + + +src_state = torch.load(src_ckpt) +src_state = update_state(src_state) +torch.save(src_state, new_ckpt) diff --git a/fairseq/examples/joint_alignment_translation/README.md b/fairseq/examples/joint_alignment_translation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..cd9c0ea65f5292198296a8f427b42e01b584e2d9 --- /dev/null +++ b/fairseq/examples/joint_alignment_translation/README.md @@ -0,0 +1,89 @@ +# Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019) + +This page includes instructions for training models described in [Jointly Learning to Align and Translate with Transformer Models (Garg et al., 2019)](https://arxiv.org/abs/1909.02074). + +## Training a joint alignment-translation model on WMT'18 En-De + +##### 1. Extract and preprocess the WMT'18 En-De data +```bash +./prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh +``` + +##### 2. Generate alignments from statistical alignment toolkits e.g. Giza++/FastAlign. +In this example, we use FastAlign. +```bash +git clone git@github.com:clab/fast_align.git +pushd fast_align +mkdir build +cd build +cmake .. +make +popd +ALIGN=fast_align/build/fast_align +paste bpe.32k/train.en bpe.32k/train.de | awk -F '\t' '{print $1 " ||| " $2}' > bpe.32k/train.en-de +$ALIGN -i bpe.32k/train.en-de -d -o -v > bpe.32k/train.align +``` + +##### 3. Preprocess the dataset with the above generated alignments. +```bash +fairseq-preprocess \ + --source-lang en --target-lang de \ + --trainpref bpe.32k/train \ + --validpref bpe.32k/valid \ + --testpref bpe.32k/test \ + --align-suffix align \ + --destdir binarized/ \ + --joined-dictionary \ + --workers 32 +``` + +##### 4. Train a model +```bash +fairseq-train \ + binarized \ + --arch transformer_wmt_en_de_big_align --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 --activation-fn relu\ + --lr 0.0002 --lr-scheduler inverse_sqrt --warmup-updates 4000 --warmup-init-lr 1e-07 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 3500 --label-smoothing 0.1 \ + --save-dir ./checkpoints --log-interval 1000 --max-update 60000 \ + --keep-interval-updates -1 --save-interval-updates 0 \ + --load-alignments --criterion label_smoothed_cross_entropy_with_alignment \ + --fp16 +``` + +Note that the `--fp16` flag requires you have CUDA 9.1 or greater and a Volta GPU or newer. + +If you want to train the above model with big batches (assuming your machine has 8 GPUs): +- add `--update-freq 8` to simulate training on 8x8=64 GPUs +- increase the learning rate; 0.0007 works well for big batches + +##### 5. Evaluate and generate the alignments (BPE level) +```bash +fairseq-generate \ + binarized --gen-subset test --print-alignment \ + --source-lang en --target-lang de \ + --path checkpoints/checkpoint_best.pt --beam 5 --nbest 1 +``` + +##### 6. Other resources. +The code for: +1. preparing alignment test sets +2. converting BPE level alignments to token level alignments +3. symmetrizing bidirectional alignments +4. evaluating alignments using AER metric +can be found [here](https://github.com/lilt/alignment-scripts) + +## Citation + +```bibtex +@inproceedings{garg2019jointly, + title = {Jointly Learning to Align and Translate with Transformer Models}, + author = {Garg, Sarthak and Peitz, Stephan and Nallasamy, Udhyakumar and Paulik, Matthias}, + booktitle = {Conference on Empirical Methods in Natural Language Processing (EMNLP)}, + address = {Hong Kong}, + month = {November}, + url = {https://arxiv.org/abs/1909.02074}, + year = {2019}, +} +``` diff --git a/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh b/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh new file mode 100755 index 0000000000000000000000000000000000000000..e3efeb21d302ef8d9eae8f1d4b06434c593705f6 --- /dev/null +++ b/fairseq/examples/joint_alignment_translation/prepare-wmt18en2de_no_norm_no_escape_no_agressive.sh @@ -0,0 +1,118 @@ +#!/bin/bash + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +echo 'Cloning Moses github repository (for tokenization scripts)...' +git clone https://github.com/moses-smt/mosesdecoder.git + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +CLEAN=$SCRIPTS/training/clean-corpus-n.perl +REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl + +URLS=( + "http://statmt.org/wmt13/training-parallel-europarl-v7.tgz" + "http://statmt.org/wmt13/training-parallel-commoncrawl.tgz" + "http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz" + "http://data.statmt.org/wmt18/translation-task/rapid2016.tgz" + "http://data.statmt.org/wmt17/translation-task/dev.tgz" + "http://statmt.org/wmt14/test-full.tgz" +) +CORPORA=( + "training/europarl-v7.de-en" + "commoncrawl.de-en" + "training-parallel-nc-v13/news-commentary-v13.de-en" + "rapid2016.de-en" +) + +if [ ! -d "$SCRIPTS" ]; then + echo "Please set SCRIPTS variable correctly to point to Moses scripts." + exit +fi + +src=en +tgt=de +lang=en-de +prep=wmt18_en_de +tmp=$prep/tmp +orig=orig +dev=dev/newstest2012 +codes=32000 +bpe=bpe.32k + +mkdir -p $orig $tmp $prep $bpe + +cd $orig + +for ((i=0;i<${#URLS[@]};++i)); do + url=${URLS[i]} + file=$(basename $url) + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + wget "$url" + if [ -f $file ]; then + echo "$url successfully downloaded." + else + echo "$url not successfully downloaded." + exit 1 + fi + if [ ${file: -4} == ".tgz" ]; then + tar zxvf $file + elif [ ${file: -4} == ".tar" ]; then + tar xvf $file + fi + fi +done +cd .. + +echo "pre-processing train data..." +for l in $src $tgt; do + rm -rf $tmp/train.tags.$lang.tok.$l + for f in "${CORPORA[@]}"; do + cat $orig/$f.$l | \ + perl $REM_NON_PRINT_CHAR | \ + perl $TOKENIZER -threads 8 -l $l -no-escape >> $tmp/train.tags.$lang.tok.$l + done +done + +echo "pre-processing test data..." +for l in $src $tgt; do + if [ "$l" == "$src" ]; then + t="src" + else + t="ref" + fi + grep '\s*//g' | \ + sed -e 's/\s*<\/seg>\s*//g' | \ + sed -e "s/\’/\'/g" | \ + perl $TOKENIZER -threads 8 -l $l -no-escape > $tmp/test.$l + echo "" +done + +# apply length filtering before BPE +perl $CLEAN -ratio 1.5 $tmp/train.tags.$lang.tok $src $tgt $tmp/train 1 100 + +# use newstest2012 for valid +echo "pre-processing valid data..." +for l in $src $tgt; do + rm -rf $tmp/valid.$l + cat $orig/$dev.$l | \ + perl $REM_NON_PRINT_CHAR | \ + perl $TOKENIZER -threads 8 -l $l -no-escape >> $tmp/valid.$l +done + +mkdir output +mv $tmp/{train,valid,test}.{$src,$tgt} output + +#BPE +git clone https://github.com/glample/fastBPE.git +pushd fastBPE +g++ -std=c++11 -pthread -O3 fastBPE/main.cc -IfastBPE -o fast +popd +fastBPE/fast learnbpe $codes output/train.$src output/train.$tgt > $bpe/codes +for split in {train,valid,test}; do for lang in {en,de}; do fastBPE/fast applybpe $bpe/$split.$lang output/$split.$lang $bpe/codes; done; done diff --git a/fairseq/examples/language_model/README.adaptive_inputs.md b/fairseq/examples/language_model/README.adaptive_inputs.md new file mode 100644 index 0000000000000000000000000000000000000000..6650d58f37f320aa46402d59ce6494b2dd1c3faa --- /dev/null +++ b/fairseq/examples/language_model/README.adaptive_inputs.md @@ -0,0 +1,39 @@ +# Adaptive Input Representations for Neural Language Modeling (Baevski and Auli, 2018) + +## Pre-trained models + +Description | Parameters | Dataset | Model and Test set(s) +---|---:|---|--- +Adaptive Inputs
([Baevski and Auli, 2018](https://arxiv.org/abs/1809.10853)) | 1026M | [Google Billion Words](https://github.com/ciprian-chelba/1-billion-word-language-modeling-benchmark) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_gbw_huge.tar.bz2) +Adaptive Inputs
([Baevski and Auli, 2018](https://arxiv.org/abs/1809.10853)) | 247M | [WikiText-103](https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset/) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_wiki103.v2.tar.bz2) + +## Training an LM with adaptive inputs + +First, see the general [language modeling README](README.md) for instructions on +preprocessing the WikiText-103 data. + +Then use the following training command to train a model with adaptive inputs +using the `transformer_lm_wiki103` model architecture: +```bash +fairseq-train --task language_modeling \ + data-bin/wikitext-103 \ + --save-dir checkpoints/transformer_wikitext-103 \ + --arch transformer_lm_wiki103 \ + --max-update 286000 --lr 1.0 --t-mult 2 --lr-period-updates 270000 --lr-scheduler cosine --lr-shrink 0.75 \ + --warmup-updates 16000 --warmup-init-lr 1e-07 --stop-min-lr 1e-09 --optimizer nag --min-lr 0.0001 --clip-norm 0.1 \ + --criterion adaptive_loss --max-tokens 3072 --update-freq 3 --tokens-per-sample 3072 --seed 1 \ + --sample-break-mode none --skip-invalid-size-inputs-valid-test --ddp-backend=legacy_ddp +``` + +## Citation + +```bibtex +@inproceedings{ + baevski2018adaptive, + title={Adaptive Input Representations for Neural Language Modeling}, + author={Alexei Baevski and Michael Auli}, + booktitle={International Conference on Learning Representations}, + year={2019}, + url={https://openreview.net/forum?id=ByxZX20qFQ}, +} +``` diff --git a/fairseq/examples/language_model/README.conv.md b/fairseq/examples/language_model/README.conv.md new file mode 100644 index 0000000000000000000000000000000000000000..1ff8635906cf278208be4714e0ef805a6a6b4da1 --- /dev/null +++ b/fairseq/examples/language_model/README.conv.md @@ -0,0 +1,40 @@ +# Language Modeling with Gated Convolutional Networks (Dauphin et al., 2017) + +## Example usage + +First download and preprocess the data following the main [language modeling README](README.md). + +Then to train a convolutional LM using the `fconv_lm_dauphin_wikitext103` +architecture: +```bash +fairseq-train --task language_modeling \ + data-bin/wikitext-103 \ + --save-dir checkpoints/fconv_wikitext-103 \ + --arch fconv_lm_dauphin_wikitext103 \ + --adaptive-softmax-cutoff 10000,20000,200000 \ + --dropout 0.2 \ + --criterion adaptive_loss \ + --optimizer nag --clip-norm 0.1 --weight-decay 5e-06 \ + --lr 1.0 --lr-scheduler reduce_lr_on_plateau --lr-shrink 0.5 \ + --max-tokens 1024 --tokens-per-sample 1024 \ + --ddp-backend legacy_ddp \ + --max-epoch 35 +``` + +And evaluate with: +```bash +fairseq-eval-lm data-bin/wikitext-103 --path checkpoints/fconv_wiki103/checkpoint_best.pt +``` + +## Citation + +```bibtex +@inproceedings{dauphin2017language, + title={Language Modeling with Gated Convolutional Networks}, + author={Dauphin, Yann N and Fan, Angela and Auli, Michael and Grangier, David}, + booktitle={Proceedings of the 34th International Conference on Machine Learning-Volume 70}, + pages={933--941}, + year={2017}, + organization={JMLR} +} +``` diff --git a/fairseq/examples/language_model/README.md b/fairseq/examples/language_model/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e78ea48e08dc99b69751923762107a8f8a9a5e3e --- /dev/null +++ b/fairseq/examples/language_model/README.md @@ -0,0 +1,123 @@ +# Neural Language Modeling + +## Pre-trained models + +Model | Description | Dataset | Download +---|---|---|--- +`transformer_lm.gbw.adaptive_huge` | Adaptive Inputs
([Baevski and Auli, 2018](https://arxiv.org/abs/1809.10853))
1026M params | [Google Billion Words](https://github.com/ciprian-chelba/1-billion-word-language-modeling-benchmark) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_gbw_huge.tar.bz2) +`transformer_lm.wiki103.adaptive` | Adaptive Inputs
([Baevski and Auli, 2018](https://arxiv.org/abs/1809.10853))
247M params | [WikiText-103](https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_wiki103.v2.tar.bz2) +`transformer_lm.wmt19.en` | English LM
([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) | [WMT News Crawl](http://data.statmt.org/news-crawl/) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.en.tar.gz) +`transformer_lm.wmt19.de` | German LM
([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) | [WMT News Crawl](http://data.statmt.org/news-crawl/) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.de.tar.gz) +`transformer_lm.wmt19.ru` | Russian LM
([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) | [WMT News Crawl](http://data.statmt.org/news-crawl/) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.ru.tar.gz) + +## Example usage + +We require a few additional Python dependencies for preprocessing: +```bash +pip install fastBPE sacremoses +``` + +To sample from a language model using PyTorch Hub: +```python +import torch + +# List available models +torch.hub.list('pytorch/fairseq') # [..., 'transformer_lm.wmt19.en', ...] + +# Load an English LM trained on WMT'19 News Crawl data +en_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt19.en', tokenizer='moses', bpe='fastbpe') +en_lm.eval() # disable dropout + +# Move model to GPU +en_lm.cuda() + +# Sample from the language model +en_lm.sample('Barack Obama', beam=1, sampling=True, sampling_topk=10, temperature=0.8) +# "Barack Obama is coming to Sydney and New Zealand (...)" + +# Compute perplexity for a sequence +en_lm.score('Barack Obama is coming to Sydney and New Zealand')['positional_scores'].mean().neg().exp() +# tensor(15.1474) + +# The same interface can be used with custom models as well +from fairseq.models.transformer_lm import TransformerLanguageModel +custom_lm = TransformerLanguageModel.from_pretrained('/path/to/model/dir', 'checkpoint100.pt', tokenizer='moses', bpe='fastbpe') +custom_lm.sample('Barack Obama', beam=5) +# "Barack Obama (...)" +``` + +## Training a transformer language model with the CLI tools + +### 1) Preprocess the data + +First download and prepare the [WikiText-103 dataset](https://www.salesforce.com/products/einstein/ai-research/the-wikitext-dependency-language-modeling-dataset/): +```bash +cd examples/language_model/ +bash prepare-wikitext-103.sh +cd ../.. +``` + +Next preprocess/binarize the data: +```bash +TEXT=examples/language_model/wikitext-103 +fairseq-preprocess \ + --only-source \ + --trainpref $TEXT/wiki.train.tokens \ + --validpref $TEXT/wiki.valid.tokens \ + --testpref $TEXT/wiki.test.tokens \ + --destdir data-bin/wikitext-103 \ + --workers 20 +``` + +### 2) Train a language model + +Next we'll train a basic transformer language model on wikitext-103. For more +advanced usage, see the [adaptive inputs README](README.adaptive_inputs.md). + +To train a basic LM (assumes 2 GPUs): +``` +$ fairseq-train --task language_modeling \ + data-bin/wikitext-103 \ + --save-dir checkpoints/transformer_wikitext-103 \ + --arch transformer_lm --share-decoder-input-output-embed \ + --dropout 0.1 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --weight-decay 0.01 --clip-norm 0.0 \ + --lr 0.0005 --lr-scheduler inverse_sqrt --warmup-updates 4000 --warmup-init-lr 1e-07 \ + --tokens-per-sample 512 --sample-break-mode none \ + --max-tokens 2048 --update-freq 16 \ + --fp16 \ + --max-update 50000 +``` + +If you run out of memory, try reducing `--max-tokens` (max number of tokens per +batch) or `--tokens-per-sample` (max sequence length). You can also adjust +`--update-freq` to accumulate gradients and simulate training on a different +number of GPUs. + +### 3) Evaluate + +```bash +fairseq-eval-lm data-bin/wikitext-103 \ + --path checkpoints/transformer_wiki103/checkpoint_best.pt \ + --batch-size 2 \ + --tokens-per-sample 512 \ + --context-window 400 +# | Evaluated 245569 tokens in 56.1s (4379.02 tokens/s) +# | Loss: 3.4164, Perplexity: 30.46 +``` + +*Note:* The `--context-window` option controls how much context is provided to +each token when computing perplexity. When the window size is 0, the dataset is +chunked into segments of length 512 and perplexity is computed over each segment +normally. However, this results in worse (higher) perplexity since tokens that +appear earlier in each segment have less conditioning. When the maximum window +size is used (511 in this case), then we compute perplexity for each token +fully conditioned on 511 tokens of context. This slows down evaluation +significantly, since we must run a separate forward pass for every token in the +dataset, but results in better (lower) perplexity. + + +## Convolutional language models + +Please see the [convolutional LM README](README.conv.md) for instructions on +training convolutional language models. diff --git a/fairseq/examples/language_model/prepare-wikitext-103.sh b/fairseq/examples/language_model/prepare-wikitext-103.sh new file mode 100644 index 0000000000000000000000000000000000000000..751302156f0a6829af9c2ee5e0e2ca62c2cd4187 --- /dev/null +++ b/fairseq/examples/language_model/prepare-wikitext-103.sh @@ -0,0 +1,33 @@ +#!/bin/bash +# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh + +URLS=( + "https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-v1.zip" +) +FILES=( + "wikitext-103-v1.zip" +) + +for ((i=0;i<${#URLS[@]};++i)); do + file=${FILES[i]} + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + url=${URLS[i]} + wget "$url" + if [ -f $file ]; then + echo "$url successfully downloaded." + else + echo "$url not successfully downloaded." + exit -1 + fi + if [ ${file: -4} == ".tgz" ]; then + tar zxvf $file + elif [ ${file: -4} == ".tar" ]; then + tar xvf $file + elif [ ${file: -4} == ".zip" ]; then + unzip $file + fi + fi +done +cd .. diff --git a/fairseq/examples/laser/README.md b/fairseq/examples/laser/README.md new file mode 100644 index 0000000000000000000000000000000000000000..66acada04f58fa235cd312753f144f6f1e5f4a33 --- /dev/null +++ b/fairseq/examples/laser/README.md @@ -0,0 +1,144 @@ +# LASER Language-Agnostic SEntence Representations + +LASER is a library to calculate and use multilingual sentence embeddings. + +You can find more information about LASER and how to use it on the official [LASER repository](https://github.com/facebookresearch/LASER). + +This folder contains source code for training LASER embeddings. + + +## Prepare data and configuration file + +Binarize your data with fairseq, as described [here](https://fairseq.readthedocs.io/en/latest/getting_started.html#data-pre-processing). + +Create a json config file with this format: +``` +{ + "src_vocab": "/path/to/spm.src.cvocab", + "tgt_vocab": "/path/to/spm.tgt.cvocab", + "train": [ + { + "type": "translation", + "id": 0, + "src": "/path/to/srclang1-tgtlang0/train.srclang1", + "tgt": "/path/to/srclang1-tgtlang0/train.tgtlang0" + }, + { + "type": "translation", + "id": 1, + "src": "/path/to/srclang1-tgtlang1/train.srclang1", + "tgt": "/path/to/srclang1-tgtlang1/train.tgtlang1" + }, + { + "type": "translation", + "id": 0, + "src": "/path/to/srclang2-tgtlang0/train.srclang2", + "tgt": "/path/to/srclang2-tgtlang0/train.tgtlang0" + }, + { + "type": "translation", + "id": 1, + "src": "/path/to/srclang2-tgtlang1/train.srclang2", + "tgt": "/path/to/srclang2-tgtlang1/train.tgtlang1" + }, + ... + ], + "valid": [ + { + "type": "translation", + "id": 0, + "src": "/unused", + "tgt": "/unused" + } + ] +} +``` +where paths are paths to binarized indexed fairseq dataset files. +`id` represents the target language id. + + +## Training Command Line Example + +``` +fairseq-train \ + /path/to/configfile_described_above.json \ + --user-dir examples/laser/laser_src \ + --log-interval 100 --log-format simple \ + --task laser --arch laser_lstm \ + --save-dir . \ + --optimizer adam \ + --lr 0.001 \ + --lr-scheduler inverse_sqrt \ + --clip-norm 5 \ + --warmup-updates 90000 \ + --update-freq 2 \ + --dropout 0.0 \ + --encoder-dropout-out 0.1 \ + --max-tokens 2000 \ + --max-epoch 50 \ + --encoder-bidirectional \ + --encoder-layers 5 \ + --encoder-hidden-size 512 \ + --decoder-layers 1 \ + --decoder-hidden-size 2048 \ + --encoder-embed-dim 320 \ + --decoder-embed-dim 320 \ + --decoder-lang-embed-dim 32 \ + --warmup-init-lr 0.001 \ + --disable-validation +``` + + +## Applications + +We showcase several applications of multilingual sentence embeddings +with code to reproduce our results (in the directory "tasks"). + +* [**Cross-lingual document classification**](https://github.com/facebookresearch/LASER/tree/master/tasks/mldoc) using the + [*MLDoc*](https://github.com/facebookresearch/MLDoc) corpus [2,6] +* [**WikiMatrix**](https://github.com/facebookresearch/LASER/tree/master/tasks/WikiMatrix) + Mining 135M Parallel Sentences in 1620 Language Pairs from Wikipedia [7] +* [**Bitext mining**](https://github.com/facebookresearch/LASER/tree/master/tasks/bucc) using the + [*BUCC*](https://comparable.limsi.fr/bucc2018/bucc2018-task.html) corpus [3,5] +* [**Cross-lingual NLI**](https://github.com/facebookresearch/LASER/tree/master/tasks/xnli) + using the [*XNLI*](https://www.nyu.edu/projects/bowman/xnli/) corpus [4,5,6] +* [**Multilingual similarity search**](https://github.com/facebookresearch/LASER/tree/master/tasks/similarity) [1,6] +* [**Sentence embedding of text files**](https://github.com/facebookresearch/LASER/tree/master/tasks/embed) + example how to calculate sentence embeddings for arbitrary text files in any of the supported language. + +**For all tasks, we use exactly the same multilingual encoder, without any task specific optimization or fine-tuning.** + + + +## References + +[1] Holger Schwenk and Matthijs Douze, + [*Learning Joint Multilingual Sentence Representations with Neural Machine Translation*](https://aclanthology.info/papers/W17-2619/w17-2619), + ACL workshop on Representation Learning for NLP, 2017 + +[2] Holger Schwenk and Xian Li, + [*A Corpus for Multilingual Document Classification in Eight Languages*](http://www.lrec-conf.org/proceedings/lrec2018/pdf/658.pdf), + LREC, pages 3548-3551, 2018. + +[3] Holger Schwenk, + [*Filtering and Mining Parallel Data in a Joint Multilingual Space*](http://aclweb.org/anthology/P18-2037) + ACL, July 2018 + +[4] Alexis Conneau, Guillaume Lample, Ruty Rinott, Adina Williams, Samuel R. Bowman, Holger Schwenk and Veselin Stoyanov, + [*XNLI: Cross-lingual Sentence Understanding through Inference*](https://aclweb.org/anthology/D18-1269), + EMNLP, 2018. + +[5] Mikel Artetxe and Holger Schwenk, + [*Margin-based Parallel Corpus Mining with Multilingual Sentence Embeddings*](https://arxiv.org/abs/1811.01136) + arXiv, Nov 3 2018. + +[6] Mikel Artetxe and Holger Schwenk, + [*Massively Multilingual Sentence Embeddings for Zero-Shot Cross-Lingual Transfer and Beyond*](https://arxiv.org/abs/1812.10464) + arXiv, Dec 26 2018. + +[7] Holger Schwenk, Vishrav Chaudhary, Shuo Sun, Hongyu Gong and Paco Guzman, + [*WikiMatrix: Mining 135M Parallel Sentences in 1620 Language Pairs from Wikipedia*](https://arxiv.org/abs/1907.05791) + arXiv, July 11 2019. + +[8] Holger Schwenk, Guillaume Wenzek, Sergey Edunov, Edouard Grave and Armand Joulin + [*CCMatrix: Mining Billions of High-Quality Parallel Sentences on the WEB*](https://arxiv.org/abs/1911.04944) diff --git a/fairseq/examples/laser/laser_src/__init__.py b/fairseq/examples/laser/laser_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ffbd656d8786e421008fb4cb0d1d8911dc8330c --- /dev/null +++ b/fairseq/examples/laser/laser_src/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .laser_task import * # noqa +from .laser_lstm import * # noqa +from .laser_transformer import * # noqa diff --git a/fairseq/examples/laser/laser_src/laser_lstm.py b/fairseq/examples/laser/laser_src/laser_lstm.py new file mode 100644 index 0000000000000000000000000000000000000000..10df90e002d5a7dd74a571dbc3b328c130c57a0a --- /dev/null +++ b/fairseq/examples/laser/laser_src/laser_lstm.py @@ -0,0 +1,585 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from fairseq import options, utils + +from fairseq.models import ( + FairseqEncoder, + FairseqIncrementalDecoder, + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) + + +@register_model("laser_lstm") +class LSTMModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens=None, + tgt_tokens=None, + tgt_lengths=None, + target_language_id=None, + dataset_name="", + ): + assert target_language_id is not None + + src_encoder_out = self.encoder(src_tokens, src_lengths, dataset_name) + return self.decoder( + prev_output_tokens, src_encoder_out, lang_id=target_language_id + ) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--dropout", + default=0.1, + type=float, + metavar="D", + help="dropout probability", + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-embed-path", + default=None, + type=str, + metavar="STR", + help="path to pre-trained encoder embedding", + ) + parser.add_argument( + "--encoder-hidden-size", type=int, metavar="N", help="encoder hidden size" + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="number of encoder layers" + ) + parser.add_argument( + "--encoder-bidirectional", + action="store_true", + help="make all layers of encoder bidirectional", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-embed-path", + default=None, + type=str, + metavar="STR", + help="path to pre-trained decoder embedding", + ) + parser.add_argument( + "--decoder-hidden-size", type=int, metavar="N", help="decoder hidden size" + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="number of decoder layers" + ) + parser.add_argument( + "--decoder-out-embed-dim", + type=int, + metavar="N", + help="decoder output embedding dimension", + ) + parser.add_argument( + "--decoder-zero-init", + type=str, + metavar="BOOL", + help="initialize the decoder hidden/cell state to zero", + ) + parser.add_argument( + "--decoder-lang-embed-dim", + type=int, + metavar="N", + help="decoder language embedding dimension", + ) + parser.add_argument( + "--fixed-embeddings", + action="store_true", + help="keep embeddings fixed (ENCODER ONLY)", + ) # TODO Also apply to decoder embeddings? + + # Granular dropout settings (if not specified these default to --dropout) + parser.add_argument( + "--encoder-dropout-in", + type=float, + metavar="D", + help="dropout probability for encoder input embedding", + ) + parser.add_argument( + "--encoder-dropout-out", + type=float, + metavar="D", + help="dropout probability for encoder output", + ) + parser.add_argument( + "--decoder-dropout-in", + type=float, + metavar="D", + help="dropout probability for decoder input embedding", + ) + parser.add_argument( + "--decoder-dropout-out", + type=float, + metavar="D", + help="dropout probability for decoder output", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted (in case there are any new ones) + base_architecture(args) + + def load_pretrained_embedding_from_file(embed_path, dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + embed_dict = utils.parse_embedding(embed_path) + utils.print_embed_overlap(embed_dict, dictionary) + return utils.load_embedding(embed_dict, dictionary, embed_tokens) + + pretrained_encoder_embed = None + if args.encoder_embed_path: + pretrained_encoder_embed = load_pretrained_embedding_from_file( + args.encoder_embed_path, task.source_dictionary, args.encoder_embed_dim + ) + pretrained_decoder_embed = None + if args.decoder_embed_path: + pretrained_decoder_embed = load_pretrained_embedding_from_file( + args.decoder_embed_path, task.target_dictionary, args.decoder_embed_dim + ) + + num_langs = task.num_tasks if hasattr(task, "num_tasks") else 0 + + encoder = LSTMEncoder( + dictionary=task.source_dictionary, + embed_dim=args.encoder_embed_dim, + hidden_size=args.encoder_hidden_size, + num_layers=args.encoder_layers, + dropout_in=args.encoder_dropout_in, + dropout_out=args.encoder_dropout_out, + bidirectional=args.encoder_bidirectional, + pretrained_embed=pretrained_encoder_embed, + fixed_embeddings=args.fixed_embeddings, + ) + decoder = LSTMDecoder( + dictionary=task.target_dictionary, + embed_dim=args.decoder_embed_dim, + hidden_size=args.decoder_hidden_size, + out_embed_dim=args.decoder_out_embed_dim, + num_layers=args.decoder_layers, + dropout_in=args.decoder_dropout_in, + dropout_out=args.decoder_dropout_out, + zero_init=options.eval_bool(args.decoder_zero_init), + encoder_embed_dim=args.encoder_embed_dim, + encoder_output_units=encoder.output_units, + pretrained_embed=pretrained_decoder_embed, + num_langs=num_langs, + lang_embed_dim=args.decoder_lang_embed_dim, + ) + return cls(encoder, decoder) + + +class LSTMEncoder(FairseqEncoder): + """LSTM encoder.""" + + def __init__( + self, + dictionary, + embed_dim=512, + hidden_size=512, + num_layers=1, + dropout_in=0.1, + dropout_out=0.1, + bidirectional=False, + left_pad=True, + pretrained_embed=None, + padding_value=0.0, + fixed_embeddings=False, + ): + super().__init__(dictionary) + self.num_layers = num_layers + self.dropout_in = dropout_in + self.dropout_out = dropout_out + self.bidirectional = bidirectional + self.hidden_size = hidden_size + + num_embeddings = len(dictionary) + self.padding_idx = dictionary.pad() + if pretrained_embed is None: + self.embed_tokens = Embedding(num_embeddings, embed_dim, self.padding_idx) + else: + self.embed_tokens = pretrained_embed + if fixed_embeddings: + self.embed_tokens.weight.requires_grad = False + + self.lstm = LSTM( + input_size=embed_dim, + hidden_size=hidden_size, + num_layers=num_layers, + dropout=self.dropout_out if num_layers > 1 else 0.0, + bidirectional=bidirectional, + ) + self.left_pad = left_pad + self.padding_value = padding_value + + self.output_units = hidden_size + if bidirectional: + self.output_units *= 2 + + def forward(self, src_tokens, src_lengths, dataset_name): + if self.left_pad: + # convert left-padding to right-padding + src_tokens = utils.convert_padding_direction( + src_tokens, + self.padding_idx, + left_to_right=True, + ) + + bsz, seqlen = src_tokens.size() + + # embed tokens + x = self.embed_tokens(src_tokens) + x = F.dropout(x, p=self.dropout_in, training=self.training) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # pack embedded source tokens into a PackedSequence + try: + packed_x = nn.utils.rnn.pack_padded_sequence(x, src_lengths.data.tolist()) + except BaseException: + raise Exception(f"Packing failed in dataset {dataset_name}") + + # apply LSTM + if self.bidirectional: + state_size = 2 * self.num_layers, bsz, self.hidden_size + else: + state_size = self.num_layers, bsz, self.hidden_size + h0 = x.data.new(*state_size).zero_() + c0 = x.data.new(*state_size).zero_() + packed_outs, (final_hiddens, final_cells) = self.lstm(packed_x, (h0, c0)) + + # unpack outputs and apply dropout + x, _ = nn.utils.rnn.pad_packed_sequence( + packed_outs, padding_value=self.padding_value + ) + x = F.dropout(x, p=self.dropout_out, training=self.training) + assert list(x.size()) == [seqlen, bsz, self.output_units] + + if self.bidirectional: + + def combine_bidir(outs): + return torch.cat( + [ + torch.cat([outs[2 * i], outs[2 * i + 1]], dim=0).view( + 1, bsz, self.output_units + ) + for i in range(self.num_layers) + ], + dim=0, + ) + + final_hiddens = combine_bidir(final_hiddens) + final_cells = combine_bidir(final_cells) + + encoder_padding_mask = src_tokens.eq(self.padding_idx).t() + + # Set padded outputs to -inf so they are not selected by max-pooling + padding_mask = src_tokens.eq(self.padding_idx).t().unsqueeze(-1) + if padding_mask.any(): + x = x.float().masked_fill_(padding_mask, float("-inf")).type_as(x) + + # Build the sentence embedding by max-pooling over the encoder outputs + sentemb = x.max(dim=0)[0] + + return { + "sentemb": sentemb, + "encoder_out": (x, final_hiddens, final_cells), + "encoder_padding_mask": encoder_padding_mask + if encoder_padding_mask.any() + else None, + } + + def reorder_encoder_out(self, encoder_out_dict, new_order): + encoder_out_dict["sentemb"] = encoder_out_dict["sentemb"].index_select( + 0, new_order + ) + encoder_out_dict["encoder_out"] = tuple( + eo.index_select(1, new_order) for eo in encoder_out_dict["encoder_out"] + ) + if encoder_out_dict["encoder_padding_mask"] is not None: + encoder_out_dict["encoder_padding_mask"] = encoder_out_dict[ + "encoder_padding_mask" + ].index_select(1, new_order) + return encoder_out_dict + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return int(1e5) # an arbitrary large number + + +class LSTMDecoder(FairseqIncrementalDecoder): + """LSTM decoder.""" + + def __init__( + self, + dictionary, + embed_dim=512, + hidden_size=512, + out_embed_dim=512, + num_layers=1, + dropout_in=0.1, + dropout_out=0.1, + zero_init=False, + encoder_embed_dim=512, + encoder_output_units=512, + pretrained_embed=None, + num_langs=1, + lang_embed_dim=0, + ): + super().__init__(dictionary) + self.dropout_in = dropout_in + self.dropout_out = dropout_out + self.hidden_size = hidden_size + + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + if pretrained_embed is None: + self.embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + else: + self.embed_tokens = pretrained_embed + + self.layers = nn.ModuleList( + [ + LSTMCell( + input_size=encoder_output_units + embed_dim + lang_embed_dim + if layer == 0 + else hidden_size, + hidden_size=hidden_size, + ) + for layer in range(num_layers) + ] + ) + if hidden_size != out_embed_dim: + self.additional_fc = Linear(hidden_size, out_embed_dim) + self.fc_out = Linear(out_embed_dim, num_embeddings, dropout=dropout_out) + + if zero_init: + self.sentemb2init = None + else: + self.sentemb2init = Linear( + encoder_output_units, 2 * num_layers * hidden_size + ) + + if lang_embed_dim == 0: + self.embed_lang = None + else: + self.embed_lang = nn.Embedding(num_langs, lang_embed_dim) + nn.init.uniform_(self.embed_lang.weight, -0.1, 0.1) + + def forward( + self, prev_output_tokens, encoder_out_dict, incremental_state=None, lang_id=0 + ): + sentemb = encoder_out_dict["sentemb"] + encoder_out = encoder_out_dict["encoder_out"] + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + bsz, seqlen = prev_output_tokens.size() + + # get outputs from encoder + encoder_outs, _, _ = encoder_out[:3] + srclen = encoder_outs.size(0) + + # embed tokens + x = self.embed_tokens(prev_output_tokens) + x = F.dropout(x, p=self.dropout_in, training=self.training) + + # embed language identifier + if self.embed_lang is not None: + lang_ids = prev_output_tokens.data.new_full((bsz,), lang_id) + langemb = self.embed_lang(lang_ids) + # TODO Should we dropout here??? + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # initialize previous states (or get from cache during incremental generation) + cached_state = utils.get_incremental_state( + self, incremental_state, "cached_state" + ) + if cached_state is not None: + prev_hiddens, prev_cells, input_feed = cached_state + else: + num_layers = len(self.layers) + if self.sentemb2init is None: + prev_hiddens = [ + x.data.new(bsz, self.hidden_size).zero_() for i in range(num_layers) + ] + prev_cells = [ + x.data.new(bsz, self.hidden_size).zero_() for i in range(num_layers) + ] + else: + init = self.sentemb2init(sentemb) + prev_hiddens = [ + init[:, (2 * i) * self.hidden_size : (2 * i + 1) * self.hidden_size] + for i in range(num_layers) + ] + prev_cells = [ + init[ + :, + (2 * i + 1) * self.hidden_size : (2 * i + 2) * self.hidden_size, + ] + for i in range(num_layers) + ] + input_feed = x.data.new(bsz, self.hidden_size).zero_() + + attn_scores = x.data.new(srclen, seqlen, bsz).zero_() + outs = [] + for j in range(seqlen): + if self.embed_lang is None: + input = torch.cat((x[j, :, :], sentemb), dim=1) + else: + input = torch.cat((x[j, :, :], sentemb, langemb), dim=1) + + for i, rnn in enumerate(self.layers): + # recurrent cell + hidden, cell = rnn(input, (prev_hiddens[i], prev_cells[i])) + + # hidden state becomes the input to the next layer + input = F.dropout(hidden, p=self.dropout_out, training=self.training) + + # save state for next time step + prev_hiddens[i] = hidden + prev_cells[i] = cell + + out = hidden + out = F.dropout(out, p=self.dropout_out, training=self.training) + + # input feeding + input_feed = out + + # save final output + outs.append(out) + + # cache previous states (no-op except during incremental generation) + utils.set_incremental_state( + self, + incremental_state, + "cached_state", + (prev_hiddens, prev_cells, input_feed), + ) + + # collect outputs across time steps + x = torch.cat(outs, dim=0).view(seqlen, bsz, self.hidden_size) + + # T x B x C -> B x T x C + x = x.transpose(1, 0) + + # srclen x tgtlen x bsz -> bsz x tgtlen x srclen + attn_scores = attn_scores.transpose(0, 2) + + # project back to size of vocabulary + if hasattr(self, "additional_fc"): + x = self.additional_fc(x) + x = F.dropout(x, p=self.dropout_out, training=self.training) + x = self.fc_out(x) + + return x, attn_scores + + def reorder_incremental_state(self, incremental_state, new_order): + super().reorder_incremental_state(incremental_state, new_order) + cached_state = utils.get_incremental_state( + self, incremental_state, "cached_state" + ) + if cached_state is None: + return + + def reorder_state(state): + if isinstance(state, list): + return [reorder_state(state_i) for state_i in state] + return state.index_select(0, new_order) + + new_state = tuple(map(reorder_state, cached_state)) + utils.set_incremental_state(self, incremental_state, "cached_state", new_state) + + def max_positions(self): + """Maximum output length supported by the decoder.""" + return int(1e5) # an arbitrary large number + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.uniform_(m.weight, -0.1, 0.1) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def LSTM(input_size, hidden_size, **kwargs): + m = nn.LSTM(input_size, hidden_size, **kwargs) + for name, param in m.named_parameters(): + if "weight" in name or "bias" in name: + param.data.uniform_(-0.1, 0.1) + return m + + +def LSTMCell(input_size, hidden_size, **kwargs): + m = nn.LSTMCell(input_size, hidden_size, **kwargs) + for name, param in m.named_parameters(): + if "weight" in name or "bias" in name: + param.data.uniform_(-0.1, 0.1) + return m + + +def Linear(in_features, out_features, bias=True, dropout=0): + """Weight-normalized Linear layer (input: N x T x C)""" + m = nn.Linear(in_features, out_features, bias=bias) + m.weight.data.uniform_(-0.1, 0.1) + if bias: + m.bias.data.uniform_(-0.1, 0.1) + return m + + +@register_model_architecture("laser_lstm", "laser_lstm") +def base_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_hidden_size = getattr( + args, "encoder_hidden_size", args.encoder_embed_dim + ) + args.encoder_layers = getattr(args, "encoder_layers", 1) + args.encoder_bidirectional = getattr(args, "encoder_bidirectional", False) + args.encoder_dropout_in = getattr(args, "encoder_dropout_in", args.dropout) + args.encoder_dropout_out = getattr(args, "encoder_dropout_out", args.dropout) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_hidden_size = getattr( + args, "decoder_hidden_size", args.decoder_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 1) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + args.decoder_dropout_in = getattr(args, "decoder_dropout_in", args.dropout) + args.decoder_dropout_out = getattr(args, "decoder_dropout_out", args.dropout) + args.decoder_zero_init = getattr(args, "decoder_zero_init", "0") + args.decoder_lang_embed_dim = getattr(args, "decoder_lang_embed_dim", 0) + args.fixed_embeddings = getattr(args, "fixed_embeddings", False) diff --git a/fairseq/examples/laser/laser_src/laser_task.py b/fairseq/examples/laser/laser_src/laser_task.py new file mode 100644 index 0000000000000000000000000000000000000000..e4152fde6861488acc3595fa25c456bf60f134b9 --- /dev/null +++ b/fairseq/examples/laser/laser_src/laser_task.py @@ -0,0 +1,331 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from collections import OrderedDict, defaultdict +import json +import os +import logging +from argparse import ArgumentError + +from fairseq import options, models +from fairseq.data import ( + data_utils, + Dictionary, + LanguagePairDataset, + IndexedDataset, + FairseqDataset, +) +from .multitask_data_utils import ( + MultitaskDatasetWrapper, + MultidatasetEpochBatchIterator, +) + + +from fairseq.tasks import LegacyFairseqTask, register_task + +logger = logging.getLogger(__name__) + + +@register_task("laser") +class LaserTask(LegacyFairseqTask): + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "configfile", metavar="PATH", help="dataset configuration file in json" + ) + parser.add_argument( + "--weighting-alpha", + type=float, + default=None, + help="alpha for automatic weighting", + ) + parser.add_argument( + "--raw-text", action="store_true", help="load raw text dataset" + ) + parser.add_argument( + "--left-pad-source", + default="True", + type=str, + metavar="BOOL", + help="pad the source on the left (default: True)", + ) + parser.add_argument( + "--left-pad-target", + default="False", + type=str, + metavar="BOOL", + help="pad the target on the left (default: False)", + ) + try: + parser.add_argument( + "--max-source-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the source sequence", + ) + parser.add_argument( + "--max-target-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the target sequence", + ) + except ArgumentError: + # this might have already been defined. Once we transition this to hydra it should be fine to add it here. + pass + + def __init__(self, args, config, src_dictionary, tgt_dictionary, num_tasks): + super().__init__(args) + self.config = config + self.src_dictionary = src_dictionary + self.tgt_dictionary = tgt_dictionary + self.num_tasks = num_tasks + + @classmethod + def setup_task(cls, args, **kwargs): + with open(args.configfile, "r") as f: + config = json.load(f) + num_tasks = max(dataset["id"] for dataset in config["train"]) + 1 + + args.left_pad_source = options.eval_bool(args.left_pad_source) + args.left_pad_target = options.eval_bool(args.left_pad_target) + + src_dictionary = Dictionary.load(config["src_vocab"]) + tgt_dictionary = Dictionary.load(config["tgt_vocab"]) + + logger.info( + "| src Dictionary {} : {} types".format( + config["src_vocab"], len(src_dictionary) + ) + ) + logger.info( + "| tgt Dictionary {} : {} types".format( + config["tgt_vocab"], len(tgt_dictionary) + ) + ) + + return cls(args, config, src_dictionary, tgt_dictionary, num_tasks) + + # Experimental overriding for backtranslation + def build_model(self, args): + model = models.build_model(args, self) + return model + + def dataset(self, split): + if split not in self.datasets: + raise KeyError("Dataset not loaded: " + split) + return self.datasets[split] + + def load_dataset(self, split, epoch=1, **kwargs): + """Load a dataset split.""" + + def indexed_dataset(path, dictionary): + if self.args.raw_text: + raise Exception("Unable to handle raw text.") + dataset = IndexedDataset(path, fix_lua_indexing=True) + + return dataset + + pair_datasets = OrderedDict() + + if split == "valid": + self.datasets[split] = pair_datasets + return + + if split not in self.config: + raise FileNotFoundError( + "Dataset not found in config file: {}".format(split) + ) + + size_by_corpus = defaultdict(int) + size_sum = 0 + size_sum_with_subsampling = 0 + init_pair_datasets = {} + + for dataset_config in self.config[split]: + src_path = os.path.dirname(dataset_config["src"]) + corpus_name = src_path.split("/")[-2] + language_pair_name = src_path.split("/")[-1] + pair_datasets_key = corpus_name + "-" + language_pair_name + + logger.info(f"loading... {pair_datasets_key}") + if "src" in dataset_config: + src_dataset = indexed_dataset( + dataset_config["src"], self.src_dictionary + ) + else: + src_dataset = None + + if "tgt" in dataset_config: + tgt_dataset = indexed_dataset( + dataset_config["tgt"], self.tgt_dictionary + ) + else: + tgt_dataset = None + + dataset = LanguagePairDataset( + src_dataset, + src_dataset.sizes, + self.src_dictionary, + tgt_dataset, + tgt_dataset.sizes, + self.tgt_dictionary, + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + ) + + if pair_datasets_key in init_pair_datasets: + logger.warning( + f"Ignoring already added {pair_datasets_key}. " + f"Consider using `sample` key in order to upsample." + ) + else: + init_pair_datasets[pair_datasets_key] = { + "dataset": dataset, + "sample": dataset_config.get("sample", None), + "id": dataset_config.get("id", None), + "len": len(dataset), + } + + length_sum = 0 + weighted_freqs_sum = 0 + freq_per_dataset = {} + vmax = 0 + vmin = 1 + weighted_freq_per_dataset = {} + + if self.args.weighting_alpha: + for key in init_pair_datasets: + if init_pair_datasets[key]["sample"] is None: + length_sum += len(init_pair_datasets[key]["dataset"]) + + for key in init_pair_datasets: + if init_pair_datasets[key]["sample"] is None: + val = float(init_pair_datasets[key]["len"]) / length_sum + freq_per_dataset[key] = val + weighted_freqs_sum += val ** self.args.weighting_alpha + + for key in freq_per_dataset: + val = ( + freq_per_dataset[key] ** self.args.weighting_alpha + / weighted_freqs_sum + ) + vmin = min(vmin, val) + vmax = max(vmax, val) + weighted_freq_per_dataset[key] = val + + for pair_datasets_key in init_pair_datasets: + dataset_config = init_pair_datasets[pair_datasets_key] + dataset = dataset_config["dataset"] + sample = dataset_config["sample"] + if sample is None: + sample = 1.0 + + if pair_datasets_key in weighted_freq_per_dataset: + w = vmax / weighted_freq_per_dataset[pair_datasets_key] + sample = w + + sample = round(sample) + + initial_sample = sample + initial_pair_datasets_key = pair_datasets_key + + while sample >= 1.0: + assert ( + pair_datasets_key not in pair_datasets + ), f"{pair_datasets_key} already in" + size_sum_with_subsampling += len(dataset) + pair_datasets[pair_datasets_key] = MultitaskDatasetWrapper( + dataset, dataset_config.get("id", 0), 1.0, name=pair_datasets_key + ) + size_sum += len(dataset) + sample -= 1.0 + pair_datasets_key += "-up" + + assert sample < 1e-6, f"sample remains > 0 {pair_datasets_key}" + + logger.info( + f"added pair {initial_pair_datasets_key} length {len(dataset)} new_length = {len(dataset)*initial_sample}" + ) + size_by_corpus[corpus_name] += len(dataset) + + self.datasets[split] = pair_datasets + logger.info( + f"Datasets number = {len(self.datasets[split])} size = {size_sum} size_sum_with_subsampling = {size_sum_with_subsampling}" + ) + + @property + def source_dictionary(self): + return self.src_dictionary + + @property + def target_dictionary(self): + return self.tgt_dictionary + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + + assert isinstance(dataset, OrderedDict) + assert len(dataset) + assert isinstance(dataset[next(iter(dataset))], FairseqDataset) + + # initialize the dataset with the correct starting epoch + for _, dt in dataset.items(): + dt.set_epoch(epoch) + + indices = OrderedDict() + batch_sampler = OrderedDict() + + with data_utils.numpy_seed(seed + epoch): + for key, dt in dataset.items(): + logger.info(f"\t ordered_indices {key}") + indices[key] = dt.ordered_indices() + + # filter examples that are too large + if max_positions is not None: + for key, dt in dataset.items(): + logger.info(f"\t filter_by_size {key}") + indices[key], ignored = dt.filter_indices_by_size( + indices[key], max_positions + ) + + for key, dt in dataset.items(): + logger.info(f"\t batch_by_size {key}") + batch_sampler[key] = data_utils.batch_by_size( + indices[key], + dt.num_tokens, + max_tokens=max_tokens, + max_sentences=max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + ) + + epoch_iter = MultidatasetEpochBatchIterator( + dataset=dataset, + batch_sampler=batch_sampler, + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + epoch=epoch, + ) + + return epoch_iter diff --git a/fairseq/examples/laser/laser_src/laser_transformer.py b/fairseq/examples/laser/laser_src/laser_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..0be030994ff87334ca0392302374693f7f2c61b3 --- /dev/null +++ b/fairseq/examples/laser/laser_src/laser_transformer.py @@ -0,0 +1,354 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +from typing import Any, Dict, List, Optional +from torch import Tensor + +import torch +import torch.nn as nn + +from fairseq.models import ( + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import ( + base_architecture, + Embedding, + TransformerModel, + TransformerEncoder, + TransformerDecoder, +) +from fairseq.modules import ( + TransformerDecoderLayer, +) + +logger = logging.getLogger(__name__) + + +@register_model("laser_transformer") +class LaserTransformerModel(FairseqEncoderDecoderModel): + """Train Transformer for LASER task + + Requires --task laser + """ + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens=None, + tgt_tokens=None, + tgt_lengths=None, + target_language_id=-1, + dataset_name="", + ): + laser_encoder_out = self.encoder(src_tokens, src_lengths) + return self.decoder( + prev_output_tokens, laser_encoder_out, lang_id=target_language_id + ) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + TransformerModel.add_args(parser) + parser.add_argument( + "--decoder-lang-embed-dim", + type=int, + metavar="N", + help="decoder language embedding dimension", + ) + + @classmethod + def build_model(cls, args, task): + base_laser_transformer_architecture(args) + + num_langs = task.num_tasks if hasattr(task, "num_tasks") else 0 + + def load_embed_tokens(dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + + return Embedding(num_embeddings, embed_dim, padding_idx) + + encoder_embed_tokens = load_embed_tokens( + task.source_dictionary, args.encoder_embed_dim + ) + decoder_embed_tokens = load_embed_tokens( + task.target_dictionary, args.decoder_embed_dim + ) + num_langs = task.num_tasks if hasattr(task, "num_tasks") else 0 + + encoder = LaserTransformerEncoder( + args, task.source_dictionary, encoder_embed_tokens + ) + + decoder = LaserTransformerDecoder( + args, + task.target_dictionary, + decoder_embed_tokens, + num_langs=num_langs, + lang_embed_dim=args.decoder_lang_embed_dim, + ) + + return cls(encoder, decoder) + + +class LaserTransformerEncoder(TransformerEncoder): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def forward(self, src_tokens, *args, **kwargs): + encoder_out = super().forward(src_tokens, *args, **kwargs) + + x = encoder_out["encoder_out"][0] # T x B x C + padding_mask = src_tokens.eq(self.padding_idx).t().unsqueeze(-1) + + if padding_mask.any(): + x = x.float().masked_fill_(padding_mask, float("-inf")).type_as(x) + + # Build the sentence embedding by max-pooling over the encoder outputs + sentemb = x.max(dim=0)[0] + + # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in + # `foward` so we use a dictionary instead. + # TorchScript does not support mixed values so the values are all lists. + # The empty list is equivalent to None. + return {"sentemb": [sentemb]} # B x C + + @torch.jit.export + def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order): + """ + Same as the one in transformer.py, with new_sentemb + """ + if len(encoder_out["sentemb"]) == 0: + new_sentemb = [] + else: + new_sentemb = [encoder_out["sentemb"][0].index_select(0, new_order)] + + return { + "sentemb": new_sentemb, # B x C + } + + +class LaserTransformerDecoder(TransformerDecoder): + def __init__(self, args, dictionary, *kargs, **kwargs): + self.num_langs = kwargs.get("num_langs", 1) + self.lang_embed_dim = kwargs.get("lang_embed_dim", 0) + kwargs.pop("num_langs", None) + kwargs.pop("lang_embed_dim", None) + + super().__init__(args, dictionary, *kargs, **kwargs, no_encoder_attn=True) + + if self.lang_embed_dim == 0: + self.embed_lang = None + else: + self.embed_lang = nn.Embedding(self.num_langs, self.lang_embed_dim) + nn.init.uniform_(self.embed_lang.weight, -0.1, 0.1) + + if self.output_projection is not None: + laser_output_embed_dim = ( + self.output_embed_dim + self.lang_embed_dim + args.encoder_embed_dim + ) + self.output_projection = nn.Linear( + laser_output_embed_dim, len(dictionary), bias=False + ) + nn.init.normal_( + self.output_projection.weight, + mean=0, + std=laser_output_embed_dim ** -0.5, + ) + + def build_decoder_layer(self, args, no_encoder_attn=False): + decoder_embed_dim = args.decoder_embed_dim + args.decoder_embed_dim = ( + decoder_embed_dim + self.lang_embed_dim + args.encoder_embed_dim + ) + res = TransformerDecoderLayer(args, no_encoder_attn=True) + args.decoder_embed_dim = decoder_embed_dim + + return res + + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + lang_id: Optional[int] = None, + ): + """ + Similar to *forward* but only return features. + + Includes several features from "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + alignment_layer (int, optional): return mean alignment over + heads at this layer (default: last layer). + alignment_heads (int, optional): only average alignment over + this many heads (default: all heads). + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + if alignment_layer is None: + alignment_layer = self.num_layers - 1 + + # embed positions + positions = ( + self.embed_positions( + prev_output_tokens, incremental_state=incremental_state + ) + if self.embed_positions is not None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + bsz, seqlen = prev_output_tokens.size() + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.quant_noise is not None: + x = self.quant_noise(x) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + if self.embed_lang is not None: + lang_ids = prev_output_tokens.data.new_full((bsz,), lang_id) + langemb = self.embed_lang(lang_ids) + langemb = langemb.unsqueeze(0) + repeat_vals = [x.shape[0] // langemb.shape[0]] + [-1] * ( + len(langemb.shape) - 1 + ) + x = torch.cat((x, langemb.expand(*repeat_vals)), dim=-1) + + sentemb = encoder_out["sentemb"][0] + sentemb = sentemb.unsqueeze(0) + + repeat_vals = [x.shape[0] // sentemb.shape[0]] + [-1] * (len(sentemb.shape) - 1) + x = torch.cat((x, sentemb.expand(*repeat_vals)), dim=-1) + + self_attn_padding_mask: Optional[Tensor] = None + if self.cross_self_attention or prev_output_tokens.eq(self.padding_idx).any(): + self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx) + + # decoder layers + attn: Optional[Tensor] = None + inner_states: List[Optional[Tensor]] = [x] + for idx, layer in enumerate(self.layers): + if incremental_state is None and not full_context_alignment: + self_attn_mask = self.buffered_future_mask(x) + else: + self_attn_mask = None + + x, layer_attn, _ = layer( + x, + None, + None, + incremental_state, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=self_attn_padding_mask, + need_attn=bool((idx == alignment_layer)), + need_head_weights=bool((idx == alignment_layer)), + ) + inner_states.append(x) + if layer_attn is not None and idx == alignment_layer: + attn = layer_attn.float().to(x) + + if attn is not None: + if alignment_heads is not None: + attn = attn[:alignment_heads] + + # average probabilities over heads + attn = attn.mean(dim=0) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": [attn], "inner_states": inner_states} + + def forward( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + lang_id: Optional[int] = None, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False). + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + + assert lang_id is not None + + x, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + incremental_state=incremental_state, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + lang_id=lang_id, + ) + if not features_only: + x = self.output_layer(x) + return x, extra + + +@register_model_architecture("laser_transformer", "laser_transformer") +def base_laser_transformer_architecture(args): + base_architecture(args) + args.decoder_lang_embed_dim = getattr(args, "decoder_lang_embed_dim", 0) diff --git a/fairseq/examples/laser/laser_src/multitask_data_utils.py b/fairseq/examples/laser/laser_src/multitask_data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b05caea26793bf5112a7abc29d76225f578f3ebe --- /dev/null +++ b/fairseq/examples/laser/laser_src/multitask_data_utils.py @@ -0,0 +1,143 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import OrderedDict + +import numpy as np + +from fairseq.data import BaseWrapperDataset, FairseqDataset, iterators + + +class MultiItr(object): + def __init__(self, itr): + self.itr = itr + self._counts = [0 for x in itr] + + def __len__(self): + return sum(len(itr) for itr in self.itr) + + def __iter__(self): + return self + + def __next__(self): + ratios = [count / len(itr) for count, itr in zip(self._counts, self.itr)] + idx = ratios.index(min(ratios)) + self._counts[idx] += 1 + return next(self.itr[idx]) + + +class MultidatasetEpochBatchIterator(iterators.EpochBatchIterating): + """A wrapper around multiple epoch batch iterators.""" + + def __init__( + self, + dataset, + batch_sampler, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + ): + + assert isinstance(dataset, OrderedDict) + assert len(dataset) + assert isinstance(dataset[next(iter(dataset))], FairseqDataset) + + self.iterators = [] + + self.epoch = epoch + for key, dt in dataset.items(): + epoch_iter = iterators.EpochBatchIterator( + dataset=dt, + collate_fn=dt.collater, + batch_sampler=batch_sampler[key], + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=0, + epoch=epoch, + ) + self.iterators.append(epoch_iter) + + def __len__(self): + return sum(len(itr) for itr in self.iterators) + + def next_epoch_itr(self, shuffle=True, fix_batches_to_gpus=False): + # `self.epoch += 1` should be handled by underlying `EpochBatchIterator`s. + return MultiItr( + [ + itr.next_epoch_itr( + shuffle=shuffle, fix_batches_to_gpus=fix_batches_to_gpus + ) + for itr in self.iterators + ] + ) + + def end_of_epoch(self): + return all(itr.end_of_epoch() for itr in self.iterators) + + @property + def next_epoch_idx(self): + """Return the epoch index after *next_epoch_itr* is called.""" + + epochs = [itr.next_epoch_idx for itr in self.iterators] + self.epoch = epochs[0] + assert all(epoch == self.epoch for epoch in epochs) + + return self.epoch + + @property + def iterations_in_epoch(self): + return sum(itr.iterations_in_epoch for itr in self.iterators) + + def state_dict(self): + return { + "iterators": [it.state_dict() for it in self.iterators], + "epoch": self.epoch, + } + + def load_state_dict(self, state_dict): + self.epoch = state_dict["epoch"] + for it, d in zip(self.iterators, state_dict["iterators"]): + it.load_state_dict(d) + + +class MultitaskDatasetWrapper(BaseWrapperDataset): + """A wrapper for a multitask dataset.""" + + def __init__(self, dataset, target_language_id, sample=1.0, name=""): + super().__init__(dataset) + self.target_language_id = target_language_id + self.sample = sample + self.name = name + + def collater(self, *args, **kwargs): + ans = self.dataset.collater(*args, **kwargs) + if "net_input" in ans: + ans["net_input"]["target_language_id"] = self.target_language_id + ans["net_input"]["dataset_name"] = self.name + return ans + + def num_tokens(self, *args, **kwargs): + return self.dataset.num_tokens(*args, **kwargs) + + def ordered_indices(self, *args, **kwargs): + indices = self.dataset.ordered_indices(*args, **kwargs) + # Hacky solution for sampling + size = int(self.sample * indices.shape[0]) + + return indices.take(np.sort(np.random.permutation(indices.shape[0])[:size])) + + def size(self, index: int): + return self.dataset.size(index) + + @property + def supports_prefetch(self): + """Whether this dataset supports prefetching.""" + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.dataset.prefetch(indices) diff --git a/fairseq/examples/latent_depth/README.md b/fairseq/examples/latent_depth/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7774c333053b95d15b180fdfc3ee3cd817790520 --- /dev/null +++ b/fairseq/examples/latent_depth/README.md @@ -0,0 +1,77 @@ +# Deep Transformers with Latent Depth (Li et al., 2020) + +[https://arxiv.org/abs/2009.13102](https://arxiv.org/abs/2009.13102). + +## Introduction + +We present a probabilistic framework to automatically learn which layer(s) to use by learning the posterior distributions of layer selection. As an extension of this framework, we propose a novel method to train one shared Transformer network for multilingual machine translation with different layer selection posteriors for each language pair. + +## Training a multilingual model with latent depth + +Below is an example of training with latent depth in decoder for one-to-many (O2M) related languages. We use the same preprocessed (numberized and binarized) TED8 dataset as in [Balancing Training for Multilingual Neural Machine Translation (Wang et al., 2020)](https://github.com/cindyxinyiwang/multiDDS), which could be generated by [the script](https://github.com/cindyxinyiwang/multiDDS/blob/multiDDS/util_scripts/prepare_multilingual_data.sh) the author provided. +```bash +lang_pairs_str="eng-aze,eng-bel,eng-ces,eng-glg,eng-por,eng-rus,eng-slk,eng-tur" +databin_dir= + +fairseq-train ${databin_dir} \ + --user-dir examples/latent_depth/latent_depth_src \ + --lang-pairs "${lang_pairs_str}" \ + --arch multilingual_transformer_iwslt_de_en \ + --task multilingual_translation_latent_depth \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --share-encoders \ + --share-decoders \ + --decoder-langtok \ + --share-decoder-input-output-embed \ + --dropout 0.3 --attention-dropout 0.3 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt --stop-min-lr 1e-9 --warmup-init-lr 1e-7 --warmup-updates 8000 \ + --max-tokens 4096 --update-freq 1 \ + --lr 0.0015 \ + --clip-norm 1.0 \ + --seed 2 \ + --ddp-backend=legacy_ddp \ + --encoder-layers 12 \ + --decoder-layers 24 \ + --decoder-latent-layer \ + --sparsity-weight 0.1 \ + --anneal-updates 5000 \ + --soft-update 500 \ + --target-layers 12 \ + --share-weight 0.1 +``` +## Inference command + +```bash +lang_pairs_str="eng-aze,eng-bel,eng-ces,eng-glg,eng-por,eng-rus,eng-slk,eng-tur" +databin_dir= +model_path= +src_lang= +tgt_lang= +gen_data= + +fairseq-generate ${databin_dir} \ + --path ${model_path} \ + --task multilingual_translation_latent_depth \ + --decoder-latent-layer \ + --lang-pairs "${lang_pairs_str}" \ + -s ${src_lang} -t ${tgt_lang} \ + --gen-subset $gen_data \ + --scoring sacrebleu \ + --remove-bpe 'sentencepiece' \ + --lenpen 1.0 \ + --beam 5 \ + --decoder-langtok \ + --max-tokens 4096 +``` + + +## Citation +```bibtex +@article{li2020deep, + title={Deep Transformers with Latent Depth}, + author={Li, Xian and Stickland, Asa Cooper and Tang, Yuqing and Kong, Xiang}, + journal={arXiv preprint arXiv:2009.13102}, + year={2020} +} +``` diff --git a/fairseq/examples/latent_depth/latent_depth_src/__init__.py b/fairseq/examples/latent_depth/latent_depth_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c5fa76039ff98c18d3c14b5f4a8f73ffe644de11 --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import multilingual_translation_latent_depth # noqa +from .loss import latent_depth # noqa +from .models import latent_multilingual_transformer # noqa +from .modules import latent_layers # noqa diff --git a/fairseq/examples/latent_depth/latent_depth_src/loss/__init__.py b/fairseq/examples/latent_depth/latent_depth_src/loss/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/latent_depth/latent_depth_src/loss/latent_depth.py b/fairseq/examples/latent_depth/latent_depth_src/loss/latent_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..a3b9535ecac3ec403868681a8b50c1fbe1c90dfe --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/loss/latent_depth.py @@ -0,0 +1,99 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +from torch.nn.modules.loss import _Loss + + +class LatentLayersKLLoss(_Loss): + def __init__(self, args): + super().__init__() + self.args = args + + def forward(self, layer_samples, lang_idx, update_num, sample_size): + prior = self.args.prior + samples = layer_samples[lang_idx] + eps = 1e-7 + if prior == "uniform": + # uniform prior + kl_loss = (samples * (torch.log(samples + eps) - math.log(0.5))).sum(-1) + elif prior == "agged_posterior": + # aggregated posterior + y_t = torch.stack([x.detach() for x in layer_samples], dim=0) + agged_q = torch.sum(y_t, dim=0) + row_norm = agged_q.sum(-1) + normed_agg_q = agged_q / row_norm + kl_loss = ( + samples * (torch.log(samples + eps) - torch.log(normed_agg_q + eps)) + ).sum(-1) + else: + raise NotImplementedError("The specified prior is not implemented.") + + # normalized by number of layers + kl_loss /= layer_samples[0].size()[0] + kl_weight = min( + self.args.sparsity_weight, + (update_num - self.args.soft_update) + * self.args.sparsity_weight + / self.args.anneal_updates, + ) + kl_loss *= kl_weight * sample_size + return kl_loss + + +class LatentLayersSparsityLoss(_Loss): + def __init__(self, args): + super().__init__() + self.args = args + + def is_valid(self, update_num): + if self.args.target_layers <= 0: + return False + return update_num > (self.args.soft_update + self.args.anneal_updates) + + def forward(self, layer_samples_list, update_num, sample_size): + batch_loss = 0 + share_loss = 0 + global_sparsity_loss = 0 + layer_samples = torch.stack(layer_samples_list, dim=0) + if ( + self.args.target_layers > 0 or self.args.share_weight > 0 + ) and update_num > (self.args.soft_update + self.args.anneal_updates): + # anneal sparsity weight + if update_num < (self.args.anneal_updates + self.args.soft_update): + weight_anneal = 0 + elif update_num < (2 * self.args.anneal_updates + self.args.soft_update): + weight_anneal = ( + (update_num - self.args.soft_update - self.args.anneal_updates) + * self.args.share_weight + / self.args.anneal_updates + ) + else: + weight_anneal = 1 + # compute ratio among languages + layer_utilization = torch.sum(layer_samples, dim=0) + layer_utilization /= layer_samples.size()[0] + if self.args.share_weight > 0: + # encouraging sharing across languages + share_loss = sum( + -1.0 * v * math.log(v) for v in layer_utilization if v > 0 + ) + batch_loss += ( + weight_anneal * self.args.share_weight * sample_size * share_loss + ) + if self.args.target_layers > 0: + # computed expected number of layers selected + expeted_layers = sum(layer_utilization) + # compute l2 loss wrt target number of layers + global_sparsity_loss = (expeted_layers - self.args.target_layers) ** 2 + batch_loss += ( + weight_anneal + * self.args.share_weight + * sample_size + * global_sparsity_loss + ) + return batch_loss diff --git a/fairseq/examples/latent_depth/latent_depth_src/models/__init__.py b/fairseq/examples/latent_depth/latent_depth_src/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/latent_depth/latent_depth_src/models/latent_multilingual_transformer.py b/fairseq/examples/latent_depth/latent_depth_src/models/latent_multilingual_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..9e7b655feee0042d42ac2b13cec5f1d2a88e201e --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/models/latent_multilingual_transformer.py @@ -0,0 +1,76 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.models import register_model, register_model_architecture +from fairseq.models.multilingual_transformer import MultilingualTransformerModel +from fairseq.models.transformer import ( + TransformerDecoder, + TransformerEncoder, + base_architecture, +) +from fairseq.utils import safe_hasattr + +from .latent_transformer import LatentTransformerDecoder, LatentTransformerEncoder + + +@register_model("latent_multilingual_transformer") +class LatentMultilingualTransformerModel(MultilingualTransformerModel): + """A variant of standard multilingual Transformer models which encoder and/or + decoders supports latent depth, as is in "Deep Transformer with Latent Depth" + (https://arxiv.org/abs/2009.13102). + """ + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + MultilingualTransformerModel.add_args(parser) + parser.add_argument( + '--soft-select', + action='store_true', + help='use soft samples in training an inference', + ) + parser.add_argument( + '--sampling-tau', + type=float, + default=5., + help='sampling temperature', + ) + + @classmethod + def _get_module_class(cls, is_encoder, args, lang_dict, embed_tokens, langs): + if is_encoder: + if safe_hasattr(args, "encoder_latent_layer") and args.encoder_latent_layer: + return LatentTransformerEncoder( + args, lang_dict, embed_tokens, num_logits=len(langs) + ) + else: + return TransformerEncoder(args, lang_dict, embed_tokens) + else: + if safe_hasattr(args, "decoder_latent_layer") and args.decoder_latent_layer: + return LatentTransformerDecoder( + args, lang_dict, embed_tokens, num_logits=len(langs) + ) + else: + return TransformerDecoder(args, lang_dict, embed_tokens) + + +@register_model_architecture( + "latent_multilingual_transformer", "latent_multilingual_transformer" +) +def latent_multilingual_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 24) + args.share_encoders = getattr(args, "share_encoders", True) + args.share_decoders = getattr(args, "share_decoders", True) + args.share_encoder_embeddings = getattr(args, "share_encoder_embeddings", True) + args.share_decoder_embeddings = getattr(args, "share_decoder_embeddings", True) + + base_architecture(args) diff --git a/fairseq/examples/latent_depth/latent_depth_src/models/latent_transformer.py b/fairseq/examples/latent_depth/latent_depth_src/models/latent_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..6a825301a452bd935deafdaf78fa2427ca9a469e --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/models/latent_transformer.py @@ -0,0 +1,156 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Any, Dict, Optional + +import torch.nn as nn +from fairseq.models.fairseq_encoder import EncoderOut +from fairseq.models.transformer import TransformerDecoder, TransformerEncoder +from fairseq.modules import TransformerDecoderLayer, TransformerEncoderLayer +from torch import Tensor + +from ..modules.latent_layers import LayerSelect + + +class LatentTransformerEncoder(TransformerEncoder): + """Latent depth (https://arxiv.org/abs/2009.13102) implemented in + TransformerEncoder. + """ + + def __init__(self, args, dictionary, embed_tokens, num_logits=1): + self.num_logits = num_logits + self.num_layers = args.encoder_layers + super().__init__(args, dictionary, embed_tokens) + self.layer_select = LayerSelect( + num_layers=self.num_layers, + num_logits=self.num_logits, + soft_select=getattr(args, "soft_select", False), + sampling_tau=getattr(args, "sampling_tau", 5.), + ) + self.lang_idx = None + self.layers = nn.ModuleList( + [self._build_encoder_layer(args, idx) for idx in range(args.encoder_layers)] + ) + + def set_lang_idx(self, lang_idx): + self.lang_idx = lang_idx + + def _build_encoder_layer(self, args, idx=None): + return LatentTransformerEncoderLayer(args, idx, layer_select=self.layer_select) + + def forward(self, src_tokens, src_lengths, return_all_hiddens: bool = False): + self.layer_select.sample(self.lang_idx) + return super().forward(src_tokens, src_lengths, return_all_hiddens) + + +class LatentTransformerEncoderLayer(TransformerEncoderLayer): + """Encoder layer with each (non_residual) block weighted by samples of Bernouli + or Gumbel Signmoid samples. + + Args: + args (argparse.Namespace): parsed command-line arguments from standard + TransformerEncoderLayer. + idx (int): layer index (used to retrieve samples). + layer_select (LayerSelect, optional): instance of LayerSelect module with logits + parameters and sampling method. + """ + + def __init__(self, args, idx, layer_select=None): + super().__init__(args) + self.idx = idx + self.layer_select = layer_select + + def residual_connection(self, x, residual): + return residual + x * self.layer_select(self.idx) + + +class LatentTransformerDecoder(TransformerDecoder): + """Latent depth (https://arxiv.org/abs/2009.13102) implemented in + TransformerDecoder. + """ + + def __init__( + self, args, dictionary, embed_tokens, no_encoder_attn=False, num_logits=1 + ): + self.num_logits = num_logits + self.num_layers = args.decoder_layers + super().__init__( + args, dictionary, embed_tokens, no_encoder_attn=no_encoder_attn + ) + self.layer_select = LayerSelect( + num_layers=self.num_layers, + num_logits=self.num_logits, + soft_select=getattr(args, "soft_select", False), + sampling_tau=getattr(args, "sampling_tau", 5.), + ) + self.lang_idx = None + self.layers = nn.ModuleList( + [ + self._build_decoder_layer(args, no_encoder_attn, idx) + for idx in range(args.decoder_layers) + ] + ) + + def set_lang_idx(self, lang_idx): + self.lang_idx = lang_idx + + def _build_decoder_layer(self, args, no_encoder_attn=False, idx=None): + return LatentTransformerDecoderLayer( + args, idx, layer_select=self.layer_select, no_encoder_attn=no_encoder_attn + ) + + def forward( + self, + prev_output_tokens, + encoder_out: Optional[EncoderOut] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + ): + self.layer_select.sample(self.lang_idx) + return super().forward( + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + incremental_state=incremental_state, + features_only=features_only, + alignment_layer=alignment_layer, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + + +class LatentTransformerDecoderLayer(TransformerDecoderLayer): + """Decoder layer with each (non_residual) block weighted by samples of Bernouli + or Gumbel Signmoid samples. + + Args: + args (argparse.Namespace): parsed command-line arguments from standard + TransformerDecoderLayer. + idx (int): layer index (used to retrieve samples). + layer_select (LayerSelect, optional): instance of LayerSelect module with logits + parameters and sampling method. + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + + """ + + def __init__( + self, + args, + idx, + layer_select=None, + no_encoder_attn=False, + add_bias_kv=False, + add_zero_attn=False, + ): + super().__init__(args, no_encoder_attn, add_bias_kv, add_zero_attn) + self.idx = idx + self.layer_select = layer_select + + def residual_connection(self, x, residual): + return residual + x * self.layer_select(self.idx) diff --git a/fairseq/examples/latent_depth/latent_depth_src/modules/__init__.py b/fairseq/examples/latent_depth/latent_depth_src/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/latent_depth/latent_depth_src/modules/latent_layers.py b/fairseq/examples/latent_depth/latent_depth_src/modules/latent_layers.py new file mode 100644 index 0000000000000000000000000000000000000000..2be05d5535cb05b16f61603a7356df2326bf2e23 --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/modules/latent_layers.py @@ -0,0 +1,75 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + + +class LayerSelect(nn.Module): + """Compute samples (from a Gumbel-Sigmoid distribution) which is used as + either (soft) weighting or (hard) selection of residual connection. + https://arxiv.org/abs/2009.13102 + """ + def __init__(self, num_layers, num_logits, soft_select=False, sampling_tau=5.): + super(LayerSelect, self).__init__() + self.layer_logits = torch.nn.Parameter( + torch.Tensor(num_logits, num_layers), + requires_grad=True, + ) + self.hard_select = not soft_select + self.tau = sampling_tau + self.detach_grad = False + self.layer_samples = [None] * num_logits + + def sample(self, logit_idx): + """To leverage the efficiency of distributed training, samples for all + layers are computed at once for each logit_idx. Logits are parameters + learnt independent of each other. + + Args: + logit_idx: The index of logit parameters used for sampling. + """ + assert logit_idx is not None + self.samples = self._gumbel_sigmoid( + self.layer_logits[logit_idx, :].detach() + if self.detach_grad + else self.layer_logits[logit_idx, :], + dim=-1, + tau=self.tau, + hard=self.hard_select, + ) + self.layer_samples[logit_idx] = self.samples + + def forward(self, i): + sample = self.samples[i] + return sample + + def _gumbel_sigmoid( + self, logits, tau=1, hard=False, eps=1e-10, dim=-1, threshold=0.5 + ): + # ~Gumbel(0,1) + gumbels1 = ( + -torch.empty_like(logits, memory_format=torch.legacy_contiguous_format) + .exponential_() + .log() + ) + gumbels2 = ( + -torch.empty_like(logits, memory_format=torch.legacy_contiguous_format) + .exponential_() + .log() + ) + # Difference of two gumbels because we apply a sigmoid + gumbels1 = (logits + gumbels1 - gumbels2) / tau + y_soft = gumbels1.sigmoid() + if hard: + # Straight through. + y_hard = torch.zeros_like( + logits, memory_format=torch.legacy_contiguous_format + ).masked_fill(y_soft > threshold, 1.0) + ret = y_hard - y_soft.detach() + y_soft + else: + # Reparametrization trick. + ret = y_soft + return ret diff --git a/fairseq/examples/latent_depth/latent_depth_src/multilingual_translation_latent_depth.py b/fairseq/examples/latent_depth/latent_depth_src/multilingual_translation_latent_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..8cc2a7174b765b7ad8808489196e12082a91a2d7 --- /dev/null +++ b/fairseq/examples/latent_depth/latent_depth_src/multilingual_translation_latent_depth.py @@ -0,0 +1,195 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.tasks import register_task +from fairseq.tasks.multilingual_translation import MultilingualTranslationTask +from fairseq.utils import safe_hasattr + +from .loss.latent_depth import LatentLayersKLLoss, LatentLayersSparsityLoss + + +@register_task("multilingual_translation_latent_depth") +class MultilingualTranslationTaskLatentDepth(MultilingualTranslationTask): + """A task for multiple translation with latent depth. + + See `"Deep Transformer with Latent Depth" + (Li et al., 2020) `_. + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + MultilingualTranslationTask.add_args(parser) + parser.add_argument('--encoder-latent-layer', action='store_true', help='latent layer selection in encoder') + parser.add_argument('--decoder-latent-layer', action='store_true', help='latent layer selection in decoder') + parser.add_argument('--target-layers', default=-1, type=int, + help='number of effective layers to learn; -1 means no constraint') + parser.add_argument('--sparsity-weight', default=0.0, type=float, + help='weight for sparsity loss') + parser.add_argument('--share-weight', default=0.0, type=float, + help='weight for sharing loss') + parser.add_argument('--soft-update', default=1, type=int, + help='number of updates with soft sampling') + parser.add_argument('--anneal-updates', default=1, type=int, + help='number of updates to anneal the KL loss weight') + parser.add_argument('--prior', default="uniform", type=str, + help='prior used for computing KL loss') + # fmt: on + + def __init__(self, args, dicts, training): + super().__init__(args, dicts, training) + self.src_langs, self.tgt_langs = zip( + *[(lang.split("-")[0], lang.split("-")[1]) for lang in args.lang_pairs] + ) + if self.training and self.encoder_latent_layer: + assert self.args.share_encoders + if self.training and self.decoder_latent_layer: + assert self.args.share_decoders + if training or self.encoder_latent_layer or self.decoder_latent_layer: + self.lang_pairs = args.lang_pairs + else: + self.lang_pairs = ["{}-{}".format(args.source_lang, args.target_lang)] + self.eval_lang_pairs = self.lang_pairs + self.model_lang_pairs = self.lang_pairs + if self.training and (self.encoder_latent_layer or self.decoder_latent_layer): + self.kl_loss = LatentLayersKLLoss(self.args) + self.sparsity_loss = LatentLayersSparsityLoss(self.args) + + def _per_lang_pair_train_loss( + self, lang_pair, model, update_num, criterion, sample, optimizer, ignore_grad + ): + src, tgt = lang_pair.split("-") + if self.encoder_latent_layer: + src_lang_idx = self.src_lang_idx_dict[src] + model.models[lang_pair].encoder.set_lang_idx(src_lang_idx) + model.models[lang_pair].encoder.layer_select.hard_select = ( + update_num > self.args.soft_update + ) + if self.decoder_latent_layer: + tgt_lang_idx = self.tgt_lang_idx_dict[tgt] + model.models[lang_pair].decoder.set_lang_idx(tgt_lang_idx) + model.models[lang_pair].decoder.layer_select.hard_select = ( + update_num > self.args.soft_update + ) + + loss, sample_size, logging_output = criterion( + model.models[lang_pair], sample[lang_pair] + ) + if self.encoder_latent_layer: + none_samples = sum( + 1 if x is None else 0 + for x in model.models[lang_pair].encoder.layer_select.layer_samples + ) + if none_samples == 0 or self.args.prior != "agged_posterior": + loss += self.kl_loss( + model.models[lang_pair].encoder.layer_select.layer_samples, + src_lang_idx, + update_num, + sample_size, + ) + if self.decoder_latent_layer: + none_samples = sum( + 1 if x is None else 0 + for x in model.models[lang_pair].decoder.layer_select.layer_samples + ) + if none_samples == 0 or self.args.prior != "agged_posterior": + loss += self.kl_loss( + model.models[lang_pair].decoder.layer_select.layer_samples, + tgt_lang_idx, + update_num, + sample_size, + ) + if ignore_grad: + loss *= 0 + + if hasattr(self, "sparsity_loss") and self.sparsity_loss.is_valid(update_num): + # need to retain the graph if sparsity loss needs to be added + loss.backward(retain_graph=True) + else: + optimizer.backward(loss) + + return loss, sample_size, logging_output + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + agg_loss, agg_sample_size, agg_logging_output = super().train_step( + sample, model, criterion, optimizer, update_num, ignore_grad + ) + # compute auxiliary loss from layere sparsity, based on all samples from all languages + if hasattr(self, "sparsity_loss") and self.sparsity_loss.is_valid(update_num): + sparsity_loss = 0 + if self.encoder_latent_layer: + sparsity_loss += self.sparsity_loss( + next( + iter(model.models.values()) + ).encoder.layer_select.layer_samples, + update_num, + agg_sample_size, + ) + if self.decoder_latent_layer: + sparsity_loss += self.sparsity_loss( + next( + iter(model.models.values()) + ).decoder.layer_select.layer_samples, + update_num, + agg_sample_size, + ) + if sparsity_loss > 0: + optimizer.backward(sparsity_loss) + return agg_loss, agg_sample_size, agg_logging_output + + def _per_lang_pair_valid_loss(self, lang_pair, model, criterion, sample): + src, tgt = lang_pair.split("-") + if self.encoder_latent_layer: + src_lang_idx = self.src_lang_idx_dict[src] + model.models[lang_pair].encoder.set_lang_idx(src_lang_idx) + if self.decoder_latent_layer: + tgt_lang_idx = self.tgt_lang_idx_dict[tgt] + model.models[lang_pair].decoder.set_lang_idx(tgt_lang_idx) + loss, sample_size, logging_output = criterion( + model.models[lang_pair], sample[lang_pair] + ) + return loss, sample_size, logging_output + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + if self.encoder_latent_layer or self.decoder_latent_layer: + for model in models: + if self.encoder_latent_layer: + assert model.encoder.layer_select is not None + src_lang_idx = self.src_lang_idx_dict[self.args.source_lang] + model.encoder.set_lang_idx(src_lang_idx) + if self.decoder_latent_layer: + assert model.decoder.layer_select is not None + tgt_lang_idx = self.tgt_lang_idx_dict[self.args.target_lang] + model.decoder.set_lang_idx(tgt_lang_idx) + return super().inference_step( + generator, models, sample, prefix_tokens, constraints + ) + + @property + def encoder_latent_layer(self): + return ( + safe_hasattr(self.args, "encoder_latent_layer") + and self.args.encoder_latent_layer + ) + + @property + def decoder_latent_layer(self): + return ( + safe_hasattr(self.args, "decoder_latent_layer") + and self.args.decoder_latent_layer + ) + + @property + def src_lang_idx_dict(self): + return {lang: lang_idx for lang_idx, lang in enumerate(self.src_langs)} + + @property + def tgt_lang_idx_dict(self): + return {lang: lang_idx for lang_idx, lang in enumerate(self.tgt_langs)} diff --git a/fairseq/examples/layerdrop/README.md b/fairseq/examples/layerdrop/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4d48ee9615e1458e1e889635dc9938e427a7f64a --- /dev/null +++ b/fairseq/examples/layerdrop/README.md @@ -0,0 +1,154 @@ +# Reducing Transformer Depth on Demand with Structured Dropout (Fan et al., 2019) +This page contains information for how to train models with LayerDrop, based on this [paper](https://arxiv.org/abs/1909.11556). + +## Citation: +If you found this technique useful, please cite our paper: +```bibtex +@article{fan2019reducing, + title={Reducing Transformer Depth on Demand with Structured Dropout}, + author={Fan, Angela and Grave, Edouard and Joulin, Armand}, + journal={arXiv preprint arXiv:1909.11556}, + year={2019} +} +``` + +## Pre-trained models + +Model | Description | Download +---|---|--- +`layerdrop_wmt_en_de_12_6` | Transformer + LayerDrop 0.2 trained on WMT16 en-de with 12 encoder and 6 decoder layers | [layerdrop_wmt_en_de_12_6.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/layerdrop_wmt_en_de_12_6.tar.gz) +`roberta_layerdrop.base` | RoBERTa Base + LayerDrop 0.2 | [roberta_layerdrop.base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta_layerdrop.base.qnli.tar.gz) +`roberta_layerdrop.large` | RoBERTa Large + LayerDrop 0.2 | [roberta_layerdrop.large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta_layerdrop.large.tar.gz) +`roberta_layerdrop.large.mnli` | `roberta_layerdrop.large` finetuned on [MNLI](http://www.nyu.edu/projects/bowman/multinli) | [roberta_layerdrop.large.mnli.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta_layerdrop.large.mnli.tar.gz) +`roberta_layerdrop.large.qnli` | `roberta_layerdrop.large` finetuned on [QNLI](https://arxiv.org/abs/1804.07461) | [roberta_layerdrop.large.mnli.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta_layerdrop.large.qnli.tar.gz) + + +Evaluate performance of these pre-trained models: +```bash +# Example for Machine Translation +fairseq-generate /path/to/bped/wmt/data --path nmt_checkpoint.pt \ + --beam 8 --lenpen 0.4 \ + --batch-size 64 \ + --remove-bpe \ + --gen-subset test > wmt16_gen.txt +bash scripts/compound_split_bleu.sh wmt16_gen.txt +# prints BLEU4 = 30.17 +``` + +```python +# Example for RoBERTa + LayerDrop finetuned on MNLI: +from fairseq.models.roberta import RobertaModel + +roberta_layerdrop = RobertaModel.from_pretrained( + '/path/to/MNLI/model', + checkpoint_file='mnli_checkpoint.pt', + data_name_or_path='/path/to/MNLI/data/MNLI-bin' +) +label_map = {0: 'contradiction', 2: 'neutral', 1: 'entailment'} +ncorrect, nsamples = 0, 0 +roberta_layerdrop.cuda() +roberta_layerdrop.eval() +with open('/path/to/MNLI/data/dev_matched.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[8], tokens[9], tokens[-1] + tokens = roberta_layerdrop.encode(sent1, sent2) + prediction = roberta_layerdrop.predict('sentence_classification_head', tokens).argmax().item() + prediction_label = label_map[prediction] + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) +# prints | Accuracy: 0.9026999490575649 + + +# Example for RoBERTa + LayerDrop finetuned on QNLI: +roberta = RobertaModel.from_pretrained( + '/path/to/QNLI/model', + checkpoint_file='qnli_checkpoint.pt', + data_name_or_path='/path/to/QNLI/data/QNLI-bin' +) + +label_fn = lambda label: roberta.task.label_dictionary.string( + [label + roberta.task.target_dictionary.nspecial] +) +ncorrect, nsamples = 0, 0 +roberta.cuda() +roberta.eval() +with open('/path/to/QNLI/data/dev.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[1], tokens[2], tokens[3] + tokens = roberta.encode(sent1, sent2) + prediction = roberta.predict('sentence_classification_head', tokens).argmax().item() + prediction_label = label_fn(prediction) + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) +# prints | Accuracy: 0.9480139117700896 +``` + + +## Example usage + +To train a model with LayerDrop, add the following flags. We recommend 0.2, a value that worked well in our experiments. For Language Models that are decoder-only, you need only the decoder flag. For RoBERTa, an encoder, you need only the encoder flag. The encoder and decoder LayerDrop values can be set differently. +``` +--encoder-layerdrop 0.2 --decoder-layerdrop 0.2 +``` + +To prune a model that has been trained with LayerDrop, add the following flags followed by a comma separated list of which layers you would like to keep. +``` +--encoder-layers-to-keep 0,2,4,6,8,10,12,14 --decoder-layers-to-keep 0,2,4,6,8,10,12,14 +``` +Setting these flags should print a message such as: +``` +| Pruning model to specified layer configuration +``` +You should also see a smaller number of parameters in the model, for example the 16-Layer Transformer Language Model prints: +``` +num. model params: 246933504 +``` +while a model pruned to 8 Layers prints: +``` +num. model params: 146163712 +``` + +If you would like to pick up training with a model that has been pruned, simply adding these flags is sufficient. If you would like to use a script that only does evaluation (no training), you may need to pass an override command. A specific example would be for language modeling: +```bash +fairseq-eval-lm /path/to/wikitext-103 \ + --path /path/to/model/checkpoint.pt \ + --model-overrides "{'decoder_layers_to_keep':'0,2,4,6,8,10,12,14'}" +``` +This model override command overrides the training parameters and updates the model arguments so that the pruned model is run instead of the full model. + +## Reproduce Paper Results + +Looking to reproduce the results in the paper? + +1. For Translation on WMT16 en-de, we followed this setting [here](https://github.com/pytorch/fairseq/blob/main/examples/scaling_nmt/README.md) +2. To train RoBERTa, we followed this setting [here](https://github.com/pytorch/fairseq/tree/main/examples/roberta) +3. To train Language Models on Wikitext-103, we followed this setting [here](https://github.com/pytorch/fairseq/tree/main/examples/language_model) + + +## Tips + +1. If you would like to train large models with better performance, LayerDrop should be set to a smaller value such as 0.1 or 0.2. Too much LayerDrop will mean the model has too much regularization, so may not reach the best performance. Since LayerDrop adds regularization, you may achieve the best performance by slightly reducing the amount of standard dropout (for example, reduce by 0.1). + +2. If you would like to train large models to be pruned and made smaller, LayerDrop should be set to a larger value such as 0.5 if you want to prune very aggressively (such as removing half the network or more). If you would like to prune fewer layers away, LayerDrop can be set to a smaller value such as 0.2. Our experiments were conducted with low values of LayerDrop (such as 0.1 and 0.2), for reference. + +3. When pruning layers at inference time, it is best to spread out the layers remaining so they are evenly spaced throughout the network. For example, if you want to remove 50% of the network, keeping every other layer is good. + + +## FAQ + +1. How did the sharing layers experiment work? In an appendix (https://openreview.net/pdf?id=SylO2yStDr) we added an experiment on Wikitext-103 language modeling that combined LayerDrop with Weight Sharing. We shared chunks of 2 layers such that every other layer had shared weights. For example, if our network has layers 1 through 6, then layer 1 and 2 are shared, layer 3 and 4 are shared, and layer 5 and 6 are shared. + +2. LayerDrop hasn't been helping in my setting? During training time, LayerDrop can help regularize your network. This is most important if your network is already overfitting - if your network is underfitting, it is possible LayerDrop is adding too much regularization. We recommend using smaller values (such as 0.1 or 0.2) and also decreasing the quantity of standard dropout (for example, reduce by 0.1). + +3. Can you train a model without LayerDrop and finetune with LayerDrop (e.g. for BERT)? In our experiments, we did not see great performance. Models such as RoBERTa have trained for a long time in the pre-training setting, so only finetuning with LayerDrop for a few epochs on a downstream task such as MNLI does not achieve the robustness required for successful pruning. + + +## Having an issue or have a question? + +Please open an issue in this repository with the details of your question. Thanks! diff --git a/fairseq/examples/linformer/README.md b/fairseq/examples/linformer/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f8b36bc691cb8f5bf82942e07b6d9c014387bdd8 --- /dev/null +++ b/fairseq/examples/linformer/README.md @@ -0,0 +1,22 @@ +# Linformer: Self-Attention with Linear Complexity (Wang et al., 2020) + +This example contains code to train Linformer models as described in our paper +[Linformer: Self-Attention with Linear Complexity](https://arxiv.org/abs/2006.04768). + +## Training a new Linformer RoBERTa model + +You can mostly follow the [RoBERTa pretraining README](/examples/roberta/README.pretraining.md), +updating your training command with `--user-dir examples/linformer/linformer_src --arch linformer_roberta_base`. + +## Citation + +If you use our work, please cite: + +```bibtex +@article{wang2020linformer, + title={Linformer: Self-Attention with Linear Complexity}, + author={Wang, Sinong and Li, Belinda and Khabsa, Madian and Fang, Han and Ma, Hao}, + journal={arXiv preprint arXiv:2006.04768}, + year={2020} +} +``` diff --git a/fairseq/examples/linformer/linformer_src/__init__.py b/fairseq/examples/linformer/linformer_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1c52f135ea6f99d0effe8ce1f7d77cbd66be3745 --- /dev/null +++ b/fairseq/examples/linformer/linformer_src/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .models import linformer_roberta # noqa diff --git a/fairseq/examples/linformer/linformer_src/models/__init__.py b/fairseq/examples/linformer/linformer_src/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/linformer/linformer_src/models/linformer_roberta.py b/fairseq/examples/linformer/linformer_src/models/linformer_roberta.py new file mode 100644 index 0000000000000000000000000000000000000000..b7bdbb11057d0ba791c2f8c7fb1e77507c90172e --- /dev/null +++ b/fairseq/examples/linformer/linformer_src/models/linformer_roberta.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Linformer: Self-Attention with Linear Complexity +""" + +import logging + +import torch +from fairseq import utils +from fairseq.models import register_model, register_model_architecture +from fairseq.models.roberta import ( + init_bert_params, + roberta_base_architecture, + roberta_large_architecture, + RobertaEncoder, + RobertaModel, +) +from fairseq.utils import safe_hasattr + +from ..modules.linformer_sentence_encoder import LinformerTransformerEncoder + + +logger = logging.getLogger(__name__) + + +@register_model("linformer_roberta") +class LinformerModel(RobertaModel): + @staticmethod + def add_args(parser): + RobertaModel.add_args(parser) + + # add args for Linformer + parser.add_argument( + "--compressed", type=int, help="compressed ratio of sequence length" + ) + parser.add_argument( + "--shared-kv-compressed", + type=int, + help="share compressed matrix between k and v, in each layer", + ) + parser.add_argument( + "--shared-layer-kv-compressed", + type=int, + help="share compressed matrix between k and v and across all layers", + ) + parser.add_argument( + "--freeze-compress", + type=int, + help="freeze the parameters in compressed layer", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present + base_architecture(args) + + if not safe_hasattr(args, "max_positions"): + args.max_positions = args.tokens_per_sample + + encoder = LinformerEncoder(args, task.source_dictionary) + return cls(args, encoder) + + +class LinformerEncoder(RobertaEncoder): + """Linformer encoder.""" + + def __init__(self, args, dictionary): + super().__init__(args, dictionary) + self.register_buffer("version", torch.tensor(2)) + + def build_encoder(self, args, dictionary, embed_tokens): + encoder = LinformerTransformerEncoder(args, dictionary, embed_tokens) + encoder.apply(init_bert_params) + return encoder + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + prefix = name + "." if name != "" else "" + + # some old checkpoints had weight sharing implemented incorrectly + # (note: this was correct in the original paper code) + if utils.item(state_dict.get(f"{prefix}version", torch.tensor(1))) < 2: + state_dict[f"{prefix}version"] = torch.tensor(1) + # check if input embeddings and output embeddings were tied + if not torch.allclose( + state_dict[f"{prefix}sentence_encoder.embed_tokens.weight"], + state_dict[f"{prefix}lm_head.weight"], + ): + # they weren't tied, re-init the LM head without weight sharing + self.lm_head = self.build_lm_head( + embed_dim=self.args.encoder_embed_dim, + output_dim=len(self.dictionary), + activation_fn=self.args.activation_fn, + weight=None, # don't share weights + ) + + +@register_model_architecture("linformer_roberta", "linformer_roberta") +def base_architecture(args): + args.compressed = getattr(args, "compressed", 4) + args.shared_kv_compressed = getattr(args, "shared_kv_compressed", 0) + args.shared_layer_kv_compressed = getattr(args, "shared_layer_kv_compressed", 0) + args.freeze_compress = getattr(args, "freeze_compress", 0) + roberta_base_architecture(args) + + +@register_model_architecture("linformer_roberta", "linformer_roberta_base") +def linformer_roberta_base_architecture(args): + base_architecture(args) + + +@register_model_architecture("linformer_roberta", "linformer_roberta_large") +def linformer_roberta_large_architecture(args): + roberta_large_architecture(args) + base_architecture(args) diff --git a/fairseq/examples/linformer/linformer_src/modules/__init__.py b/fairseq/examples/linformer/linformer_src/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder.py b/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..44f7989bd863329f763aa62b78df2eb42b3084ea --- /dev/null +++ b/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch.nn as nn +from fairseq.models.transformer import TransformerEncoder + +from .linformer_sentence_encoder_layer import LinformerTransformerEncoderLayer + + +class LinformerTransformerEncoder(TransformerEncoder): + """ + Implementation for a Bi-directional Linformer based Sentence Encoder used + in BERT/XLM style pre-trained models. + + This first computes the token embedding using the token embedding matrix, + position embeddings (if specified) and segment embeddings + (if specified). After applying the specified number of + LinformerEncoderLayers, it outputs all the internal states of the + encoder as well as the final representation associated with the first + token (usually CLS token). + + Input: + - tokens: B x T matrix representing sentences + - segment_labels: B x T matrix representing segment label for tokens + + Output: + - a tuple of the following: + - a list of internal model states used to compute the + predictions where each tensor has shape T x B x C + - sentence representation associated with first input token + in format B x C. + """ + + def __init__(self, args, dictionary, embed_tokens): + self.compress_layer = None + super().__init__(args, dictionary, embed_tokens) + + def build_encoder_layer(self, args): + if self.args.shared_layer_kv_compressed == 1 and self.compress_layer is None: + compress_layer = nn.Linear( + self.args.max_positions, + self.args.max_positions // self.args.compressed, + ) + # intialize parameters for compressed layer + nn.init.xavier_uniform_(compress_layer.weight, gain=1 / math.sqrt(2)) + if self.args.freeze_compress == 1: + compress_layer.weight.requires_grad = False + self.compress_layer = compress_layer + + return LinformerTransformerEncoderLayer(args, self.compress_layer) diff --git a/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder_layer.py b/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..7e2caa03400129ac0bb34ae35274cdf46f27a055 --- /dev/null +++ b/fairseq/examples/linformer/linformer_src/modules/linformer_sentence_encoder_layer.py @@ -0,0 +1,65 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq import utils +from fairseq.modules import TransformerEncoderLayer + +from .multihead_linear_attention import MultiheadLinearAttention + + +class LinformerTransformerEncoderLayer(TransformerEncoderLayer): + """ + Implements a Linformer Encoder Layer used in BERT/XLM style pre-trained + models. + """ + + def __init__(self, args, shared_compress_layer): + # wrap in a list so it's not automatically registered by PyTorch + self.shared_compress_layer = [shared_compress_layer] + + super().__init__(args) + + self.register_buffer("version", torch.tensor(2)) + + def build_self_attention(self, embed_dim, args): + return MultiheadLinearAttention( + embed_dim, + args.encoder_attention_heads, + dropout=args.dropout, + self_attention=True, + q_noise=args.quant_noise_pq, + qn_block_size=args.quant_noise_pq_block_size, + compressed=args.compressed, + max_seq_len=args.max_positions, + shared_kv_compressed=args.shared_kv_compressed, + shared_compress_layer=self.shared_compress_layer[0], + freeze_compress=args.freeze_compress, + ) + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + prefix = name + "." if name != "" else "" + + # some old checkpoints had weight sharing implemented incorrectly + # (note: this was correct in the original paper code) + if utils.item(state_dict.get(f"{prefix}version", torch.tensor(1))) < 2: + state_dict[f"{prefix}version"] = torch.tensor(1) + # check compression layer sharing + if f"{prefix}shared_compress_layer.weight" in state_dict: + # reinitialize block without sharing compression layer to match + # old behavior + self.shared_compress_layer = [ + torch.nn.Linear( + self.shared_compress_layer[0].weight.size(1), + self.shared_compress_layer[0].weight.size(0), + ) + ] + self.self_attn = self.build_self_attention(self.embed_dim, self.args) + # delete shared_compress_layer, since it's already copied to + # self_attn.compress_k.weight + del state_dict[f"{prefix}shared_compress_layer.weight"] + if f"{prefix}shared_compress_layer.bias" in state_dict: + del state_dict[f"{prefix}shared_compress_layer.bias"] diff --git a/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py b/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..6be1007279217c5de644e8b054f5d14a19f06c55 --- /dev/null +++ b/fairseq/examples/linformer/linformer_src/modules/multihead_linear_attention.py @@ -0,0 +1,481 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Dict, Optional, Tuple + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.quant_noise import quant_noise +from torch import Tensor, nn +from torch.nn import Parameter + + +@with_incremental_state +class MultiheadLinearAttention(nn.Module): + """Multi-headed linformer attention. + + Projects the key and values down to the compressed dimension, before computing self-attention. + + See "Linformer: Self-Attention with Linear Complexity" for more details. + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + self_attention=False, + encoder_decoder_attention=False, + q_noise=0.0, + qn_block_size=8, + compressed=1, + max_seq_len=256, + shared_kv_compressed=0, + shared_compress_layer=None, + freeze_compress=0, + ): + super().__init__() + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim + + self.num_heads = num_heads + self.dropout = dropout + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.scaling = self.head_dim ** -0.5 + + self.self_attention = self_attention + self.encoder_decoder_attention = encoder_decoder_attention + + assert not self.self_attention or self.qkv_same_dim, ( + "Self-attention requires query, key and " "value to be of the same size" + ) + + self.k_proj = quant_noise( + nn.Linear(self.kdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.v_proj = quant_noise( + nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.q_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + # used for compress sequence to subsequence + if shared_compress_layer is None: + self.compress_seq_len = max_seq_len // compressed + self.compress_k = nn.Linear(max_seq_len, self.compress_seq_len, bias=False) + if shared_kv_compressed == 0: + self.compress_v = nn.Linear( + max_seq_len, self.compress_seq_len, bias=False + ) + self.layerwise_sharing = False + else: + self.compress_k = shared_compress_layer + if shared_kv_compressed == 0: + self.compress_v = shared_compress_layer + self.layerwise_sharing = True + self.shared_kv_compressed = shared_kv_compressed + + self.out_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + if add_bias_kv: + self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim)) + self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim)) + else: + self.bias_k = self.bias_v = None + + self.add_zero_attn = add_zero_attn + + self.reset_parameters() + + if freeze_compress == 1: + self.compress_k.weight.requires_grad = False + if shared_kv_compressed == 0: + self.compress_v.weight.requires_grad = False + + self.onnx_trace = False + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def reset_parameters(self): + if self.qkv_same_dim: + # Empirically observed the convergence to be much better with + # the scaled initialization + nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2)) + if ( + not self.layerwise_sharing + ): # otherwise, we already initialize the parameters + nn.init.xavier_uniform_(self.compress_k.weight, gain=1 / math.sqrt(2)) + if self.shared_kv_compressed == 0: + nn.init.xavier_uniform_( + self.compress_v.weight, gain=1 / math.sqrt(2) + ) + else: + nn.init.xavier_uniform_(self.k_proj.weight) + nn.init.xavier_uniform_(self.v_proj.weight) + nn.init.xavier_uniform_(self.q_proj.weight) + if ( + not self.layerwise_sharing + ): # otherwise, we already initialize the parameters + nn.init.xavier_uniform_(self.compress_k.weight) + if self.shared_kv_compressed == 0: + nn.init.xavier_uniform_(self.compress_v.weight) + + nn.init.xavier_uniform_(self.out_proj.weight) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.xavier_normal_(self.bias_k) + if self.bias_v is not None: + nn.init.xavier_normal_(self.bias_v) + + def forward( + self, + query, + key: Optional[Tensor], + value: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + need_weights: bool = True, + static_kv: bool = False, + attn_mask: Optional[Tensor] = None, + before_softmax: bool = False, + need_head_weights: bool = False, + ) -> Tuple[Tensor, Optional[Tensor]]: + """Input shape: Time x Batch x Channel + + Args: + key_padding_mask (ByteTensor, optional): mask to exclude + keys that are pads, of shape `(batch, src_len)`, where + padding elements are indicated by 1s. + need_weights (bool, optional): return the attention weights, + averaged over heads (default: False). + attn_mask (ByteTensor, optional): typically used to + implement causal attention, where the mask prevents the + attention from looking forward in time (default: None). + before_softmax (bool, optional): return the raw attention + weights and values before the attention softmax. + need_head_weights (bool, optional): return the attention + weights for each head. Implies *need_weights*. Default: + return the average attention weights over all heads. + """ + if need_head_weights: + need_weights = True + + tgt_len, bsz, embed_dim = query.size() + assert embed_dim == self.embed_dim + assert list(query.size()) == [tgt_len, bsz, embed_dim] + + if incremental_state is not None: + saved_state = self._get_input_buffer(incremental_state) + if saved_state is not None and "prev_key" in saved_state: + # previous time steps are cached - no need to recompute + # key and value if they are static + if static_kv: + assert self.encoder_decoder_attention and not self.self_attention + key = value = None + else: + saved_state = None + + if self.self_attention: + q = self.q_proj(query) + + k_input = query.permute(1, 2, 0).contiguous() # B * C * T + k_input = ( + F.linear(k_input, self.compress_k.weight[:, 0:tgt_len]) + .permute(2, 0, 1) + .contiguous() + ) + k = self.k_proj(k_input) + + v_input = query.permute(1, 2, 0).contiguous() # B * C * T + if self.shared_kv_compressed == 0: + v_input = ( + F.linear(v_input, self.compress_v.weight[:, 0:tgt_len]) + .permute(2, 0, 1) + .contiguous() + ) + if self.shared_kv_compressed == 1: # use shared kv compressed linear layer + v_input = ( + F.linear(v_input, self.compress_k.weight[:, 0:tgt_len]) + .permute(2, 0, 1) + .contiguous() + ) + v = self.v_proj(v_input) + elif self.encoder_decoder_attention: + # encoder-decoder attention + q = self.q_proj(query) + if key is None: + assert value is None + k = v = None + else: + k = self.k_proj(key) + v = self.v_proj(key) + + else: + assert key is not None and value is not None + q = self.q_proj(query) + k = self.k_proj(key) + v = self.v_proj(value) + q *= self.scaling + + if self.bias_k is not None: + assert self.bias_v is not None + k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + if key_padding_mask is not None: + key_padding_mask = torch.cat( + [ + key_padding_mask, + key_padding_mask.new_zeros(key_padding_mask.size(0), 1), + ], + dim=1, + ) + + q = ( + q.contiguous() + .view(tgt_len, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if k is not None: + k = ( + k.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if v is not None: + v = ( + v.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + if saved_state is not None: + # saved states are stored with shape (bsz, num_heads, seq_len, head_dim) + if "prev_key" in saved_state: + _prev_key = saved_state["prev_key"] + assert _prev_key is not None + prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + k = prev_key + else: + assert k is not None + k = torch.cat([prev_key, k], dim=1) + if "prev_value" in saved_state: + _prev_value = saved_state["prev_value"] + assert _prev_value is not None + prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + v = prev_value + else: + assert v is not None + v = torch.cat([prev_value, v], dim=1) + prev_key_padding_mask: Optional[Tensor] = None + if "prev_key_padding_mask" in saved_state: + prev_key_padding_mask = saved_state["prev_key_padding_mask"] + assert k is not None and v is not None + key_padding_mask = MultiheadLinearAttention._append_prev_key_padding_mask( + key_padding_mask=key_padding_mask, + prev_key_padding_mask=prev_key_padding_mask, + batch_size=bsz, + src_len=k.size(1), + static_kv=static_kv, + ) + + saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_key_padding_mask"] = key_padding_mask + # In this branch incremental_state is never None + assert incremental_state is not None + incremental_state = self._set_input_buffer(incremental_state, saved_state) + assert k is not None + src_len = k.size(1) + + if self.add_zero_attn: + assert v is not None + src_len += 1 + k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1) + v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + + attn_weights = torch.bmm(q, k.transpose(1, 2)) + attn_weights = MultiheadLinearAttention.apply_sparse_mask( + attn_weights, tgt_len, src_len, bsz + ) + + assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len] + + if attn_mask is not None: + attn_mask = attn_mask.unsqueeze(0) + if self.onnx_trace: + attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1) + attn_weights += attn_mask + + if before_softmax: + return attn_weights, v + + attn_weights_float = utils.softmax( + attn_weights, dim=-1, onnx_trace=self.onnx_trace + ) + attn_weights = attn_weights_float.type_as(attn_weights) + attn_probs = F.dropout( + attn_weights, + p=self.dropout, + training=self.training, + ) + assert v is not None + attn = torch.bmm(attn_probs, v) + assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim] + if self.onnx_trace and attn.size(1) == 1: + # when ONNX tracing a single decoder step (sequence length == 1) + # the transpose is a no-op copy before view, thus unnecessary + attn = attn.contiguous().view(tgt_len, bsz, embed_dim) + else: + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim) + attn = self.out_proj(attn) + attn_weights: Optional[Tensor] = None + if need_weights: + attn_weights = attn_weights_float.view( + bsz, self.num_heads, tgt_len, src_len + ).transpose(1, 0) + if not need_head_weights: + # average attention weights over heads + attn_weights = attn_weights.mean(dim=0) + + return attn, attn_weights + + @staticmethod + def _append_prev_key_padding_mask( + key_padding_mask: Optional[Tensor], + prev_key_padding_mask: Optional[Tensor], + batch_size: int, + src_len: int, + static_kv: bool, + ) -> Optional[Tensor]: + # saved key padding masks have shape (bsz, seq_len) + if prev_key_padding_mask is not None and static_kv: + new_key_padding_mask = prev_key_padding_mask + elif prev_key_padding_mask is not None and key_padding_mask is not None: + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1 + ) + # During incremental decoding, as the padding token enters and + # leaves the frame, there will be a time when prev or current + # is None + elif prev_key_padding_mask is not None: + filler = torch.zeros( + (batch_size, src_len - prev_key_padding_mask.size(1)), + device=prev_key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), filler.float()], dim=1 + ) + elif key_padding_mask is not None: + filler = torch.zeros( + (batch_size, src_len - key_padding_mask.size(1)), + device=key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [filler.float(), key_padding_mask.float()], dim=1 + ) + else: + new_key_padding_mask = prev_key_padding_mask + return new_key_padding_mask + + @torch.jit.export + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + """Reorder buffered internal state (for incremental generation).""" + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + for k in input_buffer.keys(): + input_buffer_k = input_buffer[k] + if input_buffer_k is not None: + if self.encoder_decoder_attention and input_buffer_k.size( + 0 + ) == new_order.size(0): + break + input_buffer[k] = input_buffer_k.index_select(0, new_order) + incremental_state = self._set_input_buffer(incremental_state, input_buffer) + return incremental_state + + def _get_input_buffer( + self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] + ) -> Dict[str, Optional[Tensor]]: + result = self.get_incremental_state(incremental_state, "attn_state") + if result is not None: + return result + else: + empty_result: Dict[str, Optional[Tensor]] = {} + return empty_result + + def _set_input_buffer( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + buffer: Dict[str, Optional[Tensor]], + ): + return self.set_incremental_state(incremental_state, "attn_state", buffer) + + def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int): + return attn_weights + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + items_to_add = {} + keys_to_remove = [] + for k in state_dict.keys(): + if k.endswith(prefix + "in_proj_weight"): + # in_proj_weight used to be q + k + v with same dimensions + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim] + items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim] + items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :] + + keys_to_remove.append(k) + + k_bias = prefix + "in_proj_bias" + if k_bias in state_dict.keys(): + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim] + items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][ + dim : 2 * dim + ] + items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :] + + keys_to_remove.append(prefix + "in_proj_bias") + + for k in keys_to_remove: + del state_dict[k] + + for key, value in items_to_add.items(): + state_dict[key] = value diff --git a/fairseq/examples/m2m_100/README.md b/fairseq/examples/m2m_100/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02a68a5f0919a26a0468069bed46a5b1abc78941 --- /dev/null +++ b/fairseq/examples/m2m_100/README.md @@ -0,0 +1,241 @@ +# Beyond English-Centric Multilingual Machine Translation + +## Introduction +In this work, we create a true Many-to-Many multilingual translation model that can translate directly between any pair of 100 languages. Our focus on non-English-Centric models brings gains of more than 10 BLEU when directly translating between non-English directions while performing competitively with the best single systems of WMT. + +If you are new to using fairseq, read the following walkthrough. Otherwise, skip to the sections below. + +0. **Generation Data** + +To download the generation data, follow the below commands. Note that all datasets need to be detokenized *before* applying SPM in the data preprocessing step. If you use these evaluation datasets, please cite their associated papers. +```bash +# WMT - use sacrebleu, example here: +sacrebleu -t wmt14 -l fr-en --echo src > wmt.test.fr-en.fr +sacrebleu -t wmt14 -l fr-en --echo ref > wmt.test.fr-en.en + +# WAT +wget http://lotus.kuee.kyoto-u.ac.jp/WAT/my-en-data/wat2020.my-en.zip +unzip wat2020.my-en.zip + +# FLORES +# download from: https://github.com/facebookresearch/flores + +# TED - need to detokenize with Moses! +# from: https://github.com/neulab/word-embeddings-for-nmt +wget http://phontron.com/data/ted_talks.tar.gz + +# Autshumato +# request to download: https://repo.sadilar.org/handle/20.500.12185/397 + +# Tatoeba Challenge +# available here: https://github.com/Helsinki-NLP/Tatoeba-Challenge +``` + +1. **Training Data** + +To produce the training data, we use a combination of [CCMatrix](https://arxiv.org/abs/1911.04944) and [CCAligned](https://arxiv.org/abs/1911.06154). Check out the instructions [here](https://github.com/facebookresearch/LASER/tree/master/tasks/CCMatrix) to download the raw data. + +2. **Preprocess Data** + +After downloading raw data, you will need to postprocess the data, then apply SPM, then binarize. Note that it is very important you run the postprocessing script, because this removes any instance of the evaluation data in the mined training data. + +```bash +# preprocess data + +# remove sentences with more than 50% punctuation +python /path/to/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py + +# deduplicate training data +paste /path/to/datadir/train.$src /path/to/datadir/train.$tgt | awk '!x[$0]++' > /path/to/datadir/train.dedup +echo "keeping $(wc -l /path/to/datadir/train.dedup) bitext out of $(wc -l /path/to/datadir/train.$src)" +cut -f1 /path/to/datadir/train.dedup > /path/to/datadir/train.$src +cut -f2 /path/to/datadir/train.dedup > /path/to/datadir/train.$tgt + +# remove all instances of evaluation data from the training data +python /path/to/fairseq/examples/m2m_100/process_data/dedup_data.py + +# frequency cleaning +wget https://dl.fbaipublicfiles.com/m2m_100/histograms.tar.gz +tar -xvzf histograms.tar.gz +python /path/to/fairseq/examples/m2m_100/process_data/clean_histogram.py --src $src --tgt $tgt --src-file /path/to/source/file --tgt-file /path/to/output/file --src-output-file source_output.$src --tgt-output-file target_output.$tgt --histograms /path/to/histograms + +# apply SPM +wget https://dl.fbaipublicfiles.com/m2m_100/spm.128k.model +python /path/to/fairseq/scripts/spm_encode.py \ + --model spm.128k.model \ + --output_format=piece \ + --inputs=/path/to/input/file/here \ + --outputs=/path/to/output/file/here + +# length ratio cleaning +perl mosesdecoder/scripts/training/clean-corpus-n.perl --ratio 3 /path/to/training/data/train.spm.$src-$tgt $src $tgt /path/to/output/directory/train.spm.$src-$tgt 1 250 + +# binarize data +wget https://dl.fbaipublicfiles.com/m2m_100/data_dict.128k.txt +fairseq-preprocess \ + --source-lang $src --target-lang $tgt \ + --testpref spm.$src.$tgt \ + --thresholdsrc 0 --thresholdtgt 0 \ + --destdir data_bin \ + --srcdict data_dict.128k.txt --tgtdict data_dict.128k.txt +``` + +3. **Training Scripts** + +To reproduce the training of our models, we train with fairseq-py's multilingual translation [task](https://github.com/pytorch/fairseq/tree/main/examples/multilingual). If you are interested in model parallel training, also check out [fairscale](https://github.com/facebookresearch/fairscale). + +4. **Generation** + +To generate from our models, follow the the commands in the generation section below. + + +If you use any of the resources listed here, please cite: +```bibtex +@article{fan2020beyond, + title={Beyond English-Centric Multilingual Machine Translation}, + author={Fan, Angela and Bhosale, Shruti and Schwenk, Holger and Ma, Zhiyi and El-Kishky, Ahmed and Goyal, Siddharth and Baines, Mandeep and Celebi, Onur and Wenzek, Guillaume and Chaudhary, Vishrav and Goyal, Naman and Birch, Tom and Liptchinsky, Vitaliy and Edunov, Sergey and Grave, Edouard and Auli, Michael and Joulin, Armand}, + journal={arXiv preprint}, + year={2020} +} + +@article{schwenk2019ccmatrix, + title={Ccmatrix: Mining billions of high-quality parallel sentences on the web}, + author={Schwenk, Holger and Wenzek, Guillaume and Edunov, Sergey and Grave, Edouard and Joulin, Armand}, + journal={arXiv preprint arXiv:1911.04944}, + year={2019} +} + +@article{el2019massive, + title={A Massive Collection of Cross-Lingual Web-Document Pairs}, + author={El-Kishky, Ahmed and Chaudhary, Vishrav and Guzman, Francisco and Koehn, Philipp}, + journal={arXiv preprint arXiv:1911.06154}, + year={2019} +} +``` + + +## Trained Models + +### 418M and 1.2B Model +We include the last checkpoint for both of these models. + +```bash +wget https://dl.fbaipublicfiles.com/m2m_100/model_dict.128k.txt +wget https://dl.fbaipublicfiles.com/m2m_100/language_pairs_small_models.txt + +# 418M parameter model +wget https://dl.fbaipublicfiles.com/m2m_100/418M_last_checkpoint.pt + +# 1.2B parameter model +wget https://dl.fbaipublicfiles.com/m2m_100/1.2B_last_checkpoint.pt + +# Generation: +fairseq-generate $binarized_data_path --batch-size 32 --path $path_to_model --fixed-dictionary model_dict.128k.txt -s en -t fr --remove-bpe 'sentencepiece' --beam 5 --task translation_multi_simple_epoch --lang-pairs language_pairs_small_models.txt --decoder-langtok --encoder-langtok src --gen-subset test > gen_out +``` + +### 12B Model +12B parameter model trained on many-to-many training data for 100 languages. We include the last checkpoint, average of last 5 checkpoints, average of last 10 checkpoints. There isn't a universally best choice out of these three, but all three versions are pretty close in accuracy. You can either sweep over the 3 checkpoints on a dev test and use the best performing checkpoint for final testing. Or the last checkpoint can be a good default choice. + +**Model Download Links** +Configuration | 2 32GB GPUs | 4 16GB GPUs | 6 12GB GPUs | 8 8GB GPUs +:--|:--|:--|:--|:-- +Last Checkpoint | [12b_last_chk_2_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_last_chk_2_gpus.pt) | [12b_last_chk_4_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_last_chk_4_gpus.pt) | [12b_last_chk_6_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_last_chk_6_gpus.pt) | [12b_last_chk_8_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_last_chk_8_gpus.pt) +Average of last 5 checkpoints | [12b_avg5_chk_2_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg5_chk_2_gpus.pt) | [12b_avg5_chk_4_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg5_chk_4_gpus.pt) | [12b_avg5_chk_6_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg5_chk_6_gpus.pt) | [12b_avg5_chk_8_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg5_chk_8_gpus.pt) +Average of last 10 checkpoints | [12b_avg10_chk_2_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg10_chk_2_gpus.pt) | [12b_avg10_chk_4_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg10_chk_4_gpus.pt) | [12b_avg10_chk_6_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg10_chk_6_gpus.pt) | [12b_avg10_chk_8_gpus.pt](https://dl.fbaipublicfiles.com/m2m_100/12b_avg10_chk_8_gpus.pt) + +**Generation Arguments** +Configuration | 2 32GB GPUs | 4 16GB GPUs | 6 12GB GPUs | 8 8GB GPUs +:--|:--|:--|:--|:-- +`--pipeline-encoder-balance` | `[26]` | `[1,15,10]` | `[1,9,9,7]` | `[1,6,6,6,7]` +`--pipeline-encoder-devices` | `[0]` | `[0,1,0]` | `[0,1,2,0]` | `[0,4,5,1,0]` +`--pipeline-decoder-balance` | `[3,22,1]` | `[3,11,11,1]` | `[3,7,7,8,1]` | `[1,6,6,6,6,1]` +`--pipeline-decoder-devices` | `[0,1,0]` | `[0,2,3,0]` | `[0,3,4,5,0]` | `[0,2,6,7,3,0]` + + +## SentencePiece Model + +```bash +wget https://dl.fbaipublicfiles.com/m2m_100/spm.128k.model +``` + +## Generation with M2M-100 + +### Encode using our SentencePiece Model + +Note: Install SentencePiece from [here](https://github.com/google/sentencepiece) + +```bash +fairseq=/path/to/fairseq +cd $fairseq +sacrebleu --echo src -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.de +sacrebleu --echo ref -l de-fr -t wmt19 | head -n 20 > raw_input.de-fr.fr +wget https://dl.fbaipublicfiles.com/m2m_100/spm.128k.model +for lang in de fr ; do + python scripts/spm_encode.py \ + --model spm.128k.model \ + --output_format=piece \ + --inputs=raw_input.de-fr.${lang} \ + --outputs=spm.de-fr.${lang} +done +``` + +### Binarization + +```bash +wget https://dl.fbaipublicfiles.com/m2m_100/data_dict.128k.txt +fairseq-preprocess \ + --source-lang de --target-lang fr \ + --testpref spm.de-fr \ + --thresholdsrc 0 --thresholdtgt 0 \ + --destdir data_bin \ + --srcdict data_dict.128k.txt --tgtdict data_dict.128k.txt +``` + +### Generation for the 12B model + +Note that generation can currently be run using 2 32GB / 4 16GB / 6 12GB / 8 8GB GPUs, and the corresponding model checkpoints and pipeline arguments can be found in the [12B Model Section](#12b-model). +Generation on CPUs will be added in the future. + +```bash +wget https://dl.fbaipublicfiles.com/m2m_100/model_dict.128k.txt +wget https://dl.fbaipublicfiles.com/m2m_100/language_pairs.txt +wget https://dl.fbaipublicfiles.com/m2m_100/12b_last_chk_4_gpus.pt +fairseq-generate \ + data_bin \ + --batch-size 1 \ + --path 12b_last_chk_4_gpus.pt \ + --fixed-dictionary model_dict.128k.txt \ + -s de -t fr \ + --remove-bpe 'sentencepiece' \ + --beam 5 \ + --task translation_multi_simple_epoch \ + --lang-pairs language_pairs.txt \ + --decoder-langtok --encoder-langtok src \ + --gen-subset test \ + --fp16 \ + --dataset-impl mmap \ + --distributed-world-size 1 --distributed-no-spawn \ + --pipeline-model-parallel \ + --pipeline-chunks 1 \ + --pipeline-encoder-balance '[1,15,10]' \ + --pipeline-encoder-devices '[0,1,0]' \ + --pipeline-decoder-balance '[3,11,11,1]' \ + --pipeline-decoder-devices '[0,2,3,0]' > gen_out +``` +## Evaluation with M2M-100 + +### Tokenization + +Note: Refer to tokenizers/README.md for more details on tokenization. + +```bash +cd ${fairseq}/examples/m2m_100 +cat ${fairseq}/gen_out | grep -P "^H" | sort -V | cut -f 3- | sh tok.sh fr > hyp +cat ${fairseq}/raw_input.de-fr.fr | sh tok.sh fr > ref +``` + +### BLEU + +```bash +sacrebleu -tok 'none' ref < hyp +``` diff --git a/fairseq/examples/m2m_100/install_dependecies.sh b/fairseq/examples/m2m_100/install_dependecies.sh new file mode 100755 index 0000000000000000000000000000000000000000..82a1054745264a56fbec4a8eb593884f8a42bd08 --- /dev/null +++ b/fairseq/examples/m2m_100/install_dependecies.sh @@ -0,0 +1,78 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +CWD=`pwd` +INSTALL_PATH=$CWD/tokenizers/thirdparty + +MOSES=$INSTALL_PATH/mosesdecoder +if [ ! -d $MOSES ]; then + echo 'Cloning Moses github repository (for tokenization scripts)...' + git clone https://github.com/moses-smt/mosesdecoder.git $MOSES + cd $MOSES + # To deal with differences in handling ' vs " + git checkout 03578921cc1a03402 + cd - +fi + +WMT16_SCRIPTS=$INSTALL_PATH/wmt16-scripts +if [ ! -d $WMT16_SCRIPTS ]; then + echo 'Cloning Romanian tokenization scripts' + git clone https://github.com/rsennrich/wmt16-scripts.git $WMT16_SCRIPTS +fi + +KYTEA=$INSTALL_PATH/kytea +if [ ! -f $KYTEA/bin/kytea ]; then + git clone https://github.com/neubig/kytea.git $KYTEA + cd $KYTEA + autoreconf -i + ./configure --prefix=`pwd` + make + make install + cd .. +fi + +export MECAB=$INSTALL_PATH/mecab-0.996-ko-0.9.2 +if [ ! -f $MECAB/bin/mecab ]; then + cd $INSTALL_PATH + curl -LO https://bitbucket.org/eunjeon/mecab-ko/downloads/mecab-0.996-ko-0.9.2.tar.gz + tar zxfv mecab-0.996-ko-0.9.2.tar.gz + cd mecab-0.996-ko-0.9.2/ + ./configure --prefix=`pwd` + make + make install + + cd .. + curl -LO https://bitbucket.org/eunjeon/mecab-ko-dic/downloads/mecab-ko-dic-2.1.1-20180720.tar.gz + tar zxfv mecab-ko-dic-2.1.1-20180720.tar.gz + cd mecab-ko-dic-2.1.1-20180720/ + ./autogen.sh + ./configure --prefix=`pwd` --with-dicdir=$MECAB/lib/mecab/dic/mecab-ko-dic --with-mecab-config=$MECAB/bin/mecab-config + make + sh -c 'echo "dicdir=$MECAB/lib/mecab/dic/mecab-ko-dic" > $MECAB/etc/mecabrc' + make install + cd $CWD +fi + +INDIC_RESOURCES_PATH=$INSTALL_PATH/indic_nlp_resources +if [ ! -d $INDIC_RESOURCES_PATH ]; then + echo 'Cloning indic_nlp_resources' + git clone https://github.com/anoopkunchukuttan/indic_nlp_resources.git $INDIC_RESOURCES_PATH +fi + + +if [ ! -f $INSTALL_PATH/seg_my.py ]; then + cd $INSTALL_PATH + wget http://lotus.kuee.kyoto-u.ac.jp/WAT/my-en-data/wat2020.my-en.zip + unzip wat2020.my-en.zip + # switch to python3 + cat wat2020.my-en/myseg.py |sed 's/^sys.std/###sys.std/g' | sed 's/### sys/sys/g' | sed 's/unichr/chr/g' > seg_my.py + cd $CWD +fi + + +pip install pythainlp sacrebleu indic-nlp-library + diff --git a/fairseq/examples/m2m_100/process_data/clean_histogram.py b/fairseq/examples/m2m_100/process_data/clean_histogram.py new file mode 100644 index 0000000000000000000000000000000000000000..e24e073dc0eb43c76e2ce717f52bb848c5b026b8 --- /dev/null +++ b/fairseq/examples/m2m_100/process_data/clean_histogram.py @@ -0,0 +1,52 @@ +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument('--src', type=str, help='Source language') +parser.add_argument('--tgt', type=str, help='Target language') +parser.add_argument('--src-file', type=str, help='Input source file') +parser.add_argument('--tgt-file', type=str, help='Input target file') +parser.add_argument('--src-output-file', type=str, help='Output source file') +parser.add_argument('--tgt-output-file', type=str, help='Output target file') +parser.add_argument('--threshold', type=float, default=0.5, help='Threshold') +parser.add_argument('--threshold-character', type=str, default=']', help='Threshold character') +parser.add_argument('--histograms', type=str, help='Path to histograms') + +args = parser.parse_args() + + +def read_hist(f): + ch = [] + for line in f: + c = line[0] + if c == args.threshold_character: + break + ch.append(c) + return ch + + +with(open("{}/{}".format(args.histograms, args.src), 'r', encoding='utf8')) as f: + ch1 = read_hist(f) + +with(open("{}/{}".format(args.histograms, args.tgt), 'r', encoding='utf8')) as f: + ch2 = read_hist(f) + +print("Accepted characters for {}: {}".format(args.src, ch1)) +print("Accepted characters for {}: {}".format(args.tgt, ch2)) + +with open(args.src_file, 'r', encoding='utf8') as fs1, open(args.tgt_file, 'r', encoding='utf8') as fs2, open(args.src_output_file, 'w', encoding='utf8') as fos1, open(args.tgt_output_file, 'w', encoding='utf8') as fos2: + ls1 = fs1.readline() + ls2 = fs2.readline() + + while ls1 or ls2: + cnt1 = len([c for c in ls1.strip() if c in ch1]) + cnt2 = len([c for c in ls2.strip() if c in ch2]) + + if cnt1 / len(ls1) > args.threshold and cnt2 / len(ls2) > args.threshold: + fos1.write(ls1) + fos2.write(ls2) + else: + print("{} {} {} \n{} {} {}".format(args.src, cnt1 / len(ls1), ls1.strip(), args.tgt, cnt2 / len(ls2), ls2.strip())) + + ls1 = fs1.readline() + ls2 = fs2.readline() + \ No newline at end of file diff --git a/fairseq/examples/m2m_100/process_data/dedup_data.py b/fairseq/examples/m2m_100/process_data/dedup_data.py new file mode 100644 index 0000000000000000000000000000000000000000..58d9ed1cd17b3ba70772a6d9adab709785495fd9 --- /dev/null +++ b/fairseq/examples/m2m_100/process_data/dedup_data.py @@ -0,0 +1,91 @@ +import argparse +from collections import namedtuple +import os + +DATADIR = "/path/to/train_data" +DEDUP_FROM_DIR = "/path/to/eval/data" +OUTPUT_DIR = "/path/to/output/data" + + +def main(args): + languages = set() + for language_directory in os.listdir(DATADIR): + if "_" in language_directory: + src, tgt = language_directory.split("_") + languages.add(LanguagePair(src=src, tgt=tgt)) + + data = existing_data() + train_languages = sorted(languages) + for language_pair in train_languages[args.start_index:args.start_index + args.size]: + print(language_pair) + dedup(language_pair, data) + + +LanguagePair = namedtuple("LanguagePair", ["src", "tgt"]) + + +def existing_data(): + data = set() + for file in os.listdir(DEDUP_FROM_DIR): + with open(os.path.join(DEDUP_FROM_DIR, file)) as f: + data |= set(f.readlines()) + return data + +def dedup(language_pair, data, verbose=True, output=True): + train_filenames = LanguagePair( + src=f"{DATADIR}/{language_pair.src}_{language_pair.tgt}/train.{language_pair.src}", + tgt=f"{DATADIR}/{language_pair.src}_{language_pair.tgt}/train.{language_pair.tgt}", + ) + + output_filenames = LanguagePair( + src=f"{OUTPUT_DIR}/train.dedup.{language_pair.src}-{language_pair.tgt}.{language_pair.src}", + tgt=f"{OUTPUT_DIR}/train.dedup.{language_pair.src}-{language_pair.tgt}.{language_pair.tgt}" + ) + + # If output exists, skip this pair. It has already been done. + if (os.path.exists(output_filenames.src) and + os.path.exists(output_filenames.tgt)): + if verbose: + print(f"{language_pair.src}-{language_pair.tgt} already done.") + return + + if verbose: + print(f"{language_pair.src}-{language_pair.tgt} ready, will check dups.") + + # If there is no output, no need to actually do the loop. + if not output: + return + + if os.path.exists(train_filenames.src) and os.path.exists(train_filenames.tgt): + with open(train_filenames.src) as f: + train_source = f.readlines() + + with open(train_filenames.tgt) as f: + train_target = f.readlines() + + # do dedup + new_train_source = [] + new_train_target = [] + for i, train_line in enumerate(train_source): + if train_line not in data and train_target[i] not in data: + new_train_source.append(train_line) + new_train_target.append(train_target[i]) + + assert len(train_source) == len(train_target) + assert len(new_train_source) == len(new_train_target) + assert len(new_train_source) <= len(train_source) + + with open(output_filenames.src, "w") as o: + for line in new_train_source: + o.write(line) + + with open(output_filenames.tgt, "w") as o: + for line in new_train_target: + o.write(line) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("-s", "--start-index", required=True, type=int) + parser.add_argument("-n", "--size", required=True, type=int) + main(parser.parse_args()) diff --git a/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py b/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py new file mode 100644 index 0000000000000000000000000000000000000000..6c280de2403daffab477ac88e2008a68b9e61ff0 --- /dev/null +++ b/fairseq/examples/m2m_100/process_data/remove_too_much_punc.py @@ -0,0 +1,36 @@ +import gzip +import argparse +from string import punctuation + +def len_no_punc(s, punc): + return len([ch for ch in s if ch in punc]) + +def filter_overpunc(len_npunc, len_sen): + return len_npunc < 0.5*len_sen + +def main(args): + punc = punctuation + "—|–" + print('Processing file {}'.format(args.input)) + with gzip.open(args.input, 'rt', encoding=args.encoding) as tsv: + with open(args.bitext + '.' + args.src_lang, 'wt', encoding=args.encoding) as fsrc: + with open(args.bitext + '.' + args.tgt_lang, 'wt', encoding=args.encoding) as ftgt: + line = tsv.readline() + fields = line.split('\t') + + src, tgt = fields[1], fields[2] + + nchar_npunc_src = len_no_punc(src, punc) + nchar_npunc_tgt = len_no_punc(tgt, punc) + + if filter_overpunc(nchar_npunc_src, len(src)) and filter_overpunc(nchar_npunc_tgt, len(tgt)): + fsrc.write(src.strip() + '\n') + ftgt.write(tgt.strip() + '\n') + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("--input", required=True, type=str) + parser.add_argument('--encoding', default='utf-8', help='character encoding for input/output') + parser.add_argument('--bitext', type=str, required=True, help='language direction') + parser.add_argument('--src-lang', type=str, required=True, help='Source language') + parser.add_argument('--tgt-lang', type=str, required=True, help='Target language') + main(parser.parse_args()) diff --git a/fairseq/examples/m2m_100/tok.sh b/fairseq/examples/m2m_100/tok.sh new file mode 100755 index 0000000000000000000000000000000000000000..ba2ec5a2f3f4794d2e528d3a6574bf05abe1d043 --- /dev/null +++ b/fairseq/examples/m2m_100/tok.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +# Copyright (c) 2019-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +set -e + +TOKENIZERS_SCRIPTS=tokenizers +INSTALL_PATH=$TOKENIZERS_SCRIPTS/thirdparty + +N_THREADS=8 + +lg=$1 + +MOSES=$INSTALL_PATH/mosesdecoder +REPLACE_UNICODE_PUNCT=$MOSES/scripts/tokenizer/replace-unicode-punctuation.perl +NORM_PUNC=$MOSES/scripts/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$MOSES/scripts/tokenizer/remove-non-printing-char.perl +TOKENIZER=$MOSES/scripts/tokenizer/tokenizer.perl + +# special tokenization for Romanian +WMT16_SCRIPTS=$INSTALL_PATH/wmt16-scripts + +NORMALIZE_ROMANIAN=$WMT16_SCRIPTS/preprocess/normalise-romanian.py +REMOVE_DIACRITICS=$WMT16_SCRIPTS/preprocess/remove-diacritics.py + +# Burmese +MY_SEGMENT=$INSTALL_PATH/seg_my.py + +# Arabic +AR_TOKENIZER=$TOKENIZERS_SCRIPTS/tokenizer_ar.sh + +# Korean +KO_SEGMENT=$TOKENIZERS_SCRIPTS/seg_ko.sh + +# Japanese +JA_SEGMENT=$TOKENIZERS_SCRIPTS/seg_ja.sh + +# Indic +IN_TOKENIZER=$TOKENIZERS_SCRIPTS/tokenize_indic.py +INDIC_RESOURCES_PATH=$INSTALL_PATH/indic_nlp_resources + +# Thai +THAI_TOKENIZER=$TOKENIZERS_SCRIPTS/tokenize_thai.py + +# Chinese +CHINESE_TOKENIZER=$TOKENIZERS_SCRIPTS/tokenize_zh.py + +# Chinese +if [ "$lg" = "zh" ]; then + cat - | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l $lg | $REM_NON_PRINT_CHAR | python $CHINESE_TOKENIZER +# Thai +elif [ "$lg" = "th" ]; then + cat - | python $THAI_TOKENIZER +# Japanese +elif [ "$lg" = "ja" ]; then + cat - | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l $lg | $REM_NON_PRINT_CHAR | ${JA_SEGMENT} +# Korean +elif [ "$lg" = "ko" ]; then + cat - | $REM_NON_PRINT_CHAR | ${KO_SEGMENT} +# Romanian +elif [ "$lg" = "ro" ]; then + cat - | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l $lg | $REM_NON_PRINT_CHAR | $NORMALIZE_ROMANIAN | $REMOVE_DIACRITICS | $TOKENIZER -no-escape -threads $N_THREADS -l $lg +# Burmese +elif [ "$lg" = "my" ]; then + cat - | python ${MY_SEGMENT} +# Arabic +elif [ "$lg" = "ar" ]; then + cat - | ${AR_TOKENIZER} +# Indic +elif [ "$lg" = "ne" ]; then + cat - | python ${IN_TOKENIZER} $lg +elif [ "$lg" = "si" ]; then + cat - | python ${IN_TOKENIZER} $lg +elif [ "$lg" = "hi" ]; then + cat - | python ${IN_TOKENIZER} $lg +# other languages +else + cat - | $REPLACE_UNICODE_PUNCT | $NORM_PUNC -l $lg | $REM_NON_PRINT_CHAR | $TOKENIZER -no-escape -threads $N_THREADS -l $lg +fi diff --git a/fairseq/examples/m2m_100/tokenizers/README.md b/fairseq/examples/m2m_100/tokenizers/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e116932bc80572f221cff6472a7b1eea7032925d --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/README.md @@ -0,0 +1,18 @@ +# M2M-100 Tokenization + +We apply different tokenization strategies for different languages following the existing literature. Here we provide tok.sh a tokenizer that can be used to reproduce our results. + +To reproduce the results, follow these steps: + +``` +tgt_lang=... +reference_translation=... +cat generation_output | grep -P "^H" | sort -V | cut -f 3- | sh tok.sh $tgt_lang > hyp +cat $reference_translation |sh tok.sh $tgt_lang > ref +sacrebleu -tok 'none' ref < hyp +``` + +## Installation + +Tools needed for all the languages except Arabic can be installed by running install_dependencies.sh +If you want to evaluate Arabic models, please follow the instructions provided here: http://alt.qcri.org/tools/arabic-normalizer/ to install diff --git a/fairseq/examples/m2m_100/tokenizers/seg_ja.sh b/fairseq/examples/m2m_100/tokenizers/seg_ja.sh new file mode 100755 index 0000000000000000000000000000000000000000..be6f5ca5fe4ac8e8c786a439caaed1d1314f1aef --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/seg_ja.sh @@ -0,0 +1,11 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +SCRIPT=`realpath $0` +KYTEA=`dirname $SCRIPT`/thirdparty/kytea +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$KYTEA/lib:/usr/local/lib +export PATH=$PATH:"$KYTEA/bin" + +cat - | tr -d "[:blank:]" | kytea -notags diff --git a/fairseq/examples/m2m_100/tokenizers/seg_ko.sh b/fairseq/examples/m2m_100/tokenizers/seg_ko.sh new file mode 100755 index 0000000000000000000000000000000000000000..c523d92634d9b61b97bbcdbfd17dfc33465bfc09 --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/seg_ko.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +SCRIPT=`realpath $0` +MECAB=`dirname $SCRIPT`/thirdparty/mecab-0.996-ko-0.9.2 + +export PATH=$PATH:"$MECAB/bin":"$MECAB/lib" +export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:"$MECAB/lib" + +cat - | mecab -O wakati diff --git a/fairseq/examples/m2m_100/tokenizers/thirdparty/.gitignore b/fairseq/examples/m2m_100/tokenizers/thirdparty/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..19eb6a9dd705ac583f22ecb60d9b744987e27ff1 --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/thirdparty/.gitignore @@ -0,0 +1,12 @@ +seg_my.py +indic_nlp_library/ +indic_nlp_resources/ +kytea/ +mecab-0.996-ko-0.9.2.tar.gz +mecab-0.996-ko-0.9.2/ +mosesdecoder/ +wat2020.my-en.zip +wat2020.my-en/ +wmt16-scripts/ +mecab-ko-dic-2.1.1-20180720/ +mecab-ko-dic-2.1.1-20180720.tar.gz \ No newline at end of file diff --git a/fairseq/examples/m2m_100/tokenizers/tokenize_indic.py b/fairseq/examples/m2m_100/tokenizers/tokenize_indic.py new file mode 100644 index 0000000000000000000000000000000000000000..a44fad07f7c718f99cccd445f33c62b0e3c562f4 --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/tokenize_indic.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# Use: echo {text} | python tokenize_indic.py {language} + +import sys + +from indicnlp.normalize.indic_normalize import IndicNormalizerFactory +from indicnlp.tokenize.indic_tokenize import trivial_tokenize + + +factory = IndicNormalizerFactory() +normalizer = factory.get_normalizer( + sys.argv[1], remove_nuktas=False, nasals_mode="do_nothing" +) + +for line in sys.stdin: + normalized_line = normalizer.normalize(line.strip()) + tokenized_line = " ".join(trivial_tokenize(normalized_line, sys.argv[1])) + print(tokenized_line) diff --git a/fairseq/examples/m2m_100/tokenizers/tokenize_thai.py b/fairseq/examples/m2m_100/tokenizers/tokenize_thai.py new file mode 100644 index 0000000000000000000000000000000000000000..9c72cb89056f6fc92a8963415e5f3a1e61b33a5b --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/tokenize_thai.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + +from pythainlp import word_tokenize + + +for line in sys.stdin: + print(" ".join(word_tokenize(line.strip()))) diff --git a/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py b/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py new file mode 100644 index 0000000000000000000000000000000000000000..674b5849cba829cf4f07a69369e9cc6eed376d4c --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/tokenize_zh.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import fileinput + +import sacrebleu + + +for line in fileinput.input(): + print(sacrebleu.tokenize_zh(line)) diff --git a/fairseq/examples/m2m_100/tokenizers/tokenizer_ar.sh b/fairseq/examples/m2m_100/tokenizers/tokenizer_ar.sh new file mode 100755 index 0000000000000000000000000000000000000000..ad35d7adf28dc9b23d13a6a3fec0b12cb760e855 --- /dev/null +++ b/fairseq/examples/m2m_100/tokenizers/tokenizer_ar.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env sh +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +# +# Please follow the instructions here http://alt.qcri.org/tools/arabic-normalizer/ +# to install tools needed for Arabic + +echo "Please install Arabic tools: http://alt.qcri.org/tools/arabic-normalizer/" +echo "Then update environment variables in tokenizer_ar.sh" +exit 1 + +SVMTOOL=... +GOMOSESGO=... +QCRI_ARABIC_NORMALIZER=... + +export PERL5LIB="$SVMTOOL/lib":"$GOMOSESGO/bin/MADA-3.2":$PERL5LIB + + +tempfile=$(mktemp) +cat - > $tempfile + +cd $QCRI_ARABIC_NORMALIZER + +bash qcri_normalizer_mada3.2_aramorph1.2.1.sh $tempfile +cat $tempfile.mada_norm-aramorph.europarl_tok diff --git a/fairseq/examples/mbart/README.md b/fairseq/examples/mbart/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a45e37243c2c5d4027f79cf71498ca58bbac7d98 --- /dev/null +++ b/fairseq/examples/mbart/README.md @@ -0,0 +1,123 @@ +# MBART: Multilingual Denoising Pre-training for Neural Machine Translation +[https://arxiv.org/abs/2001.08210] + +## Introduction + +MBART is a sequence-to-sequence denoising auto-encoder pre-trained on large-scale monolingual corpora in many languages using the BART objective. mBART is one of the first methods for pre-training a complete sequence-to-sequence model by denoising full texts in multiple languages, while previous approaches have focused only on the encoder, decoder, or reconstructing parts of the text. + +## Pre-trained models + +Model | Description | # params | Download +---|---|---|--- +`mbart.CC25` | mBART model with 12 encoder and decoder layers trained on 25 languages' monolingual corpus | 610M | [mbart.CC25.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/mbart/mbart.cc25.v2.tar.gz) +`mbart.ft.ro_en` | finetune mBART cc25 model on ro-en language pairs | 610M | [mbart.cc25.ft.enro.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/mbart/mbart.cc25.ft.enro.tar.gz) + +## Results + +**[WMT16 EN-RO](https://www.statmt.org/wmt16/translation-task.html)** + +_(test set, no additional data used)_ + +Model | en-ro | ro-en +---|---|--- +`Random` | 34.3 | 34.0 +`mbart.cc25` | 37.7 | 37.8 +`mbart.enro.bilingual` | 38.5 | 38.5 + +## BPE data +# download model +wget https://dl.fbaipublicfiles.com/fairseq/models/mbart/mbart.cc25.v2.tar.gz +tar -xzvf mbart.CC25.tar.gz +# bpe data +install SPM [here](https://github.com/google/sentencepiece) +```bash +SPM=/path/to/sentencepiece/build/src/spm_encode +MODEL=sentence.bpe.model +${SPM} --model=${MODEL} < ${DATA}/${TRAIN}.${SRC} > ${DATA}/${TRAIN}.spm.${SRC} & +${SPM} --model=${MODEL} < ${DATA}/${TRAIN}.${TGT} > ${DATA}/${TRAIN}.spm.${TGT} & +${SPM} --model=${MODEL} < ${DATA}/${VALID}.${SRC} > ${DATA}/${VALID}.spm.${SRC} & +${SPM} --model=${MODEL} < ${DATA}/${VALID}.${TGT} > ${DATA}/${VALID}.spm.${TGT} & +${SPM} --model=${MODEL} < ${DATA}/${TEST}.${SRC} > ${DATA}/${TEST}.spm.${SRC} & +${SPM} --model=${MODEL} < ${DATA}/${TEST}.${TGT} > ${DATA}/${TEST}.spm.${TGT} & +``` + +## Preprocess data + +```bash +DICT=dict.txt +fairseq-preprocess \ + --source-lang ${SRC} \ + --target-lang ${TGT} \ + --trainpref ${DATA}/${TRAIN}.spm \ + --validpref ${DATA}/${VALID}.spm \ + --testpref ${DATA}/${TEST}.spm \ + --destdir ${DEST}/${NAME} \ + --thresholdtgt 0 \ + --thresholdsrc 0 \ + --srcdict ${DICT} \ + --tgtdict ${DICT} \ + --workers 70 +``` + +## Finetune on EN-RO +Finetune on mbart CC25 + +```bash +PRETRAIN=mbart.cc25 # fix if you moved the downloaded checkpoint +langs=ar_AR,cs_CZ,de_DE,en_XX,es_XX,et_EE,fi_FI,fr_XX,gu_IN,hi_IN,it_IT,ja_XX,kk_KZ,ko_KR,lt_LT,lv_LV,my_MM,ne_NP,nl_XX,ro_RO,ru_RU,si_LK,tr_TR,vi_VN,zh_CN + +fairseq-train path_2_data \ + --encoder-normalize-before --decoder-normalize-before \ + --arch mbart_large --layernorm-embedding \ + --task translation_from_pretrained_bart \ + --source-lang en_XX --target-lang ro_RO \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.2 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler polynomial_decay --lr 3e-05 --warmup-updates 2500 --total-num-update 40000 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 1024 --update-freq 2 \ + --save-interval 1 --save-interval-updates 5000 --keep-interval-updates 10 --no-epoch-checkpoints \ + --seed 222 --log-format simple --log-interval 2 \ + --restore-file $PRETRAIN \ + --reset-optimizer --reset-meters --reset-dataloader --reset-lr-scheduler \ + --langs $langs \ + --ddp-backend legacy_ddp +``` +## Generate on EN-RO +Get sacrebleu on finetuned en-ro model + +get tokenizer [here](https://github.com/rsennrich/wmt16-scripts) +```bash +wget https://dl.fbaipublicfiles.com/fairseq/models/mbart/mbart.cc25.ft.enro.tar.gz +tar -xzvf mbart.cc25.ft.enro.tar.gz +``` + +```bash +model_dir=MBART_finetuned_enro # fix if you moved the checkpoint + +fairseq-generate path_2_data \ + --path $model_dir/model.pt \ + --task translation_from_pretrained_bart \ + --gen-subset test \ + -t ro_RO -s en_XX \ + --bpe 'sentencepiece' --sentencepiece-model $model_dir/sentence.bpe.model \ + --sacrebleu --remove-bpe 'sentencepiece' \ + --batch-size 32 --langs $langs > en_ro + +cat en_ro | grep -P "^H" |sort -V |cut -f 3- | sed 's/\[ro_RO\]//g' |$TOKENIZER ro > en_ro.hyp +cat en_ro | grep -P "^T" |sort -V |cut -f 2- | sed 's/\[ro_RO\]//g' |$TOKENIZER ro > en_ro.ref +sacrebleu -tok 'none' -s 'none' en_ro.ref < en_ro.hyp +``` + +## Citation + +```bibtex +@article{liu2020multilingual, + title={Multilingual Denoising Pre-training for Neural Machine Translation}, + author={Yinhan Liu and Jiatao Gu and Naman Goyal and Xian Li and Sergey Edunov and Marjan Ghazvininejad and Mike Lewis and Luke Zettlemoyer}, + year={2020}, + eprint={2001.08210}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` diff --git a/fairseq/examples/megatron_11b/README.md b/fairseq/examples/megatron_11b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..945c96c91e2e2d93466abc28d90bc25a1e7dd471 --- /dev/null +++ b/fairseq/examples/megatron_11b/README.md @@ -0,0 +1,161 @@ +# Megatron-11b + +Megatron-11b is a unidirectional language model with `11B` parameters based on [Megatron-LM](https://arxiv.org/pdf/1909.08053.pdf). Following the original Megatron work, we trained the model using intra-layer model parallelism with each layer's parameters split across 8 GPUs. + +Megatron-11b is trained on the same data and uses the same byte-pair encoding (BPE) as [RoBERTa](https://arxiv.org/pdf/1907.11692.pdf). + +## Pre-trained models + +Model | Description | # params | # filesize | Download +---|---|---|---|--- +`megatron_11b` | megatron_11b unidirectional language model | 11B | 19Gb | [megatron_11b.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/model_parallel/megatron_11b.tar.gz) + +#### Architecture: + +Param | Value +---|--- +embed_dim | 3072 +ffn_dim | 3072 * 6 +layers | 72 +attention heads | 32 + +#### Training details: + +Param | value +---|--- +bsz | 512 +num_updates | 300,000 +peak_lr | 1.5e-04 +lr scheduler | inverse_sqrt +clip norm | 0.0 + + +## Example training command (model parallel) + +Megatron-11b contains too many parameters to train on a single GPU. Following +the original Megatron work, we adopt an intra-layer model parallel training +approach in which each layer's parameters are split across multiple GPUs and +activations and gradients are communicated during the forward/backward pass, +respectively. We similarly split the loss computation using the +`vocab_parallel_cross_entropy` criterion. + +The following training command illustrates how to do model parallel training in +fairseq. We assume that each machine (node) has 8 GPUs among which to split the +model parameters (`--model-parallel-size 8`). If you have access to multiple +nodes, you may combine this with data parallel training by increasing +`--distributed-world-size`. + +To train Megatron-11b on a single node: + + +```bash +fairseq-train \ + --distributed-world-size 8 \ + --memory-efficient-fp16 \ + --num-workers 2 \ + --model-parallel-size 8 \ + --criterion vocab_parallel_cross_entropy \ + --task language_modeling \ + --sample-break-mode none \ + --tokens-per-sample 1024 \ + --arch transformer_lm_megatron_11b \ + --share-decoder-input-output-embed \ + --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-08 --clip-norm 0.0 \ + --lr-scheduler inverse_sqrt --lr 0.00015 \ + --warmup-updates 3000 --weight-decay 0.01 \ + --dropout 0.1 --attention-dropout 0.1 \ + --batch-size 2 \ + --max-update 300000; +``` + +Note: Above was tested on `DGX-1` box, with `8xV100-32Gb` GPUs. + +## Results + +**[Wikitext103](https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset/)** + +Model | Valid perplexity | Test perplexity +---|---|--- +`megatron_11b` | 10.64 | 10.54 + + +## Evaluating `megatron_11b` on Wikitext-103 + +#### 1. Downloading Megatron-11b +```bash +# WARNING: this file is 19GB +wget https://dl.fbaipublicfiles.com/fairseq/models/model_parallel/megatron_11b.tar.gz +tar -xzvf megatron_11b.tar.gz +``` + +#### 2. Download Wikitext-103 +```bash +wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip +unzip wikitext-103-raw-v1.zip +``` + +#### 3. Detokenize test tokens +Megatron-11b uses a byte-level BPE that expects raw (untokenized) input. Since +the wikitext-103 dataset comes tokenized, we apply a simple detokenization +process to restore the untokenized test set: + +```bash +python -m examples.megatron_11b.detok wikitext-103-raw/wiki.test.raw > wikitext-103-raw/wiki.test.detok +``` + +#### 4. BPE encoding +```bash +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe' + +python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json encoder.json \ + --vocab-bpe vocab.bpe \ + --inputs "wikitext-103-raw/wiki.test.detok" \ + --outputs "wikitext-103-raw/wiki.test.bpe" \ + --workers 60; +``` + +#### 5. Fairseq binarize +```bash +fairseq-preprocess \ + --only-source \ + --testpref wikitext-103-raw/wiki.test.bpe \ + --srcdict megatron_11b/dict.txt \ + --destdir wikitext103-bin; +``` + +#### 6. Evaluating perplexity. +We can now evaluate perplexity on the test set. Note that because we've modified +the test set (via detokenization and BPE), the perplexity reported by +`fairseq-eval-lm` needs to be renormalized. + +Compute unnormalized perplexity: + +```bash +DATA_PATH=wikitext103-bin/ +fairseq-eval-lm \ + $DATA_PATH \ + --path megatron_11b/model.pt \ + --task language_modeling \ + --gen-subset test \ + --batch-size 8 \ + --criterion cross_entropy \ + --context-window 992 \ + --distributed-world-size 8 \ + --model-parallel-size 8; +# Expected PPL (unnormalized_ppl): [8.46] +# Note: the eval command needs to run on 8 GPUs for the released model +``` +Renormalizing formula: `2 ^ ( log_2(unnormalized_PPL) * (270847 / 245566))`. +PPL After normalization: `10.54` + +To renormalize the perplexity, we must account for the change in token count +after detokenizing and appling BPE. The formula for this is: +`2 ^ ( log_2(unnormalized_PPL) * (new_token_cnt / orig_token_cnt))` + +For the wikitext-103 test set, the original token count is `245566` and the +token count after detokenization and applying BPE is `270847`. + +The perplexity after renormalization is: +`2 ^ ( log_2(8.46) * (270847 / 245566)) = 10.54` diff --git a/fairseq/examples/megatron_11b/detok.py b/fairseq/examples/megatron_11b/detok.py new file mode 100644 index 0000000000000000000000000000000000000000..49921b28a1f35c6216b5ed85729453524e7a049d --- /dev/null +++ b/fairseq/examples/megatron_11b/detok.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import fileinput + +import sacremoses + + +def main(): + parser = argparse.ArgumentParser(description="") + parser.add_argument("files", nargs="*", help="input files") + args = parser.parse_args() + + detok = sacremoses.MosesDetokenizer() + + for line in fileinput.input(args.files, openhook=fileinput.hook_compressed): + print( + detok.detokenize(line.strip().split(" ")) + .replace(" @", "") + .replace("@ ", "") + .replace(" =", "=") + .replace("= ", "=") + .replace(" – ", "–") + ) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/ML50_langs.txt b/fairseq/examples/multilingual/ML50_langs.txt new file mode 100644 index 0000000000000000000000000000000000000000..558abbc785072629de8000e343fc02a32c0afb97 --- /dev/null +++ b/fairseq/examples/multilingual/ML50_langs.txt @@ -0,0 +1,52 @@ +ar_AR +cs_CZ +de_DE +en_XX +es_XX +et_EE +fi_FI +fr_XX +gu_IN +hi_IN +it_IT +ja_XX +kk_KZ +ko_KR +lt_LT +lv_LV +my_MM +ne_NP +nl_XX +ro_RO +ru_RU +si_LK +tr_TR +vi_VN +zh_CN +af_ZA +az_AZ +bn_IN +fa_IR +he_IL +hr_HR +id_ID +ka_GE +km_KH +mk_MK +ml_IN +mn_MN +mr_IN +pl_PL +ps_AF +pt_XX +sv_SE +sw_KE +ta_IN +te_IN +th_TH +tl_XX +uk_UA +ur_PK +xh_ZA +gl_ES +sl_SI \ No newline at end of file diff --git a/fairseq/examples/multilingual/README.md b/fairseq/examples/multilingual/README.md new file mode 100644 index 0000000000000000000000000000000000000000..46ff9c351b1030e0729f89f246e0cd86444c1633 --- /dev/null +++ b/fairseq/examples/multilingual/README.md @@ -0,0 +1,158 @@ +# Multilingual Translation + +[[Multilingual Translation with Extensible Multilingual Pretraining and Finetuning, https://arxiv.org/abs/2008.00401]](https://arxiv.org/abs/2008.00401) + +## Introduction + +This work is for training multilingual translation models with multiple bitext datasets. This multilingual translation framework supports (see [[training section]](#Training) and [[finetuning section]](#Finetuning) for examples) + +* temperature based sampling over unbalancing datasets of different translation directions + - --sampling-method' with + choices=['uniform', 'temperature', 'concat'] + - --sampling-temperature +* configurable to automatically add source and/or target language tokens to source/target sentences using data which are prepared in the same way as bilignual training + - --encoder-langtok with choices=['src', 'tgt', None] to specify whether to add source or target language tokens to the source sentences + - --decoder-langtok (binary option) to specify whether to add target language tokens to the target sentences or not +* finetuning mBART pretrained models for multilingual translation + - --finetune-from-model to specify the path from which to load the pretrained model + +## Preprocessing data +Multilingual training requires a joint BPE vocab. Please follow [mBART's preprocessing steps](https://github.com/pytorch/fairseq/tree/main/examples/mbart#bpe-data) to reuse our pretrained sentence-piece model. + +You can also train a joint BPE model on your own dataset and then follow the steps in [[link]](https://github.com/pytorch/fairseq/tree/main/examples/translation#multilingual-translation). + +## Training + + +```bash +lang_pairs= +path_2_data= +lang_list= + +fairseq-train $path_2_data \ + --encoder-normalize-before --decoder-normalize-before \ + --arch transformer --layernorm-embedding \ + --task translation_multi_simple_epoch \ + --sampling-method "temperature" \ + --sampling-temperature 1.5 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.2 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt --lr 3e-05 --warmup-updates 2500 --max-update 40000 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 1024 --update-freq 2 \ + --save-interval 1 --save-interval-updates 5000 --keep-interval-updates 10 --no-epoch-checkpoints \ + --seed 222 --log-format simple --log-interval 2 +``` + +## Finetuning +We can also finetune multilingual models from a monolingual pretrained models, e.g. [mMBART](https://github.com/pytorch/fairseq/tree/main/examples/mbart). +```bash +lang_pairs= +path_2_data= +lang_list= +pretrained_model= + +fairseq-train $path_2_data \ + --finetune-from-model $pretrained_model \ + --encoder-normalize-before --decoder-normalize-before \ + --arch transformer --layernorm-embedding \ + --task translation_multi_simple_epoch \ + --sampling-method "temperature" \ + --sampling-temperature 1.5 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.2 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt --lr 3e-05 --warmup-updates 2500 --max-update 40000 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 1024 --update-freq 2 \ + --save-interval 1 --save-interval-updates 5000 --keep-interval-updates 10 --no-epoch-checkpoints \ + --seed 222 --log-format simple --log-interval 2 +``` +## Generate +The following command uses the multilingual task (translation_multi_simple_epoch) to generate translation from $source_lang to $target_lang on the test dataset. During generaton, the source language tokens are added to source sentences and the target language tokens are added as the starting token to decode target sentences. Options --lang-dict and --lang-pairs are needed to tell the generation process the ordered list of languages and translation directions that the trained model are awared of; they will need to be consistent with the training. + +```bash +model= +source_lang= +target_lang= + +fairseq-generate $path_2_data \ + --path $model \ + --task translation_multi_simple_epoch \ + --gen-subset test \ + --source-lang $source_lang \ + --target-lang $target_lang + --sacrebleu --remove-bpe 'sentencepiece'\ + --batch-size 32 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" > ${source_lang}_${target_lang}.txt +``` +Fairseq will generate translation into a file {source_lang}_${target_lang}.txt with sacreblue at the end. + +You can also use costomized tokenizer to compare the performance with the literature. For example, you get a tokenizer [here](https://github.com/rsennrich/wmt16-scripts) and do the following: +```bash +TOKENIZER= +TOK_CMD=<"$TOKENIZER $target_lang" or cat for sacrebleu> + +cat {source_lang}_${target_lang}.txt | grep -P "^H" |sort -V |cut -f 3- |$TOK_CMD > ${source_lang}_${target_lang}.hyp +cat {source_lang}_${target_lang}.txt | grep -P "^T" |sort -V |cut -f 2- |$TOK_CMD > ${source_lang}_${target_lang}.ref +sacrebleu -tok 'none' -s 'none' ${source_lang}_${target_lang}.ref < ${source_lang}_${target_lang}.hyp +``` + +# mBART50 models + +* [mMBART 50 pretrained model](https://dl.fbaipublicfiles.com/fairseq/models/mbart50/mbart50.pretrained.tar.gz). +* [mMBART 50 finetuned many-to-one](https://dl.fbaipublicfiles.com/fairseq/models/mbart50/mbart50.ft.n1.tar.gz). +* [mMBART 50 finetuned one-to-many](https://dl.fbaipublicfiles.com/fairseq/models/mbart50/mbart50.ft.1n.tar.gz). +* [mMBART 50 finetuned many-to-many](https://dl.fbaipublicfiles.com/fairseq/models/mbart50/mbart50.ft.nn.tar.gz). + +Please download and extract from the above tarballs. Each tarball contains +* The fairseq model checkpoint: model.pt +* The list of supported languages: ML50_langs.txt +* Sentence piece model: sentence.bpe.model +* Fairseq dictionary of each language: dict.{lang}.txt (please replace lang with a language specified in ML50_langs.txt) + +To use the trained models, +* use the tool [binarize.py](./data_scripts/binarize.py) to binarize your data using sentence.bpe.model and dict.{lang}.txt, and copy the dictionaries to your data path +* then run the generation command: +```bash +path_2_data= +model=/model.pt +lang_list=/ML50_langs.txt +source_lang= +target_lang= + +fairseq-generate $path_2_data \ + --path $model \ + --task translation_multi_simple_epoch \ + --gen-subset test \ + --source-lang $source_lang \ + --target-lang $target_lang + --sacrebleu --remove-bpe 'sentencepiece'\ + --batch-size 32 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" +``` + +## Citation + +```bibtex +@article{tang2020multilingual, + title={Multilingual Translation with Extensible Multilingual Pretraining and Finetuning}, + author={Yuqing Tang and Chau Tran and Xian Li and Peng-Jen Chen and Naman Goyal and Vishrav Chaudhary and Jiatao Gu and Angela Fan}, + year={2020}, + eprint={2008.00401}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` diff --git a/fairseq/examples/multilingual/data_scripts/README.md b/fairseq/examples/multilingual/data_scripts/README.md new file mode 100644 index 0000000000000000000000000000000000000000..cc610c0c9e936a5ae4659ceda691c6db6d387296 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/README.md @@ -0,0 +1,24 @@ + +# Install dependency +```bash +pip install -r requirement.txt +``` + +# Download the data set +```bash +export WORKDIR_ROOT= + +``` +The downloaded data will be at $WORKDIR_ROOT/ML50 + +# preprocess the data +Install SPM [here](https://github.com/google/sentencepiece) +```bash +export WORKDIR_ROOT= +export SPM_PATH= +``` +* $WORKDIR_ROOT/ML50/raw: extracted raw data +* $WORKDIR_ROOT/ML50/dedup: dedup data +* $WORKDIR_ROOT/ML50/clean: data with valid and test sentences removed from the dedup data + + diff --git a/fairseq/examples/multilingual/data_scripts/binarize.py b/fairseq/examples/multilingual/data_scripts/binarize.py new file mode 100755 index 0000000000000000000000000000000000000000..ee54c6aabf021ca526743f8f1f67b91889e1e335 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/binarize.py @@ -0,0 +1,200 @@ +import shutil +import os, sys +from subprocess import check_call, check_output +import glob +import argparse +import shutil +import pathlib +import itertools + +def call_output(cmd): + print(f"Executing: {cmd}") + ret = check_output(cmd, shell=True) + print(ret) + return ret + +def call(cmd): + print(cmd) + check_call(cmd, shell=True) + + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + +SPM_PATH = os.environ.get('SPM_PATH', None) + +if SPM_PATH is None or not SPM_PATH.strip(): + print("Please install sentence piecence from https://github.com/google/sentencepiece and set SPM_PATH pointing to the installed spm_encode.py. Exitting...") + sys.exit(-1) + + +SPM_MODEL = f'{WORKDIR_ROOT}/sentence.bpe.model' +SPM_VOCAB = f'{WORKDIR_ROOT}/dict_250k.txt' + +SPM_ENCODE = f'{SPM_PATH}' + +if not os.path.exists(SPM_MODEL): + call(f"wget https://dl.fbaipublicfiles.com/fairseq/models/mbart50/sentence.bpe.model -O {SPM_MODEL}") + + +if not os.path.exists(SPM_VOCAB): + call(f"wget https://dl.fbaipublicfiles.com/fairseq/models/mbart50/dict_250k.txt -O {SPM_VOCAB}") + + + +def get_data_size(raw): + cmd = f'wc -l {raw}' + ret = call_output(cmd) + return int(ret.split()[0]) + +def encode_spm(model, direction, prefix='', splits=['train', 'test', 'valid'], pairs_per_shard=None): + src, tgt = direction.split('-') + + for split in splits: + src_raw, tgt_raw = f'{RAW_DIR}/{split}{prefix}.{direction}.{src}', f'{RAW_DIR}/{split}{prefix}.{direction}.{tgt}' + if os.path.exists(src_raw) and os.path.exists(tgt_raw): + cmd = f"""python {SPM_ENCODE} \ + --model {model}\ + --output_format=piece \ + --inputs {src_raw} {tgt_raw} \ + --outputs {BPE_DIR}/{direction}{prefix}/{split}.bpe.{src} {BPE_DIR}/{direction}{prefix}/{split}.bpe.{tgt} """ + print(cmd) + call(cmd) + + +def binarize_( + bpe_dir, + databin_dir, + direction, spm_vocab=SPM_VOCAB, + splits=['train', 'test', 'valid'], +): + src, tgt = direction.split('-') + + try: + shutil.rmtree(f'{databin_dir}', ignore_errors=True) + os.mkdir(f'{databin_dir}') + except OSError as error: + print(error) + cmds = [ + "fairseq-preprocess", + f"--source-lang {src} --target-lang {tgt}", + f"--destdir {databin_dir}/", + f"--workers 8", + ] + if isinstance(spm_vocab, tuple): + src_vocab, tgt_vocab = spm_vocab + cmds.extend( + [ + f"--srcdict {src_vocab}", + f"--tgtdict {tgt_vocab}", + ] + ) + else: + cmds.extend( + [ + f"--joined-dictionary", + f"--srcdict {spm_vocab}", + ] + ) + input_options = [] + if 'train' in splits and glob.glob(f"{bpe_dir}/train.bpe*"): + input_options.append( + f"--trainpref {bpe_dir}/train.bpe", + ) + if 'valid' in splits and glob.glob(f"{bpe_dir}/valid.bpe*"): + input_options.append(f"--validpref {bpe_dir}/valid.bpe") + if 'test' in splits and glob.glob(f"{bpe_dir}/test.bpe*"): + input_options.append(f"--testpref {bpe_dir}/test.bpe") + if len(input_options) > 0: + cmd = " ".join(cmds + input_options) + print(cmd) + call(cmd) + + +def binarize( + databin_dir, + direction, spm_vocab=SPM_VOCAB, prefix='', + splits=['train', 'test', 'valid'], + pairs_per_shard=None, +): + def move_databin_files(from_folder, to_folder): + for bin_file in glob.glob(f"{from_folder}/*.bin") \ + + glob.glob(f"{from_folder}/*.idx") \ + + glob.glob(f"{from_folder}/dict*"): + try: + shutil.move(bin_file, to_folder) + except OSError as error: + print(error) + bpe_databin_dir = f"{BPE_DIR}/{direction}{prefix}_databin" + bpe_dir = f"{BPE_DIR}/{direction}{prefix}" + if pairs_per_shard is None: + binarize_(bpe_dir, bpe_databin_dir, direction, spm_vocab=spm_vocab, splits=splits) + move_databin_files(bpe_databin_dir, databin_dir) + else: + # binarize valid and test which will not be sharded + binarize_( + bpe_dir, bpe_databin_dir, direction, + spm_vocab=spm_vocab, splits=[s for s in splits if s != "train"]) + for shard_bpe_dir in glob.glob(f"{bpe_dir}/shard*"): + path_strs = os.path.split(shard_bpe_dir) + shard_str = path_strs[-1] + shard_folder = f"{bpe_databin_dir}/{shard_str}" + databin_shard_folder = f"{databin_dir}/{shard_str}" + print(f'working from {shard_folder} to {databin_shard_folder}') + os.makedirs(databin_shard_folder, exist_ok=True) + binarize_( + shard_bpe_dir, shard_folder, direction, + spm_vocab=spm_vocab, splits=["train"]) + + for test_data in glob.glob(f"{bpe_databin_dir}/valid.*") + glob.glob(f"{bpe_databin_dir}/test.*"): + filename = os.path.split(test_data)[-1] + try: + os.symlink(test_data, f"{databin_shard_folder}/{filename}") + except OSError as error: + print(error) + move_databin_files(shard_folder, databin_shard_folder) + + +def load_langs(path): + with open(path) as fr: + langs = [l.strip() for l in fr] + return langs + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("--data_root", default=f"{WORKDIR_ROOT}/ML50") + parser.add_argument("--raw-folder", default='raw') + parser.add_argument("--bpe-folder", default='bpe') + parser.add_argument("--databin-folder", default='databin') + + args = parser.parse_args() + + DATA_PATH = args.data_root #'/private/home/yuqtang/public_data/ML50' + RAW_DIR = f'{DATA_PATH}/{args.raw_folder}' + BPE_DIR = f'{DATA_PATH}/{args.bpe_folder}' + DATABIN_DIR = f'{DATA_PATH}/{args.databin_folder}' + os.makedirs(BPE_DIR, exist_ok=True) + + raw_files = itertools.chain( + glob.glob(f'{RAW_DIR}/train*'), + glob.glob(f'{RAW_DIR}/valid*'), + glob.glob(f'{RAW_DIR}/test*'), + ) + + directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] + + for direction in directions: + prefix = "" + splits = ['train', 'valid', 'test'] + try: + shutil.rmtree(f'{BPE_DIR}/{direction}{prefix}', ignore_errors=True) + os.mkdir(f'{BPE_DIR}/{direction}{prefix}') + os.makedirs(DATABIN_DIR, exist_ok=True) + except OSError as error: + print(error) + spm_model, spm_vocab = SPM_MODEL, SPM_VOCAB + encode_spm(spm_model, direction=direction, splits=splits) + binarize(DATABIN_DIR, direction, spm_vocab=spm_vocab, splits=splits) diff --git a/fairseq/examples/multilingual/data_scripts/check_iswlt_test_data.py b/fairseq/examples/multilingual/data_scripts/check_iswlt_test_data.py new file mode 100644 index 0000000000000000000000000000000000000000..f8e2eb0f15699f1b458a8445d0c1dd6229a21f77 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/check_iswlt_test_data.py @@ -0,0 +1,67 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import os, sys +import subprocess +import re +from subprocess import check_call, check_output + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + + +BLEU_REGEX = re.compile("^BLEU\\S* = (\\S+) ") +def run_eval_bleu(cmd): + output = check_output(cmd, shell=True, stderr=subprocess.STDOUT).decode("utf-8").strip() + print(output) + bleu = -1.0 + for line in output.strip().split('\n'): + m = BLEU_REGEX.search(line) + if m is not None: + bleu = m.groups()[0] + bleu = float(bleu) + break + return bleu + +def check_data_test_bleu(raw_folder, data_lang_pairs): + not_matchings = [] + for sacrebleu_set, src_tgts in data_lang_pairs: + for src_tgt in src_tgts: + print(f'checking test bleus for: {src_tgt} at {sacrebleu_set}') + src, tgt = src_tgt.split('-') + ssrc, stgt = src[:2], tgt[:2] + if os.path.exists(f'{raw_folder}/test.{tgt}-{src}.{src}'): + # reversed direction may have different test set + test_src = f'{raw_folder}/test.{tgt}-{src}.{src}' + else: + test_src = f'{raw_folder}/test.{src}-{tgt}.{src}' + cmd1 = f'cat {test_src} | sacrebleu -t "{sacrebleu_set}" -l {stgt}-{ssrc}; [ $? -eq 0 ] || echo ""' + test_tgt = f'{raw_folder}/test.{src}-{tgt}.{tgt}' + cmd2 = f'cat {test_tgt} | sacrebleu -t "{sacrebleu_set}" -l {ssrc}-{stgt}; [ $? -eq 0 ] || echo ""' + bleu1 = run_eval_bleu(cmd1) + if bleu1 != 100.0: + not_matchings.append(f'{sacrebleu_set}:{src_tgt} source side not matching: {test_src}') + bleu2 = run_eval_bleu(cmd2) + if bleu2 != 100.0: + not_matchings.append(f'{sacrebleu_set}:{src_tgt} target side not matching: {test_tgt}') + return not_matchings + +if __name__ == "__main__": + to_data_path = f'{WORKDIR_ROOT}/iwsltv2' + not_matching = check_data_test_bleu( + f'{to_data_path}/raw', + [ + ('iwslt17', ['en_XX-ar_AR', 'en_XX-ko_KR', 'ar_AR-en_XX', 'ko_KR-en_XX']), + ('iwslt17', ['en_XX-it_IT', 'en_XX-nl_XX', 'it_IT-en_XX', 'nl_XX-en_XX']), + ('iwslt17/tst2015', ['en_XX-vi_VN', "vi_VN-en_XX"]), + ] + ) + if len(not_matching) > 0: + print('the following datasets do not have matching test datasets:\n\t', '\n\t'.join(not_matching)) + diff --git a/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py b/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py new file mode 100644 index 0000000000000000000000000000000000000000..07b338dcfd2d7f10317608274631d0edd93ba889 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/check_self_overlaps.py @@ -0,0 +1,103 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import os +import glob +import argparse +from utils.dedup import deup +import sys + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + +def get_directions(folder): + raw_files = glob.glob(f'{folder}/train*') + directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] + return directions + +def diff_list(lhs, rhs): + return set(lhs).difference(set(rhs)) + +def check_diff( + from_src_file, from_tgt_file, + to_src_file, to_tgt_file, +): + seen_in_from = set() + seen_src_in_from = set() + seen_tgt_in_from = set() + from_count = 0 + with open(from_src_file, encoding='utf-8') as fsrc, \ + open(from_tgt_file, encoding='utf-8') as ftgt: + for s, t in zip(fsrc, ftgt): + seen_in_from.add((s, t)) + seen_src_in_from.add(s) + seen_tgt_in_from.add(t) + from_count += 1 + common = 0 + common_src = 0 + common_tgt = 0 + to_count = 0 + seen = set() + + with open(to_src_file, encoding='utf-8') as fsrc, \ + open(to_tgt_file, encoding='utf-8') as ftgt: + for s, t in zip(fsrc, ftgt): + to_count += 1 + if (s, t) not in seen: + if (s, t) in seen_in_from: + common += 1 + if s in seen_src_in_from: + common_src += 1 + seen_src_in_from.remove(s) + if t in seen_tgt_in_from: + common_tgt += 1 + seen_tgt_in_from.remove(t) + seen.add((s, t)) + return common, common_src, common_tgt, from_count, to_count + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--folder", type=str, required=True, + help="the data folder ") + parser.add_argument("--split", type=str, default='test', + help="split (valid, test) to check against training data") + parser.add_argument('--directions', type=str, default=None, required=False) + + args = parser.parse_args() + + if args.directions is None: + directions = set(get_directions(args.folder)) + directions = sorted(directions) + else: + directions = args.directions.split(',') + directions = sorted(set(directions)) + + results = [] + print(f'checking where {args.split} split data are in training') + print(f'direction\tcommon_count\tsrc common\ttgt common\tfrom_size\tto_size') + + for direction in directions: + src, tgt = direction.split('-') + from_src_file = f'{args.folder}/{args.split}.{src}-{tgt}.{src}' + from_tgt_file = f'{args.folder}/{args.split}.{src}-{tgt}.{tgt}' + if not os.path.exists(from_src_file): + # some test/valid data might in reverse directinos: + from_src_file = f'{args.folder}/{args.split}.{tgt}-{src}.{src}' + from_tgt_file = f'{args.folder}/{args.split}.{tgt}-{src}.{tgt}' + to_src_file = f'{args.folder}/train.{src}-{tgt}.{src}' + to_tgt_file = f'{args.folder}/train.{src}-{tgt}.{tgt}' + if not os.path.exists(to_src_file) or not os.path.exists(from_src_file): + continue + r = check_diff(from_src_file, from_tgt_file, to_src_file, to_tgt_file) + results.append(r) + print(f'{direction}\t', '\t'.join(map(str, r))) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/data_scripts/check_valid_test_overlaps.py b/fairseq/examples/multilingual/data_scripts/check_valid_test_overlaps.py new file mode 100644 index 0000000000000000000000000000000000000000..40fa9aecdf9108e095feb3661236453c0f7ed7c4 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/check_valid_test_overlaps.py @@ -0,0 +1,124 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import os +import argparse +import pandas as pd +import sys + + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + +def load_langs(path): + with open(path) as fr: + langs = [l.strip() for l in fr] + return langs + + + +def load_sentences(raw_data, split, direction): + src, tgt = direction.split('-') + src_path = f"{raw_data}/{split}.{direction}.{src}" + tgt_path = f"{raw_data}/{split}.{direction}.{tgt}" + if os.path.exists(src_path) and os.path.exists(tgt_path): + return [(src, open(src_path).read().splitlines()), (tgt, open(tgt_path).read().splitlines())] + else: + return [] + +def swap_direction(d): + src, tgt = d.split('-') + return f'{tgt}-{src}' + +def get_all_test_data(raw_data, directions, split='test'): + test_data = [ + x + for dd in directions + for d in [dd, swap_direction(dd)] + for x in load_sentences(raw_data, split, d) + ] + # all_test_data = {s for _, d in test_data for s in d} + all_test_data = {} + for lang, d in test_data: + for s in d: + s = s.strip() + lgs = all_test_data.get(s, set()) + lgs.add(lang) + all_test_data[s] = lgs + return all_test_data, test_data + + +def check_train_sentences(src_path, tgt_path, direction, all_test_data, mess_up_train={}): + # src, tgt = direction.split('-') + print(f'check training data for {direction} in {src_path} and {tgt_path}') + size = 0 + overlapped_size_counted_dup = 0 + if not os.path.exists(tgt_path) or not os.path.exists(src_path): + return mess_up_train, size, overlapped_size_counted_dup + + with open(src_path) as f, open(tgt_path) as g: + for src_line, tgt_line in zip(f, g): + s = src_line.strip() + t = tgt_line.strip() + size += 1 + if s in all_test_data: + langs = mess_up_train.get(s, set()) + langs.add(direction) + mess_up_train[s] = langs + overlapped_size_counted_dup += 1 + if t in all_test_data: + langs = mess_up_train.get(t, set()) + langs.add(direction) + mess_up_train[t] = langs + overlapped_size_counted_dup += 1 + print(f'{direction}: size={size}, overlapped={overlapped_size_counted_dup}') + return mess_up_train, size, overlapped_size_counted_dup + +def check_train_all(raw_data, directions, all_test_data): + mess_up_train = {} + data_sizes = {} + # raw_data = '~chau/data-bin/MineBART/multilingual_mined_100M/en_XX/et_EE-en_XX/all.{en_XX, et_EE}' + print(f'checking training data againsts # {len(all_test_data)} sentences') + print(f'example test data: ', [s for i, s in enumerate(all_test_data.keys()) if i < 10]) + for direction in directions: + src, tgt = direction.split('-') + path = f'{raw_data}/en_XX/{direction}/all' + src_path = f'{path}.{src}' + tgt_path = f'{path}.{tgt}' + print(f'checking {src_path} {tgt_path}') + _, size, overlapped_size_counted_dup = check_train_sentences(src_path, tgt_path, direction, all_test_data, mess_up_train) + data_sizes[direction] = (size, overlapped_size_counted_dup) + return mess_up_train, data_sizes + + + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--folder", type=str, required=True, + help="the data folder ") + parser.add_argument("--test-data", type=str, required=True, + help="the test data folder ") + parser.add_argument('--directions', type=str, default=None, required=False) + + args = parser.parse_args() + directions = args.directions.split(',') + directions = sorted(set(directions)) + + results = [] + # print(f'checking where {args.split} split data are in training') + # print(f'direction\tcommon_count\tsrc common\ttgt common\tfrom_size\tto_size') + raw_data = args.folder + all_test_data, test_data = get_all_test_data(args.test_data, directions, split='test') + mess_up_train, data_sizes = check_train_all(raw_data, directions, all_test_data) + print(data_sizes) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/data_scripts/dedup_all.py b/fairseq/examples/multilingual/data_scripts/dedup_all.py new file mode 100644 index 0000000000000000000000000000000000000000..ef39c05ee606aaeda1d9e94970932d2241a8b281 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/dedup_all.py @@ -0,0 +1,52 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + + +import os +import glob +import argparse +from utils.dedup import deup + +import sys +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--from-folder", type=str, required=True, + help="the data folder to be dedup") + parser.add_argument("--to-folder", type=str, required=True, + help="the data folder to save deduped data") + parser.add_argument('--directions', type=str, default=None, required=False) + + args = parser.parse_args() + + if args.directions is None: + raw_files = glob.glob(f'{args.from_folder}/train*') + + directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] + else: + directions = args.directions.split(',') + directions = sorted(set(directions)) + + for direction in directions: + src, tgt = direction.split('-') + src_file = f'{args.from_folder}/train.{src}-{tgt}.{src}' + tgt_file = f'{args.from_folder}/train.{src}-{tgt}.{tgt}' + src_file_out = f'{args.to_folder}/train.{src}-{tgt}.{src}' + tgt_file_out = f'{args.to_folder}/train.{src}-{tgt}.{tgt}' + assert src_file != src_file_out + assert tgt_file != tgt_file_out + print(f'deduping {src_file}, {tgt_file}') + deup(src_file, tgt_file, src_file_out, tgt_file_out) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/data_scripts/download_ML50_v1.sh b/fairseq/examples/multilingual/data_scripts/download_ML50_v1.sh new file mode 100644 index 0000000000000000000000000000000000000000..99fbc75920836a4b4bbdbd6b523749843288e450 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_ML50_v1.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + +# first run download_wmt20.sh; it will install a few useful tools for other scripts +# TODO: need to print out instructions on downloading a few files which requires manually authentication from the websites +bash ./download_wmt20.sh + +python ./download_wmt19_and_before.py +bash ./download_wat19_my.sh +python ./download_ted_and_extract.py +bash ./download_lotus.sh +bash ./download_iitb.sh +bash ./download_af_xh.sh + + +# IWSLT downloading URLs have changed in between; TODO: fix them: +bash ./download_iwslt_and_extract.sh + +# TODO: globalvoices URLs changed; need to be fixed +bash ./download_flores_data.sh diff --git a/fairseq/examples/multilingual/data_scripts/download_af_xh.sh b/fairseq/examples/multilingual/data_scripts/download_af_xh.sh new file mode 100644 index 0000000000000000000000000000000000000000..a78fbbbbccb6f6ae005a1f03b97f083a2d958ebe --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_af_xh.sh @@ -0,0 +1,164 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +# set -x -e + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + +# put intermediate files +TMP_DIR=$WORKDIR_ROOT/temp/af_xhv2 +# output {train,valid,test} files to dest +DEST=${WORKDIR_ROOT}/ML50/raw + + + +ROOT=${WORKDIR_ROOT} +UTILS=$PWD/utils +TMX2CORPUS="${UTILS}/tmx2corpus" +TMX_TOOL="python ${TMX2CORPUS}/tmx2corpus.py" + +mkdir -p $TMP_DIR +mkdir -p $DEST +mkdir -p $UTILS + +function download_opus(){ + src=$1 + tgt=$2 + subset=$3 + ulr=$4 + + mkdir extract_$subset.$src-$tgt + pushd extract_$subset.$src-$tgt + if [ ! -f "$subset.$src-$tgt.tmx.gz" ]; then + wget $url -O "$subset.$src-$tgt.tmx.gz" + gzip -d "$subset.$src-$tgt.tmx.gz" + f=$subset.$src-$tgt.tmx + $TMX_TOOL $f + mv bitext.$src ../$subset.$src-$tgt.$src + mv bitext.$tgt ../$subset.$src-$tgt.$tgt + fi + popd +} + +function concat_subsets(){ + src=$1 + tgt=$2 + subsets=$3 + src_train=raw_train.$src-$tgt.$src + tgt_train=raw_train.$src-$tgt.$tgt + > $src_train + > $tgt_train + for subset in $subsets; do + cat $subset.$src-$tgt.$src >> $src_train + cat $subset.$src-$tgt.$tgt >> $tgt_train + done +} + + + +function get_seeded_random() +{ + seed="$1" + openssl enc -aes-256-ctr -pass pass:"$seed" -nosalt \ + /dev/null +} + +function split_train_valid(){ + src=$1 + tgt=$2 + raw_src_train=raw_train.$src-$tgt.$src + raw_tgt_train=raw_train.$src-$tgt.$tgt + + shuf --random-source=<(get_seeded_random 43) $raw_src_train > shuffled.$src-$tgt.$src + shuf --random-source=<(get_seeded_random 43) $raw_tgt_train > shuffled.$src-$tgt.$tgt + + head -n 1500 shuffled.$src-$tgt.$src > valid.$src-$tgt.$src + head -n 1500 shuffled.$src-$tgt.$tgt > valid.$src-$tgt.$tgt + + tail +1501 shuffled.$src-$tgt.$src > train.$src-$tgt.$src + tail +1501 shuffled.$src-$tgt.$tgt > train.$src-$tgt.$tgt +} + +function copy2dst(){ + lsrc=$1 + ltgt=$2 + src=${lsrc:0:2} + tgt=${ltgt:0:2} + + + cp valid.$src-$tgt.$src $DEST/valid.$lsrc-$ltgt.$lsrc + cp valid.$src-$tgt.$tgt $DEST/valid.$lsrc-$ltgt.$ltgt + + cp train.$src-$tgt.$src $DEST/train.$lsrc-$ltgt.$lsrc + cp train.$src-$tgt.$tgt $DEST/train.$lsrc-$ltgt.$ltgt +} + + + + +#for xh-en +declare -A xh_en_urls +xh_en_urls=( + [Tatoeba]=https://object.pouta.csc.fi/OPUS-Tatoeba/v20190709/tmx/en-xh.tmx.gz + [wikimedia]=https://object.pouta.csc.fi/OPUS-wikimedia/v20190628/tmx/en-xh.tmx.gz + [memat]=https://object.pouta.csc.fi/OPUS-memat/v1/tmx/en-xh.tmx.gz + [uedin]=https://object.pouta.csc.fi/OPUS-bible-uedin/v1/tmx/en-xh.tmx.gz + [GNOME]=https://object.pouta.csc.fi/OPUS-GNOME/v1/tmx/en-xh.tmx.gz + [XhosaNavy]=https://object.pouta.csc.fi/OPUS-XhosaNavy/v1/tmx/en-xh.tmx.gz + [KDE4]=https://object.pouta.csc.fi/OPUS-KDE4/v2/tmx/en-xh.tmx.gz + [Ubuntu]=https://object.pouta.csc.fi/OPUS-Ubuntu/v14.10/tmx/en-xh.tmx.gz +) + +mkdir $TMP_DIR/xh-en +pushd $TMP_DIR/xh-en +for k in "${!xh_en_urls[@]}" +do + name=$k + url=${xh_en_urls[$k]} + echo "$name: $url" + download_opus xh en $name $ulr +done +concat_subsets xh en "${!xh_en_urls[@]}" +split_train_valid xh en +copy2dst xh_ZA en_XX +popd + + +## +#for af-en +declare -A af_en_urls +af_en_urls=( + [Tatoeba]=https://object.pouta.csc.fi/OPUS-Tatoeba/v20190709/tmx/af-en.tmx.gz + [uedin]=https://object.pouta.csc.fi/OPUS-bible-uedin/v1/tmx/af-en.tmx.gz + [GNOME]=https://object.pouta.csc.fi/OPUS-GNOME/v1/tmx/af-en.tmx.gz + [QED]=https://object.pouta.csc.fi/OPUS-QED/v2.0a/tmx/af-en.tmx.gz + [KDE4]=https://object.pouta.csc.fi/OPUS-KDE4/v2/tmx/af-en.tmx.gz + [OpenSubtitles]=https://object.pouta.csc.fi/OPUS-OpenSubtitles/v2018/tmx/af-en.tmx.gz + [SPC]=https://object.pouta.csc.fi/OPUS-SPC/v1/tmx/af-en.tmx.gz + [Ubuntu]=https://object.pouta.csc.fi/OPUS-Ubuntu/v14.10/tmx/af-en.tmx.gz +) + +mkdir $TMP_DIR/af-en +pushd $TMP_DIR/af-en +for k in "${!af_en_urls[@]}" +do + name=$k + url=${af_en_urls[$k]} + echo "$name: $url" + download_opus af en $name $ulr +done +concat_subsets af en "${!af_en_urls[@]}" +split_train_valid af en +copy2dst af_ZA en_XX +popd + + diff --git a/fairseq/examples/multilingual/data_scripts/download_flores_data.sh b/fairseq/examples/multilingual/data_scripts/download_flores_data.sh new file mode 100644 index 0000000000000000000000000000000000000000..e6175ce0c38b06a1ebddaeca808f71b47f77f500 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_flores_data.sh @@ -0,0 +1,246 @@ +#!/bin/bash + +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + +set -e +set -o pipefail + +SRC=en +SI_TGT=si +NE_TGT=ne + +DESTDIR=${WORKDIR_ROOT}/ML50/raw/ + +ROOT=${WORKDIR_ROOT}/tmp +mkdir -p $ROOT +DATA=$ROOT/data +NE_ROOT=$DATA/all-clean-ne +SI_ROOT=$DATA/all-clean-si + +mkdir -p $DATA $NE_ROOT $SI_ROOT + +SI_OPUS_DATASETS=( + "$SI_ROOT/GNOME.en-si" + "$SI_ROOT/Ubuntu.en-si" + "$SI_ROOT/KDE4.en-si" + "$SI_ROOT/OpenSubtitles.en-si" +) + +SI_OPUS_URLS=( + "https://object.pouta.csc.fi/OPUS-GNOME/v1/moses/en-si.txt.zip" + "https://object.pouta.csc.fi/OPUS-Ubuntu/v14.10/moses/en-si.txt.zip" + "https://object.pouta.csc.fi/OPUS-KDE4/v2/moses/en-si.txt.zip" + "https://object.pouta.csc.fi/OPUS-OpenSubtitles/v2018/moses/en-si.txt.zip" +) + +NE_OPUS_DATASETS=( + "$NE_ROOT/GNOME.en-ne" + "$NE_ROOT/Ubuntu.en-ne" + "$NE_ROOT/KDE4.en-ne" +) + +NE_OPUS_URLS=( + "https://object.pouta.csc.fi/OPUS-GNOME/v1/moses/en-ne.txt.zip" + "https://object.pouta.csc.fi/OPUS-Ubuntu/v14.10/moses/en-ne.txt.zip" + "https://object.pouta.csc.fi/OPUS-KDE4/v2/moses/en-ne.txt.zip" +) + +REMOVE_FILE_PATHS=() + +# Download data +download_data() { + CORPORA=$1 + URL=$2 + + if [ -f $CORPORA ]; then + echo "$CORPORA already exists, skipping download" + else + echo "Downloading $URL" + wget $URL -O $CORPORA --no-check-certificate || rm -f $CORPORA + if [ -f $CORPORA ]; then + echo "$URL successfully downloaded." + else + echo "$URL not successfully downloaded." + rm -f $CORPORA + exit -1 + fi + fi +} + +# Example: download_opus_data $LANG_ROOT $TGT +download_opus_data() { + LANG_ROOT=$1 + TGT=$2 + + if [ "$TGT" = "si" ]; then + URLS=("${SI_OPUS_URLS[@]}") + DATASETS=("${SI_OPUS_DATASETS[@]}") + else + URLS=("${NE_OPUS_URLS[@]}") + DATASETS=("${NE_OPUS_DATASETS[@]}") + fi + + # Download and extract data + for ((i=0;i<${#URLS[@]};++i)); do + URL=${URLS[i]} + CORPORA=${DATASETS[i]} + + download_data $CORPORA $URL + unzip -o $CORPORA -d $LANG_ROOT + REMOVE_FILE_PATHS+=( $CORPORA $CORPORA.xml $CORPORA.ids $LANG_ROOT/README $LANG_ROOT/LICENSE ) + done + + cat ${DATASETS[0]}.$SRC ${DATASETS[1]}.$SRC ${DATASETS[2]}.$SRC > $LANG_ROOT/GNOMEKDEUbuntu.$SRC-$TGT.$SRC + cat ${DATASETS[0]}.$TGT ${DATASETS[1]}.$TGT ${DATASETS[2]}.$TGT > $LANG_ROOT/GNOMEKDEUbuntu.$SRC-$TGT.$TGT + + REMOVE_FILE_PATHS+=( ${DATASETS[0]}.$SRC ${DATASETS[1]}.$SRC ${DATASETS[2]}.$SRC ) + REMOVE_FILE_PATHS+=( ${DATASETS[0]}.$TGT ${DATASETS[1]}.$TGT ${DATASETS[2]}.$TGT ) +} + +download_opus_data $SI_ROOT $SI_TGT +cp ${SI_OPUS_DATASETS[3]}.$SRC $SI_ROOT/OpenSubtitles2018.$SRC-$SI_TGT.$SRC +cp ${SI_OPUS_DATASETS[3]}.$SI_TGT $SI_ROOT/OpenSubtitles2018.$SRC-$SI_TGT.$SI_TGT +REMOVE_FILE_PATHS+=( ${SI_OPUS_DATASETS[3]}.$SRC ${SI_OPUS_DATASETS[3]}.$SI_TGT ) + +download_opus_data $NE_ROOT $NE_TGT + + +# Download and extract Global Voices data +GLOBAL_VOICES="$NE_ROOT/globalvoices.2018q4.ne-en" +GLOBAL_VOICES_URL="http://www.casmacat.eu/corpus/global-voices/globalvoices.ne-en.xliff.gz" + +download_data $GLOBAL_VOICES.gz $GLOBAL_VOICES_URL +gunzip -Nf $GLOBAL_VOICES.gz + +sed -ne 's?.*\(.*\).*?\1?p' $GLOBAL_VOICES > $GLOBAL_VOICES.$NE_TGT +sed -ne 's?.*]*>\(.*\).*?\1?p' $GLOBAL_VOICES > $GLOBAL_VOICES.$SRC + +REMOVE_FILE_PATHS+=( $GLOBAL_VOICES ) + +# Download and extract the bible dataset +BIBLE_TOOLS=bible-corpus-tools +XML_BIBLES=XML_Bibles +XML_BIBLES_DUP=XML_Bibles_dup + +if [ ! -e $BIBLE_TOOLS ]; then + echo "Cloning bible-corpus-tools repository..." + git clone https://github.com/christos-c/bible-corpus-tools.git +fi + +mkdir -p $BIBLE_TOOLS/bin $XML_BIBLES $XML_BIBLES_DUP +javac -cp "$BIBLE_TOOLS/lib/*" -d $BIBLE_TOOLS/bin $BIBLE_TOOLS/src/bible/readers/*.java $BIBLE_TOOLS/src/bible/*.java + +download_data bible.tar.gz "https://github.com/christos-c/bible-corpus/archive/v1.2.1.tar.gz" +tar xvzf bible.tar.gz + +cp bible-corpus-1.2.1/bibles/{Greek.xml,English.xml,Nepali.xml} $XML_BIBLES/ +cp bible-corpus-1.2.1/bibles/{Greek.xml,English-WEB.xml,Nepali.xml} $XML_BIBLES_DUP/ + +java -cp $BIBLE_TOOLS/lib/*:$BIBLE_TOOLS/bin bible.CreateMLBooks $XML_BIBLES +java -cp $BIBLE_TOOLS/lib/*:$BIBLE_TOOLS/bin bible.CreateMLBooks $XML_BIBLES_DUP +java -cp $BIBLE_TOOLS/lib/*:$BIBLE_TOOLS/bin bible.CreateVerseAlignedBooks $XML_BIBLES +java -cp $BIBLE_TOOLS/lib/*:$BIBLE_TOOLS/bin bible.CreateVerseAlignedBooks $XML_BIBLES_DUP + +cat $XML_BIBLES/aligned/*/English.txt > $NE_ROOT/bible.$SRC-$NE_TGT.$SRC +cat $XML_BIBLES/aligned/*/Nepali.txt > $NE_ROOT/bible.$SRC-$NE_TGT.$NE_TGT +cat $XML_BIBLES_DUP/aligned/*/English-WEB.txt > $NE_ROOT/bible_dup.$SRC-$NE_TGT.$SRC +cat $XML_BIBLES_DUP/aligned/*/Nepali.txt > $NE_ROOT/bible_dup.$SRC-$NE_TGT.$NE_TGT +REMOVE_FILE_PATHS+=( bible-corpus-1.2.1 bible.tar.gz $BIBLE_TOOLS $XML_BIBLES $XML_BIBLES_DUP ) + +# Download and extract the Penn Treebank dataset +NE_TAGGED=$ROOT/new_submissions_parallel_corpus_project_Nepal +NE_TAGGED_URL="http://www.cle.org.pk/Downloads/ling_resources/parallelcorpus/NepaliTaggedCorpus.zip" +EN_TAGGED_PATCH_URL="https://dl.fbaipublicfiles.com/fairseq/data/nepali-penn-treebank.en.patch" +NE_TAGGED_PATCH_URL="https://dl.fbaipublicfiles.com/fairseq/data/nepali-penn-treebank.ne.patch" +MOSES=mosesdecoder +MOSES_TOK=$MOSES/scripts/tokenizer +EN_PATCH_REGEX="{s:\\\/:\/:g;s/\*\T\*\-\n+//g;s/\-LCB\-/\{/g;s/\-RCB\-/\}/g; s/\-LSB\-/\[/g; s/\-RSB\-/\]/g;s/\-LRB\-/\(/g; s/\-RRB\-/\)/g; s/\'\'/\"/g; s/\`\`/\"/g; s/\ +\'s\ +/\'s /g; s/\ +\'re\ +/\'re /g; s/\"\ +/\"/g; s/\ +\"/\"/g; s/\ n't([\ \.\"])/n't\1/g; s/\r+(.)/\1/g;}" +NE_PATCH_REGEX="{s:\p{Cf}::g;s:\\\/:\/:g;s/\*\T\*\-\n+//g;s/\-LCB\-/\{/g;s/\-RCB\-/\}/g; s/\-LSB\-/\[/g; s/\-RSB\-/\]/g;s/\-LRB\-/\(/g; s/\-RRB\-/\)/g; s/\'\'/\"/g; s/\`\`/\"/g; s/\ +\'s\ +/\'s /g; s/\ +\'re\ +/\'re /g; s/\"\ +/\"/g; s/\ +\"/\"/g; s/\ n't([\ \.\"])/n't\1/g; s/\r+(.)/\1/g;}" + +download_data $DATA/nepali-penn-treebank.$SRC.patch $EN_TAGGED_PATCH_URL +download_data $DATA/nepali-penn-treebank.$NE_TGT.patch $NE_TAGGED_PATCH_URL +download_data original.zip $NE_TAGGED_URL +unzip -o original.zip -d $ROOT + +cat $NE_TAGGED/00.txt $NE_TAGGED/01.txt $NE_TAGGED/02.txt > $NE_TAGGED/nepali-penn-treebank.$SRC +cat $NE_TAGGED/00ne_revised.txt $NE_TAGGED/01ne_revised.txt $NE_TAGGED/02ne_revised.txt > $NE_TAGGED/nepali-penn-treebank.$NE_TGT + +patch $NE_TAGGED/nepali-penn-treebank.$SRC -i $DATA/nepali-penn-treebank.$SRC.patch -o $NE_TAGGED/nepali-penn-treebank-patched.$SRC +patch $NE_TAGGED/nepali-penn-treebank.$NE_TGT -i $DATA/nepali-penn-treebank.$NE_TGT.patch -o $NE_TAGGED/nepali-penn-treebank-patched.$NE_TGT + +if [ ! -e $MOSES ]; then + echo "Cloning moses repository..." + git clone https://github.com/moses-smt/mosesdecoder.git +fi + +cat $NE_TAGGED/nepali-penn-treebank-patched.$SRC | \ + perl -anpe "$EN_PATCH_REGEX" | \ + $MOSES_TOK/tokenizer.perl -l $SRC | \ + $MOSES_TOK/detokenizer.perl -l $SRC > $NE_ROOT/nepali-penn-treebank.$SRC + +cat $NE_TAGGED/nepali-penn-treebank-patched.$NE_TGT | \ + perl -CIO -anpe "$NE_PATCH_REGEX" | \ + $MOSES_TOK/detokenizer.perl -l $SRC > $NE_ROOT/nepali-penn-treebank.$NE_TGT + + +# Download nepali dictionary data +NE_DICT=$NE_ROOT/dictionaries +download_data $NE_DICT "http://www.seas.upenn.edu/~nlp/resources/TACL-data-release/dictionaries.tar.gz" +tar xvzf $NE_DICT +cp dictionaries/dict.ne $NE_ROOT/dictionary.$NE_TGT-$SRC +REMOVE_FILE_PATHS+=( $NE_DICT dictionaries ) + +REMOVE_FILE_PATHS+=( $MOSES $NE_TAGGED original.zip $DATA/nepali-penn-treebank.$SRC.patch $DATA/nepali-penn-treebank.$NE_TGT.patch ) + + +# Remove the temporary files +for ((i=0;i<${#REMOVE_FILE_PATHS[@]};++i)); do + rm -rf ${REMOVE_FILE_PATHS[i]} +done + +# Copy the training data +si=si_LK +ne=ne_NP +en=en_XX +cat $SI_ROOT/GNOMEKDEUbuntu.en-si.si $SI_ROOT/OpenSubtitles2018.en-si.si > $DESTDIR/train.$si-$en.$si +cat $SI_ROOT/GNOMEKDEUbuntu.en-si.en $SI_ROOT/OpenSubtitles2018.en-si.en > $DESTDIR/train.$si-$en.$en + +cat $NE_ROOT/bible_dup.en-ne.ne $NE_ROOT/bible.en-ne.ne $NE_ROOT/globalvoices.2018q4.ne-en.ne $NE_ROOT/GNOMEKDEUbuntu.en-ne.ne $NE_ROOT/nepali-penn-treebank.ne > $DESTDIR/train.$ne-$en.$ne +cat $NE_ROOT/bible_dup.en-ne.en $NE_ROOT/bible.en-ne.en $NE_ROOT/globalvoices.2018q4.ne-en.en $NE_ROOT/GNOMEKDEUbuntu.en-ne.en $NE_ROOT/nepali-penn-treebank.en > $DESTDIR/train.$ne-$en.$en + + +#Download the test sets +wget https://github.com/facebookresearch/flores/raw/master/data/wikipedia_en_ne_si_test_sets.tgz +tar -xvzf wikipedia_en_ne_si_test_sets.tgz + +cp wikipedia_en_ne_si_test_sets/wikipedia.dev.ne-en.ne $DESTDIR/valid.$ne-$en.$ne +cp wikipedia_en_ne_si_test_sets/wikipedia.dev.ne-en.en $DESTDIR/valid.$ne-$en.$en + +cp wikipedia_en_ne_si_test_sets/wikipedia.dev.si-en.si $DESTDIR/valid.$si-$en.$si +cp wikipedia_en_ne_si_test_sets/wikipedia.dev.si-en.en $DESTDIR/valid.$si-$en.$en + +cp wikipedia_en_ne_si_test_sets/wikipedia.devtest.ne-en.ne $DESTDIR/devtest.$ne-$en.$ne +cp wikipedia_en_ne_si_test_sets/wikipedia.devtest.ne-en.en $DESTDIR/devtest.$ne-$en.$en + +cp wikipedia_en_ne_si_test_sets/wikipedia.devtest.si-en.si $DESTDIR/devtest.$si-$en.$si +cp wikipedia_en_ne_si_test_sets/wikipedia.devtest.si-en.en $DESTDIR/devtest.$si-$en.$en + +cp wikipedia_en_ne_si_test_sets/wikipedia.test.ne-en.ne $DESTDIR/test.$ne-$en.$ne +cp wikipedia_en_ne_si_test_sets/wikipedia.test.ne-en.en $DESTDIR/test.$ne-$en.$en + +cp wikipedia_en_ne_si_test_sets/wikipedia.test.si-en.si $DESTDIR/test.$si-$en.$si +cp wikipedia_en_ne_si_test_sets/wikipedia.test.si-en.en $DESTDIR/test.$si-$en.$en + +rm -rf wikipedia_en_ne_si_test_sets.tgz wikipedia_en_ne_si_test_sets diff --git a/fairseq/examples/multilingual/data_scripts/download_iitb.sh b/fairseq/examples/multilingual/data_scripts/download_iitb.sh new file mode 100644 index 0000000000000000000000000000000000000000..a884e20839e2a41a57405cb6af362e37bd16ab6f --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_iitb.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + +IITB=$WORKDIR_ROOT/IITB +mkdir -p $IITB +pushd $IITB + +wget http://www.cfilt.iitb.ac.in/~moses/iitb_en_hi_parallel/iitb_corpus_download/parallel.tgz +tar -xvzf parallel.tgz + +wget http://www.cfilt.iitb.ac.in/~moses/iitb_en_hi_parallel/iitb_corpus_download/dev_test.tgz +tar -xvzf dev_test.tgz + +DESTDIR=${WORKDIR_ROOT}/ML50/raw/ + +cp parallel/IITB.en-hi.en $DESTDIR/train.hi_IN-en_XX.en_XX +cp parallel/IITB.en-hi.hi $DESTDIR/train.hi_IN-en_XX.hi_IN + +cp dev_test/dev.en $DESTDIR/valid.hi_IN-en_XX.en_XX +cp dev_test/dev.hi $DESTDIR/valid.hi_IN-en_XX.hi_IN + +cp dev_test/test.en $DESTDIR/test.hi_IN-en_XX.en_XX +cp dev_test/test.hi $DESTDIR/test.hi_IN-en_XX.hi_IN +popd \ No newline at end of file diff --git a/fairseq/examples/multilingual/data_scripts/download_iwslt_and_extract.sh b/fairseq/examples/multilingual/data_scripts/download_iwslt_and_extract.sh new file mode 100644 index 0000000000000000000000000000000000000000..ca3591b3db1715f136773d62e4b9b9ede97d436c --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_iwslt_and_extract.sh @@ -0,0 +1,225 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +#echo 'Cloning Moses github repository (for tokenization scripts)...' +#git clone https://github.com/moses-smt/mosesdecoder.git + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + + +data_root=${WORKDIR_ROOT}/iwsltv2 +DESTDIR=${WORKDIR_ROOT}/ML50/raw + + +langs="ar_AR it_IT nl_XX ko_KR vi_VN" +echo "data_root: $data_root" + +download_path=${data_root}/downloads +raw=${DESTDIR} +tmp=${data_root}/tmp +orig=${data_root}/orig + +mkdir -p $download_path $orig $raw $tmp +####################### +download_iwslt(){ + iwslt_key=$1 + src=$2 + tgt=$3 + save_prefix=$4 + pushd ${download_path} + if [[ ! -f ${save_prefix}$src-$tgt.tgz ]]; then + wget https://wit3.fbk.eu/archive/${iwslt_key}/texts/$src/$tgt/$src-$tgt.tgz -O ${save_prefix}$src-$tgt.tgz + [ $? -eq 0 ] && return 0 + fi + popd +} + +extract_iwslt(){ + src=$1 + tgt=$2 + prefix=$3 + pushd $orig + tar zxvf ${download_path}/${prefix}$src-${tgt}.tgz + popd +} + +generate_train(){ + lsrc=$1 + ltgt=$2 + src=${lsrc:0:2} + tgt=${ltgt:0:2} + for ll in $lsrc $ltgt; do + l=${ll:0:2} + f="$orig/*/train.tags.$src-$tgt.$l" + f_raw=$raw/train.$lsrc-$ltgt.$ll + cat $f \ + | grep -v '' \ + | grep -v '' \ + | grep -v '' \ + | grep -v '' \ + | grep -v '' \ + | sed -e 's///g' \ + | sed -e 's/<\/title>//g' \ + | sed -e 's/<description>//g' \ + | sed -e 's/<\/description>//g' \ + | sed 's/^\s*//g' \ + | sed 's/\s*$//g' \ + > $f_raw + [ $? -eq 0 ] && echo "extracted $f to $f_raw" + done + return 0 +} + +convert_valid_test(){ + src=$1 + tgt=$2 + for l in $src $tgt; do + echo "lang: ${l}" + for o in `ls $orig/*/IWSLT*.TED*.$src-$tgt.$l.xml`; do + fname=${o##*/} + f=$tmp/${fname%.*} + echo "$o => $f" + grep '<seg id' $o \ + | sed -e 's/<seg id="[0-9]*">\s*//g' \ + | sed -e 's/\s*<\/seg>\s*//g' \ + | sed -e "s/\’/\'/g" \ + > $f + echo "" + done + done +} + +generate_subset(){ + lsrc=$1 + ltgt=$2 + src=${lsrc:0:2} + tgt=${ltgt:0:2} + subset=$3 + prefix=$4 + for ll in $lsrc $ltgt; do + l=${ll:0:2} + f=$tmp/$prefix.${src}-${tgt}.$l + if [[ -f $f ]]; then + cp $f $raw/$subset.${lsrc}-$ltgt.${ll} + fi + done +} +################# + +echo "downloading iwslt training and dev data" +# using multilingual for it, nl +download_iwslt "2017-01-trnmted" DeEnItNlRo DeEnItNlRo +download_iwslt "2017-01-trnted" ar en +download_iwslt "2017-01-trnted" en ar +download_iwslt "2017-01-trnted" ko en +download_iwslt "2017-01-trnted" en ko +download_iwslt "2015-01" vi en +download_iwslt "2015-01" en vi + +echo "donwloading iwslt test data" +download_iwslt "2017-01-mted-test" it en "test." +download_iwslt "2017-01-mted-test" en it "test." +download_iwslt "2017-01-mted-test" nl en "test." +download_iwslt "2017-01-mted-test" en nl "test." + +download_iwslt "2017-01-ted-test" ar en "test." +download_iwslt "2017-01-ted-test" en ar "test." +download_iwslt "2017-01-ted-test" ko en "test." +download_iwslt "2017-01-ted-test" en ko "test." +download_iwslt "2015-01-test" vi en "test." +download_iwslt "2015-01-test" en vi "test." + +echo "extract training data tar balls" +extract_iwslt DeEnItNlRo DeEnItNlRo +extract_iwslt ar en +extract_iwslt en ar +extract_iwslt ko en +extract_iwslt en ko +extract_iwslt vi en +extract_iwslt en vi + + +echo "extracting iwslt test data" +for lang in $langs; do + l=${lang:0:2} + extract_iwslt $l en "test." + extract_iwslt en $l "test." +done + +echo "convert dev and test data" +for lang in $langs; do + s_lang=${lang:0:2} + convert_valid_test $s_lang en + convert_valid_test en $s_lang +done + + + +echo "creating training data into $raw" +for lang in $langs; do + generate_train $lang en_XX + generate_train en_XX $lang +done + +echo "creating iwslt dev data into raw" +generate_subset en_XX vi_VN valid "IWSLT15.TED.tst2013" +generate_subset vi_VN en_XX valid "IWSLT15.TED.tst2013" + +generate_subset en_XX ar_AR valid "IWSLT17.TED.tst2016" +generate_subset ar_AR en_XX valid "IWSLT17.TED.tst2016" +generate_subset en_XX ko_KR valid "IWSLT17.TED.tst2016" +generate_subset ko_KR en_XX valid "IWSLT17.TED.tst2016" + + +generate_subset en_XX it_IT valid "IWSLT17.TED.tst2010" +generate_subset it_IT en_XX valid "IWSLT17.TED.tst2010" +generate_subset en_XX nl_XX valid "IWSLT17.TED.tst2010" +generate_subset nl_XX en_XX valid "IWSLT17.TED.tst2010" + +echo "creating iswslt test data into raw" +generate_subset en_XX vi_VN test "IWSLT15.TED.tst2015" +generate_subset vi_VN en_XX test "IWSLT15.TED.tst2015" + +generate_subset en_XX ar_AR test "IWSLT17.TED.tst2017" +generate_subset ar_AR en_XX test "IWSLT17.TED.tst2017" +generate_subset en_XX ko_KR test "IWSLT17.TED.tst2017" +generate_subset ko_KR en_XX test "IWSLT17.TED.tst2017" + +generate_subset en_XX it_IT test "IWSLT17.TED.tst2017.mltlng" +generate_subset it_IT en_XX test "IWSLT17.TED.tst2017.mltlng" +generate_subset en_XX nl_XX test "IWSLT17.TED.tst2017.mltlng" +generate_subset nl_XX en_XX test "IWSLT17.TED.tst2017.mltlng" + +# normalze iwslt directions into x-en +pushd $raw +for lang in $langs; do + for split in test valid; do + x_en_f1=$split.$lang-en_XX.en_XX + x_en_f2=$split.$lang-en_XX.${lang} + + en_x_f1=$split.en_XX-$lang.en_XX + en_x_f2=$split.en_XX-$lang.${lang} + + if [ -f $en_x_f1 ] && [ ! -f $x_en_f1 ]; then + echo "cp $en_x_f1 $x_en_f1" + cp $en_x_f1 $x_en_f1 + fi + if [ -f $x_en_f2 ] && [ ! -f $x_en_f2 ]; then + echo "cp $en_x_f2 $x_en_f2" + cp $en_x_f2 $x_en_f2 + fi + done +done +popd \ No newline at end of file diff --git a/fairseq/examples/multilingual/data_scripts/download_lotus.sh b/fairseq/examples/multilingual/data_scripts/download_lotus.sh new file mode 100644 index 0000000000000000000000000000000000000000..c08c701314a8e575637deff78381ab02c2ef6728 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_lotus.sh @@ -0,0 +1,46 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + +SRCDIR=$WORKDIR_ROOT/indic_languages_corpus +DESTDIR=${WORKDIR_ROOT}/ML50/raw/ +mkdir -p $SRCDIR +mkdir -p $DESTDIR + +cd $SRCDIR +wget http://lotus.kuee.kyoto-u.ac.jp/WAT/indic-multilingual/indic_languages_corpus.tar.gz +tar -xvzf indic_languages_corpus.tar.gz + +SRC_EXTRACT_DIR=$SRCDIR/indic_languages_corpus/bilingual + +cp $SRC_EXTRACT_DIR/ml-en/train.ml $DESTDIR/train.ml_IN-en_XX.ml_IN +cp $SRC_EXTRACT_DIR/ml-en/train.en $DESTDIR/train.ml_IN-en_XX.en_XX +cp $SRC_EXTRACT_DIR/ml-en/dev.ml $DESTDIR/valid.ml_IN-en_XX.ml_IN +cp $SRC_EXTRACT_DIR/ml-en/dev.en $DESTDIR/valid.ml_IN-en_XX.en_XX +cp $SRC_EXTRACT_DIR/ml-en/test.ml $DESTDIR/test.ml_IN-en_XX.ml_IN +cp $SRC_EXTRACT_DIR/ml-en/test.en $DESTDIR/test.ml_IN-en_XX.en_XX + +cp $SRC_EXTRACT_DIR/ur-en/train.ur $DESTDIR/train.ur_PK-en_XX.ur_PK +cp $SRC_EXTRACT_DIR/ur-en/train.en $DESTDIR/train.ur_PK-en_XX.en_XX +cp $SRC_EXTRACT_DIR/ur-en/dev.ur $DESTDIR/valid.ur_PK-en_XX.ur_PK +cp $SRC_EXTRACT_DIR/ur-en/dev.en $DESTDIR/valid.ur_PK-en_XX.en_XX +cp $SRC_EXTRACT_DIR/ur-en/test.ur $DESTDIR/test.ur_PK-en_XX.ur_PK +cp $SRC_EXTRACT_DIR/ur-en/test.en $DESTDIR/test.ur_PK-en_XX.en_XX + +cp $SRC_EXTRACT_DIR/te-en/train.te $DESTDIR/train.te_IN-en_XX.te_IN +cp $SRC_EXTRACT_DIR/te-en/train.en $DESTDIR/train.te_IN-en_XX.en_XX +cp $SRC_EXTRACT_DIR/te-en/dev.te $DESTDIR/valid.te_IN-en_XX.te_IN +cp $SRC_EXTRACT_DIR/te-en/dev.en $DESTDIR/valid.te_IN-en_XX.en_XX +cp $SRC_EXTRACT_DIR/te-en/test.te $DESTDIR/test.te_IN-en_XX.te_IN +cp $SRC_EXTRACT_DIR/te-en/test.en $DESTDIR/test.te_IN-en_XX.en_XX diff --git a/fairseq/examples/multilingual/data_scripts/download_ted_and_extract.py b/fairseq/examples/multilingual/data_scripts/download_ted_and_extract.py new file mode 100644 index 0000000000000000000000000000000000000000..eb756680fa7dc31a14ba45c216776a6d60c16b60 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_ted_and_extract.py @@ -0,0 +1,338 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import itertools +import os +import csv +from collections import defaultdict +from six.moves import zip +import io +import wget +import sys + +from subprocess import check_call, check_output + +# scripts and data locations +CWD = os.getcwd() +UTILS = f"{CWD}/utils" + +MOSES = f"{UTILS}/mosesdecoder" + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + + +# please donwload mosesdecoder here: +detok_cmd = f'{MOSES}/scripts/tokenizer/detokenizer.perl' + + +def call(cmd): + print(f"Executing: {cmd}") + check_call(cmd, shell=True) + +class MultiLingualAlignedCorpusReader(object): + """A class to read TED talk dataset + """ + + def __init__(self, corpus_path, delimiter='\t', + target_token=True, bilingual=True, corpus_type='file', + lang_dict={'source': ['fr'], 'target': ['en']}, + eval_lang_dict=None, zero_shot=False, + detok=True, + ): + + self.empty_line_flag = 'NULL' + self.corpus_path = corpus_path + self.delimiter = delimiter + self.bilingual = bilingual + self.lang_dict = lang_dict + self.lang_set = set() + self.target_token = target_token + self.zero_shot = zero_shot + self.eval_lang_dict = eval_lang_dict + self.corpus_type = corpus_type + self.detok = detok + + for list_ in self.lang_dict.values(): + for lang in list_: + self.lang_set.add(lang) + + self.data = dict() + self.data['train'] = self.read_aligned_corpus(split_type='train') + self.data['test'] = self.read_aligned_corpus(split_type='test') + self.data['dev'] = self.read_aligned_corpus(split_type='dev') + + def read_data(self, file_loc_): + data_list = list() + with io.open(file_loc_, 'r', encoding='utf8') as fp: + for line in fp: + try: + text = line.strip() + except IndexError: + text = self.empty_line_flag + data_list.append(text) + return data_list + + def filter_text(self, dict_): + if self.target_token: + field_index = 1 + else: + field_index = 0 + data_dict = defaultdict(list) + list1 = dict_['source'] + list2 = dict_['target'] + for sent1, sent2 in zip(list1, list2): + try: + src_sent = ' '.join(sent1.split()[field_index: ]) + except IndexError: + src_sent = 'NULL' + + if src_sent.find(self.empty_line_flag) != -1 or len(src_sent) == 0: + continue + + elif sent2.find(self.empty_line_flag) != -1 or len(sent2) == 0: + continue + + else: + data_dict['source'].append(sent1) + data_dict['target'].append(sent2) + return data_dict + + def read_file(self, split_type, data_type): + return self.data[split_type][data_type] + + def save_file(self, path_, split_type, data_type, lang): + tok_file = tok_file_name(path_, lang) + with io.open(tok_file, 'w', encoding='utf8') as fp: + for line in self.data[split_type][data_type]: + fp.write(line + '\n') + if self.detok: + de_tok(tok_file, lang) + + def add_target_token(self, list_, lang_id): + new_list = list() + token = '__' + lang_id + '__' + for sent in list_: + new_list.append(token + ' ' + sent) + return new_list + + def read_from_single_file(self, path_, s_lang, t_lang): + data_dict = defaultdict(list) + with io.open(path_, 'r', encoding='utf8') as fp: + reader = csv.DictReader(fp, delimiter='\t', quoting=csv.QUOTE_NONE) + for row in reader: + data_dict['source'].append(row[s_lang]) + data_dict['target'].append(row[t_lang]) + + if self.target_token: + text = self.add_target_token(data_dict['source'], t_lang) + data_dict['source'] = text + + return data_dict['source'], data_dict['target'] + + def read_aligned_corpus(self, split_type='train'): + data_dict = defaultdict(list) + iterable = [] + s_list = [] + t_list = [] + + if self.zero_shot: + if split_type == "train": + iterable = zip(self.lang_dict['source'], self.lang_dict['target']) + else: + iterable = zip(self.eval_lang_dict['source'], self.eval_lang_dict['target']) + + elif self.bilingual: + iterable = itertools.product(self.lang_dict['source'], self.lang_dict['target']) + + for s_lang, t_lang in iterable: + if s_lang == t_lang: + continue + if self.corpus_type == 'file': + split_type_file_path = os.path.join(self.corpus_path, + "all_talks_{}.tsv".format(split_type)) + s_list, t_list = self.read_from_single_file(split_type_file_path, + s_lang=s_lang, + t_lang=t_lang) + data_dict['source'] += s_list + data_dict['target'] += t_list + new_data_dict = self.filter_text(data_dict) + return new_data_dict + + +def read_langs(corpus_path): + split_type_file_path = os.path.join(corpus_path, 'extracted', + "all_talks_dev.tsv") + with io.open(split_type_file_path, 'r', encoding='utf8') as fp: + reader = csv.DictReader(fp, delimiter='\t', quoting=csv.QUOTE_NONE) + header = next(reader) + return [k for k in header.keys() if k != 'talk_name'] + +def extra_english(corpus_path, split): + split_type_file_path = os.path.join(corpus_path, + f"all_talks_{split}.tsv") + output_split_type_file_path = os.path.join(corpus_path, + f"all_talks_{split}.en") + with io.open(split_type_file_path, 'r', encoding='utf8') as fp, io.open(output_split_type_file_path, 'w', encoding='utf8') as fw: + reader = csv.DictReader(fp, delimiter='\t', quoting=csv.QUOTE_NONE) + for row in reader: + line = row['en'] + fw.write(line + '\n') + de_tok(output_split_type_file_path, 'en') + + + +def tok_file_name(filename, lang): + seps = filename.split('.') + seps.insert(-1, 'tok') + tok_file = '.'.join(seps) + return tok_file + +def de_tok(tok_file, lang): + # seps = tok_file.split('.') + # seps.insert(-1, 'detok') + # de_tok_file = '.'.join(seps) + de_tok_file = tok_file.replace('.tok.', '.') + cmd = 'perl {detok_cmd} -l {lang} < {tok_file} > {de_tok_file}'.format( + detok_cmd=detok_cmd, tok_file=tok_file, + de_tok_file=de_tok_file, lang=lang[:2]) + call(cmd) + +def extra_bitex( + ted_data_path, + lsrc_lang, + ltrg_lang, + target_token, + output_data_path, +): + def get_ted_lang(lang): + long_langs = ['pt-br', 'zh-cn', 'zh-tw', 'fr-ca'] + if lang[:5] in long_langs: + return lang[:5] + elif lang[:4] =='calv': + return lang[:5] + elif lang in ['pt_BR', 'zh_CN', 'zh_TW', 'fr_CA']: + return lang.lower().replace('_', '-') + return lang[:2] + src_lang = get_ted_lang(lsrc_lang) + trg_lang = get_ted_lang(ltrg_lang) + train_lang_dict={'source': [src_lang], 'target': [trg_lang]} + eval_lang_dict = {'source': [src_lang], 'target': [trg_lang]} + + obj = MultiLingualAlignedCorpusReader(corpus_path=ted_data_path, + lang_dict=train_lang_dict, + target_token=target_token, + corpus_type='file', + eval_lang_dict=eval_lang_dict, + zero_shot=False, + bilingual=True) + + os.makedirs(output_data_path, exist_ok=True) + lsrc_lang = lsrc_lang.replace('-', '_') + ltrg_lang = ltrg_lang.replace('-', '_') + obj.save_file(output_data_path + f"/train.{lsrc_lang}-{ltrg_lang}.{lsrc_lang}", + split_type='train', data_type='source', lang=src_lang) + obj.save_file(output_data_path + f"/train.{lsrc_lang}-{ltrg_lang}.{ltrg_lang}", + split_type='train', data_type='target', lang=trg_lang) + + obj.save_file(output_data_path + f"/test.{lsrc_lang}-{ltrg_lang}.{lsrc_lang}", + split_type='test', data_type='source', lang=src_lang) + obj.save_file(output_data_path + f"/test.{lsrc_lang}-{ltrg_lang}.{ltrg_lang}", + split_type='test', data_type='target', lang=trg_lang) + + obj.save_file(output_data_path + f"/valid.{lsrc_lang}-{ltrg_lang}.{lsrc_lang}", + split_type='dev', data_type='source', lang=src_lang) + obj.save_file(output_data_path + f"/valid.{lsrc_lang}-{ltrg_lang}.{ltrg_lang}", + split_type='dev', data_type='target', lang=trg_lang) + + +def bar_custom(current, total, width=80): + print("Downloading: %d%% [%d / %d] Ks" % (current / total * 100, current / 1000, total / 1000), end='\r') + + +def download_and_extract(download_to, extract_to): + url = 'http://phontron.com/data/ted_talks.tar.gz' + filename = f"{download_to}/ted_talks.tar.gz" + if os.path.exists(filename): + print(f'{filename} has already been downloaded so skip') + else: + filename = wget.download(url, filename, bar=bar_custom) + if os.path.exists(f'{extract_to}/all_talks_train.tsv'): + print(f'Already extracted so skip') + else: + extract_cmd = f'tar xzfv "{filename}" -C "{extract_to}"' + call(extract_cmd) + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument('--ted_data_path', type=str, default=WORKDIR_ROOT, required=False) + parser.add_argument( + '--direction-list', + type=str, + # default=None, + #for ML50 + default=( + "bn_IN-en_XX,he_IL-en_XX,fa_IR-en_XX,id_ID-en_XX,sv_SE-en_XX,pt_XX-en_XX,ka_GE-en_XX,ka_GE-en_XX,th_TH-en_XX," + "mr_IN-en_XX,hr_HR-en_XX,uk_UA-en_XX,az_AZ-en_XX,mk_MK-en_XX,gl_ES-en_XX,sl_SI-en_XX,mn_MN-en_XX," + #non-english directions + # "fr_XX-de_DE," # replaced with wmt20 + # "ja_XX-ko_KR,es_XX-pt_XX,ru_RU-sv_SE,hi_IN-bn_IN,id_ID-ar_AR,cs_CZ-pl_PL,ar_AR-tr_TR" + ), + required=False) + parser.add_argument('--target-token', action='store_true', default=False) + parser.add_argument('--extract-all-english', action='store_true', default=False) + + args = parser.parse_args() + + import sys + import json + + # TED Talks data directory + ted_data_path = args.ted_data_path + + download_to = f'{ted_data_path}/downloads' + extract_to = f'{ted_data_path}/extracted' + + #DESTDIR=${WORKDIR_ROOT}/ML50/raw/ + output_path = f'{ted_data_path}/ML50/raw' + os.makedirs(download_to, exist_ok=True) + os.makedirs(extract_to, exist_ok=True) + os.makedirs(output_path, exist_ok=True) + download_and_extract(download_to, extract_to) + + + if args.extract_all_english: + for split in ['train', 'dev', 'test']: + extra_english(ted_data_path, split) + exit(0) + if args.direction_list is not None: + directions = args.direction_list.strip().split(',') + directions = [tuple(d.strip().split('-', 1)) for d in directions if d] + else: + langs = read_langs(ted_data_path) + # directions = [ + # '{}.{}'.format(src, tgt) + # for src in langs + # for tgt in langs + # if src < tgt + # ] + directions = [('en', tgt) for tgt in langs if tgt != 'en'] + print(f'num directions={len(directions)}: {directions}') + + for src_lang, trg_lang in directions: + print('--working on {}-{}'.format(src_lang, trg_lang)) + extra_bitex( + extract_to, + src_lang, + trg_lang, + target_token=args.target_token, + output_data_path=output_path + ) diff --git a/fairseq/examples/multilingual/data_scripts/download_wat19_my.sh b/fairseq/examples/multilingual/data_scripts/download_wat19_my.sh new file mode 100644 index 0000000000000000000000000000000000000000..c1e2d47287a29af4576e7a63641e8152ecb63c44 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_wat19_my.sh @@ -0,0 +1,36 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + +SRCDIR=$WORKDIR_ROOT/indic_languages_corpus +DESTDIR=$WORKDIR_ROOT/ML50/raw +mkdir -p $SRCDIR +mkdir -p $DESTDIR + +WAT_MY_EN=wat2020.my-en.zip +cd $SRCDIR +# please refer to http://lotus.kuee.kyoto-u.ac.jp/WAT/my-en-data/ for latest URL if the following url expired +#- The data used for WAT2020 are identical to those used in WAT2019. +wget http://lotus.kuee.kyoto-u.ac.jp/WAT/my-en-data/$WAT_MY_EN +unzip $WAT_MY_EN + + +SRC_EXTRACT_DIR=$SRCDIR/wat2020.my-en/alt + +cp $SRC_EXTRACT_DIR/train.alt.en $DESTDIR/train.my_MM-en_XX.en_XX +cp $SRC_EXTRACT_DIR/train.alt.my $DESTDIR/train.my_MM-en_XX.my_MM +cp $SRC_EXTRACT_DIR/dev.alt.en $DESTDIR/valid.my_MM-en_XX.en_XX +cp $SRC_EXTRACT_DIR/dev.alt.my $DESTDIR/valid.my_MM-en_XX.my_MM +cp $SRC_EXTRACT_DIR/test.alt.en $DESTDIR/test.my_MM-en_XX.en_XX +cp $SRC_EXTRACT_DIR/test.alt.my $DESTDIR/test.my_MM-en_XX.my_MM diff --git a/fairseq/examples/multilingual/data_scripts/download_wmt19_and_before.py b/fairseq/examples/multilingual/data_scripts/download_wmt19_and_before.py new file mode 100644 index 0000000000000000000000000000000000000000..3465731eb3e55047c44d1b336a97e99cb3a89a53 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_wmt19_and_before.py @@ -0,0 +1,899 @@ +from typing import NamedTuple, List +from urllib.parse import urlparse +import os, sys +import subprocess +from subprocess import check_call, check_output +import glob +import wget +import re +import multiprocessing as mp +from functools import partial +import pathlib +from collections import OrderedDict + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + +# scripts and data locations +CWD = os.getcwd() +UTILS = f"{CWD}/utils" + +MOSES = f"{UTILS}/mosesdecoder" +SGM_TOOL = f'{MOSES}/scripts/ems/support/input-from-sgm.perl' + +TMX2CORPUS = f"{UTILS}/tmx2corpus" +TMX_TOOL = f'python {TMX2CORPUS}/tmx2corpus.py' + +to_data_path = f'{WORKDIR_ROOT}/wmt' +download_to = f'{to_data_path}/downloads' +manually_downloads = f'{to_data_path}/downloads' +extract_to = f'{to_data_path}/extracted' +#DESTDIR=${WORKDIR_ROOT}/ML50/raw/ +raw_data = f'{WORKDIR_ROOT}/ML50/raw' +#### + +class DLDataset(NamedTuple): + name: str + train_urls: List[str] + valid_urls: List[str] + test_urls: List[str] + train_files_patterns: List[str] = [] + valid_files_patterns: List[str] = [] + test_files_patterns: List[str] = [] + + + +def bar_custom(current, total, width=80): + print("Downloading: %d%% [%d / %d] Ks" % (current / total * 100, current / 1000, total / 1000), end='\r') + +def get_downloaded_file(dl_folder, url): + if isinstance(url, tuple): + url, f = url + else: + url_f = urlparse(url) + # f = os.path.split(url_f.path)[-1] + f = '_'.join(url_f.path.split('/')[1:]) + return url, f"{dl_folder}/{f}" + +def download_parts_and_combine(dl_folder, urls, filename): + parts = [] + for url_record in urls: + url, part_file = get_downloaded_file(dl_folder, url_record) + if os.path.exists(part_file): + print(f'{part_file} has already been downloaded so skip') + else: + part_file = wget.download(url, part_file, bar=bar_custom) + parts.append(part_file) + + def get_combine_cmd(parts): + #default as tar.gz.?? + return f'cat {" ".join(parts)} > {filename}' + + combine_cmd = get_combine_cmd(parts) + call(combine_cmd, debug=True) + return filename + +def download_a_url(dl_folder, url): + url, filename = get_downloaded_file(dl_folder, url) + if os.path.exists(filename): + print(f'{filename} has already been downloaded so skip') + return filename + + print(f'downloading {url} to {filename}') + if isinstance(url, list) or isinstance(url, tuple): + download_parts_and_combine(dl_folder, url, filename) + else: + wget.download(url, filename, bar=bar_custom) + print(f'dowloaded: {filename}') + return filename + +def download_files(dl_folder, urls, completed_urls={}): + for url_record in urls: + url, _ = get_downloaded_file(dl_folder, url_record) + filename = download_a_url(dl_folder, url_record) + completed_urls[str(url)] = filename + return completed_urls + +def check_need_manual_downalod(dl_folder, to_manually_download_urls): + to_be_manually_dowloaded = [] + manually_completed_urls = {} + for url_record, instruction in to_manually_download_urls: + url, filename = get_downloaded_file(dl_folder, url_record) + if not os.path.exists(filename): + print(f'{url} need to be download manually, please download it manually following {instruction}; and copy it to {filename}') + to_be_manually_dowloaded.append((url, filename)) + else: + manually_completed_urls[url] = filename + # if len(to_be_manually_dowloaded) > 0: + # raise ValueError('Missing files that need to be downloaded manually; stop the process now.') + return to_be_manually_dowloaded + +def download_dataset(to_folder, dl_dataset, completed_urls={}): + download_files(to_folder, dl_dataset.train_urls, completed_urls) + download_files(to_folder, dl_dataset.valid_urls, completed_urls) + download_files(to_folder, dl_dataset.test_urls, completed_urls) + print('completed downloading') + return completed_urls + +def call(cmd, debug=False): + if debug: + print(cmd) + check_call(cmd, shell=True) + + +def get_extract_name(file_path): + path = os.path.split(file_path) + return path[-1] + '_extract' #.split('.')[0] + +def extract_file(downloaded_file, extract_folder, get_extract_name=get_extract_name, debug=False): + extract_name = get_extract_name(downloaded_file) + extract_to = f'{extract_folder}/{extract_name}' + os.makedirs(extract_to, exist_ok=True) + if os.path.exists(f'{extract_to}/DONE'): + print(f'{downloaded_file} has already been extracted to {extract_to} so skip') + return extract_to + def get_extract_cmd(filename): + if filename.endswith('.tgz') or filename.endswith('tar.gz'): + return f'tar xzfv {filename} -C {extract_to}' + elif filename.endswith('.gz.tar'): + return f'tar xfv {filename} -C {extract_to}; (cd {extract_to}; gzip -d *.gz; [ $? -eq 0 ] || gzip -d */*.gz)' + elif filename.endswith('.tar'): + return f'tar xfv {filename} -C {extract_to}' + elif filename.endswith('.gz'): + return f'cp {filename} {extract_to}; (cd {extract_to}; gzip -d *.gz)' + elif filename.endswith('.zip'): + return f'unzip {filename} -d {extract_to}' + extract_cmd = get_extract_cmd(downloaded_file) + print(f'extracting {downloaded_file}') + if isinstance(extract_cmd, list): + for c in extract_cmd: + call(c, debug=debug) + else: + call(extract_cmd, debug=debug) + call(f'echo DONE > {extract_to}/DONE') + return extract_to + + +def extract_all_files( + completed_urls, extract_folder, + get_extract_name=get_extract_name, + completed_extraction={}, + debug=False): + extracted_folders = OrderedDict() + for url, downloaded_file in set(completed_urls.items()): + if downloaded_file in completed_extraction: + print(f'{downloaded_file} is already extracted; so skip') + continue + folder = extract_file(downloaded_file, extract_folder, get_extract_name, debug) + extracted_folders[url] = folder + return extracted_folders + + +def my_glob(folder): + for p in [f'{folder}/*', f'{folder}/*/*', f'{folder}/*/*/*']: + for f in glob.glob(p): + yield f + + +def sgm2raw(sgm, debug): + to_file = sgm[0:len(sgm) - len('.sgm')] + if os.path.exists(to_file): + debug and print(f'{sgm} already converted to {to_file}; so skip') + return to_file + cmd = f'{SGM_TOOL} < {sgm} > {to_file}' + call(cmd, debug) + return to_file + +def tmx2raw(tmx, debug): + to_file = tmx[0:len(tmx) - len('.tmx')] + to_folder = os.path.join(*os.path.split(tmx)[:-1]) + if os.path.exists(f'{to_folder}/bitext.en'): + debug and print(f'{tmx} already extracted to {to_file}; so skip') + return to_file + cmd = f'(cd {to_folder}; {TMX_TOOL} {tmx})' + call(cmd, debug) + return to_file + +CZENG16_REGEX = re.compile(r'.*?data.plaintext-format/0[0-9]train$') +WMT19_WIKITITLES_REGEX = re.compile(r'.*?wikititles-v1.(\w\w)-en.tsv.gz') +TSV_REGEX = re.compile(r'.*?(\w\w)-(\w\w).tsv$') + + + +def cut_wikitles(wiki_file, debug): + # different languages have different file names: + if wiki_file.endswith('wiki/fi-en/titles.fi-en'): + to_file1 = f'{wiki_file}.fi' + to_file2 = f'{wiki_file}.en' + BACKSLASH = '\\' + cmd1 = f"cat {wiki_file} | sed 's/|||/{BACKSLASH}t/g' |cut -f1 |awk '{{$1=$1}};1' > {to_file1}" + cmd2 = f"cat {wiki_file} | sed 's/|||/{BACKSLASH}t/g' |cut -f2 |awk '{{$1=$1}};1' > {to_file2}" +# elif WMT19_WIKITITLES_REGEX.match(wiki_file): +# src = WMT19_WIKITITLES_REGEX.match(wiki_file).groups()[0] +# to_file1 = f'{wiki_file}.{src}' +# to_file2 = f'{wiki_file}.en' +# cmd1 = f"cat {wiki_file} | cut -f1 |awk '{{$1=$1}};1' > {to_file1}" +# cmd2 = f"cat {wiki_file} | cut -f2 |awk '{{$1=$1}};1' > {to_file2}" + else: + return None + if os.path.exists(to_file1) and os.path.exists(to_file2): + debug and print(f'{wiki_file} already processed to {to_file1} and {to_file2}; so skip') + return wiki_file + + call(cmd1, debug=debug) + call(cmd2, debug=debug) + return wiki_file + +def cut_tsv(file, debug): + m = TSV_REGEX.match(file) + if m is None: + raise ValueError(f'{file} is not matching tsv pattern') + src = m.groups()[0] + tgt = m.groups()[1] + + to_file1 = f'{file}.{src}' + to_file2 = f'{file}.{tgt}' + cmd1 = f"cat {file} | cut -f1 |awk '{{$1=$1}};1' > {to_file1}" + cmd2 = f"cat {file} | cut -f2 |awk '{{$1=$1}};1' > {to_file2}" + if os.path.exists(to_file1) and os.path.exists(to_file2): + debug and print(f'{file} already processed to {to_file1} and {to_file2}; so skip') + return file + + call(cmd1, debug=debug) + call(cmd2, debug=debug) + return file + + +def convert_file_if_needed(file, debug): + if file.endswith('.sgm'): + return sgm2raw(file, debug) + elif file.endswith('.tmx'): + return tmx2raw(file, debug) + elif file.endswith('wiki/fi-en/titles.fi-en'): + return cut_wikitles(file, debug) +# elif WMT19_WIKITITLES_REGEX.match(file): +# return cut_wikitles(file, debug) + elif file.endswith('.tsv'): + return cut_tsv(file, debug) + elif CZENG16_REGEX.match(file): + return convert2czeng17(file, debug) + else: + return file + + +def convert_files_if_needed(extracted_foldrs, my_glob=my_glob, debug=False): + return { + url: list(sorted(set(convert_file_if_needed(f, debug)) for f in sorted(set(my_glob(folder))))) + for url, folder in extracted_foldrs.items() + } + +def match_patt(file_path, file_pattern, src, tgt, lang): + return file_pattern.format(src=src, tgt=tgt, lang=lang) in file_path + +def match_patts(file_path, file_patterns, src, tgt, lang): + for file_pattern in file_patterns: + params = { k: v for k, v in [('src', src), ('tgt', tgt), ('lang', lang)] if k in file_pattern} + matching = file_pattern.format(**params) + + if isinstance(file_pattern, tuple): + pattern, directions = file_pattern + if f'{src}-{tgt}' in directions and matching in file_path: + return True + else: + if matching in file_path: + return True + return False + +def extracted_glob(extracted_folder, file_patterns, src, tgt, lang): + def get_matching_pattern(file_pattern): + params = { + k: v + for k, v in [('src', src), ('tgt', tgt), ('lang', lang)] + if '{' + k + '}' in file_pattern + } + file_pattern = re.sub(r'{src:(.*?)}', r'\1' if lang == src else '', file_pattern) + file_pattern = re.sub(r'{tgt:(.*?)}', r'\1' if lang == tgt else '', file_pattern) + file_pattern = file_pattern.format(**params) + return file_pattern + for file_pattern in file_patterns: + if isinstance(file_pattern, tuple): + file_pattern, lang_pairs = file_pattern + if f'{src}-{tgt}' not in lang_pairs: + continue +# print('working on pattern: ', file_pattern, lang_pairs ) + matching_pattern = get_matching_pattern(file_pattern) + if matching_pattern is None: + continue + glob_patterns = f'{extracted_folder}/{matching_pattern}' +# print('glob_patterns: ', glob_patterns) + for f in glob.glob(glob_patterns): + yield f + +# for debug usage +def all_extracted_files(split, src, tgt, extracted_folders, split_urls): + def get_url(url): + if isinstance(url, tuple): + url, downloaded_file = url + return url + return [ + f + for url in split_urls + for f in my_glob(extracted_folders[str(get_url(url))]) + ] + +def concat_files(split, src, tgt, extracted_folders, split_urls, path_patterns, to_folder, debug=False): +# if debug: +# print('extracted files to be filtered by patterns: ', +# '\n\t'.join(sorted(all_extracted_files(split, src, tgt, extracted_folders, split_urls)))) + for lang in [src, tgt]: + to_file = f'{to_folder}/{split}.{src}-{tgt}.{lang}' + s_src, s_tgt, s_lang = src.split('_')[0], tgt.split('_')[0], lang.split('_')[0] + files = [] + for url in split_urls: + if isinstance(url, tuple): + url, downloaded_file = url + if str(url) not in extracted_folders: + print(f'warning: {url} not in extracted files') + for extracted_file in set( + extracted_glob( + extracted_folders[str(url)], path_patterns, + s_src, s_tgt, s_lang)): + files.append(extracted_file) + if len(files) == 0: + print('warning: ', f'No files found for split {to_file}') + continue + files = sorted(set(files)) + print(f'concating {len(files)} files into {to_file}') + cmd = ['cat'] + [f'"{f}"' for f in files] + [f'>{to_file}'] + cmd = " ".join(cmd) + call(cmd, debug=debug) + +UTILS = os.path.join(pathlib.Path(__file__).parent, 'utils') +LID_MODEL = f'{download_to}/lid.176.bin' +LID_MULTI = f'{UTILS}/fasttext_multi_filter.py' + +def lid_filter(split, src, tgt, from_folder, to_folder, debug=False): + if not os.path.exists(LID_MODEL): + call(f'wget -nc https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin -O {LID_MODEL}') + from_prefix = f'{from_folder}/{split}.{src}-{tgt}' + to_prefix = f'{to_folder}/{split}.{src}-{tgt}' + if os.path.exists(f'{from_prefix}.{src}') and os.path.exists(f'{from_prefix}.{tgt}'): + s_src, s_tgt = src.split('_')[0], tgt.split('_')[0] + cmd = ( + f'python {LID_MULTI} --model {LID_MODEL} --inputs {from_prefix}.{src} {from_prefix}.{tgt} ' + f'--langs {s_src} {s_tgt} --outputs {to_prefix}.{src} {to_prefix}.{tgt}' + ) + print(f'filtering {from_prefix}') + call(cmd, debug=debug) + +def concat_into_splits(dl_dataset, src, tgt, extracted_folders, to_folder, debug): + to_folder_tmp = f"{to_folder}_tmp" + os.makedirs(to_folder_tmp, exist_ok=True) + concat_files('train', src, tgt, + extracted_folders, + split_urls=dl_dataset.train_urls, + path_patterns=dl_dataset.train_files_patterns, + to_folder=to_folder_tmp, debug=debug) + lid_filter('train', src, tgt, to_folder_tmp, to_folder, debug) + + concat_files('valid', src, tgt, + extracted_folders, + split_urls=dl_dataset.valid_urls, + path_patterns=dl_dataset.valid_files_patterns, + to_folder=to_folder, debug=debug) + concat_files('test', src, tgt, + extracted_folders, + split_urls=dl_dataset.test_urls, + path_patterns=dl_dataset.test_files_patterns, + to_folder=to_folder, debug=debug) + + +def download_multi(dl_folder, extract_folder, urls, num_processes=8, debug=False): + pool = mp.Pool(processes=num_processes) + download_f = partial(download_a_url, dl_folder) + downloaded_files = pool.imap_unordered(download_f, urls) + pool.close() + pool.join() + +BLEU_REGEX = re.compile("^BLEU\\S* = (\\S+) ") +def run_eval_bleu(cmd): + output = check_output(cmd, shell=True, stderr=subprocess.STDOUT).decode("utf-8").strip() + print(output) + bleu = -1.0 + for line in output.strip().split('\n'): + m = BLEU_REGEX.search(line) + if m is not None: + bleu = m.groups()[0] + bleu = float(bleu) + break + return bleu + +def check_wmt_test_bleu(raw_folder, wmt_lang_pairs): + not_matchings = [] + for wmt, src_tgts in wmt_lang_pairs: + for src_tgt in src_tgts: + print(f'checking test bleus for: {src_tgt} at {wmt}') + src, tgt = src_tgt.split('-') + ssrc, stgt = src[:2], tgt[:2] + if os.path.exists(f'{raw_folder}/test.{tgt}-{src}.{src}'): + # reversed direction may have different test set + test_src = f'{raw_folder}/test.{tgt}-{src}.{src}' + else: + test_src = f'{raw_folder}/test.{src}-{tgt}.{src}' + cmd1 = f'cat {test_src} | sacrebleu -t "{wmt}" -l {stgt}-{ssrc}; [ $? -eq 0 ] || echo ""' + test_tgt = f'{raw_folder}/test.{src}-{tgt}.{tgt}' + cmd2 = f'cat {test_tgt} | sacrebleu -t "{wmt}" -l {ssrc}-{stgt}; [ $? -eq 0 ] || echo ""' + bleu1 = run_eval_bleu(cmd1) + if bleu1 != 100.0: + not_matchings.append(f'{wmt}:{src_tgt} source side not matching: {test_src}') + bleu2 = run_eval_bleu(cmd2) + if bleu2 != 100.0: + not_matchings.append(f'{wmt}:{src_tgt} target side not matching: {test_tgt}') + return not_matchings + +def download_and_extract( + to_folder, lang_pairs, dl_dataset, + to_manually_download_urls, + completed_urls={}, completed_extraction={}, + debug=False): + + dl_folder = f'{to_folder}/downloads' + extract_folder = f'{to_folder}/extracted' + raw_folder = f'{to_folder}/raw' + lid_filtered = f'{to_folder}/lid_filtered' + + os.makedirs(extract_folder, exist_ok=True) + os.makedirs(raw_folder, exist_ok=True) + os.makedirs(lid_filtered, exist_ok=True) + + + to_be_manually_dowloaded = check_need_manual_downalod(dl_folder, to_manually_download_urls) + + completed_urls = download_dataset( + dl_folder, dl_dataset, completed_urls) + if debug: + print('completed urls: ', completed_urls) + + + extracted_folders = extract_all_files( + completed_urls, + extract_folder=extract_folder, + completed_extraction=completed_extraction, + debug=debug) + if debug: + print('download files have been extracted to folders: ', extracted_folders) + + converted_files = convert_files_if_needed(extracted_folders, debug=False) + for src_tgt in lang_pairs: + print(f'working on {dl_dataset.name}: {src_tgt}') + src, tgt = src_tgt.split('-') + concat_into_splits(dl_dataset, + src=src, tgt=tgt, + extracted_folders=extracted_folders, + to_folder=raw_folder, debug=debug) + print('completed data into: ', raw_folder) + +def download_czang16(download_to, username=None): + wgets = [ + f'wget --user={username} --password=czeng -P {download_to} http://ufallab.ms.mff.cuni.cz/~bojar/czeng16-data/data-plaintext-format.{i}.tar' + for i in range(10)] + cmds = [] + for i, cmd in enumerate(wgets): + filename = f'{download_to}/data-plaintext-format.{i}.tar' + if os.path.exists(filename): + print(f'{filename} has already been downloaded; so skip') + continue + cmds.append(cmd) + if cmds and username is None: + raise ValueError('No czeng username is given; please register at http://ufal.mff.cuni.cz/czeng/czeng16 to obtain username to download') + for cmd in cmds: + call(cmd) + print('done with downloading czeng1.6') + +def download_czeng17_script(download_to, extract_folder, debug=False): + url = 'http://ufal.mff.cuni.cz/czeng/download.php?f=convert_czeng16_to_17.pl.zip' + filename = f'{download_to}/convert_czeng16_to_17.pl.zip' + extract_to = f'{extract_folder}/{get_extract_name(filename)}' + script_path = f'{extract_to}/convert_czeng16_to_17.pl' + + if not os.path.exists(script_path): + wget.download(url, filename, bar=bar_custom) + extract_to = extract_file(f'{download_to}/convert_czeng16_to_17.pl.zip', extract_folder, get_extract_name=get_extract_name, debug=debug) + return script_path + +czeng17_script_path = "" +def convert2czeng17(file, debug): + en_file = f'{file}.en' + cs_file = f'{file}.cs' + + if not os.path.exists(en_file) or not os.path.exists(cs_file): + cs_cmd = f'cat {file} | perl {czeng17_script_path} | cut -f3 > {cs_file}' + en_cmd = f'cat {file} | perl {czeng17_script_path} | cut -f4 > {en_file}' + call(cs_cmd, debug) + call(en_cmd, debug) + else: + print(f'already extracted: {en_file} and {cs_file}') + return file + +def extract_czeng17(extract_folder, debug=False): + url = 'http://ufal.mff.cuni.cz/czeng/download.php?f=convert_czeng16_to_17.pl.zip' + filename = f'{download_to}/convert_czeng16_to_17.pl.zip' + extract_to = f'{extract_folder}/{get_extract_name(filename)}' + script_path = f'{extract_to}/convert_czeng16_to_17.pl' + + if not os.path.exists(script_path): + wget.download(url, filename, bar=bar_custom) + extract_to = extract_file(f'{download_to}/convert_czeng16_to_17.pl.zip', extract_folder, get_extract_name=get_extract_name, debug=debug) + return script_path + +######### +# definitions of wmt data sources +# for es-en +# Punctuation in the official test sets will be encoded with ASCII characters (not complex Unicode characters) as much as possible. You may want to normalize your system's output before submission. You are able able to use a rawer version of the test sets that does not have this normalization. +# script to normalize punctuation: http://www.statmt.org/wmt11/normalize-punctuation.perl +wmt13_es_en = DLDataset( + name='wmt13_es-en', + train_urls=[ + 'http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz', + 'http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz', + 'http://www.statmt.org/wmt13/training-parallel-un.tgz', + 'http://www.statmt.org/wmt13/training-parallel-nc-v8.tgz', + ], + valid_urls=[ + ('http://www.statmt.org/wmt13/dev.tgz', 'wmt13_dev.tgz') + ], + test_urls=[ + ('http://www.statmt.org/wmt13/test.tgz', 'wmt13_test.tgz') + ], + train_files_patterns=[ + ('*/europarl-v7.{src}-{tgt}.{lang}', ['es-en']), + ('*commoncrawl.{src}-{tgt}.{lang}', ['es-en']), + ('*/news-commentary-v8.{src}-{tgt}.{lang}', ['es-en']), + ('un/*undoc.2000.{src}-{tgt}.{lang}', ['es-en']), + ] , + valid_files_patterns=[ + ('dev/newstest2012.{lang}', ['es-en']) + ], + test_files_patterns=[ + ('test/newstest*.{lang}', ['es-en']) + ], +) + +wmt14_de_fr_en = DLDataset( + name='wmt14_de_fr_en', + train_urls=[ + 'http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz', + 'http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz', + 'http://www.statmt.org/wmt13/training-parallel-un.tgz', + 'http://www.statmt.org/wmt14/training-parallel-nc-v9.tgz', + ('http://www.statmt.org/wmt10/training-giga-fren.tar', 'training-giga-fren.gz.tar'), #it is actuall a gz.tar + ], + valid_urls=[ + ('http://www.statmt.org/wmt14/dev.tgz', 'wmt14_dev.tgz'), + ], + test_urls=[ + ('http://www.statmt.org/wmt14/test-full.tgz', 'wmt14_test_full.tgz'), # cleaned test sets + ], + train_files_patterns=[ + ('*/europarl-v7.{src}-{tgt}.{lang}', ['fr-en', 'de-en']), + ('*commoncrawl.{src}-{tgt}.{lang}', ['fr-en', 'de-en']), + ('*/*news-commentary-v9.{src}-{tgt}.{lang}', ['fr-en', 'de-en']), + ('un/undoc.2000.{src}-{tgt}.{lang}', ['fr-en']), + ('*giga-{src}{tgt}*{lang}', ['fr-en']) + ], + valid_files_patterns=[ + ('dev/newstest2013.{lang}', ['fr-en', 'de-en']) + ], + test_files_patterns=[ + ('test-full/newstest*{src}{tgt}-{src:src}{tgt:ref}.{lang}', ['en-de', 'de-en', 'fr-en', 'en-fr']), + ], +) + +# pip install git+https://github.com/amake/tmx2corpus.git +wmt16_ro_en = DLDataset( + name='wmt16_ro-en', + train_urls=[ + ('http://data.statmt.org/wmt16/translation-task/training-parallel-ep-v8.tgz', 'wmt16_training-parallel-ep-v8.tgz'), + ('http://opus.nlpl.eu/download.php?f=SETIMES/v2/tmx/en-ro.tmx.gz', 'en-ro.tmx.gz'), + ], + valid_urls=[ + ('http://data.statmt.org/wmt16/translation-task/dev-romanian-updated.tgz', 'wmt16_dev.tgz') + ], + test_urls=[ + ('http://data.statmt.org/wmt16/translation-task/test.tgz', 'wmt16_test.tgz') + ], + train_files_patterns=[ + ('*/*europarl-v8.{src}-{tgt}.{lang}', ['ro-en']), + ('bitext.{lang}', ['ro-en']) #setimes from tmux + ] , + valid_files_patterns=[ + ('dev/newsdev2016*{src}{tgt}*.{lang}', ['ro-en', 'ro-en']) + ], + test_files_patterns=[ + ('test/newstest*{src}{tgt}*.{lang}', ['ro-en', 'en-ro']) + ], +) + +cwmt_wmt_instruction = 'cwmt download instruction at: http://nlp.nju.edu.cn/cwmt-wmt' +wmt17_fi_lv_tr_zh_en_manual_downloads = [ + # fake urls to have unique keys for the data + ( ('http://nlp.nju.edu.cn/cwmt-wmt/CASIA2015.zip', 'CASIA2015.zip'), cwmt_wmt_instruction), + ( ('http://nlp.nju.edu.cn/cwmt-wmt/CASICT2011.zip', 'CASICT2011.zip'), cwmt_wmt_instruction), + ( ('http://nlp.nju.edu.cn/cwmt-wmt/CASICT2015.zip', 'CASICT2015.zip'), cwmt_wmt_instruction), + ( ('http://nlp.nju.edu.cn/cwmt-wmt/Datum2015.zip', 'Datum2015.zip'), cwmt_wmt_instruction), + ( ('http://nlp.nju.edu.cn/cwmt-wmt/Datum2017.zip', 'Datum2017.zip'), cwmt_wmt_instruction), + ( ('http://nlp.nju.edu.cn/cwmt-wmt/NEU2017.zip', 'NEU2017.zip'), cwmt_wmt_instruction), +] +wmt17_fi_lv_tr_zh_en = DLDataset( + name='wmt17_fi_lv_tr_zh_en', + train_urls=[ + ('http://data.statmt.org/wmt17/translation-task/training-parallel-ep-v8.tgz', 'wmt17_training-parallel-ep-v8.tgz'), + 'http://data.statmt.org/wmt17/translation-task/training-parallel-nc-v12.tgz', + 'http://www.statmt.org/wmt15/wiki-titles.tgz', + ('http://opus.nlpl.eu/download.php?f=SETIMES/v2/tmx/en-tr.tmx.gz', 'en-tr.tmx.gz'), + ('http://data.statmt.org/wmt17/translation-task/rapid2016.tgz', 'wmt17_rapid2016.tgz'), + 'http://data.statmt.org/wmt17/translation-task/leta.v1.tgz', + 'http://data.statmt.org/wmt17/translation-task/dcep.lv-en.v1.tgz', + 'http://data.statmt.org/wmt17/translation-task/books.lv-en.v1.tgz', + (('https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.00', + 'https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.01',), 'UNv1.0.en-zh.tar.gz'), + #manually download files: + ('http://nlp.nju.edu.cn/cwmt-wmt/CASIA2015.zip', 'CASIA2015.zip'), + ('http://nlp.nju.edu.cn/cwmt-wmt/CASICT2011.zip', 'CASICT2011.zip'), + ('http://nlp.nju.edu.cn/cwmt-wmt/CASICT2015.zip', 'CASICT2015.zip'), + ('http://nlp.nju.edu.cn/cwmt-wmt/Datum2015.zip', 'Datum2015.zip'), + ('http://nlp.nju.edu.cn/cwmt-wmt/Datum2017.zip', 'Datum2017.zip'), + ('http://nlp.nju.edu.cn/cwmt-wmt/NEU2017.zip', 'NEU2017.zip'), + ], + valid_urls=[ + ('http://data.statmt.org/wmt17/translation-task/dev.tgz', 'wmt17_dev.tgz'), + ], + test_urls=[ + #NEW: Improved translations for zh test sets + ('http://data.statmt.org/wmt17/translation-task/test-update-1.tgz', 'wmt17_test_zh_en.tgz'), + ('http://data.statmt.org/wmt17/translation-task/test.tgz', 'wmt17_test_others.tgz') + ], + train_files_patterns=[ + ('casict*/cas*{src:ch}{tgt:en}.txt', ['zh-en', 'zh-en'] ), + ('casia*/cas*{src:ch}{tgt:en}.txt', ['zh-en', 'zh-en'] ), + ('dataum*/Book*{src:cn}{tgt:en}.txt', ['zh-en', 'zh-en']), + ('neu*/NEU*{src:cn}{tgt:en}.txt', ['zh-en', 'zh-en'] ), + ('*/*UNv1.0.en-zh.{src:zh}{tgt:en}', ['zh-en']), + ('training/*news-commentary-v12.{src}-{tgt}.{lang}', ['zh-en', ]), + + ('*/*europarl-v8.{src}-{tgt}.{lang}', ['fi-en', 'lv-en']), + ('wiki/fi-en/titles.{src}-{tgt}.{lang}', ['fi-en', ]), + ('rapid2016.{tgt}-{src}.{lang}', ['fi-en', 'lv-en']), + ('*/leta.{lang}', ['lv-en']), + ('*/dcep.{lang}', ['lv-en']), + ('*/farewell.{lang}', ['lv-en']), + ('bitext.{lang}', ['tr-en']), + ] , + valid_files_patterns=[ + ('dev/newsdev2017*{src}{tgt}-{src:src}{tgt:ref}.{lang}', + [ + 'fi-en', 'lv-en', 'tr-en', 'zh-en', + 'en-fi', 'en-lv', 'en-tr', 'en-zh' + ]), + ('dev/newstest2016*{src}{tgt}-{src:src}{tgt:ref}.{lang}', + [ + 'fi-en', 'tr-en', + 'en-fi', 'en-tr', + ]), + ], + test_files_patterns=[ + ('test/newstest2017-{src}{tgt}-{src:src}{tgt:ref}.{lang}', + [ + 'fi-en', 'lv-en', 'tr-en', + 'en-fi', 'en-lv', 'en-tr', + ]), + ('newstest2017-{src}{tgt}-{src:src}{tgt:ref}.{lang}', + [ + 'zh-en', + 'en-zh' + ]), + ], +) + +czeng_instruction = 'download instruction at: http://ufal.mff.cuni.cz/czeng/czeng16' +#alternative: use the prepared data but detokenize it? +wmt18_cs_et_en_manual_downloads = [ +#for cs, need to register and download; Register and download CzEng 1.6. +#Better results can be obtained by using a subset of sentences, released under a new version name CzEng 1.7. + # ((f'http://ufallab.ms.mff.cuni.cz/~bojar/czeng16-data/data-plaintext-format.{i}.tar', + # f'data-plaintext-format.{i}.tar'), czeng_instruction) + # for i in range(10) +] + +wmt18_cs_et_en = DLDataset( + name='wmt18_cs_et_en', + train_urls=[ + 'http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz', + 'http://data.statmt.org/wmt18/translation-task/training-parallel-ep-v8.tgz', + 'https://s3.amazonaws.com/web-language-models/paracrawl/release1/paracrawl-release1.en-cs.zipporah0-dedup-clean.tgz', + 'https://s3.amazonaws.com/web-language-models/paracrawl/release1/paracrawl-release1.en-et.zipporah0-dedup-clean.tgz', + 'http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz', + 'http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz', + ('http://data.statmt.org/wmt18/translation-task/rapid2016.tgz', 'wmt18_rapid2016.tgz'), + # (tuple( + # (f'http://ufallab.ms.mff.cuni.cz/~bojar/czeng16-data/data-plaintext-format.{i}.tar', + # f'data-plaintext-format.{i}.tar') + # for i in range(10) + # ), + # 'czeng16_data_plaintext.gz.tar'), + ], + valid_urls=[ + ('http://data.statmt.org/wmt18/translation-task/dev.tgz', 'wmt18_dev.tgz'), + ], + test_urls=[ + ('http://data.statmt.org/wmt18/translation-task/test.tgz', 'wmt18_test.tgz'), + ], + train_files_patterns=[ + # ('*/*europarl-v7.{src}-{tgt}.{lang}', ['cs-en']), + ('*/*europarl-v8.{src}-{tgt}.{lang}', ['et-en']), + # ('*paracrawl-release1.{tgt}-{src}.zipporah0-dedup-clean.{lang}', ['cs-en', 'et-en']), + ('*paracrawl-release1.{tgt}-{src}.zipporah0-dedup-clean.{lang}', ['et-en']), + # ('*commoncrawl.{src}-{tgt}.{lang}', ['cs-en']), + # ('*/news-commentary-v13.{src}-{tgt}.{lang}', ['cs-en']), + # ('data.plaintext-format/*train.{lang}', ['cs-en']), + ('rapid2016.{tgt}-{src}.{lang}', ['et-en']), + ] , + valid_files_patterns=[ + ('dev/newsdev2018*{src}{tgt}-{src:src}{tgt:ref}.{lang}', ['et-en']), + # ('dev/newstest2017*{src}{tgt}-{src:src}{tgt:ref}.{lang}', ['cs-en']) + ], + test_files_patterns=[ + ('test/newstest2018-{src}{tgt}-{src:src}{tgt:ref}.{lang}', + # ['cs-en', 'et-en']), + ['et-en']), + ] +) + +ru_en_yandex_instruction = 'Yandex Corpus download instruction at: https://translate.yandex.ru/corpus?lang=en' +wmt19_ru_gu_kk_lt_manual_downloads = [ + (('https://translate.yandex.ru/corpus?lang=en', 'wmt19_1mcorpus.zip'), ru_en_yandex_instruction) +] +wmt19_ru_gu_kk_lt = DLDataset( + name='wmt19_ru_gu_kk_lt', + train_urls=[ + 'http://www.statmt.org/europarl/v9/training/europarl-v9.lt-en.tsv.gz', + 'https://s3.amazonaws.com/web-language-models/paracrawl/release3/en-lt.bicleaner07.tmx.gz', + 'https://s3.amazonaws.com/web-language-models/paracrawl/release1/paracrawl-release1.en-ru.zipporah0-dedup-clean.tgz', + 'http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz', + 'http://data.statmt.org/news-commentary/v14/training/news-commentary-v14-wmt19.en-kk.tsv.gz', + 'http://data.statmt.org/news-commentary/v14/training/news-commentary-v14.en-ru.tsv.gz', + 'http://data.statmt.org/wikititles/v1/wikititles-v1.kk-en.tsv.gz', + 'http://data.statmt.org/wikititles/v1/wikititles-v1.ru-en.tsv.gz', + 'http://data.statmt.org/wikititles/v1/wikititles-v1.kk-en.tsv.gz', + 'http://data.statmt.org/wikititles/v1/wikititles-v1.lt-en.tsv.gz', + 'http://data.statmt.org/wikititles/v1/wikititles-v1.gu-en.tsv.gz', + (('https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.00', + 'https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.01', + 'https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.02',), + 'wmt19_UNv1.0.en-ru.tar.gz'), + 'https://tilde-model.s3-eu-west-1.amazonaws.com/rapid2016.en-lt.tmx.zip', + ('https://translate.yandex.ru/corpus?lang=en', 'wmt19_1mcorpus.zip'), + ], + valid_urls=[ + ('http://data.statmt.org/wmt19/translation-task/dev.tgz', 'wmt19_dev.tgz'), + ], + test_urls=[ + ('http://data.statmt.org/wmt19/translation-task/test.tgz', 'wmt19_test.tgz'), + ], + train_files_patterns=[ + ('*europarl-v9.{src}-{tgt}.tsv.{lang}', ['lt-en']), + #paracrawl + ('*paracrawl-release1.{tgt}-{src}.zipporah0-dedup-clean.{lang}', ['ru-en']), + ('bitext.{lang}', ['lt-en',]), + ('*commoncrawl.{src}-{tgt}.{lang}', ['ru-en',]), + ('*news-commentary-v14-wmt19.{tgt}-{src}.tsv.{lang}', ['kk-en', ]), + ('*news-commentary-v14.{tgt}-{src}.tsv.{lang}', ['ru-en']), + #yandex + ('corpus.{tgt}_{src}.1m.{lang}', ['ru-en']), + ('wikititles_v1_wikititles-v1.{src}-{tgt}.tsv.{lang}', ['ru-en', 'kk-en', 'lt-en', 'gu-en']), + ('*/UNv1.0.{tgt}-{src}.{lang}', ['ru-en']), + #rapid + ('bitext.{lang}', ['lt-en']) + ], + valid_files_patterns=[ + ('dev/newsdev2019*{src}{tgt}-{src:src}{tgt:ref}.{lang}', ['gu-en', 'kk-en', 'lt-en']), + ('dev/newstest2018*{src}{tgt}-{src:src}{tgt:ref}.{lang}', ['ru-en']), + ], + test_files_patterns=[ + ('sgm/newstest2019-{src}{tgt}-{src:src}{tgt:ref}.{lang}', + ['ru-en', 'gu-en', 'kk-en', 'lt-en', 'en-ru', 'en-gu', 'en-kk', 'en-lt']), + ] +) + + +######### + +if __name__ == "__main__": + # speed up the downloads with multiple processing + dl_folder = f'{to_data_path}/downloads' + extract_folder = f'{to_data_path}/extracted' + + urls = [ + url + for dataset in [wmt13_es_en, wmt14_de_fr_en, wmt16_ro_en, wmt18_cs_et_en, wmt19_ru_gu_kk_lt] + for urls in [dataset.train_urls, dataset.valid_urls, dataset.test_urls] + for url in urls + ] + urls = set(urls) + download_multi(dl_folder, extract_folder, urls, num_processes=8, debug=True) + + # check manually downlaods + to_manually_download_urls = ( + wmt17_fi_lv_tr_zh_en_manual_downloads + wmt18_cs_et_en_manual_downloads + wmt19_ru_gu_kk_lt_manual_downloads + ) + to_be_manually_dowloaded = check_need_manual_downalod(dl_folder, to_manually_download_urls) + if len(to_be_manually_dowloaded) > 0: + print('Missing files that need to be downloaded manually; stop the process now.') + exit(-1) + + completed_urls = {} + completed_extraction = {} + def work_on_wmt(directions, wmt_data): + download_and_extract( + to_data_path, + directions, + wmt_data, + to_manually_download_urls=to_manually_download_urls, + completed_urls=completed_urls, completed_extraction=completed_extraction, debug=True) + + work_on_wmt( + ['es_XX-en_XX'], + wmt13_es_en,) + work_on_wmt( + [ + 'fr_XX-en_XX', 'en_XX-fr_XX', + # 'en_XX-de_DE', 'de_DE-en_XX', + ], + wmt14_de_fr_en,) + work_on_wmt( + ['ro_RO-en_XX', 'en_XX-ro_XX'], + wmt16_ro_en,) + work_on_wmt( + [ + # 'zh_CN-en_XX', + 'lv_LV-en_XX', 'fi_FI-en_XX', 'tr_TR-en_XX', + #in case the reversed directions have different train/valid/test data + # 'en_XX-zh_CN', + 'en_XX-lv_LV', 'en_XX-fi_FI', 'en_XX-tr_TR', + ], + wmt17_fi_lv_tr_zh_en, ) + # czeng17_script_path = download_czeng17_script(download_to, extract_to, debug=False) + # cz_username = None + work_on_wmt( + [ + # 'cs_CZ-en_XX', + 'et_EE-en_XX'], + wmt18_cs_et_en,) + work_on_wmt( + [ + # 'ru_RU-en_XX', 'en_XX-ru_RU', + 'gu_IN-en_XX', 'kk_KZ-en_XX', 'lt_LT-en_XX', + #in case the reversed directions have different train/valid/test data + 'en_XX-gu_IN', 'en_XX-kk_KZ', 'en_XX-lt_LT' + ], + wmt19_ru_gu_kk_lt,) + + not_matching = check_wmt_test_bleu( + f'{to_data_path}/raw', + [ + ('wmt13', ['es_XX-en_XX']), + ('wmt14/full', ['fr_XX-en_XX',]), + ('wmt16', ['ro_RO-en_XX',]), + # ('wmt17/improved', ['zh_CN-en_XX']), + ('wmt17', [ 'lv_LV-en_XX', 'fi_FI-en_XX', 'tr_TR-en_XX']), + ('wmt18', ['cs_CZ-en_XX', 'et_EE-en_XX']), + ('wmt19', ['gu_IN-en_XX', 'kk_KZ-en_XX', 'lt_LT-en_XX']), + #'ru_RU-en_XX', + ] + ) + if len(not_matching) > 0: + print('the following datasets do not have matching test datasets:\n\t', '\n\t'.join(not_matching)) + diff --git a/fairseq/examples/multilingual/data_scripts/download_wmt20.sh b/fairseq/examples/multilingual/data_scripts/download_wmt20.sh new file mode 100644 index 0000000000000000000000000000000000000000..31cd5c76b75081331ae03c5ea70ea7ddebaa06e1 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/download_wmt20.sh @@ -0,0 +1,547 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + + + +set -x -e + +# TODO update the workdir and dest dir name +# put fasttext model +WORKDIR=$WORKDIR_ROOT +# put intermediate files +TMP_DIR=$WORKDIR_ROOT/tmp/tmp_wmt20_lowres_download +# output {train,valid,test} files to dest +DEST=$WORKDIR_ROOT/ML50/raw + +UTILS=$PWD/utils + +# per dataset locations +COMMONCRAWL_DIR=$TMP_DIR/commoncrawl +YANDEX_CORPUS=$WORKDIR_ROOT/wmt20/official/ru/yandex/1mcorpus.zip +# unzipped +CZENG_CORPUS=$WORKDIR_ROOT/wmt20/official/cs/czeng/czeng20-train +CCMT_DIR=$WORKDIR_ROOT/wmt20/official/zh/ccmt/parallel + +download_and_select() { + SUBFOLDER=$1 + URL=$2 + UNCOMPRESS_CMD=$3 + LANG=$4 + INPUT_FILEPATH=$5 + if [[ $# -gt 5 ]]; then + LANG_COL=$6 + EN_COL=$7 + fi + + mkdir -p $SUBFOLDER + cd $SUBFOLDER + wget -nc --content-disposition $URL + $UNCOMPRESS_CMD + + if [[ $# -gt 5 ]]; then + cut -f$LANG_COL $INPUT_FILEPATH > $INPUT_FILEPATH.$LANG + cut -f$EN_COL $INPUT_FILEPATH > $INPUT_FILEPATH.en + fi + cd .. + + ln -sf $SUBFOLDER/$INPUT_FILEPATH.$LANG $SUBFOLDER.$LANG + ln -sf $SUBFOLDER/$INPUT_FILEPATH.en $SUBFOLDER.en +} + +prepare_lid() { + pip install fasttext + + # TODO specify global workdir + MODEL=$WORKDIR/fasttext/lid.176.bin + LID_MULTI=$UTILS/fasttext_multi_filter.py + + if [ ! -f "$MODEL" ]; then + echo "downloading fasttext lid model..." + mkdir -p $WORKDIR/fasttext + wget -nc https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin -O $MODEL + fi +} + +prepare_moses() { + pushd $UTILS + echo 'Cloning Moses github repository (for tokenization scripts)...' + git clone https://github.com/moses-smt/mosesdecoder.git + popd +} + +lid_filter() { + # TODO specify global workdir + MODEL=$WORKDIR/fasttext/lid.176.bin + LID_MULTI=$UTILS/fasttext_multi_filter.py + + prepare_lid + + SRC=$1 + SRC_FILE=$2 + SRC_OUTPUT=$3 + TGT=$4 + TGT_FILE=$5 + TGT_OUTPUT=$6 + python $LID_MULTI --model $MODEL --inputs $SRC_FILE $TGT_FILE --langs $SRC $TGT --outputs $SRC_OUTPUT $TGT_OUTPUT +} + +prepare_ja_ted() { + mkdir -p ted + cd ted + + wget -nc https://wit3.fbk.eu/archive/2017-01-trnted//texts/en/ja/en-ja.tgz + tar -zxvf en-ja.tgz + cat en-ja/train.tags.en-ja.en | grep -v -P "^[ ]*\<" | sed 's/^[ \t]*//g' | sed 's/[ \t]*$//g' > en-ja/train.en-ja.en + cat en-ja/train.tags.en-ja.ja | grep -v -P "^[ ]*\<" | sed 's/^[ \t]*//g' | sed 's/[ \t]*$//g' > en-ja/train.en-ja.ja + + cd .. + ln -sf ted/en-ja/train.en-ja.ja ted.ja + ln -sf ted/en-ja/train.en-ja.en ted.en +} + +prepare_ja() { + OUTPUT_DIR=$TMP_DIR/ja + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select paracrawl "http://www.kecl.ntt.co.jp/icl/lirg/jparacrawl/release/2.0/bitext/en-ja.tar.gz" "tar -zxvf en-ja.tar.gz" ja en-ja/en-ja.bicleaner05.txt 4 3 & + download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-ja.tsv.gz" "gunzip -f news-commentary-v15.en-ja.tsv.gz" ja news-commentary-v15.en-ja.tsv 2 1 & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ja-en.tsv.gz" "gunzip -f wikititles-v2.ja-en.tsv.gz" ja wikititles-v2.ja-en.tsv 1 2 & + download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ja.langid.tsv.gz" "gunzip -f WikiMatrix.v1.en-ja.langid.tsv.gz" ja WikiMatrix.v1.en-ja.langid.tsv 3 2 & + download_and_select subtitle "https://nlp.stanford.edu/projects/jesc/data/split.tar.gz" "tar -zxvf split.tar.gz" ja split/train 2 1 & + download_and_select kftt "http://www.phontron.com/kftt/download/kftt-data-1.0.tar.gz" "tar -zxvf kftt-data-1.0.tar.gz" ja kftt-data-1.0/data/orig/kyoto-train & + + prepare_ja_ted & + + # ted data needs to + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.ja" | sort -V | xargs cat > all.ja + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter ja all.ja $DEST/train.ja_XX-en_XX.ja_XX en all.en $DEST/train.ja_XX-en_XX.en_XX +} + +prepare_ta() { + OUTPUT_DIR=$TMP_DIR/ta + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ta-en.tsv.gz" "gunzip -f wikititles-v2.ta-en.tsv.gz" ta wikititles-v2.ta-en.tsv 1 2 & + download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ta.langid.tsv.gz" "gunzip -f WikiMatrix.v1.en-ta.langid.tsv.gz" ta WikiMatrix.v1.en-ta.langid.tsv 3 2 & + download_and_select pmindia "http://data.statmt.org/pmindia/v1/parallel/pmindia.v1.ta-en.tsv" "" ta pmindia.v1.ta-en.tsv 2 1 & + download_and_select tanzil "https://object.pouta.csc.fi/OPUS-Tanzil/v1/moses/en-ta.txt.zip" "unzip en-ta.txt.zip" ta Tanzil.en-ta & + download_and_select pib "http://preon.iiit.ac.in/~jerin/resources/datasets/pib-v0.tar" "tar -xvf pib-v0.tar" ta pib/en-ta/train & + download_and_select mkb "http://preon.iiit.ac.in/~jerin/resources/datasets/mkb-v0.tar" "tar -xvf mkb-v0.tar" ta mkb/en-ta/mkb & + download_and_select ufal "http://ufal.mff.cuni.cz/~ramasamy/parallel/data/v2/en-ta-parallel-v2.tar.gz" "tar -zxvf en-ta-parallel-v2.tar.gz" ta en-ta-parallel-v2/corpus.bcn.train & + + wait + + # need special handling for nlpc + mkdir -p nlpc + cd nlpc + wget -nc https://raw.githubusercontent.com/nlpc-uom/English-Tamil-Parallel-Corpus/master/En-Ta%20Corpus/En-Ta%20English.txt + wget -nc https://github.com/nlpc-uom/English-Tamil-Parallel-Corpus/raw/master/En-Ta%20Corpus/En-Ta%20Tamil.txt + tail -n +4 "En-Ta English.txt" > en-ta.en + tail -n +4 "En-Ta Tamil.txt" > en-ta.ta + cd .. + ln -sf nlpc/en-ta.en nlpc.en + ln -sf nlpc/en-ta.ta nlpc.ta + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.ta" | sort -V | xargs cat > all.ta + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter ta all.ta $DEST/train.ta_IN-en_XX.ta_IN en all.en $DEST/train.ta_IN-en_XX.en_XX +} + +prepare_iu() { + OUTPUT_DIR=$TMP_DIR/iu + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select nh "https://nrc-digital-repository.canada.ca/eng/view/dataset/?id=c7e34fa7-7629-43c2-bd6d-19b32bf64f60" "tar -zxvf Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0.1.tgz" iu Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0/NunavutHansard > /dev/null & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.iu-en.tsv.gz" "gunzip -f wikititles-v2.iu-en.tsv.gz" iu wikititles-v2.iu-en.tsv 1 2 & + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.iu" | sort -V | xargs cat | nh/Nunavut-Hansard-Inuktitut-English-Parallel-Corpus-3.0/scripts/normalize-iu-spelling.pl > all.iu + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + paste all.iu all.en | awk -F $'\t' '$1!=""&&$2!=""' > all.iuen + cut -f1 all.iuen > $DEST/train.iu_CA-en_XX.iu_CA + cut -f2 all.iuen > $DEST/train.iu_CA-en_XX.en_XX +} + +prepare_km() { + OUTPUT_DIR=$TMP_DIR/km + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select paracrawl "http://data.statmt.org/wmt20/translation-task/ps-km/wmt20-sent.en-km.xz" "unxz wmt20-sent.en-km.zx" km wmt20-sent.en-km 2 1 & + + # km-parallel has multiple sets, concat all of them together + mkdir -p opus + cd opus + wget -nc "http://data.statmt.org/wmt20/translation-task/ps-km/km-parallel.tgz" + tar -zxvf km-parallel.tgz + find ./km-parallel -maxdepth 1 -name "*.km" | sort -V | xargs cat > opus.km + find ./km-parallel -maxdepth 1 -name "*.en" | sort -V | xargs cat > opus.en + cd .. + ln -sf opus/opus.km . + ln -sf opus/opus.en . + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.km" | sort -V | xargs cat > all.km + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter km all.km $DEST/train.km_KH-en_XX.km_KH en all.en $DEST/train.km_KH-en_XX.en_XX +} + +prepare_ps() { + OUTPUT_DIR=$TMP_DIR/ps + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select paracrawl "http://data.statmt.org/wmt20/translation-task/ps-km/wmt20-sent.en-ps.xz" "unxz wmt20-sent.en-ps.xz" ps wmt20-sent.en-ps 2 1 & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ps-en.tsv.gz" "gunzip -f wikititles-v2.ps-en.tsv.gz" ps wikititles-v2.ps-en.tsv 1 2 & + # ps-parallel has multiple sets, concat all of them together + mkdir -p opus + cd opus + wget -nc "http://data.statmt.org/wmt20/translation-task/ps-km/ps-parallel.tgz" + tar -zxvf ps-parallel.tgz + find ./ps-parallel -maxdepth 1 -name "*.ps" | sort -V | xargs cat > opus.ps + find ./ps-parallel -maxdepth 1 -name "*.en" | sort -V | xargs cat > opus.en + cd .. + ln -sf opus/opus.ps opus.ps + ln -sf opus/opus.en opus.en + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.ps" | sort -V | xargs cat > all.ps + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter ps all.ps $DEST/train.ps_AF-en_XX.ps_AF en all.en $DEST/train.ps_AF-en_XX.en_XX +} + +download_commoncrawl() { + mkdir -p $COMMONCRAWL_DIR + cd $COMMONCRAWL_DIR + + wget -nc "http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz" + tar -zxvf training-parallel-commoncrawl.tgz +} +link_commoncrawl() { + LANG=$1 + ln -sf $COMMONCRAWL_DIR/commoncrawl.$LANG-en.en commoncrawl.en + ln -sf $COMMONCRAWL_DIR/commoncrawl.$LANG-en.$LANG commoncrawl.$LANG +} + +strip_xlf() { + INPUT_FILE=$1 + SRC=$2 + TGT=$3 + grep '<source xml:lang=' $INPUT_FILE | sed 's/^<[^<>]*>//g' | sed 's/<[^<>]*>$//g' > $INPUT_FILE.$SRC + grep '<target xml:lang=' $INPUT_FILE | sed 's/^<[^<>]*>//g' | sed 's/<[^<>]*>$//g' > $INPUT_FILE.$TGT +} + +download_and_process_tilde() { + URL=$1 + UNCOMPRESS_CMD=$2 + FILENAME=$3 + LANG=$4 + PROCESS_CMD=$5 + + mkdir -p tilde + cd tilde + wget -nc $URL + $UNCOMPRESS_CMD + echo "executing cmd" + echo $PROCESS_CMD + $PROCESS_CMD + cd .. + ln -sf tilde/$FILENAME.$LANG tilde.$LANG + ln -sf tilde/$FILENAME.en tilde.en +} + +prepare_cs() { + OUTPUT_DIR=$TMP_DIR/cs + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + #download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.cs-en.tsv.gz" "gunzip europarl-v10.cs-en.tsv.gz" cs europarl-v10.cs-en.tsv 1 2 & + #download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-cs.txt.gz" "gunzip en-cs.txt.gz" cs en-cs.txt 2 1 & + #link_commoncrawl cs + #download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.cs-en.tsv.gz" "gunzip news-commentary-v15.cs-en.tsv.gz" cs news-commentary-v15.cs-en.tsv 1 2 & + #download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.cs-en.tsv.gz" "gunzip wikititles-v2.cs-en.tsv.gz" cs wikititles-v2.cs-en.tsv 1 2 & + #download_and_process_tilde "http://data.statmt.org/wmt20/translation-task/rapid/RAPID_2019.cs-en.xlf.gz" "gunzip RAPID_2019.cs-en.xlf.gz" RAPID_2019.cs-en.xlf cs "strip_xlf RAPID_2019.cs-en.xlf cs en" & + #download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.cs-en.langid.tsv.gz" "gunzip WikiMatrix.v1.cs-en.langid.tsv.gz" cs WikiMatrix.v1.cs-en.langid.tsv 2 3 & + + #wait + + # remove previous results + #rm -f all.?? + #find ./ -maxdepth 1 -name "*.cs" | sort -V | xargs cat > all.cs + #find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + if [ -z $CZENG_CORPUS ] ; + then + echo "Please download CZENG_CORPUS manually and place them at $CZENG_CORPUS. Exitting..." + exit + fi + cat $CZENG_CORPUS | sed '/^$/d' | cut -f5 > all.cs + cat $CZENG_CORPUS | sed '/^$/d' | cut -f6 > all.en + + lid_filter cs all.cs $DEST/train.cs_CZ-en_XX.cs_CZ en all.en $DEST/train.cs_CZ-en_XX.en_XX +} + +prepare_de() { + OUTPUT_DIR=$TMP_DIR/de + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.de-en.tsv.gz" "gunzip europarl-v10.de-en.tsv.gz" de europarl-v10.de-en.tsv 1 2 & + download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-de.txt.gz" "gunzip en-de.txt.gz" de en-de.txt 2 1 & + link_commoncrawl de + download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.de-en.tsv.gz" "gunzip news-commentary-v15.de-en.tsv.gz" de news-commentary-v15.de-en.tsv 1 2 & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.de-en.tsv.gz" "gunzip wikititles-v2.de-en.tsv.gz" de wikititles-v2.de-en.tsv 1 2 & + download_and_process_tilde "http://data.statmt.org/wmt20/translation-task/rapid/RAPID_2019.de-en.xlf.gz" "gunzip RAPID_2019.de-en.xlf.gz" RAPID_2019.de-en.xlf de "strip_xlf RAPID_2019.de-en.xlf de en" & + download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.de-en.langid.tsv.gz" "gunzip WikiMatrix.v1.de-en.langid.tsv.gz" de WikiMatrix.v1.de-en.langid.tsv 2 3 & + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.de" | sort -V | xargs cat > all.de + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter de all.de $DEST/train.de_DE-en_XX.de_DE en all.en $DEST/train.de_DE-en_XX.en_XX +} + +prepare_tmx() { + TMX_FILE=$1 + git clone https://github.com/amake/TMX2Corpus $UTILS/tmx2corpus + pip install tinysegmenter + + python $UTILS/tmx2corpus/tmx2corpus.py $TMX_FILE +} + +prepare_pl() { + OUTPUT_DIR=$TMP_DIR/pl + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + # download_and_select europarl "http://www.statmt.org/europarl/v10/training/europarl-v10.pl-en.tsv.gz" "gunzip europarl-v10.pl-en.tsv.gz" pl europarl-v10.pl-en.tsv 1 2 & + # download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release5.1/en-pl.txt.gz" "gunzip en-pl.txt.gz" pl en-pl.txt 2 1 & + # download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.pl-en.tsv.gz" "gunzip wikititles-v2.pl-en.tsv.gz" pl wikititles-v2.pl-en.tsv 1 2 & + download_and_select tilde "https://tilde-model.s3-eu-west-1.amazonaws.com/rapid2019.en-pl.tmx.zip" "gunzip rapid2019.en-pl.tmx.zip" bitext pl "prepare_tmx RAPID_2019.UNIQUE.en-pl.tmx" & + # download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-pl.langid.tsv.gz" "gunzip WikiMatrix.v1.en-pl.langid.tsv.gz" pl WikiMatrix.v1.en-pl.langid.tsv 3 2 & + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.pl" | sort -V | xargs cat > all.pl + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter pl all.pl $DEST/train.pl_PL-en_XX.pl_PL en all.en $DEST/train.pl_PL-en_XX.en_XX +} + +prepare_uncorpus() { + $URLS=$1 + $FILES=$2 + + mkdir -p uncorpus + cd uncorpus + + for URL in $URLS; do + wget -nc $URL + done + cat $FILES > uncorpus.tar.gz + tar -zxvf uncorpus.tar.gz + + cd .. + ln -sf uncorpus/en-$LANG/UNv1.0.en-$LANG.$LANG uncorpus.$LANG + ln -sf uncorpus/en-$LANG/UNv1.0.en-$LANG.en uncorpus.en +} + +prepare_yandex() { + mkdir -p yandex + cd yandex + unzip $YANDEX_CORPUS ./ + cd .. + ln -s yandex/corpus.en_ru.1m.en yandex.en + ln -s yandex/corpus.en_ru.1m.ru yandex.ru +} + +prepare_ru() { + OUTPUT_DIR=$TMP_DIR/ru + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select paracrawl "https://s3.amazonaws.com/web-language-models/paracrawl/release1/paracrawl-release1.en-ru.zipporah0-dedup-clean.tgz" "tar -zxvf paracrawl-release1.en-ru.zipporah0-dedup-clean.tgz" ru paracrawl-release1.en-ru.zipporah0-dedup-clean & + link_commoncrawl ru + download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-ru.tsv.gz" "gunzip news-commentary-v15.en-ru.tsv.gz" ru news-commentary-v15.en-ru.tsv 2 1 & + prepare_yandex & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.ru-en.tsv.gz" "gunzip wikititles-v2.ru-en.tsv.gz" ru wikititles-v2.ru-en.tsv 1 2 & + prepare_uncorpus "https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.00 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.01 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-ru.tar.gz.02" "UNv1.0.en-ru.tar.gz.00 UNv1.0.en-ru.tar.gz.01 UNv1.0.en-ru.tar.gz.02" & + download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-ru.langid.tsv.gz" "gunzip WikiMatrix.v1.en-ru.langid.tsv.gz" ru WikiMatrix.v1.en-ru.langid.tsv 3 2 & + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.ru" | sort -V | xargs cat > all.ru + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter ru all.ru $DEST/train.ru_RU-en_XX.ru_RU en all.en $DEST/train.ru_RU-en_XX.en_XX +} + +prepare_ccmt() { + mkdir -p ccmt + cd ccmt + # assume ccmt data is already unzipped under CCMT_DIR folder + cat $CCMT_DIR/datum2017/Book*_cn.txt | sed 's/ //g' > datum2017.detok.zh + cat $CCMT_DIR/datum2017/Book*_en.txt > datum2017.detok.en + cat $CCMT_DIR/casict2011/casict-A_ch.txt $CCMT_DIR/casict2011/casict-B_ch.txt $CCMT_DIR/casict2015/casict2015_ch.txt $CCMT_DIR/datum2015/datum_ch.txt $CCMT_DIR/neu2017/NEU_cn.txt datum2017.detok.zh > ccmt.zh + cat $CCMT_DIR/casict2011/casict-A_en.txt $CCMT_DIR/casict2011/casict-B_en.txt $CCMT_DIR/casict2015/casict2015_en.txt $CCMT_DIR/datum2015/datum_en.txt $CCMT_DIR/neu2017/NEU_en.txt datum2017.detok.en > ccmt.en + cd .. + ln -sf ccmt/ccmt.zh ccmt.zh + ln -sf ccmt/ccmt.en ccmt.en +} + +prepare_zh() { + OUTPUT_DIR=$TMP_DIR/zh + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + + download_and_select newscommentary "http://data.statmt.org/news-commentary/v15/training/news-commentary-v15.en-zh.tsv.gz" "gunzip news-commentary-v15.en-zh.tsv.gz" zh news-commentary-v15.en-zh.tsv 2 1 & + download_and_select wikititles "http://data.statmt.org/wikititles/v2/wikititles-v2.zh-en.tsv.gz" "gunzip wikititles-v2.zh-en.tsv.gz" zh wikititles-v2.zh-en.tsv 1 2 & + prepare_uncorpus "https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.00 https://stuncorpusprod.blob.core.windows.net/corpusfiles/UNv1.0.en-zh.tar.gz.01" "UNv1.0.en-zh.tar.gz.00 UNv1.0.en-zh.tar.gz.01" & + prepare_ccmt & + download_and_select wikimatrix "http://data.statmt.org/wmt20/translation-task/WikiMatrix/WikiMatrix.v1.en-zh.langid.tsv.gz" "gunzip WikiMatrix.v1.en-zh.langid.tsv.gz" zh WikiMatrix.v1.en-zh.langid.tsv 3 2 & + + wait + + # remove previous results + rm -f all.?? + find ./ -maxdepth 1 -name "*.zh" | sort -V | xargs cat > all.zh + find ./ -maxdepth 1 -name "*.en" | sort -V | xargs cat > all.en + lid_filter zh all.zh $DEST/train.zh_CN-en_XX.zh_CN en all.en $DEST/train.zh_CN-en_XX.en_XX +} + +prepare_tests() { + OUTPUT_DIR=$TMP_DIR + mkdir -p $OUTPUT_DIR + cd $OUTPUT_DIR + wget -nc http://data.statmt.org/wmt20/translation-task/dev.tgz + tar -zxvf dev.tgz + cd dev + + cat newsdev2020-jaen-src.ja.sgm | $UTILS/strip_sgm.sh > newsdev2020-jaen.ja + cat newsdev2020-jaen-ref.en.sgm | $UTILS/strip_sgm.sh > newsdev2020-jaen.en + split newsdev2020-jaen.ja -a 0 -n r/1/2 > $DEST/valid.ja_XX-en_XX.ja_XX + split newsdev2020-jaen.en -a 0 -n r/1/2 > $DEST/valid.ja_XX-en_XX.en_XX + split newsdev2020-jaen.ja -a 0 -n r/2/2 > $DEST/test.ja_XX-en_XX.ja_XX + split newsdev2020-jaen.en -a 0 -n r/2/2 > $DEST/test.ja_XX-en_XX.en_XX + + cat newsdev2020-iuen-src.iu.sgm | strip_sgm.sh > newsdev2020-iuen.iu + cat newsdev2020-iuen-ref.en.sgm | strip_sgm.sh > newsdev2020-iuen.en + split newsdev2020-iuen.iu -a 0 -n r/1/2 > $DEST/valid.iu_CA-en_XX.iu_CA + split newsdev2020-iuen.en -a 0 -n r/1/2 > $DEST/valid.iu_CA-en_XX.en_XX + split newsdev2020-iuen.iu -a 0 -n r/2/2 > $DEST/test.iu_CA-en_XX.iu_CA + split newsdev2020-iuen.en -a 0 -n r/2/2 > $DEST/test.iu_CA-en_XX.en_XX + + cat newsdev2020-taen-src.ta.sgm | strip_sgm.sh > newsdev2020-taen.ta + cat newsdev2020-taen-ref.en.sgm | strip_sgm.sh > newsdev2020-taen.en + split newsdev2020-taen.ta -a 0 -n r/1/2 > $DEST/valid.ta_IN-en_XX.ta_IN + split newsdev2020-taen.en -a 0 -n r/1/2 > $DEST/valid.ta_IN-en_XX.en_XX + split newsdev2020-taen.ta -a 0 -n r/2/2 > $DEST/test.ta_IN-en_XX.ta_IN + split newsdev2020-taen.en -a 0 -n r/2/2 > $DEST/test.ta_IN-en_XX.en_XX + + cp wikipedia.dev.km-en.km $DEST/valid.km_KH-en_XX.km_KH + cp wikipedia.dev.km-en.en $DEST/valid.km_KH-en_XX.en_XX + cp wikipedia.devtest.km-en.km $DEST/test.km_KH-en_XX.km_KH + cp wikipedia.devtest.km-en.en $DEST/test.km_KH-en_XX.en_XX + + cp wikipedia.dev.ps-en.ps $DEST/valid.ps_AF-en_XX.ps_AF + cp wikipedia.dev.ps-en.en $DEST/valid.ps_AF-en_XX.en_XX + cp wikipedia.devtest.ps-en.ps $DEST/test.ps_AF-en_XX.ps_AF + cp wikipedia.devtest.ps-en.en $DEST/test.ps_AF-en_XX.en_XX + + cat newsdev2020-plen-src.pl.sgm | strip_sgm.sh > newsdev2020-plen.pl + cat newsdev2020-plen-ref.en.sgm | strip_sgm.sh > newsdev2020-plen.en + split newsdev2020-plen.pl -a 0 -n r/1/2 > $DEST/valid.pl_PL-en_XX.pl_PL + split newsdev2020-plen.en -a 0 -n r/1/2 > $DEST/valid.pl_PL-en_XX.en_XX + split newsdev2020-plen.pl -a 0 -n r/2/2 > $DEST/test.pl_PL-en_XX.pl_PL + split newsdev2020-plen.en -a 0 -n r/2/2 > $DEST/test.pl_PL-en_XX.en_XX + + cat newstest2018-encs-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-cs_CZ.en_XX + cat newstest2018-encs-ref.cs.sgm | strip_sgm.sh > $DEST/valid.en_XX-cs_CZ.cs_CZ + cat newstest2019-encs-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-cs_CZ.en_XX + cat newstest2019-encs-ref.cs.sgm | strip_sgm.sh > $DEST/test.en_XX-cs_CZ.cs_CZ + + cat newstest2018-deen-src.de.sgm | strip_sgm.sh > $DEST/valid.de_DE-en_XX.de_DE + cat newstest2018-deen-ref.en.sgm | strip_sgm.sh > $DEST/valid.de_DE-en_XX.en_XX + cat newstest2018-ende-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-de_DE.en_XX + cat newstest2018-ende-ref.de.sgm | strip_sgm.sh > $DEST/valid.en_XX-de_DE.de_DE + cat newstest2019-deen-src.de.sgm | strip_sgm.sh > $DEST/test.de_DE-en_XX.de_DE + cat newstest2019-deen-ref.en.sgm | strip_sgm.sh > $DEST/test.de_DE-en_XX.en_XX + cat newstest2019-ende-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-de_DE.en_XX + cat newstest2019-ende-ref.de.sgm | strip_sgm.sh > $DEST/test.en_XX-de_DE.de_DE + + cat newstest2018-ruen-src.ru.sgm | strip_sgm.sh > $DEST/valid.ru_RU-en_XX.ru_RU + cat newstest2018-ruen-ref.en.sgm | strip_sgm.sh > $DEST/valid.ru_RU-en_XX.en_XX + cat newstest2018-enru-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-ru_RU.en_XX + cat newstest2018-enru-ref.ru.sgm | strip_sgm.sh > $DEST/valid.en_XX-ru_RU.ru_RU + cat newstest2019-ruen-src.ru.sgm | strip_sgm.sh > $DEST/test.ru_RU-en_XX.ru_RU + cat newstest2019-ruen-ref.en.sgm | strip_sgm.sh > $DEST/test.ru_RU-en_XX.en_XX + cat newstest2019-enru-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-ru_RU.en_XX + cat newstest2019-enru-ref.ru.sgm | strip_sgm.sh > $DEST/test.en_XX-ru_RU.ru_RU + + cat newstest2018-zhen-src.zh.sgm | strip_sgm.sh > $DEST/valid.zh_CN-en_XX.zh_CN + cat newstest2018-zhen-ref.en.sgm | strip_sgm.sh > $DEST/valid.zh_CN-en_XX.en_XX + cat newstest2018-enzh-src.en.sgm | strip_sgm.sh > $DEST/valid.en_XX-zh_CN.en_XX + cat newstest2018-enzh-ref.zh.sgm | strip_sgm.sh > $DEST/valid.en_XX-zh_CN.zh_CN + cat newstest2019-zhen-src.zh.sgm | strip_sgm.sh > $DEST/test.zh_CN-en_XX.zh_CN + cat newstest2019-zhen-ref.en.sgm | strip_sgm.sh > $DEST/test.zh_CN-en_XX.en_XX + cat newstest2019-enzh-src.en.sgm | strip_sgm.sh > $DEST/test.en_XX-zh_CN.en_XX + cat newstest2019-enzh-ref.zh.sgm | strip_sgm.sh > $DEST/test.en_XX-zh_CN.zh_CN +} + +mkdir -p $DEST + +prepare_lid +prepare_moses +download_commoncrawl + +prepare_ja & +prepare_ta & +prepare_km & +prepare_ps & +prepare_iu & +prepare_cs & +prepare_de & +prepare_pl & +prepare_ru & +prepare_zh & + +# prepare valid/test set +prepare_tests & + +# wait + +# TODO remove intermediate files +# rm -rf $TMP_DIR diff --git a/fairseq/examples/multilingual/data_scripts/preprocess_ML50_v1.sh b/fairseq/examples/multilingual/data_scripts/preprocess_ML50_v1.sh new file mode 100644 index 0000000000000000000000000000000000000000..4655936149cab212b3cfa14f306d71153729f9d7 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/preprocess_ML50_v1.sh @@ -0,0 +1,27 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +if [ -z $WORKDIR_ROOT ] ; +then + echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..." + exit +fi + +if [ -z $SPM_PATH ] ; +then + echo "Please install sentence piecence from https://github.com/google/sentencepiece and set SPM_PATH pointing to the installed spm_encode.py. Exitting..." + exit +fi + +ML50=${WORKDIR_ROOT}/ML50 + +mkdir -p $ML50/dedup +mkdir -p $ML50/cleaned_dedup + +python ./dedup_all.py --from-folder $ML50/raw --to-folder $ML50/dedup +python ./remove_valid_test_in_train.py --from-folder $ML50/dedup --to-folder $ML50/clean +python ./binarize.py --raw-folder $ML50/clean \ No newline at end of file diff --git a/fairseq/examples/multilingual/data_scripts/remove_valid_test_in_train.py b/fairseq/examples/multilingual/data_scripts/remove_valid_test_in_train.py new file mode 100755 index 0000000000000000000000000000000000000000..ef618adef7c7d010f8de38fb5ebeb5a35d2d3cac --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/remove_valid_test_in_train.py @@ -0,0 +1,290 @@ +import os, sys +import glob, itertools +import pandas as pd + +WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) + +if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): + print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') + sys.exit(-1) + + +def load_langs(path): + with open(path) as fr: + langs = [l.strip() for l in fr] + return langs + + + +def load_sentences(raw_data, split, direction): + src, tgt = direction.split('-') + src_path = f"{raw_data}/{split}.{direction}.{src}" + tgt_path = f"{raw_data}/{split}.{direction}.{tgt}" + if os.path.exists(src_path) and os.path.exists(tgt_path): + return [(src, open(src_path).read().splitlines()), (tgt, open(tgt_path).read().splitlines())] + else: + return [] + +def swap_direction(d): + src, tgt = d.split('-') + return f'{tgt}-{src}' + +def get_all_test_data(raw_data, directions, split='test'): + test_data = [ + x + for dd in directions + for d in [dd, swap_direction(dd)] + for x in load_sentences(raw_data, split, d) + ] + # all_test_data = {s for _, d in test_data for s in d} + all_test_data = {} + for lang, d in test_data: + for s in d: + s = s.strip() + lgs = all_test_data.get(s, set()) + lgs.add(lang) + all_test_data[s] = lgs + return all_test_data, test_data + +def check_train_sentences(raw_data, direction, all_test_data, mess_up_train={}): + src, tgt = direction.split('-') + tgt_path = f"{raw_data}/train.{direction}.{tgt}" + src_path = f"{raw_data}/train.{direction}.{src}" + print(f'check training data in {raw_data}/train.{direction}') + size = 0 + if not os.path.exists(tgt_path) or not os.path.exists(src_path): + return mess_up_train, size + with open(src_path) as f, open(tgt_path) as g: + for src_line, tgt_line in zip(f, g): + s = src_line.strip() + t = tgt_line.strip() + size += 1 + if s in all_test_data: + langs = mess_up_train.get(s, set()) + langs.add(direction) + mess_up_train[s] = langs + if t in all_test_data: + langs = mess_up_train.get(t, set()) + langs.add(direction) + mess_up_train[t] = langs + return mess_up_train, size + +def check_train_all(raw_data, directions, all_test_data): + mess_up_train = {} + data_sizes = {} + for direction in directions: + _, size = check_train_sentences(raw_data, direction, all_test_data, mess_up_train) + data_sizes[direction] = size + return mess_up_train, data_sizes + +def count_train_in_other_set(mess_up_train): + train_in_others = [(direction, s) for s, directions in mess_up_train.items() for direction in directions] + counts = {} + for direction, s in train_in_others: + counts[direction] = counts.get(direction, 0) + 1 + return counts + +def train_size_if_remove_in_otherset(data_sizes, mess_up_train): + counts_in_other = count_train_in_other_set(mess_up_train) + remain_sizes = [] + for direction, count in counts_in_other.items(): + remain_sizes.append((direction, data_sizes[direction] - count, data_sizes[direction], count, 100 * count / data_sizes[direction] )) + return remain_sizes + + +def remove_messed_up_sentences(raw_data, direction, mess_up_train, mess_up_train_pairs, corrected_langs): + split = 'train' + src_lang, tgt_lang = direction.split('-') + + tgt = f"{raw_data}/{split}.{direction}.{tgt_lang}" + src = f"{raw_data}/{split}.{direction}.{src_lang}" + print(f'working on {direction}: ', src, tgt) + if not os.path.exists(tgt) or not os.path.exists(src) : + return + + corrected_tgt = f"{to_folder}/{split}.{direction}.{tgt_lang}" + corrected_src = f"{to_folder}/{split}.{direction}.{src_lang}" + line_num = 0 + keep_num = 0 + with open(src, encoding='utf8',) as fsrc, \ + open(tgt, encoding='utf8',) as ftgt, \ + open(corrected_src, 'w', encoding='utf8') as fsrc_corrected, \ + open(corrected_tgt, 'w', encoding='utf8') as ftgt_corrected: + for s, t in zip(fsrc, ftgt): + s = s.strip() + t = t.strip() + if t not in mess_up_train \ + and s not in mess_up_train \ + and (s, t) not in mess_up_train_pairs \ + and (t, s) not in mess_up_train_pairs: + corrected_langs.add(direction) + print(s, file=fsrc_corrected) + print(t, file=ftgt_corrected) + keep_num += 1 + line_num += 1 + if line_num % 1000 == 0: + print(f'completed {line_num} lines', end='\r') + return line_num, keep_num + +########## + + +def merge_valid_test_messup(mess_up_train_valid, mess_up_train_test): + merged_mess = [] + for s in set(list(mess_up_train_valid.keys()) + list(mess_up_train_test.keys())): + if not s: + continue + valid = mess_up_train_valid.get(s, set()) + test = mess_up_train_test.get(s, set()) + merged_mess.append((s, valid | test)) + return dict(merged_mess) + + + +######### +def check_train_pairs(raw_data, direction, all_test_data, mess_up_train={}): + src, tgt = direction.split('-') + #a hack; TODO: check the reversed directions + path1 = f"{raw_data}/train.{src}-{tgt}.{src}" + path2 = f"{raw_data}/train.{src}-{tgt}.{tgt}" + if not os.path.exists(path1) or not os.path.exists(path2) : + return + + with open(path1) as f1, open(path2) as f2: + for src_line, tgt_line in zip(f1, f2): + s = src_line.strip() + t = tgt_line.strip() + if (s, t) in all_test_data or (t, s) in all_test_data: + langs = mess_up_train.get( (s, t), set()) + langs.add(src) + langs.add(tgt) + mess_up_train[(s, t)] = langs + + +def load_pairs(raw_data, split, direction): + src, tgt = direction.split('-') + src_f = f"{raw_data}/{split}.{direction}.{src}" + tgt_f = f"{raw_data}/{split}.{direction}.{tgt}" + if tgt != 'en_XX': + src_f, tgt_f = tgt_f, src_f + if os.path.exists(src_f) and os.path.exists(tgt_f): + return list(zip(open(src_f).read().splitlines(), + open(tgt_f).read().splitlines(), + )) + else: + return [] + +# skip_langs = ['cs_CZ', 'en_XX', 'tl_XX', 'tr_TR'] +def get_messed_up_test_pairs(split, directions): + test_pairs = [ + (d, load_pairs(raw_data, split, d)) + for d in directions + ] + # all_test_data = {s for _, d in test_data for s in d} + all_test_pairs = {} + for direction, d in test_pairs: + src, tgt = direction.split('-') + for s in d: + langs = all_test_pairs.get(s, set()) + langs.add(src) + langs.add(tgt) + all_test_pairs[s] = langs + mess_up_train_pairs = {} + for direction in directions: + check_train_pairs(raw_data, direction, all_test_pairs, mess_up_train_pairs) + return all_test_pairs, mess_up_train_pairs + + + +if __name__ == "__main__": + ####### + import argparse + parser = argparse.ArgumentParser() + parser.add_argument( + '--from-folder', + required=True, + type=str) + parser.add_argument( + '--to-folder', + required=True, + type=str) + parser.add_argument( + '--directions', + default=None, + type=str) + + + args = parser.parse_args() + raw_data = args.from_folder + to_folder = args.to_folder + os.makedirs(to_folder, exist_ok=True) + + if args.directions: + directions = args.directions.split(',') + else: + raw_files = itertools.chain( + glob.glob(f'{raw_data}/train*'), + glob.glob(f'{raw_data}/valid*'), + glob.glob(f'{raw_data}/test*'), + ) + directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] + print('working on directions: ', directions) + + ########## + + + + all_test_data, test_data = get_all_test_data(raw_data, directions, 'test') + print('==loaded test data==') + all_valid_data, valid_data = get_all_test_data(raw_data, directions, 'valid') + print('==loaded valid data==') + all_valid_test_data = merge_valid_test_messup(all_test_data, all_valid_data) + mess_up_train, data_sizes = check_train_all(raw_data, directions, all_valid_test_data) + print('training messing up with valid, test data:', len(mess_up_train)) + data_situation = train_size_if_remove_in_otherset(data_sizes, mess_up_train) + df = pd.DataFrame(data_situation, columns=['direction', 'train_size_after_remove', 'orig_size', 'num_to_remove', 'remove_percent']) + df.sort_values('remove_percent', ascending=False) + df.to_csv(f'{raw_data}/clean_summary.tsv', sep='\t') + print(f'projected data clean summary in: {raw_data}/clean_summary.tsv') + + # correct the dataset: + all_test_pairs, mess_up_test_train_pairs = get_messed_up_test_pairs('test', directions) + all_valid_pairs, mess_up_valid_train_pairs = get_messed_up_test_pairs('valid', directions) + + all_messed_pairs = set(mess_up_test_train_pairs.keys()).union(set(mess_up_valid_train_pairs.keys())) + corrected_directions = set() + + real_data_situation = [] + for direction in directions: + org_size, new_size = remove_messed_up_sentences(raw_data, direction, mess_up_train, all_messed_pairs, corrected_directions) + if org_size == 0: + print(f"{direction} has size 0") + continue + real_data_situation.append( + (direction, new_size, org_size, org_size - new_size, (org_size - new_size) / org_size * 100) + ) + print('corrected directions: ', corrected_directions) + df = pd.DataFrame(real_data_situation, columns=['direction', 'train_size_after_remove', 'orig_size', 'num_to_remove', 'remove_percent']) + df.sort_values('remove_percent', ascending=False) + df.to_csv(f'{raw_data}/actual_clean_summary.tsv', sep='\t') + print(f'actual data clean summary (which can be different from the projected one because of duplications) in: {raw_data}/actual_clean_summary.tsv') + + import shutil + for direction in directions: + src_lang, tgt_lang = direction.split('-') + for split in ['train', 'valid', 'test']: + # copying valid, test and uncorrected train + if direction in corrected_directions and split == 'train': + continue + tgt = f"{raw_data}/{split}.{direction}.{tgt_lang}" + src = f"{raw_data}/{split}.{direction}.{src_lang}" + if not (os.path.exists(src) and os.path.exists(tgt)): + continue + corrected_tgt = f"{to_folder}/{split}.{direction}.{tgt_lang}" + corrected_src = f"{to_folder}/{split}.{direction}.{src_lang}" + print(f'copying {src} to {corrected_src}') + shutil.copyfile(src, corrected_src) + print(f'copying {tgt} to {corrected_tgt}') + shutil.copyfile(tgt, corrected_tgt) + + print('completed') \ No newline at end of file diff --git a/fairseq/examples/multilingual/data_scripts/requirement.txt b/fairseq/examples/multilingual/data_scripts/requirement.txt new file mode 100644 index 0000000000000000000000000000000000000000..e85d7d540e08a1407f92dfb2311972a1a5a30123 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/requirement.txt @@ -0,0 +1,2 @@ +wget +pandas \ No newline at end of file diff --git a/fairseq/examples/multilingual/data_scripts/utils/dedup.py b/fairseq/examples/multilingual/data_scripts/utils/dedup.py new file mode 100644 index 0000000000000000000000000000000000000000..d6fed8c695cf218d3502d6ed8d23015520c0e179 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/utils/dedup.py @@ -0,0 +1,41 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import argparse + +def deup(src_file, tgt_file, src_file_out, tgt_file_out): + seen = set() + dup_count = 0 + with open(src_file, encoding='utf-8') as fsrc, \ + open(tgt_file, encoding='utf-8') as ftgt, \ + open(src_file_out, 'w', encoding='utf-8') as fsrc_out, \ + open(tgt_file_out, 'w', encoding='utf-8') as ftgt_out: + for s, t in zip(fsrc, ftgt): + if (s, t) not in seen: + fsrc_out.write(s) + ftgt_out.write(t) + seen.add((s, t)) + else: + dup_count += 1 + print(f'number of duplication: {dup_count}') + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--src-file", type=str, required=True, + help="src file") + parser.add_argument("--tgt-file", type=str, required=True, + help="tgt file") + parser.add_argument("--src-file-out", type=str, required=True, + help="src ouptut file") + parser.add_argument("--tgt-file-out", type=str, required=True, + help="tgt ouput file") + args = parser.parse_args() + deup(args.src_file, args.tgt_file, args.src_file_out, args.tgt_file_out) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/data_scripts/utils/fasttext_multi_filter.py b/fairseq/examples/multilingual/data_scripts/utils/fasttext_multi_filter.py new file mode 100644 index 0000000000000000000000000000000000000000..41b38ba5bef20cb043921ac61820db8689189a5a --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/utils/fasttext_multi_filter.py @@ -0,0 +1,63 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +#!/bin/python + +import fasttext +from multiprocessing import Pool +import contextlib +import sys +import argparse +from functools import partial +import io + +model = None +def init(model_path): + global model + model = fasttext.load_model(model_path) + +def pred(lines): + return lines, [model.predict(line.strip())[0][0][9:] for line in lines] + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--model", type=str, required=True, + help="model to load") + parser.add_argument("--inputs", nargs="+", default=['-'], + help="input files to filter") + parser.add_argument("--langs", nargs="+", required=True, + help="lang ids of each input file") + parser.add_argument("--outputs", nargs="+", default=['-'], + help="path to save lid filtered outputs") + parser.add_argument("--num-workers", type=int, metavar="N", default=10, + help="number of processes in parallel") + args = parser.parse_args() + + assert len(args.inputs) == len(args.langs) and len(args.inputs) == len(args.outputs) + + with contextlib.ExitStack() as stack: + inputs = [ + stack.enter_context(open(input, "r", encoding="utf-8", newline="\n", errors="replace")) + if input != "-" else io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8', errors="replace") + for input in args.inputs + ] + outputs = [ + stack.enter_context(open(output, "w", encoding="utf-8", newline="\n")) + if output != "-" else sys.stdout + for output in args.outputs + ] + with Pool(args.num_workers, initializer=partial(init, args.model)) as p: + skip_cnt = 0 + for lines, preds in p.imap(pred, list(zip(*inputs)), chunksize=500): + if not all(a == b for a, b in zip(preds, args.langs)): + skip_cnt += 1 + continue + for line, output_h in zip(lines, outputs): + print(line.strip(), file=output_h) + print(f"Skipped {skip_cnt} lines.") + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/multilingual/data_scripts/utils/strip_sgm.sh b/fairseq/examples/multilingual/data_scripts/utils/strip_sgm.sh new file mode 100755 index 0000000000000000000000000000000000000000..7f4f61d7b1a46f51a1221de6b336cb70b5a0b8b3 --- /dev/null +++ b/fairseq/examples/multilingual/data_scripts/utils/strip_sgm.sh @@ -0,0 +1 @@ +grep "seg id" | sed 's/<seg id="[0-9]\+">//g' | sed 's/<\/seg>//g' diff --git a/fairseq/examples/multilingual/finetune_multilingual_model.sh b/fairseq/examples/multilingual/finetune_multilingual_model.sh new file mode 100644 index 0000000000000000000000000000000000000000..25960c5dc8a02e5580b61837099770a082b4dd83 --- /dev/null +++ b/fairseq/examples/multilingual/finetune_multilingual_model.sh @@ -0,0 +1,32 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +path_2_data=$1 # <path to data> which contains binarized data for each directions +lang_list=$2 # <path to a file which contains a list of languages separted by new lines> +lang_pairs=$3 #a list language pairs to train multilingual models, e.g. "en-fr,en-cs,fr-en,cs-en" +# pretrained can be an mBART pretrained model as well +pretrained_model=$4 #<path to a pretrained model> + + +fairseq-train "$path_2_data" \ + --encoder-normalize-before --decoder-normalize-before \ + --arch transformer --layernorm-embedding \ + --task translation_multi_simple_epoch \ + --finetune-from-model "$pretrained_model" \ + --sampling-method "temperature" \ + --sampling-temperature "1.5" \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.2 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt --lr 3e-05 --warmup-updates 2500 --max-update 40000 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 1024 --update-freq 2 \ + --save-interval 1 --save-interval-updates 5000 --keep-interval-updates 10 --no-epoch-checkpoints \ + --seed 222 --log-format simple --log-interval 2 diff --git a/fairseq/examples/multilingual/multilingual_fairseq_gen.sh b/fairseq/examples/multilingual/multilingual_fairseq_gen.sh new file mode 100644 index 0000000000000000000000000000000000000000..65aa322d7daaa428015de98abe4664a6a4164bfd --- /dev/null +++ b/fairseq/examples/multilingual/multilingual_fairseq_gen.sh @@ -0,0 +1,26 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +lang_pairs="en-fr,en-cs,fr-en,cs-en" +path_2_data=$1 # <path to data> +lang_list=$2 # <path to a file which contains list of languages separted by new lines> +model=$3 # <path to a trained model> +source_lang=cs +target_lang=en + +fairseq-generate "$path_2_data" \ + --path "$model" \ + --task translation_multi_simple_epoch \ + --gen-subset test \ + --source-lang "$source_lang" \ + --target-lang "$target_lang" \ + --sacrebleu --remove-bpe 'sentencepiece'\ + --batch-size 32 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" diff --git a/fairseq/examples/multilingual/train_multilingual_model.sh b/fairseq/examples/multilingual/train_multilingual_model.sh new file mode 100644 index 0000000000000000000000000000000000000000..cc050bd3f02de8a2f303737f187442d2eb80e4ef --- /dev/null +++ b/fairseq/examples/multilingual/train_multilingual_model.sh @@ -0,0 +1,28 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +path_2_data=$1 # <path to data> which contains binarized data for each directions +lang_list=$2 # <path to a file which contains a list of languages separted by new lines> +lang_pairs=$3 #a list language pairs to train multilingual models, e.g. "en-fr,en-cs,fr-en,cs-en" + +fairseq-train "$path_2_data" \ + --encoder-normalize-before --decoder-normalize-before \ + --arch transformer --layernorm-embedding \ + --task translation_multi_simple_epoch \ + --sampling-method "temperature" \ + --sampling-temperature 1.5 \ + --encoder-langtok "src" \ + --decoder-langtok \ + --lang-dict "$lang_list" \ + --lang-pairs "$lang_pairs" \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.2 \ + --optimizer adam --adam-eps 1e-06 --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt --lr 3e-05 --warmup-updates 2500 --max-update 40000 \ + --dropout 0.3 --attention-dropout 0.1 --weight-decay 0.0 \ + --max-tokens 1024 --update-freq 2 \ + --save-interval 1 --save-interval-updates 5000 --keep-interval-updates 10 --no-epoch-checkpoints \ + --seed 222 --log-format simple --log-interval 2 diff --git a/fairseq/examples/noisychannel/README.md b/fairseq/examples/noisychannel/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9d101aa874ec36ff3bb5c1166169a4c4f38ffe2b --- /dev/null +++ b/fairseq/examples/noisychannel/README.md @@ -0,0 +1,72 @@ +# Simple and Effective Noisy Channel Modeling for Neural Machine Translation (Yee et al., 2019) +This page contains pointers to pre-trained models as well as instructions on how to run the reranking scripts. + +## Citation: +```bibtex +@inproceedings{yee2019simple, + title = {Simple and Effective Noisy Channel Modeling for Neural Machine Translation}, + author = {Kyra Yee and Yann Dauphin and Michael Auli}, + booktitle = {Conference on Empirical Methods in Natural Language Processing}, + year = {2019}, +} +``` + +## Pre-trained Models: + +Model | Description | Download +---|---|--- +`transformer.noisychannel.de-en` | De->En Forward Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/forward_de2en.tar.bz2) +`transformer.noisychannel.en-de` | En->De Channel Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/backward_en2de.tar.bz2) +`transformer_lm.noisychannel.en` | En Language model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/reranking_en_lm.tar.bz2) + +Test Data: [newstest_wmt17](https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/wmt17test.tar.bz2) + +## Example usage + +``` +mkdir rerank_example +curl https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/forward_de2en.tar.bz2 | tar xvjf - -C rerank_example +curl https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/backward_en2de.tar.bz2 | tar xvjf - -C rerank_example +curl https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/reranking_en_lm.tar.bz2 | tar xvjf - -C rerank_example +curl https://dl.fbaipublicfiles.com/fairseq/models/noisychannel/wmt17test.tar.bz2 | tar xvjf - -C rerank_example + +beam=50 +num_trials=1000 +fw_name=fw_model_ex +bw_name=bw_model_ex +lm_name=lm_ex +data_dir=rerank_example/hyphen-splitting-mixed-case-wmt17test-wmt14bpe +data_dir_name=wmt17 +lm=rerank_example/lm/checkpoint_best.pt +lm_bpe_code=rerank_example/lm/bpe32k.code +lm_dict=rerank_example/lm/dict.txt +batch_size=32 +bw=rerank_example/backward_en2de.pt +fw=rerank_example/forward_de2en.pt + +# reranking with P(T|S) P(S|T) and P(T) +python examples/noisychannel/rerank_tune.py $data_dir --tune-param lenpen weight1 weight3 \ + --lower-bound 0 0 0 --upper-bound 3 3 3 --data-dir-name $data_dir_name \ + --num-trials $num_trials --source-lang de --target-lang en --gen-model $fw \ + -n $beam --batch-size $batch_size --score-model2 $fw --score-model1 $bw \ + --backwards1 --weight2 1 \ + -lm $lm --lm-dict $lm_dict --lm-name en_newscrawl --lm-bpe-code $lm_bpe_code \ + --model2-name $fw_name --model1-name $bw_name --gen-model-name $fw_name + +# reranking with P(T|S) and P(T) +python examples/noisychannel/rerank_tune.py $data_dir --tune-param lenpen weight3 \ + --lower-bound 0 0 --upper-bound 3 3 --data-dir-name $data_dir_name \ + --num-trials $num_trials --source-lang de --target-lang en --gen-model $fw \ + -n $beam --batch-size $batch_size --score-model1 $fw \ + -lm $lm --lm-dict $lm_dict --lm-name en_newscrawl --lm-bpe-code $lm_bpe_code \ + --model1-name $fw_name --gen-model-name $fw_name + +# to run with a preconfigured set of hyperparameters for the lenpen and model weights, using rerank.py instead. +python examples/noisychannel/rerank.py $data_dir \ + --lenpen 0.269 --weight1 1 --weight2 0.929 --weight3 0.831 \ + --data-dir-name $data_dir_name --source-lang de --target-lang en --gen-model $fw \ + -n $beam --batch-size $batch_size --score-model2 $fw --score-model1 $bw --backwards1 \ + -lm $lm --lm-dict $lm_dict --lm-name en_newscrawl --lm-bpe-code $lm_bpe_code \ + --model2-name $fw_name --model1-name $bw_name --gen-model-name $fw_name +``` + diff --git a/fairseq/examples/noisychannel/__init__.py b/fairseq/examples/noisychannel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..89f1aef4f6328d25425e0bcabb42dfffd2ed35f0 --- /dev/null +++ b/fairseq/examples/noisychannel/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .rerank_options import * # noqa diff --git a/fairseq/examples/noisychannel/rerank.py b/fairseq/examples/noisychannel/rerank.py new file mode 100644 index 0000000000000000000000000000000000000000..bb80d11a67cd75764a89f6f41915b0348ae96e92 --- /dev/null +++ b/fairseq/examples/noisychannel/rerank.py @@ -0,0 +1,428 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from multiprocessing import Pool + +import numpy as np +from fairseq import options +from fairseq.data import dictionary +from fairseq.scoring import bleu + +from examples.noisychannel import ( + rerank_generate, + rerank_options, + rerank_score_bw, + rerank_score_lm, + rerank_utils, +) + + +def score_target_hypo( + args, a, b, c, lenpen, target_outfile, hypo_outfile, write_hypos, normalize +): + + print("lenpen", lenpen, "weight1", a, "weight2", b, "weight3", c) + gen_output_lst, bitext1_lst, bitext2_lst, lm_res_lst = load_score_files(args) + dict = dictionary.Dictionary() + scorer = scorer = bleu.Scorer( + bleu.BleuConfig( + pad=dict.pad(), + eos=dict.eos(), + unk=dict.unk(), + ) + ) + + ordered_hypos = {} + ordered_targets = {} + + for shard_id in range(len(bitext1_lst)): + bitext1 = bitext1_lst[shard_id] + bitext2 = bitext2_lst[shard_id] + gen_output = gen_output_lst[shard_id] + lm_res = lm_res_lst[shard_id] + + total = len(bitext1.rescore_source.keys()) + source_lst = [] + hypo_lst = [] + score_lst = [] + reference_lst = [] + j = 1 + best_score = -math.inf + + for i in range(total): + # length is measured in terms of words, not bpe tokens, since models may not share the same bpe + target_len = len(bitext1.rescore_hypo[i].split()) + + if lm_res is not None: + lm_score = lm_res.score[i] + else: + lm_score = 0 + + if bitext2 is not None: + bitext2_score = bitext2.rescore_score[i] + bitext2_backwards = bitext2.backwards + else: + bitext2_score = None + bitext2_backwards = None + + score = rerank_utils.get_score( + a, + b, + c, + target_len, + bitext1.rescore_score[i], + bitext2_score, + lm_score=lm_score, + lenpen=lenpen, + src_len=bitext1.source_lengths[i], + tgt_len=bitext1.target_lengths[i], + bitext1_backwards=bitext1.backwards, + bitext2_backwards=bitext2_backwards, + normalize=normalize, + ) + + if score > best_score: + best_score = score + best_hypo = bitext1.rescore_hypo[i] + + if j == gen_output.num_hypos[i] or j == args.num_rescore: + j = 1 + hypo_lst.append(best_hypo) + score_lst.append(best_score) + source_lst.append(bitext1.rescore_source[i]) + reference_lst.append(bitext1.rescore_target[i]) + + best_score = -math.inf + best_hypo = "" + else: + j += 1 + + gen_keys = list(sorted(gen_output.no_bpe_target.keys())) + + for key in range(len(gen_keys)): + if args.prefix_len is None: + assert hypo_lst[key] in gen_output.no_bpe_hypo[gen_keys[key]], ( + "pred and rescore hypo mismatch: i: " + + str(key) + + ", " + + str(hypo_lst[key]) + + str(gen_keys[key]) + + str(gen_output.no_bpe_hypo[key]) + ) + sys_tok = dict.encode_line(hypo_lst[key]) + ref_tok = dict.encode_line(gen_output.no_bpe_target[gen_keys[key]]) + scorer.add(ref_tok, sys_tok) + + else: + full_hypo = rerank_utils.get_full_from_prefix( + hypo_lst[key], gen_output.no_bpe_hypo[gen_keys[key]] + ) + sys_tok = dict.encode_line(full_hypo) + ref_tok = dict.encode_line(gen_output.no_bpe_target[gen_keys[key]]) + scorer.add(ref_tok, sys_tok) + + # if only one set of hyper parameters is provided, write the predictions to a file + if write_hypos: + # recover the orinal ids from n best list generation + for key in range(len(gen_output.no_bpe_target)): + if args.prefix_len is None: + assert hypo_lst[key] in gen_output.no_bpe_hypo[gen_keys[key]], ( + "pred and rescore hypo mismatch:" + + "i:" + + str(key) + + str(hypo_lst[key]) + + str(gen_output.no_bpe_hypo[key]) + ) + ordered_hypos[gen_keys[key]] = hypo_lst[key] + ordered_targets[gen_keys[key]] = gen_output.no_bpe_target[ + gen_keys[key] + ] + + else: + full_hypo = rerank_utils.get_full_from_prefix( + hypo_lst[key], gen_output.no_bpe_hypo[gen_keys[key]] + ) + ordered_hypos[gen_keys[key]] = full_hypo + ordered_targets[gen_keys[key]] = gen_output.no_bpe_target[ + gen_keys[key] + ] + + # write the hypos in the original order from nbest list generation + if args.num_shards == (len(bitext1_lst)): + with open(target_outfile, "w") as t: + with open(hypo_outfile, "w") as h: + for key in range(len(ordered_hypos)): + t.write(ordered_targets[key]) + h.write(ordered_hypos[key]) + + res = scorer.result_string(4) + if write_hypos: + print(res) + score = rerank_utils.parse_bleu_scoring(res) + return score + + +def match_target_hypo(args, target_outfile, hypo_outfile): + """combine scores from the LM and bitext models, and write the top scoring hypothesis to a file""" + if len(args.weight1) == 1: + res = score_target_hypo( + args, + args.weight1[0], + args.weight2[0], + args.weight3[0], + args.lenpen[0], + target_outfile, + hypo_outfile, + True, + args.normalize, + ) + rerank_scores = [res] + else: + print("launching pool") + with Pool(32) as p: + rerank_scores = p.starmap( + score_target_hypo, + [ + ( + args, + args.weight1[i], + args.weight2[i], + args.weight3[i], + args.lenpen[i], + target_outfile, + hypo_outfile, + False, + args.normalize, + ) + for i in range(len(args.weight1)) + ], + ) + + if len(rerank_scores) > 1: + best_index = np.argmax(rerank_scores) + best_score = rerank_scores[best_index] + print("best score", best_score) + print("best lenpen", args.lenpen[best_index]) + print("best weight1", args.weight1[best_index]) + print("best weight2", args.weight2[best_index]) + print("best weight3", args.weight3[best_index]) + return ( + args.lenpen[best_index], + args.weight1[best_index], + args.weight2[best_index], + args.weight3[best_index], + best_score, + ) + + else: + return ( + args.lenpen[0], + args.weight1[0], + args.weight2[0], + args.weight3[0], + rerank_scores[0], + ) + + +def load_score_files(args): + if args.all_shards: + shard_ids = list(range(args.num_shards)) + else: + shard_ids = [args.shard_id] + + gen_output_lst = [] + bitext1_lst = [] + bitext2_lst = [] + lm_res1_lst = [] + + for shard_id in shard_ids: + using_nbest = args.nbest_list is not None + ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) = rerank_utils.get_directories( + args.data_dir_name, + args.num_rescore, + args.gen_subset, + args.gen_model_name, + shard_id, + args.num_shards, + args.sampling, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + + rerank1_is_gen = ( + args.gen_model == args.score_model1 and args.source_prefix_frac is None + ) + rerank2_is_gen = ( + args.gen_model == args.score_model2 and args.source_prefix_frac is None + ) + + score1_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model1_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards1, + ) + if args.score_model2 is not None: + score2_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model2_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards2, + ) + if args.language_model is not None: + lm_score_file = rerank_utils.rescore_file_name( + pre_gen, args.prefix_len, args.lm_name, lm_file=True + ) + + # get gen output + predictions_bpe_file = pre_gen + "/generate_output_bpe.txt" + if using_nbest: + print("Using predefined n-best list from interactive.py") + predictions_bpe_file = args.nbest_list + gen_output = rerank_utils.BitextOutputFromGen( + predictions_bpe_file, + bpe_symbol=args.post_process, + nbest=using_nbest, + prefix_len=args.prefix_len, + target_prefix_frac=args.target_prefix_frac, + ) + + if rerank1_is_gen: + bitext1 = gen_output + else: + bitext1 = rerank_utils.BitextOutput( + score1_file, + args.backwards1, + args.right_to_left1, + args.post_process, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + + if args.score_model2 is not None or args.nbest_list is not None: + if rerank2_is_gen: + bitext2 = gen_output + else: + bitext2 = rerank_utils.BitextOutput( + score2_file, + args.backwards2, + args.right_to_left2, + args.post_process, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + + assert ( + bitext2.source_lengths == bitext1.source_lengths + ), "source lengths for rescoring models do not match" + assert ( + bitext2.target_lengths == bitext1.target_lengths + ), "target lengths for rescoring models do not match" + else: + if args.diff_bpe: + assert args.score_model2 is None + bitext2 = gen_output + else: + bitext2 = None + + if args.language_model is not None: + lm_res1 = rerank_utils.LMOutput( + lm_score_file, + args.lm_dict, + args.prefix_len, + args.post_process, + args.target_prefix_frac, + ) + else: + lm_res1 = None + + gen_output_lst.append(gen_output) + bitext1_lst.append(bitext1) + bitext2_lst.append(bitext2) + lm_res1_lst.append(lm_res1) + return gen_output_lst, bitext1_lst, bitext2_lst, lm_res1_lst + + +def rerank(args): + if type(args.lenpen) is not list: + args.lenpen = [args.lenpen] + if type(args.weight1) is not list: + args.weight1 = [args.weight1] + if type(args.weight2) is not list: + args.weight2 = [args.weight2] + if type(args.weight3) is not list: + args.weight3 = [args.weight3] + if args.all_shards: + shard_ids = list(range(args.num_shards)) + else: + shard_ids = [args.shard_id] + + for shard_id in shard_ids: + ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) = rerank_utils.get_directories( + args.data_dir_name, + args.num_rescore, + args.gen_subset, + args.gen_model_name, + shard_id, + args.num_shards, + args.sampling, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + rerank_generate.gen_and_reprocess_nbest(args) + rerank_score_bw.score_bw(args) + rerank_score_lm.score_lm(args) + + if args.write_hypos is None: + write_targets = pre_gen + "/matched_targets" + write_hypos = pre_gen + "/matched_hypos" + else: + write_targets = args.write_hypos + "_targets" + args.gen_subset + write_hypos = args.write_hypos + "_hypos" + args.gen_subset + + if args.all_shards: + write_targets += "_all_shards" + write_hypos += "_all_shards" + + ( + best_lenpen, + best_weight1, + best_weight2, + best_weight3, + best_score, + ) = match_target_hypo(args, write_targets, write_hypos) + + return best_lenpen, best_weight1, best_weight2, best_weight3, best_score + + +def cli_main(): + parser = rerank_options.get_reranking_parser() + args = options.parse_args_and_arch(parser) + rerank(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/noisychannel/rerank_generate.py b/fairseq/examples/noisychannel/rerank_generate.py new file mode 100644 index 0000000000000000000000000000000000000000..daeeae059a677a9fcd7c370be087f1f5c189bc52 --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_generate.py @@ -0,0 +1,397 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Generate n-best translations using a trained model. +""" + +import os +import subprocess +from contextlib import redirect_stdout + +from fairseq import options +from fairseq_cli import generate, preprocess + +from examples.noisychannel import rerank_options, rerank_utils + + +def gen_and_reprocess_nbest(args): + if args.score_dict_dir is None: + args.score_dict_dir = args.data + if args.prefix_len is not None: + assert ( + args.right_to_left1 is False + ), "prefix length not compatible with right to left models" + assert ( + args.right_to_left2 is False + ), "prefix length not compatible with right to left models" + + if args.nbest_list is not None: + assert args.score_model2 is None + + if args.backwards1: + scorer1_src = args.target_lang + scorer1_tgt = args.source_lang + else: + scorer1_src = args.source_lang + scorer1_tgt = args.target_lang + + store_data = ( + os.path.join(os.path.dirname(__file__)) + "/rerank_data/" + args.data_dir_name + ) + if not os.path.exists(store_data): + os.makedirs(store_data) + + ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) = rerank_utils.get_directories( + args.data_dir_name, + args.num_rescore, + args.gen_subset, + args.gen_model_name, + args.shard_id, + args.num_shards, + args.sampling, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + assert not ( + args.right_to_left1 and args.backwards1 + ), "backwards right to left not supported" + assert not ( + args.right_to_left2 and args.backwards2 + ), "backwards right to left not supported" + assert not ( + args.prefix_len is not None and args.target_prefix_frac is not None + ), "target prefix frac and target prefix len incompatible" + + # make directory to store generation results + if not os.path.exists(pre_gen): + os.makedirs(pre_gen) + + rerank1_is_gen = ( + args.gen_model == args.score_model1 and args.source_prefix_frac is None + ) + rerank2_is_gen = ( + args.gen_model == args.score_model2 and args.source_prefix_frac is None + ) + + if args.nbest_list is not None: + rerank2_is_gen = True + + # make directories to store preprossed nbest list for reranking + if not os.path.exists(left_to_right_preprocessed_dir): + os.makedirs(left_to_right_preprocessed_dir) + if not os.path.exists(right_to_left_preprocessed_dir): + os.makedirs(right_to_left_preprocessed_dir) + if not os.path.exists(lm_preprocessed_dir): + os.makedirs(lm_preprocessed_dir) + if not os.path.exists(backwards_preprocessed_dir): + os.makedirs(backwards_preprocessed_dir) + + score1_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model1_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards1, + ) + if args.score_model2 is not None: + score2_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model2_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards2, + ) + + predictions_bpe_file = pre_gen + "/generate_output_bpe.txt" + + using_nbest = args.nbest_list is not None + + if using_nbest: + print("Using predefined n-best list from interactive.py") + predictions_bpe_file = args.nbest_list + + else: + if not os.path.isfile(predictions_bpe_file): + print("STEP 1: generate predictions using the p(T|S) model with bpe") + print(args.data) + param1 = [ + args.data, + "--path", + args.gen_model, + "--shard-id", + str(args.shard_id), + "--num-shards", + str(args.num_shards), + "--nbest", + str(args.num_rescore), + "--batch-size", + str(args.batch_size), + "--beam", + str(args.num_rescore), + "--batch-size", + str(args.num_rescore), + "--gen-subset", + args.gen_subset, + "--source-lang", + args.source_lang, + "--target-lang", + args.target_lang, + ] + if args.sampling: + param1 += ["--sampling"] + + gen_parser = options.get_generation_parser() + input_args = options.parse_args_and_arch(gen_parser, param1) + + print(input_args) + with open(predictions_bpe_file, "w") as f: + with redirect_stdout(f): + generate.main(input_args) + + gen_output = rerank_utils.BitextOutputFromGen( + predictions_bpe_file, + bpe_symbol=args.post_process, + nbest=using_nbest, + prefix_len=args.prefix_len, + target_prefix_frac=args.target_prefix_frac, + ) + + if args.diff_bpe: + rerank_utils.write_reprocessed( + gen_output.no_bpe_source, + gen_output.no_bpe_hypo, + gen_output.no_bpe_target, + pre_gen + "/source_gen_bpe." + args.source_lang, + pre_gen + "/target_gen_bpe." + args.target_lang, + pre_gen + "/reference_gen_bpe." + args.target_lang, + ) + bitext_bpe = args.rescore_bpe_code + bpe_src_param = [ + "-c", + bitext_bpe, + "--input", + pre_gen + "/source_gen_bpe." + args.source_lang, + "--output", + pre_gen + "/rescore_data." + args.source_lang, + ] + bpe_tgt_param = [ + "-c", + bitext_bpe, + "--input", + pre_gen + "/target_gen_bpe." + args.target_lang, + "--output", + pre_gen + "/rescore_data." + args.target_lang, + ] + + subprocess.call( + [ + "python", + os.path.join( + os.path.dirname(__file__), "subword-nmt/subword_nmt/apply_bpe.py" + ), + ] + + bpe_src_param, + shell=False, + ) + + subprocess.call( + [ + "python", + os.path.join( + os.path.dirname(__file__), "subword-nmt/subword_nmt/apply_bpe.py" + ), + ] + + bpe_tgt_param, + shell=False, + ) + + if (not os.path.isfile(score1_file) and not rerank1_is_gen) or ( + args.score_model2 is not None + and not os.path.isfile(score2_file) + and not rerank2_is_gen + ): + print( + "STEP 2: process the output of generate.py so we have clean text files with the translations" + ) + + rescore_file = "/rescore_data" + if args.prefix_len is not None: + prefix_len_rescore_file = rescore_file + "prefix" + str(args.prefix_len) + if args.target_prefix_frac is not None: + target_prefix_frac_rescore_file = ( + rescore_file + "target_prefix_frac" + str(args.target_prefix_frac) + ) + if args.source_prefix_frac is not None: + source_prefix_frac_rescore_file = ( + rescore_file + "source_prefix_frac" + str(args.source_prefix_frac) + ) + + if not args.right_to_left1 or not args.right_to_left2: + if not args.diff_bpe: + rerank_utils.write_reprocessed( + gen_output.source, + gen_output.hypo, + gen_output.target, + pre_gen + rescore_file + "." + args.source_lang, + pre_gen + rescore_file + "." + args.target_lang, + pre_gen + "/reference_file", + bpe_symbol=args.post_process, + ) + if args.prefix_len is not None: + bw_rescore_file = prefix_len_rescore_file + rerank_utils.write_reprocessed( + gen_output.source, + gen_output.hypo, + gen_output.target, + pre_gen + prefix_len_rescore_file + "." + args.source_lang, + pre_gen + prefix_len_rescore_file + "." + args.target_lang, + pre_gen + "/reference_file", + prefix_len=args.prefix_len, + bpe_symbol=args.post_process, + ) + elif args.target_prefix_frac is not None: + bw_rescore_file = target_prefix_frac_rescore_file + rerank_utils.write_reprocessed( + gen_output.source, + gen_output.hypo, + gen_output.target, + pre_gen + + target_prefix_frac_rescore_file + + "." + + args.source_lang, + pre_gen + + target_prefix_frac_rescore_file + + "." + + args.target_lang, + pre_gen + "/reference_file", + bpe_symbol=args.post_process, + target_prefix_frac=args.target_prefix_frac, + ) + else: + bw_rescore_file = rescore_file + + if args.source_prefix_frac is not None: + fw_rescore_file = source_prefix_frac_rescore_file + rerank_utils.write_reprocessed( + gen_output.source, + gen_output.hypo, + gen_output.target, + pre_gen + + source_prefix_frac_rescore_file + + "." + + args.source_lang, + pre_gen + + source_prefix_frac_rescore_file + + "." + + args.target_lang, + pre_gen + "/reference_file", + bpe_symbol=args.post_process, + source_prefix_frac=args.source_prefix_frac, + ) + else: + fw_rescore_file = rescore_file + + if args.right_to_left1 or args.right_to_left2: + rerank_utils.write_reprocessed( + gen_output.source, + gen_output.hypo, + gen_output.target, + pre_gen + "/right_to_left_rescore_data." + args.source_lang, + pre_gen + "/right_to_left_rescore_data." + args.target_lang, + pre_gen + "/right_to_left_reference_file", + right_to_left=True, + bpe_symbol=args.post_process, + ) + + print("STEP 3: binarize the translations") + if ( + not args.right_to_left1 + or args.score_model2 is not None + and not args.right_to_left2 + or not rerank1_is_gen + ): + + if args.backwards1 or args.backwards2: + if args.backwards_score_dict_dir is not None: + bw_dict = args.backwards_score_dict_dir + else: + bw_dict = args.score_dict_dir + bw_preprocess_param = [ + "--source-lang", + scorer1_src, + "--target-lang", + scorer1_tgt, + "--trainpref", + pre_gen + bw_rescore_file, + "--srcdict", + bw_dict + "/dict." + scorer1_src + ".txt", + "--tgtdict", + bw_dict + "/dict." + scorer1_tgt + ".txt", + "--destdir", + backwards_preprocessed_dir, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(bw_preprocess_param) + preprocess.main(input_args) + + preprocess_param = [ + "--source-lang", + scorer1_src, + "--target-lang", + scorer1_tgt, + "--trainpref", + pre_gen + fw_rescore_file, + "--srcdict", + args.score_dict_dir + "/dict." + scorer1_src + ".txt", + "--tgtdict", + args.score_dict_dir + "/dict." + scorer1_tgt + ".txt", + "--destdir", + left_to_right_preprocessed_dir, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(preprocess_param) + preprocess.main(input_args) + + if args.right_to_left1 or args.right_to_left2: + preprocess_param = [ + "--source-lang", + scorer1_src, + "--target-lang", + scorer1_tgt, + "--trainpref", + pre_gen + "/right_to_left_rescore_data", + "--srcdict", + args.score_dict_dir + "/dict." + scorer1_src + ".txt", + "--tgtdict", + args.score_dict_dir + "/dict." + scorer1_tgt + ".txt", + "--destdir", + right_to_left_preprocessed_dir, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(preprocess_param) + preprocess.main(input_args) + + return gen_output + + +def cli_main(): + parser = rerank_options.get_reranking_parser() + args = options.parse_args_and_arch(parser) + gen_and_reprocess_nbest(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/noisychannel/rerank_options.py b/fairseq/examples/noisychannel/rerank_options.py new file mode 100644 index 0000000000000000000000000000000000000000..de91939e6635bdf33c9dc330116be07d9e8be6a2 --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_options.py @@ -0,0 +1,149 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq import options + + +def get_reranking_parser(default_task="translation"): + parser = options.get_parser("Generation and reranking", default_task) + add_reranking_args(parser) + return parser + + +def get_tuning_parser(default_task="translation"): + parser = options.get_parser("Reranking tuning", default_task) + add_reranking_args(parser) + add_tuning_args(parser) + return parser + + +def add_reranking_args(parser): + group = parser.add_argument_group("Reranking") + # fmt: off + group.add_argument('--score-model1', '-s1', type=str, metavar='FILE', required=True, + help='path to first model or ensemble of models for rescoring') + group.add_argument('--score-model2', '-s2', type=str, metavar='FILE', required=False, + help='path to second model or ensemble of models for rescoring') + group.add_argument('--num-rescore', '-n', type=int, metavar='N', default=10, + help='the number of candidate hypothesis to rescore') + group.add_argument('-bz', '--batch-size', type=int, metavar='N', default=128, + help='batch size for generating the nbest list') + group.add_argument('--gen-subset', default='test', metavar='SET', choices=['test', 'train', 'valid'], + help='data subset to generate (train, valid, test)') + group.add_argument('--gen-model', default=None, metavar='FILE', + help='the model to generate translations') + group.add_argument('-b1', '--backwards1', action='store_true', + help='whether or not the first model group is backwards') + group.add_argument('-b2', '--backwards2', action='store_true', + help='whether or not the second model group is backwards') + group.add_argument('-a', '--weight1', default=1, nargs='+', type=float, + help='the weight(s) of the first model') + group.add_argument('-b', '--weight2', default=1, nargs='+', type=float, + help='the weight(s) of the second model, or the gen model if using nbest from interactive.py') + group.add_argument('-c', '--weight3', default=1, nargs='+', type=float, + help='the weight(s) of the third model') + + # lm arguments + group.add_argument('-lm', '--language-model', default=None, metavar='FILE', + help='language model for target language to rescore translations') + group.add_argument('--lm-dict', default=None, metavar='FILE', + help='the dict of the language model for the target language') + group.add_argument('--lm-name', default=None, + help='the name of the language model for the target language') + group.add_argument('--lm-bpe-code', default=None, metavar='FILE', + help='the bpe code for the language model for the target language') + group.add_argument('--data-dir-name', default=None, + help='name of data directory') + group.add_argument('--lenpen', default=1, nargs='+', type=float, + help='length penalty: <1.0 favors shorter, >1.0 favors longer sentences') + group.add_argument('--score-dict-dir', default=None, + help='the directory with dictionaries for the scoring models') + group.add_argument('--right-to-left1', action='store_true', + help='whether the first model group is a right to left model') + group.add_argument('--right-to-left2', action='store_true', + help='whether the second model group is a right to left model') + group.add_argument('--post-process', '--remove-bpe', default='@@ ', + help='the bpe symbol, used for the bitext and LM') + group.add_argument('--prefix-len', default=None, type=int, + help='the length of the target prefix to use in rescoring (in terms of words wo bpe)') + group.add_argument('--sampling', action='store_true', + help='use sampling instead of beam search for generating n best list') + group.add_argument('--diff-bpe', action='store_true', + help='bpe for rescoring and nbest list not the same') + group.add_argument('--rescore-bpe-code', default=None, + help='bpe code for rescoring models') + group.add_argument('--nbest-list', default=None, + help='use predefined nbest list in interactive.py format') + group.add_argument('--write-hypos', default=None, + help='filename prefix to write hypos to') + group.add_argument('--ref-translation', default=None, + help='reference translation to use with nbest list from interactive.py') + group.add_argument('--backwards-score-dict-dir', default=None, + help='the directory with dictionaries for the backwards model,' + 'if None then it is assumed the fw and backwards models share dictionaries') + + # extra scaling args + group.add_argument('--gen-model-name', default=None, + help='the name of the models that generated the nbest list') + group.add_argument('--model1-name', default=None, + help='the name of the set for model1 group ') + group.add_argument('--model2-name', default=None, + help='the name of the set for model2 group') + group.add_argument('--shard-id', default=0, type=int, + help='the id of the shard to generate') + group.add_argument('--num-shards', default=1, type=int, + help='the number of shards to generate across') + group.add_argument('--all-shards', action='store_true', + help='use all shards') + group.add_argument('--target-prefix-frac', default=None, type=float, + help='the fraction of the target prefix to use in rescoring (in terms of words wo bpe)') + group.add_argument('--source-prefix-frac', default=None, type=float, + help='the fraction of the source prefix to use in rescoring (in terms of words wo bpe)') + group.add_argument('--normalize', action='store_true', + help='whether to normalize by src and target len') + # fmt: on + return group + + +def add_tuning_args(parser): + group = parser.add_argument_group("Tuning") + + group.add_argument( + "--lower-bound", + default=[-0.7], + nargs="+", + type=float, + help="lower bound of search space", + ) + group.add_argument( + "--upper-bound", + default=[3], + nargs="+", + type=float, + help="upper bound of search space", + ) + group.add_argument( + "--tune-param", + default=["lenpen"], + nargs="+", + choices=["lenpen", "weight1", "weight2", "weight3"], + help="the parameter(s) to tune", + ) + group.add_argument( + "--tune-subset", + default="valid", + choices=["valid", "test", "train"], + help="the subset to tune on ", + ) + group.add_argument( + "--num-trials", + default=1000, + type=int, + help="number of trials to do for random search", + ) + group.add_argument( + "--share-weights", action="store_true", help="share weight2 and weight 3" + ) + return group diff --git a/fairseq/examples/noisychannel/rerank_score_bw.py b/fairseq/examples/noisychannel/rerank_score_bw.py new file mode 100644 index 0000000000000000000000000000000000000000..b0bc913651bd76667e25c214acb70f2bca19e185 --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_score_bw.py @@ -0,0 +1,143 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +from contextlib import redirect_stdout + +from fairseq import options +from fairseq_cli import generate + +from examples.noisychannel import rerank_options, rerank_utils + + +def score_bw(args): + if args.backwards1: + scorer1_src = args.target_lang + scorer1_tgt = args.source_lang + else: + scorer1_src = args.source_lang + scorer1_tgt = args.target_lang + + if args.score_model2 is not None: + if args.backwards2: + scorer2_src = args.target_lang + scorer2_tgt = args.source_lang + else: + scorer2_src = args.source_lang + scorer2_tgt = args.target_lang + + rerank1_is_gen = ( + args.gen_model == args.score_model1 and args.source_prefix_frac is None + ) + rerank2_is_gen = ( + args.gen_model == args.score_model2 and args.source_prefix_frac is None + ) + + ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) = rerank_utils.get_directories( + args.data_dir_name, + args.num_rescore, + args.gen_subset, + args.gen_model_name, + args.shard_id, + args.num_shards, + args.sampling, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + + score1_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model1_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards1, + ) + + if args.score_model2 is not None: + score2_file = rerank_utils.rescore_file_name( + pre_gen, + args.prefix_len, + args.model2_name, + target_prefix_frac=args.target_prefix_frac, + source_prefix_frac=args.source_prefix_frac, + backwards=args.backwards2, + ) + + if args.right_to_left1: + rerank_data1 = right_to_left_preprocessed_dir + elif args.backwards1: + rerank_data1 = backwards_preprocessed_dir + else: + rerank_data1 = left_to_right_preprocessed_dir + + gen_param = ["--batch-size", str(128), "--score-reference", "--gen-subset", "train"] + if not rerank1_is_gen and not os.path.isfile(score1_file): + print("STEP 4: score the translations for model 1") + + model_param1 = [ + "--path", + args.score_model1, + "--source-lang", + scorer1_src, + "--target-lang", + scorer1_tgt, + ] + gen_model1_param = [rerank_data1] + gen_param + model_param1 + + gen_parser = options.get_generation_parser() + input_args = options.parse_args_and_arch(gen_parser, gen_model1_param) + + with open(score1_file, "w") as f: + with redirect_stdout(f): + generate.main(input_args) + + if ( + args.score_model2 is not None + and not os.path.isfile(score2_file) + and not rerank2_is_gen + ): + print("STEP 4: score the translations for model 2") + + if args.right_to_left2: + rerank_data2 = right_to_left_preprocessed_dir + elif args.backwards2: + rerank_data2 = backwards_preprocessed_dir + else: + rerank_data2 = left_to_right_preprocessed_dir + + model_param2 = [ + "--path", + args.score_model2, + "--source-lang", + scorer2_src, + "--target-lang", + scorer2_tgt, + ] + gen_model2_param = [rerank_data2] + gen_param + model_param2 + + gen_parser = options.get_generation_parser() + input_args = options.parse_args_and_arch(gen_parser, gen_model2_param) + + with open(score2_file, "w") as f: + with redirect_stdout(f): + generate.main(input_args) + + +def cli_main(): + parser = rerank_options.get_reranking_parser() + args = options.parse_args_and_arch(parser) + score_bw(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/noisychannel/rerank_score_lm.py b/fairseq/examples/noisychannel/rerank_score_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..e80948d78b02561cbd09d72c319222105f41f6bb --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_score_lm.py @@ -0,0 +1,81 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os + +from fairseq import options + +from examples.noisychannel import rerank_options, rerank_utils + + +def score_lm(args): + using_nbest = args.nbest_list is not None + ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) = rerank_utils.get_directories( + args.data_dir_name, + args.num_rescore, + args.gen_subset, + args.gen_model_name, + args.shard_id, + args.num_shards, + args.sampling, + args.prefix_len, + args.target_prefix_frac, + args.source_prefix_frac, + ) + + predictions_bpe_file = pre_gen + "/generate_output_bpe.txt" + if using_nbest: + print("Using predefined n-best list from interactive.py") + predictions_bpe_file = args.nbest_list + + gen_output = rerank_utils.BitextOutputFromGen( + predictions_bpe_file, bpe_symbol=args.post_process, nbest=using_nbest + ) + + if args.language_model is not None: + lm_score_file = rerank_utils.rescore_file_name( + pre_gen, args.prefix_len, args.lm_name, lm_file=True + ) + + if args.language_model is not None and not os.path.isfile(lm_score_file): + print("STEP 4.5: language modeling for P(T)") + if args.lm_bpe_code is None: + bpe_status = "no bpe" + elif args.lm_bpe_code == "shared": + bpe_status = "shared" + else: + bpe_status = "different" + + rerank_utils.lm_scoring( + lm_preprocessed_dir, + bpe_status, + gen_output, + pre_gen, + args.lm_dict, + args.lm_name, + args.language_model, + args.lm_bpe_code, + 128, + lm_score_file, + args.target_lang, + args.source_lang, + prefix_len=args.prefix_len, + ) + + +def cli_main(): + parser = rerank_options.get_reranking_parser() + args = options.parse_args_and_arch(parser) + score_lm(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/noisychannel/rerank_tune.py b/fairseq/examples/noisychannel/rerank_tune.py new file mode 100644 index 0000000000000000000000000000000000000000..b2e8b7594a370b2462f77252d54d7ef80e290f7c --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_tune.py @@ -0,0 +1,102 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import random + +import numpy as np +from fairseq import options + +from examples.noisychannel import rerank, rerank_options + + +def random_search(args): + param_values = [] + tuneable_parameters = ["lenpen", "weight1", "weight2", "weight3"] + initial_params = [args.lenpen, args.weight1, args.weight2, args.weight3] + for i, elem in enumerate(initial_params): + if type(elem) is not list: + initial_params[i] = [elem] + else: + initial_params[i] = elem + + tune_parameters = args.tune_param.copy() + for i in range(len(args.tune_param)): + assert args.upper_bound[i] >= args.lower_bound[i] + index = tuneable_parameters.index(args.tune_param[i]) + del tuneable_parameters[index] + del initial_params[index] + + tune_parameters += tuneable_parameters + param_values += initial_params + random.seed(args.seed) + + random_params = np.array( + [ + [ + random.uniform(args.lower_bound[i], args.upper_bound[i]) + for i in range(len(args.tune_param)) + ] + for k in range(args.num_trials) + ] + ) + set_params = np.array( + [ + [initial_params[i][0] for i in range(len(tuneable_parameters))] + for k in range(args.num_trials) + ] + ) + random_params = np.concatenate((random_params, set_params), 1) + + rerank_args = vars(args).copy() + if args.nbest_list: + rerank_args["gen_subset"] = "test" + else: + rerank_args["gen_subset"] = args.tune_subset + + for k in range(len(tune_parameters)): + rerank_args[tune_parameters[k]] = list(random_params[:, k]) + + if args.share_weights: + k = tune_parameters.index("weight2") + rerank_args["weight3"] = list(random_params[:, k]) + + rerank_args = argparse.Namespace(**rerank_args) + best_lenpen, best_weight1, best_weight2, best_weight3, best_score = rerank.rerank( + rerank_args + ) + rerank_args = vars(args).copy() + rerank_args["lenpen"] = [best_lenpen] + rerank_args["weight1"] = [best_weight1] + rerank_args["weight2"] = [best_weight2] + rerank_args["weight3"] = [best_weight3] + + # write the hypothesis from the valid set from the best trial + + if args.gen_subset != "valid": + rerank_args["gen_subset"] = "valid" + rerank_args = argparse.Namespace(**rerank_args) + rerank.rerank(rerank_args) + + # test with the best hyperparameters on gen subset + rerank_args = vars(args).copy() + rerank_args["gen_subset"] = args.gen_subset + rerank_args["lenpen"] = [best_lenpen] + rerank_args["weight1"] = [best_weight1] + rerank_args["weight2"] = [best_weight2] + rerank_args["weight3"] = [best_weight3] + rerank_args = argparse.Namespace(**rerank_args) + rerank.rerank(rerank_args) + + +def cli_main(): + parser = rerank_options.get_tuning_parser() + args = options.parse_args_and_arch(parser) + + random_search(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/noisychannel/rerank_utils.py b/fairseq/examples/noisychannel/rerank_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2c6bf1b1afbb089cf5e84f720eb7a067479fbcbc --- /dev/null +++ b/fairseq/examples/noisychannel/rerank_utils.py @@ -0,0 +1,850 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +import os +import re +import subprocess +from contextlib import redirect_stdout + +from fairseq import options +from fairseq_cli import eval_lm, preprocess + + +def reprocess(fle): + # takes in a file of generate.py translation generate_output + # returns a source dict and hypothesis dict, where keys are the ID num (as a string) + # and values and the corresponding source and translation. There may be several translations + # per source, so the values for hypothesis_dict are lists. + # parses output of generate.py + + with open(fle, "r") as f: + txt = f.read() + + """reprocess generate.py output""" + p = re.compile(r"[STHP][-]\d+\s*") + hp = re.compile(r"(\s*[-]?\d+[.]?\d+\s*)|(\s*(-inf)\s*)") + source_dict = {} + hypothesis_dict = {} + score_dict = {} + target_dict = {} + pos_score_dict = {} + lines = txt.split("\n") + + for line in lines: + line += "\n" + prefix = re.search(p, line) + if prefix is not None: + assert len(prefix.group()) > 2, "prefix id not found" + _, j = prefix.span() + id_num = prefix.group()[2:] + id_num = int(id_num) + line_type = prefix.group()[0] + if line_type == "H": + h_txt = line[j:] + hypo = re.search(hp, h_txt) + assert ( + hypo is not None + ), "regular expression failed to find the hypothesis scoring" + _, i = hypo.span() + score = hypo.group() + if id_num in hypothesis_dict: + hypothesis_dict[id_num].append(h_txt[i:]) + score_dict[id_num].append(float(score)) + else: + hypothesis_dict[id_num] = [h_txt[i:]] + score_dict[id_num] = [float(score)] + + elif line_type == "S": + source_dict[id_num] = line[j:] + elif line_type == "T": + target_dict[id_num] = line[j:] + elif line_type == "P": + pos_scores = (line[j:]).split() + pos_scores = [float(x) for x in pos_scores] + if id_num in pos_score_dict: + pos_score_dict[id_num].append(pos_scores) + else: + pos_score_dict[id_num] = [pos_scores] + + return source_dict, hypothesis_dict, score_dict, target_dict, pos_score_dict + + +def reprocess_nbest(fle): + """reprocess interactive.py output""" + with open(fle, "r") as f: + txt = f.read() + + source_dict = {} + hypothesis_dict = {} + score_dict = {} + target_dict = {} + pos_score_dict = {} + lines = txt.split("\n") + + hp = re.compile(r"[-]?\d+[.]?\d+") + j = -1 + + for _i, line in enumerate(lines): + line += "\n" + line_type = line[0] + + if line_type == "H": + hypo = re.search(hp, line) + _, start_index = hypo.span() + score = hypo.group() + if j in score_dict: + score_dict[j].append(float(score)) + hypothesis_dict[j].append(line[start_index:].strip("\t")) + else: + score_dict[j] = [float(score)] + hypothesis_dict[j] = [line[start_index:].strip("\t")] + elif line_type == "O": + j += 1 + source_dict[j] = line[2:] + # we don't have the targets for interactive.py + target_dict[j] = "filler" + + elif line_type == "P": + pos_scores = [float(pos_score) for pos_score in line.split()[1:]] + if j in pos_score_dict: + pos_score_dict[j].append(pos_scores) + else: + pos_score_dict[j] = [pos_scores] + + assert source_dict.keys() == hypothesis_dict.keys() + assert source_dict.keys() == pos_score_dict.keys() + assert source_dict.keys() == score_dict.keys() + + return source_dict, hypothesis_dict, score_dict, target_dict, pos_score_dict + + +def write_reprocessed( + sources, + hypos, + targets, + source_outfile, + hypo_outfile, + target_outfile, + right_to_left=False, + prefix_len=None, + bpe_symbol=None, + target_prefix_frac=None, + source_prefix_frac=None, +): + + """writes nbest hypothesis for rescoring""" + assert not ( + prefix_len is not None and target_prefix_frac is not None + ), "in writing reprocessed, only one type of prefix may be used" + assert not ( + prefix_len is not None and source_prefix_frac is not None + ), "in writing reprocessed, only one type of prefix may be used" + assert not ( + target_prefix_frac is not None and source_prefix_frac is not None + ), "in writing reprocessed, only one type of prefix may be used" + + with open(source_outfile, "w") as source_file, open( + hypo_outfile, "w" + ) as hypo_file, open(target_outfile, "w") as target_file: + + assert len(sources) == len(hypos), "sources and hypos list length mismatch" + if right_to_left: + for i in range(len(sources)): + for j in range(len(hypos[i])): + if prefix_len is None: + hypo_file.write(make_right_to_left(hypos[i][j]) + "\n") + else: + raise NotImplementedError() + source_file.write(make_right_to_left(sources[i]) + "\n") + target_file.write(make_right_to_left(targets[i]) + "\n") + else: + for i in sorted(sources.keys()): + for j in range(len(hypos[i])): + if prefix_len is not None: + shortened = ( + get_prefix_no_bpe(hypos[i][j], bpe_symbol, prefix_len) + + "\n" + ) + hypo_file.write(shortened) + source_file.write(sources[i]) + target_file.write(targets[i]) + elif target_prefix_frac is not None: + num_words, shortened, num_bpe_tokens = calc_length_from_frac( + hypos[i][j], target_prefix_frac, bpe_symbol + ) + shortened += "\n" + hypo_file.write(shortened) + source_file.write(sources[i]) + target_file.write(targets[i]) + elif source_prefix_frac is not None: + num_words, shortened, num_bpe_tokensn = calc_length_from_frac( + sources[i], source_prefix_frac, bpe_symbol + ) + shortened += "\n" + hypo_file.write(hypos[i][j]) + source_file.write(shortened) + target_file.write(targets[i]) + else: + hypo_file.write(hypos[i][j]) + source_file.write(sources[i]) + target_file.write(targets[i]) + + +def calc_length_from_frac(bpe_sentence, prefix_frac, bpe_symbol): + # return number of words, (not bpe tokens) that we want + no_bpe_sen = remove_bpe(bpe_sentence, bpe_symbol) + len_sen = len(no_bpe_sen.split()) + + num_words = math.ceil(len_sen * prefix_frac) + prefix = get_prefix_no_bpe(bpe_sentence, bpe_symbol, num_words) + num_bpe_tokens = len(prefix.split()) + return num_words, prefix, num_bpe_tokens + + +def get_prefix(sentence, prefix_len): + """assuming no bpe, gets the prefix of the sentence with prefix_len words""" + tokens = sentence.strip("\n").split() + if prefix_len >= len(tokens): + return sentence.strip("\n") + else: + return " ".join(tokens[:prefix_len]) + + +def get_prefix_no_bpe(sentence, bpe_symbol, prefix_len): + if bpe_symbol is None: + return get_prefix(sentence, prefix_len) + else: + return " ".join(get_prefix_from_len(sentence.split(), bpe_symbol, prefix_len)) + + +def get_prefix_from_len(sentence, bpe_symbol, prefix_len): + """get the prefix of sentence with bpe, with prefix len in terms of words, not bpe tokens""" + bpe_count = sum([bpe_symbol.strip(" ") in t for t in sentence[:prefix_len]]) + if bpe_count == 0: + return sentence[:prefix_len] + else: + return sentence[:prefix_len] + get_prefix_from_len( + sentence[prefix_len:], bpe_symbol, bpe_count + ) + + +def get_num_bpe_tokens_from_len(sentence, bpe_symbol, prefix_len): + """given a prefix length in terms of words, return the number of bpe tokens""" + prefix = get_prefix_no_bpe(sentence, bpe_symbol, prefix_len) + assert len(remove_bpe(prefix, bpe_symbol).split()) <= prefix_len + return len(prefix.split(" ")) + + +def make_right_to_left(line): + tokens = line.split() + tokens.reverse() + new_line = " ".join(tokens) + return new_line + + +def remove_bpe(line, bpe_symbol): + line = line.replace("\n", "") + line = (line + " ").replace(bpe_symbol, "").rstrip() + return line + ("\n") + + +def remove_bpe_dict(pred_dict, bpe_symbol): + new_dict = {} + for i in pred_dict: + if type(pred_dict[i]) == list: + new_list = [remove_bpe(elem, bpe_symbol) for elem in pred_dict[i]] + new_dict[i] = new_list + else: + new_dict[i] = remove_bpe(pred_dict[i], bpe_symbol) + return new_dict + + +def parse_bleu_scoring(line): + p = re.compile(r"(BLEU4 = )\d+[.]\d+") + res = re.search(p, line) + assert res is not None, line + return float(res.group()[8:]) + + +def get_full_from_prefix(hypo_prefix, hypos): + """given a hypo prefix, recover the first hypo from the list of complete hypos beginning with that prefix""" + for hypo in hypos: + hypo_prefix = hypo_prefix.strip("\n") + len_prefix = len(hypo_prefix) + if hypo[:len_prefix] == hypo_prefix: + return hypo + # no match found + raise Exception() + + +def get_score( + a, + b, + c, + target_len, + bitext_score1, + bitext_score2=None, + lm_score=None, + lenpen=None, + src_len=None, + tgt_len=None, + bitext1_backwards=False, + bitext2_backwards=False, + normalize=False, +): + if bitext1_backwards: + bitext1_norm = src_len + else: + bitext1_norm = tgt_len + if bitext_score2 is not None: + if bitext2_backwards: + bitext2_norm = src_len + else: + bitext2_norm = tgt_len + else: + bitext2_norm = 1 + bitext_score2 = 0 + if normalize: + score = ( + a * bitext_score1 / bitext1_norm + + b * bitext_score2 / bitext2_norm + + c * lm_score / src_len + ) + else: + score = a * bitext_score1 + b * bitext_score2 + c * lm_score + + if lenpen is not None: + score /= (target_len) ** float(lenpen) + + return score + + +class BitextOutput(object): + def __init__( + self, + output_file, + backwards, + right_to_left, + bpe_symbol, + prefix_len=None, + target_prefix_frac=None, + source_prefix_frac=None, + ): + """process output from rescoring""" + source, hypo, score, target, pos_score = reprocess(output_file) + if backwards: + self.hypo_fracs = source_prefix_frac + else: + self.hypo_fracs = target_prefix_frac + + # remove length penalty so we can use raw scores + score, num_bpe_tokens = get_score_from_pos( + pos_score, prefix_len, hypo, bpe_symbol, self.hypo_fracs, backwards + ) + source_lengths = {} + target_lengths = {} + + assert hypo.keys() == source.keys(), "key mismatch" + if backwards: + tmp = hypo + hypo = source + source = tmp + for i in source: + # since we are reranking, there should only be one hypo per source sentence + if backwards: + len_src = len(source[i][0].split()) + # record length without <eos> + if len_src == num_bpe_tokens[i][0] - 1: + source_lengths[i] = num_bpe_tokens[i][0] - 1 + else: + source_lengths[i] = num_bpe_tokens[i][0] + + target_lengths[i] = len(hypo[i].split()) + + source[i] = remove_bpe(source[i][0], bpe_symbol) + target[i] = remove_bpe(target[i], bpe_symbol) + hypo[i] = remove_bpe(hypo[i], bpe_symbol) + + score[i] = float(score[i][0]) + pos_score[i] = pos_score[i][0] + + else: + len_tgt = len(hypo[i][0].split()) + # record length without <eos> + if len_tgt == num_bpe_tokens[i][0] - 1: + target_lengths[i] = num_bpe_tokens[i][0] - 1 + else: + target_lengths[i] = num_bpe_tokens[i][0] + + source_lengths[i] = len(source[i].split()) + + if right_to_left: + source[i] = remove_bpe(make_right_to_left(source[i]), bpe_symbol) + target[i] = remove_bpe(make_right_to_left(target[i]), bpe_symbol) + hypo[i] = remove_bpe(make_right_to_left(hypo[i][0]), bpe_symbol) + score[i] = float(score[i][0]) + pos_score[i] = pos_score[i][0] + else: + assert ( + len(hypo[i]) == 1 + ), "expected only one hypothesis per source sentence" + source[i] = remove_bpe(source[i], bpe_symbol) + target[i] = remove_bpe(target[i], bpe_symbol) + hypo[i] = remove_bpe(hypo[i][0], bpe_symbol) + score[i] = float(score[i][0]) + pos_score[i] = pos_score[i][0] + + self.rescore_source = source + self.rescore_hypo = hypo + self.rescore_score = score + self.rescore_target = target + self.rescore_pos_score = pos_score + self.backwards = backwards + self.right_to_left = right_to_left + self.target_lengths = target_lengths + self.source_lengths = source_lengths + + +class BitextOutputFromGen(object): + def __init__( + self, + predictions_bpe_file, + bpe_symbol=None, + nbest=False, + prefix_len=None, + target_prefix_frac=None, + ): + if nbest: + ( + pred_source, + pred_hypo, + pred_score, + pred_target, + pred_pos_score, + ) = reprocess_nbest(predictions_bpe_file) + else: + pred_source, pred_hypo, pred_score, pred_target, pred_pos_score = reprocess( + predictions_bpe_file + ) + + assert len(pred_source) == len(pred_hypo) + assert len(pred_source) == len(pred_score) + assert len(pred_source) == len(pred_target) + assert len(pred_source) == len(pred_pos_score) + + # remove length penalty so we can use raw scores + pred_score, num_bpe_tokens = get_score_from_pos( + pred_pos_score, prefix_len, pred_hypo, bpe_symbol, target_prefix_frac, False + ) + + self.source = pred_source + self.target = pred_target + self.score = pred_score + self.pos_score = pred_pos_score + self.hypo = pred_hypo + self.target_lengths = {} + self.source_lengths = {} + + self.no_bpe_source = remove_bpe_dict(pred_source.copy(), bpe_symbol) + self.no_bpe_hypo = remove_bpe_dict(pred_hypo.copy(), bpe_symbol) + self.no_bpe_target = remove_bpe_dict(pred_target.copy(), bpe_symbol) + + # indexes to match those from the rescoring models + self.rescore_source = {} + self.rescore_target = {} + self.rescore_pos_score = {} + self.rescore_hypo = {} + self.rescore_score = {} + self.num_hypos = {} + self.backwards = False + self.right_to_left = False + + index = 0 + + for i in sorted(pred_source.keys()): + for j in range(len(pred_hypo[i])): + + self.target_lengths[index] = len(self.hypo[i][j].split()) + self.source_lengths[index] = len(self.source[i].split()) + + self.rescore_source[index] = self.no_bpe_source[i] + self.rescore_target[index] = self.no_bpe_target[i] + self.rescore_hypo[index] = self.no_bpe_hypo[i][j] + self.rescore_score[index] = float(pred_score[i][j]) + self.rescore_pos_score[index] = pred_pos_score[i][j] + self.num_hypos[index] = len(pred_hypo[i]) + index += 1 + + +def get_score_from_pos( + pos_score_dict, prefix_len, hypo_dict, bpe_symbol, hypo_frac, backwards +): + score_dict = {} + num_bpe_tokens_dict = {} + assert prefix_len is None or hypo_frac is None + for key in pos_score_dict: + score_dict[key] = [] + num_bpe_tokens_dict[key] = [] + for i in range(len(pos_score_dict[key])): + if prefix_len is not None and not backwards: + num_bpe_tokens = get_num_bpe_tokens_from_len( + hypo_dict[key][i], bpe_symbol, prefix_len + ) + score_dict[key].append(sum(pos_score_dict[key][i][:num_bpe_tokens])) + num_bpe_tokens_dict[key].append(num_bpe_tokens) + elif hypo_frac is not None: + num_words, shortened, hypo_prefix_len = calc_length_from_frac( + hypo_dict[key][i], hypo_frac, bpe_symbol + ) + score_dict[key].append(sum(pos_score_dict[key][i][:hypo_prefix_len])) + num_bpe_tokens_dict[key].append(hypo_prefix_len) + else: + score_dict[key].append(sum(pos_score_dict[key][i])) + num_bpe_tokens_dict[key].append(len(pos_score_dict[key][i])) + return score_dict, num_bpe_tokens_dict + + +class LMOutput(object): + def __init__( + self, + lm_score_file, + lm_dict=None, + prefix_len=None, + bpe_symbol=None, + target_prefix_frac=None, + ): + ( + lm_sentences, + lm_sen_scores, + lm_sen_pos_scores, + lm_no_bpe_sentences, + lm_bpe_tokens, + ) = parse_lm( + lm_score_file, + prefix_len=prefix_len, + bpe_symbol=bpe_symbol, + target_prefix_frac=target_prefix_frac, + ) + + self.sentences = lm_sentences + self.score = lm_sen_scores + self.pos_score = lm_sen_pos_scores + self.lm_dict = lm_dict + self.no_bpe_sentences = lm_no_bpe_sentences + self.bpe_tokens = lm_bpe_tokens + + +def parse_lm(input_file, prefix_len=None, bpe_symbol=None, target_prefix_frac=None): + """parse output of eval_lm""" + with open(input_file, "r") as f: + text = f.readlines() + text = text[7:] + cleaned_text = text[:-2] + + sentences = {} + sen_scores = {} + sen_pos_scores = {} + no_bpe_sentences = {} + num_bpe_tokens_dict = {} + for _i, line in enumerate(cleaned_text): + tokens = line.split() + if tokens[0].isdigit(): + line_id = int(tokens[0]) + scores = [float(x[1:-1]) for x in tokens[2::2]] + sentences[line_id] = " ".join(tokens[1::2][:-1]) + "\n" + if bpe_symbol is not None: + # exclude <eos> symbol to match output from generate.py + bpe_sen = " ".join(tokens[1::2][:-1]) + "\n" + no_bpe_sen = remove_bpe(bpe_sen, bpe_symbol) + no_bpe_sentences[line_id] = no_bpe_sen + + if prefix_len is not None: + num_bpe_tokens = get_num_bpe_tokens_from_len( + bpe_sen, bpe_symbol, prefix_len + ) + sen_scores[line_id] = sum(scores[:num_bpe_tokens]) + num_bpe_tokens_dict[line_id] = num_bpe_tokens + elif target_prefix_frac is not None: + num_words, shortened, target_prefix_len = calc_length_from_frac( + bpe_sen, target_prefix_frac, bpe_symbol + ) + sen_scores[line_id] = sum(scores[:target_prefix_len]) + num_bpe_tokens_dict[line_id] = target_prefix_len + else: + sen_scores[line_id] = sum(scores) + num_bpe_tokens_dict[line_id] = len(scores) + + sen_pos_scores[line_id] = scores + + return sentences, sen_scores, sen_pos_scores, no_bpe_sentences, num_bpe_tokens_dict + + +def get_directories( + data_dir_name, + num_rescore, + gen_subset, + fw_name, + shard_id, + num_shards, + sampling=False, + prefix_len=None, + target_prefix_frac=None, + source_prefix_frac=None, +): + nbest_file_id = ( + "nbest_" + + str(num_rescore) + + "_subset_" + + gen_subset + + "_fw_name_" + + fw_name + + "_shard_" + + str(shard_id) + + "_of_" + + str(num_shards) + ) + + if sampling: + nbest_file_id += "_sampling" + + # the directory containing all information for this nbest list + pre_gen = ( + os.path.join(os.path.dirname(__file__)) + + "/rerank_data/" + + data_dir_name + + "/" + + nbest_file_id + ) + # the directory to store the preprocessed nbest list, for left to right rescoring + left_to_right_preprocessed_dir = pre_gen + "/left_to_right_preprocessed" + if source_prefix_frac is not None: + left_to_right_preprocessed_dir = ( + left_to_right_preprocessed_dir + "/prefix_frac" + str(source_prefix_frac) + ) + # the directory to store the preprocessed nbest list, for right to left rescoring + right_to_left_preprocessed_dir = pre_gen + "/right_to_left_preprocessed" + # the directory to store the preprocessed nbest list, for backwards rescoring + backwards_preprocessed_dir = pre_gen + "/backwards" + if target_prefix_frac is not None: + backwards_preprocessed_dir = ( + backwards_preprocessed_dir + "/prefix_frac" + str(target_prefix_frac) + ) + elif prefix_len is not None: + backwards_preprocessed_dir = ( + backwards_preprocessed_dir + "/prefix_" + str(prefix_len) + ) + + # the directory to store the preprocessed nbest list, for rescoring with P(T) + lm_preprocessed_dir = pre_gen + "/lm_preprocessed" + + return ( + pre_gen, + left_to_right_preprocessed_dir, + right_to_left_preprocessed_dir, + backwards_preprocessed_dir, + lm_preprocessed_dir, + ) + + +def lm_scoring( + preprocess_directory, + bpe_status, + gen_output, + pre_gen, + cur_lm_dict, + cur_lm_name, + cur_language_model, + cur_lm_bpe_code, + batch_size, + lm_score_file, + target_lang, + source_lang, + prefix_len=None, +): + if prefix_len is not None: + assert ( + bpe_status == "different" + ), "bpe status must be different to use prefix len" + if bpe_status == "no bpe": + # run lm on output without bpe + write_reprocessed( + gen_output.no_bpe_source, + gen_output.no_bpe_hypo, + gen_output.no_bpe_target, + pre_gen + "/rescore_data_no_bpe.de", + pre_gen + "/rescore_data_no_bpe.en", + pre_gen + "/reference_file_no_bpe", + ) + + preprocess_lm_param = [ + "--only-source", + "--trainpref", + pre_gen + "/rescore_data_no_bpe." + target_lang, + "--srcdict", + cur_lm_dict, + "--destdir", + preprocess_directory, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(preprocess_lm_param) + preprocess.main(input_args) + + eval_lm_param = [ + preprocess_directory, + "--path", + cur_language_model, + "--output-word-probs", + "--batch-size", + str(batch_size), + "--max-tokens", + "1024", + "--sample-break-mode", + "eos", + "--gen-subset", + "train", + ] + + eval_lm_parser = options.get_eval_lm_parser() + input_args = options.parse_args_and_arch(eval_lm_parser, eval_lm_param) + + with open(lm_score_file, "w") as f: + with redirect_stdout(f): + eval_lm.main(input_args) + + elif bpe_status == "shared": + preprocess_lm_param = [ + "--only-source", + "--trainpref", + pre_gen + "/rescore_data." + target_lang, + "--srcdict", + cur_lm_dict, + "--destdir", + preprocess_directory, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(preprocess_lm_param) + preprocess.main(input_args) + + eval_lm_param = [ + preprocess_directory, + "--path", + cur_language_model, + "--output-word-probs", + "--batch-size", + str(batch_size), + "--sample-break-mode", + "eos", + "--gen-subset", + "train", + ] + + eval_lm_parser = options.get_eval_lm_parser() + input_args = options.parse_args_and_arch(eval_lm_parser, eval_lm_param) + + with open(lm_score_file, "w") as f: + with redirect_stdout(f): + eval_lm.main(input_args) + + elif bpe_status == "different": + rescore_file = pre_gen + "/rescore_data_no_bpe" + rescore_bpe = pre_gen + "/rescore_data_new_bpe" + + rescore_file += "." + rescore_bpe += "." + + write_reprocessed( + gen_output.no_bpe_source, + gen_output.no_bpe_hypo, + gen_output.no_bpe_target, + rescore_file + source_lang, + rescore_file + target_lang, + pre_gen + "/reference_file_no_bpe", + bpe_symbol=None, + ) + + # apply LM bpe to nbest list + bpe_src_param = [ + "-c", + cur_lm_bpe_code, + "--input", + rescore_file + target_lang, + "--output", + rescore_bpe + target_lang, + ] + subprocess.call( + [ + "python", + os.path.join( + os.path.dirname(__file__), "subword-nmt/subword_nmt/apply_bpe.py" + ), + ] + + bpe_src_param, + shell=False, + ) + # uncomment to use fastbpe instead of subword-nmt bpe + # bpe_src_param = [rescore_bpe+target_lang, rescore_file+target_lang, cur_lm_bpe_code] + # subprocess.call(["/private/home/edunov/fastBPE/fast", "applybpe"] + bpe_src_param, shell=False) + + preprocess_dir = preprocess_directory + + preprocess_lm_param = [ + "--only-source", + "--trainpref", + rescore_bpe + target_lang, + "--srcdict", + cur_lm_dict, + "--destdir", + preprocess_dir, + ] + preprocess_parser = options.get_preprocessing_parser() + input_args = preprocess_parser.parse_args(preprocess_lm_param) + preprocess.main(input_args) + + eval_lm_param = [ + preprocess_dir, + "--path", + cur_language_model, + "--output-word-probs", + "--batch-size", + str(batch_size), + "--max-tokens", + "1024", + "--sample-break-mode", + "eos", + "--gen-subset", + "train", + ] + + eval_lm_parser = options.get_eval_lm_parser() + input_args = options.parse_args_and_arch(eval_lm_parser, eval_lm_param) + + with open(lm_score_file, "w") as f: + with redirect_stdout(f): + eval_lm.main(input_args) + + +def rescore_file_name( + nbest_dir, + prefix_len, + scorer_name, + lm_file=False, + target_prefix_frac=None, + source_prefix_frac=None, + backwards=None, +): + if lm_file: + score_file = nbest_dir + "/lm_score_translations_model_" + scorer_name + ".txt" + else: + score_file = nbest_dir + "/" + scorer_name + "_score_translations.txt" + if backwards: + if prefix_len is not None: + score_file += "prefix_len" + str(prefix_len) + elif target_prefix_frac is not None: + score_file += "target_prefix_frac" + str(target_prefix_frac) + else: + if source_prefix_frac is not None: + score_file += "source_prefix_frac" + str(source_prefix_frac) + return score_file diff --git a/fairseq/examples/nonautoregressive_translation/README.md b/fairseq/examples/nonautoregressive_translation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8793e225c99732c42c9c19e22075cde37c73341d --- /dev/null +++ b/fairseq/examples/nonautoregressive_translation/README.md @@ -0,0 +1,146 @@ +# Non-autoregressive Neural Machine Translation (NAT) + +This page mainly includes instructions for reproducing results from the following papers +* [Levenshtein Transformer (Gu et al., 2019)](https://arxiv.org/abs/1905.11006). +* [Understanding Knowledge Distillation in Non-autoregressive Machine Translation (Zhou et al., 2019)](https://arxiv.org/abs/1911.02727). + +We also provided our own implementations for several popular non-autoregressive-based models as reference:<br> +* [Non-Autoregressive Neural Machine Translation (Gu et al., 2017)](https://arxiv.org/abs/1711.02281)<br> +* [Deterministic Non-Autoregressive Neural Sequence Modeling by Iterative Refinement (Lee et al., 2018)](https://arxiv.org/abs/1802.06901)<br> +* [Insertion Transformer: Flexible Sequence Generation via Insertion Operations (Stern et al., 2019)](https://arxiv.org/abs/1902.03249)<br> +* [Mask-Predict: Parallel Decoding of Conditional Masked Language Models (Ghazvininejad et al., 2019)](https://arxiv.org/abs/1904.09324v2)<br> +* [Fast Structured Decoding for Sequence Models (Sun et al., 2019)](https://arxiv.org/abs/1910.11555) + +## Dataset + +First, follow the [instructions to download and preprocess the WMT'14 En-De dataset](../translation#wmt14-english-to-german-convolutional). +Make sure to learn a joint vocabulary by passing the `--joined-dictionary` option to `fairseq-preprocess`. + +### Knowledge Distillation +Following [Gu et al. 2019](https://arxiv.org/abs/1905.11006), [knowledge distillation](https://arxiv.org/abs/1606.07947) from an autoregressive model can effectively simplify the training data distribution, which is sometimes essential for NAT-based models to learn good translations. +The easiest way of performing distillation is to follow the [instructions of training a standard transformer model](../translation) on the same data, and then decode the training set to produce a distillation dataset for NAT. + +### Download +We also provided the preprocessed [original](http://dl.fbaipublicfiles.com/nat/original_dataset.zip) and [distillation](http://dl.fbaipublicfiles.com/nat/distill_dataset.zip) datasets. Please build the binarized dataset on your own. + + +## Train a model + +Then we can train a nonautoregressive model using the `translation_lev` task and a new criterion `nat_loss`. +Use the `--noise` flag to specify the input noise used on the target sentences. +In default, we run the task for *Levenshtein Transformer*, with `--noise='random_delete'`. Full scripts to run other models can also be found [here](./scripts.md). + +The following command will train a *Levenshtein Transformer* on the binarized dataset. + +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch levenshtein_transformer \ + --noise random_delete \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + +## Translate + +Once a model is trained, we can generate translations using an `iterative_refinement_generator` which will based on the model's initial output and iteratively read and greedily refine the translation until (1) the model predicts the same translations for two consecutive iterations; or (2) the generator reaches the maximum iterations (`--iter-decode-max-iter`). Use `--print-step` to check the actual # of iteration for each sentence. + +For *Levenshtein Transformer*, it sometimes helps to apply a `--iter-decode-eos-penalty` (typically, 0~3) to penalize the model finishing generation too early and generating too short translations. + +For example, to generate with `--iter-decode-max-iter=9`: +```bash +fairseq-generate \ + data-bin/wmt14_en_de_distill \ + --gen-subset test \ + --task translation_lev \ + --path checkpoints/checkpoint_best.pt \ + --iter-decode-max-iter 9 \ + --iter-decode-eos-penalty 0 \ + --beam 1 --remove-bpe \ + --print-step \ + --batch-size 400 +``` +In the end of the generation, we can see the tokenized BLEU score for the translation. + +## Advanced Decoding Methods +### Ensemble +The NAT models use special implementations of [ensembling](https://github.com/fairinternal/fairseq-py/blob/b98d88da52f2f21f1b169bab8c70c1c4ca19a768/fairseq/sequence_generator.py#L522) to support iterative refinement and a variety of parallel operations in different models, while it shares the same API as standard autoregressive models as follows: +```bash +fairseq-generate \ + data-bin/wmt14_en_de_distill \ + --gen-subset test \ + --task translation_lev \ + --path checkpoint_1.pt:checkpoint_2.pt:checkpoint_3.pt \ + --iter-decode-max-iter 9 \ + --iter-decode-eos-penalty 0 \ + --beam 1 --remove-bpe \ + --print-step \ + --batch-size 400 +``` +We use ``:`` to split multiple models. Note that, not all NAT models support ensembling for now. + + +### Length-beam +For models that predict lengths before decoding (e.g. the vanilla NAT, Mask-Predict, etc), it is possible to improve the translation quality by varying the target lengths around the predicted value, and translating the same example multiple times in parallel. We can select the best translation with the highest scores defined by your model's output. + +Note that, not all models support length beams. For models which dynamically change the lengths (e.g. *Insertion Transformer*, *Levenshtein Transformer*), the same trick does not apply. + +### Re-ranking +If the model generates multiple translations with length beam, we can also introduce an autoregressive model to rerank the translations considering scoring from an autoregressive model is much faster than decoding from that. + +For example, to generate translations with length beam and reranking, +```bash +fairseq-generate \ + data-bin/wmt14_en_de_distill \ + --gen-subset test \ + --task translation_lev \ + --path checkpoints/checkpoint_best.pt:at_checkpoints/checkpoint_best.pt \ + --iter-decode-max-iter 9 \ + --iter-decode-eos-penalty 0 \ + --iter-decode-with-beam 9 \ + --iter-decode-with-external-reranker \ + --beam 1 --remove-bpe \ + --print-step \ + --batch-size 100 +``` +Note that we need to make sure the autoregressive model shares the same vocabulary as our target non-autoregressive model. + + +## Citation + +```bibtex +@incollection{NIPS2019_9297, + title = {Levenshtein Transformer}, + author = {Gu, Jiatao and Wang, Changhan and Zhao, Junbo}, + booktitle = {Advances in Neural Information Processing Systems 32}, + editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett}, + pages = {11179--11189}, + year = {2019}, + publisher = {Curran Associates, Inc.}, + url = {http://papers.nips.cc/paper/9297-levenshtein-transformer.pdf} +} +``` +```bibtex +@article{zhou2019understanding, + title={Understanding Knowledge Distillation in Non-autoregressive Machine Translation}, + author={Zhou, Chunting and Neubig, Graham and Gu, Jiatao}, + journal={arXiv preprint arXiv:1911.02727}, + year={2019} +} +``` diff --git a/fairseq/examples/nonautoregressive_translation/scripts.md b/fairseq/examples/nonautoregressive_translation/scripts.md new file mode 100644 index 0000000000000000000000000000000000000000..9d3d7b67dc08440b5f4d1c5a7ffcd4bd6e76c14f --- /dev/null +++ b/fairseq/examples/nonautoregressive_translation/scripts.md @@ -0,0 +1,179 @@ +# Examples of Training scripts for Non-autoregressive Machine Translation models + +### Non-autoregressive Transformer (NAT, Gu et al., 2017) +Note that we need to have an additional module to perform "length prediction" (`--length-loss-factor`) before generating the whole sequence. +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch nonautoregressive_transformer \ + --noise full_mask \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --pred-length-offset \ + --length-loss-factor 0.1 \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + +### Fast Structured Decoding for Sequence Models (NAT-CRF, Sun et al., 2019) +Note that we implemented a low-rank appromixated CRF model by setting `--crf-lowrank-approx=32` and `--crf-beam-approx=64` as discribed in the original paper. All other settings are the same as the vanilla NAT model. +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch nacrf_transformer \ + --noise full_mask \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --pred-length-offset \ + --length-loss-factor 0.1 \ + --word-ins-loss-factor 0.5 \ + --crf-lowrank-approx 32 \ + --crf-beam-approx 64 \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + + +### Non-autoregressive Transformer with Iterative Refinement (iNAT, Lee et al., 2018) +Note that `--train-step` means how many iterations of refinement we used during training, and `--dae-ratio` controls the ratio of denoising auto-encoder training described in the original paper. +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch iterative_nonautoregressive_transformer \ + --noise full_mask \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --pred-length-offset \ + --length-loss-factor 0.1 \ + --train-step 4 \ + --dae-ratio 0.5 \ + --stochastic-approx \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + +### Insertion Transformer (InsT, Stern et al., 2019) +Note that we need to specify the "slot-loss" (uniform or balanced tree) described in the original paper. Here we use `--label-tau` to control the temperature. + +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch insertion_transformer \ + --noise random_delete \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + + +### Mask Predict (CMLM, Ghazvininejad et al., 2019) +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch cmlm_transformer \ + --noise random_mask \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` + + + + +### Levenshtein Transformer (LevT, Gu et al., 2019) +```bash +fairseq-train \ + data-bin/wmt14_en_de_distill \ + --save-dir checkpoints \ + --ddp-backend=legacy_ddp \ + --task translation_lev \ + --criterion nat_loss \ + --arch levenshtein_transformer \ + --noise random_delete \ + --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9,0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --stop-min-lr '1e-09' --warmup-updates 10000 \ + --warmup-init-lr '1e-07' --label-smoothing 0.1 \ + --dropout 0.3 --weight-decay 0.01 \ + --decoder-learned-pos \ + --encoder-learned-pos \ + --apply-bert-init \ + --log-format 'simple' --log-interval 100 \ + --fixed-validation-seed 7 \ + --max-tokens 8000 \ + --save-interval-updates 10000 \ + --max-update 300000 +``` diff --git a/fairseq/examples/paraphraser/README.md b/fairseq/examples/paraphraser/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3810311f30f99f0a07fd8e5d3723bffeba9948c3 --- /dev/null +++ b/fairseq/examples/paraphraser/README.md @@ -0,0 +1,46 @@ +# Paraphrasing with round-trip translation and mixture of experts + +Machine translation models can be used to paraphrase text by translating it to +an intermediate language and back (round-trip translation). + +This example shows how to paraphrase text by first passing it to an +English-French translation model, followed by a French-English [mixture of +experts translation model](/examples/translation_moe). + +##### 0. Setup + +Clone fairseq from source and install necessary dependencies: +```bash +git clone https://github.com/pytorch/fairseq.git +cd fairseq +pip install --editable . +pip install sacremoses sentencepiece +``` + +##### 1. Download models +```bash +wget https://dl.fbaipublicfiles.com/fairseq/models/paraphraser.en-fr.tar.gz +wget https://dl.fbaipublicfiles.com/fairseq/models/paraphraser.fr-en.hMoEup.tar.gz +tar -xzvf paraphraser.en-fr.tar.gz +tar -xzvf paraphraser.fr-en.hMoEup.tar.gz +``` + +##### 2. Paraphrase +```bash +python examples/paraphraser/paraphrase.py \ + --en2fr paraphraser.en-fr \ + --fr2en paraphraser.fr-en.hMoEup +# Example input: +# The new date for the Games, postponed for a year in response to the coronavirus pandemic, gives athletes time to recalibrate their training schedules. +# Example outputs: +# Delayed one year in response to the coronavirus pandemic, the new date of the Games gives athletes time to rebalance their training schedule. +# The new date of the Games, which was rescheduled one year in response to the coronavirus (CV) pandemic, gives athletes time to rebalance their training schedule. +# The new date of the Games, postponed one year in response to the coronavirus pandemic, provides athletes with time to rebalance their training schedule. +# The Games' new date, postponed one year in response to the coronavirus pandemic, gives athletes time to rebalance their training schedule. +# The new Games date, postponed one year in response to the coronavirus pandemic, gives the athletes time to rebalance their training schedule. +# The new date of the Games, which was postponed one year in response to the coronavirus pandemic, gives the athletes time to rebalance their training schedule. +# The new date of the Games, postponed one year in response to the coronavirus pandemic, gives athletes time to rebalance their training schedule. +# The new date of the Games, postponed one year in response to the coronavirus pandemic, gives athletes time to re-balance their training schedule. +# The new date of the Games, postponed one year in response to the coronavirus pandemic, gives the athletes time to rebalance their schedule of training. +# The new date of the Games, postponed one year in response to the pandemic of coronavirus, gives the athletes time to rebalance their training schedule. +``` diff --git a/fairseq/examples/paraphraser/paraphrase.py b/fairseq/examples/paraphraser/paraphrase.py new file mode 100644 index 0000000000000000000000000000000000000000..d3422fb3db9a381b73a854d2379df214ebe544a2 --- /dev/null +++ b/fairseq/examples/paraphraser/paraphrase.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python3 -u + +import argparse +import fileinput +import logging +import os +import sys + +from fairseq.models.transformer import TransformerModel + + +logging.getLogger().setLevel(logging.INFO) + + +def main(): + parser = argparse.ArgumentParser(description="") + parser.add_argument("--en2fr", required=True, help="path to en2fr model") + parser.add_argument( + "--fr2en", required=True, help="path to fr2en mixture of experts model" + ) + parser.add_argument( + "--user-dir", help="path to fairseq examples/translation_moe/src directory" + ) + parser.add_argument( + "--num-experts", + type=int, + default=10, + help="(keep at 10 unless using a different model)", + ) + parser.add_argument( + "files", + nargs="*", + default=["-"], + help='input files to paraphrase; "-" for stdin', + ) + args = parser.parse_args() + + if args.user_dir is None: + args.user_dir = os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), # examples/ + "translation_moe", + "src", + ) + if os.path.exists(args.user_dir): + logging.info("found user_dir:" + args.user_dir) + else: + raise RuntimeError( + "cannot find fairseq examples/translation_moe/src " + "(tried looking here: {})".format(args.user_dir) + ) + + logging.info("loading en2fr model from:" + args.en2fr) + en2fr = TransformerModel.from_pretrained( + model_name_or_path=args.en2fr, + tokenizer="moses", + bpe="sentencepiece", + ).eval() + + logging.info("loading fr2en model from:" + args.fr2en) + fr2en = TransformerModel.from_pretrained( + model_name_or_path=args.fr2en, + tokenizer="moses", + bpe="sentencepiece", + user_dir=args.user_dir, + task="translation_moe", + ).eval() + + def gen_paraphrases(en): + fr = en2fr.translate(en) + return [ + fr2en.translate(fr, inference_step_args={"expert": i}) + for i in range(args.num_experts) + ] + + logging.info("Type the input sentence and press return:") + for line in fileinput.input(args.files): + line = line.strip() + if len(line) == 0: + continue + for paraphrase in gen_paraphrases(line): + print(paraphrase) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/pay_less_attention_paper/README.md b/fairseq/examples/pay_less_attention_paper/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5adab11f4dc3461f9e7126ac391b04e703616e6b --- /dev/null +++ b/fairseq/examples/pay_less_attention_paper/README.md @@ -0,0 +1,176 @@ +# Pay Less Attention with Lightweight and Dynamic Convolutions (Wu et al., 2019) + +This page contains pointers to pre-trained models as well as instructions on how to train new models for [our paper](https://arxiv.org/abs/1901.10430). + +## Citation: +```bibtex +@inproceedings{wu2018pay, + title = {Pay Less Attention with Lightweight and Dynamic Convolutions}, + author = {Felix Wu and Angela Fan and Alexei Baevski and Yann Dauphin and Michael Auli}, + booktitle = {International Conference on Learning Representations}, + year = {2019}, + url = {https://arxiv.org/abs/1901.10430}, +} +``` + +## Translation + +### Pre-trained models +For some datasets we release models without GLUs which are faster at inference. + +Model | Description | Dataset | Download +---|---|---|--- +`lightconv.no_glu.iwslt14.de-en` | LightConv (without GLUs) | [IWSLT14 German-English](https://wit3.fbk.eu/archive/2014-01/texts/de/en/de-en.tgz) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.lightconv.tar.gz) <br> IWSLT14 test: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/iwslt14.de-en.test.tar.bz2) +`dynamicconv.no_glu.iwslt14.de-en` | DynamicConv (without GLUs) | [IWSLT14 German-English](https://wit3.fbk.eu/archive/2014-01/texts/de/en/de-en.tgz) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.dynamicconv.tar.gz) <br> IWSLT14 test: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/iwslt14.de-en.test.tar.bz2) +`lightconv.no_glu.wmt16.en-de` | LightConv (without GLUs) | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv.tar.gz) <br> newstest2014 (shared vocab): <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) +`dynamicconv.no_glu.wmt16.en-de` | DynamicConv (without GLUs) | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv.tar.gz) <br> newstest2014 (shared vocab): <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) +`lightconv.glu.wmt16.en-de` | LightConv | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv-glu.tar.gz) <br> newstest2014 (shared vocab): <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) +`dynamicconv.glu.wmt16.en-de` | DynamicConv | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv-glu.tar.gz) <br> newstest2014 (shared vocab): <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) +`lightconv.glu.wmt14.en-fr` | LightConv | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.lightconv-glu.tar.gz) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-fr.joined-dict.newstest2014.tar.bz2) +`dynamicconv.glu.wmt14.en-fr` | DynamicConv | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.dynamicconv-glu.tar.gz) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-fr.joined-dict.newstest2014.tar.bz2) +`lightconv.glu.wmt17.zh-en` | LightConv | [WMT17 Chinese-English](http://statmt.org/wmt17/translation-task.html#Download) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.lightconv-glu.tar.gz) <br> newstest2017: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt17.zh-en.newstest2017.tar.bz2) +`dynamicconv.glu.wmt17.zh-en` | DynamicConv | [WMT17 Chinese-English](http://statmt.org/wmt17/translation-task.html#Download) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.dynamicconv-glu.tar.gz) <br> newstest2017: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt17.zh-en.newstest2017.tar.bz2) + +### Memory-Efficient CUDA Kernels + +Since the PyTorch implementations of Light/Dynamic conv are quite memory intensive, we have developed CUDA kernels that implement the light and dynamic convolution operator in a memory-efficient and performant manner. For large sequence lengths, these kernels save about 50% memory compared to the PyTorch equivalent. + +To install the kernels, use the commands below. Once installed, they will automatically be used in place of the PyTorch implementations whenever a light or dynamic convolution is used. + +```sh +# to install lightconv +cd fairseq/modules/lightconv_layer +python cuda_function_gen.py +python setup.py install + +# to install dynamicconv +cd fairseq/modules/dynamicconv_layer +python cuda_function_gen.py +python setup.py install +``` + +### Example usage (torch.hub) + +We require a few additional Python dependencies for preprocessing: +```bash +pip install sacremoses subword_nmt +``` + +Interactive translation via PyTorch Hub: +```python +import torch + +# List available models +torch.hub.list('pytorch/fairseq') # [..., 'lightconv.glu.wmt17.zh-en', ... ] + +# Load a transformer trained on WMT'16 En-De +zh2en = torch.hub.load('pytorch/fairseq', 'lightconv.glu.wmt17.zh-en', tokenizer='moses', bpe='subword_nmt') + +# The underlying model is available under the *models* attribute +assert isinstance(zh2en.models[0], fairseq.models.lightconv.LightConvModel) + +# Translate a sentence +zh2en.translate('你好 世界') +# 'Hello World' +``` + +Loading custom models: +```python +from fairseq.models.lightconv import LightConvModel +en2fr = LightConvModel.from_pretrained( + '/path/to/checkpoints', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='data-bin/wmt14_en_fr', + bpe='subword_nmt', + bpe_codes='data-bin/wmt14_en_fr/en.code' +) +en2fr.translate('Hello world!') +# 'Bonjour le monde' +``` + +### Preprocessing the training datasets + +Please follow the instructions in [`examples/translation/README.md`](../translation/README.md) to preprocess the data. + +### Training and evaluation options: +To use the model without GLU, please set `--encoder-glu 0 --decoder-glu 0`. +For LightConv, please use `--encoder-conv-type lightweight --decoder-conv-type lightweight`, otherwise the default is DynamicConv. +For best BLEU results, lenpen may need to be manually tuned. + +To use the CUDA kernels, first install the PyTorch modules using the commands +above. Once the CUDA modules are installed, they will automatically be used +instead of the PyTorch modules. + +### IWSLT14 De-En +Training and evaluating DynamicConv (without GLU) on a GPU: +```sh +# Training +SAVE="save/dynamic_conv_iwslt" +mkdir -p $SAVE +CUDA_VISIBLE_DEVICES=0 $(which fairseq-train) data-bin/iwslt14.tokenized.de-en \ + --clip-norm 0 --optimizer adam --lr 0.0005 \ + --source-lang de --target-lang en --max-tokens 4000 --no-progress-bar \ + --log-interval 100 --stop-min-lr '1e-09' --weight-decay 0.0001 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --lr-scheduler inverse_sqrt \ + --ddp-backend=legacy_ddp \ + --max-update 50000 --warmup-updates 4000 --warmup-init-lr '1e-07' \ + --adam-betas '(0.9, 0.98)' --keep-last-epochs 10 \ + -a lightconv_iwslt_de_en --save-dir $SAVE \ + --dropout 0.3 --attention-dropout 0.1 --weight-dropout 0.1 \ + --encoder-glu 0 --decoder-glu 0 +python scripts/average_checkpoints.py --inputs $SAVE \ + --num-epoch-checkpoints 10 --output "${SAVE}/checkpoint_last10_avg.pt" + +# Evaluation +CUDA_VISIBLE_DEVICES=0 fairseq-generate data-bin/iwslt14.tokenized.de-en --path "${SAVE}/checkpoint_last10_avg.pt" --batch-size 128 --beam 4 --remove-bpe --lenpen 1 --gen-subset test --quiet +``` + +### WMT16 En-De +Training and evaluating DynamicConv (with GLU) on WMT16 En-De using cosine scheduler on one machine with 8 V100 GPUs: +```sh +# Training +SAVE="save/dynamic_conv_wmt16en2de" +mkdir -p $SAVE +python -m torch.distributed.launch --nproc_per_node 8 $(which fairseq-train) \ + data-bin/wmt16_en_de_bpe32k --fp16 --log-interval 100 --no-progress-bar \ + --max-update 30000 --share-all-embeddings --optimizer adam \ + --adam-betas '(0.9, 0.98)' --clip-norm 0.0 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --stop-min-lr 1e-09 --update-freq 16 --attention-dropout 0.1 --keep-last-epochs 10 \ + --ddp-backend=legacy_ddp --max-tokens 3584 \ + --lr-scheduler cosine --warmup-init-lr 1e-7 --warmup-updates 10000 \ + --lr-shrink 1 --lr 0.001 --min-lr 1e-7 --warmup-init-lr 1e-07 \ + --t-mult 1 --lr-period-updates 20000 \ + --arch lightconv_wmt_en_de_big --save-dir $SAVE \ + --dropout 0.3 --attention-dropout 0.1 --weight-dropout 0.1 \ + --encoder-glu 1 --decoder-glu 1 + +# Evaluation +CUDA_VISIBLE_DEVICES=0 fairseq-generate data-bin/wmt16.en-de.joined-dict.newstest2014 --path "${SAVE}/checkpoint_best.pt" --batch-size 128 --beam 5 --remove-bpe --lenpen 0.5 --gen-subset test > wmt16_gen.txt +bash scripts/compound_split_bleu.sh wmt16_gen.txt +``` + +### WMT14 En-Fr +Training DynamicConv (with GLU) on WMT14 En-Fr using cosine scheduler on one machine with 8 V100 GPUs: +```sh +# Training +SAVE="save/dynamic_conv_wmt14en2fr" +mkdir -p $SAVE +python -m torch.distributed.launch --nproc_per_node 8 $(which fairseq-train) \ + data-bin/wmt14_en_fr --fp16 --log-interval 100 --no-progress-bar \ + --max-update 30000 --share-all-embeddings --optimizer adam \ + --adam-betas '(0.9, 0.98)' --clip-norm 0.0 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --stop-min-lr 1e-09 --update-freq 16 --attention-dropout 0.1 --keep-last-epochs 10 \ + --ddp-backend=legacy_ddp --max-tokens 3584 \ + --lr-scheduler cosine --warmup-init-lr 1e-7 --warmup-updates 10000 \ + --lr-shrink 1 --lr 0.001 --min-lr 1e-7 --warmup-init-lr 1e-07 \ + --t-mult 1 --lr-period-updates 70000 \ + --arch lightconv_wmt_en_fr_big --save-dir $SAVE \ + --dropout 0.1 --attention-dropout 0.1 --weight-dropout 0.1 \ + --encoder-glu 1 --decoder-glu 1 + +# Evaluation +CUDA_VISIBLE_DEVICES=0 fairseq-generate data-bin/wmt14.en-fr.joined-dict.newstest2014 --path "${SAVE}/checkpoint_best.pt" --batch-size 128 --beam 5 --remove-bpe --lenpen 0.9 --gen-subset test +``` diff --git a/fairseq/examples/pointer_generator/README.md b/fairseq/examples/pointer_generator/README.md new file mode 100644 index 0000000000000000000000000000000000000000..60965708254aae2174812ea6686a9807825b7fb6 --- /dev/null +++ b/fairseq/examples/pointer_generator/README.md @@ -0,0 +1,82 @@ +# Transformer with Pointer-Generator Network + +This page describes the `transformer_pointer_generator` model that incorporates +a pointing mechanism in the Transformer model that facilitates copying of input +words to the output. This architecture is described in [Enarvi et al. (2020)](https://www.aclweb.org/anthology/2020.nlpmc-1.4/). + +## Background + +The pointer-generator network was introduced in [See et al. (2017)](https://arxiv.org/abs/1704.04368) +for RNN encoder-decoder attention models. A similar mechanism can be +incorporated in a Transformer model by reusing one of the many attention +distributions for pointing. The attention distribution over the input words is +interpolated with the normal output distribution over the vocabulary words. This +allows the model to generate words that appear in the input, even if they don't +appear in the vocabulary, helping especially with small vocabularies. + +## Implementation + +The mechanism for copying out-of-vocabulary words from the input has been +implemented differently to See et al. In their [implementation](https://github.com/abisee/pointer-generator) +they convey the word identities through the model in order to be able to produce +words that appear in the input sequence but not in the vocabulary. A different +approach was taken in the Fairseq implementation to keep it self-contained in +the model file, avoiding any changes to the rest of the code base. Copying +out-of-vocabulary words is possible by pre-processing the input and +post-processing the output. This is described in detail in the next section. + +## Usage + +The training and evaluation procedure is outlined below. You can also find a +more detailed example for the XSum dataset on [this page](README.xsum.md). + +##### 1. Create a vocabulary and extend it with source position markers + +The pointing mechanism is especially helpful with small vocabularies, if we are +able to recover the identities of any out-of-vocabulary words that are copied +from the input. For this purpose, the model allows extending the vocabulary with +special tokens that can be used in place of `<unk>` tokens to identify different +input positions. For example, the user may add `<unk-0>`, `<unk-1>`, `<unk-2>`, +etc. to the end of the vocabulary, after the normal words. Below is an example +of how to create a vocabulary of 10000 most common words and add 1000 input +position markers. + +```bash +vocab_size=10000 +position_markers=1000 +export LC_ALL=C +cat train.src train.tgt | + tr -s '[:space:]' '\n' | + sort | + uniq -c | + sort -k1,1bnr -k2 | + head -n "$((vocab_size - 4))" | + awk '{ print $2 " " $1 }' >dict.pg.txt +python3 -c "[print('<unk-{}> 0'.format(n)) for n in range($position_markers)]" >>dict.pg.txt +``` + +##### 2. Preprocess the text data + +The idea is that any `<unk>` tokens in the text are replaced with `<unk-0>` if +it appears in the first input position, `<unk-1>` if it appears in the second +input position, and so on. This can be achieved using the `preprocess.py` script +that is provided in this directory. + +##### 3. Train a model + +The number of these special tokens is given to the model with the +`--source-position-markers` argument—the model simply maps all of these to the +same word embedding as `<unk>`. + +The attention distribution that is used for pointing is selected using the +`--alignment-heads` and `--alignment-layer` command-line arguments in the same +way as with the `transformer_align` model. + +##### 4. Generate text and postprocess it + +When using the model to generate text, you want to preprocess the input text in +the same way that training data was processed, replacing out-of-vocabulary words +with `<unk-N>` tokens. If any of these tokens are copied to the output, the +actual words can be retrieved from the unprocessed input text. Any `<unk-N>` +token should be replaced with the word at position N in the original input +sequence. This can be achieved using the `postprocess.py` script. diff --git a/fairseq/examples/pointer_generator/README.xsum.md b/fairseq/examples/pointer_generator/README.xsum.md new file mode 100644 index 0000000000000000000000000000000000000000..ac3a8c3ddc96cd9810b45d49f6b361e43de1e9fb --- /dev/null +++ b/fairseq/examples/pointer_generator/README.xsum.md @@ -0,0 +1,180 @@ +## Training a pointer-generator model on the Extreme Summarization dataset + +##### 1. Download the Extreme Summarization data and preprocess it + +Follow the instructions [here](https://github.com/EdinburghNLP/XSum) to obtain +the original Extreme Summarization dataset. You should have six files, +{train,validation,test}.{document,summary}. + +##### 2. Create a vocabulary and extend it with source position markers + +```bash +vocab_size=10000 +position_markers=1000 +export LC_ALL=C +cat train.document train.summary | + tr -s '[:space:]' '\n' | + sort | + uniq -c | + sort -k1,1bnr -k2 | + head -n "$((vocab_size - 4))" | + awk '{ print $2 " " $1 }' >dict.pg.txt +python3 -c "[print('<unk-{}> 0'.format(n)) for n in range($position_markers)]" >>dict.pg.txt +``` + +This creates the file dict.pg.txt that contains the 10k most frequent words, +followed by 1k source position markers: + +``` +the 4954867 +. 4157552 +, 3439668 +to 2212159 +a 1916857 +of 1916820 +and 1823350 +... +<unk-0> 0 +<unk-1> 0 +<unk-2> 0 +<unk-3> 0 +<unk-4> 0 +... +``` + +##### 2. Preprocess the text data + +```bash +./preprocess.py --source train.document --target train.summary --vocab <(cut -d' ' -f1 dict.pg.txt) --source-out train.pg.src --target-out train.pg.tgt +./preprocess.py --source validation.document --target validation.summary --vocab <(cut -d' ' -f1 dict.pg.txt) --source-out valid.pg.src --target-out valid.pg.tgt +./preprocess.py --source test.document --vocab <(cut -d' ' -f1 dict.pg.txt) --source-out test.pg.src +``` + +The data should now contain `<unk-N>` tokens in place of out-of-vocabulary words. + +##### 3. Binarize the dataset: + +```bash +fairseq-preprocess \ + --source-lang src \ + --target-lang tgt \ + --trainpref train.pg \ + --validpref valid.pg \ + --destdir bin \ + --workers 60 \ + --srcdict dict.pg.txt \ + --joined-dictionary +``` + +##### 3. Train a model + +```bash +total_updates=20000 +warmup_updates=500 +lr=0.001 +max_tokens=4096 +update_freq=4 +pointer_layer=-2 + +CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 fairseq-train bin \ + --user-dir examples/pointer_generator/pointer_generator_src \ + --max-tokens "$max_tokens" \ + --task translation \ + --source-lang src --target-lang tgt \ + --truncate-source \ + --layernorm-embedding \ + --share-all-embeddings \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --required-batch-size-multiple 1 \ + --arch transformer_pointer_generator \ + --alignment-layer "$pointer_layer" \ + --alignment-heads 1 \ + --source-position-markers 1000 \ + --criterion label_smoothed_cross_entropy \ + --label-smoothing 0.1 \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.01 --optimizer adam --adam-betas "(0.9, 0.999)" --adam-eps 1e-08 \ + --clip-norm 0.1 \ + --lr-scheduler inverse_sqrt --lr "$lr" --max-update "$total_updates" --warmup-updates "$warmup_updates" \ + --update-freq "$update_freq" \ + --skip-invalid-size-inputs-valid-test +``` + +Above we specify that our dictionary contains 1000 source position markers, and +that we want to use one attention head from the penultimate decoder layer for +pointing. It should run in 5.5 hours on one node with eight 32GB V100 GPUs. The +logged messages confirm that dictionary indices above 10000 will be mapped to +the `<unk>` embedding: + +``` +2020-09-24 20:43:53 | INFO | fairseq.tasks.translation | [src] dictionary: 11000 types +2020-09-24 20:43:53 | INFO | fairseq.tasks.translation | [tgt] dictionary: 11000 types +2020-09-24 20:43:53 | INFO | fairseq.data.data_utils | loaded 11332 examples from: bin/valid.src-tgt.src +2020-09-24 20:43:53 | INFO | fairseq.data.data_utils | loaded 11332 examples from: bin/valid.src-tgt.tgt +2020-09-24 20:43:53 | INFO | fairseq.tasks.translation | bin valid src-tgt 11332 examples +2020-09-24 20:43:53 | INFO | fairseq.models.transformer_pg | dictionary indices from 10000 to 10999 will be mapped to 3 +``` + +##### 4. Summarize the test sequences + +```bash +batch_size=32 +beam_size=6 +max_length=60 +length_penalty=1.0 + +fairseq-interactive bin \ + --user-dir examples/pointer_generator/pointer_generator_src \ + --batch-size "$batch_size" \ + --task translation \ + --source-lang src --target-lang tgt \ + --path checkpoints/checkpoint_last.pt \ + --input test.pg.src \ + --buffer-size 200 \ + --max-len-a 0 \ + --max-len-b "$max_length" \ + --lenpen "$length_penalty" \ + --beam "$beam_size" \ + --skip-invalid-size-inputs-valid-test | + tee generate.out +grep ^H generate.out | cut -f 3- >generate.hyp +``` + +Now you should have the generated sequences in `generate.hyp`. They contain +`<unk-N>` tokens that the model has copied from the source sequence. In order to +retrieve the original words, we need the unprocessed source sequences from +`test.document`. + +##### 5. Process the generated output + +Since we skipped too long inputs when producing `generate.hyp`, we also have to +skip too long sequences now that we read `test.document`. + +```bash +./postprocess.py \ + --source <(awk 'NF<1024' test.document) \ + --target generate.hyp \ + --target-out generate.hyp.processed +``` + +Now you'll find the final sequences from `generate.hyp.processed`, with +`<unk-N>` replaced with the original word from the source sequence. + +##### An example of a summarized sequence + +The original source document in `test.document`: + +> de roon moved to teesside in june 2016 for an initial # 8.8 m fee and played 33 premier league games last term . the netherlands international , 26 , scored five goals in 36 league and cup games during his spell at boro . meanwhile , manager garry monk confirmed the championship club 's interest in signing chelsea midfielder lewis baker . `` he 's a target and one of many that we 've had throughout the summer months , '' said monk . find all the latest football transfers on our dedicated page . + +The preprocessed source document in `test.src.pg`: + +> de \<unk-1> moved to \<unk-4> in june 2016 for an initial # \<unk-12> m fee and played 33 premier league games last term . the netherlands international , 26 , scored five goals in 36 league and cup games during his spell at boro . meanwhile , manager garry monk confirmed the championship club 's interest in signing chelsea midfielder lewis baker . `` he 's a target and one of many that we 've had throughout the summer months , '' said monk . find all the latest football transfers on our dedicated page . + +The generated summary in `generate.hyp`: + +> middlesbrough striker \<unk> de \<unk-1> has joined spanish side \<unk> on a season-long loan . + +The generated summary after postprocessing in `generate.hyp.processed`: + +> middlesbrough striker \<unk> de roon has joined spanish side \<unk> on a season-long loan . diff --git a/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py b/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c361ff6bd616512fe2521387665de1ad1aff66d0 --- /dev/null +++ b/fairseq/examples/pointer_generator/pointer_generator_src/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import transformer_pg # noqa diff --git a/fairseq/examples/pointer_generator/pointer_generator_src/transformer_pg.py b/fairseq/examples/pointer_generator/pointer_generator_src/transformer_pg.py new file mode 100644 index 0000000000000000000000000000000000000000..4ccf30f4eb154f8fab1e285934fb973a2d1166cb --- /dev/null +++ b/fairseq/examples/pointer_generator/pointer_generator_src/transformer_pg.py @@ -0,0 +1,518 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import Any, Dict, Optional, List, Tuple + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer import ( + DEFAULT_MAX_SOURCE_POSITIONS, + DEFAULT_MAX_TARGET_POSITIONS, + TransformerDecoder, + TransformerEncoder, + TransformerModel, + base_architecture, +) +from torch import Tensor + + +logger = logging.getLogger(__name__) + + +@register_model("transformer_pointer_generator") +class TransformerPointerGeneratorModel(TransformerModel): + """ + Transformer model from `"Attention Is All You Need" (Vaswani et al, 2017) + <https://arxiv.org/abs/1706.03762>`_, augmented with a pointer-generator + network from `"Get To The Point: Summarization with Pointer-Generator + Networks" (See et al, 2017) <https://arxiv.org/abs/1704.04368>`_. + + Args: + encoder (TransformerPointerGeneratorEncoder): the encoder + decoder (TransformerPointerGeneratorDecoder): the decoder + + The Transformer pointer-generator model provides the following named + architectures and command-line arguments: + + .. argparse:: + :ref: fairseq.models.transformer_pointer_generator_parser + :prog: + """ + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + TransformerModel.add_args(parser) + parser.add_argument('--alignment-heads', type=int, metavar='N', + help='number of attention heads to be used for ' + 'pointing') + parser.add_argument('--alignment-layer', type=int, metavar='I', + help='layer number to be used for pointing (0 ' + 'corresponding to the bottommost layer)') + parser.add_argument('--source-position-markers', type=int, metavar='N', + help='dictionary includes N additional items that ' + 'represent an OOV token at a particular input ' + 'position') + parser.add_argument('--force-generation', type=float, metavar='P', + default=None, + help='set the vocabulary distribution weight to P, ' + 'instead of predicting it from the input (1.0 ' + 'corresponding to generation, 0.0 to pointing)') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if args.encoder_layers_to_keep: + args.encoder_layers = len(args.encoder_layers_to_keep.split(",")) + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if getattr(args, "max_source_positions", None) is None: + args.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = DEFAULT_MAX_TARGET_POSITIONS + if getattr(args, "source_position_markers", None) is None: + args.source_position_markers = args.max_source_positions + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + if src_dict != tgt_dict: + raise ValueError("Pointer-generator requires a joined dictionary") + + def build_embedding(dictionary, embed_dim, path=None): + # The dictionary may include additional items that can be used in + # place of the normal OOV token and that all map to the same + # embedding. Using a different token for each input position allows + # one to restore the word identities from the original source text. + num_embeddings = len(dictionary) - args.source_position_markers + padding_idx = dictionary.pad() + unk_idx = dictionary.unk() + logger.info( + "dictionary indices from {0} to {1} will be mapped to {2}".format( + num_embeddings, len(dictionary) - 1, unk_idx + ) + ) + emb = Embedding(num_embeddings, embed_dim, padding_idx, unk_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + if args.share_all_embeddings: + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = build_embedding( + src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + encoder_embed_tokens = build_embedding( + src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = build_embedding( + tgt_dict, args.decoder_embed_dim, args.decoder_embed_path + ) + + encoder = cls.build_encoder(args, src_dict, encoder_embed_tokens) + decoder = cls.build_decoder(args, tgt_dict, decoder_embed_tokens) + return cls(args, encoder, decoder) + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerPointerGeneratorEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerPointerGeneratorDecoder(args, tgt_dict, embed_tokens) + + +class TransformerPointerGeneratorEncoder(TransformerEncoder): + """ + Transformer encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`TransformerEncoderLayer`. The pointer-generator variant adds + the source tokens to the encoder output as these are otherwise not passed + to the decoder. + """ + + def forward( + self, + src_tokens, + src_lengths: Optional[Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[Tensor] = None + ): + """ + Runs the `forward()` method of the parent Transformer class. Then adds + the source tokens into the encoder output tuple. + + While it might be more elegant that the model would pass the source + tokens to the `forward()` method of the decoder too, this would require + changes to `SequenceGenerator`. + + Args: + src_tokens (torch.LongTensor): tokens in the source language of + shape `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + namedtuple: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + - **src_tokens** (Tensor): input token ids of shape + `(batch, src_len)` + """ + encoder_out = self.forward_scriptable(src_tokens, + src_lengths, + return_all_hiddens, + token_embeddings) + + # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in + # `forward` so we use a dictionary instead. + # TorchScript does not support mixed values so the values are all lists. + # The empty list is equivalent to None. + return { + "encoder_out": encoder_out["encoder_out"], # T x B x C + "encoder_padding_mask": encoder_out["encoder_padding_mask"], # B x T + "encoder_embedding": encoder_out["encoder_embedding"], # B x T x C + "encoder_states": encoder_out["encoder_states"], # List[T x B x C] + "src_tokens": [src_tokens], # B x T + "src_lengths": [], + } + + +class TransformerPointerGeneratorDecoder(TransformerDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. The pointer-generator variant mixes + the output probabilities with an attention distribution in the output layer. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + """ + + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens, no_encoder_attn=False) + + # In the pointer-generator model these arguments define the decoder + # layer and the number of attention heads that will be averaged to + # create the alignment for pointing. + self.alignment_heads = args.alignment_heads + self.alignment_layer = args.alignment_layer + + input_embed_dim = embed_tokens.embedding_dim + + # Generation probabilities / interpolation coefficients are predicted + # from the current decoder input embedding and the decoder output, which + # is the size of output_embed_dim. + p_gen_input_size = input_embed_dim + self.output_embed_dim + self.project_p_gens = nn.Linear(p_gen_input_size, 1) + nn.init.zeros_(self.project_p_gens.bias) + + # The dictionary may include a separate entry for an OOV token in each + # input position, so that their identity can be restored from the + # original source text. + self.num_types = len(dictionary) + self.num_oov_types = args.source_position_markers + self.num_embeddings = self.num_types - self.num_oov_types + self.force_p_gen = args.force_generation + + def forward( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + alignment_layer: Optional[int] = 0, + alignment_heads: Optional[int] = 1, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention + incremental_state (dict, optional): dictionary used for storing + state during :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False) + alignment_layer (int, optional): 0-based index of the layer to be + used for pointing (default: 0) + alignment_heads (int, optional): number of attention heads to be + used for pointing (default: 1) + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + # The normal Transformer model doesn't pass the alignment_layer and + # alignment_heads parameters correctly. We use our local variables. + x, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + incremental_state=incremental_state, + alignment_layer=self.alignment_layer, + alignment_heads=self.alignment_heads, + ) + if not features_only: + # Embedding the tokens again for generation probability prediction, + # so that we don't have to reimplement the whole extract_features() + # method. + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + prev_output_embed = self.embed_tokens(prev_output_tokens) + prev_output_embed *= self.embed_scale + predictors = torch.cat((prev_output_embed, x), 2) + p_gens = self.project_p_gens(predictors) + p_gens = torch.sigmoid(p_gens.float()) + # Torchscript complains if encoder_out or attn are None because + # `output_layer()` signature expects tensors instead + attn: Optional[Tensor] = extra["attn"][0] + assert encoder_out is not None + assert attn is not None + x = self.output_layer(x, attn, encoder_out["src_tokens"][0], p_gens) + return x, extra + + def output_layer( + self, + features: Tensor, + attn: Tensor, + src_tokens: Tensor, + p_gens: Tensor + ) -> Tensor: + """ + Project features to the vocabulary size and mix with the attention + distributions. + """ + if self.force_p_gen is not None: + p_gens = self.force_p_gen + + # project back to size of vocabulary + if self.adaptive_softmax is None: + logits = self.output_projection(features) + else: + logits = features + + batch_size = logits.shape[0] + output_length = logits.shape[1] + assert logits.shape[2] == self.num_embeddings + assert src_tokens.shape[0] == batch_size + src_length = src_tokens.shape[1] + + # The final output distribution will be a mixture of the normal output + # distribution (softmax of logits) and attention weights. + gen_dists = self.get_normalized_probs_scriptable( + (logits, None), log_probs=False, sample=None + ) + gen_dists = torch.mul(gen_dists, p_gens) + padding_size = (batch_size, output_length, self.num_oov_types) + padding = gen_dists.new_zeros(padding_size) + gen_dists = torch.cat((gen_dists, padding), 2) + assert gen_dists.shape[2] == self.num_types + + # Scatter attention distributions to distributions over the extended + # vocabulary in a tensor of shape [batch_size, output_length, + # vocab_size]. Each attention weight will be written into a location + # that is for other dimensions the same as in the index tensor, but for + # the third dimension it's the value of the index tensor (the token ID). + attn = torch.mul(attn.float(), 1 - p_gens) + index = src_tokens[:, None, :] + index = index.expand(batch_size, output_length, src_length) + attn_dists_size = (batch_size, output_length, self.num_types) + attn_dists = attn.new_zeros(attn_dists_size) + attn_dists.scatter_add_(2, index, attn.float()) + + # Final distributions, [batch_size, output_length, num_types]. + return gen_dists + attn_dists + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """ + Get normalized probabilities (or log probs) from a net's output. + Pointer-generator network output is already normalized. + """ + probs = net_output[0] + # Make sure the probabilities are greater than zero when returning log + # probabilities. + return probs.clamp(1e-10, 1.0).log() if log_probs else probs + + +class Embedding(nn.Embedding): + r"""A simple lookup table that stores embeddings of a fixed dictionary and size. + This module is often used to store word embeddings and retrieve them using indices. + The input to the module is a list of indices, and the output is the corresponding + word embeddings. This subclass differs from the standard PyTorch Embedding class by + allowing additional vocabulary entries that will be mapped to the unknown token + embedding. + Args: + num_embeddings (int): size of the dictionary of embeddings + embedding_dim (int): the size of each embedding vector + padding_idx (int): Pads the output with the embedding vector at :attr:`padding_idx` + (initialized to zeros) whenever it encounters the index. + unk_idx (int): Maps all token indices that are greater than or equal to + num_embeddings to this index. + Attributes: + weight (Tensor): the learnable weights of the module of shape (num_embeddings, embedding_dim) + initialized from :math:`\mathcal{N}(0, 1)` + Shape: + - Input: :math:`(*)`, LongTensor of arbitrary shape containing the indices to extract + - Output: :math:`(*, H)`, where `*` is the input shape and :math:`H=\text{embedding\_dim}` + .. note:: + Keep in mind that only a limited number of optimizers support + sparse gradients: currently it's :class:`optim.SGD` (`CUDA` and `CPU`), + :class:`optim.SparseAdam` (`CUDA` and `CPU`) and :class:`optim.Adagrad` (`CPU`) + .. note:: + With :attr:`padding_idx` set, the embedding vector at + :attr:`padding_idx` is initialized to all zeros. However, note that this + vector can be modified afterwards, e.g., using a customized + initialization method, and thus changing the vector used to pad the + output. The gradient for this vector from :class:`~torch.nn.Embedding` + is always zero. + """ + __constants__ = ["unk_idx"] + + # Torchscript: Inheriting from Embedding class produces an error when exporting to Torchscript + # -> RuntimeError: Unable to cast Python instance to C++ type (compile in debug mode for details + # It's happening because max_norm attribute from nn.Embedding is None by default and it cannot be + # cast to a C++ type + def __init__( + self, + num_embeddings: int, + embedding_dim: int, + padding_idx: Optional[int], + unk_idx: int, + max_norm: Optional[float] = float("inf"), + ): + super().__init__(num_embeddings, embedding_dim, padding_idx=padding_idx, max_norm=max_norm) + self.unk_idx = unk_idx + nn.init.normal_(self.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(self.weight[padding_idx], 0) + + def forward(self, input): + input = torch.where( + input >= self.num_embeddings, torch.ones_like(input) * self.unk_idx, input + ) + return nn.functional.embedding( + input, self.weight, self.padding_idx, self.max_norm, + self.norm_type, self.scale_grad_by_freq, self.sparse + ) + + +@register_model_architecture( + "transformer_pointer_generator", "transformer_pointer_generator" +) +def transformer_pointer_generator(args): + args.alignment_heads = getattr(args, "alignment_heads", 1) + args.alignment_layer = getattr(args, "alignment_layer", -1) + base_architecture(args) + if args.alignment_layer < 0: + args.alignment_layer = args.decoder_layers + args.alignment_layer + + +@register_model_architecture( + "transformer_pointer_generator", "transformer_pointer_generator_iwslt_de_en" +) +def transformer_pointer_generator_iwslt_de_en(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 6) + transformer_pointer_generator(args) + + +@register_model_architecture( + "transformer_pointer_generator", "transformer_pointer_generator_wmt_en_de" +) +def transformer_pointer_generator_wmt_en_de(args): + transformer_pointer_generator(args) + + +# Transformer pointer-generator with the base Transformer parameters as used in +# the "Attention Is All You Need" paper (Vaswani et al., 2017) +@register_model_architecture( + "transformer_pointer_generator", + "transformer_pointer_generator_vaswani_wmt_en_de_big", +) +def transformer_pointer_generator_vaswani_wmt_en_de_big(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.3) + transformer_pointer_generator(args) + + +@register_model_architecture( + "transformer_pointer_generator", + "transformer_pointer_generator_vaswani_wmt_en_fr_big", +) +def transformer_pointer_generator_vaswani_wmt_en_fr_big(args): + args.dropout = getattr(args, "dropout", 0.1) + transformer_pointer_generator_vaswani_wmt_en_de_big(args) + + +@register_model_architecture( + "transformer_pointer_generator", "transformer_pointer_generator_wmt_en_de_big" +) +def transformer_pointer_generator_wmt_en_de_big(args): + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + transformer_pointer_generator_vaswani_wmt_en_de_big(args) + + +# default parameters used in tensor2tensor implementation +@register_model_architecture( + "transformer_pointer_generator", "transformer_pointer_generator_wmt_en_de_big_t2t" +) +def transformer_pointer_generator_wmt_en_de_big_t2t(args): + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.activation_dropout = getattr(args, "activation_dropout", 0.1) + transformer_pointer_generator_vaswani_wmt_en_de_big(args) diff --git a/fairseq/examples/pointer_generator/postprocess.py b/fairseq/examples/pointer_generator/postprocess.py new file mode 100755 index 0000000000000000000000000000000000000000..b213aed80fd1e3d86f975256fcb7d9d4c16ca857 --- /dev/null +++ b/fairseq/examples/pointer_generator/postprocess.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import re +import sys + + +class OOVIndexError(IndexError): + def __init__(self, pos, source_seq, target_seq): + super(OOVIndexError, self).__init__( + "A <unk-N> tag in the target sequence refers to a position that is " + "outside the source sequence. Most likely there was a mismatch in " + "provided source and target sequences. Otherwise this would mean that " + "the pointing mechanism somehow attended to a position that is past " + "the actual sequence end." + ) + self.source_pos = pos + self.source_seq = source_seq + self.target_seq = target_seq + + +def replace_oovs(source_in, target_in, target_out): + """Replaces <unk-N> tokens in the target text with the corresponding word in + the source text. + """ + + oov_re = re.compile("^<unk-([0-9]+)>$") + + for source_seq, target_seq in zip(source_in, target_in): + target_seq_out = [] + + pos_to_word = source_seq.strip().split() + for token in target_seq.strip().split(): + m = oov_re.match(token) + if m: + pos = int(m.group(1)) + if pos >= len(pos_to_word): + raise OOVIndexError(pos, source_seq, target_seq) + token_out = pos_to_word[pos] + else: + token_out = token + target_seq_out.append(token_out) + target_out.write(" ".join(target_seq_out) + "\n") + + +def main(): + parser = argparse.ArgumentParser( + description="Replaces <unk-N> tokens in target sequences with words from " + "the corresponding position in the source sequence." + ) + parser.add_argument( + "--source", type=str, help="text file with source sequences", required=True + ) + parser.add_argument( + "--target", type=str, help="text file with target sequences", required=True + ) + parser.add_argument( + "--target-out", + type=str, + help="where to write target sequences without <unk-N> " "entries", + required=True, + ) + args = parser.parse_args() + + target_in = ( + open(args.target, "r", encoding="utf-8") if args.target is not None else None + ) + target_out = ( + open(args.target_out, "w", encoding="utf-8") + if args.target_out is not None + else None + ) + with open(args.source, "r", encoding="utf-8") as source_in, open( + args.target, "r", encoding="utf-8" + ) as target_in, open(args.target_out, "w", encoding="utf-8") as target_out: + replace_oovs(source_in, target_in, target_out) + + +if __name__ == "__main__": + try: + main() + except OOVIndexError as e: + print(e, file=sys.stderr) + print("Source sequence:", e.source_seq.strip(), file=sys.stderr) + print("Target sequence:", e.target_seq.strip(), file=sys.stderr) + print( + "Source sequence length:", + len(e.source_seq.strip().split()), + file=sys.stderr, + ) + print("The offending tag points to:", e.source_pos) + sys.exit(2) diff --git a/fairseq/examples/pointer_generator/preprocess.py b/fairseq/examples/pointer_generator/preprocess.py new file mode 100755 index 0000000000000000000000000000000000000000..f72ca7d3d97e12ab7b405dcff314bdb6c0a78755 --- /dev/null +++ b/fairseq/examples/pointer_generator/preprocess.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +from itertools import zip_longest + + +def replace_oovs(source_in, target_in, vocabulary, source_out, target_out): + """Replaces out-of-vocabulary words in source and target text with <unk-N>, + where N in is the position of the word in the source sequence. + """ + + def format_unk(pos): + return "<unk-{}>".format(pos) + + if target_in is None: + target_in = [] + + for seq_num, (source_seq, target_seq) in enumerate( + zip_longest(source_in, target_in) + ): + source_seq_out = [] + target_seq_out = [] + + word_to_pos = dict() + for position, token in enumerate(source_seq.strip().split()): + if token in vocabulary: + token_out = token + else: + if token in word_to_pos: + oov_pos = word_to_pos[token] + else: + word_to_pos[token] = position + oov_pos = position + token_out = format_unk(oov_pos) + source_seq_out.append(token_out) + source_out.write(" ".join(source_seq_out) + "\n") + + if target_seq is not None: + for token in target_seq.strip().split(): + if token in word_to_pos: + token_out = format_unk(word_to_pos[token]) + else: + token_out = token + target_seq_out.append(token_out) + if target_out is not None: + target_out.write(" ".join(target_seq_out) + "\n") + + +def main(): + parser = argparse.ArgumentParser( + description="Replaces out-of-vocabulary words in both source and target " + "sequences with tokens that indicate the position of the word " + "in the source sequence." + ) + parser.add_argument( + "--source", type=str, help="text file with source sequences", required=True + ) + parser.add_argument( + "--target", type=str, help="text file with target sequences", default=None + ) + parser.add_argument("--vocab", type=str, help="vocabulary file", required=True) + parser.add_argument( + "--source-out", + type=str, + help="where to write source sequences with <unk-N> entries", + required=True, + ) + parser.add_argument( + "--target-out", + type=str, + help="where to write target sequences with <unk-N> entries", + default=None, + ) + args = parser.parse_args() + + with open(args.vocab, encoding="utf-8") as vocab: + vocabulary = vocab.read().splitlines() + + target_in = ( + open(args.target, "r", encoding="utf-8") if args.target is not None else None + ) + target_out = ( + open(args.target_out, "w", encoding="utf-8") + if args.target_out is not None + else None + ) + with open(args.source, "r", encoding="utf-8") as source_in, open( + args.source_out, "w", encoding="utf-8" + ) as source_out: + replace_oovs(source_in, target_in, vocabulary, source_out, target_out) + if target_in is not None: + target_in.close() + if target_out is not None: + target_out.close() + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/quant_noise/README.md b/fairseq/examples/quant_noise/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a04d7e4e8a077f11c9f63cfa3d1f20e2b899be8c --- /dev/null +++ b/fairseq/examples/quant_noise/README.md @@ -0,0 +1,298 @@ +# Training with Quantization Noise for Extreme Model Compression ({Fan\*, Stock\*} *et al.*, 2020) +This page contains information for how to train and quantize models with Quantization Noise, for both scalar quantization like `int8` and Iterative Product Quantization. +Check out our paper [here](https://arxiv.org/abs/2004.07320). + +Looking for pretrained models? They will be added shortly. +Looking for code to train vision models? We are working on open sourcing our code as part of ClassyVision. Please check back, but note that both the Scalar and Iterative Product Quantization counterparts of the `nn.Conv2d` module are already included in this release. + +**Contents**: +- [Walk through of code](#walk-through-the-code) +- [Reproduce NLP Results](#looking-to-reproduce-the-nlp-results-in-the-paper) +- [Reproduce Vision Results](#looking-to-reproduce-the-vision-results-in-the-paper) + + +## Citation +```bibtex +@article{fan2020training, + title={Training with Quantization Noise for Extreme Model Compression}, + author={Angela Fan* and Pierre Stock* and and Benjamin Graham and Edouard Grave and Remi Gribonval and Herve Jegou and Armand Joulin}, + year={2020}, + eprint={2004.07320}, + archivePrefix={arXiv}, + primaryClass={cs.ML} +} +``` + +## Walk through the code + +Training a model with Quant-Noise improves the performance in subsequent inference-time quantization by training models to be robust to quantization. This technique is useful for both scalar and product quantization methods, as well as multiple domains. We detail below our approach to train, quantize models and integrate our code to quantize your favorite models. + +### Scalar Quantization + +Unlike the section [Iterative Product Quantization](#iterative-product-quantization) which gives state-of-the-art compression, this section showcases the usefulness of our approach for simple scalar quantization baselines such as int8 using on-GPU Fake Quantization. + +#### Training + +Scalar quantization with Quant-Noise consists in randomly quantizing a proportion `p` of the weights during training. Scalar quantization is implemented [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quantization/scalar) under the form of Fake Quantization, meaning that we emulate int8 on GPU by quantizing and de-quantizing both the weights and the activations. We rely on PyTorch's [quantization primitives](https://github.com/pytorch/pytorch/tree/master/torch/quantization). + +To train a model with Quant-Noise, add the following flag: +``` +--quant-noise-scalar 0.5 +``` +Large values of noise make the network easier to quantize but may result in higher non-quantized test and validation perplexities. + +#### Quantization + +When evaluating a network, all quantized modules and activation hooks automatically switch to `p=1` so the validation accuracy reported by Fairseq is actually the quantized one, nothing more to do. + + +#### Integration with your own code + +Looking to quantize your own models with Quant-Noise + Scalar Quantization? +- Use the function `quantize_model_` implemented [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quantization/scalar/utils.py) to (1) replace all your modules by their quantized counterparts and (2) add hooks to those modules to quantize the activations. +- Then, perform your training as usual. Note that in `eval()` mode, the network is always fully quantized (weights and activations) by default (`p=1`). + + + +### Iterative Product Quantization + + +Iterative Product Quantization with Quant-Noise proceeds in two steps. First, a model must be trained uncompressed with Quant-Noise. Second, the model must be quantized with iPQ. Note that we implement here the simplest form of noise, which consists in randomly dropping a proportion `p` of blocks, and that worked as well as assigning those blocks to their current centroid. + +#### Training + +To train a model with Quant-Noise, add the following flags: +``` +--quant-noise-pq 0.1 --quant-noise-pq-block-size 8 +``` +`quant-noise-pq` controls how much dropout is applied to the blocks of the weight matrix. `quant-noise-pq-block-size` controls the size of the weight matrix blocks. +We recommend training with 0.05 to 0.2 Quant-Noise, a value that worked well in our experiments. For the block-size, we recommend training with block-size of 8. Note that the block size must be a multiple of `input_features`, see the size checks [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quant_noise.py). Large block sizes result in higher compression ratio but may induce a loss in accuracy. + +We currently support training Transformer based models, such as sequence-to-sequence, language models, and BERT architectures. The `quant_noise` function [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quant_noise.py) wraps a module. It splits a weight matrix into blocks and applies random dropout to these blocks. +In the Transformer architectures, quant-noise is applied to the input and output embeddings, the attention, and the FFN. + +Quant-Noise can also be combined with **LayerDrop** (see [here](https://github.com/pytorch/fairseq/tree/main/examples/layerdrop)) to add its pruning effect to the quantized model and make the model even smaller. We recommend training with LayerDrop 0.1 or 0.2. + +#### Quantization + +We implement an improved version of product quantization from Stock et al, **iPQ**, described [here](https://arxiv.org/abs/1907.05686), see code with old API [here](https://github.com/facebookresearch/kill-the-bits). Note that we improved the iPQ API in terms of both compute speed and usability as described below. + +For the particular case of PQ, quantization is made sequentially. We recommend first quantizing the FFNs, then the EMBs, and finally the ATTNs. Quantization is done in two sub-steps: +- First, perform `n` steps of Product Quantization (generally `n=20` is enough). +- Then, finetune the obtained centroids. + +#### Integration with your own code + +Looking to quantize your own models with Quant-Noise + iPQ? +- First wrap your modules with the `quant_noise` function [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quant_noise.py), which is module-agnostic and train your favorite model. +- Then, quantize your trained model using the code [here](https://github.com/pytorch/fairseq/tree/main/fairseq/modules/quantization/pq). This can be done *without any changes to your training loop*. Below is an example code for integration. +Note that we tried our approach only on Transformers and various Convolutional Models such as EfficientNets. + +```python +from fairseq.modules.quantization.pq import quantize_model_, SizeTracker + +# get configuration parameters +n_centroids_config = config["n_centroids"] +block_sizes_config = config["block_sizes"] +layers_to_quantize = config["layers_to_quantize"] + +# size tracker for keeping track of assignments, centroids and non-compressed sizes +size_tracker = SizeTracker(model) + +# Quantize model by stages +for step in range(len(layers_to_quantize)): + + # quantize model in-place + quantized_layers = quantize_model_( + model, + size_tracker, + layers_to_quantize, + block_sizes_config, + n_centroids_config, + step=step, + ) + logger.info(f"Finetuning stage {step}, quantized layers: {quantized_layers}") + logger.info(f"{size_tracker}") + + # Don't forget to re-create/update trainer/optimizer since model parameters have changed + optimizer = ... + + # Finetune the centroids with your usual training loop for a few epochs + trainer.train_epoch() +``` + + +## Looking to reproduce the NLP results in the paper? + +We detail below how to reproduce the state-of-the-art results in reported in the paper for Quant-Noise + Iterative Product Quantization. + +### Training with Quant-Noise + +To **train** RoBERTa + QuantNoise, we followed this setting [here](https://github.com/pytorch/fairseq/tree/main/examples/roberta). +The following command can be used to train a RoBERTa Base + QuantNoise model: + +```bash +TOTAL_UPDATES=125000 +WARMUP_UPDATES=10000 +PEAK_LR=0.0005 +TOKENS_PER_SAMPLE=512 +MAX_POSITIONS=512 +MAX_SENTENCES=16 +UPDATE_FREQ=2 +DATA_DIR=/path/to/data/here + +fairseq-train $DATA_DIR \ + --task masked_lm --criterion masked_lm --arch roberta_base \ + --sample-break-mode complete \ + --tokens-per-sample $TOKENS_PER_SAMPLE --max-positions $MAX_POSITIONS \ + --optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-6 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $PEAK_LR \ + --warmup-updates $WARMUP_UPDATES --total-num-update $TOTAL_UPDATES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.01 \ + --batch-size $MAX_SENTENCES \ + --update-freq $UPDATE_FREQ --max-update $TOTAL_UPDATES \ + --save-dir checkpoint/roberta \ + --ddp-backend legacy_ddp --encoder-layerdrop 0.2 \ + --quant-noise-pq 0.2 --quant-noise-pq-block-size 8 --untie-weights-roberta +``` + +To **finetune** RoBERTa + QuantNoise, we followed this setting [here](https://github.com/pytorch/fairseq/blob/main/examples/roberta/README.glue.md). +The following command can be used to finetune a RoBERTa Base + QuantNoise model on the RTE dataset: + +```bash +TOTAL_NUM_UPDATES=2036 +WARMUP_UPDATES=122 +LR=2e-05 +NUM_CLASSES=2 +MAX_SENTENCES=16 +ROBERTA_PATH=/path/to/roberta_quantnoise/model.pt + +fairseq-train /path/to/rte/data/ \ + --restore-file $ROBERTA_PATH \ + --max-positions 512 \ + --batch-size $MAX_SENTENCES \ + --max-tokens 4400 \ + --task sentence_prediction \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --init-token 0 --separator-token 2 \ + --arch roberta_large \ + --criterion sentence_prediction \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.1 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-06 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --max-epoch 10 \ + --find-unused-parameters \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --ddp-backend legacy_ddp \ + --quant-noise-pq 0.2 --quant-noise-pq-block-size 8 +``` + +To **train** Language Models on Wikitext-103, we followed this setting [here](https://github.com/pytorch/fairseq/tree/main/examples/language_model). +The following command can be used to train a Transformer + QuantNoise model on Wikitext-103: + +```bash +fairseq-train --task language_modeling /path/to/wikitext-103/data \ + --save-dir checkpoints/transformer_wikitext-103 \ + --adaptive-input --adaptive-input-cutoff 20000,60000 --adaptive-input-factor 4 \ + --adaptive-softmax-cutoff 20000,60000 --adaptive-softmax-dropout 0.2 --adaptive-softmax-factor 4.0 \ + --tie-adaptive-proj --tie-adaptive-weights \ + --arch transformer_lm_gbw \ + --attention-dropout 0.1 --dropout 0.2 --relu-dropout 0.1 \ + --clip-norm 0.1 --criterion adaptive_loss \ + --ddp-backend legacy_ddp \ + --decoder-attention-heads 8 --decoder-embed-dim 1024 --decoder-ffn-embed-dim 4096 --decoder-input-dim 1024 \ + --decoder-layers 16 --decoder-normalize-before --decoder-output-dim 1024 \ + --min-lr 0.0001 --lr-period-updates 270000 --lr-scheduler cosine --lr-shrink 0.75 --lr 1.0 --t-mult 2.0 \ + --max-tokens 3072 --tokens-per-sample 3072 --momentum 0.99 --optimizer nag \ + --sample-break-mode none --update-freq 3 \ + --warmup-init-lr 1e-07 --warmup-updates 16000 \ + --weight-decay 0 --seed 1 --stop-min-lr 1e-09 \ + --quant-noise-pq 0.05 --quant-noise-pq-block-size 8 +``` + +To **evaluate** this model, note you need to use the `eval.py` script. The following command can be used to evaluate: + +```bash +fairseq-eval-lm /path/to/wikitext-103/data --path /path/to/model/checkpoint \ + --sample-break-mode complete \ + --max-tokens 3072 \ + --context-window 2560 \ + --softmax-batch 1024 \ + --gen-subset valid +``` +and change the `--gen-subset` to `test` if you would like to evaluate on the test set instead. + + +### Iterative Product Quantization + +To quantize the finetuned RoBERTa model, we use this command on 1 GPU. This should run in a day. +```bash +TOTAL_NUM_UPDATES=6108 # 2036 updates for each iteration +WARMUP_UPDATES=122 +LR=2e-05 +NUM_CLASSES=2 +MAX_SENTENCES=16 +fairseq-train --task sentence_prediction /path/to/data/ \ + --restore-file $ROBERTA_PATH \ + --save-dir checkpoints/roberta_finetuned \ + --max-positions 512 \ + --batch-size $MAX_SENTENCES \ + --max-tokens 4400 \ + --init-token 0 --separator-token 2 \ + --arch roberta_large \ + --criterion sentence_prediction \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.1 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-06 \ + --clip-norm 0.0 --lr-scheduler polynomial_decay \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --no-progress-bar --skip-invalid-size-inputs-valid-test --ddp-backend legacy_ddp \ + --quantization-config-path /path/to/config/yaml +``` + +To quantize the trained Language Model, we use this command on 8 V100 23GB GPUs. This should run in a couple of hours. +```bash +fairseq-train --task language_modeling /path/to/wikitext-103/data \ + --save-dir checkpoints/transformer_wikitext-103 \ + --adaptive-input --adaptive-input-cutoff 20000,60000 --adaptive-input-factor 4 \ + --adaptive-softmax-cutoff 20000,60000 --adaptive-softmax-dropout 0.2 --adaptive-softmax-factor 4.0 \ + --arch transformer_lm_gbw \ + --attention-dropout 0.1 --dropout 0.2 --relu-dropout 0.1 \ + --bucket-cap-mb 25 --char-embedder-highway-layers 2 --character-embedding-dim 4 \ + --clip-norm 0.1 --criterion adaptive_loss \ + --ddp-backend legacy_ddp \ + --decoder-attention-heads 8 --decoder-embed-dim 1024 --decoder-ffn-embed-dim 4096 --decoder-input-dim 1024 --decoder-layers 16 --decoder-normalize-before --decoder-output-dim 1024 \ + --fp16 --keep-last-epochs -1 \ + --min-lr 0.0001 --lr-period-updates 270000 --lr-scheduler cosine --lr-shrink 0.75 --lr 0.05 --stop-min-lr 1e-09 \ + --max-tokens 2944 --tokens-per-sample 2944\ + --momentum 0.99 --no-epoch-checkpoints --no-progress-bar --optimizer nag --required-batch-size-multiple 8 \ + --sample-break-mode none --t-mult 2.0 --skip-invalid-size-inputs-valid-test \ + --tie-adaptive-proj --tie-adaptive-weights --update-freq 3 --weight-decay 0 --seed 1 \ + --log-interval 100 --no-progress-bar --skip-invalid-size-inputs-valid-test \ + --restore-file path/to/trained/lm/with/quant/noise \ + --max-update 13500 --quantization-config-path /path/to/config/yaml +``` +If you have less capacity or if your distributed training freezes, try reducing `--max-tokens` and `--tokens-per-sample` (this may reduce the quantized accuracy a bit). + +### Remarks + +We try to keep the open-sourced code as readable and as easy-to-plug as possible. Therefore, we did not test it for the following cases: +- Scalar quantization with RoBERTa. +- Quantization with iPQ and `int8` combined. + +If you have trouble adapting it, we will be more than happy to help! + +## Looking to reproduce the Vision results in the paper? + +We are working on open sourcing our code as part of ClassyVision. Please check back. + + +## Having an issue or have a question? + +Please open an issue in this repository with the details of your question. Thanks! diff --git a/fairseq/examples/quant_noise/transformer_quantization_config.yaml b/fairseq/examples/quant_noise/transformer_quantization_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d4be14a93a3593f8e6dc66c3b05061bfdde3e0e0 --- /dev/null +++ b/fairseq/examples/quant_noise/transformer_quantization_config.yaml @@ -0,0 +1,33 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# This file defines example configuration arguments for quantizing +# a transformer model with product quantization + +# Number of Centroids for Product Quantization, by default 256 (byte-aligned) +n_centroids: + Linear: + key: in_features + value: {"*": 256} + Embedding: + key: embedding_dim + value: {"*": 256} + +# Block Sizes for Product Quantization +# We suggest: 8 for FFN, 4 for ATTN, 4 for embedding projections, 8 for embeddings +block_sizes: + Linear: + key: fuzzy_name + value: {fc: 8, attn: 4, emb: 4} + Embedding: + key: fuzzy_name + value: {emb: 8} + +# Layers to Quantize Sequentially +# We suggest: first FFN, then EMB, then ATTN +layers_to_quantize: + - decoder\\.layers\\.\d+\\.fc[12] + - decoder\\.embed_tokens\\.embeddings\\.[012]\\.[01] + - decoder\\.layers\\.\d+\\.self_attn\\.(k_proj|v_proj|q_proj|out_proj) diff --git a/fairseq/examples/roberta/README.custom_classification.md b/fairseq/examples/roberta/README.custom_classification.md new file mode 100644 index 0000000000000000000000000000000000000000..7254bb7d178760ef5b847901bbcac3711af33ca2 --- /dev/null +++ b/fairseq/examples/roberta/README.custom_classification.md @@ -0,0 +1,168 @@ +# Finetuning RoBERTa on a custom classification task + +This example shows how to finetune RoBERTa on the IMDB dataset, but should illustrate the process for most classification tasks. + +### 1) Get the data + +```bash +wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz +tar zxvf aclImdb_v1.tar.gz +``` + + +### 2) Format data + +`IMDB` data has one data-sample in each file, below python code-snippet converts it one file for train and valid each for ease of processing. +```python +import argparse +import os +import random +from glob import glob + +random.seed(0) + +def main(args): + for split in ['train', 'test']: + samples = [] + for class_label in ['pos', 'neg']: + fnames = glob(os.path.join(args.datadir, split, class_label) + '/*.txt') + for fname in fnames: + with open(fname) as fin: + line = fin.readline() + samples.append((line, 1 if class_label == 'pos' else 0)) + random.shuffle(samples) + out_fname = 'train' if split == 'train' else 'dev' + f1 = open(os.path.join(args.datadir, out_fname + '.input0'), 'w') + f2 = open(os.path.join(args.datadir, out_fname + '.label'), 'w') + for sample in samples: + f1.write(sample[0] + '\n') + f2.write(str(sample[1]) + '\n') + f1.close() + f2.close() + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--datadir', default='aclImdb') + args = parser.parse_args() + main(args) +``` + + +### 3) BPE encode + +Run `multiprocessing_bpe_encoder`, you can also do this in previous step for each sample but that might be slower. +```bash +# Download encoder.json and vocab.bpe +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe' + +for SPLIT in train dev; do + python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json encoder.json \ + --vocab-bpe vocab.bpe \ + --inputs "aclImdb/$SPLIT.input0" \ + --outputs "aclImdb/$SPLIT.input0.bpe" \ + --workers 60 \ + --keep-empty +done +``` + + +### 4) Preprocess data + +```bash +# Download fairseq dictionary. +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt' + +fairseq-preprocess \ + --only-source \ + --trainpref "aclImdb/train.input0.bpe" \ + --validpref "aclImdb/dev.input0.bpe" \ + --destdir "IMDB-bin/input0" \ + --workers 60 \ + --srcdict dict.txt + +fairseq-preprocess \ + --only-source \ + --trainpref "aclImdb/train.label" \ + --validpref "aclImdb/dev.label" \ + --destdir "IMDB-bin/label" \ + --workers 60 + +``` + + +### 5) Run training + +```bash +TOTAL_NUM_UPDATES=7812 # 10 epochs through IMDB for bsz 32 +WARMUP_UPDATES=469 # 6 percent of the number of updates +LR=1e-05 # Peak LR for polynomial LR scheduler. +HEAD_NAME=imdb_head # Custom name for the classification head. +NUM_CLASSES=2 # Number of classes for the classification task. +MAX_SENTENCES=8 # Batch size. +ROBERTA_PATH=/path/to/roberta.large/model.pt + +CUDA_VISIBLE_DEVICES=0 fairseq-train IMDB-bin/ \ + --restore-file $ROBERTA_PATH \ + --max-positions 512 \ + --batch-size $MAX_SENTENCES \ + --max-tokens 4400 \ + --task sentence_prediction \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --init-token 0 --separator-token 2 \ + --arch roberta_large \ + --criterion sentence_prediction \ + --classification-head-name $HEAD_NAME \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.1 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-06 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --max-epoch 10 \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --shorten-method "truncate" \ + --find-unused-parameters \ + --update-freq 4 +``` + +The above command will finetune RoBERTa-large with an effective batch-size of 32 +sentences (`--batch-size=8 --update-freq=4`). The expected +`best-validation-accuracy` after 10 epochs is ~96.5%. + +If you run out of GPU memory, try decreasing `--batch-size` and increase +`--update-freq` to compensate. + + +### 6) Load model using hub interface + +Now we can load the trained model checkpoint using the RoBERTa hub interface. + +Assuming your checkpoints are stored in `checkpoints/`: +```python +from fairseq.models.roberta import RobertaModel +roberta = RobertaModel.from_pretrained( + 'checkpoints', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='IMDB-bin' +) +roberta.eval() # disable dropout +``` + +Finally you can make predictions using the `imdb_head` (or whatever you set +`--classification-head-name` to during training): +```python +label_fn = lambda label: roberta.task.label_dictionary.string( + [label + roberta.task.label_dictionary.nspecial] +) + +tokens = roberta.encode('Best movie this year') +pred = label_fn(roberta.predict('imdb_head', tokens).argmax().item()) +assert pred == '1' # positive + +tokens = roberta.encode('Worst movie ever') +pred = label_fn(roberta.predict('imdb_head', tokens).argmax().item()) +assert pred == '0' # negative +``` diff --git a/fairseq/examples/roberta/README.glue.md b/fairseq/examples/roberta/README.glue.md new file mode 100644 index 0000000000000000000000000000000000000000..4f596d55af99fba3cdf58b1d5ff3d8f8dbf4383d --- /dev/null +++ b/fairseq/examples/roberta/README.glue.md @@ -0,0 +1,64 @@ +# Finetuning RoBERTa on GLUE tasks + +### 1) Download the data from GLUE website (https://gluebenchmark.com/tasks) using following commands: +```bash +wget https://gist.githubusercontent.com/W4ngatang/60c2bdb54d156a41194446737ce03e2e/raw/17b8dd0d724281ed7c3b2aeeda662b92809aadd5/download_glue_data.py +python download_glue_data.py --data_dir glue_data --tasks all +``` + +### 2) Preprocess GLUE task data: +```bash +./examples/roberta/preprocess_GLUE_tasks.sh glue_data <glue_task_name> +``` +`glue_task_name` is one of the following: +`{ALL, QQP, MNLI, QNLI, MRPC, RTE, STS-B, SST-2, CoLA}` +Use `ALL` for preprocessing all the glue tasks. + +### 3) Fine-tuning on GLUE task: +Example fine-tuning cmd for `RTE` task +```bash +ROBERTA_PATH=/path/to/roberta/model.pt + +CUDA_VISIBLE_DEVICES=0 fairseq-hydra-train -config-dir examples/roberta/config/finetuning --config-name rte \ +task.data=RTE-bin checkpoint.restore_file=$ROBERTA_PATH +``` + +There are additional config files for each of the GLUE tasks in the examples/roberta/config/finetuning directory. + +**Note:** + +a) Above cmd-args and hyperparams are tested on one Nvidia `V100` GPU with `32gb` of memory for each task. Depending on the GPU memory resources available to you, you can use increase `--update-freq` and reduce `--batch-size`. + +b) All the settings in above table are suggested settings based on our hyperparam search within a fixed search space (for careful comparison across models). You might be able to find better metrics with wider hyperparam search. + +### Inference on GLUE task +After training the model as mentioned in previous step, you can perform inference with checkpoints in `checkpoints/` directory using following python code snippet: + +```python +from fairseq.models.roberta import RobertaModel + +roberta = RobertaModel.from_pretrained( + 'checkpoints/', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='RTE-bin' +) + +label_fn = lambda label: roberta.task.label_dictionary.string( + [label + roberta.task.label_dictionary.nspecial] +) +ncorrect, nsamples = 0, 0 +roberta.cuda() +roberta.eval() +with open('glue_data/RTE/dev.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[1], tokens[2], tokens[3] + tokens = roberta.encode(sent1, sent2) + prediction = roberta.predict('sentence_classification_head', tokens).argmax().item() + prediction_label = label_fn(prediction) + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) + +``` diff --git a/fairseq/examples/roberta/README.md b/fairseq/examples/roberta/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ed4d5df52ccea01216276054a1f253d0d16c0409 --- /dev/null +++ b/fairseq/examples/roberta/README.md @@ -0,0 +1,296 @@ +# RoBERTa: A Robustly Optimized BERT Pretraining Approach + +https://arxiv.org/abs/1907.11692 + +## Introduction + +RoBERTa iterates on BERT's pretraining procedure, including training the model longer, with bigger batches over more data; removing the next sentence prediction objective; training on longer sequences; and dynamically changing the masking pattern applied to the training data. See the associated paper for more details. + +### What's New: + +- December 2020: German model (GottBERT) is available: [GottBERT](https://github.com/pytorch/fairseq/tree/main/examples/gottbert). +- January 2020: Italian model (UmBERTo) is available from Musixmatch Research: [UmBERTo](https://github.com/musixmatchresearch/umberto). +- November 2019: French model (CamemBERT) is available: [CamemBERT](https://github.com/pytorch/fairseq/tree/main/examples/camembert). +- November 2019: Multilingual encoder (XLM-RoBERTa) is available: [XLM-R](https://github.com/pytorch/fairseq/tree/main/examples/xlmr). +- September 2019: TensorFlow and TPU support via the [transformers library](https://github.com/huggingface/transformers). +- August 2019: RoBERTa is now supported in the [pytorch-transformers library](https://github.com/huggingface/pytorch-transformers). +- August 2019: Added [tutorial for finetuning on WinoGrande](https://github.com/pytorch/fairseq/tree/main/examples/roberta/wsc#roberta-training-on-winogrande-dataset). +- August 2019: Added [tutorial for pretraining RoBERTa using your own data](README.pretraining.md). + +## Pre-trained models + +Model | Description | # params | Download +---|---|---|--- +`roberta.base` | RoBERTa using the BERT-base architecture | 125M | [roberta.base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta.base.tar.gz) +`roberta.large` | RoBERTa using the BERT-large architecture | 355M | [roberta.large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz) +`roberta.large.mnli` | `roberta.large` finetuned on [MNLI](http://www.nyu.edu/projects/bowman/multinli) | 355M | [roberta.large.mnli.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.mnli.tar.gz) +`roberta.large.wsc` | `roberta.large` finetuned on [WSC](wsc/README.md) | 355M | [roberta.large.wsc.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.wsc.tar.gz) + +## Results + +**[GLUE (Wang et al., 2019)](https://gluebenchmark.com/)** +_(dev set, single model, single-task finetuning)_ + +Model | MNLI | QNLI | QQP | RTE | SST-2 | MRPC | CoLA | STS-B +---|---|---|---|---|---|---|---|--- +`roberta.base` | 87.6 | 92.8 | 91.9 | 78.7 | 94.8 | 90.2 | 63.6 | 91.2 +`roberta.large` | 90.2 | 94.7 | 92.2 | 86.6 | 96.4 | 90.9 | 68.0 | 92.4 +`roberta.large.mnli` | 90.2 | - | - | - | - | - | - | - + +**[SuperGLUE (Wang et al., 2019)](https://super.gluebenchmark.com/)** +_(dev set, single model, single-task finetuning)_ + +Model | BoolQ | CB | COPA | MultiRC | RTE | WiC | WSC +---|---|---|---|---|---|---|--- +`roberta.large` | 86.9 | 98.2 | 94.0 | 85.7 | 89.5 | 75.6 | - +`roberta.large.wsc` | - | - | - | - | - | - | 91.3 + +**[SQuAD (Rajpurkar et al., 2018)](https://rajpurkar.github.io/SQuAD-explorer/)** +_(dev set, no additional data used)_ + +Model | SQuAD 1.1 EM/F1 | SQuAD 2.0 EM/F1 +---|---|--- +`roberta.large` | 88.9/94.6 | 86.5/89.4 + +**[RACE (Lai et al., 2017)](http://www.qizhexie.com/data/RACE_leaderboard.html)** +_(test set)_ + +Model | Accuracy | Middle | High +---|---|---|--- +`roberta.large` | 83.2 | 86.5 | 81.3 + +**[HellaSwag (Zellers et al., 2019)](https://rowanzellers.com/hellaswag/)** +_(test set)_ + +Model | Overall | In-domain | Zero-shot | ActivityNet | WikiHow +---|---|---|---|---|--- +`roberta.large` | 85.2 | 87.3 | 83.1 | 74.6 | 90.9 + +**[Commonsense QA (Talmor et al., 2019)](https://www.tau-nlp.org/commonsenseqa)** +_(test set)_ + +Model | Accuracy +---|--- +`roberta.large` (single model) | 72.1 +`roberta.large` (ensemble) | 72.5 + +**[Winogrande (Sakaguchi et al., 2019)](https://arxiv.org/abs/1907.10641)** +_(test set)_ + +Model | Accuracy +---|--- +`roberta.large` | 78.1 + +**[XNLI (Conneau et al., 2018)](https://arxiv.org/abs/1809.05053)** +_(TRANSLATE-TEST)_ + +Model | en | fr | es | de | el | bg | ru | tr | ar | vi | th | zh | hi | sw | ur +---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--- +`roberta.large.mnli` | 91.3 | 82.91 | 84.27 | 81.24 | 81.74 | 83.13 | 78.28 | 76.79 | 76.64 | 74.17 | 74.05 | 77.5 | 70.9 | 66.65 | 66.81 + +## Example usage + +##### Load RoBERTa from torch.hub (PyTorch >= 1.1): +```python +import torch +roberta = torch.hub.load('pytorch/fairseq', 'roberta.large') +roberta.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Load RoBERTa (for PyTorch 1.0 or custom models): +```python +# Download roberta.large model +wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz +tar -xzvf roberta.large.tar.gz + +# Load the model in fairseq +from fairseq.models.roberta import RobertaModel +roberta = RobertaModel.from_pretrained('/path/to/roberta.large', checkpoint_file='model.pt') +roberta.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Apply Byte-Pair Encoding (BPE) to input text: +```python +tokens = roberta.encode('Hello world!') +assert tokens.tolist() == [0, 31414, 232, 328, 2] +roberta.decode(tokens) # 'Hello world!' +``` + +##### Extract features from RoBERTa: +```python +# Extract the last layer's features +last_layer_features = roberta.extract_features(tokens) +assert last_layer_features.size() == torch.Size([1, 5, 1024]) + +# Extract all layer's features (layer 0 is the embedding layer) +all_layers = roberta.extract_features(tokens, return_all_hiddens=True) +assert len(all_layers) == 25 +assert torch.all(all_layers[-1] == last_layer_features) +``` + +##### Use RoBERTa for sentence-pair classification tasks: +```python +# Download RoBERTa already finetuned for MNLI +roberta = torch.hub.load('pytorch/fairseq', 'roberta.large.mnli') +roberta.eval() # disable dropout for evaluation + +# Encode a pair of sentences and make a prediction +tokens = roberta.encode('Roberta is a heavily optimized version of BERT.', 'Roberta is not very optimized.') +roberta.predict('mnli', tokens).argmax() # 0: contradiction + +# Encode another pair of sentences +tokens = roberta.encode('Roberta is a heavily optimized version of BERT.', 'Roberta is based on BERT.') +roberta.predict('mnli', tokens).argmax() # 2: entailment +``` + +##### Register a new (randomly initialized) classification head: +```python +roberta.register_classification_head('new_task', num_classes=3) +logprobs = roberta.predict('new_task', tokens) # tensor([[-1.1050, -1.0672, -1.1245]], grad_fn=<LogSoftmaxBackward>) +``` + +##### Batched prediction: +```python +import torch +from fairseq.data.data_utils import collate_tokens + +roberta = torch.hub.load('pytorch/fairseq', 'roberta.large.mnli') +roberta.eval() + +batch_of_pairs = [ + ['Roberta is a heavily optimized version of BERT.', 'Roberta is not very optimized.'], + ['Roberta is a heavily optimized version of BERT.', 'Roberta is based on BERT.'], + ['potatoes are awesome.', 'I like to run.'], + ['Mars is very far from earth.', 'Mars is very close.'], +] + +batch = collate_tokens( + [roberta.encode(pair[0], pair[1]) for pair in batch_of_pairs], pad_idx=1 +) + +logprobs = roberta.predict('mnli', batch) +print(logprobs.argmax(dim=1)) +# tensor([0, 2, 1, 0]) +``` + +##### Using the GPU: +```python +roberta.cuda() +roberta.predict('new_task', tokens) # tensor([[-1.1050, -1.0672, -1.1245]], device='cuda:0', grad_fn=<LogSoftmaxBackward>) +``` + +## Advanced usage + +#### Filling masks: + +RoBERTa can be used to fill `<mask>` tokens in the input. Some examples from the +[Natural Questions dataset](https://ai.google.com/research/NaturalQuestions/): +```python +roberta.fill_mask('The first Star wars movie came out in <mask>', topk=3) +# [('The first Star wars movie came out in 1977', 0.9504708051681519, ' 1977'), ('The first Star wars movie came out in 1978', 0.009986862540245056, ' 1978'), ('The first Star wars movie came out in 1979', 0.009574787691235542, ' 1979')] + +roberta.fill_mask('Vikram samvat calender is official in <mask>', topk=3) +# [('Vikram samvat calender is official in India', 0.21878819167613983, ' India'), ('Vikram samvat calender is official in Delhi', 0.08547237515449524, ' Delhi'), ('Vikram samvat calender is official in Gujarat', 0.07556215673685074, ' Gujarat')] + +roberta.fill_mask('<mask> is the common currency of the European Union', topk=3) +# [('Euro is the common currency of the European Union', 0.9456493854522705, 'Euro'), ('euro is the common currency of the European Union', 0.025748178362846375, 'euro'), ('€ is the common currency of the European Union', 0.011183084920048714, '€')] +``` + +#### Pronoun disambiguation (Winograd Schema Challenge): + +RoBERTa can be used to disambiguate pronouns. First install spaCy and download the English-language model: +```bash +pip install spacy +python -m spacy download en_core_web_lg +``` + +Next load the `roberta.large.wsc` model and call the `disambiguate_pronoun` +function. The pronoun should be surrounded by square brackets (`[]`) and the +query referent surrounded by underscores (`_`), or left blank to return the +predicted candidate text directly: +```python +roberta = torch.hub.load('pytorch/fairseq', 'roberta.large.wsc', user_dir='examples/roberta/wsc') +roberta.cuda() # use the GPU (optional) + +roberta.disambiguate_pronoun('The _trophy_ would not fit in the brown suitcase because [it] was too big.') +# True +roberta.disambiguate_pronoun('The trophy would not fit in the brown _suitcase_ because [it] was too big.') +# False + +roberta.disambiguate_pronoun('The city councilmen refused the demonstrators a permit because [they] feared violence.') +# 'The city councilmen' +roberta.disambiguate_pronoun('The city councilmen refused the demonstrators a permit because [they] advocated violence.') +# 'demonstrators' +``` + +See the [RoBERTA Winograd Schema Challenge (WSC) README](wsc/README.md) for more details on how to train this model. + +#### Extract features aligned to words: + +By default RoBERTa outputs one feature vector per BPE token. You can instead +realign the features to match [spaCy's word-level tokenization](https://spacy.io/usage/linguistic-features#tokenization) +with the `extract_features_aligned_to_words` method. This will compute a +weighted average of the BPE-level features for each word and expose them in +spaCy's `Token.vector` attribute: +```python +doc = roberta.extract_features_aligned_to_words('I said, "hello RoBERTa."') +assert len(doc) == 10 +for tok in doc: + print('{:10}{} (...)'.format(str(tok), tok.vector[:5])) +# <s> tensor([-0.1316, -0.0386, -0.0832, -0.0477, 0.1943], grad_fn=<SliceBackward>) (...) +# I tensor([ 0.0559, 0.1541, -0.4832, 0.0880, 0.0120], grad_fn=<SliceBackward>) (...) +# said tensor([-0.1565, -0.0069, -0.8915, 0.0501, -0.0647], grad_fn=<SliceBackward>) (...) +# , tensor([-0.1318, -0.0387, -0.0834, -0.0477, 0.1944], grad_fn=<SliceBackward>) (...) +# " tensor([-0.0486, 0.1818, -0.3946, -0.0553, 0.0981], grad_fn=<SliceBackward>) (...) +# hello tensor([ 0.0079, 0.1799, -0.6204, -0.0777, -0.0923], grad_fn=<SliceBackward>) (...) +# RoBERTa tensor([-0.2339, -0.1184, -0.7343, -0.0492, 0.5829], grad_fn=<SliceBackward>) (...) +# . tensor([-0.1341, -0.1203, -0.1012, -0.0621, 0.1892], grad_fn=<SliceBackward>) (...) +# " tensor([-0.1341, -0.1203, -0.1012, -0.0621, 0.1892], grad_fn=<SliceBackward>) (...) +# </s> tensor([-0.0930, -0.0392, -0.0821, 0.0158, 0.0649], grad_fn=<SliceBackward>) (...) +``` + +#### Evaluating the `roberta.large.mnli` model: + +Example python code snippet to evaluate accuracy on the MNLI `dev_matched` set. +```python +label_map = {0: 'contradiction', 1: 'neutral', 2: 'entailment'} +ncorrect, nsamples = 0, 0 +roberta.cuda() +roberta.eval() +with open('glue_data/MNLI/dev_matched.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[8], tokens[9], tokens[-1] + tokens = roberta.encode(sent1, sent2) + prediction = roberta.predict('mnli', tokens).argmax().item() + prediction_label = label_map[prediction] + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) +# Expected output: 0.9060 +``` + +## Finetuning + +- [Finetuning on GLUE](README.glue.md) +- [Finetuning on custom classification tasks (e.g., IMDB)](README.custom_classification.md) +- [Finetuning on Winograd Schema Challenge (WSC)](wsc/README.md) +- [Finetuning on Commonsense QA (CQA)](commonsense_qa/README.md) + +## Pretraining using your own data + +See the [tutorial for pretraining RoBERTa using your own data](README.pretraining.md). + +## Citation + +```bibtex +@article{liu2019roberta, + title = {RoBERTa: A Robustly Optimized BERT Pretraining Approach}, + author = {Yinhan Liu and Myle Ott and Naman Goyal and Jingfei Du and + Mandar Joshi and Danqi Chen and Omer Levy and Mike Lewis and + Luke Zettlemoyer and Veselin Stoyanov}, + journal={arXiv preprint arXiv:1907.11692}, + year = {2019}, +} +``` diff --git a/fairseq/examples/roberta/README.pretraining.md b/fairseq/examples/roberta/README.pretraining.md new file mode 100644 index 0000000000000000000000000000000000000000..a4e7453529111fdd198be637d911d1764cb96c0e --- /dev/null +++ b/fairseq/examples/roberta/README.pretraining.md @@ -0,0 +1,84 @@ +# Pretraining RoBERTa using your own data + +This tutorial will walk you through pretraining RoBERTa over your own data. + +### 1) Preprocess the data + +Data should be preprocessed following the [language modeling format](/examples/language_model), i.e. each document should be separated by an empty line (only useful with `--sample-break-mode complete_doc`). Lines will be concatenated as a 1D text stream during training. + +We'll use the [WikiText-103 dataset](https://www.salesforce.com/products/einstein/ai-research/the-wikitext-dependency-language-modeling-dataset/) +to demonstrate how to preprocess raw text data with the GPT-2 BPE. Of course +this dataset is quite small, so the resulting pretrained model will perform +poorly, but it gives the general idea. + +First download the dataset: +```bash +wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip +unzip wikitext-103-raw-v1.zip +``` + +Next encode it with the GPT-2 BPE: +```bash +mkdir -p gpt2_bpe +wget -O gpt2_bpe/encoder.json https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json +wget -O gpt2_bpe/vocab.bpe https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe +for SPLIT in train valid test; do \ + python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json gpt2_bpe/encoder.json \ + --vocab-bpe gpt2_bpe/vocab.bpe \ + --inputs wikitext-103-raw/wiki.${SPLIT}.raw \ + --outputs wikitext-103-raw/wiki.${SPLIT}.bpe \ + --keep-empty \ + --workers 60; \ +done +``` + +Finally preprocess/binarize the data using the GPT-2 fairseq dictionary: +```bash +wget -O gpt2_bpe/dict.txt https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt +fairseq-preprocess \ + --only-source \ + --srcdict gpt2_bpe/dict.txt \ + --trainpref wikitext-103-raw/wiki.train.bpe \ + --validpref wikitext-103-raw/wiki.valid.bpe \ + --testpref wikitext-103-raw/wiki.test.bpe \ + --destdir data-bin/wikitext-103 \ + --workers 60 +``` + +### 2) Train RoBERTa base +```bash +DATA_DIR=data-bin/wikitext-103 + +fairseq-hydra-train -m --config-dir examples/roberta/config/pretraining \ +--config-name base task.data=$DATA_DIR +``` + +**Note:** You can optionally resume training the released RoBERTa base model by +adding `checkpoint.restore_file=/path/to/roberta.base/model.pt`. + +**Note:** The above command assumes training on 8x32GB V100 GPUs. Each GPU uses +a batch size of 16 sequences (`dataset.batch_size`) and accumulates gradients to +further increase the batch size by 16x (`optimization.update_freq`), for a total batch size +of 2048 sequences. If you have fewer GPUs or GPUs with less memory you may need +to reduce `dataset.batch_size` and increase dataset.update_freq to compensate. +Alternatively if you have more GPUs you can decrease `dataset.update_freq` accordingly +to increase training speed. + +**Note:** The learning rate and batch size are tightly connected and need to be +adjusted together. We generally recommend increasing the learning rate as you +increase the batch size according to the following table (although it's also +dataset dependent, so don't rely on the following values too closely): + +batch size | peak learning rate +---|--- +256 | 0.0001 +2048 | 0.0005 +8192 | 0.0007 + +### 3) Load your pretrained model +```python +from fairseq.models.roberta import RobertaModel +roberta = RobertaModel.from_pretrained('checkpoints', 'checkpoint_best.pt', 'path/to/data') +assert isinstance(roberta.model, torch.nn.Module) +``` diff --git a/fairseq/examples/roberta/README.race.md b/fairseq/examples/roberta/README.race.md new file mode 100644 index 0000000000000000000000000000000000000000..13c917e8eca6621e91dce541c7e41436b38cbdc1 --- /dev/null +++ b/fairseq/examples/roberta/README.race.md @@ -0,0 +1,68 @@ +# Finetuning RoBERTa on RACE tasks + +### 1) Download the data from RACE website (http://www.cs.cmu.edu/~glai1/data/race/) + +### 2) Preprocess RACE data: +```bash +python ./examples/roberta/preprocess_RACE.py --input-dir <input-dir> --output-dir <extracted-data-dir> +./examples/roberta/preprocess_RACE.sh <extracted-data-dir> <output-dir> +``` + +### 3) Fine-tuning on RACE: + +```bash +MAX_EPOCH=5 # Number of training epochs. +LR=1e-05 # Peak LR for fixed LR scheduler. +NUM_CLASSES=4 +MAX_SENTENCES=1 # Batch size per GPU. +UPDATE_FREQ=8 # Accumulate gradients to simulate training on 8 GPUs. +DATA_DIR=/path/to/race-output-dir +ROBERTA_PATH=/path/to/roberta/model.pt + +CUDA_VISIBLE_DEVICES=0,1 fairseq-train $DATA_DIR --ddp-backend=legacy_ddp \ + --restore-file $ROBERTA_PATH \ + --reset-optimizer --reset-dataloader --reset-meters \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --task sentence_ranking \ + --num-classes $NUM_CLASSES \ + --init-token 0 --separator-token 2 \ + --max-option-length 128 \ + --max-positions 512 \ + --shorten-method "truncate" \ + --arch roberta_large \ + --dropout 0.1 --attention-dropout 0.1 --weight-decay 0.01 \ + --criterion sentence_ranking \ + --optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-06 \ + --clip-norm 0.0 \ + --lr-scheduler fixed --lr $LR \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --batch-size $MAX_SENTENCES \ + --required-batch-size-multiple 1 \ + --update-freq $UPDATE_FREQ \ + --max-epoch $MAX_EPOCH +``` + +**Note:** + +a) As contexts in RACE are relatively long, we are using smaller batch size per GPU while increasing update-freq to achieve larger effective batch size. + +b) Above cmd-args and hyperparams are tested on one Nvidia `V100` GPU with `32gb` of memory for each task. Depending on the GPU memory resources available to you, you can use increase `--update-freq` and reduce `--batch-size`. + +c) The setting in above command is based on our hyperparam search within a fixed search space (for careful comparison across models). You might be able to find better metrics with wider hyperparam search. + +### 4) Evaluation: + +``` +DATA_DIR=/path/to/race-output-dir # data directory used during training +MODEL_PATH=/path/to/checkpoint_best.pt # path to the finetuned model checkpoint +PREDS_OUT=preds.tsv # output file path to save prediction +TEST_SPLIT=test # can be test (Middle) or test1 (High) +fairseq-validate \ + $DATA_DIR \ + --valid-subset $TEST_SPLIT \ + --path $MODEL_PATH \ + --batch-size 1 \ + --task sentence_ranking \ + --criterion sentence_ranking \ + --save-predictions $PREDS_OUT +``` diff --git a/fairseq/examples/roberta/commonsense_qa/README.md b/fairseq/examples/roberta/commonsense_qa/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7f386decd87d93bf701e2e313c7fea39d982224f --- /dev/null +++ b/fairseq/examples/roberta/commonsense_qa/README.md @@ -0,0 +1,99 @@ +# Finetuning RoBERTa on Commonsense QA + +We follow a similar approach to [finetuning RACE](../README.race.md). Specifically +for each question we construct five inputs, one for each of the five candidate +answer choices. Each input is constructed by concatenating the question and +candidate answer. We then encode each input and pass the resulting "[CLS]" +representations through a fully-connected layer to predict the correct answer. +We train with a standard cross-entropy loss. + +We also found it helpful to prepend a prefix of `Q:` to the question and `A:` to +the answer. The complete input format is: +``` +<s> Q: Where would I not want a fox? </s> A: hen house </s> +``` + +Our final submission is based on a hyperparameter search over the learning rate +(1e-5, 2e-5, 3e-5), batch size (8, 16), number of training steps (2000, 3000, +4000) and random seed. We selected the model with the best performance on the +development set after 100 trials. + +### 1) Download data from the Commonsense QA website (https://www.tau-nlp.org/commonsenseqa) +```bash +bash examples/roberta/commonsense_qa/download_cqa_data.sh +``` + +### 2) Finetune + +```bash +MAX_UPDATES=3000 # Number of training steps. +WARMUP_UPDATES=150 # Linearly increase LR over this many steps. +LR=1e-05 # Peak LR for polynomial LR scheduler. +MAX_SENTENCES=16 # Batch size. +SEED=1 # Random seed. +ROBERTA_PATH=/path/to/roberta/model.pt +DATA_DIR=data/CommonsenseQA + +# we use the --user-dir option to load the task from +# the examples/roberta/commonsense_qa directory: +FAIRSEQ_PATH=/path/to/fairseq +FAIRSEQ_USER_DIR=${FAIRSEQ_PATH}/examples/roberta/commonsense_qa + +CUDA_VISIBLE_DEVICES=0 fairseq-train --fp16 --ddp-backend=legacy_ddp \ + $DATA_DIR \ + --user-dir $FAIRSEQ_USER_DIR \ + --restore-file $ROBERTA_PATH \ + --reset-optimizer --reset-dataloader --reset-meters \ + --no-epoch-checkpoints --no-last-checkpoints --no-save-optimizer-state \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --task commonsense_qa --init-token 0 --bpe gpt2 \ + --arch roberta_large --max-positions 512 \ + --dropout 0.1 --attention-dropout 0.1 --weight-decay 0.01 \ + --criterion sentence_ranking --num-classes 5 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-06 --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR \ + --warmup-updates $WARMUP_UPDATES --total-num-update $MAX_UPDATES \ + --batch-size $MAX_SENTENCES \ + --max-update $MAX_UPDATES \ + --log-format simple --log-interval 25 \ + --seed $SEED +``` + +The above command assumes training on 1 GPU with 32GB of RAM. For GPUs with +less memory, decrease `--batch-size` and increase `--update-freq` +accordingly to compensate. + +### 3) Evaluate +```python +import json +import torch +from fairseq.models.roberta import RobertaModel +from examples.roberta import commonsense_qa # load the Commonsense QA task +roberta = RobertaModel.from_pretrained('checkpoints', 'checkpoint_best.pt', 'data/CommonsenseQA') +roberta.eval() # disable dropout +roberta.cuda() # use the GPU (optional) +nsamples, ncorrect = 0, 0 +with open('data/CommonsenseQA/valid.jsonl') as h: + for line in h: + example = json.loads(line) + scores = [] + for choice in example['question']['choices']: + input = roberta.encode( + 'Q: ' + example['question']['stem'], + 'A: ' + choice['text'], + no_separator=True + ) + score = roberta.predict('sentence_classification_head', input, return_logits=True) + scores.append(score) + pred = torch.cat(scores).argmax() + answer = ord(example['answerKey']) - ord('A') + nsamples += 1 + if pred == answer: + ncorrect += 1 + +print('Accuracy: ' + str(ncorrect / float(nsamples))) +# Accuracy: 0.7846027846027847 +``` + +The above snippet is not batched, which makes it quite slow. See [instructions +for batched prediction with RoBERTa](https://github.com/pytorch/fairseq/tree/main/examples/roberta#batched-prediction). diff --git a/fairseq/examples/roberta/commonsense_qa/__init__.py b/fairseq/examples/roberta/commonsense_qa/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42d21f35eb3dd33a053dcf0edd5eadd2dff11294 --- /dev/null +++ b/fairseq/examples/roberta/commonsense_qa/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import commonsense_qa_task # noqa diff --git a/fairseq/examples/roberta/commonsense_qa/commonsense_qa_task.py b/fairseq/examples/roberta/commonsense_qa/commonsense_qa_task.py new file mode 100644 index 0000000000000000000000000000000000000000..216093f7087a61060767babf5a3f3f4e716a4dfe --- /dev/null +++ b/fairseq/examples/roberta/commonsense_qa/commonsense_qa_task.py @@ -0,0 +1,190 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import json +import os + +import numpy as np +import torch +from fairseq.data import ( + Dictionary, + IdDataset, + ListDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + RawLabelDataset, + RightPadDataset, + SortDataset, + data_utils, + encoders, +) +from fairseq.tasks import LegacyFairseqTask, register_task + + +@register_task("commonsense_qa") +class CommonsenseQATask(LegacyFairseqTask): + """Task to finetune RoBERTa for Commonsense QA.""" + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "data", metavar="DIR", help="path to data directory; we load <split>.jsonl" + ) + parser.add_argument( + "--init-token", + type=int, + default=None, + help="add token at the beginning of each batch item", + ) + parser.add_argument("--num-classes", type=int, default=5) + + def __init__(self, args, vocab): + super().__init__(args) + self.vocab = vocab + self.mask = vocab.add_symbol("<mask>") + + self.bpe = encoders.build_bpe(args) + + @classmethod + def load_dictionary(cls, filename): + """Load the dictionary from the filename + + Args: + filename (str): the filename + """ + dictionary = Dictionary.load(filename) + dictionary.add_symbol("<mask>") + return dictionary + + @classmethod + def setup_task(cls, args, **kwargs): + assert ( + args.criterion == "sentence_ranking" + ), "Must set --criterion=sentence_ranking" + + # load data and label dictionaries + vocab = cls.load_dictionary(os.path.join(args.data, "dict.txt")) + print("| dictionary: {} types".format(len(vocab))) + + return cls(args, vocab) + + def load_dataset( + self, split, epoch=1, combine=False, data_path=None, return_only=False, **kwargs + ): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + + def binarize(s, append_bos=False): + if self.bpe is not None: + s = self.bpe.encode(s) + tokens = self.vocab.encode_line( + s, + append_eos=True, + add_if_not_exist=False, + ).long() + if append_bos and self.args.init_token is not None: + tokens = torch.cat([tokens.new([self.args.init_token]), tokens]) + return tokens + + if data_path is None: + data_path = os.path.join(self.args.data, split + ".jsonl") + if not os.path.exists(data_path): + raise FileNotFoundError("Cannot find data: {}".format(data_path)) + + src_tokens = [[] for i in range(self.args.num_classes)] + src_lengths = [[] for i in range(self.args.num_classes)] + labels = [] + + with open(data_path) as h: + for line in h: + example = json.loads(line.strip()) + if "answerKey" in example: + label = ord(example["answerKey"]) - ord("A") + labels.append(label) + question = example["question"]["stem"] + assert len(example["question"]["choices"]) == self.args.num_classes + # format: `<s> Q: Where would I not want a fox? </s> A: hen house </s>` + question = "Q: " + question + question_toks = binarize(question, append_bos=True) + for i, choice in enumerate(example["question"]["choices"]): + src = "A: " + choice["text"] + src_bin = torch.cat([question_toks, binarize(src)]) + src_tokens[i].append(src_bin) + src_lengths[i].append(len(src_bin)) + assert all( + len(src_tokens[0]) == len(src_tokens[i]) + for i in range(self.args.num_classes) + ) + assert len(src_tokens[0]) == len(src_lengths[0]) + assert len(labels) == 0 or len(labels) == len(src_tokens[0]) + + for i in range(self.args.num_classes): + src_lengths[i] = np.array(src_lengths[i]) + src_tokens[i] = ListDataset(src_tokens[i], src_lengths[i]) + src_lengths[i] = ListDataset(src_lengths[i]) + + dataset = { + "id": IdDataset(), + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_tokens[0], reduce=True), + } + + for i in range(self.args.num_classes): + dataset.update( + { + "net_input{}".format(i + 1): { + "src_tokens": RightPadDataset( + src_tokens[i], + pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": src_lengths[i], + } + } + ) + + if len(labels) > 0: + dataset.update({"target": RawLabelDataset(labels)}) + + dataset = NestedDictionaryDataset( + dataset, + sizes=[np.maximum.reduce([src_token.sizes for src_token in src_tokens])], + ) + + with data_utils.numpy_seed(self.args.seed): + dataset = SortDataset( + dataset, + # shuffle + sort_order=[np.random.permutation(len(dataset))], + ) + + print("| Loaded {} with {} samples".format(split, len(dataset))) + + self.datasets[split] = dataset + return self.datasets[split] + + def build_model(self, args): + from fairseq import models + + model = models.build_model(args, self) + + model.register_classification_head( + "sentence_classification_head", + num_classes=1, + ) + + return model + + @property + def source_dictionary(self): + return self.vocab + + @property + def target_dictionary(self): + return self.vocab diff --git a/fairseq/examples/roberta/commonsense_qa/download_cqa_data.sh b/fairseq/examples/roberta/commonsense_qa/download_cqa_data.sh new file mode 100644 index 0000000000000000000000000000000000000000..5f300093fa0a0feb819d8b6aed307b59e3891d01 --- /dev/null +++ b/fairseq/examples/roberta/commonsense_qa/download_cqa_data.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +OUTDIR=data/CommonsenseQA + +mkdir -p $OUTDIR + +wget -O $OUTDIR/train.jsonl https://s3.amazonaws.com/commensenseqa/train_rand_split.jsonl +wget -O $OUTDIR/valid.jsonl https://s3.amazonaws.com/commensenseqa/dev_rand_split.jsonl +wget -O $OUTDIR/test.jsonl https://s3.amazonaws.com/commensenseqa/test_rand_split_no_answers.jsonl +wget -O $OUTDIR/dict.txt https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt diff --git a/fairseq/examples/roberta/config/finetuning/cola.yaml b/fairseq/examples/roberta/config/finetuning/cola.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ac76611201275fcee6311b625599ea0863c92898 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/cola.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 16 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 320 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 5336 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/mnli.yaml b/fairseq/examples/roberta/config/finetuning/mnli.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5be10c362fdadae49e5a6018ef74095892903914 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/mnli.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 3 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 32 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 7432 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 123873 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/mrpc.yaml b/fairseq/examples/roberta/config/finetuning/mrpc.yaml new file mode 100644 index 0000000000000000000000000000000000000000..aa8b7db393ed00dd9b403ba009de70bf18a75309 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/mrpc.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 16 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 137 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 2296 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/qnli.yaml b/fairseq/examples/roberta/config/finetuning/qnli.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b4595b090ee23b74bb3924c09704702c4208e395 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/qnli.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 32 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 1986 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 33112 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/qqp.yaml b/fairseq/examples/roberta/config/finetuning/qqp.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5a2b2ed743963af1f558927f226d993c66fbd45c --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/qqp.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 32 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 28318 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 113272 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/rte.yaml b/fairseq/examples/roberta/config/finetuning/rte.yaml new file mode 100644 index 0000000000000000000000000000000000000000..73184650117e5f1ce5ec4542a0076eaf3044c2a3 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/rte.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 16 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 122 + +optimization: + clip_norm: 0.0 + lr: [2e-05] + max_update: 2036 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/sst_2.yaml b/fairseq/examples/roberta/config/finetuning/sst_2.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a93ad2f22c4c248f043fc18d345d61e9484ed39e --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/sst_2.yaml @@ -0,0 +1,59 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 2 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + best_checkpoint_metric: accuracy + maximize_best_checkpoint_metric: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + +dataset: + batch_size: 32 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 1256 + +optimization: + clip_norm: 0.0 + lr: [1e-05] + max_update: 20935 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/finetuning/sts_b.yaml b/fairseq/examples/roberta/config/finetuning/sts_b.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2d495221ad846162c0b3f15ea6e17d723e7ea754 --- /dev/null +++ b/fairseq/examples/roberta/config/finetuning/sts_b.yaml @@ -0,0 +1,58 @@ +# @package _group_ + +common: + fp16: true + fp16_init_scale: 4 + threshold_loss_scale: 1 + fp16_scale_window: 128 + log_format: json + log_interval: 200 + +task: + _name: sentence_prediction + data: ??? + init_token: 0 + separator_token: 2 + num_classes: 1 + max_positions: 512 + +checkpoint: + restore_file: ??? + reset_optimizer: true + reset_dataloader: true + reset_meters: true + no_epoch_checkpoints: true + +distributed_training: + find_unused_parameters: true + distributed_world_size: 1 + +criterion: + _name: sentence_prediction + regression_target: true + +dataset: + batch_size: 16 + required_batch_size_multiple: 1 + max_tokens: 4400 + +optimizer: + _name: adam + weight_decay: 0.1 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 214 + +optimization: + clip_norm: 0.0 + lr: [2e-05] + max_update: 3598 + max_epoch: 10 + +model: + _name: roberta + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/config/pretraining/base.yaml b/fairseq/examples/roberta/config/pretraining/base.yaml new file mode 100644 index 0000000000000000000000000000000000000000..97829908f740ba6813c895aa32019cc2760c1eb8 --- /dev/null +++ b/fairseq/examples/roberta/config/pretraining/base.yaml @@ -0,0 +1,42 @@ +# @package _group_ +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + no_epoch_checkpoints: true + +task: + _name: masked_lm + data: ??? + sample_break_mode: complete + tokens_per_sample: 512 + +criterion: masked_lm + +dataset: + batch_size: 16 + ignore_unused_valid_subsets: true + +optimizer: + _name: adam + weight_decay: 0.01 + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 10000 + +optimization: + clip_norm: 0 + lr: [0.0005] + max_update: 125000 + update_freq: [16] + +model: + _name: roberta + max_positions: 512 + dropout: 0.1 + attention_dropout: 0.1 diff --git a/fairseq/examples/roberta/multiprocessing_bpe_encoder.py b/fairseq/examples/roberta/multiprocessing_bpe_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..43fe0451bf4d5762d734314075b1402c2a8db2bb --- /dev/null +++ b/fairseq/examples/roberta/multiprocessing_bpe_encoder.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import contextlib +import sys +from collections import Counter +from multiprocessing import Pool + +from fairseq.data.encoders.gpt2_bpe import get_encoder + + +def main(): + """ + Helper script to encode raw text with the GPT-2 BPE using multiple processes. + + The encoder.json and vocab.bpe files can be obtained here: + - https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json + - https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe + """ + parser = argparse.ArgumentParser() + parser.add_argument( + "--encoder-json", + help="path to encoder.json", + ) + parser.add_argument( + "--vocab-bpe", + type=str, + help="path to vocab.bpe", + ) + parser.add_argument( + "--inputs", + nargs="+", + default=["-"], + help="input files to filter/encode", + ) + parser.add_argument( + "--outputs", + nargs="+", + default=["-"], + help="path to save encoded outputs", + ) + parser.add_argument( + "--keep-empty", + action="store_true", + help="keep empty lines", + ) + parser.add_argument("--workers", type=int, default=20) + args = parser.parse_args() + + assert len(args.inputs) == len( + args.outputs + ), "number of input and output paths should match" + + with contextlib.ExitStack() as stack: + inputs = [ + stack.enter_context(open(input, "r", encoding="utf-8")) + if input != "-" + else sys.stdin + for input in args.inputs + ] + outputs = [ + stack.enter_context(open(output, "w", encoding="utf-8")) + if output != "-" + else sys.stdout + for output in args.outputs + ] + + encoder = MultiprocessingEncoder(args) + pool = Pool(args.workers, initializer=encoder.initializer) + encoded_lines = pool.imap(encoder.encode_lines, zip(*inputs), 100) + + stats = Counter() + for i, (filt, enc_lines) in enumerate(encoded_lines, start=1): + if filt == "PASS": + for enc_line, output_h in zip(enc_lines, outputs): + print(enc_line, file=output_h) + else: + stats["num_filtered_" + filt] += 1 + if i % 10000 == 0: + print("processed {} lines".format(i), file=sys.stderr) + + for k, v in stats.most_common(): + print("[{}] filtered {} lines".format(k, v), file=sys.stderr) + + +class MultiprocessingEncoder(object): + def __init__(self, args): + self.args = args + + def initializer(self): + global bpe + bpe = get_encoder(self.args.encoder_json, self.args.vocab_bpe) + + def encode(self, line): + global bpe + ids = bpe.encode(line) + return list(map(str, ids)) + + def decode(self, tokens): + global bpe + return bpe.decode(tokens) + + def encode_lines(self, lines): + """ + Encode a set of lines. All lines will be encoded together. + """ + enc_lines = [] + for line in lines: + line = line.strip() + if len(line) == 0 and not self.args.keep_empty: + return ["EMPTY", None] + tokens = self.encode(line) + enc_lines.append(" ".join(tokens)) + return ["PASS", enc_lines] + + def decode_lines(self, lines): + dec_lines = [] + for line in lines: + tokens = map(int, line.strip().split()) + dec_lines.append(self.decode(tokens)) + return ["PASS", dec_lines] + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/roberta/preprocess_GLUE_tasks.sh b/fairseq/examples/roberta/preprocess_GLUE_tasks.sh new file mode 100755 index 0000000000000000000000000000000000000000..7f215a3b53e1c4a7b1f0320102915a49d84a5015 --- /dev/null +++ b/fairseq/examples/roberta/preprocess_GLUE_tasks.sh @@ -0,0 +1,185 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +# raw glue data as downloaded by glue download script (https://gist.github.com/W4ngatang/60c2bdb54d156a41194446737ce03e2e) +if [[ $# -ne 2 ]]; then + echo "Run as following:" + echo "./examples/roberta/preprocess_GLUE_tasks.sh <glud_data_folder> <task_name>" + exit 1 +fi + +GLUE_DATA_FOLDER=$1 + +# download bpe encoder.json, vocabulary and fairseq dictionary +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt' + +TASKS=$2 # QQP + +if [ "$TASKS" = "ALL" ] +then + TASKS="QQP MNLI QNLI MRPC RTE STS-B SST-2 CoLA" +fi + +for TASK in $TASKS +do + echo "Preprocessing $TASK" + + TASK_DATA_FOLDER="$GLUE_DATA_FOLDER/$TASK" + echo "Raw data as downloaded from glue website: $TASK_DATA_FOLDER" + + SPLITS="train dev test" + INPUT_COUNT=2 + if [ "$TASK" = "QQP" ] + then + INPUT_COLUMNS=( 4 5 ) + TEST_INPUT_COLUMNS=( 2 3 ) + LABEL_COLUMN=6 + elif [ "$TASK" = "MNLI" ] + then + SPLITS="train dev_matched dev_mismatched test_matched test_mismatched" + INPUT_COLUMNS=( 9 10 ) + TEST_INPUT_COLUMNS=( 9 10 ) + DEV_LABEL_COLUMN=16 + LABEL_COLUMN=12 + elif [ "$TASK" = "QNLI" ] + then + INPUT_COLUMNS=( 2 3 ) + TEST_INPUT_COLUMNS=( 2 3 ) + LABEL_COLUMN=4 + elif [ "$TASK" = "MRPC" ] + then + INPUT_COLUMNS=( 4 5 ) + TEST_INPUT_COLUMNS=( 4 5 ) + LABEL_COLUMN=1 + elif [ "$TASK" = "RTE" ] + then + INPUT_COLUMNS=( 2 3 ) + TEST_INPUT_COLUMNS=( 2 3 ) + LABEL_COLUMN=4 + elif [ "$TASK" = "STS-B" ] + then + INPUT_COLUMNS=( 8 9 ) + TEST_INPUT_COLUMNS=( 8 9 ) + LABEL_COLUMN=10 + # Following are single sentence tasks. + elif [ "$TASK" = "SST-2" ] + then + INPUT_COLUMNS=( 1 ) + TEST_INPUT_COLUMNS=( 2 ) + LABEL_COLUMN=2 + INPUT_COUNT=1 + elif [ "$TASK" = "CoLA" ] + then + INPUT_COLUMNS=( 4 ) + TEST_INPUT_COLUMNS=( 2 ) + LABEL_COLUMN=2 + INPUT_COUNT=1 + fi + + # Strip out header and filter lines that don't have expected number of fields. + rm -rf "$TASK_DATA_FOLDER/processed" + mkdir -p "$TASK_DATA_FOLDER/processed" + for SPLIT in $SPLITS + do + # CoLA train and dev doesn't have header. + if [[ ( "$TASK" = "CoLA") && ( "$SPLIT" != "test" ) ]] + then + cp "$TASK_DATA_FOLDER/$SPLIT.tsv" "$TASK_DATA_FOLDER/processed/$SPLIT.tsv.temp"; + else + tail -n +2 "$TASK_DATA_FOLDER/$SPLIT.tsv" > "$TASK_DATA_FOLDER/processed/$SPLIT.tsv.temp"; + fi + + # Remove unformatted lines from train and dev files for QQP dataset. + if [[ ( "$TASK" = "QQP") && ( "$SPLIT" != "test" ) ]] + then + awk -F '\t' -v NUM_FIELDS=6 'NF==NUM_FIELDS{print}{}' "$TASK_DATA_FOLDER/processed/$SPLIT.tsv.temp" > "$TASK_DATA_FOLDER/processed/$SPLIT.tsv"; + else + cp "$TASK_DATA_FOLDER/processed/$SPLIT.tsv.temp" "$TASK_DATA_FOLDER/processed/$SPLIT.tsv"; + fi + rm "$TASK_DATA_FOLDER/processed/$SPLIT.tsv.temp"; + done + + # Split into input0, input1 and label + for SPLIT in $SPLITS + do + for INPUT_TYPE in $(seq 0 $((INPUT_COUNT-1))) + do + if [[ "$SPLIT" != test* ]] + then + COLUMN_NUMBER=${INPUT_COLUMNS[$INPUT_TYPE]} + else + COLUMN_NUMBER=${TEST_INPUT_COLUMNS[$INPUT_TYPE]} + fi + cut -f"$COLUMN_NUMBER" "$TASK_DATA_FOLDER/processed/$SPLIT.tsv" > "$TASK_DATA_FOLDER/processed/$SPLIT.raw.input$INPUT_TYPE"; + done + + if [[ "$SPLIT" != test* ]] + then + if [ "$TASK" = "MNLI" ] && [ "$SPLIT" != "train" ] + then + cut -f"$DEV_LABEL_COLUMN" "$TASK_DATA_FOLDER/processed/$SPLIT.tsv" > "$TASK_DATA_FOLDER/processed/$SPLIT.label"; + else + cut -f"$LABEL_COLUMN" "$TASK_DATA_FOLDER/processed/$SPLIT.tsv" > "$TASK_DATA_FOLDER/processed/$SPLIT.label"; + fi + fi + + # BPE encode. + for INPUT_TYPE in $(seq 0 $((INPUT_COUNT-1))) + do + LANG="input$INPUT_TYPE" + echo "BPE encoding $SPLIT/$LANG" + python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json encoder.json \ + --vocab-bpe vocab.bpe \ + --inputs "$TASK_DATA_FOLDER/processed/$SPLIT.raw.$LANG" \ + --outputs "$TASK_DATA_FOLDER/processed/$SPLIT.$LANG" \ + --workers 60 \ + --keep-empty; + done + done + + # Remove output directory. + rm -rf "$TASK-bin" + + DEVPREF="$TASK_DATA_FOLDER/processed/dev.LANG" + TESTPREF="$TASK_DATA_FOLDER/processed/test.LANG" + if [ "$TASK" = "MNLI" ] + then + DEVPREF="$TASK_DATA_FOLDER/processed/dev_matched.LANG,$TASK_DATA_FOLDER/processed/dev_mismatched.LANG" + TESTPREF="$TASK_DATA_FOLDER/processed/test_matched.LANG,$TASK_DATA_FOLDER/processed/test_mismatched.LANG" + fi + + # Run fairseq preprocessing: + for INPUT_TYPE in $(seq 0 $((INPUT_COUNT-1))) + do + LANG="input$INPUT_TYPE" + fairseq-preprocess \ + --only-source \ + --trainpref "$TASK_DATA_FOLDER/processed/train.$LANG" \ + --validpref "${DEVPREF//LANG/$LANG}" \ + --testpref "${TESTPREF//LANG/$LANG}" \ + --destdir "$TASK-bin/$LANG" \ + --workers 60 \ + --srcdict dict.txt; + done + if [[ "$TASK" != "STS-B" ]] + then + fairseq-preprocess \ + --only-source \ + --trainpref "$TASK_DATA_FOLDER/processed/train.label" \ + --validpref "${DEVPREF//LANG/label}" \ + --destdir "$TASK-bin/label" \ + --workers 60; + else + # For STS-B output range is converted to be between: [0.0, 1.0] + mkdir -p "$TASK-bin/label" + awk '{print $1 / 5.0 }' "$TASK_DATA_FOLDER/processed/train.label" > "$TASK-bin/label/train.label" + awk '{print $1 / 5.0 }' "$TASK_DATA_FOLDER/processed/dev.label" > "$TASK-bin/label/valid.label" + fi +done diff --git a/fairseq/examples/roberta/preprocess_RACE.py b/fairseq/examples/roberta/preprocess_RACE.py new file mode 100644 index 0000000000000000000000000000000000000000..cdd66072718ccb6033304c97926271909a17f9d6 --- /dev/null +++ b/fairseq/examples/roberta/preprocess_RACE.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import json +import os +import re + + +class InputExample: + def __init__(self, paragraph, qa_list, label): + self.paragraph = paragraph + self.qa_list = qa_list + self.label = label + + +def get_examples(data_dir, set_type): + """ + Extract paragraph and question-answer list from each json file + """ + examples = [] + + levels = ["middle", "high"] + set_type_c = set_type.split("-") + if len(set_type_c) == 2: + levels = [set_type_c[1]] + set_type = set_type_c[0] + for level in levels: + cur_dir = os.path.join(data_dir, set_type, level) + for filename in os.listdir(cur_dir): + cur_path = os.path.join(cur_dir, filename) + with open(cur_path, "r") as f: + cur_data = json.load(f) + answers = cur_data["answers"] + options = cur_data["options"] + questions = cur_data["questions"] + context = cur_data["article"].replace("\n", " ") + context = re.sub(r"\s+", " ", context) + for i in range(len(answers)): + label = ord(answers[i]) - ord("A") + qa_list = [] + question = questions[i] + for j in range(4): + option = options[i][j] + if "_" in question: + qa_cat = question.replace("_", option) + else: + qa_cat = " ".join([question, option]) + qa_cat = re.sub(r"\s+", " ", qa_cat) + qa_list.append(qa_cat) + examples.append(InputExample(context, qa_list, label)) + + return examples + + +def main(): + """ + Helper script to extract paragraphs questions and answers from RACE datasets. + """ + parser = argparse.ArgumentParser() + parser.add_argument( + "--input-dir", + help="input directory for downloaded RACE dataset", + ) + parser.add_argument( + "--output-dir", + help="output directory for extracted data", + ) + args = parser.parse_args() + + if not os.path.exists(args.output_dir): + os.makedirs(args.output_dir, exist_ok=True) + + for set_type in ["train", "dev", "test-middle", "test-high"]: + examples = get_examples(args.input_dir, set_type) + qa_file_paths = [ + os.path.join(args.output_dir, set_type + ".input" + str(i + 1)) + for i in range(4) + ] + qa_files = [open(qa_file_path, "w") for qa_file_path in qa_file_paths] + outf_context_path = os.path.join(args.output_dir, set_type + ".input0") + outf_label_path = os.path.join(args.output_dir, set_type + ".label") + outf_context = open(outf_context_path, "w") + outf_label = open(outf_label_path, "w") + for example in examples: + outf_context.write(example.paragraph + "\n") + for i in range(4): + qa_files[i].write(example.qa_list[i] + "\n") + outf_label.write(str(example.label) + "\n") + + for f in qa_files: + f.close() + outf_label.close() + outf_context.close() + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/roberta/preprocess_RACE.sh b/fairseq/examples/roberta/preprocess_RACE.sh new file mode 100755 index 0000000000000000000000000000000000000000..932d2ab6e521fecc7d0297f26a8c43857541ef3b --- /dev/null +++ b/fairseq/examples/roberta/preprocess_RACE.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +# data should be downloaded and processed with reprocess_RACE.py +if [[ $# -ne 2 ]]; then + echo "Run as following:" + echo "./examples/roberta/preprocess_RACE.sh <race_data_folder> <output_folder>" + exit 1 +fi + +RACE_DATA_FOLDER=$1 +OUT_DATA_FOLDER=$2 + +# download bpe encoder.json, vocabulary and fairseq dictionary +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe' +wget -N 'https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt' + +SPLITS="train dev test-middle test-high" +INPUT_TYPES="input0 input1 input2 input3 input4" +for INPUT_TYPE in $INPUT_TYPES +do + for SPLIT in $SPLITS + do + echo "BPE encoding $SPLIT/$INPUT_TYPE" + python -m examples.roberta.multiprocessing_bpe_encoder \ + --encoder-json encoder.json \ + --vocab-bpe vocab.bpe \ + --inputs "$RACE_DATA_FOLDER/$SPLIT.$INPUT_TYPE" \ + --outputs "$RACE_DATA_FOLDER/$SPLIT.$INPUT_TYPE.bpe" \ + --workers 10 \ + --keep-empty; + + done +done + +for INPUT_TYPE in $INPUT_TYPES + do + LANG="input$INPUT_TYPE" + fairseq-preprocess \ + --only-source \ + --trainpref "$RACE_DATA_FOLDER/train.$INPUT_TYPE.bpe" \ + --validpref "$RACE_DATA_FOLDER/dev.$INPUT_TYPE.bpe" \ + --testpref "$RACE_DATA_FOLDER/test-middle.$INPUT_TYPE.bpe,$RACE_DATA_FOLDER/test-high.$INPUT_TYPE.bpe" \ + --destdir "$OUT_DATA_FOLDER/$INPUT_TYPE" \ + --workers 10 \ + --srcdict dict.txt; +done + +rm -rf "$OUT_DATA_FOLDER/label" +mkdir -p "$OUT_DATA_FOLDER/label" +cp "$RACE_DATA_FOLDER/train.label" "$OUT_DATA_FOLDER/label/" +cp "$RACE_DATA_FOLDER/dev.label" "$OUT_DATA_FOLDER/label/valid.label" +cp "$RACE_DATA_FOLDER/test-middle.label" "$OUT_DATA_FOLDER/label/test.label" +cp "$RACE_DATA_FOLDER/test-high.label" "$OUT_DATA_FOLDER/label/test1.label" diff --git a/fairseq/examples/roberta/wsc/README.md b/fairseq/examples/roberta/wsc/README.md new file mode 100644 index 0000000000000000000000000000000000000000..21a045d999739836a17574593292e42131315ae9 --- /dev/null +++ b/fairseq/examples/roberta/wsc/README.md @@ -0,0 +1,125 @@ +# Finetuning RoBERTa on Winograd Schema Challenge (WSC) data + +The following instructions can be used to finetune RoBERTa on the WSC training +data provided by [SuperGLUE](https://super.gluebenchmark.com/). + +Note that there is high variance in the results. For our GLUE/SuperGLUE +submission we swept over the learning rate (1e-5, 2e-5, 3e-5), batch size (16, +32, 64) and total number of updates (500, 1000, 2000, 3000), as well as the +random seed. Out of ~100 runs we chose the best 7 models and ensembled them. + +**Approach:** The instructions below use a slightly different loss function than +what's described in the original RoBERTa arXiv paper. In particular, +[Kocijan et al. (2019)](https://arxiv.org/abs/1905.06290) introduce a margin +ranking loss between `(query, candidate)` pairs with tunable hyperparameters +alpha and beta. This is supported in our code as well with the `--wsc-alpha` and +`--wsc-beta` arguments. However, we achieved slightly better (and more robust) +results on the development set by instead using a single cross entropy loss term +over the log-probabilities for the query and all mined candidates. **The +candidates are mined using spaCy from each input sentence in isolation, so the +approach remains strictly pointwise.** This reduces the number of +hyperparameters and our best model achieved 92.3% development set accuracy, +compared to ~90% accuracy for the margin loss. Later versions of the RoBERTa +arXiv paper will describe this updated formulation. + +### 1) Download the WSC data from the SuperGLUE website: +```bash +wget https://dl.fbaipublicfiles.com/glue/superglue/data/v2/WSC.zip +unzip WSC.zip + +# we also need to copy the RoBERTa dictionary into the same directory +wget -O WSC/dict.txt https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/dict.txt +``` + +### 2) Finetune over the provided training data: +```bash +TOTAL_NUM_UPDATES=2000 # Total number of training steps. +WARMUP_UPDATES=250 # Linearly increase LR over this many steps. +LR=2e-05 # Peak LR for polynomial LR scheduler. +MAX_SENTENCES=16 # Batch size per GPU. +SEED=1 # Random seed. +ROBERTA_PATH=/path/to/roberta/model.pt + +# we use the --user-dir option to load the task and criterion +# from the examples/roberta/wsc directory: +FAIRSEQ_PATH=/path/to/fairseq +FAIRSEQ_USER_DIR=${FAIRSEQ_PATH}/examples/roberta/wsc + +CUDA_VISIBLE_DEVICES=0,1,2,3 fairseq-train WSC/ \ + --restore-file $ROBERTA_PATH \ + --reset-optimizer --reset-dataloader --reset-meters \ + --no-epoch-checkpoints --no-last-checkpoints --no-save-optimizer-state \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --valid-subset val \ + --fp16 --ddp-backend legacy_ddp \ + --user-dir $FAIRSEQ_USER_DIR \ + --task wsc --criterion wsc --wsc-cross-entropy \ + --arch roberta_large --bpe gpt2 --max-positions 512 \ + --dropout 0.1 --attention-dropout 0.1 --weight-decay 0.01 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-06 \ + --lr-scheduler polynomial_decay --lr $LR \ + --warmup-updates $WARMUP_UPDATES --total-num-update $TOTAL_NUM_UPDATES \ + --batch-size $MAX_SENTENCES \ + --max-update $TOTAL_NUM_UPDATES \ + --log-format simple --log-interval 100 \ + --seed $SEED +``` + +The above command assumes training on 4 GPUs, but you can achieve the same +results on a single GPU by adding `--update-freq=4`. + +### 3) Evaluate +```python +from fairseq.models.roberta import RobertaModel +from examples.roberta.wsc import wsc_utils # also loads WSC task and criterion +roberta = RobertaModel.from_pretrained('checkpoints', 'checkpoint_best.pt', 'WSC/') +roberta.cuda() +nsamples, ncorrect = 0, 0 +for sentence, label in wsc_utils.jsonl_iterator('WSC/val.jsonl', eval=True): + pred = roberta.disambiguate_pronoun(sentence) + nsamples += 1 + if pred == label: + ncorrect += 1 +print('Accuracy: ' + str(ncorrect / float(nsamples))) +# Accuracy: 0.9230769230769231 +``` + +## RoBERTa training on WinoGrande dataset +We have also provided `winogrande` task and criterion for finetuning on the +[WinoGrande](https://mosaic.allenai.org/projects/winogrande) like datasets +where there are always two candidates and one is correct. +It's more efficient implementation for such subcases. + +```bash +TOTAL_NUM_UPDATES=23750 # Total number of training steps. +WARMUP_UPDATES=2375 # Linearly increase LR over this many steps. +LR=1e-05 # Peak LR for polynomial LR scheduler. +MAX_SENTENCES=32 # Batch size per GPU. +SEED=1 # Random seed. +ROBERTA_PATH=/path/to/roberta/model.pt + +# we use the --user-dir option to load the task and criterion +# from the examples/roberta/wsc directory: +FAIRSEQ_PATH=/path/to/fairseq +FAIRSEQ_USER_DIR=${FAIRSEQ_PATH}/examples/roberta/wsc + +cd fairseq +CUDA_VISIBLE_DEVICES=0 fairseq-train winogrande_1.0/ \ + --restore-file $ROBERTA_PATH \ + --reset-optimizer --reset-dataloader --reset-meters \ + --no-epoch-checkpoints --no-last-checkpoints --no-save-optimizer-state \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --valid-subset val \ + --fp16 --ddp-backend legacy_ddp \ + --user-dir $FAIRSEQ_USER_DIR \ + --task winogrande --criterion winogrande \ + --wsc-margin-alpha 5.0 --wsc-margin-beta 0.4 \ + --arch roberta_large --bpe gpt2 --max-positions 512 \ + --dropout 0.1 --attention-dropout 0.1 --weight-decay 0.01 \ + --optimizer adam --adam-betas '(0.9, 0.98)' --adam-eps 1e-06 \ + --lr-scheduler polynomial_decay --lr $LR \ + --warmup-updates $WARMUP_UPDATES --total-num-update $TOTAL_NUM_UPDATES \ + --batch-size $MAX_SENTENCES \ + --max-update $TOTAL_NUM_UPDATES \ + --log-format simple --log-interval 100 +``` diff --git a/fairseq/examples/roberta/wsc/__init__.py b/fairseq/examples/roberta/wsc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..78afa4728eeed96142900118f6452730023466c9 --- /dev/null +++ b/fairseq/examples/roberta/wsc/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import wsc_criterion # noqa +from . import wsc_task # noqa diff --git a/fairseq/examples/roberta/wsc/wsc_criterion.py b/fairseq/examples/roberta/wsc/wsc_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..ed0251fdecc3573228ad271f1090aaf914b48cd1 --- /dev/null +++ b/fairseq/examples/roberta/wsc/wsc_criterion.py @@ -0,0 +1,167 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.criterions import LegacyFairseqCriterion, register_criterion +from fairseq.data import encoders + + +@register_criterion("wsc") +class WSCCriterion(LegacyFairseqCriterion): + def __init__(self, args, task): + super().__init__(args, task) + if self.args.save_predictions is not None: + self.prediction_h = open(self.args.save_predictions, "w") + else: + self.prediction_h = None + self.bpe = encoders.build_bpe(args.bpe) + self.tokenizer = encoders.build_tokenizer(args.tokenizer) + + def __del__(self): + if self.prediction_h is not None: + self.prediction_h.close() + + @staticmethod + def add_args(parser): + """Add criterion-specific arguments to the parser.""" + parser.add_argument("--wsc-margin-alpha", type=float, metavar="A", default=1.0) + parser.add_argument("--wsc-margin-beta", type=float, metavar="B", default=0.0) + parser.add_argument( + "--wsc-cross-entropy", + action="store_true", + help="use cross entropy formulation instead of margin loss", + ) + parser.add_argument( + "--save-predictions", metavar="FILE", help="file to save predictions to" + ) + + def get_masked_input(self, tokens, mask): + masked_tokens = tokens.clone() + masked_tokens[mask] = self.task.mask + return masked_tokens + + def get_lprobs(self, model, tokens, mask): + logits, _ = model(src_tokens=self.get_masked_input(tokens, mask)) + lprobs = F.log_softmax(logits, dim=-1, dtype=torch.float) + scores = lprobs.gather(2, tokens.unsqueeze(-1)).squeeze(-1) + mask = mask.type_as(scores) + scores = (scores * mask).sum(dim=-1) / mask.sum(dim=-1) + return scores + + def get_loss(self, query_lprobs, cand_lprobs): + if self.args.wsc_cross_entropy: + return F.cross_entropy( + torch.cat([query_lprobs, cand_lprobs]).unsqueeze(0), + query_lprobs.new([0]).long(), + ) + else: + return ( + -query_lprobs + + self.args.wsc_margin_alpha + * (cand_lprobs - query_lprobs + self.args.wsc_margin_beta).clamp(min=0) + ).sum() + + def forward(self, model, sample, reduce=True): + # compute loss and accuracy + loss, nloss = 0.0, 0 + ncorrect, nqueries = 0, 0 + + for i, label in enumerate(sample["labels"]): + query_lprobs = self.get_lprobs( + model, + sample["query_tokens"][i].unsqueeze(0), + sample["query_masks"][i].unsqueeze(0), + ) + cand_lprobs = self.get_lprobs( + model, + sample["candidate_tokens"][i], + sample["candidate_masks"][i], + ) + + pred = (query_lprobs >= cand_lprobs).all().item() + + if label is not None: + label = 1 if label else 0 + ncorrect += 1 if pred == label else 0 + nqueries += 1 + + if label: + # only compute a loss for positive instances + nloss += 1 + loss += self.get_loss(query_lprobs, cand_lprobs) + + id = sample["id"][i].item() + if self.prediction_h is not None: + print("{}\t{}\t{}".format(id, pred, label), file=self.prediction_h) + + if nloss == 0: + loss = torch.tensor(0.0, requires_grad=True) + + sample_size = nqueries if nqueries > 0 else 1 + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + "ncorrect": ncorrect, + "nqueries": nqueries, + } + return loss, sample_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + agg_output = { + "loss": loss_sum / sample_size / math.log(2), + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + + ncorrect = sum(log.get("ncorrect", 0) for log in logging_outputs) + nqueries = sum(log.get("nqueries", 0) for log in logging_outputs) + if nqueries > 0: + agg_output["accuracy"] = ncorrect / float(nqueries) + + return agg_output + + +@register_criterion("winogrande") +class WinograndeCriterion(WSCCriterion): + def forward(self, model, sample, reduce=True): + # compute loss and accuracy + query_lprobs = self.get_lprobs( + model, + sample["query_tokens"], + sample["query_masks"], + ) + cand_lprobs = self.get_lprobs( + model, + sample["candidate_tokens"], + sample["candidate_masks"], + ) + pred = query_lprobs >= cand_lprobs + loss = self.get_loss(query_lprobs, cand_lprobs) + + sample_size = sample["query_tokens"].size(0) + ncorrect = pred.sum().item() + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + "ncorrect": ncorrect, + "nqueries": sample_size, + } + return loss, sample_size, logging_output diff --git a/fairseq/examples/roberta/wsc/wsc_task.py b/fairseq/examples/roberta/wsc/wsc_task.py new file mode 100644 index 0000000000000000000000000000000000000000..602ea737ed75a33fddf44dd859e999ecfce2730d --- /dev/null +++ b/fairseq/examples/roberta/wsc/wsc_task.py @@ -0,0 +1,401 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import json +import os +import tempfile + +import numpy as np +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.data import ( + Dictionary, + IdDataset, + ListDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + PadDataset, + SortDataset, + data_utils, + encoders, +) +from fairseq.tasks import LegacyFairseqTask, register_task + +from . import wsc_utils + + +@register_task("wsc") +class WSCTask(LegacyFairseqTask): + """Task to finetune RoBERTa for Winograd Schemas.""" + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "data", metavar="DIR", help="path to data directory; we load <split>.jsonl" + ) + parser.add_argument( + "--init-token", + type=int, + default=None, + help="add token at the beginning of each batch item", + ) + + def __init__(self, args, vocab): + super().__init__(args) + self.vocab = vocab + self.mask = vocab.add_symbol("<mask>") + + self.bpe = encoders.build_bpe(args) + self.tokenizer = encoders.build_tokenizer(args) + + # hack to handle GPT-2 BPE, which includes leading spaces + if args.bpe == "gpt2": + self.leading_space = True + self.trailing_space = False + else: + self.leading_space = False + self.trailing_space = True + + @classmethod + def load_dictionary(cls, filename): + """Load the dictionary from the filename + + Args: + filename (str): the filename + """ + dictionary = Dictionary.load(filename) + dictionary.add_symbol("<mask>") + return dictionary + + @classmethod + def setup_task(cls, args, **kwargs): + assert args.criterion == "wsc", "Must set --criterion=wsc" + + # load data and label dictionaries + vocab = cls.load_dictionary(os.path.join(args.data, "dict.txt")) + print("| dictionary: {} types".format(len(vocab))) + + return cls(args, vocab) + + def binarize(self, s: str, append_eos: bool = False): + if self.tokenizer is not None: + s = self.tokenizer.encode(s) + if self.bpe is not None: + s = self.bpe.encode(s) + tokens = self.vocab.encode_line( + s, + append_eos=append_eos, + add_if_not_exist=False, + ).long() + if self.args.init_token is not None: + tokens = torch.cat([tokens.new([self.args.init_token]), tokens]) + return tokens + + def binarize_with_mask(self, txt, prefix, suffix, leading_space, trailing_space): + toks = self.binarize( + prefix + leading_space + txt + trailing_space + suffix, + append_eos=True, + ) + mask = torch.zeros_like(toks, dtype=torch.bool) + mask_start = len(self.binarize(prefix)) + mask_size = len(self.binarize(leading_space + txt)) + mask[mask_start : mask_start + mask_size] = 1 + return toks, mask + + def load_dataset( + self, split, epoch=1, combine=False, data_path=None, return_only=False, **kwargs + ): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if data_path is None: + data_path = os.path.join(self.args.data, split + ".jsonl") + if not os.path.exists(data_path): + raise FileNotFoundError("Cannot find data: {}".format(data_path)) + + query_tokens = [] + query_masks = [] + query_lengths = [] + candidate_tokens = [] + candidate_masks = [] + candidate_lengths = [] + labels = [] + + for sentence, pronoun_span, query, label in wsc_utils.jsonl_iterator(data_path): + prefix = sentence[: pronoun_span.start].text + suffix = sentence[pronoun_span.end :].text_with_ws + + # spaCy spans include trailing spaces, but we need to know about + # leading spaces for the GPT-2 BPE + leading_space = ( + " " if sentence[: pronoun_span.start].text_with_ws.endswith(" ") else "" + ) + trailing_space = " " if pronoun_span.text_with_ws.endswith(" ") else "" + + # get noun phrases, excluding pronouns and anything overlapping with the query + cand_spans = wsc_utils.filter_noun_chunks( + wsc_utils.extended_noun_chunks(sentence), + exclude_pronouns=True, + exclude_query=query, + exact_match=False, + ) + + if query is not None: + query_toks, query_mask = self.binarize_with_mask( + query, prefix, suffix, leading_space, trailing_space + ) + query_len = len(query_toks) + else: + query_toks, query_mask, query_len = None, None, 0 + + query_tokens.append(query_toks) + query_masks.append(query_mask) + query_lengths.append(query_len) + + cand_toks, cand_masks = [], [] + for cand_span in cand_spans: + toks, mask = self.binarize_with_mask( + cand_span.text, + prefix, + suffix, + leading_space, + trailing_space, + ) + cand_toks.append(toks) + cand_masks.append(mask) + + # collate candidates + cand_toks = data_utils.collate_tokens(cand_toks, pad_idx=self.vocab.pad()) + cand_masks = data_utils.collate_tokens(cand_masks, pad_idx=0) + assert cand_toks.size() == cand_masks.size() + + candidate_tokens.append(cand_toks) + candidate_masks.append(cand_masks) + candidate_lengths.append(cand_toks.size(1)) + + labels.append(label) + + query_lengths = np.array(query_lengths) + query_tokens = ListDataset(query_tokens, query_lengths) + query_masks = ListDataset(query_masks, query_lengths) + + candidate_lengths = np.array(candidate_lengths) + candidate_tokens = ListDataset(candidate_tokens, candidate_lengths) + candidate_masks = ListDataset(candidate_masks, candidate_lengths) + + labels = ListDataset(labels, [1] * len(labels)) + + dataset = { + "id": IdDataset(), + "query_tokens": query_tokens, + "query_masks": query_masks, + "candidate_tokens": candidate_tokens, + "candidate_masks": candidate_masks, + "labels": labels, + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(query_tokens, reduce=True), + } + + nested_dataset = NestedDictionaryDataset( + dataset, + sizes=[query_lengths], + ) + + with data_utils.numpy_seed(self.args.seed): + shuffle = np.random.permutation(len(query_tokens)) + dataset = SortDataset( + nested_dataset, + # shuffle + sort_order=[shuffle], + ) + + if return_only: + return dataset + + self.datasets[split] = dataset + return self.datasets[split] + + def build_dataset_for_inference(self, sample_json): + with tempfile.NamedTemporaryFile(buffering=0) as h: + h.write((json.dumps(sample_json) + "\n").encode("utf-8")) + dataset = self.load_dataset( + "disambiguate_pronoun", + data_path=h.name, + return_only=True, + ) + return dataset + + def disambiguate_pronoun(self, model, sentence, use_cuda=False): + sample_json = wsc_utils.convert_sentence_to_json(sentence) + dataset = self.build_dataset_for_inference(sample_json) + sample = dataset.collater([dataset[0]]) + if use_cuda: + sample = utils.move_to_cuda(sample) + + def get_masked_input(tokens, mask): + masked_tokens = tokens.clone() + masked_tokens[mask.bool()] = self.mask + return masked_tokens + + def get_lprobs(tokens, mask): + logits, _ = model(src_tokens=get_masked_input(tokens, mask)) + lprobs = F.log_softmax(logits, dim=-1, dtype=torch.float) + scores = lprobs.gather(2, tokens.unsqueeze(-1)).squeeze(-1) + mask = mask.type_as(scores) + scores = (scores * mask).sum(dim=-1) / mask.sum(dim=-1) + return scores + + cand_lprobs = get_lprobs( + sample["candidate_tokens"][0], + sample["candidate_masks"][0], + ) + if sample["query_tokens"][0] is not None: + query_lprobs = get_lprobs( + sample["query_tokens"][0].unsqueeze(0), + sample["query_masks"][0].unsqueeze(0), + ) + return (query_lprobs >= cand_lprobs).all().item() == 1 + else: + best_idx = cand_lprobs.argmax().item() + full_cand = sample["candidate_tokens"][0][best_idx] + mask = sample["candidate_masks"][0][best_idx] + toks = full_cand[mask.bool()] + return self.bpe.decode(self.source_dictionary.string(toks)).strip() + + @property + def source_dictionary(self): + return self.vocab + + @property + def target_dictionary(self): + return self.vocab + + +@register_task("winogrande") +class WinograndeTask(WSCTask): + """ + Task for WinoGrande dataset. Efficient implementation for Winograd schema + tasks with exactly two candidates, one of which is correct. + """ + + @classmethod + def setup_task(cls, args, **kwargs): + assert args.criterion == "winogrande", "Must set --criterion=winogrande" + + # load data and label dictionaries + vocab = cls.load_dictionary(os.path.join(args.data, "dict.txt")) + print("| dictionary: {} types".format(len(vocab))) + + return cls(args, vocab) + + def load_dataset( + self, split, epoch=1, combine=False, data_path=None, return_only=False, **kwargs + ): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if data_path is None: + data_path = os.path.join(self.args.data, split + ".jsonl") + if not os.path.exists(data_path): + raise FileNotFoundError("Cannot find data: {}".format(data_path)) + + query_tokens = [] + query_masks = [] + query_lengths = [] + candidate_tokens = [] + candidate_masks = [] + candidate_lengths = [] + + itr = wsc_utils.winogrande_jsonl_iterator(data_path, eval=(split == "test")) + + for sample in itr: + sentence, pronoun_span, query, cand_text = sample + prefix = sentence[: pronoun_span[0]].rstrip() + suffix = sentence[pronoun_span[1] :] + + leading_space = " " if sentence[: pronoun_span[0]].endswith(" ") else "" + trailing_space = "" + + if query is not None: + query_toks, query_mask = self.binarize_with_mask( + query, + prefix, + suffix, + leading_space, + trailing_space, + ) + query_len = len(query_toks) + else: + query_toks, query_mask, query_len = None, None, 0 + + query_tokens.append(query_toks) + query_masks.append(query_mask) + query_lengths.append(query_len) + + cand_toks, cand_mask = self.binarize_with_mask( + cand_text, + prefix, + suffix, + leading_space, + trailing_space, + ) + + candidate_tokens.append(cand_toks) + candidate_masks.append(cand_mask) + candidate_lengths.append(cand_toks.size(0)) + + query_lengths = np.array(query_lengths) + + def get_pad_dataset_fn(tokens, length, pad_idx): + return PadDataset( + ListDataset(tokens, length), + pad_idx=pad_idx, + left_pad=False, + ) + + query_tokens = get_pad_dataset_fn(query_tokens, query_lengths, self.vocab.pad()) + query_masks = get_pad_dataset_fn(query_masks, query_lengths, 0) + + candidate_lengths = np.array(candidate_lengths) + candidate_tokens = get_pad_dataset_fn( + candidate_tokens, candidate_lengths, self.vocab.pad() + ) + candidate_masks = get_pad_dataset_fn(candidate_masks, candidate_lengths, 0) + + dataset = { + "id": IdDataset(), + "query_tokens": query_tokens, + "query_masks": query_masks, + "candidate_tokens": candidate_tokens, + "candidate_masks": candidate_masks, + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(query_tokens, reduce=True), + } + + nested_dataset = NestedDictionaryDataset( + dataset, + sizes=[query_lengths], + ) + + with data_utils.numpy_seed(self.args.seed): + shuffle = np.random.permutation(len(query_tokens)) + dataset = SortDataset( + nested_dataset, + # shuffle + sort_order=[shuffle], + ) + + if return_only: + return dataset + + self.datasets[split] = dataset + return self.datasets[split] diff --git a/fairseq/examples/roberta/wsc/wsc_utils.py b/fairseq/examples/roberta/wsc/wsc_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..da6ba74383a2490e1108609f315f44ad4b3bf002 --- /dev/null +++ b/fairseq/examples/roberta/wsc/wsc_utils.py @@ -0,0 +1,241 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import json +from functools import lru_cache + + +def convert_sentence_to_json(sentence): + if "_" in sentence: + prefix, rest = sentence.split("_", 1) + query, rest = rest.split("_", 1) + query_index = len(prefix.rstrip().split(" ")) + else: + query, query_index = None, None + + prefix, rest = sentence.split("[", 1) + pronoun, rest = rest.split("]", 1) + pronoun_index = len(prefix.rstrip().split(" ")) + + sentence = sentence.replace("_", "").replace("[", "").replace("]", "") + + return { + "idx": 0, + "text": sentence, + "target": { + "span1_index": query_index, + "span1_text": query, + "span2_index": pronoun_index, + "span2_text": pronoun, + }, + } + + +def extended_noun_chunks(sentence): + noun_chunks = {(np.start, np.end) for np in sentence.noun_chunks} + np_start, cur_np = 0, "NONE" + for i, token in enumerate(sentence): + np_type = token.pos_ if token.pos_ in {"NOUN", "PROPN"} else "NONE" + if np_type != cur_np: + if cur_np != "NONE": + noun_chunks.add((np_start, i)) + if np_type != "NONE": + np_start = i + cur_np = np_type + if cur_np != "NONE": + noun_chunks.add((np_start, len(sentence))) + return [sentence[s:e] for (s, e) in sorted(noun_chunks)] + + +def find_token(sentence, start_pos): + found_tok = None + for tok in sentence: + if tok.idx == start_pos: + found_tok = tok + break + return found_tok + + +def find_span(sentence, search_text, start=0): + search_text = search_text.lower() + for tok in sentence[start:]: + remainder = sentence[tok.i :].text.lower() + if remainder.startswith(search_text): + len_to_consume = len(search_text) + start_idx = tok.idx + for next_tok in sentence[tok.i :]: + end_idx = next_tok.idx + len(next_tok.text) + if end_idx - start_idx == len_to_consume: + span = sentence[tok.i : next_tok.i + 1] + return span + return None + + +@lru_cache(maxsize=1) +def get_detokenizer(): + from sacremoses import MosesDetokenizer + + detok = MosesDetokenizer(lang="en") + return detok + + +@lru_cache(maxsize=1) +def get_spacy_nlp(): + import en_core_web_lg + + nlp = en_core_web_lg.load() + return nlp + + +def jsonl_iterator(input_fname, positive_only=False, ngram_order=3, eval=False): + detok = get_detokenizer() + nlp = get_spacy_nlp() + + with open(input_fname) as fin: + for line in fin: + sample = json.loads(line.strip()) + + if positive_only and "label" in sample and not sample["label"]: + # only consider examples where the query is correct + continue + + target = sample["target"] + + # clean up the query + query = target["span1_text"] + if query is not None: + if "\n" in query: + continue + if query.endswith(".") or query.endswith(","): + query = query[:-1] + + # split tokens + tokens = sample["text"].split(" ") + + def strip_pronoun(x): + return x.rstrip('.,"') + + # find the pronoun + pronoun_idx = target["span2_index"] + pronoun = strip_pronoun(target["span2_text"]) + if strip_pronoun(tokens[pronoun_idx]) != pronoun: + # hack: sometimes the index is misaligned + if strip_pronoun(tokens[pronoun_idx + 1]) == pronoun: + pronoun_idx += 1 + else: + raise Exception("Misaligned pronoun!") + assert strip_pronoun(tokens[pronoun_idx]) == pronoun + + # split tokens before and after the pronoun + before = tokens[:pronoun_idx] + after = tokens[pronoun_idx + 1 :] + + # the GPT BPE attaches leading spaces to tokens, so we keep track + # of whether we need spaces before or after the pronoun + leading_space = " " if pronoun_idx > 0 else "" + trailing_space = " " if len(after) > 0 else "" + + # detokenize + before = detok.detokenize(before, return_str=True) + pronoun = detok.detokenize([pronoun], return_str=True) + after = detok.detokenize(after, return_str=True) + + # hack: when the pronoun ends in a period (or comma), move the + # punctuation to the "after" part + if pronoun.endswith(".") or pronoun.endswith(","): + after = pronoun[-1] + trailing_space + after + pronoun = pronoun[:-1] + + # hack: when the "after" part begins with a comma or period, remove + # the trailing space + if after.startswith(".") or after.startswith(","): + trailing_space = "" + + # parse sentence with spacy + sentence = nlp(before + leading_space + pronoun + trailing_space + after) + + # find pronoun span + start = len(before + leading_space) + first_pronoun_tok = find_token(sentence, start_pos=start) + pronoun_span = find_span(sentence, pronoun, start=first_pronoun_tok.i) + assert pronoun_span.text == pronoun + + if eval: + # convert to format where pronoun is surrounded by "[]" and + # query is surrounded by "_" + query_span = find_span(sentence, query) + query_with_ws = "_{}_{}".format( + query_span.text, + (" " if query_span.text_with_ws.endswith(" ") else ""), + ) + pronoun_with_ws = "[{}]{}".format( + pronoun_span.text, + (" " if pronoun_span.text_with_ws.endswith(" ") else ""), + ) + if query_span.start < pronoun_span.start: + first = (query_span, query_with_ws) + second = (pronoun_span, pronoun_with_ws) + else: + first = (pronoun_span, pronoun_with_ws) + second = (query_span, query_with_ws) + sentence = ( + sentence[: first[0].start].text_with_ws + + first[1] + + sentence[first[0].end : second[0].start].text_with_ws + + second[1] + + sentence[second[0].end :].text + ) + yield sentence, sample.get("label", None) + else: + yield sentence, pronoun_span, query, sample.get("label", None) + + +def winogrande_jsonl_iterator(input_fname, eval=False): + with open(input_fname) as fin: + for line in fin: + sample = json.loads(line.strip()) + sentence, option1, option2 = ( + sample["sentence"], + sample["option1"], + sample["option2"], + ) + + pronoun_span = (sentence.index("_"), sentence.index("_") + 1) + + if eval: + query, cand = option1, option2 + else: + query = option1 if sample["answer"] == "1" else option2 + cand = option2 if sample["answer"] == "1" else option1 + yield sentence, pronoun_span, query, cand + + +def filter_noun_chunks( + chunks, exclude_pronouns=False, exclude_query=None, exact_match=False +): + if exclude_pronouns: + chunks = [ + np + for np in chunks + if (np.lemma_ != "-PRON-" and not all(tok.pos_ == "PRON" for tok in np)) + ] + + if exclude_query is not None: + excl_txt = [exclude_query.lower()] + filtered_chunks = [] + for chunk in chunks: + lower_chunk = chunk.text.lower() + found = False + for excl in excl_txt: + if ( + not exact_match and (lower_chunk in excl or excl in lower_chunk) + ) or lower_chunk == excl: + found = True + break + if not found: + filtered_chunks.append(chunk) + chunks = filtered_chunks + + return chunks diff --git a/fairseq/examples/rxf/README.md b/fairseq/examples/rxf/README.md new file mode 100644 index 0000000000000000000000000000000000000000..22a1cc47df23c7e0ebbf0ad805031478d1b4a95e --- /dev/null +++ b/fairseq/examples/rxf/README.md @@ -0,0 +1,52 @@ +[Better Fine-Tuning by Reducing Representational Collapse](https://arxiv.org/abs/2008.03156) +===================== +This repo contains the code to replicate all experiments from the _Better Fine-Tuning by Reducing Representational Collapse_ paper excluding the probing results. + +The R3F sentence prediction criterion is registered as `sentence_prediction_r3f` while the label smoothing version of it is implemented as `label_smoothed_cross_entropy_r3f`. The R4F version of the sentence prediction criterion can be achieved by applying spectral norm to the classification head via the `--spectral-norm-classification-head` parameter. + +## Hyper-parameters +Our methods introduce 3 new hyper-parameters; `--eps` which sets the standard deviation or range of the distribution we're sampling from, `--r3f-lambda` which controls the combining of logistic loss and noisy KL loss and `--noise-type` which controls which parametric distribution we use ('normal', 'uniform'). + +For example to run R3F on RTE from GLUE + +``` +TOTAL_NUM_UPDATES=3120 +WARMUP_UPDATES=187 +LR=1e-05 +NUM_CLASSES=2 +MAX_SENTENCES=8 # Batch size. +ROBERTA_PATH=/path/to/roberta/model.pt + +CUDA_VISIBLE_DEVICES=0 fairseq-train RTE-bin \ + --restore-file $ROBERTA_PATH \ + --max-positions 512 \ + --max-sentences $MAX_SENTENCES \ + --max-tokens 4400 \ + --task sentence_prediction \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --init-token 0 --separator-token 2 \ + --arch roberta_large \ + --criterion sentence_prediction_r3f \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.1 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-06 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --max-epoch 10 \ + --find-unused-parameters \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric \ + --noise-type uniform --r3f-lambda 0.7 \ + --user-dir examples/rxf/rxf_src +``` + +## Citation +```bibtex +@article{aghajanyan2020better, + title={Better Fine-Tuning by Reducing Representational Collapse}, + author={Aghajanyan, Armen and Shrivastava, Akshat and Gupta, Anchit and Goyal, Naman and Zettlemoyer, Luke and Gupta, Sonal}, + journal={arXiv preprint arXiv:2008.03156}, + year={2020} +} +``` diff --git a/fairseq/examples/rxf/__init__.py b/fairseq/examples/rxf/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b24cb6b797b4159c9862bab1f882ee6ae95614ab --- /dev/null +++ b/fairseq/examples/rxf/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import rxf_src # noqa diff --git a/fairseq/examples/rxf/rxf_src/__init__.py b/fairseq/examples/rxf/rxf_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..306e232d6f386b26153864601114e162080dcee4 --- /dev/null +++ b/fairseq/examples/rxf/rxf_src/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import label_smoothed_cross_entropy_r3f, sentence_prediction_r3f # noqa diff --git a/fairseq/examples/rxf/rxf_src/label_smoothed_cross_entropy_r3f.py b/fairseq/examples/rxf/rxf_src/label_smoothed_cross_entropy_r3f.py new file mode 100644 index 0000000000000000000000000000000000000000..079db13e61c5ef46d1b1d288012145148eb0be04 --- /dev/null +++ b/fairseq/examples/rxf/rxf_src/label_smoothed_cross_entropy_r3f.py @@ -0,0 +1,157 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.criterions.label_smoothed_cross_entropy import label_smoothed_nll_loss + + +@register_criterion("label_smoothed_cross_entropy_r3f") +class LabelSmoothedCrossEntropyR3FCriterion(FairseqCriterion): + def __init__( + self, task, sentence_avg, label_smoothing, eps, r3f_lambda, noise_type + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.label_smoothing = label_smoothing + self.eps = eps + self.r3f_lambda = r3f_lambda + self.noise_type = noise_type + if self.noise_type in {"normal"}: + self.noise_sampler = torch.distributions.normal.Normal( + loc=0.0, scale=self.eps + ) + elif self.noise_type == "uniform": + self.noise_sampler = torch.distributions.uniform.Uniform( + low=-self.eps, high=self.eps + ) + else: + raise Exception(f"unrecognized noise type {self.noise_type}") + + @staticmethod + def add_args(parser): + """Add criterion-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--label-smoothing', default=0., type=float, metavar='D', + help='epsilon for label smoothing, 0 means no label smoothing') + parser.add_argument('--eps', type=float, default=1e-5, + help='noise eps') + parser.add_argument('--r3f-lambda', type=float, default=1.0, + help='lambda for combining logistic loss and noisy KL loss') + parser.add_argument('--noise-type', type=str, default='normal', + choices=['normal', 'uniform'], + help='type of noises') + # fmt: on + + def _get_symm_kl(self, noised_logits, input_logits): + return ( + F.kl_div( + F.log_softmax(noised_logits, dim=-1, dtype=torch.float32), + F.softmax(input_logits, dim=-1, dtype=torch.float32), + None, + None, + "sum", + ) + + F.kl_div( + F.log_softmax(input_logits, dim=-1, dtype=torch.float32), + F.softmax(noised_logits, dim=-1, dtype=torch.float32), + None, + None, + "sum", + ) + ) / noised_logits.size(0) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + token_embeddings = model.encoder.embed_tokens(sample["net_input"]["src_tokens"]) + input_logits, extra = model(**sample["net_input"]) + loss, nll_loss = self.compute_loss( + model, (input_logits, extra), sample, reduce=reduce + ) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + + if model.training: + noise = self.noise_sampler.sample(sample_shape=token_embeddings.shape).to( + token_embeddings + ) + noised_embeddings = token_embeddings.clone() + noise + + noised_logits, _ = model( + **sample["net_input"], token_embeddings=noised_embeddings + ) + symm_kl = self._get_symm_kl(noised_logits, input_logits) + + if model.training: + symm_kl = symm_kl * sample_size + loss = loss + self.r3f_lambda * symm_kl + + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + + if model.training: + logging_output.update( + symm_kl=utils.item(symm_kl.data) if reduce else symm_kl.data + ) + + return loss, sample_size, logging_output + + def compute_loss(self, model, net_output, sample, reduce=True): + lprobs = model.get_normalized_probs(net_output, log_probs=True) + lprobs = lprobs.view(-1, lprobs.size(-1)) + target = model.get_targets(sample, net_output).view(-1, 1) + loss, nll_loss = label_smoothed_nll_loss( + lprobs, + target, + self.label_smoothing, + ignore_index=self.padding_idx, + reduce=reduce, + ) + return loss, nll_loss + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + symm_kl_sum = sum(log.get("symm_kl", 0) for log in logging_outputs) + + metrics.log_scalar("symm_kl", symm_kl_sum / sample_size, sample_size, round=3) + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/examples/rxf/rxf_src/sentence_prediction_r3f.py b/fairseq/examples/rxf/rxf_src/sentence_prediction_r3f.py new file mode 100644 index 0000000000000000000000000000000000000000..6ecffd6b143debb1c67adccd77a6aaed194ec55a --- /dev/null +++ b/fairseq/examples/rxf/rxf_src/sentence_prediction_r3f.py @@ -0,0 +1,171 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +@register_criterion("sentence_prediction_r3f") +class SentencePredictionR3F(FairseqCriterion): + def __init__( + self, + task, + eps, + r3f_lambda, + noise_type, + classification_head_name, + regression_target, + ): + super().__init__(task) + self.eps = eps + self.r3f_lambda = r3f_lambda + self.noise_type = noise_type + self.classification_head_name = classification_head_name + self.regression_target = regression_target + if self.noise_type in {"normal"}: + self.noise_sampler = torch.distributions.normal.Normal( + loc=0.0, scale=self.eps + ) + elif self.noise_type == "uniform": + self.noise_sampler = torch.distributions.uniform.Uniform( + low=-self.eps, high=self.eps + ) + else: + raise Exception(f"unrecognized noise type {self.noise_type}") + + @staticmethod + def add_args(parser): + # fmt: off + parser.add_argument('--eps', type=float, default=1e-5, + help='noise eps') + parser.add_argument('--r3f-lambda', type=float, default=1.0, + help='lambda for combining logistic loss and noisy KL loss') + parser.add_argument('--noise-type', type=str, default='uniform', + choices=['normal', 'uniform'], + help='type of noises for RXF methods') + parser.add_argument('--classification-head-name', + default='sentence_classification_head', + help='name of the classification head to use') + parser.add_argument('--regression-target', action='store_true') + # fmt: on + + def _get_symm_kl(self, noised_logits, input_logits): + return ( + F.kl_div( + F.log_softmax(noised_logits, dim=-1, dtype=torch.float32), + F.softmax(input_logits, dim=-1, dtype=torch.float32), + None, + None, + "sum", + ) + + F.kl_div( + F.log_softmax(input_logits, dim=-1, dtype=torch.float32), + F.softmax(noised_logits, dim=-1, dtype=torch.float32), + None, + None, + "sum", + ) + ) / noised_logits.size(0) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + assert ( + hasattr(model, "classification_heads") + and self.classification_head_name in model.classification_heads + ), "model must provide sentence classification head for --criterion=sentence_prediction" + + token_embeddings = model.encoder.sentence_encoder.embed_tokens( + sample["net_input"]["src_tokens"] + ) + input_logits, _ = model( + **sample["net_input"], + features_only=True, + classification_head_name=self.classification_head_name, + token_embeddings=token_embeddings, + ) + if model.training and self.noise_sampler: + noise = self.noise_sampler.sample(sample_shape=token_embeddings.shape).to( + token_embeddings + ) + noised_embeddings = token_embeddings.detach().clone() + noise + + noised_logits, _ = model( + **sample["net_input"], + features_only=True, + classification_head_name=self.classification_head_name, + token_embeddings=noised_embeddings, + ) + symm_kl = self._get_symm_kl(noised_logits, input_logits) + else: + symm_kl = 0 + + targets = model.get_targets(sample, [input_logits]).view(-1) + sample_size = targets.numel() + + if not self.regression_target: + loss = F.nll_loss( + F.log_softmax(input_logits, dim=-1, dtype=torch.float32), + targets, + reduction="sum", + ) + if model.training: + symm_kl = symm_kl * sample_size + loss = loss + self.r3f_lambda * symm_kl + else: + logits = input_logits.squeeze().float() + targets = targets.float() + loss = F.mse_loss(logits, targets, reduction="sum") + + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample_size, + "sample_size": sample_size, + } + + if not self.regression_target: + preds = input_logits.max(dim=1)[1] + logging_output.update(ncorrect=(preds == targets).sum().item()) + + if model.training and self.noise_sampler: + logging_output.update( + symm_kl=utils.item(symm_kl.data) if reduce else symm_kl.data + ) + return loss, sample_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + symm_kl_sum = sum(log.get("symm_kl", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + agg_output = { + "loss": loss_sum / sample_size / math.log(2), + "symm_kl": symm_kl_sum / sample_size, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + + if len(logging_outputs) > 0 and "ncorrect" in logging_outputs[0]: + ncorrect = sum(log.get("ncorrect", 0) for log in logging_outputs) + agg_output.update(accuracy=ncorrect / nsentences) + + if sample_size != ntokens: + agg_output["nll_loss"] = loss_sum / ntokens / math.log(2) + return agg_output diff --git a/fairseq/examples/scaling_nmt/README.md b/fairseq/examples/scaling_nmt/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0cc3360c3bbd58fe35a51591db8f081fc8576877 --- /dev/null +++ b/fairseq/examples/scaling_nmt/README.md @@ -0,0 +1,114 @@ +# Scaling Neural Machine Translation (Ott et al., 2018) + +This page includes instructions for reproducing results from the paper [Scaling Neural Machine Translation (Ott et al., 2018)](https://arxiv.org/abs/1806.00187). + +## Pre-trained models + +Model | Description | Dataset | Download +---|---|---|--- +`transformer.wmt14.en-fr` | Transformer <br> ([Ott et al., 2018](https://arxiv.org/abs/1806.00187)) | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-fr.joined-dict.transformer.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-fr.joined-dict.newstest2014.tar.bz2) +`transformer.wmt16.en-de` | Transformer <br> ([Ott et al., 2018](https://arxiv.org/abs/1806.00187)) | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt16.en-de.joined-dict.transformer.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) + +## Training a new model on WMT'16 En-De + +First download the [preprocessed WMT'16 En-De data provided by Google](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8). + +Then: + +##### 1. Extract the WMT'16 En-De data +```bash +TEXT=wmt16_en_de_bpe32k +mkdir -p $TEXT +tar -xzvf wmt16_en_de.tar.gz -C $TEXT +``` + +##### 2. Preprocess the dataset with a joined dictionary +```bash +fairseq-preprocess \ + --source-lang en --target-lang de \ + --trainpref $TEXT/train.tok.clean.bpe.32000 \ + --validpref $TEXT/newstest2013.tok.bpe.32000 \ + --testpref $TEXT/newstest2014.tok.bpe.32000 \ + --destdir data-bin/wmt16_en_de_bpe32k \ + --nwordssrc 32768 --nwordstgt 32768 \ + --joined-dictionary \ + --workers 20 +``` + +##### 3. Train a model +```bash +fairseq-train \ + data-bin/wmt16_en_de_bpe32k \ + --arch transformer_vaswani_wmt_en_de_big --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr 0.0005 --lr-scheduler inverse_sqrt --warmup-updates 4000 --warmup-init-lr 1e-07 \ + --dropout 0.3 --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --max-tokens 3584 \ + --fp16 +``` + +Note that the `--fp16` flag requires you have CUDA 9.1 or greater and a Volta GPU or newer. + +***IMPORTANT:*** You will get better performance by training with big batches and +increasing the learning rate. If you want to train the above model with big batches +(assuming your machine has 8 GPUs): +- add `--update-freq 16` to simulate training on 8x16=128 GPUs +- increase the learning rate; 0.001 works well for big batches + +##### 4. Evaluate + +Now we can evaluate our trained model. + +Note that the original [Attention Is All You Need](https://arxiv.org/abs/1706.03762) +paper used a couple tricks to achieve better BLEU scores. We use these same tricks in +the Scaling NMT paper, so it's important to apply them when reproducing our results. + +First, use the [average_checkpoints.py](/scripts/average_checkpoints.py) script to +average the last few checkpoints. Averaging the last 5-10 checkpoints is usually +good, but you may need to adjust this depending on how long you've trained: +```bash +python scripts/average_checkpoints \ + --inputs /path/to/checkpoints \ + --num-epoch-checkpoints 10 \ + --output checkpoint.avg10.pt +``` + +Next, generate translations using a beam width of 4 and length penalty of 0.6: +```bash +fairseq-generate \ + data-bin/wmt16_en_de_bpe32k \ + --path checkpoint.avg10.pt \ + --beam 4 --lenpen 0.6 --remove-bpe > gen.out +``` + +Finally, we apply the ["compound splitting" script](/scripts/compound_split_bleu.sh) to +add spaces around dashes. For example "Café-Liebhaber" would become three tokens: +"Café - Liebhaber". This typically results in larger BLEU scores, but it is not +appropriate to compare these inflated scores to work which does not include this trick. +This trick was used in the [original AIAYN code](https://github.com/tensorflow/tensor2tensor/blob/fc9335c0203685cbbfe2b30c92db4352d8f60779/tensor2tensor/utils/get_ende_bleu.sh), +so we used it in the Scaling NMT paper as well. That said, it's strongly advised to +report [sacrebleu](https://github.com/mjpost/sacrebleu) scores instead. + +To compute "compound split" tokenized BLEU (not recommended!): +```bash +bash scripts/compound_split_bleu.sh gen.out +# BLEU4 = 29.29, 60.3/35.0/22.8/15.3 (BP=1.000, ratio=1.004, syslen=64763, reflen=64496) +``` + +To compute detokenized BLEU with sacrebleu (preferred): +```bash +bash scripts/sacrebleu.sh wmt14/full en de gen.out +# BLEU+case.mixed+lang.en-de+numrefs.1+smooth.exp+test.wmt14/full+tok.13a+version.1.4.3 = 28.6 59.3/34.3/22.1/14.9 (BP = 1.000 ratio = 1.016 hyp_len = 63666 ref_len = 62688) +``` + +## Citation + +```bibtex +@inproceedings{ott2018scaling, + title = {Scaling Neural Machine Translation}, + author = {Ott, Myle and Edunov, Sergey and Grangier, David and Auli, Michael}, + booktitle = {Proceedings of the Third Conference on Machine Translation (WMT)}, + year = 2018, +} +``` diff --git a/fairseq/examples/shuffled_word_order/README.finetuning.md b/fairseq/examples/shuffled_word_order/README.finetuning.md new file mode 100644 index 0000000000000000000000000000000000000000..ecbcb65884640c3327a2cbaef8aad4f3cfe812f7 --- /dev/null +++ b/fairseq/examples/shuffled_word_order/README.finetuning.md @@ -0,0 +1,135 @@ +# Fine-tuning details + +For each task (GLUE and PAWS), we perform hyperparam search for each model, and report the mean and standard deviation across 5 seeds of the best model. First, get the datasets following the instructions in [RoBERTa fine-tuning README](../roberta/README.glue.md). Alternatively, you can use [huggingface datasets](https://huggingface.co/docs/datasets/) to get the task data: + +```python +from datasets import load_dataset +import pandas as pd +from pathlib import Path + +key2file = { +"paws": { + "loc": "paws_data", + "columns": ["id", "sentence1", "sentence2", "label"], + "train": "train.tsv", + "validation": "dev.tsv", + "test": "test.tsv" + } +} + +task_data = load_dataset("paws", "labeled_final") +task_config = key2file["paws"] +save_path = Path(task_config["loc"]) +save_path.mkdir(exist_ok=True, parents=True) +for key, fl in task_config.items(): + if key in ["loc", "columns"]: + continue + print(f"Reading {key}") + columns = task_config["columns"] + df = pd.DataFrame(task_data[key]) + print(df.columns) + df = df[columns] + print(f"Got {len(df)} records") + save_loc = save_path / fl + print(f"Saving to : {save_loc}") + df.to_csv(save_loc, sep="\t", header=None, index=None) + +``` + +- Preprocess using RoBERTa GLUE preprocessing script, while keeping in mind the column numbers for `sentence1`, `sentence2` and `label` (which is 0,1,2 if you save the data according to the above example.) +- Then, fine-tuning is performed similarly to RoBERTa (for example, in case of RTE): + +```bash +TOTAL_NUM_UPDATES=30875 # 10 epochs through RTE for bsz 16 +WARMUP_UPDATES=1852 # 6 percent of the number of updates +LR=2e-05 # Peak LR for polynomial LR scheduler. +NUM_CLASSES=2 +MAX_SENTENCES=16 # Batch size. +SHUFFLED_ROBERTA_PATH=/path/to/shuffled_roberta/model.pt + +CUDA_VISIBLE_DEVICES=0 fairseq-train RTE-bin/ \ + --restore-file $SHUFFLED_ROBERTA_PATH \ + --max-positions 512 \ + --batch-size $MAX_SENTENCES \ + --max-tokens 4400 \ + --task sentence_prediction \ + --reset-optimizer --reset-dataloader --reset-meters \ + --required-batch-size-multiple 1 \ + --init-token 0 --separator-token 2 \ + --arch roberta_large \ + --criterion sentence_prediction \ + --num-classes $NUM_CLASSES \ + --dropout 0.1 --attention-dropout 0.1 \ + --weight-decay 0.1 --optimizer adam --adam-betas "(0.9, 0.98)" --adam-eps 1e-06 \ + --clip-norm 0.0 \ + --lr-scheduler polynomial_decay --lr $LR --total-num-update $TOTAL_NUM_UPDATES --warmup-updates $WARMUP_UPDATES \ + --fp16 --fp16-init-scale 4 --threshold-loss-scale 1 --fp16-scale-window 128 \ + --max-epoch 10 \ + --find-unused-parameters \ + --best-checkpoint-metric accuracy --maximize-best-checkpoint-metric; +``` + +- `TOTAL_NUM_UPDATES` is computed based on the `--batch_size` value and the dataset size. +- `WARMUP_UPDATES` is computed as 6% of `TOTAL_NUM_UPDATES` +- Best hyperparam of `--lr` and `--batch_size` is reported below: + +## `--lr` + +| | name | RTE | MRPC | SST-2 | CoLA | QQP | QNLI | MNLI | PAWS | +| --: | :----------- | ----: | ----: | ----: | ----: | ----: | ----: | ----: | ----: | +| 0 | original | 2e-05 | 2e-05 | 1e-05 | 2e-05 | 1e-05 | 1e-05 | 1e-05 | 2e-05 | +| 1 | n_1 | 2e-05 | 1e-05 | 1e-05 | 1e-05 | 3e-05 | 1e-05 | 2e-05 | 2e-05 | +| 2 | n_2 | 2e-05 | 2e-05 | 1e-05 | 1e-05 | 2e-05 | 1e-05 | 1e-05 | 3e-05 | +| 3 | n_3 | 3e-05 | 1e-05 | 2e-05 | 2e-05 | 3e-05 | 1e-05 | 1e-05 | 2e-05 | +| 4 | n_4 | 3e-05 | 1e-05 | 2e-05 | 2e-05 | 2e-05 | 1e-05 | 1e-05 | 2e-05 | +| 5 | r512 | 1e-05 | 3e-05 | 2e-05 | 2e-05 | 3e-05 | 2e-05 | 3e-05 | 2e-05 | +| 6 | rand_corpus | 2e-05 | 1e-05 | 3e-05 | 1e-05 | 3e-05 | 3e-05 | 3e-05 | 2e-05 | +| 7 | rand_uniform | 2e-05 | 1e-05 | 3e-05 | 2e-05 | 3e-05 | 3e-05 | 3e-05 | 1e-05 | +| 8 | rand_init | 1e-05 | 1e-05 | 3e-05 | 1e-05 | 1e-05 | 1e-05 | 2e-05 | 1e-05 | +| 9 | no_pos | 1e-05 | 3e-05 | 2e-05 | 1e-05 | 1e-05 | 1e-05 | 1e-05 | 1e-05 | + +## `--batch_size` + +| | name | RTE | MRPC | SST-2 | CoLA | QQP | QNLI | MNLI | PAWS | +| --: | :----------- | --: | ---: | ----: | ---: | --: | ---: | ---: | ---: | +| 0 | orig | 16 | 16 | 32 | 16 | 16 | 32 | 32 | 16 | +| 1 | n_1 | 32 | 32 | 16 | 32 | 32 | 16 | 32 | 16 | +| 2 | n_2 | 32 | 16 | 32 | 16 | 32 | 32 | 16 | 32 | +| 3 | n_3 | 32 | 32 | 16 | 32 | 32 | 16 | 32 | 32 | +| 4 | n_4 | 32 | 16 | 32 | 16 | 32 | 32 | 32 | 32 | +| 5 | r512 | 32 | 16 | 16 | 32 | 32 | 16 | 16 | 16 | +| 6 | rand_corpus | 16 | 16 | 16 | 16 | 32 | 16 | 16 | 32 | +| 7 | rand_uniform | 16 | 32 | 16 | 16 | 32 | 16 | 16 | 16 | +| 8 | rand_init | 16 | 16 | 32 | 16 | 16 | 16 | 32 | 16 | +| 9 | no_pos | 16 | 32 | 16 | 16 | 32 | 16 | 16 | 16 | + +- Perform inference similar to RoBERTa as well: + +```python +from fairseq.models.roberta import RobertaModel + +roberta = RobertaModel.from_pretrained( + 'checkpoints/', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='PAWS-bin' +) + +label_fn = lambda label: roberta.task.label_dictionary.string( + [label + roberta.task.label_dictionary.nspecial] +) +ncorrect, nsamples = 0, 0 +roberta.cuda() +roberta.eval() +with open('paws_data/dev.tsv') as fin: + fin.readline() + for index, line in enumerate(fin): + tokens = line.strip().split('\t') + sent1, sent2, target = tokens[0], tokens[1], tokens[2] + tokens = roberta.encode(sent1, sent2) + prediction = roberta.predict('sentence_classification_head', tokens).argmax().item() + prediction_label = label_fn(prediction) + ncorrect += int(prediction_label == target) + nsamples += 1 +print('| Accuracy: ', float(ncorrect)/float(nsamples)) + +``` diff --git a/fairseq/examples/shuffled_word_order/README.md b/fairseq/examples/shuffled_word_order/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f20483849a8ca33bf349b57882a79155ba593bf1 --- /dev/null +++ b/fairseq/examples/shuffled_word_order/README.md @@ -0,0 +1,84 @@ +# Masked Language Modeling and the Distributional Hypothesis: Order Word Matters Pre-training for Little + +[https://arxiv.org/abs/2104.06644](https://arxiv.org/abs/2104.06644) + +## Introduction + +In this work, we pre-train [RoBERTa](../roberta) base on various word shuffled variants of BookWiki corpus (16GB). We observe that a word shuffled pre-trained model achieves surprisingly good scores on GLUE, PAWS and several parametric probing tasks. Please read our paper for more details on the experiments. + +## Pre-trained models + +| Model | Description | Download | +| ------------------------------------- | -------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | +| `roberta.base.orig` | RoBERTa (base) trained on natural corpus | [roberta.base.orig.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.orig.tar.gz) | +| `roberta.base.shuffle.n1` | RoBERTa (base) trained on n=1 gram sentence word shuffled data | [roberta.base.shuffle.n1.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n1.tar.gz) | +| `roberta.base.shuffle.n2` | RoBERTa (base) trained on n=2 gram sentence word shuffled data | [roberta.base.shuffle.n2.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n2.tar.gz) | +| `roberta.base.shuffle.n3` | RoBERTa (base) trained on n=3 gram sentence word shuffled data | [roberta.base.shuffle.n3.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n3.tar.gz) | +| `roberta.base.shuffle.n4` | RoBERTa (base) trained on n=4 gram sentence word shuffled data | [roberta.base.shuffle.n4.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n4.tar.gz) | +| `roberta.base.shuffle.512` | RoBERTa (base) trained on unigram 512 word block shuffled data | [roberta.base.shuffle.512.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.512.tar.gz) | +| `roberta.base.shuffle.corpus` | RoBERTa (base) trained on unigram corpus word shuffled data | [roberta.base.shuffle.corpus.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.corpus.tar.gz) | +| `roberta.base.shuffle.corpus_uniform` | RoBERTa (base) trained on unigram corpus word shuffled data, where all words are uniformly sampled | [roberta.base.shuffle.corpus_uniform.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.corpus_uniform.tar.gz) | +| `roberta.base.nopos` | RoBERTa (base) without positional embeddings, trained on natural corpus | [roberta.base.nopos.tar.gz](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.nopos.tar.gz) | + +## Results + +[GLUE (Wang et al, 2019)](https://gluebenchmark.com/) & [PAWS (Zhang et al, 2019)](https://github.com/google-research-datasets/paws) _(dev set, single model, single-task fine-tuning, median of 5 seeds)_ + +| name | CoLA | MNLI | MRPC | PAWS | QNLI | QQP | RTE | SST-2 | +| :----------------------------------- | ----: | ----: | ----: | ----: | ----: | ----: | ----: | ----: | +| `roberta.base.orig` | 61.4 | 86.11 | 89.19 | 94.46 | 92.53 | 91.26 | 74.64 | 93.92 | +| `roberta.base.shuffle.n1` | 35.15 | 82.64 | 86 | 89.97 | 89.02 | 91.01 | 69.02 | 90.47 | +| `roberta.base.shuffle.n2` | 54.37 | 83.43 | 86.24 | 93.46 | 90.44 | 91.36 | 70.83 | 91.79 | +| `roberta.base.shuffle.n3` | 48.72 | 83.85 | 86.36 | 94.05 | 91.69 | 91.24 | 70.65 | 92.02 | +| `roberta.base.shuffle.n4` | 58.64 | 83.77 | 86.98 | 94.32 | 91.69 | 91.4 | 70.83 | 92.48 | +| `roberta.base.shuffle.512` | 12.76 | 77.52 | 79.61 | 84.77 | 85.19 | 90.2 | 56.52 | 86.34 | +| `roberta.base.shuffle.corpus` | 0 | 71.9 | 70.52 | 58.52 | 71.11 | 85.52 | 53.99 | 83.35 | +| `roberta.base.shuffle.corpus_random` | 9.19 | 72.33 | 70.76 | 58.42 | 77.76 | 85.93 | 53.99 | 84.04 | +| `roberta.base.nopos` | 0 | 63.5 | 72.73 | 57.08 | 77.72 | 87.87 | 54.35 | 83.24 | + +For more results on probing tasks, please refer to [our paper](https://arxiv.org/abs/2104.06644). + +## Example Usage + +Follow the same usage as in [RoBERTa](https://github.com/pytorch/fairseq/tree/main/examples/roberta) to load and test your models: + +```python +# Download roberta.base.shuffle.n1 model +wget https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n1.tar.gz +tar -xzvf roberta.base.shuffle.n1.tar.gz + +# Load the model in fairseq +from fairseq.models.roberta import RoBERTaModel +roberta = RoBERTaModel.from_pretrained('/path/to/roberta.base.shuffle.n1', checkpoint_file='model.pt') +roberta.eval() # disable dropout (or leave in train mode to finetune) +``` + +**Note**: The model trained without positional embeddings (`roberta.base.nopos`) is a modified `RoBERTa` model, where the positional embeddings are not used. Thus, the typical `from_pretrained` method on fairseq version of RoBERTa will not be able to load the above model weights. To do so, construct a new `RoBERTaModel` object by setting the flag `use_positional_embeddings` to `False` (or [in the latest code](https://github.com/pytorch/fairseq/blob/main/fairseq/models/roberta/model.py#L543), set `no_token_positional_embeddings` to `True`), and then load the individual weights. + +## Fine-tuning Evaluation + +We provide the trained fine-tuned models on MNLI here for each model above for quick evaluation (1 seed for each model). Please refer to [finetuning details](README.finetuning.md) for the parameters of these models. Follow [RoBERTa](https://github.com/pytorch/fairseq/tree/main/examples/roberta) instructions to evaluate these models. + +| Model | MNLI M Dev Accuracy | Link | +| :----------------------------------------- | :------------------ | :--------------------------------------------------------------------------------------------------------------- | +| `roberta.base.orig.mnli` | 86.14 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.orig.mnli.tar.gz) | +| `roberta.base.shuffle.n1.mnli` | 82.55 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n1.mnli.tar.gz) | +| `roberta.base.shuffle.n2.mnli` | 83.21 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n2.mnli.tar.gz) | +| `roberta.base.shuffle.n3.mnli` | 83.89 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n3.mnli.tar.gz) | +| `roberta.base.shuffle.n4.mnli` | 84.00 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.n4.mnli.tar.gz) | +| `roberta.base.shuffle.512.mnli` | 77.22 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.512.mnli.tar.gz) | +| `roberta.base.shuffle.corpus.mnli` | 71.88 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.corpus.mnli.tar.gz) | +| `roberta.base.shuffle.corpus_uniform.mnli` | 72.46 | [Download](https://dl.fbaipublicfiles.com/unnatural_pretraining/roberta.base.shuffle.corpus_uniform.mnli.tar.gz) | + +## Citation + +```bibtex +@misc{sinha2021masked, + title={Masked Language Modeling and the Distributional Hypothesis: Order Word Matters Pre-training for Little}, + author={Koustuv Sinha and Robin Jia and Dieuwke Hupkes and Joelle Pineau and Adina Williams and Douwe Kiela}, + year={2021}, + eprint={2104.06644}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} +``` diff --git a/fairseq/examples/simultaneous_translation/README.md b/fairseq/examples/simultaneous_translation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..62a005e0ec6f15af9015d335e34b45df6ed89b6c --- /dev/null +++ b/fairseq/examples/simultaneous_translation/README.md @@ -0,0 +1,5 @@ +# Simultaneous Translation +Examples of simultaneous translation in fairseq +- [English-to-Japanese text-to-text wait-k model](docs/enja-waitk.md) +- [English-to-Germen text-to-text monotonic multihead attention model](docs/ende-mma.md) +- [English-to-Germen speech-to-text simultaneous translation model](../speech_to_text/docs/simulst_mustc_example.md) diff --git a/fairseq/examples/simultaneous_translation/__init__.py b/fairseq/examples/simultaneous_translation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5835316ba9b23c0d99d1a8f109ee047682211546 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import models # noqa diff --git a/fairseq/examples/simultaneous_translation/docs/ende-mma.md b/fairseq/examples/simultaneous_translation/docs/ende-mma.md new file mode 100644 index 0000000000000000000000000000000000000000..241d604a3b31a37755da68aad6ff47d46891d3fc --- /dev/null +++ b/fairseq/examples/simultaneous_translation/docs/ende-mma.md @@ -0,0 +1,74 @@ +# Simultaneous Machine Translation + +This directory contains the code for the paper [Monotonic Multihead Attention](https://openreview.net/forum?id=Hyg96gBKPS) + +## Prepare Data + +[Please follow the instructions to download and preprocess the WMT'15 En-De dataset.](https://github.com/pytorch/fairseq/tree/simulastsharedtask/examples/translation#prepare-wmt14en2desh) + +Another example of training an English to Japanese model can be found [here](docs/enja.md) + +## Training + +- MMA-IL + +```shell +fairseq-train \ + data-bin/wmt15_en_de_32k \ + --simul-type infinite_lookback \ + --user-dir $FAIRSEQ/example/simultaneous_translation \ + --mass-preservation \ + --criterion latency_augmented_label_smoothed_cross_entropy \ + --latency-weight-avg 0.1 \ + --max-update 50000 \ + --arch transformer_monotonic_iwslt_de_en save_dir_key=lambda \ + --optimizer adam --adam-betas '(0.9, 0.98)' \ + --lr-scheduler 'inverse_sqrt' \ + --warmup-init-lr 1e-7 --warmup-updates 4000 \ + --lr 5e-4 --stop-min-lr 1e-9 --clip-norm 0.0 --weight-decay 0.0001\ + --dropout 0.3 \ + --label-smoothing 0.1\ + --max-tokens 3584 +``` + +- MMA-H + +```shell +fairseq-train \ + data-bin/wmt15_en_de_32k \ + --simul-type hard_aligned \ + --user-dir $FAIRSEQ/example/simultaneous_translation \ + --mass-preservation \ + --criterion latency_augmented_label_smoothed_cross_entropy \ + --latency-weight-var 0.1 \ + --max-update 50000 \ + --arch transformer_monotonic_iwslt_de_en save_dir_key=lambda \ + --optimizer adam --adam-betas '(0.9, 0.98)' \ + --lr-scheduler 'inverse_sqrt' \ + --warmup-init-lr 1e-7 --warmup-updates 4000 \ + --lr 5e-4 --stop-min-lr 1e-9 --clip-norm 0.0 --weight-decay 0.0001\ + --dropout 0.3 \ + --label-smoothing 0.1\ + --max-tokens 3584 +``` + +- wait-k + +```shell +fairseq-train \ + data-bin/wmt15_en_de_32k \ + --simul-type wait-k \ + --waitk-lagging 3 \ + --user-dir $FAIRSEQ/example/simultaneous_translation \ + --mass-preservation \ + --criterion latency_augmented_label_smoothed_cross_entropy \ + --max-update 50000 \ + --arch transformer_monotonic_iwslt_de_en save_dir_key=lambda \ + --optimizer adam --adam-betas '(0.9, 0.98)' \ + --lr-scheduler 'inverse_sqrt' \ + --warmup-init-lr 1e-7 --warmup-updates 4000 \ + --lr 5e-4 --stop-min-lr 1e-9 --clip-norm 0.0 --weight-decay 0.0001\ + --dropout 0.3 \ + --label-smoothing 0.1\ + --max-tokens 3584 +``` diff --git a/fairseq/examples/simultaneous_translation/docs/enja-waitk.md b/fairseq/examples/simultaneous_translation/docs/enja-waitk.md new file mode 100644 index 0000000000000000000000000000000000000000..fb9d82576f80b4405564a99774fc98ac2fe6ad3b --- /dev/null +++ b/fairseq/examples/simultaneous_translation/docs/enja-waitk.md @@ -0,0 +1,106 @@ +# An example of English to Japaneses Simultaneous Translation System + +This is an example of training and evaluating a transformer *wait-k* English to Japanese simultaneous text-to-text translation model. + +## Data Preparation +This section introduces the data preparation for training and evaluation. +If you only want to evaluate the model, please jump to [Inference & Evaluation](#inference-&-evaluation) + +For illustration, we only use the following subsets of the available data from [WMT20 news translation task](http://www.statmt.org/wmt20/translation-task.html), which results in 7,815,391 sentence pairs. +- News Commentary v16 +- Wiki Titles v3 +- WikiMatrix V1 +- Japanese-English Subtitle Corpus +- The Kyoto Free Translation Task Corpus + +We use WMT20 development data as development set. Training `transformer_vaswani_wmt_en_de_big` model on such amount of data will result in 17.3 BLEU with greedy search and 19.7 with beam (10) search. Notice that a better performance can be achieved with the full WMT training data. + +We use [sentencepiece](https://github.com/google/sentencepiece) toolkit to tokenize the data with a vocabulary size of 32000. +Additionally, we filtered out the sentences longer than 200 words after tokenization. +Assuming the tokenized text data is saved at `${DATA_DIR}`, +we prepare the data binary with the following command. + +```bash +fairseq-preprocess \ + --source-lang en --target-lang ja \ + --trainpref ${DATA_DIR}/train \ + --validpref ${DATA_DIR}/dev \ + --testpref ${DATA_DIR}/test \ + --destdir ${WMT20_ENJA_DATA_BIN} \ + --nwordstgt 32000 --nwordssrc 32000 \ + --workers 20 +``` + +## Simultaneous Translation Model Training +To train a wait-k `(k=10)` model. +```bash +fairseq-train ${WMT20_ENJA_DATA_BIN} \ + --save-dir ${SAVEDIR} + --simul-type waitk \ + --waitk-lagging 10 \ + --max-epoch 70 \ + --arch transformer_monotonic_vaswani_wmt_en_de_big \ + --optimizer adam \ + --adam-betas '(0.9, 0.98)' \ + --lr-scheduler inverse_sqrt \ + --warmup-init-lr 1e-07 \ + --warmup-updates 4000 \ + --lr 0.0005 \ + --stop-min-lr 1e-09 \ + --clip-norm 10.0 \ + --dropout 0.3 \ + --weight-decay 0.0 \ + --criterion label_smoothed_cross_entropy \ + --label-smoothing 0.1 \ + --max-tokens 3584 +``` +This command is for training on 8 GPUs. Equivalently, the model can be trained on one GPU with `--update-freq 8`. + +## Inference & Evaluation +First of all, install [SimulEval](https://github.com/facebookresearch/SimulEval) for evaluation. + +```bash +git clone https://github.com/facebookresearch/SimulEval.git +cd SimulEval +pip install -e . +``` + +The following command is for the evaluation. +Assuming the source and reference files are `${SRC_FILE}` and `${REF_FILE}`, the sentencepiece model file for English is saved at `${SRC_SPM_PATH}` + + +```bash +simuleval \ + --source ${SRC_FILE} \ + --target ${TGT_FILE} \ + --data-bin ${WMT20_ENJA_DATA_BIN} \ + --sacrebleu-tokenizer ja-mecab \ + --eval-latency-unit char \ + --no-space \ + --src-splitter-type sentencepiecemodel \ + --src-splitter-path ${SRC_SPM_PATH} \ + --agent ${FAIRSEQ}/examples/simultaneous_translation/agents/simul_trans_text_agent_enja.py \ + --model-path ${SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --output ${OUTPUT} \ + --scores +``` + +The `--data-bin` should be the same in previous sections if you prepare the data from the scratch. +If only for evaluation, a prepared data directory can be found [here](https://dl.fbaipublicfiles.com/simultaneous_translation/wmt20_enja_medium_databin.tgz) and a pretrained checkpoint (wait-k=10 model) can be downloaded from [here](https://dl.fbaipublicfiles.com/simultaneous_translation/wmt20_enja_medium_wait10_ckpt.pt). + +The output should look like this: +```bash +{ + "Quality": { + "BLEU": 11.442253287568398 + }, + "Latency": { + "AL": 8.6587861866951, + "AP": 0.7863304776251316, + "DAL": 9.477850951194764 + } +} +``` +The latency is evaluated by characters (`--eval-latency-unit`) on the target side. The latency is evaluated with `sacrebleu` with `MeCab` tokenizer `--sacrebleu-tokenizer ja-mecab`. `--no-space` indicates that do not add space when merging the predicted words. + +If `--output ${OUTPUT}` option is used, the detailed log and scores will be stored under the `${OUTPUT}` directory. diff --git a/fairseq/examples/simultaneous_translation/eval/agents/simul_t2t_enja.py b/fairseq/examples/simultaneous_translation/eval/agents/simul_t2t_enja.py new file mode 100644 index 0000000000000000000000000000000000000000..8f3c8703ca37398b9d389ce5181bdfac2333cdf2 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/eval/agents/simul_t2t_enja.py @@ -0,0 +1,226 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os + +from fairseq import checkpoint_utils, tasks +import sentencepiece as spm +import torch + +try: + from simuleval import READ_ACTION, WRITE_ACTION, DEFAULT_EOS + from simuleval.agents import TextAgent +except ImportError: + print("Please install simuleval 'pip install simuleval'") + + +BOS_PREFIX = "\u2581" + + +class SimulTransTextAgentJA(TextAgent): + """ + Simultaneous Translation + Text agent for Japanese + """ + def __init__(self, args): + + # Whether use gpu + self.gpu = getattr(args, "gpu", False) + + # Max len + self.max_len = args.max_len + + # Load Model + self.load_model_vocab(args) + + # build word splitter + self.build_word_splitter(args) + + self.eos = DEFAULT_EOS + + def initialize_states(self, states): + states.incremental_states = dict() + states.incremental_states["online"] = dict() + + def to_device(self, tensor): + if self.gpu: + return tensor.cuda() + else: + return tensor.cpu() + + def load_model_vocab(self, args): + + filename = args.model_path + if not os.path.exists(filename): + raise IOError("Model file not found: {}".format(filename)) + + state = checkpoint_utils.load_checkpoint_to_cpu(filename) + + task_args = state["cfg"]["task"] + task_args.data = args.data_bin + + task = tasks.setup_task(task_args) + + # build model for ensemble + state["cfg"]["model"].load_pretrained_encoder_from = None + state["cfg"]["model"].load_pretrained_decoder_from = None + + self.model = task.build_model(state["cfg"]["model"]) + self.model.load_state_dict(state["model"], strict=True) + self.model.eval() + self.model.share_memory() + + if self.gpu: + self.model.cuda() + + # Set dictionary + self.dict = {} + self.dict["tgt"] = task.target_dictionary + self.dict["src"] = task.source_dictionary + + @staticmethod + def add_args(parser): + # fmt: off + parser.add_argument('--model-path', type=str, required=True, + help='path to your pretrained model.') + parser.add_argument("--data-bin", type=str, required=True, + help="Path of data binary") + parser.add_argument("--max-len", type=int, default=100, + help="Max length of translation") + parser.add_argument("--tgt-splitter-type", type=str, default="SentencePiece", + help="Subword splitter type for target text.") + parser.add_argument("--tgt-splitter-path", type=str, default=None, + help="Subword splitter model path for target text.") + parser.add_argument("--src-splitter-type", type=str, default="SentencePiece", + help="Subword splitter type for source text.") + parser.add_argument("--src-splitter-path", type=str, default=None, + help="Subword splitter model path for source text.") + # fmt: on + return parser + + def build_word_splitter(self, args): + self.spm = {} + for lang in ['src', 'tgt']: + if getattr(args, f'{lang}_splitter_type', None): + path = getattr(args, f'{lang}_splitter_path', None) + if path: + self.spm[lang] = spm.SentencePieceProcessor() + self.spm[lang].Load(path) + + def segment_to_units(self, segment, states): + # Split a full word (segment) into subwords (units) + return self.spm['src'].EncodeAsPieces(segment) + + def update_model_encoder(self, states): + if len(states.units.source) == 0: + return + + src_indices = [ + self.dict['src'].index(x) + for x in states.units.source.value + ] + + if states.finish_read(): + # Append the eos index when the prediction is over + src_indices += [self.dict["tgt"].eos_index] + + src_indices = self.to_device( + torch.LongTensor(src_indices).unsqueeze(0) + ) + src_lengths = self.to_device( + torch.LongTensor([src_indices.size(1)]) + ) + + states.encoder_states = self.model.encoder(src_indices, src_lengths) + + torch.cuda.empty_cache() + + def update_states_read(self, states): + # Happens after a read action. + self.update_model_encoder(states) + + def units_to_segment(self, units, states): + # Merge sub words (units) to full word (segment). + # For Japanese, we can directly send + # the untokenized token to server except the BOS token + # with following option + # --sacrebleu-tokenizer MeCab + # --eval-latency-unit char + # --no-space + token = units.value.pop() + + if ( + token == self.dict["tgt"].eos_word + or len(states.segments.target) > self.max_len + ): + return DEFAULT_EOS + + if BOS_PREFIX == token: + return None + if token[0] == BOS_PREFIX: + return token[1:] + else: + return token + + def policy(self, states): + + if not getattr(states, "encoder_states", None): + # No encoder states, read a token first + return READ_ACTION + + # encode previous predicted target tokens + tgt_indices = self.to_device( + torch.LongTensor( + [self.model.decoder.dictionary.eos()] + + [ + self.dict['tgt'].index(x) + for x in states.units.target.value + if x is not None + ] + ).unsqueeze(0) + ) + + # Current steps + states.incremental_states["steps"] = { + "src": states.encoder_states["encoder_out"][0].size(0), + "tgt": 1 + len(states.units.target), + } + + # Online only means the reading is not finished + states.incremental_states["online"]["only"] = ( + torch.BoolTensor([not states.finish_read()]) + ) + + x, outputs = self.model.decoder.forward( + prev_output_tokens=tgt_indices, + encoder_out=states.encoder_states, + incremental_state=states.incremental_states, + ) + + states.decoder_out = x + + torch.cuda.empty_cache() + + if outputs.action == 0: + return READ_ACTION + else: + return WRITE_ACTION + + def predict(self, states): + # Predict target token from decoder states + decoder_states = states.decoder_out + + lprobs = self.model.get_normalized_probs( + [decoder_states[:, -1:]], log_probs=True + ) + + index = lprobs.argmax(dim=-1)[0, 0].item() + + if index != self.dict['tgt'].eos_index: + token = self.dict['tgt'].string([index]) + else: + token = self.dict['tgt'].eos_word + + return token diff --git a/fairseq/examples/simultaneous_translation/models/__init__.py b/fairseq/examples/simultaneous_translation/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..257a96593ff7af93c206c066d8db4ad795b2ae36 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/models/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + model_name = file[: file.find(".py")] + importlib.import_module( + "examples.simultaneous_translation.models." + model_name + ) diff --git a/fairseq/examples/simultaneous_translation/models/convtransformer_simul_trans.py b/fairseq/examples/simultaneous_translation/models/convtransformer_simul_trans.py new file mode 100644 index 0000000000000000000000000000000000000000..4a26422f650cf13ee7d4e8d2228b50ec49876fb8 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/models/convtransformer_simul_trans.py @@ -0,0 +1,204 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +from fairseq import checkpoint_utils +from fairseq.models import ( + register_model, + register_model_architecture, +) +from fairseq.models.speech_to_text import ( + ConvTransformerModel, + convtransformer_espnet, + ConvTransformerEncoder, +) +from fairseq.models.speech_to_text.modules.augmented_memory_attention import ( + augmented_memory, + SequenceEncoder, + AugmentedMemoryConvTransformerEncoder, +) + +from torch import nn, Tensor +from typing import Dict, List +from fairseq.models.speech_to_text.modules.emformer import NoSegAugmentedMemoryTransformerEncoderLayer + +@register_model("convtransformer_simul_trans") +class SimulConvTransformerModel(ConvTransformerModel): + """ + Implementation of the paper: + + SimulMT to SimulST: Adapting Simultaneous Text Translation to + End-to-End Simultaneous Speech Translation + + https://www.aclweb.org/anthology/2020.aacl-main.58.pdf + """ + + @staticmethod + def add_args(parser): + super(SimulConvTransformerModel, SimulConvTransformerModel).add_args(parser) + parser.add_argument( + "--train-monotonic-only", + action="store_true", + default=False, + help="Only train monotonic attention", + ) + + @classmethod + def build_decoder(cls, args, task, embed_tokens): + tgt_dict = task.tgt_dict + + from examples.simultaneous_translation.models.transformer_monotonic_attention import ( + TransformerMonotonicDecoder, + ) + + decoder = TransformerMonotonicDecoder(args, tgt_dict, embed_tokens) + + if getattr(args, "load_pretrained_decoder_from", None): + decoder = checkpoint_utils.load_pretrained_component_from_model( + component=decoder, checkpoint=args.load_pretrained_decoder_from + ) + return decoder + + +@register_model_architecture( + "convtransformer_simul_trans", "convtransformer_simul_trans_espnet" +) +def convtransformer_simul_trans_espnet(args): + convtransformer_espnet(args) + + +@register_model("convtransformer_augmented_memory") +@augmented_memory +class AugmentedMemoryConvTransformerModel(SimulConvTransformerModel): + @classmethod + def build_encoder(cls, args): + encoder = SequenceEncoder(args, AugmentedMemoryConvTransformerEncoder(args)) + + if getattr(args, "load_pretrained_encoder_from", None) is not None: + encoder = checkpoint_utils.load_pretrained_component_from_model( + component=encoder, checkpoint=args.load_pretrained_encoder_from + ) + + return encoder + + +@register_model_architecture( + "convtransformer_augmented_memory", "convtransformer_augmented_memory" +) +def augmented_memory_convtransformer_espnet(args): + convtransformer_espnet(args) + + +# ============================================================================ # +# Convtransformer +# with monotonic attention decoder +# with emformer encoder +# ============================================================================ # + + +class ConvTransformerEmformerEncoder(ConvTransformerEncoder): + def __init__(self, args): + super().__init__(args) + stride = self.conv_layer_stride(args) + trf_left_context = args.segment_left_context // stride + trf_right_context = args.segment_right_context // stride + context_config = [trf_left_context, trf_right_context] + self.transformer_layers = nn.ModuleList( + [ + NoSegAugmentedMemoryTransformerEncoderLayer( + input_dim=args.encoder_embed_dim, + num_heads=args.encoder_attention_heads, + ffn_dim=args.encoder_ffn_embed_dim, + num_layers=args.encoder_layers, + dropout_in_attn=args.dropout, + dropout_on_attn=args.dropout, + dropout_on_fc1=args.dropout, + dropout_on_fc2=args.dropout, + activation_fn=args.activation_fn, + context_config=context_config, + segment_size=args.segment_length, + max_memory_size=args.max_memory_size, + scaled_init=True, # TODO: use constant for now. + tanh_on_mem=args.amtrf_tanh_on_mem, + ) + ] + ) + self.conv_transformer_encoder = ConvTransformerEncoder(args) + + def forward(self, src_tokens, src_lengths): + encoder_out: Dict[str, List[Tensor]] = self.conv_transformer_encoder(src_tokens, src_lengths.to(src_tokens.device)) + output = encoder_out["encoder_out"][0] + encoder_padding_masks = encoder_out["encoder_padding_mask"] + + return { + "encoder_out": [output], + # This is because that in the original implementation + # the output didn't consider the last segment as right context. + "encoder_padding_mask": [encoder_padding_masks[0][:, : output.size(0)]] if len(encoder_padding_masks) > 0 + else [], + "encoder_embedding": [], + "encoder_states": [], + "src_tokens": [], + "src_lengths": [], + } + + @staticmethod + def conv_layer_stride(args): + # TODO: make it configurable from the args + return 4 + + +@register_model("convtransformer_emformer") +class ConvtransformerEmformer(SimulConvTransformerModel): + @staticmethod + def add_args(parser): + super(ConvtransformerEmformer, ConvtransformerEmformer).add_args(parser) + + parser.add_argument( + "--segment-length", + type=int, + metavar="N", + help="length of each segment (not including left context / right context)", + ) + parser.add_argument( + "--segment-left-context", + type=int, + help="length of left context in a segment", + ) + parser.add_argument( + "--segment-right-context", + type=int, + help="length of right context in a segment", + ) + parser.add_argument( + "--max-memory-size", + type=int, + default=-1, + help="Right context for the segment.", + ) + parser.add_argument( + "--amtrf-tanh-on-mem", + default=False, + action="store_true", + help="whether to use tanh on memory vector", + ) + + @classmethod + def build_encoder(cls, args): + encoder = ConvTransformerEmformerEncoder(args) + if getattr(args, "load_pretrained_encoder_from", None): + encoder = checkpoint_utils.load_pretrained_component_from_model( + component=encoder, checkpoint=args.load_pretrained_encoder_from + ) + return encoder + + +@register_model_architecture( + "convtransformer_emformer", + "convtransformer_emformer", +) +def convtransformer_emformer_base(args): + convtransformer_espnet(args) diff --git a/fairseq/examples/simultaneous_translation/models/transformer_monotonic_attention.py b/fairseq/examples/simultaneous_translation/models/transformer_monotonic_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..7b9414b0eb3b30c935478cd5b8a894168bd8cc98 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/models/transformer_monotonic_attention.py @@ -0,0 +1,302 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, NamedTuple, Optional + +import torch +import torch.nn as nn +from examples.simultaneous_translation.modules.monotonic_transformer_layer import ( + TransformerMonotonicDecoderLayer, + TransformerMonotonicEncoderLayer, +) +from fairseq.models import ( + register_model, + register_model_architecture, +) +from fairseq.models.transformer import ( + TransformerModel, + TransformerEncoder, + TransformerDecoder, + base_architecture, + transformer_iwslt_de_en, + transformer_vaswani_wmt_en_de_big, + tiny_architecture +) +from torch import Tensor + +DEFAULT_MAX_SOURCE_POSITIONS = 1024 +DEFAULT_MAX_TARGET_POSITIONS = 1024 +READ_ACTION = 0 +WRITE_ACTION = 1 + +TransformerMonotonicDecoderOut = NamedTuple( + "TransformerMonotonicDecoderOut", + [ + ("action", int), + ("p_choose", Optional[Tensor]), + ("attn_list", Optional[List[Optional[Dict[str, Tensor]]]]), + ("encoder_out", Optional[Dict[str, List[Tensor]]]), + ("encoder_padding_mask", Optional[Tensor]), + ], +) + + +@register_model("transformer_unidirectional") +class TransformerUnidirectionalModel(TransformerModel): + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerMonotonicEncoder(args, src_dict, embed_tokens) + + +@register_model("transformer_monotonic") +class TransformerModelSimulTrans(TransformerModel): + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerMonotonicEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerMonotonicDecoder(args, tgt_dict, embed_tokens) + + +class TransformerMonotonicEncoder(TransformerEncoder): + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens) + + self.dictionary = dictionary + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + TransformerMonotonicEncoderLayer(args) + for i in range(args.encoder_layers) + ] + ) + + +class TransformerMonotonicDecoder(TransformerDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + super().__init__(args, dictionary, embed_tokens, no_encoder_attn=False) + + self.dictionary = dictionary + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + TransformerMonotonicDecoderLayer(args) + for _ in range(args.decoder_layers) + ] + ) + self.policy_criterion = getattr(args, "policy_criterion", "any") + self.num_updates = None + + def set_num_updates(self, num_updates): + self.num_updates = num_updates + + def pre_attention( + self, + prev_output_tokens, + encoder_out_dict: Dict[str, List[Tensor]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + ): + positions = ( + self.embed_positions( + prev_output_tokens, + incremental_state=incremental_state, + ) + if self.embed_positions is not None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + encoder_out = encoder_out_dict["encoder_out"][0] + + if "encoder_padding_mask" in encoder_out_dict: + encoder_padding_mask = ( + encoder_out_dict["encoder_padding_mask"][0] + if encoder_out_dict["encoder_padding_mask"] + and len(encoder_out_dict["encoder_padding_mask"]) > 0 + else None + ) + else: + encoder_padding_mask = None + + return x, encoder_out, encoder_padding_mask + + def post_attention(self, x): + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x + + def clean_cache( + self, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + end_id: Optional[int] = None, + ): + """ + Clean cache in the monotonic layers. + The cache is generated because of a forward pass of decoder has run but no prediction, + so that the self attention key value in decoder is written in the incremental state. + end_id is the last idx of the layers + """ + if end_id is None: + end_id = len(self.layers) + + for index, layer in enumerate(self.layers): + if index < end_id: + layer.prune_incremental_state(incremental_state) + + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, # unused + alignment_layer: Optional[int] = None, # unused + alignment_heads: Optional[int] = None, # unsed + ): + """ + Similar to *forward* but only return features. + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + # incremental_state = None + assert encoder_out is not None + (x, encoder_outs, encoder_padding_mask) = self.pre_attention( + prev_output_tokens, encoder_out, incremental_state + ) + attn = None + inner_states = [x] + attn_list: List[Optional[Dict[str, Tensor]]] = [] + + p_choose = torch.tensor([1.0]) + + for i, layer in enumerate(self.layers): + + x, attn, _ = layer( + x=x, + encoder_out=encoder_outs, + encoder_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + self_attn_mask=self.buffered_future_mask(x) + if incremental_state is None + else None, + ) + + inner_states.append(x) + attn_list.append(attn) + + if incremental_state is not None: + if_online = incremental_state["online"]["only"] + assert if_online is not None + if if_online.to(torch.bool): + # Online indicates that the encoder states are still changing + assert attn is not None + if self.policy_criterion == "any": + # Any head decide to read than read + head_read = layer.encoder_attn._get_monotonic_buffer(incremental_state)["head_read"] + assert head_read is not None + if head_read.any(): + # We need to prune the last self_attn saved_state + # if model decide not to read + # otherwise there will be duplicated saved_state + self.clean_cache(incremental_state, i + 1) + + return x, TransformerMonotonicDecoderOut( + action=0, + p_choose=p_choose, + attn_list=None, + encoder_out=None, + encoder_padding_mask=None, + ) + + x = self.post_attention(x) + + return x, TransformerMonotonicDecoderOut( + action=1, + p_choose=p_choose, + attn_list=attn_list, + encoder_out=encoder_out, + encoder_padding_mask=encoder_padding_mask, + ) + + +@register_model_architecture("transformer_monotonic", "transformer_monotonic") +def base_monotonic_architecture(args): + base_architecture(args) + args.encoder_unidirectional = getattr(args, "encoder_unidirectional", False) + + +@register_model_architecture( + "transformer_monotonic", "transformer_monotonic_iwslt_de_en" +) +def transformer_monotonic_iwslt_de_en(args): + transformer_iwslt_de_en(args) + base_monotonic_architecture(args) + + +# parameters used in the "Attention Is All You Need" paper (Vaswani et al., 2017) +@register_model_architecture( + "transformer_monotonic", "transformer_monotonic_vaswani_wmt_en_de_big" +) +def transformer_monotonic_vaswani_wmt_en_de_big(args): + transformer_vaswani_wmt_en_de_big(args) + + +@register_model_architecture( + "transformer_monotonic", "transformer_monotonic_vaswani_wmt_en_fr_big" +) +def transformer_monotonic_vaswani_wmt_en_fr_big(args): + transformer_monotonic_vaswani_wmt_en_fr_big(args) + + +@register_model_architecture( + "transformer_unidirectional", "transformer_unidirectional_iwslt_de_en" +) +def transformer_unidirectional_iwslt_de_en(args): + transformer_iwslt_de_en(args) + + +@register_model_architecture("transformer_monotonic", "transformer_monotonic_tiny") +def monotonic_tiny_architecture(args): + tiny_architecture(args) + base_monotonic_architecture(args) diff --git a/fairseq/examples/simultaneous_translation/modules/__init__.py b/fairseq/examples/simultaneous_translation/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f5ea180f9b4cdb27cd553439b6df9d743105f18c --- /dev/null +++ b/fairseq/examples/simultaneous_translation/modules/__init__.py @@ -0,0 +1,23 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import os +import importlib +from fairseq import registry + +( + build_monotonic_attention, + register_monotonic_attention, + MONOTONIC_ATTENTION_REGISTRY, + _, +) = registry.setup_registry("--simul-type") + +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + model_name = file[: file.find(".py")] + importlib.import_module( + "examples.simultaneous_translation.modules." + model_name + ) diff --git a/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py b/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py new file mode 100644 index 0000000000000000000000000000000000000000..3991414aed3800f301e4097e819d3064bb549c37 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/modules/fixed_pre_decision.py @@ -0,0 +1,190 @@ +from functools import partial + +import torch +from torch import Tensor +import math +import torch.nn.functional as F + +from . import register_monotonic_attention +from .monotonic_multihead_attention import ( + MonotonicAttention, + MonotonicInfiniteLookbackAttention, + WaitKAttention +) +from typing import Dict, Optional + + +def fixed_pooling_monotonic_attention(monotonic_attention): + def create_model(monotonic_attention, klass): + class FixedStrideMonotonicAttention(monotonic_attention): + def __init__(self, args): + self.waitk_lagging = 0 + self.num_heads = 0 + self.noise_mean = 0.0 + self.noise_var = 0.0 + super().__init__(args) + self.pre_decision_type = args.fixed_pre_decision_type + self.pre_decision_ratio = args.fixed_pre_decision_ratio + self.pre_decision_pad_threshold = args.fixed_pre_decision_pad_threshold + assert self.pre_decision_ratio > 1 + + if args.fixed_pre_decision_type == "average": + self.pooling_layer = torch.nn.AvgPool1d( + kernel_size=self.pre_decision_ratio, + stride=self.pre_decision_ratio, + ceil_mode=True, + ) + elif args.fixed_pre_decision_type == "last": + + def last(key): + if key.size(2) < self.pre_decision_ratio: + return key + else: + k = key[ + :, + :, + self.pre_decision_ratio - 1:: self.pre_decision_ratio, + ].contiguous() + if key.size(-1) % self.pre_decision_ratio != 0: + k = torch.cat([k, key[:, :, -1:]], dim=-1).contiguous() + return k + + self.pooling_layer = last + else: + raise NotImplementedError + + @staticmethod + def add_args(parser): + super( + FixedStrideMonotonicAttention, FixedStrideMonotonicAttention + ).add_args(parser) + parser.add_argument( + "--fixed-pre-decision-ratio", + type=int, + required=True, + help=( + "Ratio for the fixed pre-decision," + "indicating how many encoder steps will start" + "simultaneous decision making process." + ), + ) + parser.add_argument( + "--fixed-pre-decision-type", + default="average", + choices=["average", "last"], + help="Pooling type", + ) + parser.add_argument( + "--fixed-pre-decision-pad-threshold", + type=float, + default=0.3, + help="If a part of the sequence has pad" + ",the threshold the pooled part is a pad.", + ) + + def insert_zeros(self, x): + bsz_num_heads, tgt_len, src_len = x.size() + stride = self.pre_decision_ratio + weight = F.pad(torch.ones(1, 1, 1).to(x), (stride - 1, 0)) + x_upsample = F.conv_transpose1d( + x.view(-1, src_len).unsqueeze(1), + weight, + stride=stride, + padding=0, + ) + return x_upsample.squeeze(1).view(bsz_num_heads, tgt_len, -1) + + def p_choose( + self, + query: Optional[Tensor], + key: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + ): + assert key is not None + assert query is not None + src_len = key.size(0) + tgt_len = query.size(0) + batch_size = query.size(1) + + key_pool = self.pooling_layer(key.transpose(0, 2)).transpose(0, 2) + + if key_padding_mask is not None: + key_padding_mask_pool = ( + self.pooling_layer(key_padding_mask.unsqueeze(0).float()) + .squeeze(0) + .gt(self.pre_decision_pad_threshold) + ) + # Make sure at least one element is not pad + key_padding_mask_pool[:, 0] = 0 + else: + key_padding_mask_pool = None + + if incremental_state is not None: + # The floor instead of ceil is used for inference + # But make sure the length key_pool at least 1 + if ( + max(1, math.floor(key.size(0) / self.pre_decision_ratio)) + ) < key_pool.size(0): + key_pool = key_pool[:-1] + if key_padding_mask_pool is not None: + key_padding_mask_pool = key_padding_mask_pool[:-1] + + p_choose_pooled = self.p_choose_from_qk( + query, + key_pool, + key_padding_mask_pool, + incremental_state=incremental_state, + ) + + # Upsample, interpolate zeros + p_choose = self.insert_zeros(p_choose_pooled) + + if p_choose.size(-1) < src_len: + # Append zeros if the upsampled p_choose is shorter than src_len + p_choose = torch.cat( + [ + p_choose, + torch.zeros( + p_choose.size(0), + tgt_len, + src_len - p_choose.size(-1) + ).to(p_choose) + ], + dim=2 + ) + else: + # can be larger than src_len because we used ceil before + p_choose = p_choose[:, :, :src_len] + p_choose[:, :, -1] = p_choose_pooled[:, :, -1] + + assert list(p_choose.size()) == [ + batch_size * self.num_heads, + tgt_len, + src_len, + ] + + return p_choose + + FixedStrideMonotonicAttention.__name__ = klass.__name__ + return FixedStrideMonotonicAttention + + return partial(create_model, monotonic_attention) + + +@register_monotonic_attention("waitk_fixed_pre_decision") +@fixed_pooling_monotonic_attention(WaitKAttention) +class WaitKAttentionFixedStride: + pass + + +@register_monotonic_attention("hard_aligned_fixed_pre_decision") +@fixed_pooling_monotonic_attention(MonotonicAttention) +class MonotonicAttentionFixedStride: + pass + + +@register_monotonic_attention("infinite_lookback_fixed_pre_decision") +@fixed_pooling_monotonic_attention(MonotonicInfiniteLookbackAttention) +class MonotonicInfiniteLookbackAttentionFixedStride: + pass diff --git a/fairseq/examples/simultaneous_translation/modules/monotonic_multihead_attention.py b/fairseq/examples/simultaneous_translation/modules/monotonic_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..11ef60c9458c6d24e45b20a8eab030c18e6801e5 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/modules/monotonic_multihead_attention.py @@ -0,0 +1,519 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +from torch import Tensor +import torch.nn as nn + +from examples.simultaneous_translation.utils.p_choose_strategy import ( + learnable_p_choose, + waitk_p_choose +) + +from examples.simultaneous_translation.utils.monotonic_attention import ( + expected_alignment_from_p_choose, + expected_soft_attention, + mass_preservation, +) +from fairseq.modules import MultiheadAttention + +from . import register_monotonic_attention +from typing import Dict, Optional + + +@register_monotonic_attention("hard_aligned") +class MonotonicAttention(MultiheadAttention): + """ + Abstract class of monotonic attentions + """ + k_in_proj: Dict[str, nn.Linear] + q_in_proj: Dict[str, nn.Linear] + + def __init__(self, args): + super().__init__( + embed_dim=args.decoder_embed_dim, + num_heads=args.decoder_attention_heads, + kdim=getattr(args, "encoder_embed_dim", None), + vdim=getattr(args, "encoder_embed_dim", None), + dropout=args.attention_dropout, + encoder_decoder_attention=True, + ) + + self.soft_attention = False + + self.eps = getattr(args, "attention_eps", True) + self.mass_preservation = getattr(args, "mass_preservation", True) + + self.noise_type = args.noise_type + self.noise_mean = args.noise_mean + self.noise_var = args.noise_var + + self.energy_bias_init = args.energy_bias_init + self.energy_bias = ( + nn.Parameter(self.energy_bias_init * torch.ones([1])) + if args.energy_bias is True + else 0 + ) + + self.k_in_proj = {"monotonic": self.k_proj} + self.q_in_proj = {"monotonic": self.q_proj} + self.chunk_size = None + + @staticmethod + def add_args(parser): + # fmt: off + parser.add_argument('--no-mass-preservation', action="store_false", + dest="mass_preservation", + help='Do not stay on the last token when decoding') + parser.add_argument('--mass-preservation', action="store_true", + dest="mass_preservation", + help='Stay on the last token when decoding') + parser.set_defaults(mass_preservation=True) + parser.add_argument('--noise-var', type=float, default=1.0, + help='Variance of discretness noise') + parser.add_argument('--noise-mean', type=float, default=0.0, + help='Mean of discretness noise') + parser.add_argument('--noise-type', type=str, default="flat", + help='Type of discretness noise') + parser.add_argument('--energy-bias', action="store_true", + default=False, + help='Bias for energy') + parser.add_argument('--energy-bias-init', type=float, default=-2.0, + help='Initial value of the bias for energy') + parser.add_argument('--attention-eps', type=float, default=1e-6, + help='Epsilon when calculating expected attention') + + def energy_from_qk( + self, + query: Tensor, + key: Tensor, + energy_type: str, + key_padding_mask: Optional[Tensor] = None, + bias: int = 0 + ): + """ + Compute energy from query and key + q_func_value is a tuple looks like + (q_proj_func, q_tensor) + q_tensor size: bsz, tgt_len, emb_dim + k_tensor size: bsz, src_len, emb_dim + key_padding_mask size: bsz, src_len + attn_mask: bsz, src_len + """ + + length, bsz, _ = query.size() + q = self.q_in_proj[energy_type].forward(query) + q = ( + q.contiguous() + .view(length, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + q = q * self.scaling + length, bsz, _ = key.size() + k = self.k_in_proj[energy_type].forward(key) + k = ( + k.contiguous() + .view(length, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + energy = torch.bmm(q, k.transpose(1, 2)) + bias + + if key_padding_mask is not None: + energy = energy.masked_fill( + key_padding_mask.unsqueeze(1).to(torch.bool), + - float("inf") + ) + + return energy + + def p_choose_from_qk(self, query, key, key_padding_mask, incremental_states=None): + monotonic_energy = self.energy_from_qk( + query, + key, + "monotonic", + key_padding_mask=key_padding_mask, + bias=self.energy_bias, + ) + + p_choose = learnable_p_choose( + monotonic_energy, + self.noise_mean, + self.noise_var, + self.training + ) + return p_choose + + def p_choose(self, query, key, key_padding_mask, incremental_states=None): + return self.p_choose_from_qk(self, query, key, key_padding_mask) + + def monotonic_attention_process_infer( + self, + query: Optional[Tensor], + key: Optional[Tensor], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + ): + """ + Monotonic attention at inference time + Notice that this function is designed for simuleval not sequence_generator + """ + assert query is not None + assert key is not None + + if query.size(1) != 1: + raise RuntimeError( + "Simultaneous translation models don't support batch decoding." + ) + # 1. compute stepwise probability + p_choose = self.p_choose( + query, key, None, incremental_state + ).squeeze(1) + + # 2. Compute the alpha + src_len = key.size(0) + # Maximum steps allows in this iteration + max_steps = src_len - 1 if self.mass_preservation else src_len + monotonic_cache = self._get_monotonic_buffer(incremental_state) + # Step for each head + monotonic_step = monotonic_cache.get( + 'head_step', + p_choose.new_zeros(1, self.num_heads).long() + ) + assert monotonic_step is not None + finish_read = monotonic_step.eq(max_steps) + p_choose_i = torch.tensor(1) + + while finish_read.sum().item() < self.num_heads: + # p_choose: self.num_heads, src_len + # only choose the p at monotonic steps + # p_choose_i: 1, self.num_heads + p_choose_i = ( + p_choose.gather( + 1, + monotonic_step + .clamp(0, src_len - 1), + ) + ) + + read_one_step = ( + (p_choose_i < 0.5) + .type_as(monotonic_step) + .masked_fill(finish_read, 0) + ) + # 1 x bsz + # sample actions on unfinished seq + # 0 means stay, finish reading + # 1 means leave, continue reading + + monotonic_step += read_one_step + + finish_read = monotonic_step.eq(max_steps) | (read_one_step == 0) + + # p_choose at last steps + p_choose_i = ( + p_choose.gather( + 1, + monotonic_step + .clamp(0, src_len - 1), + ) + ) + + monotonic_cache["head_step"] = monotonic_step + # Whether a head is looking for new input + monotonic_cache["head_read"] = ( + monotonic_step.eq(max_steps) & (p_choose_i < 0.5) + ) + self._set_monotonic_buffer(incremental_state, monotonic_cache) + + # 2. Update alpha + alpha = ( + p_choose + .new_zeros([self.num_heads, src_len]) + .scatter( + 1, + (monotonic_step) + .view(self.num_heads, 1).clamp(0, src_len - 1), + 1 + ) + ) + + if not self.mass_preservation: + alpha = alpha.masked_fill( + (monotonic_step == max_steps) + .view(self.num_heads, 1), + 0 + ) + + # 4. Compute Beta + if self.soft_attention: + monotonic_step = monotonic_step.t() + beta_mask = torch.arange(src_len).expand_as(alpha).gt(monotonic_step).unsqueeze(1) + # If it's soft attention just do softmax on current context + soft_energy = self.energy_from_qk( + query, + key, + "soft" + ) + beta = torch.nn.functional.softmax( + soft_energy.masked_fill(beta_mask, -float("inf")), dim=-1 + ) + # It could happen that a head doesn't move at all + beta = beta.masked_fill(monotonic_step.eq(0).unsqueeze(1), 0) + else: + # If it's hard attention just select the last state + beta = alpha + + return p_choose, alpha, beta + + def monotonic_attention_process_train( + self, + query: Optional[Tensor], + key: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + ): + """ + Calculating monotonic attention process for training + Including: + stepwise probability: p_choose + expected hard alignment: alpha + expected soft attention: beta + """ + assert query is not None + assert key is not None + + # 1. compute stepwise probability + p_choose = self.p_choose_from_qk(query, key, key_padding_mask) + + # 2. compute expected_alignment + alpha = expected_alignment_from_p_choose( + p_choose, + key_padding_mask, + eps=self.eps, + ) + + if self.mass_preservation: + alpha = mass_preservation( + alpha, key_padding_mask + ) + + # 3. compute expected soft attention (soft aligned model only) + if self.soft_attention: + soft_energy = self.energy_from_qk( + query, + key, + "soft", + key_padding_mask=None, + ) + + beta = expected_soft_attention( + alpha, + soft_energy, + padding_mask=key_padding_mask, + chunk_size=self.chunk_size, + eps=self.eps, + ) + else: + beta = alpha + soft_energy = alpha + + return p_choose, alpha, beta, soft_energy + + def forward( + self, + query: Optional[Tensor], + key: Optional[Tensor], + value: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + attn_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + need_weights: bool = True, static_kv: bool = False, need_head_weights: bool = False, + ): + """ + query: tgt_len, bsz, embed_dim + key: src_len, bsz, embed_dim + value: src_len, bsz, embed_dim + """ + + assert attn_mask is None + assert query is not None + assert key is not None + assert value is not None + + tgt_len, bsz, embed_dim = query.size() + src_len = value.size(0) + + if key_padding_mask is not None: + assert not key_padding_mask[:, 0].any(), ( + "Only right padding is supported." + ) + key_padding_mask = ( + key_padding_mask + .unsqueeze(1) + .expand([bsz, self.num_heads, src_len]) + .contiguous() + .view(-1, src_len) + ) + + if incremental_state is not None: + # Inference + ( + p_choose, alpha, beta + ) = self.monotonic_attention_process_infer( + query, key, incremental_state + ) + soft_energy = beta + else: + # Train + ( + p_choose, alpha, beta, soft_energy + ) = self.monotonic_attention_process_train( + query, key, key_padding_mask + ) + + v = self.v_proj(value) + length, bsz, _ = v.size() + v = ( + v.contiguous() + .view(length, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + attn = torch.bmm(beta.type_as(v), v) + + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim) + + attn = self.out_proj(attn) + + p_choose = p_choose.view(bsz, self.num_heads, tgt_len, src_len) + alpha = alpha.view(bsz, self.num_heads, tgt_len, src_len) + beta = beta.view(bsz, self.num_heads, tgt_len, src_len) + + return attn, { + "p_choose": p_choose, + "alpha": alpha, + "beta": beta, + } + + def _get_monotonic_buffer(self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]): + maybe_incremental_state = self.get_incremental_state( + incremental_state, + 'monotonic', + ) + if maybe_incremental_state is None: + typed_empty_dict: Dict[str, Optional[Tensor]] = {} + return typed_empty_dict + else: + return maybe_incremental_state + + def _set_monotonic_buffer(self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], buffer: Dict[str, Optional[Tensor]]): + self.set_incremental_state( + incremental_state, + 'monotonic', + buffer, + ) + + +@register_monotonic_attention("infinite_lookback") +class MonotonicInfiniteLookbackAttention( + MonotonicAttention +): + def __init__(self, args): + super().__init__(args) + self.soft_attention = True + self.init_soft_attention() + + def init_soft_attention(self): + self.k_proj_soft = nn.Linear(self.kdim, self.embed_dim, bias=True) + self.q_proj_soft = nn.Linear(self.embed_dim, self.embed_dim, bias=True) + self.k_in_proj["soft"] = self.k_proj_soft + self.q_in_proj["soft"] = self.q_proj_soft + + if self.qkv_same_dim: + # Empirically observed the convergence to be much better with + # the scaled initialization + nn.init.xavier_uniform_( + self.k_in_proj["soft"].weight, gain=1 / math.sqrt(2) + ) + nn.init.xavier_uniform_( + self.q_in_proj["soft"].weight, gain=1 / math.sqrt(2) + ) + else: + nn.init.xavier_uniform_(self.k_in_proj["soft"].weight) + nn.init.xavier_uniform_(self.q_in_proj["soft"].weight) + + +@register_monotonic_attention("waitk") +class WaitKAttention( + MonotonicInfiniteLookbackAttention +): + """ + STACL: Simultaneous Translation with Implicit Anticipation and + Controllable Latency using Prefix-to-Prefix Framework + https://www.aclweb.org/anthology/P19-1289/ + """ + def __init__(self, args): + super().__init__(args) + self.q_in_proj["soft"] = self.q_in_proj["monotonic"] + self.k_in_proj["soft"] = self.k_in_proj["monotonic"] + + self.waitk_lagging = args.waitk_lagging + assert self.waitk_lagging > 0, ( + f"Lagging has to been larger than 0, get {self.waitk_lagging}." + ) + + @staticmethod + def add_args(parser): + super( + MonotonicInfiniteLookbackAttention, + MonotonicInfiniteLookbackAttention + ).add_args(parser) + + parser.add_argument( + "--waitk-lagging", type=int, required=True, help="Wait K lagging" + ) + + def p_choose_from_qk( + self, + query: Optional[Tensor], + key: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + ): + assert query is not None + assert key is not None + + p_choose = waitk_p_choose( + tgt_len=query.size(0), + src_len=key.size(0), + bsz=query.size(1) * self.num_heads, + waitk_lagging=self.waitk_lagging, + key_padding_mask=key_padding_mask, + incremental_state=incremental_state, + ) + + return p_choose.to(query) + + +@register_monotonic_attention("chunkwise") +class ChunkwiseAttention( + MonotonicInfiniteLookbackAttention +): + def __init__(self, args): + super().__init__(args) + self.chunk_size = args.mocha_chunk_size + assert self.chunk_size > 1 + + @staticmethod + def add_args(parser): + super( + MonotonicInfiniteLookbackAttention + ).add_args(parser) + + parser.add_argument( + "--mocha-chunk-size", type=int, + required=True, help="Mocha chunk size" + ) diff --git a/fairseq/examples/simultaneous_translation/modules/monotonic_transformer_layer.py b/fairseq/examples/simultaneous_translation/modules/monotonic_transformer_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..94bd71fb9c46a64a8b6e1960f47dfc43b78dda43 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/modules/monotonic_transformer_layer.py @@ -0,0 +1,182 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.modules import TransformerDecoderLayer, TransformerEncoderLayer + +from . import build_monotonic_attention + +from typing import Dict, Optional, List + +from torch import Tensor +import torch + + +class TransformerMonotonicEncoderLayer(TransformerEncoderLayer): + def forward(self, x, encoder_padding_mask): + seq_len, _, _ = x.size() + attn_mask = x.new_ones([seq_len, seq_len]).triu(1) + attn_mask = attn_mask.masked_fill(attn_mask.bool(), float("-inf")) + return super().forward(x, encoder_padding_mask, attn_mask) + + +class TransformerMonotonicDecoderLayer(TransformerDecoderLayer): + def __init__(self, args): + super().__init__(args) + + assert args.simul_type is not None, "A --simul-type is needed." + self.encoder_attn = build_monotonic_attention(args) + + def prune_incremental_state( + self, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] + ): + input_buffer = self.self_attn._get_input_buffer(incremental_state) + for key in ["prev_key", "prev_value"]: + input_buffer_key = input_buffer[key] + assert input_buffer_key is not None + if input_buffer_key.size(2) > 1: + input_buffer[key] = input_buffer_key[:, :, :-1, :] + else: + typed_empty_dict: Dict[str, Optional[Tensor]] = {} + input_buffer = typed_empty_dict + break + assert incremental_state is not None + self.self_attn._set_input_buffer(incremental_state, input_buffer) + + def forward( + self, + x, + encoder_out: Optional[Tensor] = None, + encoder_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + prev_self_attn_state: Optional[List[Tensor]] = None, + prev_attn_state: Optional[List[Tensor]] = None, + self_attn_mask: Optional[Tensor] = None, + self_attn_padding_mask: Optional[Tensor] = None, + need_attn: bool = False, + need_head_weights: bool = False, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor, optional): binary + ByteTensor of shape `(batch, src_len)` where padding + elements are indicated by ``1``. + need_attn (bool, optional): return attention weights + need_head_weights (bool, optional): return attention weights + for each head (default: return average over heads). + + Returns: + encoded output of shape `(seq_len, batch, embed_dim)` + """ + if need_head_weights: + need_attn = True + + residual = x + if self.normalize_before: + x = self.self_attn_layer_norm(x) + if prev_self_attn_state is not None: + prev_key, prev_value = prev_self_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_self_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_self_attn_state[2] + assert incremental_state is not None + self.self_attn._set_input_buffer(incremental_state, saved_state) + _self_attn_input_buffer = self.self_attn._get_input_buffer(incremental_state) + if self.cross_self_attention and not ( + incremental_state is not None + and _self_attn_input_buffer is not None + and "prev_key" in _self_attn_input_buffer + ): + if self_attn_mask is not None: + assert encoder_out is not None + self_attn_mask = torch.cat( + (x.new_zeros(x.size(0), encoder_out.size(0)), self_attn_mask), dim=1 + ) + if self_attn_padding_mask is not None: + if encoder_padding_mask is None: + assert encoder_out is not None + encoder_padding_mask = self_attn_padding_mask.new_zeros( + encoder_out.size(1), encoder_out.size(0) + ) + self_attn_padding_mask = torch.cat( + (encoder_padding_mask, self_attn_padding_mask), dim=1 + ) + assert encoder_out is not None + y = torch.cat((encoder_out, x), dim=0) + else: + y = x + + x, attn = self.self_attn( + query=x, + key=y, + value=y, + key_padding_mask=self_attn_padding_mask, + incremental_state=incremental_state, + need_weights=False, + attn_mask=self_attn_mask, + ) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + assert self.encoder_attn is not None + residual = x + if self.normalize_before: + x = self.encoder_attn_layer_norm(x) + if prev_attn_state is not None: + prev_key, prev_value = prev_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_attn_state[2] + assert incremental_state is not None + self.encoder_attn._set_input_buffer(incremental_state, saved_state) + + x, attn = self.encoder_attn( + query=x, + key=encoder_out, + value=encoder_out, + key_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + static_kv=True, + need_weights=need_attn or (not self.training and self.need_attn), + need_head_weights=need_head_weights, + ) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.encoder_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.final_layer_norm(x) + if self.onnx_trace and incremental_state is not None: + saved_state = self.self_attn._get_input_buffer(incremental_state) + assert saved_state is not None + if self_attn_padding_mask is not None: + self_attn_state = [ + saved_state["prev_key"], + saved_state["prev_value"], + saved_state["prev_key_padding_mask"], + ] + else: + self_attn_state = [saved_state["prev_key"], saved_state["prev_value"]] + return x, attn, self_attn_state + return x, attn, None diff --git a/fairseq/examples/simultaneous_translation/tests/test_text_models.py b/fairseq/examples/simultaneous_translation/tests/test_text_models.py new file mode 100644 index 0000000000000000000000000000000000000000..127adfa6337333ba5ae598fcd158956def0d520f --- /dev/null +++ b/fairseq/examples/simultaneous_translation/tests/test_text_models.py @@ -0,0 +1,407 @@ +import argparse +import unittest +from typing import Any, Dict + +import torch +from examples.simultaneous_translation.models import ( + transformer_monotonic_attention +) + + +from tests.test_roberta import FakeTask + + +DEFAULT_CONFIG = { + "attention_eps": 1e-6, + "mass_preservation": True, + "noise_type": "flat", + "noise_mean": 0.0, + "noise_var": 1.0, + "energy_bias_init": -2, + "energy_bias": True +} + + +PAD_INDEX = 1 + + +def generate_config(overrides_kv): + new_dict = {key: value for key, value in DEFAULT_CONFIG.items()} + for key, value in overrides_kv.items(): + new_dict[key] = value + return new_dict + + +def make_sample_with_padding(longer_src=False) -> Dict[str, Any]: + tokens_1 = torch.LongTensor( + [ + [2, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15, 2], + [ + 2, 11, 12, 14, 15, 10, 11, 12, 13, 14, 15, 2, + PAD_INDEX, PAD_INDEX + ], + ] + ) + tokens_2 = torch.LongTensor( + [ + [2, 11, 12, 13, 14, 2, PAD_INDEX, PAD_INDEX], + [2, 11, 22, 33, 2, PAD_INDEX, PAD_INDEX, PAD_INDEX] + ] + ) + if longer_src: + src_tokens = tokens_1[:, 1:] + prev_output_tokens = tokens_2 + else: + src_tokens = tokens_2[:, 1:8] + prev_output_tokens = tokens_1 + + src_lengths = src_tokens.ne(PAD_INDEX).sum(dim=1).long() + + sample = { + "net_input": { + "src_tokens": src_tokens, + "prev_output_tokens": prev_output_tokens, + "src_lengths": src_lengths, + }, + "target": prev_output_tokens[:, 1:], + } + return sample + + +def build_transformer_monotonic_attention(**extra_args: Any): + overrides = { + # Use characteristics dimensions + "encoder_embed_dim": 12, + "encoder_ffn_embed_dim": 14, + "decoder_embed_dim": 12, + "decoder_ffn_embed_dim": 14, + # Disable dropout so we have comparable tests. + "dropout": 0, + "attention_dropout": 0, + "activation_dropout": 0, + "encoder_layerdrop": 0, + } + overrides.update(extra_args) + # Overrides the defaults from the parser + args = argparse.Namespace(**overrides) + transformer_monotonic_attention.monotonic_tiny_architecture(args) + + torch.manual_seed(0) + task = FakeTask(args) + return ( + transformer_monotonic_attention + .TransformerModelSimulTrans + .build_model(args, task) + ) + + +def expected_alignment_formula( + p_choose, + mass_perservation=True, + padding_mask=None +): + # Online and Linear-Time Attention by Enforcing Monotonic Alignments + # https://arxiv.org/pdf/1704.00784.pdf + # Eq 18, 19 + bsz, tgt_len, src_len = p_choose.size() + alpha = torch.zeros_like(p_choose) + + if padding_mask is not None: + bsz_pad = padding_mask.size(0) + num_heads = int(bsz / bsz_pad) + padding_mask = ( + padding_mask + .unsqueeze(1) + .expand([bsz_pad, num_heads, src_len]) + .contiguous() + .view(-1, src_len) + ) + + p_choose = p_choose.masked_fill(padding_mask.unsqueeze(1), 0) + + for bsz_i in range(bsz): + for i in range(tgt_len): + for j in range(src_len): + if i == 0: + if j == 0: + # First source token + alpha[bsz_i, i, j] = p_choose[bsz_i, i, j] + else: + # First target token + alpha[bsz_i, i, j] = ( + p_choose[bsz_i, i, j] + * torch.prod( + 1 - p_choose[bsz_i, i, :j] + ) + ) + else: + alpha[bsz_i, i, j] = alpha[bsz_i, i - 1, j] + for k in range(j): + alpha[bsz_i, i, j] += ( + alpha[bsz_i, i - 1, k] + * torch.prod( + 1 - p_choose[bsz_i, i, k:j] + ) + ) + alpha[bsz_i, i, j] *= p_choose[bsz_i, i, j] + + alpha = alpha.masked_fill(padding_mask.unsqueeze(1), 0) + + if mass_perservation: + alpha = mass_perservation_formula(alpha, False, padding_mask) + + return alpha + + +def mass_perservation_formula(alpha, left_padding=False, padding_mask=None): + if padding_mask is None or alpha.size(-1) == 1: + if alpha.size(-1) > 1: + alpha[:, :, -1] = 1 - alpha[:, :, :-1].sum(dim=-1) + return alpha + + src_lens = (padding_mask.logical_not()).sum(dim=1).long() + + bsz, tgt_len, src_len = alpha.size() + + assert ( + not left_padding + or (left_padding and (not padding_mask[:, 0].any())) + ) + + alpha = alpha.masked_fill(padding_mask.unsqueeze(1), 0) + + for bsz_i in range(bsz): + if left_padding: + alpha[bsz_i, :, -1] = ( + 1 - alpha[bsz_i, :, :-1].sum(dim=-1) + ) + else: + alpha[bsz_i, :, src_lens[bsz_i] - 1] = ( + 1 - alpha[bsz_i, :, :src_lens[bsz_i] - 1].sum(dim=-1) + ) + + return alpha + + +def expected_soft_attention_formula( + alpha, + soft_energy, + padding_mask=None, + chunksize=1e10, +): + # Monotonic Infinite Lookback Attention for Simultaneous Machine Translation + # https://arxiv.org/pdf/1906.05218.pdf + # Eq 14 + + # Monotonic Chunkwise Attention + # https://arxiv.org/abs/1712.05382 + # Eq 17 + bsz, tgt_len, src_len = alpha.size() + beta = torch.zeros_like(alpha) + + if padding_mask is not None: + bsz_pad = padding_mask.size(0) + num_heads = int(bsz / bsz_pad) + # Expanding for potential head dimension + padding_mask = ( + padding_mask + .unsqueeze(1) + .expand([bsz_pad, num_heads, src_len]) + .contiguous() + .view(-1, src_len) + ) + soft_energy = soft_energy.masked_fill(padding_mask.unsqueeze(1), float('-inf')) + + for bsz_i in range(bsz): + for i in range(tgt_len): + for j in range(src_len): + for k in range(j, min([src_len, j + chunksize])): + if not padding_mask[bsz_i, j]: + beta[bsz_i, i, j] += ( + alpha[bsz_i, i, k] * torch.exp(soft_energy[bsz_i, i, j]) + / torch.sum(torch.exp(soft_energy[bsz_i, i, max([0, k - chunksize + 1]):k + 1])) + ) + return beta + + +class MonotonicAttentionTestAbstractClass(object): + def test_forward(self): + sample = make_sample_with_padding() + out, _ = self.model.forward(**sample["net_input"]) + loss = out.sum() + loss.backward() + + def test_p_choose(self): + sample = make_sample_with_padding() + _, extra_out = self.model.forward(**sample["net_input"]) + for item in extra_out.attn_list: + p_choose = item["p_choose"] + self.assertTrue(p_choose.le(1.0).all()) + self.assertTrue(p_choose.ge(0.0).all()) + + def test_expected_alignment(self): + for longer_src in [True, False]: + sample = make_sample_with_padding(longer_src) + _, extra_out = self.model.forward(**sample["net_input"]) + for item in extra_out.attn_list: + p_choose = item["p_choose"] + alpha_system = item["alpha"] + self.assertTrue(p_choose.size() == alpha_system.size()) + bsz, num_head, tgt_len, src_len = alpha_system.size() + alpha_system = alpha_system.view(-1, tgt_len, src_len) + p_choose = p_choose.view(-1, tgt_len, src_len) + + alpha_real = expected_alignment_formula( + p_choose, + self.model.decoder.layers[0].encoder_attn.mass_preservation, + sample["net_input"]["src_tokens"].eq(PAD_INDEX) + ) + + self.assertTrue( + torch.abs(alpha_system - alpha_real).le(5e-5).all(), + ) + + +class HardMonotonicAttentionTestCase( + unittest.TestCase, + MonotonicAttentionTestAbstractClass +): + def setUp(self): + self.model = build_transformer_monotonic_attention( + **generate_config({"simul_type": "hard_aligned"}) + ) + + +class InfiniteLookbackTestCase( + unittest.TestCase, + MonotonicAttentionTestAbstractClass +): + def setUp(self): + self.model = build_transformer_monotonic_attention( + **generate_config( + { + "simul_type": "infinite_lookback" + } + ) + ) + self.model.train() + + def test_fp16_for_long_input(self): + sample = { + "net_input": { + "src_tokens": torch.LongTensor([7] * 1000 + [2]).cuda().unsqueeze(0), + "prev_output_tokens": torch.LongTensor([7] * 1000 + [2]).cuda().unsqueeze(0), + "src_lengths": torch.LongTensor([1000]).cuda(), + }, + "target": torch.LongTensor([2] + [7] * 1000).unsqueeze(0).cuda() + } + self.model.cuda().half() + _, extra_out = self.model.forward(**sample["net_input"]) + for item in extra_out.attn_list: + for key in ["p_choose", "alpha", "beta", "soft_energy"]: + self.assertFalse(torch.isnan(item[key]).any()) + + def test_expected_attention(self): + for longer_src in [True, False]: + sample = make_sample_with_padding(longer_src) + _, extra_out = self.model.forward(**sample["net_input"]) + for item in extra_out.attn_list: + p_choose = item["p_choose"] + alpha_system = item["alpha"] + beta_system = item["beta"] + soft_energy_system = item["soft_energy"] + self.assertTrue(beta_system.size() == alpha_system.size()) + self.assertTrue(p_choose.size() == alpha_system.size()) + + bsz, num_head, tgt_len, src_len = alpha_system.size() + + alpha_system = alpha_system.view(-1, tgt_len, src_len) + beta_system = beta_system.view(-1, tgt_len, src_len) + p_choose = p_choose.view(-1, tgt_len, src_len) + soft_energy_system = soft_energy_system.view(-1, tgt_len, src_len) + + alpha_real = expected_alignment_formula( + p_choose, + self.model.decoder.layers[0].encoder_attn.mass_preservation, + sample["net_input"]["src_tokens"].eq(PAD_INDEX) + ) + + beta_real = expected_soft_attention_formula( + alpha_real, + soft_energy_system, + sample["net_input"]["src_tokens"].eq(PAD_INDEX), + chunksize=getattr( + self.model.decoder.layers[0].encoder_attn, + "chunk_size", + int(1e10) + ) + ) + + self.assertTrue( + torch.abs(beta_system - beta_real).le(1e-5).all(), + ) + + +class ChunkwiswTestCase( + InfiniteLookbackTestCase +): + def setUp(self): + self.model = build_transformer_monotonic_attention( + **generate_config( + { + "simul_type": "chunkwise", + "mocha_chunk_size": 3 + } + ) + ) + + +class WaitkTestCase(InfiniteLookbackTestCase): + def setUp(self): + self.model = build_transformer_monotonic_attention( + **generate_config( + { + "simul_type": "waitk", + "waitk_lagging": 3, + } + ) + ) + + def check_waitk(self, p_choose, lagging, padding_mask): + bsz, tgt_len, src_len = p_choose.size() + for bsz_i in range(bsz): + for i in range(tgt_len): + for j in range(src_len): + if not padding_mask[bsz_i, j]: + if j - i == lagging - 1: + self.assertTrue(p_choose[bsz_i, i, j] == 1) + else: + self.assertTrue(p_choose[bsz_i, i, j] == 0) + + def test_waitk_p_choose(self): + for longer_src in [True, False]: + for k in [1, 3, 10, 20, 100]: + sample = make_sample_with_padding(longer_src) + model = build_transformer_monotonic_attention( + **generate_config( + { + "simul_type": "waitk", + "waitk_lagging": k, + } + ) + ) + model.train() + _, extra_out = model.forward(**sample["net_input"]) + for item in extra_out.attn_list: + p_choose = item["p_choose"] + bsz, num_heads, tgt_len, src_len = p_choose.size() + padding_mask = sample["net_input"]["src_tokens"].eq(PAD_INDEX) + padding_mask = ( + padding_mask + .unsqueeze(1) + .expand([bsz, num_heads, src_len]) + .contiguous() + .view(-1, src_len) + ) + p_choose = p_choose.view(bsz * num_heads, tgt_len, src_len) + self.check_waitk(p_choose, k, padding_mask) diff --git a/fairseq/examples/simultaneous_translation/utils/__init__.py b/fairseq/examples/simultaneous_translation/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1e9ce844f59a4211061392084cc81075e6bab19f --- /dev/null +++ b/fairseq/examples/simultaneous_translation/utils/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +# automatically import any Python files in the criterions/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + module = file[: file.find(".py")] + importlib.import_module("examples.simultaneous_translation.utils." + module) diff --git a/fairseq/examples/simultaneous_translation/utils/functions.py b/fairseq/examples/simultaneous_translation/utils/functions.py new file mode 100644 index 0000000000000000000000000000000000000000..590a6c11cea222ac9096b19f0e3dfe1b71b6c10b --- /dev/null +++ b/fairseq/examples/simultaneous_translation/utils/functions.py @@ -0,0 +1,125 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + + +def prob_check(tensor, eps=1e-10): + assert not torch.isnan(tensor).any(), ( + "Nan in a probability tensor." + ) + # Add the eps here to prevent errors introduced by precision + assert tensor.le(1.0 + eps).all() and tensor.ge(0.0 - eps).all(), ( + "Incorrect values in a probability tensor" + ", 0.0 <= tensor <= 1.0" + ) + + +def exclusive_cumprod(tensor, dim: int, eps: float = 1e-10): + """ + Implementing exclusive cumprod. + There is cumprod in pytorch, however there is no exclusive mode. + cumprod(x) = [x1, x1x2, x2x3x4, ..., prod_{i=1}^n x_i] + exclusive means + cumprod(x) = [1, x1, x1x2, x1x2x3, ..., prod_{i=1}^{n-1} x_i] + """ + tensor_size = list(tensor.size()) + tensor_size[dim] = 1 + return_tensor = safe_cumprod( + torch.cat([torch.ones(tensor_size).type_as(tensor), tensor], dim=dim), + dim=dim, + eps=eps, + ) + + if dim == 0: + return return_tensor[:-1] + elif dim == 1: + return return_tensor[:, :-1] + elif dim == 2: + return return_tensor[:, :, :-1] + else: + raise RuntimeError( + "Cumprod on dimension 3 and more is not implemented" + ) + + +def safe_cumprod(tensor, dim: int, eps: float = 1e-10): + """ + An implementation of cumprod to prevent precision issue. + cumprod(x) + = [x1, x1x2, x1x2x3, ....] + = [exp(log(x1)), exp(log(x1) + log(x2)), exp(log(x1) + log(x2) + log(x3)), ...] + = exp(cumsum(log(x))) + """ + + if (tensor + eps < 0).any().item(): + raise RuntimeError( + "Safe cumprod can only take non-negative tensors as input." + "Consider use torch.cumprod if you want to calculate negative values." + ) + + log_tensor = torch.log(tensor + eps) + cumsum_log_tensor = torch.cumsum(log_tensor, dim) + exp_cumsum_log_tensor = torch.exp(cumsum_log_tensor) + return exp_cumsum_log_tensor + + +def moving_sum(x, start_idx: int, end_idx: int): + """ + From MONOTONIC CHUNKWISE ATTENTION + https://arxiv.org/pdf/1712.05382.pdf + Equation (18) + + x = [x_1, x_2, ..., x_N] + MovingSum(x, start_idx, end_idx)_n = Sigma_{m=n−(start_idx−1)}^{n+end_idx-1} x_m + for n in {1, 2, 3, ..., N} + + x : src_len, batch_size + start_idx : start idx + end_idx : end idx + + Example + src_len = 5 + batch_size = 3 + x = + [[ 0, 5, 10], + [ 1, 6, 11], + [ 2, 7, 12], + [ 3, 8, 13], + [ 4, 9, 14]] + + MovingSum(x, 3, 1) = + [[ 0, 5, 10], + [ 1, 11, 21], + [ 3, 18, 33], + [ 6, 21, 36], + [ 9, 24, 39]] + + MovingSum(x, 1, 3) = + [[ 3, 18, 33], + [ 6, 21, 36], + [ 9, 24, 39], + [ 7, 17, 27], + [ 4, 9, 14]] + """ + # TODO: Make dimension configurable + assert start_idx > 0 and end_idx > 0 + batch_size, tgt_len, src_len = x.size() + x = x.view(-1, src_len).unsqueeze(1) + # batch_size, 1, src_len + moving_sum_weight = torch.ones([1, 1, end_idx + start_idx - 1]).type_as(x) + + moving_sum = torch.nn.functional.conv1d( + x, moving_sum_weight, padding=start_idx + end_idx - 1 + ).squeeze(1) + + moving_sum = moving_sum[:, end_idx:-start_idx] + + assert src_len == moving_sum.size(1) + assert batch_size * tgt_len == moving_sum.size(0) + + moving_sum = moving_sum.view(batch_size, tgt_len, src_len) + + return moving_sum diff --git a/fairseq/examples/simultaneous_translation/utils/monotonic_attention.py b/fairseq/examples/simultaneous_translation/utils/monotonic_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..61dbb112bfd5ea7b92f2739f046910f486bb0153 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/utils/monotonic_attention.py @@ -0,0 +1,198 @@ +from typing import Optional +import torch +from torch import Tensor + +from examples.simultaneous_translation.utils.functions import ( + exclusive_cumprod, + prob_check, + moving_sum, +) + + +def expected_alignment_from_p_choose( + p_choose: Tensor, + padding_mask: Optional[Tensor] = None, + eps: float = 1e-6 +): + """ + Calculating expected alignment for from stepwise probability + + Reference: + Online and Linear-Time Attention by Enforcing Monotonic Alignments + https://arxiv.org/pdf/1704.00784.pdf + + q_ij = (1 − p_{ij−1})q_{ij−1} + a+{i−1j} + a_ij = p_ij q_ij + + Parallel solution: + ai = p_i * cumprod(1 − pi) * cumsum(a_i / cumprod(1 − pi)) + + ============================================================ + Expected input size + p_choose: bsz, tgt_len, src_len + """ + prob_check(p_choose) + + # p_choose: bsz, tgt_len, src_len + bsz, tgt_len, src_len = p_choose.size() + dtype = p_choose.dtype + + p_choose = p_choose.float() + + if padding_mask is not None: + p_choose = p_choose.masked_fill(padding_mask.unsqueeze(1), 0.0) + + # cumprod_1mp : bsz, tgt_len, src_len + cumprod_1mp = exclusive_cumprod(1 - p_choose, dim=2, eps=eps) + cumprod_1mp_clamp = torch.clamp(cumprod_1mp, eps, 1.0) + + alpha_0 = p_choose.new_zeros([bsz, 1, src_len]) + alpha_0[:, :, 0] = 1.0 + + previous_alpha = [alpha_0] + + for i in range(tgt_len): + # p_choose: bsz , tgt_len, src_len + # cumprod_1mp_clamp : bsz, tgt_len, src_len + # previous_alpha[i]: bsz, 1, src_len + # alpha_i: bsz, src_len + alpha_i = ( + p_choose[:, i] + * cumprod_1mp[:, i] + * torch.cumsum( + previous_alpha[i][:, 0] / cumprod_1mp_clamp[:, i], dim=1 + ) + ).clamp(0, 1.0) + + previous_alpha.append(alpha_i.unsqueeze(1)) + + # alpha: bsz * num_heads, tgt_len, src_len + alpha = torch.cat(previous_alpha[1:], dim=1) + + # Mix precision to prevent overflow for fp16 + alpha = alpha.type(dtype) + + prob_check(alpha) + + return alpha + + +def expected_soft_attention( + alpha: Tensor, + soft_energy: Tensor, + padding_mask: Optional[Tensor] = None, + chunk_size: Optional[int] = None, + eps: float = 1e-10 +): + """ + Function to compute expected soft attention for + monotonic infinite lookback attention from + expected alignment and soft energy. + + Reference: + Monotonic Chunkwise Attention + https://arxiv.org/abs/1712.05382 + + Monotonic Infinite Lookback Attention for Simultaneous Machine Translation + https://arxiv.org/abs/1906.05218 + + alpha: bsz, tgt_len, src_len + soft_energy: bsz, tgt_len, src_len + padding_mask: bsz, src_len + left_padding: bool + """ + if padding_mask is not None: + alpha = alpha.masked_fill(padding_mask.unsqueeze(1), 0.0) + soft_energy = soft_energy.masked_fill( + padding_mask.unsqueeze(1), -float("inf") + ) + + prob_check(alpha) + + dtype = alpha.dtype + + alpha = alpha.float() + soft_energy = soft_energy.float() + + soft_energy = soft_energy - soft_energy.max(dim=2, keepdim=True)[0] + exp_soft_energy = torch.exp(soft_energy) + eps + + if chunk_size is not None: + # Chunkwise + beta = ( + exp_soft_energy + * moving_sum( + alpha / (eps + moving_sum(exp_soft_energy, chunk_size, 1)), + 1, chunk_size + ) + ) + else: + # Infinite lookback + # Notice that infinite lookback is a special case of chunkwise + # where chunksize = inf + inner_items = alpha / (eps + torch.cumsum(exp_soft_energy, dim=2)) + + beta = ( + exp_soft_energy + * torch.cumsum(inner_items.flip(dims=[2]), dim=2) + .flip(dims=[2]) + ) + + if padding_mask is not None: + beta = beta.masked_fill( + padding_mask.unsqueeze(1).to(torch.bool), 0.0) + + # Mix precision to prevent overflow for fp16 + beta = beta.type(dtype) + + beta = beta.clamp(0, 1) + + prob_check(beta) + + return beta + + +def mass_preservation( + alpha: Tensor, + padding_mask: Optional[Tensor] = None, + left_padding: bool = False +): + """ + Function to compute the mass perservation for alpha. + This means that the residual weights of alpha will be assigned + to the last token. + + Reference: + Monotonic Infinite Lookback Attention for Simultaneous Machine Translation + https://arxiv.org/abs/1906.05218 + + alpha: bsz, tgt_len, src_len + padding_mask: bsz, src_len + left_padding: bool + """ + + prob_check(alpha) + + if padding_mask is not None: + if not left_padding: + assert not padding_mask[:, 0].any(), ( + "Find padding on the beginning of the sequence." + ) + alpha = alpha.masked_fill(padding_mask.unsqueeze(1), 0.0) + + if left_padding or padding_mask is None: + residuals = 1 - alpha[:, :, :-1].sum(dim=-1).clamp(0, 1) + alpha[:, :, -1] = residuals + else: + # right padding + _, tgt_len, src_len = alpha.size() + residuals = 1 - alpha.sum(dim=-1, keepdim=True).clamp(0, 1) + src_lens = src_len - padding_mask.sum(dim=1, keepdim=True) + src_lens = src_lens.expand(-1, tgt_len).contiguous() + # add back the last value + residuals += alpha.gather(2, src_lens.unsqueeze(2) - 1) + alpha = alpha.scatter(2, src_lens.unsqueeze(2) - 1, residuals) + + prob_check(alpha) + + return alpha diff --git a/fairseq/examples/simultaneous_translation/utils/p_choose_strategy.py b/fairseq/examples/simultaneous_translation/utils/p_choose_strategy.py new file mode 100644 index 0000000000000000000000000000000000000000..724c6912a62d48fc61988cac1434a4f5c8754521 --- /dev/null +++ b/fairseq/examples/simultaneous_translation/utils/p_choose_strategy.py @@ -0,0 +1,126 @@ +from typing import Optional, Dict +from torch import Tensor +import torch + + +def waitk_p_choose( + tgt_len: int, + src_len: int, + bsz: int, + waitk_lagging: int, + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None +): + + max_src_len = src_len + if incremental_state is not None: + # Retrieve target length from incremental states + # For inference the length of query is always 1 + max_tgt_len = incremental_state["steps"]["tgt"] + assert max_tgt_len is not None + max_tgt_len = int(max_tgt_len) + else: + max_tgt_len = tgt_len + + if max_src_len < waitk_lagging: + if incremental_state is not None: + max_tgt_len = 1 + return torch.zeros( + bsz, max_tgt_len, max_src_len + ) + + # Assuming the p_choose looks like this for wait k=3 + # src_len = 6, max_tgt_len = 5 + # [0, 0, 1, 0, 0, 0, 0] + # [0, 0, 0, 1, 0, 0, 0] + # [0, 0, 0, 0, 1, 0, 0] + # [0, 0, 0, 0, 0, 1, 0] + # [0, 0, 0, 0, 0, 0, 1] + # linearize the p_choose matrix: + # [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0...] + # The indices of linearized matrix that equals 1 is + # 2 + 6 * 0 + # 3 + 6 * 1 + # ... + # n + src_len * n + k - 1 = n * (src_len + 1) + k - 1 + # n from 0 to max_tgt_len - 1 + # + # First, generate the indices (activate_indices_offset: bsz, max_tgt_len) + # Second, scatter a zeros tensor (bsz, max_tgt_len * src_len) + # with activate_indices_offset + # Third, resize the tensor to (bsz, max_tgt_len, src_len) + + activate_indices_offset = ( + ( + torch.arange(max_tgt_len) * (max_src_len + 1) + + waitk_lagging - 1 + ) + .unsqueeze(0) + .expand(bsz, max_tgt_len) + .long() + ) + + if key_padding_mask is not None: + if key_padding_mask[:, 0].any(): + # Left padding + activate_indices_offset += ( + key_padding_mask.sum(dim=1, keepdim=True) + ) + + # Need to clamp the indices that are too large + activate_indices_offset = ( + activate_indices_offset + .clamp( + 0, + min( + [ + max_tgt_len, + max_src_len - waitk_lagging + 1 + ] + ) * max_src_len - 1 + ) + ) + + p_choose = torch.zeros(bsz, max_tgt_len * max_src_len) + + p_choose = p_choose.scatter( + 1, + activate_indices_offset, + 1.0 + ).view(bsz, max_tgt_len, max_src_len) + + if key_padding_mask is not None: + p_choose = p_choose.to(key_padding_mask) + p_choose = p_choose.masked_fill(key_padding_mask.unsqueeze(1), 0) + + if incremental_state is not None: + p_choose = p_choose[:, -1:] + + return p_choose.float() + + +def learnable_p_choose( + energy, + noise_mean: float = 0.0, + noise_var: float = 0.0, + training: bool = True +): + """ + Calculating step wise prob for reading and writing + 1 to read, 0 to write + energy: bsz, tgt_len, src_len + """ + + noise = 0 + if training: + # add noise here to encourage discretness + noise = ( + torch.normal(noise_mean, noise_var, energy.size()) + .type_as(energy) + .to(energy.device) + ) + + p_choose = torch.sigmoid(energy + noise) + + # p_choose: bsz * self.num_heads, tgt_len, src_len + return p_choose diff --git a/fairseq/examples/speech_recognition/README.md b/fairseq/examples/speech_recognition/README.md new file mode 100644 index 0000000000000000000000000000000000000000..17030bf0fd50bb843a508e13e97ed436eae33287 --- /dev/null +++ b/fairseq/examples/speech_recognition/README.md @@ -0,0 +1,83 @@ +### 2021 Update: We are merging this example into the [S2T framework](../speech_to_text), which supports more generic speech-to-text tasks (e.g. speech translation) and more flexible data processing pipelines. Please stay tuned. + +# Speech Recognition +`examples/speech_recognition` is implementing ASR task in Fairseq, along with needed features, datasets, models and loss functions to train and infer model described in [Transformers with convolutional context for ASR (Abdelrahman Mohamed et al., 2019)](https://arxiv.org/abs/1904.11660). + + +## Additional dependencies +On top of main fairseq dependencies there are couple more additional requirements. + +1) Please follow the instructions to install [torchaudio](https://github.com/pytorch/audio). This is required to compute audio fbank features. +2) [Sclite](http://www1.icsi.berkeley.edu/Speech/docs/sctk-1.2/sclite.htm#sclite_name_0) is used to measure WER. Sclite can be downloaded and installed from source from sctk package [here](http://www.openslr.org/4/). Training and inference doesn't require Sclite dependency. +3) [sentencepiece](https://github.com/google/sentencepiece) is required in order to create dataset with word-piece targets. + +## Preparing librispeech data +``` +./examples/speech_recognition/datasets/prepare-librispeech.sh $DIR_TO_SAVE_RAW_DATA $DIR_FOR_PREPROCESSED_DATA +``` + +## Training librispeech data +``` +python train.py $DIR_FOR_PREPROCESSED_DATA --save-dir $MODEL_PATH --max-epoch 80 --task speech_recognition --arch vggtransformer_2 --optimizer adadelta --lr 1.0 --adadelta-eps 1e-8 --adadelta-rho 0.95 --clip-norm 10.0 --max-tokens 5000 --log-format json --log-interval 1 --criterion cross_entropy_acc --user-dir examples/speech_recognition/ +``` + +## Inference for librispeech +`$SET` can be `test_clean` or `test_other` +Any checkpoint in `$MODEL_PATH` can be selected. In this example we are working with `checkpoint_last.pt` +``` +python examples/speech_recognition/infer.py $DIR_FOR_PREPROCESSED_DATA --task speech_recognition --max-tokens 25000 --nbest 1 --path $MODEL_PATH/checkpoint_last.pt --beam 20 --results-path $RES_DIR --batch-size 40 --gen-subset $SET --user-dir examples/speech_recognition/ +``` + +## Inference for librispeech +``` +sclite -r ${RES_DIR}/ref.word-checkpoint_last.pt-${SET}.txt -h ${RES_DIR}/hypo.word-checkpoint_last.pt-${SET}.txt -i rm -o all stdout > $RES_REPORT +``` +`Sum/Avg` row from first table of the report has WER + +## Using flashlight (previously called [wav2letter](https://github.com/facebookresearch/wav2letter)) components +[flashlight](https://github.com/facebookresearch/flashlight) now has integration with fairseq. Currently this includes: + +* AutoSegmentationCriterion (ASG) +* flashlight-style Conv/GLU model +* flashlight's beam search decoder + +To use these, follow the instructions on [this page](https://github.com/facebookresearch/flashlight/tree/master/bindings/python) to install python bindings. + +## Training librispeech data (flashlight style, Conv/GLU + ASG loss) +Training command: +``` +python train.py $DIR_FOR_PREPROCESSED_DATA --save-dir $MODEL_PATH --max-epoch 100 --task speech_recognition --arch w2l_conv_glu_enc --batch-size 4 --optimizer sgd --lr 0.3,0.8 --momentum 0.8 --clip-norm 0.2 --max-tokens 50000 --log-format json --log-interval 100 --num-workers 0 --sentence-avg --criterion asg_loss --asg-transitions-init 5 --max-replabel 2 --linseg-updates 8789 --user-dir examples/speech_recognition +``` + +Note that ASG loss currently doesn't do well with word-pieces. You should prepare a dataset with character targets by setting `nbpe=31` in `prepare-librispeech.sh`. + +## Inference for librispeech (flashlight decoder, n-gram LM) +Inference command: +``` +python examples/speech_recognition/infer.py $DIR_FOR_PREPROCESSED_DATA --task speech_recognition --seed 1 --nbest 1 --path $MODEL_PATH/checkpoint_last.pt --gen-subset $SET --results-path $RES_DIR --w2l-decoder kenlm --kenlm-model $KENLM_MODEL_PATH --lexicon $LEXICON_PATH --beam 200 --beam-threshold 15 --lm-weight 1.5 --word-score 1.5 --sil-weight -0.3 --criterion asg_loss --max-replabel 2 --user-dir examples/speech_recognition +``` + +`$KENLM_MODEL_PATH` should be a standard n-gram language model file. `$LEXICON_PATH` should be a flashlight-style lexicon (list of known words and their spellings). For ASG inference, a lexicon line should look like this (note the repetition labels): +``` +doorbell D O 1 R B E L 1 ▁ +``` +For CTC inference with word-pieces, repetition labels are not used and the lexicon should have most common spellings for each word (one can use sentencepiece's `NBestEncodeAsPieces` for this): +``` +doorbell ▁DOOR BE LL +doorbell ▁DOOR B E LL +doorbell ▁DO OR BE LL +doorbell ▁DOOR B EL L +doorbell ▁DOOR BE L L +doorbell ▁DO OR B E LL +doorbell ▁DOOR B E L L +doorbell ▁DO OR B EL L +doorbell ▁DO O R BE LL +doorbell ▁DO OR BE L L +``` +Lowercase vs. uppercase matters: the *word* should match the case of the n-gram language model (i.e. `$KENLM_MODEL_PATH`), while the *spelling* should match the case of the token dictionary (i.e. `$DIR_FOR_PREPROCESSED_DATA/dict.txt`). + +## Inference for librispeech (flashlight decoder, viterbi only) +Inference command: +``` +python examples/speech_recognition/infer.py $DIR_FOR_PREPROCESSED_DATA --task speech_recognition --seed 1 --nbest 1 --path $MODEL_PATH/checkpoint_last.pt --gen-subset $SET --results-path $RES_DIR --w2l-decoder viterbi --criterion asg_loss --max-replabel 2 --user-dir examples/speech_recognition +``` diff --git a/fairseq/examples/speech_recognition/__init__.py b/fairseq/examples/speech_recognition/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0278f6a27340c7ff7e207d09348483d1b0d3a100 --- /dev/null +++ b/fairseq/examples/speech_recognition/__init__.py @@ -0,0 +1 @@ +from . import criterions, models, tasks # noqa diff --git a/fairseq/examples/speech_recognition/criterions/ASG_loss.py b/fairseq/examples/speech_recognition/criterions/ASG_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..41f50bbd70388ce723f2d316d4e9776bcd6be3c9 --- /dev/null +++ b/fairseq/examples/speech_recognition/criterions/ASG_loss.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from examples.speech_recognition.data.replabels import pack_replabels +from fairseq import utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +@register_criterion("asg_loss") +class ASGCriterion(FairseqCriterion): + @staticmethod + def add_args(parser): + group = parser.add_argument_group("ASG Loss") + group.add_argument( + "--asg-transitions-init", + help="initial diagonal value of transition matrix", + type=float, + default=0.0, + ) + group.add_argument( + "--max-replabel", help="maximum # of replabels", type=int, default=2 + ) + group.add_argument( + "--linseg-updates", + help="# of training updates to use LinSeg initialization", + type=int, + default=0, + ) + group.add_argument( + "--hide-linseg-messages", + help="hide messages about LinSeg initialization", + action="store_true", + ) + + def __init__( + self, + task, + silence_token, + asg_transitions_init, + max_replabel, + linseg_updates, + hide_linseg_messages, + ): + from flashlight.lib.sequence.criterion import ASGLoss, CriterionScaleMode + + super().__init__(task) + self.tgt_dict = task.target_dictionary + self.eos = self.tgt_dict.eos() + self.silence = ( + self.tgt_dict.index(silence_token) + if silence_token in self.tgt_dict + else None + ) + self.max_replabel = max_replabel + + num_labels = len(self.tgt_dict) + self.asg = ASGLoss(num_labels, scale_mode=CriterionScaleMode.TARGET_SZ_SQRT) + self.asg.trans = torch.nn.Parameter( + asg_transitions_init * torch.eye(num_labels), requires_grad=True + ) + + self.linseg_progress = torch.nn.Parameter( + torch.tensor([0], dtype=torch.int), requires_grad=False + ) + self.linseg_maximum = linseg_updates + self.linseg_message_state = "none" if hide_linseg_messages else "start" + + @classmethod + def build_criterion(cls, args, task): + return cls( + task, + args.silence_token, + args.asg_transitions_init, + args.max_replabel, + args.linseg_updates, + args.hide_linseg_messages, + ) + + def linseg_step(self): + if not self.training: + return False + if self.linseg_progress.item() < self.linseg_maximum: + if self.linseg_message_state == "start": + print("| using LinSeg to initialize ASG") + self.linseg_message_state = "finish" + self.linseg_progress.add_(1) + return True + elif self.linseg_message_state == "finish": + print("| finished LinSeg initialization") + self.linseg_message_state = "none" + return False + + def replace_eos_with_silence(self, tgt): + if tgt[-1] != self.eos: + return tgt + elif self.silence is None or (len(tgt) > 1 and tgt[-2] == self.silence): + return tgt[:-1] + else: + return tgt[:-1] + [self.silence] + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + + net_output = model(**sample["net_input"]) + emissions = net_output["encoder_out"].transpose(0, 1).contiguous() + B = emissions.size(0) + T = emissions.size(1) + device = emissions.device + + target = torch.IntTensor(B, T) + target_size = torch.IntTensor(B) + using_linseg = self.linseg_step() + + for b in range(B): + initial_target_size = sample["target_lengths"][b].item() + if initial_target_size == 0: + raise ValueError("target size cannot be zero") + + tgt = sample["target"][b, :initial_target_size].tolist() + tgt = self.replace_eos_with_silence(tgt) + tgt = pack_replabels(tgt, self.tgt_dict, self.max_replabel) + tgt = tgt[:T] + + if using_linseg: + tgt = [tgt[t * len(tgt) // T] for t in range(T)] + + target[b][: len(tgt)] = torch.IntTensor(tgt) + target_size[b] = len(tgt) + + loss = self.asg.forward(emissions, target.to(device), target_size.to(device)) + + if reduce: + loss = torch.sum(loss) + + sample_size = ( + sample["target"].size(0) if self.args.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + agg_output = { + "loss": loss_sum / nsentences, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + return agg_output diff --git a/fairseq/examples/speech_recognition/criterions/__init__.py b/fairseq/examples/speech_recognition/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..579abd2ace1b14b80f5e53e5c96583e4d5b14c52 --- /dev/null +++ b/fairseq/examples/speech_recognition/criterions/__init__.py @@ -0,0 +1,17 @@ +import importlib +import os + + +# ASG loss requires flashlight bindings +files_to_skip = set() +try: + import flashlight.lib.sequence.criterion +except ImportError: + files_to_skip.add("ASG_loss.py") + +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_") and file not in files_to_skip: + criterion_name = file[: file.find(".py")] + importlib.import_module( + "examples.speech_recognition.criterions." + criterion_name + ) diff --git a/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py b/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py new file mode 100644 index 0000000000000000000000000000000000000000..7c4d8ba3802a2da9467c42b0aa18653c7bbb2ec9 --- /dev/null +++ b/fairseq/examples/speech_recognition/criterions/cross_entropy_acc.py @@ -0,0 +1,130 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import logging +import math + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +@register_criterion("cross_entropy_acc") +class CrossEntropyWithAccCriterion(FairseqCriterion): + def __init__(self, task, sentence_avg): + super().__init__(task) + self.sentence_avg = sentence_avg + + def compute_loss(self, model, net_output, target, reduction, log_probs): + # N, T -> N * T + target = target.view(-1) + lprobs = model.get_normalized_probs(net_output, log_probs=log_probs) + if not hasattr(lprobs, "batch_first"): + logging.warning( + "ERROR: we need to know whether " + "batch first for the net output; " + "you need to set batch_first attribute for the return value of " + "model.get_normalized_probs. Now, we assume this is true, but " + "in the future, we will raise exception instead. " + ) + batch_first = getattr(lprobs, "batch_first", True) + if not batch_first: + lprobs = lprobs.transpose(0, 1) + + # N, T, D -> N * T, D + lprobs = lprobs.view(-1, lprobs.size(-1)) + loss = F.nll_loss( + lprobs, target, ignore_index=self.padding_idx, reduction=reduction + ) + return lprobs, loss + + def get_logging_output(self, sample, target, lprobs, loss): + target = target.view(-1) + mask = target != self.padding_idx + correct = torch.sum( + lprobs.argmax(1).masked_select(mask) == target.masked_select(mask) + ) + total = torch.sum(mask) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + + logging_output = { + "loss": utils.item(loss.data), # * sample['ntokens'], + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + "correct": utils.item(correct.data), + "total": utils.item(total.data), + "nframes": torch.sum(sample["net_input"]["src_lengths"]).item(), + } + + return sample_size, logging_output + + def forward(self, model, sample, reduction="sum", log_probs=True): + """Computes the cross entropy with accuracy metric for the given sample. + + This is similar to CrossEntropyCriterion in fairseq, but also + computes accuracy metrics as part of logging + + Args: + logprobs (Torch.tensor) of shape N, T, D i.e. + batchsize, timesteps, dimensions + targets (Torch.tensor) of shape N, T i.e batchsize, timesteps + + Returns: + tuple: With three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + + TODO: + * Currently this Criterion will only work with LSTMEncoderModels or + FairseqModels which have decoder, or Models which return TorchTensor + as net_output. + We need to make a change to support all FairseqEncoder models. + """ + net_output = model(**sample["net_input"]) + target = model.get_targets(sample, net_output) + lprobs, loss = self.compute_loss( + model, net_output, target, reduction, log_probs + ) + sample_size, logging_output = self.get_logging_output( + sample, target, lprobs, loss + ) + return loss, sample_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + correct_sum = sum(log.get("correct", 0) for log in logging_outputs) + total_sum = sum(log.get("total", 0) for log in logging_outputs) + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + nframes = sum(log.get("nframes", 0) for log in logging_outputs) + agg_output = { + "loss": loss_sum / sample_size / math.log(2) if sample_size > 0 else 0.0, + # if args.sentence_avg, then sample_size is nsentences, then loss + # is per-sentence loss; else sample_size is ntokens, the loss + # becomes per-output token loss + "ntokens": ntokens, + "nsentences": nsentences, + "nframes": nframes, + "sample_size": sample_size, + "acc": correct_sum * 100.0 / total_sum if total_sum > 0 else 0.0, + "correct": correct_sum, + "total": total_sum, + # total is the number of validate tokens + } + if sample_size != ntokens: + agg_output["nll_loss"] = loss_sum / ntokens / math.log(2) + # loss: per output token loss + # nll_loss: per sentence loss + return agg_output diff --git a/fairseq/examples/speech_recognition/data/__init__.py b/fairseq/examples/speech_recognition/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..47bb6e24ddf25aa4fd5bf0fe9672f89099efb9b4 --- /dev/null +++ b/fairseq/examples/speech_recognition/data/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .asr_dataset import AsrDataset + + +__all__ = [ + "AsrDataset", +] diff --git a/fairseq/examples/speech_recognition/data/asr_dataset.py b/fairseq/examples/speech_recognition/data/asr_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..63a6fcac85d73b1fce8e4d044b4209b1b67fa8ce --- /dev/null +++ b/fairseq/examples/speech_recognition/data/asr_dataset.py @@ -0,0 +1,122 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os + +import numpy as np +from fairseq.data import FairseqDataset + +from . import data_utils +from .collaters import Seq2SeqCollater + + +class AsrDataset(FairseqDataset): + """ + A dataset representing speech and corresponding transcription. + + Args: + aud_paths: (List[str]): A list of str with paths to audio files. + aud_durations_ms (List[int]): A list of int containing the durations of + audio files. + tgt (List[torch.LongTensor]): A list of LongTensors containing the indices + of target transcriptions. + tgt_dict (~fairseq.data.Dictionary): target vocabulary. + ids (List[str]): A list of utterance IDs. + speakers (List[str]): A list of speakers corresponding to utterances. + num_mel_bins (int): Number of triangular mel-frequency bins (default: 80) + frame_length (float): Frame length in milliseconds (default: 25.0) + frame_shift (float): Frame shift in milliseconds (default: 10.0) + """ + + def __init__( + self, + aud_paths, + aud_durations_ms, + tgt, + tgt_dict, + ids, + speakers, + num_mel_bins=80, + frame_length=25.0, + frame_shift=10.0, + ): + assert frame_length > 0 + assert frame_shift > 0 + assert all(x > frame_length for x in aud_durations_ms) + self.frame_sizes = [ + int(1 + (d - frame_length) / frame_shift) for d in aud_durations_ms + ] + + assert len(aud_paths) > 0 + assert len(aud_paths) == len(aud_durations_ms) + assert len(aud_paths) == len(tgt) + assert len(aud_paths) == len(ids) + assert len(aud_paths) == len(speakers) + self.aud_paths = aud_paths + self.tgt_dict = tgt_dict + self.tgt = tgt + self.ids = ids + self.speakers = speakers + self.num_mel_bins = num_mel_bins + self.frame_length = frame_length + self.frame_shift = frame_shift + + self.s2s_collater = Seq2SeqCollater( + 0, + 1, + pad_index=self.tgt_dict.pad(), + eos_index=self.tgt_dict.eos(), + move_eos_to_beginning=True, + ) + + def __getitem__(self, index): + import torchaudio + import torchaudio.compliance.kaldi as kaldi + + tgt_item = self.tgt[index] if self.tgt is not None else None + + path = self.aud_paths[index] + if not os.path.exists(path): + raise FileNotFoundError("Audio file not found: {}".format(path)) + sound, sample_rate = torchaudio.load_wav(path) + output = kaldi.fbank( + sound, + num_mel_bins=self.num_mel_bins, + frame_length=self.frame_length, + frame_shift=self.frame_shift, + ) + output_cmvn = data_utils.apply_mv_norm(output) + + return {"id": index, "data": [output_cmvn.detach(), tgt_item]} + + def __len__(self): + return len(self.aud_paths) + + def collater(self, samples): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[int]): sample indices to collate + + Returns: + dict: a mini-batch suitable for forwarding with a Model + """ + return self.s2s_collater.collate(samples) + + def num_tokens(self, index): + return self.frame_sizes[index] + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + return ( + self.frame_sizes[index], + len(self.tgt[index]) if self.tgt is not None else 0, + ) + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + return np.arange(len(self)) diff --git a/fairseq/examples/speech_recognition/data/collaters.py b/fairseq/examples/speech_recognition/data/collaters.py new file mode 100644 index 0000000000000000000000000000000000000000..6acfec876b87e5a00bc92083b1181301a2a18e3f --- /dev/null +++ b/fairseq/examples/speech_recognition/data/collaters.py @@ -0,0 +1,131 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" + This module contains collection of classes which implement + collate functionalities for various tasks. + + Collaters should know what data to expect for each sample + and they should pack / collate them into batches +""" + + +from __future__ import absolute_import, division, print_function, unicode_literals + +import numpy as np +import torch +from fairseq.data import data_utils as fairseq_data_utils + + +class Seq2SeqCollater(object): + """ + Implements collate function mainly for seq2seq tasks + This expects each sample to contain feature (src_tokens) and + targets. + This collator is also used for aligned training task. + """ + + def __init__( + self, + feature_index=0, + label_index=1, + pad_index=1, + eos_index=2, + move_eos_to_beginning=True, + ): + self.feature_index = feature_index + self.label_index = label_index + self.pad_index = pad_index + self.eos_index = eos_index + self.move_eos_to_beginning = move_eos_to_beginning + + def _collate_frames(self, frames): + """Convert a list of 2d frames into a padded 3d tensor + Args: + frames (list): list of 2d frames of size L[i]*f_dim. Where L[i] is + length of i-th frame and f_dim is static dimension of features + Returns: + 3d tensor of size len(frames)*len_max*f_dim where len_max is max of L[i] + """ + len_max = max(frame.size(0) for frame in frames) + f_dim = frames[0].size(1) + res = frames[0].new(len(frames), len_max, f_dim).fill_(0.0) + + for i, v in enumerate(frames): + res[i, : v.size(0)] = v + + return res + + def collate(self, samples): + """ + utility function to collate samples into batch for speech recognition. + """ + if len(samples) == 0: + return {} + + # parse samples into torch tensors + parsed_samples = [] + for s in samples: + # skip invalid samples + if s["data"][self.feature_index] is None: + continue + source = s["data"][self.feature_index] + if isinstance(source, (np.ndarray, np.generic)): + source = torch.from_numpy(source) + target = s["data"][self.label_index] + if isinstance(target, (np.ndarray, np.generic)): + target = torch.from_numpy(target).long() + elif isinstance(target, list): + target = torch.LongTensor(target) + + parsed_sample = {"id": s["id"], "source": source, "target": target} + parsed_samples.append(parsed_sample) + samples = parsed_samples + + id = torch.LongTensor([s["id"] for s in samples]) + frames = self._collate_frames([s["source"] for s in samples]) + # sort samples by descending number of frames + frames_lengths = torch.LongTensor([s["source"].size(0) for s in samples]) + frames_lengths, sort_order = frames_lengths.sort(descending=True) + id = id.index_select(0, sort_order) + frames = frames.index_select(0, sort_order) + + target = None + target_lengths = None + prev_output_tokens = None + if samples[0].get("target", None) is not None: + ntokens = sum(len(s["target"]) for s in samples) + target = fairseq_data_utils.collate_tokens( + [s["target"] for s in samples], + self.pad_index, + self.eos_index, + left_pad=False, + move_eos_to_beginning=False, + ) + target = target.index_select(0, sort_order) + target_lengths = torch.LongTensor( + [s["target"].size(0) for s in samples] + ).index_select(0, sort_order) + prev_output_tokens = fairseq_data_utils.collate_tokens( + [s["target"] for s in samples], + self.pad_index, + self.eos_index, + left_pad=False, + move_eos_to_beginning=self.move_eos_to_beginning, + ) + prev_output_tokens = prev_output_tokens.index_select(0, sort_order) + else: + ntokens = sum(len(s["source"]) for s in samples) + + batch = { + "id": id, + "ntokens": ntokens, + "net_input": {"src_tokens": frames, "src_lengths": frames_lengths}, + "target": target, + "target_lengths": target_lengths, + "nsentences": len(samples), + } + if prev_output_tokens is not None: + batch["net_input"]["prev_output_tokens"] = prev_output_tokens + return batch diff --git a/fairseq/examples/speech_recognition/data/data_utils.py b/fairseq/examples/speech_recognition/data/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cc4729e63c8ef551b29617d1169a44c24f509ad0 --- /dev/null +++ b/fairseq/examples/speech_recognition/data/data_utils.py @@ -0,0 +1,100 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + + +def calc_mean_invstddev(feature): + if len(feature.size()) != 2: + raise ValueError("We expect the input feature to be 2-D tensor") + mean = feature.mean(0) + var = feature.var(0) + # avoid division by ~zero + eps = 1e-8 + if (var < eps).any(): + return mean, 1.0 / (torch.sqrt(var) + eps) + return mean, 1.0 / torch.sqrt(var) + + +def apply_mv_norm(features): + # If there is less than 2 spectrograms, the variance cannot be computed (is NaN) + # and normalization is not possible, so return the item as it is + if features.size(0) < 2: + return features + mean, invstddev = calc_mean_invstddev(features) + res = (features - mean) * invstddev + return res + + +def lengths_to_encoder_padding_mask(lengths, batch_first=False): + """ + convert lengths (a 1-D Long/Int tensor) to 2-D binary tensor + + Args: + lengths: a (B, )-shaped tensor + + Return: + max_length: maximum length of B sequences + encoder_padding_mask: a (max_length, B) binary mask, where + [t, b] = 0 for t < lengths[b] and 1 otherwise + + TODO: + kernelize this function if benchmarking shows this function is slow + """ + max_lengths = torch.max(lengths).item() + bsz = lengths.size(0) + encoder_padding_mask = torch.arange( + max_lengths + ).to( # a (T, ) tensor with [0, ..., T-1] + lengths.device + ).view( # move to the right device + 1, max_lengths + ).expand( # reshape to (1, T)-shaped tensor + bsz, -1 + ) >= lengths.view( # expand to (B, T)-shaped tensor + bsz, 1 + ).expand( + -1, max_lengths + ) + if not batch_first: + return encoder_padding_mask.t(), max_lengths + else: + return encoder_padding_mask, max_lengths + + +def encoder_padding_mask_to_lengths( + encoder_padding_mask, max_lengths, batch_size, device +): + """ + convert encoder_padding_mask (2-D binary tensor) to a 1-D tensor + + Conventionally, encoder output contains a encoder_padding_mask, which is + a 2-D mask in a shape (T, B), whose (t, b) element indicate whether + encoder_out[t, b] is a valid output (=0) or not (=1). Occasionally, we + need to convert this mask tensor to a 1-D tensor in shape (B, ), where + [b] denotes the valid length of b-th sequence + + Args: + encoder_padding_mask: a (T, B)-shaped binary tensor or None; if None, + indicating all are valid + Return: + seq_lengths: a (B,)-shaped tensor, where its (b, )-th element is the + number of valid elements of b-th sequence + + max_lengths: maximum length of all sequence, if encoder_padding_mask is + not None, max_lengths must equal to encoder_padding_mask.size(0) + + batch_size: batch size; if encoder_padding_mask is + not None, max_lengths must equal to encoder_padding_mask.size(1) + + device: which device to put the result on + """ + if encoder_padding_mask is None: + return torch.Tensor([max_lengths] * batch_size).to(torch.int32).to(device) + + assert encoder_padding_mask.size(0) == max_lengths, "max_lengths does not match" + assert encoder_padding_mask.size(1) == batch_size, "batch_size does not match" + + return max_lengths - torch.sum(encoder_padding_mask, dim=0) diff --git a/fairseq/examples/speech_recognition/data/replabels.py b/fairseq/examples/speech_recognition/data/replabels.py new file mode 100644 index 0000000000000000000000000000000000000000..441f1bd432b95865fc981c6c695cee299b07ed62 --- /dev/null +++ b/fairseq/examples/speech_recognition/data/replabels.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Replabel transforms for use with flashlight's ASG criterion. +""" + + +def replabel_symbol(i): + """ + Replabel symbols used in flashlight, currently just "1", "2", ... + This prevents training with numeral tokens, so this might change in the future + """ + return str(i) + + +def pack_replabels(tokens, dictionary, max_reps): + """ + Pack a token sequence so that repeated symbols are replaced by replabels + """ + if len(tokens) == 0 or max_reps <= 0: + return tokens + + replabel_value_to_idx = [0] * (max_reps + 1) + for i in range(1, max_reps + 1): + replabel_value_to_idx[i] = dictionary.index(replabel_symbol(i)) + + result = [] + prev_token = -1 + num_reps = 0 + for token in tokens: + if token == prev_token and num_reps < max_reps: + num_reps += 1 + else: + if num_reps > 0: + result.append(replabel_value_to_idx[num_reps]) + num_reps = 0 + result.append(token) + prev_token = token + if num_reps > 0: + result.append(replabel_value_to_idx[num_reps]) + return result + + +def unpack_replabels(tokens, dictionary, max_reps): + """ + Unpack a token sequence so that replabels are replaced by repeated symbols + """ + if len(tokens) == 0 or max_reps <= 0: + return tokens + + replabel_idx_to_value = {} + for i in range(1, max_reps + 1): + replabel_idx_to_value[dictionary.index(replabel_symbol(i))] = i + + result = [] + prev_token = -1 + for token in tokens: + try: + for _ in range(replabel_idx_to_value[token]): + result.append(prev_token) + prev_token = -1 + except KeyError: + result.append(token) + prev_token = token + return result diff --git a/fairseq/examples/speech_recognition/datasets/asr_prep_json.py b/fairseq/examples/speech_recognition/datasets/asr_prep_json.py new file mode 100644 index 0000000000000000000000000000000000000000..b8db8ff16691158fae034a8ab3faad622b351caf --- /dev/null +++ b/fairseq/examples/speech_recognition/datasets/asr_prep_json.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import argparse +import concurrent.futures +import json +import multiprocessing +import os +from collections import namedtuple +from itertools import chain + +import sentencepiece as spm +from fairseq.data import Dictionary + + +MILLISECONDS_TO_SECONDS = 0.001 + + +def process_sample(aud_path, lable, utt_id, sp, tgt_dict): + import torchaudio + + input = {} + output = {} + si, ei = torchaudio.info(aud_path) + input["length_ms"] = int( + si.length / si.channels / si.rate / MILLISECONDS_TO_SECONDS + ) + input["path"] = aud_path + + token = " ".join(sp.EncodeAsPieces(lable)) + ids = tgt_dict.encode_line(token, append_eos=False) + output["text"] = lable + output["token"] = token + output["tokenid"] = ", ".join(map(str, [t.tolist() for t in ids])) + return {utt_id: {"input": input, "output": output}} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--audio-dirs", + nargs="+", + default=["-"], + required=True, + help="input directories with audio files", + ) + parser.add_argument( + "--labels", + required=True, + help="aggregated input labels with format <ID LABEL> per line", + type=argparse.FileType("r", encoding="UTF-8"), + ) + parser.add_argument( + "--spm-model", + required=True, + help="sentencepiece model to use for encoding", + type=argparse.FileType("r", encoding="UTF-8"), + ) + parser.add_argument( + "--dictionary", + required=True, + help="file to load fairseq dictionary from", + type=argparse.FileType("r", encoding="UTF-8"), + ) + parser.add_argument("--audio-format", choices=["flac", "wav"], default="wav") + parser.add_argument( + "--output", + required=True, + type=argparse.FileType("w"), + help="path to save json output", + ) + args = parser.parse_args() + + sp = spm.SentencePieceProcessor() + sp.Load(args.spm_model.name) + + tgt_dict = Dictionary.load(args.dictionary) + + labels = {} + for line in args.labels: + (utt_id, label) = line.split(" ", 1) + labels[utt_id] = label + if len(labels) == 0: + raise Exception("No labels found in ", args.labels_path) + + Sample = namedtuple("Sample", "aud_path utt_id") + samples = [] + for path, _, files in chain.from_iterable( + os.walk(path) for path in args.audio_dirs + ): + for f in files: + if f.endswith(args.audio_format): + if len(os.path.splitext(f)) != 2: + raise Exception("Expect <utt_id.extension> file name. Got: ", f) + utt_id = os.path.splitext(f)[0] + if utt_id not in labels: + continue + samples.append(Sample(os.path.join(path, f), utt_id)) + + utts = {} + num_cpu = multiprocessing.cpu_count() + with concurrent.futures.ThreadPoolExecutor(max_workers=num_cpu) as executor: + future_to_sample = { + executor.submit( + process_sample, s.aud_path, labels[s.utt_id], s.utt_id, sp, tgt_dict + ): s + for s in samples + } + for future in concurrent.futures.as_completed(future_to_sample): + try: + data = future.result() + except Exception as exc: + print("generated an exception: ", exc) + else: + utts.update(data) + json.dump({"utts": utts}, args.output, indent=4) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_recognition/datasets/prepare-librispeech.sh b/fairseq/examples/speech_recognition/datasets/prepare-librispeech.sh new file mode 100755 index 0000000000000000000000000000000000000000..9e9297f08947027685ff508bfa91ff26b0d8ea0c --- /dev/null +++ b/fairseq/examples/speech_recognition/datasets/prepare-librispeech.sh @@ -0,0 +1,88 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# Prepare librispeech dataset + +base_url=www.openslr.org/resources/12 +train_dir=train_960 + +if [ "$#" -ne 2 ]; then + echo "Usage: $0 <download_dir> <out_dir>" + echo "e.g.: $0 /tmp/librispeech_raw/ ~/data/librispeech_final" + exit 1 +fi + +download_dir=${1%/} +out_dir=${2%/} + +fairseq_root=~/fairseq-py/ +mkdir -p ${out_dir} +cd ${out_dir} || exit + +nbpe=5000 +bpemode=unigram + +if [ ! -d "$fairseq_root" ]; then + echo "$0: Please set correct fairseq_root" + exit 1 +fi + +echo "Data Download" +for part in dev-clean test-clean dev-other test-other train-clean-100 train-clean-360 train-other-500; do + url=$base_url/$part.tar.gz + if ! wget -P $download_dir $url; then + echo "$0: wget failed for $url" + exit 1 + fi + if ! tar -C $download_dir -xvzf $download_dir/$part.tar.gz; then + echo "$0: error un-tarring archive $download_dir/$part.tar.gz" + exit 1 + fi +done + +echo "Merge all train packs into one" +mkdir -p ${download_dir}/LibriSpeech/${train_dir}/ +for part in train-clean-100 train-clean-360 train-other-500; do + mv ${download_dir}/LibriSpeech/${part}/* $download_dir/LibriSpeech/${train_dir}/ +done +echo "Merge train text" +find ${download_dir}/LibriSpeech/${train_dir}/ -name '*.txt' -exec cat {} \; >> ${download_dir}/LibriSpeech/${train_dir}/text + +# Use combined dev-clean and dev-other as validation set +find ${download_dir}/LibriSpeech/dev-clean/ ${download_dir}/LibriSpeech/dev-other/ -name '*.txt' -exec cat {} \; >> ${download_dir}/LibriSpeech/valid_text +find ${download_dir}/LibriSpeech/test-clean/ -name '*.txt' -exec cat {} \; >> ${download_dir}/LibriSpeech/test-clean/text +find ${download_dir}/LibriSpeech/test-other/ -name '*.txt' -exec cat {} \; >> ${download_dir}/LibriSpeech/test-other/text + + +dict=data/lang_char/${train_dir}_${bpemode}${nbpe}_units.txt +encoded=data/lang_char/${train_dir}_${bpemode}${nbpe}_encoded.txt +fairseq_dict=data/lang_char/${train_dir}_${bpemode}${nbpe}_fairseq_dict.txt +bpemodel=data/lang_char/${train_dir}_${bpemode}${nbpe} +echo "dictionary: ${dict}" +echo "Dictionary preparation" +mkdir -p data/lang_char/ +echo "<unk> 3" > ${dict} +echo "</s> 2" >> ${dict} +echo "<pad> 1" >> ${dict} +cut -f 2- -d" " ${download_dir}/LibriSpeech/${train_dir}/text > data/lang_char/input.txt +spm_train --input=data/lang_char/input.txt --vocab_size=${nbpe} --model_type=${bpemode} --model_prefix=${bpemodel} --input_sentence_size=100000000 --unk_id=3 --eos_id=2 --pad_id=1 --bos_id=-1 --character_coverage=1 +spm_encode --model=${bpemodel}.model --output_format=piece < data/lang_char/input.txt > ${encoded} +cat ${encoded} | tr ' ' '\n' | sort | uniq | awk '{print $0 " " NR+3}' >> ${dict} +cat ${encoded} | tr ' ' '\n' | sort | uniq -c | awk '{print $2 " " $1}' > ${fairseq_dict} +wc -l ${dict} + +echo "Prepare train and test jsons" +for part in train_960 test-other test-clean; do + python ${fairseq_root}/examples/speech_recognition/datasets/asr_prep_json.py --audio-dirs ${download_dir}/LibriSpeech/${part} --labels ${download_dir}/LibriSpeech/${part}/text --spm-model ${bpemodel}.model --audio-format flac --dictionary ${fairseq_dict} --output ${part}.json +done +# fairseq expects to find train.json and valid.json during training +mv train_960.json train.json + +echo "Prepare valid json" +python ${fairseq_root}/examples/speech_recognition/datasets/asr_prep_json.py --audio-dirs ${download_dir}/LibriSpeech/dev-clean ${download_dir}/LibriSpeech/dev-other --labels ${download_dir}/LibriSpeech/valid_text --spm-model ${bpemodel}.model --audio-format flac --dictionary ${fairseq_dict} --output valid.json + +cp ${fairseq_dict} ./dict.txt +cp ${bpemodel}.model ./spm.model diff --git a/fairseq/examples/speech_recognition/infer.py b/fairseq/examples/speech_recognition/infer.py new file mode 100644 index 0000000000000000000000000000000000000000..6e9a878af46242ced57cfcd0e876a3d2ef3820ae --- /dev/null +++ b/fairseq/examples/speech_recognition/infer.py @@ -0,0 +1,427 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Run inference for pre-processed data with a trained model. +""" + +import ast +import logging +import math +import os +import sys + +import editdistance +import numpy as np +import torch +from fairseq import checkpoint_utils, options, progress_bar, tasks, utils +from fairseq.data.data_utils import post_process +from fairseq.logging.meters import StopwatchMeter, TimeMeter + + +logging.basicConfig() +logging.root.setLevel(logging.INFO) +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +def add_asr_eval_argument(parser): + parser.add_argument("--kspmodel", default=None, help="sentence piece model") + parser.add_argument( + "--wfstlm", default=None, help="wfstlm on dictonary output units" + ) + parser.add_argument( + "--rnnt_decoding_type", + default="greedy", + help="wfstlm on dictonary\ +output units", + ) + try: + parser.add_argument( + "--lm-weight", + "--lm_weight", + type=float, + default=0.2, + help="weight for lm while interpolating with neural score", + ) + except: + pass + parser.add_argument( + "--rnnt_len_penalty", default=-0.5, help="rnnt length penalty on word level" + ) + parser.add_argument( + "--w2l-decoder", + choices=["viterbi", "kenlm", "fairseqlm"], + help="use a w2l decoder", + ) + parser.add_argument("--lexicon", help="lexicon for w2l decoder") + parser.add_argument("--unit-lm", action="store_true", help="if using a unit lm") + parser.add_argument("--kenlm-model", "--lm-model", help="lm model for w2l decoder") + parser.add_argument("--beam-threshold", type=float, default=25.0) + parser.add_argument("--beam-size-token", type=float, default=100) + parser.add_argument("--word-score", type=float, default=1.0) + parser.add_argument("--unk-weight", type=float, default=-math.inf) + parser.add_argument("--sil-weight", type=float, default=0.0) + parser.add_argument( + "--dump-emissions", + type=str, + default=None, + help="if present, dumps emissions into this file and exits", + ) + parser.add_argument( + "--dump-features", + type=str, + default=None, + help="if present, dumps features into this file and exits", + ) + parser.add_argument( + "--load-emissions", + type=str, + default=None, + help="if present, loads emissions from this file", + ) + return parser + + +def check_args(args): + # assert args.path is not None, "--path required for generation!" + # assert args.results_path is not None, "--results_path required for generation!" + assert ( + not args.sampling or args.nbest == args.beam + ), "--sampling requires --nbest to be equal to --beam" + assert ( + args.replace_unk is None or args.raw_text + ), "--replace-unk requires a raw text dataset (--raw-text)" + + +def get_dataset_itr(args, task, models): + return task.get_batch_iterator( + dataset=task.dataset(args.gen_subset), + max_tokens=args.max_tokens, + max_sentences=args.batch_size, + max_positions=(sys.maxsize, sys.maxsize), + ignore_invalid_inputs=args.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=args.required_batch_size_multiple, + num_shards=args.num_shards, + shard_id=args.shard_id, + num_workers=args.num_workers, + data_buffer_size=args.data_buffer_size, + ).next_epoch_itr(shuffle=False) + + +def process_predictions( + args, hypos, sp, tgt_dict, target_tokens, res_files, speaker, id +): + for hypo in hypos[: min(len(hypos), args.nbest)]: + hyp_pieces = tgt_dict.string(hypo["tokens"].int().cpu()) + + if "words" in hypo: + hyp_words = " ".join(hypo["words"]) + else: + hyp_words = post_process(hyp_pieces, args.post_process) + + if res_files is not None: + print( + "{} ({}-{})".format(hyp_pieces, speaker, id), + file=res_files["hypo.units"], + ) + print( + "{} ({}-{})".format(hyp_words, speaker, id), + file=res_files["hypo.words"], + ) + + tgt_pieces = tgt_dict.string(target_tokens) + tgt_words = post_process(tgt_pieces, args.post_process) + + if res_files is not None: + print( + "{} ({}-{})".format(tgt_pieces, speaker, id), + file=res_files["ref.units"], + ) + print( + "{} ({}-{})".format(tgt_words, speaker, id), file=res_files["ref.words"] + ) + + if not args.quiet: + logger.info("HYPO:" + hyp_words) + logger.info("TARGET:" + tgt_words) + logger.info("___________________") + + hyp_words = hyp_words.split() + tgt_words = tgt_words.split() + return editdistance.eval(hyp_words, tgt_words), len(tgt_words) + + +def prepare_result_files(args): + def get_res_file(file_prefix): + if args.num_shards > 1: + file_prefix = f"{args.shard_id}_{file_prefix}" + path = os.path.join( + args.results_path, + "{}-{}-{}.txt".format( + file_prefix, os.path.basename(args.path), args.gen_subset + ), + ) + return open(path, "w", buffering=1) + + if not args.results_path: + return None + + return { + "hypo.words": get_res_file("hypo.word"), + "hypo.units": get_res_file("hypo.units"), + "ref.words": get_res_file("ref.word"), + "ref.units": get_res_file("ref.units"), + } + + +def optimize_models(args, use_cuda, models): + """Optimize ensemble for generation""" + for model in models: + model.make_generation_fast_( + beamable_mm_beam_size=None if args.no_beamable_mm else args.beam, + need_attn=args.print_alignment, + ) + if args.fp16: + model.half() + if use_cuda: + model.cuda() + + +class ExistingEmissionsDecoder(object): + def __init__(self, decoder, emissions): + self.decoder = decoder + self.emissions = emissions + + def generate(self, models, sample, **unused): + ids = sample["id"].cpu().numpy() + try: + emissions = np.stack(self.emissions[ids]) + except: + print([x.shape for x in self.emissions[ids]]) + raise Exception("invalid sizes") + emissions = torch.from_numpy(emissions) + return self.decoder.decode(emissions) + + +def main(args, task=None, model_state=None): + check_args(args) + + if args.max_tokens is None and args.batch_size is None: + args.max_tokens = 4000000 + logger.info(args) + + use_cuda = torch.cuda.is_available() and not args.cpu + + logger.info("| decoding with criterion {}".format(args.criterion)) + + task = tasks.setup_task(args) + + # Load ensemble + if args.load_emissions: + models, criterions = [], [] + task.load_dataset(args.gen_subset) + else: + logger.info("| loading model(s) from {}".format(args.path)) + models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task( + utils.split_paths(args.path, separator="\\"), + arg_overrides=ast.literal_eval(args.model_overrides), + task=task, + suffix=args.checkpoint_suffix, + strict=(args.checkpoint_shard_count == 1), + num_shards=args.checkpoint_shard_count, + state=model_state, + ) + optimize_models(args, use_cuda, models) + task.load_dataset(args.gen_subset, task_cfg=saved_cfg.task) + + + # Set dictionary + tgt_dict = task.target_dictionary + + logger.info( + "| {} {} {} examples".format( + args.data, args.gen_subset, len(task.dataset(args.gen_subset)) + ) + ) + + # hack to pass transitions to W2lDecoder + if args.criterion == "asg_loss": + raise NotImplementedError("asg_loss is currently not supported") + # trans = criterions[0].asg.trans.data + # args.asg_transitions = torch.flatten(trans).tolist() + + # Load dataset (possibly sharded) + itr = get_dataset_itr(args, task, models) + + # Initialize generator + gen_timer = StopwatchMeter() + + def build_generator(args): + w2l_decoder = getattr(args, "w2l_decoder", None) + if w2l_decoder == "viterbi": + from examples.speech_recognition.w2l_decoder import W2lViterbiDecoder + + return W2lViterbiDecoder(args, task.target_dictionary) + elif w2l_decoder == "kenlm": + from examples.speech_recognition.w2l_decoder import W2lKenLMDecoder + + return W2lKenLMDecoder(args, task.target_dictionary) + elif w2l_decoder == "fairseqlm": + from examples.speech_recognition.w2l_decoder import W2lFairseqLMDecoder + + return W2lFairseqLMDecoder(args, task.target_dictionary) + else: + print( + "only flashlight decoders with (viterbi, kenlm, fairseqlm) options are supported at the moment" + ) + + # please do not touch this unless you test both generate.py and infer.py with audio_pretraining task + generator = build_generator(args) + + if args.load_emissions: + generator = ExistingEmissionsDecoder( + generator, np.load(args.load_emissions, allow_pickle=True) + ) + logger.info("loaded emissions from " + args.load_emissions) + + num_sentences = 0 + + if args.results_path is not None and not os.path.exists(args.results_path): + os.makedirs(args.results_path) + + max_source_pos = ( + utils.resolve_max_positions( + task.max_positions(), *[model.max_positions() for model in models] + ), + ) + + if max_source_pos is not None: + max_source_pos = max_source_pos[0] + if max_source_pos is not None: + max_source_pos = max_source_pos[0] - 1 + + if args.dump_emissions: + emissions = {} + if args.dump_features: + features = {} + models[0].bert.proj = None + else: + res_files = prepare_result_files(args) + errs_t = 0 + lengths_t = 0 + with progress_bar.build_progress_bar(args, itr) as t: + wps_meter = TimeMeter() + for sample in t: + sample = utils.move_to_cuda(sample) if use_cuda else sample + if "net_input" not in sample: + continue + + prefix_tokens = None + if args.prefix_size > 0: + prefix_tokens = sample["target"][:, : args.prefix_size] + + gen_timer.start() + if args.dump_emissions: + with torch.no_grad(): + encoder_out = models[0](**sample["net_input"]) + emm = models[0].get_normalized_probs(encoder_out, log_probs=True) + emm = emm.transpose(0, 1).cpu().numpy() + for i, id in enumerate(sample["id"]): + emissions[id.item()] = emm[i] + continue + elif args.dump_features: + with torch.no_grad(): + encoder_out = models[0](**sample["net_input"]) + feat = encoder_out["encoder_out"].transpose(0, 1).cpu().numpy() + for i, id in enumerate(sample["id"]): + padding = ( + encoder_out["encoder_padding_mask"][i].cpu().numpy() + if encoder_out["encoder_padding_mask"] is not None + else None + ) + features[id.item()] = (feat[i], padding) + continue + hypos = task.inference_step(generator, models, sample, prefix_tokens) + num_generated_tokens = sum(len(h[0]["tokens"]) for h in hypos) + gen_timer.stop(num_generated_tokens) + + for i, sample_id in enumerate(sample["id"].tolist()): + speaker = None + # id = task.dataset(args.gen_subset).ids[int(sample_id)] + id = sample_id + toks = ( + sample["target"][i, :] + if "target_label" not in sample + else sample["target_label"][i, :] + ) + target_tokens = utils.strip_pad(toks, tgt_dict.pad()).int().cpu() + # Process top predictions + errs, length = process_predictions( + args, + hypos[i], + None, + tgt_dict, + target_tokens, + res_files, + speaker, + id, + ) + errs_t += errs + lengths_t += length + + wps_meter.update(num_generated_tokens) + t.log({"wps": round(wps_meter.avg)}) + num_sentences += ( + sample["nsentences"] if "nsentences" in sample else sample["id"].numel() + ) + + wer = None + if args.dump_emissions: + emm_arr = [] + for i in range(len(emissions)): + emm_arr.append(emissions[i]) + np.save(args.dump_emissions, emm_arr) + logger.info(f"saved {len(emissions)} emissions to {args.dump_emissions}") + elif args.dump_features: + feat_arr = [] + for i in range(len(features)): + feat_arr.append(features[i]) + np.save(args.dump_features, feat_arr) + logger.info(f"saved {len(features)} emissions to {args.dump_features}") + else: + if lengths_t > 0: + wer = errs_t * 100.0 / lengths_t + logger.info(f"WER: {wer}") + + logger.info( + "| Processed {} sentences ({} tokens) in {:.1f}s ({:.2f}" + "sentences/s, {:.2f} tokens/s)".format( + num_sentences, + gen_timer.n, + gen_timer.sum, + num_sentences / gen_timer.sum, + 1.0 / gen_timer.avg, + ) + ) + logger.info("| Generate {} with beam={}".format(args.gen_subset, args.beam)) + return task, wer + + +def make_parser(): + parser = options.get_generation_parser() + parser = add_asr_eval_argument(parser) + return parser + + +def cli_main(): + parser = make_parser() + args = options.parse_args_and_arch(parser) + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/speech_recognition/kaldi/__init__.py b/fairseq/examples/speech_recognition/kaldi/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/speech_recognition/kaldi/add-self-loop-simple.cc b/fairseq/examples/speech_recognition/kaldi/add-self-loop-simple.cc new file mode 100644 index 0000000000000000000000000000000000000000..e18fb62df52ab85d7802615d8619b0fd94a08f8c --- /dev/null +++ b/fairseq/examples/speech_recognition/kaldi/add-self-loop-simple.cc @@ -0,0 +1,94 @@ +/* + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <iostream> +#include "fstext/fstext-lib.h" // @manual +#include "util/common-utils.h" // @manual + +/* + * This program is to modify a FST without self-loop by: + * for each incoming arc with non-eps input symbol, add a self-loop arc + * with that non-eps symbol as input and eps as output. + * + * This is to make sure the resultant FST can do deduplication for repeated + * symbols, which is very common in acoustic model + * + */ +namespace { +int32 AddSelfLoopsSimple(fst::StdVectorFst* fst) { + typedef fst::MutableArcIterator<fst::StdVectorFst> IterType; + + int32 num_states_before = fst->NumStates(); + fst::MakePrecedingInputSymbolsSame(false, fst); + int32 num_states_after = fst->NumStates(); + KALDI_LOG << "There are " << num_states_before + << " states in the original FST; " + << " after MakePrecedingInputSymbolsSame, there are " + << num_states_after << " states " << std::endl; + + auto weight_one = fst::StdArc::Weight::One(); + + int32 num_arc_added = 0; + + fst::StdArc self_loop_arc; + self_loop_arc.weight = weight_one; + + int32 num_states = fst->NumStates(); + std::vector<std::set<int32>> incoming_non_eps_label_per_state(num_states); + + for (int32 state = 0; state < num_states; state++) { + for (IterType aiter(fst, state); !aiter.Done(); aiter.Next()) { + fst::StdArc arc(aiter.Value()); + if (arc.ilabel != 0) { + incoming_non_eps_label_per_state[arc.nextstate].insert(arc.ilabel); + } + } + } + + for (int32 state = 0; state < num_states; state++) { + if (!incoming_non_eps_label_per_state[state].empty()) { + auto& ilabel_set = incoming_non_eps_label_per_state[state]; + for (auto it = ilabel_set.begin(); it != ilabel_set.end(); it++) { + self_loop_arc.ilabel = *it; + self_loop_arc.olabel = 0; + self_loop_arc.nextstate = state; + fst->AddArc(state, self_loop_arc); + num_arc_added++; + } + } + } + return num_arc_added; +} + +void print_usage() { + std::cout << "add-self-loop-simple usage:\n" + "\tadd-self-loop-simple <in-fst> <out-fst> \n"; +} +} // namespace + +int main(int argc, char** argv) { + if (argc != 3) { + print_usage(); + exit(1); + } + + auto input = argv[1]; + auto output = argv[2]; + + auto fst = fst::ReadFstKaldi(input); + auto num_states = fst->NumStates(); + KALDI_LOG << "Loading FST from " << input << " with " << num_states + << " states." << std::endl; + + int32 num_arc_added = AddSelfLoopsSimple(fst); + KALDI_LOG << "Adding " << num_arc_added << " self-loop arcs " << std::endl; + + fst::WriteFstKaldi(*fst, std::string(output)); + KALDI_LOG << "Writing FST to " << output << std::endl; + + delete fst; +} diff --git a/fairseq/examples/speech_recognition/kaldi/config/kaldi_initializer.yaml b/fairseq/examples/speech_recognition/kaldi/config/kaldi_initializer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..be9ba98f55463d41d5d5ea35e306abc0886dbead --- /dev/null +++ b/fairseq/examples/speech_recognition/kaldi/config/kaldi_initializer.yaml @@ -0,0 +1,8 @@ +# @package _group_ + +data_dir: ??? +fst_dir: ??? +in_labels: ??? +kaldi_root: ??? +lm_arpa: ??? +blank_symbol: <s> diff --git a/fairseq/examples/speech_recognition/kaldi/kaldi_decoder.py b/fairseq/examples/speech_recognition/kaldi/kaldi_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..5f62cc58ae8c0c5a3ba7d17713fedf0abc302942 --- /dev/null +++ b/fairseq/examples/speech_recognition/kaldi/kaldi_decoder.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from concurrent.futures import ThreadPoolExecutor +import logging +from omegaconf import MISSING +import os +import torch +from typing import Optional +import warnings + + +from dataclasses import dataclass +from fairseq.dataclass import FairseqDataclass +from .kaldi_initializer import KaldiInitializerConfig, initalize_kaldi + + +logger = logging.getLogger(__name__) + + +@dataclass +class KaldiDecoderConfig(FairseqDataclass): + hlg_graph_path: Optional[str] = None + output_dict: str = MISSING + + kaldi_initializer_config: Optional[KaldiInitializerConfig] = None + + acoustic_scale: float = 0.5 + max_active: int = 10000 + beam_delta: float = 0.5 + hash_ratio: float = 2.0 + + is_lattice: bool = False + lattice_beam: float = 10.0 + prune_interval: int = 25 + determinize_lattice: bool = True + prune_scale: float = 0.1 + max_mem: int = 0 + phone_determinize: bool = True + word_determinize: bool = True + minimize: bool = True + + num_threads: int = 1 + + +class KaldiDecoder(object): + def __init__( + self, + cfg: KaldiDecoderConfig, + beam: int, + nbest: int = 1, + ): + try: + from kaldi.asr import FasterRecognizer, LatticeFasterRecognizer + from kaldi.base import set_verbose_level + from kaldi.decoder import ( + FasterDecoder, + FasterDecoderOptions, + LatticeFasterDecoder, + LatticeFasterDecoderOptions, + ) + from kaldi.lat.functions import DeterminizeLatticePhonePrunedOptions + from kaldi.fstext import read_fst_kaldi, SymbolTable + except: + warnings.warn( + "pykaldi is required for this functionality. Please install from https://github.com/pykaldi/pykaldi" + ) + + # set_verbose_level(2) + + self.acoustic_scale = cfg.acoustic_scale + self.nbest = nbest + + if cfg.hlg_graph_path is None: + assert ( + cfg.kaldi_initializer_config is not None + ), "Must provide hlg graph path or kaldi initializer config" + cfg.hlg_graph_path = initalize_kaldi(cfg.kaldi_initializer_config) + + assert os.path.exists(cfg.hlg_graph_path), cfg.hlg_graph_path + + if cfg.is_lattice: + self.dec_cls = LatticeFasterDecoder + opt_cls = LatticeFasterDecoderOptions + self.rec_cls = LatticeFasterRecognizer + else: + assert self.nbest == 1, "nbest > 1 requires lattice decoder" + self.dec_cls = FasterDecoder + opt_cls = FasterDecoderOptions + self.rec_cls = FasterRecognizer + + self.decoder_options = opt_cls() + self.decoder_options.beam = beam + self.decoder_options.max_active = cfg.max_active + self.decoder_options.beam_delta = cfg.beam_delta + self.decoder_options.hash_ratio = cfg.hash_ratio + + if cfg.is_lattice: + self.decoder_options.lattice_beam = cfg.lattice_beam + self.decoder_options.prune_interval = cfg.prune_interval + self.decoder_options.determinize_lattice = cfg.determinize_lattice + self.decoder_options.prune_scale = cfg.prune_scale + det_opts = DeterminizeLatticePhonePrunedOptions() + det_opts.max_mem = cfg.max_mem + det_opts.phone_determinize = cfg.phone_determinize + det_opts.word_determinize = cfg.word_determinize + det_opts.minimize = cfg.minimize + self.decoder_options.det_opts = det_opts + + self.output_symbols = {} + with open(cfg.output_dict, "r") as f: + for line in f: + items = line.rstrip().split() + assert len(items) == 2 + self.output_symbols[int(items[1])] = items[0] + + logger.info(f"Loading FST from {cfg.hlg_graph_path}") + self.fst = read_fst_kaldi(cfg.hlg_graph_path) + self.symbol_table = SymbolTable.read_text(cfg.output_dict) + + self.executor = ThreadPoolExecutor(max_workers=cfg.num_threads) + + def generate(self, models, sample, **unused): + """Generate a batch of inferences.""" + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in sample["net_input"].items() if k != "prev_output_tokens" + } + emissions, padding = self.get_emissions(models, encoder_input) + return self.decode(emissions, padding) + + def get_emissions(self, models, encoder_input): + """Run encoder and normalize emissions""" + model = models[0] + + all_encoder_out = [m(**encoder_input) for m in models] + + if len(all_encoder_out) > 1: + + if "encoder_out" in all_encoder_out[0]: + encoder_out = { + "encoder_out": sum(e["encoder_out"] for e in all_encoder_out) + / len(all_encoder_out), + "encoder_padding_mask": all_encoder_out[0]["encoder_padding_mask"], + } + padding = encoder_out["encoder_padding_mask"] + else: + encoder_out = { + "logits": sum(e["logits"] for e in all_encoder_out) + / len(all_encoder_out), + "padding_mask": all_encoder_out[0]["padding_mask"], + } + padding = encoder_out["padding_mask"] + else: + encoder_out = all_encoder_out[0] + padding = ( + encoder_out["padding_mask"] + if "padding_mask" in encoder_out + else encoder_out["encoder_padding_mask"] + ) + + if hasattr(model, "get_logits"): + emissions = model.get_logits(encoder_out, normalize=True) + else: + emissions = model.get_normalized_probs(encoder_out, log_probs=True) + + return ( + emissions.cpu().float().transpose(0, 1), + padding.cpu() if padding is not None and padding.any() else None, + ) + + def decode_one(self, logits, padding): + from kaldi.matrix import Matrix + + decoder = self.dec_cls(self.fst, self.decoder_options) + asr = self.rec_cls( + decoder, self.symbol_table, acoustic_scale=self.acoustic_scale + ) + + if padding is not None: + logits = logits[~padding] + + mat = Matrix(logits.numpy()) + + out = asr.decode(mat) + + if self.nbest > 1: + from kaldi.fstext import shortestpath + from kaldi.fstext.utils import ( + convert_compact_lattice_to_lattice, + convert_lattice_to_std, + convert_nbest_to_list, + get_linear_symbol_sequence, + ) + + lat = out["lattice"] + + sp = shortestpath(lat, nshortest=self.nbest) + + sp = convert_compact_lattice_to_lattice(sp) + sp = convert_lattice_to_std(sp) + seq = convert_nbest_to_list(sp) + + results = [] + for s in seq: + _, o, w = get_linear_symbol_sequence(s) + words = list(self.output_symbols[z] for z in o) + results.append( + { + "tokens": words, + "words": words, + "score": w.value, + "emissions": logits, + } + ) + return results + else: + words = out["text"].split() + return [ + { + "tokens": words, + "words": words, + "score": out["likelihood"], + "emissions": logits, + } + ] + + def decode(self, emissions, padding): + if padding is None: + padding = [None] * len(emissions) + + ret = list( + map( + lambda e, p: self.executor.submit(self.decode_one, e, p), + emissions, + padding, + ) + ) + return ret diff --git a/fairseq/examples/speech_recognition/kaldi/kaldi_initializer.py b/fairseq/examples/speech_recognition/kaldi/kaldi_initializer.py new file mode 100644 index 0000000000000000000000000000000000000000..6d2a2a4b6b809ba1106f9a57cb6f241dc083e670 --- /dev/null +++ b/fairseq/examples/speech_recognition/kaldi/kaldi_initializer.py @@ -0,0 +1,698 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +import hydra +from hydra.core.config_store import ConfigStore +import logging +from omegaconf import MISSING, OmegaConf +import os +import os.path as osp +from pathlib import Path +import subprocess +from typing import Optional + +from fairseq.data.dictionary import Dictionary +from fairseq.dataclass import FairseqDataclass + +script_dir = Path(__file__).resolve().parent +config_path = script_dir / "config" + + +logger = logging.getLogger(__name__) + + +@dataclass +class KaldiInitializerConfig(FairseqDataclass): + data_dir: str = MISSING + fst_dir: Optional[str] = None + in_labels: str = MISSING + out_labels: Optional[str] = None + wav2letter_lexicon: Optional[str] = None + lm_arpa: str = MISSING + kaldi_root: str = MISSING + blank_symbol: str = "<s>" + silence_symbol: Optional[str] = None + + +def create_units(fst_dir: Path, in_labels: str, vocab: Dictionary) -> Path: + in_units_file = fst_dir / f"kaldi_dict.{in_labels}.txt" + if not in_units_file.exists(): + + logger.info(f"Creating {in_units_file}") + + with open(in_units_file, "w") as f: + print("<eps> 0", file=f) + i = 1 + for symb in vocab.symbols[vocab.nspecial :]: + if not symb.startswith("madeupword"): + print(f"{symb} {i}", file=f) + i += 1 + return in_units_file + + +def create_lexicon( + cfg: KaldiInitializerConfig, + fst_dir: Path, + unique_label: str, + in_units_file: Path, + out_words_file: Path, +) -> (Path, Path): + + disambig_in_units_file = fst_dir / f"kaldi_dict.{cfg.in_labels}_disambig.txt" + lexicon_file = fst_dir / f"kaldi_lexicon.{unique_label}.txt" + disambig_lexicon_file = fst_dir / f"kaldi_lexicon.{unique_label}_disambig.txt" + if ( + not lexicon_file.exists() + or not disambig_lexicon_file.exists() + or not disambig_in_units_file.exists() + ): + logger.info(f"Creating {lexicon_file} (in units file: {in_units_file})") + + assert cfg.wav2letter_lexicon is not None or cfg.in_labels == cfg.out_labels + + if cfg.wav2letter_lexicon is not None: + lm_words = set() + with open(out_words_file, "r") as lm_dict_f: + for line in lm_dict_f: + lm_words.add(line.split()[0]) + + num_skipped = 0 + total = 0 + with open(cfg.wav2letter_lexicon, "r") as w2l_lex_f, open( + lexicon_file, "w" + ) as out_f: + for line in w2l_lex_f: + items = line.rstrip().split("\t") + assert len(items) == 2, items + if items[0] in lm_words: + print(items[0], items[1], file=out_f) + else: + num_skipped += 1 + logger.debug( + f"Skipping word {items[0]} as it was not found in LM" + ) + total += 1 + if num_skipped > 0: + logger.warning( + f"Skipped {num_skipped} out of {total} words as they were not found in LM" + ) + else: + with open(in_units_file, "r") as in_f, open(lexicon_file, "w") as out_f: + for line in in_f: + symb = line.split()[0] + if symb != "<eps>" and symb != "<ctc_blank>" and symb != "<SIL>": + print(symb, symb, file=out_f) + + lex_disambig_path = ( + Path(cfg.kaldi_root) / "egs/wsj/s5/utils/add_lex_disambig.pl" + ) + res = subprocess.run( + [lex_disambig_path, lexicon_file, disambig_lexicon_file], + check=True, + capture_output=True, + ) + ndisambig = int(res.stdout) + disamib_path = Path(cfg.kaldi_root) / "egs/wsj/s5/utils/add_disambig.pl" + res = subprocess.run( + [disamib_path, "--include-zero", in_units_file, str(ndisambig)], + check=True, + capture_output=True, + ) + with open(disambig_in_units_file, "wb") as f: + f.write(res.stdout) + + return disambig_lexicon_file, disambig_in_units_file + + +def create_G( + kaldi_root: Path, fst_dir: Path, lm_arpa: Path, arpa_base: str +) -> (Path, Path): + + out_words_file = fst_dir / f"kaldi_dict.{arpa_base}.txt" + grammar_graph = fst_dir / f"G_{arpa_base}.fst" + if not grammar_graph.exists() or not out_words_file.exists(): + logger.info(f"Creating {grammar_graph}") + arpa2fst = kaldi_root / "src/lmbin/arpa2fst" + subprocess.run( + [ + arpa2fst, + "--disambig-symbol=#0", + f"--write-symbol-table={out_words_file}", + lm_arpa, + grammar_graph, + ], + check=True, + ) + return grammar_graph, out_words_file + + +def create_L( + kaldi_root: Path, + fst_dir: Path, + unique_label: str, + lexicon_file: Path, + in_units_file: Path, + out_words_file: Path, +) -> Path: + lexicon_graph = fst_dir / f"L.{unique_label}.fst" + + if not lexicon_graph.exists(): + logger.info(f"Creating {lexicon_graph} (in units: {in_units_file})") + make_lex = kaldi_root / "egs/wsj/s5/utils/make_lexicon_fst.pl" + fstcompile = kaldi_root / "tools/openfst-1.6.7/bin/fstcompile" + fstaddselfloops = kaldi_root / "src/fstbin/fstaddselfloops" + fstarcsort = kaldi_root / "tools/openfst-1.6.7/bin/fstarcsort" + + def write_disambig_symbol(file): + with open(file, "r") as f: + for line in f: + items = line.rstrip().split() + if items[0] == "#0": + out_path = str(file) + "_disamig" + with open(out_path, "w") as out_f: + print(items[1], file=out_f) + return out_path + + return None + + in_disambig_sym = write_disambig_symbol(in_units_file) + assert in_disambig_sym is not None + out_disambig_sym = write_disambig_symbol(out_words_file) + assert out_disambig_sym is not None + + try: + with open(lexicon_graph, "wb") as out_f: + res = subprocess.run( + [make_lex, lexicon_file], capture_output=True, check=True + ) + assert len(res.stderr) == 0, res.stderr.decode("utf-8") + res = subprocess.run( + [ + fstcompile, + f"--isymbols={in_units_file}", + f"--osymbols={out_words_file}", + "--keep_isymbols=false", + "--keep_osymbols=false", + ], + input=res.stdout, + capture_output=True, + ) + assert len(res.stderr) == 0, res.stderr.decode("utf-8") + res = subprocess.run( + [fstaddselfloops, in_disambig_sym, out_disambig_sym], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstarcsort, "--sort_type=olabel"], + input=res.stdout, + capture_output=True, + check=True, + ) + out_f.write(res.stdout) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + os.remove(lexicon_graph) + raise + except AssertionError: + os.remove(lexicon_graph) + raise + + return lexicon_graph + + +def create_LG( + kaldi_root: Path, + fst_dir: Path, + unique_label: str, + lexicon_graph: Path, + grammar_graph: Path, +) -> Path: + lg_graph = fst_dir / f"LG.{unique_label}.fst" + + if not lg_graph.exists(): + logger.info(f"Creating {lg_graph}") + + fsttablecompose = kaldi_root / "src/fstbin/fsttablecompose" + fstdeterminizestar = kaldi_root / "src/fstbin/fstdeterminizestar" + fstminimizeencoded = kaldi_root / "src/fstbin/fstminimizeencoded" + fstpushspecial = kaldi_root / "src/fstbin/fstpushspecial" + fstarcsort = kaldi_root / "tools/openfst-1.6.7/bin/fstarcsort" + + try: + with open(lg_graph, "wb") as out_f: + res = subprocess.run( + [fsttablecompose, lexicon_graph, grammar_graph], + capture_output=True, + check=True, + ) + res = subprocess.run( + [ + fstdeterminizestar, + "--use-log=true", + ], + input=res.stdout, + capture_output=True, + ) + res = subprocess.run( + [fstminimizeencoded], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstpushspecial], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstarcsort, "--sort_type=ilabel"], + input=res.stdout, + capture_output=True, + check=True, + ) + out_f.write(res.stdout) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + os.remove(lg_graph) + raise + + return lg_graph + + +def create_H( + kaldi_root: Path, + fst_dir: Path, + disambig_out_units_file: Path, + in_labels: str, + vocab: Dictionary, + blk_sym: str, + silence_symbol: Optional[str], +) -> (Path, Path, Path): + h_graph = ( + fst_dir / f"H.{in_labels}{'_' + silence_symbol if silence_symbol else ''}.fst" + ) + h_out_units_file = fst_dir / f"kaldi_dict.h_out.{in_labels}.txt" + disambig_in_units_file_int = Path(str(h_graph) + "isym_disambig.int") + disambig_out_units_file_int = Path(str(disambig_out_units_file) + ".int") + if ( + not h_graph.exists() + or not h_out_units_file.exists() + or not disambig_in_units_file_int.exists() + ): + logger.info(f"Creating {h_graph}") + eps_sym = "<eps>" + + num_disambig = 0 + osymbols = [] + + with open(disambig_out_units_file, "r") as f, open( + disambig_out_units_file_int, "w" + ) as out_f: + for line in f: + symb, id = line.rstrip().split() + if line.startswith("#"): + num_disambig += 1 + print(id, file=out_f) + else: + if len(osymbols) == 0: + assert symb == eps_sym, symb + osymbols.append((symb, id)) + + i_idx = 0 + isymbols = [(eps_sym, 0)] + + imap = {} + + for i, s in enumerate(vocab.symbols): + i_idx += 1 + isymbols.append((s, i_idx)) + imap[s] = i_idx + + fst_str = [] + + node_idx = 0 + root_node = node_idx + + special_symbols = [blk_sym] + if silence_symbol is not None: + special_symbols.append(silence_symbol) + + for ss in special_symbols: + fst_str.append("{} {} {} {}".format(root_node, root_node, ss, eps_sym)) + + for symbol, _ in osymbols: + if symbol == eps_sym or symbol.startswith("#"): + continue + + node_idx += 1 + # 1. from root to emitting state + fst_str.append("{} {} {} {}".format(root_node, node_idx, symbol, symbol)) + # 2. from emitting state back to root + fst_str.append("{} {} {} {}".format(node_idx, root_node, eps_sym, eps_sym)) + # 3. from emitting state to optional blank state + pre_node = node_idx + node_idx += 1 + for ss in special_symbols: + fst_str.append("{} {} {} {}".format(pre_node, node_idx, ss, eps_sym)) + # 4. from blank state back to root + fst_str.append("{} {} {} {}".format(node_idx, root_node, eps_sym, eps_sym)) + + fst_str.append("{}".format(root_node)) + + fst_str = "\n".join(fst_str) + h_str = str(h_graph) + isym_file = h_str + ".isym" + + with open(isym_file, "w") as f: + for sym, id in isymbols: + f.write("{} {}\n".format(sym, id)) + + with open(h_out_units_file, "w") as f: + for sym, id in osymbols: + f.write("{} {}\n".format(sym, id)) + + with open(disambig_in_units_file_int, "w") as f: + disam_sym_id = len(isymbols) + for _ in range(num_disambig): + f.write("{}\n".format(disam_sym_id)) + disam_sym_id += 1 + + fstcompile = kaldi_root / "tools/openfst-1.6.7/bin/fstcompile" + fstaddselfloops = kaldi_root / "src/fstbin/fstaddselfloops" + fstarcsort = kaldi_root / "tools/openfst-1.6.7/bin/fstarcsort" + + try: + with open(h_graph, "wb") as out_f: + res = subprocess.run( + [ + fstcompile, + f"--isymbols={isym_file}", + f"--osymbols={h_out_units_file}", + "--keep_isymbols=false", + "--keep_osymbols=false", + ], + input=str.encode(fst_str), + capture_output=True, + check=True, + ) + res = subprocess.run( + [ + fstaddselfloops, + disambig_in_units_file_int, + disambig_out_units_file_int, + ], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstarcsort, "--sort_type=olabel"], + input=res.stdout, + capture_output=True, + check=True, + ) + out_f.write(res.stdout) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + os.remove(h_graph) + raise + return h_graph, h_out_units_file, disambig_in_units_file_int + + +def create_HLGa( + kaldi_root: Path, + fst_dir: Path, + unique_label: str, + h_graph: Path, + lg_graph: Path, + disambig_in_words_file_int: Path, +) -> Path: + hlga_graph = fst_dir / f"HLGa.{unique_label}.fst" + + if not hlga_graph.exists(): + logger.info(f"Creating {hlga_graph}") + + fsttablecompose = kaldi_root / "src/fstbin/fsttablecompose" + fstdeterminizestar = kaldi_root / "src/fstbin/fstdeterminizestar" + fstrmsymbols = kaldi_root / "src/fstbin/fstrmsymbols" + fstrmepslocal = kaldi_root / "src/fstbin/fstrmepslocal" + fstminimizeencoded = kaldi_root / "src/fstbin/fstminimizeencoded" + + try: + with open(hlga_graph, "wb") as out_f: + res = subprocess.run( + [ + fsttablecompose, + h_graph, + lg_graph, + ], + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstdeterminizestar, "--use-log=true"], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstrmsymbols, disambig_in_words_file_int], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstrmepslocal], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstminimizeencoded], + input=res.stdout, + capture_output=True, + check=True, + ) + out_f.write(res.stdout) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + os.remove(hlga_graph) + raise + + return hlga_graph + + +def create_HLa( + kaldi_root: Path, + fst_dir: Path, + unique_label: str, + h_graph: Path, + l_graph: Path, + disambig_in_words_file_int: Path, +) -> Path: + hla_graph = fst_dir / f"HLa.{unique_label}.fst" + + if not hla_graph.exists(): + logger.info(f"Creating {hla_graph}") + + fsttablecompose = kaldi_root / "src/fstbin/fsttablecompose" + fstdeterminizestar = kaldi_root / "src/fstbin/fstdeterminizestar" + fstrmsymbols = kaldi_root / "src/fstbin/fstrmsymbols" + fstrmepslocal = kaldi_root / "src/fstbin/fstrmepslocal" + fstminimizeencoded = kaldi_root / "src/fstbin/fstminimizeencoded" + + try: + with open(hla_graph, "wb") as out_f: + res = subprocess.run( + [ + fsttablecompose, + h_graph, + l_graph, + ], + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstdeterminizestar, "--use-log=true"], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstrmsymbols, disambig_in_words_file_int], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstrmepslocal], + input=res.stdout, + capture_output=True, + check=True, + ) + res = subprocess.run( + [fstminimizeencoded], + input=res.stdout, + capture_output=True, + check=True, + ) + out_f.write(res.stdout) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + os.remove(hla_graph) + raise + + return hla_graph + + +def create_HLG( + kaldi_root: Path, + fst_dir: Path, + unique_label: str, + hlga_graph: Path, + prefix: str = "HLG", +) -> Path: + hlg_graph = fst_dir / f"{prefix}.{unique_label}.fst" + + if not hlg_graph.exists(): + logger.info(f"Creating {hlg_graph}") + + add_self_loop = script_dir / "add-self-loop-simple" + kaldi_src = kaldi_root / "src" + kaldi_lib = kaldi_src / "lib" + + try: + if not add_self_loop.exists(): + fst_include = kaldi_root / "tools/openfst-1.6.7/include" + add_self_loop_src = script_dir / "add-self-loop-simple.cc" + + subprocess.run( + [ + "c++", + f"-I{kaldi_src}", + f"-I{fst_include}", + f"-L{kaldi_lib}", + add_self_loop_src, + "-lkaldi-base", + "-lkaldi-fstext", + "-o", + add_self_loop, + ], + check=True, + ) + + my_env = os.environ.copy() + my_env["LD_LIBRARY_PATH"] = f"{kaldi_lib}:{my_env['LD_LIBRARY_PATH']}" + + subprocess.run( + [ + add_self_loop, + hlga_graph, + hlg_graph, + ], + check=True, + capture_output=True, + env=my_env, + ) + except subprocess.CalledProcessError as e: + logger.error(f"cmd: {e.cmd}, err: {e.stderr.decode('utf-8')}") + raise + + return hlg_graph + + +def initalize_kaldi(cfg: KaldiInitializerConfig) -> Path: + if cfg.fst_dir is None: + cfg.fst_dir = osp.join(cfg.data_dir, "kaldi") + if cfg.out_labels is None: + cfg.out_labels = cfg.in_labels + + kaldi_root = Path(cfg.kaldi_root) + data_dir = Path(cfg.data_dir) + fst_dir = Path(cfg.fst_dir) + fst_dir.mkdir(parents=True, exist_ok=True) + + arpa_base = osp.splitext(osp.basename(cfg.lm_arpa))[0] + unique_label = f"{cfg.in_labels}.{arpa_base}" + + with open(data_dir / f"dict.{cfg.in_labels}.txt", "r") as f: + vocab = Dictionary.load(f) + + in_units_file = create_units(fst_dir, cfg.in_labels, vocab) + + grammar_graph, out_words_file = create_G( + kaldi_root, fst_dir, Path(cfg.lm_arpa), arpa_base + ) + + disambig_lexicon_file, disambig_L_in_units_file = create_lexicon( + cfg, fst_dir, unique_label, in_units_file, out_words_file + ) + + h_graph, h_out_units_file, disambig_in_units_file_int = create_H( + kaldi_root, + fst_dir, + disambig_L_in_units_file, + cfg.in_labels, + vocab, + cfg.blank_symbol, + cfg.silence_symbol, + ) + lexicon_graph = create_L( + kaldi_root, + fst_dir, + unique_label, + disambig_lexicon_file, + disambig_L_in_units_file, + out_words_file, + ) + lg_graph = create_LG( + kaldi_root, fst_dir, unique_label, lexicon_graph, grammar_graph + ) + hlga_graph = create_HLGa( + kaldi_root, fst_dir, unique_label, h_graph, lg_graph, disambig_in_units_file_int + ) + hlg_graph = create_HLG(kaldi_root, fst_dir, unique_label, hlga_graph) + + # for debugging + # hla_graph = create_HLa(kaldi_root, fst_dir, unique_label, h_graph, lexicon_graph, disambig_in_units_file_int) + # hl_graph = create_HLG(kaldi_root, fst_dir, unique_label, hla_graph, prefix="HL_looped") + # create_HLG(kaldi_root, fst_dir, "phnc", h_graph, prefix="H_looped") + + return hlg_graph + + +@hydra.main(config_path=config_path, config_name="kaldi_initializer") +def cli_main(cfg: KaldiInitializerConfig) -> None: + container = OmegaConf.to_container(cfg, resolve=True, enum_to_str=True) + cfg = OmegaConf.create(container) + OmegaConf.set_struct(cfg, True) + initalize_kaldi(cfg) + + +if __name__ == "__main__": + + logging.root.setLevel(logging.INFO) + logging.basicConfig(level=logging.INFO) + + try: + from hydra._internal.utils import ( + get_args, + ) # pylint: disable=import-outside-toplevel + + cfg_name = get_args().config_name or "kaldi_initializer" + except ImportError: + logger.warning("Failed to get config name from hydra args") + cfg_name = "kaldi_initializer" + + cs = ConfigStore.instance() + cs.store(name=cfg_name, node=KaldiInitializerConfig) + + cli_main() diff --git a/fairseq/examples/speech_recognition/models/__init__.py b/fairseq/examples/speech_recognition/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54b5a1c31243e55d384f80ef9514461cd35b15c6 --- /dev/null +++ b/fairseq/examples/speech_recognition/models/__init__.py @@ -0,0 +1,8 @@ +import importlib +import os + + +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + model_name = file[: file.find(".py")] + importlib.import_module("examples.speech_recognition.models." + model_name) diff --git a/fairseq/examples/speech_recognition/models/vggtransformer.py b/fairseq/examples/speech_recognition/models/vggtransformer.py new file mode 100644 index 0000000000000000000000000000000000000000..bca0ae59a8cbe2b7c337e395021c883a61d101ee --- /dev/null +++ b/fairseq/examples/speech_recognition/models/vggtransformer.py @@ -0,0 +1,1020 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import math +from collections.abc import Iterable + +import torch +import torch.nn as nn +from examples.speech_recognition.data.data_utils import lengths_to_encoder_padding_mask +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqEncoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + LinearizedConvolution, + TransformerDecoderLayer, + TransformerEncoderLayer, + VGGBlock, +) + + +@register_model("asr_vggtransformer") +class VGGTransformerModel(FairseqEncoderDecoderModel): + """ + Transformers with convolutional context for ASR + https://arxiv.org/abs/1904.11660 + """ + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--input-feat-per-channel", + type=int, + metavar="N", + help="encoder input dimension per input channel", + ) + parser.add_argument( + "--vggblock-enc-config", + type=str, + metavar="EXPR", + help=""" + an array of tuples each containing the configuration of one vggblock: + [(out_channels, + conv_kernel_size, + pooling_kernel_size, + num_conv_layers, + use_layer_norm), ...]) + """, + ) + parser.add_argument( + "--transformer-enc-config", + type=str, + metavar="EXPR", + help="""" + a tuple containing the configuration of the encoder transformer layers + configurations: + [(input_dim, + num_heads, + ffn_dim, + normalize_before, + dropout, + attention_dropout, + relu_dropout), ...]') + """, + ) + parser.add_argument( + "--enc-output-dim", + type=int, + metavar="N", + help=""" + encoder output dimension, can be None. If specified, projecting the + transformer output to the specified dimension""", + ) + parser.add_argument( + "--in-channels", + type=int, + metavar="N", + help="number of encoder input channels", + ) + parser.add_argument( + "--tgt-embed-dim", + type=int, + metavar="N", + help="embedding dimension of the decoder target tokens", + ) + parser.add_argument( + "--transformer-dec-config", + type=str, + metavar="EXPR", + help=""" + a tuple containing the configuration of the decoder transformer layers + configurations: + [(input_dim, + num_heads, + ffn_dim, + normalize_before, + dropout, + attention_dropout, + relu_dropout), ...] + """, + ) + parser.add_argument( + "--conv-dec-config", + type=str, + metavar="EXPR", + help=""" + an array of tuples for the decoder 1-D convolution config + [(out_channels, conv_kernel_size, use_layer_norm), ...]""", + ) + + @classmethod + def build_encoder(cls, args, task): + return VGGTransformerEncoder( + input_feat_per_channel=args.input_feat_per_channel, + vggblock_config=eval(args.vggblock_enc_config), + transformer_config=eval(args.transformer_enc_config), + encoder_output_dim=args.enc_output_dim, + in_channels=args.in_channels, + ) + + @classmethod + def build_decoder(cls, args, task): + return TransformerDecoder( + dictionary=task.target_dictionary, + embed_dim=args.tgt_embed_dim, + transformer_config=eval(args.transformer_dec_config), + conv_config=eval(args.conv_dec_config), + encoder_output_dim=args.enc_output_dim, + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted + # (in case there are any new ones) + base_architecture(args) + + encoder = cls.build_encoder(args, task) + decoder = cls.build_decoder(args, task) + return cls(encoder, decoder) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = super().get_normalized_probs(net_output, log_probs, sample) + lprobs.batch_first = True + return lprobs + + +DEFAULT_ENC_VGGBLOCK_CONFIG = ((32, 3, 2, 2, False),) * 2 +DEFAULT_ENC_TRANSFORMER_CONFIG = ((256, 4, 1024, True, 0.2, 0.2, 0.2),) * 2 +# 256: embedding dimension +# 4: number of heads +# 1024: FFN +# True: apply layerNorm before (dropout + resiaul) instead of after +# 0.2 (dropout): dropout after MultiheadAttention and second FC +# 0.2 (attention_dropout): dropout in MultiheadAttention +# 0.2 (relu_dropout): dropout after ReLu +DEFAULT_DEC_TRANSFORMER_CONFIG = ((256, 2, 1024, True, 0.2, 0.2, 0.2),) * 2 +DEFAULT_DEC_CONV_CONFIG = ((256, 3, True),) * 2 + + +# TODO: repace transformer encoder config from one liner +# to explicit args to get rid of this transformation +def prepare_transformer_encoder_params( + input_dim, + num_heads, + ffn_dim, + normalize_before, + dropout, + attention_dropout, + relu_dropout, +): + args = argparse.Namespace() + args.encoder_embed_dim = input_dim + args.encoder_attention_heads = num_heads + args.attention_dropout = attention_dropout + args.dropout = dropout + args.activation_dropout = relu_dropout + args.encoder_normalize_before = normalize_before + args.encoder_ffn_embed_dim = ffn_dim + return args + + +def prepare_transformer_decoder_params( + input_dim, + num_heads, + ffn_dim, + normalize_before, + dropout, + attention_dropout, + relu_dropout, +): + args = argparse.Namespace() + args.encoder_embed_dim = None + args.decoder_embed_dim = input_dim + args.decoder_attention_heads = num_heads + args.attention_dropout = attention_dropout + args.dropout = dropout + args.activation_dropout = relu_dropout + args.decoder_normalize_before = normalize_before + args.decoder_ffn_embed_dim = ffn_dim + return args + + +class VGGTransformerEncoder(FairseqEncoder): + """VGG + Transformer encoder""" + + def __init__( + self, + input_feat_per_channel, + vggblock_config=DEFAULT_ENC_VGGBLOCK_CONFIG, + transformer_config=DEFAULT_ENC_TRANSFORMER_CONFIG, + encoder_output_dim=512, + in_channels=1, + transformer_context=None, + transformer_sampling=None, + ): + """constructor for VGGTransformerEncoder + + Args: + - input_feat_per_channel: feature dim (not including stacked, + just base feature) + - in_channel: # input channels (e.g., if stack 8 feature vector + together, this is 8) + - vggblock_config: configuration of vggblock, see comments on + DEFAULT_ENC_VGGBLOCK_CONFIG + - transformer_config: configuration of transformer layer, see comments + on DEFAULT_ENC_TRANSFORMER_CONFIG + - encoder_output_dim: final transformer output embedding dimension + - transformer_context: (left, right) if set, self-attention will be focused + on (t-left, t+right) + - transformer_sampling: an iterable of int, must match with + len(transformer_config), transformer_sampling[i] indicates sampling + factor for i-th transformer layer, after multihead att and feedfoward + part + """ + super().__init__(None) + + self.num_vggblocks = 0 + if vggblock_config is not None: + if not isinstance(vggblock_config, Iterable): + raise ValueError("vggblock_config is not iterable") + self.num_vggblocks = len(vggblock_config) + + self.conv_layers = nn.ModuleList() + self.in_channels = in_channels + self.input_dim = input_feat_per_channel + self.pooling_kernel_sizes = [] + + if vggblock_config is not None: + for _, config in enumerate(vggblock_config): + ( + out_channels, + conv_kernel_size, + pooling_kernel_size, + num_conv_layers, + layer_norm, + ) = config + self.conv_layers.append( + VGGBlock( + in_channels, + out_channels, + conv_kernel_size, + pooling_kernel_size, + num_conv_layers, + input_dim=input_feat_per_channel, + layer_norm=layer_norm, + ) + ) + self.pooling_kernel_sizes.append(pooling_kernel_size) + in_channels = out_channels + input_feat_per_channel = self.conv_layers[-1].output_dim + + transformer_input_dim = self.infer_conv_output_dim( + self.in_channels, self.input_dim + ) + # transformer_input_dim is the output dimension of VGG part + + self.validate_transformer_config(transformer_config) + self.transformer_context = self.parse_transformer_context(transformer_context) + self.transformer_sampling = self.parse_transformer_sampling( + transformer_sampling, len(transformer_config) + ) + + self.transformer_layers = nn.ModuleList() + + if transformer_input_dim != transformer_config[0][0]: + self.transformer_layers.append( + Linear(transformer_input_dim, transformer_config[0][0]) + ) + self.transformer_layers.append( + TransformerEncoderLayer( + prepare_transformer_encoder_params(*transformer_config[0]) + ) + ) + + for i in range(1, len(transformer_config)): + if transformer_config[i - 1][0] != transformer_config[i][0]: + self.transformer_layers.append( + Linear(transformer_config[i - 1][0], transformer_config[i][0]) + ) + self.transformer_layers.append( + TransformerEncoderLayer( + prepare_transformer_encoder_params(*transformer_config[i]) + ) + ) + + self.encoder_output_dim = encoder_output_dim + self.transformer_layers.extend( + [ + Linear(transformer_config[-1][0], encoder_output_dim), + LayerNorm(encoder_output_dim), + ] + ) + + def forward(self, src_tokens, src_lengths, **kwargs): + """ + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (B,) + """ + bsz, max_seq_len, _ = src_tokens.size() + x = src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim) + x = x.transpose(1, 2).contiguous() + # (B, C, T, feat) + + for layer_idx in range(len(self.conv_layers)): + x = self.conv_layers[layer_idx](x) + + bsz, _, output_seq_len, _ = x.size() + + # (B, C, T, feat) -> (B, T, C, feat) -> (T, B, C, feat) -> (T, B, C * feat) + x = x.transpose(1, 2).transpose(0, 1) + x = x.contiguous().view(output_seq_len, bsz, -1) + + input_lengths = src_lengths.clone() + for s in self.pooling_kernel_sizes: + input_lengths = (input_lengths.float() / s).ceil().long() + + encoder_padding_mask, _ = lengths_to_encoder_padding_mask( + input_lengths, batch_first=True + ) + if not encoder_padding_mask.any(): + encoder_padding_mask = None + + subsampling_factor = int(max_seq_len * 1.0 / output_seq_len + 0.5) + attn_mask = self.lengths_to_attn_mask(input_lengths, subsampling_factor) + + transformer_layer_idx = 0 + + for layer_idx in range(len(self.transformer_layers)): + + if isinstance(self.transformer_layers[layer_idx], TransformerEncoderLayer): + x = self.transformer_layers[layer_idx]( + x, encoder_padding_mask, attn_mask + ) + + if self.transformer_sampling[transformer_layer_idx] != 1: + sampling_factor = self.transformer_sampling[transformer_layer_idx] + x, encoder_padding_mask, attn_mask = self.slice( + x, encoder_padding_mask, attn_mask, sampling_factor + ) + + transformer_layer_idx += 1 + + else: + x = self.transformer_layers[layer_idx](x) + + # encoder_padding_maks is a (T x B) tensor, its [t, b] elements indicate + # whether encoder_output[t, b] is valid or not (valid=0, invalid=1) + + return { + "encoder_out": x, # (T, B, C) + "encoder_padding_mask": encoder_padding_mask.t() + if encoder_padding_mask is not None + else None, + # (B, T) --> (T, B) + } + + def infer_conv_output_dim(self, in_channels, input_dim): + sample_seq_len = 200 + sample_bsz = 10 + x = torch.randn(sample_bsz, in_channels, sample_seq_len, input_dim) + for i, _ in enumerate(self.conv_layers): + x = self.conv_layers[i](x) + x = x.transpose(1, 2) + mb, seq = x.size()[:2] + return x.contiguous().view(mb, seq, -1).size(-1) + + def validate_transformer_config(self, transformer_config): + for config in transformer_config: + input_dim, num_heads = config[:2] + if input_dim % num_heads != 0: + msg = ( + "ERROR in transformer config {}: ".format(config) + + "input dimension {} ".format(input_dim) + + "not dividable by number of heads {}".format(num_heads) + ) + raise ValueError(msg) + + def parse_transformer_context(self, transformer_context): + """ + transformer_context can be the following: + - None; indicates no context is used, i.e., + transformer can access full context + - a tuple/list of two int; indicates left and right context, + any number <0 indicates infinite context + * e.g., (5, 6) indicates that for query at x_t, transformer can + access [t-5, t+6] (inclusive) + * e.g., (-1, 6) indicates that for query at x_t, transformer can + access [0, t+6] (inclusive) + """ + if transformer_context is None: + return None + + if not isinstance(transformer_context, Iterable): + raise ValueError("transformer context must be Iterable if it is not None") + + if len(transformer_context) != 2: + raise ValueError("transformer context must have length 2") + + left_context = transformer_context[0] + if left_context < 0: + left_context = None + + right_context = transformer_context[1] + if right_context < 0: + right_context = None + + if left_context is None and right_context is None: + return None + + return (left_context, right_context) + + def parse_transformer_sampling(self, transformer_sampling, num_layers): + """ + parsing transformer sampling configuration + + Args: + - transformer_sampling, accepted input: + * None, indicating no sampling + * an Iterable with int (>0) as element + - num_layers, expected number of transformer layers, must match with + the length of transformer_sampling if it is not None + + Returns: + - A tuple with length num_layers + """ + if transformer_sampling is None: + return (1,) * num_layers + + if not isinstance(transformer_sampling, Iterable): + raise ValueError( + "transformer_sampling must be an iterable if it is not None" + ) + + if len(transformer_sampling) != num_layers: + raise ValueError( + "transformer_sampling {} does not match with the number " + "of layers {}".format(transformer_sampling, num_layers) + ) + + for layer, value in enumerate(transformer_sampling): + if not isinstance(value, int): + raise ValueError("Invalid value in transformer_sampling: ") + if value < 1: + raise ValueError( + "{} layer's subsampling is {}.".format(layer, value) + + " This is not allowed! " + ) + return transformer_sampling + + def slice(self, embedding, padding_mask, attn_mask, sampling_factor): + """ + embedding is a (T, B, D) tensor + padding_mask is a (B, T) tensor or None + attn_mask is a (T, T) tensor or None + """ + embedding = embedding[::sampling_factor, :, :] + if padding_mask is not None: + padding_mask = padding_mask[:, ::sampling_factor] + if attn_mask is not None: + attn_mask = attn_mask[::sampling_factor, ::sampling_factor] + + return embedding, padding_mask, attn_mask + + def lengths_to_attn_mask(self, input_lengths, subsampling_factor=1): + """ + create attention mask according to sequence lengths and transformer + context + + Args: + - input_lengths: (B, )-shape Int/Long tensor; input_lengths[b] is + the length of b-th sequence + - subsampling_factor: int + * Note that the left_context and right_context is specified in + the input frame-level while input to transformer may already + go through subsampling (e.g., the use of striding in vggblock) + we use subsampling_factor to scale the left/right context + + Return: + - a (T, T) binary tensor or None, where T is max(input_lengths) + * if self.transformer_context is None, None + * if left_context is None, + * attn_mask[t, t + right_context + 1:] = 1 + * others = 0 + * if right_context is None, + * attn_mask[t, 0:t - left_context] = 1 + * others = 0 + * elsif + * attn_mask[t, t - left_context: t + right_context + 1] = 0 + * others = 1 + """ + if self.transformer_context is None: + return None + + maxT = torch.max(input_lengths).item() + attn_mask = torch.zeros(maxT, maxT) + + left_context = self.transformer_context[0] + right_context = self.transformer_context[1] + if left_context is not None: + left_context = math.ceil(self.transformer_context[0] / subsampling_factor) + if right_context is not None: + right_context = math.ceil(self.transformer_context[1] / subsampling_factor) + + for t in range(maxT): + if left_context is not None: + st = 0 + en = max(st, t - left_context) + attn_mask[t, st:en] = 1 + if right_context is not None: + st = t + right_context + 1 + st = min(st, maxT - 1) + attn_mask[t, st:] = 1 + + return attn_mask.to(input_lengths.device) + + def reorder_encoder_out(self, encoder_out, new_order): + encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select( + 1, new_order + ) + if encoder_out["encoder_padding_mask"] is not None: + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(1, new_order) + return encoder_out + + +class TransformerDecoder(FairseqIncrementalDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs. + Default: ``False`` + left_pad (bool, optional): whether the input is left-padded. Default: + ``False`` + """ + + def __init__( + self, + dictionary, + embed_dim=512, + transformer_config=DEFAULT_ENC_TRANSFORMER_CONFIG, + conv_config=DEFAULT_DEC_CONV_CONFIG, + encoder_output_dim=512, + ): + + super().__init__(dictionary) + vocab_size = len(dictionary) + self.padding_idx = dictionary.pad() + self.embed_tokens = Embedding(vocab_size, embed_dim, self.padding_idx) + + self.conv_layers = nn.ModuleList() + for i in range(len(conv_config)): + out_channels, kernel_size, layer_norm = conv_config[i] + if i == 0: + conv_layer = LinearizedConv1d( + embed_dim, out_channels, kernel_size, padding=kernel_size - 1 + ) + else: + conv_layer = LinearizedConv1d( + conv_config[i - 1][0], + out_channels, + kernel_size, + padding=kernel_size - 1, + ) + self.conv_layers.append(conv_layer) + if layer_norm: + self.conv_layers.append(nn.LayerNorm(out_channels)) + self.conv_layers.append(nn.ReLU()) + + self.layers = nn.ModuleList() + if conv_config[-1][0] != transformer_config[0][0]: + self.layers.append(Linear(conv_config[-1][0], transformer_config[0][0])) + self.layers.append( + TransformerDecoderLayer( + prepare_transformer_decoder_params(*transformer_config[0]) + ) + ) + + for i in range(1, len(transformer_config)): + if transformer_config[i - 1][0] != transformer_config[i][0]: + self.layers.append( + Linear(transformer_config[i - 1][0], transformer_config[i][0]) + ) + self.layers.append( + TransformerDecoderLayer( + prepare_transformer_decoder_params(*transformer_config[i]) + ) + ) + self.fc_out = Linear(transformer_config[-1][0], vocab_size) + + def forward(self, prev_output_tokens, encoder_out=None, incremental_state=None): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for input feeding/teacher forcing + encoder_out (Tensor, optional): output from the encoder, used for + encoder-side attention + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + Returns: + tuple: + - the last decoder layer's output of shape `(batch, tgt_len, + vocab)` + - the last decoder layer's attention weights of shape `(batch, + tgt_len, src_len)` + """ + target_padding_mask = ( + (prev_output_tokens == self.padding_idx).to(prev_output_tokens.device) + if incremental_state is None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + + # embed tokens + x = self.embed_tokens(prev_output_tokens) + + # B x T x C -> T x B x C + x = self._transpose_if_training(x, incremental_state) + + for layer in self.conv_layers: + if isinstance(layer, LinearizedConvolution): + x = layer(x, incremental_state) + else: + x = layer(x) + + # B x T x C -> T x B x C + x = self._transpose_if_inference(x, incremental_state) + + # decoder layers + for layer in self.layers: + if isinstance(layer, TransformerDecoderLayer): + x, *_ = layer( + x, + (encoder_out["encoder_out"] if encoder_out is not None else None), + ( + encoder_out["encoder_padding_mask"].t() + if encoder_out["encoder_padding_mask"] is not None + else None + ), + incremental_state, + self_attn_mask=( + self.buffered_future_mask(x) + if incremental_state is None + else None + ), + self_attn_padding_mask=( + target_padding_mask if incremental_state is None else None + ), + ) + else: + x = layer(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + x = self.fc_out(x) + + return x, None + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + not hasattr(self, "_future_mask") + or self._future_mask is None + or self._future_mask.device != tensor.device + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(tensor.new(dim, dim)), 1 + ) + if self._future_mask.size(0) < dim: + self._future_mask = torch.triu( + utils.fill_with_neg_inf(self._future_mask.resize_(dim, dim)), 1 + ) + return self._future_mask[:dim, :dim] + + def _transpose_if_training(self, x, incremental_state): + if incremental_state is None: + x = x.transpose(0, 1) + return x + + def _transpose_if_inference(self, x, incremental_state): + if incremental_state: + x = x.transpose(0, 1) + return x + + +@register_model("asr_vggtransformer_encoder") +class VGGTransformerEncoderModel(FairseqEncoderModel): + def __init__(self, encoder): + super().__init__(encoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--input-feat-per-channel", + type=int, + metavar="N", + help="encoder input dimension per input channel", + ) + parser.add_argument( + "--vggblock-enc-config", + type=str, + metavar="EXPR", + help=""" + an array of tuples each containing the configuration of one vggblock + [(out_channels, conv_kernel_size, pooling_kernel_size,num_conv_layers), ...] + """, + ) + parser.add_argument( + "--transformer-enc-config", + type=str, + metavar="EXPR", + help=""" + a tuple containing the configuration of the Transformer layers + configurations: + [(input_dim, + num_heads, + ffn_dim, + normalize_before, + dropout, + attention_dropout, + relu_dropout), ]""", + ) + parser.add_argument( + "--enc-output-dim", + type=int, + metavar="N", + help="encoder output dimension, projecting the LSTM output", + ) + parser.add_argument( + "--in-channels", + type=int, + metavar="N", + help="number of encoder input channels", + ) + parser.add_argument( + "--transformer-context", + type=str, + metavar="EXPR", + help=""" + either None or a tuple of two ints, indicating left/right context a + transformer can have access to""", + ) + parser.add_argument( + "--transformer-sampling", + type=str, + metavar="EXPR", + help=""" + either None or a tuple of ints, indicating sampling factor in each layer""", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + base_architecture_enconly(args) + encoder = VGGTransformerEncoderOnly( + vocab_size=len(task.target_dictionary), + input_feat_per_channel=args.input_feat_per_channel, + vggblock_config=eval(args.vggblock_enc_config), + transformer_config=eval(args.transformer_enc_config), + encoder_output_dim=args.enc_output_dim, + in_channels=args.in_channels, + transformer_context=eval(args.transformer_context), + transformer_sampling=eval(args.transformer_sampling), + ) + return cls(encoder) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + # net_output['encoder_out'] is a (T, B, D) tensor + lprobs = super().get_normalized_probs(net_output, log_probs, sample) + # lprobs is a (T, B, D) tensor + # we need to transoose to get (B, T, D) tensor + lprobs = lprobs.transpose(0, 1).contiguous() + lprobs.batch_first = True + return lprobs + + +class VGGTransformerEncoderOnly(VGGTransformerEncoder): + def __init__( + self, + vocab_size, + input_feat_per_channel, + vggblock_config=DEFAULT_ENC_VGGBLOCK_CONFIG, + transformer_config=DEFAULT_ENC_TRANSFORMER_CONFIG, + encoder_output_dim=512, + in_channels=1, + transformer_context=None, + transformer_sampling=None, + ): + super().__init__( + input_feat_per_channel=input_feat_per_channel, + vggblock_config=vggblock_config, + transformer_config=transformer_config, + encoder_output_dim=encoder_output_dim, + in_channels=in_channels, + transformer_context=transformer_context, + transformer_sampling=transformer_sampling, + ) + self.fc_out = Linear(self.encoder_output_dim, vocab_size) + + def forward(self, src_tokens, src_lengths, **kwargs): + """ + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (B,) + """ + + enc_out = super().forward(src_tokens, src_lengths) + x = self.fc_out(enc_out["encoder_out"]) + # x = F.log_softmax(x, dim=-1) + # Note: no need this line, because model.get_normalized_prob will call + # log_softmax + return { + "encoder_out": x, # (T, B, C) + "encoder_padding_mask": enc_out["encoder_padding_mask"], # (T, B) + } + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return (1e6, 1e6) # an arbitrary large number + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + # nn.init.uniform_(m.weight, -0.1, 0.1) + # nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, bias=True, dropout=0): + """Linear layer (input: N x T x C)""" + m = nn.Linear(in_features, out_features, bias=bias) + # m.weight.data.uniform_(-0.1, 0.1) + # if bias: + # m.bias.data.uniform_(-0.1, 0.1) + return m + + +def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0, **kwargs): + """Weight-normalized Conv1d layer optimized for decoding""" + m = LinearizedConvolution(in_channels, out_channels, kernel_size, **kwargs) + std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels)) + nn.init.normal_(m.weight, mean=0, std=std) + nn.init.constant_(m.bias, 0) + return nn.utils.weight_norm(m, dim=2) + + +def LayerNorm(embedding_dim): + m = nn.LayerNorm(embedding_dim) + return m + + +# seq2seq models +def base_architecture(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 40) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", DEFAULT_ENC_VGGBLOCK_CONFIG + ) + args.transformer_enc_config = getattr( + args, "transformer_enc_config", DEFAULT_ENC_TRANSFORMER_CONFIG + ) + args.enc_output_dim = getattr(args, "enc_output_dim", 512) + args.in_channels = getattr(args, "in_channels", 1) + args.tgt_embed_dim = getattr(args, "tgt_embed_dim", 128) + args.transformer_dec_config = getattr( + args, "transformer_dec_config", DEFAULT_ENC_TRANSFORMER_CONFIG + ) + args.conv_dec_config = getattr(args, "conv_dec_config", DEFAULT_DEC_CONV_CONFIG) + args.transformer_context = getattr(args, "transformer_context", "None") + + +@register_model_architecture("asr_vggtransformer", "vggtransformer_1") +def vggtransformer_1(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", "[(64, 3, 2, 2, True), (128, 3, 2, 2, True)]" + ) + args.transformer_enc_config = getattr( + args, + "transformer_enc_config", + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 14", + ) + args.enc_output_dim = getattr(args, "enc_output_dim", 1024) + args.tgt_embed_dim = getattr(args, "tgt_embed_dim", 128) + args.conv_dec_config = getattr(args, "conv_dec_config", "((256, 3, True),) * 4") + args.transformer_dec_config = getattr( + args, + "transformer_dec_config", + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 4", + ) + + +@register_model_architecture("asr_vggtransformer", "vggtransformer_2") +def vggtransformer_2(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", "[(64, 3, 2, 2, True), (128, 3, 2, 2, True)]" + ) + args.transformer_enc_config = getattr( + args, + "transformer_enc_config", + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 16", + ) + args.enc_output_dim = getattr(args, "enc_output_dim", 1024) + args.tgt_embed_dim = getattr(args, "tgt_embed_dim", 512) + args.conv_dec_config = getattr(args, "conv_dec_config", "((256, 3, True),) * 4") + args.transformer_dec_config = getattr( + args, + "transformer_dec_config", + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 6", + ) + + +@register_model_architecture("asr_vggtransformer", "vggtransformer_base") +def vggtransformer_base(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", "[(64, 3, 2, 2, True), (128, 3, 2, 2, True)]" + ) + args.transformer_enc_config = getattr( + args, "transformer_enc_config", "((512, 8, 2048, True, 0.15, 0.15, 0.15),) * 12" + ) + + args.enc_output_dim = getattr(args, "enc_output_dim", 512) + args.tgt_embed_dim = getattr(args, "tgt_embed_dim", 512) + args.conv_dec_config = getattr(args, "conv_dec_config", "((256, 3, True),) * 4") + args.transformer_dec_config = getattr( + args, "transformer_dec_config", "((512, 8, 2048, True, 0.15, 0.15, 0.15),) * 6" + ) + # Size estimations: + # Encoder: + # - vggblock param: 64*1*3*3 + 64*64*3*3 + 128*64*3*3 + 128*128*3 = 258K + # Transformer: + # - input dimension adapter: 2560 x 512 -> 1.31M + # - transformer_layers (x12) --> 37.74M + # * MultiheadAttention: 512*512*3 (in_proj) + 512*512 (out_proj) = 1.048M + # * FFN weight: 512*2048*2 = 2.097M + # - output dimension adapter: 512 x 512 -> 0.26 M + # Decoder: + # - LinearizedConv1d: 512 * 256 * 3 + 256 * 256 * 3 * 3 + # - transformer_layer: (x6) --> 25.16M + # * MultiheadAttention (self-attention): 512*512*3 + 512*512 = 1.048M + # * MultiheadAttention (encoder-attention): 512*512*3 + 512*512 = 1.048M + # * FFN: 512*2048*2 = 2.097M + # Final FC: + # - FC: 512*5000 = 256K (assuming vocab size 5K) + # In total: + # ~65 M + + +# CTC models +def base_architecture_enconly(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 40) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", "[(32, 3, 2, 2, True)] * 2" + ) + args.transformer_enc_config = getattr( + args, "transformer_enc_config", "((256, 4, 1024, True, 0.2, 0.2, 0.2),) * 2" + ) + args.enc_output_dim = getattr(args, "enc_output_dim", 512) + args.in_channels = getattr(args, "in_channels", 1) + args.transformer_context = getattr(args, "transformer_context", "None") + args.transformer_sampling = getattr(args, "transformer_sampling", "None") + + +@register_model_architecture("asr_vggtransformer_encoder", "vggtransformer_enc_1") +def vggtransformer_enc_1(args): + # vggtransformer_1 is the same as vggtransformer_enc_big, except the number + # of layers is increased to 16 + # keep it here for backward compatiablity purpose + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.vggblock_enc_config = getattr( + args, "vggblock_enc_config", "[(64, 3, 2, 2, True), (128, 3, 2, 2, True)]" + ) + args.transformer_enc_config = getattr( + args, + "transformer_enc_config", + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 16", + ) + args.enc_output_dim = getattr(args, "enc_output_dim", 1024) diff --git a/fairseq/examples/speech_recognition/models/w2l_conv_glu_enc.py b/fairseq/examples/speech_recognition/models/w2l_conv_glu_enc.py new file mode 100644 index 0000000000000000000000000000000000000000..655a9b0d19d11e35511392a016f9d6b7d7aa2925 --- /dev/null +++ b/fairseq/examples/speech_recognition/models/w2l_conv_glu_enc.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderModel, + register_model, + register_model_architecture, +) +from fairseq.modules.fairseq_dropout import FairseqDropout + + +default_conv_enc_config = """[ + (400, 13, 170, 0.2), + (440, 14, 0, 0.214), + (484, 15, 0, 0.22898), + (532, 16, 0, 0.2450086), + (584, 17, 0, 0.262159202), + (642, 18, 0, 0.28051034614), + (706, 19, 0, 0.30014607037), + (776, 20, 0, 0.321156295296), + (852, 21, 0, 0.343637235966), + (936, 22, 0, 0.367691842484), + (1028, 23, 0, 0.393430271458), + (1130, 24, 0, 0.42097039046), + (1242, 25, 0, 0.450438317792), + (1366, 26, 0, 0.481969000038), + (1502, 27, 0, 0.51570683004), + (1652, 28, 0, 0.551806308143), + (1816, 29, 0, 0.590432749713), +]""" + + +@register_model("asr_w2l_conv_glu_encoder") +class W2lConvGluEncoderModel(FairseqEncoderModel): + def __init__(self, encoder): + super().__init__(encoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--input-feat-per-channel", + type=int, + metavar="N", + help="encoder input dimension per input channel", + ) + parser.add_argument( + "--in-channels", + type=int, + metavar="N", + help="number of encoder input channels", + ) + parser.add_argument( + "--conv-enc-config", + type=str, + metavar="EXPR", + help=""" + an array of tuples each containing the configuration of one conv layer + [(out_channels, kernel_size, padding, dropout), ...] + """, + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + conv_enc_config = getattr(args, "conv_enc_config", default_conv_enc_config) + encoder = W2lConvGluEncoder( + vocab_size=len(task.target_dictionary), + input_feat_per_channel=args.input_feat_per_channel, + in_channels=args.in_channels, + conv_enc_config=eval(conv_enc_config), + ) + return cls(encoder) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + lprobs = super().get_normalized_probs(net_output, log_probs, sample) + lprobs.batch_first = False + return lprobs + + +class W2lConvGluEncoder(FairseqEncoder): + def __init__( + self, vocab_size, input_feat_per_channel, in_channels, conv_enc_config + ): + super().__init__(None) + + self.input_dim = input_feat_per_channel + if in_channels != 1: + raise ValueError("only 1 input channel is currently supported") + + self.conv_layers = nn.ModuleList() + self.linear_layers = nn.ModuleList() + self.dropouts = [] + cur_channels = input_feat_per_channel + + for out_channels, kernel_size, padding, dropout in conv_enc_config: + layer = nn.Conv1d(cur_channels, out_channels, kernel_size, padding=padding) + layer.weight.data.mul_(math.sqrt(3)) # match wav2letter init + self.conv_layers.append(nn.utils.weight_norm(layer)) + self.dropouts.append( + FairseqDropout(dropout, module_name=self.__class__.__name__) + ) + if out_channels % 2 != 0: + raise ValueError("odd # of out_channels is incompatible with GLU") + cur_channels = out_channels // 2 # halved by GLU + + for out_channels in [2 * cur_channels, vocab_size]: + layer = nn.Linear(cur_channels, out_channels) + layer.weight.data.mul_(math.sqrt(3)) + self.linear_layers.append(nn.utils.weight_norm(layer)) + cur_channels = out_channels // 2 + + def forward(self, src_tokens, src_lengths, **kwargs): + + """ + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (B,) + """ + B, T, _ = src_tokens.size() + x = src_tokens.transpose(1, 2).contiguous() # (B, feat, T) assuming C == 1 + + for layer_idx in range(len(self.conv_layers)): + x = self.conv_layers[layer_idx](x) + x = F.glu(x, dim=1) + x = self.dropouts[layer_idx](x) + + x = x.transpose(1, 2).contiguous() # (B, T, 908) + x = self.linear_layers[0](x) + x = F.glu(x, dim=2) + x = self.dropouts[-1](x) + x = self.linear_layers[1](x) + + assert x.size(0) == B + assert x.size(1) == T + + encoder_out = x.transpose(0, 1) # (T, B, vocab_size) + + # need to debug this -- find a simpler/elegant way in pytorch APIs + encoder_padding_mask = ( + torch.arange(T).view(1, T).expand(B, -1).to(x.device) + >= src_lengths.view(B, 1).expand(-1, T) + ).t() # (B x T) -> (T x B) + + return { + "encoder_out": encoder_out, # (T, B, vocab_size) + "encoder_padding_mask": encoder_padding_mask, # (T, B) + } + + def reorder_encoder_out(self, encoder_out, new_order): + encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select( + 1, new_order + ) + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(1, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return (1e6, 1e6) # an arbitrary large number + + +@register_model_architecture("asr_w2l_conv_glu_encoder", "w2l_conv_glu_enc") +def w2l_conv_glu_enc(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.in_channels = getattr(args, "in_channels", 1) + args.conv_enc_config = getattr(args, "conv_enc_config", default_conv_enc_config) diff --git a/fairseq/examples/speech_recognition/new/README.md b/fairseq/examples/speech_recognition/new/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5fa0e97245d3ba6db69d11222261b0644960183d --- /dev/null +++ b/fairseq/examples/speech_recognition/new/README.md @@ -0,0 +1,43 @@ +# Flashlight Decoder + +This script runs decoding for pre-trained speech recognition models. + +## Usage + +Assuming a few variables: + +```bash +checkpoint=<path-to-checkpoint> +data=<path-to-data-directory> +lm_model=<path-to-language-model> +lexicon=<path-to-lexicon> +``` + +Example usage for decoding a fine-tuned Wav2Vec model: + +```bash +python $FAIRSEQ_ROOT/examples/speech_recognition/new/infer.py --multirun \ + task=audio_pretraining \ + task.data=$data \ + task.labels=ltr \ + common_eval.path=$checkpoint \ + decoding.type=kenlm \ + decoding.lexicon=$lexicon \ + decoding.lmpath=$lm_model \ + dataset.gen_subset=dev_clean,dev_other,test_clean,test_other +``` + +Example usage for using Ax to sweep WER parameters (requires `pip install hydra-ax-sweeper`): + +```bash +python $FAIRSEQ_ROOT/examples/speech_recognition/new/infer.py --multirun \ + hydra/sweeper=ax \ + task=audio_pretraining \ + task.data=$data \ + task.labels=ltr \ + common_eval.path=$checkpoint \ + decoding.type=kenlm \ + decoding.lexicon=$lexicon \ + decoding.lmpath=$lm_model \ + dataset.gen_subset=dev_other +``` diff --git a/fairseq/examples/speech_recognition/new/__init__.py b/fairseq/examples/speech_recognition/new/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/speech_recognition/new/conf/hydra/sweeper/ax.yaml b/fairseq/examples/speech_recognition/new/conf/hydra/sweeper/ax.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fbeff17ca6b5fb0a1b44de0abe0d1a3d3d2aeeb2 --- /dev/null +++ b/fairseq/examples/speech_recognition/new/conf/hydra/sweeper/ax.yaml @@ -0,0 +1,26 @@ +# @package hydra.sweeper +_target_: hydra_plugins.hydra_ax_sweeper.ax_sweeper.AxSweeper +max_batch_size: null +ax_config: + max_trials: 128 + early_stop: + minimize: true + max_epochs_without_improvement: 32 + epsilon: 1.0e-05 + experiment: + name: ${dataset.gen_subset} + objective_name: wer + minimize: true + parameter_constraints: null + outcome_constraints: null + status_quo: null + client: + verbose_logging: false + random_seed: null + params: + decoding.lmweight: + type: range + bounds: [0.0, 5.0] + decoding.wordscore: + type: range + bounds: [-5.0, 5.0] diff --git a/fairseq/examples/speech_recognition/new/conf/infer.yaml b/fairseq/examples/speech_recognition/new/conf/infer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f176228082478fae0586a6da60a437e7b377b9ae --- /dev/null +++ b/fairseq/examples/speech_recognition/new/conf/infer.yaml @@ -0,0 +1,25 @@ +# @package _group_ + +defaults: + - task: null + - model: null + +hydra: + run: + dir: ${common_eval.results_path}/${dataset.gen_subset} + sweep: + dir: ${common_eval.results_path} + subdir: ${dataset.gen_subset} +common_eval: + results_path: null + path: null + post_process: letter + quiet: true +dataset: + max_tokens: 1000000 + gen_subset: test +distributed_training: + distributed_world_size: 1 +decoding: + beam: 5 + type: viterbi diff --git a/fairseq/examples/speech_recognition/new/decoders/__init__.py b/fairseq/examples/speech_recognition/new/decoders/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/speech_recognition/new/decoders/base_decoder.py b/fairseq/examples/speech_recognition/new/decoders/base_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..a097969b3c0650cf8ea2ab5f8e96bbc68ea9b97f --- /dev/null +++ b/fairseq/examples/speech_recognition/new/decoders/base_decoder.py @@ -0,0 +1,62 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools as it +from typing import Any, Dict, List + +import torch +from fairseq.data.dictionary import Dictionary +from fairseq.models.fairseq_model import FairseqModel + + +class BaseDecoder: + def __init__(self, tgt_dict: Dictionary) -> None: + self.tgt_dict = tgt_dict + self.vocab_size = len(tgt_dict) + + self.blank = ( + tgt_dict.index("<ctc_blank>") + if "<ctc_blank>" in tgt_dict.indices + else tgt_dict.bos() + ) + if "<sep>" in tgt_dict.indices: + self.silence = tgt_dict.index("<sep>") + elif "|" in tgt_dict.indices: + self.silence = tgt_dict.index("|") + else: + self.silence = tgt_dict.eos() + + def generate( + self, models: List[FairseqModel], sample: Dict[str, Any], **unused + ) -> List[List[Dict[str, torch.LongTensor]]]: + encoder_input = { + k: v for k, v in sample["net_input"].items() if k != "prev_output_tokens" + } + emissions = self.get_emissions(models, encoder_input) + return self.decode(emissions) + + def get_emissions( + self, + models: List[FairseqModel], + encoder_input: Dict[str, Any], + ) -> torch.FloatTensor: + model = models[0] + encoder_out = model(**encoder_input) + if hasattr(model, "get_logits"): + emissions = model.get_logits(encoder_out) + else: + emissions = model.get_normalized_probs(encoder_out, log_probs=True) + return emissions.transpose(0, 1).float().cpu().contiguous() + + def get_tokens(self, idxs: torch.IntTensor) -> torch.LongTensor: + idxs = (g[0] for g in it.groupby(idxs)) + idxs = filter(lambda x: x != self.blank, idxs) + return torch.LongTensor(list(idxs)) + + def decode( + self, + emissions: torch.FloatTensor, + ) -> List[List[Dict[str, torch.LongTensor]]]: + raise NotImplementedError diff --git a/fairseq/examples/speech_recognition/new/decoders/decoder.py b/fairseq/examples/speech_recognition/new/decoders/decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..b5bec8cf707b53104ef7a45993a5db2893d3443b --- /dev/null +++ b/fairseq/examples/speech_recognition/new/decoders/decoder.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Union + +from fairseq.data.dictionary import Dictionary + +from .decoder_config import DecoderConfig, FlashlightDecoderConfig +from .base_decoder import BaseDecoder + + +def Decoder( + cfg: Union[DecoderConfig, FlashlightDecoderConfig], tgt_dict: Dictionary +) -> BaseDecoder: + + if cfg.type == "viterbi": + from .viterbi_decoder import ViterbiDecoder + + return ViterbiDecoder(tgt_dict) + if cfg.type == "kenlm": + from .flashlight_decoder import KenLMDecoder + + return KenLMDecoder(cfg, tgt_dict) + if cfg.type == "fairseqlm": + from .flashlight_decoder import FairseqLMDecoder + + return FairseqLMDecoder(cfg, tgt_dict) + raise NotImplementedError(f"Invalid decoder name: {cfg.name}") diff --git a/fairseq/examples/speech_recognition/new/decoders/decoder_config.py b/fairseq/examples/speech_recognition/new/decoders/decoder_config.py new file mode 100644 index 0000000000000000000000000000000000000000..659eb94a9b8187a7c126d7b439ac2742f9d72022 --- /dev/null +++ b/fairseq/examples/speech_recognition/new/decoders/decoder_config.py @@ -0,0 +1,70 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import Optional + +from fairseq.dataclass.configs import FairseqDataclass +from fairseq.dataclass.constants import ChoiceEnum +from omegaconf import MISSING + + +DECODER_CHOICES = ChoiceEnum(["viterbi", "kenlm", "fairseqlm"]) + + +@dataclass +class DecoderConfig(FairseqDataclass): + type: DECODER_CHOICES = field( + default="viterbi", + metadata={"help": "The type of decoder to use"}, + ) + + +@dataclass +class FlashlightDecoderConfig(FairseqDataclass): + nbest: int = field( + default=1, + metadata={"help": "Number of decodings to return"}, + ) + unitlm: bool = field( + default=False, + metadata={"help": "If set, use unit language model"}, + ) + lmpath: str = field( + default=MISSING, + metadata={"help": "Language model for KenLM decoder"}, + ) + lexicon: Optional[str] = field( + default=None, + metadata={"help": "Lexicon for Flashlight decoder"}, + ) + beam: int = field( + default=50, + metadata={"help": "Number of beams to use for decoding"}, + ) + beamthreshold: float = field( + default=50.0, + metadata={"help": "Threshold for beam search decoding"}, + ) + beamsizetoken: Optional[int] = field( + default=None, metadata={"help": "Beam size to use"} + ) + wordscore: float = field( + default=-1, + metadata={"help": "Word score for KenLM decoder"}, + ) + unkweight: float = field( + default=-math.inf, + metadata={"help": "Unknown weight for KenLM decoder"}, + ) + silweight: float = field( + default=0, + metadata={"help": "Silence weight for KenLM decoder"}, + ) + lmweight: float = field( + default=2, + metadata={"help": "Weight for LM while interpolating score"}, + ) diff --git a/fairseq/examples/speech_recognition/new/decoders/flashlight_decoder.py b/fairseq/examples/speech_recognition/new/decoders/flashlight_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..38c7ac492f390a367a64769d7a72fe228df097c7 --- /dev/null +++ b/fairseq/examples/speech_recognition/new/decoders/flashlight_decoder.py @@ -0,0 +1,431 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import gc +import os.path as osp +import warnings +from collections import deque, namedtuple +from typing import Any, Dict, Tuple + +import numpy as np +import torch +from fairseq import tasks +from fairseq.data.dictionary import Dictionary +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.models.fairseq_model import FairseqModel +from fairseq.utils import apply_to_sample +from omegaconf import open_dict, OmegaConf + +from typing import List + +from .decoder_config import FlashlightDecoderConfig +from .base_decoder import BaseDecoder + +try: + from flashlight.lib.text.decoder import ( + LM, + CriterionType, + DecodeResult, + KenLM, + LexiconDecoder, + LexiconDecoderOptions, + LexiconFreeDecoder, + LexiconFreeDecoderOptions, + LMState, + SmearingMode, + Trie, + ) + from flashlight.lib.text.dictionary import create_word_dict, load_words +except ImportError: + warnings.warn( + "flashlight python bindings are required to use this functionality. " + "Please install from " + "https://github.com/facebookresearch/flashlight/tree/master/bindings/python" + ) + LM = object + LMState = object + + +class KenLMDecoder(BaseDecoder): + def __init__(self, cfg: FlashlightDecoderConfig, tgt_dict: Dictionary) -> None: + super().__init__(tgt_dict) + + self.nbest = cfg.nbest + self.unitlm = cfg.unitlm + + if cfg.lexicon: + self.lexicon = load_words(cfg.lexicon) + self.word_dict = create_word_dict(self.lexicon) + self.unk_word = self.word_dict.get_index("<unk>") + + self.lm = KenLM(cfg.lmpath, self.word_dict) + self.trie = Trie(self.vocab_size, self.silence) + + start_state = self.lm.start(False) + for word, spellings in self.lexicon.items(): + word_idx = self.word_dict.get_index(word) + _, score = self.lm.score(start_state, word_idx) + for spelling in spellings: + spelling_idxs = [tgt_dict.index(token) for token in spelling] + assert ( + tgt_dict.unk() not in spelling_idxs + ), f"{word} {spelling} {spelling_idxs}" + self.trie.insert(spelling_idxs, word_idx, score) + self.trie.smear(SmearingMode.MAX) + + self.decoder_opts = LexiconDecoderOptions( + beam_size=cfg.beam, + beam_size_token=cfg.beamsizetoken or len(tgt_dict), + beam_threshold=cfg.beamthreshold, + lm_weight=cfg.lmweight, + word_score=cfg.wordscore, + unk_score=cfg.unkweight, + sil_score=cfg.silweight, + log_add=False, + criterion_type=CriterionType.CTC, + ) + + self.decoder = LexiconDecoder( + self.decoder_opts, + self.trie, + self.lm, + self.silence, + self.blank, + self.unk_word, + [], + self.unitlm, + ) + else: + assert self.unitlm, "Lexicon-free decoding requires unit LM" + + d = {w: [[w]] for w in tgt_dict.symbols} + self.word_dict = create_word_dict(d) + self.lm = KenLM(cfg.lmpath, self.word_dict) + self.decoder_opts = LexiconFreeDecoderOptions( + beam_size=cfg.beam, + beam_size_token=cfg.beamsizetoken or len(tgt_dict), + beam_threshold=cfg.beamthreshold, + lm_weight=cfg.lmweight, + sil_score=cfg.silweight, + log_add=False, + criterion_type=CriterionType.CTC, + ) + self.decoder = LexiconFreeDecoder( + self.decoder_opts, self.lm, self.silence, self.blank, [] + ) + + def get_timesteps(self, token_idxs: List[int]) -> List[int]: + """Returns frame numbers corresponding to every non-blank token. + + Parameters + ---------- + token_idxs : List[int] + IDs of decoded tokens. + + Returns + ------- + List[int] + Frame numbers corresponding to every non-blank token. + """ + timesteps = [] + for i, token_idx in enumerate(token_idxs): + if token_idx == self.blank: + continue + if i == 0 or token_idx != token_idxs[i-1]: + timesteps.append(i) + return timesteps + + def decode( + self, + emissions: torch.FloatTensor, + ) -> List[List[Dict[str, torch.LongTensor]]]: + B, T, N = emissions.size() + hypos = [] + for b in range(B): + emissions_ptr = emissions.data_ptr() + 4 * b * emissions.stride(0) + results = self.decoder.decode(emissions_ptr, T, N) + + nbest_results = results[: self.nbest] + hypos.append( + [ + { + "tokens": self.get_tokens(result.tokens), + "score": result.score, + "timesteps": self.get_timesteps(result.tokens), + "words": [ + self.word_dict.get_entry(x) for x in result.words if x >= 0 + ], + } + for result in nbest_results + ] + ) + return hypos + + +FairseqLMState = namedtuple( + "FairseqLMState", + [ + "prefix", + "incremental_state", + "probs", + ], +) + + +class FairseqLM(LM): + def __init__(self, dictionary: Dictionary, model: FairseqModel) -> None: + super().__init__() + + self.dictionary = dictionary + self.model = model + self.unk = self.dictionary.unk() + + self.save_incremental = False # this currently does not work properly + self.max_cache = 20_000 + + if torch.cuda.is_available(): + model.cuda() + model.eval() + model.make_generation_fast_() + + self.states = {} + self.stateq = deque() + + def start(self, start_with_nothing: bool) -> LMState: + state = LMState() + prefix = torch.LongTensor([[self.dictionary.eos()]]) + incremental_state = {} if self.save_incremental else None + with torch.no_grad(): + res = self.model(prefix.cuda(), incremental_state=incremental_state) + probs = self.model.get_normalized_probs(res, log_probs=True, sample=None) + + if incremental_state is not None: + incremental_state = apply_to_sample(lambda x: x.cpu(), incremental_state) + self.states[state] = FairseqLMState( + prefix.numpy(), incremental_state, probs[0, -1].cpu().numpy() + ) + self.stateq.append(state) + + return state + + def score( + self, + state: LMState, + token_index: int, + no_cache: bool = False, + ) -> Tuple[LMState, int]: + """ + Evaluate language model based on the current lm state and new word + Parameters: + ----------- + state: current lm state + token_index: index of the word + (can be lexicon index then you should store inside LM the + mapping between indices of lexicon and lm, or lm index of a word) + Returns: + -------- + (LMState, float): pair of (new state, score for the current word) + """ + curr_state = self.states[state] + + def trim_cache(targ_size: int) -> None: + while len(self.stateq) > targ_size: + rem_k = self.stateq.popleft() + rem_st = self.states[rem_k] + rem_st = FairseqLMState(rem_st.prefix, None, None) + self.states[rem_k] = rem_st + + if curr_state.probs is None: + new_incremental_state = ( + curr_state.incremental_state.copy() + if curr_state.incremental_state is not None + else None + ) + with torch.no_grad(): + if new_incremental_state is not None: + new_incremental_state = apply_to_sample( + lambda x: x.cuda(), new_incremental_state + ) + elif self.save_incremental: + new_incremental_state = {} + + res = self.model( + torch.from_numpy(curr_state.prefix).cuda(), + incremental_state=new_incremental_state, + ) + probs = self.model.get_normalized_probs( + res, log_probs=True, sample=None + ) + + if new_incremental_state is not None: + new_incremental_state = apply_to_sample( + lambda x: x.cpu(), new_incremental_state + ) + + curr_state = FairseqLMState( + curr_state.prefix, new_incremental_state, probs[0, -1].cpu().numpy() + ) + + if not no_cache: + self.states[state] = curr_state + self.stateq.append(state) + + score = curr_state.probs[token_index].item() + + trim_cache(self.max_cache) + + outstate = state.child(token_index) + if outstate not in self.states and not no_cache: + prefix = np.concatenate( + [curr_state.prefix, torch.LongTensor([[token_index]])], -1 + ) + incr_state = curr_state.incremental_state + + self.states[outstate] = FairseqLMState(prefix, incr_state, None) + + if token_index == self.unk: + score = float("-inf") + + return outstate, score + + def finish(self, state: LMState) -> Tuple[LMState, int]: + """ + Evaluate eos for language model based on the current lm state + Returns: + -------- + (LMState, float): pair of (new state, score for the current word) + """ + return self.score(state, self.dictionary.eos()) + + def empty_cache(self) -> None: + self.states = {} + self.stateq = deque() + gc.collect() + + +class FairseqLMDecoder(BaseDecoder): + def __init__(self, cfg: FlashlightDecoderConfig, tgt_dict: Dictionary) -> None: + super().__init__(tgt_dict) + + self.nbest = cfg.nbest + self.unitlm = cfg.unitlm + + self.lexicon = load_words(cfg.lexicon) if cfg.lexicon else None + self.idx_to_wrd = {} + + checkpoint = torch.load(cfg.lmpath, map_location="cpu") + + if "cfg" in checkpoint and checkpoint["cfg"] is not None: + lm_args = checkpoint["cfg"] + else: + lm_args = convert_namespace_to_omegaconf(checkpoint["args"]) + + if not OmegaConf.is_dict(lm_args): + lm_args = OmegaConf.create(lm_args) + + with open_dict(lm_args.task): + lm_args.task.data = osp.dirname(cfg.lmpath) + + task = tasks.setup_task(lm_args.task) + model = task.build_model(lm_args.model) + model.load_state_dict(checkpoint["model"], strict=False) + + self.trie = Trie(self.vocab_size, self.silence) + + self.word_dict = task.dictionary + self.unk_word = self.word_dict.unk() + self.lm = FairseqLM(self.word_dict, model) + + if self.lexicon: + start_state = self.lm.start(False) + for i, (word, spellings) in enumerate(self.lexicon.items()): + if self.unitlm: + word_idx = i + self.idx_to_wrd[i] = word + score = 0 + else: + word_idx = self.word_dict.index(word) + _, score = self.lm.score(start_state, word_idx, no_cache=True) + + for spelling in spellings: + spelling_idxs = [tgt_dict.index(token) for token in spelling] + assert ( + tgt_dict.unk() not in spelling_idxs + ), f"{spelling} {spelling_idxs}" + self.trie.insert(spelling_idxs, word_idx, score) + self.trie.smear(SmearingMode.MAX) + + self.decoder_opts = LexiconDecoderOptions( + beam_size=cfg.beam, + beam_size_token=cfg.beamsizetoken or len(tgt_dict), + beam_threshold=cfg.beamthreshold, + lm_weight=cfg.lmweight, + word_score=cfg.wordscore, + unk_score=cfg.unkweight, + sil_score=cfg.silweight, + log_add=False, + criterion_type=CriterionType.CTC, + ) + + self.decoder = LexiconDecoder( + self.decoder_opts, + self.trie, + self.lm, + self.silence, + self.blank, + self.unk_word, + [], + self.unitlm, + ) + else: + assert self.unitlm, "Lexicon-free decoding requires unit LM" + + d = {w: [[w]] for w in tgt_dict.symbols} + self.word_dict = create_word_dict(d) + self.lm = KenLM(cfg.lmpath, self.word_dict) + self.decoder_opts = LexiconFreeDecoderOptions( + beam_size=cfg.beam, + beam_size_token=cfg.beamsizetoken or len(tgt_dict), + beam_threshold=cfg.beamthreshold, + lm_weight=cfg.lmweight, + sil_score=cfg.silweight, + log_add=False, + criterion_type=CriterionType.CTC, + ) + self.decoder = LexiconFreeDecoder( + self.decoder_opts, self.lm, self.silence, self.blank, [] + ) + + def decode( + self, + emissions: torch.FloatTensor, + ) -> List[List[Dict[str, torch.LongTensor]]]: + B, T, N = emissions.size() + hypos = [] + + def make_hypo(result: DecodeResult) -> Dict[str, Any]: + hypo = { + "tokens": self.get_tokens(result.tokens), + "score": result.score, + } + if self.lexicon: + hypo["words"] = [ + self.idx_to_wrd[x] if self.unitlm else self.word_dict[x] + for x in result.words + if x >= 0 + ] + return hypo + + for b in range(B): + emissions_ptr = emissions.data_ptr() + 4 * b * emissions.stride(0) + results = self.decoder.decode(emissions_ptr, T, N) + + nbest_results = results[: self.nbest] + hypos.append([make_hypo(result) for result in nbest_results]) + self.lm.empty_cache() + + return hypos diff --git a/fairseq/examples/speech_recognition/new/decoders/viterbi_decoder.py b/fairseq/examples/speech_recognition/new/decoders/viterbi_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..b1c47868fa3b4e21f939b0695ede8d14ba1b168d --- /dev/null +++ b/fairseq/examples/speech_recognition/new/decoders/viterbi_decoder.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from typing import List, Dict + +from .base_decoder import BaseDecoder + + +class ViterbiDecoder(BaseDecoder): + def decode( + self, + emissions: torch.FloatTensor, + ) -> List[List[Dict[str, torch.LongTensor]]]: + def get_pred(e): + toks = e.argmax(dim=-1).unique_consecutive() + return toks[toks != self.blank] + + return [[{"tokens": get_pred(x), "score": 0}] for x in emissions] diff --git a/fairseq/examples/speech_recognition/new/infer.py b/fairseq/examples/speech_recognition/new/infer.py new file mode 100644 index 0000000000000000000000000000000000000000..3fb67151e0dc425e02d090a62b1d83e6039e6ccb --- /dev/null +++ b/fairseq/examples/speech_recognition/new/infer.py @@ -0,0 +1,471 @@ +#!/usr/bin/env python -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import ast +import hashlib +import logging +import os +import shutil +import sys +from dataclasses import dataclass, field, is_dataclass +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple, Union + +import editdistance +import torch +import torch.distributed as dist +from examples.speech_recognition.new.decoders.decoder_config import ( + DecoderConfig, + FlashlightDecoderConfig, +) +from examples.speech_recognition.new.decoders.decoder import Decoder +from fairseq import checkpoint_utils, distributed_utils, progress_bar, tasks, utils +from fairseq.data.data_utils import post_process +from fairseq.dataclass.configs import ( + CheckpointConfig, + CommonConfig, + CommonEvalConfig, + DatasetConfig, + DistributedTrainingConfig, + FairseqDataclass, +) +from fairseq.logging.meters import StopwatchMeter, TimeMeter +from fairseq.logging.progress_bar import BaseProgressBar +from fairseq.models.fairseq_model import FairseqModel +from omegaconf import OmegaConf + +import hydra +from hydra.core.config_store import ConfigStore + +logging.root.setLevel(logging.INFO) +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +config_path = Path(__file__).resolve().parent / "conf" + + +@dataclass +class DecodingConfig(DecoderConfig, FlashlightDecoderConfig): + unique_wer_file: bool = field( + default=False, + metadata={"help": "If set, use a unique file for storing WER"}, + ) + results_path: Optional[str] = field( + default=None, + metadata={ + "help": "If set, write hypothesis and reference sentences into this directory" + }, + ) + + +@dataclass +class InferConfig(FairseqDataclass): + task: Any = None + decoding: DecodingConfig = DecodingConfig() + common: CommonConfig = CommonConfig() + common_eval: CommonEvalConfig = CommonEvalConfig() + checkpoint: CheckpointConfig = CheckpointConfig() + distributed_training: DistributedTrainingConfig = DistributedTrainingConfig() + dataset: DatasetConfig = DatasetConfig() + is_ax: bool = field( + default=False, + metadata={ + "help": "if true, assumes we are using ax for tuning and returns a tuple for ax to consume" + }, + ) + + +def reset_logging(): + root = logging.getLogger() + for handler in root.handlers: + root.removeHandler(handler) + root.setLevel(os.environ.get("LOGLEVEL", "INFO").upper()) + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter( + logging.Formatter( + fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + ) + root.addHandler(handler) + + +class InferenceProcessor: + cfg: InferConfig + + def __init__(self, cfg: InferConfig) -> None: + self.cfg = cfg + self.task = tasks.setup_task(cfg.task) + + models, saved_cfg = self.load_model_ensemble() + self.models = models + self.saved_cfg = saved_cfg + self.tgt_dict = self.task.target_dictionary + + self.task.load_dataset( + self.cfg.dataset.gen_subset, + task_cfg=saved_cfg.task, + ) + self.generator = Decoder(cfg.decoding, self.tgt_dict) + self.gen_timer = StopwatchMeter() + self.wps_meter = TimeMeter() + self.num_sentences = 0 + self.total_errors = 0 + self.total_length = 0 + + self.hypo_words_file = None + self.hypo_units_file = None + self.ref_words_file = None + self.ref_units_file = None + + self.progress_bar = self.build_progress_bar() + + def __enter__(self) -> "InferenceProcessor": + if self.cfg.decoding.results_path is not None: + self.hypo_words_file = self.get_res_file("hypo.word") + self.hypo_units_file = self.get_res_file("hypo.units") + self.ref_words_file = self.get_res_file("ref.word") + self.ref_units_file = self.get_res_file("ref.units") + return self + + def __exit__(self, *exc) -> bool: + if self.cfg.decoding.results_path is not None: + self.hypo_words_file.close() + self.hypo_units_file.close() + self.ref_words_file.close() + self.ref_units_file.close() + return False + + def __iter__(self) -> Any: + for sample in self.progress_bar: + if not self.cfg.common.cpu: + sample = utils.move_to_cuda(sample) + + # Happens on the last batch. + if "net_input" not in sample: + continue + yield sample + + def log(self, *args, **kwargs): + self.progress_bar.log(*args, **kwargs) + + def print(self, *args, **kwargs): + self.progress_bar.print(*args, **kwargs) + + def get_res_file(self, fname: str) -> None: + fname = os.path.join(self.cfg.decoding.results_path, fname) + if self.data_parallel_world_size > 1: + fname = f"{fname}.{self.data_parallel_rank}" + return open(fname, "w", buffering=1) + + def merge_shards(self) -> None: + """Merges all shard files into shard 0, then removes shard suffix.""" + + shard_id = self.data_parallel_rank + num_shards = self.data_parallel_world_size + + if self.data_parallel_world_size > 1: + + def merge_shards_with_root(fname: str) -> None: + fname = os.path.join(self.cfg.decoding.results_path, fname) + logger.info("Merging %s on shard %d", fname, shard_id) + base_fpath = Path(f"{fname}.0") + with open(base_fpath, "a") as out_file: + for s in range(1, num_shards): + shard_fpath = Path(f"{fname}.{s}") + with open(shard_fpath, "r") as in_file: + for line in in_file: + out_file.write(line) + shard_fpath.unlink() + shutil.move(f"{fname}.0", fname) + + dist.barrier() # ensure all shards finished writing + if shard_id == (0 % num_shards): + merge_shards_with_root("hypo.word") + if shard_id == (1 % num_shards): + merge_shards_with_root("hypo.units") + if shard_id == (2 % num_shards): + merge_shards_with_root("ref.word") + if shard_id == (3 % num_shards): + merge_shards_with_root("ref.units") + dist.barrier() + + def optimize_model(self, model: FairseqModel) -> None: + model.make_generation_fast_() + if self.cfg.common.fp16: + model.half() + if not self.cfg.common.cpu: + model.cuda() + + def load_model_ensemble(self) -> Tuple[List[FairseqModel], FairseqDataclass]: + arg_overrides = ast.literal_eval(self.cfg.common_eval.model_overrides) + models, saved_cfg = checkpoint_utils.load_model_ensemble( + utils.split_paths(self.cfg.common_eval.path, separator="\\"), + arg_overrides=arg_overrides, + task=self.task, + suffix=self.cfg.checkpoint.checkpoint_suffix, + strict=(self.cfg.checkpoint.checkpoint_shard_count == 1), + num_shards=self.cfg.checkpoint.checkpoint_shard_count, + ) + for model in models: + self.optimize_model(model) + return models, saved_cfg + + def get_dataset_itr(self, disable_iterator_cache: bool = False) -> None: + return self.task.get_batch_iterator( + dataset=self.task.dataset(self.cfg.dataset.gen_subset), + max_tokens=self.cfg.dataset.max_tokens, + max_sentences=self.cfg.dataset.batch_size, + max_positions=(sys.maxsize, sys.maxsize), + ignore_invalid_inputs=self.cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple, + seed=self.cfg.common.seed, + num_shards=self.data_parallel_world_size, + shard_id=self.data_parallel_rank, + num_workers=self.cfg.dataset.num_workers, + data_buffer_size=self.cfg.dataset.data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ).next_epoch_itr(shuffle=False) + + def build_progress_bar( + self, + epoch: Optional[int] = None, + prefix: Optional[str] = None, + default_log_format: str = "tqdm", + ) -> BaseProgressBar: + return progress_bar.progress_bar( + iterator=self.get_dataset_itr(), + log_format=self.cfg.common.log_format, + log_interval=self.cfg.common.log_interval, + epoch=epoch, + prefix=prefix, + tensorboard_logdir=self.cfg.common.tensorboard_logdir, + default_log_format=default_log_format, + ) + + @property + def data_parallel_world_size(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 1 + return distributed_utils.get_data_parallel_world_size() + + @property + def data_parallel_rank(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 0 + return distributed_utils.get_data_parallel_rank() + + def process_sentence( + self, + sample: Dict[str, Any], + hypo: Dict[str, Any], + sid: int, + batch_id: int, + ) -> Tuple[int, int]: + speaker = None # Speaker can't be parsed from dataset. + + if "target_label" in sample: + toks = sample["target_label"] + else: + toks = sample["target"] + toks = toks[batch_id, :] + + # Processes hypothesis. + hyp_pieces = self.tgt_dict.string(hypo["tokens"].int().cpu()) + if "words" in hypo: + hyp_words = " ".join(hypo["words"]) + else: + hyp_words = post_process(hyp_pieces, self.cfg.common_eval.post_process) + + # Processes target. + target_tokens = utils.strip_pad(toks, self.tgt_dict.pad()) + tgt_pieces = self.tgt_dict.string(target_tokens.int().cpu()) + tgt_words = post_process(tgt_pieces, self.cfg.common_eval.post_process) + + if self.cfg.decoding.results_path is not None: + print(f"{hyp_pieces} ({speaker}-{sid})", file=self.hypo_units_file) + print(f"{hyp_words} ({speaker}-{sid})", file=self.hypo_words_file) + print(f"{tgt_pieces} ({speaker}-{sid})", file=self.ref_units_file) + print(f"{tgt_words} ({speaker}-{sid})", file=self.ref_words_file) + + if not self.cfg.common_eval.quiet: + logger.info(f"HYPO: {hyp_words}") + logger.info(f"REF: {tgt_words}") + logger.info("---------------------") + + hyp_words, tgt_words = hyp_words.split(), tgt_words.split() + + return editdistance.eval(hyp_words, tgt_words), len(tgt_words) + + def process_sample(self, sample: Dict[str, Any]) -> None: + self.gen_timer.start() + hypos = self.task.inference_step( + generator=self.generator, + models=self.models, + sample=sample, + ) + num_generated_tokens = sum(len(h[0]["tokens"]) for h in hypos) + self.gen_timer.stop(num_generated_tokens) + self.wps_meter.update(num_generated_tokens) + + for batch_id, sample_id in enumerate(sample["id"].tolist()): + errs, length = self.process_sentence( + sample=sample, + sid=sample_id, + batch_id=batch_id, + hypo=hypos[batch_id][0], + ) + self.total_errors += errs + self.total_length += length + + self.log({"wps": round(self.wps_meter.avg)}) + if "nsentences" in sample: + self.num_sentences += sample["nsentences"] + else: + self.num_sentences += sample["id"].numel() + + def log_generation_time(self) -> None: + logger.info( + "Processed %d sentences (%d tokens) in %.1fs %.2f " + "sentences per second, %.2f tokens per second)", + self.num_sentences, + self.gen_timer.n, + self.gen_timer.sum, + self.num_sentences / self.gen_timer.sum, + 1.0 / self.gen_timer.avg, + ) + + +def parse_wer(wer_file: Path) -> float: + with open(wer_file, "r") as f: + return float(f.readline().strip().split(" ")[1]) + + +def get_wer_file(cfg: InferConfig) -> Path: + """Hashes the decoding parameters to a unique file ID.""" + base_path = "wer" + if cfg.decoding.results_path is not None: + base_path = os.path.join(cfg.decoding.results_path, base_path) + + if cfg.decoding.unique_wer_file: + yaml_str = OmegaConf.to_yaml(cfg.decoding) + fid = int(hashlib.md5(yaml_str.encode("utf-8")).hexdigest(), 16) + return Path(f"{base_path}.{fid % 1000000}") + else: + return Path(base_path) + + +def main(cfg: InferConfig) -> float: + """Entry point for main processing logic. + + Args: + cfg: The inferance configuration to use. + wer: Optional shared memory pointer for returning the WER. If not None, + the final WER value will be written here instead of being returned. + + Returns: + The final WER if `wer` is None, otherwise None. + """ + + yaml_str, wer_file = OmegaConf.to_yaml(cfg.decoding), get_wer_file(cfg) + + # Validates the provided configuration. + if cfg.dataset.max_tokens is None and cfg.dataset.batch_size is None: + cfg.dataset.max_tokens = 4000000 + if not cfg.common.cpu and not torch.cuda.is_available(): + raise ValueError("CUDA not found; set `cpu=True` to run without CUDA") + + with InferenceProcessor(cfg) as processor: + for sample in processor: + processor.process_sample(sample) + + processor.log_generation_time() + + if cfg.decoding.results_path is not None: + processor.merge_shards() + + errs_t, leng_t = processor.total_errors, processor.total_length + + if cfg.common.cpu: + logger.warning("Merging WER requires CUDA.") + elif processor.data_parallel_world_size > 1: + stats = torch.LongTensor([errs_t, leng_t]).cuda() + dist.all_reduce(stats, op=dist.ReduceOp.SUM) + errs_t, leng_t = stats[0].item(), stats[1].item() + + wer = errs_t * 100.0 / leng_t + + if distributed_utils.is_master(cfg.distributed_training): + with open(wer_file, "w") as f: + f.write( + ( + f"WER: {wer}\n" + f"err / num_ref_words = {errs_t} / {leng_t}\n\n" + f"{yaml_str}" + ) + ) + + return wer + + +@hydra.main(config_path=config_path, config_name="infer") +def hydra_main(cfg: InferConfig) -> Union[float, Tuple[float, Optional[float]]]: + container = OmegaConf.to_container(cfg, resolve=True, enum_to_str=True) + cfg = OmegaConf.create(container) + OmegaConf.set_struct(cfg, True) + + if cfg.common.reset_logging: + reset_logging() + + # logger.info("Config:\n%s", OmegaConf.to_yaml(cfg)) + wer = float("inf") + + try: + if cfg.common.profile: + with torch.cuda.profiler.profile(): + with torch.autograd.profiler.emit_nvtx(): + distributed_utils.call_main(cfg, main) + else: + distributed_utils.call_main(cfg, main) + + wer = parse_wer(get_wer_file(cfg)) + except BaseException as e: # pylint: disable=broad-except + if not cfg.common.suppress_crashes: + raise + else: + logger.error("Crashed! %s", str(e)) + + logger.info("Word error rate: %.4f", wer) + if cfg.is_ax: + return wer, None + + return wer + + +def cli_main() -> None: + try: + from hydra._internal.utils import ( + get_args, + ) # pylint: disable=import-outside-toplevel + + cfg_name = get_args().config_name or "infer" + except ImportError: + logger.warning("Failed to get config name from hydra args") + cfg_name = "infer" + + cs = ConfigStore.instance() + cs.store(name=cfg_name, node=InferConfig) + + for k in InferConfig.__dataclass_fields__: + if is_dataclass(InferConfig.__dataclass_fields__[k].type): + v = InferConfig.__dataclass_fields__[k].default + cs.store(name=k, node=v) + + hydra_main() # pylint: disable=no-value-for-parameter + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/speech_recognition/tasks/__init__.py b/fairseq/examples/speech_recognition/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7ac3b8dc69639c92cc129294356e9012745e3fb2 --- /dev/null +++ b/fairseq/examples/speech_recognition/tasks/__init__.py @@ -0,0 +1,8 @@ +import importlib +import os + + +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + task_name = file[: file.find(".py")] + importlib.import_module("examples.speech_recognition.tasks." + task_name) diff --git a/fairseq/examples/speech_recognition/tasks/speech_recognition.py b/fairseq/examples/speech_recognition/tasks/speech_recognition.py new file mode 100644 index 0000000000000000000000000000000000000000..d9f011d55ff4fdfeb4c04ca790c314d685708c3a --- /dev/null +++ b/fairseq/examples/speech_recognition/tasks/speech_recognition.py @@ -0,0 +1,157 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import json +import os +import re +import sys + +import torch +from examples.speech_recognition.data import AsrDataset +from examples.speech_recognition.data.replabels import replabel_symbol +from fairseq.data import Dictionary +from fairseq.tasks import LegacyFairseqTask, register_task + + +def get_asr_dataset_from_json(data_json_path, tgt_dict): + """ + Parse data json and create dataset. + See scripts/asr_prep_json.py which pack json from raw files + + Json example: + { + "utts": { + "4771-29403-0025": { + "input": { + "length_ms": 170, + "path": "/tmp/file1.flac" + }, + "output": { + "text": "HELLO \n", + "token": "HE LLO", + "tokenid": "4815, 861" + } + }, + "1564-142299-0096": { + ... + } + } + """ + if not os.path.isfile(data_json_path): + raise FileNotFoundError("Dataset not found: {}".format(data_json_path)) + with open(data_json_path, "rb") as f: + data_samples = json.load(f)["utts"] + assert len(data_samples) != 0 + sorted_samples = sorted( + data_samples.items(), + key=lambda sample: int(sample[1]["input"]["length_ms"]), + reverse=True, + ) + aud_paths = [s[1]["input"]["path"] for s in sorted_samples] + ids = [s[0] for s in sorted_samples] + speakers = [] + for s in sorted_samples: + m = re.search("(.+?)-(.+?)-(.+?)", s[0]) + speakers.append(m.group(1) + "_" + m.group(2)) + frame_sizes = [s[1]["input"]["length_ms"] for s in sorted_samples] + tgt = [ + [int(i) for i in s[1]["output"]["tokenid"].split(", ")] + for s in sorted_samples + ] + # append eos + tgt = [[*t, tgt_dict.eos()] for t in tgt] + return AsrDataset(aud_paths, frame_sizes, tgt, tgt_dict, ids, speakers) + + +@register_task("speech_recognition") +class SpeechRecognitionTask(LegacyFairseqTask): + """ + Task for training speech recognition model. + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument("data", help="path to data directory") + parser.add_argument( + "--silence-token", default="\u2581", help="token for silence (used by w2l)" + ) + parser.add_argument( + "--max-source-positions", + default=sys.maxsize, + type=int, + metavar="N", + help="max number of frames in the source sequence", + ) + parser.add_argument( + "--max-target-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the target sequence", + ) + + def __init__(self, args, tgt_dict): + super().__init__(args) + self.tgt_dict = tgt_dict + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task (e.g., load dictionaries).""" + dict_path = os.path.join(args.data, "dict.txt") + if not os.path.isfile(dict_path): + raise FileNotFoundError("Dict not found: {}".format(dict_path)) + tgt_dict = Dictionary.load(dict_path) + + if args.criterion == "ctc_loss": + tgt_dict.add_symbol("<ctc_blank>") + elif args.criterion == "asg_loss": + for i in range(1, args.max_replabel + 1): + tgt_dict.add_symbol(replabel_symbol(i)) + + print("| dictionary: {} types".format(len(tgt_dict))) + return cls(args, tgt_dict) + + def load_dataset(self, split, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + data_json_path = os.path.join(self.args.data, "{}.json".format(split)) + self.datasets[split] = get_asr_dataset_from_json(data_json_path, self.tgt_dict) + + def build_generator(self, models, args, **unused): + w2l_decoder = getattr(args, "w2l_decoder", None) + if w2l_decoder == "viterbi": + from examples.speech_recognition.w2l_decoder import W2lViterbiDecoder + + return W2lViterbiDecoder(args, self.target_dictionary) + elif w2l_decoder == "kenlm": + from examples.speech_recognition.w2l_decoder import W2lKenLMDecoder + + return W2lKenLMDecoder(args, self.target_dictionary) + elif w2l_decoder == "fairseqlm": + from examples.speech_recognition.w2l_decoder import W2lFairseqLMDecoder + + return W2lFairseqLMDecoder(args, self.target_dictionary) + else: + return super().build_generator(models, args) + + @property + def target_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self.tgt_dict + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary` (if applicable + for this task).""" + return None + + def max_positions(self): + """Return the max speech and sentence length allowed by the task.""" + return (self.args.max_source_positions, self.args.max_target_positions) diff --git a/fairseq/examples/speech_recognition/utils/wer_utils.py b/fairseq/examples/speech_recognition/utils/wer_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cf6f3d09ba41a46ad4d7968fb3c286dd53d15c38 --- /dev/null +++ b/fairseq/examples/speech_recognition/utils/wer_utils.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import re +from collections import deque +from enum import Enum + +import numpy as np + + +""" + Utility modules for computation of Word Error Rate, + Alignments, as well as more granular metrics like + deletion, insersion and substitutions. +""" + + +class Code(Enum): + match = 1 + substitution = 2 + insertion = 3 + deletion = 4 + + +class Token(object): + def __init__(self, lbl="", st=np.nan, en=np.nan): + if np.isnan(st): + self.label, self.start, self.end = "", 0.0, 0.0 + else: + self.label, self.start, self.end = lbl, st, en + + +class AlignmentResult(object): + def __init__(self, refs, hyps, codes, score): + self.refs = refs # std::deque<int> + self.hyps = hyps # std::deque<int> + self.codes = codes # std::deque<Code> + self.score = score # float + + +def coordinate_to_offset(row, col, ncols): + return int(row * ncols + col) + + +def offset_to_row(offset, ncols): + return int(offset / ncols) + + +def offset_to_col(offset, ncols): + return int(offset % ncols) + + +def trimWhitespace(str): + return re.sub(" +", " ", re.sub(" *$", "", re.sub("^ *", "", str))) + + +def str2toks(str): + pieces = trimWhitespace(str).split(" ") + toks = [] + for p in pieces: + toks.append(Token(p, 0.0, 0.0)) + return toks + + +class EditDistance(object): + def __init__(self, time_mediated): + self.time_mediated_ = time_mediated + self.scores_ = np.nan # Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> + self.backtraces_ = ( + np.nan + ) # Eigen::Matrix<size_t, Eigen::Dynamic, Eigen::Dynamic> backtraces_; + self.confusion_pairs_ = {} + + def cost(self, ref, hyp, code): + if self.time_mediated_: + if code == Code.match: + return abs(ref.start - hyp.start) + abs(ref.end - hyp.end) + elif code == Code.insertion: + return hyp.end - hyp.start + elif code == Code.deletion: + return ref.end - ref.start + else: # substitution + return abs(ref.start - hyp.start) + abs(ref.end - hyp.end) + 0.1 + else: + if code == Code.match: + return 0 + elif code == Code.insertion or code == Code.deletion: + return 3 + else: # substitution + return 4 + + def get_result(self, refs, hyps): + res = AlignmentResult(refs=deque(), hyps=deque(), codes=deque(), score=np.nan) + + num_rows, num_cols = self.scores_.shape + res.score = self.scores_[num_rows - 1, num_cols - 1] + + curr_offset = coordinate_to_offset(num_rows - 1, num_cols - 1, num_cols) + + while curr_offset != 0: + curr_row = offset_to_row(curr_offset, num_cols) + curr_col = offset_to_col(curr_offset, num_cols) + + prev_offset = self.backtraces_[curr_row, curr_col] + + prev_row = offset_to_row(prev_offset, num_cols) + prev_col = offset_to_col(prev_offset, num_cols) + + res.refs.appendleft(curr_row - 1) # Note: this was .push_front() in C++ + res.hyps.appendleft(curr_col - 1) + if curr_row - 1 == prev_row and curr_col == prev_col: + res.codes.appendleft(Code.deletion) + elif curr_row == prev_row and curr_col - 1 == prev_col: + res.codes.appendleft(Code.insertion) + else: + # assert(curr_row - 1 == prev_row and curr_col - 1 == prev_col) + ref_str = refs[res.refs[0]].label + hyp_str = hyps[res.hyps[0]].label + + if ref_str == hyp_str: + res.codes.appendleft(Code.match) + else: + res.codes.appendleft(Code.substitution) + + confusion_pair = "%s -> %s" % (ref_str, hyp_str) + if confusion_pair not in self.confusion_pairs_: + self.confusion_pairs_[confusion_pair] = 1 + else: + self.confusion_pairs_[confusion_pair] += 1 + + curr_offset = prev_offset + + return res + + def align(self, refs, hyps): + if len(refs) == 0 and len(hyps) == 0: + return np.nan + + # NOTE: we're not resetting the values in these matrices because every value + # will be overridden in the loop below. If this assumption doesn't hold, + # be sure to set all entries in self.scores_ and self.backtraces_ to 0. + self.scores_ = np.zeros((len(refs) + 1, len(hyps) + 1)) + self.backtraces_ = np.zeros((len(refs) + 1, len(hyps) + 1)) + + num_rows, num_cols = self.scores_.shape + + for i in range(num_rows): + for j in range(num_cols): + if i == 0 and j == 0: + self.scores_[i, j] = 0.0 + self.backtraces_[i, j] = 0 + continue + + if i == 0: + self.scores_[i, j] = self.scores_[i, j - 1] + self.cost( + None, hyps[j - 1], Code.insertion + ) + self.backtraces_[i, j] = coordinate_to_offset(i, j - 1, num_cols) + continue + + if j == 0: + self.scores_[i, j] = self.scores_[i - 1, j] + self.cost( + refs[i - 1], None, Code.deletion + ) + self.backtraces_[i, j] = coordinate_to_offset(i - 1, j, num_cols) + continue + + # Below here both i and j are greater than 0 + ref = refs[i - 1] + hyp = hyps[j - 1] + best_score = self.scores_[i - 1, j - 1] + ( + self.cost(ref, hyp, Code.match) + if (ref.label == hyp.label) + else self.cost(ref, hyp, Code.substitution) + ) + + prev_row = i - 1 + prev_col = j - 1 + ins = self.scores_[i, j - 1] + self.cost(None, hyp, Code.insertion) + if ins < best_score: + best_score = ins + prev_row = i + prev_col = j - 1 + + delt = self.scores_[i - 1, j] + self.cost(ref, None, Code.deletion) + if delt < best_score: + best_score = delt + prev_row = i - 1 + prev_col = j + + self.scores_[i, j] = best_score + self.backtraces_[i, j] = coordinate_to_offset( + prev_row, prev_col, num_cols + ) + + return self.get_result(refs, hyps) + + +class WERTransformer(object): + def __init__(self, hyp_str, ref_str, verbose=True): + self.ed_ = EditDistance(False) + self.id2oracle_errs_ = {} + self.utts_ = 0 + self.words_ = 0 + self.insertions_ = 0 + self.deletions_ = 0 + self.substitutions_ = 0 + + self.process(["dummy_str", hyp_str, ref_str]) + + if verbose: + print("'%s' vs '%s'" % (hyp_str, ref_str)) + self.report_result() + + def process(self, input): # std::vector<std::string>&& input + if len(input) < 3: + print( + "Input must be of the form <id> ... <hypo> <ref> , got ", + len(input), + " inputs:", + ) + return None + + # Align + # std::vector<Token> hyps; + # std::vector<Token> refs; + + hyps = str2toks(input[-2]) + refs = str2toks(input[-1]) + + alignment = self.ed_.align(refs, hyps) + if alignment is None: + print("Alignment is null") + return np.nan + + # Tally errors + ins = 0 + dels = 0 + subs = 0 + for code in alignment.codes: + if code == Code.substitution: + subs += 1 + elif code == Code.insertion: + ins += 1 + elif code == Code.deletion: + dels += 1 + + # Output + row = input + row.append(str(len(refs))) + row.append(str(ins)) + row.append(str(dels)) + row.append(str(subs)) + # print(row) + + # Accumulate + kIdIndex = 0 + kNBestSep = "/" + + pieces = input[kIdIndex].split(kNBestSep) + + if len(pieces) == 0: + print( + "Error splitting ", + input[kIdIndex], + " on '", + kNBestSep, + "', got empty list", + ) + return np.nan + + id = pieces[0] + if id not in self.id2oracle_errs_: + self.utts_ += 1 + self.words_ += len(refs) + self.insertions_ += ins + self.deletions_ += dels + self.substitutions_ += subs + self.id2oracle_errs_[id] = [ins, dels, subs] + else: + curr_err = ins + dels + subs + prev_err = np.sum(self.id2oracle_errs_[id]) + if curr_err < prev_err: + self.id2oracle_errs_[id] = [ins, dels, subs] + + return 0 + + def report_result(self): + # print("---------- Summary ---------------") + if self.words_ == 0: + print("No words counted") + return + + # 1-best + best_wer = ( + 100.0 + * (self.insertions_ + self.deletions_ + self.substitutions_) + / self.words_ + ) + + print( + "\tWER = %0.2f%% (%i utts, %i words, %0.2f%% ins, " + "%0.2f%% dels, %0.2f%% subs)" + % ( + best_wer, + self.utts_, + self.words_, + 100.0 * self.insertions_ / self.words_, + 100.0 * self.deletions_ / self.words_, + 100.0 * self.substitutions_ / self.words_, + ) + ) + + def wer(self): + if self.words_ == 0: + wer = np.nan + else: + wer = ( + 100.0 + * (self.insertions_ + self.deletions_ + self.substitutions_) + / self.words_ + ) + return wer + + def stats(self): + if self.words_ == 0: + stats = {} + else: + wer = ( + 100.0 + * (self.insertions_ + self.deletions_ + self.substitutions_) + / self.words_ + ) + stats = dict( + { + "wer": wer, + "utts": self.utts_, + "numwords": self.words_, + "ins": self.insertions_, + "dels": self.deletions_, + "subs": self.substitutions_, + "confusion_pairs": self.ed_.confusion_pairs_, + } + ) + return stats + + +def calc_wer(hyp_str, ref_str): + t = WERTransformer(hyp_str, ref_str, verbose=0) + return t.wer() + + +def calc_wer_stats(hyp_str, ref_str): + t = WERTransformer(hyp_str, ref_str, verbose=0) + return t.stats() + + +def get_wer_alignment_codes(hyp_str, ref_str): + """ + INPUT: hypothesis string, reference string + OUTPUT: List of alignment codes (intermediate results from WER computation) + """ + t = WERTransformer(hyp_str, ref_str, verbose=0) + return t.ed_.align(str2toks(ref_str), str2toks(hyp_str)).codes + + +def merge_counts(x, y): + # Merge two hashes which have 'counts' as their values + # This can be used for example to merge confusion pair counts + # conf_pairs = merge_counts(conf_pairs, stats['confusion_pairs']) + for k, v in y.items(): + if k not in x: + x[k] = 0 + x[k] += v + return x diff --git a/fairseq/examples/speech_recognition/w2l_decoder.py b/fairseq/examples/speech_recognition/w2l_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..fbf2d3524ee40bd0d08b6a9560047d96e49b6045 --- /dev/null +++ b/fairseq/examples/speech_recognition/w2l_decoder.py @@ -0,0 +1,486 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Flashlight decoders. +""" + +import gc +import itertools as it +import os.path as osp +from typing import List +import warnings +from collections import deque, namedtuple + +import numpy as np +import torch +from examples.speech_recognition.data.replabels import unpack_replabels +from fairseq import tasks +from fairseq.utils import apply_to_sample +from omegaconf import open_dict +from fairseq.dataclass.utils import convert_namespace_to_omegaconf + + +try: + from flashlight.lib.text.dictionary import create_word_dict, load_words + from flashlight.lib.sequence.criterion import CpuViterbiPath, get_data_ptr_as_bytes + from flashlight.lib.text.decoder import ( + CriterionType, + LexiconDecoderOptions, + KenLM, + LM, + LMState, + SmearingMode, + Trie, + LexiconDecoder, + ) +except: + warnings.warn( + "flashlight python bindings are required to use this functionality. Please install from https://github.com/facebookresearch/flashlight/tree/master/bindings/python" + ) + LM = object + LMState = object + + +class W2lDecoder(object): + def __init__(self, args, tgt_dict): + self.tgt_dict = tgt_dict + self.vocab_size = len(tgt_dict) + self.nbest = args.nbest + + # criterion-specific init + self.criterion_type = CriterionType.CTC + self.blank = ( + tgt_dict.index("<ctc_blank>") + if "<ctc_blank>" in tgt_dict.indices + else tgt_dict.bos() + ) + if "<sep>" in tgt_dict.indices: + self.silence = tgt_dict.index("<sep>") + elif "|" in tgt_dict.indices: + self.silence = tgt_dict.index("|") + else: + self.silence = tgt_dict.eos() + self.asg_transitions = None + + def generate(self, models, sample, **unused): + """Generate a batch of inferences.""" + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in sample["net_input"].items() if k != "prev_output_tokens" + } + emissions = self.get_emissions(models, encoder_input) + return self.decode(emissions) + + def get_emissions(self, models, encoder_input): + """Run encoder and normalize emissions""" + model = models[0] + encoder_out = model(**encoder_input) + if hasattr(model, "get_logits"): + emissions = model.get_logits(encoder_out) # no need to normalize emissions + else: + emissions = model.get_normalized_probs(encoder_out, log_probs=True) + return emissions.transpose(0, 1).float().cpu().contiguous() + + def get_tokens(self, idxs): + """Normalize tokens by handling CTC blank, ASG replabels, etc.""" + idxs = (g[0] for g in it.groupby(idxs)) + idxs = filter(lambda x: x != self.blank, idxs) + return torch.LongTensor(list(idxs)) + + +class W2lViterbiDecoder(W2lDecoder): + def __init__(self, args, tgt_dict): + super().__init__(args, tgt_dict) + + def decode(self, emissions): + B, T, N = emissions.size() + hypos = [] + if self.asg_transitions is None: + transitions = torch.FloatTensor(N, N).zero_() + else: + transitions = torch.FloatTensor(self.asg_transitions).view(N, N) + viterbi_path = torch.IntTensor(B, T) + workspace = torch.ByteTensor(CpuViterbiPath.get_workspace_size(B, T, N)) + CpuViterbiPath.compute( + B, + T, + N, + get_data_ptr_as_bytes(emissions), + get_data_ptr_as_bytes(transitions), + get_data_ptr_as_bytes(viterbi_path), + get_data_ptr_as_bytes(workspace), + ) + return [ + [{"tokens": self.get_tokens(viterbi_path[b].tolist()), "score": 0}] + for b in range(B) + ] + + +class W2lKenLMDecoder(W2lDecoder): + def __init__(self, args, tgt_dict): + super().__init__(args, tgt_dict) + + self.unit_lm = getattr(args, "unit_lm", False) + + if args.lexicon: + self.lexicon = load_words(args.lexicon) + self.word_dict = create_word_dict(self.lexicon) + self.unk_word = self.word_dict.get_index("<unk>") + + self.lm = KenLM(args.kenlm_model, self.word_dict) + self.trie = Trie(self.vocab_size, self.silence) + + start_state = self.lm.start(False) + for i, (word, spellings) in enumerate(self.lexicon.items()): + word_idx = self.word_dict.get_index(word) + _, score = self.lm.score(start_state, word_idx) + for spelling in spellings: + spelling_idxs = [tgt_dict.index(token) for token in spelling] + assert ( + tgt_dict.unk() not in spelling_idxs + ), f"{spelling} {spelling_idxs}" + self.trie.insert(spelling_idxs, word_idx, score) + self.trie.smear(SmearingMode.MAX) + + self.decoder_opts = LexiconDecoderOptions( + beam_size=args.beam, + beam_size_token=int(getattr(args, "beam_size_token", len(tgt_dict))), + beam_threshold=args.beam_threshold, + lm_weight=args.lm_weight, + word_score=args.word_score, + unk_score=args.unk_weight, + sil_score=args.sil_weight, + log_add=False, + criterion_type=self.criterion_type, + ) + + if self.asg_transitions is None: + N = 768 + # self.asg_transitions = torch.FloatTensor(N, N).zero_() + self.asg_transitions = [] + + self.decoder = LexiconDecoder( + self.decoder_opts, + self.trie, + self.lm, + self.silence, + self.blank, + self.unk_word, + self.asg_transitions, + self.unit_lm, + ) + else: + assert args.unit_lm, "lexicon free decoding can only be done with a unit language model" + from flashlight.lib.text.decoder import LexiconFreeDecoder, LexiconFreeDecoderOptions + + d = {w: [[w]] for w in tgt_dict.symbols} + self.word_dict = create_word_dict(d) + self.lm = KenLM(args.kenlm_model, self.word_dict) + self.decoder_opts = LexiconFreeDecoderOptions( + beam_size=args.beam, + beam_size_token=int(getattr(args, "beam_size_token", len(tgt_dict))), + beam_threshold=args.beam_threshold, + lm_weight=args.lm_weight, + sil_score=args.sil_weight, + log_add=False, + criterion_type=self.criterion_type, + ) + self.decoder = LexiconFreeDecoder( + self.decoder_opts, self.lm, self.silence, self.blank, [] + ) + + def get_timesteps(self, token_idxs: List[int]) -> List[int]: + """Returns frame numbers corresponding to every non-blank token. + + Parameters + ---------- + token_idxs : List[int] + IDs of decoded tokens. + + Returns + ------- + List[int] + Frame numbers corresponding to every non-blank token. + """ + timesteps = [] + for i, token_idx in enumerate(token_idxs): + if token_idx == self.blank: + continue + if i == 0 or token_idx != token_idxs[i-1]: + timesteps.append(i) + return timesteps + + def decode(self, emissions): + B, T, N = emissions.size() + hypos = [] + for b in range(B): + emissions_ptr = emissions.data_ptr() + 4 * b * emissions.stride(0) + results = self.decoder.decode(emissions_ptr, T, N) + + nbest_results = results[: self.nbest] + hypos.append( + [ + { + "tokens": self.get_tokens(result.tokens), + "score": result.score, + "timesteps": self.get_timesteps(result.tokens), + "words": [ + self.word_dict.get_entry(x) for x in result.words if x >= 0 + ], + } + for result in nbest_results + ] + ) + return hypos + + +FairseqLMState = namedtuple("FairseqLMState", ["prefix", "incremental_state", "probs"]) + + +class FairseqLM(LM): + def __init__(self, dictionary, model): + LM.__init__(self) + self.dictionary = dictionary + self.model = model + self.unk = self.dictionary.unk() + + self.save_incremental = False # this currently does not work properly + self.max_cache = 20_000 + + model.cuda() + model.eval() + model.make_generation_fast_() + + self.states = {} + self.stateq = deque() + + def start(self, start_with_nothing): + state = LMState() + prefix = torch.LongTensor([[self.dictionary.eos()]]) + incremental_state = {} if self.save_incremental else None + with torch.no_grad(): + res = self.model(prefix.cuda(), incremental_state=incremental_state) + probs = self.model.get_normalized_probs(res, log_probs=True, sample=None) + + if incremental_state is not None: + incremental_state = apply_to_sample(lambda x: x.cpu(), incremental_state) + self.states[state] = FairseqLMState( + prefix.numpy(), incremental_state, probs[0, -1].cpu().numpy() + ) + self.stateq.append(state) + + return state + + def score(self, state: LMState, token_index: int, no_cache: bool = False): + """ + Evaluate language model based on the current lm state and new word + Parameters: + ----------- + state: current lm state + token_index: index of the word + (can be lexicon index then you should store inside LM the + mapping between indices of lexicon and lm, or lm index of a word) + + Returns: + -------- + (LMState, float): pair of (new state, score for the current word) + """ + curr_state = self.states[state] + + def trim_cache(targ_size): + while len(self.stateq) > targ_size: + rem_k = self.stateq.popleft() + rem_st = self.states[rem_k] + rem_st = FairseqLMState(rem_st.prefix, None, None) + self.states[rem_k] = rem_st + + if curr_state.probs is None: + new_incremental_state = ( + curr_state.incremental_state.copy() + if curr_state.incremental_state is not None + else None + ) + with torch.no_grad(): + if new_incremental_state is not None: + new_incremental_state = apply_to_sample( + lambda x: x.cuda(), new_incremental_state + ) + elif self.save_incremental: + new_incremental_state = {} + + res = self.model( + torch.from_numpy(curr_state.prefix).cuda(), + incremental_state=new_incremental_state, + ) + probs = self.model.get_normalized_probs( + res, log_probs=True, sample=None + ) + + if new_incremental_state is not None: + new_incremental_state = apply_to_sample( + lambda x: x.cpu(), new_incremental_state + ) + + curr_state = FairseqLMState( + curr_state.prefix, new_incremental_state, probs[0, -1].cpu().numpy() + ) + + if not no_cache: + self.states[state] = curr_state + self.stateq.append(state) + + score = curr_state.probs[token_index].item() + + trim_cache(self.max_cache) + + outstate = state.child(token_index) + if outstate not in self.states and not no_cache: + prefix = np.concatenate( + [curr_state.prefix, torch.LongTensor([[token_index]])], -1 + ) + incr_state = curr_state.incremental_state + + self.states[outstate] = FairseqLMState(prefix, incr_state, None) + + if token_index == self.unk: + score = float("-inf") + + return outstate, score + + def finish(self, state: LMState): + """ + Evaluate eos for language model based on the current lm state + + Returns: + -------- + (LMState, float): pair of (new state, score for the current word) + """ + return self.score(state, self.dictionary.eos()) + + def empty_cache(self): + self.states = {} + self.stateq = deque() + gc.collect() + + +class W2lFairseqLMDecoder(W2lDecoder): + def __init__(self, args, tgt_dict): + super().__init__(args, tgt_dict) + + self.unit_lm = getattr(args, "unit_lm", False) + + self.lexicon = load_words(args.lexicon) if args.lexicon else None + self.idx_to_wrd = {} + + checkpoint = torch.load(args.kenlm_model, map_location="cpu") + + if "cfg" in checkpoint and checkpoint["cfg"] is not None: + lm_args = checkpoint["cfg"] + else: + lm_args = convert_namespace_to_omegaconf(checkpoint["args"]) + + with open_dict(lm_args.task): + lm_args.task.data = osp.dirname(args.kenlm_model) + + task = tasks.setup_task(lm_args.task) + model = task.build_model(lm_args.model) + model.load_state_dict(checkpoint["model"], strict=False) + + self.trie = Trie(self.vocab_size, self.silence) + + self.word_dict = task.dictionary + self.unk_word = self.word_dict.unk() + self.lm = FairseqLM(self.word_dict, model) + + if self.lexicon: + start_state = self.lm.start(False) + for i, (word, spellings) in enumerate(self.lexicon.items()): + if self.unit_lm: + word_idx = i + self.idx_to_wrd[i] = word + score = 0 + else: + word_idx = self.word_dict.index(word) + _, score = self.lm.score(start_state, word_idx, no_cache=True) + + for spelling in spellings: + spelling_idxs = [tgt_dict.index(token) for token in spelling] + assert ( + tgt_dict.unk() not in spelling_idxs + ), f"{spelling} {spelling_idxs}" + self.trie.insert(spelling_idxs, word_idx, score) + self.trie.smear(SmearingMode.MAX) + + self.decoder_opts = LexiconDecoderOptions( + beam_size=args.beam, + beam_size_token=int(getattr(args, "beam_size_token", len(tgt_dict))), + beam_threshold=args.beam_threshold, + lm_weight=args.lm_weight, + word_score=args.word_score, + unk_score=args.unk_weight, + sil_score=args.sil_weight, + log_add=False, + criterion_type=self.criterion_type, + ) + + self.decoder = LexiconDecoder( + self.decoder_opts, + self.trie, + self.lm, + self.silence, + self.blank, + self.unk_word, + [], + self.unit_lm, + ) + else: + assert args.unit_lm, "lexicon free decoding can only be done with a unit language model" + from flashlight.lib.text.decoder import LexiconFreeDecoder, LexiconFreeDecoderOptions + + d = {w: [[w]] for w in tgt_dict.symbols} + self.word_dict = create_word_dict(d) + self.lm = KenLM(args.kenlm_model, self.word_dict) + self.decoder_opts = LexiconFreeDecoderOptions( + beam_size=args.beam, + beam_size_token=int(getattr(args, "beam_size_token", len(tgt_dict))), + beam_threshold=args.beam_threshold, + lm_weight=args.lm_weight, + sil_score=args.sil_weight, + log_add=False, + criterion_type=self.criterion_type, + ) + self.decoder = LexiconFreeDecoder( + self.decoder_opts, self.lm, self.silence, self.blank, [] + ) + + def decode(self, emissions): + B, T, N = emissions.size() + hypos = [] + + def idx_to_word(idx): + if self.unit_lm: + return self.idx_to_wrd[idx] + else: + return self.word_dict[idx] + + def make_hypo(result): + hypo = {"tokens": self.get_tokens(result.tokens), "score": result.score} + if self.lexicon: + hypo["words"] = [idx_to_word(x) for x in result.words if x >= 0] + return hypo + + for b in range(B): + emissions_ptr = emissions.data_ptr() + 4 * b * emissions.stride(0) + results = self.decoder.decode(emissions_ptr, T, N) + + nbest_results = results[: self.nbest] + hypos.append([make_hypo(result) for result in nbest_results]) + self.lm.empty_cache() + + return hypos diff --git a/fairseq/examples/speech_synthesis/README.md b/fairseq/examples/speech_synthesis/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4a3ae54b857c43621c9fb67ee4b214584beec835 --- /dev/null +++ b/fairseq/examples/speech_synthesis/README.md @@ -0,0 +1,16 @@ +Speech Synthesis (S^2) +=== + +Speech synthesis with fairseq. + +- Autoregressive and non-autoregressive models +- Multi-speaker synthesis +- Audio preprocessing +- Automatic metrics +- Similar data configuration as [S2T](../speech_to_text/README.md) + + +## Examples +- [Single-speaker synthesis on LJSpeech](docs/ljspeech_example.md) +- [Multi-speaker synthesis on VCTK](docs/vctk_example.md) +- [Multi-speaker synthesis on Common Voice](docs/common_voice_example.md) diff --git a/fairseq/examples/speech_synthesis/__init__.py b/fairseq/examples/speech_synthesis/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/examples/speech_synthesis/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/examples/speech_synthesis/data_utils.py b/fairseq/examples/speech_synthesis/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f43a4a90046fb9ee4944dc06ba377c1faade141d --- /dev/null +++ b/fairseq/examples/speech_synthesis/data_utils.py @@ -0,0 +1,320 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +from pathlib import Path +from typing import Optional, List, Dict +import zipfile +import tempfile +from dataclasses import dataclass +from itertools import groupby + +import torch +import torch.nn.functional as F +import numpy as np +from tqdm import tqdm + +from examples.speech_to_text.data_utils import load_tsv_to_dicts +from fairseq.data.audio.audio_utils import TTSSpectrogram, TTSMelScale + + +def trim_or_pad_to_target_length( + data_1d_or_2d: np.ndarray, target_length: int +) -> np.ndarray: + assert len(data_1d_or_2d.shape) in {1, 2} + delta = data_1d_or_2d.shape[0] - target_length + if delta >= 0: # trim if being longer + data_1d_or_2d = data_1d_or_2d[: target_length] + else: # pad if being shorter + if len(data_1d_or_2d.shape) == 1: + data_1d_or_2d = np.concatenate( + [data_1d_or_2d, np.zeros(-delta)], axis=0 + ) + else: + data_1d_or_2d = np.concatenate( + [data_1d_or_2d, np.zeros((-delta, data_1d_or_2d.shape[1]))], + axis=0 + ) + return data_1d_or_2d + + +def extract_logmel_spectrogram( + waveform: torch.Tensor, sample_rate: int, + output_path: Optional[Path] = None, win_length: int = 1024, + hop_length: int = 256, n_fft: int = 1024, + win_fn: callable = torch.hann_window, n_mels: int = 80, + f_min: float = 0., f_max: float = 8000, eps: float = 1e-5, + overwrite: bool = False, target_length: Optional[int] = None +): + if output_path is not None and output_path.is_file() and not overwrite: + return + + spectrogram_transform = TTSSpectrogram( + n_fft=n_fft, win_length=win_length, hop_length=hop_length, + window_fn=win_fn + ) + mel_scale_transform = TTSMelScale( + n_mels=n_mels, sample_rate=sample_rate, f_min=f_min, f_max=f_max, + n_stft=n_fft // 2 + 1 + ) + spectrogram = spectrogram_transform(waveform) + mel_spec = mel_scale_transform(spectrogram) + logmel_spec = torch.clamp(mel_spec, min=eps).log() + assert len(logmel_spec.shape) == 3 and logmel_spec.shape[0] == 1 + logmel_spec = logmel_spec.squeeze().t() # D x T -> T x D + if target_length is not None: + trim_or_pad_to_target_length(logmel_spec, target_length) + + if output_path is not None: + np.save(output_path.as_posix(), logmel_spec) + else: + return logmel_spec + + +def extract_pitch( + waveform: torch.Tensor, sample_rate: int, + output_path: Optional[Path] = None, hop_length: int = 256, + log_scale: bool = True, phoneme_durations: Optional[List[int]] = None +): + if output_path is not None and output_path.is_file(): + return + + try: + import pyworld + except ImportError: + raise ImportError("Please install PyWORLD: pip install pyworld") + + _waveform = waveform.squeeze(0).double().numpy() + pitch, t = pyworld.dio( + _waveform, sample_rate, frame_period=hop_length / sample_rate * 1000 + ) + pitch = pyworld.stonemask(_waveform, pitch, t, sample_rate) + + if phoneme_durations is not None: + pitch = trim_or_pad_to_target_length(pitch, sum(phoneme_durations)) + try: + from scipy.interpolate import interp1d + except ImportError: + raise ImportError("Please install SciPy: pip install scipy") + nonzero_ids = np.where(pitch != 0)[0] + interp_fn = interp1d( + nonzero_ids, + pitch[nonzero_ids], + fill_value=(pitch[nonzero_ids[0]], pitch[nonzero_ids[-1]]), + bounds_error=False, + ) + pitch = interp_fn(np.arange(0, len(pitch))) + d_cumsum = np.cumsum(np.concatenate([np.array([0]), phoneme_durations])) + pitch = np.array( + [ + np.mean(pitch[d_cumsum[i-1]: d_cumsum[i]]) + for i in range(1, len(d_cumsum)) + ] + ) + assert len(pitch) == len(phoneme_durations) + + if log_scale: + pitch = np.log(pitch + 1) + + if output_path is not None: + np.save(output_path.as_posix(), pitch) + else: + return pitch + + +def extract_energy( + waveform: torch.Tensor, output_path: Optional[Path] = None, + hop_length: int = 256, n_fft: int = 1024, log_scale: bool = True, + phoneme_durations: Optional[List[int]] = None +): + if output_path is not None and output_path.is_file(): + return + + assert len(waveform.shape) == 2 and waveform.shape[0] == 1 + waveform = waveform.view(1, 1, waveform.shape[1]) + waveform = F.pad( + waveform.unsqueeze(1), [n_fft // 2, n_fft // 2, 0, 0], + mode="reflect" + ) + waveform = waveform.squeeze(1) + + fourier_basis = np.fft.fft(np.eye(n_fft)) + cutoff = int((n_fft / 2 + 1)) + fourier_basis = np.vstack( + [np.real(fourier_basis[:cutoff, :]), + np.imag(fourier_basis[:cutoff, :])] + ) + + forward_basis = torch.FloatTensor(fourier_basis[:, None, :]) + forward_transform = F.conv1d( + waveform, forward_basis, stride=hop_length, padding=0 + ) + + real_part = forward_transform[:, :cutoff, :] + imag_part = forward_transform[:, cutoff:, :] + magnitude = torch.sqrt(real_part ** 2 + imag_part ** 2) + energy = torch.norm(magnitude, dim=1).squeeze(0).numpy() + + if phoneme_durations is not None: + energy = trim_or_pad_to_target_length(energy, sum(phoneme_durations)) + d_cumsum = np.cumsum(np.concatenate([np.array([0]), phoneme_durations])) + energy = np.array( + [ + np.mean(energy[d_cumsum[i - 1]: d_cumsum[i]]) + for i in range(1, len(d_cumsum)) + ] + ) + assert len(energy) == len(phoneme_durations) + + if log_scale: + energy = np.log(energy + 1) + + if output_path is not None: + np.save(output_path.as_posix(), energy) + else: + return energy + + +def get_global_cmvn(feature_root: Path, output_path: Optional[Path] = None): + mean_x, mean_x2, n_frames = None, None, 0 + feature_paths = feature_root.glob("*.npy") + for p in tqdm(feature_paths): + with open(p, 'rb') as f: + frames = np.load(f).squeeze() + + n_frames += frames.shape[0] + + cur_mean_x = frames.sum(axis=0) + if mean_x is None: + mean_x = cur_mean_x + else: + mean_x += cur_mean_x + + cur_mean_x2 = (frames ** 2).sum(axis=0) + if mean_x2 is None: + mean_x2 = cur_mean_x2 + else: + mean_x2 += cur_mean_x2 + + mean_x /= n_frames + mean_x2 /= n_frames + var_x = mean_x2 - mean_x ** 2 + std_x = np.sqrt(np.maximum(var_x, 1e-10)) + + if output_path is not None: + with open(output_path, 'wb') as f: + np.savez(f, mean=mean_x, std=std_x) + else: + return {"mean": mean_x, "std": std_x} + + +def ipa_phonemize(text, lang="en-us", use_g2p=False): + if use_g2p: + assert lang == "en-us", "g2pE phonemizer only works for en-us" + try: + from g2p_en import G2p + g2p = G2p() + return " ".join("|" if p == " " else p for p in g2p(text)) + except ImportError: + raise ImportError( + "Please install phonemizer: pip install g2p_en" + ) + else: + try: + from phonemizer import phonemize + from phonemizer.separator import Separator + return phonemize( + text, backend='espeak', language=lang, + separator=Separator(word="| ", phone=" ") + ) + except ImportError: + raise ImportError( + "Please install phonemizer: pip install phonemizer" + ) + + +@dataclass +class ForceAlignmentInfo(object): + tokens: List[str] + frame_durations: List[int] + start_sec: Optional[float] + end_sec: Optional[float] + + +def get_mfa_alignment_by_sample_id( + textgrid_zip_path: str, sample_id: str, sample_rate: int, + hop_length: int, silence_phones: List[str] = ("sil", "sp", "spn") +) -> ForceAlignmentInfo: + try: + import tgt + except ImportError: + raise ImportError("Please install TextGridTools: pip install tgt") + + filename = f"{sample_id}.TextGrid" + out_root = Path(tempfile.gettempdir()) + tgt_path = out_root / filename + with zipfile.ZipFile(textgrid_zip_path) as f_zip: + f_zip.extract(filename, path=out_root) + textgrid = tgt.io.read_textgrid(tgt_path.as_posix()) + os.remove(tgt_path) + + phones, frame_durations = [], [] + start_sec, end_sec, end_idx = 0, 0, 0 + for t in textgrid.get_tier_by_name("phones")._objects: + s, e, p = t.start_time, t.end_time, t.text + # Trim leading silences + if len(phones) == 0: + if p in silence_phones: + continue + else: + start_sec = s + phones.append(p) + if p not in silence_phones: + end_sec = e + end_idx = len(phones) + r = sample_rate / hop_length + frame_durations.append(int(np.round(e * r) - np.round(s * r))) + # Trim tailing silences + phones = phones[:end_idx] + frame_durations = frame_durations[:end_idx] + + return ForceAlignmentInfo( + tokens=phones, frame_durations=frame_durations, start_sec=start_sec, + end_sec=end_sec + ) + + +def get_mfa_alignment( + textgrid_zip_path: str, sample_ids: List[str], sample_rate: int, + hop_length: int +) -> Dict[str, ForceAlignmentInfo]: + return { + i: get_mfa_alignment_by_sample_id( + textgrid_zip_path, i, sample_rate, hop_length + ) for i in tqdm(sample_ids) + } + + +def get_unit_alignment( + id_to_unit_tsv_path: str, sample_ids: List[str] +) -> Dict[str, ForceAlignmentInfo]: + id_to_units = { + e["id"]: e["units"] for e in load_tsv_to_dicts(id_to_unit_tsv_path) + } + id_to_units = {i: id_to_units[i].split() for i in sample_ids} + id_to_units_collapsed = { + i: [uu for uu, _ in groupby(u)] for i, u in id_to_units.items() + } + id_to_durations = { + i: [len(list(g)) for _, g in groupby(u)] for i, u in id_to_units.items() + } + + return { + i: ForceAlignmentInfo( + tokens=id_to_units_collapsed[i], frame_durations=id_to_durations[i], + start_sec=None, end_sec=None + ) + for i in sample_ids + } diff --git a/fairseq/examples/speech_synthesis/docs/common_voice_example.md b/fairseq/examples/speech_synthesis/docs/common_voice_example.md new file mode 100644 index 0000000000000000000000000000000000000000..40e841b284a7e34b458b286eb0bb60e33c0601da --- /dev/null +++ b/fairseq/examples/speech_synthesis/docs/common_voice_example.md @@ -0,0 +1,56 @@ +[[Back]](..) + +# Common Voice + +[Common Voice](https://commonvoice.mozilla.org/en/datasets) is a public domain speech corpus with 11.2K hours of read +speech in 76 languages (the latest version 7.0). We provide examples for building +[Transformer](https://arxiv.org/abs/1809.08895) models on this dataset. + + +## Data preparation +[Download](https://commonvoice.mozilla.org/en/datasets) and unpack Common Voice v4 to a path `${DATA_ROOT}/${LANG_ID}`. +Create splits and generate audio manifests with +```bash +python -m examples.speech_synthesis.preprocessing.get_common_voice_audio_manifest \ + --data-root ${DATA_ROOT} \ + --lang ${LANG_ID} \ + --output-manifest-root ${AUDIO_MANIFEST_ROOT} --convert-to-wav +``` + +Then, extract log-Mel spectrograms, generate feature manifest and create data configuration YAML with +```bash +python -m examples.speech_synthesis.preprocessing.get_feature_manifest \ + --audio-manifest-root ${AUDIO_MANIFEST_ROOT} \ + --output-root ${FEATURE_MANIFEST_ROOT} \ + --ipa-vocab --lang ${LANG_ID} +``` +where we use phoneme inputs (`--ipa-vocab`) as example. + +To denoise audio and trim leading/trailing silence using signal processing based VAD, run +```bash +for SPLIT in dev test train; do + python -m examples.speech_synthesis.preprocessing.denoise_and_vad_audio \ + --audio-manifest ${AUDIO_MANIFEST_ROOT}/${SPLIT}.audio.tsv \ + --output-dir ${PROCESSED_DATA_ROOT} \ + --denoise --vad --vad-agg-level 2 +done +``` + + +## Training +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#transformer).) + + +## Inference +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#inference).) + +## Automatic Evaluation +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#automatic-evaluation).) + +## Results + +| Language | Speakers | --arch | Params | Test MCD | Model | +|---|---|---|---|---|---| +| English | 200 | tts_transformer | 54M | 3.8 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2/cv4_en200_transformer_phn.tar) | + +[[Back]](..) diff --git a/fairseq/examples/speech_synthesis/docs/ljspeech_example.md b/fairseq/examples/speech_synthesis/docs/ljspeech_example.md new file mode 100644 index 0000000000000000000000000000000000000000..90c524fac8ffdc1819ec9bb36928500320337603 --- /dev/null +++ b/fairseq/examples/speech_synthesis/docs/ljspeech_example.md @@ -0,0 +1,138 @@ +[[Back]](..) + +# LJSpeech + +[LJSpeech](https://keithito.com/LJ-Speech-Dataset) is a public domain TTS +corpus with around 24 hours of English speech sampled at 22.05kHz. We provide examples for building +[Transformer](https://arxiv.org/abs/1809.08895) and [FastSpeech 2](https://arxiv.org/abs/2006.04558) +models on this dataset. + + +## Data preparation + +Download data, create splits and generate audio manifests with +```bash +python -m examples.speech_synthesis.preprocessing.get_ljspeech_audio_manifest \ + --output-data-root ${AUDIO_DATA_ROOT} \ + --output-manifest-root ${AUDIO_MANIFEST_ROOT} +``` + +Then, extract log-Mel spectrograms, generate feature manifest and create data configuration YAML with +```bash +python -m examples.speech_synthesis.preprocessing.get_feature_manifest \ + --audio-manifest-root ${AUDIO_MANIFEST_ROOT} \ + --output-root ${FEATURE_MANIFEST_ROOT} \ + --ipa-vocab --use-g2p +``` +where we use phoneme inputs (`--ipa-vocab --use-g2p`) as example. + +FastSpeech 2 additionally requires frame durations, pitch and energy as auxiliary training targets. +Add `--add-fastspeech-targets` to include these fields in the feature manifests. We get frame durations either from +phoneme-level force-alignment or frame-level pseudo-text unit sequence. They should be pre-computed and specified via: +- `--textgrid-zip ${TEXT_GRID_ZIP_PATH}` for a ZIP file, inside which there is one + [TextGrid](https://www.fon.hum.uva.nl/praat/manual/TextGrid.html) file per sample to provide force-alignment info. +- `--id-to-units-tsv ${ID_TO_UNIT_TSV}` for a TSV file, where there are 2 columns for sample ID and + space-delimited pseudo-text unit sequence, respectively. + +For your convenience, we provide pre-computed +[force-alignment](https://dl.fbaipublicfiles.com/fairseq/s2/ljspeech_mfa.zip) from +[Montreal Forced Aligner](https://github.com/MontrealCorpusTools/Montreal-Forced-Aligner) and +[pseudo-text units](s3://dl.fbaipublicfiles.com/fairseq/s2/ljspeech_hubert.tsv) from +[HuBERT](https://github.com/pytorch/fairseq/tree/main/examples/hubert). You can also generate them by yourself using +a different software or model. + + +## Training +#### Transformer +```bash +fairseq-train ${FEATURE_MANIFEST_ROOT} --save-dir ${SAVE_DIR} \ + --config-yaml config.yaml --train-subset train --valid-subset dev \ + --num-workers 4 --max-tokens 30000 --max-update 200000 \ + --task text_to_speech --criterion tacotron2 --arch tts_transformer \ + --clip-norm 5.0 --n-frames-per-step 4 --bce-pos-weight 5.0 \ + --dropout 0.1 --attention-dropout 0.1 --activation-dropout 0.1 \ + --encoder-normalize-before --decoder-normalize-before \ + --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --seed 1 --update-freq 8 --eval-inference --best-checkpoint-metric mcd_loss +``` +where `SAVE_DIR` is the checkpoint root path. We set `--update-freq 8` to simulate 8 GPUs with 1 GPU. You may want to +update it accordingly when using more than 1 GPU. + +#### FastSpeech2 +```bash +fairseq-train ${FEATURE_MANIFEST_ROOT} --save-dir ${SAVE_DIR} \ + --config-yaml config.yaml --train-subset train --valid-subset dev \ + --num-workers 4 --max-sentences 6 --max-update 200000 \ + --task text_to_speech --criterion fastspeech2 --arch fastspeech2 \ + --clip-norm 5.0 --n-frames-per-step 1 \ + --dropout 0.1 --attention-dropout 0.1 --activation-dropout 0.1 \ + --encoder-normalize-before --decoder-normalize-before \ + --optimizer adam --lr 5e-4 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --seed 1 --update-freq 8 --eval-inference --best-checkpoint-metric mcd_loss +``` + + +## Inference +Average the last 5 checkpoints, generate the test split spectrogram and waveform using the default Griffin-Lim vocoder: +```bash +SPLIT=test +CHECKPOINT_NAME=avg_last_5 +CHECKPOINT_PATH=${SAVE_DIR}/checkpoint_${CHECKPOINT_NAME}.pt +python scripts/average_checkpoints.py --inputs ${SAVE_DIR} \ + --num-epoch-checkpoints 5 \ + --output ${CHECKPOINT_PATH} + +python -m examples.speech_synthesis.generate_waveform ${FEATURE_MANIFEST_ROOT} \ + --config-yaml config.yaml --gen-subset ${SPLIT} --task text_to_speech \ + --path ${CHECKPOINT_PATH} --max-tokens 50000 --spec-bwd-max-iter 32 \ + --dump-waveforms +``` +which dumps files (waveform, feature, attention plot, etc.) to `${SAVE_DIR}/generate-${CHECKPOINT_NAME}-${SPLIT}`. To +re-synthesize target waveforms for automatic evaluation, add `--dump-target`. + +## Automatic Evaluation +To start with, generate the manifest for synthetic speech, which will be taken as inputs by evaluation scripts. +```bash +python -m examples.speech_synthesis.evaluation.get_eval_manifest \ + --generation-root ${SAVE_DIR}/generate-${CHECKPOINT_NAME}-${SPLIT} \ + --audio-manifest ${AUDIO_MANIFEST_ROOT}/${SPLIT}.audio.tsv \ + --output-path ${EVAL_OUTPUT_ROOT}/eval.tsv \ + --vocoder griffin_lim --sample-rate 22050 --audio-format flac \ + --use-resynthesized-target +``` +Speech recognition (ASR) models usually operate at lower sample rates (e.g. 16kHz). For the WER/CER metric, +you may need to resample the audios accordingly --- add `--output-sample-rate 16000` for `generate_waveform.py` and +use `--sample-rate 16000` for `get_eval_manifest.py`. + + +#### WER/CER metric +We use wav2vec 2.0 ASR model as example. [Download](https://github.com/pytorch/fairseq/tree/main/examples/wav2vec) +the model checkpoint and dictionary, then compute WER/CER with +```bash +python -m examples.speech_synthesis.evaluation.eval_asr \ + --audio-header syn --text-header text --err-unit char --split ${SPLIT} \ + --w2v-ckpt ${WAV2VEC2_CHECKPOINT_PATH} --w2v-dict-dir ${WAV2VEC2_DICT_DIR} \ + --raw-manifest ${EVAL_OUTPUT_ROOT}/eval_16khz.tsv --asr-dir ${EVAL_OUTPUT_ROOT}/asr +``` + +#### MCD/MSD metric +```bash +python -m examples.speech_synthesis.evaluation.eval_sp \ + ${EVAL_OUTPUT_ROOT}/eval.tsv --mcd --msd +``` + +#### F0 metrics +```bash +python -m examples.speech_synthesis.evaluation.eval_f0 \ + ${EVAL_OUTPUT_ROOT}/eval.tsv --gpe --vde --ffe +``` + + +## Results + +| --arch | Params | Test MCD | Model | +|---|---|---|---| +| tts_transformer | 54M | 3.8 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2/ljspeech_transformer_phn.tar) | +| fastspeech2 | 41M | 3.8 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2/ljspeech_fastspeech2_phn.tar) | + +[[Back]](..) diff --git a/fairseq/examples/speech_synthesis/docs/vctk_example.md b/fairseq/examples/speech_synthesis/docs/vctk_example.md new file mode 100644 index 0000000000000000000000000000000000000000..2ba78f3f73d6ea30f9de89150fbbc9dd5923b6fa --- /dev/null +++ b/fairseq/examples/speech_synthesis/docs/vctk_example.md @@ -0,0 +1,51 @@ +[[Back]](..) + +# VCTK + +[VCTK](https://datashare.ed.ac.uk/handle/10283/3443) is an open English speech corpus. We provide examples +for building [Transformer](https://arxiv.org/abs/1809.08895) models on this dataset. + + +## Data preparation +Download data, create splits and generate audio manifests with +```bash +python -m examples.speech_synthesis.preprocessing.get_vctk_audio_manifest \ + --output-data-root ${AUDIO_DATA_ROOT} \ + --output-manifest-root ${AUDIO_MANIFEST_ROOT} +``` + +Then, extract log-Mel spectrograms, generate feature manifest and create data configuration YAML with +```bash +python -m examples.speech_synthesis.preprocessing.get_feature_manifest \ + --audio-manifest-root ${AUDIO_MANIFEST_ROOT} \ + --output-root ${FEATURE_MANIFEST_ROOT} \ + --ipa-vocab --use-g2p +``` +where we use phoneme inputs (`--ipa-vocab --use-g2p`) as example. + +To denoise audio and trim leading/trailing silence using signal processing based VAD, run +```bash +for SPLIT in dev test train; do + python -m examples.speech_synthesis.preprocessing.denoise_and_vad_audio \ + --audio-manifest ${AUDIO_MANIFEST_ROOT}/${SPLIT}.audio.tsv \ + --output-dir ${PROCESSED_DATA_ROOT} \ + --denoise --vad --vad-agg-level 3 +done +``` + +## Training +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#transformer).) + +## Inference +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#inference).) + +## Automatic Evaluation +(Please refer to [the LJSpeech example](../docs/ljspeech_example.md#automatic-evaluation).) + +## Results + +| --arch | Params | Test MCD | Model | +|---|---|---|---| +| tts_transformer | 54M | 3.4 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2/vctk_transformer_phn.tar) | + +[[Back]](..) diff --git a/fairseq/examples/speech_synthesis/evaluation/__init__.py b/fairseq/examples/speech_synthesis/evaluation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/examples/speech_synthesis/evaluation/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/examples/speech_synthesis/evaluation/eval_asr.py b/fairseq/examples/speech_synthesis/evaluation/eval_asr.py new file mode 100644 index 0000000000000000000000000000000000000000..005a11bfb34ca477ad9e133acd60f249e66cda47 --- /dev/null +++ b/fairseq/examples/speech_synthesis/evaluation/eval_asr.py @@ -0,0 +1,128 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import editdistance +import re +import shutil +import soundfile as sf +import subprocess +from pathlib import Path + +from examples.speech_to_text.data_utils import load_tsv_to_dicts + + +def preprocess_text(text): + text = "|".join(re.sub(r"[^A-Z' ]", " ", text.upper()).split()) + text = " ".join(text) + return text + + +def prepare_w2v_data( + dict_dir, sample_rate, label, audio_paths, texts, split, data_dir +): + data_dir.mkdir(parents=True, exist_ok=True) + shutil.copyfile( + dict_dir / f"dict.{label}.txt", + data_dir / f"dict.{label}.txt" + ) + with open(data_dir / f"{split}.tsv", "w") as f: + f.write("/\n") + for audio_path in audio_paths: + wav, sr = sf.read(audio_path) + assert sr == sample_rate, f"{sr} != sample_rate" + nsample = len(wav) + f.write(f"{audio_path}\t{nsample}\n") + with open(data_dir / f"{split}.{label}", "w") as f: + for text in texts: + text = preprocess_text(text) + f.write(f"{text}\n") + + +def run_asr(asr_dir, split, w2v_ckpt, w2v_label, res_dir): + """ + results will be saved at + {res_dir}/{ref,hypo}.word-{w2v_ckpt.filename}-{split}.txt + """ + cmd = ["python", "-m", "examples.speech_recognition.infer"] + cmd += [str(asr_dir.resolve())] + cmd += ["--task", "audio_finetuning", "--nbest", "1", "--quiet"] + cmd += ["--w2l-decoder", "viterbi", "--criterion", "ctc"] + cmd += ["--post-process", "letter", "--max-tokens", "4000000"] + cmd += ["--path", str(w2v_ckpt.resolve()), "--labels", w2v_label] + cmd += ["--gen-subset", split, "--results-path", str(res_dir.resolve())] + + print(f"running cmd:\n{' '.join(cmd)}") + subprocess.run(cmd, check=True) + + +def compute_error_rate(hyp_wrd_path, ref_wrd_path, unit="word"): + """each line is "<text> (None-<index>)" """ + tokenize_line = { + "word": lambda x: re.sub(r" \(.*\)$", "", x.rstrip()).split(), + "char": lambda x: list(re.sub(r" \(.*\)$", "", x.rstrip())) + }.get(unit) + if tokenize_line is None: + raise ValueError(f"{unit} not supported") + + inds = [int(re.sub(r"\D*(\d*)\D*", r"\1", line)) + for line in open(hyp_wrd_path)] + hyps = [tokenize_line(line) for line in open(hyp_wrd_path)] + refs = [tokenize_line(line) for line in open(ref_wrd_path)] + assert(len(hyps) == len(refs)) + err_rates = [ + editdistance.eval(hyp, ref) / len(ref) for hyp, ref in zip(hyps, refs) + ] + ind_to_err_rates = {i: e for i, e in zip(inds, err_rates)} + return ind_to_err_rates + + +def main(args): + samples = load_tsv_to_dicts(args.raw_manifest) + ids = [ + sample[args.id_header] if args.id_header else "" for sample in samples + ] + audio_paths = [sample[args.audio_header] for sample in samples] + texts = [sample[args.text_header] for sample in samples] + + prepare_w2v_data( + args.w2v_dict_dir, + args.w2v_sample_rate, + args.w2v_label, + audio_paths, + texts, + args.split, + args.asr_dir + ) + run_asr(args.asr_dir, args.split, args.w2v_ckpt, args.w2v_label, args.asr_dir) + ind_to_err_rates = compute_error_rate( + args.asr_dir / f"hypo.word-{args.w2v_ckpt.name}-{args.split}.txt", + args.asr_dir / f"ref.word-{args.w2v_ckpt.name}-{args.split}.txt", + args.err_unit, + ) + + uer_path = args.asr_dir / f"uer_{args.err_unit}.{args.split}.tsv" + with open(uer_path, "w") as f: + f.write("id\taudio\tuer\n") + for ind, (id_, audio_path) in enumerate(zip(ids, audio_paths)): + f.write(f"{id_}\t{audio_path}\t{ind_to_err_rates[ind]:.4f}\n") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--raw-manifest", required=True, type=Path) + parser.add_argument("--asr-dir", required=True, type=Path) + parser.add_argument("--id-header", default="id", type=str) + parser.add_argument("--audio-header", default="audio", type=str) + parser.add_argument("--text-header", default="src_text", type=str) + parser.add_argument("--split", default="raw", type=str) + parser.add_argument("--w2v-ckpt", required=True, type=Path) + parser.add_argument("--w2v-dict-dir", required=True, type=Path) + parser.add_argument("--w2v-sample-rate", default=16000, type=int) + parser.add_argument("--w2v-label", default="ltr", type=str) + parser.add_argument("--err-unit", default="word", type=str) + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/speech_synthesis/evaluation/eval_f0.py b/fairseq/examples/speech_synthesis/evaluation/eval_f0.py new file mode 100644 index 0000000000000000000000000000000000000000..df721d683113b44957149cfc3cddaba36520a22c --- /dev/null +++ b/fairseq/examples/speech_synthesis/evaluation/eval_f0.py @@ -0,0 +1,266 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Signal processing-based evaluation using waveforms +""" +import numpy as np +import os.path as op + +import torchaudio +import tqdm +from tabulate import tabulate + +from examples.speech_synthesis.utils import ( + gross_pitch_error, voicing_decision_error, f0_frame_error +) +from examples.speech_synthesis.evaluation.eval_sp import load_eval_spec + + +def difference_function(x, n, tau_max): + """ + Compute difference function of data x. This solution is implemented directly + with Numpy fft. + + + :param x: audio data + :param n: length of data + :param tau_max: integration window size + :return: difference function + :rtype: list + """ + + x = np.array(x, np.float64) + w = x.size + tau_max = min(tau_max, w) + x_cumsum = np.concatenate((np.array([0.]), (x * x).cumsum())) + size = w + tau_max + p2 = (size // 32).bit_length() + nice_numbers = (16, 18, 20, 24, 25, 27, 30, 32) + size_pad = min(x * 2 ** p2 for x in nice_numbers if x * 2 ** p2 >= size) + fc = np.fft.rfft(x, size_pad) + conv = np.fft.irfft(fc * fc.conjugate())[:tau_max] + return x_cumsum[w:w - tau_max:-1] + x_cumsum[w] - x_cumsum[:tau_max] - \ + 2 * conv + + +def cumulative_mean_normalized_difference_function(df, n): + """ + Compute cumulative mean normalized difference function (CMND). + + :param df: Difference function + :param n: length of data + :return: cumulative mean normalized difference function + :rtype: list + """ + + # scipy method + cmn_df = df[1:] * range(1, n) / np.cumsum(df[1:]).astype(float) + return np.insert(cmn_df, 0, 1) + + +def get_pitch(cmdf, tau_min, tau_max, harmo_th=0.1): + """ + Return fundamental period of a frame based on CMND function. + + :param cmdf: Cumulative Mean Normalized Difference function + :param tau_min: minimum period for speech + :param tau_max: maximum period for speech + :param harmo_th: harmonicity threshold to determine if it is necessary to + compute pitch frequency + :return: fundamental period if there is values under threshold, 0 otherwise + :rtype: float + """ + tau = tau_min + while tau < tau_max: + if cmdf[tau] < harmo_th: + while tau + 1 < tau_max and cmdf[tau + 1] < cmdf[tau]: + tau += 1 + return tau + tau += 1 + + return 0 # if unvoiced + + +def compute_yin(sig, sr, w_len=512, w_step=256, f0_min=100, f0_max=500, + harmo_thresh=0.1): + """ + + Compute the Yin Algorithm. Return fundamental frequency and harmonic rate. + + https://github.com/NVIDIA/mellotron adaption of + https://github.com/patriceguyot/Yin + + :param sig: Audio signal (list of float) + :param sr: sampling rate (int) + :param w_len: size of the analysis window (samples) + :param w_step: size of the lag between two consecutives windows (samples) + :param f0_min: Minimum fundamental frequency that can be detected (hertz) + :param f0_max: Maximum fundamental frequency that can be detected (hertz) + :param harmo_thresh: Threshold of detection. The yalgorithmù return the + first minimum of the CMND function below this threshold. + + :returns: + + * pitches: list of fundamental frequencies, + * harmonic_rates: list of harmonic rate values for each fundamental + frequency value (= confidence value) + * argmins: minimums of the Cumulative Mean Normalized DifferenceFunction + * times: list of time of each estimation + :rtype: tuple + """ + + tau_min = int(sr / f0_max) + tau_max = int(sr / f0_min) + + # time values for each analysis window + time_scale = range(0, len(sig) - w_len, w_step) + times = [t/float(sr) for t in time_scale] + frames = [sig[t:t + w_len] for t in time_scale] + + pitches = [0.0] * len(time_scale) + harmonic_rates = [0.0] * len(time_scale) + argmins = [0.0] * len(time_scale) + + for i, frame in enumerate(frames): + # Compute YIN + df = difference_function(frame, w_len, tau_max) + cm_df = cumulative_mean_normalized_difference_function(df, tau_max) + p = get_pitch(cm_df, tau_min, tau_max, harmo_thresh) + + # Get results + if np.argmin(cm_df) > tau_min: + argmins[i] = float(sr / np.argmin(cm_df)) + if p != 0: # A pitch was found + pitches[i] = float(sr / p) + harmonic_rates[i] = cm_df[p] + else: # No pitch, but we compute a value of the harmonic rate + harmonic_rates[i] = min(cm_df) + + return pitches, harmonic_rates, argmins, times + + +def extract_f0(samples): + f0_samples = [] + for sample in tqdm.tqdm(samples): + if not op.isfile(sample["ref"]) or not op.isfile(sample["syn"]): + f0_samples.append(None) + continue + + # assume single channel + yref, sr = torchaudio.load(sample["ref"]) + ysyn, _sr = torchaudio.load(sample["syn"]) + yref, ysyn = yref[0], ysyn[0] + assert sr == _sr, f"{sr} != {_sr}" + + yref_f0 = compute_yin(yref, sr) + ysyn_f0 = compute_yin(ysyn, sr) + + f0_samples += [ + { + "ref": yref_f0, + "syn": ysyn_f0 + } + ] + + return f0_samples + + +def eval_f0_error(samples, distortion_fn): + results = [] + for sample in tqdm.tqdm(samples): + if sample is None: + results.append(None) + continue + # assume single channel + yref_f, _, _, yref_t = sample["ref"] + ysyn_f, _, _, ysyn_t = sample["syn"] + + yref_f = np.array(yref_f) + yref_t = np.array(yref_t) + ysyn_f = np.array(ysyn_f) + ysyn_t = np.array(ysyn_t) + + distortion = distortion_fn(yref_t, yref_f, ysyn_t, ysyn_f) + results.append((distortion.item(), + len(yref_f), + len(ysyn_f) + )) + return results + + +def eval_gross_pitch_error(samples): + return eval_f0_error(samples, gross_pitch_error) + + +def eval_voicing_decision_error(samples): + return eval_f0_error(samples, voicing_decision_error) + + +def eval_f0_frame_error(samples): + return eval_f0_error(samples, f0_frame_error) + + +def print_results(results, show_bin): + results = np.array(list(filter(lambda x: x is not None, results))) + + np.set_printoptions(precision=3) + + def _print_result(results): + res = { + "nutt": len(results), + "error": results[:, 0].mean(), + "std": results[:, 0].std(), + "dur_ref": int(results[:, 1].sum()), + "dur_syn": int(results[:, 2].sum()), + } + print(tabulate([res.values()], res.keys(), floatfmt=".4f")) + + print(">>>> ALL") + _print_result(results) + + if show_bin: + edges = [0, 200, 400, 600, 800, 1000, 2000, 4000] + for i in range(1, len(edges)): + mask = np.logical_and(results[:, 1] >= edges[i-1], + results[:, 1] < edges[i]) + if not mask.any(): + continue + bin_results = results[mask] + print(f">>>> ({edges[i-1]}, {edges[i]})") + _print_result(bin_results) + + +def main(eval_f0, gpe, vde, ffe, show_bin): + samples = load_eval_spec(eval_f0) + if gpe or vde or ffe: + f0_samples = extract_f0(samples) + + if gpe: + print("===== Evaluate Gross Pitch Error =====") + results = eval_gross_pitch_error(f0_samples) + print_results(results, show_bin) + if vde: + print("===== Evaluate Voicing Decision Error =====") + results = eval_voicing_decision_error(f0_samples) + print_results(results, show_bin) + if ffe: + print("===== Evaluate F0 Frame Error =====") + results = eval_f0_frame_error(f0_samples) + print_results(results, show_bin) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("eval_f0") + parser.add_argument("--gpe", action="store_true") + parser.add_argument("--vde", action="store_true") + parser.add_argument("--ffe", action="store_true") + parser.add_argument("--show-bin", action="store_true") + args = parser.parse_args() + + main(args.eval_f0, args.gpe, args.vde, args.ffe, args.show_bin) diff --git a/fairseq/examples/speech_synthesis/evaluation/eval_sp.py b/fairseq/examples/speech_synthesis/evaluation/eval_sp.py new file mode 100644 index 0000000000000000000000000000000000000000..702c4980389624f788abc0b42cdf54757a52512f --- /dev/null +++ b/fairseq/examples/speech_synthesis/evaluation/eval_sp.py @@ -0,0 +1,131 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +""" +Signal processing-based evaluation using waveforms +""" + +import csv +import numpy as np +import os.path as op + +import torch +import tqdm +from tabulate import tabulate +import torchaudio + +from examples.speech_synthesis.utils import batch_mel_spectral_distortion +from fairseq.tasks.text_to_speech import batch_mel_cepstral_distortion + + +def load_eval_spec(path): + with open(path) as f: + reader = csv.DictReader(f, delimiter='\t') + samples = list(reader) + return samples + + +def eval_distortion(samples, distortion_fn, device="cuda"): + nmiss = 0 + results = [] + for sample in tqdm.tqdm(samples): + if not op.isfile(sample["ref"]) or not op.isfile(sample["syn"]): + nmiss += 1 + results.append(None) + continue + # assume single channel + yref, sr = torchaudio.load(sample["ref"]) + ysyn, _sr = torchaudio.load(sample["syn"]) + yref, ysyn = yref[0].to(device), ysyn[0].to(device) + assert sr == _sr, f"{sr} != {_sr}" + + distortion, extra = distortion_fn([yref], [ysyn], sr, None)[0] + _, _, _, _, _, pathmap = extra + nins = torch.sum(pathmap.sum(dim=1) - 1) # extra frames in syn + ndel = torch.sum(pathmap.sum(dim=0) - 1) # missing frames from syn + results.append( + (distortion.item(), # path distortion + pathmap.size(0), # yref num frames + pathmap.size(1), # ysyn num frames + pathmap.sum().item(), # path length + nins.item(), # insertion + ndel.item(), # deletion + ) + ) + return results + + +def eval_mel_cepstral_distortion(samples, device="cuda"): + return eval_distortion(samples, batch_mel_cepstral_distortion, device) + + +def eval_mel_spectral_distortion(samples, device="cuda"): + return eval_distortion(samples, batch_mel_spectral_distortion, device) + + +def print_results(results, show_bin): + results = np.array(list(filter(lambda x: x is not None, results))) + + np.set_printoptions(precision=3) + + def _print_result(results): + dist, dur_ref, dur_syn, dur_ali, nins, ndel = results.sum(axis=0) + res = { + "nutt": len(results), + "dist": dist, + "dur_ref": int(dur_ref), + "dur_syn": int(dur_syn), + "dur_ali": int(dur_ali), + "dist_per_ref_frm": dist/dur_ref, + "dist_per_syn_frm": dist/dur_syn, + "dist_per_ali_frm": dist/dur_ali, + "ins": nins/dur_ref, + "del": ndel/dur_ref, + } + print(tabulate( + [res.values()], + res.keys(), + floatfmt=".4f" + )) + + print(">>>> ALL") + _print_result(results) + + if show_bin: + edges = [0, 200, 400, 600, 800, 1000, 2000, 4000] + for i in range(1, len(edges)): + mask = np.logical_and(results[:, 1] >= edges[i-1], + results[:, 1] < edges[i]) + if not mask.any(): + continue + bin_results = results[mask] + print(f">>>> ({edges[i-1]}, {edges[i]})") + _print_result(bin_results) + + +def main(eval_spec, mcd, msd, show_bin): + samples = load_eval_spec(eval_spec) + device = "cpu" + if mcd: + print("===== Evaluate Mean Cepstral Distortion =====") + results = eval_mel_cepstral_distortion(samples, device) + print_results(results, show_bin) + if msd: + print("===== Evaluate Mean Spectral Distortion =====") + results = eval_mel_spectral_distortion(samples, device) + print_results(results, show_bin) + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("eval_spec") + parser.add_argument("--mcd", action="store_true") + parser.add_argument("--msd", action="store_true") + parser.add_argument("--show-bin", action="store_true") + args = parser.parse_args() + + main(args.eval_spec, args.mcd, args.msd, args.show_bin) diff --git a/fairseq/examples/speech_synthesis/evaluation/get_eval_manifest.py b/fairseq/examples/speech_synthesis/evaluation/get_eval_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..a28cd607a096844438f6a3ba6b007d94d67d1bc8 --- /dev/null +++ b/fairseq/examples/speech_synthesis/evaluation/get_eval_manifest.py @@ -0,0 +1,58 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import csv +from pathlib import Path + + +def main(args): + """ + `uid syn ref text` + """ + in_root = Path(args.generation_root).resolve() + ext = args.audio_format + with open(args.audio_manifest) as f, open(args.output_path, "w") as f_out: + reader = csv.DictReader( + f, delimiter="\t", quotechar=None, doublequote=False, + lineterminator="\n", quoting=csv.QUOTE_NONE + ) + header = ["id", "syn", "ref", "text", "speaker"] + f_out.write("\t".join(header) + "\n") + for row in reader: + dir_name = f"{ext}_{args.sample_rate}hz_{args.vocoder}" + id_ = row["id"] + syn = (in_root / dir_name / f"{id_}.{ext}").as_posix() + ref = row["audio"] + if args.use_resynthesized_target: + ref = (in_root / f"{dir_name}_tgt" / f"{id_}.{ext}").as_posix() + sample = [id_, syn, ref, row["tgt_text"], row["speaker"]] + f_out.write("\t".join(sample) + "\n") + print(f"wrote evaluation file to {args.output_path}") + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument( + "--generation-root", help="output directory for generate_waveform.py" + ) + parser.add_argument( + "--audio-manifest", + help="used to determine the original utterance ID and text" + ) + parser.add_argument( + "--output-path", help="path to output evaluation spec file" + ) + parser.add_argument( + "--use-resynthesized-target", action="store_true", + help="use resynthesized reference instead of the original audio" + ) + parser.add_argument("--vocoder", type=str, default="griffin_lim") + parser.add_argument("--sample-rate", type=int, default=22_050) + parser.add_argument("--audio-format", type=str, default="wav") + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/speech_synthesis/generate_waveform.py b/fairseq/examples/speech_synthesis/generate_waveform.py new file mode 100644 index 0000000000000000000000000000000000000000..bfc2ef8eb3d91366caf7609d75aa1795ab0ed8f9 --- /dev/null +++ b/fairseq/examples/speech_synthesis/generate_waveform.py @@ -0,0 +1,191 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import logging +import matplotlib.pyplot as plt +import numpy as np +from pathlib import Path +import soundfile as sf +import sys +import torch +import torchaudio + +from fairseq import checkpoint_utils, options, tasks, utils +from fairseq.logging import progress_bar +from fairseq.tasks.text_to_speech import plot_tts_output +from fairseq.data.audio.text_to_speech_dataset import TextToSpeechDataset + + +logging.basicConfig() +logging.root.setLevel(logging.INFO) +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +def make_parser(): + parser = options.get_speech_generation_parser() + parser.add_argument("--dump-features", action="store_true") + parser.add_argument("--dump-waveforms", action="store_true") + parser.add_argument("--dump-attentions", action="store_true") + parser.add_argument("--dump-eos-probs", action="store_true") + parser.add_argument("--dump-plots", action="store_true") + parser.add_argument("--dump-target", action="store_true") + parser.add_argument("--output-sample-rate", default=22050, type=int) + parser.add_argument("--teacher-forcing", action="store_true") + parser.add_argument( + "--audio-format", type=str, default="wav", choices=["wav", "flac"] + ) + return parser + + +def postprocess_results( + dataset: TextToSpeechDataset, sample, hypos, resample_fn, dump_target +): + def to_np(x): + return None if x is None else x.detach().cpu().numpy() + + sample_ids = [dataset.ids[i] for i in sample["id"].tolist()] + texts = sample["src_texts"] + attns = [to_np(hypo["attn"]) for hypo in hypos] + eos_probs = [to_np(hypo.get("eos_prob", None)) for hypo in hypos] + feat_preds = [to_np(hypo["feature"]) for hypo in hypos] + wave_preds = [to_np(resample_fn(h["waveform"])) for h in hypos] + if dump_target: + feat_targs = [to_np(hypo["targ_feature"]) for hypo in hypos] + wave_targs = [to_np(resample_fn(h["targ_waveform"])) for h in hypos] + else: + feat_targs = [None for _ in hypos] + wave_targs = [None for _ in hypos] + + return zip(sample_ids, texts, attns, eos_probs, feat_preds, wave_preds, + feat_targs, wave_targs) + + +def dump_result( + is_na_model, + args, + vocoder, + sample_id, + text, + attn, + eos_prob, + feat_pred, + wave_pred, + feat_targ, + wave_targ, +): + sample_rate = args.output_sample_rate + out_root = Path(args.results_path) + if args.dump_features: + feat_dir = out_root / "feat" + feat_dir.mkdir(exist_ok=True, parents=True) + np.save(feat_dir / f"{sample_id}.npy", feat_pred) + if args.dump_target: + feat_tgt_dir = out_root / "feat_tgt" + feat_tgt_dir.mkdir(exist_ok=True, parents=True) + np.save(feat_tgt_dir / f"{sample_id}.npy", feat_targ) + if args.dump_attentions: + attn_dir = out_root / "attn" + attn_dir.mkdir(exist_ok=True, parents=True) + np.save(attn_dir / f"{sample_id}.npy", attn.numpy()) + if args.dump_eos_probs and not is_na_model: + eos_dir = out_root / "eos" + eos_dir.mkdir(exist_ok=True, parents=True) + np.save(eos_dir / f"{sample_id}.npy", eos_prob) + + if args.dump_plots: + images = [feat_pred.T] if is_na_model else [feat_pred.T, attn] + names = ["output"] if is_na_model else ["output", "alignment"] + if feat_targ is not None: + images = [feat_targ.T] + images + names = [f"target (idx={sample_id})"] + names + if is_na_model: + plot_tts_output(images, names, attn, "alignment", suptitle=text) + else: + plot_tts_output(images, names, eos_prob, "eos prob", suptitle=text) + plot_dir = out_root / "plot" + plot_dir.mkdir(exist_ok=True, parents=True) + plt.savefig(plot_dir / f"{sample_id}.png") + plt.close() + + if args.dump_waveforms: + ext = args.audio_format + if wave_pred is not None: + wav_dir = out_root / f"{ext}_{sample_rate}hz_{vocoder}" + wav_dir.mkdir(exist_ok=True, parents=True) + sf.write(wav_dir / f"{sample_id}.{ext}", wave_pred, sample_rate) + if args.dump_target and wave_targ is not None: + wav_tgt_dir = out_root / f"{ext}_{sample_rate}hz_{vocoder}_tgt" + wav_tgt_dir.mkdir(exist_ok=True, parents=True) + sf.write(wav_tgt_dir / f"{sample_id}.{ext}", wave_targ, sample_rate) + + +def main(args): + assert(args.dump_features or args.dump_waveforms or args.dump_attentions + or args.dump_eos_probs or args.dump_plots) + if args.max_tokens is None and args.batch_size is None: + args.max_tokens = 8000 + logger.info(args) + + use_cuda = torch.cuda.is_available() and not args.cpu + task = tasks.setup_task(args) + models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task( + [args.path], + task=task, + ) + model = models[0].cuda() if use_cuda else models[0] + # use the original n_frames_per_step + task.args.n_frames_per_step = saved_cfg.task.n_frames_per_step + task.load_dataset(args.gen_subset, task_cfg=saved_cfg.task) + + data_cfg = task.data_cfg + sample_rate = data_cfg.config.get("features", {}).get("sample_rate", 22050) + resample_fn = { + False: lambda x: x, + True: lambda x: torchaudio.sox_effects.apply_effects_tensor( + x.detach().cpu().unsqueeze(0), sample_rate, + [['rate', str(args.output_sample_rate)]] + )[0].squeeze(0) + }.get(args.output_sample_rate != sample_rate) + if args.output_sample_rate != sample_rate: + logger.info(f"resampling to {args.output_sample_rate}Hz") + + generator = task.build_generator([model], args) + itr = task.get_batch_iterator( + dataset=task.dataset(args.gen_subset), + max_tokens=args.max_tokens, + max_sentences=args.batch_size, + max_positions=(sys.maxsize, sys.maxsize), + ignore_invalid_inputs=args.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=args.required_batch_size_multiple, + num_shards=args.num_shards, + shard_id=args.shard_id, + num_workers=args.num_workers, + data_buffer_size=args.data_buffer_size, + ).next_epoch_itr(shuffle=False) + + Path(args.results_path).mkdir(exist_ok=True, parents=True) + is_na_model = getattr(model, "NON_AUTOREGRESSIVE", False) + dataset = task.dataset(args.gen_subset) + vocoder = task.args.vocoder + with progress_bar.build_progress_bar(args, itr) as t: + for sample in t: + sample = utils.move_to_cuda(sample) if use_cuda else sample + hypos = generator.generate(model, sample, has_targ=args.dump_target) + for result in postprocess_results( + dataset, sample, hypos, resample_fn, args.dump_target + ): + dump_result(is_na_model, args, vocoder, *result) + + +def cli_main(): + parser = make_parser() + args = options.parse_args_and_arch(parser) + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/__init__.py b/fairseq/examples/speech_synthesis/preprocessing/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py b/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py new file mode 100644 index 0000000000000000000000000000000000000000..4e13b38a5d3fb44dd3969e6afcb8f202274ee3b7 --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoise_and_vad_audio.py @@ -0,0 +1,204 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +import csv +import tempfile +from collections import defaultdict +from pathlib import Path + +import torchaudio +try: + import webrtcvad +except ImportError: + raise ImportError("Please install py-webrtcvad: pip install webrtcvad") +import pandas as pd +from tqdm import tqdm + +from examples.speech_synthesis.preprocessing.denoiser.pretrained import master64 +import examples.speech_synthesis.preprocessing.denoiser.utils as utils +from examples.speech_synthesis.preprocessing.vad import ( + frame_generator, vad_collector, read_wave, write_wave, FS_MS, THRESHOLD, + SCALE +) +from examples.speech_to_text.data_utils import save_df_to_tsv + + +log = logging.getLogger(__name__) + +PATHS = ["after_denoise", "after_vad"] +MIN_T = 0.05 + + +def generate_tmp_filename(extension="txt"): + return tempfile._get_default_tempdir() + "/" + \ + next(tempfile._get_candidate_names()) + "." + extension + + +def convert_sr(inpath, sr, output_path=None): + if not output_path: + output_path = generate_tmp_filename("wav") + cmd = f"sox {inpath} -r {sr} {output_path}" + os.system(cmd) + return output_path + + +def apply_vad(vad, inpath): + audio, sample_rate = read_wave(inpath) + frames = frame_generator(FS_MS, audio, sample_rate) + frames = list(frames) + segments = vad_collector(sample_rate, FS_MS, 300, vad, frames) + merge_segments = list() + timestamp_start = 0.0 + timestamp_end = 0.0 + # removing start, end, and long sequences of sils + for i, segment in enumerate(segments): + merge_segments.append(segment[0]) + if i and timestamp_start: + sil_duration = segment[1] - timestamp_end + if sil_duration > THRESHOLD: + merge_segments.append(int(THRESHOLD / SCALE) * (b'\x00')) + else: + merge_segments.append(int((sil_duration / SCALE)) * (b'\x00')) + timestamp_start = segment[1] + timestamp_end = segment[2] + segment = b''.join(merge_segments) + return segment, sample_rate + + +def write(wav, filename, sr=16_000): + # Normalize audio if it prevents clipping + wav = wav / max(wav.abs().max().item(), 1) + torchaudio.save(filename, wav.cpu(), sr, encoding="PCM_S", + bits_per_sample=16) + + +def process(args): + # making sure we are requested either denoise or vad + if not args.denoise and not args.vad: + log.error("No denoise or vad is requested.") + return + + log.info("Creating out directories...") + if args.denoise: + out_denoise = Path(args.output_dir).absolute().joinpath(PATHS[0]) + out_denoise.mkdir(parents=True, exist_ok=True) + if args.vad: + out_vad = Path(args.output_dir).absolute().joinpath(PATHS[1]) + out_vad.mkdir(parents=True, exist_ok=True) + + log.info("Loading pre-trained speech enhancement model...") + model = master64().to(args.device) + + log.info("Building the VAD model...") + vad = webrtcvad.Vad(int(args.vad_agg_level)) + + # preparing the output dict + output_dict = defaultdict(list) + + log.info(f"Parsing input manifest: {args.audio_manifest}") + with open(args.audio_manifest, "r") as f: + manifest_dict = csv.DictReader(f, delimiter="\t") + for row in tqdm(manifest_dict): + filename = str(row["audio"]) + + final_output = filename + keep_sample = True + n_frames = row["n_frames"] + snr = -1 + if args.denoise: + output_path_denoise = out_denoise.joinpath(Path(filename).name) + # convert to 16khz in case we use a differet sr + tmp_path = convert_sr(final_output, 16000) + + # loading audio file and generating the enhanced version + out, sr = torchaudio.load(tmp_path) + out = out.to(args.device) + estimate = model(out) + estimate = (1 - args.dry_wet) * estimate + args.dry_wet * out + write(estimate[0], str(output_path_denoise), sr) + + snr = utils.cal_snr(out, estimate) + snr = snr.cpu().detach().numpy()[0][0] + final_output = str(output_path_denoise) + + if args.vad: + output_path_vad = out_vad.joinpath(Path(filename).name) + sr = torchaudio.info(final_output).sample_rate + if sr in [16000, 32000, 48000]: + tmp_path = final_output + elif sr < 16000: + tmp_path = convert_sr(final_output, 16000) + elif sr < 32000: + tmp_path = convert_sr(final_output, 32000) + else: + tmp_path = convert_sr(final_output, 48000) + # apply VAD + segment, sample_rate = apply_vad(vad, tmp_path) + if len(segment) < sample_rate * MIN_T: + keep_sample = False + print(( + f"WARNING: skip {filename} because it is too short " + f"after VAD ({len(segment) / sample_rate} < {MIN_T})" + )) + else: + if sample_rate != sr: + tmp_path = generate_tmp_filename("wav") + write_wave(tmp_path, segment, sample_rate) + convert_sr(tmp_path, sr, + output_path=str(output_path_vad)) + else: + write_wave(str(output_path_vad), segment, sample_rate) + final_output = str(output_path_vad) + segment, _ = torchaudio.load(final_output) + n_frames = segment.size(1) + + if keep_sample: + output_dict["id"].append(row["id"]) + output_dict["audio"].append(final_output) + output_dict["n_frames"].append(n_frames) + output_dict["tgt_text"].append(row["tgt_text"]) + output_dict["speaker"].append(row["speaker"]) + output_dict["src_text"].append(row["src_text"]) + output_dict["snr"].append(snr) + + out_tsv_path = Path(args.output_dir) / Path(args.audio_manifest).name + log.info(f"Saving manifest to {out_tsv_path.as_posix()}") + save_df_to_tsv(pd.DataFrame.from_dict(output_dict), out_tsv_path) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--audio-manifest", "-i", required=True, + type=str, help="path to the input manifest.") + parser.add_argument( + "--output-dir", "-o", required=True, type=str, + help="path to the output dir. it will contain files after denoising and" + " vad" + ) + parser.add_argument("--vad-agg-level", "-a", type=int, default=2, + help="the aggresive level of the vad [0-3].") + parser.add_argument( + "--dry-wet", "-dw", type=float, default=0.01, + help="the level of linear interpolation between noisy and enhanced " + "files." + ) + parser.add_argument( + "--device", "-d", type=str, default="cpu", + help="the device to be used for the speech enhancement model: " + "cpu | cuda." + ) + parser.add_argument("--denoise", action="store_true", + help="apply a denoising") + parser.add_argument("--vad", action="store_true", help="apply a VAD") + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoiser/__init__.py b/fairseq/examples/speech_synthesis/preprocessing/denoiser/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoiser/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoiser/demucs.py b/fairseq/examples/speech_synthesis/preprocessing/denoiser/demucs.py new file mode 100644 index 0000000000000000000000000000000000000000..3f70e73d6a37d32e05b6cf0e87f42e13c467cd52 --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoiser/demucs.py @@ -0,0 +1,473 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# author: adefossez + +import math +import time + +import torch as th +from torch import nn +from torch.nn import functional as F + +from .resample import downsample2, upsample2 +from .utils import capture_init + + +class BLSTM(nn.Module): + def __init__(self, dim, layers=2, bi=True): + super().__init__() + klass = nn.LSTM + self.lstm = klass( + bidirectional=bi, num_layers=layers, hidden_size=dim, input_size=dim + ) + self.linear = None + if bi: + self.linear = nn.Linear(2 * dim, dim) + + def forward(self, x, hidden=None): + x, hidden = self.lstm(x, hidden) + if self.linear: + x = self.linear(x) + return x, hidden + + +def rescale_conv(conv, reference): + std = conv.weight.std().detach() + scale = (std / reference)**0.5 + conv.weight.data /= scale + if conv.bias is not None: + conv.bias.data /= scale + + +def rescale_module(module, reference): + for sub in module.modules(): + if isinstance(sub, (nn.Conv1d, nn.ConvTranspose1d)): + rescale_conv(sub, reference) + + +class Demucs(nn.Module): + """ + Demucs speech enhancement model. + Args: + - chin (int): number of input channels. + - chout (int): number of output channels. + - hidden (int): number of initial hidden channels. + - depth (int): number of layers. + - kernel_size (int): kernel size for each layer. + - stride (int): stride for each layer. + - causal (bool): if false, uses BiLSTM instead of LSTM. + - resample (int): amount of resampling to apply to the input/output. + Can be one of 1, 2 or 4. + - growth (float): number of channels is multiplied by this for every layer. + - max_hidden (int): maximum number of channels. Can be useful to + control the size/speed of the model. + - normalize (bool): if true, normalize the input. + - glu (bool): if true uses GLU instead of ReLU in 1x1 convolutions. + - rescale (float): controls custom weight initialization. + See https://arxiv.org/abs/1911.13254. + - floor (float): stability flooring when normalizing. + + """ + @capture_init + def __init__(self, + chin=1, + chout=1, + hidden=48, + depth=5, + kernel_size=8, + stride=4, + causal=True, + resample=4, + growth=2, + max_hidden=10_000, + normalize=True, + glu=True, + rescale=0.1, + floor=1e-3): + + super().__init__() + if resample not in [1, 2, 4]: + raise ValueError("Resample should be 1, 2 or 4.") + + self.chin = chin + self.chout = chout + self.hidden = hidden + self.depth = depth + self.kernel_size = kernel_size + self.stride = stride + self.causal = causal + self.floor = floor + self.resample = resample + self.normalize = normalize + + self.encoder = nn.ModuleList() + self.decoder = nn.ModuleList() + activation = nn.GLU(1) if glu else nn.ReLU() + ch_scale = 2 if glu else 1 + + for index in range(depth): + encode = [] + encode += [ + nn.Conv1d(chin, hidden, kernel_size, stride), + nn.ReLU(), + nn.Conv1d(hidden, hidden * ch_scale, 1), activation, + ] + self.encoder.append(nn.Sequential(*encode)) + + decode = [] + decode += [ + nn.Conv1d(hidden, ch_scale * hidden, 1), activation, + nn.ConvTranspose1d(hidden, chout, kernel_size, stride), + ] + if index > 0: + decode.append(nn.ReLU()) + self.decoder.insert(0, nn.Sequential(*decode)) + chout = hidden + chin = hidden + hidden = min(int(growth * hidden), max_hidden) + + self.lstm = BLSTM(chin, bi=not causal) + if rescale: + rescale_module(self, reference=rescale) + + def valid_length(self, length): + """ + Return the nearest valid length to use with the model so that + there is no time steps left over in a convolutions, e.g. for all + layers, size of the input - kernel_size % stride = 0. + + If the mixture has a valid length, the estimated sources + will have exactly the same length. + """ + length = math.ceil(length * self.resample) + for _ in range(self.depth): + length = math.ceil((length - self.kernel_size) / self.stride) + 1 + length = max(length, 1) + for _ in range(self.depth): + length = (length - 1) * self.stride + self.kernel_size + length = int(math.ceil(length / self.resample)) + return int(length) + + @property + def total_stride(self): + return self.stride ** self.depth // self.resample + + def forward(self, mix): + if mix.dim() == 2: + mix = mix.unsqueeze(1) + + if self.normalize: + mono = mix.mean(dim=1, keepdim=True) + std = mono.std(dim=-1, keepdim=True) + mix = mix / (self.floor + std) + else: + std = 1 + length = mix.shape[-1] + x = mix + x = F.pad(x, (0, self.valid_length(length) - length)) + if self.resample == 2: + x = upsample2(x) + elif self.resample == 4: + x = upsample2(x) + x = upsample2(x) + skips = [] + for encode in self.encoder: + x = encode(x) + skips.append(x) + x = x.permute(2, 0, 1) + x, _ = self.lstm(x) + x = x.permute(1, 2, 0) + for decode in self.decoder: + skip = skips.pop(-1) + x = x + skip[..., :x.shape[-1]] + x = decode(x) + if self.resample == 2: + x = downsample2(x) + elif self.resample == 4: + x = downsample2(x) + x = downsample2(x) + + x = x[..., :length] + return std * x + + +def fast_conv(conv, x): + """ + Faster convolution evaluation if either kernel size is 1 + or length of sequence is 1. + """ + batch, chin, length = x.shape + chout, chin, kernel = conv.weight.shape + assert batch == 1 + if kernel == 1: + x = x.view(chin, length) + out = th.addmm(conv.bias.view(-1, 1), + conv.weight.view(chout, chin), x) + elif length == kernel: + x = x.view(chin * kernel, 1) + out = th.addmm(conv.bias.view(-1, 1), + conv.weight.view(chout, chin * kernel), x) + else: + out = conv(x) + return out.view(batch, chout, -1) + + +class DemucsStreamer: + """ + Streaming implementation for Demucs. It supports being fed with any amount + of audio at a time. You will get back as much audio as possible at that + point. + + Args: + - demucs (Demucs): Demucs model. + - dry (float): amount of dry (e.g. input) signal to keep. 0 is maximum + noise removal, 1 just returns the input signal. Small values > 0 + allows to limit distortions. + - num_frames (int): number of frames to process at once. Higher values + will increase overall latency but improve the real time factor. + - resample_lookahead (int): extra lookahead used for the resampling. + - resample_buffer (int): size of the buffer of previous inputs/outputs + kept for resampling. + """ + def __init__(self, demucs, + dry=0, + num_frames=1, + resample_lookahead=64, + resample_buffer=256): + device = next(iter(demucs.parameters())).device + self.demucs = demucs + self.lstm_state = None + self.conv_state = None + self.dry = dry + self.resample_lookahead = resample_lookahead + resample_buffer = min(demucs.total_stride, resample_buffer) + self.resample_buffer = resample_buffer + self.frame_length = demucs.valid_length(1) + \ + demucs.total_stride * (num_frames - 1) + self.total_length = self.frame_length + self.resample_lookahead + self.stride = demucs.total_stride * num_frames + self.resample_in = th.zeros(demucs.chin, resample_buffer, device=device) + self.resample_out = th.zeros( + demucs.chin, resample_buffer, device=device + ) + + self.frames = 0 + self.total_time = 0 + self.variance = 0 + self.pending = th.zeros(demucs.chin, 0, device=device) + + bias = demucs.decoder[0][2].bias + weight = demucs.decoder[0][2].weight + chin, chout, kernel = weight.shape + self._bias = bias.view(-1, 1).repeat(1, kernel).view(-1, 1) + self._weight = weight.permute(1, 2, 0).contiguous() + + def reset_time_per_frame(self): + self.total_time = 0 + self.frames = 0 + + @property + def time_per_frame(self): + return self.total_time / self.frames + + def flush(self): + """ + Flush remaining audio by padding it with zero. Call this + when you have no more input and want to get back the last chunk of audio. + """ + pending_length = self.pending.shape[1] + padding = th.zeros( + self.demucs.chin, self.total_length, device=self.pending.device + ) + out = self.feed(padding) + return out[:, :pending_length] + + def feed(self, wav): + """ + Apply the model to mix using true real time evaluation. + Normalization is done online as is the resampling. + """ + begin = time.time() + demucs = self.demucs + resample_buffer = self.resample_buffer + stride = self.stride + resample = demucs.resample + + if wav.dim() != 2: + raise ValueError("input wav should be two dimensional.") + chin, _ = wav.shape + if chin != demucs.chin: + raise ValueError(f"Expected {demucs.chin} channels, got {chin}") + + self.pending = th.cat([self.pending, wav], dim=1) + outs = [] + while self.pending.shape[1] >= self.total_length: + self.frames += 1 + frame = self.pending[:, :self.total_length] + dry_signal = frame[:, :stride] + if demucs.normalize: + mono = frame.mean(0) + variance = (mono**2).mean() + self.variance = variance / self.frames + \ + (1 - 1 / self.frames) * self.variance + frame = frame / (demucs.floor + math.sqrt(self.variance)) + frame = th.cat([self.resample_in, frame], dim=-1) + self.resample_in[:] = frame[:, stride - resample_buffer:stride] + + if resample == 4: + frame = upsample2(upsample2(frame)) + elif resample == 2: + frame = upsample2(frame) + # remove pre sampling buffer + frame = frame[:, resample * resample_buffer:] + # remove extra samples after window + frame = frame[:, :resample * self.frame_length] + + out, extra = self._separate_frame(frame) + padded_out = th.cat([self.resample_out, out, extra], 1) + self.resample_out[:] = out[:, -resample_buffer:] + if resample == 4: + out = downsample2(downsample2(padded_out)) + elif resample == 2: + out = downsample2(padded_out) + else: + out = padded_out + + out = out[:, resample_buffer // resample:] + out = out[:, :stride] + + if demucs.normalize: + out *= math.sqrt(self.variance) + out = self.dry * dry_signal + (1 - self.dry) * out + outs.append(out) + self.pending = self.pending[:, stride:] + + self.total_time += time.time() - begin + if outs: + out = th.cat(outs, 1) + else: + out = th.zeros(chin, 0, device=wav.device) + return out + + def _separate_frame(self, frame): + demucs = self.demucs + skips = [] + next_state = [] + first = self.conv_state is None + stride = self.stride * demucs.resample + x = frame[None] + for idx, encode in enumerate(demucs.encoder): + stride //= demucs.stride + length = x.shape[2] + if idx == demucs.depth - 1: + # This is sligthly faster for the last conv + x = fast_conv(encode[0], x) + x = encode[1](x) + x = fast_conv(encode[2], x) + x = encode[3](x) + else: + if not first: + prev = self.conv_state.pop(0) + prev = prev[..., stride:] + tgt = (length - demucs.kernel_size) // demucs.stride + 1 + missing = tgt - prev.shape[-1] + offset = length - demucs.kernel_size - \ + demucs.stride * (missing - 1) + x = x[..., offset:] + x = encode[1](encode[0](x)) + x = fast_conv(encode[2], x) + x = encode[3](x) + if not first: + x = th.cat([prev, x], -1) + next_state.append(x) + skips.append(x) + + x = x.permute(2, 0, 1) + x, self.lstm_state = demucs.lstm(x, self.lstm_state) + x = x.permute(1, 2, 0) + # In the following, x contains only correct samples, i.e. the one + # for which each time position is covered by two window of the upper + # layer. extra contains extra samples to the right, and is used only as + # a better padding for the online resampling. + extra = None + for idx, decode in enumerate(demucs.decoder): + skip = skips.pop(-1) + x += skip[..., :x.shape[-1]] + x = fast_conv(decode[0], x) + x = decode[1](x) + + if extra is not None: + skip = skip[..., x.shape[-1]:] + extra += skip[..., :extra.shape[-1]] + extra = decode[2](decode[1](decode[0](extra))) + x = decode[2](x) + next_state.append( + x[..., -demucs.stride:] - decode[2].bias.view(-1, 1) + ) + if extra is None: + extra = x[..., -demucs.stride:] + else: + extra[..., :demucs.stride] += next_state[-1] + x = x[..., :-demucs.stride] + + if not first: + prev = self.conv_state.pop(0) + x[..., :demucs.stride] += prev + if idx != demucs.depth - 1: + x = decode[3](x) + extra = decode[3](extra) + self.conv_state = next_state + return x[0], extra[0] + + +def test(): + import argparse + parser = argparse.ArgumentParser( + "denoiser.demucs", + description="Benchmark the streaming Demucs implementation, as well as " + "checking the delta with the offline implementation.") + parser.add_argument("--depth", default=5, type=int) + parser.add_argument("--resample", default=4, type=int) + parser.add_argument("--hidden", default=48, type=int) + parser.add_argument("--sample_rate", default=16000, type=float) + parser.add_argument("--device", default="cpu") + parser.add_argument("-t", "--num_threads", type=int) + parser.add_argument("-f", "--num_frames", type=int, default=1) + args = parser.parse_args() + if args.num_threads: + th.set_num_threads(args.num_threads) + sr = args.sample_rate + sr_ms = sr / 1000 + demucs = Demucs( + depth=args.depth, hidden=args.hidden, resample=args.resample + ).to(args.device) + x = th.randn(1, int(sr * 4)).to(args.device) + out = demucs(x[None])[0] + streamer = DemucsStreamer(demucs, num_frames=args.num_frames) + out_rt = [] + frame_size = streamer.total_length + with th.no_grad(): + while x.shape[1] > 0: + out_rt.append(streamer.feed(x[:, :frame_size])) + x = x[:, frame_size:] + frame_size = streamer.demucs.total_stride + out_rt.append(streamer.flush()) + out_rt = th.cat(out_rt, 1) + model_size = sum(p.numel() for p in demucs.parameters()) * 4 / 2**20 + initial_lag = streamer.total_length / sr_ms + tpf = 1000 * streamer.time_per_frame + print(f"model size: {model_size:.1f}MB, ", end='') + print(f"delta batch/streaming: {th.norm(out - out_rt) / th.norm(out):.2%}") + print(f"initial lag: {initial_lag:.1f}ms, ", end='') + print(f"stride: {streamer.stride * args.num_frames / sr_ms:.1f}ms") + print(f"time per frame: {tpf:.1f}ms, ", end='') + rtf = (1000 * streamer.time_per_frame) / (streamer.stride / sr_ms) + print(f"RTF: {rtf:.2f}") + print(f"Total lag with computation: {initial_lag + tpf:.1f}ms") + + +if __name__ == "__main__": + test() diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoiser/pretrained.py b/fairseq/examples/speech_synthesis/preprocessing/denoiser/pretrained.py new file mode 100644 index 0000000000000000000000000000000000000000..2fa846075b6872cdcc0baebca0b9acbb9ffcd287 --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoiser/pretrained.py @@ -0,0 +1,81 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# author: adefossez + +import logging + +import torch.hub + +from .demucs import Demucs +from .utils import deserialize_model + +logger = logging.getLogger(__name__) +ROOT = "https://dl.fbaipublicfiles.com/adiyoss/denoiser/" +DNS_48_URL = ROOT + "dns48-11decc9d8e3f0998.th" +DNS_64_URL = ROOT + "dns64-a7761ff99a7d5bb6.th" +MASTER_64_URL = ROOT + "master64-8a5dfb4bb92753dd.th" + + +def _demucs(pretrained, url, **kwargs): + model = Demucs(**kwargs) + if pretrained: + state_dict = torch.hub.load_state_dict_from_url(url, map_location='cpu') + model.load_state_dict(state_dict) + return model + + +def dns48(pretrained=True): + return _demucs(pretrained, DNS_48_URL, hidden=48) + + +def dns64(pretrained=True): + return _demucs(pretrained, DNS_64_URL, hidden=64) + + +def master64(pretrained=True): + return _demucs(pretrained, MASTER_64_URL, hidden=64) + + +def add_model_flags(parser): + group = parser.add_mutually_exclusive_group(required=False) + group.add_argument( + "-m", "--model_path", help="Path to local trained model." + ) + group.add_argument( + "--dns48", action="store_true", + help="Use pre-trained real time H=48 model trained on DNS." + ) + group.add_argument( + "--dns64", action="store_true", + help="Use pre-trained real time H=64 model trained on DNS." + ) + group.add_argument( + "--master64", action="store_true", + help="Use pre-trained real time H=64 model trained on DNS and Valentini." + ) + + +def get_model(args): + """ + Load local model package or torchhub pre-trained model. + """ + if args.model_path: + logger.info("Loading model from %s", args.model_path) + pkg = torch.load(args.model_path) + model = deserialize_model(pkg) + elif args.dns64: + logger.info("Loading pre-trained real time H=64 model trained on DNS.") + model = dns64() + elif args.master64: + logger.info( + "Loading pre-trained real time H=64 model trained on DNS and Valentini." + ) + model = master64() + else: + logger.info("Loading pre-trained real time H=48 model trained on DNS.") + model = dns48() + logger.debug(model) + return model diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoiser/resample.py b/fairseq/examples/speech_synthesis/preprocessing/denoiser/resample.py new file mode 100644 index 0000000000000000000000000000000000000000..1222addc424d4f898d602009e4032907241aadfe --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoiser/resample.py @@ -0,0 +1,79 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# author: adefossez + +import math + +import torch as th +from torch.nn import functional as F + + +def sinc(t): + """sinc. + + :param t: the input tensor + """ + return th.where(t == 0, th.tensor(1., device=t.device, dtype=t.dtype), + th.sin(t) / t) + + +def kernel_upsample2(zeros=56): + """kernel_upsample2. + + """ + win = th.hann_window(4 * zeros + 1, periodic=False) + winodd = win[1::2] + t = th.linspace(-zeros + 0.5, zeros - 0.5, 2 * zeros) + t *= math.pi + kernel = (sinc(t) * winodd).view(1, 1, -1) + return kernel + + +def upsample2(x, zeros=56): + """ + Upsampling the input by 2 using sinc interpolation. + Smith, Julius, and Phil Gossett. "A flexible sampling-rate conversion method." + ICASSP'84. IEEE International Conference on Acoustics, Speech, and Signal Processing. + Vol. 9. IEEE, 1984. + """ + *other, time = x.shape + kernel = kernel_upsample2(zeros).to(x) + out = F.conv1d(x.view(-1, 1, time), kernel, padding=zeros)[..., 1:].view( + *other, time + ) + y = th.stack([x, out], dim=-1) + return y.view(*other, -1) + + +def kernel_downsample2(zeros=56): + """kernel_downsample2. + + """ + win = th.hann_window(4 * zeros + 1, periodic=False) + winodd = win[1::2] + t = th.linspace(-zeros + 0.5, zeros - 0.5, 2 * zeros) + t.mul_(math.pi) + kernel = (sinc(t) * winodd).view(1, 1, -1) + return kernel + + +def downsample2(x, zeros=56): + """ + Downsampling the input by 2 using sinc interpolation. + Smith, Julius, and Phil Gossett. "A flexible sampling-rate conversion method." + ICASSP'84. IEEE International Conference on Acoustics, Speech, and Signal Processing. + Vol. 9. IEEE, 1984. + """ + if x.shape[-1] % 2 != 0: + x = F.pad(x, (0, 1)) + xeven = x[..., ::2] + xodd = x[..., 1::2] + *other, time = xodd.shape + kernel = kernel_downsample2(zeros).to(x) + out = xeven + F.conv1d( + xodd.view(-1, 1, time), kernel, padding=zeros + )[..., :-1].view(*other, time) + return out.view(*other, -1).mul(0.5) diff --git a/fairseq/examples/speech_synthesis/preprocessing/denoiser/utils.py b/fairseq/examples/speech_synthesis/preprocessing/denoiser/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..734d047f1bb8e3aa98c88e152eee7f91fea3d814 --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/denoiser/utils.py @@ -0,0 +1,176 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# author: adefossez + +import functools +import logging +from contextlib import contextmanager +import inspect +import time + +logger = logging.getLogger(__name__) + +EPS = 1e-8 + + +def capture_init(init): + """capture_init. + + Decorate `__init__` with this, and you can then + recover the *args and **kwargs passed to it in `self._init_args_kwargs` + """ + @functools.wraps(init) + def __init__(self, *args, **kwargs): + self._init_args_kwargs = (args, kwargs) + init(self, *args, **kwargs) + + return __init__ + + +def deserialize_model(package, strict=False): + """deserialize_model. + + """ + klass = package['class'] + if strict: + model = klass(*package['args'], **package['kwargs']) + else: + sig = inspect.signature(klass) + kw = package['kwargs'] + for key in list(kw): + if key not in sig.parameters: + logger.warning("Dropping inexistant parameter %s", key) + del kw[key] + model = klass(*package['args'], **kw) + model.load_state_dict(package['state']) + return model + + +def copy_state(state): + return {k: v.cpu().clone() for k, v in state.items()} + + +def serialize_model(model): + args, kwargs = model._init_args_kwargs + state = copy_state(model.state_dict()) + return {"class": model.__class__, "args": args, "kwargs": kwargs, "state": state} + + +@contextmanager +def swap_state(model, state): + """ + Context manager that swaps the state of a model, e.g: + + # model is in old state + with swap_state(model, new_state): + # model in new state + # model back to old state + """ + old_state = copy_state(model.state_dict()) + model.load_state_dict(state) + try: + yield + finally: + model.load_state_dict(old_state) + + +def pull_metric(history, name): + out = [] + for metrics in history: + if name in metrics: + out.append(metrics[name]) + return out + + +class LogProgress: + """ + Sort of like tqdm but using log lines and not as real time. + Args: + - logger: logger obtained from `logging.getLogger`, + - iterable: iterable object to wrap + - updates (int): number of lines that will be printed, e.g. + if `updates=5`, log every 1/5th of the total length. + - total (int): length of the iterable, in case it does not support + `len`. + - name (str): prefix to use in the log. + - level: logging level (like `logging.INFO`). + """ + def __init__(self, + logger, + iterable, + updates=5, + total=None, + name="LogProgress", + level=logging.INFO): + self.iterable = iterable + self.total = total or len(iterable) + self.updates = updates + self.name = name + self.logger = logger + self.level = level + + def update(self, **infos): + self._infos = infos + + def __iter__(self): + self._iterator = iter(self.iterable) + self._index = -1 + self._infos = {} + self._begin = time.time() + return self + + def __next__(self): + self._index += 1 + try: + value = next(self._iterator) + except StopIteration: + raise + else: + return value + finally: + log_every = max(1, self.total // self.updates) + # logging is delayed by 1 it, in order to have the metrics from update + if self._index >= 1 and self._index % log_every == 0: + self._log() + + def _log(self): + self._speed = (1 + self._index) / (time.time() - self._begin) + infos = " | ".join(f"{k.capitalize()} {v}" for k, v in self._infos.items()) + if self._speed < 1e-4: + speed = "oo sec/it" + elif self._speed < 0.1: + speed = f"{1/self._speed:.1f} sec/it" + else: + speed = f"{self._speed:.1f} it/sec" + out = f"{self.name} | {self._index}/{self.total} | {speed}" + if infos: + out += " | " + infos + self.logger.log(self.level, out) + + +def colorize(text, color): + """ + Display text with some ANSI color in the terminal. + """ + code = f"\033[{color}m" + restore = "\033[0m" + return "".join([code, text, restore]) + + +def bold(text): + """ + Display text in bold in the terminal. + """ + return colorize(text, "1") + + +def cal_snr(lbl, est): + import torch + y = 10.0 * torch.log10( + torch.sum(lbl**2, dim=-1) / (torch.sum((est-lbl)**2, dim=-1) + EPS) + + EPS + ) + return y diff --git a/fairseq/examples/speech_synthesis/preprocessing/get_common_voice_audio_manifest.py b/fairseq/examples/speech_synthesis/preprocessing/get_common_voice_audio_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..a30254604311a488a1d4959f941051890ed32b2e --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/get_common_voice_audio_manifest.py @@ -0,0 +1,140 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +from collections import defaultdict +from typing import List, Dict, Tuple + +import pandas as pd +import numpy as np +import torchaudio +from tqdm import tqdm + +from examples.speech_to_text.data_utils import load_df_from_tsv, save_df_to_tsv + + +log = logging.getLogger(__name__) + +SPLITS = ["train", "dev", "test"] + + +def get_top_n( + root: Path, n_speakers: int = 10, min_n_tokens: int = 5 +) -> pd.DataFrame: + df = load_df_from_tsv(root / "validated.tsv") + df["n_tokens"] = [len(s.split()) for s in df["sentence"]] + df = df[df["n_tokens"] >= min_n_tokens] + df["n_frames"] = [ + torchaudio.info((root / "clips" / p).as_posix()).num_frames + for p in tqdm(df["path"]) + ] + df["id"] = [Path(p).stem for p in df["path"]] + total_duration_ms = df.groupby("client_id")["n_frames"].agg(["sum"]) + total_duration_ms = total_duration_ms.sort_values("sum", ascending=False) + + top_n_total_duration_ms = total_duration_ms.head(n_speakers) + top_n_client_ids = set(top_n_total_duration_ms.index.tolist()) + df_top_n = df[df["client_id"].isin(top_n_client_ids)] + return df_top_n + + +def get_splits( + df, train_split_ratio=0.99, speaker_in_all_splits=False, rand_seed=0 +) -> Tuple[Dict[str, str], List[str]]: + np.random.seed(rand_seed) + dev_split_ratio = (1. - train_split_ratio) / 3 + grouped = list(df.groupby("client_id")) + id_to_split = {} + for _, cur_df in tqdm(grouped): + cur_n_examples = len(cur_df) + if speaker_in_all_splits and cur_n_examples < 3: + continue + cur_n_train = int(cur_n_examples * train_split_ratio) + cur_n_dev = int(cur_n_examples * dev_split_ratio) + cur_n_test = cur_n_examples - cur_n_dev - cur_n_train + if speaker_in_all_splits and cur_n_dev * cur_n_test == 0: + cur_n_dev, cur_n_test = 1, 1 + cur_n_train = cur_n_examples - cur_n_dev - cur_n_test + cur_indices = cur_df.index.tolist() + cur_shuffled_indices = np.random.permutation(cur_n_examples) + cur_shuffled_indices = [cur_indices[i] for i in cur_shuffled_indices] + cur_indices_by_split = { + "train": cur_shuffled_indices[:cur_n_train], + "dev": cur_shuffled_indices[cur_n_train: cur_n_train + cur_n_dev], + "test": cur_shuffled_indices[cur_n_train + cur_n_dev:] + } + for split in SPLITS: + for i in cur_indices_by_split[split]: + id_ = df["id"].loc[i] + id_to_split[id_] = split + return id_to_split, sorted(df["client_id"].unique()) + + +def convert_to_wav(root: Path, filenames: List[str], target_sr=16_000): + out_root = root / "wav" + out_root.mkdir(exist_ok=True, parents=True) + print("Converting to WAV...") + for n in tqdm(filenames): + in_path = (root / "clips" / n).as_posix() + waveform, sr = torchaudio.load(in_path) + converted, converted_sr = torchaudio.sox_effects.apply_effects_tensor( + waveform, sr, [["rate", str(target_sr)], ["channels", "1"]] + ) + out_path = (out_root / Path(n).with_suffix(".wav").name).as_posix() + torchaudio.save(out_path, converted, converted_sr, encoding="PCM_S", + bits_per_sample=16) + + +def process(args): + data_root = Path(args.data_root).absolute() / args.lang + + # Generate TSV manifest + print("Generating manifest...") + + df_top_n = get_top_n(data_root) + id_to_split, speakers = get_splits(df_top_n) + + if args.convert_to_wav: + convert_to_wav(data_root, df_top_n["path"].tolist()) + + manifest_by_split = {split: defaultdict(list) for split in SPLITS} + for sample in tqdm(df_top_n.to_dict(orient="index").values()): + sample_id = sample["id"] + split = id_to_split[sample_id] + manifest_by_split[split]["id"].append(sample_id) + if args.convert_to_wav: + audio_path = data_root / "wav" / f"{sample_id}.wav" + else: + audio_path = data_root / "clips" / f"{sample_id}.mp3" + manifest_by_split[split]["audio"].append(audio_path.as_posix()) + manifest_by_split[split]["n_frames"].append(sample["n_frames"]) + manifest_by_split[split]["tgt_text"].append(sample["sentence"]) + manifest_by_split[split]["speaker"].append(sample["client_id"]) + manifest_by_split[split]["src_text"].append(sample["sentence"]) + + output_root = Path(args.output_manifest_root).absolute() + output_root.mkdir(parents=True, exist_ok=True) + for split in SPLITS: + save_df_to_tsv( + pd.DataFrame.from_dict(manifest_by_split[split]), + output_root / f"{split}.audio.tsv" + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--data-root", "-d", required=True, type=str) + parser.add_argument("--output-manifest-root", "-m", required=True, type=str) + parser.add_argument("--lang", "-l", required=True, type=str) + parser.add_argument("--convert-to-wav", action="store_true") + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/get_feature_manifest.py b/fairseq/examples/speech_synthesis/preprocessing/get_feature_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..516f2cc469af9b417126dea1988698adac41d8ab --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/get_feature_manifest.py @@ -0,0 +1,233 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +import shutil +from tempfile import NamedTemporaryFile +from collections import Counter, defaultdict + +import pandas as pd +import torchaudio +from tqdm import tqdm + +from fairseq.data.audio.audio_utils import convert_waveform +from examples.speech_to_text.data_utils import ( + create_zip, + gen_config_yaml, + gen_vocab, + get_zip_manifest, + load_tsv_to_dicts, + save_df_to_tsv +) +from examples.speech_synthesis.data_utils import ( + extract_logmel_spectrogram, extract_pitch, extract_energy, get_global_cmvn, + ipa_phonemize, get_mfa_alignment, get_unit_alignment +) + + +log = logging.getLogger(__name__) + + +def process(args): + assert "train" in args.splits + out_root = Path(args.output_root).absolute() + out_root.mkdir(exist_ok=True) + + print("Fetching data...") + audio_manifest_root = Path(args.audio_manifest_root).absolute() + samples = [] + for s in args.splits: + for e in load_tsv_to_dicts(audio_manifest_root / f"{s}.audio.tsv"): + e["split"] = s + samples.append(e) + sample_ids = [s["id"] for s in samples] + + # Get alignment info + id_to_alignment = None + if args.textgrid_zip is not None: + assert args.id_to_units_tsv is None + id_to_alignment = get_mfa_alignment( + args.textgrid_zip, sample_ids, args.sample_rate, args.hop_length + ) + elif args.id_to_units_tsv is not None: + # assume identical hop length on the unit sequence + id_to_alignment = get_unit_alignment(args.id_to_units_tsv, sample_ids) + + # Extract features and pack features into ZIP + feature_name = "logmelspec80" + zip_path = out_root / f"{feature_name}.zip" + pitch_zip_path = out_root / "pitch.zip" + energy_zip_path = out_root / "energy.zip" + gcmvn_npz_path = out_root / "gcmvn_stats.npz" + if zip_path.exists() and gcmvn_npz_path.exists(): + print(f"{zip_path} and {gcmvn_npz_path} exist.") + else: + feature_root = out_root / feature_name + feature_root.mkdir(exist_ok=True) + pitch_root = out_root / "pitch" + energy_root = out_root / "energy" + if args.add_fastspeech_targets: + pitch_root.mkdir(exist_ok=True) + energy_root.mkdir(exist_ok=True) + print("Extracting Mel spectrogram features...") + for sample in tqdm(samples): + waveform, sample_rate = torchaudio.load(sample["audio"]) + waveform, sample_rate = convert_waveform( + waveform, sample_rate, normalize_volume=args.normalize_volume, + to_sample_rate=args.sample_rate + ) + sample_id = sample["id"] + target_length = None + if id_to_alignment is not None: + a = id_to_alignment[sample_id] + target_length = sum(a.frame_durations) + if a.start_sec is not None and a.end_sec is not None: + start_frame = int(a.start_sec * sample_rate) + end_frame = int(a.end_sec * sample_rate) + waveform = waveform[:, start_frame: end_frame] + extract_logmel_spectrogram( + waveform, sample_rate, feature_root / f"{sample_id}.npy", + win_length=args.win_length, hop_length=args.hop_length, + n_fft=args.n_fft, n_mels=args.n_mels, f_min=args.f_min, + f_max=args.f_max, target_length=target_length + ) + if args.add_fastspeech_targets: + assert id_to_alignment is not None + extract_pitch( + waveform, sample_rate, pitch_root / f"{sample_id}.npy", + hop_length=args.hop_length, log_scale=True, + phoneme_durations=id_to_alignment[sample_id].frame_durations + ) + extract_energy( + waveform, energy_root / f"{sample_id}.npy", + hop_length=args.hop_length, n_fft=args.n_fft, + log_scale=True, + phoneme_durations=id_to_alignment[sample_id].frame_durations + ) + print("ZIPing features...") + create_zip(feature_root, zip_path) + get_global_cmvn(feature_root, gcmvn_npz_path) + shutil.rmtree(feature_root) + if args.add_fastspeech_targets: + create_zip(pitch_root, pitch_zip_path) + shutil.rmtree(pitch_root) + create_zip(energy_root, energy_zip_path) + shutil.rmtree(energy_root) + + print("Fetching ZIP manifest...") + audio_paths, audio_lengths = get_zip_manifest(zip_path) + pitch_paths, pitch_lengths, energy_paths, energy_lengths = [None] * 4 + if args.add_fastspeech_targets: + pitch_paths, pitch_lengths = get_zip_manifest(pitch_zip_path) + energy_paths, energy_lengths = get_zip_manifest(energy_zip_path) + # Generate TSV manifest + print("Generating manifest...") + manifest_by_split = {split: defaultdict(list) for split in args.splits} + for sample in tqdm(samples): + sample_id, split = sample["id"], sample["split"] + normalized_utt = sample["tgt_text"] + if id_to_alignment is not None: + normalized_utt = " ".join(id_to_alignment[sample_id].tokens) + elif args.ipa_vocab: + normalized_utt = ipa_phonemize( + normalized_utt, lang=args.lang, use_g2p=args.use_g2p + ) + manifest_by_split[split]["id"].append(sample_id) + manifest_by_split[split]["audio"].append(audio_paths[sample_id]) + manifest_by_split[split]["n_frames"].append(audio_lengths[sample_id]) + manifest_by_split[split]["tgt_text"].append(normalized_utt) + manifest_by_split[split]["speaker"].append(sample["speaker"]) + manifest_by_split[split]["src_text"].append(sample["src_text"]) + if args.add_fastspeech_targets: + assert id_to_alignment is not None + duration = " ".join( + str(d) for d in id_to_alignment[sample_id].frame_durations + ) + manifest_by_split[split]["duration"].append(duration) + manifest_by_split[split]["pitch"].append(pitch_paths[sample_id]) + manifest_by_split[split]["energy"].append(energy_paths[sample_id]) + for split in args.splits: + save_df_to_tsv( + pd.DataFrame.from_dict(manifest_by_split[split]), + out_root / f"{split}.tsv" + ) + # Generate vocab + vocab_name, spm_filename = None, None + if id_to_alignment is not None or args.ipa_vocab: + vocab = Counter() + for t in manifest_by_split["train"]["tgt_text"]: + vocab.update(t.split(" ")) + vocab_name = "vocab.txt" + with open(out_root / vocab_name, "w") as f: + for s, c in vocab.most_common(): + f.write(f"{s} {c}\n") + else: + spm_filename_prefix = "spm_char" + spm_filename = f"{spm_filename_prefix}.model" + with NamedTemporaryFile(mode="w") as f: + for t in manifest_by_split["train"]["tgt_text"]: + f.write(t + "\n") + f.flush() # needed to ensure gen_vocab sees dumped text + gen_vocab(Path(f.name), out_root / spm_filename_prefix, "char") + # Generate speaker list + speakers = sorted({sample["speaker"] for sample in samples}) + speakers_path = out_root / "speakers.txt" + with open(speakers_path, "w") as f: + for speaker in speakers: + f.write(f"{speaker}\n") + # Generate config YAML + win_len_t = args.win_length / args.sample_rate + hop_len_t = args.hop_length / args.sample_rate + extra = { + "sample_rate": args.sample_rate, + "features": { + "type": "spectrogram+melscale+log", + "eps": 1e-2, "n_mels": args.n_mels, "n_fft": args.n_fft, + "window_fn": "hann", "win_length": args.win_length, + "hop_length": args.hop_length, "sample_rate": args.sample_rate, + "win_len_t": win_len_t, "hop_len_t": hop_len_t, + "f_min": args.f_min, "f_max": args.f_max, + "n_stft": args.n_fft // 2 + 1 + } + } + if len(speakers) > 1: + extra["speaker_set_filename"] = "speakers.txt" + gen_config_yaml( + out_root, spm_filename=spm_filename, vocab_name=vocab_name, + audio_root=out_root.as_posix(), input_channels=None, + input_feat_per_channel=None, specaugment_policy=None, + cmvn_type="global", gcmvn_path=gcmvn_npz_path, extra=extra + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--audio-manifest-root", "-m", required=True, type=str) + parser.add_argument("--output-root", "-o", required=True, type=str) + parser.add_argument("--splits", "-s", type=str, nargs="+", + default=["train", "dev", "test"]) + parser.add_argument("--ipa-vocab", action="store_true") + parser.add_argument("--use-g2p", action="store_true") + parser.add_argument("--lang", type=str, default="en-us") + parser.add_argument("--win-length", type=int, default=1024) + parser.add_argument("--hop-length", type=int, default=256) + parser.add_argument("--n-fft", type=int, default=1024) + parser.add_argument("--n-mels", type=int, default=80) + parser.add_argument("--f-min", type=int, default=20) + parser.add_argument("--f-max", type=int, default=8000) + parser.add_argument("--sample-rate", type=int, default=22050) + parser.add_argument("--normalize-volume", "-n", action="store_true") + parser.add_argument("--textgrid-zip", type=str, default=None) + parser.add_argument("--id-to-units-tsv", type=str, default=None) + parser.add_argument("--add-fastspeech-targets", action="store_true") + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/get_ljspeech_audio_manifest.py b/fairseq/examples/speech_synthesis/preprocessing/get_ljspeech_audio_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..7ec1fb7521b8a9b821d28bcaaaedb034f6e95e0b --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/get_ljspeech_audio_manifest.py @@ -0,0 +1,70 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +from collections import defaultdict + +import pandas as pd +from torchaudio.datasets import LJSPEECH +from tqdm import tqdm + +from examples.speech_to_text.data_utils import save_df_to_tsv + + +log = logging.getLogger(__name__) + +SPLITS = ["train", "dev", "test"] + + +def process(args): + out_root = Path(args.output_data_root).absolute() + out_root.mkdir(parents=True, exist_ok=True) + + # Generate TSV manifest + print("Generating manifest...") + # following FastSpeech's splits + dataset = LJSPEECH(out_root.as_posix(), download=True) + id_to_split = {} + for x in dataset._flist: + id_ = x[0] + speaker = id_.split("-")[0] + id_to_split[id_] = { + "LJ001": "test", "LJ002": "test", "LJ003": "dev" + }.get(speaker, "train") + manifest_by_split = {split: defaultdict(list) for split in SPLITS} + progress = tqdm(enumerate(dataset), total=len(dataset)) + for i, (waveform, _, utt, normalized_utt) in progress: + sample_id = dataset._flist[i][0] + split = id_to_split[sample_id] + manifest_by_split[split]["id"].append(sample_id) + audio_path = f"{dataset._path}/{sample_id}.wav" + manifest_by_split[split]["audio"].append(audio_path) + manifest_by_split[split]["n_frames"].append(len(waveform[0])) + manifest_by_split[split]["tgt_text"].append(normalized_utt) + manifest_by_split[split]["speaker"].append("ljspeech") + manifest_by_split[split]["src_text"].append(utt) + + manifest_root = Path(args.output_manifest_root).absolute() + manifest_root.mkdir(parents=True, exist_ok=True) + for split in SPLITS: + save_df_to_tsv( + pd.DataFrame.from_dict(manifest_by_split[split]), + manifest_root / f"{split}.audio.tsv" + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output-data-root", "-d", required=True, type=str) + parser.add_argument("--output-manifest-root", "-m", required=True, type=str) + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/get_speaker_embedding.py b/fairseq/examples/speech_synthesis/preprocessing/get_speaker_embedding.py new file mode 100644 index 0000000000000000000000000000000000000000..0e3e4c5cd7aef15dae0b41b0ec7b33e17f66597f --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/get_speaker_embedding.py @@ -0,0 +1,89 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import argparse +from collections import defaultdict +from itertools import chain +from pathlib import Path + +import numpy as np +import torchaudio +import torchaudio.sox_effects as ta_sox +import yaml +from tqdm import tqdm + +from examples.speech_to_text.data_utils import load_tsv_to_dicts +from examples.speech_synthesis.preprocessing.speaker_embedder import SpkrEmbedder + + +def extract_embedding(audio_path, embedder): + wav, sr = torchaudio.load(audio_path) # 2D + if sr != embedder.RATE: + wav, sr = ta_sox.apply_effects_tensor( + wav, sr, [["rate", str(embedder.RATE)]] + ) + try: + emb = embedder([wav[0].cuda().float()]).cpu().numpy() + except RuntimeError: + emb = None + return emb + + +def process(args): + print("Fetching data...") + raw_manifest_root = Path(args.raw_manifest_root).absolute() + samples = [load_tsv_to_dicts(raw_manifest_root / (s + ".tsv")) + for s in args.splits] + samples = list(chain(*samples)) + with open(args.config, "r") as f: + config = yaml.load(f, Loader=yaml.FullLoader) + with open(f"{config['audio_root']}/{config['speaker_set_filename']}") as f: + speaker_to_id = {r.strip(): i for i, r in enumerate(f)} + + embedder = SpkrEmbedder(args.ckpt).cuda() + speaker_to_cnt = defaultdict(float) + speaker_to_emb = defaultdict(float) + for sample in tqdm(samples, desc="extract emb"): + emb = extract_embedding(sample["audio"], embedder) + if emb is not None: + speaker_to_cnt[sample["speaker"]] += 1 + speaker_to_emb[sample["speaker"]] += emb + if len(speaker_to_emb) != len(speaker_to_id): + missed = set(speaker_to_id) - set(speaker_to_emb.keys()) + print( + f"WARNING: missing embeddings for {len(missed)} speaker:\n{missed}" + ) + speaker_emb_mat = np.zeros((len(speaker_to_id), len(emb)), float) + for speaker in speaker_to_emb: + idx = speaker_to_id[speaker] + emb = speaker_to_emb[speaker] + cnt = speaker_to_cnt[speaker] + speaker_emb_mat[idx, :] = emb / cnt + speaker_emb_name = "speaker_emb.npy" + speaker_emb_path = f"{config['audio_root']}/{speaker_emb_name}" + np.save(speaker_emb_path, speaker_emb_mat) + config["speaker_emb_filename"] = speaker_emb_name + + with open(args.new_config, "w") as f: + yaml.dump(config, f) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--raw-manifest-root", "-m", required=True, type=str) + parser.add_argument("--splits", "-s", type=str, nargs="+", + default=["train"]) + parser.add_argument("--config", "-c", required=True, type=str) + parser.add_argument("--new-config", "-n", required=True, type=str) + parser.add_argument("--ckpt", required=True, type=str, + help="speaker embedder checkpoint") + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/get_vctk_audio_manifest.py b/fairseq/examples/speech_synthesis/preprocessing/get_vctk_audio_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..7afa40fcd195465a225c9f251734e84fe6b3c7ef --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/get_vctk_audio_manifest.py @@ -0,0 +1,79 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import numpy as np +import re +from pathlib import Path +from collections import defaultdict + +import pandas as pd +from torchaudio.datasets import VCTK +from tqdm import tqdm + +from examples.speech_to_text.data_utils import save_df_to_tsv + + +log = logging.getLogger(__name__) + +SPLITS = ["train", "dev", "test"] + + +def normalize_text(text): + return re.sub(r"[^a-zA-Z.?!,'\- ]", '', text) + + +def process(args): + out_root = Path(args.output_data_root).absolute() + out_root.mkdir(parents=True, exist_ok=True) + + # Generate TSV manifest + print("Generating manifest...") + dataset = VCTK(out_root.as_posix(), download=False) + ids = list(dataset._walker) + np.random.seed(args.seed) + np.random.shuffle(ids) + n_train = len(ids) - args.n_dev - args.n_test + _split = ["train"] * n_train + ["dev"] * args.n_dev + ["test"] * args.n_test + id_to_split = dict(zip(ids, _split)) + manifest_by_split = {split: defaultdict(list) for split in SPLITS} + progress = tqdm(enumerate(dataset), total=len(dataset)) + for i, (waveform, _, text, speaker_id, _) in progress: + sample_id = dataset._walker[i] + _split = id_to_split[sample_id] + audio_dir = Path(dataset._path) / dataset._folder_audio / speaker_id + audio_path = audio_dir / f"{sample_id}.wav" + text = normalize_text(text) + manifest_by_split[_split]["id"].append(sample_id) + manifest_by_split[_split]["audio"].append(audio_path.as_posix()) + manifest_by_split[_split]["n_frames"].append(len(waveform[0])) + manifest_by_split[_split]["tgt_text"].append(text) + manifest_by_split[_split]["speaker"].append(speaker_id) + manifest_by_split[_split]["src_text"].append(text) + + manifest_root = Path(args.output_manifest_root).absolute() + manifest_root.mkdir(parents=True, exist_ok=True) + for _split in SPLITS: + save_df_to_tsv( + pd.DataFrame.from_dict(manifest_by_split[_split]), + manifest_root / f"{_split}.audio.tsv" + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output-data-root", "-d", required=True, type=str) + parser.add_argument("--output-manifest-root", "-m", required=True, type=str) + parser.add_argument("--n-dev", default=50, type=int) + parser.add_argument("--n-test", default=100, type=int) + parser.add_argument("--seed", "-s", default=1234, type=int) + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_synthesis/preprocessing/speaker_embedder/__init__.py b/fairseq/examples/speech_synthesis/preprocessing/speaker_embedder/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3b178676ba322ef613df42977cb498101f841b09 --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/speaker_embedder/__init__.py @@ -0,0 +1,135 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import librosa +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.data +import torchaudio + + +EMBEDDER_PARAMS = { + 'num_mels': 40, + 'n_fft': 512, + 'emb_dim': 256, + 'lstm_hidden': 768, + 'lstm_layers': 3, + 'window': 80, + 'stride': 40, +} + + +def set_requires_grad(nets, requires_grad=False): + """Set requies_grad=Fasle for all the networks to avoid unnecessary + computations + Parameters: + nets (network list) -- a list of networks + requires_grad (bool) -- whether the networks require gradients or not + """ + if not isinstance(nets, list): + nets = [nets] + for net in nets: + if net is not None: + for param in net.parameters(): + param.requires_grad = requires_grad + + +class LinearNorm(nn.Module): + def __init__(self, hp): + super(LinearNorm, self).__init__() + self.linear_layer = nn.Linear(hp["lstm_hidden"], hp["emb_dim"]) + + def forward(self, x): + return self.linear_layer(x) + + +class SpeechEmbedder(nn.Module): + def __init__(self, hp): + super(SpeechEmbedder, self).__init__() + self.lstm = nn.LSTM(hp["num_mels"], + hp["lstm_hidden"], + num_layers=hp["lstm_layers"], + batch_first=True) + self.proj = LinearNorm(hp) + self.hp = hp + + def forward(self, mel): + # (num_mels, T) -> (num_mels, T', window) + mels = mel.unfold(1, self.hp["window"], self.hp["stride"]) + mels = mels.permute(1, 2, 0) # (T', window, num_mels) + x, _ = self.lstm(mels) # (T', window, lstm_hidden) + x = x[:, -1, :] # (T', lstm_hidden), use last frame only + x = self.proj(x) # (T', emb_dim) + x = x / torch.norm(x, p=2, dim=1, keepdim=True) # (T', emb_dim) + + x = x.mean(dim=0) + if x.norm(p=2) != 0: + x = x / x.norm(p=2) + return x + + +class SpkrEmbedder(nn.Module): + RATE = 16000 + + def __init__( + self, + embedder_path, + embedder_params=EMBEDDER_PARAMS, + rate=16000, + hop_length=160, + win_length=400, + pad=False, + ): + super(SpkrEmbedder, self).__init__() + embedder_pt = torch.load(embedder_path, map_location="cpu") + self.embedder = SpeechEmbedder(embedder_params) + self.embedder.load_state_dict(embedder_pt) + self.embedder.eval() + set_requires_grad(self.embedder, requires_grad=False) + self.embedder_params = embedder_params + + self.register_buffer('mel_basis', torch.from_numpy( + librosa.filters.mel( + sr=self.RATE, + n_fft=self.embedder_params["n_fft"], + n_mels=self.embedder_params["num_mels"]) + ) + ) + + self.resample = None + if rate != self.RATE: + self.resample = torchaudio.transforms.Resample(rate, self.RATE) + self.hop_length = hop_length + self.win_length = win_length + self.pad = pad + + def get_mel(self, y): + if self.pad and y.shape[-1] < 14000: + y = F.pad(y, (0, 14000 - y.shape[-1])) + + window = torch.hann_window(self.win_length).to(y) + y = torch.stft(y, n_fft=self.embedder_params["n_fft"], + hop_length=self.hop_length, + win_length=self.win_length, + window=window) + magnitudes = torch.norm(y, dim=-1, p=2) ** 2 + mel = torch.log10(self.mel_basis @ magnitudes + 1e-6) + return mel + + def forward(self, inputs): + dvecs = [] + for wav in inputs: + mel = self.get_mel(wav) + if mel.dim() == 3: + mel = mel.squeeze(0) + dvecs += [self.embedder(mel)] + dvecs = torch.stack(dvecs) + + dvec = torch.mean(dvecs, dim=0) + dvec = dvec / torch.norm(dvec) + + return dvec diff --git a/fairseq/examples/speech_synthesis/preprocessing/vad/__init__.py b/fairseq/examples/speech_synthesis/preprocessing/vad/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9cf121081fbde2f5085ed380f0841649d143a4be --- /dev/null +++ b/fairseq/examples/speech_synthesis/preprocessing/vad/__init__.py @@ -0,0 +1,192 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import collections +import contextlib +import wave + +try: + import webrtcvad +except ImportError: + raise ImportError("Please install py-webrtcvad: pip install webrtcvad") +import argparse +import os +import logging +from tqdm import tqdm + +AUDIO_SUFFIX = '.wav' +FS_MS = 30 +SCALE = 6e-5 +THRESHOLD = 0.3 + + +def read_wave(path): + """Reads a .wav file. + Takes the path, and returns (PCM audio data, sample rate). + """ + with contextlib.closing(wave.open(path, 'rb')) as wf: + num_channels = wf.getnchannels() + assert num_channels == 1 + sample_width = wf.getsampwidth() + assert sample_width == 2 + sample_rate = wf.getframerate() + assert sample_rate in (8000, 16000, 32000, 48000) + pcm_data = wf.readframes(wf.getnframes()) + return pcm_data, sample_rate + + +def write_wave(path, audio, sample_rate): + """Writes a .wav file. + Takes path, PCM audio data, and sample rate. + """ + with contextlib.closing(wave.open(path, 'wb')) as wf: + wf.setnchannels(1) + wf.setsampwidth(2) + wf.setframerate(sample_rate) + wf.writeframes(audio) + + +class Frame(object): + """Represents a "frame" of audio data.""" + def __init__(self, bytes, timestamp, duration): + self.bytes = bytes + self.timestamp = timestamp + self.duration = duration + + +def frame_generator(frame_duration_ms, audio, sample_rate): + """Generates audio frames from PCM audio data. + Takes the desired frame duration in milliseconds, the PCM data, and + the sample rate. + Yields Frames of the requested duration. + """ + n = int(sample_rate * (frame_duration_ms / 1000.0) * 2) + offset = 0 + timestamp = 0.0 + duration = (float(n) / sample_rate) / 2.0 + while offset + n < len(audio): + yield Frame(audio[offset:offset + n], timestamp, duration) + timestamp += duration + offset += n + + +def vad_collector(sample_rate, frame_duration_ms, + padding_duration_ms, vad, frames): + """Filters out non-voiced audio frames. + Given a webrtcvad.Vad and a source of audio frames, yields only + the voiced audio. + Uses a padded, sliding window algorithm over the audio frames. + When more than 90% of the frames in the window are voiced (as + reported by the VAD), the collector triggers and begins yielding + audio frames. Then the collector waits until 90% of the frames in + the window are unvoiced to detrigger. + The window is padded at the front and back to provide a small + amount of silence or the beginnings/endings of speech around the + voiced frames. + Arguments: + sample_rate - The audio sample rate, in Hz. + frame_duration_ms - The frame duration in milliseconds. + padding_duration_ms - The amount to pad the window, in milliseconds. + vad - An instance of webrtcvad.Vad. + frames - a source of audio frames (sequence or generator). + Returns: A generator that yields PCM audio data. + """ + num_padding_frames = int(padding_duration_ms / frame_duration_ms) + # We use a deque for our sliding window/ring buffer. + ring_buffer = collections.deque(maxlen=num_padding_frames) + # We have two states: TRIGGERED and NOTTRIGGERED. We start in the + # NOTTRIGGERED state. + triggered = False + + voiced_frames = [] + for frame in frames: + is_speech = vad.is_speech(frame.bytes, sample_rate) + + # sys.stdout.write('1' if is_speech else '0') + if not triggered: + ring_buffer.append((frame, is_speech)) + num_voiced = len([f for f, speech in ring_buffer if speech]) + # If we're NOTTRIGGERED and more than 90% of the frames in + # the ring buffer are voiced frames, then enter the + # TRIGGERED state. + if num_voiced > 0.9 * ring_buffer.maxlen: + triggered = True + # We want to yield all the audio we see from now until + # we are NOTTRIGGERED, but we have to start with the + # audio that's already in the ring buffer. + for f, _ in ring_buffer: + voiced_frames.append(f) + ring_buffer.clear() + else: + # We're in the TRIGGERED state, so collect the audio data + # and add it to the ring buffer. + voiced_frames.append(frame) + ring_buffer.append((frame, is_speech)) + num_unvoiced = len([f for f, speech in ring_buffer if not speech]) + # If more than 90% of the frames in the ring buffer are + # unvoiced, then enter NOTTRIGGERED and yield whatever + # audio we've collected. + if num_unvoiced > 0.9 * ring_buffer.maxlen: + triggered = False + yield [b''.join([f.bytes for f in voiced_frames]), + voiced_frames[0].timestamp, voiced_frames[-1].timestamp] + ring_buffer.clear() + voiced_frames = [] + # If we have any leftover voiced audio when we run out of input, + # yield it. + if voiced_frames: + yield [b''.join([f.bytes for f in voiced_frames]), + voiced_frames[0].timestamp, voiced_frames[-1].timestamp] + + +def main(args): + # create output folder + try: + cmd = f"mkdir -p {args.out_path}" + os.system(cmd) + except Exception: + logging.error("Can not create output folder") + exit(-1) + + # build vad object + vad = webrtcvad.Vad(int(args.agg)) + # iterating over wavs in dir + for file in tqdm(os.listdir(args.in_path)): + if file.endswith(AUDIO_SUFFIX): + audio_inpath = os.path.join(args.in_path, file) + audio_outpath = os.path.join(args.out_path, file) + audio, sample_rate = read_wave(audio_inpath) + frames = frame_generator(FS_MS, audio, sample_rate) + frames = list(frames) + segments = vad_collector(sample_rate, FS_MS, 300, vad, frames) + merge_segments = list() + timestamp_start = 0.0 + timestamp_end = 0.0 + # removing start, end, and long sequences of sils + for i, segment in enumerate(segments): + merge_segments.append(segment[0]) + if i and timestamp_start: + sil_duration = segment[1] - timestamp_end + if sil_duration > THRESHOLD: + merge_segments.append(int(THRESHOLD / SCALE)*(b'\x00')) + else: + merge_segments.append(int((sil_duration / SCALE))*(b'\x00')) + timestamp_start = segment[1] + timestamp_end = segment[2] + segment = b''.join(merge_segments) + write_wave(audio_outpath, segment, sample_rate) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Apply vad to a file of fils.') + parser.add_argument('in_path', type=str, help='Path to the input files') + parser.add_argument('out_path', type=str, + help='Path to save the processed files') + parser.add_argument('--agg', type=int, default=3, + help='The level of aggressiveness of the VAD: [0-3]') + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/speech_synthesis/utils.py b/fairseq/examples/speech_synthesis/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2c7b03733d2290d3834d2c68a16034198daa1e69 --- /dev/null +++ b/fairseq/examples/speech_synthesis/utils.py @@ -0,0 +1,101 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from scipy.interpolate import interp1d +import torchaudio + +from fairseq.tasks.text_to_speech import ( + batch_compute_distortion, compute_rms_dist +) + + +def batch_mel_spectral_distortion( + y1, y2, sr, normalize_type="path", mel_fn=None +): + """ + https://arxiv.org/pdf/2011.03568.pdf + + Same as Mel Cepstral Distortion, but computed on log-mel spectrograms. + """ + if mel_fn is None or mel_fn.sample_rate != sr: + mel_fn = torchaudio.transforms.MelSpectrogram( + sr, n_fft=int(0.05 * sr), win_length=int(0.05 * sr), + hop_length=int(0.0125 * sr), f_min=20, n_mels=80, + window_fn=torch.hann_window + ).to(y1[0].device) + offset = 1e-6 + return batch_compute_distortion( + y1, y2, sr, lambda y: torch.log(mel_fn(y) + offset).transpose(-1, -2), + compute_rms_dist, normalize_type + ) + + +# This code is based on +# "https://github.com/bastibe/MAPS-Scripts/blob/master/helper.py" +def _same_t_in_true_and_est(func): + def new_func(true_t, true_f, est_t, est_f): + assert type(true_t) is np.ndarray + assert type(true_f) is np.ndarray + assert type(est_t) is np.ndarray + assert type(est_f) is np.ndarray + + interpolated_f = interp1d( + est_t, est_f, bounds_error=False, kind='nearest', fill_value=0 + )(true_t) + return func(true_t, true_f, true_t, interpolated_f) + + return new_func + + +@_same_t_in_true_and_est +def gross_pitch_error(true_t, true_f, est_t, est_f): + """The relative frequency in percent of pitch estimates that are + outside a threshold around the true pitch. Only frames that are + considered pitched by both the ground truth and the estimator (if + applicable) are considered. + """ + + correct_frames = _true_voiced_frames(true_t, true_f, est_t, est_f) + gross_pitch_error_frames = _gross_pitch_error_frames( + true_t, true_f, est_t, est_f + ) + return np.sum(gross_pitch_error_frames) / np.sum(correct_frames) + + +def _gross_pitch_error_frames(true_t, true_f, est_t, est_f, eps=1e-8): + voiced_frames = _true_voiced_frames(true_t, true_f, est_t, est_f) + true_f_p_eps = [x + eps for x in true_f] + pitch_error_frames = np.abs(est_f / true_f_p_eps - 1) > 0.2 + return voiced_frames & pitch_error_frames + + +def _true_voiced_frames(true_t, true_f, est_t, est_f): + return (est_f != 0) & (true_f != 0) + + +def _voicing_decision_error_frames(true_t, true_f, est_t, est_f): + return (est_f != 0) != (true_f != 0) + + +@_same_t_in_true_and_est +def f0_frame_error(true_t, true_f, est_t, est_f): + gross_pitch_error_frames = _gross_pitch_error_frames( + true_t, true_f, est_t, est_f + ) + voicing_decision_error_frames = _voicing_decision_error_frames( + true_t, true_f, est_t, est_f + ) + return (np.sum(gross_pitch_error_frames) + + np.sum(voicing_decision_error_frames)) / (len(true_t)) + + +@_same_t_in_true_and_est +def voicing_decision_error(true_t, true_f, est_t, est_f): + voicing_decision_error_frames = _voicing_decision_error_frames( + true_t, true_f, est_t, est_f + ) + return np.sum(voicing_decision_error_frames) / (len(true_t)) diff --git a/fairseq/examples/speech_text_joint_to_text/README.md b/fairseq/examples/speech_text_joint_to_text/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e071d241e0e02b35d3aac777ac09b4ef3be9119f --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/README.md @@ -0,0 +1,46 @@ +# Joint Speech Text training in Fairseq +An extension of Fairseq s2t project with the speech to text task enhanced by the co-trained text to text mapping task. More details about Fairseq s2t can be found [here](../speech_to_text/README.md) + +## Examples +Examples of speech text joint training in fairseq +- [English-to-German MuST-C model](docs/ende-mustc.md) +- [IWSLT 2021 Multilingual Speech Translation](docs/iwslt2021.md) + +## Citation +Please cite as: +``` +@inproceedings{Tang2021AGM, + title={A General Multi-Task Learning Framework to Leverage Text Data for Speech to Text Tasks}, + author={Yun Tang and J. Pino and Changhan Wang and Xutai Ma and Dmitriy Genzel}, + booktitle={ICASSP}, + year={2021} +} + +@inproceedings{Tang2021IST, + title = {Improving Speech Translation by Understanding and Learning from the Auxiliary Text Translation Task}, + author = {Yun Tang and Juan Pino and Xian Li and Changhan Wang and Dmitriy Genzel}, + booktitle = {ACL}, + year = {2021}, +} + +@inproceedings{Tang2021FST, + title = {FST: the FAIR Speech Translation System for the IWSLT21 Multilingual Shared Task}, + author = {Yun Tang and Hongyu Gong and Xian Li and Changhan Wang and Juan Pino and Holger Schwenk and Naman Goyal}, + booktitle = {IWSLT}, + year = {2021}, +} + +@inproceedings{wang2020fairseqs2t, + title = {fairseq S2T: Fast Speech-to-Text Modeling with fairseq}, + author = {Changhan Wang and Yun Tang and Xutai Ma and Anne Wu and Dmytro Okhonko and Juan Pino}, + booktitle = {Proceedings of the 2020 Conference of the Asian Chapter of the Association for Computational Linguistics (AACL): System Demonstrations}, + year = {2020}, +} + +@inproceedings{ott2019fairseq, + title = {fairseq: A Fast, Extensible Toolkit for Sequence Modeling}, + author = {Myle Ott and Sergey Edunov and Alexei Baevski and Angela Fan and Sam Gross and Nathan Ng and David Grangier and Michael Auli}, + booktitle = {Proceedings of NAACL-HLT 2019: Demonstrations}, + year = {2019}, +} +``` diff --git a/fairseq/examples/speech_text_joint_to_text/__init__.py b/fairseq/examples/speech_text_joint_to_text/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..239d2e69f9a235095dee1ea7b3a94164a77273f5 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import tasks, criterions, models # noqa diff --git a/fairseq/examples/speech_text_joint_to_text/configs/mustc_noise.list b/fairseq/examples/speech_text_joint_to_text/configs/mustc_noise.list new file mode 100644 index 0000000000000000000000000000000000000000..02eeac4e009f77b765004272f59a1618214da18d --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/configs/mustc_noise.list @@ -0,0 +1,49 @@ +"(Applause) NOISE +"(Laughter) VOICE +"(Laughter)" VOICE +(Applause) NOISE +(Applause). NOISE +(Audience) VOICE +(Audio) NOISE +(Beat) NOISE +(Beatboxing) VOICE +(Beep) NOISE +(Beeps) NOISE +(Cheering) VOICE +(Cheers) VOICE +(Claps) NOISE +(Clicking) NOISE +(Clunk) NOISE +(Coughs) NOISE +(Drums) NOISE +(Explosion) NOISE +(Gasps) VOICE +(Guitar) NOISE +(Honk) NOISE +(Laugher) VOICE +(Laughing) VOICE +(Laughs) VOICE +(Laughter) VOICE +(Laughter). VOICE +(Laughter)... VOICE +(Mumbling) VOICE +(Music) NOISE +(Noise) NOISE +(Recording) VOICE +(Ringing) NOISE +(Shouts) VOICE +(Sigh) VOICE +(Sighs) VOICE +(Silence) NOISE +(Singing) VOICE +(Sings) VOICE +(Spanish) VOICE +(Static) NOISE +(Tones) NOISE +(Trumpet) NOISE +(Video) NOISE +(Video): NOISE +(Voice-over) NOISE +(Whistle) NOISE +(Whistling) NOISE +(video): NOISE diff --git a/fairseq/examples/speech_text_joint_to_text/criterions/__init__.py b/fairseq/examples/speech_text_joint_to_text/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7faae73119321af0b34fe8e26499a2ef5577291a --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/criterions/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +for file in os.listdir(os.path.dirname(__file__)): + if file.endswith(".py") and not file.startswith("_"): + criterion_name = file[: file.find(".py")] + importlib.import_module( + "examples.speech_text_joint_to_text.criterions." + criterion_name + ) diff --git a/fairseq/examples/speech_text_joint_to_text/criterions/text_guide_cross_entropy_acc.py b/fairseq/examples/speech_text_joint_to_text/criterions/text_guide_cross_entropy_acc.py new file mode 100644 index 0000000000000000000000000000000000000000..0d356e5a10241716b58a5bc04a9d204a72553ff8 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/criterions/text_guide_cross_entropy_acc.py @@ -0,0 +1,223 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import math + +import torch +import torch.nn.functional as F +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.criterions.label_smoothed_cross_entropy import label_smoothed_nll_loss +from fairseq import metrics, utils + + +@register_criterion("guided_label_smoothed_cross_entropy_with_accuracy") +class GuidedCrossEntAccCriterion(FairseqCriterion): + def __init__( + self, + task, + sentence_avg, + guide_alpha, + text_input_cost_ratio, + label_smoothing, + disable_text_guide_update_num=0, + attentive_cost_regularization=0, + ): + """ + guide_alpha: alpha to inteplate nll and kd loss + text_input_cost_ratio: loss ratio for text only input data + label_smoothing: label smoothing ratio + disable_text_guide_update_num: only use nll loss for the first N updates + attentive_cost_regularization: ratio fo attentive cost + """ + super().__init__(task) + self.alpha = guide_alpha + self.attn_beta = attentive_cost_regularization + self.sentence_avg = sentence_avg + self.eps = label_smoothing + self.text_input_cost_ratio = text_input_cost_ratio + self.disable_update_num = disable_text_guide_update_num + assert self.alpha >= 0 and self.alpha <= 1.0 + + @staticmethod + def add_args(parser): + """Add criterion-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--label-smoothing', default=0., type=float, metavar='D', + help='epsilon for label smoothing, 0 means no label smoothing') + # fmt: off + parser.add_argument('--guide-alpha', default=0., type=float, metavar='D', + help='alpha to merge kd cost from text to speech input with ce loss') + # fmt: off + parser.add_argument('--disable-text-guide-update-num', default=0, type=int, metavar='D', + help='disable guided target from text for the first N updates.') + parser.add_argument("--attentive-cost-regularization", default=0.0, type=float, metavar='D', + help="use encoder attentive loss regularization with cost ratio D") + parser.add_argument("--attentive-cost-without-normalize", action='store_true', + help="Don't do normalization during attentive cost computation") + + def forward(self, model, sample, reduce=True): + reduction = 'sum' if reduce else 'none' + net_input = sample["net_input"] + net_output = model(**net_input) + attn_cost = None + lprobs = model.get_normalized_probs(net_output, log_probs=True) + is_dual_input = True if net_input['src_tokens'] is not None and net_input.get('src_txt_tokens') is not None else False + target = model.get_targets(sample, net_output) + src_token_num = 0 + if is_dual_input: + # lprobs_spch from speech encoder and lprobs_text from text encoder + lprobs_spch, lprobs_text = torch.chunk(lprobs, 2) + lprobs_spch.batch_first = lprobs.batch_first + lprobs_text.batch_first = lprobs.batch_first + + speech_loss, speech_nll_loss, speech_correct, speech_total = \ + self.guide_loss_and_acc(model, lprobs_spch, lprobs_text, target, reduce=(reduction == 'sum')) + text_loss, text_nll_loss, text_correct, text_total = self.compute_loss_and_acc(model, lprobs_text, target, reduction=reduction) + loss = (speech_loss + text_loss) + nll_loss = (speech_nll_loss + text_nll_loss) + correct = speech_correct + text_correct + total = speech_total + text_total + + attn_cost = net_output[1].get('attn_cost') + if attn_cost is not None: + # attn_cost is batch_first and padding tokens have been masked already + src_token_num = attn_cost.ne(0).sum() + attn_cost = attn_cost.sum() + loss = loss + attn_cost * self.attn_beta + else: + attn_cost = 0 + else: + loss, nll_loss, correct, total = self.compute_loss_and_acc(model, lprobs, target, reduction=reduction) + if sample["net_input"]['src_tokens'] is None: # text input only + loss = loss * self.text_input_cost_ratio + speech_loss = None + speech_nll_loss = None + + sample_size, logging_output = self.get_logging_output( + sample, loss, nll_loss, correct, total, src_token_num, speech_loss, speech_nll_loss, attn_cost, is_dual_input + ) + return loss, sample_size, logging_output + + def compute_loss_and_acc(self, model, lprobs, target, reduction='sum'): + if not lprobs.batch_first: + lprobs = lprobs.transpose(0, 1) + lprobs = lprobs.view(-1, lprobs.size(-1)) # -> (B x T) x C + target = target.view(-1) + loss, nll_loss = label_smoothed_nll_loss( + lprobs, target, self.eps, ignore_index=self.padding_idx, reduce=(reduction == 'sum'), + ) + + mask = target.ne(self.padding_idx) + correct = torch.sum(lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask))) + total = torch.sum(mask) + return loss, nll_loss, correct, total + + def guide_loss_and_acc(self, model, lprobs, lprobs_teacher, target, reduce=True): + """ lprobs_teacher is used as guide for lprobs """ + if self.alpha == 0.0 or model.num_updates < self.disable_update_num: + return self.compute_loss_and_acc(model, lprobs, target, reduction=('sum' if reduce else 'none')) + if not lprobs.batch_first: + lprobs = lprobs.transpose(0, 1) + lprobs_teacher = lprobs_teacher.transpose(0, 1) + + lprobs = lprobs.view(-1, lprobs.size(-1)).float() # -> (B x T) x C + lprobs_teacher = lprobs_teacher.view(-1, lprobs_teacher.size(-1)).float() # -> (B x T) x C + target = target.view(-1) + loss = F.nll_loss(lprobs, target, ignore_index=self.padding_idx, reduction='sum' if reduce else 'none') + nll_loss = loss + probs_teacher = lprobs_teacher.exp().masked_fill_(target.unsqueeze(-1).eq(self.padding_idx), 0) + probs_teacher = probs_teacher.detach() + guide_loss = -(probs_teacher*lprobs).sum() if reduce else -(probs_teacher*lprobs).sum(-1, keepdim=True) + loss = self.alpha*guide_loss + (1.0 - self.alpha)*loss + + mask = target.ne(self.padding_idx) + correct = torch.sum(lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask))) + total = torch.sum(mask) + return loss, nll_loss, correct, total + + def get_logging_output( + self, + sample, + loss, + nll_loss, + correct, + total, + src_token_num=0, + speech_loss=None, + speech_nll_loss=None, + attn_cost=None, + is_dual_input=False, + ): + + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + mul_size = 2 if is_dual_input else 1 + + logging_output = { + "loss": utils.item(loss.data), # * sample['ntokens'], + "nll_loss": utils.item(nll_loss.data), # * sample['ntokens'], + "ntokens": sample["ntokens"]*mul_size, + "nsentences": sample["target"].size(0)*mul_size, + "sample_size": sample_size*mul_size, + "correct": utils.item(correct.data), + "total": utils.item(total.data), + "src_token_num": utils.item(src_token_num.data) if src_token_num > 0 else 0, + "nframes": torch.sum(sample["net_input"]["src_lengths"]).item(), + } + + if speech_loss is not None: + logging_output["speech_loss"] = utils.item(speech_loss.data) + logging_output["speech_nll_loss"] = utils.item(speech_nll_loss.data) + logging_output["sample_size_speech_cost"] = sample_size + logging_output["speech_attn_loss"] = attn_cost + + return sample_size*mul_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + correct_sum = sum(log.get("correct", 0) for log in logging_outputs) + total_sum = sum(log.get("total", 0) for log in logging_outputs) + src_token_sum = sum(log.get("src_token_num", 0) for log in logging_outputs) + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + nframes = sum(log.get("nframes", 0) for log in logging_outputs) + speech_loss_sum = sum(log.get("speech_loss", 0) for log in logging_outputs) + speech_nll_loss_sum = sum(log.get("speech_nll_loss", 0) for log in logging_outputs) + speech_attn_loss_sum = sum(log.get("speech_attn_loss", 0) for log in logging_outputs) + sample_size_speech = sum(log.get("sample_size_speech_cost", 0) for log in logging_outputs) + + agg_output = { + "loss": loss_sum / sample_size / math.log(2) if sample_size > 0 else 0.0, + "nll_loss": nll_loss_sum / sample_size / math.log(2) if sample_size > 0 else 0.0, + # if args.sentence_avg, then sample_size is nsentences, and loss + # is per-sentence loss; else sample_size is ntokens, and the loss + # becomes per-output token loss + "speech_loss": speech_loss_sum / sample_size_speech / math.log(2) if sample_size_speech > 0 else 0.0, + "speech_nll_loss": speech_nll_loss_sum / sample_size_speech / math.log(2) if sample_size_speech > 0 else 0.0, + "speech_attn_loss": speech_attn_loss_sum / src_token_sum / math.log(2) if src_token_sum > 0 else 0.0, + "ntokens": ntokens, + "nsentences": nsentences, + "nframes": nframes, + "sample_size": sample_size, + "acc": correct_sum * 100.0 / total_sum if total_sum > 0 else 0.0, + "correct": correct_sum, + "total": total_sum, + "src_token_num": src_token_sum, + # total is the number of validate tokens + } + return agg_output + + @classmethod + def reduce_metrics(cls, logging_outputs): + """Aggregate logging outputs from data parallel training.""" + agg_logging_outputs = cls.aggregate_logging_outputs(logging_outputs) + for k, v in agg_logging_outputs.items(): + if k in {'nsentences', 'ntokens', 'sample_size'}: + continue + metrics.log_scalar(k, v, round=3) diff --git a/fairseq/examples/speech_text_joint_to_text/docs/ende-mustc.md b/fairseq/examples/speech_text_joint_to_text/docs/ende-mustc.md new file mode 100644 index 0000000000000000000000000000000000000000..2897c4e27b053d4fd65b37fb7e586679dffed1ba --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/docs/ende-mustc.md @@ -0,0 +1,112 @@ +[[Back]](..) + +# Joint Speech Text Training for the MuST-C English to German Speech Translation task + +Joint Training Baseline: it is based on paper ["A general multi-task learning framework to leverage text data for speech to text tasks"](https://arxiv.org/pdf/2010.11338.pdf) + +Enhanced Joint Training: the joint training is enhanced with pre-trained models, cross attentive regularization and online knowledge distillation based on paper ["Improving Speech Translation by Understanding and Learning from the Auxiliary Text Translation Task"](https://research.fb.com/publications/improving-speech-translation-by-understanding-and-learning-from-the-auxiliary-text-translation-task) + +## Prepare Data +#### Download files +- Sentence piece model [spm.model](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/spm.model) +- Dictionary [dict.txt](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/dict.txt) +- config [config.yaml](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/config.yaml) +#### Prepare MuST-C data set +- [Please follow the data preparation in the S2T example](https://github.com/pytorch/fairseq/blob/main/examples/speech_to_text/docs/mustc_example.md) +- Append src_text in the tsv file with phoneme representation. +```bash + python examples/speech_text_joint_to_text/scripts/g2p_encode.py \ + --lower-case --do-filter --use-word-start --no-punc \ + --reserve-word examples/speech_text_joint_to_text/configs/mustc_noise.list \ + --data-path ${must_c_en_de_src_text} \ + --out-path ${must_c_en_de_src_text_pho} +``` +- Update tsv data with src_text generated above and save to $MANIFEST_ROOT +- Prepare phoneme dictionary and save to $MANIFEST_ROOT as [src_dict.txt](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/src_dict.txt) +#### Prepare WMT text data +- [Download wmt data](https://github.com/pytorch/fairseq/blob/main/examples/translation/prepare-wmt14en2de.sh) +- Convert source text (English) into phoneme representation as above +- Generate binary parallel file for training (as translation example) and save data in $parallel_text_data + +## Training +The model is trained with 8 v100 GPUs. + +#### Download pretrained models +- [pretrain_encoder](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_multilingual_asr_transformer_m.pt) +- [pretrain_nmt](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/checkpoint_mt.pt) + +#### Training scripts +- Jointly trained model from scratch +```bash +python train.py ${MANIFEST_ROOT} \ + --save-dir ${save_dir} \ + --num-workers 8 \ + --task speech_text_joint_to_text \ + --arch dualinputs2ttransformer_s \ + --user-dir examples/speech_text_joint_to_text \ + --max-epoch 100 --update-mix-data \ + --optimizer adam --lr-scheduler inverse_sqrt \ + --lr 0.001 --update-freq 4 --clip-norm 10.0 \ + --criterion guided_label_smoothed_cross_entropy_with_accuracy \ + --label-smoothing 0.1 --max-tokens 10000 --max-tokens-text 10000 \ + --max-positions-text 400 --seed 2 --speech-encoder-layers 12 \ + --text-encoder-layers 6 --encoder-shared-layers 6 --decoder-layers 6 \ + --dropout 0.1 --warmup-updates 20000 \ + --text-sample-ratio 0.25 --parallel-text-data ${parallel_text_data} \ + --text-input-cost-ratio 0.5 --enc-grad-mult 2.0 --add-speech-eos \ + --log-format json --langpairs en-de --noise-token '"'"'▁NOISE'"'"' \ + --mask-text-ratio 0.0 --max-tokens-valid 20000 --ddp-backend no_c10d \ + --log-interval 100 --data-buffer-size 50 --config-yaml config.yaml \ + --keep-last-epochs 10 +``` +- Jointly trained model with good initialization, cross attentive loss and online knowledge distillation +```bash +python train.py ${MANIFEST_ROOT} \ + --save-dir ${save_dir} \ + --num-workers 8 \ + --task speech_text_joint_to_text \ + --arch dualinputs2ttransformer_m \ + --user-dir examples/speech_text_joint_to_text \ + --max-epoch 100 --update-mix-data \ + --optimizer adam --lr-scheduler inverse_sqrt \ + --lr 0.002 --update-freq 4 --clip-norm 10.0 \ + --criterion guided_label_smoothed_cross_entropy_with_accuracy \ + --guide-alpha 0.8 --disable-text-guide-update-num 5000 \ + --label-smoothing 0.1 --max-tokens 10000 --max-tokens-text 10000 \ + --max-positions-text 400 --seed 2 --speech-encoder-layers 12 \ + --text-encoder-layers 6 --encoder-shared-layers 6 --decoder-layers 6 \ + --dropout 0.1 --warmup-updates 20000 --attentive-cost-regularization 0.02 \ + --text-sample-ratio 0.25 --parallel-text-data ${parallel_text_data} \ + --text-input-cost-ratio 0.5 --enc-grad-mult 2.0 --add-speech-eos \ + --log-format json --langpairs en-de --noise-token '"'"'▁NOISE'"'"' \ + --mask-text-ratio 0.0 --max-tokens-valid 20000 --ddp-backend no_c10d \ + --log-interval 100 --data-buffer-size 50 --config-yaml config.yaml \ + --load-pretrain-speech-encoder ${pretrain_encoder} \ + --load-pretrain-decoder ${pretrain_nmt} \ + --load-pretrain-text-encoder-last ${pretrain_nmt} \ + --keep-last-epochs 10 +``` + +## Evaluation +```bash +python ./fairseq_cli/generate.py \ + ${MANIFEST_ROOT} \ + --task speech_text_joint_to_text \ + --max-tokens 25000 \ + --nbest 1 \ + --results-path ${infer_results} \ + --batch-size 512 \ + --path ${model} \ + --gen-subset tst-COMMON \ + --config-yaml config_spm.yaml \ + --scoring sacrebleu \ + --beam 5 --lenpen 1.0 \ + --user-dir examples/speech_text_joint_to_text \ + --load-speech-only +``` + +## Results (Joint training with initialization + CAR + online KD) +|Direction|En-De | En-Es | En-Fr | +|---|---|---|---| +|BLEU|27.4| 31.2 | 37.6 | +|checkpoint | [link](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_de/checkpoint_ave_10.pt) |[link](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_es/checkpoint_ave_10.pt)|[link](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/must_c/en_fr/checkpoint_ave_10.pt)| diff --git a/fairseq/examples/speech_text_joint_to_text/docs/iwslt2021.md b/fairseq/examples/speech_text_joint_to_text/docs/iwslt2021.md new file mode 100644 index 0000000000000000000000000000000000000000..920ff271c2e178c7a4ca3c7c8ce57a2f28653969 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/docs/iwslt2021.md @@ -0,0 +1,76 @@ +[[Back]](..) + +# Joint Speech Text Training for the 2021 IWSLT multilingual speech translation + +This directory contains the code from paper ["FST: the FAIR Speech Translation System for the IWSLT21 Multilingual Shared Task"](https://arxiv.org/pdf/2107.06959.pdf). + +## Prepare Data +#### Download files +- Sentence piece model [spm.model](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/spm.model) +- Dictionary [tgt_dict.txt](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/dict.txt) +- Config [config.yaml](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/config.yaml) + +#### Prepare +- [Please follow the data preparation in speech-to-text](https://github.com/pytorch/fairseq/blob/main/examples/speech_to_text/docs/mtedx_example.md) + + + +## Training + +#### Download pretrained models +- [Pretrained mbart model](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/mbart.pt) +- [Pretrained w2v model](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/xlsr_53_56k.pt) + + +#### Training scripts + +```bash +python train.py ${MANIFEST_ROOT} \ + --save-dir ${save_dir} \ + --user-dir examples/speech_text_joint_to_text \ + --train-subset train_es_en_tedx,train_es_es_tedx,train_fr_en_tedx,train_fr_es_tedx,train_fr_fr_tedx,train_it_it_tedx,train_pt_en_tedx,train_pt_pt_tedx \ + --valid-subset valid_es_en_tedx,valid_es_es_tedx,valid_es_fr_tedx,valid_es_it_tedx,valid_es_pt_tedx,valid_fr_en_tedx,valid_fr_es_tedx,valid_fr_fr_tedx,valid_fr_pt_tedx,valid_it_en_tedx,valid_it_es_tedx,valid_it_it_tedx,valid_pt_en_tedx,valid_pt_es_tedx,valid_pt_pt_tedx \ + --config-yaml config.yaml --ddp-backend no_c10d \ + --num-workers 2 --task speech_text_joint_to_text \ + --criterion guided_label_smoothed_cross_entropy_with_accuracy \ + --label-smoothing 0.3 --guide-alpha 0.8 \ + --disable-text-guide-update-num 5000 --arch dualinputxmtransformer_base \ + --max-tokens 500000 --max-sentences 3 --max-tokens-valid 800000 \ + --max-source-positions 800000 --enc-grad-mult 2.0 \ + --attentive-cost-regularization 0.02 --optimizer adam \ + --clip-norm 1.0 --log-format simple --log-interval 200 \ + --keep-last-epochs 5 --seed 1 \ + --w2v-path ${w2v_path} \ + --load-pretrained-mbart-from ${mbart_path} \ + --max-update 1000000 --update-freq 4 \ + --skip-invalid-size-inputs-valid-test \ + --skip-encoder-projection --save-interval 1 \ + --attention-dropout 0.3 --mbart-dropout 0.3 \ + --finetune-w2v-params all --finetune-mbart-decoder-params all \ + --finetune-mbart-encoder-params all --stack-w2v-mbart-encoder \ + --drop-w2v-layers 12 --normalize \ + --lr 5e-05 --lr-scheduler inverse_sqrt --warmup-updates 5000 +``` + +## Evaluation +```bash +python ./fairseq_cli/generate.py + ${MANIFEST_ROOT} \ + --task speech_text_joint_to_text \ + --user-dir ./examples/speech_text_joint_to_text \ + --load-speech-only --gen-subset test_es_en_tedx \ + --path ${model} \ + --max-source-positions 800000 \ + --skip-invalid-size-inputs-valid-test \ + --config-yaml config.yaml \ + --infer-target-lang en \ + --max-tokens 800000 \ + --beam 5 \ + --results-path ${RESULTS_DIR} \ + --scoring sacrebleu +``` +The trained model can be downloaded [here](https://dl.fbaipublicfiles.com/joint_speech_text_4_s2t/iwslt/iwslt_data/checkpoint17.pt) + +|direction|es_en|fr_en|pt_en|it_en|fr_es|pt_es|it_es|es_es|fr_fr|pt_pt|it_it| +|---|---|---|---|---|---|---|---|---|---|---|---| +|BLEU|31.62|36.93|35.07|27.12|38.87|35.57|34.13|74.59|74.64|70.84|69.76| diff --git a/fairseq/examples/speech_text_joint_to_text/models/__init__.py b/fairseq/examples/speech_text_joint_to_text/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7a394c7e4f25bfef8603596ca3629e65ca7b0d8b --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/models/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + +for file in os.listdir(os.path.dirname(__file__)): + if file.endswith(".py") and not file.startswith("_"): + model_name = file[: file.find(".py")] + importlib.import_module( + "examples.speech_text_joint_to_text.models." + model_name + ) diff --git a/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputtransformer.py b/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputtransformer.py new file mode 100644 index 0000000000000000000000000000000000000000..7970a3c71401b4835ba09158ea06134418afa065 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputtransformer.py @@ -0,0 +1,1090 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from collections import namedtuple + +import torch +import torch.nn as nn +from fairseq import checkpoint_utils +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqDecoder, + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.fairseq_encoder import EncoderOut +from fairseq.models.speech_to_text import ( + TransformerDecoder, + S2TTransformerEncoder, +) +from fairseq.models.transformer import TransformerEncoder +from fairseq.modules import ( + TransformerEncoderLayer, + GradMultiply, + LayerNorm, +) + +logger = logging.getLogger(__name__) + + +class SpeechEoSEncoder(FairseqEncoder): + def __init__(self, encoder, eos_num, feat_dim, adapter_type="None", adapter_dim=0): + super().__init__(None) + self.encoder = encoder + self.eos_num = eos_num # downsampling rate for speech input feature + self.eos_emb = ( + nn.Parameter(torch.zeros(1, feat_dim), requires_grad=True) + if eos_num > 0 + else None + ) + self.adapter = self.add_adapter(adapter_type, adapter_dim) + + def add_adapter(self, adapter_type, adapter_dim): + def _make_identity(linear, eps=1e-5): + assert isinstance(linear, nn.Linear) + linear.weight.data.mul_(eps) + linear.weight.data.fill_diagonal_(1.0) + if linear.bias is not None: + linear.bias.data.mul_(eps) + + adapter = None + if adapter_type == "Linear": + assert adapter_dim > 0 + adapter = nn.Sequential( + nn.Linear(adapter_dim, adapter_dim), LayerNorm(adapter_dim) + ) + # initialize the adapter as identity matrix first + _make_identity(adapter[0]) + + elif adapter_type == "MLP": + assert adapter_dim > 0 + # assume the model is pre-norm model + adapter = nn.Sequential( + nn.Linear(adapter_dim, 2 * adapter_dim), + nn.ReLU(), + nn.Linear(2 * adapter_dim, adapter_dim), + LayerNorm(adapter_dim), + ) + _make_identity(adapter[0]) + _make_identity(adapter[2]) + return adapter + + def add_eos(self, src_tokens, src_lengths): + bsz, max_seq_len, fdim = src_tokens.size() + if self.eos_num > 0: + src_token_eos = torch.zeros( + [bsz, max_seq_len + self.eos_num, fdim], + dtype=src_tokens.dtype, + device=src_tokens.device, + ) + src_token_eos[:, :max_seq_len] = src_tokens + for bi in range(bsz): + src_token_eos[bi][ + src_lengths[bi] : src_lengths[bi] + self.eos_num + ] = self.eos_emb.expand(self.eos_num, fdim) + src_lengths = src_lengths + self.eos_num + src_tokens = src_token_eos + return src_tokens, src_lengths + + def apply_adapter(self, enc_out): + if self.adapter is None: + return enc_out + rst = self.adapter(enc_out.encoder_out) + if enc_out.encoder_padding_mask is not None: + rst.masked_fill_( + enc_out.encoder_padding_mask.transpose(0, 1).unsqueeze(-1), 0 + ) + return EncoderOut( + encoder_out=rst, + encoder_padding_mask=enc_out.encoder_padding_mask, + encoder_embedding=enc_out.encoder_embedding, + encoder_states=enc_out.encoder_states, + src_tokens=enc_out.src_tokens, + src_lengths=enc_out.src_lengths, + ) + + def forward(self, src_tokens, src_lengths=None, return_all_hiddens=False, **kwargs): + """ + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (B,) + """ + src_tokens, src_lengths = self.add_eos(src_tokens, src_lengths) + enc_out = self.encoder(src_tokens, src_lengths, return_all_hiddens) + enc_out = self.apply_adapter(enc_out) + return enc_out + + def reorder_encoder_out(self, encoder_out, new_order): + return self.encoder.reorder_encoder_out(encoder_out, new_order) + + +class DualInputEncoder(FairseqEncoder): + def __init__( + self, + args, + spch_encoder, + text_encoder, + dictionary, + cross_attentive_loss_before_last_layer=-1, + ): + super().__init__(dictionary) + + self.spch_encoder = spch_encoder + self.text_encoder = text_encoder + self.enc_grad_mult = args.enc_grad_mult + self.cross_attentive_loss_before_last_layer = ( + cross_attentive_loss_before_last_layer + ) + self.use_cross_attentive_loss = ( + False if cross_attentive_loss_before_last_layer <= -1 else True + ) + self.enc2_along_grad_mult = args.enc2_along_grad_mult + + @classmethod + def set_shared_layer(cls, share_level, src_layer, tgt_layer): + """ + share parameters from tgt_layer to src_layer + share_level: + 0: share everything + 1: share everything but different model + 2: share weight but not bias, layernorm + """ + if share_level == 0: + return tgt_layer + if isinstance(src_layer, nn.Linear): + return tgt_layer + if isinstance(src_layer, TransformerEncoderLayer): + assert src_layer.embed_dim == tgt_layer.embed_dim + assert src_layer.normalize_before == tgt_layer.normalize_before + if share_level == 1: + src_layer.fc1 = tgt_layer.fc1 + src_layer.fc2 = tgt_layer.fc2 + src_layer.self_attn = tgt_layer.self_attn + src_layer.final_layer_norm = tgt_layer.final_layer_norm + src_layer.self_attn_layer_norm = tgt_layer.self_attn_layer_norm + src_layer.layernorm_embedding = tgt_layer.layernorm_embedding + else: + src_layer.fc1.weight = tgt_layer.fc1.weight + src_layer.fc2.weight = tgt_layer.fc2.weight + src_layer.self_attn.k_proj.weight = tgt_layer.self_attn.k_proj.weight + src_layer.self_attn.v_proj.weight = tgt_layer.self_attn.v_proj.weight + src_layer.self_attn.q_proj.weight = tgt_layer.self_attn.q_proj.weight + src_layer.self_attn.out_proj.weight = ( + tgt_layer.self_attn.out_proj.weight + ) + else: + if share_level == 1: + return tgt_layer + return src_layer + + @classmethod + def build_spch_encoder(cls, args): + cfg = { + "input_feat_per_channel": args.input_feat_per_channel, + "input_channels": args.input_channels, + "conv_kernel_sizes": args.conv_kernel_sizes, + "conv_channels": args.conv_channels, + "encoder_embed_dim": args.encoder_embed_dim, + "encoder_ffn_embed_dim": args.encoder_ffn_embed_dim, + "encoder_layers": args.speech_encoder_layers, + "encoder_layerdrop": args.encoder_layerdrop, + "encoder_attention_heads": args.encoder_attention_heads, + "max_source_positions": args.max_source_positions, + "dropout": args.dropout, + "encoder_normalize_before": args.encoder_normalize_before, + "activation_dropout": args.activation_dropout, + "attention_dropout": args.attention_dropout, + "activation_fn": args.activation_fn, + "layernorm_embedding": args.layernorm_embedding, + "no_token_positional_embeddings": args.no_token_positional_embeddings, + "no_scale_embedding": args.no_scale_embedding, + "quant_noise_pq": args.quant_noise_pq, + "encoder_freezing_updates": 0, + } + model_args = namedtuple("args", cfg.keys())(*cfg.values()) + spch_encoder = S2TTransformerEncoder(model_args) + if args.add_speech_eos: + spch_encoder = SpeechEoSEncoder( + spch_encoder, + 2 * len(args.conv_kernel_sizes.split(",")), + args.input_feat_per_channel, + adapter_type=getattr(args, "speech_encoder_adapter_type", "None"), + adapter_dim=args.encoder_embed_dim, + ) + return spch_encoder + + @classmethod + def build_text_encoder(cls, args, src_dictionary, spch_encoder): + if args.encoder_shared_layers > 0: + mx_shared_layers = ( + args.speech_encoder_layers + if args.speech_encoder_layers < args.text_encoder_layers + else args.text_encoder_layers + ) + args.encoder_shared_layers = ( + args.encoder_shared_layers + if args.encoder_shared_layers <= mx_shared_layers + else mx_shared_layers + ) + cfg = { + "encoder_embed_dim": args.encoder_text_embed_dim, + "encoder_ffn_embed_dim": args.encoder_ffn_embed_dim, + "encoder_layers": args.text_encoder_layers, + "encoder_layerdrop": args.encoder_layerdrop, + "encoder_attention_heads": args.encoder_attention_heads, + "encoder_learned_pos": args.encoder_learned_pos, + "max_source_positions": args.max_source_positions, + "dropout": args.dropout, + "encoder_normalize_before": args.encoder_normalize_before, + "activation_dropout": args.activation_dropout, + "attention_dropout": args.attention_dropout, + "activation_fn": args.activation_fn, + "adaptive_input": args.adaptive_input, + "no_token_positional_embeddings": args.no_token_positional_embeddings, + "no_scale_embedding": args.no_scale_embedding, + "quant_noise_pq": args.quant_noise_pq, + } + model_args = namedtuple("args", cfg.keys())(*cfg.values()) + enc_emb = nn.Embedding( + len(src_dictionary), model_args.encoder_embed_dim, src_dictionary.pad() + ) + text_encoder = TransformerEncoder(model_args, src_dictionary, enc_emb) + if args.add_speech_eos: + spch_encoder = spch_encoder.encoder + if args.encoder_shared_layers > 0: + text_encoder.layer_norm = cls.set_shared_layer( + args.encoder_shared_layer_level, + text_encoder.layer_norm, + spch_encoder.layer_norm, + ) + for i, ly in enumerate( + spch_encoder.transformer_layers[-args.encoder_shared_layers :] + ): + ly_id = i + args.text_encoder_layers - args.encoder_shared_layers + assert isinstance(text_encoder.layers[ly_id], type(ly)) + text_encoder.layers[ly_id] = cls.set_shared_layer( + args.encoder_shared_layer_level, + text_encoder.layers[ly_id], + ly, + ) + return text_encoder + + def mult_rst_grad(self, rst, ratio): + assert isinstance(rst, dict) # instead of EncoderOut + assert len(rst["encoder_out"]) == 1 + rst["encoder_out"][0] = GradMultiply.apply(rst["encoder_out"][0], ratio) + return rst + + def process_attentive_loss_states(self, rst, interstates): + assert isinstance(rst, dict) # instead of EncoderOut + rst["encoder_states"] = interstates + return rst + + def forward( + self, + src_tokens, + src_lengths=None, + src_txt_tokens=None, + src_txt_lengths=None, + **kwargs + ): + """ + Args: + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (speech) (B,) + src_txt_tokens: padded tensor (B, T) + src_txt_lengths: tensor of original lengths of input utterances (text) (B,) + """ + # src_tokens only: inference + # src_tokens, src_lengths: speech only training + # src_txt_tokens, src_txt_lengths: text only training + # all valid: speech + text training + + if src_tokens is None and src_txt_tokens is None: + raise ValueError( + "src_tokens and src_txt_tokens cannot be None at the same time" + ) + ret1 = None + ret2 = None + return_all_hiddens = False + if src_tokens is not None: + if ( + self.use_cross_attentive_loss and src_txt_tokens is not None + ): # remove self.training so we can get attn score during validation step + return_all_hiddens = True + ret1 = self.spch_encoder( + src_tokens, src_lengths, return_all_hiddens=return_all_hiddens + ) + + if self.use_cross_attentive_loss and src_txt_tokens is not None: + assert self.cross_attentive_loss_before_last_layer < len( + ret1["encoder_states"] + ) + ret1 = self.process_attentive_loss_states( + ret1, + ret1["encoder_states"][ + -self.cross_attentive_loss_before_last_layer - 1 + ], + ) + + if src_txt_tokens is not None: + ret2 = self.text_encoder( + src_txt_tokens, src_txt_lengths, return_all_hiddens=return_all_hiddens + ) + if return_all_hiddens: + if self.cross_attentive_loss_before_last_layer == len( + self.text_encoder.layers + ): + text_embedding, _ = self.text_encoder.forward_embedding( + src_txt_tokens + ) + text_embedding = text_embedding.transpose(0, 1) + ret2 = self.process_attentive_loss_states(ret2, text_embedding) + else: + assert self.cross_attentive_loss_before_last_layer < len( + self.text_encoder.layers + ) + ret2 = self.process_attentive_loss_states( + ret2, + ret2["encoder_states"][ + -self.cross_attentive_loss_before_last_layer - 1 + ], + ) + + def merge_output(rst1, rst2): + if rst1 is None: + if not (self.enc2_along_grad_mult == 1.0 or self.training): + rst2 = self.mult_rst_grad(rst2, self.enc2_along_grad_mult) + return rst2 + if rst2 is None: + return rst1 + if self.enc_grad_mult != 1.0 and self.training: + rst1 = self.mult_rst_grad(rst1, self.enc_grad_mult) + rst2 = self.mult_rst_grad(rst2, self.enc_grad_mult) + rst = (rst1, rst2) + return rst + + return merge_output(ret1, ret2) + + def reorder_encoder_out(self, encoder_out, new_order): + assert self.training is False # used for inference only + return self.spch_encoder.reorder_encoder_out(encoder_out, new_order) + + +# TransformerMultiInputDecoder: take one or two encoder inputs +class TransformerMultiInputDecoder(FairseqDecoder): + def __init__( + self, + dictionary, + spch_decoder, + text_decoder, + compute_cross_attentive_loss=False, + cross_attentive_loss_with_norm=True, + cross_attentive_loss_reverse=False, + ): + + super().__init__(dictionary) + self.spch_decoder = spch_decoder + self.text_decoder = text_decoder + self.compute_cross_attentive_loss = compute_cross_attentive_loss + self.cross_attentive_loss_with_norm = cross_attentive_loss_with_norm + self.cross_attentive_loss_reverse = cross_attentive_loss_reverse + + @classmethod + def share_spchdecoder(cls, task_args, text_decoder, spch_decoder): + if task_args.decoder_shared_layer_level == 0: + return text_decoder + assert text_decoder.embed_tokens == spch_decoder.embed_tokens + spch_decoder.project_in_dim = text_decoder.project_in_dim + spch_decoder.embed_positions = text_decoder.embed_positions + spch_decoder.layernorm_embedding = text_decoder.layernorm_embedding + spch_decoder.project_out_dim = text_decoder.project_out_dim + spch_decoder.adaptive_softmax = text_decoder.adaptive_softmax + if task_args.decoder_shared_layer_level == 1: + spch_decoder.output_projection = text_decoder.output_projection + spch_decoder.layer_norm = text_decoder.layer_norm + else: # 2 + spch_decoder.output_projection.weight = ( + text_decoder.output_projection.weight + ) + for i, ly in enumerate(text_decoder.layers): + sly = spch_decoder.layers[i] + sly.self_attn = ly.self_attn + sly.self_attn_layer_norm = ly.self_attn_layer_norm + # sly.encoder_attn = ly.encoder_attn + if ( + task_args.decoder_shared_layer_level == 1 + ): # share everything, but under different models + sly.encoder_attn = ly.encoder_attn + sly.encoder_attn_layer_norm = ly.encoder_attn_layer_norm + sly.fc1 = ly.fc1 + sly.fc2 = ly.fc2 + sly.final_layer_norm = ly.final_layer_norm + else: # task_args.decoder_shared_layer_level == 2: #separated encoder_attn_layer_norm and bias + sly.encoder_attn.k_proj.weight = ly.encoder_attn.k_proj.weight + sly.encoder_attn.v_proj.weight = ly.encoder_attn.v_proj.weight + sly.encoder_attn.q_proj.weight = ly.encoder_attn.q_proj.weight + sly.encoder_attn.out_proj.weight = ly.encoder_attn.out_proj.weight + sly.fc1.weight = ly.fc1.weight + sly.fc2.weight = ly.fc2.weight + + return spch_decoder + + def cross_attentive_loss( + self, teacher_states, student_states, teacher_masking, student_masking, eps=1e-6 + ): + x = teacher_states.transpose(0, 1) # from T X B X D to B X T X D + y = student_states.transpose(0, 1) + if self.cross_attentive_loss_with_norm: + x = x / (x.norm(dim=2, keepdim=True) + eps) + y = y / (y.norm(dim=2, keepdim=True) + eps) + dim = x.size(-1) + # lengths: batch X seqLen + sim_scores_xy = torch.bmm(x, y.transpose(1, 2)) # batch X lenx X leny ] + if y.dtype == torch.float16: + sim_scores_xy = sim_scores_xy.float() + y = y.float() + x = x.float() + if teacher_masking != []: + assert len(teacher_masking) == 1 + sim_scores_xy = sim_scores_xy.masked_fill( + teacher_masking[0].unsqueeze(-1), float("-inf") + ) + if student_masking != []: + sim_scores_xy = sim_scores_xy.masked_fill( + student_masking[0].unsqueeze(1), float("-inf") + ) + # do masking + y_weights = utils.softmax(sim_scores_xy, dim=-1) + if teacher_masking != []: + y_weights = y_weights.masked_fill(teacher_masking[0].unsqueeze(-1), 0) + x_reconstruct_from_y = torch.bmm(y_weights, y) + + sim_scores_xx = torch.bmm(x, x.transpose(1, 2)) # batch X lenx X lenx ] + x_weights = utils.softmax(sim_scores_xx, dim=-1) + if teacher_masking != []: + x_weights = x_weights.masked_fill(teacher_masking[0].unsqueeze(-1), 0) + + # no gradient for teacher state + x_reconstruct_from_x = torch.bmm(x_weights, x).detach() + cost = (x_reconstruct_from_x - x_reconstruct_from_y).norm(dim=2) + if teacher_masking != []: + cost = cost.masked_fill(teacher_masking[0], 0) + + if not self.cross_attentive_loss_with_norm: + cost = cost / dim + return cost + + def forward( + self, + prev_output_tokens, + encoder_out, + incremental_state=None, + has_txt_input=False, + **kwargs + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for input feeding/teacher forcing. If there are + two or more input during training, they will share the same prev_output_tokens + encoder_out (tuple[Tensor]): output from the encoder, used for + encoder-side attention. It will be tuple if there are more inputs, but a tensor + if only one input + incremental_state ([dict]): dictionary used for storing state during + :ref:`Incremental decoding`. It is only valid for inference, only from single + input + Returns: + tuple: + - the last decoder layer's output of shape `(batch, tgt_len, + vocab)`. If there are N inputs, batch will be N bigger than a single input + - the last decoder layer's attention weights of shape `(batch, + tgt_len, src_len)` + """ + assert not isinstance(encoder_out, EncoderOut) + if isinstance(encoder_out, tuple): # training with mulitple input + rst = [] + assert len(encoder_out) == 2 + for i, eo in enumerate(encoder_out): + assert incremental_state is None + if i == 0: + rst.append( + self.spch_decoder(prev_output_tokens, eo, incremental_state) + ) + else: + rst.append( + self.text_decoder(prev_output_tokens, eo, incremental_state) + ) + dec_out = torch.cat([r[0] for r in rst], dim=0) + attn_cost = None + if self.compute_cross_attentive_loss: + assert isinstance(encoder_out[0], dict) + if self.cross_attentive_loss_reverse: + attn_cost = self.cross_attentive_loss( + teacher_states=encoder_out[1]["encoder_states"], # text_states + student_states=encoder_out[0]["encoder_states"], # spch_states + teacher_masking=encoder_out[1]["encoder_padding_mask"], + student_masking=encoder_out[0]["encoder_padding_mask"], + ) + else: + attn_cost = self.cross_attentive_loss( + teacher_states=encoder_out[0]["encoder_states"], # spch_states + student_states=encoder_out[1]["encoder_states"], # text_states + teacher_masking=encoder_out[0]["encoder_padding_mask"], + student_masking=encoder_out[1]["encoder_padding_mask"], + ) + + return (dec_out, {"attn_cost": attn_cost}) + else: # inference or training with one input + if has_txt_input: + return self.text_decoder( + prev_output_tokens, encoder_out, incremental_state + ) + return self.spch_decoder(prev_output_tokens, encoder_out, incremental_state) + + +# Note: +# dual input transformer: +# encoder: S2TTransformerEncoder for speech + TransformerEncoder for text +# decoder: TransformerDecoder for text +@register_model("dual_input_s2t_transformer") +class DualInputS2TTransformerModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + self.num_updates = 0 + + def max_positions(self): + return None # it is provided in task + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # encoder 1: S2TTransformerEncoder for speech + parser.add_argument( + "--conv-kernel-sizes", + type=str, + metavar="N", + help="kernel sizes of Conv1d subsampling layers", + ) + parser.add_argument( + "--conv-channels", + type=int, + metavar="N", + help="# of channels in Conv1d subsampling layers", + ) + parser.add_argument( + "--enc-output-dim", + type=int, + metavar="N", + help=""" + encoder output dimension, can be None. If specified, projecting the + transformer output to the specified dimension""", + ) + # standard Transformer + parser.add_argument( + "--activation-fn", + type=str, + default="relu", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--activation-dropout", + "--relu-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN.", + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-text-embed-dim", + type=int, + metavar="N", + help="encoder text embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads", + ) + parser.add_argument( + "--layernorm-embedding", + action="store_true", + help="add layernorm to embedding", + ) + parser.add_argument( + "--no-scale-embedding", + action="store_true", + help="if True, dont scale embeddings", + ) + # non-standard transformer parameters + parser.add_argument( + "--speech-encoder-layers", + type=int, + metavar="N", + help="num speech encoder layers", + ) + parser.add_argument( + "--text-encoder-layers", + type=int, + metavar="N", + help="num text encoder layers", + ) + parser.add_argument( + "--encoder-shared-layers", + type=int, + metavar="N", + help="num shared encoder layers", + ) + parser.add_argument( + "--encoder-shared-layer-level", + type=int, + metavar="N", + default=0, + choices=[0, 1, 2], + help="share layer level 0: all share 1: all share with separate model 2: share weight but not bias and layernorm", + ) + + parser.add_argument( + "--decoder-shared-layer-level", + default=0, + choices=[0, 1, 2], + type=int, + metavar="N", + help="0: share everything; 1: share everything with different model 2: no share layer_norm and bias", + ) + ### + parser.add_argument( + "--text-input-cost-ratio", + type=float, + default=1.0, + metavar="V", + help="text input cost ratio relative to speech input cost", + ) + parser.add_argument( + "--init-scale", + type=float, + default=1.0, + metavar="V", + help="scale the initial weight by given factor", + ) + parser.add_argument( + "--enc-grad-mult", + type=float, + metavar="V", + default=1.0, + help="multiply enc1 and enc2 gradient by V", + ) + parser.add_argument( + "--enc2-along-grad-mult", + type=float, + metavar="V", + default=1.0, + help="multiply enc2 gradient by V if only enc2 is used", + ) + parser.add_argument( + "--load-pretrain-encoder", + type=str, + default="", + metavar="EXPR", + help=""" path to the pretrained encoder """, + ) + parser.add_argument( + "--load-pretrain-speech-encoder", + type=str, + default="", + metavar="EXPR", + help=""" path to the pretrained speech encoder """, + ) + parser.add_argument( + "--load-pretrain-text-encoder", + type=str, + default="", + metavar="EXPR", + help=""" path to the pretrained text encoder """, + ) + parser.add_argument( + "--load-pretrain-text-encoder-last", + type=str, + default="", + metavar="EXPR", + help=""" path to the pretrained text encoder """, + ) + parser.add_argument( + "--load-pretrain-decoder", + type=str, + metavar="EXPR", + default="", + help=""" path to the pretrained encoder """, + ) + parser.add_argument( + "--add-speech-eos", + action="store_true", + help="add eos token at the end of input feature", + ) + parser.add_argument( + "--speech-encoder-adapter-type", + type=str, + metavar="EXPR", + default="None", + choices=["None", "Linear", "MLP"], + help="add speech encoder adapter", + ) + + @classmethod + def build_encoder(cls, args, task): + spch_encoder = DualInputEncoder.build_spch_encoder(args) + text_encoder = DualInputEncoder.build_text_encoder( + args, task.src_dict, spch_encoder + ) + cross_attentive_loss_before_last_layer = ( + 0 if getattr(args, "attentive_cost_regularization", 0.0) > 0.0 else -1 + ) + encoder = DualInputEncoder( + args, + spch_encoder, + text_encoder, + task.src_dict, + cross_attentive_loss_before_last_layer, + ) + if args.init_scale != 1.0: + with torch.no_grad(): + for param in encoder.parameters(): + param.data.mul_(args.init_scale) + if args.load_pretrain_text_encoder != "": + checkpoint_utils.load_pretrained_component_from_model( + text_encoder, args.load_pretrain_text_encoder + ) + if args.load_pretrain_speech_encoder != "": + if hasattr(spch_encoder, "encoder"): + checkpoint_utils.load_pretrained_component_from_model( + spch_encoder.encoder, args.load_pretrain_speech_encoder + ) + else: + checkpoint_utils.load_pretrained_component_from_model( + spch_encoder, args.load_pretrain_speech_encoder + ) + if ( + args.load_pretrain_text_encoder_last != "" + ): # if share encoder, speech encoder parameters will be used. + # It provides a chance to use pre-trained mt encoder instead + checkpoint_utils.load_pretrained_component_from_model( + text_encoder, args.load_pretrain_text_encoder_last + ) + + if args.load_pretrain_encoder != "": + checkpoint_utils.load_pretrained_component_from_model( + encoder, args.load_pretrain_encoder + ) + return encoder + + @classmethod + def build_decoder(cls, args, task): + dec_cfg = { + "decoder_layerdrop": args.decoder_layerdrop, + "share_decoder_input_output_embed": args.share_decoder_input_output_embed, + "decoder_embed_dim": args.decoder_embed_dim, + "max_target_positions": args.max_target_positions, + "dropout": args.dropout, + "encoder_learned_pos": args.encoder_learned_pos, + "decoder_learned_pos": args.decoder_learned_pos, + "layernorm_embedding": args.layernorm_embedding, + "decoder_normalize_before": args.decoder_normalize_before, + "activation_dropout": args.activation_dropout, + "attention_dropout": args.attention_dropout, + "decoder_ffn_embed_dim": args.decoder_ffn_embed_dim, + "decoder_layers": args.decoder_layers, + "decoder_attention_heads": args.decoder_attention_heads, + "decoder_output_dim": args.decoder_embed_dim, + "no_scale_embedding": args.no_scale_embedding, + "adaptive_input": args.adaptive_input, + "quant_noise_pq": args.quant_noise_pq, + "adaptive_softmax_cutoff": args.adaptive_softmax_cutoff, + "tie_adaptive_weights": args.tie_adaptive_weights, + "no_token_positional_embeddings": args.no_token_positional_embeddings, + } + dec_cfg = namedtuple("args", dec_cfg.keys())(*dec_cfg.values()) + dec_emb = nn.Embedding( + len(task.target_dictionary), + args.decoder_embed_dim, + task.target_dictionary.pad(), + ) + compute_cross_attentive_loss = ( + True if getattr(args, "attentive_cost_regularization", 0.0) > 0.0 else False + ) + cross_attentive_loss_without_norm = getattr( + args, "attentive_cost_without_normalize", False + ) + cross_attentive_loss_reverse = ( + False # getattr(args, "attentive_cost_reverse", False) + ) + + text_decoder = TransformerDecoder(dec_cfg, task.target_dictionary, dec_emb) + spch_decoder = TransformerDecoder(dec_cfg, task.target_dictionary, dec_emb) + spch_decoder = TransformerMultiInputDecoder.share_spchdecoder( + args, text_decoder, spch_decoder + ) + decoder = TransformerMultiInputDecoder( + dictionary=task.target_dictionary, + spch_decoder=spch_decoder, + text_decoder=text_decoder, + compute_cross_attentive_loss=compute_cross_attentive_loss, + cross_attentive_loss_with_norm=True + if not cross_attentive_loss_without_norm + else False, + cross_attentive_loss_reverse=cross_attentive_loss_reverse, + ) + if args.init_scale != 1.0: + with torch.no_grad(): + for param in decoder.parameters(): + param.data.mul_(args.init_scale) + if args.load_pretrain_decoder != "": + try: + checkpoint_utils.load_pretrained_component_from_model( + decoder, args.load_pretrain_decoder + ) + except RuntimeError: + checkpoint_utils.load_pretrained_component_from_model( + decoder.text_decoder, args.load_pretrain_decoder + ) + if args.decoder_shared_layer_level > 0: + checkpoint_utils.load_pretrained_component_from_model( + decoder.spch_decoder, args.load_pretrain_decoder + ) + + return decoder + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted + # (in case there are any new ones) + dualinputs2ttransformer_base(args) + + encoder = cls.build_encoder(args, task) + decoder = cls.build_decoder(args, task) + return cls(encoder, decoder) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = super().get_normalized_probs(net_output, log_probs, sample) + lprobs.batch_first = True + return lprobs + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + super().set_num_updates(num_updates) + self.num_updates = num_updates + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + use_encoder_outputs=False, + src_txt_tokens=None, + src_txt_lengths=None, + mode="sup_speech", + **kwargs + ): + """ + Run the forward pass for an encoder-decoder model. + + First feed a batch of source tokens through the encoder. Then, feed the + encoder output and previous decoder outputs (i.e., teacher forcing) to + the decoder to produce the next outputs:: + + encoder_out = self.encoder(src_tokens, src_lengths) + return self.decoder(prev_output_tokens, encoder_out) + + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (LongTensor): source sentence lengths of shape `(batch)` + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + mode = 'sup_speech' or 'text' + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + if mode == "text": + assert src_txt_tokens is None + src_txt_tokens = src_tokens + src_txt_lengths = src_lengths + src_tokens = None + src_lengths = None + encoder_out = self.encoder( + src_tokens, + src_lengths=src_lengths, + src_txt_tokens=src_txt_tokens, + src_txt_lengths=src_txt_lengths, + **kwargs + ) + has_txt_input = True if src_txt_tokens is not None else False + decoder_out = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + has_txt_input=has_txt_input, + **kwargs + ) + if use_encoder_outputs: + return decoder_out, encoder_out + return decoder_out + + +@register_model_architecture( + "dual_input_s2t_transformer", "dualinputs2ttransformer_base" +) +def dualinputs2ttransformer_base(args): + args.encoder_freezing_updates = getattr(args, "encoder_freezing_updates", 0) + # Convolutional subsampler + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.conv_kernel_sizes = getattr(args, "conv_kernel_sizes", "5,5") + args.conv_channels = getattr(args, "conv_channels", 1024) + # Transformer + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_text_embed_dim = getattr( + args, "encoder_text_embed_dim", args.encoder_embed_dim + ) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.encoder_layerdrop = getattr(args, "encoder_layerdrop", 0) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", args.dropout) + args.activation_dropout = getattr(args, "activation_dropout", args.dropout) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + + args.speech_encoder_layers = getattr(args, "speech_encoder_layers", 10) + args.text_encoder_layers = getattr(args, "text_encoder_layers", 6) + args.encoder_shared_layers = getattr(args, "encoder_shared_layers", 0) + args.decoder_layers = getattr(args, "decoder_layers", 6) + + args.add_speech_eos = getattr(args, "add_speech_eos", False) + + +@register_model_architecture("dual_input_s2t_transformer", "dualinputs2ttransformer_s") +def dualinputs2ttransformer_s(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 256 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.dropout = getattr(args, "dropout", 0.1) + args.speech_encoder_layers = getattr(args, "speech_encoder_layers", 7) + args.text_encoder_layers = getattr(args, "text_encoder_layers", 7) + args.decoder_layers = getattr(args, "decoder_layers", 7) + dualinputs2ttransformer_base(args) + + +@register_model_architecture("dual_input_s2t_transformer", "dualinputs2ttransformer_m") +def dualinputs2ttransformer_m(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 512 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.dropout = getattr(args, "dropout", 0.15) + args.speech_encoder_layers = getattr(args, "speech_encoder_layers", 10) + args.text_encoder_layers = getattr(args, "text_encoder_layers", 6) + args.decoder_layers = getattr(args, "decoder_layers", 6) + dualinputs2ttransformer_base(args) + + +@register_model_architecture("dual_input_s2t_transformer", "dualinputs2ttransformer_b") +def dualinputs2ttransformer_b(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 768 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 12) + args.dropout = getattr(args, "dropout", 0.15) + args.speech_encoder_layers = getattr(args, "speech_encoder_layers", 12) + args.text_encoder_layers = getattr(args, "text_encoder_layers", 6) + args.decoder_layers = getattr(args, "decoder_layers", 6) + dualinputs2ttransformer_base(args) + + +@register_model_architecture("dual_input_s2t_transformer", "dualinputs2ttransformer_l") +def dualinputs2ttransformer_l(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.2) + args.speech_encoder_layers = getattr(args, "speech_encoder_layers", 12) + args.text_encoder_layers = getattr(args, "text_encoder_layers", 6) + args.decoder_layers = getattr(args, "decoder_layers", 6) + dualinputs2ttransformer_base(args) diff --git a/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputxmtransformer.py b/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputxmtransformer.py new file mode 100644 index 0000000000000000000000000000000000000000..50683e6d7c8c0db5b8f019e5f7f5fb8c6dfd9f66 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/models/s2t_dualinputxmtransformer.py @@ -0,0 +1,585 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import copy + +import torch.nn as nn +from fairseq import checkpoint_utils +from fairseq import utils +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq.models import ( + register_model, + register_model_architecture, + FairseqEncoder, +) +from fairseq.models.speech_to_text import XMTransformerModel, Wav2VecEncoderWithAdaptor +from fairseq.models.speech_to_text.xm_transformer import ( + set_default_adaptor_args, + set_default_w2v_encoder_args, +) +from fairseq.models.transformer import TransformerEncoder, TransformerDecoder +from fairseq.models.wav2vec import TransformerSentenceEncoderLayer +from fairseq.utils import safe_hasattr + +from .s2t_dualinputtransformer import ( + DualInputS2TTransformerModel, + TransformerMultiInputDecoder, + DualInputEncoder, +) + + +class TransformerSentenceEncoderLayerStd(TransformerSentenceEncoderLayer): + def __init__(self, sent_enc_layer): + super(TransformerSentenceEncoderLayer, self).__init__() + self.embedding_dim = sent_enc_layer.embedding_dim + self.dropout = sent_enc_layer.dropout + self.activation_dropout = sent_enc_layer.activation_dropout + + # Initialize blocks + self.activation_fn = sent_enc_layer.activation_fn + self.self_attn = sent_enc_layer.self_attn + + self.dropout1 = sent_enc_layer.dropout1 + self.dropout2 = sent_enc_layer.dropout2 + self.dropout3 = sent_enc_layer.dropout3 + + self.layer_norm_first = sent_enc_layer.layer_norm_first + + # layer norm associated with the self attention layer + self.self_attn_layer_norm = sent_enc_layer.self_attn_layer_norm + self.fc1 = sent_enc_layer.fc1 + self.fc2 = sent_enc_layer.fc2 + + # layer norm associated with the position wise feed-forward NN + self.final_layer_norm = sent_enc_layer.final_layer_norm + + def forward( + self, + x, + self_attn_mask=None, + self_attn_padding_mask=None, + need_weights=None, + att_args=None, + ): + x, attn = super().forward( + x, self_attn_mask, self_attn_padding_mask, need_weights, att_args + ) + return x + + +# TODO retire SharedEncoder +class SharedEncoder(FairseqEncoder): + def __init__(self, wav2vec_enc, mbart_enc, adaptor, shared_layers): + super().__init__(None) + self.w2v_encoder = wav2vec_enc + self.shared_layers = self.w2v_encoder.w2v_model.encoder.layers[-shared_layers:] + self.w2v_encoder.w2v_model.encoder.layers = ( + self.w2v_encoder.w2v_model.encoder.layers[:-shared_layers] + ) + self.adaptor = adaptor + if self.shared_layers[-1].layer_norm_first: + self.final_layer_norm = mbart_enc.layer_norm + else: + mbart_enc.layer_norm = None + self.final_layer_norm = None + shared_layer_from = len(mbart_enc.layers) - shared_layers + if shared_layer_from < 0: + shared_layer_from = 0 + for layer_id, layer in enumerate(self.shared_layers): + mbart_enc.layers[ + shared_layer_from + layer_id + ] = TransformerSentenceEncoderLayerStd(layer) + + def forward(self, src_tokens, src_lengths=None, **kwargs): + padding_mask = lengths_to_padding_mask(src_lengths) + if not padding_mask.any(): + padding_mask = None + + out = self.w2v_encoder.forward(src_tokens, padding_mask, tbc=True) + x = out["encoder_out"] + enc_padding_mask = None + if out["encoder_padding_mask"] is not None: + enc_padding_mask = out["encoder_padding_mask"].transpose( + 0, 1 + ) # T X B --> B X T + + x, enc_padding_mask = self.adaptor(x, enc_padding_mask) + for layer in self.shared_layers: + x, _ = layer(x, enc_padding_mask) + if self.final_layer_norm is not None: + x = self.final_layer_norm(x) + + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [enc_padding_mask] + if enc_padding_mask is not None + else [], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": [], # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + } + + +class StackedWav2VecEncoderWithAdaptor(FairseqEncoder): + def __init__( + self, + wav2vec_enc, + mbart_enc_layers, + mbart_layer_norm, + adaptor, + drop_w2v_layers=0, + ): + super().__init__(None) + self.w2v_encoder = wav2vec_enc + self.adaptor = adaptor + self.mbart_encoder_layers = mbart_enc_layers + self.final_layer_norm = mbart_layer_norm + if drop_w2v_layers > 0: + self.w2v_encoder.w2v_model.encoder.layers = ( + self.w2v_encoder.w2v_model.encoder.layers[:-drop_w2v_layers] + ) + + def forward(self, src_tokens, src_lengths=None, return_all_hiddens=False, **kwargs): + padding_mask = lengths_to_padding_mask(src_lengths) + if not padding_mask.any(): + padding_mask = None + + out = self.w2v_encoder.forward(src_tokens, padding_mask, tbc=True) + x = out["encoder_out"] + enc_padding_mask = None + if out["encoder_padding_mask"] is not None: + enc_padding_mask = out["encoder_padding_mask"].transpose( + 0, 1 + ) # T X B --> B X T + + x, enc_padding_mask = self.adaptor(x, enc_padding_mask) + encoder_states = [] + for layer in self.mbart_encoder_layers: + x = layer(x, enc_padding_mask) + if return_all_hiddens: + encoder_states.append(x) + if self.final_layer_norm is not None: + x = self.final_layer_norm(x) + + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [enc_padding_mask] + if enc_padding_mask is not None + else [], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + } + + def reorder_encoder_out(self, encoder_out, new_order): + new_encoder_out = ( + [] + if len(encoder_out["encoder_out"]) == 0 + else [x.index_select(1, new_order) for x in encoder_out["encoder_out"]] + ) + + new_encoder_padding_mask = ( + [] + if len(encoder_out["encoder_padding_mask"]) == 0 + else [ + x.index_select(0, new_order) + for x in encoder_out["encoder_padding_mask"] + ] + ) + + new_encoder_embedding = ( + [] + if len(encoder_out["encoder_embedding"]) == 0 + else [ + x.index_select(0, new_order) for x in encoder_out["encoder_embedding"] + ] + ) + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], # B x T + "src_lengths": [], # B x 1 + } + + +# Note: +# dual input transformer: +# encoder: wav2vec for speech + mbart encoder for text +# decoder: mbart decoder for text +@register_model("dual_input_xm_transformer") +class DualInputXMTransformerModel(DualInputS2TTransformerModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # wav2vec encoder + Wav2VecEncoderWithAdaptor.add_args(parser) + # add_decoder_args(parser) + # mbart Transformer + parser.add_argument( + "--activation-fn", + type=str, + default="relu", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + + parser.add_argument( + "--mbart-dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--mbart-attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--mbart-activation-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN.", + ) + + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="num encoder layers" + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads", + ) + parser.add_argument( + "--decoder-normalize-before", + action="store_true", + help="apply layernorm before each decoder block", + ) + parser.add_argument( + "--layernorm-embedding", + action="store_true", + help="add layernorm to embedding", + ) + parser.add_argument( + "--no-scale-embedding", + action="store_true", + help="if True, dont scale embeddings", + ) + parser.add_argument( + "--load-pretrained-mbart-from", + type=str, + metavar="STR", + help="model to take text encoder decoder weights from (for initialization)", + ) + # parser.add_argument("--finetune-w2v-params", type=str, metavar="STR", + # help="comma-separated param strings to finetune.") + parser.add_argument( + "--finetune-mbart-decoder-params", + type=str, + metavar="STR", + help="comma-separated param strings to finetune.", + ) + parser.add_argument( + "--finetune-mbart-encoder-params", + type=str, + metavar="STR", + help="comma-separated param strings to finetune.", + ) + parser.add_argument( + "--skip-encoder-projection", + action="store_true", + help="skip the projection layer in encoder", + ) + + parser.add_argument( + "--enc-grad-mult", + type=float, + metavar="V", + default=1.0, + help="multiply enc1 and enc2 gradient by V", + ) + parser.add_argument( + "--enc2-along-grad-mult", + type=float, + metavar="V", + default=1.0, + help="multiply enc2 gradient by V if only enc2 is used", + ) + parser.add_argument( + "--text-input-cost-ratio", + type=float, + default=1.0, + metavar="V", + help="text input cost ratio relative to speech input cost", + ) + parser.add_argument( + "--stack-w2v-mbart-encoder", + action="store_true", + help="stack w2v and mbart encoder", + ) + parser.add_argument( + "--stack-w2v-mbart-nonorm-encoder", + action="store_true", + help="stack w2v and mbart encoder", + ) + parser.add_argument( + "--no-final-norm-decoder", action="store_true", help="no layer norm" + ) + parser.add_argument( + "--drop-w2v-layers", + type=int, + default=0, + metavar="N", + help="drop w2v encoder layers", + ) + + parser.add_argument( + "--share-w2v-text-encoder", + action="store_true", + help="share w2v encoder layers with text encoder", + ) + parser.add_argument( + "--shared-w2v-layers", + type=int, + default=0, + metavar="N", + help="shared encoder layers from w2v encoder", + ) + + @classmethod + def build_encoder(cls, args, task): + _args = copy.deepcopy(args) + _args.dropout = args.mbart_dropout + _args.attention_dropout = args.mbart_attention_dropout + _args.activation_dropout = args.mbart_activation_dropout + _args.max_source_positions = 1024 + enc_emb = nn.Embedding( + len(task.src_dict), _args.encoder_embed_dim, task.src_dict.pad() + ) + text_encoder = TransformerEncoder(_args, task.src_dict, enc_emb) + spch_encoder = Wav2VecEncoderWithAdaptor(args) + if getattr(args, "load_pretrained_mbart_from", None): + text_encoder = checkpoint_utils.load_pretrained_component_from_model( + component=text_encoder, checkpoint=args.load_pretrained_mbart_from + ) + if getattr(args, "stack_w2v_mbart_encoder", False): + assert getattr(args, "share_w2v_text_encoder", False) is False + spch_encoder = StackedWav2VecEncoderWithAdaptor( + spch_encoder.w2v_encoder, + text_encoder.layers, + text_encoder.layer_norm, + spch_encoder.adaptor, + args.drop_w2v_layers, + ) + elif getattr(args, "stack_w2v_mbart_nonorm_encoder", False): + text_encoder.layer_norm = None + spch_encoder = StackedWav2VecEncoderWithAdaptor( + spch_encoder.w2v_encoder, + text_encoder.layers, + text_encoder.layer_norm, + spch_encoder.adaptor, + args.drop_w2v_layers, + ) + elif getattr(args, "share_w2v_text_encoder", False): + spch_encoder = SharedEncoder( + spch_encoder.w2v_encoder, + text_encoder, + spch_encoder.adaptor, + args.shared_w2v_layers, + ) + + for k, p in spch_encoder.named_parameters(): + # Freeze pretrained models by default + if safe_hasattr( + args, "finetune_w2v_params" + ) and XMTransformerModel.finetune_params(args.finetune_w2v_params, k): + p.requires_grad = True + else: + p.requires_grad = False + for k, p in text_encoder.named_parameters(): + # Freeze pretrained models by default + if safe_hasattr( + args, "finetune_mbart_encoder_params" + ) and XMTransformerModel.finetune_params( + args.finetune_mbart_encoder_params, k + ): + p.requires_grad = True + else: + p.requires_grad = False + cross_attentive_loss_before_last_layer = ( + 0 if getattr(args, "attentive_cost_regularization", 0.0) > 0.0 else -1 + ) + encoder = DualInputEncoder( + args, + spch_encoder, + text_encoder, + task.src_dict, + cross_attentive_loss_before_last_layer, + ) + return encoder + + @classmethod + def build_decoder(cls, args, task): + _args = copy.deepcopy(args) + _args.dropout = args.mbart_dropout + _args.attention_dropout = args.mbart_attention_dropout + _args.activation_dropout = args.mbart_activation_dropout + _args.max_target_positions = 1024 + dec_emb = nn.Embedding( + len(task.tgt_dict), _args.encoder_embed_dim, task.tgt_dict.pad() + ) + decoder = TransformerDecoder(_args, task.tgt_dict, dec_emb) + if getattr(args, "load_pretrained_mbart_from", None): + decoder = checkpoint_utils.load_pretrained_component_from_model( + component=decoder, checkpoint=args.load_pretrained_mbart_from + ) + if getattr(args, "no_final_norm_decoder", False): + decoder.layer_norm = None + for k, p in decoder.named_parameters(): + # Freeze pretrained models by default + if safe_hasattr( + args, "finetune_mbart_decoder_params" + ) and XMTransformerModel.finetune_params( + args.finetune_mbart_decoder_params, k + ): + p.requires_grad = True + else: + p.requires_grad = False + + compute_cross_attentive_loss = ( + True if getattr(args, "attentive_cost_regularization", 0.0) > 0.0 else False + ) + cross_attentive_loss_without_norm = getattr( + args, "attentive_cost_without_normalize", False + ) + cross_attentive_loss_reverse = ( + False # getattr(args, "attentive_cost_reverse", False) + ) + decoder = TransformerMultiInputDecoder( + dictionary=task.target_dictionary, + spch_decoder=decoder, + text_decoder=decoder, + compute_cross_attentive_loss=compute_cross_attentive_loss, + cross_attentive_loss_with_norm=True + if not cross_attentive_loss_without_norm + else False, + cross_attentive_loss_reverse=cross_attentive_loss_reverse, + ) + return decoder + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted + # (in case there are any new ones) + dualinputxmtransformer_base(args) + + encoder = cls.build_encoder(args, task) + decoder = cls.build_decoder(args, task) + return cls(encoder, decoder) + + +@register_model_architecture("dual_input_xm_transformer", "dualinputxmtransformer_base") +def dualinputxmtransformer_base(args): + # wav2vec encoder + set_default_w2v_encoder_args(args) + set_default_adaptor_args(args) + + # mbart model + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr( + args, "encoder_ffn_embed_dim", 4 * args.encoder_embed_dim + ) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.encoder_layerdrop = getattr(args, "encoder_layerdrop", 0) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4 * 1024) + args.decoder_layers = getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", True) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + + args.adaptive_input = getattr(args, "adaptive_input", False) + + args.mbart_attention_dropout = getattr(args, "mbart_attention_dropout", 0.0) + args.mbart_activation_dropout = getattr(args, "mbart_activation_dropout", 0.0) + args.mbart_dropout = getattr(args, "mbart_dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", True + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.layernorm_embedding = getattr(args, "layernorm_embedding", True) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.pooler_dropout = getattr(args, "pooler_dropout", 0.0) diff --git a/fairseq/examples/speech_text_joint_to_text/scripts/g2p_encode.py b/fairseq/examples/speech_text_joint_to_text/scripts/g2p_encode.py new file mode 100644 index 0000000000000000000000000000000000000000..9db779396f492e3f71b08d7b895beb81d8e46bc9 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/scripts/g2p_encode.py @@ -0,0 +1,191 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import itertools +import logging +import re +import time + +from g2p_en import G2p + +logger = logging.getLogger(__name__) + +FAIL_SENT = "FAILED_SENTENCE" + + +def parse(): + parser = argparse.ArgumentParser() + parser.add_argument("--data-path", type=str, required=True) + parser.add_argument("--out-path", type=str, required=True) + parser.add_argument("--lower-case", action="store_true") + parser.add_argument("--do-filter", action="store_true") + parser.add_argument("--use-word-start", action="store_true") + parser.add_argument("--dup-vowel", default=1, type=int) + parser.add_argument("--dup-consonant", default=1, type=int) + parser.add_argument("--no-punc", action="store_true") + parser.add_argument("--reserve-word", type=str, default="") + parser.add_argument( + "--reserve-first-column", + action="store_true", + help="first column is sentence id", + ) + ### + parser.add_argument("--parallel-process-num", default=1, type=int) + parser.add_argument("--logdir", default="") + args = parser.parse_args() + return args + + +def process_sent(sent, g2p, res_wrds, args): + sents = pre_process_sent(sent, args.do_filter, args.lower_case, res_wrds) + pho_seqs = [do_g2p(g2p, s, res_wrds, i == 0) for i, s in enumerate(sents)] + pho_seq = ( + [FAIL_SENT] + if [FAIL_SENT] in pho_seqs + else list(itertools.chain.from_iterable(pho_seqs)) + ) + if args.no_punc: + pho_seq = remove_punc(pho_seq) + if args.dup_vowel > 1 or args.dup_consonant > 1: + pho_seq = dup_pho(pho_seq, args.dup_vowel, args.dup_consonant) + if args.use_word_start: + pho_seq = add_word_start(pho_seq) + return " ".join(pho_seq) + + +def remove_punc(sent): + ns = [] + regex = re.compile("[^a-zA-Z0-9 ]") + for p in sent: + if (not regex.search(p)) or p == FAIL_SENT: + if p == " " and (len(ns) == 0 or ns[-1] == " "): + continue + ns.append(p) + return ns + + +def do_g2p(g2p, sent, res_wrds, is_first_sent): + if sent in res_wrds: + pho_seq = [res_wrds[sent]] + else: + pho_seq = g2p(sent) + if not is_first_sent: + pho_seq = [" "] + pho_seq # add space to separate + return pho_seq + + +def pre_process_sent(sent, do_filter, lower_case, res_wrds): + if do_filter: + sent = re.sub("-", " ", sent) + sent = re.sub("—", " ", sent) + if len(res_wrds) > 0: + wrds = sent.split() + wrds = ["SPLIT_ME " + w + " SPLIT_ME" if w in res_wrds else w for w in wrds] + sents = [x.strip() for x in " ".join(wrds).split("SPLIT_ME") if x.strip() != ""] + else: + sents = [sent] + if lower_case: + sents = [s.lower() if s not in res_wrds else s for s in sents] + return sents + + +def dup_pho(sent, dup_v_num, dup_c_num): + """ + duplicate phoneme defined as cmudict + http://www.speech.cs.cmu.edu/cgi-bin/cmudict + """ + if dup_v_num == 1 and dup_c_num == 1: + return sent + ns = [] + for p in sent: + ns.append(p) + if re.search(r"\d$", p): + for i in range(1, dup_v_num): + ns.append(f"{p}-{i}P") + elif re.search(r"\w", p): + for i in range(1, dup_c_num): + ns.append(f"{p}-{i}P") + return ns + + +def add_word_start(sent): + ns = [] + do_add = True + ws = "▁" + for p in sent: + if do_add: + p = ws + p + do_add = False + if p == " ": + do_add = True + else: + ns.append(p) + return ns + + +def load_reserve_word(reserve_word): + if reserve_word == "": + return [] + with open(reserve_word, "r") as fp: + res_wrds = [x.strip().split() for x in fp.readlines() if x.strip() != ""] + assert sum([0 if len(x) == 2 else 1 for x in res_wrds]) == 0 + res_wrds = dict(res_wrds) + return res_wrds + + +def process_sents(sents, args): + g2p = G2p() + out_sents = [] + res_wrds = load_reserve_word(args.reserve_word) + for sent in sents: + col1 = "" + if args.reserve_first_column: + col1, sent = sent.split(None, 1) + sent = process_sent(sent, g2p, res_wrds, args) + if args.reserve_first_column and col1 != "": + sent = f"{col1} {sent}" + out_sents.append(sent) + return out_sents + + +def main(): + args = parse() + out_sents = [] + with open(args.data_path, "r") as fp: + sent_list = [x.strip() for x in fp.readlines()] + if args.parallel_process_num > 1: + try: + import submitit + except ImportError: + logger.warn( + "submitit is not found and only one job is used to process the data" + ) + submitit = None + + if args.parallel_process_num == 1 or submitit is None: + out_sents = process_sents(sent_list, args) + else: + # process sentences with parallel computation + lsize = len(sent_list) // args.parallel_process_num + 1 + executor = submitit.AutoExecutor(folder=args.logdir) + executor.update_parameters(timeout_min=1000, cpus_per_task=4) + jobs = [] + for i in range(args.parallel_process_num): + job = executor.submit( + process_sents, sent_list[lsize * i : lsize * (i + 1)], args + ) + jobs.append(job) + is_running = True + while is_running: + time.sleep(5) + is_running = sum([job.done() for job in jobs]) < len(jobs) + out_sents = list(itertools.chain.from_iterable([job.result() for job in jobs])) + with open(args.out_path, "w") as fp: + fp.write("\n".join(out_sents) + "\n") + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_text_joint_to_text/tasks/__init__.py b/fairseq/examples/speech_text_joint_to_text/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d878278475fb24cf6b97d66d784e657567f5aa80 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/tasks/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + +for file in os.listdir(os.path.dirname(__file__)): + if file.endswith(".py") and not file.startswith("_"): + task_name = file[: file.find(".py")] + importlib.import_module("examples.speech_text_joint_to_text.tasks." + task_name) diff --git a/fairseq/examples/speech_text_joint_to_text/tasks/speech_text_joint.py b/fairseq/examples/speech_text_joint_to_text/tasks/speech_text_joint.py new file mode 100644 index 0000000000000000000000000000000000000000..f2b3966d2d6b103f3dc2ff170c12ab9663875684 --- /dev/null +++ b/fairseq/examples/speech_text_joint_to_text/tasks/speech_text_joint.py @@ -0,0 +1,372 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import logging +import os +from argparse import Namespace +from pathlib import Path + +import torch +from fairseq.data import ( + encoders, + Dictionary, + ResamplingDataset, + TransformEosLangPairDataset, + ConcatDataset, +) +from fairseq.data.iterators import GroupedEpochBatchIterator +from fairseq.data.audio.multi_modality_dataset import ( + MultiModalityDataset, + LangPairMaskDataset, + ModalityDatasetItem, +) +from fairseq.data.audio.speech_to_text_dataset import SpeechToTextDataset, SpeechToTextDatasetCreator +from fairseq.data.audio.speech_to_text_joint_dataset import ( + S2TJointDataConfig, + SpeechToTextJointDatasetCreator, +) +from fairseq.tasks import register_task +from fairseq.tasks.speech_to_text import SpeechToTextTask +from fairseq.tasks.translation import load_langpair_dataset + +logger = logging.getLogger(__name__) +LANG_TAG_TEMPLATE = "<lang:{}>" + + +@register_task("speech_text_joint_to_text") +class SpeechTextJointToTextTask(SpeechToTextTask): + """ + Task for joint training speech and text to text. + """ + + @classmethod + def add_args(cls, parser): + """Add task-specific arguments to the parser.""" + super(SpeechTextJointToTextTask, cls).add_args(parser) + ### + parser.add_argument( + "--parallel-text-data", + default="", + help="path to parallel text data directory", + ) + parser.add_argument( + "--max-tokens-text", + type=int, + metavar="N", + help="maximum tokens for encoder text input ", + ) + parser.add_argument( + "--max-positions-text", + type=int, + metavar="N", + default=400, + help="maximum tokens for per encoder text input ", + ) + parser.add_argument( + "--langpairs", + default=None, + metavar="S", + help='language pairs for text training, separated with ","', + ) + parser.add_argument( + "--speech-sample-ratio", + default=1, + type=float, + metavar="N", + help="Multiple Ratio for speech dataset with transcripts ", + ) + parser.add_argument( + "--text-sample-ratio", + default=1, + type=float, + metavar="N", + help="Multiple Ratio for text set ", + ) + parser.add_argument( + "--update-mix-data", + action="store_true", + help="use mixed data in one update when update-freq > 1", + ) + parser.add_argument( + "--load-speech-only", + action="store_true", + help="load speech data only", + ) + parser.add_argument( + "--mask-text-ratio", + type=float, + metavar="V", + default=0.0, + help="mask V source tokens for text only mode", + ) + parser.add_argument( + "--mask-text-type", + default="random", + choices=["random", "tail"], + help="mask text typed", + ) + parser.add_argument( + "--noise-token", + default="", + help="noise token for masking src text tokens if mask-text-ratio > 0", + ) + parser.add_argument( + "--infer-target-lang", + default="", + metavar="S", + help="target language for inference", + ) + + def __init__(self, args, src_dict, tgt_dict, infer_tgt_lang_id=None): + super().__init__(args, tgt_dict) + self.src_dict = src_dict + self.data_cfg = S2TJointDataConfig(Path(args.data) / args.config_yaml) + assert self.tgt_dict.pad() == self.src_dict.pad() + assert self.tgt_dict.eos() == self.src_dict.eos() + self.speech_only = args.load_speech_only + self._infer_tgt_lang_id = infer_tgt_lang_id + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task (e.g., load dictionaries).""" + data_cfg = S2TJointDataConfig(Path(args.data) / args.config_yaml) + tgt_dict_path = Path(args.data) / data_cfg.vocab_filename + src_dict_path = Path(args.data) / data_cfg.src_vocab_filename + if (not os.path.isfile(src_dict_path)) or (not os.path.isfile(tgt_dict_path)): + raise FileNotFoundError("Dict not found: {}".format(args.data)) + src_dict = Dictionary.load(src_dict_path.as_posix()) + tgt_dict = Dictionary.load(tgt_dict_path.as_posix()) + + print("| src dictionary: {} types".format(len(src_dict))) + print("| tgt dictionary: {} types".format(len(tgt_dict))) + + if args.parallel_text_data != "": + if not os.path.isabs(args.parallel_text_data): + args.parallel_text_data = os.path.join( + args.data, args.parallel_text_data + ) + + if args.langpairs is None: + raise Exception( + "Could not infer language pair, please provide it explicitly" + ) + infer_tgt_lang_id = None + if args.infer_target_lang != "" and data_cfg.prepend_tgt_lang_tag_no_change: + tgt_lang_tag = SpeechToTextDataset.LANG_TAG_TEMPLATE.format( + args.infer_target_lang + ) + infer_tgt_lang_id = tgt_dict.index(tgt_lang_tag) + assert infer_tgt_lang_id != tgt_dict.unk() + return cls(args, src_dict, tgt_dict, infer_tgt_lang_id=infer_tgt_lang_id) + + def load_langpair_dataset(self, prepend_tgt_lang_tag=False, sampling_alpha=1.0, epoch=0): + lang_pairs = [] + text_dataset = None + split = "train" + for lp in self.args.langpairs.split(","): + src, tgt = lp.split("-") + text_dataset = load_langpair_dataset( + self.args.parallel_text_data, + split, + src, + self.src_dict, + tgt, + self.tgt_dict, + combine=True, + dataset_impl=None, + upsample_primary=1, + left_pad_source=False, + left_pad_target=False, + max_source_positions=self.args.max_positions_text, + max_target_positions=self.args.max_target_positions, + load_alignments=False, + truncate_source=False, + ) + if prepend_tgt_lang_tag: + # TODO + text_dataset = TransformEosLangPairDataset( + text_dataset, + src_eos=self.src_dict.eos(), + tgt_bos=self.tgt_dict.eos(), # 'prev_output_tokens' starts with eos + new_tgt_bos=self.tgt_dict.index(LANG_TAG_TEMPLATE.format(tgt)), + ) + lang_pairs.append(text_dataset) + if len(lang_pairs) > 1: + if sampling_alpha != 1.0: + size_ratios = SpeechToTextDatasetCreator.get_size_ratios( + self.args.langpairs.split(","), + [len(s) for s in lang_pairs], + alpha=sampling_alpha, + ) + lang_pairs = [ + ResamplingDataset( + d, size_ratio=r, epoch=epoch, replace=(r >= 1.0) + ) + for d, r in zip(lang_pairs, size_ratios) + ] + return ConcatDataset(lang_pairs) + return text_dataset + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + return generator.generate( + models, + sample, + prefix_tokens=prefix_tokens, + constraints=constraints, + bos_token=self._infer_tgt_lang_id, + ) + + def build_src_tokenizer(self, args): + logger.info(f"src-pre-tokenizer: {self.data_cfg.src_pre_tokenizer}") + return encoders.build_tokenizer(Namespace(**self.data_cfg.src_pre_tokenizer)) + + def build_src_bpe(self, args): + logger.info(f"tokenizer: {self.data_cfg.src_bpe_tokenizer}") + return encoders.build_bpe(Namespace(**self.data_cfg.src_bpe_tokenizer)) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + is_train_split = split.startswith("train") + pre_tokenizer = self.build_tokenizer(self.args) + bpe_tokenizer = self.build_bpe(self.args) + src_pre_tokenizer = self.build_src_tokenizer(self.args) + src_bpe_tokenizer = self.build_src_bpe(self.args) + ast_dataset = SpeechToTextJointDatasetCreator.from_tsv( + self.args.data, + self.data_cfg, + split, + self.tgt_dict, + src_dict=None if self.speech_only else self.src_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + src_pre_tokenizer=src_pre_tokenizer, + src_bpe_tokenizer=src_bpe_tokenizer, + is_train_split=is_train_split, + epoch=epoch, + seed=self.args.seed, + ) + noise_token_id = -1 + text_dataset = None + if self.args.parallel_text_data != "" and is_train_split: + text_dataset = self.load_langpair_dataset( + self.data_cfg.prepend_tgt_lang_tag_no_change, + 1.0, + epoch=epoch, + ) + if self.args.mask_text_ratio > 0: + # add mask + noise_token_id = ( + self.src_dict.unk() + if self.args.noise_token == "" + else self.src_dict.index(self.args.noise_token) + ) + text_dataset = LangPairMaskDataset( + text_dataset, + src_bos=self.src_dict.bos(), + src_eos=self.src_dict.eos(), + noise_id=noise_token_id, + mask_ratio=self.args.mask_text_ratio, + mask_type=self.args.mask_text_type, + ) + + if text_dataset is not None: + mdsets = [ + ModalityDatasetItem( + "sup_speech", + ast_dataset, + (self.args.max_source_positions, self.args.max_target_positions), + self.args.max_tokens, + self.args.batch_size, + ), + ModalityDatasetItem( + "text", + text_dataset, + (self.args.max_positions_text, self.args.max_target_positions), + self.args.max_tokens_text + if self.args.max_tokens_text is not None + else self.args.max_tokens, + self.args.batch_size, + ), + ] + ast_dataset = MultiModalityDataset(mdsets) + self.datasets[split] = ast_dataset + + @property + def target_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self.tgt_dict + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary` (if applicable + for this task).""" + return None if self.speech_only else self.src_dict + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=0, + data_buffer_size=0, + disable_iterator_cache=False, + ): + + if not isinstance(dataset, MultiModalityDataset): + return super(SpeechTextJointToTextTask, self).get_batch_iterator( + dataset, + max_tokens, + max_sentences, + max_positions, + ignore_invalid_inputs, + required_batch_size_multiple, + seed, + num_shards, + shard_id, + num_workers, + epoch, + data_buffer_size, + disable_iterator_cache, + ) + + mult_ratio = [self.args.speech_sample_ratio, self.args.text_sample_ratio] + assert len(dataset.datasets) == 2 + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + batch_samplers = dataset.get_batch_samplers( + mult_ratio, required_batch_size_multiple, seed + ) + + # return a reusable, sharded iterator + epoch_iter = GroupedEpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_samplers=batch_samplers, + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + epoch=epoch, + mult_rate=1 if self.args.update_mix_data else max(self.args.update_freq), + buffer_size=data_buffer_size, + ) + self.dataset_to_epoch_iter[dataset] = {} # refresh it every epoch + return epoch_iter diff --git a/fairseq/examples/speech_to_text/README.md b/fairseq/examples/speech_to_text/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f639d300d342f8de1392c98bfc44ec8690188539 --- /dev/null +++ b/fairseq/examples/speech_to_text/README.md @@ -0,0 +1,77 @@ +# Speech-to-Text (S2T) Modeling + +[https://www.aclweb.org/anthology/2020.aacl-demo.6](https://www.aclweb.org/anthology/2020.aacl-demo.6.pdf) + +Speech recognition (ASR) and speech-to-text translation (ST) with fairseq. + +## Data Preparation +S2T modeling data consists of source speech features, target text and other optional information +(source text, speaker id, etc.). Fairseq S2T uses per-dataset-split TSV manifest files +to store these information. Each data field is represented by a column in the TSV file. + +Unlike text token embeddings, speech features (e.g. log mel-scale filter banks) are usually fixed +during model training and can be pre-computed. The manifest file contains the path to +either the feature file in NumPy format or the WAV/FLAC audio file. For the latter, +features will be extracted on-the-fly by fairseq S2T. Optionally, feature/audio files can be packed +into uncompressed ZIP files (then accessed via byte offset and length) to improve I/O performance. + +Fairseq S2T also employs a YAML file for data related configurations: tokenizer type and dictionary path +for the target text, feature transforms such as CMVN (cepstral mean and variance normalization) and SpecAugment, +temperature-based resampling, etc. + +## Model Training +Fairseq S2T uses the unified `fairseq-train` interface for model training. It requires arguments `--task speech_to_text`, + `--arch <model architecture in fairseq.models.speech_to_text.*>` and `--config-yaml <config YAML filename>`. + +## Inference & Evaluation +Fairseq S2T uses the unified `fairseq-generate`/`fairseq-interactive` interface for inference and evaluation. It +requires arguments `--task speech_to_text` and `--config-yaml <config YAML filename>`. The interactive console takes +audio paths (one per line) as inputs. + + +## Examples +- [Speech Recognition (ASR) on LibriSpeech](docs/librispeech_example.md) + +- [Speech-to-Text Translation (ST) on MuST-C](docs/mustc_example.md) + +- [Speech-to-Text Translation (ST) on CoVoST 2](docs/covost_example.md) + +- [Speech-to-Text Translation (ST) on Multilingual TEDx](docs/mtedx_example.md) +- [Simultaneous Speech-to-Text Translation (SimulST) on MuST-C](docs/simulst_mustc_example.md) + +## Updates +- 02/04/2021: Added interactive decoding (`fairseq-interactive`) support. Examples: + [ASR (LibriSpeech)](docs/librispeech_example.md#interactive-decoding) + and [ST (CoVoST 2)](docs/covost_example.md#interactive-decoding). +- 01/08/2021: Several fixes for S2T Transformer model, inference-time de-tokenization, scorer configuration and data + preparation scripts. We also add pre-trained models to the examples and revise the instructions. + Breaking changes: the data preparation scripts now extract filterbank features without CMVN. CMVN is instead applied + on-the-fly (defined in the config YAML). + +## What's Next +- We are migrating the old fairseq [ASR example](../speech_recognition) into this S2T framework and + merging the features from both sides. +- The following papers also base their experiments on fairseq S2T. We are adding more examples for replication. + - [Improving Cross-Lingual Transfer Learning for End-to-End Speech Recognition with Speech Translation (Wang et al., 2020)](https://arxiv.org/abs/2006.05474) + - [Self-Supervised Representations Improve End-to-End Speech Translation (Wu et al., 2020)](https://arxiv.org/abs/2006.12124) + - [Self-Training for End-to-End Speech Translation (Pino et al., 2020)](https://arxiv.org/abs/2006.02490) + - [CoVoST: A Diverse Multilingual Speech-To-Text Translation Corpus (Wang et al., 2020)](https://arxiv.org/abs/2002.01320) + - [Harnessing Indirect Training Data for End-to-End Automatic Speech Translation: Tricks of the Trade (Pino et al., 2019)](https://arxiv.org/abs/1909.06515) + +## Citation +Please cite as: +``` +@inproceedings{wang2020fairseqs2t, + title = {fairseq S2T: Fast Speech-to-Text Modeling with fairseq}, + author = {Changhan Wang and Yun Tang and Xutai Ma and Anne Wu and Dmytro Okhonko and Juan Pino}, + booktitle = {Proceedings of the 2020 Conference of the Asian Chapter of the Association for Computational Linguistics (AACL): System Demonstrations}, + year = {2020}, +} + +@inproceedings{ott2019fairseq, + title = {fairseq: A Fast, Extensible Toolkit for Sequence Modeling}, + author = {Myle Ott and Sergey Edunov and Alexei Baevski and Angela Fan and Sam Gross and Nathan Ng and David Grangier and Michael Auli}, + booktitle = {Proceedings of NAACL-HLT 2019: Demonstrations}, + year = {2019}, +} +``` diff --git a/fairseq/examples/speech_to_text/data_utils.py b/fairseq/examples/speech_to_text/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..41afac0bf8f6d70e06bee1a34e220ab396ec247d --- /dev/null +++ b/fairseq/examples/speech_to_text/data_utils.py @@ -0,0 +1,382 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import csv +from pathlib import Path +import zipfile +from functools import reduce +from multiprocessing import cpu_count +from typing import Any, Dict, List, Optional, Union +import io + +import numpy as np +import pandas as pd +import sentencepiece as sp +from fairseq.data.audio.audio_utils import ( + convert_waveform, _get_kaldi_fbank, _get_torchaudio_fbank, is_npy_data, + is_sf_audio_data +) +import torch +import soundfile as sf +from tqdm import tqdm + + +UNK_TOKEN, UNK_TOKEN_ID = "<unk>", 3 +BOS_TOKEN, BOS_TOKEN_ID = "<s>", 0 +EOS_TOKEN, EOS_TOKEN_ID = "</s>", 2 +PAD_TOKEN, PAD_TOKEN_ID = "<pad>", 1 + + +def gen_vocab( + input_path: Path, output_path_prefix: Path, model_type="bpe", + vocab_size=1000, special_symbols: Optional[List[str]] = None +): + # Train SentencePiece Model + arguments = [ + f"--input={input_path.as_posix()}", + f"--model_prefix={output_path_prefix.as_posix()}", + f"--model_type={model_type}", + f"--vocab_size={vocab_size}", + "--character_coverage=1.0", + f"--num_threads={cpu_count()}", + f"--unk_id={UNK_TOKEN_ID}", + f"--bos_id={BOS_TOKEN_ID}", + f"--eos_id={EOS_TOKEN_ID}", + f"--pad_id={PAD_TOKEN_ID}", + ] + if special_symbols is not None: + _special_symbols = ",".join(special_symbols) + arguments.append(f"--user_defined_symbols={_special_symbols}") + sp.SentencePieceTrainer.Train(" ".join(arguments)) + # Export fairseq dictionary + spm = sp.SentencePieceProcessor() + spm.Load(output_path_prefix.as_posix() + ".model") + vocab = {i: spm.IdToPiece(i) for i in range(spm.GetPieceSize())} + assert ( + vocab.get(UNK_TOKEN_ID) == UNK_TOKEN + and vocab.get(PAD_TOKEN_ID) == PAD_TOKEN + and vocab.get(BOS_TOKEN_ID) == BOS_TOKEN + and vocab.get(EOS_TOKEN_ID) == EOS_TOKEN + ) + vocab = { + i: s + for i, s in vocab.items() + if s not in {UNK_TOKEN, BOS_TOKEN, EOS_TOKEN, PAD_TOKEN} + } + with open(output_path_prefix.as_posix() + ".txt", "w") as f_out: + for _, s in sorted(vocab.items(), key=lambda x: x[0]): + f_out.write(f"{s} 1\n") + + +def extract_fbank_features( + waveform: torch.FloatTensor, + sample_rate: int, + output_path: Optional[Path] = None, + n_mel_bins: int = 80, + overwrite: bool = False, +): + if output_path is not None and output_path.is_file() and not overwrite: + return + + _waveform = convert_waveform(waveform, sample_rate, to_mono=True) + # Kaldi compliance: 16-bit signed integers + _waveform = _waveform * (2 ** 15) + _waveform = _waveform.numpy() + + features = _get_kaldi_fbank(_waveform, sample_rate, n_mel_bins) + if features is None: + features = _get_torchaudio_fbank(_waveform, sample_rate, n_mel_bins) + if features is None: + raise ImportError( + "Please install pyKaldi or torchaudio to enable fbank feature extraction" + ) + + if output_path is not None: + np.save(output_path.as_posix(), features) + return features + + +def create_zip(data_root: Path, zip_path: Path): + paths = list(data_root.glob("*.npy")) + with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_STORED) as f: + for path in tqdm(paths): + f.write(path, arcname=path.name) + + +def get_zip_manifest( + zip_path: Path, zip_root: Optional[Path] = None, is_audio=False +): + _zip_path = Path.joinpath(zip_root or Path(""), zip_path) + with zipfile.ZipFile(_zip_path, mode="r") as f: + info = f.infolist() + paths, lengths = {}, {} + for i in tqdm(info): + utt_id = Path(i.filename).stem + offset, file_size = i.header_offset + 30 + len(i.filename), i.file_size + paths[utt_id] = f"{zip_path.as_posix()}:{offset}:{file_size}" + with open(_zip_path, "rb") as f: + f.seek(offset) + byte_data = f.read(file_size) + assert len(byte_data) > 1 + if is_audio: + assert is_sf_audio_data(byte_data), i + else: + assert is_npy_data(byte_data), i + byte_data_fp = io.BytesIO(byte_data) + if is_audio: + lengths[utt_id] = sf.info(byte_data_fp).frames + else: + lengths[utt_id] = np.load(byte_data_fp).shape[0] + return paths, lengths + + +def gen_config_yaml( + manifest_root: Path, + spm_filename: Optional[str] = None, + vocab_name: Optional[str] = None, + yaml_filename: str = "config.yaml", + specaugment_policy: Optional[str] = "lb", + prepend_tgt_lang_tag: bool = False, + sampling_alpha: Optional[float] = None, + input_channels: Optional[int] = 1, + input_feat_per_channel: Optional[int] = 80, + audio_root: str = "", + cmvn_type: str = "utterance", + gcmvn_path: Optional[Path] = None, + extra=None +): + manifest_root = manifest_root.absolute() + writer = S2TDataConfigWriter(manifest_root / yaml_filename) + assert spm_filename is not None or vocab_name is not None + vocab_name = spm_filename.replace(".model", ".txt") if vocab_name is None \ + else vocab_name + writer.set_vocab_filename(vocab_name) + if input_channels is not None: + writer.set_input_channels(input_channels) + if input_feat_per_channel is not None: + writer.set_input_feat_per_channel(input_feat_per_channel) + specaugment_setters = { + "lb": writer.set_specaugment_lb_policy, + "ld": writer.set_specaugment_ld_policy, + "sm": writer.set_specaugment_sm_policy, + "ss": writer.set_specaugment_ss_policy, + } + specaugment_setter = specaugment_setters.get(specaugment_policy, None) + if specaugment_setter is not None: + specaugment_setter() + if spm_filename is not None: + writer.set_bpe_tokenizer( + { + "bpe": "sentencepiece", + "sentencepiece_model": (manifest_root / spm_filename).as_posix(), + } + ) + if prepend_tgt_lang_tag: + writer.set_prepend_tgt_lang_tag(True) + if sampling_alpha is not None: + writer.set_sampling_alpha(sampling_alpha) + + if cmvn_type not in ["global", "utterance"]: + raise NotImplementedError + + if specaugment_policy is not None: + writer.set_feature_transforms( + "_train", [f"{cmvn_type}_cmvn", "specaugment"] + ) + writer.set_feature_transforms("*", [f"{cmvn_type}_cmvn"]) + + if cmvn_type == "global": + if gcmvn_path is None: + raise ValueError("Please provide path of global cmvn file.") + else: + writer.set_global_cmvn(gcmvn_path.as_posix()) + + if len(audio_root) > 0: + writer.set_audio_root(audio_root) + + if extra is not None: + writer.set_extra(extra) + writer.flush() + + +def load_df_from_tsv(path: Union[str, Path]) -> pd.DataFrame: + _path = path if isinstance(path, str) else path.as_posix() + return pd.read_csv( + _path, + sep="\t", + header=0, + encoding="utf-8", + escapechar="\\", + quoting=csv.QUOTE_NONE, + na_filter=False, + ) + + +def save_df_to_tsv(dataframe, path: Union[str, Path]): + _path = path if isinstance(path, str) else path.as_posix() + dataframe.to_csv( + _path, + sep="\t", + header=True, + index=False, + encoding="utf-8", + escapechar="\\", + quoting=csv.QUOTE_NONE, + ) + + +def load_tsv_to_dicts(path: Union[str, Path]) -> List[dict]: + with open(path, "r") as f: + reader = csv.DictReader( + f, + delimiter="\t", + quotechar=None, + doublequote=False, + lineterminator="\n", + quoting=csv.QUOTE_NONE, + ) + rows = [dict(e) for e in reader] + return rows + + +def filter_manifest_df( + df, is_train_split=False, extra_filters=None, min_n_frames=5, max_n_frames=3000 +): + filters = { + "no speech": df["audio"] == "", + f"short speech (<{min_n_frames} frames)": df["n_frames"] < min_n_frames, + "empty sentence": df["tgt_text"] == "", + } + if is_train_split: + filters[f"long speech (>{max_n_frames} frames)"] = df["n_frames"] > max_n_frames + if extra_filters is not None: + filters.update(extra_filters) + invalid = reduce(lambda x, y: x | y, filters.values()) + valid = ~invalid + print( + "| " + + ", ".join(f"{n}: {f.sum()}" for n, f in filters.items()) + + f", total {invalid.sum()} filtered, {valid.sum()} remained." + ) + return df[valid] + + +def cal_gcmvn_stats(features_list): + features = np.concatenate(features_list) + square_sums = (features ** 2).sum(axis=0) + mean = features.mean(axis=0) + features = np.subtract(features, mean) + var = square_sums / features.shape[0] - mean ** 2 + std = np.sqrt(np.maximum(var, 1e-8)) + return {"mean": mean.astype("float32"), "std": std.astype("float32")} + + +class S2TDataConfigWriter(object): + DEFAULT_VOCAB_FILENAME = "dict.txt" + DEFAULT_INPUT_FEAT_PER_CHANNEL = 80 + DEFAULT_INPUT_CHANNELS = 1 + + def __init__(self, yaml_path: Path): + try: + import yaml + except ImportError: + print("Please install PyYAML for S2T data config YAML files") + self.yaml = yaml + self.yaml_path = yaml_path + self.config = {} + + def flush(self): + with open(self.yaml_path, "w") as f: + self.yaml.dump(self.config, f) + + def set_audio_root(self, audio_root=""): + self.config["audio_root"] = audio_root + + def set_vocab_filename(self, vocab_filename: str = "dict.txt"): + self.config["vocab_filename"] = vocab_filename + + def set_specaugment( + self, + time_wrap_w: int, + freq_mask_n: int, + freq_mask_f: int, + time_mask_n: int, + time_mask_t: int, + time_mask_p: float, + ): + self.config["specaugment"] = { + "time_wrap_W": time_wrap_w, + "freq_mask_N": freq_mask_n, + "freq_mask_F": freq_mask_f, + "time_mask_N": time_mask_n, + "time_mask_T": time_mask_t, + "time_mask_p": time_mask_p, + } + + def set_specaugment_lb_policy(self): + self.set_specaugment( + time_wrap_w=0, + freq_mask_n=1, + freq_mask_f=27, + time_mask_n=1, + time_mask_t=100, + time_mask_p=1.0, + ) + + def set_specaugment_ld_policy(self): + self.set_specaugment( + time_wrap_w=0, + freq_mask_n=2, + freq_mask_f=27, + time_mask_n=2, + time_mask_t=100, + time_mask_p=1.0, + ) + + def set_specaugment_sm_policy(self): + self.set_specaugment( + time_wrap_w=0, + freq_mask_n=2, + freq_mask_f=15, + time_mask_n=2, + time_mask_t=70, + time_mask_p=0.2, + ) + + def set_specaugment_ss_policy(self): + self.set_specaugment( + time_wrap_w=0, + freq_mask_n=2, + freq_mask_f=27, + time_mask_n=2, + time_mask_t=70, + time_mask_p=0.2, + ) + + def set_input_channels(self, input_channels: int = 1): + self.config["input_channels"] = input_channels + + def set_input_feat_per_channel(self, input_feat_per_channel: int = 80): + self.config["input_feat_per_channel"] = input_feat_per_channel + + def set_bpe_tokenizer(self, bpe_tokenizer: Dict[str, Any]): + self.config["bpe_tokenizer"] = bpe_tokenizer + + def set_global_cmvn(self, stats_npz_path: str): + self.config["global_cmvn"] = {"stats_npz_path": stats_npz_path} + + def set_feature_transforms(self, split: str, transforms: List[str]): + if "transforms" not in self.config: + self.config["transforms"] = {} + self.config["transforms"][split] = transforms + + def set_prepend_tgt_lang_tag(self, flag: bool = True): + self.config["prepend_tgt_lang_tag"] = flag + + def set_sampling_alpha(self, sampling_alpha: float = 1.0): + self.config["sampling_alpha"] = sampling_alpha + + def set_extra(self, data): + self.config.update(data) diff --git a/fairseq/examples/speech_to_text/docs/covost_example.md b/fairseq/examples/speech_to_text/docs/covost_example.md new file mode 100644 index 0000000000000000000000000000000000000000..16447f041e4751f79d9f7848b33ef2ff943d63c2 --- /dev/null +++ b/fairseq/examples/speech_to_text/docs/covost_example.md @@ -0,0 +1,102 @@ +[[Back]](..) + +# S2T Example: ST on CoVoST +We replicate the experiments in +[CoVoST 2 and Massively Multilingual Speech-to-Text Translation (Wang et al., 2020)](https://arxiv.org/abs/2007.10310). + +## Data Preparation +[Download](https://commonvoice.mozilla.org/en/datasets) and unpack Common Voice v4 to a path +`${COVOST_ROOT}/${SOURCE_LANG_ID}`, then preprocess it with +```bash +# additional Python packages for S2T data processing/model training +pip install pandas torchaudio sentencepiece + +# En ASR +python examples/speech_to_text/prep_covost_data.py \ + --data-root ${COVOST_ROOT} --vocab-type char --src-lang en +# ST +python examples/speech_to_text/prep_covost_data.py \ + --data-root ${COVOST_ROOT} --vocab-type char \ + --src-lang fr --tgt-lang en +``` +The generated files (manifest, features, vocabulary and data configuration) will be added to +`${COVOST_ROOT}/${SOURCE_LANG_ID}`. + +Download our vocabulary files if you want to use our pre-trained models: +- ASR: [En](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_asr_vocab_char.zip) +- ST: [Fr-En](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_fr_en_st_vocab_char.zip), [De-En](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_de_en_st_vocab_char.zip), [Es-En](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_es_en_st_vocab_char.zip), [Ca-En](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_ca_en_st_vocab_char.zip), [En-De](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_de_st_vocab_char.zip), [En-Ca](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_ca_st_vocab_char.zip), [En-Fa](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_fa_st_vocab_char.zip), [En-Et](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_et_st_vocab_char.zip) + +## ASR +#### Training +We train an En ASR model for encoder pre-training of all ST models: +```bash +fairseq-train ${COVOST_ROOT}/en \ + --config-yaml config_asr_en.yaml --train-subset train_asr_en --valid-subset dev_asr_en \ + --save-dir ${ASR_SAVE_DIR} --num-workers 4 --max-tokens 50000 --max-update 60000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --report-accuracy --arch s2t_transformer_s --dropout 0.15 --optimizer adam --lr 2e-3 \ + --lr-scheduler inverse_sqrt --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 +``` +where `ASR_SAVE_DIR` is the checkpoint root path. We set `--update-freq 8` to simulate 8 GPUs with 1 GPU. +You may want to update it accordingly when using more than 1 GPU. + +#### Inference & Evaluation +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ASR_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}" +fairseq-generate ${COVOST_ROOT}/en \ + --config-yaml config_asr_en.yaml --gen-subset test_asr_en --task speech_to_text \ + --path ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \ + --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct +``` +#### Results +| --arch | Params | En | Model | +|---|---|---|---| +| s2t_transformer_s | 31M | 25.6 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_asr_transformer_s.pt) | + +## ST +#### Training +Fr-En as example: +```bash +fairseq-train ${COVOST_ROOT}/fr \ + --config-yaml config_st_fr_en.yaml --train-subset train_st_fr_en --valid-subset dev_st_fr_en \ + --save-dir ${ST_SAVE_DIR} --num-workers 4 --max-update 30000 --max-tokens 40000 \ # --max-tokens 50000 for en-* + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --encoder-freezing-updates 1000 --optimizer adam --lr 2e-3 \ + --lr-scheduler inverse_sqrt --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 \ + --load-pretrained-encoder-from ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} +``` +where `ST_SAVE_DIR` is the checkpoint root path. The ST encoder is pre-trained by En ASR for faster training and better +performance: `--load-pretrained-encoder-from <ASR checkpoint path>`. We set `--update-freq 8` to simulate 8 GPUs with 1 GPU. +You may want to update it accordingly when using more than 1 GPU. + +#### Inference & Evaluation +Average the last 10 checkpoints and evaluate on test split: +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ST_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ST_SAVE_DIR}/${CHECKPOINT_FILENAME}" +fairseq-generate ${COVOST_ROOT}/fr \ + --config-yaml config_st_fr_en.yaml --gen-subset test_st_fr_en --task speech_to_text \ + --path ${ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 --scoring sacrebleu +``` + +## Interactive Decoding +Launch the interactive console via +```bash +fairseq-interactive ${COVOST_ROOT}/fr --config-yaml config_st_fr_en.yaml \ + --task speech_to_text --path ${SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 +``` +Type in WAV/FLAC/OGG audio paths (one per line) after the prompt. + +#### Results +| --arch | Params | Fr-En | De-En | Es-En | Ca-En | En-De | En-Ca | En-Fa | En-Et | Model | +|---|---|---|---|---|---|---|---|---|---|---| +| s2t_transformer_s | 31M | [27.2](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_fr_en_st_transformer_s.pt) | [17.7](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_de_en_st_transformer_s.pt) | [23.1](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_es_en_st_transformer_s.pt) | [19.3](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_ca_en_st_transformer_s.pt) | [16.1](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_de_st_transformer_s.pt) | [21.6](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_ca_st_transformer_s.pt) | [12.9](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_fa_st_transformer_s.pt) | [12.8](https://dl.fbaipublicfiles.com/fairseq/s2t/covost2_en_et_st_transformer_s.pt) | (<-Download) | + +[[Back]](..) diff --git a/fairseq/examples/speech_to_text/docs/librispeech_example.md b/fairseq/examples/speech_to_text/docs/librispeech_example.md new file mode 100644 index 0000000000000000000000000000000000000000..4040fda9426027537036ba987d087a43e734bfd9 --- /dev/null +++ b/fairseq/examples/speech_to_text/docs/librispeech_example.md @@ -0,0 +1,69 @@ +[[Back]](..) + +# S2T Example: Speech Recognition (ASR) on LibriSpeech +[LibriSpeech](https://www.danielpovey.com/files/2015_icassp_librispeech.pdf) is a de-facto standard English ASR +benchmark. We provide competitive +vanilla [Transformer](https://papers.nips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf) baselines. + +## Data preparation +Download and preprocess LibriSpeech data with +```bash +# additional Python packages for S2T data processing/model training +pip install pandas torchaudio sentencepiece + +python examples/speech_to_text/prep_librispeech_data.py \ + --output-root ${LS_ROOT} --vocab-type unigram --vocab-size 10000 +``` +where `LS_ROOT` is the root path for downloaded data as well as generated files (manifest, features, vocabulary and +data configuration). + +[Download](https://dl.fbaipublicfiles.com/fairseq/s2t/librispeech_vocab_unigram10000.zip) our vocabulary files +if you want to use our pre-trained models. + +## Training +```bash +fairseq-train ${LS_ROOT} --save-dir ${SAVE_DIR} \ + --config-yaml config.yaml --train-subset train-clean-100,train-clean-360,train-other-500 --valid-subset dev-clean,dev-other \ + --num-workers 4 --max-tokens 40000 --max-update 300000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --share-decoder-input-output-embed \ + --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt --warmup-updates 10000 \ + --clip-norm 10.0 --seed 1 --update-freq 8 +``` +where `SAVE_DIR` is the checkpoint root path. Here we use `--arch s2t_transformer_s` (31M parameters) as example. +For better performance, you may switch to `s2t_transformer_m` (71M, with `--lr 1e-3`) or `s2t_transformer_l` +(268M, with `--lr 5e-4`). We set `--update-freq 8` to simulate 8 GPUs with 1 GPU. You may want to update it accordingly +when using more than 1 GPU. + +## Inference & Evaluation +Average the last 10 checkpoints and evaluate on the 4 splits +(`dev-clean`, `dev-other`, `test-clean` and `test-other`): +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py --inputs ${SAVE_DIR} \ + --num-epoch-checkpoints 10 \ + --output "${SAVE_DIR}/${CHECKPOINT_FILENAME}" +for SUBSET in dev-clean dev-other test-clean test-other; do + fairseq-generate ${LS_ROOT} --config-yaml config.yaml --gen-subset ${SUBSET} \ + --task speech_to_text --path ${SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 --scoring wer +done +``` + +## Interactive Decoding +Launch the interactive console via +```bash +fairseq-interactive ${LS_ROOT} --config-yaml config.yaml --task speech_to_text \ + --path ${SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 +``` +Type in WAV/FLAC/OGG audio paths (one per line) after the prompt. + +## Results + +| --arch | Params | dev-clean | dev-other | test-clean | test-other | Model | +|---|---|---|---|---|---|---| +| s2t_transformer_s | 30M | 3.8 | 8.9 | 4.4 | 9.0 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/librispeech_transformer_s.pt) | +| s2t_transformer_m | 71M | 3.2 | 8.0 | 3.4 | 7.9 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/librispeech_transformer_m.pt) | +| s2t_transformer_l | 268M | 3.0 | 7.5 | 3.2 | 7.5 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/librispeech_transformer_l.pt) | + +[[Back]](..) diff --git a/fairseq/examples/speech_to_text/docs/mtedx_example.md b/fairseq/examples/speech_to_text/docs/mtedx_example.md new file mode 100644 index 0000000000000000000000000000000000000000..25b4556affbf5bc141b103095d15fffef6225c0e --- /dev/null +++ b/fairseq/examples/speech_to_text/docs/mtedx_example.md @@ -0,0 +1,200 @@ +[[Back]](..) + +# S2T Example: Speech Translation (ST) on Multilingual TEDx + +[Multilingual TEDx](https://arxiv.org/abs/2102.01757) is multilingual corpus for speech recognition and +speech translation. The data is derived from TEDx talks in 8 source languages +with translations to a subset of 5 target languages. + +## Data Preparation +[Download](http://openslr.org/100/) and unpack Multilingual TEDx data to a path +`${MTEDX_ROOT}/${LANG_PAIR}`, then preprocess it with +```bash +# additional Python packages for S2T data processing/model training +pip install pandas torchaudio soundfile sentencepiece + +# Generate TSV manifests, features, vocabulary +# and configuration for each language +python examples/speech_to_text/prep_mtedx_data.py \ + --data-root ${MTEDX_ROOT} --task asr \ + --vocab-type unigram --vocab-size 1000 +python examples/speech_to_text/prep_mtedx_data.py \ + --data-root ${MTEDX_ROOT} --task st \ + --vocab-type unigram --vocab-size 1000 + +# Add vocabulary and configuration for joint data +# (based on the manifests and features generated above) +python examples/speech_to_text/prep_mtedx_data.py \ + --data-root ${MTEDX_ROOT} --task asr --joint \ + --vocab-type unigram --vocab-size 8000 +python examples/speech_to_text/prep_mtedx_data.py \ + --data-root ${MTEDX_ROOT} --task st --joint \ + --vocab-type unigram --vocab-size 8000 +``` +The generated files (manifest, features, vocabulary and data configuration) will be added to +`${MTEDX_ROOT}/${LANG_PAIR}` (per-language data) and `MTEDX_ROOT` (joint data). + + +## ASR +#### Training +Spanish as example: +```bash +fairseq-train ${MTEDX_ROOT}/es-es \ + --config-yaml config_asr.yaml --train-subset train_asr --valid-subset valid_asr \ + --save-dir ${ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-epoch 200 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --report-accuracy \ + --arch s2t_transformer_xs --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --dropout 0.3 --label-smoothing 0.1 \ + --load-pretrained-encoder-from ${PRETRAINED_ENCODER} \ + --skip-invalid-size-inputs-valid-test \ + --keep-last-epochs 10 --update-freq 8 --patience 10 +``` +For joint model (using ASR data from all 8 languages): +```bash +fairseq-train ${MTEDX_ROOT} \ + --config-yaml config_asr.yaml \ + --train-subset train_es-es_asr,train_fr-fr_asr,train_pt-pt_asr,train_it-it_asr,train_ru-ru_asr,train_el-el_asr,train_ar-ar_asr,train_de-de_asr \ + --valid-subset valid_es-es_asr,valid_fr-fr_asr,valid_pt-pt_asr,valid_it-it_asr,valid_ru-ru_asr,valid_el-el_asr,valid_ar-ar_asr,valid_de-de_asr \ + --save-dir ${MULTILINGUAL_ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-epoch 200 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --report-accuracy \ + --arch s2t_transformer_s --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --dropout 0.3 --label-smoothing 0.1 \ + --skip-invalid-size-inputs-valid-test \ + --keep-last-epochs 10 --update-freq 8 --patience 10 \ + --ignore-prefix-size 1 +``` +where `MULTILINGUAL_ASR_SAVE_DIR` is the checkpoint root path. We set `--update-freq 8` to simulate 8 GPUs +with 1 GPU. You may want to update it accordingly when using more than 1 GPU. +For multilingual models, we prepend target language ID token as target BOS, which should be excluded from +the training loss via `--ignore-prefix-size 1`. + +#### Inference & Evaluation +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ASR_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}" + +fairseq-generate ${MTEDX_ROOT}/es-es \ + --config-yaml config_asr.yaml --gen-subset test --task speech_to_text \ + --path ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \ + --skip-invalid-size-inputs-valid-test \ + --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct --remove-bpe + +# For models trained on joint data +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${MULTILINGUAL_ASR_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${MULTILINGUAL_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}" + +for LANG in es fr pt it ru el ar de; do + fairseq-generate ${MTEDX_ROOT} \ + --config-yaml config_asr.yaml --gen-subset test_${LANG}-${LANG}_asr --task speech_to_text \ + --prefix-size 1 --path ${MULTILINGUAL_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 40000 --beam 5 \ + --skip-invalid-size-inputs-valid-test \ + --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct --remove-bpe +done +``` +#### Results +| Data | --arch | Params | Es | Fr | Pt | It | Ru | El | Ar | De | +|--------------|--------------------|--------|------|------|------|------|------|-------|-------|-------| +| Monolingual | s2t_transformer_xs | 10M | 46.4 | 45.6 | 54.8 | 48.0 | 74.7 | 109.5 | 104.4 | 111.1 | + + +## ST +#### Training +Es-En as example: +```bash +fairseq-train ${MTEDX_ROOT}/es-en \ + --config-yaml config_st.yaml --train-subset train_st --valid-subset valid_st \ + --save-dir ${ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-epoch 200 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --report-accuracy \ + --arch s2t_transformer_xs --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --dropout 0.3 --label-smoothing 0.1 \ + --load-pretrained-encoder-from ${PRETRAINED_ENCODER} \ + --skip-invalid-size-inputs-valid-test \ + --keep-last-epochs 10 --update-freq 8 --patience 10 +``` +For multilingual model (all 12 directions): +```bash +fairseq-train ${MTEDX_ROOT} \ + --config-yaml config_st.yaml \ + --train-subset train_el-en_st,train_es-en_st,train_es-fr_st,train_es-it_st,train_es-pt_st,train_fr-en_st,train_fr-es_st,train_fr-pt_st,train_it-en_st,train_it-es_st,train_pt-en_st,train_pt-es_st,train_ru-en_st \ + --valid-subset valid_el-en_st,valid_es-en_st,valid_es-fr_st,valid_es-it_st,valid_es-pt_st,valid_fr-en_st,valid_fr-es_st,valid_fr-pt_st,valid_it-en_st,valid_it-es_st,valid_pt-en_st,valid_pt-es_st,valid_ru-en_st \ + --save-dir ${MULTILINGUAL_ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-epoch 200 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --report-accuracy \ + --arch s2t_transformer_s --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --dropout 0.3 --label-smoothing 0.1 \ + --skip-invalid-size-inputs-valid-test \ + --keep-last-epochs 10 --update-freq 8 --patience 10 \ + --ignore-prefix-size 1 \ + --load-pretrained-encoder-from ${PRETRAINED_ENCODER} +``` +where `ST_SAVE_DIR` (`MULTILINGUAL_ST_SAVE_DIR`) is the checkpoint root path. The ST encoder is pre-trained by ASR +for faster training and better performance: `--load-pretrained-encoder-from <(JOINT_)ASR checkpoint path>`. We set +`--update-freq 8` to simulate 8 GPUs with 1 GPU. You may want to update it accordingly when using more than 1 GPU. +For multilingual models, we prepend target language ID token as target BOS, which should be excluded from +the training loss via `--ignore-prefix-size 1`. + +#### Inference & Evaluation +Average the last 10 checkpoints and evaluate on the `test` split: +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ST_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ST_SAVE_DIR}/${CHECKPOINT_FILENAME}" + +fairseq-generate ${MTEDX_ROOT}/es-en \ + --config-yaml config_st.yaml --gen-subset test --task speech_to_text \ + --path ${ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 --scoring sacrebleu --remove-bpe + +# For multilingual models +python scripts/average_checkpoints.py \ + --inputs ${MULTILINGUAL_ST_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME}" + +for LANGPAIR in es-en es-fr es-pt fr-en fr-es fr-pt pt-en pt-es it-en it-es ru-en el-en; do + fairseq-generate ${MTEDX_ROOT} \ + --config-yaml config_st.yaml --gen-subset test_${LANGPAIR}_st --task speech_to_text \ + --prefix-size 1 --path ${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 40000 --beam 5 \ + --skip-invalid-size-inputs-valid-test \ + --scoring sacrebleu --remove-bpe +done +``` +For multilingual models, we force decoding from the target language ID token (as BOS) via `--prefix-size 1`. + +#### Results +| Data | --arch | Params | Es-En | Es-Pt | Es-Fr | Fr-En | Fr-Es | Fr-Pt | Pt-En | Pt-Es | It-En | It-Es | Ru-En | El-En | +|--------------|--------------------|-----|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------| +| Bilingual | s2t_transformer_xs | 10M | 7.0 | 12.2 | 1.7 | 8.9 | 10.6 | 7.9 | 8.1 | 8.7 | 6.4 | 1.0 | 0.7 | 0.6 | +| Multilingual | s2t_transformer_s | 31M | 12.3 | 17.4 | 6.1 | 12.0 | 13.6 | 13.2 | 12.0 | 13.7 | 10.7 | 13.1 | 0.6 | 0.8 | + + +## Citation +Please cite as: +``` +@misc{salesky2021mtedx, + title={Multilingual TEDx Corpus for Speech Recognition and Translation}, + author={Elizabeth Salesky and Matthew Wiesner and Jacob Bremerman and Roldano Cattoni and Matteo Negri and Marco Turchi and Douglas W. Oard and Matt Post}, + year={2021}, +} + +@inproceedings{wang2020fairseqs2t, + title = {fairseq S2T: Fast Speech-to-Text Modeling with fairseq}, + author = {Changhan Wang and Yun Tang and Xutai Ma and Anne Wu and Dmytro Okhonko and Juan Pino}, + booktitle = {Proceedings of the 2020 Conference of the Asian Chapter of the Association for Computational Linguistics (AACL): System Demonstrations}, + year = {2020}, +} + +@inproceedings{ott2019fairseq, + title = {fairseq: A Fast, Extensible Toolkit for Sequence Modeling}, + author = {Myle Ott and Sergey Edunov and Alexei Baevski and Angela Fan and Sam Gross and Nathan Ng and David Grangier and Michael Auli}, + booktitle = {Proceedings of NAACL-HLT 2019: Demonstrations}, + year = {2019}, +} +``` + +[[Back]](..) diff --git a/fairseq/examples/speech_to_text/docs/mustc_example.md b/fairseq/examples/speech_to_text/docs/mustc_example.md new file mode 100644 index 0000000000000000000000000000000000000000..c95ef3e15660107c3384f87c1680f005044e7f3b --- /dev/null +++ b/fairseq/examples/speech_to_text/docs/mustc_example.md @@ -0,0 +1,155 @@ +[[Back]](..) + +# S2T Example: Speech Translation (ST) on MuST-C + +[MuST-C](https://www.aclweb.org/anthology/N19-1202) is multilingual speech-to-text translation corpus with +8-language translations on English TED talks. We match the state-of-the-art performance in +[ESPNet-ST](https://arxiv.org/pdf/2004.10234.pdf) with a simpler model training pipeline. + +## Data Preparation +[Download](https://ict.fbk.eu/must-c) and unpack MuST-C data to a path +`${MUSTC_ROOT}/en-${TARGET_LANG_ID}`, then preprocess it with +```bash +# additional Python packages for S2T data processing/model training +pip install pandas torchaudio soundfile sentencepiece + +# Generate TSV manifests, features, vocabulary +# and configuration for each language +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task asr \ + --vocab-type unigram --vocab-size 5000 +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task st \ + --vocab-type unigram --vocab-size 8000 + +# Add vocabulary and configuration for joint data +# (based on the manifests and features generated above) +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task asr --joint \ + --vocab-type unigram --vocab-size 10000 +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task st --joint \ + --vocab-type unigram --vocab-size 10000 +``` +The generated files (manifest, features, vocabulary and data configuration) will be added to +`${MUSTC_ROOT}/en-${TARGET_LANG_ID}` (per-language data) and `MUSTC_ROOT` (joint data). + +Download our vocabulary files if you want to use our pre-trained models: +- ASR: [En-De](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_asr_vocab_unigram5000.zip), [En-Nl](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_asr_vocab_unigram5000.zip), [En-Es](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_asr_vocab_unigram5000.zip), [En-Fr](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_asr_vocab_unigram5000.zip), [En-It](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_asr_vocab_unigram5000.zip), [En-Pt](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_asr_vocab_unigram5000.zip), [En-Ro](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_asr_vocab_unigram5000.zip), [En-Ru](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_asr_vocab_unigram5000.zip), [Joint](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_joint_asr_vocab_unigram10000.zip) +- ST: [En-De](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_st_vocab_unigram8000.zip), [En-Nl](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_st_vocab_unigram8000.zip), [En-Es](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_st_vocab_unigram8000.zip), [En-Fr](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_st_vocab_unigram8000.zip), [En-It](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_st_vocab_unigram8000.zip), [En-Pt](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_st_vocab_unigram8000.zip), [En-Ro](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_st_vocab_unigram8000.zip), [En-Ru](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_st_vocab_unigram8000.zip), [Multilingual](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_multilingual_st_vocab_unigram10000.zip) + +## ASR +#### Training +En-De as example: +```bash +fairseq-train ${MUSTC_ROOT}/en-de \ + --config-yaml config_asr.yaml --train-subset train_asr --valid-subset dev_asr \ + --save-dir ${ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --optimizer adam --lr 1e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 +``` +For joint model (using ASR data from all 8 directions): +```bash +fairseq-train ${MUSTC_ROOT} \ + --config-yaml config_asr.yaml \ + --train-subset train_de_asr,train_nl_asr,train_es_asr,train_fr_asr,train_it_asr,train_pt_asr,train_ro_asr,train_ru_asr \ + --valid-subset dev_de_asr,dev_nl_asr,dev_es_asr,dev_fr_asr,dev_it_asr,dev_pt_asr,dev_ro_asr,dev_ru_asr \ + --save-dir ${JOINT_ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --optimizer adam --lr 1e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 +``` +where `ASR_SAVE_DIR` (`JOINT_ASR_SAVE_DIR`) is the checkpoint root path. We set `--update-freq 8` to simulate 8 GPUs +with 1 GPU. You may want to update it accordingly when using more than 1 GPU. + +#### Inference & Evaluation +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ASR_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}" +fairseq-generate ${MUSTC_ROOT}/en-de \ + --config-yaml config_asr.yaml --gen-subset tst-COMMON_asr --task speech_to_text \ + --path ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \ + --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct + +# For models trained on joint data +python scripts/average_checkpoints.py \ + --inputs ${JOINT_ASR_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}" +for LANG in de nl es fr it pt ro ru; do + fairseq-generate ${MUSTC_ROOT} \ + --config-yaml config_asr.yaml --gen-subset tst-COMMON_${LANG}_asr --task speech_to_text \ + --path ${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \ + --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct +done +``` +#### Results +| Data | --arch | Params | En-De | En-Nl | En-Es | En-Fr | En-It | En-Pt | En-Ro | En-Ru | Model | +|---|---|---|---|---|---|---|---|---|---|---|---| +| Single | s2t_transformer_s | 31M | [18.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_asr_transformer_s.pt) | [17.6](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_asr_transformer_s.pt) | [17.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_asr_transformer_s.pt) | [17.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_asr_transformer_s.pt) | [17.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_asr_transformer_s.pt) | [19.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_asr_transformer_s.pt) | [18.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_asr_transformer_s.pt) | [17.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_asr_transformer_s.pt) | (<-Download) | +| Joint | s2t_transformer_m | 76M | 16.8 | 16.7 | 16.9 | 16.9 | 17.0 | 17.4 | 17.0 | 16.9 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_joint_asr_transformer_m.pt) | + +## ST +#### Training +En-De as example: +```bash +fairseq-train ${MUSTC_ROOT}/en-de \ + --config-yaml config_st.yaml --train-subset train_st --valid-subset dev_st \ + --save-dir ${ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 \ + --load-pretrained-encoder-from ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} +``` +For multilingual model (all 8 directions): +```bash +fairseq-train ${MUSTC_ROOT} \ + --config-yaml config_st.yaml \ + --train-subset train_de_st,train_nl_st,train_es_st,train_fr_st,train_it_st,train_pt_st,train_ro_st,train_ru_st \ + --valid-subset dev_de_st,dev_nl_st,dev_es_st,dev_fr_st,dev_it_st,dev_pt_st,dev_ro_st,dev_ru_st \ + --save-dir ${MULTILINGUAL_ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \ + --arch s2t_transformer_s --ignore-prefix-size 1 --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 \ + --load-pretrained-encoder-from ${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} +``` +where `ST_SAVE_DIR` (`MULTILINGUAL_ST_SAVE_DIR`) is the checkpoint root path. The ST encoder is pre-trained by ASR +for faster training and better performance: `--load-pretrained-encoder-from <(JOINT_)ASR checkpoint path>`. We set +`--update-freq 8` to simulate 8 GPUs with 1 GPU. You may want to update it accordingly when using more than 1 GPU. +For multilingual models, we prepend target language ID token as target BOS, which should be excluded from +the training loss via `--ignore-prefix-size 1`. + +#### Inference & Evaluation +Average the last 10 checkpoints and evaluate on the `tst-COMMON` split: +```bash +CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt +python scripts/average_checkpoints.py \ + --inputs ${ST_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${ST_SAVE_DIR}/${CHECKPOINT_FILENAME}" +fairseq-generate ${MUSTC_ROOT}/en-de \ + --config-yaml config_st.yaml --gen-subset tst-COMMON_st --task speech_to_text \ + --path ${ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 --scoring sacrebleu + +# For multilingual models +python scripts/average_checkpoints.py \ + --inputs ${MULTILINGUAL_ST_SAVE_DIR} --num-epoch-checkpoints 10 \ + --output "${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME}" +for LANG in de nl es fr it pt ro ru; do + fairseq-generate ${MUSTC_ROOT} \ + --config-yaml config_st.yaml --gen-subset tst-COMMON_${LANG}_st --task speech_to_text \ + --prefix-size 1 --path ${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --max-tokens 50000 --beam 5 --scoring sacrebleu +done +``` +For multilingual models, we force decoding from the target language ID token (as BOS) via `--prefix-size 1`. + +#### Results +| Data | --arch | Params | En-De | En-Nl | En-Es | En-Fr | En-It | En-Pt | En-Ro | En-Ru | Model | +|---|---|---|---|---|---|---|---|---|---|---|---| +| Bilingual | s2t_transformer_s | 31M | [22.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_st_transformer_s.pt) | [27.3](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_st_transformer_s.pt) | [27.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_st_transformer_s.pt) | [32.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_st_transformer_s.pt) | [22.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_st_transformer_s.pt) | [28.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_st_transformer_s.pt) | [21.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_st_transformer_s.pt) | [15.3](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_st_transformer_s.pt) | (<-Download) | +| Multilingual | s2t_transformer_m | 76M | 24.5 | 28.6 | 28.2 | 34.9 | 24.6 | 31.1 | 23.8 | 16.0 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_multilingual_st_transformer_m.pt) | + +[[Back]](..) diff --git a/fairseq/examples/speech_to_text/docs/simulst_mustc_example.md b/fairseq/examples/speech_to_text/docs/simulst_mustc_example.md new file mode 100644 index 0000000000000000000000000000000000000000..f3b5a413a27bbe2700da3f418460aa0a7c41abdd --- /dev/null +++ b/fairseq/examples/speech_to_text/docs/simulst_mustc_example.md @@ -0,0 +1,190 @@ +# Simultaneous Speech Translation (SimulST) on MuST-C + +This is a tutorial of training and evaluating a transformer *wait-k* simultaneous model on MUST-C English-Germen Dataset, from [SimulMT to SimulST: Adapting Simultaneous Text Translation to End-to-End Simultaneous Speech Translation](https://www.aclweb.org/anthology/2020.aacl-main.58.pdf). + +[MuST-C](https://www.aclweb.org/anthology/N19-1202) is multilingual speech-to-text translation corpus with 8-language translations on English TED talks. + +## Data Preparation +This section introduces the data preparation for training and evaluation. +If you only want to evaluate the model, please jump to [Inference & Evaluation](#inference--evaluation) + +[Download](https://ict.fbk.eu/must-c) and unpack MuST-C data to a path +`${MUSTC_ROOT}/en-${TARGET_LANG_ID}`, then preprocess it with +```bash +# Additional Python packages for S2T data processing/model training +pip install pandas torchaudio sentencepiece + +# Generate TSV manifests, features, vocabulary, +# global cepstral and mean estimation, +# and configuration for each language +cd fairseq + +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task asr \ + --vocab-type unigram --vocab-size 10000 \ + --cmvn-type global + +python examples/speech_to_text/prep_mustc_data.py \ + --data-root ${MUSTC_ROOT} --task st \ + --vocab-type unigram --vocab-size 10000 \ + --cmvn-type global +``` + +## ASR Pretraining +We need a pretrained offline ASR model. Assuming the save directory of the ASR model is `${ASR_SAVE_DIR}`. +The following command (and the subsequent training commands in this tutorial) assume training on 1 GPU (you can also train on 8 GPUs and remove the `--update-freq 8` option). +``` +fairseq-train ${MUSTC_ROOT}/en-de \ + --config-yaml config_asr.yaml --train-subset train_asr --valid-subset dev_asr \ + --save-dir ${ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \ + --task speech_to_text --criterion label_smoothed_cross_entropy --report-accuracy \ + --arch convtransformer_espnet --optimizer adam --lr 0.0005 --lr-scheduler inverse_sqrt \ + --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 +``` +A pretrained ASR checkpoint can be downloaded [here](https://dl.fbaipublicfiles.com/simultaneous_translation/must_c_v1_en_de_pretrained_asr) + +## Simultaneous Speech Translation Training + +### Wait-K with fixed pre-decision module +Fixed pre-decision indicates that the model operate simultaneous policy on the boundaries of fixed chunks. +Here is a example of fixed pre-decision ratio 7 (the simultaneous decision is made every 7 encoder states) and +a wait-3 policy model. Assuming the save directory is `${ST_SAVE_DIR}` +```bash + fairseq-train ${MUSTC_ROOT}/en-de \ + --config-yaml config_st.yaml --train-subset train_st --valid-subset dev_st \ + --save-dir ${ST_SAVE_DIR} --num-workers 8 \ + --optimizer adam --lr 0.0001 --lr-scheduler inverse_sqrt --clip-norm 10.0 \ + --criterion label_smoothed_cross_entropy \ + --warmup-updates 4000 --max-update 100000 --max-tokens 40000 --seed 2 \ + --load-pretrained-encoder-from ${ASR_SAVE_DIR}/checkpoint_best.pt \ + --task speech_to_text \ + --arch convtransformer_simul_trans_espnet \ + --simul-type waitk_fixed_pre_decision \ + --waitk-lagging 3 \ + --fixed-pre-decision-ratio 7 \ + --update-freq 8 + +``` +### Monotonic multihead attention with fixed pre-decision module +``` + fairseq-train ${MUSTC_ROOT}/en-de \ + --config-yaml config_st.yaml --train-subset train_st --valid-subset dev_st \ + --save-dir ${ST_SAVE_DIR} --num-workers 8 \ + --optimizer adam --lr 0.0001 --lr-scheduler inverse_sqrt --clip-norm 10.0 \ + --warmup-updates 4000 --max-update 100000 --max-tokens 40000 --seed 2 \ + --load-pretrained-encoder-from ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --task speech_to_text \ + --criterion latency_augmented_label_smoothed_cross_entropy \ + --latency-weight-avg 0.1 \ + --arch convtransformer_simul_trans_espnet \ + --simul-type infinite_lookback_fixed_pre_decision \ + --fixed-pre-decision-ratio 7 \ + --update-freq 8 +``` +## Inference & Evaluation +[SimulEval](https://github.com/facebookresearch/SimulEval) is used for evaluation. +The following command is for evaluation. + +``` +git clone https://github.com/facebookresearch/SimulEval.git +cd SimulEval +pip install -e . + +simuleval \ + --agent ${FAIRSEQ}/examples/speech_to_text/simultaneous_translation/agents/fairseq_simul_st_agent.py + --source ${SRC_LIST_OF_AUDIO} + --target ${TGT_FILE} + --data-bin ${MUSTC_ROOT}/en-de \ + --config config_st.yaml \ + --model-path ${ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \ + --output ${OUTPUT} \ + --scores +``` + +The source file `${SRC_LIST_OF_AUDIO}` is a list of paths of audio files. Assuming your audio files stored at `/home/user/data`, +it should look like this + +```bash +/home/user/data/audio-1.wav +/home/user/data/audio-2.wav +``` + +Each line of target file `${TGT_FILE}` is the translation for each audio file input. +```bash +Translation_1 +Translation_2 +``` +The evaluation runs on the original MUSTC segmentation. +The following command will generate the wav list and text file for a evaluation set `${SPLIT}` (chose from `dev`, `tst-COMMON` and `tst-HE`) in MUSTC to `${EVAL_DATA}`. +```bash +python ${FAIRSEQ}/examples/speech_to_text/seg_mustc_data.py \ + --data-root ${MUSTC_ROOT} --lang de \ + --split ${SPLIT} --task st \ + --output ${EVAL_DATA} +``` + +The `--data-bin` and `--config` should be the same in previous section if you prepare the data from the scratch. +If only for evaluation, a prepared data directory can be found [here](https://dl.fbaipublicfiles.com/simultaneous_translation/must_c_v1.0_en_de_databin.tgz). It contains +- `spm_unigram10000_st.model`: a sentencepiece model binary. +- `spm_unigram10000_st.txt`: the dictionary file generated by the sentencepiece model. +- `gcmvn.npz`: the binary for global cepstral mean and variance. +- `config_st.yaml`: the config yaml file. It looks like this. +You will need to set the absolute paths for `sentencepiece_model` and `stats_npz_path` if the data directory is downloaded. +```yaml +bpe_tokenizer: + bpe: sentencepiece + sentencepiece_model: ABS_PATH_TO_SENTENCEPIECE_MODEL +global_cmvn: + stats_npz_path: ABS_PATH_TO_GCMVN_FILE +input_channels: 1 +input_feat_per_channel: 80 +sampling_alpha: 1.0 +specaugment: + freq_mask_F: 27 + freq_mask_N: 1 + time_mask_N: 1 + time_mask_T: 100 + time_mask_p: 1.0 + time_wrap_W: 0 +transforms: + '*': + - global_cmvn + _train: + - global_cmvn + - specaugment +vocab_filename: spm_unigram10000_st.txt +``` + +Notice that once a `--data-bin` is set, the `--config` is the base name of the config yaml, not the full path. + +Set `--model-path` to the model checkpoint. +A pretrained checkpoint can be downloaded from [here](https://dl.fbaipublicfiles.com/simultaneous_translation/convtransformer_wait5_pre7), which is a wait-5 model with a pre-decision of 280 ms. + +The result of this model on `tst-COMMON` is: +```bash +{ + "Quality": { + "BLEU": 13.94974229366959 + }, + "Latency": { + "AL": 1751.8031870037803, + "AL_CA": 2338.5911762796536, + "AP": 0.7931395378788959, + "AP_CA": 0.9405103863210942, + "DAL": 1987.7811616943081, + "DAL_CA": 2425.2751560926167 + } +} +``` + +If `--output ${OUTPUT}` option is used, the detailed log and scores will be stored under the `${OUTPUT}` directory. + + +The quality is measured by detokenized BLEU. So make sure that the predicted words sent to the server are detokenized. + +The latency metrics are +* Average Proportion +* Average Lagging +* Differentiable Average Lagging + +Again they will also be evaluated on detokenized text. diff --git a/fairseq/examples/speech_to_text/prep_covost_data.py b/fairseq/examples/speech_to_text/prep_covost_data.py new file mode 100644 index 0000000000000000000000000000000000000000..411e9b55152ea4a8e345e8c2d18431958c4f4c07 --- /dev/null +++ b/fairseq/examples/speech_to_text/prep_covost_data.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +import shutil +from tempfile import NamedTemporaryFile +from typing import Optional, Tuple + +import pandas as pd +import torchaudio +from examples.speech_to_text.data_utils import ( + create_zip, + extract_fbank_features, + filter_manifest_df, + gen_config_yaml, + gen_vocab, + get_zip_manifest, + load_df_from_tsv, + save_df_to_tsv, +) +from torch import Tensor +from torch.utils.data import Dataset +from torchaudio.datasets.utils import download_url, extract_archive +from tqdm import tqdm + + +log = logging.getLogger(__name__) + + +MANIFEST_COLUMNS = ["id", "audio", "n_frames", "tgt_text", "speaker"] + + +class CoVoST(Dataset): + """Create a Dataset for CoVoST (https://github.com/facebookresearch/covost). + + Args: + root (str): root path to the dataset and generated manifests/features + source_language (str): source (audio) language + target_language (str, optional): target (text) language, + None for no translation (default: None) + version (int, optional): CoVoST version. (default: 2) + download (bool, optional): Whether to download the dataset if it is not + found at root path. (default: ``False``). + """ + + COVOST_URL_TEMPLATE = ( + "https://dl.fbaipublicfiles.com/covost/" + "covost_v2.{src_lang}_{tgt_lang}.tsv.tar.gz" + ) + + VERSIONS = {2} + SPLITS = ["train", "dev", "test"] + + XX_EN_LANGUAGES = { + 1: ["fr", "de", "nl", "ru", "es", "it", "tr", "fa", "sv-SE", "mn", "zh-CN"], + 2: [ + "fr", + "de", + "es", + "ca", + "it", + "ru", + "zh-CN", + "pt", + "fa", + "et", + "mn", + "nl", + "tr", + "ar", + "sv-SE", + "lv", + "sl", + "ta", + "ja", + "id", + "cy", + ], + } + EN_XX_LANGUAGES = { + 1: [], + 2: [ + "de", + "tr", + "fa", + "sv-SE", + "mn", + "zh-CN", + "cy", + "ca", + "sl", + "et", + "id", + "ar", + "ta", + "lv", + "ja", + ], + } + + def __init__( + self, + root: str, + split: str, + source_language: str, + target_language: Optional[str] = None, + version: int = 2, + ) -> None: + assert version in self.VERSIONS and split in self.SPLITS + assert source_language is not None + self.no_translation = target_language is None + if not self.no_translation: + assert "en" in {source_language, target_language} + if source_language == "en": + assert target_language in self.EN_XX_LANGUAGES[version] + else: + assert source_language in self.XX_EN_LANGUAGES[version] + else: + # Hack here so that we can get "split" column from CoVoST TSV. + # Note that we use CoVoST train split for ASR which is an extension + # to Common Voice train split. + target_language = "de" if source_language == "en" else "en" + + self.root: Path = Path(root) + + cv_tsv_path = self.root / "validated.tsv" + assert cv_tsv_path.is_file() + + covost_url = self.COVOST_URL_TEMPLATE.format( + src_lang=source_language, tgt_lang=target_language + ) + covost_archive = self.root / Path(covost_url).name + if not covost_archive.is_file(): + download_url(covost_url, self.root.as_posix(), hash_value=None) + extract_archive(covost_archive.as_posix()) + + cv_tsv = load_df_from_tsv(cv_tsv_path) + covost_tsv = load_df_from_tsv( + self.root / Path(covost_url).name.replace(".tar.gz", "") + ) + df = pd.merge( + left=cv_tsv[["path", "sentence", "client_id"]], + right=covost_tsv[["path", "translation", "split"]], + how="inner", + on="path", + ) + if split == "train": + df = df[(df["split"] == split) | (df["split"] == f"{split}_covost")] + else: + df = df[df["split"] == split] + data = df.to_dict(orient="index").items() + data = [v for k, v in sorted(data, key=lambda x: x[0])] + self.data = [] + for e in data: + try: + path = self.root / "clips" / e["path"] + _ = torchaudio.info(path.as_posix()) + self.data.append(e) + except RuntimeError: + pass + + def __getitem__( + self, n: int + ) -> Tuple[Tensor, int, str, str, Optional[str], str, str]: + """Load the n-th sample from the dataset. + + Args: + n (int): The index of the sample to be loaded + + Returns: + tuple: ``(waveform, sample_rate, sentence, translation, speaker_id, + sample_id)`` + """ + data = self.data[n] + path = self.root / "clips" / data["path"] + waveform, sample_rate = torchaudio.load(path) + sentence = data["sentence"] + translation = None if self.no_translation else data["translation"] + speaker_id = data["client_id"] + _id = data["path"].replace(".mp3", "") + return waveform, sample_rate, sentence, translation, speaker_id, _id + + def __len__(self) -> int: + return len(self.data) + + +def process(args): + root = Path(args.data_root).absolute() / args.src_lang + if not root.is_dir(): + raise NotADirectoryError(f"{root} does not exist") + # Extract features + feature_root = root / "fbank80" + feature_root.mkdir(exist_ok=True) + for split in CoVoST.SPLITS: + print(f"Fetching split {split}...") + dataset = CoVoST(root, split, args.src_lang, args.tgt_lang) + print("Extracting log mel filter bank features...") + for waveform, sample_rate, _, _, _, utt_id in tqdm(dataset): + extract_fbank_features( + waveform, sample_rate, feature_root / f"{utt_id}.npy" + ) + # Pack features into ZIP + zip_path = root / "fbank80.zip" + print("ZIPing features...") + create_zip(feature_root, zip_path) + print("Fetching ZIP manifest...") + audio_paths, audio_lengths = get_zip_manifest(zip_path) + # Generate TSV manifest + print("Generating manifest...") + train_text = [] + task = f"asr_{args.src_lang}" + if args.tgt_lang is not None: + task = f"st_{args.src_lang}_{args.tgt_lang}" + for split in CoVoST.SPLITS: + manifest = {c: [] for c in MANIFEST_COLUMNS} + dataset = CoVoST(root, split, args.src_lang, args.tgt_lang) + for _, _, src_utt, tgt_utt, speaker_id, utt_id in tqdm(dataset): + manifest["id"].append(utt_id) + manifest["audio"].append(audio_paths[utt_id]) + manifest["n_frames"].append(audio_lengths[utt_id]) + manifest["tgt_text"].append(src_utt if args.tgt_lang is None else tgt_utt) + manifest["speaker"].append(speaker_id) + is_train_split = split.startswith("train") + if is_train_split: + train_text.extend(manifest["tgt_text"]) + df = pd.DataFrame.from_dict(manifest) + df = filter_manifest_df(df, is_train_split=is_train_split) + save_df_to_tsv(df, root / f"{split}_{task}.tsv") + # Generate vocab + vocab_size_str = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{vocab_size_str}_{task}" + with NamedTemporaryFile(mode="w") as f: + for t in train_text: + f.write(t + "\n") + gen_vocab( + Path(f.name), + root / spm_filename_prefix, + args.vocab_type, + args.vocab_size + ) + # Generate config YAML + gen_config_yaml( + root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{task}.yaml", + specaugment_policy="lb", + ) + # Clean up + shutil.rmtree(feature_root) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--data-root", "-d", required=True, type=str, + help="data root with sub-folders for each language <root>/<src_lang>" + ) + parser.add_argument( + "--vocab-type", + default="unigram", + required=True, + type=str, + choices=["bpe", "unigram", "char"], + ), + parser.add_argument("--vocab-size", default=1000, type=int) + parser.add_argument("--src-lang", "-s", required=True, type=str) + parser.add_argument("--tgt-lang", "-t", type=str) + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_to_text/prep_librispeech_data.py b/fairseq/examples/speech_to_text/prep_librispeech_data.py new file mode 100644 index 0000000000000000000000000000000000000000..f379fa7bf195f48ad6b2ed3dbd93a5fbeb7abf79 --- /dev/null +++ b/fairseq/examples/speech_to_text/prep_librispeech_data.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +import shutil +from tempfile import NamedTemporaryFile + +import pandas as pd +from examples.speech_to_text.data_utils import ( + create_zip, + extract_fbank_features, + gen_config_yaml, + gen_vocab, + get_zip_manifest, + save_df_to_tsv, +) +from torchaudio.datasets import LIBRISPEECH +from tqdm import tqdm + + +log = logging.getLogger(__name__) + +SPLITS = [ + "train-clean-100", + "train-clean-360", + "train-other-500", + "dev-clean", + "dev-other", + "test-clean", + "test-other", +] + +MANIFEST_COLUMNS = ["id", "audio", "n_frames", "tgt_text", "speaker"] + + +def process(args): + out_root = Path(args.output_root).absolute() + out_root.mkdir(exist_ok=True) + # Extract features + feature_root = out_root / "fbank80" + feature_root.mkdir(exist_ok=True) + for split in SPLITS: + print(f"Fetching split {split}...") + dataset = LIBRISPEECH(out_root.as_posix(), url=split, download=True) + print("Extracting log mel filter bank features...") + for wav, sample_rate, _, spk_id, chapter_no, utt_no in tqdm(dataset): + sample_id = f"{spk_id}-{chapter_no}-{utt_no}" + extract_fbank_features( + wav, sample_rate, feature_root / f"{sample_id}.npy" + ) + # Pack features into ZIP + zip_path = out_root / "fbank80.zip" + print("ZIPing features...") + create_zip(feature_root, zip_path) + print("Fetching ZIP manifest...") + audio_paths, audio_lengths = get_zip_manifest(zip_path) + # Generate TSV manifest + print("Generating manifest...") + train_text = [] + for split in SPLITS: + manifest = {c: [] for c in MANIFEST_COLUMNS} + dataset = LIBRISPEECH(out_root.as_posix(), url=split) + for _, _, utt, spk_id, chapter_no, utt_no in tqdm(dataset): + sample_id = f"{spk_id}-{chapter_no}-{utt_no}" + manifest["id"].append(sample_id) + manifest["audio"].append(audio_paths[sample_id]) + manifest["n_frames"].append(audio_lengths[sample_id]) + manifest["tgt_text"].append(utt.lower()) + manifest["speaker"].append(spk_id) + save_df_to_tsv( + pd.DataFrame.from_dict(manifest), out_root / f"{split}.tsv" + ) + if split.startswith("train"): + train_text.extend(manifest["tgt_text"]) + # Generate vocab + vocab_size = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{vocab_size}" + with NamedTemporaryFile(mode="w") as f: + for t in train_text: + f.write(t + "\n") + gen_vocab( + Path(f.name), + out_root / spm_filename_prefix, + args.vocab_type, + args.vocab_size, + ) + # Generate config YAML + gen_config_yaml( + out_root, + spm_filename=spm_filename_prefix + ".model", + specaugment_policy="ld" + ) + # Clean up + shutil.rmtree(feature_root) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--output-root", "-o", required=True, type=str) + parser.add_argument( + "--vocab-type", + default="unigram", + required=True, + type=str, + choices=["bpe", "unigram", "char"], + ), + parser.add_argument("--vocab-size", default=10000, type=int) + args = parser.parse_args() + + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_to_text/prep_mtedx_data.py b/fairseq/examples/speech_to_text/prep_mtedx_data.py new file mode 100644 index 0000000000000000000000000000000000000000..2dfd6317631f56b7fd1e31da98f29f79681ba972 --- /dev/null +++ b/fairseq/examples/speech_to_text/prep_mtedx_data.py @@ -0,0 +1,271 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +from pathlib import Path +import shutil +from itertools import groupby +from tempfile import NamedTemporaryFile +from typing import Tuple + +import pandas as pd +import soundfile as sf +from examples.speech_to_text.data_utils import ( + create_zip, + extract_fbank_features, + filter_manifest_df, + gen_config_yaml, + gen_vocab, + get_zip_manifest, + load_df_from_tsv, + save_df_to_tsv, +) +import torch +from torch.utils.data import Dataset +from tqdm import tqdm + +from fairseq.data.audio.audio_utils import get_waveform, convert_waveform + + +log = logging.getLogger(__name__) + + +MANIFEST_COLUMNS = [ + "id", "audio", "n_frames", "tgt_text", "speaker", "tgt_lang" +] + + +class mTEDx(Dataset): + """ + Create a Dataset for Multilingual TEDx. + Each item is a tuple of the form: waveform, sample_rate, source utterance, + target utterance, speaker_id, utterance_id + """ + + SPLITS = ["train", "valid", "test"] + LANGPAIRS = ["es-es", "fr-fr", "pt-pt", "it-it", "ru-ru", "el-el", "ar-ar", + "de-de", "es-en", "es-fr", "es-pt", "es-it", "fr-en", "fr-es", + "fr-pt", "pt-en", "pt-es", "it-en", "it-es", "ru-en", "el-en"] + + def __init__(self, root: str, lang: str, split: str) -> None: + assert split in self.SPLITS and lang in self.LANGPAIRS + _root = Path(root) / f"{lang}" / "data" / split + wav_root, txt_root = _root / "wav", _root / "txt" + assert _root.is_dir() and wav_root.is_dir() and txt_root.is_dir() + # Load audio segments + try: + import yaml + except ImportError: + print( + "Please install PyYAML to load the Multilingual TEDx YAML files" + ) + with open(txt_root / f"{split}.yaml") as f: + segments = yaml.load(f, Loader=yaml.BaseLoader) + # Load source and target utterances + src, tgt = lang.split("-") + for _lang in [src, tgt]: + with open(txt_root / f"{split}.{_lang}") as f: + utterances = [r.strip() for r in f] + assert len(segments) == len(utterances) + for i, u in enumerate(utterances): + segments[i][_lang] = u + # Gather info + self.data = [] + for wav_filename, _seg_group in groupby(segments, lambda x: x["wav"]): + wav_filename = wav_filename.replace(".wav", ".flac") + wav_path = wav_root / wav_filename + sample_rate = sf.info(wav_path.as_posix()).samplerate + seg_group = sorted(_seg_group, key=lambda x: float(x["offset"])) + for i, segment in enumerate(seg_group): + offset = int(float(segment["offset"]) * sample_rate) + n_frames = int(float(segment["duration"]) * sample_rate) + _id = f"{wav_path.stem}_{i}" + self.data.append( + ( + wav_path.as_posix(), + offset, + n_frames, + sample_rate, + segment[src], + segment[tgt], + segment["speaker_id"], + tgt, + _id, + ) + ) + + def __getitem__( + self, n: int + ) -> Tuple[torch.Tensor, int, str, str, str, str, str]: + wav_path, offset, n_frames, sr, src_utt, tgt_utt, spk_id, tgt_lang, \ + utt_id = self.data[n] + waveform, _ = get_waveform(wav_path, frames=n_frames, start=offset) + waveform = torch.from_numpy(waveform) + return waveform, sr, src_utt, tgt_utt, spk_id, tgt_lang, utt_id + + def __len__(self) -> int: + return len(self.data) + + +def process(args): + root = Path(args.data_root).absolute() + for lang in mTEDx.LANGPAIRS: + cur_root = root / f"{lang}" + if not cur_root.is_dir(): + print(f"{cur_root.as_posix()} does not exist. Skipped.") + continue + # Extract features + audio_root = cur_root / ("flac" if args.use_audio_input else "fbank80") + audio_root.mkdir(exist_ok=True) + for split in mTEDx.SPLITS: + print(f"Fetching split {split}...") + dataset = mTEDx(root.as_posix(), lang, split) + if args.use_audio_input: + print("Converting audios...") + for waveform, sample_rate, _, _, _, utt_id in tqdm(dataset): + tgt_sample_rate = 16_000 + _wavform, _ = convert_waveform( + waveform, sample_rate, to_mono=True, + to_sample_rate=tgt_sample_rate + ) + sf.write( + (audio_root / f"{utt_id}.flac").as_posix(), + _wavform.numpy(), tgt_sample_rate + ) + else: + print("Extracting log mel filter bank features...") + for waveform, sample_rate, _, _, _, _, utt_id in tqdm(dataset): + extract_fbank_features( + waveform, sample_rate, audio_root / f"{utt_id}.npy" + ) + # Pack features into ZIP + zip_path = cur_root / f"{audio_root.name}.zip" + print("ZIPing audios/features...") + create_zip(audio_root, zip_path) + print("Fetching ZIP manifest...") + audio_paths, audio_lengths = get_zip_manifest(zip_path) + # Generate TSV manifest + print("Generating manifest...") + train_text = [] + for split in mTEDx.SPLITS: + is_train_split = split.startswith("train") + manifest = {c: [] for c in MANIFEST_COLUMNS} + ds = mTEDx(args.data_root, lang, split) + for _, _, src_utt, tgt_utt, spk_id, tgt_lang, utt_id in tqdm(ds): + manifest["id"].append(utt_id) + manifest["audio"].append(audio_paths[utt_id]) + manifest["n_frames"].append(audio_lengths[utt_id]) + manifest["tgt_text"].append( + src_utt if args.task == "asr" else tgt_utt + ) + manifest["speaker"].append(spk_id) + manifest["tgt_lang"].append(tgt_lang) + if is_train_split: + train_text.extend(manifest["tgt_text"]) + df = pd.DataFrame.from_dict(manifest) + df = filter_manifest_df(df, is_train_split=is_train_split) + save_df_to_tsv(df, cur_root / f"{split}_{args.task}.tsv") + # Generate vocab + v_size_str = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{v_size_str}_{args.task}" + with NamedTemporaryFile(mode="w") as f: + for t in train_text: + f.write(t + "\n") + gen_vocab( + Path(f.name), + cur_root / spm_filename_prefix, + args.vocab_type, + args.vocab_size, + ) + # Generate config YAML + if args.use_audio_input: + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy=None, + extra={"use_audio_input": True} + ) + else: + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy="lb", + ) + # Clean up + shutil.rmtree(audio_root) + + +def process_joint(args): + cur_root = Path(args.data_root) + assert all((cur_root / f"{lang}").is_dir() for lang in mTEDx.LANGPAIRS), \ + "do not have downloaded data available for all languages" + # Generate vocab + vocab_size_str = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{vocab_size_str}_{args.task}" + with NamedTemporaryFile(mode="w") as f: + for lang in mTEDx.LANGPAIRS: + tsv_path = cur_root / f"{lang}" / f"train_{args.task}.tsv" + df = load_df_from_tsv(tsv_path) + for t in df["tgt_text"]: + f.write(t + "\n") + special_symbols = None + if args.joint: + # Add tgt_lang tags to dict + special_symbols = list( + {f'<lang:{lang.split("-")[1]}>' for lang in mTEDx.LANGPAIRS} + ) + gen_vocab( + Path(f.name), + cur_root / spm_filename_prefix, + args.vocab_type, + args.vocab_size, + special_symbols=special_symbols + ) + # Generate config YAML + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy="ld", + prepend_tgt_lang_tag=(args.joint), + ) + # Make symbolic links to manifests + for lang in mTEDx.LANGPAIRS: + for split in mTEDx.SPLITS: + src_path = cur_root / f"{lang}" / f"{split}_{args.task}.tsv" + desc_path = cur_root / f"{split}_{lang}_{args.task}.tsv" + if not desc_path.is_symlink(): + os.symlink(src_path, desc_path) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--data-root", "-d", required=True, type=str) + parser.add_argument( + "--vocab-type", + default="unigram", + required=True, + type=str, + choices=["bpe", "unigram", "char"], + ), + parser.add_argument("--vocab-size", default=8000, type=int) + parser.add_argument("--task", type=str, choices=["asr", "st"]) + parser.add_argument("--joint", action="store_true", help="") + parser.add_argument("--use-audio-input", action="store_true") + args = parser.parse_args() + + if args.joint: + process_joint(args) + else: + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_to_text/prep_mustc_data.py b/fairseq/examples/speech_to_text/prep_mustc_data.py new file mode 100644 index 0000000000000000000000000000000000000000..3f0d3fcbd9437999f86d5a39e3d18ba9669f5894 --- /dev/null +++ b/fairseq/examples/speech_to_text/prep_mustc_data.py @@ -0,0 +1,291 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +from pathlib import Path +import shutil +from itertools import groupby +from tempfile import NamedTemporaryFile +from typing import Tuple + +import numpy as np +import pandas as pd +import soundfile as sf +from examples.speech_to_text.data_utils import ( + create_zip, + extract_fbank_features, + filter_manifest_df, + gen_config_yaml, + gen_vocab, + get_zip_manifest, + load_df_from_tsv, + save_df_to_tsv, + cal_gcmvn_stats, +) +import torch +from torch.utils.data import Dataset +from tqdm import tqdm + +from fairseq.data.audio.audio_utils import get_waveform, convert_waveform + + +log = logging.getLogger(__name__) + + +MANIFEST_COLUMNS = ["id", "audio", "n_frames", "tgt_text", "speaker"] + + +class MUSTC(Dataset): + """ + Create a Dataset for MuST-C. Each item is a tuple of the form: + waveform, sample_rate, source utterance, target utterance, speaker_id, + utterance_id + """ + + SPLITS = ["train", "dev", "tst-COMMON", "tst-HE"] + LANGUAGES = ["de", "es", "fr", "it", "nl", "pt", "ro", "ru"] + + def __init__(self, root: str, lang: str, split: str) -> None: + assert split in self.SPLITS and lang in self.LANGUAGES + _root = Path(root) / f"en-{lang}" / "data" / split + wav_root, txt_root = _root / "wav", _root / "txt" + assert _root.is_dir() and wav_root.is_dir() and txt_root.is_dir() + # Load audio segments + try: + import yaml + except ImportError: + print("Please install PyYAML to load the MuST-C YAML files") + with open(txt_root / f"{split}.yaml") as f: + segments = yaml.load(f, Loader=yaml.BaseLoader) + # Load source and target utterances + for _lang in ["en", lang]: + with open(txt_root / f"{split}.{_lang}") as f: + utterances = [r.strip() for r in f] + assert len(segments) == len(utterances) + for i, u in enumerate(utterances): + segments[i][_lang] = u + # Gather info + self.data = [] + for wav_filename, _seg_group in groupby(segments, lambda x: x["wav"]): + wav_path = wav_root / wav_filename + sample_rate = sf.info(wav_path.as_posix()).samplerate + seg_group = sorted(_seg_group, key=lambda x: x["offset"]) + for i, segment in enumerate(seg_group): + offset = int(float(segment["offset"]) * sample_rate) + n_frames = int(float(segment["duration"]) * sample_rate) + _id = f"{wav_path.stem}_{i}" + self.data.append( + ( + wav_path.as_posix(), + offset, + n_frames, + sample_rate, + segment["en"], + segment[lang], + segment["speaker_id"], + _id, + ) + ) + + def __getitem__( + self, n: int + ) -> Tuple[torch.Tensor, int, str, str, str, str]: + wav_path, offset, n_frames, sr, src_utt, tgt_utt, spk_id, \ + utt_id = self.data[n] + waveform, _ = get_waveform(wav_path, frames=n_frames, start=offset) + waveform = torch.from_numpy(waveform) + return waveform, sr, src_utt, tgt_utt, spk_id, utt_id + + def __len__(self) -> int: + return len(self.data) + + +def process(args): + root = Path(args.data_root).absolute() + for lang in MUSTC.LANGUAGES: + cur_root = root / f"en-{lang}" + if not cur_root.is_dir(): + print(f"{cur_root.as_posix()} does not exist. Skipped.") + continue + # Extract features + audio_root = cur_root / ("flac" if args.use_audio_input else "fbank80") + audio_root.mkdir(exist_ok=True) + + for split in MUSTC.SPLITS: + print(f"Fetching split {split}...") + dataset = MUSTC(root.as_posix(), lang, split) + if args.use_audio_input: + print("Converting audios...") + for waveform, sample_rate, _, _, _, utt_id in tqdm(dataset): + tgt_sample_rate = 16_000 + _wavform, _ = convert_waveform( + waveform, sample_rate, to_mono=True, + to_sample_rate=tgt_sample_rate + ) + sf.write( + (audio_root / f"{utt_id}.flac").as_posix(), + _wavform.numpy(), tgt_sample_rate + ) + else: + print("Extracting log mel filter bank features...") + gcmvn_feature_list = [] + if split == 'train' and args.cmvn_type == "global": + print("And estimating cepstral mean and variance stats...") + + for waveform, sample_rate, _, _, _, utt_id in tqdm(dataset): + features = extract_fbank_features( + waveform, sample_rate, audio_root / f"{utt_id}.npy" + ) + if split == 'train' and args.cmvn_type == "global": + if len(gcmvn_feature_list) < args.gcmvn_max_num: + gcmvn_feature_list.append(features) + + if split == 'train' and args.cmvn_type == "global": + # Estimate and save cmv + stats = cal_gcmvn_stats(gcmvn_feature_list) + with open(cur_root / "gcmvn.npz", "wb") as f: + np.savez(f, mean=stats["mean"], std=stats["std"]) + + # Pack features into ZIP + zip_path = cur_root / f"{audio_root.name}.zip" + print("ZIPing audios/features...") + create_zip(audio_root, zip_path) + print("Fetching ZIP manifest...") + audio_paths, audio_lengths = get_zip_manifest(zip_path) + # Generate TSV manifest + print("Generating manifest...") + train_text = [] + for split in MUSTC.SPLITS: + is_train_split = split.startswith("train") + manifest = {c: [] for c in MANIFEST_COLUMNS} + dataset = MUSTC(args.data_root, lang, split) + for _, _, src_utt, tgt_utt, speaker_id, utt_id in tqdm(dataset): + manifest["id"].append(utt_id) + manifest["audio"].append(audio_paths[utt_id]) + manifest["n_frames"].append(audio_lengths[utt_id]) + manifest["tgt_text"].append( + src_utt if args.task == "asr" else tgt_utt + ) + manifest["speaker"].append(speaker_id) + if is_train_split: + train_text.extend(manifest["tgt_text"]) + df = pd.DataFrame.from_dict(manifest) + df = filter_manifest_df(df, is_train_split=is_train_split) + save_df_to_tsv(df, cur_root / f"{split}_{args.task}.tsv") + # Generate vocab + v_size_str = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{v_size_str}_{args.task}" + with NamedTemporaryFile(mode="w") as f: + for t in train_text: + f.write(t + "\n") + gen_vocab( + Path(f.name), + cur_root / spm_filename_prefix, + args.vocab_type, + args.vocab_size, + ) + # Generate config YAML + if args.use_audio_input: + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy=None, + extra={"use_audio_input": True} + ) + else: + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy="lb", + cmvn_type=args.cmvn_type, + gcmvn_path=( + cur_root / "gcmvn.npz" if args.cmvn_type == "global" + else None + ), + ) + # Clean up + shutil.rmtree(audio_root) + + +def process_joint(args): + cur_root = Path(args.data_root) + assert all( + (cur_root / f"en-{lang}").is_dir() for lang in MUSTC.LANGUAGES + ), "do not have downloaded data available for all 8 languages" + # Generate vocab + vocab_size_str = "" if args.vocab_type == "char" else str(args.vocab_size) + spm_filename_prefix = f"spm_{args.vocab_type}{vocab_size_str}_{args.task}" + with NamedTemporaryFile(mode="w") as f: + for lang in MUSTC.LANGUAGES: + tsv_path = cur_root / f"en-{lang}" / f"train_{args.task}.tsv" + df = load_df_from_tsv(tsv_path) + for t in df["tgt_text"]: + f.write(t + "\n") + special_symbols = None + if args.task == 'st': + special_symbols = [f'<lang:{lang}>' for lang in MUSTC.LANGUAGES] + gen_vocab( + Path(f.name), + cur_root / spm_filename_prefix, + args.vocab_type, + args.vocab_size, + special_symbols=special_symbols + ) + # Generate config YAML + gen_config_yaml( + cur_root, + spm_filename=spm_filename_prefix + ".model", + yaml_filename=f"config_{args.task}.yaml", + specaugment_policy="ld", + prepend_tgt_lang_tag=(args.task == "st"), + ) + # Make symbolic links to manifests + for lang in MUSTC.LANGUAGES: + for split in MUSTC.SPLITS: + src_path = cur_root / f"en-{lang}" / f"{split}_{args.task}.tsv" + desc_path = cur_root / f"{split}_{lang}_{args.task}.tsv" + if not desc_path.is_symlink(): + os.symlink(src_path, desc_path) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--data-root", "-d", required=True, type=str) + parser.add_argument( + "--vocab-type", + default="unigram", + required=True, + type=str, + choices=["bpe", "unigram", "char"], + ), + parser.add_argument("--vocab-size", default=8000, type=int) + parser.add_argument("--task", type=str, choices=["asr", "st"]) + parser.add_argument("--joint", action="store_true", help="") + parser.add_argument( + "--cmvn-type", default="utterance", + choices=["global", "utterance"], + help="The type of cepstral mean and variance normalization" + ) + parser.add_argument( + "--gcmvn-max-num", default=150000, type=int, + help="Maximum number of sentences to use to estimate global mean and " + "variance" + ) + parser.add_argument("--use-audio-input", action="store_true") + args = parser.parse_args() + + if args.joint: + process_joint(args) + else: + process(args) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/speech_to_text/seg_mustc_data.py b/fairseq/examples/speech_to_text/seg_mustc_data.py new file mode 100644 index 0000000000000000000000000000000000000000..1ee665d6399729afe17d790d872eff34de124900 --- /dev/null +++ b/fairseq/examples/speech_to_text/seg_mustc_data.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +from pathlib import Path +import soundfile as sf +from examples.speech_to_text.prep_mustc_data import ( + MUSTC +) + +from tqdm import tqdm + +log = logging.getLogger(__name__) + + +def main(args): + root = Path(args.data_root).absolute() + lang = args.lang + split = args.split + + cur_root = root / f"en-{lang}" + assert cur_root.is_dir(), ( + f"{cur_root.as_posix()} does not exist. Skipped." + ) + + dataset = MUSTC(root.as_posix(), lang, split) + output = Path(args.output).absolute() + output.mkdir(exist_ok=True) + f_text = open(output / f"{split}.{lang}", "w") + f_wav_list = open(output / f"{split}.wav_list", "w") + for waveform, sample_rate, _, text, _, utt_id in tqdm(dataset): + sf.write( + output / f"{utt_id}.wav", + waveform.squeeze(0).numpy(), + samplerate=int(sample_rate) + ) + f_text.write(text + "\n") + f_wav_list.write(str(output / f"{utt_id}.wav") + "\n") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--data-root", "-d", required=True, type=str) + parser.add_argument("--task", required=True, type=str, choices=["asr", "st"]) + parser.add_argument("--lang", required=True, type=str) + parser.add_argument("--output", required=True, type=str) + parser.add_argument("--split", required=True, choices=MUSTC.SPLITS) + args = parser.parse_args() + + main(args) diff --git a/fairseq/examples/speech_to_text/simultaneous_translation/agents/fairseq_simul_st_agent.py b/fairseq/examples/speech_to_text/simultaneous_translation/agents/fairseq_simul_st_agent.py new file mode 100644 index 0000000000000000000000000000000000000000..61617a1739ce196abba1e9a6f9ad9e9f4b37b9c1 --- /dev/null +++ b/fairseq/examples/speech_to_text/simultaneous_translation/agents/fairseq_simul_st_agent.py @@ -0,0 +1,363 @@ +import math +import os +import json +import numpy as np +import torch +import torchaudio.compliance.kaldi as kaldi +import yaml +from fairseq import checkpoint_utils, tasks +from fairseq.file_io import PathManager + +try: + from simuleval import READ_ACTION, WRITE_ACTION, DEFAULT_EOS + from simuleval.agents import SpeechAgent + from simuleval.states import ListEntry, SpeechStates +except ImportError: + print("Please install simuleval 'pip install simuleval'") + +SHIFT_SIZE = 10 +WINDOW_SIZE = 25 +SAMPLE_RATE = 16000 +FEATURE_DIM = 80 +BOW_PREFIX = "\u2581" + + +class OnlineFeatureExtractor: + """ + Extract speech feature on the fly. + """ + + def __init__(self, args): + self.shift_size = args.shift_size + self.window_size = args.window_size + assert self.window_size >= self.shift_size + + self.sample_rate = args.sample_rate + self.feature_dim = args.feature_dim + self.num_samples_per_shift = int(self.shift_size * self.sample_rate / 1000) + self.num_samples_per_window = int(self.window_size * self.sample_rate / 1000) + self.len_ms_to_samples = lambda x: x * self.sample_rate / 1000 + self.previous_residual_samples = [] + self.global_cmvn = args.global_cmvn + + def clear_cache(self): + self.previous_residual_samples = [] + + def __call__(self, new_samples): + samples = self.previous_residual_samples + new_samples + if len(samples) < self.num_samples_per_window: + self.previous_residual_samples = samples + return + + # num_frames is the number of frames from the new segment + num_frames = math.floor( + (len(samples) - self.len_ms_to_samples(self.window_size - self.shift_size)) + / self.num_samples_per_shift + ) + + # the number of frames used for feature extraction + # including some part of thte previous segment + effective_num_samples = int( + num_frames * self.len_ms_to_samples(self.shift_size) + + self.len_ms_to_samples(self.window_size - self.shift_size) + ) + + input_samples = samples[:effective_num_samples] + self.previous_residual_samples = samples[ + num_frames * self.num_samples_per_shift: + ] + + torch.manual_seed(1) + output = kaldi.fbank( + torch.FloatTensor(input_samples).unsqueeze(0), + num_mel_bins=self.feature_dim, + frame_length=self.window_size, + frame_shift=self.shift_size, + ).numpy() + + output = self.transform(output) + + return torch.from_numpy(output) + + def transform(self, input): + if self.global_cmvn is None: + return input + + mean = self.global_cmvn["mean"] + std = self.global_cmvn["std"] + + x = np.subtract(input, mean) + x = np.divide(x, std) + return x + + +class TensorListEntry(ListEntry): + """ + Data structure to store a list of tensor. + """ + + def append(self, value): + + if len(self.value) == 0: + self.value = value + return + + self.value = torch.cat([self.value] + [value], dim=0) + + def info(self): + return { + "type": str(self.new_value_type), + "length": self.__len__(), + "value": "" if type(self.value) is list else self.value.size(), + } + + +class FairseqSimulSTAgent(SpeechAgent): + + speech_segment_size = 40 # in ms, 4 pooling ratio * 10 ms step size + + def __init__(self, args): + super().__init__(args) + + self.eos = DEFAULT_EOS + + self.gpu = getattr(args, "gpu", False) + + self.args = args + + self.load_model_vocab(args) + + if getattr( + self.model.decoder.layers[0].encoder_attn, + 'pre_decision_ratio', + None + ) is not None: + self.speech_segment_size *= ( + self.model.decoder.layers[0].encoder_attn.pre_decision_ratio + ) + + args.global_cmvn = None + if args.config: + with open(os.path.join(args.data_bin, args.config), "r") as f: + config = yaml.load(f, Loader=yaml.BaseLoader) + + if "global_cmvn" in config: + args.global_cmvn = np.load(config["global_cmvn"]["stats_npz_path"]) + + if args.global_stats: + with PathManager.open(args.global_stats, "r") as f: + global_cmvn = json.loads(f.read()) + self.global_cmvn = {"mean": global_cmvn["mean"], "std": global_cmvn["stddev"]} + + self.feature_extractor = OnlineFeatureExtractor(args) + + self.max_len = args.max_len + + self.force_finish = args.force_finish + + torch.set_grad_enabled(False) + + def build_states(self, args, client, sentence_id): + # Initialize states here, for example add customized entry to states + # This function will be called at beginning of every new sentence + states = SpeechStates(args, client, sentence_id, self) + self.initialize_states(states) + return states + + def to_device(self, tensor): + if self.gpu: + return tensor.cuda() + else: + return tensor.cpu() + + @staticmethod + def add_args(parser): + # fmt: off + parser.add_argument('--model-path', type=str, required=True, + help='path to your pretrained model.') + parser.add_argument("--data-bin", type=str, required=True, + help="Path of data binary") + parser.add_argument("--config", type=str, default=None, + help="Path to config yaml file") + parser.add_argument("--global-stats", type=str, default=None, + help="Path to json file containing cmvn stats") + parser.add_argument("--tgt-splitter-type", type=str, default="SentencePiece", + help="Subword splitter type for target text") + parser.add_argument("--tgt-splitter-path", type=str, default=None, + help="Subword splitter model path for target text") + parser.add_argument("--user-dir", type=str, default="examples/simultaneous_translation", + help="User directory for simultaneous translation") + parser.add_argument("--max-len", type=int, default=200, + help="Max length of translation") + parser.add_argument("--force-finish", default=False, action="store_true", + help="Force the model to finish the hypothsis if the source is not finished") + parser.add_argument("--shift-size", type=int, default=SHIFT_SIZE, + help="Shift size of feature extraction window.") + parser.add_argument("--window-size", type=int, default=WINDOW_SIZE, + help="Window size of feature extraction window.") + parser.add_argument("--sample-rate", type=int, default=SAMPLE_RATE, + help="Sample rate") + parser.add_argument("--feature-dim", type=int, default=FEATURE_DIM, + help="Acoustic feature dimension.") + + # fmt: on + return parser + + def load_model_vocab(self, args): + + filename = args.model_path + if not os.path.exists(filename): + raise IOError("Model file not found: {}".format(filename)) + + state = checkpoint_utils.load_checkpoint_to_cpu(filename) + + task_args = state["cfg"]["task"] + task_args.data = args.data_bin + + if args.config is not None: + task_args.config_yaml = args.config + + task = tasks.setup_task(task_args) + + # build model for ensemble + state["cfg"]["model"].load_pretrained_encoder_from = None + state["cfg"]["model"].load_pretrained_decoder_from = None + self.model = task.build_model(state["cfg"]["model"]) + self.model.load_state_dict(state["model"], strict=True) + self.model.eval() + self.model.share_memory() + + if self.gpu: + self.model.cuda() + + # Set dictionary + self.dict = {} + self.dict["tgt"] = task.target_dictionary + + def initialize_states(self, states): + self.feature_extractor.clear_cache() + states.units.source = TensorListEntry() + states.units.target = ListEntry() + states.incremental_states = dict() + + def segment_to_units(self, segment, states): + # Convert speech samples to features + features = self.feature_extractor(segment) + if features is not None: + return [features] + else: + return [] + + def units_to_segment(self, units, states): + # Merge sub word to full word. + if self.model.decoder.dictionary.eos() == units[0]: + return DEFAULT_EOS + + segment = [] + if None in units.value: + units.value.remove(None) + + for index in units: + if index is None: + units.pop() + token = self.model.decoder.dictionary.string([index]) + if token.startswith(BOW_PREFIX): + if len(segment) == 0: + segment += [token.replace(BOW_PREFIX, "")] + else: + for j in range(len(segment)): + units.pop() + + string_to_return = ["".join(segment)] + + if self.model.decoder.dictionary.eos() == units[0]: + string_to_return += [DEFAULT_EOS] + + return string_to_return + else: + segment += [token.replace(BOW_PREFIX, "")] + + if ( + len(units) > 0 + and self.model.decoder.dictionary.eos() == units[-1] + or len(states.units.target) > self.max_len + ): + tokens = [self.model.decoder.dictionary.string([unit]) for unit in units] + return ["".join(tokens).replace(BOW_PREFIX, "")] + [DEFAULT_EOS] + + return None + + def update_model_encoder(self, states): + if len(states.units.source) == 0: + return + src_indices = self.to_device( + states.units.source.value.unsqueeze(0) + ) + src_lengths = self.to_device( + torch.LongTensor([states.units.source.value.size(0)]) + ) + + states.encoder_states = self.model.encoder(src_indices, src_lengths) + torch.cuda.empty_cache() + + def update_states_read(self, states): + # Happens after a read action. + self.update_model_encoder(states) + + def policy(self, states): + if not getattr(states, "encoder_states", None): + return READ_ACTION + + tgt_indices = self.to_device( + torch.LongTensor( + [self.model.decoder.dictionary.eos()] + + [x for x in states.units.target.value if x is not None] + ).unsqueeze(0) + ) + + states.incremental_states["steps"] = { + "src": states.encoder_states["encoder_out"][0].size(0), + "tgt": 1 + len(states.units.target), + } + + states.incremental_states["online"] = {"only": torch.tensor(not states.finish_read())} + + x, outputs = self.model.decoder.forward( + prev_output_tokens=tgt_indices, + encoder_out=states.encoder_states, + incremental_state=states.incremental_states, + ) + + states.decoder_out = x + + states.decoder_out_extra = outputs + + torch.cuda.empty_cache() + + if outputs.action == 0: + return READ_ACTION + else: + return WRITE_ACTION + + def predict(self, states): + decoder_states = states.decoder_out + + lprobs = self.model.get_normalized_probs( + [decoder_states[:, -1:]], log_probs=True + ) + + index = lprobs.argmax(dim=-1) + + index = index[0, 0].item() + + if ( + self.force_finish + and index == self.model.decoder.dictionary.eos() + and not states.finish_read() + ): + # If we want to force finish the translation + # (don't stop before finish reading), return a None + # self.model.decoder.clear_cache(states.incremental_states) + index = None + + return index diff --git a/fairseq/examples/stories/README.md b/fairseq/examples/stories/README.md new file mode 100644 index 0000000000000000000000000000000000000000..588941eddc5f0280f5254affd40ef49de874c885 --- /dev/null +++ b/fairseq/examples/stories/README.md @@ -0,0 +1,66 @@ +# Hierarchical Neural Story Generation (Fan et al., 2018) + +The following commands provide an example of pre-processing data, training a model, and generating text for story generation with the WritingPrompts dataset. + +## Pre-trained models + +Description | Dataset | Model | Test set(s) +---|---|---|--- +Stories with Convolutional Model <br> ([Fan et al., 2018](https://arxiv.org/abs/1805.04833)) | [WritingPrompts](https://dl.fbaipublicfiles.com/fairseq/data/writingPrompts.tar.gz) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/stories_checkpoint.tar.bz2) | [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/stories_test.tar.bz2) + +We provide sample stories generated by the [convolutional seq2seq model](https://dl.fbaipublicfiles.com/fairseq/data/seq2seq_stories.txt) and [fusion model](https://dl.fbaipublicfiles.com/fairseq/data/fusion_stories.txt) from [Fan et al., 2018](https://arxiv.org/abs/1805.04833). The corresponding prompts for the fusion model can be found [here](https://dl.fbaipublicfiles.com/fairseq/data/fusion_prompts.txt). Note that there are unk in the file, as we modeled a small full vocabulary (no BPE or pre-training). We did not use these unk prompts for human evaluation. + +## Dataset + +The dataset can be downloaded like this: + +```bash +cd examples/stories +curl https://dl.fbaipublicfiles.com/fairseq/data/writingPrompts.tar.gz | tar xvzf - +``` + +and contains a train, test, and valid split. The dataset is described here: https://arxiv.org/abs/1805.04833. We model only the first 1000 words of each story, including one newLine token. + +## Example usage + +First we will preprocess the dataset. Note that the dataset release is the full data, but the paper models the first 1000 words of each story. Here is example code that trims the dataset to the first 1000 words of each story: +```python +data = ["train", "test", "valid"] +for name in data: + with open(name + ".wp_target") as f: + stories = f.readlines() + stories = [" ".join(i.split()[0:1000]) for i in stories] + with open(name + ".wp_target", "w") as o: + for line in stories: + o.write(line.strip() + "\n") +``` + +Once we've trimmed the data we can binarize it and train our model: +```bash +# Binarize the dataset: +export TEXT=examples/stories/writingPrompts +fairseq-preprocess --source-lang wp_source --target-lang wp_target \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/writingPrompts --padding-factor 1 --thresholdtgt 10 --thresholdsrc 10 + +# Train the model: +fairseq-train data-bin/writingPrompts -a fconv_self_att_wp --lr 0.25 --optimizer nag --clip-norm 0.1 --max-tokens 1500 --lr-scheduler reduce_lr_on_plateau --decoder-attention True --encoder-attention False --criterion label_smoothed_cross_entropy --weight-decay .0000001 --label-smoothing 0 --source-lang wp_source --target-lang wp_target --gated-attention True --self-attention True --project-input True --pretrained False + +# Train a fusion model: +# add the arguments: --pretrained True --pretrained-checkpoint path/to/checkpoint + +# Generate: +# Note: to load the pretrained model at generation time, you need to pass in a model-override argument to communicate to the fusion model at generation time where you have placed the pretrained checkpoint. By default, it will load the exact path of the fusion model's pretrained model from training time. You should use model-override if you have moved the pretrained model (or are using our provided models). If you are generating from a non-fusion model, the model-override argument is not necessary. + +fairseq-generate data-bin/writingPrompts --path /path/to/trained/model/checkpoint_best.pt --batch-size 32 --beam 1 --sampling --sampling-topk 10 --temperature 0.8 --nbest 1 --model-overrides "{'pretrained_checkpoint':'/path/to/pretrained/model/checkpoint'}" +``` + +## Citation +```bibtex +@inproceedings{fan2018hierarchical, + title = {Hierarchical Neural Story Generation}, + author = {Fan, Angela and Lewis, Mike and Dauphin, Yann}, + booktitle = {Conference of the Association for Computational Linguistics (ACL)}, + year = 2018, +} +``` diff --git a/fairseq/examples/textless_nlp/gslm/README.md b/fairseq/examples/textless_nlp/gslm/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7a76ffd57c066c20af94aa3fca24c18e2ba4c3dd --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/README.md @@ -0,0 +1,21 @@ +# Generative Spoken Language Modeling + +* [Paper](https://arxiv.org/abs/2102.01192) +* [Demo](https://speechbot.github.io/gslm/index.html) + +We build and evaluate generative speech2speech systems using [Log Mel Filtebank](https://pytorch.org/audio/stable/compliance.kaldi.html#fbank), [Modified CPC](https://github.com/facebookresearch/CPC_audio), [HuBERT Base](https://github.com/pytorch/fairseq/tree/main/examples/hubert) and [Wav2Vec 2.0 Large](https://github.com/pytorch/fairseq/tree/main/examples/wav2vec). Our system is composed of three components, namely, *speech2unit*, *ulm* and *unit2speech*. We explain about models and usage of these components in their respective sub-directories. See the links below. + +## Speech to Unit Model (speech2unit) +Speech to unit model is used for quantizing raw speech into learned discrete speech units. [More details](speech2unit) + +## Unit Language Model (ulm) +Unit Language Model is a generative language model trained on discrete speech units. [More details](ulm) + +## Unit to Speech Model (unit2speech) +Unit to speech model is used for synthesizing speech from discrete speech units. [More details](unit2speech) + +## Metrics +We show how to compute ASR based metrics as well as zero-shot metrics proposed in our paper [here](metrics). + +## Tools +We share two tools to resynthesize a given spoken utterance, and generate novel spoken language given a spoken prompt. [More detail](tools) diff --git a/fairseq/examples/textless_nlp/gslm/metrics/README.md b/fairseq/examples/textless_nlp/gslm/metrics/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0a63e2f0d844ce157f9502c82738aac2a0de3f0c --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/README.md @@ -0,0 +1,10 @@ +# GSLM Metrics + +## ASR Metrics +The suite of metrics here uses an ASR model to transcribe the synthesized speech into text, and then uses text-based metrics. We also use word error rate from ASR transcription itself as one of the metrics. [More details](asr_metrics) + +## ABX Metrics +We use [ABX](https://www.semanticscholar.org/paper/ABX-Discriminability-Measures-and-Applications-Schatz/13d3537228f728c1063cc83743cb118bba3367a0) to evaluate how well-separated phonetic categories are with quantized representations. [More details](abx_metrics) + +## sWUGGY and sBLIMP +We refer to [ZeroSpeech challenge](https://www.zerospeech.com/2021/track_s.html#scoring-based-metrics) for details on the sWUGGY and sBLIMP metrics. diff --git a/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/README.md b/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/README.md new file mode 100644 index 0000000000000000000000000000000000000000..aa2560f0453403fb5846c387848c78b037c79cb2 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/README.md @@ -0,0 +1,77 @@ +# ABX-based evaluation + +ABX is used to evaluate the quality of the obtained discrete units. + +The life cycle of the ABX-based evaluation for the Speech-to-Unit contains the following steps: +1. Training an acoustic model (or use an existing acoustic model) ([description](./../..)) +2. Perform quantization of speech by learning a K-means clustering model ([description](./../..)) +3. Compute discrete features for ABX computation using the learned clusters +4. Compute the ABX score over the discrete features taking advantage of [libri-light's ABX evaluation script][ll-abx] + +Here we assume that you already went throught the first two steps and focus solely on extracting features and computing ABX scores. + +## Libri-light setup + +Follow [libri-light's instructions][ll-instructions] for installation and [ABX evaluation setup][ll-abx] (including the download of the data items required for ABX computation). + +## Computing ABX + +### Dumping quantized features + +The first step for the ABX computation is to dump the quantized representations corresponding to the test files. + +```shell +TYPE="hubert" +LAYER=6 +CKPT_PATH="<PATH_TO_HUBERT_MODEL_CHECKPOINT_FILE>" +KM_MODEL_PATH="<PATH_TO_PRETRAINED_KM_MODEL_FILE>" + +SUBSET="dev-clean" +MANIFEST="<PATH_TO_MANIFEST_FOR_LS_DEV-CLEAN>" +DATA_DIR="<PATH_TO_DIR_TO_STORE_FEATURES>/$SUBSET" + +PYTHONPATH=. python examples/textless_nlp/gslm/metrics/abx_metrics/dump_abx_feats.py \ + --feature_type $TYPE \ + --kmeans_model_path $KM_MODEL_PATH \ + --checkpoint_path $CKPT_PATH \ + --layer $LAYER \ + --manifest_path $MANIFEST \ + --out_dir_path $DATA_DIR \ + --extension ".flac" +``` + +Again the manifest file follows the same structure than elsewhere in the codebase. + +### Compute ABX with Libri-light + +Use libri-light's `eval_ABX.py` script (within the appropriate environment set up) as followed: + +```shell +LIBRILIGHT_ROOT="<PATH_TO_LIBRILIGHT>" + +SUBSET="dev-clean" +DATA_DIR="<PATH_TO_DIR_TO_STORE_FEATURES>/$SUBSET" +ITEM_FILE_PATH="$LIBRILIGHT_ROOT/eval/ABX_data/$SUBSET.item" +OUT_DIR="<PATH_TO_DIR_TO_STORE_ABX_SCORES>/$SUBSET" + +FILE_EXTENSION=".npy" +FEATURE_SIZE=0.02 # depends on the model used + +PYTHONPATH=$LIBRILIGHT_ROOT \ + python $LIBRILIGHT_ROOT/eval/eval_ABX.py \ + $DATA_DIR \ + $ITEM_FILE_PATH \ + --file_extension $FILE_EXTENSION \ + --feature_size $FEATURE_SIZE \ + --out $OUT_DIR \ + --mode "all" +``` + +Note that `FEATURE_SIZE` will depend on the model type you are using to extract the acoustic features: +* For HuBERT and Wav2Vec2.0, use `FEATURE_SIZE=0.02` +* For CPC and Log Mel, use `FEATURE_SIZE=0.01` + +If you have a gpu available, make sure you add the `--cuda` flag for faster computation. + +[ll-instructions]: https://github.com/facebookresearch/libri-light +[ll-abx]: https://github.com/facebookresearch/libri-light/tree/master/eval#abx diff --git a/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/dump_abx_feats.py b/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/dump_abx_feats.py new file mode 100644 index 0000000000000000000000000000000000000000..41cf558970608fa5a9241e91e59ba214b609dc73 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/abx_metrics/dump_abx_feats.py @@ -0,0 +1,107 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os + +import joblib +import numpy as np + +from examples.textless_nlp.gslm.speech2unit.clustering.utils import get_audio_files +from examples.textless_nlp.gslm.speech2unit.pretrained.utils import get_features + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + +def get_parser(): + parser = argparse.ArgumentParser( + description="Quantize using K-means clustering over acoustic features." + ) + parser.add_argument( + "--feature_type", + type=str, + choices=["logmel", "hubert", "w2v2", "cpc"], + default=None, + required=True, + help="Acoustic feature type", + ) + parser.add_argument( + "--kmeans_model_path", + type=str, + required=True, + help="K-means model file path to use for inference", + ) + parser.add_argument( + "--manifest_path", + type=str, + default=None, + help="Manifest file containing the root dir and file names", + ) + parser.add_argument( + "--checkpoint_path", + type=str, + help="Pretrained model checkpoint", + ) + parser.add_argument( + "--layer", + type=int, + help="The layer of the pretrained model to extract features from", + default=-1, + ) + parser.add_argument( + "--out_dir_path", + required=True, + type=str, + help="File path of quantized output.", + ) + parser.add_argument( + "--extension", type=str, default=".flac", help="Features file path" + ) + return parser + + +def one_hot(feat, n_clusters): + return np.eye(n_clusters)[feat] + +def main(args, logger): + # Feature extraction + logger.info(f"Extracting {args.feature_type} acoustic features...") + features_batch = get_features( + feature_type=args.feature_type, + checkpoint_path=args.checkpoint_path, + layer=args.layer, + manifest_path=args.manifest_path, + sample_pct=1.0, + flatten=False, + ) + logger.info(f"Features extracted for {len(features_batch)} utterances.\n") + logger.info(f"Dimensionality of representation = {features_batch[0].shape[1]}") + + logger.info(f"Loading K-means model from {args.kmeans_model_path} ...") + kmeans_model = joblib.load(open(args.kmeans_model_path, "rb")) + kmeans_model.verbose = False + + _, fnames, _ = get_audio_files(args.manifest_path) + + os.makedirs(args.out_dir_path, exist_ok=True) + logger.info(f"Writing quantized features to {args.out_dir_path}") + for i, feats in enumerate(features_batch): + pred = kmeans_model.predict(feats) + emb = one_hot(pred, kmeans_model.n_clusters) + base_fname = os.path.basename(fnames[i]).rstrip(args.extension) + output_path = os.path.join(args.out_dir_path, f"{base_fname}.npy") + with open(output_path, "wb") as f: + np.save(f, emb) + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + main(args, logger) diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/README.md b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/README.md new file mode 100644 index 0000000000000000000000000000000000000000..90741f42b0b070f2a91b63c8badb817c6aa24230 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/README.md @@ -0,0 +1,87 @@ +# ASR-based evaluation + +Overall, the life cycle of the ASR-based evaluation for an ULM contains the following steps: + 1. Training an ULM and sampling from it [[description]](./../../ulm) + 2. Running UTS on the sampled unit sequences [[description]](./../../unit2speech) + 3. Pre-processing for the ASR (down-sampling to 16 KHz, aligning length of the generated audio with ground-truth utterances) + 4. Running ASR + 5. Calculation of the post-ASR evaluation metrics + +Here we assume that you have already went throught the first two steps and focus on the rest. + +## Preprocessing +### Down-sampling to 16KHz +The bulk conversion can be done by running +```bash + python $FAIRSEQ_ROOT/examples/textless_nlp/gslm/unit2speech/convert_to_16k.py $UTS_OUTPUT $UTS_OUTPUT_DOWNSAMPLE + ``` + where `$UTS_OUTPUT` specifies the directory with the generated audio and `$UTS_OUTPUT_DOWNSAMPLE` is the directory where downsampled audio would be saved. + + ### Matching by length +This step is somewhat optional. However, if you want to compare the fluency and diversity of a generated speech utterance to that of the ground-truth speech with the same prefix, it is a good idea to force them to be of the same length. +```bash +python $FAIRSEQ_ROOT/examples/textless_nlp/asr_metrics/cut_as.py \ + --samples_dir=$UTS_OUTPUT_DOWNSAMPLE --out_dir=$UTS_OUTPUT_DOWNSAMPLE_CUT \ + --prompts_description=data/ground_truth_continuation_dev.json +``` + +Here `ground_truth_continuation_dev.json` is a json file with ground-truth text from LibriSpeech dev-clean, associated with some meta-data (assuming the evaluation is done on dev-clean). This file can be downloaded [[here]](https://dl.fbaipublicfiles.com/textless_nlp/gslm/eval_data/ground_truth_continuation_dev.json). A similar file for the test-clean is [[here]](https://dl.fbaipublicfiles.com/textless_nlp/gslm/eval_data/ground_truth_continuation_test.json). These files are used for the evaluation and contain texts for audio sequences that are at least 6s long. + +## Running ASR +We use a pre-trained wav2vec model to run the ASR step. We firstly need to prepare manifest files which, roughly, tell the ASR system which files we want to transcribe. You can find more details and download the `960h_scratch.pt` checkpoint +[[here]](https://github.com/pytorch/fairseq/blob/main/examples/wav2vec/README.md)). To run ASR, you would also need to +install KenLM, Flashlight decoder, and download the KenLM 4-gram English language model. + +```bash + python $FAIRSEQ_ROOT/examples/wav2vec/wav2vec_manifest.py \ + $UTS_OUTPUT_DOWNSAMPLE_CUT --valid-percent 0.0 --dest $MANIFEST_DIR --ext wav +``` +where `$UTS_OUTPUT_DOWNSAMPLE_CUT` speficies the directory with the preprocessed UTS outputs and `$MANIFEST_DIR` is the output directory. + +We will be running an out-of-the-box evaluation script which requires ground-truth transcripts to measure quality metrics. We are only +interested in the transcripts (and we don't have ground-truth outputs for when our ULM generated!), hence we will just generate +some dummy transcripts instead: +```bash +cp $FAIRSEQ_ROOT/examples/textless_nlp/gslm/asr_metrics/misc/dict.ltr.txt $MANIFEST_DIR +python $FAIRSEQ_ROOT/examples/textless_nlp/gslm/asr_metrics/misc/dummy_asr_data.py --tsv=$MANIFEST_DIR/train.tsv \ + --output-dir=$MANIFEST_DIR +``` + +Now we are ready for running ASR: +``` +mkdir -p asr +python $FAIRSEQ_ROOT/examples/speech_recognition/infer.py \ + $MANIFEST_DIR \ + --task audio_pretraining --nbest 1 --path 960h_scratch.pt \ + --gen-subset=train --results-path $PATH_TO_ASR_OUTPUT \ + --w2l-decoder kenlm --lm-model 4-gram.bin \ + --lexicon librispeech/lexicon_ltr.lst --word-score -1 \ + --sil-weight 0 --lm-weight 2 --criterion ctc --labels ltr --max-tokens 300000 --remove-bpe letter +``` +where `lexicon_ltr.lst` is the LibriSpeech lexicon and `$PATH_TO_ASR_OUTPUT` is the output directory (can be downloaded [[here]](https://dl.fbaipublicfiles.com/textless_nlp/gslm/eval_data/lexicon_ltr.lst)). + +## Evaluation metrics +We run evaluation on the 1_000 shortest sequences that are at least 6s long. To filter those from the ASR transcript, we additionally provide each metric script with the paths to the manifest and `ground_truth_continuation_*` files. + +### Perplexity (PPX) +To get a PPX metric estimate on an ASR transcript, you need to run the following command: +```bash +python ppx.py $PATH_TO_ASR_OUTPUT/hypo.word-960h_scratch.pt-train.txt --cut-tail\ + --manifest=$MANIFEST_DIR/train.tsv --prompts-description=data/ground_truth_continuation_dev.json +``` +where `--cut-tail` tells the script to ignore the last token on each line (ASR puts the sequence ID there). + +### Self- and Auto-BLEU +```bash +python self_bleu.py $PATH_TO_ASR_OUTPUT/hypo.word-960h_scratch.pt-train.txt --cut-tail \ + --manifest=$MANIFEST_DIR/train.tsv --prompts-description=data/ground_truth_continuation_dev.json +``` + +### Continuation-BLEU +```bash +python continuation_eval.py --asr-transcript $PATH_TO_ASR_OUTPUT/hypo.word-960h_scratch.pt-train.txt \ + --manifest=$MANIFEST_DIR/train.tsv --prompts-description=data/ground_truth_continuation_dev.json +``` + +### AUC +Based on the metrics calculated above, we can estimate the AUC of the perplexity/diversity trade-off. We provide an illustration in a [Colab notebook](https://colab.research.google.com/drive/1pVPfOVax_PU3MkYdHRSsa-SI8GBUldNt?usp=sharing). diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/continuation_eval.py b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/continuation_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..72b92a341dcd1b82035af72b8a6b4edc65783ecc --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/continuation_eval.py @@ -0,0 +1,99 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from collections import defaultdict +import numpy as np +from misc.bleu_utils import sentence_bleu +import json +import warnings + + +def get_args(): + import argparse + + parser = argparse.ArgumentParser("Tool to calculate Continuation-BLEU2") + parser.add_argument('--asr-transcript', type=str, + help='Path to the transcript file.') + parser.add_argument('--prompts-description', type=str, + help='Path to the ground-truth continuation') + parser.add_argument('--manifest', type=str, required=True) + parser.add_argument('--take-shortest', type=int, default=1000) + + args = parser.parse_args() + + return args + + +def main(): + # NLTK produces warnings + warnings.filterwarnings("ignore") + + args = get_args() + + with open(args.prompts_description, 'r') as fin: + original_continuations = json.loads(fin.read()) + + sequence2length = [(k, v[0]) for k, v in original_continuations.items()] + assert all(float(v) >= 6.0 for (_, v) in sequence2length) # 6 seconds + + sequence2length.sort(key=lambda x: x[1]) + to_take = set(v[0] for v in sequence2length[:args.take_shortest]) + + with open(args.manifest, 'r') as fin: + fin.readline() + + linenum2file = dict([ + (i, l.split("__")[0]) for (i, l) in enumerate(fin) + ]) + + max_files = max(linenum2file.keys()) + continuations = defaultdict(list) + + mean_length_after = 0 + n_examples = 0 + + with open(args.asr_transcript, 'r') as fin: + for line in fin: + n_examples += 1 + line = line.split() + sequence_id = int(line[-1].split('-')[1][:-1]) + + assert sequence_id <= max_files + + sequence_name = linenum2file[sequence_id] + + continuations[sequence_name].append(line[:-1]) + mean_length_after += len(line) + + mean_length_after /= n_examples + print(f'Mean length of continuations, in words: {mean_length_after}') + metric_values = [] + + mean_ground_truth_words = 0 + n_examples = 0 + n_candidates = 0 + + for k, candidates in continuations.items(): + if k not in to_take: + continue + + n_examples += 1 + + ground_truth = original_continuations[k][1].split() + n_candidates += len(candidates) + bleu = sentence_bleu(candidates, ground_truth, weights=( + 0.5, 0.5), no_length_penalty=True, averaging_mode="geometric") + mean_ground_truth_words += len(ground_truth) + + metric_values.append(bleu) + + n = len(metric_values) + print( + f'Median BLEU over {n} examples: {np.median(metric_values)} +- {np.std(metric_values) / np.sqrt(n)}') + + +if __name__ == '__main__': + main() diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/bleu_utils.py b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/bleu_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..75cc5272d367c4f3be98d698b512a529bdb2e4f5 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/bleu_utils.py @@ -0,0 +1,166 @@ +""" + +TODO: the code is take from Apache-2 Licensed NLTK: make sure we do this properly! + + +Copied over from nltk.tranlate.bleu_score. This code has two major changes: + - allows to turn off length/brevity penalty --- it has no sense for self-bleu, + - allows to use arithmetic instead of geometric mean +""" + +import math +import sys +from fractions import Fraction +import warnings +from collections import Counter +from nltk.translate.bleu_score import modified_precision, closest_ref_length, brevity_penalty, SmoothingFunction + + +def corpus_bleu( + list_of_references, + hypotheses, + weights=(0.25, 0.25, 0.25, 0.25), + smoothing_function=None, + auto_reweigh=False, + averaging_mode="geometric", + no_length_penalty=False +): + """ + Calculate a single corpus-level BLEU score (aka. system-level BLEU) for all + the hypotheses and their respective references. + + Instead of averaging the sentence level BLEU scores (i.e. marco-average + precision), the original BLEU metric (Papineni et al. 2002) accounts for + the micro-average precision (i.e. summing the numerators and denominators + for each hypothesis-reference(s) pairs before the division). + + >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which', + ... 'ensures', 'that', 'the', 'military', 'always', + ... 'obeys', 'the', 'commands', 'of', 'the', 'party'] + >>> ref1a = ['It', 'is', 'a', 'guide', 'to', 'action', 'that', + ... 'ensures', 'that', 'the', 'military', 'will', 'forever', + ... 'heed', 'Party', 'commands'] + >>> ref1b = ['It', 'is', 'the', 'guiding', 'principle', 'which', + ... 'guarantees', 'the', 'military', 'forces', 'always', + ... 'being', 'under', 'the', 'command', 'of', 'the', 'Party'] + >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the', + ... 'army', 'always', 'to', 'heed', 'the', 'directions', + ... 'of', 'the', 'party'] + + >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was', + ... 'interested', 'in', 'world', 'history'] + >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history', + ... 'because', 'he', 'read', 'the', 'book'] + + >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]] + >>> hypotheses = [hyp1, hyp2] + >>> corpus_bleu(list_of_references, hypotheses) # doctest: +ELLIPSIS + 0.5920... + + The example below show that corpus_bleu() is different from averaging + sentence_bleu() for hypotheses + + >>> score1 = sentence_bleu([ref1a, ref1b, ref1c], hyp1) + >>> score2 = sentence_bleu([ref2a], hyp2) + >>> (score1 + score2) / 2 # doctest: +ELLIPSIS + 0.6223... + + :param list_of_references: a corpus of lists of reference sentences, w.r.t. hypotheses + :type list_of_references: list(list(list(str))) + :param hypotheses: a list of hypothesis sentences + :type hypotheses: list(list(str)) + :param weights: weights for unigrams, bigrams, trigrams and so on + :type weights: list(float) + :param smoothing_function: + :type smoothing_function: SmoothingFunction + :param auto_reweigh: Option to re-normalize the weights uniformly. + :type auto_reweigh: bool + :return: The corpus-level BLEU score. + :rtype: float + """ + # Before proceeding to compute BLEU, perform sanity checks. + + p_numerators = Counter() # Key = ngram order, and value = no. of ngram matches. + p_denominators = Counter() # Key = ngram order, and value = no. of ngram in ref. + hyp_lengths, ref_lengths = 0, 0 + + assert len(list_of_references) == len(hypotheses), ( + "The number of hypotheses and their reference(s) should be the " "same " + ) + + # Iterate through each hypothesis and their corresponding references. + for references, hypothesis in zip(list_of_references, hypotheses): + # For each order of ngram, calculate the numerator and + # denominator for the corpus-level modified precision. + for i, _ in enumerate(weights, start=1): + p_i = modified_precision(references, hypothesis, i) + p_numerators[i] += p_i.numerator + p_denominators[i] += p_i.denominator + + # Calculate the hypothesis length and the closest reference length. + # Adds them to the corpus-level hypothesis and reference counts. + hyp_len = len(hypothesis) + hyp_lengths += hyp_len + ref_lengths += closest_ref_length(references, hyp_len) + + # Calculate corpus-level brevity penalty. + if no_length_penalty and averaging_mode == 'geometric': + bp = 1.0 + elif no_length_penalty and averaging_mode == 'arithmetic': + bp = 0.0 + else: + assert not no_length_penalty + assert averaging_mode != 'arithmetic', 'Not sure how to apply length penalty when aurithmetic mode' + bp = brevity_penalty(ref_lengths, hyp_lengths) + + # Uniformly re-weighting based on maximum hypothesis lengths if largest + # order of n-grams < 4 and weights is set at default. + if auto_reweigh: + if hyp_lengths < 4 and weights == (0.25, 0.25, 0.25, 0.25): + weights = (1 / hyp_lengths,) * hyp_lengths + + # Collects the various precision values for the different ngram orders. + p_n = [ + Fraction(p_numerators[i], p_denominators[i], _normalize=False) + for i, _ in enumerate(weights, start=1) + ] + + # Returns 0 if there's no matching n-grams + # We only need to check for p_numerators[1] == 0, since if there's + # no unigrams, there won't be any higher order ngrams. + if p_numerators[1] == 0: + return 0 + + # If there's no smoothing, set use method0 from SmoothinFunction class. + if not smoothing_function: + smoothing_function = SmoothingFunction().method0 + # Smoothen the modified precision. + # Note: smoothing_function() may convert values into floats; + # it tries to retain the Fraction object as much as the + # smoothing method allows. + p_n = smoothing_function( + p_n, references=references, hypothesis=hypothesis, hyp_len=hyp_lengths + ) + + if averaging_mode == "geometric": + s = (w_i * math.log(p_i) for w_i, p_i in zip(weights, p_n)) + s = bp * math.exp(math.fsum(s)) + elif averaging_mode == "arithmetic": + s = (w_i * p_i for w_i, p_i in zip(weights, p_n)) + s = math.fsum(s) + + return s + + +def sentence_bleu( + references, + hypothesis, + weights=(0.25, 0.25, 0.25, 0.25), + smoothing_function=None, + auto_reweigh=False, + averaging_mode="geometric", + no_length_penalty=False +): + return corpus_bleu( + [references], [hypothesis], weights, smoothing_function, auto_reweigh, averaging_mode, no_length_penalty + ) \ No newline at end of file diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/cut_as.py b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/cut_as.py new file mode 100644 index 0000000000000000000000000000000000000000..5b7e1e968564b84c47049c5cc69c9d6b8fafe0e9 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/cut_as.py @@ -0,0 +1,69 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import torchaudio +import argparse +import json +import pathlib + + +def get_args(): + parser = argparse.ArgumentParser( + "Assuring generated audio have the same length as ground-truth audio") + parser.add_argument('--samples_dir', required=True, type=str) + parser.add_argument('--out_dir', required=True, type=str) + parser.add_argument('--prompts_description', required=True, type=str) + return parser.parse_args() + + +def cut(src, tgt, l): + x, sr = torchaudio.load(str(src)) + assert sr == 16_000 + + x = x.squeeze() + target_frames = int(l * sr) + + flag = 0 + if target_frames <= x.size(0): + x = x[:target_frames] + flag = 1 + else: + flag = 0 + torchaudio.save(str(tgt), x.unsqueeze(0), sr) + return flag + + +def main(): + args = get_args() + tgt_dir = pathlib.Path(args.out_dir) + tgt_dir.mkdir(exist_ok=True, parents=True) + + total_files, sufficiently_long = 0, 0 + + with open(args.prompts_description, 'r') as f: + description = json.loads(f.read()) + + for src_f in pathlib.Path(args.samples_dir).glob('*.wav'): + name_prompt = src_f.with_suffix('').name.split('__')[0] + + assert name_prompt in description, f'Cannot find {name_prompt}!' + + target_length = description[name_prompt][0] + tgt_f = tgt_dir / (src_f.name) + + is_long_enough = cut(src_f, tgt_f, target_length) + sufficiently_long += is_long_enough + if not is_long_enough: + print(f'{src_f} is not long enough') + + total_files += 1 + + print( + f'Total files: {total_files}; sufficiently long: {sufficiently_long}') + + +if __name__ == '__main__': + main() diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/dict.ltr.txt b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/dict.ltr.txt new file mode 100644 index 0000000000000000000000000000000000000000..69929e1666c8182148d83ef4332e4c677bb90e5a --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/misc/dict.ltr.txt @@ -0,0 +1,28 @@ +| 94802 +E 51860 +T 38431 +A 33152 +O 31495 +N 28855 +I 28794 +H 27187 +S 26071 +R 23546 +D 18289 +L 16308 +U 12400 +M 10685 +W 10317 +C 9844 +F 9062 +G 8924 +Y 8226 +P 6890 +B 6339 +V 3936 +K 3456 +' 1023 +X 636 +J 598 +Q 437 +Z 213 diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/ppx.py b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/ppx.py new file mode 100644 index 0000000000000000000000000000000000000000..d6a40e4d359bdcae6d64f53ba06d8a533aec01ac --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/ppx.py @@ -0,0 +1,122 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import torch +import numpy as np +import warnings + + +def get_target_sequences(manifest, ground_truth, to_take=1000): + import json + import pathlib + + with open(ground_truth, 'r') as fin: + original_continuations = json.loads(fin.read()) + + sequence2length = [(k, v[0]) for k, v in original_continuations.items()] + assert all(float(v) >= 6.0 for (_, v) in sequence2length) # 6 seconds + + sequence2length.sort(key=lambda x: x[1]) + to_take_sequences = set(v[0] for v in sequence2length[:to_take]) + to_take_ids = [] + + with open(manifest, 'r') as f: + f.readline() + + for i, line in enumerate(f.readlines()): + seq_id = line.split()[0] + seq_id = pathlib.Path(seq_id).name.split('__')[0] + + if seq_id in to_take_sequences: + to_take_ids.append(i) + + print(f'Took {len(to_take_ids)} ids') + return set(to_take_ids) + + +def get_args(): + import argparse + + parser = argparse.ArgumentParser("Evaluate PPX metric of a transcript.") + parser.add_argument('--asr-transcript', type=str, + help='Path to the transcript file.') + parser.add_argument('--cut-id', action='store_true', + help='Whether cut the first token (typically a seq id)') + parser.add_argument('--cut-tail', action='store_true', + help='Whether cut the last token (typically a speaker id)') + + parser.add_argument('--manifest', type=str, default=None) + parser.add_argument('--prompts-description', type=str, default=None) + + args = parser.parse_args() + + return args + + +def main(): + args = get_args() + + lm = torch.hub.load( + 'pytorch/fairseq', 'transformer_lm.wmt19.en', tokenizer='moses', bpe='fastbpe') + + lm.eval().cuda() # disable dropout + + if args.manifest is None and args.prompts_description is None: + target_ids = None + else: + target_ids = get_target_sequences( + args.manifest, args.prompts_description) + + with open(args.asr_transcript, 'r') as fin: + lines = fin.readlines() + + if target_ids is not None: + filtered = [] + for line in lines: + line_id = line.split()[-1] + line_id = int(line_id.split('-')[1][:-1]) + if line_id in target_ids: + filtered.append(line) + lines = filtered + else: + pass + + if args.cut_id: + lines = [' '.join(x.split()[1:]) for x in lines] + if args.cut_tail: + lines = [' '.join(x.split()[:-1]) for x in lines] + lines = [x.strip().lower() for x in lines] + + def get_logprob(sent): return \ + lm.score(sent)['positional_scores'].mean().neg().item() + + logprobs = [get_logprob(l) for l in lines] + + filtered = [x for x in logprobs if not np.isnan(x)] + if len(filtered) != len(logprobs): + warnings.warn("NaNs detected!") + logprobs = filtered + + perplexities = [np.exp(l) for l in logprobs] + + for name, stats in [('logprob', logprobs), ('perplexity', perplexities)]: + mean = np.mean(stats) + sem = np.std(stats) / np.sqrt(len(stats)) + + median = np.median(stats) + interval = list(np.percentile(stats, [10, 90])) + + mean, sem, median, percentile10, percentile90 = [ + round(x, 2) for x in [mean, sem, median] + interval] + + print(name) + print(f"\tMean {mean} +- {sem}") + print( + f"\tMedian {median}, 90% confidence interval {percentile10}...{percentile90}") + + +if __name__ == '__main__': + main() diff --git a/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/self_auto_bleu.py b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/self_auto_bleu.py new file mode 100644 index 0000000000000000000000000000000000000000..062bb82f669f63a537b6ee8df4d42d292eb2575e --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/metrics/asr_metrics/self_auto_bleu.py @@ -0,0 +1,201 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import nltk +from misc.bleu_utils import sentence_bleu +import warnings + + +def get_target_sequences(manifest, ground_truth, to_take=1000): + import json + import pathlib + + with open(ground_truth, 'r') as fin: + original_continuations = json.loads(fin.read()) + + sequence2length = [(k, v[0]) for k, v in original_continuations.items()] + assert all(float(v) >= 6.0 for (_, v) in sequence2length) # 6 seconds + + sequence2length.sort(key=lambda x: x[1]) + to_take_sequences = set(v[0] for v in sequence2length[:to_take]) + to_take_ids = [] + + with open(manifest, 'r') as f: + f.readline() + + for i, line in enumerate(f.readlines()): + seq_id = line.split()[0] + seq_id = pathlib.Path(seq_id).name.split('__')[0] + + if seq_id in to_take_sequences: + to_take_ids.append(i) + + print(f'Took {len(to_take_ids)} ids') + return set(to_take_ids) + + +def get_args(): + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument('--asr-transcript', type=str, + help='Path to the transcript file.') + + parser.add_argument('--manifest', required=True) + parser.add_argument('--prompts-description', required=True) + + parser.add_argument('--cut-id', action='store_true', + help='Whether cut the first token (typically a seq id)') + parser.add_argument('--cut-tail', action='store_true', + help='Whether cut the last token (typically a speaker id)') + parser.add_argument('--debug', action='store_true') + + args = parser.parse_args() + + return args + + +def get_self_bleu(utterances, averaging_mode, weights): + self_bleu = [] + + for i in range(len(utterances)): + hypo = utterances[i] + rest = utterances[:i] + utterances[i+1:] + + self_bleu.append(sentence_bleu(rest, hypo, weights, + no_length_penalty=True, averaging_mode=averaging_mode)) + + return self_bleu + + +def get_self_bleu2_arithmetic(utterances): + weights = (0.5, 0.5) # equal weight for unigrams and bigrams + return get_self_bleu(utterances, averaging_mode='arithmetic', weights=weights) + + +def get_self_bleu2_geometric(utterances): + weights = (0.5, 0.5) + return get_self_bleu(utterances, averaging_mode='geometric', weights=weights) + + +def get_auto_bleu2_arithmetic(utterances): + weights = (0.5, 0.5) + return [auto_bleu(u, mean_mode='arithmetic', weights=weights) for u in utterances] + + +def get_auto_bleu2_geometric(utterances): + weights = (0.5, 0.5) + return [auto_bleu(u, mean_mode='geometric', weights=weights) for u in utterances] + + +def get_auto_bleu3_geometric(utterances): + weights = (1./3, 1./3, 1./3) + return [auto_bleu(u, mean_mode='geometric', weights=weights) for u in utterances] + + +def get_auto_bleu3_arithmetic(utterances): + weights = (1./3, 1./3, 1./3) + return [auto_bleu(u, mean_mode='arithmetic', weights=weights) for u in utterances] + + +def get_self_bleu3_arithmetic(utterances): + weights = (1./3, 1./3, 1./3) + return get_self_bleu(utterances, averaging_mode='arithmetic', weights=weights) + + +def get_self_bleu3_geometric(utterances): + weights = (1./3, 1./3, 1./3) + return get_self_bleu(utterances, averaging_mode='geometric', weights=weights) + + +def auto_bleu(sentence, weights, mean_mode='arithmetic'): + if len(sentence) <= 1: + return 0 + + N = len(weights) + + bleu_n = np.zeros([N]) + for n in range(N): + targ_ngrams = list(nltk.ngrams(sentence, n+1)) + for p in range(len(targ_ngrams)): + left = sentence[:p] + right = sentence[(p+n+1):] + rest_ngrams = list(nltk.ngrams(left, n+1)) + \ + list(nltk.ngrams(right, n+1)) + # compute the nb of matching ngrams + bleu_n[n] += targ_ngrams[p] in rest_ngrams + bleu_n[n] /= len(targ_ngrams) # average them to get a proportion + + weights = np.array(weights) + if mean_mode == 'arithmetic': + return (bleu_n * weights).sum() + elif mean_mode == 'geometric': + return (bleu_n ** weights).prod() + else: + raise ValueError(f'Unknown agggregation mode {mean_mode}') + + +def main(): + from multiprocessing import Pool + + args = get_args() + target_ids = get_target_sequences(args.manifest, args.prompts_description) + + with open(args.asr_transcript, 'r') as fin: + lines = fin.readlines() + + terms = [x.strip().split() for x in lines] + filtered = [] + for term in terms: + line_id = int(term[-1].split('-')[1][:-1]) + if line_id in target_ids: + filtered.append(term) + terms = filtered + + if args.cut_id: + terms = [x[1:] for x in terms] + if args.cut_tail: + terms = [x[:-1] for x in terms] + + if args.debug: + terms = terms[:10] + + tasks = [ + ('Self-BLEU2-arithmetic', get_self_bleu2_arithmetic), + ('Self-BLEU2-geometric', get_self_bleu2_geometric), + ('Auto-BLEU2-arithmetic', get_auto_bleu2_arithmetic), + ('Auto-BLEU2-geometric', get_auto_bleu2_geometric), + + ('Self-BLEU3-arithmetic', get_self_bleu3_arithmetic), + ('Self-BLEU3-geometric', get_self_bleu3_geometric), + ('Auto-BLEU3-arithmetic', get_auto_bleu3_arithmetic), + ('Auto-BLEU3-geometric', get_auto_bleu3_geometric), + ] + + n_processes = min(16, len(tasks)) + with Pool(n_processes) as pool: + metrics = pool.map(run_f, [(t[1], terms) for t in tasks]) + + for (metric_name, _), metric in zip(tasks, metrics): + metric, sem = np.mean(metric), np.std(metric) / np.sqrt(len(metric)) + + metric, sem = [ + round(100 * x, 2) for x in [metric, sem] + ] + + print(f'{metric_name} {metric} +- {sem}') + + +def run_f(task_params): + f, terms = task_params + return f(terms) + + +if __name__ == '__main__': + # NLTK produces warnings + warnings.filterwarnings("ignore") + + main() diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/README.md b/fairseq/examples/textless_nlp/gslm/speech2unit/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1a3d131ec165f12e37906420fc2c284a7223bda2 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/README.md @@ -0,0 +1,71 @@ +# Speech to Unit Model (speech2unit) + +## Acoustic Model +For quantizing speech we learn a K-means clustering over acoustic representations for which we either use Log-Mel Filterbank or pretrained acoustic representation models. For using pretrained models, please download from their respective locations linked below. +* [Modified CPC](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/cpc_big_ll6kh_top_ctc.pt) +* [HuBERT-Base](https://dl.fbaipublicfiles.com/hubert/hubert_base_ls960.pt) +* [Wav2Vec 2.0-Base](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_new.pt) + +## Quantization Model +You can download pretrained quantized model from the list below. + +K-Means Model | Download Link +|-|- +Log Mel Filterbank + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/km50/km.bin) +Log Mel Filterbank + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/km100/km.bin) +Log Mel Filterbank + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/km200/km.bin) +Log Mel Filterbank + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/km500/km.bin) +Modified CPC + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/km50/km.bin) +Modified CPC + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/km100/km.bin) +Modified CPC + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/km200/km.bin) +Modified CPC + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/km500/km.bin) +HuBERT Base + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/km50/km.bin) +HuBERT Base + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/km100/km.bin) +HuBERT Base + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/km200/km.bin) +HuBERT Base + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/km500/km.bin) +wav2vec 2.0 Large + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/km50/km.bin) +wav2vec 2.0 Large + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/km100/km.bin) +wav2vec 2.0 Large + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/km200/km.bin) +wav2vec 2.0 Large + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/km500/km.bin) + +### Quantization +For quantizing speech with a given acoustic representation, please follow the steps below. +1. Learn K-means clustering model +``` +N_CLUSTERS=<number_of_clusters_used_for_kmeans> +TYPE=<one_of_logmel/cpc/hubert/w2v2> +CKPT_PATH=<path_of_pretrained_acoustic_model> +LAYER=<layer_of_acoustic_model_to_extract_features_from> +MANIFEST=<tab_separated_manifest_of_audio_files_for_training_kmeans> +KM_MODEL_PATH=<output_path_of_the_kmeans_model> + +PYTHONPATH=. python examples/textless_nlp/gslm/speech2unit/clustering/cluster_kmeans.py \ + --num_clusters $N_CLUSTERS \ + --feature_type $TYPE \ + --checkpoint_path $CKPT_PATH \ + --layer $LAYER \ + --manifest_path $MANIFEST \ + --out_kmeans_model_path $KM_MODEL_PATH +``` +2. Quantize using the learned clusters +``` +MANIFEST=<tab_separated_manifest_of_audio_files_to_quantize> +OUT_QUANTIZED_FILE=<output_quantized_audio_file_path> + +python examples/textless_nlp/gslm/speech2unit/clustering/del/quantize_with_kmeans.py \ + --feature_type $TYPE \ + --kmeans_model_path $KM_MODEL_PATH \ + --checkpoint_path $CKPT_PATH \ + --layer $LAYER \ + --manifest_path $MANIFEST \ + --out_quantized_file_path $OUT_QUANTIZED_FILE \ + --extension ".flac" +``` + +Note about the manifest file is a file with paths and length of input audio files. The format of the file is as follows: +``` +<path_of_root_directory_containing_audio_files> +<relative_path_of_audio_file_1>\t<number_of_frames_1> +<relative_path_of_audio_file_2>\t<number_of_frames_1> +... +``` \ No newline at end of file diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/__init__.py b/fairseq/examples/textless_nlp/gslm/speech2unit/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/__init__.py b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/cluster_kmeans.py b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/cluster_kmeans.py new file mode 100644 index 0000000000000000000000000000000000000000..7cf844a95a075ee9ad318dc11dd71537d1ef6a5b --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/cluster_kmeans.py @@ -0,0 +1,212 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os +import time + +import numpy as np +from sklearn.cluster import MiniBatchKMeans + +import joblib +from examples.textless_nlp.gslm.speech2unit.pretrained.utils import ( + get_and_dump_features, + get_features, +) + + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + + +def get_parser(): + parser = argparse.ArgumentParser( + description="Learn K-means clustering over acoustic features." + ) + + # Features arguments + parser.add_argument( + "--in_features_path", type=str, default=None, help="Features file path" + ) + parser.add_argument( + "--feature_type", + type=str, + choices=["logmel", "hubert", "w2v2", "cpc"], + default=None, + help="Acoustic feature type", + ) + parser.add_argument( + "--manifest_path", + type=str, + default=None, + help="Manifest file containing the root dir and file names", + ) + parser.add_argument( + "--out_features_path", + type=str, + default=None, + help="Features file path to write to", + ) + parser.add_argument( + "--checkpoint_path", + type=str, + help="Pretrained acoustic model checkpoint", + ) + parser.add_argument( + "--layer", + type=int, + help="The layer of the pretrained model to extract features from", + default=-1, + ) + parser.add_argument( + "--sample_pct", + type=float, + help="Percent data to use for K-means training", + default=0.1, + ) + + # K-means arguments + parser.add_argument( + "--num_clusters", type=int, help="Nubmer of clusters", default=50 + ) + parser.add_argument("--init", default="k-means++") + parser.add_argument( + "--max_iter", + type=int, + help="Maximum number of iterations for K-means training", + default=150, + ) + parser.add_argument( + "--batch_size", + type=int, + help="Batch size for K-means training", + default=10000, + ) + parser.add_argument("--tol", default=0.0, type=float) + parser.add_argument("--max_no_improvement", default=100, type=int) + parser.add_argument("--n_init", default=20, type=int) + parser.add_argument("--reassignment_ratio", default=0.5, type=float) + parser.add_argument( + "--out_kmeans_model_path", + type=str, + required=True, + help="Path to save K-means model", + ) + + # Leftovers + parser.add_argument( + "--seed", + type=int, + help="Random seed to use for K-means training", + default=1369, + ) + + return parser + + +def get_kmeans_model( + n_clusters, + init, + max_iter, + batch_size, + tol, + max_no_improvement, + n_init, + reassignment_ratio, + random_state, +): + return MiniBatchKMeans( + n_clusters=n_clusters, + init=init, + max_iter=max_iter, + batch_size=batch_size, + tol=tol, + max_no_improvement=max_no_improvement, + n_init=n_init, + reassignment_ratio=reassignment_ratio, + random_state=random_state, + verbose=1, + compute_labels=True, + init_size=None, + ) + + +def train_kmeans(kmeans_model, features_batch): + start_time = time.time() + kmeans_model.fit(features_batch) + time_taken = round((time.time() - start_time) // 60, 2) + return kmeans_model, time_taken + + +def main(args, logger): + # Features loading/extraction for K-means + if args.in_features_path: + # Feature loading + logger.info(f"Loading features from {args.in_features_path}...") + features_batch = np.load(args.in_features_path, allow_pickle=True) + else: + # Feature extraction + logger.info(f"Extracting {args.feature_type} acoustic features...") + features_batch = ( + get_features( + feature_type=args.feature_type, + checkpoint_path=args.checkpoint_path, + layer=args.layer, + manifest_path=args.manifest_path, + sample_pct=args.sample_pct, + flatten=True, + ) + if not args.out_features_path + else get_and_dump_features( + feature_type=args.feature_type, + checkpoint_path=args.checkpoint_path, + layer=args.layer, + manifest_path=args.manifest_path, + sample_pct=args.sample_pct, + flatten=True, + out_features_path=args.out_features_path, + ) + ) + if args.out_features_path: + logger.info( + f"Saved extracted features at {args.out_features_path}" + ) + logger.info(f"Features shape = {features_batch.shape}\n") + + # Learn and save K-means model + kmeans_model = get_kmeans_model( + n_clusters=args.num_clusters, + init=args.init, + max_iter=args.max_iter, + batch_size=args.batch_size, + tol=args.tol, + max_no_improvement=args.max_no_improvement, + n_init=args.n_init, + reassignment_ratio=args.reassignment_ratio, + random_state=args.seed, + ) + logger.info("Starting k-means training...") + kmeans_model, time_taken = train_kmeans( + kmeans_model=kmeans_model, features_batch=features_batch + ) + logger.info(f"...done k-means training in {time_taken} minutes") + inertia = -kmeans_model.score(features_batch) / len(features_batch) + logger.info(f"Total intertia: {round(inertia, 2)}\n") + + logger.info(f"Saving k-means model to {args.out_kmeans_model_path}") + os.makedirs(os.path.dirname(args.out_kmeans_model_path), exist_ok=True) + joblib.dump(kmeans_model, open(args.out_kmeans_model_path, "wb")) + + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + main(args, logger) diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/dump_feats.py b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/dump_feats.py new file mode 100644 index 0000000000000000000000000000000000000000..031567c6d85d16b5236053abf008b7cabccb4673 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/dump_feats.py @@ -0,0 +1,91 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging + +from examples.textless_nlp.gslm.speech2unit.pretrained.utils import ( + get_and_dump_features, +) + + +def get_parser(): + parser = argparse.ArgumentParser( + description="Compute and dump log mel fbank features." + ) + parser.add_argument( + "--feature_type", + type=str, + choices=["logmel", "hubert", "w2v2", "cpc"], + default=None, + help="Acoustic feature type", + ) + parser.add_argument( + "--manifest_path", + type=str, + default=None, + help="Manifest file containing the root dir and file names", + ) + parser.add_argument( + "--out_features_path", + type=str, + default=None, + help="Features file path to write to", + ) + parser.add_argument( + "--checkpoint_path", + type=str, + help="Pretrained acoustic model checkpoint", + ) + parser.add_argument( + "--layer", + type=int, + help="The layer of the pretrained model to extract features from", + default=-1, + ) + parser.add_argument( + "--sample_pct", + type=float, + help="Percent data to use for K-means training", + default=0.1, + ) + parser.add_argument( + "--out_features_path", + type=str, + help="Path to save log mel fbank features", + ) + return parser + + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + + +if __name__ == "__main__": + """ + Example command: + python ~/speechbot/clustering/dump_logmelfank_feats.py \ + --manifest_path /checkpoint/kushall/data/LJSpeech-1.1/asr_input_wavs_16k/train.tsv + --out_features_path /checkpoint/kushall/experiments/speechbot/logmelfbank/features/ljspeech/train.npy + """ + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + + logger.info(f"Extracting {args.feature_type} acoustic features...") + get_and_dump_features( + feature_type=args.feature_type, + checkpoint_path=args.checkpoint_path, + layer=args.layer, + manifest_path=args.manifest_path, + sample_pct=args.sample_pct, + flatten=True, + out_features_path=args.out_features_path, + ) + logger.info(f"Saved extracted features at {args.out_features_path}") diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/quantize_with_kmeans.py b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/quantize_with_kmeans.py new file mode 100644 index 0000000000000000000000000000000000000000..2c87445d810cd790f887d1a135287a334cbdf223 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/quantize_with_kmeans.py @@ -0,0 +1,125 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os + +import numpy as np + +import joblib +from examples.textless_nlp.gslm.speech2unit.clustering.utils import ( + get_audio_files, +) +from examples.textless_nlp.gslm.speech2unit.pretrained.utils import ( + get_features, +) + + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + + +def get_parser(): + parser = argparse.ArgumentParser( + description="Quantize using K-means clustering over acoustic features." + ) + parser.add_argument( + "--feature_type", + type=str, + choices=["logmel", "hubert", "w2v2", "cpc"], + default=None, + required=True, + help="Acoustic feature type", + ) + parser.add_argument( + "--acoustic_model_path", + type=str, + help="Pretrained acoustic model checkpoint" + ) + parser.add_argument( + "--layer", + type=int, + help="The layer of the pretrained model to extract features from", + default=-1, + ) + parser.add_argument( + "--kmeans_model_path", + type=str, + required=True, + help="K-means model file path to use for inference", + ) + parser.add_argument( + "--features_path", + type=str, + default=None, + help="Features file path. You don't need to enter acoustic model details if you have dumped features", + ) + parser.add_argument( + "--manifest_path", + type=str, + default=None, + help="Manifest file containing the root dir and file names", + ) + parser.add_argument( + "--out_quantized_file_path", + required=True, + type=str, + help="File path of quantized output.", + ) + parser.add_argument( + "--extension", type=str, default=".flac", help="Features file path" + ) + return parser + + +def main(args, logger): + # Feature extraction + if args.features_path is not None: + logger.info(f"Loading acoustic features from {args.features_path}...") + features_batch = np.load(args.features_path) + else: + logger.info(f"Extracting {args.feature_type} acoustic features...") + features_batch = get_features( + feature_type=args.feature_type, + checkpoint_path=args.acoustic_model_path, + layer=args.layer, + manifest_path=args.manifest_path, + sample_pct=1.0, + flatten=False, + ) + logger.info( + f"Features extracted for {len(features_batch)} utterances.\n" + ) + logger.info( + f"Dimensionality of representation = {features_batch[0].shape[1]}" + ) + + # K-means model + logger.info(f"Loading K-means model from {args.kmeans_model_path} ...") + kmeans_model = joblib.load(open(args.kmeans_model_path, "rb")) + kmeans_model.verbose = False + + _, fnames, _ = get_audio_files(args.manifest_path) + + os.makedirs(os.path.dirname(args.out_quantized_file_path), exist_ok=True) + print(f"Writing quantized predictions to {args.out_quantized_file_path}") + with open(args.out_quantized_file_path, "w") as fout: + for i, feats in enumerate(features_batch): + pred = kmeans_model.predict(feats) + pred_str = " ".join(str(p) for p in pred) + base_fname = os.path.basename(fnames[i]).rstrip(args.extension) + fout.write(f"{base_fname}|{pred_str}\n") + + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + main(args, logger) diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/utils.py b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..cf08d1fe4b470477b724aa8d770d91c0cac35a0e --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/clustering/utils.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import List, Tuple + + +def get_audio_files(manifest_path: str) -> Tuple[str, List[str], List[int]]: + fnames, sizes = [], [] + with open(manifest_path, "r") as f: + root_dir = f.readline().strip() + for line in f: + items = line.strip().split("\t") + assert ( + len(items) == 2 + ), f"File must have two columns separated by tab. Got {line}" + fnames.append(items[0]) + sizes.append(int(items[1])) + return root_dir, fnames, sizes diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/cpc_feature_reader.py b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/cpc_feature_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..c613f52d3c3de43a048849a231a9a34e2a883486 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/cpc_feature_reader.py @@ -0,0 +1,192 @@ +import soundfile as sf +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class CpcFeatureReader: + """ + Wrapper class to run inference on CPC model. + Helps extract features for a given audio file. + """ + + def __init__( + self, + checkpoint_path, + layer, + use_encoder_layer=False, + norm_features=False, + sample_rate=16000, + max_chunk=64000, + ): + self.model = load_cpc_model(checkpoint_path, layer).eval().cuda() + self.sample_rate = sample_rate + self.max_chunk = max_chunk + self.norm_features = norm_features + self.use_encoder_layer = use_encoder_layer + + def read_audio(self, path, ref_len=None): + wav, sr = sf.read(path) + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + assert sr == self.sample_rate, sr + if ref_len is not None and abs(ref_len - len(wav)) > 160: + print(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + def get_feats(self, file_path, ref_len=None): + x = self.read_audio(file_path, ref_len) + # Inspired from CPC_audio feature_loader.py + with torch.no_grad(): + x = torch.from_numpy(x).float().cuda() + x = x.view(1, 1, -1) + size = x.size(2) + feat = [] + start = 0 + while start < size: + if start + self.max_chunk > size: + break + x_chunk = x[..., start : start + self.max_chunk] + feat_chunk = self.model.extract_features( + source=x_chunk, + get_encoded=self.use_encoder_layer, + norm_output=self.norm_features, + ) + feat.append(feat_chunk) + start += self.max_chunk + + if start < size: + x_chunk = x[:, -self.max_chunk :] + feat_chunk = self.model.extract_features( + source=x_chunk, + get_encoded=self.use_encoder_layer, + norm_output=self.norm_features, + ) + df = x_chunk.size(2) // feat_chunk.size(1) + delta = (size - start) // df + feat.append(feat_chunk[:, -delta:]) + return torch.cat(feat, 1).squeeze(0) + + +def load_cpc_model(checkpoint_path, layer=None): + state_dict = torch.load(checkpoint_path) + weights = state_dict["weights"] + config = state_dict["config"] + if layer is not None: + config["nLevelsGRU"] = layer + + encoder = CPCEncoder(config["hiddenEncoder"]) + ar_net = CPCAR( + config["hiddenEncoder"], config["hiddenGar"], False, config["nLevelsGRU"] + ) + + model = CPCModel(encoder, ar_net) + model.load_state_dict(weights, strict=False) + model.config = config + + return model + + +class ChannelNorm(nn.Module): + def __init__(self, num_features, epsilon=1e-05, affine=True): + super(ChannelNorm, self).__init__() + if affine: + self.weight = nn.parameter.Parameter(torch.Tensor(1, num_features, 1)) + self.bias = nn.parameter.Parameter(torch.Tensor(1, num_features, 1)) + else: + self.weight = None + self.bias = None + self.epsilon = epsilon + self.p = 0 + self.affine = affine + self.reset_parameters() + + def reset_parameters(self): + if self.affine: + torch.nn.init.ones_(self.weight) + torch.nn.init.zeros_(self.bias) + + def forward(self, x): + cum_mean = x.mean(dim=1, keepdim=True) + cum_var = x.var(dim=1, keepdim=True) + x = (x - cum_mean) * torch.rsqrt(cum_var + self.epsilon) + if self.weight is not None: + x = x * self.weight + self.bias + return x + + +class CPCEncoder(nn.Module): + def __init__(self, hidden_dim=512): + super(CPCEncoder, self).__init__() + self.conv0 = nn.Conv1d(1, hidden_dim, 10, stride=5, padding=3) + self.batchNorm0 = ChannelNorm(hidden_dim) + self.conv1 = nn.Conv1d(hidden_dim, hidden_dim, 8, stride=4, padding=2) + self.batchNorm1 = ChannelNorm(hidden_dim) + self.conv2 = nn.Conv1d(hidden_dim, hidden_dim, 4, stride=2, padding=1) + self.batchNorm2 = ChannelNorm(hidden_dim) + self.conv3 = nn.Conv1d(hidden_dim, hidden_dim, 4, stride=2, padding=1) + self.batchNorm3 = ChannelNorm(hidden_dim) + self.conv4 = nn.Conv1d(hidden_dim, hidden_dim, 4, stride=2, padding=1) + self.batchNorm4 = ChannelNorm(hidden_dim) + self.DOWNSAMPLING = 160 + + def get_output_dim(self): + return self.conv4.out_channels + + def forward(self, x): + x = F.relu(self.batchNorm0(self.conv0(x))) + x = F.relu(self.batchNorm1(self.conv1(x))) + x = F.relu(self.batchNorm2(self.conv2(x))) + x = F.relu(self.batchNorm3(self.conv3(x))) + x = F.relu(self.batchNorm4(self.conv4(x))) + return x + + +class CPCAR(nn.Module): + def __init__(self, dim_encoded, dim_output, keep_hidden, num_layers): + super(CPCAR, self).__init__() + self.baseNet = nn.LSTM( + dim_encoded, dim_output, num_layers=num_layers, batch_first=True + ) + self.hidden = None + self.keep_hidden = keep_hidden + + def get_output_dim(self): + return self.baseNet.hidden_size + + def forward(self, x): + try: + self.baseNet.flatten_parameters() + except RuntimeError: + pass + x, h = self.baseNet(x, self.hidden) + if self.keep_hidden: + if isinstance(h, tuple): + self.hidden = tuple(x.detach() for x in h) + else: + self.hidden = h.detach() + return x + + +class CPCModel(nn.Module): + def __init__(self, encoder, ar_net): + super(CPCModel, self).__init__() + self.gEncoder = encoder + self.gAR = ar_net + self.config = None + + def forward(self, x, label): + encoded = self.gEncoder(x).permute(0, 2, 1) + cpc_feature = self.gAR(encoded) + return cpc_feature, encoded, label + + def extract_features(self, source, get_encoded=False, norm_output=False): + cpc_feature, encoded, _ = self.forward(source, None) + if get_encoded: + cpc_feature = encoded + if norm_output: + mean = cpc_feature.mean(dim=1, keepdim=True) + var = cpc_feature.var(dim=1, keepdim=True) + cpc_feature = (cpc_feature - mean) / torch.sqrt(var + 1e-08) + return cpc_feature diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/hubert_feature_reader.py b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/hubert_feature_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..09442206e19abf854f2f02754ec7c6f8bc564200 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/hubert_feature_reader.py @@ -0,0 +1,59 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import fairseq +import soundfile as sf +import torch.nn.functional as F + + +class HubertFeatureReader: + """ + Wrapper class to run inference on HuBERT model. + Helps extract features for a given audio file. + """ + + def __init__(self, checkpoint_path, layer, max_chunk=1600000): + ( + model, + cfg, + task, + ) = fairseq.checkpoint_utils.load_model_ensemble_and_task( + [checkpoint_path] + ) + self.model = model[0].eval().cuda() + self.task = task + self.layer = layer + self.max_chunk = max_chunk + + def read_audio(self, path, ref_len=None): + wav, sr = sf.read(path) + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + assert sr == self.task.cfg.sample_rate, sr + if ref_len is not None and abs(ref_len - len(wav)) > 160: + print(f"ref {ref_len} != read {len(wav)} ({path})") + return wav + + def get_feats(self, file_path, ref_len=None): + x = self.read_audio(file_path, ref_len) + with torch.no_grad(): + x = torch.from_numpy(x).float().cuda() + if self.task.cfg.normalize: + x = F.layer_norm(x, x.shape) + x = x.view(1, -1) + + feat = [] + for start in range(0, x.size(1), self.max_chunk): + x_chunk = x[:, start: start + self.max_chunk] + feat_chunk, _ = self.model.extract_features( + source=x_chunk, + padding_mask=None, + mask=False, + output_layer=self.layer, + ) + feat.append(feat_chunk) + return torch.cat(feat, 1).squeeze(0) diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/logmel_feature_reader.py b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/logmel_feature_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..106f50247622deca688b223f1ad63275d5b65e58 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/logmel_feature_reader.py @@ -0,0 +1,30 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import soundfile as sf +import torch +import torchaudio.compliance.kaldi as kaldi + + +class LogMelFeatureReader: + """ + Wrapper class to run inference on HuBERT model. + Helps extract features for a given audio file. + """ + + def __init__(self, *args, **kwargs): + self.num_mel_bins = kwargs.get("num_mel_bins", 80) + self.frame_length = kwargs.get("frame_length", 25.0) + + def get_feats(self, file_path): + wav, sr = sf.read(file_path) + feats = torch.from_numpy(wav).float() + feats = kaldi.fbank( + feats.unsqueeze(0), + num_mel_bins=self.num_mel_bins, + frame_length=self.frame_length, + sample_frequency=sr, + ) + return feats diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/utils.py b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5aaddf6421ab7fa417af508005671a0ed821c701 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/utils.py @@ -0,0 +1,126 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import gc +import os +import random +import shutil +import numpy as np + +import torch +import tqdm +from examples.textless_nlp.gslm.speech2unit.pretrained.cpc_feature_reader import ( + CpcFeatureReader, +) +from examples.textless_nlp.gslm.speech2unit.pretrained.hubert_feature_reader import ( + HubertFeatureReader, +) +from examples.textless_nlp.gslm.speech2unit.pretrained.logmel_feature_reader import ( + LogMelFeatureReader, +) +from examples.textless_nlp.gslm.speech2unit.pretrained.w2v2_feature_reader import ( + Wav2VecFeatureReader, +) + + +def get_feature_reader(feature_type): + if feature_type == "logmel": + return LogMelFeatureReader + elif feature_type == "hubert": + return HubertFeatureReader + elif feature_type == "w2v2": + return Wav2VecFeatureReader + elif feature_type == "cpc": + return CpcFeatureReader + else: + raise NotImplementedError(f"{feature_type} is not supported.") + + +def get_feature_iterator( + feature_type, checkpoint_path, layer, manifest_path, sample_pct +): + feature_reader_cls = get_feature_reader(feature_type) + with open(manifest_path, "r") as fp: + lines = fp.read().split("\n") + root = lines.pop(0).strip() + file_path_list = [ + os.path.join(root, line.split("\t")[0]) + for line in lines + if len(line) > 0 + ] + if sample_pct < 1.0: + file_path_list = random.sample( + file_path_list, int(sample_pct * len(file_path_list)) + ) + num_files = len(file_path_list) + reader = feature_reader_cls( + checkpoint_path=checkpoint_path, layer=layer + ) + + def iterate(): + for file_path in file_path_list: + feats = reader.get_feats(file_path) + yield feats.cpu().numpy() + + return iterate, num_files + + +def get_features( + feature_type, checkpoint_path, layer, manifest_path, sample_pct, flatten +): + generator, num_files = get_feature_iterator( + feature_type=feature_type, + checkpoint_path=checkpoint_path, + layer=layer, + manifest_path=manifest_path, + sample_pct=sample_pct, + ) + iterator = generator() + + features_list = [] + for features in tqdm.tqdm(iterator, total=num_files): + features_list.append(features) + + # Explicit clean up + del iterator + del generator + gc.collect() + torch.cuda.empty_cache() + + if flatten: + return np.concatenate(features_list) + + return features_list + + +def get_and_dump_features( + feature_type, + checkpoint_path, + layer, + manifest_path, + sample_pct, + flatten, + out_features_path, +): + # Feature extraction + features_batch = get_features( + feature_type=feature_type, + checkpoint_path=checkpoint_path, + layer=layer, + manifest_path=manifest_path, + sample_pct=sample_pct, + flatten=flatten, + ) + + # Save features + out_dir_path = os.path.dirname(out_features_path) + os.makedirs(out_dir_path, exist_ok=True) + shutil.copyfile( + manifest_path, + os.path.join(out_dir_path, os.path.basename(manifest_path)), + ) + np.save(out_features_path, features_batch) + + return features_batch diff --git a/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/w2v2_feature_reader.py b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/w2v2_feature_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..b878321e445093f187e7af5310622a6ac456c30d --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/speech2unit/pretrained/w2v2_feature_reader.py @@ -0,0 +1,46 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import fairseq +import soundfile as sf + + +class Wav2VecFeatureReader: + """ + Wrapper class to run inference on Wav2Vec 2.0 model. + Helps extract features for a given audio file. + """ + + def __init__(self, checkpoint_path, layer): + state = fairseq.checkpoint_utils.load_checkpoint_to_cpu( + checkpoint_path + ) + + w2v_args = state["args"] + self.task = fairseq.tasks.setup_task(w2v_args) + model = self.task.build_model(w2v_args) + model.load_state_dict(state["model"], strict=True) + model.eval() + model.cuda() + self.model = model + self.layer = layer + + def read_audio(self, fname): + wav, sr = sf.read(fname) + if wav.ndim == 2: + wav = wav.mean(-1) + assert wav.ndim == 1, wav.ndim + assert sr == self.task.cfg.sample_rate, sr + return wav + + def get_feats(self, file_path): + x = self.read_audio(file_path) + with torch.no_grad(): + source = torch.from_numpy(x).view(1, -1).float().cuda() + res = self.model( + source=source, mask=False, features_only=True, layer=self.layer + ) + return res["layer_results"][self.layer][0].squeeze(1) diff --git a/fairseq/examples/textless_nlp/gslm/tools/README.md b/fairseq/examples/textless_nlp/gslm/tools/README.md new file mode 100644 index 0000000000000000000000000000000000000000..61fcbbded80023f75eaec4b69ddfbbe4cc252e5b --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/tools/README.md @@ -0,0 +1,22 @@ +# GSLM Tools + +## Resynthesis +You can use the command line tool below to input an audio file and get the resynthesized audio. This tool implements the unsupervised method for resynthesis described in the paper. The way to invoke the command line tool is shown below. +``` +FAIRSEQ_ROOT=<path_to_your_fairseq_repo_root> +TYPE=<one_of_logmel/cpc/hubert/w2v2> +ACOUSTIC_MODEL_PATH=<path_of_pretrained_acoustic_model> +LAYER=<layer_of_acoustic_model_to_extract_features_from> +KM_MODEL_PATH=<output_path_of_the_kmeans_model> +TTS_MODEL_PATH=<unit2speech_model_file_path> +WAVEGLOW_PATH=<path_where_you_have_downloaded_waveglow_checkpoint> + +PYTHONPATH=${FAIRSEQ_ROOT}:${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/unit2speech python ${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/tools/gen_speech.py \ + --feature_type $TYPE \ + --acoustic_model_path $ACOUSTIC_MODEL_PATH \ + --layer $LAYER \ + --kmeans_model_path $KM_MODEL_PATH \ + --tts_model_path $TTS_MODEL_PATH \ + --waveglow_path $WAVEGLOW_PATH \ + --max_decoder_steps 2000 +``` \ No newline at end of file diff --git a/fairseq/examples/textless_nlp/gslm/tools/resynthesize_speech.py b/fairseq/examples/textless_nlp/gslm/tools/resynthesize_speech.py new file mode 100644 index 0000000000000000000000000000000000000000..2b6215d372035284f115b6eec0712a324246b67a --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/tools/resynthesize_speech.py @@ -0,0 +1,138 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import gc +import logging + +import joblib +import soundfile as sf +import torch +from examples.textless_nlp.gslm.speech2unit.pretrained.utils import ( + get_feature_reader, +) +from examples.textless_nlp.gslm.unit2speech.tts_data import ( + TacotronInputDataset, +) +from examples.textless_nlp.gslm.unit2speech.utils import ( + load_tacotron, + load_waveglow, + synthesize_audio, +) + + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + + +def get_parser(): + parser = argparse.ArgumentParser( + description="GSLM speech resynthesis tool." + ) + parser.add_argument( + "--feature_type", + type=str, + choices=["logmel", "hubert", "w2v2", "cpc"], + default=None, + required=True, + help="Acoustic feature type", + ) + parser.add_argument( + "--acoustic_model_path", + type=str, + help="Pretrained acoustic model checkpoint", + ) + parser.add_argument( + "--layer", type=int, help="Layer of acoustic model" + ) + parser.add_argument( + "--kmeans_model_path", + type=str, + required=True, + help="K-means model file path to use for inference", + ) + parser.add_argument( + "--tts_model_path", + type=str, + help="TTS model file path to use for inference", + ) + parser.add_argument( + "--waveglow_path", + type=str, + help="Waveglow (vocoder) model file path to use for inference", + ) + parser.add_argument("--max_decoder_steps", type=int, default=2000) + parser.add_argument("--denoiser_strength", type=float, default=0.1) + return parser + + +################################################ +def main(args, logger): + # Acoustic Model + logger.info(f"Loading acoustic model from {args.tts_model_path}...") + feature_reader_cls = get_feature_reader(args.feature_type) + reader = feature_reader_cls( + checkpoint_path=args.acoustic_model_path, layer=args.layer + ) + + # K-means Model + logger.info(f"Loading K-means model from {args.kmeans_model_path} ...") + kmeans_model = joblib.load(open(args.kmeans_model_path, "rb")) + kmeans_model.verbose = False + + # TTS Model + logger.info(f"Loading TTS model from {args.tts_model_path}...") + tacotron_model, sample_rate, hparams = load_tacotron( + tacotron_model_path=args.tts_model_path, + max_decoder_steps=args.max_decoder_steps, + ) + + # Waveglow Model + logger.info(f"Loading Waveglow model from {args.waveglow_path}...") + waveglow, denoiser = load_waveglow(waveglow_path=args.waveglow_path) + + # Dataset + tts_dataset = TacotronInputDataset(hparams) + + iters = 0 + while True: + in_file_path = input( + "Input: Enter the full file path of audio file...\n" + ) + out_file_path = input( + "Output: Enter the full file path of audio file...\n" + ) + feats = reader.get_feats(in_file_path).cpu().numpy() + iters += 1 + if iters == 1000: + gc.collect() + torch.cuda.empty_cache() + + quantized_units = kmeans_model.predict(feats) + quantized_units_str = " ".join(map(str, quantized_units)) + + tts_input = tts_dataset.get_tensor(quantized_units_str) + mel, aud, aud_dn, has_eos = synthesize_audio( + tacotron_model, + waveglow, + denoiser, + tts_input.unsqueeze(0), + strength=args.denoiser_strength, + ) + sf.write( + f"{out_file_path}", aud_dn[0].cpu().float().numpy(), sample_rate + ) + logger.info("Resynthesis done!\n") + + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + main(args, logger) diff --git a/fairseq/examples/textless_nlp/gslm/ulm/README.md b/fairseq/examples/textless_nlp/gslm/ulm/README.md new file mode 100644 index 0000000000000000000000000000000000000000..01459121cebefc61fdc2eae201462aa78d699111 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/ulm/README.md @@ -0,0 +1,72 @@ +# Unit Language Model (ULM) + +Here you can find links to the pre-trained ULMs and instructions on training new models using fairseq. At the end of the page, we also share how to run sampling for those models and provide pointers to the transcribed prompts we used. + +## Pre-trained models + +Using the links below, you can download pre-trained models for various unit types and vocabulary sizes: + +| | 50 | 100 | 200 +|-|-|-|- +| LogMel Filterbank | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/lm_km50/logmel50_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/lm_km100/logmel100_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/lm_km200/logmel200_lm.tgz) +| Modified CPC | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/lm_km50/cpc50_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/lm_km100/cpc100_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/lm_km200/cpc200_lm.tgz) +| HuBERT | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/lm_km50/hubert50_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/lm_km100/hubert100_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/lm_km200/hubert200_lm.tgz) +| Wav2Vec 2.0 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/lm_km50/w2v2_50_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/lm_km100/w2v2_100_lm.tgz) | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/lm_km200/w2v2_200_lm.tgz) + + +## Preprocessing data +Assuming that unit-transcribed train, valid, and test sets are located in `data/train.txt`, `data/valid.txt`, and `data/test.txt`, respectively, +we run the following command to get a preprocessed version of the datast in `data-bin`: + +```bash +fairseq-preprocess --only-source \ + --trainpref data/train.txt --validpref data/valid.txt --testpref data/test.txt \ + --destdir data-bin/ --workers 40 +``` +As a result, the `data-bin` directory should appear. + +## Fitting a Unit Language Model (ULM) +As an ULM, we train a standard fairseq Transformer LM. Assuming 8 GPUs used for training, a good starting point for an ULM training would be: +```bash + fairseq-train data-bin/ \ + --task=language_modeling \ + --arch=transformer_lm_big \ + --share-decoder-input-output-embed \ + --dropout=0.1 \ + --attention-dropout=0.1 \ + --optimizer=adam \ + --adam-betas='(0.9, 0.98)' \ + --clip-norm=1.0 \ + --lr=0.0005 \ + --lr-scheduler=inverse_sqrt \ + --warmup-updates=4000 \ + --warmup-init-lr=1e-07 \ + --tokens-per-sample=3072 \ + --update-freq=16 \ + --max-tokens=4096 \ + --num-workers=4 \ + --skip-invalid-size-inputs-valid-test \ + --max-update=500000 \ + --log-interval=10 \ + --seed=100501 \ + --fp16 \ + --sample-break-mode=eos +``` +This command will train a Transformer-large model (12 layers). You can train other standard LM models provided by fairseq, e.g. specify `--arch=transformer_lm` to train a smaller (6-layer) Transformer model. When training with a different number of GPUs, it might be a good idea to adjust the `update-freq` parameter. To save the GPU memory at an expense of additional computation, it can be useful to enable activation checkpointing with `--checkpoint-activations`. + +## Sampling from an ULM +Once an ULM was trained, we can use it for generating new utterances. Suppose, that the prompts are given in a file named `prompts.txt`. Then we can sample continuations by running the following command: + +```bash + python sample.py data-bin/ \ + --path=checkpoints/checkpoint_best.pt --task=language_modeling --sampling --temperature=0.7 \ + --seed=1 --prompts=prompts.txt --output=samples.txt --max-len-a=0 --max-len-b=500 \ + --prefix-size=-1 --batch-size=16 --fp16 --samples-per-prompt=10 +``` +Here, `--prefix-size` controls the number of tokens that are used to prime the ULM. When set to a positive value, the sampling script will take first `prefix-size` tokens to prompt the ULM; with `0` it runs unconditional sampling and with `-1` the entire prompt is used. +`--samples-per-prompt` specifies how many utterances are generated with every prompt which can be useful when generating multiple prompt continuations. In this command, `--max-len-a` and `--max-len-b` control the number of generated tokens. + +When using a pretrained model from above, `data-bin` should point to the unpacked directory (with `dict.txt` file). + +Evaluation-time, to generate prompts, we used utterances from LibriSpeech dev-clean and test-clean that are longer than 6s. We took first 3s from an utterance as a prompt. Unit transcripts of those prompts can be downloaded here: [[dev]](https://dl.fbaipublicfiles.com/textless_nlp/gslm/eval_data/dev_prompts.tgz) [[test]](https://dl.fbaipublicfiles.com/textless_nlp/gslm/eval_data/test_prompts.tgz) + diff --git a/fairseq/examples/textless_nlp/gslm/ulm/sample.py b/fairseq/examples/textless_nlp/gslm/ulm/sample.py new file mode 100644 index 0000000000000000000000000000000000000000..77302a6894cacf07588cf34fb1e695dc519d7df5 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/ulm/sample.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Sample from a trained LM; hacked fairseq-interactive +""" +from collections import namedtuple +import os +import ast +import numpy as np + +from fairseq import checkpoint_utils, options, tasks, utils + +import tqdm + +Batch = namedtuple('Batch', 'ids src_tokens src_lengths') +Translation = namedtuple('Translation', 'src_str hypos pos_scores alignments') + + +def make_batches(lines, args, task, max_positions): + tokens = [ + task.source_dictionary.encode_line( + src_str, add_if_not_exist=False + ).long() + for src_str in lines + ] + lengths = [t.numel() for t in tokens] + itr = task.get_batch_iterator( + dataset=task.build_dataset_for_inference(tokens, lengths), + max_tokens=args.dataset.max_tokens, + max_sentences=args.dataset.batch_size, + max_positions=max_positions, + ignore_invalid_inputs=args.dataset.skip_invalid_size_inputs_valid_test + ).next_epoch_itr(shuffle=False) + for batch in itr: + yield Batch( + ids=batch['id'], + src_tokens=batch['net_input']['src_tokens'], src_lengths=batch['net_input']['src_lengths'], + ) + + +def main(args): + arg_prompts = args.prompts + arg_output = args.output + arg_debug = args.debug + arg_sample_size = args.samples_per_prompt + + try: + from fairseq.dataclass.utils import convert_namespace_to_omegaconf + args = convert_namespace_to_omegaconf(args) + except: + pass + + # if args.max_tokens is None and args.max_sentences is None: + if args.common.seed is not None: + np.random.seed(args.common.seed) + utils.set_torch_seed(args.common.seed) + + if args.generation.sampling: + args.generation.nbest = args.generation.beam = arg_sample_size + + task = tasks.setup_task(args.task) + + overrides = ast.literal_eval(args.common_eval.model_overrides) + + models, _model_args = checkpoint_utils.load_model_ensemble( + args.common_eval.path.split(os.pathsep), + arg_overrides=overrides, + task=task, + suffix=getattr(args, "checkpoint_suffix", ""), + ) + + # Set dictionaries + src_dict = task.source_dictionary + tgt_dict = task.target_dictionary + + # Optimize ensemble for generation + for model in models: + model.prepare_for_inference_(args) + model.cuda() + + # Load alignment dictionary for unknown word replacement + # (None if no unknown word replacement, empty if no path to align dictionary) + align_dict = utils.load_align_dict(args.generation.replace_unk) + + max_positions = utils.resolve_max_positions( + task.max_positions(), + *[model.max_positions() for model in models] + ) + + output_file = open(arg_output, 'w') + + with open(arg_prompts, 'r') as fin: + lines = fin.readlines() + + split = [x.split('|', 1) for x in lines] + seq_id = [x[0] for x in split] + prompts = [x[1] for x in split] + + if args.generation.prefix_size >= 0: + prompts = [' '.join(l.split()[:args.generation.prefix_size]) + for l in prompts] + + if arg_debug: + prompts = prompts[:10] + + generator = task.build_generator(models, args.generation) + + start_id = 0 + pbar = tqdm.tqdm(total=len(prompts)) + for batch in make_batches(prompts, args, task, max_positions): + src_tokens = batch.src_tokens + src_lengths = batch.src_lengths + src_tokens = src_tokens.cuda() + src_lengths = src_lengths.cuda() + + sample = { + 'net_input': { + 'src_tokens': src_tokens, + 'src_lengths': src_lengths, + }, + } + + results = [] + translations = task.inference_step(generator, models, sample) + for i, (id, hypos) in enumerate(zip(batch.ids.tolist(), translations)): + src_tokens_i = utils.strip_pad(src_tokens[i], tgt_dict.pad()) + results.append((i + start_id, src_tokens_i, hypos)) + + # sort output to match input order + for id, src_tokens, hypos in sorted(results, key=lambda x: x[0]): + if src_dict is not None: + src_str = src_dict.string( + src_tokens, args.common_eval.post_process) + + # Process top predictions + for hypo_id, hypo in enumerate(hypos): + _hypo_tokens, hypo_str, _alignment = utils.post_process_prediction( + hypo_tokens=hypo['tokens'].int().cpu(), + src_str=src_str, + alignment=hypo['alignment'], + align_dict=align_dict, + tgt_dict=tgt_dict, + remove_bpe=args.common_eval.post_process, + ) + + detok_hypo_str = hypo_str + utterance = detok_hypo_str + print(f'{seq_id[id]}__{hypo_id}|{utterance}', file=output_file) + pbar.update(1) + start_id += len(results) + + # output_file.close() + + +def cli_main(): + parser = options.get_interactive_generation_parser() + parser.add_argument('--prompts', type=str, default=None, required=True) + parser.add_argument('--output', type=str, default=None, required=True) + parser.add_argument('--debug', action='store_true') + parser.add_argument('--samples-per-prompt', type=int, default=1) + + args = options.parse_args_and_arch(parser) + + np.random.seed(args.seed) + utils.set_torch_seed(args.seed) + + main(args) + + +if __name__ == '__main__': + cli_main() diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/README.md b/fairseq/examples/textless_nlp/gslm/unit2speech/README.md new file mode 100644 index 0000000000000000000000000000000000000000..57104230655c7c517d25904e634c53b6159ee60f --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/README.md @@ -0,0 +1,42 @@ +# Unit to Speech Model (unit2speech) + +Unit to speech model is modified Tacotron2 model that learns to synthesize speech from discrete speech units. All models are trained on quantized [LJSpeech](https://keithito.com/LJ-Speech-Dataset/). + +Upstream Units | Download Link +|-|- +Log Mel Filterbank + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km50/tts_checkpoint_best.pt) +Log Mel Filterbank + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km100/tts_checkpoint_best.pt) +Log Mel Filterbank + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km200/tts_checkpoint_best.pt) +Log Mel Filterbank + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/logmel/tts_km500/tts_checkpoint_best.pt) +Modified CPC + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km50/tts_checkpoint_best.pt) +Modified CPC + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km100/tts_checkpoint_best.pt) +Modified CPC + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km200/tts_checkpoint_best.pt) +Modified CPC + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/cpc/tts_km500/tts_checkpoint_best.pt) +HuBERT Base + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km50/tts_checkpoint_best.pt) +HuBERT Base + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km100/tts_checkpoint_best.pt) +HuBERT Base + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km200/tts_checkpoint_best.pt) +HuBERT Base + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/hubert/tts_km500/tts_checkpoint_best.pt) +wav2vec 2.0 Large + KM50 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km50/tts_checkpoint_best.pt) +wav2vec 2.0 Large + KM100 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km100/tts_checkpoint_best.pt) +wav2vec 2.0 Large + KM200 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km200/tts_checkpoint_best.pt) +wav2vec 2.0 Large + KM500 | [download](https://dl.fbaipublicfiles.com/textless_nlp/gslm/w2v2/tts_km500/tts_checkpoint_best.pt) + +## Run inference using a unit2speech model +* Install librosa, unidecode and inflect using `pip install librosa, unidecode, inflect` +* Download [Waveglow checkpoint](https://dl.fbaipublicfiles.com/textless_nlp/gslm/waveglow_256channels_new.pt). This is the vocoder. + +Sample commnd to run inference using trained unit2speech models. Please note that the quantized audio to synthesized should be using the same units as the unit2speech model was trained with. +``` +FAIRSEQ_ROOT=<path_to_your_fairseq_repo_root> +TTS_MODEL_PATH=<unit2speech_model_file_path> +QUANTIZED_UNIT_PATH=<quantized_audio_file_path> +OUT_DIR=<dir_to_dump_synthesized_audio_files> +WAVEGLOW_PATH=<path_where_you_have_downloaded_waveglow_checkpoint> + +PYTHONPATH=${FAIRSEQ_ROOT}:${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/unit2speech python ${FAIRSEQ_ROOT}/examples/textless_nlp/gslm/unit2speech/synthesize_audio_from_units.py \ + --tts_model_path $TTS_MODEL_PATH \ + --quantized_unit_path $QUANTIZED_UNIT_PATH \ + --out_audio_dir $OUT_DIR \ + --waveglow_path $WAVEGLOW_PATH \ + --max_decoder_steps 2000 +``` \ No newline at end of file diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/convert_to_16k.py b/fairseq/examples/textless_nlp/gslm/unit2speech/convert_to_16k.py new file mode 100644 index 0000000000000000000000000000000000000000..2be848fceae65e3bd5747a2c98106b0215c6a039 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/convert_to_16k.py @@ -0,0 +1,56 @@ +import os +import shlex +import subprocess +import progressbar +from time import time +from pathlib import Path + +def find_all_files(path_dir, extension): + out = [] + for root, dirs, filenames in os.walk(path_dir): + for f in filenames: + if f.endswith(extension): + out.append(((str(Path(f).stem)), os.path.join(root, f))) + return out + +def convert16k(inputfile, outputfile16k): + command = ('sox -c 1 -b 16 {} -t wav {} rate 16k'.format(inputfile, outputfile16k)) + subprocess.call(shlex.split(command)) + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description='Convert to wav 16k audio using sox.') + parser.add_argument('input_dir', type=str, + help='Path to the input dir.') + parser.add_argument('output_dir', type=str, + help='Path to the output dir.') + parser.add_argument('--extension', type=str, default='wav', + help='Audio file extension in the input. Default: mp3') + args = parser.parse_args() + + # Find all sequences + print(f"Finding all audio files with extension '{args.extension}' from {args.input_dir}...") + audio_files = find_all_files(args.input_dir, args.extension) + print(f"Done! Found {len(audio_files)} files.") + + # Convert to relative path + audio_files = [os.path.relpath(file[-1], start=args.input_dir) for file in audio_files] + + # Create all the directories needed + rel_dirs_set = set([os.path.dirname(file) for file in audio_files]) + for rel_dir in rel_dirs_set: + Path(os.path.join(args.output_dir, rel_dir)).mkdir(parents=True, exist_ok=True) + + # Converting wavs files + print("Converting the audio to wav files...") + bar = progressbar.ProgressBar(maxval=len(audio_files)) + bar.start() + start_time = time() + for index, file in enumerate(audio_files): + bar.update(index) + input_file = os.path.join(args.input_dir, file) + output_file = os.path.join(args.output_dir, os.path.splitext(file)[0]+".wav") + convert16k(input_file, output_file) + bar.finish() + print(f"...done {len(audio_files)} files in {time()-start_time} seconds.") \ No newline at end of file diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/glow.py b/fairseq/examples/textless_nlp/gslm/unit2speech/glow.py new file mode 100644 index 0000000000000000000000000000000000000000..7a7696403d505afdf0f1606f8220801b0f46152f --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/glow.py @@ -0,0 +1,311 @@ +# ***************************************************************************** +# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of the NVIDIA CORPORATION nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# ***************************************************************************** +import copy +import torch +from torch.autograd import Variable +import torch.nn.functional as F + + +@torch.jit.script +def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels): + n_channels_int = n_channels[0] + in_act = input_a+input_b + t_act = torch.tanh(in_act[:, :n_channels_int, :]) + s_act = torch.sigmoid(in_act[:, n_channels_int:, :]) + acts = t_act * s_act + return acts + + +class WaveGlowLoss(torch.nn.Module): + def __init__(self, sigma=1.0): + super(WaveGlowLoss, self).__init__() + self.sigma = sigma + + def forward(self, model_output): + z, log_s_list, log_det_W_list = model_output + for i, log_s in enumerate(log_s_list): + if i == 0: + log_s_total = torch.sum(log_s) + log_det_W_total = log_det_W_list[i] + else: + log_s_total = log_s_total + torch.sum(log_s) + log_det_W_total += log_det_W_list[i] + + loss = torch.sum(z*z)/(2*self.sigma*self.sigma) - log_s_total - log_det_W_total + return loss/(z.size(0)*z.size(1)*z.size(2)) + + +class Invertible1x1Conv(torch.nn.Module): + """ + The layer outputs both the convolution, and the log determinant + of its weight matrix. If reverse=True it does convolution with + inverse + """ + def __init__(self, c): + super(Invertible1x1Conv, self).__init__() + self.conv = torch.nn.Conv1d(c, c, kernel_size=1, stride=1, padding=0, + bias=False) + + # Sample a random orthonormal matrix to initialize weights + W = torch.qr(torch.FloatTensor(c, c).normal_())[0] + + # Ensure determinant is 1.0 not -1.0 + if torch.det(W) < 0: + W[:,0] = -1*W[:,0] + W = W.view(c, c, 1) + self.conv.weight.data = W + + def forward(self, z, reverse=False): + # shape + batch_size, group_size, n_of_groups = z.size() + + W = self.conv.weight.squeeze() + + if reverse: + if not hasattr(self, 'W_inverse'): + # Reverse computation + W_inverse = W.float().inverse() + W_inverse = Variable(W_inverse[..., None]) + if z.type() == 'torch.cuda.HalfTensor': + W_inverse = W_inverse.half() + self.W_inverse = W_inverse + z = F.conv1d(z, self.W_inverse, bias=None, stride=1, padding=0) + return z + else: + # Forward computation + log_det_W = batch_size * n_of_groups * torch.logdet(W) + z = self.conv(z) + return z, log_det_W + + +class WN(torch.nn.Module): + """ + This is the WaveNet like layer for the affine coupling. The primary difference + from WaveNet is the convolutions need not be causal. There is also no dilation + size reset. The dilation only doubles on each layer + """ + def __init__(self, n_in_channels, n_mel_channels, n_layers, n_channels, + kernel_size): + super(WN, self).__init__() + assert(kernel_size % 2 == 1) + assert(n_channels % 2 == 0) + self.n_layers = n_layers + self.n_channels = n_channels + self.in_layers = torch.nn.ModuleList() + self.res_skip_layers = torch.nn.ModuleList() + + start = torch.nn.Conv1d(n_in_channels, n_channels, 1) + start = torch.nn.utils.weight_norm(start, name='weight') + self.start = start + + # Initializing last layer to 0 makes the affine coupling layers + # do nothing at first. This helps with training stability + end = torch.nn.Conv1d(n_channels, 2*n_in_channels, 1) + end.weight.data.zero_() + end.bias.data.zero_() + self.end = end + + cond_layer = torch.nn.Conv1d(n_mel_channels, 2*n_channels*n_layers, 1) + self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight') + + for i in range(n_layers): + dilation = 2 ** i + padding = int((kernel_size*dilation - dilation)/2) + in_layer = torch.nn.Conv1d(n_channels, 2*n_channels, kernel_size, + dilation=dilation, padding=padding) + in_layer = torch.nn.utils.weight_norm(in_layer, name='weight') + self.in_layers.append(in_layer) + + + # last one is not necessary + if i < n_layers - 1: + res_skip_channels = 2*n_channels + else: + res_skip_channels = n_channels + res_skip_layer = torch.nn.Conv1d(n_channels, res_skip_channels, 1) + res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight') + self.res_skip_layers.append(res_skip_layer) + + def forward(self, forward_input): + audio, spect = forward_input + audio = self.start(audio) + output = torch.zeros_like(audio) + n_channels_tensor = torch.IntTensor([self.n_channels]) + + spect = self.cond_layer(spect) + + for i in range(self.n_layers): + spect_offset = i*2*self.n_channels + acts = fused_add_tanh_sigmoid_multiply( + self.in_layers[i](audio), + spect[:,spect_offset:spect_offset+2*self.n_channels,:], + n_channels_tensor) + + res_skip_acts = self.res_skip_layers[i](acts) + if i < self.n_layers - 1: + audio = audio + res_skip_acts[:,:self.n_channels,:] + output = output + res_skip_acts[:,self.n_channels:,:] + else: + output = output + res_skip_acts + + return self.end(output) + + +class WaveGlow(torch.nn.Module): + def __init__(self, n_mel_channels, n_flows, n_group, n_early_every, + n_early_size, WN_config): + super(WaveGlow, self).__init__() + + self.upsample = torch.nn.ConvTranspose1d(n_mel_channels, + n_mel_channels, + 1024, stride=256) + assert(n_group % 2 == 0) + self.n_flows = n_flows + self.n_group = n_group + self.n_early_every = n_early_every + self.n_early_size = n_early_size + self.WN = torch.nn.ModuleList() + self.convinv = torch.nn.ModuleList() + + n_half = int(n_group/2) + + # Set up layers with the right sizes based on how many dimensions + # have been output already + n_remaining_channels = n_group + for k in range(n_flows): + if k % self.n_early_every == 0 and k > 0: + n_half = n_half - int(self.n_early_size/2) + n_remaining_channels = n_remaining_channels - self.n_early_size + self.convinv.append(Invertible1x1Conv(n_remaining_channels)) + self.WN.append(WN(n_half, n_mel_channels*n_group, **WN_config)) + self.n_remaining_channels = n_remaining_channels # Useful during inference + + def forward(self, forward_input): + """ + forward_input[0] = mel_spectrogram: batch x n_mel_channels x frames + forward_input[1] = audio: batch x time + """ + spect, audio = forward_input + + # Upsample spectrogram to size of audio + spect = self.upsample(spect) + assert(spect.size(2) >= audio.size(1)) + if spect.size(2) > audio.size(1): + spect = spect[:, :, :audio.size(1)] + + spect = spect.unfold(2, self.n_group, self.n_group).permute(0, 2, 1, 3) + spect = spect.contiguous().view(spect.size(0), spect.size(1), -1).permute(0, 2, 1) + + audio = audio.unfold(1, self.n_group, self.n_group).permute(0, 2, 1) + output_audio = [] + log_s_list = [] + log_det_W_list = [] + + for k in range(self.n_flows): + if k % self.n_early_every == 0 and k > 0: + output_audio.append(audio[:,:self.n_early_size,:]) + audio = audio[:,self.n_early_size:,:] + + audio, log_det_W = self.convinv[k](audio) + log_det_W_list.append(log_det_W) + + n_half = int(audio.size(1)/2) + audio_0 = audio[:,:n_half,:] + audio_1 = audio[:,n_half:,:] + + output = self.WN[k]((audio_0, spect)) + log_s = output[:, n_half:, :] + b = output[:, :n_half, :] + audio_1 = torch.exp(log_s)*audio_1 + b + log_s_list.append(log_s) + + audio = torch.cat([audio_0, audio_1],1) + + output_audio.append(audio) + return torch.cat(output_audio,1), log_s_list, log_det_W_list + + def infer(self, spect, sigma=1.0): + spect = self.upsample(spect) + # trim conv artifacts. maybe pad spec to kernel multiple + time_cutoff = self.upsample.kernel_size[0] - self.upsample.stride[0] + spect = spect[:, :, :-time_cutoff] + + spect = spect.unfold(2, self.n_group, self.n_group).permute(0, 2, 1, 3) + spect = spect.contiguous().view(spect.size(0), spect.size(1), -1).permute(0, 2, 1) + + if spect.type() == 'torch.cuda.HalfTensor': + audio = torch.cuda.HalfTensor(spect.size(0), + self.n_remaining_channels, + spect.size(2)).normal_() + else: + audio = torch.cuda.FloatTensor(spect.size(0), + self.n_remaining_channels, + spect.size(2)).normal_() + + audio = torch.autograd.Variable(sigma*audio) + + for k in reversed(range(self.n_flows)): + n_half = int(audio.size(1)/2) + audio_0 = audio[:,:n_half,:] + audio_1 = audio[:,n_half:,:] + + output = self.WN[k]((audio_0, spect)) + + s = output[:, n_half:, :] + b = output[:, :n_half, :] + audio_1 = (audio_1 - b)/torch.exp(s) + audio = torch.cat([audio_0, audio_1],1) + + audio = self.convinv[k](audio, reverse=True) + + if k % self.n_early_every == 0 and k > 0: + if spect.type() == 'torch.cuda.HalfTensor': + z = torch.cuda.HalfTensor(spect.size(0), self.n_early_size, spect.size(2)).normal_() + else: + z = torch.cuda.FloatTensor(spect.size(0), self.n_early_size, spect.size(2)).normal_() + audio = torch.cat((sigma*z, audio),1) + + audio = audio.permute(0,2,1).contiguous().view(audio.size(0), -1).data + return audio + + @staticmethod + def remove_weightnorm(model): + waveglow = model + for WN in waveglow.WN: + WN.start = torch.nn.utils.remove_weight_norm(WN.start) + WN.in_layers = remove(WN.in_layers) + WN.cond_layer = torch.nn.utils.remove_weight_norm(WN.cond_layer) + WN.res_skip_layers = remove(WN.res_skip_layers) + return waveglow + + +def remove(conv_list): + new_conv_list = torch.nn.ModuleList() + for old_conv in conv_list: + old_conv = torch.nn.utils.remove_weight_norm(old_conv) + new_conv_list.append(old_conv) + return new_conv_list diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/multiproc.py b/fairseq/examples/textless_nlp/gslm/unit2speech/multiproc.py new file mode 100644 index 0000000000000000000000000000000000000000..2a287a4e97c66acbd36897b25f2ece5494005f03 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/multiproc.py @@ -0,0 +1,27 @@ +import os +import time +import torch +import sys +import subprocess + +argslist = list(sys.argv)[1:] +log_dir = argslist[-1] +num_gpus = torch.cuda.device_count() +argslist.append('--n_gpus={}'.format(num_gpus)) +workers = [] +job_id = time.strftime("%Y_%m_%d-%H%M%S") +argslist.append("--group_name=group_{}".format(job_id)) + +print("GPU log directory is {}".format(log_dir)) +os.makedirs(log_dir, exist_ok=True) +for i in range(num_gpus): + argslist.append('--rank={}'.format(i)) + stdout = None if i == 0 else open("{}/{}_GPU_{}.log".format(log_dir, job_id, i), + "w") + print(argslist) + p = subprocess.Popen([str(sys.executable)]+argslist, stdout=stdout) + workers.append(p) + argslist = argslist[:-1] + +for p in workers: + p.wait() diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/synthesize_audio_from_units.py b/fairseq/examples/textless_nlp/gslm/unit2speech/synthesize_audio_from_units.py new file mode 100644 index 0000000000000000000000000000000000000000..f226d5f50514ecb5ee3b4f1031df750609a56112 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/synthesize_audio_from_units.py @@ -0,0 +1,97 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import os + +import soundfile as sf +from examples.textless_nlp.gslm.unit2speech.tts_data import ( + TacotronInputDataset, +) +from examples.textless_nlp.gslm.unit2speech.utils import ( + load_quantized_audio_from_file, + load_tacotron, + load_waveglow, + synthesize_audio, +) + + +def get_logger(): + log_format = "[%(asctime)s] [%(levelname)s]: %(message)s" + logging.basicConfig(format=log_format, level=logging.INFO) + logger = logging.getLogger(__name__) + return logger + + +def get_parser(): + parser = argparse.ArgumentParser( + description="Wav2Vec 2.0 speech generator." + ) + parser.add_argument( + "--quantized_unit_path", + type=str, + help="K-means model file path to use for inference", + ) + parser.add_argument( + "--tts_model_path", + type=str, + help="TTS model file path to use for inference", + ) + parser.add_argument( + "--waveglow_path", + type=str, + help="Path to the waveglow checkpoint (vocoder).", + ) + parser.add_argument("--max_decoder_steps", type=int, default=2000) + parser.add_argument("--denoiser_strength", type=float, default=0.1) + parser.add_argument( + "--out_audio_dir", + type=str, + help="Output directory to dump audio files", + ) + + return parser + + +def main(args, logger): + # Load quantized audio + logger.info(f"Loading quantized audio from {args.quantized_unit_path}...") + names_batch, quantized_units_batch = load_quantized_audio_from_file( + file_path=args.quantized_unit_path + ) + + logger.info(f"Loading TTS model from {args.tts_model_path}...") + tacotron_model, sample_rate, hparams = load_tacotron( + tacotron_model_path=args.tts_model_path, + max_decoder_steps=args.max_decoder_steps, + ) + + logger.info(f"Loading Waveglow model from {args.waveglow_path}...") + waveglow, denoiser = load_waveglow(waveglow_path=args.waveglow_path) + + tts_dataset = TacotronInputDataset(hparams) + for name, quantized_units in zip(names_batch, quantized_units_batch): + quantized_units_str = " ".join(map(str, quantized_units)) + tts_input = tts_dataset.get_tensor(quantized_units_str) + mel, aud, aud_dn, has_eos = synthesize_audio( + tacotron_model, + waveglow, + denoiser, + tts_input.unsqueeze(0), + strength=args.denoiser_strength, + ) + out_file_path = os.path.join(args.out_audio_dir, f"{name}.wav") + sf.write( + f"{out_file_path}", aud_dn[0].cpu().float().numpy(), sample_rate + ) + + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + logger = get_logger() + logger.info(args) + main(args, logger) diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/__init__.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/audio_processing.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/audio_processing.py new file mode 100644 index 0000000000000000000000000000000000000000..b5af7f723eb8047bc58db2f85234aea161fbc659 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/audio_processing.py @@ -0,0 +1,93 @@ +import torch +import numpy as np +from scipy.signal import get_window +import librosa.util as librosa_util + + +def window_sumsquare(window, n_frames, hop_length=200, win_length=800, + n_fft=800, dtype=np.float32, norm=None): + """ + # from librosa 0.6 + Compute the sum-square envelope of a window function at a given hop length. + + This is used to estimate modulation effects induced by windowing + observations in short-time fourier transforms. + + Parameters + ---------- + window : string, tuple, number, callable, or list-like + Window specification, as in `get_window` + + n_frames : int > 0 + The number of analysis frames + + hop_length : int > 0 + The number of samples to advance between frames + + win_length : [optional] + The length of the window function. By default, this matches `n_fft`. + + n_fft : int > 0 + The length of each analysis frame. + + dtype : np.dtype + The data type of the output + + Returns + ------- + wss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))` + The sum-squared envelope of the window function + """ + if win_length is None: + win_length = n_fft + + n = n_fft + hop_length * (n_frames - 1) + x = np.zeros(n, dtype=dtype) + + # Compute the squared window at the desired length + win_sq = get_window(window, win_length, fftbins=True) + win_sq = librosa_util.normalize(win_sq, norm=norm)**2 + win_sq = librosa_util.pad_center(win_sq, n_fft) + + # Fill the envelope + for i in range(n_frames): + sample = i * hop_length + x[sample:min(n, sample + n_fft)] += win_sq[:max(0, min(n_fft, n - sample))] + return x + + +def griffin_lim(magnitudes, stft_fn, n_iters=30): + """ + PARAMS + ------ + magnitudes: spectrogram magnitudes + stft_fn: STFT class with transform (STFT) and inverse (ISTFT) methods + """ + + angles = np.angle(np.exp(2j * np.pi * np.random.rand(*magnitudes.size()))) + angles = angles.astype(np.float32) + angles = torch.autograd.Variable(torch.from_numpy(angles)) + signal = stft_fn.inverse(magnitudes, angles).squeeze(1) + + for i in range(n_iters): + _, angles = stft_fn.transform(signal) + signal = stft_fn.inverse(magnitudes, angles).squeeze(1) + return signal + + +def dynamic_range_compression(x, C=1, clip_val=1e-5): + """ + PARAMS + ------ + C: compression factor + """ + return torch.log(torch.clamp(x, min=clip_val) * C) + + +def dynamic_range_decompression(x, C=1): + """ + PARAMS + ------ + C: compression factor used to compress + """ + return torch.exp(x) / C diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cleaners.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cleaners.py new file mode 100644 index 0000000000000000000000000000000000000000..e2e35c1a8cc4c628c5d05802677142c9a2122d2b --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cleaners.py @@ -0,0 +1,90 @@ +""" from https://github.com/keithito/tacotron """ + +''' +Cleaners are transformations that run over the input text at both training and eval time. + +Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners" +hyperparameter. Some cleaners are English-specific. You'll typically want to use: + 1. "english_cleaners" for English text + 2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using + the Unidecode library (https://pypi.python.org/pypi/Unidecode) + 3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update + the symbols in symbols.py to match your data). +''' + +import re +from unidecode import unidecode +from .numbers import normalize_numbers + + +# Regular expression matching whitespace: +_whitespace_re = re.compile(r'\s+') + +# List of (regular expression, replacement) pairs for abbreviations: +_abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [ + ('mrs', 'misess'), + ('mr', 'mister'), + ('dr', 'doctor'), + ('st', 'saint'), + ('co', 'company'), + ('jr', 'junior'), + ('maj', 'major'), + ('gen', 'general'), + ('drs', 'doctors'), + ('rev', 'reverend'), + ('lt', 'lieutenant'), + ('hon', 'honorable'), + ('sgt', 'sergeant'), + ('capt', 'captain'), + ('esq', 'esquire'), + ('ltd', 'limited'), + ('col', 'colonel'), + ('ft', 'fort'), +]] + + +def expand_abbreviations(text): + for regex, replacement in _abbreviations: + text = re.sub(regex, replacement, text) + return text + + +def expand_numbers(text): + return normalize_numbers(text) + + +def lowercase(text): + return text.lower() + + +def collapse_whitespace(text): + return re.sub(_whitespace_re, ' ', text) + + +def convert_to_ascii(text): + return unidecode(text) + + +def basic_cleaners(text): + '''Basic pipeline that lowercases and collapses whitespace without transliteration.''' + text = lowercase(text) + text = collapse_whitespace(text) + return text + + +def transliteration_cleaners(text): + '''Pipeline for non-English text that transliterates to ASCII.''' + text = convert_to_ascii(text) + text = lowercase(text) + text = collapse_whitespace(text) + return text + + +def english_cleaners(text): + '''Pipeline for English text, including number and abbreviation expansion.''' + text = convert_to_ascii(text) + text = lowercase(text) + text = expand_numbers(text) + text = expand_abbreviations(text) + text = collapse_whitespace(text) + return text diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cmudict.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cmudict.py new file mode 100644 index 0000000000000000000000000000000000000000..62bfef745c30a56f7b6605d9e3becfbc40edb50d --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/cmudict.py @@ -0,0 +1,65 @@ +""" from https://github.com/keithito/tacotron """ + +import re + + +valid_symbols = [ + 'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1', 'AH2', + 'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0', 'AY1', 'AY2', + 'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0', 'ER1', 'ER2', 'EY', + 'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0', 'IH1', 'IH2', 'IY', 'IY0', 'IY1', + 'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0', + 'OY1', 'OY2', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW', + 'UW0', 'UW1', 'UW2', 'V', 'W', 'Y', 'Z', 'ZH' +] + +_valid_symbol_set = set(valid_symbols) + + +class CMUDict: + '''Thin wrapper around CMUDict data. http://www.speech.cs.cmu.edu/cgi-bin/cmudict''' + def __init__(self, file_or_path, keep_ambiguous=True): + if isinstance(file_or_path, str): + with open(file_or_path, encoding='latin-1') as f: + entries = _parse_cmudict(f) + else: + entries = _parse_cmudict(file_or_path) + if not keep_ambiguous: + entries = {word: pron for word, pron in entries.items() if len(pron) == 1} + self._entries = entries + + + def __len__(self): + return len(self._entries) + + + def lookup(self, word): + '''Returns list of ARPAbet pronunciations of the given word.''' + return self._entries.get(word.upper()) + + + +_alt_re = re.compile(r'\([0-9]+\)') + + +def _parse_cmudict(file): + cmudict = {} + for line in file: + if len(line) and (line[0] >= 'A' and line[0] <= 'Z' or line[0] == "'"): + parts = line.split(' ') + word = re.sub(_alt_re, '', parts[0]) + pronunciation = _get_pronunciation(parts[1]) + if pronunciation: + if word in cmudict: + cmudict[word].append(pronunciation) + else: + cmudict[word] = [pronunciation] + return cmudict + + +def _get_pronunciation(s): + parts = s.strip().split(' ') + for part in parts: + if part not in _valid_symbol_set: + return None + return ' '.join(parts) diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/layers.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..f10d557ff5a4fff03b94f81543bd58cf1a66bc8f --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/layers.py @@ -0,0 +1,103 @@ +import torch +from librosa.filters import mel as librosa_mel_fn +from .audio_processing import dynamic_range_compression +from .audio_processing import dynamic_range_decompression +from .stft import STFT +from .utils import get_mask_from_lengths + + +class LinearNorm(torch.nn.Module): + def __init__(self, in_dim, out_dim, bias=True, w_init_gain='linear'): + super(LinearNorm, self).__init__() + self.linear_layer = torch.nn.Linear(in_dim, out_dim, bias=bias) + + torch.nn.init.xavier_uniform_( + self.linear_layer.weight, + gain=torch.nn.init.calculate_gain(w_init_gain)) + + def forward(self, x): + return self.linear_layer(x) + + +class ConvNorm(torch.nn.Module): + def __init__(self, in_channels, out_channels, kernel_size=1, stride=1, + padding=None, dilation=1, bias=True, w_init_gain='linear'): + super(ConvNorm, self).__init__() + if padding is None: + assert(kernel_size % 2 == 1) + padding = int(dilation * (kernel_size - 1) / 2) + + self.conv = torch.nn.Conv1d(in_channels, out_channels, + kernel_size=kernel_size, stride=stride, + padding=padding, dilation=dilation, + bias=bias) + + torch.nn.init.xavier_uniform_( + self.conv.weight, gain=torch.nn.init.calculate_gain(w_init_gain)) + + def forward(self, signal): + conv_signal = self.conv(signal) + return conv_signal + + +class GlobalAvgPool(torch.nn.Module): + def __init__(self): + super(GlobalAvgPool, self).__init__() + + def forward(self, x, lengths=None): + """Average pooling across time steps (dim=1) with optionally lengths. + Args: + x: torch.Tensor of shape (N, T, ...) + lengths: None or torch.Tensor of shape (N,) + dim: dimension to pool + """ + if lengths is None: + return x.mean(dim=1, keepdim=False) + else: + mask = get_mask_from_lengths(lengths).type(x.type()).to(x.device) + mask_shape = list(mask.size()) + [1 for _ in range(x.ndimension()-2)] + mask = mask.reshape(*mask_shape) + numer = (x * mask).sum(dim=1, keepdim=False) + denom = mask.sum(dim=1, keepdim=False) + return numer / denom + + +class TacotronSTFT(torch.nn.Module): + def __init__(self, filter_length=1024, hop_length=256, win_length=1024, + n_mel_channels=80, sampling_rate=22050, mel_fmin=0.0, + mel_fmax=8000.0): + super(TacotronSTFT, self).__init__() + self.n_mel_channels = n_mel_channels + self.sampling_rate = sampling_rate + self.stft_fn = STFT(filter_length, hop_length, win_length) + mel_basis = librosa_mel_fn( + sampling_rate, filter_length, n_mel_channels, mel_fmin, mel_fmax) + mel_basis = torch.from_numpy(mel_basis).float() + self.register_buffer('mel_basis', mel_basis) + + def spectral_normalize(self, magnitudes): + output = dynamic_range_compression(magnitudes) + return output + + def spectral_de_normalize(self, magnitudes): + output = dynamic_range_decompression(magnitudes) + return output + + def mel_spectrogram(self, y): + """Computes mel-spectrograms from a batch of waves + PARAMS + ------ + y: Variable(torch.FloatTensor) with shape (B, T) in range [-1, 1] + + RETURNS + ------- + mel_output: torch.FloatTensor of shape (B, n_mel_channels, T) + """ + assert(torch.min(y.data) >= -1) + assert(torch.max(y.data) <= 1) + + magnitudes, phases = self.stft_fn.transform(y) + magnitudes = magnitudes.data + mel_output = torch.matmul(self.mel_basis, magnitudes) + mel_output = self.spectral_normalize(mel_output) + return mel_output diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/model.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/model.py new file mode 100644 index 0000000000000000000000000000000000000000..ccf132b150a7cc1c125c1190b5fd8f43edaae685 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/model.py @@ -0,0 +1,669 @@ +from math import sqrt +import torch +import torch.distributions as distr +from torch.autograd import Variable +from torch import nn +from torch.nn import functional as F +from .layers import ConvNorm, LinearNorm, GlobalAvgPool +from .utils import to_gpu, get_mask_from_lengths + + +class LocationLayer(nn.Module): + def __init__(self, attention_n_filters, attention_kernel_size, + attention_dim): + super(LocationLayer, self).__init__() + padding = int((attention_kernel_size - 1) / 2) + self.location_conv = ConvNorm(2, attention_n_filters, + kernel_size=attention_kernel_size, + padding=padding, bias=False, stride=1, + dilation=1) + self.location_dense = LinearNorm(attention_n_filters, attention_dim, + bias=False, w_init_gain='tanh') + + def forward(self, attention_weights_cat): + processed_attention = self.location_conv(attention_weights_cat) + processed_attention = processed_attention.transpose(1, 2) + processed_attention = self.location_dense(processed_attention) + return processed_attention + + +class Attention(nn.Module): + def __init__(self, attention_rnn_dim, embedding_dim, attention_dim, + attention_location_n_filters, attention_location_kernel_size): + super(Attention, self).__init__() + self.query_layer = LinearNorm(attention_rnn_dim, attention_dim, + bias=False, w_init_gain='tanh') + self.memory_layer = LinearNorm(embedding_dim, attention_dim, bias=False, + w_init_gain='tanh') + self.v = LinearNorm(attention_dim, 1, bias=False) + self.location_layer = LocationLayer(attention_location_n_filters, + attention_location_kernel_size, + attention_dim) + self.score_mask_value = -float("inf") + + def get_alignment_energies(self, query, processed_memory, + attention_weights_cat): + """ + PARAMS + ------ + query: decoder output (batch, n_mel_channels * n_frames_per_step) + processed_memory: processed encoder outputs (B, T_in, attention_dim) + attention_weights_cat: cumulative and prev. att weights (B, 2, max_time) + + RETURNS + ------- + alignment (batch, max_time) + """ + + processed_query = self.query_layer(query.unsqueeze(1)) + processed_attention_weights = self.location_layer(attention_weights_cat) + energies = self.v(torch.tanh( + processed_query + processed_attention_weights + processed_memory)) + + energies = energies.squeeze(-1) + return energies + + def forward(self, attention_hidden_state, memory, processed_memory, + attention_weights_cat, mask): + """ + PARAMS + ------ + attention_hidden_state: attention rnn last output + memory: encoder outputs + processed_memory: processed encoder outputs + attention_weights_cat: previous and cummulative attention weights + mask: binary mask for padded data + """ + alignment = self.get_alignment_energies( + attention_hidden_state, processed_memory, attention_weights_cat) + + if mask is not None: + alignment.data.masked_fill_(mask, self.score_mask_value) + + attention_weights = F.softmax(alignment, dim=1) + attention_context = torch.bmm(attention_weights.unsqueeze(1), memory) + attention_context = attention_context.squeeze(1) + + return attention_context, attention_weights + + +class Prenet(nn.Module): + def __init__(self, in_dim, sizes): + super(Prenet, self).__init__() + in_sizes = [in_dim] + sizes[:-1] + self.layers = nn.ModuleList( + [LinearNorm(in_size, out_size, bias=False) + for (in_size, out_size) in zip(in_sizes, sizes)]) + + def forward(self, x): + for linear in self.layers: + x = F.dropout(F.relu(linear(x)), p=0.5, training=True) + return x + + +class Postnet(nn.Module): + """Postnet + - Five 1-d convolution with 512 channels and kernel size 5 + """ + + def __init__(self, hparams): + super(Postnet, self).__init__() + self.convolutions = nn.ModuleList() + + self.convolutions.append( + nn.Sequential( + ConvNorm(hparams.n_mel_channels, hparams.postnet_embedding_dim, + kernel_size=hparams.postnet_kernel_size, stride=1, + padding=int((hparams.postnet_kernel_size - 1) / 2), + dilation=1, w_init_gain='tanh'), + nn.BatchNorm1d(hparams.postnet_embedding_dim)) + ) + + for i in range(1, hparams.postnet_n_convolutions - 1): + self.convolutions.append( + nn.Sequential( + ConvNorm(hparams.postnet_embedding_dim, + hparams.postnet_embedding_dim, + kernel_size=hparams.postnet_kernel_size, stride=1, + padding=int((hparams.postnet_kernel_size - 1) / 2), + dilation=1, w_init_gain='tanh'), + nn.BatchNorm1d(hparams.postnet_embedding_dim)) + ) + + self.convolutions.append( + nn.Sequential( + ConvNorm(hparams.postnet_embedding_dim, hparams.n_mel_channels, + kernel_size=hparams.postnet_kernel_size, stride=1, + padding=int((hparams.postnet_kernel_size - 1) / 2), + dilation=1, w_init_gain='linear'), + nn.BatchNorm1d(hparams.n_mel_channels)) + ) + + def forward(self, x): + for i in range(len(self.convolutions) - 1): + x = F.dropout(torch.tanh(self.convolutions[i](x)), 0.5, self.training) + x = F.dropout(self.convolutions[-1](x), 0.5, self.training) + + return x + + +class Encoder(nn.Module): + """Encoder module: + - Three 1-d convolution banks + - Bidirectional LSTM + """ + def __init__(self, hparams): + super(Encoder, self).__init__() + + convolutions = [] + for _ in range(hparams.encoder_n_convolutions): + conv_layer = nn.Sequential( + ConvNorm(hparams.encoder_embedding_dim, + hparams.encoder_embedding_dim, + kernel_size=hparams.encoder_kernel_size, stride=1, + padding=int((hparams.encoder_kernel_size - 1) / 2), + dilation=1, w_init_gain='relu'), + nn.BatchNorm1d(hparams.encoder_embedding_dim)) + convolutions.append(conv_layer) + self.convolutions = nn.ModuleList(convolutions) + + self.lstm = nn.LSTM(hparams.encoder_embedding_dim, + int(hparams.encoder_embedding_dim / 2), 1, + batch_first=True, bidirectional=True) + + def forward(self, x, input_lengths): + for conv in self.convolutions: + x = F.dropout(F.relu(conv(x)), 0.5, self.training) + + x = x.transpose(1, 2) + + # pytorch tensor are not reversible, hence the conversion + input_lengths = input_lengths.cpu().numpy() + x = nn.utils.rnn.pack_padded_sequence( + x, input_lengths, batch_first=True) + + self.lstm.flatten_parameters() + outputs, _ = self.lstm(x) + + outputs, _ = nn.utils.rnn.pad_packed_sequence( + outputs, batch_first=True) + + return outputs + + def inference(self, x): + for conv in self.convolutions: + x = F.dropout(F.relu(conv(x)), 0.5, self.training) + + x = x.transpose(1, 2) + + self.lstm.flatten_parameters() + outputs, _ = self.lstm(x) + + return outputs + + +class AudioEncoder(nn.Module): + def __init__(self, hparams): + super(AudioEncoder, self).__init__() + + assert hparams.lat_dim > 0 + + convolutions = [] + inp_dim = hparams.n_mel_channels + for _ in range(hparams.lat_n_convolutions): + conv_layer = nn.Sequential( + ConvNorm(inp_dim, hparams.lat_n_filters, + kernel_size=hparams.lat_kernel_size, stride=1, + padding=int((hparams.lat_kernel_size - 1) / 2), + dilation=1, w_init_gain='tanh'), + nn.BatchNorm1d(hparams.lat_n_filters)) + inp_dim = hparams.lat_n_filters + convolutions.append(conv_layer) + self.convolutions = nn.ModuleList(convolutions) + + self.lstm = nn.LSTM(hparams.lat_n_filters, + int(hparams.lat_n_filters / 2), + hparams.lat_n_blstms, batch_first=True, + bidirectional=True) + self.pool = GlobalAvgPool() + + self.mu_proj = LinearNorm(hparams.lat_n_filters, hparams.lat_dim) + self.logvar_proj = LinearNorm(hparams.lat_n_filters, hparams.lat_dim) + self.lat_dim = hparams.lat_dim + + def forward(self, x, lengths): + """ + Args: + x (torch.Tensor): (B, F, T) + """ + + for conv in self.convolutions: + x = F.dropout(F.tanh(conv(x)), 0.5, self.training) + + x = x.transpose(1, 2) # (B, T, D) + + # x may not be sorted by length. Sort->process->unsort + max_len = x.size(1) + assert max_len == torch.max(lengths).item() + + lengths, perm_idx = lengths.sort(0, descending=True) + x = x[perm_idx] + x = nn.utils.rnn.pack_padded_sequence(x, lengths, batch_first=True) + + self.lstm.flatten_parameters() + outputs, _ = self.lstm(x) + outputs, _ = nn.utils.rnn.pad_packed_sequence(outputs, batch_first=True) + + _, unperm_idx = perm_idx.sort(0) + outputs = outputs[unperm_idx] # (B, T, D) + lengths = lengths[unperm_idx] # (B, T, D) + + outputs = self.pool(outputs, lengths) # (B, D) + + mu = self.mu_proj(outputs) + logvar = self.logvar_proj(outputs) + z = distr.Normal(mu, logvar).rsample() + return z, mu, logvar + + +class Decoder(nn.Module): + def __init__(self, hparams): + super(Decoder, self).__init__() + self.n_mel_channels = hparams.n_mel_channels + self.n_frames_per_step = hparams.n_frames_per_step + self.encoder_embedding_dim = hparams.encoder_embedding_dim + self.obs_dim = hparams.obs_dim + self.lat_dim = hparams.lat_dim + self.attention_rnn_dim = hparams.attention_rnn_dim + self.decoder_rnn_dim = hparams.decoder_rnn_dim + self.prenet_dim = hparams.prenet_dim + self.max_decoder_steps = hparams.max_decoder_steps + self.gate_threshold = hparams.gate_threshold + self.p_attention_dropout = hparams.p_attention_dropout + self.p_decoder_dropout = hparams.p_decoder_dropout + + self.prenet = Prenet( + hparams.n_mel_channels * hparams.n_frames_per_step, + [hparams.prenet_dim, hparams.prenet_dim]) + + self.attention_rnn = nn.LSTMCell( + hparams.prenet_dim + hparams.encoder_embedding_dim, + hparams.attention_rnn_dim) + + self.attention_layer = Attention( + hparams.attention_rnn_dim, hparams.encoder_embedding_dim, + hparams.attention_dim, hparams.attention_location_n_filters, + hparams.attention_location_kernel_size) + + encoder_tot_dim = (hparams.encoder_embedding_dim + \ + hparams.lat_dim + hparams.obs_dim) + self.decoder_rnn = nn.LSTMCell( + hparams.attention_rnn_dim + encoder_tot_dim, + hparams.decoder_rnn_dim, 1) + + self.linear_projection = LinearNorm( + hparams.decoder_rnn_dim + encoder_tot_dim, + hparams.n_mel_channels * hparams.n_frames_per_step) + + self.gate_layer = LinearNorm( + hparams.decoder_rnn_dim + encoder_tot_dim, 1, + bias=True, w_init_gain='sigmoid') + + def get_go_frame(self, memory): + """ Gets all zeros frames to use as first decoder input + PARAMS + ------ + memory: decoder outputs + + RETURNS + ------- + decoder_input: all zeros frames + """ + B = memory.size(0) + decoder_input = Variable(memory.data.new( + B, self.n_mel_channels * self.n_frames_per_step).zero_()) + return decoder_input + + def initialize_decoder_states(self, memory, obs_and_lat, mask): + """ Initializes attention rnn states, decoder rnn states, attention + weights, attention cumulative weights, attention context, stores memory + and stores processed memory + PARAMS + ------ + memory: Encoder outputs + obs_and_lat: Observed and latent attribute embeddings + mask: Mask for padded data if training, expects None for inference + """ + B = memory.size(0) + MAX_TIME = memory.size(1) + + self.attention_hidden = Variable(memory.data.new( + B, self.attention_rnn_dim).zero_()) + self.attention_cell = Variable(memory.data.new( + B, self.attention_rnn_dim).zero_()) + + self.decoder_hidden = Variable(memory.data.new( + B, self.decoder_rnn_dim).zero_()) + self.decoder_cell = Variable(memory.data.new( + B, self.decoder_rnn_dim).zero_()) + + self.attention_weights = Variable(memory.data.new( + B, MAX_TIME).zero_()) + self.attention_weights_cum = Variable(memory.data.new( + B, MAX_TIME).zero_()) + self.attention_context = Variable(memory.data.new( + B, self.encoder_embedding_dim).zero_()) + + self.memory = memory + self.processed_memory = self.attention_layer.memory_layer(memory) + self.obs_and_lat = obs_and_lat + self.mask = mask + + def parse_decoder_inputs(self, decoder_inputs): + """ Prepares decoder inputs, i.e. mel outputs + PARAMS + ------ + decoder_inputs: inputs used for teacher-forced training, i.e. mel-specs + + RETURNS + ------- + inputs: processed decoder inputs + + """ + # (B, n_mel_channels, T_out) -> (B, T_out, n_mel_channels) + decoder_inputs = decoder_inputs.transpose(1, 2) + decoder_inputs = decoder_inputs.view( + decoder_inputs.size(0), + int(decoder_inputs.size(1)/self.n_frames_per_step), -1) + # (B, T_out, n_mel_channels) -> (T_out, B, n_mel_channels) + decoder_inputs = decoder_inputs.transpose(0, 1) + return decoder_inputs + + def parse_decoder_outputs(self, mel_outputs, gate_outputs, alignments): + """ Prepares decoder outputs for output + PARAMS + ------ + mel_outputs: + gate_outputs: gate output energies + alignments: + + RETURNS + ------- + mel_outputs: + gate_outpust: gate output energies + alignments: + """ + # (T_out, B) -> (B, T_out) + alignments = torch.stack(alignments).transpose(0, 1) + # (T_out, B) -> (B, T_out) + gate_outputs = torch.stack(gate_outputs).transpose(0, 1) + gate_outputs = gate_outputs.contiguous() + # (T_out, B, n_mel_channels) -> (B, T_out, n_mel_channels) + mel_outputs = torch.stack(mel_outputs).transpose(0, 1).contiguous() + # decouple frames per step + mel_outputs = mel_outputs.view( + mel_outputs.size(0), -1, self.n_mel_channels) + # (B, T_out, n_mel_channels) -> (B, n_mel_channels, T_out) + mel_outputs = mel_outputs.transpose(1, 2) + + return mel_outputs, gate_outputs, alignments + + def decode(self, decoder_input): + """ Decoder step using stored states, attention and memory + PARAMS + ------ + decoder_input: previous mel output + + RETURNS + ------- + mel_output: + gate_output: gate output energies + attention_weights: + """ + cell_input = torch.cat((decoder_input, self.attention_context), -1) + self.attention_hidden, self.attention_cell = self.attention_rnn( + cell_input, (self.attention_hidden, self.attention_cell)) + self.attention_hidden = F.dropout( + self.attention_hidden, self.p_attention_dropout, self.training) + + attention_weights_cat = torch.cat( + (self.attention_weights.unsqueeze(1), + self.attention_weights_cum.unsqueeze(1)), dim=1) + self.attention_context, self.attention_weights = self.attention_layer( + self.attention_hidden, self.memory, self.processed_memory, + attention_weights_cat, self.mask) + + self.attention_weights_cum += self.attention_weights + decoder_input = torch.cat( + (self.attention_hidden, self.attention_context), -1) + if self.obs_and_lat is not None: + decoder_input = torch.cat((decoder_input, self.obs_and_lat), -1) + self.decoder_hidden, self.decoder_cell = self.decoder_rnn( + decoder_input, (self.decoder_hidden, self.decoder_cell)) + self.decoder_hidden = F.dropout( + self.decoder_hidden, self.p_decoder_dropout, self.training) + + decoder_hidden_attention_context = torch.cat( + (self.decoder_hidden, self.attention_context), dim=1) + if self.obs_and_lat is not None: + decoder_hidden_attention_context = torch.cat( + (decoder_hidden_attention_context, self.obs_and_lat), dim=1) + decoder_output = self.linear_projection( + decoder_hidden_attention_context) + + gate_prediction = self.gate_layer(decoder_hidden_attention_context) + return decoder_output, gate_prediction, self.attention_weights + + def forward(self, memory, obs_and_lat, decoder_inputs, memory_lengths): + """ Decoder forward pass for training + PARAMS + ------ + memory: Encoder outputs + obs_and_lat: Observed and latent attribute embeddings + decoder_inputs: Decoder inputs for teacher forcing. i.e. mel-specs + memory_lengths: Encoder output lengths for attention masking. + + RETURNS + ------- + mel_outputs: mel outputs from the decoder + gate_outputs: gate outputs from the decoder + alignments: sequence of attention weights from the decoder + """ + + decoder_input = self.get_go_frame(memory).unsqueeze(0) + decoder_inputs = self.parse_decoder_inputs(decoder_inputs) + decoder_inputs = torch.cat((decoder_input, decoder_inputs), dim=0) + decoder_inputs = self.prenet(decoder_inputs) + + self.initialize_decoder_states( + memory, obs_and_lat, mask=~get_mask_from_lengths(memory_lengths)) + + mel_outputs, gate_outputs, alignments = [], [], [] + while len(mel_outputs) < decoder_inputs.size(0) - 1: + decoder_input = decoder_inputs[len(mel_outputs)] + mel_output, gate_output, attention_weights = self.decode( + decoder_input) + mel_outputs += [mel_output.squeeze(1)] + gate_outputs += [gate_output.squeeze()] + alignments += [attention_weights] + + mel_outputs, gate_outputs, alignments = self.parse_decoder_outputs( + mel_outputs, gate_outputs, alignments) + + return mel_outputs, gate_outputs, alignments + + def inference(self, memory, obs_and_lat, ret_has_eos=False): + """ Decoder inference + PARAMS + ------ + memory: Encoder outputs + obs_and_lat: Observed and latent attribute embeddings + + RETURNS + ------- + mel_outputs: mel outputs from the decoder + gate_outputs: gate outputs from the decoder + alignments: sequence of attention weights from the decoder + """ + decoder_input = self.get_go_frame(memory) + + self.initialize_decoder_states(memory, obs_and_lat, mask=None) + + mel_outputs, gate_outputs, alignments = [], [], [] + has_eos = False + while True: + decoder_input = self.prenet(decoder_input) + mel_output, gate_output, alignment = self.decode(decoder_input) + + mel_outputs += [mel_output.squeeze(1)] + gate_outputs += [gate_output] + alignments += [alignment] + + if torch.sigmoid(gate_output.data) > self.gate_threshold: + has_eos = True + break + elif len(mel_outputs) == self.max_decoder_steps: + # print("Warning! Reached max decoder steps") + break + + decoder_input = mel_output + + mel_outputs, gate_outputs, alignments = self.parse_decoder_outputs( + mel_outputs, gate_outputs, alignments) + + if ret_has_eos: + return mel_outputs, gate_outputs, alignments, has_eos + else: + return mel_outputs, gate_outputs, alignments + + +class Tacotron2(nn.Module): + def __init__(self, hparams): + super(Tacotron2, self).__init__() + self.mask_padding = hparams.mask_padding + self.fp16_run = hparams.fp16_run + self.n_mel_channels = hparams.n_mel_channels + self.n_frames_per_step = hparams.n_frames_per_step + + # initialize text encoder embedding + self.embedding = nn.Embedding( + hparams.n_symbols, hparams.symbols_embedding_dim) + std = sqrt(2.0 / (hparams.n_symbols + hparams.symbols_embedding_dim)) + val = sqrt(3.0) * std # uniform bounds for std + self.embedding.weight.data.uniform_(-val, val) + + # initialize observed attribute embedding + self.obs_embedding = None + if hparams.obs_dim > 0: + self.obs_embedding = nn.Embedding( + hparams.obs_n_class, hparams.obs_dim) + std = sqrt(2.0 / (hparams.obs_n_class + hparams.obs_dim)) + val = sqrt(3.0) * std # uniform bounds for std + self.obs_embedding.weight.data.uniform_(-val, val) + + self.encoder = Encoder(hparams) + self.decoder = Decoder(hparams) + self.postnet = Postnet(hparams) + + self.lat_encoder = None + if hparams.lat_dim > 0: + self.lat_encoder = AudioEncoder(hparams) + + def parse_batch(self, batch): + (text_padded, input_lengths, obs_labels, + mel_padded, gate_padded, output_lengths) = batch + text_padded = to_gpu(text_padded).long() + input_lengths = to_gpu(input_lengths).long() + obs_labels = to_gpu(obs_labels).long() + max_len = torch.max(input_lengths.data).item() + mel_padded = to_gpu(mel_padded).float() + gate_padded = to_gpu(gate_padded).float() + output_lengths = to_gpu(output_lengths).long() + + return ( + (text_padded, input_lengths, obs_labels, + mel_padded, max_len, output_lengths), + (mel_padded, gate_padded)) + + def parse_output(self, outputs, output_lengths=None): + if self.mask_padding and output_lengths is not None: + mask = ~get_mask_from_lengths(output_lengths) + mask = mask.expand(self.n_mel_channels, mask.size(0), mask.size(1)) + mask = mask.permute(1, 0, 2) + + outputs[0].data.masked_fill_(mask, 0.0) + outputs[1].data.masked_fill_(mask, 0.0) + outputs[2].data.masked_fill_(mask[:, 0, :], 1e3) # gate energies + + return outputs + + def forward(self, inputs): + (text_inputs, text_lengths, obs_labels, + mels, max_len, output_lengths) = inputs + text_lengths, output_lengths = text_lengths.data, output_lengths.data + + embedded_inputs = self.embedding(text_inputs).transpose(1, 2) + + encoder_outputs = self.encoder(embedded_inputs, text_lengths) + + obs = None + if self.obs_embedding is not None: + obs = self.obs_embedding(obs_labels) + + lat, lat_mu, lat_logvar = None, None, None + if self.lat_encoder is not None: + (lat, lat_mu, lat_logvar) = self.lat_encoder(mels, output_lengths) + + obs_and_lat = [x for x in [obs, lat] if x is not None] + if bool(obs_and_lat): + obs_and_lat = torch.cat(obs_and_lat, dim=-1) + else: + obs_and_lat = None + + mel_outputs, gate_outputs, alignments = self.decoder( + encoder_outputs, obs_and_lat, mels, memory_lengths=text_lengths) + + mel_outputs_postnet = self.postnet(mel_outputs) + mel_outputs_postnet = mel_outputs + mel_outputs_postnet + + return self.parse_output( + [mel_outputs, mel_outputs_postnet, gate_outputs, alignments, + lat_mu, lat_logvar], + output_lengths) + + def inference(self, inputs, obs_labels=None, lat=None, ret_has_eos=False): + embedded_inputs = self.embedding(inputs).transpose(1, 2) + encoder_outputs = self.encoder.inference(embedded_inputs) + + if obs_labels is None: + obs_labels = torch.LongTensor(len(inputs)) + obs_labels = obs_labels.to(inputs.device).zero_() + + obs = None + if self.obs_embedding is not None: + obs = self.obs_embedding(obs_labels) + + if self.lat_encoder is not None: + if lat is None: + lat = torch.FloatTensor(len(inputs), self.lat_encoder.lat_dim) + lat = lat.to(inputs.device).zero_().type(encoder_outputs.type()) + + obs_and_lat = [x for x in [obs, lat] if x is not None] + if bool(obs_and_lat): + obs_and_lat = torch.cat(obs_and_lat, dim=-1) + else: + obs_and_lat = None + + mel_outputs, gate_outputs, alignments, has_eos = self.decoder.inference( + encoder_outputs, obs_and_lat, ret_has_eos=True) + + mel_outputs_postnet = self.postnet(mel_outputs) + mel_outputs_postnet = mel_outputs + mel_outputs_postnet + + outputs = self.parse_output( + [mel_outputs, mel_outputs_postnet, gate_outputs, alignments]) + + if ret_has_eos: + return outputs + [has_eos] + else: + return outputs diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/numbers.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/numbers.py new file mode 100644 index 0000000000000000000000000000000000000000..0d5f7fa818a45ecf132627d240afac653e148070 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/numbers.py @@ -0,0 +1,71 @@ +""" from https://github.com/keithito/tacotron """ + +import inflect +import re + + +_inflect = inflect.engine() +_comma_number_re = re.compile(r'([0-9][0-9\,]+[0-9])') +_decimal_number_re = re.compile(r'([0-9]+\.[0-9]+)') +_pounds_re = re.compile(r'£([0-9\,]*[0-9]+)') +_dollars_re = re.compile(r'\$([0-9\.\,]*[0-9]+)') +_ordinal_re = re.compile(r'[0-9]+(st|nd|rd|th)') +_number_re = re.compile(r'[0-9]+') + + +def _remove_commas(m): + return m.group(1).replace(',', '') + + +def _expand_decimal_point(m): + return m.group(1).replace('.', ' point ') + + +def _expand_dollars(m): + match = m.group(1) + parts = match.split('.') + if len(parts) > 2: + return match + ' dollars' # Unexpected format + dollars = int(parts[0]) if parts[0] else 0 + cents = int(parts[1]) if len(parts) > 1 and parts[1] else 0 + if dollars and cents: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s, %s %s' % (dollars, dollar_unit, cents, cent_unit) + elif dollars: + dollar_unit = 'dollar' if dollars == 1 else 'dollars' + return '%s %s' % (dollars, dollar_unit) + elif cents: + cent_unit = 'cent' if cents == 1 else 'cents' + return '%s %s' % (cents, cent_unit) + else: + return 'zero dollars' + + +def _expand_ordinal(m): + return _inflect.number_to_words(m.group(0)) + + +def _expand_number(m): + num = int(m.group(0)) + if num > 1000 and num < 3000: + if num == 2000: + return 'two thousand' + elif num > 2000 and num < 2010: + return 'two thousand ' + _inflect.number_to_words(num % 100) + elif num % 100 == 0: + return _inflect.number_to_words(num // 100) + ' hundred' + else: + return _inflect.number_to_words(num, andword='', zero='oh', group=2).replace(', ', ' ') + else: + return _inflect.number_to_words(num, andword='') + + +def normalize_numbers(text): + text = re.sub(_comma_number_re, _remove_commas, text) + text = re.sub(_pounds_re, r'\1 pounds', text) + text = re.sub(_dollars_re, _expand_dollars, text) + text = re.sub(_decimal_number_re, _expand_decimal_point, text) + text = re.sub(_ordinal_re, _expand_ordinal, text) + text = re.sub(_number_re, _expand_number, text) + return text diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/stft.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/stft.py new file mode 100644 index 0000000000000000000000000000000000000000..63fcd431e2d7746b696aaa0d4172bc04ffb88efa --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/stft.py @@ -0,0 +1,141 @@ +""" +BSD 3-Clause License + +Copyright (c) 2017, Prem Seetharaman +All rights reserved. + +* Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" + +import torch +import numpy as np +import torch.nn.functional as F +from torch.autograd import Variable +from scipy.signal import get_window +from librosa.util import pad_center, tiny +from .audio_processing import window_sumsquare + + +class STFT(torch.nn.Module): + """adapted from Prem Seetharaman's https://github.com/pseeth/pytorch-stft""" + def __init__(self, filter_length=800, hop_length=200, win_length=800, + window='hann'): + super(STFT, self).__init__() + self.filter_length = filter_length + self.hop_length = hop_length + self.win_length = win_length + self.window = window + self.forward_transform = None + scale = self.filter_length / self.hop_length + fourier_basis = np.fft.fft(np.eye(self.filter_length)) + + cutoff = int((self.filter_length / 2 + 1)) + fourier_basis = np.vstack([np.real(fourier_basis[:cutoff, :]), + np.imag(fourier_basis[:cutoff, :])]) + + forward_basis = torch.FloatTensor(fourier_basis[:, None, :]) + inverse_basis = torch.FloatTensor( + np.linalg.pinv(scale * fourier_basis).T[:, None, :]) + + if window is not None: + assert(filter_length >= win_length) + # get window and zero center pad it to filter_length + fft_window = get_window(window, win_length, fftbins=True) + fft_window = pad_center(fft_window, filter_length) + fft_window = torch.from_numpy(fft_window).float() + + # window the bases + forward_basis *= fft_window + inverse_basis *= fft_window + + self.register_buffer('forward_basis', forward_basis.float()) + self.register_buffer('inverse_basis', inverse_basis.float()) + + def transform(self, input_data): + num_batches = input_data.size(0) + num_samples = input_data.size(1) + + self.num_samples = num_samples + + # similar to librosa, reflect-pad the input + input_data = input_data.view(num_batches, 1, num_samples) + input_data = F.pad( + input_data.unsqueeze(1), + (int(self.filter_length / 2), int(self.filter_length / 2), 0, 0), + mode='reflect') + input_data = input_data.squeeze(1) + + forward_transform = F.conv1d( + input_data, + Variable(self.forward_basis, requires_grad=False), + stride=self.hop_length, + padding=0) + + cutoff = int((self.filter_length / 2) + 1) + real_part = forward_transform[:, :cutoff, :] + imag_part = forward_transform[:, cutoff:, :] + + magnitude = torch.sqrt(real_part**2 + imag_part**2) + phase = torch.autograd.Variable( + torch.atan2(imag_part.data, real_part.data)) + + return magnitude, phase + + def inverse(self, magnitude, phase): + recombine_magnitude_phase = torch.cat( + [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) + + inverse_transform = F.conv_transpose1d( + recombine_magnitude_phase, + Variable(self.inverse_basis, requires_grad=False), + stride=self.hop_length, + padding=0) + + if self.window is not None: + window_sum = window_sumsquare( + self.window, magnitude.size(-1), hop_length=self.hop_length, + win_length=self.win_length, n_fft=self.filter_length, + dtype=np.float32) + # remove modulation effects + approx_nonzero_indices = torch.from_numpy( + np.where(window_sum > tiny(window_sum))[0]) + window_sum = torch.autograd.Variable( + torch.from_numpy(window_sum), requires_grad=False) + window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum + inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] + + # scale by hop ratio + inverse_transform *= float(self.filter_length) / self.hop_length + + inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] + inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] + + return inverse_transform + + def forward(self, input_data): + self.magnitude, self.phase = self.transform(input_data) + reconstruction = self.inverse(self.magnitude, self.phase) + return reconstruction diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/symbols.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/symbols.py new file mode 100644 index 0000000000000000000000000000000000000000..5f0d70fdad92ba4f554d971710b60f2f9e8d9298 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/symbols.py @@ -0,0 +1,18 @@ +""" from https://github.com/keithito/tacotron """ + +''' +Defines the set of symbols used in text input to the model. + +The default is a set of ASCII characters that works well for English or text that has been run through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details. ''' +from . import cmudict + +_pad = '_' +_punctuation = '!\'(),.:;? ' +_special = '-' +_letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' + +# Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters): +_arpabet = ['@' + s for s in cmudict.valid_symbols] + +# Export all symbols: +symbols = [_pad] + list(_special) + list(_punctuation) + list(_letters) + _arpabet diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/text.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/text.py new file mode 100644 index 0000000000000000000000000000000000000000..49e2ca498bf67ad226af5de796b9f44afa65198d --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/text.py @@ -0,0 +1,107 @@ +""" from https://github.com/keithito/tacotron """ +import numpy as np +import re +from . import cleaners +from .symbols import symbols + + +# Mappings from symbol to numeric ID and vice versa: +_symbol_to_id = {s: i for i, s in enumerate(symbols)} +_id_to_symbol = {i: s for i, s in enumerate(symbols)} + +# Regular expression matching text enclosed in curly braces: +_curly_re = re.compile(r'(.*?)\{(.+?)\}(.*)') + +# Special symbols +SOS_TOK = '<s>' +EOS_TOK = '</s>' + +def text_to_sequence(text, cleaner_names): + '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text. + + The text can optionally have ARPAbet sequences enclosed in curly braces embedded + in it. For example, "Turn left on {HH AW1 S S T AH0 N} Street." + + Args: + text: string to convert to a sequence + cleaner_names: names of the cleaner functions to run the text through + + Returns: + List of integers corresponding to the symbols in the text + ''' + sequence = [] + + # Check for curly braces and treat their contents as ARPAbet: + while len(text): + m = _curly_re.match(text) + if not m: + sequence += _symbols_to_sequence(_clean_text(text, cleaner_names)) + break + sequence += _symbols_to_sequence(_clean_text(m.group(1), cleaner_names)) + sequence += _arpabet_to_sequence(m.group(2)) + text = m.group(3) + + return sequence + + +def sample_code_chunk(code, size): + assert(size > 0 and size <= len(code)) + start = np.random.randint(len(code) - size + 1) + end = start + size + return code[start:end], start, end + + +def code_to_sequence(code, code_dict, collapse_code): + if collapse_code: + prev_c = None + sequence = [] + for c in code: + if c in code_dict and c != prev_c: + sequence.append(code_dict[c]) + prev_c = c + else: + sequence = [code_dict[c] for c in code if c in code_dict] + if len(sequence) < 0.95 * len(code): + print('WARNING : over 5%% codes are OOV') + + return sequence + + +def sequence_to_text(sequence): + '''Converts a sequence of IDs back to a string''' + result = '' + for symbol_id in sequence: + if symbol_id in _id_to_symbol: + s = _id_to_symbol[symbol_id] + # Enclose ARPAbet back in curly braces: + if len(s) > 1 and s[0] == '@': + s = '{%s}' % s[1:] + result += s + return result.replace('}{', ' ') + + +def sequence_to_code(sequence, code_dict): + '''Analogous to sequence_to_text''' + id_to_code = {i: c for c, i in code_dict.items()} + return ' '.join([id_to_code[i] for i in sequence]) + + +def _clean_text(text, cleaner_names): + for name in cleaner_names: + cleaner = getattr(cleaners, name) + if not cleaner: + raise Exception('Unknown cleaner: %s' % name) + text = cleaner(text) + return text + + +def _symbols_to_sequence(symbols): + return [_symbol_to_id[s] for s in symbols if _should_keep_symbol(s)] + + +def _arpabet_to_sequence(text): + return _symbols_to_sequence(['@' + s for s in text.split()]) + + +def _should_keep_symbol(s): + return s in _symbol_to_id and s != '_' and s != '~' diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/utils.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..66a426d2223ce75ffae6cee2131770556c5949bc --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/utils.py @@ -0,0 +1,167 @@ +import collections +import io +import json +import librosa +import numpy as np +import soundfile as sf +import time +import torch +from scipy.io.wavfile import read +from .text import SOS_TOK, EOS_TOK + + +def get_mask_from_lengths(lengths): + max_len = torch.max(lengths).item() + ids = torch.arange(0, max_len, out=torch.cuda.LongTensor(max_len)) + mask = (ids < lengths.unsqueeze(1)) + return mask + + +def load_wav_to_torch(full_path, sr=None): + data, sr = librosa.load(full_path, sr=sr) + data = np.clip(data, -1, 1) # potentially out of [-1, 1] due to resampling + data = data * 32768.0 # match values loaded by scipy + return torch.FloatTensor(data.astype(np.float32)), sr + + +def read_binary_audio(bin_data, tar_sr=None): + """ + read binary audio (`bytes` or `uint8` `numpy.ndarray`) to `float32` + `numpy.ndarray` + + RETURNS: + data (np.ndarray) : audio of shape (n,) or (2, n) + tar_sr (int) : sample rate + """ + data, ori_sr = sf.read(io.BytesIO(bin_data), dtype='float32') + data = data.T + if (tar_sr is not None) and (ori_sr != tar_sr): + data = librosa.resample(data, ori_sr, tar_sr) + else: + tar_sr = ori_sr + data = np.clip(data, -1, 1) + data = data * 32768.0 + return torch.FloatTensor(data.astype(np.float32)), tar_sr + + +def load_filepaths_and_text(filename): + with open(filename, encoding='utf-8') as f: + data = [json.loads(line.rstrip()) for line in f] + return data + + +def to_gpu(x): + x = x.contiguous() + + if torch.cuda.is_available(): + x = x.cuda(non_blocking=True) + return torch.autograd.Variable(x) + + +def load_code_dict(path, add_sos=False, add_eos=False): + if not path: + return {} + + with open(path, 'r') as f: + codes = ['_'] + [line.rstrip() for line in f] # '_' for pad + code_dict = {c: i for i, c in enumerate(codes)} + + if add_sos: + code_dict[SOS_TOK] = len(code_dict) + if add_eos: + code_dict[EOS_TOK] = len(code_dict) + assert(set(code_dict.values()) == set(range(len(code_dict)))) + + return code_dict + + +def load_obs_label_dict(path): + if not path: + return {} + with open(path, 'r') as f: + obs_labels = [line.rstrip() for line in f] + return {c: i for i, c in enumerate(obs_labels)} + + +# A simple timer class inspired from `tnt.TimeMeter` +class CudaTimer: + def __init__(self, keys): + self.keys = keys + self.reset() + + def start(self, key): + s = torch.cuda.Event(enable_timing=True) + s.record() + self.start_events[key].append(s) + return self + + def stop(self, key): + e = torch.cuda.Event(enable_timing=True) + e.record() + self.end_events[key].append(e) + return self + + def reset(self): + self.start_events = collections.defaultdict(list) + self.end_events = collections.defaultdict(list) + self.running_times = collections.defaultdict(float) + self.n = collections.defaultdict(int) + return self + + def value(self): + self._synchronize() + return {k: self.running_times[k] / self.n[k] for k in self.keys} + + def _synchronize(self): + torch.cuda.synchronize() + for k in self.keys: + starts = self.start_events[k] + ends = self.end_events[k] + if len(starts) == 0: + raise ValueError("Trying to divide by zero in TimeMeter") + if len(ends) != len(starts): + raise ValueError("Call stop before checking value!") + time = 0 + for start, end in zip(starts, ends): + time += start.elapsed_time(end) + self.running_times[k] += time * 1e-3 + self.n[k] += len(starts) + self.start_events = collections.defaultdict(list) + self.end_events = collections.defaultdict(list) + + +# Used to measure the time taken for multiple events +class Timer: + def __init__(self, keys): + self.keys = keys + self.n = {} + self.running_time = {} + self.total_time = {} + self.reset() + + def start(self, key): + self.running_time[key] = time.time() + return self + + def stop(self, key): + self.total_time[key] = time.time() - self.running_time[key] + self.n[key] += 1 + self.running_time[key] = None + return self + + def reset(self): + for k in self.keys: + self.total_time[k] = 0 + self.running_time[k] = None + self.n[k] = 0 + return self + + def value(self): + vals = {} + for k in self.keys: + if self.n[k] == 0: + raise ValueError("Trying to divide by zero in TimeMeter") + else: + vals[k] = self.total_time[k] / self.n[k] + return vals + diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/waveglow_denoiser.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/waveglow_denoiser.py new file mode 100644 index 0000000000000000000000000000000000000000..6a6585e8b6901a059445ff54ca20ea87751bbb11 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tacotron2/waveglow_denoiser.py @@ -0,0 +1,40 @@ +# import sys +# sys.path.append('tacotron2') +import torch +from .layers import STFT + + +class Denoiser(torch.nn.Module): + """ Removes model bias from audio produced with waveglow """ + + def __init__(self, waveglow, filter_length=1024, n_overlap=4, + win_length=1024, mode='zeros'): + super(Denoiser, self).__init__() + self.stft = STFT(filter_length=filter_length, + hop_length=int(filter_length/n_overlap), + win_length=win_length).cuda() + if mode == 'zeros': + mel_input = torch.zeros( + (1, 80, 88), + dtype=waveglow.upsample.weight.dtype, + device=waveglow.upsample.weight.device) + elif mode == 'normal': + mel_input = torch.randn( + (1, 80, 88), + dtype=waveglow.upsample.weight.dtype, + device=waveglow.upsample.weight.device) + else: + raise Exception("Mode {} if not supported".format(mode)) + + with torch.no_grad(): + bias_audio = waveglow.infer(mel_input, sigma=0.0).float() + bias_spec, _ = self.stft.transform(bias_audio) + + self.register_buffer('bias_spec', bias_spec[:, :, 0][:, :, None]) + + def forward(self, audio, strength=0.1): + audio_spec, audio_angles = self.stft.transform(audio.cuda().float()) + audio_spec_denoised = audio_spec - self.bias_spec * strength + audio_spec_denoised = torch.clamp(audio_spec_denoised, 0.0) + audio_denoised = self.stft.inverse(audio_spec_denoised, audio_angles) + return audio_denoised diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/tts_data.py b/fairseq/examples/textless_nlp/gslm/unit2speech/tts_data.py new file mode 100644 index 0000000000000000000000000000000000000000..eb0f7c360d749fd9d489b40b04dae8652b095098 --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/tts_data.py @@ -0,0 +1,52 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import torch +import numpy as np +from examples.textless_nlp.gslm.unit2speech.tacotron2.text import ( + EOS_TOK, + SOS_TOK, + code_to_sequence, + text_to_sequence, +) +from examples.textless_nlp.gslm.unit2speech.tacotron2.utils import ( + load_code_dict, +) + + +class TacotronInputDataset: + def __init__(self, hparams, append_str=""): + self.is_text = getattr(hparams, "text_or_code", "text") == "text" + if not self.is_text: + self.code_dict = load_code_dict(hparams.code_dict) + self.code_key = hparams.code_key + self.add_sos = hparams.add_sos + self.add_eos = hparams.add_eos + self.collapse_code = hparams.collapse_code + self.append_str = append_str + + def process_code(self, inp_str): + inp_toks = inp_str.split() + if self.add_sos: + inp_toks = [SOS_TOK] + inp_toks + if self.add_eos: + inp_toks = inp_toks + [EOS_TOK] + return code_to_sequence(inp_toks, self.code_dict, self.collapse_code) + + def process_text(self, inp_str): + return text_to_sequence(inp_str, ["english_cleaners"]) + + def get_tensor(self, inp_str): + # uid, txt, inp_str = self._get_data(idx) + inp_str = inp_str + self.append_str + if self.is_text: + inp_toks = self.process_text(inp_str) + else: + inp_toks = self.process_code(inp_str) + return torch.from_numpy(np.array(inp_toks)).long() + + def __len__(self): + return len(self.data) diff --git a/fairseq/examples/textless_nlp/gslm/unit2speech/utils.py b/fairseq/examples/textless_nlp/gslm/unit2speech/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..7aced08d38301b98b19e2df7d19f1c61150107bc --- /dev/null +++ b/fairseq/examples/textless_nlp/gslm/unit2speech/utils.py @@ -0,0 +1,55 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import torch +from examples.textless_nlp.gslm.unit2speech.tacotron2.model import Tacotron2 +from examples.textless_nlp.gslm.unit2speech.tacotron2.waveglow_denoiser import ( + Denoiser, +) + + +def load_quantized_audio_from_file(file_path): + base_fname_batch, quantized_units_batch = [], [] + with open(file_path) as f: + for line in f: + base_fname, quantized_units_str = line.rstrip().split("|") + quantized_units = [int(q) for q in quantized_units_str.split(" ")] + base_fname_batch.append(base_fname) + quantized_units_batch.append(quantized_units) + return base_fname_batch, quantized_units_batch + + +def synthesize_audio(model, waveglow, denoiser, inp, lab=None, strength=0.0): + assert inp.size(0) == 1 + inp = inp.cuda() + if lab is not None: + lab = torch.LongTensor(1).cuda().fill_(lab) + + with torch.no_grad(): + _, mel, _, ali, has_eos = model.inference(inp, lab, ret_has_eos=True) + aud = waveglow.infer(mel, sigma=0.666) + aud_dn = denoiser(aud, strength=strength).squeeze(1) + return mel, aud, aud_dn, has_eos + + +def load_tacotron(tacotron_model_path, max_decoder_steps): + ckpt_dict = torch.load(tacotron_model_path) + hparams = ckpt_dict["hparams"] + hparams.max_decoder_steps = max_decoder_steps + sr = hparams.sampling_rate + model = Tacotron2(hparams) + model.load_state_dict(ckpt_dict["model_dict"]) + model = model.cuda().eval().half() + return model, sr, hparams + + +def load_waveglow(waveglow_path): + waveglow = torch.load(waveglow_path)["model"] + waveglow = waveglow.cuda().eval().half() + for k in waveglow.convinv: + k.float() + denoiser = Denoiser(waveglow) + return waveglow, denoiser diff --git a/fairseq/examples/translation/README.md b/fairseq/examples/translation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2941f5eb8482dab61dca5eca27a71abd7ee5bf5c --- /dev/null +++ b/fairseq/examples/translation/README.md @@ -0,0 +1,301 @@ +# Neural Machine Translation + +This README contains instructions for [using pretrained translation models](#example-usage-torchhub) +as well as [training new models](#training-a-new-model). + +## Pre-trained models + +Model | Description | Dataset | Download +---|---|---|--- +`conv.wmt14.en-fr` | Convolutional <br> ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.newstest2014.tar.bz2) <br> newstest2012/2013: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.ntst1213.tar.bz2) +`conv.wmt14.en-de` | Convolutional <br> ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT14 English-German](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-de.fconv-py.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-de.newstest2014.tar.bz2) +`conv.wmt17.en-de` | Convolutional <br> ([Gehring et al., 2017](https://arxiv.org/abs/1705.03122)) | [WMT17 English-German](http://statmt.org/wmt17/translation-task.html#Download) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt17.v2.en-de.fconv-py.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt17.v2.en-de.newstest2014.tar.bz2) +`transformer.wmt14.en-fr` | Transformer <br> ([Ott et al., 2018](https://arxiv.org/abs/1806.00187)) | [WMT14 English-French](http://statmt.org/wmt14/translation-task.html#Download) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-fr.joined-dict.transformer.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt14.en-fr.joined-dict.newstest2014.tar.bz2) +`transformer.wmt16.en-de` | Transformer <br> ([Ott et al., 2018](https://arxiv.org/abs/1806.00187)) | [WMT16 English-German](https://drive.google.com/uc?export=download&id=0B_bZck-ksdkpM25jRUN2X2UxMm8) | model: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/models/wmt16.en-de.joined-dict.transformer.tar.bz2) <br> newstest2014: <br> [download (.tar.bz2)](https://dl.fbaipublicfiles.com/fairseq/data/wmt16.en-de.joined-dict.newstest2014.tar.bz2) +`transformer.wmt18.en-de` | Transformer <br> ([Edunov et al., 2018](https://arxiv.org/abs/1808.09381)) <br> WMT'18 winner | [WMT'18 English-German](http://www.statmt.org/wmt18/translation-task.html) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt18.en-de.ensemble.tar.gz) <br> See NOTE in the archive +`transformer.wmt19.en-de` | Transformer <br> ([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) <br> WMT'19 winner | [WMT'19 English-German](http://www.statmt.org/wmt19/translation-task.html) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-de.joined-dict.ensemble.tar.gz) +`transformer.wmt19.de-en` | Transformer <br> ([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) <br> WMT'19 winner | [WMT'19 German-English](http://www.statmt.org/wmt19/translation-task.html) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.de-en.joined-dict.ensemble.tar.gz) +`transformer.wmt19.en-ru` | Transformer <br> ([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) <br> WMT'19 winner | [WMT'19 English-Russian](http://www.statmt.org/wmt19/translation-task.html) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-ru.ensemble.tar.gz) +`transformer.wmt19.ru-en` | Transformer <br> ([Ng et al., 2019](https://arxiv.org/abs/1907.06616)) <br> WMT'19 winner | [WMT'19 Russian-English](http://www.statmt.org/wmt19/translation-task.html) | model: <br> [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.ru-en.ensemble.tar.gz) + +## Example usage (torch.hub) + +We require a few additional Python dependencies for preprocessing: +```bash +pip install fastBPE sacremoses subword_nmt +``` + +Interactive translation via PyTorch Hub: +```python +import torch + +# List available models +torch.hub.list('pytorch/fairseq') # [..., 'transformer.wmt16.en-de', ... ] + +# Load a transformer trained on WMT'16 En-De +# Note: WMT'19 models use fastBPE instead of subword_nmt, see instructions below +en2de = torch.hub.load('pytorch/fairseq', 'transformer.wmt16.en-de', + tokenizer='moses', bpe='subword_nmt') +en2de.eval() # disable dropout + +# The underlying model is available under the *models* attribute +assert isinstance(en2de.models[0], fairseq.models.transformer.TransformerModel) + +# Move model to GPU for faster translation +en2de.cuda() + +# Translate a sentence +en2de.translate('Hello world!') +# 'Hallo Welt!' + +# Batched translation +en2de.translate(['Hello world!', 'The cat sat on the mat.']) +# ['Hallo Welt!', 'Die Katze saß auf der Matte.'] +``` + +Loading custom models: +```python +from fairseq.models.transformer import TransformerModel +zh2en = TransformerModel.from_pretrained( + '/path/to/checkpoints', + checkpoint_file='checkpoint_best.pt', + data_name_or_path='data-bin/wmt17_zh_en_full', + bpe='subword_nmt', + bpe_codes='data-bin/wmt17_zh_en_full/zh.code' +) +zh2en.translate('你好 世界') +# 'Hello World' +``` + +If you are using a `transformer.wmt19` models, you will need to set the `bpe` +argument to `'fastbpe'` and (optionally) load the 4-model ensemble: +```python +en2de = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-de', + checkpoint_file='model1.pt:model2.pt:model3.pt:model4.pt', + tokenizer='moses', bpe='fastbpe') +en2de.eval() # disable dropout +``` + +## Example usage (CLI tools) + +Generation with the binarized test sets can be run in batch mode as follows, e.g. for WMT 2014 English-French on a GTX-1080ti: +```bash +mkdir -p data-bin +curl https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2 | tar xvjf - -C data-bin +curl https://dl.fbaipublicfiles.com/fairseq/data/wmt14.v2.en-fr.newstest2014.tar.bz2 | tar xvjf - -C data-bin +fairseq-generate data-bin/wmt14.en-fr.newstest2014 \ + --path data-bin/wmt14.en-fr.fconv-py/model.pt \ + --beam 5 --batch-size 128 --remove-bpe | tee /tmp/gen.out +# ... +# | Translated 3003 sentences (96311 tokens) in 166.0s (580.04 tokens/s) +# | Generate test with beam=5: BLEU4 = 40.83, 67.5/46.9/34.4/25.5 (BP=1.000, ratio=1.006, syslen=83262, reflen=82787) + +# Compute BLEU score +grep ^H /tmp/gen.out | cut -f3- > /tmp/gen.out.sys +grep ^T /tmp/gen.out | cut -f2- > /tmp/gen.out.ref +fairseq-score --sys /tmp/gen.out.sys --ref /tmp/gen.out.ref +# BLEU4 = 40.83, 67.5/46.9/34.4/25.5 (BP=1.000, ratio=1.006, syslen=83262, reflen=82787) +``` + +## Training a new model + +### IWSLT'14 German to English (Transformer) + +The following instructions can be used to train a Transformer model on the [IWSLT'14 German to English dataset](http://workshop2014.iwslt.org/downloads/proceeding.pdf). + +First download and preprocess the data: +```bash +# Download and prepare the data +cd examples/translation/ +bash prepare-iwslt14.sh +cd ../.. + +# Preprocess/binarize the data +TEXT=examples/translation/iwslt14.tokenized.de-en +fairseq-preprocess --source-lang de --target-lang en \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/iwslt14.tokenized.de-en \ + --workers 20 +``` + +Next we'll train a Transformer translation model over this data: +```bash +CUDA_VISIBLE_DEVICES=0 fairseq-train \ + data-bin/iwslt14.tokenized.de-en \ + --arch transformer_iwslt_de_en --share-decoder-input-output-embed \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr 5e-4 --lr-scheduler inverse_sqrt --warmup-updates 4000 \ + --dropout 0.3 --weight-decay 0.0001 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --max-tokens 4096 \ + --eval-bleu \ + --eval-bleu-args '{"beam": 5, "max_len_a": 1.2, "max_len_b": 10}' \ + --eval-bleu-detok moses \ + --eval-bleu-remove-bpe \ + --eval-bleu-print-samples \ + --best-checkpoint-metric bleu --maximize-best-checkpoint-metric +``` + +Finally we can evaluate our trained model: +```bash +fairseq-generate data-bin/iwslt14.tokenized.de-en \ + --path checkpoints/checkpoint_best.pt \ + --batch-size 128 --beam 5 --remove-bpe +``` + +### WMT'14 English to German (Convolutional) + +The following instructions can be used to train a Convolutional translation model on the WMT English to German dataset. +See the [Scaling NMT README](../scaling_nmt/README.md) for instructions to train a Transformer translation model on this data. + +The WMT English to German dataset can be preprocessed using the `prepare-wmt14en2de.sh` script. +By default it will produce a dataset that was modeled after [Attention Is All You Need (Vaswani et al., 2017)](https://arxiv.org/abs/1706.03762), but with additional news-commentary-v12 data from WMT'17. + +To use only data available in WMT'14 or to replicate results obtained in the original [Convolutional Sequence to Sequence Learning (Gehring et al., 2017)](https://arxiv.org/abs/1705.03122) paper, please use the `--icml17` option. + +```bash +# Download and prepare the data +cd examples/translation/ +# WMT'17 data: +bash prepare-wmt14en2de.sh +# or to use WMT'14 data: +# bash prepare-wmt14en2de.sh --icml17 +cd ../.. + +# Binarize the dataset +TEXT=examples/translation/wmt17_en_de +fairseq-preprocess \ + --source-lang en --target-lang de \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/wmt17_en_de --thresholdtgt 0 --thresholdsrc 0 \ + --workers 20 + +# Train the model +mkdir -p checkpoints/fconv_wmt_en_de +fairseq-train \ + data-bin/wmt17_en_de \ + --arch fconv_wmt_en_de \ + --dropout 0.2 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --optimizer nag --clip-norm 0.1 \ + --lr 0.5 --lr-scheduler fixed --force-anneal 50 \ + --max-tokens 4000 \ + --save-dir checkpoints/fconv_wmt_en_de + +# Evaluate +fairseq-generate data-bin/wmt17_en_de \ + --path checkpoints/fconv_wmt_en_de/checkpoint_best.pt \ + --beam 5 --remove-bpe +``` + +### WMT'14 English to French +```bash +# Download and prepare the data +cd examples/translation/ +bash prepare-wmt14en2fr.sh +cd ../.. + +# Binarize the dataset +TEXT=examples/translation/wmt14_en_fr +fairseq-preprocess \ + --source-lang en --target-lang fr \ + --trainpref $TEXT/train --validpref $TEXT/valid --testpref $TEXT/test \ + --destdir data-bin/wmt14_en_fr --thresholdtgt 0 --thresholdsrc 0 \ + --workers 60 + +# Train the model +mkdir -p checkpoints/fconv_wmt_en_fr +fairseq-train \ + data-bin/wmt14_en_fr \ + --arch fconv_wmt_en_fr \ + --dropout 0.1 \ + --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \ + --optimizer nag --clip-norm 0.1 \ + --lr 0.5 --lr-scheduler fixed --force-anneal 50 \ + --max-tokens 3000 \ + --save-dir checkpoints/fconv_wmt_en_fr + +# Evaluate +fairseq-generate \ + data-bin/fconv_wmt_en_fr \ + --path checkpoints/fconv_wmt_en_fr/checkpoint_best.pt \ + --beam 5 --remove-bpe +``` + +## Multilingual Translation + +We also support training multilingual translation models. In this example we'll +train a multilingual `{de,fr}-en` translation model using the IWSLT'17 datasets. + +Note that we use slightly different preprocessing here than for the IWSLT'14 +En-De data above. In particular we learn a joint BPE code for all three +languages and use fairseq-interactive and sacrebleu for scoring the test set. + +```bash +# First install sacrebleu and sentencepiece +pip install sacrebleu sentencepiece + +# Then download and preprocess the data +cd examples/translation/ +bash prepare-iwslt17-multilingual.sh +cd ../.. + +# Binarize the de-en dataset +TEXT=examples/translation/iwslt17.de_fr.en.bpe16k +fairseq-preprocess --source-lang de --target-lang en \ + --trainpref $TEXT/train.bpe.de-en \ + --validpref $TEXT/valid0.bpe.de-en,$TEXT/valid1.bpe.de-en,$TEXT/valid2.bpe.de-en,$TEXT/valid3.bpe.de-en,$TEXT/valid4.bpe.de-en,$TEXT/valid5.bpe.de-en \ + --destdir data-bin/iwslt17.de_fr.en.bpe16k \ + --workers 10 + +# Binarize the fr-en dataset +# NOTE: it's important to reuse the en dictionary from the previous step +fairseq-preprocess --source-lang fr --target-lang en \ + --trainpref $TEXT/train.bpe.fr-en \ + --validpref $TEXT/valid0.bpe.fr-en,$TEXT/valid1.bpe.fr-en,$TEXT/valid2.bpe.fr-en,$TEXT/valid3.bpe.fr-en,$TEXT/valid4.bpe.fr-en,$TEXT/valid5.bpe.fr-en \ + --tgtdict data-bin/iwslt17.de_fr.en.bpe16k/dict.en.txt \ + --destdir data-bin/iwslt17.de_fr.en.bpe16k \ + --workers 10 + +# Train a multilingual transformer model +# NOTE: the command below assumes 1 GPU, but accumulates gradients from +# 8 fwd/bwd passes to simulate training on 8 GPUs +mkdir -p checkpoints/multilingual_transformer +CUDA_VISIBLE_DEVICES=0 fairseq-train data-bin/iwslt17.de_fr.en.bpe16k/ \ + --max-epoch 50 \ + --ddp-backend=legacy_ddp \ + --task multilingual_translation --lang-pairs de-en,fr-en \ + --arch multilingual_transformer_iwslt_de_en \ + --share-decoders --share-decoder-input-output-embed \ + --optimizer adam --adam-betas '(0.9, 0.98)' \ + --lr 0.0005 --lr-scheduler inverse_sqrt \ + --warmup-updates 4000 --warmup-init-lr '1e-07' \ + --label-smoothing 0.1 --criterion label_smoothed_cross_entropy \ + --dropout 0.3 --weight-decay 0.0001 \ + --save-dir checkpoints/multilingual_transformer \ + --max-tokens 4000 \ + --update-freq 8 + +# Generate and score the test set with sacrebleu +SRC=de +sacrebleu --test-set iwslt17 --language-pair ${SRC}-en --echo src \ + | python scripts/spm_encode.py --model examples/translation/iwslt17.de_fr.en.bpe16k/sentencepiece.bpe.model \ + > iwslt17.test.${SRC}-en.${SRC}.bpe +cat iwslt17.test.${SRC}-en.${SRC}.bpe \ + | fairseq-interactive data-bin/iwslt17.de_fr.en.bpe16k/ \ + --task multilingual_translation --lang-pairs de-en,fr-en \ + --source-lang ${SRC} --target-lang en \ + --path checkpoints/multilingual_transformer/checkpoint_best.pt \ + --buffer-size 2000 --batch-size 128 \ + --beam 5 --remove-bpe=sentencepiece \ + > iwslt17.test.${SRC}-en.en.sys +grep ^H iwslt17.test.${SRC}-en.en.sys | cut -f3 \ + | sacrebleu --test-set iwslt17 --language-pair ${SRC}-en +``` + +##### Argument format during inference + +During inference it is required to specify a single `--source-lang` and +`--target-lang`, which indicates the inference langauge direction. +`--lang-pairs`, `--encoder-langtok`, `--decoder-langtok` have to be set to +the same value as training. diff --git a/fairseq/examples/translation/prepare-iwslt14.sh b/fairseq/examples/translation/prepare-iwslt14.sh new file mode 100644 index 0000000000000000000000000000000000000000..2fb6643fbccb58701dcbb77d91430e68a821ba38 --- /dev/null +++ b/fairseq/examples/translation/prepare-iwslt14.sh @@ -0,0 +1,115 @@ +#!/usr/bin/env bash +# +# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh + +echo 'Cloning Moses github repository (for tokenization scripts)...' +git clone https://github.com/moses-smt/mosesdecoder.git + +echo 'Cloning Subword NMT repository (for BPE pre-processing)...' +git clone https://github.com/rsennrich/subword-nmt.git + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +LC=$SCRIPTS/tokenizer/lowercase.perl +CLEAN=$SCRIPTS/training/clean-corpus-n.perl +BPEROOT=subword-nmt/subword_nmt +BPE_TOKENS=10000 + +URL="http://dl.fbaipublicfiles.com/fairseq/data/iwslt14/de-en.tgz" +GZ=de-en.tgz + +if [ ! -d "$SCRIPTS" ]; then + echo "Please set SCRIPTS variable correctly to point to Moses scripts." + exit +fi + +src=de +tgt=en +lang=de-en +prep=iwslt14.tokenized.de-en +tmp=$prep/tmp +orig=orig + +mkdir -p $orig $tmp $prep + +echo "Downloading data from ${URL}..." +cd $orig +wget "$URL" + +if [ -f $GZ ]; then + echo "Data successfully downloaded." +else + echo "Data not successfully downloaded." + exit +fi + +tar zxvf $GZ +cd .. + +echo "pre-processing train data..." +for l in $src $tgt; do + f=train.tags.$lang.$l + tok=train.tags.$lang.tok.$l + + cat $orig/$lang/$f | \ + grep -v '<url>' | \ + grep -v '<talkid>' | \ + grep -v '<keywords>' | \ + sed -e 's/<title>//g' | \ + sed -e 's/<\/title>//g' | \ + sed -e 's/<description>//g' | \ + sed -e 's/<\/description>//g' | \ + perl $TOKENIZER -threads 8 -l $l > $tmp/$tok + echo "" +done +perl $CLEAN -ratio 1.5 $tmp/train.tags.$lang.tok $src $tgt $tmp/train.tags.$lang.clean 1 175 +for l in $src $tgt; do + perl $LC < $tmp/train.tags.$lang.clean.$l > $tmp/train.tags.$lang.$l +done + +echo "pre-processing valid/test data..." +for l in $src $tgt; do + for o in `ls $orig/$lang/IWSLT14.TED*.$l.xml`; do + fname=${o##*/} + f=$tmp/${fname%.*} + echo $o $f + grep '<seg id' $o | \ + sed -e 's/<seg id="[0-9]*">\s*//g' | \ + sed -e 's/\s*<\/seg>\s*//g' | \ + sed -e "s/\’/\'/g" | \ + perl $TOKENIZER -threads 8 -l $l | \ + perl $LC > $f + echo "" + done +done + + +echo "creating train, valid, test..." +for l in $src $tgt; do + awk '{if (NR%23 == 0) print $0; }' $tmp/train.tags.de-en.$l > $tmp/valid.$l + awk '{if (NR%23 != 0) print $0; }' $tmp/train.tags.de-en.$l > $tmp/train.$l + + cat $tmp/IWSLT14.TED.dev2010.de-en.$l \ + $tmp/IWSLT14.TEDX.dev2012.de-en.$l \ + $tmp/IWSLT14.TED.tst2010.de-en.$l \ + $tmp/IWSLT14.TED.tst2011.de-en.$l \ + $tmp/IWSLT14.TED.tst2012.de-en.$l \ + > $tmp/test.$l +done + +TRAIN=$tmp/train.en-de +BPE_CODE=$prep/code +rm -f $TRAIN +for l in $src $tgt; do + cat $tmp/train.$l >> $TRAIN +done + +echo "learn_bpe.py on ${TRAIN}..." +python $BPEROOT/learn_bpe.py -s $BPE_TOKENS < $TRAIN > $BPE_CODE + +for L in $src $tgt; do + for f in train.$L valid.$L test.$L; do + echo "apply_bpe.py to ${f}..." + python $BPEROOT/apply_bpe.py -c $BPE_CODE < $tmp/$f > $prep/$f + done +done diff --git a/fairseq/examples/translation/prepare-iwslt17-multilingual.sh b/fairseq/examples/translation/prepare-iwslt17-multilingual.sh new file mode 100644 index 0000000000000000000000000000000000000000..23be87555322bc03b13e9d95951d88b1a442f97a --- /dev/null +++ b/fairseq/examples/translation/prepare-iwslt17-multilingual.sh @@ -0,0 +1,133 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +SRCS=( + "de" + "fr" +) +TGT=en + +ROOT=$(dirname "$0") +SCRIPTS=$ROOT/../../scripts +SPM_TRAIN=$SCRIPTS/spm_train.py +SPM_ENCODE=$SCRIPTS/spm_encode.py + +BPESIZE=16384 +ORIG=$ROOT/iwslt17_orig +DATA=$ROOT/iwslt17.de_fr.en.bpe16k +mkdir -p "$ORIG" "$DATA" + +TRAIN_MINLEN=1 # remove sentences with <1 BPE token +TRAIN_MAXLEN=250 # remove sentences with >250 BPE tokens + +URLS=( + "https://wit3.fbk.eu/archive/2017-01-trnted/texts/de/en/de-en.tgz" + "https://wit3.fbk.eu/archive/2017-01-trnted/texts/fr/en/fr-en.tgz" +) +ARCHIVES=( + "de-en.tgz" + "fr-en.tgz" +) +VALID_SETS=( + "IWSLT17.TED.dev2010.de-en IWSLT17.TED.tst2010.de-en IWSLT17.TED.tst2011.de-en IWSLT17.TED.tst2012.de-en IWSLT17.TED.tst2013.de-en IWSLT17.TED.tst2014.de-en IWSLT17.TED.tst2015.de-en" + "IWSLT17.TED.dev2010.fr-en IWSLT17.TED.tst2010.fr-en IWSLT17.TED.tst2011.fr-en IWSLT17.TED.tst2012.fr-en IWSLT17.TED.tst2013.fr-en IWSLT17.TED.tst2014.fr-en IWSLT17.TED.tst2015.fr-en" +) + +# download and extract data +for ((i=0;i<${#URLS[@]};++i)); do + ARCHIVE=$ORIG/${ARCHIVES[i]} + if [ -f "$ARCHIVE" ]; then + echo "$ARCHIVE already exists, skipping download" + else + URL=${URLS[i]} + wget -P "$ORIG" "$URL" + if [ -f "$ARCHIVE" ]; then + echo "$URL successfully downloaded." + else + echo "$URL not successfully downloaded." + exit 1 + fi + fi + FILE=${ARCHIVE: -4} + if [ -e "$FILE" ]; then + echo "$FILE already exists, skipping extraction" + else + tar -C "$ORIG" -xzvf "$ARCHIVE" + fi +done + +echo "pre-processing train data..." +for SRC in "${SRCS[@]}"; do + for LANG in "${SRC}" "${TGT}"; do + cat "$ORIG/${SRC}-${TGT}/train.tags.${SRC}-${TGT}.${LANG}" \ + | grep -v '<url>' \ + | grep -v '<talkid>' \ + | grep -v '<keywords>' \ + | grep -v '<speaker>' \ + | grep -v '<reviewer' \ + | grep -v '<translator' \ + | grep -v '<doc' \ + | grep -v '</doc>' \ + | sed -e 's/<title>//g' \ + | sed -e 's/<\/title>//g' \ + | sed -e 's/<description>//g' \ + | sed -e 's/<\/description>//g' \ + | sed 's/^\s*//g' \ + | sed 's/\s*$//g' \ + > "$DATA/train.${SRC}-${TGT}.${LANG}" + done +done + +echo "pre-processing valid data..." +for ((i=0;i<${#SRCS[@]};++i)); do + SRC=${SRCS[i]} + VALID_SET=(${VALID_SETS[i]}) + for ((j=0;j<${#VALID_SET[@]};++j)); do + FILE=${VALID_SET[j]} + for LANG in "$SRC" "$TGT"; do + grep '<seg id' "$ORIG/${SRC}-${TGT}/${FILE}.${LANG}.xml" \ + | sed -e 's/<seg id="[0-9]*">\s*//g' \ + | sed -e 's/\s*<\/seg>\s*//g' \ + | sed -e "s/\’/\'/g" \ + > "$DATA/valid${j}.${SRC}-${TGT}.${LANG}" + done + done +done + +# learn BPE with sentencepiece +TRAIN_FILES=$(for SRC in "${SRCS[@]}"; do echo $DATA/train.${SRC}-${TGT}.${SRC}; echo $DATA/train.${SRC}-${TGT}.${TGT}; done | tr "\n" ",") +echo "learning joint BPE over ${TRAIN_FILES}..." +python "$SPM_TRAIN" \ + --input=$TRAIN_FILES \ + --model_prefix=$DATA/sentencepiece.bpe \ + --vocab_size=$BPESIZE \ + --character_coverage=1.0 \ + --model_type=bpe + +# encode train/valid +echo "encoding train with learned BPE..." +for SRC in "${SRCS[@]}"; do + python "$SPM_ENCODE" \ + --model "$DATA/sentencepiece.bpe.model" \ + --output_format=piece \ + --inputs $DATA/train.${SRC}-${TGT}.${SRC} $DATA/train.${SRC}-${TGT}.${TGT} \ + --outputs $DATA/train.bpe.${SRC}-${TGT}.${SRC} $DATA/train.bpe.${SRC}-${TGT}.${TGT} \ + --min-len $TRAIN_MINLEN --max-len $TRAIN_MAXLEN +done + +echo "encoding valid with learned BPE..." +for ((i=0;i<${#SRCS[@]};++i)); do + SRC=${SRCS[i]} + VALID_SET=(${VALID_SETS[i]}) + for ((j=0;j<${#VALID_SET[@]};++j)); do + python "$SPM_ENCODE" \ + --model "$DATA/sentencepiece.bpe.model" \ + --output_format=piece \ + --inputs $DATA/valid${j}.${SRC}-${TGT}.${SRC} $DATA/valid${j}.${SRC}-${TGT}.${TGT} \ + --outputs $DATA/valid${j}.bpe.${SRC}-${TGT}.${SRC} $DATA/valid${j}.bpe.${SRC}-${TGT}.${TGT} + done +done diff --git a/fairseq/examples/translation/prepare-wmt14en2de.sh b/fairseq/examples/translation/prepare-wmt14en2de.sh new file mode 100644 index 0000000000000000000000000000000000000000..6702c88b568c9e680b525593ff0c9fb0a474825d --- /dev/null +++ b/fairseq/examples/translation/prepare-wmt14en2de.sh @@ -0,0 +1,142 @@ +#!/bin/bash +# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh + +echo 'Cloning Moses github repository (for tokenization scripts)...' +git clone https://github.com/moses-smt/mosesdecoder.git + +echo 'Cloning Subword NMT repository (for BPE pre-processing)...' +git clone https://github.com/rsennrich/subword-nmt.git + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +CLEAN=$SCRIPTS/training/clean-corpus-n.perl +NORM_PUNC=$SCRIPTS/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl +BPEROOT=subword-nmt/subword_nmt +BPE_TOKENS=40000 + +URLS=( + "http://statmt.org/wmt13/training-parallel-europarl-v7.tgz" + "http://statmt.org/wmt13/training-parallel-commoncrawl.tgz" + "http://data.statmt.org/wmt17/translation-task/training-parallel-nc-v12.tgz" + "http://data.statmt.org/wmt17/translation-task/dev.tgz" + "http://statmt.org/wmt14/test-full.tgz" +) +FILES=( + "training-parallel-europarl-v7.tgz" + "training-parallel-commoncrawl.tgz" + "training-parallel-nc-v12.tgz" + "dev.tgz" + "test-full.tgz" +) +CORPORA=( + "training/europarl-v7.de-en" + "commoncrawl.de-en" + "training/news-commentary-v12.de-en" +) + +# This will make the dataset compatible to the one used in "Convolutional Sequence to Sequence Learning" +# https://arxiv.org/abs/1705.03122 +if [ "$1" == "--icml17" ]; then + URLS[2]="http://statmt.org/wmt14/training-parallel-nc-v9.tgz" + FILES[2]="training-parallel-nc-v9.tgz" + CORPORA[2]="training/news-commentary-v9.de-en" + OUTDIR=wmt14_en_de +else + OUTDIR=wmt17_en_de +fi + +if [ ! -d "$SCRIPTS" ]; then + echo "Please set SCRIPTS variable correctly to point to Moses scripts." + exit +fi + +src=en +tgt=de +lang=en-de +prep=$OUTDIR +tmp=$prep/tmp +orig=orig +dev=dev/newstest2013 + +mkdir -p $orig $tmp $prep + +cd $orig + +for ((i=0;i<${#URLS[@]};++i)); do + file=${FILES[i]} + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + url=${URLS[i]} + wget "$url" + if [ -f $file ]; then + echo "$url successfully downloaded." + else + echo "$url not successfully downloaded." + exit -1 + fi + if [ ${file: -4} == ".tgz" ]; then + tar zxvf $file + elif [ ${file: -4} == ".tar" ]; then + tar xvf $file + fi + fi +done +cd .. + +echo "pre-processing train data..." +for l in $src $tgt; do + rm $tmp/train.tags.$lang.tok.$l + for f in "${CORPORA[@]}"; do + cat $orig/$f.$l | \ + perl $NORM_PUNC $l | \ + perl $REM_NON_PRINT_CHAR | \ + perl $TOKENIZER -threads 8 -a -l $l >> $tmp/train.tags.$lang.tok.$l + done +done + +echo "pre-processing test data..." +for l in $src $tgt; do + if [ "$l" == "$src" ]; then + t="src" + else + t="ref" + fi + grep '<seg id' $orig/test-full/newstest2014-deen-$t.$l.sgm | \ + sed -e 's/<seg id="[0-9]*">\s*//g' | \ + sed -e 's/\s*<\/seg>\s*//g' | \ + sed -e "s/\’/\'/g" | \ + perl $TOKENIZER -threads 8 -a -l $l > $tmp/test.$l + echo "" +done + +echo "splitting train and valid..." +for l in $src $tgt; do + awk '{if (NR%100 == 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/valid.$l + awk '{if (NR%100 != 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/train.$l +done + +TRAIN=$tmp/train.de-en +BPE_CODE=$prep/code +rm -f $TRAIN +for l in $src $tgt; do + cat $tmp/train.$l >> $TRAIN +done + +echo "learn_bpe.py on ${TRAIN}..." +python $BPEROOT/learn_bpe.py -s $BPE_TOKENS < $TRAIN > $BPE_CODE + +for L in $src $tgt; do + for f in train.$L valid.$L test.$L; do + echo "apply_bpe.py to ${f}..." + python $BPEROOT/apply_bpe.py -c $BPE_CODE < $tmp/$f > $tmp/bpe.$f + done +done + +perl $CLEAN -ratio 1.5 $tmp/bpe.train $src $tgt $prep/train 1 250 +perl $CLEAN -ratio 1.5 $tmp/bpe.valid $src $tgt $prep/valid 1 250 + +for L in $src $tgt; do + cp $tmp/bpe.test.$L $prep/test.$L +done diff --git a/fairseq/examples/translation/prepare-wmt14en2fr.sh b/fairseq/examples/translation/prepare-wmt14en2fr.sh new file mode 100644 index 0000000000000000000000000000000000000000..2ac97a5b76fab255449493488ed8bd67350a7bac --- /dev/null +++ b/fairseq/examples/translation/prepare-wmt14en2fr.sh @@ -0,0 +1,136 @@ +#!/bin/bash +# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh + +echo 'Cloning Moses github repository (for tokenization scripts)...' +git clone https://github.com/moses-smt/mosesdecoder.git + +echo 'Cloning Subword NMT repository (for BPE pre-processing)...' +git clone https://github.com/rsennrich/subword-nmt.git + +SCRIPTS=mosesdecoder/scripts +TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl +CLEAN=$SCRIPTS/training/clean-corpus-n.perl +NORM_PUNC=$SCRIPTS/tokenizer/normalize-punctuation.perl +REM_NON_PRINT_CHAR=$SCRIPTS/tokenizer/remove-non-printing-char.perl +BPEROOT=subword-nmt/subword_nmt +BPE_TOKENS=40000 + +URLS=( + "http://statmt.org/wmt13/training-parallel-europarl-v7.tgz" + "http://statmt.org/wmt13/training-parallel-commoncrawl.tgz" + "http://statmt.org/wmt13/training-parallel-un.tgz" + "http://statmt.org/wmt14/training-parallel-nc-v9.tgz" + "http://statmt.org/wmt10/training-giga-fren.tar" + "http://statmt.org/wmt14/test-full.tgz" +) +FILES=( + "training-parallel-europarl-v7.tgz" + "training-parallel-commoncrawl.tgz" + "training-parallel-un.tgz" + "training-parallel-nc-v9.tgz" + "training-giga-fren.tar" + "test-full.tgz" +) +CORPORA=( + "training/europarl-v7.fr-en" + "commoncrawl.fr-en" + "un/undoc.2000.fr-en" + "training/news-commentary-v9.fr-en" + "giga-fren.release2.fixed" +) + +if [ ! -d "$SCRIPTS" ]; then + echo "Please set SCRIPTS variable correctly to point to Moses scripts." + exit +fi + +src=en +tgt=fr +lang=en-fr +prep=wmt14_en_fr +tmp=$prep/tmp +orig=orig + +mkdir -p $orig $tmp $prep + +cd $orig + +for ((i=0;i<${#URLS[@]};++i)); do + file=${FILES[i]} + if [ -f $file ]; then + echo "$file already exists, skipping download" + else + url=${URLS[i]} + wget "$url" + if [ -f $file ]; then + echo "$url successfully downloaded." + else + echo "$url not successfully downloaded." + exit -1 + fi + if [ ${file: -4} == ".tgz" ]; then + tar zxvf $file + elif [ ${file: -4} == ".tar" ]; then + tar xvf $file + fi + fi +done + +gunzip giga-fren.release2.fixed.*.gz +cd .. + +echo "pre-processing train data..." +for l in $src $tgt; do + rm $tmp/train.tags.$lang.tok.$l + for f in "${CORPORA[@]}"; do + cat $orig/$f.$l | \ + perl $NORM_PUNC $l | \ + perl $REM_NON_PRINT_CHAR | \ + perl $TOKENIZER -threads 8 -a -l $l >> $tmp/train.tags.$lang.tok.$l + done +done + +echo "pre-processing test data..." +for l in $src $tgt; do + if [ "$l" == "$src" ]; then + t="src" + else + t="ref" + fi + grep '<seg id' $orig/test-full/newstest2014-fren-$t.$l.sgm | \ + sed -e 's/<seg id="[0-9]*">\s*//g' | \ + sed -e 's/\s*<\/seg>\s*//g' | \ + sed -e "s/\’/\'/g" | \ + perl $TOKENIZER -threads 8 -a -l $l > $tmp/test.$l + echo "" +done + +echo "splitting train and valid..." +for l in $src $tgt; do + awk '{if (NR%1333 == 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/valid.$l + awk '{if (NR%1333 != 0) print $0; }' $tmp/train.tags.$lang.tok.$l > $tmp/train.$l +done + +TRAIN=$tmp/train.fr-en +BPE_CODE=$prep/code +rm -f $TRAIN +for l in $src $tgt; do + cat $tmp/train.$l >> $TRAIN +done + +echo "learn_bpe.py on ${TRAIN}..." +python $BPEROOT/learn_bpe.py -s $BPE_TOKENS < $TRAIN > $BPE_CODE + +for L in $src $tgt; do + for f in train.$L valid.$L test.$L; do + echo "apply_bpe.py to ${f}..." + python $BPEROOT/apply_bpe.py -c $BPE_CODE < $tmp/$f > $tmp/bpe.$f + done +done + +perl $CLEAN -ratio 1.5 $tmp/bpe.train $src $tgt $prep/train 1 250 +perl $CLEAN -ratio 1.5 $tmp/bpe.valid $src $tgt $prep/valid 1 250 + +for L in $src $tgt; do + cp $tmp/bpe.test.$L $prep/test.$L +done diff --git a/fairseq/examples/translation_moe/README.md b/fairseq/examples/translation_moe/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2e5c8af617f410f64ca38d29447bd05b6af8c5a8 --- /dev/null +++ b/fairseq/examples/translation_moe/README.md @@ -0,0 +1,89 @@ +# Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019) + +This page includes instructions for reproducing results from the paper [Mixture Models for Diverse Machine Translation: Tricks of the Trade (Shen et al., 2019)](https://arxiv.org/abs/1902.07816). + +## Download data + +First, follow the [instructions to download and preprocess the WMT'17 En-De dataset](../translation#prepare-wmt14en2desh). +Make sure to learn a joint vocabulary by passing the `--joined-dictionary` option to `fairseq-preprocess`. + +## Train a model + +Then we can train a mixture of experts model using the `translation_moe` task. +Use the `--method` flag to choose the MoE variant; we support hard mixtures with a learned or uniform prior (`--method hMoElp` and `hMoEup`, respectively) and soft mixures (`--method sMoElp` and `sMoEup`). +The model is trained with online responsibility assignment and shared parameterization. + +The following command will train a `hMoElp` model with `3` experts: +```bash +fairseq-train --ddp-backend='legacy_ddp' \ + data-bin/wmt17_en_de \ + --max-update 100000 \ + --task translation_moe --user-dir examples/translation_moe/translation_moe_src \ + --method hMoElp --mean-pool-gating-network \ + --num-experts 3 \ + --arch transformer_wmt_en_de --share-all-embeddings \ + --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \ + --lr-scheduler inverse_sqrt --warmup-init-lr 1e-07 --warmup-updates 4000 \ + --lr 0.0007 \ + --dropout 0.1 --weight-decay 0.0 --criterion cross_entropy \ + --max-tokens 3584 +``` + +## Translate + +Once a model is trained, we can generate translations from different experts using the `--gen-expert` option. +For example, to generate from expert 0: +```bash +fairseq-generate data-bin/wmt17_en_de \ + --path checkpoints/checkpoint_best.pt \ + --beam 1 --remove-bpe \ + --task translation_moe --user-dir examples/translation_moe/translation_moe_src \ + --method hMoElp --mean-pool-gating-network \ + --num-experts 3 \ + --gen-expert 0 +``` + +## Evaluate + +First download a tokenized version of the WMT'14 En-De test set with multiple references: +```bash +wget dl.fbaipublicfiles.com/fairseq/data/wmt14-en-de.extra_refs.tok +``` + +Next apply BPE on the fly and run generation for each expert: +```bash +BPE_CODE=examples/translation/wmt17_en_de/code +for EXPERT in $(seq 0 2); do \ + cat wmt14-en-de.extra_refs.tok \ + | grep ^S | cut -f 2 \ + | fairseq-interactive data-bin/wmt17_en_de \ + --path checkpoints/checkpoint_best.pt \ + --beam 1 \ + --bpe subword_nmt --bpe-codes $BPE_CODE \ + --buffer-size 500 --max-tokens 6000 \ + --task translation_moe --user-dir examples/translation_moe/translation_moe_src \ + --method hMoElp --mean-pool-gating-network \ + --num-experts 3 \ + --gen-expert $EXPERT ; \ +done > wmt14-en-de.extra_refs.tok.gen.3experts +``` + +Finally use `score_moe.py` to compute pairwise BLUE and average oracle BLEU: +```bash +python examples/translation_moe/score.py --sys wmt14-en-de.extra_refs.tok.gen.3experts --ref wmt14-en-de.extra_refs.tok +# pairwise BLEU: 48.26 +# #refs covered: 2.11 +# multi-reference BLEU (leave-one-out): 59.46 +``` +This matches row 3 from Table 7 in the paper. + +## Citation + +```bibtex +@article{shen2019mixture, + title = {Mixture Models for Diverse Machine Translation: Tricks of the Trade}, + author = {Tianxiao Shen and Myle Ott and Michael Auli and Marc'Aurelio Ranzato}, + journal = {International Conference on Machine Learning}, + year = 2019, +} +``` diff --git a/fairseq/examples/translation_moe/score.py b/fairseq/examples/translation_moe/score.py new file mode 100644 index 0000000000000000000000000000000000000000..9a529a985019710ea202cb6bf28ae071c0ce4135 --- /dev/null +++ b/fairseq/examples/translation_moe/score.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Scoring script for computing pairwise BLEU and multi-ref BLEU over a set of +candidate hypotheses. + +See `"Mixture Models for Diverse Machine Translation: Tricks of the Trade" +(Shen et al., 2019) <https://arxiv.org/abs/1902.07816>`_. +""" + +import argparse +import random +import sys +from itertools import chain + +import numpy as np +from sacrebleu import compute_bleu, corpus_bleu as _corpus_bleu + + +def main(): + parser = argparse.ArgumentParser(sys.argv[0]) + parser.add_argument( + "--sys", nargs="*", default="", metavar="FILE", help="path to system output" + ) + parser.add_argument("--ref", default="", metavar="FILE", help="path to references") + parser.add_argument( + "--output", + default="", + metavar="FILE", + help="print outputs into a pretty format", + ) + args = parser.parse_args() + + if args.sys: + src, tgt, hypos, log_probs = load_sys(args.sys) + print("pairwise BLEU: %.2f" % pairwise(hypos)) + if args.output: + merge(src, tgt, hypos, log_probs, args.output) + + if args.ref: + _, _, refs = load_ref(args.ref) + if args.sys: + multi_ref(refs, hypos) + else: + intra_ref(refs) + + +def dictolist(d): + a = sorted(d.items(), key=lambda i: i[0]) + return [i[1] for i in a] + + +def load_sys(paths): + src, tgt, hypos, log_probs = {}, {}, {}, {} + for path in paths: + with open(path) as f: + for line in f: + line = line.rstrip() + # S: source + # T: target + # D: detokenized system output + if line.startswith(("S-", "T-", "D-")): + i = int(line[line.find("-") + 1 : line.find("\t")]) + if line.startswith("S-"): + src[i] = line.split("\t")[1] + if line.startswith("T-"): + tgt[i] = line.split("\t")[1] + if line.startswith("D-"): + if i not in hypos: + hypos[i] = [] + log_probs[i] = [] + hypos[i].append(line.split("\t")[2]) + log_probs[i].append(float(line.split("\t")[1])) + return dictolist(src), dictolist(tgt), dictolist(hypos), dictolist(log_probs) + + +def load_ref(path): + with open(path) as f: + lines = f.readlines() + src, tgt, refs = [], [], [] + i = 0 + while i < len(lines): + if lines[i].startswith("S-"): + src.append(lines[i].split("\t")[1].rstrip()) + i += 1 + elif lines[i].startswith("T-"): + tgt.append(lines[i].split("\t")[1].rstrip()) + i += 1 + else: + a = [] + while i < len(lines) and lines[i].startswith("R"): + a.append(lines[i].split("\t")[1].rstrip()) + i += 1 + refs.append(a) + return src, tgt, refs + + +def merge(src, tgt, hypos, log_probs, path): + with open(path, "w") as f: + for s, t, hs, lps in zip(src, tgt, hypos, log_probs): + f.write(s + "\n") + f.write(t + "\n") + f.write("\n") + for h, lp in zip(hs, lps): + f.write("\t%f\t%s\n" % (lp, h.strip())) + f.write("------------------------------------------------------\n") + + +def corpus_bleu(sys_stream, ref_streams): + bleu = _corpus_bleu(sys_stream, ref_streams, tokenize="none") + return bleu.score + + +def sentence_bleu(hypothesis, reference): + bleu = _corpus_bleu(hypothesis, reference) + for i in range(1, 4): + bleu.counts[i] += 1 + bleu.totals[i] += 1 + bleu = compute_bleu( + bleu.counts, + bleu.totals, + bleu.sys_len, + bleu.ref_len, + smooth_method="exp", + ) + return bleu.score + + +def pairwise(sents): + _ref, _hypo = [], [] + for s in sents: + for i in range(len(s)): + for j in range(len(s)): + if i != j: + _ref.append(s[i]) + _hypo.append(s[j]) + return corpus_bleu(_hypo, [_ref]) + + +def multi_ref(refs, hypos): + _ref, _hypo = [], [] + ref_cnt = 0 + assert len(refs) == len(hypos) + + # count number of refs covered + for rs, hs in zip(refs, hypos): + a = set() + for h in hs: + s = [sentence_bleu(h, r) for r in rs] + j = np.argmax(s) + _ref.append(rs[j]) + _hypo.append(h) + best = [k for k in range(len(rs)) if s[k] == s[j]] + a.add(random.choice(best)) + ref_cnt += len(a) + print("#refs covered: %.2f" % (ref_cnt / len(refs))) + + # transpose refs and hypos + refs = list(zip(*refs)) + hypos = list(zip(*hypos)) + + # compute multi-ref corpus BLEU (leave-one-out to be comparable to intra_ref) + k = len(hypos) + m = len(refs) + flat_hypos = [hypos[j][i] for i in range(len(hypos[0])) for j in range(k)] + duplicated_refs = [[ref for ref in refs_i for _ in range(k)] for refs_i in refs] + loo_bleus = [] + for held_out_ref in range(m): + remaining_refs = ( + duplicated_refs[:held_out_ref] + duplicated_refs[held_out_ref + 1 :] + ) + assert len(remaining_refs) == m - 1 + loo_bleus.append(corpus_bleu(flat_hypos, remaining_refs)) + print("average multi-reference BLEU (leave-one-out): %.2f" % np.mean(loo_bleus)) + + +def intra_ref(refs): + print("ref pairwise BLEU: %.2f" % pairwise(refs)) + refs = list(zip(*refs)) + m = len(refs) + concat_h = [] + concat_rest = [[] for j in range(m - 1)] + for i, h in enumerate(refs): + rest = refs[:i] + refs[i + 1 :] + concat_h.append(h) + for j in range(m - 1): + concat_rest[j].extend(rest[j]) + concat_h = list(chain.from_iterable(concat_h)) + bleu = corpus_bleu(concat_h, concat_rest) + print("multi-reference BLEU (leave-one-out): %.2f" % bleu) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/translation_moe/translation_moe_src/__init__.py b/fairseq/examples/translation_moe/translation_moe_src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c0abe53e973b4bb31cfb062708965d002c79b6e7 --- /dev/null +++ b/fairseq/examples/translation_moe/translation_moe_src/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import translation_moe # noqa diff --git a/fairseq/examples/translation_moe/translation_moe_src/logsumexp_moe.py b/fairseq/examples/translation_moe/translation_moe_src/logsumexp_moe.py new file mode 100644 index 0000000000000000000000000000000000000000..fb299daecbc2b15fb66555bbfb8d1d983e481518 --- /dev/null +++ b/fairseq/examples/translation_moe/translation_moe_src/logsumexp_moe.py @@ -0,0 +1,26 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + + +class LogSumExpMoE(torch.autograd.Function): + """Standard LogSumExp forward pass, but use *posterior* for the backward. + + See `"Mixture Models for Diverse Machine Translation: Tricks of the Trade" + (Shen et al., 2019) <https://arxiv.org/abs/1902.07816>`_. + """ + + @staticmethod + def forward(ctx, logp, posterior, dim=-1): + ctx.save_for_backward(posterior) + ctx.dim = dim + return torch.logsumexp(logp, dim=dim) + + @staticmethod + def backward(ctx, grad_output): + (posterior,) = ctx.saved_tensors + grad_logp = grad_output.unsqueeze(ctx.dim) * posterior + return grad_logp, None, None diff --git a/fairseq/examples/translation_moe/translation_moe_src/mean_pool_gating_network.py b/fairseq/examples/translation_moe/translation_moe_src/mean_pool_gating_network.py new file mode 100644 index 0000000000000000000000000000000000000000..efc7ae40bf8fed6c2384cbc6f94477c4caa4c10c --- /dev/null +++ b/fairseq/examples/translation_moe/translation_moe_src/mean_pool_gating_network.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F + + +class MeanPoolGatingNetwork(torch.nn.Module): + """A simple mean-pooling gating network for selecting experts. + + This module applies mean pooling over an encoder's output and returns + reponsibilities for each expert. The encoder format is expected to match + :class:`fairseq.models.transformer.TransformerEncoder`. + """ + + def __init__(self, embed_dim, num_experts, dropout=None): + super().__init__() + self.embed_dim = embed_dim + self.num_experts = num_experts + + self.fc1 = torch.nn.Linear(embed_dim, embed_dim) + self.dropout = torch.nn.Dropout(dropout) if dropout is not None else None + self.fc2 = torch.nn.Linear(embed_dim, num_experts) + + def forward(self, encoder_out): + if not ( + "encoder_out" in encoder_out + and "encoder_padding_mask" in encoder_out + and encoder_out["encoder_out"][0].size(2) == self.embed_dim + ): + raise ValueError("Unexpected format for encoder_out") + + # mean pooling over time + encoder_padding_mask = encoder_out["encoder_padding_mask"][0] # B x T + encoder_out = encoder_out["encoder_out"][0].transpose(0, 1) # B x T x C + if encoder_padding_mask is not None: + encoder_out = encoder_out.clone() # required because of transpose above + encoder_out[encoder_padding_mask] = 0 + ntokens = torch.sum(~encoder_padding_mask, dim=1, keepdim=True) + x = torch.sum(encoder_out, dim=1) / ntokens.type_as(encoder_out) + else: + x = torch.mean(encoder_out, dim=1) + + x = torch.tanh(self.fc1(x)) + if self.dropout is not None: + x = self.dropout(x) + x = self.fc2(x) + return F.log_softmax(x, dim=-1, dtype=torch.float32).type_as(x) diff --git a/fairseq/examples/translation_moe/translation_moe_src/translation_moe.py b/fairseq/examples/translation_moe/translation_moe_src/translation_moe.py new file mode 100644 index 0000000000000000000000000000000000000000..7f28c32dd6152f53d6922cdfccfa903e0bdc5829 --- /dev/null +++ b/fairseq/examples/translation_moe/translation_moe_src/translation_moe.py @@ -0,0 +1,258 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import torch +from omegaconf import II + +from fairseq import metrics, utils +from fairseq.dataclass import ChoiceEnum +from fairseq.tasks import register_task +from fairseq.tasks.translation import TranslationConfig, TranslationTask + +from .logsumexp_moe import LogSumExpMoE +from .mean_pool_gating_network import MeanPoolGatingNetwork + + +METHOD_CHOICES = ChoiceEnum(["sMoElp", "sMoEup", "hMoElp", "hMoEup"]) + + +@dataclass +class TranslationMoEConfig(TranslationConfig): + method: METHOD_CHOICES = field( + default="hMoEup", + metadata={"help": "MoE method"}, + ) + num_experts: int = field( + default=3, + metadata={"help": "number of experts"}, + ) + mean_pool_gating_network: bool = field( + default=False, + metadata={"help": "use a simple mean-pooling gating network"}, + ) + mean_pool_gating_network_dropout: float = field( + default=0, + metadata={"help": "dropout for mean-pooling gating network"}, + ) + mean_pool_gating_network_encoder_dim: int = field( + default=0, + metadata={"help": "encoder output dim for mean-pooling gating network"}, + ) + gen_expert: int = field( + default=0, + metadata={"help": "which expert to use for generation"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + + +@register_task("translation_moe", dataclass=TranslationMoEConfig) +class TranslationMoETask(TranslationTask): + """ + Translation task for Mixture of Experts (MoE) models. + + See `"Mixture Models for Diverse Machine Translation: Tricks of the Trade" + (Shen et al., 2019) <https://arxiv.org/abs/1902.07816>`_. + + Args: + src_dict (~fairseq.data.Dictionary): dictionary for the source language + tgt_dict (~fairseq.data.Dictionary): dictionary for the target language + + .. note:: + + The translation task is compatible with :mod:`fairseq-train`, + :mod:`fairseq-generate` and :mod:`fairseq-interactive`. + + The translation task provides the following additional command-line + arguments: + + .. argparse:: + :ref: fairseq.tasks.translation_parser + :prog: + """ + + cfg: TranslationMoEConfig + + def __init__(self, cfg: TranslationMoEConfig, src_dict, tgt_dict): + if cfg.method == "sMoElp": + # soft MoE with learned prior + self.uniform_prior = False + self.hard_selection = False + elif cfg.method == "sMoEup": + # soft MoE with uniform prior + self.uniform_prior = True + self.hard_selection = False + elif cfg.method == "hMoElp": + # hard MoE with learned prior + self.uniform_prior = False + self.hard_selection = True + elif cfg.method == "hMoEup": + # hard MoE with uniform prior + self.uniform_prior = True + self.hard_selection = True + + # add indicator tokens for each expert + for i in range(cfg.num_experts): + # add to both dictionaries in case we're sharing embeddings + src_dict.add_symbol("<expert_{}>".format(i)) + tgt_dict.add_symbol("<expert_{}>".format(i)) + + super().__init__(cfg, src_dict, tgt_dict) + + def build_model(self, cfg): + from fairseq import models + + model = models.build_model(cfg, self) + if not self.uniform_prior and not hasattr(model, "gating_network"): + if self.cfg.mean_pool_gating_network: + if self.cfg.mean_pool_gating_network_encoder_dim > 0: + encoder_dim = self.cfg.mean_pool_gating_network_encoder_dim + elif getattr(cfg, "encoder_embed_dim", None): + # assume that encoder_embed_dim is the encoder's output dimension + encoder_dim = cfg.encoder_embed_dim + else: + raise ValueError( + "Must specify --mean-pool-gating-network-encoder-dim" + ) + + if self.cfg.mean_pool_gating_network_dropout > 0: + dropout = self.cfg.mean_pool_gating_network_dropout + elif getattr(cfg, "dropout", None): + dropout = cfg.dropout + else: + raise ValueError("Must specify task.mean_pool_gating_network_dropout") + + model.gating_network = MeanPoolGatingNetwork( + encoder_dim, + self.cfg.num_experts, + dropout, + ) + else: + raise ValueError( + "translation_moe task with learned prior requires the model to " + "have a gating network; try using --mean-pool-gating-network" + ) + return model + + def expert_index(self, i): + return i + self.tgt_dict.index("<expert_0>") + + def _get_loss(self, sample, model, criterion): + assert hasattr( + criterion, "compute_loss" + ), "translation_moe task requires the criterion to implement the compute_loss() method" + + k = self.cfg.num_experts + bsz = sample["target"].size(0) + + def get_lprob_y(encoder_out, prev_output_tokens_k): + net_output = model.decoder( + prev_output_tokens=prev_output_tokens_k, + encoder_out=encoder_out, + ) + loss, _ = criterion.compute_loss(model, net_output, sample, reduce=False) + loss = loss.view(bsz, -1) + return -loss.sum(dim=1, keepdim=True) # -> B x 1 + + def get_lprob_yz(winners=None): + encoder_out = model.encoder( + src_tokens=sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + ) + + if winners is None: + lprob_y = [] + for i in range(k): + prev_output_tokens_k = sample["net_input"][ + "prev_output_tokens" + ].clone() + assert not prev_output_tokens_k.requires_grad + prev_output_tokens_k[:, 0] = self.expert_index(i) + lprob_y.append(get_lprob_y(encoder_out, prev_output_tokens_k)) + lprob_y = torch.cat(lprob_y, dim=1) # -> B x K + else: + prev_output_tokens_k = sample["net_input"]["prev_output_tokens"].clone() + prev_output_tokens_k[:, 0] = self.expert_index(winners) + lprob_y = get_lprob_y(encoder_out, prev_output_tokens_k) # -> B + + if self.uniform_prior: + lprob_yz = lprob_y + else: + lprob_z = model.gating_network(encoder_out) # B x K + if winners is not None: + lprob_z = lprob_z.gather(dim=1, index=winners.unsqueeze(-1)) + lprob_yz = lprob_y + lprob_z.type_as(lprob_y) # B x K + + return lprob_yz + + # compute responsibilities without dropout + with utils.model_eval(model): # disable dropout + with torch.no_grad(): # disable autograd + lprob_yz = get_lprob_yz() # B x K + prob_z_xy = torch.nn.functional.softmax(lprob_yz, dim=1) + assert not prob_z_xy.requires_grad + + # compute loss with dropout + if self.hard_selection: + winners = prob_z_xy.max(dim=1)[1] + loss = -get_lprob_yz(winners) + else: + lprob_yz = get_lprob_yz() # B x K + loss = -LogSumExpMoE.apply(lprob_yz, prob_z_xy, 1) + + loss = loss.sum() + sample_size = ( + sample["target"].size(0) if self.cfg.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": utils.item(loss.data), + "ntokens": sample["ntokens"], + "nsentences": bsz, + "sample_size": sample_size, + "posterior": prob_z_xy.float().sum(dim=0).cpu(), + } + return loss, sample_size, logging_output + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + model.train() + loss, sample_size, logging_output = self._get_loss(sample, model, criterion) + if ignore_grad: + loss *= 0 + optimizer.backward(loss) + return loss, sample_size, logging_output + + def valid_step(self, sample, model, criterion): + model.eval() + with torch.no_grad(): + loss, sample_size, logging_output = self._get_loss(sample, model, criterion) + return loss, sample_size, logging_output + + def inference_step( + self, + generator, + models, + sample, + prefix_tokens=None, + expert=None, + constraints=None, + ): + expert = expert or self.cfg.gen_expert + with torch.no_grad(): + return generator.generate( + models, + sample, + prefix_tokens=prefix_tokens, + constraints=constraints, + bos_token=self.expert_index(expert), + ) + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + metrics.log_scalar( + "posterior", + sum(log["posterior"] for log in logging_outputs if "posterior" in log), + ) diff --git a/fairseq/examples/truncated_bptt/README.md b/fairseq/examples/truncated_bptt/README.md new file mode 100644 index 0000000000000000000000000000000000000000..86518c9d5ef09fbd4fed1512a52e9431b74f08fa --- /dev/null +++ b/fairseq/examples/truncated_bptt/README.md @@ -0,0 +1,70 @@ +# Truncated Backpropagation Through Time (BPTT) + +Truncated BPTT is a useful technique for training language models on very long +sequences. Typically a long sequences is split into chunks and a language model +is trained over the chunks sequentially. The LM may condition on previous +chunks, but gradients only flow through the current chunk. This technique was +the basis for the paper: [Transformer-XL: Attentive Language Models Beyond a +Fixed-Length Context](https://arxiv.org/abs/1901.02860), which achieved +state-of-the-art language modeling results at the time of publication. + +It is slightly tricky to implement Truncated BPTT efficiently in fairseq, since +we need to iterate over the data sequentially and disable any batch shuffling +logic. The code provided in this example illustrates how to implement Truncated +BPTT in fairseq by overriding ``FairseqTask::get_batch_iterator`` to iterate +over the data sequentially. Crucially, this example supports batching and +multi-GPU (data parallel) training. + +##### 0. Setup + +First, see the general [language modeling README](README.md) for instructions on +preprocessing the WikiText-103 data. + +##### 1. Train a Transformer-XL model on WikiText-103 + +We will train a 16-layer Transformer-XL model following the [hyperparameters +used in the original +paper](https://github.com/kimiyoung/transformer-xl/blob/master/pytorch/run_wt103_base.sh). + +The following command assumes 4 GPUs, so that the total batch size is 60 +sequences (15 x 4). Training should take ~24 hours on 4 V100 GPUs: +```bash +CUDA_VISIBLE_DEVICES=0,1,2,3 fairseq-train \ + --user-dir examples/truncated_bptt \ + data-bin/wikitext-103/ \ + --task truncated_bptt_lm --tokens-per-sample 150 \ + --batch-size 15 --max-update 200000 \ + --arch transformer_xl --n-layer 16 --d-model 410 --n-head 10 \ + --d-head 41 --d-inner 2100 --dropout 0.1 --dropatt 0.0 --mem-len 150 \ + --optimizer adam --clip-norm 0.25 \ + --lr-scheduler cosine --warmup-updates 0 --min-lr 0.0 --lr 0.00025 \ + --log-format json --log-interval 25 \ + --fp16 +``` + +If training on a single GPU, set `--update-freq=4` to accumulate 4x gradients +and simulate training on 4 GPUs. + +##### 2. Evaluate + +```bash +fairseq-eval-lm data-bin/wikitext-103/ \ + --path checkpoints/checkpoint_best.pt \ + --user-dir examples/truncated_bptt/ \ + --task truncated_bptt_lm \ + --batch-size 1 --required-batch-size-multiple 1 \ + --model-overrides '{"mem_len":640,"clamp_len":400,"same_length":True}' \ + --tokens-per-sample 64 +# ... | INFO | fairseq_cli.eval_lm | num. model params: 151123537 +# ... | INFO | fairseq_cli.eval_lm | Evaluated 245569 tokens in 83.1s (2956.82 tokens/s) +# ... | INFO | fairseq_cli.eval_lm | Loss (base 2): 4.5668, Perplexity: 23.70 +# Compare to 24.0 test perplexity from the paper +``` + +*Note:* During training the model saw 150 tokens of context +(``--tokens-per-sample=150``) and 150 extra memory tokens (``--mem-len=150``). +During evaluation we measure perplexity on sequences of 64 tokens +(``--tokens-per-sample=64``) and increase the memory length +(``--model-overrides='{"mem_len":640}'``). These settings match the evaluation +settings from [the original +paper](https://github.com/kimiyoung/transformer-xl/blob/master/pytorch/run_wt103_base.sh). diff --git a/fairseq/examples/truncated_bptt/__init__.py b/fairseq/examples/truncated_bptt/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eee484d427a68828462469d133144a8d7c052c40 --- /dev/null +++ b/fairseq/examples/truncated_bptt/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import transformer_xl_model, truncated_bptt_lm_task # noqa diff --git a/fairseq/examples/truncated_bptt/transformer_xl_model.py b/fairseq/examples/truncated_bptt/transformer_xl_model.py new file mode 100644 index 0000000000000000000000000000000000000000..a6c8b25a07276c2ee30c0aa5f0e4b0a2837ed5ca --- /dev/null +++ b/fairseq/examples/truncated_bptt/transformer_xl_model.py @@ -0,0 +1,155 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from dataclasses import dataclass, field +from typing import Dict, List, Optional + +import torch +from fairseq.dataclass import FairseqDataclass +from fairseq.models import ( + FairseqIncrementalDecoder, + FairseqLanguageModel, + register_model, +) +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from omegaconf import II + + +logger = logging.getLogger(__name__) + + +@dataclass +class TransformerXLConfig(FairseqDataclass): + # defaults come from the original Transformer-XL code + cutoffs: List[int] = field(default_factory=lambda: [20000, 40000, 200000]) + d_model: int = 500 + n_head: int = 10 + d_head: int = 50 + d_inner: int = 1000 + div_val: int = 1 + n_layer: int = 12 + mem_len: int = 0 + clamp_len: int = -1 + same_length: bool = False + dropout: float = 0.0 + dropatt: float = 0.0 + checkpoint_activations: bool = False + offload_activations: bool = False + max_target_positions: int = II("task.max_target_positions") + + +@register_model("transformer_xl", dataclass=TransformerXLConfig) +class TransformerXLLanguageModel(FairseqLanguageModel): + @classmethod + def build_model(cls, cfg: TransformerXLConfig, task): + return cls(TransformerXLDecoder(cfg, task)) + + +class TransformerXLDecoder(FairseqIncrementalDecoder): + def __init__(self, cfg, task): + try: + from transformers.models.transfo_xl import ( + TransfoXLConfig, + TransfoXLLMHeadModel, + ) + except ImportError: + from transformers.configuration_transfo_xl import TransfoXLConfig + from transformers.modeling_transfo_xl import TransfoXLLMHeadModel + + super().__init__(task.target_dictionary) + self.cfg = cfg + + # remove any cutoffs larger than the vocab size + cutoffs = [ + cutoff for cutoff in cfg.cutoffs if cutoff < len(task.target_dictionary) + ] + + config = TransfoXLConfig( + vocab_size=len(task.target_dictionary), + cutoffs=cutoffs, + d_model=cfg.d_model, + d_embed=cfg.d_model, + n_head=cfg.n_head, + d_head=cfg.d_head, + d_inner=cfg.d_inner, + div_val=cfg.div_val, + n_layer=cfg.n_layer, + mem_len=cfg.mem_len, + clamp_len=cfg.clamp_len, + same_length=cfg.same_length, + dropout=cfg.dropout, + dropatt=cfg.dropatt, + ) + logger.info(config) + self.model = TransfoXLLMHeadModel(config) + + # Workaround a bug in huggingface's ``ProjectedAdaptiveLogSoftmax`` + # which adds ``None`` values to an ``nn.ParameterList``, which is not + # supported in PyTorch. Instead we can replace this with an + # ``nn.ModuleList``, which does support ``None`` values. + try: + if all(p is None for p in self.model.crit.out_projs._parameters.values()): + self.model.crit.out_projs = torch.nn.ModuleList( + [None] * len(self.model.crit.out_projs._parameters) + ) + except Exception: + pass + + if cfg.checkpoint_activations or cfg.offload_activations: + for i in range(len(self.model.transformer.layers)): + self.model.transformer.layers[i] = checkpoint_wrapper( + self.model.transformer.layers[i], + offload_to_cpu=cfg.offload_activations, + ) + # TODO: may save mem to wrap(layer.pos_ff.CoreNet[3]) + + self._mems = None + + def forward( + self, + src_tokens, + src_lengths=None, # unused + incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None, + encoder_out=None, + ): + if incremental_state is not None: # used during inference + mems = self.get_incremental_state(incremental_state, "mems") + src_tokens = src_tokens[:, -1:] # only keep the most recent token + else: + mems = self._mems + + output = self.model( + input_ids=src_tokens, + mems=mems, + return_dict=False, + ) + + if len(output) >= 2: + if incremental_state is not None: + self.set_incremental_state(incremental_state, "mems", output[1]) + else: + self._mems = output[1] + + return (output[0],) + + def max_positions(self): + return self.cfg.max_target_positions + + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[torch.Tensor]]], + new_order: torch.Tensor, + ): + """Reorder incremental state. + + This will be called when the order of the input has changed from the + previous time step. A typical use case is beam search, where the input + order changes between time steps based on the selection of beams. + """ + mems = self.get_incremental_state(incremental_state, "mems") + if mems is not None: + new_mems = [mems_i.index_select(1, new_order) for mems_i in mems] + self.set_incremental_state(incremental_state, "mems", new_mems) diff --git a/fairseq/examples/truncated_bptt/truncated_bptt_lm_task.py b/fairseq/examples/truncated_bptt/truncated_bptt_lm_task.py new file mode 100644 index 0000000000000000000000000000000000000000..02be0e7fb4213b98798c85b79e9046e9990b97fc --- /dev/null +++ b/fairseq/examples/truncated_bptt/truncated_bptt_lm_task.py @@ -0,0 +1,281 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +from dataclasses import dataclass, field +from typing import List, Optional, Tuple + +import torch +from fairseq import utils +from fairseq.data import ( + Dictionary, + TokenBlockDataset, + data_utils, + iterators, +) +from fairseq.dataclass import FairseqDataclass +from fairseq.distributed import utils as dist_utils +from fairseq.tasks import FairseqTask, register_task +from omegaconf import II + + +logger = logging.getLogger(__name__) + + +@dataclass +class TruncatedBPTTLMConfig(FairseqDataclass): + data: str = field(default="???", metadata={"help": "path to data directory"}) + tokens_per_sample: int = field( + default=1024, + metadata={"help": "max number of tokens per sequence"}, + ) + batch_size: int = II("dataset.batch_size") + # Some models use *max_target_positions* to know how many positional + # embeddings to learn. We use II(...) to make it default to + # *tokens_per_sample*, but in principle there could be more positional + # embeddings than tokens in a single batch. This may also be irrelevant for + # custom model implementations. + max_target_positions: int = II("task.tokens_per_sample") + # these will be populated automatically if not provided + data_parallel_rank: Optional[int] = None + data_parallel_size: Optional[int] = None + + +@register_task("truncated_bptt_lm", dataclass=TruncatedBPTTLMConfig) +class TruncatedBPTTLMTask(FairseqTask): + def __init__(self, cfg: TruncatedBPTTLMConfig): + super().__init__(cfg) + + if cfg.data_parallel_rank is None or cfg.data_parallel_size is None: + if torch.distributed.is_initialized(): + cfg.data_parallel_rank = dist_utils.get_data_parallel_rank() + cfg.data_parallel_size = dist_utils.get_data_parallel_world_size() + else: + cfg.data_parallel_rank = 0 + cfg.data_parallel_size = 1 + + # load the dictionary + paths = utils.split_paths(cfg.data) + assert len(paths) > 0 + self.dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(self.dictionary))) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split (e.g., train, valid, test)""" + + # support sharded datasets + paths = utils.split_paths(self.cfg.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + # each element of *data* will be a tensorized line from the original + # text dataset, similar to ``open(split_path).readlines()`` + data = data_utils.load_indexed_dataset( + split_path, self.dictionary, combine=combine + ) + if data is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + # this is similar to ``data.view(-1).split(tokens_per_sample)`` + data = TokenBlockDataset( + data, + data.sizes, + block_size=self.cfg.tokens_per_sample, + pad=None, # unused + eos=None, # unused + break_mode="none", + ) + + self.datasets[split] = TruncatedBPTTDataset( + data=data, + bsz_per_shard=self.cfg.batch_size, + shard_id=self.cfg.data_parallel_rank, + num_shards=self.cfg.data_parallel_size, + ) + + def dataset(self, split): + return self.datasets[split] + + def get_batch_iterator( + self, dataset, num_workers=0, epoch=1, data_buffer_size=0, **kwargs + ): + return iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=self._collate_fn, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size, + # we don't use the batching functionality from EpochBatchIterator; + # instead every item in *dataset* is a whole batch + batch_sampler=[[i] for i in range(len(dataset))], + disable_shuffling=True, + ) + + def _collate_fn(self, items: List[List[torch.Tensor]]): + # we don't use fairseq's batching functionality, so we expect a single + # Tensor of type List[torch.Tensor] + assert len(items) == 1 + + # item will have shape B x T (the last batch may have length < T) + id, item = items[0] + item = data_utils.collate_tokens(item, pad_idx=self.source_dictionary.pad()) + B, T = item.size() + + # shift item one position over and append a padding token for the target + target = torch.nn.functional.pad( + item[:, 1:], (0, 1, 0, 0), value=self.target_dictionary.pad() + ) + + # fairseq expects batches to have the following structure + return { + "id": torch.tensor([id]*item.size(0)), + "net_input": { + "src_tokens": item, + }, + "target": target, + "nsentences": item.size(0), + "ntokens": item.numel(), + } + + def build_dataset_for_inference( + self, src_tokens: List[torch.Tensor], src_lengths: List[int], **kwargs + ) -> torch.utils.data.Dataset: + eos = self.source_dictionary.eos() + dataset = TokenBlockDataset( + src_tokens, + src_lengths, + block_size=None, # ignored for "eos" break mode + pad=self.source_dictionary.pad(), + eos=eos, + break_mode="eos", + ) + + class Dataset(torch.utils.data.Dataset): + def __getitem__(self, i): + item = dataset[i] + if item[-1] == eos: + # remove eos to support generating with a prefix + item = item[:-1] + return (i, [item]) + + def __len__(self): + return len(dataset) + + return Dataset() + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + if constraints is not None: + raise NotImplementedError + + # SequenceGenerator doesn't use *src_tokens* directly, we need to + # pass the *prefix_tokens* argument instead. + if prefix_tokens is None and sample["net_input"]["src_tokens"].nelement(): + prefix_tokens = sample["net_input"]["src_tokens"] + + # begin generation with the end-of-sentence token + bos_token = self.source_dictionary.eos() + + return generator.generate( + models, sample, prefix_tokens=prefix_tokens, bos_token=bos_token + ) + + def eval_lm_dataloader( + self, + dataset, + max_tokens: Optional[int] = 36000, + batch_size: Optional[int] = None, + max_positions: Optional[int] = None, + num_shards: int = 1, + shard_id: int = 0, + num_workers: int = 1, + data_buffer_size: int = 10, + context_window: int = 0, + ): + if context_window > 0: + raise NotImplementedError( + "Transformer-XL doesn't need --context-window, try " + "--model-overrides '{\"mem_len\":42}' instead " + ) + return self.get_batch_iterator( + dataset=dataset, + max_tokens=max_tokens, + max_sentences=batch_size, + max_positions=max_positions, + ignore_invalid_inputs=True, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + data_buffer_size=data_buffer_size, + ).next_epoch_itr(shuffle=False) + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + +class TruncatedBPTTDataset(torch.utils.data.Dataset): + def __init__( + self, + data: List[torch.Tensor], # ordered list of items + bsz_per_shard, # number of items processed per GPUs per forward + shard_id, # current GPU ID + num_shards, # number of GPUs + ): + super().__init__() + self.data = data + + def batchify(data, bsz): + # Work out how cleanly we can divide the dataset into bsz parts. + nbatch = data.size(0) // bsz + # Trim off any extra elements that wouldn't cleanly fit (remainders). + data = data.narrow(0, 0, nbatch * bsz) + # Evenly divide the data across the bsz batches. + data = data.view(bsz, -1).contiguous() + return data + + # total number of sequences processed by all GPUs in each forward pass + global_batch_size = bsz_per_shard * num_shards + + """ + With a 16 item dataset, bsz_per_shard=2 and num_shards=3, + *indices* might look like: + + indices = [[0, 1], + [2, 3], + [4, 5], + [6, 7], + [8, 9], + [10, 11]] + + The size of the TruncatedBPTTDataset instance will be 2, + and shard 1 will see items: + + [(0, [data[4], data[6]]), + (1, [data[5], data[7]])] + """ + indices = batchify(torch.arange(len(data)), global_batch_size) + assert indices.size(0) == global_batch_size + + self.my_indices = indices[ + shard_id * bsz_per_shard : (shard_id + 1) * bsz_per_shard + ] + assert self.my_indices.size(0) == bsz_per_shard + + def __len__(self): + return self.my_indices.size(1) + + def __getitem__(self, i) -> Tuple[int, List[torch.Tensor]]: + return (i, [self.data[idx] for idx in self.my_indices[:, i]]) diff --git a/fairseq/examples/unsupervised_quality_estimation/README.md b/fairseq/examples/unsupervised_quality_estimation/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e86a0d13b883af0c37fdc2c1fee9b0b9dff4d18c --- /dev/null +++ b/fairseq/examples/unsupervised_quality_estimation/README.md @@ -0,0 +1,126 @@ +# Unsupervised Quality Estimation for Neural Machine Translation (Fomicheva et al., 2020) + +This page includes instructions for reproducing results from the paper [Unsupervised Quality Estimation for Neural +Machine Translation (Fomicheva et al., 2020)](https://arxiv.org/abs/2005.10608) + +## Requirements: + +* mosesdecoder: https://github.com/moses-smt/mosesdecoder +* subword-nmt: https://github.com/rsennrich/subword-nmt +* flores: https://github.com/facebookresearch/flores + +## Download Models and Test Data + +Download translation models and test data from [MLQE dataset repository](https://github.com/facebookresearch/mlqe). + +## Set up: + +Given a testset consisting of source sentences and reference translations: + +* `SRC_LANG`: source language +* `TGT_LANG`: target language +* `INPUT`: input prefix, such that the file `$INPUT.$SRC_LANG` contains source sentences and `$INPUT.$TGT_LANG` +contains the reference sentences +* `OUTPUT_DIR`: output path to store results +* `MOSES_DECODER`: path to mosesdecoder installation +* `BPE_ROOT`: path to subword-nmt installation +* `BPE`: path to BPE model +* `MODEL_DIR`: directory containing the NMT model `.pt` file as well as the source and target vocabularies. +* `TMP`: directory for intermediate temporary files +* `GPU`: if translating with GPU, id of the GPU to use for inference +* `DROPOUT_N`: number of stochastic forward passes + +`$DROPOUT_N` is set to 30 in the experiments reported in the paper. However, we observed that increasing it beyond 10 +does not bring substantial improvements. + +## Translate the data using standard decoding + +Preprocess the input data: +``` +for LANG in $SRC_LANG $TGT_LANG; do + perl $MOSES_DECODER/scripts/tokenizer/tokenizer.perl -threads 80 -a -l $LANG < $INPUT.$LANG > $TMP/preprocessed.tok.$LANG + python $BPE_ROOT/apply_bpe.py -c ${BPE} < $TMP/preprocessed.tok.$LANG > $TMP/preprocessed.tok.bpe.$LANG +done +``` + +Binarize the data for faster translation: + +``` +fairseq-preprocess --srcdict $MODEL_DIR/dict.$SRC_LANG.txt --tgtdict $MODEL_DIR/dict.$TGT_LANG.txt +--source-lang ${SRC_LANG} --target-lang ${TGT_LANG} --testpref $TMP/preprocessed.tok.bpe --destdir $TMP/bin --workers 4 +``` + +Translate + +``` +CUDA_VISIBLE_DEVICES=$GPU fairseq-generate $TMP/bin --path ${MODEL_DIR}/${SRC_LANG}-${TGT_LANG}.pt --beam 5 +--source-lang $SRC_LANG --target-lang $TGT_LANG --no-progress-bar --unkpen 5 > $TMP/fairseq.out +grep ^H $TMP/fairseq.out | cut -d- -f2- | sort -n | cut -f3- > $TMP/mt.out +``` + +Post-process + +``` +sed -r 's/(@@ )| (@@ ?$)//g' < $TMP/mt.out | perl $MOSES_DECODER/scripts/tokenizer/detokenizer.perl +-l $TGT_LANG > $OUTPUT_DIR/mt.out +``` + +## Produce uncertainty estimates + +### Scoring + +Make temporary files to store the translations repeated N times. + +``` +python ${SCRIPTS}/scripts/uncertainty/repeat_lines.py -i $TMP/preprocessed.tok.bpe.$SRC_LANG -n $DROPOUT_N +-o $TMP/repeated.$SRC_LANG +python ${SCRIPTS}/scripts/uncertainty/repeat_lines.py -i $TMP/mt.out -n $DROPOUT_N -o $TMP/repeated.$TGT_LANG + +fairseq-preprocess --srcdict ${MODEL_DIR}/dict.${SRC_LANG}.txt $TGT_DIC --source-lang ${SRC_LANG} +--target-lang ${TGT_LANG} --testpref ${TMP}/repeated --destdir ${TMP}/bin-repeated +``` + +Produce model scores for the generated translations using `--retain-dropout` option to apply dropout at inference time: + +``` +CUDA_VISIBLE_DEVICES=${GPU} fairseq-generate ${TMP}/bin-repeated --path ${MODEL_DIR}/${LP}.pt --beam 5 + --source-lang $SRC_LANG --target-lang $TGT_LANG --no-progress-bar --unkpen 5 --score-reference --retain-dropout + --retain-dropout-modules '["TransformerModel","TransformerEncoder","TransformerDecoder","TransformerEncoderLayer"]' + TransformerDecoderLayer --seed 46 > $TMP/dropout.scoring.out + +grep ^H $TMP/dropout.scoring.out | cut -d- -f2- | sort -n | cut -f2 > $TMP/dropout.scores + +``` + +Use `--retain-dropout-modules` to specify the modules. By default, dropout is applied in the same places +as for training. + +Compute the mean of the resulting output distribution: + +``` +python $SCRIPTS/scripts/uncertainty/aggregate_scores.py -i $TMP/dropout.scores -o $OUTPUT_DIR/dropout.scores.mean +-n $DROPOUT_N +``` + +### Generation + +Produce multiple translation hypotheses for the same source using `--retain-dropout` option: + +``` +CUDA_VISIBLE_DEVICES=${GPU} fairseq-generate ${TMP}/bin-repeated --path ${MODEL_DIR}/${LP}.pt + --beam 5 --source-lang $SRC_LANG --target-lang $TGT_LANG --no-progress-bar --retain-dropout + --unkpen 5 --retain-dropout-modules TransformerModel TransformerEncoder TransformerDecoder +TransformerEncoderLayer TransformerDecoderLayer --seed 46 > $TMP/dropout.generation.out + +grep ^H $TMP/dropout.generation.out | cut -d- -f2- | sort -n | cut -f3- > $TMP/dropout.hypotheses_ + +sed -r 's/(@@ )| (@@ ?$)//g' < $TMP/dropout.hypotheses_ | perl $MOSES_DECODER/scripts/tokenizer/detokenizer.perl +-l $TGT_LANG > $TMP/dropout.hypotheses +``` + +Compute similarity between multiple hypotheses corresponding to the same source sentence using Meteor +evaluation metric: +``` +python meteor.py -i $TMP/dropout.hypotheses -m <path_to_meteor_installation> -n $DROPOUT_N -o +$OUTPUT_DIR/dropout.gen.sim.meteor +``` diff --git a/fairseq/examples/unsupervised_quality_estimation/aggregate_scores.py b/fairseq/examples/unsupervised_quality_estimation/aggregate_scores.py new file mode 100644 index 0000000000000000000000000000000000000000..66d50d07ff2067b802b90a2aadd88df23153830a --- /dev/null +++ b/fairseq/examples/unsupervised_quality_estimation/aggregate_scores.py @@ -0,0 +1,41 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import sys + +import numpy as np + + +aggregate_funcs = { + "std": np.std, + "var": np.var, + "median": np.median, + "mean": np.mean, + "min": np.min, + "max": np.max, +} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("-i", "--input_file", required=True, type=str) + parser.add_argument("-n", "--repeat_times", required=True, type=int) + parser.add_argument("-o", "--output_file", required=False) + parser.add_argument("-f", "--func", required=False, default="mean") + args = parser.parse_args() + + stream = open(args.output_file, "w") if args.output_file else sys.stdout + + segment_scores = [] + for line in open(args.input_file): + segment_scores.append(float(line.strip())) + if len(segment_scores) == args.repeat_times: + stream.write("{}\n".format(aggregate_funcs[args.func](segment_scores))) + segment_scores = [] + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/unsupervised_quality_estimation/meteor.py b/fairseq/examples/unsupervised_quality_estimation/meteor.py new file mode 100644 index 0000000000000000000000000000000000000000..2ee0448cf1f167f6f3ecee56ad807922cffb0956 --- /dev/null +++ b/fairseq/examples/unsupervised_quality_estimation/meteor.py @@ -0,0 +1,109 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import math +import os +import subprocess +import sys +import tempfile +from collections import defaultdict +from itertools import combinations + + +def read_translations(path, n_repeats): + segment_counter = 0 + segment_translations = [] + translations = defaultdict(list) + for line in open(path): + segment_translations.append(" ".join(line.split())) + if len(segment_translations) == n_repeats: + translations[segment_counter] = segment_translations + segment_translations = [] + segment_counter += 1 + return translations + + +def generate_input(translations, n_repeats): + _, ref_path = tempfile.mkstemp() + _, mt_path = tempfile.mkstemp() + ref_fh = open(ref_path, "w") + mt_fh = open(mt_path, "w") + for segid in sorted(translations.keys()): + assert len(translations[segid]) == n_repeats + indexes = combinations(range(n_repeats), 2) + for idx1, idx2 in indexes: + mt_fh.write(translations[segid][idx1].strip() + "\n") + ref_fh.write(translations[segid][idx2].strip() + "\n") + sys.stderr.write("\nSaved translations to %s and %s" % (ref_path, mt_path)) + return ref_path, mt_path + + +def run_meteor(ref_path, mt_path, metric_path, lang="en"): + _, out_path = tempfile.mkstemp() + subprocess.call( + [ + "java", + "-Xmx2G", + "-jar", + metric_path, + mt_path, + ref_path, + "-p", + "0.5 0.2 0.6 0.75", # default parameters, only changed alpha to give equal weight to P and R + "-norm", + "-l", + lang, + ], + stdout=open(out_path, "w"), + ) + os.remove(ref_path) + os.remove(mt_path) + sys.stderr.write("\nSaved Meteor output to %s" % out_path) + return out_path + + +def read_output(meteor_output_path, n_repeats): + n_combinations = math.factorial(n_repeats) / ( + math.factorial(2) * math.factorial(n_repeats - 2) + ) + raw_scores = [] + average_scores = [] + for line in open(meteor_output_path): + if not line.startswith("Segment "): + continue + score = float(line.strip().split("\t")[1]) + raw_scores.append(score) + if len(raw_scores) == n_combinations: + average_scores.append(sum(raw_scores) / n_combinations) + raw_scores = [] + os.remove(meteor_output_path) + return average_scores + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("-i", "--infile") + parser.add_argument("-n", "--repeat_times", type=int) + parser.add_argument("-m", "--meteor") + parser.add_argument("-o", "--output") + args = parser.parse_args() + + translations = read_translations(args.infile, args.repeat_times) + sys.stderr.write("\nGenerating input for Meteor...") + ref_path, mt_path = generate_input(translations, args.repeat_times) + sys.stderr.write("\nRunning Meteor...") + out_path = run_meteor(ref_path, mt_path, args.meteor) + sys.stderr.write("\nReading output...") + scores = read_output(out_path, args.repeat_times) + sys.stderr.write("\nWriting results...") + with open(args.output, "w") as o: + for scr in scores: + o.write("{}\n".format(scr)) + o.close() + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/unsupervised_quality_estimation/repeat_lines.py b/fairseq/examples/unsupervised_quality_estimation/repeat_lines.py new file mode 100644 index 0000000000000000000000000000000000000000..5a04851a74624e9c8ebc259805b7aed6c638b0de --- /dev/null +++ b/fairseq/examples/unsupervised_quality_estimation/repeat_lines.py @@ -0,0 +1,28 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import sys + + +def _normalize_spaces(line): + return " ".join(line.split()) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("-i", "--input_file", required=True, type=str) + parser.add_argument("-n", "--repeat_times", required=True, type=int) + parser.add_argument("-o", "--output_file", required=False, type=str) + args = parser.parse_args() + stream = open(args.output_file, "w") if args.output_file else sys.stdout + + for line in open(args.input_file): + for _ in range(args.repeat_times): + stream.write(_normalize_spaces(line) + "\n") + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/README.md b/fairseq/examples/wav2vec/README.md new file mode 100644 index 0000000000000000000000000000000000000000..253c8af2516580bbc33e8ecc8efe4f7a526d7142 --- /dev/null +++ b/fairseq/examples/wav2vec/README.md @@ -0,0 +1,376 @@ +# wav2vec 2.0 + +wav2vec 2.0 learns speech representations on unlabeled data as described in [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations (Baevski et al., 2020)](https://arxiv.org/abs/2006.11477). + +We learned speech representations in multiple languages as well in [Unsupervised Cross-lingual Representation Learning for Speech Recognition (Conneau et al., 2020)](https://arxiv.org/abs/2006.13979). + +We also combined wav2vec 2.0 with self-training in [Self-training and Pre-training are Complementary for Speech Recognition (Xu et al., 2020)](https://arxiv.org/abs/2010.11430). + +We combined speech data from multiple domains in [Robust wav2vec 2.0: Analyzing Domain Shift in Self-Supervised Pre-Training (Hsu, et al., 2021)](https://arxiv.org/abs/2104.01027) + +## Pre-trained models + +Model | Finetuning split | Dataset | Model +|---|---|---|--- +Wav2Vec 2.0 Base | No finetuning | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_small.pt) +Wav2Vec 2.0 Base | 10 minutes | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_small_10m.pt) +Wav2Vec 2.0 Base | 100 hours | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_small_100h.pt) +Wav2Vec 2.0 Base | 960 hours | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_small_960h.pt) +Wav2Vec 2.0 Large | No finetuning | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/libri960_big.pt) +Wav2Vec 2.0 Large | 10 minutes | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_big_10m.pt) +Wav2Vec 2.0 Large | 100 hours | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_big_100h.pt) +Wav2Vec 2.0 Large | 960 hours | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_big_960h.pt) +Wav2Vec 2.0 Large (LV-60)* | No finetuning | [Libri-Light](https://github.com/facebookresearch/libri-light) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_new.pt) +Wav2Vec 2.0 Large (LV-60)* | 10 minutes | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_10m_new.pt) +Wav2Vec 2.0 Large (LV-60)* | 100 hours | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_100h_new.pt) +Wav2Vec 2.0 Large (LV-60)* | 960 hours | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec2_vox_960h_new.pt) +Wav2Vec 2.0 Large (LV-60) + Self Training * | 10 minutes | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_10m_pl.pt) +Wav2Vec 2.0 Large (LV-60) + Self Training * | 100 hours | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_100h_pl.pt) +Wav2Vec 2.0 Large (LV-60) + Self Training * | 960 hours | [Libri-Light](https://github.com/facebookresearch/libri-light) + [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_vox_960h_pl.pt) +Wav2Vec 2.0 Large (LV-60 + CV + SWBD + FSH) ** | No finetuning | [Libri-Light](https://github.com/facebookresearch/libri-light) + [CommonVoice](https://commonvoice.mozilla.org/en/languages) + [Switchboard](https://catalog.ldc.upenn.edu/LDC97S62) + [Fisher](https://catalog.ldc.upenn.edu/LDC2004T19) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/w2v_large_lv_fsh_swbd_cv.pt) +Wav2Vec 2.0 Large (LV-60 + CV + SWBD + FSH) ** | 960 hours Librispeech | [Libri-Light](https://github.com/facebookresearch/libri-light) + [CommonVoice](https://commonvoice.mozilla.org/en/languages) + [Switchboard](https://catalog.ldc.upenn.edu/LDC97S62) + [Fisher](https://catalog.ldc.upenn.edu/LDC2004T19) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/w2v_large_lv_fsh_swbd_cv_ftls960.pt) +Wav2Vec 2.0 Large (LV-60 + CV + SWBD + FSH) ** | 300 hours Switchboard | [Libri-Light](https://github.com/facebookresearch/libri-light) + [CommonVoice](https://commonvoice.mozilla.org/en/languages) + [Switchboard](https://catalog.ldc.upenn.edu/LDC97S62) + [Fisher](https://catalog.ldc.upenn.edu/LDC2004T19) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/w2v_large_lv_fsh_swbd_cv_ftsb300.pt) + +\* updated (Oct. 24, 2020)\ +** updated (Jul. 8, 2021) + +We also release multilingual pre-trained wav2vec 2.0 (XLSR) models: + +Model | Architecture | Hours | Languages | Datasets | Model +|---|---|---|---|---|--- +XLSR-53 | Large | 56k | 53 | MLS, CommonVoice, BABEL | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/xlsr_53_56k.pt) + +The XLSR model uses the following datasets for multilingual pretraining: + +* **[MLS: Multilingual LibriSpeech](https://indico2.conference4me.psnc.pl/event/35/contributions/3585/attachments/1060/1101/Wed-2-6-10.pdf)** (8 languages, 50.7k hours): *Dutch, English, French, German, Italian, Polish, Portuguese, Spanish* + +* **[CommonVoice](https://commonvoice.mozilla.org/en/languages)** (36 languages, 3.6k hours): *Arabic, Basque, Breton, Chinese (CN), Chinese (HK), Chinese (TW), Chuvash, Dhivehi, Dutch, English, Esperanto, Estonian, French, German, Hakh-Chin, Indonesian, Interlingua, Irish, Italian, Japanese, Kabyle, Kinyarwanda, Kyrgyz, Latvian, Mongolian, Persian, Portuguese, Russian, Sakha, Slovenian, Spanish, Swedish, Tamil, Tatar, Turkish, Welsh* (see also [finetuning splits]([https://dl.fbaipublicfiles.com/cpc_audio/common_voices_splits.tar.gz]) from [this paper](https://arxiv.org/abs/2002.02848)). + +* **[Babel](https://catalog.ldc.upenn.edu/byyear)** (17 languages, 1.7k hours): *Assamese, Bengali, Cantonese, Cebuano, Georgian, Haitian, Kazakh, Kurmanji, Lao, Pashto, Swahili, Tagalog, Tamil, Tok, Turkish, Vietnamese, Zulu* + + +## Training a new model with the CLI tools + +Given a directory containing wav files to be used for pretraining (we recommend splitting each file into separate file 10 to 30 seconds in length) + +### Prepare training data manifest: + +First, install the `soundfile` library: +```shell script +pip install soundfile +``` + +Next, run: + +```shell script +$ python examples/wav2vec/wav2vec_manifest.py /path/to/waves --dest /manifest/path --ext $ext --valid-percent $valid +``` + +$ext should be set to flac, wav, or whatever format your dataset happens to use that soundfile can read. + +$valid should be set to some reasonable percentage (like 0.01) of training data to use for validation. +To use a pre-defined validation set (like dev-other from librispeech), set to it 0 and then overwrite valid.tsv with a +separately pre-processed manifest file. + +### Train a wav2vec 2.0 base model: + +This configuration was used for the base model trained on the Librispeech dataset in the wav2vec 2.0 paper + +Note that the input is expected to be single channel, sampled at 16 kHz + +```shell script +$ fairseq-hydra-train \ + task.data=/path/to/data \ + --config-dir /path/to/fairseq-py/examples/wav2vec/config/pretraining \ + --config-name wav2vec2_base_librispeech +``` + +Note: you can simulate 64 GPUs by using k GPUs and adding command line parameters (before `--config-dir`) +`distributed_training.distributed_world_size=k` `+optimization.update_freq='[x]'` where x = 64/k + +### Train a wav2vec 2.0 large model: + +This configuration was used for the large model trained on the Libri-light dataset in the wav2vec 2.0 paper + +```shell script +$ fairseq-hydra-train \ + task.data=/path/to/data \ + --config-dir /path/to/fairseq-py/examples/wav2vec/config/pretraining \ + --config-name wav2vec2_large_librivox +``` + +Note: you can simulate 128 GPUs by using k GPUs and adding command line parameters (before `--config-dir`) +`distributed_training.distributed_world_size=k` `+optimization.update_freq='[x]'` where x = 128/k + +### Fine-tune a pre-trained model with CTC: + +Fine-tuning a model requires parallel audio and labels file, as well as a vocabulary file in fairseq format. +A letter vocabulary can be downloaded [here](https://dl.fbaipublicfiles.com/fairseq/wav2vec/dict.ltr.txt). +An example [script](libri_labels.py) that generates labels for the Librispeech dataset from the tsv file produced by wav2vec_manifest.py can be used as follows: + +```shell script +split=train +$ python libri_labels.py /path/to/tsv --output-dir /output/dir --output-name $split +``` + +Fine-tuning on 100h of Librispeech with letter targets: +```shell script +$ fairseq-hydra-train \ + distributed_training.distributed_port=$PORT \ + task.data=/path/to/data \ + model.w2v_path=/path/to/model.pt \ + --config-dir /path/to/fairseq-py/examples/wav2vec/config/finetuning \ + --config-name base_100h +``` + +There are other config files in the config/finetuning directory that can be used to fine-tune on other splits. +You can specify the right config via the `--config-name` parameter. + +Note: you can simulate 24 GPUs by using k GPUs and adding command line parameters (before `--config-dir`) +`distributed_training.distributed_world_size=k` `+optimization.update_freq='[x]'` where x = 24/k + +Decoding with a language model during training requires flashlight [python bindings](https://github.com/facebookresearch/flashlight/tree/master/bindings/python) (previously called [wav2letter](https://github.com/facebookresearch/wav2letter). +If you want to use a language model, add `+criterion.wer_args='[/path/to/kenlm, /path/to/lexicon, 2, -1]'` to the command line. + +### Evaluating a CTC model: + +Evaluating a CTC model with a language model requires [flashlight python bindings](https://github.com/facebookresearch/flashlight/tree/master/bindings/python) (previously called [wav2letter](https://github.com/facebookresearch/wav2letter) to be installed. + +Fairseq transformer language model used in the wav2vec 2.0 paper can be obtained from the [wav2letter model repository](https://github.com/facebookresearch/wav2letter/tree/master/recipes/sota/2019). +Be sure to upper-case the language model vocab after downloading it. + +Letter dictionary for pre-trained models can be found [here](https://dl.fbaipublicfiles.com/fairseq/wav2vec/dict.ltr.txt). + +Next, run the evaluation command: + +```shell script +$subset=dev_other +python examples/speech_recognition/infer.py /checkpoint/abaevski/data/speech/libri/10h/wav2vec/raw --task audio_finetuning \ +--nbest 1 --path /path/to/model --gen-subset $subset --results-path /path/to/save/results/for/sclite --w2l-decoder kenlm \ +--lm-model /path/to/kenlm.bin --lm-weight 2 --word-score -1 --sil-weight 0 --criterion ctc --labels ltr --max-tokens 4000000 \ +--post-process letter +``` + +To get raw numbers, use --w2l-decoder viterbi and omit the lexicon. To use the transformer language model, use --w2l-decoder fairseqlm. + +## Use wav2vec 2.0 with 🤗Transformers: + +Wav2Vec2 is also available in the [🤗Transformers library](https://github.com/huggingface/transformers) since version 4.4. + +Pretrained Models can be found on the [hub](https://huggingface.co/models?filter=wav2vec2) +and documentation can be found [here](https://huggingface.co/transformers/master/model_doc/wav2vec2.html). + +Usage example: + +```python +# !pip install transformers +# !pip install datasets +import soundfile as sf +import torch +from datasets import load_dataset +from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor + +# load pretrained model +processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-base-960h") +model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h") + + +librispeech_samples_ds = load_dataset("patrickvonplaten/librispeech_asr_dummy", "clean", split="validation") + +# load audio +audio_input, sample_rate = sf.read(librispeech_samples_ds[0]["file"]) + +# pad input values and return pt tensor +input_values = processor(audio_input, sampling_rate=sample_rate, return_tensors="pt").input_values + +# INFERENCE + +# retrieve logits & take argmax +logits = model(input_values).logits +predicted_ids = torch.argmax(logits, dim=-1) + +# transcribe +transcription = processor.decode(predicted_ids[0]) + +# FINE-TUNE + +target_transcription = "A MAN SAID TO THE UNIVERSE I EXIST" + +# encode labels +with processor.as_target_processor(): + labels = processor(target_transcription, return_tensors="pt").input_ids + +# compute loss by passing labels +loss = model(input_values, labels=labels).loss +loss.backward() +``` + +# wav2vec + +Example to train a wav2vec model as described in [wav2vec: Unsupervised Pre-training for Speech Recognition (Schneider et al., 2019)](https://arxiv.org/abs/1904.05862). + +## Pre-trained models + +Description | Dataset | Model +---|---|--- +Wav2Vec large | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/wav2vec_large.pt) + +#### Example usage: +```python +import torch +import fairseq + +cp_path = '/path/to/wav2vec.pt' +model, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([cp_path]) +model = model[0] +model.eval() + +wav_input_16khz = torch.randn(1,10000) +z = model.feature_extractor(wav_input_16khz) +c = model.feature_aggregator(z) +``` + +## Training a new model with the CLI tools + +Given a directory containing wav files to be used for pretraining (we recommend splitting each file into separate files 10 to 30 seconds in length) + +### Prepare training data manifest: + +``` +$ python examples/wav2vec/wav2vec_manifest.py /path/to/waves --dest /manifest/path --ext wav +``` + +### Train a wav2vec model: + +``` +$ python train.py /manifest/path --save-dir /model/path --num-workers 6 --fp16 --max-update 400000 --save-interval 1 --no-epoch-checkpoints \ +--arch wav2vec --task audio_pretraining --min-lr 1e-06 --stop-min-lr 1e-09 --optimizer adam --lr 0.005 --lr-scheduler cosine \ +--conv-feature-layers [(512, 10, 5), (512, 8, 4), (512, 4, 2), (512, 4, 2), (512, 4, 2), (512, 1, 1), (512, 1, 1)] \ +--conv-aggregator-layers [(512, 2, 1), (512, 3, 1), (512, 4, 1), (512, 5, 1), (512, 6, 1), (512, 7, 1), (512, 8, 1), (512, 9, 1), (512, 10, 1), (512, 11, 1), (512, 12, 1), (512, 13, 1)] \ +--skip-connections-agg --residual-scale 0.5 --log-compression --warmup-updates 500 --warmup-init-lr 1e-07 --criterion wav2vec --num-negatives 10 \ +--max-sample-size 150000 --max-tokens 1500000 --skip-invalid-size-inputs-valid-test +``` + +### Run wav2vec2 pre-training on Google Cloud TPUs: + +Wav2Vec2 is now supported on TPUs! It's currently pre-training only. + +#### Using hydra on a v3-8: + +``` +$ OMP_NUM_THREADS=1 fairseq-hydra-train \ + task.data=/manifest/path \ + --config-dir /PATH/TO/FAIRSEQ/examples/wav2vec/config/pretraining \ + --config-name wav2vec2_large_librivox_tpu.yaml +``` + +#### Using command line arguments on a v3-8: +Note: Commandline arguments way of execution has a [known-problem](https://github.com/pytorch/fairseq/issues/3741) currently. + +``` +$ OMP_NUM_THREADS=1 python train.py /manifest/path --save-dir /model/path --num-workers 6 --fp16 --max-update 400000 --save-interval 1 --no-epoch-checkpoints \ +--arch wav2vec2 --task audio_pretraining --min-lr 1e-06 --stop-min-lr 1e-09 --optimizer adam --lr 0.005 --lr-scheduler cosine \ +--conv-feature-layers [(512, 10, 5), (512, 8, 4), (512, 4, 2), (512, 4, 2), (512, 4, 2), (512, 1, 1), (512, 1, 1)] \ +--conv-aggregator-layers [(512, 2, 1), (512, 3, 1), (512, 4, 1), (512, 5, 1), (512, 6, 1), (512, 7, 1), (512, 8, 1), (512, 9, 1), (512, 10, 1), (512, 11, 1), (512, 12, 1), (512, 13, 1)] \ +--skip-connections-agg --residual-scale 0.5 --log-compression --warmup-updates 500 --warmup-init-lr 1e-07 --criterion wav2vec --num-negatives 10 \ +--max-sample-size 150000 --max-tokens 1500000 --skip-invalid-size-inputs-valid-test \ +--tpu --distributed-world-size 8 --num-batch-buckets 3 --enable-padding \ +--encoder-layerdrop 0 --mask-channel-prob 0.1 +``` + +#### Using hydra on a pod slice (v3-N with N > 8): + +``` +$ OMP_NUM_THREADS=1 fairseq-hydra-train \ + task.data=/manifest/path \ + --config-dir /PATH/TO/FAIRSEQ/examples/wav2vec/config/pretraining \ + --config-name wav2vec2_large_librivox_tpu-pod.yaml # edit distributed-world-size accordingly +``` + +#### Using command line arguments on a pod slice (v3-N with N > 8): +Note: Commandline arguments way of execution has a [known-problem](https://github.com/pytorch/fairseq/issues/3741) currently. + +``` +$ python -m torch_xla.distributed.xla_dist \ + --tpu ${TPUNAME} --conda-env=torch-xla-${TORCH_XLA_VERSION} --env OMP_NUM_THREADS=1 \ + -- \ +python train.py /manifest/path --save-dir /model/path --num-workers 6 --fp16 --max-update 400000 --save-interval 1 --no-epoch-checkpoints \ +--arch wav2vec2 --task audio_pretraining --min-lr 1e-06 --stop-min-lr 1e-09 --optimizer adam --lr 0.005 --lr-scheduler cosine \ +--conv-feature-layers [(512, 10, 5), (512, 8, 4), (512, 4, 2), (512, 4, 2), (512, 4, 2), (512, 1, 1), (512, 1, 1)] \ +--conv-aggregator-layers [(512, 2, 1), (512, 3, 1), (512, 4, 1), (512, 5, 1), (512, 6, 1), (512, 7, 1), (512, 8, 1), (512, 9, 1), (512, 10, 1), (512, 11, 1), (512, 12, 1), (512, 13, 1)] \ +--skip-connections-agg --residual-scale 0.5 --log-compression --warmup-updates 500 --warmup-init-lr 1e-07 --criterion wav2vec --num-negatives 10 \ +--max-sample-size 150000 --max-tokens 1500000 --skip-invalid-size-inputs-valid-test \ +--tpu --distributed-world-size ${WORLD_SIZE} --num-batch-buckets 3 --enable-padding \ +--encoder-layerdrop 0 --mask-channel-prob 0.1 +``` + +### Extract embeddings from the downstream task data: + +``` +$ PYTHONPATH=/path/to/fairseq python examples/wav2vec/wav2vec_featurize.py --input /path/to/task/waves --output /path/to/output \ +--model /model/path/checkpoint_best.pt --split train valid test +``` + +# vq-wav2vec + +Example to train a vq-wav2vec model as described in [vq-wav2vec: Self-Supervised Learning of Discrete Speech Representations (Baevski et al., 2019)](https://arxiv.org/abs/1910.05453). + +These models are also used in [Effectiveness of self-supervised pre-training for speech recognition (Baevski et al., 2019)](https://arxiv.org/abs/1911.03912). + +## Pre-trained models + +Description | Dataset | Model +---|---|--- +vq-wav2vec Gumbel | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/vq-wav2vec.pt) +vq-wav2vec K-means | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/vq-wav2vec_kmeans.pt) +Roberta on K-means codes | [Librispeech](http://www.openslr.org/12) | [download](https://dl.fbaipublicfiles.com/fairseq/wav2vec/bert_kmeans.tar) + +#### Example usage: +```python +import torch +import fairseq + +cp = torch.load('/path/to/vq-wav2vec.pt') +model, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([cp]) +model = model[0] +model.eval() + +wav_input_16khz = torch.randn(1,10000) +z = model.feature_extractor(wav_input_16khz) +_, idxs = model.vector_quantizer.forward_idx(z) +print(idxs.shape) # output: torch.Size([1, 60, 2]), 60 timesteps with 2 indexes corresponding to 2 groups in the model +``` + +## Training a new model with the CLI tools + +Given a directory containing wav files to be used for pretraining (we recommend splitting each file into separate file 10 to 30 seconds in length) + +### Prepare training data manifest: + +``` +$ python examples/wav2vec/wav2vec_manifest.py /path/to/waves --dest /manifest/path --ext wav +``` + +### Train a gumbel vq-wav2vec model: + +``` +$ python train.py /manifest/path --save-dir /model/path --num-workers 6 --fp16 --max-update 400000 \ +--save-interval 1 --no-epoch-checkpoints --arch wav2vec --task audio_pretraining --min-lr 1e-06 --stop-min-lr 1e-09 \ +--optimizer adam --lr 1e-05 --lr-scheduler cosine \ +--conv-feature-layers [(512, 10, 5), (512, 8, 4), (512, 4, 2), (512, 4, 2), (512, 4, 2), (512, 1, 1), (512, 1, 1), (512, 1, 1)] \ +--conv-aggregator-layers [(512, 2, 1), (512, 3, 1), (512, 4, 1), (512, 5, 1), (512, 6, 1), (512, 7, 1), (512, 8, 1), (512, 9, 1), (512, 10, 1), (512, 11, 1), (512, 12, 1), (512, 13, 1)] \ +--activation gelu --offset auto --skip-connections-agg --residual-scale 0.5 \ +--log-keys ["prob_perplexity","code_perplexity","temp"] --vq-type gumbel --vq-groups 2 --vq-depth 2 \ +--combine-groups --vq-vars 320 --vq-temp (2,0.5,0.999995) --prediction-steps 12 --warmup-updates 1000 \ +--warmup-init-lr 1e-07 --criterion wav2vec --num-negatives 10 --max-sample-size 150000 \ +--max-tokens 300000 --cross-sample-negatives 0 --update-freq 1 --seed 2 --skip-invalid-size-inputs-valid-test +``` + +for k-means training, set vq-type with "kmeans" and add --loss-weights [1] argument. Pre-trained models were trained on 16 GPUs. + +### Tokenize audio data (e.g. for BERT training): + +``` +$ PYTHONPATH=/path/to/fairseq python examples/wav2vec/vq-wav2vec_featurize.py --data-dir /manifest/path --output-dir /path/to/output \ +--checkpoint /model/path/checkpoint_best.pt --split train valid test --extension tsv +``` diff --git a/fairseq/examples/wav2vec/__init__.py b/fairseq/examples/wav2vec/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/wav2vec/config/finetuning/base_100h.yaml b/fairseq/examples/wav2vec/config/finetuning/base_100h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..153b5df1708f187933a68ff55009652a107c69eb --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/base_100h.yaml @@ -0,0 +1,58 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: false + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 3200000 + skip_invalid_size_inputs_valid_test: true + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 2 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 80000 + lr: [0.00003] + sentence_avg: true + update_freq: [4] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.65 + mask_channel_prob: 0.5 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 0 diff --git a/fairseq/examples/wav2vec/config/finetuning/base_10h.yaml b/fairseq/examples/wav2vec/config/finetuning/base_10h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5044518025aadf73b3f5f204a74969cf3f982f03 --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/base_10h.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 50 + save_interval_updates: 10000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: false + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 3200000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 50 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 2 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 20000 + lr: [0.00005] + sentence_avg: true + update_freq: [4] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.65 + mask_channel_prob: 0.5 + mask_channel_length: 64 + layerdrop: 0.05 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/base_10m.yaml b/fairseq/examples/wav2vec/config/finetuning/base_10m.yaml new file mode 100644 index 0000000000000000000000000000000000000000..14abc013bd1862bc0ec3df7e2603924ab9fe671a --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/base_10m.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 1000 + save_interval_updates: 50 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: false + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 3200000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 1000 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 2 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 13000 + lr: [0.00005] + sentence_avg: true + update_freq: [4] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.65 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/base_1h.yaml b/fairseq/examples/wav2vec/config/finetuning/base_1h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..14abc013bd1862bc0ec3df7e2603924ab9fe671a --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/base_1h.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 1000 + save_interval_updates: 50 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: false + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 3200000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 1000 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 2 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 13000 + lr: [0.00005] + sentence_avg: true + update_freq: [4] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.65 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/base_960h.yaml b/fairseq/examples/wav2vec/config/finetuning/base_960h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3eadc36b37b5caa7c0f0838e4e9ff2d401110429 --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/base_960h.yaml @@ -0,0 +1,57 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: false + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 3200000 + skip_invalid_size_inputs_valid_test: true + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 8 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 320000 + lr: [0.0001] + sentence_avg: true + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.5 + mask_channel_prob: 0.1 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 0 diff --git a/fairseq/examples/wav2vec/config/finetuning/vox_100h.yaml b/fairseq/examples/wav2vec/config/finetuning/vox_100h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b8f81e5e1895e448c6126f9ccd6d9c4a5fb36b18 --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/vox_100h.yaml @@ -0,0 +1,58 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 1280000 + skip_invalid_size_inputs_valid_test: true + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 4 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 80000 + lr: [0.00003] + sentence_avg: true + update_freq: [5] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.5 + mask_channel_prob: 0.5 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/vox_10h.yaml b/fairseq/examples/wav2vec/config/finetuning/vox_10h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8f1ca71ee2bd195934f85010e141772479769f0b --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/vox_10h.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 50 + save_interval_updates: 10000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 1280000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 50 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 4 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 20000 + lr: [0.0001] + sentence_avg: true + update_freq: [5] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.75 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/vox_10m.yaml b/fairseq/examples/wav2vec/config/finetuning/vox_10m.yaml new file mode 100644 index 0000000000000000000000000000000000000000..07e327fe7477c88545d7744a5928d2fe703dd6de --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/vox_10m.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 1000 + save_interval_updates: 50 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 1280000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 1000 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 4 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 13000 + lr: [0.0001] + sentence_avg: true + update_freq: [5] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.65 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/vox_1h.yaml b/fairseq/examples/wav2vec/config/finetuning/vox_1h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..fac1bbb32fa98364568dd1af0f6fb703906e0606 --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/vox_1h.yaml @@ -0,0 +1,63 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval: 1000 + save_interval_updates: 50 + keep_interval_updates: 1 + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 1280000 + skip_invalid_size_inputs_valid_test: true + validate_after_updates: 10000 + validate_interval: 1000 + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 4 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 13000 + lr: [0.0003] + sentence_avg: true + update_freq: [5] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.75 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/finetuning/vox_960h.yaml b/fairseq/examples/wav2vec/config/finetuning/vox_960h.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9d72404fa3b72624ed00556deced2513dff075d8 --- /dev/null +++ b/fairseq/examples/wav2vec/config/finetuning/vox_960h.yaml @@ -0,0 +1,57 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + no_epoch_checkpoints: true + best_checkpoint_metric: wer + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 1280000 + skip_invalid_size_inputs_valid_test: true + valid_subset: dev_other + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 24 + +criterion: + _name: ctc + zero_infinity: true + +optimization: + max_update: 320000 + lr: [0.00003] + sentence_avg: true + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.5 + mask_channel_prob: 0.25 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 10000 diff --git a/fairseq/examples/wav2vec/config/pretraining/wav2vec2_base_librispeech.yaml b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_base_librispeech.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b686e21ab1d367158fe7afa4197303a4ee74df66 --- /dev/null +++ b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_base_librispeech.yaml @@ -0,0 +1,57 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + +task: + _name: audio_pretraining + data: ??? + max_sample_size: 250000 + min_sample_size: 32000 + normalize: false + +dataset: + num_workers: 6 + max_tokens: 1400000 + skip_invalid_size_inputs_valid_test: true + +distributed_training: + distributed_world_size: 64 + ddp_backend: legacy_ddp + +criterion: + _name: wav2vec + infonce: true + log_keys: ["prob_perplexity","code_perplexity","temp"] + loss_weights: [0.1, 10] + +optimization: + max_update: 400000 + lr: [0.0005] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: wav2vec2 + quantize_targets: true + final_dim: 256 + encoder_layerdrop: 0.05 + dropout_input: 0.1 + dropout_features: 0.1 + feature_grad_mult: 0.1 + encoder_embed_dim: 768 diff --git a/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox.yaml b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3192ce4cba42d1741099d27aad8588a45a59814c --- /dev/null +++ b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox.yaml @@ -0,0 +1,70 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + +task: + _name: audio_pretraining + data: ??? + max_sample_size: 320000 + min_sample_size: 32000 + normalize: true + +dataset: + batch_size: 4 + num_workers: 6 + max_tokens: 1200000 + skip_invalid_size_inputs_valid_test: true + +distributed_training: + distributed_world_size: 128 + ddp_backend: legacy_ddp + +criterion: + _name: wav2vec + infonce: true + log_keys: ["prob_perplexity","code_perplexity","temp"] + loss_weights: [0.1, 0] + +optimization: + max_update: 1000000 + lr: [0.005] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: wav2vec2 + quantize_targets: true + extractor_mode: layer_norm + layer_norm_first: true + final_dim: 768 + latent_temp: [2.0,0.1,0.999995] + encoder_layerdrop: 0.00 + dropout_input: 0.0 + dropout_features: 0.0 + dropout: 0.0 + attention_dropout: 0.0 + conv_bias: true + + encoder_layers: 24 + encoder_embed_dim: 1024 + encoder_ffn_embed_dim: 4096 + encoder_attention_heads: 16 + + feature_grad_mult: 1.0 + diff --git a/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu-pod.yaml b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu-pod.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ff35a95b6596b74215ef1bbdd2ec8d462d1d8542 --- /dev/null +++ b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu-pod.yaml @@ -0,0 +1,72 @@ +# @package _group_ + +common: + tpu: true + fp16: false + log_format: json + log_interval: 10 + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + +task: + _name: audio_pretraining + data: ??? + max_sample_size: 250000 + min_sample_size: 32000 + normalize: true + num_batch_buckets: 3 + precompute_mask_indices: true + enable_padding: true + +dataset: + num_workers: 6 + max_tokens: 1200000 + skip_invalid_size_inputs_valid_test: true + +distributed_training: + distributed_world_size: 128 + ddp_backend: legacy_ddp + +criterion: + _name: wav2vec + infonce: true + log_keys: ["prob_perplexity","code_perplexity","temp"] + loss_weights: [0.1, 0] + +optimization: + max_update: 1000000 + lr: [0.005] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: wav2vec2 + quantize_targets: true + extractor_mode: layer_norm + layer_norm_first: true + final_dim: 768 + latent_temp: [2.0,0.1,0.999995] + encoder_layerdrop: 0.00 + dropout_input: 0.0 + dropout_features: 0.0 + dropout: 0.0 + attention_dropout: 0.0 + conv_bias: true + + encoder_layers: 24 + encoder_embed_dim: 1024 + encoder_ffn_embed_dim: 4096 + encoder_attention_heads: 16 + + feature_grad_mult: 1.0 diff --git a/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu.yaml b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ee55bdab72e40c2f410cde592e3cfe5ff7f06e0c --- /dev/null +++ b/fairseq/examples/wav2vec/config/pretraining/wav2vec2_large_librivox_tpu.yaml @@ -0,0 +1,77 @@ +# @package _group_ + +common: + tpu: true + fp16: false + log_format: json + log_interval: 10 + +checkpoint: + save_interval_updates: 25000 + keep_interval_updates: 1 + no_epoch_checkpoints: true + +task: + _name: audio_pretraining + data: ??? + max_sample_size: 250000 + min_sample_size: 32000 + normalize: true + num_batch_buckets: 3 + precompute_mask_indices: true + enable_padding: true + inferred_w2v_config: + mask_prob: 0.65 + mask_selection: 'static' + mask_other: 0 + mask_channel_prob: 0.1 + +dataset: + num_workers: 6 + max_tokens: 1200000 + skip_invalid_size_inputs_valid_test: true + +distributed_training: + distributed_world_size: 8 + ddp_backend: legacy_ddp + +criterion: + _name: wav2vec + infonce: true + log_keys: ["prob_perplexity","code_perplexity","temp"] + loss_weights: [0.1, 0] + +optimization: + max_update: 1000000 + lr: [0.005] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-06 + weight_decay: 0.01 + +lr_scheduler: + _name: polynomial_decay + warmup_updates: 32000 + +model: + _name: wav2vec2 + quantize_targets: true + extractor_mode: layer_norm + layer_norm_first: true + final_dim: 768 + latent_temp: [2.0,0.1,0.999995] + encoder_layerdrop: 0.00 + dropout_input: 0.0 + dropout_features: 0.0 + dropout: 0.0 + attention_dropout: 0.0 + conv_bias: true + + encoder_layers: 24 + encoder_embed_dim: 1024 + encoder_ffn_embed_dim: 4096 + encoder_attention_heads: 16 + + feature_grad_mult: 1.0 diff --git a/fairseq/examples/wav2vec/libri_labels.py b/fairseq/examples/wav2vec/libri_labels.py new file mode 100644 index 0000000000000000000000000000000000000000..694a202604c7a4a480550550679ce6c16bd10e42 --- /dev/null +++ b/fairseq/examples/wav2vec/libri_labels.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Helper script to pre-compute embeddings for a flashlight (previously called wav2letter++) dataset +""" + +import argparse +import os + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("tsv") + parser.add_argument("--output-dir", required=True) + parser.add_argument("--output-name", required=True) + args = parser.parse_args() + + os.makedirs(args.output_dir, exist_ok=True) + + transcriptions = {} + + with open(args.tsv, "r") as tsv, open( + os.path.join(args.output_dir, args.output_name + ".ltr"), "w" + ) as ltr_out, open( + os.path.join(args.output_dir, args.output_name + ".wrd"), "w" + ) as wrd_out: + root = next(tsv).strip() + for line in tsv: + line = line.strip() + dir = os.path.dirname(line) + if dir not in transcriptions: + parts = dir.split(os.path.sep) + trans_path = f"{parts[-2]}-{parts[-1]}.trans.txt" + path = os.path.join(root, dir, trans_path) + assert os.path.exists(path) + texts = {} + with open(path, "r") as trans_f: + for tline in trans_f: + items = tline.strip().split() + texts[items[0]] = " ".join(items[1:]) + transcriptions[dir] = texts + part = os.path.basename(line).split(".")[0] + assert part in transcriptions[dir] + print(transcriptions[dir][part], file=wrd_out) + print( + " ".join(list(transcriptions[dir][part].replace(" ", "|"))) + " |", + file=ltr_out, + ) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/scripts/binarize_manifest.sh b/fairseq/examples/wav2vec/scripts/binarize_manifest.sh new file mode 100644 index 0000000000000000000000000000000000000000..6f201bdb524fad51a69d8c45889eaa1578efc62d --- /dev/null +++ b/fairseq/examples/wav2vec/scripts/binarize_manifest.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash + +# usage: bash binarize_manifest <dest_dir> <train_split> <valid_split> + +DEST_DIR=$1 +TRAIN_SPLIT=$2 +VALID_SPLIT=$3 +FAIRSEQ_ROOT=$4 + +mkdir -p $DEST_DIR + +# split file path and lengths into separate files +cut -f1 $TRAIN_SPLIT.tsv > $DEST_DIR/train_fnames.txt +cut -f1 $VALID_SPLIT.tsv > $DEST_DIR/valid_fnames.txt +cut -f2 $TRAIN_SPLIT.tsv > $DEST_DIR/train.lengths +cut -f2 $VALID_SPLIT.tsv > $DEST_DIR/valid.lengths + +# copy root directory +head -1 $TRAIN_SPLIT.tsv > $DEST_DIR/train.root +head -1 $VALID_SPLIT.tsv > $DEST_DIR/valid.root + +# remove root directory +sed -i '1d' $DEST_DIR/train_fnames.txt +sed -i '1d' $DEST_DIR/valid_fnames.txt +sed -i '1d' $DEST_DIR/train.lengths +sed -i '1d' $DEST_DIR/valid.lengths + +# insert spaces between characters +sed -i -e 's/\(.\)/\1 /g' $DEST_DIR/train_fnames.txt +sed -i -e 's/\(.\)/\1 /g' $DEST_DIR/valid_fnames.txt + +# run preprocessor +PYTHONPATH=$FAIRSEQ_ROOT python $FAIRSEQ_ROOT/fairseq_cli/preprocess.py --dataset-impl mmap --trainpref $DEST_DIR/train_fnames.txt --validpref $DEST_DIR/valid_fnames.txt --workers 60 --only-source --destdir $DEST_DIR diff --git a/fairseq/examples/wav2vec/unsupervised/README.md b/fairseq/examples/wav2vec/unsupervised/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0b213fd202d04bce2149936ec149c23c6d483745 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/README.md @@ -0,0 +1,103 @@ +# wav2vec Unsupervised (wav2vec-U) + +Wav2vec Unsupervised (wav2vec-U) is a framework for building speech recognition systems without any labeled training data as described in [Unsupervised Speech Recognition (Baevski et al., 2021)](https://ai.facebook.com/research/publications/unsupervised-speech-recognition). The model takes as input wav2vec 2.0 or XLSR representations (see [pretrained models](https://github.com/pytorch/fairseq/blob/main/examples/wav2vec)) as well as unlabeled speech and text data. + + The wav2vec-U training procedure consists of three consecutive main steps: +* Preparation of speech representations and text data +* Generative adversarial training (GAN) +* Iterative self-training + Kaldi LM-decoding + +## Preparation of speech and text data +Similar to [wav2vec 2.0](https://github.com/pytorch/fairseq/blob/main/examples/wav2vec/README.md), data folders contain {train,valid,test}.{tsv,wrd,phn} files, where audio paths are stored in tsv files, and word, letter or phoneme transcriptions are stored in .{wrd,ltr,phn}. + +In **/path/to/data/with_silence** you need a *train.tsv* file as well as (optionally) *{valid,test}.{tsv,wrd,phn}*. It is nice to have *10h.{tsv,phn}* files there too for reproducing the ablation study on layer selection. In **/path/to/data/without_silence** you have the same files, except *.tsv* files contain audios with silences removed using rVAD. + +Pre-requisites: +* set FAIRSEQ_ROOT environmental variable to your fairseq installation +* set RVAD_ROOT environmental variable to a checkout of [rVADfast](https://github.com/zhenghuatan/rVADfast) +* set KENLM_ROOT environmental variable to the location of [KenLM](https://github.com/kpu/kenlm) binaries +* install [PyKaldi](https://github.com/pykaldi/pykaldi) and set KALDI_ROOT environmental variable to the location of your kaldi installation. To use the version bundled with PyKaldi, you can use /path/to/pykaldi/tools/kaldi + +Create new audio files without silences: +```shell +# create a manifest file for the set original of audio files +python $FAIRSEQ_ROOT/examples/wav2vec/wav2vec_manifest.py /dir/to/save/audio/files --ext wav --dest /path/to/new/train.tsv --valid-percent 0 + +python scripts/vads.py -r $RVAD_ROOT < /path/to/train.tsv > train.vads + +python scripts/remove_silence.py --tsv /path/to/train.tsv --vads train.vads --out /dir/to/save/audio/files + +python $FAIRSEQ_ROOT/examples/wav2vec/wav2vec_manifest.py /dir/to/save/audio/files --ext wav --dest /path/to/new/train.tsv --valid-percent 0.01 +``` + +Next, we need to preprocess the audio data to better match phonemized text data: + +```shell +zsh scripts/prepare_audio.sh /dir/with/{train,test,valid}.tsv /output/dir /path/to/wav2vec2/model.pt 512 14 +``` +Note that if you have splits different than train/valid/test, you will need to modify this script. The last two arguments are the PCA dimensionality and the 0-based index of the layer from which to extract representations. + +Now we need to prepare text data: +```shell +zsh scripts/prepare_text.sh language /path/to/text/file /output/dir 1000 espeak /path/to/fasttext/lid/model +``` + +The fourth argument is minimum number observations of phones to keep. If your text corpus is small, you might want to reduce this number. + +The fifth argument is which phonemizer to use. Supported values are [espeak](http://espeak.sourceforge.net/), [espeak-ng](https://github.com/espeak-ng/espeak-ng), and [G2P](https://github.com/Kyubyong/g2p) (english only). + +Pre-trained fasttext LID models can be downloaded [here](https://fasttext.cc/docs/en/language-identification.html). + +### Prepare TIMIT data +TIMIT transcripts include silence. Therefore VAD is not used for audio preprocessing, and we do not wrap transcripts with silences or insert random silence in between words. + +To prepare TIMIT data for both the matched an unmatched setup: +```shell +bash scripts/prepare_timit.sh /dir/to/timit/raw/data /output/dir /path/to/wav2vec2/model.pt +``` + +Note that we assume the TIMIT distribution with capitalized directories and filenames are used (e.g., `TRAIN/DR1/FCJF0/SA1.PHN`). + +## Generative adversarial training (GAN) + +We then use a GAN model to build a first unsupervised ASR model. The data preparation above of both speech features and text data is a necessary procedure that enables the generator to match speech to text in an unsupervised way. + +Launching GAN training on top of preprocessed features, with default hyperparameters can be done with: + +``` +PREFIX=w2v_unsup_gan_xp +TASK_DATA=/path/to/features/precompute_unfiltered_pca512_cls128_mean_pooled +TEXT_DATA=/path/to/data/phones # path to fairseq-preprocessed GAN data (phones dir) +KENLM_PATH=/path/to/data/phones/kenlm.phn.o4.bin # KenLM 4-gram phoneme language model (LM data = GAN data here) + +PYTHONPATH=$FAIRSEQ_ROOT PREFIX=$PREFIX fairseq-hydra-train \ + -m --config-dir config/gan \ + --config-name w2vu \ + task.data=${TASK_DATA} \ + task.text_data=${TEXT_DATA} \ + task.kenlm_path=${KENLM_PATH} \ + common.user_dir=${FAIRSEQ_ROOT}/examples/wav2vec/unsupervised \ + model.code_penalty=2,4 model.gradient_penalty=1.5,2.0 \ + model.smoothness_weight=0.5,0.75,1.0 'common.seed=range(0,5)' +``` + + +Once we find the best checkpoint (chosen using unsupervised metric that combined language model perplexity and vocabulary usage), we can use it to generate phone labels (or word labels with an appropriate kaldi WFST): + +```shell +python w2vu_generate.py --config-dir config/generate --config-name viterbi \ +fairseq.common.user_dir=${FAIRSEQ_ROOT}/examples/wav2vec/unsupervised \ +fairseq.task.data=/path/to/dir/with/features \ +fairseq.common_eval.path=/path/to/gan/checkpoint \ +fairseq.dataset.gen_subset=valid results_path=/where/to/save/transcriptions +``` + +The decoding without LM works best on the same adjacent-mean-pooled features that the gan was trained on, while decoding with LM works better on features before the adjacent timestep mean-pooling step (without the "_pooled" suffix). + +## Iterative self-training + Kaldi LM-decoding +After the GAN training provides a first unsupervised model, we can then progressively refine the quality of transcriptions using several iterations of semi-supervised learning. We perform two iterations: first, pseudo-label the training data with the unsupervised GAN model and train an HMM on the pseudo-labels. Second, we relabel the training data with the HMM and then fine-tune the original wav2vec 2.0 model using the HMM pseudo-labels with a CTC loss. Note that HMM models use phonemes as output, while wav2vec 2.0 use letter. Both are decoded using WFST decoders into words. + + +Please see [this README](kaldi_self_train/README.md) for more instructions on how to do iterative self-training + Kaldi LM-decoding. + +*** Note: these instructions are a work in progress and will be updated over the next few days diff --git a/fairseq/examples/wav2vec/unsupervised/__init__.py b/fairseq/examples/wav2vec/unsupervised/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/examples/wav2vec/unsupervised/config/finetuning/w2v_finetune.yaml b/fairseq/examples/wav2vec/unsupervised/config/finetuning/w2v_finetune.yaml new file mode 100644 index 0000000000000000000000000000000000000000..19a3ef34849d33836ec4084dcbd755c53879ba28 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/finetuning/w2v_finetune.yaml @@ -0,0 +1,62 @@ +# @package _group_ + +common: + fp16: true + log_format: json + log_interval: 200 + tensorboard_logdir: tb + +checkpoint: + no_epoch_checkpoints: true + save_interval_updates: 20000 + +task: + _name: audio_finetuning + data: ??? + normalize: true + labels: ltr + +dataset: + num_workers: 6 + max_tokens: 800000 + skip_invalid_size_inputs_valid_test: true + train_subset: train + valid_subset: valid + +distributed_training: + ddp_backend: legacy_ddp + distributed_world_size: 8 + find_unused_parameters: True + +criterion: + _name: ctc + zero_infinity: true + post_process: letter + +optimization: + max_update: 80000 + lr: [0.00003] + sentence_avg: true + update_freq: [1] + +optimizer: + _name: adam + adam_betas: (0.9,0.98) + adam_eps: 1e-08 + +lr_scheduler: + _name: tri_stage + phase_ratio: [0.1, 0.4, 0.5] + final_lr_scale: 0.05 + +model: + _name: wav2vec_ctc + w2v_path: ??? + apply_mask: true + mask_prob: 0.25 + mask_channel_prob: 0.1 + mask_channel_length: 64 + layerdrop: 0.1 + activation_dropout: 0.1 + feature_grad_mult: 0.0 + freeze_finetune_updates: 0 diff --git a/fairseq/examples/wav2vec/unsupervised/config/gan/w2vu.yaml b/fairseq/examples/wav2vec/unsupervised/config/gan/w2vu.yaml new file mode 100644 index 0000000000000000000000000000000000000000..74f1829d1497560f6e1e006073f19716d36bc947 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/gan/w2vu.yaml @@ -0,0 +1,115 @@ +# @package _group_ + +common: + fp16: false + fp16_no_flatten_grads: true + log_format: json + log_interval: 100 + tensorboard_logdir: tb + reset_logging: false + suppress_crashes: false + +checkpoint: + save_interval: 1000 + save_interval_updates: 1000 + no_epoch_checkpoints: true + best_checkpoint_metric: weighted_lm_ppl + save_dir: . + +distributed_training: + distributed_world_size: 1 + +task: + _name: unpaired_audio_text + data: ??? + text_data: ??? + labels: phn + sort_by_length: false + unfiltered: false + max_length: null + append_eos: false + kenlm_path: ??? + +dataset: + num_workers: 6 + batch_size: 160 + skip_invalid_size_inputs_valid_test: true + valid_subset: valid + validate_interval: 1000 + validate_interval_updates: 1000 + +criterion: + _name: model + log_keys: + - accuracy_dense + - accuracy_token + - temp + - code_ppl + +optimization: + max_update: 150000 + clip_norm: 5.0 + lr: [0] + +optimizer: + _name: composite + groups: + generator: + lr: [0.0004] + lr_float: null + optimizer: + _name: adam + adam_betas: [0.5,0.98] + adam_eps: 1e-06 + weight_decay: 0 + amsgrad: false + lr_scheduler: + _name: fixed + warmup_updates: 0 + discriminator: + lr: [ 0.0005 ] + lr_float: null + optimizer: + _name: adam + adam_betas: [0.5,0.98] + adam_eps: 1e-06 + weight_decay: 0.0001 + amsgrad: false + lr_scheduler: + _name: fixed + warmup_updates: 0 + +lr_scheduler: pass_through + +model: + _name: wav2vec_u + + discriminator_dim: 384 + discriminator_depth: 2 + discriminator_kernel: 6 + discriminator_linear_emb: false + discriminator_causal: true + discriminator_max_pool: false + discriminator_act_after_linear: false + discriminator_dropout: 0.0 + discriminator_weight_norm: false + + generator_stride: 1 + generator_kernel: 4 + generator_bias: false + generator_dropout: 0.1 + + smoothness_weight: 0.5 + smoothing: 0 + smoothing_one_sided: false + gumbel: false + hard_gumbel: false + gradient_penalty: 1.5 + code_penalty: 4.0 + temp: [ 2,0.1,0.99995 ] + input_dim: 512 + + segmentation: + type: JOIN + mean_pool_join: false + remove_zeros: false diff --git a/fairseq/examples/wav2vec/unsupervised/config/generate/viterbi.yaml b/fairseq/examples/wav2vec/unsupervised/config/generate/viterbi.yaml new file mode 100644 index 0000000000000000000000000000000000000000..9c88beebcb15f9047195c8c7e79c21eac59db418 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/generate/viterbi.yaml @@ -0,0 +1,21 @@ +# @package _group_ + +fairseq: + task: + _name: unpaired_audio_text + labels: phn + data: ??? + sort_by_length: false + shuffle: false + text_data: '' + + common_eval: + path: ??? + quiet: true + + dataset: + gen_subset: valid + batch_size: 1 + +w2l_decoder: VITERBI +post_process: silence diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_matched/test.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/test.uid new file mode 100644 index 0000000000000000000000000000000000000000..401008246a1bc2cbf309d9d0aa56710f0ff643bc --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/test.uid @@ -0,0 +1,192 @@ +FDHC0_SI1559 +FDHC0_SI2189 +FDHC0_SI929 +FDHC0_SX119 +FDHC0_SX209 +FDHC0_SX29 +FDHC0_SX299 +FDHC0_SX389 +FELC0_SI1386 +FELC0_SI2016 +FELC0_SI756 +FELC0_SX126 +FELC0_SX216 +FELC0_SX306 +FELC0_SX36 +FELC0_SX396 +FJLM0_SI1043 +FJLM0_SI1673 +FJLM0_SI2303 +FJLM0_SX143 +FJLM0_SX233 +FJLM0_SX323 +FJLM0_SX413 +FJLM0_SX53 +FMGD0_SI1564 +FMGD0_SI2194 +FMGD0_SI934 +FMGD0_SX124 +FMGD0_SX214 +FMGD0_SX304 +FMGD0_SX34 +FMGD0_SX394 +FMLD0_SI2185 +FMLD0_SI822 +FMLD0_SI925 +FMLD0_SX115 +FMLD0_SX205 +FMLD0_SX25 +FMLD0_SX295 +FMLD0_SX385 +FNLP0_SI1308 +FNLP0_SI1938 +FNLP0_SI678 +FNLP0_SX138 +FNLP0_SX228 +FNLP0_SX318 +FNLP0_SX408 +FNLP0_SX48 +FPAS0_SI1272 +FPAS0_SI2204 +FPAS0_SI944 +FPAS0_SX134 +FPAS0_SX224 +FPAS0_SX314 +FPAS0_SX404 +FPAS0_SX44 +FPKT0_SI1538 +FPKT0_SI2168 +FPKT0_SI908 +FPKT0_SX188 +FPKT0_SX278 +FPKT0_SX368 +FPKT0_SX8 +FPKT0_SX98 +MBPM0_SI1577 +MBPM0_SI1584 +MBPM0_SI947 +MBPM0_SX137 +MBPM0_SX227 +MBPM0_SX317 +MBPM0_SX407 +MBPM0_SX47 +MCMJ0_SI1094 +MCMJ0_SI464 +MCMJ0_SI602 +MCMJ0_SX104 +MCMJ0_SX14 +MCMJ0_SX194 +MCMJ0_SX284 +MCMJ0_SX374 +MDAB0_SI1039 +MDAB0_SI1669 +MDAB0_SI2299 +MDAB0_SX139 +MDAB0_SX229 +MDAB0_SX319 +MDAB0_SX409 +MDAB0_SX49 +MGRT0_SI1450 +MGRT0_SI2080 +MGRT0_SI820 +MGRT0_SX10 +MGRT0_SX100 +MGRT0_SX190 +MGRT0_SX280 +MGRT0_SX370 +MJDH0_SI1354 +MJDH0_SI1984 +MJDH0_SI724 +MJDH0_SX184 +MJDH0_SX274 +MJDH0_SX364 +MJDH0_SX4 +MJDH0_SX94 +MJLN0_SI1449 +MJLN0_SI2079 +MJLN0_SI819 +MJLN0_SX189 +MJLN0_SX279 +MJLN0_SX369 +MJLN0_SX9 +MJLN0_SX99 +MJMP0_SI1535 +MJMP0_SI1791 +MJMP0_SI905 +MJMP0_SX185 +MJMP0_SX275 +MJMP0_SX365 +MJMP0_SX5 +MJMP0_SX95 +MKLT0_SI1213 +MKLT0_SI1843 +MKLT0_SI583 +MKLT0_SX133 +MKLT0_SX223 +MKLT0_SX313 +MKLT0_SX403 +MKLT0_SX43 +MLLL0_SI1363 +MLLL0_SI1993 +MLLL0_SI733 +MLLL0_SX103 +MLLL0_SX13 +MLLL0_SX193 +MLLL0_SX283 +MLLL0_SX373 +MLNT0_SI1574 +MLNT0_SI1902 +MLNT0_SI642 +MLNT0_SX102 +MLNT0_SX12 +MLNT0_SX192 +MLNT0_SX282 +MLNT0_SX372 +MNJM0_SI1580 +MNJM0_SI2210 +MNJM0_SI950 +MNJM0_SX140 +MNJM0_SX230 +MNJM0_SX320 +MNJM0_SX410 +MNJM0_SX50 +MPAM0_SI1189 +MPAM0_SI1819 +MPAM0_SI1961 +MPAM0_SX109 +MPAM0_SX19 +MPAM0_SX199 +MPAM0_SX289 +MPAM0_SX379 +MTAS1_SI1473 +MTAS1_SI2098 +MTAS1_SI838 +MTAS1_SX118 +MTAS1_SX208 +MTAS1_SX28 +MTAS1_SX298 +MTAS1_SX388 +MTLS0_SI1370 +MTLS0_SI2000 +MTLS0_SI740 +MTLS0_SX110 +MTLS0_SX20 +MTLS0_SX200 +MTLS0_SX290 +MTLS0_SX380 +MWBT0_SI1553 +MWBT0_SI2183 +MWBT0_SI923 +MWBT0_SX113 +MWBT0_SX203 +MWBT0_SX23 +MWBT0_SX293 +MWBT0_SX383 +MWEW0_SI1361 +MWEW0_SI1991 +MWEW0_SI731 +MWEW0_SX101 +MWEW0_SX11 +MWEW0_SX191 +MWEW0_SX281 +MWEW0_SX371 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train.uid new file mode 100644 index 0000000000000000000000000000000000000000..c39fd0b91d51e0ae15caf1e9701d0d9ef51ee21b --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train.uid @@ -0,0 +1,3696 @@ +FAEM0_SI1392 +FAEM0_SI2022 +FAEM0_SI762 +FAEM0_SX132 +FAEM0_SX222 +FAEM0_SX312 +FAEM0_SX402 +FAEM0_SX42 +FAJW0_SI1263 +FAJW0_SI1893 +FAJW0_SI633 +FAJW0_SX183 +FAJW0_SX273 +FAJW0_SX3 +FAJW0_SX363 +FAJW0_SX93 +FALK0_SI1086 +FALK0_SI456 +FALK0_SI658 +FALK0_SX186 +FALK0_SX276 +FALK0_SX366 +FALK0_SX6 +FALK0_SX96 +FALR0_SI1325 +FALR0_SI1955 +FALR0_SI695 +FALR0_SX155 +FALR0_SX245 +FALR0_SX335 +FALR0_SX425 +FALR0_SX65 +FAPB0_SI1063 +FAPB0_SI1693 +FAPB0_SI2323 +FAPB0_SX163 +FAPB0_SX253 +FAPB0_SX343 +FAPB0_SX433 +FAPB0_SX73 +FBAS0_SI1387 +FBAS0_SI1472 +FBAS0_SI2066 +FBAS0_SX127 +FBAS0_SX217 +FBAS0_SX307 +FBAS0_SX37 +FBAS0_SX397 +FBCG1_SI1612 +FBCG1_SI2242 +FBCG1_SI982 +FBCG1_SX172 +FBCG1_SX262 +FBCG1_SX352 +FBCG1_SX442 +FBCG1_SX82 +FBCH0_SI1586 +FBCH0_SI956 +FBCH0_SI959 +FBCH0_SX146 +FBCH0_SX236 +FBCH0_SX326 +FBCH0_SX416 +FBCH0_SX56 +FBJL0_SI1552 +FBJL0_SI2182 +FBJL0_SI922 +FBJL0_SX112 +FBJL0_SX202 +FBJL0_SX22 +FBJL0_SX292 +FBJL0_SX382 +FBLV0_SI1058 +FBLV0_SI1688 +FBLV0_SI2318 +FBLV0_SX158 +FBLV0_SX248 +FBLV0_SX338 +FBLV0_SX428 +FBLV0_SX68 +FBMH0_SI1136 +FBMH0_SI1766 +FBMH0_SI970 +FBMH0_SX146 +FBMH0_SX236 +FBMH0_SX326 +FBMH0_SX416 +FBMH0_SX56 +FBMJ0_SI1776 +FBMJ0_SI516 +FBMJ0_SI815 +FBMJ0_SX156 +FBMJ0_SX246 +FBMJ0_SX336 +FBMJ0_SX426 +FBMJ0_SX66 +FCAG0_SI1503 +FCAG0_SI1641 +FCAG0_SI2133 +FCAG0_SX153 +FCAG0_SX243 +FCAG0_SX333 +FCAG0_SX423 +FCAG0_SX63 +FCAJ0_SI1479 +FCAJ0_SI1804 +FCAJ0_SI849 +FCAJ0_SX129 +FCAJ0_SX219 +FCAJ0_SX309 +FCAJ0_SX39 +FCAJ0_SX399 +FCDR1_SI1186 +FCDR1_SI1816 +FCDR1_SI556 +FCDR1_SX106 +FCDR1_SX16 +FCDR1_SX196 +FCDR1_SX286 +FCDR1_SX376 +FCEG0_SI1248 +FCEG0_SI1878 +FCEG0_SI618 +FCEG0_SX168 +FCEG0_SX258 +FCEG0_SX348 +FCEG0_SX438 +FCEG0_SX78 +FCJF0_SI1027 +FCJF0_SI1657 +FCJF0_SI648 +FCJF0_SX127 +FCJF0_SX217 +FCJF0_SX307 +FCJF0_SX37 +FCJF0_SX397 +FCJS0_SI1607 +FCJS0_SI2237 +FCJS0_SI977 +FCJS0_SX167 +FCJS0_SX257 +FCJS0_SX347 +FCJS0_SX437 +FCJS0_SX77 +FCKE0_SI1111 +FCKE0_SI1741 +FCKE0_SI481 +FCKE0_SX121 +FCKE0_SX211 +FCKE0_SX301 +FCKE0_SX31 +FCKE0_SX391 +FCLT0_SI1438 +FCLT0_SI2068 +FCLT0_SI808 +FCLT0_SX178 +FCLT0_SX268 +FCLT0_SX358 +FCLT0_SX448 +FCLT0_SX88 +FCMG0_SI1142 +FCMG0_SI1242 +FCMG0_SI1872 +FCMG0_SX162 +FCMG0_SX252 +FCMG0_SX342 +FCMG0_SX432 +FCMG0_SX72 +FCMM0_SI1083 +FCMM0_SI1957 +FCMM0_SI453 +FCMM0_SX183 +FCMM0_SX273 +FCMM0_SX363 +FCMM0_SX420 +FCMM0_SX93 +FCRZ0_SI1913 +FCRZ0_SI2053 +FCRZ0_SI793 +FCRZ0_SX163 +FCRZ0_SX253 +FCRZ0_SX343 +FCRZ0_SX433 +FCRZ0_SX73 +FCYL0_SI1297 +FCYL0_SI1927 +FCYL0_SI667 +FCYL0_SX127 +FCYL0_SX217 +FCYL0_SX349 +FCYL0_SX37 +FCYL0_SX397 +FDAS1_SI1461 +FDAS1_SI2091 +FDAS1_SI831 +FDAS1_SX111 +FDAS1_SX201 +FDAS1_SX21 +FDAS1_SX291 +FDAS1_SX381 +FDAW0_SI1271 +FDAW0_SI1406 +FDAW0_SI2036 +FDAW0_SX146 +FDAW0_SX236 +FDAW0_SX326 +FDAW0_SX416 +FDAW0_SX56 +FDFB0_SI1318 +FDFB0_SI1948 +FDFB0_SI2010 +FDFB0_SX148 +FDFB0_SX238 +FDFB0_SX328 +FDFB0_SX418 +FDFB0_SX58 +FDJH0_SI1565 +FDJH0_SI2195 +FDJH0_SI935 +FDJH0_SX125 +FDJH0_SX215 +FDJH0_SX305 +FDJH0_SX35 +FDJH0_SX395 +FDKN0_SI1081 +FDKN0_SI1202 +FDKN0_SI1711 +FDKN0_SX181 +FDKN0_SX271 +FDKN0_SX361 +FDKN0_SX451 +FDKN0_SX91 +FDML0_SI1149 +FDML0_SI1779 +FDML0_SI2075 +FDML0_SX159 +FDML0_SX249 +FDML0_SX339 +FDML0_SX429 +FDML0_SX69 +FDMY0_SI1197 +FDMY0_SI567 +FDMY0_SI714 +FDMY0_SX117 +FDMY0_SX207 +FDMY0_SX27 +FDMY0_SX297 +FDMY0_SX387 +FDNC0_SI1278 +FDNC0_SI1908 +FDNC0_SI2287 +FDNC0_SX108 +FDNC0_SX18 +FDNC0_SX198 +FDNC0_SX288 +FDNC0_SX378 +FDTD0_SI1561 +FDTD0_SI2191 +FDTD0_SI931 +FDTD0_SX121 +FDTD0_SX211 +FDTD0_SX301 +FDTD0_SX321 +FDTD0_SX391 +FDXW0_SI1511 +FDXW0_SI2141 +FDXW0_SI881 +FDXW0_SX161 +FDXW0_SX251 +FDXW0_SX341 +FDXW0_SX431 +FDXW0_SX71 +FEAC0_SI1245 +FEAC0_SI1875 +FEAC0_SI615 +FEAC0_SX165 +FEAC0_SX255 +FEAC0_SX345 +FEAC0_SX435 +FEAC0_SX75 +FEAR0_SI1252 +FEAR0_SI1882 +FEAR0_SI622 +FEAR0_SX172 +FEAR0_SX262 +FEAR0_SX352 +FEAR0_SX442 +FEAR0_SX82 +FECD0_SI1418 +FECD0_SI2048 +FECD0_SI788 +FECD0_SX158 +FECD0_SX248 +FECD0_SX338 +FECD0_SX428 +FECD0_SX68 +FEEH0_SI1112 +FEEH0_SI1742 +FEEH0_SI471 +FEEH0_SX122 +FEEH0_SX212 +FEEH0_SX302 +FEEH0_SX32 +FEEH0_SX392 +FEME0_SI1505 +FEME0_SI2135 +FEME0_SI875 +FEME0_SX155 +FEME0_SX245 +FEME0_SX335 +FEME0_SX425 +FEME0_SX65 +FETB0_SI1148 +FETB0_SI1778 +FETB0_SI518 +FETB0_SX158 +FETB0_SX248 +FETB0_SX338 +FETB0_SX428 +FETB0_SX68 +FEXM0_SI1101 +FEXM0_SI1731 +FEXM0_SI482 +FEXM0_SX111 +FEXM0_SX201 +FEXM0_SX291 +FEXM0_SX366 +FEXM0_SX381 +FGCS0_SI1486 +FGCS0_SI2116 +FGCS0_SI856 +FGCS0_SX136 +FGCS0_SX226 +FGCS0_SX316 +FGCS0_SX406 +FGCS0_SX46 +FGDP0_SI1618 +FGDP0_SI2248 +FGDP0_SI988 +FGDP0_SX178 +FGDP0_SX268 +FGDP0_SX358 +FGDP0_SX448 +FGDP0_SX88 +FGMB0_SI1145 +FGMB0_SI1775 +FGMB0_SI515 +FGMB0_SX155 +FGMB0_SX245 +FGMB0_SX335 +FGMB0_SX425 +FGMB0_SX65 +FGRW0_SI1152 +FGRW0_SI1782 +FGRW0_SI1990 +FGRW0_SX162 +FGRW0_SX252 +FGRW0_SX342 +FGRW0_SX432 +FGRW0_SX72 +FHLM0_SI1560 +FHLM0_SI2190 +FHLM0_SI930 +FHLM0_SX120 +FHLM0_SX210 +FHLM0_SX300 +FHLM0_SX349 +FHLM0_SX390 +FHXS0_SI1075 +FHXS0_SI2302 +FHXS0_SI2335 +FHXS0_SX175 +FHXS0_SX265 +FHXS0_SX355 +FHXS0_SX445 +FHXS0_SX85 +FJDM2_SI1582 +FJDM2_SI1964 +FJDM2_SI2212 +FJDM2_SX142 +FJDM2_SX232 +FJDM2_SX322 +FJDM2_SX412 +FJDM2_SX52 +FJEN0_SI1047 +FJEN0_SI1677 +FJEN0_SI2307 +FJEN0_SX147 +FJEN0_SX237 +FJEN0_SX327 +FJEN0_SX417 +FJEN0_SX57 +FJHK0_SI1022 +FJHK0_SI1652 +FJHK0_SI2282 +FJHK0_SX122 +FJHK0_SX212 +FJHK0_SX302 +FJHK0_SX32 +FJHK0_SX392 +FJKL0_SI1562 +FJKL0_SI2192 +FJKL0_SI932 +FJKL0_SX122 +FJKL0_SX212 +FJKL0_SX302 +FJKL0_SX32 +FJKL0_SX392 +FJLG0_SI1506 +FJLG0_SI1889 +FJLG0_SI2306 +FJLG0_SX179 +FJLG0_SX269 +FJLG0_SX359 +FJLG0_SX449 +FJLG0_SX89 +FJLR0_SI1231 +FJLR0_SI1861 +FJLR0_SI601 +FJLR0_SX151 +FJLR0_SX241 +FJLR0_SX331 +FJLR0_SX421 +FJLR0_SX61 +FJRB0_SI1302 +FJRB0_SI1932 +FJRB0_SI672 +FJRB0_SX132 +FJRB0_SX222 +FJRB0_SX312 +FJRB0_SX402 +FJRB0_SX42 +FJRP1_SI1432 +FJRP1_SI2062 +FJRP1_SI802 +FJRP1_SX172 +FJRP1_SX262 +FJRP1_SX352 +FJRP1_SX442 +FJRP1_SX82 +FJSK0_SI1052 +FJSK0_SI1682 +FJSK0_SI2312 +FJSK0_SX152 +FJSK0_SX242 +FJSK0_SX332 +FJSK0_SX422 +FJSK0_SX62 +FJSP0_SI1434 +FJSP0_SI1763 +FJSP0_SI804 +FJSP0_SX174 +FJSP0_SX264 +FJSP0_SX354 +FJSP0_SX444 +FJSP0_SX84 +FJWB1_SI2055 +FJWB1_SI748 +FJWB1_SI795 +FJWB1_SX165 +FJWB1_SX255 +FJWB1_SX345 +FJWB1_SX435 +FJWB1_SX75 +FJXM0_SI1211 +FJXM0_SI1971 +FJXM0_SI581 +FJXM0_SX131 +FJXM0_SX221 +FJXM0_SX311 +FJXM0_SX401 +FJXM0_SX41 +FJXP0_SI1122 +FJXP0_SI1752 +FJXP0_SI492 +FJXP0_SX132 +FJXP0_SX222 +FJXP0_SX312 +FJXP0_SX402 +FJXP0_SX42 +FKAA0_SI1208 +FKAA0_SI1838 +FKAA0_SI578 +FKAA0_SX128 +FKAA0_SX218 +FKAA0_SX308 +FKAA0_SX38 +FKAA0_SX398 +FKDE0_SI1141 +FKDE0_SI1771 +FKDE0_SI2221 +FKDE0_SX151 +FKDE0_SX241 +FKDE0_SX331 +FKDE0_SX421 +FKDE0_SX61 +FKDW0_SI1207 +FKDW0_SI1891 +FKDW0_SI577 +FKDW0_SX127 +FKDW0_SX217 +FKDW0_SX307 +FKDW0_SX37 +FKDW0_SX397 +FKFB0_SI1608 +FKFB0_SI2238 +FKFB0_SI978 +FKFB0_SX168 +FKFB0_SX258 +FKFB0_SX348 +FKFB0_SX438 +FKFB0_SX78 +FKKH0_SI1290 +FKKH0_SI1920 +FKKH0_SI660 +FKKH0_SX120 +FKKH0_SX210 +FKKH0_SX30 +FKKH0_SX300 +FKKH0_SX390 +FKLC0_SI1615 +FKLC0_SI2245 +FKLC0_SI985 +FKLC0_SX175 +FKLC0_SX265 +FKLC0_SX355 +FKLC0_SX445 +FKLC0_SX85 +FKLC1_SI1048 +FKLC1_SI1678 +FKLC1_SI2308 +FKLC1_SX148 +FKLC1_SX238 +FKLC1_SX328 +FKLC1_SX418 +FKLC1_SX58 +FKLH0_SI1257 +FKLH0_SI1887 +FKLH0_SI627 +FKLH0_SX177 +FKLH0_SX267 +FKLH0_SX357 +FKLH0_SX447 +FKLH0_SX87 +FKSR0_SI1117 +FKSR0_SI1747 +FKSR0_SI487 +FKSR0_SX161 +FKSR0_SX217 +FKSR0_SX366 +FKSR0_SX37 +FKSR0_SX397 +FLAC0_SI1339 +FLAC0_SI2161 +FLAC0_SI901 +FLAC0_SX181 +FLAC0_SX271 +FLAC0_SX361 +FLAC0_SX451 +FLAC0_SX91 +FLAG0_SI1464 +FLAG0_SI2094 +FLAG0_SI834 +FLAG0_SX114 +FLAG0_SX204 +FLAG0_SX24 +FLAG0_SX294 +FLAG0_SX384 +FLEH0_SI1051 +FLEH0_SI1681 +FLEH0_SI2311 +FLEH0_SX151 +FLEH0_SX241 +FLEH0_SX331 +FLEH0_SX421 +FLEH0_SX61 +FLET0_SI1137 +FLET0_SI1767 +FLET0_SI507 +FLET0_SX147 +FLET0_SX237 +FLET0_SX277 +FLET0_SX417 +FLET0_SX57 +FLHD0_SI1344 +FLHD0_SI1827 +FLHD0_SI1974 +FLHD0_SX174 +FLHD0_SX264 +FLHD0_SX354 +FLHD0_SX444 +FLHD0_SX84 +FLJA0_SI1078 +FLJA0_SI1708 +FLJA0_SI2338 +FLJA0_SX178 +FLJA0_SX268 +FLJA0_SX358 +FLJA0_SX448 +FLJA0_SX88 +FLJD0_SI1516 +FLJD0_SI2146 +FLJD0_SI886 +FLJD0_SX166 +FLJD0_SX256 +FLJD0_SX346 +FLJD0_SX436 +FLJD0_SX76 +FLJG0_SI1611 +FLJG0_SI2241 +FLJG0_SI981 +FLJG0_SX171 +FLJG0_SX261 +FLJG0_SX351 +FLJG0_SX441 +FLJG0_SX81 +FLKM0_SI1880 +FLKM0_SI620 +FLKM0_SI686 +FLKM0_SX116 +FLKM0_SX260 +FLKM0_SX350 +FLKM0_SX440 +FLKM0_SX80 +FLMA0_SI1243 +FLMA0_SI1873 +FLMA0_SI613 +FLMA0_SX163 +FLMA0_SX253 +FLMA0_SX343 +FLMA0_SX433 +FLMA0_SX73 +FLMC0_SI1372 +FLMC0_SI2002 +FLMC0_SI742 +FLMC0_SX112 +FLMC0_SX22 +FLMC0_SX292 +FLMC0_SX336 +FLMC0_SX382 +FLMK0_SI1035 +FLMK0_SI1229 +FLMK0_SI2295 +FLMK0_SX135 +FLMK0_SX225 +FLMK0_SX315 +FLMK0_SX405 +FLMK0_SX45 +FLOD0_SI1287 +FLOD0_SI1917 +FLOD0_SI657 +FLOD0_SX117 +FLOD0_SX171 +FLOD0_SX207 +FLOD0_SX297 +FLOD0_SX387 +FLTM0_SI1070 +FLTM0_SI1700 +FLTM0_SI2330 +FLTM0_SX170 +FLTM0_SX260 +FLTM0_SX350 +FLTM0_SX440 +FLTM0_SX80 +FMAH1_SI1509 +FMAH1_SI2139 +FMAH1_SI879 +FMAH1_SX159 +FMAH1_SX249 +FMAH1_SX339 +FMAH1_SX429 +FMAH1_SX69 +FMBG0_SI1160 +FMBG0_SI1790 +FMBG0_SI2264 +FMBG0_SX260 +FMBG0_SX3 +FMBG0_SX350 +FMBG0_SX440 +FMBG0_SX80 +FMEM0_SI1377 +FMEM0_SI2007 +FMEM0_SI747 +FMEM0_SX117 +FMEM0_SX207 +FMEM0_SX297 +FMEM0_SX333 +FMEM0_SX387 +FMJB0_SI1177 +FMJB0_SI1807 +FMJB0_SI547 +FMJB0_SX187 +FMJB0_SX277 +FMJB0_SX367 +FMJB0_SX7 +FMJB0_SX97 +FMJF0_SI1254 +FMJF0_SI1884 +FMJF0_SI624 +FMJF0_SX174 +FMJF0_SX264 +FMJF0_SX354 +FMJF0_SX444 +FMJF0_SX84 +FMJU0_SI1389 +FMJU0_SI2019 +FMJU0_SI759 +FMJU0_SX129 +FMJU0_SX219 +FMJU0_SX309 +FMJU0_SX39 +FMJU0_SX399 +FMKC0_SI1041 +FMKC0_SI1072 +FMKC0_SI1702 +FMKC0_SX172 +FMKC0_SX262 +FMKC0_SX352 +FMKC0_SX442 +FMKC0_SX82 +FMKF0_SI1018 +FMKF0_SI1536 +FMKF0_SI906 +FMKF0_SX186 +FMKF0_SX276 +FMKF0_SX366 +FMKF0_SX6 +FMKF0_SX96 +FMMH0_SI1537 +FMMH0_SI2167 +FMMH0_SI907 +FMMH0_SX187 +FMMH0_SX367 +FMMH0_SX420 +FMMH0_SX7 +FMMH0_SX97 +FMPG0_SI1602 +FMPG0_SI2232 +FMPG0_SI972 +FMPG0_SX162 +FMPG0_SX252 +FMPG0_SX342 +FMPG0_SX432 +FMPG0_SX72 +FNKL0_SI1522 +FNKL0_SI2152 +FNKL0_SI892 +FNKL0_SX172 +FNKL0_SX196 +FNKL0_SX262 +FNKL0_SX442 +FNKL0_SX82 +FNTB0_SI1203 +FNTB0_SI573 +FNTB0_SI679 +FNTB0_SX123 +FNTB0_SX213 +FNTB0_SX303 +FNTB0_SX33 +FNTB0_SX393 +FPAB1_SI1471 +FPAB1_SI2101 +FPAB1_SI841 +FPAB1_SX121 +FPAB1_SX211 +FPAB1_SX301 +FPAB1_SX31 +FPAB1_SX391 +FPAC0_SI1921 +FPAC0_SI2011 +FPAC0_SI661 +FPAC0_SX121 +FPAC0_SX211 +FPAC0_SX301 +FPAC0_SX31 +FPAC0_SX391 +FPAD0_SI1346 +FPAD0_SI1976 +FPAD0_SI716 +FPAD0_SX176 +FPAD0_SX266 +FPAD0_SX356 +FPAD0_SX446 +FPAD0_SX86 +FPAF0_SI1054 +FPAF0_SI1684 +FPAF0_SI2314 +FPAF0_SX154 +FPAF0_SX244 +FPAF0_SX334 +FPAF0_SX424 +FPAF0_SX64 +FPAZ0_SI1593 +FPAZ0_SI2223 +FPAZ0_SI963 +FPAZ0_SX153 +FPAZ0_SX243 +FPAZ0_SX27 +FPAZ0_SX423 +FPAZ0_SX63 +FPJF0_SI1046 +FPJF0_SI1259 +FPJF0_SI1676 +FPJF0_SX146 +FPJF0_SX236 +FPJF0_SX326 +FPJF0_SX352 +FPJF0_SX56 +FPLS0_SI1590 +FPLS0_SI2220 +FPLS0_SI960 +FPLS0_SX150 +FPLS0_SX240 +FPLS0_SX3 +FPLS0_SX330 +FPLS0_SX60 +FPMY0_SI1153 +FPMY0_SI1783 +FPMY0_SI523 +FPMY0_SX163 +FPMY0_SX196 +FPMY0_SX253 +FPMY0_SX343 +FPMY0_SX73 +FREH0_SI1315 +FREH0_SI1945 +FREH0_SI685 +FREH0_SX145 +FREH0_SX235 +FREH0_SX325 +FREH0_SX415 +FREH0_SX55 +FRJB0_SI1427 +FRJB0_SI1470 +FRJB0_SI1794 +FRJB0_SX167 +FRJB0_SX257 +FRJB0_SX347 +FRJB0_SX437 +FRJB0_SX77 +FRLL0_SI1514 +FRLL0_SI805 +FRLL0_SI884 +FRLL0_SX164 +FRLL0_SX254 +FRLL0_SX344 +FRLL0_SX434 +FRLL0_SX74 +FSAG0_SI1323 +FSAG0_SI1953 +FSAG0_SI693 +FSAG0_SX153 +FSAG0_SX243 +FSAG0_SX333 +FSAG0_SX423 +FSAG0_SX63 +FSAH0_SI1244 +FSAH0_SI1874 +FSAH0_SI614 +FSAH0_SX164 +FSAH0_SX327 +FSAH0_SX344 +FSAH0_SX434 +FSAH0_SX74 +FSAK0_SI1300 +FSAK0_SI1930 +FSAK0_SI670 +FSAK0_SX130 +FSAK0_SX220 +FSAK0_SX310 +FSAK0_SX40 +FSAK0_SX400 +FSBK0_SI1069 +FSBK0_SI1699 +FSBK0_SI2329 +FSBK0_SX169 +FSBK0_SX259 +FSBK0_SX349 +FSBK0_SX439 +FSBK0_SX79 +FSCN0_SI1886 +FSCN0_SI626 +FSCN0_SI705 +FSCN0_SX176 +FSCN0_SX266 +FSCN0_SX356 +FSCN0_SX446 +FSCN0_SX86 +FSDC0_SI1312 +FSDC0_SI1942 +FSDC0_SI2234 +FSDC0_SX142 +FSDC0_SX232 +FSDC0_SX322 +FSDC0_SX412 +FSDC0_SX52 +FSDJ0_SI1115 +FSDJ0_SI1745 +FSDJ0_SI485 +FSDJ0_SX125 +FSDJ0_SX215 +FSDJ0_SX305 +FSDJ0_SX35 +FSDJ0_SX395 +FSGF0_SI1557 +FSGF0_SI2187 +FSGF0_SI927 +FSGF0_SX117 +FSGF0_SX207 +FSGF0_SX27 +FSGF0_SX297 +FSGF0_SX387 +FSJG0_SI1570 +FSJG0_SI2200 +FSJG0_SI940 +FSJG0_SX130 +FSJG0_SX220 +FSJG0_SX310 +FSJG0_SX40 +FSJG0_SX400 +FSJK1_SI1025 +FSJK1_SI2285 +FSJK1_SI696 +FSJK1_SX125 +FSJK1_SX215 +FSJK1_SX305 +FSJK1_SX35 +FSJK1_SX395 +FSJS0_SI1171 +FSJS0_SI1801 +FSJS0_SI541 +FSJS0_SX181 +FSJS0_SX271 +FSJS0_SX361 +FSJS0_SX451 +FSJS0_SX91 +FSJW0_SI1333 +FSJW0_SI1963 +FSJW0_SI703 +FSJW0_SX163 +FSJW0_SX253 +FSJW0_SX343 +FSJW0_SX433 +FSJW0_SX73 +FSKC0_SI1416 +FSKC0_SI2046 +FSKC0_SI786 +FSKC0_SX156 +FSKC0_SX246 +FSKC0_SX336 +FSKC0_SX426 +FSKC0_SX66 +FSKL0_SI1529 +FSKL0_SI2159 +FSKL0_SI899 +FSKL0_SX179 +FSKL0_SX269 +FSKL0_SX359 +FSKL0_SX449 +FSKL0_SX89 +FSKP0_SI1098 +FSKP0_SI1728 +FSKP0_SI468 +FSKP0_SX108 +FSKP0_SX18 +FSKP0_SX198 +FSKP0_SX288 +FSKP0_SX378 +FSLS0_SI1056 +FSLS0_SI1686 +FSLS0_SI2316 +FSLS0_SX156 +FSLS0_SX202 +FSLS0_SX246 +FSLS0_SX426 +FSLS0_SX66 +FSMA0_SI1621 +FSMA0_SI2251 +FSMA0_SI991 +FSMA0_SX181 +FSMA0_SX271 +FSMA0_SX361 +FSMA0_SX451 +FSMA0_SX91 +FSMM0_SI1314 +FSMM0_SI1944 +FSMM0_SI684 +FSMM0_SX144 +FSMM0_SX234 +FSMM0_SX324 +FSMM0_SX414 +FSMM0_SX54 +FSMS1_SI1504 +FSMS1_SI2134 +FSMS1_SI874 +FSMS1_SX154 +FSMS1_SX244 +FSMS1_SX334 +FSMS1_SX347 +FSMS1_SX64 +FSPM0_SI1241 +FSPM0_SI1871 +FSPM0_SI611 +FSPM0_SX161 +FSPM0_SX251 +FSPM0_SX341 +FSPM0_SX431 +FSPM0_SX71 +FSRH0_SI1719 +FSRH0_SI1931 +FSRH0_SI671 +FSRH0_SX131 +FSRH0_SX221 +FSRH0_SX311 +FSRH0_SX401 +FSRH0_SX41 +FSSB0_SI1082 +FSSB0_SI1712 +FSSB0_SI2342 +FSSB0_SX182 +FSSB0_SX272 +FSSB0_SX362 +FSSB0_SX452 +FSSB0_SX92 +FTAJ0_SI1329 +FTAJ0_SI474 +FTAJ0_SI699 +FTAJ0_SX159 +FTAJ0_SX249 +FTAJ0_SX339 +FTAJ0_SX429 +FTAJ0_SX69 +FTBR0_SI1402 +FTBR0_SI2181 +FTBR0_SI921 +FTBR0_SX111 +FTBR0_SX201 +FTBR0_SX21 +FTBR0_SX291 +FTBR0_SX381 +FTBW0_SI1345 +FTBW0_SI1975 +FTBW0_SI715 +FTBW0_SX175 +FTBW0_SX265 +FTBW0_SX355 +FTBW0_SX445 +FTBW0_SX85 +FTLG0_SI1743 +FTLG0_SI483 +FTLG0_SI840 +FTLG0_SX123 +FTLG0_SX213 +FTLG0_SX303 +FTLG0_SX33 +FTLG0_SX393 +FTMG0_SI1532 +FTMG0_SI2162 +FTMG0_SI902 +FTMG0_SX182 +FTMG0_SX272 +FTMG0_SX362 +FTMG0_SX452 +FTMG0_SX92 +FVFB0_SI1032 +FVFB0_SI1510 +FVFB0_SI2292 +FVFB0_SX132 +FVFB0_SX222 +FVFB0_SX312 +FVFB0_SX402 +FVFB0_SX42 +FVKB0_SI1159 +FVKB0_SI1789 +FVKB0_SI529 +FVKB0_SX169 +FVKB0_SX259 +FVKB0_SX349 +FVKB0_SX439 +FVKB0_SX79 +FVMH0_SI1466 +FVMH0_SI2096 +FVMH0_SI836 +FVMH0_SX116 +FVMH0_SX206 +FVMH0_SX26 +FVMH0_SX296 +FVMH0_SX386 +MABC0_SI1620 +MABC0_SI2041 +MABC0_SI781 +MABC0_SX151 +MABC0_SX241 +MABC0_SX331 +MABC0_SX421 +MABC0_SX61 +MADC0_SI1367 +MADC0_SI1997 +MADC0_SI737 +MADC0_SX107 +MADC0_SX17 +MADC0_SX197 +MADC0_SX287 +MADC0_SX377 +MADD0_SI1295 +MADD0_SI1798 +MADD0_SI538 +MADD0_SX178 +MADD0_SX268 +MADD0_SX358 +MADD0_SX448 +MADD0_SX88 +MAEB0_SI1411 +MAEB0_SI2250 +MAEB0_SI990 +MAEB0_SX180 +MAEB0_SX270 +MAEB0_SX360 +MAEB0_SX450 +MAEB0_SX90 +MAEO0_SI1326 +MAEO0_SI1655 +MAEO0_SI1956 +MAEO0_SX156 +MAEO0_SX246 +MAEO0_SX336 +MAEO0_SX426 +MAEO0_SX66 +MAFM0_SI1569 +MAFM0_SI2199 +MAFM0_SI939 +MAFM0_SX129 +MAFM0_SX219 +MAFM0_SX309 +MAFM0_SX39 +MAFM0_SX399 +MAJP0_SI1074 +MAJP0_SI1704 +MAJP0_SI2334 +MAJP0_SX174 +MAJP0_SX264 +MAJP0_SX354 +MAJP0_SX444 +MAJP0_SX84 +MAKB0_SI1016 +MAKB0_SI1646 +MAKB0_SI2276 +MAKB0_SX116 +MAKB0_SX206 +MAKB0_SX26 +MAKB0_SX296 +MAKB0_SX386 +MAKR0_SI1352 +MAKR0_SI1982 +MAKR0_SI722 +MAKR0_SX182 +MAKR0_SX272 +MAKR0_SX362 +MAKR0_SX452 +MAKR0_SX92 +MAPV0_SI1293 +MAPV0_SI1923 +MAPV0_SI663 +MAPV0_SX123 +MAPV0_SX213 +MAPV0_SX303 +MAPV0_SX33 +MAPV0_SX393 +MARC0_SI1188 +MARC0_SI1818 +MARC0_SI558 +MARC0_SX108 +MARC0_SX18 +MARC0_SX198 +MARC0_SX288 +MARC0_SX378 +MARW0_SI1276 +MARW0_SI1906 +MARW0_SI646 +MARW0_SX106 +MARW0_SX16 +MARW0_SX286 +MARW0_SX349 +MARW0_SX376 +MBAR0_SI1319 +MBAR0_SI1949 +MBAR0_SI689 +MBAR0_SX149 +MBAR0_SX239 +MBAR0_SX329 +MBAR0_SX419 +MBAR0_SX59 +MBBR0_SI1055 +MBBR0_SI1685 +MBBR0_SI2315 +MBBR0_SX155 +MBBR0_SX245 +MBBR0_SX335 +MBBR0_SX425 +MBBR0_SX65 +MBCG0_SI2217 +MBCG0_SI486 +MBCG0_SI957 +MBCG0_SX147 +MBCG0_SX237 +MBCG0_SX327 +MBCG0_SX417 +MBCG0_SX57 +MBEF0_SI1281 +MBEF0_SI1911 +MBEF0_SI651 +MBEF0_SX111 +MBEF0_SX201 +MBEF0_SX21 +MBEF0_SX291 +MBEF0_SX381 +MBGT0_SI1341 +MBGT0_SI1841 +MBGT0_SI711 +MBGT0_SX171 +MBGT0_SX261 +MBGT0_SX351 +MBGT0_SX441 +MBGT0_SX81 +MBJV0_SI1247 +MBJV0_SI1877 +MBJV0_SI617 +MBJV0_SX167 +MBJV0_SX257 +MBJV0_SX347 +MBJV0_SX437 +MBJV0_SX77 +MBMA0_SI1222 +MBMA0_SI1852 +MBMA0_SI592 +MBMA0_SX142 +MBMA0_SX232 +MBMA0_SX322 +MBMA0_SX412 +MBMA0_SX52 +MBMA1_SI2207 +MBMA1_SI2214 +MBMA1_SI954 +MBMA1_SX144 +MBMA1_SX234 +MBMA1_SX324 +MBMA1_SX414 +MBMA1_SX54 +MBML0_SI1169 +MBML0_SI1799 +MBML0_SI539 +MBML0_SX179 +MBML0_SX269 +MBML0_SX359 +MBML0_SX449 +MBML0_SX89 +MBOM0_SI1014 +MBOM0_SI1644 +MBOM0_SI2274 +MBOM0_SX114 +MBOM0_SX204 +MBOM0_SX294 +MBOM0_SX311 +MBOM0_SX384 +MBSB0_SI1353 +MBSB0_SI1983 +MBSB0_SI723 +MBSB0_SX183 +MBSB0_SX273 +MBSB0_SX3 +MBSB0_SX363 +MBSB0_SX93 +MBTH0_SI2102 +MBTH0_SI505 +MBTH0_SI757 +MBTH0_SX122 +MBTH0_SX212 +MBTH0_SX302 +MBTH0_SX32 +MBTH0_SX392 +MBWP0_SI1531 +MBWP0_SI1969 +MBWP0_SI709 +MBWP0_SX169 +MBWP0_SX259 +MBWP0_SX349 +MBWP0_SX439 +MBWP0_SX79 +MCAE0_SI1447 +MCAE0_SI2077 +MCAE0_SI817 +MCAE0_SX187 +MCAE0_SX277 +MCAE0_SX367 +MCAE0_SX7 +MCAE0_SX97 +MCAL0_SI1138 +MCAL0_SI1768 +MCAL0_SI508 +MCAL0_SX148 +MCAL0_SX238 +MCAL0_SX328 +MCAL0_SX418 +MCAL0_SX58 +MCDC0_SI1292 +MCDC0_SI1922 +MCDC0_SI662 +MCDC0_SX122 +MCDC0_SX212 +MCDC0_SX302 +MCDC0_SX32 +MCDC0_SX392 +MCDD0_SI1513 +MCDD0_SI2143 +MCDD0_SI883 +MCDD0_SX163 +MCDD0_SX253 +MCDD0_SX343 +MCDD0_SX433 +MCDD0_SX73 +MCDR0_SI1154 +MCDR0_SI1784 +MCDR0_SI524 +MCDR0_SX164 +MCDR0_SX254 +MCDR0_SX344 +MCDR0_SX434 +MCDR0_SX74 +MCEF0_SI1135 +MCEF0_SI1765 +MCEF0_SI842 +MCEF0_SX145 +MCEF0_SX235 +MCEF0_SX325 +MCEF0_SX415 +MCEF0_SX55 +MCEW0_SI1442 +MCEW0_SI2072 +MCEW0_SI812 +MCEW0_SX182 +MCEW0_SX272 +MCEW0_SX362 +MCEW0_SX452 +MCEW0_SX92 +MCHL0_SI1347 +MCHL0_SI1404 +MCHL0_SI1977 +MCHL0_SX177 +MCHL0_SX267 +MCHL0_SX357 +MCHL0_SX447 +MCHL0_SX87 +MCLK0_SI1660 +MCLK0_SI2290 +MCLK0_SI650 +MCLK0_SX130 +MCLK0_SX220 +MCLK0_SX310 +MCLK0_SX40 +MCLK0_SX400 +MCLM0_SI1456 +MCLM0_SI2086 +MCLM0_SI826 +MCLM0_SX106 +MCLM0_SX16 +MCLM0_SX196 +MCLM0_SX286 +MCLM0_SX376 +MCPM0_SI1194 +MCPM0_SI1824 +MCPM0_SI564 +MCPM0_SX114 +MCPM0_SX204 +MCPM0_SX24 +MCPM0_SX294 +MCPM0_SX384 +MCRE0_SI1121 +MCRE0_SI1725 +MCRE0_SI1751 +MCRE0_SX131 +MCRE0_SX221 +MCRE0_SX24 +MCRE0_SX401 +MCRE0_SX41 +MCSS0_SI1380 +MCSS0_SI688 +MCSS0_SI750 +MCSS0_SX120 +MCSS0_SX210 +MCSS0_SX30 +MCSS0_SX300 +MCSS0_SX390 +MCTH0_SI1209 +MCTH0_SI1839 +MCTH0_SI579 +MCTH0_SX129 +MCTH0_SX219 +MCTH0_SX309 +MCTH0_SX39 +MCTH0_SX399 +MCTM0_SI1350 +MCTM0_SI1980 +MCTM0_SI720 +MCTM0_SX180 +MCTM0_SX270 +MCTM0_SX360 +MCTM0_SX450 +MCTM0_SX90 +MCXM0_SI1351 +MCXM0_SI1981 +MCXM0_SI721 +MCXM0_SX181 +MCXM0_SX271 +MCXM0_SX361 +MCXM0_SX451 +MCXM0_SX91 +MDAC0_SI1261 +MDAC0_SI1837 +MDAC0_SI631 +MDAC0_SX181 +MDAC0_SX271 +MDAC0_SX361 +MDAC0_SX451 +MDAC0_SX91 +MDAS0_SI1266 +MDAS0_SI1896 +MDAS0_SI636 +MDAS0_SX186 +MDAS0_SX21 +MDAS0_SX276 +MDAS0_SX6 +MDAS0_SX96 +MDBB1_SI1006 +MDBB1_SI1636 +MDBB1_SI2056 +MDBB1_SX106 +MDBB1_SX16 +MDBB1_SX196 +MDBB1_SX286 +MDBB1_SX376 +MDBP0_SI1158 +MDBP0_SI1788 +MDBP0_SI528 +MDBP0_SX168 +MDBP0_SX258 +MDBP0_SX348 +MDBP0_SX438 +MDBP0_SX78 +MDCD0_SI1415 +MDCD0_SI2045 +MDCD0_SI785 +MDCD0_SX155 +MDCD0_SX245 +MDCD0_SX335 +MDCD0_SX425 +MDCD0_SX65 +MDCM0_SI1480 +MDCM0_SI2110 +MDCM0_SI850 +MDCM0_SX130 +MDCM0_SX220 +MDCM0_SX310 +MDCM0_SX40 +MDCM0_SX400 +MDDC0_SI1419 +MDDC0_SI2049 +MDDC0_SI789 +MDDC0_SX159 +MDDC0_SX249 +MDDC0_SX339 +MDDC0_SX429 +MDDC0_SX69 +MDED0_SI1170 +MDED0_SI1800 +MDED0_SI540 +MDED0_SX180 +MDED0_SX270 +MDED0_SX360 +MDED0_SX450 +MDED0_SX90 +MDEF0_SI1123 +MDEF0_SI1563 +MDEF0_SI2193 +MDEF0_SX123 +MDEF0_SX213 +MDEF0_SX303 +MDEF0_SX33 +MDEF0_SX393 +MDEM0_SI1868 +MDEM0_SI608 +MDEM0_SI800 +MDEM0_SX158 +MDEM0_SX248 +MDEM0_SX338 +MDEM0_SX428 +MDEM0_SX68 +MDHL0_SI1439 +MDHL0_SI2069 +MDHL0_SI809 +MDHL0_SX179 +MDHL0_SX269 +MDHL0_SX359 +MDHL0_SX449 +MDHL0_SX89 +MDHS0_SI1530 +MDHS0_SI2160 +MDHS0_SI900 +MDHS0_SX180 +MDHS0_SX270 +MDHS0_SX360 +MDHS0_SX450 +MDHS0_SX90 +MDJM0_SI1455 +MDJM0_SI2085 +MDJM0_SI825 +MDJM0_SX105 +MDJM0_SX15 +MDJM0_SX195 +MDJM0_SX285 +MDJM0_SX375 +MDKS0_SI1066 +MDKS0_SI1696 +MDKS0_SI2326 +MDKS0_SX166 +MDKS0_SX256 +MDKS0_SX346 +MDKS0_SX436 +MDKS0_SX76 +MDLB0_SI1306 +MDLB0_SI1936 +MDLB0_SI676 +MDLB0_SX136 +MDLB0_SX226 +MDLB0_SX316 +MDLB0_SX406 +MDLB0_SX46 +MDLC0_SI1395 +MDLC0_SI2025 +MDLC0_SI765 +MDLC0_SX135 +MDLC0_SX225 +MDLC0_SX315 +MDLC0_SX405 +MDLC0_SX45 +MDLC1_SI1435 +MDLC1_SI2065 +MDLC1_SI2144 +MDLC1_SX175 +MDLC1_SX265 +MDLC1_SX355 +MDLC1_SX445 +MDLC1_SX85 +MDLC2_SI1614 +MDLC2_SI2244 +MDLC2_SI984 +MDLC2_SX174 +MDLC2_SX264 +MDLC2_SX354 +MDLC2_SX444 +MDLC2_SX84 +MDLH0_SI1960 +MDLH0_SI574 +MDLH0_SI700 +MDLH0_SX160 +MDLH0_SX250 +MDLH0_SX340 +MDLH0_SX430 +MDLH0_SX70 +MDLM0_SI1234 +MDLM0_SI1864 +MDLM0_SI604 +MDLM0_SX154 +MDLM0_SX244 +MDLM0_SX334 +MDLM0_SX424 +MDLM0_SX64 +MDLR0_SI1233 +MDLR0_SI1863 +MDLR0_SI603 +MDLR0_SX153 +MDLR0_SX243 +MDLR0_SX333 +MDLR0_SX423 +MDLR0_SX63 +MDLR1_SI1299 +MDLR1_SI1929 +MDLR1_SI669 +MDLR1_SX129 +MDLR1_SX219 +MDLR1_SX309 +MDLR1_SX39 +MDLR1_SX399 +MDMA0_SI1238 +MDMA0_SI1430 +MDMA0_SI2060 +MDMA0_SX170 +MDMA0_SX260 +MDMA0_SX350 +MDMA0_SX440 +MDMA0_SX80 +MDMT0_SI1832 +MDMT0_SI2341 +MDMT0_SI572 +MDMT0_SX122 +MDMT0_SX212 +MDMT0_SX302 +MDMT0_SX32 +MDMT0_SX392 +MDNS0_SI1011 +MDNS0_SI2271 +MDNS0_SI873 +MDNS0_SX111 +MDNS0_SX201 +MDNS0_SX21 +MDNS0_SX291 +MDNS0_SX381 +MDPB0_SI1760 +MDPB0_SI2126 +MDPB0_SI866 +MDPB0_SX146 +MDPB0_SX236 +MDPB0_SX326 +MDPB0_SX416 +MDPB0_SX56 +MDPK0_SI1053 +MDPK0_SI1683 +MDPK0_SI552 +MDPK0_SX153 +MDPK0_SX243 +MDPK0_SX333 +MDPK0_SX423 +MDPK0_SX63 +MDPS0_SI1651 +MDPS0_SI1979 +MDPS0_SI719 +MDPS0_SX179 +MDPS0_SX269 +MDPS0_SX359 +MDPS0_SX449 +MDPS0_SX89 +MDRD0_SI1382 +MDRD0_SI2012 +MDRD0_SI752 +MDRD0_SX122 +MDRD0_SX212 +MDRD0_SX302 +MDRD0_SX32 +MDRD0_SX392 +MDSJ0_SI1462 +MDSJ0_SI2092 +MDSJ0_SI832 +MDSJ0_SX112 +MDSJ0_SX22 +MDSJ0_SX292 +MDSJ0_SX382 +MDSJ0_SX438 +MDSS0_SI1881 +MDSS0_SI2087 +MDSS0_SI621 +MDSS0_SX171 +MDSS0_SX261 +MDSS0_SX351 +MDSS0_SX441 +MDSS0_SX81 +MDSS1_SI1327 +MDSS1_SI1713 +MDSS1_SI697 +MDSS1_SX157 +MDSS1_SX247 +MDSS1_SX337 +MDSS1_SX427 +MDSS1_SX67 +MDTB0_SI1200 +MDTB0_SI1830 +MDTB0_SI570 +MDTB0_SX120 +MDTB0_SX210 +MDTB0_SX300 +MDTB0_SX321 +MDTB0_SX390 +MDWD0_SI1260 +MDWD0_SI1890 +MDWD0_SI557 +MDWD0_SX180 +MDWD0_SX270 +MDWD0_SX360 +MDWD0_SX450 +MDWD0_SX90 +MDWH0_SI1168 +MDWH0_SI1925 +MDWH0_SI665 +MDWH0_SX125 +MDWH0_SX215 +MDWH0_SX305 +MDWH0_SX35 +MDWH0_SX395 +MDWM0_SI1546 +MDWM0_SI2176 +MDWM0_SI916 +MDWM0_SX106 +MDWM0_SX16 +MDWM0_SX286 +MDWM0_SX376 +MDWM0_SX433 +MEAL0_SI1547 +MEAL0_SI2177 +MEAL0_SI917 +MEAL0_SX107 +MEAL0_SX197 +MEAL0_SX287 +MEAL0_SX347 +MEAL0_SX377 +MEDR0_SI1374 +MEDR0_SI2004 +MEDR0_SI744 +MEDR0_SX114 +MEDR0_SX204 +MEDR0_SX24 +MEDR0_SX294 +MEDR0_SX384 +MEFG0_SI465 +MEFG0_SI491 +MEFG0_SI598 +MEFG0_SX105 +MEFG0_SX15 +MEFG0_SX195 +MEFG0_SX285 +MEFG0_SX375 +MEGJ0_SI1337 +MEGJ0_SI1967 +MEGJ0_SI707 +MEGJ0_SX167 +MEGJ0_SX257 +MEGJ0_SX3 +MEGJ0_SX437 +MEGJ0_SX77 +MEJL0_SI1592 +MEJL0_SI1654 +MEJL0_SI962 +MEJL0_SX152 +MEJL0_SX242 +MEJL0_SX332 +MEJL0_SX422 +MEJL0_SX62 +MEJS0_SI1240 +MEJS0_SI1870 +MEJS0_SI610 +MEJS0_SX160 +MEJS0_SX250 +MEJS0_SX340 +MEJS0_SX430 +MEJS0_SX70 +MESG0_SI1332 +MESG0_SI1962 +MESG0_SI702 +MESG0_SX162 +MESG0_SX252 +MESG0_SX342 +MESG0_SX432 +MESG0_SX72 +MESJ0_SI2039 +MESJ0_SI2257 +MESJ0_SI997 +MESJ0_SX187 +MESJ0_SX277 +MESJ0_SX367 +MESJ0_SX7 +MESJ0_SX97 +MEWM0_SI1348 +MEWM0_SI1978 +MEWM0_SI718 +MEWM0_SX178 +MEWM0_SX268 +MEWM0_SX358 +MEWM0_SX448 +MEWM0_SX88 +MFER0_SI1492 +MFER0_SI2122 +MFER0_SI862 +MFER0_SX142 +MFER0_SX232 +MFER0_SX322 +MFER0_SX412 +MFER0_SX52 +MFMC0_SI1132 +MFMC0_SI1762 +MFMC0_SI502 +MFMC0_SX142 +MFMC0_SX232 +MFMC0_SX322 +MFMC0_SX412 +MFMC0_SX52 +MFRM0_SI1155 +MFRM0_SI1717 +MFRM0_SI1785 +MFRM0_SX165 +MFRM0_SX255 +MFRM0_SX345 +MFRM0_SX435 +MFRM0_SX75 +MFWK0_SI1249 +MFWK0_SI1879 +MFWK0_SI619 +MFWK0_SX169 +MFWK0_SX259 +MFWK0_SX349 +MFWK0_SX439 +MFWK0_SX79 +MFXS0_SI1674 +MFXS0_SI2225 +MFXS0_SI2304 +MFXS0_SX144 +MFXS0_SX234 +MFXS0_SX324 +MFXS0_SX414 +MFXS0_SX54 +MFXV0_SI1005 +MFXV0_SI1342 +MFXV0_SI1635 +MFXV0_SX105 +MFXV0_SX15 +MFXV0_SX195 +MFXV0_SX285 +MFXV0_SX375 +MGAF0_SI1282 +MGAF0_SI1912 +MGAF0_SI652 +MGAF0_SX112 +MGAF0_SX202 +MGAF0_SX22 +MGAF0_SX292 +MGAF0_SX382 +MGAG0_SI1321 +MGAG0_SI645 +MGAG0_SI691 +MGAG0_SX151 +MGAG0_SX241 +MGAG0_SX331 +MGAG0_SX421 +MGAG0_SX61 +MGAK0_SI1036 +MGAK0_SI1666 +MGAK0_SI2296 +MGAK0_SX136 +MGAK0_SX226 +MGAK0_SX316 +MGAK0_SX406 +MGAK0_SX46 +MGAR0_SI1212 +MGAR0_SI1694 +MGAR0_SI1842 +MGAR0_SX132 +MGAR0_SX222 +MGAR0_SX312 +MGAR0_SX402 +MGAR0_SX42 +MGAW0_SI1165 +MGAW0_SI1802 +MGAW0_SI535 +MGAW0_SX175 +MGAW0_SX265 +MGAW0_SX355 +MGAW0_SX445 +MGAW0_SX85 +MGES0_SI1481 +MGES0_SI2111 +MGES0_SI851 +MGES0_SX131 +MGES0_SX221 +MGES0_SX311 +MGES0_SX401 +MGES0_SX41 +MGJC0_SI1256 +MGJC0_SI1335 +MGJC0_SI1965 +MGJC0_SX165 +MGJC0_SX255 +MGJC0_SX345 +MGJC0_SX435 +MGJC0_SX75 +MGRL0_SI1497 +MGRL0_SI2127 +MGRL0_SI867 +MGRL0_SX147 +MGRL0_SX237 +MGRL0_SX327 +MGRL0_SX417 +MGRL0_SX57 +MGRP0_SI1317 +MGRP0_SI1947 +MGRP0_SI687 +MGRP0_SX147 +MGRP0_SX237 +MGRP0_SX327 +MGRP0_SX417 +MGRP0_SX57 +MGSH0_SI1176 +MGSH0_SI1806 +MGSH0_SI546 +MGSH0_SX127 +MGSH0_SX186 +MGSH0_SX276 +MGSH0_SX6 +MGSH0_SX96 +MGSL0_SI1164 +MGSL0_SI534 +MGSL0_SI797 +MGSL0_SX174 +MGSL0_SX264 +MGSL0_SX354 +MGSL0_SX444 +MGSL0_SX84 +MGXP0_SI1087 +MGXP0_SI457 +MGXP0_SI525 +MGXP0_SX187 +MGXP0_SX277 +MGXP0_SX367 +MGXP0_SX7 +MGXP0_SX97 +MHBS0_SI1575 +MHBS0_SI2205 +MHBS0_SI945 +MHBS0_SX135 +MHBS0_SX225 +MHBS0_SX315 +MHBS0_SX405 +MHBS0_SX45 +MHIT0_SI1613 +MHIT0_SI2243 +MHIT0_SI983 +MHIT0_SX173 +MHIT0_SX263 +MHIT0_SX353 +MHIT0_SX443 +MHIT0_SX83 +MHJB0_SI1017 +MHJB0_SI1647 +MHJB0_SI2277 +MHJB0_SX117 +MHJB0_SX207 +MHJB0_SX27 +MHJB0_SX297 +MHJB0_SX387 +MHMG0_SI1365 +MHMG0_SI1995 +MHMG0_SI735 +MHMG0_SX105 +MHMG0_SX15 +MHMG0_SX195 +MHMG0_SX285 +MHMG0_SX375 +MHMR0_SI1119 +MHMR0_SI1692 +MHMR0_SI489 +MHMR0_SX129 +MHMR0_SX219 +MHMR0_SX309 +MHMR0_SX39 +MHMR0_SX399 +MHRM0_SI1475 +MHRM0_SI2218 +MHRM0_SI958 +MHRM0_SX148 +MHRM0_SX238 +MHRM0_SX328 +MHRM0_SX418 +MHRM0_SX58 +MHXL0_SI1772 +MHXL0_SI512 +MHXL0_SI612 +MHXL0_SX152 +MHXL0_SX242 +MHXL0_SX332 +MHXL0_SX422 +MHXL0_SX62 +MILB0_SI2163 +MILB0_SI807 +MILB0_SI903 +MILB0_SX183 +MILB0_SX273 +MILB0_SX3 +MILB0_SX363 +MILB0_SX93 +MJAC0_SI1331 +MJAC0_SI2148 +MJAC0_SI701 +MJAC0_SX251 +MJAC0_SX307 +MJAC0_SX341 +MJAC0_SX431 +MJAC0_SX71 +MJAE0_SI1524 +MJAE0_SI1999 +MJAE0_SI2154 +MJAE0_SX174 +MJAE0_SX264 +MJAE0_SX354 +MJAE0_SX444 +MJAE0_SX84 +MJAI0_SI1604 +MJAI0_SI682 +MJAI0_SI710 +MJAI0_SX164 +MJAI0_SX254 +MJAI0_SX344 +MJAI0_SX434 +MJAI0_SX74 +MJBG0_SI1232 +MJBG0_SI1724 +MJBG0_SI1862 +MJBG0_SX152 +MJBG0_SX242 +MJBG0_SX332 +MJBG0_SX422 +MJBG0_SX62 +MJDA0_SI1031 +MJDA0_SI1661 +MJDA0_SI2291 +MJDA0_SX131 +MJDA0_SX221 +MJDA0_SX311 +MJDA0_SX401 +MJDA0_SX41 +MJDC0_SI1161 +MJDC0_SI2165 +MJDC0_SI531 +MJDC0_SX171 +MJDC0_SX261 +MJDC0_SX351 +MJDC0_SX441 +MJDC0_SX81 +MJDE0_SI1120 +MJDE0_SI463 +MJDE0_SI490 +MJDE0_SX130 +MJDE0_SX220 +MJDE0_SX310 +MJDE0_SX40 +MJDE0_SX400 +MJDG0_SI1042 +MJDG0_SI1672 +MJDG0_SI1705 +MJDG0_SX142 +MJDG0_SX232 +MJDG0_SX322 +MJDG0_SX412 +MJDG0_SX52 +MJDM0_SI1340 +MJDM0_SI1937 +MJDM0_SI974 +MJDM0_SX170 +MJDM0_SX260 +MJDM0_SX350 +MJDM0_SX440 +MJDM0_SX80 +MJEB0_SI1286 +MJEB0_SI1916 +MJEB0_SI656 +MJEB0_SX170 +MJEB0_SX206 +MJEB0_SX26 +MJEB0_SX296 +MJEB0_SX386 +MJEB1_SI1467 +MJEB1_SI2097 +MJEB1_SI837 +MJEB1_SX117 +MJEB1_SX207 +MJEB1_SX27 +MJEB1_SX297 +MJEB1_SX387 +MJEE0_SI1237 +MJEE0_SI1867 +MJEE0_SI607 +MJEE0_SX157 +MJEE0_SX247 +MJEE0_SX337 +MJEE0_SX427 +MJEE0_SX67 +MJFH0_SI1107 +MJFH0_SI1737 +MJFH0_SI477 +MJFH0_SX117 +MJFH0_SX207 +MJFH0_SX27 +MJFH0_SX297 +MJFH0_SX387 +MJFR0_SI1605 +MJFR0_SI2235 +MJFR0_SI975 +MJFR0_SX165 +MJFR0_SX255 +MJFR0_SX345 +MJFR0_SX435 +MJFR0_SX75 +MJHI0_SI1328 +MJHI0_SI555 +MJHI0_SI698 +MJHI0_SX158 +MJHI0_SX248 +MJHI0_SX338 +MJHI0_SX428 +MJHI0_SX68 +MJJB0_SI1139 +MJJB0_SI1277 +MJJB0_SI1769 +MJJB0_SX149 +MJJB0_SX239 +MJJB0_SX329 +MJJB0_SX419 +MJJB0_SX59 +MJJJ0_SI1163 +MJJJ0_SI1793 +MJJJ0_SI533 +MJJJ0_SX173 +MJJJ0_SX263 +MJJJ0_SX353 +MJJJ0_SX443 +MJJJ0_SX83 +MJJM0_SI1251 +MJJM0_SI1457 +MJJM0_SI827 +MJJM0_SX107 +MJJM0_SX17 +MJJM0_SX197 +MJJM0_SX287 +MJJM0_SX377 +MJKR0_SI1201 +MJKR0_SI1831 +MJKR0_SI571 +MJKR0_SX121 +MJKR0_SX211 +MJKR0_SX301 +MJKR0_SX31 +MJKR0_SX391 +MJLB0_SI1616 +MJLB0_SI2246 +MJLB0_SI986 +MJLB0_SX176 +MJLB0_SX266 +MJLB0_SX356 +MJLB0_SX446 +MJLB0_SX86 +MJLG1_SI1012 +MJLG1_SI1642 +MJLG1_SI2272 +MJLG1_SX112 +MJLG1_SX202 +MJLG1_SX22 +MJLG1_SX292 +MJLG1_SX382 +MJLS0_SI1096 +MJLS0_SI1726 +MJLS0_SI466 +MJLS0_SX106 +MJLS0_SX16 +MJLS0_SX196 +MJLS0_SX286 +MJLS0_SX376 +MJMA0_SI1495 +MJMA0_SI2125 +MJMA0_SI865 +MJMA0_SX145 +MJMA0_SX235 +MJMA0_SX325 +MJMA0_SX415 +MJMA0_SX55 +MJMD0_SI1028 +MJMD0_SI1658 +MJMD0_SI2288 +MJMD0_SX128 +MJMD0_SX218 +MJMD0_SX308 +MJMD0_SX38 +MJMD0_SX398 +MJMM0_SI1255 +MJMM0_SI1885 +MJMM0_SI625 +MJMM0_SX175 +MJMM0_SX265 +MJMM0_SX355 +MJMM0_SX445 +MJMM0_SX85 +MJPG0_SI1191 +MJPG0_SI1821 +MJPG0_SI561 +MJPG0_SX111 +MJPG0_SX201 +MJPG0_SX21 +MJPG0_SX291 +MJPG0_SX381 +MJPM0_SI1368 +MJPM0_SI1998 +MJPM0_SI738 +MJPM0_SX108 +MJPM0_SX18 +MJPM0_SX198 +MJPM0_SX288 +MJPM0_SX378 +MJPM1_SI1897 +MJPM1_SI2280 +MJPM1_SI761 +MJPM1_SX131 +MJPM1_SX221 +MJPM1_SX311 +MJPM1_SX401 +MJPM1_SX41 +MJRA0_SI1236 +MJRA0_SI1866 +MJRA0_SI606 +MJRA0_SX156 +MJRA0_SX246 +MJRA0_SX336 +MJRA0_SX426 +MJRA0_SX66 +MJRG0_SI1366 +MJRG0_SI1996 +MJRG0_SI736 +MJRG0_SX106 +MJRG0_SX16 +MJRG0_SX286 +MJRG0_SX352 +MJRG0_SX376 +MJRH0_SI1125 +MJRH0_SI1755 +MJRH0_SI1840 +MJRH0_SX135 +MJRH0_SX225 +MJRH0_SX315 +MJRH0_SX405 +MJRH0_SX45 +MJRH1_SI1558 +MJRH1_SI1774 +MJRH1_SI514 +MJRH1_SX154 +MJRH1_SX244 +MJRH1_SX334 +MJRH1_SX424 +MJRH1_SX64 +MJRK0_SI1662 +MJRK0_SI2103 +MJRK0_SI880 +MJRK0_SX160 +MJRK0_SX250 +MJRK0_SX340 +MJRK0_SX430 +MJRK0_SX70 +MJRP0_SI1835 +MJRP0_SI1845 +MJRP0_SI585 +MJRP0_SX135 +MJRP0_SX225 +MJRP0_SX315 +MJRP0_SX405 +MJRP0_SX45 +MJSR0_SI1424 +MJSR0_SI2054 +MJSR0_SI794 +MJSR0_SX164 +MJSR0_SX254 +MJSR0_SX344 +MJSR0_SX434 +MJSR0_SX74 +MJWG0_SI2155 +MJWG0_SI813 +MJWG0_SI895 +MJWG0_SX175 +MJWG0_SX265 +MJWG0_SX355 +MJWG0_SX445 +MJWG0_SX85 +MJWS0_SI1143 +MJWS0_SI1773 +MJWS0_SI513 +MJWS0_SX153 +MJWS0_SX243 +MJWS0_SX333 +MJWS0_SX423 +MJWS0_SX63 +MJWT0_SI1291 +MJWT0_SI1381 +MJWT0_SI751 +MJWT0_SX121 +MJWT0_SX211 +MJWT0_SX301 +MJWT0_SX31 +MJWT0_SX391 +MJXA0_SI1507 +MJXA0_SI2137 +MJXA0_SI877 +MJXA0_SX157 +MJXA0_SX247 +MJXA0_SX337 +MJXA0_SX427 +MJXA0_SX67 +MJXL0_SI1172 +MJXL0_SI1795 +MJXL0_SI542 +MJXL0_SX182 +MJXL0_SX272 +MJXL0_SX362 +MJXL0_SX452 +MJXL0_SX92 +MKAG0_SI1609 +MKAG0_SI2239 +MKAG0_SI979 +MKAG0_SX169 +MKAG0_SX259 +MKAG0_SX30 +MKAG0_SX439 +MKAG0_SX79 +MKAH0_SI1528 +MKAH0_SI2158 +MKAH0_SI898 +MKAH0_SX178 +MKAH0_SX268 +MKAH0_SX358 +MKAH0_SX448 +MKAH0_SX88 +MKAJ0_SI1414 +MKAJ0_SI2044 +MKAJ0_SI784 +MKAJ0_SX154 +MKAJ0_SX244 +MKAJ0_SX334 +MKAJ0_SX424 +MKAJ0_SX64 +MKAM0_SI1250 +MKAM0_SI1316 +MKAM0_SI1465 +MKAM0_SX146 +MKAM0_SX236 +MKAM0_SX326 +MKAM0_SX416 +MKAM0_SX56 +MKDB0_SI2132 +MKDB0_SI588 +MKDB0_SI872 +MKDB0_SX152 +MKDB0_SX242 +MKDB0_SX332 +MKDB0_SX422 +MKDB0_SX62 +MKDD0_SI1567 +MKDD0_SI2197 +MKDD0_SI937 +MKDD0_SX127 +MKDD0_SX217 +MKDD0_SX307 +MKDD0_SX37 +MKDD0_SX397 +MKDT0_SI2153 +MKDT0_SI814 +MKDT0_SI893 +MKDT0_SX173 +MKDT0_SX263 +MKDT0_SX353 +MKDT0_SX443 +MKDT0_SX83 +MKES0_SI1253 +MKES0_SI1883 +MKES0_SI623 +MKES0_SX173 +MKES0_SX263 +MKES0_SX353 +MKES0_SX443 +MKES0_SX83 +MKJO0_SI1517 +MKJO0_SI2147 +MKJO0_SI887 +MKJO0_SX167 +MKJO0_SX257 +MKJO0_SX424 +MKJO0_SX437 +MKJO0_SX77 +MKLN0_SI1598 +MKLN0_SI2228 +MKLN0_SI968 +MKLN0_SX158 +MKLN0_SX248 +MKLN0_SX338 +MKLN0_SX428 +MKLN0_SX68 +MKLR0_SI1059 +MKLR0_SI1689 +MKLR0_SI2319 +MKLR0_SX159 +MKLR0_SX249 +MKLR0_SX339 +MKLR0_SX429 +MKLR0_SX69 +MKLS0_SI1437 +MKLS0_SI1533 +MKLS0_SI2067 +MKLS0_SX177 +MKLS0_SX267 +MKLS0_SX357 +MKLS0_SX447 +MKLS0_SX87 +MKLS1_SI1545 +MKLS1_SI2175 +MKLS1_SI915 +MKLS1_SX105 +MKLS1_SX15 +MKLS1_SX195 +MKLS1_SX285 +MKLS1_SX375 +MKLW0_SI1571 +MKLW0_SI1844 +MKLW0_SI2201 +MKLW0_SX131 +MKLW0_SX221 +MKLW0_SX311 +MKLW0_SX401 +MKLW0_SX41 +MKRG0_SI1491 +MKRG0_SI2121 +MKRG0_SI861 +MKRG0_SX141 +MKRG0_SX231 +MKRG0_SX31 +MKRG0_SX411 +MKRG0_SX51 +MKXL0_SI1185 +MKXL0_SI1815 +MKXL0_SI1958 +MKXL0_SX105 +MKXL0_SX15 +MKXL0_SX195 +MKXL0_SX285 +MKXL0_SX375 +MLBC0_SI1239 +MLBC0_SI1869 +MLBC0_SI609 +MLBC0_SX159 +MLBC0_SX249 +MLBC0_SX339 +MLBC0_SX429 +MLBC0_SX69 +MLEL0_SI1246 +MLEL0_SI1876 +MLEL0_SI616 +MLEL0_SX166 +MLEL0_SX256 +MLEL0_SX346 +MLEL0_SX436 +MLEL0_SX76 +MLJC0_SI1225 +MLJC0_SI1855 +MLJC0_SI595 +MLJC0_SX145 +MLJC0_SX235 +MLJC0_SX325 +MLJC0_SX415 +MLJC0_SX55 +MLJH0_SI1324 +MLJH0_SI1422 +MLJH0_SI694 +MLJH0_SX154 +MLJH0_SX244 +MLJH0_SX334 +MLJH0_SX424 +MLJH0_SX64 +MLNS0_SI1407 +MLNS0_SI2037 +MLNS0_SI777 +MLNS0_SX147 +MLNS0_SX237 +MLNS0_SX327 +MLNS0_SX417 +MLNS0_SX57 +MLSH0_SI1417 +MLSH0_SI2047 +MLSH0_SI787 +MLSH0_SX157 +MLSH0_SX247 +MLSH0_SX337 +MLSH0_SX427 +MLSH0_SX67 +MMAA0_SI1588 +MMAA0_SI2105 +MMAA0_SI845 +MMAA0_SX125 +MMAA0_SX215 +MMAA0_SX305 +MMAA0_SX35 +MMAA0_SX395 +MMAB1_SI1494 +MMAB1_SI2124 +MMAB1_SI864 +MMAB1_SX144 +MMAB1_SX234 +MMAB1_SX324 +MMAB1_SX414 +MMAB1_SX54 +MMAG0_SI1126 +MMAG0_SI1756 +MMAG0_SI496 +MMAG0_SX136 +MMAG0_SX226 +MMAG0_SX316 +MMAG0_SX406 +MMAG0_SX46 +MMAM0_SI1597 +MMAM0_SI1668 +MMAM0_SI2227 +MMAM0_SX157 +MMAM0_SX247 +MMAM0_SX337 +MMAM0_SX427 +MMAM0_SX67 +MMAR0_SI1336 +MMAR0_SI1966 +MMAR0_SI706 +MMAR0_SX166 +MMAR0_SX256 +MMAR0_SX346 +MMAR0_SX436 +MMAR0_SX76 +MMBS0_SI1151 +MMBS0_SI1781 +MMBS0_SI521 +MMBS0_SX161 +MMBS0_SX251 +MMBS0_SX341 +MMBS0_SX431 +MMBS0_SX71 +MMCC0_SI1338 +MMCC0_SI1968 +MMCC0_SI708 +MMCC0_SX168 +MMCC0_SX258 +MMCC0_SX348 +MMCC0_SX438 +MMCC0_SX78 +MMDB0_SI1358 +MMDB0_SI1617 +MMDB0_SI987 +MMDB0_SX177 +MMDB0_SX267 +MMDB0_SX357 +MMDB0_SX447 +MMDB0_SX87 +MMDG0_SI1780 +MMDG0_SI2035 +MMDG0_SI520 +MMDG0_SX160 +MMDG0_SX250 +MMDG0_SX340 +MMDG0_SX430 +MMDG0_SX70 +MMDM0_SI1311 +MMDM0_SI1941 +MMDM0_SI681 +MMDM0_SX141 +MMDM0_SX231 +MMDM0_SX321 +MMDM0_SX411 +MMDM0_SX51 +MMDM1_SI1650 +MMDM1_SI2043 +MMDM1_SI783 +MMDM1_SX153 +MMDM1_SX243 +MMDM1_SX333 +MMDM1_SX423 +MMDM1_SX63 +MMDS0_SI1343 +MMDS0_SI1973 +MMDS0_SI713 +MMDS0_SX173 +MMDS0_SX263 +MMDS0_SX353 +MMDS0_SX443 +MMDS0_SX83 +MMEA0_SI1388 +MMEA0_SI2018 +MMEA0_SI758 +MMEA0_SX128 +MMEA0_SX218 +MMEA0_SX308 +MMEA0_SX38 +MMEA0_SX398 +MMEB0_SI1357 +MMEB0_SI1987 +MMEB0_SI727 +MMEB0_SX187 +MMEB0_SX327 +MMEB0_SX367 +MMEB0_SX7 +MMEB0_SX97 +MMGC0_SI1305 +MMGC0_SI1935 +MMGC0_SI2184 +MMGC0_SX135 +MMGC0_SX225 +MMGC0_SX315 +MMGC0_SX405 +MMGC0_SX45 +MMGG0_SI1079 +MMGG0_SI1709 +MMGG0_SI2339 +MMGG0_SX179 +MMGG0_SX269 +MMGG0_SX359 +MMGG0_SX449 +MMGG0_SX89 +MMGK0_SI1322 +MMGK0_SI1952 +MMGK0_SI692 +MMGK0_SX152 +MMGK0_SX242 +MMGK0_SX332 +MMGK0_SX422 +MMGK0_SX62 +MMJB1_SI1408 +MMJB1_SI2038 +MMJB1_SI778 +MMJB1_SX148 +MMJB1_SX238 +MMJB1_SX328 +MMJB1_SX418 +MMJB1_SX58 +MMLM0_SI1527 +MMLM0_SI2150 +MMLM0_SI897 +MMLM0_SX177 +MMLM0_SX267 +MMLM0_SX357 +MMLM0_SX447 +MMLM0_SX87 +MMPM0_SI1061 +MMPM0_SI1691 +MMPM0_SI2321 +MMPM0_SX161 +MMPM0_SX251 +MMPM0_SX341 +MMPM0_SX431 +MMPM0_SX71 +MMRP0_SI2034 +MMRP0_SI717 +MMRP0_SI774 +MMRP0_SX144 +MMRP0_SX234 +MMRP0_SX324 +MMRP0_SX414 +MMRP0_SX54 +MMSM0_SI1106 +MMSM0_SI1736 +MMSM0_SI476 +MMSM0_SX116 +MMSM0_SX206 +MMSM0_SX26 +MMSM0_SX296 +MMSM0_SX386 +MMVP0_SI1284 +MMVP0_SI1914 +MMVP0_SI654 +MMVP0_SX114 +MMVP0_SX204 +MMVP0_SX294 +MMVP0_SX347 +MMVP0_SX384 +MMWB0_SI1619 +MMWB0_SI2249 +MMWB0_SI989 +MMWB0_SX179 +MMWB0_SX269 +MMWB0_SX359 +MMWB0_SX449 +MMWB0_SX89 +MMWS0_SI1518 +MMWS0_SI559 +MMWS0_SI888 +MMWS0_SX168 +MMWS0_SX258 +MMWS0_SX348 +MMWS0_SX438 +MMWS0_SX78 +MMWS1_SI1071 +MMWS1_SI1701 +MMWS1_SI2331 +MMWS1_SX261 +MMWS1_SX27 +MMWS1_SX351 +MMWS1_SX441 +MMWS1_SX81 +MMXS0_SI2136 +MMXS0_SI629 +MMXS0_SI876 +MMXS0_SX156 +MMXS0_SX246 +MMXS0_SX336 +MMXS0_SX426 +MMXS0_SX66 +MNET0_SI1446 +MNET0_SI2076 +MNET0_SI816 +MNET0_SX186 +MNET0_SX276 +MNET0_SX366 +MNET0_SX6 +MNET0_SX96 +MNTW0_SI1068 +MNTW0_SI1698 +MNTW0_SI2328 +MNTW0_SX168 +MNTW0_SX202 +MNTW0_SX258 +MNTW0_SX348 +MNTW0_SX78 +MPAR0_SI1576 +MPAR0_SI2206 +MPAR0_SI946 +MPAR0_SX136 +MPAR0_SX226 +MPAR0_SX316 +MPAR0_SX406 +MPAR0_SX46 +MPEB0_SI1034 +MPEB0_SI1860 +MPEB0_SI600 +MPEB0_SX150 +MPEB0_SX240 +MPEB0_SX330 +MPEB0_SX420 +MPEB0_SX60 +MPFU0_SI1258 +MPFU0_SI1888 +MPFU0_SI628 +MPFU0_SX178 +MPFU0_SX268 +MPFU0_SX358 +MPFU0_SX448 +MPFU0_SX88 +MPGH0_SI1554 +MPGH0_SI675 +MPGH0_SI924 +MPGH0_SX114 +MPGH0_SX204 +MPGH0_SX24 +MPGH0_SX294 +MPGH0_SX384 +MPGR0_SI1410 +MPGR0_SI2040 +MPGR0_SI780 +MPGR0_SX150 +MPGR0_SX240 +MPGR0_SX330 +MPGR0_SX420 +MPGR0_SX60 +MPGR1_SI1269 +MPGR1_SI1499 +MPGR1_SI2129 +MPGR1_SX149 +MPGR1_SX239 +MPGR1_SX329 +MPGR1_SX419 +MPGR1_SX59 +MPMB0_SI1501 +MPMB0_SI2131 +MPMB0_SI871 +MPMB0_SX151 +MPMB0_SX241 +MPMB0_SX331 +MPMB0_SX421 +MPMB0_SX61 +MPPC0_SI1412 +MPPC0_SI2042 +MPPC0_SI782 +MPPC0_SX152 +MPPC0_SX242 +MPPC0_SX332 +MPPC0_SX422 +MPPC0_SX62 +MPRB0_SI1205 +MPRB0_SI1215 +MPRB0_SI575 +MPRB0_SX125 +MPRB0_SX215 +MPRB0_SX305 +MPRB0_SX35 +MPRB0_SX395 +MPRD0_SI1431 +MPRD0_SI2061 +MPRD0_SI801 +MPRD0_SX171 +MPRD0_SX261 +MPRD0_SX351 +MPRD0_SX441 +MPRD0_SX81 +MPRK0_SI1097 +MPRK0_SI1727 +MPRK0_SI467 +MPRK0_SX107 +MPRK0_SX17 +MPRK0_SX197 +MPRK0_SX287 +MPRK0_SX377 +MPRT0_SI1210 +MPRT0_SI495 +MPRT0_SI580 +MPRT0_SX130 +MPRT0_SX220 +MPRT0_SX310 +MPRT0_SX40 +MPRT0_SX400 +MPSW0_SI1067 +MPSW0_SI1697 +MPSW0_SI2327 +MPSW0_SX167 +MPSW0_SX24 +MPSW0_SX257 +MPSW0_SX437 +MPSW0_SX77 +MRAB0_SI1224 +MRAB0_SI1854 +MRAB0_SI594 +MRAB0_SX144 +MRAB0_SX234 +MRAB0_SX324 +MRAB0_SX414 +MRAB0_SX54 +MRAB1_SI1478 +MRAB1_SI2108 +MRAB1_SI848 +MRAB1_SX128 +MRAB1_SX218 +MRAB1_SX308 +MRAB1_SX38 +MRAB1_SX398 +MRAI0_SI1954 +MRAI0_SI2052 +MRAI0_SI792 +MRAI0_SX162 +MRAI0_SX252 +MRAI0_SX342 +MRAI0_SX432 +MRAI0_SX72 +MRAM0_SI1275 +MRAM0_SI1905 +MRAM0_SI1951 +MRAM0_SX105 +MRAM0_SX15 +MRAM0_SX195 +MRAM0_SX285 +MRAM0_SX375 +MRAV0_SI1008 +MRAV0_SI1638 +MRAV0_SI2268 +MRAV0_SX108 +MRAV0_SX18 +MRAV0_SX198 +MRAV0_SX288 +MRAV0_SX378 +MRBC0_SI1665 +MRBC0_SI1859 +MRBC0_SI599 +MRBC0_SX149 +MRBC0_SX239 +MRBC0_SX329 +MRBC0_SX419 +MRBC0_SX59 +MRCG0_SI1428 +MRCG0_SI2058 +MRCG0_SI798 +MRCG0_SX168 +MRCG0_SX258 +MRCG0_SX348 +MRCG0_SX438 +MRCG0_SX78 +MRCW0_SI1371 +MRCW0_SI2001 +MRCW0_SI741 +MRCW0_SX111 +MRCW0_SX201 +MRCW0_SX21 +MRCW0_SX291 +MRCW0_SX381 +MRDD0_SI1050 +MRDD0_SI1680 +MRDD0_SI2310 +MRDD0_SX150 +MRDD0_SX240 +MRDD0_SX277 +MRDD0_SX330 +MRDD0_SX60 +MRDM0_SI1044 +MRDM0_SI1595 +MRDM0_SI965 +MRDM0_SX155 +MRDM0_SX245 +MRDM0_SX335 +MRDM0_SX425 +MRDM0_SX65 +MRDS0_SI1167 +MRDS0_SI1797 +MRDS0_SI537 +MRDS0_SX177 +MRDS0_SX267 +MRDS0_SX357 +MRDS0_SX447 +MRDS0_SX87 +MREE0_SI1104 +MREE0_SI1734 +MREE0_SI1959 +MREE0_SX114 +MREE0_SX204 +MREE0_SX24 +MREE0_SX294 +MREE0_SX384 +MREH1_SI1599 +MREH1_SI2229 +MREH1_SI969 +MREH1_SX159 +MREH1_SX249 +MREH1_SX339 +MREH1_SX429 +MREH1_SX69 +MREM0_SI1591 +MREM0_SI511 +MREM0_SI961 +MREM0_SX151 +MREM0_SX241 +MREM0_SX331 +MREM0_SX421 +MREM0_SX61 +MREW1_SI1500 +MREW1_SI2130 +MREW1_SI870 +MREW1_SX150 +MREW1_SX240 +MREW1_SX330 +MREW1_SX420 +MREW1_SX60 +MRFK0_SI1076 +MRFK0_SI1706 +MRFK0_SI2336 +MRFK0_SX176 +MRFK0_SX266 +MRFK0_SX356 +MRFK0_SX446 +MRFK0_SX86 +MRFL0_SI1156 +MRFL0_SI1786 +MRFL0_SI526 +MRFL0_SX166 +MRFL0_SX256 +MRFL0_SX346 +MRFL0_SX436 +MRFL0_SX76 +MRGM0_SI1162 +MRGM0_SI1792 +MRGM0_SI532 +MRGM0_SX172 +MRGM0_SX262 +MRGM0_SX416 +MRGM0_SX442 +MRGM0_SX82 +MRGS0_SI1356 +MRGS0_SI1986 +MRGS0_SI726 +MRGS0_SX186 +MRGS0_SX276 +MRGS0_SX366 +MRGS0_SX6 +MRGS0_SX96 +MRHL0_SI1515 +MRHL0_SI2145 +MRHL0_SI885 +MRHL0_SX165 +MRHL0_SX255 +MRHL0_SX345 +MRHL0_SX435 +MRHL0_SX75 +MRJB1_SI1020 +MRJB1_SI1413 +MRJB1_SI2021 +MRJB1_SX120 +MRJB1_SX210 +MRJB1_SX30 +MRJB1_SX300 +MRJB1_SX390 +MRJH0_SI1519 +MRJH0_SI889 +MRJH0_SI914 +MRJH0_SX169 +MRJH0_SX259 +MRJH0_SX307 +MRJH0_SX439 +MRJH0_SX79 +MRJM0_SI1095 +MRJM0_SI1228 +MRJM0_SI1858 +MRJM0_SX148 +MRJM0_SX238 +MRJM0_SX328 +MRJM0_SX418 +MRJM0_SX58 +MRJM1_SI1298 +MRJM1_SI1928 +MRJM1_SI668 +MRJM1_SX128 +MRJM1_SX218 +MRJM1_SX308 +MRJM1_SX38 +MRJM1_SX398 +MRJT0_SI1498 +MRJT0_SI1805 +MRJT0_SI868 +MRJT0_SX148 +MRJT0_SX238 +MRJT0_SX328 +MRJT0_SX418 +MRJT0_SX58 +MRKM0_SI1267 +MRKM0_SI1391 +MRKM0_SI637 +MRKM0_SX187 +MRKM0_SX277 +MRKM0_SX367 +MRKM0_SX7 +MRKM0_SX97 +MRLD0_SI1594 +MRLD0_SI2224 +MRLD0_SI964 +MRLD0_SX154 +MRLD0_SX244 +MRLD0_SX334 +MRLD0_SX424 +MRLD0_SX64 +MRLJ0_SI1420 +MRLJ0_SI2050 +MRLJ0_SI790 +MRLJ0_SX160 +MRLJ0_SX250 +MRLJ0_SX340 +MRLJ0_SX430 +MRLJ0_SX70 +MRLJ1_SI1671 +MRLJ1_SI2301 +MRLJ1_SI2332 +MRLJ1_SX141 +MRLJ1_SX231 +MRLJ1_SX321 +MRLJ1_SX411 +MRLJ1_SX51 +MRLK0_SI1468 +MRLK0_SI2140 +MRLK0_SI843 +MRLK0_SX123 +MRLK0_SX213 +MRLK0_SX303 +MRLK0_SX33 +MRLK0_SX393 +MRLR0_SI1196 +MRLR0_SI1826 +MRLR0_SI566 +MRLR0_SX116 +MRLR0_SX206 +MRLR0_SX26 +MRLR0_SX296 +MRLR0_SX386 +MRMB0_SI1581 +MRMB0_SI2211 +MRMB0_SI951 +MRMB0_SX141 +MRMB0_SX231 +MRMB0_SX321 +MRMB0_SX411 +MRMB0_SX51 +MRMG0_SI1080 +MRMG0_SI1710 +MRMG0_SI2340 +MRMG0_SX180 +MRMG0_SX270 +MRMG0_SX360 +MRMG0_SX450 +MRMG0_SX90 +MRMH0_SI1021 +MRMH0_SI1349 +MRMH0_SI2281 +MRMH0_SX121 +MRMH0_SX211 +MRMH0_SX301 +MRMH0_SX31 +MRMH0_SX391 +MRML0_SI1421 +MRML0_SI2051 +MRML0_SI791 +MRML0_SX161 +MRML0_SX251 +MRML0_SX341 +MRML0_SX431 +MRML0_SX71 +MRMS0_SI1113 +MRMS0_SI2057 +MRMS0_SI2100 +MRMS0_SX120 +MRMS0_SX210 +MRMS0_SX30 +MRMS0_SX300 +MRMS0_SX390 +MRPC1_SI1482 +MRPC1_SI2026 +MRPC1_SI2112 +MRPC1_SX132 +MRPC1_SX222 +MRPC1_SX312 +MRPC1_SX402 +MRPC1_SX42 +MRRE0_SI1334 +MRRE0_SI704 +MRRE0_SI952 +MRRE0_SX164 +MRRE0_SX254 +MRRE0_SX344 +MRRE0_SX434 +MRRE0_SX74 +MRSO0_SI1206 +MRSO0_SI1659 +MRSO0_SI2289 +MRSO0_SX129 +MRSO0_SX219 +MRSO0_SX309 +MRSO0_SX39 +MRSO0_SX399 +MRSP0_SI1429 +MRSP0_SI2059 +MRSP0_SI799 +MRSP0_SX169 +MRSP0_SX196 +MRSP0_SX259 +MRSP0_SX439 +MRSP0_SX79 +MRTC0_SI1458 +MRTC0_SI2088 +MRTC0_SI828 +MRTC0_SX108 +MRTC0_SX18 +MRTC0_SX198 +MRTC0_SX288 +MRTC0_SX378 +MRTJ0_SI1551 +MRTJ0_SI2032 +MRTJ0_SI772 +MRTJ0_SX142 +MRTJ0_SX232 +MRTJ0_SX322 +MRTJ0_SX412 +MRTJ0_SX52 +MRVG0_SI1140 +MRVG0_SI1770 +MRVG0_SI510 +MRVG0_SX150 +MRVG0_SX240 +MRVG0_SX330 +MRVG0_SX420 +MRVG0_SX60 +MRWA0_SI1603 +MRWA0_SI2233 +MRWA0_SI973 +MRWA0_SX163 +MRWA0_SX253 +MRWA0_SX343 +MRWA0_SX433 +MRWA0_SX73 +MRWS0_SI1102 +MRWS0_SI1732 +MRWS0_SI472 +MRWS0_SX112 +MRWS0_SX202 +MRWS0_SX22 +MRWS0_SX292 +MRWS0_SX382 +MRXB0_SI1585 +MRXB0_SI2215 +MRXB0_SI955 +MRXB0_SX145 +MRXB0_SX235 +MRXB0_SX325 +MRXB0_SX415 +MRXB0_SX55 +MSAH1_SI1049 +MSAH1_SI1679 +MSAH1_SI2309 +MSAH1_SX149 +MSAH1_SX239 +MSAH1_SX329 +MSAH1_SX419 +MSAH1_SX59 +MSAS0_SI1376 +MSAS0_SI2006 +MSAS0_SI746 +MSAS0_SX116 +MSAS0_SX206 +MSAS0_SX26 +MSAS0_SX296 +MSAS0_SX386 +MSAT0_SI1526 +MSAT0_SI2156 +MSAT0_SI896 +MSAT0_SX176 +MSAT0_SX266 +MSAT0_SX356 +MSAT0_SX446 +MSAT0_SX86 +MSAT1_SI1073 +MSAT1_SI1703 +MSAT1_SI2333 +MSAT1_SX173 +MSAT1_SX263 +MSAT1_SX353 +MSAT1_SX443 +MSAT1_SX83 +MSDB0_SI1007 +MSDB0_SI1637 +MSDB0_SI2267 +MSDB0_SX107 +MSDB0_SX17 +MSDB0_SX197 +MSDB0_SX287 +MSDB0_SX377 +MSDH0_SI2113 +MSDH0_SI2240 +MSDH0_SI980 +MSDH0_SX170 +MSDH0_SX260 +MSDH0_SX350 +MSDH0_SX440 +MSDH0_SX80 +MSDS0_SI1077 +MSDS0_SI1707 +MSDS0_SI2337 +MSDS0_SX177 +MSDS0_SX267 +MSDS0_SX357 +MSDS0_SX447 +MSDS0_SX87 +MSEM1_SI1440 +MSEM1_SI2070 +MSEM1_SI810 +MSEM1_SX180 +MSEM1_SX270 +MSEM1_SX360 +MSEM1_SX450 +MSEM1_SX90 +MSES0_SI1589 +MSES0_SI2216 +MSES0_SI2219 +MSES0_SX149 +MSES0_SX239 +MSES0_SX329 +MSES0_SX419 +MSES0_SX59 +MSFH0_SI1216 +MSFH0_SI1738 +MSFH0_SI586 +MSFH0_SX136 +MSFH0_SX226 +MSFH0_SX316 +MSFH0_SX406 +MSFH0_SX46 +MSFV0_SI1262 +MSFV0_SI1892 +MSFV0_SI632 +MSFV0_SX182 +MSFV0_SX272 +MSFV0_SX362 +MSFV0_SX452 +MSFV0_SX92 +MSJK0_SI1596 +MSJK0_SI2226 +MSJK0_SI966 +MSJK0_SX156 +MSJK0_SX246 +MSJK0_SX336 +MSJK0_SX426 +MSJK0_SX66 +MSMC0_SI1907 +MSMC0_SI509 +MSMC0_SI647 +MSMC0_SX107 +MSMC0_SX17 +MSMC0_SX197 +MSMC0_SX287 +MSMC0_SX377 +MSMR0_SI1150 +MSMR0_SI1405 +MSMR0_SI775 +MSMR0_SX145 +MSMR0_SX235 +MSMR0_SX325 +MSMR0_SX415 +MSMR0_SX55 +MSMS0_SI1433 +MSMS0_SI2063 +MSMS0_SI803 +MSMS0_SX173 +MSMS0_SX263 +MSMS0_SX353 +MSMS0_SX443 +MSMS0_SX83 +MSRG0_SI1221 +MSRG0_SI1851 +MSRG0_SI591 +MSRG0_SX141 +MSRG0_SX231 +MSRG0_SX321 +MSRG0_SX411 +MSRG0_SX51 +MSRR0_SI1131 +MSRR0_SI1761 +MSRR0_SI501 +MSRR0_SX141 +MSRR0_SX231 +MSRR0_SX30 +MSRR0_SX411 +MSRR0_SX51 +MSTF0_SI1396 +MSTF0_SI766 +MSTF0_SI852 +MSTF0_SX136 +MSTF0_SX226 +MSTF0_SX316 +MSTF0_SX406 +MSTF0_SX46 +MSVS0_SI1568 +MSVS0_SI2198 +MSVS0_SI938 +MSVS0_SX128 +MSVS0_SX218 +MSVS0_SX308 +MSVS0_SX38 +MSVS0_SX398 +MTAB0_SI1572 +MTAB0_SI2202 +MTAB0_SI942 +MTAB0_SX132 +MTAB0_SX222 +MTAB0_SX312 +MTAB0_SX402 +MTAB0_SX42 +MTAS0_SI1385 +MTAS0_SI2015 +MTAS0_SI755 +MTAS0_SX125 +MTAS0_SX215 +MTAS0_SX305 +MTAS0_SX35 +MTAS0_SX395 +MTAT0_SI1110 +MTAT0_SI1740 +MTAT0_SI811 +MTAT0_SX120 +MTAT0_SX210 +MTAT0_SX30 +MTAT0_SX300 +MTAT0_SX390 +MTAT1_SI1409 +MTAT1_SI1627 +MTAT1_SI779 +MTAT1_SX149 +MTAT1_SX239 +MTAT1_SX329 +MTAT1_SX419 +MTAT1_SX59 +MTBC0_SI1173 +MTBC0_SI1803 +MTBC0_SI543 +MTBC0_SX183 +MTBC0_SX273 +MTBC0_SX347 +MTBC0_SX363 +MTBC0_SX93 +MTCS0_SI1972 +MTCS0_SI2265 +MTCS0_SI712 +MTCS0_SX172 +MTCS0_SX262 +MTCS0_SX352 +MTCS0_SX442 +MTCS0_SX82 +MTDB0_SI1401 +MTDB0_SI2031 +MTDB0_SI771 +MTDB0_SX141 +MTDB0_SX231 +MTDB0_SX321 +MTDB0_SX411 +MTDB0_SX51 +MTDP0_SI1274 +MTDP0_SI1521 +MTDP0_SI2151 +MTDP0_SX171 +MTDP0_SX261 +MTDP0_SX351 +MTDP0_SX441 +MTDP0_SX81 +MTER0_SI1157 +MTER0_SI1787 +MTER0_SI527 +MTER0_SX167 +MTER0_SX17 +MTER0_SX257 +MTER0_SX437 +MTER0_SX77 +MTJG0_SI1520 +MTJG0_SI2157 +MTJG0_SI890 +MTJG0_SX170 +MTJG0_SX260 +MTJG0_SX350 +MTJG0_SX440 +MTJG0_SX80 +MTJM0_SI1226 +MTJM0_SI1856 +MTJM0_SI655 +MTJM0_SX146 +MTJM0_SX236 +MTJM0_SX326 +MTJM0_SX416 +MTJM0_SX56 +MTJS0_SI1192 +MTJS0_SI1822 +MTJS0_SI562 +MTJS0_SX112 +MTJS0_SX202 +MTJS0_SX22 +MTJS0_SX292 +MTJS0_SX382 +MTJU0_SI2020 +MTJU0_SI2269 +MTJU0_SI760 +MTJU0_SX130 +MTJU0_SX220 +MTJU0_SX310 +MTJU0_SX40 +MTJU0_SX400 +MTKD0_SI1187 +MTKD0_SI1817 +MTKD0_SI630 +MTKD0_SX107 +MTKD0_SX17 +MTKD0_SX197 +MTKD0_SX287 +MTKD0_SX377 +MTKP0_SI1023 +MTKP0_SI2283 +MTKP0_SI454 +MTKP0_SX123 +MTKP0_SX213 +MTKP0_SX303 +MTKP0_SX33 +MTKP0_SX393 +MTLB0_SI1134 +MTLB0_SI1764 +MTLB0_SI504 +MTLB0_SX144 +MTLB0_SX234 +MTLB0_SX324 +MTLB0_SX414 +MTLB0_SX54 +MTLC0_SI1313 +MTLC0_SI1477 +MTLC0_SI847 +MTLC0_SX127 +MTLC0_SX217 +MTLC0_SX307 +MTLC0_SX37 +MTLC0_SX397 +MTML0_SI1065 +MTML0_SI1695 +MTML0_SI2325 +MTML0_SX165 +MTML0_SX255 +MTML0_SX345 +MTML0_SX435 +MTML0_SX75 +MTMN0_SI1064 +MTMN0_SI2324 +MTMN0_SI582 +MTMN0_SX164 +MTMN0_SX254 +MTMN0_SX344 +MTMN0_SX434 +MTMN0_SX74 +MTMT0_SI1118 +MTMT0_SI1748 +MTMT0_SI488 +MTMT0_SX128 +MTMT0_SX218 +MTMT0_SX308 +MTMT0_SX38 +MTMT0_SX398 +MTPF0_SI1235 +MTPF0_SI1865 +MTPF0_SI605 +MTPF0_SX155 +MTPF0_SX245 +MTPF0_SX335 +MTPF0_SX425 +MTPF0_SX65 +MTPG0_SI1383 +MTPG0_SI2013 +MTPG0_SI753 +MTPG0_SX123 +MTPG0_SX213 +MTPG0_SX303 +MTPG0_SX33 +MTPG0_SX393 +MTPP0_SI1508 +MTPP0_SI2138 +MTPP0_SI878 +MTPP0_SX158 +MTPP0_SX248 +MTPP0_SX338 +MTPP0_SX428 +MTPP0_SX68 +MTPR0_SI1600 +MTPR0_SI2230 +MTPR0_SI506 +MTPR0_SX160 +MTPR0_SX250 +MTPR0_SX340 +MTPR0_SX430 +MTPR0_SX70 +MTQC0_SI1441 +MTQC0_SI2071 +MTQC0_SI480 +MTQC0_SX181 +MTQC0_SX271 +MTQC0_SX361 +MTQC0_SX451 +MTQC0_SX91 +MTRC0_SI1623 +MTRC0_SI589 +MTRC0_SI993 +MTRC0_SX170 +MTRC0_SX183 +MTRC0_SX273 +MTRC0_SX363 +MTRC0_SX93 +MTRR0_SI1548 +MTRR0_SI2178 +MTRR0_SI918 +MTRR0_SX108 +MTRR0_SX18 +MTRR0_SX198 +MTRR0_SX288 +MTRR0_SX378 +MTRT0_SI1227 +MTRT0_SI1857 +MTRT0_SI597 +MTRT0_SX147 +MTRT0_SX237 +MTRT0_SX254 +MTRT0_SX417 +MTRT0_SX57 +MTWH1_SI1512 +MTWH1_SI2142 +MTWH1_SI882 +MTWH1_SX162 +MTWH1_SX252 +MTWH1_SX342 +MTWH1_SX432 +MTWH1_SX72 +MTXS0_SI1060 +MTXS0_SI1690 +MTXS0_SI2320 +MTXS0_SX160 +MTXS0_SX250 +MTXS0_SX340 +MTXS0_SX430 +MTXS0_SX70 +MVJH0_SI1556 +MVJH0_SI2186 +MVJH0_SI926 +MVJH0_SX116 +MVJH0_SX206 +MVJH0_SX26 +MVJH0_SX296 +MVJH0_SX386 +MVLO0_SI1147 +MVLO0_SI1777 +MVLO0_SI517 +MVLO0_SX157 +MVLO0_SX247 +MVLO0_SX337 +MVLO0_SX427 +MVLO0_SX67 +MVRW0_SI1485 +MVRW0_SI2115 +MVRW0_SI855 +MVRW0_SX135 +MVRW0_SX225 +MVRW0_SX315 +MVRW0_SX405 +MVRW0_SX45 +MWAC0_SI1601 +MWAC0_SI2231 +MWAC0_SI971 +MWAC0_SX161 +MWAC0_SX251 +MWAC0_SX341 +MWAC0_SX431 +MWAC0_SX71 +MWAD0_SI1062 +MWAD0_SI1749 +MWAD0_SI2322 +MWAD0_SX162 +MWAD0_SX252 +MWAD0_SX342 +MWAD0_SX432 +MWAD0_SX72 +MWAR0_SI1045 +MWAR0_SI1675 +MWAR0_SI2305 +MWAR0_SX145 +MWAR0_SX235 +MWAR0_SX325 +MWAR0_SX415 +MWAR0_SX55 +MWCH0_SI1622 +MWCH0_SI1895 +MWCH0_SI2252 +MWCH0_SX182 +MWCH0_SX272 +MWCH0_SX362 +MWCH0_SX452 +MWCH0_SX92 +MWDK0_SI1436 +MWDK0_SI2017 +MWDK0_SI806 +MWDK0_SX176 +MWDK0_SX266 +MWDK0_SX356 +MWDK0_SX446 +MWDK0_SX86 +MWEM0_SI1320 +MWEM0_SI1393 +MWEM0_SI1950 +MWEM0_SX150 +MWEM0_SX240 +MWEM0_SX330 +MWEM0_SX420 +MWEM0_SX60 +MWGR0_SI1606 +MWGR0_SI2236 +MWGR0_SI976 +MWGR0_SX166 +MWGR0_SX256 +MWGR0_SX346 +MWGR0_SX436 +MWGR0_SX76 +MWRE0_SI1057 +MWRE0_SI1687 +MWRE0_SI2317 +MWRE0_SX157 +MWRE0_SX247 +MWRE0_SX337 +MWRE0_SX427 +MWRE0_SX67 +MWRP0_SI1443 +MWRP0_SI1525 +MWRP0_SI2073 +MWRP0_SX183 +MWRP0_SX273 +MWRP0_SX3 +MWRP0_SX363 +MWRP0_SX93 +MWSB0_SI1626 +MWSB0_SI2256 +MWSB0_SI996 +MWSB0_SX186 +MWSB0_SX276 +MWSB0_SX366 +MWSB0_SX6 +MWSB0_SX96 +MWSH0_SI1426 +MWSH0_SI2266 +MWSH0_SI796 +MWSH0_SX166 +MWSH0_SX256 +MWSH0_SX346 +MWSH0_SX436 +MWSH0_SX76 +MZMB0_SI1166 +MZMB0_SI1796 +MZMB0_SI536 +MZMB0_SX176 +MZMB0_SX266 +MZMB0_SX356 +MZMB0_SX446 +MZMB0_SX86 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train_text.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train_text.uid new file mode 100644 index 0000000000000000000000000000000000000000..c39fd0b91d51e0ae15caf1e9701d0d9ef51ee21b --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/train_text.uid @@ -0,0 +1,3696 @@ +FAEM0_SI1392 +FAEM0_SI2022 +FAEM0_SI762 +FAEM0_SX132 +FAEM0_SX222 +FAEM0_SX312 +FAEM0_SX402 +FAEM0_SX42 +FAJW0_SI1263 +FAJW0_SI1893 +FAJW0_SI633 +FAJW0_SX183 +FAJW0_SX273 +FAJW0_SX3 +FAJW0_SX363 +FAJW0_SX93 +FALK0_SI1086 +FALK0_SI456 +FALK0_SI658 +FALK0_SX186 +FALK0_SX276 +FALK0_SX366 +FALK0_SX6 +FALK0_SX96 +FALR0_SI1325 +FALR0_SI1955 +FALR0_SI695 +FALR0_SX155 +FALR0_SX245 +FALR0_SX335 +FALR0_SX425 +FALR0_SX65 +FAPB0_SI1063 +FAPB0_SI1693 +FAPB0_SI2323 +FAPB0_SX163 +FAPB0_SX253 +FAPB0_SX343 +FAPB0_SX433 +FAPB0_SX73 +FBAS0_SI1387 +FBAS0_SI1472 +FBAS0_SI2066 +FBAS0_SX127 +FBAS0_SX217 +FBAS0_SX307 +FBAS0_SX37 +FBAS0_SX397 +FBCG1_SI1612 +FBCG1_SI2242 +FBCG1_SI982 +FBCG1_SX172 +FBCG1_SX262 +FBCG1_SX352 +FBCG1_SX442 +FBCG1_SX82 +FBCH0_SI1586 +FBCH0_SI956 +FBCH0_SI959 +FBCH0_SX146 +FBCH0_SX236 +FBCH0_SX326 +FBCH0_SX416 +FBCH0_SX56 +FBJL0_SI1552 +FBJL0_SI2182 +FBJL0_SI922 +FBJL0_SX112 +FBJL0_SX202 +FBJL0_SX22 +FBJL0_SX292 +FBJL0_SX382 +FBLV0_SI1058 +FBLV0_SI1688 +FBLV0_SI2318 +FBLV0_SX158 +FBLV0_SX248 +FBLV0_SX338 +FBLV0_SX428 +FBLV0_SX68 +FBMH0_SI1136 +FBMH0_SI1766 +FBMH0_SI970 +FBMH0_SX146 +FBMH0_SX236 +FBMH0_SX326 +FBMH0_SX416 +FBMH0_SX56 +FBMJ0_SI1776 +FBMJ0_SI516 +FBMJ0_SI815 +FBMJ0_SX156 +FBMJ0_SX246 +FBMJ0_SX336 +FBMJ0_SX426 +FBMJ0_SX66 +FCAG0_SI1503 +FCAG0_SI1641 +FCAG0_SI2133 +FCAG0_SX153 +FCAG0_SX243 +FCAG0_SX333 +FCAG0_SX423 +FCAG0_SX63 +FCAJ0_SI1479 +FCAJ0_SI1804 +FCAJ0_SI849 +FCAJ0_SX129 +FCAJ0_SX219 +FCAJ0_SX309 +FCAJ0_SX39 +FCAJ0_SX399 +FCDR1_SI1186 +FCDR1_SI1816 +FCDR1_SI556 +FCDR1_SX106 +FCDR1_SX16 +FCDR1_SX196 +FCDR1_SX286 +FCDR1_SX376 +FCEG0_SI1248 +FCEG0_SI1878 +FCEG0_SI618 +FCEG0_SX168 +FCEG0_SX258 +FCEG0_SX348 +FCEG0_SX438 +FCEG0_SX78 +FCJF0_SI1027 +FCJF0_SI1657 +FCJF0_SI648 +FCJF0_SX127 +FCJF0_SX217 +FCJF0_SX307 +FCJF0_SX37 +FCJF0_SX397 +FCJS0_SI1607 +FCJS0_SI2237 +FCJS0_SI977 +FCJS0_SX167 +FCJS0_SX257 +FCJS0_SX347 +FCJS0_SX437 +FCJS0_SX77 +FCKE0_SI1111 +FCKE0_SI1741 +FCKE0_SI481 +FCKE0_SX121 +FCKE0_SX211 +FCKE0_SX301 +FCKE0_SX31 +FCKE0_SX391 +FCLT0_SI1438 +FCLT0_SI2068 +FCLT0_SI808 +FCLT0_SX178 +FCLT0_SX268 +FCLT0_SX358 +FCLT0_SX448 +FCLT0_SX88 +FCMG0_SI1142 +FCMG0_SI1242 +FCMG0_SI1872 +FCMG0_SX162 +FCMG0_SX252 +FCMG0_SX342 +FCMG0_SX432 +FCMG0_SX72 +FCMM0_SI1083 +FCMM0_SI1957 +FCMM0_SI453 +FCMM0_SX183 +FCMM0_SX273 +FCMM0_SX363 +FCMM0_SX420 +FCMM0_SX93 +FCRZ0_SI1913 +FCRZ0_SI2053 +FCRZ0_SI793 +FCRZ0_SX163 +FCRZ0_SX253 +FCRZ0_SX343 +FCRZ0_SX433 +FCRZ0_SX73 +FCYL0_SI1297 +FCYL0_SI1927 +FCYL0_SI667 +FCYL0_SX127 +FCYL0_SX217 +FCYL0_SX349 +FCYL0_SX37 +FCYL0_SX397 +FDAS1_SI1461 +FDAS1_SI2091 +FDAS1_SI831 +FDAS1_SX111 +FDAS1_SX201 +FDAS1_SX21 +FDAS1_SX291 +FDAS1_SX381 +FDAW0_SI1271 +FDAW0_SI1406 +FDAW0_SI2036 +FDAW0_SX146 +FDAW0_SX236 +FDAW0_SX326 +FDAW0_SX416 +FDAW0_SX56 +FDFB0_SI1318 +FDFB0_SI1948 +FDFB0_SI2010 +FDFB0_SX148 +FDFB0_SX238 +FDFB0_SX328 +FDFB0_SX418 +FDFB0_SX58 +FDJH0_SI1565 +FDJH0_SI2195 +FDJH0_SI935 +FDJH0_SX125 +FDJH0_SX215 +FDJH0_SX305 +FDJH0_SX35 +FDJH0_SX395 +FDKN0_SI1081 +FDKN0_SI1202 +FDKN0_SI1711 +FDKN0_SX181 +FDKN0_SX271 +FDKN0_SX361 +FDKN0_SX451 +FDKN0_SX91 +FDML0_SI1149 +FDML0_SI1779 +FDML0_SI2075 +FDML0_SX159 +FDML0_SX249 +FDML0_SX339 +FDML0_SX429 +FDML0_SX69 +FDMY0_SI1197 +FDMY0_SI567 +FDMY0_SI714 +FDMY0_SX117 +FDMY0_SX207 +FDMY0_SX27 +FDMY0_SX297 +FDMY0_SX387 +FDNC0_SI1278 +FDNC0_SI1908 +FDNC0_SI2287 +FDNC0_SX108 +FDNC0_SX18 +FDNC0_SX198 +FDNC0_SX288 +FDNC0_SX378 +FDTD0_SI1561 +FDTD0_SI2191 +FDTD0_SI931 +FDTD0_SX121 +FDTD0_SX211 +FDTD0_SX301 +FDTD0_SX321 +FDTD0_SX391 +FDXW0_SI1511 +FDXW0_SI2141 +FDXW0_SI881 +FDXW0_SX161 +FDXW0_SX251 +FDXW0_SX341 +FDXW0_SX431 +FDXW0_SX71 +FEAC0_SI1245 +FEAC0_SI1875 +FEAC0_SI615 +FEAC0_SX165 +FEAC0_SX255 +FEAC0_SX345 +FEAC0_SX435 +FEAC0_SX75 +FEAR0_SI1252 +FEAR0_SI1882 +FEAR0_SI622 +FEAR0_SX172 +FEAR0_SX262 +FEAR0_SX352 +FEAR0_SX442 +FEAR0_SX82 +FECD0_SI1418 +FECD0_SI2048 +FECD0_SI788 +FECD0_SX158 +FECD0_SX248 +FECD0_SX338 +FECD0_SX428 +FECD0_SX68 +FEEH0_SI1112 +FEEH0_SI1742 +FEEH0_SI471 +FEEH0_SX122 +FEEH0_SX212 +FEEH0_SX302 +FEEH0_SX32 +FEEH0_SX392 +FEME0_SI1505 +FEME0_SI2135 +FEME0_SI875 +FEME0_SX155 +FEME0_SX245 +FEME0_SX335 +FEME0_SX425 +FEME0_SX65 +FETB0_SI1148 +FETB0_SI1778 +FETB0_SI518 +FETB0_SX158 +FETB0_SX248 +FETB0_SX338 +FETB0_SX428 +FETB0_SX68 +FEXM0_SI1101 +FEXM0_SI1731 +FEXM0_SI482 +FEXM0_SX111 +FEXM0_SX201 +FEXM0_SX291 +FEXM0_SX366 +FEXM0_SX381 +FGCS0_SI1486 +FGCS0_SI2116 +FGCS0_SI856 +FGCS0_SX136 +FGCS0_SX226 +FGCS0_SX316 +FGCS0_SX406 +FGCS0_SX46 +FGDP0_SI1618 +FGDP0_SI2248 +FGDP0_SI988 +FGDP0_SX178 +FGDP0_SX268 +FGDP0_SX358 +FGDP0_SX448 +FGDP0_SX88 +FGMB0_SI1145 +FGMB0_SI1775 +FGMB0_SI515 +FGMB0_SX155 +FGMB0_SX245 +FGMB0_SX335 +FGMB0_SX425 +FGMB0_SX65 +FGRW0_SI1152 +FGRW0_SI1782 +FGRW0_SI1990 +FGRW0_SX162 +FGRW0_SX252 +FGRW0_SX342 +FGRW0_SX432 +FGRW0_SX72 +FHLM0_SI1560 +FHLM0_SI2190 +FHLM0_SI930 +FHLM0_SX120 +FHLM0_SX210 +FHLM0_SX300 +FHLM0_SX349 +FHLM0_SX390 +FHXS0_SI1075 +FHXS0_SI2302 +FHXS0_SI2335 +FHXS0_SX175 +FHXS0_SX265 +FHXS0_SX355 +FHXS0_SX445 +FHXS0_SX85 +FJDM2_SI1582 +FJDM2_SI1964 +FJDM2_SI2212 +FJDM2_SX142 +FJDM2_SX232 +FJDM2_SX322 +FJDM2_SX412 +FJDM2_SX52 +FJEN0_SI1047 +FJEN0_SI1677 +FJEN0_SI2307 +FJEN0_SX147 +FJEN0_SX237 +FJEN0_SX327 +FJEN0_SX417 +FJEN0_SX57 +FJHK0_SI1022 +FJHK0_SI1652 +FJHK0_SI2282 +FJHK0_SX122 +FJHK0_SX212 +FJHK0_SX302 +FJHK0_SX32 +FJHK0_SX392 +FJKL0_SI1562 +FJKL0_SI2192 +FJKL0_SI932 +FJKL0_SX122 +FJKL0_SX212 +FJKL0_SX302 +FJKL0_SX32 +FJKL0_SX392 +FJLG0_SI1506 +FJLG0_SI1889 +FJLG0_SI2306 +FJLG0_SX179 +FJLG0_SX269 +FJLG0_SX359 +FJLG0_SX449 +FJLG0_SX89 +FJLR0_SI1231 +FJLR0_SI1861 +FJLR0_SI601 +FJLR0_SX151 +FJLR0_SX241 +FJLR0_SX331 +FJLR0_SX421 +FJLR0_SX61 +FJRB0_SI1302 +FJRB0_SI1932 +FJRB0_SI672 +FJRB0_SX132 +FJRB0_SX222 +FJRB0_SX312 +FJRB0_SX402 +FJRB0_SX42 +FJRP1_SI1432 +FJRP1_SI2062 +FJRP1_SI802 +FJRP1_SX172 +FJRP1_SX262 +FJRP1_SX352 +FJRP1_SX442 +FJRP1_SX82 +FJSK0_SI1052 +FJSK0_SI1682 +FJSK0_SI2312 +FJSK0_SX152 +FJSK0_SX242 +FJSK0_SX332 +FJSK0_SX422 +FJSK0_SX62 +FJSP0_SI1434 +FJSP0_SI1763 +FJSP0_SI804 +FJSP0_SX174 +FJSP0_SX264 +FJSP0_SX354 +FJSP0_SX444 +FJSP0_SX84 +FJWB1_SI2055 +FJWB1_SI748 +FJWB1_SI795 +FJWB1_SX165 +FJWB1_SX255 +FJWB1_SX345 +FJWB1_SX435 +FJWB1_SX75 +FJXM0_SI1211 +FJXM0_SI1971 +FJXM0_SI581 +FJXM0_SX131 +FJXM0_SX221 +FJXM0_SX311 +FJXM0_SX401 +FJXM0_SX41 +FJXP0_SI1122 +FJXP0_SI1752 +FJXP0_SI492 +FJXP0_SX132 +FJXP0_SX222 +FJXP0_SX312 +FJXP0_SX402 +FJXP0_SX42 +FKAA0_SI1208 +FKAA0_SI1838 +FKAA0_SI578 +FKAA0_SX128 +FKAA0_SX218 +FKAA0_SX308 +FKAA0_SX38 +FKAA0_SX398 +FKDE0_SI1141 +FKDE0_SI1771 +FKDE0_SI2221 +FKDE0_SX151 +FKDE0_SX241 +FKDE0_SX331 +FKDE0_SX421 +FKDE0_SX61 +FKDW0_SI1207 +FKDW0_SI1891 +FKDW0_SI577 +FKDW0_SX127 +FKDW0_SX217 +FKDW0_SX307 +FKDW0_SX37 +FKDW0_SX397 +FKFB0_SI1608 +FKFB0_SI2238 +FKFB0_SI978 +FKFB0_SX168 +FKFB0_SX258 +FKFB0_SX348 +FKFB0_SX438 +FKFB0_SX78 +FKKH0_SI1290 +FKKH0_SI1920 +FKKH0_SI660 +FKKH0_SX120 +FKKH0_SX210 +FKKH0_SX30 +FKKH0_SX300 +FKKH0_SX390 +FKLC0_SI1615 +FKLC0_SI2245 +FKLC0_SI985 +FKLC0_SX175 +FKLC0_SX265 +FKLC0_SX355 +FKLC0_SX445 +FKLC0_SX85 +FKLC1_SI1048 +FKLC1_SI1678 +FKLC1_SI2308 +FKLC1_SX148 +FKLC1_SX238 +FKLC1_SX328 +FKLC1_SX418 +FKLC1_SX58 +FKLH0_SI1257 +FKLH0_SI1887 +FKLH0_SI627 +FKLH0_SX177 +FKLH0_SX267 +FKLH0_SX357 +FKLH0_SX447 +FKLH0_SX87 +FKSR0_SI1117 +FKSR0_SI1747 +FKSR0_SI487 +FKSR0_SX161 +FKSR0_SX217 +FKSR0_SX366 +FKSR0_SX37 +FKSR0_SX397 +FLAC0_SI1339 +FLAC0_SI2161 +FLAC0_SI901 +FLAC0_SX181 +FLAC0_SX271 +FLAC0_SX361 +FLAC0_SX451 +FLAC0_SX91 +FLAG0_SI1464 +FLAG0_SI2094 +FLAG0_SI834 +FLAG0_SX114 +FLAG0_SX204 +FLAG0_SX24 +FLAG0_SX294 +FLAG0_SX384 +FLEH0_SI1051 +FLEH0_SI1681 +FLEH0_SI2311 +FLEH0_SX151 +FLEH0_SX241 +FLEH0_SX331 +FLEH0_SX421 +FLEH0_SX61 +FLET0_SI1137 +FLET0_SI1767 +FLET0_SI507 +FLET0_SX147 +FLET0_SX237 +FLET0_SX277 +FLET0_SX417 +FLET0_SX57 +FLHD0_SI1344 +FLHD0_SI1827 +FLHD0_SI1974 +FLHD0_SX174 +FLHD0_SX264 +FLHD0_SX354 +FLHD0_SX444 +FLHD0_SX84 +FLJA0_SI1078 +FLJA0_SI1708 +FLJA0_SI2338 +FLJA0_SX178 +FLJA0_SX268 +FLJA0_SX358 +FLJA0_SX448 +FLJA0_SX88 +FLJD0_SI1516 +FLJD0_SI2146 +FLJD0_SI886 +FLJD0_SX166 +FLJD0_SX256 +FLJD0_SX346 +FLJD0_SX436 +FLJD0_SX76 +FLJG0_SI1611 +FLJG0_SI2241 +FLJG0_SI981 +FLJG0_SX171 +FLJG0_SX261 +FLJG0_SX351 +FLJG0_SX441 +FLJG0_SX81 +FLKM0_SI1880 +FLKM0_SI620 +FLKM0_SI686 +FLKM0_SX116 +FLKM0_SX260 +FLKM0_SX350 +FLKM0_SX440 +FLKM0_SX80 +FLMA0_SI1243 +FLMA0_SI1873 +FLMA0_SI613 +FLMA0_SX163 +FLMA0_SX253 +FLMA0_SX343 +FLMA0_SX433 +FLMA0_SX73 +FLMC0_SI1372 +FLMC0_SI2002 +FLMC0_SI742 +FLMC0_SX112 +FLMC0_SX22 +FLMC0_SX292 +FLMC0_SX336 +FLMC0_SX382 +FLMK0_SI1035 +FLMK0_SI1229 +FLMK0_SI2295 +FLMK0_SX135 +FLMK0_SX225 +FLMK0_SX315 +FLMK0_SX405 +FLMK0_SX45 +FLOD0_SI1287 +FLOD0_SI1917 +FLOD0_SI657 +FLOD0_SX117 +FLOD0_SX171 +FLOD0_SX207 +FLOD0_SX297 +FLOD0_SX387 +FLTM0_SI1070 +FLTM0_SI1700 +FLTM0_SI2330 +FLTM0_SX170 +FLTM0_SX260 +FLTM0_SX350 +FLTM0_SX440 +FLTM0_SX80 +FMAH1_SI1509 +FMAH1_SI2139 +FMAH1_SI879 +FMAH1_SX159 +FMAH1_SX249 +FMAH1_SX339 +FMAH1_SX429 +FMAH1_SX69 +FMBG0_SI1160 +FMBG0_SI1790 +FMBG0_SI2264 +FMBG0_SX260 +FMBG0_SX3 +FMBG0_SX350 +FMBG0_SX440 +FMBG0_SX80 +FMEM0_SI1377 +FMEM0_SI2007 +FMEM0_SI747 +FMEM0_SX117 +FMEM0_SX207 +FMEM0_SX297 +FMEM0_SX333 +FMEM0_SX387 +FMJB0_SI1177 +FMJB0_SI1807 +FMJB0_SI547 +FMJB0_SX187 +FMJB0_SX277 +FMJB0_SX367 +FMJB0_SX7 +FMJB0_SX97 +FMJF0_SI1254 +FMJF0_SI1884 +FMJF0_SI624 +FMJF0_SX174 +FMJF0_SX264 +FMJF0_SX354 +FMJF0_SX444 +FMJF0_SX84 +FMJU0_SI1389 +FMJU0_SI2019 +FMJU0_SI759 +FMJU0_SX129 +FMJU0_SX219 +FMJU0_SX309 +FMJU0_SX39 +FMJU0_SX399 +FMKC0_SI1041 +FMKC0_SI1072 +FMKC0_SI1702 +FMKC0_SX172 +FMKC0_SX262 +FMKC0_SX352 +FMKC0_SX442 +FMKC0_SX82 +FMKF0_SI1018 +FMKF0_SI1536 +FMKF0_SI906 +FMKF0_SX186 +FMKF0_SX276 +FMKF0_SX366 +FMKF0_SX6 +FMKF0_SX96 +FMMH0_SI1537 +FMMH0_SI2167 +FMMH0_SI907 +FMMH0_SX187 +FMMH0_SX367 +FMMH0_SX420 +FMMH0_SX7 +FMMH0_SX97 +FMPG0_SI1602 +FMPG0_SI2232 +FMPG0_SI972 +FMPG0_SX162 +FMPG0_SX252 +FMPG0_SX342 +FMPG0_SX432 +FMPG0_SX72 +FNKL0_SI1522 +FNKL0_SI2152 +FNKL0_SI892 +FNKL0_SX172 +FNKL0_SX196 +FNKL0_SX262 +FNKL0_SX442 +FNKL0_SX82 +FNTB0_SI1203 +FNTB0_SI573 +FNTB0_SI679 +FNTB0_SX123 +FNTB0_SX213 +FNTB0_SX303 +FNTB0_SX33 +FNTB0_SX393 +FPAB1_SI1471 +FPAB1_SI2101 +FPAB1_SI841 +FPAB1_SX121 +FPAB1_SX211 +FPAB1_SX301 +FPAB1_SX31 +FPAB1_SX391 +FPAC0_SI1921 +FPAC0_SI2011 +FPAC0_SI661 +FPAC0_SX121 +FPAC0_SX211 +FPAC0_SX301 +FPAC0_SX31 +FPAC0_SX391 +FPAD0_SI1346 +FPAD0_SI1976 +FPAD0_SI716 +FPAD0_SX176 +FPAD0_SX266 +FPAD0_SX356 +FPAD0_SX446 +FPAD0_SX86 +FPAF0_SI1054 +FPAF0_SI1684 +FPAF0_SI2314 +FPAF0_SX154 +FPAF0_SX244 +FPAF0_SX334 +FPAF0_SX424 +FPAF0_SX64 +FPAZ0_SI1593 +FPAZ0_SI2223 +FPAZ0_SI963 +FPAZ0_SX153 +FPAZ0_SX243 +FPAZ0_SX27 +FPAZ0_SX423 +FPAZ0_SX63 +FPJF0_SI1046 +FPJF0_SI1259 +FPJF0_SI1676 +FPJF0_SX146 +FPJF0_SX236 +FPJF0_SX326 +FPJF0_SX352 +FPJF0_SX56 +FPLS0_SI1590 +FPLS0_SI2220 +FPLS0_SI960 +FPLS0_SX150 +FPLS0_SX240 +FPLS0_SX3 +FPLS0_SX330 +FPLS0_SX60 +FPMY0_SI1153 +FPMY0_SI1783 +FPMY0_SI523 +FPMY0_SX163 +FPMY0_SX196 +FPMY0_SX253 +FPMY0_SX343 +FPMY0_SX73 +FREH0_SI1315 +FREH0_SI1945 +FREH0_SI685 +FREH0_SX145 +FREH0_SX235 +FREH0_SX325 +FREH0_SX415 +FREH0_SX55 +FRJB0_SI1427 +FRJB0_SI1470 +FRJB0_SI1794 +FRJB0_SX167 +FRJB0_SX257 +FRJB0_SX347 +FRJB0_SX437 +FRJB0_SX77 +FRLL0_SI1514 +FRLL0_SI805 +FRLL0_SI884 +FRLL0_SX164 +FRLL0_SX254 +FRLL0_SX344 +FRLL0_SX434 +FRLL0_SX74 +FSAG0_SI1323 +FSAG0_SI1953 +FSAG0_SI693 +FSAG0_SX153 +FSAG0_SX243 +FSAG0_SX333 +FSAG0_SX423 +FSAG0_SX63 +FSAH0_SI1244 +FSAH0_SI1874 +FSAH0_SI614 +FSAH0_SX164 +FSAH0_SX327 +FSAH0_SX344 +FSAH0_SX434 +FSAH0_SX74 +FSAK0_SI1300 +FSAK0_SI1930 +FSAK0_SI670 +FSAK0_SX130 +FSAK0_SX220 +FSAK0_SX310 +FSAK0_SX40 +FSAK0_SX400 +FSBK0_SI1069 +FSBK0_SI1699 +FSBK0_SI2329 +FSBK0_SX169 +FSBK0_SX259 +FSBK0_SX349 +FSBK0_SX439 +FSBK0_SX79 +FSCN0_SI1886 +FSCN0_SI626 +FSCN0_SI705 +FSCN0_SX176 +FSCN0_SX266 +FSCN0_SX356 +FSCN0_SX446 +FSCN0_SX86 +FSDC0_SI1312 +FSDC0_SI1942 +FSDC0_SI2234 +FSDC0_SX142 +FSDC0_SX232 +FSDC0_SX322 +FSDC0_SX412 +FSDC0_SX52 +FSDJ0_SI1115 +FSDJ0_SI1745 +FSDJ0_SI485 +FSDJ0_SX125 +FSDJ0_SX215 +FSDJ0_SX305 +FSDJ0_SX35 +FSDJ0_SX395 +FSGF0_SI1557 +FSGF0_SI2187 +FSGF0_SI927 +FSGF0_SX117 +FSGF0_SX207 +FSGF0_SX27 +FSGF0_SX297 +FSGF0_SX387 +FSJG0_SI1570 +FSJG0_SI2200 +FSJG0_SI940 +FSJG0_SX130 +FSJG0_SX220 +FSJG0_SX310 +FSJG0_SX40 +FSJG0_SX400 +FSJK1_SI1025 +FSJK1_SI2285 +FSJK1_SI696 +FSJK1_SX125 +FSJK1_SX215 +FSJK1_SX305 +FSJK1_SX35 +FSJK1_SX395 +FSJS0_SI1171 +FSJS0_SI1801 +FSJS0_SI541 +FSJS0_SX181 +FSJS0_SX271 +FSJS0_SX361 +FSJS0_SX451 +FSJS0_SX91 +FSJW0_SI1333 +FSJW0_SI1963 +FSJW0_SI703 +FSJW0_SX163 +FSJW0_SX253 +FSJW0_SX343 +FSJW0_SX433 +FSJW0_SX73 +FSKC0_SI1416 +FSKC0_SI2046 +FSKC0_SI786 +FSKC0_SX156 +FSKC0_SX246 +FSKC0_SX336 +FSKC0_SX426 +FSKC0_SX66 +FSKL0_SI1529 +FSKL0_SI2159 +FSKL0_SI899 +FSKL0_SX179 +FSKL0_SX269 +FSKL0_SX359 +FSKL0_SX449 +FSKL0_SX89 +FSKP0_SI1098 +FSKP0_SI1728 +FSKP0_SI468 +FSKP0_SX108 +FSKP0_SX18 +FSKP0_SX198 +FSKP0_SX288 +FSKP0_SX378 +FSLS0_SI1056 +FSLS0_SI1686 +FSLS0_SI2316 +FSLS0_SX156 +FSLS0_SX202 +FSLS0_SX246 +FSLS0_SX426 +FSLS0_SX66 +FSMA0_SI1621 +FSMA0_SI2251 +FSMA0_SI991 +FSMA0_SX181 +FSMA0_SX271 +FSMA0_SX361 +FSMA0_SX451 +FSMA0_SX91 +FSMM0_SI1314 +FSMM0_SI1944 +FSMM0_SI684 +FSMM0_SX144 +FSMM0_SX234 +FSMM0_SX324 +FSMM0_SX414 +FSMM0_SX54 +FSMS1_SI1504 +FSMS1_SI2134 +FSMS1_SI874 +FSMS1_SX154 +FSMS1_SX244 +FSMS1_SX334 +FSMS1_SX347 +FSMS1_SX64 +FSPM0_SI1241 +FSPM0_SI1871 +FSPM0_SI611 +FSPM0_SX161 +FSPM0_SX251 +FSPM0_SX341 +FSPM0_SX431 +FSPM0_SX71 +FSRH0_SI1719 +FSRH0_SI1931 +FSRH0_SI671 +FSRH0_SX131 +FSRH0_SX221 +FSRH0_SX311 +FSRH0_SX401 +FSRH0_SX41 +FSSB0_SI1082 +FSSB0_SI1712 +FSSB0_SI2342 +FSSB0_SX182 +FSSB0_SX272 +FSSB0_SX362 +FSSB0_SX452 +FSSB0_SX92 +FTAJ0_SI1329 +FTAJ0_SI474 +FTAJ0_SI699 +FTAJ0_SX159 +FTAJ0_SX249 +FTAJ0_SX339 +FTAJ0_SX429 +FTAJ0_SX69 +FTBR0_SI1402 +FTBR0_SI2181 +FTBR0_SI921 +FTBR0_SX111 +FTBR0_SX201 +FTBR0_SX21 +FTBR0_SX291 +FTBR0_SX381 +FTBW0_SI1345 +FTBW0_SI1975 +FTBW0_SI715 +FTBW0_SX175 +FTBW0_SX265 +FTBW0_SX355 +FTBW0_SX445 +FTBW0_SX85 +FTLG0_SI1743 +FTLG0_SI483 +FTLG0_SI840 +FTLG0_SX123 +FTLG0_SX213 +FTLG0_SX303 +FTLG0_SX33 +FTLG0_SX393 +FTMG0_SI1532 +FTMG0_SI2162 +FTMG0_SI902 +FTMG0_SX182 +FTMG0_SX272 +FTMG0_SX362 +FTMG0_SX452 +FTMG0_SX92 +FVFB0_SI1032 +FVFB0_SI1510 +FVFB0_SI2292 +FVFB0_SX132 +FVFB0_SX222 +FVFB0_SX312 +FVFB0_SX402 +FVFB0_SX42 +FVKB0_SI1159 +FVKB0_SI1789 +FVKB0_SI529 +FVKB0_SX169 +FVKB0_SX259 +FVKB0_SX349 +FVKB0_SX439 +FVKB0_SX79 +FVMH0_SI1466 +FVMH0_SI2096 +FVMH0_SI836 +FVMH0_SX116 +FVMH0_SX206 +FVMH0_SX26 +FVMH0_SX296 +FVMH0_SX386 +MABC0_SI1620 +MABC0_SI2041 +MABC0_SI781 +MABC0_SX151 +MABC0_SX241 +MABC0_SX331 +MABC0_SX421 +MABC0_SX61 +MADC0_SI1367 +MADC0_SI1997 +MADC0_SI737 +MADC0_SX107 +MADC0_SX17 +MADC0_SX197 +MADC0_SX287 +MADC0_SX377 +MADD0_SI1295 +MADD0_SI1798 +MADD0_SI538 +MADD0_SX178 +MADD0_SX268 +MADD0_SX358 +MADD0_SX448 +MADD0_SX88 +MAEB0_SI1411 +MAEB0_SI2250 +MAEB0_SI990 +MAEB0_SX180 +MAEB0_SX270 +MAEB0_SX360 +MAEB0_SX450 +MAEB0_SX90 +MAEO0_SI1326 +MAEO0_SI1655 +MAEO0_SI1956 +MAEO0_SX156 +MAEO0_SX246 +MAEO0_SX336 +MAEO0_SX426 +MAEO0_SX66 +MAFM0_SI1569 +MAFM0_SI2199 +MAFM0_SI939 +MAFM0_SX129 +MAFM0_SX219 +MAFM0_SX309 +MAFM0_SX39 +MAFM0_SX399 +MAJP0_SI1074 +MAJP0_SI1704 +MAJP0_SI2334 +MAJP0_SX174 +MAJP0_SX264 +MAJP0_SX354 +MAJP0_SX444 +MAJP0_SX84 +MAKB0_SI1016 +MAKB0_SI1646 +MAKB0_SI2276 +MAKB0_SX116 +MAKB0_SX206 +MAKB0_SX26 +MAKB0_SX296 +MAKB0_SX386 +MAKR0_SI1352 +MAKR0_SI1982 +MAKR0_SI722 +MAKR0_SX182 +MAKR0_SX272 +MAKR0_SX362 +MAKR0_SX452 +MAKR0_SX92 +MAPV0_SI1293 +MAPV0_SI1923 +MAPV0_SI663 +MAPV0_SX123 +MAPV0_SX213 +MAPV0_SX303 +MAPV0_SX33 +MAPV0_SX393 +MARC0_SI1188 +MARC0_SI1818 +MARC0_SI558 +MARC0_SX108 +MARC0_SX18 +MARC0_SX198 +MARC0_SX288 +MARC0_SX378 +MARW0_SI1276 +MARW0_SI1906 +MARW0_SI646 +MARW0_SX106 +MARW0_SX16 +MARW0_SX286 +MARW0_SX349 +MARW0_SX376 +MBAR0_SI1319 +MBAR0_SI1949 +MBAR0_SI689 +MBAR0_SX149 +MBAR0_SX239 +MBAR0_SX329 +MBAR0_SX419 +MBAR0_SX59 +MBBR0_SI1055 +MBBR0_SI1685 +MBBR0_SI2315 +MBBR0_SX155 +MBBR0_SX245 +MBBR0_SX335 +MBBR0_SX425 +MBBR0_SX65 +MBCG0_SI2217 +MBCG0_SI486 +MBCG0_SI957 +MBCG0_SX147 +MBCG0_SX237 +MBCG0_SX327 +MBCG0_SX417 +MBCG0_SX57 +MBEF0_SI1281 +MBEF0_SI1911 +MBEF0_SI651 +MBEF0_SX111 +MBEF0_SX201 +MBEF0_SX21 +MBEF0_SX291 +MBEF0_SX381 +MBGT0_SI1341 +MBGT0_SI1841 +MBGT0_SI711 +MBGT0_SX171 +MBGT0_SX261 +MBGT0_SX351 +MBGT0_SX441 +MBGT0_SX81 +MBJV0_SI1247 +MBJV0_SI1877 +MBJV0_SI617 +MBJV0_SX167 +MBJV0_SX257 +MBJV0_SX347 +MBJV0_SX437 +MBJV0_SX77 +MBMA0_SI1222 +MBMA0_SI1852 +MBMA0_SI592 +MBMA0_SX142 +MBMA0_SX232 +MBMA0_SX322 +MBMA0_SX412 +MBMA0_SX52 +MBMA1_SI2207 +MBMA1_SI2214 +MBMA1_SI954 +MBMA1_SX144 +MBMA1_SX234 +MBMA1_SX324 +MBMA1_SX414 +MBMA1_SX54 +MBML0_SI1169 +MBML0_SI1799 +MBML0_SI539 +MBML0_SX179 +MBML0_SX269 +MBML0_SX359 +MBML0_SX449 +MBML0_SX89 +MBOM0_SI1014 +MBOM0_SI1644 +MBOM0_SI2274 +MBOM0_SX114 +MBOM0_SX204 +MBOM0_SX294 +MBOM0_SX311 +MBOM0_SX384 +MBSB0_SI1353 +MBSB0_SI1983 +MBSB0_SI723 +MBSB0_SX183 +MBSB0_SX273 +MBSB0_SX3 +MBSB0_SX363 +MBSB0_SX93 +MBTH0_SI2102 +MBTH0_SI505 +MBTH0_SI757 +MBTH0_SX122 +MBTH0_SX212 +MBTH0_SX302 +MBTH0_SX32 +MBTH0_SX392 +MBWP0_SI1531 +MBWP0_SI1969 +MBWP0_SI709 +MBWP0_SX169 +MBWP0_SX259 +MBWP0_SX349 +MBWP0_SX439 +MBWP0_SX79 +MCAE0_SI1447 +MCAE0_SI2077 +MCAE0_SI817 +MCAE0_SX187 +MCAE0_SX277 +MCAE0_SX367 +MCAE0_SX7 +MCAE0_SX97 +MCAL0_SI1138 +MCAL0_SI1768 +MCAL0_SI508 +MCAL0_SX148 +MCAL0_SX238 +MCAL0_SX328 +MCAL0_SX418 +MCAL0_SX58 +MCDC0_SI1292 +MCDC0_SI1922 +MCDC0_SI662 +MCDC0_SX122 +MCDC0_SX212 +MCDC0_SX302 +MCDC0_SX32 +MCDC0_SX392 +MCDD0_SI1513 +MCDD0_SI2143 +MCDD0_SI883 +MCDD0_SX163 +MCDD0_SX253 +MCDD0_SX343 +MCDD0_SX433 +MCDD0_SX73 +MCDR0_SI1154 +MCDR0_SI1784 +MCDR0_SI524 +MCDR0_SX164 +MCDR0_SX254 +MCDR0_SX344 +MCDR0_SX434 +MCDR0_SX74 +MCEF0_SI1135 +MCEF0_SI1765 +MCEF0_SI842 +MCEF0_SX145 +MCEF0_SX235 +MCEF0_SX325 +MCEF0_SX415 +MCEF0_SX55 +MCEW0_SI1442 +MCEW0_SI2072 +MCEW0_SI812 +MCEW0_SX182 +MCEW0_SX272 +MCEW0_SX362 +MCEW0_SX452 +MCEW0_SX92 +MCHL0_SI1347 +MCHL0_SI1404 +MCHL0_SI1977 +MCHL0_SX177 +MCHL0_SX267 +MCHL0_SX357 +MCHL0_SX447 +MCHL0_SX87 +MCLK0_SI1660 +MCLK0_SI2290 +MCLK0_SI650 +MCLK0_SX130 +MCLK0_SX220 +MCLK0_SX310 +MCLK0_SX40 +MCLK0_SX400 +MCLM0_SI1456 +MCLM0_SI2086 +MCLM0_SI826 +MCLM0_SX106 +MCLM0_SX16 +MCLM0_SX196 +MCLM0_SX286 +MCLM0_SX376 +MCPM0_SI1194 +MCPM0_SI1824 +MCPM0_SI564 +MCPM0_SX114 +MCPM0_SX204 +MCPM0_SX24 +MCPM0_SX294 +MCPM0_SX384 +MCRE0_SI1121 +MCRE0_SI1725 +MCRE0_SI1751 +MCRE0_SX131 +MCRE0_SX221 +MCRE0_SX24 +MCRE0_SX401 +MCRE0_SX41 +MCSS0_SI1380 +MCSS0_SI688 +MCSS0_SI750 +MCSS0_SX120 +MCSS0_SX210 +MCSS0_SX30 +MCSS0_SX300 +MCSS0_SX390 +MCTH0_SI1209 +MCTH0_SI1839 +MCTH0_SI579 +MCTH0_SX129 +MCTH0_SX219 +MCTH0_SX309 +MCTH0_SX39 +MCTH0_SX399 +MCTM0_SI1350 +MCTM0_SI1980 +MCTM0_SI720 +MCTM0_SX180 +MCTM0_SX270 +MCTM0_SX360 +MCTM0_SX450 +MCTM0_SX90 +MCXM0_SI1351 +MCXM0_SI1981 +MCXM0_SI721 +MCXM0_SX181 +MCXM0_SX271 +MCXM0_SX361 +MCXM0_SX451 +MCXM0_SX91 +MDAC0_SI1261 +MDAC0_SI1837 +MDAC0_SI631 +MDAC0_SX181 +MDAC0_SX271 +MDAC0_SX361 +MDAC0_SX451 +MDAC0_SX91 +MDAS0_SI1266 +MDAS0_SI1896 +MDAS0_SI636 +MDAS0_SX186 +MDAS0_SX21 +MDAS0_SX276 +MDAS0_SX6 +MDAS0_SX96 +MDBB1_SI1006 +MDBB1_SI1636 +MDBB1_SI2056 +MDBB1_SX106 +MDBB1_SX16 +MDBB1_SX196 +MDBB1_SX286 +MDBB1_SX376 +MDBP0_SI1158 +MDBP0_SI1788 +MDBP0_SI528 +MDBP0_SX168 +MDBP0_SX258 +MDBP0_SX348 +MDBP0_SX438 +MDBP0_SX78 +MDCD0_SI1415 +MDCD0_SI2045 +MDCD0_SI785 +MDCD0_SX155 +MDCD0_SX245 +MDCD0_SX335 +MDCD0_SX425 +MDCD0_SX65 +MDCM0_SI1480 +MDCM0_SI2110 +MDCM0_SI850 +MDCM0_SX130 +MDCM0_SX220 +MDCM0_SX310 +MDCM0_SX40 +MDCM0_SX400 +MDDC0_SI1419 +MDDC0_SI2049 +MDDC0_SI789 +MDDC0_SX159 +MDDC0_SX249 +MDDC0_SX339 +MDDC0_SX429 +MDDC0_SX69 +MDED0_SI1170 +MDED0_SI1800 +MDED0_SI540 +MDED0_SX180 +MDED0_SX270 +MDED0_SX360 +MDED0_SX450 +MDED0_SX90 +MDEF0_SI1123 +MDEF0_SI1563 +MDEF0_SI2193 +MDEF0_SX123 +MDEF0_SX213 +MDEF0_SX303 +MDEF0_SX33 +MDEF0_SX393 +MDEM0_SI1868 +MDEM0_SI608 +MDEM0_SI800 +MDEM0_SX158 +MDEM0_SX248 +MDEM0_SX338 +MDEM0_SX428 +MDEM0_SX68 +MDHL0_SI1439 +MDHL0_SI2069 +MDHL0_SI809 +MDHL0_SX179 +MDHL0_SX269 +MDHL0_SX359 +MDHL0_SX449 +MDHL0_SX89 +MDHS0_SI1530 +MDHS0_SI2160 +MDHS0_SI900 +MDHS0_SX180 +MDHS0_SX270 +MDHS0_SX360 +MDHS0_SX450 +MDHS0_SX90 +MDJM0_SI1455 +MDJM0_SI2085 +MDJM0_SI825 +MDJM0_SX105 +MDJM0_SX15 +MDJM0_SX195 +MDJM0_SX285 +MDJM0_SX375 +MDKS0_SI1066 +MDKS0_SI1696 +MDKS0_SI2326 +MDKS0_SX166 +MDKS0_SX256 +MDKS0_SX346 +MDKS0_SX436 +MDKS0_SX76 +MDLB0_SI1306 +MDLB0_SI1936 +MDLB0_SI676 +MDLB0_SX136 +MDLB0_SX226 +MDLB0_SX316 +MDLB0_SX406 +MDLB0_SX46 +MDLC0_SI1395 +MDLC0_SI2025 +MDLC0_SI765 +MDLC0_SX135 +MDLC0_SX225 +MDLC0_SX315 +MDLC0_SX405 +MDLC0_SX45 +MDLC1_SI1435 +MDLC1_SI2065 +MDLC1_SI2144 +MDLC1_SX175 +MDLC1_SX265 +MDLC1_SX355 +MDLC1_SX445 +MDLC1_SX85 +MDLC2_SI1614 +MDLC2_SI2244 +MDLC2_SI984 +MDLC2_SX174 +MDLC2_SX264 +MDLC2_SX354 +MDLC2_SX444 +MDLC2_SX84 +MDLH0_SI1960 +MDLH0_SI574 +MDLH0_SI700 +MDLH0_SX160 +MDLH0_SX250 +MDLH0_SX340 +MDLH0_SX430 +MDLH0_SX70 +MDLM0_SI1234 +MDLM0_SI1864 +MDLM0_SI604 +MDLM0_SX154 +MDLM0_SX244 +MDLM0_SX334 +MDLM0_SX424 +MDLM0_SX64 +MDLR0_SI1233 +MDLR0_SI1863 +MDLR0_SI603 +MDLR0_SX153 +MDLR0_SX243 +MDLR0_SX333 +MDLR0_SX423 +MDLR0_SX63 +MDLR1_SI1299 +MDLR1_SI1929 +MDLR1_SI669 +MDLR1_SX129 +MDLR1_SX219 +MDLR1_SX309 +MDLR1_SX39 +MDLR1_SX399 +MDMA0_SI1238 +MDMA0_SI1430 +MDMA0_SI2060 +MDMA0_SX170 +MDMA0_SX260 +MDMA0_SX350 +MDMA0_SX440 +MDMA0_SX80 +MDMT0_SI1832 +MDMT0_SI2341 +MDMT0_SI572 +MDMT0_SX122 +MDMT0_SX212 +MDMT0_SX302 +MDMT0_SX32 +MDMT0_SX392 +MDNS0_SI1011 +MDNS0_SI2271 +MDNS0_SI873 +MDNS0_SX111 +MDNS0_SX201 +MDNS0_SX21 +MDNS0_SX291 +MDNS0_SX381 +MDPB0_SI1760 +MDPB0_SI2126 +MDPB0_SI866 +MDPB0_SX146 +MDPB0_SX236 +MDPB0_SX326 +MDPB0_SX416 +MDPB0_SX56 +MDPK0_SI1053 +MDPK0_SI1683 +MDPK0_SI552 +MDPK0_SX153 +MDPK0_SX243 +MDPK0_SX333 +MDPK0_SX423 +MDPK0_SX63 +MDPS0_SI1651 +MDPS0_SI1979 +MDPS0_SI719 +MDPS0_SX179 +MDPS0_SX269 +MDPS0_SX359 +MDPS0_SX449 +MDPS0_SX89 +MDRD0_SI1382 +MDRD0_SI2012 +MDRD0_SI752 +MDRD0_SX122 +MDRD0_SX212 +MDRD0_SX302 +MDRD0_SX32 +MDRD0_SX392 +MDSJ0_SI1462 +MDSJ0_SI2092 +MDSJ0_SI832 +MDSJ0_SX112 +MDSJ0_SX22 +MDSJ0_SX292 +MDSJ0_SX382 +MDSJ0_SX438 +MDSS0_SI1881 +MDSS0_SI2087 +MDSS0_SI621 +MDSS0_SX171 +MDSS0_SX261 +MDSS0_SX351 +MDSS0_SX441 +MDSS0_SX81 +MDSS1_SI1327 +MDSS1_SI1713 +MDSS1_SI697 +MDSS1_SX157 +MDSS1_SX247 +MDSS1_SX337 +MDSS1_SX427 +MDSS1_SX67 +MDTB0_SI1200 +MDTB0_SI1830 +MDTB0_SI570 +MDTB0_SX120 +MDTB0_SX210 +MDTB0_SX300 +MDTB0_SX321 +MDTB0_SX390 +MDWD0_SI1260 +MDWD0_SI1890 +MDWD0_SI557 +MDWD0_SX180 +MDWD0_SX270 +MDWD0_SX360 +MDWD0_SX450 +MDWD0_SX90 +MDWH0_SI1168 +MDWH0_SI1925 +MDWH0_SI665 +MDWH0_SX125 +MDWH0_SX215 +MDWH0_SX305 +MDWH0_SX35 +MDWH0_SX395 +MDWM0_SI1546 +MDWM0_SI2176 +MDWM0_SI916 +MDWM0_SX106 +MDWM0_SX16 +MDWM0_SX286 +MDWM0_SX376 +MDWM0_SX433 +MEAL0_SI1547 +MEAL0_SI2177 +MEAL0_SI917 +MEAL0_SX107 +MEAL0_SX197 +MEAL0_SX287 +MEAL0_SX347 +MEAL0_SX377 +MEDR0_SI1374 +MEDR0_SI2004 +MEDR0_SI744 +MEDR0_SX114 +MEDR0_SX204 +MEDR0_SX24 +MEDR0_SX294 +MEDR0_SX384 +MEFG0_SI465 +MEFG0_SI491 +MEFG0_SI598 +MEFG0_SX105 +MEFG0_SX15 +MEFG0_SX195 +MEFG0_SX285 +MEFG0_SX375 +MEGJ0_SI1337 +MEGJ0_SI1967 +MEGJ0_SI707 +MEGJ0_SX167 +MEGJ0_SX257 +MEGJ0_SX3 +MEGJ0_SX437 +MEGJ0_SX77 +MEJL0_SI1592 +MEJL0_SI1654 +MEJL0_SI962 +MEJL0_SX152 +MEJL0_SX242 +MEJL0_SX332 +MEJL0_SX422 +MEJL0_SX62 +MEJS0_SI1240 +MEJS0_SI1870 +MEJS0_SI610 +MEJS0_SX160 +MEJS0_SX250 +MEJS0_SX340 +MEJS0_SX430 +MEJS0_SX70 +MESG0_SI1332 +MESG0_SI1962 +MESG0_SI702 +MESG0_SX162 +MESG0_SX252 +MESG0_SX342 +MESG0_SX432 +MESG0_SX72 +MESJ0_SI2039 +MESJ0_SI2257 +MESJ0_SI997 +MESJ0_SX187 +MESJ0_SX277 +MESJ0_SX367 +MESJ0_SX7 +MESJ0_SX97 +MEWM0_SI1348 +MEWM0_SI1978 +MEWM0_SI718 +MEWM0_SX178 +MEWM0_SX268 +MEWM0_SX358 +MEWM0_SX448 +MEWM0_SX88 +MFER0_SI1492 +MFER0_SI2122 +MFER0_SI862 +MFER0_SX142 +MFER0_SX232 +MFER0_SX322 +MFER0_SX412 +MFER0_SX52 +MFMC0_SI1132 +MFMC0_SI1762 +MFMC0_SI502 +MFMC0_SX142 +MFMC0_SX232 +MFMC0_SX322 +MFMC0_SX412 +MFMC0_SX52 +MFRM0_SI1155 +MFRM0_SI1717 +MFRM0_SI1785 +MFRM0_SX165 +MFRM0_SX255 +MFRM0_SX345 +MFRM0_SX435 +MFRM0_SX75 +MFWK0_SI1249 +MFWK0_SI1879 +MFWK0_SI619 +MFWK0_SX169 +MFWK0_SX259 +MFWK0_SX349 +MFWK0_SX439 +MFWK0_SX79 +MFXS0_SI1674 +MFXS0_SI2225 +MFXS0_SI2304 +MFXS0_SX144 +MFXS0_SX234 +MFXS0_SX324 +MFXS0_SX414 +MFXS0_SX54 +MFXV0_SI1005 +MFXV0_SI1342 +MFXV0_SI1635 +MFXV0_SX105 +MFXV0_SX15 +MFXV0_SX195 +MFXV0_SX285 +MFXV0_SX375 +MGAF0_SI1282 +MGAF0_SI1912 +MGAF0_SI652 +MGAF0_SX112 +MGAF0_SX202 +MGAF0_SX22 +MGAF0_SX292 +MGAF0_SX382 +MGAG0_SI1321 +MGAG0_SI645 +MGAG0_SI691 +MGAG0_SX151 +MGAG0_SX241 +MGAG0_SX331 +MGAG0_SX421 +MGAG0_SX61 +MGAK0_SI1036 +MGAK0_SI1666 +MGAK0_SI2296 +MGAK0_SX136 +MGAK0_SX226 +MGAK0_SX316 +MGAK0_SX406 +MGAK0_SX46 +MGAR0_SI1212 +MGAR0_SI1694 +MGAR0_SI1842 +MGAR0_SX132 +MGAR0_SX222 +MGAR0_SX312 +MGAR0_SX402 +MGAR0_SX42 +MGAW0_SI1165 +MGAW0_SI1802 +MGAW0_SI535 +MGAW0_SX175 +MGAW0_SX265 +MGAW0_SX355 +MGAW0_SX445 +MGAW0_SX85 +MGES0_SI1481 +MGES0_SI2111 +MGES0_SI851 +MGES0_SX131 +MGES0_SX221 +MGES0_SX311 +MGES0_SX401 +MGES0_SX41 +MGJC0_SI1256 +MGJC0_SI1335 +MGJC0_SI1965 +MGJC0_SX165 +MGJC0_SX255 +MGJC0_SX345 +MGJC0_SX435 +MGJC0_SX75 +MGRL0_SI1497 +MGRL0_SI2127 +MGRL0_SI867 +MGRL0_SX147 +MGRL0_SX237 +MGRL0_SX327 +MGRL0_SX417 +MGRL0_SX57 +MGRP0_SI1317 +MGRP0_SI1947 +MGRP0_SI687 +MGRP0_SX147 +MGRP0_SX237 +MGRP0_SX327 +MGRP0_SX417 +MGRP0_SX57 +MGSH0_SI1176 +MGSH0_SI1806 +MGSH0_SI546 +MGSH0_SX127 +MGSH0_SX186 +MGSH0_SX276 +MGSH0_SX6 +MGSH0_SX96 +MGSL0_SI1164 +MGSL0_SI534 +MGSL0_SI797 +MGSL0_SX174 +MGSL0_SX264 +MGSL0_SX354 +MGSL0_SX444 +MGSL0_SX84 +MGXP0_SI1087 +MGXP0_SI457 +MGXP0_SI525 +MGXP0_SX187 +MGXP0_SX277 +MGXP0_SX367 +MGXP0_SX7 +MGXP0_SX97 +MHBS0_SI1575 +MHBS0_SI2205 +MHBS0_SI945 +MHBS0_SX135 +MHBS0_SX225 +MHBS0_SX315 +MHBS0_SX405 +MHBS0_SX45 +MHIT0_SI1613 +MHIT0_SI2243 +MHIT0_SI983 +MHIT0_SX173 +MHIT0_SX263 +MHIT0_SX353 +MHIT0_SX443 +MHIT0_SX83 +MHJB0_SI1017 +MHJB0_SI1647 +MHJB0_SI2277 +MHJB0_SX117 +MHJB0_SX207 +MHJB0_SX27 +MHJB0_SX297 +MHJB0_SX387 +MHMG0_SI1365 +MHMG0_SI1995 +MHMG0_SI735 +MHMG0_SX105 +MHMG0_SX15 +MHMG0_SX195 +MHMG0_SX285 +MHMG0_SX375 +MHMR0_SI1119 +MHMR0_SI1692 +MHMR0_SI489 +MHMR0_SX129 +MHMR0_SX219 +MHMR0_SX309 +MHMR0_SX39 +MHMR0_SX399 +MHRM0_SI1475 +MHRM0_SI2218 +MHRM0_SI958 +MHRM0_SX148 +MHRM0_SX238 +MHRM0_SX328 +MHRM0_SX418 +MHRM0_SX58 +MHXL0_SI1772 +MHXL0_SI512 +MHXL0_SI612 +MHXL0_SX152 +MHXL0_SX242 +MHXL0_SX332 +MHXL0_SX422 +MHXL0_SX62 +MILB0_SI2163 +MILB0_SI807 +MILB0_SI903 +MILB0_SX183 +MILB0_SX273 +MILB0_SX3 +MILB0_SX363 +MILB0_SX93 +MJAC0_SI1331 +MJAC0_SI2148 +MJAC0_SI701 +MJAC0_SX251 +MJAC0_SX307 +MJAC0_SX341 +MJAC0_SX431 +MJAC0_SX71 +MJAE0_SI1524 +MJAE0_SI1999 +MJAE0_SI2154 +MJAE0_SX174 +MJAE0_SX264 +MJAE0_SX354 +MJAE0_SX444 +MJAE0_SX84 +MJAI0_SI1604 +MJAI0_SI682 +MJAI0_SI710 +MJAI0_SX164 +MJAI0_SX254 +MJAI0_SX344 +MJAI0_SX434 +MJAI0_SX74 +MJBG0_SI1232 +MJBG0_SI1724 +MJBG0_SI1862 +MJBG0_SX152 +MJBG0_SX242 +MJBG0_SX332 +MJBG0_SX422 +MJBG0_SX62 +MJDA0_SI1031 +MJDA0_SI1661 +MJDA0_SI2291 +MJDA0_SX131 +MJDA0_SX221 +MJDA0_SX311 +MJDA0_SX401 +MJDA0_SX41 +MJDC0_SI1161 +MJDC0_SI2165 +MJDC0_SI531 +MJDC0_SX171 +MJDC0_SX261 +MJDC0_SX351 +MJDC0_SX441 +MJDC0_SX81 +MJDE0_SI1120 +MJDE0_SI463 +MJDE0_SI490 +MJDE0_SX130 +MJDE0_SX220 +MJDE0_SX310 +MJDE0_SX40 +MJDE0_SX400 +MJDG0_SI1042 +MJDG0_SI1672 +MJDG0_SI1705 +MJDG0_SX142 +MJDG0_SX232 +MJDG0_SX322 +MJDG0_SX412 +MJDG0_SX52 +MJDM0_SI1340 +MJDM0_SI1937 +MJDM0_SI974 +MJDM0_SX170 +MJDM0_SX260 +MJDM0_SX350 +MJDM0_SX440 +MJDM0_SX80 +MJEB0_SI1286 +MJEB0_SI1916 +MJEB0_SI656 +MJEB0_SX170 +MJEB0_SX206 +MJEB0_SX26 +MJEB0_SX296 +MJEB0_SX386 +MJEB1_SI1467 +MJEB1_SI2097 +MJEB1_SI837 +MJEB1_SX117 +MJEB1_SX207 +MJEB1_SX27 +MJEB1_SX297 +MJEB1_SX387 +MJEE0_SI1237 +MJEE0_SI1867 +MJEE0_SI607 +MJEE0_SX157 +MJEE0_SX247 +MJEE0_SX337 +MJEE0_SX427 +MJEE0_SX67 +MJFH0_SI1107 +MJFH0_SI1737 +MJFH0_SI477 +MJFH0_SX117 +MJFH0_SX207 +MJFH0_SX27 +MJFH0_SX297 +MJFH0_SX387 +MJFR0_SI1605 +MJFR0_SI2235 +MJFR0_SI975 +MJFR0_SX165 +MJFR0_SX255 +MJFR0_SX345 +MJFR0_SX435 +MJFR0_SX75 +MJHI0_SI1328 +MJHI0_SI555 +MJHI0_SI698 +MJHI0_SX158 +MJHI0_SX248 +MJHI0_SX338 +MJHI0_SX428 +MJHI0_SX68 +MJJB0_SI1139 +MJJB0_SI1277 +MJJB0_SI1769 +MJJB0_SX149 +MJJB0_SX239 +MJJB0_SX329 +MJJB0_SX419 +MJJB0_SX59 +MJJJ0_SI1163 +MJJJ0_SI1793 +MJJJ0_SI533 +MJJJ0_SX173 +MJJJ0_SX263 +MJJJ0_SX353 +MJJJ0_SX443 +MJJJ0_SX83 +MJJM0_SI1251 +MJJM0_SI1457 +MJJM0_SI827 +MJJM0_SX107 +MJJM0_SX17 +MJJM0_SX197 +MJJM0_SX287 +MJJM0_SX377 +MJKR0_SI1201 +MJKR0_SI1831 +MJKR0_SI571 +MJKR0_SX121 +MJKR0_SX211 +MJKR0_SX301 +MJKR0_SX31 +MJKR0_SX391 +MJLB0_SI1616 +MJLB0_SI2246 +MJLB0_SI986 +MJLB0_SX176 +MJLB0_SX266 +MJLB0_SX356 +MJLB0_SX446 +MJLB0_SX86 +MJLG1_SI1012 +MJLG1_SI1642 +MJLG1_SI2272 +MJLG1_SX112 +MJLG1_SX202 +MJLG1_SX22 +MJLG1_SX292 +MJLG1_SX382 +MJLS0_SI1096 +MJLS0_SI1726 +MJLS0_SI466 +MJLS0_SX106 +MJLS0_SX16 +MJLS0_SX196 +MJLS0_SX286 +MJLS0_SX376 +MJMA0_SI1495 +MJMA0_SI2125 +MJMA0_SI865 +MJMA0_SX145 +MJMA0_SX235 +MJMA0_SX325 +MJMA0_SX415 +MJMA0_SX55 +MJMD0_SI1028 +MJMD0_SI1658 +MJMD0_SI2288 +MJMD0_SX128 +MJMD0_SX218 +MJMD0_SX308 +MJMD0_SX38 +MJMD0_SX398 +MJMM0_SI1255 +MJMM0_SI1885 +MJMM0_SI625 +MJMM0_SX175 +MJMM0_SX265 +MJMM0_SX355 +MJMM0_SX445 +MJMM0_SX85 +MJPG0_SI1191 +MJPG0_SI1821 +MJPG0_SI561 +MJPG0_SX111 +MJPG0_SX201 +MJPG0_SX21 +MJPG0_SX291 +MJPG0_SX381 +MJPM0_SI1368 +MJPM0_SI1998 +MJPM0_SI738 +MJPM0_SX108 +MJPM0_SX18 +MJPM0_SX198 +MJPM0_SX288 +MJPM0_SX378 +MJPM1_SI1897 +MJPM1_SI2280 +MJPM1_SI761 +MJPM1_SX131 +MJPM1_SX221 +MJPM1_SX311 +MJPM1_SX401 +MJPM1_SX41 +MJRA0_SI1236 +MJRA0_SI1866 +MJRA0_SI606 +MJRA0_SX156 +MJRA0_SX246 +MJRA0_SX336 +MJRA0_SX426 +MJRA0_SX66 +MJRG0_SI1366 +MJRG0_SI1996 +MJRG0_SI736 +MJRG0_SX106 +MJRG0_SX16 +MJRG0_SX286 +MJRG0_SX352 +MJRG0_SX376 +MJRH0_SI1125 +MJRH0_SI1755 +MJRH0_SI1840 +MJRH0_SX135 +MJRH0_SX225 +MJRH0_SX315 +MJRH0_SX405 +MJRH0_SX45 +MJRH1_SI1558 +MJRH1_SI1774 +MJRH1_SI514 +MJRH1_SX154 +MJRH1_SX244 +MJRH1_SX334 +MJRH1_SX424 +MJRH1_SX64 +MJRK0_SI1662 +MJRK0_SI2103 +MJRK0_SI880 +MJRK0_SX160 +MJRK0_SX250 +MJRK0_SX340 +MJRK0_SX430 +MJRK0_SX70 +MJRP0_SI1835 +MJRP0_SI1845 +MJRP0_SI585 +MJRP0_SX135 +MJRP0_SX225 +MJRP0_SX315 +MJRP0_SX405 +MJRP0_SX45 +MJSR0_SI1424 +MJSR0_SI2054 +MJSR0_SI794 +MJSR0_SX164 +MJSR0_SX254 +MJSR0_SX344 +MJSR0_SX434 +MJSR0_SX74 +MJWG0_SI2155 +MJWG0_SI813 +MJWG0_SI895 +MJWG0_SX175 +MJWG0_SX265 +MJWG0_SX355 +MJWG0_SX445 +MJWG0_SX85 +MJWS0_SI1143 +MJWS0_SI1773 +MJWS0_SI513 +MJWS0_SX153 +MJWS0_SX243 +MJWS0_SX333 +MJWS0_SX423 +MJWS0_SX63 +MJWT0_SI1291 +MJWT0_SI1381 +MJWT0_SI751 +MJWT0_SX121 +MJWT0_SX211 +MJWT0_SX301 +MJWT0_SX31 +MJWT0_SX391 +MJXA0_SI1507 +MJXA0_SI2137 +MJXA0_SI877 +MJXA0_SX157 +MJXA0_SX247 +MJXA0_SX337 +MJXA0_SX427 +MJXA0_SX67 +MJXL0_SI1172 +MJXL0_SI1795 +MJXL0_SI542 +MJXL0_SX182 +MJXL0_SX272 +MJXL0_SX362 +MJXL0_SX452 +MJXL0_SX92 +MKAG0_SI1609 +MKAG0_SI2239 +MKAG0_SI979 +MKAG0_SX169 +MKAG0_SX259 +MKAG0_SX30 +MKAG0_SX439 +MKAG0_SX79 +MKAH0_SI1528 +MKAH0_SI2158 +MKAH0_SI898 +MKAH0_SX178 +MKAH0_SX268 +MKAH0_SX358 +MKAH0_SX448 +MKAH0_SX88 +MKAJ0_SI1414 +MKAJ0_SI2044 +MKAJ0_SI784 +MKAJ0_SX154 +MKAJ0_SX244 +MKAJ0_SX334 +MKAJ0_SX424 +MKAJ0_SX64 +MKAM0_SI1250 +MKAM0_SI1316 +MKAM0_SI1465 +MKAM0_SX146 +MKAM0_SX236 +MKAM0_SX326 +MKAM0_SX416 +MKAM0_SX56 +MKDB0_SI2132 +MKDB0_SI588 +MKDB0_SI872 +MKDB0_SX152 +MKDB0_SX242 +MKDB0_SX332 +MKDB0_SX422 +MKDB0_SX62 +MKDD0_SI1567 +MKDD0_SI2197 +MKDD0_SI937 +MKDD0_SX127 +MKDD0_SX217 +MKDD0_SX307 +MKDD0_SX37 +MKDD0_SX397 +MKDT0_SI2153 +MKDT0_SI814 +MKDT0_SI893 +MKDT0_SX173 +MKDT0_SX263 +MKDT0_SX353 +MKDT0_SX443 +MKDT0_SX83 +MKES0_SI1253 +MKES0_SI1883 +MKES0_SI623 +MKES0_SX173 +MKES0_SX263 +MKES0_SX353 +MKES0_SX443 +MKES0_SX83 +MKJO0_SI1517 +MKJO0_SI2147 +MKJO0_SI887 +MKJO0_SX167 +MKJO0_SX257 +MKJO0_SX424 +MKJO0_SX437 +MKJO0_SX77 +MKLN0_SI1598 +MKLN0_SI2228 +MKLN0_SI968 +MKLN0_SX158 +MKLN0_SX248 +MKLN0_SX338 +MKLN0_SX428 +MKLN0_SX68 +MKLR0_SI1059 +MKLR0_SI1689 +MKLR0_SI2319 +MKLR0_SX159 +MKLR0_SX249 +MKLR0_SX339 +MKLR0_SX429 +MKLR0_SX69 +MKLS0_SI1437 +MKLS0_SI1533 +MKLS0_SI2067 +MKLS0_SX177 +MKLS0_SX267 +MKLS0_SX357 +MKLS0_SX447 +MKLS0_SX87 +MKLS1_SI1545 +MKLS1_SI2175 +MKLS1_SI915 +MKLS1_SX105 +MKLS1_SX15 +MKLS1_SX195 +MKLS1_SX285 +MKLS1_SX375 +MKLW0_SI1571 +MKLW0_SI1844 +MKLW0_SI2201 +MKLW0_SX131 +MKLW0_SX221 +MKLW0_SX311 +MKLW0_SX401 +MKLW0_SX41 +MKRG0_SI1491 +MKRG0_SI2121 +MKRG0_SI861 +MKRG0_SX141 +MKRG0_SX231 +MKRG0_SX31 +MKRG0_SX411 +MKRG0_SX51 +MKXL0_SI1185 +MKXL0_SI1815 +MKXL0_SI1958 +MKXL0_SX105 +MKXL0_SX15 +MKXL0_SX195 +MKXL0_SX285 +MKXL0_SX375 +MLBC0_SI1239 +MLBC0_SI1869 +MLBC0_SI609 +MLBC0_SX159 +MLBC0_SX249 +MLBC0_SX339 +MLBC0_SX429 +MLBC0_SX69 +MLEL0_SI1246 +MLEL0_SI1876 +MLEL0_SI616 +MLEL0_SX166 +MLEL0_SX256 +MLEL0_SX346 +MLEL0_SX436 +MLEL0_SX76 +MLJC0_SI1225 +MLJC0_SI1855 +MLJC0_SI595 +MLJC0_SX145 +MLJC0_SX235 +MLJC0_SX325 +MLJC0_SX415 +MLJC0_SX55 +MLJH0_SI1324 +MLJH0_SI1422 +MLJH0_SI694 +MLJH0_SX154 +MLJH0_SX244 +MLJH0_SX334 +MLJH0_SX424 +MLJH0_SX64 +MLNS0_SI1407 +MLNS0_SI2037 +MLNS0_SI777 +MLNS0_SX147 +MLNS0_SX237 +MLNS0_SX327 +MLNS0_SX417 +MLNS0_SX57 +MLSH0_SI1417 +MLSH0_SI2047 +MLSH0_SI787 +MLSH0_SX157 +MLSH0_SX247 +MLSH0_SX337 +MLSH0_SX427 +MLSH0_SX67 +MMAA0_SI1588 +MMAA0_SI2105 +MMAA0_SI845 +MMAA0_SX125 +MMAA0_SX215 +MMAA0_SX305 +MMAA0_SX35 +MMAA0_SX395 +MMAB1_SI1494 +MMAB1_SI2124 +MMAB1_SI864 +MMAB1_SX144 +MMAB1_SX234 +MMAB1_SX324 +MMAB1_SX414 +MMAB1_SX54 +MMAG0_SI1126 +MMAG0_SI1756 +MMAG0_SI496 +MMAG0_SX136 +MMAG0_SX226 +MMAG0_SX316 +MMAG0_SX406 +MMAG0_SX46 +MMAM0_SI1597 +MMAM0_SI1668 +MMAM0_SI2227 +MMAM0_SX157 +MMAM0_SX247 +MMAM0_SX337 +MMAM0_SX427 +MMAM0_SX67 +MMAR0_SI1336 +MMAR0_SI1966 +MMAR0_SI706 +MMAR0_SX166 +MMAR0_SX256 +MMAR0_SX346 +MMAR0_SX436 +MMAR0_SX76 +MMBS0_SI1151 +MMBS0_SI1781 +MMBS0_SI521 +MMBS0_SX161 +MMBS0_SX251 +MMBS0_SX341 +MMBS0_SX431 +MMBS0_SX71 +MMCC0_SI1338 +MMCC0_SI1968 +MMCC0_SI708 +MMCC0_SX168 +MMCC0_SX258 +MMCC0_SX348 +MMCC0_SX438 +MMCC0_SX78 +MMDB0_SI1358 +MMDB0_SI1617 +MMDB0_SI987 +MMDB0_SX177 +MMDB0_SX267 +MMDB0_SX357 +MMDB0_SX447 +MMDB0_SX87 +MMDG0_SI1780 +MMDG0_SI2035 +MMDG0_SI520 +MMDG0_SX160 +MMDG0_SX250 +MMDG0_SX340 +MMDG0_SX430 +MMDG0_SX70 +MMDM0_SI1311 +MMDM0_SI1941 +MMDM0_SI681 +MMDM0_SX141 +MMDM0_SX231 +MMDM0_SX321 +MMDM0_SX411 +MMDM0_SX51 +MMDM1_SI1650 +MMDM1_SI2043 +MMDM1_SI783 +MMDM1_SX153 +MMDM1_SX243 +MMDM1_SX333 +MMDM1_SX423 +MMDM1_SX63 +MMDS0_SI1343 +MMDS0_SI1973 +MMDS0_SI713 +MMDS0_SX173 +MMDS0_SX263 +MMDS0_SX353 +MMDS0_SX443 +MMDS0_SX83 +MMEA0_SI1388 +MMEA0_SI2018 +MMEA0_SI758 +MMEA0_SX128 +MMEA0_SX218 +MMEA0_SX308 +MMEA0_SX38 +MMEA0_SX398 +MMEB0_SI1357 +MMEB0_SI1987 +MMEB0_SI727 +MMEB0_SX187 +MMEB0_SX327 +MMEB0_SX367 +MMEB0_SX7 +MMEB0_SX97 +MMGC0_SI1305 +MMGC0_SI1935 +MMGC0_SI2184 +MMGC0_SX135 +MMGC0_SX225 +MMGC0_SX315 +MMGC0_SX405 +MMGC0_SX45 +MMGG0_SI1079 +MMGG0_SI1709 +MMGG0_SI2339 +MMGG0_SX179 +MMGG0_SX269 +MMGG0_SX359 +MMGG0_SX449 +MMGG0_SX89 +MMGK0_SI1322 +MMGK0_SI1952 +MMGK0_SI692 +MMGK0_SX152 +MMGK0_SX242 +MMGK0_SX332 +MMGK0_SX422 +MMGK0_SX62 +MMJB1_SI1408 +MMJB1_SI2038 +MMJB1_SI778 +MMJB1_SX148 +MMJB1_SX238 +MMJB1_SX328 +MMJB1_SX418 +MMJB1_SX58 +MMLM0_SI1527 +MMLM0_SI2150 +MMLM0_SI897 +MMLM0_SX177 +MMLM0_SX267 +MMLM0_SX357 +MMLM0_SX447 +MMLM0_SX87 +MMPM0_SI1061 +MMPM0_SI1691 +MMPM0_SI2321 +MMPM0_SX161 +MMPM0_SX251 +MMPM0_SX341 +MMPM0_SX431 +MMPM0_SX71 +MMRP0_SI2034 +MMRP0_SI717 +MMRP0_SI774 +MMRP0_SX144 +MMRP0_SX234 +MMRP0_SX324 +MMRP0_SX414 +MMRP0_SX54 +MMSM0_SI1106 +MMSM0_SI1736 +MMSM0_SI476 +MMSM0_SX116 +MMSM0_SX206 +MMSM0_SX26 +MMSM0_SX296 +MMSM0_SX386 +MMVP0_SI1284 +MMVP0_SI1914 +MMVP0_SI654 +MMVP0_SX114 +MMVP0_SX204 +MMVP0_SX294 +MMVP0_SX347 +MMVP0_SX384 +MMWB0_SI1619 +MMWB0_SI2249 +MMWB0_SI989 +MMWB0_SX179 +MMWB0_SX269 +MMWB0_SX359 +MMWB0_SX449 +MMWB0_SX89 +MMWS0_SI1518 +MMWS0_SI559 +MMWS0_SI888 +MMWS0_SX168 +MMWS0_SX258 +MMWS0_SX348 +MMWS0_SX438 +MMWS0_SX78 +MMWS1_SI1071 +MMWS1_SI1701 +MMWS1_SI2331 +MMWS1_SX261 +MMWS1_SX27 +MMWS1_SX351 +MMWS1_SX441 +MMWS1_SX81 +MMXS0_SI2136 +MMXS0_SI629 +MMXS0_SI876 +MMXS0_SX156 +MMXS0_SX246 +MMXS0_SX336 +MMXS0_SX426 +MMXS0_SX66 +MNET0_SI1446 +MNET0_SI2076 +MNET0_SI816 +MNET0_SX186 +MNET0_SX276 +MNET0_SX366 +MNET0_SX6 +MNET0_SX96 +MNTW0_SI1068 +MNTW0_SI1698 +MNTW0_SI2328 +MNTW0_SX168 +MNTW0_SX202 +MNTW0_SX258 +MNTW0_SX348 +MNTW0_SX78 +MPAR0_SI1576 +MPAR0_SI2206 +MPAR0_SI946 +MPAR0_SX136 +MPAR0_SX226 +MPAR0_SX316 +MPAR0_SX406 +MPAR0_SX46 +MPEB0_SI1034 +MPEB0_SI1860 +MPEB0_SI600 +MPEB0_SX150 +MPEB0_SX240 +MPEB0_SX330 +MPEB0_SX420 +MPEB0_SX60 +MPFU0_SI1258 +MPFU0_SI1888 +MPFU0_SI628 +MPFU0_SX178 +MPFU0_SX268 +MPFU0_SX358 +MPFU0_SX448 +MPFU0_SX88 +MPGH0_SI1554 +MPGH0_SI675 +MPGH0_SI924 +MPGH0_SX114 +MPGH0_SX204 +MPGH0_SX24 +MPGH0_SX294 +MPGH0_SX384 +MPGR0_SI1410 +MPGR0_SI2040 +MPGR0_SI780 +MPGR0_SX150 +MPGR0_SX240 +MPGR0_SX330 +MPGR0_SX420 +MPGR0_SX60 +MPGR1_SI1269 +MPGR1_SI1499 +MPGR1_SI2129 +MPGR1_SX149 +MPGR1_SX239 +MPGR1_SX329 +MPGR1_SX419 +MPGR1_SX59 +MPMB0_SI1501 +MPMB0_SI2131 +MPMB0_SI871 +MPMB0_SX151 +MPMB0_SX241 +MPMB0_SX331 +MPMB0_SX421 +MPMB0_SX61 +MPPC0_SI1412 +MPPC0_SI2042 +MPPC0_SI782 +MPPC0_SX152 +MPPC0_SX242 +MPPC0_SX332 +MPPC0_SX422 +MPPC0_SX62 +MPRB0_SI1205 +MPRB0_SI1215 +MPRB0_SI575 +MPRB0_SX125 +MPRB0_SX215 +MPRB0_SX305 +MPRB0_SX35 +MPRB0_SX395 +MPRD0_SI1431 +MPRD0_SI2061 +MPRD0_SI801 +MPRD0_SX171 +MPRD0_SX261 +MPRD0_SX351 +MPRD0_SX441 +MPRD0_SX81 +MPRK0_SI1097 +MPRK0_SI1727 +MPRK0_SI467 +MPRK0_SX107 +MPRK0_SX17 +MPRK0_SX197 +MPRK0_SX287 +MPRK0_SX377 +MPRT0_SI1210 +MPRT0_SI495 +MPRT0_SI580 +MPRT0_SX130 +MPRT0_SX220 +MPRT0_SX310 +MPRT0_SX40 +MPRT0_SX400 +MPSW0_SI1067 +MPSW0_SI1697 +MPSW0_SI2327 +MPSW0_SX167 +MPSW0_SX24 +MPSW0_SX257 +MPSW0_SX437 +MPSW0_SX77 +MRAB0_SI1224 +MRAB0_SI1854 +MRAB0_SI594 +MRAB0_SX144 +MRAB0_SX234 +MRAB0_SX324 +MRAB0_SX414 +MRAB0_SX54 +MRAB1_SI1478 +MRAB1_SI2108 +MRAB1_SI848 +MRAB1_SX128 +MRAB1_SX218 +MRAB1_SX308 +MRAB1_SX38 +MRAB1_SX398 +MRAI0_SI1954 +MRAI0_SI2052 +MRAI0_SI792 +MRAI0_SX162 +MRAI0_SX252 +MRAI0_SX342 +MRAI0_SX432 +MRAI0_SX72 +MRAM0_SI1275 +MRAM0_SI1905 +MRAM0_SI1951 +MRAM0_SX105 +MRAM0_SX15 +MRAM0_SX195 +MRAM0_SX285 +MRAM0_SX375 +MRAV0_SI1008 +MRAV0_SI1638 +MRAV0_SI2268 +MRAV0_SX108 +MRAV0_SX18 +MRAV0_SX198 +MRAV0_SX288 +MRAV0_SX378 +MRBC0_SI1665 +MRBC0_SI1859 +MRBC0_SI599 +MRBC0_SX149 +MRBC0_SX239 +MRBC0_SX329 +MRBC0_SX419 +MRBC0_SX59 +MRCG0_SI1428 +MRCG0_SI2058 +MRCG0_SI798 +MRCG0_SX168 +MRCG0_SX258 +MRCG0_SX348 +MRCG0_SX438 +MRCG0_SX78 +MRCW0_SI1371 +MRCW0_SI2001 +MRCW0_SI741 +MRCW0_SX111 +MRCW0_SX201 +MRCW0_SX21 +MRCW0_SX291 +MRCW0_SX381 +MRDD0_SI1050 +MRDD0_SI1680 +MRDD0_SI2310 +MRDD0_SX150 +MRDD0_SX240 +MRDD0_SX277 +MRDD0_SX330 +MRDD0_SX60 +MRDM0_SI1044 +MRDM0_SI1595 +MRDM0_SI965 +MRDM0_SX155 +MRDM0_SX245 +MRDM0_SX335 +MRDM0_SX425 +MRDM0_SX65 +MRDS0_SI1167 +MRDS0_SI1797 +MRDS0_SI537 +MRDS0_SX177 +MRDS0_SX267 +MRDS0_SX357 +MRDS0_SX447 +MRDS0_SX87 +MREE0_SI1104 +MREE0_SI1734 +MREE0_SI1959 +MREE0_SX114 +MREE0_SX204 +MREE0_SX24 +MREE0_SX294 +MREE0_SX384 +MREH1_SI1599 +MREH1_SI2229 +MREH1_SI969 +MREH1_SX159 +MREH1_SX249 +MREH1_SX339 +MREH1_SX429 +MREH1_SX69 +MREM0_SI1591 +MREM0_SI511 +MREM0_SI961 +MREM0_SX151 +MREM0_SX241 +MREM0_SX331 +MREM0_SX421 +MREM0_SX61 +MREW1_SI1500 +MREW1_SI2130 +MREW1_SI870 +MREW1_SX150 +MREW1_SX240 +MREW1_SX330 +MREW1_SX420 +MREW1_SX60 +MRFK0_SI1076 +MRFK0_SI1706 +MRFK0_SI2336 +MRFK0_SX176 +MRFK0_SX266 +MRFK0_SX356 +MRFK0_SX446 +MRFK0_SX86 +MRFL0_SI1156 +MRFL0_SI1786 +MRFL0_SI526 +MRFL0_SX166 +MRFL0_SX256 +MRFL0_SX346 +MRFL0_SX436 +MRFL0_SX76 +MRGM0_SI1162 +MRGM0_SI1792 +MRGM0_SI532 +MRGM0_SX172 +MRGM0_SX262 +MRGM0_SX416 +MRGM0_SX442 +MRGM0_SX82 +MRGS0_SI1356 +MRGS0_SI1986 +MRGS0_SI726 +MRGS0_SX186 +MRGS0_SX276 +MRGS0_SX366 +MRGS0_SX6 +MRGS0_SX96 +MRHL0_SI1515 +MRHL0_SI2145 +MRHL0_SI885 +MRHL0_SX165 +MRHL0_SX255 +MRHL0_SX345 +MRHL0_SX435 +MRHL0_SX75 +MRJB1_SI1020 +MRJB1_SI1413 +MRJB1_SI2021 +MRJB1_SX120 +MRJB1_SX210 +MRJB1_SX30 +MRJB1_SX300 +MRJB1_SX390 +MRJH0_SI1519 +MRJH0_SI889 +MRJH0_SI914 +MRJH0_SX169 +MRJH0_SX259 +MRJH0_SX307 +MRJH0_SX439 +MRJH0_SX79 +MRJM0_SI1095 +MRJM0_SI1228 +MRJM0_SI1858 +MRJM0_SX148 +MRJM0_SX238 +MRJM0_SX328 +MRJM0_SX418 +MRJM0_SX58 +MRJM1_SI1298 +MRJM1_SI1928 +MRJM1_SI668 +MRJM1_SX128 +MRJM1_SX218 +MRJM1_SX308 +MRJM1_SX38 +MRJM1_SX398 +MRJT0_SI1498 +MRJT0_SI1805 +MRJT0_SI868 +MRJT0_SX148 +MRJT0_SX238 +MRJT0_SX328 +MRJT0_SX418 +MRJT0_SX58 +MRKM0_SI1267 +MRKM0_SI1391 +MRKM0_SI637 +MRKM0_SX187 +MRKM0_SX277 +MRKM0_SX367 +MRKM0_SX7 +MRKM0_SX97 +MRLD0_SI1594 +MRLD0_SI2224 +MRLD0_SI964 +MRLD0_SX154 +MRLD0_SX244 +MRLD0_SX334 +MRLD0_SX424 +MRLD0_SX64 +MRLJ0_SI1420 +MRLJ0_SI2050 +MRLJ0_SI790 +MRLJ0_SX160 +MRLJ0_SX250 +MRLJ0_SX340 +MRLJ0_SX430 +MRLJ0_SX70 +MRLJ1_SI1671 +MRLJ1_SI2301 +MRLJ1_SI2332 +MRLJ1_SX141 +MRLJ1_SX231 +MRLJ1_SX321 +MRLJ1_SX411 +MRLJ1_SX51 +MRLK0_SI1468 +MRLK0_SI2140 +MRLK0_SI843 +MRLK0_SX123 +MRLK0_SX213 +MRLK0_SX303 +MRLK0_SX33 +MRLK0_SX393 +MRLR0_SI1196 +MRLR0_SI1826 +MRLR0_SI566 +MRLR0_SX116 +MRLR0_SX206 +MRLR0_SX26 +MRLR0_SX296 +MRLR0_SX386 +MRMB0_SI1581 +MRMB0_SI2211 +MRMB0_SI951 +MRMB0_SX141 +MRMB0_SX231 +MRMB0_SX321 +MRMB0_SX411 +MRMB0_SX51 +MRMG0_SI1080 +MRMG0_SI1710 +MRMG0_SI2340 +MRMG0_SX180 +MRMG0_SX270 +MRMG0_SX360 +MRMG0_SX450 +MRMG0_SX90 +MRMH0_SI1021 +MRMH0_SI1349 +MRMH0_SI2281 +MRMH0_SX121 +MRMH0_SX211 +MRMH0_SX301 +MRMH0_SX31 +MRMH0_SX391 +MRML0_SI1421 +MRML0_SI2051 +MRML0_SI791 +MRML0_SX161 +MRML0_SX251 +MRML0_SX341 +MRML0_SX431 +MRML0_SX71 +MRMS0_SI1113 +MRMS0_SI2057 +MRMS0_SI2100 +MRMS0_SX120 +MRMS0_SX210 +MRMS0_SX30 +MRMS0_SX300 +MRMS0_SX390 +MRPC1_SI1482 +MRPC1_SI2026 +MRPC1_SI2112 +MRPC1_SX132 +MRPC1_SX222 +MRPC1_SX312 +MRPC1_SX402 +MRPC1_SX42 +MRRE0_SI1334 +MRRE0_SI704 +MRRE0_SI952 +MRRE0_SX164 +MRRE0_SX254 +MRRE0_SX344 +MRRE0_SX434 +MRRE0_SX74 +MRSO0_SI1206 +MRSO0_SI1659 +MRSO0_SI2289 +MRSO0_SX129 +MRSO0_SX219 +MRSO0_SX309 +MRSO0_SX39 +MRSO0_SX399 +MRSP0_SI1429 +MRSP0_SI2059 +MRSP0_SI799 +MRSP0_SX169 +MRSP0_SX196 +MRSP0_SX259 +MRSP0_SX439 +MRSP0_SX79 +MRTC0_SI1458 +MRTC0_SI2088 +MRTC0_SI828 +MRTC0_SX108 +MRTC0_SX18 +MRTC0_SX198 +MRTC0_SX288 +MRTC0_SX378 +MRTJ0_SI1551 +MRTJ0_SI2032 +MRTJ0_SI772 +MRTJ0_SX142 +MRTJ0_SX232 +MRTJ0_SX322 +MRTJ0_SX412 +MRTJ0_SX52 +MRVG0_SI1140 +MRVG0_SI1770 +MRVG0_SI510 +MRVG0_SX150 +MRVG0_SX240 +MRVG0_SX330 +MRVG0_SX420 +MRVG0_SX60 +MRWA0_SI1603 +MRWA0_SI2233 +MRWA0_SI973 +MRWA0_SX163 +MRWA0_SX253 +MRWA0_SX343 +MRWA0_SX433 +MRWA0_SX73 +MRWS0_SI1102 +MRWS0_SI1732 +MRWS0_SI472 +MRWS0_SX112 +MRWS0_SX202 +MRWS0_SX22 +MRWS0_SX292 +MRWS0_SX382 +MRXB0_SI1585 +MRXB0_SI2215 +MRXB0_SI955 +MRXB0_SX145 +MRXB0_SX235 +MRXB0_SX325 +MRXB0_SX415 +MRXB0_SX55 +MSAH1_SI1049 +MSAH1_SI1679 +MSAH1_SI2309 +MSAH1_SX149 +MSAH1_SX239 +MSAH1_SX329 +MSAH1_SX419 +MSAH1_SX59 +MSAS0_SI1376 +MSAS0_SI2006 +MSAS0_SI746 +MSAS0_SX116 +MSAS0_SX206 +MSAS0_SX26 +MSAS0_SX296 +MSAS0_SX386 +MSAT0_SI1526 +MSAT0_SI2156 +MSAT0_SI896 +MSAT0_SX176 +MSAT0_SX266 +MSAT0_SX356 +MSAT0_SX446 +MSAT0_SX86 +MSAT1_SI1073 +MSAT1_SI1703 +MSAT1_SI2333 +MSAT1_SX173 +MSAT1_SX263 +MSAT1_SX353 +MSAT1_SX443 +MSAT1_SX83 +MSDB0_SI1007 +MSDB0_SI1637 +MSDB0_SI2267 +MSDB0_SX107 +MSDB0_SX17 +MSDB0_SX197 +MSDB0_SX287 +MSDB0_SX377 +MSDH0_SI2113 +MSDH0_SI2240 +MSDH0_SI980 +MSDH0_SX170 +MSDH0_SX260 +MSDH0_SX350 +MSDH0_SX440 +MSDH0_SX80 +MSDS0_SI1077 +MSDS0_SI1707 +MSDS0_SI2337 +MSDS0_SX177 +MSDS0_SX267 +MSDS0_SX357 +MSDS0_SX447 +MSDS0_SX87 +MSEM1_SI1440 +MSEM1_SI2070 +MSEM1_SI810 +MSEM1_SX180 +MSEM1_SX270 +MSEM1_SX360 +MSEM1_SX450 +MSEM1_SX90 +MSES0_SI1589 +MSES0_SI2216 +MSES0_SI2219 +MSES0_SX149 +MSES0_SX239 +MSES0_SX329 +MSES0_SX419 +MSES0_SX59 +MSFH0_SI1216 +MSFH0_SI1738 +MSFH0_SI586 +MSFH0_SX136 +MSFH0_SX226 +MSFH0_SX316 +MSFH0_SX406 +MSFH0_SX46 +MSFV0_SI1262 +MSFV0_SI1892 +MSFV0_SI632 +MSFV0_SX182 +MSFV0_SX272 +MSFV0_SX362 +MSFV0_SX452 +MSFV0_SX92 +MSJK0_SI1596 +MSJK0_SI2226 +MSJK0_SI966 +MSJK0_SX156 +MSJK0_SX246 +MSJK0_SX336 +MSJK0_SX426 +MSJK0_SX66 +MSMC0_SI1907 +MSMC0_SI509 +MSMC0_SI647 +MSMC0_SX107 +MSMC0_SX17 +MSMC0_SX197 +MSMC0_SX287 +MSMC0_SX377 +MSMR0_SI1150 +MSMR0_SI1405 +MSMR0_SI775 +MSMR0_SX145 +MSMR0_SX235 +MSMR0_SX325 +MSMR0_SX415 +MSMR0_SX55 +MSMS0_SI1433 +MSMS0_SI2063 +MSMS0_SI803 +MSMS0_SX173 +MSMS0_SX263 +MSMS0_SX353 +MSMS0_SX443 +MSMS0_SX83 +MSRG0_SI1221 +MSRG0_SI1851 +MSRG0_SI591 +MSRG0_SX141 +MSRG0_SX231 +MSRG0_SX321 +MSRG0_SX411 +MSRG0_SX51 +MSRR0_SI1131 +MSRR0_SI1761 +MSRR0_SI501 +MSRR0_SX141 +MSRR0_SX231 +MSRR0_SX30 +MSRR0_SX411 +MSRR0_SX51 +MSTF0_SI1396 +MSTF0_SI766 +MSTF0_SI852 +MSTF0_SX136 +MSTF0_SX226 +MSTF0_SX316 +MSTF0_SX406 +MSTF0_SX46 +MSVS0_SI1568 +MSVS0_SI2198 +MSVS0_SI938 +MSVS0_SX128 +MSVS0_SX218 +MSVS0_SX308 +MSVS0_SX38 +MSVS0_SX398 +MTAB0_SI1572 +MTAB0_SI2202 +MTAB0_SI942 +MTAB0_SX132 +MTAB0_SX222 +MTAB0_SX312 +MTAB0_SX402 +MTAB0_SX42 +MTAS0_SI1385 +MTAS0_SI2015 +MTAS0_SI755 +MTAS0_SX125 +MTAS0_SX215 +MTAS0_SX305 +MTAS0_SX35 +MTAS0_SX395 +MTAT0_SI1110 +MTAT0_SI1740 +MTAT0_SI811 +MTAT0_SX120 +MTAT0_SX210 +MTAT0_SX30 +MTAT0_SX300 +MTAT0_SX390 +MTAT1_SI1409 +MTAT1_SI1627 +MTAT1_SI779 +MTAT1_SX149 +MTAT1_SX239 +MTAT1_SX329 +MTAT1_SX419 +MTAT1_SX59 +MTBC0_SI1173 +MTBC0_SI1803 +MTBC0_SI543 +MTBC0_SX183 +MTBC0_SX273 +MTBC0_SX347 +MTBC0_SX363 +MTBC0_SX93 +MTCS0_SI1972 +MTCS0_SI2265 +MTCS0_SI712 +MTCS0_SX172 +MTCS0_SX262 +MTCS0_SX352 +MTCS0_SX442 +MTCS0_SX82 +MTDB0_SI1401 +MTDB0_SI2031 +MTDB0_SI771 +MTDB0_SX141 +MTDB0_SX231 +MTDB0_SX321 +MTDB0_SX411 +MTDB0_SX51 +MTDP0_SI1274 +MTDP0_SI1521 +MTDP0_SI2151 +MTDP0_SX171 +MTDP0_SX261 +MTDP0_SX351 +MTDP0_SX441 +MTDP0_SX81 +MTER0_SI1157 +MTER0_SI1787 +MTER0_SI527 +MTER0_SX167 +MTER0_SX17 +MTER0_SX257 +MTER0_SX437 +MTER0_SX77 +MTJG0_SI1520 +MTJG0_SI2157 +MTJG0_SI890 +MTJG0_SX170 +MTJG0_SX260 +MTJG0_SX350 +MTJG0_SX440 +MTJG0_SX80 +MTJM0_SI1226 +MTJM0_SI1856 +MTJM0_SI655 +MTJM0_SX146 +MTJM0_SX236 +MTJM0_SX326 +MTJM0_SX416 +MTJM0_SX56 +MTJS0_SI1192 +MTJS0_SI1822 +MTJS0_SI562 +MTJS0_SX112 +MTJS0_SX202 +MTJS0_SX22 +MTJS0_SX292 +MTJS0_SX382 +MTJU0_SI2020 +MTJU0_SI2269 +MTJU0_SI760 +MTJU0_SX130 +MTJU0_SX220 +MTJU0_SX310 +MTJU0_SX40 +MTJU0_SX400 +MTKD0_SI1187 +MTKD0_SI1817 +MTKD0_SI630 +MTKD0_SX107 +MTKD0_SX17 +MTKD0_SX197 +MTKD0_SX287 +MTKD0_SX377 +MTKP0_SI1023 +MTKP0_SI2283 +MTKP0_SI454 +MTKP0_SX123 +MTKP0_SX213 +MTKP0_SX303 +MTKP0_SX33 +MTKP0_SX393 +MTLB0_SI1134 +MTLB0_SI1764 +MTLB0_SI504 +MTLB0_SX144 +MTLB0_SX234 +MTLB0_SX324 +MTLB0_SX414 +MTLB0_SX54 +MTLC0_SI1313 +MTLC0_SI1477 +MTLC0_SI847 +MTLC0_SX127 +MTLC0_SX217 +MTLC0_SX307 +MTLC0_SX37 +MTLC0_SX397 +MTML0_SI1065 +MTML0_SI1695 +MTML0_SI2325 +MTML0_SX165 +MTML0_SX255 +MTML0_SX345 +MTML0_SX435 +MTML0_SX75 +MTMN0_SI1064 +MTMN0_SI2324 +MTMN0_SI582 +MTMN0_SX164 +MTMN0_SX254 +MTMN0_SX344 +MTMN0_SX434 +MTMN0_SX74 +MTMT0_SI1118 +MTMT0_SI1748 +MTMT0_SI488 +MTMT0_SX128 +MTMT0_SX218 +MTMT0_SX308 +MTMT0_SX38 +MTMT0_SX398 +MTPF0_SI1235 +MTPF0_SI1865 +MTPF0_SI605 +MTPF0_SX155 +MTPF0_SX245 +MTPF0_SX335 +MTPF0_SX425 +MTPF0_SX65 +MTPG0_SI1383 +MTPG0_SI2013 +MTPG0_SI753 +MTPG0_SX123 +MTPG0_SX213 +MTPG0_SX303 +MTPG0_SX33 +MTPG0_SX393 +MTPP0_SI1508 +MTPP0_SI2138 +MTPP0_SI878 +MTPP0_SX158 +MTPP0_SX248 +MTPP0_SX338 +MTPP0_SX428 +MTPP0_SX68 +MTPR0_SI1600 +MTPR0_SI2230 +MTPR0_SI506 +MTPR0_SX160 +MTPR0_SX250 +MTPR0_SX340 +MTPR0_SX430 +MTPR0_SX70 +MTQC0_SI1441 +MTQC0_SI2071 +MTQC0_SI480 +MTQC0_SX181 +MTQC0_SX271 +MTQC0_SX361 +MTQC0_SX451 +MTQC0_SX91 +MTRC0_SI1623 +MTRC0_SI589 +MTRC0_SI993 +MTRC0_SX170 +MTRC0_SX183 +MTRC0_SX273 +MTRC0_SX363 +MTRC0_SX93 +MTRR0_SI1548 +MTRR0_SI2178 +MTRR0_SI918 +MTRR0_SX108 +MTRR0_SX18 +MTRR0_SX198 +MTRR0_SX288 +MTRR0_SX378 +MTRT0_SI1227 +MTRT0_SI1857 +MTRT0_SI597 +MTRT0_SX147 +MTRT0_SX237 +MTRT0_SX254 +MTRT0_SX417 +MTRT0_SX57 +MTWH1_SI1512 +MTWH1_SI2142 +MTWH1_SI882 +MTWH1_SX162 +MTWH1_SX252 +MTWH1_SX342 +MTWH1_SX432 +MTWH1_SX72 +MTXS0_SI1060 +MTXS0_SI1690 +MTXS0_SI2320 +MTXS0_SX160 +MTXS0_SX250 +MTXS0_SX340 +MTXS0_SX430 +MTXS0_SX70 +MVJH0_SI1556 +MVJH0_SI2186 +MVJH0_SI926 +MVJH0_SX116 +MVJH0_SX206 +MVJH0_SX26 +MVJH0_SX296 +MVJH0_SX386 +MVLO0_SI1147 +MVLO0_SI1777 +MVLO0_SI517 +MVLO0_SX157 +MVLO0_SX247 +MVLO0_SX337 +MVLO0_SX427 +MVLO0_SX67 +MVRW0_SI1485 +MVRW0_SI2115 +MVRW0_SI855 +MVRW0_SX135 +MVRW0_SX225 +MVRW0_SX315 +MVRW0_SX405 +MVRW0_SX45 +MWAC0_SI1601 +MWAC0_SI2231 +MWAC0_SI971 +MWAC0_SX161 +MWAC0_SX251 +MWAC0_SX341 +MWAC0_SX431 +MWAC0_SX71 +MWAD0_SI1062 +MWAD0_SI1749 +MWAD0_SI2322 +MWAD0_SX162 +MWAD0_SX252 +MWAD0_SX342 +MWAD0_SX432 +MWAD0_SX72 +MWAR0_SI1045 +MWAR0_SI1675 +MWAR0_SI2305 +MWAR0_SX145 +MWAR0_SX235 +MWAR0_SX325 +MWAR0_SX415 +MWAR0_SX55 +MWCH0_SI1622 +MWCH0_SI1895 +MWCH0_SI2252 +MWCH0_SX182 +MWCH0_SX272 +MWCH0_SX362 +MWCH0_SX452 +MWCH0_SX92 +MWDK0_SI1436 +MWDK0_SI2017 +MWDK0_SI806 +MWDK0_SX176 +MWDK0_SX266 +MWDK0_SX356 +MWDK0_SX446 +MWDK0_SX86 +MWEM0_SI1320 +MWEM0_SI1393 +MWEM0_SI1950 +MWEM0_SX150 +MWEM0_SX240 +MWEM0_SX330 +MWEM0_SX420 +MWEM0_SX60 +MWGR0_SI1606 +MWGR0_SI2236 +MWGR0_SI976 +MWGR0_SX166 +MWGR0_SX256 +MWGR0_SX346 +MWGR0_SX436 +MWGR0_SX76 +MWRE0_SI1057 +MWRE0_SI1687 +MWRE0_SI2317 +MWRE0_SX157 +MWRE0_SX247 +MWRE0_SX337 +MWRE0_SX427 +MWRE0_SX67 +MWRP0_SI1443 +MWRP0_SI1525 +MWRP0_SI2073 +MWRP0_SX183 +MWRP0_SX273 +MWRP0_SX3 +MWRP0_SX363 +MWRP0_SX93 +MWSB0_SI1626 +MWSB0_SI2256 +MWSB0_SI996 +MWSB0_SX186 +MWSB0_SX276 +MWSB0_SX366 +MWSB0_SX6 +MWSB0_SX96 +MWSH0_SI1426 +MWSH0_SI2266 +MWSH0_SI796 +MWSH0_SX166 +MWSH0_SX256 +MWSH0_SX346 +MWSH0_SX436 +MWSH0_SX76 +MZMB0_SI1166 +MZMB0_SI1796 +MZMB0_SI536 +MZMB0_SX176 +MZMB0_SX266 +MZMB0_SX356 +MZMB0_SX446 +MZMB0_SX86 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_matched/valid.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/valid.uid new file mode 100644 index 0000000000000000000000000000000000000000..ab5ef381ab9319aa9aefa9054e0a5128aec6f5e1 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_matched/valid.uid @@ -0,0 +1,400 @@ +FADG0_SI1279 +FADG0_SI1909 +FADG0_SI649 +FADG0_SX109 +FADG0_SX19 +FADG0_SX199 +FADG0_SX289 +FADG0_SX379 +FAKS0_SI1573 +FAKS0_SI2203 +FAKS0_SI943 +FAKS0_SX133 +FAKS0_SX223 +FAKS0_SX313 +FAKS0_SX403 +FAKS0_SX43 +FCAL1_SI1403 +FCAL1_SI2033 +FCAL1_SI773 +FCAL1_SX143 +FCAL1_SX233 +FCAL1_SX323 +FCAL1_SX413 +FCAL1_SX53 +FCMH0_SI1454 +FCMH0_SI2084 +FCMH0_SI824 +FCMH0_SX104 +FCMH0_SX14 +FCMH0_SX194 +FCMH0_SX284 +FCMH0_SX374 +FDAC1_SI1474 +FDAC1_SI2104 +FDAC1_SI844 +FDAC1_SX124 +FDAC1_SX214 +FDAC1_SX304 +FDAC1_SX34 +FDAC1_SX394 +FDMS0_SI1218 +FDMS0_SI1502 +FDMS0_SI1848 +FDMS0_SX138 +FDMS0_SX228 +FDMS0_SX318 +FDMS0_SX408 +FDMS0_SX48 +FDRW0_SI1283 +FDRW0_SI1423 +FDRW0_SI653 +FDRW0_SX113 +FDRW0_SX203 +FDRW0_SX23 +FDRW0_SX293 +FDRW0_SX383 +FEDW0_SI1084 +FEDW0_SI1653 +FEDW0_SI1714 +FEDW0_SX184 +FEDW0_SX274 +FEDW0_SX364 +FEDW0_SX4 +FEDW0_SX94 +FGJD0_SI1179 +FGJD0_SI549 +FGJD0_SI818 +FGJD0_SX189 +FGJD0_SX279 +FGJD0_SX369 +FGJD0_SX9 +FGJD0_SX99 +FJEM0_SI1264 +FJEM0_SI1894 +FJEM0_SI634 +FJEM0_SX184 +FJEM0_SX274 +FJEM0_SX364 +FJEM0_SX4 +FJEM0_SX94 +FJMG0_SI1181 +FJMG0_SI1811 +FJMG0_SI551 +FJMG0_SX101 +FJMG0_SX11 +FJMG0_SX191 +FJMG0_SX281 +FJMG0_SX371 +FJSJ0_SI1484 +FJSJ0_SI2114 +FJSJ0_SI854 +FJSJ0_SX134 +FJSJ0_SX224 +FJSJ0_SX314 +FJSJ0_SX404 +FJSJ0_SX44 +FKMS0_SI1490 +FKMS0_SI2120 +FKMS0_SI860 +FKMS0_SX140 +FKMS0_SX230 +FKMS0_SX320 +FKMS0_SX410 +FKMS0_SX50 +FMAH0_SI1289 +FMAH0_SI1919 +FMAH0_SI659 +FMAH0_SX119 +FMAH0_SX209 +FMAH0_SX29 +FMAH0_SX299 +FMAH0_SX389 +FMML0_SI1040 +FMML0_SI1670 +FMML0_SI2300 +FMML0_SX140 +FMML0_SX230 +FMML0_SX320 +FMML0_SX410 +FMML0_SX50 +FNMR0_SI1399 +FNMR0_SI2029 +FNMR0_SI769 +FNMR0_SX139 +FNMR0_SX229 +FNMR0_SX319 +FNMR0_SX409 +FNMR0_SX49 +FREW0_SI1030 +FREW0_SI1280 +FREW0_SI1910 +FREW0_SX110 +FREW0_SX20 +FREW0_SX200 +FREW0_SX290 +FREW0_SX380 +FSEM0_SI1198 +FSEM0_SI1828 +FSEM0_SI568 +FSEM0_SX118 +FSEM0_SX208 +FSEM0_SX28 +FSEM0_SX298 +FSEM0_SX388 +MAJC0_SI1946 +MAJC0_SI2095 +MAJC0_SI835 +MAJC0_SX115 +MAJC0_SX205 +MAJC0_SX25 +MAJC0_SX295 +MAJC0_SX385 +MBDG0_SI1463 +MBDG0_SI2093 +MBDG0_SI833 +MBDG0_SX113 +MBDG0_SX203 +MBDG0_SX23 +MBDG0_SX293 +MBDG0_SX383 +MBNS0_SI1220 +MBNS0_SI1850 +MBNS0_SI590 +MBNS0_SX140 +MBNS0_SX230 +MBNS0_SX320 +MBNS0_SX410 +MBNS0_SX50 +MBWM0_SI1304 +MBWM0_SI1934 +MBWM0_SI674 +MBWM0_SX134 +MBWM0_SX224 +MBWM0_SX314 +MBWM0_SX404 +MBWM0_SX44 +MCSH0_SI1549 +MCSH0_SI2179 +MCSH0_SI919 +MCSH0_SX109 +MCSH0_SX19 +MCSH0_SX199 +MCSH0_SX289 +MCSH0_SX379 +MDLF0_SI1583 +MDLF0_SI2213 +MDLF0_SI953 +MDLF0_SX143 +MDLF0_SX233 +MDLF0_SX323 +MDLF0_SX413 +MDLF0_SX53 +MDLS0_SI1628 +MDLS0_SI2258 +MDLS0_SI998 +MDLS0_SX188 +MDLS0_SX278 +MDLS0_SX368 +MDLS0_SX8 +MDLS0_SX98 +MDVC0_SI2174 +MDVC0_SI2196 +MDVC0_SI936 +MDVC0_SX126 +MDVC0_SX216 +MDVC0_SX306 +MDVC0_SX36 +MDVC0_SX396 +MERS0_SI1019 +MERS0_SI1649 +MERS0_SI497 +MERS0_SX119 +MERS0_SX209 +MERS0_SX29 +MERS0_SX299 +MERS0_SX389 +MGJF0_SI1901 +MGJF0_SI641 +MGJF0_SI776 +MGJF0_SX101 +MGJF0_SX11 +MGJF0_SX191 +MGJF0_SX281 +MGJF0_SX371 +MGLB0_SI1534 +MGLB0_SI2164 +MGLB0_SI904 +MGLB0_SX184 +MGLB0_SX274 +MGLB0_SX364 +MGLB0_SX4 +MGLB0_SX94 +MGWT0_SI1539 +MGWT0_SI2169 +MGWT0_SI909 +MGWT0_SX189 +MGWT0_SX279 +MGWT0_SX369 +MGWT0_SX9 +MGWT0_SX99 +MJAR0_SI1988 +MJAR0_SI2247 +MJAR0_SI728 +MJAR0_SX188 +MJAR0_SX278 +MJAR0_SX368 +MJAR0_SX8 +MJAR0_SX98 +MJFC0_SI1033 +MJFC0_SI1663 +MJFC0_SI2293 +MJFC0_SX133 +MJFC0_SX223 +MJFC0_SX313 +MJFC0_SX403 +MJFC0_SX43 +MJSW0_SI1010 +MJSW0_SI1640 +MJSW0_SI2270 +MJSW0_SX110 +MJSW0_SX20 +MJSW0_SX200 +MJSW0_SX290 +MJSW0_SX380 +MMDB1_SI1625 +MMDB1_SI2255 +MMDB1_SI995 +MMDB1_SX185 +MMDB1_SX275 +MMDB1_SX365 +MMDB1_SX5 +MMDB1_SX95 +MMDM2_SI1452 +MMDM2_SI1555 +MMDM2_SI2082 +MMDM2_SX102 +MMDM2_SX12 +MMDM2_SX192 +MMDM2_SX282 +MMDM2_SX372 +MMJR0_SI1648 +MMJR0_SI2166 +MMJR0_SI2278 +MMJR0_SX118 +MMJR0_SX208 +MMJR0_SX28 +MMJR0_SX298 +MMJR0_SX388 +MMWH0_SI1089 +MMWH0_SI1301 +MMWH0_SI459 +MMWH0_SX189 +MMWH0_SX279 +MMWH0_SX369 +MMWH0_SX9 +MMWH0_SX99 +MPDF0_SI1542 +MPDF0_SI2172 +MPDF0_SI912 +MPDF0_SX102 +MPDF0_SX12 +MPDF0_SX192 +MPDF0_SX282 +MPDF0_SX372 +MRCS0_SI1223 +MRCS0_SI1853 +MRCS0_SI593 +MRCS0_SX143 +MRCS0_SX233 +MRCS0_SX323 +MRCS0_SX413 +MRCS0_SX53 +MREB0_SI1375 +MREB0_SI2005 +MREB0_SI745 +MREB0_SX115 +MREB0_SX205 +MREB0_SX25 +MREB0_SX295 +MREB0_SX385 +MRJM4_SI1489 +MRJM4_SI2119 +MRJM4_SI859 +MRJM4_SX139 +MRJM4_SX229 +MRJM4_SX319 +MRJM4_SX409 +MRJM4_SX49 +MRJR0_SI1182 +MRJR0_SI1812 +MRJR0_SI2313 +MRJR0_SX102 +MRJR0_SX12 +MRJR0_SX192 +MRJR0_SX282 +MRJR0_SX372 +MROA0_SI1307 +MROA0_SI1970 +MROA0_SI677 +MROA0_SX137 +MROA0_SX227 +MROA0_SX317 +MROA0_SX407 +MROA0_SX47 +MRTK0_SI1093 +MRTK0_SI1723 +MRTK0_SI1750 +MRTK0_SX103 +MRTK0_SX13 +MRTK0_SX193 +MRTK0_SX283 +MRTK0_SX373 +MRWS1_SI1130 +MRWS1_SI1496 +MRWS1_SI500 +MRWS1_SX140 +MRWS1_SX230 +MRWS1_SX320 +MRWS1_SX410 +MRWS1_SX50 +MTAA0_SI1285 +MTAA0_SI1915 +MTAA0_SI596 +MTAA0_SX115 +MTAA0_SX205 +MTAA0_SX25 +MTAA0_SX295 +MTAA0_SX385 +MTDT0_SI1994 +MTDT0_SI2254 +MTDT0_SI994 +MTDT0_SX184 +MTDT0_SX274 +MTDT0_SX364 +MTDT0_SX4 +MTDT0_SX94 +MTEB0_SI1133 +MTEB0_SI2064 +MTEB0_SI503 +MTEB0_SX143 +MTEB0_SX233 +MTEB0_SX323 +MTEB0_SX413 +MTEB0_SX53 +MTHC0_SI1015 +MTHC0_SI1645 +MTHC0_SI2275 +MTHC0_SX115 +MTHC0_SX205 +MTHC0_SX25 +MTHC0_SX295 +MTHC0_SX385 +MWJG0_SI1124 +MWJG0_SI1754 +MWJG0_SI494 +MWJG0_SX134 +MWJG0_SX224 +MWJG0_SX314 +MWJG0_SX404 +MWJG0_SX44 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/test.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/test.uid new file mode 100644 index 0000000000000000000000000000000000000000..e3967e42423d4d82d159cb395514d41c13316da2 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/test.uid @@ -0,0 +1,1680 @@ +FADG0_SA1 +FADG0_SA2 +FADG0_SI1279 +FADG0_SI1909 +FADG0_SI649 +FADG0_SX109 +FADG0_SX19 +FADG0_SX199 +FADG0_SX289 +FADG0_SX379 +FAKS0_SA1 +FAKS0_SA2 +FAKS0_SI1573 +FAKS0_SI2203 +FAKS0_SI943 +FAKS0_SX133 +FAKS0_SX223 +FAKS0_SX313 +FAKS0_SX403 +FAKS0_SX43 +FASW0_SA1 +FASW0_SA2 +FASW0_SI1550 +FASW0_SI2180 +FASW0_SI920 +FASW0_SX110 +FASW0_SX20 +FASW0_SX200 +FASW0_SX290 +FASW0_SX380 +FAWF0_SA1 +FAWF0_SA2 +FAWF0_SI1000 +FAWF0_SI1630 +FAWF0_SI2260 +FAWF0_SX10 +FAWF0_SX100 +FAWF0_SX190 +FAWF0_SX280 +FAWF0_SX370 +FCAL1_SA1 +FCAL1_SA2 +FCAL1_SI1403 +FCAL1_SI2033 +FCAL1_SI773 +FCAL1_SX143 +FCAL1_SX233 +FCAL1_SX323 +FCAL1_SX413 +FCAL1_SX53 +FCAU0_SA1 +FCAU0_SA2 +FCAU0_SI1037 +FCAU0_SI1667 +FCAU0_SI2297 +FCAU0_SX137 +FCAU0_SX227 +FCAU0_SX317 +FCAU0_SX407 +FCAU0_SX47 +FCFT0_SA1 +FCFT0_SA2 +FCFT0_SI1178 +FCFT0_SI1808 +FCFT0_SI548 +FCFT0_SX188 +FCFT0_SX278 +FCFT0_SX368 +FCFT0_SX8 +FCFT0_SX98 +FCMH0_SA1 +FCMH0_SA2 +FCMH0_SI1454 +FCMH0_SI2084 +FCMH0_SI824 +FCMH0_SX104 +FCMH0_SX14 +FCMH0_SX194 +FCMH0_SX284 +FCMH0_SX374 +FCMH1_SA1 +FCMH1_SA2 +FCMH1_SI1493 +FCMH1_SI2123 +FCMH1_SI863 +FCMH1_SX143 +FCMH1_SX233 +FCMH1_SX323 +FCMH1_SX413 +FCMH1_SX53 +FCMR0_SA1 +FCMR0_SA2 +FCMR0_SI1105 +FCMR0_SI1735 +FCMR0_SI475 +FCMR0_SX115 +FCMR0_SX205 +FCMR0_SX25 +FCMR0_SX295 +FCMR0_SX385 +FCRH0_SA1 +FCRH0_SA2 +FCRH0_SI1088 +FCRH0_SI1718 +FCRH0_SI458 +FCRH0_SX188 +FCRH0_SX278 +FCRH0_SX368 +FCRH0_SX8 +FCRH0_SX98 +FDAC1_SA1 +FDAC1_SA2 +FDAC1_SI1474 +FDAC1_SI2104 +FDAC1_SI844 +FDAC1_SX124 +FDAC1_SX214 +FDAC1_SX304 +FDAC1_SX34 +FDAC1_SX394 +FDHC0_SA1 +FDHC0_SA2 +FDHC0_SI1559 +FDHC0_SI2189 +FDHC0_SI929 +FDHC0_SX119 +FDHC0_SX209 +FDHC0_SX29 +FDHC0_SX299 +FDHC0_SX389 +FDMS0_SA1 +FDMS0_SA2 +FDMS0_SI1218 +FDMS0_SI1502 +FDMS0_SI1848 +FDMS0_SX138 +FDMS0_SX228 +FDMS0_SX318 +FDMS0_SX408 +FDMS0_SX48 +FDRD1_SA1 +FDRD1_SA2 +FDRD1_SI1544 +FDRD1_SI1566 +FDRD1_SI2149 +FDRD1_SX104 +FDRD1_SX14 +FDRD1_SX194 +FDRD1_SX284 +FDRD1_SX374 +FDRW0_SA1 +FDRW0_SA2 +FDRW0_SI1283 +FDRW0_SI1423 +FDRW0_SI653 +FDRW0_SX113 +FDRW0_SX203 +FDRW0_SX23 +FDRW0_SX293 +FDRW0_SX383 +FEDW0_SA1 +FEDW0_SA2 +FEDW0_SI1084 +FEDW0_SI1653 +FEDW0_SI1714 +FEDW0_SX184 +FEDW0_SX274 +FEDW0_SX364 +FEDW0_SX4 +FEDW0_SX94 +FELC0_SA1 +FELC0_SA2 +FELC0_SI1386 +FELC0_SI2016 +FELC0_SI756 +FELC0_SX126 +FELC0_SX216 +FELC0_SX306 +FELC0_SX36 +FELC0_SX396 +FGJD0_SA1 +FGJD0_SA2 +FGJD0_SI1179 +FGJD0_SI549 +FGJD0_SI818 +FGJD0_SX189 +FGJD0_SX279 +FGJD0_SX369 +FGJD0_SX9 +FGJD0_SX99 +FGMD0_SA1 +FGMD0_SA2 +FGMD0_SI1943 +FGMD0_SI2107 +FGMD0_SI683 +FGMD0_SX143 +FGMD0_SX233 +FGMD0_SX323 +FGMD0_SX413 +FGMD0_SX53 +FGWR0_SA1 +FGWR0_SA2 +FGWR0_SI1578 +FGWR0_SI2208 +FGWR0_SI948 +FGWR0_SX138 +FGWR0_SX228 +FGWR0_SX318 +FGWR0_SX408 +FGWR0_SX48 +FHES0_SA1 +FHES0_SA2 +FHES0_SI1109 +FHES0_SI1739 +FHES0_SI479 +FHES0_SX119 +FHES0_SX209 +FHES0_SX29 +FHES0_SX299 +FHES0_SX389 +FHEW0_SA1 +FHEW0_SA2 +FHEW0_SI2023 +FHEW0_SI690 +FHEW0_SI763 +FHEW0_SX133 +FHEW0_SX223 +FHEW0_SX313 +FHEW0_SX403 +FHEW0_SX43 +FISB0_SA1 +FISB0_SA2 +FISB0_SI1579 +FISB0_SI2209 +FISB0_SI949 +FISB0_SX139 +FISB0_SX229 +FISB0_SX319 +FISB0_SX409 +FISB0_SX49 +FJAS0_SA1 +FJAS0_SA2 +FJAS0_SI1400 +FJAS0_SI2030 +FJAS0_SI770 +FJAS0_SX140 +FJAS0_SX230 +FJAS0_SX320 +FJAS0_SX410 +FJAS0_SX50 +FJCS0_SA1 +FJCS0_SA2 +FJCS0_SI1309 +FJCS0_SI1833 +FJCS0_SI1939 +FJCS0_SX139 +FJCS0_SX229 +FJCS0_SX319 +FJCS0_SX409 +FJCS0_SX49 +FJEM0_SA1 +FJEM0_SA2 +FJEM0_SI1264 +FJEM0_SI1894 +FJEM0_SI634 +FJEM0_SX184 +FJEM0_SX274 +FJEM0_SX364 +FJEM0_SX4 +FJEM0_SX94 +FJLM0_SA1 +FJLM0_SA2 +FJLM0_SI1043 +FJLM0_SI1673 +FJLM0_SI2303 +FJLM0_SX143 +FJLM0_SX233 +FJLM0_SX323 +FJLM0_SX413 +FJLM0_SX53 +FJMG0_SA1 +FJMG0_SA2 +FJMG0_SI1181 +FJMG0_SI1811 +FJMG0_SI551 +FJMG0_SX101 +FJMG0_SX11 +FJMG0_SX191 +FJMG0_SX281 +FJMG0_SX371 +FJRE0_SA1 +FJRE0_SA2 +FJRE0_SI1116 +FJRE0_SI1587 +FJRE0_SI1746 +FJRE0_SX126 +FJRE0_SX216 +FJRE0_SX306 +FJRE0_SX36 +FJRE0_SX396 +FJSA0_SA1 +FJSA0_SA2 +FJSA0_SI1379 +FJSA0_SI2009 +FJSA0_SI749 +FJSA0_SX119 +FJSA0_SX209 +FJSA0_SX29 +FJSA0_SX299 +FJSA0_SX389 +FJSJ0_SA1 +FJSJ0_SA2 +FJSJ0_SI1484 +FJSJ0_SI2114 +FJSJ0_SI854 +FJSJ0_SX134 +FJSJ0_SX224 +FJSJ0_SX314 +FJSJ0_SX404 +FJSJ0_SX44 +FJWB0_SA1 +FJWB0_SA2 +FJWB0_SI1265 +FJWB0_SI635 +FJWB0_SI992 +FJWB0_SX185 +FJWB0_SX275 +FJWB0_SX365 +FJWB0_SX5 +FJWB0_SX95 +FKMS0_SA1 +FKMS0_SA2 +FKMS0_SI1490 +FKMS0_SI2120 +FKMS0_SI860 +FKMS0_SX140 +FKMS0_SX230 +FKMS0_SX320 +FKMS0_SX410 +FKMS0_SX50 +FLAS0_SA1 +FLAS0_SA2 +FLAS0_SI1026 +FLAS0_SI1488 +FLAS0_SI858 +FLAS0_SX138 +FLAS0_SX228 +FLAS0_SX318 +FLAS0_SX408 +FLAS0_SX48 +FLBW0_SA1 +FLBW0_SA2 +FLBW0_SI1219 +FLBW0_SI1849 +FLBW0_SI2253 +FLBW0_SX139 +FLBW0_SX229 +FLBW0_SX319 +FLBW0_SX409 +FLBW0_SX49 +FLKD0_SA1 +FLKD0_SA2 +FLKD0_SI1369 +FLKD0_SI739 +FLKD0_SI894 +FLKD0_SX109 +FLKD0_SX19 +FLKD0_SX199 +FLKD0_SX289 +FLKD0_SX379 +FLNH0_SA1 +FLNH0_SA2 +FLNH0_SI1214 +FLNH0_SI584 +FLNH0_SI941 +FLNH0_SX134 +FLNH0_SX224 +FLNH0_SX314 +FLNH0_SX404 +FLNH0_SX44 +FMAF0_SA1 +FMAF0_SA2 +FMAF0_SI1459 +FMAF0_SI2089 +FMAF0_SI829 +FMAF0_SX109 +FMAF0_SX19 +FMAF0_SX199 +FMAF0_SX289 +FMAF0_SX379 +FMAH0_SA1 +FMAH0_SA2 +FMAH0_SI1289 +FMAH0_SI1919 +FMAH0_SI659 +FMAH0_SX119 +FMAH0_SX209 +FMAH0_SX29 +FMAH0_SX299 +FMAH0_SX389 +FMCM0_SA1 +FMCM0_SA2 +FMCM0_SI1180 +FMCM0_SI1810 +FMCM0_SI550 +FMCM0_SX10 +FMCM0_SX100 +FMCM0_SX190 +FMCM0_SX280 +FMCM0_SX370 +FMGD0_SA1 +FMGD0_SA2 +FMGD0_SI1564 +FMGD0_SI2194 +FMGD0_SI934 +FMGD0_SX124 +FMGD0_SX214 +FMGD0_SX304 +FMGD0_SX34 +FMGD0_SX394 +FMLD0_SA1 +FMLD0_SA2 +FMLD0_SI2185 +FMLD0_SI822 +FMLD0_SI925 +FMLD0_SX115 +FMLD0_SX205 +FMLD0_SX25 +FMLD0_SX295 +FMLD0_SX385 +FMML0_SA1 +FMML0_SA2 +FMML0_SI1040 +FMML0_SI1670 +FMML0_SI2300 +FMML0_SX140 +FMML0_SX230 +FMML0_SX320 +FMML0_SX410 +FMML0_SX50 +FNLP0_SA1 +FNLP0_SA2 +FNLP0_SI1308 +FNLP0_SI1938 +FNLP0_SI678 +FNLP0_SX138 +FNLP0_SX228 +FNLP0_SX318 +FNLP0_SX408 +FNLP0_SX48 +FNMR0_SA1 +FNMR0_SA2 +FNMR0_SI1399 +FNMR0_SI2029 +FNMR0_SI769 +FNMR0_SX139 +FNMR0_SX229 +FNMR0_SX319 +FNMR0_SX409 +FNMR0_SX49 +FPAS0_SA1 +FPAS0_SA2 +FPAS0_SI1272 +FPAS0_SI2204 +FPAS0_SI944 +FPAS0_SX134 +FPAS0_SX224 +FPAS0_SX314 +FPAS0_SX404 +FPAS0_SX44 +FPKT0_SA1 +FPKT0_SA2 +FPKT0_SI1538 +FPKT0_SI2168 +FPKT0_SI908 +FPKT0_SX188 +FPKT0_SX278 +FPKT0_SX368 +FPKT0_SX8 +FPKT0_SX98 +FRAM1_SA1 +FRAM1_SA2 +FRAM1_SI1360 +FRAM1_SI522 +FRAM1_SI730 +FRAM1_SX10 +FRAM1_SX100 +FRAM1_SX190 +FRAM1_SX280 +FRAM1_SX370 +FREW0_SA1 +FREW0_SA2 +FREW0_SI1030 +FREW0_SI1280 +FREW0_SI1910 +FREW0_SX110 +FREW0_SX20 +FREW0_SX200 +FREW0_SX290 +FREW0_SX380 +FRNG0_SA1 +FRNG0_SA2 +FRNG0_SI1355 +FRNG0_SI1985 +FRNG0_SI725 +FRNG0_SX185 +FRNG0_SX275 +FRNG0_SX365 +FRNG0_SX5 +FRNG0_SX95 +FSEM0_SA1 +FSEM0_SA2 +FSEM0_SI1198 +FSEM0_SI1828 +FSEM0_SI568 +FSEM0_SX118 +FSEM0_SX208 +FSEM0_SX28 +FSEM0_SX298 +FSEM0_SX388 +FSLB1_SA1 +FSLB1_SA2 +FSLB1_SI1904 +FSLB1_SI644 +FSLB1_SI891 +FSLB1_SX104 +FSLB1_SX14 +FSLB1_SX194 +FSLB1_SX284 +FSLB1_SX374 +FSXA0_SA1 +FSXA0_SA2 +FSXA0_SI1108 +FSXA0_SI1846 +FSXA0_SI478 +FSXA0_SX118 +FSXA0_SX208 +FSXA0_SX28 +FSXA0_SX298 +FSXA0_SX388 +FTLH0_SA1 +FTLH0_SA2 +FTLH0_SI1009 +FTLH0_SI1390 +FTLH0_SI1639 +FTLH0_SX109 +FTLH0_SX19 +FTLH0_SX199 +FTLH0_SX289 +FTLH0_SX379 +FUTB0_SA1 +FUTB0_SA2 +FUTB0_SI1204 +FUTB0_SI1330 +FUTB0_SI1834 +FUTB0_SX124 +FUTB0_SX214 +FUTB0_SX304 +FUTB0_SX34 +FUTB0_SX394 +MABW0_SA1 +MABW0_SA2 +MABW0_SI1230 +MABW0_SI1664 +MABW0_SI2294 +MABW0_SX134 +MABW0_SX224 +MABW0_SX314 +MABW0_SX404 +MABW0_SX44 +MAHH0_SA1 +MAHH0_SA2 +MAHH0_SI1294 +MAHH0_SI1924 +MAHH0_SI664 +MAHH0_SX124 +MAHH0_SX214 +MAHH0_SX304 +MAHH0_SX34 +MAHH0_SX394 +MAJC0_SA1 +MAJC0_SA2 +MAJC0_SI1946 +MAJC0_SI2095 +MAJC0_SI835 +MAJC0_SX115 +MAJC0_SX205 +MAJC0_SX25 +MAJC0_SX295 +MAJC0_SX385 +MBDG0_SA1 +MBDG0_SA2 +MBDG0_SI1463 +MBDG0_SI2093 +MBDG0_SI833 +MBDG0_SX113 +MBDG0_SX203 +MBDG0_SX23 +MBDG0_SX293 +MBDG0_SX383 +MBJK0_SA1 +MBJK0_SA2 +MBJK0_SI1175 +MBJK0_SI2128 +MBJK0_SI545 +MBJK0_SX185 +MBJK0_SX275 +MBJK0_SX365 +MBJK0_SX5 +MBJK0_SX95 +MBNS0_SA1 +MBNS0_SA2 +MBNS0_SI1220 +MBNS0_SI1850 +MBNS0_SI590 +MBNS0_SX140 +MBNS0_SX230 +MBNS0_SX320 +MBNS0_SX410 +MBNS0_SX50 +MBPM0_SA1 +MBPM0_SA2 +MBPM0_SI1577 +MBPM0_SI1584 +MBPM0_SI947 +MBPM0_SX137 +MBPM0_SX227 +MBPM0_SX317 +MBPM0_SX407 +MBPM0_SX47 +MBWM0_SA1 +MBWM0_SA2 +MBWM0_SI1304 +MBWM0_SI1934 +MBWM0_SI674 +MBWM0_SX134 +MBWM0_SX224 +MBWM0_SX314 +MBWM0_SX404 +MBWM0_SX44 +MCCS0_SA1 +MCCS0_SA2 +MCCS0_SI1469 +MCCS0_SI2099 +MCCS0_SI839 +MCCS0_SX119 +MCCS0_SX209 +MCCS0_SX29 +MCCS0_SX299 +MCCS0_SX389 +MCEM0_SA1 +MCEM0_SA2 +MCEM0_SI1398 +MCEM0_SI2028 +MCEM0_SI768 +MCEM0_SX138 +MCEM0_SX228 +MCEM0_SX318 +MCEM0_SX408 +MCEM0_SX48 +MCHH0_SA1 +MCHH0_SA2 +MCHH0_SI1004 +MCHH0_SI1634 +MCHH0_SI530 +MCHH0_SX104 +MCHH0_SX14 +MCHH0_SX194 +MCHH0_SX284 +MCHH0_SX374 +MCMB0_SA1 +MCMB0_SA2 +MCMB0_SI1268 +MCMB0_SI1898 +MCMB0_SI638 +MCMB0_SX188 +MCMB0_SX278 +MCMB0_SX368 +MCMB0_SX8 +MCMB0_SX98 +MCMJ0_SA1 +MCMJ0_SA2 +MCMJ0_SI1094 +MCMJ0_SI464 +MCMJ0_SI602 +MCMJ0_SX104 +MCMJ0_SX14 +MCMJ0_SX194 +MCMJ0_SX284 +MCMJ0_SX374 +MCRC0_SA1 +MCRC0_SA2 +MCRC0_SI1092 +MCRC0_SI1722 +MCRC0_SI462 +MCRC0_SX102 +MCRC0_SX12 +MCRC0_SX192 +MCRC0_SX282 +MCRC0_SX372 +MCSH0_SA1 +MCSH0_SA2 +MCSH0_SI1549 +MCSH0_SI2179 +MCSH0_SI919 +MCSH0_SX109 +MCSH0_SX19 +MCSH0_SX199 +MCSH0_SX289 +MCSH0_SX379 +MCTT0_SA1 +MCTT0_SA2 +MCTT0_SI1144 +MCTT0_SI2188 +MCTT0_SI928 +MCTT0_SX118 +MCTT0_SX208 +MCTT0_SX28 +MCTT0_SX298 +MCTT0_SX388 +MCTW0_SA1 +MCTW0_SA2 +MCTW0_SI1373 +MCTW0_SI2003 +MCTW0_SI743 +MCTW0_SX113 +MCTW0_SX203 +MCTW0_SX23 +MCTW0_SX293 +MCTW0_SX383 +MDAB0_SA1 +MDAB0_SA2 +MDAB0_SI1039 +MDAB0_SI1669 +MDAB0_SI2299 +MDAB0_SX139 +MDAB0_SX229 +MDAB0_SX319 +MDAB0_SX409 +MDAB0_SX49 +MDAC2_SA1 +MDAC2_SA2 +MDAC2_SI2259 +MDAC2_SI560 +MDAC2_SI999 +MDAC2_SX189 +MDAC2_SX279 +MDAC2_SX369 +MDAC2_SX9 +MDAC2_SX99 +MDAW1_SA1 +MDAW1_SA2 +MDAW1_SI1453 +MDAW1_SI2083 +MDAW1_SI823 +MDAW1_SX103 +MDAW1_SX13 +MDAW1_SX193 +MDAW1_SX283 +MDAW1_SX373 +MDBB0_SA1 +MDBB0_SA2 +MDBB0_SI1195 +MDBB0_SI1825 +MDBB0_SI565 +MDBB0_SX115 +MDBB0_SX205 +MDBB0_SX25 +MDBB0_SX295 +MDBB0_SX385 +MDLD0_SA1 +MDLD0_SA2 +MDLD0_SI1543 +MDLD0_SI2173 +MDLD0_SI913 +MDLD0_SX103 +MDLD0_SX13 +MDLD0_SX193 +MDLD0_SX283 +MDLD0_SX373 +MDLF0_SA1 +MDLF0_SA2 +MDLF0_SI1583 +MDLF0_SI2213 +MDLF0_SI953 +MDLF0_SX143 +MDLF0_SX233 +MDLF0_SX323 +MDLF0_SX413 +MDLF0_SX53 +MDLS0_SA1 +MDLS0_SA2 +MDLS0_SI1628 +MDLS0_SI2258 +MDLS0_SI998 +MDLS0_SX188 +MDLS0_SX278 +MDLS0_SX368 +MDLS0_SX8 +MDLS0_SX98 +MDRB0_SA1 +MDRB0_SA2 +MDRB0_SI1174 +MDRB0_SI2109 +MDRB0_SI544 +MDRB0_SX184 +MDRB0_SX274 +MDRB0_SX364 +MDRB0_SX4 +MDRB0_SX94 +MDRM0_SA1 +MDRM0_SA2 +MDRM0_SI1013 +MDRM0_SI1643 +MDRM0_SI2273 +MDRM0_SX113 +MDRM0_SX203 +MDRM0_SX23 +MDRM0_SX293 +MDRM0_SX383 +MDSC0_SA1 +MDSC0_SA2 +MDSC0_SI1038 +MDSC0_SI2298 +MDSC0_SI967 +MDSC0_SX138 +MDSC0_SX228 +MDSC0_SX318 +MDSC0_SX408 +MDSC0_SX48 +MDVC0_SA1 +MDVC0_SA2 +MDVC0_SI2174 +MDVC0_SI2196 +MDVC0_SI936 +MDVC0_SX126 +MDVC0_SX216 +MDVC0_SX306 +MDVC0_SX36 +MDVC0_SX396 +MDWA0_SA1 +MDWA0_SA2 +MDWA0_SI1146 +MDWA0_SI1445 +MDWA0_SI519 +MDWA0_SX185 +MDWA0_SX275 +MDWA0_SX365 +MDWA0_SX5 +MDWA0_SX95 +MDWK0_SA1 +MDWK0_SA2 +MDWK0_SI1540 +MDWK0_SI2170 +MDWK0_SI910 +MDWK0_SX10 +MDWK0_SX100 +MDWK0_SX190 +MDWK0_SX280 +MDWK0_SX370 +MERS0_SA1 +MERS0_SA2 +MERS0_SI1019 +MERS0_SI1649 +MERS0_SI497 +MERS0_SX119 +MERS0_SX209 +MERS0_SX29 +MERS0_SX299 +MERS0_SX389 +MESD0_SA1 +MESD0_SA2 +MESD0_SI1002 +MESD0_SI1632 +MESD0_SI2262 +MESD0_SX102 +MESD0_SX12 +MESD0_SX192 +MESD0_SX282 +MESD0_SX372 +MFGK0_SA1 +MFGK0_SA2 +MFGK0_SI1451 +MFGK0_SI1744 +MFGK0_SI484 +MFGK0_SX124 +MFGK0_SX214 +MFGK0_SX304 +MFGK0_SX34 +MFGK0_SX394 +MGJF0_SA1 +MGJF0_SA2 +MGJF0_SI1901 +MGJF0_SI641 +MGJF0_SI776 +MGJF0_SX101 +MGJF0_SX11 +MGJF0_SX191 +MGJF0_SX281 +MGJF0_SX371 +MGLB0_SA1 +MGLB0_SA2 +MGLB0_SI1534 +MGLB0_SI2164 +MGLB0_SI904 +MGLB0_SX184 +MGLB0_SX274 +MGLB0_SX364 +MGLB0_SX4 +MGLB0_SX94 +MGMM0_SA1 +MGMM0_SA2 +MGMM0_SI1129 +MGMM0_SI1759 +MGMM0_SI499 +MGMM0_SX139 +MGMM0_SX229 +MGMM0_SX319 +MGMM0_SX409 +MGMM0_SX49 +MGRT0_SA1 +MGRT0_SA2 +MGRT0_SI1450 +MGRT0_SI2080 +MGRT0_SI820 +MGRT0_SX10 +MGRT0_SX100 +MGRT0_SX190 +MGRT0_SX280 +MGRT0_SX370 +MGWT0_SA1 +MGWT0_SA2 +MGWT0_SI1539 +MGWT0_SI2169 +MGWT0_SI909 +MGWT0_SX189 +MGWT0_SX279 +MGWT0_SX369 +MGWT0_SX9 +MGWT0_SX99 +MHPG0_SA1 +MHPG0_SA2 +MHPG0_SI1090 +MHPG0_SI1720 +MHPG0_SI460 +MHPG0_SX10 +MHPG0_SX100 +MHPG0_SX190 +MHPG0_SX280 +MHPG0_SX370 +MJAR0_SA1 +MJAR0_SA2 +MJAR0_SI1988 +MJAR0_SI2247 +MJAR0_SI728 +MJAR0_SX188 +MJAR0_SX278 +MJAR0_SX368 +MJAR0_SX8 +MJAR0_SX98 +MJBR0_SA1 +MJBR0_SA2 +MJBR0_SI1001 +MJBR0_SI1631 +MJBR0_SI2261 +MJBR0_SX101 +MJBR0_SX11 +MJBR0_SX191 +MJBR0_SX281 +MJBR0_SX371 +MJDH0_SA1 +MJDH0_SA2 +MJDH0_SI1354 +MJDH0_SI1984 +MJDH0_SI724 +MJDH0_SX184 +MJDH0_SX274 +MJDH0_SX364 +MJDH0_SX4 +MJDH0_SX94 +MJDM1_SA1 +MJDM1_SA2 +MJDM1_SI1085 +MJDM1_SI1715 +MJDM1_SI455 +MJDM1_SX185 +MJDM1_SX275 +MJDM1_SX365 +MJDM1_SX5 +MJDM1_SX95 +MJES0_SA1 +MJES0_SA2 +MJES0_SI1384 +MJES0_SI2014 +MJES0_SI754 +MJES0_SX124 +MJES0_SX214 +MJES0_SX304 +MJES0_SX34 +MJES0_SX394 +MJFC0_SA1 +MJFC0_SA2 +MJFC0_SI1033 +MJFC0_SI1663 +MJFC0_SI2293 +MJFC0_SX133 +MJFC0_SX223 +MJFC0_SX313 +MJFC0_SX403 +MJFC0_SX43 +MJJG0_SA1 +MJJG0_SA2 +MJJG0_SI1003 +MJJG0_SI1633 +MJJG0_SI2263 +MJJG0_SX103 +MJJG0_SX13 +MJJG0_SX193 +MJJG0_SX283 +MJJG0_SX373 +MJLN0_SA1 +MJLN0_SA2 +MJLN0_SI1449 +MJLN0_SI2079 +MJLN0_SI819 +MJLN0_SX189 +MJLN0_SX279 +MJLN0_SX369 +MJLN0_SX9 +MJLN0_SX99 +MJMP0_SA1 +MJMP0_SA2 +MJMP0_SI1535 +MJMP0_SI1791 +MJMP0_SI905 +MJMP0_SX185 +MJMP0_SX275 +MJMP0_SX365 +MJMP0_SX5 +MJMP0_SX95 +MJRF0_SA1 +MJRF0_SA2 +MJRF0_SI1114 +MJRF0_SI2081 +MJRF0_SI821 +MJRF0_SX101 +MJRF0_SX11 +MJRF0_SX191 +MJRF0_SX281 +MJRF0_SX371 +MJSW0_SA1 +MJSW0_SA2 +MJSW0_SI1010 +MJSW0_SI1640 +MJSW0_SI2270 +MJSW0_SX110 +MJSW0_SX20 +MJSW0_SX200 +MJSW0_SX290 +MJSW0_SX380 +MJTC0_SA1 +MJTC0_SA2 +MJTC0_SI1460 +MJTC0_SI2090 +MJTC0_SI830 +MJTC0_SX110 +MJTC0_SX20 +MJTC0_SX200 +MJTC0_SX290 +MJTC0_SX380 +MJTH0_SA1 +MJTH0_SA2 +MJTH0_SI1296 +MJTH0_SI1926 +MJTH0_SI666 +MJTH0_SX126 +MJTH0_SX216 +MJTH0_SX306 +MJTH0_SX36 +MJTH0_SX396 +MJVW0_SA1 +MJVW0_SA2 +MJVW0_SI1733 +MJVW0_SI1758 +MJVW0_SI473 +MJVW0_SX113 +MJVW0_SX203 +MJVW0_SX23 +MJVW0_SX293 +MJVW0_SX383 +MKCH0_SA1 +MKCH0_SA2 +MKCH0_SI1378 +MKCH0_SI1425 +MKCH0_SI2008 +MKCH0_SX118 +MKCH0_SX208 +MKCH0_SX28 +MKCH0_SX298 +MKCH0_SX388 +MKCL0_SA1 +MKCL0_SA2 +MKCL0_SI1091 +MKCL0_SI1721 +MKCL0_SI461 +MKCL0_SX101 +MKCL0_SX11 +MKCL0_SX191 +MKCL0_SX281 +MKCL0_SX371 +MKDR0_SA1 +MKDR0_SA2 +MKDR0_SI1273 +MKDR0_SI1903 +MKDR0_SI643 +MKDR0_SX103 +MKDR0_SX13 +MKDR0_SX193 +MKDR0_SX283 +MKDR0_SX373 +MKJL0_SA1 +MKJL0_SA2 +MKJL0_SI1100 +MKJL0_SI1730 +MKJL0_SI470 +MKJL0_SX110 +MKJL0_SX20 +MKJL0_SX200 +MKJL0_SX290 +MKJL0_SX380 +MKLT0_SA1 +MKLT0_SA2 +MKLT0_SI1213 +MKLT0_SI1843 +MKLT0_SI583 +MKLT0_SX133 +MKLT0_SX223 +MKLT0_SX313 +MKLT0_SX403 +MKLT0_SX43 +MLIH0_SA1 +MLIH0_SA2 +MLIH0_SI1183 +MLIH0_SI1813 +MLIH0_SI553 +MLIH0_SX103 +MLIH0_SX13 +MLIH0_SX193 +MLIH0_SX283 +MLIH0_SX373 +MLJB0_SA1 +MLJB0_SA2 +MLJB0_SI1310 +MLJB0_SI1940 +MLJB0_SI680 +MLJB0_SX140 +MLJB0_SX230 +MLJB0_SX320 +MLJB0_SX410 +MLJB0_SX50 +MLLL0_SA1 +MLLL0_SA2 +MLLL0_SI1363 +MLLL0_SI1993 +MLLL0_SI733 +MLLL0_SX103 +MLLL0_SX13 +MLLL0_SX193 +MLLL0_SX283 +MLLL0_SX373 +MLNT0_SA1 +MLNT0_SA2 +MLNT0_SI1574 +MLNT0_SI1902 +MLNT0_SI642 +MLNT0_SX102 +MLNT0_SX12 +MLNT0_SX192 +MLNT0_SX282 +MLNT0_SX372 +MMAB0_SA1 +MMAB0_SA2 +MMAB0_SI1362 +MMAB0_SI1992 +MMAB0_SI732 +MMAB0_SX102 +MMAB0_SX12 +MMAB0_SX192 +MMAB0_SX282 +MMAB0_SX372 +MMDB1_SA1 +MMDB1_SA2 +MMDB1_SI1625 +MMDB1_SI2255 +MMDB1_SI995 +MMDB1_SX185 +MMDB1_SX275 +MMDB1_SX365 +MMDB1_SX5 +MMDB1_SX95 +MMDH0_SA1 +MMDH0_SA2 +MMDH0_SI1656 +MMDH0_SI2118 +MMDH0_SI2286 +MMDH0_SX126 +MMDH0_SX216 +MMDH0_SX306 +MMDH0_SX36 +MMDH0_SX396 +MMDM2_SA1 +MMDM2_SA2 +MMDM2_SI1452 +MMDM2_SI1555 +MMDM2_SI2082 +MMDM2_SX102 +MMDM2_SX12 +MMDM2_SX192 +MMDM2_SX282 +MMDM2_SX372 +MMJR0_SA1 +MMJR0_SA2 +MMJR0_SI1648 +MMJR0_SI2166 +MMJR0_SI2278 +MMJR0_SX118 +MMJR0_SX208 +MMJR0_SX28 +MMJR0_SX298 +MMJR0_SX388 +MMWH0_SA1 +MMWH0_SA2 +MMWH0_SI1089 +MMWH0_SI1301 +MMWH0_SI459 +MMWH0_SX189 +MMWH0_SX279 +MMWH0_SX369 +MMWH0_SX9 +MMWH0_SX99 +MNJM0_SA1 +MNJM0_SA2 +MNJM0_SI1580 +MNJM0_SI2210 +MNJM0_SI950 +MNJM0_SX140 +MNJM0_SX230 +MNJM0_SX320 +MNJM0_SX410 +MNJM0_SX50 +MNLS0_SA1 +MNLS0_SA2 +MNLS0_SI1483 +MNLS0_SI1610 +MNLS0_SI853 +MNLS0_SX133 +MNLS0_SX223 +MNLS0_SX313 +MNLS0_SX403 +MNLS0_SX43 +MPAB0_SA1 +MPAB0_SA2 +MPAB0_SI1103 +MPAB0_SI1128 +MPAB0_SI498 +MPAB0_SX138 +MPAB0_SX228 +MPAB0_SX318 +MPAB0_SX408 +MPAB0_SX48 +MPAM0_SA1 +MPAM0_SA2 +MPAM0_SI1189 +MPAM0_SI1819 +MPAM0_SI1961 +MPAM0_SX109 +MPAM0_SX19 +MPAM0_SX199 +MPAM0_SX289 +MPAM0_SX379 +MPAM1_SA1 +MPAM1_SA2 +MPAM1_SI1029 +MPAM1_SI1836 +MPAM1_SI576 +MPAM1_SX126 +MPAM1_SX216 +MPAM1_SX306 +MPAM1_SX36 +MPAM1_SX396 +MPCS0_SA1 +MPCS0_SA2 +MPCS0_SI1359 +MPCS0_SI1989 +MPCS0_SI729 +MPCS0_SX189 +MPCS0_SX279 +MPCS0_SX369 +MPCS0_SX9 +MPCS0_SX99 +MPDF0_SA1 +MPDF0_SA2 +MPDF0_SI1542 +MPDF0_SI2172 +MPDF0_SI912 +MPDF0_SX102 +MPDF0_SX12 +MPDF0_SX192 +MPDF0_SX282 +MPDF0_SX372 +MPGL0_SA1 +MPGL0_SA2 +MPGL0_SI1099 +MPGL0_SI1729 +MPGL0_SI469 +MPGL0_SX109 +MPGL0_SX19 +MPGL0_SX199 +MPGL0_SX289 +MPGL0_SX379 +MPLB0_SA1 +MPLB0_SA2 +MPLB0_SI1394 +MPLB0_SI2024 +MPLB0_SI764 +MPLB0_SX134 +MPLB0_SX224 +MPLB0_SX314 +MPLB0_SX404 +MPLB0_SX44 +MPWM0_SA1 +MPWM0_SA2 +MPWM0_SI1127 +MPWM0_SI1757 +MPWM0_SI2279 +MPWM0_SX137 +MPWM0_SX227 +MPWM0_SX317 +MPWM0_SX407 +MPWM0_SX47 +MRCS0_SA1 +MRCS0_SA2 +MRCS0_SI1223 +MRCS0_SI1853 +MRCS0_SI593 +MRCS0_SX143 +MRCS0_SX233 +MRCS0_SX323 +MRCS0_SX413 +MRCS0_SX53 +MRCZ0_SA1 +MRCZ0_SA2 +MRCZ0_SI1541 +MRCZ0_SI2171 +MRCZ0_SI911 +MRCZ0_SX101 +MRCZ0_SX11 +MRCZ0_SX191 +MRCZ0_SX281 +MRCZ0_SX371 +MREB0_SA1 +MREB0_SA2 +MREB0_SI1375 +MREB0_SI2005 +MREB0_SI745 +MREB0_SX115 +MREB0_SX205 +MREB0_SX25 +MREB0_SX295 +MREB0_SX385 +MRES0_SA1 +MRES0_SA2 +MRES0_SI1217 +MRES0_SI1847 +MRES0_SI587 +MRES0_SX137 +MRES0_SX227 +MRES0_SX317 +MRES0_SX407 +MRES0_SX47 +MRGG0_SA1 +MRGG0_SA2 +MRGG0_SI1199 +MRGG0_SI1829 +MRGG0_SI569 +MRGG0_SX119 +MRGG0_SX209 +MRGG0_SX29 +MRGG0_SX299 +MRGG0_SX389 +MRJM3_SA1 +MRJM3_SA2 +MRJM3_SI1448 +MRJM3_SI1809 +MRJM3_SI2078 +MRJM3_SX188 +MRJM3_SX278 +MRJM3_SX368 +MRJM3_SX8 +MRJM3_SX98 +MRJM4_SA1 +MRJM4_SA2 +MRJM4_SI1489 +MRJM4_SI2119 +MRJM4_SI859 +MRJM4_SX139 +MRJM4_SX229 +MRJM4_SX319 +MRJM4_SX409 +MRJM4_SX49 +MRJO0_SA1 +MRJO0_SA2 +MRJO0_SI1364 +MRJO0_SI1624 +MRJO0_SI734 +MRJO0_SX104 +MRJO0_SX14 +MRJO0_SX194 +MRJO0_SX284 +MRJO0_SX374 +MRJR0_SA1 +MRJR0_SA2 +MRJR0_SI1182 +MRJR0_SI1812 +MRJR0_SI2313 +MRJR0_SX102 +MRJR0_SX12 +MRJR0_SX192 +MRJR0_SX282 +MRJR0_SX372 +MRJS0_SA1 +MRJS0_SA2 +MRJS0_SI1444 +MRJS0_SI1523 +MRJS0_SI2074 +MRJS0_SX184 +MRJS0_SX274 +MRJS0_SX364 +MRJS0_SX4 +MRJS0_SX94 +MRKO0_SA1 +MRKO0_SA2 +MRKO0_SI1397 +MRKO0_SI2027 +MRKO0_SI767 +MRKO0_SX137 +MRKO0_SX227 +MRKO0_SX317 +MRKO0_SX407 +MRKO0_SX47 +MRMS1_SA1 +MRMS1_SA2 +MRMS1_SI1487 +MRMS1_SI2117 +MRMS1_SI857 +MRMS1_SX137 +MRMS1_SX227 +MRMS1_SX317 +MRMS1_SX407 +MRMS1_SX47 +MROA0_SA1 +MROA0_SA2 +MROA0_SI1307 +MROA0_SI1970 +MROA0_SI677 +MROA0_SX137 +MROA0_SX227 +MROA0_SX317 +MROA0_SX407 +MROA0_SX47 +MRPC0_SA1 +MRPC0_SA2 +MRPC0_SI1753 +MRPC0_SI493 +MRPC0_SI933 +MRPC0_SX133 +MRPC0_SX223 +MRPC0_SX313 +MRPC0_SX403 +MRPC0_SX43 +MRPP0_SA1 +MRPP0_SA2 +MRPP0_SI1184 +MRPP0_SI1814 +MRPP0_SI554 +MRPP0_SX104 +MRPP0_SX14 +MRPP0_SX194 +MRPP0_SX284 +MRPP0_SX374 +MRRK0_SA1 +MRRK0_SA2 +MRRK0_SI1288 +MRRK0_SI1716 +MRRK0_SI1918 +MRRK0_SX118 +MRRK0_SX208 +MRRK0_SX28 +MRRK0_SX298 +MRRK0_SX388 +MRTK0_SA1 +MRTK0_SA2 +MRTK0_SI1093 +MRTK0_SI1723 +MRTK0_SI1750 +MRTK0_SX103 +MRTK0_SX13 +MRTK0_SX193 +MRTK0_SX283 +MRTK0_SX373 +MRWS1_SA1 +MRWS1_SA2 +MRWS1_SI1130 +MRWS1_SI1496 +MRWS1_SI500 +MRWS1_SX140 +MRWS1_SX230 +MRWS1_SX320 +MRWS1_SX410 +MRWS1_SX50 +MSFH1_SA1 +MSFH1_SA2 +MSFH1_SI1270 +MSFH1_SI1900 +MSFH1_SI640 +MSFH1_SX10 +MSFH1_SX100 +MSFH1_SX190 +MSFH1_SX280 +MSFH1_SX370 +MSJS1_SA1 +MSJS1_SA2 +MSJS1_SI1899 +MSJS1_SI639 +MSJS1_SI869 +MSJS1_SX189 +MSJS1_SX279 +MSJS1_SX369 +MSJS1_SX9 +MSJS1_SX99 +MSLB0_SA1 +MSLB0_SA2 +MSLB0_SI1193 +MSLB0_SI1823 +MSLB0_SI563 +MSLB0_SX113 +MSLB0_SX203 +MSLB0_SX23 +MSLB0_SX293 +MSLB0_SX383 +MSTK0_SA1 +MSTK0_SA2 +MSTK0_SI1024 +MSTK0_SI2222 +MSTK0_SI2284 +MSTK0_SX124 +MSTK0_SX214 +MSTK0_SX304 +MSTK0_SX34 +MSTK0_SX394 +MTAA0_SA1 +MTAA0_SA2 +MTAA0_SI1285 +MTAA0_SI1915 +MTAA0_SI596 +MTAA0_SX115 +MTAA0_SX205 +MTAA0_SX25 +MTAA0_SX295 +MTAA0_SX385 +MTAS1_SA1 +MTAS1_SA2 +MTAS1_SI1473 +MTAS1_SI2098 +MTAS1_SI838 +MTAS1_SX118 +MTAS1_SX208 +MTAS1_SX28 +MTAS1_SX298 +MTAS1_SX388 +MTDT0_SA1 +MTDT0_SA2 +MTDT0_SI1994 +MTDT0_SI2254 +MTDT0_SI994 +MTDT0_SX184 +MTDT0_SX274 +MTDT0_SX364 +MTDT0_SX4 +MTDT0_SX94 +MTEB0_SA1 +MTEB0_SA2 +MTEB0_SI1133 +MTEB0_SI2064 +MTEB0_SI503 +MTEB0_SX143 +MTEB0_SX233 +MTEB0_SX323 +MTEB0_SX413 +MTEB0_SX53 +MTHC0_SA1 +MTHC0_SA2 +MTHC0_SI1015 +MTHC0_SI1645 +MTHC0_SI2275 +MTHC0_SX115 +MTHC0_SX205 +MTHC0_SX25 +MTHC0_SX295 +MTHC0_SX385 +MTLS0_SA1 +MTLS0_SA2 +MTLS0_SI1370 +MTLS0_SI2000 +MTLS0_SI740 +MTLS0_SX110 +MTLS0_SX20 +MTLS0_SX200 +MTLS0_SX290 +MTLS0_SX380 +MTMR0_SA1 +MTMR0_SA2 +MTMR0_SI1303 +MTMR0_SI1933 +MTMR0_SI673 +MTMR0_SX133 +MTMR0_SX223 +MTMR0_SX313 +MTMR0_SX403 +MTMR0_SX43 +MTWH0_SA1 +MTWH0_SA2 +MTWH0_SI1190 +MTWH0_SI1629 +MTWH0_SI1820 +MTWH0_SX110 +MTWH0_SX20 +MTWH0_SX200 +MTWH0_SX290 +MTWH0_SX380 +MWBT0_SA1 +MWBT0_SA2 +MWBT0_SI1553 +MWBT0_SI2183 +MWBT0_SI923 +MWBT0_SX113 +MWBT0_SX203 +MWBT0_SX23 +MWBT0_SX293 +MWBT0_SX383 +MWEW0_SA1 +MWEW0_SA2 +MWEW0_SI1361 +MWEW0_SI1991 +MWEW0_SI731 +MWEW0_SX101 +MWEW0_SX11 +MWEW0_SX191 +MWEW0_SX281 +MWEW0_SX371 +MWJG0_SA1 +MWJG0_SA2 +MWJG0_SI1124 +MWJG0_SI1754 +MWJG0_SI494 +MWJG0_SX134 +MWJG0_SX224 +MWJG0_SX314 +MWJG0_SX404 +MWJG0_SX44 +MWVW0_SA1 +MWVW0_SA2 +MWVW0_SI1476 +MWVW0_SI2106 +MWVW0_SI846 +MWVW0_SX126 +MWVW0_SX216 +MWVW0_SX306 +MWVW0_SX36 +MWVW0_SX396 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train.uid new file mode 100644 index 0000000000000000000000000000000000000000..35b02e7f82cc788f59860befad083ba8cfc899c0 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train.uid @@ -0,0 +1,3000 @@ +FAEM0_SA1 +FAEM0_SA2 +FAEM0_SI2022 +FAEM0_SX132 +FAEM0_SX222 +FAEM0_SX312 +FAEM0_SX402 +FAJW0_SA2 +FAJW0_SI1893 +FAJW0_SX183 +FAJW0_SX273 +FAJW0_SX363 +FALK0_SA1 +FALK0_SA2 +FALK0_SI1086 +FALK0_SI456 +FALK0_SX276 +FALK0_SX366 +FALK0_SX96 +FALR0_SA1 +FALR0_SA2 +FALR0_SI1955 +FALR0_SI695 +FALR0_SX155 +FALR0_SX245 +FALR0_SX425 +FALR0_SX65 +FAPB0_SA1 +FAPB0_SA2 +FAPB0_SI1693 +FAPB0_SX163 +FAPB0_SX253 +FAPB0_SX343 +FAPB0_SX73 +FBAS0_SA2 +FBAS0_SI1387 +FBAS0_SX127 +FBAS0_SX307 +FBAS0_SX37 +FBAS0_SX397 +FBCG1_SA2 +FBCG1_SI1612 +FBCG1_SI2242 +FBCG1_SI982 +FBCG1_SX262 +FBCG1_SX82 +FBCH0_SA1 +FBCH0_SA2 +FBCH0_SI1586 +FBCH0_SI956 +FBCH0_SX146 +FBCH0_SX326 +FBCH0_SX56 +FBJL0_SA1 +FBJL0_SA2 +FBJL0_SI1552 +FBJL0_SI2182 +FBJL0_SX112 +FBJL0_SX202 +FBJL0_SX22 +FBJL0_SX292 +FBJL0_SX382 +FBLV0_SA2 +FBLV0_SI2318 +FBLV0_SX158 +FBLV0_SX248 +FBLV0_SX428 +FBMH0_SA2 +FBMH0_SI1766 +FBMH0_SX146 +FBMH0_SX236 +FBMH0_SX326 +FBMH0_SX416 +FBMH0_SX56 +FBMJ0_SA2 +FBMJ0_SX156 +FBMJ0_SX246 +FBMJ0_SX426 +FBMJ0_SX66 +FCAG0_SA2 +FCAG0_SI1503 +FCAG0_SI1641 +FCAG0_SI2133 +FCAG0_SX333 +FCAG0_SX423 +FCAG0_SX63 +FCAJ0_SA1 +FCAJ0_SA2 +FCAJ0_SI1804 +FCAJ0_SI849 +FCAJ0_SX129 +FCAJ0_SX219 +FCAJ0_SX39 +FCAJ0_SX399 +FCDR1_SA1 +FCDR1_SA2 +FCDR1_SX16 +FCDR1_SX376 +FCEG0_SA1 +FCEG0_SI1248 +FCEG0_SI1878 +FCEG0_SI618 +FCEG0_SX168 +FCEG0_SX258 +FCEG0_SX348 +FCEG0_SX438 +FCEG0_SX78 +FCJF0_SA2 +FCJF0_SI1027 +FCJF0_SI1657 +FCJF0_SI648 +FCJF0_SX217 +FCJF0_SX307 +FCJF0_SX37 +FCJF0_SX397 +FCJS0_SA1 +FCJS0_SA2 +FCJS0_SI977 +FCJS0_SX167 +FCJS0_SX347 +FCJS0_SX437 +FCJS0_SX77 +FCKE0_SA1 +FCKE0_SI1111 +FCKE0_SX211 +FCKE0_SX301 +FCKE0_SX31 +FCKE0_SX391 +FCLT0_SA1 +FCLT0_SA2 +FCLT0_SI1438 +FCLT0_SX178 +FCLT0_SX268 +FCLT0_SX358 +FCMG0_SA1 +FCMG0_SI1242 +FCMG0_SX162 +FCMG0_SX252 +FCMG0_SX342 +FCMM0_SI1083 +FCMM0_SI453 +FCMM0_SX273 +FCMM0_SX363 +FCMM0_SX93 +FCRZ0_SA1 +FCRZ0_SA2 +FCRZ0_SI1913 +FCRZ0_SI793 +FCRZ0_SX163 +FCRZ0_SX253 +FCRZ0_SX343 +FCRZ0_SX73 +FCYL0_SA2 +FCYL0_SI1297 +FCYL0_SI1927 +FCYL0_SX127 +FCYL0_SX217 +FCYL0_SX397 +FDAS1_SA1 +FDAS1_SA2 +FDAS1_SX111 +FDAS1_SX21 +FDAS1_SX291 +FDAW0_SA1 +FDAW0_SA2 +FDAW0_SX146 +FDAW0_SX236 +FDAW0_SX326 +FDAW0_SX416 +FDAW0_SX56 +FDFB0_SI1318 +FDFB0_SI1948 +FDFB0_SX148 +FDFB0_SX238 +FDFB0_SX328 +FDFB0_SX418 +FDJH0_SA1 +FDJH0_SA2 +FDJH0_SI1565 +FDJH0_SI2195 +FDJH0_SX125 +FDJH0_SX215 +FDJH0_SX35 +FDJH0_SX395 +FDKN0_SA1 +FDKN0_SA2 +FDKN0_SI1081 +FDKN0_SI1711 +FDKN0_SX271 +FDKN0_SX361 +FDKN0_SX91 +FDML0_SA1 +FDML0_SI1149 +FDML0_SI1779 +FDML0_SI2075 +FDML0_SX339 +FDML0_SX69 +FDMY0_SI1197 +FDMY0_SX117 +FDMY0_SX207 +FDMY0_SX297 +FDNC0_SA1 +FDNC0_SA2 +FDNC0_SI2287 +FDNC0_SX108 +FDNC0_SX18 +FDNC0_SX378 +FDTD0_SA2 +FDTD0_SI1561 +FDTD0_SI2191 +FDTD0_SI931 +FDTD0_SX121 +FDTD0_SX301 +FDTD0_SX391 +FDXW0_SA2 +FDXW0_SI1511 +FDXW0_SI2141 +FDXW0_SI881 +FDXW0_SX161 +FDXW0_SX431 +FEAC0_SA1 +FEAC0_SA2 +FEAC0_SI1245 +FEAC0_SI1875 +FEAC0_SX255 +FEAC0_SX345 +FEAC0_SX435 +FEAR0_SA1 +FEAR0_SA2 +FEAR0_SI1252 +FEAR0_SI1882 +FEAR0_SX172 +FEAR0_SX262 +FEAR0_SX442 +FEAR0_SX82 +FECD0_SA2 +FECD0_SI2048 +FECD0_SX158 +FECD0_SX248 +FECD0_SX338 +FECD0_SX428 +FEEH0_SA2 +FEEH0_SI1112 +FEEH0_SX212 +FEEH0_SX302 +FEEH0_SX32 +FEEH0_SX392 +FEME0_SA2 +FEME0_SI1505 +FEME0_SI2135 +FEME0_SX245 +FEME0_SX425 +FETB0_SA2 +FETB0_SI1778 +FETB0_SI518 +FETB0_SX248 +FETB0_SX338 +FETB0_SX428 +FETB0_SX68 +FEXM0_SA2 +FEXM0_SI1731 +FEXM0_SX111 +FEXM0_SX201 +FEXM0_SX291 +FEXM0_SX381 +FGCS0_SA1 +FGCS0_SA2 +FGCS0_SI1486 +FGCS0_SI2116 +FGCS0_SI856 +FGCS0_SX46 +FGDP0_SA2 +FGDP0_SI1618 +FGDP0_SI2248 +FGDP0_SX178 +FGDP0_SX268 +FGDP0_SX358 +FGDP0_SX448 +FGMB0_SA1 +FGMB0_SA2 +FGMB0_SI515 +FGMB0_SX155 +FGMB0_SX425 +FGMB0_SX65 +FGRW0_SA2 +FGRW0_SI1782 +FGRW0_SI1990 +FGRW0_SX252 +FGRW0_SX342 +FGRW0_SX72 +FHLM0_SA1 +FHLM0_SA2 +FHLM0_SI1560 +FHLM0_SI2190 +FHLM0_SI930 +FHLM0_SX210 +FHLM0_SX300 +FHXS0_SI2335 +FHXS0_SX265 +FHXS0_SX355 +FHXS0_SX85 +FJDM2_SI1582 +FJDM2_SI1964 +FJDM2_SI2212 +FJDM2_SX322 +FJDM2_SX412 +FJEN0_SA2 +FJEN0_SI1047 +FJEN0_SI1677 +FJEN0_SI2307 +FJEN0_SX147 +FJEN0_SX237 +FJEN0_SX57 +FJHK0_SA1 +FJHK0_SA2 +FJHK0_SI1022 +FJHK0_SI1652 +FJHK0_SX122 +FJHK0_SX212 +FJHK0_SX32 +FJHK0_SX392 +FJKL0_SA1 +FJKL0_SA2 +FJKL0_SI1562 +FJKL0_SI2192 +FJKL0_SX122 +FJKL0_SX302 +FJKL0_SX32 +FJLG0_SA1 +FJLG0_SA2 +FJLG0_SI1506 +FJLG0_SX179 +FJLG0_SX269 +FJLG0_SX359 +FJLG0_SX449 +FJLG0_SX89 +FJLR0_SA2 +FJLR0_SI1861 +FJLR0_SI601 +FJLR0_SX151 +FJLR0_SX241 +FJLR0_SX331 +FJLR0_SX421 +FJLR0_SX61 +FJRB0_SA1 +FJRB0_SA2 +FJRB0_SI1302 +FJRB0_SI1932 +FJRB0_SI672 +FJRB0_SX132 +FJRB0_SX222 +FJRB0_SX312 +FJRB0_SX42 +FJRP1_SA2 +FJRP1_SI802 +FJRP1_SX172 +FJRP1_SX442 +FJSK0_SA2 +FJSK0_SI1682 +FJSK0_SI2312 +FJSK0_SX152 +FJSK0_SX242 +FJSK0_SX332 +FJSK0_SX422 +FJSK0_SX62 +FJSP0_SA1 +FJSP0_SA2 +FJSP0_SI1763 +FJSP0_SI804 +FJSP0_SX174 +FJSP0_SX84 +FJWB1_SA2 +FJWB1_SI2055 +FJWB1_SI795 +FJWB1_SX165 +FJWB1_SX255 +FJWB1_SX75 +FJXM0_SA2 +FJXM0_SI1211 +FJXM0_SI1971 +FJXM0_SX131 +FJXM0_SX221 +FJXP0_SA2 +FJXP0_SI492 +FJXP0_SX222 +FJXP0_SX312 +FJXP0_SX402 +FJXP0_SX42 +FKAA0_SA2 +FKAA0_SI1208 +FKAA0_SI1838 +FKAA0_SI578 +FKAA0_SX218 +FKAA0_SX308 +FKAA0_SX38 +FKDE0_SA2 +FKDE0_SI2221 +FKDE0_SX331 +FKDW0_SA1 +FKDW0_SA2 +FKDW0_SI577 +FKDW0_SX127 +FKDW0_SX217 +FKDW0_SX307 +FKDW0_SX37 +FKFB0_SA1 +FKFB0_SI2238 +FKFB0_SI978 +FKFB0_SX168 +FKFB0_SX258 +FKKH0_SI660 +FKKH0_SX210 +FKKH0_SX30 +FKKH0_SX300 +FKLC0_SA1 +FKLC0_SA2 +FKLC0_SI1615 +FKLC0_SI2245 +FKLC0_SX265 +FKLC0_SX445 +FKLC0_SX85 +FKLC1_SA1 +FKLC1_SA2 +FKLC1_SI1678 +FKLC1_SX148 +FKLC1_SX58 +FKLH0_SA1 +FKLH0_SI1887 +FKLH0_SI627 +FKLH0_SX267 +FKLH0_SX357 +FKLH0_SX447 +FKLH0_SX87 +FKSR0_SI1117 +FKSR0_SX161 +FKSR0_SX37 +FKSR0_SX397 +FLAC0_SA1 +FLAC0_SA2 +FLAC0_SI2161 +FLAC0_SI901 +FLAC0_SX181 +FLAC0_SX271 +FLAC0_SX361 +FLAC0_SX91 +FLAG0_SA1 +FLAG0_SI2094 +FLAG0_SX294 +FLEH0_SA1 +FLEH0_SA2 +FLEH0_SX151 +FLEH0_SX241 +FLEH0_SX421 +FLEH0_SX61 +FLET0_SA2 +FLET0_SI1137 +FLET0_SI1767 +FLET0_SX147 +FLET0_SX237 +FLET0_SX277 +FLET0_SX417 +FLET0_SX57 +FLHD0_SA1 +FLHD0_SA2 +FLHD0_SI1344 +FLHD0_SI1974 +FLHD0_SX174 +FLHD0_SX264 +FLHD0_SX444 +FLHD0_SX84 +FLJA0_SA2 +FLJA0_SI1708 +FLJA0_SX268 +FLJA0_SX358 +FLJA0_SX448 +FLJA0_SX88 +FLJD0_SA1 +FLJD0_SA2 +FLJD0_SI2146 +FLJD0_SX166 +FLJD0_SX256 +FLJD0_SX346 +FLJD0_SX436 +FLJG0_SA1 +FLJG0_SI1611 +FLJG0_SI2241 +FLJG0_SX261 +FLJG0_SX441 +FLJG0_SX81 +FLKM0_SI1880 +FLKM0_SX116 +FLMA0_SA2 +FLMA0_SI1243 +FLMA0_SI1873 +FLMA0_SX163 +FLMA0_SX253 +FLMA0_SX343 +FLMC0_SA1 +FLMC0_SA2 +FLMC0_SI2002 +FLMC0_SI742 +FLMC0_SX112 +FLMC0_SX292 +FLMC0_SX336 +FLMC0_SX382 +FLMK0_SA2 +FLMK0_SI2295 +FLMK0_SX135 +FLMK0_SX225 +FLMK0_SX45 +FLOD0_SA1 +FLOD0_SA2 +FLOD0_SI1287 +FLOD0_SI657 +FLOD0_SX207 +FLOD0_SX387 +FLTM0_SA2 +FLTM0_SI1700 +FLTM0_SX260 +FLTM0_SX80 +FMAH1_SA1 +FMAH1_SI1509 +FMAH1_SI2139 +FMAH1_SX249 +FMAH1_SX339 +FMAH1_SX429 +FMAH1_SX69 +FMBG0_SA1 +FMBG0_SI1790 +FMBG0_SX260 +FMBG0_SX3 +FMBG0_SX350 +FMBG0_SX440 +FMBG0_SX80 +FMEM0_SA2 +FMEM0_SI1377 +FMEM0_SI2007 +FMEM0_SX117 +FMEM0_SX207 +FMEM0_SX297 +FMJB0_SA1 +FMJB0_SA2 +FMJB0_SI1807 +FMJB0_SX187 +FMJB0_SX277 +FMJB0_SX367 +FMJB0_SX7 +FMJF0_SA1 +FMJF0_SI1254 +FMJF0_SI1884 +FMJF0_SX264 +FMJF0_SX354 +FMJF0_SX444 +FMJU0_SA1 +FMJU0_SA2 +FMJU0_SI2019 +FMJU0_SI759 +FMJU0_SX129 +FMJU0_SX219 +FMJU0_SX39 +FMKC0_SA1 +FMKC0_SA2 +FMKC0_SI1072 +FMKC0_SX172 +FMKC0_SX262 +FMKC0_SX352 +FMKF0_SA1 +FMKF0_SA2 +FMKF0_SI1536 +FMKF0_SI906 +FMKF0_SX276 +FMKF0_SX366 +FMKF0_SX6 +FMKF0_SX96 +FMMH0_SA1 +FMMH0_SA2 +FMMH0_SI1537 +FMMH0_SI2167 +FMMH0_SI907 +FMMH0_SX187 +FMMH0_SX367 +FMMH0_SX420 +FMMH0_SX7 +FMMH0_SX97 +FMPG0_SI1602 +FMPG0_SI2232 +FMPG0_SX252 +FMPG0_SX72 +FNKL0_SA1 +FNKL0_SA2 +FNKL0_SI2152 +FNKL0_SX172 +FNKL0_SX196 +FNKL0_SX262 +FNKL0_SX442 +FNKL0_SX82 +FNTB0_SA1 +FNTB0_SA2 +FNTB0_SX123 +FNTB0_SX213 +FNTB0_SX33 +FNTB0_SX393 +FPAB1_SA2 +FPAB1_SX121 +FPAB1_SX301 +FPAB1_SX31 +FPAB1_SX391 +FPAC0_SA1 +FPAC0_SI2011 +FPAC0_SX121 +FPAC0_SX211 +FPAC0_SX301 +FPAC0_SX31 +FPAC0_SX391 +FPAD0_SA1 +FPAD0_SI1346 +FPAD0_SI1976 +FPAD0_SX266 +FPAD0_SX446 +FPAF0_SI1684 +FPAF0_SI2314 +FPAF0_SX244 +FPAF0_SX334 +FPAF0_SX424 +FPAF0_SX64 +FPAZ0_SI1593 +FPAZ0_SX153 +FPAZ0_SX27 +FPAZ0_SX423 +FPAZ0_SX63 +FPJF0_SA2 +FPJF0_SI1046 +FPJF0_SI1676 +FPJF0_SX236 +FPJF0_SX326 +FPLS0_SA1 +FPLS0_SA2 +FPLS0_SI2220 +FPLS0_SX150 +FPLS0_SX240 +FPLS0_SX3 +FPLS0_SX60 +FPMY0_SA2 +FPMY0_SI1783 +FPMY0_SX163 +FPMY0_SX196 +FPMY0_SX253 +FPMY0_SX73 +FREH0_SI1315 +FREH0_SI685 +FREH0_SX145 +FREH0_SX235 +FREH0_SX325 +FREH0_SX55 +FRJB0_SA1 +FRJB0_SA2 +FRJB0_SI1427 +FRJB0_SI1470 +FRJB0_SI1794 +FRJB0_SX167 +FRJB0_SX257 +FRJB0_SX437 +FRJB0_SX77 +FRLL0_SA1 +FRLL0_SA2 +FRLL0_SI1514 +FRLL0_SI884 +FRLL0_SX164 +FRLL0_SX254 +FRLL0_SX344 +FRLL0_SX74 +FSAG0_SA2 +FSAG0_SI1953 +FSAG0_SI693 +FSAG0_SX63 +FSAH0_SI1244 +FSAH0_SI1874 +FSAH0_SX344 +FSAH0_SX74 +FSAK0_SA1 +FSAK0_SA2 +FSAK0_SI1930 +FSAK0_SI670 +FSAK0_SX130 +FSAK0_SX220 +FSAK0_SX310 +FSAK0_SX40 +FSAK0_SX400 +FSBK0_SA1 +FSBK0_SI1699 +FSBK0_SI2329 +FSBK0_SX259 +FSBK0_SX439 +FSBK0_SX79 +FSCN0_SI1886 +FSCN0_SX356 +FSDC0_SA1 +FSDC0_SI1942 +FSDC0_SI2234 +FSDC0_SX232 +FSDC0_SX412 +FSDJ0_SA1 +FSDJ0_SA2 +FSDJ0_SI1745 +FSDJ0_SX125 +FSDJ0_SX35 +FSGF0_SA1 +FSGF0_SA2 +FSGF0_SI1557 +FSGF0_SX207 +FSGF0_SX27 +FSGF0_SX297 +FSGF0_SX387 +FSJG0_SI1570 +FSJG0_SI2200 +FSJG0_SX310 +FSJK1_SA1 +FSJK1_SI1025 +FSJK1_SI2285 +FSJK1_SI696 +FSJK1_SX215 +FSJK1_SX305 +FSJK1_SX395 +FSJS0_SA2 +FSJS0_SI1171 +FSJS0_SI1801 +FSJS0_SI541 +FSJS0_SX271 +FSJS0_SX361 +FSJS0_SX91 +FSJW0_SA1 +FSJW0_SA2 +FSJW0_SI703 +FSJW0_SX163 +FSJW0_SX253 +FSJW0_SX343 +FSJW0_SX73 +FSKC0_SA1 +FSKC0_SA2 +FSKC0_SI2046 +FSKC0_SX156 +FSKC0_SX336 +FSKC0_SX426 +FSKC0_SX66 +FSKL0_SA1 +FSKL0_SA2 +FSKL0_SI2159 +FSKL0_SI899 +FSKL0_SX179 +FSKL0_SX269 +FSKL0_SX359 +FSKL0_SX89 +FSKP0_SA1 +FSKP0_SI1728 +FSKP0_SI468 +FSKP0_SX108 +FSKP0_SX18 +FSKP0_SX198 +FSKP0_SX288 +FSKP0_SX378 +FSLS0_SA1 +FSLS0_SA2 +FSLS0_SI1056 +FSLS0_SI1686 +FSLS0_SI2316 +FSLS0_SX202 +FSLS0_SX246 +FSLS0_SX66 +FSMA0_SA1 +FSMA0_SI1621 +FSMA0_SI2251 +FSMA0_SX271 +FSMA0_SX361 +FSMA0_SX91 +FSMM0_SA1 +FSMM0_SA2 +FSMM0_SI1314 +FSMM0_SI1944 +FSMM0_SI684 +FSMM0_SX414 +FSMM0_SX54 +FSMS1_SA1 +FSMS1_SA2 +FSMS1_SI1504 +FSMS1_SI2134 +FSMS1_SI874 +FSMS1_SX154 +FSMS1_SX334 +FSMS1_SX64 +FSPM0_SA1 +FSPM0_SI1871 +FSPM0_SI611 +FSPM0_SX341 +FSPM0_SX431 +FSRH0_SA1 +FSRH0_SA2 +FSRH0_SI1719 +FSRH0_SX131 +FSRH0_SX41 +FSSB0_SA1 +FSSB0_SA2 +FSSB0_SI1082 +FSSB0_SI2342 +FSSB0_SX182 +FSSB0_SX272 +FSSB0_SX452 +FSSB0_SX92 +FTAJ0_SA1 +FTAJ0_SA2 +FTAJ0_SI1329 +FTAJ0_SI474 +FTAJ0_SX339 +FTAJ0_SX69 +FTBR0_SA1 +FTBR0_SA2 +FTBR0_SI2181 +FTBR0_SX111 +FTBR0_SX201 +FTBR0_SX291 +FTBR0_SX381 +FTBW0_SA2 +FTBW0_SI1345 +FTBW0_SI1975 +FTBW0_SX265 +FTBW0_SX355 +FTBW0_SX445 +FTBW0_SX85 +FTLG0_SA1 +FTLG0_SA2 +FTLG0_SI840 +FTLG0_SX123 +FTLG0_SX213 +FTLG0_SX303 +FTLG0_SX33 +FTLG0_SX393 +FTMG0_SA1 +FTMG0_SA2 +FTMG0_SX182 +FTMG0_SX272 +FTMG0_SX362 +FTMG0_SX92 +FVFB0_SA1 +FVFB0_SI1032 +FVFB0_SI2292 +FVFB0_SX222 +FVFB0_SX312 +FVFB0_SX402 +FVKB0_SA2 +FVKB0_SI1159 +FVKB0_SI1789 +FVKB0_SI529 +FVKB0_SX169 +FVKB0_SX259 +FVKB0_SX439 +FVKB0_SX79 +FVMH0_SA1 +FVMH0_SI2096 +FVMH0_SX206 +FVMH0_SX296 +FVMH0_SX386 +MABC0_SA1 +MABC0_SA2 +MABC0_SX151 +MABC0_SX241 +MABC0_SX331 +MABC0_SX421 +MABC0_SX61 +MADC0_SA1 +MADC0_SA2 +MADC0_SI1997 +MADC0_SX17 +MADC0_SX197 +MADC0_SX287 +MADD0_SA1 +MADD0_SI1798 +MADD0_SI538 +MADD0_SX358 +MADD0_SX448 +MAEB0_SA1 +MAEB0_SA2 +MAEB0_SI2250 +MAEB0_SI990 +MAEB0_SX180 +MAEB0_SX270 +MAEB0_SX360 +MAEB0_SX90 +MAEO0_SA2 +MAEO0_SI1655 +MAEO0_SI1956 +MAEO0_SX156 +MAEO0_SX246 +MAEO0_SX336 +MAEO0_SX426 +MAEO0_SX66 +MAFM0_SA1 +MAFM0_SA2 +MAFM0_SI1569 +MAFM0_SI2199 +MAFM0_SX219 +MAFM0_SX39 +MAFM0_SX399 +MAJP0_SA1 +MAJP0_SI1074 +MAJP0_SI2334 +MAJP0_SX264 +MAJP0_SX354 +MAJP0_SX444 +MAJP0_SX84 +MAKB0_SA1 +MAKB0_SX206 +MAKB0_SX296 +MAKR0_SA1 +MAKR0_SA2 +MAKR0_SI1352 +MAKR0_SI1982 +MAKR0_SI722 +MAKR0_SX182 +MAKR0_SX272 +MAKR0_SX452 +MAPV0_SA1 +MAPV0_SA2 +MAPV0_SI1923 +MAPV0_SX123 +MAPV0_SX303 +MAPV0_SX33 +MAPV0_SX393 +MARC0_SA1 +MARC0_SI1188 +MARC0_SI1818 +MARC0_SI558 +MARC0_SX288 +MARC0_SX378 +MARW0_SA1 +MARW0_SA2 +MARW0_SI1276 +MARW0_SI646 +MARW0_SX106 +MARW0_SX16 +MARW0_SX376 +MBAR0_SA2 +MBAR0_SI1319 +MBAR0_SI1949 +MBAR0_SI689 +MBAR0_SX149 +MBAR0_SX239 +MBAR0_SX329 +MBBR0_SA1 +MBBR0_SA2 +MBBR0_SI1685 +MBBR0_SX155 +MBBR0_SX245 +MBBR0_SX425 +MBCG0_SA2 +MBCG0_SI2217 +MBCG0_SX147 +MBCG0_SX237 +MBCG0_SX417 +MBCG0_SX57 +MBEF0_SA1 +MBEF0_SA2 +MBEF0_SX111 +MBEF0_SX201 +MBEF0_SX291 +MBGT0_SA1 +MBGT0_SI1341 +MBGT0_SI711 +MBGT0_SX81 +MBJV0_SA2 +MBJV0_SI1247 +MBJV0_SI1877 +MBJV0_SX167 +MBJV0_SX257 +MBJV0_SX437 +MBJV0_SX77 +MBMA0_SA1 +MBMA0_SA2 +MBMA0_SI1852 +MBMA0_SX142 +MBMA0_SX322 +MBMA0_SX412 +MBMA1_SA1 +MBMA1_SA2 +MBMA1_SI2207 +MBMA1_SX144 +MBMA1_SX234 +MBMA1_SX414 +MBML0_SA1 +MBML0_SI1799 +MBML0_SI539 +MBML0_SX179 +MBML0_SX269 +MBML0_SX359 +MBML0_SX449 +MBOM0_SA1 +MBOM0_SI1014 +MBOM0_SI1644 +MBOM0_SX114 +MBOM0_SX204 +MBOM0_SX311 +MBOM0_SX384 +MBSB0_SA2 +MBSB0_SI1353 +MBSB0_SI1983 +MBSB0_SI723 +MBSB0_SX183 +MBSB0_SX273 +MBSB0_SX363 +MBSB0_SX93 +MBTH0_SA1 +MBTH0_SI505 +MBTH0_SI757 +MBTH0_SX212 +MBTH0_SX302 +MBTH0_SX392 +MBWP0_SA1 +MBWP0_SA2 +MBWP0_SI1531 +MBWP0_SI1969 +MBWP0_SI709 +MBWP0_SX169 +MBWP0_SX259 +MBWP0_SX439 +MBWP0_SX79 +MCAE0_SA1 +MCAE0_SA2 +MCAE0_SX187 +MCAE0_SX367 +MCAE0_SX7 +MCAE0_SX97 +MCAL0_SA1 +MCAL0_SI508 +MCAL0_SX148 +MCAL0_SX238 +MCAL0_SX328 +MCAL0_SX418 +MCAL0_SX58 +MCDC0_SA2 +MCDC0_SI1292 +MCDC0_SI1922 +MCDC0_SI662 +MCDC0_SX122 +MCDC0_SX302 +MCDC0_SX32 +MCDC0_SX392 +MCDD0_SA1 +MCDD0_SI1513 +MCDD0_SI2143 +MCDD0_SX163 +MCDD0_SX343 +MCDD0_SX73 +MCDR0_SA1 +MCDR0_SA2 +MCDR0_SX164 +MCDR0_SX254 +MCDR0_SX344 +MCDR0_SX434 +MCDR0_SX74 +MCEF0_SA1 +MCEF0_SA2 +MCEF0_SI1135 +MCEF0_SI1765 +MCEF0_SX145 +MCEF0_SX325 +MCEF0_SX55 +MCEW0_SI1442 +MCEW0_SX182 +MCEW0_SX272 +MCEW0_SX92 +MCHL0_SA1 +MCHL0_SA2 +MCHL0_SI1977 +MCHL0_SX177 +MCHL0_SX267 +MCHL0_SX357 +MCHL0_SX447 +MCLK0_SA1 +MCLK0_SA2 +MCLK0_SI1660 +MCLK0_SX130 +MCLK0_SX220 +MCLK0_SX40 +MCLK0_SX400 +MCLM0_SA2 +MCLM0_SI1456 +MCLM0_SX106 +MCLM0_SX16 +MCLM0_SX196 +MCLM0_SX286 +MCLM0_SX376 +MCPM0_SA2 +MCPM0_SI1194 +MCPM0_SI564 +MCPM0_SX204 +MCPM0_SX24 +MCRE0_SA1 +MCRE0_SA2 +MCRE0_SI1121 +MCRE0_SI1725 +MCRE0_SI1751 +MCRE0_SX131 +MCRE0_SX221 +MCRE0_SX24 +MCRE0_SX401 +MCRE0_SX41 +MCSS0_SA1 +MCSS0_SA2 +MCSS0_SX120 +MCSS0_SX210 +MCSS0_SX30 +MCSS0_SX300 +MCSS0_SX390 +MCTH0_SA2 +MCTH0_SI1209 +MCTH0_SI1839 +MCTH0_SI579 +MCTH0_SX129 +MCTH0_SX219 +MCTH0_SX309 +MCTH0_SX399 +MCTM0_SA1 +MCTM0_SA2 +MCTM0_SI720 +MCTM0_SX180 +MCTM0_SX270 +MCTM0_SX360 +MCTM0_SX450 +MCTM0_SX90 +MCXM0_SA1 +MCXM0_SA2 +MCXM0_SI1351 +MCXM0_SI1981 +MCXM0_SI721 +MCXM0_SX181 +MCXM0_SX271 +MCXM0_SX361 +MCXM0_SX451 +MDAC0_SA2 +MDAC0_SI1261 +MDAC0_SI1837 +MDAC0_SX271 +MDAC0_SX451 +MDAC0_SX91 +MDAS0_SA1 +MDAS0_SA2 +MDAS0_SI1266 +MDAS0_SX186 +MDAS0_SX21 +MDAS0_SX276 +MDAS0_SX96 +MDBB1_SA1 +MDBB1_SA2 +MDBB1_SI1006 +MDBB1_SI1636 +MDBB1_SI2056 +MDBB1_SX196 +MDBB1_SX286 +MDBP0_SA1 +MDBP0_SA2 +MDBP0_SI1158 +MDBP0_SI1788 +MDBP0_SX258 +MDBP0_SX348 +MDBP0_SX78 +MDCD0_SA1 +MDCD0_SA2 +MDCD0_SI2045 +MDCD0_SX155 +MDCD0_SX65 +MDCM0_SA1 +MDCM0_SA2 +MDCM0_SI2110 +MDCM0_SI850 +MDCM0_SX130 +MDCM0_SX220 +MDCM0_SX310 +MDDC0_SA1 +MDDC0_SA2 +MDDC0_SX249 +MDDC0_SX339 +MDDC0_SX429 +MDED0_SI1170 +MDED0_SI1800 +MDED0_SX180 +MDED0_SX270 +MDED0_SX360 +MDED0_SX450 +MDED0_SX90 +MDEF0_SA1 +MDEF0_SA2 +MDEF0_SI1563 +MDEF0_SI2193 +MDEF0_SX213 +MDEF0_SX33 +MDEF0_SX393 +MDEM0_SA2 +MDEM0_SI1868 +MDEM0_SX158 +MDEM0_SX248 +MDEM0_SX338 +MDEM0_SX68 +MDHL0_SA1 +MDHL0_SA2 +MDHL0_SI2069 +MDHL0_SI809 +MDHL0_SX179 +MDHL0_SX359 +MDHL0_SX89 +MDHS0_SX180 +MDHS0_SX270 +MDHS0_SX360 +MDHS0_SX450 +MDHS0_SX90 +MDJM0_SA1 +MDJM0_SA2 +MDJM0_SI2085 +MDJM0_SI825 +MDJM0_SX195 +MDJM0_SX285 +MDJM0_SX375 +MDKS0_SA1 +MDKS0_SA2 +MDKS0_SI1066 +MDKS0_SI1696 +MDKS0_SI2326 +MDKS0_SX256 +MDKS0_SX76 +MDLB0_SA1 +MDLB0_SI1936 +MDLB0_SI676 +MDLB0_SX226 +MDLB0_SX316 +MDLB0_SX46 +MDLC0_SA1 +MDLC0_SA2 +MDLC0_SI765 +MDLC0_SX135 +MDLC0_SX225 +MDLC0_SX315 +MDLC0_SX45 +MDLC1_SA1 +MDLC1_SX175 +MDLC1_SX265 +MDLC1_SX355 +MDLC1_SX85 +MDLC2_SA1 +MDLC2_SA2 +MDLC2_SI1614 +MDLC2_SI984 +MDLC2_SX174 +MDLC2_SX264 +MDLC2_SX444 +MDLC2_SX84 +MDLH0_SA1 +MDLH0_SI1960 +MDLH0_SI574 +MDLH0_SI700 +MDLH0_SX250 +MDLH0_SX340 +MDLH0_SX70 +MDLM0_SA1 +MDLM0_SA2 +MDLM0_SX244 +MDLM0_SX334 +MDLM0_SX64 +MDLR0_SI1233 +MDLR0_SX243 +MDLR0_SX423 +MDLR0_SX63 +MDLR1_SI1299 +MDLR1_SI1929 +MDLR1_SX129 +MDLR1_SX219 +MDLR1_SX309 +MDLR1_SX39 +MDLR1_SX399 +MDMA0_SA1 +MDMA0_SA2 +MDMA0_SI1238 +MDMA0_SI2060 +MDMT0_SI2341 +MDMT0_SI572 +MDMT0_SX212 +MDMT0_SX302 +MDMT0_SX392 +MDNS0_SA1 +MDNS0_SX111 +MDNS0_SX291 +MDNS0_SX381 +MDPB0_SA1 +MDPB0_SA2 +MDPB0_SI2126 +MDPB0_SX146 +MDPB0_SX236 +MDPB0_SX326 +MDPB0_SX56 +MDPK0_SA1 +MDPK0_SA2 +MDPK0_SI1683 +MDPK0_SI552 +MDPK0_SX153 +MDPK0_SX243 +MDPK0_SX63 +MDPS0_SA1 +MDPS0_SA2 +MDPS0_SI1651 +MDPS0_SI1979 +MDPS0_SX179 +MDPS0_SX269 +MDPS0_SX449 +MDPS0_SX89 +MDRD0_SA2 +MDRD0_SI1382 +MDRD0_SI2012 +MDRD0_SX122 +MDRD0_SX212 +MDRD0_SX302 +MDRD0_SX392 +MDSJ0_SA1 +MDSJ0_SA2 +MDSJ0_SI832 +MDSJ0_SX112 +MDSJ0_SX22 +MDSJ0_SX292 +MDSJ0_SX382 +MDSS0_SA1 +MDSS0_SI1881 +MDSS0_SI2087 +MDSS0_SI621 +MDSS0_SX171 +MDSS0_SX261 +MDSS0_SX351 +MDSS0_SX81 +MDSS1_SA2 +MDSS1_SI1713 +MDSS1_SX247 +MDSS1_SX337 +MDSS1_SX427 +MDTB0_SA1 +MDTB0_SA2 +MDTB0_SI570 +MDTB0_SX210 +MDTB0_SX300 +MDTB0_SX321 +MDTB0_SX390 +MDWD0_SA1 +MDWD0_SI1890 +MDWD0_SI557 +MDWD0_SX180 +MDWD0_SX360 +MDWD0_SX450 +MDWH0_SA2 +MDWH0_SI1925 +MDWH0_SX125 +MDWH0_SX35 +MDWH0_SX395 +MDWM0_SI1546 +MDWM0_SI2176 +MDWM0_SX106 +MDWM0_SX376 +MDWM0_SX433 +MEAL0_SA1 +MEAL0_SI1547 +MEAL0_SI917 +MEAL0_SX197 +MEAL0_SX287 +MEAL0_SX377 +MEDR0_SI744 +MEDR0_SX114 +MEDR0_SX204 +MEDR0_SX24 +MEDR0_SX294 +MEDR0_SX384 +MEFG0_SA2 +MEFG0_SI465 +MEFG0_SX105 +MEFG0_SX15 +MEFG0_SX195 +MEFG0_SX285 +MEFG0_SX375 +MEGJ0_SI1967 +MEGJ0_SX437 +MEGJ0_SX77 +MEJL0_SA2 +MEJL0_SI1592 +MEJL0_SI1654 +MEJL0_SI962 +MEJL0_SX332 +MEJL0_SX422 +MEJL0_SX62 +MEJS0_SA1 +MEJS0_SA2 +MEJS0_SI1870 +MEJS0_SX250 +MEJS0_SX430 +MEJS0_SX70 +MESG0_SA1 +MESG0_SA2 +MESG0_SI1332 +MESG0_SI1962 +MESG0_SX162 +MESG0_SX252 +MESG0_SX342 +MESG0_SX72 +MESJ0_SA1 +MESJ0_SA2 +MESJ0_SI2257 +MESJ0_SI997 +MESJ0_SX277 +MESJ0_SX367 +MESJ0_SX7 +MEWM0_SA1 +MEWM0_SA2 +MEWM0_SI1348 +MEWM0_SI1978 +MEWM0_SX268 +MEWM0_SX358 +MEWM0_SX448 +MFER0_SA1 +MFER0_SA2 +MFER0_SI1492 +MFER0_SI2122 +MFER0_SX232 +MFER0_SX322 +MFER0_SX412 +MFER0_SX52 +MFMC0_SA1 +MFMC0_SA2 +MFMC0_SI1132 +MFMC0_SI1762 +MFMC0_SI502 +MFMC0_SX142 +MFMC0_SX232 +MFMC0_SX322 +MFMC0_SX412 +MFMC0_SX52 +MFRM0_SA1 +MFRM0_SA2 +MFRM0_SI1155 +MFRM0_SI1717 +MFRM0_SI1785 +MFRM0_SX165 +MFRM0_SX255 +MFRM0_SX75 +MFWK0_SA1 +MFWK0_SA2 +MFWK0_SI1249 +MFWK0_SI619 +MFWK0_SX259 +MFWK0_SX439 +MFWK0_SX79 +MFXS0_SA1 +MFXS0_SA2 +MFXS0_SI1674 +MFXS0_SI2225 +MFXS0_SI2304 +MFXS0_SX144 +MFXS0_SX234 +MFXS0_SX414 +MFXV0_SA1 +MFXV0_SI1635 +MFXV0_SX15 +MFXV0_SX195 +MFXV0_SX285 +MFXV0_SX375 +MGAF0_SA2 +MGAF0_SI1912 +MGAF0_SI652 +MGAF0_SX112 +MGAF0_SX202 +MGAF0_SX292 +MGAG0_SA1 +MGAG0_SI1321 +MGAG0_SI645 +MGAG0_SX151 +MGAG0_SX241 +MGAG0_SX331 +MGAG0_SX421 +MGAG0_SX61 +MGAK0_SA1 +MGAK0_SA2 +MGAK0_SI1666 +MGAK0_SI2296 +MGAK0_SX316 +MGAK0_SX406 +MGAR0_SA1 +MGAR0_SA2 +MGAR0_SI1212 +MGAR0_SI1694 +MGAR0_SI1842 +MGAR0_SX222 +MGAR0_SX402 +MGAR0_SX42 +MGAW0_SA1 +MGAW0_SA2 +MGAW0_SI1802 +MGAW0_SX265 +MGAW0_SX355 +MGAW0_SX445 +MGAW0_SX85 +MGES0_SA2 +MGES0_SI1481 +MGES0_SX131 +MGES0_SX221 +MGES0_SX401 +MGES0_SX41 +MGJC0_SA1 +MGJC0_SI1256 +MGJC0_SI1335 +MGJC0_SI1965 +MGJC0_SX165 +MGJC0_SX255 +MGJC0_SX345 +MGRL0_SA1 +MGRL0_SA2 +MGRL0_SI1497 +MGRL0_SX237 +MGRL0_SX417 +MGRL0_SX57 +MGRP0_SA1 +MGRP0_SI1947 +MGRP0_SI687 +MGRP0_SX147 +MGRP0_SX237 +MGRP0_SX417 +MGRP0_SX57 +MGSH0_SA1 +MGSH0_SX186 +MGSH0_SX96 +MGSL0_SA2 +MGSL0_SI1164 +MGSL0_SX174 +MGSL0_SX354 +MGSL0_SX444 +MGSL0_SX84 +MGXP0_SA1 +MGXP0_SA2 +MGXP0_SI457 +MGXP0_SX277 +MGXP0_SX367 +MGXP0_SX97 +MHBS0_SA1 +MHBS0_SA2 +MHBS0_SI1575 +MHBS0_SI2205 +MHBS0_SX135 +MHBS0_SX225 +MHBS0_SX405 +MHIT0_SA2 +MHIT0_SI1613 +MHIT0_SI2243 +MHIT0_SX173 +MHIT0_SX263 +MHIT0_SX353 +MHIT0_SX443 +MHIT0_SX83 +MHJB0_SA2 +MHJB0_SI1647 +MHJB0_SI2277 +MHJB0_SX117 +MHJB0_SX207 +MHJB0_SX27 +MHJB0_SX297 +MHJB0_SX387 +MHMG0_SA1 +MHMG0_SA2 +MHMG0_SI1365 +MHMG0_SI1995 +MHMG0_SX105 +MHMG0_SX15 +MHMG0_SX285 +MHMG0_SX375 +MHMR0_SA2 +MHMR0_SI1119 +MHMR0_SX129 +MHMR0_SX219 +MHMR0_SX309 +MHMR0_SX39 +MHMR0_SX399 +MHRM0_SA2 +MHRM0_SI1475 +MHRM0_SI2218 +MHRM0_SX238 +MHRM0_SX328 +MHRM0_SX418 +MHXL0_SA1 +MHXL0_SA2 +MHXL0_SI512 +MHXL0_SI612 +MHXL0_SX152 +MHXL0_SX332 +MHXL0_SX422 +MHXL0_SX62 +MILB0_SA1 +MILB0_SI2163 +MILB0_SI807 +MILB0_SX183 +MILB0_SX273 +MILB0_SX3 +MILB0_SX363 +MILB0_SX93 +MJAC0_SA1 +MJAC0_SA2 +MJAC0_SI1331 +MJAC0_SI2148 +MJAC0_SX341 +MJAC0_SX431 +MJAE0_SA1 +MJAE0_SA2 +MJAE0_SI1524 +MJAE0_SI1999 +MJAE0_SI2154 +MJAE0_SX264 +MJAE0_SX354 +MJAE0_SX444 +MJAI0_SI1604 +MJAI0_SX164 +MJAI0_SX254 +MJAI0_SX344 +MJAI0_SX434 +MJAI0_SX74 +MJBG0_SA1 +MJBG0_SA2 +MJBG0_SI1232 +MJBG0_SI1724 +MJBG0_SI1862 +MJBG0_SX152 +MJBG0_SX242 +MJBG0_SX332 +MJBG0_SX422 +MJDA0_SA1 +MJDA0_SA2 +MJDA0_SI1661 +MJDA0_SI2291 +MJDA0_SX131 +MJDA0_SX221 +MJDA0_SX401 +MJDA0_SX41 +MJDC0_SA1 +MJDC0_SA2 +MJDC0_SI1161 +MJDC0_SI2165 +MJDC0_SX171 +MJDC0_SX261 +MJDC0_SX351 +MJDC0_SX441 +MJDC0_SX81 +MJDE0_SA2 +MJDE0_SX130 +MJDE0_SX310 +MJDE0_SX40 +MJDE0_SX400 +MJDG0_SA1 +MJDG0_SI1672 +MJDG0_SX142 +MJDG0_SX232 +MJDG0_SX322 +MJDG0_SX412 +MJDG0_SX52 +MJDM0_SA2 +MJDM0_SI1937 +MJDM0_SX260 +MJDM0_SX440 +MJDM0_SX80 +MJEB0_SA1 +MJEB0_SA2 +MJEB0_SI1286 +MJEB0_SI1916 +MJEB0_SX206 +MJEB0_SX26 +MJEB0_SX386 +MJEB1_SA1 +MJEB1_SI2097 +MJEB1_SX117 +MJEB1_SX27 +MJEB1_SX297 +MJEE0_SA2 +MJEE0_SI1237 +MJEE0_SI1867 +MJEE0_SI607 +MJEE0_SX157 +MJEE0_SX427 +MJEE0_SX67 +MJFH0_SA1 +MJFH0_SI1737 +MJFH0_SI477 +MJFH0_SX117 +MJFH0_SX207 +MJFH0_SX27 +MJFH0_SX297 +MJFH0_SX387 +MJFR0_SA2 +MJFR0_SI1605 +MJFR0_SI2235 +MJFR0_SI975 +MJFR0_SX165 +MJFR0_SX255 +MJFR0_SX345 +MJHI0_SA2 +MJHI0_SI555 +MJHI0_SI698 +MJHI0_SX248 +MJHI0_SX338 +MJHI0_SX428 +MJHI0_SX68 +MJJB0_SA2 +MJJB0_SI1139 +MJJB0_SI1277 +MJJB0_SI1769 +MJJB0_SX149 +MJJB0_SX329 +MJJB0_SX419 +MJJB0_SX59 +MJJJ0_SA1 +MJJJ0_SA2 +MJJJ0_SI1793 +MJJJ0_SI533 +MJJJ0_SX173 +MJJJ0_SX263 +MJJJ0_SX353 +MJJJ0_SX83 +MJJM0_SA1 +MJJM0_SI1457 +MJJM0_SX17 +MJJM0_SX197 +MJJM0_SX287 +MJJM0_SX377 +MJKR0_SA2 +MJKR0_SI1201 +MJKR0_SI1831 +MJKR0_SX121 +MJKR0_SX211 +MJKR0_SX301 +MJKR0_SX31 +MJKR0_SX391 +MJLB0_SA1 +MJLB0_SA2 +MJLB0_SI2246 +MJLB0_SI986 +MJLB0_SX266 +MJLB0_SX356 +MJLB0_SX446 +MJLB0_SX86 +MJLG1_SA1 +MJLG1_SA2 +MJLG1_SI1012 +MJLG1_SI1642 +MJLG1_SI2272 +MJLG1_SX112 +MJLG1_SX202 +MJLG1_SX22 +MJLG1_SX382 +MJLS0_SA1 +MJLS0_SA2 +MJLS0_SI1096 +MJLS0_SI466 +MJLS0_SX16 +MJLS0_SX196 +MJLS0_SX286 +MJLS0_SX376 +MJMA0_SI1495 +MJMA0_SI865 +MJMA0_SX145 +MJMA0_SX235 +MJMA0_SX325 +MJMA0_SX415 +MJMA0_SX55 +MJMD0_SA1 +MJMD0_SI1028 +MJMD0_SI1658 +MJMD0_SX128 +MJMD0_SX218 +MJMD0_SX398 +MJMM0_SA1 +MJMM0_SA2 +MJMM0_SI1885 +MJMM0_SI625 +MJMM0_SX265 +MJMM0_SX355 +MJMM0_SX445 +MJPG0_SA1 +MJPG0_SA2 +MJPG0_SI561 +MJPG0_SX291 +MJPG0_SX381 +MJPM0_SA1 +MJPM0_SI1998 +MJPM0_SI738 +MJPM0_SX108 +MJPM0_SX18 +MJPM0_SX198 +MJPM0_SX288 +MJPM1_SA1 +MJPM1_SA2 +MJPM1_SI1897 +MJPM1_SI761 +MJPM1_SX131 +MJPM1_SX221 +MJPM1_SX41 +MJRA0_SI606 +MJRA0_SX156 +MJRA0_SX246 +MJRA0_SX66 +MJRG0_SA1 +MJRG0_SA2 +MJRG0_SX106 +MJRG0_SX16 +MJRG0_SX286 +MJRH0_SA1 +MJRH0_SA2 +MJRH0_SI1125 +MJRH0_SI1755 +MJRH0_SX135 +MJRH0_SX315 +MJRH0_SX405 +MJRH0_SX45 +MJRH1_SA2 +MJRH1_SI1774 +MJRH1_SX334 +MJRH1_SX64 +MJRK0_SI2103 +MJRK0_SX340 +MJRK0_SX70 +MJRP0_SI1835 +MJRP0_SI585 +MJRP0_SX135 +MJRP0_SX315 +MJRP0_SX405 +MJRP0_SX45 +MJSR0_SA2 +MJSR0_SX164 +MJSR0_SX254 +MJSR0_SX434 +MJSR0_SX74 +MJWG0_SA2 +MJWG0_SI2155 +MJWG0_SX355 +MJWG0_SX445 +MJWG0_SX85 +MJWS0_SA1 +MJWS0_SA2 +MJWS0_SI1143 +MJWS0_SI1773 +MJWS0_SX243 +MJWS0_SX423 +MJWT0_SA2 +MJWT0_SI751 +MJXA0_SA1 +MJXA0_SA2 +MJXA0_SI1507 +MJXA0_SI2137 +MJXA0_SI877 +MJXA0_SX157 +MJXA0_SX247 +MJXA0_SX337 +MJXA0_SX67 +MJXL0_SA1 +MJXL0_SA2 +MJXL0_SI1795 +MJXL0_SX182 +MJXL0_SX272 +MJXL0_SX362 +MJXL0_SX452 +MJXL0_SX92 +MKAG0_SA2 +MKAG0_SI1609 +MKAG0_SI2239 +MKAG0_SX169 +MKAG0_SX30 +MKAG0_SX439 +MKAG0_SX79 +MKAH0_SA1 +MKAH0_SA2 +MKAH0_SI1528 +MKAH0_SI2158 +MKAH0_SI898 +MKAH0_SX268 +MKAH0_SX358 +MKAH0_SX448 +MKAH0_SX88 +MKAJ0_SA1 +MKAJ0_SI1414 +MKAJ0_SI2044 +MKAJ0_SI784 +MKAJ0_SX244 +MKAJ0_SX334 +MKAJ0_SX424 +MKAJ0_SX64 +MKAM0_SA2 +MKAM0_SI1316 +MKAM0_SX236 +MKAM0_SX416 +MKDB0_SI2132 +MKDB0_SI588 +MKDB0_SI872 +MKDB0_SX242 +MKDB0_SX332 +MKDB0_SX422 +MKDB0_SX62 +MKDD0_SA1 +MKDD0_SX127 +MKDD0_SX217 +MKDD0_SX307 +MKDD0_SX37 +MKDD0_SX397 +MKDT0_SA1 +MKDT0_SA2 +MKDT0_SI2153 +MKDT0_SI893 +MKDT0_SX173 +MKDT0_SX263 +MKDT0_SX353 +MKDT0_SX443 +MKDT0_SX83 +MKES0_SA2 +MKES0_SX263 +MKES0_SX353 +MKES0_SX443 +MKES0_SX83 +MKJO0_SA1 +MKJO0_SA2 +MKJO0_SI2147 +MKJO0_SX167 +MKJO0_SX257 +MKJO0_SX424 +MKJO0_SX77 +MKLN0_SA1 +MKLN0_SA2 +MKLN0_SI1598 +MKLN0_SI2228 +MKLN0_SX158 +MKLN0_SX338 +MKLN0_SX428 +MKLN0_SX68 +MKLR0_SA1 +MKLR0_SI1059 +MKLR0_SI2319 +MKLR0_SX159 +MKLR0_SX249 +MKLR0_SX339 +MKLR0_SX429 +MKLR0_SX69 +MKLS0_SA2 +MKLS0_SI1533 +MKLS0_SX177 +MKLS0_SX267 +MKLS0_SX447 +MKLS1_SI1545 +MKLS1_SI2175 +MKLS1_SX105 +MKLS1_SX15 +MKLS1_SX195 +MKLS1_SX285 +MKLW0_SA2 +MKLW0_SI1844 +MKLW0_SI2201 +MKLW0_SX131 +MKLW0_SX221 +MKLW0_SX401 +MKLW0_SX41 +MKRG0_SA1 +MKRG0_SA2 +MKRG0_SI1491 +MKRG0_SI2121 +MKRG0_SX141 +MKRG0_SX231 +MKRG0_SX31 +MKRG0_SX51 +MKXL0_SA1 +MKXL0_SI1185 +MKXL0_SX105 +MKXL0_SX195 +MKXL0_SX285 +MLBC0_SA2 +MLBC0_SI609 +MLBC0_SX159 +MLBC0_SX339 +MLBC0_SX429 +MLBC0_SX69 +MLEL0_SI1876 +MLEL0_SX346 +MLEL0_SX76 +MLJC0_SA1 +MLJC0_SA2 +MLJC0_SI1855 +MLJC0_SI595 +MLJC0_SX235 +MLJC0_SX325 +MLJC0_SX55 +MLJH0_SI1324 +MLJH0_SX154 +MLJH0_SX334 +MLJH0_SX424 +MLNS0_SA1 +MLNS0_SA2 +MLNS0_SI1407 +MLNS0_SI777 +MLNS0_SX147 +MLNS0_SX237 +MLNS0_SX327 +MLNS0_SX417 +MLNS0_SX57 +MLSH0_SA1 +MLSH0_SA2 +MLSH0_SI2047 +MLSH0_SI787 +MLSH0_SX157 +MLSH0_SX337 +MLSH0_SX427 +MLSH0_SX67 +MMAA0_SI2105 +MMAA0_SX125 +MMAA0_SX215 +MMAA0_SX305 +MMAA0_SX395 +MMAB1_SA1 +MMAB1_SA2 +MMAB1_SI2124 +MMAB1_SX144 +MMAB1_SX414 +MMAB1_SX54 +MMAG0_SI496 +MMAG0_SX226 +MMAG0_SX406 +MMAG0_SX46 +MMAM0_SA1 +MMAM0_SA2 +MMAM0_SI1597 +MMAM0_SI1668 +MMAM0_SX247 +MMAM0_SX337 +MMAM0_SX67 +MMAR0_SA1 +MMAR0_SA2 +MMAR0_SI1336 +MMAR0_SI706 +MMAR0_SX436 +MMAR0_SX76 +MMBS0_SA1 +MMBS0_SA2 +MMBS0_SI1151 +MMBS0_SX251 +MMBS0_SX341 +MMBS0_SX431 +MMBS0_SX71 +MMCC0_SA1 +MMCC0_SI1968 +MMCC0_SI708 +MMCC0_SX168 +MMCC0_SX258 +MMCC0_SX348 +MMCC0_SX438 +MMCC0_SX78 +MMDB0_SA1 +MMDB0_SA2 +MMDB0_SI1358 +MMDB0_SI1617 +MMDB0_SX267 +MMDB0_SX357 +MMDB0_SX447 +MMDB0_SX87 +MMDG0_SI2035 +MMDG0_SX340 +MMDG0_SX430 +MMDG0_SX70 +MMDM0_SA1 +MMDM0_SA2 +MMDM0_SX231 +MMDM0_SX321 +MMDM0_SX411 +MMDM0_SX51 +MMDM1_SA1 +MMDM1_SI1650 +MMDM1_SI783 +MMDM1_SX243 +MMDS0_SA2 +MMDS0_SI1343 +MMDS0_SI1973 +MMDS0_SI713 +MMDS0_SX173 +MMDS0_SX263 +MMDS0_SX353 +MMDS0_SX443 +MMDS0_SX83 +MMEA0_SA2 +MMEA0_SI1388 +MMEA0_SI2018 +MMEA0_SI758 +MMEA0_SX218 +MMEA0_SX308 +MMEA0_SX38 +MMEB0_SA1 +MMEB0_SI1357 +MMEB0_SI1987 +MMEB0_SI727 +MMEB0_SX7 +MMEB0_SX97 +MMGC0_SA1 +MMGC0_SI1935 +MMGC0_SI2184 +MMGC0_SX315 +MMGC0_SX405 +MMGC0_SX45 +MMGG0_SA1 +MMGG0_SA2 +MMGG0_SI1709 +MMGG0_SI2339 +MMGG0_SX179 +MMGG0_SX359 +MMGG0_SX89 +MMGK0_SA1 +MMGK0_SA2 +MMGK0_SI1322 +MMGK0_SI1952 +MMGK0_SI692 +MMGK0_SX152 +MMGK0_SX242 +MMGK0_SX422 +MMJB1_SA1 +MMJB1_SI1408 +MMJB1_SI2038 +MMJB1_SI778 +MMJB1_SX148 +MMJB1_SX238 +MMJB1_SX328 +MMJB1_SX418 +MMJB1_SX58 +MMLM0_SA1 +MMLM0_SA2 +MMLM0_SI1527 +MMLM0_SI897 +MMLM0_SX177 +MMLM0_SX267 +MMLM0_SX357 +MMLM0_SX447 +MMLM0_SX87 +MMPM0_SA1 +MMPM0_SA2 +MMPM0_SI1061 +MMPM0_SI1691 +MMPM0_SI2321 +MMPM0_SX251 +MMPM0_SX341 +MMPM0_SX431 +MMPM0_SX71 +MMRP0_SA1 +MMRP0_SI2034 +MMRP0_SI717 +MMRP0_SI774 +MMRP0_SX234 +MMRP0_SX414 +MMRP0_SX54 +MMSM0_SA1 +MMSM0_SA2 +MMSM0_SI1736 +MMSM0_SX26 +MMSM0_SX296 +MMSM0_SX386 +MMVP0_SI1284 +MMVP0_SI1914 +MMVP0_SX114 +MMVP0_SX204 +MMVP0_SX294 +MMVP0_SX384 +MMWB0_SA2 +MMWB0_SI1619 +MMWB0_SX179 +MMWB0_SX269 +MMWS0_SA1 +MMWS0_SI1518 +MMWS0_SI559 +MMWS0_SI888 +MMWS0_SX258 +MMWS0_SX78 +MMWS1_SA1 +MMWS1_SA2 +MMWS1_SI1071 +MMWS1_SI2331 +MMWS1_SX261 +MMWS1_SX27 +MMWS1_SX351 +MMWS1_SX441 +MMWS1_SX81 +MMXS0_SA1 +MMXS0_SA2 +MMXS0_SI629 +MMXS0_SI876 +MMXS0_SX156 +MMXS0_SX336 +MMXS0_SX66 +MNET0_SA1 +MNET0_SA2 +MNET0_SI1446 +MNET0_SI2076 +MNET0_SX186 +MNET0_SX276 +MNET0_SX366 +MNET0_SX96 +MNTW0_SA1 +MNTW0_SI2328 +MNTW0_SX202 +MNTW0_SX258 +MNTW0_SX348 +MPAR0_SA1 +MPAR0_SA2 +MPAR0_SI1576 +MPAR0_SX226 +MPAR0_SX406 +MPAR0_SX46 +MPEB0_SA1 +MPEB0_SA2 +MPEB0_SX150 +MPEB0_SX420 +MPEB0_SX60 +MPFU0_SA1 +MPFU0_SA2 +MPFU0_SI1888 +MPFU0_SX178 +MPFU0_SX268 +MPFU0_SX358 +MPFU0_SX88 +MPGH0_SA1 +MPGH0_SA2 +MPGH0_SI1554 +MPGH0_SI924 +MPGH0_SX204 +MPGH0_SX294 +MPGH0_SX384 +MPGR0_SA1 +MPGR0_SA2 +MPGR0_SI2040 +MPGR0_SI780 +MPGR0_SX150 +MPGR0_SX420 +MPGR0_SX60 +MPGR1_SA1 +MPGR1_SA2 +MPGR1_SI1269 +MPGR1_SI2129 +MPGR1_SX239 +MPGR1_SX329 +MPGR1_SX419 +MPGR1_SX59 +MPMB0_SX241 +MPPC0_SA2 +MPPC0_SI2042 +MPPC0_SI782 +MPPC0_SX152 +MPPC0_SX242 +MPPC0_SX332 +MPPC0_SX422 +MPPC0_SX62 +MPRB0_SA1 +MPRB0_SA2 +MPRB0_SI1205 +MPRB0_SX125 +MPRB0_SX215 +MPRB0_SX305 +MPRB0_SX35 +MPRB0_SX395 +MPRD0_SA2 +MPRD0_SI1431 +MPRD0_SI2061 +MPRK0_SA2 +MPRK0_SX17 +MPRK0_SX197 +MPRT0_SA2 +MPRT0_SI1210 +MPRT0_SI495 +MPRT0_SI580 +MPRT0_SX130 +MPRT0_SX220 +MPRT0_SX40 +MPRT0_SX400 +MPSW0_SA1 +MPSW0_SA2 +MPSW0_SI1697 +MPSW0_SI2327 +MPSW0_SX24 +MPSW0_SX257 +MPSW0_SX77 +MRAB0_SA1 +MRAB0_SA2 +MRAB0_SI1224 +MRAB0_SI594 +MRAB0_SX144 +MRAB0_SX234 +MRAB0_SX324 +MRAB0_SX414 +MRAB0_SX54 +MRAB1_SA1 +MRAB1_SA2 +MRAB1_SI1478 +MRAB1_SI2108 +MRAB1_SX218 +MRAB1_SX38 +MRAB1_SX398 +MRAI0_SI1954 +MRAI0_SX162 +MRAI0_SX252 +MRAI0_SX342 +MRAM0_SI1275 +MRAM0_SI1905 +MRAM0_SX105 +MRAM0_SX195 +MRAM0_SX285 +MRAM0_SX375 +MRAV0_SA1 +MRAV0_SA2 +MRAV0_SI1008 +MRAV0_SI1638 +MRAV0_SI2268 +MRAV0_SX108 +MRAV0_SX18 +MRAV0_SX198 +MRAV0_SX288 +MRAV0_SX378 +MRBC0_SA1 +MRBC0_SA2 +MRBC0_SI1665 +MRBC0_SI599 +MRBC0_SX149 +MRBC0_SX239 +MRBC0_SX59 +MRCG0_SA1 +MRCG0_SI2058 +MRCG0_SX258 +MRCG0_SX78 +MRCW0_SA2 +MRCW0_SI1371 +MRCW0_SI2001 +MRCW0_SX111 +MRCW0_SX201 +MRCW0_SX21 +MRCW0_SX381 +MRDD0_SA1 +MRDD0_SA2 +MRDD0_SI1050 +MRDD0_SI2310 +MRDD0_SX240 +MRDD0_SX330 +MRDM0_SA1 +MRDM0_SA2 +MRDM0_SI965 +MRDM0_SX155 +MRDM0_SX245 +MRDM0_SX425 +MRDS0_SA2 +MRDS0_SI1167 +MRDS0_SI1797 +MRDS0_SI537 +MRDS0_SX177 +MRDS0_SX267 +MRDS0_SX357 +MRDS0_SX447 +MRDS0_SX87 +MREE0_SA1 +MREE0_SA2 +MREE0_SI1734 +MREE0_SX114 +MREE0_SX204 +MREE0_SX294 +MREE0_SX384 +MREH1_SA2 +MREH1_SI2229 +MREH1_SX159 +MREH1_SX339 +MREH1_SX429 +MREM0_SA1 +MREM0_SI1591 +MREM0_SI961 +MREM0_SX151 +MREM0_SX241 +MREM0_SX331 +MREM0_SX421 +MREM0_SX61 +MREW1_SA1 +MREW1_SA2 +MREW1_SI1500 +MREW1_SI2130 +MREW1_SX150 +MREW1_SX240 +MREW1_SX330 +MREW1_SX420 +MREW1_SX60 +MRFK0_SA1 +MRFK0_SA2 +MRFK0_SI1706 +MRFK0_SI2336 +MRFK0_SX176 +MRFK0_SX266 +MRFK0_SX356 +MRFK0_SX86 +MRFL0_SA2 +MRFL0_SI1786 +MRFL0_SX346 +MRGM0_SA1 +MRGM0_SI1162 +MRGM0_SI1792 +MRGM0_SX416 +MRGM0_SX82 +MRGS0_SA1 +MRGS0_SI1986 +MRGS0_SX276 +MRGS0_SX366 +MRGS0_SX96 +MRHL0_SA1 +MRHL0_SA2 +MRHL0_SI1515 +MRHL0_SI2145 +MRHL0_SX165 +MRHL0_SX255 +MRHL0_SX75 +MRJB1_SI1020 +MRJB1_SX300 +MRJH0_SA1 +MRJH0_SI914 +MRJH0_SX259 +MRJH0_SX439 +MRJM0_SA1 +MRJM0_SA2 +MRJM0_SI1095 +MRJM0_SI1228 +MRJM0_SI1858 +MRJM0_SX238 +MRJM0_SX328 +MRJM0_SX418 +MRJM0_SX58 +MRJM1_SA1 +MRJM1_SI668 +MRJM1_SX218 +MRJM1_SX308 +MRJM1_SX38 +MRJM1_SX398 +MRJT0_SA1 +MRJT0_SI1805 +MRJT0_SX148 +MRJT0_SX238 +MRKM0_SA1 +MRKM0_SX187 +MRKM0_SX277 +MRKM0_SX7 +MRKM0_SX97 +MRLD0_SA1 +MRLD0_SI1594 +MRLD0_SI964 +MRLD0_SX244 +MRLD0_SX334 +MRLD0_SX64 +MRLJ0_SA2 +MRLJ0_SI1420 +MRLJ0_SI2050 +MRLJ0_SX160 +MRLJ0_SX430 +MRLJ0_SX70 +MRLJ1_SI1671 +MRLJ1_SI2332 +MRLJ1_SX141 +MRLJ1_SX231 +MRLJ1_SX411 +MRLJ1_SX51 +MRLK0_SA1 +MRLK0_SA2 +MRLK0_SI2140 +MRLK0_SX303 +MRLK0_SX33 +MRLK0_SX393 +MRLR0_SA1 +MRLR0_SA2 +MRLR0_SI1826 +MRLR0_SI566 +MRLR0_SX116 +MRLR0_SX206 +MRLR0_SX26 +MRLR0_SX296 +MRLR0_SX386 +MRMB0_SA1 +MRMB0_SI2211 +MRMB0_SI951 +MRMB0_SX141 +MRMB0_SX231 +MRMB0_SX321 +MRMB0_SX51 +MRMG0_SA2 +MRMG0_SI1710 +MRMG0_SI2340 +MRMG0_SX180 +MRMG0_SX270 +MRMG0_SX360 +MRMG0_SX90 +MRMH0_SA1 +MRMH0_SA2 +MRMH0_SI1021 +MRMH0_SX211 +MRMH0_SX301 +MRMH0_SX31 +MRMH0_SX391 +MRML0_SI2051 +MRML0_SI791 +MRML0_SX431 +MRML0_SX71 +MRMS0_SA1 +MRMS0_SA2 +MRMS0_SI1113 +MRMS0_SI2100 +MRMS0_SX120 +MRMS0_SX210 +MRMS0_SX30 +MRMS0_SX300 +MRMS0_SX390 +MRPC1_SA1 +MRPC1_SA2 +MRPC1_SI1482 +MRPC1_SI2026 +MRPC1_SX132 +MRPC1_SX222 +MRPC1_SX312 +MRPC1_SX402 +MRPC1_SX42 +MRRE0_SI704 +MRRE0_SX254 +MRRE0_SX434 +MRSO0_SA1 +MRSO0_SA2 +MRSO0_SI1659 +MRSO0_SI2289 +MRSO0_SX219 +MRSO0_SX309 +MRSO0_SX399 +MRSP0_SA1 +MRSP0_SA2 +MRSP0_SI2059 +MRSP0_SI799 +MRSP0_SX169 +MRSP0_SX196 +MRSP0_SX439 +MRSP0_SX79 +MRTC0_SA1 +MRTC0_SA2 +MRTC0_SI2088 +MRTC0_SI828 +MRTC0_SX108 +MRTC0_SX18 +MRTC0_SX198 +MRTC0_SX288 +MRTJ0_SA2 +MRTJ0_SI1551 +MRTJ0_SI2032 +MRTJ0_SX322 +MRTJ0_SX412 +MRVG0_SA1 +MRVG0_SA2 +MRVG0_SI1770 +MRVG0_SI510 +MRVG0_SX150 +MRVG0_SX330 +MRVG0_SX420 +MRVG0_SX60 +MRWA0_SA1 +MRWA0_SA2 +MRWA0_SI1603 +MRWA0_SI2233 +MRWA0_SX253 +MRWA0_SX343 +MRWA0_SX433 +MRWS0_SA1 +MRWS0_SA2 +MRWS0_SX112 +MRWS0_SX202 +MRWS0_SX292 +MRXB0_SA1 +MRXB0_SI1585 +MRXB0_SX145 +MRXB0_SX235 +MRXB0_SX325 +MRXB0_SX55 +MSAH1_SA1 +MSAH1_SA2 +MSAH1_SI1049 +MSAH1_SI2309 +MSAH1_SX149 +MSAH1_SX239 +MSAH1_SX329 +MSAH1_SX419 +MSAH1_SX59 +MSAS0_SA1 +MSAS0_SA2 +MSAS0_SI2006 +MSAS0_SX26 +MSAS0_SX296 +MSAT0_SA2 +MSAT0_SI1526 +MSAT0_SI2156 +MSAT0_SI896 +MSAT0_SX176 +MSAT0_SX266 +MSAT0_SX356 +MSAT0_SX446 +MSAT0_SX86 +MSAT1_SA1 +MSAT1_SA2 +MSAT1_SI1073 +MSAT1_SI1703 +MSAT1_SI2333 +MSAT1_SX173 +MSAT1_SX353 +MSDB0_SA1 +MSDB0_SA2 +MSDB0_SI1007 +MSDB0_SI1637 +MSDB0_SI2267 +MSDB0_SX107 +MSDB0_SX17 +MSDH0_SA1 +MSDH0_SA2 +MSDH0_SI2113 +MSDH0_SX260 +MSDH0_SX350 +MSDS0_SA2 +MSDS0_SI1707 +MSDS0_SI2337 +MSDS0_SX177 +MSDS0_SX447 +MSDS0_SX87 +MSEM1_SA1 +MSEM1_SA2 +MSEM1_SX360 +MSEM1_SX450 +MSEM1_SX90 +MSES0_SA1 +MSES0_SA2 +MSES0_SI2216 +MSES0_SI2219 +MSES0_SX149 +MSES0_SX329 +MSES0_SX59 +MSFH0_SA2 +MSFH0_SI1216 +MSFH0_SI586 +MSFH0_SX226 +MSFH0_SX46 +MSFV0_SA1 +MSFV0_SA2 +MSFV0_SI1262 +MSFV0_SX182 +MSFV0_SX272 +MSFV0_SX452 +MSJK0_SA1 +MSJK0_SA2 +MSJK0_SI2226 +MSJK0_SI966 +MSJK0_SX156 +MSJK0_SX246 +MSJK0_SX426 +MSJK0_SX66 +MSMC0_SA1 +MSMC0_SA2 +MSMC0_SI1907 +MSMC0_SI647 +MSMC0_SX107 +MSMC0_SX17 +MSMC0_SX197 +MSMC0_SX287 +MSMC0_SX377 +MSMR0_SA1 +MSMR0_SA2 +MSMR0_SI1405 +MSMR0_SI775 +MSMR0_SX145 +MSMR0_SX235 +MSMR0_SX325 +MSMR0_SX55 +MSMS0_SA2 +MSMS0_SI2063 +MSMS0_SI803 +MSMS0_SX263 +MSMS0_SX353 +MSMS0_SX443 +MSRG0_SA2 +MSRG0_SI1851 +MSRG0_SI591 +MSRG0_SX141 +MSRG0_SX231 +MSRG0_SX321 +MSRG0_SX411 +MSRG0_SX51 +MSRR0_SA1 +MSRR0_SA2 +MSRR0_SI1131 +MSRR0_SX141 +MSRR0_SX231 +MSRR0_SX30 +MSRR0_SX411 +MSRR0_SX51 +MSTF0_SA1 +MSTF0_SA2 +MSTF0_SI1396 +MSTF0_SX136 +MSTF0_SX226 +MSTF0_SX406 +MSVS0_SA1 +MSVS0_SI1568 +MSVS0_SX128 +MSVS0_SX218 +MSVS0_SX38 +MTAB0_SA1 +MTAB0_SA2 +MTAB0_SI2202 +MTAB0_SI942 +MTAB0_SX132 +MTAB0_SX222 +MTAB0_SX402 +MTAB0_SX42 +MTAS0_SA1 +MTAS0_SA2 +MTAS0_SI1385 +MTAS0_SI2015 +MTAS0_SI755 +MTAS0_SX125 +MTAS0_SX305 +MTAT0_SA2 +MTAT0_SI1740 +MTAT0_SX120 +MTAT0_SX210 +MTAT0_SX30 +MTAT0_SX300 +MTAT1_SA1 +MTAT1_SA2 +MTAT1_SI1409 +MTAT1_SI1627 +MTAT1_SX239 +MTAT1_SX419 +MTBC0_SA1 +MTBC0_SA2 +MTBC0_SI1173 +MTBC0_SX183 +MTBC0_SX273 +MTBC0_SX347 +MTBC0_SX363 +MTBC0_SX93 +MTCS0_SA1 +MTCS0_SI1972 +MTCS0_SX172 +MTCS0_SX262 +MTCS0_SX352 +MTCS0_SX442 +MTDB0_SA1 +MTDB0_SA2 +MTDB0_SI2031 +MTDB0_SX141 +MTDB0_SX231 +MTDB0_SX321 +MTDB0_SX411 +MTDB0_SX51 +MTDP0_SI1274 +MTDP0_SI2151 +MTDP0_SX261 +MTDP0_SX441 +MTDP0_SX81 +MTER0_SI527 +MTER0_SX167 +MTER0_SX17 +MTER0_SX257 +MTER0_SX77 +MTJG0_SA2 +MTJG0_SI1520 +MTJG0_SI890 +MTJG0_SX350 +MTJG0_SX440 +MTJG0_SX80 +MTJM0_SA1 +MTJM0_SA2 +MTJM0_SI1226 +MTJM0_SI655 +MTJM0_SX236 +MTJM0_SX326 +MTJM0_SX416 +MTJM0_SX56 +MTJS0_SA1 +MTJS0_SI1192 +MTJS0_SX112 +MTJS0_SX202 +MTJS0_SX22 +MTJS0_SX292 +MTJU0_SA1 +MTJU0_SA2 +MTJU0_SI2269 +MTJU0_SI760 +MTJU0_SX220 +MTJU0_SX310 +MTJU0_SX40 +MTKD0_SA1 +MTKD0_SA2 +MTKD0_SI1187 +MTKD0_SI1817 +MTKD0_SX17 +MTKD0_SX197 +MTKD0_SX377 +MTKP0_SA1 +MTKP0_SA2 +MTKP0_SX123 +MTKP0_SX213 +MTKP0_SX303 +MTKP0_SX33 +MTKP0_SX393 +MTLB0_SA2 +MTLB0_SI1764 +MTLB0_SI504 +MTLB0_SX144 +MTLB0_SX414 +MTLB0_SX54 +MTLC0_SA2 +MTLC0_SI847 +MTLC0_SX127 +MTLC0_SX217 +MTLC0_SX307 +MTLC0_SX37 +MTLC0_SX397 +MTML0_SA1 +MTML0_SA2 +MTML0_SI1065 +MTML0_SI1695 +MTML0_SX255 +MTML0_SX345 +MTML0_SX75 +MTMN0_SA1 +MTMN0_SX164 +MTMN0_SX254 +MTMN0_SX344 +MTMN0_SX74 +MTMT0_SA1 +MTMT0_SI1118 +MTMT0_SX128 +MTMT0_SX218 +MTMT0_SX308 +MTMT0_SX38 +MTMT0_SX398 +MTPF0_SA1 +MTPF0_SA2 +MTPF0_SI1235 +MTPF0_SI1865 +MTPF0_SI605 +MTPF0_SX155 +MTPF0_SX245 +MTPF0_SX335 +MTPF0_SX425 +MTPG0_SA1 +MTPG0_SA2 +MTPG0_SI2013 +MTPG0_SX123 +MTPG0_SX213 +MTPG0_SX33 +MTPG0_SX393 +MTPP0_SA1 +MTPP0_SA2 +MTPP0_SI2138 +MTPP0_SI878 +MTPP0_SX158 +MTPP0_SX248 +MTPP0_SX428 +MTPP0_SX68 +MTPR0_SA1 +MTPR0_SA2 +MTPR0_SI1600 +MTPR0_SI506 +MTPR0_SX250 +MTPR0_SX70 +MTQC0_SA2 +MTQC0_SI2071 +MTQC0_SX271 +MTQC0_SX361 +MTRC0_SA1 +MTRC0_SA2 +MTRC0_SI1623 +MTRC0_SI993 +MTRC0_SX170 +MTRC0_SX183 +MTRC0_SX273 +MTRC0_SX363 +MTRC0_SX93 +MTRR0_SA1 +MTRR0_SA2 +MTRR0_SI1548 +MTRR0_SI2178 +MTRR0_SX108 +MTRR0_SX18 +MTRR0_SX378 +MTRT0_SA1 +MTRT0_SI1857 +MTRT0_SI597 +MTRT0_SX147 +MTRT0_SX237 +MTRT0_SX417 +MTWH1_SA1 +MTWH1_SA2 +MTWH1_SI1512 +MTWH1_SI2142 +MTWH1_SI882 +MTWH1_SX162 +MTWH1_SX252 +MTWH1_SX342 +MTWH1_SX432 +MTXS0_SI1690 +MTXS0_SX250 +MTXS0_SX340 +MTXS0_SX70 +MVJH0_SA1 +MVJH0_SA2 +MVJH0_SI2186 +MVJH0_SX116 +MVJH0_SX26 +MVJH0_SX386 +MVLO0_SA2 +MVLO0_SI1147 +MVLO0_SI1777 +MVLO0_SX157 +MVLO0_SX247 +MVLO0_SX337 +MVLO0_SX427 +MVLO0_SX67 +MVRW0_SA1 +MVRW0_SI1485 +MVRW0_SI2115 +MVRW0_SI855 +MVRW0_SX315 +MVRW0_SX405 +MVRW0_SX45 +MWAC0_SA1 +MWAC0_SI2231 +MWAC0_SI971 +MWAC0_SX71 +MWAD0_SA1 +MWAD0_SA2 +MWAD0_SI1062 +MWAD0_SI1749 +MWAD0_SI2322 +MWAD0_SX162 +MWAD0_SX252 +MWAD0_SX342 +MWAR0_SA2 +MWAR0_SI2305 +MWAR0_SX145 +MWAR0_SX235 +MWAR0_SX325 +MWAR0_SX415 +MWAR0_SX55 +MWCH0_SA1 +MWCH0_SA2 +MWCH0_SI1622 +MWCH0_SX272 +MWCH0_SX362 +MWCH0_SX92 +MWDK0_SX266 +MWDK0_SX356 +MWDK0_SX446 +MWEM0_SA1 +MWEM0_SI1950 +MWEM0_SX240 +MWEM0_SX330 +MWEM0_SX60 +MWGR0_SA1 +MWGR0_SA2 +MWGR0_SI1606 +MWGR0_SI2236 +MWGR0_SI976 +MWGR0_SX166 +MWGR0_SX256 +MWGR0_SX436 +MWGR0_SX76 +MWRE0_SA1 +MWRE0_SI1687 +MWRE0_SI2317 +MWRE0_SX157 +MWRP0_SA2 +MWRP0_SI1525 +MWRP0_SI2073 +MWRP0_SX183 +MWRP0_SX3 +MWRP0_SX93 +MWSB0_SA1 +MWSB0_SA2 +MWSB0_SI1626 +MWSB0_SI2256 +MWSB0_SX186 +MWSB0_SX366 +MWSB0_SX6 +MWSB0_SX96 +MWSH0_SA1 +MWSH0_SA2 +MWSH0_SI2266 +MWSH0_SX346 +MWSH0_SX436 +MZMB0_SA2 +MZMB0_SI1166 +MZMB0_SI1796 +MZMB0_SI536 +MZMB0_SX176 +MZMB0_SX266 +MZMB0_SX356 +MZMB0_SX446 +MZMB0_SX86 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train_text.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train_text.uid new file mode 100644 index 0000000000000000000000000000000000000000..0e0c2517c9415ce76d5863781f621402cd15b911 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/train_text.uid @@ -0,0 +1,1000 @@ +FAEM0_SI762 +FAEM0_SX42 +FAJW0_SA1 +FAJW0_SX3 +FAJW0_SX93 +FALK0_SX186 +FALK0_SX6 +FALR0_SI1325 +FBAS0_SA1 +FBAS0_SX217 +FBCG1_SA1 +FBCG1_SX172 +FBCG1_SX442 +FBCH0_SX236 +FBCH0_SX416 +FBLV0_SA1 +FBLV0_SI1058 +FBLV0_SX338 +FBLV0_SX68 +FBMH0_SA1 +FBMJ0_SI815 +FCAG0_SA1 +FCAG0_SX153 +FCAG0_SX243 +FCAJ0_SI1479 +FCAJ0_SX309 +FCDR1_SX106 +FCDR1_SX196 +FCEG0_SA2 +FCJF0_SA1 +FCJF0_SX127 +FCJS0_SI1607 +FCJS0_SI2237 +FCJS0_SX257 +FCKE0_SA2 +FCKE0_SX121 +FCLT0_SI2068 +FCLT0_SX448 +FCLT0_SX88 +FCMG0_SA2 +FCMG0_SI1872 +FCMG0_SX72 +FCMM0_SA1 +FCMM0_SA2 +FCMM0_SX183 +FCRZ0_SI2053 +FCRZ0_SX433 +FCYL0_SA1 +FCYL0_SX37 +FDAS1_SI2091 +FDAS1_SX201 +FDAS1_SX381 +FDAW0_SI1406 +FDFB0_SA1 +FDFB0_SA2 +FDFB0_SI2010 +FDFB0_SX58 +FDJH0_SX305 +FDML0_SA2 +FDML0_SX159 +FDML0_SX249 +FDML0_SX429 +FDMY0_SA2 +FDMY0_SX27 +FDNC0_SX198 +FDNC0_SX288 +FDTD0_SX211 +FDXW0_SA1 +FDXW0_SX251 +FDXW0_SX341 +FDXW0_SX71 +FEAC0_SX165 +FEAC0_SX75 +FEAR0_SI622 +FECD0_SX68 +FEEH0_SA1 +FEEH0_SI1742 +FEEH0_SI471 +FEEH0_SX122 +FEME0_SA1 +FEME0_SX155 +FEME0_SX65 +FETB0_SA1 +FETB0_SI1148 +FETB0_SX158 +FEXM0_SI1101 +FGCS0_SX136 +FGCS0_SX226 +FGCS0_SX316 +FGCS0_SX406 +FGDP0_SA1 +FGMB0_SI1775 +FGMB0_SX245 +FHLM0_SX390 +FHXS0_SA2 +FHXS0_SX445 +FJDM2_SA1 +FJDM2_SX232 +FJDM2_SX52 +FJHK0_SX302 +FJKL0_SX212 +FJKL0_SX392 +FJLG0_SI2306 +FJLR0_SA1 +FJRP1_SI2062 +FJRP1_SX82 +FJSK0_SA1 +FJSP0_SX264 +FJSP0_SX354 +FJSP0_SX444 +FJWB1_SA1 +FJWB1_SX345 +FJWB1_SX435 +FJXM0_SA1 +FJXM0_SI581 +FJXM0_SX401 +FJXP0_SA1 +FJXP0_SI1122 +FJXP0_SX132 +FKAA0_SX128 +FKAA0_SX398 +FKDE0_SA1 +FKDE0_SX151 +FKDE0_SX241 +FKDE0_SX421 +FKDE0_SX61 +FKDW0_SX397 +FKFB0_SA2 +FKFB0_SX348 +FKFB0_SX78 +FKKH0_SA1 +FKKH0_SA2 +FKKH0_SX120 +FKKH0_SX390 +FKLC0_SX355 +FKLC1_SI2308 +FKLC1_SX238 +FKLC1_SX328 +FKLC1_SX418 +FKLH0_SA2 +FKLH0_SX177 +FKSR0_SA1 +FKSR0_SA2 +FKSR0_SI1747 +FKSR0_SI487 +FKSR0_SX217 +FLAC0_SX451 +FLAG0_SA2 +FLAG0_SX114 +FLAG0_SX204 +FLAG0_SX24 +FLAG0_SX384 +FLEH0_SI1681 +FLEH0_SI2311 +FLEH0_SX331 +FLET0_SA1 +FLHD0_SI1827 +FLHD0_SX354 +FLJA0_SA1 +FLJA0_SI2338 +FLJD0_SI886 +FLJD0_SX76 +FLJG0_SA2 +FLKM0_SA2 +FLKM0_SI686 +FLKM0_SX260 +FLKM0_SX80 +FLMA0_SA1 +FLMA0_SI613 +FLMA0_SX433 +FLMA0_SX73 +FLMC0_SX22 +FLMK0_SI1035 +FLMK0_SX315 +FLMK0_SX405 +FLOD0_SI1917 +FLOD0_SX117 +FLOD0_SX171 +FLOD0_SX297 +FLTM0_SA1 +FLTM0_SI1070 +FLTM0_SI2330 +FMAH1_SA2 +FMAH1_SX159 +FMBG0_SA2 +FMBG0_SI2264 +FMEM0_SI747 +FMEM0_SX387 +FMJB0_SI547 +FMJB0_SX97 +FMJF0_SA2 +FMJU0_SX309 +FMJU0_SX399 +FMKC0_SI1702 +FMKC0_SX442 +FMKC0_SX82 +FMKF0_SX186 +FMPG0_SA2 +FNKL0_SI1522 +FNTB0_SI1203 +FNTB0_SI573 +FNTB0_SX303 +FPAB1_SI1471 +FPAB1_SX211 +FPAC0_SA2 +FPAD0_SA2 +FPAD0_SX356 +FPAD0_SX86 +FPAF0_SA2 +FPAF0_SX154 +FPAZ0_SA1 +FPAZ0_SA2 +FPAZ0_SX243 +FPJF0_SA1 +FPJF0_SX146 +FPJF0_SX56 +FPLS0_SI1590 +FPLS0_SX330 +FPMY0_SA1 +FPMY0_SX343 +FREH0_SA1 +FREH0_SA2 +FREH0_SX415 +FRJB0_SX347 +FRLL0_SX434 +FSAG0_SA1 +FSAG0_SX243 +FSAH0_SA1 +FSAH0_SA2 +FSAH0_SX164 +FSAH0_SX434 +FSBK0_SA2 +FSBK0_SI1069 +FSBK0_SX169 +FSCN0_SA2 +FSCN0_SI626 +FSCN0_SX266 +FSCN0_SX446 +FSCN0_SX86 +FSDC0_SA2 +FSDC0_SX142 +FSDC0_SX322 +FSDC0_SX52 +FSDJ0_SI485 +FSDJ0_SX215 +FSDJ0_SX305 +FSDJ0_SX395 +FSGF0_SX117 +FSJG0_SX130 +FSJK1_SA2 +FSJK1_SX125 +FSJK1_SX35 +FSJS0_SX181 +FSJW0_SI1963 +FSJW0_SX433 +FSKC0_SI1416 +FSKC0_SI786 +FSKC0_SX246 +FSKL0_SI1529 +FSKL0_SX449 +FSKP0_SA2 +FSLS0_SX156 +FSLS0_SX426 +FSMA0_SA2 +FSMA0_SX181 +FSMM0_SX144 +FSMM0_SX234 +FSMS1_SX244 +FSMS1_SX347 +FSPM0_SA2 +FSPM0_SX161 +FSPM0_SX71 +FSRH0_SI1931 +FSRH0_SI671 +FSRH0_SX221 +FSRH0_SX401 +FTAJ0_SI699 +FTAJ0_SX159 +FTAJ0_SX249 +FTAJ0_SX429 +FTBR0_SX21 +FTBW0_SA1 +FTMG0_SI1532 +FTMG0_SI2162 +FTMG0_SX452 +FVFB0_SA2 +FVFB0_SX132 +FVFB0_SX42 +FVKB0_SA1 +FVMH0_SA2 +FVMH0_SX116 +FVMH0_SX26 +MABC0_SI1620 +MABC0_SI2041 +MABC0_SI781 +MADC0_SX107 +MADC0_SX377 +MADD0_SA2 +MADD0_SI1295 +MADD0_SX178 +MADD0_SX268 +MADD0_SX88 +MAEB0_SX450 +MAEO0_SA1 +MAFM0_SI939 +MAFM0_SX129 +MAFM0_SX309 +MAJP0_SA2 +MAKB0_SI1646 +MAKB0_SX26 +MAKB0_SX386 +MAKR0_SX362 +MAKR0_SX92 +MAPV0_SX213 +MARC0_SA2 +MARC0_SX108 +MARC0_SX18 +MARC0_SX198 +MARW0_SI1906 +MBAR0_SA1 +MBAR0_SX419 +MBAR0_SX59 +MBBR0_SI2315 +MBBR0_SX65 +MBCG0_SA1 +MBCG0_SI486 +MBEF0_SI1281 +MBEF0_SI1911 +MBEF0_SI651 +MBEF0_SX21 +MBEF0_SX381 +MBGT0_SA2 +MBGT0_SX261 +MBGT0_SX351 +MBGT0_SX441 +MBJV0_SA1 +MBJV0_SI617 +MBJV0_SX347 +MBMA0_SI592 +MBMA0_SX232 +MBMA0_SX52 +MBMA1_SI2214 +MBMA1_SX54 +MBML0_SA2 +MBML0_SI1169 +MBML0_SX89 +MBOM0_SA2 +MBOM0_SI2274 +MBOM0_SX294 +MBSB0_SA1 +MBSB0_SX3 +MBTH0_SA2 +MBTH0_SX122 +MBTH0_SX32 +MCAE0_SX277 +MCAL0_SA2 +MCAL0_SI1768 +MCDC0_SA1 +MCDC0_SX212 +MCDD0_SA2 +MCDD0_SI883 +MCDD0_SX253 +MCDD0_SX433 +MCDR0_SI1154 +MCEF0_SX235 +MCEF0_SX415 +MCEW0_SA2 +MCHL0_SX87 +MCLK0_SX310 +MCLM0_SA1 +MCLM0_SI2086 +MCLM0_SI826 +MCPM0_SA1 +MCPM0_SX114 +MCPM0_SX294 +MCPM0_SX384 +MCSS0_SI750 +MCTH0_SA1 +MCTH0_SX39 +MCXM0_SX91 +MDAC0_SA1 +MDAC0_SX181 +MDAC0_SX361 +MDAS0_SX6 +MDBB1_SX106 +MDBB1_SX16 +MDBB1_SX376 +MDBP0_SX168 +MDCD0_SI1415 +MDCD0_SX245 +MDCD0_SX425 +MDCM0_SX40 +MDCM0_SX400 +MDDC0_SI2049 +MDDC0_SI789 +MDDC0_SX159 +MDDC0_SX69 +MDED0_SA1 +MDED0_SA2 +MDEF0_SX123 +MDEF0_SX303 +MDHL0_SI1439 +MDHL0_SX269 +MDHL0_SX449 +MDHS0_SA1 +MDHS0_SA2 +MDHS0_SI1530 +MDHS0_SI2160 +MDJM0_SX105 +MDJM0_SX15 +MDKS0_SX436 +MDLB0_SA2 +MDLC0_SX405 +MDLC1_SA2 +MDLC1_SI2065 +MDLC1_SI2144 +MDLC1_SX445 +MDLC2_SI2244 +MDLC2_SX354 +MDLH0_SA2 +MDLM0_SI1234 +MDLM0_SI1864 +MDLM0_SX154 +MDLM0_SX424 +MDLR0_SA1 +MDLR0_SA2 +MDLR0_SI1863 +MDLR0_SI603 +MDLR0_SX153 +MDLR1_SA1 +MDLR1_SA2 +MDMA0_SI1430 +MDMA0_SX260 +MDMA0_SX80 +MDMT0_SA1 +MDMT0_SA2 +MDMT0_SI1832 +MDMT0_SX122 +MDMT0_SX32 +MDNS0_SA2 +MDNS0_SI2271 +MDNS0_SX201 +MDNS0_SX21 +MDPB0_SX416 +MDPK0_SI1053 +MDPK0_SX333 +MDPK0_SX423 +MDPS0_SI719 +MDPS0_SX359 +MDRD0_SA1 +MDRD0_SX32 +MDSJ0_SI2092 +MDSS0_SA2 +MDSS0_SX441 +MDSS1_SA1 +MDSS1_SI1327 +MDSS1_SI697 +MDSS1_SX157 +MDSS1_SX67 +MDTB0_SI1200 +MDTB0_SI1830 +MDTB0_SX120 +MDWD0_SA2 +MDWD0_SX270 +MDWD0_SX90 +MDWH0_SX215 +MDWH0_SX305 +MDWM0_SA1 +MDWM0_SA2 +MDWM0_SX16 +MDWM0_SX286 +MEAL0_SA2 +MEAL0_SI2177 +MEAL0_SX107 +MEAL0_SX347 +MEDR0_SA1 +MEDR0_SA2 +MEDR0_SI1374 +MEFG0_SA1 +MEGJ0_SA2 +MEGJ0_SX257 +MEGJ0_SX3 +MEJL0_SA1 +MEJL0_SX152 +MEJL0_SX242 +MEJS0_SI610 +MEJS0_SX160 +MEJS0_SX340 +MESG0_SX432 +MESJ0_SX187 +MESJ0_SX97 +MEWM0_SI718 +MEWM0_SX178 +MEWM0_SX88 +MFER0_SI862 +MFER0_SX142 +MFRM0_SX345 +MFRM0_SX435 +MFWK0_SI1879 +MFWK0_SX169 +MFXS0_SX54 +MFXV0_SA2 +MFXV0_SX105 +MGAF0_SA1 +MGAF0_SX22 +MGAF0_SX382 +MGAG0_SA2 +MGAK0_SX226 +MGAK0_SX46 +MGAR0_SX132 +MGAW0_SI535 +MGAW0_SX175 +MGES0_SA1 +MGES0_SI2111 +MGES0_SI851 +MGJC0_SA2 +MGJC0_SX75 +MGRL0_SI2127 +MGRL0_SI867 +MGRL0_SX147 +MGRP0_SA2 +MGSH0_SA2 +MGSH0_SI1806 +MGSH0_SX127 +MGSH0_SX276 +MGSH0_SX6 +MGSL0_SA1 +MGSL0_SI534 +MGSL0_SX264 +MGXP0_SX187 +MGXP0_SX7 +MHBS0_SX315 +MHBS0_SX45 +MHIT0_SA1 +MHJB0_SA1 +MHJB0_SI1017 +MHMG0_SX195 +MHMR0_SA1 +MHMR0_SI489 +MHRM0_SA1 +MHRM0_SI958 +MHRM0_SX148 +MHRM0_SX58 +MHXL0_SI1772 +MHXL0_SX242 +MILB0_SA2 +MJAC0_SX307 +MJAC0_SX71 +MJAE0_SX174 +MJAI0_SA1 +MJAI0_SA2 +MJBG0_SX62 +MJDA0_SI1031 +MJDA0_SX311 +MJDE0_SI463 +MJDG0_SA2 +MJDG0_SI1042 +MJDG0_SI1705 +MJDM0_SA1 +MJDM0_SI974 +MJEB0_SI656 +MJEB0_SX296 +MJEB1_SA2 +MJEB1_SX207 +MJEB1_SX387 +MJEE0_SA1 +MJEE0_SX247 +MJEE0_SX337 +MJFH0_SA2 +MJFH0_SI1107 +MJFR0_SX75 +MJHI0_SA1 +MJHI0_SX158 +MJJB0_SA1 +MJJB0_SX239 +MJJJ0_SX443 +MJJM0_SA2 +MJJM0_SI827 +MJJM0_SX107 +MJKR0_SA1 +MJKR0_SI571 +MJLB0_SX176 +MJLG1_SX292 +MJLS0_SX106 +MJMA0_SA1 +MJMA0_SA2 +MJMD0_SA2 +MJMD0_SX308 +MJMD0_SX38 +MJMM0_SX85 +MJPG0_SI1191 +MJPG0_SX111 +MJPG0_SX201 +MJPG0_SX21 +MJPM0_SA2 +MJPM0_SX378 +MJPM1_SI2280 +MJPM1_SX401 +MJRA0_SA1 +MJRA0_SA2 +MJRA0_SI1236 +MJRA0_SI1866 +MJRA0_SX426 +MJRG0_SI1366 +MJRG0_SI1996 +MJRG0_SX376 +MJRH0_SX225 +MJRH1_SA1 +MJRH1_SI514 +MJRH1_SX154 +MJRH1_SX244 +MJRH1_SX424 +MJRK0_SA1 +MJRK0_SA2 +MJRK0_SI1662 +MJRK0_SX160 +MJRK0_SX250 +MJRK0_SX430 +MJRP0_SA1 +MJRP0_SA2 +MJRP0_SX225 +MJSR0_SA1 +MJSR0_SI1424 +MJSR0_SX344 +MJWG0_SA1 +MJWG0_SX265 +MJWS0_SI513 +MJWS0_SX153 +MJWS0_SX63 +MJWT0_SA1 +MJWT0_SX121 +MJWT0_SX211 +MJWT0_SX301 +MJWT0_SX31 +MJWT0_SX391 +MJXA0_SX427 +MJXL0_SI542 +MKAG0_SA1 +MKAG0_SX259 +MKAJ0_SA2 +MKAJ0_SX154 +MKAM0_SA1 +MKAM0_SX146 +MKAM0_SX326 +MKAM0_SX56 +MKDB0_SA1 +MKDB0_SA2 +MKDB0_SX152 +MKDD0_SA2 +MKES0_SA1 +MKES0_SI1253 +MKES0_SI1883 +MKES0_SX173 +MKJO0_SI1517 +MKJO0_SI887 +MKJO0_SX437 +MKLN0_SI968 +MKLN0_SX248 +MKLR0_SA2 +MKLR0_SI1689 +MKLS0_SA1 +MKLS0_SX357 +MKLS0_SX87 +MKLS1_SA1 +MKLS1_SA2 +MKLS1_SX375 +MKLW0_SA1 +MKRG0_SX411 +MKXL0_SA2 +MKXL0_SX15 +MKXL0_SX375 +MLBC0_SA1 +MLBC0_SI1869 +MLBC0_SX249 +MLEL0_SA1 +MLEL0_SA2 +MLEL0_SI1246 +MLEL0_SX256 +MLEL0_SX436 +MLJC0_SX145 +MLJC0_SX415 +MLJH0_SX64 +MLNS0_SI2037 +MMAA0_SA1 +MMAA0_SA2 +MMAA0_SX35 +MMAB1_SI1494 +MMAB1_SX234 +MMAG0_SA2 +MMAG0_SI1126 +MMAG0_SX316 +MMAM0_SI2227 +MMAM0_SX157 +MMAM0_SX427 +MMAR0_SX256 +MMBS0_SI1781 +MMCC0_SA2 +MMDB0_SX177 +MMDG0_SA1 +MMDG0_SA2 +MMDG0_SI520 +MMDG0_SX160 +MMDG0_SX250 +MMDM0_SI1941 +MMDM0_SI681 +MMDM0_SX141 +MMDM1_SA2 +MMDM1_SI2043 +MMDM1_SX423 +MMDM1_SX63 +MMDS0_SA1 +MMEA0_SA1 +MMEA0_SX128 +MMEA0_SX398 +MMEB0_SA2 +MMEB0_SX187 +MMEB0_SX367 +MMGC0_SA2 +MMGC0_SX135 +MMGC0_SX225 +MMGG0_SX269 +MMGK0_SX332 +MMGK0_SX62 +MMJB1_SA2 +MMRP0_SA2 +MMRP0_SX144 +MMSM0_SX116 +MMSM0_SX206 +MMVP0_SA1 +MMVP0_SA2 +MMWB0_SI989 +MMWB0_SX89 +MMWS0_SA2 +MMWS0_SX168 +MMWS0_SX348 +MMWS0_SX438 +MMWS1_SI1701 +MMXS0_SI2136 +MMXS0_SX246 +MMXS0_SX426 +MNET0_SI816 +MNET0_SX6 +MNTW0_SA2 +MNTW0_SX168 +MNTW0_SX78 +MPAR0_SI2206 +MPAR0_SI946 +MPAR0_SX136 +MPAR0_SX316 +MPEB0_SI1034 +MPEB0_SI1860 +MPEB0_SX240 +MPEB0_SX330 +MPFU0_SI628 +MPFU0_SX448 +MPGH0_SX114 +MPGH0_SX24 +MPGR0_SX240 +MPGR0_SX330 +MPGR1_SX149 +MPPC0_SA1 +MPRD0_SA1 +MPRD0_SX261 +MPRD0_SX351 +MPRD0_SX441 +MPRD0_SX81 +MPRK0_SI1727 +MPRK0_SX107 +MPRK0_SX377 +MPRT0_SA1 +MPRT0_SX310 +MPSW0_SI1067 +MPSW0_SX167 +MPSW0_SX437 +MRAB1_SX128 +MRAB1_SX308 +MRAI0_SA1 +MRAI0_SA2 +MRAI0_SX72 +MRAM0_SA1 +MRAM0_SA2 +MRAM0_SX15 +MRBC0_SI1859 +MRBC0_SX329 +MRBC0_SX419 +MRCG0_SI798 +MRCG0_SX168 +MRCW0_SA1 +MRCW0_SX291 +MRDD0_SI1680 +MRDD0_SX150 +MRDD0_SX277 +MRDD0_SX60 +MRDM0_SI1595 +MRDM0_SX65 +MRDS0_SA1 +MREE0_SX24 +MREH1_SX249 +MREH1_SX69 +MREM0_SA2 +MREW1_SI870 +MRFK0_SX446 +MRFL0_SA1 +MRFL0_SX256 +MRFL0_SX436 +MRFL0_SX76 +MRGM0_SA2 +MRGM0_SX262 +MRGS0_SA2 +MRGS0_SX186 +MRHL0_SI885 +MRHL0_SX345 +MRHL0_SX435 +MRJB1_SA1 +MRJB1_SA2 +MRJB1_SX210 +MRJB1_SX30 +MRJB1_SX390 +MRJH0_SA2 +MRJH0_SX307 +MRJH0_SX79 +MRJM0_SX148 +MRJM1_SA2 +MRJM1_SI1298 +MRJM1_SI1928 +MRJM1_SX128 +MRJT0_SA2 +MRJT0_SI1498 +MRJT0_SX328 +MRJT0_SX418 +MRKM0_SA2 +MRKM0_SX367 +MRLD0_SA2 +MRLD0_SI2224 +MRLD0_SX154 +MRLD0_SX424 +MRLJ0_SA1 +MRLJ0_SX250 +MRLJ0_SX340 +MRLJ1_SA1 +MRLJ1_SA2 +MRLJ1_SX321 +MRLK0_SI843 +MRLK0_SX123 +MRLK0_SX213 +MRMB0_SA2 +MRMB0_SI1581 +MRMB0_SX411 +MRMG0_SA1 +MRMG0_SI1080 +MRMG0_SX450 +MRMH0_SI1349 +MRMH0_SI2281 +MRMH0_SX121 +MRML0_SA2 +MRML0_SX341 +MRPC1_SI2112 +MRRE0_SA2 +MRRE0_SX164 +MRRE0_SX344 +MRRE0_SX74 +MRSO0_SX129 +MRSO0_SX39 +MRSP0_SX259 +MRTC0_SX378 +MRVG0_SI1140 +MRVG0_SX240 +MRWA0_SI973 +MRWA0_SX163 +MRWA0_SX73 +MRWS0_SI1732 +MRWS0_SI472 +MRWS0_SX22 +MRWS0_SX382 +MRXB0_SA2 +MRXB0_SX415 +MSAH1_SI1679 +MSAS0_SX116 +MSAS0_SX206 +MSAS0_SX386 +MSAT0_SA1 +MSAT1_SX263 +MSAT1_SX443 +MSAT1_SX83 +MSDB0_SX197 +MSDB0_SX287 +MSDB0_SX377 +MSDH0_SI2240 +MSDH0_SX440 +MSDH0_SX80 +MSDS0_SA1 +MSEM1_SI1440 +MSEM1_SX180 +MSEM1_SX270 +MSES0_SI1589 +MSES0_SX239 +MSES0_SX419 +MSFH0_SX316 +MSFV0_SI1892 +MSFV0_SX362 +MSFV0_SX92 +MSMR0_SX415 +MSMS0_SA1 +MSMS0_SX173 +MSMS0_SX83 +MSRG0_SA1 +MSRG0_SI1221 +MSTF0_SI766 +MSTF0_SX316 +MSTF0_SX46 +MSVS0_SA2 +MSVS0_SX308 +MTAS0_SX215 +MTAS0_SX35 +MTAS0_SX395 +MTAT0_SX390 +MTAT1_SX59 +MTBC0_SI1803 +MTCS0_SA2 +MTCS0_SI2265 +MTCS0_SX82 +MTDP0_SA2 +MTER0_SA2 +MTER0_SI1787 +MTJG0_SA1 +MTJG0_SI2157 +MTJG0_SX260 +MTJM0_SI1856 +MTJM0_SX146 +MTJU0_SX130 +MTJU0_SX400 +MTKD0_SX107 +MTKD0_SX287 +MTKP0_SI1023 +MTLB0_SA1 +MTLB0_SX234 +MTLC0_SA1 +MTML0_SI2325 +MTML0_SX165 +MTMN0_SA2 +MTMN0_SI1064 +MTMN0_SI2324 +MTMN0_SX434 +MTMT0_SA2 +MTMT0_SI1748 +MTPF0_SX65 +MTPG0_SI1383 +MTPG0_SI753 +MTPG0_SX303 +MTPP0_SX338 +MTPR0_SX340 +MTQC0_SI480 +MTQC0_SX91 +MTRR0_SX198 +MTRR0_SX288 +MTRT0_SA2 +MTRT0_SX254 +MTRT0_SX57 +MTWH1_SX72 +MTXS0_SA1 +MTXS0_SA2 +MVJH0_SI926 +MVJH0_SX206 +MVJH0_SX296 +MVLO0_SA1 +MVRW0_SA2 +MVRW0_SX135 +MVRW0_SX225 +MWAC0_SA2 +MWAC0_SX341 +MWAC0_SX431 +MWAD0_SX432 +MWAD0_SX72 +MWAR0_SA1 +MWAR0_SI1675 +MWCH0_SI1895 +MWCH0_SI2252 +MWCH0_SX182 +MWCH0_SX452 +MWDK0_SA1 +MWDK0_SA2 +MWDK0_SI2017 +MWDK0_SI806 +MWDK0_SX176 +MWDK0_SX86 +MWEM0_SA2 +MWEM0_SI1320 +MWEM0_SI1393 +MWEM0_SX150 +MWGR0_SX346 +MWRE0_SX247 +MWRE0_SX337 +MWRE0_SX427 +MWRP0_SA1 +MWRP0_SX273 +MWRP0_SX363 +MWSB0_SX276 +MWSH0_SX256 +MWSH0_SX76 +MZMB0_SA1 diff --git a/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/valid.uid b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/valid.uid new file mode 100644 index 0000000000000000000000000000000000000000..e99edfe937854a5f47a2f0384f0e067487336883 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/config/timit_unmatched/valid.uid @@ -0,0 +1,620 @@ +FAEM0_SI1392 +FAJW0_SI1263 +FAJW0_SI633 +FALK0_SI658 +FALR0_SX335 +FAPB0_SI1063 +FAPB0_SI2323 +FAPB0_SX433 +FBAS0_SI1472 +FBAS0_SI2066 +FBCG1_SX352 +FBCH0_SI959 +FBJL0_SI922 +FBLV0_SI1688 +FBMH0_SI1136 +FBMH0_SI970 +FBMJ0_SA1 +FBMJ0_SI1776 +FBMJ0_SI516 +FBMJ0_SX336 +FCDR1_SI1186 +FCDR1_SI1816 +FCDR1_SI556 +FCDR1_SX286 +FCKE0_SI1741 +FCKE0_SI481 +FCLT0_SI808 +FCMG0_SI1142 +FCMG0_SX432 +FCMM0_SI1957 +FCMM0_SX420 +FCYL0_SI667 +FCYL0_SX349 +FDAS1_SI1461 +FDAS1_SI831 +FDAW0_SI1271 +FDAW0_SI2036 +FDJH0_SI935 +FDKN0_SI1202 +FDKN0_SX181 +FDKN0_SX451 +FDMY0_SA1 +FDMY0_SI567 +FDMY0_SI714 +FDMY0_SX387 +FDNC0_SI1278 +FDNC0_SI1908 +FDTD0_SA1 +FDTD0_SX321 +FEAC0_SI615 +FEAR0_SX352 +FECD0_SA1 +FECD0_SI1418 +FECD0_SI788 +FEME0_SI875 +FEME0_SX335 +FEXM0_SA1 +FEXM0_SI482 +FEXM0_SX366 +FGDP0_SI988 +FGDP0_SX88 +FGMB0_SI1145 +FGMB0_SX335 +FGRW0_SA1 +FGRW0_SI1152 +FGRW0_SX162 +FGRW0_SX432 +FHLM0_SX120 +FHLM0_SX349 +FHXS0_SA1 +FHXS0_SI1075 +FHXS0_SI2302 +FHXS0_SX175 +FJDM2_SA2 +FJDM2_SX142 +FJEN0_SA1 +FJEN0_SX327 +FJEN0_SX417 +FJHK0_SI2282 +FJKL0_SI932 +FJLG0_SI1889 +FJLR0_SI1231 +FJRB0_SX402 +FJRP1_SA1 +FJRP1_SI1432 +FJRP1_SX262 +FJRP1_SX352 +FJSK0_SI1052 +FJSP0_SI1434 +FJWB1_SI748 +FJXM0_SX311 +FJXM0_SX41 +FJXP0_SI1752 +FKAA0_SA1 +FKDE0_SI1141 +FKDE0_SI1771 +FKDW0_SI1207 +FKDW0_SI1891 +FKFB0_SI1608 +FKFB0_SX438 +FKKH0_SI1290 +FKKH0_SI1920 +FKLC0_SI985 +FKLC0_SX175 +FKLC1_SI1048 +FKLH0_SI1257 +FKSR0_SX366 +FLAC0_SI1339 +FLAG0_SI1464 +FLAG0_SI834 +FLEH0_SI1051 +FLET0_SI507 +FLJA0_SI1078 +FLJA0_SX178 +FLJD0_SI1516 +FLJG0_SI981 +FLJG0_SX171 +FLJG0_SX351 +FLKM0_SA1 +FLKM0_SI620 +FLKM0_SX350 +FLKM0_SX440 +FLMC0_SI1372 +FLMK0_SA1 +FLMK0_SI1229 +FLTM0_SX170 +FLTM0_SX350 +FLTM0_SX440 +FMAH1_SI879 +FMBG0_SI1160 +FMEM0_SA1 +FMEM0_SX333 +FMJB0_SI1177 +FMJF0_SI624 +FMJF0_SX174 +FMJF0_SX84 +FMJU0_SI1389 +FMKC0_SI1041 +FMKF0_SI1018 +FMPG0_SA1 +FMPG0_SI972 +FMPG0_SX162 +FMPG0_SX342 +FMPG0_SX432 +FNKL0_SI892 +FNTB0_SI679 +FPAB1_SA1 +FPAB1_SI2101 +FPAB1_SI841 +FPAC0_SI1921 +FPAC0_SI661 +FPAD0_SI716 +FPAD0_SX176 +FPAF0_SA1 +FPAF0_SI1054 +FPAZ0_SI2223 +FPAZ0_SI963 +FPJF0_SI1259 +FPJF0_SX352 +FPLS0_SI960 +FPMY0_SI1153 +FPMY0_SI523 +FREH0_SI1945 +FRLL0_SI805 +FSAG0_SI1323 +FSAG0_SX153 +FSAG0_SX333 +FSAG0_SX423 +FSAH0_SI614 +FSAH0_SX327 +FSAK0_SI1300 +FSBK0_SX349 +FSCN0_SA1 +FSCN0_SI705 +FSCN0_SX176 +FSDC0_SI1312 +FSDJ0_SI1115 +FSGF0_SI2187 +FSGF0_SI927 +FSJG0_SA1 +FSJG0_SA2 +FSJG0_SI940 +FSJG0_SX220 +FSJG0_SX40 +FSJG0_SX400 +FSJS0_SA1 +FSJS0_SX451 +FSJW0_SI1333 +FSKP0_SI1098 +FSMA0_SI991 +FSMA0_SX451 +FSMM0_SX324 +FSPM0_SI1241 +FSPM0_SX251 +FSRH0_SX311 +FSSB0_SI1712 +FSSB0_SX362 +FTBR0_SI1402 +FTBR0_SI921 +FTBW0_SI715 +FTBW0_SX175 +FTLG0_SI1743 +FTLG0_SI483 +FTMG0_SI902 +FVFB0_SI1510 +FVKB0_SX349 +FVMH0_SI1466 +FVMH0_SI836 +MADC0_SI1367 +MADC0_SI737 +MAEB0_SI1411 +MAEO0_SI1326 +MAJP0_SI1704 +MAJP0_SX174 +MAKB0_SA2 +MAKB0_SI1016 +MAKB0_SI2276 +MAKB0_SX116 +MAPV0_SI1293 +MAPV0_SI663 +MARW0_SX286 +MARW0_SX349 +MBBR0_SI1055 +MBBR0_SX335 +MBCG0_SI957 +MBCG0_SX327 +MBGT0_SI1841 +MBGT0_SX171 +MBMA0_SI1222 +MBMA1_SI954 +MBMA1_SX324 +MBTH0_SI2102 +MBWP0_SX349 +MCAE0_SI1447 +MCAE0_SI2077 +MCAE0_SI817 +MCAL0_SI1138 +MCDR0_SI1784 +MCDR0_SI524 +MCEF0_SI842 +MCEW0_SA1 +MCEW0_SI2072 +MCEW0_SI812 +MCEW0_SX362 +MCEW0_SX452 +MCHL0_SI1347 +MCHL0_SI1404 +MCLK0_SI2290 +MCLK0_SI650 +MCPM0_SI1824 +MCSS0_SI1380 +MCSS0_SI688 +MCTM0_SI1350 +MCTM0_SI1980 +MDAC0_SI631 +MDAS0_SI1896 +MDAS0_SI636 +MDBP0_SI528 +MDBP0_SX438 +MDCD0_SI785 +MDCD0_SX335 +MDCM0_SI1480 +MDDC0_SI1419 +MDED0_SI540 +MDEF0_SI1123 +MDEM0_SA1 +MDEM0_SI608 +MDEM0_SI800 +MDEM0_SX428 +MDHS0_SI900 +MDJM0_SI1455 +MDKS0_SX166 +MDKS0_SX346 +MDLB0_SI1306 +MDLB0_SX136 +MDLB0_SX406 +MDLC0_SI1395 +MDLC0_SI2025 +MDLC1_SI1435 +MDLH0_SX160 +MDLH0_SX430 +MDLM0_SI604 +MDLR0_SX333 +MDLR1_SI669 +MDMA0_SX170 +MDMA0_SX350 +MDMA0_SX440 +MDNS0_SI1011 +MDNS0_SI873 +MDPB0_SI1760 +MDPB0_SI866 +MDRD0_SI752 +MDSJ0_SI1462 +MDSJ0_SX438 +MDWD0_SI1260 +MDWH0_SA1 +MDWH0_SI1168 +MDWH0_SI665 +MDWM0_SI916 +MEDR0_SI2004 +MEFG0_SI491 +MEFG0_SI598 +MEGJ0_SA1 +MEGJ0_SI1337 +MEGJ0_SI707 +MEGJ0_SX167 +MEJS0_SI1240 +MESG0_SI702 +MESJ0_SI2039 +MFWK0_SX349 +MFXS0_SX324 +MFXV0_SI1005 +MFXV0_SI1342 +MGAF0_SI1282 +MGAG0_SI691 +MGAK0_SI1036 +MGAK0_SX136 +MGAR0_SX312 +MGAW0_SI1165 +MGES0_SX311 +MGJC0_SX435 +MGRL0_SX327 +MGRP0_SI1317 +MGRP0_SX327 +MGSH0_SI1176 +MGSH0_SI546 +MGSL0_SI797 +MGXP0_SI1087 +MGXP0_SI525 +MHBS0_SI945 +MHIT0_SI983 +MHMG0_SI735 +MHMR0_SI1692 +MILB0_SI903 +MJAC0_SI701 +MJAC0_SX251 +MJAE0_SX84 +MJAI0_SI682 +MJAI0_SI710 +MJDC0_SI531 +MJDE0_SA1 +MJDE0_SI1120 +MJDE0_SI490 +MJDE0_SX220 +MJDM0_SI1340 +MJDM0_SX170 +MJDM0_SX350 +MJEB0_SX170 +MJEB1_SI1467 +MJEB1_SI837 +MJFR0_SA1 +MJFR0_SX435 +MJHI0_SI1328 +MJJJ0_SI1163 +MJJM0_SI1251 +MJLB0_SI1616 +MJLS0_SI1726 +MJMA0_SI2125 +MJMD0_SI2288 +MJMM0_SI1255 +MJMM0_SX175 +MJPG0_SI1821 +MJPM0_SI1368 +MJPM1_SX311 +MJRA0_SX336 +MJRG0_SI736 +MJRG0_SX352 +MJRH0_SI1840 +MJRH1_SI1558 +MJRK0_SI880 +MJRP0_SI1845 +MJSR0_SI2054 +MJSR0_SI794 +MJWG0_SI813 +MJWG0_SI895 +MJWG0_SX175 +MJWS0_SX333 +MJWT0_SI1291 +MJWT0_SI1381 +MJXL0_SI1172 +MKAG0_SI979 +MKAH0_SX178 +MKAM0_SI1250 +MKAM0_SI1465 +MKDD0_SI1567 +MKDD0_SI2197 +MKDD0_SI937 +MKDT0_SI814 +MKES0_SI623 +MKLS0_SI1437 +MKLS0_SI2067 +MKLS1_SI915 +MKLW0_SI1571 +MKLW0_SX311 +MKRG0_SI861 +MKXL0_SI1815 +MKXL0_SI1958 +MLBC0_SI1239 +MLEL0_SI616 +MLEL0_SX166 +MLJC0_SI1225 +MLJH0_SA1 +MLJH0_SA2 +MLJH0_SI1422 +MLJH0_SI694 +MLJH0_SX244 +MLSH0_SI1417 +MLSH0_SX247 +MMAA0_SI1588 +MMAA0_SI845 +MMAB1_SI864 +MMAB1_SX324 +MMAG0_SA1 +MMAG0_SI1756 +MMAG0_SX136 +MMAR0_SI1966 +MMAR0_SX166 +MMAR0_SX346 +MMBS0_SI521 +MMBS0_SX161 +MMCC0_SI1338 +MMDB0_SI987 +MMDG0_SI1780 +MMDM0_SI1311 +MMDM1_SX153 +MMDM1_SX333 +MMEB0_SX327 +MMGC0_SI1305 +MMGG0_SI1079 +MMGG0_SX449 +MMLM0_SI2150 +MMPM0_SX161 +MMRP0_SX324 +MMSM0_SI1106 +MMSM0_SI476 +MMVP0_SI654 +MMVP0_SX347 +MMWB0_SA1 +MMWB0_SI2249 +MMWB0_SX359 +MMWB0_SX449 +MNTW0_SI1068 +MNTW0_SI1698 +MPEB0_SI600 +MPFU0_SI1258 +MPGH0_SI675 +MPGR0_SI1410 +MPGR1_SI1499 +MPMB0_SA1 +MPMB0_SA2 +MPMB0_SI1501 +MPMB0_SI2131 +MPMB0_SI871 +MPMB0_SX151 +MPMB0_SX331 +MPMB0_SX421 +MPMB0_SX61 +MPPC0_SI1412 +MPRB0_SI1215 +MPRB0_SI575 +MPRD0_SI801 +MPRD0_SX171 +MPRK0_SA1 +MPRK0_SI1097 +MPRK0_SI467 +MPRK0_SX287 +MRAB0_SI1854 +MRAB1_SI848 +MRAI0_SI2052 +MRAI0_SI792 +MRAI0_SX432 +MRAM0_SI1951 +MRCG0_SA2 +MRCG0_SI1428 +MRCG0_SX348 +MRCG0_SX438 +MRCW0_SI741 +MRDM0_SI1044 +MRDM0_SX335 +MREE0_SI1104 +MREE0_SI1959 +MREH1_SA1 +MREH1_SI1599 +MREH1_SI969 +MREM0_SI511 +MRFK0_SI1076 +MRFL0_SI1156 +MRFL0_SI526 +MRFL0_SX166 +MRGM0_SI532 +MRGM0_SX172 +MRGM0_SX442 +MRGS0_SI1356 +MRGS0_SI726 +MRGS0_SX6 +MRJB1_SI1413 +MRJB1_SI2021 +MRJB1_SX120 +MRJH0_SI1519 +MRJH0_SI889 +MRJH0_SX169 +MRJT0_SI868 +MRJT0_SX58 +MRKM0_SI1267 +MRKM0_SI1391 +MRKM0_SI637 +MRLJ0_SI790 +MRLJ1_SI2301 +MRLK0_SI1468 +MRLR0_SI1196 +MRML0_SA1 +MRML0_SI1421 +MRML0_SX161 +MRML0_SX251 +MRMS0_SI2057 +MRRE0_SA1 +MRRE0_SI1334 +MRRE0_SI952 +MRSO0_SI1206 +MRSP0_SI1429 +MRTC0_SI1458 +MRTJ0_SA1 +MRTJ0_SI772 +MRTJ0_SX142 +MRTJ0_SX232 +MRTJ0_SX52 +MRWS0_SI1102 +MRXB0_SI2215 +MRXB0_SI955 +MSAS0_SI1376 +MSAS0_SI746 +MSDH0_SI980 +MSDH0_SX170 +MSDS0_SI1077 +MSDS0_SX267 +MSDS0_SX357 +MSEM1_SI2070 +MSEM1_SI810 +MSFH0_SA1 +MSFH0_SI1738 +MSFH0_SX136 +MSFH0_SX406 +MSFV0_SI632 +MSJK0_SI1596 +MSJK0_SX336 +MSMC0_SI509 +MSMR0_SI1150 +MSMS0_SI1433 +MSRR0_SI1761 +MSRR0_SI501 +MSTF0_SI852 +MSVS0_SI2198 +MSVS0_SI938 +MSVS0_SX398 +MTAB0_SI1572 +MTAB0_SX312 +MTAT0_SA1 +MTAT0_SI1110 +MTAT0_SI811 +MTAT1_SI779 +MTAT1_SX149 +MTAT1_SX329 +MTBC0_SI543 +MTCS0_SI712 +MTDB0_SI1401 +MTDB0_SI771 +MTDP0_SA1 +MTDP0_SI1521 +MTDP0_SX171 +MTDP0_SX351 +MTER0_SA1 +MTER0_SI1157 +MTER0_SX437 +MTJG0_SX170 +MTJS0_SA2 +MTJS0_SI1822 +MTJS0_SI562 +MTJS0_SX382 +MTJU0_SI2020 +MTKD0_SI630 +MTKP0_SI2283 +MTKP0_SI454 +MTLB0_SI1134 +MTLB0_SX324 +MTLC0_SI1313 +MTLC0_SI1477 +MTML0_SX435 +MTMN0_SI582 +MTMT0_SI488 +MTPP0_SI1508 +MTPR0_SI2230 +MTPR0_SX160 +MTPR0_SX430 +MTQC0_SA1 +MTQC0_SI1441 +MTQC0_SX181 +MTQC0_SX451 +MTRC0_SI589 +MTRR0_SI918 +MTRT0_SI1227 +MTXS0_SI1060 +MTXS0_SI2320 +MTXS0_SX160 +MTXS0_SX430 +MVJH0_SI1556 +MVLO0_SI517 +MWAC0_SI1601 +MWAC0_SX161 +MWAC0_SX251 +MWAR0_SI1045 +MWDK0_SI1436 +MWEM0_SX420 +MWRE0_SA2 +MWRE0_SI1057 +MWRE0_SX67 +MWRP0_SI1443 +MWSB0_SI996 +MWSH0_SI1426 +MWSH0_SI796 +MWSH0_SX166 diff --git a/fairseq/examples/wav2vec/unsupervised/data/__init__.py b/fairseq/examples/wav2vec/unsupervised/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0545627efc9a6f9bb180e351ead519a2cb6dea7 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/data/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .extracted_features_dataset import ExtractedFeaturesDataset +from .random_input_dataset import RandomInputDataset + + +__all__ = [ + "ExtractedFeaturesDataset", + "RandomInputDataset", +] diff --git a/fairseq/examples/wav2vec/unsupervised/data/extracted_features_dataset.py b/fairseq/examples/wav2vec/unsupervised/data/extracted_features_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ee9c4a3602be9db8ddfe67d41ce8a96a98ad1e --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/data/extracted_features_dataset.py @@ -0,0 +1,144 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import logging +import os +import contextlib + +import numpy as np +import torch + +from fairseq.data import FairseqDataset, data_utils + + +logger = logging.getLogger(__name__) + + +class ExtractedFeaturesDataset(FairseqDataset): + def __init__( + self, + path, + split, + min_length=3, + max_length=None, + labels=None, + label_dict=None, + shuffle=True, + sort_by_length=True, + ): + super().__init__() + + self.min_length = min_length + self.max_length = max_length + self.shuffle = shuffle + self.sort_by_length = sort_by_length + self.label_dict = label_dict + + if labels is not None: + assert label_dict is not None + + self.sizes = [] + self.offsets = [] + self.labels = [] + + path = os.path.join(path, split) + data_path = path + self.data = np.load(data_path + ".npy", mmap_mode="r") + + offset = 0 + skipped = 0 + + if not os.path.exists(path + f".{labels}"): + labels = None + + with open(data_path + ".lengths", "r") as len_f, open( + path + f".{labels}", "r" + ) if labels is not None else contextlib.ExitStack() as lbl_f: + for line in len_f: + length = int(line.rstrip()) + lbl = None if labels is None else next(lbl_f).rstrip().split() + if length >= min_length and ( + max_length is None or length <= max_length + ): + self.sizes.append(length) + self.offsets.append(offset) + if lbl is not None: + self.labels.append(lbl) + offset += length + + self.sizes = np.asarray(self.sizes) + self.offsets = np.asarray(self.offsets) + + logger.info(f"loaded {len(self.offsets)}, skipped {skipped} samples") + + def __getitem__(self, index): + offset = self.offsets[index] + end = self.sizes[index] + offset + feats = torch.from_numpy(self.data[offset:end].copy()).float() + + res = {"id": index, "features": feats} + if len(self.labels) > 0: + res["target"] = self.label_dict.encode_line( + self.labels[index], + line_tokenizer=lambda x: x, + append_eos=False, + ) + + return res + + def __len__(self): + return len(self.sizes) + + def collater(self, samples): + if len(samples) == 0: + return {} + + features = [s["features"] for s in samples] + sizes = [len(s) for s in features] + + target_size = max(sizes) + + collated_features = features[0].new_zeros( + len(features), target_size, features[0].size(-1) + ) + padding_mask = torch.BoolTensor(collated_features.shape[:-1]).fill_(False) + for i, (f, size) in enumerate(zip(features, sizes)): + collated_features[i, :size] = f + padding_mask[i, size:] = True + + res = { + "id": torch.LongTensor([s["id"] for s in samples]), + "net_input": {"features": collated_features, "padding_mask": padding_mask}, + } + + if len(self.labels) > 0: + target = data_utils.collate_tokens( + [s["target"] for s in samples], + pad_idx=self.label_dict.pad(), + left_pad=False, + ) + res["target"] = target + return res + + def num_tokens(self, index): + return self.size(index) + + def size(self, index): + return self.sizes[index] + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + if self.shuffle: + order = [np.random.permutation(len(self))] + else: + order = [np.arange(len(self))] + + if self.sort_by_length: + order.append(self.sizes) + return np.lexsort(order)[::-1] + else: + return order[0] diff --git a/fairseq/examples/wav2vec/unsupervised/data/random_input_dataset.py b/fairseq/examples/wav2vec/unsupervised/data/random_input_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..886505616cc7f7a515ecebf34fae5c2bc541de03 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/data/random_input_dataset.py @@ -0,0 +1,62 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import random +from typing import List + +from fairseq.data import BaseWrapperDataset, data_utils + + +class RandomInputDataset(BaseWrapperDataset): + def __init__( + self, + dataset, + random_input_dataset, + input_key_path: List[str], + add_to_input, + pad_idx, + ): + super().__init__(dataset) + self.random_input_dataset = random_input_dataset + if isinstance(input_key_path, str): + input_key_path = [input_key_path] + assert len(input_key_path) > 0 + self.input_key_path = input_key_path + self.add_to_input = add_to_input + self.pad_idx = pad_idx + + def get_target(self, item): + target_loc = item + for p in self.input_key_path[:-1]: + target_loc = target_loc[p] + return self.input_key_path[-1], target_loc + + def get_target_value(self, item): + k, target_loc = self.get_target(item) + return target_loc[k] + + def __getitem__(self, index): + item = self.dataset[index] + k, target_loc = self.get_target(item) + target_loc[k] = random.choice(self.random_input_dataset) + return item + + def collater(self, samples): + collated = self.dataset.collater(samples) + if len(collated) == 0: + return collated + indices = set(collated["id"].tolist()) + + random_inputs = data_utils.collate_tokens( + [self.get_target_value(s) for s in samples if s["id"] in indices], + pad_idx=self.pad_idx, + left_pad=False, + ) + k, target_loc = self.get_target( + collated if not self.add_to_input else collated["net_input"] + ) + target_loc[k] = random_inputs + + return collated diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/README.md b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/README.md new file mode 100644 index 0000000000000000000000000000000000000000..314984fcbb6825169193b21bd6bb3fca5fd2503b --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/README.md @@ -0,0 +1,56 @@ +# Self-Training with Kaldi HMM Models +This folder contains recipes for self-training on pseudo phone transcripts and +decoding into phones or words with [kaldi](https://github.com/kaldi-asr/kaldi). + +To start, download and install kaldi follow its instruction, and place this +folder in `path/to/kaldi/egs`. + +## Training +Assuming the following has been prepared: +- `w2v_dir`: contains features `{train,valid}.{npy,lengths}`, real transcripts `{train,valid}.${label}`, and dict `dict.${label}.txt` +- `lab_dir`: contains pseudo labels `{train,valid}.txt` +- `arpa_lm`: Arpa-format n-gram phone LM for decoding +- `arpa_lm_bin`: Arpa-format n-gram phone LM for unsupervised model selection to be used with KenLM + +Set these variables in `train.sh`, as well as `out_dir`, the output directory, +and then run it. + +The output will be: +``` +==== WER w.r.t. real transcript (select based on unsupervised metric) +INFO:root:./out/exp/mono/decode_valid/scoring/14.0.0.tra.txt: score 0.9178 wer 28.71% lm_ppl 24.4500 gt_wer 25.57% +INFO:root:./out/exp/tri1/decode_valid/scoring/17.1.0.tra.txt: score 0.9257 wer 26.99% lm_ppl 30.8494 gt_wer 21.90% +INFO:root:./out/exp/tri2b/decode_valid/scoring/8.0.0.tra.txt: score 0.7506 wer 23.15% lm_ppl 25.5944 gt_wer 15.78% +``` +where `wer` is the word eror rate with respect to the pseudo label, `gt_wer` to +the ground truth label, `lm_ppl` the language model perplexity of HMM prediced +transcripts, and `score` is the unsupervised metric for model selection. We +choose the model and the LM parameter of the one with the lowest score. In the +example above, it is `tri2b`, `8.0.0`. + + +## Decoding into Phones +In `decode_phone.sh`, set `out_dir` the same as used in `train.sh`, set +`dec_exp` and `dec_lmparam` to the selected model and LM parameter (e.g. +`tri2b` and `8.0.0` in the above example). `dec_script` needs to be set +according to `dec_exp`: for mono/tri1/tri2b, use `decode.sh`; for tri3b, use +`decode_fmllr.sh`. + +The output will be saved at `out_dir/dec_data` + + +## Decoding into Words +`decode_word_step1.sh` prepares WFSTs for word decoding. Besides the variables +mentioned above, set +- `wrd_arpa_lm`: Arpa-format n-gram word LM for decoding +- `wrd_arpa_lm_bin`: Arpa-format n-gram word LM for unsupervised model selection + +`decode_word_step1.sh` decodes the `train` and `valid` split into word and runs +unsupervised model selection using the `valid` split. The output is like: +``` +INFO:root:./out/exp/tri2b/decodeword_valid/scoring/17.0.0.tra.txt: score 1.8693 wer 24.97% lm_ppl 1785.5333 gt_wer 31.45% +``` + +After determining the LM parameter (`17.0.0` in the example above), set it in +`decode_word_step2.sh` and run it. The output will be saved at +`out_dir/dec_data_word`. diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/cmd.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/cmd.sh new file mode 100644 index 0000000000000000000000000000000000000000..e74953194d41f0d93855d41b2acef08556d92477 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/cmd.sh @@ -0,0 +1,15 @@ +# you can change cmd.sh depending on what type of queue you are using. +# If you have no queueing system and want to run on a local machine, you +# can change all instances 'queue.pl' to run.pl (but be careful and run +# commands one by one: most recipes will exhaust the memory on your +# machine). queue.pl works with GridEngine (qsub). slurm.pl works +# with slurm. Different queues are configured differently, with different +# queue names and different ways of specifying things like memory; +# to account for these differences you can create and edit the file +# conf/queue.conf to match your queue's configuration. Search for +# conf/queue.conf in http://kaldi-asr.org/doc/queue.html for more information, +# or search for the string 'default_config' in utils/queue.pl or utils/slurm.pl. + +export train_cmd="run.pl --mem 2G" +export decode_cmd="run.pl --mem 4G" +export mkgraph_cmd="run.pl --mem 8G" diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_phone.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_phone.sh new file mode 100644 index 0000000000000000000000000000000000000000..947342a0b7d8f50bcf4164b284ef3303a1247b64 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_phone.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +# decode into phones (and prepare a new data directory for HMM outputs) + +. ./path.sh + +set -eu + +out_dir= # same as in train.sh +dec_lmparam= # LM hyperparameters (e.g., 7.0.0) +dec_exp= +dec_script= +dec_splits="train valid" +dec_data_dir=$out_dir/dec_data # where to write HMM output + +data_dir=${out_dir}/data + +local/decode.sh --nj 40 --graph_name graph \ + --val_sets "$dec_splits" --decode_script $dec_script \ + $out_dir/exp/$dec_exp $data_dir $data_dir/lang_test + +if [ ! -z $dec_lmparam ]; then + for x in $dec_splits; do + mkdir -p $dec_data_dir/$x + cp $data_dir/$x/{feats.scp,cmvn.scp,utt2spk,spk2utt} $dec_data_dir/$x/ + + tra=$out_dir/exp/$dec_exp/decode_${x}/scoring/${dec_lmparam}.tra + cat $tra | utils/int2sym.pl -f 2- $data_dir/lang/words.txt | \ + sed 's:<UNK>::g' | sed 's:<SIL>::g' > $dec_data_dir/${x}/text + utils/fix_data_dir.sh $dec_data_dir/${x} + echo "WER on ${x} is" $(compute-wer ark:$data_dir/${x}_gt/text ark:$dec_data_dir/$x/text | cut -d" " -f2-) + done +fi diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step1.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step1.sh new file mode 100644 index 0000000000000000000000000000000000000000..c1276bbe4d0e02deb984c7c10d6c0486dce09a5f --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step1.sh @@ -0,0 +1,46 @@ +#!/bin/bash + +# prepare word WFSTs, reference data, and decode + +set -eu + +w2v_dir= # same as in train.sh +out_dir= # same as in train.sh +lexicon= # word to phone mapping +wrd_arpa_lm= # word LM +wrd_arpa_lm_bin= # word LM for KenLM, used in unsupervised selection + +dec_exp= # what HMM stage to decode (e.g., tri3b) +dec_script= # what decoding script to use (e.g., steps/decode_fmllr.sh) +phn_label=phnc +wrd_label=wrd +dec_suffix=word +dec_splits="train valid" +valid_split="valid" + +data_dir=$out_dir/data +wrd_data_dir=$out_dir/data_word + +lexicon_clean=$(mktemp) +cat $lexicon | sort | uniq > $lexicon_clean +local/prepare_lang_word.sh $w2v_dir/dict.${phn_label}.txt $data_dir $lexicon_clean && rm $lexicon_clean +local/prepare_lm.sh --langdir $data_dir/lang_word --lmdir $data_dir/lang_test_word $wrd_arpa_lm $data_dir + +for x in $dec_splits; do + x_gt=${x}_gt + mkdir -p $wrd_data_dir/$x_gt + cp $data_dir/$x_gt/{feats.scp,cmvn.scp,utt2spk,spk2utt} $wrd_data_dir/$x_gt/ + python local/copy_aligned_text.py < $w2v_dir/$x.$wrd_label > $wrd_data_dir/$x_gt/text +done + +local/decode.sh --nj 40 --graph_name graph${dec_suffix} --decode_suffix $dec_suffix \ + --val_sets "$dec_splits" --decode_script $dec_script \ + $out_dir/exp/$dec_exp $data_dir $data_dir/lang_test_word + +local/unsup_select_decode_word.sh \ + --split $valid_split --kenlm_path $wrd_arpa_lm_bin \ + --ref_txt $wrd_data_dir/${valid_split}_gt/text \ + --psd_txt $data_dir/${valid_split}/text \ + --dec_name decode${dec_suffix} --graph_name graph${dec_suffix} \ + --phonemize_lexicon $data_dir/local/dict_word/lexicon.txt \ + $out_dir/exp diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh new file mode 100644 index 0000000000000000000000000000000000000000..59a6cbb12539cf62658f8344f7be7cecf2e3380f --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/decode_word_step2.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +# prepare a new data directory of HMM word output + +. ./path.sh + +set -eu + +out_dir= # same as in train.sh +dec_lmparam= # LM hyperparameters (e.g., 7.0.0) + +dec_exp=tri3b # what HMM stage to decode (e.g., tri3b) +dec_suffix=word +dec_splits="train valid" +dec_data_dir=$out_dir/dec_data_word # where to write HMM output + +data_dir=$out_dir/data +wrd_data_dir=$out_dir/data_word + +for x in $dec_splits; do + mkdir -p $dec_data_dir/$x + cp $data_dir/$x/{feats.scp,cmvn.scp,utt2spk,spk2utt} $dec_data_dir/$x/ + + tra=$out_dir/exp/$dec_exp/decode${dec_suffix}_${x}/scoring/${dec_lmparam}.tra + cat $tra | utils/int2sym.pl -f 2- $data_dir/lang_word/words.txt | \ + sed 's:<UNK>::g' | sed 's:<SIL>::g' > $dec_data_dir/$x/text + utils/fix_data_dir.sh $dec_data_dir/$x + echo "WER on $x is" $(compute-wer ark:$wrd_data_dir/${x}_gt/text ark:$dec_data_dir/$x/text | cut -d" " -f2-) +done + diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/copy_aligned_text.py b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/copy_aligned_text.py new file mode 100644 index 0000000000000000000000000000000000000000..5f4faa99218b0b30c980cad167c52b2297cd92c3 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/copy_aligned_text.py @@ -0,0 +1,4 @@ +import sys + +for idx, line in enumerate(sys.stdin): + print(f"utt{idx:010d} {line}", end='') \ No newline at end of file diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/decode.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/decode.sh new file mode 100755 index 0000000000000000000000000000000000000000..811cb63c88bb7cdd03b0a250ef2db32b5eaa50df --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/decode.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +set -u + +val_sets="dev_other" +graph_name=graph +decode_suffix="" +decode_script="steps/decode_fmllr.sh" +decode_args="" +nj=60 + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +set -x +exp_dir=$1 +data_root=$2 +lang_test=$3 + +graph=$exp_dir/$graph_name + +if [ ! -d $graph ]; then + utils/mkgraph.sh $lang_test $exp_dir $graph +fi + +for part in $val_sets; do + dec_dir=$exp_dir/decode${decode_suffix}_${part} + if [ ! -d $dec_dir ]; then + echo "decoding $part for $exp_dir" + $decode_script --nj $nj --cmd "$decode_cmd" $decode_args \ + $graph $data_root/$part $dec_dir & + else + echo "$dec_dir exists. skip" + fi +done + +wait diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_data_from_w2v.py b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_data_from_w2v.py new file mode 100644 index 0000000000000000000000000000000000000000..66954ea5c9f3f3330e3230860229c7c4046a5d6a --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_data_from_w2v.py @@ -0,0 +1,56 @@ +import kaldi_io +import numpy as np +import os + + +def get_parser(): + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("w2v_dir", help="wav2vec feature and text directory") + parser.add_argument("tar_root", help="output data directory in kaldi's format") + parser.add_argument("split", help="name of the subset") + parser.add_argument("--label", default="", help="if specified, copy labels too") + return parser + +def main(): + parser = get_parser() + args = parser.parse_args() + + tar_dir = os.path.join(args.tar_root, args.split) + os.makedirs(tar_dir, exist_ok=True) + + lengths_path = os.path.join(args.w2v_dir, f"{args.split}.lengths") + with open(lengths_path) as f: + lengths = [int(line.rstrip()) for line in f] + offsets = [0] + np.cumsum(lengths[:-1]).tolist() + feats = np.load( + os.path.join(args.w2v_dir, f"{args.split}.npy"), + mmap_mode="r" + ) + assert feats.shape[0] == sum(lengths), \ + f"lengths mismatch {feats.shape[0]} != {sum(lengths)}" + + ark_path = os.path.join(tar_dir, "feats.ark") + scp_path = os.path.join(tar_dir, "feats.scp") + wspec = f"ark:| copy-feats --compress=true ark:- ark,scp:{ark_path},{scp_path}" + with kaldi_io.open_or_fd(wspec, "wb") as f: + for idx, (offset, length) in enumerate(zip(offsets, lengths)): + feat = feats[offset:offset+length] + kaldi_io.write_mat(f, feat, key=f"utt{idx:010d}") + + u2s_path = os.path.join(tar_dir, "utt2spk") + s2u_path = os.path.join(tar_dir, "spk2utt") + with open(u2s_path, "w") as f_u2s, open(s2u_path, "w") as f_s2u: + for idx in range(len(lengths)): + f_u2s.write(f"utt{idx:010d} utt{idx:010d}\n") + f_s2u.write(f"utt{idx:010d} utt{idx:010d}\n") + + if bool(args.label): + lab_path = os.path.join(args.w2v_dir, f"{args.split}.{args.label}") + txt_path = os.path.join(tar_dir, "text") + with open(lab_path) as f_lab, open(txt_path, "w") as f_txt: + for idx, line in enumerate(f_lab): + f_txt.write(f"utt{idx:010d} {line}") + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang.sh new file mode 100755 index 0000000000000000000000000000000000000000..e9a80001eb47d5af863d6aab11a59362a59cef61 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +sil_prob=0.5 +num_sil_states=3 +num_nonsil_states=1 + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +set -eux + +dict=$1 +data_dir=$2 + +dict_dir=$data_dir/local/dict +tmplm_dir=$data_dir/local/lang_tmp +lm_dir=$data_dir/lang + +mkdir -p $dict_dir $tmplm_dir $lm_dir + +# prepare dict +echo "SIL" > $dict_dir/silence_phones.txt +echo "SIL" > $dict_dir/optional_silence.txt +awk '{print $1}' $dict > $dict_dir/nonsilence_phones.txt + +echo "SIL SIL" > $dict_dir/lexicon.txt +echo "<UNK> SIL" >> $dict_dir/lexicon.txt +awk '{print $1" "$1}' $dict >> $dict_dir/lexicon.txt + +echo "SIL" > $dict_dir/extra_questions.txt +awk '{printf $1" "} END {printf "\n"}' $dict >> $dict_dir/extra_questions.txt + +# prepare lang +utils/prepare_lang.sh --sil-prob $sil_prob --position-dependent-phones false \ + --num_sil_states $num_sil_states --num_nonsil_states $num_nonsil_states \ + $dict_dir "<UNK>" $tmplm_dir $lm_dir diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang_word.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang_word.sh new file mode 100755 index 0000000000000000000000000000000000000000..a7ea3877beefe1d4d53f9f7e32b004d8ce01e22a --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lang_word.sh @@ -0,0 +1,35 @@ +#!/bin/bash + +num_sil_states=3 +num_nonsil_states=1 + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +set -eux + +dict=$1 +data_dir=$2 +lexicon=$3 + +dict_dir=$data_dir/local/dict_word +tmplm_dir=$data_dir/local/lang_tmp_word +lm_dir=$data_dir/lang_word + +mkdir -p $dict_dir $tmplm_dir $lm_dir + +# prepare dict +echo "SIL" > $dict_dir/silence_phones.txt +echo "SIL" > $dict_dir/optional_silence.txt +awk '{print $1}' $dict > $dict_dir/nonsilence_phones.txt + +(echo "!SIL SIL"; echo "<UNK> SIL";) | cat - $lexicon > $dict_dir/lexicon.txt + +echo "SIL" > $dict_dir/extra_questions.txt +awk '{printf $1" "} END {printf "\n"}' $dict >> $dict_dir/extra_questions.txt + +# prepare lang +utils/prepare_lang.sh --position-dependent-phones false \ + --num_sil_states $num_sil_states --num_nonsil_states $num_nonsil_states \ + $dict_dir "<UNK>" $tmplm_dir $lm_dir diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lm.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lm.sh new file mode 100755 index 0000000000000000000000000000000000000000..c2edcefede2da3b6a991b9c8fbc78c96d46d27cb --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/prepare_lm.sh @@ -0,0 +1,35 @@ +#!/usr/bin/env bash + +langdir="" +lmdir="" + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +arpa_lm=$1 +data=$2 + +if [ -z $langdir ]; then + langdir=$data/lang +fi +if [ -z $lmdir ]; then + lmdir=$data/lang_test +fi + +if [ ! -d $langdir ]; then + echo "$langdir not found. run local/prepare_lang.sh first" && exit 1 +fi + +mkdir -p $lmdir +cp -r $langdir/* $lmdir + +if [[ "$arpa_lm" == *.gz ]]; then + gunzip -c $arpa_lm | arpa2fst --disambig-symbol=#0 --read-symbol-table=$lmdir/words.txt - $lmdir/G.fst +else + arpa2fst --disambig-symbol=#0 --read-symbol-table=$lmdir/words.txt $arpa_lm $lmdir/G.fst +fi +fstisstochastic $lmdir/G.fst +utils/validate_lang.pl $lmdir || exit 1 + +echo "done preparing lm ($lmdir)" diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh new file mode 100755 index 0000000000000000000000000000000000000000..cb5bbb7277bfb9f2d5440da0514bf7b16da8140d --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +# Copyright 2012 Johns Hopkins University (Author: Daniel Povey) +# 2014 Guoguo Chen +# Apache 2.0 + +[ -f ./path.sh ] && . ./path.sh + +# begin configuration section. +cmd=run.pl +stage=0 +decode_mbr=true +word_ins_penalty=0.0,0.5,1.0 +min_lmwt=7 +max_lmwt=17 +iter=final +#end configuration section. + +[ -f ./path.sh ] && . ./path.sh +. parse_options.sh || exit 1; + +if [ $# -ne 3 ]; then + echo "Usage: local/score.sh [--cmd (run.pl|queue.pl...)] <data-dir> <lang-dir|graph-dir> <decode-dir>" + echo " Options:" + echo " --cmd (run.pl|queue.pl...) # specify how to run the sub-processes." + echo " --stage (0|1|2) # start scoring script from part-way through." + echo " --decode_mbr (true/false) # maximum bayes risk decoding (confusion network)." + echo " --min_lmwt <int> # minumum LM-weight for lattice rescoring " + echo " --max_lmwt <int> # maximum LM-weight for lattice rescoring " + exit 1; +fi + +data=$1 +lang_or_graph=$2 +dir=$3 + +symtab=$lang_or_graph/words.txt + +for f in $symtab $dir/lat.1.gz $data/text; do + [ ! -f $f ] && echo "score.sh: no such file $f" && exit 1; +done + +mkdir -p $dir/scoring/log + +cat $data/text | sed 's:<NOISE>::g' | sed 's:<SPOKEN_NOISE>::g' > $dir/scoring/test_filt.txt + +for wip in $(echo $word_ins_penalty | sed 's/,/ /g'); do + $cmd LMWT=$min_lmwt:$max_lmwt $dir/scoring/log/best_path.LMWT.$wip.log \ + lattice-scale --inv-acoustic-scale=LMWT "ark:gunzip -c $dir/lat.*.gz|" ark:- \| \ + lattice-add-penalty --word-ins-penalty=$wip ark:- ark:- \| \ + lattice-best-path --word-symbol-table=$symtab \ + ark:- ark,t:$dir/scoring/LMWT.$wip.tra || exit 1; +done + +# Note: the double level of quoting for the sed command +for wip in $(echo $word_ins_penalty | sed 's/,/ /g'); do + $cmd LMWT=$min_lmwt:$max_lmwt $dir/scoring/log/score.LMWT.$wip.log \ + cat $dir/scoring/LMWT.$wip.tra \| \ + utils/int2sym.pl -f 2- $symtab \| sed 's:\<UNK\>::g' \| \ + compute-wer --text --mode=present \ + ark:$dir/scoring/test_filt.txt ark,p:- ">&" $dir/wer_LMWT_$wip || exit 1; +done + +exit 0; diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh new file mode 100755 index 0000000000000000000000000000000000000000..9ecf1690c67f8a019009ef32d973fbd45b56c7ca --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/show_wer.sh @@ -0,0 +1,52 @@ +#!/bin/bash + +split="dev_other" +ref_data="" +get_best_wer=true +dec_name="decode" +graph_name="graph" + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +exp_root=$1 + +set -eu + +echo "==== WER w.r.t. pseudo transcript" +for x in $exp_root/*/${dec_name}_${split}*; do grep WER $x/wer_* 2>/dev/null | utils/best_wer.sh; done + + +if [ ! -z $ref_data ]; then + echo "==== WER w.r.t. real transcript (select based on pseudo WER)" + ref_txt=$ref_data/$split/text + for x in $exp_root/*/${dec_name}_${split}*; do + lang=$(dirname $x)/$graph_name + + lmwt=$( + grep WER $x/wer_* 2>/dev/null | utils/best_wer.sh | + sed 's/.*wer_\(.*\)$/\1/g' | sed 's/_/./g' + ) + tra=$x/scoring/$lmwt.tra + cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:<UNK>::g' | sed 's:<SIL>::g' | \ + compute-wer --text --mode=present \ + ark:$ref_txt ark,p:- 2> /dev/null | grep WER | xargs -I{} echo {} $tra + done +fi + +if [ ! -z $ref_data ] && $get_best_wer; then + echo "==== WER w.r.t. real transcript (select based on true WER)" + ref_txt=$ref_data/$split/text + for x in $exp_root/*/${dec_name}_${split}*; do + lang=$(dirname $x)/$graph_name + + for tra in $x/scoring/*.tra; do + cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:<UNK>::g' | sed 's:<SIL>::g' | \ + compute-wer --text --mode=present \ + ark:$ref_txt ark,p:- 2> /dev/null | grep WER | xargs -I{} echo {} $tra + done | sort -k2n | head -n1 + done +fi + +exit 0; diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh new file mode 100755 index 0000000000000000000000000000000000000000..913c1d8e4357c146026b86e78f0b16f921776441 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/train_subset_lgbeam.sh @@ -0,0 +1,129 @@ +#!/usr/bin/env bash + +out_root=/tmp +out_name=train_${RANDOM} +num_nonsil_states=1 + +valid="dev_other" +train="train" +mono_size="-1" # 2000 +tri1_size="-1" # 5000 +tri2b_size="-1" # 10000 +tri3b_size="-1" # 10000 + +# Acoustic model parameters +numLeavesTri1=2000 +numGaussTri1=10000 +numLeavesMLLT=2500 +numGaussMLLT=15000 +numLeavesSAT=2500 +numGaussSAT=15000 + +stage=1 +max_stage=1 + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +data=$1 +lang=$2 +lang_test=$3 + +exp_root=$out_root/$out_name + +# you might not want to do this for interactive shells. +set -e + + +if [ $stage -le 1 ] && [ $max_stage -ge 1 ]; then + # train a monophone system + if [ ! $mono_size -eq -1 ]; then + utils/subset_data_dir.sh $data/$train $mono_size $data/${train}_${mono_size} + mono_train=${train}_${mono_size} + else + mono_train=${train} + fi + + steps/train_mono.sh --boost-silence 1.25 --nj 20 --cmd "$train_cmd" \ + --initial-beam 40 --regular-beam 60 --retry-beam 120 \ + $data/$mono_train $lang $exp_root/mono + + utils/mkgraph.sh $lang_test $exp_root/mono $exp_root/mono/graph + steps/decode.sh --nj 20 --cmd "$decode_cmd" \ + $exp_root/mono/graph $data/$valid $exp_root/mono/decode_$valid & +fi + + +if [ $stage -le 2 ] && [ $max_stage -ge 2 ]; then + # train a first delta + delta-delta triphone system on a subset of 5000 utterances + if [ ! $tri1_size -eq -1 ]; then + utils/subset_data_dir.sh $data/$train $tri1_size $data/${train}_${tri1_size} + tri1_train=${train}_${tri1_size} + else + tri1_train=${train} + fi + + steps/align_si.sh --boost-silence 1.25 --nj 10 --cmd "$train_cmd" \ + $data/$tri1_train $lang \ + $exp_root/mono $exp_root/mono_ali_${tri1_train} + + steps_gan/train_deltas.sh --boost-silence 1.25 --cmd "$train_cmd" \ + --num_nonsil_states $num_nonsil_states $numLeavesTri1 $numGaussTri1 \ + $data/$tri1_train $lang \ + $exp_root/mono_ali_${tri1_train} $exp_root/tri1 + + utils/mkgraph.sh $lang_test $exp_root/tri1 $exp_root/tri1/graph + steps/decode.sh --nj 20 --cmd "$decode_cmd" \ + $exp_root/tri1/graph $data/$valid $exp_root/tri1/decode_$valid & +fi + +if [ $stage -le 3 ] && [ $max_stage -ge 3 ]; then + # train an LDA+MLLT system. + if [ ! $tri2b_size -eq -1 ]; then + utils/subset_data_dir.sh $data/$train $tri2b_size $data/${train}_${tri2b_size} + tri2b_train=${train}_${tri2b_size} + else + tri2b_train=${train} + fi + + steps/align_si.sh --nj 10 --cmd "$train_cmd" \ + $data/$tri2b_train $lang \ + $exp_root/tri1 $exp_root/tri1_ali_${tri2b_train} + + steps_gan/train_lda_mllt.sh --cmd "$train_cmd" \ + --num_nonsil_states $num_nonsil_states \ + --splice-opts "--left-context=3 --right-context=3" $numLeavesMLLT $numGaussMLLT \ + $data/$tri2b_train $lang \ + $exp_root/tri1_ali_${tri2b_train} $exp_root/tri2b + + utils/mkgraph.sh $lang_test $exp_root/tri2b $exp_root/tri2b/graph + steps/decode.sh --nj 20 --cmd "$decode_cmd" \ + $exp_root/tri2b/graph $data/$valid $exp_root/tri2b/decode_$valid & +fi + + +if [ $stage -le 4 ] && [ $max_stage -ge 4 ]; then + # Train tri3b, which is LDA+MLLT+SAT on 10k utts + if [ ! $tri3b_size -eq -1 ]; then + utils/subset_data_dir.sh $data/$train $tri3b_size $data/${train}_${tri3b_size} + tri3b_train=${train}_${tri3b_size} + else + tri3b_train=${train} + fi + + steps/align_si.sh --nj 10 --cmd "$train_cmd" --use-graphs true \ + $data/$tri3b_train $lang \ + $exp_root/tri2b $exp_root/tri2b_ali_${tri2b_train} + + steps_gan/train_sat.sh --cmd "$train_cmd" \ + --num_nonsil_states $num_nonsil_states $numLeavesSAT $numGaussSAT \ + $data/$tri3b_train $lang \ + $exp_root/tri2b_ali_${tri2b_train} $exp_root/tri3b + + utils/mkgraph.sh $lang_test $exp_root/tri3b $exp_root/tri3b/graph + steps/decode_fmllr.sh --nj 20 --cmd "$decode_cmd" \ + $exp_root/tri3b/graph $data/$valid $exp_root/tri3b/decode_$valid & +fi + +wait diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py new file mode 100644 index 0000000000000000000000000000000000000000..1122c88c1964d8beead63bc8dfe21d41602b83bc --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select.py @@ -0,0 +1,135 @@ +""" +Implement unsupervised metric for decoding hyperparameter selection: + $$ alpha * LM_PPL + ViterbitUER(%) * 100 $$ +""" +import argparse +import logging +import math +import sys + +import kenlm +import editdistance +from g2p_en import G2p + +logging.root.setLevel(logging.INFO) +logging.basicConfig(stream=sys.stdout, level=logging.INFO) +logger = logging.getLogger(__name__) + + +def get_parser(): + parser = argparse.ArgumentParser() + parser.add_argument("ref_tra", help="reference pseudo labels") + parser.add_argument("hyp_tra", help="decoded pseudo labels to be assess") + parser.add_argument("--kenlm_path", default="/checkpoint/abaevski/data/speech/libri/librispeech_lm_novox.phnc_o5.bin", help="") + parser.add_argument("--uppercase", action="store_true", help="") + parser.add_argument("--skipwords", default="", help="") + parser.add_argument("--gt_tra", default="", help="ground truth pseudo labels for computing oracle WER") + parser.add_argument("--min_vt_uer", default=0.0, type=float) + parser.add_argument("--phonemize", action="store_true", help="phonemize word hypotheses, used when reference is phone transcript") + parser.add_argument("--phonemize_lexicon", default="", type=str, help="use a lexicon for phonemizing") + return parser + +def load_tra(tra_path): + with open(tra_path, "r") as f: + uid_to_tra = {} + for line in f: + toks = line.rstrip().split() + uid, tra = toks[0], " ".join(toks[1:]) + uid_to_tra[uid] = tra + logger.debug(f"loaded {len(uid_to_tra)} utterances from {tra_path}") + return uid_to_tra + +def load_lex(lex_path): + with open(lex_path, "r") as f: + w2p = {} + for line in f: + w, p = line.rstrip().split(None, 1) + w2p[w] = p.split() + return w2p + +def compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p, g2p_dict): + d_cnt = 0 + w_cnt = 0 + w_cnt_h = 0 + for uid in hyp_uid_to_tra: + ref = ref_uid_to_tra[uid].split() + if g2p_dict is not None: + hyp = [] + for word in hyp_uid_to_tra[uid].split(): + if word in g2p_dict: + hyp = hyp + g2p_dict[word] + else: + logger.warning(f"{word} not in g2p_dict") + elif g2p is not None: + hyp = g2p(hyp_uid_to_tra[uid]) + hyp = [p for p in hyp if p != "'" and p != " "] + hyp = [p[:-1] if p[-1].isnumeric() else p for p in hyp] + else: + hyp = hyp_uid_to_tra[uid].split() + logger.debug(( + f"======================\n" + f"HYP: {' '.join(hyp)}\n" + f"REF: {' '.join(ref)}" + )) + d_cnt += editdistance.eval(ref, hyp) + w_cnt += len(ref) + w_cnt_h += len(hyp) + wer = float(d_cnt) / w_cnt + logger.debug(( + f"wer = {wer*100:.2f}%; num. of ref words = {w_cnt}; " + f"num. of hyp words = {w_cnt_h}; num. of sentences = {len(ref_uid_to_tra)}" + )) + return wer + +def compute_lm_ppl(hyp_uid_to_tra, score_fn): + lm_score = 0. + w_cnt = 0 + for hyp in hyp_uid_to_tra.values(): + cur_score = score_fn(hyp) + cur_cnt = len(hyp.split()) + 1 # plus one for </s> + lm_score += cur_score + w_cnt += cur_cnt + logger.debug(( + f"======================\n" + f"score sum/avg = {cur_score:.2f}/{cur_score/cur_cnt:.2f}\n" + f"hyp = {hyp}" + )) + lm_ppl = math.pow(10, -lm_score / w_cnt) + logger.debug(f"lm ppl = {lm_ppl:.2f}; num. of words = {w_cnt}") + return lm_ppl + +def main(): + args = get_parser().parse_args() + logger.debug(f"Args: {args}") + + ref_uid_to_tra = load_tra(args.ref_tra) + hyp_uid_to_tra = load_tra(args.hyp_tra) + assert not bool(set(hyp_uid_to_tra.keys()) - set(ref_uid_to_tra.keys())) + + lm = kenlm.Model(args.kenlm_path) + skipwords = set(args.skipwords.split(",")) + def compute_lm_score(s): + s = " ".join(w for w in s.split() if w not in skipwords) + s = s.upper() if args.uppercase else s + return lm.score(s) + + g2p, g2p_dict = None, None + if args.phonemize: + if args.phonemize_lexicon: + g2p_dict = load_lex(args.phonemize_lexicon) + else: + g2p = G2p() + + wer = compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p, g2p_dict) + lm_ppl = compute_lm_ppl(hyp_uid_to_tra, compute_lm_score) + + gt_wer = -math.inf + if args.gt_tra: + gt_uid_to_tra = load_tra(args.gt_tra) + gt_wer = compute_wer(gt_uid_to_tra, hyp_uid_to_tra, None, None) + + score = math.log(lm_ppl) * max(wer, args.min_vt_uer) + logging.info(f"{args.hyp_tra}: score={score:.4f}; wer={wer*100:.2f}%; lm_ppl={lm_ppl:.4f}; gt_wer={gt_wer*100:.2f}%") + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode.sh new file mode 100755 index 0000000000000000000000000000000000000000..b34c5b6e0688914a53515162f817a93617b609e5 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode.sh @@ -0,0 +1,37 @@ +#!/bin/bash + +split="dev_other" +ref_txt="" # ground truth transcript path +psd_txt="" # pseudo transcript path +get_best_wer=true +dec_name="decode" +graph_name="graph" +kenlm_path=/checkpoint/abaevski/data/speech/libri/librispeech_lm_novox.phnc_o6.bin + +. ./cmd.sh +. ./path.sh +. parse_options.sh + +exp_root=$1 +unsup_args="" +if [ $# -ge 2 ]; then + unsup_args=$2 +fi + +set -eu + +if [ ! -z $ref_txt ] && $get_best_wer; then + echo "==== WER w.r.t. real transcript (select based on unsupervised metric)" + for x in $exp_root/*/${dec_name}_${split}*; do + lang=$(dirname $x)/$graph_name + + ( + for tra in $x/scoring/*.tra; do + cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:<UNK>::g' | sed 's:<SIL>::g' > $tra.txt + python local/unsup_select.py $psd_txt $tra.txt --kenlm_path $kenlm_path --gt_tra $ref_txt $unsup_args + done 2>/dev/null | grep "score=" | sed 's/=/ /g' | sed 's/;//g' | sort -k3n | head -n1 + ) & + done +fi +wait + diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode_word.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode_word.sh new file mode 100755 index 0000000000000000000000000000000000000000..c10a6b8809b77bca2b2c02df8b8702725bdd51c7 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/unsup_select_decode_word.sh @@ -0,0 +1,35 @@ +#!/bin/bash + +split="dev_other" +ref_txt="" # ground truth transcript path +psd_txt="" # pseudo transcript path +get_best_wer=true +dec_name="decode" +graph_name="graph" +kenlm_path=/checkpoint/abaevski/data/speech/libri/librispeech_lm_novox.phnc_o6.bin +phonemize_lexicon="" + +. ./cmd.sh +. ./path.sh +. parse_options.sh +. /private/home/wnhsu/unsup_asr/fairseq-py-unsup/env.sh + +exp_root=$1 + +set -eu + +if [ ! -z $ref_txt ] && $get_best_wer; then + echo "==== WER w.r.t. real transcript (select based on unsupervised metric)" + for x in $exp_root/*/${dec_name}_${split}*; do + lang=$(dirname $x)/$graph_name + + for tra in $x/scoring/*.tra; do + cat $tra | utils/int2sym.pl -f 2- $lang/words.txt | sed 's:\<UNK\>::g' > $tra.txt + python local/unsup_select.py $psd_txt $tra.txt \ + --kenlm_path $kenlm_path --gt_tra $ref_txt --phonemize \ + --phonemize_lexicon "$phonemize_lexicon" + done | grep "score=" | sed 's/=/ /g' | sed 's/;//g' | sort -k3n | head -n1 + done +fi + + diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/path.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/path.sh new file mode 100755 index 0000000000000000000000000000000000000000..1a6fb5f891b55d9fd978cfe54565f112f7eedce7 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/path.sh @@ -0,0 +1,5 @@ +export KALDI_ROOT=`pwd`/../../.. +export PATH=$PWD/utils/:$KALDI_ROOT/tools/openfst/bin:$PWD:$PATH +[ ! -f $KALDI_ROOT/tools/config/common_path.sh ] && echo >&2 "The standard file $KALDI_ROOT/tools/config/common_path.sh is not present -> Exit!" && exit 1 +. $KALDI_ROOT/tools/config/common_path.sh +export LC_ALL=C diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_deltas.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_deltas.sh new file mode 100755 index 0000000000000000000000000000000000000000..af68715ab0d87ae40666596d9d877d593684f8e2 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_deltas.sh @@ -0,0 +1,175 @@ +#!/usr/bin/env bash + +# Copyright 2012 Johns Hopkins University (Author: Daniel Povey) +# Apache 2.0 + +# Begin configuration. +stage=-4 # This allows restarting after partway, when something when wrong. +config= +cmd=run.pl +scale_opts="--transition-scale=1.0 --acoustic-scale=0.1 --self-loop-scale=0.1" +realign_iters="10 20 30"; +num_iters=35 # Number of iterations of training +max_iter_inc=25 # Last iter to increase #Gauss on. +beam=10 +careful=false +retry_beam=40 +boost_silence=1.0 # Factor by which to boost silence likelihoods in alignment +power=0.25 # Exponent for number of gaussians according to occurrence counts +cluster_thresh=-1 # for build-tree control final bottom-up clustering of leaves +norm_vars=false # deprecated. Prefer --cmvn-opts "--norm-vars=true" + # use the option --cmvn-opts "--norm-means=false" +cmvn_opts= +delta_opts= +context_opts= # use"--context-width=5 --central-position=2" for quinphone +num_nonsil_states=3 +# End configuration. + +echo "$0 $@" # Print the command line for logging + +[ -f path.sh ] && . ./path.sh; +. parse_options.sh || exit 1; + +if [ $# != 6 ]; then + echo "Usage: steps/train_deltas.sh <num-leaves> <tot-gauss> <data-dir> <lang-dir> <alignment-dir> <exp-dir>" + echo "e.g.: steps/train_deltas.sh 2000 10000 data/train_si84_half data/lang exp/mono_ali exp/tri1" + echo "main options (for others, see top of script file)" + echo " --cmd (utils/run.pl|utils/queue.pl <queue opts>) # how to run jobs." + echo " --config <config-file> # config containing options" + echo " --stage <stage> # stage to do partial re-run from." + exit 1; +fi + +numleaves=$1 +totgauss=$2 +data=$3 +lang=$4 +alidir=$5 +dir=$6 + +for f in $alidir/final.mdl $alidir/ali.1.gz $data/feats.scp $lang/phones.txt; do + [ ! -f $f ] && echo "train_deltas.sh: no such file $f" && exit 1; +done + +numgauss=$numleaves +incgauss=$[($totgauss-$numgauss)/$max_iter_inc] # per-iter increment for #Gauss +oov=`cat $lang/oov.int` || exit 1; +ciphonelist=`cat $lang/phones/context_indep.csl` || exit 1; +nj=`cat $alidir/num_jobs` || exit 1; +mkdir -p $dir/log +echo $nj > $dir/num_jobs + +utils/lang/check_phones_compatible.sh $lang/phones.txt $alidir/phones.txt || exit 1; +cp $lang/phones.txt $dir || exit 1; + +sdata=$data/split$nj; +split_data.sh $data $nj || exit 1; + + +[ $(cat $alidir/cmvn_opts 2>/dev/null | wc -c) -gt 1 ] && [ -z "$cmvn_opts" ] && \ + echo "$0: warning: ignoring CMVN options from source directory $alidir" +$norm_vars && cmvn_opts="--norm-vars=true $cmvn_opts" +echo $cmvn_opts > $dir/cmvn_opts # keep track of options to CMVN. +[ ! -z $delta_opts ] && echo $delta_opts > $dir/delta_opts + +feats="ark,s,cs:apply-cmvn $cmvn_opts --utt2spk=ark:$sdata/JOB/utt2spk scp:$sdata/JOB/cmvn.scp scp:$sdata/JOB/feats.scp ark:- | add-deltas $delta_opts ark:- ark:- |" + +rm $dir/.error 2>/dev/null + +if [ $stage -le -3 ]; then + echo "$0: accumulating tree stats" + $cmd JOB=1:$nj $dir/log/acc_tree.JOB.log \ + acc-tree-stats $context_opts \ + --ci-phones=$ciphonelist $alidir/final.mdl "$feats" \ + "ark:gunzip -c $alidir/ali.JOB.gz|" $dir/JOB.treeacc || exit 1; + sum-tree-stats $dir/treeacc $dir/*.treeacc 2>$dir/log/sum_tree_acc.log || exit 1; + rm $dir/*.treeacc +fi + +if [ $stage -le -2 ]; then + echo "$0: getting questions for tree-building, via clustering" + # preparing questions, roots file... + cluster-phones --pdf-class-list=$(($num_nonsil_states / 2)) $context_opts \ + $dir/treeacc $lang/phones/sets.int \ + $dir/questions.int 2> $dir/log/questions.log || exit 1; + cat $lang/phones/extra_questions.int >> $dir/questions.int + compile-questions $context_opts $lang/topo $dir/questions.int \ + $dir/questions.qst 2>$dir/log/compile_questions.log || exit 1; + + echo "$0: building the tree" + $cmd $dir/log/build_tree.log \ + build-tree $context_opts --verbose=1 --max-leaves=$numleaves \ + --cluster-thresh=$cluster_thresh $dir/treeacc $lang/phones/roots.int \ + $dir/questions.qst $lang/topo $dir/tree || exit 1; + + $cmd $dir/log/init_model.log \ + gmm-init-model --write-occs=$dir/1.occs \ + $dir/tree $dir/treeacc $lang/topo $dir/1.mdl || exit 1; + if grep 'no stats' $dir/log/init_model.log; then + echo "** The warnings above about 'no stats' generally mean you have phones **" + echo "** (or groups of phones) in your phone set that had no corresponding data. **" + echo "** You should probably figure out whether something went wrong, **" + echo "** or whether your data just doesn't happen to have examples of those **" + echo "** phones. **" + fi + + gmm-mixup --mix-up=$numgauss $dir/1.mdl $dir/1.occs $dir/1.mdl 2>$dir/log/mixup.log || exit 1; + rm $dir/treeacc +fi + +if [ $stage -le -1 ]; then + # Convert the alignments. + echo "$0: converting alignments from $alidir to use current tree" + $cmd JOB=1:$nj $dir/log/convert.JOB.log \ + convert-ali $alidir/final.mdl $dir/1.mdl $dir/tree \ + "ark:gunzip -c $alidir/ali.JOB.gz|" "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; +fi + +if [ $stage -le 0 ]; then + echo "$0: compiling graphs of transcripts" + $cmd JOB=1:$nj $dir/log/compile_graphs.JOB.log \ + compile-train-graphs --read-disambig-syms=$lang/phones/disambig.int $dir/tree $dir/1.mdl $lang/L.fst \ + "ark:utils/sym2int.pl --map-oov $oov -f 2- $lang/words.txt < $sdata/JOB/text |" \ + "ark:|gzip -c >$dir/fsts.JOB.gz" || exit 1; +fi + +x=1 +while [ $x -lt $num_iters ]; do + echo "$0: training pass $x" + if [ $stage -le $x ]; then + if echo $realign_iters | grep -w $x >/dev/null; then + echo "$0: aligning data" + mdl="gmm-boost-silence --boost=$boost_silence `cat $lang/phones/optional_silence.csl` $dir/$x.mdl - |" + $cmd JOB=1:$nj $dir/log/align.$x.JOB.log \ + gmm-align-compiled $scale_opts --beam=$beam --retry-beam=$retry_beam --careful=$careful "$mdl" \ + "ark:gunzip -c $dir/fsts.JOB.gz|" "$feats" \ + "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; + fi + $cmd JOB=1:$nj $dir/log/acc.$x.JOB.log \ + gmm-acc-stats-ali $dir/$x.mdl "$feats" \ + "ark,s,cs:gunzip -c $dir/ali.JOB.gz|" $dir/$x.JOB.acc || exit 1; + $cmd $dir/log/update.$x.log \ + gmm-est --mix-up=$numgauss --power=$power \ + --write-occs=$dir/$[$x+1].occs $dir/$x.mdl \ + "gmm-sum-accs - $dir/$x.*.acc |" $dir/$[$x+1].mdl || exit 1; + rm $dir/$x.mdl $dir/$x.*.acc + rm $dir/$x.occs + fi + [ $x -le $max_iter_inc ] && numgauss=$[$numgauss+$incgauss]; + x=$[$x+1]; +done + +rm $dir/final.mdl $dir/final.occs 2>/dev/null +ln -s $x.mdl $dir/final.mdl +ln -s $x.occs $dir/final.occs + +steps/diagnostic/analyze_alignments.sh --cmd "$cmd" $lang $dir + +# Summarize warning messages... +utils/summarize_warnings.pl $dir/log + +steps/info/gmm_dir_info.pl $dir + +echo "$0: Done training system with delta+delta-delta features in $dir" + +exit 0 diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_lda_mllt.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_lda_mllt.sh new file mode 100755 index 0000000000000000000000000000000000000000..9d8c319ce848e431ec47a3548156347ae3b50ced --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_lda_mllt.sh @@ -0,0 +1,239 @@ +#!/usr/bin/env bash + +# Copyright 2012 Johns Hopkins University (Author: Daniel Povey) +# +# LDA+MLLT refers to the way we transform the features after computing +# the MFCCs: we splice across several frames, reduce the dimension (to 40 +# by default) using Linear Discriminant Analysis), and then later estimate, +# over multiple iterations, a diagonalizing transform known as MLLT or STC. +# See http://kaldi-asr.org/doc/transform.html for more explanation. +# +# Apache 2.0. + +# Begin configuration. +cmd=run.pl +config= +stage=-5 +scale_opts="--transition-scale=1.0 --acoustic-scale=0.1 --self-loop-scale=0.1" +realign_iters="10 20 30"; +mllt_iters="2 4 6 12"; +num_iters=35 # Number of iterations of training +max_iter_inc=25 # Last iter to increase #Gauss on. +dim=40 +beam=10 +retry_beam=40 +careful=false +boost_silence=1.0 # Factor by which to boost silence likelihoods in alignment +power=0.25 # Exponent for number of gaussians according to occurrence counts +randprune=4.0 # This is approximately the ratio by which we will speed up the + # LDA and MLLT calculations via randomized pruning. +splice_opts= +cluster_thresh=-1 # for build-tree control final bottom-up clustering of leaves +norm_vars=false # deprecated. Prefer --cmvn-opts "--norm-vars=false" +cmvn_opts= +context_opts= # use "--context-width=5 --central-position=2" for quinphone. +# End configuration. +train_tree=true # if false, don't actually train the tree. +use_lda_mat= # If supplied, use this LDA[+MLLT] matrix. +num_nonsil_states=3 + +echo "$0 $@" # Print the command line for logging + +[ -f path.sh ] && . ./path.sh +. parse_options.sh || exit 1; + +if [ $# != 6 ]; then + echo "Usage: steps/train_lda_mllt.sh [options] <#leaves> <#gauss> <data> <lang> <alignments> <dir>" + echo " e.g.: steps/train_lda_mllt.sh 2500 15000 data/train_si84 data/lang exp/tri1_ali_si84 exp/tri2b" + echo "Main options (for others, see top of script file)" + echo " --cmd (utils/run.pl|utils/queue.pl <queue opts>) # how to run jobs." + echo " --config <config-file> # config containing options" + echo " --stage <stage> # stage to do partial re-run from." + exit 1; +fi + +numleaves=$1 +totgauss=$2 +data=$3 +lang=$4 +alidir=$5 +dir=$6 + +for f in $alidir/final.mdl $alidir/ali.1.gz $data/feats.scp $lang/phones.txt; do + [ ! -f $f ] && echo "train_lda_mllt.sh: no such file $f" && exit 1; +done + +numgauss=$numleaves +incgauss=$[($totgauss-$numgauss)/$max_iter_inc] # per-iter #gauss increment +oov=`cat $lang/oov.int` || exit 1; +nj=`cat $alidir/num_jobs` || exit 1; +silphonelist=`cat $lang/phones/silence.csl` || exit 1; +ciphonelist=`cat $lang/phones/context_indep.csl` || exit 1; + +mkdir -p $dir/log + +utils/lang/check_phones_compatible.sh $lang/phones.txt $alidir/phones.txt || exit 1; +cp $lang/phones.txt $dir || exit 1; + +echo $nj >$dir/num_jobs +echo "$splice_opts" >$dir/splice_opts # keep track of frame-splicing options + # so that later stages of system building can know what they were. + + +[ $(cat $alidir/cmvn_opts 2>/dev/null | wc -c) -gt 1 ] && [ -z "$cmvn_opts" ] && \ + echo "$0: warning: ignoring CMVN options from source directory $alidir" +$norm_vars && cmvn_opts="--norm-vars=true $cmvn_opts" +echo $cmvn_opts > $dir/cmvn_opts # keep track of options to CMVN. + +sdata=$data/split$nj; +split_data.sh $data $nj || exit 1; + +splicedfeats="ark,s,cs:apply-cmvn $cmvn_opts --utt2spk=ark:$sdata/JOB/utt2spk scp:$sdata/JOB/cmvn.scp scp:$sdata/JOB/feats.scp ark:- | splice-feats $splice_opts ark:- ark:- |" +# Note: $feats gets overwritten later in the script. +feats="$splicedfeats transform-feats $dir/0.mat ark:- ark:- |" + + + +if [ $stage -le -5 ]; then + if [ -z "$use_lda_mat" ]; then + echo "$0: Accumulating LDA statistics." + rm $dir/lda.*.acc 2>/dev/null + $cmd JOB=1:$nj $dir/log/lda_acc.JOB.log \ + ali-to-post "ark:gunzip -c $alidir/ali.JOB.gz|" ark:- \| \ + weight-silence-post 0.0 $silphonelist $alidir/final.mdl ark:- ark:- \| \ + acc-lda --rand-prune=$randprune $alidir/final.mdl "$splicedfeats" ark,s,cs:- \ + $dir/lda.JOB.acc || exit 1; + est-lda --write-full-matrix=$dir/full.mat --dim=$dim $dir/0.mat $dir/lda.*.acc \ + 2>$dir/log/lda_est.log || exit 1; + rm $dir/lda.*.acc + else + echo "$0: Using supplied LDA matrix $use_lda_mat" + cp $use_lda_mat $dir/0.mat || exit 1; + [ ! -z "$mllt_iters" ] && \ + echo "$0: Warning: using supplied LDA matrix $use_lda_mat but we will do MLLT," && \ + echo " which you might not want; to disable MLLT, specify --mllt-iters ''" && \ + sleep 5 + fi +fi + +cur_lda_iter=0 + +if [ $stage -le -4 ] && $train_tree; then + echo "$0: Accumulating tree stats" + $cmd JOB=1:$nj $dir/log/acc_tree.JOB.log \ + acc-tree-stats $context_opts \ + --ci-phones=$ciphonelist $alidir/final.mdl "$feats" \ + "ark:gunzip -c $alidir/ali.JOB.gz|" $dir/JOB.treeacc || exit 1; + [ `ls $dir/*.treeacc | wc -w` -ne "$nj" ] && echo "$0: Wrong #tree-accs" && exit 1; + $cmd $dir/log/sum_tree_acc.log \ + sum-tree-stats $dir/treeacc $dir/*.treeacc || exit 1; + rm $dir/*.treeacc +fi + + +if [ $stage -le -3 ] && $train_tree; then + echo "$0: Getting questions for tree clustering." + # preparing questions, roots file... + cluster-phones --pdf-class-list=$(($num_nonsil_states / 2)) $context_opts $dir/treeacc $lang/phones/sets.int \ + $dir/questions.int 2> $dir/log/questions.log || exit 1; + cat $lang/phones/extra_questions.int >> $dir/questions.int + compile-questions $context_opts $lang/topo $dir/questions.int \ + $dir/questions.qst 2>$dir/log/compile_questions.log || exit 1; + + echo "$0: Building the tree" + $cmd $dir/log/build_tree.log \ + build-tree $context_opts --verbose=1 --max-leaves=$numleaves \ + --cluster-thresh=$cluster_thresh $dir/treeacc $lang/phones/roots.int \ + $dir/questions.qst $lang/topo $dir/tree || exit 1; +fi + +if [ $stage -le -2 ]; then + echo "$0: Initializing the model" + if $train_tree; then + gmm-init-model --write-occs=$dir/1.occs \ + $dir/tree $dir/treeacc $lang/topo $dir/1.mdl 2> $dir/log/init_model.log || exit 1; + grep 'no stats' $dir/log/init_model.log && echo "This is a bad warning."; + rm $dir/treeacc + else + cp $alidir/tree $dir/ || exit 1; + $cmd JOB=1 $dir/log/init_model.log \ + gmm-init-model-flat $dir/tree $lang/topo $dir/1.mdl \ + "$feats subset-feats ark:- ark:-|" || exit 1; + fi +fi + + +if [ $stage -le -1 ]; then + # Convert the alignments. + echo "$0: Converting alignments from $alidir to use current tree" + $cmd JOB=1:$nj $dir/log/convert.JOB.log \ + convert-ali $alidir/final.mdl $dir/1.mdl $dir/tree \ + "ark:gunzip -c $alidir/ali.JOB.gz|" "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; +fi + +if [ $stage -le 0 ] && [ "$realign_iters" != "" ]; then + echo "$0: Compiling graphs of transcripts" + $cmd JOB=1:$nj $dir/log/compile_graphs.JOB.log \ + compile-train-graphs --read-disambig-syms=$lang/phones/disambig.int $dir/tree $dir/1.mdl $lang/L.fst \ + "ark:utils/sym2int.pl --map-oov $oov -f 2- $lang/words.txt < $data/split$nj/JOB/text |" \ + "ark:|gzip -c >$dir/fsts.JOB.gz" || exit 1; +fi + + +x=1 +while [ $x -lt $num_iters ]; do + echo Training pass $x + if echo $realign_iters | grep -w $x >/dev/null && [ $stage -le $x ]; then + echo Aligning data + mdl="gmm-boost-silence --boost=$boost_silence `cat $lang/phones/optional_silence.csl` $dir/$x.mdl - |" + $cmd JOB=1:$nj $dir/log/align.$x.JOB.log \ + gmm-align-compiled $scale_opts --beam=$beam --retry-beam=$retry_beam --careful=$careful "$mdl" \ + "ark:gunzip -c $dir/fsts.JOB.gz|" "$feats" \ + "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; + fi + if echo $mllt_iters | grep -w $x >/dev/null; then + if [ $stage -le $x ]; then + echo "$0: Estimating MLLT" + $cmd JOB=1:$nj $dir/log/macc.$x.JOB.log \ + ali-to-post "ark:gunzip -c $dir/ali.JOB.gz|" ark:- \| \ + weight-silence-post 0.0 $silphonelist $dir/$x.mdl ark:- ark:- \| \ + gmm-acc-mllt --rand-prune=$randprune $dir/$x.mdl "$feats" ark:- $dir/$x.JOB.macc \ + || exit 1; + est-mllt $dir/$x.mat.new $dir/$x.*.macc 2> $dir/log/mupdate.$x.log || exit 1; + gmm-transform-means $dir/$x.mat.new $dir/$x.mdl $dir/$x.mdl \ + 2> $dir/log/transform_means.$x.log || exit 1; + compose-transforms --print-args=false $dir/$x.mat.new $dir/$cur_lda_iter.mat $dir/$x.mat || exit 1; + rm $dir/$x.*.macc + fi + feats="$splicedfeats transform-feats $dir/$x.mat ark:- ark:- |" + cur_lda_iter=$x + fi + + if [ $stage -le $x ]; then + $cmd JOB=1:$nj $dir/log/acc.$x.JOB.log \ + gmm-acc-stats-ali $dir/$x.mdl "$feats" \ + "ark,s,cs:gunzip -c $dir/ali.JOB.gz|" $dir/$x.JOB.acc || exit 1; + $cmd $dir/log/update.$x.log \ + gmm-est --write-occs=$dir/$[$x+1].occs --mix-up=$numgauss --power=$power \ + $dir/$x.mdl "gmm-sum-accs - $dir/$x.*.acc |" $dir/$[$x+1].mdl || exit 1; + rm $dir/$x.mdl $dir/$x.*.acc $dir/$x.occs + fi + [ $x -le $max_iter_inc ] && numgauss=$[$numgauss+$incgauss]; + x=$[$x+1]; +done + +rm $dir/final.{mdl,mat,occs} 2>/dev/null +ln -s $x.mdl $dir/final.mdl +ln -s $x.occs $dir/final.occs +ln -s $cur_lda_iter.mat $dir/final.mat + +steps/diagnostic/analyze_alignments.sh --cmd "$cmd" $lang $dir + +# Summarize warning messages... +utils/summarize_warnings.pl $dir/log + +steps/info/gmm_dir_info.pl $dir + +echo "$0: Done training system with LDA+MLLT features in $dir" + +exit 0 diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_sat.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_sat.sh new file mode 100755 index 0000000000000000000000000000000000000000..f75afafb1c4ad04ee71ab8541064ab0477430616 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/steps_gan/train_sat.sh @@ -0,0 +1,281 @@ +#!/usr/bin/env bash +# Copyright 2012 Johns Hopkins University (Author: Daniel Povey). Apache 2.0. + + +# This does Speaker Adapted Training (SAT), i.e. train on +# fMLLR-adapted features. It can be done on top of either LDA+MLLT, or +# delta and delta-delta features. If there are no transforms supplied +# in the alignment directory, it will estimate transforms itself before +# building the tree (and in any case, it estimates transforms a number +# of times during training). + + +# Begin configuration section. +stage=-5 +exit_stage=-100 # you can use this to require it to exit at the + # beginning of a specific stage. Not all values are + # supported. +fmllr_update_type=full +cmd=run.pl +scale_opts="--transition-scale=1.0 --acoustic-scale=0.1 --self-loop-scale=0.1" +beam=10 +retry_beam=40 +careful=false +boost_silence=1.0 # Factor by which to boost silence likelihoods in alignment +context_opts= # e.g. set this to "--context-width 5 --central-position 2" for quinphone. +realign_iters="10 20 30"; +fmllr_iters="2 4 6 12"; +silence_weight=0.0 # Weight on silence in fMLLR estimation. +num_iters=35 # Number of iterations of training +max_iter_inc=25 # Last iter to increase #Gauss on. +power=0.2 # Exponent for number of gaussians according to occurrence counts +cluster_thresh=-1 # for build-tree control final bottom-up clustering of leaves +phone_map= +train_tree=true +tree_stats_opts= +cluster_phones_opts= +compile_questions_opts= +# End configuration section. +num_nonsil_states=3 + +echo "$0 $@" # Print the command line for logging + +[ -f path.sh ] && . ./path.sh +. parse_options.sh || exit 1; + +if [ $# != 6 ]; then + echo "Usage: steps/train_sat.sh <#leaves> <#gauss> <data> <lang> <ali-dir> <exp-dir>" + echo " e.g.: steps/train_sat.sh 2500 15000 data/train_si84 data/lang exp/tri2b_ali_si84 exp/tri3b" + echo "Main options (for others, see top of script file)" + echo " --cmd (utils/run.pl|utils/queue.pl <queue opts>) # how to run jobs." + echo " --config <config-file> # config containing options" + echo " --stage <stage> # stage to do partial re-run from." + exit 1; +fi + +numleaves=$1 +totgauss=$2 +data=$3 +lang=$4 +alidir=$5 +dir=$6 + +for f in $data/feats.scp $lang/phones.txt $alidir/final.mdl $alidir/ali.1.gz; do + [ ! -f $f ] && echo "train_sat.sh: no such file $f" && exit 1; +done + +numgauss=$numleaves +incgauss=$[($totgauss-$numgauss)/$max_iter_inc] # per-iter #gauss increment +oov=`cat $lang/oov.int` +nj=`cat $alidir/num_jobs` || exit 1; +silphonelist=`cat $lang/phones/silence.csl` +ciphonelist=`cat $lang/phones/context_indep.csl` || exit 1; +sdata=$data/split$nj; +splice_opts=`cat $alidir/splice_opts 2>/dev/null` # frame-splicing options. +cmvn_opts=`cat $alidir/cmvn_opts 2>/dev/null` +delta_opts=`cat $alidir/delta_opts 2>/dev/null` +phone_map_opt= +[ ! -z "$phone_map" ] && phone_map_opt="--phone-map='$phone_map'" + +mkdir -p $dir/log +cp $alidir/splice_opts $dir 2>/dev/null # frame-splicing options. +cp $alidir/cmvn_opts $dir 2>/dev/null # cmn/cmvn option. +cp $alidir/delta_opts $dir 2>/dev/null # delta option. + +utils/lang/check_phones_compatible.sh $lang/phones.txt $alidir/phones.txt || exit 1; +cp $lang/phones.txt $dir || exit 1; + +echo $nj >$dir/num_jobs +[[ -d $sdata && $data/feats.scp -ot $sdata ]] || split_data.sh $data $nj || exit 1; + +# Set up features. + +if [ -f $alidir/final.mat ]; then feat_type=lda; else feat_type=delta; fi +echo "$0: feature type is $feat_type" + +## Set up speaker-independent features. +case $feat_type in + delta) sifeats="ark,s,cs:apply-cmvn $cmvn_opts --utt2spk=ark:$sdata/JOB/utt2spk scp:$sdata/JOB/cmvn.scp scp:$sdata/JOB/feats.scp ark:- | add-deltas $delta_opts ark:- ark:- |";; + lda) sifeats="ark,s,cs:apply-cmvn $cmvn_opts --utt2spk=ark:$sdata/JOB/utt2spk scp:$sdata/JOB/cmvn.scp scp:$sdata/JOB/feats.scp ark:- | splice-feats $splice_opts ark:- ark:- | transform-feats $alidir/final.mat ark:- ark:- |" + cp $alidir/final.mat $dir + cp $alidir/full.mat $dir 2>/dev/null + ;; + *) echo "$0: invalid feature type $feat_type" && exit 1; +esac + +## Get initial fMLLR transforms (possibly from alignment dir) +if [ -f $alidir/trans.1 ]; then + echo "$0: Using transforms from $alidir" + feats="$sifeats transform-feats --utt2spk=ark:$sdata/JOB/utt2spk ark,s,cs:$alidir/trans.JOB ark:- ark:- |" + cur_trans_dir=$alidir +else + if [ $stage -le -5 ]; then + echo "$0: obtaining initial fMLLR transforms since not present in $alidir" + # The next line is necessary because of $silphonelist otherwise being incorrect; would require + # old $lang dir which would require another option. Not needed anyway. + [ ! -z "$phone_map" ] && \ + echo "$0: error: you must provide transforms if you use the --phone-map option." && exit 1; + $cmd JOB=1:$nj $dir/log/fmllr.0.JOB.log \ + ali-to-post "ark:gunzip -c $alidir/ali.JOB.gz|" ark:- \| \ + weight-silence-post $silence_weight $silphonelist $alidir/final.mdl ark:- ark:- \| \ + gmm-est-fmllr --fmllr-update-type=$fmllr_update_type \ + --spk2utt=ark:$sdata/JOB/spk2utt $alidir/final.mdl "$sifeats" \ + ark:- ark:$dir/trans.JOB || exit 1; + fi + feats="$sifeats transform-feats --utt2spk=ark:$sdata/JOB/utt2spk ark,s,cs:$dir/trans.JOB ark:- ark:- |" + cur_trans_dir=$dir +fi + +if [ $stage -le -4 ] && $train_tree; then + # Get tree stats. + echo "$0: Accumulating tree stats" + $cmd JOB=1:$nj $dir/log/acc_tree.JOB.log \ + acc-tree-stats $context_opts $tree_stats_opts $phone_map_opt --ci-phones=$ciphonelist $alidir/final.mdl "$feats" \ + "ark:gunzip -c $alidir/ali.JOB.gz|" $dir/JOB.treeacc || exit 1; + [ "`ls $dir/*.treeacc | wc -w`" -ne "$nj" ] && echo "$0: Wrong #tree-accs" && exit 1; + $cmd $dir/log/sum_tree_acc.log \ + sum-tree-stats $dir/treeacc $dir/*.treeacc || exit 1; + rm $dir/*.treeacc +fi + +if [ $stage -le -3 ] && $train_tree; then + echo "$0: Getting questions for tree clustering." + # preparing questions, roots file... + cluster-phones --pdf-class-list=$(($num_nonsil_states / 2)) \ + $cluster_phones_opts $context_opts \ + $dir/treeacc $lang/phones/sets.int $dir/questions.int 2>$dir/log/questions.log || exit 1; + cat $lang/phones/extra_questions.int >> $dir/questions.int + compile-questions $context_opts $compile_questions_opts $lang/topo $dir/questions.int $dir/questions.qst 2>$dir/log/compile_questions.log || exit 1; + + echo "$0: Building the tree" + $cmd $dir/log/build_tree.log \ + build-tree $context_opts --verbose=1 --max-leaves=$numleaves \ + --cluster-thresh=$cluster_thresh $dir/treeacc $lang/phones/roots.int \ + $dir/questions.qst $lang/topo $dir/tree || exit 1; +fi + +if [ $stage -le -2 ]; then + echo "$0: Initializing the model" + if $train_tree; then + gmm-init-model --write-occs=$dir/1.occs \ + $dir/tree $dir/treeacc $lang/topo $dir/1.mdl 2> $dir/log/init_model.log || exit 1; + grep 'no stats' $dir/log/init_model.log && echo "This is a bad warning."; + rm $dir/treeacc + else + cp $alidir/tree $dir/ || exit 1; + $cmd JOB=1 $dir/log/init_model.log \ + gmm-init-model-flat $dir/tree $lang/topo $dir/1.mdl \ + "$feats subset-feats ark:- ark:-|" || exit 1; + fi +fi + +if [ $stage -le -1 ]; then + # Convert the alignments. + echo "$0: Converting alignments from $alidir to use current tree" + $cmd JOB=1:$nj $dir/log/convert.JOB.log \ + convert-ali $phone_map_opt $alidir/final.mdl $dir/1.mdl $dir/tree \ + "ark:gunzip -c $alidir/ali.JOB.gz|" "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; +fi + +[ "$exit_stage" -eq 0 ] && echo "$0: Exiting early: --exit-stage $exit_stage" && exit 0; + +if [ $stage -le 0 ] && [ "$realign_iters" != "" ]; then + echo "$0: Compiling graphs of transcripts" + $cmd JOB=1:$nj $dir/log/compile_graphs.JOB.log \ + compile-train-graphs --read-disambig-syms=$lang/phones/disambig.int $dir/tree $dir/1.mdl $lang/L.fst \ + "ark:utils/sym2int.pl --map-oov $oov -f 2- $lang/words.txt < $sdata/JOB/text |" \ + "ark:|gzip -c >$dir/fsts.JOB.gz" || exit 1; +fi + +x=1 +while [ $x -lt $num_iters ]; do + echo Pass $x + if echo $realign_iters | grep -w $x >/dev/null && [ $stage -le $x ]; then + echo Aligning data + mdl="gmm-boost-silence --boost=$boost_silence `cat $lang/phones/optional_silence.csl` $dir/$x.mdl - |" + $cmd JOB=1:$nj $dir/log/align.$x.JOB.log \ + gmm-align-compiled $scale_opts --beam=$beam --retry-beam=$retry_beam --careful=$careful "$mdl" \ + "ark:gunzip -c $dir/fsts.JOB.gz|" "$feats" \ + "ark:|gzip -c >$dir/ali.JOB.gz" || exit 1; + fi + + if echo $fmllr_iters | grep -w $x >/dev/null; then + if [ $stage -le $x ]; then + echo Estimating fMLLR transforms + # We estimate a transform that's additional to the previous transform; + # we'll compose them. + $cmd JOB=1:$nj $dir/log/fmllr.$x.JOB.log \ + ali-to-post "ark:gunzip -c $dir/ali.JOB.gz|" ark:- \| \ + weight-silence-post $silence_weight $silphonelist $dir/$x.mdl ark:- ark:- \| \ + gmm-est-fmllr --fmllr-update-type=$fmllr_update_type \ + --spk2utt=ark:$sdata/JOB/spk2utt $dir/$x.mdl \ + "$feats" ark:- ark:$dir/tmp_trans.JOB || exit 1; + for n in `seq $nj`; do + ! ( compose-transforms --b-is-affine=true \ + ark:$dir/tmp_trans.$n ark:$cur_trans_dir/trans.$n ark:$dir/composed_trans.$n \ + && mv $dir/composed_trans.$n $dir/trans.$n && \ + rm $dir/tmp_trans.$n ) 2>$dir/log/compose_transforms.$x.log \ + && echo "$0: Error composing transforms" && exit 1; + done + fi + feats="$sifeats transform-feats --utt2spk=ark:$sdata/JOB/utt2spk ark:$dir/trans.JOB ark:- ark:- |" + cur_trans_dir=$dir + fi + + if [ $stage -le $x ]; then + $cmd JOB=1:$nj $dir/log/acc.$x.JOB.log \ + gmm-acc-stats-ali $dir/$x.mdl "$feats" \ + "ark,s,cs:gunzip -c $dir/ali.JOB.gz|" $dir/$x.JOB.acc || exit 1; + [ `ls $dir/$x.*.acc | wc -w` -ne "$nj" ] && echo "$0: Wrong #accs" && exit 1; + $cmd $dir/log/update.$x.log \ + gmm-est --power=$power --write-occs=$dir/$[$x+1].occs --mix-up=$numgauss $dir/$x.mdl \ + "gmm-sum-accs - $dir/$x.*.acc |" $dir/$[$x+1].mdl || exit 1; + rm $dir/$x.mdl $dir/$x.*.acc + rm $dir/$x.occs + fi + [ $x -le $max_iter_inc ] && numgauss=$[$numgauss+$incgauss]; + x=$[$x+1]; +done + + +if [ $stage -le $x ]; then + # Accumulate stats for "alignment model"-- this model is + # computed with the speaker-independent features, but matches Gaussian-for-Gaussian + # with the final speaker-adapted model. + $cmd JOB=1:$nj $dir/log/acc_alimdl.JOB.log \ + ali-to-post "ark:gunzip -c $dir/ali.JOB.gz|" ark:- \| \ + gmm-acc-stats-twofeats $dir/$x.mdl "$feats" "$sifeats" \ + ark,s,cs:- $dir/$x.JOB.acc || exit 1; + [ `ls $dir/$x.*.acc | wc -w` -ne "$nj" ] && echo "$0: Wrong #accs" && exit 1; + # Update model. + $cmd $dir/log/est_alimdl.log \ + gmm-est --power=$power --remove-low-count-gaussians=false $dir/$x.mdl \ + "gmm-sum-accs - $dir/$x.*.acc|" $dir/$x.alimdl || exit 1; + rm $dir/$x.*.acc +fi + +rm $dir/final.{mdl,alimdl,occs} 2>/dev/null +ln -s $x.mdl $dir/final.mdl +ln -s $x.occs $dir/final.occs +ln -s $x.alimdl $dir/final.alimdl + + +steps/diagnostic/analyze_alignments.sh --cmd "$cmd" $lang $dir + +utils/summarize_warnings.pl $dir/log +( + echo "$0: Likelihood evolution:" + for x in `seq $[$num_iters-1]`; do + tail -n 30 $dir/log/acc.$x.*.log | awk '/Overall avg like/{l += $(NF-3)*$(NF-1); t += $(NF-1); } + /Overall average logdet/{d += $(NF-3)*$(NF-1); t2 += $(NF-1);} + END{ d /= t2; l /= t; printf("%s ", d+l); } ' + done + echo +) | tee $dir/log/summary.log + + +steps/info/gmm_dir_info.pl $dir + +echo "$0: done training SAT system in $dir" + +exit 0 diff --git a/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/train.sh b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..f3a3d3fc7cc98a38d8e9d523a0b43c0c8ea51bf9 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/train.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +set -eu + +w2v_dir= # contains features `{train,valid}.{npy,lengths}`, real transcripts `{train,valid}.${label}`, and dict `dict.${label}.txt` +lab_dir= # contains pseudo labels `{train,valid}.txt` +out_dir= # output root +arpa_lm= # phone LM +arpa_lm_bin= # (binary) phone LM for KenLM, used in unsupervised selection + +label=phnc +train_name="train" +valid_name="valid" +data_dir=${out_dir}/data + +mkdir -p ${out_dir}/exp +local/prepare_lang.sh $w2v_dir/dict.${label}.txt $data_dir +local/prepare_lm.sh $arpa_lm $data_dir + +for x in $train_name $valid_name; do + x_gt=${x}_gt + + # prepare pseudo data + python local/prepare_data_from_w2v.py $w2v_dir $data_dir $x + steps/compute_cmvn_stats.sh $data_dir/$x $out_dir/exp/make_feat/$x $out_dir/feats/$x + python local/copy_aligned_text.py < $lab_dir/$x.txt > $data_dir/$x/text + + # prepare ground truth data + mkdir $data_dir/$x_gt + cp $data_dir/$x/{feats.scp,cmvn.scp,utt2spk,spk2utt} $data_dir/$x_gt/ + python local/copy_aligned_text.py < $w2v_dir/$x.$label > $data_dir/$x_gt/text +done + +local/train_subset_lgbeam.sh \ + --out_root ${out_dir} --out_name exp --train $train_name --valid $valid_name \ + --mono_size 2000 --tri1_size 5000 --tri2b_size -1 --tri3b_size -1 \ + --stage 1 --max_stage 3 $data_dir $data_dir/lang $data_dir/lang_test + +local/unsup_select_decode.sh \ + --split $valid_name --kenlm_path $arpa_lm_bin \ + --ref_txt $data_dir/${valid_name}_gt/text \ + --psd_txt $data_dir/${valid_name}/text \ + $out_dir/exp diff --git a/fairseq/examples/wav2vec/unsupervised/models/__init__.py b/fairseq/examples/wav2vec/unsupervised/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3e3039b7081a9e3228c8abefb6391a75b4864439 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/models/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .wav2vec_u import Wav2vec_U + + +__all__ = [ + "Wav2vec_U", +] diff --git a/fairseq/examples/wav2vec/unsupervised/models/wav2vec_u.py b/fairseq/examples/wav2vec/unsupervised/models/wav2vec_u.py new file mode 100644 index 0000000000000000000000000000000000000000..27792ebda842057e33fed3dc53dd9d8a594d0483 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/models/wav2vec_u.py @@ -0,0 +1,637 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +from enum import Enum, auto +import math +import numpy as np +from typing import Tuple, List, Optional, Dict + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch import autograd + +from fairseq import checkpoint_utils, utils +from fairseq.dataclass import FairseqDataclass +from fairseq.models import BaseFairseqModel, register_model +from fairseq.modules import ( + SamePad, + TransposeLast, +) + + +class SegmentationType(Enum): + NONE = auto() + RANDOM = auto() + UNIFORM_RANDOM = auto() + UNIFORM_RANDOM_JOIN = auto() + JOIN = auto() + + +@dataclass +class SegmentationConfig(FairseqDataclass): + type: SegmentationType = SegmentationType.NONE + subsample_rate: float = 0.25 + mean_pool: bool = True + mean_pool_join: bool = False + remove_zeros: bool = False + + +@dataclass +class Wav2vec_UConfig(FairseqDataclass): + + discriminator_kernel: int = 3 + discriminator_dilation: int = 1 + discriminator_dim: int = 256 + discriminator_causal: bool = True + discriminator_linear_emb: bool = False + discriminator_depth: int = 1 + discriminator_max_pool: bool = False + discriminator_act_after_linear: bool = False + discriminator_dropout: float = 0.0 + discriminator_spectral_norm: bool = False + discriminator_weight_norm: bool = False + + generator_kernel: int = 4 + generator_dilation: int = 1 + generator_stride: int = 1 + generator_bias: bool = False + generator_dropout: float = 0.0 + + blank_weight: float = 0 + blank_mode: str = "add" + blank_is_sil: bool = False + no_softmax: bool = False + + smoothness_weight: float = 0.0 + smoothing: float = 0.0 + smoothing_one_sided: bool = False + gradient_penalty: float = 0.0 + probabilistic_grad_penalty_slicing: bool = False + code_penalty: float = 0.0 + gumbel: bool = False + hard_gumbel: bool = True + temp: Tuple[float, float, float] = (2, 0.1, 0.99995) + input_dim: int = 128 + + segmentation: SegmentationConfig = SegmentationConfig() + + +class Segmenter(nn.Module): + cfg: SegmentationConfig + + def __init__(self, cfg: SegmentationConfig): + super().__init__() + self.cfg = cfg + self.subsample_rate = cfg.subsample_rate + + def pre_segment(self, dense_x, dense_padding_mask): + return dense_x, dense_padding_mask + + def logit_segment(self, logits, padding_mask): + return logits, padding_mask + + +class RandomSegmenter(Segmenter): + def pre_segment(self, dense_x, dense_padding_mask): + target_num = math.ceil(dense_x.size(1) * self.subsample_rate) + ones = torch.ones(dense_x.shape[:-1], device=dense_x.device) + indices, _ = ones.multinomial(target_num).sort(dim=-1) + indices_ld = indices.unsqueeze(-1).expand(-1, -1, dense_x.size(-1)) + dense_x = dense_x.gather(1, indices_ld) + dense_padding_mask = dense_padding_mask.gather(1, index=indices) + return dense_x, dense_padding_mask + + +class UniformRandomSegmenter(Segmenter): + def pre_segment(self, dense_x, dense_padding_mask): + bsz, tsz, fsz = dense_x.shape + + target_num = math.ceil(tsz * self.subsample_rate) + + rem = tsz % target_num + + if rem > 0: + dense_x = F.pad(dense_x, [0, 0, 0, target_num - rem]) + dense_padding_mask = F.pad( + dense_padding_mask, [0, target_num - rem], value=True + ) + + dense_x = dense_x.view(bsz, target_num, -1, fsz) + dense_padding_mask = dense_padding_mask.view(bsz, target_num, -1) + + if self.cfg.mean_pool: + dense_x = dense_x.mean(dim=-2) + dense_padding_mask = dense_padding_mask.all(dim=-1) + else: + ones = torch.ones((bsz, dense_x.size(2)), device=dense_x.device) + indices = ones.multinomial(1) + indices = indices.unsqueeze(-1).expand(-1, target_num, -1) + indices_ld = indices.unsqueeze(-1).expand(-1, -1, -1, fsz) + dense_x = dense_x.gather(2, indices_ld).reshape(bsz, -1, fsz) + dense_padding_mask = dense_padding_mask.gather(2, index=indices).reshape( + bsz, -1 + ) + return dense_x, dense_padding_mask + + +class JoinSegmenter(Segmenter): + def logit_segment(self, logits, padding_mask): + preds = logits.argmax(dim=-1) + + if padding_mask.any(): + preds[padding_mask] = -1 # mark pad + uniques = [] + + bsz, tsz, csz = logits.shape + + for p in preds: + uniques.append( + p.cpu().unique_consecutive(return_inverse=True, return_counts=True) + ) + + new_tsz = max(u[0].numel() for u in uniques) + new_logits = logits.new_zeros(bsz, new_tsz, csz) + new_pad = padding_mask.new_zeros(bsz, new_tsz) + + for b in range(bsz): + u, idx, c = uniques[b] + keep = u != -1 + + if self.cfg.remove_zeros: + keep.logical_and_(u != 0) + + if self.training and not self.cfg.mean_pool_join: + u[0] = 0 + u[1:] = c.cumsum(0)[:-1] + m = c > 1 + r = torch.rand(m.sum()) + o = (c[m] * r).long() + u[m] += o + new_logits[b, : u.numel()] = logits[b, u] + else: + new_logits[b].index_add_( + dim=0, index=idx.to(new_logits.device), source=logits[b] + ) + new_logits[b, : c.numel()] /= c.unsqueeze(-1).to(new_logits.device) + + new_sz = keep.sum() + if not keep.all(): + kept_logits = new_logits[b, : c.numel()][keep] + new_logits[b, :new_sz] = kept_logits + + if new_sz < new_tsz: + pad = new_tsz - new_sz + new_logits[b, -pad:] = 0 + new_pad[b, -pad:] = True + + return new_logits, new_pad + + +class UniformRandomJoinSegmenter(UniformRandomSegmenter, JoinSegmenter): + pass + + +SEGMENT_FACTORY = { + SegmentationType.NONE: Segmenter, + SegmentationType.RANDOM: RandomSegmenter, + SegmentationType.UNIFORM_RANDOM: UniformRandomSegmenter, + SegmentationType.UNIFORM_RANDOM_JOIN: UniformRandomJoinSegmenter, + SegmentationType.JOIN: JoinSegmenter, +} + + +class Discriminator(nn.Module): + def __init__(self, dim, cfg: Wav2vec_UConfig): + super().__init__() + + inner_dim = cfg.discriminator_dim + kernel = cfg.discriminator_kernel + dilation = cfg.discriminator_dilation + self.max_pool = cfg.discriminator_max_pool + + if cfg.discriminator_causal: + padding = kernel - 1 + else: + padding = kernel // 2 + + def make_conv(in_d, out_d, k, p=0, has_dilation=True): + conv = nn.Conv1d( + in_d, + out_d, + kernel_size=k, + padding=p, + dilation=dilation if has_dilation else 1, + ) + if cfg.discriminator_spectral_norm: + conv = nn.utils.spectral_norm(conv) + elif cfg.discriminator_weight_norm: + conv = nn.utils.weight_norm(conv) + return conv + + inner_net = [ + nn.Sequential( + make_conv(inner_dim, inner_dim, kernel, padding), + SamePad(kernel_size=kernel, causal=cfg.discriminator_causal), + nn.Dropout(cfg.discriminator_dropout), + nn.GELU(), + ) + for _ in range(cfg.discriminator_depth - 1) + ] + [ + make_conv(inner_dim, 1, kernel, padding, has_dilation=False), + SamePad(kernel_size=kernel, causal=cfg.discriminator_causal), + ] + + if cfg.discriminator_linear_emb: + emb_net = [make_conv(dim, inner_dim, 1)] + else: + emb_net = [ + make_conv(dim, inner_dim, kernel, padding), + SamePad(kernel_size=kernel, causal=cfg.discriminator_causal), + ] + + if cfg.discriminator_act_after_linear: + emb_net.append(nn.GELU()) + + self.net = nn.Sequential( + *emb_net, + nn.Dropout(cfg.discriminator_dropout), + *inner_net, + ) + + def forward(self, x, padding_mask): + x = x.transpose(1, 2) # BTC -> BCT + x = self.net(x) + x = x.transpose(1, 2) + x_sz = x.size(1) + if padding_mask is not None and padding_mask.any() and padding_mask.dim() > 1: + padding_mask = padding_mask[:, : x.size(1)] + x[padding_mask] = float("-inf") if self.max_pool else 0 + x_sz = x_sz - padding_mask.sum(dim=-1) + x = x.squeeze(-1) + if self.max_pool: + x, _ = x.max(dim=-1) + else: + x = x.sum(dim=-1) + x = x / x_sz + return x + + +class Generator(nn.Module): + def __init__(self, input_dim, output_dim, cfg: Wav2vec_UConfig): + super().__init__() + + self.cfg = cfg + self.output_dim = output_dim + self.stride = cfg.generator_stride + self.dropout = nn.Dropout(cfg.generator_dropout) + + padding = cfg.generator_kernel // 2 + self.proj = nn.Sequential( + TransposeLast(), + nn.Conv1d( + input_dim, + output_dim, + kernel_size=cfg.generator_kernel, + stride=cfg.generator_stride, + dilation=cfg.generator_dilation, + padding=padding, + bias=cfg.generator_bias, + ), + TransposeLast(), + ) + + def forward(self, dense_x, tokens, dense_padding_mask): + dense_x = self.dropout(dense_x) + + dense_x = self.proj(dense_x) + if self.stride > 1: + dense_padding_mask = dense_padding_mask[:, :: self.stride] + + if dense_padding_mask.size(1) != dense_x.size(1): + new_padding = dense_padding_mask.new_zeros(dense_x.shape[:-1]) + diff = new_padding.size(1) - dense_padding_mask.size(1) + assert ( + diff > 0 + ), f"{new_padding.shape}, {dense_padding_mask.shape}, {dense_x.shape}, {diff}" + if diff > 0: + new_padding[:, diff:] = dense_padding_mask + else: + assert diff < 0 + new_padding = dense_padding_mask[:, :diff] + + dense_padding_mask = new_padding + + result = {} + + token_x = None + if tokens is not None: + token_x = dense_x.new_zeros(tokens.numel(), self.output_dim) + token_x.scatter_(1, tokens.view(-1, 1).long(), 1) + token_x = token_x.view(tokens.shape + (self.output_dim,)) + + result["dense_x"] = dense_x + result["token_x"] = token_x + result["dense_padding_mask"] = dense_padding_mask + + return result + + +@register_model("wav2vec_u", dataclass=Wav2vec_UConfig) +class Wav2vec_U(BaseFairseqModel): + def calc_gradient_penalty(self, real_data, fake_data): + + b_size = min(real_data.size(0), fake_data.size(0)) + t_size = min(real_data.size(1), fake_data.size(1)) + + if self.cfg.probabilistic_grad_penalty_slicing: + + def get_slice(data, dim, target_size): + + size = data.size(dim) + diff = size - target_size + if diff <= 0: + return data + + start = np.random.randint(0, diff + 1) + return data.narrow(dim=dim, start=start, length=target_size) + + real_data = get_slice(real_data, 0, b_size) + real_data = get_slice(real_data, 1, t_size) + fake_data = get_slice(fake_data, 0, b_size) + fake_data = get_slice(fake_data, 1, t_size) + + else: + real_data = real_data[:b_size, :t_size] + fake_data = fake_data[:b_size, :t_size] + + alpha = torch.rand(real_data.size(0), 1, 1) + alpha = alpha.expand(real_data.size()) + alpha = alpha.to(real_data.device) + + interpolates = alpha * real_data + ((1 - alpha) * fake_data) + + disc_interpolates = self.discriminator(interpolates, None) + + gradients = autograd.grad( + outputs=disc_interpolates, + inputs=interpolates, + grad_outputs=torch.ones(disc_interpolates.size(), device=real_data.device), + create_graph=True, + retain_graph=True, + only_inputs=True, + )[0] + + gradient_penalty = (gradients.norm(2, dim=1) - 1) ** 2 + return gradient_penalty + + def set_num_updates(self, num_updates): + super().set_num_updates(num_updates) + self.update_num = num_updates + self.curr_temp = max( + self.max_temp * self.temp_decay ** num_updates, self.min_temp + ) + + def discrim_step(self, num_updates): + return num_updates % 2 == 1 + + def get_groups_for_update(self, num_updates): + return "discriminator" if self.discrim_step(num_updates) else "generator" + + def __init__(self, cfg: Wav2vec_UConfig, target_dict): + super().__init__() + + self.cfg = cfg + self.zero_index = target_dict.index("<SIL>") if "<SIL>" in target_dict else 0 + self.smoothness_weight = cfg.smoothness_weight + + output_size = len(target_dict) + self.pad = target_dict.pad() + self.eos = target_dict.eos() + self.smoothing = cfg.smoothing + self.smoothing_one_sided = cfg.smoothing_one_sided + self.no_softmax = cfg.no_softmax + self.gumbel = cfg.gumbel + self.hard_gumbel = cfg.hard_gumbel + self.last_acc = None + + self.gradient_penalty = cfg.gradient_penalty + self.code_penalty = cfg.code_penalty + self.blank_weight = cfg.blank_weight + self.blank_mode = cfg.blank_mode + self.blank_index = target_dict.index("<SIL>") if cfg.blank_is_sil else 0 + assert self.blank_index != target_dict.unk() + + self.discriminator = Discriminator(output_size, cfg) + for p in self.discriminator.parameters(): + p.param_group = "discriminator" + + self.pca_A = self.pca_b = None + d = cfg.input_dim + + self.segmenter = SEGMENT_FACTORY[cfg.segmentation.type](cfg.segmentation) + + self.generator = Generator(d, output_size, cfg) + + for p in self.generator.parameters(): + p.param_group = "generator" + + for p in self.segmenter.parameters(): + p.param_group = "generator" + + self.max_temp, self.min_temp, self.temp_decay = cfg.temp + self.curr_temp = self.max_temp + self.update_num = 0 + + @classmethod + def build_model(cls, cfg, task): + return cls(cfg, task.target_dictionary) + + def get_logits( + self, + net_output: Optional[Dict[str, List[Optional[torch.Tensor]]]], + normalize: bool = False, + ): + logits = net_output["logits"] + + if self.blank_weight != 0: + if self.blank_mode == "add": + logits[..., self.blank_index] += self.blank_weight + elif self.blank_mode == "set": + logits[..., self.blank_index] = self.blank_weight + else: + raise Exception(f"invalid blank mode {self.blank_mode}") + + padding = net_output["padding_mask"] + if padding.any(): + logits[padding] = float("-inf") + logits[padding][..., self.blank_index] = float("inf") + + if normalize: + logits = utils.log_softmax(logits.float(), dim=-1) + + return logits.transpose(0, 1) + + def get_normalized_probs( + self, + net_output: Tuple[ + torch.Tensor, Optional[Dict[str, List[Optional[torch.Tensor]]]] + ], + log_probs: bool, + sample: Optional[Dict[str, torch.Tensor]] = None, + ): + logits = self.get_logits(net_output) + + probs = super().get_normalized_probs(logits, log_probs, sample) + # BTC -> TBC for ctc + probs = probs.transpose(0, 1) + return probs + + def normalize(self, dense_x): + + bsz, tsz, csz = dense_x.shape + + if dense_x.numel() == 0: + raise Exception(dense_x.shape) + _, k = dense_x.max(-1) + hard_x = ( + dense_x.new_zeros(bsz * tsz, csz) + .scatter_(-1, k.view(-1, 1), 1.0) + .view(-1, csz) + ) + hard_probs = torch.mean(hard_x.float(), dim=0) + code_perplexity = torch.exp( + -torch.sum(hard_probs * torch.log(hard_probs + 1e-7), dim=-1) + ) + + avg_probs = torch.softmax(dense_x.reshape(-1, csz).float(), dim=-1).mean(dim=0) + prob_perplexity = torch.exp( + -torch.sum(avg_probs * torch.log(avg_probs + 1e-7), dim=-1) + ) + + if not self.no_softmax: + if self.training and self.gumbel: + dense_x = F.gumbel_softmax( + dense_x.float(), tau=self.curr_temp, hard=self.hard_gumbel + ).type_as(dense_x) + else: + dense_x = dense_x.softmax(-1) + + return dense_x, code_perplexity, prob_perplexity + + def forward( + self, + features, + padding_mask, + random_label=None, + dense_x_only=False, + segment=True, + ): + if segment: + features, padding_mask = self.segmenter.pre_segment(features, padding_mask) + + orig_size = features.size(0) * features.size(1) - padding_mask.sum() + + gen_result = self.generator(features, random_label, padding_mask) + + orig_dense_x, token_x = gen_result["dense_x"], gen_result["token_x"] + orig_dense_padding_mask = gen_result["dense_padding_mask"] + + if segment: + dense_x, dense_padding_mask = self.segmenter.logit_segment( + orig_dense_x, orig_dense_padding_mask + ) + else: + dense_x = orig_dense_x + dense_padding_mask = orig_dense_padding_mask + + dense_logits = dense_x + prob_perplexity = None + code_perplexity = None + + if not (self.no_softmax and dense_x_only): + dense_x, code_perplexity, prob_perplexity = self.normalize(dense_logits) + + if dense_x_only or self.discriminator is None: + return { + "logits": dense_x, + "padding_mask": dense_padding_mask, + } + + token_padding_mask = random_label == self.pad + + dense_y = self.discriminator(dense_x, dense_padding_mask) + token_y = self.discriminator(token_x, token_padding_mask) + + sample_size = features.size(0) + + d_step = self.discrim_step(self.update_num) + + fake_smooth = self.smoothing + real_smooth = self.smoothing + if self.smoothing_one_sided: + fake_smooth = 0 + + zero_loss = None + smoothness_loss = None + code_pen = None + + if d_step: + loss_dense = F.binary_cross_entropy_with_logits( + dense_y, + dense_y.new_ones(dense_y.shape) - fake_smooth, + reduction="sum", + ) + loss_token = F.binary_cross_entropy_with_logits( + token_y, + token_y.new_zeros(token_y.shape) + real_smooth, + reduction="sum", + ) + if self.training and self.gradient_penalty > 0: + grad_pen = self.calc_gradient_penalty(token_x, dense_x) + grad_pen = grad_pen.sum() * self.gradient_penalty + else: + grad_pen = None + else: + grad_pen = None + loss_token = None + loss_dense = F.binary_cross_entropy_with_logits( + dense_y, + dense_y.new_zeros(dense_y.shape) + fake_smooth, + reduction="sum", + ) + num_vars = dense_x.size(-1) + if prob_perplexity is not None: + code_pen = (num_vars - prob_perplexity) / num_vars + code_pen = code_pen * sample_size * self.code_penalty + + if self.smoothness_weight > 0: + smoothness_loss = F.mse_loss( + dense_logits[:, :-1], dense_logits[:, 1:], reduction="none" + ) + smoothness_loss[dense_padding_mask[:, 1:]] = 0 + smoothness_loss = ( + smoothness_loss.mean() * sample_size * self.smoothness_weight + ) + + result = { + "losses": { + "grad_pen": grad_pen, + "code_pen": code_pen, + "smoothness": smoothness_loss, + }, + "temp": self.curr_temp, + "code_ppl": code_perplexity, + "prob_ppl": prob_perplexity, + "d_steps": int(d_step), + "sample_size": sample_size, + } + + suff = "_d" if d_step else "_g" + result["losses"]["dense" + suff] = loss_dense + result["losses"]["token" + suff] = loss_token + + return result diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/apply_pca.py b/fairseq/examples/wav2vec/unsupervised/scripts/apply_pca.py new file mode 100644 index 0000000000000000000000000000000000000000..10ad6ce47cfdf0a87ba089b299fe9551b29fa167 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/apply_pca.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import math +import numpy as np +import tqdm +import torch +from shutil import copyfile + +from npy_append_array import NpyAppendArray + + +def get_parser(): + parser = argparse.ArgumentParser( + description="transforms features via a given pca and stored them in target dir" + ) + # fmt: off + parser.add_argument('source', help='directory with features') + parser.add_argument('--split', help='which split to read', required=True) + parser.add_argument('--save-dir', help='where to save the output', required=True) + parser.add_argument('--pca-path', type=str, help='pca location. will append _A.npy and _b.npy', required=True) + parser.add_argument('--batch-size', type=int, default=2048000, help='batch size') + parser.add_argument('--unfiltered', action='store_true', help='process the unfiltered version') + # fmt: on + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + source_path = osp.join(args.source, args.split) + data_poth = source_path + "_unfiltered" if args.unfiltered else source_path + + print(f"data path: {data_poth}") + + features = np.load(data_poth + ".npy", mmap_mode="r") + pca_A = torch.from_numpy(np.load(args.pca_path + "_A.npy")).cuda() + pca_b = torch.from_numpy(np.load(args.pca_path + "_b.npy")).cuda() + + os.makedirs(args.save_dir, exist_ok=True) + save_path = osp.join(args.save_dir, args.split) + + copyfile(source_path + ".tsv", save_path + ".tsv") + copyfile(data_poth + ".lengths", save_path + ".lengths") + + if osp.exists(source_path + ".phn"): + copyfile(source_path + ".phn", save_path + ".phn") + + if osp.exists(source_path + ".wrd"): + copyfile(source_path + ".wrd", save_path + ".wrd") + + if osp.exists(save_path + ".npy"): + os.remove(save_path + ".npy") + npaa = NpyAppendArray(save_path + ".npy") + + batches = math.ceil(features.shape[0] / args.batch_size) + + with torch.no_grad(): + for b in tqdm.trange(batches): + start = b * args.batch_size + end = start + args.batch_size + x = torch.from_numpy(features[start:end]).cuda() + x = torch.matmul(x, pca_A) + pca_b + npaa.append(x.cpu().numpy()) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/copy_labels.py b/fairseq/examples/wav2vec/unsupervised/scripts/copy_labels.py new file mode 100644 index 0000000000000000000000000000000000000000..989868388eefccc37c82d7602f709632035c7aa1 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/copy_labels.py @@ -0,0 +1,10 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + +for idx, line in enumerate(sys.stdin): + print(f"utt{idx:010d} {line}", end="") diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/filter_lexicon.py b/fairseq/examples/wav2vec/unsupervised/scripts/filter_lexicon.py new file mode 100644 index 0000000000000000000000000000000000000000..5bf3e51e7a50ac3f07cc41739198cde946dc79aa --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/filter_lexicon.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import sys + +from fairseq.data import Dictionary + + +def get_parser(): + parser = argparse.ArgumentParser( + description="filters a lexicon given a unit dictionary" + ) + parser.add_argument("-d", "--unit-dict", help="unit dictionary", required=True) + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + d = Dictionary.load(args.unit_dict) + symbols = set(d.symbols) + + for line in sys.stdin: + items = line.rstrip().split() + skip = len(items) < 2 + for x in items[1:]: + if x not in symbols: + skip = True + break + if not skip: + print(line, end="") + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/filter_tsv.py b/fairseq/examples/wav2vec/unsupervised/scripts/filter_tsv.py new file mode 100644 index 0000000000000000000000000000000000000000..a09d79acf31414ea3eae82db59cf9f105aefcdf1 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/filter_tsv.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import argparse +import sys + + +parser = argparse.ArgumentParser() +parser.add_argument("--tsv", required=True, type=str) +parser.add_argument("--no-skip", action="store_true") +parser.add_argument("--keep", action="store_true") +params = parser.parse_args() + + +def get_fname(line): + p = os.path.basename(line.split("\t")[0]) + p = os.path.splitext(p)[0] + return p + + +# filenames to exclude +seen = set() +with open(params.tsv) as f: + if not params.no_skip: + root = next(f).rstrip() + for line in f: + seen.add(get_fname(line)) + +for i, line in enumerate(sys.stdin): + exists = get_fname(line) in seen + keep = (exists and params.keep) or (not exists and not params.keep) + if i == 0 or keep: + print(line, end="") diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/g2p_wrd_to_phn.py b/fairseq/examples/wav2vec/unsupervised/scripts/g2p_wrd_to_phn.py new file mode 100644 index 0000000000000000000000000000000000000000..2e31c307bd67d10941150160c7fb8c9e085ac5d9 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/g2p_wrd_to_phn.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import sys + +from g2p_en import G2p + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--compact", + action="store_true", + help="if set, compacts phones", + ) + args = parser.parse_args() + + compact = args.compact + + wrd_to_phn = {} + g2p = G2p() + for line in sys.stdin: + words = line.strip().split() + phones = [] + for w in words: + if w not in wrd_to_phn: + wrd_to_phn[w] = g2p(w) + if compact: + wrd_to_phn[w] = [ + p[:-1] if p[-1].isnumeric() else p for p in wrd_to_phn[w] + ] + phones.extend(wrd_to_phn[w]) + try: + print(" ".join(phones)) + except: + print(wrd_to_phn, words, phones, file=sys.stderr) + raise + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/ltr_to_wrd.py b/fairseq/examples/wav2vec/unsupervised/scripts/ltr_to_wrd.py new file mode 100644 index 0000000000000000000000000000000000000000..36c85d1e2f60487494a92207feb4685e78db8aa2 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/ltr_to_wrd.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + + +def main(): + for line in sys.stdin: + print(line.replace(" ", "").replace("|", " ").strip()) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/mean_pool.py b/fairseq/examples/wav2vec/unsupervised/scripts/mean_pool.py new file mode 100644 index 0000000000000000000000000000000000000000..4eea048ef3455cb3c897e74c18778c78fdc9fcbf --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/mean_pool.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import math +import numpy as np +import tqdm +import torch +import torch.nn.functional as F +from shutil import copyfile + +from npy_append_array import NpyAppendArray + + +def get_parser(): + parser = argparse.ArgumentParser( + description="mean pools representations by compressing uniform splits of the data" + ) + # fmt: off + parser.add_argument('source', help='directory with features') + parser.add_argument('--split', help='which split to read', required=True) + parser.add_argument('--save-dir', help='where to save the output', required=True) + parser.add_argument('--subsample-rate', type=float, default=0.5, help='size to subsample data to') + + parser.add_argument('--remove-extra', action='store_true', help='if true, removes extra states that cant be pooled, otherwise pads with 0s') + # fmt: on + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + source_path = osp.join(args.source, args.split) + + print(f"data path: {source_path}") + + features = np.load(source_path + ".npy", mmap_mode="r") + + os.makedirs(args.save_dir, exist_ok=True) + save_path = osp.join(args.save_dir, args.split) + + copyfile(source_path + ".tsv", save_path + ".tsv") + + if os.path.exists(source_path + ".phn"): + copyfile(source_path + ".phn", save_path + ".phn") + if os.path.exists(source_path + ".wrd"): + copyfile(source_path + ".wrd", save_path + ".wrd") + + if os.path.exists(osp.join(args.source, "dict.phn.txt")): + copyfile( + osp.join(args.source, "dict.phn.txt"), + osp.join(args.save_dir, "dict.phn.txt"), + ) + + if osp.exists(save_path + ".npy"): + os.remove(save_path + ".npy") + npaa = NpyAppendArray(save_path + ".npy") + + with open(source_path + ".lengths", "r") as lf: + lengths = lf.readlines() + + fsz = features.shape[-1] + start = 0 + with torch.no_grad(): + with open(save_path + ".lengths", "w") as lengths_out: + for length in tqdm.tqdm(lengths): + length = int(length) + end = start + length + feats = features[start:end] + start += length + x = torch.from_numpy(feats).cuda() + target_num = math.ceil(length * args.subsample_rate) + rem = length % target_num + + if rem > 0: + if args.remove_extra: + to_rem = target_num - rem + target_num -= 1 + x = x[:-to_rem] + else: + to_add = target_num - rem + x = F.pad(x, [0, 0, 0, to_add]) + x[-to_add:] = x[-to_add - 1] + + x = x.view(target_num, -1, fsz) + x = x.mean(dim=-2) + print(target_num, file=lengths_out) + npaa.append(x.cpu().numpy()) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/merge_clusters.py b/fairseq/examples/wav2vec/unsupervised/scripts/merge_clusters.py new file mode 100644 index 0000000000000000000000000000000000000000..2780f9d971d847b3ad0b59e9a33780553ebce902 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/merge_clusters.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import numpy as np +import tqdm +import torch +import random +from shutil import copyfile + +from npy_append_array import NpyAppendArray + + +def get_parser(): + parser = argparse.ArgumentParser( + description="transforms features via a given pca and stored them in target dir" + ) + # fmt: off + parser.add_argument('source', help='directory with features') + parser.add_argument('--split', help='which split to read', required=True) + parser.add_argument('--save-dir', help='where to save the output', required=True) + parser.add_argument('--cluster-dir', help='where the clusters are') + parser.add_argument('--pooling', type=str, default='mean', choices=['mean', 'sample'], help='how to pool') + # fmt: on + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + source_path = osp.join(args.source, args.split) + cluster_path = osp.join(args.cluster_dir, args.split + ".src") + print(f"data path: {source_path}") + + features = np.load(source_path + ".npy", mmap_mode="r") + sizes = [] + offsets = [] + offset = 0 + with open(source_path + ".lengths", "r") as len_f: + for line in len_f: + length = int(line.rstrip()) + sizes.append(length) + offsets.append(offset) + offset += length + + clusters = [] + with open(cluster_path, "r") as cf: + for line in cf: + line = line.rstrip() + items = line.split() + items = list(map(int, items)) + clusters.append(items) + + os.makedirs(args.save_dir, exist_ok=True) + save_path = osp.join(args.save_dir, args.split) + + copyfile(source_path + ".tsv", save_path + ".tsv") + + if os.path.exists(source_path + ".phn"): + copyfile(source_path + ".phn", save_path + ".phn") + if os.path.exists(osp.join(args.source, "dict.phn.txt")): + copyfile( + osp.join(args.source, "dict.phn.txt"), + osp.join(args.save_dir, "dict.phn.txt"), + ) + if os.path.exists(source_path + ".wrd"): + copyfile(source_path + ".wrd", save_path + ".wrd") + + if osp.exists(save_path + ".npy"): + os.remove(save_path + ".npy") + npaa = NpyAppendArray(save_path + ".npy") + + def merge(feats, clust): + feats = torch.from_numpy(feats.copy()) + clust = torch.LongTensor(clust) + _, counts = clust.unique_consecutive(return_counts=True) + curr = 0 + + merged = [] + for c in counts: + c = c.item() + start = curr + end = curr + c + curr += c + if args.pooling == "mean": + new_x = feats[start:end].mean(dim=0) + elif args.pooling == "sample": + new_x = feats[start + int(random.random() * c)] + else: + raise NotImplementedError() + merged.append(new_x) + + return torch.stack(merged, dim=0).numpy() + + with open(save_path + ".lengths", "w") as l_f: + for size, offset, clust in tqdm.tqdm( + zip(sizes, offsets, clusters), total=len(sizes) + ): + end = size + offset + feats = features[offset:end] + feats = merge(feats, clust) + print(len(feats), file=l_f) + npaa.append(feats) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/normalize_and_filter_text.py b/fairseq/examples/wav2vec/unsupervised/scripts/normalize_and_filter_text.py new file mode 100644 index 0000000000000000000000000000000000000000..c2bd16efb530af5af3f72ab0edb3044b4e9fcd5c --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/normalize_and_filter_text.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import fasttext as ft +import os +import regex +import sys + + +def get_parser(): + parser = argparse.ArgumentParser( + description="reads text from stdin and outputs normalized, lid-filtered version to stdout" + ) + parser.add_argument( + "--fasttext-model", + help="path to fasttext model", + default="lid.187.bin", + ) + parser.add_argument("--lang", help="language id", required=True) + parser.add_argument( + "--lid-threshold", + type=float, + help="threshold for this lang id probability", + default=0.4, + ) + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + filter_r = regex.compile(r"[^\p{L}\p{N}\p{M}\' \-]") + + lg = args.lang.lower() + lg_label = f"__label__{lg}" + thresh = args.lid_threshold + + if os.path.exists(args.fasttext_model): + model = ft.load_model(args.fasttext_model) + else: + print( + f"fasttext language id model {args.fasttext_model} not found. Proceeding without language filtering. " + f"To enable language filtering, please download the latest language id model " + f"from https://fasttext.cc/docs/en/language-identification.html", + file=sys.stderr, + ) + model = None + + for line in sys.stdin: + line = line.strip() + line = filter_r.sub(" ", line) + line = " ".join(line.split()) + + if model is not None: + lid, prob = model.predict(line, k=100) + try: + target_idx = lid.index(lg_label) + except ValueError: + continue + if target_idx == 0 or prob[target_idx] >= thresh: + print(line) + else: + print(line) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py b/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py new file mode 100644 index 0000000000000000000000000000000000000000..9d0ffeb27d038a6b82aaf0f6bdf208af565663f6 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/normalize_text.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import regex +import sys + + +def main(): + filter_r = regex.compile(r"[^\p{L}\p{N}\p{M}\' \-]") + + for line in sys.stdin: + line = line.strip() + line = filter_r.sub(" ", line) + line = " ".join(line.split()) + print(line) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/pca.py b/fairseq/examples/wav2vec/unsupervised/scripts/pca.py new file mode 100644 index 0000000000000000000000000000000000000000..948cf5319fd86ba1bccff65270b2881048faf9b1 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/pca.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import numpy as np + +import faiss + + + +def get_parser(): + parser = argparse.ArgumentParser( + description="compute a pca matrix given an array of numpy features" + ) + # fmt: off + parser.add_argument('data', help='numpy file containing features') + parser.add_argument('--output', help='where to save the pca matrix', required=True) + parser.add_argument('--dim', type=int, help='dim for pca reduction', required=True) + parser.add_argument('--eigen-power', type=float, default=0, help='eigen power, -0.5 for whitening') + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + print("Reading features") + x = np.load(args.data, mmap_mode="r") + + print("Computing PCA") + pca = faiss.PCAMatrix(x.shape[-1], args.dim, args.eigen_power) + pca.train(x) + b = faiss.vector_to_array(pca.b) + A = faiss.vector_to_array(pca.A).reshape(pca.d_out, pca.d_in) + + os.makedirs(args.output, exist_ok=True) + + prefix = str(args.dim) + if args.eigen_power != 0: + prefix += f"_{args.eigen_power}" + + np.save(osp.join(args.output, f"{prefix}_pca_A"), A.T) + np.save(osp.join(args.output, f"{prefix}_pca_b"), b) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py b/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py new file mode 100644 index 0000000000000000000000000000000000000000..c6512d7322def67b27aba46e9e36da171db6963b --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import numpy as np +import sys + + +def get_parser(): + parser = argparse.ArgumentParser( + description="converts words to phones adding optional silences around in between words" + ) + parser.add_argument( + "--sil-prob", + "-s", + type=float, + default=0, + help="probability of inserting silence between each word", + ) + parser.add_argument( + "--surround", + action="store_true", + help="if set, surrounds each example with silence", + ) + parser.add_argument( + "--lexicon", + help="lexicon to convert to phones", + required=True, + ) + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + sil_prob = args.sil_prob + surround = args.surround + sil = "<SIL>" + + wrd_to_phn = {} + + with open(args.lexicon, "r") as lf: + for line in lf: + items = line.rstrip().split() + assert len(items) > 1, line + assert items[0] not in wrd_to_phn, items + wrd_to_phn[items[0]] = items[1:] + + for line in sys.stdin: + words = line.strip().split() + + if not all(w in wrd_to_phn for w in words): + continue + + phones = [] + if surround: + phones.append(sil) + + sample_sil_probs = None + if sil_prob > 0 and len(words) > 1: + sample_sil_probs = np.random.random(len(words) - 1) + + for i, w in enumerate(words): + phones.extend(wrd_to_phn[w]) + if ( + sample_sil_probs is not None + and i < len(sample_sil_probs) + and sample_sil_probs[i] < sil_prob + ): + phones.append(sil) + + if surround: + phones.append(sil) + print(" ".join(phones)) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/prepare_audio.sh b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_audio.sh new file mode 100644 index 0000000000000000000000000000000000000000..013f7a9b055a7693a29f9c5ba1e4003a9a25850e --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_audio.sh @@ -0,0 +1,78 @@ +#!/usr/bin/env zsh +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +source_dir=$1 +tgt_dir=$2 +model=$3 + +if [ -z "$4" ] + then + dim=512 + else + dim=$4 +fi + +echo "using $dim dim for PCA" + +if [ -z "$5" ] + then + layer=14 + else + layer=$5 +fi + +echo "extracting from layer $layer" + +train_split=train +valid_split=valid +test_split=test + +all_splits=($train_split) + +if [[ -f "$source_dir/valid.tsv" ]]; then + all_splits+=('valid') +fi + +if [[ -f "$source_dir/test.tsv" ]]; then + all_splits+=('test') +fi + +echo "processing splits: $all_splits" + +mkdir -p $tgt_dir + +cp $source_dir/*.tsv $tgt_dir +cp $source_dir/*.wrd $tgt_dir +cp $source_dir/*.ltr $tgt_dir +cp $source_dir/*.phn $tgt_dir +cp $source_dir/dict* $tgt_dir + +setopt shwordsplit + +for split in $all_splits; do + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/wav2vec_extract_features.py $source_dir --split $split \ + --save-dir $tgt_dir --checkpoint $model --layer $layer +done + +python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/wav2vec_cluster_faiss.py $tgt_dir/${train_split}.tsv \ +--checkpoint $model --save-dir $tgt_dir -f "CLUS128" --sample-pct 1.0 + +for split in $all_splits; do + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/wav2vec_apply_cluster_faiss.py $tgt_dir \ + --checkpoint $model --path $tgt_dir/CLUS128 --split $split +done + +python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/pca.py $tgt_dir/${train_split}.npy --output $tgt_dir/pca --dim $dim + +for split in $all_splits; do + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/apply_pca.py $tgt_dir --split $split --save-dir $tgt_dir/precompute_pca$dim --pca-path $tgt_dir/pca/${dim}_pca --batch-size 1048000 + + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/merge_clusters.py $tgt_dir/precompute_pca$dim --cluster-dir $tgt_dir/CLUS128 \ + --split $split --save-dir $tgt_dir/precompute_pca${dim}_cls128_mean --pooling mean + + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/mean_pool.py $tgt_dir/precompute_pca${dim}_cls128_mean \ + --save-dir $tgt_dir/precompute_pca${dim}_cls128_mean_pooled --split $split +done diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/prepare_text.sh b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_text.sh new file mode 100644 index 0000000000000000000000000000000000000000..1caf13cb6a2a0bd84e5322c92124b2fa37368f9a --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_text.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env zsh +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +lg=$1 +text_path=$2 +target_dir=$3 +min_phones=$4 +phonemizer=$5 +lid_path=$6 + +if [ -z "$lid_path" ]; then + lid_path="lid.187.bin" +fi + +ph_lg=${lg:l} +if test "$lg" = 'fr'; then + ph_lg='fr-fr' +elif test "$lg" = 'en'; then + ph_lg='en-us' +elif test "$lg" = 'pt'; then + ph_lg='pt-br' +fi + +ESPEAK_PATH='' +if test "$phonemizer" = 'espeak'; then + ESPEAK_PATH=$(which espeak) +elif test "$phonemizer" = 'espeak-ng'; then + ESPEAK_PATH=$(which espeak-ng) +elif test "$phonemizer" = 'G2P'; then + ESPEAK_PATH='' +else + echo "Unknown phonemizer $phonemizer. Valid options are espeak, espean-ng and G2P" + exit 1 +fi + +echo $lg +echo $ph_lg +echo $text_path +echo $target_dir +echo "min phone seen threshold is $min_phones" + +mkdir -p $target_dir +python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/normalize_and_filter_text.py --lang $lg --fasttext-model $lid_path < $text_path | grep -v '\-\-\-' >! $target_dir/lm.upper.lid.txt +python $FAIRSEQ_ROOT/fairseq_cli/preprocess.py --dataset-impl mmap --trainpref $target_dir/lm.upper.lid.txt --only-source --destdir $target_dir --thresholdsrc 2 --padding-factor 1 --dict-only +cut -f1 -d' ' $target_dir/dict.txt | grep -v -x '[[:punct:]]*' | grep -Pv '\d\d\d\d\d+' >! $target_dir/words.txt + + +if [ -z "$ESPEAK_PATH" ]; then + python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/g2p_wrd_to_phn.py --compact < $target_dir/words.txt > $target_dir/phones.txt +else + # echoing 1 into corpus will prevent the mismatch lines between lexicon and phones in case the phonemizer fails + one=$(echo "1" | PHONEMIZER_ESPEAK_PATH=$ESPEAK_PATH phonemize -p ' ' -w '' -l $ph_lg --language-switch remove-flags) + sed 's/$/ 1/' $target_dir/words.txt | PHONEMIZER_ESPEAK_PATH=$ESPEAK_PATH phonemize -o $target_dir/phones.txt -p ' ' -w '' -l $ph_lg -j 70 --language-switch remove-flags + echo "one is ${one}" + sed -i "s/${one}$//" $target_dir/phones.txt +fi + +paste $target_dir/words.txt $target_dir/phones.txt >! $target_dir/lexicon.lst + +python $FAIRSEQ_ROOT/fairseq_cli/preprocess.py --dataset-impl mmap --trainpref $target_dir/phones.txt --only-source --destdir $target_dir/phones --thresholdsrc $min_phones --padding-factor 1 --dict-only + +python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/filter_lexicon.py -d $target_dir/phones/dict.txt < $target_dir/lexicon.lst >! $target_dir/lexicon_filtered.lst +python $FAIRSEQ_ROOT/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py -s 0.25 --surround --lexicon $target_dir/lexicon_filtered.lst < $target_dir/lm.upper.lid.txt >! $target_dir/phones/lm.phones.filtered.txt +cp $target_dir/phones/dict.txt $target_dir/phones/dict.phn.txt +echo "<SIL> 0" >> $target_dir/phones/dict.phn.txt +python $FAIRSEQ_ROOT/fairseq_cli/preprocess.py --dataset-impl mmap --trainpref $target_dir/phones/lm.phones.filtered.txt --workers 70 --only-source --destdir $target_dir/phones --srcdict $target_dir/phones/dict.phn.txt + +$KENLM_ROOT/lmplz -o 4 < $target_dir/lm.upper.lid.txt --discount_fallback --prune 0 0 0 3 >! $target_dir/kenlm.wrd.o40003.arpa +$KENLM_ROOT/build_binary $target_dir/kenlm.wrd.o40003.arpa $target_dir/kenlm.wrd.o40003.bin + +lg=$lg python $FAIRSEQ_ROOT/examples/speech_recognition/kaldi/kaldi_initializer.py kaldi_root=$KALDI_ROOT fst_dir=$target_dir/fst/phn_to_words_sil lm_arpa=$target_dir/kenlm.wrd.o40003.arpa wav2letter_lexicon=$target_dir/lexicon_filtered.lst data_dir=$target_dir/phones in_labels=phn "blank_symbol='<SIL>'" +lg=$lg python $FAIRSEQ_ROOT/examples/speech_recognition/kaldi/kaldi_initializer.py kaldi_root=$KALDI_ROOT fst_dir=$target_dir/fst/phn_to_words lm_arpa=$target_dir/kenlm.wrd.o40003.arpa wav2letter_lexicon=$target_dir/lexicon_filtered.lst data_dir=$target_dir/phones in_labels=phn + +$KENLM_ROOT/lmplz -o 4 < $target_dir/phones/lm.phones.filtered.txt --discount_fallback >! $target_dir/phones/lm.phones.filtered.04.arpa +$KENLM_ROOT/build_binary $target_dir/phones/lm.phones.filtered.04.arpa $target_dir/phones/lm.phones.filtered.04.bin +$KENLM_ROOT/lmplz -o 6 < $target_dir/phones/lm.phones.filtered.txt --discount_fallback >! $target_dir/phones/lm.phones.filtered.06.arpa +$KENLM_ROOT/build_binary $target_dir/phones/lm.phones.filtered.06.arpa $target_dir/phones/lm.phones.filtered.06.bin + +lg=$lg python $FAIRSEQ_ROOT/examples/speech_recognition/kaldi/kaldi_initializer.py kaldi_root=$KALDI_ROOT fst_dir=$target_dir/fst/phn_to_phn_sil lm_arpa=$target_dir/phones/lm.phones.filtered.06.arpa data_dir=$target_dir/phones in_labels=phn "blank_symbol='<SIL>'" diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/prepare_timit.sh b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_timit.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8f5d596b4b4ec55f11a82dbbf83bad4a22c0b6c --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/prepare_timit.sh @@ -0,0 +1,79 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +timit_root=$1 # assume it is the upper-cased version +tgt_dir=$2 +model=$3 + +set -eu + +setups="matched unmatched" +splits="test valid train train_text" + +tgt_dir=$(realpath $tgt_dir) +sph2wav=$KALDI_ROOT/tools/sph2pipe_v2.5/sph2pipe +wav_dir=$tgt_dir/wav + + +mkdir -p $tgt_dir $wav_dir +find $timit_root/{TRAIN,TEST} -iname "*.WAV" > $tgt_dir/all_sph.flist +cat $tgt_dir/all_sph.flist | sed -e 's#//*#/#g' -e 's#.*/\([^/]*\)/\([^/]*\).WAV#\1_\2#g' > $tgt_dir/all.uid +paste -d' ' $tgt_dir/{all_sph.flist,all.uid} | \ + awk -v sph2wav=$sph2wav -v wav_dir=$wav_dir '{print sph2wav " -f wav " $1 " > " wav_dir "/" $2 ".wav"}' \ + > $tgt_dir/sph2wav.sh +bash $tgt_dir/sph2wav.sh +cat $tgt_dir/all.uid | awk -v wav_dir=$(pwd)/$wav_dir '{print $1" "wav_dir"/"$1".wav"}' | sort > $tgt_dir/all_wav.scp +cut -d' ' -f2 $tgt_dir/all_wav.scp | xargs -I{} soxi -s {} > $tgt_dir/all.dur +paste -d' ' $tgt_dir/{all_wav.scp,all.dur} > $tgt_dir/all_wav_dur.scp +rm $tgt_dir/{all.uid,all_sph.flist,sph2wav.sh} + +find $timit_root/{TRAIN,TEST} -iname "*.PHN" > $tgt_dir/all_phn60.flist +while read line; do + if [ ! -f $line ]; then + >&2 echo "Cannot find transcription file '$line'" && exit 1; + fi + cut -f3 -d' ' "$line" | tr '\n' ' ' | perl -ape 's: *$:\n:;' +done < $tgt_dir/all_phn60.flist > $tgt_dir/all.phn60 +cat $tgt_dir/all_phn60.flist | sed -e 's#//*#/#g' -e 's#.*/\([^/]*\)/\([^/]*\).PHN#\1_\2#g' | \ + paste -d' ' - $tgt_dir/all.phn60 | \ + $KALDI_ROOT/egs/timit/s5/local/timit_norm_trans.pl -i - -m $KALDI_ROOT/egs/timit/s5/conf/phones.60-48-39.map -to 39 | \ + sort > $tgt_dir/all.phn +echo "done preparing wav and 39-phone transcripts" + + +for s in $setups; do + mkdir -p $tgt_dir/$s + for x in $splits; do + uid_path=config/timit_${s}/${x}.uid + grep -w -f $uid_path $tgt_dir/all.phn | cut -d' ' -f2- > $tgt_dir/$s/$x.phn + ln -sf $(realpath $tgt_dir/$s/$x.phn) $tgt_dir/$s/$x.wrd + + echo "/" > $tgt_dir/$s/$x.tsv && grep -w -f $uid_path $tgt_dir/all_wav_dur.scp | cut -d' ' -f2- | sed 's# #\t#' >> $tgt_dir/$s/$x.tsv + done + + for x in $splits; do + cat $tgt_dir/$s/$x.phn + done | tr ' ' '\n' | sort -u | awk '{print $1" "1}' > $tgt_dir/$s/dict.phn.txt + ln -sf $(realpath $tgt_dir/$s/dict.phn.txt) $tgt_dir/$s/dict.wrd.txt +done +echo "done preparing unmatched and matched setups for TIMIT" + + +for s in $setups; do + zsh scripts/prepare_audio.sh $tgt_dir/$s $tgt_dir/$s/feat $model + + lm_dir=$tgt_dir/$s/phones + fst_dir=$tgt_dir/$s/fst/phn_to_phn + + python $FAIRSEQ_ROOT/fairseq_cli/preprocess.py --dataset-impl mmap --trainpref $tgt_dir/$s/train_text.phn --workers 10 --only-source --destdir $lm_dir --srcdict $tgt_dir/$s/dict.phn.txt + $KENLM_ROOT/lmplz -o 3 < $tgt_dir/$s/train_text.phn --discount_fallback >$lm_dir/train_text_phn.03.arpa + $KENLM_ROOT/build_binary $lm_dir/train_text_phn.03.arpa $lm_dir/train_text_phn.03.bin + $KENLM_ROOT/lmplz -o 4 < $tgt_dir/$s/train_text.phn --discount_fallback >$lm_dir/train_text_phn.04.arpa + $KENLM_ROOT/build_binary $lm_dir/train_text_phn.04.arpa $lm_dir/train_text_phn.04.bin + + python $FAIRSEQ_ROOT/examples/speech_recognition/kaldi/kaldi_initializer.py kaldi_root=$KALDI_ROOT fst_dir=$fst_dir lm_arpa=$lm_dir/train_text_phn.03.arpa data_dir=$tgt_dir/$s in_labels=phn +done +echo "done preprocessing audio and text for wav2vec-U" diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/remove_silence.py b/fairseq/examples/wav2vec/unsupervised/scripts/remove_silence.py new file mode 100644 index 0000000000000000000000000000000000000000..fac88b989703262a84b242b2761df621bf02c739 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/remove_silence.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +get intervals from .vads file, specify output data, and this script removes silences and saves the audio data in out path folder +paths=shards/train.tsv +vads=shards/train.vads +python remove_silence.py --paths $paths --vads $vads +""" + +import os +import argparse +import torch +import torchaudio +import tqdm + + +parser = argparse.ArgumentParser() +parser.add_argument("--tsv", default="", type=str) +parser.add_argument("--vads", default="", type=str) +parser.add_argument("--out", type=str) +params = parser.parse_args() + +# load paths +paths = [] +with open(params.tsv) as f: + root = next(f).rstrip() + for line in f: + paths.append(os.path.join(root, line.rstrip().split("\t")[0])) + +# load vads +list_intervals = [] +with open(params.vads) as f: + for line in f: + interval = [ + [int(w.split(":")[0]), int(w.split(":")[1])] for w in line.rstrip().split() + ] + list_intervals.append(interval) + + +# load audio and keep only intervals (i.e. remove silences) +for i in tqdm.trange(len(paths)): + data, _ = torchaudio.load(paths[i]) + if len(list_intervals[i]) > 0: + data_filtered = torch.cat( + [data[0][int(it[0]) : int(it[1])] for it in list_intervals[i]] + ).unsqueeze(0) + else: + data_filtered = data + + # YOU MAY NEED TO MODIFY THIS TO GET THE RIGHT SUBPATH + # outpath = params.out + '/'.join(paths[i].split('/')[-1]) + outpath = params.out + "/" + "/".join(paths[i].split("/")[-2:]) + + if not os.path.isdir("/".join(outpath.split("/")[:-1])): + os.makedirs("/".join(outpath.split("/")[:-1])) + if not os.path.exists(outpath): + torchaudio.save(outpath, data_filtered, sample_rate=16000) + else: + print(outpath, "exists!") diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/vads.py b/fairseq/examples/wav2vec/unsupervised/scripts/vads.py new file mode 100644 index 0000000000000000000000000000000000000000..2398da97d8c44b8f3f270b22d5508a003482b4d6 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/vads.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import sys + +from copy import deepcopy +from scipy.signal import lfilter + +import numpy as np +from tqdm import tqdm +import soundfile as sf +import os.path as osp + + +def get_parser(): + parser = argparse.ArgumentParser(description="compute vad segments") + parser.add_argument( + "--rvad-home", + "-r", + help="path to rvad home (see https://github.com/zhenghuatan/rVADfast)", + required=True, + ) + + return parser + + +def rvad(speechproc, path): + winlen, ovrlen, pre_coef, nfilter, nftt = 0.025, 0.01, 0.97, 20, 512 + ftThres = 0.5 + vadThres = 0.4 + opts = 1 + + data, fs = sf.read(path) + assert fs == 16_000, "sample rate must be 16khz" + ft, flen, fsh10, nfr10 = speechproc.sflux(data, fs, winlen, ovrlen, nftt) + + # --spectral flatness -- + pv01 = np.zeros(ft.shape[0]) + pv01[np.less_equal(ft, ftThres)] = 1 + pitch = deepcopy(ft) + + pvblk = speechproc.pitchblockdetect(pv01, pitch, nfr10, opts) + + # --filtering-- + ENERGYFLOOR = np.exp(-50) + b = np.array([0.9770, -0.9770]) + a = np.array([1.0000, -0.9540]) + fdata = lfilter(b, a, data, axis=0) + + # --pass 1-- + noise_samp, noise_seg, n_noise_samp = speechproc.snre_highenergy( + fdata, nfr10, flen, fsh10, ENERGYFLOOR, pv01, pvblk + ) + + # sets noisy segments to zero + for j in range(n_noise_samp): + fdata[range(int(noise_samp[j, 0]), int(noise_samp[j, 1]) + 1)] = 0 + + vad_seg = speechproc.snre_vad( + fdata, nfr10, flen, fsh10, ENERGYFLOOR, pv01, pvblk, vadThres + ) + return vad_seg, data + + +def main(): + parser = get_parser() + args = parser.parse_args() + + sys.path.append(args.rvad_home) + import speechproc + + stride = 160 + lines = sys.stdin.readlines() + root = lines[0].rstrip() + for fpath in tqdm(lines[1:]): + path = osp.join(root, fpath.split()[0]) + vads, wav = rvad(speechproc, path) + + start = None + vad_segs = [] + for i, v in enumerate(vads): + if start is None and v == 1: + start = i * stride + elif start is not None and v == 0: + vad_segs.append((start, i * stride)) + start = None + if start is not None: + vad_segs.append((start, len(wav))) + + print(" ".join(f"{v[0]}:{v[1]}" for v in vad_segs)) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_apply_cluster_faiss.py b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_apply_cluster_faiss.py new file mode 100644 index 0000000000000000000000000000000000000000..a5dd7ae6c15b358206e067385be260c94021bf20 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_apply_cluster_faiss.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import numpy as np +import tqdm +import torch +import sys + +import faiss +import torch.nn.functional as F + +from wav2vec_cluster_faiss import parse_faiss_specs, Wav2VecFeatureReader + + +def get_parser(): + parser = argparse.ArgumentParser(description="apply clusters") + # fmt: off + parser.add_argument('data', help='location of tsv files') + parser.add_argument('--split', help='split to process', required=True) + parser.add_argument('--labels', help='split to process', default="phn") + parser.add_argument('--path', help='path to pca and centroids', required=True) + parser.add_argument('--checkpoint', type=str, help='checkpoint for wav2vec model (if using wav2vec features)', required=True) + parser.add_argument('--layer', '-l', type=int, help='which layer to read', default=14) + parser.add_argument('--max-tsz', type=int, help='batch kmeans up to this much', default=14) + # fmt: on + + return parser + + +def get_iterator(args): + label_path = osp.join(args.data, f"{args.split}.{args.labels}") + if osp.exists(label_path): + lp = open(label_path, "r") + else: + lp = None + + with open(osp.join(args.data, f"{args.split}.tsv"), "r") as fp: + lines = fp.read().split("\n") + root = lines.pop(0).strip() + files = [line.rstrip() for line in lines if len(line) > 0] + + if lp is not None: + lbls = [line.rstrip() for line in lp] + else: + lbls = [None] * len(files) + + num = len(files) + reader = Wav2VecFeatureReader(args.checkpoint, args.layer) + + def iterate(): + for fname, lbl in zip(files, lbls): + file = osp.join(root, fname.split("\t")[0]) + feats = reader.get_feats(file) + yield feats.data, fname, lbl + + return iterate, num, root + + +def main(): + parser = get_parser() + args = parser.parse_args() + + spec = osp.basename(args.path) + + try: + faiss_spec = parse_faiss_specs(spec.rstrip("/"))[0] + except: + print(spec) + raise + + print("Faiss Spec:", faiss_spec, file=sys.stderr) + + if faiss_spec.pca: + A = torch.from_numpy(np.load(osp.join(args.path, "pca_A.npy"))).cuda() + b = torch.from_numpy(np.load(osp.join(args.path, "pca_b.npy"))).cuda() + print("Loaded PCA", file=sys.stderr) + + centroids = np.load(osp.join(args.path, "centroids.npy")) + print("Loaded centroids", centroids.shape, file=sys.stderr) + + res = faiss.StandardGpuResources() + index_flat = ( + faiss.IndexFlatL2(centroids.shape[1]) + if not faiss_spec.sphere + else faiss.IndexFlatIP(centroids.shape[1]) + ) + faiss_index = faiss.index_cpu_to_gpu(res, 0, index_flat) + faiss_index.add(centroids) + + generator, num, root = get_iterator(args) + iterator = generator() + + had_labels = False + label_path = osp.join(args.path, f"{args.split}.{args.labels}") + + with torch.no_grad(): + with open(osp.join(args.path, f"{args.split}.src"), "w") as fp, open( + osp.join(args.path, f"{args.split}.tsv"), "w" + ) as pp, open(label_path, "w") as lp: + print(root, file=pp) + for f, fname, lbl in tqdm.tqdm(iterator, total=num): + if faiss_spec.pca: + f = torch.mm(f, A) + b + if faiss_spec.norm: + f = F.normalize(f, p=2, dim=-1) + + f = f.cpu().numpy() + + _, z = faiss_index.search(f, 1) + + print(" ".join(str(x.item()) for x in z), file=fp) + print(fname, file=pp) + + if lbl is not None: + print(lbl, file=lp) + had_labels = True + if not had_labels: + os.remove(label_path) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_cluster_faiss.py b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_cluster_faiss.py new file mode 100644 index 0000000000000000000000000000000000000000..632a69e9f4bd98d33abb689c15557c818d0e35ea --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_cluster_faiss.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import gc +import os +import os.path as osp +import random +import numpy as np +import tqdm +import torch + +from collections import namedtuple + +import faiss + +import fairseq +import soundfile as sf + + +def get_parser(): + parser = argparse.ArgumentParser( + description="compute kmeans codebook from kaldi-computed feats" + ) + # fmt: off + parser.add_argument('data', help='location of tsv files') + parser.add_argument('--save-dir', help='where to save the output', required=True) + parser.add_argument('--checkpoint', type=str, help='checkpoint for wav2vec model (if using wav2vec features)', required=True) + parser.add_argument('--sample-pct', '-r', type=float, help='percentage of timesteps to sample', default=0) + parser.add_argument('--layer', '-l', type=int, help='which layer to read', default=14) + parser.add_argument('--faiss-specs', '-f', type=str, + help='faiss index specs; separated by space ' + 'format is: PCAx_NORM_CLUSx_SPHERICAL -> ' + 'PCAx if exists first apply PCA ' + 'NORM if exists, normalize the vector by L2 norm ' + 'CLUSx must exist, cluster to x clusters ' + 'SPEHRICAL if exists, apply spherical kmeans', + default='l2') + # fmt: on + + return parser + + +faiss_spec = namedtuple("faiss_spec", ["pca", "norm", "n_clus", "sphere", "spec_str"]) + + +def parse_faiss_specs(specs_str): + specs = [] + for ss in specs_str.split(): + comps = ss.split("_") + pca = 0 + norm = False + n_clus = 0 + sphere = False + for c in comps: + if c.startswith("PCA"): + pca = int(c[3:]) + elif c == "NORM": + norm = True + elif c.startswith("CLUS"): + n_clus = int(c[4:]) + elif c == "SPHERICAL": + sphere = True + assert n_clus > 0 + specs.append( + faiss_spec(pca=pca, norm=norm, n_clus=n_clus, sphere=sphere, spec_str=ss) + ) + return specs + + +class Wav2VecFeatureReader(object): + def __init__(self, cp_file, layer): + state = fairseq.checkpoint_utils.load_checkpoint_to_cpu(cp_file) + + self.layer = layer + + if "cfg" in state: + w2v_args = state["cfg"] + task = fairseq.tasks.setup_task(w2v_args.task) + model = task.build_model(w2v_args.model) + else: + w2v_args = state["args"] + task = fairseq.tasks.setup_task(w2v_args) + model = task.build_model(w2v_args) + model.load_state_dict(state["model"], strict=True) + model.eval() + model.cuda() + self.model = model + + def read_audio(self, fname): + """Load an audio file and return PCM along with the sample rate""" + wav, sr = sf.read(fname) + assert sr == 16e3 + + return wav + + def get_feats(self, loc): + x = self.read_audio(loc) + with torch.no_grad(): + source = torch.from_numpy(x).view(1, -1).float().cuda() + res = self.model( + source=source, mask=False, features_only=True, layer=self.layer + ) + return res["layer_results"][self.layer][0].squeeze(1) + + +def get_iterator(args): + with open(args.data, "r") as fp: + lines = fp.read().split("\n") + root = lines.pop(0).strip() + files = [osp.join(root, line.split("\t")[0]) for line in lines if len(line) > 0] + + if getattr(args, "sample_pct", 0) > 0: + files = random.sample(files, int(args.sample_pct * len(files))) + num = len(files) + reader = Wav2VecFeatureReader(args.checkpoint, args.layer) + + def iterate(): + for fname in files: + feats = reader.get_feats(fname) + yield feats.cpu().numpy() + + return iterate, num + + +def main(): + parser = get_parser() + args = parser.parse_args() + + faiss_specs = parse_faiss_specs(args.faiss_specs) + print("Faiss Specs:", faiss_specs) + + feat_path = osp.join(args.save_dir, "features") + if osp.exists(feat_path + ".npy"): + feats = np.load(feat_path + ".npy") + else: + generator, num = get_iterator(args) + iterator = generator() + + feats = [] + for f in tqdm.tqdm(iterator, total=num): + feats.append(f) + + del iterator + del generator + + feats = np.concatenate(feats) + + print(feats.shape) + + os.makedirs(args.save_dir, exist_ok=True) + # np.save(feat_path, feats) + + gc.collect() + torch.cuda.empty_cache() + + reload = False + for spec in faiss_specs: + print("Processing spec", spec) + + if reload: + print("Reloading...") + del feats + gc.collect() + feats = np.load(feat_path + ".npy") + + save_path = osp.join(args.save_dir, spec.spec_str) + os.makedirs(save_path, exist_ok=True) + d = feats.shape[-1] + x = feats + if spec.pca > 0: + print("Computing PCA") + pca = faiss.PCAMatrix(d, spec.pca) + pca.train(x) + d = spec.pca + b = faiss.vector_to_array(pca.b) + A = faiss.vector_to_array(pca.A).reshape(pca.d_out, pca.d_in) + np.save(osp.join(save_path, "pca_A"), A.T) + np.save(osp.join(save_path, "pca_b"), b) + print("Applying PCA") + x = pca.apply_py(x) + + if spec.norm: + reload = spec.pca <= 0 + print("Normalizing") + faiss.normalize_L2(x) + + print("Computing kmeans") + kmeans = faiss.Kmeans( + d, + spec.n_clus, + niter=50, + verbose=True, + spherical=spec.sphere, + max_points_per_centroid=feats.shape[0], + gpu=True, + nredo=3, + ) + kmeans.train(x) + np.save(osp.join(save_path, "centroids"), kmeans.centroids) + del kmeans + del x + gc.collect() + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_extract_features.py b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_extract_features.py new file mode 100644 index 0000000000000000000000000000000000000000..b07e274d202414ce40d00aa64a27cf97bb49c1c3 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/wav2vec_extract_features.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import os.path as osp +import tqdm +import torch +import torch.nn.functional as F +from shutil import copyfile + +from npy_append_array import NpyAppendArray + +import fairseq +import soundfile as sf + + +def get_parser(): + parser = argparse.ArgumentParser( + description="compute kmeans codebook from kaldi-computed feats" + ) + # fmt: off + parser.add_argument('data', help='location of tsv files') + parser.add_argument('--split', help='which split to read', required=True) + parser.add_argument('--save-dir', help='where to save the output', required=True) + parser.add_argument('--checkpoint', type=str, help='checkpoint for wav2vec ctc model', required=True) + parser.add_argument('--layer', type=int, default=14, help='which layer to use') + # fmt: on + + return parser + + +class Wav2VecFeatureReader(object): + def __init__(self, cp_file, layer): + model, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task( + [cp_file] + ) + model = model[0] + model.eval() + model.cuda() + self.model = model + self.task = task + self.layer = layer + + def read_audio(self, fname): + """Load an audio file and return PCM along with the sample rate""" + wav, sr = sf.read(fname) + assert sr == 16e3 + + return wav + + def get_feats(self, loc): + x = self.read_audio(loc) + with torch.no_grad(): + source = torch.from_numpy(x).float().cuda() + if self.task.cfg.normalize: + assert source.dim() == 1, source.dim() + with torch.no_grad(): + source = F.layer_norm(source, source.shape) + source = source.view(1, -1) + + m_res = self.model(source=source, mask=False, features_only=True, layer=self.layer) + return m_res["x"].squeeze(0).cpu() + + +def get_iterator(args): + with open(osp.join(args.data, args.split) + ".tsv", "r") as fp: + lines = fp.read().split("\n") + root = lines.pop(0).strip() + files = [osp.join(root, line.split("\t")[0]) for line in lines if len(line) > 0] + + num = len(files) + reader = Wav2VecFeatureReader(args.checkpoint, args.layer) + + def iterate(): + for fname in files: + w2v_feats = reader.get_feats(fname) + yield w2v_feats + + return iterate, num + + +def main(): + parser = get_parser() + args = parser.parse_args() + + os.makedirs(args.save_dir, exist_ok=True) + + def create_files(dest): + copyfile(osp.join(args.data, args.split) + ".tsv", dest + ".tsv") + if osp.exists(osp.join(args.data, args.split) + ".wrd"): + copyfile(osp.join(args.data, args.split) + ".wrd", dest + ".wrd") + if osp.exists(osp.join(args.data, args.split) + ".phn"): + copyfile(osp.join(args.data, args.split) + ".phn", dest + ".phn") + + if osp.exists(dest + ".npy"): + os.remove(dest + ".npy") + npaa = NpyAppendArray(dest + ".npy") + return npaa + + save_path = osp.join(args.save_dir, args.split) + npaa = create_files(save_path) + + generator, num = get_iterator(args) + iterator = generator() + + with open(save_path + ".lengths", "w") as l_f: + for w2v_feats in tqdm.tqdm(iterator, total=num): + print(len(w2v_feats), file=l_f) + + if len(w2v_feats) > 0: + npaa.append(w2v_feats.numpy()) + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/wer.py b/fairseq/examples/wav2vec/unsupervised/scripts/wer.py new file mode 100644 index 0000000000000000000000000000000000000000..613ab50d39019f6edf67c56c2353646be2a2f17d --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/wer.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Implement unsupervised metric for decoding hyperparameter selection: + $$ alpha * LM_PPL + ViterbitUER(%) * 100 $$ +""" +import argparse +import logging +import sys + +import editdistance + +logging.root.setLevel(logging.INFO) +logging.basicConfig(stream=sys.stdout, level=logging.INFO) +logger = logging.getLogger(__name__) + + +def get_parser(): + parser = argparse.ArgumentParser() + parser.add_argument("-s", "--hypo", help="hypo transcription", required=True) + parser.add_argument( + "-r", "--reference", help="reference transcription", required=True + ) + return parser + + +def compute_wer(ref_uid_to_tra, hyp_uid_to_tra, g2p): + d_cnt = 0 + w_cnt = 0 + w_cnt_h = 0 + for uid in hyp_uid_to_tra: + ref = ref_uid_to_tra[uid].split() + if g2p is not None: + hyp = g2p(hyp_uid_to_tra[uid]) + hyp = [p for p in hyp if p != "'" and p != " "] + hyp = [p[:-1] if p[-1].isnumeric() else p for p in hyp] + else: + hyp = hyp_uid_to_tra[uid].split() + d_cnt += editdistance.eval(ref, hyp) + w_cnt += len(ref) + w_cnt_h += len(hyp) + wer = float(d_cnt) / w_cnt + logger.debug( + ( + f"wer = {wer * 100:.2f}%; num. of ref words = {w_cnt}; " + f"num. of hyp words = {w_cnt_h}; num. of sentences = {len(ref_uid_to_tra)}" + ) + ) + return wer + + +def main(): + args = get_parser().parse_args() + + errs = 0 + count = 0 + with open(args.hypo, "r") as hf, open(args.reference, "r") as rf: + for h, r in zip(hf, rf): + h = h.rstrip().split() + r = r.rstrip().split() + errs += editdistance.eval(r, h) + count += len(r) + + logger.info(f"UER: {errs / count * 100:.2f}%") + + +if __name__ == "__main__": + main() + + +def load_tra(tra_path): + with open(tra_path, "r") as f: + uid_to_tra = {} + for line in f: + uid, tra = line.split(None, 1) + uid_to_tra[uid] = tra + logger.debug(f"loaded {len(uid_to_tra)} utterances from {tra_path}") + return uid_to_tra diff --git a/fairseq/examples/wav2vec/unsupervised/scripts/wrd_to_ltr.py b/fairseq/examples/wav2vec/unsupervised/scripts/wrd_to_ltr.py new file mode 100644 index 0000000000000000000000000000000000000000..f83471409a434556cab70086ca9e2d72d4bdddd5 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/scripts/wrd_to_ltr.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + + +def main(): + for line in sys.stdin: + print(" ".join(list(line.strip().replace(" ", "|"))) + " |") + + +if __name__ == "__main__": + main() diff --git a/fairseq/examples/wav2vec/unsupervised/tasks/__init__.py b/fairseq/examples/wav2vec/unsupervised/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6d7dd625e09451be671908578f93148f371f53cd --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/tasks/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .unpaired_audio_text import UnpairedAudioText + + +__all__ = [ + "UnpairedAudioText", +] diff --git a/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py b/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py new file mode 100644 index 0000000000000000000000000000000000000000..5f292528f80d6bb51f16a4324d97342d28fce942 --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/tasks/unpaired_audio_text.py @@ -0,0 +1,447 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +from dataclasses import dataclass, field +import logging +import math +import os +from typing import Optional +import torch + +from fairseq.logging import metrics +from fairseq.tasks import FairseqTask, register_task +from ..data import ExtractedFeaturesDataset, RandomInputDataset + +from fairseq.data import ( + Dictionary, + data_utils, + StripTokenDataset, +) +from fairseq.dataclass import FairseqDataclass +from fairseq.distributed.utils import get_data_parallel_world_size +from omegaconf import MISSING + +from examples.speech_recognition.kaldi.kaldi_decoder import ( + KaldiDecoder, + KaldiDecoderConfig, +) + + +logger = logging.getLogger(__name__) + + +@dataclass +class DecodingConfig(FairseqDataclass): + kenlm_path: Optional[str] = None + lm_weight: float = 0 + blank_weight: float = 0 + + +@dataclass +class UnpairedAudioTextConfig(FairseqDataclass): + data: str = field( + default=MISSING, metadata={"help": "path to data directory containing audio"} + ) + text_data: str = field( + default=MISSING, metadata={"help": "path to data directory containing text"} + ) + max_length: Optional[int] = None + labels: Optional[str] = field( + default=None, + metadata={"help": "extension of the label file to load, used for fine-tuning"}, + ) + unfiltered: bool = field( + default=False, metadata={"help": "load data with _unfiltered suffix"} + ) + ctc_eval: bool = field( + default=False, metadata={"help": "eval UER as if computed by CTC"} + ) + sort_by_length: bool = field( + default=True, metadata={"help": "sort examples by length of audio timesteps"} + ) + shuffle: bool = field(default=True, metadata={"help": "shuffle examples"}) + append_eos: bool = field(default=False, metadata={"help": "append eos"}) + uppercase: Optional[bool] = field( + default=False, metadata={"help": "uppercase for LM score computation"} + ) + skipwords: Optional[str] = field( + default="", + metadata={ + "help": "comma-separated words to be removed for LM score computation" + }, + ) + kenlm_path: Optional[str] = None + vocab_usage_power: float = 2 + + word_decoder_config: Optional[KaldiDecoderConfig] = None + word_kenlm_path: Optional[str] = None + + decoding_config: DecodingConfig = DecodingConfig() + + +@register_task("unpaired_audio_text", dataclass=UnpairedAudioTextConfig) +class UnpairedAudioText(FairseqTask): + """ """ + + cfg: UnpairedAudioTextConfig + + def __init__( + self, + cfg: UnpairedAudioTextConfig, + source_dictionary=None, + target_dictionary=None, + ): + super().__init__(cfg) + + self._target_dictionary = target_dictionary + self._source_dictionary = source_dictionary + self.num_symbols = ( + len([s for s in target_dictionary.symbols if not s.startswith("madeup")]) + - target_dictionary.nspecial + ) + self.sil_id = ( + target_dictionary.index("<SIL>") if "<SIL>" in target_dictionary else -1 + ) + self.kenlm = None + if cfg.kenlm_path is not None: + import kenlm + + self.kenlm = kenlm.Model(cfg.kenlm_path) + + self.word_kenlm = None + if cfg.word_kenlm_path is not None: + import kenlm + + self.word_kenlm = kenlm.Model(cfg.word_kenlm_path) + + self.uppercase = cfg.uppercase + self.skipwords = set(cfg.skipwords.split(",")) + + def str_postprocess(s): + s = " ".join(w for w in s.split() if w not in self.skipwords) + s = s.upper() if self.uppercase else s + return s + + self.str_postprocess = str_postprocess + self.compute_lm_score = lambda s: self.kenlm.score(self.str_postprocess(s)) + + self.compute_word_score = None + if cfg.word_decoder_config is not None: + self.kaldi_decoder = KaldiDecoder(cfg.word_decoder_config, beam=10) + + def compute_word_score(logits, padding): + res = self.kaldi_decoder.decode(logits, padding) + for r in res: + r = r.result() + assert len(r) == 1 + r = r[0] + yield r["score"], r["words"] + + self.compute_word_score = compute_word_score + + @classmethod + def setup_task(cls, cfg: UnpairedAudioTextConfig, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + cfg (AudioPretrainingConfig): configuration of this task + """ + + dict_path = os.path.join(cfg.text_data, "dict.txt") + if os.path.exists(dict_path): + target_dictionary = Dictionary.load(dict_path) + else: + dict_path = os.path.join(cfg.data, f"dict.{cfg.labels}.txt") + target_dictionary = Dictionary.load(dict_path) + + return cls(cfg, target_dictionary=target_dictionary) + + def optimizer_step(self, optimizer, model, update_num): + if hasattr(model, "get_groups_for_update"): + groups = model.get_groups_for_update(update_num) + optimizer.step(groups={groups}) + else: + optimizer.step() + + def valid_step(self, sample, model, criterion): + res = model( + **sample["net_input"], + dense_x_only=True, + ) + + dense_x = res["logits"] + padding_mask = res["padding_mask"] + + word_scores = None + if self.compute_word_score is not None: + word_scores = self.compute_word_score(dense_x.cpu(), padding_mask.cpu()) + + z = dense_x.argmax(-1) + z[padding_mask] = self.target_dictionary.pad() + + vocab_seen = torch.zeros(self.num_symbols, dtype=torch.bool) + + import editdistance + + c_err = 0 + c_len = 0 + pred_c_len = 0 + lm_score_sum = 0 + for i, (x, t, id) in enumerate( + zip( + z, + sample["target"] if "target" in sample else [None] * len(z), + sample["id"], + ) + ): + + if t is not None: + t = t[(t >= self.target_dictionary.nspecial)] + x = x[ + (x >= self.target_dictionary.nspecial) + & (x < (self.num_symbols + self.target_dictionary.nspecial)) + ] + if self.sil_id >= 0: + x = x[x != self.sil_id] + + vocab_seen[x - self.target_dictionary.nspecial] = True + + pred_units_arr = x + if self.cfg.ctc_eval: + pred_units_arr = pred_units_arr.unique_consecutive() + pred_units_arr = pred_units_arr[pred_units_arr != 0] + + if id == 0: + if t is not None: + logger.info(f"REF: {self.target_dictionary.string(t)}") + logger.info(f"HYP: {self.target_dictionary.string(pred_units_arr)}") + + if self.kenlm is not None: + if t is not None: + ref_lm_s = self.compute_lm_score( + self.target_dictionary.string(t) + ) + logger.info( + f"LM [REF]: {ref_lm_s}, {math.pow(10, -ref_lm_s / (len(t) + 1))}" + ) + + hyp_lm_s = self.compute_lm_score( + self.target_dictionary.string(pred_units_arr) + ) + logger.info( + f"LM [HYP]: {hyp_lm_s}, {math.pow(10, -hyp_lm_s / (len(pred_units_arr) + 1))}" + ) + + pred_units_arr = pred_units_arr.tolist() + + pred_c_len += len(pred_units_arr) + + if t is not None: + t = t.tolist() + c_err += editdistance.eval(pred_units_arr, t) + c_len += len(t) + else: + c_len = pred_c_len + + if self.kenlm is not None: + pred_str = self.target_dictionary.string(pred_units_arr) + lm_score = self.compute_lm_score(pred_str) + lm_score_sum += lm_score + + kaldi_score_sum = 0 + word_lm_sum = 0 + num_words = 0 + if word_scores is not None: + for score, words in word_scores: + kaldi_score_sum += score + num_words += len(words) + if self.word_kenlm is not None: + word_lm_sum += self.kenlm.score(" ".join(words)) + + try: + world_size = get_data_parallel_world_size() + except: + world_size = 1 + + logging_output = { + "loss": c_err, + "_num_char_errors": c_err, + "_num_chars": c_len, + "_num_pred_chars": pred_c_len, + "ntokens": c_len, + "nsentences": z.size(0), + "sample_size": c_len, + "_world_size": world_size, + "_lm_score_sum": lm_score_sum, + "_kaldi_score_sum": kaldi_score_sum, + "_word_lm_sum": word_lm_sum, + "_num_words": num_words, + "_vocab_seen": vocab_seen, + } + + return c_err, c_len, logging_output + + def load_dataset(self, split: str, task_cfg: FairseqDataclass = None, **kwargs): + data_path = self.cfg.data + task_cfg = task_cfg or self.cfg + + has_unpaired_text = os.path.exists( + os.path.join(self.cfg.text_data, f"{split}.idx") + ) + + self.datasets[split] = ExtractedFeaturesDataset( + path=data_path, + split=split, + min_length=3, + max_length=task_cfg.max_length, + labels=None if has_unpaired_text else task_cfg.labels, + label_dict=self.target_dictionary, + shuffle=getattr(task_cfg, "shuffle", True), + sort_by_length=task_cfg.sort_by_length, + ) + + logger.info(f"split {split} has unpaired text? {has_unpaired_text}") + if has_unpaired_text: + text_dataset = data_utils.load_indexed_dataset( + os.path.join(self.cfg.text_data, split), self.target_dictionary + ) + text_dataset = StripTokenDataset(text_dataset, self.target_dictionary.eos()) + self.datasets[split] = RandomInputDataset( + self.datasets[split], + text_dataset, + ["random_label"], + add_to_input=True, + pad_idx=self.target_dictionary.pad(), + ) + + @property + def source_dictionary(self): + return self._source_dictionary + + @property + def target_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self._target_dictionary + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return None + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + zero = torch.scalar_tensor(0.0) + num_char_errors = sum( + log.get("_num_char_errors", zero) for log in logging_outputs + ) + num_chars = sum(log.get("_num_chars", zero) for log in logging_outputs) + num_word_errors = sum( + log.get("_num_word_errors", zero) for log in logging_outputs + ) + num_words = sum(log.get("_num_words", zero) for log in logging_outputs) + num_pred_chars = sum( + log.get("_num_pred_chars", zero) for log in logging_outputs + ) + + lm_score_sum = sum(log.get("_lm_score_sum", zero) for log in logging_outputs) + vocab_seen = ( + sum(log.get("_vocab_seen", zero) for log in logging_outputs) + .bool() + .sum() + .item() + ) + kaldi_score_sum = sum( + log.get("_kaldi_score_sum", zero) for log in logging_outputs + ) + word_lm_sum = sum(log.get("_word_lm_sum", zero) for log in logging_outputs) + + metrics.log_scalar_sum("_num_char_errors", num_char_errors) + metrics.log_scalar_sum("_num_chars", num_chars) + metrics.log_scalar_sum("_num_word_errors", num_word_errors) + metrics.log_scalar_sum("_num_words", num_words) + + metrics.log_scalar_sum("lm_score_sum", lm_score_sum) + metrics.log_scalar_sum("num_pred_chars", num_pred_chars) + + if self.cfg.word_kenlm_path is not None: + metrics.log_scalar_sum("kaldi_score_sum", kaldi_score_sum) + metrics.log_scalar_sum("word_lm_sum", word_lm_sum) + + if num_chars > 0: + metrics.log_derived( + "uer", + lambda meters: meters["_num_char_errors"].sum + * 100.0 + / meters["_num_chars"].sum + if meters["_num_chars"].sum > 0 + else float("nan"), + ) + + if lm_score_sum < 0 and vocab_seen > 0: + metrics.log_scalar("vocab_seen_pct", vocab_seen / self.num_symbols) + + metrics.log_derived( + "weighted_lm_ppl", + lambda meters: math.pow( + 10, + -meters["lm_score_sum"].sum + / ( + meters["num_pred_chars"].sum + meters["nsentences"].sum + ), # account for </s> + ) + / meters["vocab_seen_pct"].avg ** self.cfg.vocab_usage_power, + ) + + metrics.log_derived( + "lm_ppl", + lambda meters: math.pow( + 10, + -meters["lm_score_sum"].sum + / ( + meters["num_pred_chars"].sum + meters["nsentences"].sum + ), # account for </s> + ), + ) + else: + metrics.log_derived("weighted_lm_ppl", lambda meters: float("inf")) + + if num_words > 0: + if word_lm_sum != 0: + metrics.log_derived( + "word_lm_ppl", + lambda meters: math.pow( + 10, + -meters["word_lm_sum"].sum + / ( + meters["_num_words"].sum + meters["nsentences"].sum + ), # account for </s> + ), + ) + metrics.log_derived( + "weighted_word_lm_ppl", + lambda meters: math.pow( + 10, + -meters["word_lm_sum"].sum + / ( + meters["_num_words"].sum + meters["nsentences"].sum + ), # account for </s> + ) + / meters["vocab_seen_pct"].avg ** self.cfg.vocab_usage_power, + ) + + if self.cfg.word_kenlm_path is not None: + metrics.log_derived( + "kaldi_score", + lambda meters: meters["kaldi_score_sum"].sum + / meters["nsentences"].sum, + ) + + def build_model(self, cfg: FairseqDataclass): + model = super().build_model(cfg) + + return model diff --git a/fairseq/examples/wav2vec/unsupervised/w2vu_generate.py b/fairseq/examples/wav2vec/unsupervised/w2vu_generate.py new file mode 100644 index 0000000000000000000000000000000000000000..6177239dc75f6937d036462a5a2379aaee202e7d --- /dev/null +++ b/fairseq/examples/wav2vec/unsupervised/w2vu_generate.py @@ -0,0 +1,707 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Run inference for pre-processed data with a trained model. +""" + +import ast +from collections import namedtuple +from dataclasses import dataclass, field +from enum import Enum, auto +import hydra +from hydra.core.config_store import ConfigStore +import logging +import math +import os +from omegaconf import OmegaConf +from typing import Optional +import sys + +import editdistance +import torch + +from hydra.core.hydra_config import HydraConfig + +from fairseq import checkpoint_utils, progress_bar, tasks, utils +from fairseq.data.data_utils import post_process +from fairseq.dataclass.configs import FairseqDataclass, FairseqConfig +from fairseq.logging.meters import StopwatchMeter +from omegaconf import open_dict + +from examples.speech_recognition.kaldi.kaldi_decoder import KaldiDecoderConfig + +logging.root.setLevel(logging.INFO) +logging.basicConfig(stream=sys.stdout, level=logging.INFO) +logger = logging.getLogger(__name__) + + +class DecoderType(Enum): + VITERBI = auto() + KENLM = auto() + FAIRSEQ = auto() + KALDI = auto() + + +@dataclass +class UnsupGenerateConfig(FairseqDataclass): + fairseq: FairseqConfig = FairseqConfig() + lm_weight: float = field( + default=2.0, + metadata={"help": "language model weight"}, + ) + w2l_decoder: DecoderType = field( + default=DecoderType.VITERBI, + metadata={"help": "type of decoder to use"}, + ) + kaldi_decoder_config: Optional[KaldiDecoderConfig] = None + lexicon: Optional[str] = field( + default=None, + metadata={ + "help": "path to lexicon. This is also used to 'phonemize' for unsupvised param tuning" + }, + ) + lm_model: Optional[str] = field( + default=None, + metadata={"help": "path to language model (kenlm or fairseq)"}, + ) + unit_lm: bool = field( + default=False, + metadata={"help": "whether to use unit lm"}, + ) + beam_threshold: float = field( + default=50.0, + metadata={"help": "beam score threshold"}, + ) + beam_size_token: float = field( + default=100.0, + metadata={"help": "max tokens per beam"}, + ) + beam: int = field( + default=5, + metadata={"help": "decoder beam size"}, + ) + nbest: int = field( + default=1, + metadata={"help": "number of results to return"}, + ) + word_score: float = field( + default=1.0, + metadata={"help": "word score to add at end of word"}, + ) + unk_weight: float = field( + default=-math.inf, + metadata={"help": "unknown token weight"}, + ) + sil_weight: float = field( + default=0.0, + metadata={"help": "silence token weight"}, + ) + targets: Optional[str] = field( + default=None, + metadata={"help": "extension of ground truth labels to compute UER"}, + ) + results_path: Optional[str] = field( + default=None, + metadata={"help": "where to store results"}, + ) + post_process: Optional[str] = field( + default=None, + metadata={"help": "how to post process results"}, + ) + vocab_usage_power: float = field( + default=2, + metadata={"help": "for unsupervised param tuning"}, + ) + + viterbi_transcript: Optional[str] = field( + default=None, + metadata={"help": "for unsupervised param tuning"}, + ) + min_lm_ppl: float = field( + default=0, + metadata={"help": "for unsupervised param tuning"}, + ) + min_vt_uer: float = field( + default=0, + metadata={"help": "for unsupervised param tuning"}, + ) + + blank_weight: float = field( + default=0, + metadata={"help": "value to add or set for blank emission"}, + ) + blank_mode: str = field( + default="set", + metadata={ + "help": "can be add or set, how to modify blank emission with blank weight" + }, + ) + sil_is_blank: bool = field( + default=False, + metadata={"help": "if true, <SIL> token is same as blank token"}, + ) + + unsupervised_tuning: bool = field( + default=False, + metadata={ + "help": "if true, returns a score based on unsupervised param selection metric instead of UER" + }, + ) + is_ax: bool = field( + default=False, + metadata={ + "help": "if true, assumes we are using ax for tuning and returns a tuple for ax to consume" + }, + ) + + +def get_dataset_itr(cfg, task): + return task.get_batch_iterator( + dataset=task.dataset(cfg.fairseq.dataset.gen_subset), + max_tokens=cfg.fairseq.dataset.max_tokens, + max_sentences=cfg.fairseq.dataset.batch_size, + max_positions=(sys.maxsize, sys.maxsize), + ignore_invalid_inputs=cfg.fairseq.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=cfg.fairseq.dataset.required_batch_size_multiple, + num_shards=cfg.fairseq.dataset.num_shards, + shard_id=cfg.fairseq.dataset.shard_id, + num_workers=cfg.fairseq.dataset.num_workers, + data_buffer_size=cfg.fairseq.dataset.data_buffer_size, + ).next_epoch_itr(shuffle=False) + + +def process_predictions( + cfg: UnsupGenerateConfig, + hypos, + tgt_dict, + target_tokens, + res_files, +): + retval = [] + word_preds = [] + transcriptions = [] + dec_scores = [] + + for i, hypo in enumerate(hypos[: min(len(hypos), cfg.nbest)]): + if torch.is_tensor(hypo["tokens"]): + tokens = hypo["tokens"].int().cpu() + tokens = tokens[tokens >= tgt_dict.nspecial] + hyp_pieces = tgt_dict.string(tokens) + else: + hyp_pieces = " ".join(hypo["tokens"]) + + if "words" in hypo and len(hypo["words"]) > 0: + hyp_words = " ".join(hypo["words"]) + else: + hyp_words = post_process(hyp_pieces, cfg.post_process) + + to_write = {} + if res_files is not None: + to_write[res_files["hypo.units"]] = hyp_pieces + to_write[res_files["hypo.words"]] = hyp_words + + tgt_words = "" + if target_tokens is not None: + if isinstance(target_tokens, str): + tgt_pieces = tgt_words = target_tokens + else: + tgt_pieces = tgt_dict.string(target_tokens) + tgt_words = post_process(tgt_pieces, cfg.post_process) + + if res_files is not None: + to_write[res_files["ref.units"]] = tgt_pieces + to_write[res_files["ref.words"]] = tgt_words + + if not cfg.fairseq.common_eval.quiet: + logger.info(f"HYPO {i}:" + hyp_words) + if tgt_words: + logger.info("TARGET:" + tgt_words) + + if "am_score" in hypo and "lm_score" in hypo: + logger.info( + f"DECODER AM SCORE: {hypo['am_score']}, DECODER LM SCORE: {hypo['lm_score']}, DECODER SCORE: {hypo['score']}" + ) + elif "score" in hypo: + logger.info(f"DECODER SCORE: {hypo['score']}") + + logger.info("___________________") + + hyp_words_arr = hyp_words.split() + tgt_words_arr = tgt_words.split() + + retval.append( + ( + editdistance.eval(hyp_words_arr, tgt_words_arr), + len(hyp_words_arr), + len(tgt_words_arr), + hyp_pieces, + hyp_words, + ) + ) + word_preds.append(hyp_words_arr) + transcriptions.append(to_write) + dec_scores.append(-hypo.get("score", 0)) # negate cuz kaldi returns NLL + + if len(retval) > 1: + best = None + for r, t in zip(retval, transcriptions): + if best is None or r[0] < best[0][0]: + best = r, t + for dest, tran in best[1].items(): + print(tran, file=dest) + dest.flush() + return best[0] + + assert len(transcriptions) == 1 + for dest, tran in transcriptions[0].items(): + print(tran, file=dest) + + return retval[0] + + +def prepare_result_files(cfg: UnsupGenerateConfig): + def get_res_file(file_prefix): + if cfg.fairseq.dataset.num_shards > 1: + file_prefix = f"{cfg.fairseq.dataset.shard_id}_{file_prefix}" + path = os.path.join( + cfg.results_path, + "{}{}.txt".format( + cfg.fairseq.dataset.gen_subset, + file_prefix, + ), + ) + return open(path, "w", buffering=1) + + if not cfg.results_path: + return None + + return { + "hypo.words": get_res_file(""), + "hypo.units": get_res_file("_units"), + "ref.words": get_res_file("_ref"), + "ref.units": get_res_file("_ref_units"), + "hypo.nbest.words": get_res_file("_nbest_words"), + } + + +def optimize_models(cfg: UnsupGenerateConfig, use_cuda, models): + """Optimize ensemble for generation""" + for model in models: + model.eval() + if cfg.fairseq.common.fp16: + model.half() + if use_cuda: + model.cuda() + + +GenResult = namedtuple( + "GenResult", + [ + "count", + "errs_t", + "gen_timer", + "lengths_hyp_unit_t", + "lengths_hyp_t", + "lengths_t", + "lm_score_t", + "num_feats", + "num_sentences", + "num_symbols", + "vt_err_t", + "vt_length_t", + ], +) + + +def generate(cfg: UnsupGenerateConfig, models, saved_cfg, use_cuda): + task = tasks.setup_task(cfg.fairseq.task) + saved_cfg.task.labels = cfg.fairseq.task.labels + task.load_dataset(cfg.fairseq.dataset.gen_subset, task_cfg=saved_cfg.task) + # Set dictionary + tgt_dict = task.target_dictionary + logger.info( + "| {} {} {} examples".format( + cfg.fairseq.task.data, + cfg.fairseq.dataset.gen_subset, + len(task.dataset(cfg.fairseq.dataset.gen_subset)), + ) + ) + # Load dataset (possibly sharded) + itr = get_dataset_itr(cfg, task) + # Initialize generator + gen_timer = StopwatchMeter() + + def build_generator(cfg: UnsupGenerateConfig): + w2l_decoder = cfg.w2l_decoder + if w2l_decoder == DecoderType.VITERBI: + from examples.speech_recognition.w2l_decoder import W2lViterbiDecoder + + return W2lViterbiDecoder(cfg, task.target_dictionary) + elif w2l_decoder == DecoderType.KENLM: + from examples.speech_recognition.w2l_decoder import W2lKenLMDecoder + + return W2lKenLMDecoder(cfg, task.target_dictionary) + elif w2l_decoder == DecoderType.FAIRSEQ: + from examples.speech_recognition.w2l_decoder import W2lFairseqLMDecoder + + return W2lFairseqLMDecoder(cfg, task.target_dictionary) + elif w2l_decoder == DecoderType.KALDI: + from examples.speech_recognition.kaldi.kaldi_decoder import KaldiDecoder + + assert cfg.kaldi_decoder_config is not None + + return KaldiDecoder( + cfg.kaldi_decoder_config, + cfg.beam, + ) + else: + raise NotImplementedError( + "only wav2letter decoders with (viterbi, kenlm, fairseqlm) options are supported at the moment but found " + + str(w2l_decoder) + ) + + generator = build_generator(cfg) + + kenlm = None + fairseq_lm = None + if cfg.lm_model is not None: + import kenlm + + kenlm = kenlm.Model(cfg.lm_model) + + num_sentences = 0 + if cfg.results_path is not None and not os.path.exists(cfg.results_path): + os.makedirs(cfg.results_path) + + res_files = prepare_result_files(cfg) + errs_t = 0 + lengths_hyp_t = 0 + lengths_hyp_unit_t = 0 + lengths_t = 0 + count = 0 + num_feats = 0 + all_hyp_pieces = [] + all_hyp_words = [] + + num_symbols = ( + len([s for s in tgt_dict.symbols if not s.startswith("madeup")]) + - tgt_dict.nspecial + ) + targets = None + if cfg.targets is not None: + tgt_path = os.path.join( + cfg.fairseq.task.data, cfg.fairseq.dataset.gen_subset + "." + cfg.targets + ) + if os.path.exists(tgt_path): + with open(tgt_path, "r") as f: + targets = f.read().splitlines() + viterbi_transcript = None + if cfg.viterbi_transcript is not None and len(cfg.viterbi_transcript) > 0: + logger.info(f"loading viterbi transcript from {cfg.viterbi_transcript}") + with open(cfg.viterbi_transcript, "r") as vf: + viterbi_transcript = vf.readlines() + viterbi_transcript = [v.rstrip().split() for v in viterbi_transcript] + + gen_timer.start() + + start = 0 + end = len(itr) + + hypo_futures = None + if cfg.w2l_decoder == DecoderType.KALDI: + logger.info("Extracting features") + hypo_futures = [] + samples = [] + with progress_bar.build_progress_bar(cfg.fairseq.common, itr) as t: + for i, sample in enumerate(t): + if "net_input" not in sample or i < start or i >= end: + continue + if "padding_mask" not in sample["net_input"]: + sample["net_input"]["padding_mask"] = None + + hypos, num_feats = gen_hypos( + generator, models, num_feats, sample, task, use_cuda + ) + hypo_futures.append(hypos) + samples.append(sample) + itr = list(zip(hypo_futures, samples)) + start = 0 + end = len(itr) + logger.info("Finished extracting features") + + with progress_bar.build_progress_bar(cfg.fairseq.common, itr) as t: + for i, sample in enumerate(t): + if i < start or i >= end: + continue + + if hypo_futures is not None: + hypos, sample = sample + hypos = [h.result() for h in hypos] + else: + if "net_input" not in sample: + continue + + hypos, num_feats = gen_hypos( + generator, models, num_feats, sample, task, use_cuda + ) + + for i, sample_id in enumerate(sample["id"].tolist()): + if targets is not None: + target_tokens = targets[sample_id] + elif "target" in sample or "target_label" in sample: + toks = ( + sample["target"][i, :] + if "target_label" not in sample + else sample["target_label"][i, :] + ) + + target_tokens = utils.strip_pad(toks, tgt_dict.pad()).int().cpu() + else: + target_tokens = None + + # Process top predictions + ( + errs, + length_hyp, + length, + hyp_pieces, + hyp_words, + ) = process_predictions( + cfg, + hypos[i], + tgt_dict, + target_tokens, + res_files, + ) + errs_t += errs + lengths_hyp_t += length_hyp + lengths_hyp_unit_t += ( + len(hyp_pieces) if len(hyp_pieces) > 0 else len(hyp_words) + ) + lengths_t += length + count += 1 + all_hyp_pieces.append(hyp_pieces) + all_hyp_words.append(hyp_words) + + num_sentences += ( + sample["nsentences"] if "nsentences" in sample else sample["id"].numel() + ) + + lm_score_sum = 0 + if kenlm is not None: + + if cfg.unit_lm: + lm_score_sum = sum(kenlm.score(w) for w in all_hyp_pieces) + else: + lm_score_sum = sum(kenlm.score(w) for w in all_hyp_words) + elif fairseq_lm is not None: + lm_score_sum = sum(fairseq_lm.score([h.split() for h in all_hyp_words])[0]) + + vt_err_t = 0 + vt_length_t = 0 + if viterbi_transcript is not None: + unit_hyps = [] + if cfg.targets is not None and cfg.lexicon is not None: + lex = {} + with open(cfg.lexicon, "r") as lf: + for line in lf: + items = line.rstrip().split() + lex[items[0]] = items[1:] + for h in all_hyp_pieces: + hyp_ws = [] + for w in h.split(): + assert w in lex, w + hyp_ws.extend(lex[w]) + unit_hyps.append(hyp_ws) + + else: + unit_hyps.extend([h.split() for h in all_hyp_words]) + + vt_err_t = sum( + editdistance.eval(vt, h) for vt, h in zip(viterbi_transcript, unit_hyps) + ) + + vt_length_t = sum(len(h) for h in viterbi_transcript) + + if res_files is not None: + for r in res_files.values(): + r.close() + + gen_timer.stop(lengths_hyp_t) + + return GenResult( + count, + errs_t, + gen_timer, + lengths_hyp_unit_t, + lengths_hyp_t, + lengths_t, + lm_score_sum, + num_feats, + num_sentences, + num_symbols, + vt_err_t, + vt_length_t, + ) + + +def gen_hypos(generator, models, num_feats, sample, task, use_cuda): + sample = utils.move_to_cuda(sample) if use_cuda else sample + + if "features" in sample["net_input"]: + sample["net_input"]["dense_x_only"] = True + num_feats += ( + sample["net_input"]["features"].shape[0] + * sample["net_input"]["features"].shape[1] + ) + hypos = task.inference_step(generator, models, sample, None) + return hypos, num_feats + + +def main(cfg: UnsupGenerateConfig, model=None): + if ( + cfg.fairseq.dataset.max_tokens is None + and cfg.fairseq.dataset.batch_size is None + ): + cfg.fairseq.dataset.max_tokens = 1024000 + + use_cuda = torch.cuda.is_available() and not cfg.fairseq.common.cpu + + task = tasks.setup_task(cfg.fairseq.task) + + overrides = ast.literal_eval(cfg.fairseq.common_eval.model_overrides) + + if cfg.fairseq.task._name == "unpaired_audio_text": + overrides["model"] = { + "blank_weight": cfg.blank_weight, + "blank_mode": cfg.blank_mode, + "blank_is_sil": cfg.sil_is_blank, + "no_softmax": True, + "segmentation": { + "type": "NONE", + }, + } + else: + overrides["model"] = { + "blank_weight": cfg.blank_weight, + "blank_mode": cfg.blank_mode, + } + + if model is None: + # Load ensemble + logger.info("| loading model(s) from {}".format(cfg.fairseq.common_eval.path)) + models, saved_cfg = checkpoint_utils.load_model_ensemble( + cfg.fairseq.common_eval.path.split("\\"), + arg_overrides=overrides, + task=task, + suffix=cfg.fairseq.checkpoint.checkpoint_suffix, + strict=(cfg.fairseq.checkpoint.checkpoint_shard_count == 1), + num_shards=cfg.fairseq.checkpoint.checkpoint_shard_count, + ) + optimize_models(cfg, use_cuda, models) + else: + models = [model] + saved_cfg = cfg.fairseq + + with open_dict(saved_cfg.task): + saved_cfg.task.shuffle = False + saved_cfg.task.sort_by_length = False + + gen_result = generate(cfg, models, saved_cfg, use_cuda) + + wer = None + if gen_result.lengths_t > 0: + wer = gen_result.errs_t * 100.0 / gen_result.lengths_t + logger.info(f"WER: {wer}") + + lm_ppl = float("inf") + + if gen_result.lm_score_t != 0 and gen_result.lengths_hyp_t > 0: + hyp_len = gen_result.lengths_hyp_t + lm_ppl = math.pow( + 10, -gen_result.lm_score_t / (hyp_len + gen_result.num_sentences) + ) + logger.info(f"LM PPL: {lm_ppl}") + + logger.info( + "| Processed {} sentences ({} tokens) in {:.1f}s ({:.2f}" + " sentences/s, {:.2f} tokens/s)".format( + gen_result.num_sentences, + gen_result.gen_timer.n, + gen_result.gen_timer.sum, + gen_result.num_sentences / gen_result.gen_timer.sum, + 1.0 / gen_result.gen_timer.avg, + ) + ) + + vt_diff = None + if gen_result.vt_length_t > 0: + vt_diff = gen_result.vt_err_t / gen_result.vt_length_t + vt_diff = max(cfg.min_vt_uer, vt_diff) + + lm_ppl = max(cfg.min_lm_ppl, lm_ppl) + + if not cfg.unsupervised_tuning == 0: + weighted_score = wer + else: + weighted_score = math.log(lm_ppl) * (vt_diff or 1.0) + + res = ( + f"| Generate {cfg.fairseq.dataset.gen_subset} with beam={cfg.beam}, " + f"lm_weight={cfg.kaldi_decoder_config.acoustic_scale if cfg.kaldi_decoder_config else cfg.lm_weight}, " + f"word_score={cfg.word_score}, sil_weight={cfg.sil_weight}, blank_weight={cfg.blank_weight}, " + f"WER: {wer}, LM_PPL: {lm_ppl}, num feats: {gen_result.num_feats}, " + f"length: {gen_result.lengths_hyp_t}, UER to viterbi: {(vt_diff or 0) * 100}, score: {weighted_score}" + ) + + logger.info(res) + # print(res) + + return task, weighted_score + + +@hydra.main( + config_path=os.path.join("../../..", "fairseq", "config"), config_name="config" +) +def hydra_main(cfg): + with open_dict(cfg): + # make hydra logging work with ddp (see # see https://github.com/facebookresearch/hydra/issues/1126) + cfg.job_logging_cfg = OmegaConf.to_container( + HydraConfig.get().job_logging, resolve=True + ) + + cfg = OmegaConf.create( + OmegaConf.to_container(cfg, resolve=False, enum_to_str=False) + ) + OmegaConf.set_struct(cfg, True) + logger.info(cfg) + + utils.import_user_module(cfg.fairseq.common) + + _, score = main(cfg) + + if cfg.is_ax: + return score, None + return score + + +def cli_main(): + try: + from hydra._internal.utils import get_args + + cfg_name = get_args().config_name or "config" + except: + logger.warning("Failed to get config name from hydra args") + cfg_name = "config" + + cs = ConfigStore.instance() + cs.store(name=cfg_name, node=UnsupGenerateConfig) + hydra_main() + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/examples/wav2vec/vq-wav2vec_featurize.py b/fairseq/examples/wav2vec/vq-wav2vec_featurize.py new file mode 100644 index 0000000000000000000000000000000000000000..627072ee174c22831209e00984b945eb9dc2c279 --- /dev/null +++ b/fairseq/examples/wav2vec/vq-wav2vec_featurize.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Helper script to pre-compute embeddings for a flashlight (previously called wav2letter++) dataset +""" + +import argparse +import glob +import os +import os.path as osp +import pprint + +import soundfile as sf +import torch +import fairseq +from torch import nn +from torch.utils.data import DataLoader + + +try: + import tqdm +except: + print("Install tqdm to use --log-format=tqdm") + + +class FilesDataset: + def __init__(self, files, labels): + self.files = files + if labels and osp.exists(labels): + with open(labels, "r") as lbl_f: + self.labels = [line.rstrip() for line in lbl_f] + else: + self.labels = labels + + def __len__(self): + return len(self.files) + + def __getitem__(self, index): + fname = self.files[index] + + wav, sr = sf.read(fname) + assert sr == 16000 + + wav = torch.from_numpy(wav).float() + lbls = None + if self.labels: + if isinstance(self.labels, str): + lbl_file = osp.splitext(fname)[0] + "." + self.labels + with open(lbl_file, "r") as lblf: + lbls = lblf.readline() + assert lbls is not None + else: + lbls = self.labels[index] + return wav, lbls + + def collate(self, batch): + return batch + + +class ArgTypes: + @staticmethod + def existing_path(arg): + arg = str(arg) + assert osp.exists(arg), f"File {arg} does not exist" + return arg + + @staticmethod + def mkdir(arg): + arg = str(arg) + os.makedirs(arg, exist_ok=True) + return arg + + +class DatasetWriter: + def __init__(self): + + self.args = self.load_config() + pprint.pprint(self.args.__dict__) + + self.model = self.load_model() + + def __getattr__(self, attr): + return getattr(self.args, attr) + + def read_manifest(self, fname): + + with open(fname, "r") as fp: + lines = fp.read().split("\n") + root = lines.pop(0).strip() + fnames = [ + osp.join(root, line.split("\t")[0]) for line in lines if len(line) > 0 + ] + + return fnames + + def process_splits(self): + + if self.args.shard is not None or self.args.num_shards is not None: + assert self.args.shard is not None and self.args.num_shards is not None + + for split in self.splits: + print(split) + + if self.extension == "tsv": + datadir = osp.join(self.data_dir, f"{split}.{self.extension}") + print("Reading manifest file: ", datadir) + files = self.read_manifest(datadir) + else: + datadir = osp.join(self.data_dir, split, f"**/*.{self.extension}") + files = glob.glob(datadir, recursive=True) + + assert len(files) > 0 + + if self.args.shard is not None: + files = files[self.args.shard :: self.args.num_shards] + + lbls = [] + with open(self.data_file(split), "w") as srcf: + for line, lbl in self.iterate(files): + print(line, file=srcf) + if self.args.labels: + lbls.append(lbl + "\n") + + if self.args.labels: + assert all(a is not None for a in lbls) + with open(self.lbl_file(split), "w") as lblf: + lblf.writelines(lbls) + + def iterate(self, files): + + data = self.load_data(files) + for samples in tqdm.tqdm(data, total=len(files) // 32): + + for wav, lbl in samples: + x = wav.unsqueeze(0).float().cuda() + + div = 1 + while x.size(-1) // div > self.args.max_size: + div += 1 + + xs = x.chunk(div, dim=-1) + + result = [] + for x in xs: + torch.cuda.empty_cache() + x = self.model.feature_extractor(x) + if self.quantize_location == "encoder": + with torch.no_grad(): + _, idx = self.model.vector_quantizer.forward_idx(x) + idx = idx.squeeze(0).cpu() + else: + with torch.no_grad(): + z = self.model.feature_aggregator(x) + _, idx = self.model.vector_quantizer.forward_idx(z) + idx = idx.squeeze(0).cpu() + result.append(idx) + + idx = torch.cat(result, dim=0) + yield " ".join("-".join(map(str, a.tolist())) for a in idx), lbl + + def lbl_file(self, name): + shard_part = "" if self.args.shard is None else f".{self.args.shard}" + return osp.join(self.output_dir, f"{name}.lbl{shard_part}") + + def data_file(self, name): + shard_part = "" if self.args.shard is None else f".{self.args.shard}" + return osp.join(self.output_dir, f"{name}.src{shard_part}") + + def var_file(self): + return osp.join(self.output_dir, f"vars.pt") + + def load_config(self): + + parser = argparse.ArgumentParser("Vector Quantized wav2vec features") + + # Model Arguments + parser.add_argument("--checkpoint", type=ArgTypes.existing_path, required=True) + parser.add_argument("--data-parallel", action="store_true") + + # Output Arguments + parser.add_argument("--output-dir", type=ArgTypes.mkdir, required=True) + + # Data Arguments + parser.add_argument("--data-dir", type=ArgTypes.existing_path, required=True) + parser.add_argument("--splits", type=str, nargs="+", required=True) + parser.add_argument("--extension", type=str, required=True) + parser.add_argument("--labels", type=str, required=False) + + parser.add_argument("--shard", type=int, default=None) + parser.add_argument("--num-shards", type=int, default=None) + parser.add_argument("--max-size", type=int, default=1300000) + + # Logger Arguments + parser.add_argument( + "--log-format", type=str, choices=["none", "simple", "tqdm"] + ) + + return parser.parse_args() + + def load_data(self, fnames): + + dataset = FilesDataset(fnames, self.args.labels) + loader = DataLoader( + dataset, batch_size=32, collate_fn=dataset.collate, num_workers=8 + ) + return loader + + def load_model(self): + model, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([self.checkpoint]) + model = model[0] + + self.quantize_location = getattr(cfg.model, "vq", "encoder") + + model.eval().float() + model.cuda() + + if self.data_parallel: + model = nn.DataParallel(model) + + return model + + def __call__(self): + + self.process_splits() + + if hasattr(self.model.feature_extractor, "vars") and ( + self.args.shard is None or self.args.shard == 0 + ): + vars = ( + self.model.feature_extractor.vars.view( + self.model.feature_extractor.banks, + self.model.feature_extractor.num_vars, + -1, + ) + .cpu() + .detach() + ) + print("writing learned latent variable embeddings: ", vars.shape) + torch.save(vars, self.var_file()) + + +if __name__ == "__main__": + write_data = DatasetWriter() + + write_data() + print("Done.") diff --git a/fairseq/examples/wav2vec/wav2vec_featurize.py b/fairseq/examples/wav2vec/wav2vec_featurize.py new file mode 100644 index 0000000000000000000000000000000000000000..588268b7080cbd3400ac144604b2d75cef2876dd --- /dev/null +++ b/fairseq/examples/wav2vec/wav2vec_featurize.py @@ -0,0 +1,249 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Helper script to pre-compute embeddings for a flashlight (previously called wav2letter++) dataset +""" + +import argparse +import glob +import os +from shutil import copy + +import h5py +import numpy as np +import soundfile as sf +import torch +import tqdm +import fairseq +from torch import nn + + +def read_audio(fname): + """ Load an audio file and return PCM along with the sample rate """ + + wav, sr = sf.read(fname) + assert sr == 16e3 + + return wav, 16e3 + + +class PretrainedWav2VecModel(nn.Module): + def __init__(self, fname): + super().__init__() + + model, cfg, task = fairseq.checkpoint_utils.load_model_ensemble_and_task([fname]) + model = model[0] + model.eval() + + self.model = model + + def forward(self, x): + with torch.no_grad(): + z = self.model.feature_extractor(x) + if isinstance(z, tuple): + z = z[0] + c = self.model.feature_aggregator(z) + return z, c + + +class EmbeddingWriterConfig(argparse.ArgumentParser): + def __init__(self): + super().__init__("Pre-compute embeddings for flashlight datasets") + + kwargs = {"action": "store", "type": str, "required": True} + + self.add_argument("--input", "-i", help="Input Directory", **kwargs) + self.add_argument("--output", "-o", help="Output Directory", **kwargs) + self.add_argument("--model", help="Path to model checkpoint", **kwargs) + self.add_argument("--split", help="Dataset Splits", nargs="+", **kwargs) + self.add_argument( + "--ext", default="wav", required=False, help="Audio file extension" + ) + + self.add_argument( + "--no-copy-labels", + action="store_true", + help="Do not copy label files. Useful for large datasets, use --targetdir in flashlight then.", + ) + self.add_argument( + "--use-feat", + action="store_true", + help="Use the feature vector ('z') instead of context vector ('c') for features", + ) + self.add_argument("--gpu", help="GPU to use", default=0, type=int) + + +class Prediction: + """ Lightweight wrapper around a fairspeech embedding model """ + + def __init__(self, fname, gpu=0): + self.gpu = gpu + self.model = PretrainedWav2VecModel(fname).cuda(gpu) + + def __call__(self, x): + x = torch.from_numpy(x).float().cuda(self.gpu) + with torch.no_grad(): + z, c = self.model(x.unsqueeze(0)) + + return z.squeeze(0).cpu().numpy(), c.squeeze(0).cpu().numpy() + + +class H5Writer: + """ Write features as hdf5 file in flashlight compatible format """ + + def __init__(self, fname): + self.fname = fname + os.makedirs(os.path.dirname(self.fname), exist_ok=True) + + def write(self, data): + channel, T = data.shape + + with h5py.File(self.fname, "w") as out_ds: + data = data.T.flatten() + out_ds["features"] = data + out_ds["info"] = np.array([16e3 // 160, T, channel]) + + +class EmbeddingDatasetWriter(object): + """Given a model and a flashlight dataset, pre-compute and store embeddings + + Args: + input_root, str : + Path to the flashlight dataset + output_root, str : + Desired output directory. Will be created if non-existent + split, str : + Dataset split + """ + + def __init__( + self, + input_root, + output_root, + split, + model_fname, + extension="wav", + gpu=0, + verbose=False, + use_feat=False, + ): + + assert os.path.exists(model_fname) + + self.model_fname = model_fname + self.model = Prediction(self.model_fname, gpu) + + self.input_root = input_root + self.output_root = output_root + self.split = split + self.verbose = verbose + self.extension = extension + self.use_feat = use_feat + + assert os.path.exists(self.input_path), "Input path '{}' does not exist".format( + self.input_path + ) + + def _progress(self, iterable, **kwargs): + if self.verbose: + return tqdm.tqdm(iterable, **kwargs) + return iterable + + def require_output_path(self, fname=None): + path = self.get_output_path(fname) + os.makedirs(path, exist_ok=True) + + @property + def input_path(self): + return self.get_input_path() + + @property + def output_path(self): + return self.get_output_path() + + def get_input_path(self, fname=None): + if fname is None: + return os.path.join(self.input_root, self.split) + return os.path.join(self.get_input_path(), fname) + + def get_output_path(self, fname=None): + if fname is None: + return os.path.join(self.output_root, self.split) + return os.path.join(self.get_output_path(), fname) + + def copy_labels(self): + self.require_output_path() + + labels = list( + filter( + lambda x: self.extension not in x, glob.glob(self.get_input_path("*")) + ) + ) + for fname in tqdm.tqdm(labels): + copy(fname, self.output_path) + + @property + def input_fnames(self): + return sorted(glob.glob(self.get_input_path("*.{}".format(self.extension)))) + + def __len__(self): + return len(self.input_fnames) + + def write_features(self): + + paths = self.input_fnames + + fnames_context = map( + lambda x: os.path.join( + self.output_path, x.replace("." + self.extension, ".h5context") + ), + map(os.path.basename, paths), + ) + + for name, target_fname in self._progress( + zip(paths, fnames_context), total=len(self) + ): + wav, sr = read_audio(name) + z, c = self.model(wav) + feat = z if self.use_feat else c + writer = H5Writer(target_fname) + writer.write(feat) + + def __repr__(self): + + return "EmbeddingDatasetWriter ({n_files} files)\n\tinput:\t{input_root}\n\toutput:\t{output_root}\n\tsplit:\t{split})".format( + n_files=len(self), **self.__dict__ + ) + + +if __name__ == "__main__": + + args = EmbeddingWriterConfig().parse_args() + + for split in args.split: + + writer = EmbeddingDatasetWriter( + input_root=args.input, + output_root=args.output, + split=split, + model_fname=args.model, + gpu=args.gpu, + extension=args.ext, + use_feat=args.use_feat, + ) + + print(writer) + writer.require_output_path() + + print("Writing Features...") + writer.write_features() + print("Done.") + + if not args.no_copy_labels: + print("Copying label data...") + writer.copy_labels() + print("Done.") diff --git a/fairseq/examples/wav2vec/wav2vec_manifest.py b/fairseq/examples/wav2vec/wav2vec_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..9b8aa180e88d9ee98bdca7089aed5046ec0d9cb9 --- /dev/null +++ b/fairseq/examples/wav2vec/wav2vec_manifest.py @@ -0,0 +1,87 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Data pre-processing: build vocabularies and binarize training data. +""" + +import argparse +import glob +import os +import random + +import soundfile + + +def get_parser(): + parser = argparse.ArgumentParser() + parser.add_argument( + "root", metavar="DIR", help="root directory containing flac files to index" + ) + parser.add_argument( + "--valid-percent", + default=0.01, + type=float, + metavar="D", + help="percentage of data to use as validation set (between 0 and 1)", + ) + parser.add_argument( + "--dest", default=".", type=str, metavar="DIR", help="output directory" + ) + parser.add_argument( + "--ext", default="flac", type=str, metavar="EXT", help="extension to look for" + ) + parser.add_argument("--seed", default=42, type=int, metavar="N", help="random seed") + parser.add_argument( + "--path-must-contain", + default=None, + type=str, + metavar="FRAG", + help="if set, path must contain this substring for a file to be included in the manifest", + ) + return parser + + +def main(args): + assert args.valid_percent >= 0 and args.valid_percent <= 1.0 + + if not os.path.exists(args.dest): + os.makedirs(args.dest) + + dir_path = os.path.realpath(args.root) + search_path = os.path.join(dir_path, "**/*." + args.ext) + rand = random.Random(args.seed) + + valid_f = ( + open(os.path.join(args.dest, "valid.tsv"), "w") + if args.valid_percent > 0 + else None + ) + + with open(os.path.join(args.dest, "train.tsv"), "w") as train_f: + print(dir_path, file=train_f) + + if valid_f is not None: + print(dir_path, file=valid_f) + + for fname in glob.iglob(search_path, recursive=True): + file_path = os.path.realpath(fname) + + if args.path_must_contain and args.path_must_contain not in file_path: + continue + + frames = soundfile.info(fname).frames + dest = train_f if rand.random() > args.valid_percent else valid_f + print( + "{}\t{}".format(os.path.relpath(file_path, dir_path), frames), file=dest + ) + if valid_f is not None: + valid_f.close() + + +if __name__ == "__main__": + parser = get_parser() + args = parser.parse_args() + main(args) diff --git a/fairseq/examples/wmt19/README.md b/fairseq/examples/wmt19/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5c90d0e6c4ae8d043ca622e70c5828dca6f9c2f2 --- /dev/null +++ b/fairseq/examples/wmt19/README.md @@ -0,0 +1,85 @@ +# WMT 19 + +This page provides pointers to the models of Facebook-FAIR's WMT'19 news translation task submission [(Ng et al., 2019)](https://arxiv.org/abs/1907.06616). + +## Pre-trained models + +Model | Description | Download +---|---|--- +`transformer.wmt19.en-de` | En->De Ensemble | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-de.joined-dict.ensemble.tar.gz) +`transformer.wmt19.de-en` | De->En Ensemble | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.de-en.joined-dict.ensemble.tar.gz) +`transformer.wmt19.en-ru` | En->Ru Ensemble | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-ru.ensemble.tar.gz) +`transformer.wmt19.ru-en` | Ru->En Ensemble | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.ru-en.ensemble.tar.gz) +`transformer_lm.wmt19.en` | En Language Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.en.tar.gz) +`transformer_lm.wmt19.de` | De Language Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.de.tar.gz) +`transformer_lm.wmt19.ru` | Ru Language Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.ru.tar.gz) + +## Pre-trained single models before finetuning + +Model | Description | Download +---|---|--- +`transformer.wmt19.en-de` | En->De Single, no finetuning | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-de.ffn8192.tar.gz) +`transformer.wmt19.de-en` | De->En Single, no finetuning | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.de-en.ffn8192.tar.gz) +`transformer.wmt19.en-ru` | En->Ru Single, no finetuning | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-ru.ffn8192.tar.gz) +`transformer.wmt19.ru-en` | Ru->En Single, no finetuning | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt19.ru-en.ffn8192.tar.gz) + +## Example usage (torch.hub) + +#### Requirements + +We require a few additional Python dependencies for preprocessing: +```bash +pip install fastBPE sacremoses +``` + +#### Translation + +```python +import torch + +# English to German translation +en2de = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-de', checkpoint_file='model1.pt:model2.pt:model3.pt:model4.pt', + tokenizer='moses', bpe='fastbpe') +en2de.translate("Machine learning is great!") # 'Maschinelles Lernen ist großartig!' + +# German to English translation +de2en = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.de-en', checkpoint_file='model1.pt:model2.pt:model3.pt:model4.pt', + tokenizer='moses', bpe='fastbpe') +de2en.translate("Maschinelles Lernen ist großartig!") # 'Machine learning is great!' + +# English to Russian translation +en2ru = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.en-ru', checkpoint_file='model1.pt:model2.pt:model3.pt:model4.pt', + tokenizer='moses', bpe='fastbpe') +en2ru.translate("Machine learning is great!") # 'Машинное обучение - это здорово!' + +# Russian to English translation +ru2en = torch.hub.load('pytorch/fairseq', 'transformer.wmt19.ru-en', checkpoint_file='model1.pt:model2.pt:model3.pt:model4.pt', + tokenizer='moses', bpe='fastbpe') +ru2en.translate("Машинное обучение - это здорово!") # 'Machine learning is great!' +``` + +#### Language Modeling + +```python +# Sample from the English LM +en_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt19.en', tokenizer='moses', bpe='fastbpe') +en_lm.sample("Machine learning is") # 'Machine learning is the future of computing, says Microsoft boss Satya Nadella ...' + +# Sample from the German LM +de_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt19.de', tokenizer='moses', bpe='fastbpe') +de_lm.sample("Maschinelles lernen ist") # 'Maschinelles lernen ist das A und O (neues-deutschland.de) Die Arbeitsbedingungen für Lehrerinnen und Lehrer sind seit Jahren verbesserungswürdig ...' + +# Sample from the Russian LM +ru_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt19.ru', tokenizer='moses', bpe='fastbpe') +ru_lm.sample("машинное обучение это") # 'машинное обучение это то, что мы называем "искусственным интеллектом".' +``` + +## Citation +```bibtex +@inproceedings{ng2019facebook}, + title = {Facebook FAIR's WMT19 News Translation Task Submission}, + author = {Ng, Nathan and Yee, Kyra and Baevski, Alexei and Ott, Myle and Auli, Michael and Edunov, Sergey}, + booktitle = {Proc. of WMT}, + year = 2019, +} +``` diff --git a/fairseq/examples/wmt20/README.md b/fairseq/examples/wmt20/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b4f2874652f8be19998a65faa1d9276d8017ec59 --- /dev/null +++ b/fairseq/examples/wmt20/README.md @@ -0,0 +1,72 @@ +# WMT 20 + +This page provides pointers to the models of Facebook-FAIR's WMT'20 news translation task submission [(Chen et al., 2020)](https://arxiv.org/abs/2011.08298). + +## Single best MT models (after finetuning on part of WMT20 news dev set) + +Model | Description | Download +---|---|--- +`transformer.wmt20.ta-en` | Ta->En | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.ta-en.single.tar.gz) +`transformer.wmt20.en-ta` | En->Ta | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-ta.single.tar.gz) +`transformer.wmt20.iu-en.news` | Iu->En (News domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu-en.news.single.tar.gz) +`transformer.wmt20.en-iu.news` | En->Iu (News domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-iu.news.single.tar.gz) +`transformer.wmt20.iu-en.nh` | Iu->En (Nunavut Hansard domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu-en.nh.single.tar.gz) +`transformer.wmt20.en-iu.nh` | En->Iu (Nunavut Hansard domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-iu.nh.single.tar.gz) + +## Language models +Model | Description | Download +---|---|--- +`transformer_lm.wmt20.en` | En Language Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en.tar.gz) +`transformer_lm.wmt20.ta` | Ta Language Model | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.ta.tar.gz) +`transformer_lm.wmt20.iu.news` | Iu Language Model (News domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu.news.tar.gz) +`transformer_lm.wmt20.iu.nh` | Iu Language Model (Nunavut Hansard domain) | [download (.tar.gz)](https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu.nh.tar.gz) + +## Example usage (torch.hub) + +#### Translation + +```python +import torch + +# English to Tamil translation +en2ta = torch.hub.load('pytorch/fairseq', 'transformer.wmt20.en-ta') +en2ta.translate("Machine learning is great!") # 'இயந்திரக் கற்றல் அருமை!' + +# Tamil to English translation +ta2en = torch.hub.load('pytorch/fairseq', 'transformer.wmt20.ta-en') +ta2en.translate("இயந்திரக் கற்றல் அருமை!") # 'Machine learning is great!' + +# English to Inuktitut translation +en2iu = torch.hub.load('pytorch/fairseq', 'transformer.wmt20.en-iu.news') +en2iu.translate("machine learning is great!") # 'ᖃᒧᑕᐅᔭᓄᑦ ᐃᓕᓐᓂᐊᕐᓂᖅ ᐱᐅᔪᒻᒪᕆᒃ!' + +# Inuktitut to English translation +iu2en = torch.hub.load('pytorch/fairseq', 'transformer.wmt20.iu-en.news') +iu2en.translate("ᖃᒧᑕᐅᔭᓄᑦ ᐃᓕᓐᓂᐊᕐᓂᖅ ᐱᐅᔪᒻᒪᕆᒃ!") # 'Machine learning excellence!' +``` + +#### Language Modeling + +```python +# Sample from the English LM +en_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt20.en') +en_lm.sample("Machine learning is") # 'Machine learning is a type of artificial intelligence that uses machine learning to learn from data and make predictions.' + +# Sample from the Tamil LM +ta_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt20.ta') +ta_lm.sample("இயந்திரக் கற்றல் என்பது செயற்கை நுண்ணறிவின்") # 'இயந்திரக் கற்றல் என்பது செயற்கை நுண்ணறிவின் ஒரு பகுதியாகும்.' + +# Sample from the Inuktitut LM +iu_lm = torch.hub.load('pytorch/fairseq', 'transformer_lm.wmt20.iu.news') +iu_lm.sample("ᖃᒧᑕᐅᔭᓄᑦ ᐃᓕᓐᓂᐊᕐᓂᖅ") # 'ᖃᒧᑕᐅᔭᓄᑦ ᐃᓕᓐᓂᐊᕐᓂᖅ, ᐊᒻᒪᓗ ᓯᓚᐅᑉ ᐊᓯᙳᖅᐸᓪᓕᐊᓂᖓᓄᑦ ᖃᓄᐃᓕᐅᕈᑎᒃᓴᑦ, ᐃᓚᖃᖅᖢᑎᒃ ᐅᑯᓂᖓ:' +``` + +## Citation +```bibtex +@inproceedings{chen2020facebook + title={Facebook AI's WMT20 News Translation Task Submission}, + author={Peng-Jen Chen and Ann Lee and Changhan Wang and Naman Goyal and Angela Fan and Mary Williamson and Jiatao Gu}, + booktitle={Proc. of WMT}, + year={2020}, +} +``` diff --git a/fairseq/examples/xlmr/README.md b/fairseq/examples/xlmr/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b95bfe15d3fe6d03951453679135c2e9187d73c7 --- /dev/null +++ b/fairseq/examples/xlmr/README.md @@ -0,0 +1,144 @@ +# Unsupervised Cross-lingual Representation Learning at Scale (XLM-RoBERTa) +https://arxiv.org/pdf/1911.02116.pdf + +# Larger-Scale Transformers for Multilingual Masked Language Modeling +https://arxiv.org/pdf/2105.00572.pdf + + +## What's New: +- June 2021: `XLMR-XL` AND `XLMR-XXL` models released. + +## Introduction + +`XLM-R` (`XLM-RoBERTa`) is a generic cross lingual sentence encoder that obtains state-of-the-art results on many cross-lingual understanding (XLU) benchmarks. It is trained on `2.5T` of filtered CommonCrawl data in 100 languages (list below). + + Language | Language|Language |Language | Language +---|---|---|---|--- +Afrikaans | Albanian | Amharic | Arabic | Armenian +Assamese | Azerbaijani | Basque | Belarusian | Bengali +Bengali Romanize | Bosnian | Breton | Bulgarian | Burmese +Burmese zawgyi font | Catalan | Chinese (Simplified) | Chinese (Traditional) | Croatian +Czech | Danish | Dutch | English | Esperanto +Estonian | Filipino | Finnish | French | Galician +Georgian | German | Greek | Gujarati | Hausa +Hebrew | Hindi | Hindi Romanize | Hungarian | Icelandic +Indonesian | Irish | Italian | Japanese | Javanese +Kannada | Kazakh | Khmer | Korean | Kurdish (Kurmanji) +Kyrgyz | Lao | Latin | Latvian | Lithuanian +Macedonian | Malagasy | Malay | Malayalam | Marathi +Mongolian | Nepali | Norwegian | Oriya | Oromo +Pashto | Persian | Polish | Portuguese | Punjabi +Romanian | Russian | Sanskrit | Scottish Gaelic | Serbian +Sindhi | Sinhala | Slovak | Slovenian | Somali +Spanish | Sundanese | Swahili | Swedish | Tamil +Tamil Romanize | Telugu | Telugu Romanize | Thai | Turkish +Ukrainian | Urdu | Urdu Romanize | Uyghur | Uzbek +Vietnamese | Welsh | Western Frisian | Xhosa | Yiddish + +## Pre-trained models + +Model | Description | #params | vocab size | Download +---|---|---|---|--- +`xlmr.base` | XLM-R using the BERT-base architecture | 250M | 250k | [xlm.base.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/xlmr.base.tar.gz) +`xlmr.large` | XLM-R using the BERT-large architecture | 560M | 250k | [xlm.large.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/xlmr.large.tar.gz) +`xlmr.xl` | XLM-R (`layers=36, model_dim=2560`) | 3.5B | 250k | [xlm.xl.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/xlmr/xlmr.xl.tar.gz) +`xlmr.xxl` | XLM-R (`layers=48, model_dim=4096`) | 10.7B | 250k | [xlm.xxl.tar.gz](https://dl.fbaipublicfiles.com/fairseq/models/xlmr/xlmr.xxl.tar.gz) + +## Results + +**[XNLI (Conneau et al., 2018)](https://arxiv.org/abs/1809.05053)** + +Model | average | en | fr | es | de | el | bg | ru | tr | ar | vi | th | zh | hi | sw | ur +---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--- +`roberta.large.mnli` _(TRANSLATE-TEST)_ | 77.8 | 91.3 | 82.9 | 84.3 | 81.2 | 81.7 | 83.1 | 78.3 | 76.8 | 76.6 | 74.2 | 74.1 | 77.5 | 70.9 | 66.7 | 66.8 +`xlmr.large` _(TRANSLATE-TRAIN-ALL)_ | 83.6 | 89.1 | 85.1 | 86.6 | 85.7 | 85.3 | 85.9 | 83.5 | 83.2 | 83.1 | 83.7 | 81.5 | 83.7 | 81.6 | 78.0 | 78.1 +`xlmr.xl` _(TRANSLATE-TRAIN-ALL)_ | 85.4 | 91.1 | 87.2 | 88.1 | 87.0 | 87.4 | 87.8 | 85.3 | 85.2 | 85.3 | 86.2 | 83.8 | 85.3 | 83.1 | 79.8 | 78.2 | 85.4 +`xlmr.xxl` _(TRANSLATE-TRAIN-ALL)_ | 86.0 | 91.5 | 87.6 | 88.7 | 87.8 | 87.4 | 88.2 | 85.6 | 85.1 | 85.8 | 86.3 | 83.9 | 85.6 | 84.6 | 81.7 | 80.6 + +**[MLQA (Lewis et al., 2018)](https://arxiv.org/abs/1910.07475)** + +Model | average | en | es | de | ar | hi | vi | zh +---|---|---|---|---|---|---|---|--- +`BERT-large` | - | 80.2/67.4 | - | - | - | - | - | - +`mBERT` | 57.7 / 41.6 | 77.7 / 65.2 | 64.3 / 46.6 | 57.9 / 44.3 | 45.7 / 29.8| 43.8 / 29.7 | 57.1 / 38.6 | 57.5 / 37.3 +`xlmr.large` | 70.7 / 52.7 | 80.6 / 67.8 | 74.1 / 56.0 | 68.5 / 53.6 | 63.1 / 43.5 | 69.2 / 51.6 | 71.3 / 50.9 | 68.0 / 45.4 +`xlmr.xl` | 73.4 / 55.3 | 85.1 / 72.6 | 66.7 / 46.2 | 70.5 / 55.5 | 74.3 / 56.9 | 72.2 / 54.7 | 74.4 / 52.9 | 70.9 / 48.5 +`xlmr.xxl` | 74.8 / 56.6 | 85.5 / 72.4 | 68.6 / 48.4 | 72.7 / 57.8 | 75.4 / 57.6 | 73.7 / 55.8 | 76.0 / 55.0 | 71.7 / 48.9 + + +## Example usage + +##### Load XLM-R from torch.hub (PyTorch >= 1.1): +```python +import torch +xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large') +xlmr.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Load XLM-R (for PyTorch 1.0 or custom models): +```python +# Download xlmr.large model +wget https://dl.fbaipublicfiles.com/fairseq/models/xlmr.large.tar.gz +tar -xzvf xlmr.large.tar.gz + +# Load the model in fairseq +from fairseq.models.roberta import XLMRModel +xlmr = XLMRModel.from_pretrained('/path/to/xlmr.large', checkpoint_file='model.pt') +xlmr.eval() # disable dropout (or leave in train mode to finetune) +``` + +##### Apply sentence-piece-model (SPM) encoding to input text: +```python +en_tokens = xlmr.encode('Hello world!') +assert en_tokens.tolist() == [0, 35378, 8999, 38, 2] +xlmr.decode(en_tokens) # 'Hello world!' + +zh_tokens = xlmr.encode('你好，世界') +assert zh_tokens.tolist() == [0, 6, 124084, 4, 3221, 2] +xlmr.decode(zh_tokens) # '你好，世界' + +hi_tokens = xlmr.encode('नमस्ते दुनिया') +assert hi_tokens.tolist() == [0, 68700, 97883, 29405, 2] +xlmr.decode(hi_tokens) # 'नमस्ते दुनिया' + +ar_tokens = xlmr.encode('مرحبا بالعالم') +assert ar_tokens.tolist() == [0, 665, 193478, 258, 1705, 77796, 2] +xlmr.decode(ar_tokens) # 'مرحبا بالعالم' + +fr_tokens = xlmr.encode('Bonjour le monde') +assert fr_tokens.tolist() == [0, 84602, 95, 11146, 2] +xlmr.decode(fr_tokens) # 'Bonjour le monde' +``` + +##### Extract features from XLM-R: +```python +# Extract the last layer's features +last_layer_features = xlmr.extract_features(zh_tokens) +assert last_layer_features.size() == torch.Size([1, 6, 1024]) + +# Extract all layer's features (layer 0 is the embedding layer) +all_layers = xlmr.extract_features(zh_tokens, return_all_hiddens=True) +assert len(all_layers) == 25 +assert torch.all(all_layers[-1] == last_layer_features) +``` + +## Citation + +```bibtex +@article{conneau2019unsupervised, + title={Unsupervised Cross-lingual Representation Learning at Scale}, + author={Conneau, Alexis and Khandelwal, Kartikay and Goyal, Naman and Chaudhary, Vishrav and Wenzek, Guillaume and Guzm{\'a}n, Francisco and Grave, Edouard and Ott, Myle and Zettlemoyer, Luke and Stoyanov, Veselin}, + journal={arXiv preprint arXiv:1911.02116}, + year={2019} +} +``` + + +```bibtex +@article{goyal2021larger, + title={Larger-Scale Transformers for Multilingual Masked Language Modeling}, + author={Goyal, Naman and Du, Jingfei and Ott, Myle and Anantharaman, Giri and Conneau, Alexis}, + journal={arXiv preprint arXiv:2105.00572}, + year={2021} +} +``` diff --git a/fairseq/fairseq/__init__.py b/fairseq/fairseq/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dc9fd1886d55756b5bdfeccf1ad329bd419a706e --- /dev/null +++ b/fairseq/fairseq/__init__.py @@ -0,0 +1,44 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import os +import sys + +try: + from .version import __version__ # noqa +except ImportError: + version_txt = os.path.join(os.path.dirname(__file__), "version.txt") + with open(version_txt) as f: + __version__ = f.read().strip() + +__all__ = ["pdb"] + +# backwards compatibility to support `from fairseq.X import Y` +from fairseq.distributed import utils as distributed_utils +from fairseq.logging import meters, metrics, progress_bar # noqa + +sys.modules["fairseq.distributed_utils"] = distributed_utils +sys.modules["fairseq.meters"] = meters +sys.modules["fairseq.metrics"] = metrics +sys.modules["fairseq.progress_bar"] = progress_bar + +# initialize hydra +from fairseq.dataclass.initialize import hydra_init +hydra_init() + +import fairseq.criterions # noqa +import fairseq.distributed # noqa +import fairseq.models # noqa +import fairseq.modules # noqa +import fairseq.optim # noqa +import fairseq.optim.lr_scheduler # noqa +import fairseq.pdb # noqa +import fairseq.scoring # noqa +import fairseq.tasks # noqa +import fairseq.token_generation_constraints # noqa + +import fairseq.benchmark # noqa +import fairseq.model_parallel # noqa diff --git a/fairseq/fairseq/benchmark/__init__.py b/fairseq/fairseq/benchmark/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0317d5c623778fe40b7bf07b77769cd10c243244 --- /dev/null +++ b/fairseq/fairseq/benchmark/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# import models/tasks to register them +from . import dummy_dataset, dummy_lm, dummy_masked_lm, dummy_model, dummy_mt # noqa diff --git a/fairseq/fairseq/benchmark/dummy_dataset.py b/fairseq/fairseq/benchmark/dummy_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..2f051754af55966e26850e94c121e0ff439bfd28 --- /dev/null +++ b/fairseq/fairseq/benchmark/dummy_dataset.py @@ -0,0 +1,36 @@ +import numpy as np +from fairseq.data import FairseqDataset + + +class DummyDataset(FairseqDataset): + def __init__(self, batch, num_items, item_size): + super().__init__() + self.batch = batch + self.num_items = num_items + self.item_size = item_size + + def __getitem__(self, index): + return index + + def __len__(self): + return self.num_items + + def collater(self, samples): + return self.batch + + @property + def sizes(self): + return np.array([self.item_size] * self.num_items) + + def num_tokens(self, index): + return self.item_size + + def size(self, index): + return self.item_size + + def ordered_indices(self): + return np.arange(self.num_items) + + @property + def supports_prefetch(self): + return False diff --git a/fairseq/fairseq/benchmark/dummy_lm.py b/fairseq/fairseq/benchmark/dummy_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..c6246a0c0e338fa36244b3aa4fb57f189fbffcb6 --- /dev/null +++ b/fairseq/fairseq/benchmark/dummy_lm.py @@ -0,0 +1,83 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from dataclasses import dataclass, field +from typing import Optional + +import torch +from .dummy_dataset import DummyDataset +from fairseq.data import Dictionary +from fairseq.dataclass import FairseqDataclass +from fairseq.tasks import FairseqTask, register_task +from omegaconf import II + + +logger = logging.getLogger(__name__) + + +@dataclass +class DummyLMConfig(FairseqDataclass): + dict_size: int = 49996 + dataset_size: int = 100000 + tokens_per_sample: int = field( + default=512, metadata={"help": "max sequence length"} + ) + add_bos_token: bool = False + batch_size: Optional[int] = II("dataset.batch_size") + max_tokens: Optional[int] = II("dataset.max_tokens") + max_target_positions: int = II("task.tokens_per_sample") + + +@register_task("dummy_lm", dataclass=DummyLMConfig) +class DummyLMTask(FairseqTask): + def __init__(self, cfg: DummyLMConfig): + super().__init__(cfg) + + # load dictionary + self.dictionary = Dictionary() + for i in range(cfg.dict_size): + self.dictionary.add_symbol("word{}".format(i)) + self.dictionary.pad_to_multiple_(8) # often faster if divisible by 8 + logger.info("dictionary: {} types".format(len(self.dictionary))) + + seq = torch.arange(cfg.tokens_per_sample + 1) + self.dictionary.pad() + 1 + + self.dummy_src = seq[:-1] + self.dummy_tgt = seq[1:] + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if self.cfg.batch_size is not None: + bsz = self.cfg.batch_size + else: + bsz = max(1, self.cfg.max_tokens // self.cfg.tokens_per_sample) + self.datasets[split] = DummyDataset( + { + "id": 1, + "net_input": { + "src_tokens": torch.stack([self.dummy_src for _ in range(bsz)]), + "src_lengths": torch.full( + (bsz,), self.cfg.tokens_per_sample, dtype=torch.long + ), + }, + "target": torch.stack([self.dummy_tgt for _ in range(bsz)]), + "nsentences": bsz, + "ntokens": bsz * self.cfg.tokens_per_sample, + }, + num_items=self.cfg.dataset_size, + item_size=self.cfg.tokens_per_sample, + ) + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary diff --git a/fairseq/fairseq/benchmark/dummy_masked_lm.py b/fairseq/fairseq/benchmark/dummy_masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..12b9c5d0f55993bf8750564882a351fc3f8055f0 --- /dev/null +++ b/fairseq/fairseq/benchmark/dummy_masked_lm.py @@ -0,0 +1,94 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from dataclasses import dataclass, field +from typing import Optional + +import torch +from omegaconf import II + +from .dummy_dataset import DummyDataset +from fairseq.data import Dictionary +from fairseq.dataclass import FairseqDataclass +from fairseq.tasks import FairseqTask, register_task + +logger = logging.getLogger(__name__) + + +@dataclass +class DummyMaskedLMConfig(FairseqDataclass): + dict_size: int = 49996 + dataset_size: int = 100000 + tokens_per_sample: int = field( + default=512, + metadata={ + "help": "max number of total tokens over all" + " segments per sample for BERT dataset" + }, + ) + batch_size: Optional[int] = II("dataset.batch_size") + max_tokens: Optional[int] = II("dataset.max_tokens") + max_target_positions: int = II("task.tokens_per_sample") + + +@register_task("dummy_masked_lm", dataclass=DummyMaskedLMConfig) +class DummyMaskedLMTask(FairseqTask): + def __init__(self, cfg: DummyMaskedLMConfig): + super().__init__(cfg) + + self.dictionary = Dictionary() + for i in range(cfg.dict_size): + self.dictionary.add_symbol("word{}".format(i)) + logger.info("dictionary: {} types".format(len(self.dictionary))) + # add mask token + self.mask_idx = self.dictionary.add_symbol("<mask>") + self.dictionary.pad_to_multiple_(8) # often faster if divisible by 8 + + mask_idx = 0 + pad_idx = 1 + seq = torch.arange(cfg.tokens_per_sample) + pad_idx + 1 + mask = torch.arange(2, cfg.tokens_per_sample, 7) # ~15% + src = seq.clone() + src[mask] = mask_idx + tgt = torch.full_like(seq, pad_idx) + tgt[mask] = seq[mask] + + self.dummy_src = src + self.dummy_tgt = tgt + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if self.cfg.batch_size is not None: + bsz = self.cfg.batch_size + else: + bsz = max(1, self.cfg.max_tokens // self.cfg.tokens_per_sample) + self.datasets[split] = DummyDataset( + { + "id": 1, + "net_input": { + "src_tokens": torch.stack([self.dummy_src for _ in range(bsz)]), + "src_lengths": torch.full( + (bsz,), self.cfg.tokens_per_sample, dtype=torch.long + ), + }, + "target": torch.stack([self.dummy_tgt for _ in range(bsz)]), + "nsentences": bsz, + "ntokens": bsz * self.cfg.tokens_per_sample, + }, + num_items=self.cfg.dataset_size, + item_size=self.cfg.tokens_per_sample, + ) + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary diff --git a/fairseq/fairseq/benchmark/dummy_model.py b/fairseq/fairseq/benchmark/dummy_model.py new file mode 100644 index 0000000000000000000000000000000000000000..ff26e4fe655d8e8d7f9942c4bd3df7cd267405fb --- /dev/null +++ b/fairseq/fairseq/benchmark/dummy_model.py @@ -0,0 +1,96 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +import torch.nn.functional as F +from fairseq.data import Dictionary +from fairseq.models import ( + FairseqDecoder, + FairseqLanguageModel, + register_model, + register_model_architecture, +) + + +@register_model("dummy_model") +class DummyModel(FairseqLanguageModel): + def __init__(self, args, encoder): + super().__init__(encoder) + self.args = args + + @staticmethod + def add_args(parser): + parser.add_argument("--num-layers", type=int, default=24) + parser.add_argument("--embed-dim", type=int, default=1024) + + @classmethod + def build_model(cls, args, task): + encoder = DummyEncoder( + num_embed=len(task.target_dictionary), + embed_dim=args.embed_dim, + num_layers=args.num_layers, + ) + return cls(args, encoder) + + def forward(self, src_tokens, masked_tokens=None, **kwargs): + return self.decoder(src_tokens, masked_tokens=masked_tokens) + + +class DummyEncoder(FairseqDecoder): + def __init__(self, num_embed=50000, embed_dim=1024, num_layers=24): + super().__init__(Dictionary()) + self.embed = nn.Embedding( + num_embeddings=num_embed, embedding_dim=embed_dim, padding_idx=0 + ) + self.layers_a = nn.ModuleList( + [ + nn.Sequential( + nn.LayerNorm(embed_dim), + nn.Linear(embed_dim, 3 * embed_dim), # q, k, v input projection + nn.Linear(3 * embed_dim, embed_dim), # skip self-attention + nn.Linear(embed_dim, embed_dim), # output projection + nn.Dropout(), + ) + for i in range(num_layers) + ] + ) + self.layers_b = nn.ModuleList( + [ + nn.Sequential( + nn.LayerNorm(embed_dim), + nn.Linear(embed_dim, 4 * embed_dim), # FFN + nn.ReLU(), + nn.Linear(4 * embed_dim, embed_dim), # FFN + nn.Dropout(0.1), + ) + for i in range(num_layers) + ] + ) + self.out_proj = nn.Linear(embed_dim, num_embed) + + def forward(self, tokens, masked_tokens=None): + x = self.embed(tokens) + for layer_a, layer_b in zip(self.layers_a, self.layers_b): + x = x + layer_a(x) + x = x + layer_b(x) + x = self.out_proj(x) + if masked_tokens is not None: + x = x[masked_tokens] + return (x,) + + def max_positions(self): + return 1024 + + def get_normalized_probs(self, net_output, log_probs, sample=None): + logits = net_output[0].float() + if log_probs: + return F.log_softmax(logits, dim=-1) + else: + return F.softmax(logits, dim=-1) + + +@register_model_architecture("dummy_model", "dummy_model") +def base_architecture(args): + pass diff --git a/fairseq/fairseq/benchmark/dummy_mt.py b/fairseq/fairseq/benchmark/dummy_mt.py new file mode 100644 index 0000000000000000000000000000000000000000..4ca7be93a38d8d2b47685b74b4f8b8f9dcb03d2e --- /dev/null +++ b/fairseq/fairseq/benchmark/dummy_mt.py @@ -0,0 +1,119 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import numpy as np +import torch +from fairseq.data import Dictionary, FairseqDataset +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("dummy_mt") +class DummyMTTask(LegacyFairseqTask): + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument("--dict-size", default=49996, type=int) + parser.add_argument("--dataset-size", default=100000, type=int) + parser.add_argument("--src-len", default=30, type=int) + parser.add_argument("--tgt-len", default=30, type=int) + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + self.seed = args.seed + + dictionary.pad_to_multiple_(8) # often faster if divisible by 8 + + self.dummy_src = torch.arange(args.src_len + 1) + dictionary.pad() + 1 + self.dummy_tgt = torch.arange(args.tgt_len + 1) + dictionary.pad() + 1 + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task. """ + dictionary = Dictionary() + for i in range(args.dict_size): + dictionary.add_symbol("word{}".format(i)) + logger.info("dictionary: {} types".format(len(dictionary))) + + args.max_source_positions = args.src_len + dictionary.pad() + 2 + args.max_target_positions = args.tgt_len + dictionary.pad() + 2 + + return cls(args, dictionary) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + Args: + split (str): name of the split (e.g., train, valid, test) + """ + item_size = max(self.args.src_len, self.args.tgt_len) + if self.args.batch_size is not None: + bsz = self.args.batch_size + else: + bsz = max(1, self.args.max_tokens // item_size) + tgt = torch.stack([self.dummy_tgt for _ in range(bsz)]) + self.datasets[split] = DummyDataset( + { + "id": 1, + "net_input": { + "src_tokens": torch.stack([self.dummy_src for _ in range(bsz)]), + "src_lengths": torch.full( + (bsz,), self.args.src_len, dtype=torch.long + ), + "prev_output_tokens": tgt.clone(), + }, + "target": tgt, + "nsentences": bsz, + "ntokens": bsz * self.args.tgt_len, + }, + num_items=self.args.dataset_size, + item_size=item_size, + ) + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + +class DummyDataset(FairseqDataset): + def __init__(self, batch, num_items, item_size): + super().__init__() + self.batch = batch + self.num_items = num_items + self.item_size = item_size + + def __getitem__(self, index): + return index + + def __len__(self): + return self.num_items + + def collater(self, samples): + return self.batch + + @property + def sizes(self): + return np.array([self.item_size] * self.num_items) + + def num_tokens(self, index): + return self.item_size + + def size(self, index): + return self.item_size + + def ordered_indices(self): + return np.arange(self.num_items) + + @property + def supports_prefetch(self): + return False diff --git a/fairseq/fairseq/binarizer.py b/fairseq/fairseq/binarizer.py new file mode 100644 index 0000000000000000000000000000000000000000..ae4d02a6dbbb523b76eb8684e87e38c74fe7c4a1 --- /dev/null +++ b/fairseq/fairseq/binarizer.py @@ -0,0 +1,80 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import Counter +from typing import Dict + +import torch + +from fairseq.file_chunker_utils import Chunker +from fairseq.file_io import PathManager +from fairseq.tokenizer import tokenize_line + + +class Binarizer: + @staticmethod + def binarize( + filename, + dict, + consumer, + tokenize=tokenize_line, + append_eos=True, + reverse_order=False, + offset=0, + end=-1, + already_numberized=False, + ) -> Dict[str, int]: + nseq, ntok = 0, 0 + replaced = Counter() + + def replaced_consumer(word, idx): + if idx == dict.unk_index and word != dict.unk_word: + replaced.update([word]) + + with Chunker( + PathManager.get_local_path(filename), offset, end + ) as line_iterator: + for line in line_iterator: + if already_numberized: + id_strings = line.strip().split() + id_list = [int(id_string) for id_string in id_strings] + if reverse_order: + id_list.reverse() + if append_eos: + id_list.append(dict.eos()) + ids = torch.IntTensor(id_list) + else: + ids = dict.encode_line( + line=line, + line_tokenizer=tokenize, + add_if_not_exist=False, + consumer=replaced_consumer, + append_eos=append_eos, + reverse_order=reverse_order, + ) + nseq += 1 + ntok += len(ids) + consumer(ids) + return { + "nseq": nseq, + "nunk": sum(replaced.values()), + "ntok": ntok, + "replaced": replaced, + } + + @staticmethod + def binarize_alignments( + filename, alignment_parser, consumer, offset=0, end=-1 + ) -> Dict[str, int]: + nseq = 0 + + with Chunker( + PathManager.get_local_path(filename), offset, end + ) as line_iterator: + for line in line_iterator: + ids = alignment_parser(line) + nseq += 1 + consumer(ids) + return {"nseq": nseq} diff --git a/fairseq/fairseq/checkpoint_utils.py b/fairseq/fairseq/checkpoint_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ef5d4c9022c3c35722f0bc9150260c7a65d35e5f --- /dev/null +++ b/fairseq/fairseq/checkpoint_utils.py @@ -0,0 +1,858 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import ast +import collections +import contextlib +import logging +import numpy as np +import os +import re +import time +import traceback +from collections import OrderedDict +from typing import Any, Dict, Optional, Union + +import torch +from fairseq.data import data_utils +from fairseq.dataclass.configs import CheckpointConfig +from fairseq.dataclass.utils import ( + convert_namespace_to_omegaconf, + overwrite_args_by_name, +) +from fairseq.distributed.fully_sharded_data_parallel import FSDP, has_FSDP +from fairseq.file_io import PathManager +from fairseq.models import FairseqDecoder, FairseqEncoder +from omegaconf import DictConfig, open_dict, OmegaConf + + +logger = logging.getLogger(__name__) + + +def save_checkpoint(cfg: CheckpointConfig, trainer, epoch_itr, val_loss): + from fairseq import meters + + # only one worker should attempt to create the required dir + if trainer.data_parallel_rank == 0: + os.makedirs(cfg.save_dir, exist_ok=True) + + prev_best = getattr(save_checkpoint, "best", val_loss) + if val_loss is not None: + best_function = max if cfg.maximize_best_checkpoint_metric else min + save_checkpoint.best = best_function(val_loss, prev_best) + + if cfg.no_save: + return + + trainer.consolidate_optimizer() # TODO(SS): do we need this if no_save_optimizer_state + + if not trainer.should_save_checkpoint_on_current_rank: + if trainer.always_call_state_dict_during_save_checkpoint: + trainer.state_dict() + return + + write_timer = meters.StopwatchMeter() + write_timer.start() + + epoch = epoch_itr.epoch + end_of_epoch = epoch_itr.end_of_epoch() + updates = trainer.get_num_updates() + + logger.info(f"Preparing to save checkpoint for epoch {epoch} @ {updates} updates") + + def is_better(a, b): + return a >= b if cfg.maximize_best_checkpoint_metric else a <= b + + suffix = trainer.checkpoint_suffix + checkpoint_conds = collections.OrderedDict() + checkpoint_conds["checkpoint{}{}.pt".format(epoch, suffix)] = ( + end_of_epoch and not cfg.no_epoch_checkpoints and epoch % cfg.save_interval == 0 + ) + checkpoint_conds["checkpoint_{}_{}{}.pt".format(epoch, updates, suffix)] = ( + not end_of_epoch + and cfg.save_interval_updates > 0 + and updates % cfg.save_interval_updates == 0 + ) + checkpoint_conds["checkpoint_best{}.pt".format(suffix)] = val_loss is not None and ( + not hasattr(save_checkpoint, "best") + or is_better(val_loss, save_checkpoint.best) + ) + if val_loss is not None and cfg.keep_best_checkpoints > 0: + worst_best = getattr(save_checkpoint, "best", None) + chkpts = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint\.best_{}_(\d+\.?\d*){}\.pt".format( + cfg.best_checkpoint_metric, suffix + ), + ) + if len(chkpts) > 0: + p = chkpts[-1] if cfg.maximize_best_checkpoint_metric else chkpts[0] + worst_best = float(p.rsplit("_")[-1].replace("{}.pt".format(suffix), "")) + # add random digits to resolve ties + with data_utils.numpy_seed(epoch, updates, val_loss): + rand_sfx = np.random.randint(0, cfg.keep_best_checkpoints) + + checkpoint_conds[ + "checkpoint.best_{}_{:.3f}{}{}.pt".format( + cfg.best_checkpoint_metric, + val_loss, + rand_sfx, + suffix + ) + ] = worst_best is None or is_better(val_loss, worst_best) + checkpoint_conds[ + "checkpoint_last{}.pt".format(suffix) + ] = not cfg.no_last_checkpoints + + extra_state = {"train_iterator": epoch_itr.state_dict(), "val_loss": val_loss} + if hasattr(save_checkpoint, "best"): + extra_state.update({"best": save_checkpoint.best}) + + checkpoints = [ + os.path.join(cfg.save_dir, fn) for fn, cond in checkpoint_conds.items() if cond + ] + if len(checkpoints) > 0: + trainer.save_checkpoint(checkpoints[0], extra_state) + for cp in checkpoints[1:]: + if cfg.write_checkpoints_asynchronously: + # TODO[ioPath]: Need to implement a delayed asynchronous + # file copying/moving feature. + logger.warning( + f"ioPath is not copying {checkpoints[0]} to {cp} " + "since async write mode is on." + ) + else: + assert PathManager.copy( + checkpoints[0], cp, overwrite=True + ), f"Failed to copy {checkpoints[0]} to {cp}" + + write_timer.stop() + logger.info( + "Saved checkpoint {} (epoch {} @ {} updates, score {}) (writing took {} seconds)".format( + checkpoints[0], epoch, updates, val_loss, write_timer.sum + ) + ) + + if not end_of_epoch and cfg.keep_interval_updates > 0: + # remove old checkpoints; checkpoints are sorted in descending order + if cfg.keep_interval_updates_pattern == -1: + checkpoints = checkpoint_paths( + cfg.save_dir, pattern=r"checkpoint_\d+_(\d+){}\.pt".format(suffix) + ) + else: + checkpoints = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint_\d+_(\d+){}\.pt".format(suffix), + keep_match=True, + ) + checkpoints = [ + x[0] + for x in checkpoints + if x[1] % cfg.keep_interval_updates_pattern != 0 + ] + + for old_chk in checkpoints[cfg.keep_interval_updates :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + if cfg.keep_last_epochs > 0: + # remove old epoch checkpoints; checkpoints are sorted in descending order + checkpoints = checkpoint_paths( + cfg.save_dir, pattern=r"checkpoint(\d+){}\.pt".format(suffix) + ) + for old_chk in checkpoints[cfg.keep_last_epochs :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + if cfg.keep_best_checkpoints > 0: + # only keep the best N checkpoints according to validation metric + checkpoints = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint\.best_{}_(\d+\.?\d*){}\.pt".format( + cfg.best_checkpoint_metric, suffix + ), + ) + if not cfg.maximize_best_checkpoint_metric: + checkpoints = checkpoints[::-1] + for old_chk in checkpoints[cfg.keep_best_checkpoints :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + +def load_checkpoint(cfg: CheckpointConfig, trainer, **passthrough_args): + """ + Load a checkpoint and restore the training iterator. + + *passthrough_args* will be passed through to + ``trainer.get_train_iterator``. + """ + + reset_optimizer = cfg.reset_optimizer + reset_lr_scheduler = cfg.reset_lr_scheduler + optimizer_overrides = ast.literal_eval(cfg.optimizer_overrides) + reset_meters = cfg.reset_meters + reset_dataloader = cfg.reset_dataloader + + if cfg.finetune_from_model is not None and ( + reset_optimizer or reset_lr_scheduler or reset_meters or reset_dataloader + ): + raise ValueError( + "--finetune-from-model can not be set together with either --reset-optimizer" + " or reset_lr_scheduler or reset_meters or reset_dataloader" + ) + + suffix = trainer.checkpoint_suffix + if ( + cfg.restore_file == "checkpoint_last.pt" + ): # default value of restore_file is 'checkpoint_last.pt' + checkpoint_path = os.path.join( + cfg.save_dir, "checkpoint_last{}.pt".format(suffix) + ) + first_launch = not PathManager.exists(checkpoint_path) + if cfg.finetune_from_model is not None and first_launch: + # if there is no last checkpoint to restore, start the finetune from pretrained model + # else just use usual logic to load checkpoint, e.g. restart from last checkpoint and etc. + if PathManager.exists(cfg.finetune_from_model): + checkpoint_path = cfg.finetune_from_model + reset_optimizer = True + reset_lr_scheduler = True + reset_meters = True + reset_dataloader = True + logger.info( + f"loading pretrained model from {checkpoint_path}: " + "optimizer, lr scheduler, meters, dataloader will be reset" + ) + else: + raise ValueError( + f"--funetune-from-model {cfg.finetune_from_model} does not exist" + ) + elif suffix is not None: + checkpoint_path = cfg.restore_file.replace(".pt", suffix + ".pt") + else: + checkpoint_path = cfg.restore_file + + if cfg.restore_file != "checkpoint_last.pt" and cfg.finetune_from_model: + raise ValueError( + "--finetune-from-model and --restore-file (non-default value) " + "can not be specified together: " + str(cfg) + ) + + extra_state = trainer.load_checkpoint( + checkpoint_path, + reset_optimizer, + reset_lr_scheduler, + optimizer_overrides, + reset_meters=reset_meters, + ) + + if ( + extra_state is not None + and "best" in extra_state + and not reset_optimizer + and not reset_meters + ): + save_checkpoint.best = extra_state["best"] + + if extra_state is not None and not reset_dataloader: + # restore iterator from checkpoint + itr_state = extra_state["train_iterator"] + epoch_itr = trainer.get_train_iterator( + epoch=itr_state["epoch"], load_dataset=True, **passthrough_args + ) + epoch_itr.load_state_dict(itr_state) + else: + epoch_itr = trainer.get_train_iterator( + epoch=1, load_dataset=True, **passthrough_args + ) + + trainer.lr_step(epoch_itr.epoch) + + return extra_state, epoch_itr + + +def load_checkpoint_to_cpu(path, arg_overrides=None, load_on_all_ranks=False): + """Loads a checkpoint to CPU (with upgrading for backward compatibility). + + If doing single-GPU training or if the checkpoint is only being loaded by at + most one process on each node (current default behavior is for only rank 0 + to read the checkpoint from disk), load_on_all_ranks should be False to + avoid errors from torch.distributed not having been initialized or + torch.distributed.barrier() hanging. + + If all processes on each node may be loading the checkpoint + simultaneously, load_on_all_ranks should be set to True to avoid I/O + conflicts. + + There's currently no support for > 1 but < all processes loading the + checkpoint on each node. + """ + local_path = PathManager.get_local_path(path) + # The locally cached file returned by get_local_path() may be stale for + # remote files that are periodically updated/overwritten (ex: + # checkpoint_last.pt) - so we remove the local copy, sync across processes + # (if needed), and then download a fresh copy. + if local_path != path and PathManager.path_requires_pathmanager(path): + try: + os.remove(local_path) + except FileNotFoundError: + # With potentially multiple processes removing the same file, the + # file being missing is benign (missing_ok isn't available until + # Python 3.8). + pass + if load_on_all_ranks: + torch.distributed.barrier() + local_path = PathManager.get_local_path(path) + + with open(local_path, "rb") as f: + state = torch.load(f, map_location=torch.device("cpu")) + + if "args" in state and state["args"] is not None and arg_overrides is not None: + args = state["args"] + for arg_name, arg_val in arg_overrides.items(): + setattr(args, arg_name, arg_val) + + if "cfg" in state and state["cfg"] is not None: + + # hack to be able to set Namespace in dict config. this should be removed when we update to newer + # omegaconf version that supports object flags, or when we migrate all existing models + from omegaconf import _utils + + old_primitive = _utils.is_primitive_type + _utils.is_primitive_type = lambda _: True + + state["cfg"] = OmegaConf.create(state["cfg"]) + + _utils.is_primitive_type = old_primitive + OmegaConf.set_struct(state["cfg"], True) + + if arg_overrides is not None: + overwrite_args_by_name(state["cfg"], arg_overrides) + + state = _upgrade_state_dict(state) + return state + + +def load_model_ensemble( + filenames, + arg_overrides: Optional[Dict[str, Any]] = None, + task=None, + strict=True, + suffix="", + num_shards=1, + state=None, +): + """Loads an ensemble of models. + + Args: + filenames (List[str]): checkpoint files to load + arg_overrides (Dict[str,Any], optional): override model args that + were used during model training + task (fairseq.tasks.FairseqTask, optional): task to use for loading + """ + assert not ( + strict and num_shards > 1 + ), "Cannot load state dict with strict=True and checkpoint shards > 1" + ensemble, args, _task = load_model_ensemble_and_task( + filenames, + arg_overrides, + task, + strict, + suffix, + num_shards, + state, + ) + return ensemble, args + + +def get_maybe_sharded_checkpoint_filename( + filename: str, suffix: str, shard_idx: int, num_shards: int +) -> str: + orig_filename = filename + filename = filename.replace(".pt", suffix + ".pt") + fsdp_filename = filename[:-3] + f"-shard{shard_idx}.pt" + model_parallel_filename = orig_filename[:-3] + f"_part{shard_idx}.pt" + if PathManager.exists(fsdp_filename): + return fsdp_filename + elif num_shards > 1: + return model_parallel_filename + else: + return filename + + +def load_model_ensemble_and_task( + filenames, + arg_overrides: Optional[Dict[str, Any]] = None, + task=None, + strict=True, + suffix="", + num_shards=1, + state=None, +): + assert state is None or len(filenames) == 1 + + from fairseq import tasks + + assert not ( + strict and num_shards > 1 + ), "Cannot load state dict with strict=True and checkpoint shards > 1" + ensemble = [] + cfg = None + for filename in filenames: + orig_filename = filename + model_shard_state = {"shard_weights": [], "shard_metadata": []} + assert num_shards > 0 + st = time.time() + for shard_idx in range(num_shards): + filename = get_maybe_sharded_checkpoint_filename( + orig_filename, suffix, shard_idx, num_shards + ) + + if not PathManager.exists(filename): + raise IOError("Model file not found: {}".format(filename)) + if state is None: + state = load_checkpoint_to_cpu(filename, arg_overrides) + if "args" in state and state["args"] is not None: + cfg = convert_namespace_to_omegaconf(state["args"]) + elif "cfg" in state and state["cfg"] is not None: + cfg = state["cfg"] + else: + raise RuntimeError( + f"Neither args nor cfg exist in state keys = {state.keys()}" + ) + + if task is None: + task = tasks.setup_task(cfg.task) + + if "task_state" in state: + task.load_state_dict(state["task_state"]) + + if "fsdp_metadata" in state and num_shards > 1: + model_shard_state["shard_weights"].append(state["model"]) + model_shard_state["shard_metadata"].append(state["fsdp_metadata"]) + # check FSDP import before the code goes too far + if not has_FSDP: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + if shard_idx == num_shards - 1: + consolidated_model_state = FSDP.consolidate_shard_weights( + shard_weights=model_shard_state["shard_weights"], + shard_metadata=model_shard_state["shard_metadata"], + ) + model = task.build_model(cfg.model) + model.load_state_dict( + consolidated_model_state, strict=strict, model_cfg=cfg.model + ) + else: + # model parallel checkpoint or unsharded checkpoint + model = task.build_model(cfg.model) + model.load_state_dict( + state["model"], strict=strict, model_cfg=cfg.model + ) + + # reset state so it gets loaded for the next model in ensemble + state = None + if shard_idx % 10 == 0 and shard_idx > 0: + elapsed = time.time() - st + logger.info( + f"Loaded {shard_idx} shards in {elapsed:.2f}s, {elapsed / (shard_idx+1):.2f}s/shard" + ) + + # build model for ensemble + ensemble.append(model) + return ensemble, cfg, task + + +def checkpoint_paths(path, pattern=r"checkpoint(\d+)\.pt", keep_match=False): + """Retrieves all checkpoints found in `path` directory. + + Checkpoints are identified by matching filename to the specified pattern. If + the pattern contains groups, the result will be sorted by the first group in + descending order. + """ + pt_regexp = re.compile(pattern) + files = PathManager.ls(path) + + entries = [] + for i, f in enumerate(files): + m = pt_regexp.fullmatch(f) + if m is not None: + idx = float(m.group(1)) if len(m.groups()) > 0 else i + entries.append((idx, m.group(0))) + if keep_match: + return [(os.path.join(path, x[1]), x[0]) for x in sorted(entries, reverse=True)] + else: + return [os.path.join(path, x[1]) for x in sorted(entries, reverse=True)] + + +def torch_persistent_save(obj, filename, async_write: bool = False): + if async_write: + with PathManager.opena(filename, "wb") as f: + _torch_persistent_save(obj, f) + else: + if PathManager.supports_rename(filename): + # do atomic save + with PathManager.open(filename + ".tmp", "wb") as f: + _torch_persistent_save(obj, f) + PathManager.rename(filename + ".tmp", filename) + else: + # fallback to non-atomic save + with PathManager.open(filename, "wb") as f: + _torch_persistent_save(obj, f) + + +def _torch_persistent_save(obj, f): + if isinstance(f, str): + with PathManager.open(f, "wb") as h: + torch_persistent_save(obj, h) + return + for i in range(3): + try: + return torch.save(obj, f) + except Exception: + if i == 2: + logger.error(traceback.format_exc()) + raise + + +def _upgrade_state_dict(state): + """Helper for upgrading old model checkpoints.""" + + # add optimizer_history + if "optimizer_history" not in state: + state["optimizer_history"] = [ + {"criterion_name": "CrossEntropyCriterion", "best_loss": state["best_loss"]} + ] + state["last_optimizer_state"] = state["optimizer"] + del state["optimizer"] + del state["best_loss"] + # move extra_state into sub-dictionary + if "epoch" in state and "extra_state" not in state: + state["extra_state"] = { + "epoch": state["epoch"], + "batch_offset": state["batch_offset"], + "val_loss": state["val_loss"], + } + del state["epoch"] + del state["batch_offset"] + del state["val_loss"] + # reduce optimizer history's memory usage (only keep the last state) + if "optimizer" in state["optimizer_history"][-1]: + state["last_optimizer_state"] = state["optimizer_history"][-1]["optimizer"] + for optim_hist in state["optimizer_history"]: + del optim_hist["optimizer"] + # record the optimizer class name + if "optimizer_name" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["optimizer_name"] = "FairseqNAG" + # move best_loss into lr_scheduler_state + if "lr_scheduler_state" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["lr_scheduler_state"] = { + "best": state["optimizer_history"][-1]["best_loss"] + } + del state["optimizer_history"][-1]["best_loss"] + # keep track of number of updates + if "num_updates" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["num_updates"] = 0 + # old model checkpoints may not have separate source/target positions + if ( + "args" in state + and hasattr(state["args"], "max_positions") + and not hasattr(state["args"], "max_source_positions") + ): + state["args"].max_source_positions = state["args"].max_positions + state["args"].max_target_positions = state["args"].max_positions + # use stateful training data iterator + if "train_iterator" not in state["extra_state"]: + state["extra_state"]["train_iterator"] = { + "epoch": state["extra_state"]["epoch"], + "iterations_in_epoch": state["extra_state"].get("batch_offset", 0), + } + + # backward compatibility, cfg updates + if "args" in state and state["args"] is not None: + # default to translation task + if not hasattr(state["args"], "task"): + state["args"].task = "translation" + # --raw-text and --lazy-load are deprecated + if getattr(state["args"], "raw_text", False): + state["args"].dataset_impl = "raw" + elif getattr(state["args"], "lazy_load", False): + state["args"].dataset_impl = "lazy" + # epochs start at 1 + if state["extra_state"]["train_iterator"] is not None: + state["extra_state"]["train_iterator"]["epoch"] = max( + state["extra_state"]["train_iterator"].get("epoch", 1), 1 + ) + # --remove-bpe ==> --postprocess + if hasattr(state["args"], "remove_bpe"): + state["args"].post_process = state["args"].remove_bpe + # --min-lr ==> --stop-min-lr + if hasattr(state["args"], "min_lr"): + state["args"].stop_min_lr = state["args"].min_lr + del state["args"].min_lr + # binary_cross_entropy / kd_binary_cross_entropy => wav2vec criterion + if ( + hasattr(state["args"], "criterion") + and state["args"].criterion in [ + "binary_cross_entropy", + "kd_binary_cross_entropy", + ] + ): + state["args"].criterion = "wav2vec" + # remove log_keys if it's None (criteria will supply a default value of []) + if hasattr(state["args"], "log_keys") and state["args"].log_keys is None: + delattr(state["args"], "log_keys") + # speech_pretraining => audio pretraining + if ( + hasattr(state["args"], "task") + and state["args"].task == "speech_pretraining" + ): + state["args"].task = "audio_pretraining" + # audio_cpc => wav2vec + if hasattr(state["args"], "arch") and state["args"].arch == "audio_cpc": + state["args"].arch = "wav2vec" + # convert legacy float learning rate to List[float] + if hasattr(state["args"], "lr") and isinstance(state["args"].lr, float): + state["args"].lr = [state["args"].lr] + # convert task data arg to a string instead of List[string] + if ( + hasattr(state["args"], "data") + and isinstance(state["args"].data, list) + and len(state["args"].data) > 0 + ): + state["args"].data = state["args"].data[0] + # remove keys in state["args"] related to teacher-student learning + for key in [ + "static_teachers", + "static_teacher_weights", + "dynamic_teachers", + "dynamic_teacher_weights", + ]: + if key in state["args"]: + delattr(state["args"], key) + + state["cfg"] = convert_namespace_to_omegaconf(state["args"]) + + if "cfg" in state and state["cfg"] is not None: + cfg = state["cfg"] + with open_dict(cfg): + # any upgrades for Hydra-based configs + if ( + "task" in cfg + and "eval_wer_config" in cfg.task + and isinstance(cfg.task.eval_wer_config.print_alignment, bool) + ): + cfg.task.eval_wer_config.print_alignment = "hard" + if "generation" in cfg and isinstance(cfg.generation.print_alignment, bool): + cfg.generation.print_alignment = "hard" if cfg.generation.print_alignment else None + if ( + "model" in cfg + and "w2v_args" in cfg.model + and cfg.model.w2v_args is not None + and ( + hasattr(cfg.model.w2v_args, "task") or "task" in cfg.model.w2v_args + ) + and hasattr(cfg.model.w2v_args.task, "eval_wer_config") + and cfg.model.w2v_args.task.eval_wer_config is not None + and isinstance( + cfg.model.w2v_args.task.eval_wer_config.print_alignment, bool + ) + ): + cfg.model.w2v_args.task.eval_wer_config.print_alignment = "hard" + + return state + + +def prune_state_dict(state_dict, model_cfg: Optional[DictConfig]): + """Prune the given state_dict if desired for LayerDrop + (https://arxiv.org/abs/1909.11556). + + Training with LayerDrop allows models to be robust to pruning at inference + time. This function prunes state_dict to allow smaller models to be loaded + from a larger model and re-maps the existing state_dict for this to occur. + + It's called by functions that load models from checkpoints and does not + need to be called directly. + """ + arch = None + if model_cfg is not None: + arch = ( + model_cfg._name + if isinstance(model_cfg, DictConfig) + else getattr(model_cfg, "arch", None) + ) + + if not model_cfg or arch is None or arch == "ptt_transformer": + # args should not be none, but don't crash if it is. + return state_dict + + encoder_layers_to_keep = getattr(model_cfg, "encoder_layers_to_keep", None) + decoder_layers_to_keep = getattr(model_cfg, "decoder_layers_to_keep", None) + + if not encoder_layers_to_keep and not decoder_layers_to_keep: + return state_dict + + # apply pruning + logger.info( + "Pruning model to specified layer configuration - this works best if the model was trained with LayerDrop" + ) + + def create_pruning_pass(layers_to_keep, layer_name): + keep_layers = sorted( + int(layer_string) for layer_string in layers_to_keep.split(",") + ) + mapping_dict = {} + for i in range(len(keep_layers)): + mapping_dict[str(keep_layers[i])] = str(i) + + regex = re.compile(r"^{layer}.*\.layers\.(\d+)".format(layer=layer_name)) + return {"substitution_regex": regex, "mapping_dict": mapping_dict} + + pruning_passes = [] + if encoder_layers_to_keep: + pruning_passes.append(create_pruning_pass(encoder_layers_to_keep, "encoder")) + if decoder_layers_to_keep: + pruning_passes.append(create_pruning_pass(decoder_layers_to_keep, "decoder")) + + new_state_dict = {} + for layer_name in state_dict.keys(): + match = re.search(r"\.layers\.(\d+)\.", layer_name) + # if layer has no number in it, it is a supporting layer, such as an + # embedding + if not match: + new_state_dict[layer_name] = state_dict[layer_name] + continue + + # otherwise, layer should be pruned. + original_layer_number = match.group(1) + # figure out which mapping dict to replace from + for pruning_pass in pruning_passes: + if original_layer_number in pruning_pass["mapping_dict"] and pruning_pass[ + "substitution_regex" + ].search(layer_name): + new_layer_number = pruning_pass["mapping_dict"][original_layer_number] + substitution_match = pruning_pass["substitution_regex"].search( + layer_name + ) + new_state_key = ( + layer_name[: substitution_match.start(1)] + + new_layer_number + + layer_name[substitution_match.end(1) :] + ) + new_state_dict[new_state_key] = state_dict[layer_name] + + # Since layers are now pruned, *_layers_to_keep are no longer needed. + # This is more of "It would make it work fix" rather than a proper fix. + if isinstance(model_cfg, DictConfig): + context = open_dict(model_cfg) + else: + context = contextlib.ExitStack() + with context: + if hasattr(model_cfg, "encoder_layers_to_keep"): + model_cfg.encoder_layers_to_keep = None + if hasattr(model_cfg, "decoder_layers_to_keep"): + model_cfg.decoder_layers_to_keep = None + + return new_state_dict + + +def load_pretrained_component_from_model( + component: Union[FairseqEncoder, FairseqDecoder], checkpoint: str +): + """ + Load a pretrained FairseqEncoder or FairseqDecoder from checkpoint into the + provided `component` object. If state_dict fails to load, there may be a + mismatch in the architecture of the corresponding `component` found in the + `checkpoint` file. + """ + if not PathManager.exists(checkpoint): + raise IOError("Model file not found: {}".format(checkpoint)) + state = load_checkpoint_to_cpu(checkpoint) + if isinstance(component, FairseqEncoder): + component_type = "encoder" + elif isinstance(component, FairseqDecoder): + component_type = "decoder" + else: + raise ValueError( + "component to load must be either a FairseqEncoder or " + "FairseqDecoder. Loading other component types are not supported." + ) + component_state_dict = OrderedDict() + for key in state["model"].keys(): + if key.startswith(component_type): + # encoder.input_layers.0.0.weight --> input_layers.0.0.weight + component_subkey = key[len(component_type) + 1 :] + component_state_dict[component_subkey] = state["model"][key] + component.load_state_dict(component_state_dict, strict=True) + return component + + +def verify_checkpoint_directory(save_dir: str) -> None: + if not os.path.exists(save_dir): + os.makedirs(save_dir, exist_ok=True) + temp_file_path = os.path.join(save_dir, "dummy") + try: + with open(temp_file_path, "w"): + pass + except OSError as e: + logger.warning( + "Unable to access checkpoint save directory: {}".format(save_dir) + ) + raise e + else: + os.remove(temp_file_path) + + +def load_ema_from_checkpoint(fpath): + """Loads exponential moving averaged (EMA) checkpoint from input and + returns a model with ema weights. + + Args: + fpath: A string path of checkpoint to load from. + + Returns: + A dict of string keys mapping to various values. The 'model' key + from the returned dict should correspond to an OrderedDict mapping + string parameter names to torch Tensors. + """ + params_dict = collections.OrderedDict() + new_state = None + + with PathManager.open(fpath, 'rb') as f: + new_state = torch.load( + f, + map_location=( + lambda s, _: torch.serialization.default_restore_location(s, 'cpu') + ), + ) + + # EMA model is stored in a separate "extra state" + model_params = new_state['extra_state']['ema'] + + for key in list(model_params.keys()): + p = model_params[key] + if isinstance(p, torch.HalfTensor): + p = p.float() + if key not in params_dict: + params_dict[key] = p.clone() + # NOTE: clone() is needed in case of p is a shared parameter + else: + raise ValueError("Key {} is repeated in EMA model params.".format(key)) + + if len(params_dict) == 0: + raise ValueError( + f"Input checkpoint path '{fpath}' does not contain " + "ema model weights, is this model trained with EMA?" + ) + + new_state['model'] = params_dict + return new_state diff --git a/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda.cpp b/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda.cpp new file mode 100644 index 0000000000000000000000000000000000000000..707219105a17a691e43de1296a72bbaffa0c7fe9 --- /dev/null +++ b/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda.cpp @@ -0,0 +1,55 @@ +/* +Copyright (c) Microsoft Corporation. +Licensed under the MIT License. +*/ + +#include <torch/extension.h> +#include <vector> + +/* +CPP Binding for CUDA OP +*/ + +// CUDA forward declarations +torch::Tensor ngram_repeat_block_cuda_forward( + torch::Tensor tokens, + torch::Tensor lprobs, + int bsz, + int step, + int beam_size, + int no_repeat_ngram_size); + +#define CHECK_CUDA(x) \ + TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +// Input check and call to CUDA OP +// Backward method not required +torch::Tensor ngram_repeat_block_forward( + torch::Tensor tokens, + torch::Tensor lprobs, + int bsz, + int step, + int beam_size, + int no_repeat_ngram_size) { + CHECK_INPUT(tokens); + CHECK_INPUT(lprobs); + assert(bsz > 0); + assert(step >= 0); + assert(beam_size > 0); + assert(no_repeat_ngram_size > 0); + + return ngram_repeat_block_cuda_forward( + tokens, lprobs, bsz, step, beam_size, no_repeat_ngram_size); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def( + "forward", + &ngram_repeat_block_forward, + "No Repeat Ngram Block forward (CUDA)"); +} diff --git a/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda_kernel.cu b/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..bd6106cba0672c3ff29c925b0f5cea557ab3eced --- /dev/null +++ b/fairseq/fairseq/clib/cuda/ngram_repeat_block_cuda_kernel.cu @@ -0,0 +1,82 @@ +/* +Copyright (c) Microsoft Corporation. +Licensed under the MIT License. +*/ + +/* +Kernel implementation for blocking repeated n-grams. +*/ + +#include <cuda.h> +#include <cuda_runtime.h> +#include <math.h> +#include <torch/extension.h> +#include <vector> + +// Ban repeated ngrams of length = 'no_repeat_ngram_size' +__global__ void banRepeatedTokens( + long* __restrict__ tokens, + float* __restrict__ lprobs, + int max_predict_len, + int vocab_size, + int no_repeat_ngram_size) { + auto row = blockIdx.x; + auto col = threadIdx.x; + auto start = row * (max_predict_len) + col; + // Each thread compares ngram starting from + // thread index with final ngram starting from + // step - no_repeat_ngram_size +2 + auto check_start_pos = blockDim.x; + auto lprob_start = row * vocab_size; + bool is_banned = true; + extern __shared__ long tokens_shm[]; + tokens_shm[col] = tokens[start]; + if (col == blockDim.x - 1) { + for (int i = 1; i < no_repeat_ngram_size; i++) { + if (col + i < max_predict_len) { + tokens_shm[col + i] = tokens[start + i]; + } + } + } + __syncthreads(); + + for (int k = 0; k < no_repeat_ngram_size - 1; k++) { + if (tokens_shm[col + k] != tokens_shm[check_start_pos + k]) { + is_banned = false; + } + } + if (is_banned == true) { + auto token_to_be_banned = tokens_shm[col + no_repeat_ngram_size - 1]; + lprobs[lprob_start + token_to_be_banned] = -INFINITY; + } +} + +// Allocate blocks and threads based on +// batch size and sequence length and launch +// kernel +torch::Tensor ngram_repeat_block_cuda_forward( + const torch::Tensor tokens, + torch::Tensor lprobs, + int bsz, + int step, + int beam_size, + int no_repeat_ngram_size) { + int threads = step - no_repeat_ngram_size + 2; + if (threads <= 0) + return lprobs; + int max_predict_len = tokens.size(1); + int vocab_size = lprobs.size(1); + auto token_ptr = tokens.data_ptr<long>(); + auto lprob_ptr = lprobs.data_ptr<float>(); + int blocks = bsz * beam_size; + int shared_mem_size = (step + 1) * sizeof(long); + + // Launching N blocks where N is number of samples in a batch (beams*bsz) + // Launching T threads where T is number of previous ngrams in a sample + // Allocating shared mem per block for fastser access of input tokens since + // each token will be accessed N times to compare with current Ngram where + // N is Ngram size. + banRepeatedTokens<<<blocks, threads, shared_mem_size>>>( + token_ptr, lprob_ptr, max_predict_len, vocab_size, no_repeat_ngram_size); + return lprobs; +} diff --git a/fairseq/fairseq/clib/libbase/balanced_assignment.cpp b/fairseq/fairseq/clib/libbase/balanced_assignment.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1a5a1061f3892be5a17e49192f744c39e0d395e8 --- /dev/null +++ b/fairseq/fairseq/clib/libbase/balanced_assignment.cpp @@ -0,0 +1,109 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* +C++ code for solving the linear assignment problem. +Based on the Auction Algorithm from +https://dspace.mit.edu/bitstream/handle/1721.1/3265/P-2108-26912652.pdf and the +implementation from: https://github.com/bkj/auction-lap Adapted to be more +efficient when each worker is looking for k jobs instead of 1. +*/ +#include <torch/extension.h> +#include <iostream> +using namespace torch::indexing; +torch::Tensor balanced_assignment(torch::Tensor job_and_worker_to_score) { + int max_iterations = 100; + torch::Tensor epsilon = + (job_and_worker_to_score.max() - job_and_worker_to_score.min()) / 50; + epsilon.clamp_min_(1e-04); + torch::Tensor worker_and_job_to_score = + job_and_worker_to_score.detach().transpose(0, 1).contiguous(); + int num_workers = worker_and_job_to_score.size(0); + int num_jobs = worker_and_job_to_score.size(1); + auto device = worker_and_job_to_score.device(); + int jobs_per_worker = num_jobs / num_workers; + torch::Tensor value = worker_and_job_to_score.clone(); + int counter = 0; + torch::Tensor max_value = worker_and_job_to_score.max(); + + torch::Tensor bid_indices; + torch::Tensor cost = worker_and_job_to_score.new_zeros({1, num_jobs}); + torch::Tensor bids = + worker_and_job_to_score.new_empty({num_workers, num_jobs}); + torch::Tensor bid_increments = + worker_and_job_to_score.new_empty({num_workers, jobs_per_worker}); + torch::Tensor top_values = + worker_and_job_to_score.new_empty({num_workers, jobs_per_worker + 1}); + torch::Tensor high_bids = worker_and_job_to_score.new_empty({num_jobs}); + + torch::Tensor top_index = top_values.to(torch::kLong); + torch::Tensor high_bidders = top_index.new_empty({num_jobs}); + torch::Tensor have_bids = high_bidders.to(torch::kBool); + torch::Tensor jobs_indices = + torch::arange({num_jobs}, torch::dtype(torch::kLong).device(device)); + torch::Tensor true_tensor = + torch::ones({1}, torch::dtype(torch::kBool).device(device)); + + while (true) { + bids.zero_(); + torch::topk_out(top_values, top_index, value, jobs_per_worker + 1, 1); + + // Each worker bids the difference in value between that job and the k+1th + // job + torch::sub_out( + bid_increments, + top_values.index({Slice(None, None), Slice(0, jobs_per_worker)}), + top_values.index({Slice(None, None), jobs_per_worker}).unsqueeze(1)); + + bid_increments.add_(epsilon); + bids.scatter_( + 1, + top_index.index({Slice(None, None), Slice(0, jobs_per_worker)}), + bid_increments); + + if (counter < max_iterations && counter > 0) { + // Put in a minimal bid to retain items from the last round if no-one else + // bids for them this round + bids.view(-1).index_put_({bid_indices}, epsilon); + } + + // Find the highest bidding worker per job + torch::max_out(high_bids, high_bidders, bids, 0); + torch::gt_out(have_bids, high_bids, 0); + + if (have_bids.all().item<bool>()) { + // All jobs were bid for + break; + } + + // Make popular items more expensive + cost.add_(high_bids); + torch::sub_out(value, worker_and_job_to_score, cost); + + bid_indices = ((high_bidders * num_jobs) + jobs_indices).index({have_bids}); + + if (counter < max_iterations) { + // Make sure that this item will be in the winning worker's top-k next + // time. + value.view(-1).index_put_({bid_indices}, max_value); + } else { + // Suboptimal approximation that converges quickly from current solution + value.view(-1).index_put_( + {bid_indices}, worker_and_job_to_score.view(-1).index({bid_indices})); + } + + counter += 1; + } + + return top_index.index({Slice(None, None), Slice(0, jobs_per_worker)}) + .reshape(-1); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("balanced_assignment", &balanced_assignment, "Balanced Assignment"); +} diff --git a/fairseq/fairseq/clib/libbleu/libbleu.cpp b/fairseq/fairseq/clib/libbleu/libbleu.cpp new file mode 100644 index 0000000000000000000000000000000000000000..939d9e1174e398fa48c840009b592c753a67939a --- /dev/null +++ b/fairseq/fairseq/clib/libbleu/libbleu.cpp @@ -0,0 +1,157 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <array> +#include <cstdio> +#include <cstring> +#include <map> + +// NOLINTNEXTLINE +typedef struct { + size_t reflen; + size_t predlen; + size_t match1; + size_t count1; + size_t match2; + size_t count2; + size_t match3; + size_t count3; + size_t match4; + size_t count4; +} bleu_stat; + +// left trim (remove pad) +void bleu_ltrim(size_t* len, int** sent, int pad) { + size_t start = 0; + while (start < *len) { + if (*(*sent + start) != pad) { + break; + } + start++; + } + *sent += start; + *len -= start; +} + +// right trim remove (eos) +void bleu_rtrim(size_t* len, int** sent, int pad, int eos) { + size_t end = *len - 1; + while (end > 0) { + if (*(*sent + end) != eos && *(*sent + end) != pad) { + break; + } + end--; + } + *len = end + 1; +} + +// left and right trim +void bleu_trim(size_t* len, int** sent, int pad, int eos) { + bleu_ltrim(len, sent, pad); + bleu_rtrim(len, sent, pad, eos); +} + +size_t bleu_hash(int len, int* data) { + size_t h = 14695981039346656037ul; + size_t prime = 0x100000001b3; + char* b = (char*)data; + size_t blen = sizeof(int) * len; + + while (blen-- > 0) { + h ^= *b++; + h *= prime; + } + + return h; +} + +void bleu_addngram( + size_t* ntotal, + size_t* nmatch, + size_t n, + size_t reflen, + int* ref, + size_t predlen, + int* pred) { + if (predlen < n) { + return; + } + + predlen = predlen - n + 1; + (*ntotal) += predlen; + + if (reflen < n) { + return; + } + + reflen = reflen - n + 1; + + std::map<size_t, size_t> count; + while (predlen > 0) { + size_t w = bleu_hash(n, pred++); + count[w]++; + predlen--; + } + + while (reflen > 0) { + size_t w = bleu_hash(n, ref++); + if (count[w] > 0) { + (*nmatch)++; + count[w] -= 1; + } + reflen--; + } +} + +extern "C" { + +#ifdef _WIN64 +__declspec(dllexport) +#endif + void bleu_zero_init(bleu_stat* stat) { + std::memset(stat, 0, sizeof(bleu_stat)); +} + +#ifdef _WIN64 +__declspec(dllexport) +#endif + void bleu_one_init(bleu_stat* stat) { + bleu_zero_init(stat); + stat->count1 = 0; + stat->count2 = 1; + stat->count3 = 1; + stat->count4 = 1; + stat->match1 = 0; + stat->match2 = 1; + stat->match3 = 1; + stat->match4 = 1; +} + +#ifdef _WIN64 +__declspec(dllexport) +#endif + void bleu_add( + bleu_stat* stat, + size_t reflen, + int* ref, + size_t predlen, + int* pred, + int pad, + int eos) { + + bleu_trim(&reflen, &ref, pad, eos); + bleu_trim(&predlen, &pred, pad, eos); + stat->reflen += reflen; + stat->predlen += predlen; + + bleu_addngram(&stat->count1, &stat->match1, 1, reflen, ref, predlen, pred); + bleu_addngram(&stat->count2, &stat->match2, 2, reflen, ref, predlen, pred); + bleu_addngram(&stat->count3, &stat->match3, 3, reflen, ref, predlen, pred); + bleu_addngram(&stat->count4, &stat->match4, 4, reflen, ref, predlen, pred); +} +} diff --git a/fairseq/fairseq/clib/libbleu/module.cpp b/fairseq/fairseq/clib/libbleu/module.cpp new file mode 100644 index 0000000000000000000000000000000000000000..35288b3177185670135f7bdc1f1589c5bb992304 --- /dev/null +++ b/fairseq/fairseq/clib/libbleu/module.cpp @@ -0,0 +1,33 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <Python.h> + +static PyMethodDef method_def[] = {{NULL, NULL, 0, NULL}}; // NOLINT + +static struct PyModuleDef module_def = { + PyModuleDef_HEAD_INIT, + "libbleu", /* name of module */ + // NOLINTNEXTLINE + NULL, /* module documentation, may be NULL */ + -1, /* size of per-interpreter state of the module, + or -1 if the module keeps state in global variables. */ + method_def}; // NOLINT + +#if PY_MAJOR_VERSION == 2 +PyMODINIT_FUNC init_libbleu() +#else +PyMODINIT_FUNC PyInit_libbleu() +#endif +{ + PyObject* m = PyModule_Create(&module_def); + if (!m) { + return NULL; + } + return m; +} diff --git a/fairseq/fairseq/clib/libnat/edit_dist.cpp b/fairseq/fairseq/clib/libnat/edit_dist.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9ffb60569d74d2868ed8113b7c787ef870e9da20 --- /dev/null +++ b/fairseq/fairseq/clib/libnat/edit_dist.cpp @@ -0,0 +1,231 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <pybind11/detail/common.h> +#include <pybind11/pybind11.h> +#include <torch/torch.h> // @manual=//caffe2:torch_extension +#include <algorithm> +#include <cstdint> +#include <iosfwd> +#include <memory> +#include <new> +#include <string> +#include <utility> +#include <vector> + +using namespace ::std; + +vector<vector<uint32_t>> edit_distance2_with_dp( + vector<uint32_t>& x, + vector<uint32_t>& y) { + uint32_t lx = x.size(); + uint32_t ly = y.size(); + vector<vector<uint32_t>> d(lx + 1, vector<uint32_t>(ly + 1)); + for (uint32_t i = 0; i < lx + 1; i++) { + d[i][0] = i; + } + for (uint32_t j = 0; j < ly + 1; j++) { + d[0][j] = j; + } + for (uint32_t i = 1; i < lx + 1; i++) { + for (uint32_t j = 1; j < ly + 1; j++) { + d[i][j] = + min(min(d[i - 1][j], d[i][j - 1]) + 1, + d[i - 1][j - 1] + 2 * (x.at(i - 1) == y.at(j - 1) ? 0 : 1)); + } + } + return d; +} + +vector<vector<uint32_t>> edit_distance2_backtracking( + vector<vector<uint32_t>>& d, + vector<uint32_t>& x, + vector<uint32_t>& y, + uint32_t terminal_symbol) { + vector<uint32_t> seq; + vector<vector<uint32_t>> edit_seqs(x.size() + 2, vector<uint32_t>()); + /* + edit_seqs: + 0~x.size() cell is the insertion sequences + last cell is the delete sequence + */ + + if (x.size() == 0) { + edit_seqs.at(0) = y; + return edit_seqs; + } + + uint32_t i = d.size() - 1; + uint32_t j = d.at(0).size() - 1; + + while ((i >= 0) && (j >= 0)) { + if ((i == 0) && (j == 0)) { + break; + } + + if ((j > 0) && (d.at(i).at(j - 1) < d.at(i).at(j))) { + seq.push_back(1); // insert + seq.push_back(y.at(j - 1)); + j--; + } else if ((i > 0) && (d.at(i - 1).at(j) < d.at(i).at(j))) { + seq.push_back(2); // delete + seq.push_back(x.at(i - 1)); + i--; + } else { + seq.push_back(3); // keep + seq.push_back(x.at(i - 1)); + i--; + j--; + } + } + + uint32_t prev_op, op, s, word; + prev_op = 0, s = 0; + for (uint32_t k = 0; k < seq.size() / 2; k++) { + op = seq.at(seq.size() - 2 * k - 2); + word = seq.at(seq.size() - 2 * k - 1); + if (prev_op != 1) { + s++; + } + if (op == 1) // insert + { + edit_seqs.at(s - 1).push_back(word); + } else if (op == 2) // delete + { + edit_seqs.at(x.size() + 1).push_back(1); + } else { + edit_seqs.at(x.size() + 1).push_back(0); + } + + prev_op = op; + } + + for (uint32_t k = 0; k < edit_seqs.size(); k++) { + if (edit_seqs[k].size() == 0) { + edit_seqs[k].push_back(terminal_symbol); + } + } + return edit_seqs; +} + +vector<vector<uint32_t>> edit_distance2_backtracking_with_delete( + vector<vector<uint32_t>>& d, + vector<uint32_t>& x, + vector<uint32_t>& y, + uint32_t terminal_symbol, + uint32_t deletion_symbol) { + vector<uint32_t> seq; + vector<vector<uint32_t>> edit_seqs(x.size() + 1, vector<uint32_t>()); + /* + edit_seqs: + 0~x.size() cell is the insertion sequences + last cell is the delete sequence + */ + + if (x.size() == 0) { + edit_seqs.at(0) = y; + return edit_seqs; + } + + uint32_t i = d.size() - 1; + uint32_t j = d.at(0).size() - 1; + + while ((i >= 0) && (j >= 0)) { + if ((i == 0) && (j == 0)) { + break; + } + + if ((j > 0) && (d.at(i).at(j - 1) < d.at(i).at(j))) { + seq.push_back(1); // insert + seq.push_back(y.at(j - 1)); + j--; + } else if ((i > 0) && (d.at(i - 1).at(j) < d.at(i).at(j))) { + seq.push_back(2); // delete + seq.push_back(x.at(i - 1)); + i--; + } else { + seq.push_back(3); // keep + seq.push_back(x.at(i - 1)); + i--; + j--; + } + } + + uint32_t prev_op, op, s, word; + prev_op = 0, s = 0; + for (uint32_t k = 0; k < seq.size() / 2; k++) { + op = seq.at(seq.size() - 2 * k - 2); + word = seq.at(seq.size() - 2 * k - 1); + if (prev_op != 1) { + s++; + } + if (op == 1) // insert + { + edit_seqs.at(s - 1).push_back(word); + } else if (op == 2) // delete + { + edit_seqs.at(s - 1).push_back(deletion_symbol); + } + + prev_op = op; + } + + for (uint32_t k = 0; k < edit_seqs.size(); k++) { + if (edit_seqs.at(k).size() == 0) { + edit_seqs.at(k).push_back(terminal_symbol); + } + } + return edit_seqs; +} + +vector<uint32_t> compute_ed2( + vector<vector<uint32_t>>& xs, + vector<vector<uint32_t>>& ys) { + vector<uint32_t> distances(xs.size()); + for (uint32_t i = 0; i < xs.size(); i++) { + vector<vector<uint32_t>> d = edit_distance2_with_dp(xs.at(i), ys.at(i)); + distances.at(i) = d.at(xs.at(i).size()).at(ys.at(i).size()); + } + return distances; +} + +vector<vector<vector<uint32_t>>> suggested_ed2_path( + vector<vector<uint32_t>>& xs, + vector<vector<uint32_t>>& ys, + uint32_t terminal_symbol) { + vector<vector<vector<uint32_t>>> seq(xs.size()); + for (uint32_t i = 0; i < xs.size(); i++) { + vector<vector<uint32_t>> d = edit_distance2_with_dp(xs.at(i), ys.at(i)); + seq.at(i) = + edit_distance2_backtracking(d, xs.at(i), ys.at(i), terminal_symbol); + } + return seq; +} + +vector<vector<vector<uint32_t>>> suggested_ed2_path_with_delete( + vector<vector<uint32_t>>& xs, + vector<vector<uint32_t>>& ys, + uint32_t terminal_symbol, + uint32_t deletion_symbol) { + vector<vector<vector<uint32_t>>> seq(xs.size()); + for (uint32_t i = 0; i < xs.size(); i++) { + vector<vector<uint32_t>> d = edit_distance2_with_dp(xs.at(i), ys.at(i)); + seq.at(i) = edit_distance2_backtracking_with_delete( + d, xs.at(i), ys.at(i), terminal_symbol, deletion_symbol); + } + return seq; +} + +PYBIND11_MODULE(libnat, m) { + m.def("compute_ed2", &compute_ed2, "compute_ed2"); + m.def("suggested_ed2_path", &suggested_ed2_path, "suggested_ed2_path"); + m.def( + "suggested_ed2_path_with_delete", + &suggested_ed2_path_with_delete, + "suggested_ed2_path_with_delete"); +} diff --git a/fairseq/fairseq/clib/libnat_cuda/binding.cpp b/fairseq/fairseq/clib/libnat_cuda/binding.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ced91c0d0afab9071842911d9876e6360d90284a --- /dev/null +++ b/fairseq/fairseq/clib/libnat_cuda/binding.cpp @@ -0,0 +1,67 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +/* + This code is partially adpoted from + https://github.com/1ytic/pytorch-edit-distance + */ + +#include <torch/types.h> +#include "edit_dist.h" + +#ifndef TORCH_CHECK +#define TORCH_CHECK AT_CHECK +#endif + +#define CHECK_CUDA(x) \ + TORCH_CHECK(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + TORCH_CHECK(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +torch::Tensor LevenshteinDistance( + torch::Tensor source, + torch::Tensor target, + torch::Tensor source_length, + torch::Tensor target_length) { + CHECK_INPUT(source); + CHECK_INPUT(target); + CHECK_INPUT(source_length); + CHECK_INPUT(target_length); + return LevenshteinDistanceCuda(source, target, source_length, target_length); +} + +torch::Tensor GenerateDeletionLabel( + torch::Tensor source, + torch::Tensor operations) { + CHECK_INPUT(source); + CHECK_INPUT(operations); + return GenerateDeletionLabelCuda(source, operations); +} + +std::pair<torch::Tensor, torch::Tensor> GenerateInsertionLabel( + torch::Tensor target, + torch::Tensor operations) { + CHECK_INPUT(target); + CHECK_INPUT(operations); + return GenerateInsertionLabelCuda(target, operations); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("levenshtein_distance", &LevenshteinDistance, "Levenshtein distance"); + m.def( + "generate_deletion_labels", + &GenerateDeletionLabel, + "Generate Deletion Label"); + m.def( + "generate_insertion_labels", + &GenerateInsertionLabel, + "Generate Insertion Label"); +} diff --git a/fairseq/fairseq/clib/libnat_cuda/edit_dist.cu b/fairseq/fairseq/clib/libnat_cuda/edit_dist.cu new file mode 100644 index 0000000000000000000000000000000000000000..96569d46c8475a90f3d51152023a46780464ecbd --- /dev/null +++ b/fairseq/fairseq/clib/libnat_cuda/edit_dist.cu @@ -0,0 +1,344 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "edit_dist.h" + +#include <THC/THC.h> +#include <cuda.h> +#include <cuda_runtime.h> +#include <device_launch_parameters.h> +#include <utility> // std::pair + +template <typename scalar_t> +__global__ void generate_deletion_label_kernel( + const scalar_t* __restrict__ source, + const size_t source_size, + const size_t operation_size, + int* __restrict__ operations, + int* __restrict__ labels) { + const int index = blockIdx.x; + const int offset = index * operation_size; + const int offset_label = index * source_size; + + for (int i = 0; i < source_size; i++) { + labels[offset_label + i] = 0; + } + + int k = 0; + for (int i = 0; i < operation_size; i++) { + if (operations[offset + i] == 0) { + break; + } else if (operations[offset + i] == 1) { + continue; + } else { + labels[offset_label + k] = 3 - operations[offset + i]; + k++; + } + } +} + +template <typename scalar_t> +__global__ void generate_insertion_label_kernel( + const scalar_t* __restrict__ target, + const size_t target_size, + const size_t operation_size, + int* __restrict__ operations, + int* __restrict__ labels, + int* __restrict__ masks) { + const int index = blockIdx.x; + const int offset = index * operation_size; + const int offset_label = index * target_size; + + int k = 0; + int u = 0; + int m = 0; + + for (int i = 0; i < target_size; i++) { + labels[offset_label + i] = 0; + masks[offset_label + i] = 0; + } + + for (int i = 0; i < operation_size - 1; i++) { + if (operations[offset + i] == 0) { + break; + } else if (operations[offset + i] == 2) { + continue; + } else if (operations[offset + i] == 1) { + masks[offset_label + m] = 1; + u++; + m++; + } else { + labels[offset_label + k] = u; + masks[offset_label + m] = 0; + k++; + m++; + u = 0; + } + } +} + +template <typename scalar_t> +__global__ void levenshtein_distance_kernel( + const scalar_t* __restrict__ source, + const scalar_t* __restrict__ target, + const int* __restrict__ source_length, + const int* __restrict__ target_length, + const size_t source_size, + const size_t target_size, + int* __restrict__ operations, + int* __restrict__ errors_curr) { + const int index = blockIdx.x; + const int offset = index * (source_size + target_size); + const int d = index * (source_size + 1) * (target_size + 1); + const int t = target_size + 1; + + auto err_idx = [d, t](int i, int j) { return d + i * t + j; }; + auto opt_idx = [offset](int k) { return offset + k; }; + + const int hyp_len = source_length[index]; + const int ref_len = target_length[index]; + const scalar_t* hyp_begin = source + index * source_size; + const scalar_t* ref_begin = target + index * target_size; + + // dynamic programming + for (int i = 0; i <= hyp_len; i++) { + errors_curr[err_idx(i, 0)] = i; + } + for (int j = 0; j <= ref_len; j++) { + errors_curr[err_idx(0, j)] = j; + } + for (int i = 1; i <= hyp_len; i++) { + for (int j = 1; j <= ref_len; j++) { + errors_curr[err_idx(i, j)] = min( + min(errors_curr[err_idx(i - 1, j)], errors_curr[err_idx(i, j - 1)]) + + 1, + errors_curr[err_idx(i - 1, j - 1)] + + 2 * (*(hyp_begin + i - 1) == *(ref_begin + j - 1) ? 0 : 1)); + } + } + + // back-tracing + int i = hyp_len; + int j = ref_len; + int o = hyp_len + ref_len; + + for (int k = 0; k < source_size + target_size; k++) { + operations[opt_idx(k)] = 0; + } + + while ((i >= 0) && (j >= 0)) { + if ((i == 0) && (j == 0)) { + break; + } + + if ((j > 0) && + (errors_curr[err_idx(i, j - 1)] < errors_curr[err_idx(i, j)])) { + o--; + operations[opt_idx(o)] = 1; + j--; // insertion + } else if ( + (i > 0) && + (errors_curr[err_idx(i - 1, j)] < errors_curr[err_idx(i, j)])) { + o--; + operations[opt_idx(o)] = 2; + i--; // deletion + } else { + o--; + operations[opt_idx(o)] = 3; + i--; + j--; // do nothing + } + } + + // moving to the left + for (int k = 0; k < hyp_len + ref_len; k++) { + if (k + o < hyp_len + ref_len) { + operations[opt_idx(k)] = operations[opt_idx(k + o)]; + } else { + operations[opt_idx(k)] = 0; // padding + } + } +} + +template <typename scalar_t> +__global__ void faster_levenshtein_distance_kernel( + const scalar_t* __restrict__ source, + const scalar_t* __restrict__ target, + const int* __restrict__ source_length, + const int* __restrict__ target_length, + const size_t source_size, + const size_t target_size, + int* __restrict__ operations) { + extern __shared__ short errors[]; + auto errors_curr = errors; + + const int index = blockIdx.x; + const int offset = index * (source_size + target_size); + const int t = target_size + 1; + + auto err_idx = [t](int i, int j) { return i * t + j; }; + auto opt_idx = [offset](int k) { return offset + k; }; + + const int hyp_len = source_length[index]; + const int ref_len = target_length[index]; + const scalar_t* hyp_begin = source + index * source_size; + const scalar_t* ref_begin = target + index * target_size; + + // dynamic programming + for (int i = 0; i <= hyp_len; i++) { + errors_curr[err_idx(i, 0)] = i; + } + for (int j = 0; j <= ref_len; j++) { + errors_curr[err_idx(0, j)] = j; + } + for (int i = 1; i <= hyp_len; i++) { + for (int j = 1; j <= ref_len; j++) { + errors_curr[err_idx(i, j)] = min( + min(errors_curr[err_idx(i - 1, j)], errors_curr[err_idx(i, j - 1)]) + + 1, + errors_curr[err_idx(i - 1, j - 1)] + + 2 * (*(hyp_begin + i - 1) == *(ref_begin + j - 1) ? 0 : 1)); + } + } + + // back-tracing + int i = hyp_len; + int j = ref_len; + int o = hyp_len + ref_len; + + for (int k = 0; k < source_size + target_size; k++) { + operations[opt_idx(k)] = 0; + } + + while ((i >= 0) && (j >= 0)) { + if ((i == 0) && (j == 0)) { + break; + } + + if ((j > 0) && + (errors_curr[err_idx(i, j - 1)] < errors_curr[err_idx(i, j)])) { + o--; + operations[opt_idx(o)] = 1; + j--; // insertion + } else if ( + (i > 0) && + (errors_curr[err_idx(i - 1, j)] < errors_curr[err_idx(i, j)])) { + o--; + operations[opt_idx(o)] = 2; + i--; // deletion + } else { + o--; + operations[opt_idx(o)] = 3; + i--; + j--; // do nothing + } + } + + // moving to the left + for (int k = 0; k < hyp_len + ref_len; k++) { + if (k + o < hyp_len + ref_len) { + operations[opt_idx(k)] = operations[opt_idx(k + o)]; + } else { + operations[opt_idx(k)] = 0; // padding + } + } +} + +torch::Tensor GenerateDeletionLabelCuda( + torch::Tensor source, + torch::Tensor operations) { + const auto batch_size = source.size(0); + at::TensorOptions options(source.device()); + options = options.dtype(at::ScalarType::Int); + auto labels = torch::empty({batch_size, source.size(1)}, options); + auto stream = at::cuda::getCurrentCUDAStream(source.device().index()); + + AT_DISPATCH_ALL_TYPES(source.scalar_type(), "generate_deletion_labels", ([&] { + generate_deletion_label_kernel<scalar_t> + <<<batch_size, 1, 0, stream>>>( + source.data_ptr<scalar_t>(), + source.size(1), + operations.size(1), + operations.data_ptr<int>(), + labels.data_ptr<int>()); + })); + + return labels; +} + +std::pair<torch::Tensor, torch::Tensor> GenerateInsertionLabelCuda( + torch::Tensor target, + torch::Tensor operations) { + const auto batch_size = target.size(0); + at::TensorOptions options(target.device()); + options = options.dtype(at::ScalarType::Int); + auto labels = torch::empty({batch_size, target.size(1)}, options); + auto masks = torch::empty({batch_size, target.size(1)}, options); + auto stream = at::cuda::getCurrentCUDAStream(target.device().index()); + + AT_DISPATCH_ALL_TYPES( + target.scalar_type(), "generate_insertion_labels", ([&] { + generate_insertion_label_kernel<scalar_t><<<batch_size, 1, 0, stream>>>( + target.data_ptr<scalar_t>(), + target.size(1), + operations.size(1), + operations.data_ptr<int>(), + labels.data_ptr<int>(), + masks.data_ptr<int>()); + })); + + return std::make_pair(labels, masks); +} + +torch::Tensor LevenshteinDistanceCuda( + torch::Tensor source, + torch::Tensor target, + torch::Tensor source_length, + torch::Tensor target_length) { + const auto batch_size = source.size(0); + const auto shared_size = + (source.size(1) + 1) * (target.size(1) + 1) * sizeof(short); + + at::TensorOptions options(source.device()); + options = options.dtype(at::ScalarType::Int); + auto operations = + torch::empty({batch_size, source.size(1) + target.size(1)}, options); + auto stream = at::cuda::getCurrentCUDAStream(source.device().index()); + + if (shared_size > 40000) { + auto distances = torch::empty( + {batch_size, (source.size(1) + 1) * (target.size(1) + 1)}, options); + AT_DISPATCH_ALL_TYPES(source.scalar_type(), "levenshtein_distance", ([&] { + levenshtein_distance_kernel<scalar_t> + <<<batch_size, 1, 0, stream>>>( + source.data_ptr<scalar_t>(), + target.data_ptr<scalar_t>(), + source_length.data_ptr<int>(), + target_length.data_ptr<int>(), + source.size(1), + target.size(1), + operations.data_ptr<int>(), + distances.data_ptr<int>()); + })); + } else { + AT_DISPATCH_ALL_TYPES( + source.scalar_type(), "faster_levenshtein_distance", ([&] { + faster_levenshtein_distance_kernel<scalar_t> + <<<batch_size, 1, shared_size, stream>>>( + source.data_ptr<scalar_t>(), + target.data_ptr<scalar_t>(), + source_length.data_ptr<int>(), + target_length.data_ptr<int>(), + source.size(1), + target.size(1), + operations.data_ptr<int>()); + })); + } + + return operations; +} diff --git a/fairseq/fairseq/clib/libnat_cuda/edit_dist.h b/fairseq/fairseq/clib/libnat_cuda/edit_dist.h new file mode 100644 index 0000000000000000000000000000000000000000..5220c52fd80529b90a67ba74e9ca73c668dab099 --- /dev/null +++ b/fairseq/fairseq/clib/libnat_cuda/edit_dist.h @@ -0,0 +1,25 @@ +/** + * Copyright 2017-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the license found in the + * LICENSE file in the root directory of this source tree. + */ + +#pragma once + +#include <torch/extension.h> + +torch::Tensor LevenshteinDistanceCuda( + torch::Tensor source, + torch::Tensor target, + torch::Tensor source_length, + torch::Tensor target_length); + +torch::Tensor GenerateDeletionLabelCuda( + torch::Tensor source, + torch::Tensor operations); + +std::pair<torch::Tensor, torch::Tensor> GenerateInsertionLabelCuda( + torch::Tensor source, + torch::Tensor operations); diff --git a/fairseq/fairseq/config/__init__.py b/fairseq/fairseq/config/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/fairseq/config/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/fairseq/config/config.yaml b/fairseq/fairseq/config/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2ed7168cb7f7473c43d864478c5c6ce51639e030 --- /dev/null +++ b/fairseq/fairseq/config/config.yaml @@ -0,0 +1,19 @@ +# @package _group_ + +hydra: + run: + dir: . + +defaults: + - _self_ + - task: null + - model: null + - criterion: cross_entropy + - optimizer: null + - lr_scheduler: fixed + - bpe: null + - tokenizer: null + - scoring: null + - generation: null + - common_eval: null + - eval_lm: null diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml new file mode 100644 index 0000000000000000000000000000000000000000..30b1a4f1e0f5e7f7c2671ff8ec995cc32363f10f --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_gbw.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 512 +decoder_output_dim: 512 +decoder_input_dim: 512 +decoder_ffn_embed_dim: 4096 +decoder_layers: 12 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1154cfa660ee5ce6a272cd1a0049eead1e92c117 --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_baevski_wiki103.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.3 +attention_dropout: 0.1 +activation_dropout: 0.1 +relu_dropout: 0.1 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 16 +decoder_attention_heads: 8 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: "20000,60000" +adaptive_softmax_dropout: 0.2 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: true +adaptive_input_factor: 4 +adaptive_input_cutoff: "20000,60000" +tie_adaptive_weights: true +tie_adaptive_proj: true +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml new file mode 100644 index 0000000000000000000000000000000000000000..309575310bfc5d9c5cde31563073bef18abc646e --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_big.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.1 +attention_dropout: 0.0 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 12 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gbw.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gbw.yaml new file mode 100644 index 0000000000000000000000000000000000000000..30b1a4f1e0f5e7f7c2671ff8ec995cc32363f10f --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gbw.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 512 +decoder_output_dim: 512 +decoder_input_dim: 512 +decoder_ffn_embed_dim: 4096 +decoder_layers: 12 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2c6cb7be3801115371566932ffc78651c9ac6c0f --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 768 +decoder_output_dim: 768 +decoder_input_dim: 768 +decoder_ffn_embed_dim: 3072 +decoder_layers: 12 +decoder_attention_heads: 12 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a08769a1781abdb13302bf57bf1338bcaf68a0ec --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_big.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1600 +decoder_output_dim: 1600 +decoder_input_dim: 1600 +decoder_ffn_embed_dim: 6400 +decoder_layers: 48 +decoder_attention_heads: 25 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml new file mode 100644 index 0000000000000000000000000000000000000000..64261d793c0f1ae091c9bf5c8c77093a07326137 --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_medium.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1280 +decoder_output_dim: 1280 +decoder_input_dim: 1280 +decoder_ffn_embed_dim: 5120 +decoder_layers: 36 +decoder_attention_heads: 20 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_small.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_small.yaml new file mode 100644 index 0000000000000000000000000000000000000000..702e81f466c82edf40433589d389edbe0a7b96db --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_gpt2_small.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "gelu" +dropout: 0.1 +attention_dropout: 0.1 +activation_dropout: 0.0 +relu_dropout: 0.0 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 24 +decoder_attention_heads: 16 +decoder_normalize_before: true +no_decoder_final_norm: false +adaptive_softmax_cutoff: null +adaptive_softmax_dropout: 0 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: false +adaptive_input_factor: 4 +adaptive_input_cutoff: null +tie_adaptive_weights: false +tie_adaptive_proj: false +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/transformer_lm/transformer_lm_wiki103.yaml b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_wiki103.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1154cfa660ee5ce6a272cd1a0049eead1e92c117 --- /dev/null +++ b/fairseq/fairseq/config/model/transformer_lm/transformer_lm_wiki103.yaml @@ -0,0 +1,36 @@ +# @package _group_ +activation_fn: "relu" +dropout: 0.3 +attention_dropout: 0.1 +activation_dropout: 0.1 +relu_dropout: 0.1 +decoder_embed_dim: 1024 +decoder_output_dim: 1024 +decoder_input_dim: 1024 +decoder_ffn_embed_dim: 4096 +decoder_layers: 16 +decoder_attention_heads: 8 +decoder_normalize_before: true +no_decoder_final_norm: true +adaptive_softmax_cutoff: "20000,60000" +adaptive_softmax_dropout: 0.2 +adaptive_softmax_factor: 4 +no_token_positional_embeddings: false +share_decoder_input_output_embed: false +character_embeddings: false +character_filters: "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]" +character_embedding_dim: 4 +char_embedder_highway_layers: 2 +adaptive_input: true +adaptive_input_factor: 4 +adaptive_input_cutoff: "20000,60000" +tie_adaptive_weights: true +tie_adaptive_proj: true +decoder_learned_pos: false +decoder_layerdrop: 0 +decoder_layers_to_keep: null +layernorm_embedding: false +no_scale_embedding: false +quant_noise_pq: 0 +quant_noise_pq_block_size: 8 +quant_noise_scalar: 0 diff --git a/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml b/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ee1329bf4612d8bb295c6cc3d8bc0a3bcef1777d --- /dev/null +++ b/fairseq/fairseq/config/model/wav2vec/vq_wav2vec_gumbel.yaml @@ -0,0 +1,5 @@ +# @package _group_ +activation: gelu +vq_type: gumbel +vq_depth: 2 +combine_groups: true diff --git a/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml b/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ce65499b808b9a3821cee4ca87c36e84d09005a1 --- /dev/null +++ b/fairseq/fairseq/config/model/wav2vec2/wav2vec2_base.yaml @@ -0,0 +1,8 @@ +# @package _group_ + +quantize_targets: true +final_dim: 256 +encoder_layerdrop: 0.05 +dropout_input: 0.1 +dropout_features: 0.1 +feature_grad_mult: 0.1 diff --git a/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml b/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml new file mode 100644 index 0000000000000000000000000000000000000000..5846f75243f27f201c85bfe6820815c015971275 --- /dev/null +++ b/fairseq/fairseq/config/model/wav2vec2/wav2vec2_large.yaml @@ -0,0 +1,20 @@ +# @package _group_ + +quantize_targets: true +extractor_mode: layer_norm +layer_norm_first: true +final_dim: 768 +latent_temp: [2.0,0.1,0.999995] +encoder_layerdrop: 0.0 +dropout_input: 0.0 +dropout_features: 0.0 +dropout: 0.0 +attention_dropout: 0.0 +conv_bias: true + +encoder_layers: 24 +encoder_embed_dim: 1024 +encoder_ffn_embed_dim: 4096 +encoder_attention_heads: 16 + +feature_grad_mult: 1.0 diff --git a/fairseq/fairseq/criterions/__init__.py b/fairseq/fairseq/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4dbf46a1cb31ce65c4224ae79cbc2d7cf9e4d111 --- /dev/null +++ b/fairseq/fairseq/criterions/__init__.py @@ -0,0 +1,36 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import importlib +import os + +from fairseq import registry +from fairseq.criterions.fairseq_criterion import ( # noqa + FairseqCriterion, + LegacyFairseqCriterion, +) +from omegaconf import DictConfig + + +( + build_criterion_, + register_criterion, + CRITERION_REGISTRY, + CRITERION_DATACLASS_REGISTRY, +) = registry.setup_registry( + "--criterion", base_class=FairseqCriterion, default="cross_entropy" +) + + +def build_criterion(cfg: DictConfig, task): + return build_criterion_(cfg, task) + + +# automatically import any Python files in the criterions/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + file_name = file[: file.find(".py")] + importlib.import_module("fairseq.criterions." + file_name) diff --git a/fairseq/fairseq/criterions/adaptive_loss.py b/fairseq/fairseq/criterions/adaptive_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..6209ceaedb6d8120ad820c11b55c13596447933c --- /dev/null +++ b/fairseq/fairseq/criterions/adaptive_loss.py @@ -0,0 +1,123 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass + +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.constants import DDP_BACKEND_CHOICES +from omegaconf import II + + +@dataclass +class AdaptiveLossConfig(FairseqDataclass): + sentence_avg: bool = II("optimization.sentence_avg") + ddp_backend: DDP_BACKEND_CHOICES = II("distributed_training.ddp_backend") + + +@register_criterion("adaptive_loss", dataclass=AdaptiveLossConfig) +class AdaptiveLoss(FairseqCriterion): + """This is an implementation of the loss function accompanying the adaptive softmax approximation for + graphical processing units (GPU), described in the paper "Efficient softmax approximation for GPUs" + (http://arxiv.org/abs/1609.04309).""" + + def __init__(self, task, sentence_avg): + super().__init__(task) + self.sentence_avg = sentence_avg + + @classmethod + def build_criterion(cls, cfg: AdaptiveLossConfig, task): + if cfg.ddp_backend in {"c10d", "pytorch_ddp"}: + raise Exception( + "AdaptiveLoss is not compatible with the PyTorch " + "version of DistributedDataParallel. Please use " + "`--ddp-backend=legacy_ddp` instead." + ) + return cls(task, cfg.sentence_avg) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + + assert ( + hasattr(model.decoder, "adaptive_softmax") + and model.decoder.adaptive_softmax is not None + ) + adaptive_softmax = model.decoder.adaptive_softmax + + net_output = model(**sample["net_input"]) + orig_target = model.get_targets(sample, net_output) + + nsentences = orig_target.size(0) + orig_target = orig_target.view(-1) + + bsz = orig_target.size(0) + + logits, target = adaptive_softmax(net_output[0], orig_target) + assert len(target) == len(logits) + + loss = net_output[0].new(1 if reduce else bsz).zero_() + + for i in range(len(target)): + if target[i] is not None: + assert target[i].min() >= 0 and target[i].max() <= logits[i].size(1) + loss += F.cross_entropy( + logits[i], + target[i], + ignore_index=self.padding_idx, + reduction="sum" if reduce else "none", + ) + + orig = utils.strip_pad(orig_target, self.padding_idx) + ntokens = orig.numel() + sample_size = sample["target"].size(0) if self.sentence_avg else ntokens + logging_output = { + "loss": loss.data, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs)) + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + else: + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/composite_loss.py b/fairseq/fairseq/criterions/composite_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..98e835fa6e4c0bcad062df9c519701bf795c98be --- /dev/null +++ b/fairseq/fairseq/criterions/composite_loss.py @@ -0,0 +1,100 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq import utils +from fairseq.criterions import LegacyFairseqCriterion, register_criterion +from torch import nn + + +@register_criterion("composite_loss") +class CompositeLoss(LegacyFairseqCriterion): + """This is a composite loss that, given a list of model outputs and a list of targets, + computes an average of losses for each output-target pair""" + + def __init__(self, args, task): + super().__init__(args, task) + self.underlying_criterion = args.underlying_criterion + + @staticmethod + def add_args(parser): + """Add criterion-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--underlying-criterion', type=str, metavar='VAL', required=True, + help='underlying criterion to use for the composite loss') + # fmt: on + + @staticmethod + def build_underlying_criterion(args, task): + saved_criterion = args.criterion + args.criterion = args.underlying_criterion + assert saved_criterion != args.underlying_criterion + underlying_criterion = task.build_criterion(args) + args.criterion = saved_criterion + return underlying_criterion + + @classmethod + def build_criterion(cls, args, task): + underlying_criterion = CompositeLoss.build_underlying_criterion(args, task) + + class FakeModel(nn.Module): + def __init__(self, model, net_out, target): + super().__init__() + self.model = model + self.net_out = net_out + self.target = target + + def forward(self, **unused): + return self.net_out + + def get_normalized_probs(self, net_output, log_probs, sample=None): + return self.model.get_normalized_probs( + net_output, log_probs, sample=sample + ) + + def get_targets(self, *unused): + return self.target + + @property + def decoder(self): + return self.model.decoder + + class _CompositeLoss(LegacyFairseqCriterion): + def __init__(self, args, task, underlying_criterion): + super().__init__(args, task) + self.underlying_criterion = underlying_criterion + + def forward(self, model, sample, reduce=True): + net_outputs = model(**sample["net_input"]) + targets = sample["target"] + + bsz = targets[0].size(0) + loss = net_outputs[0][0].new(1 if reduce else bsz).float().zero_() + + sample_size = 0 + logging_output = {} + for o, t in zip(net_outputs[0], targets): + m = FakeModel(model, (o, net_outputs[1]), t) + sample["target"] = t + l, ss, logging_output = self.underlying_criterion(m, sample, reduce) + loss += l + sample_size += ss + + loss.div_(len(targets)) + sample_size /= len(targets) + + logging_output["loss"] = utils.item(loss.data) if reduce else loss.data + return loss, sample_size, logging_output + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + return underlying_criterion.__class__.aggregate_logging_outputs( + logging_outputs + ) + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + underlying_criterion.__class__.reduce_metrics(logging_outputs) + + return _CompositeLoss(args, task, underlying_criterion) diff --git a/fairseq/fairseq/criterions/cross_entropy.py b/fairseq/fairseq/criterions/cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..fe461064716b38ecf2eb610daddbb609a1884e6b --- /dev/null +++ b/fairseq/fairseq/criterions/cross_entropy.py @@ -0,0 +1,90 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass + +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +@dataclass +class CrossEntropyCriterionConfig(FairseqDataclass): + sentence_avg: bool = II("optimization.sentence_avg") + + +@register_criterion("cross_entropy", dataclass=CrossEntropyCriterionConfig) +class CrossEntropyCriterion(FairseqCriterion): + def __init__(self, task, sentence_avg): + super().__init__(task) + self.sentence_avg = sentence_avg + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + loss, _ = self.compute_loss(model, net_output, sample, reduce=reduce) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + def compute_loss(self, model, net_output, sample, reduce=True): + lprobs = model.get_normalized_probs(net_output, log_probs=True) + lprobs = lprobs.view(-1, lprobs.size(-1)) + target = model.get_targets(sample, net_output).view(-1) + loss = F.nll_loss( + lprobs, + target, + ignore_index=self.padding_idx, + reduction="sum" if reduce else "none", + ) + return loss, loss + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + # we divide by log(2) to convert the loss from base e to base 2 + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + else: + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/ctc.py b/fairseq/fairseq/criterions/ctc.py new file mode 100644 index 0000000000000000000000000000000000000000..10e3618382c86a84466cb4264d62f31537980251 --- /dev/null +++ b/fairseq/fairseq/criterions/ctc.py @@ -0,0 +1,295 @@ +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import math +from argparse import Namespace +from dataclasses import dataclass, field +from omegaconf import II +from typing import Optional + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq.data.data_utils import post_process +from fairseq.tasks import FairseqTask +from fairseq.logging.meters import safe_round + + +@dataclass +class CtcCriterionConfig(FairseqDataclass): + zero_infinity: bool = field( + default=False, + metadata={"help": "zero inf loss when source length <= target length"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + post_process: str = field( + default="letter", + metadata={ + "help": "how to post process predictions into words. can be letter, " + "wordpiece, BPE symbols, etc. " + "See fairseq.data.data_utils.post_process() for full list of options" + }, + ) + wer_kenlm_model: Optional[str] = field( + default=None, + metadata={ + "help": "if this is provided, use kenlm to compute wer (along with other wer_* args)" + }, + ) + wer_lexicon: Optional[str] = field( + default=None, + metadata={"help": "lexicon to use with wer_kenlm_model"}, + ) + wer_lm_weight: float = field( + default=2.0, + metadata={"help": "lm weight to use with wer_kenlm_model"}, + ) + wer_word_score: float = field( + default=-1.0, + metadata={"help": "lm word score to use with wer_kenlm_model"}, + ) + + wer_args: Optional[str] = field( + default=None, + metadata={ + "help": "DEPRECATED: tuple of (wer_kenlm_model, wer_lexicon, wer_lm_weight, wer_word_score)" + }, + ) + + +@register_criterion("ctc", dataclass=CtcCriterionConfig) +class CtcCriterion(FairseqCriterion): + def __init__(self, cfg: CtcCriterionConfig, task: FairseqTask): + super().__init__(task) + self.blank_idx = ( + task.target_dictionary.index(task.blank_symbol) + if hasattr(task, "blank_symbol") + else 0 + ) + self.pad_idx = task.target_dictionary.pad() + self.eos_idx = task.target_dictionary.eos() + self.post_process = cfg.post_process + + if cfg.wer_args is not None: + ( + cfg.wer_kenlm_model, + cfg.wer_lexicon, + cfg.wer_lm_weight, + cfg.wer_word_score, + ) = eval(cfg.wer_args) + + if cfg.wer_kenlm_model is not None: + from examples.speech_recognition.w2l_decoder import W2lKenLMDecoder + + dec_args = Namespace() + dec_args.nbest = 1 + dec_args.criterion = "ctc" + dec_args.kenlm_model = cfg.wer_kenlm_model + dec_args.lexicon = cfg.wer_lexicon + dec_args.beam = 50 + dec_args.beam_size_token = min(50, len(task.target_dictionary)) + dec_args.beam_threshold = min(50, len(task.target_dictionary)) + dec_args.lm_weight = cfg.wer_lm_weight + dec_args.word_score = cfg.wer_word_score + dec_args.unk_weight = -math.inf + dec_args.sil_weight = 0 + + self.w2l_decoder = W2lKenLMDecoder(dec_args, task.target_dictionary) + else: + self.w2l_decoder = None + + self.zero_infinity = cfg.zero_infinity + self.sentence_avg = cfg.sentence_avg + + def forward(self, model, sample, reduce=True): + net_output = model(**sample["net_input"]) + lprobs = model.get_normalized_probs( + net_output, log_probs=True + ).contiguous() # (T, B, C) from the encoder + + if "src_lengths" in sample["net_input"]: + input_lengths = sample["net_input"]["src_lengths"] + else: + if net_output["padding_mask"] is not None: + non_padding_mask = ~net_output["padding_mask"] + input_lengths = non_padding_mask.long().sum(-1) + else: + input_lengths = lprobs.new_full( + (lprobs.size(1),), lprobs.size(0), dtype=torch.long + ) + + pad_mask = (sample["target"] != self.pad_idx) & ( + sample["target"] != self.eos_idx + ) + targets_flat = sample["target"].masked_select(pad_mask) + if "target_lengths" in sample: + target_lengths = sample["target_lengths"] + else: + target_lengths = pad_mask.sum(-1) + + with torch.backends.cudnn.flags(enabled=False): + loss = F.ctc_loss( + lprobs, + targets_flat, + input_lengths, + target_lengths, + blank=self.blank_idx, + reduction="sum", + zero_infinity=self.zero_infinity, + ) + + ntokens = ( + sample["ntokens"] if "ntokens" in sample else target_lengths.sum().item() + ) + + sample_size = sample["target"].size(0) if self.sentence_avg else ntokens + logging_output = { + "loss": utils.item(loss.data), # * sample['ntokens'], + "ntokens": ntokens, + "nsentences": sample["id"].numel(), + "sample_size": sample_size, + } + + if not model.training: + import editdistance + + with torch.no_grad(): + lprobs_t = lprobs.transpose(0, 1).float().contiguous().cpu() + + c_err = 0 + c_len = 0 + w_errs = 0 + w_len = 0 + wv_errs = 0 + for lp, t, inp_l in zip( + lprobs_t, + sample["target_label"] + if "target_label" in sample + else sample["target"], + input_lengths, + ): + lp = lp[:inp_l].unsqueeze(0) + + decoded = None + if self.w2l_decoder is not None: + decoded = self.w2l_decoder.decode(lp) + if len(decoded) < 1: + decoded = None + else: + decoded = decoded[0] + if len(decoded) < 1: + decoded = None + else: + decoded = decoded[0] + + p = (t != self.task.target_dictionary.pad()) & ( + t != self.task.target_dictionary.eos() + ) + targ = t[p] + targ_units = self.task.target_dictionary.string(targ) + targ_units_arr = targ.tolist() + + toks = lp.argmax(dim=-1).unique_consecutive() + pred_units_arr = toks[toks != self.blank_idx].tolist() + + c_err += editdistance.eval(pred_units_arr, targ_units_arr) + c_len += len(targ_units_arr) + + targ_words = post_process(targ_units, self.post_process).split() + + pred_units = self.task.target_dictionary.string(pred_units_arr) + pred_words_raw = post_process(pred_units, self.post_process).split() + + if decoded is not None and "words" in decoded: + pred_words = decoded["words"] + w_errs += editdistance.eval(pred_words, targ_words) + wv_errs += editdistance.eval(pred_words_raw, targ_words) + else: + dist = editdistance.eval(pred_words_raw, targ_words) + w_errs += dist + wv_errs += dist + + w_len += len(targ_words) + + logging_output["wv_errors"] = wv_errs + logging_output["w_errors"] = w_errs + logging_output["w_total"] = w_len + logging_output["c_errors"] = c_err + logging_output["c_total"] = c_len + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs)) + nsentences = utils.item( + sum(log.get("nsentences", 0) for log in logging_outputs) + ) + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar("ntokens", ntokens) + metrics.log_scalar("nsentences", nsentences) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + + c_errors = sum(log.get("c_errors", 0) for log in logging_outputs) + metrics.log_scalar("_c_errors", c_errors) + c_total = sum(log.get("c_total", 0) for log in logging_outputs) + metrics.log_scalar("_c_total", c_total) + w_errors = sum(log.get("w_errors", 0) for log in logging_outputs) + metrics.log_scalar("_w_errors", w_errors) + wv_errors = sum(log.get("wv_errors", 0) for log in logging_outputs) + metrics.log_scalar("_wv_errors", wv_errors) + w_total = sum(log.get("w_total", 0) for log in logging_outputs) + metrics.log_scalar("_w_total", w_total) + + if c_total > 0: + metrics.log_derived( + "uer", + lambda meters: safe_round( + meters["_c_errors"].sum * 100.0 / meters["_c_total"].sum, 3 + ) + if meters["_c_total"].sum > 0 + else float("nan"), + ) + if w_total > 0: + metrics.log_derived( + "wer", + lambda meters: safe_round( + meters["_w_errors"].sum * 100.0 / meters["_w_total"].sum, 3 + ) + if meters["_w_total"].sum > 0 + else float("nan"), + ) + metrics.log_derived( + "raw_wer", + lambda meters: safe_round( + meters["_wv_errors"].sum * 100.0 / meters["_w_total"].sum, 3 + ) + if meters["_w_total"].sum > 0 + else float("nan"), + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/fairseq_criterion.py b/fairseq/fairseq/criterions/fairseq_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..ff4beb02503ea48a6c09596630aad4c710be94b6 --- /dev/null +++ b/fairseq/fairseq/criterions/fairseq_criterion.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import inspect +from typing import Any, Dict, List + +from fairseq import metrics, utils +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import gen_parser_from_dataclass +from torch.nn.modules.loss import _Loss + + +class FairseqCriterion(_Loss): + def __init__(self, task): + super().__init__() + self.task = task + if hasattr(task, "target_dictionary"): + tgt_dict = task.target_dictionary + self.padding_idx = tgt_dict.pad() if tgt_dict is not None else -100 + + @classmethod + def add_args(cls, parser): + """Add criterion-specific arguments to the parser.""" + dc = getattr(cls, "__dataclass", None) + if dc is not None: + gen_parser_from_dataclass(parser, dc()) + + @classmethod + def build_criterion(cls, cfg: FairseqDataclass, task): + """Construct a criterion from command-line args.""" + # arguments in the __init__. + init_args = {} + for p in inspect.signature(cls).parameters.values(): + if ( + p.kind == p.POSITIONAL_ONLY + or p.kind == p.VAR_POSITIONAL + or p.kind == p.VAR_KEYWORD + ): + # we haven't implemented inference for these argument types, + # but PRs welcome :) + raise NotImplementedError("{} not supported".format(p.kind)) + + assert p.kind in {p.POSITIONAL_OR_KEYWORD, p.KEYWORD_ONLY} + + if p.name == "task": + init_args["task"] = task + elif p.name == "cfg": + init_args["cfg"] = cfg + elif hasattr(cfg, p.name): + init_args[p.name] = getattr(cfg, p.name) + elif p.default != p.empty: + pass # we'll use the default value + else: + raise NotImplementedError( + "Unable to infer Criterion arguments, please implement " + "{}.build_criterion".format(cls.__name__) + ) + return cls(**init_args) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + raise NotImplementedError + + @staticmethod + def aggregate_logging_outputs( + logging_outputs: List[Dict[str, Any]] + ) -> Dict[str, Any]: + """Aggregate logging outputs from data parallel training.""" + utils.deprecation_warning( + "The aggregate_logging_outputs API is deprecated. " + "Please use the reduce_metrics API instead." + ) + raise NotImplementedError + + @classmethod + def reduce_metrics(cls, logging_outputs: List[Dict[str, Any]]) -> None: + """Aggregate logging outputs from data parallel training.""" + utils.deprecation_warning( + "Criterions should implement the reduce_metrics API. " + "Falling back to deprecated aggregate_logging_outputs API." + ) + agg_logging_outputs = cls.aggregate_logging_outputs(logging_outputs) + for k, v in agg_logging_outputs.items(): + if k in {"nsentences", "ntokens", "sample_size"}: + continue + metrics.log_scalar(k, v) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return False + + +class LegacyFairseqCriterion(FairseqCriterion): + def __init__(self, args, task): + super().__init__(task=task) + self.args = args + + utils.deprecation_warning( + "Criterions should take explicit arguments instead of an " + "argparse.Namespace object, please update your criterion by " + "extending FairseqCriterion instead of LegacyFairseqCriterion." + ) + + @classmethod + def build_criterion(cls, args, task): + """Construct a criterion from command-line args.""" + return cls(args, task) diff --git a/fairseq/fairseq/criterions/fastspeech2_loss.py b/fairseq/fairseq/criterions/fastspeech2_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..085d5628d4c4c242edee4aa3bc4a01aa4582eb21 --- /dev/null +++ b/fairseq/fairseq/criterions/fastspeech2_loss.py @@ -0,0 +1,125 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +from typing import List, Dict, Any +from dataclasses import dataclass, field + +import torch +import torch.nn.functional as F + +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq.data.data_utils import lengths_to_mask +from fairseq.models.fairseq_model import FairseqEncoderModel + + +@dataclass +class FastSpeech2CriterionConfig(FairseqDataclass): + ctc_weight: float = field( + default=0.0, metadata={"help": "weight for CTC loss"} + ) + + +@register_criterion("fastspeech2", dataclass=FastSpeech2CriterionConfig) +class FastSpeech2Loss(FairseqCriterion): + def __init__(self, task, ctc_weight): + super().__init__(task) + self.ctc_weight = ctc_weight + + def forward(self, model: FairseqEncoderModel, sample, reduction="mean"): + src_tokens = sample["net_input"]["src_tokens"] + src_lens = sample["net_input"]["src_lengths"] + tgt_lens = sample["target_lengths"] + _feat_out, _, log_dur_out, pitch_out, energy_out = model( + src_tokens=src_tokens, + src_lengths=src_lens, + prev_output_tokens=sample["net_input"]["prev_output_tokens"], + incremental_state=None, + target_lengths=tgt_lens, + speaker=sample["speaker"], + durations=sample["durations"], + pitches=sample["pitches"], + energies=sample["energies"] + ) + + src_mask = lengths_to_mask(sample["net_input"]["src_lengths"]) + tgt_mask = lengths_to_mask(sample["target_lengths"]) + + pitches, energies = sample["pitches"], sample["energies"] + pitch_out, pitches = pitch_out[src_mask], pitches[src_mask] + energy_out, energies = energy_out[src_mask], energies[src_mask] + + feat_out, feat = _feat_out[tgt_mask], sample["target"][tgt_mask] + l1_loss = F.l1_loss(feat_out, feat, reduction=reduction) + + pitch_loss = F.mse_loss(pitch_out, pitches, reduction=reduction) + energy_loss = F.mse_loss(energy_out, energies, reduction=reduction) + + log_dur_out = log_dur_out[src_mask] + dur = sample["durations"].float() + dur = dur.half() if log_dur_out.type().endswith(".HalfTensor") else dur + log_dur = torch.log(dur + 1)[src_mask] + dur_loss = F.mse_loss(log_dur_out, log_dur, reduction=reduction) + + ctc_loss = torch.tensor(0.).type_as(l1_loss) + if self.ctc_weight > 0.: + lprobs = model.get_normalized_probs((_feat_out,), log_probs=True) + lprobs = lprobs.transpose(0, 1) # T x B x C + src_mask = lengths_to_mask(src_lens) + src_tokens_flat = src_tokens.masked_select(src_mask) + ctc_loss = F.ctc_loss( + lprobs, src_tokens_flat, tgt_lens, src_lens, + reduction=reduction, zero_infinity=True + ) * self.ctc_weight + + loss = l1_loss + dur_loss + pitch_loss + energy_loss + ctc_loss + + sample_size = sample["nsentences"] + logging_output = { + "loss": utils.item(loss.data), + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + "l1_loss": utils.item(l1_loss.data), + "dur_loss": utils.item(dur_loss.data), + "pitch_loss": utils.item(pitch_loss.data), + "energy_loss": utils.item(energy_loss.data), + "ctc_loss": utils.item(ctc_loss.data), + } + return loss, sample_size, logging_output + + @classmethod + def reduce_metrics(cls, logging_outputs: List[Dict[str, Any]]) -> None: + ns = [log.get("sample_size", 0) for log in logging_outputs] + ntot = sum(ns) + ws = [n / (ntot + 1e-8) for n in ns] + for key in [ + "loss", "l1_loss", "dur_loss", "pitch_loss", "energy_loss", + "ctc_loss" + ]: + vals = [log.get(key, 0) for log in logging_outputs] + val = sum(val * w for val, w in zip(vals, ws)) + metrics.log_scalar(key, val, ntot, round=3) + metrics.log_scalar("sample_size", ntot, len(logging_outputs)) + + # inference metrics + if "targ_frames" not in logging_outputs[0]: + return + n = sum(log.get("targ_frames", 0) for log in logging_outputs) + for key, new_key in [ + ("mcd_loss", "mcd_loss"), + ("pred_frames", "pred_ratio"), + ("nins", "ins_rate"), + ("ndel", "del_rate"), + ]: + val = sum(log.get(key, 0) for log in logging_outputs) + metrics.log_scalar(new_key, val / n, n, round=3) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + return False diff --git a/fairseq/fairseq/criterions/hubert_criterion.py b/fairseq/fairseq/criterions/hubert_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..68cb24e6f142c46e108c53479fd4027a741f5f92 --- /dev/null +++ b/fairseq/fairseq/criterions/hubert_criterion.py @@ -0,0 +1,177 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +import re +from dataclasses import dataclass, field +from typing import List, Optional + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class HubertCriterionConfig(FairseqDataclass): + pred_masked_weight: float = field( + default=1.0, + metadata={"help": "weight for predictive loss for masked frames"}, + ) + pred_nomask_weight: float = field( + default=0.0, + metadata={"help": "weight for predictive loss for unmasked frames"}, + ) + loss_weights: Optional[List[float]] = field( + default=None, + metadata={"help": "weights for additional loss terms (not first one)"}, + ) + log_keys: List[str] = field( + default_factory=lambda: [], + metadata={"help": "output keys to log"}, + ) + + +@register_criterion("hubert", dataclass=HubertCriterionConfig) +class HubertCriterion(FairseqCriterion): + def __init__(self, task, pred_masked_weight, pred_nomask_weight, loss_weights=None, log_keys=None): + super().__init__(task) + self.pred_masked_weight = pred_masked_weight + self.pred_nomask_weight = pred_nomask_weight + self.loss_weights = loss_weights + self.log_keys = [] if log_keys is None else log_keys + + def forward(self, model, sample, reduce=True, log_pred=False): + """Compute the loss for the given sample. + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(target_list=sample["target_list"], **sample["net_input"]) + loss = 0. + sample_size = 0 + logging_output = {} + reduction = "sum" if reduce else "none" + + loss_m_list = [] + logp_m_list = model.get_logits(net_output, True) + targ_m_list = model.get_targets(net_output, True) + assert self.pred_masked_weight == 0 or len(logp_m_list) > 0 + for i, (logp_m, targ_m) in enumerate(zip(logp_m_list, targ_m_list)): + loss_m = F.cross_entropy(logp_m, targ_m, reduction=reduction) + loss_m_list.append(loss_m) + logging_output[f"loss_m_{i}"] = loss_m.detach().item() + if self.pred_masked_weight > 0: + loss += self.pred_masked_weight * sum(loss_m_list) + sample_size += targ_m_list[0].numel() + + loss_u_list = [] + logp_u_list = model.get_logits(net_output, False) + targ_u_list = model.get_targets(net_output, False) + assert self.pred_nomask_weight == 0 or len(logp_u_list) > 0 + for i, (logp_u, targ_u) in enumerate(zip(logp_u_list, targ_u_list)): + loss_u = F.cross_entropy(logp_u, targ_u, reduction=reduction) + loss_u_list.append(loss_u) + logging_output[f"loss_u_{i}"] = loss_u.detach().item() + if self.pred_nomask_weight > 0: + loss += self.pred_nomask_weight * sum(loss_u_list) + sample_size += targ_u_list[0].numel() + + if self.loss_weights is not None: + assert hasattr(model, "get_extra_losses") + extra_losses, names = model.get_extra_losses(net_output) + if torch.is_tensor(extra_losses): + extra_losses = [extra_losses] + names = [names] + if len(self.loss_weights) == 1 and len(extra_losses) != 1: + self.loss_weights = [self.loss_weights[0]] * len(extra_losses) + assert len(extra_losses) == len(self.loss_weights), f"{len(extra_losses)}, {len(self.loss_weights)}" + for p, n, coef in zip(extra_losses, names, self.loss_weights): + if coef != 0 and p is not None: + p = coef * p.float() * sample_size + loss += p + logging_output[f"loss_{n}"] = p.item() + + logging_output = { + "loss": loss.item() if reduce else loss, + "ntokens": sample_size, + "nsentences": sample["id"].numel(), + "sample_size": sample_size, + **logging_output, + } + + for lk in self.log_keys: + if lk in net_output: + logging_output[lk] = float((net_output[lk])) + + def compute_correct(logits): + if logits.numel() == 0: + return 0, 0 + else: + assert logits.dim() > 1, logits.shape + max = logits.argmax(-1) == 0 + min = logits.argmin(-1) == 0 + both = max & min + corr = max.long().sum().item() - both.long().sum().item() + count = max.numel() + return corr, count + + with torch.no_grad(): + for i, logp_m in enumerate(logp_m_list): + corr_m, count_m = compute_correct(logp_m) + logging_output[f"correct_m_{i}"] = corr_m + logging_output[f"count_m_{i}"] = count_m + + for i, logp_u in enumerate(logp_u_list): + corr_u, count_u = compute_correct(logp_u) + logging_output[f"correct_u_{i}"] = corr_u + logging_output[f"count_u_{i}"] = count_u + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training (copied from normal cross entropy).""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar("loss", loss_sum / sample_size / math.log(2), sample_size, round=3) + if sample_size != ntokens: + metrics.log_scalar("nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3) + metrics.log_derived("ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg)) + else: + metrics.log_derived("ppl", lambda meters: utils.get_perplexity(meters["loss"].avg)) + + counts = {} + for lk in logging_outputs[0].keys(): + if lk.startswith("count_"): + val = sum(log[lk] for log in logging_outputs) + metrics.log_scalar(lk, val) + counts[lk] = val + + for lk in logging_outputs[0].keys(): + if lk.startswith("loss_"): + val = sum(log[lk] for log in logging_outputs) + metrics.log_scalar(lk, val / sample_size / math.log(2), round=3) + elif lk.startswith("correct_"): + val = sum(log[lk] for log in logging_outputs) + metrics.log_scalar(lk, val / counts[re.sub("correct", "count", lk)]) + + @staticmethod + def aggregate_logging_outputs(logging_outputs): + """Aggregate logging outputs from data parallel training.""" + raise NotImplementedError() + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return False diff --git a/fairseq/fairseq/criterions/label_smoothed_cross_entropy.py b/fairseq/fairseq/criterions/label_smoothed_cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..56d63e3e1b5a036e0adf32480e2b66f371738013 --- /dev/null +++ b/fairseq/fairseq/criterions/label_smoothed_cross_entropy.py @@ -0,0 +1,170 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field + +import torch +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from omegaconf import II + + +@dataclass +class LabelSmoothedCrossEntropyCriterionConfig(FairseqDataclass): + label_smoothing: float = field( + default=0.0, + metadata={"help": "epsilon for label smoothing, 0 means no label smoothing"}, + ) + report_accuracy: bool = field( + default=False, + metadata={"help": "report accuracy metric"}, + ) + ignore_prefix_size: int = field( + default=0, + metadata={"help": "Ignore first N tokens"}, + ) + sentence_avg: bool = II("optimization.sentence_avg") + + +def label_smoothed_nll_loss(lprobs, target, epsilon, ignore_index=None, reduce=True): + if target.dim() == lprobs.dim() - 1: + target = target.unsqueeze(-1) + nll_loss = -lprobs.gather(dim=-1, index=target) + smooth_loss = -lprobs.sum(dim=-1, keepdim=True) + if ignore_index is not None: + pad_mask = target.eq(ignore_index) + nll_loss.masked_fill_(pad_mask, 0.0) + smooth_loss.masked_fill_(pad_mask, 0.0) + else: + nll_loss = nll_loss.squeeze(-1) + smooth_loss = smooth_loss.squeeze(-1) + if reduce: + nll_loss = nll_loss.sum() + smooth_loss = smooth_loss.sum() + eps_i = epsilon / (lprobs.size(-1) - 1) + loss = (1.0 - epsilon - eps_i) * nll_loss + eps_i * smooth_loss + return loss, nll_loss + + +@register_criterion( + "label_smoothed_cross_entropy", dataclass=LabelSmoothedCrossEntropyCriterionConfig +) +class LabelSmoothedCrossEntropyCriterion(FairseqCriterion): + def __init__( + self, + task, + sentence_avg, + label_smoothing, + ignore_prefix_size=0, + report_accuracy=False, + ): + super().__init__(task) + self.sentence_avg = sentence_avg + self.eps = label_smoothing + self.ignore_prefix_size = ignore_prefix_size + self.report_accuracy = report_accuracy + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + loss, nll_loss = self.compute_loss(model, net_output, sample, reduce=reduce) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + if self.report_accuracy: + n_correct, total = self.compute_accuracy(model, net_output, sample) + logging_output["n_correct"] = utils.item(n_correct.data) + logging_output["total"] = utils.item(total.data) + return loss, sample_size, logging_output + + def get_lprobs_and_target(self, model, net_output, sample): + lprobs = model.get_normalized_probs(net_output, log_probs=True) + target = model.get_targets(sample, net_output) + if self.ignore_prefix_size > 0: + if getattr(lprobs, "batch_first", False): + lprobs = lprobs[:, self.ignore_prefix_size :, :].contiguous() + target = target[:, self.ignore_prefix_size :].contiguous() + else: + lprobs = lprobs[self.ignore_prefix_size :, :, :].contiguous() + target = target[self.ignore_prefix_size :, :].contiguous() + return lprobs.view(-1, lprobs.size(-1)), target.view(-1) + + def compute_loss(self, model, net_output, sample, reduce=True): + lprobs, target = self.get_lprobs_and_target(model, net_output, sample) + loss, nll_loss = label_smoothed_nll_loss( + lprobs, + target, + self.eps, + ignore_index=self.padding_idx, + reduce=reduce, + ) + return loss, nll_loss + + def compute_accuracy(self, model, net_output, sample): + lprobs, target = self.get_lprobs_and_target(model, net_output, sample) + mask = target.ne(self.padding_idx) + n_correct = torch.sum( + lprobs.argmax(1).masked_select(mask).eq(target.masked_select(mask)) + ) + total = torch.sum(mask) + return n_correct, total + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + nll_loss_sum = sum(log.get("nll_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + total = utils.item(sum(log.get("total", 0) for log in logging_outputs)) + if total > 0: + metrics.log_scalar("total", total) + n_correct = utils.item( + sum(log.get("n_correct", 0) for log in logging_outputs) + ) + metrics.log_scalar("n_correct", n_correct) + metrics.log_derived( + "accuracy", + lambda meters: round( + meters["n_correct"].sum * 100.0 / meters["total"].sum, 3 + ) + if meters["total"].sum > 0 + else float("nan"), + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/label_smoothed_cross_entropy_latency_augmented.py b/fairseq/fairseq/criterions/label_smoothed_cross_entropy_latency_augmented.py new file mode 100644 index 0000000000000000000000000000000000000000..223a16f740c10b58ea45a0390814363e7b5f68b8 --- /dev/null +++ b/fairseq/fairseq/criterions/label_smoothed_cross_entropy_latency_augmented.py @@ -0,0 +1,233 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import torch +from fairseq import metrics, utils +from fairseq.criterions import register_criterion +from fairseq.criterions.label_smoothed_cross_entropy import ( + LabelSmoothedCrossEntropyCriterion, + LabelSmoothedCrossEntropyCriterionConfig +) + +try: + from simuleval.metrics.latency import ( + AverageLagging, + AverageProportion, + DifferentiableAverageLagging + ) + LATENCY_METRICS = { + "average_lagging": AverageLagging, + "average_proportion": AverageProportion, + "differentiable_average_lagging": DifferentiableAverageLagging, + } +except ImportError: + LATENCY_METRICS = None + + +@dataclass +class LabelSmoothedCrossEntropyCriterionLatencyAugmentConfig( + LabelSmoothedCrossEntropyCriterionConfig +): + latency_avg_weight: float = field( + default=0.0, + metadata={"help": "weight fot average latency loss."}, + ) + latency_var_weight: float = field( + default=0.0, + metadata={"help": "weight fot variance latency loss."}, + ) + latency_avg_type: str = field( + default="differentiable_average_lagging", + metadata={"help": "latency type for average loss"}, + ) + latency_var_type: str = field( + default="variance_delay", + metadata={"help": "latency typ for variance loss"}, + ) + latency_gather_method: str = field( + default="weighted_average", + metadata={"help": "method to gather latency loss for all heads"}, + ) + latency_update_after: int = field( + default=0, + metadata={"help": "Add latency loss after certain steps"}, + ) + +@register_criterion( + "latency_augmented_label_smoothed_cross_entropy", + dataclass=LabelSmoothedCrossEntropyCriterionLatencyAugmentConfig +) +class LatencyAugmentedLabelSmoothedCrossEntropyCriterion( + LabelSmoothedCrossEntropyCriterion +): + def __init__( + self, + task, + sentence_avg, + label_smoothing, + ignore_prefix_size, + report_accuracy, + latency_avg_weight, + latency_var_weight, + latency_avg_type, + latency_var_type, + latency_gather_method, + latency_update_after, + ): + super().__init__( + task, sentence_avg, label_smoothing, ignore_prefix_size, report_accuracy + ) + assert LATENCY_METRICS is not None, "Please make sure SimulEval is installed." + + self.latency_avg_weight = latency_avg_weight + self.latency_var_weight = latency_var_weight + self.latency_avg_type = latency_avg_type + self.latency_var_type = latency_var_type + self.latency_gather_method = latency_gather_method + self.latency_update_after = latency_update_after + + def forward(self, model, sample, reduce=True): + net_output = model(**sample["net_input"]) + # 1. Compute cross entropy loss + loss, nll_loss = self.compute_loss(model, net_output, sample, reduce=reduce) + + # 2. Compute cross latency loss + latency_loss, expected_latency, expected_delays_var = self.compute_latency_loss( + model, sample, net_output + ) + + if self.latency_update_after > 0: + num_updates = getattr(model.decoder, "num_updates", None) + assert num_updates is not None, ( + "model.decoder doesn't have attribute 'num_updates'" + ) + if num_updates <= self.latency_update_after: + latency_loss = 0 + + loss += latency_loss + + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + "latency": expected_latency, + "delays_var": expected_delays_var, + "latency_loss": latency_loss, + } + + if self.report_accuracy: + n_correct, total = self.compute_accuracy(model, net_output, sample) + logging_output["n_correct"] = utils.item(n_correct.data) + logging_output["total"] = utils.item(total.data) + return loss, sample_size, logging_output + + def compute_latency_loss(self, model, sample, net_output): + assert ( + net_output[-1].encoder_padding_mask is None + or not net_output[-1].encoder_padding_mask[:, 0].any() + ), ( + "Only right padding on source is supported." + ) + # 1. Obtain the expected alignment + alpha_list = [item["alpha"] for item in net_output[1].attn_list] + num_layers = len(alpha_list) + bsz, num_heads, tgt_len, src_len = alpha_list[0].size() + + # bsz * num_layers * num_heads, tgt_len, src_len + alpha_all = torch.cat(alpha_list, dim=1).view(-1, tgt_len, src_len) + + # 2 compute expected delays + # bsz * num_heads * num_layers, tgt_len, src_len for MMA + steps = ( + torch.arange(1, 1 + src_len) + .unsqueeze(0) + .unsqueeze(1) + .expand_as(alpha_all) + .type_as(alpha_all) + ) + + expected_delays = torch.sum(steps * alpha_all, dim=-1) + + target_padding_mask = ( + model.get_targets(sample, net_output) + .eq(self.padding_idx) + .unsqueeze(1) + .expand(bsz, num_layers * num_heads, tgt_len) + .contiguous() + .view(-1, tgt_len) + ) + + src_lengths = ( + sample["net_input"]["src_lengths"] + .unsqueeze(1) + .expand(bsz, num_layers * num_heads) + .contiguous() + .view(-1) + ) + expected_latency = LATENCY_METRICS[self.latency_avg_type]( + expected_delays, src_lengths, None, + target_padding_mask=target_padding_mask + ) + + # 2.1 average expected latency of heads + # bsz, num_layers * num_heads + expected_latency = expected_latency.view(bsz, -1) + if self.latency_gather_method == "average": + # bsz * tgt_len + expected_latency = expected_delays.mean(dim=1) + elif self.latency_gather_method == "weighted_average": + weights = torch.nn.functional.softmax(expected_latency, dim=1) + expected_latency = torch.sum(expected_latency * weights, dim=1) + elif self.latency_gather_method == "max": + expected_latency = expected_latency.max(dim=1)[0] + else: + raise NotImplementedError + + expected_latency = expected_latency.sum() + avg_loss = self.latency_avg_weight * expected_latency + + # 2.2 variance of expected delays + expected_delays_var = ( + expected_delays.view(bsz, -1, tgt_len).var(dim=1).mean(dim=1) + ) + expected_delays_var = expected_delays_var.sum() + var_loss = self.latency_avg_weight * expected_delays_var + + # 3. Final loss + latency_loss = avg_loss + var_loss + + return latency_loss, expected_latency, expected_delays_var + + @classmethod + def reduce_metrics(cls, logging_outputs) -> None: + super().reduce_metrics(logging_outputs) + latency = sum( + log.get("latency", 0) for log in logging_outputs + ) + delays_var = sum( + log.get("delays_var", 0) for log in logging_outputs + ) + latency_loss = sum( + log.get("latency_loss", 0) for log in logging_outputs + ) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + metrics.log_scalar( + "latency", latency.float() / nsentences, nsentences, round=3 + ) + metrics.log_scalar( + "delays_var", delays_var / nsentences, + nsentences, round=3 + ) + metrics.log_scalar( + "latency_loss", latency_loss / nsentences, + nsentences, round=3 + ) diff --git a/fairseq/fairseq/criterions/label_smoothed_cross_entropy_with_alignment.py b/fairseq/fairseq/criterions/label_smoothed_cross_entropy_with_alignment.py new file mode 100644 index 0000000000000000000000000000000000000000..2ea37c16b4a477c48e4dd4500ec03f2d0c86d611 --- /dev/null +++ b/fairseq/fairseq/criterions/label_smoothed_cross_entropy_with_alignment.py @@ -0,0 +1,130 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +from fairseq import metrics, utils +from fairseq.criterions import register_criterion + +from .label_smoothed_cross_entropy import ( + LabelSmoothedCrossEntropyCriterion, + LabelSmoothedCrossEntropyCriterionConfig, +) + +from dataclasses import dataclass, field + + +@dataclass +class LabelSmoothedCrossEntropyCriterionWithAlignmentConfig( + LabelSmoothedCrossEntropyCriterionConfig +): + alignment_lambda: float = field( + default=0.05, metadata={"help": "weight for the alignment loss"} + ) + + +@register_criterion( + "label_smoothed_cross_entropy_with_alignment", + dataclass=LabelSmoothedCrossEntropyCriterionWithAlignmentConfig, +) +class LabelSmoothedCrossEntropyCriterionWithAlignment( + LabelSmoothedCrossEntropyCriterion +): + def __init__(self, task, sentence_avg, label_smoothing, alignment_lambda): + super().__init__(task, sentence_avg, label_smoothing) + self.alignment_lambda = alignment_lambda + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + loss, nll_loss = self.compute_loss(model, net_output, sample, reduce=reduce) + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "nll_loss": utils.item(nll_loss.data) if reduce else nll_loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + + alignment_loss = None + + # Compute alignment loss only for training set and non dummy batches. + if "alignments" in sample and sample["alignments"] is not None: + alignment_loss = self.compute_alignment_loss(sample, net_output) + + if alignment_loss is not None: + logging_output["alignment_loss"] = utils.item(alignment_loss.data) + loss += self.alignment_lambda * alignment_loss + + return loss, sample_size, logging_output + + def compute_alignment_loss(self, sample, net_output): + attn_prob = net_output[1]["attn"][0] + bsz, tgt_sz, src_sz = attn_prob.shape + attn = attn_prob.view(bsz * tgt_sz, src_sz) + + align = sample["alignments"] + align_weights = sample["align_weights"].float() + + if len(align) > 0: + # Alignment loss computation. align (shape [:, 2]) contains the src-tgt index pairs corresponding to + # the alignments. align_weights (shape [:]) contains the 1 / frequency of a tgt index for normalizing. + loss = -( + (attn[align[:, 1][:, None], align[:, 0][:, None]]).log() + * align_weights[:, None] + ).sum() + else: + return None + + return loss + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + nll_loss_sum = utils.item( + sum(log.get("nll_loss", 0) for log in logging_outputs) + ) + alignment_loss_sum = utils.item( + sum(log.get("alignment_loss", 0) for log in logging_outputs) + ) + ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs)) + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_scalar( + "alignment_loss", + alignment_loss_sum / sample_size / math.log(2), + sample_size, + round=3, + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/legacy_masked_lm.py b/fairseq/fairseq/criterions/legacy_masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..c70608c5a143b7b4fbd8c58dfcf9f873639d379c --- /dev/null +++ b/fairseq/fairseq/criterions/legacy_masked_lm.py @@ -0,0 +1,177 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +def compute_cross_entropy_loss(logits, targets, ignore_index=-100): + """ + Function to compute the cross entropy loss. The default value of + ignore_index is the same as the default value for F.cross_entropy in + pytorch. + """ + assert logits.size(0) == targets.size( + -1 + ), "Logits and Targets tensor shapes don't match up" + + loss = F.nll_loss( + F.log_softmax(logits, -1, dtype=torch.float32), + targets, + reduction="sum", + ignore_index=ignore_index, + ) + return loss + + +@register_criterion("legacy_masked_lm_loss") +class LegacyMaskedLmLoss(FairseqCriterion): + """ + Implementation for the loss used in masked language model (MLM) training. + This optionally also computes the next sentence prediction (NSP) loss and + adds it to the overall loss based on the specified args. There are three + cases to consider: + 1) Generic MLM training without NSP loss. In this case sentence_targets + and sentence_logits are both None. + 2) BERT training without NSP loss. In this case sentence_targets is + not None but sentence_logits is None and we should not be computing + a sentence level loss. + 3) BERT training with NSP loss. In this case both sentence_targets and + sentence_logits are not None and we should be computing a sentence + level loss. The weight of the sentence level loss is specified as + an argument. + """ + + def __init__(self, task, masked_lm_only, nsp_loss_weight): + super().__init__(task) + self.masked_lm_only = masked_lm_only + self.nsp_loss_weight = nsp_loss_weight + + @staticmethod + def add_args(parser): + """Args for MaskedLM Loss""" + # Default for masked_lm_only is False so as to not break BERT training + parser.add_argument( + "--masked-lm-only", + default=False, + action="store_true", + help="compute MLM loss only", + ) + parser.add_argument( + "--nsp-loss-weight", + default=1.0, + type=float, + help="weight for next sentence prediction" " loss (default 1)", + ) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + lm_logits, output_metadata = model(**sample["net_input"]) + + # reshape lm_logits from (N,T,C) to (N*T,C) + lm_logits = lm_logits.view(-1, lm_logits.size(-1)) + lm_targets = sample["lm_target"].view(-1) + lm_loss = compute_cross_entropy_loss(lm_logits, lm_targets, self.padding_idx) + + # compute the number of tokens for which loss is computed. This is used + # to normalize the loss + ntokens = utils.strip_pad(lm_targets, self.padding_idx).numel() + loss = lm_loss / ntokens + nsentences = sample["nsentences"] + # nsentences = 0 + + # Compute sentence loss if masked_lm_only is False + sentence_loss = None + if not self.masked_lm_only: + sentence_logits = output_metadata["sentence_logits"] + sentence_targets = sample["sentence_target"].view(-1) + # This needs to be recomputed due to some differences between + # TokenBlock and BlockPair dataset. This can be resolved with a + # refactor of BERTModel which we will do in the future. + # TODO: Remove this after refactor of BERTModel + nsentences = sentence_targets.size(0) + + # Check for logits being none which can happen when remove_heads + # is set to true in the BERT model. Ideally we should set + # masked_lm_only to true in this case, but that requires some + # refactor in the BERT model. + if sentence_logits is not None: + sentence_loss = compute_cross_entropy_loss( + sentence_logits, sentence_targets + ) + + loss += self.nsp_loss_weight * (sentence_loss / nsentences) + + # NOTE: as we are summing up per token mlm loss and per sentence nsp loss + # we don't need to use sample_size as denominator for the gradient + # here sample_size is just used for logging + sample_size = 1 + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "lm_loss": utils.item(lm_loss.data) if reduce else lm_loss.data, + # sentence loss is not always computed + "sentence_loss": ( + (utils.item(sentence_loss.data) if reduce else sentence_loss.data) + if sentence_loss is not None + else 0.0 + ), + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + lm_loss_sum = sum(log.get("lm_loss", 0) for log in logging_outputs) + sentence_loss_sum = sum(log.get("sentence_loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + agg_loss = sum(log.get("loss", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", + agg_loss / sample_size / math.log(2) if sample_size > 0 else 0.0, + sample_size, + round=3, + ) + metrics.log_scalar( + "lm_loss", + lm_loss_sum / ntokens / math.log(2) if ntokens > 0 else 0.0, + ntokens, + round=3, + ) + metrics.log_scalar( + "sentence_loss", + sentence_loss_sum / nsentences / math.log(2) if nsentences > 0 else 0.0, + nsentences, + round=3, + ) + metrics.log_scalar( + "nll_loss", + lm_loss_sum / ntokens / math.log(2) if ntokens > 0 else 0.0, + ntokens, + round=3, + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/masked_lm.py b/fairseq/fairseq/criterions/masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..279458f317ee258e393c4bf1879bb3c14a04ab51 --- /dev/null +++ b/fairseq/fairseq/criterions/masked_lm.py @@ -0,0 +1,98 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +import math +from omegaconf import II + +import torch +from fairseq import metrics, modules, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class MaskedLmConfig(FairseqDataclass): + tpu: bool = II("common.tpu") + + +@register_criterion("masked_lm", dataclass=MaskedLmConfig) +class MaskedLmLoss(FairseqCriterion): + """ + Implementation for the loss used in masked language model (MLM) training. + """ + + def __init__(self, cfg: MaskedLmConfig, task): + super().__init__(task) + self.tpu = cfg.tpu + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + masked_tokens = sample["target"].ne(self.padding_idx) + sample_size = masked_tokens.int().sum() + + # Rare: when all tokens are masked, project all tokens. + # We use torch.where to avoid device-to-host transfers, + # except on CPU where torch.where is not well supported + # (see github.com/pytorch/pytorch/issues/26247). + if self.tpu: + masked_tokens = None # always project all tokens on TPU + elif masked_tokens.device == torch.device("cpu"): + if not masked_tokens.any(): + masked_tokens = None + else: + masked_tokens = torch.where( + masked_tokens.any(), + masked_tokens, + masked_tokens.new([True]), + ) + + logits = model(**sample["net_input"], masked_tokens=masked_tokens)[0] + targets = model.get_targets(sample, [logits]) + if masked_tokens is not None: + targets = targets[masked_tokens] + + loss = modules.cross_entropy( + logits.view(-1, logits.size(-1)), + targets.view(-1), + reduction="sum", + ignore_index=self.padding_idx, + ) + + logging_output = { + "loss": loss if self.tpu else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/model_criterion.py b/fairseq/fairseq/criterions/model_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..30350f13b1c00498de6784579250d6b342ced7dd --- /dev/null +++ b/fairseq/fairseq/criterions/model_criterion.py @@ -0,0 +1,138 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from dataclasses import dataclass, field +from typing import Dict, List + +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass + + +logger = logging.getLogger(__name__) + + +@dataclass +class ModelCriterionConfig(FairseqDataclass): + loss_weights: Dict[str, float] = field( + default_factory=dict, + metadata={"help": "weights for the loss terms"}, + ) + log_keys: List[str] = field( + default_factory=list, + metadata={"help": "additional output keys to log"}, + ) + + +@register_criterion("model", dataclass=ModelCriterionConfig) +class ModelCriterion(FairseqCriterion): + """ + This criterion relies on the model to supply losses. + The losses should be a dictionary of name -> scalar returned by + the model either by including it in the net_output dict or by + implementing a get_losses(net_output, sample) method. The final loss is + a scaled sum of all losses according to weights in loss_weights. + If no weights are provided, then all losses are scaled by 1.0. + + The losses will be automatically logged. Additional keys from + net_output dict can be logged via the log_keys parameter. + """ + + def __init__(self, task, loss_weights=None, log_keys=None): + super().__init__(task) + self.loss_weights = loss_weights + self.log_keys = log_keys + + def forward(self, model, sample, reduce=True): + net_output = model(**sample["net_input"]) + + sample_size = net_output["sample_size"] + scaled_losses = {} + + if hasattr(model, "get_losses"): + losses = model.get_losses(net_output, sample) + elif isinstance(net_output, dict) and "losses" in net_output: + losses = net_output["losses"] + else: + raise Exception("Could not retrieve losses") + + for lk, p in losses.items(): + try: + coef = 1.0 if len(self.loss_weights) == 0 else self.loss_weights[lk] + except KeyError: + logger.error( + f"weight for loss {lk} is not in loss_weights ({self.loss_weights})" + ) + raise + if coef != 0 and p is not None: + scaled_losses[lk] = coef * p.float() + + loss = sum(scaled_losses.values()) + if reduce and loss.numel() > 1: + loss = loss.sum() + + logging_output = { + "loss": loss.data, + "ntokens": sample_size, + "nsentences": sample["id"].numel(), + "sample_size": sample_size, + "_world_size": 1, + } + + for lk in self.log_keys: + if lk in net_output and net_output[lk] is not None: + logging_output[lk] = float(net_output[lk]) + + if len(scaled_losses) > 1: + for lk, l in scaled_losses.items(): + logging_output[f"loss_{lk}"] = l.item() + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs)) + nsentences = utils.item( + sum(log.get("nsentences", 0) for log in logging_outputs) + ) + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + metrics.log_scalar("loss", loss_sum / sample_size, sample_size, round=3) + metrics.log_scalar("ntokens", ntokens) + metrics.log_scalar("nsentences", nsentences) + + builtin_keys = { + "loss", + "ntokens", + "nsentences", + "sample_size", + "_world_size", + } + + world_size = utils.item( + sum(log.get("_world_size", 0) for log in logging_outputs) + ) + + for k in logging_outputs[0]: + if k not in builtin_keys: + val = sum(log.get(k, 0) for log in logging_outputs) + if k.startswith("loss_"): + metrics.log_scalar(k, val / sample_size, sample_size, round=3) + else: + metrics.log_scalar(k, val / world_size, round=3) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/nat_loss.py b/fairseq/fairseq/criterions/nat_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..7dac32fbaf4fb10089c0bcd42b75d23f92b5cf66 --- /dev/null +++ b/fairseq/fairseq/criterions/nat_loss.py @@ -0,0 +1,180 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from torch import Tensor + +from dataclasses import dataclass, field + + +@dataclass +class LabelSmoothedDualImitationCriterionConfig(FairseqDataclass): + label_smoothing: float = field( + default=0.0, + metadata={"help": "epsilon for label smoothing, 0 means no label smoothing"}, + ) + + +@register_criterion("nat_loss", dataclass=LabelSmoothedDualImitationCriterionConfig) +class LabelSmoothedDualImitationCriterion(FairseqCriterion): + def __init__(self, task, label_smoothing): + super().__init__(task) + self.label_smoothing = label_smoothing + + def _compute_loss( + self, outputs, targets, masks=None, label_smoothing=0.0, name="loss", factor=1.0 + ): + """ + outputs: batch x len x d_model + targets: batch x len + masks: batch x len + + policy_logprob: if there is some policy + depends on the likelihood score as rewards. + """ + + def mean_ds(x: Tensor, dim=None) -> Tensor: + return ( + x.float().mean().type_as(x) + if dim is None + else x.float().mean(dim).type_as(x) + ) + + if masks is not None: + outputs, targets = outputs[masks], targets[masks] + + if masks is not None and not masks.any(): + nll_loss = torch.tensor(0) + loss = nll_loss + else: + logits = F.log_softmax(outputs, dim=-1) + if targets.dim() == 1: + losses = F.nll_loss(logits, targets.to(logits.device), reduction="none") + + else: # soft-labels + losses = F.kl_div(logits, targets.to(logits.device), reduction="none") + losses = losses.sum(-1) + + nll_loss = mean_ds(losses) + if label_smoothing > 0: + loss = ( + nll_loss * (1 - label_smoothing) - mean_ds(logits) * label_smoothing + ) + else: + loss = nll_loss + + loss = loss * factor + return {"name": name, "loss": loss, "nll_loss": nll_loss, "factor": factor} + + def _custom_loss(self, loss, name="loss", factor=1.0): + return {"name": name, "loss": loss, "factor": factor} + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + nsentences, ntokens = sample["nsentences"], sample["ntokens"] + + # B x T + src_tokens, src_lengths = ( + sample["net_input"]["src_tokens"], + sample["net_input"]["src_lengths"], + ) + tgt_tokens, prev_output_tokens = sample["target"], sample["prev_target"] + + outputs = model(src_tokens, src_lengths, prev_output_tokens, tgt_tokens) + losses, nll_loss = [], [] + + for obj in outputs: + if outputs[obj].get("loss", None) is None: + _losses = self._compute_loss( + outputs[obj].get("out"), + outputs[obj].get("tgt"), + outputs[obj].get("mask", None), + outputs[obj].get("ls", 0.0), + name=obj + "-loss", + factor=outputs[obj].get("factor", 1.0), + ) + else: + _losses = self._custom_loss( + outputs[obj].get("loss"), + name=obj + "-loss", + factor=outputs[obj].get("factor", 1.0), + ) + + losses += [_losses] + if outputs[obj].get("nll_loss", False): + nll_loss += [_losses.get("nll_loss", 0.0)] + + loss = sum(l["loss"] for l in losses) + nll_loss = sum(l for l in nll_loss) if len(nll_loss) > 0 else loss.new_tensor(0) + + # NOTE: + # we don't need to use sample_size as denominator for the gradient + # here sample_size is just used for logging + sample_size = 1 + logging_output = { + "loss": loss.data, + "nll_loss": nll_loss.data, + "ntokens": ntokens, + "nsentences": nsentences, + "sample_size": sample_size, + } + + for l in losses: + logging_output[l["name"]] = ( + utils.item(l["loss"].data / l["factor"]) + if reduce + else l[["loss"]].data / l["factor"] + ) + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + loss = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + nll_loss = utils.item(sum(log.get("nll_loss", 0) for log in logging_outputs)) + + metrics.log_scalar( + "loss", loss / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_scalar( + "nll_loss", nll_loss / sample_size / math.log(2), sample_size, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + for key in logging_outputs[0]: + if key[-5:] == "-loss": + val = sum(log.get(key, 0) for log in logging_outputs) + metrics.log_scalar( + key[:-5], + val / sample_size / math.log(2) if sample_size > 0 else 0.0, + sample_size, + round=3, + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/sentence_prediction.py b/fairseq/fairseq/criterions/sentence_prediction.py new file mode 100644 index 0000000000000000000000000000000000000000..482b97985a36aca07146772f52dde41df76bf643 --- /dev/null +++ b/fairseq/fairseq/criterions/sentence_prediction.py @@ -0,0 +1,104 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class SentencePredictionConfig(FairseqDataclass): + classification_head_name: str = field( + default="sentence_classification_head", + metadata={"help": "name of the classification head to use"}, + ) + regression_target: bool = field( + default=False, + ) + + +@register_criterion("sentence_prediction", dataclass=SentencePredictionConfig) +class SentencePredictionCriterion(FairseqCriterion): + def __init__(self, cfg: SentencePredictionConfig, task): + super().__init__(task) + self.classification_head_name = cfg.classification_head_name + self.regression_target = cfg.regression_target + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + assert ( + hasattr(model, "classification_heads") + and self.classification_head_name in model.classification_heads + ), "model must provide sentence classification head for --criterion=sentence_prediction" + + logits, _ = model( + **sample["net_input"], + features_only=True, + classification_head_name=self.classification_head_name, + ) + targets = model.get_targets(sample, [logits]).view(-1) + sample_size = targets.numel() + + if not self.regression_target: + lprobs = F.log_softmax(logits, dim=-1, dtype=torch.float32) + loss = F.nll_loss(lprobs, targets, reduction="sum") + else: + logits = logits.view(-1).float() + targets = targets.float() + loss = F.mse_loss(logits, targets, reduction="sum") + + logging_output = { + "loss": loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample_size, + "sample_size": sample_size, + } + if not self.regression_target: + preds = logits.argmax(dim=1) + logging_output["ncorrect"] = (preds == targets).sum() + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + + if len(logging_outputs) > 0 and "ncorrect" in logging_outputs[0]: + ncorrect = sum(log.get("ncorrect", 0) for log in logging_outputs) + metrics.log_scalar( + "accuracy", 100.0 * ncorrect / nsentences, nsentences, round=1 + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/sentence_ranking.py b/fairseq/fairseq/criterions/sentence_ranking.py new file mode 100644 index 0000000000000000000000000000000000000000..d4c76341d4d87e6d0da21ac89e833ce0bda13a0c --- /dev/null +++ b/fairseq/fairseq/criterions/sentence_ranking.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +@register_criterion("sentence_ranking") +class SentenceRankingCriterion(FairseqCriterion): + def __init__(self, task, ranking_head_name, save_predictions, num_classes): + super().__init__(task) + self.ranking_head_name = ranking_head_name + if save_predictions is not None: + self.prediction_h = open(save_predictions, "w") + else: + self.prediction_h = None + self.num_classes = num_classes + + def __del__(self): + if self.prediction_h is not None: + self.prediction_h.close() + + @staticmethod + def add_args(parser): + # fmt: off + parser.add_argument('--save-predictions', metavar='FILE', + help='file to save predictions to') + parser.add_argument('--ranking-head-name', + default='sentence_classification_head', + help='name of the ranking head to use') + # fmt: on + + def forward(self, model, sample, reduce=True): + """Compute ranking loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + assert ( + hasattr(model, "classification_heads") + and self.ranking_head_name in model.classification_heads + ), "model must provide sentence ranking head for --criterion=sentence_ranking" + + scores = [] + for idx in range(self.num_classes): + score, _ = model( + **sample["net_input{idx}".format(idx=idx + 1)], + classification_head_name=self.ranking_head_name, + ) + scores.append(score) + + logits = torch.cat(scores, dim=1) + sample_size = logits.size(0) + + if "target" in sample: + targets = model.get_targets(sample, [logits]).view(-1) + lprobs = F.log_softmax(logits, dim=-1, dtype=torch.float32) + loss = F.nll_loss(lprobs, targets, reduction="sum") + else: + targets = None + loss = torch.tensor(0.0, requires_grad=True) + + if self.prediction_h is not None: + preds = logits.argmax(dim=1) + for i, (id, pred) in enumerate(zip(sample["id"].tolist(), preds.tolist())): + if targets is not None: + label = targets[i].item() + print("{}\t{}\t{}".format(id, pred, label), file=self.prediction_h) + else: + print("{}\t{}".format(id, pred), file=self.prediction_h) + + logging_output = { + "loss": loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample_size, + "sample_size": sample_size, + } + if targets is not None: + logging_output["ncorrect"] = (logits.argmax(dim=1) == targets).sum() + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + + if len(logging_outputs) > 0 and "ncorrect" in logging_outputs[0]: + ncorrect = sum(log.get("ncorrect", 0) for log in logging_outputs) + metrics.log_scalar( + "accuracy", 100.0 * ncorrect / nsentences, nsentences, round=1 + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/criterions/tacotron2_loss.py b/fairseq/fairseq/criterions/tacotron2_loss.py new file mode 100644 index 0000000000000000000000000000000000000000..8c7b655c8c52f8fa478b4568850ec8f741dab78e --- /dev/null +++ b/fairseq/fairseq/criterions/tacotron2_loss.py @@ -0,0 +1,210 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import logging +from typing import Any, Dict, List +from functools import lru_cache +from dataclasses import dataclass, field + +import torch +from omegaconf import II + +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq.data.data_utils import lengths_to_mask +import torch.nn.functional as F + + +logger = logging.getLogger(__name__) + + +@dataclass +class Tacotron2CriterionConfig(FairseqDataclass): + bce_pos_weight: float = field( + default=1.0, + metadata={"help": "weight of positive examples for BCE loss"}, + ) + n_frames_per_step: int = field( + default=0, + metadata={"help": "Number of frames per decoding step"}, + ) + use_guided_attention_loss: bool = field( + default=False, + metadata={"help": "use guided attention loss"}, + ) + guided_attention_loss_sigma: float = field( + default=0.4, + metadata={"help": "weight of positive examples for BCE loss"}, + ) + ctc_weight: float = field( + default=0.0, metadata={"help": "weight for CTC loss"} + ) + sentence_avg: bool = II("optimization.sentence_avg") + + +class GuidedAttentionLoss(torch.nn.Module): + """ + Efficiently Trainable Text-to-Speech System Based on Deep Convolutional + Networks with Guided Attention (https://arxiv.org/abs/1710.08969) + """ + + def __init__(self, sigma): + super().__init__() + self.sigma = sigma + + @staticmethod + @lru_cache(maxsize=8) + def _get_weight(s_len, t_len, sigma): + grid_x, grid_y = torch.meshgrid(torch.arange(t_len), torch.arange(s_len)) + grid_x = grid_x.to(s_len.device) + grid_y = grid_y.to(s_len.device) + w = (grid_y.float() / s_len - grid_x.float() / t_len) ** 2 + return 1.0 - torch.exp(-w / (2 * (sigma ** 2))) + + def _get_weights(self, src_lens, tgt_lens): + bsz, max_s_len, max_t_len = len(src_lens), max(src_lens), max(tgt_lens) + weights = torch.zeros((bsz, max_t_len, max_s_len)) + for i, (s_len, t_len) in enumerate(zip(src_lens, tgt_lens)): + weights[i, :t_len, :s_len] = self._get_weight(s_len, t_len, + self.sigma) + return weights + + @staticmethod + def _get_masks(src_lens, tgt_lens): + in_masks = lengths_to_mask(src_lens) + out_masks = lengths_to_mask(tgt_lens) + return out_masks.unsqueeze(2) & in_masks.unsqueeze(1) + + def forward(self, attn, src_lens, tgt_lens, reduction="mean"): + weights = self._get_weights(src_lens, tgt_lens).to(attn.device) + masks = self._get_masks(src_lens, tgt_lens).to(attn.device) + loss = (weights * attn.transpose(1, 2)).masked_select(masks) + loss = torch.sum(loss) if reduction == "sum" else torch.mean(loss) + return loss + + +@register_criterion("tacotron2", dataclass=Tacotron2CriterionConfig) +class Tacotron2Criterion(FairseqCriterion): + def __init__(self, task, sentence_avg, n_frames_per_step, + use_guided_attention_loss, guided_attention_loss_sigma, + bce_pos_weight, ctc_weight): + super().__init__(task) + self.sentence_avg = sentence_avg + self.n_frames_per_step = n_frames_per_step + self.bce_pos_weight = bce_pos_weight + + self.guided_attn = None + if use_guided_attention_loss: + self.guided_attn = GuidedAttentionLoss(guided_attention_loss_sigma) + self.ctc_weight = ctc_weight + + def forward(self, model, sample, reduction="mean"): + bsz, max_len, _ = sample["target"].size() + feat_tgt = sample["target"] + feat_len = sample["target_lengths"].view(bsz, 1).expand(-1, max_len) + eos_tgt = torch.arange(max_len).to(sample["target"].device) + eos_tgt = eos_tgt.view(1, max_len).expand(bsz, -1) + eos_tgt = (eos_tgt == (feat_len - 1)).float() + src_tokens = sample["net_input"]["src_tokens"] + src_lens = sample["net_input"]["src_lengths"] + tgt_lens = sample["target_lengths"] + + feat_out, eos_out, extra = model( + src_tokens=src_tokens, + src_lengths=src_lens, + prev_output_tokens=sample["net_input"]["prev_output_tokens"], + incremental_state=None, + target_lengths=tgt_lens, + speaker=sample["speaker"] + ) + + l1_loss, mse_loss, eos_loss = self.compute_loss( + extra["feature_out"], feat_out, eos_out, feat_tgt, eos_tgt, + tgt_lens, reduction, + ) + attn_loss = torch.tensor(0.).type_as(l1_loss) + if self.guided_attn is not None: + attn_loss = self.guided_attn(extra['attn'], src_lens, tgt_lens, reduction) + ctc_loss = torch.tensor(0.).type_as(l1_loss) + if self.ctc_weight > 0.: + net_output = (feat_out, eos_out, extra) + lprobs = model.get_normalized_probs(net_output, log_probs=True) + lprobs = lprobs.transpose(0, 1) # T x B x C + src_mask = lengths_to_mask(src_lens) + src_tokens_flat = src_tokens.masked_select(src_mask) + ctc_loss = F.ctc_loss( + lprobs, src_tokens_flat, tgt_lens, src_lens, + reduction=reduction, zero_infinity=True + ) * self.ctc_weight + loss = l1_loss + mse_loss + eos_loss + attn_loss + ctc_loss + + sample_size = sample["nsentences"] if self.sentence_avg \ + else sample["ntokens"] + logging_output = { + "loss": utils.item(loss.data), + "ntokens": sample["ntokens"], + "nsentences": sample["nsentences"], + "sample_size": sample_size, + "l1_loss": utils.item(l1_loss.data), + "mse_loss": utils.item(mse_loss.data), + "eos_loss": utils.item(eos_loss.data), + "attn_loss": utils.item(attn_loss.data), + "ctc_loss": utils.item(ctc_loss.data), + } + return loss, sample_size, logging_output + + def compute_loss(self, feat_out, feat_out_post, eos_out, feat_tgt, + eos_tgt, tgt_lens, reduction="mean"): + mask = lengths_to_mask(tgt_lens) + _eos_out = eos_out[mask].squeeze() + _eos_tgt = eos_tgt[mask] + _feat_tgt = feat_tgt[mask] + _feat_out = feat_out[mask] + _feat_out_post = feat_out_post[mask] + + l1_loss = ( + F.l1_loss(_feat_out, _feat_tgt, reduction=reduction) + + F.l1_loss(_feat_out_post, _feat_tgt, reduction=reduction) + ) + mse_loss = ( + F.mse_loss(_feat_out, _feat_tgt, reduction=reduction) + + F.mse_loss(_feat_out_post, _feat_tgt, reduction=reduction) + ) + eos_loss = F.binary_cross_entropy_with_logits( + _eos_out, _eos_tgt, pos_weight=torch.tensor(self.bce_pos_weight), + reduction=reduction + ) + return l1_loss, mse_loss, eos_loss + + @classmethod + def reduce_metrics(cls, logging_outputs: List[Dict[str, Any]]) -> None: + ns = [log.get("sample_size", 0) for log in logging_outputs] + ntot = sum(ns) + ws = [n / (ntot + 1e-8) for n in ns] + for key in ["loss", "l1_loss", "mse_loss", "eos_loss", "attn_loss", "ctc_loss"]: + vals = [log.get(key, 0) for log in logging_outputs] + val = sum(val * w for val, w in zip(vals, ws)) + metrics.log_scalar(key, val, ntot, round=3) + metrics.log_scalar("sample_size", ntot, len(logging_outputs)) + + # inference metrics + if "targ_frames" not in logging_outputs[0]: + return + n = sum(log.get("targ_frames", 0) for log in logging_outputs) + for key, new_key in [ + ("mcd_loss", "mcd_loss"), + ("pred_frames", "pred_ratio"), + ("nins", "ins_rate"), + ("ndel", "del_rate"), + ]: + val = sum(log.get(key, 0) for log in logging_outputs) + metrics.log_scalar(new_key, val / n, n, round=3) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + return False diff --git a/fairseq/fairseq/criterions/wav2vec_criterion.py b/fairseq/fairseq/criterions/wav2vec_criterion.py new file mode 100644 index 0000000000000000000000000000000000000000..e04786cc3b75517cefd06303f98f8536f9279311 --- /dev/null +++ b/fairseq/fairseq/criterions/wav2vec_criterion.py @@ -0,0 +1,229 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import List, Optional + +import torch +import torch.nn.functional as F +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion +from fairseq.dataclass import FairseqDataclass +from fairseq.logging.meters import safe_round +from fairseq.utils import is_xla_tensor + + +@dataclass +class Wav2VecCriterionConfig(FairseqDataclass): + infonce: bool = field( + default=False, + metadata={ + "help": "if set, uses cross entropy instead of binary cross entropy (i.e. InfoNCE loss)" + }, + ) + loss_weights: Optional[List[float]] = field( + default=None, + metadata={"help": "weights for additional loss terms (not first one)"}, + ) + log_keys: List[str] = field( + default_factory=lambda: [], + metadata={"help": "output keys to log"}, + ) + +@register_criterion("wav2vec", dataclass=Wav2VecCriterionConfig) +class Wav2vecCriterion(FairseqCriterion): + def __init__(self, task, infonce=False, loss_weights=None, log_keys=None): + super().__init__(task) + self.infonce = infonce + self.loss_weights = loss_weights + self.log_keys = [] if log_keys is None else log_keys + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + logits = model.get_logits(net_output).float() + target = model.get_targets(sample, net_output) + self.xla = is_xla_tensor(logits) + + # XXX: handle weights on xla. + weights = None + if hasattr(model, "get_target_weights") and not self.infonce: + weights = model.get_target_weights(target, net_output) + if torch.is_tensor(weights): + weights = weights.float() + + losses = [] + + reduction = "none" if ((not reduce) or self.xla) else "sum" + if self.infonce: + loss = F.cross_entropy(logits, target, reduction=reduction) + else: + loss = F.binary_cross_entropy_with_logits( + logits, target.float(), weights, reduction=reduction + ) + + if self.xla: + # tpu-comment: since dynamic shapes lead to recompilations on xla, + # we don't shrink tensors using mask_indices. + # Instead, we use mask indices to adjust loss. + mi = ( + sample['net_input']['mask_indices'] + .transpose(0, 1) # logits are transposed in `model.get_logits` + .reshape(logits.size(0)) + ) + loss = (loss * mi).sum() if reduce else (loss * mi) + + if 'sample_size' in sample: + sample_size = sample['sample_size'] + elif 'mask_indices' in sample['net_input']: + sample_size = sample['net_input']['mask_indices'].sum() + else: + sample_size = target.numel() if self.infonce else target.long().sum().item() + losses.append(loss.detach().clone()) + + if self.loss_weights is not None: + assert hasattr(model, "get_extra_losses") + extra_losses = model.get_extra_losses(net_output) + if torch.is_tensor(extra_losses): + extra_losses = [extra_losses] + if len(self.loss_weights) == 1 and len(extra_losses) != 1: + self.loss_weights = [self.loss_weights[0]] * len(extra_losses) + assert len(extra_losses) == len( + self.loss_weights + ), f"{len(extra_losses)}, {len(self.loss_weights)}" + for p, coef in zip(extra_losses, self.loss_weights): + if coef != 0 and p is not None: + p = coef * p.float() * sample_size + loss += p + losses.append(p) + + logging_output = { + "loss": loss.item() if (reduce and not self.xla) else loss.detach(), + "ntokens": sample_size, + "nsentences": sample["id"].numel(), + "sample_size": sample_size, + } + + for lk in self.log_keys: + # Only store "logits" and "target" for computing MAP and MAUC + # during validation + if lk == "logits": + if not self.training: + logging_output["logits"] = logits.cpu().numpy() + elif lk == "target": + if not self.training: + # If the targets have been mixed with the predictions of + # teacher models, find the original targets + if hasattr(model, "get_original_targets"): + original_target = model.get_original_targets(sample, net_output) + else: + original_target = target + logging_output["target"] = original_target.cpu().numpy() + elif lk in net_output: + value = net_output[lk] + if not is_xla_tensor(value): + value = float(value) + logging_output[lk] = value + + if len(losses) > 1: + for i, l in enumerate(losses): + logging_output[f"loss_{i}"] = l.item() if not self.xla else l.detach() + + if self.infonce: + with torch.no_grad(): + if logits.numel() == 0: + corr = 0 + count = 0 + else: + assert logits.dim() > 1, logits.shape + max = logits.argmax(-1) == 0 + min = logits.argmin(-1) == 0 + if is_xla_tensor(logits): + max, min = max * mi, min * mi + both = max & min + corr = max.long().sum() - both.long().sum() + count = mi.sum() + else: + both = max & min + corr = max.long().sum().item() - both.long().sum().item() + count = float(max.numel()) + + logging_output["correct"] = corr + logging_output["count"] = count + + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs)) + ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs)) + nsentences = utils.item( + sum(log.get("nsentences", 0) for log in logging_outputs) + ) + sample_size = utils.item( + sum(log.get("sample_size", 0) for log in logging_outputs) + ) + + metrics.log_scalar( + "loss", loss_sum / (sample_size or 1) / math.log(2), sample_size, round=3 + ) + metrics.log_scalar("ntokens", ntokens) + metrics.log_scalar("nsentences", nsentences) + + correct = sum(log.get("correct", 0) for log in logging_outputs) + metrics.log_scalar("_correct", correct) + + total = sum(log.get("count", 0) for log in logging_outputs) + metrics.log_scalar("_total", total) + + if total > 0: + metrics.log_derived( + "accuracy", + lambda meters: safe_round( + meters["_correct"].sum / meters["_total"].sum, 5 + ) + if meters["_total"].sum > 0 + else float("nan"), + ) + + builtin_keys = { + "loss", + "ntokens", + "nsentences", + "sample_size", + "correct", + "count", + } + + for k in logging_outputs[0]: + if k not in builtin_keys: + val = sum(log.get(k, 0) for log in logging_outputs) + if k.startswith("loss"): + metrics.log_scalar( + k, val / (sample_size or 1) / math.log(2), sample_size, round=3 + ) + else: + metrics.log_scalar(k, val / len(logging_outputs), round=3) + + # FIXME: revert when gather based xla reduction is implemented + #@staticmethod + #def logging_outputs_can_be_summed() -> bool: + def logging_outputs_can_be_summed(self) -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + # XXX: Gather based reduction not implemented for xla yet. + # So we fall to sum based reduction for xla. + return self.xla diff --git a/fairseq/fairseq/data/__init__.py b/fairseq/fairseq/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b7eb2ec4fc5190c4dcdfe34b0259e6f448e18a9 --- /dev/null +++ b/fairseq/fairseq/data/__init__.py @@ -0,0 +1,128 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +from .dictionary import Dictionary, TruncatedDictionary + +from .fairseq_dataset import FairseqDataset, FairseqIterableDataset + +from .base_wrapper_dataset import BaseWrapperDataset + +from .add_target_dataset import AddTargetDataset +from .append_token_dataset import AppendTokenDataset +from .audio.raw_audio_dataset import BinarizedAudioDataset, FileAudioDataset +from .audio.hubert_dataset import HubertDataset +from .backtranslation_dataset import BacktranslationDataset +from .bucket_pad_length_dataset import BucketPadLengthDataset +from .colorize_dataset import ColorizeDataset +from .concat_dataset import ConcatDataset +from .concat_sentences_dataset import ConcatSentencesDataset +from .denoising_dataset import DenoisingDataset +from .id_dataset import IdDataset +from .indexed_dataset import ( + IndexedCachedDataset, + IndexedDataset, + IndexedRawTextDataset, + MMapIndexedDataset, +) +from .language_pair_dataset import LanguagePairDataset +from .list_dataset import ListDataset +from .lm_context_window_dataset import LMContextWindowDataset +from .lru_cache_dataset import LRUCacheDataset +from .mask_tokens_dataset import MaskTokensDataset +from .monolingual_dataset import MonolingualDataset +from .multi_corpus_sampled_dataset import MultiCorpusSampledDataset +from .nested_dictionary_dataset import NestedDictionaryDataset +from .noising import NoisingDataset +from .numel_dataset import NumelDataset +from .num_samples_dataset import NumSamplesDataset +from .offset_tokens_dataset import OffsetTokensDataset +from .pad_dataset import LeftPadDataset, PadDataset, RightPadDataset +from .prepend_dataset import PrependDataset +from .prepend_token_dataset import PrependTokenDataset +from .raw_label_dataset import RawLabelDataset +from .replace_dataset import ReplaceDataset +from .resampling_dataset import ResamplingDataset +from .roll_dataset import RollDataset +from .round_robin_zip_datasets import RoundRobinZipDatasets +from .sort_dataset import SortDataset +from .strip_token_dataset import StripTokenDataset +from .subsample_dataset import SubsampleDataset +from .token_block_dataset import TokenBlockDataset +from .transform_eos_dataset import TransformEosDataset +from .transform_eos_lang_pair_dataset import TransformEosLangPairDataset +from .shorten_dataset import TruncateDataset, RandomCropDataset +from .multilingual.sampled_multi_dataset import SampledMultiDataset +from .multilingual.sampled_multi_epoch_dataset import SampledMultiEpochDataset +from .fasta_dataset import FastaDataset, EncodedFastaDataset + +from .iterators import ( + CountingIterator, + EpochBatchIterator, + GroupedIterator, + ShardedIterator, +) + +__all__ = [ + "AddTargetDataset", + "AppendTokenDataset", + "BacktranslationDataset", + "BaseWrapperDataset", + "BinarizedAudioDataset", + "BucketPadLengthDataset", + "ColorizeDataset", + "ConcatDataset", + "ConcatSentencesDataset", + "CountingIterator", + "DenoisingDataset", + "Dictionary", + "EncodedFastaDataset", + "EpochBatchIterator", + "FairseqDataset", + "FairseqIterableDataset", + "FastaDataset", + "FileAudioDataset", + "GroupedIterator", + "HubertDataset", + "IdDataset", + "IndexedCachedDataset", + "IndexedDataset", + "IndexedRawTextDataset", + "LanguagePairDataset", + "LeftPadDataset", + "ListDataset", + "LMContextWindowDataset", + "LRUCacheDataset", + "MaskTokensDataset", + "MMapIndexedDataset", + "MonolingualDataset", + "MultiCorpusSampledDataset", + "NestedDictionaryDataset", + "NoisingDataset", + "NumelDataset", + "NumSamplesDataset", + "OffsetTokensDataset", + "PadDataset", + "PrependDataset", + "PrependTokenDataset", + "RandomCropDataset", + "RawLabelDataset", + "ResamplingDataset", + "ReplaceDataset", + "RightPadDataset", + "RollDataset", + "RoundRobinZipDatasets", + "SampledMultiDataset", + "SampledMultiEpochDataset", + "ShardedIterator", + "SortDataset", + "StripTokenDataset", + "SubsampleDataset", + "TokenBlockDataset", + "TransformEosDataset", + "TransformEosLangPairDataset", + "TruncateDataset", + "TruncatedDictionary", +] diff --git a/fairseq/fairseq/data/add_target_dataset.py b/fairseq/fairseq/data/add_target_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..d8a08e746dedb8a5d9d9e4b9ad149e0da469d644 --- /dev/null +++ b/fairseq/fairseq/data/add_target_dataset.py @@ -0,0 +1,79 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import BaseWrapperDataset, data_utils +from fairseq.data.text_compressor import TextCompressor, TextCompressionLevel + + +class AddTargetDataset(BaseWrapperDataset): + def __init__( + self, + dataset, + labels, + pad, + eos, + batch_targets, + process_label=None, + label_len_fn=None, + add_to_input=False, + text_compression_level=TextCompressionLevel.none + ): + super().__init__(dataset) + self.labels = labels + self.batch_targets = batch_targets + self.pad = pad + self.eos = eos + self.process_label = process_label + self.label_len_fn = label_len_fn + self.add_to_input = add_to_input + self.text_compressor = TextCompressor(level=text_compression_level) + + def get_label(self, index, process_fn=None): + lbl = self.labels[index] + lbl = self.text_compressor.decompress(lbl) + return lbl if process_fn is None else process_fn(lbl) + + def __getitem__(self, index): + item = self.dataset[index] + item["label"] = self.get_label(index, process_fn=self.process_label) + return item + + def size(self, index): + sz = self.dataset.size(index) + own_sz = self.label_len_fn(self.get_label(index)) + return sz, own_sz + + def collater(self, samples): + collated = self.dataset.collater(samples) + if len(collated) == 0: + return collated + indices = set(collated["id"].tolist()) + target = [s["label"] for s in samples if s["id"] in indices] + + if self.batch_targets: + collated["target_lengths"] = torch.LongTensor([len(t) for t in target]) + target = data_utils.collate_tokens(target, pad_idx=self.pad, left_pad=False) + collated["ntokens"] = collated["target_lengths"].sum().item() + else: + collated["ntokens"] = sum([len(t) for t in target]) + + collated["target"] = target + + if self.add_to_input: + eos = target.new_full((target.size(0), 1), self.eos) + collated["target"] = torch.cat([target, eos], dim=-1).long() + collated["net_input"]["prev_output_tokens"] = torch.cat( + [eos, target], dim=-1 + ).long() + collated["ntokens"] += target.size(0) + return collated + + def filter_indices_by_size(self, indices, max_sizes): + indices, ignored = data_utils._filter_by_size_dynamic( + indices, self.size, max_sizes + ) + return indices, ignored diff --git a/fairseq/fairseq/data/append_token_dataset.py b/fairseq/fairseq/data/append_token_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..87695bd0f5fcb6b10247e3b743340623e6438cc1 --- /dev/null +++ b/fairseq/fairseq/data/append_token_dataset.py @@ -0,0 +1,41 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from . import BaseWrapperDataset + + +class AppendTokenDataset(BaseWrapperDataset): + def __init__(self, dataset, token=None): + super().__init__(dataset) + self.token = token + if token is not None: + self._sizes = np.array(dataset.sizes) + 1 + else: + self._sizes = dataset.sizes + + def __getitem__(self, idx): + item = self.dataset[idx] + if self.token is not None: + item = torch.cat([item, item.new([self.token])]) + return item + + @property + def sizes(self): + return self._sizes + + def num_tokens(self, index): + n = self.dataset.num_tokens(index) + if self.token is not None: + n += 1 + return n + + def size(self, index): + n = self.dataset.size(index) + if self.token is not None: + n += 1 + return n diff --git a/fairseq/fairseq/data/audio/__init__.py b/fairseq/fairseq/data/audio/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/fairseq/data/audio/audio_utils.py b/fairseq/fairseq/data/audio/audio_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b9444cb8d005fe537b2968d9ed0d92273c46b8f6 --- /dev/null +++ b/fairseq/fairseq/data/audio/audio_utils.py @@ -0,0 +1,280 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from pathlib import Path +from typing import BinaryIO, Optional, Tuple, Union, List + +import numpy as np +import torch +import torch.nn.functional as F + + +SF_AUDIO_FILE_EXTENSIONS = {".wav", ".flac", ".ogg"} +FEATURE_OR_SF_AUDIO_FILE_EXTENSIONS = {".npy", ".wav", ".flac", ".ogg"} + + +def convert_waveform( + waveform: Union[np.ndarray, torch.Tensor], sample_rate: int, + normalize_volume: bool = False, to_mono: bool = False, + to_sample_rate: Optional[int] = None +) -> Tuple[Union[np.ndarray, torch.Tensor], int]: + """convert a waveform: + - to a target sample rate + - from multi-channel to mono channel + - volume normalization + + Args: + waveform (numpy.ndarray or torch.Tensor): 2D original waveform + (channels x length) + sample_rate (int): original sample rate + normalize_volume (bool): perform volume normalization + to_mono (bool): convert to mono channel if having multiple channels + to_sample_rate (Optional[int]): target sample rate + Returns: + waveform (numpy.ndarray): converted 2D waveform (channels x length) + sample_rate (float): target sample rate + """ + try: + import torchaudio.sox_effects as ta_sox + except ImportError: + raise ImportError("Please install torchaudio: pip install torchaudio") + + effects = [] + if normalize_volume: + effects.append(["gain", "-n"]) + if to_sample_rate is not None and to_sample_rate != sample_rate: + effects.append(["rate", f"{to_sample_rate}"]) + if to_mono and waveform.shape[0] > 1: + effects.append(["channels", "1"]) + if len(effects) > 0: + is_np_input = isinstance(waveform, np.ndarray) + _waveform = torch.from_numpy(waveform) if is_np_input else waveform + converted, converted_sample_rate = ta_sox.apply_effects_tensor( + _waveform, sample_rate, effects + ) + if is_np_input: + converted = converted.numpy() + return converted, converted_sample_rate + return waveform, sample_rate + + +def get_waveform( + path_or_fp: Union[str, BinaryIO], normalization: bool = True, + mono: bool = True, frames: int = -1, start: int = 0, + always_2d: bool = True, output_sample_rate: Optional[int] = None, + normalize_volume: bool = False +) -> Tuple[np.ndarray, int]: + """Get the waveform and sample rate of a 16-bit WAV/FLAC/OGG Vorbis audio. + + Args: + path_or_fp (str or BinaryIO): the path or file-like object + normalization (bool): normalize values to [-1, 1] (Default: True) + mono (bool): convert multi-channel audio to mono-channel one + frames (int): the number of frames to read. (-1 for reading all) + start (int): Where to start reading. A negative value counts from the end. + always_2d (bool): always return 2D array even for mono-channel audios + output_sample_rate (Optional[int]): output sample rate + normalize_volume (bool): normalize volume + Returns: + waveform (numpy.ndarray): 1D or 2D waveform (channels x length) + sample_rate (float): sample rate + """ + if isinstance(path_or_fp, str): + ext = Path(path_or_fp).suffix + if ext not in SF_AUDIO_FILE_EXTENSIONS: + raise ValueError(f"Unsupported audio format: {ext}") + + try: + import soundfile as sf + except ImportError: + raise ImportError("Please install soundfile: pip install soundfile") + + waveform, sample_rate = sf.read( + path_or_fp, dtype="float32", always_2d=True, frames=frames, start=start + ) + waveform = waveform.T # T x C -> C x T + waveform, sample_rate = convert_waveform( + waveform, sample_rate, normalize_volume=normalize_volume, to_mono=mono, + to_sample_rate=output_sample_rate + ) + + if not normalization: + waveform *= 2 ** 15 # denormalized to 16-bit signed integers + if not always_2d: + waveform = waveform.squeeze(axis=0) + return waveform, sample_rate + + +def _get_kaldi_fbank( + waveform: np.ndarray, sample_rate: int, n_bins=80 +) -> Optional[np.ndarray]: + """Get mel-filter bank features via PyKaldi.""" + try: + from kaldi.feat.fbank import FbankOptions, Fbank + from kaldi.feat.mel import MelBanksOptions + from kaldi.feat.window import FrameExtractionOptions + from kaldi.matrix import Vector + + mel_opts = MelBanksOptions() + mel_opts.num_bins = n_bins + frame_opts = FrameExtractionOptions() + frame_opts.samp_freq = sample_rate + opts = FbankOptions() + opts.mel_opts = mel_opts + opts.frame_opts = frame_opts + fbank = Fbank(opts=opts) + features = fbank.compute(Vector(waveform.squeeze()), 1.0).numpy() + return features + except ImportError: + return None + + +def _get_torchaudio_fbank( + waveform: np.ndarray, sample_rate, n_bins=80 +) -> Optional[np.ndarray]: + """Get mel-filter bank features via TorchAudio.""" + try: + import torchaudio.compliance.kaldi as ta_kaldi + + waveform = torch.from_numpy(waveform) + features = ta_kaldi.fbank( + waveform, num_mel_bins=n_bins, sample_frequency=sample_rate + ) + return features.numpy() + except ImportError: + return None + + +def get_fbank(path_or_fp: Union[str, BinaryIO], n_bins=80) -> np.ndarray: + """Get mel-filter bank features via PyKaldi or TorchAudio. Prefer PyKaldi + (faster CPP implementation) to TorchAudio (Python implementation). Note that + Kaldi/TorchAudio requires 16-bit signed integers as inputs and hence the + waveform should not be normalized.""" + waveform, sample_rate = get_waveform(path_or_fp, normalization=False) + + features = _get_kaldi_fbank(waveform, sample_rate, n_bins) + if features is None: + features = _get_torchaudio_fbank(waveform, sample_rate, n_bins) + if features is None: + raise ImportError( + "Please install pyKaldi or torchaudio to enable " + "online filterbank feature extraction" + ) + + return features + + +def is_npy_data(data: bytes) -> bool: + return data[0] == 147 and data[1] == 78 + + +def is_sf_audio_data(data: bytes) -> bool: + is_wav = data[0] == 82 and data[1] == 73 and data[2] == 70 + is_flac = data[0] == 102 and data[1] == 76 and data[2] == 97 + is_ogg = data[0] == 79 and data[1] == 103 and data[2] == 103 + return is_wav or is_flac or is_ogg + + +def read_from_stored_zip(zip_path: str, offset: int, file_size: int) -> bytes: + with open(zip_path, "rb") as f: + f.seek(offset) + data = f.read(file_size) + return data + + +def parse_path(path: str) -> Tuple[str, List[int]]: + """Parse data path which is either a path to + 1. a .npy/.wav/.flac/.ogg file + 2. a stored ZIP file with slicing info: "[zip_path]:[offset]:[length]" + + Args: + path (str): the data path to parse + + Returns: + file_path (str): the file path + slice_ptr (list of int): empty in case 1; + byte offset and length for the slice in case 2 + """ + + if Path(path).suffix in FEATURE_OR_SF_AUDIO_FILE_EXTENSIONS: + _path, slice_ptr = path, [] + else: + _path, *slice_ptr = path.split(":") + if not Path(_path).is_file(): + raise FileNotFoundError(f"File not found: {_path}") + assert len(slice_ptr) in {0, 2}, f"Invalid path: {path}" + slice_ptr = [int(i) for i in slice_ptr] + return _path, slice_ptr + + +def get_window( + window_fn: callable, n_fft: int, win_length: int +) -> torch.Tensor: + padding = n_fft - win_length + assert padding >= 0 + return F.pad(window_fn(win_length), (padding // 2, padding - padding // 2)) + + +def get_fourier_basis(n_fft: int) -> torch.Tensor: + basis = np.fft.fft(np.eye(n_fft)) + basis = np.vstack( + [np.real(basis[:n_fft // 2 + 1, :]), np.imag(basis[:n_fft // 2 + 1, :])] + ) + return torch.from_numpy(basis).float() + + +def get_mel_filters( + sample_rate: int, n_fft: int, n_mels: int, f_min: float, f_max: float +) -> torch.Tensor: + try: + import librosa + except ImportError: + raise ImportError("Please install librosa: pip install librosa") + basis = librosa.filters.mel(sample_rate, n_fft, n_mels, f_min, f_max) + return torch.from_numpy(basis).float() + + +class TTSSpectrogram(torch.nn.Module): + def __init__( + self, n_fft: int, win_length: int, hop_length: int, + window_fn: callable = torch.hann_window, return_phase: bool = False + ) -> None: + super(TTSSpectrogram, self).__init__() + self.n_fft = n_fft + self.hop_length = hop_length + self.return_phase = return_phase + + basis = get_fourier_basis(n_fft).unsqueeze(1) + basis *= get_window(window_fn, n_fft, win_length) + self.register_buffer('basis', basis) + + def forward( + self, waveform: torch.Tensor + ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + padding = (self.n_fft // 2, self.n_fft // 2) + x = F.pad(waveform.unsqueeze(1), padding, mode='reflect') + x = F.conv1d(x, self.basis, stride=self.hop_length) + real_part = x[:, :self.n_fft // 2 + 1, :] + imag_part = x[:, self.n_fft // 2 + 1:, :] + magnitude = torch.sqrt(real_part ** 2 + imag_part ** 2) + if self.return_phase: + phase = torch.atan2(imag_part, real_part) + return magnitude, phase + return magnitude + + +class TTSMelScale(torch.nn.Module): + def __init__( + self, n_mels: int, sample_rate: int, f_min: float, f_max: float, + n_stft: int + ) -> None: + super(TTSMelScale, self).__init__() + basis = get_mel_filters(sample_rate, (n_stft - 1) * 2, n_mels, f_min, + f_max) + self.register_buffer('basis', basis) + + def forward(self, specgram: torch.Tensor) -> torch.Tensor: + return torch.matmul(self.basis, specgram) diff --git a/fairseq/fairseq/data/audio/data_cfg.py b/fairseq/fairseq/data/audio/data_cfg.py new file mode 100644 index 0000000000000000000000000000000000000000..95b403ad9c617afb5656131693c92b9cc3befd3b --- /dev/null +++ b/fairseq/fairseq/data/audio/data_cfg.py @@ -0,0 +1,139 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from pathlib import Path +from typing import Dict, Optional + + +class S2TDataConfig(object): + """Wrapper class for data config YAML""" + + def __init__(self, yaml_path: Path): + try: + import yaml + except ImportError: + print("Please install PyYAML: pip install PyYAML") + self.config = {} + if yaml_path.is_file(): + try: + with open(yaml_path) as f: + self.config = yaml.load(f, Loader=yaml.FullLoader) + except Exception as e: + raise Exception( + f"Failed to load config from {yaml_path.as_posix()}: {e}" + ) + else: + raise FileNotFoundError(f"{yaml_path.as_posix()} not found") + self.root = yaml_path.parent + + def _auto_convert_to_abs_path(self, x): + if isinstance(x, str): + if not Path(x).exists() and (self.root / x).exists(): + return (self.root / x).as_posix() + elif isinstance(x, dict): + return {k: self._auto_convert_to_abs_path(v) for k, v in x.items()} + return x + + @property + def vocab_filename(self): + """fairseq vocabulary file under data root""" + return self.config.get("vocab_filename", "dict.txt") + + @property + def speaker_set_filename(self): + """fairseq vocabulary file under data root""" + return self.config.get("speaker_set_filename", None) + + @property + def shuffle(self) -> bool: + """Shuffle dataset samples before batching""" + return self.config.get("shuffle", False) + + @property + def pre_tokenizer(self) -> Dict: + """Pre-tokenizer to apply before subword tokenization. Returning + a dictionary with `tokenizer` providing the tokenizer name and + the other items providing the tokenizer-specific arguments. + Tokenizers are defined in `fairseq.data.encoders.*`""" + tokenizer = self.config.get("pre_tokenizer", {"tokenizer": None}) + return self._auto_convert_to_abs_path(tokenizer) + + @property + def bpe_tokenizer(self) -> Dict: + """Subword tokenizer to apply after pre-tokenization. Returning + a dictionary with `bpe` providing the tokenizer name and + the other items providing the tokenizer-specific arguments. + Tokenizers are defined in `fairseq.data.encoders.*`""" + tokenizer = self.config.get("bpe_tokenizer", {"bpe": None}) + return self._auto_convert_to_abs_path(tokenizer) + + @property + def prepend_tgt_lang_tag(self) -> bool: + """Prepend target lang ID token as the target BOS (e.g. for to-many + multilingual setting). During inference, this requires `--prefix-size 1` + to force BOS to be lang ID token.""" + return self.config.get("prepend_tgt_lang_tag", False) + + @property + def input_feat_per_channel(self): + """The dimension of input features (per audio channel)""" + return self.config.get("input_feat_per_channel", 80) + + @property + def input_channels(self): + """The number of channels in the input audio""" + return self.config.get("input_channels", 1) + + @property + def sample_rate(self): + return self.config.get("sample_rate", 16_000) + + @property + def sampling_alpha(self): + """Hyper-parameter alpha = 1/T for temperature-based resampling. + (alpha = 1 for no resampling)""" + return self.config.get("sampling_alpha", 1.0) + + @property + def use_audio_input(self): + """Needed by the dataset loader to see if the model requires + raw audio as inputs.""" + return self.config.get("use_audio_input", False) + + @property + def use_sample_rate(self): + """Needed by the dataset loader to see if the model requires + raw audio with specific sample rate as inputs.""" + return self.config.get("use_sample_rate", 16000) + + @property + def audio_root(self): + """Audio paths in the manifest TSV can be relative and this provides + the root path. Set this to empty string when using absolute paths.""" + return self.config.get("audio_root", "") + + def get_feature_transforms(self, split, is_train): + """Split-specific feature transforms. Allowing train set + wildcard `_train`, evaluation set wildcard `_eval` and general + wildcard `*` for matching.""" + from copy import deepcopy + + cfg = deepcopy(self.config) + _cur = cfg.get("transforms", {}) + cur = _cur.get(split) + cur = _cur.get("_train") if cur is None and is_train else cur + cur = _cur.get("_eval") if cur is None and not is_train else cur + cur = _cur.get("*") if cur is None else cur + cfg["transforms"] = cur + return cfg + + @property + def global_cmvn_stats_npz(self) -> Optional[str]: + path = self.config.get("global_cmvn", {}).get("stats_npz_path", None) + return self._auto_convert_to_abs_path(path) + + @property + def vocoder(self) -> Optional[Dict[str, str]]: + return self.config.get("vocoder", None) diff --git a/fairseq/fairseq/data/audio/feature_transforms/__init__.py b/fairseq/fairseq/data/audio/feature_transforms/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..359fa069716cba0dd615ce0959368b20828c31f7 --- /dev/null +++ b/fairseq/fairseq/data/audio/feature_transforms/__init__.py @@ -0,0 +1,82 @@ +import importlib +import os +from abc import ABC, abstractmethod +from typing import Dict, Optional + + +class AudioFeatureTransform(ABC): + @classmethod + @abstractmethod + def from_config_dict(cls, config: Optional[Dict] = None): + pass + + +AUDIO_FEATURE_TRANSFORM_REGISTRY = {} +AUDIO_FEATURE_TRANSFORM_CLASS_NAMES = set() + + +def register_audio_feature_transform(name): + def register_audio_feature_transform_cls(cls): + if name in AUDIO_FEATURE_TRANSFORM_REGISTRY: + raise ValueError(f"Cannot register duplicate transform ({name})") + if not issubclass(cls, AudioFeatureTransform): + raise ValueError( + f"Transform ({name}: {cls.__name__}) must extend " + "AudioFeatureTransform" + ) + if cls.__name__ in AUDIO_FEATURE_TRANSFORM_CLASS_NAMES: + raise ValueError( + f"Cannot register audio feature transform with duplicate " + f"class name ({cls.__name__})" + ) + AUDIO_FEATURE_TRANSFORM_REGISTRY[name] = cls + AUDIO_FEATURE_TRANSFORM_CLASS_NAMES.add(cls.__name__) + return cls + + return register_audio_feature_transform_cls + + +def get_audio_feature_transform(name): + return AUDIO_FEATURE_TRANSFORM_REGISTRY[name] + + +transforms_dir = os.path.dirname(__file__) +for file in os.listdir(transforms_dir): + path = os.path.join(transforms_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + name = file[: file.find(".py")] if file.endswith(".py") else file + importlib.import_module("fairseq.data.audio.feature_transforms." + name) + + +class CompositeAudioFeatureTransform(AudioFeatureTransform): + @classmethod + def from_config_dict(cls, config=None): + _config = {} if config is None else config + _transforms = _config.get("transforms") + if _transforms is None: + return None + transforms = [ + get_audio_feature_transform(_t).from_config_dict(_config.get(_t)) + for _t in _transforms + ] + return CompositeAudioFeatureTransform(transforms) + + def __init__(self, transforms): + self.transforms = [t for t in transforms if t is not None] + + def __call__(self, x): + for t in self.transforms: + x = t(x) + return x + + def __repr__(self): + format_string = ( + [self.__class__.__name__ + "("] + + [f" {t.__repr__()}" for t in self.transforms] + + [")"] + ) + return "\n".join(format_string) diff --git a/fairseq/fairseq/data/audio/feature_transforms/global_cmvn.py b/fairseq/fairseq/data/audio/feature_transforms/global_cmvn.py new file mode 100644 index 0000000000000000000000000000000000000000..e457ff176fee3b996da11f47e7dc61b81c445ba3 --- /dev/null +++ b/fairseq/fairseq/data/audio/feature_transforms/global_cmvn.py @@ -0,0 +1,29 @@ +import numpy as np +from fairseq.data.audio.feature_transforms import ( + AudioFeatureTransform, + register_audio_feature_transform, +) + + +@register_audio_feature_transform("global_cmvn") +class GlobalCMVN(AudioFeatureTransform): + """Global CMVN (cepstral mean and variance normalization). The global mean + and variance need to be pre-computed and stored in NumPy format (.npz).""" + + @classmethod + def from_config_dict(cls, config=None): + _config = {} if config is None else config + return GlobalCMVN(_config.get("stats_npz_path")) + + def __init__(self, stats_npz_path): + self.stats_npz_path = stats_npz_path + stats = np.load(stats_npz_path) + self.mean, self.std = stats["mean"], stats["std"] + + def __repr__(self): + return self.__class__.__name__ + f'(stats_npz_path="{self.stats_npz_path}")' + + def __call__(self, x): + x = np.subtract(x, self.mean) + x = np.divide(x, self.std) + return x diff --git a/fairseq/fairseq/data/audio/feature_transforms/specaugment.py b/fairseq/fairseq/data/audio/feature_transforms/specaugment.py new file mode 100644 index 0000000000000000000000000000000000000000..ce5802b41a903ea8f3e3e8a169d5048b4e908f99 --- /dev/null +++ b/fairseq/fairseq/data/audio/feature_transforms/specaugment.py @@ -0,0 +1,131 @@ +import math +import numbers +from typing import Optional + +import numpy as np +from fairseq.data.audio.feature_transforms import ( + AudioFeatureTransform, + register_audio_feature_transform, +) + + +@register_audio_feature_transform("specaugment") +class SpecAugmentTransform(AudioFeatureTransform): + """SpecAugment (https://arxiv.org/abs/1904.08779)""" + + @classmethod + def from_config_dict(cls, config=None): + _config = {} if config is None else config + return SpecAugmentTransform( + _config.get("time_warp_W", 0), + _config.get("freq_mask_N", 0), + _config.get("freq_mask_F", 0), + _config.get("time_mask_N", 0), + _config.get("time_mask_T", 0), + _config.get("time_mask_p", 0.0), + _config.get("mask_value", None), + ) + + def __init__( + self, + time_warp_w: int = 0, + freq_mask_n: int = 0, + freq_mask_f: int = 0, + time_mask_n: int = 0, + time_mask_t: int = 0, + time_mask_p: float = 0.0, + mask_value: Optional[float] = 0.0, + ): + # Sanity checks + assert mask_value is None or isinstance( + mask_value, numbers.Number + ), f"mask_value (type: {type(mask_value)}) must be None or a number" + if freq_mask_n > 0: + assert freq_mask_f > 0, ( + f"freq_mask_F ({freq_mask_f}) " + f"must be larger than 0 when doing freq masking." + ) + if time_mask_n > 0: + assert time_mask_t > 0, ( + f"time_mask_T ({time_mask_t}) must be larger than 0 when " + f"doing time masking." + ) + + self.time_warp_w = time_warp_w + self.freq_mask_n = freq_mask_n + self.freq_mask_f = freq_mask_f + self.time_mask_n = time_mask_n + self.time_mask_t = time_mask_t + self.time_mask_p = time_mask_p + self.mask_value = mask_value + + def __repr__(self): + return ( + self.__class__.__name__ + + "(" + + ", ".join( + [ + f"time_warp_w={self.time_warp_w}", + f"freq_mask_n={self.freq_mask_n}", + f"freq_mask_f={self.freq_mask_f}", + f"time_mask_n={self.time_mask_n}", + f"time_mask_t={self.time_mask_t}", + f"time_mask_p={self.time_mask_p}", + ] + ) + + ")" + ) + + def __call__(self, spectrogram): + assert len(spectrogram.shape) == 2, "spectrogram must be a 2-D tensor." + + distorted = spectrogram.copy() # make a copy of input spectrogram. + num_frames = spectrogram.shape[0] # or 'tau' in the paper. + num_freqs = spectrogram.shape[1] # or 'miu' in the paper. + mask_value = self.mask_value + + if mask_value is None: # if no value was specified, use local mean. + mask_value = spectrogram.mean() + + if num_frames == 0: + return spectrogram + + if num_freqs < self.freq_mask_f: + return spectrogram + + if self.time_warp_w > 0: + if 2 * self.time_warp_w < num_frames: + import cv2 + + w0 = np.random.randint(self.time_warp_w, num_frames - self.time_warp_w) + w = np.random.randint(-self.time_warp_w + 1, self.time_warp_w) + upper, lower = distorted[:w0, :], distorted[w0:, :] + upper = cv2.resize( + upper, dsize=(num_freqs, w0 + w), interpolation=cv2.INTER_LINEAR + ) + lower = cv2.resize( + lower, + dsize=(num_freqs, num_frames - w0 - w), + interpolation=cv2.INTER_LINEAR, + ) + distorted = np.concatenate((upper, lower), axis=0) + + for _i in range(self.freq_mask_n): + f = np.random.randint(0, self.freq_mask_f) + f0 = np.random.randint(0, num_freqs - f) + if f != 0: + distorted[:, f0 : f0 + f] = mask_value + + max_time_mask_t = min( + self.time_mask_t, math.floor(num_frames * self.time_mask_p) + ) + if max_time_mask_t < 1: + return distorted + + for _i in range(self.time_mask_n): + t = np.random.randint(0, max_time_mask_t) + t0 = np.random.randint(0, num_frames - t) + if t != 0: + distorted[t0 : t0 + t, :] = mask_value + + return distorted diff --git a/fairseq/fairseq/data/audio/feature_transforms/utterance_cmvn.py b/fairseq/fairseq/data/audio/feature_transforms/utterance_cmvn.py new file mode 100644 index 0000000000000000000000000000000000000000..6bbd0ae821b42ab693f4141e7c161d6d7cb0b15a --- /dev/null +++ b/fairseq/fairseq/data/audio/feature_transforms/utterance_cmvn.py @@ -0,0 +1,40 @@ +import numpy as np +from fairseq.data.audio.feature_transforms import ( + AudioFeatureTransform, + register_audio_feature_transform, +) + + +@register_audio_feature_transform("utterance_cmvn") +class UtteranceCMVN(AudioFeatureTransform): + """Utterance-level CMVN (cepstral mean and variance normalization)""" + + @classmethod + def from_config_dict(cls, config=None): + _config = {} if config is None else config + return UtteranceCMVN( + _config.get("norm_means", True), + _config.get("norm_vars", True), + ) + + def __init__(self, norm_means=True, norm_vars=True): + self.norm_means, self.norm_vars = norm_means, norm_vars + + def __repr__(self): + return ( + self.__class__.__name__ + + f"(norm_means={self.norm_means}, norm_vars={self.norm_vars})" + ) + + def __call__(self, x): + mean = x.mean(axis=0) + square_sums = (x ** 2).sum(axis=0) + + if self.norm_means: + x = np.subtract(x, mean) + if self.norm_vars: + var = square_sums / x.shape[0] - mean ** 2 + std = np.sqrt(np.maximum(var, 1e-10)) + x = np.divide(x, std) + + return x diff --git a/fairseq/fairseq/data/audio/frm_text_to_speech_dataset.py b/fairseq/fairseq/data/audio/frm_text_to_speech_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..125b1fc0c0a67190e6d9ba4866664cbc9006a142 --- /dev/null +++ b/fairseq/fairseq/data/audio/frm_text_to_speech_dataset.py @@ -0,0 +1,207 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory.abs + +import csv +import logging +import os.path as op +from typing import List, Optional + +import numpy as np +import torch +from fairseq.data import Dictionary +from fairseq.data.audio.speech_to_text_dataset import ( + S2TDataConfig +) +from fairseq.data.audio.text_to_speech_dataset import ( + TextToSpeechDataset, TextToSpeechDatasetCreator +) + +logger = logging.getLogger(__name__) + + +class FrmTextToSpeechDataset(TextToSpeechDataset): + def __init__( + self, + split: str, + is_train_split: bool, + data_cfg: S2TDataConfig, + audio_paths: List[str], + n_frames: List[int], + src_texts: Optional[List[str]] = None, + tgt_texts: Optional[List[str]] = None, + speakers: Optional[List[str]] = None, + src_langs: Optional[List[str]] = None, + tgt_langs: Optional[List[str]] = None, + ids: Optional[List[str]] = None, + tgt_dict: Optional[Dictionary] = None, + pre_tokenizer=None, + bpe_tokenizer=None, + n_frames_per_step=1, + speaker_to_id=None, + do_chunk=False, + chunk_bound=-1, + chunk_init=50, + chunk_incr=5, + add_eos=True, + dedup=True, + ref_fpu=-1 + ): + # It assumes texts are encoded at a fixed frame-rate + super().__init__( + split=split, + is_train_split=is_train_split, + data_cfg=data_cfg, + audio_paths=audio_paths, + n_frames=n_frames, + src_texts=src_texts, + tgt_texts=tgt_texts, + speakers=speakers, + src_langs=src_langs, + tgt_langs=tgt_langs, + ids=ids, + tgt_dict=tgt_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + n_frames_per_step=n_frames_per_step, + speaker_to_id=speaker_to_id + ) + + self.do_chunk = do_chunk + self.chunk_bound = chunk_bound + self.chunk_init = chunk_init + self.chunk_incr = chunk_incr + self.add_eos = add_eos + self.dedup = dedup + self.ref_fpu = ref_fpu + + self.chunk_size = -1 + + if do_chunk: + assert self.chunk_incr >= 0 + assert self.pre_tokenizer is None + + def __getitem__(self, index): + index, source, target, speaker_id, _, _, _ = super().__getitem__(index) + if target[-1].item() == self.tgt_dict.eos_index: + target = target[:-1] + + fpu = source.size(0) / target.size(0) # frame-per-unit + fps = self.n_frames_per_step + assert ( + self.ref_fpu == -1 or + abs((fpu * fps - self.ref_fpu) / self.ref_fpu) < 0.1 + ), f"{fpu*fps} != {self.ref_fpu}" + + # only chunk training split + if self.is_train_split and self.do_chunk and self.chunk_size > 0: + lang = target[:int(self.data_cfg.prepend_tgt_lang_tag)] + text = target[int(self.data_cfg.prepend_tgt_lang_tag):] + size = len(text) + chunk_size = min(self.chunk_size, size) + chunk_start = np.random.randint(size - chunk_size + 1) + text = text[chunk_start:chunk_start+chunk_size] + target = torch.cat((lang, text), 0) + + f_size = int(np.floor(chunk_size * fpu)) + f_start = int(np.floor(chunk_start * fpu)) + assert(f_size > 0) + source = source[f_start:f_start+f_size, :] + + if self.dedup: + target = torch.unique_consecutive(target) + + if self.add_eos: + eos_idx = self.tgt_dict.eos_index + target = torch.cat((target, torch.LongTensor([eos_idx])), 0) + + return index, source, target, speaker_id + + def set_epoch(self, epoch): + if self.is_train_split and self.do_chunk: + old = self.chunk_size + self.chunk_size = self.chunk_init + epoch * self.chunk_incr + if self.chunk_bound > 0: + self.chunk_size = min(self.chunk_size, self.chunk_bound) + logger.info(( + f"{self.split}: setting chunk size " + f"from {old} to {self.chunk_size}" + )) + + +class FrmTextToSpeechDatasetCreator(TextToSpeechDatasetCreator): + # inherit for key names + @classmethod + def from_tsv( + cls, + root: str, + data_cfg: S2TDataConfig, + split: str, + tgt_dict, + pre_tokenizer, + bpe_tokenizer, + is_train_split: bool, + n_frames_per_step: int, + speaker_to_id, + do_chunk: bool = False, + chunk_bound: int = -1, + chunk_init: int = 50, + chunk_incr: int = 5, + add_eos: bool = True, + dedup: bool = True, + ref_fpu: float = -1 + ) -> FrmTextToSpeechDataset: + tsv_path = op.join(root, f"{split}.tsv") + if not op.isfile(tsv_path): + raise FileNotFoundError(f"Dataset not found: {tsv_path}") + with open(tsv_path) as f: + reader = csv.DictReader( + f, + delimiter="\t", + quotechar=None, + doublequote=False, + lineterminator="\n", + quoting=csv.QUOTE_NONE, + ) + s = [dict(e) for e in reader] + assert len(s) > 0 + + ids = [ss[cls.KEY_ID] for ss in s] + audio_paths = [ + op.join(data_cfg.audio_root, ss[cls.KEY_AUDIO]) for ss in s + ] + n_frames = [int(ss[cls.KEY_N_FRAMES]) for ss in s] + tgt_texts = [ss[cls.KEY_TGT_TEXT] for ss in s] + src_texts = [ss.get(cls.KEY_SRC_TEXT, cls.DEFAULT_SRC_TEXT) for ss in s] + speakers = [ss.get(cls.KEY_SPEAKER, cls.DEFAULT_SPEAKER) for ss in s] + src_langs = [ss.get(cls.KEY_SRC_LANG, cls.DEFAULT_LANG) for ss in s] + tgt_langs = [ss.get(cls.KEY_TGT_LANG, cls.DEFAULT_LANG) for ss in s] + + return FrmTextToSpeechDataset( + split=split, + is_train_split=is_train_split, + data_cfg=data_cfg, + audio_paths=audio_paths, + n_frames=n_frames, + src_texts=src_texts, + tgt_texts=tgt_texts, + speakers=speakers, + src_langs=src_langs, + tgt_langs=tgt_langs, + ids=ids, + tgt_dict=tgt_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + n_frames_per_step=n_frames_per_step, + speaker_to_id=speaker_to_id, + do_chunk=do_chunk, + chunk_bound=chunk_bound, + chunk_init=chunk_init, + chunk_incr=chunk_incr, + add_eos=add_eos, + dedup=dedup, + ref_fpu=ref_fpu + ) diff --git a/fairseq/fairseq/data/audio/hubert_dataset.py b/fairseq/fairseq/data/audio/hubert_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..f00fe301a64a8740ed3ce07e44f6774edb933926 --- /dev/null +++ b/fairseq/fairseq/data/audio/hubert_dataset.py @@ -0,0 +1,358 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools +import logging +import os +import sys +from typing import Any, List, Optional, Union + +import numpy as np + +import torch +import torch.nn.functional as F +from fairseq.data import data_utils +from fairseq.data.fairseq_dataset import FairseqDataset + +logger = logging.getLogger(__name__) + + +def load_audio(manifest_path, max_keep, min_keep): + n_long, n_short = 0, 0 + names, inds, sizes = [], [], [] + with open(manifest_path) as f: + root = f.readline().strip() + for ind, line in enumerate(f): + items = line.strip().split("\t") + assert len(items) == 2, line + sz = int(items[1]) + if min_keep is not None and sz < min_keep: + n_short += 1 + elif max_keep is not None and sz > max_keep: + n_long += 1 + else: + names.append(items[0]) + inds.append(ind) + sizes.append(sz) + tot = ind + 1 + logger.info( + ( + f"max_keep={max_keep}, min_keep={min_keep}, " + f"loaded {len(names)}, skipped {n_short} short and {n_long} long, " + f"longest-loaded={max(sizes)}, shortest-loaded={min(sizes)}" + ) + ) + return root, names, inds, tot, sizes + + +def load_label(label_path, inds, tot): + with open(label_path) as f: + labels = [line.rstrip() for line in f] + assert ( + len(labels) == tot + ), f"number of labels does not match ({len(labels)} != {tot})" + labels = [labels[i] for i in inds] + return labels + + +def load_label_offset(label_path, inds, tot): + with open(label_path) as f: + code_lengths = [len(line.encode("utf-8")) for line in f] + assert ( + len(code_lengths) == tot + ), f"number of labels does not match ({len(code_lengths)} != {tot})" + offsets = list(itertools.accumulate([0] + code_lengths)) + offsets = [(offsets[i], offsets[i + 1]) for i in inds] + return offsets + + +def verify_label_lengths( + audio_sizes, + audio_rate, + label_path, + label_rate, + inds, + tot, + tol=0.1, # tolerance in seconds +): + if label_rate < 0: + logger.info(f"{label_path} is sequence label. skipped") + return + + with open(label_path) as f: + lengths = [len(line.rstrip().split()) for line in f] + assert len(lengths) == tot + lengths = [lengths[i] for i in inds] + num_invalid = 0 + for i, ind in enumerate(inds): + dur_from_audio = audio_sizes[i] / audio_rate + dur_from_label = lengths[i] / label_rate + if abs(dur_from_audio - dur_from_label) > tol: + logger.warning( + ( + f"audio and label duration differ too much " + f"(|{dur_from_audio} - {dur_from_label}| > {tol}) " + f"in line {ind+1} of {label_path}. Check if `label_rate` " + f"is correctly set (currently {label_rate}). " + f"num. of samples = {audio_sizes[i]}; " + f"label length = {lengths[i]}" + ) + ) + num_invalid += 1 + if num_invalid > 0: + logger.warning( + f"total {num_invalid} (audio, label) pairs with mismatched lengths" + ) + + +class HubertDataset(FairseqDataset): + def __init__( + self, + manifest_path: str, + sample_rate: float, + label_paths: List[str], + label_rates: Union[List[float], float], # -1 for sequence labels + pad_list: List[str], + eos_list: List[str], + label_processors: Optional[List[Any]] = None, + max_keep_sample_size: Optional[int] = None, + min_keep_sample_size: Optional[int] = None, + max_sample_size: Optional[int] = None, + shuffle: bool = True, + pad_audio: bool = False, + normalize: bool = False, + store_labels: bool = True, + random_crop: bool = False, + single_target: bool = False, + ): + self.audio_root, self.audio_names, inds, tot, self.sizes = load_audio( + manifest_path, max_keep_sample_size, min_keep_sample_size + ) + self.sample_rate = sample_rate + self.shuffle = shuffle + self.random_crop = random_crop + + self.num_labels = len(label_paths) + self.pad_list = pad_list + self.eos_list = eos_list + self.label_processors = label_processors + self.single_target = single_target + self.label_rates = ( + [label_rates for _ in range(len(label_paths))] + if isinstance(label_rates, int) + else label_rates + ) + self.store_labels = store_labels + if store_labels: + self.label_list = [load_label(p, inds, tot) for p in label_paths] + else: + self.label_paths = label_paths + self.label_offsets_list = [ + load_label_offset(p, inds, tot) for p in label_paths + ] + assert ( + label_processors is None + or len(label_processors) == self.num_labels + ) + for label_path, label_rate in zip(label_paths, self.label_rates): + verify_label_lengths( + self.sizes, sample_rate, label_path, label_rate, inds, tot + ) + + self.max_sample_size = ( + max_sample_size if max_sample_size is not None else sys.maxsize + ) + self.pad_audio = pad_audio + self.normalize = normalize + logger.info( + f"pad_audio={pad_audio}, random_crop={random_crop}, " + f"normalize={normalize}, max_sample_size={self.max_sample_size}" + ) + + def get_audio(self, index): + import soundfile as sf + + wav_path = os.path.join(self.audio_root, self.audio_names[index]) + wav, cur_sample_rate = sf.read(wav_path) + wav = torch.from_numpy(wav).float() + wav = self.postprocess(wav, cur_sample_rate) + return wav + + def get_label(self, index, label_idx): + if self.store_labels: + label = self.label_list[label_idx][index] + else: + with open(self.label_paths[label_idx]) as f: + offset_s, offset_e = self.label_offsets_list[label_idx][index] + f.seek(offset_s) + label = f.read(offset_e - offset_s) + + if self.label_processors is not None: + label = self.label_processors[label_idx](label) + return label + + def get_labels(self, index): + return [self.get_label(index, i) for i in range(self.num_labels)] + + def __getitem__(self, index): + wav = self.get_audio(index) + labels = self.get_labels(index) + return {"id": index, "source": wav, "label_list": labels} + + def __len__(self): + return len(self.sizes) + + def crop_to_max_size(self, wav, target_size): + size = len(wav) + diff = size - target_size + if diff <= 0: + return wav, 0 + + start, end = 0, target_size + if self.random_crop: + start = np.random.randint(0, diff + 1) + end = size - diff + start + return wav[start:end], start + + def collater(self, samples): + # target = max(sizes) -> random_crop not used + # target = max_sample_size -> random_crop used for long + samples = [s for s in samples if s["source"] is not None] + if len(samples) == 0: + return {} + + audios = [s["source"] for s in samples] + audio_sizes = [len(s) for s in audios] + if self.pad_audio: + audio_size = min(max(audio_sizes), self.max_sample_size) + else: + audio_size = min(min(audio_sizes), self.max_sample_size) + collated_audios, padding_mask, audio_starts = self.collater_audio( + audios, audio_size + ) + + targets_by_label = [ + [s["label_list"][i] for s in samples] + for i in range(self.num_labels) + ] + targets_list, lengths_list, ntokens_list = self.collater_label( + targets_by_label, audio_size, audio_starts + ) + + net_input = {"source": collated_audios, "padding_mask": padding_mask} + batch = { + "id": torch.LongTensor([s["id"] for s in samples]), + "net_input": net_input, + } + + if self.single_target: + batch["target_lengths"] = lengths_list[0] + batch["ntokens"] = ntokens_list[0] + batch["target"] = targets_list[0] + else: + batch["target_lengths_list"] = lengths_list + batch["ntokens_list"] = ntokens_list + batch["target_list"] = targets_list + return batch + + def collater_audio(self, audios, audio_size): + collated_audios = audios[0].new_zeros(len(audios), audio_size) + padding_mask = ( + torch.BoolTensor(collated_audios.shape).fill_(False) + # if self.pad_audio else None + ) + audio_starts = [0 for _ in audios] + for i, audio in enumerate(audios): + diff = len(audio) - audio_size + if diff == 0: + collated_audios[i] = audio + elif diff < 0: + assert self.pad_audio + collated_audios[i] = torch.cat( + [audio, audio.new_full((-diff,), 0.0)] + ) + padding_mask[i, diff:] = True + else: + collated_audios[i], audio_starts[i] = self.crop_to_max_size( + audio, audio_size + ) + return collated_audios, padding_mask, audio_starts + + def collater_frm_label( + self, targets, audio_size, audio_starts, label_rate, pad + ): + assert label_rate > 0 + s2f = label_rate / self.sample_rate + frm_starts = [int(round(s * s2f)) for s in audio_starts] + frm_size = int(round(audio_size * s2f)) + if not self.pad_audio: + rem_size = [len(t) - s for t, s in zip(targets, frm_starts)] + frm_size = min(frm_size, *rem_size) + targets = [t[s: s + frm_size] for t, s in zip(targets, frm_starts)] + logger.debug(f"audio_starts={audio_starts}") + logger.debug(f"frame_starts={frm_starts}") + logger.debug(f"frame_size={frm_size}") + + lengths = torch.LongTensor([len(t) for t in targets]) + ntokens = lengths.sum().item() + targets = data_utils.collate_tokens( + targets, pad_idx=pad, left_pad=False + ) + return targets, lengths, ntokens + + def collater_seq_label(self, targets, pad): + lengths = torch.LongTensor([len(t) for t in targets]) + ntokens = lengths.sum().item() + targets = data_utils.collate_tokens( + targets, pad_idx=pad, left_pad=False + ) + return targets, lengths, ntokens + + def collater_label(self, targets_by_label, audio_size, audio_starts): + targets_list, lengths_list, ntokens_list = [], [], [] + itr = zip(targets_by_label, self.label_rates, self.pad_list) + for targets, label_rate, pad in itr: + if label_rate == -1: + targets, lengths, ntokens = self.collater_seq_label( + targets, pad + ) + else: + targets, lengths, ntokens = self.collater_frm_label( + targets, audio_size, audio_starts, label_rate, pad + ) + targets_list.append(targets) + lengths_list.append(lengths) + ntokens_list.append(ntokens) + return targets_list, lengths_list, ntokens_list + + def num_tokens(self, index): + return self.size(index) + + def size(self, index): + if self.pad_audio: + return self.sizes[index] + return min(self.sizes[index], self.max_sample_size) + + def ordered_indices(self): + if self.shuffle: + order = [np.random.permutation(len(self))] + else: + order = [np.arange(len(self))] + + order.append(self.sizes) + return np.lexsort(order)[::-1] + + def postprocess(self, wav, cur_sample_rate): + if wav.dim() == 2: + wav = wav.mean(-1) + assert wav.dim() == 1, wav.dim() + + if cur_sample_rate != self.sample_rate: + raise Exception(f"sr {cur_sample_rate} != {self.sample_rate}") + + if self.normalize: + with torch.no_grad(): + wav = F.layer_norm(wav, wav.shape) + return wav diff --git a/fairseq/fairseq/data/audio/multi_modality_dataset.py b/fairseq/fairseq/data/audio/multi_modality_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..69d23d31c1eb66803fa5062b5991a7c34ab07dc7 --- /dev/null +++ b/fairseq/fairseq/data/audio/multi_modality_dataset.py @@ -0,0 +1,263 @@ +# Copyright (c) 2021-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import logging +import math +from typing import List, Optional, NamedTuple + +import numpy as np +import torch +from fairseq.data import ( + ConcatDataset, + LanguagePairDataset, + FileAudioDataset, + data_utils, +) +from fairseq.data import FairseqDataset + +logger = logging.getLogger(__name__) + + +class ModalityDatasetItem(NamedTuple): + datasetname: str + dataset: any + max_positions: List[int] + max_tokens: Optional[int] = None + max_sentences: Optional[int] = None + +# MultiModalityDataset: it concate multiple datasets with different modalities. +# Compared with ConcatDataset it can 1) sample data given the ratios for different datasets +# 2) it adds mode to indicate what type of the data samples come from. +# It will be used with GroupedEpochBatchIterator together to generate mini-batch with samples +# from the same type of dataset +# If only one dataset is used, it will perform like the original dataset with mode added +class MultiModalityDataset(ConcatDataset): + def __init__(self, datasets: List[ModalityDatasetItem]): + id_to_mode = [] + dsets = [] + max_tokens = [] + max_sentences = [] + max_positions = [] + for dset in datasets: + id_to_mode.append(dset.datasetname) + dsets.append(dset.dataset) + max_tokens.append(dset.max_tokens) + max_positions.append(dset.max_positions) + max_sentences.append(dset.max_sentences) + weights = [1.0 for s in dsets] + super().__init__(dsets, weights) + self.max_tokens = max_tokens + self.max_positions = max_positions + self.max_sentences = max_sentences + self.id_to_mode = id_to_mode + self.raw_sub_batch_samplers = [] + self._cur_epoch = 0 + + def set_epoch(self, epoch): + super().set_epoch(epoch) + self._cur_epoch = epoch + + def __getitem__(self, idx): + dataset_idx, sample_idx = self._get_dataset_and_sample_index(idx) + sample = self.datasets[dataset_idx][sample_idx] + return (dataset_idx, sample) + + def collater(self, samples): + if len(samples) == 0: + return {} + dataset_idx = samples[0][0] + # make sure all samples in samples are from same dataset + assert sum([0 if dataset_idx == s[0] else 1 for s in samples]) == 0 + samples = self.datasets[dataset_idx].collater([x[1] for x in samples]) + # add mode + samples["net_input"]["mode"] = self.id_to_mode[dataset_idx] + + return samples + + def size(self, index: int): + if len(self.datasets) == 1: + return self.datasets[0].size(index) + return super().size(index) + + @property + def sizes(self): + if len(self.datasets) == 1: + return self.datasets[0].sizes + super().sizes + + def ordered_indices(self): + """ + Returns indices sorted by length. So less padding is needed. + """ + if len(self.datasets) == 1: + return self.datasets[0].ordered_indices() + indices_group = [] + for d_idx, ds in enumerate(self.datasets): + sample_num = self.cumulative_sizes[d_idx] + if d_idx > 0: + sample_num = sample_num - self.cumulative_sizes[d_idx - 1] + assert sample_num == len(ds) + indices_group.append(ds.ordered_indices()) + return indices_group + + def get_raw_batch_samplers(self, required_batch_size_multiple, seed): + if len(self.raw_sub_batch_samplers) > 0: + logger.info(" raw_sub_batch_samplers exists. No action is taken") + return + with data_utils.numpy_seed(seed): + indices = self.ordered_indices() + for i, ds in enumerate(self.datasets): + indices[i] = ds.filter_indices_by_size( + indices[i], + self.max_positions[i], + )[0] + sub_batch_sampler = ds.batch_by_size( + indices[i], + max_tokens=self.max_tokens[i], + max_sentences=self.max_sentences[i], + required_batch_size_multiple=required_batch_size_multiple, + ) + self.raw_sub_batch_samplers.append(sub_batch_sampler) + + def get_batch_samplers(self, mult_ratios, required_batch_size_multiple, seed): + self.get_raw_batch_samplers(required_batch_size_multiple, seed) + batch_samplers = [] + for i, _ in enumerate(self.datasets): + if i > 0: + sub_batch_sampler = [ + [y + self.cumulative_sizes[i - 1] for y in x] + for x in self.raw_sub_batch_samplers[i] + ] + else: + sub_batch_sampler = list(self.raw_sub_batch_samplers[i]) + smp_r = mult_ratios[i] + if smp_r != 1: + is_increase = "increased" if smp_r > 1 else "decreased" + logger.info( + "number of batch for the dataset {} is {} from {} to {}".format( + self.id_to_mode[i], + is_increase, + len(sub_batch_sampler), + int(len(sub_batch_sampler) * smp_r), + ) + ) + mul_samplers = [] + for _ in range(math.floor(smp_r)): + mul_samplers = mul_samplers + sub_batch_sampler + if math.floor(smp_r) != smp_r: + with data_utils.numpy_seed(seed + self._cur_epoch): + np.random.shuffle(sub_batch_sampler) + smp_num = int( + (smp_r - math.floor(smp_r)) * len(sub_batch_sampler) + ) + mul_samplers = mul_samplers + sub_batch_sampler[:smp_num] + sub_batch_sampler = mul_samplers + else: + logger.info( + "dataset {} batch number is {} ".format( + self.id_to_mode[i], len(sub_batch_sampler) + ) + ) + batch_samplers.append(sub_batch_sampler) + + return batch_samplers + + +class LangPairMaskDataset(FairseqDataset): + def __init__( + self, + dataset: LanguagePairDataset, + src_eos: int, + src_bos: Optional[int] = None, + noise_id: Optional[int] = -1, + mask_ratio: Optional[float] = 0, + mask_type: Optional[str] = "random", + ): + self.dataset = dataset + self.src_eos = src_eos + self.src_bos = src_bos + self.noise_id = noise_id + self.mask_ratio = mask_ratio + self.mask_type = mask_type + assert mask_type in ("random", "tail") + + @property + def src_sizes(self): + return self.dataset.src_sizes + + @property + def tgt_sizes(self): + return self.dataset.tgt_sizes + + @property + def sizes(self): + # dataset.sizes can be a dynamically computed sizes: + return self.dataset.sizes + + def get_batch_shapes(self): + return self.dataset.buckets + + def num_tokens_vec(self, indices): + return self.dataset.num_tokens_vec(indices) + + def __len__(self): + return len(self.dataset) + + def num_tokens(self, index): + return self.dataset.num_tokens(index) + + def size(self, index): + return self.dataset.size(index) + + def ordered_indices(self): + return self.dataset.ordered_indices() + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.dataset.prefetch(indices) + + def mask_src_tokens(self, sample): + src_item = sample["source"] + mask = None + if self.mask_type == "random": + mask = torch.rand(len(src_item)).le(self.mask_ratio) + else: + mask = torch.ones(len(src_item)) + mask[: int(len(src_item) * (1 - self.mask_ratio))] = 0 + mask = mask.eq(1) + if src_item[0] == self.src_bos: + mask[0] = False + if src_item[-1] == self.src_eos: + mask[-1] = False + mask_src_item = src_item.masked_fill(mask, self.noise_id) + smp = {"id": sample["id"], "source": mask_src_item, "target": sample["target"]} + return smp + + def __getitem__(self, index): + sample = self.dataset[index] + if self.mask_ratio > 0: + sample = self.mask_src_tokens(sample) + return sample + + def collater(self, samples, pad_to_length=None): + return self.dataset.collater(samples, pad_to_length) + + +class FileAudioDatasetWrapper(FileAudioDataset): + def collater(self, samples): + samples = super().collater(samples) + if len(samples) == 0: + return {} + samples["net_input"]["src_tokens"] = samples["net_input"]["source"] + samples["net_input"]["prev_output_tokens"] = None + del samples["net_input"]["source"] + samples["net_input"]["src_lengths"] = None + samples["net_input"]["alignment"] = None + return samples diff --git a/fairseq/fairseq/data/audio/raw_audio_dataset.py b/fairseq/fairseq/data/audio/raw_audio_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..f4e965493cdf94a1f92fa7dab45cc68973c8cdb5 --- /dev/null +++ b/fairseq/fairseq/data/audio/raw_audio_dataset.py @@ -0,0 +1,392 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import logging +import os +import sys +import io + +import numpy as np +import torch +import torch.nn.functional as F + +from .. import FairseqDataset +from ..data_utils import compute_mask_indices, get_buckets, get_bucketed_sizes +from fairseq.data.audio.audio_utils import ( + parse_path, + read_from_stored_zip, + is_sf_audio_data, +) +from fairseq.data.text_compressor import TextCompressor, TextCompressionLevel + + +logger = logging.getLogger(__name__) + + +class RawAudioDataset(FairseqDataset): + def __init__( + self, + sample_rate, + max_sample_size=None, + min_sample_size=0, + shuffle=True, + pad=False, + normalize=False, + compute_mask_indices=False, + **mask_compute_kwargs, + ): + super().__init__() + + self.sample_rate = sample_rate + self.sizes = [] + self.max_sample_size = ( + max_sample_size if max_sample_size is not None else sys.maxsize + ) + self.min_sample_size = min_sample_size + self.pad = pad + self.shuffle = shuffle + self.normalize = normalize + self.compute_mask_indices = compute_mask_indices + if self.compute_mask_indices: + self.mask_compute_kwargs = mask_compute_kwargs + self._features_size_map = {} + self._C = mask_compute_kwargs["encoder_embed_dim"] + self._conv_feature_layers = eval(mask_compute_kwargs["conv_feature_layers"]) + + def __getitem__(self, index): + raise NotImplementedError() + + def __len__(self): + return len(self.sizes) + + def postprocess(self, feats, curr_sample_rate): + if feats.dim() == 2: + feats = feats.mean(-1) + + if curr_sample_rate != self.sample_rate: + raise Exception(f"sample rate: {curr_sample_rate}, need {self.sample_rate}") + + assert feats.dim() == 1, feats.dim() + + if self.normalize: + with torch.no_grad(): + feats = F.layer_norm(feats, feats.shape) + return feats + + def crop_to_max_size(self, wav, target_size): + size = len(wav) + diff = size - target_size + if diff <= 0: + return wav + + start = np.random.randint(0, diff + 1) + end = size - diff + start + return wav[start:end] + + def _compute_mask_indices(self, dims, padding_mask): + B, T, C = dims + mask_indices, mask_channel_indices = None, None + if self.mask_compute_kwargs["mask_prob"] > 0: + mask_indices = compute_mask_indices( + (B, T), + padding_mask, + self.mask_compute_kwargs["mask_prob"], + self.mask_compute_kwargs["mask_length"], + self.mask_compute_kwargs["mask_selection"], + self.mask_compute_kwargs["mask_other"], + min_masks=2, + no_overlap=self.mask_compute_kwargs["no_mask_overlap"], + min_space=self.mask_compute_kwargs["mask_min_space"], + ) + mask_indices = torch.from_numpy(mask_indices) + if self.mask_compute_kwargs["mask_channel_prob"] > 0: + mask_channel_indices = compute_mask_indices( + (B, C), + None, + self.mask_compute_kwargs["mask_channel_prob"], + self.mask_compute_kwargs["mask_channel_length"], + self.mask_compute_kwargs["mask_channel_selection"], + self.mask_compute_kwargs["mask_channel_other"], + no_overlap=self.mask_compute_kwargs["no_mask_channel_overlap"], + min_space=self.mask_compute_kwargs["mask_channel_min_space"], + ) + mask_channel_indices = ( + torch.from_numpy(mask_channel_indices).unsqueeze(1).expand(-1, T, -1) + ) + + return mask_indices, mask_channel_indices + + @staticmethod + def _bucket_tensor(tensor, num_pad, value): + return F.pad(tensor, (0, num_pad), value=value) + + def collater(self, samples): + samples = [s for s in samples if s["source"] is not None] + if len(samples) == 0: + return {} + + sources = [s["source"] for s in samples] + sizes = [len(s) for s in sources] + + if self.pad: + target_size = min(max(sizes), self.max_sample_size) + else: + target_size = min(min(sizes), self.max_sample_size) + + collated_sources = sources[0].new_zeros(len(sources), target_size) + padding_mask = ( + torch.BoolTensor(collated_sources.shape).fill_(False) if self.pad else None + ) + for i, (source, size) in enumerate(zip(sources, sizes)): + diff = size - target_size + if diff == 0: + collated_sources[i] = source + elif diff < 0: + assert self.pad + collated_sources[i] = torch.cat( + [source, source.new_full((-diff,), 0.0)] + ) + padding_mask[i, diff:] = True + else: + collated_sources[i] = self.crop_to_max_size(source, target_size) + + input = {"source": collated_sources} + out = {"id": torch.LongTensor([s["id"] for s in samples])} + if self.pad: + input["padding_mask"] = padding_mask + + if hasattr(self, "num_buckets") and self.num_buckets > 0: + assert self.pad, "Cannot bucket without padding first." + bucket = max(self._bucketed_sizes[s["id"]] for s in samples) + num_pad = bucket - collated_sources.size(-1) + if num_pad: + input["source"] = self._bucket_tensor(collated_sources, num_pad, 0) + input["padding_mask"] = self._bucket_tensor(padding_mask, num_pad, True) + + if self.compute_mask_indices: + B = input["source"].size(0) + T = self._get_mask_indices_dims(input["source"].size(-1)) + padding_mask_reshaped = input["padding_mask"].clone() + extra = padding_mask_reshaped.size(1) % T + if extra > 0: + padding_mask_reshaped = padding_mask_reshaped[:, :-extra] + padding_mask_reshaped = padding_mask_reshaped.view( + padding_mask_reshaped.size(0), T, -1 + ) + padding_mask_reshaped = padding_mask_reshaped.all(-1) + input["padding_count"] = padding_mask_reshaped.sum(-1).max().item() + mask_indices, mask_channel_indices = self._compute_mask_indices( + (B, T, self._C), + padding_mask_reshaped, + ) + input["mask_indices"] = mask_indices + input["mask_channel_indices"] = mask_channel_indices + out["sample_size"] = mask_indices.sum().item() + + out["net_input"] = input + return out + + def _get_mask_indices_dims(self, size, padding=0, dilation=1): + if size not in self._features_size_map: + L_in = size + for (_, kernel_size, stride) in self._conv_feature_layers: + L_out = L_in + 2 * padding - dilation * (kernel_size - 1) - 1 + L_out = 1 + L_out // stride + L_in = L_out + self._features_size_map[size] = L_out + return self._features_size_map[size] + + def num_tokens(self, index): + return self.size(index) + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + if self.pad: + return self.sizes[index] + return min(self.sizes[index], self.max_sample_size) + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + + if self.shuffle: + order = [np.random.permutation(len(self))] + order.append( + np.minimum( + np.array(self.sizes), + self.max_sample_size, + ) + ) + return np.lexsort(order)[::-1] + else: + return np.arange(len(self)) + + def set_bucket_info(self, num_buckets): + self.num_buckets = num_buckets + if self.num_buckets > 0: + self._collated_sizes = np.minimum( + np.array(self.sizes), + self.max_sample_size, + ) + self.buckets = get_buckets( + self._collated_sizes, + self.num_buckets, + ) + self._bucketed_sizes = get_bucketed_sizes( + self._collated_sizes, self.buckets + ) + logger.info( + f"{len(self.buckets)} bucket(s) for the audio dataset: " + f"{self.buckets}" + ) + + +class FileAudioDataset(RawAudioDataset): + def __init__( + self, + manifest_path, + sample_rate, + max_sample_size=None, + min_sample_size=0, + shuffle=True, + pad=False, + normalize=False, + num_buckets=0, + compute_mask_indices=False, + text_compression_level=TextCompressionLevel.none, + **mask_compute_kwargs, + ): + super().__init__( + sample_rate=sample_rate, + max_sample_size=max_sample_size, + min_sample_size=min_sample_size, + shuffle=shuffle, + pad=pad, + normalize=normalize, + compute_mask_indices=compute_mask_indices, + **mask_compute_kwargs, + ) + + self.text_compressor = TextCompressor(level=text_compression_level) + + skipped = 0 + self.fnames = [] + sizes = [] + self.skipped_indices = set() + + with open(manifest_path, "r") as f: + self.root_dir = f.readline().strip() + for i, line in enumerate(f): + items = line.strip().split("\t") + assert len(items) == 2, line + sz = int(items[1]) + if min_sample_size is not None and sz < min_sample_size: + skipped += 1 + self.skipped_indices.add(i) + continue + self.fnames.append(self.text_compressor.compress(items[0])) + sizes.append(sz) + logger.info(f"loaded {len(self.fnames)}, skipped {skipped} samples") + + self.sizes = np.array(sizes, dtype=np.int64) + + try: + import pyarrow + + self.fnames = pyarrow.array(self.fnames) + except: + logger.debug( + "Could not create a pyarrow array. Please install pyarrow for better performance" + ) + pass + + self.set_bucket_info(num_buckets) + + def __getitem__(self, index): + import soundfile as sf + fn = self.fnames[index] + fn = fn if isinstance(self.fnames, list) else fn.as_py() + fn = self.text_compressor.decompress(fn) + path_or_fp = os.path.join(self.root_dir, fn) + _path, slice_ptr = parse_path(path_or_fp) + if len(slice_ptr) == 2: + byte_data = read_from_stored_zip(_path, slice_ptr[0], slice_ptr[1]) + assert is_sf_audio_data(byte_data) + path_or_fp = io.BytesIO(byte_data) + + wav, curr_sample_rate = sf.read(path_or_fp, dtype="float32") + + feats = torch.from_numpy(wav).float() + feats = self.postprocess(feats, curr_sample_rate) + return {"id": index, "source": feats} + + +class BinarizedAudioDataset(RawAudioDataset): + def __init__( + self, + data_dir, + split, + sample_rate, + max_sample_size=None, + min_sample_size=0, + shuffle=True, + pad=False, + normalize=False, + num_buckets=0, + compute_mask_indices=False, + **mask_compute_kwargs, + ): + super().__init__( + sample_rate=sample_rate, + max_sample_size=max_sample_size, + min_sample_size=min_sample_size, + shuffle=shuffle, + pad=pad, + normalize=normalize, + compute_mask_indices=compute_mask_indices, + **mask_compute_kwargs, + ) + + from fairseq.data import data_utils, Dictionary + + self.fnames_dict = Dictionary.load(os.path.join(data_dir, "dict.txt")) + + root_path = os.path.join(data_dir, f"{split}.root") + if os.path.exists(root_path): + with open(root_path, "r") as f: + self.root_dir = next(f).strip() + else: + self.root_dir = None + + fnames_path = os.path.join(data_dir, split) + self.fnames = data_utils.load_indexed_dataset(fnames_path, self.fnames_dict) + lengths_path = os.path.join(data_dir, f"{split}.lengths") + + with open(lengths_path, "r") as f: + for line in f: + sz = int(line.rstrip()) + assert ( + sz >= min_sample_size + ), f"Min sample size is not supported for binarized dataset, but found a sample with size {sz}" + self.sizes.append(sz) + + self.sizes = np.array(self.sizes, dtype=np.int64) + + self.set_bucket_info(num_buckets) + logger.info(f"loaded {len(self.fnames)} samples") + + def __getitem__(self, index): + import soundfile as sf + + fname = self.fnames_dict.string(self.fnames[index], separator="") + if self.root_dir: + fname = os.path.join(self.root_dir, fname) + + wav, curr_sample_rate = sf.read(fname) + feats = torch.from_numpy(wav).float() + feats = self.postprocess(feats, curr_sample_rate) + return {"id": index, "source": feats} diff --git a/fairseq/fairseq/data/audio/speech_to_text_dataset.py b/fairseq/fairseq/data/audio/speech_to_text_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..164bf413e4fd41b895348c9ef0bb57421843eb17 --- /dev/null +++ b/fairseq/fairseq/data/audio/speech_to_text_dataset.py @@ -0,0 +1,525 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import csv +import io +import logging +import re +from collections import defaultdict +from pathlib import Path +from typing import Dict, List, Optional +from dataclasses import dataclass + +import numpy as np +import torch +from fairseq.data import ( + ConcatDataset, + Dictionary, + FairseqDataset, + ResamplingDataset, + data_utils as fairseq_data_utils, +) +from fairseq.data.audio.audio_utils import ( + get_fbank, + get_waveform, + read_from_stored_zip, + is_npy_data, + is_sf_audio_data, + parse_path, + FEATURE_OR_SF_AUDIO_FILE_EXTENSIONS, +) +from fairseq.data.audio.feature_transforms import CompositeAudioFeatureTransform +from fairseq.data.audio.data_cfg import S2TDataConfig + + +logger = logging.getLogger(__name__) + + +def get_features_from_npy_or_audio(path): + ext = Path(path).suffix + if ext not in FEATURE_OR_SF_AUDIO_FILE_EXTENSIONS: + raise ValueError(f'Unsupported file format for "{path}"') + return np.load(path) if ext == ".npy" else get_fbank(path) + + +def get_features_or_waveform_from_stored_zip( + path, byte_offset, byte_size, need_waveform=False, use_sample_rate=None, +): + assert path.endswith(".zip") + data = read_from_stored_zip(path, byte_offset, byte_size) + f = io.BytesIO(data) + if is_npy_data(data): + features_or_waveform = np.load(f) + elif is_sf_audio_data(data): + features_or_waveform = \ + get_waveform( + f, always_2d=False, output_sample_rate=use_sample_rate + )[0] if need_waveform else get_fbank(f) + else: + raise ValueError(f'Unknown file format for "{path}"') + return features_or_waveform + + +def get_features_or_waveform( + path: str, need_waveform=False, use_sample_rate=None +): + """Get speech features from .npy file or waveform from .wav/.flac file. + The file may be inside an uncompressed ZIP file and is accessed via byte + offset and length. + + Args: + path (str): File path in the format of "<.npy/.wav/.flac path>" or + "<zip path>:<byte offset>:<byte length>". + need_waveform (bool): return waveform instead of features. + use_sample_rate (int): change sample rate for the input wave file + + Returns: + features_or_waveform (numpy.ndarray): speech features or waveform. + """ + _path, slice_ptr = parse_path(path) + if len(slice_ptr) == 0: + if need_waveform: + return get_waveform( + _path, always_2d=False, output_sample_rate=use_sample_rate + )[0] + return get_features_from_npy_or_audio(_path) + elif len(slice_ptr) == 2: + features_or_waveform = get_features_or_waveform_from_stored_zip( + _path, slice_ptr[0], slice_ptr[1], need_waveform=need_waveform, + use_sample_rate=use_sample_rate + ) + else: + raise ValueError(f"Invalid path: {path}") + + return features_or_waveform + + +def _collate_frames( + frames: List[torch.Tensor], is_audio_input: bool = False +) -> torch.Tensor: + """ + Convert a list of 2D frames into a padded 3D tensor + Args: + frames (list): list of 2D frames of size L[i]*f_dim. Where L[i] is + length of i-th frame and f_dim is static dimension of features + Returns: + 3D tensor of size len(frames)*len_max*f_dim where len_max is max of L[i] + """ + max_len = max(frame.size(0) for frame in frames) + if is_audio_input: + out = frames[0].new_zeros((len(frames), max_len)) + else: + out = frames[0].new_zeros((len(frames), max_len, frames[0].size(1))) + for i, v in enumerate(frames): + out[i, : v.size(0)] = v + return out + + +@dataclass +class SpeechToTextDatasetItem(object): + index: int + source: torch.Tensor + target: Optional[torch.Tensor] = None + speaker_id: Optional[int] = None + + +class SpeechToTextDataset(FairseqDataset): + LANG_TAG_TEMPLATE = "<lang:{}>" + + def __init__( + self, + split: str, + is_train_split: bool, + cfg: S2TDataConfig, + audio_paths: List[str], + n_frames: List[int], + src_texts: Optional[List[str]] = None, + tgt_texts: Optional[List[str]] = None, + speakers: Optional[List[str]] = None, + src_langs: Optional[List[str]] = None, + tgt_langs: Optional[List[str]] = None, + ids: Optional[List[str]] = None, + tgt_dict: Optional[Dictionary] = None, + pre_tokenizer=None, + bpe_tokenizer=None, + n_frames_per_step=1, + speaker_to_id=None + ): + self.split, self.is_train_split = split, is_train_split + self.cfg = cfg + self.audio_paths, self.n_frames = audio_paths, n_frames + self.n_samples = len(audio_paths) + assert len(n_frames) == self.n_samples > 0 + assert src_texts is None or len(src_texts) == self.n_samples + assert tgt_texts is None or len(tgt_texts) == self.n_samples + assert speakers is None or len(speakers) == self.n_samples + assert src_langs is None or len(src_langs) == self.n_samples + assert tgt_langs is None or len(tgt_langs) == self.n_samples + assert ids is None or len(ids) == self.n_samples + assert (tgt_dict is None and tgt_texts is None) or ( + tgt_dict is not None and tgt_texts is not None + ) + self.src_texts, self.tgt_texts = src_texts, tgt_texts + self.src_langs, self.tgt_langs = src_langs, tgt_langs + self.speakers = speakers + self.tgt_dict = tgt_dict + self.check_tgt_lang_tag() + self.ids = ids + self.shuffle = cfg.shuffle if is_train_split else False + + self.feature_transforms = CompositeAudioFeatureTransform.from_config_dict( + self.cfg.get_feature_transforms(split, is_train_split) + ) + + self.pre_tokenizer = pre_tokenizer + self.bpe_tokenizer = bpe_tokenizer + self.n_frames_per_step = n_frames_per_step + self.speaker_to_id = speaker_to_id + + self.tgt_lens = self.get_tgt_lens_and_check_oov() + + logger.info(self.__repr__()) + + def get_tgt_lens_and_check_oov(self): + if self.tgt_texts is None: + return [0 for _ in range(self.n_samples)] + tgt_lens = [] + n_tokens, n_oov_tokens = 0, 0 + for i in range(self.n_samples): + tokenized = self.get_tokenized_tgt_text(i).split(" ") + oov_tokens = [ + t + for t in tokenized + if self.tgt_dict.index(t) == self.tgt_dict.unk_index + ] + n_tokens += len(tokenized) + n_oov_tokens += len(oov_tokens) + tgt_lens.append(len(tokenized)) + logger.info(f"'{self.split}' has {n_oov_tokens / n_tokens * 100:.2f}% OOV") + return tgt_lens + + def __repr__(self): + return ( + self.__class__.__name__ + + f'(split="{self.split}", n_samples={self.n_samples:_}, ' + f"prepend_tgt_lang_tag={self.cfg.prepend_tgt_lang_tag}, " + f"shuffle={self.shuffle}, transforms={self.feature_transforms}, " + f"n_frames_per_step={self.n_frames_per_step}" + ) + + @classmethod + def is_lang_tag(cls, token): + pattern = cls.LANG_TAG_TEMPLATE.replace("{}", "(.*)") + return re.match(pattern, token) + + def check_tgt_lang_tag(self): + if self.cfg.prepend_tgt_lang_tag: + assert self.tgt_langs is not None and self.tgt_dict is not None + tgt_lang_tags = [ + self.LANG_TAG_TEMPLATE.format(t) for t in set(self.tgt_langs) + ] + assert all(t in self.tgt_dict for t in tgt_lang_tags) + + @classmethod + def tokenize(cls, tokenizer, text: str): + return text if tokenizer is None else tokenizer.encode(text) + + def get_tokenized_tgt_text(self, index: int): + text = self.tokenize(self.pre_tokenizer, self.tgt_texts[index]) + text = self.tokenize(self.bpe_tokenizer, text) + return text + + def pack_frames(self, feature: torch.Tensor): + if self.n_frames_per_step == 1: + return feature + n_packed_frames = feature.shape[0] // self.n_frames_per_step + feature = feature[:self.n_frames_per_step * n_packed_frames] + return feature.reshape(n_packed_frames, -1) + + @classmethod + def get_lang_tag_idx(cls, lang: str, dictionary: Dictionary): + lang_tag_idx = dictionary.index(cls.LANG_TAG_TEMPLATE.format(lang)) + assert lang_tag_idx != dictionary.unk() + return lang_tag_idx + + def __getitem__(self, index: int) -> SpeechToTextDatasetItem: + source = get_features_or_waveform( + self.audio_paths[index], + need_waveform=self.cfg.use_audio_input, + use_sample_rate=self.cfg.use_sample_rate, + ) + if self.feature_transforms is not None: + assert not self.cfg.use_audio_input + source = self.feature_transforms(source) + source = torch.from_numpy(source).float() + source = self.pack_frames(source) + + target = None + if self.tgt_texts is not None: + tokenized = self.get_tokenized_tgt_text(index) + target = self.tgt_dict.encode_line( + tokenized, add_if_not_exist=False, append_eos=True + ).long() + if self.cfg.prepend_tgt_lang_tag: + lang_tag_idx = self.get_lang_tag_idx( + self.tgt_langs[index], self.tgt_dict + ) + target = torch.cat((torch.LongTensor([lang_tag_idx]), target), 0) + + speaker_id = None + if self.speaker_to_id is not None: + speaker_id = self.speaker_to_id[self.speakers[index]] + return SpeechToTextDatasetItem( + index=index, source=source, target=target, speaker_id=speaker_id + ) + + def __len__(self): + return self.n_samples + + def collater( + self, samples: List[SpeechToTextDatasetItem], return_order: bool = False + ) -> Dict: + if len(samples) == 0: + return {} + indices = torch.tensor([x.index for x in samples], dtype=torch.long) + frames = _collate_frames([x.source for x in samples], self.cfg.use_audio_input) + # sort samples by descending number of frames + n_frames = torch.tensor([x.source.size(0) for x in samples], dtype=torch.long) + n_frames, order = n_frames.sort(descending=True) + indices = indices.index_select(0, order) + frames = frames.index_select(0, order) + + target, target_lengths = None, None + prev_output_tokens = None + ntokens = None + if self.tgt_texts is not None: + target = fairseq_data_utils.collate_tokens( + [x.target for x in samples], + self.tgt_dict.pad(), + self.tgt_dict.eos(), + left_pad=False, + move_eos_to_beginning=False, + ) + target = target.index_select(0, order) + target_lengths = torch.tensor( + [x.target.size(0) for x in samples], dtype=torch.long + ).index_select(0, order) + prev_output_tokens = fairseq_data_utils.collate_tokens( + [x.target for x in samples], + self.tgt_dict.pad(), + self.tgt_dict.eos(), + left_pad=False, + move_eos_to_beginning=True, + ) + prev_output_tokens = prev_output_tokens.index_select(0, order) + ntokens = sum(x.target.size(0) for x in samples) + + speaker = None + if self.speaker_to_id is not None: + speaker = torch.tensor( + [s.speaker_id for s in samples], dtype=torch.long + ).index_select(0, order).view(-1, 1) + + net_input = { + "src_tokens": frames, + "src_lengths": n_frames, + "prev_output_tokens": prev_output_tokens, + } + out = { + "id": indices, + "net_input": net_input, + "speaker": speaker, + "target": target, + "target_lengths": target_lengths, + "ntokens": ntokens, + "nsentences": len(samples), + } + if return_order: + out["order"] = order + return out + + def num_tokens(self, index): + return self.n_frames[index] + + def size(self, index): + return self.n_frames[index], self.tgt_lens[index] + + @property + def sizes(self): + return np.array(self.n_frames) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return True + + def ordered_indices(self): + if self.shuffle: + order = [np.random.permutation(len(self))] + else: + order = [np.arange(len(self))] + # first by descending order of # of frames then by original/random order + order.append([-n for n in self.n_frames]) + return np.lexsort(order) + + def prefetch(self, indices): + raise False + + +class SpeechToTextDatasetCreator(object): + # mandatory columns + KEY_ID, KEY_AUDIO, KEY_N_FRAMES = "id", "audio", "n_frames" + KEY_TGT_TEXT = "tgt_text" + # optional columns + KEY_SPEAKER, KEY_SRC_TEXT = "speaker", "src_text" + KEY_SRC_LANG, KEY_TGT_LANG = "src_lang", "tgt_lang" + # default values + DEFAULT_SPEAKER = DEFAULT_SRC_TEXT = DEFAULT_LANG = "" + + @classmethod + def _from_list( + cls, + split_name: str, + is_train_split, + samples: List[Dict], + cfg: S2TDataConfig, + tgt_dict, + pre_tokenizer, + bpe_tokenizer, + n_frames_per_step, + speaker_to_id + ) -> SpeechToTextDataset: + audio_root = Path(cfg.audio_root) + ids = [s[cls.KEY_ID] for s in samples] + audio_paths = [(audio_root / s[cls.KEY_AUDIO]).as_posix() for s in samples] + n_frames = [int(s[cls.KEY_N_FRAMES]) for s in samples] + tgt_texts = [s[cls.KEY_TGT_TEXT] for s in samples] + src_texts = [s.get(cls.KEY_SRC_TEXT, cls.DEFAULT_SRC_TEXT) for s in samples] + speakers = [s.get(cls.KEY_SPEAKER, cls.DEFAULT_SPEAKER) for s in samples] + src_langs = [s.get(cls.KEY_SRC_LANG, cls.DEFAULT_LANG) for s in samples] + tgt_langs = [s.get(cls.KEY_TGT_LANG, cls.DEFAULT_LANG) for s in samples] + return SpeechToTextDataset( + split_name, + is_train_split, + cfg, + audio_paths, + n_frames, + src_texts=src_texts, + tgt_texts=tgt_texts, + speakers=speakers, + src_langs=src_langs, + tgt_langs=tgt_langs, + ids=ids, + tgt_dict=tgt_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + n_frames_per_step=n_frames_per_step, + speaker_to_id=speaker_to_id + ) + + @classmethod + def get_size_ratios( + cls, datasets: List[SpeechToTextDataset], alpha: float = 1.0 + ) -> List[float]: + """Size ratios for temperature-based sampling + (https://arxiv.org/abs/1907.05019)""" + + id_to_lp, lp_to_sz = {}, defaultdict(int) + for ds in datasets: + lang_pairs = {f"{s}->{t}" for s, t in zip(ds.src_langs, ds.tgt_langs)} + assert len(lang_pairs) == 1 + lang_pair = list(lang_pairs)[0] + id_to_lp[ds.split] = lang_pair + lp_to_sz[lang_pair] += sum(ds.n_frames) + + sz_sum = sum(v for v in lp_to_sz.values()) + lp_to_prob = {k: v / sz_sum for k, v in lp_to_sz.items()} + lp_to_tgt_prob = {k: v ** alpha for k, v in lp_to_prob.items()} + prob_sum = sum(v for v in lp_to_tgt_prob.values()) + lp_to_tgt_prob = {k: v / prob_sum for k, v in lp_to_tgt_prob.items()} + lp_to_sz_ratio = { + k: (lp_to_tgt_prob[k] * sz_sum) / v for k, v in lp_to_sz.items() + } + size_ratio = [lp_to_sz_ratio[id_to_lp[ds.split]] for ds in datasets] + + p_formatted = { + k: f"{lp_to_prob[k]:.3f}->{lp_to_tgt_prob[k]:.3f}" for k in lp_to_sz + } + logger.info(f"sampling probability balancing: {p_formatted}") + sr_formatted = {ds.split: f"{r:.3f}" for ds, r in zip(datasets, size_ratio)} + logger.info(f"balanced sampling size ratio: {sr_formatted}") + return size_ratio + + @classmethod + def _load_samples_from_tsv(cls, root: str, split: str): + tsv_path = Path(root) / f"{split}.tsv" + if not tsv_path.is_file(): + raise FileNotFoundError(f"Dataset not found: {tsv_path}") + with open(tsv_path) as f: + reader = csv.DictReader( + f, + delimiter="\t", + quotechar=None, + doublequote=False, + lineterminator="\n", + quoting=csv.QUOTE_NONE, + ) + samples = [dict(e) for e in reader] + if len(samples) == 0: + raise ValueError(f"Empty manifest: {tsv_path}") + return samples + + @classmethod + def _from_tsv( + cls, + root: str, + cfg: S2TDataConfig, + split: str, + tgt_dict, + is_train_split: bool, + pre_tokenizer, + bpe_tokenizer, + n_frames_per_step, + speaker_to_id + ) -> SpeechToTextDataset: + samples = cls._load_samples_from_tsv(root, split) + return cls._from_list( + split, is_train_split, samples, cfg, tgt_dict, pre_tokenizer, + bpe_tokenizer, n_frames_per_step, speaker_to_id + ) + + @classmethod + def from_tsv( + cls, + root: str, + cfg: S2TDataConfig, + splits: str, + tgt_dict, + pre_tokenizer, + bpe_tokenizer, + is_train_split: bool, + epoch: int, + seed: int, + n_frames_per_step: int = 1, + speaker_to_id=None + ) -> SpeechToTextDataset: + datasets = [ + cls._from_tsv( + root, cfg, split, tgt_dict, is_train_split, pre_tokenizer, + bpe_tokenizer, n_frames_per_step, speaker_to_id + ) + for split in splits.split(",") + ] + + if is_train_split and len(datasets) > 1 and cfg.sampling_alpha != 1.0: + # temperature-based sampling + size_ratios = cls.get_size_ratios(datasets, alpha=cfg.sampling_alpha) + datasets = [ + ResamplingDataset( + d, size_ratio=r, seed=seed, epoch=epoch, replace=(r >= 1.0) + ) + for r, d in zip(size_ratios, datasets) + ] + + return ConcatDataset(datasets) if len(datasets) > 1 else datasets[0] diff --git a/fairseq/fairseq/data/audio/speech_to_text_joint_dataset.py b/fairseq/fairseq/data/audio/speech_to_text_joint_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..885ee7e0a32a246ce249810a6622c808f1a15e09 --- /dev/null +++ b/fairseq/fairseq/data/audio/speech_to_text_joint_dataset.py @@ -0,0 +1,288 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from pathlib import Path +from typing import Dict, List, Optional, NamedTuple + +import torch +from fairseq.data import ( + ConcatDataset, + Dictionary, + ResamplingDataset, + data_utils as fairseq_data_utils, +) +from fairseq.data.audio.speech_to_text_dataset import ( + SpeechToTextDataset, + S2TDataConfig, + SpeechToTextDatasetCreator, +) + + +logger = logging.getLogger(__name__) + + +class S2TJointDataConfig(S2TDataConfig): + """Wrapper class for data config YAML""" + + @property + def src_vocab_filename(self): + """fairseq vocabulary file under data root""" + return self.config.get("src_vocab_filename", "src_dict.txt") + + @property + def src_pre_tokenizer(self) -> Dict: + """Pre-tokenizer to apply before subword tokenization. Returning + a dictionary with `tokenizer` providing the tokenizer name and + the other items providing the tokenizer-specific arguments. + Tokenizers are defined in `fairseq.data.encoders.*`""" + return self.config.get("src_pre_tokenizer", {"tokenizer": None}) + + @property + def src_bpe_tokenizer(self) -> Dict: + """Subword tokenizer to apply on source text after pre-tokenization. + Returning a dictionary with `bpe` providing the tokenizer name and + the other items providing the tokenizer-specific arguments. + Tokenizers are defined in `fairseq.data.encoders.*`""" + return self.config.get("src_bpe_tokenizer", {"bpe": None}) + + @property + def prepend_tgt_lang_tag_no_change(self) -> bool: + """Prepend target lang ID token as the prev_output_tokens BOS (e.g. for + to-many multilingual setting). No change needed during inference. + """ + return self.config.get("prepend_tgt_lang_tag_no_change", False) + + +class SpeechToTextJointDatasetItem(NamedTuple): + index: int + source: torch.Tensor + target: Optional[torch.Tensor] = None + src_txt_tokens: Optional[torch.Tensor] = None + tgt_lang_tag: Optional[int] = None + + +class SpeechToTextJointDataset(SpeechToTextDataset): + def __init__( + self, + split: str, + is_train_split: bool, + cfg: S2TJointDataConfig, + audio_paths: List[str], + n_frames: List[int], + src_texts: Optional[List[str]] = None, + tgt_texts: Optional[List[str]] = None, + speakers: Optional[List[str]] = None, + src_langs: Optional[List[str]] = None, + tgt_langs: Optional[List[str]] = None, + ids: Optional[List[str]] = None, + tgt_dict: Optional[Dictionary] = None, + src_dict: Optional[Dictionary] = None, + pre_tokenizer=None, + bpe_tokenizer=None, + src_pre_tokenizer=None, + src_bpe_tokenizer=None, + ): + super().__init__( + split, + is_train_split, + cfg, + audio_paths, + n_frames, + src_texts=src_texts, + tgt_texts=tgt_texts, + speakers=speakers, + src_langs=src_langs, + tgt_langs=tgt_langs, + ids=ids, + tgt_dict=tgt_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + ) + + self.src_dict = src_dict + self.src_pre_tokenizer = src_pre_tokenizer + self.src_bpe_tokenizer = src_bpe_tokenizer + + def get_tokenized_src_text(self, index: int): + text = self.tokenize(self.src_pre_tokenizer, self.src_texts[index]) + text = self.tokenize(self.src_bpe_tokenizer, text) + return text + + def __getitem__(self, index: int) -> SpeechToTextJointDatasetItem: + s2t_dataset_item = super().__getitem__(index) + src_tokens = None + if self.src_texts is not None and self.src_dict is not None: + src_tokens = self.get_tokenized_src_text(index) + src_tokens = self.src_dict.encode_line( + src_tokens, add_if_not_exist=False, append_eos=True + ).long() + tgt_lang_tag = None + if self.cfg.prepend_tgt_lang_tag_no_change: + # prepend_tgt_lang_tag_no_change: modify prev_output_tokens instead + tgt_lang_tag = self.get_lang_tag_idx(self.tgt_langs[index], self.tgt_dict) + + return SpeechToTextJointDatasetItem( + index=index, + source=s2t_dataset_item.source, + target=s2t_dataset_item.target, + src_txt_tokens=src_tokens, + tgt_lang_tag=tgt_lang_tag, + ) + + def __len__(self): + return self.n_samples + + def collater(self, samples: List[SpeechToTextJointDatasetItem]) -> Dict: + s2t_out = super().collater(samples, return_order=True) + if s2t_out == {}: + return s2t_out + net_input, order = s2t_out["net_input"], s2t_out["order"] + + if self.src_texts is not None and self.src_dict is not None: + src_txt_tokens = fairseq_data_utils.collate_tokens( + [x.src_txt_tokens for x in samples], + self.src_dict.pad(), + self.src_dict.eos(), + left_pad=False, + move_eos_to_beginning=False, + ) + src_txt_tokens = src_txt_tokens.index_select(0, order) + src_txt_lengths = torch.tensor( + [x.src_txt_tokens.size()[0] for x in samples], dtype=torch.long + ).index_select(0, order) + net_input["src_txt_tokens"] = src_txt_tokens + net_input["src_txt_lengths"] = src_txt_lengths + + if self.tgt_texts is not None and samples[0].tgt_lang_tag is not None: + for i in range(len(samples)): + net_input["prev_output_tokens"][i][0] = samples[order[i]].tgt_lang_tag + + out = { + "id": s2t_out["id"], + "net_input": net_input, + "target": s2t_out["target"], + "target_lengths": s2t_out["target_lengths"], + "ntokens": s2t_out["ntokens"], + "nsentences": len(samples), + } + return out + + +class SpeechToTextJointDatasetCreator(SpeechToTextDatasetCreator): + @classmethod + def _from_list( + cls, + split_name: str, + is_train_split, + samples: List[Dict], + cfg: S2TJointDataConfig, + tgt_dict, + src_dict, + pre_tokenizer, + bpe_tokenizer, + src_pre_tokenizer, + src_bpe_tokenizer, + ) -> SpeechToTextJointDataset: + audio_root = Path(cfg.audio_root) + ids = [s[cls.KEY_ID] for s in samples] + audio_paths = [(audio_root / s[cls.KEY_AUDIO]).as_posix() for s in samples] + n_frames = [int(s[cls.KEY_N_FRAMES]) for s in samples] + tgt_texts = [s[cls.KEY_TGT_TEXT] for s in samples] + src_texts = [s.get(cls.KEY_SRC_TEXT, cls.DEFAULT_SRC_TEXT) for s in samples] + speakers = [s.get(cls.KEY_SPEAKER, cls.DEFAULT_SPEAKER) for s in samples] + src_langs = [s.get(cls.KEY_SRC_LANG, cls.DEFAULT_LANG) for s in samples] + tgt_langs = [s.get(cls.KEY_TGT_LANG, cls.DEFAULT_LANG) for s in samples] + return SpeechToTextJointDataset( + split_name, + is_train_split, + cfg, + audio_paths, + n_frames, + src_texts=src_texts, + tgt_texts=tgt_texts, + speakers=speakers, + src_langs=src_langs, + tgt_langs=tgt_langs, + ids=ids, + tgt_dict=tgt_dict, + src_dict=src_dict, + pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, + src_pre_tokenizer=src_pre_tokenizer, + src_bpe_tokenizer=src_bpe_tokenizer, + ) + + @classmethod + def _from_tsv( + cls, + root: str, + cfg: S2TJointDataConfig, + split: str, + tgt_dict, + src_dict, + is_train_split: bool, + pre_tokenizer, + bpe_tokenizer, + src_pre_tokenizer, + src_bpe_tokenizer, + ) -> SpeechToTextJointDataset: + samples = cls._load_samples_from_tsv(root, split) + return cls._from_list( + split, + is_train_split, + samples, + cfg, + tgt_dict, + src_dict, + pre_tokenizer, + bpe_tokenizer, + src_pre_tokenizer, + src_bpe_tokenizer, + ) + + @classmethod + def from_tsv( + cls, + root: str, + cfg: S2TJointDataConfig, + splits: str, + tgt_dict, + src_dict, + pre_tokenizer, + bpe_tokenizer, + src_pre_tokenizer, + src_bpe_tokenizer, + is_train_split: bool, + epoch: int, + seed: int, + ) -> SpeechToTextJointDataset: + datasets = [ + cls._from_tsv( + root, + cfg, + split, + tgt_dict, + src_dict, + is_train_split, + pre_tokenizer, + bpe_tokenizer, + src_pre_tokenizer, + src_bpe_tokenizer, + ) + for split in splits.split(",") + ] + + if is_train_split and len(datasets) > 1 and cfg.sampling_alpha != 1.0: + # temperature-based sampling + size_ratios = cls.get_size_ratios(datasets, alpha=cfg.sampling_alpha) + datasets = [ + ResamplingDataset( + d, size_ratio=r, seed=seed, epoch=epoch, replace=(r >= 1.0) + ) + for r, d in zip(size_ratios, datasets) + ] + + return ConcatDataset(datasets) if len(datasets) > 1 else datasets[0] diff --git a/fairseq/fairseq/data/audio/text_to_speech_dataset.py b/fairseq/fairseq/data/audio/text_to_speech_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..abfcb2be4028889acd72c6f40d4c832e48cff344 --- /dev/null +++ b/fairseq/fairseq/data/audio/text_to_speech_dataset.py @@ -0,0 +1,215 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory.abs + +from pathlib import Path +from typing import List, Dict, Optional, Any +from dataclasses import dataclass + +import numpy as np +import torch + +from fairseq.data.audio.speech_to_text_dataset import ( + SpeechToTextDataset, SpeechToTextDatasetCreator, S2TDataConfig, + _collate_frames, get_features_or_waveform +) +from fairseq.data import Dictionary, data_utils as fairseq_data_utils + + +@dataclass +class TextToSpeechDatasetItem(object): + index: int + source: torch.Tensor + target: Optional[torch.Tensor] = None + speaker_id: Optional[int] = None + duration: Optional[torch.Tensor] = None + pitch: Optional[torch.Tensor] = None + energy: Optional[torch.Tensor] = None + + +class TextToSpeechDataset(SpeechToTextDataset): + def __init__( + self, + split: str, + is_train_split: bool, + cfg: S2TDataConfig, + audio_paths: List[str], + n_frames: List[int], + src_texts: Optional[List[str]] = None, + tgt_texts: Optional[List[str]] = None, + speakers: Optional[List[str]] = None, + src_langs: Optional[List[str]] = None, + tgt_langs: Optional[List[str]] = None, + ids: Optional[List[str]] = None, + tgt_dict: Optional[Dictionary] = None, + pre_tokenizer=None, + bpe_tokenizer=None, + n_frames_per_step=1, + speaker_to_id=None, + durations: Optional[List[List[int]]] = None, + pitches: Optional[List[str]] = None, + energies: Optional[List[str]] = None + ): + super(TextToSpeechDataset, self).__init__( + split, is_train_split, cfg, audio_paths, n_frames, + src_texts=src_texts, tgt_texts=tgt_texts, speakers=speakers, + src_langs=src_langs, tgt_langs=tgt_langs, ids=ids, + tgt_dict=tgt_dict, pre_tokenizer=pre_tokenizer, + bpe_tokenizer=bpe_tokenizer, n_frames_per_step=n_frames_per_step, + speaker_to_id=speaker_to_id + ) + self.durations = durations + self.pitches = pitches + self.energies = energies + + def __getitem__(self, index: int) -> TextToSpeechDatasetItem: + s2t_item = super().__getitem__(index) + + duration, pitch, energy = None, None, None + if self.durations is not None: + duration = torch.tensor( + self.durations[index] + [0], dtype=torch.long # pad 0 for EOS + ) + if self.pitches is not None: + pitch = get_features_or_waveform(self.pitches[index]) + pitch = torch.from_numpy( + np.concatenate((pitch, [0])) # pad 0 for EOS + ).float() + if self.energies is not None: + energy = get_features_or_waveform(self.energies[index]) + energy = torch.from_numpy( + np.concatenate((energy, [0])) # pad 0 for EOS + ).float() + return TextToSpeechDatasetItem( + index=index, source=s2t_item.source, target=s2t_item.target, + speaker_id=s2t_item.speaker_id, duration=duration, pitch=pitch, + energy=energy + ) + + def collater(self, samples: List[TextToSpeechDatasetItem]) -> Dict[str, Any]: + if len(samples) == 0: + return {} + + src_lengths, order = torch.tensor( + [s.target.shape[0] for s in samples], dtype=torch.long + ).sort(descending=True) + id_ = torch.tensor([s.index for s in samples], + dtype=torch.long).index_select(0, order) + feat = _collate_frames( + [s.source for s in samples], self.cfg.use_audio_input + ).index_select(0, order) + target_lengths = torch.tensor( + [s.source.shape[0] for s in samples], dtype=torch.long + ).index_select(0, order) + + src_tokens = fairseq_data_utils.collate_tokens( + [s.target for s in samples], + self.tgt_dict.pad(), + self.tgt_dict.eos(), + left_pad=False, + move_eos_to_beginning=False, + ).index_select(0, order) + + speaker = None + if self.speaker_to_id is not None: + speaker = torch.tensor( + [s.speaker_id for s in samples], dtype=torch.long + ).index_select(0, order).view(-1, 1) + + bsz, _, d = feat.size() + prev_output_tokens = torch.cat( + (feat.new_zeros((bsz, 1, d)), feat[:, :-1, :]), dim=1 + ) + + durations, pitches, energies = None, None, None + if self.durations is not None: + durations = fairseq_data_utils.collate_tokens( + [s.duration for s in samples], 0 + ).index_select(0, order) + assert src_tokens.shape[1] == durations.shape[1] + if self.pitches is not None: + pitches = _collate_frames([s.pitch for s in samples], True) + pitches = pitches.index_select(0, order) + assert src_tokens.shape[1] == pitches.shape[1] + if self.energies is not None: + energies = _collate_frames([s.energy for s in samples], True) + energies = energies.index_select(0, order) + assert src_tokens.shape[1] == energies.shape[1] + src_texts = [self.tgt_dict.string(samples[i].target) for i in order] + + return { + "id": id_, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + "prev_output_tokens": prev_output_tokens, + }, + "speaker": speaker, + "target": feat, + "durations": durations, + "pitches": pitches, + "energies": energies, + "target_lengths": target_lengths, + "ntokens": sum(target_lengths).item(), + "nsentences": len(samples), + "src_texts": src_texts, + } + + +class TextToSpeechDatasetCreator(SpeechToTextDatasetCreator): + KEY_DURATION = "duration" + KEY_PITCH = "pitch" + KEY_ENERGY = "energy" + + @classmethod + def _from_list( + cls, + split_name: str, + is_train_split, + samples: List[Dict], + cfg: S2TDataConfig, + tgt_dict, + pre_tokenizer, + bpe_tokenizer, + n_frames_per_step, + speaker_to_id + ) -> TextToSpeechDataset: + audio_root = Path(cfg.audio_root) + ids = [s[cls.KEY_ID] for s in samples] + audio_paths = [(audio_root / s[cls.KEY_AUDIO]).as_posix() for s in samples] + n_frames = [int(s[cls.KEY_N_FRAMES]) for s in samples] + tgt_texts = [s[cls.KEY_TGT_TEXT] for s in samples] + src_texts = [s.get(cls.KEY_SRC_TEXT, cls.DEFAULT_SRC_TEXT) for s in samples] + speakers = [s.get(cls.KEY_SPEAKER, cls.DEFAULT_SPEAKER) for s in samples] + src_langs = [s.get(cls.KEY_SRC_LANG, cls.DEFAULT_LANG) for s in samples] + tgt_langs = [s.get(cls.KEY_TGT_LANG, cls.DEFAULT_LANG) for s in samples] + + durations = [s.get(cls.KEY_DURATION, None) for s in samples] + durations = [ + None if dd is None else [int(d) for d in dd.split(" ")] + for dd in durations + ] + durations = None if any(dd is None for dd in durations) else durations + + pitches = [s.get(cls.KEY_PITCH, None) for s in samples] + pitches = [ + None if pp is None else (audio_root / pp).as_posix() + for pp in pitches + ] + pitches = None if any(pp is None for pp in pitches) else pitches + + energies = [s.get(cls.KEY_ENERGY, None) for s in samples] + energies = [ + None if ee is None else (audio_root / ee).as_posix() + for ee in energies] + energies = None if any(ee is None for ee in energies) else energies + + return TextToSpeechDataset( + split_name, is_train_split, cfg, audio_paths, n_frames, + src_texts, tgt_texts, speakers, src_langs, tgt_langs, ids, tgt_dict, + pre_tokenizer, bpe_tokenizer, n_frames_per_step, speaker_to_id, + durations, pitches, energies + ) diff --git a/fairseq/fairseq/data/backtranslation_dataset.py b/fairseq/fairseq/data/backtranslation_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..8f70c90df3d237077537993e125d366c95292f1a --- /dev/null +++ b/fairseq/fairseq/data/backtranslation_dataset.py @@ -0,0 +1,165 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq import utils + +from . import FairseqDataset + + +def backtranslate_samples(samples, collate_fn, generate_fn, cuda=True): + """Backtranslate a list of samples. + + Given an input (*samples*) of the form: + + [{'id': 1, 'source': 'hallo welt'}] + + this will return: + + [{'id': 1, 'source': 'hello world', 'target': 'hallo welt'}] + + Args: + samples (List[dict]): samples to backtranslate. Individual samples are + expected to have a 'source' key, which will become the 'target' + after backtranslation. + collate_fn (callable): function to collate samples into a mini-batch + generate_fn (callable): function to generate backtranslations + cuda (bool): use GPU for generation (default: ``True``) + + Returns: + List[dict]: an updated list of samples with a backtranslated source + """ + collated_samples = collate_fn(samples) + s = utils.move_to_cuda(collated_samples) if cuda else collated_samples + generated_sources = generate_fn(s) + + id_to_src = {sample["id"]: sample["source"] for sample in samples} + + # Go through each tgt sentence in batch and its corresponding best + # generated hypothesis and create a backtranslation data pair + # {id: id, source: generated backtranslation, target: original tgt} + return [ + { + "id": id.item(), + "target": id_to_src[id.item()], + "source": hypos[0]["tokens"].cpu(), + } + for id, hypos in zip(collated_samples["id"], generated_sources) + ] + + +class BacktranslationDataset(FairseqDataset): + """ + Sets up a backtranslation dataset which takes a tgt batch, generates + a src using a tgt-src backtranslation function (*backtranslation_fn*), + and returns the corresponding `{generated src, input tgt}` batch. + + Args: + tgt_dataset (~fairseq.data.FairseqDataset): the dataset to be + backtranslated. Only the source side of this dataset will be used. + After backtranslation, the source sentences in this dataset will be + returned as the targets. + src_dict (~fairseq.data.Dictionary): the dictionary of backtranslated + sentences. + tgt_dict (~fairseq.data.Dictionary, optional): the dictionary of + sentences to be backtranslated. + backtranslation_fn (callable, optional): function to call to generate + backtranslations. This is typically the `generate` method of a + :class:`~fairseq.sequence_generator.SequenceGenerator` object. + Pass in None when it is not available at initialization time, and + use set_backtranslation_fn function to set it when available. + output_collater (callable, optional): function to call on the + backtranslated samples to create the final batch + (default: ``tgt_dataset.collater``). + cuda: use GPU for generation + """ + + def __init__( + self, + tgt_dataset, + src_dict, + tgt_dict=None, + backtranslation_fn=None, + output_collater=None, + cuda=True, + **kwargs + ): + self.tgt_dataset = tgt_dataset + self.backtranslation_fn = backtranslation_fn + self.output_collater = ( + output_collater if output_collater is not None else tgt_dataset.collater + ) + self.cuda = cuda if torch.cuda.is_available() else False + self.src_dict = src_dict + self.tgt_dict = tgt_dict + + def __getitem__(self, index): + """ + Returns a single sample from *tgt_dataset*. Note that backtranslation is + not applied in this step; use :func:`collater` instead to backtranslate + a batch of samples. + """ + return self.tgt_dataset[index] + + def __len__(self): + return len(self.tgt_dataset) + + def set_backtranslation_fn(self, backtranslation_fn): + self.backtranslation_fn = backtranslation_fn + + def collater(self, samples): + """Merge and backtranslate a list of samples to form a mini-batch. + + Using the samples from *tgt_dataset*, load a collated target sample to + feed to the backtranslation model. Then take the backtranslation with + the best score as the source and the original input as the target. + + Note: we expect *tgt_dataset* to provide a function `collater()` that + will collate samples into the format expected by *backtranslation_fn*. + After backtranslation, we will feed the new list of samples (i.e., the + `(backtranslated source, original source)` pairs) to *output_collater* + and return the result. + + Args: + samples (List[dict]): samples to backtranslate and collate + + Returns: + dict: a mini-batch with keys coming from *output_collater* + """ + if samples[0].get("is_dummy", False): + return samples + samples = backtranslate_samples( + samples=samples, + collate_fn=self.tgt_dataset.collater, + generate_fn=(lambda net_input: self.backtranslation_fn(net_input)), + cuda=self.cuda, + ) + return self.output_collater(samples) + + def num_tokens(self, index): + """Just use the tgt dataset num_tokens""" + return self.tgt_dataset.num_tokens(index) + + def ordered_indices(self): + """Just use the tgt dataset ordered_indices""" + return self.tgt_dataset.ordered_indices() + + def size(self, index): + """Return an example's size as a float or tuple. This value is used + when filtering a dataset with ``--max-positions``. + + Note: we use *tgt_dataset* to approximate the length of the source + sentence, since we do not know the actual length until after + backtranslation. + """ + tgt_size = self.tgt_dataset.size(index)[0] + return (tgt_size, tgt_size) + + @property + def supports_prefetch(self): + return getattr(self.tgt_dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.tgt_dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/base_wrapper_dataset.py b/fairseq/fairseq/data/base_wrapper_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..134d398b47dc73c8807759188504aee205b3b34d --- /dev/null +++ b/fairseq/fairseq/data/base_wrapper_dataset.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from torch.utils.data.dataloader import default_collate + +from . import FairseqDataset + + +class BaseWrapperDataset(FairseqDataset): + def __init__(self, dataset): + super().__init__() + self.dataset = dataset + + def __getitem__(self, index): + return self.dataset[index] + + def __len__(self): + return len(self.dataset) + + def collater(self, samples): + if hasattr(self.dataset, "collater"): + return self.dataset.collater(samples) + else: + return default_collate(samples) + + @property + def sizes(self): + return self.dataset.sizes + + def num_tokens(self, index): + return self.dataset.num_tokens(index) + + def size(self, index): + return self.dataset.size(index) + + def ordered_indices(self): + return self.dataset.ordered_indices() + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def attr(self, attr: str, index: int): + return self.dataset.attr(attr, index) + + def prefetch(self, indices): + self.dataset.prefetch(indices) + + def get_batch_shapes(self): + return self.dataset.get_batch_shapes() + + def batch_by_size( + self, + indices, + max_tokens=None, + max_sentences=None, + required_batch_size_multiple=1, + ): + return self.dataset.batch_by_size( + indices, + max_tokens=max_tokens, + max_sentences=max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + ) + + def filter_indices_by_size(self, indices, max_sizes): + return self.dataset.filter_indices_by_size(indices, max_sizes) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return self.dataset.can_reuse_epoch_itr_across_epochs + + def set_epoch(self, epoch): + super().set_epoch(epoch) + if hasattr(self.dataset, "set_epoch"): + self.dataset.set_epoch(epoch) diff --git a/fairseq/fairseq/data/bucket_pad_length_dataset.py b/fairseq/fairseq/data/bucket_pad_length_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..0f9410014845873bb0344fca6478c231c88e9dea --- /dev/null +++ b/fairseq/fairseq/data/bucket_pad_length_dataset.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch.nn.functional as F +from fairseq.data import BaseWrapperDataset +from fairseq.data.data_utils import get_buckets, get_bucketed_sizes + + +class BucketPadLengthDataset(BaseWrapperDataset): + """ + Bucket and pad item lengths to the nearest bucket size. This can be used to + reduce the number of unique batch shapes, which is important on TPUs since + each new batch shape requires a recompilation. + + Args: + dataset (FairseqDatset): dataset to bucket + sizes (List[int]): all item sizes + num_buckets (int): number of buckets to create + pad_idx (int): padding symbol + left_pad (bool): if True, pad on the left; otherwise right pad + """ + + def __init__( + self, + dataset, + sizes, + num_buckets, + pad_idx, + left_pad, + tensor_key=None, + ): + super().__init__(dataset) + self.pad_idx = pad_idx + self.left_pad = left_pad + + assert num_buckets > 0 + self.buckets = get_buckets(sizes, num_buckets) + self._bucketed_sizes = get_bucketed_sizes(sizes, self.buckets) + self._tensor_key = tensor_key + + def _set_tensor(self, item, val): + if self._tensor_key is None: + return val + item[self._tensor_key] = val + return item + + def _get_tensor(self, item): + if self._tensor_key is None: + return item + return item[self._tensor_key] + + def _pad(self, tensor, bucket_size, dim=-1): + num_pad = bucket_size - tensor.size(dim) + return F.pad( + tensor, + (num_pad if self.left_pad else 0, 0 if self.left_pad else num_pad), + value=self.pad_idx, + ) + + def __getitem__(self, index): + item = self.dataset[index] + bucket_size = self._bucketed_sizes[index] + tensor = self._get_tensor(item) + padded = self._pad(tensor, bucket_size) + return self._set_tensor(item, padded) + + @property + def sizes(self): + return self._bucketed_sizes + + def num_tokens(self, index): + return self._bucketed_sizes[index] + + def size(self, index): + return self._bucketed_sizes[index] diff --git a/fairseq/fairseq/data/colorize_dataset.py b/fairseq/fairseq/data/colorize_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..6ef097bff1a013f4944b1cb55e1e7e4e2480b3a6 --- /dev/null +++ b/fairseq/fairseq/data/colorize_dataset.py @@ -0,0 +1,25 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import BaseWrapperDataset + + +class ColorizeDataset(BaseWrapperDataset): + """ Adds 'colors' property to net input that is obtained from the provided color getter for use by models """ + + def __init__(self, dataset, color_getter): + super().__init__(dataset) + self.color_getter = color_getter + + def collater(self, samples): + base_collate = super().collater(samples) + if len(base_collate) > 0: + base_collate["net_input"]["colors"] = torch.tensor( + list(self.color_getter(self.dataset, s["id"]) for s in samples), + dtype=torch.long, + ) + return base_collate diff --git a/fairseq/fairseq/data/concat_dataset.py b/fairseq/fairseq/data/concat_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..01a4078bb159fa44b2d1062b9a971fe7f1abd1c2 --- /dev/null +++ b/fairseq/fairseq/data/concat_dataset.py @@ -0,0 +1,124 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import bisect + +import numpy as np +from torch.utils.data.dataloader import default_collate + +from . import FairseqDataset + + +class ConcatDataset(FairseqDataset): + @staticmethod + def cumsum(sequence, sample_ratios): + r, s = [], 0 + for e, ratio in zip(sequence, sample_ratios): + curr_len = int(ratio * len(e)) + r.append(curr_len + s) + s += curr_len + return r + + def __init__(self, datasets, sample_ratios=1): + super(ConcatDataset, self).__init__() + assert len(datasets) > 0, "datasets should not be an empty iterable" + self.datasets = list(datasets) + if isinstance(sample_ratios, int): + sample_ratios = [sample_ratios] * len(self.datasets) + self.sample_ratios = sample_ratios + self.cumulative_sizes = self.cumsum(self.datasets, sample_ratios) + self.real_sizes = [len(d) for d in self.datasets] + + def __len__(self): + return self.cumulative_sizes[-1] + + def __getitem__(self, idx): + dataset_idx, sample_idx = self._get_dataset_and_sample_index(idx) + return self.datasets[dataset_idx][sample_idx] + + def _get_dataset_and_sample_index(self, idx: int): + dataset_idx = bisect.bisect_right(self.cumulative_sizes, idx) + if dataset_idx == 0: + sample_idx = idx + else: + sample_idx = idx - self.cumulative_sizes[dataset_idx - 1] + sample_idx = sample_idx % self.real_sizes[dataset_idx] + return dataset_idx, sample_idx + + def collater(self, samples, **extra_args): + # For now only supports datasets with same underlying collater implementations + if hasattr(self.datasets[0], "collater"): + return self.datasets[0].collater(samples, **extra_args) + else: + return default_collate(samples, **extra_args) + + def size(self, idx: int): + """ + Return an example's size as a float or tuple. + """ + dataset_idx, sample_idx = self._get_dataset_and_sample_index(idx) + return self.datasets[dataset_idx].size(sample_idx) + + def num_tokens(self, index: int): + return np.max(self.size(index)) + + def attr(self, attr: str, index: int): + dataset_idx = bisect.bisect_right(self.cumulative_sizes, index) + return getattr(self.datasets[dataset_idx], attr, None) + + @property + def sizes(self): + _dataset_sizes = [] + for ds, sr in zip(self.datasets, self.sample_ratios): + if isinstance(ds.sizes, np.ndarray): + _dataset_sizes.append(np.tile(ds.sizes, sr)) + else: + # Only support underlying dataset with single size array. + assert isinstance(ds.sizes, list) + _dataset_sizes.append(np.tile(ds.sizes[0], sr)) + return np.concatenate(_dataset_sizes) + + @property + def supports_prefetch(self): + return all(d.supports_prefetch for d in self.datasets) + + def ordered_indices(self): + """ + Returns indices sorted by length. So less padding is needed. + """ + if isinstance(self.sizes, np.ndarray) and len(self.sizes.shape) > 1: + # special handling for concatenating lang_pair_datasets + indices = np.arange(len(self)) + sizes = self.sizes + tgt_sizes = ( + sizes[:, 1] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else None + ) + src_sizes = ( + sizes[:, 0] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else sizes + ) + # sort by target length, then source length + if tgt_sizes is not None: + indices = indices[np.argsort(tgt_sizes[indices], kind="mergesort")] + return indices[np.argsort(src_sizes[indices], kind="mergesort")] + else: + return np.argsort(self.sizes) + + def prefetch(self, indices): + frm = 0 + for to, ds in zip(self.cumulative_sizes, self.datasets): + real_size = len(ds) + if getattr(ds, "supports_prefetch", False): + ds.prefetch([(i - frm) % real_size for i in indices if frm <= i < to]) + frm = to + + @property + def can_reuse_epoch_itr_across_epochs(self): + return all(d.can_reuse_epoch_itr_across_epochs for d in self.datasets) + + def set_epoch(self, epoch): + super().set_epoch(epoch) + for ds in self.datasets: + if hasattr(ds, "set_epoch"): + ds.set_epoch(epoch) diff --git a/fairseq/fairseq/data/concat_sentences_dataset.py b/fairseq/fairseq/data/concat_sentences_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..625a29370e90f9d1d7274024afb902ed83a22325 --- /dev/null +++ b/fairseq/fairseq/data/concat_sentences_dataset.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import FairseqDataset + + +class ConcatSentencesDataset(FairseqDataset): + def __init__(self, *datasets): + super().__init__() + self.datasets = datasets + assert all( + len(ds) == len(datasets[0]) for ds in datasets + ), "datasets must have the same length" + + def __getitem__(self, index): + return torch.cat([ds[index] for ds in self.datasets]) + + def __len__(self): + return len(self.datasets[0]) + + def collater(self, samples): + return self.datasets[0].collater(samples) + + @property + def sizes(self): + return sum(ds.sizes for ds in self.datasets) + + def num_tokens(self, index): + return sum(ds.num_tokens(index) for ds in self.datasets) + + def size(self, index): + return sum(ds.size(index) for ds in self.datasets) + + def ordered_indices(self): + return self.datasets[0].ordered_indices() + + @property + def supports_prefetch(self): + return any(getattr(ds, "supports_prefetch", False) for ds in self.datasets) + + def prefetch(self, indices): + for ds in self.datasets: + if getattr(ds, "supports_prefetch", False): + ds.prefetch(indices) + + def set_epoch(self, epoch): + super().set_epoch(epoch) + for ds in self.datasets: + if hasattr(ds, "set_epoch"): + ds.set_epoch(epoch) diff --git a/fairseq/fairseq/data/data_utils.py b/fairseq/fairseq/data/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b3de57681e0fb6b026003eff19f7745caf6799d3 --- /dev/null +++ b/fairseq/fairseq/data/data_utils.py @@ -0,0 +1,595 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +try: + from collections.abc import Iterable +except ImportError: + from collections import Iterable +import contextlib +import itertools +import logging +import re +import warnings +from typing import Optional, Tuple + +import numpy as np +import torch + +from fairseq.file_io import PathManager +from fairseq import utils +import os + +logger = logging.getLogger(__name__) + + +def infer_language_pair(path): + """Infer language pair from filename: <split>.<lang1>-<lang2>.(...).idx""" + src, dst = None, None + for filename in PathManager.ls(path): + parts = filename.split(".") + if len(parts) >= 3 and len(parts[1].split("-")) == 2: + return parts[1].split("-") + return src, dst + + +def collate_tokens( + values, + pad_idx, + eos_idx=None, + left_pad=False, + move_eos_to_beginning=False, + pad_to_length=None, + pad_to_multiple=1, + pad_to_bsz=None, +): + """Convert a list of 1d tensors into a padded 2d tensor.""" + size = max(v.size(0) for v in values) + size = size if pad_to_length is None else max(size, pad_to_length) + if pad_to_multiple != 1 and size % pad_to_multiple != 0: + size = int(((size - 0.1) // pad_to_multiple + 1) * pad_to_multiple) + + batch_size = len(values) if pad_to_bsz is None else max(len(values), pad_to_bsz) + res = values[0].new(batch_size, size).fill_(pad_idx) + + def copy_tensor(src, dst): + assert dst.numel() == src.numel() + if move_eos_to_beginning: + if eos_idx is None: + # if no eos_idx is specified, then use the last token in src + dst[0] = src[-1] + else: + dst[0] = eos_idx + dst[1:] = src[:-1] + else: + dst.copy_(src) + + for i, v in enumerate(values): + copy_tensor(v, res[i][size - len(v) :] if left_pad else res[i][: len(v)]) + return res + +def load_indexed_dataset( + path, dictionary=None, dataset_impl=None, combine=False, default="cached" +): + """A helper function for loading indexed datasets. + + Args: + path (str): path to indexed dataset (e.g., 'data-bin/train') + dictionary (~fairseq.data.Dictionary): data dictionary + dataset_impl (str, optional): which dataset implementation to use. If + not provided, it will be inferred automatically. For legacy indexed + data we use the 'cached' implementation by default. + combine (bool, optional): automatically load and combine multiple + datasets. For example, if *path* is 'data-bin/train', then we will + combine 'data-bin/train', 'data-bin/train1', ... and return a + single ConcatDataset instance. + """ + import fairseq.data.indexed_dataset as indexed_dataset + from fairseq.data.concat_dataset import ConcatDataset + + datasets = [] + for k in itertools.count(): + path_k = path + (str(k) if k > 0 else "") + try: + path_k = indexed_dataset.get_indexed_dataset_to_local(path_k) + except Exception as e: + if "StorageException: [404] Path not found" in str(e): + logger.warning(f"path_k: {e} not found") + else: + raise e + + dataset_impl_k = dataset_impl + if dataset_impl_k is None: + dataset_impl_k = indexed_dataset.infer_dataset_impl(path_k) + dataset = indexed_dataset.make_dataset( + path_k, + impl=dataset_impl_k or default, + fix_lua_indexing=True, + dictionary=dictionary, + ) + if dataset is None: + break + logger.info("loaded {:,} examples from: {}".format(len(dataset), path_k)) + datasets.append(dataset) + if not combine: + break + if len(datasets) == 0: + return None + elif len(datasets) == 1: + return datasets[0] + else: + return ConcatDataset(datasets) + + +@contextlib.contextmanager +def numpy_seed(seed, *addl_seeds): + """Context manager which seeds the NumPy PRNG with the specified seed and + restores the state afterward""" + if seed is None: + yield + return + if len(addl_seeds) > 0: + seed = int(hash((seed, *addl_seeds)) % 1e6) + state = np.random.get_state() + np.random.seed(seed) + try: + yield + finally: + np.random.set_state(state) + + +def collect_filtered(function, iterable, filtered): + """ + Similar to :func:`filter` but collects filtered elements in ``filtered``. + + Args: + function (callable): function that returns ``False`` for elements that + should be filtered + iterable (iterable): iterable to filter + filtered (list): list to store filtered elements + """ + for el in iterable: + if function(el): + yield el + else: + filtered.append(el) + + +def _filter_by_size_dynamic(indices, size_fn, max_positions, raise_exception=False): + def compare_leq(a, b): + return a <= b if not isinstance(a, tuple) else max(a) <= b + + def check_size(idx): + if isinstance(max_positions, float) or isinstance(max_positions, int): + return size_fn(idx) <= max_positions + elif isinstance(max_positions, dict): + idx_size = size_fn(idx) + assert isinstance(idx_size, dict) + intersect_keys = set(max_positions.keys()) & set(idx_size.keys()) + return all( + all( + a is None or b is None or a <= b + for a, b in zip(idx_size[key], max_positions[key]) + ) + for key in intersect_keys + ) + else: + # For MultiCorpusSampledDataset, will generalize it later + if not isinstance(size_fn(idx), Iterable): + return all(size_fn(idx) <= b for b in max_positions) + return all( + a is None or b is None or a <= b + for a, b in zip(size_fn(idx), max_positions) + ) + + ignored = [] + itr = collect_filtered(check_size, indices, ignored) + indices = np.fromiter(itr, dtype=np.int64, count=-1) + return indices, ignored + + +def filter_by_size(indices, dataset, max_positions, raise_exception=False): + """ + [deprecated] Filter indices based on their size. + Use `FairseqDataset::filter_indices_by_size` instead. + + Args: + indices (List[int]): ordered list of dataset indices + dataset (FairseqDataset): fairseq dataset instance + max_positions (tuple): filter elements larger than this size. + Comparisons are done component-wise. + raise_exception (bool, optional): if ``True``, raise an exception if + any elements are filtered (default: False). + """ + warnings.warn( + "data_utils.filter_by_size is deprecated. " + "Use `FairseqDataset::filter_indices_by_size` instead.", + stacklevel=2, + ) + if isinstance(max_positions, float) or isinstance(max_positions, int): + if hasattr(dataset, "sizes") and isinstance(dataset.sizes, np.ndarray): + ignored = indices[dataset.sizes[indices] > max_positions].tolist() + indices = indices[dataset.sizes[indices] <= max_positions] + elif ( + hasattr(dataset, "sizes") + and isinstance(dataset.sizes, list) + and len(dataset.sizes) == 1 + ): + ignored = indices[dataset.sizes[0][indices] > max_positions].tolist() + indices = indices[dataset.sizes[0][indices] <= max_positions] + else: + indices, ignored = _filter_by_size_dynamic( + indices, dataset.size, max_positions + ) + else: + indices, ignored = _filter_by_size_dynamic(indices, dataset.size, max_positions) + + if len(ignored) > 0 and raise_exception: + raise Exception( + ( + "Size of sample #{} is invalid (={}) since max_positions={}, " + "skip this example with --skip-invalid-size-inputs-valid-test" + ).format(ignored[0], dataset.size(ignored[0]), max_positions) + ) + if len(ignored) > 0: + logger.warning( + ( + "{} samples have invalid sizes and will be skipped, " + "max_positions={}, first few sample ids={}" + ).format(len(ignored), max_positions, ignored[:10]) + ) + return indices + + +def filter_paired_dataset_indices_by_size(src_sizes, tgt_sizes, indices, max_sizes): + """Filter a list of sample indices. Remove those that are longer + than specified in max_sizes. + + Args: + indices (np.array): original array of sample indices + max_sizes (int or list[int] or tuple[int]): max sample size, + can be defined separately for src and tgt (then list or tuple) + + Returns: + np.array: filtered sample array + list: list of removed indices + """ + if max_sizes is None: + return indices, [] + if type(max_sizes) in (int, float): + max_src_size, max_tgt_size = max_sizes, max_sizes + else: + max_src_size, max_tgt_size = max_sizes + if tgt_sizes is None: + ignored = indices[src_sizes[indices] > max_src_size] + else: + ignored = indices[ + (src_sizes[indices] > max_src_size) | (tgt_sizes[indices] > max_tgt_size) + ] + if len(ignored) > 0: + if tgt_sizes is None: + indices = indices[src_sizes[indices] <= max_src_size] + else: + indices = indices[ + (src_sizes[indices] <= max_src_size) + & (tgt_sizes[indices] <= max_tgt_size) + ] + return indices, ignored.tolist() + + +def batch_by_size( + indices, + num_tokens_fn, + num_tokens_vec=None, + max_tokens=None, + max_sentences=None, + required_batch_size_multiple=1, + fixed_shapes=None, +): + """ + Yield mini-batches of indices bucketed by size. Batches may contain + sequences of different lengths. + + Args: + indices (List[int]): ordered list of dataset indices + num_tokens_fn (callable): function that returns the number of tokens at + a given index + num_tokens_vec (List[int], optional): precomputed vector of the number + of tokens for each index in indices (to enable faster batch generation) + max_tokens (int, optional): max number of tokens in each batch + (default: None). + max_sentences (int, optional): max number of sentences in each + batch (default: None). + required_batch_size_multiple (int, optional): require batch size to + be less than N or a multiple of N (default: 1). + fixed_shapes (List[Tuple[int, int]], optional): if given, batches will + only be created with the given shapes. *max_sentences* and + *required_batch_size_multiple* will be ignored (default: None). + """ + try: + from fairseq.data.data_utils_fast import ( + batch_by_size_fn, + batch_by_size_vec, + batch_fixed_shapes_fast, + ) + except ImportError: + raise ImportError( + "Please build Cython components with: " + "`python setup.py build_ext --inplace`" + ) + except ValueError: + raise ValueError( + "Please build (or rebuild) Cython components with `python setup.py build_ext --inplace`." + ) + + # added int() to avoid TypeError: an integer is required + max_tokens = ( + int(max_tokens) if max_tokens is not None else -1 + ) + max_sentences = max_sentences if max_sentences is not None else -1 + bsz_mult = required_batch_size_multiple + + if not isinstance(indices, np.ndarray): + indices = np.fromiter(indices, dtype=np.int64, count=-1) + + if num_tokens_vec is not None and not isinstance(num_tokens_vec, np.ndarray): + num_tokens_vec = np.fromiter(num_tokens_vec, dtype=np.int64, count=-1) + + if fixed_shapes is None: + if num_tokens_vec is None: + return batch_by_size_fn( + indices, + num_tokens_fn, + max_tokens, + max_sentences, + bsz_mult, + ) + else: + return batch_by_size_vec( + indices, + num_tokens_vec, + max_tokens, + max_sentences, + bsz_mult, + ) + + else: + fixed_shapes = np.array(fixed_shapes, dtype=np.int64) + sort_order = np.lexsort( + [ + fixed_shapes[:, 1].argsort(), # length + fixed_shapes[:, 0].argsort(), # bsz + ] + ) + fixed_shapes_sorted = fixed_shapes[sort_order] + return batch_fixed_shapes_fast(indices, num_tokens_fn, fixed_shapes_sorted) + + +def post_process(sentence: str, symbol: str): + if symbol == "sentencepiece": + sentence = sentence.replace(" ", "").replace("\u2581", " ").strip() + elif symbol == "wordpiece": + sentence = sentence.replace(" ", "").replace("_", " ").strip() + elif symbol == "letter": + sentence = sentence.replace(" ", "").replace("|", " ").strip() + elif symbol == "silence": + import re + sentence = sentence.replace("<SIL>", "") + sentence = re.sub(' +', ' ', sentence).strip() + elif symbol == "_EOW": + sentence = sentence.replace(" ", "").replace("_EOW", " ").strip() + elif symbol in {"subword_nmt", "@@ ", "@@"}: + if symbol == "subword_nmt": + symbol = "@@ " + sentence = (sentence + " ").replace(symbol, "").rstrip() + elif symbol == "none": + pass + elif symbol is not None: + raise NotImplementedError(f"Unknown post_process option: {symbol}") + return sentence + + +def compute_mask_indices( + shape: Tuple[int, int], + padding_mask: Optional[torch.Tensor], + mask_prob: float, + mask_length: int, + mask_type: str = "static", + mask_other: float = 0.0, + min_masks: int = 0, + no_overlap: bool = False, + min_space: int = 0, +) -> np.ndarray: + """ + Computes random mask spans for a given shape + + Args: + shape: the the shape for which to compute masks. + should be of size 2 where first element is batch size and 2nd is timesteps + padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements + mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by + number of timesteps divided by length of mask span to mask approximately this percentage of all elements. + however due to overlaps, the actual number will be smaller (unless no_overlap is True) + mask_type: how to compute mask lengths + static = fixed size + uniform = sample from uniform distribution [mask_other, mask_length*2] + normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element + poisson = sample from possion distribution with lambda = mask length + min_masks: minimum number of masked spans + no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping + min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans + """ + + bsz, all_sz = shape + mask = np.full((bsz, all_sz), False) + + all_num_mask = int( + # add a random number for probabilistic rounding + mask_prob * all_sz / float(mask_length) + + np.random.rand() + ) + + all_num_mask = max(min_masks, all_num_mask) + + mask_idcs = [] + for i in range(bsz): + if padding_mask is not None: + sz = all_sz - padding_mask[i].long().sum().item() + num_mask = int( + # add a random number for probabilistic rounding + mask_prob * sz / float(mask_length) + + np.random.rand() + ) + num_mask = max(min_masks, num_mask) + else: + sz = all_sz + num_mask = all_num_mask + + if mask_type == "static": + lengths = np.full(num_mask, mask_length) + elif mask_type == "uniform": + lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask) + elif mask_type == "normal": + lengths = np.random.normal(mask_length, mask_other, size=num_mask) + lengths = [max(1, int(round(x))) for x in lengths] + elif mask_type == "poisson": + lengths = np.random.poisson(mask_length, size=num_mask) + lengths = [int(round(x)) for x in lengths] + else: + raise Exception("unknown mask selection " + mask_type) + + if sum(lengths) == 0: + lengths[0] = min(mask_length, sz - 1) + + if no_overlap: + mask_idc = [] + + def arrange(s, e, length, keep_length): + span_start = np.random.randint(s, e - length) + mask_idc.extend(span_start + i for i in range(length)) + + new_parts = [] + if span_start - s - min_space >= keep_length: + new_parts.append((s, span_start - min_space + 1)) + if e - span_start - keep_length - min_space > keep_length: + new_parts.append((span_start + length + min_space, e)) + return new_parts + + parts = [(0, sz)] + min_length = min(lengths) + for length in sorted(lengths, reverse=True): + lens = np.fromiter( + (e - s if e - s >= length + min_space else 0 for s, e in parts), + np.int, + ) + l_sum = np.sum(lens) + if l_sum == 0: + break + probs = lens / np.sum(lens) + c = np.random.choice(len(parts), p=probs) + s, e = parts.pop(c) + parts.extend(arrange(s, e, length, min_length)) + mask_idc = np.asarray(mask_idc) + else: + min_len = min(lengths) + if sz - min_len <= num_mask: + min_len = sz - num_mask - 1 + + mask_idc = np.random.choice(sz - min_len, num_mask, replace=False) + + mask_idc = np.asarray( + [ + mask_idc[j] + offset + for j in range(len(mask_idc)) + for offset in range(lengths[j]) + ] + ) + + mask_idcs.append(np.unique(mask_idc[mask_idc < sz])) + + min_len = min([len(m) for m in mask_idcs]) + for i, mask_idc in enumerate(mask_idcs): + if len(mask_idc) > min_len: + mask_idc = np.random.choice(mask_idc, min_len, replace=False) + mask[i, mask_idc] = True + + return mask + + +def get_mem_usage(): + try: + import psutil + + mb = 1024 * 1024 + return f"used={psutil.virtual_memory().used / mb}Mb; avail={psutil.virtual_memory().available / mb}Mb" + except ImportError: + return "N/A" + + +# lens: torch.LongTensor +# returns: torch.BoolTensor +def lengths_to_padding_mask(lens): + bsz, max_lens = lens.size(0), torch.max(lens).item() + mask = torch.arange(max_lens).to(lens.device).view(1, max_lens) + mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens) + return mask + + +# lens: torch.LongTensor +# returns: torch.BoolTensor +def lengths_to_mask(lens): + return ~lengths_to_padding_mask(lens) + + +def get_buckets(sizes, num_buckets): + buckets = np.unique( + np.percentile( + sizes, + np.linspace(0, 100, num_buckets + 1), + interpolation='lower', + )[1:] + ) + return buckets + + +def get_bucketed_sizes(orig_sizes, buckets): + sizes = np.copy(orig_sizes) + assert np.min(sizes) >= 0 + start_val = -1 + for end_val in buckets: + mask = (sizes > start_val) & (sizes <= end_val) + sizes[mask] = end_val + start_val = end_val + return sizes + + + +def _find_extra_valid_paths(dataset_path: str) -> set: + paths = utils.split_paths(dataset_path) + all_valid_paths = set() + for sub_dir in paths: + contents = PathManager.ls(sub_dir) + valid_paths = [c for c in contents if re.match("valid*[0-9].*", c) is not None] + all_valid_paths |= {os.path.basename(p) for p in valid_paths} + # Remove .bin, .idx etc + roots = {os.path.splitext(p)[0] for p in all_valid_paths} + return roots + + +def raise_if_valid_subsets_unintentionally_ignored(train_cfg) -> None: + """Raises if there are paths matching 'valid*[0-9].*' which are not combined or ignored.""" + if ( + train_cfg.dataset.ignore_unused_valid_subsets + or train_cfg.dataset.combine_valid_subsets + or train_cfg.dataset.disable_validation + or not hasattr(train_cfg.task, "data") + ): + return + other_paths = _find_extra_valid_paths(train_cfg.task.data) + specified_subsets = train_cfg.dataset.valid_subset.split(",") + ignored_paths = [p for p in other_paths if p not in specified_subsets] + if ignored_paths: + advice = "Set --combine-val to combine them or --ignore-unused-valid-subsets to ignore them." + msg = f"Valid paths {ignored_paths} will be ignored. {advice}" + raise ValueError(msg) diff --git a/fairseq/fairseq/data/data_utils_fast.pyx b/fairseq/fairseq/data/data_utils_fast.pyx new file mode 100644 index 0000000000000000000000000000000000000000..c61f31d6b2113d4c6a03d6553335997098ba0c20 --- /dev/null +++ b/fairseq/fairseq/data/data_utils_fast.pyx @@ -0,0 +1,178 @@ +# cython: language_level=3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np + +cimport cython +cimport numpy as np + +from libc.stdint cimport int32_t, int64_t +from libcpp cimport bool as bool_t + +ctypedef int64_t DTYPE_t + +@cython.cdivision(True) +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef list batch_by_size_vec( + np.ndarray[int64_t, ndim=1] indices, + np.ndarray[int64_t, ndim=1] num_tokens_vec, + int64_t max_tokens, + int64_t max_sentences, + int32_t bsz_mult, +): + if indices.shape[0] == 0: + return [] + + assert max_tokens <= 0 or np.max(num_tokens_vec) <= max_tokens, ( + f"Sentences lengths should not exceed max_tokens={max_tokens}" + ) + + cdef int32_t indices_len = indices.shape[0] + cdef np.ndarray[int32_t, ndim=1] batches_ends = \ + np.zeros(indices_len, dtype=np.int32) + cdef int32_t[:] batches_ends_view = batches_ends + cdef int64_t[:] num_tokens_view = num_tokens_vec + + cdef int32_t pos = 0 + cdef int32_t new_batch_end = 0 + + cdef int64_t new_batch_max_tokens = 0 + cdef int32_t new_batch_sentences = 0 + cdef int64_t new_batch_num_tokens = 0 + + cdef bool_t overflow = False + cdef bool_t size_matches_with_bsz_mult = False + + cdef int32_t batches_count = 0 + cdef int32_t batch_start = 0 + cdef int64_t tail_max_tokens = 0 + cdef int64_t batch_max_tokens = 0 + + for pos in range(indices_len): + # At every pos we keep stats about the last complete batch [batch_start:batch_end), + # and tail [batch_end:pos]. + # 1) Every time when (batch + tail) forms a valid batch + # (according to max_tokens, max_sentences and bsz_mult) we append tail to batch. + # 2) When (batch+tail) violates max_tokens or max_sentences constraints + # we finalize running batch, and tail becomes a new batch. + # 3) There is a corner case when tail also violates constraints. + # In that situation [batch_end:pos-1] (tail without the current pos) + # gets added to the finalized batches, while [pos:pos] becomes a new tail. + # + # Important: For the sake of performance try to avoid using function calls within this loop. + + tail_max_tokens = tail_max_tokens \ + if tail_max_tokens > num_tokens_view[pos] \ + else num_tokens_view[pos] + new_batch_end = pos + 1 + new_batch_max_tokens = batch_max_tokens \ + if batch_max_tokens > tail_max_tokens \ + else tail_max_tokens + new_batch_sentences = new_batch_end - batch_start + new_batch_num_tokens = new_batch_sentences * new_batch_max_tokens + + overflow = (new_batch_sentences > max_sentences > 0 or + new_batch_num_tokens > max_tokens > 0) + size_matches_with_bsz_mult = (new_batch_sentences < bsz_mult or + new_batch_sentences % bsz_mult == 0) + + if overflow: + tail_num_tokens = tail_max_tokens * \ + (new_batch_end - batches_ends_view[batches_count]) + tail_overflow = tail_num_tokens > max_tokens > 0 + # In case of a tail overflow finalize two batches + if tail_overflow: + batches_count += 1 + batches_ends_view[batches_count] = pos + tail_max_tokens = num_tokens_view[pos] + batch_start = batches_ends_view[batches_count] + batches_count += 1 + new_batch_max_tokens = tail_max_tokens + + if overflow or size_matches_with_bsz_mult: + batches_ends_view[batches_count] = new_batch_end + batch_max_tokens = new_batch_max_tokens + tail_max_tokens = 0 + if batches_ends_view[batches_count] != indices_len: + batches_count += 1 + # Memory and time-efficient split + return np.split(indices, batches_ends[:batches_count]) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef list batch_by_size_fn( + np.ndarray[DTYPE_t, ndim=1] indices, + num_tokens_fn, + int64_t max_tokens, + int64_t max_sentences, + int32_t bsz_mult, +): + cdef int32_t indices_len = indices.shape[0] + cdef np.ndarray[int64_t, ndim=1] num_tokens_vec = np.zeros(indices_len, + dtype=np.int64) + cdef DTYPE_t[:] indices_view = indices + cdef DTYPE_t[:] num_tokens_vec_view = num_tokens_vec + cdef int64_t pos + for pos in range(indices_len): + num_tokens_vec[pos] = num_tokens_fn(indices_view[pos]) + return batch_by_size_vec(indices, num_tokens_vec, max_tokens, + max_sentences, bsz_mult,) + + +cdef _find_valid_shape( + DTYPE_t[:, :] shapes_view, + int64_t num_sentences, + int64_t num_tokens, +): + """Return index of first valid shape of -1 if none is found.""" + for i in range(shapes_view.shape[0]): + if num_sentences <= shapes_view[i][0] and num_tokens <= shapes_view[i][1]: + return i + return -1 + + +@cython.cdivision(True) +cpdef list batch_fixed_shapes_fast( + np.ndarray[DTYPE_t, ndim=1] indices, + num_tokens_fn, + np.ndarray[DTYPE_t, ndim=2] fixed_shapes_sorted, +): + cdef int64_t sample_len = 0 + cdef list sample_lens = [] + cdef list batch = [] + cdef list batches = [] + cdef int64_t mod_len + cdef int64_t i + cdef int64_t idx + cdef int64_t num_tokens + cdef DTYPE_t[:] indices_view = indices + cdef DTYPE_t[:, :] shapes_view = fixed_shapes_sorted + + for i in range(len(indices_view)): + idx = indices_view[i] + num_tokens = num_tokens_fn(idx) + sample_lens.append(num_tokens) + sample_len = max(sample_len, num_tokens) + + shape_idx = _find_valid_shape(shapes_view, len(batch) + 1, sample_len) + if shape_idx == -1: + batches.append(batch) + batch = [] + sample_lens = [] + sample_len = 0 + shapes_view = fixed_shapes_sorted + elif shape_idx > 0: + # small optimization for the next call to _find_valid_shape + shapes_view = shapes_view[shape_idx:] + + batch.append(idx) + + if len(batch) > 0: + batches.append(batch) + + return batches diff --git a/fairseq/fairseq/data/denoising_dataset.py b/fairseq/fairseq/data/denoising_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..bdb62c8d5db9c8755c72db4d0d8083c936f18dc8 --- /dev/null +++ b/fairseq/fairseq/data/denoising_dataset.py @@ -0,0 +1,436 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import numpy as np +import torch + +from . import FairseqDataset, data_utils + + +def collate( + samples, + pad_idx, + eos_idx, + vocab, + left_pad_source=False, + left_pad_target=False, + input_feeding=True, + pad_to_length=None, +): + assert input_feeding + if len(samples) == 0: + return {} + + def merge(key, left_pad, move_eos_to_beginning=False, pad_to_length=None): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx=None, # use eos_idx of each sample instead of vocab.eos() + left_pad=left_pad, + move_eos_to_beginning=move_eos_to_beginning, + pad_to_length=pad_to_length, + ) + + id = torch.LongTensor([s["id"] for s in samples]) + src_tokens = merge( + "source", + left_pad=left_pad_source, + pad_to_length=pad_to_length["source"] if pad_to_length is not None else None, + ) + # sort by descending source length + src_lengths = torch.LongTensor([s["source"].numel() for s in samples]) + src_lengths, sort_order = src_lengths.sort(descending=True) + id = id.index_select(0, sort_order) + src_tokens = src_tokens.index_select(0, sort_order) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge( + "target", + left_pad=left_pad_target, + pad_to_length=pad_to_length["target"] + if pad_to_length is not None + else None, + ) + target = target.index_select(0, sort_order) + ntokens = sum(len(s["target"]) for s in samples) + + if input_feeding: + # we create a shifted version of targets for feeding the + # previous output token(s) into the next decoder step + prev_output_tokens = merge( + "target", + left_pad=left_pad_target, + move_eos_to_beginning=True, + pad_to_length=pad_to_length["target"] + if pad_to_length is not None + else None, + ) + prev_output_tokens = prev_output_tokens.index_select(0, sort_order) + else: + ntokens = sum(len(s["source"]) for s in samples) + + batch = { + "id": id, + "ntokens": ntokens, + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + }, + "target": target, + "nsentences": samples[0]["source"].size(0), + "sort_order": sort_order, + } + if prev_output_tokens is not None: + batch["net_input"]["prev_output_tokens"] = prev_output_tokens + + return batch + + +class DenoisingDataset(FairseqDataset): + """ + A wrapper around TokenBlockDataset for BART dataset. + + Args: + dataset (TokenBlockDataset): dataset to wrap + sizes (List[int]): sentence lengths + vocab (~fairseq.data.Dictionary): vocabulary + mask_idx (int): dictionary index used for masked token + mask_whole_words: only mask whole words. This should be a byte mask + over vocab indices, indicating whether it is the beginning of a + word. We will extend any mask to encompass the whole word. + shuffle (bool, optional): shuffle the elements before batching. + Default: ``True`` + seed: Seed for random number generator for reproducibility. + args: argparse arguments. + """ + + def __init__( + self, + dataset, + sizes, + vocab, + mask_idx, + mask_whole_words, + shuffle, + seed, + args, + eos=None, + item_transform_func=None, + ): + self.dataset = dataset + + self.sizes = sizes + + self.vocab = vocab + self.shuffle = shuffle + self.seed = seed + self.mask_idx = mask_idx + self.mask_whole_word = mask_whole_words + self.mask_ratio = args.mask + self.random_ratio = args.mask_random + self.insert_ratio = args.insert + self.rotate_ratio = args.rotate + self.permute_sentence_ratio = args.permute_sentences + self.eos = eos if eos is not None else vocab.eos() + self.item_transform_func = item_transform_func + + if args.bpe != "gpt2": + self.full_stop_index = self.vocab.eos() + else: + assert args.bpe == "gpt2" + self.full_stop_index = self.vocab.index("13") + + self.replace_length = args.replace_length + if self.replace_length not in [-1, 0, 1]: + raise ValueError(f"invalid arg: replace_length={self.replace_length}") + if args.mask_length not in ["subword", "word", "span-poisson"]: + raise ValueError(f"invalid arg: mask-length={args.mask_length}") + if args.mask_length == "subword" and args.replace_length not in [0, 1]: + raise ValueError(f"if using subwords, use replace-length=1 or 0") + + self.mask_span_distribution = None + if args.mask_length == "span-poisson": + _lambda = args.poisson_lambda + + lambda_to_the_k = 1 + e_to_the_minus_lambda = math.exp(-_lambda) + k_factorial = 1 + ps = [] + for k in range(0, 128): + ps.append(e_to_the_minus_lambda * lambda_to_the_k / k_factorial) + lambda_to_the_k *= _lambda + k_factorial *= k + 1 + if ps[-1] < 0.0000001: + break + ps = torch.FloatTensor(ps) + self.mask_span_distribution = torch.distributions.Categorical(ps) + + self.epoch = 0 + + @property + def can_reuse_epoch_itr_across_epochs(self): + return True # only the noise changes, not item sizes + + def set_epoch(self, epoch, **unused): + self.epoch = epoch + + def __getitem__(self, index): + with data_utils.numpy_seed(self.seed, self.epoch, index): + tokens = self.dataset[index] + assert tokens[-1] == self.eos + source, target = tokens, tokens.clone() + + if self.permute_sentence_ratio > 0.0: + source = self.permute_sentences(source, self.permute_sentence_ratio) + + if self.mask_ratio > 0: + source = self.add_whole_word_mask(source, self.mask_ratio) + + if self.insert_ratio > 0: + source = self.add_insertion_noise(source, self.insert_ratio) + + if self.rotate_ratio > 0.0 and np.random.random() < self.rotate_ratio: + source = self.add_rolling_noise(source) + # there can additional changes to make: + if self.item_transform_func is not None: + source, target = self.item_transform_func(source, target) + + assert (source >= 0).all() + assert (source[1:-1] >= 1).all() + assert (source <= len(self.vocab)).all() + assert source[0] == self.vocab.bos() + assert source[-1] == self.eos + return { + "id": index, + "source": source, + "target": target, + } + + def __len__(self): + return len(self.dataset) + + def permute_sentences(self, source, p=1.0): + full_stops = source == self.full_stop_index + # Pretend it ends with a full stop so last span is a sentence + full_stops[-2] = 1 + + # Tokens that are full stops, where the previous token is not + sentence_ends = (full_stops[1:] * ~full_stops[:-1]).nonzero(as_tuple=False) + 2 + result = source.clone() + + num_sentences = sentence_ends.size(0) + num_to_permute = math.ceil((num_sentences * 2 * p) / 2.0) + substitutions = torch.randperm(num_sentences)[:num_to_permute] + ordering = torch.arange(0, num_sentences) + ordering[substitutions] = substitutions[torch.randperm(num_to_permute)] + + # Ignore <bos> at start + index = 1 + for i in ordering: + sentence = source[(sentence_ends[i - 1] if i > 0 else 1) : sentence_ends[i]] + result[index : index + sentence.size(0)] = sentence + index += sentence.size(0) + return result + + def word_starts(self, source): + if self.mask_whole_word is not None: + is_word_start = self.mask_whole_word.gather(0, source) + else: + is_word_start = torch.ones(source.size()) + is_word_start[0] = 0 + is_word_start[-1] = 0 + return is_word_start + + def add_whole_word_mask(self, source, p): + is_word_start = self.word_starts(source) + num_to_mask = int(math.ceil(is_word_start.float().sum() * p)) + num_inserts = 0 + if num_to_mask == 0: + return source + + if self.mask_span_distribution is not None: + lengths = self.mask_span_distribution.sample(sample_shape=(num_to_mask,)) + + # Make sure we have enough to mask + cum_length = torch.cumsum(lengths, 0) + while cum_length[-1] < num_to_mask: + lengths = torch.cat( + [ + lengths, + self.mask_span_distribution.sample(sample_shape=(num_to_mask,)), + ], + dim=0, + ) + cum_length = torch.cumsum(lengths, 0) + + # Trim to masking budget + i = 0 + while cum_length[i] < num_to_mask: + i += 1 + lengths[i] = num_to_mask - (0 if i == 0 else cum_length[i - 1]) + num_to_mask = i + 1 + lengths = lengths[:num_to_mask] + + # Handle 0-length mask (inserts) separately + lengths = lengths[lengths > 0] + num_inserts = num_to_mask - lengths.size(0) + num_to_mask -= num_inserts + if num_to_mask == 0: + return self.add_insertion_noise(source, num_inserts / source.size(0)) + + assert (lengths > 0).all() + else: + lengths = torch.ones((num_to_mask,)).long() + assert is_word_start[-1] == 0 + word_starts = is_word_start.nonzero(as_tuple=False) + indices = word_starts[ + torch.randperm(word_starts.size(0))[:num_to_mask] + ].squeeze(1) + mask_random = torch.FloatTensor(num_to_mask).uniform_() < self.random_ratio + + source_length = source.size(0) + assert source_length - 1 not in indices + to_keep = torch.ones(source_length, dtype=torch.bool) + is_word_start[ + -1 + ] = 255 # acts as a long length, so spans don't go over the end of doc + if self.replace_length == 0: + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 1, len(self.vocab), size=(mask_random.sum(),) + ) + + if self.mask_span_distribution is not None: + assert len(lengths.size()) == 1 + assert lengths.size() == indices.size() + lengths -= 1 + while indices.size(0) > 0: + assert lengths.size() == indices.size() + lengths -= is_word_start[indices + 1].long() + uncompleted = lengths >= 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + lengths = lengths[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 1, len(self.vocab), size=(mask_random.sum(),) + ) + else: + # A bit faster when all lengths are 1 + while indices.size(0) > 0: + uncompleted = is_word_start[indices + 1] == 0 + indices = indices[uncompleted] + 1 + mask_random = mask_random[uncompleted] + if self.replace_length != -1: + # delete token + to_keep[indices] = 0 + else: + # keep index, but replace it with [MASK] + source[indices] = self.mask_idx + source[indices[mask_random]] = torch.randint( + 1, len(self.vocab), size=(mask_random.sum(),) + ) + + assert source_length - 1 not in indices + + source = source[to_keep] + + if num_inserts > 0: + source = self.add_insertion_noise(source, num_inserts / source.size(0)) + + return source + + def add_permuted_noise(self, tokens, p): + num_words = len(tokens) + num_to_permute = math.ceil(((num_words * 2) * p) / 2.0) + substitutions = torch.randperm(num_words - 2)[:num_to_permute] + 1 + tokens[substitutions] = tokens[substitutions[torch.randperm(num_to_permute)]] + return tokens + + def add_rolling_noise(self, tokens): + offset = np.random.randint(1, max(1, tokens.size(-1) - 1) + 1) + tokens = torch.cat( + (tokens[0:1], tokens[offset:-1], tokens[1:offset], tokens[-1:]), + dim=0, + ) + return tokens + + def add_insertion_noise(self, tokens, p): + if p == 0.0: + return tokens + + num_tokens = len(tokens) + n = int(math.ceil(num_tokens * p)) + + noise_indices = torch.randperm(num_tokens + n - 2)[:n] + 1 + noise_mask = torch.zeros(size=(num_tokens + n,), dtype=torch.bool) + noise_mask[noise_indices] = 1 + result = torch.LongTensor(n + len(tokens)).fill_(-1) + + num_random = int(math.ceil(n * self.random_ratio)) + result[noise_indices[num_random:]] = self.mask_idx + result[noise_indices[:num_random]] = torch.randint( + low=1, high=len(self.vocab), size=(num_random,) + ) + + result[~noise_mask] = tokens + + assert (result >= 0).all() + return result + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + Args: + samples (List[dict]): samples to collate + Returns: + dict: a mini-batch of data + """ + return collate( + samples, self.vocab.pad(), self.eos, self.vocab, pad_to_length=pad_to_length + ) + + def num_tokens(self, index): + """Return the number of tokens in a sample. This value is used to + enforce ``--max-tokens`` during batching.""" + return self.sizes[index] + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + return self.sizes[index] + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + if self.shuffle: + indices = np.random.permutation(len(self)) + else: + indices = np.arange(len(self)) + return indices[np.argsort(self.sizes[indices], kind="mergesort")] + + def prefetch(self, indices): + self.src.prefetch(indices) + self.tgt.prefetch(indices) + + @property + def supports_prefetch(self): + return ( + hasattr(self.src, "supports_prefetch") + and self.src.supports_prefetch + and hasattr(self.tgt, "supports_prefetch") + and self.tgt.supports_prefetch + ) diff --git a/fairseq/fairseq/data/dictionary.py b/fairseq/fairseq/data/dictionary.py new file mode 100644 index 0000000000000000000000000000000000000000..d6495389f0102156f0b2dc6f892946d572911bbe --- /dev/null +++ b/fairseq/fairseq/data/dictionary.py @@ -0,0 +1,401 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +from collections import Counter +from multiprocessing import Pool + +import torch +from fairseq import utils +from fairseq.data import data_utils +from fairseq.file_chunker_utils import Chunker, find_offsets +from fairseq.file_io import PathManager +from fairseq.tokenizer import tokenize_line + + +class Dictionary: + """A mapping from symbols to consecutive integers""" + + def __init__( + self, + *, # begin keyword-only arguments + bos="<s>", + pad="<pad>", + eos="</s>", + unk="<unk>", + extra_special_symbols=None, + ): + self.bos_word, self.unk_word, self.pad_word, self.eos_word = bos, unk, pad, eos + self.symbols = [] + self.count = [] + self.indices = {} + self.bos_index = self.add_symbol(bos) + self.pad_index = self.add_symbol(pad) + self.eos_index = self.add_symbol(eos) + self.unk_index = self.add_symbol(unk) + if extra_special_symbols: + for s in extra_special_symbols: + self.add_symbol(s) + self.nspecial = len(self.symbols) + + def __eq__(self, other): + return self.indices == other.indices + + def __getitem__(self, idx): + if idx < len(self.symbols): + return self.symbols[idx] + return self.unk_word + + def get_count(self, idx): + return self.count[idx] + + def __len__(self): + """Returns the number of symbols in the dictionary""" + return len(self.symbols) + + def __contains__(self, sym): + return sym in self.indices + + def index(self, sym): + """Returns the index of the specified symbol""" + assert isinstance(sym, str) + if sym in self.indices: + return self.indices[sym] + return self.unk_index + + def string( + self, + tensor, + bpe_symbol=None, + escape_unk=False, + extra_symbols_to_ignore=None, + unk_string=None, + include_eos=False, + separator=" ", + ): + """Helper for converting a tensor of token indices to a string. + + Can optionally remove BPE symbols or escape <unk> words. + """ + if torch.is_tensor(tensor) and tensor.dim() == 2: + return "\n".join( + self.string( + t, + bpe_symbol, + escape_unk, + extra_symbols_to_ignore, + include_eos=include_eos, + ) + for t in tensor + ) + + extra_symbols_to_ignore = set(extra_symbols_to_ignore or []) + if not include_eos: + extra_symbols_to_ignore.add(self.eos()) + + def token_string(i): + if i == self.unk(): + if unk_string is not None: + return unk_string + else: + return self.unk_string(escape_unk) + else: + return self[i] + + if hasattr(self, "bos_index"): + extra_symbols_to_ignore.add(self.bos()) + + sent = separator.join( + token_string(i) + for i in tensor + if utils.item(i) not in extra_symbols_to_ignore + ) + + return data_utils.post_process(sent, bpe_symbol) + + def unk_string(self, escape=False): + """Return unknown string, optionally escaped as: <<unk>>""" + if escape: + return "<{}>".format(self.unk_word) + else: + return self.unk_word + + def add_symbol(self, word, n=1, overwrite=False): + """Adds a word to the dictionary""" + if word in self.indices and not overwrite: + idx = self.indices[word] + self.count[idx] = self.count[idx] + n + return idx + else: + idx = len(self.symbols) + self.indices[word] = idx + self.symbols.append(word) + self.count.append(n) + return idx + + def update(self, new_dict): + """Updates counts from new dictionary.""" + for word in new_dict.symbols: + idx2 = new_dict.indices[word] + if word in self.indices: + idx = self.indices[word] + self.count[idx] = self.count[idx] + new_dict.count[idx2] + else: + idx = len(self.symbols) + self.indices[word] = idx + self.symbols.append(word) + self.count.append(new_dict.count[idx2]) + + def finalize(self, threshold=-1, nwords=-1, padding_factor=8): + """Sort symbols by frequency in descending order, ignoring special ones. + + Args: + - threshold defines the minimum word count + - nwords defines the total number of words in the final dictionary, + including special symbols + - padding_factor can be used to pad the dictionary size to be a + multiple of 8, which is important on some hardware (e.g., Nvidia + Tensor Cores). + """ + if nwords <= 0: + nwords = len(self) + + new_indices = dict(zip(self.symbols[: self.nspecial], range(self.nspecial))) + new_symbols = self.symbols[: self.nspecial] + new_count = self.count[: self.nspecial] + + c = Counter( + dict( + sorted(zip(self.symbols[self.nspecial :], self.count[self.nspecial :])) + ) + ) + for symbol, count in c.most_common(nwords - self.nspecial): + if count >= threshold: + new_indices[symbol] = len(new_symbols) + new_symbols.append(symbol) + new_count.append(count) + else: + break + + assert len(new_symbols) == len(new_indices) + + self.count = list(new_count) + self.symbols = list(new_symbols) + self.indices = new_indices + + self.pad_to_multiple_(padding_factor) + + def pad_to_multiple_(self, padding_factor): + """Pad Dictionary size to be a multiple of *padding_factor*.""" + if padding_factor > 1: + i = 0 + while len(self) % padding_factor != 0: + symbol = "madeupword{:04d}".format(i) + self.add_symbol(symbol, n=0) + i += 1 + + def bos(self): + """Helper to get index of beginning-of-sentence symbol""" + return self.bos_index + + def pad(self): + """Helper to get index of pad symbol""" + return self.pad_index + + def eos(self): + """Helper to get index of end-of-sentence symbol""" + return self.eos_index + + def unk(self): + """Helper to get index of unk symbol""" + return self.unk_index + + @classmethod + def load(cls, f): + """Loads the dictionary from a text file with the format: + + ``` + <symbol0> <count0> + <symbol1> <count1> + ... + ``` + """ + d = cls() + d.add_from_file(f) + return d + + def add_from_file(self, f): + """ + Loads a pre-existing dictionary from a text file and adds its symbols + to this instance. + """ + if isinstance(f, str): + try: + with open(PathManager.get_local_path(f), "r", encoding="utf-8") as fd: + self.add_from_file(fd) + except FileNotFoundError as fnfe: + raise fnfe + except UnicodeError: + raise Exception( + "Incorrect encoding detected in {}, please " + "rebuild the dataset".format(f) + ) + return + + lines = f.readlines() + indices_start_line = self._load_meta(lines) + + for line in lines[indices_start_line:]: + try: + line, field = line.rstrip().rsplit(" ", 1) + if field == "#fairseq:overwrite": + overwrite = True + line, field = line.rsplit(" ", 1) + else: + overwrite = False + count = int(field) + word = line + if word in self and not overwrite: + raise RuntimeError( + "Duplicate word found when loading Dictionary: '{}'. " + "Duplicate words can overwrite earlier ones by adding the " + "#fairseq:overwrite flag at the end of the corresponding row " + "in the dictionary file. If using the Camembert model, please " + "download an updated copy of the model file.".format(word) + ) + self.add_symbol(word, n=count, overwrite=overwrite) + except ValueError: + raise ValueError( + f"Incorrect dictionary format, expected '<token> <cnt> [flags]': \"{line}\"" + ) + + def _save(self, f, kv_iterator): + if isinstance(f, str): + PathManager.mkdirs(os.path.dirname(f)) + with PathManager.open(f, "w", encoding="utf-8") as fd: + return self.save(fd) + for k, v in kv_iterator: + print("{} {}".format(k, v), file=f) + + def _get_meta(self): + return [], [] + + def _load_meta(self, lines): + return 0 + + def save(self, f): + """Stores dictionary into a text file""" + ex_keys, ex_vals = self._get_meta() + self._save( + f, + zip( + ex_keys + self.symbols[self.nspecial :], + ex_vals + self.count[self.nspecial :], + ), + ) + + def dummy_sentence(self, length): + t = torch.Tensor(length).uniform_(self.nspecial + 1, len(self)).long() + t[-1] = self.eos() + return t + + def encode_line( + self, + line, + line_tokenizer=tokenize_line, + add_if_not_exist=True, + consumer=None, + append_eos=True, + reverse_order=False, + ) -> torch.IntTensor: + words = line_tokenizer(line) + if reverse_order: + words = list(reversed(words)) + nwords = len(words) + ids = torch.IntTensor(nwords + 1 if append_eos else nwords) + + for i, word in enumerate(words): + if add_if_not_exist: + idx = self.add_symbol(word) + else: + idx = self.index(word) + if consumer is not None: + consumer(word, idx) + ids[i] = idx + if append_eos: + ids[nwords] = self.eos_index + return ids + + @staticmethod + def _add_file_to_dictionary_single_worker( + filename, + tokenize, + eos_word, + start_offset, + end_offset, + ): + counter = Counter() + with Chunker(filename, start_offset, end_offset) as line_iterator: + for line in line_iterator: + for word in tokenize(line): + counter.update([word]) + counter.update([eos_word]) + return counter + + @staticmethod + def add_file_to_dictionary(filename, dict, tokenize, num_workers): + def merge_result(counter): + for w, c in sorted(counter.items()): + dict.add_symbol(w, c) + + local_file = PathManager.get_local_path(filename) + offsets = find_offsets(local_file, num_workers) + if num_workers > 1: + chunks = zip(offsets, offsets[1:]) + pool = Pool(processes=num_workers) + results = [] + for (start_offset, end_offset) in chunks: + results.append( + pool.apply_async( + Dictionary._add_file_to_dictionary_single_worker, + ( + local_file, + tokenize, + dict.eos_word, + start_offset, + end_offset, + ), + ) + ) + pool.close() + pool.join() + for r in results: + merge_result(r.get()) + else: + merge_result( + Dictionary._add_file_to_dictionary_single_worker( + local_file, tokenize, dict.eos_word, offsets[0], offsets[1] + ) + ) + + +class TruncatedDictionary(object): + def __init__(self, wrapped_dict, length): + self.__class__ = type( + wrapped_dict.__class__.__name__, + (self.__class__, wrapped_dict.__class__), + {}, + ) + self.__dict__ = wrapped_dict.__dict__ + self.wrapped_dict = wrapped_dict + self.length = min(len(self.wrapped_dict), length) + + def __len__(self): + return self.length + + def __getitem__(self, i): + if i < self.length: + return self.wrapped_dict[i] + return self.wrapped_dict.unk() diff --git a/fairseq/fairseq/data/encoders/__init__.py b/fairseq/fairseq/data/encoders/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7cbe00a10520331709441e5e77991bd2edca8c06 --- /dev/null +++ b/fairseq/fairseq/data/encoders/__init__.py @@ -0,0 +1,29 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import importlib +import os + +from fairseq import registry + + +build_tokenizer, register_tokenizer, TOKENIZER_REGISTRY, _ = registry.setup_registry( + "--tokenizer", + default=None, +) + + +build_bpe, register_bpe, BPE_REGISTRY, _ = registry.setup_registry( + "--bpe", + default=None, +) + + +# automatically import any Python files in the encoders/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + module = file[: file.find(".py")] + importlib.import_module("fairseq.data.encoders." + module) diff --git a/fairseq/fairseq/data/encoders/byte_bpe.py b/fairseq/fairseq/data/encoders/byte_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..31e3a0627827f19ca7f0b58da45e46d40a80c3bf --- /dev/null +++ b/fairseq/fairseq/data/encoders/byte_bpe.py @@ -0,0 +1,48 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from dataclasses import dataclass, field + +from fairseq import file_utils +from fairseq.data.encoders import register_bpe +from fairseq.data.encoders.byte_utils import ( + SPACE, + SPACE_ESCAPE, + byte_encode, + smart_byte_decode, +) +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class ByteBpeConfig(FairseqDataclass): + sentencepiece_model_path: str = field( + default="???", metadata={"help": "path to sentencepiece model"} + ) + + +@register_bpe("byte_bpe", dataclass=ByteBpeConfig) +class ByteBPE(object): + def __init__(self, cfg): + vocab = file_utils.cached_path(cfg.sentencepiece_model_path) + try: + import sentencepiece as spm + + self.sp = spm.SentencePieceProcessor() + self.sp.Load(vocab) + except ImportError: + raise ImportError( + "Please install sentencepiece with: pip install sentencepiece" + ) + + def encode(self, x: str) -> str: + byte_encoded = byte_encode(x) + return SPACE.join(self.sp.EncodeAsPieces(byte_encoded)) + + @staticmethod + def decode(x: str) -> str: + unescaped = x.replace(SPACE, "").replace(SPACE_ESCAPE, SPACE) + return smart_byte_decode(unescaped) diff --git a/fairseq/fairseq/data/encoders/byte_utils.py b/fairseq/fairseq/data/encoders/byte_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a305c080926c2d094b7e8ae48f5331da82025a75 --- /dev/null +++ b/fairseq/fairseq/data/encoders/byte_utils.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import re + + +WHITESPACE_NORMALIZER = re.compile(r"\s+") +SPACE = chr(32) +SPACE_ESCAPE = chr(9601) +# excluding non-breaking space (160) here +PRINTABLE_LATIN = set( + list(range(32, 126 + 1)) + list(range(161, 172 + 1)) + list(range(174, 255 + 1)) +) +BYTE_TO_BCHAR = { + b: chr(b) if b in PRINTABLE_LATIN else chr(256 + b) for b in range(256) +} +BCHAR_TO_BYTE = {bc: b for b, bc in BYTE_TO_BCHAR.items()} + + +def byte_encode(x: str) -> str: + normalized = WHITESPACE_NORMALIZER.sub(SPACE, x) + return "".join([BYTE_TO_BCHAR[b] for b in normalized.encode("utf-8")]) + + +def byte_decode(x: str) -> str: + try: + return bytes([BCHAR_TO_BYTE[bc] for bc in x]).decode("utf-8") + except ValueError: + return "" + + +def smart_byte_decode(x: str) -> str: + output = byte_decode(x) + if output == "": + # DP the best recovery (max valid chars) if it's broken + n_bytes = len(x) + f = [0 for _ in range(n_bytes + 1)] + pt = [0 for _ in range(n_bytes + 1)] + for i in range(1, n_bytes + 1): + f[i], pt[i] = f[i - 1], i - 1 + for j in range(1, min(4, i) + 1): + if f[i - j] + 1 > f[i] and len(byte_decode(x[i - j : i])) > 0: + f[i], pt[i] = f[i - j] + 1, i - j + cur_pt = n_bytes + while cur_pt > 0: + if f[cur_pt] == f[pt[cur_pt]] + 1: + output = byte_decode(x[pt[cur_pt] : cur_pt]) + output + cur_pt = pt[cur_pt] + return output diff --git a/fairseq/fairseq/data/encoders/bytes.py b/fairseq/fairseq/data/encoders/bytes.py new file mode 100644 index 0000000000000000000000000000000000000000..f88f8f6929f5b6bdb0db470be9ebedf8fe1f752d --- /dev/null +++ b/fairseq/fairseq/data/encoders/bytes.py @@ -0,0 +1,34 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from fairseq.data.encoders import register_bpe +from fairseq.data.encoders.byte_utils import ( + SPACE, + SPACE_ESCAPE, + byte_encode, + smart_byte_decode, +) + + +@register_bpe("bytes") +class Bytes(object): + def __init__(self, *unused): + pass + + @staticmethod + def add_args(parser): + pass + + @staticmethod + def encode(x: str) -> str: + encoded = byte_encode(x) + escaped = encoded.replace(SPACE, SPACE_ESCAPE) + return SPACE.join(list(escaped)) + + @staticmethod + def decode(x: str) -> str: + unescaped = x.replace(SPACE, "").replace(SPACE_ESCAPE, SPACE) + return smart_byte_decode(unescaped) diff --git a/fairseq/fairseq/data/encoders/characters.py b/fairseq/fairseq/data/encoders/characters.py new file mode 100644 index 0000000000000000000000000000000000000000..494ea219392716dc75d2c1e19d71cd55b9b2f4ba --- /dev/null +++ b/fairseq/fairseq/data/encoders/characters.py @@ -0,0 +1,30 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from fairseq.data.encoders import register_bpe + + +SPACE = chr(32) +SPACE_ESCAPE = chr(9601) + + +@register_bpe("characters") +class Characters(object): + def __init__(self, *unused): + pass + + @staticmethod + def add_args(parser): + pass + + @staticmethod + def encode(x: str) -> str: + escaped = x.replace(SPACE, SPACE_ESCAPE) + return SPACE.join(list(escaped)) + + @staticmethod + def decode(x: str) -> str: + return x.replace(SPACE, "").replace(SPACE_ESCAPE, SPACE) diff --git a/fairseq/fairseq/data/encoders/fastbpe.py b/fairseq/fairseq/data/encoders/fastbpe.py new file mode 100644 index 0000000000000000000000000000000000000000..f7c21039549ea002e73d1ad7cde5735f215f11ee --- /dev/null +++ b/fairseq/fairseq/data/encoders/fastbpe.py @@ -0,0 +1,36 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq import file_utils +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class fastBPEConfig(FairseqDataclass): + bpe_codes: str = field(default="???", metadata={"help": "path to fastBPE BPE"}) + + +@register_bpe("fastbpe", dataclass=fastBPEConfig) +class fastBPE(object): + def __init__(self, cfg): + if cfg.bpe_codes is None: + raise ValueError("--bpe-codes is required for --bpe=fastbpe") + codes = file_utils.cached_path(cfg.bpe_codes) + try: + import fastBPE + + self.bpe = fastBPE.fastBPE(codes) + self.bpe_symbol = "@@ " + except ImportError: + raise ImportError("Please install fastBPE with: pip install fastBPE") + + def encode(self, x: str) -> str: + return self.bpe.apply([x])[0] + + def decode(self, x: str) -> str: + return (x + " ").replace(self.bpe_symbol, "").rstrip() diff --git a/fairseq/fairseq/data/encoders/gpt2_bpe.py b/fairseq/fairseq/data/encoders/gpt2_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..b7426b249bbbabd8e20bbe8ca5449809efdf85fc --- /dev/null +++ b/fairseq/fairseq/data/encoders/gpt2_bpe.py @@ -0,0 +1,45 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq import file_utils +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass + +from .gpt2_bpe_utils import get_encoder + + +DEFAULT_ENCODER_JSON = "https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/encoder.json" +DEFAULT_VOCAB_BPE = "https://dl.fbaipublicfiles.com/fairseq/gpt2_bpe/vocab.bpe" + + +@dataclass +class GPT2BPEConfig(FairseqDataclass): + gpt2_encoder_json: str = field( + default=DEFAULT_ENCODER_JSON, metadata={"help": "path to encoder.json"} + ) + gpt2_vocab_bpe: str = field( + default=DEFAULT_VOCAB_BPE, metadata={"help": "path to vocab.bpe"} + ) + + +@register_bpe("gpt2", dataclass=GPT2BPEConfig) +class GPT2BPE(object): + def __init__(self, cfg): + encoder_json = file_utils.cached_path(cfg.gpt2_encoder_json) + vocab_bpe = file_utils.cached_path(cfg.gpt2_vocab_bpe) + self.bpe = get_encoder(encoder_json, vocab_bpe) + + def encode(self, x: str) -> str: + return " ".join(map(str, self.bpe.encode(x))) + + def decode(self, x: str) -> str: + return self.bpe.decode( + [int(tok) if tok not in {"<unk>", "<mask>"} and not tok.startswith('<') else tok for tok in x.split()] + ) + + def is_beginning_of_word(self, x: str) -> bool: + return self.decode(x).startswith(" ") diff --git a/fairseq/fairseq/data/encoders/gpt2_bpe_utils.py b/fairseq/fairseq/data/encoders/gpt2_bpe_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..688d4e36e358df2dcc432d37d3e57bd81e2f1ed1 --- /dev/null +++ b/fairseq/fairseq/data/encoders/gpt2_bpe_utils.py @@ -0,0 +1,140 @@ +""" +Byte pair encoding utilities from GPT-2. + +Original source: https://github.com/openai/gpt-2/blob/master/src/encoder.py +Original license: MIT +""" + +import json +from functools import lru_cache + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = ( + list(range(ord("!"), ord("~") + 1)) + + list(range(ord("¡"), ord("¬") + 1)) + + list(range(ord("®"), ord("ÿ") + 1)) + ) + cs = bs[:] + n = 0 + for b in range(2 ** 8): + if b not in bs: + bs.append(b) + cs.append(2 ** 8 + n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +class Encoder: + def __init__(self, encoder, bpe_merges, errors="replace"): + self.encoder = encoder + self.decoder = {v: k for k, v in self.encoder.items()} + self.errors = errors # how to handle errors in decoding + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + self.bpe_ranks = dict(zip(bpe_merges, range(len(bpe_merges)))) + self.cache = {} + + try: + import regex as re + + self.re = re + except ImportError: + raise ImportError("Please install regex with: pip install regex") + + # Should haved added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions + self.pat = self.re.compile( + r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""" + ) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token) + pairs = get_pairs(word) + + if not pairs: + return token + + while True: + bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf"))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word) - 1 and word[i + 1] == second: + new_word.append(first + second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = " ".join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + for token in self.re.findall(self.pat, text): + token = "".join(self.byte_encoder[b] for b in token.encode("utf-8")) + bpe_tokens.extend( + self.encoder[bpe_token] for bpe_token in self.bpe(token).split(" ") + ) + return bpe_tokens + + def decode(self, tokens): + text = "".join([self.decoder.get(token, token) for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode( + "utf-8", errors=self.errors + ) + return text + + +def get_encoder(encoder_json_path, vocab_bpe_path): + with open(encoder_json_path, "r") as f: + encoder = json.load(f) + with open(vocab_bpe_path, "r", encoding="utf-8") as f: + bpe_data = f.read() + bpe_merges = [tuple(merge_str.split()) for merge_str in bpe_data.split("\n")[1:-1]] + return Encoder( + encoder=encoder, + bpe_merges=bpe_merges, + ) diff --git a/fairseq/fairseq/data/encoders/hf_bert_bpe.py b/fairseq/fairseq/data/encoders/hf_bert_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..a41c059343ec7e2914b2c9d2f53f526c33f9659d --- /dev/null +++ b/fairseq/fairseq/data/encoders/hf_bert_bpe.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +from typing import Optional + +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class BertBPEConfig(FairseqDataclass): + bpe_cased: bool = field(default=False, metadata={"help": "set for cased BPE"}) + bpe_vocab_file: Optional[str] = field( + default=None, metadata={"help": "bpe vocab file"} + ) + + +@register_bpe("bert", dataclass=BertBPEConfig) +class BertBPE(object): + def __init__(self, cfg): + try: + from transformers import BertTokenizer + except ImportError: + raise ImportError( + "Please install transformers with: pip install transformers" + ) + + if cfg.bpe_vocab_file: + self.bert_tokenizer = BertTokenizer( + cfg.bpe_vocab_file, do_lower_case=not cfg.bpe_cased + ) + else: + vocab_file_name = ( + "bert-base-cased" if cfg.bpe_cased else "bert-base-uncased" + ) + self.bert_tokenizer = BertTokenizer.from_pretrained(vocab_file_name) + + def encode(self, x: str) -> str: + return " ".join(self.bert_tokenizer.tokenize(x)) + + def decode(self, x: str) -> str: + return self.bert_tokenizer.clean_up_tokenization( + self.bert_tokenizer.convert_tokens_to_string(x.split(" ")) + ) + + def is_beginning_of_word(self, x: str) -> bool: + return not x.startswith("##") diff --git a/fairseq/fairseq/data/encoders/hf_byte_bpe.py b/fairseq/fairseq/data/encoders/hf_byte_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..c508578d41bf6b7ce0a847e0797d71b19beb393d --- /dev/null +++ b/fairseq/fairseq/data/encoders/hf_byte_bpe.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass +from fairseq import file_utils + + +@dataclass +class HuggingFaceByteLevelBPEConfig(FairseqDataclass): + bpe_merges: str = field(default="???", metadata={"help": "path to merges.txt"}) + bpe_vocab: str = field(default="???", metadata={"help": "path to vocab.json"}) + bpe_add_prefix_space: bool = field( + default=False, metadata={"help": "add prefix space before encoding"} + ) + + +@register_bpe("hf_byte_bpe", dataclass=HuggingFaceByteLevelBPEConfig) +class HuggingFaceByteLevelBPE(object): + def __init__(self, cfg): + try: + from tokenizers import ByteLevelBPETokenizer + except ImportError: + raise ImportError( + "Please install huggingface/tokenizers with: " "pip install tokenizers" + ) + + bpe_vocab = file_utils.cached_path(cfg.bpe_vocab) + bpe_merges = file_utils.cached_path(cfg.bpe_merges) + + self.bpe = ByteLevelBPETokenizer( + bpe_vocab, + bpe_merges, + add_prefix_space=cfg.bpe_add_prefix_space, + ) + + def encode(self, x: str) -> str: + return " ".join(map(str, self.bpe.encode(x).ids)) + + def decode(self, x: str) -> str: + return self.bpe.decode( + [int(tok) if tok not in {"<unk>", "<mask>"} else tok for tok in x.split()] + ) + + def is_beginning_of_word(self, x: str) -> bool: + return self.decode(x).startswith(" ") diff --git a/fairseq/fairseq/data/encoders/moses_tokenizer.py b/fairseq/fairseq/data/encoders/moses_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..e236dad167a037a8ed95f7fc8292b27b10d580b0 --- /dev/null +++ b/fairseq/fairseq/data/encoders/moses_tokenizer.py @@ -0,0 +1,49 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq.data.encoders import register_tokenizer +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class MosesTokenizerConfig(FairseqDataclass): + source_lang: str = field(default="en", metadata={"help": "source language"}) + target_lang: str = field(default="en", metadata={"help": "target language"}) + moses_no_dash_splits: bool = field( + default=False, metadata={"help": "don't apply dash split rules"} + ) + moses_no_escape: bool = field( + default=False, + metadata={"help": "don't perform HTML escaping on apostrophe, quotes, etc."}, + ) + + +@register_tokenizer("moses", dataclass=MosesTokenizerConfig) +class MosesTokenizer(object): + def __init__(self, cfg: MosesTokenizerConfig): + self.cfg = cfg + + try: + from sacremoses import MosesTokenizer, MosesDetokenizer + + self.tok = MosesTokenizer(cfg.source_lang) + self.detok = MosesDetokenizer(cfg.target_lang) + except ImportError: + raise ImportError( + "Please install Moses tokenizer with: pip install sacremoses" + ) + + def encode(self, x: str) -> str: + return self.tok.tokenize( + x, + aggressive_dash_splits=(not self.cfg.moses_no_dash_splits), + return_str=True, + escape=(not self.cfg.moses_no_escape), + ) + + def decode(self, x: str) -> str: + return self.detok.detokenize(x.split()) diff --git a/fairseq/fairseq/data/encoders/nltk_tokenizer.py b/fairseq/fairseq/data/encoders/nltk_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0ab92377b3a23bb48384c3f7acf299612e8b0775 --- /dev/null +++ b/fairseq/fairseq/data/encoders/nltk_tokenizer.py @@ -0,0 +1,24 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.data.encoders import register_tokenizer +from fairseq.dataclass import FairseqDataclass + + +@register_tokenizer("nltk", dataclass=FairseqDataclass) +class NLTKTokenizer(object): + def __init__(self, *unused): + try: + from nltk.tokenize import word_tokenize + + self.word_tokenize = word_tokenize + except ImportError: + raise ImportError("Please install nltk with: pip install nltk") + + def encode(self, x: str) -> str: + return " ".join(self.word_tokenize(x)) + + def decode(self, x: str) -> str: + return x diff --git a/fairseq/fairseq/data/encoders/sentencepiece_bpe.py b/fairseq/fairseq/data/encoders/sentencepiece_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..a76d46a2014e81eff72b19f6c13084a855fcd477 --- /dev/null +++ b/fairseq/fairseq/data/encoders/sentencepiece_bpe.py @@ -0,0 +1,48 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq import file_utils +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class SentencepieceConfig(FairseqDataclass): + sentencepiece_model: str = field( + default="???", metadata={"help": "path to sentencepiece model"} + ) + + +@register_bpe("sentencepiece", dataclass=SentencepieceConfig) +class SentencepieceBPE(object): + def __init__(self, cfg): + sentencepiece_model = file_utils.cached_path(cfg.sentencepiece_model) + try: + import sentencepiece as spm + + self.sp = spm.SentencePieceProcessor() + self.sp.Load(sentencepiece_model) + except ImportError: + raise ImportError( + "Please install sentencepiece with: pip install sentencepiece" + ) + + def encode(self, x: str) -> str: + return " ".join(self.sp.EncodeAsPieces(x)) + + def decode(self, x: str) -> str: + return x.replace(" ", "").replace("\u2581", " ").strip() + + def is_beginning_of_word(self, x: str) -> bool: + if x in ["<unk>", "<s>", "</s>", "<pad>"]: + # special elements are always considered beginnings + # HACK: this logic is already present in fairseq/tasks/masked_lm.py + # but these special tokens are also contained in the sentencepiece + # vocabulary which causes duplicate special tokens. This hack makes + # sure that they are all taken into account. + return True + return x.startswith("\u2581") diff --git a/fairseq/fairseq/data/encoders/space_tokenizer.py b/fairseq/fairseq/data/encoders/space_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..925ad41b7c1aee6738c63938c36bd3ee16dca812 --- /dev/null +++ b/fairseq/fairseq/data/encoders/space_tokenizer.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import re + +from fairseq.data.encoders import register_tokenizer +from fairseq.dataclass import FairseqDataclass + + +@register_tokenizer("space", dataclass=FairseqDataclass) +class SpaceTokenizer(object): + def __init__(self, *unused): + self.space_tok = re.compile(r"\s+") + + def encode(self, x: str) -> str: + return self.space_tok.sub(" ", x) + + def decode(self, x: str) -> str: + return x diff --git a/fairseq/fairseq/data/encoders/subword_nmt_bpe.py b/fairseq/fairseq/data/encoders/subword_nmt_bpe.py new file mode 100644 index 0000000000000000000000000000000000000000..5d724d2730a5895ca55af2998c2ced471625b516 --- /dev/null +++ b/fairseq/fairseq/data/encoders/subword_nmt_bpe.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq import file_utils +from fairseq.data.encoders import register_bpe +from fairseq.dataclass import FairseqDataclass + + +@dataclass +class SubwordNMTBPEConfig(FairseqDataclass): + bpe_codes: str = field(default="???", metadata={"help": "path to subword NMT BPE"}) + bpe_separator: str = field(default="@@", metadata={"help": "BPE separator"}) + + +@register_bpe("subword_nmt", dataclass=SubwordNMTBPEConfig) +class SubwordNMTBPE(object): + def __init__(self, cfg): + if cfg.bpe_codes is None: + raise ValueError("--bpe-codes is required for --bpe=subword_nmt") + codes = file_utils.cached_path(cfg.bpe_codes) + try: + from subword_nmt import apply_bpe + + bpe_parser = apply_bpe.create_parser() + bpe_args = bpe_parser.parse_args( + [ + "--codes", + codes, + "--separator", + cfg.bpe_separator, + ] + ) + self.bpe = apply_bpe.BPE( + bpe_args.codes, + bpe_args.merges, + bpe_args.separator, + None, + bpe_args.glossaries, + ) + self.bpe_symbol = bpe_args.separator + " " + except ImportError: + raise ImportError( + "Please install subword_nmt with: pip install subword-nmt" + ) + + def encode(self, x: str) -> str: + return self.bpe.process_line(x) + + def decode(self, x: str) -> str: + return (x + " ").replace(self.bpe_symbol, "").rstrip() diff --git a/fairseq/fairseq/data/encoders/utils.py b/fairseq/fairseq/data/encoders/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d93eb532ef84f0e2bc708b777229ab2cb76ca14b --- /dev/null +++ b/fairseq/fairseq/data/encoders/utils.py @@ -0,0 +1,30 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq.data import encoders + + +def get_whole_word_mask(args, dictionary): + bpe = encoders.build_bpe(args) + if bpe is not None: + + def is_beginning_of_word(i): + if i < dictionary.nspecial: + # special elements are always considered beginnings + return True + tok = dictionary[i] + if tok.startswith("madeupword"): + return True + try: + return bpe.is_beginning_of_word(tok) + except ValueError: + return True + + mask_whole_words = torch.ByteTensor( + list(map(is_beginning_of_word, range(len(dictionary)))) + ) + return mask_whole_words + return None diff --git a/fairseq/fairseq/data/fairseq_dataset.py b/fairseq/fairseq/data/fairseq_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..23e6992dbaf34e52f2fdcd0c8fc418c93744ea4e --- /dev/null +++ b/fairseq/fairseq/data/fairseq_dataset.py @@ -0,0 +1,205 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import numpy as np +import torch.utils.data +from fairseq.data import data_utils + +logger = logging.getLogger(__name__) + + +class EpochListening: + """Mixin for receiving updates whenever the epoch increments.""" + + @property + def can_reuse_epoch_itr_across_epochs(self): + """ + Whether we can reuse the :class:`fairseq.data.EpochBatchIterator` for + this dataset across epochs. + + This needs to return ``False`` if the sample sizes can change across + epochs, in which case we may need to regenerate batches at each epoch. + If your dataset relies in ``set_epoch`` then you should consider setting + this to ``False``. + """ + return True + + def set_epoch(self, epoch): + """Will receive the updated epoch number at the beginning of the epoch.""" + pass + + +class FairseqDataset(torch.utils.data.Dataset, EpochListening): + """A dataset that provides helpers for batching.""" + + def __getitem__(self, index): + raise NotImplementedError + + def __len__(self): + raise NotImplementedError + + def collater(self, samples): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[dict]): samples to collate + + Returns: + dict: a mini-batch suitable for forwarding with a Model + """ + raise NotImplementedError + + def num_tokens(self, index): + """Return the number of tokens in a sample. This value is used to + enforce ``--max-tokens`` during batching.""" + raise NotImplementedError + + def num_tokens_vec(self, indices): + """Return the number of tokens for a set of positions defined by indices. + This value is used to enforce ``--max-tokens`` during batching.""" + raise NotImplementedError + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + raise NotImplementedError + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + return np.arange(len(self), dtype=np.int64) + + @property + def supports_prefetch(self): + """Whether this dataset supports prefetching.""" + return False + + def attr(self, attr: str, index: int): + return getattr(self, attr, None) + + def prefetch(self, indices): + """Prefetch the data required for this epoch.""" + raise NotImplementedError + + def get_batch_shapes(self): + """ + Return a list of valid batch shapes, for example:: + + [(8, 512), (16, 256), (32, 128)] + + The first dimension of each tuple is the batch size and can be ``None`` + to automatically infer the max batch size based on ``--max-tokens``. + The second dimension of each tuple is the max supported length as given + by :func:`fairseq.data.FairseqDataset.num_tokens`. + + This will be used by :func:`fairseq.data.FairseqDataset.batch_by_size` + to restrict batch shapes. This is useful on TPUs to avoid too many + dynamic shapes (and recompilations). + """ + return None + + def batch_by_size( + self, + indices, + max_tokens=None, + max_sentences=None, + required_batch_size_multiple=1, + ): + """ + Given an ordered set of indices, return batches according to + *max_tokens*, *max_sentences* and *required_batch_size_multiple*. + """ + from fairseq.data import data_utils + + fixed_shapes = self.get_batch_shapes() + if fixed_shapes is not None: + + def adjust_bsz(bsz, num_tokens): + if bsz is None: + assert max_tokens is not None, "Must specify --max-tokens" + bsz = max_tokens // num_tokens + if max_sentences is not None: + bsz = min(bsz, max_sentences) + elif ( + bsz >= required_batch_size_multiple + and bsz % required_batch_size_multiple != 0 + ): + bsz -= bsz % required_batch_size_multiple + return bsz + + fixed_shapes = np.array( + [ + [adjust_bsz(bsz, num_tokens), num_tokens] + for (bsz, num_tokens) in fixed_shapes + ] + ) + + try: + num_tokens_vec = self.num_tokens_vec(indices).astype('int64') + except NotImplementedError: + num_tokens_vec = None + + return data_utils.batch_by_size( + indices, + num_tokens_fn=self.num_tokens, + num_tokens_vec=num_tokens_vec, + max_tokens=max_tokens, + max_sentences=max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + fixed_shapes=fixed_shapes, + ) + + def filter_indices_by_size(self, indices, max_sizes): + """ + Filter a list of sample indices. Remove those that are longer than + specified in *max_sizes*. + + WARNING: don't update, override method in child classes + + Args: + indices (np.array): original array of sample indices + max_sizes (int or list[int] or tuple[int]): max sample size, + can be defined separately for src and tgt (then list or tuple) + + Returns: + np.array: filtered sample array + list: list of removed indices + """ + if isinstance(max_sizes, float) or isinstance(max_sizes, int): + if hasattr(self, "sizes") and isinstance(self.sizes, np.ndarray): + ignored = indices[self.sizes[indices] > max_sizes].tolist() + indices = indices[self.sizes[indices] <= max_sizes] + elif ( + hasattr(self, "sizes") + and isinstance(self.sizes, list) + and len(self.sizes) == 1 + ): + ignored = indices[self.sizes[0][indices] > max_sizes].tolist() + indices = indices[self.sizes[0][indices] <= max_sizes] + else: + indices, ignored = data_utils._filter_by_size_dynamic( + indices, self.size, max_sizes + ) + else: + indices, ignored = data_utils._filter_by_size_dynamic( + indices, self.size, max_sizes + ) + return indices, ignored + + @property + def supports_fetch_outside_dataloader(self): + """Whether this dataset supports fetching outside the workers of the dataloader.""" + return True + + +class FairseqIterableDataset(torch.utils.data.IterableDataset, EpochListening): + """ + For datasets that need to be read sequentially, usually because the data is + being streamed or otherwise can't be manipulated on a single machine. + """ + + def __iter__(self): + raise NotImplementedError diff --git a/fairseq/fairseq/data/fasta_dataset.py b/fairseq/fairseq/data/fasta_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..007011974a997fd7446dd29d7eba097d7513bab0 --- /dev/null +++ b/fairseq/fairseq/data/fasta_dataset.py @@ -0,0 +1,107 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import subprocess +import threading +from pathlib import Path + +import numpy as np +import torch + + +def fasta_file_path(prefix_path): + return prefix_path + ".fasta" + + +class FastaDataset(torch.utils.data.Dataset): + """ + For loading protein sequence datasets in the common FASTA data format + """ + + def __init__(self, path: str, cache_indices=False): + self.fn = fasta_file_path(path) + self.threadlocal = threading.local() + self.cache = Path(f"{path}.fasta.idx.npy") + if cache_indices: + if self.cache.exists(): + self.offsets, self.sizes = np.load(self.cache) + else: + self.offsets, self.sizes = self._build_index(path) + np.save(self.cache, np.stack([self.offsets, self.sizes])) + else: + self.offsets, self.sizes = self._build_index(path) + + def _get_file(self): + if not hasattr(self.threadlocal, "f"): + self.threadlocal.f = open(self.fn, "r") + return self.threadlocal.f + + def __getitem__(self, idx): + f = self._get_file() + f.seek(self.offsets[idx]) + desc = f.readline().strip() + line = f.readline() + seq = "" + while line != "" and line[0] != ">": + seq += line.strip() + line = f.readline() + return desc, seq + + def __len__(self): + return self.offsets.size + + def _build_index(self, path: str): + # Use grep and awk to get 100M/s on local SSD. + # Should process your enormous 100G fasta in ~10 min single core... + path = fasta_file_path(path) + bytes_offsets = subprocess.check_output( + f"cat {path} | tqdm --bytes --total $(wc -c < {path})" + "| grep --byte-offset '^>' -o | cut -d: -f1", + shell=True, + ) + fasta_lengths = subprocess.check_output( + f"cat {path} | tqdm --bytes --total $(wc -c < {path})" + "| awk '/^>/ {print \"\";next;} { printf(\"%s\",$0);}' | tail -n+2 | awk '{print length($1)}'", + shell=True, + ) + bytes_np = np.fromstring(bytes_offsets, dtype=np.int64, sep=" ") + sizes_np = np.fromstring(fasta_lengths, dtype=np.int64, sep=" ") + return bytes_np, sizes_np + + def __setstate__(self, state): + self.__dict__ = state + self.threadlocal = threading.local() + + def __getstate__(self): + d = {} + for i, v in self.__dict__.items(): + if i != "threadlocal": + d[i] = v + return d + + def __del__(self): + if hasattr(self.threadlocal, "f"): + self.threadlocal.f.close() + del self.threadlocal.f + + @staticmethod + def exists(path): + return os.path.exists(fasta_file_path(path)) + + +class EncodedFastaDataset(FastaDataset): + """ + The FastaDataset returns raw sequences - this allows us to return + indices with a dictionary instead. + """ + + def __init__(self, path, dictionary): + super().__init__(path, cache_indices=True) + self.dictionary = dictionary + + def __getitem__(self, idx): + desc, seq = super().__getitem__(idx) + return self.dictionary.encode_line(seq, line_tokenizer=list).long() diff --git a/fairseq/fairseq/data/huffman/__init__.py b/fairseq/fairseq/data/huffman/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9b61fafadba28f65fe78a28b2099368b83cfcf41 --- /dev/null +++ b/fairseq/fairseq/data/huffman/__init__.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .huffman_coder import HuffmanCodeBuilder, HuffmanCoder +from .huffman_mmap_indexed_dataset import ( + HuffmanMMapIndex, + HuffmanMMapIndexedDataset, + HuffmanMMapIndexedDatasetBuilder, + vocab_file_path, +) + +__all__ = [ + "HuffmanCoder", + "HuffmanCodeBuilder", + "HuffmanMMapIndexedDatasetBuilder", + "HuffmanMMapIndexedDataset", + "HuffmanMMapIndex", + "vocab_file_path", +] diff --git a/fairseq/fairseq/data/huffman/huffman_coder.py b/fairseq/fairseq/data/huffman/huffman_coder.py new file mode 100644 index 0000000000000000000000000000000000000000..6531f1547cbd7250aa03e0ef8c2efbac49bb1aff --- /dev/null +++ b/fairseq/fairseq/data/huffman/huffman_coder.py @@ -0,0 +1,265 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import re +import typing as tp +from collections import Counter, deque +from dataclasses import dataclass + +from bitarray import bitarray, util +from fairseq.data import Dictionary + +# basically we have to write to addressable bytes for the memory mapped +# dataset loader. Sentences that get encoded to a length that is not a +# multiple of BLOCKSIZE (a byte) will be padded to fit. (see _pad in the coder) +BLOCKSIZE = 8 + + +class HuffmanCoder: + def __init__( + self, root: "HuffmanNode", bos="<s>", pad="<pad>", eos="</s>", unk="<unk>" + ): + self.root = root + self.table = root.code_table() + self.bos_word, self.unk_word, self.pad_word, self.eos_word = bos, unk, pad, eos + + def _pad(self, a: bitarray) -> bitarray: + """ + bitpadding, 1 then 0. + + If the array is already a multiple of blocksize, we add a full block. + """ + pad_len = BLOCKSIZE - (len(a) % BLOCKSIZE) - 1 + padding = bitarray("1" + "0" * pad_len) + return a + padding + + def _unpad(self, a: bitarray) -> bitarray: + """ + remove the bitpadding. + + There will be a set of 0s preceded by a 1 at the end of the bitarray, we remove that + """ + # count the 0 padding at the end until we find the first 1 + # we want to remove the one too + remove_cnt = util.rindex(a, 1) + return a[:remove_cnt] + + def encode(self, iter: tp.List[str]) -> bytes: + """ + encode a list of tokens a return bytes. We use bitpadding to make sure the encoded bits fit in bytes. + """ + a = bitarray() + for token in iter: + code = self.get_code(token) + if code is None: + if self.unk_word is None: + raise Exception(f"unknown token {token} cannot be encoded.") + else: + token = self.unk_word + a = a + self.get_code(token) + return self._pad(a).tobytes() + + def decode(self, bits: bytes) -> tp.Iterator["HuffmanNode"]: + """ + take bitpadded bytes and decode it to a set of leaves. You can then use each node to find the symbol/id + """ + a = bitarray() + a.frombytes(bits) + return self.root.decode(self._unpad(a)) + + def get_code(self, symbol: str) -> tp.Optional[bitarray]: + node = self.get_node(symbol) + return None if node is None else node.code + + def get_node(self, symbol: str) -> "HuffmanNode": + return self.table.get(symbol) + + @classmethod + def from_file( + cls, + filename: str, + bos="<s>", + pad="<pad>", + eos="</s>", + unk="<unk>", + ) -> "HuffmanCoder": + builder = HuffmanCodeBuilder.from_file(filename) + return builder.build_code(bos=bos, pad=pad, eos=eos, unk=unk) + + def to_file(self, filename, sep="\t"): + nodes = list(self.table.values()) + nodes.sort(key=lambda n: n.id) + with open(filename, "w", encoding="utf-8") as output: + for n in nodes: + output.write(f"{n.symbol}{sep}{n.count}\n") + + def __iter__(self): + for n in self.table.values(): + yield n + + def merge(self, other_coder: "HuffmanCoder") -> "HuffmanCoder": + builder = HuffmanCodeBuilder() + for n in self: + builder.increment(n.symbol, n.count) + for n in other_coder: + builder.increment(n.symbol, n.count) + return builder.build_code() + + def __eq__(self, other: "HuffmanCoder") -> bool: + return self.table == other.table + + def __len__(self) -> int: + return len(self.table) + + def __contains__(self, sym: str) -> bool: + return sym in self.table + + def to_dictionary(self) -> Dictionary: + dictionary = Dictionary(bos=self.bos, unk=self.unk, pad=self.pad, eos=self.eos) + for n in self: + dictionary.add_symbol(n.symbol, n=n.count) + dictionary.finalize() + return dictionary + + +@dataclass +class HuffmanNode: + """ + a node in a Huffman tree + """ + + id: int + count: int + symbol: tp.Optional[str] = None + left: tp.Optional["HuffmanNode"] = None + right: tp.Optional["HuffmanNode"] = None + code: tp.Optional[bitarray] = None + + def is_leaf(self) -> bool: + return self.left is None and self.right is None + + def code_table(self, prefix: tp.Optional[bitarray] = None) -> tp.Dict[str, "HuffmanNode"]: + defaulted_prefix = prefix if prefix is not None else bitarray() + if self.is_leaf(): + self.code = ( + defaulted_prefix if len(defaulted_prefix) > 0 else bitarray("0") + ) # leaf could be the root if there is only one symbol + return {self.symbol: self} + + codes_right = self.right.code_table(defaulted_prefix + bitarray([0])) + codes_left = self.left.code_table(defaulted_prefix + bitarray([1])) + return {**codes_left, **codes_right} + + def decode(self, bits: bitarray) -> tp.Iterator["HuffmanNode"]: + current_node = self + for bit in bits: + if bit == 0: # go right + current_node = current_node.right + else: # go left + current_node = current_node.left + if current_node is None: + # we shouldn't be on a leaf here + raise Exception("fell off a leaf") + if current_node.is_leaf(): + yield current_node + current_node = self + if current_node != self: + raise Exception("couldn't decode all the bits") + + +class HuffmanCodeBuilder: + """ + build a dictionary with occurence count and then build the Huffman code for it. + """ + + def __init__(self): + self.symbols = Counter() + + def add_symbols(self, *syms) -> None: + self.symbols.update(syms) + + def increment(self, symbol: str, cnt: int) -> None: + self.symbols[symbol] += cnt + + @classmethod + def from_file(cls, filename): + c = cls() + with open(filename, "r", encoding="utf-8") as input: + for line in input: + split = re.split(r"[\s]+", line) + c.increment(split[0], int(split[1])) + return c + + def to_file(self, filename, sep="\t"): + with open(filename, "w", encoding="utf-8") as output: + for (tok, cnt) in self.symbols.most_common(): + output.write(f"{tok}{sep}{cnt}\n") + + def _smallest(self, q1: deque, q2: deque) -> HuffmanNode: + if len(q1) == 0: + return q2.pop() + + if len(q2) == 0: + return q1.pop() + + if q1[-1].count < q2[-1].count: + return q1.pop() + + return q2.pop() + + def __add__(self, c: "HuffmanCodeBuilder") -> "HuffmanCodeBuilder": + new_c = self.symbols + c.symbols + new_b = HuffmanCodeBuilder() + new_b.symbols = new_c + return new_b + + def build_code( + self, + bos="<s>", + pad="<pad>", + eos="</s>", + unk="<unk>", + ) -> HuffmanCoder: + assert len(self.symbols) > 0, "cannot build code from empty list of symbols" + + if self.symbols[bos] == 0: + self.add_symbols(bos) + if self.symbols[pad] == 0: + self.add_symbols(pad) + if self.symbols[eos] == 0: + self.add_symbols(eos) + if self.symbols[unk] == 0: + self.add_symbols(unk) + + node_id = 0 + leaves_queue = deque( + [ + HuffmanNode(symbol=symbol, count=count, id=idx) + for idx, (symbol, count) in enumerate(self.symbols.most_common()) + ] + ) # left are the most common, right are the least common + + if len(leaves_queue) == 1: + root = leaves_queue.pop() + root.id = 0 + return HuffmanCoder(root) + + nodes_queue = deque() + + while len(leaves_queue) > 0 or len(nodes_queue) != 1: + # get the lowest two nodes at the head of each queue + node1 = self._smallest(leaves_queue, nodes_queue) + node2 = self._smallest(leaves_queue, nodes_queue) + + # add new node + nodes_queue.appendleft( + HuffmanNode( + count=node1.count + node2.count, left=node1, right=node2, id=node_id + ) + ) + node_id += 1 + + # we are left with the root + return HuffmanCoder(nodes_queue.pop(), bos=bos, pad=pad, eos=eos, unk=unk) diff --git a/fairseq/fairseq/data/huffman/huffman_mmap_indexed_dataset.py b/fairseq/fairseq/data/huffman/huffman_mmap_indexed_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..3279dae89a8bca95178bbe1285d3cb334890b12f --- /dev/null +++ b/fairseq/fairseq/data/huffman/huffman_mmap_indexed_dataset.py @@ -0,0 +1,287 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import mmap +import os +import shutil +import struct +import typing as tp +from functools import lru_cache + +import numpy as np +import torch +from fairseq.data import indexed_dataset +from fairseq.data.huffman import HuffmanCoder +from fairseq.file_io import PathManager + + +class HuffmanMMapIndex: + """ + keep an index of the offsets in the huffman binary file. + First a header, then the list of sizes (num tokens) for each instance and finally + the addresses of each instance. + """ + + _HDR_MAGIC = b"HUFFIDX\x00\x00" + _VERSION = 1 + + @classmethod + def writer(cls, path: str, data_len: int): + class _Writer: + def __enter__(self): + self._file = open(path, "wb") + + # write header (magic + version) + self._file.write(cls._HDR_MAGIC) + self._file.write(struct.pack("<Q", cls._VERSION)) + self._file.write(struct.pack("<Q", data_len)) + + return self + + def write(self, sizes, pointers): + # add number of items in the index to the header + self._file.write(struct.pack("<Q", len(sizes))) + + # write sizes + sizes = np.array(sizes, dtype=np.int32) + self._file.write(sizes.tobytes(order="C")) + del sizes + + # write address pointers + pointers = np.array(pointers, dtype=np.int64) + self._file.write(pointers.tobytes(order="C")) + del pointers + + def __exit__(self, exc_type, exc_val, exc_tb): + self._file.close() + + return _Writer() + + def __init__(self, path): + with open(path, "rb") as stream: + # read headers + magic_test = stream.read(9) + assert self._HDR_MAGIC == magic_test, ( + "Index file doesn't match expected format. " + "Make sure that --dataset-impl is configured properly." + ) + (version,) = struct.unpack("<Q", stream.read(8)) + assert ( + self._VERSION == version + ), "Unexpected file version f{version} != code version f{self._VERSION}" + + # read length of data file + (self._data_len,) = struct.unpack("<Q", stream.read(8)) + # read number of items in data file/index + (self._len,) = struct.unpack("<Q", stream.read(8)) + offset = stream.tell() + + indexed_dataset._warmup_mmap_file(path) + + self._bin_buffer_mmap = np.memmap(path, mode="r", order="C") + self._bin_buffer = memoryview(self._bin_buffer_mmap) + self._sizes = np.frombuffer( + self._bin_buffer, dtype=np.int32, count=self._len, offset=offset + ) + self._pointers = np.frombuffer( + self._bin_buffer, + dtype=np.int64, + count=self._len, + offset=offset + self._sizes.nbytes, + ) + + def __del__(self): + self._bin_buffer_mmap._mmap.close() + del self._bin_buffer_mmap + + def __iter__(self): + for i in range(self._len): + yield self[i] + + @property + def data_len(self): + return self._data_len + + @property + def sizes(self): + return self._sizes + + @lru_cache(maxsize=8) + def __getitem__(self, i): + return self._pointers[i], self._sizes[i] + + def __len__(self): + return self._len + + +def vocab_file_path(prefix_path): + return prefix_path + ".vocab" + + +class HuffmanMMapIndexedDataset(torch.utils.data.Dataset): + """ + an indexed dataset that use mmap and memoryview to access data from disk + that was compressed with a HuffmanCoder. + """ + + def __init__(self, prefix_path): + super().__init__() + + self._prefix_path = None + self._index = None + self._bin_buffer = None + self._coder = None + self._file = None + + self._bin_buffer_mmap = None + + self._do_init(prefix_path) + + def __getstate__(self): + return self._prefix_path + + def __setstate__(self, state): + self._do_init(state) + + def _do_init(self, prefix_path): + self._prefix_path = prefix_path + self._index = HuffmanMMapIndex( + indexed_dataset.index_file_path(self._prefix_path) + ) + self._coder = HuffmanCoder.from_file(vocab_file_path(self._prefix_path)) + + indexed_dataset._warmup_mmap_file( + indexed_dataset.data_file_path(self._prefix_path) + ) + self._file = os.open( + indexed_dataset.data_file_path(self._prefix_path), os.O_RDONLY + ) + self._bin_buffer_mmap = mmap.mmap( + self._file, + self._index.data_len, + access=mmap.ACCESS_READ, + ) + self._bin_buffer = memoryview(self._bin_buffer_mmap) + + def __del__(self): + del self._bin_buffer + if self._file: + os.close(self._file) + del self._index + + def __len__(self): + return len(self._index) + + def _decode(self, i): + ptr, _ = self._index[i] + if i == 0: + raw_bytes = self._bin_buffer[:ptr] + else: + (prev_ptr, _) = self._index[i - 1] + raw_bytes = self._bin_buffer[prev_ptr:ptr] + + return self._coder.decode(raw_bytes.tobytes()) + + @lru_cache(maxsize=8) + def __getitem__(self, i): + nodes = self._decode(i) + return torch.tensor([n.id for n in nodes], dtype=torch.int64) + + def __iter__(self): + for idx in range(len(self)): + yield self[idx] + + def get_symbols(self, i): + nodes = self._decode(i) + for n in nodes: + yield n.symbol + + @property + def sizes(self): + return self._index.sizes + + @property + def supports_prefetch(self): + return False + + @property + def coder(self): + return self._coder + + @staticmethod + def exists(prefix_path): + return ( + PathManager.exists(indexed_dataset.index_file_path(prefix_path)) + and PathManager.exists(indexed_dataset.data_file_path(prefix_path)) + and PathManager.exists(vocab_file_path(prefix_path)) + ) + + +class HuffmanMMapIndexedDatasetBuilder: + """ + Helper to build a memory mapped datasets with a huffman encoder. + You can either open/close this manually or use it as a ContextManager. + Provide your own coder, it will then be stored alongside the dataset. + The builder will first write the vocab file, then open the binary file so you can stream + into it, finally the index will be written when the builder is closed (your index should fit in memory). + """ + + def __init__(self, path_prefix: str, coder: HuffmanCoder) -> None: + self._path_prefix = path_prefix + self._coder = coder + self._sizes = [] + self._ptrs = [] + self._data_len = 0 + + def open(self): + self._coder.to_file(vocab_file_path(self._path_prefix)) + self._data_file = open(indexed_dataset.data_file_path(self._path_prefix), "wb") + + def __enter__(self) -> "HuffmanMMapIndexedDatasetBuilder": + self.open() + return self + + def add_item(self, tokens: tp.List[str]) -> None: + """ + add a list of tokens to the dataset, they will compressed with the + provided coder before being written to file. + """ + encoded = self._coder.encode(tokens) + code_len = len(encoded) + last_ptr = 0 + if len(self._ptrs) > 0: + last_ptr = self._ptrs[-1] + self._sizes.append(len(tokens)) + self._ptrs.append(last_ptr + code_len) + self._data_len += code_len + self._data_file.write(encoded) + + def append(self, other_dataset_path_prefix: str) -> None: + """ + append an existing dataset. + Beware, if it wasn't built with the same coder, you are in trouble. + """ + other_index = HuffmanMMapIndex( + indexed_dataset.index_file_path(other_dataset_path_prefix) + ) + for (ptr, size) in other_index: + self._ptrs.append(ptr + self._data_len) + self._sizes.append(size) + + # Concatenate data + with open(indexed_dataset.data_file_path(other_dataset_path_prefix), "rb") as f: + shutil.copyfileobj(f, self._data_file) + + self._data_len += other_index.data_len + + def close(self): + self._data_file.close() + with HuffmanMMapIndex.writer( + indexed_dataset.index_file_path(self._path_prefix), self._data_len + ) as index: + index.write(self._sizes, self._ptrs) + + def __exit__(self, exc_type, exc_val, exc_tb) -> None: + self.close() diff --git a/fairseq/fairseq/data/id_dataset.py b/fairseq/fairseq/data/id_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..3e4d7969cf2a26e852b466f165a6fadabae3b35f --- /dev/null +++ b/fairseq/fairseq/data/id_dataset.py @@ -0,0 +1,19 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import FairseqDataset + + +class IdDataset(FairseqDataset): + def __getitem__(self, index): + return index + + def __len__(self): + return 0 + + def collater(self, samples): + return torch.tensor(samples) diff --git a/fairseq/fairseq/data/indexed_dataset.py b/fairseq/fairseq/data/indexed_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..23afb43356557d65c0e8f441ff9cdc890136ddbf --- /dev/null +++ b/fairseq/fairseq/data/indexed_dataset.py @@ -0,0 +1,585 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import shutil +import struct +from functools import lru_cache + +import numpy as np +import torch +from fairseq.dataclass.constants import DATASET_IMPL_CHOICES +from fairseq.data.fasta_dataset import FastaDataset +from fairseq.file_io import PathManager +from fairseq.data.huffman import HuffmanMMapIndexedDataset, HuffmanMMapIndex + +from . import FairseqDataset + +from typing import Union + + +def best_fitting_int_dtype( + max_int_to_represent, +) -> Union[np.uint16, np.uint32, np.int64]: + + if max_int_to_represent is None: + return np.uint32 # Safe guess + elif max_int_to_represent < 65500: + return np.uint16 + elif max_int_to_represent < 4294967295: + return np.uint32 + else: + return np.int64 + # we avoid np.uint64 because it doesn't save space and its type promotion behaves unexpectedly + # https://github.com/numpy/numpy/issues/5745 + + +def get_available_dataset_impl(): + return list(map(str, DATASET_IMPL_CHOICES)) + + +def infer_dataset_impl(path): + if IndexedRawTextDataset.exists(path): + return "raw" + elif IndexedDataset.exists(path): + with open(index_file_path(path), "rb") as f: + magic = f.read(8) + if magic == IndexedDataset._HDR_MAGIC: + return "cached" + elif magic == MMapIndexedDataset.Index._HDR_MAGIC[:8]: + return "mmap" + elif magic == HuffmanMMapIndex._HDR_MAGIC[:8]: + return "huffman" + else: + return None + elif FastaDataset.exists(path): + return "fasta" + else: + return None + + +def make_builder(out_file, impl, vocab_size=None): + if impl == "mmap": + return MMapIndexedDatasetBuilder( + out_file, dtype=best_fitting_int_dtype(vocab_size) + ) + elif impl == "fasta": + raise NotImplementedError + elif impl == "huffman": + raise ValueError("Use HuffmanCodeBuilder directly as it has a different interface.") + else: + return IndexedDatasetBuilder(out_file) + + +def make_dataset(path, impl, fix_lua_indexing=False, dictionary=None): + if impl == "raw" and IndexedRawTextDataset.exists(path): + assert dictionary is not None + return IndexedRawTextDataset(path, dictionary) + elif impl == "lazy" and IndexedDataset.exists(path): + return IndexedDataset(path, fix_lua_indexing=fix_lua_indexing) + elif impl == "cached" and IndexedDataset.exists(path): + return IndexedCachedDataset(path, fix_lua_indexing=fix_lua_indexing) + elif impl == "mmap" and MMapIndexedDataset.exists(path): + return MMapIndexedDataset(path) + elif impl == "fasta" and FastaDataset.exists(path): + from fairseq.data.fasta_dataset import EncodedFastaDataset + + return EncodedFastaDataset(path, dictionary) + elif impl == "huffman" and HuffmanMMapIndexedDataset.exists(path): + return HuffmanMMapIndexedDataset(path) + return None + + +def dataset_exists(path, impl): + if impl == "raw": + return IndexedRawTextDataset.exists(path) + elif impl == "mmap": + return MMapIndexedDataset.exists(path) + elif impl == "huffman": + return HuffmanMMapIndexedDataset.exists(path) + else: + return IndexedDataset.exists(path) + + +def read_longs(f, n): + a = np.empty(n, dtype=np.int64) + f.readinto(a) + return a + + +def write_longs(f, a): + f.write(np.array(a, dtype=np.int64)) + + +_code_to_dtype = { + 1: np.uint8, + 2: np.int8, + 3: np.int16, + 4: np.int32, + 5: np.int64, + 6: np.float, + 7: np.double, + 8: np.uint16, + 9: np.uint32, + 10: np.uint64, +} + + +def _dtype_header_code(dtype) -> int: + for k in _code_to_dtype.keys(): + if _code_to_dtype[k] == dtype: + return k + raise ValueError(dtype) + + +def index_file_path(prefix_path): + return prefix_path + ".idx" + + +def data_file_path(prefix_path): + return prefix_path + ".bin" + + +class IndexedDataset(FairseqDataset): + """Loader for TorchNet IndexedDataset""" + + _HDR_MAGIC = b"TNTIDX\x00\x00" + + def __init__(self, path, fix_lua_indexing=False): + super().__init__() + self.path = path + self.fix_lua_indexing = fix_lua_indexing + self.data_file = None + self.read_index(path) + + def read_index(self, path): + with open(index_file_path(path), "rb") as f: + magic = f.read(8) + assert magic == self._HDR_MAGIC, ( + "Index file doesn't match expected format. " + "Make sure that --dataset-impl is configured properly." + ) + version = f.read(8) + assert struct.unpack("<Q", version) == (1,) + code, self.element_size = struct.unpack("<QQ", f.read(16)) + self.dtype = _code_to_dtype[code] + self._len, self.s = struct.unpack("<QQ", f.read(16)) + self.dim_offsets = read_longs(f, self._len + 1) + self.data_offsets = read_longs(f, self._len + 1) + self.sizes = read_longs(f, self.s) + + def read_data(self, path): + self.data_file = open(data_file_path(path), "rb", buffering=0) + + def check_index(self, i): + if i < 0 or i >= self._len: + raise IndexError("index out of range") + + def __del__(self): + if self.data_file: + self.data_file.close() + + @lru_cache(maxsize=8) + def __getitem__(self, i) -> torch.Tensor: + if not self.data_file: + self.read_data(self.path) + self.check_index(i) + tensor_size = self.sizes[self.dim_offsets[i] : self.dim_offsets[i + 1]] + a = np.empty(tensor_size, dtype=self.dtype) + self.data_file.seek(self.data_offsets[i] * self.element_size) + self.data_file.readinto(a) + item = torch.from_numpy(a).long() + if self.fix_lua_indexing: + item -= 1 # subtract 1 for 0-based indexing + return item + + def __len__(self): + return self._len + + def num_tokens(self, index): + return self.sizes[index] + + def size(self, index): + return self.sizes[index] + + @staticmethod + def exists(path): + return PathManager.exists(index_file_path(path)) and PathManager.exists( + data_file_path(path) + ) + + @property + def supports_prefetch(self): + return False # avoid prefetching to save memory + + +class IndexedCachedDataset(IndexedDataset): + def __init__(self, path, fix_lua_indexing=False): + super().__init__(path, fix_lua_indexing=fix_lua_indexing) + self.cache = None + self.cache_index = {} + + @property + def supports_prefetch(self): + return True + + def prefetch(self, indices): + if all(i in self.cache_index for i in indices): + return + if not self.data_file: + self.read_data(self.path) + indices = sorted(set(indices)) + total_size = 0 + for i in indices: + total_size += self.data_offsets[i + 1] - self.data_offsets[i] + self.cache = np.empty(total_size, dtype=self.dtype) + ptx = 0 + self.cache_index.clear() + for i in indices: + self.cache_index[i] = ptx + size = self.data_offsets[i + 1] - self.data_offsets[i] + a = self.cache[ptx : ptx + size] + self.data_file.seek(self.data_offsets[i] * self.element_size) + self.data_file.readinto(a) + ptx += size + if self.data_file: + # close and delete data file after prefetch so we can pickle + self.data_file.close() + self.data_file = None + + @lru_cache(maxsize=8) + def __getitem__(self, i): + self.check_index(i) + tensor_size = self.sizes[self.dim_offsets[i] : self.dim_offsets[i + 1]] + a = np.empty(tensor_size, dtype=self.dtype) + ptx = self.cache_index[i] + np.copyto(a, self.cache[ptx : ptx + a.size]) + item = torch.from_numpy(a).long() + if self.fix_lua_indexing: + item -= 1 # subtract 1 for 0-based indexing + return item + + +class IndexedRawTextDataset(FairseqDataset): + """Takes a text file as input and binarizes it in memory at instantiation. + Original lines are also kept in memory""" + + def __init__(self, path, dictionary, append_eos=True, reverse_order=False): + self.tokens_list = [] + self.lines = [] + self.sizes = [] + self.append_eos = append_eos + self.reverse_order = reverse_order + self.read_data(path, dictionary) + self.size = len(self.tokens_list) + + def read_data(self, path, dictionary): + with open(path, "r", encoding="utf-8") as f: + for line in f: + self.lines.append(line.strip("\n")) + tokens = dictionary.encode_line( + line, + add_if_not_exist=False, + append_eos=self.append_eos, + reverse_order=self.reverse_order, + ).long() + self.tokens_list.append(tokens) + self.sizes.append(len(tokens)) + self.sizes = np.array(self.sizes) + + def check_index(self, i): + if i < 0 or i >= self.size: + raise IndexError("index out of range") + + @lru_cache(maxsize=8) + def __getitem__(self, i): + self.check_index(i) + return self.tokens_list[i] + + def get_original_text(self, i): + self.check_index(i) + return self.lines[i] + + def __del__(self): + pass + + def __len__(self): + return self.size + + def num_tokens(self, index): + return self.sizes[index] + + def size(self, index): + return self.sizes[index] + + @staticmethod + def exists(path): + return PathManager.exists(path) + + +class IndexedDatasetBuilder: + element_sizes = { + np.uint8: 1, + np.int8: 1, + np.int16: 2, + np.int32: 4, + np.int64: 8, + np.float: 4, + np.double: 8, + } + + def __init__(self, out_file, dtype=np.int32): + self.out_file = open(out_file, "wb") + self.dtype = dtype + self.data_offsets = [0] + self.dim_offsets = [0] + self.sizes = [] + self.element_size = self.element_sizes[self.dtype] + + def add_item(self, tensor): + # +1 for Lua compatibility + bytes = self.out_file.write(np.array(tensor.numpy() + 1, dtype=self.dtype)) + self.data_offsets.append(self.data_offsets[-1] + bytes / self.element_size) + for s in tensor.size(): + self.sizes.append(s) + self.dim_offsets.append(self.dim_offsets[-1] + len(tensor.size())) + + def merge_file_(self, another_file): + index = IndexedDataset(another_file) + assert index.dtype == self.dtype + + begin = self.data_offsets[-1] + for offset in index.data_offsets[1:]: + self.data_offsets.append(begin + offset) + self.sizes.extend(index.sizes) + begin = self.dim_offsets[-1] + for dim_offset in index.dim_offsets[1:]: + self.dim_offsets.append(begin + dim_offset) + + with open(data_file_path(another_file), "rb") as f: + while True: + data = f.read(1024) + if data: + self.out_file.write(data) + else: + break + + def finalize(self, index_file): + self.out_file.close() + index = open(index_file, "wb") + index.write(b"TNTIDX\x00\x00") + index.write(struct.pack("<Q", 1)) + index.write( + struct.pack("<QQ", _dtype_header_code(self.dtype), self.element_size) + ) + index.write(struct.pack("<QQ", len(self.data_offsets) - 1, len(self.sizes))) + write_longs(index, self.dim_offsets) + write_longs(index, self.data_offsets) + write_longs(index, self.sizes) + index.close() + + +def _warmup_mmap_file(path): + with open(path, "rb") as stream: + while stream.read(100 * 1024 * 1024): + pass + + +class MMapIndexedDataset(torch.utils.data.Dataset): + class Index: + _HDR_MAGIC = b"MMIDIDX\x00\x00" + + @classmethod + def writer(cls, path, dtype): + class _Writer: + def __enter__(self): + self._file = open(path, "wb") + + self._file.write(cls._HDR_MAGIC) + self._file.write(struct.pack("<Q", 1)) + self._file.write(struct.pack("<B", _dtype_header_code(dtype))) + + return self + + @staticmethod + def _get_pointers(sizes): + dtype_size = dtype().itemsize + address = 0 + pointers = [] + + for size in sizes: + pointers.append(address) + address += size * dtype_size + + return pointers + + def write(self, sizes): + pointers = self._get_pointers(sizes) + + self._file.write(struct.pack("<Q", len(sizes))) + + sizes = np.array(sizes, dtype=np.int32) + self._file.write(sizes.tobytes(order="C")) + del sizes + + pointers = np.array(pointers, dtype=np.int64) + self._file.write(pointers.tobytes(order="C")) + del pointers + + def __exit__(self, exc_type, exc_val, exc_tb): + self._file.close() + + return _Writer() + + def __init__(self, path): + with open(path, "rb") as stream: + magic_test = stream.read(9) + assert self._HDR_MAGIC == magic_test, ( + "Index file doesn't match expected format. " + "Make sure that --dataset-impl is configured properly." + ) + version = struct.unpack("<Q", stream.read(8)) + assert (1,) == version + + (dtype_code,) = struct.unpack("<B", stream.read(1)) + self._dtype = _code_to_dtype[dtype_code] + self._dtype_size = self._dtype().itemsize + + self._len = struct.unpack("<Q", stream.read(8))[0] + offset = stream.tell() + + _warmup_mmap_file(path) + + self._bin_buffer_mmap = np.memmap(path, mode="r", order="C") + self._bin_buffer = memoryview(self._bin_buffer_mmap) + self._sizes = np.frombuffer( + self._bin_buffer, dtype=np.int32, count=self._len, offset=offset + ) + self._pointers = np.frombuffer( + self._bin_buffer, + dtype=np.int64, + count=self._len, + offset=offset + self._sizes.nbytes, + ) + + def __del__(self): + self._bin_buffer_mmap._mmap.close() + del self._bin_buffer_mmap + + @property + def dtype(self): + return self._dtype + + @property + def sizes(self): + return self._sizes + + @lru_cache(maxsize=8) + def __getitem__(self, i): + return self._pointers[i], self._sizes[i] + + def __len__(self): + return self._len + + def __init__(self, path): + super().__init__() + + self._path = None + self._index = None + self._bin_buffer = None + + self._do_init(path) + + def __getstate__(self): + return self._path + + def __setstate__(self, state): + self._do_init(state) + + def _do_init(self, path): + self._path = path + self._index = self.Index(index_file_path(self._path)) + + _warmup_mmap_file(data_file_path(self._path)) + self._bin_buffer_mmap = np.memmap( + data_file_path(self._path), mode="r", order="C" + ) + self._bin_buffer = memoryview(self._bin_buffer_mmap) + + def __del__(self): + self._bin_buffer_mmap._mmap.close() + del self._bin_buffer_mmap + del self._index + + def __len__(self): + return len(self._index) + + @lru_cache(maxsize=8) + def __getitem__(self, i): + ptr, size = self._index[i] + np_array = np.frombuffer( + self._bin_buffer, dtype=self._index.dtype, count=size, offset=ptr + ) + if self._index.dtype != np.int64: + np_array = np_array.astype(np.int64) + + return torch.from_numpy(np_array) + + @property + def sizes(self): + return self._index.sizes + + @property + def supports_prefetch(self): + return False + + @staticmethod + def exists(path): + return PathManager.exists(index_file_path(path)) and PathManager.exists( + data_file_path(path) + ) + + +def get_indexed_dataset_to_local(path) -> str: + local_index_path = PathManager.get_local_path(index_file_path(path)) + local_data_path = PathManager.get_local_path(data_file_path(path)) + + assert local_index_path.endswith(".idx") and local_data_path.endswith(".bin"), ( + "PathManager.get_local_path does not return files with expected patterns: " + f"{local_index_path} and {local_data_path}" + ) + + local_path = local_data_path[:-4] # stripping surfix ".bin" + assert local_path == local_index_path[:-4] # stripping surfix ".idx" + return local_path + + +class MMapIndexedDatasetBuilder: + def __init__(self, out_file, dtype=np.int64): + self._data_file = open(out_file, "wb") + self._dtype = dtype + self._sizes = [] + + def add_item(self, tensor): + np_array = np.array(tensor.numpy(), dtype=self._dtype) + self._data_file.write(np_array.tobytes(order="C")) + self._sizes.append(np_array.size) + + def merge_file_(self, another_file): + # Concatenate index + index = MMapIndexedDataset.Index(index_file_path(another_file)) + assert index.dtype == self._dtype + + for size in index.sizes: + self._sizes.append(size) + + # Concatenate data + with open(data_file_path(another_file), "rb") as f: + shutil.copyfileobj(f, self._data_file) + + def finalize(self, index_file): + self._data_file.close() + + with MMapIndexedDataset.Index.writer(index_file, self._dtype) as index: + index.write(self._sizes) diff --git a/fairseq/fairseq/data/iterators.py b/fairseq/fairseq/data/iterators.py new file mode 100644 index 0000000000000000000000000000000000000000..1ce26e57e58f9006ea801e77a1437e45743a3b8b --- /dev/null +++ b/fairseq/fairseq/data/iterators.py @@ -0,0 +1,765 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools +import logging +import math +import operator +import os +import queue +import time +from threading import Thread + +import numpy as np +import torch +from fairseq.data import data_utils + + +logger = logging.getLogger(__name__) + +# Object used by _background_consumer to signal the source is exhausted +# to the main thread. +_sentinel = object() + + +class CountingIterator(object): + """Wrapper around an iterable that maintains the iteration count. + + Args: + iterable (iterable): iterable to wrap + start (int): starting iteration count. Note that this doesn't + actually advance the iterator. + total (int): override the iterator length returned by ``__len``. + This can be used to truncate *iterator*. + + Attributes: + n (int): number of elements consumed from this iterator + """ + + def __init__(self, iterable, start=None, total=None): + self._itr = iter(iterable) + self.n = start or getattr(iterable, "n", 0) + self.total = total or self.n + len(iterable) + + def __len__(self): + return self.total + + def __iter__(self): + return self + + def __next__(self): + if not self.has_next(): + raise StopIteration + try: + x = next(self._itr) + except StopIteration: + raise IndexError(f"Iterator expected to have length {self.total}, " + "but exhausted at position {self.n}.") + self.n += 1 + return x + + def has_next(self): + """Whether the iterator has been exhausted.""" + return self.n < self.total + + def skip(self, n): + """Fast-forward the iterator by skipping n elements.""" + for _ in range(n): + next(self) + return self + + def take(self, n): + """Truncate the iterator to n elements at most.""" + self.total = min(self.total, n) + # Propagate this change to the underlying iterator + if hasattr(self._itr, "take"): + self._itr.take(max(n - self.n, 0)) + return self + + +class EpochBatchIterating(object): + def __len__(self) -> int: + raise NotImplementedError + + @property + def next_epoch_idx(self): + raise NotImplementedError + + def next_epoch_itr( + self, shuffle=True, fix_batches_to_gpus=False, set_dataset_epoch=True + ): + """Return a new iterator over the dataset. + + Args: + shuffle (bool, optional): shuffle batches before returning the + iterator (default: True). + fix_batches_to_gpus (bool, optional): ensure that batches are always + allocated to the same shards across epochs. Requires + that :attr:`dataset` supports prefetching (default: False). + set_dataset_epoch (bool, optional): update the wrapped Dataset with + the new epoch number (default: True). + """ + raise NotImplementedError + + def end_of_epoch(self) -> bool: + """Returns whether the most recent epoch iterator has been exhausted""" + raise NotImplementedError + + @property + def iterations_in_epoch(self) -> int: + """The number of consumed batches in the current epoch.""" + raise NotImplementedError + + def state_dict(self): + """Returns a dictionary containing a whole state of the iterator.""" + raise NotImplementedError + + def load_state_dict(self, state_dict): + """Copies the state of the iterator from the given *state_dict*.""" + raise NotImplementedError + + @property + def first_batch(self): + return "DUMMY" + + +class StreamingEpochBatchIterator(EpochBatchIterating): + """A steaming-style iterator over a :class:`torch.utils.data.IterableDataset`. + + Args: + dataset (~torch.utils.data.Dataset): dataset from which to load the data + max_sentences: batch size + collate_fn (callable): merges a list of samples to form a mini-batch + num_workers (int, optional): how many subprocesses to use for data + loading. 0 means the data will be loaded in the main process + (default: 0). + epoch (int, optional): the epoch to start the iterator from + (default: 1). + buffer_size (int, optional): the number of batches to keep ready in the + queue. Helps speeding up dataloading. When buffer_size is zero, the + default torch.utils.data.DataLoader preloading is used. + timeout (int, optional): if positive, the timeout value for collecting a batch + from workers. Should always be non-negative (default: ``0``). + """ + + def __init__( + self, + dataset, + max_sentences=1, + collate_fn=None, + epoch=1, + num_workers=0, + buffer_size=0, + timeout=0, + ): + assert isinstance(dataset, torch.utils.data.IterableDataset) + self.dataset = dataset + self.max_sentences = max_sentences + self.collate_fn = collate_fn + self.epoch = max(epoch, 1) # we use 1-based indexing for epochs + self.num_workers = num_workers + # This upper limit here is to prevent people from abusing this feature + # in a shared computing environment. + self.buffer_size = min(buffer_size, 20) + self.timeout = timeout + + self._current_epoch_iterator = None + + @property + def next_epoch_idx(self): + """Return the epoch index after *next_epoch_itr* is called.""" + if self._current_epoch_iterator is not None and self.end_of_epoch(): + return self.epoch + 1 + else: + return self.epoch + + def next_epoch_itr( + self, shuffle=True, fix_batches_to_gpus=False, set_dataset_epoch=True + ): + self.epoch = self.next_epoch_idx + if set_dataset_epoch and hasattr(self.dataset, "set_epoch"): + self.dataset.set_epoch(self.epoch) + self._current_epoch_iterator = self._get_iterator_for_epoch(self.epoch, shuffle) + return self._current_epoch_iterator + + def end_of_epoch(self) -> bool: + return not self._current_epoch_iterator.has_next() + + @property + def iterations_in_epoch(self) -> int: + if self._current_epoch_iterator is not None: + return self._current_epoch_iterator.n + return 0 + + def state_dict(self): + return { + "epoch": self.epoch, + } + + def load_state_dict(self, state_dict): + self.epoch = state_dict["epoch"] + + def _get_iterator_for_epoch(self, epoch, shuffle, offset=0): + if self.num_workers > 0: + os.environ["PYTHONWARNINGS"] = "ignore:semaphore_tracker:UserWarning" + + # Create data loader + worker_init_fn = getattr(self.dataset, "worker_init_fn", None) + itr = torch.utils.data.DataLoader( + self.dataset, + batch_size=self.max_sentences, + collate_fn=self.collate_fn, + num_workers=self.num_workers, + timeout=self.timeout, + worker_init_fn=worker_init_fn, + pin_memory=True, + ) + + # Wrap with a BufferedIterator if needed + if self.buffer_size > 0: + itr = BufferedIterator(self.buffer_size, itr) + + # Wrap with CountingIterator + itr = CountingIterator(itr, start=offset) + + return itr + + +class EpochBatchIterator(EpochBatchIterating): + """A multi-epoch iterator over a :class:`torch.utils.data.Dataset`. + + Compared to :class:`torch.utils.data.DataLoader`, this iterator: + + - can be reused across multiple epochs with the :func:`next_epoch_itr` + method (optionally shuffled between epochs) + - can be serialized/deserialized with the :func:`state_dict` and + :func:`load_state_dict` methods + - supports sharding with the *num_shards* and *shard_id* arguments + + Args: + dataset (~torch.utils.data.Dataset): dataset from which to load the data + collate_fn (callable): merges a list of samples to form a mini-batch + batch_sampler (~torch.utils.data.Sampler or a callable): an iterator over batches of + indices, or a callable to create such an iterator (~torch.utils.data.Sampler). + A callable batch_sampler will be called for each epoch to enable per epoch dynamic + batch iterators defined by this callable batch_sampler. + seed (int, optional): seed for random number generator for + reproducibility (default: 1). + num_shards (int, optional): shard the data iterator into N + shards (default: 1). + shard_id (int, optional): which shard of the data iterator to + return (default: 0). + num_workers (int, optional): how many subprocesses to use for data + loading. 0 means the data will be loaded in the main process + (default: 0). + epoch (int, optional): the epoch to start the iterator from + (default: 1). + buffer_size (int, optional): the number of batches to keep ready in the + queue. Helps speeding up dataloading. When buffer_size is zero, the + default torch.utils.data.DataLoader preloading is used. + timeout (int, optional): if positive, the timeout value for collecting a batch + from workers. Should always be non-negative (default: ``0``). + disable_shuffling (bool, optional): force disable shuffling + (default: ``False``). + """ + + def __init__( + self, + dataset, + collate_fn, + batch_sampler, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + buffer_size=0, + timeout=0, + disable_shuffling=False, + ): + assert isinstance(dataset, torch.utils.data.Dataset) + self.dataset = dataset + self.collate_fn = collate_fn + self.batch_sampler = batch_sampler + self._frozen_batches = ( + tuple(batch_sampler) if not callable(batch_sampler) else None + ) + self.seed = seed + self.num_shards = num_shards + self.shard_id = shard_id + self.num_workers = num_workers + # This upper limit here is to prevent people from abusing this feature + # in a shared computing environment. + self.buffer_size = min(buffer_size, 20) + self.timeout = timeout + self.disable_shuffling = disable_shuffling + + self.epoch = max(epoch, 1) # we use 1-based indexing for epochs + self.shuffle = not disable_shuffling + self._cur_epoch_itr = None + self._next_epoch_itr = None + self._supports_prefetch = getattr(dataset, "supports_prefetch", False) + + @property + def frozen_batches(self): + if self._frozen_batches is None: + self._frozen_batches = tuple(self.batch_sampler(self.dataset, self.epoch)) + return self._frozen_batches + + @property + def first_batch(self): + if len(self.frozen_batches) == 0: + raise Exception( + "The dataset is empty. This could indicate " + "that all elements in the dataset have been skipped. " + "Try increasing the max number of allowed tokens or using " + "a larger dataset." + ) + + if getattr(self.dataset, "supports_fetch_outside_dataloader", True): + return self.collate_fn([self.dataset[i] for i in self.frozen_batches[0]]) + else: + return "DUMMY" + + def __len__(self): + return int(math.ceil(len(self.frozen_batches) / float(self.num_shards))) + + @property + def n(self): + return self.iterations_in_epoch + + @property + def next_epoch_idx(self): + """Return the epoch index after *next_epoch_itr* is called.""" + if self._next_epoch_itr is not None: + return self.epoch + elif self._cur_epoch_itr is not None and self.end_of_epoch(): + return self.epoch + 1 + else: + return self.epoch + + def next_epoch_itr( + self, shuffle=True, fix_batches_to_gpus=False, set_dataset_epoch=True + ): + """Return a new iterator over the dataset. + + Args: + shuffle (bool, optional): shuffle batches before returning the + iterator (default: True). + fix_batches_to_gpus (bool, optional): ensure that batches are always + allocated to the same shards across epochs. Requires + that :attr:`dataset` supports prefetching (default: False). + set_dataset_epoch (bool, optional): update the wrapped Dataset with + the new epoch number (default: True). + """ + if self.disable_shuffling: + shuffle = False + prev_epoch = self.epoch + self.epoch = self.next_epoch_idx + if set_dataset_epoch and hasattr(self.dataset, "set_epoch"): + self.dataset.set_epoch(self.epoch) + if self._next_epoch_itr is not None: + self._cur_epoch_itr = self._next_epoch_itr + self._next_epoch_itr = None + else: + if callable(self.batch_sampler) and prev_epoch != self.epoch: + # reset _frozen_batches to refresh the next epoch + self._frozen_batches = None + self._cur_epoch_itr = self._get_iterator_for_epoch( + self.epoch, + shuffle, + fix_batches_to_gpus=fix_batches_to_gpus, + ) + self.shuffle = shuffle + return self._cur_epoch_itr + + def end_of_epoch(self) -> bool: + """Returns whether the most recent epoch iterator has been exhausted""" + return not self._cur_epoch_itr.has_next() + + @property + def iterations_in_epoch(self): + """The number of consumed batches in the current epoch.""" + if self._cur_epoch_itr is not None: + return self._cur_epoch_itr.n + elif self._next_epoch_itr is not None: + return self._next_epoch_itr.n + return 0 + + def state_dict(self): + """Returns a dictionary containing a whole state of the iterator.""" + if self.end_of_epoch(): + epoch = self.epoch + 1 + iter_in_epoch = 0 + else: + epoch = self.epoch + iter_in_epoch = self.iterations_in_epoch + return { + "version": 2, + "epoch": epoch, + "iterations_in_epoch": iter_in_epoch, + "shuffle": self.shuffle, + } + + def load_state_dict(self, state_dict): + """Copies the state of the iterator from the given *state_dict*.""" + self.epoch = state_dict["epoch"] + itr_pos = state_dict.get("iterations_in_epoch", 0) + version = state_dict.get("version", 1) + if itr_pos > 0: + # fast-forward epoch iterator + self._next_epoch_itr = self._get_iterator_for_epoch( + self.epoch, + shuffle=state_dict.get("shuffle", True), + offset=itr_pos, + ) + if self._next_epoch_itr is None: + if version == 1: + # legacy behavior: we finished the epoch, increment epoch counter + self.epoch += 1 + else: + raise RuntimeError( + "Cannot resume training due to dataloader mismatch, please " + "report this to the fairseq developers. You can relaunch " + "training with `--reset-dataloader` and it should work." + ) + else: + self._next_epoch_itr = None + + def _get_iterator_for_epoch( + self, epoch, shuffle, fix_batches_to_gpus=False, offset=0 + ): + def shuffle_batches(batches, seed): + with data_utils.numpy_seed(seed): + np.random.shuffle(batches) + return batches + + if self._supports_prefetch: + batches = self.frozen_batches + + if shuffle and not fix_batches_to_gpus: + batches = shuffle_batches(list(batches), self.seed + epoch) + + batches = list( + ShardedIterator(batches, self.num_shards, self.shard_id, fill_value=[]) + ) + self.dataset.prefetch([i for s in batches for i in s]) + + if shuffle and fix_batches_to_gpus: + batches = shuffle_batches(batches, self.seed + epoch + self.shard_id) + else: + if shuffle: + batches = shuffle_batches(list(self.frozen_batches), self.seed + epoch) + else: + batches = self.frozen_batches + batches = list( + ShardedIterator(batches, self.num_shards, self.shard_id, fill_value=[]) + ) + + if offset > 0 and offset >= len(batches): + return None + + if self.num_workers > 0: + os.environ["PYTHONWARNINGS"] = "ignore:semaphore_tracker:UserWarning" + + # Create data loader + itr = torch.utils.data.DataLoader( + self.dataset, + collate_fn=self.collate_fn, + batch_sampler=batches[offset:], + num_workers=self.num_workers, + timeout=self.timeout, + pin_memory=True, + ) + + # Wrap with a BufferedIterator if needed + if self.buffer_size > 0: + itr = BufferedIterator(self.buffer_size, itr) + + # Wrap with CountingIterator + itr = CountingIterator(itr, start=offset) + return itr + + +class GroupedIterator(CountingIterator): + """Wrapper around an iterable that returns groups (chunks) of items. + + Args: + iterable (iterable): iterable to wrap + chunk_size (int): size of each chunk + + Attributes: + n (int): number of elements consumed from this iterator + """ + + def __init__(self, iterable, chunk_size): + itr = _chunk_iterator(iterable, chunk_size) + super().__init__( + itr, + start=int(math.ceil(getattr(iterable, "n", 0) / float(chunk_size))), + total=int(math.ceil(len(iterable) / float(chunk_size))), + ) + self.chunk_size = chunk_size + + +def _chunk_iterator(itr, chunk_size): + chunk = [] + for x in itr: + chunk.append(x) + if len(chunk) == chunk_size: + yield chunk + chunk = [] + if len(chunk) > 0: + yield chunk + + +class ShardedIterator(CountingIterator): + """A sharded wrapper around an iterable, padded to length. + + Args: + iterable (iterable): iterable to wrap + num_shards (int): number of shards to split the iterable into + shard_id (int): which shard to iterator over + fill_value (Any, optional): padding value when the iterable doesn't + evenly divide *num_shards* (default: None). + + Attributes: + n (int): number of elements consumed from this iterator + """ + + def __init__(self, iterable, num_shards, shard_id, fill_value=None): + if shard_id < 0 or shard_id >= num_shards: + raise ValueError("shard_id must be between 0 and num_shards") + sharded_len = int(math.ceil(len(iterable) / float(num_shards))) + itr = map( + operator.itemgetter(1), + itertools.zip_longest( + range(sharded_len), + itertools.islice(iterable, shard_id, len(iterable), num_shards), + fillvalue=fill_value, + ), + ) + super().__init__( + itr, + start=int(math.ceil(getattr(iterable, "n", 0) / float(num_shards))), + total=sharded_len, + ) + + +class BackgroundConsumer(Thread): + def __init__(self, queue, source, max_len, cuda_device): + Thread.__init__(self) + + self._queue = queue + self._source = source + self._max_len = max_len + self.count = 0 + self.cuda_device = cuda_device + + def run(self): + # set_device to avoid creation of GPU0 context when using pin_memory + if self.cuda_device is not None: + torch.cuda.set_device(self.cuda_device) + + try: + for item in self._source: + self._queue.put(item) + + # Stop if we reached the maximum length + self.count += 1 + if self._max_len is not None and self.count >= self._max_len: + break + + # Signal the consumer we are done. + self._queue.put(_sentinel) + except Exception as e: + self._queue.put(e) + + +class BufferedIterator(object): + def __init__(self, size, iterable): + self._queue = queue.Queue(size) + self._iterable = iterable + self._consumer = None + + self.start_time = time.time() + self.warning_time = None + + self.total = len(iterable) + + def _create_consumer(self): + self._consumer = BackgroundConsumer( + self._queue, + self._iterable, + self.total, + torch.cuda.current_device() if torch.cuda.is_available() else None + ) + self._consumer.daemon = True + self._consumer.start() + + def __iter__(self): + return self + + def __len__(self): + return self.total + + def take(self, n): + self.total = min(self.total, n) + # Propagate this change to the underlying iterator + if hasattr(self._iterable, "take"): + self._iterable.take(n) + return self + + def __next__(self): + # Create consumer if not created yet + if self._consumer is None: + self._create_consumer() + + # Notify the user if there is a data loading bottleneck + if self._queue.qsize() < min(2, max(1, self._queue.maxsize // 2)): + if time.time() - self.start_time > 5 * 60: + if ( + self.warning_time is None + or time.time() - self.warning_time > 15 * 60 + ): + logger.debug( + "Data loading buffer is empty or nearly empty. This may " + "indicate a data loading bottleneck, and increasing the " + "number of workers (--num-workers) may help." + ) + self.warning_time = time.time() + + # Get next example + item = self._queue.get(True) + if isinstance(item, Exception): + raise item + if item is _sentinel: + raise StopIteration() + return item + +class GroupedEpochBatchIterator(EpochBatchIterator): + """Grouped version of EpochBatchIterator + It takes several samplers from different datasets. + Each epoch shuffle the dataset wise sampler individually with different + random seed. The those sub samplers are combined with into + one big samplers with deterministic permutation to mix batches from + different datasets. It will act like EpochBatchIterator but make sure + 1) data from one data set each time + 2) for different workers, they use the same order to fetch the data + so they will use data from the same dataset everytime + mult_rate is used for update_freq > 1 case where we want to make sure update_freq + mini-batches come from same source + """ + + def __init__( + self, + dataset, + collate_fn, + batch_samplers, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=0, + mult_rate=1, + buffer_size=0, + ): + super().__init__( + dataset, + collate_fn, + batch_samplers, + seed, + num_shards, + shard_id, + num_workers, + epoch, + buffer_size, + ) + # level 0: sub-samplers 1: batch_idx 2: batches + self._frozen_batches = tuple([tuple(sub_batch) for sub_batch in batch_samplers]) + self.step_size = mult_rate * num_shards + + self.lengths = [ + (len(x) // self.step_size) * self.step_size for x in self.frozen_batches + ] + + def __len__(self): + return sum(self.lengths) + + @property + def first_batch(self): + if len(self.frozen_batches) == 0: + raise Exception( + "The dataset is empty. This could indicate " + "that all elements in the dataset have been skipped. " + "Try increasing the max number of allowed tokens or using " + "a larger dataset." + ) + + if self.dataset.supports_fetch_outside_dataloader: + return self.collate_fn([self.dataset[i] for i in self.frozen_batches[0][0]]) + else: + return "DUMMY" + + def _get_iterator_for_epoch( + self, epoch, shuffle, fix_batches_to_gpus=False, offset=0 + ): + def shuffle_batches(batches, seed): + with data_utils.numpy_seed(seed): + np.random.shuffle(batches) + return batches + + def return_full_batches(batch_sets, seed, shuffle): + if shuffle: + batch_sets = [shuffle_batches(list(x), seed) for x in batch_sets] + + batch_sets = [ + batch_sets[i][: self.lengths[i]] for i in range(len(batch_sets)) + ] + batches = list(itertools.chain.from_iterable(batch_sets)) + + if shuffle: + with data_utils.numpy_seed(seed): + idx = np.random.permutation(len(batches) // self.step_size) + if len(idx) * self.step_size != len(batches): + raise ValueError( + "ERROR: %d %d %d %d" + % (len(idx), self.step_size, len(batches), self.shard_id), + ":".join(["%d" % x for x in self.lengths]), + ) + mini_shards = [ + batches[i * self.step_size : (i + 1) * self.step_size] + for i in idx + ] + batches = list(itertools.chain.from_iterable(mini_shards)) + + return batches + + if self._supports_prefetch: + raise NotImplementedError("To be implemented") + else: + batches = return_full_batches( + self.frozen_batches, self.seed + epoch, shuffle + ) + batches = list( + ShardedIterator(batches, self.num_shards, self.shard_id, fill_value=[]) + ) + + if offset > 0 and offset >= len(batches): + return None + + if self.num_workers > 0: + os.environ["PYTHONWARNINGS"] = "ignore:semaphore_tracker:UserWarning" + + itr = torch.utils.data.DataLoader( + self.dataset, + collate_fn=self.collate_fn, + batch_sampler=batches[offset:], + num_workers=self.num_workers, + ) + if self.buffer_size > 0: + itr = BufferedIterator(self.buffer_size, itr) + + return CountingIterator(itr, start=offset) diff --git a/fairseq/fairseq/data/language_pair_dataset.py b/fairseq/fairseq/data/language_pair_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ff3e14bf14770638524ef6067b558e455dbe5f2b --- /dev/null +++ b/fairseq/fairseq/data/language_pair_dataset.py @@ -0,0 +1,471 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import numpy as np +import torch +from fairseq.data import FairseqDataset, data_utils + + +logger = logging.getLogger(__name__) + + +def collate( + samples, + pad_idx, + eos_idx, + left_pad_source=True, + left_pad_target=False, + input_feeding=True, + pad_to_length=None, + pad_to_multiple=1, +): + if len(samples) == 0: + return {} + + def merge(key, left_pad, move_eos_to_beginning=False, pad_to_length=None): + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx, + left_pad, + move_eos_to_beginning, + pad_to_length=pad_to_length, + pad_to_multiple=pad_to_multiple, + ) + + def check_alignment(alignment, src_len, tgt_len): + if alignment is None or len(alignment) == 0: + return False + if ( + alignment[:, 0].max().item() >= src_len - 1 + or alignment[:, 1].max().item() >= tgt_len - 1 + ): + logger.warning("alignment size mismatch found, skipping alignment!") + return False + return True + + def compute_alignment_weights(alignments): + """ + Given a tensor of shape [:, 2] containing the source-target indices + corresponding to the alignments, a weight vector containing the + inverse frequency of each target index is computed. + For e.g. if alignments = [[5, 7], [2, 3], [1, 3], [4, 2]], then + a tensor containing [1., 0.5, 0.5, 1] should be returned (since target + index 3 is repeated twice) + """ + align_tgt = alignments[:, 1] + _, align_tgt_i, align_tgt_c = torch.unique( + align_tgt, return_inverse=True, return_counts=True + ) + align_weights = align_tgt_c[align_tgt_i[np.arange(len(align_tgt))]] + return 1.0 / align_weights.float() + + id = torch.LongTensor([s["id"] for s in samples]) + src_tokens = merge( + "source", + left_pad=left_pad_source, + pad_to_length=pad_to_length["source"] if pad_to_length is not None else None, + ) + # sort by descending source length + src_lengths = torch.LongTensor( + [s["source"].ne(pad_idx).long().sum() for s in samples] + ) + src_lengths, sort_order = src_lengths.sort(descending=True) + id = id.index_select(0, sort_order) + src_tokens = src_tokens.index_select(0, sort_order) + + prev_output_tokens = None + target = None + if samples[0].get("target", None) is not None: + target = merge( + "target", + left_pad=left_pad_target, + pad_to_length=pad_to_length["target"] + if pad_to_length is not None + else None, + ) + target = target.index_select(0, sort_order) + tgt_lengths = torch.LongTensor( + [s["target"].ne(pad_idx).long().sum() for s in samples] + ).index_select(0, sort_order) + ntokens = tgt_lengths.sum().item() + + if samples[0].get("prev_output_tokens", None) is not None: + prev_output_tokens = merge("prev_output_tokens", left_pad=left_pad_target) + elif input_feeding: + # we create a shifted version of targets for feeding the + # previous output token(s) into the next decoder step + prev_output_tokens = merge( + "target", + left_pad=left_pad_target, + move_eos_to_beginning=True, + pad_to_length=pad_to_length["target"] + if pad_to_length is not None + else None, + ) + else: + ntokens = src_lengths.sum().item() + + batch = { + "id": id, + "nsentences": len(samples), + "ntokens": ntokens, + "net_input": {"src_tokens": src_tokens, "src_lengths": src_lengths,}, + "target": target, + } + if prev_output_tokens is not None: + batch["net_input"]["prev_output_tokens"] = prev_output_tokens.index_select( + 0, sort_order + ) + + if samples[0].get("alignment", None) is not None: + bsz, tgt_sz = batch["target"].shape + src_sz = batch["net_input"]["src_tokens"].shape[1] + + offsets = torch.zeros((len(sort_order), 2), dtype=torch.long) + offsets[:, 1] += torch.arange(len(sort_order), dtype=torch.long) * tgt_sz + if left_pad_source: + offsets[:, 0] += src_sz - src_lengths + if left_pad_target: + offsets[:, 1] += tgt_sz - tgt_lengths + + alignments = [ + alignment + offset + for align_idx, offset, src_len, tgt_len in zip( + sort_order, offsets, src_lengths, tgt_lengths + ) + for alignment in [samples[align_idx]["alignment"].view(-1, 2)] + if check_alignment(alignment, src_len, tgt_len) + ] + + if len(alignments) > 0: + alignments = torch.cat(alignments, dim=0) + align_weights = compute_alignment_weights(alignments) + + batch["alignments"] = alignments + batch["align_weights"] = align_weights + + if samples[0].get("constraints", None) is not None: + # Collate the packed constraints across the samples, padding to + # the length of the longest sample. + lens = [sample.get("constraints").size(0) for sample in samples] + max_len = max(lens) + constraints = torch.zeros((len(samples), max(lens))).long() + for i, sample in enumerate(samples): + constraints[i, 0 : lens[i]] = samples[i].get("constraints") + batch["constraints"] = constraints.index_select(0, sort_order) + + return batch + + +class LanguagePairDataset(FairseqDataset): + """ + A pair of torch.utils.data.Datasets. + + Args: + src (torch.utils.data.Dataset): source dataset to wrap + src_sizes (List[int]): source sentence lengths + src_dict (~fairseq.data.Dictionary): source vocabulary + tgt (torch.utils.data.Dataset, optional): target dataset to wrap + tgt_sizes (List[int], optional): target sentence lengths + tgt_dict (~fairseq.data.Dictionary, optional): target vocabulary + left_pad_source (bool, optional): pad source tensors on the left side + (default: True). + left_pad_target (bool, optional): pad target tensors on the left side + (default: False). + shuffle (bool, optional): shuffle dataset elements before batching + (default: True). + input_feeding (bool, optional): create a shifted version of the targets + to be passed into the model for teacher forcing (default: True). + remove_eos_from_source (bool, optional): if set, removes eos from end + of source if it's present (default: False). + append_eos_to_target (bool, optional): if set, appends eos to end of + target if it's absent (default: False). + align_dataset (torch.utils.data.Dataset, optional): dataset + containing alignments. + constraints (Tensor, optional): 2d tensor with a concatenated, zero- + delimited list of constraints for each sentence. + append_bos (bool, optional): if set, appends bos to the beginning of + source/target sentence. + num_buckets (int, optional): if set to a value greater than 0, then + batches will be bucketed into the given number of batch shapes. + src_lang_id (int, optional): source language ID, if set, the collated batch + will contain a field 'src_lang_id' in 'net_input' which indicates the + source language of the samples. + tgt_lang_id (int, optional): target language ID, if set, the collated batch + will contain a field 'tgt_lang_id' which indicates the target language + of the samples. + """ + + def __init__( + self, + src, + src_sizes, + src_dict, + tgt=None, + tgt_sizes=None, + tgt_dict=None, + left_pad_source=True, + left_pad_target=False, + shuffle=True, + input_feeding=True, + remove_eos_from_source=False, + append_eos_to_target=False, + align_dataset=None, + constraints=None, + append_bos=False, + eos=None, + num_buckets=0, + src_lang_id=None, + tgt_lang_id=None, + pad_to_multiple=1, + ): + if tgt_dict is not None: + assert src_dict.pad() == tgt_dict.pad() + assert src_dict.eos() == tgt_dict.eos() + assert src_dict.unk() == tgt_dict.unk() + if tgt is not None: + assert len(src) == len( + tgt + ), "Source and target must contain the same number of examples" + self.src = src + self.tgt = tgt + self.src_sizes = np.array(src_sizes) + self.tgt_sizes = np.array(tgt_sizes) if tgt_sizes is not None else None + self.sizes = ( + np.vstack((self.src_sizes, self.tgt_sizes)).T + if self.tgt_sizes is not None + else self.src_sizes + ) + self.src_dict = src_dict + self.tgt_dict = tgt_dict + self.left_pad_source = left_pad_source + self.left_pad_target = left_pad_target + self.shuffle = shuffle + self.input_feeding = input_feeding + self.remove_eos_from_source = remove_eos_from_source + self.append_eos_to_target = append_eos_to_target + self.align_dataset = align_dataset + if self.align_dataset is not None: + assert ( + self.tgt_sizes is not None + ), "Both source and target needed when alignments are provided" + self.constraints = constraints + self.append_bos = append_bos + self.eos = eos if eos is not None else src_dict.eos() + self.src_lang_id = src_lang_id + self.tgt_lang_id = tgt_lang_id + if num_buckets > 0: + from fairseq.data import BucketPadLengthDataset + + self.src = BucketPadLengthDataset( + self.src, + sizes=self.src_sizes, + num_buckets=num_buckets, + pad_idx=self.src_dict.pad(), + left_pad=self.left_pad_source, + ) + self.src_sizes = self.src.sizes + logger.info("bucketing source lengths: {}".format(list(self.src.buckets))) + if self.tgt is not None: + self.tgt = BucketPadLengthDataset( + self.tgt, + sizes=self.tgt_sizes, + num_buckets=num_buckets, + pad_idx=self.tgt_dict.pad(), + left_pad=self.left_pad_target, + ) + self.tgt_sizes = self.tgt.sizes + logger.info( + "bucketing target lengths: {}".format(list(self.tgt.buckets)) + ) + + # determine bucket sizes using self.num_tokens, which will return + # the padded lengths (thanks to BucketPadLengthDataset) + num_tokens = np.vectorize(self.num_tokens, otypes=[np.compat.long]) + self.bucketed_num_tokens = num_tokens(np.arange(len(self.src))) + self.buckets = [ + (None, num_tokens) for num_tokens in np.unique(self.bucketed_num_tokens) + ] + else: + self.buckets = None + self.pad_to_multiple = pad_to_multiple + + def get_batch_shapes(self): + return self.buckets + + def __getitem__(self, index): + tgt_item = self.tgt[index] if self.tgt is not None else None + src_item = self.src[index] + # Append EOS to end of tgt sentence if it does not have an EOS and remove + # EOS from end of src sentence if it exists. This is useful when we use + # use existing datasets for opposite directions i.e., when we want to + # use tgt_dataset as src_dataset and vice versa + if self.append_eos_to_target: + eos = self.tgt_dict.eos() if self.tgt_dict else self.src_dict.eos() + if self.tgt and self.tgt[index][-1] != eos: + tgt_item = torch.cat([self.tgt[index], torch.LongTensor([eos])]) + + if self.append_bos: + bos = self.tgt_dict.bos() if self.tgt_dict else self.src_dict.bos() + if self.tgt and self.tgt[index][0] != bos: + tgt_item = torch.cat([torch.LongTensor([bos]), self.tgt[index]]) + + bos = self.src_dict.bos() + if self.src[index][0] != bos: + src_item = torch.cat([torch.LongTensor([bos]), self.src[index]]) + + if self.remove_eos_from_source: + eos = self.src_dict.eos() + if self.src[index][-1] == eos: + src_item = self.src[index][:-1] + + example = { + "id": index, + "source": src_item, + "target": tgt_item, + } + if self.align_dataset is not None: + example["alignment"] = self.align_dataset[index] + if self.constraints is not None: + example["constraints"] = self.constraints[index] + return example + + def __len__(self): + return len(self.src) + + def collater(self, samples, pad_to_length=None): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[dict]): samples to collate + pad_to_length (dict, optional): a dictionary of + {'source': source_pad_to_length, 'target': target_pad_to_length} + to indicate the max length to pad to in source and target respectively. + + Returns: + dict: a mini-batch with the following keys: + + - `id` (LongTensor): example IDs in the original input order + - `ntokens` (int): total number of tokens in the batch + - `net_input` (dict): the input to the Model, containing keys: + + - `src_tokens` (LongTensor): a padded 2D Tensor of tokens in + the source sentence of shape `(bsz, src_len)`. Padding will + appear on the left if *left_pad_source* is ``True``. + - `src_lengths` (LongTensor): 1D Tensor of the unpadded + lengths of each source sentence of shape `(bsz)` + - `prev_output_tokens` (LongTensor): a padded 2D Tensor of + tokens in the target sentence, shifted right by one + position for teacher forcing, of shape `(bsz, tgt_len)`. + This key will not be present if *input_feeding* is + ``False``. Padding will appear on the left if + *left_pad_target* is ``True``. + - `src_lang_id` (LongTensor): a long Tensor which contains source + language IDs of each sample in the batch + + - `target` (LongTensor): a padded 2D Tensor of tokens in the + target sentence of shape `(bsz, tgt_len)`. Padding will appear + on the left if *left_pad_target* is ``True``. + - `tgt_lang_id` (LongTensor): a long Tensor which contains target language + IDs of each sample in the batch + """ + res = collate( + samples, + pad_idx=self.src_dict.pad(), + eos_idx=self.eos, + left_pad_source=self.left_pad_source, + left_pad_target=self.left_pad_target, + input_feeding=self.input_feeding, + pad_to_length=pad_to_length, + pad_to_multiple=self.pad_to_multiple, + ) + if self.src_lang_id is not None or self.tgt_lang_id is not None: + src_tokens = res["net_input"]["src_tokens"] + bsz = src_tokens.size(0) + if self.src_lang_id is not None: + res["net_input"]["src_lang_id"] = ( + torch.LongTensor([[self.src_lang_id]]).expand(bsz, 1).to(src_tokens) + ) + if self.tgt_lang_id is not None: + res["tgt_lang_id"] = ( + torch.LongTensor([[self.tgt_lang_id]]).expand(bsz, 1).to(src_tokens) + ) + return res + + def num_tokens(self, index): + """Return the number of tokens in a sample. This value is used to + enforce ``--max-tokens`` during batching.""" + return max( + self.src_sizes[index], + self.tgt_sizes[index] if self.tgt_sizes is not None else 0, + ) + + def num_tokens_vec(self, indices): + """Return the number of tokens for a set of positions defined by indices. + This value is used to enforce ``--max-tokens`` during batching.""" + sizes = self.src_sizes[indices] + if self.tgt_sizes is not None: + sizes = np.maximum(sizes, self.tgt_sizes[indices]) + return sizes + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + return ( + self.src_sizes[index], + self.tgt_sizes[index] if self.tgt_sizes is not None else 0, + ) + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + if self.shuffle: + indices = np.random.permutation(len(self)).astype(np.int64) + else: + indices = np.arange(len(self), dtype=np.int64) + if self.buckets is None: + # sort by target length, then source length + if self.tgt_sizes is not None: + indices = indices[np.argsort(self.tgt_sizes[indices], kind="mergesort")] + return indices[np.argsort(self.src_sizes[indices], kind="mergesort")] + else: + # sort by bucketed_num_tokens, which is: + # max(padded_src_len, padded_tgt_len) + return indices[ + np.argsort(self.bucketed_num_tokens[indices], kind="mergesort") + ] + + @property + def supports_prefetch(self): + return getattr(self.src, "supports_prefetch", False) and ( + getattr(self.tgt, "supports_prefetch", False) or self.tgt is None + ) + + def prefetch(self, indices): + self.src.prefetch(indices) + if self.tgt is not None: + self.tgt.prefetch(indices) + if self.align_dataset is not None: + self.align_dataset.prefetch(indices) + + def filter_indices_by_size(self, indices, max_sizes): + """Filter a list of sample indices. Remove those that are longer + than specified in max_sizes. + + Args: + indices (np.array): original array of sample indices + max_sizes (int or list[int] or tuple[int]): max sample size, + can be defined separately for src and tgt (then list or tuple) + + Returns: + np.array: filtered sample array + list: list of removed indices + """ + return data_utils.filter_paired_dataset_indices_by_size( + self.src_sizes, self.tgt_sizes, indices, max_sizes, + ) diff --git a/fairseq/fairseq/data/legacy/__init__.py b/fairseq/fairseq/data/legacy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9bd5c72b5e9d7f67fb7e4ef10808d7ec08967ff4 --- /dev/null +++ b/fairseq/fairseq/data/legacy/__init__.py @@ -0,0 +1,16 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .block_pair_dataset import BlockPairDataset +from .masked_lm_dataset import MaskedLMDataset +from .masked_lm_dictionary import BertDictionary, MaskedLMDictionary + + +__all__ = [ + "BertDictionary", + "BlockPairDataset", + "MaskedLMDataset", + "MaskedLMDictionary", +] diff --git a/fairseq/fairseq/data/legacy/block_pair_dataset.py b/fairseq/fairseq/data/legacy/block_pair_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ba069b46052286c531b4f9706d96788732cd2ad2 --- /dev/null +++ b/fairseq/fairseq/data/legacy/block_pair_dataset.py @@ -0,0 +1,311 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import numpy as np +import torch +from fairseq.data import FairseqDataset + + +class BlockPairDataset(FairseqDataset): + """Break a Dataset of tokens into sentence pair blocks for next sentence + prediction as well as masked language model. + + High-level logics are: + 1. break input tensor to tensor blocks + 2. pair the blocks with 50% next sentence and 50% random sentence + 3. return paired blocks as well as related segment labels + + Args: + dataset (~torch.utils.data.Dataset): dataset to break into blocks + sizes: array of sentence lengths + dictionary: dictionary for the task + block_size: maximum block size + break_mode: mode for breaking copurs into block pairs. currently we support + 2 modes + doc: respect document boundaries and each part of the pair should belong to on document + none: don't respect any boundary and cut tokens evenly + short_seq_prob: probability for generating shorter block pairs + doc_break_size: Size for empty line separating documents. Typically 1 if + the sentences have eos, 0 otherwise. + """ + + def __init__( + self, + dataset, + dictionary, + sizes, + block_size, + break_mode="doc", + short_seq_prob=0.1, + doc_break_size=1, + ): + super().__init__() + self.dataset = dataset + self.pad = dictionary.pad() + self.eos = dictionary.eos() + self.cls = dictionary.cls() + self.mask = dictionary.mask() + self.sep = dictionary.sep() + self.break_mode = break_mode + self.dictionary = dictionary + self.short_seq_prob = short_seq_prob + self.block_indices = [] + + assert len(dataset) == len(sizes) + + if break_mode == "doc": + cur_doc = [] + for sent_id, sz in enumerate(sizes): + assert doc_break_size == 0 or sz != 0, ( + "when doc_break_size is non-zero, we expect documents to be" + "separated by a blank line with a single eos." + ) + # empty line as document separator + if sz == doc_break_size: + if len(cur_doc) == 0: + continue + self.block_indices.append(cur_doc) + cur_doc = [] + else: + cur_doc.append(sent_id) + max_num_tokens = block_size - 3 # Account for [CLS], [SEP], [SEP] + self.sent_pairs = [] + self.sizes = [] + for doc_id, doc in enumerate(self.block_indices): + self._generate_sentence_pair(doc, doc_id, max_num_tokens, sizes) + elif break_mode is None or break_mode == "none": + # each block should have half of the block size since we are constructing block pair + sent_length = (block_size - 3) // 2 + total_len = sum(dataset.sizes) + length = math.ceil(total_len / sent_length) + + def block_at(i): + start = i * sent_length + end = min(start + sent_length, total_len) + return (start, end) + + sent_indices = np.array([block_at(i) for i in range(length)]) + sent_sizes = np.array([e - s for s, e in sent_indices]) + dataset_index = self._sent_to_dataset_index(sent_sizes) + + # pair sentences + self._pair_sentences(dataset_index) + else: + raise ValueError("Invalid break_mode: " + break_mode) + + def _pair_sentences(self, dataset_index): + """ + Give a list of evenly cut blocks/sentences, pair these sentences with 50% + consecutive sentences and 50% random sentences. + This is used for none break mode + """ + # pair sentences + for sent_id, sent in enumerate(dataset_index): + next_sent_label = ( + 1 if np.random.rand() > 0.5 and sent_id != len(dataset_index) - 1 else 0 + ) + if next_sent_label: + next_sent = dataset_index[sent_id + 1] + else: + next_sent = dataset_index[ + self._skip_sampling(len(dataset_index), [sent_id, sent_id + 1]) + ] + self.sent_pairs.append((sent, next_sent, next_sent_label)) + + # The current blocks don't include the special tokens but the + # sizes already account for this + self.sizes.append(3 + sent[3] + next_sent[3]) + + def _sent_to_dataset_index(self, sent_sizes): + """ + Build index mapping block indices to the underlying dataset indices + """ + dataset_index = [] + ds_idx, ds_remaining = -1, 0 + for to_consume in sent_sizes: + sent_size = to_consume + if ds_remaining == 0: + ds_idx += 1 + ds_remaining = sent_sizes[ds_idx] + start_ds_idx = ds_idx + start_offset = sent_sizes[ds_idx] - ds_remaining + while to_consume > ds_remaining: + to_consume -= ds_remaining + ds_idx += 1 + ds_remaining = sent_sizes[ds_idx] + ds_remaining -= to_consume + dataset_index.append( + ( + start_ds_idx, # starting index in dataset + start_offset, # starting offset within starting index + ds_idx, # ending index in dataset + sent_size, # sentence length + ) + ) + assert ds_remaining == 0 + assert ds_idx == len(self.dataset) - 1 + return dataset_index + + def _generate_sentence_pair(self, doc, doc_id, max_num_tokens, sizes): + """ + Go through a single document and genrate sentence paris from it + """ + current_chunk = [] + current_length = 0 + curr = 0 + # To provide more randomness, we decrease target seq length for parts of + # samples (10% by default). Note that max_num_tokens is the hard threshold + # for batching and will never be changed. + target_seq_length = max_num_tokens + if np.random.random() < self.short_seq_prob: + target_seq_length = np.random.randint(2, max_num_tokens) + # loop through all sentences in document + while curr < len(doc): + sent_id = doc[curr] + current_chunk.append(sent_id) + current_length = sum(sizes[current_chunk]) + # split chunk and generate pair when exceed target_seq_length or + # finish the loop + if curr == len(doc) - 1 or current_length >= target_seq_length: + # split the chunk into 2 parts + a_end = 1 + if len(current_chunk) > 2: + a_end = np.random.randint(1, len(current_chunk) - 1) + sent_a = current_chunk[:a_end] + len_a = sum(sizes[sent_a]) + # generate next sentence label, note that if there is only 1 sentence + # in current chunk, label is always 0 + next_sent_label = ( + 1 if np.random.rand() > 0.5 and len(current_chunk) != 1 else 0 + ) + if not next_sent_label: + # if next sentence label is 0, sample sent_b from a random doc + target_b_length = target_seq_length - len_a + rand_doc_id = self._skip_sampling(len(self.block_indices), [doc_id]) + random_doc = self.block_indices[rand_doc_id] + random_start = np.random.randint(0, len(random_doc)) + sent_b = [] + len_b = 0 + for j in range(random_start, len(random_doc)): + sent_b.append(random_doc[j]) + len_b = sum(sizes[sent_b]) + if len_b >= target_b_length: + break + # return the second part of the chunk since it's not used + num_unused_segments = len(current_chunk) - a_end + curr -= num_unused_segments + else: + # if next sentence label is 1, use the second part of chunk as sent_B + sent_b = current_chunk[a_end:] + len_b = sum(sizes[sent_b]) + # currently sent_a and sent_B may be longer than max_num_tokens, + # truncate them and return block idx and offsets for them + sent_a, sent_b = self._truncate_sentences( + sent_a, sent_b, max_num_tokens + ) + self.sent_pairs.append((sent_a, sent_b, next_sent_label)) + self.sizes.append(3 + sent_a[3] + sent_b[3]) + current_chunk = [] + curr += 1 + + def _skip_sampling(self, total, skip_ids): + """ + Generate a random integer which is not in skip_ids. Sample range is [0, total) + TODO: ids in skip_ids should be consecutive, we can extend it to more generic version later + """ + rand_id = np.random.randint(total - len(skip_ids)) + return rand_id if rand_id < min(skip_ids) else rand_id + len(skip_ids) + + def _truncate_sentences(self, sent_a, sent_b, max_num_tokens): + """ + Trancate a pair of sentence to limit total length under max_num_tokens + Logics: + 1. Truncate longer sentence + 2. Tokens to be truncated could be at the beginning or the end of the sentnce + Returns: + Truncated sentences represented by dataset idx + """ + len_a, len_b = sum(self.dataset.sizes[sent_a]), sum(self.dataset.sizes[sent_b]) + front_cut_a = front_cut_b = end_cut_a = end_cut_b = 0 + + while True: + total_length = ( + len_a + len_b - front_cut_a - front_cut_b - end_cut_a - end_cut_b + ) + if total_length <= max_num_tokens: + break + + if len_a - front_cut_a - end_cut_a > len_b - front_cut_b - end_cut_b: + if np.random.rand() < 0.5: + front_cut_a += 1 + else: + end_cut_a += 1 + else: + if np.random.rand() < 0.5: + front_cut_b += 1 + else: + end_cut_b += 1 + + # calculate ds indices as well as offsets and return + truncated_sent_a = self._cut_sentence(sent_a, front_cut_a, end_cut_a) + truncated_sent_b = self._cut_sentence(sent_b, front_cut_b, end_cut_b) + return truncated_sent_a, truncated_sent_b + + def _cut_sentence(self, sent, front_cut, end_cut): + """ + Cut a sentence based on the numbers of tokens to be cut from beginning and end + Represent the sentence as dataset idx and return + """ + start_ds_idx, end_ds_idx, offset = sent[0], sent[-1], 0 + target_len = sum(self.dataset.sizes[sent]) - front_cut - end_cut + while front_cut > 0: + if self.dataset.sizes[start_ds_idx] > front_cut: + offset += front_cut + break + else: + front_cut -= self.dataset.sizes[start_ds_idx] + start_ds_idx += 1 + while end_cut > 0: + if self.dataset.sizes[end_ds_idx] > end_cut: + break + else: + end_cut -= self.dataset.sizes[end_ds_idx] + end_ds_idx -= 1 + return start_ds_idx, offset, end_ds_idx, target_len + + def _fetch_block(self, start_ds_idx, offset, end_ds_idx, length): + """ + Fetch a block of tokens based on its dataset idx + """ + buffer = torch.cat( + [self.dataset[idx] for idx in range(start_ds_idx, end_ds_idx + 1)] + ) + s, e = offset, offset + length + return buffer[s:e] + + def __getitem__(self, index): + block1, block2, next_sent_label = self.sent_pairs[index] + block1 = self._fetch_block(*block1) + block2 = self._fetch_block(*block2) + return block1, block2, next_sent_label + + def __len__(self): + return len(self.sizes) + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + prefetch_idx = set() + for index in indices: + for block1, block2, _ in [self.sent_pairs[index]]: + for ds_idx in range(block1[0], block1[2] + 1): + prefetch_idx.add(ds_idx) + for ds_idx in range(block2[0], block2[2] + 1): + prefetch_idx.add(ds_idx) + self.dataset.prefetch(prefetch_idx) diff --git a/fairseq/fairseq/data/legacy/masked_lm_dataset.py b/fairseq/fairseq/data/legacy/masked_lm_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..dd8ea2c60aff306ab3a756223a298a28d41a4991 --- /dev/null +++ b/fairseq/fairseq/data/legacy/masked_lm_dataset.py @@ -0,0 +1,303 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Dict, List, Tuple + +import numpy as np +import torch +from fairseq.data import Dictionary, FairseqDataset, data_utils +from fairseq.data.concat_dataset import ConcatDataset +from fairseq.data.legacy.block_pair_dataset import BlockPairDataset +from fairseq.data.token_block_dataset import TokenBlockDataset + + +class MaskedLMDataset(FairseqDataset): + """ + A wrapper Dataset for masked language modelling. The dataset + wraps around TokenBlockDataset or BlockedPairDataset and creates a batch + where the input blocks are masked according to the specified masking + probability. Additionally the batch can also contain sentence level targets + if this is specified. + + Args: + dataset: Dataset which generates blocks of data. Only BlockPairDataset + and TokenBlockDataset are supported. + sizes: Sentence lengths + vocab: Dictionary with the vocabulary and special tokens. + pad_idx: Id of padding token in dictionary + mask_idx: Id of mask token in dictionary + classif_token_idx: Id of classification token in dictionary. This is the + token associated with the sentence embedding (Eg: CLS for BERT) + sep_token_idx: Id of separator token in dictionary + (Eg: SEP in BERT) + seed: Seed for random number generator for reproducibility. + shuffle: Shuffle the elements before batching. + has_pairs: Specifies whether the underlying dataset + generates a pair of blocks along with a sentence_target or not. + Setting it to True assumes that the underlying dataset generates a + label for the pair of sentences which is surfaced as + sentence_target. The default value assumes a single block with no + sentence target. + segment_id: An optional segment id for filling in the segment labels + when we are in the single block setting (Eg: XLM). Default is 0. + masking_ratio: specifies what percentage of the blocks should be masked. + masking_prob: specifies the probability of a given token being + replaced with the "MASK" token. + random_token_prob: specifies the probability of a given token being + replaced by a random token from the vocabulary. + """ + + def __init__( + self, + dataset: FairseqDataset, + sizes: np.ndarray, + vocab: Dictionary, + pad_idx: int, + mask_idx: int, + classif_token_idx: int, + sep_token_idx: int, + seed: int = 1, + shuffle: bool = True, + has_pairs: bool = True, + segment_id: int = 0, + masking_ratio: float = 0.15, + masking_prob: float = 0.8, + random_token_prob: float = 0.1, + ): + # Make sure the input datasets are the ones supported + assert ( + isinstance(dataset, TokenBlockDataset) + or isinstance(dataset, BlockPairDataset) + or isinstance(dataset, ConcatDataset) + ), ( + "MaskedLMDataset only wraps TokenBlockDataset or BlockPairDataset or " + "ConcatDataset" + ) + + self.dataset = dataset + self.sizes = np.array(sizes) + self.vocab = vocab + self.pad_idx = pad_idx + self.mask_idx = mask_idx + self.classif_token_idx = classif_token_idx + self.sep_token_idx = sep_token_idx + self.shuffle = shuffle + self.seed = seed + self.has_pairs = has_pairs + self.segment_id = segment_id + self.masking_ratio = masking_ratio + self.masking_prob = masking_prob + self.random_token_prob = random_token_prob + + # If we have only one block then sizes needs to be updated to include + # the classification token + if not has_pairs: + self.sizes = self.sizes + 1 + + def __getitem__(self, index: int): + # if has_pairs, then expect 2 blocks and a sentence target + if self.has_pairs: + (block_one, block_two, sentence_target) = self.dataset[index] + else: + block_one = self.dataset[index] + + return { + "id": index, + "block_one": block_one, + "block_two": block_two if self.has_pairs else None, + "sentence_target": sentence_target if self.has_pairs else None, + } + + def __len__(self): + return len(self.dataset) + + def _mask_block( + self, + sentence: np.ndarray, + mask_idx: int, + pad_idx: int, + dictionary_token_range: Tuple, + ): + """ + Mask tokens for Masked Language Model training + Samples mask_ratio tokens that will be predicted by LM. + + Note:This function may not be efficient enough since we had multiple + conversions between np and torch, we can replace them with torch + operators later. + + Args: + sentence: 1d tensor to be masked + mask_idx: index to use for masking the sentence + pad_idx: index to use for masking the target for tokens we aren't + predicting + dictionary_token_range: range of indices in dictionary which can + be used for random word replacement + (e.g. without special characters) + Return: + masked_sent: masked sentence + target: target with words which we are not predicting replaced + by pad_idx + """ + masked_sent = np.copy(sentence) + sent_length = len(sentence) + mask_num = math.ceil(sent_length * self.masking_ratio) + mask = np.random.choice(sent_length, mask_num, replace=False) + target = np.copy(sentence) + + for i in range(sent_length): + if i in mask: + rand = np.random.random() + + # replace with mask if probability is less than masking_prob + # (Eg: 0.8) + if rand < self.masking_prob: + masked_sent[i] = mask_idx + + # replace with random token if probability is less than + # masking_prob + random_token_prob (Eg: 0.9) + elif rand < (self.masking_prob + self.random_token_prob): + # sample random token from dictionary + masked_sent[i] = np.random.randint( + dictionary_token_range[0], dictionary_token_range[1] + ) + else: + target[i] = pad_idx + + return masked_sent, target + + def _collate(self, samples: List[Dict], pad_idx: int, eos_idx: int): + """ + Does the heavy lifting for creating a batch from the input list of + examples. The logic is as follows: + 1. Mask the input blocks. In case has_pair is True then we have 2 + blocks to mask. + 2. Prepend the first masked block tensor with the special token + used as sentence embedding. Eg: CLS in BERT. This happens + irrespective of the value of has_pair. + 3. If has_pair is True, then append the first masked block with the + special separator token (eg: SEP for BERT) and compute segment + label accordingly. In this case, also append the second masked + block with this special separator token and compute its segment + label. + 4. For the targets tensor, prepend and append with padding index + accordingly. + 5. Concatenate all tensors. + """ + if len(samples) == 0: + return {} + # To ensure determinism, we reset the state of the PRNG after every + # batch based on the seed and the first id of the batch. This ensures + # that across epochs we get the same mask for the same example. This + # is needed for reproducibility and is how BERT does masking + # TODO: Can we add deteminism without this constraint? + with data_utils.numpy_seed(self.seed + samples[0]["id"]): + for s in samples: + + # token range is needed for replacing with random token during + # masking + token_range = (self.vocab.nspecial, len(self.vocab)) + + # mask according to specified probabilities. + masked_blk_one, masked_tgt_one = self._mask_block( + s["block_one"], + self.mask_idx, + self.pad_idx, + token_range, + ) + + tokens = np.concatenate([[self.classif_token_idx], masked_blk_one]) + targets = np.concatenate([[self.pad_idx], masked_tgt_one]) + segments = np.ones(len(tokens)) * self.segment_id + + # if has_pairs is True then we need to add the SEP token to both + # the blocks after masking and re-compute segments based on the new + # lengths. + if self.has_pairs: + tokens_one = np.concatenate([tokens, [self.sep_token_idx]]) + targets_one = np.concatenate([targets, [self.pad_idx]]) + + masked_blk_two, masked_tgt_two = self._mask_block( + s["block_two"], self.mask_idx, self.pad_idx, token_range + ) + tokens_two = np.concatenate([masked_blk_two, [self.sep_token_idx]]) + targets_two = np.concatenate([masked_tgt_two, [self.pad_idx]]) + + # block + 1 sep + 1 special (CLS) + segments_one = np.zeros(len(tokens_one)) + # block + 1 sep + segments_two = np.ones(len(tokens_two)) + + tokens = np.concatenate([tokens_one, tokens_two]) + targets = np.concatenate([targets_one, targets_two]) + segments = np.concatenate([segments_one, segments_two]) + + s["source"] = torch.LongTensor(tokens) + s["segment_labels"] = torch.LongTensor(segments) + s["lm_target"] = torch.LongTensor(targets) + + def merge(key): + return data_utils.collate_tokens( + [s[key] for s in samples], pad_idx, eos_idx, left_pad=False + ) + + return { + "id": torch.LongTensor([s["id"] for s in samples]), + "ntokens": sum(len(s["source"]) for s in samples), + "net_input": { + "src_tokens": merge("source"), + "segment_labels": merge("segment_labels"), + }, + "lm_target": merge("lm_target"), + "sentence_target": torch.LongTensor([s["sentence_target"] for s in samples]) + if self.has_pairs + else None, + "nsentences": len(samples), + } + + def collater(self, samples: List[Dict]): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[dict]): samples to collate + + Returns: + dict: a mini-batch of data + """ + return self._collate(samples, self.vocab.pad(), self.vocab.eos()) + + def num_tokens(self, index: int): + """ + Return the number of tokens in a sample. This value is used to + enforce max-tokens during batching. + """ + return self.sizes[index] + + def size(self, index: int): + """ + Return an example's size as a float or tuple. This value is used when + filtering a dataset with max-positions. + """ + return self.sizes[index] + + def ordered_indices(self): + """ + Return an ordered list of indices. Batches will be constructed based + on this order. + """ + if self.shuffle: + return np.random.permutation(len(self)) + else: + order = [np.arange(len(self))] + order.append(self.sizes) + return np.lexsort(order) + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + self.dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/legacy/masked_lm_dictionary.py b/fairseq/fairseq/data/legacy/masked_lm_dictionary.py new file mode 100644 index 0000000000000000000000000000000000000000..dee88f7a3ed72ea465ea4e8ffe7b1c01ff6f57f1 --- /dev/null +++ b/fairseq/fairseq/data/legacy/masked_lm_dictionary.py @@ -0,0 +1,60 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.data import Dictionary + + +class MaskedLMDictionary(Dictionary): + """ + Dictionary for Masked Language Modelling tasks. This extends Dictionary by + adding the mask symbol. + """ + + def __init__( + self, + pad="<pad>", + eos="</s>", + unk="<unk>", + mask="<mask>", + ): + super().__init__(pad=pad, eos=eos, unk=unk) + self.mask_word = mask + self.mask_index = self.add_symbol(mask) + self.nspecial = len(self.symbols) + + def mask(self): + """Helper to get index of mask symbol""" + return self.mask_index + + +class BertDictionary(MaskedLMDictionary): + """ + Dictionary for BERT task. This extends MaskedLMDictionary by adding support + for cls and sep symbols. + """ + + def __init__( + self, + pad="<pad>", + eos="</s>", + unk="<unk>", + mask="<mask>", + cls="<cls>", + sep="<sep>", + ): + super().__init__(pad=pad, eos=eos, unk=unk, mask=mask) + self.cls_word = cls + self.sep_word = sep + self.cls_index = self.add_symbol(cls) + self.sep_index = self.add_symbol(sep) + self.nspecial = len(self.symbols) + + def cls(self): + """Helper to get index of cls symbol""" + return self.cls_index + + def sep(self): + """Helper to get index of sep symbol""" + return self.sep_index diff --git a/fairseq/fairseq/data/list_dataset.py b/fairseq/fairseq/data/list_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..12f00aa43661d6bad701c9e72653ba8779136906 --- /dev/null +++ b/fairseq/fairseq/data/list_dataset.py @@ -0,0 +1,32 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import BaseWrapperDataset + + +class ListDataset(BaseWrapperDataset): + def __init__(self, dataset, sizes=None): + super().__init__(dataset) + self._sizes = sizes + + def __iter__(self): + for x in self.dataset: + yield x + + def collater(self, samples): + return samples + + @property + def sizes(self): + return self._sizes + + def num_tokens(self, index): + return self.sizes[index] + + def size(self, index): + return self.sizes[index] + + def set_epoch(self, epoch): + pass diff --git a/fairseq/fairseq/data/lm_context_window_dataset.py b/fairseq/fairseq/data/lm_context_window_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..1a945927cf0d96719003685676a990737a3762b2 --- /dev/null +++ b/fairseq/fairseq/data/lm_context_window_dataset.py @@ -0,0 +1,97 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from typing import Dict + +from fairseq.data.monolingual_dataset import MonolingualDataset + +from . import FairseqDataset + + +class LMContextWindowDataset(FairseqDataset): + """ + Wraps a MonolingualDataset and provides more context for evaluation. + + Each item in the new dataset will have a maximum size of + ``tokens_per_sample + context_window``. + + Args: + dataset: dataset to wrap + tokens_per_sample (int): the max number of tokens in each dataset item + context_window (int): the number of accumulated tokens to add to each + dataset item + pad_idx (int): padding symbol + """ + + def __init__( + self, + dataset: MonolingualDataset, + tokens_per_sample: int, + context_window: int, + pad_idx: int, + ): + assert context_window > 0 + self.dataset = dataset + self.tokens_per_sample = tokens_per_sample + self.context_window = context_window + self.pad_idx = pad_idx + self.prev_tokens = np.empty([0]) + + def __getitem__(self, index): + return self.dataset[index] + + def __len__(self): + return len(self.dataset) + + def collater(self, samples) -> Dict: + sample = self.dataset.collater(samples) + + pad = self.pad_idx + max_sample_len = self.tokens_per_sample + self.context_window + + bsz, tsz = sample["net_input"]["src_tokens"].shape + start_idxs = [0] * bsz + toks = sample["net_input"]["src_tokens"] + lengths = sample["net_input"]["src_lengths"] + tgt = sample["target"] + new_toks = np.empty([bsz, tsz + self.context_window], dtype=np.int64) + new_tgt = np.full([bsz, tsz + self.context_window], pad, dtype=np.int64) + sample_lens = toks.ne(pad).long().sum(dim=1).cpu() + for i in range(bsz): + sample_len = sample_lens[i] + extra = len(self.prev_tokens) + sample_len - max_sample_len + if extra > 0: + self.prev_tokens = self.prev_tokens[extra:] + pads = np.full(self.context_window - len(self.prev_tokens), pad) + new_toks[i] = np.concatenate([self.prev_tokens, toks[i].numpy(), pads]) + new_tgt[ + i, len(self.prev_tokens) : len(self.prev_tokens) + len(tgt[i]) + ] = tgt[i] + start_idxs[i] = len(self.prev_tokens) + lengths[i] += len(self.prev_tokens) + self.prev_tokens = new_toks[i][new_toks[i] != pad][-self.context_window :] + sample["net_input"]["src_tokens"] = torch.from_numpy(new_toks) + sample["target"] = torch.from_numpy(new_tgt) + sample["start_indices"] = start_idxs + return sample + + def num_tokens(self, index): + return self.dataset.num_tokens(index) + + def size(self, index): + return self.dataset.size(index) + + def ordered_indices(self): + # NOTE we don't shuffle the data to retain access to the previous dataset elements + return np.arange(len(self.dataset)) + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/lru_cache_dataset.py b/fairseq/fairseq/data/lru_cache_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a7854ac1701392754ce5795cafe9c634671aebdf --- /dev/null +++ b/fairseq/fairseq/data/lru_cache_dataset.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from functools import lru_cache + +from . import BaseWrapperDataset + + +class LRUCacheDataset(BaseWrapperDataset): + def __init__(self, dataset, token=None): + super().__init__(dataset) + + @lru_cache(maxsize=8) + def __getitem__(self, index): + return self.dataset[index] + + @lru_cache(maxsize=8) + def collater(self, samples): + return self.dataset.collater(samples) diff --git a/fairseq/fairseq/data/mask_tokens_dataset.py b/fairseq/fairseq/data/mask_tokens_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..9123235594c3977994a3ae8a03ab4c9e395cc5de --- /dev/null +++ b/fairseq/fairseq/data/mask_tokens_dataset.py @@ -0,0 +1,220 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from functools import lru_cache + +import numpy as np +import torch +from fairseq.data import Dictionary, data_utils + +from . import BaseWrapperDataset, LRUCacheDataset + + +class MaskTokensDataset(BaseWrapperDataset): + """ + A wrapper Dataset for masked language modeling. + + Input items are masked according to the specified masking probability. + + Args: + dataset: Dataset to wrap. + sizes: Sentence lengths + vocab: Dictionary with the vocabulary and special tokens. + pad_idx: Id of pad token in vocab + mask_idx: Id of mask token in vocab + return_masked_tokens: controls whether to return the non-masked tokens + (the default) or to return a tensor with the original masked token + IDs (and *pad_idx* elsewhere). The latter is useful as targets for + masked LM training. + seed: Seed for random number generator for reproducibility. + mask_prob: probability of replacing a token with *mask_idx*. + leave_unmasked_prob: probability that a masked token is unmasked. + random_token_prob: probability of replacing a masked token with a + random token from the vocabulary. + freq_weighted_replacement: sample random replacement words based on + word frequencies in the vocab. + mask_whole_words: only mask whole words. This should be a byte mask + over vocab indices, indicating whether it is the beginning of a + word. We will extend any mask to encompass the whole word. + bpe: BPE to use for whole-word masking. + mask_multiple_length : repeat each mask index multiple times. Default + value is 1. + mask_stdev : standard deviation of masks distribution in case of + multiple masking. Default value is 0. + """ + + @classmethod + def apply_mask(cls, dataset: torch.utils.data.Dataset, *args, **kwargs): + """Return the source and target datasets for masked LM training.""" + dataset = LRUCacheDataset(dataset) + return ( + LRUCacheDataset(cls(dataset, *args, **kwargs, return_masked_tokens=False)), + LRUCacheDataset(cls(dataset, *args, **kwargs, return_masked_tokens=True)), + ) + + def __init__( + self, + dataset: torch.utils.data.Dataset, + vocab: Dictionary, + pad_idx: int, + mask_idx: int, + return_masked_tokens: bool = False, + seed: int = 1, + mask_prob: float = 0.15, + leave_unmasked_prob: float = 0.1, + random_token_prob: float = 0.1, + freq_weighted_replacement: bool = False, + mask_whole_words: torch.Tensor = None, + mask_multiple_length: int = 1, + mask_stdev: float = 0.0, + ): + assert 0.0 < mask_prob < 1.0 + assert 0.0 <= random_token_prob <= 1.0 + assert 0.0 <= leave_unmasked_prob <= 1.0 + assert random_token_prob + leave_unmasked_prob <= 1.0 + assert mask_multiple_length >= 1 + assert mask_stdev >= 0.0 + + self.dataset = dataset + self.vocab = vocab + self.pad_idx = pad_idx + self.mask_idx = mask_idx + self.return_masked_tokens = return_masked_tokens + self.seed = seed + self.mask_prob = mask_prob + self.leave_unmasked_prob = leave_unmasked_prob + self.random_token_prob = random_token_prob + self.mask_whole_words = mask_whole_words + self.mask_multiple_length = mask_multiple_length + self.mask_stdev = mask_stdev + + if random_token_prob > 0.0: + if freq_weighted_replacement: + weights = np.array(self.vocab.count) + else: + weights = np.ones(len(self.vocab)) + weights[: self.vocab.nspecial] = 0 + self.weights = weights / weights.sum() + + self.epoch = 0 + + @property + def can_reuse_epoch_itr_across_epochs(self): + return True # only the noise changes, not item sizes + + def set_epoch(self, epoch, **unused): + super().set_epoch(epoch) + self.epoch = epoch + + def __getitem__(self, index: int): + return self.__getitem_cached__(self.seed, self.epoch, index) + + @lru_cache(maxsize=8) + def __getitem_cached__(self, seed: int, epoch: int, index: int): + with data_utils.numpy_seed(self.seed, self.epoch, index): + item = self.dataset[index] + sz = len(item) + + assert ( + self.mask_idx not in item + ), "Dataset contains mask_idx (={}), this is not expected!".format( + self.mask_idx, + ) + + if self.mask_whole_words is not None: + word_begins_mask = self.mask_whole_words.gather(0, item) + word_begins_idx = word_begins_mask.nonzero().view(-1) + sz = len(word_begins_idx) + words = np.split(word_begins_mask, word_begins_idx)[1:] + assert len(words) == sz + word_lens = list(map(len, words)) + + # decide elements to mask + mask = np.full(sz, False) + num_mask = int( + # add a random number for probabilistic rounding + self.mask_prob * sz / float(self.mask_multiple_length) + + np.random.rand() + ) + + # multiple masking as described in the vq-wav2vec paper (https://arxiv.org/abs/1910.05453) + mask_idc = np.random.choice(sz, num_mask, replace=False) + if self.mask_stdev > 0.0: + lengths = np.random.normal( + self.mask_multiple_length, self.mask_stdev, size=num_mask + ) + lengths = [max(0, int(round(x))) for x in lengths] + mask_idc = np.asarray( + [ + mask_idc[j] + offset + for j in range(len(mask_idc)) + for offset in range(lengths[j]) + ], + dtype=np.int64, + ) + else: + mask_idc = np.concatenate( + [mask_idc + i for i in range(self.mask_multiple_length)] + ) + mask_idc = mask_idc[mask_idc < len(mask)] + try: + mask[mask_idc] = True + except: # something wrong + print( + "Assigning mask indexes {} to mask {} failed!".format( + mask_idc, mask + ) + ) + raise + + if self.return_masked_tokens: + # exit early if we're just returning the masked tokens + # (i.e., the targets for masked LM training) + if self.mask_whole_words is not None: + mask = np.repeat(mask, word_lens) + new_item = np.full(len(mask), self.pad_idx) + new_item[mask] = item[torch.from_numpy(mask.astype(np.uint8)) == 1] + return torch.from_numpy(new_item) + + # decide unmasking and random replacement + rand_or_unmask_prob = self.random_token_prob + self.leave_unmasked_prob + if rand_or_unmask_prob > 0.0: + rand_or_unmask = mask & (np.random.rand(sz) < rand_or_unmask_prob) + if self.random_token_prob == 0.0: + unmask = rand_or_unmask + rand_mask = None + elif self.leave_unmasked_prob == 0.0: + unmask = None + rand_mask = rand_or_unmask + else: + unmask_prob = self.leave_unmasked_prob / rand_or_unmask_prob + decision = np.random.rand(sz) < unmask_prob + unmask = rand_or_unmask & decision + rand_mask = rand_or_unmask & (~decision) + else: + unmask = rand_mask = None + + if unmask is not None: + mask = mask ^ unmask + + if self.mask_whole_words is not None: + mask = np.repeat(mask, word_lens) + + new_item = np.copy(item) + new_item[mask] = self.mask_idx + if rand_mask is not None: + num_rand = rand_mask.sum() + if num_rand > 0: + if self.mask_whole_words is not None: + rand_mask = np.repeat(rand_mask, word_lens) + num_rand = rand_mask.sum() + + new_item[rand_mask] = np.random.choice( + len(self.vocab), + num_rand, + p=self.weights, + ) + + return torch.from_numpy(new_item) diff --git a/fairseq/fairseq/data/monolingual_dataset.py b/fairseq/fairseq/data/monolingual_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..54fd583b64a3a475324ade6eaaeccf593d747fdc --- /dev/null +++ b/fairseq/fairseq/data/monolingual_dataset.py @@ -0,0 +1,253 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from . import FairseqDataset, data_utils + + +def collate(samples, pad_idx, eos_idx, fixed_pad_length=None, pad_to_bsz=None): + if len(samples) == 0: + return {} + + def merge(key, is_list=False): + if is_list: + res = [] + for i in range(len(samples[0][key])): + res.append( + data_utils.collate_tokens( + [s[key][i] for s in samples], + pad_idx, + eos_idx, + left_pad=False, + pad_to_length=fixed_pad_length, + pad_to_bsz=pad_to_bsz, + ) + ) + return res + else: + return data_utils.collate_tokens( + [s[key] for s in samples], + pad_idx, + eos_idx, + left_pad=False, + pad_to_length=fixed_pad_length, + pad_to_bsz=pad_to_bsz, + ) + + src_tokens = merge("source") + if samples[0]["target"] is not None: + is_target_list = isinstance(samples[0]["target"], list) + target = merge("target", is_target_list) + else: + target = src_tokens + + return { + "id": torch.LongTensor([s["id"] for s in samples]), + "nsentences": len(samples), + "ntokens": sum(len(s["source"]) for s in samples), + "net_input": { + "src_tokens": src_tokens, + "src_lengths": torch.LongTensor([s["source"].numel() for s in samples]), + }, + "target": target, + } + + +class MonolingualDataset(FairseqDataset): + """ + A wrapper around torch.utils.data.Dataset for monolingual data. + + Args: + dataset (torch.utils.data.Dataset): dataset to wrap + sizes (List[int]): sentence lengths + vocab (~fairseq.data.Dictionary): vocabulary + shuffle (bool, optional): shuffle the elements before batching + (default: True). + """ + + def __init__( + self, + dataset, + sizes, + src_vocab, + tgt_vocab=None, + add_eos_for_other_targets=False, + shuffle=False, + targets=None, + add_bos_token=False, + fixed_pad_length=None, + pad_to_bsz=None, + src_lang_idx=None, + tgt_lang_idx=None, + ): + self.dataset = dataset + self.sizes = np.array(sizes) + self.vocab = src_vocab + self.tgt_vocab = tgt_vocab or src_vocab + self.add_eos_for_other_targets = add_eos_for_other_targets + self.shuffle = shuffle + self.add_bos_token = add_bos_token + self.fixed_pad_length = fixed_pad_length + self.pad_to_bsz = pad_to_bsz + self.src_lang_idx = src_lang_idx + self.tgt_lang_idx = tgt_lang_idx + + assert targets is None or all( + t in {"self", "future", "past"} for t in targets + ), "targets must be none or one of 'self', 'future', 'past'" + if targets is not None and len(targets) == 0: + targets = None + self.targets = targets + + def __getitem__(self, index): + if self.targets is not None: + # *future_target* is the original sentence + # *source* is shifted right by 1 (maybe left-padded with eos) + # *past_target* is shifted right by 2 (left-padded as needed) + # + # Left-to-right language models should condition on *source* and + # predict *future_target*. + # Right-to-left language models should condition on *source* and + # predict *past_target*. + source, future_target, past_target = self.dataset[index] + source, target = self._make_source_target( + source, future_target, past_target + ) + else: + source = self.dataset[index] + target = None + source, target = self._maybe_add_bos(source, target) + return {"id": index, "source": source, "target": target} + + def __len__(self): + return len(self.dataset) + + def _make_source_target(self, source, future_target, past_target): + if self.targets is not None: + target = [] + + if ( + self.add_eos_for_other_targets + and (("self" in self.targets) or ("past" in self.targets)) + and source[-1] != self.vocab.eos() + ): + # append eos at the end of source + source = torch.cat([source, source.new([self.vocab.eos()])]) + + if "future" in self.targets: + future_target = torch.cat( + [future_target, future_target.new([self.vocab.pad()])] + ) + if "past" in self.targets: + # first token is before the start of sentence which is only used in "none" break mode when + # add_eos_for_other_targets is False + past_target = torch.cat( + [ + past_target.new([self.vocab.pad()]), + past_target[1:], + source[-2, None], + ] + ) + + for t in self.targets: + if t == "self": + target.append(source) + elif t == "future": + target.append(future_target) + elif t == "past": + target.append(past_target) + else: + raise Exception("invalid target " + t) + + if len(target) == 1: + target = target[0] + else: + target = future_target + + return source, self._filter_vocab(target) + + def _maybe_add_bos(self, source, target): + if self.add_bos_token: + source = torch.cat([source.new([self.vocab.bos()]), source]) + if target is not None: + target = torch.cat([target.new([self.tgt_vocab.bos()]), target]) + return source, target + + def num_tokens_vec(self, indices): + """Return the number of tokens for a set of positions defined by indices. + This value is used to enforce ``--max-tokens`` during batching.""" + return self.sizes[indices] + + def _filter_vocab(self, target): + if len(self.tgt_vocab) != len(self.vocab): + + def _filter(target): + mask = target.ge(len(self.tgt_vocab)) + if mask.any(): + target[mask] = self.tgt_vocab.unk() + return target + + if isinstance(target, list): + return [_filter(t) for t in target] + return _filter(target) + return target + + def collater(self, samples): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[dict]): samples to collate + + Returns: + dict: a mini-batch with the following keys: + + - `id` (LongTensor): example IDs in the original input order + - `ntokens` (int): total number of tokens in the batch + - `net_input` (dict): the input to the Model, containing keys: + + - `src_tokens` (LongTensor): a padded 2D Tensor of tokens in + the source sentence of shape `(bsz, src_len)`. Padding will + appear on the right. + + - `target` (LongTensor): a padded 2D Tensor of tokens in the + target sentence of shape `(bsz, tgt_len)`. Padding will appear + on the right. + """ + return collate( + samples, + self.vocab.pad(), + self.vocab.eos(), + self.fixed_pad_length, + self.pad_to_bsz, + ) + + def num_tokens(self, index): + """Return the number of tokens in a sample. This value is used to + enforce ``--max-tokens`` during batching.""" + return self.sizes[index] + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + return self.sizes[index] + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + if self.shuffle: + order = [np.random.permutation(len(self))] + else: + order = [np.arange(len(self))] + order.append(self.sizes) + return np.lexsort(order) + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + self.dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/multi_corpus_dataset.py b/fairseq/fairseq/data/multi_corpus_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..746155e515897da9fc9c803f9396a45b5cead8d0 --- /dev/null +++ b/fairseq/fairseq/data/multi_corpus_dataset.py @@ -0,0 +1,245 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import time +from collections import OrderedDict +from typing import Dict, List + +import numpy as np +from fairseq.data import data_utils + +from . import FairseqDataset + +logger = logging.getLogger(__name__) + + +class MultiCorpusDataset(FairseqDataset): + """ + Stores multiple instances of FairseqDataset together. Requires each instance + to be the same dataset, as the collate method needs to work on batches with + samples from each dataset. + + Allows specifying a distribution over the datasets to use. Note that unlike + MultiCorpusSampledDataset, this distribution allows sampling for each item, + rather than on a batch level. + + Each time ordered_indices() is called, a new sample is generated with + the specified distribution. + + Args: + datasets: a OrderedDict of FairseqDataset instances. + distribution: a List containing the probability of getting an utterance from + corresponding dataset + seed: random seed for sampling the datsets + sort_indices: if true, will sort the ordered indices by size + batch_sample: if true, will ensure each batch is from a single dataset + """ + + def __init__( + self, + datasets: Dict[str, FairseqDataset], + distribution: List[float], + seed: int, + sort_indices: bool = False, + batch_sample: bool = False, + distributed_rank=None, + ): + super().__init__() + assert isinstance(datasets, OrderedDict) + assert len(datasets) == len(distribution) + assert sum(distribution) == 1 + self.datasets = datasets + self.distribution = distribution + self.seed = seed + self.sort_indices = sort_indices + self.batch_sample = batch_sample + self.distributed_rank = distributed_rank + + # Avoid repeated conversions to list later + self.dataset_list = list(datasets.values()) + self.total_num_instances = 0 + + first_dataset = list(self.datasets.values())[0] + + self.dataset_offsets = [] + for dataset in datasets.values(): + assert isinstance(dataset, FairseqDataset) + assert type(dataset) is type(first_dataset) + self.dataset_offsets.append(self.total_num_instances) + self.total_num_instances += len(dataset) + + def ordered_indices(self): + start = time.time() + with data_utils.numpy_seed(self.seed, self.epoch): + logger.info(f"sampling new dataset with seed {self.seed} epoch {self.epoch}") + sampled_indices = [] + num_selected_instances = 0 + + # For each dataset i, sample self.distribution[i] * self.total_num_instances + for i, key in enumerate(self.datasets): + + if i < len(self.datasets) - 1: + num_instances = int(self.distribution[i] * self.total_num_instances) + high = self.dataset_offsets[i + 1] + else: + num_instances = self.total_num_instances - num_selected_instances + high = self.total_num_instances + + logger.info(f"sampling {num_instances} from {key} dataset") + num_selected_instances += num_instances + + # First, add k copies of the dataset where k = num_instances // len(dataset). + # This ensures an equal distribution of the data points as much as possible. + # For the remaining entries randomly sample them + dataset_size = len(self.datasets[key]) + num_copies = num_instances // dataset_size + dataset_indices = ( + np.random.permutation(high - self.dataset_offsets[i]) + + self.dataset_offsets[i] + )[: num_instances - num_copies * dataset_size] + if num_copies > 0: + sampled_indices += list( + np.concatenate( + ( + np.repeat( + np.arange(self.dataset_offsets[i], high), num_copies + ), + dataset_indices, + ) + ) + ) + else: + sampled_indices += list(dataset_indices) + + assert ( + len(sampled_indices) == self.total_num_instances + ), f"{len(sampled_indices)} vs {self.total_num_instances}" + + np.random.shuffle(sampled_indices) + if self.sort_indices: + sampled_indices.sort(key=lambda i: self.num_tokens(i)) + + logger.info( + "multi_corpus_dataset ordered_indices took {}s".format( + time.time() - start + ) + ) + return np.array(sampled_indices, dtype=np.int64) + + def _map_index(self, index: int): + """ + If dataset A has length N and dataset B has length M + then index 1 maps to index 1 of dataset A, and index N + 1 + maps to index 1 of B. + """ + counter = 0 + for key, dataset in self.datasets.items(): + if index < counter + len(dataset): + return index - counter, key + counter += len(dataset) + raise ValueError( + "Invalid index: {}, max: {}".format(index, self.total_num_instances) + ) + + def __len__(self): + """ + Length of this dataset is the sum of individual datasets + """ + return self.total_num_instances + + def __getitem__(self, index): + new_index, key = self._map_index(index) + try: + item = self.datasets[key][new_index] + item["full_id"] = index + return item + except Exception as e: + e.args = (f"Error from {key} dataset", *e.args) + raise + + def collater(self, samples): + """ + If we are doing batch sampling, then pick the right collater to use. + + Otherwise we assume all collaters are the same. + """ + if len(samples) == 0: + return None + if "full_id" in samples[0]: + _, key = self._map_index(samples[0]["full_id"]) + try: + batch = self.datasets[key].collater(samples) + except Exception: + print(f"Collating failed for key {key}", flush=True) + raise + return batch + else: + # Subclasses may override __getitem__ to not specify full_id + return list(self.datasets.values())[0].collater(samples) + + def num_tokens(self, index: int): + index, key = self._map_index(index) + return self.datasets[key].num_tokens(index) + + def size(self, index: int): + index, key = self._map_index(index) + return self.datasets[key].size(index) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return False + + def set_epoch(self, epoch, **unused): + super().set_epoch(epoch) + logger.info(f"setting epoch of multi_corpus_dataset to {epoch}") + self.epoch = epoch + + @property + def supports_prefetch(self): + return False + + @property + def supports_fetch_outside_dataloader(self): + return all( + self.datasets[key].supports_fetch_outside_dataloader + for key in self.datasets + ) + + def batch_by_size( + self, + indices, + max_tokens=None, + max_sentences=None, + required_batch_size_multiple=1, + ): + if not self.batch_sample: + return super().batch_by_size( + indices, max_tokens, max_sentences, required_batch_size_multiple + ) + + dataset_indices = {key: [] for key in self.datasets} + for i in indices: + _, key = self._map_index(i) + dataset_indices[key].append(i) + + batches = [] + for key in dataset_indices: + cur_batches = super().batch_by_size( + np.array(dataset_indices[key], dtype=np.int64), + max_tokens, + max_sentences, + required_batch_size_multiple, + ) + logger.info(f"Created {len(cur_batches)} batches for dataset {key}") + batches += cur_batches + + # If this dataset is used in a distributed training setup, + # then shuffle such that the order is seeded by the distributed rank + # as well + if self.distributed_rank is not None: + with data_utils.numpy_seed(self.seed, self.epoch, self.distributed_rank): + np.random.shuffle(batches) + return batches diff --git a/fairseq/fairseq/data/multi_corpus_sampled_dataset.py b/fairseq/fairseq/data/multi_corpus_sampled_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..e2e9fdf004dd1da519a170a5e8bc225775776f72 --- /dev/null +++ b/fairseq/fairseq/data/multi_corpus_sampled_dataset.py @@ -0,0 +1,152 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import OrderedDict +from typing import Callable, Dict, List + +import numpy as np + +from . import FairseqDataset + + +def uniform_sampler(x): + # Sample from uniform distribution + return np.random.choice(x, 1).item() + + +class MultiCorpusSampledDataset(FairseqDataset): + """ + Stores multiple instances of FairseqDataset together and in every iteration + creates a batch by first sampling a dataset according to a specified + probability distribution and then getting instances from that dataset. + + Args: + datasets: an OrderedDict of FairseqDataset instances. + sampling_func: A function for sampling over list of dataset keys. + The default strategy is to sample uniformly. + """ + + def __init__( + self, + datasets: Dict[str, FairseqDataset], + sampling_func: Callable[[List], int] = None, + ): + super().__init__() + assert isinstance(datasets, OrderedDict) + self.datasets = datasets + if sampling_func is None: + sampling_func = uniform_sampler + self.sampling_func = sampling_func + + self.total_num_instances = 0 + for _, dataset in datasets.items(): + assert isinstance(dataset, FairseqDataset) + self.total_num_instances += len(dataset) + + self._ordered_indices = None + + def __len__(self): + """ + Length of this dataset is the sum of individual datasets + """ + return self.total_num_instances + + def ordered_indices(self): + """ + Ordered indices for batching. Here we call the underlying + dataset's ordered_indices() so that we get the same random ordering + as we would have from using the underlying dataset directly. + """ + if self._ordered_indices is None: + self._ordered_indices = OrderedDict( + [ + (key, dataset.ordered_indices()) + for key, dataset in self.datasets.items() + ] + ) + return np.arange(len(self)) + + def _map_index_to_dataset(self, key: int, index: int): + """ + Different underlying datasets have different lengths. In order to ensure + we are not accessing an index outside the range of the current dataset + size, we wrap around. This function should be called after we have + created an ordering for this and all underlying datasets. + """ + assert ( + self._ordered_indices is not None + ), "Must call MultiCorpusSampledDataset.ordered_indices() first" + mapped_index = index % len(self.datasets[key]) + return self._ordered_indices[key][mapped_index] + + def __getitem__(self, index: int): + """ + Get the item associated with index from each underlying dataset. + Since index is in the range of [0, TotalNumInstances], we need to + map the index to the dataset before retrieving the item. + """ + return OrderedDict( + [ + (key, dataset[self._map_index_to_dataset(key, index)]) + for key, dataset in self.datasets.items() + ] + ) + + def collater(self, samples: List[Dict]): + """ + Generate a mini-batch for this dataset. + To convert this into a regular mini-batch we use the following + logic: + 1. Select a dataset using the specified probability distribution. + 2. Call the collater function of the selected dataset. + """ + if len(samples) == 0: + return None + + selected_key = self.sampling_func(list(self.datasets.keys())) + selected_samples = [sample[selected_key] for sample in samples] + return self.datasets[selected_key].collater(selected_samples) + + def num_tokens(self, index: int): + """ + Return an example's length (number of tokens), used for batching. Here + we return the max across all examples at index across all underlying + datasets. + """ + return max( + dataset.num_tokens(self._map_index_to_dataset(key, index)) + for key, dataset in self.datasets.items() + ) + + def size(self, index: int): + """ + Return an example's size as a float or tuple. Here we return the max + across all underlying datasets. This value is used when filtering a + dataset with max-positions. + """ + return max( + dataset.size(self._map_index_to_dataset(key, index)) + for key, dataset in self.datasets.items() + ) + + @property + def supports_prefetch(self): + return all( + getattr(dataset, "supports_prefetch", False) + for dataset in self.datasets.values() + ) + + def prefetch(self, indices): + for key, dataset in self.datasets.items(): + dataset.prefetch( + [self._map_index_to_dataset(key, index) for index in indices] + ) + + @property + def supports_fetch_outside_dataloader(self): + return all( + self.datasets[key].supports_fetch_outside_dataloader + for key in self.datasets + ) diff --git a/fairseq/fairseq/data/multilingual/__init__.py b/fairseq/fairseq/data/multilingual/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6264236915a7269a4d920ee8213004374dd86a9a --- /dev/null +++ b/fairseq/fairseq/data/multilingual/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/fairseq/fairseq/data/multilingual/multilingual_data_manager.py b/fairseq/fairseq/data/multilingual/multilingual_data_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..137481b449b9cb5b2b486950c6cea669ac507c48 --- /dev/null +++ b/fairseq/fairseq/data/multilingual/multilingual_data_manager.py @@ -0,0 +1,1136 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools +import json +import logging +import math +import os +from collections import OrderedDict, defaultdict +from argparse import ArgumentError + +from fairseq import utils +from fairseq.data import ( + AppendTokenDataset, + ConcatDataset, + Dictionary, + LanguagePairDataset, + PrependTokenDataset, + SampledMultiDataset, + SampledMultiEpochDataset, + StripTokenDataset, + TransformEosLangPairDataset, + TruncateDataset, + data_utils, + indexed_dataset, +) +from fairseq.data.multilingual.multilingual_utils import ( + EncoderLangtok, + LangTokSpec, + LangTokStyle, + augment_dictionary, + get_lang_tok, +) +from fairseq.data.multilingual.sampled_multi_dataset import CollateFormat +from fairseq.file_io import PathManager +from fairseq.utils import FileContentsAction, csv_str_list, eval_str_dict + + +logger = logging.getLogger(__name__) + +SRC_DICT_NAME = 'src' +TGT_DICT_NAME = 'tgt' + + +def _lang_id(dic: Dictionary, lang: str): + """Return language ID index.""" + idx = dic.index(lang) + assert idx != dic.unk_index, "cannot find language ID for lang {}".format(lang) + return idx + + +def load_sampling_weights(from_file): + with open(from_file) as f: + weights = json.load(f) + return weights + + +class MultilingualDatasetManager(object): + def __init__(self, args, lang_pairs, langs, dicts, sampling_method): + super().__init__() + self.args = args + self.seed = args.seed + self.lang_pairs = lang_pairs + self.extra_lang_pairs = ( + list( + {p for _, v in args.extra_lang_pairs.items() for p in v.split(",")} + ) + if args.extra_lang_pairs + else [] + ) + self.src_langs = {p.split("-")[0] for p in args.lang_pairs + self.extra_lang_pairs} + self.tgt_langs = {p.split("-")[1] for p in args.lang_pairs + self.extra_lang_pairs} + self.langs = langs + self.dicts = dicts + self.lang_dict = self.create_lang_dictionary(self.langs) + self.sampling_method = sampling_method + self.sampling_scheduler = None + self._has_sharded_data = False + self._num_shards_dict = {} + self._training_data_sizes = defaultdict(lambda: {}) + + @classmethod + def setup_data_manager(cls, args, lang_pairs, langs, dicts, sampling_method): + return MultilingualDatasetManager( + args, lang_pairs, langs, dicts, sampling_method + ) + + @staticmethod + def add_args(parser): + parser.add_argument( + "data", + help="colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner", + action=FileContentsAction, + ) + parser.add_argument( + "--langs", + default=None, + type=csv_str_list, + help="a list of languages comma sperated languages which can appear in lang-pairs; " + "note that the ordering determines language token IDs", + ) + parser.add_argument( + "--lang-dict", + default=None, + type=str, + help="an external file which contains a list of " + "languages which can appear in lang-pairs; " + "note that the ordering determines language token IDs; " + "--langs and --lang-dict are two exclusive options", + ) + parser.add_argument('--source-dict', default=None, type=str, + help='path to source dictionary; if specified it will override per language dictionary loading') + parser.add_argument('--target-dict', default=None, type=str, + help='path to target dictionary; if specified it will override per language dictionary loading') + parser.add_argument( + "--lang-tok-style", + default=LangTokStyle.multilingual.value, + type=str, + choices=[LangTokStyle.multilingual.value, LangTokStyle.mbart.value], + help="language token styles", + ) + + parser.add_argument( + "--load-alignments", + action="store_true", + help="load the binarized alignments", + ) + parser.add_argument( + "--left-pad-source", + default="True", + type=str, + metavar="BOOL", + help="pad the source on the left", + ) + parser.add_argument( + "--left-pad-target", + default="False", + type=str, + metavar="BOOL", + help="pad the target on the left", + ) + try: + parser.add_argument( + "--max-source-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the source sequence", + ) + parser.add_argument( + "--max-target-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the target sequence", + ) + except ArgumentError: + # this might have already been defined. Once we transition this to hydra it should be fine to add it here. + pass + parser.add_argument( + "--upsample-primary", + default=1, + type=int, + help="amount to upsample primary dataset", + ) + parser.add_argument( + "--truncate-source", + action="store_true", + default=False, + help="truncate source to max-source-positions", + ) + parser.add_argument( + "--encoder-langtok", + default=None, + type=str, + choices=[EncoderLangtok.src.value, EncoderLangtok.tgt.value], + metavar="SRCTGT", + help="prepend to the beginning of source sentence the source or target " + "language token. (src/tgt)", + ) + parser.add_argument( + "--decoder-langtok", + action="store_true", + help="prepend to the beginning of target sentence the target language token", + ) + parser.add_argument( + "--lang-tok-replacing-bos-eos", action="store_true", default=False + ) + parser.add_argument( + "--enable-lang-ids", + default=False, + action="store_true", + help="whether to include language IDs in samples", + ) + parser.add_argument( + "--enable-reservsed-directions-shared-datasets", + default=False, + action="store_true", + help="whether to allow datasets be used in reversed directions", + ) + + parser.add_argument( + "--extra-data", + help='a dictionary of data name to this path, \ + e.g. {"mined", path_to_mined_data, "denoised": path_to_denoised_data}', + type=lambda uf: eval_str_dict(uf, type=str), + default=None, + ) + parser.add_argument( + "--extra-lang-pairs", + help='a dictionary of data name to the language pairs they serve, \ + e.g. {"mined": comma-separated-lang-pairs, "denoised": comma-separated-lang-pairs}', + type=lambda uf: eval_str_dict(uf, type=str), + default=None, + ) + parser.add_argument( + "--fixed-dictionary", + help="Fixed dictionary to use with model path", + default=None, + type=str, + ) + parser.add_argument( + "--langtoks-specs", + help='a list of comma separated data types that a set of language tokens to be specialized for, \ + e.g. "main,dae,mined". There will be a set of language tokens added to the vocab to \ + distinguish languages in different training data types. If not specified, default language \ + tokens per languages will be added', + default=LangTokSpec.main.value, + type=csv_str_list, + ) + parser.add_argument( + "--langtoks", + help='a dictionary of how to add language tokens, \ + e.g. {"mined": (None, "tgt"), "mono_dae": ("src.dae", "tgt"), "main": \ + ("src", "tgt")}, or {"mined": ("src.mined", "tgt")}', + default=None, + type=lambda uf: eval_str_dict(uf, type=str), + ) + parser.add_argument( + "--sampling-weights-from-file", + help='a file contain a python dictionary of how to sample data sets, \ + e.g. { "main:en_XX-es_XX": 0.2, "mined:en_XX-pt_XX": 0.5, \ + "mono_dae:es_XX-es_XX: 0.3, "main:en_xx-fr_XX": 0.8 }', + default=None, + type=str, + ) + parser.add_argument( + "--sampling-weights", + help='a dictionary of how to sample data sets, \ + e.g. { "main:en_XX-es_XX": 0.2, "mined:en_XX-pt_XX": 0.5, \ + "mono_dae:es_XX-es_XX: 0.3, "main:en_xx-fr_XX": 0.8 }', + default=None, + type=lambda uf: eval_str_dict(uf, type=str), + ) + parser.add_argument( + "--virtual-epoch-size", + default=None, + type=int, + help="virtual epoch size to speed up data loading", + ) + parser.add_argument( + "--virtual-data-size", + default=None, + type=int, + help="virtual data size of the whole joint dataset to speed" + "up data loading and have specific dynamic sampling strategy interval", + ) + + @classmethod + def load_langs(cls, args, **kwargs): + if args.lang_dict and args.langs: + raise ValueError("--langs and --lang-dict can not both be specified") + if args.lang_dict is None and args.langs is None: + logger.warning( + "External language dictionary is not provided; " + "use lang-pairs to infer the set of supported languages. " + "The language ordering is not stable which might cause " + "misalignment in pretraining and finetuning." + ) + # infer from lang_pairs as it is + langs = list( + {x for lang_pair in args.lang_pairs for x in lang_pair.split("-")} + ) + langs = sorted(langs) + logger.info(f"inferred language list: {langs}") + elif args.lang_dict: + with open( + PathManager.get_local_path(args.lang_dict), "r", encoding="utf-8" + ) as f: + langs = [lang.strip() for lang in f.readlines() if lang.strip()] + logger.info( + f"loaded language list from {args.lang_dict} as they are ordered in file" + ) + elif args.langs: + langs = args.langs + logger.info( + f"parsed the language list as they are ordered in the option: {langs}" + ) + return langs + + def has_sharded_data(self, split): + return self._has_sharded_data and split == getattr( + self.args, "train_subset", None + ) + + def _shared_collater(self): + return not (self.args.extra_data and "mono_dae" in self.args.extra_data) and ( + not self.args.lang_tok_replacing_bos_eos + ) + + def estimate_global_pass_epoch(self, epoch): + if self.args.virtual_epoch_size is None or self.args.virtual_data_size is None: + return None + # one epoch more for remaining data in each shard + virtual_epochs_per_shard = math.ceil( + self.args.virtual_data_size / self.args.virtual_epoch_size + ) + # note that fairseq epoch / shard_epoch starts from 1 + shard_epoch = (epoch - 1) // virtual_epochs_per_shard + 1 + return shard_epoch + + @classmethod + def prepare(cls, load_dictionary, args, **kargs): + args.left_pad_source = utils.eval_bool(args.left_pad_source) + args.left_pad_target = utils.eval_bool(args.left_pad_target) + + if not hasattr(args, "shuffle_instance"): + args.shuffle_instance = False + if args.langtoks is None: + args.langtoks = {} + if "main" not in args.langtoks: + src_langtok_spec = args.encoder_langtok if args.encoder_langtok else None + tgt_langtok_spec = "tgt" if args.decoder_langtok else None + args.langtoks["main"] = (src_langtok_spec, tgt_langtok_spec) + + def check_langs(langs, pairs): + messages = [] + for src, tgt in pairs: + if src not in langs or tgt not in langs: + messages.append( + f"language pair {src}-{tgt} contains languages " + "that are not in the language dictionary" + ) + if len(messages) > 0: + raise ValueError(" ".join(messages) + f"; langs: {langs}") + + if args.lang_pairs is None: + raise ValueError( + "--lang-pairs is required. List all the language pairs in the training objective." + ) + if isinstance(args.lang_pairs, str): + args.lang_pairs = args.lang_pairs.split(",") + if args.source_lang is not None or args.target_lang is not None: + training = False + else: + training = True + language_list = cls.load_langs(args, **kargs) + check_langs( + language_list, + ( + [p.split("-") for p in args.lang_pairs] + if training + else [(args.source_lang, args.target_lang)] + ), + ) + + def load_dictionary_and_postproc(path): + d = load_dictionary(path) + augment_dictionary( + dictionary=d, + language_list=language_list, + lang_tok_style=args.lang_tok_style, + langtoks_specs=args.langtoks_specs, + extra_data=args.extra_data, + ) + return d + + dicts = cls.load_all_dictionaries(args, language_list, load_dictionary_and_postproc, training) + return language_list, dicts, training + + @classmethod + def load_all_dictionaries(cls, args, language_list, load_dictionary, training): + dicts = OrderedDict() + if args.source_dict is not None: + dicts[SRC_DICT_NAME] = load_dictionary(args.source_dict) + if args.target_dict is not None: + dicts[TGT_DICT_NAME] = load_dictionary(args.target_dict) + + if training: + extra_lang_pairs = ( + list( + {p for _, v in args.extra_lang_pairs.items() for p in v.split(",")} + ) + if args.extra_lang_pairs + else [] + ) + src_langs_to_load_dicts = sorted( + {p.split("-")[0] for p in (args.lang_pairs + extra_lang_pairs)} + ) + tgt_langs_to_load_dicts = sorted( + {p.split("-")[1] for p in (args.lang_pairs + extra_lang_pairs)} + ) + else: + src_langs_to_load_dicts = [args.source_lang] + tgt_langs_to_load_dicts = [args.target_lang] + + paths = utils.split_paths(args.data) + assert len(paths) > 0 + + def load_dicts(langs_to_load_dicts): + for lang in langs_to_load_dicts: + dicts[lang] = load_dictionary( + os.path.join(paths[0], "dict.{}.txt".format(lang)) + ) + if len(dicts) > 0: + dict0 = next(iter(dicts.values())) + assert dicts[lang].pad() == dict0.pad() + assert dicts[lang].eos() == dict0.eos() + assert dicts[lang].unk() == dict0.unk() + logger.info("[{}] dictionary: {} types".format(lang, len(dicts[lang]))) + + if args.fixed_dictionary is not None: + fixed_dict = load_dictionary(args.fixed_dictionary) + dicts = {lang: fixed_dict for lang in src_langs_to_load_dicts + tgt_langs_to_load_dicts} + else: + if args.source_dict is None: + load_dicts(src_langs_to_load_dicts) + if args.target_dict is None: + load_dicts(tgt_langs_to_load_dicts) + return dicts + + def get_source_dictionary(self, lang): + if self.args.source_dict is not None: + return self.dicts[SRC_DICT_NAME] + else: + return self.dicts[lang] + + def get_target_dictionary(self, lang): + if self.args.target_dict is not None: + return self.dicts[TGT_DICT_NAME] + else: + return self.dicts[lang] + + @classmethod + def create_lang_dictionary(cls, langs): + unk = "<unk>" + # hack to remove symbols other than unk as they are not needed by lang dict + lang_dict = Dictionary(pad=unk, eos=unk, unk=unk, bos=unk) + for lang in langs: + lang_dict.add_symbol(lang) + return lang_dict + + @classmethod + def get_langtok_index(cls, lang_tok, dic): + idx = dic.index(lang_tok) + assert ( + idx != dic.unk_index + ), "cannot find language token {} in the dictionary".format(lang_tok) + return idx + + def get_encoder_langtok(self, src_lang, tgt_lang, spec=None): + if spec is None: + return None + if spec and spec.startswith("src"): + if src_lang is None: + return None + langtok = get_lang_tok( + lang=src_lang, lang_tok_style=self.args.lang_tok_style, spec=spec + ) + else: + if tgt_lang is None: + return None + langtok = get_lang_tok( + lang=tgt_lang, lang_tok_style=self.args.lang_tok_style, spec=spec + ) + return self.get_langtok_index( + langtok, self.get_source_dictionary(src_lang) if src_lang else self.get_target_dictionary(tgt_lang) + ) + + def get_decoder_langtok(self, tgt_lang, spec=None): + if spec is None: + return None + langtok = get_lang_tok( + lang=tgt_lang, lang_tok_style=self.args.lang_tok_style, spec=spec + ) + return self.get_langtok_index(langtok, self.get_target_dictionary(tgt_lang)) + + @classmethod + def load_data(cls, path, vdict, impl): + dataset = data_utils.load_indexed_dataset(path, vdict, impl) + return dataset + + @classmethod + def split_exists(cls, split, src, tgt, lang, data_path, dataset_impl): + filename = os.path.join(data_path, "{}.{}-{}.{}".format(split, src, tgt, lang)) + return indexed_dataset.dataset_exists(filename, impl=dataset_impl) + + def load_lang_dataset( + self, + data_path, + split, + src, + src_dict, + tgt, + tgt_dict, + combine, + dataset_impl, + upsample_primary, + max_source_positions, + prepend_bos=False, + load_alignments=False, + truncate_source=False, + ): + + src_datasets = [] + tgt_datasets = [] + + for k in itertools.count(): + split_k = split + (str(k) if k > 0 else "") + + # infer langcode + if self.split_exists(split_k, src, tgt, src, data_path, dataset_impl): + prefix = os.path.join(data_path, "{}.{}-{}.".format(split_k, src, tgt)) + elif self.split_exists(split_k, tgt, src, src, data_path, dataset_impl): + prefix = os.path.join(data_path, "{}.{}-{}.".format(split_k, tgt, src)) + else: + if k > 0: + break + else: + logger.error( + f"Dataset not found: {data_path}, {split_k}, {src}, {tgt}" + ) + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, data_path) + ) + + src_dataset = self.load_data(prefix + src, src_dict, dataset_impl) + if truncate_source: + src_dataset = AppendTokenDataset( + TruncateDataset( + StripTokenDataset(src_dataset, src_dict.eos()), + max_source_positions - 1, + ), + src_dict.eos(), + ) + src_datasets.append(src_dataset) + tgt_datasets.append(self.load_data(prefix + tgt, tgt_dict, dataset_impl)) + + logger.info( + "{} {} {}-{} {} examples".format( + data_path, split_k, src, tgt, len(src_datasets[-1]) + ) + ) + + if not combine: + break + + assert len(src_datasets) == len(tgt_datasets) + + if len(src_datasets) == 1: + src_dataset, tgt_dataset = src_datasets[0], tgt_datasets[0] + else: + sample_ratios = [1] * len(src_datasets) + sample_ratios[0] = upsample_primary + src_dataset = ConcatDataset(src_datasets, sample_ratios) + tgt_dataset = ConcatDataset(tgt_datasets, sample_ratios) + + if prepend_bos: + assert hasattr(src_dict, "bos_index") and hasattr(tgt_dict, "bos_index") + src_dataset = PrependTokenDataset(src_dataset, src_dict.bos()) + tgt_dataset = PrependTokenDataset(tgt_dataset, tgt_dict.bos()) + + align_dataset = None + if load_alignments: + align_path = os.path.join( + data_path, "{}.align.{}-{}".format(split, src, tgt) + ) + if indexed_dataset.dataset_exists(align_path, impl=dataset_impl): + align_dataset = data_utils.load_indexed_dataset( + align_path, None, dataset_impl + ) + + return src_dataset, tgt_dataset, align_dataset + + def load_langpair_dataset( + self, + data_path, + split, + src, + src_dict, + tgt, + tgt_dict, + combine, + dataset_impl, + upsample_primary, + left_pad_source, + left_pad_target, + max_source_positions, + max_target_positions, + prepend_bos=False, + load_alignments=False, + truncate_source=False, + src_dataset_transform_func=lambda dataset: dataset, + tgt_dataset_transform_func=lambda dataset: dataset, + src_lang_id=None, + tgt_lang_id=None, + langpairs_sharing_datasets=None, + ): + norm_direction = "-".join(sorted([src, tgt])) + if langpairs_sharing_datasets is not None: + src_dataset = langpairs_sharing_datasets.get( + (data_path, split, norm_direction, src), "NotInCache" + ) + tgt_dataset = langpairs_sharing_datasets.get( + (data_path, split, norm_direction, tgt), "NotInCache" + ) + align_dataset = langpairs_sharing_datasets.get( + (data_path, split, norm_direction, src, tgt), "NotInCache" + ) + + # a hack: any one is not in cache, we need to reload them + if ( + langpairs_sharing_datasets is None + or src_dataset == "NotInCache" + or tgt_dataset == "NotInCache" + or align_dataset == "NotInCache" + or split != getattr(self.args, "train_subset", None) + ): + # source and target datasets can be reused in reversed directions to save memory + # reversed directions of valid and test data will not share source and target datasets + src_dataset, tgt_dataset, align_dataset = self.load_lang_dataset( + data_path, + split, + src, + src_dict, + tgt, + tgt_dict, + combine, + dataset_impl, + upsample_primary, + max_source_positions=max_source_positions, + prepend_bos=prepend_bos, + load_alignments=load_alignments, + truncate_source=truncate_source, + ) + src_dataset = src_dataset_transform_func(src_dataset) + tgt_dataset = tgt_dataset_transform_func(tgt_dataset) + if langpairs_sharing_datasets is not None: + langpairs_sharing_datasets[ + (data_path, split, norm_direction, src) + ] = src_dataset + langpairs_sharing_datasets[ + (data_path, split, norm_direction, tgt) + ] = tgt_dataset + langpairs_sharing_datasets[ + (data_path, split, norm_direction, src, tgt) + ] = align_dataset + if align_dataset is None: + # no align data so flag the reverse direction as well in sharing + langpairs_sharing_datasets[ + (data_path, split, norm_direction, tgt, src) + ] = align_dataset + else: + logger.info( + f"Reusing source and target datasets of [{split}] {tgt}-{src} for reversed direction: " + f"[{split}] {src}-{tgt}: src length={len(src_dataset)}; tgt length={len(tgt_dataset)}" + ) + + return LanguagePairDataset( + src_dataset, + src_dataset.sizes, + src_dict, + tgt_dataset, + tgt_dataset.sizes if tgt_dataset is not None else None, + tgt_dict, + left_pad_source=left_pad_source, + left_pad_target=left_pad_target, + align_dataset=align_dataset, + src_lang_id=src_lang_id, + tgt_lang_id=tgt_lang_id, + ) + + def src_dataset_tranform_func(self, src_lang, tgt_lang, dataset, spec=None): + if self.args.lang_tok_replacing_bos_eos: + # it is handled by self.alter_dataset_langtok + # TODO: Unifiy with alter_dataset_langtok + return dataset + if spec is None: + return dataset + tok = self.get_encoder_langtok(src_lang, tgt_lang, spec) + if tok: + return PrependTokenDataset(dataset, tok) + return dataset + + def tgt_dataset_tranform_func(self, source_lang, target_lang, dataset, spec=None): + if dataset is None: + # note that target dataset can be None during inference time + return None + if self.args.lang_tok_replacing_bos_eos: + # TODO: Unifiy with alter_dataset_langtok + # It is handled by self.alter_dataset_langtok. + # The complication in self.alter_dataset_langtok + # makes a unified framework difficult. + return dataset + # if not self.args.decoder_langtok: + if not spec: + return dataset + tok = self.get_decoder_langtok(target_lang, spec) + if tok: + return PrependTokenDataset(dataset, tok) + return dataset + + def alter_dataset_langtok( + self, + lang_pair_dataset, + src_eos=None, + src_lang=None, + tgt_eos=None, + tgt_lang=None, + src_langtok_spec=None, + tgt_langtok_spec=None, + ): + if src_langtok_spec is None and tgt_langtok_spec is None: + return lang_pair_dataset + + new_src_eos = None + if ( + src_langtok_spec is not None + and src_eos is not None + and (src_lang is not None or tgt_lang is not None) + ): + new_src_eos = self.get_encoder_langtok(src_lang, tgt_lang, src_langtok_spec) + else: + src_eos = None + + new_tgt_bos = None + if tgt_langtok_spec and tgt_eos is not None and tgt_lang is not None: + new_tgt_bos = self.get_decoder_langtok(tgt_lang, tgt_langtok_spec) + else: + tgt_eos = None + + return TransformEosLangPairDataset( + lang_pair_dataset, + src_eos=src_eos, + new_src_eos=new_src_eos, + tgt_bos=tgt_eos, + new_tgt_bos=new_tgt_bos, + ) + + def load_a_dataset( + self, + split, + data_path, + src, + src_dict, + tgt, + tgt_dict, + combine, + prepend_bos=False, + langpairs_sharing_datasets=None, + data_category=None, + **extra_kwargs, + ): + dataset_impl = self.args.dataset_impl + upsample_primary = self.args.upsample_primary + left_pad_source = self.args.left_pad_source + left_pad_target = self.args.left_pad_target + max_source_positions = self.args.max_source_positions + max_target_positions = self.args.max_target_positions + load_alignments = self.args.load_alignments + truncate_source = self.args.truncate_source + src_dataset_transform_func = self.src_dataset_tranform_func + tgt_dataset_transform_func = self.tgt_dataset_tranform_func + enable_lang_ids = self.args.enable_lang_ids + lang_dictionary = self.lang_dict + src_langtok_spec, tgt_langtok_spec = extra_kwargs["langtok_spec"] + + src_langtok = self.get_encoder_langtok(src, tgt, src_langtok_spec) + tgt_langtok = self.get_decoder_langtok(tgt, tgt_langtok_spec) + logger.info( + f"{data_category}:{src}-{tgt} src_langtok: {src_langtok}; tgt_langtok: {tgt_langtok}" + ) + + langpair_ds = self.load_langpair_dataset( + data_path, + split, + src, + src_dict, + tgt, + tgt_dict, + combine, + dataset_impl, + upsample_primary, + left_pad_source, + left_pad_target, + max_source_positions, + max_target_positions, + prepend_bos, + load_alignments, + truncate_source, + src_dataset_transform_func=lambda dataset: src_dataset_transform_func( + src, tgt, dataset, src_langtok_spec + ), + tgt_dataset_transform_func=lambda dataset: tgt_dataset_transform_func( + src, tgt, dataset, tgt_langtok_spec + ), + src_lang_id=_lang_id(lang_dictionary, src) + if enable_lang_ids and lang_dictionary is not None + else None, + tgt_lang_id=_lang_id(lang_dictionary, tgt) + if enable_lang_ids and lang_dictionary is not None + else None, + langpairs_sharing_datasets=langpairs_sharing_datasets, + ) + # TODO: handle modified lang toks for mined data and dae data + if self.args.lang_tok_replacing_bos_eos: + ds = self.alter_dataset_langtok( + langpair_ds, + src_eos=self.get_source_dictionary(src).eos() if src else self.get_target_dictionary(tgt).eos(), + src_lang=src, + tgt_eos=self.get_target_dictionary(tgt).eos(), + tgt_lang=tgt, + src_langtok_spec=src_langtok_spec, + tgt_langtok_spec=tgt_langtok_spec, + ) + else: + ds = langpair_ds + return ds + + def load_split_langpair_datasets(self, split, data_param_list): + datasets = [] + langpairs_sharing_datasets = ( + {} if self.args.enable_reservsed_directions_shared_datasets else None + ) + for param in data_param_list: + ds = self.load_a_dataset( + split=split, + langpairs_sharing_datasets=langpairs_sharing_datasets, + **param, + ) + datasets.append(ds) + return datasets + + def get_data_paths_and_lang_pairs(self, split): + datapaths = {"main": self.args.data} + lang_pairs = {"main": self.lang_pairs} + if split == getattr(self.args, "train_subset", None): + # only training data can have extra data and extra language pairs + if self.args.extra_data: + extra_datapaths = self.args.extra_data + datapaths.update(extra_datapaths) + if self.args.extra_lang_pairs: + extra_lang_pairs = { + k: v.split(",") for k, v in self.args.extra_lang_pairs.items() + } + lang_pairs.update(extra_lang_pairs) + return datapaths, lang_pairs + + @classmethod + def get_dataset_key(cls, data_category, src, tgt): + return f"{data_category}:{src}-{tgt}" + + @classmethod + def _get_shard_num_dict(cls, split, paths): + shards = defaultdict(int) + for path in paths: + files = PathManager.ls(path) + directions = set() + for f in files: + if f.startswith(split) and f.endswith(".idx"): + # idx files of the form "{split}.{src}-{tgt}.{lang}.idx" + direction = f.split(".")[-3] + directions.add(direction) + for direction in directions: + shards[direction] += 1 + return shards + + def get_split_num_data_shards(self, split): + if split in self._num_shards_dict: + return self._num_shards_dict[split] + num_shards_dict = {} + data_paths, lang_pairs = self.get_data_paths_and_lang_pairs(split) + + for data_category, paths in data_paths.items(): + if data_category not in lang_pairs: + continue + paths = utils.split_paths(paths) + shards_dict = self._get_shard_num_dict(split, paths) + lang_dirs = [ + lang_pair.split("-") for lang_pair in lang_pairs[data_category] + ] + lang_dirs = [x if len(x) > 1 else (x[0], x[0]) for x in lang_dirs] + for src, tgt in lang_dirs: + key = self.get_dataset_key(data_category, src, tgt) + if "mono_" in data_category: + # monolingual data requires tgt only + assert src is None or src == tgt, ( + f"error: src={src}, " + "tgt={tgt} for data_category={data_category}" + ) + num_shards_dict[key] = shards_dict[tgt] + else: + if f"{src}-{tgt}" in shards_dict: + num_shards_dict[key] = shards_dict[f"{src}-{tgt}"] + elif f"{tgt}-{src}" in shards_dict: + # follow the fairseq tradition to use reversed direction data if it is not available + num_shards_dict[key] = shards_dict[f"{tgt}-{src}"] + self._num_shards_dict[split] = num_shards_dict + logger.info(f"[{split}] num of shards: {num_shards_dict}") + return num_shards_dict + + @classmethod + def get_shard_id(cls, num_shards, epoch, shard_epoch=None): + shard = epoch if shard_epoch is None else shard_epoch + shard = (shard - 1) % num_shards + return shard + + def get_split_data_path(self, paths, epoch, shard_epoch, num_shards): + path = paths[self.get_shard_id(num_shards, epoch, shard_epoch)] + return path + + def get_split_data_param_list(self, split, epoch, shard_epoch=None): + # TODO: to extend with extra datasets and keys and loop over different shard data paths + param_list = [] + data_paths, lang_pairs = self.get_data_paths_and_lang_pairs(split) + logger.info(f"langtoks settings: {self.args.langtoks}") + split_num_shards_dict = self.get_split_num_data_shards(split) + for data_category, paths in data_paths.items(): + if data_category not in lang_pairs: + continue + paths = utils.split_paths(paths) + assert len(paths) > 0 + if len(paths) > 1: + self._has_sharded_data = True + if split != getattr(self.args, "train_subset", None): + # if not training data set, use the first shard for valid and test + paths = paths[:1] + + if data_category in self.args.langtoks: + lang_tok_spec = self.args.langtoks[data_category] + else: + # default to None + lang_tok_spec = (None, None) + + # infer langcode + lang_dirs = [ + lang_pair.split("-") for lang_pair in lang_pairs[data_category] + ] + lang_dirs = [x if len(x) > 1 else (x[0], x[0]) for x in lang_dirs] + for src, tgt in lang_dirs: + assert src is not None or data_category == "mono_dae", ( + f"error: src={src}, " "tgt={tgt} for data_category={data_category}" + ) + # logger.info(f"preparing param for {data_category}: {src} - {tgt}") + key = self.get_dataset_key(data_category, src, tgt) + data_path = self.get_split_data_path( + paths, epoch, shard_epoch, split_num_shards_dict[key] + ) + param_list.append( + { + "key": key, + "data_path": data_path, + "split": split, + "src": src, + "src_dict": self.get_source_dictionary(src) + if src and data_category != "mono_dae" + else None, + "tgt": tgt, + "tgt_dict": self.get_target_dictionary(tgt), + "data_category": data_category, + "langtok_spec": lang_tok_spec, + } + ) + return param_list + + def get_train_dataset_sizes( + self, data_param_list, datasets, epoch, shard_epoch=None + ): + num_shards = [ + self.get_split_num_data_shards(param["split"])[param["key"]] + for param in data_param_list + ] + data_sizes = [] + for (key, d), num_shard in zip(datasets, num_shards): + my_data_sizes = self._training_data_sizes[key] + shard_ind = self.get_shard_id(num_shard, epoch, shard_epoch) + if shard_ind not in my_data_sizes: + my_data_sizes[shard_ind] = len(d) + known_size = max(my_data_sizes.values()) + data_sizes.append( + # If we don't know the data size of the shard yet, + # use the the max known data size to approximate. + # Note that we preprocess shards by a designated shard size + # and put any remaining data at the end into the last shard so + # the max shard size approximation is almost correct before loading + # the last shard; after loading the last shard, it will have the + # exact data sizes of the whole data size. + (key, sum(my_data_sizes.get(i, known_size) for i in range(num_shard))) + ) + logger.info( + f"estimated total data sizes of all shards used in sampling ratios: {data_sizes}. " + "Note that if the data a shard has not been loaded yet, use the max known data size to approximate" + ) + return [s for _, s in data_sizes] + + def get_train_sampling_ratios( + self, data_param_list, datasets, epoch=1, shard_epoch=None + ): + data_sizes = self.get_train_dataset_sizes( + data_param_list, datasets, epoch, shard_epoch + ) + sampling_func = self.sampling_method.sampling_method_selector() + sample_ratios = sampling_func(data_sizes) if sampling_func is not None else None + return sample_ratios + + def get_sampling_ratios(self, data_param_list, datasets, epoch, shard_epoch=None): + if self.args.sampling_weights_from_file: + weights = load_sampling_weights(self.args.sampling_weights_from_file) + sample_ratios = [weights[k] for k, _ in datasets] + logger.info( + "| ignoring --sampling-weights when loadding sampling weights " + f"from file {self.args.sampling_weights_from_file}" + ) + elif self.args.sampling_weights: + sample_ratios = [self.args.sampling_weights[k] for k, _ in datasets] + else: + sample_ratios = self.get_train_sampling_ratios( + data_param_list, datasets, epoch, shard_epoch + ) + + if sample_ratios is not None: + logger.info( + "| Upsample ratios: {}".format( + list(zip(map(lambda x: x["key"], data_param_list), sample_ratios)) + ) + ) + assert len(sample_ratios) == len(datasets) + return sample_ratios + + def load_split_datasets( + self, split, training, epoch=1, combine=False, shard_epoch=None, **kwargs + ): + data_param_list = self.get_split_data_param_list( + split, epoch, shard_epoch=shard_epoch + ) + langpairs_sharing_datasets = ( + {} if self.args.enable_reservsed_directions_shared_datasets else None + ) + datasets = [ + ( + param["key"], + self.load_a_dataset( + combine=combine, + langpairs_sharing_datasets=langpairs_sharing_datasets, + **param, + ), + ) + for param in data_param_list + ] + return datasets, data_param_list + + def load_into_concat_dataset(self, split, datasets, data_param_list): + if self.args.lang_tok_replacing_bos_eos: + # TODO: to investigate why TransformEosLangPairDataset doesn't work with ConcatDataset + return SampledMultiDataset( + OrderedDict(datasets), + sampling_ratios=None, + eval_key=None, + collate_format=CollateFormat.single, + virtual_size=None, + split=split, + ) + return ConcatDataset([d for _, d in datasets]) + + def load_sampled_multi_epoch_dataset( + self, split, training, epoch=0, combine=False, shard_epoch=None, **kwargs + ): + datasets, data_param_list = self.load_split_datasets( + split, training, epoch, combine, shard_epoch=shard_epoch, **kwargs + ) + if training and split == getattr(self.args, "train_subset", None): + sample_ratios = self.get_sampling_ratios(data_param_list, datasets, epoch) + return SampledMultiEpochDataset( + OrderedDict(datasets), + epoch=epoch, + shard_epoch=shard_epoch, + # valid and test datasets will be degenerate to concating datasets: + sampling_ratios=sample_ratios, + eval_key=None, + collate_format=CollateFormat.single, + virtual_size=self.args.virtual_data_size, + split=split, + virtual_epoch_size=self.args.virtual_epoch_size, + # if not using lang_tok altering, simplified to use the same collater + shared_collater=self._shared_collater(), + ) + else: + return self.load_into_concat_dataset(split, datasets, data_param_list) + + def load_sampled_multi_dataset( + self, split, training, epoch=0, combine=False, shard_epoch=None, **kwargs + ): + datasets, data_param_list = self.load_split_datasets( + split, training, epoch, combine, shard_epoch=shard_epoch, **kwargs + ) + if training and split == getattr(self.args, "train_subset", None): + sample_ratios = self.get_sampling_ratios(data_param_list, datasets, epoch) + return SampledMultiDataset( + OrderedDict(datasets), + epoch=epoch, + # valid and test datasets will be degerate to concating datasets: + sampling_ratios=sample_ratios, + eval_key=None, + collate_format=CollateFormat.single, + virtual_size=self.args.virtual_data_size, + split=split, + # if not using lang_tok altering, simplified to use the same collater + shared_collater=self._shared_collater(), + ) + else: + return self.load_into_concat_dataset(split, datasets, data_param_list) + + def load_dataset( + self, split, training, epoch=0, combine=False, shard_epoch=None, **kwargs + ): + if self.args.virtual_epoch_size is None: + return self.load_sampled_multi_dataset( + split, training, epoch, combine, shard_epoch, **kwargs + ) + else: + return self.load_sampled_multi_epoch_dataset( + split, training, epoch, combine, shard_epoch, **kwargs + ) diff --git a/fairseq/fairseq/data/multilingual/multilingual_utils.py b/fairseq/fairseq/data/multilingual/multilingual_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b4e0f9828cabfdbe375d05d9152b58bdbd6de7dc --- /dev/null +++ b/fairseq/fairseq/data/multilingual/multilingual_utils.py @@ -0,0 +1,63 @@ +from enum import Enum +from typing import Dict, List, Optional, Sequence + +import torch +from fairseq.data import Dictionary + + +class EncoderLangtok(Enum): + """ + Prepend to the beginning of source sentence either the + source or target language token. (src/tgt). + """ + + src = "src" + tgt = "tgt" + + +class LangTokSpec(Enum): + main = "main" + mono_dae = "mono_dae" + + +class LangTokStyle(Enum): + multilingual = "multilingual" + mbart = "mbart" + + +@torch.jit.export +def get_lang_tok( + lang: str, lang_tok_style: str, spec: str = LangTokSpec.main.value +) -> str: + # TOKEN_STYLES can't be defined outside this fn since it needs to be + # TorchScriptable. + TOKEN_STYLES: Dict[str, str] = { + LangTokStyle.mbart.value: "[{}]", + LangTokStyle.multilingual.value: "__{}__", + } + + if spec.endswith("dae"): + lang = f"{lang}_dae" + elif spec.endswith("mined"): + lang = f"{lang}_mined" + style = TOKEN_STYLES[lang_tok_style] + return style.format(lang) + + +def augment_dictionary( + dictionary: Dictionary, + language_list: List[str], + lang_tok_style: str, + langtoks_specs: Sequence[str] = (LangTokSpec.main.value,), + extra_data: Optional[Dict[str, str]] = None, +) -> None: + for spec in langtoks_specs: + for language in language_list: + dictionary.add_symbol( + get_lang_tok(lang=language, lang_tok_style=lang_tok_style, spec=spec) + ) + + if lang_tok_style == LangTokStyle.mbart.value or ( + extra_data is not None and LangTokSpec.mono_dae.value in extra_data + ): + dictionary.add_symbol("<mask>") diff --git a/fairseq/fairseq/data/multilingual/sampled_multi_dataset.py b/fairseq/fairseq/data/multilingual/sampled_multi_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..b0a617424ee3c5923b37796773da4c97851a16c5 --- /dev/null +++ b/fairseq/fairseq/data/multilingual/sampled_multi_dataset.py @@ -0,0 +1,467 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import datetime +import hashlib +import logging +import time +from bisect import bisect_right +from collections import OrderedDict, defaultdict +from enum import Enum +from typing import List + +import numpy as np +import torch +from fairseq.data import FairseqDataset, data_utils +from fairseq.distributed import utils as distributed_utils + + +def get_time_gap(s, e): + return ( + datetime.datetime.fromtimestamp(e) - datetime.datetime.fromtimestamp(s) + ).__str__() + + +logger = logging.getLogger(__name__) + + +def default_virtual_size_func(datasets, ratios, max_scale_up=1.5): + sizes = [len(d) for d in datasets] + if ratios is None: + return sum(sizes) + largest_idx = np.argmax(sizes) + largest_r = ratios[largest_idx] + largest_s = sizes[largest_idx] + # set virtual sizes relative to the largest dataset + virtual_sizes = [(r / largest_r) * largest_s for r in ratios] + vsize = sum(virtual_sizes) + max_size = sum(sizes) * max_scale_up + return int(vsize if vsize < max_size else max_size) + + +class CollateFormat(Enum): + single = 1 + ordered_dict = 2 + + +class SampledMultiDataset(FairseqDataset): + """Samples from multiple sub-datasets according to given sampling ratios. + Args: + datasets ( + List[~torch.utils.data.Dataset] + or OrderedDict[str, ~torch.utils.data.Dataset] + ): datasets + sampling_ratios (List[float]): list of probability of each dataset to be sampled + (default: None, which corresponds to concatenating all dataset together). + seed (int): RNG seed to use (default: 2). + epoch (int): starting epoch number (default: 1). + eval_key (str, optional): a key used at evaluation time that causes + this instance to pass-through batches from *datasets[eval_key]*. + collate_format (CollateFormat): collater output format, either CollateFormat.ordered_dict or + CollateFormat.single (default: CollateFormat.single) where CollateFormat.single configures + the collater to output batches of data mixed from all sub-datasets, + and CollateFormat.ordered_dict configures the collater to output a dictionary of batches indexed by keys + of sub-datasets. + Note that not all sub-datasets will present in a single batch in both formats. + virtual_size (int, or callable): the expected virtual size of the dataset (default: default_virtual_size_func). + split (str): the split of the data, e.g. 'train', 'valid' or 'test'. + shared_collater (bool): whether or not to all sub-datasets have the same collater. + shuffle (bool): whether or not to shuffle data (default: True). + """ + + def __init__( + self, + datasets, + sampling_ratios=None, + seed=2, + epoch=1, + eval_key=None, + collate_format=CollateFormat.single, + virtual_size=default_virtual_size_func, + split="", + shared_collater=False, + shuffle=True, + ): + super().__init__() + self.shared_collater = shared_collater + self.shuffle = shuffle + + if isinstance(datasets, OrderedDict): + self.keys = list(datasets.keys()) + datasets = list(datasets.values()) + elif isinstance(datasets, List): + self.keys = list(range(len(datasets))) + else: + raise AssertionError() + self.datasets = datasets + self.split = split + + self.eval_key = eval_key + if self.eval_key is not None: + self.collate_format = CollateFormat.single + else: + self.collate_format = collate_format + + self.seed = seed + self._cur_epoch = None + + self.cumulated_sizes = None + # self.datasets[k][self._cur_indices[i]] is the data item i in this sampled dataset + # namely, data item i is sampled from the kth sub-dataset self.datasets[k] + # where self.cumulated_sizes[k-1] <= i < self.cumulated_sizes[k] + self._cur_indices = None + + self._sizes = None + self.virtual_size_per_dataset = None + # caching properties + self._reset_cached_properties() + self.setup_sampling(sampling_ratios, virtual_size) + self.set_epoch(epoch) + + def _clean_if_not_none(self, var_list): + for v in var_list: + if v is not None: + del v + + def _reset_cached_properties(self): + self._clean_if_not_none([self._sizes, self._cur_indices]) + self._sizes = None + self._cur_indices = None + + def setup_sampling(self, sample_ratios, virtual_size): + sizes = [len(d) for d in self.datasets] + if sample_ratios is None: + # default back to concating datasets + self.sample_ratios = None + self.virtual_size = sum(sizes) + else: + if not isinstance(sample_ratios, np.ndarray): + sample_ratios = np.array(sample_ratios) + self.sample_ratios = sample_ratios + virtual_size = ( + default_virtual_size_func if virtual_size is None else virtual_size + ) + self.virtual_size = ( + virtual_size(self.datasets, self.sample_ratios) + if callable(virtual_size) + else virtual_size + ) + + def adjust_sampling(self, epoch, sampling_ratios, virtual_size): + if sampling_ratios is not None: + sampling_ratios = self._sync_sample_ratios(sampling_ratios) + self.setup_sampling(sampling_ratios, virtual_size) + + def _sync_sample_ratios(self, ratios): + # in case the ratios are not precisely the same across processes + # also to ensure every procresses update the ratios in the same pace + ratios = torch.DoubleTensor(ratios) + if torch.distributed.is_initialized(): + if torch.cuda.is_available(): + distributed_utils.all_reduce( + ratios.cuda(), group=distributed_utils.get_data_parallel_group() + ) + else: + distributed_utils.all_reduce( + ratios, group=distributed_utils.get_data_parallel_group() + ) + ret = ratios.cpu() + ret = ret.numpy() + return ret + + def random_choice_in_dataset(self, rng, dataset, choice_size): + if hasattr(dataset, "random_choice_in_dataset"): + return dataset.random_choice_in_dataset(rng, choice_size) + dataset_size = len(dataset) + return rng.choice( + dataset_size, choice_size, replace=(choice_size > dataset_size) + ) + + def get_virtual_indices(self, rng, datasets, sample_ratios, virtual_size): + def get_counts(sample_ratios): + counts = np.array([virtual_size * r for r in sample_ratios], dtype=np.int64) + diff = virtual_size - counts.sum() + assert diff >= 0 + # due to round-offs, the size might not match the desired sizes + if diff > 0: + dataset_indices = rng.choice( + len(sample_ratios), size=diff, p=sample_ratios + ) + for i in dataset_indices: + counts[i] += 1 + return counts + + def get_in_dataset_indices(datasets, sizes, sample_ratios): + counts = get_counts(sample_ratios) + # uniformally sample desired counts for each dataset + # if the desired counts are large, sample with replacement: + indices = [ + self.random_choice_in_dataset(rng, d, c) + for c, d in zip(counts, datasets) + ] + return indices + + sizes = [len(d) for d in datasets] + if sample_ratios is None: + # default back to concating datasets + in_dataset_indices = [list(range(s)) for s in sizes] + virtual_sizes_per_dataset = sizes + else: + ratios = sample_ratios / sample_ratios.sum() + in_dataset_indices = get_in_dataset_indices(datasets, sizes, ratios) + virtual_sizes_per_dataset = [len(d) for d in in_dataset_indices] + virtual_sizes_per_dataset = np.array(virtual_sizes_per_dataset, np.int64) + cumulative_sizes = np.cumsum(virtual_sizes_per_dataset) + assert sum(virtual_sizes_per_dataset) == virtual_size + assert cumulative_sizes[-1] == virtual_size + if virtual_size < sum(sizes): + logger.warning( + f"virtual data size ({virtual_size}) is less than real data size ({sum(sizes)})." + " If virtual size << real data size, there could be data coverage issue." + ) + in_dataset_indices = np.hstack(in_dataset_indices) + return in_dataset_indices, cumulative_sizes, virtual_sizes_per_dataset + + def _get_dataset_and_index(self, index): + i = bisect_right(self.cumulated_sizes, index) + return i, self._cur_indices[index] + + def __getitem__(self, index): + # self.__getitem__(index) returns self.datasets[k][self._cur_indices[index]] + # where k satisfies self.cumulated_sizes[k - 1] <= k < self.cumulated_sizes[k] + ds_idx, ds_sample_idx = self._get_dataset_and_index(index) + ret = (ds_idx, self.datasets[ds_idx][ds_sample_idx]) + return ret + + def num_tokens(self, index): + return self.sizes[index].max() + + def num_tokens_vec(self, indices): + sizes_vec = self.sizes[np.array(indices)] + # max across all dimensions but first one + return np.amax(sizes_vec, axis=tuple(range(1, len(sizes_vec.shape)))) + + def size(self, index): + return self.sizes[index] + + def __len__(self): + return self.virtual_size + + def collater(self, samples, **extra_args): + """Merge a list of samples to form a mini-batch.""" + if len(samples) == 0: + return None + if self.collate_format == "ordered_dict": + collect_samples = [[] for _ in range(len(self.datasets))] + for (i, sample) in samples: + collect_samples[i].append(sample) + batch = OrderedDict( + [ + (self.keys[i], dataset.collater(collect_samples[i])) + for i, (key, dataset) in enumerate(zip(self.keys, self.datasets)) + if len(collect_samples[i]) > 0 + ] + ) + elif self.shared_collater: + batch = self.datasets[0].collater([s for _, s in samples]) + else: + samples_dict = defaultdict(list) + pad_to_length = ( + defaultdict(int) + if "pad_to_length" not in extra_args + else extra_args["pad_to_length"] + ) + for ds_idx, s in samples: + pad_to_length["source"] = max( + pad_to_length["source"], s["source"].size(0) + ) + if s["target"] is not None: + pad_to_length["target"] = max( + pad_to_length["target"], s["target"].size(0) + ) + samples_dict[ds_idx].append(s) + batches = [ + self.datasets[i].collater(samples_dict[i], pad_to_length=pad_to_length) + for i in range(len(self.datasets)) + if len(samples_dict[i]) > 0 + ] + + def straight_data(tensors): + batch = torch.cat(tensors, dim=0) + return batch + + src_lengths = straight_data( + [b["net_input"]["src_lengths"] for b in batches] + ) + src_lengths, sort_order = src_lengths.sort(descending=True) + + def straight_order(tensors): + batch = straight_data(tensors) + return batch.index_select(0, sort_order) + + batch = { + "id": straight_order([b["id"] for b in batches]), + "nsentences": sum(b["nsentences"] for b in batches), + "ntokens": sum(b["ntokens"] for b in batches), + "net_input": { + "src_tokens": straight_order( + [b["net_input"]["src_tokens"] for b in batches] + ), + "src_lengths": src_lengths, + }, + "target": straight_order([b["target"] for b in batches]) + if batches[0]["target"] is not None + else None, + } + if "prev_output_tokens" in batches[0]["net_input"]: + batch["net_input"]["prev_output_tokens"] = straight_order( + [b["net_input"]["prev_output_tokens"] for b in batches] + ) + if "src_lang_id" in batches[0]["net_input"]: + batch["net_input"]["src_lang_id"] = straight_order( + [b["net_input"]["src_lang_id"] for b in batches] + ) + if "tgt_lang_id" in batches[0]: + batch["tgt_lang_id"] = straight_order( + [b["tgt_lang_id"] for b in batches] + ) + return batch + + @property + def sizes(self): + if self._sizes is not None: + return self._sizes + start_time = time.time() + in_sub_dataset_indices = [ + self._cur_indices[ + 0 if i == 0 else self.cumulated_sizes[i - 1] : self.cumulated_sizes[i] + ] + for i in range(len(self.datasets)) + ] + sub_dataset_sizes = [ + d.sizes[indices] + for d, indices in zip(self.datasets, in_sub_dataset_indices) + ] + self._sizes = np.vstack(sub_dataset_sizes) + logger.info(f"sizes() calling time: {get_time_gap(start_time, time.time())}") + return self._sizes + + def ordered_indices(self): + if self.shuffle: + indices = np.random.permutation(len(self)) + else: + indices = np.arange(len(self)) + + sizes = self.sizes + tgt_sizes = sizes[:, 1] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else None + src_sizes = ( + sizes[:, 0] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else sizes + ) + + # sort by target length, then source length + if tgt_sizes is not None: + indices = indices[np.argsort(tgt_sizes[indices], kind="mergesort")] + sort_indices = indices[np.argsort(src_sizes[indices], kind="mergesort")] + return sort_indices + + def prefetch(self, indices): + prefetch_indices = [[] for _ in range(len(self.datasets))] + for i in indices: + ds_idx, ds_sample_idx = self._get_dataset_and_index(i) + prefetch_indices[ds_idx].append(ds_sample_idx) + for i in range(len(prefetch_indices)): + self.datasets[i].prefetch(prefetch_indices[i]) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return False + + def set_epoch(self, epoch): + super().set_epoch(epoch) + if epoch == self._cur_epoch: + # re-enter so return + return + for d in self.datasets: + if hasattr(d, "set_epoch"): + d.set_epoch(epoch) + self._cur_epoch = epoch + self._establish_virtual_datasets() + + def _establish_virtual_datasets(self): + if self.sample_ratios is None and self._cur_indices is not None: + # not a samping dataset, no need to resample if indices are already established + return + self._reset_cached_properties() + + start_time = time.time() + # Generate a weighted sample of indices as a function of the + # random seed and the current epoch. + rng = np.random.RandomState( + [ + int( + hashlib.sha1( + str(self.__class__.__name__).encode("utf-8") + ).hexdigest(), + 16, + ) + % (2 ** 32), + self.seed % (2 ** 32), # global seed + self._cur_epoch, # epoch index, + ] + ) + self._clean_if_not_none( + [self.cumulated_sizes, self.virtual_size_per_dataset, self._sizes] + ) + self._sizes = None + + indices, cumulated_sizes, virtual_size_per_dataset = self.get_virtual_indices( + rng, self.datasets, self.sample_ratios, self.virtual_size + ) + self._cur_indices = indices + self.cumulated_sizes = cumulated_sizes + self.virtual_size_per_dataset = virtual_size_per_dataset + + raw_sizes = [len(d) for d in self.datasets] + sampled_sizes = self.virtual_size_per_dataset + logger.info( + f"[{self.split}] Raw sizes: {str(dict(zip(self.keys, raw_sizes)))}; " + f"raw total size: {sum(raw_sizes)}" + ) + logger.info( + f"[{self.split}] Resampled sizes: {str(dict(zip(self.keys, sampled_sizes)))}; " + f"resampled total size: {sum(sampled_sizes)}" + ) + if self.sample_ratios is not None: + logger.info( + f"[{self.split}] Upsampling ratios: {str(dict(zip(self.keys, self.sample_ratios)))}" + ) + else: + logger.info(f"[{self.split}] A concat dataset") + logger.info( + f"[{self.split}] virtual dataset established time: {get_time_gap(start_time, time.time())}" + ) + + def filter_indices_by_size(self, indices, max_sizes): + """Filter a list of sample indices. Remove those that are longer + than specified in max_sizes. + + Args: + indices (np.array): original array of sample indices + max_sizes (int or list[int] or tuple[int]): max sample size, + can be defined separately for src and tgt (then list or tuple) + + Returns: + np.array: filtered sample array + list: list of removed indices + """ + sizes = self.sizes + tgt_sizes = sizes[:, 1] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else None + src_sizes = ( + sizes[:, 0] if len(sizes.shape) > 0 and sizes.shape[1] > 1 else sizes + ) + + return data_utils.filter_paired_dataset_indices_by_size( + src_sizes, tgt_sizes, indices, max_sizes + ) diff --git a/fairseq/fairseq/data/multilingual/sampled_multi_epoch_dataset.py b/fairseq/fairseq/data/multilingual/sampled_multi_epoch_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..17387b2f85c0ee76db1a003091331b46de8d8def --- /dev/null +++ b/fairseq/fairseq/data/multilingual/sampled_multi_epoch_dataset.py @@ -0,0 +1,199 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import hashlib +import logging +import math + +import numpy as np +from fairseq.data import SampledMultiDataset + +from .sampled_multi_dataset import CollateFormat, default_virtual_size_func + + +logger = logging.getLogger(__name__) + + +class SampledMultiEpochDataset(SampledMultiDataset): + """Samples from multiple sub-datasets according to sampling ratios + using virtual epoch sizes to speed up dataloading. + Args: + datasets ( + List[~torch.utils.data.Dataset] + or OrderedDict[str, ~torch.utils.data.Dataset] + ): datasets + sampling_ratios (List[float]): list of probability of each dataset to be sampled + (default: None, which corresponds to concating all dataset together). + seed (int): RNG seed to use (default: 2). + epoch (int): starting epoch number (default: 1). + eval_key (str, optional): a key used at evaluation time that causes + this instance to pass-through batches from *datasets[eval_key]*. + collate_format (CollateFormat): collater output format, either CollateFormat.ordered_dict or + CollateFormat.single (default: CollateFormat.single) where CollateFormat.single configures + the collater to output batches of data mixed from all sub-datasets, + and CollateFormat.ordered_dict configures the collater to output a dictionary of batches indexed by keys + of sub-datasets. + Note that not all sub-datasets will present in a single batch in both formats. + virtual_size (int, or callable): the expected virtual size of the dataset (default: default_virtual_size_func). + split (str): the split of the data, e.g. 'train', 'valid' or 'test'. + virtual_epoch_size (int): virtual epoch size, the dataset will go through the data by + this virtual epoch size one by one to speed up data loading, e.g. indicing and filtering + can be performed whenever a virtual epoch is loaded without waiting for the whole dataset to be loaded. + shared_collater (bool): whether or not to all sub-datasets have the same collater. + shard_epoch (int): the real epoch number for shard selection. + shuffle (bool): whether or not to shuffle data (default: True). + """ + + def __init__( + self, + datasets, + sampling_ratios=None, + seed=2, + epoch=1, + eval_key=None, + collate_format=CollateFormat.single, + virtual_size=default_virtual_size_func, + split="", + virtual_epoch_size=None, + shared_collater=False, + shard_epoch=1, + shuffle=True, + ): + self.virtual_epoch_size = virtual_epoch_size + self._current_epoch_start_index = None + self._random_global_indices = None + self.shard_epoch = shard_epoch if shard_epoch is not None else 1 + self.load_next_shard = None + self._epoch_sizes = None + super().__init__( + datasets=datasets, + sampling_ratios=sampling_ratios, + seed=seed, + epoch=epoch, + eval_key=eval_key, + collate_format=collate_format, + virtual_size=virtual_size, + split=split, + shared_collater=shared_collater, + shuffle=shuffle, + ) + + def _setup(self, epoch): + self.virtual_epoch_size = ( + self.virtual_epoch_size + if self.virtual_epoch_size is not None + else self.virtual_size + ) + if self.virtual_epoch_size > self.virtual_size: + logger.warning( + f"virtual epoch size {self.virtual_epoch_size} " + f"is greater than virtual dataset size {self.virtual_size}" + ) + self.virtual_epoch_size = self.virtual_size + self.num_virtual_epochs = math.ceil(self.virtual_size / self.virtual_epoch_size) + self._current_epoch_start_index = self._get_epoch_start_index(epoch) + logger.info( + f"virtual epoch size {self.virtual_epoch_size}; virtual dataset size {self.virtual_size}" + ) + + def _map_epoch_index_to_global(self, index): + index = self._current_epoch_start_index + index + # add randomness + return self._random_global_indices[index] + + @property + def sizes(self): + if self._epoch_sizes is not None: + return self._epoch_sizes + _sizes = super().sizes + indices = self._random_global_indices[ + self._current_epoch_start_index : self._current_epoch_start_index + + len(self) + ] + self._epoch_sizes = _sizes[indices] + # del super()._sizes to save memory + del self._sizes + self._sizes = None + return self._epoch_sizes + + def _get_dataset_and_index(self, index): + i = self._map_epoch_index_to_global(index) + return super()._get_dataset_and_index(i) + + def __len__(self): + return ( + self.virtual_epoch_size + if self._current_epoch_start_index + self.virtual_epoch_size + < self.virtual_size + else self.virtual_size - self._current_epoch_start_index + ) + + def set_epoch(self, epoch): + if self._current_epoch_start_index is None: + # initializing epoch idnices of a virtual dataset + self._setup(epoch) + self._next_virtual_epoch(epoch) + else: + # working on already intialized epoch indices + if epoch == self._cur_epoch: + # re-enter so return + return + self._next_virtual_epoch(epoch) + + def _get_epoch_start_index(self, epoch): + assert epoch >= 1 # fairseq is using 1-based epoch everywhere + return ((epoch - 1) % self.num_virtual_epochs) * self.virtual_epoch_size + + def _next_global_indices(self, epoch): + rng = np.random.RandomState( + [ + int( + hashlib.sha1( + str(self.__class__.__name__).encode("utf-8") + ).hexdigest(), + 16, + ) + % (2 ** 32), + self.seed % (2 ** 32), # global seed + epoch, # epoch index, + ] + ) + del self._random_global_indices + self._random_global_indices = rng.choice( + self.virtual_size, self.virtual_size, replace=False + ) + if self.load_next_shard is None: + self.load_next_shard = False + else: + # increase shard epoch for next loading + self.shard_epoch += 1 + self.load_next_shard = True + logger.info( + "to load next epoch/shard in next load_dataset: " + f"epoch={epoch}/shard_epoch={self.shard_epoch}" + ) + + def _next_virtual_epoch(self, epoch): + index = self._get_epoch_start_index(epoch) + if index == 0 or self._random_global_indices is None: + # need to start from the beginning, + # so call super().set_epoch(epoch) to establish the global virtual indices + logger.info( + "establishing a new set of global virtual indices for " + f"epoch={epoch}/shard_epoch={self.shard_epoch}" + ) + super().set_epoch(epoch) + self._next_global_indices(epoch) + else: + self._cur_epoch = epoch + + # reset cache sizes and ordered_indices for the epoch after moving to a new epoch + self._clean_if_not_none( + [ + self._epoch_sizes, + ] + ) + self._epoch_sizes = None + self._current_epoch_start_index = index diff --git a/fairseq/fairseq/data/multilingual/sampling_method.py b/fairseq/fairseq/data/multilingual/sampling_method.py new file mode 100644 index 0000000000000000000000000000000000000000..140c68f01d60e902ef88f11f30f8813dc15fc681 --- /dev/null +++ b/fairseq/fairseq/data/multilingual/sampling_method.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import List + + +logger = logging.getLogger(__name__) + + +def uniform(dataset_sizes: List[int]): + return [1.0] * len(dataset_sizes) + + +def temperature_sampling(dataset_sizes, temp): + total_size = sum(dataset_sizes) + return [(size / total_size) ** (1.0 / temp) for size in dataset_sizes] + + +def make_temperature_sampling(temp=1.0): + def sampling_func(dataset_sizes): + return temperature_sampling(dataset_sizes, temp) + + return sampling_func + + +def make_ratio_sampling(ratios): + def sampling_func(dataset_sizes): + return ratios + + return sampling_func + + +class SamplingMethod: + @staticmethod + def add_arguments(parser): + parser.add_argument( + "--sampling-method", + choices=[ + "uniform", + "temperature", + "concat", + "RoundRobin", + ], + type=str, + default="concat", + help="The method to sample data per language pairs", + ) + parser.add_argument( + "--sampling-temperature", + default=1.5, + type=float, + help="only work with --sampling-method temperature", + ) + + @staticmethod + def build_sampler(args, task): + return SamplingMethod(args, task) + + def __init__(self, args, task): + self.args = args + self.task = task + + def is_adaptive(self): + return False + + def sampling_method_selector(self): + args = self.args + logger.info(f"selected sampler: {args.sampling_method}") + if args.sampling_method == "uniform": + return uniform + elif args.sampling_method == "temperature" or self.is_adaptive(): + return make_temperature_sampling(float(args.sampling_temperature)) + else: + # default to concating all data set together + return None diff --git a/fairseq/fairseq/data/nested_dictionary_dataset.py b/fairseq/fairseq/data/nested_dictionary_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..52e74abddacc923c5e29b0a0c41d7efc85482d3b --- /dev/null +++ b/fairseq/fairseq/data/nested_dictionary_dataset.py @@ -0,0 +1,125 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import OrderedDict + +import torch +from torch.utils.data.dataloader import default_collate + +from . import FairseqDataset + + +def _flatten(dico, prefix=None): + """Flatten a nested dictionary.""" + new_dico = OrderedDict() + if isinstance(dico, dict): + prefix = prefix + "." if prefix is not None else "" + for k, v in dico.items(): + if v is None: + continue + new_dico.update(_flatten(v, prefix + k)) + elif isinstance(dico, list): + for i, v in enumerate(dico): + new_dico.update(_flatten(v, prefix + ".[" + str(i) + "]")) + else: + new_dico = OrderedDict({prefix: dico}) + return new_dico + + +def _unflatten(dico): + """Unflatten a flattened dictionary into a nested dictionary.""" + new_dico = OrderedDict() + for full_k, v in dico.items(): + full_k = full_k.split(".") + node = new_dico + for k in full_k[:-1]: + if k.startswith("[") and k.endswith("]"): + k = int(k[1:-1]) + if k not in node: + node[k] = OrderedDict() + node = node[k] + node[full_k[-1]] = v + return new_dico + + +class NestedDictionaryDataset(FairseqDataset): + def __init__(self, defn, sizes=None): + super().__init__() + self.defn = _flatten(defn) + self.sizes = [sizes] if not isinstance(sizes, (list, tuple)) else sizes + + first = None + for v in self.defn.values(): + if not isinstance( + v, + ( + FairseqDataset, + torch.utils.data.Dataset, + ), + ): + raise ValueError("Expected Dataset but found: {}".format(v.__class__)) + first = first or v + if len(v) > 0: + assert len(v) == len(first), "dataset lengths must match" + + self._len = len(first) + + def __getitem__(self, index): + return OrderedDict((k, ds[index]) for k, ds in self.defn.items()) + + def __len__(self): + return self._len + + def collater(self, samples): + """Merge a list of samples to form a mini-batch. + + Args: + samples (List[dict]): samples to collate + + Returns: + dict: a mini-batch suitable for forwarding with a Model + """ + if len(samples) == 0: + return {} + sample = OrderedDict() + for k, ds in self.defn.items(): + try: + sample[k] = ds.collater([s[k] for s in samples]) + except NotImplementedError: + sample[k] = default_collate([s[k] for s in samples]) + return _unflatten(sample) + + def num_tokens(self, index): + """Return the number of tokens in a sample. This value is used to + enforce ``--max-tokens`` during batching.""" + return max(s[index] for s in self.sizes) + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + if len(self.sizes) == 1: + return self.sizes[0][index] + else: + return (s[index] for s in self.sizes) + + @property + def supports_prefetch(self): + """Whether this dataset supports prefetching.""" + return any(ds.supports_prefetch for ds in self.defn.values()) + + def prefetch(self, indices): + """Prefetch the data required for this epoch.""" + for ds in self.defn.values(): + if getattr(ds, "supports_prefetch", False): + ds.prefetch(indices) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return all(ds.can_reuse_epoch_itr_across_epochs for ds in self.defn.values()) + + def set_epoch(self, epoch): + super().set_epoch(epoch) + for ds in self.defn.values(): + ds.set_epoch(epoch) diff --git a/fairseq/fairseq/data/noising.py b/fairseq/fairseq/data/noising.py new file mode 100644 index 0000000000000000000000000000000000000000..2b1cc347203bfbdc9f1cba29e2e36427b7b5be57 --- /dev/null +++ b/fairseq/fairseq/data/noising.py @@ -0,0 +1,335 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from fairseq.data import data_utils + + +class WordNoising(object): + """Generate a noisy version of a sentence, without changing words themselves.""" + + def __init__(self, dictionary, bpe_cont_marker="@@", bpe_end_marker=None): + self.dictionary = dictionary + self.bpe_end = None + if bpe_cont_marker: + self.bpe_end = np.array( + [ + not self.dictionary[i].endswith(bpe_cont_marker) + for i in range(len(self.dictionary)) + ] + ) + elif bpe_end_marker: + self.bpe_end = np.array( + [ + self.dictionary[i].endswith(bpe_end_marker) + for i in range(len(self.dictionary)) + ] + ) + + self.get_word_idx = ( + self._get_bpe_word_idx if self.bpe_end is not None else self._get_token_idx + ) + + def noising(self, x, lengths, noising_prob=0.0): + raise NotImplementedError() + + def _get_bpe_word_idx(self, x): + """ + Given a list of BPE tokens, for every index in the tokens list, + return the index of the word grouping that it belongs to. + For example, for input x corresponding to ["how", "are", "y@@", "ou"], + return [[0], [1], [2], [2]]. + """ + # x: (T x B) + bpe_end = self.bpe_end[x] + + if x.size(0) == 1 and x.size(1) == 1: + # Special case when we only have one word in x. If x = [[N]], + # bpe_end is a scalar (bool) instead of a 2-dim array of bools, + # which makes the sum operation below fail. + return np.array([[0]]) + + # do a reduce front sum to generate word ids + word_idx = bpe_end[::-1].cumsum(0)[::-1] + word_idx = word_idx.max(0)[None, :] - word_idx + return word_idx + + def _get_token_idx(self, x): + """ + This is to extend noising functions to be able to apply to non-bpe + tokens, e.g. word or characters. + """ + x = torch.t(x) + word_idx = np.array([range(len(x_i)) for x_i in x]) + return np.transpose(word_idx) + + +class WordDropout(WordNoising): + """Randomly drop input words. If not passing blank_idx (default is None), + then dropped words will be removed. Otherwise, it will be replaced by the + blank_idx.""" + + def __init__( + self, + dictionary, + default_dropout_prob=0.1, + bpe_cont_marker="@@", + bpe_end_marker=None, + ): + super().__init__(dictionary, bpe_cont_marker, bpe_end_marker) + self.default_dropout_prob = default_dropout_prob + + def noising(self, x, lengths, dropout_prob=None, blank_idx=None): + if dropout_prob is None: + dropout_prob = self.default_dropout_prob + # x: (T x B), lengths: B + if dropout_prob == 0: + return x, lengths + + assert 0 < dropout_prob < 1 + + # be sure to drop entire words + word_idx = self.get_word_idx(x) + sentences = [] + modified_lengths = [] + for i in range(lengths.size(0)): + # Since dropout probabilities need to apply over non-pad tokens, + # it is not trivial to generate the keep mask without consider + # input lengths; otherwise, this could be done outside the loop + + # We want to drop whole words based on word_idx grouping + num_words = max(word_idx[:, i]) + 1 + + # ith example: [x0, x1, ..., eos, pad, ..., pad] + # We should only generate keep probs for non-EOS tokens. Thus if the + # input sentence ends in EOS, the last word idx is not included in + # the dropout mask generation and we append True to always keep EOS. + # Otherwise, just generate the dropout mask for all word idx + # positions. + has_eos = x[lengths[i] - 1, i] == self.dictionary.eos() + if has_eos: # has eos? + keep = np.random.rand(num_words - 1) >= dropout_prob + keep = np.append(keep, [True]) # keep EOS symbol + else: + keep = np.random.rand(num_words) >= dropout_prob + + words = x[: lengths[i], i].tolist() + + # TODO: speed up the following loop + # drop words from the input according to keep + new_s = [ + w if keep[word_idx[j, i]] else blank_idx for j, w in enumerate(words) + ] + new_s = [w for w in new_s if w is not None] + # we need to have at least one word in the sentence (more than the + # start / end sentence symbols) + if len(new_s) <= 1: + # insert at beginning in case the only token left is EOS + # EOS should be at end of list. + new_s.insert(0, words[np.random.randint(0, len(words))]) + assert len(new_s) >= 1 and ( + not has_eos # Either don't have EOS at end or last token is EOS + or (len(new_s) >= 2 and new_s[-1] == self.dictionary.eos()) + ), "New sentence is invalid." + sentences.append(new_s) + modified_lengths.append(len(new_s)) + # re-construct input + modified_lengths = torch.LongTensor(modified_lengths) + modified_x = torch.LongTensor( + modified_lengths.max(), modified_lengths.size(0) + ).fill_(self.dictionary.pad()) + for i in range(modified_lengths.size(0)): + modified_x[: modified_lengths[i], i].copy_(torch.LongTensor(sentences[i])) + + return modified_x, modified_lengths + + +class WordShuffle(WordNoising): + """Shuffle words by no more than k positions.""" + + def __init__( + self, + dictionary, + default_max_shuffle_distance=3, + bpe_cont_marker="@@", + bpe_end_marker=None, + ): + super().__init__(dictionary, bpe_cont_marker, bpe_end_marker) + self.default_max_shuffle_distance = 3 + + def noising(self, x, lengths, max_shuffle_distance=None): + if max_shuffle_distance is None: + max_shuffle_distance = self.default_max_shuffle_distance + # x: (T x B), lengths: B + if max_shuffle_distance == 0: + return x, lengths + + # max_shuffle_distance < 1 will return the same sequence + assert max_shuffle_distance > 1 + + # define noise word scores + noise = np.random.uniform( + 0, + max_shuffle_distance, + size=(x.size(0), x.size(1)), + ) + noise[0] = -1 # do not move start sentence symbol + # be sure to shuffle entire words + word_idx = self.get_word_idx(x) + x2 = x.clone() + for i in range(lengths.size(0)): + length_no_eos = lengths[i] + if x[lengths[i] - 1, i] == self.dictionary.eos(): + length_no_eos = lengths[i] - 1 + # generate a random permutation + scores = word_idx[:length_no_eos, i] + noise[word_idx[:length_no_eos, i], i] + # ensure no reordering inside a word + scores += 1e-6 * np.arange(length_no_eos.item()) + permutation = scores.argsort() + # shuffle words + x2[:length_no_eos, i].copy_( + x2[:length_no_eos, i][torch.from_numpy(permutation)] + ) + return x2, lengths + + +class UnsupervisedMTNoising(WordNoising): + """ + Implements the default configuration for noising in UnsupervisedMT + (github.com/facebookresearch/UnsupervisedMT) + """ + + def __init__( + self, + dictionary, + max_word_shuffle_distance, + word_dropout_prob, + word_blanking_prob, + bpe_cont_marker="@@", + bpe_end_marker=None, + ): + super().__init__(dictionary) + self.max_word_shuffle_distance = max_word_shuffle_distance + self.word_dropout_prob = word_dropout_prob + self.word_blanking_prob = word_blanking_prob + + self.word_dropout = WordDropout( + dictionary=dictionary, + bpe_cont_marker=bpe_cont_marker, + bpe_end_marker=bpe_end_marker, + ) + self.word_shuffle = WordShuffle( + dictionary=dictionary, + bpe_cont_marker=bpe_cont_marker, + bpe_end_marker=bpe_end_marker, + ) + + def noising(self, x, lengths): + # 1. Word Shuffle + noisy_src_tokens, noisy_src_lengths = self.word_shuffle.noising( + x=x, + lengths=lengths, + max_shuffle_distance=self.max_word_shuffle_distance, + ) + # 2. Word Dropout + noisy_src_tokens, noisy_src_lengths = self.word_dropout.noising( + x=noisy_src_tokens, + lengths=noisy_src_lengths, + dropout_prob=self.word_dropout_prob, + ) + # 3. Word Blanking + noisy_src_tokens, noisy_src_lengths = self.word_dropout.noising( + x=noisy_src_tokens, + lengths=noisy_src_lengths, + dropout_prob=self.word_blanking_prob, + blank_idx=self.dictionary.unk(), + ) + + return noisy_src_tokens + + +class NoisingDataset(torch.utils.data.Dataset): + def __init__( + self, + src_dataset, + src_dict, + seed, + noiser=None, + noising_class=UnsupervisedMTNoising, + **kwargs + ): + """ + Wrap a :class:`~torch.utils.data.Dataset` and apply noise to the + samples based on the supplied noising configuration. + + Args: + src_dataset (~torch.utils.data.Dataset): dataset to wrap. + to build self.src_dataset -- + a LanguagePairDataset with src dataset as the source dataset and + None as the target dataset. Should NOT have padding so that + src_lengths are accurately calculated by language_pair_dataset + collate function. + We use language_pair_dataset here to encapsulate the tgt_dataset + so we can re-use the LanguagePairDataset collater to format the + batches in the structure that SequenceGenerator expects. + src_dict (~fairseq.data.Dictionary): source dictionary + seed (int): seed to use when generating random noise + noiser (WordNoising): a pre-initialized :class:`WordNoising` + instance. If this is None, a new instance will be created using + *noising_class* and *kwargs*. + noising_class (class, optional): class to use to initialize a + default :class:`WordNoising` instance. + kwargs (dict, optional): arguments to initialize the default + :class:`WordNoising` instance given by *noiser*. + """ + self.src_dataset = src_dataset + self.src_dict = src_dict + self.seed = seed + self.noiser = ( + noiser + if noiser is not None + else noising_class( + dictionary=src_dict, + **kwargs, + ) + ) + self.sizes = src_dataset.sizes + + + def __getitem__(self, index): + """ + Returns a single noisy sample. Multiple samples are fed to the collater + create a noising dataset batch. + """ + src_tokens = self.src_dataset[index] + src_lengths = torch.LongTensor([len(src_tokens)]) + src_tokens = src_tokens.unsqueeze(0) + + # Transpose src tokens to fit expected shape of x in noising function + # (batch size, sequence length) -> (sequence length, batch size) + src_tokens_t = torch.t(src_tokens) + + with data_utils.numpy_seed(self.seed + index): + noisy_src_tokens = self.noiser.noising(src_tokens_t, src_lengths) + + # Transpose back to expected src_tokens format + # (sequence length, 1) -> (1, sequence length) + noisy_src_tokens = torch.t(noisy_src_tokens) + return noisy_src_tokens[0] + + def __len__(self): + """ + The length of the noising dataset is the length of src. + """ + return len(self.src_dataset) + + @property + def supports_prefetch(self): + return self.src_dataset.supports_prefetch + + def prefetch(self, indices): + if self.src_dataset.supports_prefetch: + self.src_dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/num_samples_dataset.py b/fairseq/fairseq/data/num_samples_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..99a17495c701d8a05e0268f98bf453905e11d078 --- /dev/null +++ b/fairseq/fairseq/data/num_samples_dataset.py @@ -0,0 +1,17 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import FairseqDataset + + +class NumSamplesDataset(FairseqDataset): + def __getitem__(self, index): + return 1 + + def __len__(self): + return 0 + + def collater(self, samples): + return sum(samples) diff --git a/fairseq/fairseq/data/numel_dataset.py b/fairseq/fairseq/data/numel_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ac86dfd2f1d89055de909656d61d6aca85523f00 --- /dev/null +++ b/fairseq/fairseq/data/numel_dataset.py @@ -0,0 +1,31 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from . import BaseWrapperDataset + + +class NumelDataset(BaseWrapperDataset): + def __init__(self, dataset, reduce=False): + super().__init__(dataset) + self.reduce = reduce + + def __getitem__(self, index): + item = self.dataset[index] + if torch.is_tensor(item): + return torch.numel(item) + else: + return np.size(item) + + def __len__(self): + return len(self.dataset) + + def collater(self, samples): + if self.reduce: + return sum(samples) + else: + return torch.tensor(samples) diff --git a/fairseq/fairseq/data/offset_tokens_dataset.py b/fairseq/fairseq/data/offset_tokens_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..6fabbdcdaa1a8f70d8d8c07db4cd53754503c194 --- /dev/null +++ b/fairseq/fairseq/data/offset_tokens_dataset.py @@ -0,0 +1,15 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import BaseWrapperDataset + + +class OffsetTokensDataset(BaseWrapperDataset): + def __init__(self, dataset, offset): + super().__init__(dataset) + self.offset = offset + + def __getitem__(self, idx): + return self.dataset[idx] + self.offset diff --git a/fairseq/fairseq/data/pad_dataset.py b/fairseq/fairseq/data/pad_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..8075bba6a9efc5f8421368ee0b2ae66afe3f5009 --- /dev/null +++ b/fairseq/fairseq/data/pad_dataset.py @@ -0,0 +1,28 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.data import data_utils + +from . import BaseWrapperDataset + + +class PadDataset(BaseWrapperDataset): + def __init__(self, dataset, pad_idx, left_pad): + super().__init__(dataset) + self.pad_idx = pad_idx + self.left_pad = left_pad + + def collater(self, samples): + return data_utils.collate_tokens(samples, self.pad_idx, left_pad=self.left_pad) + + +class LeftPadDataset(PadDataset): + def __init__(self, dataset, pad_idx): + super().__init__(dataset, pad_idx, left_pad=True) + + +class RightPadDataset(PadDataset): + def __init__(self, dataset, pad_idx): + super().__init__(dataset, pad_idx, left_pad=False) diff --git a/fairseq/fairseq/data/plasma_utils.py b/fairseq/fairseq/data/plasma_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b9fab3b739db46b685fa6859a2f851a14eef8407 --- /dev/null +++ b/fairseq/fairseq/data/plasma_utils.py @@ -0,0 +1,197 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import subprocess +import json +import tempfile +import hashlib +from typing import Hashable + +try: + import pyarrow.plasma as plasma + + PYARROW_AVAILABLE = True +except ImportError: + plasma = None + PYARROW_AVAILABLE = False + + +class PlasmaArray: + """ + Wrapper around numpy arrays that automatically moves the data to shared + memory upon serialization. This is particularly helpful when passing numpy + arrays through multiprocessing, so that data is not unnecessarily + duplicated or pickled. + """ + + def __init__(self, array): + super().__init__() + self.array = array + self.disable = array.nbytes < 134217728 # disable for arrays <128MB + self.object_id = None + self.path = None + + # variables with underscores shouldn't be pickled + self._client = None + self._server = None + self._server_tmp = None + self._plasma = None + + @property + def plasma(self): + if self._plasma is None and not self.disable: + self._plasma = plasma + return self._plasma + + def start_server(self): + if self.plasma is None or self._server is not None: + return + assert self.object_id is None + assert self.path is None + self._server_tmp = tempfile.NamedTemporaryFile() + self.path = self._server_tmp.name + self._server = subprocess.Popen( + ["plasma_store", "-m", str(int(1.05 * self.array.nbytes)), "-s", self.path] + ) + + @property + def client(self): + if self._client is None: + assert self.path is not None + self._client = self.plasma.connect(self.path, num_retries=200) + return self._client + + def __getstate__(self): + """Called on pickle load""" + if self.plasma is None: + return self.__dict__ + if self.object_id is None: + self.start_server() + self.object_id = self.client.put(self.array) + state = self.__dict__.copy() + del state["array"] + state["_client"] = None + state["_server"] = None + state["_server_tmp"] = None + state["_plasma"] = None + return state + + def __setstate__(self, state): + """Called on pickle save""" + self.__dict__.update(state) + if self.plasma is None: + return + self.array = self.client.get(self.object_id) + + def __del__(self): + if self._server is not None: + self._server.kill() + self._server = None + self._server_tmp.close() + self._server_tmp = None + + +DEFAULT_PLASMA_PATH = "/tmp/plasma" + + +class PlasmaView: + """Interface to write and read from shared memory. Whereas PlasmaArray writes to plasma on serialization, + PlasmaView writes to shared memory on instantiation.""" + + def __init__(self, array, split_path: str, hash_data: Hashable, plasma_path=None): + """ + Args: + array: numpy array to store. This can be read with ``PlasmaView().array`` + split_path: the path whence the data was read, used for hashing + hash_data: other metadata about the array that can be used to create a unique key. + as of writing, the 3 callers in ``TokenBlockDataset`` use:: + + hash_data = ((block_size, document_sep_len, str(break_mode), len(dataset)), 0|1|2) + + + """ + assert PYARROW_AVAILABLE + assert split_path is not None + if plasma_path is None: + plasma_path = DEFAULT_PLASMA_PATH + + self.path = plasma_path + self.split_path = split_path + self._client = None # Initialize lazily for pickle. plasma clients should not be deep copied or serialized. + self._n = None + + self.object_id = self.get_object_id(self.split_path, hash_data) + try: + self.client.put(array, object_id=self.object_id) + except plasma.PlasmaObjectExists: + pass + + @property + def client(self): + if self._client is None: + self._client = plasma.connect(self.path, num_retries=200) + return self._client + + @property + def array(self): + """Fetch a read only view of an np.array, stored in plasma.""" + ret = self.client.get(self.object_id) + return ret + + @staticmethod + def get_object_id(split_path: str, hash_data: Hashable): + """Returns plasma.ObjectID from hashing split_path and object_num.""" + hash = hashlib.blake2b(bytes(split_path, "utf-8"), digest_size=20) + harg = json.dumps(hash_data).encode("utf-8") + hash.update(harg) + return plasma.ObjectID(hash.digest()) + + def __getstate__(self): + """Called on pickle save""" + self.disconnect() + state = self.__dict__.copy() + assert state["_client"] is None + assert "object_id" in state + return state + + def __setstate__(self, state): + """Called on pickle load""" + self.__dict__.update(state) + + def __del__(self): + self.disconnect() + + def disconnect(self): + if self._client is not None: + self._client.disconnect() + self._client = None + + def __len__(self): + """Save reads by caching len""" + if self._n is None: + self._n = len(self.array) + return self._n + + +GB100 = (1024 ** 3) * 100 + + +class PlasmaStore: + def __init__(self, path=DEFAULT_PLASMA_PATH, nbytes: int = GB100): + + self.server = self.start(path, nbytes) + + def __del__(self): + self.server.kill() + + @staticmethod + def start(path=DEFAULT_PLASMA_PATH, nbytes: int = GB100) -> subprocess.Popen: + if not PYARROW_AVAILABLE: + raise ImportError("please run pip install pyarrow to use --use_plasma_view") + # best practice is to allocate more space than we need. The limitation seems to be the size of /dev/shm + _server = subprocess.Popen(["plasma_store", "-m", str(nbytes), "-s", path]) + plasma.connect(path, num_retries=200) # If we can't connect we fail immediately + return _server diff --git a/fairseq/fairseq/data/prepend_dataset.py b/fairseq/fairseq/data/prepend_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ad74784d2d7920e4a6225282d95543ce16ea50d9 --- /dev/null +++ b/fairseq/fairseq/data/prepend_dataset.py @@ -0,0 +1,28 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from . import BaseWrapperDataset + + +class PrependDataset(BaseWrapperDataset): + def __init__(self, dataset, prepend_getter, ensure_first_token_is=None): + super().__init__(dataset) + self.prepend_getter = prepend_getter + self.ensure_first_token = ensure_first_token_is + + def __getitem__(self, idx): + item = self.dataset[idx] + is_tuple = isinstance(item, tuple) + src = item[0] if is_tuple else item + + assert self.ensure_first_token is None or src[0] == self.ensure_first_token + prepend_idx = self.prepend_getter(self.dataset, idx) + assert isinstance(prepend_idx, int) + src[0] = prepend_idx + item = tuple((src,) + item[1:]) if is_tuple else src + return item diff --git a/fairseq/fairseq/data/prepend_token_dataset.py b/fairseq/fairseq/data/prepend_token_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..fd1331f4c44c1595eb9bb78baa0cf5cf3bcce9ad --- /dev/null +++ b/fairseq/fairseq/data/prepend_token_dataset.py @@ -0,0 +1,41 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch + +from . import BaseWrapperDataset + + +class PrependTokenDataset(BaseWrapperDataset): + def __init__(self, dataset, token=None): + super().__init__(dataset) + self.token = token + if token is not None: + self._sizes = np.array(dataset.sizes) + 1 + else: + self._sizes = dataset.sizes + + def __getitem__(self, idx): + item = self.dataset[idx] + if self.token is not None: + item = torch.cat([item.new([self.token]), item]) + return item + + @property + def sizes(self): + return self._sizes + + def num_tokens(self, index): + n = self.dataset.num_tokens(index) + if self.token is not None: + n += 1 + return n + + def size(self, index): + n = self.dataset.size(index) + if self.token is not None: + n += 1 + return n diff --git a/fairseq/fairseq/data/raw_label_dataset.py b/fairseq/fairseq/data/raw_label_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..d054904f419bd64855d33a2a770b43f671c7c8d8 --- /dev/null +++ b/fairseq/fairseq/data/raw_label_dataset.py @@ -0,0 +1,23 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import FairseqDataset + + +class RawLabelDataset(FairseqDataset): + def __init__(self, labels): + super().__init__() + self.labels = labels + + def __getitem__(self, index): + return self.labels[index] + + def __len__(self): + return len(self.labels) + + def collater(self, samples): + return torch.tensor(samples) diff --git a/fairseq/fairseq/data/replace_dataset.py b/fairseq/fairseq/data/replace_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..5aac2ba96bee0a8bb65f4c9e56fa0b17248ee1d9 --- /dev/null +++ b/fairseq/fairseq/data/replace_dataset.py @@ -0,0 +1,36 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import BaseWrapperDataset + + +class ReplaceDataset(BaseWrapperDataset): + """Replaces tokens found in the dataset by a specified replacement token + + Args: + dataset (~torch.utils.data.Dataset): dataset to replace tokens in + replace_map(Dictionary[int,int]): map of token to replace -> replacement token + offsets (List[int]): do not replace tokens before (from left if pos, right if neg) this offset. should be + as many as the number of objects returned by the underlying dataset __getitem__ method. + """ + + def __init__(self, dataset, replace_map, offsets): + super().__init__(dataset) + assert len(replace_map) > 0 + self.replace_map = replace_map + self.offsets = offsets + + def __getitem__(self, index): + item = self.dataset[index] + is_tuple = isinstance(item, tuple) + srcs = item if is_tuple else [item] + + for offset, src in zip(self.offsets, srcs): + for k, v in self.replace_map.items(): + src_off = src[offset:] if offset >= 0 else src[:offset] + src_off.masked_fill_(src_off == k, v) + + item = srcs if is_tuple else srcs[0] + return item diff --git a/fairseq/fairseq/data/resampling_dataset.py b/fairseq/fairseq/data/resampling_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..3d3b993164dc3962df48bacff26714328e843e80 --- /dev/null +++ b/fairseq/fairseq/data/resampling_dataset.py @@ -0,0 +1,139 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import numpy as np +from fairseq.data import BaseWrapperDataset, plasma_utils + + +logger = logging.getLogger(__name__) + + +class ResamplingDataset(BaseWrapperDataset): + """Randomly samples from a given dataset at each epoch. + + Sampling is done with or without replacement, depending on the "replace" + parameter. + + Optionally, the epoch size can be rescaled. This is potentially desirable + to increase per-epoch coverage of the base dataset (since sampling with + replacement means that many items in the dataset will be left out). In the + case of sampling without replacement, size_ratio should be strictly less + than 1. + + Args: + dataset (~torch.utils.data.Dataset): dataset on which to sample. + weights (List[float]): list of probability weights + (default: None, which corresponds to uniform sampling). + replace (bool): sampling mode; True for "with replacement", or False + for "without replacement" (default: True) + size_ratio (float): the ratio to subsample to; must be positive + (default: 1.0). + batch_by_size (bool): whether or not to batch by sequence length + (default: True). + seed (int): RNG seed to use (default: 0). + epoch (int): starting epoch number (default: 1). + """ + + def __init__( + self, + dataset, + weights=None, + replace=True, + size_ratio=1.0, + batch_by_size=True, + seed=0, + epoch=1, + ): + super().__init__(dataset) + + if weights is None: + self.weights = None + + else: + assert len(weights) == len(dataset) + weights_arr = np.array(weights, dtype=np.float64) + weights_arr /= weights_arr.sum() + self.weights = plasma_utils.PlasmaArray(weights_arr) + + self.replace = replace + + assert size_ratio > 0.0 + if not self.replace: + assert size_ratio < 1.0 + self.size_ratio = float(size_ratio) + self.actual_size = np.ceil(len(dataset) * self.size_ratio).astype(int) + + self.batch_by_size = batch_by_size + self.seed = seed + + self._cur_epoch = None + self._cur_indices = None + + self.set_epoch(epoch) + + def __getitem__(self, index): + return self.dataset[self._cur_indices.array[index]] + + def __len__(self): + return self.actual_size + + @property + def sizes(self): + if isinstance(self.dataset.sizes, list): + return [s[self._cur_indices.array] for s in self.dataset.sizes] + return self.dataset.sizes[self._cur_indices.array] + + def num_tokens(self, index): + return self.dataset.num_tokens(self._cur_indices.array[index]) + + def size(self, index): + return self.dataset.size(self._cur_indices.array[index]) + + def ordered_indices(self): + if self.batch_by_size: + order = [ + np.arange(len(self)), + self.sizes, + ] # No need to handle `self.shuffle == True` + return np.lexsort(order) + else: + return np.arange(len(self)) + + def prefetch(self, indices): + self.dataset.prefetch(self._cur_indices.array[indices]) + + @property + def can_reuse_epoch_itr_across_epochs(self): + return False + + def set_epoch(self, epoch): + logger.debug("ResamplingDataset.set_epoch: {}".format(epoch)) + super().set_epoch(epoch) + + if epoch == self._cur_epoch: + return + + self._cur_epoch = epoch + + # Generate a weighted sample of indices as a function of the + # random seed and the current epoch. + + rng = np.random.RandomState( + [ + 42, # magic number + self.seed % (2 ** 32), # global seed + self._cur_epoch, # epoch index + ] + ) + self._cur_indices = plasma_utils.PlasmaArray( + rng.choice( + len(self.dataset), + self.actual_size, + replace=self.replace, + p=(None if self.weights is None else self.weights.array), + ) + ) diff --git a/fairseq/fairseq/data/roll_dataset.py b/fairseq/fairseq/data/roll_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a2915eeb3e8fb4dfb4b2bb33e0464ad0783d854c --- /dev/null +++ b/fairseq/fairseq/data/roll_dataset.py @@ -0,0 +1,18 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import BaseWrapperDataset + + +class RollDataset(BaseWrapperDataset): + def __init__(self, dataset, shifts): + super().__init__(dataset) + self.shifts = shifts + + def __getitem__(self, index): + item = self.dataset[index] + return torch.roll(item, self.shifts) diff --git a/fairseq/fairseq/data/round_robin_zip_datasets.py b/fairseq/fairseq/data/round_robin_zip_datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..2cb7447ea955a7c3ae7372f09ee426c08acd430e --- /dev/null +++ b/fairseq/fairseq/data/round_robin_zip_datasets.py @@ -0,0 +1,160 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from collections import OrderedDict +from typing import Dict, Sequence + +import numpy as np + +from . import FairseqDataset, LanguagePairDataset + +logger = logging.getLogger(__name__) + + +class RoundRobinZipDatasets(FairseqDataset): + """Zip multiple :class:`~fairseq.data.FairseqDataset` instances together. + + Shorter datasets are repeated in a round-robin fashion to match the length + of the longest one. + + Args: + datasets (Dict[~fairseq.data.FairseqDataset]): a dictionary of + :class:`~fairseq.data.FairseqDataset` instances. + eval_key (str, optional): a key used at evaluation time that causes + this instance to pass-through batches from *datasets[eval_key]*. + """ + + def __init__(self, datasets, eval_key=None): + super().__init__() + if isinstance(datasets, dict): + datasets = OrderedDict(datasets) + assert isinstance(datasets, OrderedDict) + assert datasets, "Can't make a RoundRobinZipDatasets out of nothing" + for dataset in datasets.values(): + assert isinstance(dataset, FairseqDataset) + + self.datasets = datasets + self.eval_key = eval_key + + self.longest_dataset_key = max(datasets, key=lambda k: len(datasets[k])) + self.longest_dataset = datasets[self.longest_dataset_key] + self._ordered_indices: Dict[str, Sequence[int]] = None + + def _map_index(self, key, index): + assert ( + self._ordered_indices is not None + ), "Must call RoundRobinZipDatasets.ordered_indices() first" + o = self._ordered_indices[key] + return o[index % len(o)] + + def __getitem__(self, index): + if self.eval_key is None: + return OrderedDict( + [ + (key, dataset[self._map_index(key, index)]) + for key, dataset in self.datasets.items() + ] + ) + else: + # at evaluation time it's useful to pass-through batches from a single key + return self.datasets[self.eval_key][self._map_index(self.eval_key, index)] + + def __len__(self): + if self._ordered_indices is not None: + return len(self._ordered_indices[self.longest_dataset_key]) + return len(self.longest_dataset) + + def collater(self, samples): + """Merge a list of samples to form a mini-batch.""" + if len(samples) == 0: + return None + if self.eval_key is None: + return OrderedDict( + [ + (key, dataset.collater([sample[key] for sample in samples])) + for key, dataset in self.datasets.items() + ] + ) + else: + # at evaluation time it's useful to pass-through batches from a single key + return self.datasets[self.eval_key].collater(samples) + + def num_tokens(self, index): + """Return an example's length (number of tokens), used for batching.""" + # TODO make it configurable whether to use max() or sum() here + return max( + dataset.num_tokens(self._map_index(key, index)) + for key, dataset in self.datasets.items() + ) + + def size(self, index): + """Return an example's size as a float or tuple. This value is used when + filtering a dataset with ``--max-positions``.""" + return { + key: dataset.size(self._map_index(key, index)) + for key, dataset in self.datasets.items() + } + + def ordered_indices(self): + """Ordered indices for batching.""" + if self._ordered_indices is None: + # Call the underlying dataset's ordered_indices() here, so that we + # get the same random ordering as we would have from using the + # underlying sub-datasets directly. + self._ordered_indices = OrderedDict( + [ + (key, dataset.ordered_indices()) + for key, dataset in self.datasets.items() + ] + ) + return np.arange(len(self)) + + def filter_indices_by_size(self, indices, max_positions=None): + """ + Filter each sub-dataset independently, then update the round robin to work + on the filtered sub-datasets. + """ + + def _deep_until_language_pair(dataset): + if isinstance(dataset, LanguagePairDataset): + return dataset + if hasattr(dataset, "tgt_dataset"): + return _deep_until_language_pair(dataset.tgt_dataset) + if hasattr(dataset, "dataset"): + return _deep_until_language_pair(dataset.dataset) + raise Exception(f"Don't know how to unwrap this dataset: {dataset}") + + if not isinstance(max_positions, dict): + max_positions = {k: max_positions for k in self.datasets.keys()} + ignored_some = False + for key, dataset in self.datasets.items(): + dataset = _deep_until_language_pair(dataset) + self._ordered_indices[key], ignored = dataset.filter_indices_by_size( + self._ordered_indices[key], max_positions[key] + ) + if len(ignored) > 0: + ignored_some = True + logger.warning( + f"{len(ignored)} samples from {key} have invalid sizes and will be skipped, " + f"max_positions={max_positions[key]}, first few sample ids={ignored[:10]}" + ) + # Since we are modifying in place the _ordered_indices, + # it's not possible anymore to return valid ignored indices. + # Hopefully the extra debug information print above should be enough to debug. + # Ideally we would receive ignore_invalid_inputs so that we could have + # a proper error message. + return (np.arange(len(self)), [0] if ignored_some else []) + + @property + def supports_prefetch(self): + return all( + getattr(dataset, "supports_prefetch", False) + for dataset in self.datasets.values() + ) + + def prefetch(self, indices): + for key, dataset in self.datasets.items(): + dataset.prefetch([self._map_index(key, index) for index in indices]) diff --git a/fairseq/fairseq/data/shorten_dataset.py b/fairseq/fairseq/data/shorten_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..6ebb5d88feb3f29d1512a0873df304915d051209 --- /dev/null +++ b/fairseq/fairseq/data/shorten_dataset.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +from fairseq.data import data_utils + +from . import BaseWrapperDataset + + +class TruncateDataset(BaseWrapperDataset): + """Truncate a sequence by returning the first truncation_length tokens""" + + def __init__(self, dataset, truncation_length): + super().__init__(dataset) + assert truncation_length is not None + self.truncation_length = truncation_length + self.dataset = dataset + + def __getitem__(self, index): + item = self.dataset[index] + item_len = item.size(0) + if item_len > self.truncation_length: + item = item[: self.truncation_length] + return item + + @property + def sizes(self): + return np.minimum(self.dataset.sizes, self.truncation_length) + + def __len__(self): + return len(self.dataset) + + +class RandomCropDataset(TruncateDataset): + """Truncate a sequence by returning a random crop of truncation_length tokens""" + + def __init__(self, dataset, truncation_length, seed=1): + super().__init__(dataset, truncation_length) + self.seed = seed + self.epoch = 0 + + @property + def can_reuse_epoch_itr_across_epochs(self): + return True # only the crop changes, not item sizes + + def set_epoch(self, epoch, **unused): + super().set_epoch(epoch) + self.epoch = epoch + + def __getitem__(self, index): + with data_utils.numpy_seed(self.seed, self.epoch, index): + item = self.dataset[index] + item_len = item.size(0) + excess = item_len - self.truncation_length + if excess > 0: + start_idx = np.random.randint(0, excess) + item = item[start_idx : start_idx + self.truncation_length] + return item + + +def maybe_shorten_dataset( + dataset, + split, + shorten_data_split_list, + shorten_method, + tokens_per_sample, + seed, +): + truncate_split = ( + split in shorten_data_split_list.split(",") or len(shorten_data_split_list) == 0 + ) + if shorten_method == "truncate" and truncate_split: + dataset = TruncateDataset(dataset, tokens_per_sample) + elif shorten_method == "random_crop" and truncate_split: + dataset = RandomCropDataset(dataset, tokens_per_sample, seed) + return dataset diff --git a/fairseq/fairseq/data/sort_dataset.py b/fairseq/fairseq/data/sort_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..b3890e7279e1f26db2e48ec0a91c639e9299d60f --- /dev/null +++ b/fairseq/fairseq/data/sort_dataset.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np + +from . import BaseWrapperDataset + + +class SortDataset(BaseWrapperDataset): + def __init__(self, dataset, sort_order): + super().__init__(dataset) + if not isinstance(sort_order, (list, tuple)): + sort_order = [sort_order] + self.sort_order = sort_order + + assert all(len(so) == len(dataset) for so in sort_order) + + def ordered_indices(self): + return np.lexsort(self.sort_order) diff --git a/fairseq/fairseq/data/strip_token_dataset.py b/fairseq/fairseq/data/strip_token_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..cae39ba4d2f8106398eccd7eb0cf5c2194ec0db5 --- /dev/null +++ b/fairseq/fairseq/data/strip_token_dataset.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import BaseWrapperDataset + + +class StripTokenDataset(BaseWrapperDataset): + def __init__(self, dataset, id_to_strip): + super().__init__(dataset) + self.id_to_strip = id_to_strip + + def __getitem__(self, index): + item = self.dataset[index] + while len(item) > 0 and item[-1] == self.id_to_strip: + item = item[:-1] + while len(item) > 0 and item[0] == self.id_to_strip: + item = item[1:] + return item diff --git a/fairseq/fairseq/data/subsample_dataset.py b/fairseq/fairseq/data/subsample_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..48feaf883f87dc95f8637c24d3c96f3f9fd8bd1d --- /dev/null +++ b/fairseq/fairseq/data/subsample_dataset.py @@ -0,0 +1,72 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import numpy as np + +from . import BaseWrapperDataset + + +logger = logging.getLogger(__name__) + + +class SubsampleDataset(BaseWrapperDataset): + """Subsamples a given dataset by a specified ratio. Subsampling is done on the number of examples + + Args: + dataset (~torch.utils.data.Dataset): dataset to subsample + size_ratio(float): the ratio to subsample to. must be between 0 and 1 (exclusive) + """ + + def __init__(self, dataset, size_ratio, shuffle=False): + super().__init__(dataset) + assert size_ratio < 1 + self.actual_size = np.ceil(len(dataset) * size_ratio).astype(int) + self.indices = np.random.choice( + list(range(len(self.dataset))), self.actual_size, replace=False + ) + self.shuffle = shuffle + logger.info( + "subsampled dataset from {} to {} (ratio={})".format( + len(self.dataset), self.actual_size, size_ratio + ) + ) + + def __getitem__(self, index): + return self.dataset[self.indices[index]] + + def __len__(self): + return self.actual_size + + def collater(self, samples): + return self.dataset.collater(samples) + + @property + def sizes(self): + return self.dataset.sizes[self.indices] + + @property + def name(self): + return self.dataset.name + + def num_tokens(self, index): + return self.dataset.num_tokens(self.indices[index]) + + def size(self, index): + return self.dataset.size(self.indices[index]) + + def ordered_indices(self): + """Return an ordered list of indices. Batches will be constructed based + on this order.""" + if self.shuffle: + order = [np.random.permutation(len(self))] + else: + order = [np.arange(len(self))] + order.append(self.sizes) + return np.lexsort(order) + + def prefetch(self, indices): + self.dataset.prefetch(self.indices[indices]) diff --git a/fairseq/fairseq/data/text_compressor.py b/fairseq/fairseq/data/text_compressor.py new file mode 100644 index 0000000000000000000000000000000000000000..561e9ac89ad9f1e88df95647cfdc53e4fcf5d157 --- /dev/null +++ b/fairseq/fairseq/data/text_compressor.py @@ -0,0 +1,56 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from enum import Enum + + +class TextCompressionLevel(Enum): + none = 0 + low = 1 + high = 2 + + +class TextCompressor(object): + def __init__( + self, level: TextCompressionLevel, + max_input_byte_length: int = 2 ** 16 + ): + self.level = level + self.max_input_length = max_input_byte_length + + def compress(self, text: str) -> bytes: + if self.level == TextCompressionLevel.low: + import zlib + # zlib: built-in, fast + return zlib.compress(text.encode(), level=0) + elif self.level == TextCompressionLevel.high: + try: + import unishox2 + # unishox2: optimized for short text but slower + except ImportError: + raise ImportError( + "Please install unishox2 for the text compression feature: " + "pip install unishox2-py3" + ) + assert len(text.encode()) <= self.max_input_length + return unishox2.compress(text)[0] + else: + return text.encode() + + def decompress(self, compressed: bytes) -> str: + if self.level == TextCompressionLevel.low: + import zlib + return zlib.decompress(compressed).decode() + elif self.level == TextCompressionLevel.high: + try: + import unishox2 + except ImportError: + raise ImportError( + "Please install unishox2 for the text compression feature: " + "pip install unishox2-py3" + ) + return unishox2.decompress(compressed, self.max_input_length) + else: + return compressed.decode() diff --git a/fairseq/fairseq/data/token_block_dataset.py b/fairseq/fairseq/data/token_block_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..d2c65fd7e058072911c3aa60bfc760288a0f83e5 --- /dev/null +++ b/fairseq/fairseq/data/token_block_dataset.py @@ -0,0 +1,202 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from fairseq.data import FairseqDataset, plasma_utils +from fairseq.data.indexed_dataset import best_fitting_int_dtype +from typing import Tuple + + +class TokenBlockDataset(FairseqDataset): + """Break a Dataset of tokens into blocks. + + Args: + dataset (~torch.utils.data.Dataset): dataset to break into blocks + sizes (List[int]): sentence lengths (required for 'complete' and 'eos') + block_size (int): maximum block size (ignored in 'eos' break mode) + break_mode (str, optional): Mode used for breaking tokens. Values can + be one of: + - 'none': break tokens into equally sized blocks (up to block_size) + - 'complete': break tokens into blocks (up to block_size) such that + blocks contains complete sentences, although block_size may be + exceeded if some sentences exceed block_size + - 'complete_doc': similar to 'complete' mode, but do not + cross document boundaries + - 'eos': each block contains one sentence (block_size is ignored) + include_targets (bool, optional): return next tokens as targets + (default: False). + document_sep_len (int, optional): document separator size (required for + 'complete_doc' break mode). Typically 1 if the sentences have eos + and 0 otherwise. + """ + + def __init__( + self, + dataset, + sizes, + block_size, + pad, + eos, + break_mode=None, + include_targets=False, + document_sep_len=1, + use_plasma_view=False, + split_path=None, + plasma_path=None, + ): + + super().__init__() + self.dataset = dataset + self.pad = pad + self.eos = eos + self.include_targets = include_targets + + assert len(dataset) > 0 + + assert len(dataset) == len(sizes) + _sizes, block_to_dataset_index, slice_indices = self._build_slice_indices( + sizes, break_mode, document_sep_len, block_size + ) + if use_plasma_view: + plasma_id = (block_size, document_sep_len, str(break_mode), len(dataset)) + self._slice_indices = plasma_utils.PlasmaView( + slice_indices, split_path, (plasma_id, 0), plasma_path=plasma_path + ) + self._sizes = plasma_utils.PlasmaView( + _sizes, split_path, (plasma_id, 1), plasma_path=plasma_path + ) + self._block_to_dataset_index = plasma_utils.PlasmaView( + block_to_dataset_index, split_path, (plasma_id, 2), plasma_path=plasma_path, + ) + else: + self._slice_indices = plasma_utils.PlasmaArray(slice_indices) + self._sizes = plasma_utils.PlasmaArray(_sizes) + self._block_to_dataset_index = plasma_utils.PlasmaArray( + block_to_dataset_index + ) + + @staticmethod + def _build_slice_indices( + sizes, break_mode, document_sep_len, block_size + ) -> Tuple[np.ndarray]: + """Use token_block_utils_fast to build arrays for indexing into self.dataset""" + try: + from fairseq.data.token_block_utils_fast import ( + _get_slice_indices_fast, + _get_block_to_dataset_index_fast, + ) + except ImportError: + raise ImportError( + "Please build Cython components with: `pip install --editable .` " + "or `python setup.py build_ext --inplace`" + ) + + if isinstance(sizes, list): + sizes = np.array(sizes, dtype=np.int64) + else: + if torch.is_tensor(sizes): + sizes = sizes.numpy() + sizes = sizes.astype(np.int64) + + break_mode = break_mode if break_mode is not None else "none" + + # For "eos" break-mode, block_size is not required parameters. + if break_mode == "eos" and block_size is None: + block_size = 0 + + slice_indices = _get_slice_indices_fast( + sizes, str(break_mode), block_size, document_sep_len + ) + _sizes = slice_indices[:, 1] - slice_indices[:, 0] + + # build index mapping block indices to the underlying dataset indices + if break_mode == "eos": + # much faster version for eos break mode + block_to_dataset_index = np.stack( + [ + np.arange(len(sizes)), # starting index in dataset + np.zeros( + len(sizes), dtype=np.compat.long + ), # starting offset within starting index + np.arange(len(sizes)), # ending index in dataset + ], + 1, + ) + else: + block_to_dataset_index = _get_block_to_dataset_index_fast( + sizes, slice_indices, + ) + size_dtype = np.uint16 if block_size < 65535 else np.uint32 + num_tokens = slice_indices[-1].max() + slice_indices_dtype = best_fitting_int_dtype(num_tokens) + slice_indices = slice_indices.astype(slice_indices_dtype) + _sizes = _sizes.astype(size_dtype) + block_to_dataset_index = block_to_dataset_index.astype(slice_indices_dtype) + return _sizes, block_to_dataset_index, slice_indices + + @property + def slice_indices(self): + return self._slice_indices.array + + @property + def sizes(self): + return self._sizes.array + + @property + def block_to_dataset_index(self): + return self._block_to_dataset_index.array + + def attr(self, attr: str, index: int): + start_ds_idx, _, _ = self.block_to_dataset_index[index] + return self.dataset.attr(attr, start_ds_idx) + + def __getitem__(self, index): + start_ds_idx, start_offset, end_ds_idx = self.block_to_dataset_index[index] + + buffer = torch.cat( + [self.dataset[idx] for idx in range(start_ds_idx, end_ds_idx + 1)] + ) + slice_s, slice_e = self.slice_indices[index] + length = slice_e - slice_s + s, e = start_offset, start_offset + length + item = buffer[s:e] + + if self.include_targets: + # *target* is the original sentence (=item) + # *source* is shifted right by 1 (maybe left-padded with eos) + # *past_target* is shifted right by 2 (left-padded as needed) + if s == 0: + source = torch.cat([item.new([self.eos]), buffer[0 : e - 1]]) + past_target = torch.cat( + [item.new([self.pad, self.eos]), buffer[0 : e - 2]] + ) + else: + source = buffer[s - 1 : e - 1] + if s == 1: + past_target = torch.cat([item.new([self.eos]), buffer[0 : e - 2]]) + else: + past_target = buffer[s - 2 : e - 2] + + return source, item, past_target + + return item + + def __len__(self): + return len(self.slice_indices) + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + self.dataset.prefetch( + { + ds_idx + for index in indices + for start_ds_idx, _, end_ds_idx in [self.block_to_dataset_index[index]] + for ds_idx in range(start_ds_idx, end_ds_idx + 1) + } + ) diff --git a/fairseq/fairseq/data/token_block_utils_fast.pyx b/fairseq/fairseq/data/token_block_utils_fast.pyx new file mode 100644 index 0000000000000000000000000000000000000000..08af4f30613a7b6ffa965a7c7084acabec8f8749 --- /dev/null +++ b/fairseq/fairseq/data/token_block_utils_fast.pyx @@ -0,0 +1,187 @@ +# cython: language_level=3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +from itertools import chain +from libc.math cimport ceil + +cimport cython +cimport numpy as np + +from libc.stdint cimport int32_t, int64_t + +DTYPE = np.int64 +ctypedef int64_t DTYPE_t + + +@cython.boundscheck(False) +@cython.wraparound(False) +@cython.nonecheck(False) +cdef np.ndarray[DTYPE_t, ndim=2] _get_slice_indices_none_mode(np.ndarray[DTYPE_t, ndim=1] sizes, int block_size): + cdef DTYPE_t total_size = sizes.sum() + cdef DTYPE_t length = <DTYPE_t> ceil(total_size / <double> block_size) + cdef np.ndarray[DTYPE_t, ndim=2] slice_indices = np.zeros([length, 2], dtype=DTYPE) + cdef DTYPE_t[:, :] slice_indices_view = slice_indices + cdef DTYPE_t i + cdef DTYPE_t start + cdef DTYPE_t end + for i in range(length): + start = i * block_size + end = min(start + block_size, total_size) + slice_indices_view[i][0] = start + slice_indices_view[i][1] = end + return slice_indices + + +cdef np.ndarray[DTYPE_t, ndim=2] _fast_convert_to_np_array(list list_of_list): + """ + Faster function to convert DTYPE_t list of list. + Only fast when there are huge number of rows and low number of columns. + """ + cdef np.ndarray[DTYPE_t, ndim=1] flat = np.fromiter(chain.from_iterable(list_of_list), DTYPE, -1) + return flat.reshape((len(list_of_list), -1)) + + +@cython.boundscheck(False) +@cython.wraparound(False) +@cython.nonecheck(False) +cpdef np.ndarray[DTYPE_t, ndim=2] _get_slice_indices_fast(np.ndarray[DTYPE_t, ndim=1] sizes, str break_mode, int block_size, int document_sep_len): + cdef DTYPE_t tok_idx = 0 + cdef DTYPE_t sz_idx = 0 + cdef DTYPE_t curr_size = 0 + cdef DTYPE_t i = 0 + cdef DTYPE_t length + cdef DTYPE_t total_size + cdef DTYPE_t[:] sizes_view = sizes + cdef np.ndarray[DTYPE_t, ndim=2] slice_indices + cdef list slice_indices_list = [] + + if break_mode is None or break_mode == 'none': + slice_indices = _get_slice_indices_none_mode(sizes, block_size) + elif break_mode == 'complete': + while sz_idx < len(sizes_view): + if curr_size + sizes_view[sz_idx] <= block_size or curr_size == 0: + curr_size += sizes_view[sz_idx] + sz_idx += 1 + else: + slice_indices_list.append((tok_idx, tok_idx + curr_size)) + tok_idx += curr_size + curr_size = 0 + if curr_size > 0: + slice_indices_list.append((tok_idx, tok_idx + curr_size)) + slice_indices = _fast_convert_to_np_array(slice_indices_list) + elif break_mode == 'complete_doc': + while sz_idx < len(sizes_view): + if ( + (curr_size + sizes_view[sz_idx] <= block_size or curr_size == 0) + # an empty sentence indicates end-of-document: + and sizes_view[sz_idx] != document_sep_len + ): + curr_size += sizes_view[sz_idx] + sz_idx += 1 + else: + # Only keep non-empty documents. + if curr_size > 1: + slice_indices_list.append((tok_idx, tok_idx + curr_size)) + tok_idx += curr_size + curr_size = 0 + if sizes_view[sz_idx] == document_sep_len: + tok_idx += sizes_view[sz_idx] + sz_idx += 1 + if curr_size > 1: + slice_indices_list.append((tok_idx, tok_idx + curr_size)) + slice_indices = _fast_convert_to_np_array(slice_indices_list) + elif break_mode == 'eos': + slice_indices = np.zeros((len(sizes), 2), dtype=DTYPE) + cumsum = sizes.cumsum(axis=0) + slice_indices[1:, 0] = cumsum[:cumsum.shape[0] - 1] + slice_indices[:, 1] = cumsum + else: + raise ValueError('Invalid break_mode: ' + break_mode) + return slice_indices + + +@cython.boundscheck(False) +@cython.wraparound(False) +@cython.nonecheck(False) +cpdef np.ndarray[DTYPE_t, ndim=2] _get_block_to_dataset_index_fast(np.ndarray[DTYPE_t, ndim=1] sizes, np.ndarray[DTYPE_t, ndim=2] slice_indices): + cdef DTYPE_t start_ds_idx + cdef DTYPE_t start_offset + cdef DTYPE_t end_ds_idx + cdef DTYPE_t i + cdef DTYPE_t s + cdef DTYPE_t e + cdef DatasetSearcher ds = DatasetSearcher(sizes) + cdef np.ndarray[DTYPE_t, ndim=2] block_to_dataset_index = np.zeros([len(slice_indices), 3], dtype=DTYPE) + cdef DTYPE_t[:, :] block_to_dataset_index_view = block_to_dataset_index + cdef DTYPE_t[:, :] slice_indices_view = slice_indices + cdef Py_ssize_t x_max = slice_indices.shape[0] + + for i in range(x_max): + s = slice_indices_view[i][0] + e = slice_indices_view[i][1] + ds.seek(s) + start_ds_idx = ds.current_index + start_offset = ds.current_offset + if e <= s: + end_ds_idx = start_ds_idx + else: + ds.seek(e - 1) + end_ds_idx = ds.current_index + block_to_dataset_index_view[i][0] = start_ds_idx # starting index in dataset + block_to_dataset_index_view[i][1] = start_offset # starting offset within starting index + block_to_dataset_index_view[i][2] = end_ds_idx # ending index in dataset + return block_to_dataset_index + + +cdef class DatasetSearcher(object): + """Helper for mapping "flat" indices to indices and offsets in an + underlying dataset.""" + cdef DTYPE_t current_i + cdef DTYPE_t current_offset + cdef DTYPE_t current_index + cdef DTYPE_t[:] sizes + + def __init__(self, DTYPE_t[:] sizes): + self.sizes = sizes + self.reset() + + cdef reset(self): + self.current_offset = 0 # offset within current index in underlying dataset + self.current_i = 0 # "flat" index + self.current_index = 0 # index in underlying dataset + + @cython.boundscheck(False) + @cython.wraparound(False) + @cython.nonecheck(False) + cdef int step(self, DTYPE_t i): + cdef DTYPE_t to_consume + cdef DTYPE_t remaining + if i < self.current_i: + self.reset() + if i > self.current_i: + to_consume = i - self.current_i + remaining = self.sizes[self.current_index] - self.current_offset + if remaining > to_consume: + self.current_offset += to_consume + self.current_i += to_consume + else: + assert remaining >= 0 + self.current_i += remaining + self.current_index += 1 + self.current_offset = 0 + return 1 + return 0 + + @cython.boundscheck(False) + @cython.wraparound(False) + @cython.nonecheck(False) + cdef seek(self, DTYPE_t i): + cdef int not_done = 1 + while not_done == 1: + not_done = self.step(i) + assert self.current_i == i diff --git a/fairseq/fairseq/data/transform_eos_dataset.py b/fairseq/fairseq/data/transform_eos_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..fb14ff018edf13b20f5d0e486692dfb0a37ec6d1 --- /dev/null +++ b/fairseq/fairseq/data/transform_eos_dataset.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from . import FairseqDataset + + +class TransformEosDataset(FairseqDataset): + """A :class:`~fairseq.data.FairseqDataset` wrapper that appends/prepends/strips EOS. + + Note that the transformation is applied in :func:`collater`. + + Args: + dataset (~fairseq.data.FairseqDataset): dataset to wrap + eos (int): index of the end-of-sentence symbol + append_eos_to_src (bool, optional): append EOS to the end of src + remove_eos_from_src (bool, optional): remove EOS from the end of src + append_eos_to_tgt (bool, optional): append EOS to the end of tgt + remove_eos_from_tgt (bool, optional): remove EOS from the end of tgt + """ + + def __init__( + self, + dataset, + eos, + append_eos_to_src=False, + remove_eos_from_src=False, + append_eos_to_tgt=False, + remove_eos_from_tgt=False, + has_target=True, + ): + if not isinstance(dataset, FairseqDataset): + raise ValueError("dataset must be an instance of FairseqDataset") + if append_eos_to_src and remove_eos_from_src: + raise ValueError("cannot combine append_eos_to_src and remove_eos_from_src") + if append_eos_to_tgt and remove_eos_from_tgt: + raise ValueError("cannot combine append_eos_to_tgt and remove_eos_from_tgt") + + self.dataset = dataset + self.eos = torch.LongTensor([eos]) + self.append_eos_to_src = append_eos_to_src + self.remove_eos_from_src = remove_eos_from_src + self.append_eos_to_tgt = append_eos_to_tgt + self.remove_eos_from_tgt = remove_eos_from_tgt + self.has_target = has_target + + # precompute how we should adjust the reported sizes + self._src_delta = 0 + self._src_delta += 1 if append_eos_to_src else 0 + self._src_delta -= 1 if remove_eos_from_src else 0 + self._tgt_delta = 0 + self._tgt_delta += 1 if append_eos_to_tgt else 0 + self._tgt_delta -= 1 if remove_eos_from_tgt else 0 + + self._checked_src = False + self._checked_tgt = False + + def _check_src(self, src, expect_eos): + if not self._checked_src: + assert (src[-1] == self.eos[0]) == expect_eos + self._checked_src = True + + def _check_tgt(self, tgt, expect_eos): + if self.has_target and not self._checked_tgt: + assert (tgt[-1] == self.eos[0]) == expect_eos + self._checked_tgt = True + + def __getitem__(self, index): + return self.dataset[index] + + def __len__(self): + return len(self.dataset) + + def collater(self, samples): + def transform(item): + if self.append_eos_to_src: + self.eos = self.eos.to(device=item["source"].device) + self._check_src(item["source"], expect_eos=False) + item["source"] = torch.cat([item["source"], self.eos]) + if self.remove_eos_from_src: + self.eos = self.eos.to(device=item["source"].device) + self._check_src(item["source"], expect_eos=True) + item["source"] = item["source"][:-1] + if self.append_eos_to_tgt: + self.eos = self.eos.to(device=item["target"].device) + self._check_tgt(item["target"], expect_eos=False) + item["target"] = torch.cat([item["target"], self.eos]) + if self.remove_eos_from_tgt: + self.eos = self.eos.to(device=item["target"].device) + self._check_tgt(item["target"], expect_eos=True) + item["target"] = item["target"][:-1] + return item + + samples = list(map(transform, samples)) + return self.dataset.collater(samples) + + def num_tokens(self, index): + return self.dataset.num_tokens(index) + + def size(self, index): + if self.has_target: + src_len, tgt_len = self.dataset.size(index) + return (src_len + self._src_delta, tgt_len + self._tgt_delta) + else: + return self.dataset.size(index) + + def ordered_indices(self): + # NOTE: we assume that the ordering does not change based on the + # addition or removal of eos + return self.dataset.ordered_indices() + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.dataset.prefetch(indices) diff --git a/fairseq/fairseq/data/transform_eos_lang_pair_dataset.py b/fairseq/fairseq/data/transform_eos_lang_pair_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..e21144a88e0038c2f35711333a40315613004256 --- /dev/null +++ b/fairseq/fairseq/data/transform_eos_lang_pair_dataset.py @@ -0,0 +1,113 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from typing import Optional + +import torch + +from . import FairseqDataset + + +class TransformEosLangPairDataset(FairseqDataset): + """A :class:`~fairseq.data.FairseqDataset` wrapper that transform bos on + collated samples of language pair dataset. + + Note that the transformation is applied in :func:`collater`. + + Args: + dataset (~fairseq.data.FairseqDataset): dataset that collates sample into + LanguagePairDataset schema + src_eos (int): original source end-of-sentence symbol index to be replaced + new_src_eos (int, optional): new end-of-sentence symbol index to replace source eos symbol + tgt_bos (int, optional): original target beginning-of-sentence symbol index to be replaced + new_tgt_bos (int, optional): new beginning-of-sentence symbol index to replace at the + beginning of 'prev_output_tokens' + """ + + def __init__( + self, + dataset: FairseqDataset, + src_eos: int, + new_src_eos: Optional[int] = None, + tgt_bos: Optional[int] = None, + new_tgt_bos: Optional[int] = None, + ): + self.dataset = dataset + self.src_eos = src_eos + self.new_src_eos = new_src_eos + self.tgt_bos = tgt_bos + self.new_tgt_bos = new_tgt_bos + + def __getitem__(self, index): + return self.dataset[index] + + def __len__(self): + return len(self.dataset) + + def collater(self, samples, **extra_args): + samples = self.dataset.collater(samples, **extra_args) + if len(samples) == 0: + return samples + + if 'net_input' not in samples: + return samples + + if self.new_src_eos is not None: + if self.dataset.left_pad_source: + assert ( + samples["net_input"]["src_tokens"][:, -1] != self.src_eos + ).sum() == 0 + samples["net_input"]["src_tokens"][:, -1] = self.new_src_eos + else: + eos_idx = samples["net_input"]["src_lengths"] - 1 + assert ( + samples["net_input"]["src_tokens"][ + torch.arange(eos_idx.size(0)), eos_idx + ] + != self.src_eos + ).sum() == 0 + eos_idx = eos_idx.resize_(len(samples["net_input"]["src_lengths"]), 1) + samples["net_input"]["src_tokens"].scatter_( + 1, eos_idx, self.new_src_eos + ) + + if ( + self.new_tgt_bos is not None + and "prev_output_tokens" in samples["net_input"] + ): + if self.dataset.left_pad_target: + # TODO: support different padding direction on target side + raise NotImplementedError( + "TransformEosLangPairDataset does not implement --left-pad-target True option" + ) + else: + assert ( + samples["net_input"]["prev_output_tokens"][:, 0] != self.tgt_bos + ).sum() == 0 + samples["net_input"]["prev_output_tokens"][:, 0] = self.new_tgt_bos + + return samples + + def num_tokens(self, index): + return self.dataset.num_tokens(index) + + def size(self, index): + return self.dataset.size(index) + + @property + def sizes(self): + # dataset.sizes can be a dynamically computed sizes: + return self.dataset.sizes + + def ordered_indices(self): + return self.dataset.ordered_indices() + + @property + def supports_prefetch(self): + return getattr(self.dataset, "supports_prefetch", False) + + def prefetch(self, indices): + return self.dataset.prefetch(indices) diff --git a/fairseq/fairseq/dataclass/__init__.py b/fairseq/fairseq/dataclass/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..25408d28ec44cee56eb5fb3ab0c817dc04159e95 --- /dev/null +++ b/fairseq/fairseq/dataclass/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .configs import FairseqDataclass +from .constants import ChoiceEnum + + +__all__ = [ + "FairseqDataclass", + "ChoiceEnum", +] diff --git a/fairseq/fairseq/dataclass/configs.py b/fairseq/fairseq/dataclass/configs.py new file mode 100644 index 0000000000000000000000000000000000000000..795a1d3bfb65ff12b58fd1390de6be2f27fce504 --- /dev/null +++ b/fairseq/fairseq/dataclass/configs.py @@ -0,0 +1,1074 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys +from dataclasses import _MISSING_TYPE, dataclass, field +from typing import Any, List, Optional + +import torch + +from fairseq.dataclass.constants import ( + DATASET_IMPL_CHOICES, + DDP_BACKEND_CHOICES, + DDP_COMM_HOOK_CHOICES, + GENERATION_CONSTRAINTS_CHOICES, + GENERATION_DECODING_FORMAT_CHOICES, + LOG_FORMAT_CHOICES, + PIPELINE_CHECKPOINT_CHOICES, + PRINT_ALIGNMENT_CHOICES, + ZERO_SHARDING_CHOICES, +) + +from omegaconf import II, MISSING + + +@dataclass +class FairseqDataclass: + """fairseq base dataclass that supported fetching attributes and metas""" + + _name: Optional[str] = None + + @staticmethod + def name(): + return None + + def _get_all_attributes(self) -> List[str]: + return [k for k in self.__dataclass_fields__.keys()] + + def _get_meta( + self, attribute_name: str, meta: str, default: Optional[Any] = None + ) -> Any: + return self.__dataclass_fields__[attribute_name].metadata.get(meta, default) + + def _get_name(self, attribute_name: str) -> str: + return self.__dataclass_fields__[attribute_name].name + + def _get_default(self, attribute_name: str) -> Any: + if hasattr(self, attribute_name): + if str(getattr(self, attribute_name)).startswith("${"): + return str(getattr(self, attribute_name)) + elif str(self.__dataclass_fields__[attribute_name].default).startswith( + "${" + ): + return str(self.__dataclass_fields__[attribute_name].default) + elif ( + getattr(self, attribute_name) + != self.__dataclass_fields__[attribute_name].default + ): + return getattr(self, attribute_name) + + f = self.__dataclass_fields__[attribute_name] + if not isinstance(f.default_factory, _MISSING_TYPE): + return f.default_factory() + return f.default + + def _get_type(self, attribute_name: str) -> Any: + return self.__dataclass_fields__[attribute_name].type + + def _get_help(self, attribute_name: str) -> Any: + return self._get_meta(attribute_name, "help") + + def _get_argparse_const(self, attribute_name: str) -> Any: + return self._get_meta(attribute_name, "argparse_const") + + def _get_argparse_alias(self, attribute_name: str) -> Any: + return self._get_meta(attribute_name, "argparse_alias") + + def _get_choices(self, attribute_name: str) -> Any: + return self._get_meta(attribute_name, "choices") + + @classmethod + def from_namespace(cls, args): + if isinstance(args, cls): + return args + else: + config = cls() + for k in config.__dataclass_fields__.keys(): + if k.startswith("_"): + # private member, skip + continue + if hasattr(args, k): + setattr(config, k, getattr(args, k)) + + return config + + + +@dataclass +class CommonConfig(FairseqDataclass): + # This is the core dataclass including common parameters shared by all different jobs. Please append your params to other dataclasses if they were + # used for a particular purpose or task, such as those dedicated for `distributed training`, `optimization`, etc. + no_progress_bar: bool = field( + default=False, metadata={"help": "disable progress bar"} + ) + log_interval: int = field( + default=100, + metadata={ + "help": "log progress every N batches (when progress bar is disabled)" + }, + ) + log_format: Optional[LOG_FORMAT_CHOICES] = field( + default=None, metadata={"help": "log format to use"} + ) + log_file: Optional[str] = field( + default=None, metadata={"help": "log file to copy metrics to."} + ) + tensorboard_logdir: Optional[str] = field( + default=None, + metadata={ + "help": "path to save logs for tensorboard, should match --logdir " + "of running tensorboard (default: no tensorboard logging)" + }, + ) + wandb_project: Optional[str] = field( + default=None, + metadata={"help": "Weights and Biases project name to use for logging"}, + ) + azureml_logging: Optional[bool] = field( + default=False, metadata={"help": "Log scalars to AzureML context"}, + ) + seed: int = field( + default=1, metadata={"help": "pseudo random number generator seed"} + ) + cpu: bool = field(default=False, metadata={"help": "use CPU instead of CUDA"}) + tpu: bool = field(default=False, metadata={"help": "use TPU instead of CUDA"}) + bf16: bool = field(default=False, metadata={"help": "use bfloat16; implies --tpu"}) + memory_efficient_bf16: bool = field( + default=False, + metadata={ + "help": "use a memory-efficient version of BF16 training; implies --bf16" + }, + ) + fp16: bool = field(default=False, metadata={"help": "use FP16"}) + memory_efficient_fp16: bool = field( + default=False, + metadata={ + "help": "use a memory-efficient version of FP16 training; implies --fp16" + }, + ) + fp16_no_flatten_grads: bool = field( + default=False, metadata={"help": "don't flatten FP16 grads tensor"} + ) + fp16_init_scale: int = field( + default=2 ** 7, metadata={"help": "default FP16 loss scale"} + ) + fp16_scale_window: Optional[int] = field( + default=None, + metadata={"help": "number of updates before increasing loss scale"}, + ) + fp16_scale_tolerance: float = field( + default=0.0, + metadata={ + "help": "pct of updates that can overflow before decreasing the loss scale" + }, + ) + on_cpu_convert_precision: bool = field( + default=False, + metadata={ + "help": "if set, the floating point conversion to fp16/bf16 runs on CPU. " + "This reduces bus transfer time and GPU memory usage." + } + ) + min_loss_scale: float = field( + default=1e-4, + metadata={"help": "minimum FP16/AMP loss scale, after which training is stopped"}, + ) + threshold_loss_scale: Optional[float] = field( + default=None, metadata={"help": "threshold FP16 loss scale from below"} + ) + amp: bool = field(default=False, metadata={"help": "use automatic mixed precision"}) + amp_batch_retries: int = field( + default=2, + metadata={"help": "number of retries of same batch after reducing loss scale with AMP"}, + ) + amp_init_scale: int = field( + default=2 ** 7, metadata={"help": "default AMP loss scale"} + ) + amp_scale_window: Optional[int] = field( + default=None, + metadata={"help": "number of updates before increasing AMP loss scale"}, + ) + user_dir: Optional[str] = field( + default=None, + metadata={ + "help": "path to a python module containing custom extensions (tasks and/or architectures)" + }, + ) + empty_cache_freq: int = field( + default=0, + metadata={"help": "how often to clear the PyTorch CUDA cache (0 to disable)"}, + ) + all_gather_list_size: int = field( + default=16384, + metadata={"help": "number of bytes reserved for gathering stats from workers"}, + ) + model_parallel_size: int = field( + default=1, metadata={"help": "total number of GPUs to parallelize model over"} + ) + quantization_config_path: Optional[str] = field( + default=None, metadata={"help": "path to quantization config file"} + ) + profile: bool = field( + default=False, metadata={"help": "enable autograd profiler emit_nvtx"} + ) + reset_logging: bool = field( + default=False, + metadata={ + "help": "when using Hydra, reset the logging at the beginning of training" + }, + ) + suppress_crashes: bool = field( + default=False, + metadata={ + "help": "suppress crashes when training with the hydra_train entry point so that the " + "main method can return a value (useful for sweeps)" + }, + ) + use_plasma_view: bool = field( + default=False, metadata={"help": "Store indices and sizes in shared memory"} + ) + plasma_path: Optional[str] = field( + default="/tmp/plasma", + metadata={ + "help": "path to run plasma_store, defaults to /tmp/plasma. Paths outside /tmp tend to fail." + }, + ) + + +@dataclass +class DistributedTrainingConfig(FairseqDataclass): + distributed_world_size: int = field( + default=max(1, torch.cuda.device_count()), + metadata={ + "help": "total number of GPUs across all nodes (default: all visible GPUs)" + }, + ) + distributed_num_procs: Optional[int] = field( + default=max(1, torch.cuda.device_count()), + metadata={ + "help": "total number of processes to fork (default: all visible GPUs)" + }, + ) + distributed_rank: Optional[int] = field( + default=0, metadata={"help": "rank of the current worker"} + ) + distributed_backend: str = field( + default="nccl", metadata={"help": "distributed backend"} + ) + distributed_init_method: Optional[str] = field( + default=None, + metadata={ + "help": "typically tcp://hostname:port that will be used to " + "establish initial connetion" + }, + ) + distributed_port: int = field( + default=-1, + metadata={ + "help": "port number (not required if using --distributed-init-method)" + }, + ) + device_id: int = field( + default=0, + metadata={ + "help": "which GPU to use (usually configured automatically)", + "argparse_alias": "--local_rank", + }, + ) + distributed_no_spawn: bool = field( + default=False, + metadata={ + "help": "do not spawn multiple processes even if multiple GPUs are visible" + }, + ) + ddp_backend: DDP_BACKEND_CHOICES = field( + default="pytorch_ddp", metadata={"help": "DistributedDataParallel backend"} + ) + ddp_comm_hook: DDP_COMM_HOOK_CHOICES = field( + default="none", metadata={"help": "communication hook"} + ) + bucket_cap_mb: int = field( + default=25, metadata={"help": "bucket size for reduction"} + ) + fix_batches_to_gpus: bool = field( + default=False, + metadata={ + "help": "don't shuffle batches between GPUs; this reduces overall " + "randomness and may affect precision but avoids the cost of re-reading the data" + }, + ) + find_unused_parameters: bool = field( + default=False, + metadata={ + "help": "disable unused parameter detection (not applicable to " + "--ddp-backend=legacy_ddp)" + }, + ) + gradient_as_bucket_view: bool = field( + default=False, + metadata={ + "help": "when set to True, gradients will be views pointing to different offsets of allreduce communication buckets. This can reduce peak memory usage, where the saved memory size will be equal to the total gradients size. " + "--gradient-as-bucket-view=gradient_as_bucket_view)" + }, + ) + fast_stat_sync: bool = field( + default=False, + metadata={"help": "[deprecated] this is now defined per Criterion"}, + ) + heartbeat_timeout: int = field( + default=-1, + metadata={ + "help": "kill the job if no progress is made in N seconds; " + "set to -1 to disable" + }, + ) + broadcast_buffers: bool = field( + default=False, + metadata={ + "help": "Copy non-trainable parameters between GPUs, such as " + "batchnorm population statistics" + }, + ) + slowmo_momentum: Optional[float] = field( + default=None, + metadata={ + "help": "SlowMo momentum term; by default use 0.0 for 16 GPUs, " + "0.2 for 32 GPUs; 0.5 for 64 GPUs, 0.6 for > 64 GPUs" + }, + ) + slowmo_algorithm: str = field( + default="LocalSGD", metadata={"help": "whether to use LocalSGD or SGP"} + ) + localsgd_frequency: int = field( + default=3, metadata={"help": "Local SGD allreduce frequency"} + ) + nprocs_per_node: int = field( + default=max(1, torch.cuda.device_count()), + metadata={ + "help": "number of GPUs in each node. An allreduce operation across GPUs in " + "a node is very fast. Hence, we do allreduce across GPUs in a node, " + "and gossip across different nodes" + }, + ) + pipeline_model_parallel: bool = field( + default=False, + metadata={"help": "if set, use pipeline model parallelism across GPUs"}, + ) + pipeline_balance: Optional[str] = field( + default=None, + metadata={ + "help": "partition the model into N_K pieces, where each piece " + "contains N_i layers. The sum(args.pipeline_balance) " + "should equal the total number of layers in the model" + }, + ) + pipeline_devices: Optional[str] = field( + default=None, + metadata={ + "help": "a list of device indices indicating which device to place " + "each of the N_K partitions. The length of this list should " + "equal the length of the --pipeline-balance argument" + }, + ) + pipeline_chunks: Optional[int] = field( + default=0, metadata={"help": "microbatch count for pipeline model parallelism"} + ) + pipeline_encoder_balance: Optional[str] = field( + default=None, + metadata={ + "help": "partition the pipeline parallel encoder into N_K pieces, where each piece " + "contains N_i layers. The sum(args.pipeline_encoder_balance) " + "should equal the total number of encoder layers in the model" + }, + ) + pipeline_encoder_devices: Optional[str] = field( + default=None, + metadata={ + "help": "a list of device indices indicating which device to place " + "each of the N_K partitions. The length of this list should " + "equal the length of the --pipeline-encoder-balance argument" + }, + ) + pipeline_decoder_balance: Optional[str] = field( + default=None, + metadata={ + "help": "partition the pipeline parallel decoder into N_K pieces, where each piece " + "contains N_i layers. The sum(args.pipeline_decoder_balance) " + "should equal the total number of decoder layers in the model" + }, + ) + pipeline_decoder_devices: Optional[str] = field( + default=None, + metadata={ + "help": "a list of device indices indicating which device to place " + "each of the N_K partitions. The length of this list should " + "equal the length of the --pipeline-decoder-balance argument" + }, + ) + pipeline_checkpoint: PIPELINE_CHECKPOINT_CHOICES = field( + default="never", + metadata={"help": "checkpointing mode for pipeline model parallelism"}, + ) + zero_sharding: ZERO_SHARDING_CHOICES = field( + default="none", metadata={"help": "ZeRO sharding"} + ) + fp16: bool = II("common.fp16") + memory_efficient_fp16: bool = II("common.memory_efficient_fp16") + tpu: bool = II("common.tpu") + # configuration for --ddp-backend=fully_sharded + no_reshard_after_forward: bool = field( + default=False, metadata={"help": "don't reshard parameters after forward pass"}, + ) + fp32_reduce_scatter: bool = field( + default=False, metadata={"help": "reduce-scatter grads in FP32"}, + ) + cpu_offload: bool = field( + default=False, metadata={"help": "offload FP32 params to CPU"} + ) + use_sharded_state: bool = field( + default=False, metadata={"help": "use sharded checkpoint files"}, + ) + + +@dataclass +class DatasetConfig(FairseqDataclass): + num_workers: int = field( + default=1, metadata={"help": "how many subprocesses to use for data loading"} + ) + skip_invalid_size_inputs_valid_test: bool = field( + default=False, + metadata={"help": "ignore too long or too short lines in valid and test set"}, + ) + max_tokens: Optional[int] = field( + default=None, metadata={"help": "maximum number of tokens in a batch"} + ) + batch_size: Optional[int] = field( + default=None, + metadata={ + "help": "number of examples in a batch", + "argparse_alias": "--max-sentences", + }, + ) + required_batch_size_multiple: int = field( + default=8, metadata={"help": "batch size will be a multiplier of this value"} + ) + required_seq_len_multiple: int = field( + default=1, + metadata={ + "help": "maximum sequence length in batch will be a multiplier of this value" + }, + ) + dataset_impl: Optional[DATASET_IMPL_CHOICES] = field( + default=None, metadata={"help": "output dataset implementation"} + ) + data_buffer_size: int = field( + default=10, metadata={"help": "Number of batches to preload"} + ) + train_subset: str = field( + default="train", + metadata={"help": "data subset to use for training (e.g. train, valid, test)"}, + ) + valid_subset: str = field( + default="valid", + metadata={ + "help": "comma separated list of data subsets to use for validation" + " (e.g. train, valid, test)" + }, + ) + combine_valid_subsets: Optional[bool] = field( + default=None, + metadata={ + "help": "comma separated list of data subsets to use for validation" + " (e.g. train, valid, test)", + "argparse_alias": "--combine-val", + }, + ) + ignore_unused_valid_subsets: Optional[bool] = field( + default=False, + metadata={"help": "do not raise error if valid subsets are ignored"}, + ) + + validate_interval: int = field( + default=1, metadata={"help": "validate every N epochs"} + ) + validate_interval_updates: int = field( + default=0, metadata={"help": "validate every N updates"} + ) + validate_after_updates: int = field( + default=0, metadata={"help": "dont validate until reaching this many updates"} + ) + fixed_validation_seed: Optional[int] = field( + default=None, metadata={"help": "specified random seed for validation"} + ) + disable_validation: bool = field( + default=False, metadata={"help": "disable validation"} + ) + max_tokens_valid: Optional[int] = field( + default=II("dataset.max_tokens"), + metadata={ + "help": "maximum number of tokens in a validation batch" + " (defaults to --max-tokens)" + }, + ) + batch_size_valid: Optional[int] = field( + default=II("dataset.batch_size"), + metadata={ + "help": "batch size of the validation batch (defaults to --batch-size)", + "argparse_alias": "--max-sentences-valid", + }, + ) + max_valid_steps: Optional[int] = field(default=None, metadata={'help': 'How many batches to evaluate', + "argparse_alias": "--nval"}) + curriculum: int = field( + default=0, metadata={"help": "don't shuffle batches for first N epochs"} + ) + gen_subset: str = field( + default="test", + metadata={"help": "data subset to generate (train, valid, test)"}, + ) + num_shards: int = field( + default=1, metadata={"help": "shard generation over N shards"} + ) + shard_id: int = field( + default=0, metadata={"help": "id of the shard to generate (id < num_shards)"} + ) + + +@dataclass +class OptimizationConfig(FairseqDataclass): + max_epoch: int = field( + default=0, metadata={"help": "force stop training at specified epoch"} + ) + max_update: int = field( + default=0, metadata={"help": "force stop training at specified update"} + ) + stop_time_hours: float = field( + default=0, + metadata={ + "help": "force stop training after specified cumulative time (if >0)" + }, + ) + clip_norm: float = field( + default=0.0, metadata={"help": "clip threshold of gradients"} + ) + sentence_avg: bool = field( + default=False, + metadata={ + "help": "normalize gradients by the number of sentences in a batch" + " (default is to normalize by number of tokens)" + }, + ) + update_freq: List[int] = field( + default_factory=lambda: [1], + metadata={"help": "update parameters every N_i batches, when in epoch i"}, + ) + lr: List[float] = field( + default_factory=lambda: [0.25], + metadata={ + "help": "learning rate for the first N epochs; all epochs >N using LR_N" + " (note: this may be interpreted differently depending on --lr-scheduler)" + }, + ) + stop_min_lr: float = field( + default=-1.0, + metadata={"help": "stop training when the learning rate reaches this minimum"}, + ) + use_bmuf: bool = field( + default=False, + metadata={ + "help": "specify global optimizer for syncing models on different GPUs/shards" + }, + ) + + +@dataclass +class CheckpointConfig(FairseqDataclass): + save_dir: str = field( + default="checkpoints", metadata={"help": "path to save checkpoints"} + ) + restore_file: str = field( + default="checkpoint_last.pt", + metadata={ + "help": "filename from which to load checkpoint " + "(default: <save-dir>/checkpoint_last.pt" + }, + ) + finetune_from_model: Optional[str] = field( + default=None, + metadata={ + "help": "finetune from a pretrained model; note that meters and lr scheduler will be reset" + }, + ) + reset_dataloader: bool = field( + default=False, + metadata={ + "help": "if set, does not reload dataloader state from the checkpoint" + }, + ) + reset_lr_scheduler: bool = field( + default=False, + metadata={ + "help": "if set, does not load lr scheduler state from the checkpoint" + }, + ) + reset_meters: bool = field( + default=False, + metadata={"help": "if set, does not load meters from the checkpoint"}, + ) + reset_optimizer: bool = field( + default=False, + metadata={"help": "if set, does not load optimizer state from the checkpoint"}, + ) + optimizer_overrides: str = field( + default="{}", + metadata={ + "help": "a dictionary used to override optimizer args when loading a checkpoint" + }, + ) + save_interval: int = field( + default=1, metadata={"help": "save a checkpoint every N epochs"} + ) + save_interval_updates: int = field( + default=0, metadata={"help": "save a checkpoint (and validate) every N updates"} + ) + keep_interval_updates: int = field( + default=-1, + metadata={ + "help": "keep the last N checkpoints saved with --save-interval-updates" + }, + ) + keep_interval_updates_pattern: int = field( + default=-1, + metadata={ + "help": "when used with --keep-interval-updates, skips deleting " + "any checkpoints with update X where " + "X %% keep_interval_updates_pattern == 0" + }, + ) + keep_last_epochs: int = field( + default=-1, metadata={"help": "keep last N epoch checkpoints"} + ) + keep_best_checkpoints: int = field( + default=-1, metadata={"help": "keep best N checkpoints based on scores"} + ) + no_save: bool = field( + default=False, metadata={"help": "don't save models or checkpoints"} + ) + no_epoch_checkpoints: bool = field( + default=False, metadata={"help": "only store last and best checkpoints"} + ) + no_last_checkpoints: bool = field( + default=False, metadata={"help": "don't store last checkpoints"} + ) + no_save_optimizer_state: bool = field( + default=False, + metadata={"help": "don't save optimizer-state as part of checkpoint"}, + ) + best_checkpoint_metric: str = field( + default="loss", metadata={"help": 'metric to use for saving "best" checkpoints'} + ) + maximize_best_checkpoint_metric: bool = field( + default=False, + metadata={ + "help": 'select the largest metric value for saving "best" checkpoints' + }, + ) + patience: int = field( + default=-1, + metadata={ + "help": ( + "early stop training if valid performance doesn't " + "improve for N consecutive validation runs; note " + "that this is influenced by --validate-interval" + ) + }, + ) + checkpoint_suffix: str = field( + default="", metadata={"help": "suffix to add to the checkpoint file name"} + ) + checkpoint_shard_count: int = field( + default=1, + metadata={ + "help": "Number of shards containing the checkpoint - " + "if the checkpoint is over 300GB, it is preferable " + "to split it into shards to prevent OOM on CPU while loading " + "the checkpoint" + }, + ) + load_checkpoint_on_all_dp_ranks: bool = field( + default=False, + metadata={ + "help": "load checkpoints on all data parallel devices " + "(default: only load on rank 0 and broadcast to other devices)" + }, + ) + write_checkpoints_asynchronously: bool = field( + default=False, + metadata={ + "help": ( + "Write checkpoints asynchronously in a separate " + "thread. NOTE: This feature is currently being tested." + ), + "argparse_alias": "--save-async", + }, + ) + model_parallel_size: int = II("common.model_parallel_size") + use_ema_weights_to_init_param: bool = field( + default=False, + metadata={ + "help": "if the checkpoint has ema weights, then use it to init the model param" + "(default: false, use noema weights to init the model param)" + }, + ) + use_latest_weights_to_init_ema: bool = field( + default=False, + metadata={ + "help": "if the model has ema params, then force to use the latest weights in the ckpt to init the ema param, even ema weights exist in the ckpt" + "(default: false, use ema weights (if exist) to init the ema param)" + }, + ) + + load_on_cuda: bool = field( + default=False, + metadata={ + "help": "load on cuda " + "(default: load on cpu)" + }, + ) + + save_on_cuda: bool = field( + default=False, + metadata={ + "help": "save on cuda " + "(default: save on cpu)" + }, + ) + + +@dataclass +class FairseqBMUFConfig(FairseqDataclass): + block_lr: float = field( + default=1, metadata={"help": "block learning rate for bmuf"} + ) + block_momentum: float = field( + default=0.875, metadata={"help": "block momentum for bmuf"} + ) + global_sync_iter: int = field( + default=50, metadata={"help": "Iteration for syncing global model"} + ) + warmup_iterations: int = field( + default=500, metadata={"help": "warmup iterations for model to broadcast"} + ) + use_nbm: bool = field( + default=False, + metadata={"help": "Specify whether you want to use classical BM / Nesterov BM"}, + ) + average_sync: bool = field( + default=False, + metadata={ + "help": "Specify whether you want to average the local momentum after each sync" + }, + ) + distributed_world_size: int = II("distributed_training.distributed_world_size") + + +@dataclass +class GenerationConfig(FairseqDataclass): + beam: int = field( + default=5, metadata={"help": "beam size"}, + ) + nbest: int = field( + default=1, metadata={"help": "number of hypotheses to output"}, + ) + max_len_a: float = field( + default=0, + metadata={ + "help": "generate sequences of maximum length ax + b, where x is the source length" + }, + ) + max_len_b: int = field( + default=200, + metadata={ + "help": "generate sequences of maximum length ax + b, where x is the source length" + }, + ) + min_len: int = field( + default=1, metadata={"help": "minimum generation length"}, + ) + match_source_len: bool = field( + default=False, metadata={"help": "generations should match the source length"}, + ) + unnormalized: bool = field( + default=False, metadata={"help": "compare unnormalized hypothesis scores"}, + ) + no_early_stop: bool = field( + default=False, metadata={"help": "deprecated"}, + ) + no_beamable_mm: bool = field( + default=False, metadata={"help": "don't use BeamableMM in attention layers"}, + ) + lenpen: float = field( + default=1, + metadata={ + "help": "length penalty: <1.0 favors shorter, >1.0 favors longer sentences" + }, + ) + unkpen: float = field( + default=0, + metadata={ + "help": "unknown word penalty: <0 produces more unks, >0 produces fewer" + }, + ) + replace_unk: Optional[str] = field( + default=None, + metadata={ + "help": "perform unknown replacement (optionally with alignment dictionary)", + "argparse_const": "@@ ", + }, + ) + sacrebleu: bool = field( + default=False, metadata={"help": "score with sacrebleu"}, + ) + score_reference: bool = field( + default=False, metadata={"help": "just score the reference translation"}, + ) + prefix_size: int = field( + default=0, + metadata={"help": "initialize generation by target prefix of given length"}, + ) + no_repeat_ngram_size: int = field( + default=0, + metadata={ + "help": "ngram blocking such that this size ngram cannot be repeated in the generation" + }, + ) + sampling: bool = field( + default=False, + metadata={"help": "sample hypotheses instead of using beam search"}, + ) + sampling_topk: int = field( + default=-1, + metadata={"help": "sample from top K likely next words instead of all words"}, + ) + sampling_topp: float = field( + default=-1.0, + metadata={ + "help": "sample from the smallest set whose cumulative probability mass exceeds p for next words" + }, + ) + constraints: Optional[GENERATION_CONSTRAINTS_CHOICES] = field( + default=None, + metadata={ + "help": "enables lexically constrained decoding", + "argparse_const": "ordered", + }, + ) + temperature: float = field( + default=1.0, metadata={"help": "temperature for generation"}, + ) + diverse_beam_groups: int = field( + default=-1, metadata={"help": "number of groups for Diverse Beam Search"}, + ) + diverse_beam_strength: float = field( + default=0.5, + metadata={"help": "strength of diversity penalty for Diverse Beam Search"}, + ) + diversity_rate: float = field( + default=-1.0, + metadata={"help": "strength of diversity penalty for Diverse Siblings Search"}, + ) + print_alignment: Optional[PRINT_ALIGNMENT_CHOICES] = field( + default=None, + metadata={ + "help": "if set, uses attention feedback to compute and print alignment to source tokens " + "(valid options are: hard, soft, otherwise treated as hard alignment)", + "argparse_const": "hard", + }, + ) + print_step: bool = field( + default=False, metadata={"help": "print steps"}, + ) + lm_path: Optional[str] = field( + default=None, metadata={"help": "path to lm checkpoint for lm fusion"}, + ) + lm_weight: float = field( + default=0.0, metadata={"help": "weight for lm probs for lm fusion"}, + ) + + # arguments for iterative refinement generator + iter_decode_eos_penalty: float = field( + default=0.0, + metadata={"help": "if > 0.0, it penalized early-stopping in decoding."}, + ) + iter_decode_max_iter: int = field( + default=10, metadata={"help": "maximum iterations for iterative refinement."}, + ) + iter_decode_force_max_iter: bool = field( + default=False, + metadata={ + "help": "if set, run exact the maximum number of iterations without early stop" + }, + ) + iter_decode_with_beam: int = field( + default=1, + metadata={ + "help": "if > 1, model will generate translations varying by the lengths." + }, + ) + iter_decode_with_external_reranker: bool = field( + default=False, + metadata={ + "help": "if set, the last checkpoint are assumed to be a reranker to rescore the translations" + }, + ) + retain_iter_history: bool = field( + default=False, + metadata={ + "help": "if set, decoding returns the whole history of iterative refinement" + }, + ) + retain_dropout: bool = field( + default=False, metadata={"help": "Use dropout at inference time"}, + ) + # temporarily set to Any until https://github.com/facebookresearch/hydra/issues/1117 is fixed + # retain_dropout_modules: Optional[List[str]] = field( + retain_dropout_modules: Any = field( + default=None, + metadata={ + "help": "if set, only retain dropout for the specified modules; " + "if not set, then dropout will be retained for all modules" + }, + ) + # special decoding format for advanced decoding. + decoding_format: Optional[GENERATION_DECODING_FORMAT_CHOICES] = field( + default=None, + metadata={"help": "special decoding format for advanced decoding."}, + ) + no_seed_provided: bool = field( + default=False, + metadata={"help": "if set, dont use seed for initializing random generators"}, + ) + + +@dataclass +class CommonEvalConfig(FairseqDataclass): + path: Optional[str] = field( + default=None, metadata={"help": "path(s) to model file(s), colon separated"}, + ) + post_process: Optional[str] = field( + default=None, + metadata={ + "help": ( + "post-process text by removing BPE, letter segmentation, etc. " + "Valid options can be found in fairseq.data.utils.post_process." + ), + "argparse_const": "subword_nmt", + "argparse_alias": "--remove-bpe", + }, + ) + quiet: bool = field(default=False, metadata={"help": "only print final scores"}) + model_overrides: str = field( + default="{}", + metadata={ + "help": "a dictionary used to override model args at generation that were used during model training" + }, + ) + results_path: Optional[str] = field( + default=None, metadata={"help": "path to save eval results (optional)"} + ) + + +@dataclass +class EvalLMConfig(FairseqDataclass): + output_word_probs: bool = field( + default=False, + metadata={ + "help": "if set, outputs words and their predicted log probabilities to standard output" + }, + ) + output_word_stats: bool = field( + default=False, + metadata={ + "help": "if set, outputs word statistics such as word count, average probability, etc" + }, + ) + context_window: int = field( + default=0, + metadata={ + "help": "ensures that every evaluated token has access to a context of at least this size, if possible" + }, + ) + softmax_batch: int = field( + default=sys.maxsize, + metadata={ + "help": "if BxT is more than this, will batch the softmax over vocab to this amount of tokens, in order to fit into GPU memory" + }, + ) + + +@dataclass +class InteractiveConfig(FairseqDataclass): + buffer_size: int = field( + default=0, + metadata={ + "help": "read this many sentences into a buffer before processing them" + }, + ) + input: str = field( + default="-", metadata={"help": "file to read from; use - for stdin"}, + ) + + +@dataclass +class EMAConfig(FairseqDataclass): + store_ema: bool = field( + default=False, metadata={ + help: "store exponential moving average shadow model" + } + ) + ema_decay: float = field( + default=0.9999, metadata={ + "help": 'decay for exponential moving average model' + } + ) + ema_start_update : int = field( + default=0, metadata={"help": "start EMA update after this many model updates"} + ) + ema_seed_model : Optional[str] = field( + default=None, metadata={ + "help": "Seed to load EMA model from. " + "Used to load EMA model separately from the actual model." + } + ) + ema_update_freq : int = field( + default=1, metadata={"help": "Do EMA update every this many model updates"} + ) + ema_fp32: bool = field( + default=False, + metadata={"help": "If true, store EMA model in fp32 even if model is in fp16"}, + ) + + +@dataclass +class FairseqConfig(FairseqDataclass): + common: CommonConfig = CommonConfig() + common_eval: CommonEvalConfig = CommonEvalConfig() + distributed_training: DistributedTrainingConfig = DistributedTrainingConfig() + dataset: DatasetConfig = DatasetConfig() + optimization: OptimizationConfig = OptimizationConfig() + checkpoint: CheckpointConfig = CheckpointConfig() + bmuf: FairseqBMUFConfig = FairseqBMUFConfig() + generation: GenerationConfig = GenerationConfig() + eval_lm: EvalLMConfig = EvalLMConfig() + interactive: InteractiveConfig = InteractiveConfig() + model: Any = MISSING + task: Any = None + criterion: Any = None + optimizer: Any = None + lr_scheduler: Any = None + scoring: Any = None + bpe: Any = None + tokenizer: Any = None + ema: EMAConfig = EMAConfig() diff --git a/fairseq/fairseq/dataclass/constants.py b/fairseq/fairseq/dataclass/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..4f159cfe9ac72b0524228fe290181c6898787265 --- /dev/null +++ b/fairseq/fairseq/dataclass/constants.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from enum import Enum, EnumMeta +from typing import List + + +class StrEnumMeta(EnumMeta): + # this is workaround for submitit pickling leading to instance checks failing in hydra for StrEnum, see + # https://github.com/facebookresearch/hydra/issues/1156 + @classmethod + def __instancecheck__(cls, other): + return "enum" in str(type(other)) + + +class StrEnum(Enum, metaclass=StrEnumMeta): + def __str__(self): + return self.value + + def __eq__(self, other: str): + return self.value == other + + def __repr__(self): + return self.value + + def __hash__(self): + return hash(str(self)) + + +def ChoiceEnum(choices: List[str]): + """return the Enum class used to enforce list of choices""" + return StrEnum("Choices", {k: k for k in choices}) + + +LOG_FORMAT_CHOICES = ChoiceEnum(["json", "none", "simple", "tqdm"]) +DDP_BACKEND_CHOICES = ChoiceEnum([ + "c10d", # alias for pytorch_ddp + "fully_sharded", # FullyShardedDataParallel from fairscale + "legacy_ddp", + "no_c10d", # alias for legacy_ddp + "pytorch_ddp", + "slow_mo", +]) +DDP_COMM_HOOK_CHOICES = ChoiceEnum(["none", "fp16"]) +DATASET_IMPL_CHOICES = ChoiceEnum(["raw", "lazy", "cached", "mmap", "fasta", "huffman"]) +GENERATION_CONSTRAINTS_CHOICES = ChoiceEnum(["ordered", "unordered"]) +GENERATION_DECODING_FORMAT_CHOICES = ChoiceEnum( + ["unigram", "ensemble", "vote", "dp", "bs"] +) +ZERO_SHARDING_CHOICES = ChoiceEnum(["none", "os"]) +PIPELINE_CHECKPOINT_CHOICES = ChoiceEnum(["always", "never", "except_last"]) +PRINT_ALIGNMENT_CHOICES = ChoiceEnum(["hard", "soft"]) diff --git a/fairseq/fairseq/dataclass/initialize.py b/fairseq/fairseq/dataclass/initialize.py new file mode 100644 index 0000000000000000000000000000000000000000..8f6cbafb805b293611e2175721132078123b81d0 --- /dev/null +++ b/fairseq/fairseq/dataclass/initialize.py @@ -0,0 +1,61 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import logging +from hydra.core.config_store import ConfigStore +from fairseq.dataclass.configs import FairseqConfig +from omegaconf import DictConfig, OmegaConf + + +logger = logging.getLogger(__name__) + + +def hydra_init(cfg_name="config") -> None: + + cs = ConfigStore.instance() + cs.store(name=f"{cfg_name}", node=FairseqConfig) + + for k in FairseqConfig.__dataclass_fields__: + v = FairseqConfig.__dataclass_fields__[k].default + try: + cs.store(name=k, node=v) + except BaseException: + logger.error(f"{k} - {v}") + raise + + +def add_defaults(cfg: DictConfig) -> None: + """This function adds default values that are stored in dataclasses that hydra doesn't know about """ + + from fairseq.registry import REGISTRIES + from fairseq.tasks import TASK_DATACLASS_REGISTRY + from fairseq.models import ARCH_MODEL_NAME_REGISTRY, MODEL_DATACLASS_REGISTRY + from fairseq.dataclass.utils import merge_with_parent + from typing import Any + + OmegaConf.set_struct(cfg, False) + + for k, v in FairseqConfig.__dataclass_fields__.items(): + field_cfg = cfg.get(k) + if field_cfg is not None and v.type == Any: + dc = None + + if isinstance(field_cfg, str): + field_cfg = DictConfig({"_name": field_cfg}) + field_cfg.__dict__["_parent"] = field_cfg.__dict__["_parent"] + + name = getattr(field_cfg, "_name", None) + + if k == "task": + dc = TASK_DATACLASS_REGISTRY.get(name) + elif k == "model": + name = ARCH_MODEL_NAME_REGISTRY.get(name, name) + dc = MODEL_DATACLASS_REGISTRY.get(name) + elif k in REGISTRIES: + dc = REGISTRIES[k]["dataclass_registry"].get(name) + + if dc is not None: + cfg[k] = merge_with_parent(dc, field_cfg) diff --git a/fairseq/fairseq/dataclass/utils.py b/fairseq/fairseq/dataclass/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1320ec473756c78ec949f72f9260420c19caff0f --- /dev/null +++ b/fairseq/fairseq/dataclass/utils.py @@ -0,0 +1,493 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import ast +import inspect +import logging +import os +import re +from argparse import ArgumentError, ArgumentParser, Namespace +from dataclasses import _MISSING_TYPE, MISSING, is_dataclass +from enum import Enum +from typing import Any, Dict, List, Optional, Tuple, Type + +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.configs import FairseqConfig +from hydra.core.global_hydra import GlobalHydra +from hydra.experimental import compose, initialize +from omegaconf import DictConfig, OmegaConf, open_dict, _utils + +logger = logging.getLogger(__name__) + + +def eval_str_list(x, x_type=float): + if x is None: + return None + if isinstance(x, str): + if len(x) == 0: + return [] + x = ast.literal_eval(x) + try: + return list(map(x_type, x)) + except TypeError: + return [x_type(x)] + + +def interpret_dc_type(field_type): + if isinstance(field_type, str): + raise RuntimeError("field should be a type") + + if field_type == Any: + return str + + typestring = str(field_type) + if re.match( + r"(typing.|^)Union\[(.*), NoneType\]$", typestring + ) or typestring.startswith("typing.Optional"): + return field_type.__args__[0] + return field_type + + +def gen_parser_from_dataclass( + parser: ArgumentParser, + dataclass_instance: FairseqDataclass, + delete_default: bool = False, + with_prefix: Optional[str] = None, +) -> None: + """ + convert a dataclass instance to tailing parser arguments. + + If `with_prefix` is provided, prefix all the keys in the resulting parser with it. It means that we are + building a flat namespace from a structured dataclass (see transformer_config.py for example). + """ + + def argparse_name(name: str): + if name == "data" and (with_prefix is None or with_prefix == ''): + # normally data is positional args, so we don't add the -- nor the prefix + return name + if name == "_name": + # private member, skip + return None + full_name = "--" + name.replace("_", "-") + if with_prefix is not None and with_prefix != '': + # if a prefix is specified, construct the prefixed arg name + full_name = with_prefix + "-" + full_name[2:] # strip -- when composing + return full_name + + def get_kwargs_from_dc( + dataclass_instance: FairseqDataclass, k: str + ) -> Dict[str, Any]: + """k: dataclass attributes""" + + kwargs = {} + + field_type = dataclass_instance._get_type(k) + inter_type = interpret_dc_type(field_type) + + field_default = dataclass_instance._get_default(k) + + if isinstance(inter_type, type) and issubclass(inter_type, Enum): + field_choices = [t.value for t in list(inter_type)] + else: + field_choices = None + + field_help = dataclass_instance._get_help(k) + field_const = dataclass_instance._get_argparse_const(k) + + if isinstance(field_default, str) and field_default.startswith("${"): + kwargs["default"] = field_default + else: + if field_default is MISSING: + kwargs["required"] = True + if field_choices is not None: + kwargs["choices"] = field_choices + if ( + isinstance(inter_type, type) + and (issubclass(inter_type, List) or issubclass(inter_type, Tuple)) + ) or ("List" in str(inter_type) or "Tuple" in str(inter_type)): + if "int" in str(inter_type): + kwargs["type"] = lambda x: eval_str_list(x, int) + elif "float" in str(inter_type): + kwargs["type"] = lambda x: eval_str_list(x, float) + elif "str" in str(inter_type): + kwargs["type"] = lambda x: eval_str_list(x, str) + else: + raise NotImplementedError( + "parsing of type " + str(inter_type) + " is not implemented" + ) + if field_default is not MISSING: + kwargs["default"] = ( + ",".join(map(str, field_default)) + if field_default is not None + else None + ) + elif ( + isinstance(inter_type, type) and issubclass(inter_type, Enum) + ) or "Enum" in str(inter_type): + kwargs["type"] = str + if field_default is not MISSING: + if isinstance(field_default, Enum): + kwargs["default"] = field_default.value + else: + kwargs["default"] = field_default + elif inter_type is bool: + kwargs["action"] = ( + "store_false" if field_default is True else "store_true" + ) + kwargs["default"] = field_default + else: + kwargs["type"] = inter_type + if field_default is not MISSING: + kwargs["default"] = field_default + + # build the help with the hierarchical prefix + if with_prefix is not None and with_prefix != '' and field_help is not None: + field_help = with_prefix[2:] + ': ' + field_help + + kwargs["help"] = field_help + if field_const is not None: + kwargs["const"] = field_const + kwargs["nargs"] = "?" + + return kwargs + + for k in dataclass_instance._get_all_attributes(): + field_name = argparse_name(dataclass_instance._get_name(k)) + field_type = dataclass_instance._get_type(k) + if field_name is None: + continue + elif inspect.isclass(field_type) and issubclass(field_type, FairseqDataclass): + # for fields that are of type FairseqDataclass, we can recursively + # add their fields to the namespace (so we add the args from model, task, etc. to the root namespace) + prefix = None + if with_prefix is not None: + # if a prefix is specified, then we don't want to copy the subfields directly to the root namespace + # but we prefix them with the name of the current field. + prefix = field_name + gen_parser_from_dataclass(parser, field_type(), delete_default, prefix) + continue + + kwargs = get_kwargs_from_dc(dataclass_instance, k) + + field_args = [field_name] + alias = dataclass_instance._get_argparse_alias(k) + if alias is not None: + field_args.append(alias) + + if "default" in kwargs: + if isinstance(kwargs["default"], str) and kwargs["default"].startswith( + "${" + ): + if kwargs["help"] is None: + # this is a field with a name that will be added elsewhere + continue + else: + del kwargs["default"] + if delete_default and "default" in kwargs: + del kwargs["default"] + try: + parser.add_argument(*field_args, **kwargs) + except ArgumentError: + pass + + +def _set_legacy_defaults(args, cls): + """Helper to set default arguments based on *add_args*.""" + if not hasattr(cls, "add_args"): + return + + import argparse + + parser = argparse.ArgumentParser( + argument_default=argparse.SUPPRESS, allow_abbrev=False + ) + cls.add_args(parser) + # copied from argparse.py: + defaults = argparse.Namespace() + for action in parser._actions: + if action.dest is not argparse.SUPPRESS: + if not hasattr(defaults, action.dest): + if action.default is not argparse.SUPPRESS: + setattr(defaults, action.dest, action.default) + for key, default_value in vars(defaults).items(): + if not hasattr(args, key): + setattr(args, key, default_value) + + +def _override_attr( + sub_node: str, data_class: Type[FairseqDataclass], args: Namespace +) -> List[str]: + overrides = [] + + if not inspect.isclass(data_class) or not issubclass(data_class, FairseqDataclass): + return overrides + + def get_default(f): + if not isinstance(f.default_factory, _MISSING_TYPE): + return f.default_factory() + return f.default + + for k, v in data_class.__dataclass_fields__.items(): + if k.startswith("_"): + # private member, skip + continue + + val = get_default(v) if not hasattr(args, k) else getattr(args, k) + + field_type = interpret_dc_type(v.type) + if ( + isinstance(val, str) + and not val.startswith("${") # not interpolation + and field_type != str + and ( + not inspect.isclass(field_type) or not issubclass(field_type, Enum) + ) # not choices enum + ): + # upgrade old models that stored complex parameters as string + val = ast.literal_eval(val) + + if isinstance(val, tuple): + val = list(val) + + v_type = getattr(v.type, "__origin__", None) + if ( + (v_type is List or v_type is list or v_type is Optional) + # skip interpolation + and not (isinstance(val, str) and val.startswith("${")) + ): + # if type is int but val is float, then we will crash later - try to convert here + if hasattr(v.type, "__args__"): + t_args = v.type.__args__ + if len(t_args) == 1 and (t_args[0] is float or t_args[0] is int): + val = list(map(t_args[0], val)) + elif val is not None and ( + field_type is int or field_type is bool or field_type is float + ): + try: + val = field_type(val) + except: + pass # ignore errors here, they are often from interpolation args + + if val is None: + overrides.append("{}.{}=null".format(sub_node, k)) + elif val == "": + overrides.append("{}.{}=''".format(sub_node, k)) + elif isinstance(val, str): + val = val.replace("'", r"\'") + overrides.append("{}.{}='{}'".format(sub_node, k, val)) + elif isinstance(val, FairseqDataclass): + overrides += _override_attr(f"{sub_node}.{k}", type(val), args) + elif isinstance(val, Namespace): + sub_overrides, _ = override_module_args(val) + for so in sub_overrides: + overrides.append(f"{sub_node}.{k}.{so}") + else: + overrides.append("{}.{}={}".format(sub_node, k, val)) + + return overrides + + +def migrate_registry( + name, value, registry, args, overrides, deletes, use_name_as_val=False +): + if value in registry: + overrides.append("{}={}".format(name, value)) + overrides.append("{}._name={}".format(name, value)) + overrides.extend(_override_attr(name, registry[value], args)) + elif use_name_as_val and value is not None: + overrides.append("{}={}".format(name, value)) + else: + deletes.append(name) + + +def override_module_args(args: Namespace) -> Tuple[List[str], List[str]]: + """use the field in args to overrides those in cfg""" + overrides = [] + deletes = [] + + for k in FairseqConfig.__dataclass_fields__.keys(): + overrides.extend( + _override_attr(k, FairseqConfig.__dataclass_fields__[k].type, args) + ) + + if args is not None: + if hasattr(args, "task"): + from fairseq.tasks import TASK_DATACLASS_REGISTRY + + migrate_registry( + "task", args.task, TASK_DATACLASS_REGISTRY, args, overrides, deletes + ) + else: + deletes.append("task") + + # these options will be set to "None" if they have not yet been migrated + # so we can populate them with the entire flat args + CORE_REGISTRIES = {"criterion", "optimizer", "lr_scheduler"} + + from fairseq.registry import REGISTRIES + + for k, v in REGISTRIES.items(): + if hasattr(args, k): + migrate_registry( + k, + getattr(args, k), + v["dataclass_registry"], + args, + overrides, + deletes, + use_name_as_val=k not in CORE_REGISTRIES, + ) + else: + deletes.append(k) + + no_dc = True + if hasattr(args, "arch"): + from fairseq.models import ARCH_MODEL_REGISTRY, ARCH_MODEL_NAME_REGISTRY + + if args.arch in ARCH_MODEL_REGISTRY: + m_cls = ARCH_MODEL_REGISTRY[args.arch] + dc = getattr(m_cls, "__dataclass", None) + if dc is not None: + m_name = ARCH_MODEL_NAME_REGISTRY[args.arch] + overrides.append("model={}".format(m_name)) + overrides.append("model._name={}".format(args.arch)) + # override model params with those exist in args + overrides.extend(_override_attr("model", dc, args)) + no_dc = False + if no_dc: + deletes.append("model") + + return overrides, deletes + + +class omegaconf_no_object_check: + def __init__(self): + self.old_is_primitive = _utils.is_primitive_type + + def __enter__(self): + _utils.is_primitive_type = lambda _: True + + def __exit__(self, type, value, traceback): + _utils.is_primitive_type = self.old_is_primitive + + +def convert_namespace_to_omegaconf(args: Namespace) -> DictConfig: + """Convert a flat argparse.Namespace to a structured DictConfig.""" + + # Here we are using field values provided in args to override counterparts inside config object + overrides, deletes = override_module_args(args) + + # configs will be in fairseq/config after installation + config_path = os.path.join("..", "config") + + GlobalHydra.instance().clear() + + with initialize(config_path=config_path): + try: + composed_cfg = compose("config", overrides=overrides, strict=False) + except: + logger.error("Error when composing. Overrides: " + str(overrides)) + raise + + for k in deletes: + composed_cfg[k] = None + + cfg = OmegaConf.create( + OmegaConf.to_container(composed_cfg, resolve=True, enum_to_str=True) + ) + + # hack to be able to set Namespace in dict config. this should be removed when we update to newer + # omegaconf version that supports object flags, or when we migrate all existing models + from omegaconf import _utils + + with omegaconf_no_object_check(): + if cfg.task is None and getattr(args, "task", None): + cfg.task = Namespace(**vars(args)) + from fairseq.tasks import TASK_REGISTRY + + _set_legacy_defaults(cfg.task, TASK_REGISTRY[args.task]) + cfg.task._name = args.task + if cfg.model is None and getattr(args, "arch", None): + cfg.model = Namespace(**vars(args)) + from fairseq.models import ARCH_MODEL_REGISTRY + + _set_legacy_defaults(cfg.model, ARCH_MODEL_REGISTRY[args.arch]) + cfg.model._name = args.arch + if cfg.optimizer is None and getattr(args, "optimizer", None): + cfg.optimizer = Namespace(**vars(args)) + from fairseq.optim import OPTIMIZER_REGISTRY + + _set_legacy_defaults(cfg.optimizer, OPTIMIZER_REGISTRY[args.optimizer]) + cfg.optimizer._name = args.optimizer + if cfg.lr_scheduler is None and getattr(args, "lr_scheduler", None): + cfg.lr_scheduler = Namespace(**vars(args)) + from fairseq.optim.lr_scheduler import LR_SCHEDULER_REGISTRY + + _set_legacy_defaults( + cfg.lr_scheduler, LR_SCHEDULER_REGISTRY[args.lr_scheduler] + ) + cfg.lr_scheduler._name = args.lr_scheduler + if cfg.criterion is None and getattr(args, "criterion", None): + cfg.criterion = Namespace(**vars(args)) + from fairseq.criterions import CRITERION_REGISTRY + + _set_legacy_defaults(cfg.criterion, CRITERION_REGISTRY[args.criterion]) + cfg.criterion._name = args.criterion + + OmegaConf.set_struct(cfg, True) + return cfg + + +def overwrite_args_by_name(cfg: DictConfig, overrides: Dict[str, any]): + # this will be deprecated when we get rid of argparse and model_overrides logic + + from fairseq.registry import REGISTRIES + + with open_dict(cfg): + for k in cfg.keys(): + # "k in cfg" will return false if its a "mandatory value (e.g. ???)" + if k in cfg and isinstance(cfg[k], DictConfig): + if k in overrides and isinstance(overrides[k], dict): + for ok, ov in overrides[k].items(): + if isinstance(ov, dict) and cfg[k][ok] is not None: + overwrite_args_by_name(cfg[k][ok], ov) + else: + cfg[k][ok] = ov + else: + overwrite_args_by_name(cfg[k], overrides) + elif k in cfg and isinstance(cfg[k], Namespace): + for override_key, val in overrides.items(): + setattr(cfg[k], override_key, val) + elif k in overrides: + if ( + k in REGISTRIES + and overrides[k] in REGISTRIES[k]["dataclass_registry"] + ): + cfg[k] = DictConfig( + REGISTRIES[k]["dataclass_registry"][overrides[k]] + ) + overwrite_args_by_name(cfg[k], overrides) + cfg[k]._name = overrides[k] + else: + cfg[k] = overrides[k] + + +def merge_with_parent(dc: FairseqDataclass, cfg: DictConfig, remove_missing=True): + if remove_missing: + + if is_dataclass(dc): + target_keys = set(dc.__dataclass_fields__.keys()) + else: + target_keys = set(dc.keys()) + + with open_dict(cfg): + for k in list(cfg.keys()): + if k not in target_keys: + del cfg[k] + + merged_cfg = OmegaConf.merge(dc, cfg) + merged_cfg.__dict__["_parent"] = cfg.__dict__["_parent"] + OmegaConf.set_struct(merged_cfg, True) + return merged_cfg diff --git a/fairseq/fairseq/distributed/__init__.py b/fairseq/fairseq/distributed/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0b96b734c4b5e7cd5d295238d0764c05093dc27 --- /dev/null +++ b/fairseq/fairseq/distributed/__init__.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .distributed_timeout_wrapper import DistributedTimeoutWrapper +from .fully_sharded_data_parallel import fsdp_enable_wrap, fsdp_wrap, FullyShardedDataParallel +from .legacy_distributed_data_parallel import LegacyDistributedDataParallel +from .module_proxy_wrapper import ModuleProxyWrapper +from .tpu_distributed_data_parallel import TPUDistributedDataParallel + + +__all__ = [ + "DistributedTimeoutWrapper", + "fsdp_enable_wrap", + "fsdp_wrap", + "FullyShardedDataParallel", + "LegacyDistributedDataParallel", + "ModuleProxyWrapper", + "TPUDistributedDataParallel", +] diff --git a/fairseq/fairseq/distributed/distributed_timeout_wrapper.py b/fairseq/fairseq/distributed/distributed_timeout_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..18107ef27ea837b8c72dcaa49db18fd8e64267b1 --- /dev/null +++ b/fairseq/fairseq/distributed/distributed_timeout_wrapper.py @@ -0,0 +1,94 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import signal +import threading + +from torch import nn + + +logger = logging.getLogger(__name__) + + +class DistributedTimeoutWrapper(nn.Module): + """ + A wrapper that kills the process if no progress is made within a given + *timeout*. The timer is reset every time :func:`forward` is called. + + Usage:: + + module = DistributedTimeoutWrapper(module, timeout=30) + x = module(input) + time.sleep(20) # safe + x = module(input) + time.sleep(45) # job will be killed before this returns + + Args: + module (nn.Module): module to wrap + timeout (int): number of seconds before killing the process + (set to a value <= 0 to disable the timeout) + signal (Optional): signal to send once timeout is triggered + """ + def __init__(self, module: nn.Module, timeout: int, signal=signal.SIGINT): + super().__init__() + self.module = module + self.timeout = timeout + self.signal = signal + + if timeout > 0: + self._heartbeat = threading.Event() + self._heartbeat_thread = threading.Thread( + target=self._check_heartbeat, + args=(os.getpid(),), + daemon=True, + ) + self._heartbeat_thread.start() + self._terminated = False + else: + self._heartbeat = None + self._heartbeat_thread = None + + def __del__(self): + self.stop_timeout() + + def __getattr__(self, name): + """Forward missing attributes to wrapped module.""" + try: + return super().__getattr__(name) # defer to nn.Module's logic + except AttributeError: + return getattr(self.module, name) + + def stop_timeout(self): + if self._heartbeat_thread is not None: + self._terminated = True + self._heartbeat_thread.join() + + def state_dict(self, *args, **kwargs): + return self.module.state_dict(*args, **kwargs) + + def load_state_dict(self, *args, **kwargs): + return self.module.load_state_dict(*args, **kwargs) + + def forward(self, *args, **kwargs): + if self._heartbeat is not None: + self._heartbeat.set() + return self.module(*args, **kwargs) + + def _check_heartbeat(self, parent_pid): + self._heartbeat.wait() # wait for the first forward pass + while True: + self._heartbeat.clear() + success = self._heartbeat.wait(timeout=self.timeout) + if self._terminated: + break + elif not success: + logger.error(( + "Killing job for not making progress in {} seconds. " + "Set --heartbeat-timeout=-1 to disable this timeout." + ).format(int(self.timeout))) + os.kill(parent_pid, self.signal) + return diff --git a/fairseq/fairseq/distributed/fully_sharded_data_parallel.py b/fairseq/fairseq/distributed/fully_sharded_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..8a96bfc76516682ac8e2b7e2c3bc2e6aa3d8ef0c --- /dev/null +++ b/fairseq/fairseq/distributed/fully_sharded_data_parallel.py @@ -0,0 +1,135 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +from typing import Optional + +import torch +from fairseq.dataclass.configs import DistributedTrainingConfig +from fairseq.distributed import utils as dist_utils + + +try: + from fairscale.nn.data_parallel import FullyShardedDataParallel as FSDP + + has_FSDP = True +except ImportError: + FSDP = torch.nn.Module + has_FSDP = False + + +class FullyShardedDataParallel(FSDP): + """ + A small wrapper around fairscale's FullyShardedDataParallel (FSDP) with some + fairseq-specific checkpoint saving/loading logic. + + Args: + use_sharded_state (bool): if True, then ``state_dict`` will return + ``FSDP.local_state_dict`` and ``load_state_dict`` will call + ``FSDP.load_local_state_dict``. Otherwise, ``state_dict`` will + return the full model weights on data parallel rank 0 (empty on + other ranks) and ``load_state_dict`` will broadcast model weights + from rank 0 to other ranks. + """ + + def __init__(self, *args, use_sharded_state: bool = False, **kwargs): + if not has_FSDP: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + super().__init__(*args, **kwargs) + self.use_sharded_state = use_sharded_state + + @property + def unwrapped_module(self) -> torch.nn.Module: + if self.flatten_parameters: + return self.module.module + else: + return self.module + + def state_dict(self, destination=None, prefix="", keep_vars=False): + if self.use_sharded_state: + return super().local_state_dict( + destination=destination, prefix=prefix, keep_vars=keep_vars + ) + else: + if self.rank == 0: + return super().state_dict( + destination=destination, prefix=prefix, keep_vars=keep_vars + ) + else: + # We must call state_dict() due to use of communication + # primitives. But we don't use the result. + super().state_dict() + return destination or {} + + def load_state_dict(self, state_dict, strict=True, model_cfg=None): + if self.use_sharded_state: + return super().load_local_state_dict(state_dict, strict=strict) + else: + state_dict = dist_utils.broadcast_object( + state_dict, src_rank=0, group=self.process_group + ) + return super().load_state_dict(state_dict, strict=strict) + + +@contextlib.contextmanager +def fsdp_enable_wrap(cfg: DistributedTrainingConfig): + try: + from fairscale.nn import enable_wrap + except ImportError: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + if cfg.memory_efficient_fp16: + assert cfg.fp16 # memory_efficient_fp16 should imply fp16 + group = dist_utils.get_data_parallel_group() + if group is None and cfg.distributed_world_size == 1: + from fairscale.utils.testing import DummyProcessGroup + + group = DummyProcessGroup(rank=0, size=1) + fsdp_config = { + "process_group": group, + "reshard_after_forward": not cfg.no_reshard_after_forward, + "mixed_precision": cfg.fp16 and not cfg.memory_efficient_fp16, + "fp32_reduce_scatter": cfg.fp32_reduce_scatter, + "flatten_parameters": True, + "cpu_offload": cfg.cpu_offload, + "compute_dtype": torch.float16 if cfg.fp16 else torch.float32, + "bucket_cap_mb": cfg.bucket_cap_mb, + "state_dict_device": torch.device("cpu"), # reduce GPU mem usage + } + with enable_wrap( + wrapper_cls=FullyShardedDataParallel, + use_sharded_state=cfg.use_sharded_state, + **fsdp_config, + ): + yield + + +def fsdp_wrap(module, min_num_params: Optional[int] = None, **kwargs): + """ + Helper to wrap layers/modules in FSDP. This falls back to a no-op if + fairscale is not available. + + Args: + module (nn.Module): module to (maybe) wrap + min_num_params (int, Optional): minimum number of layer params to wrap + """ + try: + from fairscale.nn import wrap + + if min_num_params is not None: + num_params = sum(p.numel() for p in module.parameters()) + if num_params >= min_num_params: + return wrap(module, **kwargs) + else: + return module + else: + return wrap(module, **kwargs) + except ImportError: + return module diff --git a/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py b/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..b031902864d2ffdc31648168b20ccc6c1b8c3dbc --- /dev/null +++ b/fairseq/fairseq/distributed/legacy_distributed_data_parallel.py @@ -0,0 +1,165 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +A modified version of the legacy DistributedDataParallel module that uses c10d +communication primitives. This version is simpler than the latest PyTorch +version and is useful for debugging. Notably it does not overlap gradient +communication with the backward pass, which makes it slower but more robust +than the PyTorch version. + +This version also supports the *no_sync* context manager, which allows faster +training with `--update-freq`. +""" + +from collections import OrderedDict +from contextlib import contextmanager + +import torch +from torch import nn + +from fairseq.distributed import utils + + +class LegacyDistributedDataParallel(nn.Module): + """Implements distributed data parallelism at the module level. + + A simplified version of :class:`torch.nn.parallel.DistributedDataParallel`. + This version uses a c10d process group for communication and does not + broadcast buffers. + + Args: + module (~torch.nn.Module): module to be parallelized + process_group: the c10d process group to be used for distributed data + parallel all-reduction. + buffer_size (int, optional): number of elements to buffer before + performing all-reduce (default: 256M). + """ + + def __init__(self, module, process_group, buffer_size=2 ** 28): + super().__init__() + + self.module = module + self.process_group = process_group + self.world_size = utils.get_world_size(self.process_group) + + # Never use a bigger buffer than the number of model params + self.buffer_size = min(buffer_size, sum(p.numel() for p in module.parameters())) + self.buffer = None + + # We can also forcibly accumulate grads locally and only do the + # all-reduce at some later time + self.accumulate_grads = False + + # make per-device lists of parameters + paramlists = OrderedDict() + for param in self.module.parameters(): + device = param.device + if paramlists.get(device) is None: + paramlists[device] = [] + paramlists[device] += [param] + self.per_device_params = list(paramlists.values()) + + @contextmanager + def no_sync(self): + """A context manager to disable gradient synchronization.""" + old_accumulate_grads = self.accumulate_grads + self.accumulate_grads = True + yield + self.accumulate_grads = old_accumulate_grads + + def forward(self, *inputs, **kwargs): + return self.module(*inputs, **kwargs) + + def all_reduce_grads(self): + """ + This function must be called explicitly after backward to reduce + gradients. There is no automatic hook like c10d. + """ + + def all_reduce_params(params): + buffer = self.buffer + nonzero_buffer = False + if len(params) > 1: + offset = 0 + for p in params: + sz = p.numel() + if p.grad is not None: + buffer[offset : offset + sz].copy_(p.grad.data.reshape(-1)) + nonzero_buffer = True + else: + buffer[offset : offset + sz].zero_() + offset += sz + else: + # we only have a single grad to all-reduce + p = params[0] + if p.grad is not None: + buffer = p.grad.data + nonzero_buffer = True + elif p.numel() <= self.buffer.numel(): + buffer = buffer[: p.numel()] + buffer.zero_() + else: + buffer = torch.zeros_like(p) + + if nonzero_buffer: + buffer.div_(self.world_size) + + utils.all_reduce(buffer, self.process_group) + + # copy all-reduced grads back into their original place + offset = 0 + for p in params: + sz = p.numel() + if p.grad is not None: + p.grad.data.copy_(buffer[offset : offset + sz].view_as(p)) + else: + p.grad = buffer[offset : offset + sz].view_as(p).clone() + offset += sz + + def reduction_fn(): + # This function only needs to be called once + if self.accumulate_grads: + return + + if self.buffer is None: + self.buffer = next(self.module.parameters()).new(self.buffer_size) + + for params in self.per_device_params: + # All-reduce the gradients in buckets + offset = 0 + buffered_params = [] + for param in params: + if not param.requires_grad: + continue + if param.grad is None: + param.grad = torch.zeros_like(param) + + if hasattr(param, 'expert'): + # Skip gradient sync for unshared parameters + continue + + if param.grad.requires_grad: + raise RuntimeError( + "DistributedDataParallel only works " + "with gradients that don't require " + "grad" + ) + sz = param.numel() + if sz > self.buffer.numel(): + # all-reduce big params directly + all_reduce_params([param]) + else: + if offset + sz > self.buffer.numel(): + all_reduce_params(buffered_params) + offset = 0 + buffered_params.clear() + buffered_params.append(param) + offset += sz + + if len(buffered_params) > 0: + all_reduce_params(buffered_params) + + reduction_fn() diff --git a/fairseq/fairseq/distributed/module_proxy_wrapper.py b/fairseq/fairseq/distributed/module_proxy_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..fc2c6f8c718f2ac8ece308e50f7ba74a05474f4a --- /dev/null +++ b/fairseq/fairseq/distributed/module_proxy_wrapper.py @@ -0,0 +1,55 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from torch import nn + + +class ModuleProxyWrapper(nn.Module): + """ + Wrap a DistributedDataParallel module and forward requests for missing + attributes to the module wrapped by DDP (the twice-wrapped module). + Also forward calls to :func:`state_dict` and :func:`load_state_dict`. + + Usage:: + + module.xyz = "hello world" + wrapped_module = DistributedDataParallel(module, **ddp_args) + wrapped_module = ModuleProxyWrapper(wrapped_module) + assert wrapped_module.xyz == "hello world" + assert wrapped_module.state_dict().keys() == module.state_dict().keys() + + Args: + module (nn.Module): module to wrap + """ + + def __init__(self, module: nn.Module): + super().__init__() + assert hasattr(module, "module"), \ + "ModuleProxyWrapper expects input to wrap another module" + self.module = module + + def __getattr__(self, name): + """Forward missing attributes to twice-wrapped module.""" + try: + # defer to nn.Module's logic + return super().__getattr__(name) + except AttributeError: + try: + # forward to the once-wrapped module + return getattr(self.module, name) + except AttributeError: + # forward to the twice-wrapped module + return getattr(self.module.module, name) + + def state_dict(self, *args, **kwargs): + """Forward to the twice-wrapped module.""" + return self.module.module.state_dict(*args, **kwargs) + + def load_state_dict(self, *args, **kwargs): + """Forward to the twice-wrapped module.""" + return self.module.module.load_state_dict(*args, **kwargs) + + def forward(self, *args, **kwargs): + return self.module(*args, **kwargs) diff --git a/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py b/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..e971cf07c57c4e864726781092a690dd4d7d3e46 --- /dev/null +++ b/fairseq/fairseq/distributed/tpu_distributed_data_parallel.py @@ -0,0 +1,43 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import nn + +from fairseq.distributed import utils + + +class TPUDistributedDataParallel(nn.Module): + + def __init__(self, module, process_group): + super().__init__() + self.module = module + self.process_group = process_group + self.world_size = utils.get_world_size(self.process_group) + + def forward(self, *inputs, **kwargs): + return self.module(*inputs, **kwargs) + + def all_reduce_grads(self): + gradients = [] + for p in self.parameters(): + if not p.requires_grad: + continue + if p.grad is None: + p.grad = torch.zeros_like(p) + if p.grad.requires_grad: + raise RuntimeError( + "TPUDistributedDataParallel only works with gradients that don't " + "require grad" + ) + gradients.append(p.grad) + + import torch_xla.core.xla_model as xm + xm.all_reduce( + 'sum', + gradients, + scale=1. / self.world_size, + groups=self.process_group[1], + ) diff --git a/fairseq/fairseq/distributed/utils.py b/fairseq/fairseq/distributed/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..01d9926f27013f8bbf10f0cffc210390cf310cf9 --- /dev/null +++ b/fairseq/fairseq/distributed/utils.py @@ -0,0 +1,848 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import io +import logging +import os +import pickle +import random +import socket +import struct +import subprocess +import warnings +from argparse import Namespace +from collections import OrderedDict +from dataclasses import dataclass +from typing import Any, Dict, List, Mapping, Optional +import sys +import time + +import torch +import torch.distributed as dist +from fairseq.dataclass.configs import DistributedTrainingConfig, FairseqConfig +from omegaconf import open_dict + +try: + import torch_xla.core.xla_model as xm +except ImportError: + xm = None + + +# Flag to indicate if we're using Megatron +# NOTE: this is a temporary hack until we move away from Megatron's model parallel init +_USE_MEGATRON = False + +# Whether to use XLA ops (e.g., on TPUs) instead of CUDA ops. +_USE_XLA = False + + +logger = logging.getLogger(__name__) + + +def is_master(cfg: DistributedTrainingConfig): + return cfg.distributed_rank == 0 + + +def infer_init_method(cfg: DistributedTrainingConfig, force_distributed=False): + if cfg.distributed_init_method is not None or cfg.tpu: + return + + num_pipelines_per_node = None + if cfg.pipeline_model_parallel: + num_pipeline_devices, num_pipelines_per_node = _pipeline_parallel_pre_init(cfg) + + if all( + key in os.environ + for key in ["MASTER_ADDR", "MASTER_PORT", "WORLD_SIZE", "RANK"] + ): + # support torch.distributed.launch + _infer_torch_distributed_launch_init(cfg) + elif cfg.distributed_port > 0: + # we can determine the init method automatically for Slurm + _infer_slurm_init(cfg, num_pipelines_per_node) + elif cfg.distributed_world_size > 1 or force_distributed: + # fallback for single node with multiple GPUs + _infer_single_node_init(cfg) + + if cfg.pipeline_model_parallel: + _pipeline_parallel_post_init(cfg, num_pipeline_devices, num_pipelines_per_node) + elif not cfg.distributed_no_spawn: + with open_dict(cfg): + cfg.distributed_num_procs = min( + torch.cuda.device_count(), cfg.distributed_world_size + ) + + +def _infer_torch_distributed_launch_init(cfg: DistributedTrainingConfig): + cfg.distributed_init_method = "env://" + cfg.distributed_world_size = int(os.environ["WORLD_SIZE"]) + cfg.distributed_rank = int(os.environ["RANK"]) + # processes are created by torch.distributed.launch + cfg.distributed_no_spawn = True + + +def _infer_slurm_init(cfg: DistributedTrainingConfig, num_pipelines_per_node): + node_list = os.environ.get("SLURM_STEP_NODELIST") + if node_list is None: + node_list = os.environ.get("SLURM_JOB_NODELIST") + if node_list is not None: + try: + hostnames = subprocess.check_output( + ["scontrol", "show", "hostnames", node_list] + ) + cfg.distributed_init_method = "tcp://{host}:{port}".format( + host=hostnames.split()[0].decode("utf-8"), + port=cfg.distributed_port, + ) + nnodes = int(os.environ.get("SLURM_NNODES")) + ntasks_per_node = os.environ.get("SLURM_NTASKS_PER_NODE") + if ntasks_per_node is not None: + ntasks_per_node = int(ntasks_per_node) + else: + ntasks = int(os.environ.get("SLURM_NTASKS")) + nnodes = int(os.environ.get("SLURM_NNODES")) + assert ntasks % nnodes == 0 + ntasks_per_node = int(ntasks / nnodes) + if ntasks_per_node == 1: + gpus_per_node = torch.cuda.device_count() + node_id = int(os.environ.get("SLURM_NODEID")) + cfg.distributed_rank = node_id * gpus_per_node + cfg.distributed_world_size = nnodes * gpus_per_node + elif cfg.pipeline_model_parallel: + assert ntasks_per_node == num_pipelines_per_node, ( + "SLURM --ntasks-per-node must match number of pipelines per " + "node (={})".format(num_pipelines_per_node) + ) + cfg.distributed_no_spawn = True + # For 4-way MP on nodes with 8 GPUs, ranks will be [0, 1] on + # the first node, [1, 2] on the second node, etc. This + # matches torch.distributed.launch. + node_id = int(os.environ.get("SLURM_NODEID")) + local_id = int(os.environ.get("SLURM_LOCALID")) + cfg.distributed_rank = node_id * num_pipelines_per_node + local_id + # In the above example, device_id will always be in [0, 1], + # which also matches torch.distributed.launch. + cfg.device_id = local_id + # We also want to set distributed_world_size to be the total + # number of pipelines across all nodes. + cfg.distributed_world_size = nnodes * num_pipelines_per_node + else: + assert ntasks_per_node == cfg.distributed_world_size // nnodes + cfg.distributed_no_spawn = True + cfg.distributed_rank = int(os.environ.get("SLURM_PROCID")) + cfg.device_id = int(os.environ.get("SLURM_LOCALID")) + except subprocess.CalledProcessError as e: # scontrol failed + raise e + except FileNotFoundError: # Slurm is not installed + pass + + +def _infer_single_node_init(cfg: DistributedTrainingConfig): + assert ( + cfg.distributed_world_size <= torch.cuda.device_count() + ), f"world size is {cfg.distributed_world_size} but have {torch.cuda.device_count()} available devices" + port = random.randint(10000, 20000) + cfg.distributed_init_method = "tcp://localhost:{port}".format(port=port) + + +def _pipeline_parallel_pre_init(cfg: DistributedTrainingConfig): + from fairseq import utils + + balance_exists = ( + cfg.pipeline_balance is not None + or cfg.pipeline_encoder_balance is not None + or cfg.pipeline_decoder_balance is not None + ) + devices_exist = ( + cfg.pipeline_devices is not None + or cfg.pipeline_encoder_devices is not None + or cfg.pipeline_decoder_devices is not None + ) + if not balance_exists: + raise ValueError( + "--pipeline-balance is currently required for pipeline model parallelism" + ) + if not devices_exist: + raise ValueError( + "--pipeline-devices is currently required for pipeline model parallelism" + ) + + cfg.pipeline_balance = utils.eval_str_list(cfg.pipeline_balance, type=int) + if cfg.pipeline_devices is not None: + cfg.pipeline_devices = utils.eval_str_list(cfg.pipeline_devices, type=int) + num_pipeline_devices = len(set(cfg.pipeline_devices)) + else: + cfg.pipeline_encoder_devices = utils.eval_str_list( + cfg.pipeline_encoder_devices, type=int + ) + cfg.pipeline_decoder_devices = utils.eval_str_list( + cfg.pipeline_decoder_devices, type=int + ) + num_pipeline_devices = len( + set(cfg.pipeline_encoder_devices + cfg.pipeline_decoder_devices) + ) + gpus_per_node = torch.cuda.device_count() + assert ( + gpus_per_node >= num_pipeline_devices + and gpus_per_node % num_pipeline_devices == 0 + ), ( + "the number of unique device IDs in --pipeline-devices must evenly divide " + "the number of GPUs per node (multi-node pipelining is not yet supported)" + ) + num_pipelines_per_node = gpus_per_node // num_pipeline_devices + return num_pipeline_devices, num_pipelines_per_node + + +def _pipeline_parallel_post_init( + cfg: DistributedTrainingConfig, num_pipeline_devices, num_pipelines_per_node +): + if not cfg.distributed_no_spawn: + # When distributed_no_spawn is False, we expect distributed_rank and + # distributed_world_size to be based on the total number of GPUs, so + # we need to correct them to be based on the number of pipelines. + assert cfg.distributed_world_size % num_pipeline_devices == 0 + cfg.distributed_world_size = ( + cfg.distributed_world_size // num_pipeline_devices + ) + # In the case of 4-way MP on nodes with 8 GPUs, we want + # distributed_rank to be the starting GPU index for each pipeline + # i.e., 0, 2, ... + gpus_per_node = torch.cuda.device_count() + assert cfg.distributed_rank % gpus_per_node == 0 + assert cfg.distributed_rank % num_pipeline_devices == 0 + + with open_dict(cfg): + cfg.distributed_rank = cfg.distributed_rank // num_pipeline_devices + # launch one process per pipeline + cfg.distributed_num_procs = num_pipelines_per_node + + # if we have 4-way MP on a node with 8 GPUs, we want device_ids to be 0 + # and 4, indicating the starting device IDs for each pipeline + cfg.device_id *= num_pipeline_devices + + if cfg.device_id > 0: + # if there's multiple pipelines on a node (e.g., 4-way MP on an 8 + # GPU node), we need to adjust pipeline_devices accordingly + logger.debug( + "setting CUDA device={} on rank {}".format( + cfg.device_id, cfg.distributed_rank + ) + ) + torch.cuda.set_device(cfg.device_id) + with open_dict(cfg): + cfg.pipeline_devices = [cfg.device_id + d for d in cfg.pipeline_devices] + logger.info( + "setting pipeline_devices={} on rank {}".format( + cfg.pipeline_devices, cfg.distributed_rank + ) + ) + + +def distributed_init(cfg: FairseqConfig): + if isinstance(cfg, Namespace): + from fairseq.dataclass.utils import convert_namespace_to_omegaconf + + cfg = convert_namespace_to_omegaconf(cfg) + + if not cfg.common.tpu: + if torch.distributed.is_available() and torch.distributed.is_initialized(): + warnings.warn( + "Distributed is already initialized, cannot initialize twice!" + ) + else: + logger.info( + "distributed init (rank {}): {}, world_size {}, backend: {}".format( + cfg.distributed_training.distributed_rank, + cfg.distributed_training.distributed_init_method, + cfg.distributed_training.distributed_world_size, + cfg.distributed_training.distributed_backend + ) + ) + logger.info('Start init') + max_time_wait = 600 + + torch.cuda.set_device(cfg.distributed_training.device_id) # to fix NCCL error!! + + for i in range(max_time_wait): + try: + dist.init_process_group( + backend=cfg.distributed_training.distributed_backend, + init_method=cfg.distributed_training.distributed_init_method, + world_size=cfg.distributed_training.distributed_world_size, + rank=cfg.distributed_training.distributed_rank, + ) + logger.info( + "initialized host {} as rank {}".format( + socket.gethostname(), + cfg.distributed_training.distributed_rank, + ) + ) + if torch.distributed.is_initialized(): + print("single-machine distributed training is initialized.") + break + except ValueError: + # This is caused by TCPStore failure. + print('Retry: {}, with value error {}'.format( + i + 1, sys.exc_info()[0])) + time.sleep(5) + if i == max_time_wait - 1: + print('k8s resource wait too long time') + exit(-1) + except Exception: + print('Retry: {}, with value error {}'.format( + i + 1, sys.exc_info()[0])) + exit(-1) + # perform a dummy all-reduce to initialize the NCCL communicator + if torch.cuda.is_available(): + dist.all_reduce(torch.zeros(1).cuda()) + + cfg.distributed_training.distributed_rank = torch.distributed.get_rank() + else: + assert xm.xrt_world_size() == cfg.distributed_training.distributed_world_size + global _USE_XLA + _USE_XLA = True + cfg.distributed_training.device_id = xm.get_local_ordinal() + cfg.distributed_training.distributed_rank = xm.get_ordinal() + xm.rendezvous("distributed_init") # wait for all workers + + if is_master(cfg.distributed_training): + logging.getLogger().setLevel(logging.INFO) + else: + logging.getLogger().setLevel(logging.WARNING) + + if cfg.common.model_parallel_size > 1: + try: + from fairseq.model_parallel.megatron.mpu import ( + initialize_model_parallel, + model_parallel_cuda_manual_seed, + ) + except ImportError: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + global _USE_MEGATRON + _USE_MEGATRON = True + initialize_model_parallel(cfg.common.model_parallel_size) + model_parallel_cuda_manual_seed(cfg.common.seed) + model_part_number = get_model_parallel_rank() + cfg.checkpoint.checkpoint_suffix += "-model_part-{0}".format(model_part_number) + + if hasattr(cfg, "model") and getattr(cfg.model, "base_layers", 0) > 0: + cfg.checkpoint.checkpoint_suffix = f"-rank-{cfg.distributed_training.distributed_rank}" + + return cfg.distributed_training.distributed_rank + + +def distributed_main(i, main, cfg: FairseqConfig, kwargs): + # #### + if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ: + # args.rank = int(os.environ["RANK"]) + # args.world_size = int(os.environ['WORLD_SIZE']) + i = int(os.environ['LOCAL_RANK']) + elif 'SLURM_PROCID' in os.environ: + # args.rank = int(os.environ['SLURM_PROCID']) + i = cfg.distributed_training.distributed_rank % torch.cuda.device_count() + # print(args.gpu, os.environ['SLURM_LOCALID'], os.environ['SLURM_JOB_NODELIST'], os.environ['SLURM_STEP_GPUS']) + + + cfg.distributed_training.device_id = i + print('cfg.distributed_training.device_id', cfg.distributed_training.device_id) + print(cfg.distributed_training) + if torch.cuda.is_available() and not cfg.common.cpu and not cfg.common.tpu: + torch.cuda.set_device(cfg.distributed_training.device_id) + if cfg.distributed_training.distributed_rank is None: # torch.multiprocessing.spawn + cfg.distributed_training.distributed_rank = kwargs.pop("start_rank", 0) + i + + cfg.distributed_training.distributed_rank = distributed_init(cfg) + + after_distributed_init_fn = kwargs.pop("after_distributed_init_fn", None) + if after_distributed_init_fn: + cfg = after_distributed_init_fn(cfg) + + main(cfg, **kwargs) + + if torch.distributed.is_initialized(): + torch.distributed.barrier(get_global_group()) + + +def call_main(cfg: FairseqConfig, main, **kwargs): + if cfg.distributed_training.distributed_init_method is None: + infer_init_method(cfg.distributed_training) + + if cfg.distributed_training.distributed_init_method is not None: + # distributed training + if not cfg.distributed_training.distributed_no_spawn: + start_rank = cfg.distributed_training.distributed_rank + cfg.distributed_training.distributed_rank = None # assign automatically + kwargs["start_rank"] = start_rank + torch.multiprocessing.spawn( + fn=distributed_main, + args=(main, cfg, kwargs), + nprocs=min( + torch.cuda.device_count(), + cfg.distributed_training.distributed_world_size, + ), + join=True, + ) + else: + distributed_main(cfg.distributed_training.device_id, main, cfg, kwargs) + elif cfg.common.tpu and cfg.distributed_training.distributed_world_size > 1: + import torch_xla.distributed.xla_multiprocessing as xmp + + torch.multiprocessing.set_sharing_strategy("file_system") + xmp.spawn( + fn=distributed_main, + args=(main, cfg, kwargs), + # tpu-comment: + # 8 devices in one TPU VM, is the max processes to be spawned. + # The rest is driven by xm.distributed.xla_dist + nprocs=min(cfg.distributed_training.distributed_world_size, 8), + ) + else: + # single GPU main + main(cfg, **kwargs) + + +def use_xla(): + global _USE_XLA + return _USE_XLA + + +def new_groups(grouped_ranks: List[List[int]]): + if use_xla(): + return ("tpu", grouped_ranks) + else: + groups = [dist.new_group(g) for g in grouped_ranks] + my_group_idx = _find_my_group_index(grouped_ranks) + return groups[my_group_idx] + + +def _find_my_group_index(grouped_ranks): + my_rank = get_global_rank() + for i, group in enumerate(grouped_ranks): + if my_rank in group: + return i + raise RuntimeError + + +def _find_my_group(grouped_ranks): + index = _find_my_group_index(grouped_ranks) + return grouped_ranks[index] + + +def get_rank(group): + if use_xla(): + assert group[0] == "tpu" + my_group = _find_my_group(group[1]) + return my_group.index(get_global_rank()) + else: + return dist.get_rank(group=group) + + +def get_world_size(group): + if use_xla(): + assert group[0] == "tpu" + my_group = _find_my_group(group[1]) + return len(my_group) + elif torch.distributed.is_initialized(): + return dist.get_world_size(group=group) + else: + return 1 + + +def get_global_group(): + if use_xla(): + return new_groups([list(range(get_global_world_size()))]) + elif torch.distributed.is_initialized(): + if not hasattr(get_global_group, "_global_group"): + # ideally we could use torch.distributed.group.WORLD, but it seems + # to cause random NCCL hangs in some cases + get_global_group._global_group = dist.new_group() + return get_global_group._global_group + else: + return None + + +def get_global_rank(): + if use_xla(): + return xm.get_ordinal() + elif torch.distributed.is_initialized(): + return torch.distributed.get_rank() + else: + return 0 + + +def get_global_world_size(): + if use_xla(): + return xm.xrt_world_size() + elif torch.distributed.is_initialized(): + return torch.distributed.get_world_size() + else: + return 1 + + +def get_data_parallel_group(): + """Get the data parallel group the caller rank belongs to.""" + global _USE_MEGATRON + if _USE_MEGATRON: + from fairseq.model_parallel.megatron import mpu + + return mpu.get_data_parallel_group() + else: + return get_global_group() + + +def get_data_parallel_rank(): + """Return my rank for the data parallel group.""" + return get_rank(get_data_parallel_group()) + + +def get_data_parallel_world_size(): + """Return world size for the data parallel group.""" + return get_world_size(get_data_parallel_group()) + + +def get_model_parallel_group(): + global _USE_MEGATRON + if _USE_MEGATRON: + from fairseq.model_parallel.megatron import mpu + + return mpu.get_model_parallel_group() + else: + return None + + +def get_model_parallel_rank(): + """Return my rank for the model parallel group.""" + return get_rank(get_model_parallel_group()) + + +def get_model_parallel_world_size(): + """Return world size for the model parallel group.""" + return get_world_size(get_model_parallel_group()) + + +def all_reduce(tensor, group, op="sum"): + if use_xla(): + assert isinstance(group, tuple) and group[0] == "tpu" + tensor = [tensor] # wrap in a list to make xm.all_reduce in-place + return xm.all_reduce(op, tensor, groups=group[1])[0] + else: + if op == "sum": + op = dist.ReduceOp.SUM + elif op == "max": + op = dist.ReduceOp.MAX + else: + raise NotImplementedError + dist.all_reduce(tensor, op=op, group=group) + return tensor + + +def broadcast(tensor, src, group): + if use_xla(): + # XLA doesn't support broadcast, hack it with all_reduce + if get_rank(group) != src: + tensor.zero_() + all_reduce(tensor, group) + else: + dist.broadcast(tensor, src=src, group=group) + + +def all_to_all(tensor, group): + """Perform an all-to-all operation on a 1D Tensor.""" + assert tensor.dim() == 1 + split_count = get_world_size(group=group) + assert tensor.numel() % split_count == 0 + if use_xla(): + assert isinstance(group, tuple) and group[0] == "tpu" + return xm.all_to_all( + tensor, + split_dimension=0, + concat_dimension=0, + split_count=split_count, + groups=group[1], + ) + else: + output = torch.zeros_like(tensor) + dist.all_to_all_single(output, tensor, group=group) + return output + + +def all_gather(tensor, group, return_tensor=False): + """Perform an all-gather operation.""" + if use_xla(): + result = xm.all_gather(tensor, groups=group[1]) + world_size = get_world_size(group=group) + result = result.view(world_size, *tensor.size()) + if return_tensor: + return result + else: + return [result[i] for i in range(world_size)] + else: + world_size = get_world_size(group=group) + rank = get_rank(group=group) + tensor_list = [ + tensor if i == rank else torch.empty_like(tensor) for i in range(world_size) + ] + dist.all_gather(tensor_list, tensor, group=group) + if return_tensor: + return torch.stack(tensor_list, dim=0) + else: + return tensor_list + + +def all_gather_list(data, group=None, max_size=16384): + """Gathers arbitrary data from all nodes into a list. + + Similar to :func:`~torch.distributed.all_gather` but for arbitrary Python + data. Note that *data* must be picklable and any CUDA tensors will be moved + to CPU and returned on CPU as well. + + Args: + data (Any): data from the local worker to be gathered on other workers + group: group of the collective + max_size (int, optional): maximum size of the data to be gathered + across workers + """ + from fairseq import utils + + if group is None: + group = get_global_group() + torch.distributed.barrier(group=group) + rank = get_rank(group=group) + world_size = get_world_size(group=group) + + buffer_size = max_size * world_size + if ( + not hasattr(all_gather_list, "_buffer") + or all_gather_list._buffer.numel() < buffer_size + ): + all_gather_list._buffer = torch.cuda.ByteTensor(buffer_size) + all_gather_list._cpu_buffer = torch.ByteTensor(max_size).pin_memory() + buffer = all_gather_list._buffer + buffer.zero_() + cpu_buffer = all_gather_list._cpu_buffer + + data = utils.move_to_cpu(data) + enc = pickle.dumps(data) + enc_size = len(enc) + header_size = 4 # size of header that contains the length of the encoded data + size = header_size + enc_size + if size > max_size: + raise ValueError( + "encoded data size ({}) exceeds max_size ({})".format(size, max_size) + ) + + header = struct.pack(">I", enc_size) + cpu_buffer[:size] = torch.ByteTensor(list(header + enc)) + start = rank * max_size + buffer[start : start + size].copy_(cpu_buffer[:size]) + + all_reduce(buffer, group=group) + + buffer = buffer.cpu() + try: + result = [] + for i in range(world_size): + out_buffer = buffer[i * max_size : (i + 1) * max_size] + (enc_size,) = struct.unpack(">I", bytes(out_buffer[:header_size].tolist())) + if enc_size > 0: + result.append( + pickle.loads( + bytes(out_buffer[header_size : header_size + enc_size].tolist()) + ) + ) + return result + except pickle.UnpicklingError: + raise Exception( + "Unable to unpickle data from other workers. all_gather_list requires all " + "workers to enter the function together, so this error usually indicates " + "that the workers have fallen out of sync somehow. Workers can fall out of " + "sync if one of them runs out of memory, or if there are other conditions " + "in your training script that can cause one worker to finish an epoch " + "while other workers are still iterating over their portions of the data. " + "Try rerunning with --ddp-backend=legacy_ddp and see if that helps." + ) + + +def all_reduce_dict(data: Mapping[str, Any], device, group) -> Dict[str, Any]: + """ + AllReduce a dictionary of values across workers. We separately + reduce items that are already on the device and items on CPU for + better performance. + + Args: + data (Mapping[str, Any]): dictionary of data to all-reduce, but + cannot be a nested dictionary + device (torch.device): device for the reduction + group: group of the collective + """ + data_keys = list(data.keys()) + + # We want to separately reduce items that are already on the + # device and items on CPU for performance reasons. + cpu_data = OrderedDict() + device_data = OrderedDict() + for k in data_keys: + t = data[k] + if not torch.is_tensor(t): + cpu_data[k] = torch.tensor(t, dtype=torch.double) + elif t.device.type != device.type: + cpu_data[k] = t.to(dtype=torch.double) + else: + device_data[k] = t.to(dtype=torch.double) + + def _all_reduce_dict(data: OrderedDict): + if len(data) == 0: + return data + buf = torch.cat([t.view(-1) for t in data.values()]).to(device=device) + all_reduce(buf, group=group) + split_buf = torch.split(buf, [t.numel() for t in data.values()]) + reduced_data = [t.view_as(orig) for t, orig in zip(split_buf, data.values())] + return OrderedDict(zip(data.keys(), reduced_data)) + + cpu_data = _all_reduce_dict(cpu_data) + device_data = _all_reduce_dict(device_data) + + def get_from_stack(key): + if key in cpu_data: + return cpu_data[key] + elif key in device_data: + return device_data[key] + raise KeyError + + return OrderedDict([(key, get_from_stack(key)) for key in data_keys]) + + +def broadcast_tensors( + tensors: Optional[List[torch.Tensor]], + src_rank: int, + group: object, + dist_device: Optional[torch.device] = None, +) -> List[torch.Tensor]: + """ + Broadcasts a list of tensors without other (non-src) ranks needing to know + the dtypes/shapes of the tensors. + """ + if dist_device is None: + if torch.distributed.get_backend(group) == "nccl": + dist_device = torch.device("cuda") + else: + dist_device = torch.device("cpu") + + # share metadata first to simplify transfer + is_src_rank = (get_rank(group) == src_rank) + if is_src_rank: + metadata = [ + {"size": t.size(), "dtype": t.dtype, "device": t.device} for t in tensors + ] + metadata = _broadcast_object_slow(metadata, src_rank, group, dist_device) + else: + metadata = _broadcast_object_slow(None, src_rank, group, dist_device) + + out_tensors = [] + for i, meta in enumerate(metadata): + if is_src_rank: + tensor = tensors[i] + try: + broadcast(tensors[i].to(dist_device), src=src_rank, group=group) #.contiguous() + except: # error for audio experiments + broadcast(tensors[i].to(dist_device).contiguous().cuda(), src=src_rank, group=group) + print("non contiguous tensor, casted to contiguous:", i, tensors[i].shape, dist_device) + else: + tensor = torch.zeros( + [meta["size"].numel()], dtype=meta["dtype"], device=dist_device + ) + broadcast(tensor, src=src_rank, group=group) + tensor = tensor.view(meta["size"]).to(meta["device"]) + out_tensors.append(tensor) + return out_tensors + + +def broadcast_object( + obj: Any, + src_rank: int, + group: object, + dist_device: Optional[torch.device] = None, +) -> Any: + """Broadcast an arbitrary Python object to other workers.""" + if dist_device is None: + if torch.distributed.get_backend(group) == "nccl": + dist_device = torch.device("cuda") + else: + dist_device = torch.device("cpu") + + if get_rank(group) == src_rank: + # split the tensors from the non-tensors so we can broadcast them + # directly, avoiding unnecessary serialization/deserialization + tensors = [] + obj = _split_tensors_from_obj(obj, tensors) + obj = _broadcast_object_slow(obj, src_rank, group, dist_device) + tensors = broadcast_tensors(tensors, src_rank, group, dist_device) + else: + obj = _broadcast_object_slow(None, src_rank, group, dist_device) + tensors = broadcast_tensors(None, src_rank, group, dist_device) + return _put_tensors_in_obj(obj, tensors) + + +def _broadcast_object_slow( + obj: Any, src_rank: int, group: object, dist_device: torch.device, +) -> Any: + if get_rank(group) == src_rank: + # Emit data + buffer = io.BytesIO() + torch.save(obj, buffer) + buffer = torch.ByteTensor(buffer.getbuffer()).to(dist_device) + length = torch.LongTensor([len(buffer)]).to(dist_device) + broadcast(length, src=src_rank, group=group) + broadcast(buffer, src=src_rank, group=group) + else: + # Fetch from the source + length = torch.LongTensor([0]).to(dist_device) + broadcast(length, src=src_rank, group=group) + buffer = torch.ByteTensor(int(length.item())).to(dist_device) + broadcast(buffer, src=src_rank, group=group) + buffer = io.BytesIO(buffer.cpu().numpy()) + obj = torch.load(buffer, map_location="cpu") + return obj + + +@dataclass(frozen=True) +class _TensorPlaceholder: + index: int + + +def _split_tensors_from_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: + if torch.is_tensor(obj): + placeholder = _TensorPlaceholder(index=len(tensors)) + tensors.append(obj) + return placeholder + elif isinstance(obj, dict): + return {k: _split_tensors_from_obj(v, tensors) for k, v in obj.items()} + elif isinstance(obj, list): + return [_split_tensors_from_obj(v, tensors) for v in obj] + elif isinstance(obj, tuple): + return tuple(_split_tensors_from_obj(v, tensors) for v in obj) + elif isinstance(obj, set): + return {_split_tensors_from_obj(v, tensors) for v in obj} + else: + return obj + + +def _put_tensors_in_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: + if isinstance(obj, _TensorPlaceholder): + return tensors[obj.index] + elif isinstance(obj, dict): + return {k: _put_tensors_in_obj(v, tensors) for k, v in obj.items()} + elif isinstance(obj, list): + return [_put_tensors_in_obj(v, tensors) for v in obj] + elif isinstance(obj, tuple): + return tuple(_put_tensors_in_obj(v, tensors) for v in obj) + elif isinstance(obj, set): + return {_put_tensors_in_obj(v, tensors) for v in obj} + else: + return obj diff --git a/fairseq/fairseq/file_chunker_utils.py b/fairseq/fairseq/file_chunker_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..443100c61ab26808d820b7ea2b1307df6475007c --- /dev/null +++ b/fairseq/fairseq/file_chunker_utils.py @@ -0,0 +1,84 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import typing as tp + + +def _safe_readline(fd) -> str: + pos = fd.tell() + while True: + try: + return fd.readline() + except UnicodeDecodeError: + pos -= 1 + fd.seek(pos) # search where this character begins + + +def find_offsets(filename: str, num_chunks: int) -> tp.List[int]: + """ + given a file and a number of chuncks, find the offsets in the file + to be able to chunk around full lines. + """ + with open(filename, "r", encoding="utf-8") as f: + size = os.fstat(f.fileno()).st_size + chunk_size = size // num_chunks + offsets = [0 for _ in range(num_chunks + 1)] + for i in range(1, num_chunks): + f.seek(chunk_size * i) + _safe_readline(f) + offsets[i] = f.tell() + offsets[-1] = size + return offsets + + +class ChunkLineIterator: + """ + Iterator to properly iterate over lines of a file chunck. + """ + + def __init__(self, fd, start_offset: int, end_offset: int): + self._fd = fd + self._start_offset = start_offset + self._end_offset = end_offset + + def __iter__(self) -> tp.Iterable[str]: + self._fd.seek(self._start_offset) + # next(f) breaks f.tell(), hence readline() must be used + line = _safe_readline(self._fd) + while line: + pos = self._fd.tell() + # f.tell() does not always give the byte position in the file + # sometimes it skips to a very large number + # it is unlikely that through a normal read we go from + # end bytes to end + 2**32 bytes (4 GB) and this makes it unlikely + # that the procedure breaks by the undeterministic behavior of + # f.tell() + if ( + self._end_offset > 0 + and pos > self._end_offset + and pos < self._end_offset + 2 ** 32 + ): + break + yield line + line = self._fd.readline() + + +class Chunker: + """ + contextmanager to read a chunck of a file line by line. + """ + + def __init__(self, path: str, start_offset: int, end_offset: int): + self.path = path + self.start_offset = start_offset + self.end_offset = end_offset + + def __enter__(self) -> ChunkLineIterator: + self.fd = open(self.path, "r", encoding="utf-8") + return ChunkLineIterator(self.fd, self.start_offset, self.end_offset) + + def __exit__(self, exc_type, exc_val, exc_tb) -> None: + self.fd.close() diff --git a/fairseq/fairseq/file_io.py b/fairseq/fairseq/file_io.py new file mode 100644 index 0000000000000000000000000000000000000000..dba663d4aafeb925ddffa50f5055933d6531a069 --- /dev/null +++ b/fairseq/fairseq/file_io.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import shutil +from typing import List, Optional + + +logger = logging.getLogger(__file__) + + +try: + from iopath.common.file_io import g_pathmgr as IOPathManager + + try: + # [FB only - for now] AWS PathHandler for PathManager + from .fb_pathhandlers import S3PathHandler + + IOPathManager.register_handler(S3PathHandler()) + except KeyError: + logging.warning("S3PathHandler already registered.") + except ImportError: + logging.debug( + "S3PathHandler couldn't be imported. Either missing fb-only files, or boto3 module." + ) + +except ImportError: + IOPathManager = None + + +class PathManager: + """ + Wrapper for insulating OSS I/O (using Python builtin operations) from + iopath's PathManager abstraction (for transparently handling various + internal backends). + """ + + @staticmethod + def open( + path: str, + mode: str = "r", + buffering: int = -1, + encoding: Optional[str] = None, + errors: Optional[str] = None, + newline: Optional[str] = None, + ): + if IOPathManager: + return IOPathManager.open( + path=path, + mode=mode, + buffering=buffering, + encoding=encoding, + errors=errors, + newline=newline, + ) + return open( + path, + mode=mode, + buffering=buffering, + encoding=encoding, + errors=errors, + newline=newline, + ) + + @staticmethod + def copy(src_path: str, dst_path: str, overwrite: bool = False) -> bool: + if IOPathManager: + return IOPathManager.copy( + src_path=src_path, dst_path=dst_path, overwrite=overwrite + ) + return shutil.copyfile(src_path, dst_path) + + @staticmethod + def get_local_path(path: str, **kwargs) -> str: + if IOPathManager: + return IOPathManager.get_local_path(path, **kwargs) + return path + + @staticmethod + def exists(path: str) -> bool: + if IOPathManager: + return IOPathManager.exists(path) + return os.path.exists(path) + + @staticmethod + def isfile(path: str) -> bool: + if IOPathManager: + return IOPathManager.isfile(path) + return os.path.isfile(path) + + @staticmethod + def ls(path: str) -> List[str]: + if IOPathManager: + return IOPathManager.ls(path) + return os.listdir(path) + + @staticmethod + def mkdirs(path: str) -> None: + if IOPathManager: + return IOPathManager.mkdirs(path) + os.makedirs(path, exist_ok=True) + + @staticmethod + def rm(path: str) -> None: + if IOPathManager: + return IOPathManager.rm(path) + os.remove(path) + + @staticmethod + def chmod(path: str, mode: int) -> None: + if not PathManager.path_requires_pathmanager(path): + os.chmod(path, mode) + + @staticmethod + def register_handler(handler) -> None: + if IOPathManager: + return IOPathManager.register_handler(handler=handler) + + @staticmethod + def copy_from_local( + local_path: str, dst_path: str, overwrite: bool = False, **kwargs + ) -> None: + if IOPathManager: + return IOPathManager.copy_from_local( + local_path=local_path, dst_path=dst_path, overwrite=overwrite, **kwargs + ) + return shutil.copyfile(local_path, dst_path) + + @staticmethod + def path_requires_pathmanager(path: str) -> bool: + """Do we require PathManager to access given path?""" + if IOPathManager: + for p in IOPathManager._path_handlers.keys(): + if path.startswith(p): + return True + return False + + @staticmethod + def supports_rename(path: str) -> bool: + # PathManager doesn't yet support renames + return not PathManager.path_requires_pathmanager(path) + + @staticmethod + def rename(src: str, dst: str): + os.rename(src, dst) + + """ + ioPath async PathManager methods: + """ + @staticmethod + def opena( + path: str, + mode: str = "r", + buffering: int = -1, + encoding: Optional[str] = None, + errors: Optional[str] = None, + newline: Optional[str] = None, + ): + """ + Return file descriptor with asynchronous write operations. + """ + global IOPathManager + if not IOPathManager: + logging.info("ioPath is initializing PathManager.") + try: + from iopath.common.file_io import PathManager + IOPathManager = PathManager() + except Exception: + logging.exception("Failed to initialize ioPath PathManager object.") + return IOPathManager.opena( + path=path, + mode=mode, + buffering=buffering, + encoding=encoding, + errors=errors, + newline=newline, + ) + + @staticmethod + def async_close() -> bool: + """ + Wait for files to be written and clean up asynchronous PathManager. + NOTE: `PathManager.async_close()` must be called at the end of any + script that uses `PathManager.opena(...)`. + """ + global IOPathManager + if IOPathManager: + return IOPathManager.async_close() + return False diff --git a/fairseq/fairseq/file_utils.py b/fairseq/fairseq/file_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d1d5ea65746682881264e4a9c462854dcfb3413f --- /dev/null +++ b/fairseq/fairseq/file_utils.py @@ -0,0 +1,369 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Utilities for working with the local dataset cache. +This file is adapted from `AllenNLP <https://github.com/allenai/allennlp>`_. +and `huggingface <https://github.com/huggingface>`_. +""" + +import fnmatch +import json +import logging +import os +import shutil +import tarfile +import tempfile +from functools import partial, wraps +from hashlib import sha256 +from io import open + + +try: + from torch.hub import _get_torch_home + + torch_cache_home = _get_torch_home() +except ImportError: + torch_cache_home = os.path.expanduser( + os.getenv( + "TORCH_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "torch") + ) + ) +default_cache_path = os.path.join(torch_cache_home, "pytorch_fairseq") + +try: + from urllib.parse import urlparse +except ImportError: + from urlparse import urlparse + +try: + from pathlib import Path + + PYTORCH_FAIRSEQ_CACHE = Path(os.getenv("PYTORCH_FAIRSEQ_CACHE", default_cache_path)) +except (AttributeError, ImportError): + PYTORCH_FAIRSEQ_CACHE = os.getenv("PYTORCH_FAIRSEQ_CACHE", default_cache_path) + +CONFIG_NAME = "config.json" +WEIGHTS_NAME = "pytorch_model.bin" + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def load_archive_file(archive_file): + # redirect to the cache, if necessary + try: + resolved_archive_file = cached_path(archive_file, cache_dir=None) + except EnvironmentError: + logger.info( + "Archive name '{}' was not found in archive name list. " + "We assumed '{}' was a path or URL but couldn't find any file " + "associated to this path or URL.".format( + archive_file, + archive_file, + ) + ) + return None + + if resolved_archive_file == archive_file: + logger.info("loading archive file {}".format(archive_file)) + else: + logger.info( + "loading archive file {} from cache at {}".format( + archive_file, resolved_archive_file + ) + ) + + # Extract archive to temp dir and replace .tar.bz2 if necessary + tempdir = None + if not os.path.isdir(resolved_archive_file): + tempdir = tempfile.mkdtemp() + logger.info( + "extracting archive file {} to temp dir {}".format( + resolved_archive_file, tempdir + ) + ) + ext = os.path.splitext(archive_file)[1][1:] + with tarfile.open(resolved_archive_file, "r:" + ext) as archive: + top_dir = os.path.commonprefix(archive.getnames()) + archive.extractall(tempdir) + os.remove(resolved_archive_file) + shutil.move(os.path.join(tempdir, top_dir), resolved_archive_file) + shutil.rmtree(tempdir) + + return resolved_archive_file + + +def url_to_filename(url, etag=None): + """ + Convert `url` into a hashed filename in a repeatable way. + If `etag` is specified, append its hash to the URL's, delimited + by a period. + """ + url_bytes = url.encode("utf-8") + url_hash = sha256(url_bytes) + filename = url_hash.hexdigest() + + if etag: + etag_bytes = etag.encode("utf-8") + etag_hash = sha256(etag_bytes) + filename += "." + etag_hash.hexdigest() + + return filename + + +def filename_to_url(filename, cache_dir=None): + """ + Return the url and etag (which may be ``None``) stored for `filename`. + Raise ``EnvironmentError`` if `filename` or its stored metadata do not exist. + """ + if cache_dir is None: + cache_dir = PYTORCH_FAIRSEQ_CACHE + if isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + cache_path = os.path.join(cache_dir, filename) + if not os.path.exists(cache_path): + raise EnvironmentError("file {} not found".format(cache_path)) + + meta_path = cache_path + ".json" + if not os.path.exists(meta_path): + raise EnvironmentError("file {} not found".format(meta_path)) + + with open(meta_path, encoding="utf-8") as meta_file: + metadata = json.load(meta_file) + url = metadata["url"] + etag = metadata["etag"] + + return url, etag + + +def cached_path_from_pm(url_or_filename): + """ + Tries to cache the specified URL using PathManager class. + Returns the cached path if success otherwise failure. + """ + try: + from fairseq.file_io import PathManager + local_path = PathManager.get_local_path(url_or_filename) + return local_path + except Exception: + return None + + +def cached_path(url_or_filename, cache_dir=None): + """ + Given something that might be a URL (or might be a local path), + determine which. If it's a URL, download the file and cache it, and + return the path to the cached file. If it's already a local path, + make sure the file exists and then return the path. + """ + if cache_dir is None: + cache_dir = PYTORCH_FAIRSEQ_CACHE + if isinstance(url_or_filename, Path): + url_or_filename = str(url_or_filename) + if isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + parsed = urlparse(url_or_filename) + + if parsed.scheme in ("http", "https", "s3"): + # URL, so get it from the cache (downloading if necessary) + return get_from_cache(url_or_filename, cache_dir) + elif os.path.exists(url_or_filename): + # File, and it exists. + return url_or_filename + elif parsed.scheme == "": + # File, but it doesn't exist. + raise EnvironmentError("file {} not found".format(url_or_filename)) + else: + cached_path = cached_path_from_pm(url_or_filename) + if cached_path: + return cached_path + # Something unknown + raise ValueError( + "unable to parse {} as a URL or as a local path".format(url_or_filename) + ) + + +def split_s3_path(url): + """Split a full s3 path into the bucket name and path.""" + parsed = urlparse(url) + if not parsed.netloc or not parsed.path: + raise ValueError("bad s3 path {}".format(url)) + bucket_name = parsed.netloc + s3_path = parsed.path + # Remove '/' at beginning of path. + if s3_path.startswith("/"): + s3_path = s3_path[1:] + return bucket_name, s3_path + + +def s3_request(func): + """ + Wrapper function for s3 requests in order to create more helpful error + messages. + """ + + @wraps(func) + def wrapper(url, *args, **kwargs): + from botocore.exceptions import ClientError + + try: + return func(url, *args, **kwargs) + except ClientError as exc: + if int(exc.response["Error"]["Code"]) == 404: + raise EnvironmentError("file {} not found".format(url)) + else: + raise + + return wrapper + + +@s3_request +def s3_etag(url): + """Check ETag on S3 object.""" + import boto3 + + s3_resource = boto3.resource("s3") + bucket_name, s3_path = split_s3_path(url) + s3_object = s3_resource.Object(bucket_name, s3_path) + return s3_object.e_tag + + +@s3_request +def s3_get(url, temp_file): + """Pull a file directly from S3.""" + import boto3 + + s3_resource = boto3.resource("s3") + bucket_name, s3_path = split_s3_path(url) + s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file) + + +def request_wrap_timeout(func, url): + import requests + + for attempt, timeout in enumerate([10, 20, 40, 60, 60]): + try: + return func(timeout=timeout) + except requests.exceptions.Timeout as e: + logger.warning( + "Request for %s timed-out (attempt %d). Retrying with a timeout of %d secs", + url, + attempt, + timeout, + exc_info=e, + ) + continue + raise RuntimeError(f"Unable to fetch file {url}") + + +def http_get(url, temp_file): + import requests + from tqdm import tqdm + + req = request_wrap_timeout(partial(requests.get, url, stream=True), url) + content_length = req.headers.get("Content-Length") + total = int(content_length) if content_length is not None else None + progress = tqdm(unit="B", total=total) + for chunk in req.iter_content(chunk_size=1024): + if chunk: # filter out keep-alive new chunks + progress.update(len(chunk)) + temp_file.write(chunk) + progress.close() + + +def get_from_cache(url, cache_dir=None): + """ + Given a URL, look for the corresponding dataset in the local cache. + If it's not there, download it. Then return the path to the cached file. + """ + if cache_dir is None: + cache_dir = PYTORCH_FAIRSEQ_CACHE + if isinstance(cache_dir, Path): + cache_dir = str(cache_dir) + + if not os.path.exists(cache_dir): + os.makedirs(cache_dir) + + # Get eTag to add to filename, if it exists. + if url.startswith("s3://"): + etag = s3_etag(url) + else: + try: + import requests + + response = request_wrap_timeout( + partial(requests.head, url, allow_redirects=True), url + ) + if response.status_code != 200: + etag = None + else: + etag = response.headers.get("ETag") + except RuntimeError: + etag = None + + filename = url_to_filename(url, etag) + + # get cache path to put the file + cache_path = os.path.join(cache_dir, filename) + + # If we don't have a connection (etag is None) and can't identify the file + # try to get the last downloaded one + if not os.path.exists(cache_path) and etag is None: + matching_files = fnmatch.filter(os.listdir(cache_dir), filename + ".*") + matching_files = list(filter(lambda s: not s.endswith(".json"), matching_files)) + if matching_files: + cache_path = os.path.join(cache_dir, matching_files[-1]) + + if not os.path.exists(cache_path): + # Download to temporary file, then copy to cache dir once finished. + # Otherwise you get corrupt cache entries if the download gets interrupted. + with tempfile.NamedTemporaryFile() as temp_file: + logger.info("%s not found in cache, downloading to %s", url, temp_file.name) + + # GET file object + if url.startswith("s3://"): + s3_get(url, temp_file) + else: + http_get(url, temp_file) + + # we are copying the file before closing it, so flush to avoid truncation + temp_file.flush() + # shutil.copyfileobj() starts at the current position, so go to the start + temp_file.seek(0) + + logger.info("copying %s to cache at %s", temp_file.name, cache_path) + with open(cache_path, "wb") as cache_file: + shutil.copyfileobj(temp_file, cache_file) + + logger.info("creating metadata file for %s", cache_path) + meta = {"url": url, "etag": etag} + meta_path = cache_path + ".json" + with open(meta_path, "w") as meta_file: + output_string = json.dumps(meta) + meta_file.write(output_string) + + logger.info("removing temp file %s", temp_file.name) + + return cache_path + + +def read_set_from_file(filename): + """ + Extract a de-duped collection (set) of text from a file. + Expected file format is one item per line. + """ + collection = set() + with open(filename, "r", encoding="utf-8") as file_: + for line in file_: + collection.add(line.rstrip()) + return collection + + +def get_file_extension(path, dot=True, lower=True): + ext = os.path.splitext(path)[1] + ext = ext if dot else ext[1:] + return ext.lower() if lower else ext diff --git a/fairseq/fairseq/hub_utils.py b/fairseq/fairseq/hub_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d74470d2ecba2825221a2efa2ce21a9b698340df --- /dev/null +++ b/fairseq/fairseq/hub_utils.py @@ -0,0 +1,303 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import copy +import logging +import os +from typing import Any, Dict, Iterator, List + +import torch +from fairseq import utils +from fairseq.data import encoders +from omegaconf import open_dict +from torch import nn + + +logger = logging.getLogger(__name__) + + +def from_pretrained( + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + archive_map=None, + **kwargs +): + from fairseq import checkpoint_utils, file_utils + + if archive_map is not None: + if model_name_or_path in archive_map: + model_name_or_path = archive_map[model_name_or_path] + if data_name_or_path is not None and data_name_or_path in archive_map: + data_name_or_path = archive_map[data_name_or_path] + + # allow archive_map to set default arg_overrides (e.g., tokenizer, bpe) + # for each model + if isinstance(model_name_or_path, dict): + for k, v in model_name_or_path.items(): + if k == "checkpoint_file": + checkpoint_file = v + elif ( + k != "path" + # only set kwargs that don't already have overrides + and k not in kwargs + ): + kwargs[k] = v + model_name_or_path = model_name_or_path["path"] + + model_path = file_utils.load_archive_file(model_name_or_path) + + # convenience hack for loading data and BPE codes from model archive + if data_name_or_path.startswith("."): + kwargs["data"] = os.path.abspath(os.path.join(model_path, data_name_or_path)) + else: + kwargs["data"] = file_utils.load_archive_file(data_name_or_path) + for file, arg in { + "code": "bpe_codes", + "bpecodes": "bpe_codes", + "sentencepiece.bpe.model": "sentencepiece_model", + "merges.txt": "bpe_merges", + "vocab.json": "bpe_vocab", + }.items(): + path = os.path.join(model_path, file) + if os.path.exists(path): + kwargs[arg] = path + + if "user_dir" in kwargs: + utils.import_user_module(argparse.Namespace(user_dir=kwargs["user_dir"])) + + models, args, task = checkpoint_utils.load_model_ensemble_and_task( + [os.path.join(model_path, cpt) for cpt in checkpoint_file.split(os.pathsep)], + arg_overrides=kwargs, + ) + + return { + "args": args, + "task": task, + "models": models, + } + + +class GeneratorHubInterface(nn.Module): + """ + PyTorch Hub interface for generating sequences from a pre-trained + translation or language model. + """ + + def __init__(self, cfg, task, models): + super().__init__() + self.cfg = cfg + self.task = task + self.models = nn.ModuleList(models) + self.src_dict = task.source_dictionary + self.tgt_dict = task.target_dictionary + + # optimize model for generation + for model in self.models: + model.prepare_for_inference_(cfg) + + # Load alignment dictionary for unknown word replacement + # (None if no unknown word replacement, empty if no path to align dictionary) + self.align_dict = utils.load_align_dict(cfg.generation.replace_unk) + + self.tokenizer = encoders.build_tokenizer(cfg.tokenizer) + self.bpe = encoders.build_bpe(cfg.bpe) + + self.max_positions = utils.resolve_max_positions( + self.task.max_positions(), *[model.max_positions() for model in models] + ) + + # this is useful for determining the device + self.register_buffer("_float_tensor", torch.tensor([0], dtype=torch.float)) + + @property + def device(self): + return self._float_tensor.device + + def translate( + self, sentences: List[str], beam: int = 5, verbose: bool = False, **kwargs + ) -> List[str]: + return self.sample(sentences, beam, verbose, **kwargs) + + def sample( + self, sentences: List[str], beam: int = 1, verbose: bool = False, **kwargs + ) -> List[str]: + if isinstance(sentences, str): + return self.sample([sentences], beam=beam, verbose=verbose, **kwargs)[0] + tokenized_sentences = [self.encode(sentence) for sentence in sentences] + batched_hypos = self.generate(tokenized_sentences, beam, verbose, **kwargs) + return [self.decode(hypos[0]["tokens"]) for hypos in batched_hypos] + + def score(self, sentences: List[str], **kwargs): + if isinstance(sentences, str): + return self.score([sentences], **kwargs)[0] + # NOTE: this doesn't support translation tasks currently + tokenized_sentences = [self.encode(sentence) for sentence in sentences] + return [ + hypos[0] + for hypos in self.generate( + tokenized_sentences, score_reference=True, **kwargs + ) + ] + + def generate( + self, + tokenized_sentences: List[torch.LongTensor], + beam: int = 5, + verbose: bool = False, + skip_invalid_size_inputs=False, + inference_step_args=None, + prefix_allowed_tokens_fn=None, + **kwargs + ) -> List[List[Dict[str, torch.Tensor]]]: + if torch.is_tensor(tokenized_sentences) and tokenized_sentences.dim() == 1: + return self.generate( + tokenized_sentences.unsqueeze(0), beam=beam, verbose=verbose, **kwargs + )[0] + + # build generator using current args as well as any kwargs + gen_args = copy.deepcopy(self.cfg.generation) + with open_dict(gen_args): + gen_args.beam = beam + for k, v in kwargs.items(): + setattr(gen_args, k, v) + generator = self.task.build_generator( + self.models, + gen_args, + prefix_allowed_tokens_fn=prefix_allowed_tokens_fn, + ) + + inference_step_args = inference_step_args or {} + results = [] + for batch in self._build_batches(tokenized_sentences, skip_invalid_size_inputs): + batch = utils.apply_to_sample(lambda t: t.to(self.device), batch) + translations = self.task.inference_step( + generator, self.models, batch, **inference_step_args + ) + for id, hypos in zip(batch["id"].tolist(), translations): + results.append((id, hypos)) + + # sort output to match input order + outputs = [hypos for _, hypos in sorted(results, key=lambda x: x[0])] + + if verbose: + + def getarg(name, default): + return getattr(gen_args, name, getattr(self.cfg, name, default)) + + for source_tokens, target_hypotheses in zip(tokenized_sentences, outputs): + src_str_with_unk = self.string(source_tokens) + logger.info("S\t{}".format(src_str_with_unk)) + for hypo in target_hypotheses: + hypo_str = self.decode(hypo["tokens"]) + logger.info("H\t{}\t{}".format(hypo["score"], hypo_str)) + logger.info( + "P\t{}".format( + " ".join( + map( + lambda x: "{:.4f}".format(x), + hypo["positional_scores"].tolist(), + ) + ) + ) + ) + if hypo["alignment"] is not None and getarg( + "print_alignment", False + ): + logger.info( + "A\t{}".format( + " ".join( + [ + "{}-{}".format(src_idx, tgt_idx) + for src_idx, tgt_idx in hypo["alignment"] + ] + ) + ) + ) + return outputs + + def encode(self, sentence: str) -> torch.LongTensor: + sentence = self.tokenize(sentence) + sentence = self.apply_bpe(sentence) + return self.binarize(sentence) + + def decode(self, tokens: torch.LongTensor) -> str: + sentence = self.string(tokens) + sentence = self.remove_bpe(sentence) + return self.detokenize(sentence) + + def tokenize(self, sentence: str) -> str: + if self.tokenizer is not None: + sentence = self.tokenizer.encode(sentence) + return sentence + + def detokenize(self, sentence: str) -> str: + if self.tokenizer is not None: + sentence = self.tokenizer.decode(sentence) + return sentence + + def apply_bpe(self, sentence: str) -> str: + if self.bpe is not None: + sentence = self.bpe.encode(sentence) + return sentence + + def remove_bpe(self, sentence: str) -> str: + if self.bpe is not None: + sentence = self.bpe.decode(sentence) + return sentence + + def binarize(self, sentence: str) -> torch.LongTensor: + return self.src_dict.encode_line(sentence, add_if_not_exist=False).long() + + def string(self, tokens: torch.LongTensor) -> str: + return self.tgt_dict.string(tokens) + + def _build_batches( + self, tokens: List[List[int]], skip_invalid_size_inputs: bool + ) -> Iterator[Dict[str, Any]]: + lengths = torch.LongTensor([t.numel() for t in tokens]) + batch_iterator = self.task.get_batch_iterator( + dataset=self.task.build_dataset_for_inference(tokens, lengths), + max_tokens=self.cfg.dataset.max_tokens, + max_sentences=self.cfg.dataset.batch_size, + max_positions=self.max_positions, + ignore_invalid_inputs=skip_invalid_size_inputs, + disable_iterator_cache=True, + ).next_epoch_itr(shuffle=False) + return batch_iterator + + +class BPEHubInterface(object): + """PyTorch Hub interface for Byte-Pair Encoding (BPE).""" + + def __init__(self, bpe, **kwargs): + super().__init__() + args = argparse.Namespace(bpe=bpe, **kwargs) + self.bpe = encoders.build_bpe(args) + assert self.bpe is not None + + def encode(self, sentence: str) -> str: + return self.bpe.encode(sentence) + + def decode(self, sentence: str) -> str: + return self.bpe.decode(sentence) + + +class TokenizerHubInterface(object): + """PyTorch Hub interface for tokenization.""" + + def __init__(self, tokenizer, **kwargs): + super().__init__() + args = argparse.Namespace(tokenizer=tokenizer, **kwargs) + self.tokenizer = encoders.build_tokenizer(args) + assert self.tokenizer is not None + + def encode(self, sentence: str) -> str: + return self.tokenizer.encode(sentence) + + def decode(self, sentence: str) -> str: + return self.tokenizer.decode(sentence) diff --git a/fairseq/fairseq/incremental_decoding_utils.py b/fairseq/fairseq/incremental_decoding_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b26e6cd01cd4cbdffa23d88b354eb4a55a94189b --- /dev/null +++ b/fairseq/fairseq/incremental_decoding_utils.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import uuid +from typing import Dict, Optional + +from torch import Tensor + + +class FairseqIncrementalState(object): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.init_incremental_state() + + def init_incremental_state(self): + self._incremental_state_id = str(uuid.uuid4()) + + def _get_full_incremental_state_key(self, key: str) -> str: + return "{}.{}".format(self._incremental_state_id, key) + + def get_incremental_state( + self, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + key: str, + ) -> Optional[Dict[str, Optional[Tensor]]]: + """Helper for getting incremental state for an nn.Module.""" + full_key = self._get_full_incremental_state_key(key) + if incremental_state is None or full_key not in incremental_state: + return None + return incremental_state[full_key] + + def set_incremental_state( + self, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + key: str, + value: Dict[str, Optional[Tensor]], + ) -> Optional[Dict[str, Dict[str, Optional[Tensor]]]]: + """Helper for setting incremental state for an nn.Module.""" + if incremental_state is not None: + full_key = self._get_full_incremental_state_key(key) + incremental_state[full_key] = value + return incremental_state + + +def with_incremental_state(cls): + cls.__bases__ = (FairseqIncrementalState,) + tuple( + b for b in cls.__bases__ if b != FairseqIncrementalState + ) + return cls diff --git a/fairseq/fairseq/iterative_refinement_generator.py b/fairseq/fairseq/iterative_refinement_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..4fb0946f499329ceb130761b59675d761df1c158 --- /dev/null +++ b/fairseq/fairseq/iterative_refinement_generator.py @@ -0,0 +1,359 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import namedtuple + +import numpy as np +import torch +from fairseq import utils + + +DecoderOut = namedtuple( + "IterativeRefinementDecoderOut", + ["output_tokens", "output_scores", "attn", "step", "max_step", "history"], +) + + +class IterativeRefinementGenerator(object): + def __init__( + self, + tgt_dict, + models=None, + eos_penalty=0.0, + max_iter=10, + max_ratio=2, + beam_size=1, + decoding_format=None, + retain_dropout=False, + adaptive=True, + retain_history=False, + reranking=False, + ): + """ + Generates translations based on iterative refinement. + + Args: + tgt_dict: target dictionary + eos_penalty: if > 0.0, it penalized early-stopping in decoding + max_iter: maximum number of refinement iterations + max_ratio: generate sequences of maximum length ax, where x is the source length + decoding_format: decoding mode in {'unigram', 'ensemble', 'vote', 'dp', 'bs'} + retain_dropout: retaining dropout in the inference + adaptive: decoding with early stop + """ + self.bos = tgt_dict.bos() + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.eos = tgt_dict.eos() + self.vocab_size = len(tgt_dict) + self.eos_penalty = eos_penalty + self.max_iter = max_iter + self.max_ratio = max_ratio + self.beam_size = beam_size + self.reranking = reranking + self.decoding_format = decoding_format + self.retain_dropout = retain_dropout + self.retain_history = retain_history + self.adaptive = adaptive + self.models = models + + def generate_batched_itr( + self, + data_itr, + maxlen_a=None, + maxlen_b=None, + cuda=False, + timer=None, + prefix_size=0, + ): + """Iterate over a batched dataset and yield individual translations. + + Args: + maxlen_a/b: generate sequences of maximum length ax + b, + where x is the source sentence length. + cuda: use GPU for generation + timer: StopwatchMeter for timing generations. + """ + + for sample in data_itr: + if "net_input" not in sample: + continue + if timer is not None: + timer.start() + with torch.no_grad(): + hypos = self.generate( + self.models, + sample, + prefix_tokens=sample["target"][:, :prefix_size] + if prefix_size > 0 + else None, + ) + if timer is not None: + timer.stop(sample["ntokens"]) + for i, id in enumerate(sample["id"]): + # remove padding + src = utils.strip_pad(sample["net_input"]["src_tokens"][i, :], self.pad) + ref = utils.strip_pad(sample["target"][i, :], self.pad) + yield id, src, ref, hypos[i] + + @torch.no_grad() + def generate(self, models, sample, prefix_tokens=None, constraints=None): + if constraints is not None: + raise NotImplementedError( + "Constrained decoding with the IterativeRefinementGenerator is not supported" + ) + + # TODO: iterative refinement generator does not support ensemble for now. + if not self.retain_dropout: + for model in models: + model.eval() + + model, reranker = models[0], None + if self.reranking: + assert len(models) > 1, "Assuming the last checkpoint is the reranker" + assert ( + self.beam_size > 1 + ), "Reranking requires multiple translation for each example" + + reranker = models[-1] + models = models[:-1] + + if len(models) > 1 and hasattr(model, "enable_ensemble"): + assert model.allow_ensemble, "{} does not support ensembling".format( + model.__class__.__name__ + ) + model.enable_ensemble(models) + + # TODO: better encoder inputs? + src_tokens = sample["net_input"]["src_tokens"] + src_lengths = sample["net_input"]["src_lengths"] + bsz, src_len = src_tokens.size() + + # initialize + encoder_out = model.forward_encoder([src_tokens, src_lengths]) + prev_decoder_out = model.initialize_output_tokens(encoder_out, src_tokens) + + if self.beam_size > 1: + assert ( + model.allow_length_beam + ), "{} does not support decoding with length beam.".format( + model.__class__.__name__ + ) + + # regenerate data based on length-beam + length_beam_order = ( + utils.new_arange(src_tokens, self.beam_size, bsz).t().reshape(-1) + ) + encoder_out = model.encoder.reorder_encoder_out( + encoder_out, length_beam_order + ) + prev_decoder_out = model.regenerate_length_beam( + prev_decoder_out, self.beam_size + ) + bsz = bsz * self.beam_size + + sent_idxs = torch.arange(bsz) + prev_output_tokens = prev_decoder_out.output_tokens.clone() + + if self.retain_history: + prev_decoder_out = prev_decoder_out._replace(history=[prev_output_tokens]) + + finalized = [[] for _ in range(bsz)] + + def is_a_loop(x, y, s, a): + b, l_x, l_y = x.size(0), x.size(1), y.size(1) + if l_x > l_y: + y = torch.cat([y, x.new_zeros(b, l_x - l_y).fill_(self.pad)], 1) + s = torch.cat([s, s.new_zeros(b, l_x - l_y)], 1) + if a is not None: + a = torch.cat([a, a.new_zeros(b, l_x - l_y, a.size(2))], 1) + elif l_x < l_y: + x = torch.cat([x, y.new_zeros(b, l_y - l_x).fill_(self.pad)], 1) + return (x == y).all(1), y, s, a + + def finalized_hypos(step, prev_out_token, prev_out_score, prev_out_attn): + cutoff = prev_out_token.ne(self.pad) + tokens = prev_out_token[cutoff] + if prev_out_score is None: + scores, score = None, None + else: + scores = prev_out_score[cutoff] + score = scores.mean() + + if prev_out_attn is None: + hypo_attn, alignment = None, None + else: + hypo_attn = prev_out_attn[cutoff] + alignment = hypo_attn.max(dim=1)[1] + return { + "steps": step, + "tokens": tokens, + "positional_scores": scores, + "score": score, + "hypo_attn": hypo_attn, + "alignment": alignment, + } + + for step in range(self.max_iter + 1): + + decoder_options = { + "eos_penalty": self.eos_penalty, + "max_ratio": self.max_ratio, + "decoding_format": self.decoding_format, + } + prev_decoder_out = prev_decoder_out._replace( + step=step, + max_step=self.max_iter + 1, + ) + + decoder_out = model.forward_decoder( + prev_decoder_out, encoder_out, **decoder_options + ) + + if self.adaptive: + # terminate if there is a loop + terminated, out_tokens, out_scores, out_attn = is_a_loop( + prev_output_tokens, + decoder_out.output_tokens, + decoder_out.output_scores, + decoder_out.attn, + ) + decoder_out = decoder_out._replace( + output_tokens=out_tokens, + output_scores=out_scores, + attn=out_attn, + ) + + else: + terminated = decoder_out.output_tokens.new_zeros( + decoder_out.output_tokens.size(0) + ).bool() + + if step == self.max_iter: # reach last iteration, terminate + terminated.fill_(1) + + # collect finalized sentences + finalized_idxs = sent_idxs[terminated] + finalized_tokens = decoder_out.output_tokens[terminated] + finalized_scores = decoder_out.output_scores[terminated] + finalized_attn = ( + None + if (decoder_out.attn is None or decoder_out.attn.size(0) == 0) + else decoder_out.attn[terminated] + ) + + if self.retain_history: + finalized_history_tokens = [h[terminated] for h in decoder_out.history] + + for i in range(finalized_idxs.size(0)): + finalized[finalized_idxs[i]] = [ + finalized_hypos( + step, + finalized_tokens[i], + finalized_scores[i], + None if finalized_attn is None else finalized_attn[i], + ) + ] + + if self.retain_history: + finalized[finalized_idxs[i]][0]["history"] = [] + for j in range(len(finalized_history_tokens)): + finalized[finalized_idxs[i]][0]["history"].append( + finalized_hypos( + step, finalized_history_tokens[j][i], None, None + ) + ) + + # check if all terminated + if terminated.sum() == terminated.size(0): + break + + # for next step + not_terminated = ~terminated + prev_decoder_out = decoder_out._replace( + output_tokens=decoder_out.output_tokens[not_terminated], + output_scores=decoder_out.output_scores[not_terminated], + attn=decoder_out.attn[not_terminated] + if (decoder_out.attn is not None and decoder_out.attn.size(0) > 0) + else None, + history=[h[not_terminated] for h in decoder_out.history] + if decoder_out.history is not None + else None, + ) + encoder_out = model.encoder.reorder_encoder_out( + encoder_out, not_terminated.nonzero(as_tuple=False).squeeze() + ) + sent_idxs = sent_idxs[not_terminated] + prev_output_tokens = prev_decoder_out.output_tokens.clone() + + if self.beam_size > 1: + if reranker is not None: + finalized = self.rerank( + reranker, finalized, [src_tokens, src_lengths], self.beam_size + ) + + # aggregate information from length beam + finalized = [ + finalized[ + np.argmax( + [ + finalized[self.beam_size * i + j][0]["score"] + for j in range(self.beam_size) + ] + ) + + self.beam_size * i + ] + for i in range(len(finalized) // self.beam_size) + ] + + return finalized + + def rerank(self, reranker, finalized, encoder_input, beam_size): + def rebuild_batch(finalized): + finalized_tokens = [f[0]["tokens"] for f in finalized] + finalized_maxlen = max(f.size(0) for f in finalized_tokens) + final_output_tokens = ( + finalized_tokens[0] + .new_zeros(len(finalized_tokens), finalized_maxlen) + .fill_(self.pad) + ) + for i, f in enumerate(finalized_tokens): + final_output_tokens[i, : f.size(0)] = f + return final_output_tokens + + final_output_tokens = rebuild_batch(finalized) + final_output_tokens[ + :, 0 + ] = self.eos # autoregressive model assumes starting with EOS + + reranker_encoder_out = reranker.encoder(*encoder_input) + length_beam_order = ( + utils.new_arange( + final_output_tokens, beam_size, reranker_encoder_out.encoder_out.size(1) + ) + .t() + .reshape(-1) + ) + reranker_encoder_out = reranker.encoder.reorder_encoder_out( + reranker_encoder_out, length_beam_order + ) + reranking_scores = reranker.get_normalized_probs( + reranker.decoder(final_output_tokens[:, :-1], reranker_encoder_out), + True, + None, + ) + reranking_scores = reranking_scores.gather(2, final_output_tokens[:, 1:, None]) + reranking_masks = final_output_tokens[:, 1:].ne(self.pad) + reranking_scores = ( + reranking_scores[:, :, 0].masked_fill_(~reranking_masks, 0).sum(1) + ) + reranking_scores = reranking_scores / reranking_masks.sum(1).type_as( + reranking_scores + ) + + for i in range(len(finalized)): + finalized[i][0]["score"] = reranking_scores[i] + + return finalized diff --git a/fairseq/fairseq/logging/__init__.py b/fairseq/fairseq/logging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/fairseq/logging/meters.py b/fairseq/fairseq/logging/meters.py new file mode 100644 index 0000000000000000000000000000000000000000..2100b1fa0b2704b1c585f59e9349655bba0cc9e6 --- /dev/null +++ b/fairseq/fairseq/logging/meters.py @@ -0,0 +1,323 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import bisect +import time +from collections import OrderedDict +from typing import Dict, Optional + + +try: + import torch + + def type_as(a, b): + if torch.is_tensor(a) and torch.is_tensor(b): + return a.to(b) + else: + return a + + +except ImportError: + torch = None + + def type_as(a, b): + return a + + +try: + import numpy as np +except ImportError: + np = None + + +class Meter(object): + """Base class for Meters.""" + + def __init__(self): + pass + + def state_dict(self): + return {} + + def load_state_dict(self, state_dict): + pass + + def reset(self): + raise NotImplementedError + + @property + def smoothed_value(self) -> float: + """Smoothed value used for logging.""" + raise NotImplementedError + + +def safe_round(number, ndigits): + if hasattr(number, "__round__"): + return round(number, ndigits) + elif torch is not None and torch.is_tensor(number) and number.numel() == 1: + return safe_round(number.item(), ndigits) + elif np is not None and np.ndim(number) == 0 and hasattr(number, "item"): + return safe_round(number.item(), ndigits) + else: + return number + + +class AverageMeter(Meter): + """Computes and stores the average and current value""" + + def __init__(self, round: Optional[int] = None): + self.round = round + self.reset() + + def reset(self): + self.val = None # most recent update + self.sum = 0 # sum from all updates + self.count = 0 # total n from all updates + + def update(self, val, n=1): + if val is not None: + self.val = val + if n > 0: + self.sum = type_as(self.sum, val) + (val * n) + self.count = type_as(self.count, n) + n + + def state_dict(self): + return { + "val": self.val, + "sum": self.sum, + "count": self.count, + "round": self.round, + } + + def load_state_dict(self, state_dict): + self.val = state_dict["val"] + self.sum = state_dict["sum"] + self.count = state_dict["count"] + self.round = state_dict.get("round", None) + + @property + def avg(self): + return self.sum / self.count if self.count > 0 else self.val + + @property + def smoothed_value(self) -> float: + val = self.avg + if self.round is not None and val is not None: + val = safe_round(val, self.round) + return val + + +class SumMeter(Meter): + """Computes and stores the sum""" + + def __init__(self, round: Optional[int] = None): + self.round = round + self.reset() + + def reset(self): + self.sum = 0 # sum from all updates + + def update(self, val): + if val is not None: + self.sum = type_as(self.sum, val) + val + + def state_dict(self): + return { + "sum": self.sum, + "round": self.round, + } + + def load_state_dict(self, state_dict): + self.sum = state_dict["sum"] + self.round = state_dict.get("round", None) + + @property + def smoothed_value(self) -> float: + val = self.sum + if self.round is not None and val is not None: + val = safe_round(val, self.round) + return val + + +class TimeMeter(Meter): + """Computes the average occurrence of some event per second""" + + def __init__( + self, + init: int = 0, + n: int = 0, + round: Optional[int] = None, + ): + self.round = round + self.reset(init, n) + + def reset(self, init=0, n=0): + self.init = init + self.start = time.perf_counter() + self.n = n + self.i = 0 + + def update(self, val=1): + self.n = type_as(self.n, val) + val + self.i += 1 + + def state_dict(self): + return { + "init": self.elapsed_time, + "n": self.n, + "round": self.round, + } + + def load_state_dict(self, state_dict): + if "start" in state_dict: + # backwards compatibility for old state_dicts + self.reset(init=state_dict["init"]) + else: + self.reset(init=state_dict["init"], n=state_dict["n"]) + self.round = state_dict.get("round", None) + + @property + def avg(self): + return self.n / self.elapsed_time + + @property + def elapsed_time(self): + return self.init + (time.perf_counter() - self.start) + + @property + def smoothed_value(self) -> float: + val = self.avg + if self.round is not None and val is not None: + val = safe_round(val, self.round) + return val + + +class StopwatchMeter(Meter): + """Computes the sum/avg duration of some event in seconds""" + + def __init__(self, round: Optional[int] = None): + self.round = round + self.sum = 0 + self.n = 0 + self.start_time = None + + def start(self): + self.start_time = time.perf_counter() + + def stop(self, n=1, prehook=None): + if self.start_time is not None: + if prehook is not None: + prehook() + delta = time.perf_counter() - self.start_time + self.sum = self.sum + delta + self.n = type_as(self.n, n) + n + + def reset(self): + self.sum = 0 # cumulative time during which stopwatch was active + self.n = 0 # total n across all start/stop + self.start() + + def state_dict(self): + return { + "sum": self.sum, + "n": self.n, + "round": self.round, + } + + def load_state_dict(self, state_dict): + self.sum = state_dict["sum"] + self.n = state_dict["n"] + self.start_time = None + self.round = state_dict.get("round", None) + + @property + def avg(self): + return self.sum / self.n if self.n > 0 else self.sum + + @property + def elapsed_time(self): + if self.start_time is None: + return 0.0 + return time.perf_counter() - self.start_time + + @property + def smoothed_value(self) -> float: + val = self.avg if self.sum > 0 else self.elapsed_time + if self.round is not None and val is not None: + val = safe_round(val, self.round) + return val + + +class MetersDict(OrderedDict): + """A sorted dictionary of :class:`Meters`. + + Meters are sorted according to a priority that is given when the + meter is first added to the dictionary. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.priorities = [] + + def __setitem__(self, key, value): + assert key not in self, "MetersDict doesn't support reassignment" + priority, value = value + bisect.insort(self.priorities, (priority, len(self.priorities), key)) + super().__setitem__(key, value) + for _, _, key in self.priorities: # reorder dict to match priorities + self.move_to_end(key) + + def add_meter(self, key, meter, priority): + self.__setitem__(key, (priority, meter)) + + def state_dict(self): + return [ + (pri, key, self[key].__class__.__name__, self[key].state_dict()) + for pri, _, key in self.priorities + # can't serialize DerivedMeter instances + if not isinstance(self[key], MetersDict._DerivedMeter) + ] + + def load_state_dict(self, state_dict): + self.clear() + self.priorities.clear() + for pri, key, meter_cls, meter_state in state_dict: + meter = globals()[meter_cls]() + meter.load_state_dict(meter_state) + self.add_meter(key, meter, pri) + + def get_smoothed_value(self, key: str) -> float: + """Get a single smoothed value.""" + meter = self[key] + if isinstance(meter, MetersDict._DerivedMeter): + return meter.fn(self) + else: + return meter.smoothed_value + + def get_smoothed_values(self) -> Dict[str, float]: + """Get all smoothed values.""" + return OrderedDict( + [ + (key, self.get_smoothed_value(key)) + for key in self.keys() + if not key.startswith("_") + ] + ) + + def reset(self): + """Reset Meter instances.""" + for meter in self.values(): + if isinstance(meter, MetersDict._DerivedMeter): + continue + meter.reset() + + class _DerivedMeter(Meter): + """A Meter whose values are derived from other Meters.""" + + def __init__(self, fn): + self.fn = fn + + def reset(self): + pass diff --git a/fairseq/fairseq/logging/metrics.py b/fairseq/fairseq/logging/metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..58c2fb64e186ed9d5e9a06c73194d98a21bb7560 --- /dev/null +++ b/fairseq/fairseq/logging/metrics.py @@ -0,0 +1,314 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +A standalone module for aggregating metrics. + +Metrics can be logged from anywhere using the `log_*` functions defined +in this module. The logged values will be aggregated dynamically based +on the aggregation context in which the logging occurs. See the +:func:`aggregate` context manager for more details. +""" + +import contextlib +import uuid +from collections import defaultdict +from typing import Callable, List, Optional + +from .meters import * + + +# Aggregation contexts are considered "active" when inside the scope +# created by the :func:`aggregate` context manager. +_aggregators = OrderedDict() +_active_aggregators = OrderedDict() +_active_aggregators_cnt = defaultdict(lambda: 0) + + +def reset() -> None: + """Reset all metrics aggregators.""" + _aggregators.clear() + _active_aggregators.clear() + _active_aggregators_cnt.clear() + + # The "default" aggregator observes all logged values. + _aggregators["default"] = MetersDict() + _active_aggregators["default"] = _aggregators["default"] + _active_aggregators_cnt["default"] = 1 + + +reset() + + +@contextlib.contextmanager +def aggregate(name: Optional[str] = None, new_root: bool = False): + """Context manager to aggregate metrics under a given name. + + Aggregations can be nested. If *new_root* is ``False``, then logged + metrics will be recorded along the entire stack of nested + aggregators, including a global "default" aggregator. If *new_root* + is ``True``, then this aggregator will be the root of a new + aggregation stack, thus bypassing any parent aggregators. + + Note that aggregation contexts are uniquely identified by their + *name* (e.g., train, valid). Creating a context with an existing + name will reuse the corresponding :class:`MetersDict` instance. + If no name is given, then a temporary aggregator will be created. + + Usage:: + + with metrics.aggregate("train"): + for step, batch in enumerate(epoch): + with metrics.aggregate("train_inner") as agg: + metrics.log_scalar("loss", get_loss(batch)) + if step % log_interval == 0: + print(agg.get_smoothed_value("loss")) + agg.reset() + print(metrics.get_smoothed_values("train")["loss"]) + + Args: + name (str): name of the aggregation. Defaults to a + random/temporary name if not given explicitly. + new_root (bool): make this aggregation the root of a new + aggregation stack. + """ + if name is None: + # generate a temporary name + name = str(uuid.uuid4()) + assert name not in _aggregators + agg = MetersDict() + else: + assert name != "default" + agg = _aggregators.setdefault(name, MetersDict()) + + if new_root: + backup_aggregators = _active_aggregators.copy() + _active_aggregators.clear() + backup_aggregators_cnt = _active_aggregators_cnt.copy() + _active_aggregators_cnt.clear() + + _active_aggregators[name] = agg + _active_aggregators_cnt[name] += 1 + + yield agg + + _active_aggregators_cnt[name] -= 1 + if _active_aggregators_cnt[name] == 0 and name in _active_aggregators: + del _active_aggregators[name] + + if new_root: + _active_aggregators.clear() + _active_aggregators.update(backup_aggregators) + _active_aggregators_cnt.clear() + _active_aggregators_cnt.update(backup_aggregators_cnt) + + +def get_active_aggregators() -> List[MetersDict]: + return list(_active_aggregators.values()) + + +def log_scalar( + key: str, + value: float, + weight: float = 1, + priority: int = 10, + round: Optional[int] = None, +): + """Log a scalar value. + + Args: + key (str): name of the field to log + value (float): value to log + weight (float): weight that this value contributes to the average. + A weight of 0 will always log the latest value. + priority (int): smaller values are logged earlier in the output + round (Optional[int]): number of digits to round to when displaying + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, AverageMeter(round=round), priority) + agg[key].update(value, weight) + +def log_scalar_sum( + key: str, + value: float, + priority: int = 10, + round: Optional[int] = None, +): + """Log a scalar value that is summed for reporting. + + Args: + key (str): name of the field to log + value (float): value to log + priority (int): smaller values are logged earlier in the output + round (Optional[int]): number of digits to round to when displaying + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, SumMeter(round=round), priority) + agg[key].update(value) + + +def log_derived(key: str, fn: Callable[[MetersDict], float], priority: int = 20): + """Log a scalar value derived from other meters. + + Args: + key (str): name of the field to log + fn (Callable[[MetersDict], float]): function that takes a single + argument *meters* and returns the derived value + priority (int): smaller values are logged earlier in the output + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, MetersDict._DerivedMeter(fn), priority) + + +def log_speed( + key: str, + value: float, + priority: int = 30, + round: Optional[int] = None, +): + """Log the rate of some quantity per second. + + Args: + key (str): name of the field to log + value (float): value to log + priority (int): smaller values are logged earlier in the output + round (Optional[int]): number of digits to round to when displaying + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, TimeMeter(round=round), priority) + agg[key].reset() # reset meter on the first call + else: + agg[key].update(value) + + +def log_start_time(key: str, priority: int = 40, round: Optional[int] = None): + """Log the duration of some event in seconds. + + The duration will be computed once :func:`log_stop_time` is called. + + Args: + key (str): name of the field to log + priority (int): smaller values are logged earlier in the output + round (Optional[int]): number of digits to round to when displaying + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, StopwatchMeter(round=round), priority) + agg[key].start() + + +def log_stop_time(key: str, weight: float = 0.0, prehook=None): + """Log the duration of some event in seconds. + + The duration will be computed since :func:`log_start_time` was called. + Set weight > 0 to report the average time instead of the sum. + + Args: + key (str): name of the field to log + weight (float): weight that this time contributes to the average + prehook (function, no arguments): will be called before the timer + is stopped. For example, use prehook=torch.cuda.synchronize to + make sure all gpu operations are done before timer is stopped. + """ + for agg in get_active_aggregators(): + if key in agg: + agg[key].stop(weight, prehook) + + +def log_custom( + new_meter_fn: Callable[[], Meter], + key: str, + *args, + priority: int = 50, + **kwargs, +): + """Log using a custom Meter. + + Any extra *args* or *kwargs* will be passed through to the Meter's + *update* method. + + Args: + new_meter_fn (Callable[[], Meter]): function that returns a new + Meter instance + key (str): name of the field to log + priority (int): smaller values are logged earlier in the output + """ + for agg in get_active_aggregators(): + if key not in agg: + agg.add_meter(key, new_meter_fn(), priority) + agg[key].update(*args, **kwargs) + + +def reset_meter(name: str, key: str) -> None: + """Reset Meter instance aggregated under a given *name* and *key*.""" + meter = get_meter(name, key) + if meter is not None: + meter.reset() + + +def reset_meters(name: str) -> None: + """Reset Meter instances aggregated under a given *name*.""" + meters = get_meters(name) + if meters is not None: + meters.reset() + + +def get_meter(name: str, key: str) -> Meter: + """Get a single Meter instance aggregated under *name* and *key*. + + Returns: + Meter or None if no metrics have been logged under *name* and *key*. + """ + if name not in _aggregators: + return None + return _aggregators[name].get(key, None) + + +def get_meters(name: str) -> MetersDict: + """Get Meter instances aggregated under a given *name*. + + Returns: + MetersDict or None if no metrics have been logged under *name*. + """ + return _aggregators.get(name, None) + + +def get_smoothed_value(name: str, key: str) -> float: + """Get a single smoothed value. + + Raises: + KeyError: if no metrics have been logged under *name* and *key*. + """ + return _aggregators[name].get_smoothed_value(key) + + +def get_smoothed_values(name: str) -> Dict[str, float]: + """Get smoothed values aggregated under a given *name*. + + Raises: + KeyError: if no metrics have been logged under *name*. + """ + return _aggregators[name].get_smoothed_values() + + +def state_dict(): + return OrderedDict([(name, agg.state_dict()) for name, agg in _aggregators.items()]) + + +def load_state_dict(state_dict): + for name, agg_state in state_dict.items(): + _aggregators[name] = MetersDict() + _aggregators[name].load_state_dict(agg_state) + + +def xla_metrics_report(): + try: + import torch_xla.debug.metrics as met + print(met.metrics_report()) + except ImportError: + return diff --git a/fairseq/fairseq/logging/progress_bar.py b/fairseq/fairseq/logging/progress_bar.py new file mode 100644 index 0000000000000000000000000000000000000000..061082caefe542c5f0f87e04d9472583874126a3 --- /dev/null +++ b/fairseq/fairseq/logging/progress_bar.py @@ -0,0 +1,490 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Wrapper around various loggers and progress bars (e.g., tqdm). +""" + +import atexit +import json +import logging +import os +import sys +from collections import OrderedDict +from contextlib import contextmanager +from numbers import Number +from typing import Optional + +import torch + +from .meters import AverageMeter, StopwatchMeter, TimeMeter + + +logger = logging.getLogger(__name__) + + +def progress_bar( + iterator, + log_format: Optional[str] = None, + log_interval: int = 100, + log_file: Optional[str] = None, + epoch: Optional[int] = None, + prefix: Optional[str] = None, + tensorboard_logdir: Optional[str] = None, + default_log_format: str = "tqdm", + wandb_project: Optional[str] = None, + wandb_run_name: Optional[str] = None, + azureml_logging: Optional[bool] = False, +): + if log_format is None: + log_format = default_log_format + if log_file is not None: + handler = logging.FileHandler(filename=log_file) + logger.addHandler(handler) + + if log_format == "tqdm" and not sys.stderr.isatty(): + log_format = "simple" + + if log_format == "json": + bar = JsonProgressBar(iterator, epoch, prefix, log_interval) + elif log_format == "none": + bar = NoopProgressBar(iterator, epoch, prefix) + elif log_format == "simple": + bar = SimpleProgressBar(iterator, epoch, prefix, log_interval) + elif log_format == "tqdm": + bar = TqdmProgressBar(iterator, epoch, prefix) + else: + raise ValueError("Unknown log format: {}".format(log_format)) + + if tensorboard_logdir: + try: + # [FB only] custom wrapper for TensorBoard + import palaas # noqa + from .fb_tbmf_wrapper import FbTbmfWrapper + + bar = FbTbmfWrapper(bar, log_interval) + except ImportError: + bar = TensorboardProgressBarWrapper(bar, tensorboard_logdir) + + if wandb_project: + bar = WandBProgressBarWrapper(bar, wandb_project, run_name=wandb_run_name) + + if azureml_logging: + bar = AzureMLProgressBarWrapper(bar) + + return bar + + +def build_progress_bar( + args, + iterator, + epoch: Optional[int] = None, + prefix: Optional[str] = None, + default: str = "tqdm", + no_progress_bar: str = "none", +): + """Legacy wrapper that takes an argparse.Namespace.""" + if getattr(args, "no_progress_bar", False): + default = no_progress_bar + if getattr(args, "distributed_rank", 0) == 0: + tensorboard_logdir = getattr(args, "tensorboard_logdir", None) + else: + tensorboard_logdir = None + return progress_bar( + iterator, + log_format=args.log_format, + log_interval=args.log_interval, + epoch=epoch, + prefix=prefix, + tensorboard_logdir=tensorboard_logdir, + default_log_format=default, + ) + + +def format_stat(stat): + if isinstance(stat, Number): + stat = "{:g}".format(stat) + elif isinstance(stat, AverageMeter): + stat = "{:.3f}".format(stat.avg) + elif isinstance(stat, TimeMeter): + stat = "{:g}".format(round(stat.avg)) + elif isinstance(stat, StopwatchMeter): + stat = "{:g}".format(round(stat.sum)) + elif torch.is_tensor(stat): + stat = stat.tolist() + return stat + + +class BaseProgressBar(object): + """Abstract class for progress bars.""" + + def __init__(self, iterable, epoch=None, prefix=None): + self.iterable = iterable + self.n = getattr(iterable, "n", 0) + self.epoch = epoch + self.prefix = "" + if epoch is not None: + self.prefix += "epoch {:03d}".format(epoch) + if prefix is not None: + self.prefix += (" | " if self.prefix != "" else "") + prefix + + def __len__(self): + return len(self.iterable) + + def __enter__(self): + return self + + def __exit__(self, *exc): + return False + + def __iter__(self): + raise NotImplementedError + + def log(self, stats, tag=None, step=None): + """Log intermediate stats according to log_interval.""" + raise NotImplementedError + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + raise NotImplementedError + + def update_config(self, config): + """Log latest configuration.""" + pass + + def _str_commas(self, stats): + return ", ".join(key + "=" + stats[key].strip() for key in stats.keys()) + + def _str_pipes(self, stats): + return " | ".join(key + " " + stats[key].strip() for key in stats.keys()) + + def _format_stats(self, stats): + postfix = OrderedDict(stats) + # Preprocess stats according to datatype + for key in postfix.keys(): + postfix[key] = str(format_stat(postfix[key])) + return postfix + + +@contextmanager +def rename_logger(logger, new_name): + old_name = logger.name + if new_name is not None: + logger.name = new_name + yield logger + logger.name = old_name + + +class JsonProgressBar(BaseProgressBar): + """Log output in JSON format.""" + + def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000): + super().__init__(iterable, epoch, prefix) + self.log_interval = log_interval + self.i = None + self.size = None + + def __iter__(self): + self.size = len(self.iterable) + for i, obj in enumerate(self.iterable, start=self.n): + self.i = i + yield obj + + def log(self, stats, tag=None, step=None): + """Log intermediate stats according to log_interval.""" + step = step or self.i or 0 + if step > 0 and self.log_interval is not None and step % self.log_interval == 0: + update = ( + self.epoch - 1 + (self.i + 1) / float(self.size) + if self.epoch is not None + else None + ) + stats = self._format_stats(stats, epoch=self.epoch, update=update) + with rename_logger(logger, tag): + logger.info(json.dumps(stats)) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + self.stats = stats + if tag is not None: + self.stats = OrderedDict( + [(tag + "_" + k, v) for k, v in self.stats.items()] + ) + stats = self._format_stats(self.stats, epoch=self.epoch) + with rename_logger(logger, tag): + logger.info(json.dumps(stats)) + + def _format_stats(self, stats, epoch=None, update=None): + postfix = OrderedDict() + if epoch is not None: + postfix["epoch"] = epoch + if update is not None: + postfix["update"] = round(update, 3) + # Preprocess stats according to datatype + for key in stats.keys(): + postfix[key] = format_stat(stats[key]) + return postfix + + +class NoopProgressBar(BaseProgressBar): + """No logging.""" + + def __init__(self, iterable, epoch=None, prefix=None): + super().__init__(iterable, epoch, prefix) + + def __iter__(self): + for obj in self.iterable: + yield obj + + def log(self, stats, tag=None, step=None): + """Log intermediate stats according to log_interval.""" + pass + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + pass + + +class SimpleProgressBar(BaseProgressBar): + """A minimal logger for non-TTY environments.""" + + def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000): + super().__init__(iterable, epoch, prefix) + self.log_interval = log_interval + self.i = None + self.size = None + + def __iter__(self): + self.size = len(self.iterable) + for i, obj in enumerate(self.iterable, start=self.n): + self.i = i + yield obj + + def log(self, stats, tag=None, step=None): + """Log intermediate stats according to log_interval.""" + step = step or self.i or 0 + if step > 0 and self.log_interval is not None and step % self.log_interval == 0: + stats = self._format_stats(stats) + postfix = self._str_commas(stats) + with rename_logger(logger, tag): + logger.info( + "{}: {:5d} / {:d} {}".format( + self.prefix, self.i + 1, self.size, postfix + ) + ) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + postfix = self._str_pipes(self._format_stats(stats)) + with rename_logger(logger, tag): + logger.info("{} | {}".format(self.prefix, postfix)) + + +class TqdmProgressBar(BaseProgressBar): + """Log to tqdm.""" + + def __init__(self, iterable, epoch=None, prefix=None): + super().__init__(iterable, epoch, prefix) + from tqdm import tqdm + + self.tqdm = tqdm( + iterable, + self.prefix, + leave=False, + disable=(logger.getEffectiveLevel() > logging.INFO), + ) + + def __iter__(self): + return iter(self.tqdm) + + def log(self, stats, tag=None, step=None): + """Log intermediate stats according to log_interval.""" + self.tqdm.set_postfix(self._format_stats(stats), refresh=False) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + postfix = self._str_pipes(self._format_stats(stats)) + with rename_logger(logger, tag): + logger.info("{} | {}".format(self.prefix, postfix)) + + +try: + _tensorboard_writers = {} + from torch.utils.tensorboard import SummaryWriter +except ImportError: + try: + from tensorboardX import SummaryWriter + except ImportError: + SummaryWriter = None + + +def _close_writers(): + for w in _tensorboard_writers.values(): + w.close() + + +atexit.register(_close_writers) + + +class TensorboardProgressBarWrapper(BaseProgressBar): + """Log to tensorboard.""" + + def __init__(self, wrapped_bar, tensorboard_logdir): + self.wrapped_bar = wrapped_bar + self.tensorboard_logdir = tensorboard_logdir + + if SummaryWriter is None: + logger.warning( + "tensorboard not found, please install with: pip install tensorboard" + ) + + def _writer(self, key): + if SummaryWriter is None: + return None + _writers = _tensorboard_writers + if key not in _writers: + _writers[key] = SummaryWriter(os.path.join(self.tensorboard_logdir, key)) + _writers[key].add_text("sys.argv", " ".join(sys.argv)) + return _writers[key] + + def __iter__(self): + return iter(self.wrapped_bar) + + def log(self, stats, tag=None, step=None): + """Log intermediate stats to tensorboard.""" + self._log_to_tensorboard(stats, tag, step) + self.wrapped_bar.log(stats, tag=tag, step=step) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + self._log_to_tensorboard(stats, tag, step) + self.wrapped_bar.print(stats, tag=tag, step=step) + + def update_config(self, config): + """Log latest configuration.""" + # TODO add hparams to Tensorboard + self.wrapped_bar.update_config(config) + + def _log_to_tensorboard(self, stats, tag=None, step=None): + writer = self._writer(tag or "") + if writer is None: + return + if step is None: + step = stats["num_updates"] + for key in stats.keys() - {"num_updates"}: + if isinstance(stats[key], AverageMeter): + writer.add_scalar(key, stats[key].val, step) + elif isinstance(stats[key], Number): + writer.add_scalar(key, stats[key], step) + elif torch.is_tensor(stats[key]) and stats[key].numel() == 1: + writer.add_scalar(key, stats[key].item(), step) + writer.flush() + + +try: + import wandb +except ImportError: + wandb = None + + +class WandBProgressBarWrapper(BaseProgressBar): + """Log to Weights & Biases.""" + + def __init__(self, wrapped_bar, wandb_project, run_name=None): + self.wrapped_bar = wrapped_bar + if wandb is None: + logger.warning("wandb not found, pip install wandb") + return + + # reinit=False to ensure if wandb.init() is called multiple times + # within one process it still references the same run + wandb.init(project=wandb_project, reinit=False, name=run_name) + + def __iter__(self): + return iter(self.wrapped_bar) + + def log(self, stats, tag=None, step=None): + """Log intermediate stats to tensorboard.""" + self._log_to_wandb(stats, tag, step) + self.wrapped_bar.log(stats, tag=tag, step=step) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats.""" + self._log_to_wandb(stats, tag, step) + self.wrapped_bar.print(stats, tag=tag, step=step) + + def update_config(self, config): + """Log latest configuration.""" + if wandb is not None: + wandb.config.update(config) + self.wrapped_bar.update_config(config) + + def _log_to_wandb(self, stats, tag=None, step=None): + if wandb is None: + return + if step is None: + step = stats["num_updates"] + + prefix = "" if tag is None else tag + "/" + + for key in stats.keys() - {"num_updates"}: + if isinstance(stats[key], AverageMeter): + wandb.log({prefix + key: stats[key].val}, step=step) + elif isinstance(stats[key], Number): + wandb.log({prefix + key: stats[key]}, step=step) + + +try: + from azureml.core import Run +except ImportError: + Run = None + + +class AzureMLProgressBarWrapper(BaseProgressBar): + """Log to Azure ML""" + + def __init__(self, wrapped_bar): + self.wrapped_bar = wrapped_bar + if Run is None: + logger.warning("azureml.core not found, pip install azureml-core") + return + self.run = Run.get_context() + + def __exit__(self, *exc): + if Run is not None: + self.run.complete() + return False + + def __iter__(self): + return iter(self.wrapped_bar) + + def log(self, stats, tag=None, step=None): + """Log intermediate stats to AzureML""" + self._log_to_azureml(stats, tag, step) + self.wrapped_bar.log(stats, tag=tag, step=step) + + def print(self, stats, tag=None, step=None): + """Print end-of-epoch stats""" + self._log_to_azureml(stats, tag, step) + self.wrapped_bar.print(stats, tag=tag, step=step) + + def update_config(self, config): + """Log latest configuration.""" + self.wrapped_bar.update_config(config) + + def _log_to_azureml(self, stats, tag=None, step=None): + if Run is None: + return + if step is None: + step = stats["num_updates"] + + prefix = "" if tag is None else tag + "/" + + for key in stats.keys() - {"num_updates"}: + name = prefix + key + if isinstance(stats[key], AverageMeter): + self.run.log_row(name=name, **{"step": step, key: stats[key].val}) + elif isinstance(stats[key], Number): + self.run.log_row(name=name, **{"step": step, key: stats[key]}) diff --git a/fairseq/fairseq/model_parallel/__init__.py b/fairseq/fairseq/model_parallel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..69f21684872f72ae8ee26d9ff7d2d2b6e6d526c3 --- /dev/null +++ b/fairseq/fairseq/model_parallel/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import criterions, models, modules # noqa diff --git a/fairseq/fairseq/model_parallel/criterions/__init__.py b/fairseq/fairseq/model_parallel/criterions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5fae7bd4c2cfa7b4f64ad62dd9b9082f59f0e50d --- /dev/null +++ b/fairseq/fairseq/model_parallel/criterions/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +# automatically import any Python files in the criterions/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + module = file[: file.find(".py")] + importlib.import_module("fairseq.model_parallel.criterions." + module) diff --git a/fairseq/fairseq/model_parallel/criterions/vocab_parallel_cross_entropy.py b/fairseq/fairseq/model_parallel/criterions/vocab_parallel_cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..35c50ee1521963c5cb6dfb7036ccf43401c6c6ac --- /dev/null +++ b/fairseq/fairseq/model_parallel/criterions/vocab_parallel_cross_entropy.py @@ -0,0 +1,87 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +from fairseq import metrics, utils +from fairseq.criterions import FairseqCriterion, register_criterion + + +try: + from fairseq.model_parallel.megatron.mpu.cross_entropy import ( + vocab_parallel_cross_entropy, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +@register_criterion("vocab_parallel_cross_entropy") +class VocabParallelCrossEntropyCriterion(FairseqCriterion): + def __init__(self, task, sentence_avg): + super().__init__(task) + self.sentence_avg = sentence_avg + if not has_megatron_submodule: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + + def forward(self, model, sample, reduce=True): + """Compute the loss for the given sample. + + Returns a tuple with three elements: + 1) the loss + 2) the sample size, which is used as the denominator for the gradient + 3) logging outputs to display while training + """ + net_output = model(**sample["net_input"]) + target = sample["target"] + + loss = vocab_parallel_cross_entropy(net_output[0].float(), target) + loss = (loss * (target != self.padding_idx)).sum() + sample_size = ( + sample["target"].size(0) if self.sentence_avg else sample["ntokens"] + ) + logging_output = { + "loss": utils.item(loss.data) if reduce else loss.data, + "ntokens": sample["ntokens"], + "nsentences": sample["target"].size(0), + "sample_size": sample_size, + } + return loss, sample_size, logging_output + + @staticmethod + def reduce_metrics(logging_outputs) -> None: + """Aggregate logging outputs from data parallel training.""" + loss_sum = sum(log.get("loss", 0) for log in logging_outputs) + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + sample_size = sum(log.get("sample_size", 0) for log in logging_outputs) + + metrics.log_scalar( + "loss", loss_sum / sample_size / math.log(2), sample_size, round=3 + ) + if sample_size != ntokens: + metrics.log_scalar( + "nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3 + ) + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg) + ) + else: + metrics.log_derived( + "ppl", lambda meters: utils.get_perplexity(meters["loss"].avg) + ) + + @staticmethod + def logging_outputs_can_be_summed() -> bool: + """ + Whether the logging outputs returned by `forward` can be summed + across workers prior to calling `reduce_metrics`. Setting this + to True will improves distributed training speed. + """ + return True diff --git a/fairseq/fairseq/model_parallel/megatron_trainer.py b/fairseq/fairseq/model_parallel/megatron_trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..8ab4657f73c6cda91e95637921edb84ccb76b3d0 --- /dev/null +++ b/fairseq/fairseq/model_parallel/megatron_trainer.py @@ -0,0 +1,71 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Train a network across multiple GPUs. +""" + +from fairseq.dataclass.configs import FairseqConfig +from fairseq.distributed import utils as distributed_utils +from fairseq.trainer import Trainer + +try: + from fairseq.model_parallel.megatron.mpu import ( + get_data_parallel_rank, + get_data_parallel_world_size, + get_model_parallel_src_rank, + get_cuda_rng_tracker, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +class MegatronTrainer(Trainer): + """Main class for model parallel with data parallel training.""" + + def __init__(self, cfg: FairseqConfig, task, model, criterion, **kwargs): + if not has_megatron_submodule: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + super().__init__(cfg, task, model, criterion, **kwargs) + + def clip_grad_norm(self, clip_norm): + def _aggregate_model_parallel_grad_norm(total_norm): + total_norm = total_norm ** 2 + distributed_utils.all_reduce( + total_norm, group=distributed_utils.get_model_parallel_group() + ) + total_norm = total_norm ** 0.5 + return total_norm + + return self.optimizer.clip_grad_norm( + clip_norm, + aggregate_norm_fn=_aggregate_model_parallel_grad_norm, + ) + + def save_checkpoint(self, filename, extra_state): + """Save all training state in a checkpoint file.""" + extra_state['rng_tracker_states'] \ + = get_cuda_rng_tracker().get_states() + super().save_checkpoint(filename, extra_state) + + def load_checkpoint( + self, + filename, + reset_optimizer=False, + reset_lr_scheduler=False, + optimizer_overrides=None, + reset_meters=False, + ): + extra_state = super().load_checkpoint(filename, reset_optimizer=reset_optimizer, reset_lr_scheduler=reset_lr_scheduler, optimizer_overrides=optimizer_overrides, reset_meters=reset_meters) + if extra_state is not None and 'rng_tracker_states' in extra_state: + get_cuda_rng_tracker().set_states( + extra_state['rng_tracker_states']) + return extra_state diff --git a/fairseq/fairseq/model_parallel/models/__init__.py b/fairseq/fairseq/model_parallel/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3532479e52a0e1f1ba204c6f5d51c71c98ee5df0 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +# automatically import any Python files in the models/ directory +models_dir = os.path.dirname(__file__) +for file in os.listdir(models_dir): + path = os.path.join(models_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + model_name = file[: file.find(".py")] if file.endswith(".py") else file + module = importlib.import_module("fairseq.model_parallel.models." + model_name) diff --git a/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/__init__.py b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..117827c3e9c176477f33e3a6fd7fe19a922411a2 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .model import * # noqa diff --git a/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/layers.py b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..eb81ded341257ba0a43c4d0867e8f3c83f276bc7 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/layers.py @@ -0,0 +1,600 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from collections import namedtuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import options, utils +from fairseq.modules import ( + AdaptiveSoftmax, + LayerNorm, + MultiheadAttention, + PositionalEmbedding, +) + + +EncoderOut = namedtuple( + "TransformerEncoderOut", + [ + "encoder_out", # T x B x C + "encoder_padding_mask", # B x T + "encoder_embedding", # B x T x C + "encoder_states", # List[T x B x C] + ], +) + + +class TransformerEncoderEmbedding(nn.Module): + """ Encoder Embedding + Positional Embedding """ + + def __init__(self, args, embed_tokens): + super().__init__() + self.dropout = args.dropout + self.max_source_positions = args.max_source_positions + self.embed_tokens = embed_tokens + if isinstance(embed_tokens, nn.ModuleList): + self.padding_idx = embed_tokens[0].padding_idx + embed_dim = sum(e.embedding_dim for e in embed_tokens) + else: + self.padding_idx = embed_tokens.padding_idx + embed_dim = embed_tokens.embedding_dim + self.embed_scale = math.sqrt(embed_dim) + self.embed_positions = ( + PositionalEmbedding( + args.max_source_positions, + embed_dim, + self.padding_idx, + learned=args.encoder_learned_pos, + ) + if not args.no_token_positional_embeddings + else None + ) + if getattr(args, "layernorm_embedding", False): + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + def forward(self, input): + # embed tokens and positions + src_tokens = input[0] + prev_output_tokens = input[2] + if isinstance(self.embed_tokens, nn.ModuleList): + x_embed_list = [] + for embed_tokens_part in self.embed_tokens: + x_embed_list.append(embed_tokens_part(src_tokens)) + + embedded = torch.cat(x_embed_list, dim=-1) + else: + embedded = self.embed_tokens(src_tokens) + x = embed = self.embed_scale * embedded + if self.embed_positions is not None: + x = embed + self.embed_positions(src_tokens) + if self.layernorm_embedding: + x = self.layernorm_embedding(x) + x = F.dropout(x, p=self.dropout, training=self.training) + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # compute padding mask + encoder_padding_mask = src_tokens.eq(self.padding_idx) + return (x, encoder_padding_mask, prev_output_tokens) + + +class TransformerEncoderLayerNorm(nn.Module): + """ + Layer norm at the the end of all encoder layers if + args.encoder_enormalize_before = True + """ + + def __init__(self, args, embed_dim): + super().__init__() + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + def forward(self, input): + x = input[0] + encoder_padding_mask = input[1] + prev_output_tokens = input[2] + if self.layer_norm: + x = self.layer_norm(x) + # keeping track of the incremental_state is not supported yet + return (x, encoder_padding_mask, prev_output_tokens) + + +class TransformerDecoderEmbedding(nn.Module): + """ Decoder Embedding + Positional Embedding """ + + def __init__(self, args, embed_tokens): + super().__init__() + self.dropout = args.dropout + self.share_input_output_embed = args.share_decoder_input_output_embed + input_embed_dim = ( + sum(e.embedding_dim for e in embed_tokens) + if isinstance(embed_tokens, nn.ModuleList) + else embed_tokens.embedding_dim + ) + embed_dim = args.decoder_embed_dim + self.output_embed_dim = args.decoder_output_dim + + padding_idx = ( + embed_tokens[0].padding_idx + if isinstance(embed_tokens, nn.ModuleList) + else embed_tokens.padding_idx + ) + self.max_target_positions = args.max_target_positions + + self.embed_tokens = embed_tokens + self.embed_scale = math.sqrt(embed_dim) # todo: try with input_embed_dim + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + + self.embed_positions = ( + PositionalEmbedding( + args.max_target_positions, + embed_dim, + padding_idx, + learned=args.decoder_learned_pos, + ) + if not args.no_token_positional_embeddings + else None + ) + + def forward(self, input): + mt_task = False + if isinstance(input, tuple): + if len(input) == 3: + encoder_out = input[0] + encoder_padding_mask = input[1] + prev_output_tokens = input[2] + incremental_state = None # Hardcoding to avoid passing of None objects + mt_task = True + else: + # HACK for now, need to fix (TODO sidgoyal) + prev_output_tokens = input[0] + # discard "src_lengths" + encoder_out = None + encoder_padding_mask = None + incremental_state = None + + else: + prev_output_tokens = input + encoder_out = None + encoder_padding_mask = None + incremental_state = None + + positions = ( + self.embed_positions( + prev_output_tokens, + incremental_state=incremental_state, + ) + if self.embed_positions is not None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + # embed tokens and positions + + if isinstance(self.embed_tokens, nn.ModuleList): + x_embed_list = [] + for embed_tokens_part in self.embed_tokens: + x_embed_list.append(embed_tokens_part(prev_output_tokens)) + + x = self.embed_scale * torch.cat(x_embed_list, dim=-1) + else: + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + x = F.dropout(x, p=self.dropout, training=self.training) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + if mt_task: + return (x, encoder_out, encoder_padding_mask) + return x + + +class TransformerDecoderOutputLayer(nn.Module): + def __init__(self, args, embed_tokens, dictionary): + super().__init__() + self.share_input_output_embed = args.share_decoder_input_output_embed + self.embed_tokens = embed_tokens + self.output_embed_dim = args.decoder_output_dim + embed_dim = args.decoder_embed_dim + + self.project_out_dim = ( + Linear(embed_dim, self.output_embed_dim, bias=False) + if embed_dim != self.output_embed_dim and not args.tie_adaptive_weights + else None + ) + self.adaptive_softmax = None + if args.adaptive_softmax_cutoff is not None: + assert not isinstance(embed_tokens, nn.ModuleList) + self.adaptive_softmax = AdaptiveSoftmax( + len(dictionary), + self.output_embed_dim, + options.eval_str_list(args.adaptive_softmax_cutoff, type=int), + dropout=args.adaptive_softmax_dropout, + adaptive_inputs=embed_tokens if args.tie_adaptive_weights else None, + factor=args.adaptive_softmax_factor, + tie_proj=args.tie_adaptive_proj, + ) + elif not self.share_input_output_embed: + self.embed_tokens = nn.Parameter( + torch.Tensor(len(dictionary), self.output_embed_dim) + ) + nn.init.normal_( + self.embed_tokens, mean=0, std=self.output_embed_dim ** -0.5 + ) + + if args.decoder_normalize_before and not getattr( + args, "no_decoder_final_norm", False + ): + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + def forward(self, input, apply_final_proj=True): + if isinstance(input, tuple): + x = input[0] + else: + x = input + + if self.layer_norm: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + if apply_final_proj: + x = self.output_layer(x) + return x + + def output_layer(self, features, **kwargs): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + # project back to size of vocabulary + if self.share_input_output_embed: + if isinstance(self.embed_tokens, nn.ModuleList): + output = None + for i, emb in enumerate(self.embed_tokens): + sidx = i * emb.embedding_dim + eidx = (i + 1) * emb.embedding_dim + if output is None: + output = F.linear(features[:, :, sidx:eidx], emb.weight) + else: + output += F.linear(features[:, :, sidx:eidx], emb.weight) + + return output + else: + return F.linear(features, self.embed_tokens.weight) + else: + return F.linear(features, self.embed_tokens) + else: + return features + + +class TransformerEncoderLayer(nn.Module): + """Encoder layer block. + In the original paper each operation (multi-head attention or FFN) is + postprocessed with: `dropout -> add residual -> layernorm`. In the + tensor2tensor code they suggest that learning is more robust when + preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *args.encoder_normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + + def __init__(self, args): + super().__init__() + self.embed_dim = args.encoder_embed_dim + self.self_attn = MultiheadAttention( + self.embed_dim, + args.encoder_attention_heads, + dropout=args.attention_dropout, + self_attention=True, + ) + self.self_attn_layer_norm = LayerNorm(self.embed_dim) + self.dropout = args.dropout + self.activation_fn = utils.get_activation_fn( + activation=getattr(args, "activation_fn", "relu") + ) + self.activation_dropout = getattr(args, "activation_dropout", 0) + if self.activation_dropout == 0: + # for backwards compatibility with models that use args.relu_dropout + self.activation_dropout = getattr(args, "relu_dropout", 0) + self.normalize_before = args.encoder_normalize_before + self.fc1 = Linear(self.embed_dim, args.encoder_ffn_embed_dim) + self.fc2 = Linear(args.encoder_ffn_embed_dim, self.embed_dim) + self.final_layer_norm = LayerNorm(self.embed_dim) + + def upgrade_state_dict_named(self, state_dict, name): + """ + Rename layer norm states from `...layer_norms.0.weight` to + `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to + `...final_layer_norm.weight` + """ + layer_norm_map = {"0": "self_attn_layer_norm", "1": "final_layer_norm"} + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layer_norms.{}.{}".format(name, old, m) + if k in state_dict: + state_dict["{}.{}.{}".format(name, new, m)] = state_dict[k] + del state_dict[k] + + def forward(self, input): + """ + Args: + input (Tuple): + input[0] (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + input[1] (ByteTensor/FloatTensor): encoder padding mask - + binary ByteTensor of shape `(batch, src_len)` where padding elements + are indicated by ``1``. + input[2] (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing) + Returns: + output (Tuple): + output[0] (Tensor): encoded output of shape `(batch, src_len, embed_dim)` + output[1] (ByteTensor/FloatTensor): encoder padding mask + output[2] (LongTensor): previous decoder outputs + """ + x = input[0] + encoder_padding_mask = input[1] + prev_output_tokens = input[2] + residual = x + x = self.maybe_layer_norm(self.self_attn_layer_norm, x, before=True) + x, _ = self.self_attn( + query=x, key=x, value=x, key_padding_mask=encoder_padding_mask + ) + x = F.dropout(x, p=self.dropout, training=self.training) + x = residual + x + x = self.maybe_layer_norm(self.self_attn_layer_norm, x, after=True) + + residual = x + x = self.maybe_layer_norm(self.final_layer_norm, x, before=True) + x = self.activation_fn(self.fc1(x)) + x = F.dropout(x, p=self.activation_dropout, training=self.training) + x = self.fc2(x) + x = F.dropout(x, p=self.dropout, training=self.training) + x = residual + x + x = self.maybe_layer_norm(self.final_layer_norm, x, after=True) + return (x, encoder_padding_mask, prev_output_tokens) + + def maybe_layer_norm(self, layer_norm, x, before=False, after=False): + assert before ^ after + if after ^ self.normalize_before: + return layer_norm(x) + else: + return x + + +class TransformerDecoderLayer(nn.Module): + """Decoder layer block. + + In the original paper each operation (multi-head attention, encoder + attention or FFN) is postprocessed with: `dropout -> add residual -> + layernorm`. In the tensor2tensor code they suggest that learning is more + robust when preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *args.decoder_normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, args, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False + ): + super().__init__() + self.embed_dim = args.decoder_embed_dim + self.self_attn = MultiheadAttention( + embed_dim=self.embed_dim, + num_heads=args.decoder_attention_heads, + dropout=args.attention_dropout, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + self_attention=True, + ) + self.dropout = args.dropout + self.activation_fn = utils.get_activation_fn( + activation=getattr(args, "activation_fn", "relu") + ) + self.activation_dropout = getattr(args, "activation_dropout", 0) + if self.activation_dropout == 0: + # for backwards compatibility with models that use args.relu_dropout + self.activation_dropout = getattr(args, "relu_dropout", 0) + self.normalize_before = args.decoder_normalize_before + + # use layerNorm rather than FusedLayerNorm for exporting. + # char_inputs can be used to determint this. + # TODO remove this once we update apex with the fix + export = getattr(args, "char_inputs", False) + self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=export) + + if no_encoder_attn: + self.encoder_attn = None + self.encoder_attn_layer_norm = None + else: + self.encoder_attn = MultiheadAttention( + self.embed_dim, + args.decoder_attention_heads, + kdim=getattr(args, "encoder_embed_dim", None), + vdim=getattr(args, "encoder_embed_dim", None), + dropout=args.attention_dropout, + encoder_decoder_attention=True, + ) + self.encoder_attn_layer_norm = LayerNorm(self.embed_dim, export=export) + + self.fc1 = Linear(self.embed_dim, args.decoder_ffn_embed_dim) + self.fc2 = Linear(args.decoder_ffn_embed_dim, self.embed_dim) + + self.final_layer_norm = LayerNorm(self.embed_dim, export=export) + self.need_attn = True + + self.onnx_trace = False + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def forward(self, input): + """ + Args: + input (Tuple): + input[0] (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + input[1] (Tensor): encoder output of shape `(batch, src_len, embed_dim)` + input[2] (ByteTensor/FloatTensor): encoder padding mask - + binary ByteTensor of shape `(batch, src_len)` where padding elements + are indicated by ``1``. + Returns: + output (Tuple): + output[0] (Tensor): encoded output of shape `(batch, src_len, embed_dim)` + output[1] (ByteTensor/FloatTensor): encoder padding mask + output[2] (LongTensor): previous decoder outputs + """ + # Note: incremental state is not yet supported + mt_task = False + if isinstance(input, tuple): + x = input[0] + encoder_out = input[1] + encoder_padding_mask = input[2] + incremental_state = None + mt_task = True + else: + x = input + encoder_out = None + encoder_padding_mask = None + incremental_state = None + + if incremental_state is None: + self_attn_mask = self.buffered_future_mask(x) + else: + self_attn_mask = None + + # TODO: add back prev_self_attn_state, prev_attn_state, + # self_attn_padding_mask + prev_self_attn_state = None + prev_attn_state = None + self_attn_padding_mask = None + + residual = x + x = self.maybe_layer_norm(self.self_attn_layer_norm, x, before=True) + if prev_self_attn_state is not None: + if incremental_state is None: + incremental_state = {} + prev_key, prev_value = prev_self_attn_state + saved_state = {"prev_key": prev_key, "prev_value": prev_value} + self.self_attn._set_input_buffer(incremental_state, saved_state) + x, attn = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=self_attn_padding_mask, + incremental_state=incremental_state, + need_weights=False, + attn_mask=self_attn_mask, + ) + x = F.dropout(x, p=self.dropout, training=self.training) + x = residual + x + x = self.maybe_layer_norm(self.self_attn_layer_norm, x, after=True) + + if self.encoder_attn is not None: + residual = x + x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, before=True) + if prev_attn_state is not None: + if incremental_state is None: + incremental_state = {} + prev_key, prev_value = prev_attn_state + saved_state = {"prev_key": prev_key, "prev_value": prev_value} + self.encoder_attn._set_input_buffer(incremental_state, saved_state) + x, attn = self.encoder_attn( + query=x, + key=encoder_out, + value=encoder_out, + key_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + static_kv=True, + need_weights=(not self.training and self.need_attn), + ) + x = F.dropout(x, p=self.dropout, training=self.training) + x = residual + x + x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, after=True) + + residual = x + x = self.maybe_layer_norm(self.final_layer_norm, x, before=True) + x = self.activation_fn(self.fc1(x)) + x = F.dropout(x, p=self.activation_dropout, training=self.training) + x = self.fc2(x) + x = F.dropout(x, p=self.dropout, training=self.training) + x = residual + x + x = self.maybe_layer_norm(self.final_layer_norm, x, after=True) + + if mt_task: + return (x, encoder_out, encoder_padding_mask) + return x + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + not hasattr(self, "_future_mask") + or self._future_mask is None + or self._future_mask.device != tensor.device + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(tensor.new(dim, dim)), 1 + ) + if self._future_mask.size(0) < dim: + self._future_mask = torch.triu( + utils.fill_with_neg_inf(self._future_mask.resize_(dim, dim)), 1 + ) + return self._future_mask[:dim, :dim] + + def maybe_layer_norm(self, layer_norm, x, before=False, after=False): + assert before ^ after + if after ^ self.normalize_before: + return layer_norm(x) + else: + return x + + def make_generation_fast_(self, need_attn=False, **kwargs): + self.need_attn = need_attn + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m diff --git a/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/model.py b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/model.py new file mode 100644 index 0000000000000000000000000000000000000000..7f30dd98bb19b7bc414790787053efb231855129 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/pipeline_parallel_transformer/model.py @@ -0,0 +1,767 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.model_parallel.models.pipeline_parallel_transformer.layers import ( + Embedding, + TransformerDecoderEmbedding, + TransformerDecoderLayer, + TransformerDecoderOutputLayer, + TransformerEncoderEmbedding, + TransformerEncoderLayer, + TransformerEncoderLayerNorm, +) +from fairseq.models import ( + BaseFairseqModel, + FairseqDecoder, + FairseqEncoder, + register_model, + register_model_architecture, +) +from fairseq.models.fairseq_encoder import EncoderOut +from fairseq.models.transformer import ( + base_architecture, + transformer_iwslt_de_en, + transformer_wmt_en_de_big, +) +from fairseq.modules import SinusoidalPositionalEmbedding + + +logger = logging.getLogger(__name__) + + +DEFAULT_MAX_SOURCE_POSITIONS = 1024 +DEFAULT_MAX_TARGET_POSITIONS = 1024 +TORCH_PIPE = False +RPC_INIT = False + +def import_pipe(): + global TORCH_PIPE + global RPC_INIT + try: + from torch.distributed.pipeline.sync import Pipe # noqa + global Pipe + from torch.distributed.pipeline.sync.utils import partition_model + global partition_model + from torch.distributed import rpc + import tempfile + TORCH_PIPE = True + # Initialize single process RPC agent since TORCH_PIPE requires + # RRef. RRef depends on RPC being initialized and as a result we initialize + # RPC with a single node. + tmpfile = tempfile.NamedTemporaryFile() + if not RPC_INIT: + rpc.init_rpc( + name="worker", + rank=0, + world_size=1, + rpc_backend_options=rpc.TensorPipeRpcBackendOptions( + init_method="file://{}".format(tmpfile.name), + ) + ) + RPC_INIT = True + logger.info('Using torch pipe') + except ImportError: + try: + from fairscale.nn import Pipe # noqa + logger.info('Using fairscale pipe') + except ImportError: + raise ImportError("Please install fairscale with: pip install fairscale") + + +@register_model("pipeline_parallel_transformer") +class PipelineParallelTransformerModel(BaseFairseqModel): + def __init__(self, encoder, decoder, balance, devices, chunks, checkpoint): + import_pipe() + super().__init__() + assert isinstance(encoder, FairseqEncoder) + assert isinstance(decoder, FairseqDecoder) + encoder_module_list = ( + [encoder.embedding_layer] + + list(encoder.encoder_layers) + + [encoder.final_layer_norm] + ) + self.num_encoder_modules = len(encoder_module_list) + decoder_module_list = ( + [decoder.embedding_layer] + + list(decoder.decoder_layers) + + [decoder.decoder_output_layer] + ) + self.num_decoder_modules = len(decoder_module_list) + module_list = encoder_module_list + decoder_module_list + self.devices = devices + if TORCH_PIPE: + self.model = Pipe( + partition_model(nn.Sequential(*module_list), balance, devices), + chunks=chunks, + checkpoint=checkpoint, + ) + else: + self.model = Pipe( + nn.Sequential(*module_list), + balance=balance, + devices=devices, + chunks=chunks, + checkpoint=checkpoint, + ) + self.encoder_max_positions = self.max_positions_helper( + encoder.embedding_layer, "max_source_positions" + ) + self.decoder_max_positions = self.max_positions_helper( + decoder.embedding_layer, "max_target_positions" + ) + self.adaptive_softmax = getattr(decoder, "adaptive_softmax", None) + # Note: To be populated during inference + self.encoder = None + self.decoder = None + + def forward(self, src_tokens, src_lengths, prev_output_tokens): + if self.training: + input_lst = [src_tokens, src_lengths, prev_output_tokens] + input = tuple(i.to(self.devices[0], non_blocking=True) for i in input_lst) + if TORCH_PIPE: + return self.model(input).local_value() + else: + return self.model(input) + else: + assert self.encoder is not None and self.decoder is not None, ( + "encoder and decoder need to be initialized by " + + "calling the `prepare_for_inference_()` method" + ) + encoder_output_tuple = self.encoder(input) + return self.decoder(encoder_output_tuple) + + def prepare_for_inference_(self, cfg): + if self.encoder is not None and self.decoder is not None: + logger.info("Encoder and Decoder already initialized") + return + encoder_module_list = [] + decoder_module_list = [] + module_count = 0 + for partition in self.model.partitions: + for module in partition: + if module_count < self.num_encoder_modules: + encoder_module_list.append(module) + else: + decoder_module_list.append(module) + module_count += 1 + self.model = None + self.encoder = TransformerEncoder(cfg.distributed_training, None, None, encoder_module_list) + self.decoder = TransformerDecoder( + cfg.distributed_training, None, None, decoder_module_list=decoder_module_list + ) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--activation-fn', + choices=utils.get_available_activation_fns(), + help='activation function to use') + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--attention-dropout', type=float, metavar='D', + help='dropout probability for attention weights') + parser.add_argument('--activation-dropout', '--relu-dropout', type=float, metavar='D', + help='dropout probability after activation in FFN.') + parser.add_argument('--encoder-embed-path', type=str, metavar='STR', + help='path to pre-trained encoder embedding') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-ffn-embed-dim', type=int, metavar='N', + help='encoder embedding dimension for FFN') + parser.add_argument('--encoder-layers', type=int, metavar='N', + help='num encoder layers') + parser.add_argument('--encoder-attention-heads', type=int, metavar='N', + help='num encoder attention heads') + parser.add_argument('--encoder-normalize-before', action='store_true', + help='apply layernorm before each encoder block') + parser.add_argument('--encoder-learned-pos', action='store_true', + help='use learned positional embeddings in the encoder') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-ffn-embed-dim', type=int, metavar='N', + help='decoder embedding dimension for FFN') + parser.add_argument('--decoder-layers', type=int, metavar='N', + help='num decoder layers') + parser.add_argument('--decoder-attention-heads', type=int, metavar='N', + help='num decoder attention heads') + parser.add_argument('--decoder-learned-pos', action='store_true', + help='use learned positional embeddings in the decoder') + parser.add_argument('--decoder-normalize-before', action='store_true', + help='apply layernorm before each decoder block') + parser.add_argument('--share-decoder-input-output-embed', action='store_true', + help='share decoder input and output embeddings') + parser.add_argument('--share-all-embeddings', action='store_true', + help='share encoder, decoder and output embeddings' + ' (requires shared dictionary and embed dim)') + parser.add_argument('--no-token-positional-embeddings', default=False, action='store_true', + help='if set, disables positional embeddings (outside self attention)') + parser.add_argument('--adaptive-softmax-cutoff', metavar='EXPR', + help='comma separated list of adaptive softmax cutoff points. ' + 'Must be used with adaptive_loss criterion'), + parser.add_argument('--adaptive-softmax-dropout', type=float, metavar='D', + help='sets adaptive softmax dropout for the tail projections') + parser.add_argument('--num-embedding-chunks', type=int, metavar='N', default=1, + help='Number of embedding layer chunks (enables more even distribution' + 'of optimizer states across data parallel nodes' + 'when using optimizer state sharding and' + 'a big embedding vocabulary)') + # fmt: on + + @classmethod + def build_model_base(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if not hasattr(args, "max_source_positions"): + args.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS + if not hasattr(args, "max_target_positions"): + args.max_target_positions = DEFAULT_MAX_TARGET_POSITIONS + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + def build_embedding(dictionary, embed_dim, path=None, num_embed_chunks=1): + assert embed_dim % num_embed_chunks == 0, ( + f"Number of embedding chunks = {num_embed_chunks} should be " + + f"divisible by the embedding dimension = {embed_dim}" + ) + assert path is None or num_embed_chunks == 1, ( + "Loading embedding from a path with number of embedding chunks > 1" + + " is not yet supported" + ) + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + # if provided, load from preloaded dictionaries + if path: + emb = Embedding(num_embeddings, embed_dim, padding_idx) + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + else: + embed_chunk_dim = embed_dim // num_embed_chunks + emb = nn.ModuleList() + for i in range(num_embed_chunks): + emb.append(Embedding(num_embeddings, embed_chunk_dim, padding_idx)) + return emb + + num_embed_chunks = args.num_embedding_chunks + if args.share_all_embeddings: + if src_dict != tgt_dict: + raise ValueError("--share-all-embeddings requires a joined dictionary") + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = build_embedding( + src_dict, + args.encoder_embed_dim, + args.encoder_embed_path, + num_embed_chunks, + ) + decoder_embed_tokens = encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + assert args.share_decoder_input_output_embed or num_embed_chunks == 1, ( + "Not sharing decoder I/O embeddings is not yet supported with number of " + + "embedding chunks > 1" + ) + encoder_embed_tokens = build_embedding( + src_dict, + args.encoder_embed_dim, + args.encoder_embed_path, + num_embed_chunks, + ) + decoder_embed_tokens = build_embedding( + tgt_dict, + args.decoder_embed_dim, + args.decoder_embed_path, + num_embed_chunks, + ) + + encoder = cls.build_encoder(args, src_dict, encoder_embed_tokens) + decoder = cls.build_decoder(args, tgt_dict, decoder_embed_tokens) + return (encoder, decoder) + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerDecoder(args, tgt_dict, embed_tokens) + + @classmethod + def build_model(cls, args, task): + encoder, decoder = cls.build_model_base(args, task) + return PipelineParallelTransformerModel( + encoder=encoder, + decoder=decoder, + balance=utils.eval_str_list(args.pipeline_balance, type=int), + devices=utils.eval_str_list(args.pipeline_devices, type=int), + chunks=args.pipeline_chunks, + checkpoint=args.pipeline_checkpoint, + ) + + def output_layer(self, features, **kwargs): + """Project features to the default output size (typically vocabulary size).""" + return self.decoder.output_layer(features, **kwargs) + + def max_positions(self): + """Maximum length supported by the model.""" + return (self.encoder_max_positions, self.decoder_max_positions) + + def max_positions_helper( + self, embedding_layer, max_positions_field="max_source_positions" + ): + """Maximum input length supported by the encoder or decoder.""" + if embedding_layer.embed_positions is None: + return getattr(embedding_layer, max_positions_field) + return min( + getattr(embedding_layer, max_positions_field), + embedding_layer.embed_positions.max_positions, + ) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + """Get normalized probabilities (or log probs) from a net's output.""" + + if hasattr(self, "adaptive_softmax") and self.adaptive_softmax is not None: + if sample is not None: + assert "target" in sample + target = sample["target"] + else: + target = None + out = self.adaptive_softmax.get_log_prob(net_output, target=target) + return out.exp_() if not log_probs else out + + # A Pipe() module returns a tuple of tensors as the output. + # In this case, the tuple has one element - the output tensor of logits + logits = net_output if isinstance(net_output, torch.Tensor) else net_output[0] + if log_probs: + return utils.log_softmax(logits, dim=-1, onnx_trace=False) + else: + return utils.softmax(logits, dim=-1, onnx_trace=False) + + def max_decoder_positions(self): + """Maximum length supported by the decoder.""" + return self.decoder_max_positions + + def load_state_dict(self, state_dict, strict=True, model_cfg=None): + """Copies parameters and buffers from *state_dict* into this module and + its descendants. + + Overrides the method in :class:`nn.Module`. Compared with that method + this additionally "upgrades" *state_dicts* from old checkpoints. + """ + self.upgrade_state_dict(state_dict) + is_regular_transformer = not any("model.partitions" in k for k in state_dict) + if is_regular_transformer: + state_dict = self.convert_to_pipeline_parallel_state_dict(state_dict) + return super().load_state_dict(state_dict, strict) + + def convert_to_pipeline_parallel_state_dict(self, state_dict): + new_state_dict = self.state_dict() + encoder_layer_idx = 0 + decoder_layer_idx = 0 + encoder_key_suffixes = [ + "self_attn.k_proj.weight", + "self_attn.k_proj.bias", + "self_attn.v_proj.weight", + "self_attn.v_proj.bias", + "self_attn.q_proj.weight", + "self_attn.q_proj.bias", + "self_attn.out_proj.weight", + "self_attn.out_proj.bias", + "self_attn_layer_norm.weight", + "self_attn_layer_norm.bias", + "fc1.weight", + "fc1.bias", + "fc2.weight", + "fc2.bias", + "final_layer_norm.weight", + "final_layer_norm.bias", + ] + decoder_key_suffixes = [ + "self_attn.k_proj.weight", + "self_attn.k_proj.bias", + "self_attn.v_proj.weight", + "self_attn.v_proj.bias", + "self_attn.q_proj.weight", + "self_attn.q_proj.bias", + "self_attn.out_proj.weight", + "self_attn.out_proj.bias", + "self_attn_layer_norm.weight", + "self_attn_layer_norm.bias", + "encoder_attn.k_proj.weight", + "encoder_attn.k_proj.bias", + "encoder_attn.v_proj.weight", + "encoder_attn.v_proj.bias", + "encoder_attn.q_proj.weight", + "encoder_attn.q_proj.bias", + "encoder_attn.out_proj.weight", + "encoder_attn.out_proj.bias", + "encoder_attn_layer_norm.weight", + "encoder_attn_layer_norm.bias", + "fc1.weight", + "fc1.bias", + "fc2.weight", + "fc2.bias", + "final_layer_norm.weight", + "final_layer_norm.bias", + ] + for pid, partition in enumerate(self.model.partitions): + logger.info(f"Begin Partition {pid}") + for mid, module in enumerate(partition): + # fmt: off + if isinstance(module, TransformerEncoderEmbedding): + new_state_dict[f'model.partitions.{pid}.{mid}.embed_tokens.weight'] = state_dict['encoder.embed_tokens.weight'] + new_state_dict[f'model.partitions.{pid}.{mid}.embed_positions._float_tensor'] = state_dict['encoder.embed_positions._float_tensor'] + if isinstance(module, TransformerEncoderLayer): + for suffix in encoder_key_suffixes: + new_state_dict[f'model.partitions.{pid}.{mid}.{suffix}'] = state_dict[f'encoder.layers.{encoder_layer_idx}.{suffix}'] + encoder_layer_idx += 1 + if isinstance(module, TransformerDecoderLayer): + for suffix in decoder_key_suffixes: + new_state_dict[f'model.partitions.{pid}.{mid}.{suffix}'] = state_dict[f'decoder.layers.{decoder_layer_idx}.{suffix}'] + decoder_layer_idx += 1 + if isinstance(module, TransformerEncoderLayerNorm): + if 'encoder.layer_norm.weight' in state_dict: + new_state_dict[f'model.partitions.{pid}.{mid}.layer_norm.weight'] = state_dict['encoder.layer_norm.weight'] + new_state_dict[f'model.partitions.{pid}.{mid}.layer_norm.bias'] = state_dict['encoder.layer_norm.bias'] + if isinstance(module, TransformerDecoderEmbedding): + new_state_dict[f'model.partitions.{pid}.{mid}.embed_tokens.weight'] = state_dict['decoder.embed_tokens.weight'] + new_state_dict[f'model.partitions.{pid}.{mid}.embed_positions._float_tensor'] = state_dict['decoder.embed_positions._float_tensor'] + if isinstance(module, TransformerDecoderOutputLayer): + new_state_dict[f'model.partitions.{pid}.{mid}.output_projection.weight'] = state_dict['decoder.output_projection.weight'] + # fmt: on + return new_state_dict + + +class TransformerEncoder(FairseqEncoder): + """ + Transformer encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`TransformerEncoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_tokens (torch.nn.Embedding): input embedding + """ + + def __init__(self, args, dictionary, embed_tokens, encoder_module_list=None): + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + import_pipe() + self.use_pipeline = encoder_module_list is not None + if not self.use_pipeline: + self.embedding_layer = TransformerEncoderEmbedding(args, embed_tokens) + self.encoder_layers = nn.Sequential(*[TransformerEncoderLayer(args) for i in range(args.encoder_layers)]) + if isinstance(embed_tokens, nn.ModuleList): + emb_dim = sum(e.embedding_dim for e in embed_tokens) + else: + emb_dim = embed_tokens.embedding_dim + self.final_layer_norm = TransformerEncoderLayerNorm(args, emb_dim) + else: + encoder_balance = utils.eval_str_list( + args.pipeline_encoder_balance, type=int + ) + encoder_devices = utils.eval_str_list( + args.pipeline_encoder_devices, type=int + ) + assert sum(encoder_balance) == len(encoder_module_list), ( + f"Sum of encoder_balance={encoder_balance} is not equal " + + f"to num_encoder_modules={len(encoder_module_list)}" + ) + if TORCH_PIPE: + self.model = Pipe( + module=partition_model(nn.Sequential(*encoder_module_list), encoder_balance, encoder_devices), + chunks=args.pipeline_chunks, + checkpoint=args.pipeline_checkpoint, + ) + else: + self.model = Pipe( + module=nn.Sequential(*encoder_module_list), + balance=encoder_balance, + devices=encoder_devices, + chunks=args.pipeline_chunks, + checkpoint=args.pipeline_checkpoint, + ) + + def forward(self, src_tokens, src_lengths): + """ + Args: + input_tuple( + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + ) + + Returns: + output_tuple( + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - prev_output_tokens + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + ) + """ + dummy_prev_output_tokens = torch.zeros( + 1, dtype=src_tokens.dtype, device=src_tokens.device + ) + input_tuple = (src_tokens, src_lengths, dummy_prev_output_tokens) + if self.use_pipeline: + input_tuple = tuple(i.to(self.model.devices[0]) for i in input_tuple) + if TORCH_PIPE: + encoder_out = self.model(input_tuple).local_value() + else: + encoder_out = self.model(input_tuple) + else: + encoder_embed_output_tuple = self.embedding_layer(input_tuple) + encoder_layers_output = self.encoder_layers(encoder_embed_output_tuple) + encoder_out = self.final_layer_norm(encoder_layers_output) + # first element is the encoder output + # second element is the encoder padding mask + # the remaining elements of EncoderOut are not computed by + # the PipelineParallelTransformer + return EncoderOut(encoder_out[0], encoder_out[1], None, None, None, None) + + def reorder_encoder_out(self, encoder_out, new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + if encoder_out.encoder_out is not None: + encoder_out = encoder_out._replace( + encoder_out=encoder_out.encoder_out.index_select(1, new_order) + ) + if encoder_out.encoder_padding_mask is not None: + encoder_out = encoder_out._replace( + encoder_padding_mask=encoder_out.encoder_padding_mask.index_select( + 0, new_order + ) + ) + if encoder_out.encoder_embedding is not None: + encoder_out = encoder_out._replace( + encoder_embedding=encoder_out.encoder_embedding.index_select( + 0, new_order + ) + ) + if encoder_out.encoder_states is not None: + for idx, state in enumerate(encoder_out.encoder_states): + encoder_out.encoder_states[idx] = state.index_select(1, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + if self.embedding_layer.embed_positions is None: + return self.embedding_layer.max_source_positions + return min( + self.embedding_layer.max_source_positions, + self.embedding_layer.embed_positions.max_positions, + ) + + +class TransformerDecoder(FairseqDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, + args, + dictionary, + embed_tokens, + no_encoder_attn=False, + decoder_module_list=None, + ): + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + import_pipe() + self.use_pipeline = decoder_module_list is not None + if not self.use_pipeline: + self.embedding_layer = TransformerDecoderEmbedding(args, embed_tokens) + self.decoder_layers = nn.Sequential(*[ + TransformerDecoderLayer(args, no_encoder_attn) + for _ in range(args.decoder_layers) + ]) + self.decoder_output_layer = TransformerDecoderOutputLayer( + args, embed_tokens, dictionary + ) + else: + decoder_balance = utils.eval_str_list( + args.pipeline_decoder_balance, type=int + ) + decoder_devices = utils.eval_str_list( + args.pipeline_decoder_devices, type=int + ) + assert sum(decoder_balance) == len(decoder_module_list), ( + f"Sum of decoder_balance={decoder_balance} is not equal " + + f"to num_decoder_modules={len(decoder_module_list)}" + ) + if TORCH_PIPE: + self.model = Pipe( + module=partition_model(nn.Sequential(*decoder_module_list), decoder_balance, decoder_devices), + chunks=args.pipeline_chunks, + checkpoint=args.pipeline_checkpoint, + ) + else: + self.model = Pipe( + module=nn.Sequential(*decoder_module_list), + balance=decoder_balance, + devices=decoder_devices, + chunks=args.pipeline_chunks, + checkpoint=args.pipeline_checkpoint, + ) + + def forward( + self, + prev_output_tokens, + encoder_out=None, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False). + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + input_tuple = ( + encoder_out.encoder_out, + encoder_out.encoder_padding_mask, + prev_output_tokens, + ) + if self.use_pipeline: + input_tuple = tuple(i.to(self.model.devices[0]) for i in input_tuple) + if TORCH_PIPE: + return (self.model(input_tuple).local_value(),) + else: + return (self.model(input_tuple),) + else: + embed_layer_output = self.embedding_layer(input_tuple) + state = self.decoder_layers(embed_layer_output) + return (self.decoder_output_layer(state),) + + def output_layer(self, features, **kwargs): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + # project back to size of vocabulary + if self.share_input_output_embed: + return F.linear(features, self.embed_tokens.weight) + else: + return F.linear(features, self.embed_out) + else: + return features + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embedding_layer.embed_positions is None: + return self.embedding_layer.max_target_positions + return min( + self.embedding_layer.max_target_positions, + self.embedding_layer.embed_positions.max_positions, + ) + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + not hasattr(self, "_future_mask") + or self._future_mask is None + or self._future_mask.device != tensor.device + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(tensor.new(dim, dim)), 1 + ) + return self._future_mask[:dim, :dim] + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + + for i in range(len(self.layers)): + # update layer norms + layer_norm_map = { + "0": "self_attn_layer_norm", + "1": "encoder_attn_layer_norm", + "2": "final_layer_norm", + } + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layers.{}.layer_norms.{}.{}".format(name, i, old, m) + if k in state_dict: + state_dict[ + "{}.layers.{}.{}.{}".format(name, i, new, m) + ] = state_dict[k] + del state_dict[k] + + version_key = "{}.version".format(name) + if utils.item(state_dict.get(version_key, torch.Tensor([1]))[0]) <= 2: + # earlier checkpoints did not normalize after the stack of layers + self.layer_norm = None + self.normalize = False + state_dict[version_key] = torch.Tensor([1]) + + return state_dict + + +@register_model_architecture( + "pipeline_parallel_transformer", "transformer_iwslt_de_en_pipeline_parallel" +) +def transformer_iwslt_de_en_dist(args): + transformer_iwslt_de_en(args) + + +@register_model_architecture( + "pipeline_parallel_transformer", "transformer_wmt_en_de_big_pipeline_parallel" +) +def transformer_wmt_en_de_big_dist(args): + transformer_wmt_en_de_big(args) diff --git a/fairseq/fairseq/model_parallel/models/roberta/__init__.py b/fairseq/fairseq/model_parallel/models/roberta/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..117827c3e9c176477f33e3a6fd7fe19a922411a2 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/roberta/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .model import * # noqa diff --git a/fairseq/fairseq/model_parallel/models/roberta/model.py b/fairseq/fairseq/model_parallel/models/roberta/model.py new file mode 100644 index 0000000000000000000000000000000000000000..77a80ef72057219110b34678a38705549910edd3 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/roberta/model.py @@ -0,0 +1,225 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +RoBERTa: A Robustly Optimized BERT Pretraining Approach. +""" + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.model_parallel.models.transformer import ModelParallelTransformerEncoder +from fairseq.models import register_model, register_model_architecture +from fairseq.models.roberta import ( + roberta_base_architecture, + roberta_prenorm_architecture, + RobertaEncoder, + RobertaModel, +) +from fairseq.modules import LayerNorm + + +try: + from fairseq.model_parallel.megatron.mpu import ( + copy_to_model_parallel_region, + gather_from_model_parallel_region, + ColumnParallelLinear, + VocabParallelEmbedding, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + +logger = logging.getLogger(__name__) + + +@register_model("model_parallel_roberta") +class ModelParallelRobertaModel(RobertaModel): + def __init__(self, args, encoder): + super().__init__(args, encoder) + + self.classification_heads = nn.ModuleDict() + + @staticmethod + def add_args(parser): + RobertaModel.add_args(parser) + parser.add_argument( + "--no-final-layer-norm", + action="store_true", + help=( + "don't add final layernorm (only applicable when " + "--encoder-normalize-before=True" + ), + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present + base_architecture(args) + + task.source_dictionary.pad_to_multiple_(args.model_parallel_size * 8) + task.target_dictionary.pad_to_multiple_(args.model_parallel_size * 8) + + if not hasattr(args, "max_positions"): + args.max_positions = args.tokens_per_sample + + if getattr(args, "untie_weights_roberta", False): + raise NotImplementedError( + "--untie-weights-roberta is not supported in model parallel mode" + ) + + encoder = ModelParallelRobertaEncoder(args, task.source_dictionary) + return cls(args, encoder) + + def forward( + self, + src_tokens, + features_only=False, + return_all_hiddens=False, + classification_head_name=None, + **kwargs + ): + if classification_head_name is not None: + features_only = True + + x, extra = self.encoder(src_tokens, features_only, return_all_hiddens, **kwargs) + + if classification_head_name is not None: + x = self.classification_heads[classification_head_name](x) + return x, extra + + def register_classification_head( + self, name, num_classes=None, inner_dim=None, **kwargs + ): + """Register a classification head.""" + if name in self.classification_heads: + prev_num_classes = self.classification_heads[name].out_proj.out_features + prev_inner_dim = self.classification_heads[name].dense.out_features + if num_classes != prev_num_classes or inner_dim != prev_inner_dim: + logger.warning( + 're-registering head "{}" with num_classes {} (prev: {}) ' + "and inner_dim {} (prev: {})".format( + name, num_classes, prev_num_classes, inner_dim, prev_inner_dim + ) + ) + self.classification_heads[name] = ModelParallelRobertaClassificationHead( + self.args.encoder_embed_dim, + inner_dim or self.args.encoder_embed_dim, + num_classes, + self.args.pooler_activation_fn, + self.args.pooler_dropout, + ) + + +class ModelParallelRobertaLMHead(nn.Module): + """Head for masked language modeling.""" + + def __init__(self, embed_dim, output_dim, activation_fn, weight=None): + super().__init__() + self.dense = ColumnParallelLinear(embed_dim, embed_dim, gather_output=True) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.layer_norm = LayerNorm(embed_dim) + + if weight is None: + weight = nn.Linear(embed_dim, output_dim, bias=False).weight + self.weight = weight + self.bias = nn.Parameter(torch.zeros(output_dim)) + + def forward(self, features, masked_tokens=None, **kwargs): + # Only project the unmasked tokens while training, + # saves both memory and computation + if masked_tokens is not None: + features = features[masked_tokens, :] + + x = self.dense(features) + x = self.activation_fn(x) + x = self.layer_norm(x) + + x = copy_to_model_parallel_region(x) + # project back to size of vocabulary with bias + x = F.linear(x, self.weight) + x = gather_from_model_parallel_region(x).contiguous() + x = x + self.bias + return x + + +class ModelParallelRobertaClassificationHead(nn.Module): + """Head for sentence-level classification tasks.""" + + def __init__( + self, input_dim, inner_dim, num_classes, activation_fn, pooler_dropout + ): + super().__init__() + self.dense = ColumnParallelLinear(input_dim, inner_dim, gather_output=True) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(inner_dim, num_classes) + + def forward(self, features, **kwargs): + x = features[:, 0, :] # take <s> token (equiv. to [CLS]) + x = self.dropout(x) + x = self.dense(x) + x = self.activation_fn(x) + x = self.dropout(x) + x = self.out_proj(x) + return x + + +class ModelParallelRobertaEncoder(RobertaEncoder): + """RoBERTa encoder.""" + + def __init__(self, args, dictionary): + super().__init__(args, dictionary) + assert not self.args.untie_weights_roberta + + def build_embedding(self, vocab_size, embedding_dim, padding_idx): + return VocabParallelEmbedding(vocab_size, embedding_dim, padding_idx) + + def build_encoder(self, args, dictionary, embed_tokens): + return ModelParallelTransformerEncoder(args, dictionary, embed_tokens) + + def build_lm_head(self, embed_dim, output_dim, activation_fn, weight): + return ModelParallelRobertaLMHead(embed_dim, output_dim, activation_fn, weight) + + +@register_model_architecture("model_parallel_roberta", "model_parallel_roberta") +def base_architecture(args): + args.no_final_layer_norm = getattr(args, "no_final_layer_norm", False) + # model parallel RoBERTa defaults to "Pre-LN" formulation + roberta_prenorm_architecture(args) + + +# earlier versions of model parallel RoBERTa removed the final layer norm +@register_model_architecture("model_parallel_roberta", "model_parallel_roberta_v1") +def model_parallel_roberta_v1_architecture(args): + args.no_final_layer_norm = getattr(args, "no_final_layer_norm", True) + base_architecture(args) + + +@register_model_architecture( + "model_parallel_roberta", "model_parallel_roberta_postnorm" +) +def model_parallel_roberta_postnorm_architecture(args): + # the original BERT/RoBERTa uses the "Post-LN" formulation + roberta_base_architecture(args) + + +@register_model_architecture("model_parallel_roberta", "model_parallel_roberta_base") +def model_parallel_roberta_base_architecture(args): + base_architecture(args) + + +@register_model_architecture("model_parallel_roberta", "model_parallel_roberta_large") +def model_parallel_roberta_large_architecture(args): + args.encoder_layers = getattr(args, "encoder_layers", 24) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + base_architecture(args) diff --git a/fairseq/fairseq/model_parallel/models/transformer.py b/fairseq/fairseq/model_parallel/models/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..6b330ef1b7f7a506e7e8176f20a0e722b5fd5149 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/transformer.py @@ -0,0 +1,121 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch.nn as nn +from fairseq.model_parallel.modules import ( + ModelParallelTransformerDecoderLayer, + ModelParallelTransformerEncoderLayer, +) +from fairseq.models import register_model +from fairseq.models.transformer import ( + TransformerDecoder, + TransformerEncoder, + TransformerModel, +) + + +try: + from fairseq.model_parallel.megatron.mpu import ( + copy_to_model_parallel_region, + gather_from_model_parallel_region, + VocabParallelEmbedding, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +logger = logging.getLogger(__name__) + + +@register_model("model_parallel_transformer") +class ModelParallelTransformerModel(TransformerModel): + """ + Model parallel Transformer model. + """ + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + if not has_megatron_submodule: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + dictionary.pad_to_multiple_(args.model_parallel_size * 8) + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + + def _vocab_init(tensor, **kwargs): + nn.init.normal_(tensor, mean=0, std=num_embeddings ** -0.5) + nn.init.constant_(tensor[1], 0) + + emb = VocabParallelEmbedding( + num_embeddings, embed_dim, padding_idx, init_method=_vocab_init + ) + # if provided, load from preloaded dictionaries + if path: + raise NotImplementedError( + "Loading of embedding from path is not supported for model parallel" + ) + return emb + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return ModelParallelTransformerEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return ModelParallelTransformerDecoder( + args, + tgt_dict, + embed_tokens, + no_encoder_attn=getattr(args, "no_cross_attention", False), + ) + + +class ModelParallelTransformerEncoder(TransformerEncoder): + """ + Model parallel Transformer encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`ModelParallelTransformerEncoderLayer`. + """ + + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens) + + if args.no_final_layer_norm: + self.layer_norm = None + + def build_encoder_layer(self, args): + return ModelParallelTransformerEncoderLayer(args) + + +class ModelParallelTransformerDecoder(TransformerDecoder): + """ + Model Parallel Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`ModelParallelTransformerDecoderLayer`. + """ + + def build_decoder_layer(self, args, no_encoder_attn=False): + return ModelParallelTransformerDecoderLayer(args, no_encoder_attn) + + def output_layer(self, features, **kwargs): + """Project features to the vocabulary size.""" + if not self.share_input_output_embed: + raise NotImplementedError( + "Model parallel training currently requires --share-decoder-input-output-embed" + ) + + features = copy_to_model_parallel_region(features) + + # project back to size of vocabulary + x = self.output_projection(features) + + if getattr(self.args, "criterion") != "vocab_parallel_cross_entropy": + x = gather_from_model_parallel_region(x).contiguous() + return x diff --git a/fairseq/fairseq/model_parallel/models/transformer_lm.py b/fairseq/fairseq/model_parallel/models/transformer_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..dc52f6e8dd3899b6bf9bebae7415cee20baf9884 --- /dev/null +++ b/fairseq/fairseq/model_parallel/models/transformer_lm.py @@ -0,0 +1,174 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +from fairseq.model_parallel.models.transformer import ModelParallelTransformerDecoder +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer_lm import TransformerLanguageModel + + +try: + from fairseq.model_parallel.megatron.mpu import VocabParallelEmbedding + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +DEFAULT_MAX_TARGET_POSITIONS = 1024 + + +@register_model("model_parallel_transformer_lm") +class ModelParallelTransformerLanguageModel(TransformerLanguageModel): + + @staticmethod + def add_args(parser): + TransformerLanguageModel.add_args(parser) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + if not has_megatron_submodule: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + + # make sure all arguments are present in older models + base_lm_architecture(args) + + task.source_dictionary.pad_to_multiple_(args.model_parallel_size * 8) + task.target_dictionary.pad_to_multiple_(args.model_parallel_size * 8) + + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = getattr( + args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS + ) + + if args.character_embeddings: + raise NotImplementedError( + "Character embeddings is not supported for model parallel" + ) + elif args.adaptive_input: + raise NotImplementedError( + "Adaptive input is not supported for model parallel" + ) + else: + embed_tokens = cls.build_embedding( + args, task.source_dictionary, args.decoder_input_dim + ) + + decoder = ModelParallelTransformerDecoder( + args, + task.target_dictionary, + embed_tokens, + no_encoder_attn=True, + ) + return cls(decoder) + + @staticmethod + def add_args(parser): + TransformerLanguageModel.add_args(parser) + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + def _vocab_init(tensor, **kwargs): + nn.init.normal_(tensor, mean=0, std=embed_dim ** -0.5) + nn.init.constant_(tensor[1], 0) + + embed_tokens = VocabParallelEmbedding( + len(dictionary), embed_dim, dictionary.pad(), init_method=_vocab_init + ) + return embed_tokens + + +def base_lm_architecture(args): + # backward compatibility for older model checkpoints + if hasattr(args, "no_tie_adaptive_proj"): + # previous models defined --no-tie-adaptive-proj, so use the existence of + # that option to determine if this is an "old" model checkpoint + args.no_decoder_final_norm = True # old models always set this to True + if args.no_tie_adaptive_proj is False: + args.tie_adaptive_proj = True + if hasattr(args, "decoder_final_norm"): + args.no_decoder_final_norm = not args.decoder_final_norm + + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.relu_dropout = getattr(args, "relu_dropout", 0.0) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 2048) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + # Model training is not stable without this + args.decoder_normalize_before = True + args.no_decoder_final_norm = getattr(args, "no_decoder_final_norm", False) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.adaptive_softmax_factor = getattr(args, "adaptive_softmax_factor", 4) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.character_embeddings = getattr(args, "character_embeddings", False) + args.character_filters = getattr( + args, + "character_filters", + "[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]", + ) + args.character_embedding_dim = getattr(args, "character_embedding_dim", 4) + args.char_embedder_highway_layers = getattr(args, "char_embedder_highway_layers", 2) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.adaptive_input_factor = getattr(args, "adaptive_input_factor", 4) + args.adaptive_input_cutoff = getattr(args, "adaptive_input_cutoff", None) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.tie_adaptive_proj = getattr(args, "tie_adaptive_proj", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + args.decoder_layers_to_keep = getattr(args, "decoder_layers_to_keep", None) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0.0) + args.quant_noise_pq_block_size = getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = getattr(args, "quant_noise_scalar", 0.0) + args.add_bos_token = getattr(args, "add_bos_token", False) + + +@register_model_architecture("model_parallel_transformer_lm", "transformer_lm_megatron") +def transformer_lm_megatron(args): + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 3072) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 3072 * 4) + args.decoder_layers = getattr(args, "decoder_layers", 72) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 32) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.activation_fn = getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +@register_model_architecture( + "model_parallel_transformer_lm", "transformer_lm_megatron_11b" +) +def transformer_lm_megatron_11b(args): + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 3072) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 3072 * 6) + args.decoder_layers = getattr(args, "decoder_layers", 72) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 32) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.activation_fn = getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) diff --git a/fairseq/fairseq/model_parallel/modules/__init__.py b/fairseq/fairseq/model_parallel/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..11603217a188f420ea849ae0fde19979736ba208 --- /dev/null +++ b/fairseq/fairseq/model_parallel/modules/__init__.py @@ -0,0 +1,17 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +from .multihead_attention import ModelParallelMultiheadAttention +from .transformer_layer import ( + ModelParallelTransformerEncoderLayer, + ModelParallelTransformerDecoderLayer, +) + +__all__ = [ + "ModelParallelMultiheadAttention", + "ModelParallelTransformerEncoderLayer", + "ModelParallelTransformerDecoderLayer", +] diff --git a/fairseq/fairseq/model_parallel/modules/multihead_attention.py b/fairseq/fairseq/model_parallel/modules/multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..8eb9d09dad37ab132295166d691873beec63eaf1 --- /dev/null +++ b/fairseq/fairseq/model_parallel/modules/multihead_attention.py @@ -0,0 +1,349 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, Optional, Tuple + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from torch import Tensor, nn + + +try: + from fairseq.model_parallel.megatron.mpu import ( + get_cuda_rng_tracker, + get_model_parallel_world_size, + ColumnParallelLinear, + RowParallelLinear, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +@with_incremental_state +class ModelParallelMultiheadAttention(nn.Module): + """Model parallel Multi-headed attention. + This performs the Multi-headed attention over multiple gpus. + + See "Megatron-LM: https://arxiv.org/pdf/1909.08053.pdf" for more details. + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + self_attention=False, + encoder_decoder_attention=False, + ): + super().__init__() + if not has_megatron_submodule: + raise ImportError( + "\n\nPlease install the megatron submodule:" + "\n\n git submodule update --init " + "fairseq/model_parallel/megatron" + ) + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim + + self.model_parallel_size = get_model_parallel_world_size() + + self.num_heads_partition = num_heads // self.model_parallel_size + assert ( + self.num_heads_partition * self.model_parallel_size == num_heads + ), "Number of heads must be divisible by model parallel size" + + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.scaling = self.head_dim ** -0.5 + + self.self_attention = self_attention + self.encoder_decoder_attention = encoder_decoder_attention + + assert ( + not self.self_attention or self.qkv_same_dim + ), "Self-attention requires query, key and value to be of the same size" + + self.k_proj = ColumnParallelLinear( + self.kdim, embed_dim, bias=bias, gather_output=False + ) + self.v_proj = ColumnParallelLinear( + self.vdim, embed_dim, bias=bias, gather_output=False + ) + self.q_proj = ColumnParallelLinear( + embed_dim, embed_dim, bias=bias, gather_output=False + ) + self.out_proj = RowParallelLinear( + embed_dim, embed_dim, bias=bias, input_is_parallel=True + ) + + def forward( + self, + query, + key: Optional[Tensor], + value: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + static_kv: bool = False, + attn_mask: Optional[Tensor] = None, + **unused_kwargs, + ) -> Tuple[Tensor, Optional[Tensor]]: + """Input shape: Time x Batch x Channel + + Args: + key_padding_mask (ByteTensor, optional): mask to exclude + keys that are pads, of shape `(batch, src_len)`, where + padding elements are indicated by 1s. + attn_mask (ByteTensor, optional): typically used to + implement causal attention, where the mask prevents the + attention from looking forward in time (default: None). + """ + tgt_len, bsz, embed_dim = query.size() + assert embed_dim == self.embed_dim + assert list(query.size()) == [tgt_len, bsz, embed_dim] + + is_tpu = query.device.type == "xla" + + if incremental_state is not None: + saved_state = self._get_input_buffer(incremental_state) + if saved_state is not None and "prev_key" in saved_state: + # previous time steps are cached - no need to recompute + # key and value if they are static + if static_kv: + assert self.encoder_decoder_attention and not self.self_attention + key = value = None + else: + saved_state = None + + if self.self_attention: + q = self.q_proj(query) + k = self.k_proj(query) + v = self.v_proj(query) + elif self.encoder_decoder_attention: + # encoder-decoder attention + q = self.q_proj(query) + if key is None: + assert value is None + k = v = None + else: + k = self.k_proj(key) + v = self.v_proj(key) + + else: + assert key is not None and value is not None + q = self.q_proj(query) + k = self.k_proj(key) + v = self.v_proj(value) + q *= self.scaling + + q = ( + q.contiguous() + .view(tgt_len, bsz * self.num_heads_partition, self.head_dim) + .transpose(0, 1) + ) + if k is not None: + k = ( + k.contiguous() + .view(-1, bsz * self.num_heads_partition, self.head_dim) + .transpose(0, 1) + ) + if v is not None: + v = ( + v.contiguous() + .view(-1, bsz * self.num_heads_partition, self.head_dim) + .transpose(0, 1) + ) + + if saved_state is not None: + # saved states are stored with shape (bsz, num_heads_partition, seq_len, head_dim) + if "prev_key" in saved_state: + _prev_key = saved_state["prev_key"] + assert _prev_key is not None + prev_key = _prev_key.view( + bsz * self.num_heads_partition, -1, self.head_dim + ) + if static_kv: + k = prev_key + else: + assert k is not None + k = torch.cat([prev_key, k], dim=1) + if "prev_value" in saved_state: + _prev_value = saved_state["prev_value"] + assert _prev_value is not None + prev_value = _prev_value.view( + bsz * self.num_heads_partition, -1, self.head_dim + ) + if static_kv: + v = prev_value + else: + assert v is not None + v = torch.cat([prev_value, v], dim=1) + prev_key_padding_mask: Optional[Tensor] = None + if "prev_key_padding_mask" in saved_state: + prev_key_padding_mask = saved_state["prev_key_padding_mask"] + assert k is not None and v is not None + key_padding_mask = ( + ModelParallelMultiheadAttention._append_prev_key_padding_mask( + key_padding_mask=key_padding_mask, + prev_key_padding_mask=prev_key_padding_mask, + batch_size=bsz, + src_len=k.size(1), + static_kv=static_kv, + ) + ) + + saved_state["prev_key"] = k.view( + bsz, self.num_heads_partition, -1, self.head_dim + ) + saved_state["prev_value"] = v.view( + bsz, self.num_heads_partition, -1, self.head_dim + ) + saved_state["prev_key_padding_mask"] = key_padding_mask + # In this branch incremental_state is never None + assert incremental_state is not None + incremental_state = self._set_input_buffer(incremental_state, saved_state) + assert k is not None + src_len = k.size(1) + + # This is part of a workaround to get around fork/join parallelism + # not supporting Optional types. + if key_padding_mask is not None and key_padding_mask.dim() == 0: + key_padding_mask = None + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + attn_weights = torch.bmm(q, k.transpose(1, 2)) + + assert list(attn_weights.size()) == [ + bsz * self.num_heads_partition, + tgt_len, + src_len, + ] + + if attn_mask is not None: + attn_mask = attn_mask.unsqueeze(0) + attn_weights += attn_mask + + if key_padding_mask is not None: + # don't attend to padding symbols + attn_weights = attn_weights.view( + bsz, self.num_heads_partition, tgt_len, src_len + ) + if not is_tpu: + attn_weights = attn_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool), + float("-inf"), + ) + else: + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf")) + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.view( + bsz * self.num_heads_partition, tgt_len, src_len + ) + + attn_weights_float = utils.softmax(attn_weights, dim=-1) + attn_weights = attn_weights_float.type_as(attn_weights) + + with get_cuda_rng_tracker().fork(): + attn_probs = self.dropout_module(attn_weights) + + assert v is not None + attn = torch.bmm(attn_probs, v) + assert list(attn.size()) == [ + bsz * self.num_heads_partition, + tgt_len, + self.head_dim, + ] + embed_dim_partition = embed_dim // self.model_parallel_size + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim_partition) + attn = self.out_proj(attn) + # return attn_weights None to keep the return type same as single gpu multihead attention + # This will be deprecated. + attn_weights: Optional[Tensor] = None + + return attn, attn_weights + + @staticmethod + def _append_prev_key_padding_mask( + key_padding_mask: Optional[Tensor], + prev_key_padding_mask: Optional[Tensor], + batch_size: int, + src_len: int, + static_kv: bool, + ) -> Optional[Tensor]: + # saved key padding masks have shape (bsz, seq_len) + if prev_key_padding_mask is not None and static_kv: + new_key_padding_mask = prev_key_padding_mask + elif prev_key_padding_mask is not None and key_padding_mask is not None: + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1 + ) + # During incremental decoding, as the padding token enters and + # leaves the frame, there will be a time when prev or current + # is None + elif prev_key_padding_mask is not None: + + filler = torch.zeros(batch_size, src_len - prev_key_padding_mask.size(1)) + if prev_key_padding_mask.is_cuda: + filler = filler.cuda() + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), filler.float()], dim=1 + ) + elif key_padding_mask is not None: + filler = torch.zeros(batch_size, src_len - key_padding_mask.size(1)) + if key_padding_mask.is_cuda: + filler = filler.cuda() + new_key_padding_mask = torch.cat( + [filler.float(), key_padding_mask.float()], dim=1 + ) + else: + new_key_padding_mask = prev_key_padding_mask + return new_key_padding_mask + + def reorder_incremental_state( + self, incremental_state: Dict[str, Dict[str, Optional[Tensor]]], new_order + ): + """Reorder buffered internal state (for incremental generation).""" + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + for k in input_buffer.keys(): + if input_buffer[k] is not None: + input_buffer[k] = input_buffer[k].index_select(0, new_order) + incremental_state = self._set_input_buffer(incremental_state, input_buffer) + return incremental_state + + def _get_input_buffer( + self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] + ) -> Dict[str, Optional[Tensor]]: + result = self.get_incremental_state(incremental_state, "attn_state") + if result is not None: + return result + else: + empty_result: Dict[str, Optional[Tensor]] = {} + return empty_result + + def _set_input_buffer( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + buffer: Dict[str, Optional[Tensor]], + ): + return self.set_incremental_state(incremental_state, "attn_state", buffer) diff --git a/fairseq/fairseq/model_parallel/modules/transformer_layer.py b/fairseq/fairseq/model_parallel/modules/transformer_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..7ab53c6e5f12f15562717effb86ab8cb8d6b4fa3 --- /dev/null +++ b/fairseq/fairseq/model_parallel/modules/transformer_layer.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.model_parallel.modules import ModelParallelMultiheadAttention +from fairseq.modules import TransformerDecoderLayer, TransformerEncoderLayer + + +try: + from fairseq.model_parallel.megatron.mpu import ( + ColumnParallelLinear, + RowParallelLinear, + ) + + has_megatron_submodule = True +except (ImportError, ModuleNotFoundError): + has_megatron_submodule = False + + +class ModelParallelTransformerEncoderLayer(TransformerEncoderLayer): + """Encoder layer block over multiple gpus. + + See "Megatron-LM: https://arxiv.org/pdf/1909.08053.pdf" for more details. + """ + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + if q_noise > 0: + raise NotImplementedError + return ColumnParallelLinear(input_dim, output_dim, gather_output=False) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + if q_noise > 0: + raise NotImplementedError + return RowParallelLinear(input_dim, output_dim, input_is_parallel=True) + + def build_self_attention(self, embed_dim, args, **unused_kwargs): + return ModelParallelMultiheadAttention( + embed_dim, + args.encoder_attention_heads, + dropout=args.attention_dropout, + self_attention=True, + ) + + +class ModelParallelTransformerDecoderLayer(TransformerDecoderLayer): + """Decoder layer block. + + See "Megatron-LM: https://arxiv.org/pdf/1909.08053.pdf" for more details. + """ + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + if q_noise > 0: + raise NotImplementedError + return ColumnParallelLinear(input_dim, output_dim, gather_output=False) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + if q_noise > 0: + raise NotImplementedError + return RowParallelLinear(input_dim, output_dim, input_is_parallel=True) + + def build_self_attention(self, embed_dim, args, **unused_kwargs): + return ModelParallelMultiheadAttention( + embed_dim=embed_dim, + num_heads=args.decoder_attention_heads, + dropout=args.attention_dropout, + self_attention=not getattr(args, "cross_self_attention", False), + ) + + def build_encoder_attention(self, embed_dim, args, **unused_kwargs): + return ModelParallelMultiheadAttention( + embed_dim=embed_dim, + num_heads=args.decoder_attention_heads, + kdim=getattr(args, "encoder_embed_dim", None), + vdim=getattr(args, "encoder_embed_dim", None), + dropout=args.attention_dropout, + encoder_decoder_attention=True, + ) diff --git a/fairseq/fairseq/models/__init__.py b/fairseq/fairseq/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..337c77ac7bfb7e11a0662b86b98c4c0a02da26df --- /dev/null +++ b/fairseq/fairseq/models/__init__.py @@ -0,0 +1,236 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import argparse +import importlib +import os +from contextlib import ExitStack + +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import merge_with_parent +from hydra.core.config_store import ConfigStore +from omegaconf import open_dict, OmegaConf + +from .composite_encoder import CompositeEncoder +from .distributed_fairseq_model import DistributedFairseqModel +from .fairseq_decoder import FairseqDecoder +from .fairseq_encoder import FairseqEncoder +from .fairseq_incremental_decoder import FairseqIncrementalDecoder +from .fairseq_model import ( + BaseFairseqModel, + FairseqEncoderDecoderModel, + FairseqEncoderModel, + FairseqLanguageModel, + FairseqModel, + FairseqMultiModel, +) + + +MODEL_REGISTRY = {} +MODEL_DATACLASS_REGISTRY = {} +ARCH_MODEL_REGISTRY = {} +ARCH_MODEL_NAME_REGISTRY = {} +ARCH_MODEL_INV_REGISTRY = {} +ARCH_CONFIG_REGISTRY = {} + + +__all__ = [ + "BaseFairseqModel", + "CompositeEncoder", + "DistributedFairseqModel", + "FairseqDecoder", + "FairseqEncoder", + "FairseqEncoderDecoderModel", + "FairseqEncoderModel", + "FairseqIncrementalDecoder", + "FairseqLanguageModel", + "FairseqModel", + "FairseqMultiModel", +] + + +def build_model(cfg: FairseqDataclass, task): + + model = None + model_type = getattr(cfg, "_name", None) or getattr(cfg, "arch", None) + + if not model_type and len(cfg) == 1: + # this is hit if config object is nested in directory that is named after model type + + model_type = next(iter(cfg)) + if model_type in MODEL_DATACLASS_REGISTRY: + cfg = cfg[model_type] + else: + raise Exception( + "Could not infer model type from directory. Please add _name field to indicate model type. " + "Available models: " + + str(MODEL_DATACLASS_REGISTRY.keys()) + + " Requested model type: " + + model_type + ) + + if model_type in ARCH_MODEL_REGISTRY: + # case 1: legacy models + model = ARCH_MODEL_REGISTRY[model_type] + elif model_type in MODEL_DATACLASS_REGISTRY: + # case 2: config-driven models + model = MODEL_REGISTRY[model_type] + + if model_type in MODEL_DATACLASS_REGISTRY: + # set defaults from dataclass. note that arch name and model name can be the same + dc = MODEL_DATACLASS_REGISTRY[model_type] + + if isinstance(cfg, argparse.Namespace): + cfg = dc.from_namespace(cfg) + else: + cfg = merge_with_parent(dc(), cfg) + else: + if model_type in ARCH_CONFIG_REGISTRY: + with open_dict(cfg) if OmegaConf.is_config(cfg) else ExitStack(): + # this calls the different "arch" functions (like base_architecture()) that you indicate + # if you specify --arch on the command line. this is only applicable to the old argparse based models + # hydra models should expose different architectures via different config files + # it will modify the cfg object and default parameters according to the arch + ARCH_CONFIG_REGISTRY[model_type](cfg) + + assert model is not None, ( + f"Could not infer model type from {cfg}. " + "Available models: {}".format( + MODEL_DATACLASS_REGISTRY.keys() + ) + + f" Requested model type: {model_type}" + ) + + return model.build_model(cfg, task) + + +def register_model(name, dataclass=None): + """ + New model types can be added to fairseq with the :func:`register_model` + function decorator. + + For example:: + + @register_model('lstm') + class LSTM(FairseqEncoderDecoderModel): + (...) + + .. note:: All models must implement the :class:`BaseFairseqModel` interface. + Typically you will extend :class:`FairseqEncoderDecoderModel` for + sequence-to-sequence tasks or :class:`FairseqLanguageModel` for + language modeling tasks. + + Args: + name (str): the name of the model + """ + + def register_model_cls(cls): + if name in MODEL_REGISTRY: + raise ValueError("Cannot register duplicate model ({})".format(name)) + if not issubclass(cls, BaseFairseqModel): + raise ValueError( + "Model ({}: {}) must extend BaseFairseqModel".format(name, cls.__name__) + ) + MODEL_REGISTRY[name] = cls + if dataclass is not None and not issubclass(dataclass, FairseqDataclass): + raise ValueError( + "Dataclass {} must extend FairseqDataclass".format(dataclass) + ) + + cls.__dataclass = dataclass + if dataclass is not None: + MODEL_DATACLASS_REGISTRY[name] = dataclass + + cs = ConfigStore.instance() + node = dataclass() + node._name = name + cs.store(name=name, group="model", node=node, provider="fairseq") + + @register_model_architecture(name, name) + def noop(_): + pass + + return cls + + return register_model_cls + + +def register_model_architecture(model_name, arch_name): + """ + New model architectures can be added to fairseq with the + :func:`register_model_architecture` function decorator. After registration, + model architectures can be selected with the ``--arch`` command-line + argument. + + For example:: + + @register_model_architecture('lstm', 'lstm_luong_wmt_en_de') + def lstm_luong_wmt_en_de(cfg): + args.encoder_embed_dim = getattr(cfg.model, 'encoder_embed_dim', 1000) + (...) + + The decorated function should take a single argument *cfg*, which is a + :class:`omegaconf.DictConfig`. The decorated function should modify these + arguments in-place to match the desired architecture. + + Args: + model_name (str): the name of the Model (Model must already be + registered) + arch_name (str): the name of the model architecture (``--arch``) + """ + + def register_model_arch_fn(fn): + if model_name not in MODEL_REGISTRY: + raise ValueError( + "Cannot register model architecture for unknown model type ({})".format( + model_name + ) + ) + if arch_name in ARCH_MODEL_REGISTRY: + raise ValueError( + "Cannot register duplicate model architecture ({})".format(arch_name) + ) + if not callable(fn): + raise ValueError( + "Model architecture must be callable ({})".format(arch_name) + ) + ARCH_MODEL_REGISTRY[arch_name] = MODEL_REGISTRY[model_name] + ARCH_MODEL_NAME_REGISTRY[arch_name] = model_name + ARCH_MODEL_INV_REGISTRY.setdefault(model_name, []).append(arch_name) + ARCH_CONFIG_REGISTRY[arch_name] = fn + return fn + + return register_model_arch_fn + + +def import_models(models_dir, namespace): + for file in os.listdir(models_dir): + path = os.path.join(models_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + model_name = file[: file.find(".py")] if file.endswith(".py") else file + importlib.import_module(namespace + "." + model_name) + + # extra `model_parser` for sphinx + if model_name in MODEL_REGISTRY: + parser = argparse.ArgumentParser(add_help=False) + group_archs = parser.add_argument_group("Named architectures") + group_archs.add_argument( + "--arch", choices=ARCH_MODEL_INV_REGISTRY[model_name] + ) + group_args = parser.add_argument_group( + "Additional command-line arguments" + ) + MODEL_REGISTRY[model_name].add_args(group_args) + globals()[model_name + "_parser"] = parser + + +# automatically import any Python files in the models/ directory +models_dir = os.path.dirname(__file__) +import_models(models_dir, "fairseq.models") diff --git a/fairseq/fairseq/models/bart/__init__.py b/fairseq/fairseq/models/bart/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a701923f7e5a2a8aa9b75e5580ddea22907f53ee --- /dev/null +++ b/fairseq/fairseq/models/bart/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .hub_interface import * # noqa +from .model import * # noqa diff --git a/fairseq/fairseq/models/bart/hub_interface.py b/fairseq/fairseq/models/bart/hub_interface.py new file mode 100644 index 0000000000000000000000000000000000000000..4d47d9751837c744b1d0d460117b78fcbeeb12d8 --- /dev/null +++ b/fairseq/fairseq/models/bart/hub_interface.py @@ -0,0 +1,208 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import copy +import logging +from typing import Dict, List + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.data import encoders +from fairseq.hub_utils import GeneratorHubInterface +from omegaconf import open_dict + + +logger = logging.getLogger(__name__) + + +class BARTHubInterface(GeneratorHubInterface): + """A simple PyTorch Hub interface to BART. + + Usage: https://github.com/pytorch/fairseq/tree/main/examples/bart + """ + + def __init__(self, cfg, task, model): + super().__init__(cfg, task, [model]) + self.model = self.models[0] + + def encode( + self, sentence: str, *addl_sentences, no_separator=True + ) -> torch.LongTensor: + """ + BPE-encode a sentence (or multiple sentences). + + Every sequence begins with a beginning-of-sentence (`<s>`) symbol. + Every sentence ends with an end-of-sentence (`</s>`). + + Example (single sentence): `<s> a b c </s>` + Example (sentence pair): `<s> d e f </s> 1 2 3 </s>` + + The BPE encoding follows GPT-2. One subtle detail is that the GPT-2 BPE + requires leading spaces. For example:: + + >>> bart.encode('Hello world').tolist() + [0, 31414, 232, 2] + >>> bart.encode(' world').tolist() + [0, 232, 2] + >>> bart.encode('world').tolist() + [0, 8331, 2] + """ + tokens = self.bpe.encode(sentence) + if len(tokens.split(" ")) > min(self.max_positions) - 2: + tokens = " ".join(tokens.split(" ")[: min(self.max_positions) - 2]) + bpe_sentence = "<s> " + tokens + " </s>" + for s in addl_sentences: + bpe_sentence += " </s>" if not no_separator else "" + bpe_sentence += " " + self.bpe.encode(s) + " </s>" + tokens = self.task.source_dictionary.encode_line(bpe_sentence, append_eos=False) + return tokens.long() + + def decode(self, tokens: torch.LongTensor): + assert tokens.dim() == 1 + tokens = tokens.cpu().numpy() + if tokens[0] == self.task.source_dictionary.bos(): + tokens = tokens[1:] # remove <s> + eos_mask = tokens == self.task.source_dictionary.eos() + doc_mask = eos_mask[1:] & eos_mask[:-1] + sentences = np.split(tokens, doc_mask.nonzero()[0] + 1) + sentences = [ + self.bpe.decode(self.task.source_dictionary.string(s)) for s in sentences + ] + if len(sentences) == 1: + return sentences[0] + return sentences + + def _build_sample(self, src_tokens: List[torch.LongTensor]): + # assert torch.is_tensor(src_tokens) + dataset = self.task.build_dataset_for_inference( + src_tokens, + [x.numel() for x in src_tokens], + ) + sample = dataset.collater(dataset) + sample = utils.apply_to_sample(lambda tensor: tensor.to(self.device), sample) + return sample + + def generate( + self, + tokenized_sentences: List[torch.LongTensor], + *args, + inference_step_args=None, + skip_invalid_size_inputs=False, + **kwargs + ) -> List[List[Dict[str, torch.Tensor]]]: + inference_step_args = inference_step_args or {} + if "prefix_tokens" in inference_step_args: + raise NotImplementedError("prefix generation not implemented for BART") + res = [] + for batch in self._build_batches(tokenized_sentences, skip_invalid_size_inputs): + src_tokens = batch['net_input']['src_tokens'] + inference_step_args["prefix_tokens"] =src_tokens.new_full( + (src_tokens.size(0), 1), fill_value=self.task.source_dictionary.bos() + ).to(device=self.device) + results = super().generate( + src_tokens, + *args, + inference_step_args=inference_step_args, + skip_invalid_size_inputs=skip_invalid_size_inputs, + **kwargs + ) + for id, hypos in zip(batch['id'].tolist(), results): + res.append((id, hypos)) + res = [hypos for _, hypos in sorted(res, key=lambda x: x[0])] + return res + + def extract_features( + self, tokens: torch.LongTensor, return_all_hiddens: bool = False + ) -> torch.Tensor: + if tokens.dim() == 1: + tokens = tokens.unsqueeze(0) + if tokens.size(-1) > min(self.model.max_positions()): + raise ValueError( + "tokens exceeds maximum length: {} > {}".format( + tokens.size(-1), self.model.max_positions() + ) + ) + tokens.to(device=self.device), + prev_output_tokens = tokens.clone() + + prev_output_tokens[:, 0] = tokens.gather( + 1, + (tokens.ne(self.task.source_dictionary.pad()).sum(dim=1) - 1).unsqueeze(-1), + ).squeeze() + + prev_output_tokens[:, 1:] = tokens[:, :-1] + features, extra = self.model( + src_tokens=tokens, + src_lengths=None, + prev_output_tokens=prev_output_tokens, + features_only=True, + return_all_hiddens=return_all_hiddens, + ) + if return_all_hiddens: + # convert from T x B x C -> B x T x C + inner_states = extra["inner_states"] + return [inner_state.transpose(0, 1) for inner_state in inner_states] + else: + return features # just the last layer's features + + def register_classification_head( + self, name: str, num_classes: int = None, embedding_size: int = None, **kwargs + ): + self.model.register_classification_head( + name, num_classes=num_classes, embedding_size=embedding_size, **kwargs + ) + + def predict(self, head: str, tokens: torch.LongTensor, return_logits: bool = False): + if tokens.dim() == 1: + tokens = tokens.unsqueeze(0) + features = self.extract_features(tokens.to(device=self.device)) + sentence_representation = features[ + tokens.eq(self.task.source_dictionary.eos()), : + ].view(features.size(0), -1, features.size(-1))[:, -1, :] + + logits = self.model.classification_heads[head](sentence_representation) + if return_logits: + return logits + return F.log_softmax(logits, dim=-1) + + def fill_mask( + self, + masked_inputs: List[str], + topk: int = 5, + match_source_len: bool = True, + **generate_kwargs + ): + masked_token = '<mask>' + batch_tokens = [] + for masked_input in masked_inputs: + assert masked_token in masked_input, \ + "please add one {} token for the input".format(masked_token) + + text_spans = masked_input.split(masked_token) + text_spans_bpe = (' {0} '.format(masked_token)).join( + [self.bpe.encode(text_span.rstrip()) for text_span in text_spans] + ).strip() + tokens = self.task.source_dictionary.encode_line( + '<s> ' + text_spans_bpe + ' </s>', + append_eos=False, + add_if_not_exist=False, + ).long() + batch_tokens.append(tokens) + + # ensure beam size is at least as big as topk + generate_kwargs['beam'] = max( + topk, + generate_kwargs.get('beam', -1), + ) + generate_kwargs['match_source_len'] = match_source_len + batch_hypos = self.generate(batch_tokens, **generate_kwargs) + + return [ + [(self.decode(hypo['tokens']), hypo['score']) for hypo in hypos[:topk]] + for hypos in batch_hypos + ] diff --git a/fairseq/fairseq/models/bart/model.py b/fairseq/fairseq/models/bart/model.py new file mode 100644 index 0000000000000000000000000000000000000000..71d0b27cd2c0655fe3b00479b672d6d042a4d5ed --- /dev/null +++ b/fairseq/fairseq/models/bart/model.py @@ -0,0 +1,384 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +BART: Denoising Sequence-to-Sequence Pre-training for +Natural Language Generation, Translation, and Comprehension +""" +from typing import Optional + +import logging + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer import TransformerModel +from fairseq.modules.transformer_sentence_encoder import init_bert_params + +from .hub_interface import BARTHubInterface + + +logger = logging.getLogger(__name__) + + +@register_model("bart") +class BARTModel(TransformerModel): + __jit_unused_properties__ = ["supported_targets"] + + @classmethod + def hub_models(cls): + return { + "bart.base": "http://dl.fbaipublicfiles.com/fairseq/models/bart.base.tar.gz", + "bart.large": "http://dl.fbaipublicfiles.com/fairseq/models/bart.large.tar.gz", + "bart.large.mnli": "http://dl.fbaipublicfiles.com/fairseq/models/bart.large.mnli.tar.gz", + "bart.large.cnn": "http://dl.fbaipublicfiles.com/fairseq/models/bart.large.cnn.tar.gz", + "bart.large.xsum": "http://dl.fbaipublicfiles.com/fairseq/models/bart.large.xsum.tar.gz", + } + + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + + # We follow BERT's random weight initialization + self.apply(init_bert_params) + + self.classification_heads = nn.ModuleDict() + if hasattr(self.encoder, "dictionary"): + self.eos: int = self.encoder.dictionary.eos() + + @staticmethod + def add_args(parser): + super(BARTModel, BARTModel).add_args(parser) + parser.add_argument( + "--pooler-dropout", + type=float, + metavar="D", + help="dropout probability in the masked_lm pooler layers", + ) + parser.add_argument( + "--pooler-activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use for pooler layer", + ) + parser.add_argument( + "--spectral-norm-classification-head", + action="store_true", + help="Apply spectral normalization on the classification head", + ) + + @property + def supported_targets(self): + return {"self"} + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + features_only: bool = False, + classification_head_name: Optional[str] = None, + token_embeddings: Optional[torch.Tensor] = None, + return_all_hiddens: bool = True, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + if classification_head_name is not None: + features_only = True + + encoder_out = self.encoder( + src_tokens, + src_lengths=src_lengths, + token_embeddings=token_embeddings, + return_all_hiddens=return_all_hiddens + ) + x, extra = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + eos: int = self.eos + if classification_head_name is not None: + sentence_representation = x[ + src_tokens.eq(eos), : + ].view(x.size(0), -1, x.size(-1))[:, -1, :] + for k, head in self.classification_heads.items(): + # for torch script only supports iteration + if k == classification_head_name: + x = head(sentence_representation) + break + return x, extra + + @classmethod + def from_pretrained( + cls, + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + bpe="gpt2", + sample_break_mode="eos", + **kwargs, + ): + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + bpe=bpe, + load_checkpoint_heads=True, + sample_break_mode=sample_break_mode, + **kwargs, + ) + return BARTHubInterface(x["args"], x["task"], x["models"][0]) + + def register_classification_head( + self, name, num_classes=None, inner_dim=None, **kwargs + ): + """Register a classification head.""" + logger.info("Registering classification head: {0}".format(name)) + if name in self.classification_heads: + prev_num_classes = self.classification_heads[name].out_proj.out_features + prev_inner_dim = self.classification_heads[name].dense.out_features + if num_classes != prev_num_classes or inner_dim != prev_inner_dim: + logger.warning( + 're-registering head "{}" with num_classes {} (prev: {}) ' + "and inner_dim {} (prev: {})".format( + name, num_classes, prev_num_classes, inner_dim, prev_inner_dim + ) + ) + self.classification_heads[name] = BARTClassificationHead( + input_dim=self.args.encoder_embed_dim, + inner_dim=inner_dim or self.args.encoder_embed_dim, + num_classes=num_classes, + activation_fn=self.args.pooler_activation_fn, + pooler_dropout=self.args.pooler_dropout, + do_spectral_norm=getattr( + self.args, "spectral_norm_classification_head", False + ), + ) + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + + prefix = name + "." if name != "" else "" + current_head_names = ( + [] + if not hasattr(self, "classification_heads") + else self.classification_heads.keys() + ) + + # Handle new classification heads present in the state dict. + keys_to_delete = [] + for k in state_dict.keys(): + if not k.startswith(prefix + "classification_heads."): + continue + + head_name = k[len(prefix + "classification_heads.") :].split(".")[0] + num_classes = state_dict[ + prefix + "classification_heads." + head_name + ".out_proj.weight" + ].size(0) + inner_dim = state_dict[ + prefix + "classification_heads." + head_name + ".dense.weight" + ].size(0) + + if getattr(self.args, "load_checkpoint_heads", False): + if head_name not in current_head_names: + self.register_classification_head(head_name, num_classes, inner_dim) + else: + if head_name not in current_head_names: + logger.warning( + "deleting classification head ({}) from checkpoint " + "not present in current model: {}".format(head_name, k) + ) + keys_to_delete.append(k) + elif ( + num_classes + != self.classification_heads[head_name].out_proj.out_features + or inner_dim + != self.classification_heads[head_name].dense.out_features + ): + logger.warning( + "deleting classification head ({}) from checkpoint " + "with different dimensions than current model: {}".format( + head_name, k + ) + ) + keys_to_delete.append(k) + for k in keys_to_delete: + del state_dict[k] + + def truncate_emb(key): + if key in state_dict: + state_dict[key] = state_dict[key][:-1, :] + + # When finetuning on translation task, remove last row of + # embedding matrix that corresponds to mask_idx token. + loaded_dict_size = state_dict["encoder.embed_tokens.weight"].size(0) + if ( + loaded_dict_size == len(self.encoder.dictionary) + 1 + and "<mask>" not in self.encoder.dictionary + ): + truncate_emb("encoder.embed_tokens.weight") + truncate_emb("decoder.embed_tokens.weight") + truncate_emb("encoder.output_projection.weight") + truncate_emb("decoder.output_projection.weight") + + # When continued pretraining on new set of languages for mbart, + # add extra lang embeddings at the end of embed_tokens. + # Note: newly added languages are assumed to have been added at the end. + if self.args.task == "multilingual_denoising" and loaded_dict_size < len( + self.encoder.dictionary + ): + logger.info( + "Adding extra language embeddings not found in pretrained model for " + "continued pretraining of MBART on new set of languages." + ) + loaded_mask_token_embedding = state_dict["encoder.embed_tokens.weight"][ + -1, : + ] + + num_langids_to_add = len(self.encoder.dictionary) - loaded_dict_size + embed_dim = state_dict["encoder.embed_tokens.weight"].size(1) + + new_lang_embed_to_add = torch.zeros(num_langids_to_add, embed_dim) + nn.init.normal_(new_lang_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_lang_embed_to_add = new_lang_embed_to_add.to( + dtype=state_dict["encoder.embed_tokens.weight"].dtype, + ) + + state_dict["encoder.embed_tokens.weight"] = torch.cat( + [ + state_dict["encoder.embed_tokens.weight"][ + : loaded_dict_size - 1, : + ], + new_lang_embed_to_add, + loaded_mask_token_embedding.unsqueeze(0), + ] + ) + state_dict["decoder.embed_tokens.weight"] = torch.cat( + [ + state_dict["decoder.embed_tokens.weight"][ + : loaded_dict_size - 1, : + ], + new_lang_embed_to_add, + loaded_mask_token_embedding.unsqueeze(0), + ] + ) + + # Copy any newly-added classification heads into the state dict + # with their current weights. + if hasattr(self, "classification_heads"): + cur_state = self.classification_heads.state_dict() + for k, v in cur_state.items(): + if prefix + "classification_heads." + k not in state_dict: + logger.info("Overwriting " + prefix + "classification_heads." + k) + state_dict[prefix + "classification_heads." + k] = v + + +class BARTClassificationHead(nn.Module): + """Head for sentence-level classification tasks.""" + + def __init__( + self, + input_dim, + inner_dim, + num_classes, + activation_fn, + pooler_dropout, + do_spectral_norm=False, + ): + super().__init__() + self.dense = nn.Linear(input_dim, inner_dim) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(inner_dim, num_classes) + + if do_spectral_norm: + self.out_proj = torch.nn.utils.spectral_norm(self.out_proj) + + def forward(self, features, **kwargs): + x = features + x = self.dropout(x) + x = self.dense(x) + x = self.activation_fn(x) + x = self.dropout(x) + x = self.out_proj(x) + return x + + +@register_model_architecture("bart", "bart_large") +def bart_large_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 1024) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.relu_dropout = getattr(args, "relu_dropout", 0.0) + args.dropout = getattr(args, "dropout", 0.1) + args.max_target_positions = getattr(args, "max_target_positions", 1024) + args.max_source_positions = getattr(args, "max_source_positions", 1024) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", True + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", True) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", True) + args.layernorm_embedding = getattr(args, "layernorm_embedding", True) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.pooler_dropout = getattr(args, "pooler_dropout", 0.0) + + +@register_model_architecture("bart", "bart_base") +def bart_base_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 768) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 12) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 12) + bart_large_architecture(args) + + +@register_model_architecture("bart", "mbart_large") +def mbart_large_architecture(args): + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + bart_large_architecture(args) + + +@register_model_architecture("bart", "mbart_base") +def mbart_base_architecture(args): + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + bart_base_architecture(args) + + +@register_model_architecture("bart", "mbart_base_wmt20") +def mbart_base_wmt20_architecture(args): + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + mbart_base_architecture(args) diff --git a/fairseq/fairseq/models/composite_encoder.py b/fairseq/fairseq/models/composite_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..4e20fe3a833a2d87876cbec294ad2bebfba7f591 --- /dev/null +++ b/fairseq/fairseq/models/composite_encoder.py @@ -0,0 +1,57 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .fairseq_encoder import FairseqEncoder + + +class CompositeEncoder(FairseqEncoder): + """ + A wrapper around a dictionary of :class:`FairseqEncoder` objects. + + We run forward on each encoder and return a dictionary of outputs. The first + encoder's dictionary is used for initialization. + + Args: + encoders (dict): a dictionary of :class:`FairseqEncoder` objects. + """ + + def __init__(self, encoders): + super().__init__(next(iter(encoders.values())).dictionary) + self.encoders = encoders + for key in self.encoders: + self.add_module(key, self.encoders[key]) + + def forward(self, src_tokens, src_lengths): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (LongTensor): lengths of each source sentence of shape + `(batch)` + + Returns: + dict: + the outputs from each Encoder + """ + encoder_out = {} + for key in self.encoders: + encoder_out[key] = self.encoders[key](src_tokens, src_lengths) + return encoder_out + + def reorder_encoder_out(self, encoder_out, new_order): + """Reorder encoder output according to new_order.""" + for key in self.encoders: + encoder_out[key] = self.encoders[key].reorder_encoder_out( + encoder_out[key], new_order + ) + return encoder_out + + def max_positions(self): + return min(self.encoders[key].max_positions() for key in self.encoders) + + def upgrade_state_dict(self, state_dict): + for key in self.encoders: + self.encoders[key].upgrade_state_dict(state_dict) + return state_dict diff --git a/fairseq/fairseq/models/distributed_fairseq_model.py b/fairseq/fairseq/models/distributed_fairseq_model.py new file mode 100644 index 0000000000000000000000000000000000000000..5eda2276404ca686be124901674ddfe36bd6dfd1 --- /dev/null +++ b/fairseq/fairseq/models/distributed_fairseq_model.py @@ -0,0 +1,146 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import signal +import threading + +import torch +import torch.nn as nn +from torch.nn.parallel import DistributedDataParallel + +from fairseq.distributed import ( + DistributedTimeoutWrapper, + LegacyDistributedDataParallel, + ModuleProxyWrapper, + TPUDistributedDataParallel, +) + + +logger = logging.getLogger(__name__) + + +_GOSSIP_DISABLED = False +try: + import gossip +except ImportError: + _GOSSIP_DISABLED = True + + +def DistributedFairseqModel(args, model, process_group, device): + """ + Wrap a *model* to support distributed data parallel training. + + This is similar to the built-in DistributedDataParallel, but allows + additional configuration of the DistributedDataParallel class to + use, and also provides easier access to the wrapped model by + forwarding requests for missing attributes to the wrapped model. + + Args: + args (argparse.Namespace): fairseq args + model (BaseFairseqModel): model to wrap + process_group: the c10d process group to be used for distributed data + parallel all-reduction. + device: device to move model to + """ + assert isinstance(model, nn.Module) + if args.tpu: + wrapped_model = TPUDistributedDataParallel( + module=model.to(device), + process_group=process_group, + ) + # forward missing getattr and state_dict/load_state_dict to orig model + wrapped_model = ModuleProxyWrapper(wrapped_model) + elif args.ddp_backend in {"c10d", "pytorch_ddp"}: + wrapped_model = DistributedDataParallel( + module=model.to(device), + device_ids=[args.device_id], + output_device=args.device_id, + broadcast_buffers=args.broadcast_buffers, + bucket_cap_mb=args.bucket_cap_mb, + process_group=process_group, + find_unused_parameters=args.find_unused_parameters, + gradient_as_bucket_view=args.gradient_as_bucket_view, + ) + if args.ddp_comm_hook == "fp16": + logger.info("enable fp16 communication hook in DDP") + try: + from torch.distributed.algorithms.ddp_comm_hooks import ( + register_ddp_comm_hook, + DDPCommHookType, + ) + except: + logger.error( + "Could not import from torch.distributed.algorithms.ddp_comm_hooks; you may need to update your pytorch version" + ) + raise + + register_ddp_comm_hook(DDPCommHookType.FP16_COMPRESS, wrapped_model) + # forward missing getattr and state_dict/load_state_dict to orig model + wrapped_model = ModuleProxyWrapper(wrapped_model) + elif args.ddp_backend in {"no_c10d", "legacy_ddp"}: + wrapped_model = LegacyDistributedDataParallel( + module=model.to(device), + buffer_size=2 ** 28, + process_group=process_group, + ) + # forward missing getattr and state_dict/load_state_dict to orig model + wrapped_model = ModuleProxyWrapper(wrapped_model) + elif args.ddp_backend == "slow_mo": + if _GOSSIP_DISABLED: + raise ImportError( + "Cannot find gossip library. Please install from: " + "github.com/facebookresearch/stochastic_gradient_push" + ) + + # The values of slowmo_momentum below were obtained by tuning on the + # En-De 16 dataset by training the transformer_wmt_en_de_large model + if args.slowmo_momentum is None: + if args.distributed_world_size <= 16: + args.slowmo_momentum = 0.0 + elif args.distributed_world_size <= 32: + args.slowmo_momentum = 0.2 + elif args.distributed_world_size <= 64: + args.slowmo_momentum = 0.5 + else: + args.slowmo_momentum = 0.6 + + wrapped_model = gossip.GossipDataParallel( + module=model.to(device), + device_ids=[args.device_id], + output_device=args.device_id, + broadcast_buffers=args.broadcast_buffers, + nprocs_per_node=args.nprocs_per_node, + slowmo_momentum=args.slowmo_momentum, + localsgd=(args.slowmo_algorithm == "LocalSGD"), + localsgd_frequency=args.localsgd_frequency, + ) + # forward missing getattr and state_dict/load_state_dict to orig model + wrapped_model = ModuleProxyWrapper(wrapped_model) + elif args.ddp_backend == "fully_sharded": + try: + from fairscale.nn.data_parallel import FullyShardedDataParallel as FSDP + except ImportError: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + assert isinstance(model, FSDP), "expected model to already be wrapped in FSDP" + wrapped_model = model + if args.memory_efficient_fp16: + wrapped_model = wrapped_model.half() + if not args.cpu_offload: + wrapped_model = wrapped_model.to(device=device) + else: + raise ValueError("Unknown --ddp-backend: " + args.ddp_backend) + + # kill hung distributed jobs after a timeout + if getattr(args, "heartbeat_timeout", -1) > 0: + wrapped_model = DistributedTimeoutWrapper( + wrapped_model, timeout=getattr(args, "heartbeat_timeout", -1) + ) + + return wrapped_model diff --git a/fairseq/fairseq/models/ema/__init__.py b/fairseq/fairseq/models/ema/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..503ceaa609b092e48bd32a0031f4e2ffb875483f --- /dev/null +++ b/fairseq/fairseq/models/ema/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + +from .ema import EMA + + +def build_ema(model, cfg, device): + return EMA(model, cfg, device) + + +# automatically import any Python files in the models/ema/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + file_name = file[: file.find(".py")] + importlib.import_module("fairseq.models.ema." + file_name) diff --git a/fairseq/fairseq/models/ema/ema.py b/fairseq/fairseq/models/ema/ema.py new file mode 100644 index 0000000000000000000000000000000000000000..010b60ba2fd766340d2c5b8ba96f9e57c6fe25b5 --- /dev/null +++ b/fairseq/fairseq/models/ema/ema.py @@ -0,0 +1,200 @@ +#!/usr/bin/env python3 + +""" +This module has the EMA class used to store a copy of the exponentially decayed +model params. + +Typical usage of EMA class involves initializing an object using an existing +model (random or from a seed model) and setting the config like ema_decay, +ema_start_update which determine how the EMA model is updated. After every +update of the model i.e. at the end of the train_step, the EMA should be updated +by passing the new model to the EMA.step function. The EMA model state dict +can be stored in the extra state under the key of "ema" and dumped +into a checkpoint and loaded. The EMA object can be passed to tasks +by setting task.uses_ema property. +EMA is a smoothed/ensemble model which might have better performance +when used for inference or further fine-tuning. EMA class has a +reverse function to load the EMA params into a model and use it +like a regular model. +""" + +import copy +import logging + +import torch +from fairseq import checkpoint_utils + + +class EMA(object): + """Exponential Moving Average of Fairseq Models + EMA keeps a copy of the exponentially decayed model params. + The set of params should include both gradient-descent and + non-gradient descent params, such as batch mean/var and buffers. + This is a modified implementation of + the open source code in https://github.com/zhawe01/fairseq-gec.git, + and internal source code in + fbcode/mobile-vision/projects/classification_pytorch/lib/utils/model_ema.py. + + Similar to TF EMA. + https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage. + EMA provides a averaged and smoothed set of model weights, and has been shown to + improve vision models. EMA class does all necessary functions to update, reload, + or init EMA methods. + + EMA object is initialized from an arbitrary model. By default, it is stored in + the same device (unless device specified at initialization) and with the + same precision as the model (unless ema_fp32 is True). ema_fp32 is recommended. + This stores the EMA parameters in fp32 only for the EMA update step, and + is used at the default precision otherwise. + EMA is usually enabled using EMAConfig with store_ema=True. Some important + parameters to configure EMA are + 1) ema_decay - The decay of EMA + 2) ema_update_freq - EMA is updated every this many model updates. + 3) ema_start_update - Start EMA update after this many model updates [default 0] + + Key methods: + 1) step - One update of EMA using new model + 2) restore - Update EMA from a state dict + 3) reverse - Load EMA into a model + 4) get_decay, _set_decay - Used to get or set the decay. Note _set_decay is + called from step. + 5) build_fp32_params - Used to initialize or update the fp32 copy of EMA params. + Note this is enabled only when ema_fp32=True + """ + + def __init__(self, model, config, device=None): + """ + @param model model to initialize the EMA with + @param config EMAConfig object with configuration like + ema_decay, ema_update_freq, ema_fp32 + @param device If provided, copy EMA to this device (e.g. gpu). + Otherwise EMA is in the same device as the model. + """ + + self.decay = config.ema_decay + self.model = copy.deepcopy(model) + self.model.requires_grad_(False) + self.config = config + self.fp32_params = {} + + if self.config.ema_seed_model is not None: + state = checkpoint_utils.load_ema_from_checkpoint(self.config.ema_seed_model) + self.model.load_state_dict(state["model"], strict=True) + + if device is not None: + logging.info(f"Copying EMA model to device {device}") + self.model = self.model.to(device=device) + + if self.config.ema_fp32: + self.build_fp32_params() + + self.update_freq_counter = 0 + + def get_model(self): + return self.model + + def build_fp32_params(self, state_dict=None): + """ + Store a copy of the EMA params in fp32. + If state dict is passed, the EMA params is copied from + the provided state dict. Otherwise, it is copied from the + current EMA model parameters. + """ + if not self.config.ema_fp32: + raise RuntimeError( + "build_fp32_params should not be called if ema_fp32=False. " + "Use ema_fp32=True if this is really intended." + ) + + if state_dict is None: + state_dict = self.model.state_dict() + + def _to_float(t): + return t.float() if torch.is_floating_point(t) else t + + # for non-float params (like registered symbols), they are copied into this dict and covered in each update + for param_key in state_dict: + if param_key in self.fp32_params: + self.fp32_params[param_key].copy_(state_dict[param_key]) + else: + self.fp32_params[param_key] = _to_float(state_dict[param_key]) + + def restore(self, state_dict, build_fp32_params=False): + """ Load data from a model spec into EMA model """ + self.model.load_state_dict(state_dict, strict=False) + if build_fp32_params: + self.build_fp32_params(state_dict) + + def _set_decay(self, decay): + self.decay = decay + + def get_decay(self): + return self.decay + + def _step_internal(self, new_model, updates=None): + """ One update of the EMA model based on new model weights """ + decay = self.decay + + ema_state_dict = {} + ema_params = self.fp32_params if self.config.ema_fp32 else self.model.state_dict() + for key, param in new_model.state_dict().items(): + try: + ema_param = ema_params[key] + except KeyError: + ema_param = param.float().clone() if param.ndim == 1 else copy.deepcopy(param) + + if param.shape != ema_param.shape: + raise ValueError( + "incompatible tensor shapes between model param and ema param" + + "{} vs. {}".format(param.shape, ema_param.shape) + ) + if "version" in key: + # Do not decay a model.version pytorch param + continue + + # for non-float params (like registered symbols), they are covered in each update + if not torch.is_floating_point(ema_param): + if ema_param.dtype != param.dtype: + raise ValueError( + "incompatible tensor dtypes between model param and ema param" + + "{} vs. {}".format(param.dtype, ema_param.dtype) + ) + ema_param.copy_(param) + else: + ema_param.mul_(decay) + ema_param.add_(param.to(dtype=ema_param.dtype), alpha=1-decay) + ema_state_dict[key] = ema_param + self.restore(ema_state_dict, build_fp32_params=False) + + def step(self, new_model, updates=None): + """ + One update of EMA which is done every self.config.ema_update_freq + updates of the model. + + @param updates The current number of model updates done. + Decay is set of 0 if model updates < ema_start_update, which means + the model will be simply copied over to the EMA. + When model updates >= ema_start_updates, then EMA is updated with + a decay of self.config.ema_decay. + """ + self._set_decay( + 0 + if updates is not None + and updates < self.config.ema_start_update + else self.config.ema_decay + ) + if updates is not None and self.config.ema_update_freq > 1: + self.update_freq_counter += 1 + if self.update_freq_counter >= self.config.ema_update_freq: + self._step_internal(new_model, updates) + self.update_freq_counter = 0 + else: + self._step_internal(new_model, updates) + + def reverse(self, model): + """ + Load the model parameters from EMA model. + Useful for inference or fine-tuning from the EMA model. + """ + model.load_state_dict(self.model.state_dict(), strict=False) + return model diff --git a/fairseq/fairseq/models/fairseq_decoder.py b/fairseq/fairseq/models/fairseq_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..4f1e8b52a2e0a50199050f11cc613ab02ca9febe --- /dev/null +++ b/fairseq/fairseq/models/fairseq_decoder.py @@ -0,0 +1,105 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, Optional, Tuple + +import torch.nn as nn +from fairseq import utils +from torch import Tensor + + +class FairseqDecoder(nn.Module): + """Base class for decoders.""" + + def __init__(self, dictionary): + super().__init__() + self.dictionary = dictionary + self.onnx_trace = False + self.adaptive_softmax = None + + + def forward(self, prev_output_tokens, encoder_out=None, **kwargs): + """ + Args: + prev_output_tokens (LongTensor): shifted output tokens of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (dict, optional): output from the encoder, used for + encoder-side attention + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + x, extra = self.extract_features( + prev_output_tokens, encoder_out=encoder_out, **kwargs + ) + x = self.output_layer(x) + return x, extra + + def extract_features(self, prev_output_tokens, encoder_out=None, **kwargs): + """ + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + raise NotImplementedError + + def output_layer(self, features, **kwargs): + """ + Project features to the default output size, e.g., vocabulary size. + + Args: + features (Tensor): features returned by *extract_features*. + """ + raise NotImplementedError + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + return self.get_normalized_probs_scriptable(net_output, log_probs, sample) + + # TorchScript doesn't support super() method so that the scriptable Subclass + # can't access the base class model in Torchscript. + # Current workaround is to add a helper function with different name and + # call the helper function from scriptable Subclass. + def get_normalized_probs_scriptable( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + + if hasattr(self, "adaptive_softmax") and self.adaptive_softmax is not None: + if sample is not None: + assert "target" in sample + target = sample["target"] + else: + target = None + out = self.adaptive_softmax.get_log_prob(net_output[0], target=target) + return out.exp_() if not log_probs else out + + logits = net_output[0] + if log_probs: + return utils.log_softmax(logits, dim=-1, onnx_trace=self.onnx_trace) + else: + return utils.softmax(logits, dim=-1, onnx_trace=self.onnx_trace) + + def max_positions(self): + """Maximum input length supported by the decoder.""" + return 1e6 # an arbitrary large number + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade old state dicts to work with newer code.""" + return state_dict + + def prepare_for_onnx_export_(self): + self.onnx_trace = True diff --git a/fairseq/fairseq/models/fairseq_encoder.py b/fairseq/fairseq/models/fairseq_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..08cbde15a46e9b6d58e11c2f6052e7cf2d0cc8b2 --- /dev/null +++ b/fairseq/fairseq/models/fairseq_encoder.py @@ -0,0 +1,92 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, NamedTuple, Optional + +import torch +import torch.nn as nn +from torch import Tensor + + +EncoderOut = NamedTuple( + "EncoderOut", + [ + ("encoder_out", Tensor), # T x B x C + ("encoder_padding_mask", Optional[Tensor]), # B x T + ("encoder_embedding", Optional[Tensor]), # B x T x C + ("encoder_states", Optional[List[Tensor]]), # List[T x B x C] + ("src_tokens", Optional[Tensor]), # B x T + ("src_lengths", Optional[Tensor]), # B x 1 + ], +) + + +class FairseqEncoder(nn.Module): + """Base class for encoders.""" + + def __init__(self, dictionary): + super().__init__() + self.dictionary = dictionary + + def forward(self, src_tokens, src_lengths=None, **kwargs): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (LongTensor): lengths of each source sentence of shape + `(batch)` + """ + raise NotImplementedError + + def forward_torchscript(self, net_input: Dict[str, Tensor]): + """A TorchScript-compatible version of forward. + + Encoders which use additional arguments may want to override + this method for TorchScript compatibility. + """ + if torch.jit.is_scripting(): + return self.forward( + src_tokens=net_input["src_tokens"], + src_lengths=net_input["src_lengths"], + ) + else: + return self.forward_non_torchscript(net_input) + + @torch.jit.unused + def forward_non_torchscript(self, net_input: Dict[str, Tensor]): + encoder_input = { + k: v for k, v in net_input.items() if k != "prev_output_tokens" + } + return self.forward(**encoder_input) + + def reorder_encoder_out(self, encoder_out, new_order): + """ + Reorder encoder output according to `new_order`. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + `encoder_out` rearranged according to `new_order` + """ + raise NotImplementedError + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return 1e6 # an arbitrary large number + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade old state dicts to work with newer code.""" + return state_dict + + def set_num_updates(self, num_updates): + """State from trainer to pass along to model at every update.""" + + def _apply(m): + if hasattr(m, "set_num_updates") and m != self: + m.set_num_updates(num_updates) + + self.apply(_apply) diff --git a/fairseq/fairseq/models/fairseq_incremental_decoder.py b/fairseq/fairseq/models/fairseq_incremental_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..cc72a0f8f3da238a8ce846240e5008d91ce1bc1a --- /dev/null +++ b/fairseq/fairseq/models/fairseq_incremental_decoder.py @@ -0,0 +1,118 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import Dict, Optional + +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.models import FairseqDecoder +from torch import Tensor + + +logger = logging.getLogger(__name__) + + +@with_incremental_state +class FairseqIncrementalDecoder(FairseqDecoder): + """Base class for incremental decoders. + + Incremental decoding is a special mode at inference time where the Model + only receives a single timestep of input corresponding to the previous + output token (for teacher forcing) and must produce the next output + *incrementally*. Thus the model must cache any long-term state that is + needed about the sequence, e.g., hidden states, convolutional states, etc. + + Compared to the standard :class:`FairseqDecoder` interface, the incremental + decoder interface allows :func:`forward` functions to take an extra keyword + argument (*incremental_state*) that can be used to cache state across + time-steps. + + The :class:`FairseqIncrementalDecoder` interface also defines the + :func:`reorder_incremental_state` method, which is used during beam search + to select and reorder the incremental state based on the selection of beams. + + To learn more about how incremental decoding works, refer to `this blog + <http://www.telesens.co/2019/04/21/understanding-incremental-decoding-in-fairseq/>`_. + """ + + def __init__(self, dictionary): + super().__init__(dictionary) + + def forward( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **kwargs + ): + """ + Args: + prev_output_tokens (LongTensor): shifted output tokens of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (dict, optional): output from the encoder, used for + encoder-side attention + incremental_state (dict, optional): dictionary used for storing + state during :ref:`Incremental decoding` + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + raise NotImplementedError + + def extract_features( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **kwargs + ): + """ + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + raise NotImplementedError + + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + """Reorder incremental state. + + This will be called when the order of the input has changed from the + previous time step. A typical use case is beam search, where the input + order changes between time steps based on the selection of beams. + """ + pass + + def reorder_incremental_state_scripting( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + """Main entry point for reordering the incremental state. + + Due to limitations in TorchScript, we call this function in + :class:`fairseq.sequence_generator.SequenceGenerator` instead of + calling :func:`reorder_incremental_state` directly. + """ + for module in self.modules(): + if hasattr(module, "reorder_incremental_state"): + result = module.reorder_incremental_state(incremental_state, new_order) + if result is not None: + incremental_state = result + + def set_beam_size(self, beam_size): + """Sets the beam size in the decoder and all children.""" + if getattr(self, "_beam_size", -1) != beam_size: + seen = set() + + def apply_set_beam_size(module): + if ( + module != self + and hasattr(module, "set_beam_size") + and module not in seen + ): + seen.add(module) + module.set_beam_size(beam_size) + + self.apply(apply_set_beam_size) + self._beam_size = beam_size diff --git a/fairseq/fairseq/models/fairseq_model.py b/fairseq/fairseq/models/fairseq_model.py new file mode 100644 index 0000000000000000000000000000000000000000..e55c7ba1ad90f4e2f12db6c814d04a90c4e3b77c --- /dev/null +++ b/fairseq/fairseq/models/fairseq_model.py @@ -0,0 +1,569 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Base classes for various fairseq models. +""" + +import logging +from argparse import Namespace +from typing import Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.data import Dictionary +from fairseq.dataclass.utils import ( + convert_namespace_to_omegaconf, + gen_parser_from_dataclass, +) +from fairseq.models import FairseqDecoder, FairseqEncoder +from omegaconf import DictConfig +from torch import Tensor + + +logger = logging.getLogger(__name__) + + +def check_type(module, expected_type): + if hasattr(module, "unwrapped_module"): + assert isinstance(module.unwrapped_module, expected_type), \ + f"{type(module.unwrapped_module)} != {expected_type}" + else: + assert isinstance(module, expected_type), f"{type(module)} != {expected_type}" + + +class BaseFairseqModel(nn.Module): + """Base class for fairseq models.""" + + def __init__(self): + super().__init__() + self._is_generation_fast = False + + @classmethod + def add_args(cls, parser): + """Add model-specific arguments to the parser.""" + dc = getattr(cls, "__dataclass", None) + if dc is not None: + # do not set defaults so that settings defaults from various architectures still works + gen_parser_from_dataclass(parser, dc(), delete_default=True) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + raise NotImplementedError("Model must implement the build_model method") + + def get_targets(self, sample, net_output): + """Get targets from either the sample or the net's output.""" + return sample["target"] + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + return self.get_normalized_probs_scriptable(net_output, log_probs, sample) + + # TorchScript doesn't support super() method so that the scriptable Subclass + # can't access the base class model in Torchscript. + # Current workaround is to add a helper function with different name and + # call the helper function from scriptable Subclass. + def get_normalized_probs_scriptable( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Scriptable helper function for get_normalized_probs in ~BaseFairseqModel""" + if hasattr(self, "decoder"): + return self.decoder.get_normalized_probs(net_output, log_probs, sample) + elif torch.is_tensor(net_output): + # syntactic sugar for simple models which don't have a decoder + # (e.g., the classification tutorial) + logits = net_output.float() + if log_probs: + return F.log_softmax(logits, dim=-1) + else: + return F.softmax(logits, dim=-1) + raise NotImplementedError + + def extract_features(self, *args, **kwargs): + """Similar to *forward* but only return features.""" + return self(*args, **kwargs) + + def max_positions(self): + """Maximum length supported by the model.""" + return None + + def load_state_dict( + self, + state_dict, + strict=True, + model_cfg: Optional[DictConfig] = None, + args: Optional[Namespace] = None, + ): + """Copies parameters and buffers from *state_dict* into this module and + its descendants. + + Overrides the method in :class:`nn.Module`. Compared with that method + this additionally "upgrades" *state_dicts* from old checkpoints. + """ + + if model_cfg is None and args is not None: + logger.warn("using 'args' is deprecated, please update your code to use dataclass config") + model_cfg = convert_namespace_to_omegaconf(args).model + + self.upgrade_state_dict(state_dict) + + from fairseq.checkpoint_utils import prune_state_dict + + new_state_dict = prune_state_dict(state_dict, model_cfg) + return super().load_state_dict(new_state_dict, strict) + + def upgrade_state_dict(self, state_dict): + """Upgrade old state dicts to work with newer code.""" + self.upgrade_state_dict_named(state_dict, "") + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade old state dicts to work with newer code. + + Args: + state_dict (dict): state dictionary to upgrade, in place + name (str): the state dict key corresponding to the current module + """ + assert state_dict is not None + + def do_upgrade(m, prefix): + if len(prefix) > 0: + prefix += "." + + for n, c in m.named_children(): + name = prefix + n + if hasattr(c, "upgrade_state_dict_named"): + c.upgrade_state_dict_named(state_dict, name) + elif hasattr(c, "upgrade_state_dict"): + c.upgrade_state_dict(state_dict) + do_upgrade(c, name) + + do_upgrade(self, name) + + def set_num_updates(self, num_updates): + """State from trainer to pass along to model at every update.""" + for m in self.modules(): + if hasattr(m, "set_num_updates") and m != self: + m.set_num_updates(num_updates) + + def prepare_for_inference_(self, cfg: DictConfig): + """Prepare model for inference.""" + kwargs = {} + kwargs["beamable_mm_beam_size"] = ( + None + if getattr(cfg.generation, "no_beamable_mm", False) + else getattr(cfg.generation, "beam", 5) + ) + kwargs["need_attn"] = getattr(cfg.generation, "print_alignment", False) + if getattr(cfg.generation, "retain_dropout", False): + kwargs["retain_dropout"] = cfg.generation.retain_dropout + kwargs["retain_dropout_modules"] = cfg.generation.retain_dropout_modules + self.make_generation_fast_(**kwargs) + + def make_generation_fast_(self, **kwargs): + """ + Legacy entry point to optimize model for faster generation. + Prefer prepare_for_inference_. + """ + if self._is_generation_fast: + return # only apply once + self._is_generation_fast = True + + # remove weight norm from all modules in the network + def apply_remove_weight_norm(module): + try: + nn.utils.remove_weight_norm(module) + except (AttributeError, ValueError): # this module didn't have weight norm + return + + self.apply(apply_remove_weight_norm) + + def apply_make_generation_fast_(module, prefix): + if len(prefix) > 0: + prefix += "." + + base_func = BaseFairseqModel.make_generation_fast_ + for n, m in module.named_modules(): + if ( + m != self + and hasattr(m, "make_generation_fast_") + # don't call this implementation again, e.g., if + # children modules also inherit from BaseFairseqModel + and m.make_generation_fast_.__func__ is not base_func + ): + name = prefix + n + m.make_generation_fast_(name=name, **kwargs) + + apply_make_generation_fast_(self, "") + + def train(mode=True): + if mode: + raise RuntimeError("cannot train after make_generation_fast") + + # this model should no longer be used for training + self.eval() + self.train = train + + def prepare_for_onnx_export_(self, **kwargs): + """Make model exportable via ONNX trace.""" + seen = set() + + def apply_prepare_for_onnx_export_(module): + if ( + module != self + and hasattr(module, "prepare_for_onnx_export_") + and module not in seen + ): + seen.add(module) + module.prepare_for_onnx_export_(**kwargs) + + self.apply(apply_prepare_for_onnx_export_) + + @classmethod + def from_pretrained( + cls, + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + **kwargs, + ): + """ + Load a :class:`~fairseq.models.FairseqModel` from a pre-trained model + file. Downloads and caches the pre-trained model file if needed. + + The base implementation returns a + :class:`~fairseq.hub_utils.GeneratorHubInterface`, which can be used to + generate translations or sample from language models. The underlying + :class:`~fairseq.models.FairseqModel` can be accessed via the + *generator.models* attribute. + + Other models may override this to implement custom hub interfaces. + + Args: + model_name_or_path (str): either the name of a pre-trained model to + load or a path/URL to a pre-trained model state dict + checkpoint_file (str, optional): colon-separated list of checkpoint + files in the model archive to ensemble (default: 'model.pt') + data_name_or_path (str, optional): point args.data to the archive + at the given path/URL. Can start with '.' or './' to reuse the + model archive path. + """ + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + **kwargs, + ) + logger.info(x["args"]) + return hub_utils.GeneratorHubInterface(x["args"], x["task"], x["models"]) + + @classmethod + def hub_models(cls): + return {} + + +class FairseqEncoderDecoderModel(BaseFairseqModel): + """Base class for encoder-decoder models. + + Args: + encoder (FairseqEncoder): the encoder + decoder (FairseqDecoder): the decoder + """ + + def __init__(self, encoder, decoder): + super().__init__() + + self.encoder = encoder + self.decoder = decoder + + check_type(self.encoder, FairseqEncoder) + check_type(self.decoder, FairseqDecoder) + + def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): + """ + Run the forward pass for an encoder-decoder model. + + First feed a batch of source tokens through the encoder. Then, feed the + encoder output and previous decoder outputs (i.e., teacher forcing) to + the decoder to produce the next outputs:: + + encoder_out = self.encoder(src_tokens, src_lengths) + return self.decoder(prev_output_tokens, encoder_out) + + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (LongTensor): source sentence lengths of shape `(batch)` + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + decoder_out = self.decoder( + prev_output_tokens, encoder_out=encoder_out, **kwargs + ) + return decoder_out + + def forward_decoder(self, prev_output_tokens, **kwargs): + return self.decoder(prev_output_tokens, **kwargs) + + def extract_features(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): + """ + Similar to *forward* but only return features. + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + features = self.decoder.extract_features( + prev_output_tokens, encoder_out=encoder_out, **kwargs + ) + return features + + def output_layer(self, features, **kwargs): + """Project features to the default output size (typically vocabulary size).""" + return self.decoder.output_layer(features, **kwargs) + + def max_positions(self): + """Maximum length supported by the model.""" + return (self.encoder.max_positions(), self.decoder.max_positions()) + + def max_decoder_positions(self): + """Maximum length supported by the decoder.""" + return self.decoder.max_positions() + + +class FairseqModel(FairseqEncoderDecoderModel): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + utils.deprecation_warning( + "FairseqModel is deprecated, please use FairseqEncoderDecoderModel " + "or BaseFairseqModel instead", + stacklevel=4, + ) + + +class FairseqMultiModel(BaseFairseqModel): + """Base class for combining multiple encoder-decoder models.""" + + def __init__(self, encoders, decoders): + super().__init__() + assert encoders.keys() == decoders.keys() + self.keys = list(encoders.keys()) + for key in self.keys: + check_type(encoders[key], FairseqEncoder) + check_type(decoders[key], FairseqDecoder) + + self.models = nn.ModuleDict( + { + key: FairseqEncoderDecoderModel(encoders[key], decoders[key]) + for key in self.keys + } + ) + + @staticmethod + def build_shared_embeddings( + dicts: Dict[str, Dictionary], + langs: List[str], + embed_dim: int, + build_embedding: callable, + pretrained_embed_path: Optional[str] = None, + ): + """ + Helper function to build shared embeddings for a set of languages after + checking that all dicts corresponding to those languages are equivalent. + + Args: + dicts: Dict of lang_id to its corresponding Dictionary + langs: languages that we want to share embeddings for + embed_dim: embedding dimension + build_embedding: callable function to actually build the embedding + pretrained_embed_path: Optional path to load pretrained embeddings + """ + shared_dict = dicts[langs[0]] + if any(dicts[lang] != shared_dict for lang in langs): + raise ValueError( + "--share-*-embeddings requires a joined dictionary: " + "--share-encoder-embeddings requires a joined source " + "dictionary, --share-decoder-embeddings requires a joined " + "target dictionary, and --share-all-embeddings requires a " + "joint source + target dictionary." + ) + return build_embedding(shared_dict, embed_dim, pretrained_embed_path) + + def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): + raise NotImplementedError + + def max_positions(self): + """Maximum length supported by the model.""" + return { + key: ( + self.models[key].encoder.max_positions(), + self.models[key].decoder.max_positions(), + ) + for key in self.keys + } + + def max_decoder_positions(self): + """Maximum length supported by the decoder.""" + return min(model.decoder.max_positions() for model in self.models.values()) + + @property + def encoder(self): + return self.models[self.keys[0]].encoder + + @property + def decoder(self): + return self.models[self.keys[0]].decoder + + def forward_decoder(self, prev_output_tokens, **kwargs): + return self.decoder(prev_output_tokens, **kwargs) + + def load_state_dict( + self, + state_dict, + strict=True, + model_cfg=None, + args: Optional[Namespace] = None, + ): + """Copies parameters and buffers from *state_dict* into this module and + its descendants. + + Overrides the method in :class:`nn.Module`. Compared with that method + this additionally "upgrades" *state_dicts* from old checkpoints. + """ + + if model_cfg is None and args is not None: + logger.warn("using 'args' is deprecated, please update your code to use dataclass config") + model_cfg = convert_namespace_to_omegaconf(args).model + + self.upgrade_state_dict(state_dict) + + from fairseq.checkpoint_utils import prune_state_dict + + new_state_dict = prune_state_dict(state_dict, model_cfg) + return super().load_state_dict(new_state_dict, strict) + + +class FairseqLanguageModel(BaseFairseqModel): + """Base class for decoder-only models. + + Args: + decoder (FairseqDecoder): the decoder + """ + + def __init__(self, decoder): + super().__init__() + self.decoder = decoder + check_type(self.decoder, FairseqDecoder) + + def forward(self, src_tokens, **kwargs): + """ + Run the forward pass for a decoder-only model. + + Feeds a batch of tokens through the decoder to predict the next tokens. + + Args: + src_tokens (LongTensor): tokens on which to condition the decoder, + of shape `(batch, tgt_len)` + src_lengths (LongTensor): source sentence lengths of shape `(batch)` + + Returns: + tuple: + - the decoder's output of shape `(batch, seq_len, vocab)` + - a dictionary with any model-specific outputs + """ + return self.decoder(src_tokens, **kwargs) + + def forward_decoder(self, prev_output_tokens, **kwargs): + return self.decoder(prev_output_tokens, **kwargs) + + def extract_features(self, src_tokens, **kwargs): + """ + Similar to *forward* but only return features. + + Returns: + tuple: + - the decoder's features of shape `(batch, seq_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + return self.decoder.extract_features(src_tokens, **kwargs) + + def output_layer(self, features, **kwargs): + """Project features to the default output size (typically vocabulary size).""" + return self.decoder.output_layer(features, **kwargs) + + def max_positions(self): + """Maximum length supported by the model.""" + return self.decoder.max_positions() + + def max_decoder_positions(self): + """Maximum length supported by the decoder.""" + return self.decoder.max_positions() + + @property + def supported_targets(self): + return {"future"} + + +class FairseqEncoderModel(BaseFairseqModel): + """Base class for encoder-only models. + + Args: + encoder (FairseqEncoder): the encoder + """ + + def __init__(self, encoder): + super().__init__() + self.encoder = encoder + check_type(self.encoder, FairseqEncoder) + + def forward(self, src_tokens, src_lengths, **kwargs): + """ + Run the forward pass for a encoder-only model. + + Feeds a batch of tokens through the encoder to generate features. + + Args: + src_tokens (LongTensor): input tokens of shape `(batch, src_len)` + src_lengths (LongTensor): source sentence lengths of shape `(batch)` + + Returns: + the encoder's output, typically of shape `(batch, src_len, features)` + """ + return self.encoder(src_tokens, src_lengths, **kwargs) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + """Get normalized probabilities (or log probs) from a net's output.""" + encoder_out = net_output["encoder_out"] + if torch.is_tensor(encoder_out): + logits = encoder_out.float() + if log_probs: + return F.log_softmax(logits, dim=-1) + else: + return F.softmax(logits, dim=-1) + raise NotImplementedError + + def max_positions(self): + """Maximum length supported by the model.""" + return self.encoder.max_positions() diff --git a/fairseq/fairseq/models/fconv.py b/fairseq/fairseq/models/fconv.py new file mode 100644 index 0000000000000000000000000000000000000000..c99a2151014d816ec9aff6f4b27d71224dd7b4cf --- /dev/null +++ b/fairseq/fairseq/models/fconv.py @@ -0,0 +1,756 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + AdaptiveSoftmax, + BeamableMM, + FairseqDropout, + GradMultiply, + LearnedPositionalEmbedding, + LinearizedConvolution, +) + + +@register_model("fconv") +class FConvModel(FairseqEncoderDecoderModel): + """ + A fully convolutional model, i.e. a convolutional encoder and a + convolutional decoder, as described in `"Convolutional Sequence to Sequence + Learning" (Gehring et al., 2017) <https://arxiv.org/abs/1705.03122>`_. + + Args: + encoder (FConvEncoder): the encoder + decoder (FConvDecoder): the decoder + + The Convolutional model provides the following named architectures and + command-line arguments: + + .. argparse:: + :ref: fairseq.models.fconv_parser + :prog: + """ + + @classmethod + def hub_models(cls): + def moses_subword(path): + return { + "path": path, + "tokenizer": "moses", + "bpe": "subword_nmt", + } + + return { + "conv.wmt14.en-fr": moses_subword( + "https://dl.fbaipublicfiles.com/fairseq/models/wmt14.v2.en-fr.fconv-py.tar.bz2" + ), + "conv.wmt14.en-de": moses_subword( + "https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-de.fconv-py.tar.bz2" + ), + "conv.wmt17.en-de": moses_subword( + "https://dl.fbaipublicfiles.com/fairseq/models/wmt17.v2.en-de.fconv-py.tar.bz2" + ), + } + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + self.encoder.num_attention_layers = sum( + layer is not None for layer in decoder.attention + ) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-embed-path', type=str, metavar='STR', + help='path to pre-trained encoder embedding') + parser.add_argument('--encoder-layers', type=str, metavar='EXPR', + help='encoder layers [(dim, kernel_size), ...]') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-layers', type=str, metavar='EXPR', + help='decoder layers [(dim, kernel_size), ...]') + parser.add_argument('--decoder-out-embed-dim', type=int, metavar='N', + help='decoder output embedding dimension') + parser.add_argument('--decoder-attention', type=str, metavar='EXPR', + help='decoder attention [True, ...]') + parser.add_argument('--share-input-output-embed', action='store_true', + help='share input and output embeddings (requires' + ' --decoder-out-embed-dim and --decoder-embed-dim' + ' to be equal)') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted (in case there are any new ones) + base_architecture(args) + + encoder_embed_dict = None + if args.encoder_embed_path: + encoder_embed_dict = utils.parse_embedding(args.encoder_embed_path) + utils.print_embed_overlap(encoder_embed_dict, task.source_dictionary) + + decoder_embed_dict = None + if args.decoder_embed_path: + decoder_embed_dict = utils.parse_embedding(args.decoder_embed_path) + utils.print_embed_overlap(decoder_embed_dict, task.target_dictionary) + + encoder = FConvEncoder( + dictionary=task.source_dictionary, + embed_dim=args.encoder_embed_dim, + embed_dict=encoder_embed_dict, + convolutions=eval(args.encoder_layers), + dropout=args.dropout, + max_positions=args.max_source_positions, + ) + decoder = FConvDecoder( + dictionary=task.target_dictionary, + embed_dim=args.decoder_embed_dim, + embed_dict=decoder_embed_dict, + convolutions=eval(args.decoder_layers), + out_embed_dim=args.decoder_out_embed_dim, + attention=eval(args.decoder_attention), + dropout=args.dropout, + max_positions=args.max_target_positions, + share_embed=args.share_input_output_embed, + ) + return FConvModel(encoder, decoder) + + +class FConvEncoder(FairseqEncoder): + """ + Convolutional encoder consisting of `len(convolutions)` layers. + + Args: + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_dim (int, optional): embedding dimension + embed_dict (str, optional): filename from which to load pre-trained + embeddings + max_positions (int, optional): maximum supported input sequence length + convolutions (list, optional): the convolutional layer structure. Each + list item `i` corresponds to convolutional layer `i`. Layers are + given as ``(out_channels, kernel_width, [residual])``. Residual + connections are added between layers when ``residual=1`` (which is + the default behavior). + dropout (float, optional): dropout to be applied before each conv layer + """ + + def __init__( + self, + dictionary, + embed_dim=512, + embed_dict=None, + max_positions=1024, + convolutions=((512, 3),) * 20, + dropout=0.1, + ): + super().__init__(dictionary) + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.num_attention_layers = None + + num_embeddings = len(dictionary) + self.padding_idx = dictionary.pad() + self.embed_tokens = Embedding(num_embeddings, embed_dim, self.padding_idx) + if embed_dict: + self.embed_tokens = utils.load_embedding( + embed_dict, self.dictionary, self.embed_tokens + ) + + self.embed_positions = PositionalEmbedding( + max_positions, + embed_dim, + self.padding_idx, + ) + + convolutions = extend_conv_spec(convolutions) + in_channels = convolutions[0][0] + self.fc1 = Linear(embed_dim, in_channels, dropout=dropout) + self.projections = nn.ModuleList() + self.convolutions = nn.ModuleList() + self.residuals = [] + + layer_in_channels = [in_channels] + for _, (out_channels, kernel_size, residual) in enumerate(convolutions): + if residual == 0: + residual_dim = out_channels + else: + residual_dim = layer_in_channels[-residual] + self.projections.append( + Linear(residual_dim, out_channels) + if residual_dim != out_channels + else None + ) + if kernel_size % 2 == 1: + padding = kernel_size // 2 + else: + padding = 0 + self.convolutions.append( + ConvTBC( + in_channels, + out_channels * 2, + kernel_size, + dropout=dropout, + padding=padding, + ) + ) + self.residuals.append(residual) + in_channels = out_channels + layer_in_channels.append(out_channels) + self.fc2 = Linear(in_channels, embed_dim) + + def forward(self, src_tokens, src_lengths): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (LongTensor): lengths of each source sentence of shape + `(batch)` + + Returns: + dict: + - **encoder_out** (tuple): a tuple with two elements, where the + first element is the last encoder layer's output and the + second element is the same quantity summed with the input + embedding (used for attention). The shape of both tensors is + `(batch, src_len, embed_dim)`. + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + """ + # embed tokens and positions + x = self.embed_tokens(src_tokens) + self.embed_positions(src_tokens) + x = self.dropout_module(x) + input_embedding = x + + # project to size of convolution + x = self.fc1(x) + + # used to mask padding in input + encoder_padding_mask = src_tokens.eq(self.padding_idx).t() # -> T x B + if not encoder_padding_mask.any(): + encoder_padding_mask = None + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + residuals = [x] + # temporal convolutions + for proj, conv, res_layer in zip( + self.projections, self.convolutions, self.residuals + ): + if res_layer > 0: + residual = residuals[-res_layer] + residual = residual if proj is None else proj(residual) + else: + residual = None + + if encoder_padding_mask is not None: + x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0) + + x = self.dropout_module(x) + if conv.kernel_size[0] % 2 == 1: + # padding is implicit in the conv + x = conv(x) + else: + padding_l = (conv.kernel_size[0] - 1) // 2 + padding_r = conv.kernel_size[0] // 2 + x = F.pad(x, (0, 0, 0, 0, padding_l, padding_r)) + x = conv(x) + x = F.glu(x, dim=2) + + if residual is not None: + x = (x + residual) * math.sqrt(0.5) + residuals.append(x) + + # T x B x C -> B x T x C + x = x.transpose(1, 0) + + # project back to size of embedding + x = self.fc2(x) + + if encoder_padding_mask is not None: + encoder_padding_mask = encoder_padding_mask.t() # -> B x T + x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0) + + # scale gradients (this only affects backward, not forward) + x = GradMultiply.apply(x, 1.0 / (2.0 * self.num_attention_layers)) + + # add output to input embedding for attention + y = (x + input_embedding) * math.sqrt(0.5) + + return { + "encoder_out": (x, y), + "encoder_padding_mask": encoder_padding_mask, # B x T + } + + def reorder_encoder_out(self, encoder_out, new_order): + if encoder_out["encoder_out"] is not None: + encoder_out["encoder_out"] = ( + encoder_out["encoder_out"][0].index_select(0, new_order), + encoder_out["encoder_out"][1].index_select(0, new_order), + ) + if encoder_out["encoder_padding_mask"] is not None: + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(0, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return self.embed_positions.max_positions + + +class AttentionLayer(nn.Module): + def __init__(self, conv_channels, embed_dim, bmm=None): + super().__init__() + # projects from output of convolution to embedding dimension + self.in_projection = Linear(conv_channels, embed_dim) + # projects from embedding dimension to convolution size + self.out_projection = Linear(embed_dim, conv_channels) + + self.bmm = bmm if bmm is not None else torch.bmm + + def forward(self, x, target_embedding, encoder_out, encoder_padding_mask): + residual = x + + # attention + x = (self.in_projection(x) + target_embedding) * math.sqrt(0.5) + x = self.bmm(x, encoder_out[0]) + + # don't attend over padding + if encoder_padding_mask is not None: + x = ( + x.float() + .masked_fill(encoder_padding_mask.unsqueeze(1), float("-inf")) + .type_as(x) + ) # FP16 support: cast to float and back + + # softmax over last dim + sz = x.size() + x = F.softmax(x.view(sz[0] * sz[1], sz[2]), dim=1) + x = x.view(sz) + attn_scores = x + + x = self.bmm(x, encoder_out[1]) + + # scale attention output (respecting potentially different lengths) + s = encoder_out[1].size(1) + if encoder_padding_mask is None: + x = x * (s * math.sqrt(1.0 / s)) + else: + s = s - encoder_padding_mask.type_as(x).sum( + dim=1, keepdim=True + ) # exclude padding + s = s.unsqueeze(-1) + x = x * (s * s.rsqrt()) + + # project back + x = (self.out_projection(x) + residual) * math.sqrt(0.5) + return x, attn_scores + + def make_generation_fast_(self, beamable_mm_beam_size=None, **kwargs): + """Replace torch.bmm with BeamableMM.""" + if beamable_mm_beam_size is not None: + del self.bmm + self.add_module("bmm", BeamableMM(beamable_mm_beam_size)) + + +class FConvDecoder(FairseqIncrementalDecoder): + """Convolutional decoder""" + + def __init__( + self, + dictionary, + embed_dim=512, + embed_dict=None, + out_embed_dim=256, + max_positions=1024, + convolutions=((512, 3),) * 20, + attention=True, + dropout=0.1, + share_embed=False, + positional_embeddings=True, + adaptive_softmax_cutoff=None, + adaptive_softmax_dropout=0.0, + ): + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([2])) + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.need_attn = True + + convolutions = extend_conv_spec(convolutions) + in_channels = convolutions[0][0] + if isinstance(attention, bool): + # expand True into [True, True, ...] and do the same with False + attention = [attention] * len(convolutions) + if not isinstance(attention, list) or len(attention) != len(convolutions): + raise ValueError( + "Attention is expected to be a list of booleans of " + "length equal to the number of layers." + ) + + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + self.embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + if embed_dict: + self.embed_tokens = utils.load_embedding( + embed_dict, self.dictionary, self.embed_tokens + ) + + self.embed_positions = ( + PositionalEmbedding( + max_positions, + embed_dim, + padding_idx, + ) + if positional_embeddings + else None + ) + + self.fc1 = Linear(embed_dim, in_channels, dropout=dropout) + self.projections = nn.ModuleList() + self.convolutions = nn.ModuleList() + self.attention = nn.ModuleList() + self.residuals = [] + + layer_in_channels = [in_channels] + for i, (out_channels, kernel_size, residual) in enumerate(convolutions): + if residual == 0: + residual_dim = out_channels + else: + residual_dim = layer_in_channels[-residual] + self.projections.append( + Linear(residual_dim, out_channels) + if residual_dim != out_channels + else None + ) + self.convolutions.append( + LinearizedConv1d( + in_channels, + out_channels * 2, + kernel_size, + padding=(kernel_size - 1), + dropout=dropout, + ) + ) + self.attention.append( + AttentionLayer(out_channels, embed_dim) if attention[i] else None + ) + self.residuals.append(residual) + in_channels = out_channels + layer_in_channels.append(out_channels) + + self.adaptive_softmax = None + self.fc2 = self.fc3 = None + + if adaptive_softmax_cutoff is not None: + assert not share_embed + self.adaptive_softmax = AdaptiveSoftmax( + num_embeddings, + in_channels, + adaptive_softmax_cutoff, + dropout=adaptive_softmax_dropout, + ) + else: + self.fc2 = Linear(in_channels, out_embed_dim) + if share_embed: + assert out_embed_dim == embed_dim, ( + "Shared embed weights implies same dimensions " + " out_embed_dim={} vs embed_dim={}".format(out_embed_dim, embed_dim) + ) + self.fc3 = nn.Linear(out_embed_dim, num_embeddings) + self.fc3.weight = self.embed_tokens.weight + else: + self.fc3 = Linear(out_embed_dim, num_embeddings, dropout=dropout) + + def forward( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **unused + ): + if encoder_out is not None: + encoder_padding_mask = encoder_out["encoder_padding_mask"] + encoder_out = encoder_out["encoder_out"] + + # split and transpose encoder outputs + encoder_a, encoder_b = self._split_encoder_out( + encoder_out, incremental_state + ) + + if self.embed_positions is not None: + pos_embed = self.embed_positions(prev_output_tokens, incremental_state) + else: + pos_embed = 0 + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + x = self._embed_tokens(prev_output_tokens, incremental_state) + + # embed tokens and combine with positional embeddings + x += pos_embed + x = self.dropout_module(x) + target_embedding = x + + # project to size of convolution + x = self.fc1(x) + + # B x T x C -> T x B x C + x = self._transpose_if_training(x, incremental_state) + + # temporal convolutions + avg_attn_scores = None + num_attn_layers = len(self.attention) + residuals = [x] + for proj, conv, attention, res_layer in zip( + self.projections, self.convolutions, self.attention, self.residuals + ): + if res_layer > 0: + residual = residuals[-res_layer] + residual = residual if proj is None else proj(residual) + else: + residual = None + + x = self.dropout_module(x) + x = conv(x, incremental_state) + x = F.glu(x, dim=2) + + # attention + if attention is not None: + x = self._transpose_if_training(x, incremental_state) + + x, attn_scores = attention( + x, target_embedding, (encoder_a, encoder_b), encoder_padding_mask + ) + + if not self.training and self.need_attn: + attn_scores = attn_scores / num_attn_layers + if avg_attn_scores is None: + avg_attn_scores = attn_scores + else: + avg_attn_scores.add_(attn_scores) + + x = self._transpose_if_training(x, incremental_state) + + # residual + if residual is not None: + x = (x + residual) * math.sqrt(0.5) + residuals.append(x) + + # T x B x C -> B x T x C + x = self._transpose_if_training(x, incremental_state) + + # project back to size of vocabulary if not using adaptive softmax + if self.fc2 is not None and self.fc3 is not None: + x = self.fc2(x) + x = self.dropout_module(x) + x = self.fc3(x) + + return x, avg_attn_scores + + def reorder_incremental_state(self, incremental_state, new_order): + super().reorder_incremental_state(incremental_state, new_order) + encoder_out = utils.get_incremental_state( + self, incremental_state, "encoder_out" + ) + if encoder_out is not None: + encoder_out = tuple(eo.index_select(0, new_order) for eo in encoder_out) + utils.set_incremental_state( + self, incremental_state, "encoder_out", encoder_out + ) + + def max_positions(self): + """Maximum output length supported by the decoder.""" + return ( + self.embed_positions.max_positions + if self.embed_positions is not None + else float("inf") + ) + + def upgrade_state_dict(self, state_dict): + if utils.item(state_dict.get("decoder.version", torch.Tensor([1]))[0]) < 2: + # old models use incorrect weight norm dimension + for i, conv in enumerate(self.convolutions): + # reconfigure weight norm + nn.utils.remove_weight_norm(conv) + self.convolutions[i] = nn.utils.weight_norm(conv, dim=0) + state_dict["decoder.version"] = torch.Tensor([1]) + return state_dict + + def make_generation_fast_(self, need_attn=False, **kwargs): + self.need_attn = need_attn + + def _embed_tokens(self, tokens, incremental_state): + if incremental_state is not None: + # keep only the last token for incremental forward pass + tokens = tokens[:, -1:] + return self.embed_tokens(tokens) + + def _split_encoder_out(self, encoder_out, incremental_state): + """Split and transpose encoder outputs. + + This is cached when doing incremental inference. + """ + cached_result = utils.get_incremental_state( + self, incremental_state, "encoder_out" + ) + if cached_result is not None: + return cached_result + + # transpose only once to speed up attention layers + encoder_a, encoder_b = encoder_out + encoder_a = encoder_a.transpose(1, 2).contiguous() + result = (encoder_a, encoder_b) + + if incremental_state is not None: + utils.set_incremental_state(self, incremental_state, "encoder_out", result) + return result + + def _transpose_if_training(self, x, incremental_state): + if incremental_state is None: + x = x.transpose(0, 1) + return x + + +def extend_conv_spec(convolutions): + """ + Extends convolutional spec that is a list of tuples of 2 or 3 parameters + (kernel size, dim size and optionally how many layers behind to look for residual) + to default the residual propagation param if it is not specified + """ + extended = [] + for spec in convolutions: + if len(spec) == 3: + extended.append(spec) + elif len(spec) == 2: + extended.append(spec + (1,)) + else: + raise Exception( + "invalid number of parameters in convolution spec " + + str(spec) + + ". expected 2 or 3" + ) + return tuple(extended) + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, 0, 0.1) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def PositionalEmbedding(num_embeddings, embedding_dim, padding_idx): + m = LearnedPositionalEmbedding(num_embeddings, embedding_dim, padding_idx) + nn.init.normal_(m.weight, 0, 0.1) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, dropout=0.0): + """Weight-normalized Linear layer (input: N x T x C)""" + m = nn.Linear(in_features, out_features) + nn.init.normal_(m.weight, mean=0, std=math.sqrt((1 - dropout) / in_features)) + nn.init.constant_(m.bias, 0) + return nn.utils.weight_norm(m) + + +def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs): + """Weight-normalized Conv1d layer optimized for decoding""" + m = LinearizedConvolution(in_channels, out_channels, kernel_size, **kwargs) + std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels)) + nn.init.normal_(m.weight, mean=0, std=std) + nn.init.constant_(m.bias, 0) + return nn.utils.weight_norm(m, dim=2) + + +def ConvTBC(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs): + """Weight-normalized Conv1d layer""" + from fairseq.modules import ConvTBC + + m = ConvTBC(in_channels, out_channels, kernel_size, **kwargs) + std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels)) + nn.init.normal_(m.weight, mean=0, std=std) + nn.init.constant_(m.bias, 0) + return nn.utils.weight_norm(m, dim=2) + + +@register_model_architecture("fconv", "fconv") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_layers = getattr(args, "encoder_layers", "[(512, 3)] * 20") + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_layers = getattr(args, "decoder_layers", "[(512, 3)] * 20") + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256) + args.decoder_attention = getattr(args, "decoder_attention", "True") + args.share_input_output_embed = getattr(args, "share_input_output_embed", False) + + +@register_model_architecture("fconv", "fconv_iwslt_de_en") +def fconv_iwslt_de_en(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_layers = getattr(args, "encoder_layers", "[(256, 3)] * 4") + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_layers = getattr(args, "decoder_layers", "[(256, 3)] * 3") + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256) + base_architecture(args) + + +@register_model_architecture("fconv", "fconv_wmt_en_ro") +def fconv_wmt_en_ro(args): + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + base_architecture(args) + + +@register_model_architecture("fconv", "fconv_wmt_en_de") +def fconv_wmt_en_de(args): + convs = "[(512, 3)] * 9" # first 9 layers have 512 units + convs += " + [(1024, 3)] * 4" # next 4 layers have 1024 units + convs += " + [(2048, 1)] * 2" # final 2 layers use 1x1 convolutions + + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_layers = getattr(args, "encoder_layers", convs) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 768) + args.decoder_layers = getattr(args, "decoder_layers", convs) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + base_architecture(args) + + +@register_model_architecture("fconv", "fconv_wmt_en_fr") +def fconv_wmt_en_fr(args): + convs = "[(512, 3)] * 6" # first 6 layers have 512 units + convs += " + [(768, 3)] * 4" # next 4 layers have 768 units + convs += " + [(1024, 3)] * 3" # next 3 layers have 1024 units + convs += " + [(2048, 1)] * 1" # next 1 layer uses 1x1 convolutions + convs += " + [(4096, 1)] * 1" # final 1 layer uses 1x1 convolutions + + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_layers = getattr(args, "encoder_layers", convs) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 768) + args.decoder_layers = getattr(args, "decoder_layers", convs) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + base_architecture(args) diff --git a/fairseq/fairseq/models/fconv_lm.py b/fairseq/fairseq/models/fconv_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..4b243d6669cb57880353b45a01843ec22010fb5f --- /dev/null +++ b/fairseq/fairseq/models/fconv_lm.py @@ -0,0 +1,136 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq import utils +from fairseq.models import ( + FairseqLanguageModel, + register_model, + register_model_architecture, +) +from fairseq.models.fconv import FConvDecoder +from fairseq.utils import safe_hasattr + + +@register_model("fconv_lm") +class FConvLanguageModel(FairseqLanguageModel): + def __init__(self, decoder): + super().__init__(decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-layers", + type=str, + metavar="EXPR", + help="decoder layers [(dim, kernel_size), ...]", + ) + parser.add_argument( + "--decoder-out-embed-dim", + type=int, + metavar="N", + help="decoder output embedding dimension", + ) + parser.add_argument( + "--adaptive-softmax-cutoff", + metavar="EXPR", + help="comma separated list of adaptive softmax cutoff points. " + "Must be used with adaptive_loss criterion", + ) + parser.add_argument( + "--adaptive-softmax-dropout", + type=float, + metavar="D", + help="sets adaptive softmax dropout for the tail projections", + ) + parser.add_argument( + "--decoder-attention", + type=str, + metavar="EXPR", + help="decoder attention [True, ...]", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure all arguments are present in older models + base_lm_architecture(args) + + if safe_hasattr(args, "max_target_positions") and not safe_hasattr( + args, "tokens_per_sample" + ): + args.tokens_per_sample = args.max_target_positions + + decoder = FConvDecoder( + dictionary=task.target_dictionary, + embed_dim=args.decoder_embed_dim, + convolutions=eval(args.decoder_layers), + out_embed_dim=args.decoder_embed_dim, + attention=eval(args.decoder_attention), + dropout=args.dropout, + max_positions=args.tokens_per_sample, + share_embed=False, + positional_embeddings=False, + adaptive_softmax_cutoff=( + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int) + if args.criterion == "adaptive_loss" + else None + ), + adaptive_softmax_dropout=args.adaptive_softmax_dropout, + ) + return FConvLanguageModel(decoder) + + +@register_model_architecture("fconv_lm", "fconv_lm") +def base_lm_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 128) + args.decoder_layers = getattr(args, "decoder_layers", "[(1268, 4)] * 13") + args.decoder_attention = getattr(args, "decoder_attention", "False") + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + + +@register_model_architecture("fconv_lm", "fconv_lm_dauphin_wikitext103") +def fconv_lm_dauphin_wikitext103(args): + layers = "[(850, 6)] * 3" + layers += " + [(850, 1)] * 1" + layers += " + [(850, 5)] * 4" + layers += " + [(850, 1)] * 1" + layers += " + [(850, 4)] * 3" + layers += " + [(1024, 4)] * 1" + layers += " + [(2048, 4)] * 1" + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 280) + args.decoder_layers = getattr(args, "decoder_layers", layers) + args.decoder_attention = getattr(args, "decoder_attention", "False") + args.adaptive_softmax_cutoff = getattr( + args, "adaptive_softmax_cutoff", "10000,20000,200000" + ) + base_lm_architecture(args) + + +@register_model_architecture("fconv_lm", "fconv_lm_dauphin_gbw") +def fconv_lm_dauphin_gbw(args): + layers = "[(512, 5)]" + layers += " + [(128, 1, 0), (128, 5, 0), (512, 1, 3)] * 3" + layers += " + [(512, 1, 0), (512, 5, 0), (1024, 1, 3)] * 3" + layers += " + [(1024, 1, 0), (1024, 5, 0), (2048, 1, 3)] * 6" + layers += " + [(1024, 1, 0), (1024, 5, 0), (4096, 1, 3)]" + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 128) + args.decoder_layers = getattr(args, "decoder_layers", layers) + args.decoder_attention = getattr(args, "decoder_attention", "False") + args.adaptive_softmax_cutoff = getattr( + args, "adaptive_softmax_cutoff", "10000,50000,200000" + ) + base_lm_architecture(args) diff --git a/fairseq/fairseq/models/fconv_self_att.py b/fairseq/fairseq/models/fconv_self_att.py new file mode 100644 index 0000000000000000000000000000000000000000..8357ef7847ed25a62345e219c41906156828c233 --- /dev/null +++ b/fairseq/fairseq/models/fconv_self_att.py @@ -0,0 +1,674 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import math +import os + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import checkpoint_utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.models import ( + CompositeEncoder, + FairseqDecoder, + FairseqEncoder, + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + DownsampledMultiHeadAttention, + FairseqDropout, + GradMultiply, + LayerNorm, + LearnedPositionalEmbedding, + LinearizedConvolution, +) + + +logger = logging.getLogger(__name__) + + +@register_model("fconv_self_att") +class FConvModelSelfAtt(FairseqEncoderDecoderModel): + @classmethod + def hub_models(cls): + return { + "conv.stories.pretrained": { + "path": "https://dl.fbaipublicfiles.com/fairseq/models/stories_checkpoint.tar.gz", + "checkpoint_file": "pretrained_checkpoint.pt", + "tokenizer": "nltk", + }, + "conv.stories": { + "path": "https://dl.fbaipublicfiles.com/fairseq/models/stories_checkpoint.tar.gz", + "checkpoint_file": "fusion_checkpoint.pt", + "tokenizer": "nltk", + "pretrained": "True", + "pretrained_checkpoint": "./pretrained_checkpoint.pt", + }, + # Test set containing dictionaries + "data.stories": "https://dl.fbaipublicfiles.com/fairseq/data/stories_test.tar.bz2", + } + + def __init__(self, encoder, decoder, pretrained_encoder=None): + super().__init__(encoder, decoder) + self.encoder.num_attention_layers = sum( + layer is not None for layer in decoder.attention + ) + self.pretrained_encoder = pretrained_encoder + if self.pretrained_encoder is None: + encoders = {"encoder": encoder} + else: + encoders = {"encoder": encoder, "pretrained": self.pretrained_encoder} + # for fusion model, CompositeEncoder contains both pretrained and training encoders + # these are forwarded and then combined in the decoder + self.encoder = CompositeEncoder(encoders) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-layers', type=str, metavar='EXPR', + help='encoder layers [(dim, kernel_size), ...]') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-layers', type=str, metavar='EXPR', + help='decoder layers [(dim, kernel_size), ...]') + parser.add_argument('--decoder-out-embed-dim', type=int, metavar='N', + help='decoder output embedding dimension') + parser.add_argument('--decoder-attention', type=str, metavar='EXPR', + help='decoder attention [True, ...]') + parser.add_argument('--self-attention', type=str, metavar='EXPR', + help='decoder self-attention layers, ex: [True] + [False]*5') + parser.add_argument('--multihead-attention-nheads', type=int, + help='Number of heads to use in attention') + parser.add_argument('--multihead-self-attention-nheads', type=int, + help='Number of heads to use in self-attention') + parser.add_argument('--encoder-attention', type=str, metavar='EXPR', + help='encoder attention [True, ...]') + parser.add_argument('--encoder-attention-nheads', type=int, + help='Number of heads to use in encoder attention') + parser.add_argument('--project-input', type=str, metavar='EXPR', + help='Use projections in self-attention [True, ...]') + parser.add_argument('--gated-attention', type=str, metavar='EXPR', + help='Use GLU layers in self-attention projections [True, ...]') + parser.add_argument('--downsample', type=str, metavar='EXPR', + help='Use downsampling in self-attention [True, ...]') + parser.add_argument('--pretrained-checkpoint', metavar='DIR', + help='path to load checkpoint from pretrained model') + parser.add_argument('--pretrained', type=str, metavar='EXPR', + help='use pretrained model when training [True, ...]') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + trained_encoder, trained_decoder = None, None + pretrained = eval(args.pretrained) + if pretrained: + logger.info("loading pretrained model") + if not os.path.exists(args.pretrained_checkpoint): + new_pretrained_checkpoint = os.path.join( + args.data, args.pretrained_checkpoint + ) + if os.path.exists(new_pretrained_checkpoint): + args.pretrained_checkpoint = new_pretrained_checkpoint + trained_model = checkpoint_utils.load_model_ensemble( + filenames=[args.pretrained_checkpoint], + task=task, + )[0][0] + trained_decoder = list(trained_model.children())[1] + trained_encoder = list(trained_model.children())[0] + + # freeze pretrained model + for param in trained_decoder.parameters(): + param.requires_grad = False + for param in trained_encoder.parameters(): + param.requires_grad = False + + encoder = FConvEncoder( + task.source_dictionary, + embed_dim=args.encoder_embed_dim, + convolutions=eval(args.encoder_layers), + dropout=args.dropout, + max_positions=args.max_source_positions, + attention=eval(args.encoder_attention), + attention_nheads=args.encoder_attention_nheads, + ) + + decoder = FConvDecoder( + task.target_dictionary, + embed_dim=args.decoder_embed_dim, + convolutions=eval(args.decoder_layers), + out_embed_dim=args.decoder_out_embed_dim, + attention=eval(args.decoder_attention), + dropout=args.dropout, + max_positions=args.max_target_positions, + selfattention=eval(args.self_attention), + attention_nheads=args.multihead_attention_nheads, + selfattention_nheads=args.multihead_self_attention_nheads, + project_input=eval(args.project_input), + gated_attention=eval(args.gated_attention), + downsample=eval(args.downsample), + pretrained=pretrained, + trained_decoder=trained_decoder, + ) + model = FConvModelSelfAtt(encoder, decoder, trained_encoder) + + return model + + @property + def pretrained(self): + return self.pretrained_encoder is not None + + +class FConvEncoder(FairseqEncoder): + """Convolutional encoder""" + + def __init__( + self, + dictionary, + embed_dim=512, + max_positions=1024, + convolutions=((512, 3),) * 20, + dropout=0.1, + attention=False, + attention_nheads=1, + ): + super().__init__(dictionary) + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.num_attention_layers = None + + num_embeddings = len(dictionary) + self.padding_idx = dictionary.pad() + self.embed_tokens = Embedding(num_embeddings, embed_dim, self.padding_idx) + self.embed_positions = PositionalEmbedding( + max_positions, + embed_dim, + self.padding_idx, + ) + + def expand_bool_array(val): + if isinstance(val, bool): + # expand True into [True, True, ...] and do the same with False + return [val] * len(convolutions) + return val + + attention = expand_bool_array(attention) + + in_channels = convolutions[0][0] + self.fc1 = Linear(embed_dim, in_channels, dropout=dropout) + self.projections = nn.ModuleList() + self.convolutions = nn.ModuleList() + self.attention = nn.ModuleList() + self.attproj = nn.ModuleList() + for i, (out_channels, kernel_size) in enumerate(convolutions): + self.projections.append( + Linear(in_channels, out_channels) + if in_channels != out_channels + else None + ) + self.convolutions.append( + ConvTBC(in_channels, out_channels * 2, kernel_size, dropout=dropout) + ) + + self.attention.append( + SelfAttention(out_channels, embed_dim, attention_nheads) + if attention[i] + else None + ) + in_channels = out_channels + + self.fc2 = Linear(in_channels, embed_dim) + + def forward(self, src_tokens, src_lengths): + # embed tokens and positions + x = self.embed_tokens(src_tokens) + self.embed_positions(src_tokens) + x = self.dropout_module(x) + input_embedding = x.transpose(0, 1) + + # project to size of convolution + x = self.fc1(x) + + encoder_padding_mask = src_tokens.eq(self.padding_idx).t() # -> T x B + if not encoder_padding_mask.any(): + encoder_padding_mask = None + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # temporal convolutions + for proj, conv, attention in zip( + self.projections, self.convolutions, self.attention + ): + residual = x if proj is None else proj(x) + + if encoder_padding_mask is not None: + x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0) + + x = self.dropout_module(x) + padding_l = (conv.kernel_size[0] - 1) // 2 + padding_r = conv.kernel_size[0] // 2 + x = F.pad(x, (0, 0, 0, 0, padding_l, padding_r)) + x = conv(x) + x = F.glu(x, dim=2) + if attention is not None: + x = attention(x) + x = (x + residual) * math.sqrt(0.5) + + # T x B x C -> B x T x C + x = x.transpose(1, 0) + + # project back to size of embedding + x = self.fc2(x) + + if encoder_padding_mask is not None: + encoder_padding_mask = encoder_padding_mask.t() # -> B x T + x = x.masked_fill(encoder_padding_mask.unsqueeze(-1), 0) + + # scale gradients (this only affects backward, not forward) + x = GradMultiply.apply(x, 1.0 / (2.0 * self.num_attention_layers)) + + # add output to input embedding for attention + y = (x + input_embedding.transpose(0, 1)) * math.sqrt(0.5) + + return { + "encoder_out": (x, y), + "encoder_padding_mask": encoder_padding_mask, # B x T + } + + def reorder_encoder_out(self, encoder_out, new_order): + encoder_out["encoder_out"] = tuple( + eo.index_select(0, new_order) for eo in encoder_out["encoder_out"] + ) + + if encoder_out["encoder_padding_mask"] is not None: + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(0, new_order) + + if "pretrained" in encoder_out: + encoder_out["pretrained"]["encoder_out"] = tuple( + eo.index_select(0, new_order) + for eo in encoder_out["pretrained"]["encoder_out"] + ) + + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return self.embed_positions.max_positions + + +@with_incremental_state +class FConvDecoder(FairseqDecoder): + """Convolutional decoder""" + + def __init__( + self, + dictionary, + embed_dim=512, + out_embed_dim=256, + max_positions=1024, + convolutions=((512, 3),) * 8, + attention=True, + dropout=0.1, + selfattention=False, + attention_nheads=1, + selfattention_nheads=1, + project_input=False, + gated_attention=False, + downsample=False, + pretrained=False, + trained_decoder=None, + ): + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([2])) + self.pretrained = pretrained + self.pretrained_decoder = trained_decoder + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.need_attn = True + in_channels = convolutions[0][0] + + def expand_bool_array(val): + if isinstance(val, bool): + # expand True into [True, True, ...] and do the same with False + return [val] * len(convolutions) + return val + + attention = expand_bool_array(attention) + selfattention = expand_bool_array(selfattention) + + if not isinstance(attention, list) or len(attention) != len(convolutions): + raise ValueError( + "Attention is expected to be a list of booleans of " + "length equal to the number of layers." + ) + + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + self.embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + + self.embed_positions = PositionalEmbedding( + max_positions, + embed_dim, + padding_idx, + ) + + self.fc1 = Linear(embed_dim, in_channels, dropout=dropout) + self.projections = nn.ModuleList() + self.convolutions = nn.ModuleList() + self.attention = nn.ModuleList() + self.selfattention = nn.ModuleList() + self.attproj = nn.ModuleList() + for i, (out_channels, kernel_size) in enumerate(convolutions): + self.projections.append( + Linear(in_channels, out_channels) + if in_channels != out_channels + else None + ) + self.convolutions.append( + LinearizedConv1d( + in_channels, + out_channels * 2, + kernel_size, + padding=(kernel_size - 1), + dropout=dropout, + ) + ) + + self.attention.append( + DownsampledMultiHeadAttention( + out_channels, + embed_dim, + attention_nheads, + project_input=project_input, + gated=False, + downsample=False, + ) + if attention[i] + else None + ) + + self.attproj.append( + Linear(out_channels, embed_dim, dropout=dropout) + if attention[i] + else None + ) + self.selfattention.append( + SelfAttention( + out_channels, + embed_dim, + selfattention_nheads, + project_input=project_input, + gated=gated_attention, + downsample=downsample, + ) + if selfattention[i] + else None + ) + in_channels = out_channels + + self.fc2 = Linear(in_channels, out_embed_dim) + self.fc3 = Linear(out_embed_dim, num_embeddings, dropout=dropout) + + # model fusion + if self.pretrained: + # independent gates are learned from the concatenated input + self.gate1 = nn.Sequential( + Linear(out_embed_dim * 2, out_embed_dim), nn.Sigmoid() + ) + self.gate2 = nn.Sequential( + Linear(out_embed_dim * 2, out_embed_dim), nn.Sigmoid() + ) + # pretrained and trained models are joined + self.joining = nn.Sequential( + Linear(out_embed_dim * 2, out_embed_dim * 2), + LayerNorm(out_embed_dim * 2), + nn.GLU(), + Linear(out_embed_dim, out_embed_dim * 2), + LayerNorm(out_embed_dim * 2), + nn.GLU(), + Linear(out_embed_dim, out_embed_dim), + LayerNorm(out_embed_dim), + ) + # pretrained model contains an output layer that is nhid -> vocab size + # but the models are combined in their hidden state + # the hook stores the output of the pretrained model forward + self.pretrained_outputs = {} + + def save_output(): + def hook(a, b, output): + self.pretrained_outputs["out"] = output + + return hook + + self.pretrained_decoder.fc2.register_forward_hook(save_output()) + + def forward(self, prev_output_tokens, encoder_out): + trained_encoder_out = encoder_out["pretrained"] if self.pretrained else None + encoder_out = encoder_out["encoder"]["encoder_out"] + + encoder_a, encoder_b = self._split_encoder_out(encoder_out) + + # embed positions + positions = self.embed_positions(prev_output_tokens) + + # embed tokens and positions + x = self.embed_tokens(prev_output_tokens) + positions + x = self.dropout_module(x) + target_embedding = x.transpose(0, 1) + + # project to size of convolution + x = self.fc1(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # temporal convolutions + avg_attn_scores = None + for proj, conv, attention, selfattention, attproj in zip( + self.projections, + self.convolutions, + self.attention, + self.selfattention, + self.attproj, + ): + residual = x if proj is None else proj(x) + + x = self.dropout_module(x) + x = conv(x) + x = F.glu(x, dim=2) + + # attention + if attention is not None: + r = x + x, attn_scores = attention( + attproj(x) + target_embedding, encoder_a, encoder_b + ) + x = x + r + if not self.training and self.need_attn: + if avg_attn_scores is None: + avg_attn_scores = attn_scores + else: + avg_attn_scores.add_(attn_scores) + + if selfattention is not None: + x = selfattention(x) + + x = (x + residual) * math.sqrt(0.5) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + # project back to size of vocabulary + x = self.fc2(x) + x = self.dropout_module(x) + if not self.pretrained: + x = self.fc3(x) + + # fusion gating + if self.pretrained: + trained_x, _ = self.pretrained_decoder.forward( + prev_output_tokens, trained_encoder_out + ) + y = torch.cat([x, self.pretrained_outputs["out"]], dim=-1) + gate1 = self.gate1(y) + gate2 = self.gate2(y) + gated_x1 = gate1 * x + gated_x2 = gate2 * self.pretrained_outputs["out"] + fusion = torch.cat([gated_x1, gated_x2], dim=-1) + fusion = self.joining(fusion) + fusion_output = self.fc3(fusion) + return fusion_output, avg_attn_scores + else: + return x, avg_attn_scores + + def max_positions(self): + """Maximum output length supported by the decoder.""" + return self.embed_positions.max_positions + + def make_generation_fast_(self, need_attn=False, **kwargs): + self.need_attn = need_attn + + def _split_encoder_out(self, encoder_out): + """Split and transpose encoder outputs.""" + # transpose only once to speed up attention layers + encoder_a, encoder_b = encoder_out + encoder_a = encoder_a.transpose(0, 1).contiguous() + encoder_b = encoder_b.transpose(0, 1).contiguous() + result = (encoder_a, encoder_b) + return result + + +class SelfAttention(nn.Module): + def __init__( + self, + out_channels, + embed_dim, + num_heads, + project_input=False, + gated=False, + downsample=False, + ): + super().__init__() + self.attention = DownsampledMultiHeadAttention( + out_channels, + embed_dim, + num_heads, + dropout=0, + bias=True, + project_input=project_input, + gated=gated, + downsample=downsample, + ) + self.in_proj_q = Linear(out_channels, embed_dim) + self.in_proj_k = Linear(out_channels, embed_dim) + self.in_proj_v = Linear(out_channels, embed_dim) + self.ln = LayerNorm(out_channels) + + def forward(self, x): + residual = x + query = self.in_proj_q(x) + key = self.in_proj_k(x) + value = self.in_proj_v(x) + x, _ = self.attention( + query, key, value, mask_future_timesteps=True, use_scalar_bias=True + ) + return self.ln(x + residual) + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + m.weight.data.normal_(0, 0.1) + return m + + +def PositionalEmbedding(num_embeddings, embedding_dim, padding_idx): + m = LearnedPositionalEmbedding(num_embeddings, embedding_dim, padding_idx) + m.weight.data.normal_(0, 0.1) + return m + + +def Linear(in_features, out_features, dropout=0.0): + """Weight-normalized Linear layer (input: N x T x C)""" + m = nn.Linear(in_features, out_features) + m.weight.data.normal_(mean=0, std=math.sqrt((1 - dropout) / in_features)) + m.bias.data.zero_() + return m + + +def LinearizedConv1d(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs): + """Weight-normalized Conv1d layer optimized for decoding""" + m = LinearizedConvolution(in_channels, out_channels, kernel_size, **kwargs) + std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels)) + m.weight.data.normal_(mean=0, std=std) + m.bias.data.zero_() + return m + + +def ConvTBC(in_channels, out_channels, kernel_size, dropout=0.0, **kwargs): + """Weight-normalized Conv1d layer""" + from fairseq.modules import ConvTBC + + m = ConvTBC(in_channels, out_channels, kernel_size, **kwargs) + std = math.sqrt((4 * (1.0 - dropout)) / (m.kernel_size[0] * in_channels)) + m.weight.data.normal_(mean=0, std=std) + m.bias.data.zero_() + return m + + +@register_model_architecture("fconv_self_att", "fconv_self_att") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_layers = getattr(args, "encoder_layers", "[(512, 3)] * 3") + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_layers = getattr(args, "decoder_layers", "[(512, 3)] * 8") + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256) + args.decoder_attention = getattr(args, "decoder_attention", "True") + args.self_attention = getattr(args, "self_attention", "False") + args.encoder_attention = getattr(args, "encoder_attention", "False") + args.multihead_attention_nheads = getattr(args, "multihead_attention_nheads", 1) + args.multihead_self_attention_nheads = getattr( + args, "multihead_self_attention_nheads", 1 + ) + args.encoder_attention_nheads = getattr(args, "encoder_attention_nheads", 1) + args.project_input = getattr(args, "project_input", "False") + args.gated_attention = getattr(args, "gated_attention", "False") + args.downsample = getattr(args, "downsample", "False") + args.pretrained_checkpoint = getattr(args, "pretrained_checkpoint", "") + args.pretrained = getattr(args, "pretrained", "False") + + +@register_model_architecture("fconv_self_att", "fconv_self_att_wp") +def fconv_self_att_wp(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_layers = getattr( + args, "encoder_layers", "[(128, 3)] * 2 + [(512,3)] * 1" + ) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_layers = getattr( + args, "decoder_layers", "[(512, 4)] * 4 + [(768, 4)] * 2 + [(1024, 4)] * 1" + ) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256) + args.self_attention = getattr(args, "self_attention", "True") + args.multihead_self_attention_nheads = getattr( + args, "multihead_self_attention_nheads", 4 + ) + args.project_input = getattr(args, "project_input", "True") + args.gated_attention = getattr(args, "gated_attention", "True") + args.downsample = getattr(args, "downsample", "True") + base_architecture(args) diff --git a/fairseq/fairseq/models/hubert/__init__.py b/fairseq/fairseq/models/hubert/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a1b0eabbdbcaf12b15bb96b329ab1e276256f79a --- /dev/null +++ b/fairseq/fairseq/models/hubert/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .hubert import * # noqa +from .hubert_asr import * # noqa diff --git a/fairseq/fairseq/models/hubert/hubert.py b/fairseq/fairseq/models/hubert/hubert.py new file mode 100644 index 0000000000000000000000000000000000000000..232a5e402a146023e5c93f3c2574ecec98faf9d5 --- /dev/null +++ b/fairseq/fairseq/models/hubert/hubert.py @@ -0,0 +1,563 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import Dict, List, Optional, Tuple + +import numpy as np + +import torch +import torch.nn as nn +from dataclasses import dataclass, field +from fairseq import utils +from fairseq.data.data_utils import compute_mask_indices +from fairseq.data.dictionary import Dictionary +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.models import BaseFairseqModel, register_model +from fairseq.models.wav2vec.wav2vec2 import ( + ConvFeatureExtractionModel, + TransformerEncoder, +) +from fairseq.modules import GradMultiply, LayerNorm +from fairseq.tasks.hubert_pretraining import ( + HubertPretrainingConfig, + HubertPretrainingTask, +) +from omegaconf import II + +logger = logging.getLogger(__name__) + +EXTRACTOR_MODE_CHOICES = ChoiceEnum(["default", "layer_norm"]) +MASKING_DISTRIBUTION_CHOICES = ChoiceEnum( + ["static", "uniform", "normal", "poisson"] +) + + +@dataclass +class HubertConfig(FairseqDataclass): + label_rate: int = II("task.label_rate") + + extractor_mode: EXTRACTOR_MODE_CHOICES = field( + default="default", + metadata={ + "help": "mode for feature extractor. default has a single group " + "norm with d groups in the first conv block, whereas layer_norm " + "has layer norms in every block (meant to use with normalize=True)" + }, + ) + encoder_layers: int = field( + default=12, metadata={"help": "num encoder layers in the transformer"} + ) + encoder_embed_dim: int = field( + default=768, metadata={"help": "encoder embedding dimension"} + ) + encoder_ffn_embed_dim: int = field( + default=3072, metadata={"help": "encoder embedding dimension for FFN"} + ) + encoder_attention_heads: int = field( + default=12, metadata={"help": "num encoder attention heads"} + ) + activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field( + default="gelu", metadata={"help": "activation function to use"} + ) + + # dropouts + dropout: float = field( + default=0.1, + metadata={"help": "dropout probability for the transformer"}, + ) + attention_dropout: float = field( + default=0.1, + metadata={"help": "dropout probability for attention weights"}, + ) + activation_dropout: float = field( + default=0.0, + metadata={"help": "dropout probability after activation in FFN"}, + ) + encoder_layerdrop: float = field( + default=0.0, + metadata={"help": "probability of dropping a tarnsformer layer"}, + ) + dropout_input: float = field( + default=0.0, + metadata={"help": "dropout to apply to the input (after feat extr)"}, + ) + dropout_features: float = field( + default=0.0, + metadata={ + "help": "dropout to apply to the features (after feat extr)" + }, + ) + + final_dim: int = field( + default=0, + metadata={ + "help": "project final representations and targets to this many " + "dimensions. set to encoder_embed_dim is <= 0" + }, + ) + untie_final_proj: bool = field( + default=False, + metadata={"help": "use separate projection for each target"}, + ) + layer_norm_first: bool = field( + default=False, + metadata={"help": "apply layernorm first in the transformer"}, + ) + conv_feature_layers: str = field( + default="[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2", + metadata={ + "help": "string describing convolutional feature extraction " + "layers in form of a python list that contains " + "[(dim, kernel_size, stride), ...]" + }, + ) + conv_bias: bool = field( + default=False, metadata={"help": "include bias in conv encoder"} + ) + logit_temp: float = field( + default=0.1, metadata={"help": "temperature to divide logits by"} + ) + target_glu: bool = field( + default=False, metadata={"help": "adds projection + glu to targets"} + ) + feature_grad_mult: float = field( + default=1.0, + metadata={"help": "multiply feature extractor var grads by this"}, + ) + + # masking + mask_length: int = field(default=10, metadata={"help": "mask length"}) + mask_prob: float = field( + default=0.65, + metadata={"help": "probability of replacing a token with mask"}, + ) + mask_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", metadata={"help": "how to choose mask length"} + ) + mask_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument " + "(used for more complex distributions), " + "see help in compute_mask_indicesh" + }, + ) + no_mask_overlap: bool = field( + default=False, metadata={"help": "whether to allow masks to overlap"} + ) + mask_min_space: int = field( + default=1, + metadata={ + "help": "min space between spans (if no overlap is enabled)" + }, + ) + + # channel masking + mask_channel_length: int = field( + default=10, + metadata={"help": "length of the mask for features (channels)"}, + ) + mask_channel_prob: float = field( + default=0.0, + metadata={"help": "probability of replacing a feature with 0"}, + ) + mask_channel_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", + metadata={"help": "how to choose mask length for channel masking"}, + ) + mask_channel_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument " + "(used for more complex distributions), " + "see help in compute_mask_indicesh" + }, + ) + no_mask_channel_overlap: bool = field( + default=False, + metadata={"help": "whether to allow channel masks to overlap"}, + ) + mask_channel_min_space: int = field( + default=1, + metadata={ + "help": "min space between spans (if no overlap is enabled)" + }, + ) + + # positional embeddings + conv_pos: int = field( + default=128, + metadata={ + "help": "number of filters for convolutional positional embeddings" + }, + ) + conv_pos_groups: int = field( + default=16, + metadata={ + "help": "number of groups for convolutional positional embedding" + }, + ) + + latent_temp: Tuple[float, float, float] = field( + default=(2, 0.5, 0.999995), + metadata={"help": "legacy (to be removed)"}, + ) + + # loss computation + skip_masked: bool = field( + default=False, + metadata={"help": "skip computing losses over masked frames"}, + ) + skip_nomask: bool = field( + default=False, + metadata={"help": "skip computing losses over unmasked frames"}, + ) + + +@register_model("hubert", dataclass=HubertConfig) +class HubertModel(BaseFairseqModel): + def __init__( + self, + cfg: HubertConfig, + task_cfg: HubertPretrainingConfig, + dictionaries: List[Dictionary], + ) -> None: + super().__init__() + logger.info(f"HubertModel Config: {cfg}") + + feature_enc_layers = eval(cfg.conv_feature_layers) # noqa + self.embed = feature_enc_layers[-1][0] + + self.feature_extractor = ConvFeatureExtractionModel( + conv_layers=feature_enc_layers, + dropout=0.0, + mode=cfg.extractor_mode, + conv_bias=cfg.conv_bias, + ) + feature_ds_rate = np.prod([s for _, _, s in feature_enc_layers]) + self.feat2tar_ratio = ( + cfg.label_rate * feature_ds_rate / task_cfg.sample_rate + ) + + self.post_extract_proj = ( + nn.Linear(self.embed, cfg.encoder_embed_dim) + if self.embed != cfg.encoder_embed_dim + else None + ) + + self.mask_prob = cfg.mask_prob + self.mask_selection = cfg.mask_selection + self.mask_other = cfg.mask_other + self.mask_length = cfg.mask_length + self.no_mask_overlap = cfg.no_mask_overlap + self.mask_min_space = cfg.mask_min_space + + self.mask_channel_prob = cfg.mask_channel_prob + self.mask_channel_selection = cfg.mask_channel_selection + self.mask_channel_other = cfg.mask_channel_other + self.mask_channel_length = cfg.mask_channel_length + self.no_mask_channel_overlap = cfg.no_mask_channel_overlap + self.mask_channel_min_space = cfg.mask_channel_min_space + + self.dropout_input = nn.Dropout(cfg.dropout_input) + self.dropout_features = nn.Dropout(cfg.dropout_features) + + self.feature_grad_mult = cfg.feature_grad_mult + self.logit_temp = cfg.logit_temp + self.skip_masked = cfg.skip_masked + self.skip_nomask = cfg.skip_nomask + + final_dim = ( + cfg.final_dim if cfg.final_dim > 0 else cfg.encoder_embed_dim + ) + + self.mask_emb = nn.Parameter( + torch.FloatTensor(cfg.encoder_embed_dim).uniform_() + ) + + self.encoder = TransformerEncoder(cfg) + self.layer_norm = LayerNorm(self.embed) + + self.target_glu = None + if cfg.target_glu: + self.target_glu = nn.Sequential( + nn.Linear(final_dim, final_dim * 2), nn.GLU() + ) + + self.untie_final_proj = cfg.untie_final_proj + if self.untie_final_proj: + self.final_proj = nn.Linear( + cfg.encoder_embed_dim, final_dim * len(dictionaries) + ) + else: + self.final_proj = nn.Linear(cfg.encoder_embed_dim, final_dim) + + # modules below are not needed during fine-tuning + if any([d is None for d in dictionaries]): + logger.info( + "cannot find dictionary. assume will be used for fine-tuning" + ) + else: + self.num_classes = [len(d) for d in dictionaries] + self.label_embs_concat = nn.Parameter( + torch.FloatTensor(sum(self.num_classes), final_dim) + ) + nn.init.uniform_(self.label_embs_concat) + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + + super().upgrade_state_dict_named(state_dict, name) + return state_dict + + @classmethod + def build_model(cls, cfg: HubertConfig, task: HubertPretrainingTask): + """Build a new model instance.""" + + model = HubertModel(cfg, task.cfg, task.dictionaries) + return model + + def apply_mask(self, x, padding_mask, target_list): + B, T, C = x.shape + if self.mask_prob > 0: + mask_indices = compute_mask_indices( + (B, T), + padding_mask, + self.mask_prob, + self.mask_length, + self.mask_selection, + self.mask_other, + min_masks=2, + no_overlap=self.no_mask_overlap, + min_space=self.mask_min_space, + ) + mask_indices = torch.from_numpy(mask_indices).to(x.device) + x[mask_indices] = self.mask_emb + else: + mask_indices = None + + if self.mask_channel_prob > 0: + mask_channel_indices = compute_mask_indices( + (B, C), + None, + self.mask_channel_prob, + self.mask_channel_length, + self.mask_channel_selection, + self.mask_channel_other, + no_overlap=self.no_mask_channel_overlap, + min_space=self.mask_channel_min_space, + ) + mask_channel_indices = ( + torch.from_numpy(mask_channel_indices) + .to(x.device) + .unsqueeze(1) + .expand(-1, T, -1) + ) + x[mask_channel_indices] = 0 + + return x, mask_indices + + def compute_nce(self, x, pos, negs): + neg_is_pos = (pos == negs).all(-1) + pos = pos.unsqueeze(0) + targets = torch.cat([pos, negs], dim=0) + + logits = torch.cosine_similarity( + x.float(), targets.float(), dim=-1 + ).type_as(x) + logits /= self.logit_temp + if neg_is_pos.any(): + logits[1:][neg_is_pos] = float("-inf") + logits = logits.transpose(0, 1) # (num_x, num_cls+1) + return logits + + def forward_features(self, source: torch.Tensor) -> torch.Tensor: + if self.feature_grad_mult > 0: + features = self.feature_extractor(source) + if self.feature_grad_mult != 1.0: + features = GradMultiply.apply(features, self.feature_grad_mult) + else: + with torch.no_grad(): + features = self.feature_extractor(source) + return features + + def forward_targets( + self, features: torch.Tensor, target_list: List[torch.Tensor], + ) -> Tuple[torch.Tensor, torch.Tensor]: + # Trim features to ensure labels exist and then get aligned labels + feat_tsz = features.size(2) + targ_tsz = min([t.size(1) for t in target_list]) + if self.feat2tar_ratio * feat_tsz > targ_tsz: + feat_tsz = int(targ_tsz / self.feat2tar_ratio) + features = features[..., :feat_tsz] + target_inds = torch.arange(feat_tsz).float() * self.feat2tar_ratio + target_list = [t[:, target_inds.long()] for t in target_list] + return features, target_list + + def forward_padding_mask( + self, features: torch.Tensor, padding_mask: torch.Tensor, + ) -> torch.Tensor: + extra = padding_mask.size(1) % features.size(1) + if extra > 0: + padding_mask = padding_mask[:, :-extra] + padding_mask = padding_mask.view( + padding_mask.size(0), features.size(1), -1 + ) + padding_mask = padding_mask.all(-1) + return padding_mask + + def forward( + self, + source: torch.Tensor, + target_list: Optional[List[torch.Tensor]] = None, + padding_mask: Optional[torch.Tensor] = None, + mask: bool = True, + features_only: bool = False, + output_layer: Optional[int] = None, + ) -> Dict[str, torch.Tensor]: + """output layer is 1-based""" + features = self.forward_features(source) + if target_list is not None: + features, target_list = self.forward_targets(features, target_list) + + features_pen = features.float().pow(2).mean() + + features = features.transpose(1, 2) + features = self.layer_norm(features) + unmasked_features = features.clone() + + if padding_mask is not None: + padding_mask = self.forward_padding_mask(features, padding_mask) + + if self.post_extract_proj is not None: + features = self.post_extract_proj(features) + + features = self.dropout_input(features) + unmasked_features = self.dropout_features(unmasked_features) + + if mask: + x, mask_indices = self.apply_mask( + features, padding_mask, target_list + ) + else: + x = features + mask_indices = None + + # feature: (B, T, D), float + # target: (B, T), long + # x: (B, T, D), float + # padding_mask: (B, T), bool + # mask_indices: (B, T), bool + x, _ = self.encoder( + x, + padding_mask=padding_mask, + layer=None if output_layer is None else output_layer - 1 + ) + + if features_only: + return {"x": x, "padding_mask": padding_mask, "features": features} + + def compute_pred(proj_x, target, label_embs): + # compute logits for the i-th label set + y = torch.index_select(label_embs, 0, target.long()) + negs = label_embs.unsqueeze(1).expand(-1, proj_x.size(0), -1) + if self.target_glu: + y = self.target_glu(y) + negs = self.target_glu(negs) + # proj_x: (S, D) + # y: (S, D) + # negs: (Neg, S, D) + return self.compute_nce(proj_x, y, negs) + + label_embs_list = self.label_embs_concat.split(self.num_classes, 0) + + if not self.skip_masked: + masked_indices = torch.logical_and(~padding_mask, mask_indices) + proj_x_m = self.final_proj(x[masked_indices]) + if self.untie_final_proj: + proj_x_m_list = proj_x_m.chunk(len(target_list), dim=-1) + else: + proj_x_m_list = [proj_x_m for _ in range(len(target_list))] + logit_m_list = [ + compute_pred(proj_x_m, t[masked_indices], label_embs_list[i]) + for i, (proj_x_m, t) in enumerate( + zip(proj_x_m_list, target_list) + ) + ] + else: + logit_m_list = [None for _ in target_list] + + if not self.skip_nomask: + nomask_indices = torch.logical_and(~padding_mask, ~mask_indices) + proj_x_u = self.final_proj(x[nomask_indices]) + if self.untie_final_proj: + proj_x_u_list = proj_x_u.chunk(len(target_list), dim=-1) + else: + proj_x_u_list = [proj_x_u for _ in range(len(target_list))] + + logit_u_list = [ + compute_pred(proj_x_u, t[nomask_indices], label_embs_list[i]) + for i, (proj_x_u, t) in enumerate( + zip(proj_x_u_list, target_list) + ) + ] + else: + logit_u_list = [None for _ in target_list] + + result = { + "logit_m_list": logit_m_list, + "logit_u_list": logit_u_list, + "padding_mask": padding_mask, + "features_pen": features_pen, + } + return result + + def extract_features( + self, + source: torch.Tensor, + padding_mask: Optional[torch.Tensor] = None, + mask: bool = False, + ret_conv: bool = False, + output_layer: Optional[int] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + res = self.forward( + source, + padding_mask=padding_mask, + mask=mask, + features_only=True, + output_layer=output_layer, + ) + feature = res["features"] if ret_conv else res["x"] + return feature, res["padding_mask"] + + def get_logits(self, net_output, is_masked=True): + if is_masked: + logits_list = net_output["logit_m_list"] + else: + logits_list = net_output["logit_u_list"] + logits_list = [x.float() for x in logits_list if x is not None] + return logits_list + + def get_targets(self, net_output, is_masked=True): + logits_list = self.get_logits(net_output, is_masked) + targets_list = [ + x.new_zeros(x.size(0), dtype=torch.long) for x in logits_list + ] + return targets_list + + def get_extra_losses(self, net_output): + extra_losses = [] + names = [] + + if "features_pen" in net_output: + extra_losses.append(net_output["features_pen"]) + names.append("features_pen") + + return extra_losses, names + + def remove_pretraining_modules(self): + self.target_glu = None + self.final_proj = None diff --git a/fairseq/fairseq/models/hubert/hubert_asr.py b/fairseq/fairseq/models/hubert/hubert_asr.py new file mode 100644 index 0000000000000000000000000000000000000000..dce899c9de3ab68341c0b21bea749a3ee29e0d8a --- /dev/null +++ b/fairseq/fairseq/models/hubert/hubert_asr.py @@ -0,0 +1,376 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +from argparse import Namespace +from typing import Any + +import torch +import torch.nn as nn +from dataclasses import dataclass, field +from fairseq import checkpoint_utils, tasks, utils +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.models import BaseFairseqModel, FairseqEncoder, register_model +from fairseq.models.hubert.hubert import MASKING_DISTRIBUTION_CHOICES +from fairseq.tasks import FairseqTask +from omegaconf import II, MISSING + + +@dataclass +class HubertAsrConfig(FairseqDataclass): + w2v_path: str = field( + default=MISSING, metadata={"help": "path to hubert model"} + ) + no_pretrained_weights: bool = field( + default=False, + metadata={"help": "if true, does not load pretrained weights"}, + ) + dropout_input: float = field( + default=0.0, + metadata={"help": "dropout to apply to the input (after feat extr)"}, + ) + final_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout after transformer and before final projection" + }, + ) + dropout: float = field( + default=0.0, + metadata={"help": "dropout probability inside hubert model"}, + ) + attention_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability for attention weights " + "inside hubert model" + }, + ) + activation_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability after activation in FFN " + "inside hubert model" + }, + ) + + # masking + apply_mask: bool = field( + default=False, metadata={"help": "apply masking during fine-tuning"} + ) + mask_length: int = field( + default=10, metadata={"help": "repeat the mask indices multiple times"} + ) + mask_prob: float = field( + default=0.5, + metadata={ + "help": "probability of replacing a token with mask " + "(normalized by length)" + }, + ) + mask_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", metadata={"help": "how to choose masks"} + ) + mask_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument " + "(used for more complex distributions), " + "see help in compute_mask_indices" + }, + ) + no_mask_overlap: bool = field( + default=False, metadata={"help": "whether to allow masks to overlap"} + ) + + # channel masking + mask_channel_length: int = field( + default=10, + metadata={"help": "length of the mask for features (channels)"}, + ) + mask_channel_prob: float = field( + default=0.0, + metadata={"help": "probability of replacing a feature with 0"}, + ) + mask_channel_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", + metadata={"help": "how to choose mask length for channel masking"}, + ) + mask_channel_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument " + "(used for more complex distributions), " + "see help in compute_mask_indices" + }, + ) + no_mask_channel_overlap: bool = field( + default=False, + metadata={"help": "whether to allow channel masks to overlap"}, + ) + freeze_finetune_updates: int = field( + default=0, + metadata={"help": "dont finetune hubert for this many updates"}, + ) + feature_grad_mult: float = field( + default=0.0, + metadata={"help": "reset feature grad mult in hubert to this"}, + ) + layerdrop: float = field( + default=0.0, + metadata={"help": "probability of dropping a layer in hubert"}, + ) + normalize: bool = II("task.normalize") + data: str = II("task.data") + + # this holds the loaded hubert args + w2v_args: Any = None + + +@dataclass +class HubertCtcConfig(HubertAsrConfig): + pass + + +@register_model("hubert_ctc", dataclass=HubertCtcConfig) +class HubertCtc(BaseFairseqModel): + def __init__(self, cfg: HubertCtcConfig, w2v_encoder: BaseFairseqModel): + super().__init__() + self.cfg = cfg + self.w2v_encoder = w2v_encoder + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + return state_dict + + @classmethod + def build_model(cls, cfg: HubertCtcConfig, task: FairseqTask): + """Build a new model instance.""" + w2v_encoder = HubertEncoder(cfg, task.target_dictionary) + return cls(cfg, w2v_encoder) + + def get_normalized_probs(self, net_output, log_probs): + """Get normalized probabilities (or log probs) from a net's output.""" + + logits = net_output["encoder_out"] + if log_probs: + return utils.log_softmax(logits.float(), dim=-1) + else: + return utils.softmax(logits.float(), dim=-1) + + def get_logits(self, net_output): + logits = net_output["encoder_out"] + padding = net_output["encoder_padding_mask"] + if padding is not None and padding.any(): + padding = padding.T + logits[padding][..., 0] = 0 + logits[padding][..., 1:] = float("-inf") + + return logits + + def forward(self, **kwargs): + x = self.w2v_encoder(**kwargs) + return x + + +@dataclass +class HubertSeq2SeqConfig(HubertAsrConfig): + decoder_embed_dim: int = field( + default=768, metadata={"help": "decoder embedding dimension"} + ) + decoder_ffn_embed_dim: int = field( + default=3072, metadata={"help": "decoder embedding dimension for FFN"} + ) + decoder_layers: int = field( + default=6, metadata={"help": "num of decoder layers"} + ) + decoder_layerdrop: float = field( + default=0.0, metadata={"help": "decoder layerdrop chance"} + ) + decoder_attention_heads: int = field( + default=4, metadata={"help": "num decoder attention heads"} + ) + decoder_learned_pos: bool = field( + default=False, + metadata={"help": "use learned positional embeddings in the decoder"}, + ) + decoder_normalize_before: bool = field( + default=False, + metadata={"help": "apply layernorm before each decoder block"}, + ) + no_token_positional_embeddings: bool = field( + default=False, + metadata={ + "help": "if set, disables positional embeddings " + "(outside self attention)" + }, + ) + decoder_dropout: float = field( + default=0.0, metadata={"help": "dropout probability in the decoder"} + ) + decoder_attention_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability for attention weights " + "inside the decoder" + }, + ) + decoder_activation_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability after activation in FFN " + "inside the decoder" + }, + ) + max_target_positions: int = field( + default=2048, metadata={"help": "max target positions"} + ) + share_decoder_input_output_embed: bool = field( + default=False, + metadata={"help": "share decoder input and output embeddings"}, + ) + + +class HubertEncoder(FairseqEncoder): + def __init__(self, cfg: HubertAsrConfig, tgt_dict=None): + self.apply_mask = cfg.apply_mask + + arg_overrides = { + "dropout": cfg.dropout, + "activation_dropout": cfg.activation_dropout, + "dropout_input": cfg.dropout_input, + "attention_dropout": cfg.attention_dropout, + "mask_length": cfg.mask_length, + "mask_prob": cfg.mask_prob, + "mask_selection": cfg.mask_selection, + "mask_other": cfg.mask_other, + "no_mask_overlap": cfg.no_mask_overlap, + "mask_channel_length": cfg.mask_channel_length, + "mask_channel_prob": cfg.mask_channel_prob, + "mask_channel_selection": cfg.mask_channel_selection, + "mask_channel_other": cfg.mask_channel_other, + "no_mask_channel_overlap": cfg.no_mask_channel_overlap, + "encoder_layerdrop": cfg.layerdrop, + "feature_grad_mult": cfg.feature_grad_mult, + } + + if cfg.w2v_args is None: + state = checkpoint_utils.load_checkpoint_to_cpu( + cfg.w2v_path, arg_overrides + ) + w2v_args = state.get("cfg", None) + if w2v_args is None: + w2v_args = convert_namespace_to_omegaconf(state["args"]) + cfg.w2v_args = w2v_args + else: + state = None + w2v_args = cfg.w2v_args + if isinstance(w2v_args, Namespace): + cfg.w2v_args = w2v_args = convert_namespace_to_omegaconf( + w2v_args + ) + + assert cfg.normalize == w2v_args.task.normalize, ( + "Fine-tuning works best when data normalization is the same. " + "Please check that --normalize is set or unset for " + "both pre-training and here" + ) + + w2v_args.task.data = cfg.data + task = tasks.setup_task(w2v_args.task) + if state is not None and "task_state" in state: + # This will load the stored "dictionaries" object + task.load_state_dict(state["task_state"]) + model = task.build_model(w2v_args.model) + + if state is not None and not cfg.no_pretrained_weights: + # set strict=False because we omit some modules + model.load_state_dict(state["model"], strict=False) + + model.remove_pretraining_modules() + + super().__init__(task.source_dictionary) + + d = w2v_args.model.encoder_embed_dim + + self.w2v_model = model + + self.final_dropout = nn.Dropout(cfg.final_dropout) + self.freeze_finetune_updates = cfg.freeze_finetune_updates + self.num_updates = 0 + + if tgt_dict is not None: + self.proj = Linear(d, len(tgt_dict)) + elif getattr(cfg, "decoder_embed_dim", d) != d: + self.proj = Linear(d, cfg.decoder_embed_dim) + else: + self.proj = None + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + super().set_num_updates(num_updates) + self.num_updates = num_updates + + def forward(self, source, padding_mask, tbc=True, **kwargs): + + w2v_args = { + "source": source, + "padding_mask": padding_mask, + "mask": self.apply_mask and self.training, + } + + ft = self.freeze_finetune_updates <= self.num_updates + + with torch.no_grad() if not ft else contextlib.ExitStack(): + x, padding_mask = self.w2v_model.extract_features(**w2v_args) + + if tbc: + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + x = self.final_dropout(x) + + if self.proj: + x = self.proj(x) + + return { + "encoder_out": x, # T x B x C + "encoder_padding_mask": padding_mask, # B x T + "padding_mask": padding_mask, + } + + def reorder_encoder_out(self, encoder_out, new_order): + if encoder_out["encoder_out"] is not None: + encoder_out["encoder_out"] = encoder_out[ + "encoder_out" + ].index_select(1, new_order) + if encoder_out["encoder_padding_mask"] is not None: + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(0, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return None + + def upgrade_state_dict_named(self, state_dict, name): + return state_dict + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m diff --git a/fairseq/fairseq/models/huggingface/__init__.py b/fairseq/fairseq/models/huggingface/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f7911c2c8edf516855023a285b18935e5389ec02 --- /dev/null +++ b/fairseq/fairseq/models/huggingface/__init__.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +import os + + +# automatically import any Python files in the models/huggingface/ directory +models_dir = os.path.dirname(__file__) +for file in os.listdir(models_dir): + path = os.path.join(models_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + model_name = file[: file.find(".py")] if file.endswith(".py") else file + module = importlib.import_module("fairseq.models.huggingface." + model_name) diff --git a/fairseq/fairseq/models/huggingface/hf_gpt2.py b/fairseq/fairseq/models/huggingface/hf_gpt2.py new file mode 100644 index 0000000000000000000000000000000000000000..3a8eb78198f5808557092f814e92f1c9d72933ec --- /dev/null +++ b/fairseq/fairseq/models/huggingface/hf_gpt2.py @@ -0,0 +1,168 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys +from typing import Dict, List, Optional + +import torch +from fairseq.models import ( + FairseqIncrementalDecoder, + FairseqLanguageModel, + register_model, + register_model_architecture, +) + + +logger = logging.getLogger(__name__) + + +DEFAULT_MAX_TARGET_POSITIONS = 1024 + + +@register_model("hf_gpt2") +class HuggingFaceGPT2LanguageModel(FairseqLanguageModel): + def __init__(self, decoder): + super().__init__(decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--embed-dim', type=int, metavar='N', + help='embedding dimension') + parser.add_argument('--num-attention-heads', type=int, metavar='N', + help='num attention heads') + parser.add_argument('--num-layers', type=int, metavar='N', + help='num layers') + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability for all fully connected layers ' + 'in the embeddings, encoder, and pooler') + parser.add_argument('--attention-dropout', type=float, metavar='D', + help='dropout probability for attention weights') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + default_architecture(args) + return cls(HuggingFaceGPT2Decoder(args, task)) + + +class HuggingFaceGPT2Decoder(FairseqIncrementalDecoder): + def __init__(self, args, task): + try: + from transformers import GPT2Config, GPT2LMHeadModel + except ImportError: + raise ImportError( + "\n\nPlease install huggingface/transformers with:" + "\n\n pip install transformers" + ) + + super().__init__(task.target_dictionary) + + config = GPT2Config( + vocab_size=len(task.target_dictionary), + n_positions=args.max_target_positions + 1, + n_ctx=args.max_target_positions, + n_embd=args.embed_dim, + n_layer=args.num_layers, + n_head=args.num_attention_heads, + resid_pdrop=args.dropout, + embd_pdrop=args.dropout, + attn_pdrop=args.attention_dropout, + layer_norm_epsilon=1e-6, + ) + self.model = GPT2LMHeadModel(config) + + # set zero embedding for padding symbol + self.pad_idx = task.target_dictionary.pad() + self.model.transformer.wte.weight.data[self.pad_idx].zero_() + self.model.transformer.wpe.weight.data[0].zero_() + + def forward( + self, + prev_output_tokens, + src_lengths=None, + incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None, + encoder_out=None, + ): + features = self.extract_features(prev_output_tokens, incremental_state) + lm_logits = self.model.lm_head(features) + return (lm_logits,) + + def extract_features( + self, + prev_output_tokens, + incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None, + ): + if incremental_state: + past = self.get_incremental_state("past") + else: + past = None + + # don't attend to padding symbols + attention_mask = prev_output_tokens.ne(self.pad_idx).int() + + # set position ids to exclude padding symbols + position_ids = attention_mask * ( + torch.arange(1, 1 + prev_output_tokens.size(1)) + .to(prev_output_tokens) + .repeat(prev_output_tokens.size(0), 1) + ) + + outputs = self.model.transformer( + input_ids=prev_output_tokens, + past=past, + attention_mask=attention_mask, + position_ids=position_ids, + ) + last_hidden_states = outputs[0] + + if incremental_state: + self.set_incremental_state(incremental_state, "past", outputs[1]) + + return last_hidden_states + + def max_positions(self): + return self.model.config.n_positions - 1 + + +@register_model_architecture("hf_gpt2", "hf_gpt2") +def default_architecture(args): + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = getattr( + args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS + ) + args.embed_dim = getattr(args, "embed_dim", 768) + args.num_attention_heads = getattr(args, "num_attention_heads", 12) + args.num_layers = getattr(args, "num_layers", 12) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + + +@register_model_architecture("hf_gpt2", "hf_gpt2_medium") +def hf_gpt2_medium(args): + args.embed_dim = getattr(args, "embed_dim", 1024) + args.num_attention_heads = getattr(args, "num_attention_heads", 16) + args.num_layers = getattr(args, "num_layers", 24) + default_architecture(args) + + +@register_model_architecture("hf_gpt2", "hf_gpt2_large") +def hf_gpt2_large(args): + args.embed_dim = getattr(args, "embed_dim", 1280) + args.num_attention_heads = getattr(args, "num_attention_heads", 20) + args.num_layers = getattr(args, "num_layers", 36) + default_architecture(args) + + +@register_model_architecture("hf_gpt2", "hf_gpt2_xl") +def hf_gpt2_xl(args): + args.embed_dim = getattr(args, "embed_dim", 1600) + args.num_attention_heads = getattr(args, "num_attention_heads", 25) + args.num_layers = getattr(args, "num_layers", 48) + default_architecture(args) diff --git a/fairseq/fairseq/models/lightconv.py b/fairseq/fairseq/models/lightconv.py new file mode 100644 index 0000000000000000000000000000000000000000..4edfe359379bc2445c1ae1ada04bd34ca4a32798 --- /dev/null +++ b/fairseq/fairseq/models/lightconv.py @@ -0,0 +1,1019 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + AdaptiveSoftmax, + DynamicConv, + FairseqDropout, + LayerNorm, + LightweightConv, + MultiheadAttention, + PositionalEmbedding, +) +from fairseq.utils import safe_hasattr + + +@register_model("lightconv") +class LightConvModel(FairseqEncoderDecoderModel): + """ + LightConv and DynamicConv model from `"Pay Less Attention with Lightweight and Dynamic Convolutions" (Wu, et al, 2019) + <https://openreview.net/pdf?id=SkVhlh09tX>`_. + To use LightConv please set ``--encoder-conv-type lightweight --decoder-conv-type lightweight`` + To use DynamicConv please set ``--encoder-conv-type dynamic --decoder-conv-type dynamic`` + + Args: + encoder (LightConvEncoder): the encoder + decoder (LightConvDecoder): the decoder + + The LightConv model provides the following named architectures and + command-line arguments: + + .. argparse:: + :ref: fairseq.models.lightconv_parser + :prog: + """ + + @classmethod + def hub_models(cls): + # fmt: off + + def moses_subword(path): + return { + 'path': path, + 'tokenizer': 'moses', + 'bpe': 'subword_nmt', + } + + return { + 'lightconv.no_glu.iwslt14.de-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.lightconv.tar.gz'), + 'dynamicconv.no_glu.iwslt14.de-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/iwslt14.de-en.dynamicconv.tar.gz'), + 'lightconv.no_glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv.tar.gz'), + 'dynamicconv.no_glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv.tar.gz'), + 'lightconv.glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv-glu.tar.gz'), + 'dynamicconv.glu.wmt16.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv-glu.tar.gz'), + 'lightconv.glu.wmt17.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.lightconv-glu.tar.gz'), + 'dynamicconv.glu.wmt17.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt16.en-de.joined-dict.dynamicconv-glu.tar.gz'), + 'lightconv.glu.wmt14.en-fr': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.lightconv-glu.tar.gz'), + 'dynamicconv.glu.wmt14.en-fr': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt14.en-fr.joined-dict.dynamicconv-glu.tar.gz'), + 'lightconv.glu.wmt17.zh-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.lightconv-glu.tar.gz'), + 'dynamicconv.glu.wmt17.zh-en': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/dynamicconv/wmt17.zh-en.dynamicconv-glu.tar.gz'), + } + # fmt: on + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--relu-dropout", + type=float, + metavar="D", + help="dropout probability after ReLU in FFN", + ) + parser.add_argument( + "--input-dropout", + type=float, + metavar="D", + help="dropout probability of the inputs", + ) + parser.add_argument( + "--encoder-embed-path", + type=str, + metavar="STR", + help="path to pre-trained encoder embedding", + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-conv-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="num encoder layers" + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads or LightConv/DynamicConv heads", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + parser.add_argument( + "--encoder-learned-pos", + action="store_true", + help="use learned positional embeddings in the encoder", + ) + parser.add_argument( + "--decoder-embed-path", + type=str, + metavar="STR", + help="path to pre-trained decoder embedding", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-conv-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads or LightConv/DynamicConv heads", + ) + parser.add_argument( + "--decoder-learned-pos", + action="store_true", + help="use learned positional embeddings in the decoder", + ) + parser.add_argument( + "--decoder-normalize-before", + action="store_true", + help="apply layernorm before each decoder block", + ) + parser.add_argument( + "--share-decoder-input-output-embed", + action="store_true", + help="share decoder input and output embeddings", + ) + parser.add_argument( + "--share-all-embeddings", + action="store_true", + help="share encoder, decoder and output embeddings" + " (requires shared dictionary and embed dim)", + ) + parser.add_argument( + "--adaptive-softmax-cutoff", + metavar="EXPR", + help="comma separated list of adaptive softmax cutoff points. " + "Must be used with adaptive_loss criterion", + ), + parser.add_argument( + "--adaptive-softmax-dropout", + type=float, + metavar="D", + help="sets adaptive softmax dropout for the tail projections", + ) + + """LightConv and DynamicConv arguments""" + parser.add_argument( + "--encoder-kernel-size-list", + type=lambda x: utils.eval_str_list(x, int), + help='list of kernel size (default: "[3,7,15,31,31,31,31]")', + ) + parser.add_argument( + "--decoder-kernel-size-list", + type=lambda x: utils.eval_str_list(x, int), + help='list of kernel size (default: "[3,7,15,31,31,31]")', + ) + parser.add_argument( + "--encoder-glu", type=utils.eval_bool, help="glu after in proj" + ) + parser.add_argument( + "--decoder-glu", type=utils.eval_bool, help="glu after in proj" + ) + parser.add_argument( + "--encoder-conv-type", + default="dynamic", + type=str, + choices=["dynamic", "lightweight"], + help="type of convolution", + ) + parser.add_argument( + "--decoder-conv-type", + default="dynamic", + type=str, + choices=["dynamic", "lightweight"], + help="type of convolution", + ) + parser.add_argument("--weight-softmax", default=True, type=utils.eval_bool) + parser.add_argument( + "--weight-dropout", + type=float, + metavar="D", + help="dropout probability for conv weights", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if not safe_hasattr(args, "max_source_positions"): + args.max_source_positions = 1024 + if not safe_hasattr(args, "max_target_positions"): + args.max_target_positions = 1024 + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + def build_embedding(dictionary, embed_dim, path=None): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + emb = Embedding(num_embeddings, embed_dim, padding_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + if args.share_all_embeddings: + if src_dict != tgt_dict: + raise RuntimeError( + "--share-all-embeddings requires a joined dictionary" + ) + if args.encoder_embed_dim != args.decoder_embed_dim: + raise RuntimeError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise RuntimeError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = build_embedding( + src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + encoder_embed_tokens = build_embedding( + src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = build_embedding( + tgt_dict, args.decoder_embed_dim, args.decoder_embed_path + ) + + encoder = LightConvEncoder(args, src_dict, encoder_embed_tokens) + decoder = LightConvDecoder(args, tgt_dict, decoder_embed_tokens) + return LightConvModel(encoder, decoder) + + +class LightConvEncoder(FairseqEncoder): + """ + LightConv encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`LightConvEncoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_tokens (torch.nn.Embedding): input embedding + """ + + def __init__(self, args, dictionary, embed_tokens): + super().__init__(dictionary) + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + + embed_dim = embed_tokens.embedding_dim + self.padding_idx = embed_tokens.padding_idx + self.max_source_positions = args.max_source_positions + + self.embed_tokens = embed_tokens + self.embed_scale = math.sqrt(embed_dim) + self.embed_positions = ( + PositionalEmbedding( + args.max_source_positions, + embed_dim, + self.padding_idx, + learned=args.encoder_learned_pos, + ) + if not args.no_token_positional_embeddings + else None + ) + + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + LightConvEncoderLayer( + args, kernel_size=args.encoder_kernel_size_list[i] + ) + for i in range(args.encoder_layers) + ] + ) + self.register_buffer("version", torch.Tensor([2])) + self.normalize = args.encoder_normalize_before + if self.normalize: + self.layer_norm = LayerNorm(embed_dim) + + def forward(self, src_tokens, **unused): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + """ + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(src_tokens) + if self.embed_positions is not None: + x += self.embed_positions(src_tokens) + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # compute padding mask + encoder_padding_mask = src_tokens.eq(self.padding_idx) + if not encoder_padding_mask.any(): + encoder_padding_mask = None + + # encoder layers + for layer in self.layers: + x = layer(x, encoder_padding_mask) + + if self.normalize: + x = self.layer_norm(x) + + return { + "encoder_out": x, # T x B x C + "encoder_padding_mask": encoder_padding_mask, # B x T + } + + def reorder_encoder_out(self, encoder_out, new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + if encoder_out["encoder_out"] is not None: + encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select( + 1, new_order + ) + if encoder_out["encoder_padding_mask"] is not None: + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(0, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + if self.embed_positions is None: + return self.max_source_positions + return min(self.max_source_positions, self.embed_positions.max_positions) + + +class LightConvDecoder(FairseqIncrementalDecoder): + """ + LightConv decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`LightConvDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs. + Default: ``False`` + """ + + def __init__( + self, args, dictionary, embed_tokens, no_encoder_attn=False, final_norm=True + ): + super().__init__(dictionary) + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.share_input_output_embed = args.share_decoder_input_output_embed + + input_embed_dim = embed_tokens.embedding_dim + embed_dim = args.decoder_embed_dim + output_embed_dim = args.decoder_output_dim + + padding_idx = embed_tokens.padding_idx + self.max_target_positions = args.max_target_positions + + self.embed_tokens = embed_tokens + self.embed_scale = math.sqrt(embed_dim) # todo: try with input_embed_dim + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + + self.embed_positions = ( + PositionalEmbedding( + args.max_target_positions, + embed_dim, + padding_idx, + learned=args.decoder_learned_pos, + ) + if not args.no_token_positional_embeddings + else None + ) + + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + LightConvDecoderLayer( + args, no_encoder_attn, kernel_size=args.decoder_kernel_size_list[i] + ) + for i in range(args.decoder_layers) + ] + ) + + self.adaptive_softmax = None + + self.project_out_dim = ( + Linear(embed_dim, output_embed_dim, bias=False) + if embed_dim != output_embed_dim and not args.tie_adaptive_weights + else None + ) + + if args.adaptive_softmax_cutoff is not None: + self.adaptive_softmax = AdaptiveSoftmax( + len(dictionary), + output_embed_dim, + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int), + dropout=args.adaptive_softmax_dropout, + adaptive_inputs=embed_tokens if args.tie_adaptive_weights else None, + factor=args.adaptive_softmax_factor, + tie_proj=args.tie_adaptive_proj, + ) + elif not self.share_input_output_embed: + self.embed_out = nn.Parameter( + torch.Tensor(len(dictionary), output_embed_dim) + ) + nn.init.normal_(self.embed_out, mean=0, std=output_embed_dim ** -0.5) + self.register_buffer("version", torch.Tensor([2])) + self.normalize = args.decoder_normalize_before and final_norm + if self.normalize: + self.layer_norm = LayerNorm(embed_dim) + + def forward( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **kwargs + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (Tensor, optional): output from the encoder, used for + encoder-side attention + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + + Returns: + tuple: + - the last decoder layer's output of shape `(batch, tgt_len, + vocab)` + - the last decoder layer's attention weights of shape `(batch, + tgt_len, src_len)` + """ + # embed positions + positions = ( + self.embed_positions( + prev_output_tokens, + incremental_state=incremental_state, + ) + if self.embed_positions is not None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + attn = None + + inner_states = [x] + + # decoder layers + for layer in self.layers: + x, attn = layer( + x, + encoder_out["encoder_out"] if encoder_out is not None else None, + encoder_out["encoder_padding_mask"] + if encoder_out is not None + else None, + incremental_state, + ) + inner_states.append(x) + + if self.normalize: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + if self.adaptive_softmax is None: + # project back to size of vocabulary + if self.share_input_output_embed: + x = F.linear(x, self.embed_tokens.weight) + else: + x = F.linear(x, self.embed_out) + + return x, {"attn": attn, "inner_states": inner_states} + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embed_positions is None: + return self.max_target_positions + return min(self.max_target_positions, self.embed_positions.max_positions) + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + not hasattr(self, "_future_mask") + or self._future_mask is None + or self._future_mask.device != tensor.device + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(tensor.new(dim, dim)), 1 + ) + if self._future_mask.size(0) < dim: + self._future_mask = torch.triu( + utils.fill_with_neg_inf(self._future_mask.resize_(dim, dim)), 1 + ) + return self._future_mask[:dim, :dim] + + +class LightConvEncoderLayer(nn.Module): + """Encoder layer block. + + Args: + args (argparse.Namespace): parsed command-line arguments + kernel_size: kernel size of the convolution + """ + + def __init__(self, args, kernel_size=0): + super().__init__() + self.embed_dim = args.encoder_embed_dim + self.conv_dim = args.encoder_conv_dim + padding_l = ( + kernel_size // 2 + if kernel_size % 2 == 1 + else ((kernel_size - 1) // 2, kernel_size // 2) + ) + + if args.encoder_glu: + self.linear1 = Linear(self.embed_dim, 2 * self.conv_dim) + self.act = nn.GLU() + else: + self.linear1 = Linear(self.embed_dim, self.conv_dim) + self.act = None + if args.encoder_conv_type == "lightweight": + self.conv = LightweightConv( + self.conv_dim, + kernel_size, + padding_l=padding_l, + weight_softmax=args.weight_softmax, + num_heads=args.encoder_attention_heads, + weight_dropout=args.weight_dropout, + ) + elif args.encoder_conv_type == "dynamic": + self.conv = DynamicConv( + self.conv_dim, + kernel_size, + padding_l=padding_l, + weight_softmax=args.weight_softmax, + num_heads=args.encoder_attention_heads, + weight_dropout=args.weight_dropout, + ) + else: + raise NotImplementedError + self.linear2 = Linear(self.conv_dim, self.embed_dim) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.relu_dropout_module = FairseqDropout( + args.relu_dropout, module_name=self.__class__.__name__ + ) + self.input_dropout_module = FairseqDropout( + args.input_dropout, module_name=self.__class__.__name__ + ) + self.normalize_before = args.encoder_normalize_before + self.fc1 = Linear(self.embed_dim, args.encoder_ffn_embed_dim) + self.fc2 = Linear(args.encoder_ffn_embed_dim, self.embed_dim) + self.layer_norms = nn.ModuleList([LayerNorm(self.embed_dim) for _ in range(2)]) + + def forward(self, x, encoder_padding_mask): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor): binary ByteTensor of shape + `(batch, src_len)` where padding elements are indicated by ``1``. + + Returns: + encoded output of shape `(batch, src_len, embed_dim)` + """ + residual = x + x = self.maybe_layer_norm(0, x, before=True) + x = self.input_dropout_module(x) + x = self.linear1(x) + if self.act is not None: + x = self.act(x) + if encoder_padding_mask is not None: + x = x.masked_fill(encoder_padding_mask.transpose(0, 1).unsqueeze(2), 0) + x = self.conv(x) + x = self.linear2(x) + x = self.dropout_module(x) + x = residual + x + x = self.maybe_layer_norm(0, x, after=True) + + residual = x + x = self.maybe_layer_norm(1, x, before=True) + x = F.relu(self.fc1(x)) + x = self.relu_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = residual + x + x = self.maybe_layer_norm(1, x, after=True) + return x + + def maybe_layer_norm(self, i, x, before=False, after=False): + assert before ^ after + if after ^ self.normalize_before: + return self.layer_norms[i](x) + else: + return x + + def extra_repr(self): + return ( + "dropout={}, relu_dropout={}, input_dropout={}, normalize_before={}".format( + self.dropout_module.p, + self.relu_dropout_module.p, + self.input_dropout_module.p, + self.normalize_before, + ) + ) + + +class LightConvDecoderLayer(nn.Module): + """Decoder layer block. + + Args: + args (argparse.Namespace): parsed command-line arguments + no_encoder_attn (bool, optional): whether to attend to encoder outputs. + Default: ``False`` + kernel_size: kernel size of the convolution + """ + + def __init__(self, args, no_encoder_attn=False, kernel_size=0): + super().__init__() + self.embed_dim = args.decoder_embed_dim + self.conv_dim = args.decoder_conv_dim + if args.decoder_glu: + self.linear1 = Linear(self.embed_dim, 2 * self.conv_dim) + self.act = nn.GLU() + else: + self.linear1 = Linear(self.embed_dim, self.conv_dim) + self.act = None + if args.decoder_conv_type == "lightweight": + self.conv = LightweightConv( + self.conv_dim, + kernel_size, + padding_l=kernel_size - 1, + weight_softmax=args.weight_softmax, + num_heads=args.decoder_attention_heads, + weight_dropout=args.weight_dropout, + ) + elif args.decoder_conv_type == "dynamic": + self.conv = DynamicConv( + self.conv_dim, + kernel_size, + padding_l=kernel_size - 1, + weight_softmax=args.weight_softmax, + num_heads=args.decoder_attention_heads, + weight_dropout=args.weight_dropout, + ) + else: + raise NotImplementedError + self.linear2 = Linear(self.conv_dim, self.embed_dim) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.relu_dropout_module = FairseqDropout( + args.relu_dropout, module_name=self.__class__.__name__ + ) + self.input_dropout_module = FairseqDropout( + args.input_dropout, module_name=self.__class__.__name__ + ) + self.normalize_before = args.decoder_normalize_before + + self.conv_layer_norm = LayerNorm(self.embed_dim) + + if no_encoder_attn: + self.encoder_attn = None + self.encoder_attn_layer_norm = None + else: + self.encoder_attn = MultiheadAttention( + self.embed_dim, + args.decoder_attention_heads, + dropout=args.attention_dropout, + encoder_decoder_attention=True, + ) + self.encoder_attn_layer_norm = LayerNorm(self.embed_dim) + + self.fc1 = Linear(self.embed_dim, args.decoder_ffn_embed_dim) + self.fc2 = Linear(args.decoder_ffn_embed_dim, self.embed_dim) + + self.final_layer_norm = LayerNorm(self.embed_dim) + self.need_attn = True + + def forward( + self, + x, + encoder_out, + encoder_padding_mask, + incremental_state, + prev_conv_state=None, + prev_attn_state=None, + conv_mask=None, + conv_padding_mask=None, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor): binary ByteTensor of shape + `(batch, src_len)` where padding elements are indicated by ``1``. + + Returns: + encoded output of shape `(batch, src_len, embed_dim)` + """ + residual = x + x = self.maybe_layer_norm(self.conv_layer_norm, x, before=True) + if prev_conv_state is not None: + if incremental_state is None: + incremental_state = {} + self.conv._set_input_buffer(incremental_state, prev_conv_state) + x = self.input_dropout_module(x) + x = self.linear1(x) + if self.act is not None: + x = self.act(x) + x = self.conv(x, incremental_state=incremental_state) + x = self.linear2(x) + x = self.dropout_module(x) + x = residual + x + x = self.maybe_layer_norm(self.conv_layer_norm, x, after=True) + + attn = None + if self.encoder_attn is not None: + residual = x + x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, before=True) + if prev_attn_state is not None: + if incremental_state is None: + incremental_state = {} + prev_key, prev_value = prev_attn_state + saved_state = {"prev_key": prev_key, "prev_value": prev_value} + self.encoder_attn._set_input_buffer(incremental_state, saved_state) + x, attn = self.encoder_attn( + query=x, + key=encoder_out, + value=encoder_out, + key_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + static_kv=True, + need_weights=(not self.training and self.need_attn), + ) + x = self.dropout_module(x) + x = residual + x + x = self.maybe_layer_norm(self.encoder_attn_layer_norm, x, after=True) + + residual = x + x = self.maybe_layer_norm(self.final_layer_norm, x, before=True) + x = F.relu(self.fc1(x)) + x = self.relu_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = residual + x + x = self.maybe_layer_norm(self.final_layer_norm, x, after=True) + return x, attn + + def maybe_layer_norm(self, layer_norm, x, before=False, after=False): + assert before ^ after + if after ^ self.normalize_before: + return layer_norm(x) + else: + return x + + def make_generation_fast_(self, need_attn=False, **kwargs): + self.need_attn = need_attn + + def extra_repr(self): + return ( + "dropout={}, relu_dropout={}, input_dropout={}, normalize_before={}".format( + self.dropout_module.p, + self.relu_dropout_module.p, + self.input_dropout_module.p, + self.normalize_before, + ) + ) + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m + + +@register_model_architecture("lightconv", "lightconv") +def base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 7) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.relu_dropout = getattr(args, "relu_dropout", 0.0) + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.encoder_conv_dim = getattr(args, "encoder_conv_dim", args.encoder_embed_dim) + args.decoder_conv_dim = getattr(args, "decoder_conv_dim", args.decoder_embed_dim) + + args.encoder_kernel_size_list = getattr( + args, "encoder_kernel_size_list", [3, 7, 15, 31, 31, 31, 31] + ) + args.decoder_kernel_size_list = getattr( + args, "decoder_kernel_size_list", [3, 7, 15, 31, 31, 31] + ) + if len(args.encoder_kernel_size_list) == 1: + args.encoder_kernel_size_list = ( + args.encoder_kernel_size_list * args.encoder_layers + ) + if len(args.decoder_kernel_size_list) == 1: + args.decoder_kernel_size_list = ( + args.decoder_kernel_size_list * args.decoder_layers + ) + assert ( + len(args.encoder_kernel_size_list) == args.encoder_layers + ), "encoder_kernel_size_list doesn't match encoder_layers" + assert ( + len(args.decoder_kernel_size_list) == args.decoder_layers + ), "decoder_kernel_size_list doesn't match decoder_layers" + args.encoder_glu = getattr(args, "encoder_glu", True) + args.decoder_glu = getattr(args, "decoder_glu", True) + args.input_dropout = getattr(args, "input_dropout", 0.1) + args.weight_dropout = getattr(args, "weight_dropout", args.attention_dropout) + + +@register_model_architecture("lightconv", "lightconv_iwslt_de_en") +def lightconv_iwslt_de_en(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.encoder_layers = getattr(args, "encoder_layers", 7) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.weight_dropout = getattr(args, "weight_dropout", 0.1) + args.encoder_glu = getattr(args, "encoder_glu", False) + args.decoder_glu = getattr(args, "decoder_glu", False) + args.input_dropout = getattr(args, "input_dropout", 0.0) + base_architecture(args) + + +@register_model_architecture("lightconv", "lightconv_wmt_en_de") +def lightconv_wmt_en_de(args): + base_architecture(args) + + +@register_model_architecture("lightconv", "lightconv_wmt_en_de_big") +def lightconv_wmt_en_de_big(args): + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.3) + base_architecture(args) + + +@register_model_architecture("lightconv", "lightconv_wmt_en_fr_big") +def lightconv_wmt_en_fr_big(args): + args.dropout = getattr(args, "dropout", 0.1) + lightconv_wmt_en_de_big(args) + + +@register_model_architecture("lightconv", "lightconv_wmt_zh_en_big") +def lightconv_wmt_zh_en_big(args): + args.dropout = getattr(args, "dropout", 0.2) + args.attention_dropout = getattr(args, "attention_dropout", 0.2) + args.weight_dropout = getattr(args, "weight_dropout", 0.2) + lightconv_wmt_en_de_big(args) diff --git a/fairseq/fairseq/models/lightconv_lm.py b/fairseq/fairseq/models/lightconv_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..1d9efc4e42a5ecc1b83338055f18ade5a83ea666 --- /dev/null +++ b/fairseq/fairseq/models/lightconv_lm.py @@ -0,0 +1,306 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq import utils +from fairseq.models import ( + FairseqLanguageModel, + register_model, + register_model_architecture, +) +from fairseq.models.lightconv import Embedding, LightConvDecoder +from fairseq.modules import AdaptiveInput, CharacterTokenEmbedder + + +@register_model("lightconv_lm") +class LightConvLanguageModel(FairseqLanguageModel): + def __init__(self, decoder): + super().__init__(decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--dropout", + default=0.1, + type=float, + metavar="D", + help="dropout probability", + ) + parser.add_argument( + "--attention-dropout", + default=0.0, + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--relu-dropout", + default=0.0, + type=float, + metavar="D", + help="dropout probability after ReLU in FFN", + ) + parser.add_argument( + "--input-dropout", + type=float, + metavar="D", + help="dropout probability of the inputs", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-output-dim", + type=int, + metavar="N", + help="decoder output dimension", + ) + parser.add_argument( + "--decoder-input-dim", type=int, metavar="N", help="decoder input dimension" + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads or LightConv/DynamicConv heads", + ) + parser.add_argument( + "--decoder-normalize-before", + default=False, + action="store_true", + help="apply layernorm before each decoder block", + ) + parser.add_argument( + "--adaptive-softmax-cutoff", + metavar="EXPR", + help="comma separated list of adaptive softmax cutoff points. " + "Must be used with adaptive_loss criterion", + ) + parser.add_argument( + "--adaptive-softmax-dropout", + type=float, + metavar="D", + help="sets adaptive softmax dropout for the tail projections", + ) + parser.add_argument( + "--adaptive-softmax-factor", + type=float, + metavar="N", + help="adaptive input factor", + ) + parser.add_argument( + "--no-token-positional-embeddings", + default=False, + action="store_true", + help="if set, disables positional embeddings (outside self attention)", + ) + parser.add_argument( + "--share-decoder-input-output-embed", + default=False, + action="store_true", + help="share decoder input and output embeddings", + ) + parser.add_argument( + "--character-embeddings", + default=False, + action="store_true", + help="if set, uses character embedding convolutions to produce token embeddings", + ) + parser.add_argument( + "--character-filters", + type=str, + metavar="LIST", + default="[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]", + help="size of character embeddings", + ) + parser.add_argument( + "--character-embedding-dim", + type=int, + metavar="N", + default=4, + help="size of character embeddings", + ) + parser.add_argument( + "--char-embedder-highway-layers", + type=int, + metavar="N", + default=2, + help="number of highway layers for character token embeddder", + ) + parser.add_argument( + "--adaptive-input", + default=False, + action="store_true", + help="if set, uses adaptive input", + ) + parser.add_argument( + "--adaptive-input-factor", + type=float, + metavar="N", + help="adaptive input factor", + ) + parser.add_argument( + "--adaptive-input-cutoff", + metavar="EXPR", + help="comma separated list of adaptive input cutoff points.", + ) + parser.add_argument( + "--tie-adaptive-weights", + action="store_true", + help="if set, ties the weights of adaptive softmax and adaptive input", + ) + parser.add_argument( + "--tie-adaptive-proj", + action="store_true", + help="if set, ties the projection weights of adaptive softmax and adaptive input", + ) + parser.add_argument( + "--decoder-learned-pos", + action="store_true", + help="use learned positional embeddings in the decoder", + ) + + """LightConv and DynamicConv arguments""" + parser.add_argument( + "--decoder-kernel-size-list", + type=lambda x: utils.eval_str_list(x, int), + help='list of kernel size (default: "[3,7,15,31,31,31]")', + ) + parser.add_argument( + "--decoder-glu", type=utils.eval_bool, help="glu after in proj" + ) + parser.add_argument( + "--decoder-conv-type", + default="dynamic", + type=str, + choices=["dynamic", "lightweight"], + help="type of convolution", + ) + parser.add_argument("--weight-softmax", default=True, type=utils.eval_bool) + parser.add_argument( + "--weight-dropout", + type=float, + metavar="D", + help="dropout probability for conv weights", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_lm_architecture(args) + + if getattr(args, "max_source_positions", None) is None: + args.max_source_positions = args.tokens_per_sample + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = args.tokens_per_sample + + if args.character_embeddings: + embed_tokens = CharacterTokenEmbedder( + task.dictionary, + eval(args.character_filters), + args.character_embedding_dim, + args.decoder_embed_dim, + args.char_embedder_highway_layers, + ) + elif args.adaptive_input: + embed_tokens = AdaptiveInput( + len(task.dictionary), + task.dictionary.pad(), + args.decoder_input_dim, + args.adaptive_input_factor, + args.decoder_embed_dim, + utils.eval_str_list(args.adaptive_input_cutoff, type=int), + ) + else: + embed_tokens = Embedding( + len(task.dictionary), args.decoder_input_dim, task.dictionary.pad() + ) + + if args.tie_adaptive_weights: + assert args.adaptive_input + assert args.adaptive_input_factor == args.adaptive_softmax_factor + assert ( + args.adaptive_softmax_cutoff == args.adaptive_input_cutoff + ), "{} != {}".format( + args.adaptive_softmax_cutoff, args.adaptive_input_cutoff + ) + assert args.decoder_input_dim == args.decoder_output_dim + + decoder = LightConvDecoder( + args, + task.output_dictionary, + embed_tokens, + no_encoder_attn=True, + final_norm=False, + ) + return LightConvLanguageModel(decoder) + + +@register_model_architecture("lightconv_lm", "lightconv_lm") +def base_lm_architecture(args): + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 2048) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.adaptive_softmax_factor = getattr(args, "adaptive_softmax_factor", 4) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + + args.character_embeddings = getattr(args, "character_embeddings", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + args.decoder_conv_dim = getattr(args, "decoder_conv_dim", args.decoder_embed_dim) + + # The model training is not stable without this + args.decoder_normalize_before = True + + args.adaptive_input = getattr(args, "adaptive_input", False) + args.adaptive_input_factor = getattr(args, "adaptive_input_factor", 4) + args.adaptive_input_cutoff = getattr(args, "adaptive_input_cutoff", None) + + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.tie_adaptive_proj = getattr(args, "tie_adaptive_proj", False) + + args.decoder_kernel_size_list = getattr( + args, "decoder_kernel_size_list", [3, 7, 15, 31, 31, 31] + ) + if len(args.decoder_kernel_size_list) == 1: + args.decoder_kernel_size_list = ( + args.decoder_kernel_size_list * args.decoder_layers + ) + assert ( + len(args.decoder_kernel_size_list) == args.decoder_layers + ), "decoder_kernel_size_list doesn't match decoder_layers" + args.decoder_glu = getattr(args, "decoder_glu", True) + args.input_dropout = getattr(args, "input_dropout", 0.1) + args.weight_dropout = getattr(args, "weight_dropout", args.attention_dropout) + + +@register_model_architecture("lightconv_lm", "lightconv_lm_gbw") +def lightconv_lm_gbw(args): + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + base_lm_architecture(args) diff --git a/fairseq/fairseq/models/lstm.py b/fairseq/fairseq/models/lstm.py new file mode 100644 index 0000000000000000000000000000000000000000..e1e66a7d50fa1b1b313e9d1a6e7862ac9bfaa074 --- /dev/null +++ b/fairseq/fairseq/models/lstm.py @@ -0,0 +1,753 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import AdaptiveSoftmax, FairseqDropout +from torch import Tensor + + +DEFAULT_MAX_SOURCE_POSITIONS = 1e5 +DEFAULT_MAX_TARGET_POSITIONS = 1e5 + + +@register_model("lstm") +class LSTMModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-embed-path', type=str, metavar='STR', + help='path to pre-trained encoder embedding') + parser.add_argument('--encoder-freeze-embed', action='store_true', + help='freeze encoder embeddings') + parser.add_argument('--encoder-hidden-size', type=int, metavar='N', + help='encoder hidden size') + parser.add_argument('--encoder-layers', type=int, metavar='N', + help='number of encoder layers') + parser.add_argument('--encoder-bidirectional', action='store_true', + help='make all layers of encoder bidirectional') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-freeze-embed', action='store_true', + help='freeze decoder embeddings') + parser.add_argument('--decoder-hidden-size', type=int, metavar='N', + help='decoder hidden size') + parser.add_argument('--decoder-layers', type=int, metavar='N', + help='number of decoder layers') + parser.add_argument('--decoder-out-embed-dim', type=int, metavar='N', + help='decoder output embedding dimension') + parser.add_argument('--decoder-attention', type=str, metavar='BOOL', + help='decoder attention') + parser.add_argument('--adaptive-softmax-cutoff', metavar='EXPR', + help='comma separated list of adaptive softmax cutoff points. ' + 'Must be used with adaptive_loss criterion') + parser.add_argument('--share-decoder-input-output-embed', default=False, + action='store_true', + help='share decoder input and output embeddings') + parser.add_argument('--share-all-embeddings', default=False, action='store_true', + help='share encoder, decoder and output embeddings' + ' (requires shared dictionary and embed dim)') + + # Granular dropout settings (if not specified these default to --dropout) + parser.add_argument('--encoder-dropout-in', type=float, metavar='D', + help='dropout probability for encoder input embedding') + parser.add_argument('--encoder-dropout-out', type=float, metavar='D', + help='dropout probability for encoder output') + parser.add_argument('--decoder-dropout-in', type=float, metavar='D', + help='dropout probability for decoder input embedding') + parser.add_argument('--decoder-dropout-out', type=float, metavar='D', + help='dropout probability for decoder output') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure that all args are properly defaulted (in case there are any new ones) + base_architecture(args) + + if args.encoder_layers != args.decoder_layers: + raise ValueError("--encoder-layers must match --decoder-layers") + + max_source_positions = getattr( + args, "max_source_positions", DEFAULT_MAX_SOURCE_POSITIONS + ) + max_target_positions = getattr( + args, "max_target_positions", DEFAULT_MAX_TARGET_POSITIONS + ) + + def load_pretrained_embedding_from_file(embed_path, dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + embed_dict = utils.parse_embedding(embed_path) + utils.print_embed_overlap(embed_dict, dictionary) + return utils.load_embedding(embed_dict, dictionary, embed_tokens) + + if args.encoder_embed_path: + pretrained_encoder_embed = load_pretrained_embedding_from_file( + args.encoder_embed_path, task.source_dictionary, args.encoder_embed_dim + ) + else: + num_embeddings = len(task.source_dictionary) + pretrained_encoder_embed = Embedding( + num_embeddings, args.encoder_embed_dim, task.source_dictionary.pad() + ) + + if args.share_all_embeddings: + # double check all parameters combinations are valid + if task.source_dictionary != task.target_dictionary: + raise ValueError("--share-all-embeddings requires a joint dictionary") + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embed not compatible with --decoder-embed-path" + ) + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to " + "match --decoder-embed-dim" + ) + pretrained_decoder_embed = pretrained_encoder_embed + args.share_decoder_input_output_embed = True + else: + # separate decoder input embeddings + pretrained_decoder_embed = None + if args.decoder_embed_path: + pretrained_decoder_embed = load_pretrained_embedding_from_file( + args.decoder_embed_path, + task.target_dictionary, + args.decoder_embed_dim, + ) + # one last double check of parameter combinations + if args.share_decoder_input_output_embed and ( + args.decoder_embed_dim != args.decoder_out_embed_dim + ): + raise ValueError( + "--share-decoder-input-output-embeddings requires " + "--decoder-embed-dim to match --decoder-out-embed-dim" + ) + + if args.encoder_freeze_embed: + pretrained_encoder_embed.weight.requires_grad = False + if args.decoder_freeze_embed: + pretrained_decoder_embed.weight.requires_grad = False + + encoder = LSTMEncoder( + dictionary=task.source_dictionary, + embed_dim=args.encoder_embed_dim, + hidden_size=args.encoder_hidden_size, + num_layers=args.encoder_layers, + dropout_in=args.encoder_dropout_in, + dropout_out=args.encoder_dropout_out, + bidirectional=args.encoder_bidirectional, + pretrained_embed=pretrained_encoder_embed, + max_source_positions=max_source_positions, + ) + decoder = LSTMDecoder( + dictionary=task.target_dictionary, + embed_dim=args.decoder_embed_dim, + hidden_size=args.decoder_hidden_size, + out_embed_dim=args.decoder_out_embed_dim, + num_layers=args.decoder_layers, + dropout_in=args.decoder_dropout_in, + dropout_out=args.decoder_dropout_out, + attention=utils.eval_bool(args.decoder_attention), + encoder_output_units=encoder.output_units, + pretrained_embed=pretrained_decoder_embed, + share_input_output_embed=args.share_decoder_input_output_embed, + adaptive_softmax_cutoff=( + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int) + if args.criterion == "adaptive_loss" + else None + ), + max_target_positions=max_target_positions, + residuals=False, + ) + return cls(encoder, decoder) + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + ): + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths) + decoder_out = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + incremental_state=incremental_state, + ) + return decoder_out + + +class LSTMEncoder(FairseqEncoder): + """LSTM encoder.""" + + def __init__( + self, + dictionary, + embed_dim=512, + hidden_size=512, + num_layers=1, + dropout_in=0.1, + dropout_out=0.1, + bidirectional=False, + left_pad=True, + pretrained_embed=None, + padding_idx=None, + max_source_positions=DEFAULT_MAX_SOURCE_POSITIONS, + ): + super().__init__(dictionary) + self.num_layers = num_layers + self.dropout_in_module = FairseqDropout( + dropout_in*1.0, module_name=self.__class__.__name__ + ) + self.dropout_out_module = FairseqDropout( + dropout_out*1.0, module_name=self.__class__.__name__ + ) + self.bidirectional = bidirectional + self.hidden_size = hidden_size + self.max_source_positions = max_source_positions + + num_embeddings = len(dictionary) + self.padding_idx = padding_idx if padding_idx is not None else dictionary.pad() + if pretrained_embed is None: + self.embed_tokens = Embedding(num_embeddings, embed_dim, self.padding_idx) + else: + self.embed_tokens = pretrained_embed + + self.lstm = LSTM( + input_size=embed_dim, + hidden_size=hidden_size, + num_layers=num_layers, + dropout=self.dropout_out_module.p if num_layers > 1 else 0.0, + bidirectional=bidirectional, + ) + self.left_pad = left_pad + + self.output_units = hidden_size + if bidirectional: + self.output_units *= 2 + + def forward( + self, + src_tokens: Tensor, + src_lengths: Tensor, + enforce_sorted: bool = True, + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of + shape `(batch, src_len)` + src_lengths (LongTensor): lengths of each source sentence of + shape `(batch)` + enforce_sorted (bool, optional): if True, `src_tokens` is + expected to contain sequences sorted by length in a + decreasing order. If False, this condition is not + required. Default: True. + """ + if self.left_pad: + # nn.utils.rnn.pack_padded_sequence requires right-padding; + # convert left-padding to right-padding + src_tokens = utils.convert_padding_direction( + src_tokens, + torch.zeros_like(src_tokens).fill_(self.padding_idx), + left_to_right=True, + ) + + bsz, seqlen = src_tokens.size() + + # embed tokens + x = self.embed_tokens(src_tokens) + x = self.dropout_in_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # pack embedded source tokens into a PackedSequence + packed_x = nn.utils.rnn.pack_padded_sequence( + x, src_lengths.cpu(), enforce_sorted=enforce_sorted + ) + + # apply LSTM + if self.bidirectional: + state_size = 2 * self.num_layers, bsz, self.hidden_size + else: + state_size = self.num_layers, bsz, self.hidden_size + h0 = x.new_zeros(*state_size) + c0 = x.new_zeros(*state_size) + packed_outs, (final_hiddens, final_cells) = self.lstm(packed_x, (h0, c0)) + + # unpack outputs and apply dropout + x, _ = nn.utils.rnn.pad_packed_sequence( + packed_outs, padding_value=self.padding_idx * 1.0 + ) + x = self.dropout_out_module(x) + assert list(x.size()) == [seqlen, bsz, self.output_units] + + if self.bidirectional: + final_hiddens = self.combine_bidir(final_hiddens, bsz) + final_cells = self.combine_bidir(final_cells, bsz) + + encoder_padding_mask = src_tokens.eq(self.padding_idx).t() + + return tuple( + ( + x, # seq_len x batch x hidden + final_hiddens, # num_layers x batch x num_directions*hidden + final_cells, # num_layers x batch x num_directions*hidden + encoder_padding_mask, # seq_len x batch + ) + ) + + def combine_bidir(self, outs, bsz: int): + out = outs.view(self.num_layers, 2, bsz, -1).transpose(1, 2).contiguous() + return out.view(self.num_layers, bsz, -1) + + def reorder_encoder_out(self, encoder_out: Tuple[Tensor, Tensor, Tensor, Tensor], new_order): + return tuple( + ( + encoder_out[0].index_select(1, new_order), + encoder_out[1].index_select(1, new_order), + encoder_out[2].index_select(1, new_order), + encoder_out[3].index_select(1, new_order), + ) + ) + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return self.max_source_positions + + +class AttentionLayer(nn.Module): + def __init__(self, input_embed_dim, source_embed_dim, output_embed_dim, bias=False): + super().__init__() + + self.input_proj = Linear(input_embed_dim, source_embed_dim, bias=bias) + self.output_proj = Linear( + input_embed_dim + source_embed_dim, output_embed_dim, bias=bias + ) + + def forward(self, input, source_hids, encoder_padding_mask): + # input: bsz x input_embed_dim + # source_hids: srclen x bsz x source_embed_dim + + # x: bsz x source_embed_dim + x = self.input_proj(input) + + # compute attention + attn_scores = (source_hids * x.unsqueeze(0)).sum(dim=2) + + # don't attend over padding + if encoder_padding_mask is not None: + attn_scores = ( + attn_scores.float() + .masked_fill_(encoder_padding_mask, float("-inf")) + .type_as(attn_scores) + ) # FP16 support: cast to float and back + + attn_scores = F.softmax(attn_scores, dim=0) # srclen x bsz + + # sum weighted sources + x = (attn_scores.unsqueeze(2) * source_hids).sum(dim=0) + + x = torch.tanh(self.output_proj(torch.cat((x, input), dim=1))) + return x, attn_scores + + +class LSTMDecoder(FairseqIncrementalDecoder): + """LSTM decoder.""" + + def __init__( + self, + dictionary, + embed_dim=512, + hidden_size=512, + out_embed_dim=512, + num_layers=1, + dropout_in=0.1, + dropout_out=0.1, + attention=True, + encoder_output_units=512, + pretrained_embed=None, + share_input_output_embed=False, + adaptive_softmax_cutoff=None, + max_target_positions=DEFAULT_MAX_TARGET_POSITIONS, + residuals=False, + ): + super().__init__(dictionary) + self.dropout_in_module = FairseqDropout( + dropout_in*1.0, module_name=self.__class__.__name__ + ) + self.dropout_out_module = FairseqDropout( + dropout_out*1.0, module_name=self.__class__.__name__ + ) + self.hidden_size = hidden_size + self.share_input_output_embed = share_input_output_embed + self.need_attn = True + self.max_target_positions = max_target_positions + self.residuals = residuals + self.num_layers = num_layers + + self.adaptive_softmax = None + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + if pretrained_embed is None: + self.embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + else: + self.embed_tokens = pretrained_embed + + self.encoder_output_units = encoder_output_units + if encoder_output_units != hidden_size and encoder_output_units != 0: + self.encoder_hidden_proj = Linear(encoder_output_units, hidden_size) + self.encoder_cell_proj = Linear(encoder_output_units, hidden_size) + else: + self.encoder_hidden_proj = self.encoder_cell_proj = None + + # disable input feeding if there is no encoder + # input feeding is described in arxiv.org/abs/1508.04025 + input_feed_size = 0 if encoder_output_units == 0 else hidden_size + self.layers = nn.ModuleList( + [ + LSTMCell( + input_size=input_feed_size + embed_dim + if layer == 0 + else hidden_size, + hidden_size=hidden_size, + ) + for layer in range(num_layers) + ] + ) + + if attention: + # TODO make bias configurable + self.attention = AttentionLayer( + hidden_size, encoder_output_units, hidden_size, bias=False + ) + else: + self.attention = None + + if hidden_size != out_embed_dim: + self.additional_fc = Linear(hidden_size, out_embed_dim) + + if adaptive_softmax_cutoff is not None: + # setting adaptive_softmax dropout to dropout_out for now but can be redefined + self.adaptive_softmax = AdaptiveSoftmax( + num_embeddings, + hidden_size, + adaptive_softmax_cutoff, + dropout=dropout_out, + ) + elif not self.share_input_output_embed: + self.fc_out = Linear(out_embed_dim, num_embeddings, dropout=dropout_out) + + def forward( + self, + prev_output_tokens, + encoder_out: Optional[Tuple[Tensor, Tensor, Tensor, Tensor]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + src_lengths: Optional[Tensor] = None, + ): + x, attn_scores = self.extract_features( + prev_output_tokens, encoder_out, incremental_state + ) + return self.output_layer(x), attn_scores + + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Tuple[Tensor, Tensor, Tensor, Tensor]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + ): + """ + Similar to *forward* but only return features. + """ + # get outputs from encoder + if encoder_out is not None: + encoder_outs = encoder_out[0] + encoder_hiddens = encoder_out[1] + encoder_cells = encoder_out[2] + encoder_padding_mask = encoder_out[3] + else: + encoder_outs = torch.empty(0) + encoder_hiddens = torch.empty(0) + encoder_cells = torch.empty(0) + encoder_padding_mask = torch.empty(0) + srclen = encoder_outs.size(0) + + if incremental_state is not None and len(incremental_state) > 0: + prev_output_tokens = prev_output_tokens[:, -1:] + + bsz, seqlen = prev_output_tokens.size() + + # embed tokens + x = self.embed_tokens(prev_output_tokens) + x = self.dropout_in_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # initialize previous states (or get from cache during incremental generation) + if incremental_state is not None and len(incremental_state) > 0: + prev_hiddens, prev_cells, input_feed = self.get_cached_state( + incremental_state + ) + elif encoder_out is not None: + # setup recurrent cells + prev_hiddens = [encoder_hiddens[i] for i in range(self.num_layers)] + prev_cells = [encoder_cells[i] for i in range(self.num_layers)] + if self.encoder_hidden_proj is not None: + prev_hiddens = [self.encoder_hidden_proj(y) for y in prev_hiddens] + prev_cells = [self.encoder_cell_proj(y) for y in prev_cells] + input_feed = x.new_zeros(bsz, self.hidden_size) + else: + # setup zero cells, since there is no encoder + zero_state = x.new_zeros(bsz, self.hidden_size) + prev_hiddens = [zero_state for i in range(self.num_layers)] + prev_cells = [zero_state for i in range(self.num_layers)] + input_feed = None + + assert ( + srclen > 0 or self.attention is None + ), "attention is not supported if there are no encoder outputs" + attn_scores: Optional[Tensor] = ( + x.new_zeros(srclen, seqlen, bsz) if self.attention is not None else None + ) + outs = [] + for j in range(seqlen): + # input feeding: concatenate context vector from previous time step + if input_feed is not None: + input = torch.cat((x[j, :, :], input_feed), dim=1) + else: + input = x[j] + + for i, rnn in enumerate(self.layers): + # recurrent cell + hidden, cell = rnn(input, (prev_hiddens[i], prev_cells[i])) + + # hidden state becomes the input to the next layer + input = self.dropout_out_module(hidden) + if self.residuals: + input = input + prev_hiddens[i] + + # save state for next time step + prev_hiddens[i] = hidden + prev_cells[i] = cell + + # apply attention using the last layer's hidden state + if self.attention is not None: + assert attn_scores is not None + out, attn_scores[:, j, :] = self.attention( + hidden, encoder_outs, encoder_padding_mask + ) + else: + out = hidden + out = self.dropout_out_module(out) + + # input feeding + if input_feed is not None: + input_feed = out + + # save final output + outs.append(out) + + # Stack all the necessary tensors together and store + prev_hiddens_tensor = torch.stack(prev_hiddens) + prev_cells_tensor = torch.stack(prev_cells) + cache_state = torch.jit.annotate( + Dict[str, Optional[Tensor]], + { + "prev_hiddens": prev_hiddens_tensor, + "prev_cells": prev_cells_tensor, + "input_feed": input_feed, + }, + ) + self.set_incremental_state(incremental_state, "cached_state", cache_state) + + # collect outputs across time steps + x = torch.cat(outs, dim=0).view(seqlen, bsz, self.hidden_size) + + # T x B x C -> B x T x C + x = x.transpose(1, 0) + + if hasattr(self, "additional_fc") and self.adaptive_softmax is None: + x = self.additional_fc(x) + x = self.dropout_out_module(x) + # srclen x tgtlen x bsz -> bsz x tgtlen x srclen + if not self.training and self.need_attn and self.attention is not None: + assert attn_scores is not None + attn_scores = attn_scores.transpose(0, 2) + else: + attn_scores = None + return x, attn_scores + + def output_layer(self, x): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + if self.share_input_output_embed: + x = F.linear(x, self.embed_tokens.weight) + else: + x = self.fc_out(x) + return x + + def get_cached_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + ) -> Tuple[List[Tensor], List[Tensor], Optional[Tensor]]: + cached_state = self.get_incremental_state(incremental_state, "cached_state") + assert cached_state is not None + prev_hiddens_ = cached_state["prev_hiddens"] + assert prev_hiddens_ is not None + prev_cells_ = cached_state["prev_cells"] + assert prev_cells_ is not None + prev_hiddens = [prev_hiddens_[i] for i in range(self.num_layers)] + prev_cells = [prev_cells_[j] for j in range(self.num_layers)] + input_feed = cached_state[ + "input_feed" + ] # can be None for decoder-only language models + return prev_hiddens, prev_cells, input_feed + + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + if incremental_state is None or len(incremental_state) == 0: + return + prev_hiddens, prev_cells, input_feed = self.get_cached_state(incremental_state) + prev_hiddens = [p.index_select(0, new_order) for p in prev_hiddens] + prev_cells = [p.index_select(0, new_order) for p in prev_cells] + if input_feed is not None: + input_feed = input_feed.index_select(0, new_order) + cached_state_new = torch.jit.annotate( + Dict[str, Optional[Tensor]], + { + "prev_hiddens": torch.stack(prev_hiddens), + "prev_cells": torch.stack(prev_cells), + "input_feed": input_feed, + }, + ) + self.set_incremental_state(incremental_state, "cached_state", cached_state_new), + return + + def max_positions(self): + """Maximum output length supported by the decoder.""" + return self.max_target_positions + + def make_generation_fast_(self, need_attn=False, **kwargs): + self.need_attn = need_attn + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.uniform_(m.weight, -0.1, 0.1) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def LSTM(input_size, hidden_size, **kwargs): + m = nn.LSTM(input_size, hidden_size, **kwargs) + for name, param in m.named_parameters(): + if "weight" in name or "bias" in name: + param.data.uniform_(-0.1, 0.1) + return m + + +def LSTMCell(input_size, hidden_size, **kwargs): + m = nn.LSTMCell(input_size, hidden_size, **kwargs) + for name, param in m.named_parameters(): + if "weight" in name or "bias" in name: + param.data.uniform_(-0.1, 0.1) + return m + + +def Linear(in_features, out_features, bias=True, dropout=0.0): + """Linear layer (input: N x T x C)""" + m = nn.Linear(in_features, out_features, bias=bias) + m.weight.data.uniform_(-0.1, 0.1) + if bias: + m.bias.data.uniform_(-0.1, 0.1) + return m + + +@register_model_architecture("lstm", "lstm") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_freeze_embed = getattr(args, "encoder_freeze_embed", False) + args.encoder_hidden_size = getattr( + args, "encoder_hidden_size", args.encoder_embed_dim + ) + args.encoder_layers = getattr(args, "encoder_layers", 1) + args.encoder_bidirectional = getattr(args, "encoder_bidirectional", False) + args.encoder_dropout_in = getattr(args, "encoder_dropout_in", args.dropout) + args.encoder_dropout_out = getattr(args, "encoder_dropout_out", args.dropout) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_freeze_embed = getattr(args, "decoder_freeze_embed", False) + args.decoder_hidden_size = getattr( + args, "decoder_hidden_size", args.decoder_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 1) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + args.decoder_attention = getattr(args, "decoder_attention", "1") + args.decoder_dropout_in = getattr(args, "decoder_dropout_in", args.dropout) + args.decoder_dropout_out = getattr(args, "decoder_dropout_out", args.dropout) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.adaptive_softmax_cutoff = getattr( + args, "adaptive_softmax_cutoff", "10000,50000,200000" + ) + + +@register_model_architecture("lstm", "lstm_wiseman_iwslt_de_en") +def lstm_wiseman_iwslt_de_en(args): + args.dropout = getattr(args, "dropout", 0.1) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_dropout_in = getattr(args, "encoder_dropout_in", 0) + args.encoder_dropout_out = getattr(args, "encoder_dropout_out", 0) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 256) + args.decoder_dropout_in = getattr(args, "decoder_dropout_in", 0) + args.decoder_dropout_out = getattr(args, "decoder_dropout_out", args.dropout) + base_architecture(args) + + +@register_model_architecture("lstm", "lstm_luong_wmt_en_de") +def lstm_luong_wmt_en_de(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1000) + args.encoder_layers = getattr(args, "encoder_layers", 4) + args.encoder_dropout_out = getattr(args, "encoder_dropout_out", 0) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1000) + args.decoder_layers = getattr(args, "decoder_layers", 4) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 1000) + args.decoder_dropout_out = getattr(args, "decoder_dropout_out", 0) + base_architecture(args) diff --git a/fairseq/fairseq/models/lstm_lm.py b/fairseq/fairseq/models/lstm_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..454f0ac36fab78bf02a8e2f07ed9607d1da87e34 --- /dev/null +++ b/fairseq/fairseq/models/lstm_lm.py @@ -0,0 +1,142 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq import utils +from fairseq.models import ( + FairseqLanguageModel, + register_model, + register_model_architecture, +) +from fairseq.models.lstm import Embedding, LSTMDecoder + + +DEFAULT_MAX_TARGET_POSITIONS = 1e5 + + +@register_model("lstm_lm") +class LSTMLanguageModel(FairseqLanguageModel): + def __init__(self, decoder): + super().__init__(decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-hidden-size', type=int, metavar='N', + help='decoder hidden size') + parser.add_argument('--decoder-layers', type=int, metavar='N', + help='number of decoder layers') + parser.add_argument('--decoder-out-embed-dim', type=int, metavar='N', + help='decoder output embedding dimension') + parser.add_argument('--decoder-attention', type=str, metavar='BOOL', + help='decoder attention') + parser.add_argument('--adaptive-softmax-cutoff', metavar='EXPR', + help='comma separated list of adaptive softmax cutoff points. ' + 'Must be used with adaptive_loss criterion') + parser.add_argument('--residuals', default=False, + action='store_true', + help='applying residuals between LSTM layers') + + # Granular dropout settings (if not specified these default to --dropout) + parser.add_argument('--decoder-dropout-in', type=float, metavar='D', + help='dropout probability for decoder input embedding') + parser.add_argument('--decoder-dropout-out', type=float, metavar='D', + help='dropout probability for decoder output') + parser.add_argument('--share-decoder-input-output-embed', default=False, + action='store_true', + help='share decoder input and output embeddings') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if getattr(args, "max_target_positions", None) is not None: + max_target_positions = args.max_target_positions + else: + max_target_positions = getattr( + args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS + ) + + def load_pretrained_embedding_from_file(embed_path, dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + embed_tokens = Embedding(num_embeddings, embed_dim, padding_idx) + embed_dict = utils.parse_embedding(embed_path) + utils.print_embed_overlap(embed_dict, dictionary) + return utils.load_embedding(embed_dict, dictionary, embed_tokens) + + pretrained_decoder_embed = None + if args.decoder_embed_path: + pretrained_decoder_embed = load_pretrained_embedding_from_file( + args.decoder_embed_path, task.target_dictionary, args.decoder_embed_dim + ) + + if args.share_decoder_input_output_embed: + # double check all parameters combinations are valid + if task.source_dictionary != task.target_dictionary: + raise ValueError( + "--share-decoder-input-output-embeddings requires a joint dictionary" + ) + + if args.decoder_embed_dim != args.decoder_out_embed_dim: + raise ValueError( + "--share-decoder-input-output-embeddings requires " + "--decoder-embed-dim to match --decoder-out-embed-dim" + ) + + decoder = LSTMDecoder( + dictionary=task.dictionary, + embed_dim=args.decoder_embed_dim, + hidden_size=args.decoder_hidden_size, + out_embed_dim=args.decoder_out_embed_dim, + num_layers=args.decoder_layers, + dropout_in=args.decoder_dropout_in, + dropout_out=args.decoder_dropout_out, + attention=False, # decoder-only language model doesn't support attention + encoder_output_units=0, + pretrained_embed=pretrained_decoder_embed, + share_input_output_embed=args.share_decoder_input_output_embed, + adaptive_softmax_cutoff=( + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int) + if args.criterion == "adaptive_loss" + else None + ), + max_target_positions=max_target_positions, + residuals=args.residuals, + ) + + return cls(decoder) + + +@register_model_architecture("lstm_lm", "lstm_lm") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_hidden_size = getattr( + args, "decoder_hidden_size", args.decoder_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 1) + args.decoder_out_embed_dim = getattr(args, "decoder_out_embed_dim", 512) + args.decoder_attention = getattr(args, "decoder_attention", "0") + args.decoder_dropout_in = getattr(args, "decoder_dropout_in", args.dropout) + args.decoder_dropout_out = getattr(args, "decoder_dropout_out", args.dropout) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.adaptive_softmax_cutoff = getattr( + args, "adaptive_softmax_cutoff", "10000,50000,200000" + ) + args.residuals = getattr(args, "residuals", False) diff --git a/fairseq/fairseq/models/masked_lm.py b/fairseq/fairseq/models/masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..5cb49dd77cc3514e6c1383c4286e90979f6edb34 --- /dev/null +++ b/fairseq/fairseq/models/masked_lm.py @@ -0,0 +1,404 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderModel, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + LayerNorm, + SinusoidalPositionalEmbedding, + TransformerSentenceEncoder, +) +from fairseq.modules.transformer_sentence_encoder import init_bert_params +from fairseq.utils import safe_hasattr + + +logger = logging.getLogger(__name__) + + +@register_model("masked_lm") +class MaskedLMModel(FairseqEncoderModel): + """ + Class for training a Masked Language Model. It also supports an + additional sentence level prediction if the sent-loss argument is set. + """ + + def __init__(self, args, encoder): + super().__init__(encoder) + self.args = args + + # if specified then apply bert initialization on the model. We need + # to explictly call this to make sure that the output embeddings + # and projection layers are also correctly initialized + if getattr(args, "apply_bert_init", False): + self.apply(init_bert_params) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # Arguments related to dropout + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for" " attention weights", + ) + parser.add_argument( + "--act-dropout", + type=float, + metavar="D", + help="dropout probability after" " activation in FFN", + ) + + # Arguments related to hidden states and self-attention + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="num encoder layers" + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads", + ) + + # Arguments related to input and output embeddings + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--share-encoder-input-output-embed", + action="store_true", + help="share encoder input" " and output embeddings", + ) + parser.add_argument( + "--encoder-learned-pos", + action="store_true", + help="use learned positional embeddings in the encoder", + ) + parser.add_argument( + "--no-token-positional-embeddings", + action="store_true", + help="if set, disables positional embeddings" " (outside self attention)", + ) + parser.add_argument( + "--num-segment", type=int, metavar="N", help="num segment in the input" + ) + parser.add_argument( + "--max-positions", type=int, help="number of positional embeddings to learn" + ) + + # Arguments related to sentence level prediction + parser.add_argument( + "--sentence-class-num", + type=int, + metavar="N", + help="number of classes for sentence task", + ) + parser.add_argument( + "--sent-loss", + action="store_true", + help="if set," " calculate sentence level predictions", + ) + + # Arguments related to parameter initialization + parser.add_argument( + "--apply-bert-init", + action="store_true", + help="use custom param initialization for BERT", + ) + + # misc params + parser.add_argument( + "--activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + parser.add_argument( + "--pooler-activation-fn", + choices=utils.get_available_activation_fns(), + help="Which activation function to use for pooler layer.", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + + def forward(self, src_tokens, segment_labels=None, **kwargs): + return self.encoder(src_tokens, segment_labels=segment_labels, **kwargs) + + def max_positions(self): + return self.encoder.max_positions + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + # make sure all arguments are present in older models + base_architecture(args) + + if not safe_hasattr(args, "max_positions"): + args.max_positions = args.tokens_per_sample + + logger.info(args) + + encoder = MaskedLMEncoder(args, task.dictionary) + return cls(args, encoder) + + +class MaskedLMEncoder(FairseqEncoder): + """ + Encoder for Masked Language Modelling. + """ + + def __init__(self, args, dictionary): + super().__init__(dictionary) + + self.padding_idx = dictionary.pad() + self.vocab_size = dictionary.__len__() + self.max_positions = args.max_positions + + self.sentence_encoder = TransformerSentenceEncoder( + padding_idx=self.padding_idx, + vocab_size=self.vocab_size, + num_encoder_layers=args.encoder_layers, + embedding_dim=args.encoder_embed_dim, + ffn_embedding_dim=args.encoder_ffn_embed_dim, + num_attention_heads=args.encoder_attention_heads, + dropout=args.dropout, + attention_dropout=args.attention_dropout, + activation_dropout=args.act_dropout, + max_seq_len=self.max_positions, + num_segments=args.num_segment, + use_position_embeddings=not args.no_token_positional_embeddings, + encoder_normalize_before=args.encoder_normalize_before, + apply_bert_init=args.apply_bert_init, + activation_fn=args.activation_fn, + learned_pos_embedding=args.encoder_learned_pos, + ) + + self.share_input_output_embed = args.share_encoder_input_output_embed + self.embed_out = None + self.sentence_projection_layer = None + self.sentence_out_dim = args.sentence_class_num + self.lm_output_learned_bias = None + + # Remove head is set to true during fine-tuning + self.load_softmax = not getattr(args, "remove_head", False) + + self.masked_lm_pooler = nn.Linear( + args.encoder_embed_dim, args.encoder_embed_dim + ) + self.pooler_activation = utils.get_activation_fn(args.pooler_activation_fn) + + self.lm_head_transform_weight = nn.Linear( + args.encoder_embed_dim, args.encoder_embed_dim + ) + self.activation_fn = utils.get_activation_fn(args.activation_fn) + self.layer_norm = LayerNorm(args.encoder_embed_dim) + + self.lm_output_learned_bias = None + if self.load_softmax: + self.lm_output_learned_bias = nn.Parameter(torch.zeros(self.vocab_size)) + + if not self.share_input_output_embed: + self.embed_out = nn.Linear( + args.encoder_embed_dim, self.vocab_size, bias=False + ) + + if args.sent_loss: + self.sentence_projection_layer = nn.Linear( + args.encoder_embed_dim, self.sentence_out_dim, bias=False + ) + + def forward(self, src_tokens, segment_labels=None, masked_tokens=None, **unused): + """ + Forward pass for Masked LM encoder. This first computes the token + embedding using the token embedding matrix, position embeddings (if + specified) and segment embeddings (if specified). + + Here we assume that the sentence representation corresponds to the + output of the classification_token (see bert_task or cross_lingual_lm + task for more details). + Args: + - src_tokens: B x T matrix representing sentences + - segment_labels: B x T matrix representing segment label for tokens + Returns: + - a tuple of the following: + - logits for predictions in format B x T x C to be used in + softmax afterwards + - a dictionary of additional data, where 'pooled_output' contains + the representation for classification_token and 'inner_states' + is a list of internal model states used to compute the + predictions (similar in ELMO). 'sentence_logits' + is the prediction logit for NSP task and is only computed if + this is specified in the input arguments. + """ + + inner_states, sentence_rep = self.sentence_encoder( + src_tokens, + segment_labels=segment_labels, + ) + + x = inner_states[-1].transpose(0, 1) + # project masked tokens only + if masked_tokens is not None: + x = x[masked_tokens, :] + x = self.layer_norm(self.activation_fn(self.lm_head_transform_weight(x))) + + pooled_output = self.pooler_activation(self.masked_lm_pooler(sentence_rep)) + + # project back to size of vocabulary + if self.share_input_output_embed and hasattr( + self.sentence_encoder.embed_tokens, "weight" + ): + x = F.linear(x, self.sentence_encoder.embed_tokens.weight) + elif self.embed_out is not None: + x = self.embed_out(x) + if self.lm_output_learned_bias is not None: + x = x + self.lm_output_learned_bias + sentence_logits = None + if self.sentence_projection_layer: + sentence_logits = self.sentence_projection_layer(pooled_output) + + return x, { + "inner_states": inner_states, + "pooled_output": pooled_output, + "sentence_logits": sentence_logits, + } + + def max_positions(self): + """Maximum output length supported by the encoder.""" + return self.max_positions + + def upgrade_state_dict_named(self, state_dict, name): + if isinstance( + self.sentence_encoder.embed_positions, SinusoidalPositionalEmbedding + ): + state_dict[ + name + ".sentence_encoder.embed_positions._float_tensor" + ] = torch.FloatTensor(1) + if not self.load_softmax: + for k in list(state_dict.keys()): + if ( + "embed_out.weight" in k + or "sentence_projection_layer.weight" in k + or "lm_output_learned_bias" in k + ): + del state_dict[k] + return state_dict + + +@register_model_architecture("masked_lm", "masked_lm") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.act_dropout = getattr(args, "act_dropout", 0.0) + + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.share_encoder_input_output_embed = getattr( + args, "share_encoder_input_output_embed", False + ) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.num_segment = getattr(args, "num_segment", 2) + + args.sentence_class_num = getattr(args, "sentence_class_num", 2) + args.sent_loss = getattr(args, "sent_loss", False) + + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.activation_fn = getattr(args, "activation_fn", "relu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + + +@register_model_architecture("masked_lm", "bert_base") +def bert_base_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.share_encoder_input_output_embed = getattr( + args, "share_encoder_input_output_embed", True + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + args.num_segment = getattr(args, "num_segment", 2) + + args.encoder_layers = getattr(args, "encoder_layers", 12) + + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 12) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 3072) + + args.sentence_class_num = getattr(args, "sentence_class_num", 2) + args.sent_loss = getattr(args, "sent_loss", True) + + args.apply_bert_init = getattr(args, "apply_bert_init", True) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + base_architecture(args) + + +@register_model_architecture("masked_lm", "bert_large") +def bert_large_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_layers = getattr(args, "encoder_layers", 24) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + bert_base_architecture(args) + + +@register_model_architecture("masked_lm", "xlm_base") +def xlm_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.share_encoder_input_output_embed = getattr( + args, "share_encoder_input_output_embed", True + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + args.num_segment = getattr(args, "num_segment", 1) + + args.encoder_layers = getattr(args, "encoder_layers", 6) + + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + + args.sent_loss = getattr(args, "sent_loss", False) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.apply_bert_init = getattr(args, "apply_bert_init", True) + base_architecture(args) diff --git a/fairseq/fairseq/models/model_utils.py b/fairseq/fairseq/models/model_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..732d66b1d5f695151c26d29eb7f6b53179c269f1 --- /dev/null +++ b/fairseq/fairseq/models/model_utils.py @@ -0,0 +1,92 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import List, Optional + +import torch +from torch import Tensor + + +@torch.jit.script +def script_skip_tensor_list(x: List[Tensor], mask): + res = [xi[mask] if xi.size(0) == mask.size(0) else xi[:, mask] for xi in x] + outputs = [] + for i, t in enumerate(res): + if t.numel() != 0: + outputs.append(t) + else: + outputs.append(x[i]) + return outputs + + +@torch.jit.script +def script_skip_tensor(x: Tensor, mask): + # None case + if x.size(0) == 0: + return x + res = x[mask] if x.size(0) == mask.size(0) else x[:, mask] + if res.numel() == 0: + return x + else: + return res + + +@torch.jit.script +def expand_2d_or_3d_tensor(x, trg_dim: int, padding_idx: int): + """ + Expand 2D/3D tensor on dim=1 + """ + if x is None: + return None + + assert x.dim() == 2 or x.dim() == 3 + assert trg_dim >= x.size(1), (trg_dim, x.size()) + if trg_dim == x.size(1): + return x + + dims = [x.size(0), trg_dim - x.size(1)] + if x.dim() == 3: + dims.append(x.size(2)) + x = torch.cat([x, torch.zeros(dims).to(x).fill_(padding_idx)], 1) + + return x + + +@torch.jit.script +def coalesce(x: Optional[Tensor], y: Tensor) -> Tensor: + return x if x is not None else y + + +@torch.jit.script +def fill_tensors( + x: Optional[Tensor], mask, y: Optional[Tensor], padding_idx: int +) -> Optional[Tensor]: + """ + Filling tensor x with y at masked positions (dim=0). + """ + if x is None or x.size()[0] == 0 or y is None: + return x + assert x.dim() == y.dim() and mask.size(0) == x.size(0) + assert x.dim() == 2 or (x.dim() == 3 and x.size(2) == y.size(2)) + + n_selected = mask.sum() + if n_selected == 0: + return x + assert n_selected == y.size(0) + if n_selected == x.size(0): + return y + + if x.size(1) < y.size(1): + x = expand_2d_or_3d_tensor(x, y.size(1), padding_idx) + x[mask] = y + elif x.size(1) > y.size(1): + x[mask] = torch.tensor(padding_idx).type_as(x) + if x.dim() == 2: + x[mask, : y.size(1)] = y + else: + x[mask, : y.size(1), :] = y + else: + x[mask] = y + return x diff --git a/fairseq/fairseq/models/multilingual_transformer.py b/fairseq/fairseq/models/multilingual_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..e722b647edd92c95a3e93489031ae331f90e0463 --- /dev/null +++ b/fairseq/fairseq/models/multilingual_transformer.py @@ -0,0 +1,229 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import OrderedDict + +from fairseq import utils +from fairseq.models import ( + FairseqMultiModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import ( + Embedding, + TransformerDecoder, + TransformerEncoder, + TransformerModel, + base_architecture, +) +from fairseq.utils import safe_hasattr + + +@register_model("multilingual_transformer") +class MultilingualTransformerModel(FairseqMultiModel): + """Train Transformer models for multiple language pairs simultaneously. + + Requires `--task multilingual_translation`. + + We inherit all arguments from TransformerModel and assume that all language + pairs use a single Transformer architecture. In addition, we provide several + options that are specific to the multilingual setting. + + Args: + --share-encoder-embeddings: share encoder embeddings across all source languages + --share-decoder-embeddings: share decoder embeddings across all target languages + --share-encoders: share all encoder params (incl. embeddings) across all source languages + --share-decoders: share all decoder params (incl. embeddings) across all target languages + """ + + def __init__(self, encoders, decoders): + super().__init__(encoders, decoders) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + TransformerModel.add_args(parser) + parser.add_argument( + "--share-encoder-embeddings", + action="store_true", + help="share encoder embeddings across languages", + ) + parser.add_argument( + "--share-decoder-embeddings", + action="store_true", + help="share decoder embeddings across languages", + ) + parser.add_argument( + "--share-encoders", + action="store_true", + help="share encoders across languages", + ) + parser.add_argument( + "--share-decoders", + action="store_true", + help="share decoders across languages", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + from fairseq.tasks.multilingual_translation import MultilingualTranslationTask + + assert isinstance(task, MultilingualTranslationTask) + + # make sure all arguments are present in older models + base_multilingual_architecture(args) + + if not safe_hasattr(args, "max_source_positions"): + args.max_source_positions = 1024 + if not safe_hasattr(args, "max_target_positions"): + args.max_target_positions = 1024 + + src_langs = [lang_pair.split("-")[0] for lang_pair in task.model_lang_pairs] + tgt_langs = [lang_pair.split("-")[1] for lang_pair in task.model_lang_pairs] + + if args.share_encoders: + args.share_encoder_embeddings = True + if args.share_decoders: + args.share_decoder_embeddings = True + + def build_embedding(dictionary, embed_dim, path=None): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + emb = Embedding(num_embeddings, embed_dim, padding_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + # build shared embeddings (if applicable) + shared_encoder_embed_tokens, shared_decoder_embed_tokens = None, None + if args.share_all_embeddings: + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + shared_encoder_embed_tokens = FairseqMultiModel.build_shared_embeddings( + dicts=task.dicts, + langs=task.langs, + embed_dim=args.encoder_embed_dim, + build_embedding=build_embedding, + pretrained_embed_path=args.encoder_embed_path, + ) + shared_decoder_embed_tokens = shared_encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + if args.share_encoder_embeddings: + shared_encoder_embed_tokens = FairseqMultiModel.build_shared_embeddings( + dicts=task.dicts, + langs=src_langs, + embed_dim=args.encoder_embed_dim, + build_embedding=build_embedding, + pretrained_embed_path=args.encoder_embed_path, + ) + if args.share_decoder_embeddings: + shared_decoder_embed_tokens = FairseqMultiModel.build_shared_embeddings( + dicts=task.dicts, + langs=tgt_langs, + embed_dim=args.decoder_embed_dim, + build_embedding=build_embedding, + pretrained_embed_path=args.decoder_embed_path, + ) + + # encoders/decoders for each language + lang_encoders, lang_decoders = {}, {} + + def get_encoder(lang): + if lang not in lang_encoders: + if shared_encoder_embed_tokens is not None: + encoder_embed_tokens = shared_encoder_embed_tokens + else: + encoder_embed_tokens = build_embedding( + task.dicts[lang], + args.encoder_embed_dim, + args.encoder_embed_path, + ) + lang_encoders[lang] = cls._get_module_class( + True, args, task.dicts[lang], encoder_embed_tokens, src_langs + ) + return lang_encoders[lang] + + def get_decoder(lang): + if lang not in lang_decoders: + if shared_decoder_embed_tokens is not None: + decoder_embed_tokens = shared_decoder_embed_tokens + else: + decoder_embed_tokens = build_embedding( + task.dicts[lang], + args.decoder_embed_dim, + args.decoder_embed_path, + ) + lang_decoders[lang] = cls._get_module_class( + False, args, task.dicts[lang], decoder_embed_tokens, tgt_langs + ) + return lang_decoders[lang] + + # shared encoders/decoders (if applicable) + shared_encoder, shared_decoder = None, None + if args.share_encoders: + shared_encoder = get_encoder(src_langs[0]) + if args.share_decoders: + shared_decoder = get_decoder(tgt_langs[0]) + + encoders, decoders = OrderedDict(), OrderedDict() + for lang_pair, src, tgt in zip(task.model_lang_pairs, src_langs, tgt_langs): + encoders[lang_pair] = ( + shared_encoder if shared_encoder is not None else get_encoder(src) + ) + decoders[lang_pair] = ( + shared_decoder if shared_decoder is not None else get_decoder(tgt) + ) + + return MultilingualTransformerModel(encoders, decoders) + + @classmethod + def _get_module_class(cls, is_encoder, args, lang_dict, embed_tokens, langs): + module_class = TransformerEncoder if is_encoder else TransformerDecoder + return module_class(args, lang_dict, embed_tokens) + + def load_state_dict(self, state_dict, strict=True, model_cfg=None): + state_dict_subset = state_dict.copy() + for k, _ in state_dict.items(): + assert k.startswith("models.") + lang_pair = k.split(".")[1] + if lang_pair not in self.models: + del state_dict_subset[k] + super().load_state_dict(state_dict_subset, strict=strict, model_cfg=model_cfg) + + +@register_model_architecture("multilingual_transformer", "multilingual_transformer") +def base_multilingual_architecture(args): + base_architecture(args) + args.share_encoder_embeddings = getattr(args, "share_encoder_embeddings", False) + args.share_decoder_embeddings = getattr(args, "share_decoder_embeddings", False) + args.share_encoders = getattr(args, "share_encoders", False) + args.share_decoders = getattr(args, "share_decoders", False) + + +@register_model_architecture( + "multilingual_transformer", "multilingual_transformer_iwslt_de_en" +) +def multilingual_transformer_iwslt_de_en(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 6) + base_multilingual_architecture(args) diff --git a/fairseq/fairseq/models/nat/__init__.py b/fairseq/fairseq/models/nat/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..05fe822487c3bcde8346648d5826f1669c6bc1ca --- /dev/null +++ b/fairseq/fairseq/models/nat/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +from .fairseq_nat_model import * +from .nonautoregressive_transformer import * +from .nat_crf_transformer import * +from .iterative_nonautoregressive_transformer import * +from .cmlm_transformer import * +from .levenshtein_transformer import * +from .insertion_transformer import * diff --git a/fairseq/fairseq/models/nat/cmlm_transformer.py b/fairseq/fairseq/models/nat/cmlm_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..c876e9453c101c00bd8e93e6e6f1fb48dc26f993 --- /dev/null +++ b/fairseq/fairseq/models/nat/cmlm_transformer.py @@ -0,0 +1,162 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +This file implements: +Ghazvininejad, Marjan, et al. +"Constant-time machine translation with conditional masked language models." +arXiv preprint arXiv:1904.09324 (2019). +""" + +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import NATransformerModel +from fairseq.utils import new_arange + + +def _skeptical_unmasking(output_scores, output_masks, p): + sorted_index = output_scores.sort(-1)[1] + boundary_len = ( + (output_masks.sum(1, keepdim=True).type_as(output_scores) - 2) * p + ).long() + skeptical_mask = new_arange(output_masks) < boundary_len + return skeptical_mask.scatter(1, sorted_index, skeptical_mask) + + +@register_model("cmlm_transformer") +class CMLMNATransformerModel(NATransformerModel): + @staticmethod + def add_args(parser): + NATransformerModel.add_args(parser) + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + assert not self.decoder.src_embedding_copy, "do not support embedding copy." + + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + # length prediction + length_out = self.decoder.forward_length( + normalize=False, encoder_out=encoder_out + ) + length_tgt = self.decoder.forward_length_prediction( + length_out, encoder_out, tgt_tokens + ) + + # decoding + word_ins_out = self.decoder( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + ) + word_ins_mask = prev_output_tokens.eq(self.unk) + + return { + "word_ins": { + "out": word_ins_out, + "tgt": tgt_tokens, + "mask": word_ins_mask, + "ls": self.args.label_smoothing, + "nll_loss": True, + }, + "length": { + "out": length_out, + "tgt": length_tgt, + "factor": self.decoder.length_loss_factor, + }, + } + + def forward_decoder(self, decoder_out, encoder_out, decoding_format=None, **kwargs): + + step = decoder_out.step + max_step = decoder_out.max_step + + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + history = decoder_out.history + + # execute the decoder + output_masks = output_tokens.eq(self.unk) + _scores, _tokens = self.decoder( + normalize=True, + prev_output_tokens=output_tokens, + encoder_out=encoder_out, + ).max(-1) + output_tokens.masked_scatter_(output_masks, _tokens[output_masks]) + output_scores.masked_scatter_(output_masks, _scores[output_masks]) + + if history is not None: + history.append(output_tokens.clone()) + + # skeptical decoding (depend on the maximum decoding steps.) + if (step + 1) < max_step: + skeptical_mask = _skeptical_unmasking( + output_scores, output_tokens.ne(self.pad), 1 - (step + 1) / max_step + ) + + output_tokens.masked_fill_(skeptical_mask, self.unk) + output_scores.masked_fill_(skeptical_mask, 0.0) + + if history is not None: + history.append(output_tokens.clone()) + + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=None, + history=history, + ) + + +@register_model_architecture("cmlm_transformer", "cmlm_transformer") +def cmlm_base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", True) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + # --- special arguments --- + args.sg_length_pred = getattr(args, "sg_length_pred", False) + args.pred_length_offset = getattr(args, "pred_length_offset", False) + args.length_loss_factor = getattr(args, "length_loss_factor", 0.1) + args.ngram_predictor = getattr(args, "ngram_predictor", 1) + args.src_embedding_copy = getattr(args, "src_embedding_copy", False) + + +@register_model_architecture("cmlm_transformer", "cmlm_transformer_wmt_en_de") +def cmlm_wmt_en_de(args): + cmlm_base_architecture(args) diff --git a/fairseq/fairseq/models/nat/fairseq_nat_model.py b/fairseq/fairseq/models/nat/fairseq_nat_model.py new file mode 100644 index 0000000000000000000000000000000000000000..b09394112f57d9e82f2a4cbc371af888281b9e8a --- /dev/null +++ b/fairseq/fairseq/models/nat/fairseq_nat_model.py @@ -0,0 +1,170 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +from fairseq.models.transformer import ( + TransformerDecoder, + TransformerEncoder, + TransformerModel, +) +from fairseq.modules.transformer_sentence_encoder import init_bert_params + + +def ensemble_encoder(func): + def wrapper(self, *args, **kwargs): + if self.ensemble_models is None or len(self.ensemble_models) == 1: + return func(self, *args, **kwargs) + encoder_outs = [func(model, *args, **kwargs, return_all_hiddens=True) for model in self.ensemble_models] + _encoder_out = encoder_outs[0].copy() + + def stack(key): + outs = [e[key][0] for e in encoder_outs] + return [torch.stack(outs, -1) if outs[0] is not None else None] + + _encoder_out["encoder_out"] = stack("encoder_out") + _encoder_out["encoder_embedding"] = stack("encoder_embedding") + + num_layers = len(_encoder_out["encoder_states"]) + if num_layers > 0: + _encoder_out["encoder_states"] = [ + torch.stack([e["encoder_states"][i] for e in encoder_outs], -1) + for i in range(num_layers) + ] + return _encoder_out + + return wrapper + + +def ensemble_decoder(func): + def wrapper(self, normalize=False, encoder_out=None, *args, **kwargs): + if self.ensemble_models is None or len(self.ensemble_models) == 1: + return func( + self, normalize=normalize, encoder_out=encoder_out, *args, **kwargs + ) + + def _replace(encoder_out, new_val): + new_encoder_out = encoder_out.copy() + new_encoder_out["encoder_out"] = [new_val] + return new_encoder_out + + action_outs = [ + func( + model, + normalize=normalize, + encoder_out=_replace( + encoder_out, + encoder_out["encoder_out"][0][:, :, :, i] + ), + *args, + **kwargs + ) + for i, model in enumerate(self.ensemble_models) + ] + + if not isinstance(action_outs[0], tuple): # return multiple values + action_outs = [[a] for a in action_outs] + else: + action_outs = [list(a) for a in action_outs] + + ensembled_outs = [] + for i in range(len(action_outs[0])): + if i == 0 and normalize: + ensembled_outs += [ + torch.logsumexp( + torch.stack([a[i] for a in action_outs], -1), dim=-1 + ) + - math.log(len(self.ensemble_models)) + ] + elif action_outs[0][i] is not None: + ensembled_outs += [torch.stack([a[i] for a in action_outs], -1)] + else: + ensembled_outs += [None] + + if len(ensembled_outs) == 1: + return ensembled_outs[0] + return tuple(ensembled_outs) + + return wrapper + + +class FairseqNATModel(TransformerModel): + """ + Abstract class for all nonautoregressive-based models + """ + + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + self.tgt_dict = decoder.dictionary + self.bos = decoder.dictionary.bos() + self.eos = decoder.dictionary.eos() + self.pad = decoder.dictionary.pad() + self.unk = decoder.dictionary.unk() + + self.ensemble_models = None + + @property + def allow_length_beam(self): + return False + + @property + def allow_ensemble(self): + return True + + def enable_ensemble(self, models): + self.encoder.ensemble_models = [m.encoder for m in models] + self.decoder.ensemble_models = [m.decoder for m in models] + + @staticmethod + def add_args(parser): + TransformerModel.add_args(parser) + parser.add_argument( + "--apply-bert-init", + action="store_true", + help="use custom param initialization for BERT", + ) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + decoder = FairseqNATDecoder(args, tgt_dict, embed_tokens) + if getattr(args, "apply_bert_init", False): + decoder.apply(init_bert_params) + return decoder + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + encoder = FairseqNATEncoder(args, src_dict, embed_tokens) + if getattr(args, "apply_bert_init", False): + encoder.apply(init_bert_params) + return encoder + + def forward_encoder(self, encoder_inputs): + return self.encoder(*encoder_inputs) + + def forward_decoder(self, *args, **kwargs): + return NotImplementedError + + def initialize_output_tokens(self, *args, **kwargs): + return NotImplementedError + + def forward(self, *args, **kwargs): + return NotImplementedError + + +class FairseqNATEncoder(TransformerEncoder): + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens) + self.ensemble_models = None + + @ensemble_encoder + def forward(self, *args, **kwargs): + return super().forward(*args, **kwargs) + + +class FairseqNATDecoder(TransformerDecoder): + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + super().__init__(args, dictionary, embed_tokens, no_encoder_attn) + self.ensemble_models = None diff --git a/fairseq/fairseq/models/nat/insertion_transformer.py b/fairseq/fairseq/models/nat/insertion_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..bc28000f59a3b9e8098f9fe710cc8335d39eea3e --- /dev/null +++ b/fairseq/fairseq/models/nat/insertion_transformer.py @@ -0,0 +1,280 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +import torch.nn.functional as F +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import ( + FairseqNATModel, + LevenshteinTransformerDecoder, + LevenshteinTransformerModel, + ensemble_decoder, +) +from fairseq.models.transformer import Linear +from fairseq.modules.transformer_sentence_encoder import init_bert_params +from fairseq.utils import new_arange + + +class NegativeDistanceScore(object): + def __init__(self): + + # pre-compute some values + self.scores = {} + + self.scores[0.5] = self.compute_score_full(50, 0.5) + self.scores[1.0] = self.compute_score_full(50, 1.0) + self.scores[2.0] = self.compute_score_full(50, 2.0) + + def __call__(self, i, L, tau): + if (tau is None) or (tau > 1000): + return 1 / L + + if tau in self.scores: + if L < self.scores[tau].shape[0]: + return self.scores[tau][L - 1, i] + return self.compute_score(L, tau)[i] + + def compute_score(self, L, tau): + s = np.array([-abs(L / 2 - i) / tau for i in range(L)]) + s = np.exp(s - s.max()) + return s / s.sum() + + def compute_score_full(self, L, tau): + s = -abs(np.arange(0, L - 1)[:, None] / 2 - np.arange(L)[None, :]) / tau + s = np.tril(s, 0) + np.triu(s - float("inf"), 1) + s = np.exp(s - s.max(1, keepdims=True)) + return s / s.sum(1, keepdims=True) + + +neg_scorer = NegativeDistanceScore() + + +def _get_ins_targets(in_tokens, out_tokens, padding_idx, unk_idx, vocab_size, tau=None): + try: + from fairseq import libnat + except ImportError as e: + import sys + + sys.stderr.write("ERROR: missing libnat. run `pip install --editable .`\n") + raise e + + B = in_tokens.size(0) + T = in_tokens.size(1) + V = vocab_size + + with torch.cuda.device_of(in_tokens): + in_tokens_list = [ + [t for t in s if t != padding_idx] for i, s in enumerate(in_tokens.tolist()) + ] + out_tokens_list = [ + [t for t in s if t != padding_idx] + for i, s in enumerate(out_tokens.tolist()) + ] + + full_labels = libnat.suggested_ed2_path( + in_tokens_list, out_tokens_list, padding_idx + ) + insert_labels = [a[:-1] for a in full_labels] + + # numericalize1 + insert_label_tensors = in_tokens.new_zeros(B * (T - 1) * V).float() + insert_index, insert_labels = zip( + *[ + (w + (j + i * (T - 1)) * V, neg_scorer(k, len(label), tau)) + for i, labels in enumerate(insert_labels) + for j, label in enumerate(labels[1:-1]) + for k, w in enumerate(label) + ] + ) # HACK 1:-1 + insert_index, insert_labels = [ + torch.tensor(list(a), device=in_tokens.device) + for a in [insert_index, insert_labels] + ] + insert_label_tensors.scatter_(0, insert_index.long(), insert_labels) + insert_label_tensors = insert_label_tensors.view(B, T - 1, V) + + return insert_label_tensors + + +def _apply_ins_words(in_tokens, in_scores, word_ins_pred, word_ins_scores, padding_idx): + + padding_masks = in_tokens[:, 1:].eq(padding_idx) + word_ins_scores.masked_fill_(padding_masks, 0.0) + word_ins_pred.masked_fill_(padding_masks, padding_idx) + + in_coords = new_arange(in_tokens).type_as(in_scores) + + # shift all padding predictions to infinite + out_coords = (in_coords[:, 1:] - 0.5).masked_fill( + word_ins_pred.eq(padding_idx), float("inf") + ) + out_coords = torch.cat([in_coords, out_coords], 1).sort(-1)[1] + out_tokens = torch.cat([in_tokens, word_ins_pred], 1).gather(1, out_coords) + out_scores = torch.cat([in_scores, word_ins_scores], 1).gather(1, out_coords) + return out_tokens, out_scores + + +@register_model("insertion_transformer") +class InsertionTransformerModel(LevenshteinTransformerModel): + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + + @staticmethod + def add_args(parser): + FairseqNATModel.add_args(parser) + parser.add_argument("--label-tau", default=None, type=float) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + decoder = InsertionTransformerDecoder(args, tgt_dict, embed_tokens) + if getattr(args, "apply_bert_init", False): + decoder.apply(init_bert_params) + return decoder + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + + assert tgt_tokens is not None, "forward function only supports training." + + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + # generate training labels for insertion + word_ins_out = self.decoder.forward_word_ins( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + ) + + word_ins_tgt = _get_ins_targets( + prev_output_tokens, + tgt_tokens, + self.pad, + self.unk, + len(self.tgt_dict), + tau=self.decoder.label_tau, + ).type_as(word_ins_out) + word_ins_masks = prev_output_tokens[:, 1:].ne(self.pad) + + return { + "word_ins": { + "out": word_ins_out, + "tgt": word_ins_tgt, + "mask": word_ins_masks, + "ls": self.args.label_smoothing, + "nll_loss": True, + } + } + + def forward_decoder( + self, decoder_out, encoder_out, eos_penalty=0.0, max_ratio=None, **kwargs + ): + + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + history = decoder_out.history + + # TODO: decoding for InsertionTransformer + word_ins_score = self.decoder.forward_word_ins( + normalize=True, prev_output_tokens=output_tokens, encoder_out=encoder_out + ) + + if eos_penalty > 0.0: + word_ins_score[:, :, self.pad] -= eos_penalty + word_ins_score, word_ins_pred = word_ins_score.max(-1) + output_tokens, output_scores = _apply_ins_words( + output_tokens, output_scores, word_ins_pred, word_ins_score, self.pad + ) + + # delete some unnecessary paddings + cut_off = output_tokens.ne(self.pad).sum(1).max() + output_tokens = output_tokens[:, :cut_off] + output_scores = output_scores[:, :cut_off] + + if history is not None: + history.append(output_tokens.clone()) + + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=None, + history=history, + ) + + +class InsertionTransformerDecoder(LevenshteinTransformerDecoder): + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + # use the TransformerDecoder's __init__ + super(LevenshteinTransformerDecoder, self).__init__( + args, dictionary, embed_tokens, no_encoder_attn=no_encoder_attn + ) + + self.dictionary = dictionary + self.bos = dictionary.bos() + self.unk = dictionary.unk() + self.eos = dictionary.eos() + self.pool_out = Linear(self.output_embed_dim * 2, self.output_embed_dim) + + self.label_tau = getattr(args, "label_tau", None) + + @ensemble_decoder + def forward_word_ins(self, normalize, encoder_out, prev_output_tokens): + features = self.extract_features(prev_output_tokens, encoder_out=encoder_out)[0] + features = self.pool_out( + torch.cat([features[:, :-1, :], features[:, 1:, :]], 2) + ) + decoder_out = self.output_layer(features) + return F.log_softmax(decoder_out, -1) if normalize else decoder_out + + def forward_mask_ins(self, *args, **kwargs): + raise NotImplementedError + + def forward_word_del(self, *args, **kwargs): + raise NotImplementedError + + +@register_model_architecture("insertion_transformer", "insertion_transformer") +def insertion_base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + # special for insertion transformer + args.label_tau = getattr(args, "label_tau", None) diff --git a/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py b/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..bc39509980a80eb8c21e0bfdb304649ad3acc4d0 --- /dev/null +++ b/fairseq/fairseq/models/nat/iterative_nonautoregressive_transformer.py @@ -0,0 +1,228 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import NATransformerModel + + +def _sequential_poisoning(s, V, beta=0.33, bos=2, eos=3, pad=1): + # s: input batch + # V: vocabulary size + rand_words = torch.randint(low=4, high=V, size=s.size(), device=s.device) + choices = torch.rand(size=s.size(), device=s.device) + choices.masked_fill_((s == pad) | (s == bos) | (s == eos), 1) + + replace = choices < beta / 3 + repeat = (choices >= beta / 3) & (choices < beta * 2 / 3) + swap = (choices >= beta * 2 / 3) & (choices < beta) + safe = choices >= beta + + for i in range(s.size(1) - 1): + rand_word = rand_words[:, i] + next_word = s[:, i + 1] + self_word = s[:, i] + + replace_i = replace[:, i] + swap_i = swap[:, i] & (next_word != 3) + repeat_i = repeat[:, i] & (next_word != 3) + safe_i = safe[:, i] | ((next_word == 3) & (~replace_i)) + + s[:, i] = ( + self_word * (safe_i | repeat_i).long() + + next_word * swap_i.long() + + rand_word * replace_i.long() + ) + s[:, i + 1] = ( + next_word * (safe_i | replace_i).long() + + self_word * (swap_i | repeat_i).long() + ) + return s + + +def gumbel_noise(input, TINY=1e-8): + return ( + input.new_zeros(*input.size()) + .uniform_() + .add_(TINY) + .log_() + .neg_() + .add_(TINY) + .log_() + .neg_() + ) + + +@register_model("iterative_nonautoregressive_transformer") +class IterNATransformerModel(NATransformerModel): + @staticmethod + def add_args(parser): + NATransformerModel.add_args(parser) + parser.add_argument( + "--train-step", + type=int, + help="number of refinement iterations during training", + ) + parser.add_argument( + "--dae-ratio", + type=float, + help="the probability of switching to the denoising auto-encoder loss", + ) + parser.add_argument( + "--stochastic-approx", + action="store_true", + help="sampling from the decoder as the inputs for next iteration", + ) + + @classmethod + def build_model(cls, args, task): + model = super().build_model(args, task) + model.train_step = getattr(args, "train_step", 4) + model.dae_ratio = getattr(args, "dae_ratio", 0.5) + model.stochastic_approx = getattr(args, "stochastic_approx", False) + return model + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + + B, T = prev_output_tokens.size() + + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + # length prediction + length_out = self.decoder.forward_length( + normalize=False, encoder_out=encoder_out + ) + length_tgt = self.decoder.forward_length_prediction( + length_out, encoder_out, tgt_tokens + ) + + # decoding + word_ins_outs, word_ins_tgts, word_ins_masks = [], [], [] + for t in range(self.train_step): + word_ins_out = self.decoder( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + step=t, + ) + word_ins_tgt = tgt_tokens + word_ins_mask = word_ins_tgt.ne(self.pad) + + word_ins_outs.append(word_ins_out) + word_ins_tgts.append(word_ins_tgt) + word_ins_masks.append(word_ins_mask) + + if t < (self.train_step - 1): + # prediction for next iteration + if self.stochastic_approx: + word_ins_prediction = ( + word_ins_out + gumbel_noise(word_ins_out) + ).max(-1)[1] + else: + word_ins_prediction = word_ins_out.max(-1)[1] + + prev_output_tokens = prev_output_tokens.masked_scatter( + word_ins_mask, word_ins_prediction[word_ins_mask] + ) + + if self.dae_ratio > 0: + # we do not perform denoising for the first iteration + corrputed = ( + torch.rand(size=(B,), device=prev_output_tokens.device) + < self.dae_ratio + ) + corrputed_tokens = _sequential_poisoning( + tgt_tokens[corrputed], + len(self.tgt_dict), + 0.33, + self.bos, + self.eos, + self.pad, + ) + prev_output_tokens[corrputed] = corrputed_tokens + + # concat everything + word_ins_out = torch.cat(word_ins_outs, 0) + word_ins_tgt = torch.cat(word_ins_tgts, 0) + word_ins_mask = torch.cat(word_ins_masks, 0) + + return { + "word_ins": { + "out": word_ins_out, + "tgt": word_ins_tgt, + "mask": word_ins_mask, + "ls": self.args.label_smoothing, + "nll_loss": True, + }, + "length": { + "out": length_out, + "tgt": length_tgt, + "factor": self.decoder.length_loss_factor, + }, + } + + +@register_model_architecture( + "iterative_nonautoregressive_transformer", "iterative_nonautoregressive_transformer" +) +def inat_base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + # --- special arguments --- + args.sg_length_pred = getattr(args, "sg_length_pred", False) + args.pred_length_offset = getattr(args, "pred_length_offset", False) + args.length_loss_factor = getattr(args, "length_loss_factor", 0.1) + args.ngram_predictor = getattr(args, "ngram_predictor", 1) + args.src_embedding_copy = getattr(args, "src_embedding_copy", False) + + args.train_step = getattr(args, "train_step", 4) + args.dae_ratio = getattr(args, "dae_ratio", 0.5) + args.stochastic_approx = getattr(args, "stochastic_approx", False) + + +@register_model_architecture( + "iterative_nonautoregressive_transformer", + "iterative_nonautoregressive_transformer_wmt_en_de", +) +def iter_nat_wmt_en_de(args): + inat_base_architecture(args) diff --git a/fairseq/fairseq/models/nat/levenshtein_transformer.py b/fairseq/fairseq/models/nat/levenshtein_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..d60d3c52d50b1f20957039a75622ffb95d5eea24 --- /dev/null +++ b/fairseq/fairseq/models/nat/levenshtein_transformer.py @@ -0,0 +1,510 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq.iterative_refinement_generator import DecoderOut +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import FairseqNATDecoder, FairseqNATModel, ensemble_decoder +from fairseq.models.transformer import Embedding +from fairseq.modules import TransformerDecoderLayer +from fairseq.modules.transformer_sentence_encoder import init_bert_params + +from .levenshtein_utils import ( + _apply_del_words, + _apply_ins_masks, + _apply_ins_words, + _fill, + _get_del_targets, + _get_ins_targets, + _skip, + _skip_encoder_out, +) + + +@register_model("levenshtein_transformer") +class LevenshteinTransformerModel(FairseqNATModel): + @property + def allow_length_beam(self): + return False + + @staticmethod + def add_args(parser): + FairseqNATModel.add_args(parser) + parser.add_argument( + "--early-exit", + default="6,6,6", + type=str, + help="number of decoder layers before word_del, mask_ins, word_ins", + ) + parser.add_argument( + "--no-share-discriminator", + action="store_true", + help="separate parameters for discriminator", + ) + parser.add_argument( + "--no-share-maskpredictor", + action="store_true", + help="separate parameters for mask-predictor", + ) + parser.add_argument( + "--share-discriminator-maskpredictor", + action="store_true", + help="share the parameters for both mask-predictor and discriminator", + ) + parser.add_argument( + "--sampling-for-deletion", + action="store_true", + help="instead of argmax, use sampling to predict the tokens", + ) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + decoder = LevenshteinTransformerDecoder(args, tgt_dict, embed_tokens) + if getattr(args, "apply_bert_init", False): + decoder.apply(init_bert_params) + return decoder + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + + assert tgt_tokens is not None, "forward function only supports training." + + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + # generate training labels for insertion + masked_tgt_masks, masked_tgt_tokens, mask_ins_targets = _get_ins_targets( + prev_output_tokens, tgt_tokens, self.pad, self.unk + ) + mask_ins_targets = mask_ins_targets.clamp(min=0, max=255) # for safe prediction + mask_ins_masks = prev_output_tokens[:, 1:].ne(self.pad) + + mask_ins_out, _ = self.decoder.forward_mask_ins( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + ) + word_ins_out, _ = self.decoder.forward_word_ins( + normalize=False, + prev_output_tokens=masked_tgt_tokens, + encoder_out=encoder_out, + ) + + # make online prediction + if self.decoder.sampling_for_deletion: + word_predictions = torch.multinomial( + F.softmax(word_ins_out, -1).view(-1, word_ins_out.size(-1)), 1 + ).view(word_ins_out.size(0), -1) + else: + word_predictions = F.log_softmax(word_ins_out, dim=-1).max(2)[1] + + word_predictions.masked_scatter_( + ~masked_tgt_masks, tgt_tokens[~masked_tgt_masks] + ) + + # generate training labels for deletion + word_del_targets = _get_del_targets(word_predictions, tgt_tokens, self.pad) + word_del_out, _ = self.decoder.forward_word_del( + normalize=False, + prev_output_tokens=word_predictions, + encoder_out=encoder_out, + ) + word_del_masks = word_predictions.ne(self.pad) + + return { + "mask_ins": { + "out": mask_ins_out, + "tgt": mask_ins_targets, + "mask": mask_ins_masks, + "ls": 0.01, + }, + "word_ins": { + "out": word_ins_out, + "tgt": tgt_tokens, + "mask": masked_tgt_masks, + "ls": self.args.label_smoothing, + "nll_loss": True, + }, + "word_del": { + "out": word_del_out, + "tgt": word_del_targets, + "mask": word_del_masks, + }, + } + + def forward_decoder( + self, decoder_out, encoder_out, eos_penalty=0.0, max_ratio=None, **kwargs + ): + + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + attn = decoder_out.attn + history = decoder_out.history + + bsz = output_tokens.size(0) + if max_ratio is None: + max_lens = torch.zeros_like(output_tokens).fill_(255) + else: + if not encoder_out["encoder_padding_mask"]: + max_src_len = encoder_out["encoder_out"].size(0) + src_lens = encoder_out["encoder_out"].new(bsz).fill_(max_src_len) + else: + src_lens = (~encoder_out["encoder_padding_mask"][0]).sum(1) + max_lens = (src_lens * max_ratio).clamp(min=10).long() + + # delete words + # do not delete tokens if it is <s> </s> + can_del_word = output_tokens.ne(self.pad).sum(1) > 2 + if can_del_word.sum() != 0: # we cannot delete, skip + word_del_score, word_del_attn = self.decoder.forward_word_del( + normalize=True, + prev_output_tokens=_skip(output_tokens, can_del_word), + encoder_out=_skip_encoder_out(self.encoder, encoder_out, can_del_word), + ) + word_del_pred = word_del_score.max(-1)[1].bool() + + _tokens, _scores, _attn = _apply_del_words( + output_tokens[can_del_word], + output_scores[can_del_word], + word_del_attn, + word_del_pred, + self.pad, + self.bos, + self.eos, + ) + output_tokens = _fill(output_tokens, can_del_word, _tokens, self.pad) + output_scores = _fill(output_scores, can_del_word, _scores, 0) + attn = _fill(attn, can_del_word, _attn, 0.0) + + if history is not None: + history.append(output_tokens.clone()) + + # insert placeholders + can_ins_mask = output_tokens.ne(self.pad).sum(1) < max_lens + if can_ins_mask.sum() != 0: + mask_ins_score, _ = self.decoder.forward_mask_ins( + normalize=True, + prev_output_tokens=_skip(output_tokens, can_ins_mask), + encoder_out=_skip_encoder_out(self.encoder, encoder_out, can_ins_mask), + ) + if eos_penalty > 0.0: + mask_ins_score[:, :, 0] = mask_ins_score[:, :, 0] - eos_penalty + mask_ins_pred = mask_ins_score.max(-1)[1] + mask_ins_pred = torch.min( + mask_ins_pred, max_lens[can_ins_mask, None].expand_as(mask_ins_pred) + ) + + _tokens, _scores = _apply_ins_masks( + output_tokens[can_ins_mask], + output_scores[can_ins_mask], + mask_ins_pred, + self.pad, + self.unk, + self.eos, + ) + output_tokens = _fill(output_tokens, can_ins_mask, _tokens, self.pad) + output_scores = _fill(output_scores, can_ins_mask, _scores, 0) + + if history is not None: + history.append(output_tokens.clone()) + + # insert words + can_ins_word = output_tokens.eq(self.unk).sum(1) > 0 + if can_ins_word.sum() != 0: + word_ins_score, word_ins_attn = self.decoder.forward_word_ins( + normalize=True, + prev_output_tokens=_skip(output_tokens, can_ins_word), + encoder_out=_skip_encoder_out(self.encoder, encoder_out, can_ins_word), + ) + word_ins_score, word_ins_pred = word_ins_score.max(-1) + _tokens, _scores = _apply_ins_words( + output_tokens[can_ins_word], + output_scores[can_ins_word], + word_ins_pred, + word_ins_score, + self.unk, + ) + + output_tokens = _fill(output_tokens, can_ins_word, _tokens, self.pad) + output_scores = _fill(output_scores, can_ins_word, _scores, 0) + attn = _fill(attn, can_ins_word, word_ins_attn, 0.0) + + if history is not None: + history.append(output_tokens.clone()) + + # delete some unnecessary paddings + cut_off = output_tokens.ne(self.pad).sum(1).max() + output_tokens = output_tokens[:, :cut_off] + output_scores = output_scores[:, :cut_off] + attn = None if attn is None else attn[:, :cut_off, :] + + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=attn, + history=history, + ) + + def initialize_output_tokens(self, encoder_out, src_tokens): + initial_output_tokens = src_tokens.new_zeros(src_tokens.size(0), 2) + initial_output_tokens[:, 0] = self.bos + initial_output_tokens[:, 1] = self.eos + + initial_output_scores = initial_output_tokens.new_zeros( + *initial_output_tokens.size() + ).type_as(encoder_out["encoder_out"][0]) + + return DecoderOut( + output_tokens=initial_output_tokens, + output_scores=initial_output_scores, + attn=None, + step=0, + max_step=0, + history=None, + ) + + +class LevenshteinTransformerDecoder(FairseqNATDecoder): + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + super().__init__( + args, dictionary, embed_tokens, no_encoder_attn=no_encoder_attn + ) + self.dictionary = dictionary + self.bos = dictionary.bos() + self.unk = dictionary.unk() + self.eos = dictionary.eos() + self.sampling_for_deletion = getattr(args, "sampling_for_deletion", False) + self.embed_mask_ins = Embedding(256, self.output_embed_dim * 2, None) + self.embed_word_del = Embedding(2, self.output_embed_dim, None) + + # del_word, ins_mask, ins_word + self.early_exit = [int(i) for i in args.early_exit.split(",")] + assert len(self.early_exit) == 3 + + # copy layers for mask-predict/deletion + self.layers_msk = None + if getattr(args, "no_share_maskpredictor", False): + self.layers_msk = nn.ModuleList( + [ + TransformerDecoderLayer(args, no_encoder_attn) + for _ in range(self.early_exit[1]) + ] + ) + self.layers_del = None + if getattr(args, "no_share_discriminator", False): + self.layers_del = nn.ModuleList( + [ + TransformerDecoderLayer(args, no_encoder_attn) + for _ in range(self.early_exit[0]) + ] + ) + + if getattr(args, "share_discriminator_maskpredictor", False): + assert getattr( + args, "no_share_discriminator", False + ), "must set saperate discriminator" + self.layers_msk = self.layers_del + + def extract_features( + self, + prev_output_tokens, + encoder_out=None, + early_exit=None, + layers=None, + **unused + ): + """ + Similar to *forward* but only return features. + Inputs: + prev_output_tokens: Tensor(B, T) + encoder_out: a dictionary of hidden states and masks + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + the LevenshteinTransformer decoder has full-attention to all generated tokens + """ + # embed positions + positions = ( + self.embed_positions(prev_output_tokens) + if self.embed_positions is not None + else None + ) + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + attn = None + inner_states = [x] + + # decoder layers + decoder_padding_mask = prev_output_tokens.eq(self.padding_idx) + layers = self.layers if layers is None else layers + early_exit = len(layers) if early_exit is None else early_exit + for _, layer in enumerate(layers[:early_exit]): + x, attn, _ = layer( + x, + encoder_out["encoder_out"][0] + if (encoder_out is not None and len(encoder_out["encoder_out"]) > 0) + else None, + encoder_out["encoder_padding_mask"][0] + if ( + encoder_out is not None + and len(encoder_out["encoder_padding_mask"]) > 0 + ) + else None, + self_attn_mask=None, + self_attn_padding_mask=decoder_padding_mask, + ) + inner_states.append(x) + + if self.layer_norm: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": attn, "inner_states": inner_states} + + @ensemble_decoder + def forward_mask_ins(self, normalize, encoder_out, prev_output_tokens, **unused): + features, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + early_exit=self.early_exit[1], + layers=self.layers_msk, + **unused + ) + features_cat = torch.cat([features[:, :-1, :], features[:, 1:, :]], 2) + decoder_out = F.linear(features_cat, self.embed_mask_ins.weight) + if normalize: + return F.log_softmax(decoder_out, -1), extra["attn"] + return decoder_out, extra["attn"] + + @ensemble_decoder + def forward_word_ins(self, normalize, encoder_out, prev_output_tokens, **unused): + features, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + early_exit=self.early_exit[2], + layers=self.layers, + **unused + ) + decoder_out = self.output_layer(features) + if normalize: + return F.log_softmax(decoder_out, -1), extra["attn"] + return decoder_out, extra["attn"] + + @ensemble_decoder + def forward_word_del(self, normalize, encoder_out, prev_output_tokens, **unused): + features, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + early_exit=self.early_exit[0], + layers=self.layers_del, + **unused + ) + decoder_out = F.linear(features, self.embed_word_del.weight) + if normalize: + return F.log_softmax(decoder_out, -1), extra["attn"] + return decoder_out, extra["attn"] + + +@register_model_architecture("levenshtein_transformer", "levenshtein_transformer") +def levenshtein_base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.sampling_for_deletion = getattr(args, "sampling_for_deletion", False) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + args.early_exit = getattr(args, "early_exit", "6,6,6") + args.no_share_discriminator = getattr(args, "no_share_discriminator", False) + args.no_share_maskpredictor = getattr(args, "no_share_maskpredictor", False) + args.share_discriminator_maskpredictor = getattr( + args, "share_discriminator_maskpredictor", False + ) + args.no_share_last_layer = getattr(args, "no_share_last_layer", False) + + +@register_model_architecture( + "levenshtein_transformer", "levenshtein_transformer_wmt_en_de" +) +def levenshtein_transformer_wmt_en_de(args): + levenshtein_base_architecture(args) + + +# similar parameters used in the "Attention Is All You Need" paper (Vaswani et al., 2017) +@register_model_architecture( + "levenshtein_transformer", "levenshtein_transformer_vaswani_wmt_en_de_big" +) +def levenshtein_transformer_vaswani_wmt_en_de_big(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.3) + levenshtein_base_architecture(args) + + +# default parameters used in tensor2tensor implementation +@register_model_architecture( + "levenshtein_transformer", "levenshtein_transformer_wmt_en_de_big" +) +def levenshtein_transformer_wmt_en_de_big_t2t(args): + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.activation_dropout = getattr(args, "activation_dropout", 0.1) + levenshtein_transformer_vaswani_wmt_en_de_big(args) diff --git a/fairseq/fairseq/models/nat/levenshtein_utils.py b/fairseq/fairseq/models/nat/levenshtein_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..375a98c2e11354de085f0a7926f407bd1a6a2ad4 --- /dev/null +++ b/fairseq/fairseq/models/nat/levenshtein_utils.py @@ -0,0 +1,293 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq.utils import new_arange + + +# -------------- Helper Functions --------------------------------------------------- # + + +def load_libnat(): + try: + from fairseq import libnat_cuda + + return libnat_cuda, True + + except ImportError as e: + print(str(e) + "... fall back to CPU version") + + try: + from fairseq import libnat + + return libnat, False + + except ImportError as e: + import sys + + sys.stderr.write( + "ERROR: missing libnat_cuda. run `python setup.py build_ext --inplace`\n" + ) + raise e + + +def _get_ins_targets(in_tokens, out_tokens, padding_idx, unk_idx): + libnat, use_cuda = load_libnat() + + def _get_ins_targets_cuda(in_tokens, out_tokens, padding_idx, unk_idx): + in_masks = in_tokens.ne(padding_idx) + out_masks = out_tokens.ne(padding_idx) + mask_ins_targets, masked_tgt_masks = libnat.generate_insertion_labels( + out_tokens.int(), + libnat.levenshtein_distance( + in_tokens.int(), + out_tokens.int(), + in_masks.sum(1).int(), + out_masks.sum(1).int(), + ), + ) + masked_tgt_masks = masked_tgt_masks.bool() & out_masks + mask_ins_targets = mask_ins_targets.type_as(in_tokens)[ + :, 1 : in_masks.size(1) + ].masked_fill_(~in_masks[:, 1:], 0) + masked_tgt_tokens = out_tokens.masked_fill(masked_tgt_masks, unk_idx) + return masked_tgt_masks, masked_tgt_tokens, mask_ins_targets + + def _get_ins_targets_cpu(in_tokens, out_tokens, padding_idx, unk_idx): + in_seq_len, out_seq_len = in_tokens.size(1), out_tokens.size(1) + + in_tokens_list = [ + [t for t in s if t != padding_idx] for i, s in enumerate(in_tokens.tolist()) + ] + out_tokens_list = [ + [t for t in s if t != padding_idx] + for i, s in enumerate(out_tokens.tolist()) + ] + + full_labels = libnat.suggested_ed2_path( + in_tokens_list, out_tokens_list, padding_idx + ) + mask_inputs = [ + [len(c) if c[0] != padding_idx else 0 for c in a[:-1]] for a in full_labels + ] + + # generate labels + masked_tgt_masks = [] + for mask_input in mask_inputs: + mask_label = [] + for beam_size in mask_input[1:-1]: # HACK 1:-1 + mask_label += [0] + [1 for _ in range(beam_size)] + masked_tgt_masks.append( + mask_label + [0 for _ in range(out_seq_len - len(mask_label))] + ) + mask_ins_targets = [ + mask_input[1:-1] + + [0 for _ in range(in_seq_len - 1 - len(mask_input[1:-1]))] + for mask_input in mask_inputs + ] + + # transform to tensor + masked_tgt_masks = torch.tensor( + masked_tgt_masks, device=out_tokens.device + ).bool() + mask_ins_targets = torch.tensor(mask_ins_targets, device=in_tokens.device) + masked_tgt_tokens = out_tokens.masked_fill(masked_tgt_masks, unk_idx) + return masked_tgt_masks, masked_tgt_tokens, mask_ins_targets + + if use_cuda: + return _get_ins_targets_cuda(in_tokens, out_tokens, padding_idx, unk_idx) + return _get_ins_targets_cpu(in_tokens, out_tokens, padding_idx, unk_idx) + + +def _get_del_targets(in_tokens, out_tokens, padding_idx): + libnat, use_cuda = load_libnat() + + def _get_del_targets_cuda(in_tokens, out_tokens, padding_idx): + in_masks = in_tokens.ne(padding_idx) + out_masks = out_tokens.ne(padding_idx) + + word_del_targets = libnat.generate_deletion_labels( + in_tokens.int(), + libnat.levenshtein_distance( + in_tokens.int(), + out_tokens.int(), + in_masks.sum(1).int(), + out_masks.sum(1).int(), + ), + ) + word_del_targets = word_del_targets.type_as(in_tokens).masked_fill_( + ~in_masks, 0 + ) + return word_del_targets + + def _get_del_targets_cpu(in_tokens, out_tokens, padding_idx): + out_seq_len = out_tokens.size(1) + with torch.cuda.device_of(in_tokens): + in_tokens_list = [ + [t for t in s if t != padding_idx] + for i, s in enumerate(in_tokens.tolist()) + ] + out_tokens_list = [ + [t for t in s if t != padding_idx] + for i, s in enumerate(out_tokens.tolist()) + ] + + full_labels = libnat.suggested_ed2_path( + in_tokens_list, out_tokens_list, padding_idx + ) + word_del_targets = [b[-1] for b in full_labels] + word_del_targets = [ + labels + [0 for _ in range(out_seq_len - len(labels))] + for labels in word_del_targets + ] + + # transform to tensor + word_del_targets = torch.tensor(word_del_targets, device=out_tokens.device) + return word_del_targets + + if use_cuda: + return _get_del_targets_cuda(in_tokens, out_tokens, padding_idx) + return _get_del_targets_cpu(in_tokens, out_tokens, padding_idx) + + +def _apply_ins_masks( + in_tokens, in_scores, mask_ins_pred, padding_idx, unk_idx, eos_idx +): + + in_masks = in_tokens.ne(padding_idx) + in_lengths = in_masks.sum(1) + + # HACK: hacky way to shift all the paddings to eos first. + in_tokens.masked_fill_(~in_masks, eos_idx) + mask_ins_pred.masked_fill_(~in_masks[:, 1:], 0) + + out_lengths = in_lengths + mask_ins_pred.sum(1) + out_max_len = out_lengths.max() + out_masks = new_arange(out_lengths, out_max_len)[None, :] < out_lengths[:, None] + + reordering = (mask_ins_pred + in_masks[:, 1:].long()).cumsum(1) + out_tokens = ( + in_tokens.new_zeros(in_tokens.size(0), out_max_len) + .fill_(padding_idx) + .masked_fill_(out_masks, unk_idx) + ) + out_tokens[:, 0] = in_tokens[:, 0] + out_tokens.scatter_(1, reordering, in_tokens[:, 1:]) + + out_scores = None + if in_scores is not None: + in_scores.masked_fill_(~in_masks, 0) + out_scores = in_scores.new_zeros(*out_tokens.size()) + out_scores[:, 0] = in_scores[:, 0] + out_scores.scatter_(1, reordering, in_scores[:, 1:]) + + return out_tokens, out_scores + + +def _apply_ins_words(in_tokens, in_scores, word_ins_pred, word_ins_scores, unk_idx): + word_ins_masks = in_tokens.eq(unk_idx) + out_tokens = in_tokens.masked_scatter(word_ins_masks, word_ins_pred[word_ins_masks]) + + if in_scores is not None: + out_scores = in_scores.masked_scatter( + word_ins_masks, word_ins_scores[word_ins_masks] + ) + else: + out_scores = None + + return out_tokens, out_scores + + +def _apply_del_words( + in_tokens, in_scores, in_attn, word_del_pred, padding_idx, bos_idx, eos_idx +): + # apply deletion to a tensor + in_masks = in_tokens.ne(padding_idx) + bos_eos_masks = in_tokens.eq(bos_idx) | in_tokens.eq(eos_idx) + + max_len = in_tokens.size(1) + word_del_pred.masked_fill_(~in_masks, 1) + word_del_pred.masked_fill_(bos_eos_masks, 0) + + reordering = new_arange(in_tokens).masked_fill_(word_del_pred, max_len).sort(1)[1] + + out_tokens = in_tokens.masked_fill(word_del_pred, padding_idx).gather(1, reordering) + + out_scores = None + if in_scores is not None: + out_scores = in_scores.masked_fill(word_del_pred, 0).gather(1, reordering) + + out_attn = None + if in_attn is not None: + _mask = word_del_pred[:, :, None].expand_as(in_attn) + _reordering = reordering[:, :, None].expand_as(in_attn) + out_attn = in_attn.masked_fill(_mask, 0.0).gather(1, _reordering) + + return out_tokens, out_scores, out_attn + + +def _skip(x, mask): + """ + Getting sliced (dim=0) tensor by mask. Supporting tensor and list/dict of tensors. + """ + if isinstance(x, int): + return x + + if x is None: + return None + + if isinstance(x, torch.Tensor): + if x.size(0) == mask.size(0): + return x[mask] + elif x.size(1) == mask.size(0): + return x[:, mask] + + if isinstance(x, list): + return [_skip(x_i, mask) for x_i in x] + + if isinstance(x, dict): + return {k: _skip(v, mask) for k, v in x.items()} + + raise NotImplementedError + + +def _skip_encoder_out(encoder, encoder_out, mask): + if not mask.any(): + return encoder_out + else: + return encoder.reorder_encoder_out( + encoder_out, mask.nonzero(as_tuple=False).squeeze() + ) + + +def _fill(x, mask, y, padding_idx): + """ + Filling tensor x with y at masked positions (dim=0). + """ + if x is None: + return y + assert x.dim() == y.dim() and mask.size(0) == x.size(0) + assert x.dim() == 2 or (x.dim() == 3 and x.size(2) == y.size(2)) + n_selected = mask.sum() + assert n_selected == y.size(0) + + if n_selected == x.size(0): + return y + + if x.size(1) < y.size(1): + dims = [x.size(0), y.size(1) - x.size(1)] + if x.dim() == 3: + dims.append(x.size(2)) + x = torch.cat([x, x.new_zeros(*dims).fill_(padding_idx)], 1) + x[mask] = y + elif x.size(1) > y.size(1): + x[mask] = padding_idx + if x.dim() == 2: + x[mask, : y.size(1)] = y + else: + x[mask, : y.size(1), :] = y + else: + x[mask] = y + return x diff --git a/fairseq/fairseq/models/nat/nat_crf_transformer.py b/fairseq/fairseq/models/nat/nat_crf_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..d4b3cd931ceb077eb30db73df1d5d6cd714a86c2 --- /dev/null +++ b/fairseq/fairseq/models/nat/nat_crf_transformer.py @@ -0,0 +1,121 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import NATransformerModel, base_architecture +from fairseq.modules import DynamicCRF + + +@register_model("nacrf_transformer") +class NACRFTransformerModel(NATransformerModel): + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + self.crf_layer = DynamicCRF( + num_embedding=len(self.tgt_dict), + low_rank=args.crf_lowrank_approx, + beam_size=args.crf_beam_approx, + ) + + @property + def allow_ensemble(self): + return False + + @staticmethod + def add_args(parser): + NATransformerModel.add_args(parser) + parser.add_argument( + "--crf-lowrank-approx", + type=int, + help="the dimension of low-rank approximation of transition", + ) + parser.add_argument( + "--crf-beam-approx", + type=int, + help="the beam size for apporixmating the normalizing factor", + ) + parser.add_argument( + "--word-ins-loss-factor", + type=float, + help="weights on NAT loss used to co-training with CRF loss.", + ) + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + # length prediction + length_out = self.decoder.forward_length( + normalize=False, encoder_out=encoder_out + ) + length_tgt = self.decoder.forward_length_prediction( + length_out, encoder_out, tgt_tokens + ) + + # decoding + word_ins_out = self.decoder( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + ) + word_ins_tgt, word_ins_mask = tgt_tokens, tgt_tokens.ne(self.pad) + + # compute the log-likelihood of CRF + crf_nll = -self.crf_layer(word_ins_out, word_ins_tgt, word_ins_mask) + crf_nll = (crf_nll / word_ins_mask.type_as(crf_nll).sum(-1)).mean() + + return { + "word_ins": { + "out": word_ins_out, + "tgt": word_ins_tgt, + "mask": word_ins_mask, + "ls": self.args.label_smoothing, + "nll_loss": True, + "factor": self.args.word_ins_loss_factor, + }, + "word_crf": {"loss": crf_nll}, + "length": { + "out": length_out, + "tgt": length_tgt, + "factor": self.decoder.length_loss_factor, + }, + } + + def forward_decoder(self, decoder_out, encoder_out, decoding_format=None, **kwargs): + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + history = decoder_out.history + + # execute the decoder and get emission scores + output_masks = output_tokens.ne(self.pad) + word_ins_out = self.decoder( + normalize=False, prev_output_tokens=output_tokens, encoder_out=encoder_out + ) + + # run viterbi decoding through CRF + _scores, _tokens = self.crf_layer.forward_decoder(word_ins_out, output_masks) + output_tokens.masked_scatter_(output_masks, _tokens[output_masks]) + output_scores.masked_scatter_(output_masks, _scores[output_masks]) + if history is not None: + history.append(output_tokens.clone()) + + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=None, + history=history, + ) + + +@register_model_architecture("nacrf_transformer", "nacrf_transformer") +def nacrf_base_architecture(args): + args.crf_lowrank_approx = getattr(args, "crf_lowrank_approx", 32) + args.crf_beam_approx = getattr(args, "crf_beam_approx", 64) + args.word_ins_loss_factor = getattr(args, "word_ins_loss_factor", 0.5) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + base_architecture(args) diff --git a/fairseq/fairseq/models/nat/nonautoregressive_ensembles.py b/fairseq/fairseq/models/nat/nonautoregressive_ensembles.py new file mode 100644 index 0000000000000000000000000000000000000000..705a04fb49658c91114a26efd411b4653c65b943 --- /dev/null +++ b/fairseq/fairseq/models/nat/nonautoregressive_ensembles.py @@ -0,0 +1,253 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.nn.functional as F +from fairseq.models.nat import ( + _apply_del_words, + _apply_ins_masks, + _apply_ins_words, + _fill, + _skip, + _skip_encoder_out, +) + + +class _EnsembleModelEncoder(object): + def __init__(self, models): + self.models = models + + def reorder_encoder_out(self, encoder_outs, new_order): + encoder_outs = [ + model.encoder.reorder_encoder_out(encoder_out, new_order) + for model, encoder_out in zip(self.models, encoder_outs) + ] + return encoder_outs + + +class BasicEnsembleModel(torch.nn.Module): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__() + self.models = torch.nn.ModuleList(models) + self.bos = self.models[0].decoder.dictionary.bos() + self.eos = self.models[0].decoder.dictionary.eos() + self.pad = self.models[0].decoder.dictionary.pad() + self.unk = self.models[0].decoder.dictionary.unk() + self.encoder = _EnsembleModelEncoder(self.models) + + def has_encoder(self): + return hasattr(self.models[0], "encoder") + + def max_decoder_positions(self): + return min(m.max_decoder_positions() for m in self.models) + + @torch.no_grad() + def forward_encoder(self, encoder_input): + if not self.has_encoder(): + return None + return [model.forward_encoder(encoder_input) for model in self.models] + + @torch.no_grad() + def forward_decoder(self, *inputs): + raise NotImplementedError + + def initialize_output_tokens(self, *inputs): + raise NotImplementedError + + +class EnsembleLevT(BasicEnsembleModel): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__(models) + + @torch.no_grad() + def forward_decoder( + self, decoder_out, encoder_outs, eos_penalty=0.0, max_ratio=None, **kwargs + ): + # LevT ensembling + # A pipeline of three steps: deletion, placeholder, and word insertion. + # We need to average scores in each step in a pipeline way because of dependence. + # deletion + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + attn = decoder_out.attn + + bsz = output_tokens.size(0) + if max_ratio is None: + max_lens = output_tokens.new().fill_(255) + else: + if not encoder_outs[0]["encoder_padding_mask"]: + src_lens = ( + encoder_outs[0]["encoder_out"][0].new(bsz) + .fill_(encoder_outs[0]["encoder_out"][0].size(1)) + ) + else: + src_lens = (~encoder_outs[0]["encoder_padding_mask"][0]).sum(1) + max_lens = (src_lens * max_ratio).clamp(min=10).long() + + # delete words + # do not delete tokens if it is <s> </s> + can_del_word = output_tokens.ne(self.pad).sum(1) > 2 + if can_del_word.sum() != 0: # we cannot delete, skip + output_tokens, output_scores, attn = self.forward_word_del( + encoder_outs, + output_tokens, + output_scores, + attn, + can_del_word, + ) + + # insert placeholders + can_ins_mask = output_tokens.ne(self.pad).sum(1) < max_lens + if can_ins_mask.sum() != 0: + output_tokens, output_scores = self.forward_mask_ins( + encoder_outs, + output_tokens, + output_scores, + can_ins_mask, + eos_penalty, + max_lens, + ) + + # insert words + can_ins_word = output_tokens.eq(self.unk).sum(1) > 0 + if can_ins_word.sum() != 0: + output_tokens, output_scores, attn = self.forward_word_ins( + encoder_outs, + output_tokens, + output_scores, + attn, + can_ins_word, + ) + + # delete some unnecessary paddings + cut_off = output_tokens.ne(self.pad).sum(1).max() + output_tokens = output_tokens[:, :cut_off] + output_scores = output_scores[:, :cut_off] + attn = None if attn is None else attn[:, :cut_off, :] + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=attn, + history=None, + ) + + def forward_word_del( + self, encoder_outs, output_tokens, output_scores, attn, can_del_word + ): + word_del_score_avg = [] + word_del_attn_avg = [] + for model, encoder_out in zip(self.models, encoder_outs): + word_del_out, word_del_attn = model.decoder.forward_word_del( + _skip(output_tokens, can_del_word), + _skip_encoder_out(model.encoder, encoder_out, can_del_word), + ) + word_del_score = F.log_softmax(word_del_out, 2) + word_del_score_avg.append(word_del_score) + word_del_attn_avg.append(word_del_attn) + word_del_score_avg = torch.logsumexp( + torch.stack(word_del_score_avg, dim=0), dim=0 + ) - math.log(len(self.models)) + word_del_pred = word_del_score_avg.max(-1)[1].bool() + if word_del_attn_avg[0] is not None: + word_del_attn_avg = torch.stack(word_del_attn_avg, dim=0) / len(self.models) + else: + word_del_attn_avg = None + + _tokens, _scores, _attn = _apply_del_words( + output_tokens[can_del_word], + output_scores[can_del_word], + word_del_attn_avg, + word_del_pred, + self.pad, + self.bos, + self.eos, + ) + output_tokens = _fill(output_tokens, can_del_word, _tokens, self.pad) + output_scores = _fill(output_scores, can_del_word, _scores, 0) + attn = _fill(attn, can_del_word, _attn, 0.0) + return output_tokens, output_scores, attn + + def forward_mask_ins( + self, + encoder_outs, + output_tokens, + output_scores, + can_ins_mask, + eos_penalty, + max_lens, + ): + mask_ins_score_avg = [] + for model, encoder_out in zip(self.models, encoder_outs): + mask_ins_out, _ = model.decoder.forward_mask_ins( + _skip(output_tokens, can_ins_mask), + _skip_encoder_out(model.encoder, encoder_out, can_ins_mask), + ) + mask_ins_score = F.log_softmax(mask_ins_out, 2) + if eos_penalty > 0.0: + mask_ins_score[:, :, 0] -= eos_penalty + mask_ins_score_avg.append(mask_ins_score) + mask_ins_score_avg = torch.logsumexp( + torch.stack(mask_ins_score_avg, dim=0), dim=0 + ) - math.log(len(self.models)) + mask_ins_pred = mask_ins_score_avg.max(-1)[1] + mask_ins_pred = torch.min( + mask_ins_pred, max_lens[can_ins_mask, None].expand_as(mask_ins_pred) + ) + _tokens, _scores = _apply_ins_masks( + output_tokens[can_ins_mask], + output_scores[can_ins_mask], + mask_ins_pred, + self.pad, + self.unk, + self.eos, + ) + output_tokens = _fill(output_tokens, can_ins_mask, _tokens, self.pad) + output_scores = _fill(output_scores, can_ins_mask, _scores, 0) + return output_tokens, output_scores + + def forward_word_ins( + self, encoder_outs, output_tokens, output_scores, attn, can_ins_word + ): + word_ins_score_avg = [] + word_ins_attn_avg = [] + for model, encoder_out in zip(self.models, encoder_outs): + word_ins_out, word_ins_attn = model.decoder.forward_word_ins( + _skip(output_tokens, can_ins_word), + _skip_encoder_out(model.encoder, encoder_out, can_ins_word), + ) + word_ins_score = F.log_softmax(word_ins_out, 2) + word_ins_score_avg.append(word_ins_score) + word_ins_attn_avg.append(word_ins_attn) + word_ins_score_avg = torch.logsumexp( + torch.stack(word_ins_score_avg, dim=0), dim=0 + ) - math.log(len(self.models)) + if word_ins_attn_avg[0] is not None: + word_ins_attn_avg = torch.stack(word_ins_attn_avg, dim=0) / len(self.models) + else: + word_ins_attn_avg = None + word_ins_score_max, word_ins_pred = word_ins_score_avg.max(-1) + + _tokens, _scores = _apply_ins_words( + output_tokens[can_ins_word], + output_scores[can_ins_word], + word_ins_pred, + word_ins_score_max, + self.unk, + ) + + output_tokens = _fill(output_tokens, can_ins_word, _tokens, self.pad) + output_scores = _fill(output_scores, can_ins_word, _scores, 0) + attn = _fill(attn, can_ins_word, word_ins_attn, 0.0) + return output_tokens, output_scores, attn + + def initialize_output_tokens(self, encoder_outs, src_tokens): + # LevT doesn't do length prediction. + return self.models[0].initialize_output_tokens(encoder_outs[0], src_tokens) diff --git a/fairseq/fairseq/models/nat/nonautoregressive_transformer.py b/fairseq/fairseq/models/nat/nonautoregressive_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..d114202d25fbd1dca66c7abebb0b0a8bffbe094d --- /dev/null +++ b/fairseq/fairseq/models/nat/nonautoregressive_transformer.py @@ -0,0 +1,456 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.iterative_refinement_generator import DecoderOut +from fairseq.models import register_model, register_model_architecture +from fairseq.models.nat import FairseqNATDecoder, FairseqNATModel, ensemble_decoder +from fairseq.models.transformer import Embedding +from fairseq.modules.transformer_sentence_encoder import init_bert_params + + +def _mean_pooling(enc_feats, src_masks): + # enc_feats: T x B x C + # src_masks: B x T or None + if src_masks is None: + enc_feats = enc_feats.mean(0) + else: + src_masks = (~src_masks).transpose(0, 1).type_as(enc_feats) + enc_feats = ( + (enc_feats / src_masks.sum(0)[None, :, None]) * src_masks[:, :, None] + ).sum(0) + return enc_feats + + +def _argmax(x, dim): + return (x == x.max(dim, keepdim=True)[0]).type_as(x) + + +def _uniform_assignment(src_lens, trg_lens): + max_trg_len = trg_lens.max() + steps = (src_lens.float() - 1) / (trg_lens.float() - 1) # step-size + # max_trg_len + index_t = utils.new_arange(trg_lens, max_trg_len).float() + index_t = steps[:, None] * index_t[None, :] # batch_size X max_trg_len + index_t = torch.round(index_t).long().detach() + return index_t + + +@register_model("nonautoregressive_transformer") +class NATransformerModel(FairseqNATModel): + @property + def allow_length_beam(self): + return True + + @staticmethod + def add_args(parser): + FairseqNATModel.add_args(parser) + + # length prediction + parser.add_argument( + "--src-embedding-copy", + action="store_true", + help="copy encoder word embeddings as the initial input of the decoder", + ) + parser.add_argument( + "--pred-length-offset", + action="store_true", + help="predicting the length difference between the target and source sentences", + ) + parser.add_argument( + "--sg-length-pred", + action="store_true", + help="stop the gradients back-propagated from the length predictor", + ) + parser.add_argument( + "--length-loss-factor", + type=float, + help="weights on the length prediction loss", + ) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + decoder = NATransformerDecoder(args, tgt_dict, embed_tokens) + if getattr(args, "apply_bert_init", False): + decoder.apply(init_bert_params) + return decoder + + def forward( + self, src_tokens, src_lengths, prev_output_tokens, tgt_tokens, **kwargs + ): + # encoding + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + # length prediction + length_out = self.decoder.forward_length( + normalize=False, encoder_out=encoder_out + ) + length_tgt = self.decoder.forward_length_prediction( + length_out, encoder_out, tgt_tokens + ) + + # decoding + word_ins_out = self.decoder( + normalize=False, + prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out, + ) + + return { + "word_ins": { + "out": word_ins_out, + "tgt": tgt_tokens, + "mask": tgt_tokens.ne(self.pad), + "ls": self.args.label_smoothing, + "nll_loss": True, + }, + "length": { + "out": length_out, + "tgt": length_tgt, + "factor": self.decoder.length_loss_factor, + }, + } + + def forward_decoder(self, decoder_out, encoder_out, decoding_format=None, **kwargs): + step = decoder_out.step + output_tokens = decoder_out.output_tokens + output_scores = decoder_out.output_scores + history = decoder_out.history + + # execute the decoder + output_masks = output_tokens.ne(self.pad) + _scores, _tokens = self.decoder( + normalize=True, + prev_output_tokens=output_tokens, + encoder_out=encoder_out, + step=step, + ).max(-1) + + output_tokens.masked_scatter_(output_masks, _tokens[output_masks]) + output_scores.masked_scatter_(output_masks, _scores[output_masks]) + if history is not None: + history.append(output_tokens.clone()) + + return decoder_out._replace( + output_tokens=output_tokens, + output_scores=output_scores, + attn=None, + history=history, + ) + + def initialize_output_tokens(self, encoder_out, src_tokens): + # length prediction + length_tgt = self.decoder.forward_length_prediction( + self.decoder.forward_length(normalize=True, encoder_out=encoder_out), + encoder_out=encoder_out, + ) + + max_length = length_tgt.clamp_(min=2).max() + idx_length = utils.new_arange(src_tokens, max_length) + + initial_output_tokens = src_tokens.new_zeros( + src_tokens.size(0), max_length + ).fill_(self.pad) + initial_output_tokens.masked_fill_( + idx_length[None, :] < length_tgt[:, None], self.unk + ) + initial_output_tokens[:, 0] = self.bos + initial_output_tokens.scatter_(1, length_tgt[:, None] - 1, self.eos) + + initial_output_scores = initial_output_tokens.new_zeros( + *initial_output_tokens.size() + ).type_as(encoder_out["encoder_out"][0]) + + return DecoderOut( + output_tokens=initial_output_tokens, + output_scores=initial_output_scores, + attn=None, + step=0, + max_step=0, + history=None, + ) + + def regenerate_length_beam(self, decoder_out, beam_size): + output_tokens = decoder_out.output_tokens + length_tgt = output_tokens.ne(self.pad).sum(1) + length_tgt = ( + length_tgt[:, None] + + utils.new_arange(length_tgt, 1, beam_size) + - beam_size // 2 + ) + length_tgt = length_tgt.view(-1).clamp_(min=2) + max_length = length_tgt.max() + idx_length = utils.new_arange(length_tgt, max_length) + + initial_output_tokens = output_tokens.new_zeros( + length_tgt.size(0), max_length + ).fill_(self.pad) + initial_output_tokens.masked_fill_( + idx_length[None, :] < length_tgt[:, None], self.unk + ) + initial_output_tokens[:, 0] = self.bos + initial_output_tokens.scatter_(1, length_tgt[:, None] - 1, self.eos) + + initial_output_scores = initial_output_tokens.new_zeros( + *initial_output_tokens.size() + ).type_as(decoder_out.output_scores) + + return decoder_out._replace( + output_tokens=initial_output_tokens, output_scores=initial_output_scores + ) + + +class NATransformerDecoder(FairseqNATDecoder): + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + super().__init__( + args, dictionary, embed_tokens, no_encoder_attn=no_encoder_attn + ) + self.dictionary = dictionary + self.bos = dictionary.bos() + self.unk = dictionary.unk() + self.eos = dictionary.eos() + + self.encoder_embed_dim = args.encoder_embed_dim + self.sg_length_pred = getattr(args, "sg_length_pred", False) + self.pred_length_offset = getattr(args, "pred_length_offset", False) + self.length_loss_factor = getattr(args, "length_loss_factor", 0.1) + self.src_embedding_copy = getattr(args, "src_embedding_copy", False) + self.embed_length = Embedding(256, self.encoder_embed_dim, None) + + @ensemble_decoder + def forward(self, normalize, encoder_out, prev_output_tokens, step=0, **unused): + features, _ = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + embedding_copy=(step == 0) & self.src_embedding_copy, + ) + decoder_out = self.output_layer(features) + return F.log_softmax(decoder_out, -1) if normalize else decoder_out + + @ensemble_decoder + def forward_length(self, normalize, encoder_out): + enc_feats = encoder_out["encoder_out"][0] # T x B x C + if len(encoder_out["encoder_padding_mask"]) > 0: + src_masks = encoder_out["encoder_padding_mask"][0] # B x T + else: + src_masks = None + enc_feats = _mean_pooling(enc_feats, src_masks) + if self.sg_length_pred: + enc_feats = enc_feats.detach() + length_out = F.linear(enc_feats, self.embed_length.weight) + return F.log_softmax(length_out, -1) if normalize else length_out + + def extract_features( + self, + prev_output_tokens, + encoder_out=None, + early_exit=None, + embedding_copy=False, + **unused + ): + """ + Similar to *forward* but only return features. + + Inputs: + prev_output_tokens: Tensor(B, T) + encoder_out: a dictionary of hidden states and masks + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + the LevenshteinTransformer decoder has full-attention to all generated tokens + """ + # embedding + if embedding_copy: + src_embd = encoder_out["encoder_embedding"][0] + if len(encoder_out["encoder_padding_mask"]) > 0: + src_mask = encoder_out["encoder_padding_mask"][0] + else: + src_mask = None + src_mask = ( + ~src_mask + if src_mask is not None + else prev_output_tokens.new_ones(*src_embd.size()[:2]).bool() + ) + + x, decoder_padding_mask = self.forward_embedding( + prev_output_tokens, + self.forward_copying_source( + src_embd, src_mask, prev_output_tokens.ne(self.padding_idx) + ), + ) + + else: + + x, decoder_padding_mask = self.forward_embedding(prev_output_tokens) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + attn = None + inner_states = [x] + + # decoder layers + for i, layer in enumerate(self.layers): + + # early exit from the decoder. + if (early_exit is not None) and (i >= early_exit): + break + + x, attn, _ = layer( + x, + encoder_out["encoder_out"][0] + if (encoder_out is not None and len(encoder_out["encoder_out"]) > 0) + else None, + encoder_out["encoder_padding_mask"][0] + if ( + encoder_out is not None + and len(encoder_out["encoder_padding_mask"]) > 0 + ) + else None, + self_attn_mask=None, + self_attn_padding_mask=decoder_padding_mask, + ) + inner_states.append(x) + + if self.layer_norm: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": attn, "inner_states": inner_states} + + def forward_embedding(self, prev_output_tokens, states=None): + # embed positions + positions = ( + self.embed_positions(prev_output_tokens) + if self.embed_positions is not None + else None + ) + + # embed tokens and positions + if states is None: + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + if self.project_in_dim is not None: + x = self.project_in_dim(x) + else: + x = states + + if positions is not None: + x += positions + x = self.dropout_module(x) + decoder_padding_mask = prev_output_tokens.eq(self.padding_idx) + return x, decoder_padding_mask + + def forward_copying_source(self, src_embeds, src_masks, tgt_masks): + length_sources = src_masks.sum(1) + length_targets = tgt_masks.sum(1) + mapped_inputs = _uniform_assignment(length_sources, length_targets).masked_fill( + ~tgt_masks, 0 + ) + copied_embedding = torch.gather( + src_embeds, + 1, + mapped_inputs.unsqueeze(-1).expand( + *mapped_inputs.size(), src_embeds.size(-1) + ), + ) + return copied_embedding + + def forward_length_prediction(self, length_out, encoder_out, tgt_tokens=None): + enc_feats = encoder_out["encoder_out"][0] # T x B x C + if len(encoder_out["encoder_padding_mask"]) > 0: + src_masks = encoder_out["encoder_padding_mask"][0] # B x T + else: + src_masks = None + if self.pred_length_offset: + if src_masks is None: + src_lengs = enc_feats.new_ones(enc_feats.size(1)).fill_( + enc_feats.size(0) + ) + else: + src_lengs = (~src_masks).transpose(0, 1).type_as(enc_feats).sum(0) + src_lengs = src_lengs.long() + + if tgt_tokens is not None: + # obtain the length target + tgt_lengs = tgt_tokens.ne(self.padding_idx).sum(1).long() + if self.pred_length_offset: + length_tgt = tgt_lengs - src_lengs + 128 + else: + length_tgt = tgt_lengs + length_tgt = length_tgt.clamp(min=0, max=255) + + else: + # predict the length target (greedy for now) + # TODO: implementing length-beam + pred_lengs = length_out.max(-1)[1] + if self.pred_length_offset: + length_tgt = pred_lengs - 128 + src_lengs + else: + length_tgt = pred_lengs + + return length_tgt + + +@register_model_architecture( + "nonautoregressive_transformer", "nonautoregressive_transformer" +) +def base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.apply_bert_init = getattr(args, "apply_bert_init", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + # --- special arguments --- + args.sg_length_pred = getattr(args, "sg_length_pred", False) + args.pred_length_offset = getattr(args, "pred_length_offset", False) + args.length_loss_factor = getattr(args, "length_loss_factor", 0.1) + args.src_embedding_copy = getattr(args, "src_embedding_copy", False) + + +@register_model_architecture( + "nonautoregressive_transformer", "nonautoregressive_transformer_wmt_en_de" +) +def nonautoregressive_transformer_wmt_en_de(args): + base_architecture(args) diff --git a/fairseq/fairseq/models/roberta/__init__.py b/fairseq/fairseq/models/roberta/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4cd723ae96aec8e3182773483f123109d23b620e --- /dev/null +++ b/fairseq/fairseq/models/roberta/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .hub_interface import * # noqa +from .model import * # noqa +from .enc_dec import * # noqa +from .model_camembert import * # noqa +from .model_gottbert import * # noqa +from .model_xlmr import * # noqa diff --git a/fairseq/fairseq/models/roberta/alignment_utils.py b/fairseq/fairseq/models/roberta/alignment_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ccc7f74cb94d5b8baa2d4e9dfd44f653d47ee43e --- /dev/null +++ b/fairseq/fairseq/models/roberta/alignment_utils.py @@ -0,0 +1,118 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import Counter +from typing import List + +import torch + + +def align_bpe_to_words(roberta, bpe_tokens: torch.LongTensor, other_tokens: List[str]): + """ + Helper to align GPT-2 BPE to other tokenization formats (e.g., spaCy). + + Args: + roberta (RobertaHubInterface): RoBERTa instance + bpe_tokens (torch.LongTensor): GPT-2 BPE tokens of shape `(T_bpe)` + other_tokens (List[str]): other tokens of shape `(T_words)` + + Returns: + List[str]: mapping from *other_tokens* to corresponding *bpe_tokens*. + """ + assert bpe_tokens.dim() == 1 + assert bpe_tokens[0] == 0 + + def clean(text): + return text.strip() + + # remove whitespaces to simplify alignment + bpe_tokens = [roberta.task.source_dictionary.string([x]) for x in bpe_tokens] + bpe_tokens = [ + clean(roberta.bpe.decode(x) if x not in {"<s>", ""} else x) for x in bpe_tokens + ] + other_tokens = [clean(str(o)) for o in other_tokens] + + # strip leading <s> + bpe_tokens = bpe_tokens[1:] + assert "".join(bpe_tokens) == "".join(other_tokens) + + # create alignment from every word to a list of BPE tokens + alignment = [] + bpe_toks = filter(lambda item: item[1] != "", enumerate(bpe_tokens, start=1)) + j, bpe_tok = next(bpe_toks) + for other_tok in other_tokens: + bpe_indices = [] + while True: + if other_tok.startswith(bpe_tok): + bpe_indices.append(j) + other_tok = other_tok[len(bpe_tok) :] + try: + j, bpe_tok = next(bpe_toks) + except StopIteration: + j, bpe_tok = None, None + elif bpe_tok.startswith(other_tok): + # other_tok spans multiple BPE tokens + bpe_indices.append(j) + bpe_tok = bpe_tok[len(other_tok) :] + other_tok = "" + else: + raise Exception('Cannot align "{}" and "{}"'.format(other_tok, bpe_tok)) + if other_tok == "": + break + assert len(bpe_indices) > 0 + alignment.append(bpe_indices) + assert len(alignment) == len(other_tokens) + + return alignment + + +def align_features_to_words(roberta, features, alignment): + """ + Align given features to words. + + Args: + roberta (RobertaHubInterface): RoBERTa instance + features (torch.Tensor): features to align of shape `(T_bpe x C)` + alignment: alignment between BPE tokens and words returned by + func:`align_bpe_to_words`. + """ + assert features.dim() == 2 + + bpe_counts = Counter(j for bpe_indices in alignment for j in bpe_indices) + assert bpe_counts[0] == 0 # <s> shouldn't be aligned + denom = features.new([bpe_counts.get(j, 1) for j in range(len(features))]) + weighted_features = features / denom.unsqueeze(-1) + + output = [weighted_features[0]] + largest_j = -1 + for bpe_indices in alignment: + output.append(weighted_features[bpe_indices].sum(dim=0)) + largest_j = max(largest_j, *bpe_indices) + for j in range(largest_j + 1, len(features)): + output.append(weighted_features[j]) + output = torch.stack(output) + assert torch.all(torch.abs(output.sum(dim=0) - features.sum(dim=0)) < 1e-4) + return output + + +def spacy_nlp(): + if getattr(spacy_nlp, "_nlp", None) is None: + try: + from spacy.lang.en import English + + spacy_nlp._nlp = English() + except ImportError: + raise ImportError("Please install spacy with: pip install spacy") + return spacy_nlp._nlp + + +def spacy_tokenizer(): + if getattr(spacy_tokenizer, "_tokenizer", None) is None: + try: + nlp = spacy_nlp() + spacy_tokenizer._tokenizer = nlp.Defaults.create_tokenizer(nlp) + except ImportError: + raise ImportError("Please install spacy with: pip install spacy") + return spacy_tokenizer._tokenizer diff --git a/fairseq/fairseq/models/roberta/enc_dec.py b/fairseq/fairseq/models/roberta/enc_dec.py new file mode 100644 index 0000000000000000000000000000000000000000..e538dee0aa5984b1a3d02ce81117d2046c030593 --- /dev/null +++ b/fairseq/fairseq/models/roberta/enc_dec.py @@ -0,0 +1,192 @@ +import argparse +import logging + +import torch.nn as nn +import fairseq.checkpoint_utils +from fairseq.models import ( + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import TransformerDecoder +from fairseq.models.roberta import model as roberta + +logger = logging.getLogger(__name__) + + +@register_model("roberta_enc_dec") +class RobertaEncDecModel(FairseqEncoderDecoderModel): + @staticmethod + def add_args(parser): + parser.add_argument( + "--pretrained-mlm-checkpoint", + default=None, + type=str, + metavar="PRETRAINED", + help="path to pretrained mlm checkpoint", + ) + parser.add_argument( + "--pretrained-decoder", action="store_true", help="reload decoder" + ) + parser.add_argument( + "--hack-layernorm-embedding", + action="store_true", + help="hack to reload old models trained with encoder-normalize-before=False (no equivalent to encoder-normalize-before=False and layernorm_embedding=False", + ) + parser.add_argument( + "--share-decoder-input-output-embed", + action="store_true", + help="share decoder input and output embeddings", + ) + parser.add_argument( + "--share-all-embeddings", + action="store_true", + help="share encoder, decoder and output embeddings" + " (requires shared dictionary and embed dim)", + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present + base_enc_dec_architecture(args) + if args.pretrained_mlm_checkpoint: + arg_overrides = None + if args.hack_layernorm_embedding: + arg_overrides = {"layernorm_embedding": False} + loaded = fairseq.checkpoint_utils.load_model_ensemble_and_task( + [args.pretrained_mlm_checkpoint], arg_overrides=arg_overrides + ) + ([roberta_enc], _cfg, _task) = loaded + else: + # Do we need to edit untie_weights here ? + share_in_out = ( + args.share_decoder_input_output_embed or args.share_all_embeddings + ) + args.untie_weights_roberta = not share_in_out + if args.hack_layernorm_embedding: + args.layernorm_embedding = False + args.encoder_normalize_before = False + roberta_enc = roberta.RobertaModel.build_model(args, task) + + return cls.from_roberta(roberta_enc, args, task.source_dictionary) + + @staticmethod + def from_roberta(roberta_enc: roberta.RobertaModel, args, dictionary): + encoder = roberta_enc.encoder.sentence_encoder + vocab_size, embed_dim = encoder.embed_tokens.weight.shape + + if args.share_all_embeddings: + lm_head = roberta_enc.encoder.lm_head + assert encoder.embed_tokens.weight is lm_head.weight, ( + "Can't use --share-all-embeddings with a model " + "that was pretraiend with --untie-weights-roberta_enc" + ) + else: + lm_head = roberta.RobertaLMHead( + embed_dim, vocab_size, roberta_enc.args.activation_fn + ) + + dec_embs = nn.Embedding(vocab_size, embed_dim, dictionary.pad()) + if args.share_all_embeddings or args.share_decoder_input_output_embed: + # Note: I wasn't able to use Embedding _weight parameter to achive this sharing. + dec_embs.weight = lm_head.weight + + decoder = TransformerDecoder( + RobertaEncDecModel.read_args_from_roberta(roberta_enc.args), + dictionary, + dec_embs, + no_encoder_attn=False, + output_projection=lm_head, + ) + if getattr(args, "pretrained_decoder", False): + decoder_dict = encoder.state_dict() + + # TODO: hide setting "encoder_attn" layers behind a flag. + for k, w in list(decoder_dict.items()): + if ".self_attn" in k: + k_enc_attn = k.replace(".self_attn", ".encoder_attn") + decoder_dict[k_enc_attn] = w.detach().clone() + + for k, w in lm_head.state_dict().items(): + decoder_dict["output_projection." + k] = w + + missing_keys, unexpected_keys = decoder.load_state_dict( + decoder_dict, strict=False + ) + # missing_keys = [m for m in missing_keys if ".encoder_attn" not in m] + assert not missing_keys and not unexpected_keys, ( + "Failed to load state dict. " + f"Missing keys: {missing_keys}. " + f"Unexpected keys: {unexpected_keys}." + ) + + if args.share_all_embeddings: + assert decoder.output_projection.weight is decoder.embed_tokens.weight + assert encoder.embed_tokens.weight is decoder.embed_tokens.weight + elif args.share_decoder_input_output_embed: + assert decoder.output_projection.weight is decoder.embed_tokens.weight + assert encoder.embed_tokens.weight is not decoder.embed_tokens.weight + else: + assert decoder.output_projection.weight is not decoder.embed_tokens.weight + assert encoder.embed_tokens.weight is not decoder.embed_tokens.weight + + return RobertaEncDecModel(encoder, decoder) + + @staticmethod + def read_args_from_roberta(roberta_args: argparse.Namespace): + # TODO: this would become easier if encoder/decoder where using a similar + # TransformerConfig object + args = argparse.Namespace(**vars(roberta_args)) + attr_map = [ + ("encoder_attention_heads", "decoder_attention_heads"), + ("encoder_embed_dim", "decoder_embed_dim"), + ("encoder_embed_dim", "decoder_output_dim"), + ("encoder_normalize_before", "decoder_normalize_before"), + ("encoder_layers_to_keep", "decoder_layers_to_keep"), + ("encoder_ffn_embed_dim", "decoder_ffn_embed_dim"), + ("encoder_layerdrop", "decoder_layerdrop"), + ("encoder_layers", "decoder_layers"), + ("encoder_learned_pos", "decoder_learned_pos"), + # should this be set from here ? + ("max_positions", "max_target_positions"), + ] + for k1, k2 in attr_map: + setattr(args, k2, getattr(roberta_args, k1)) + + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = not roberta_args.untie_weights_roberta + return args + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + super().upgrade_state_dict_named(state_dict, name) + old_keys = list(state_dict.keys()) + + # rename decoder -> encoder before upgrading children modules + for k in old_keys: + if k.startswith(prefix + "encoder.lm_head"): + state_dict.pop(k) + continue + new_k = k + new_k = new_k.replace(".sentence_encoder.", ".") + new_k = new_k.replace("decoder.lm_head.", "decoder.output_projection.") + if k == new_k: + continue + # print(k, "->", new_k) + state_dict[new_k] = state_dict.pop(k) + + +@register_model_architecture("roberta_enc_dec", "roberta_enc_dec") +def base_enc_dec_architecture(args): + args.hack_layernorm_embedding = getattr(args, "hack_layernorm_embedding", False) + args.pretrained_mlm_checkpoint = getattr(args, "pretrained_mlm_checkpoint", None) + args.pretrained_decoder = getattr(args, "pretrained_decoder", None) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + + roberta.base_architecture(args) diff --git a/fairseq/fairseq/models/roberta/hub_interface.py b/fairseq/fairseq/models/roberta/hub_interface.py new file mode 100644 index 0000000000000000000000000000000000000000..ba298d63ba5da2a5b2f1a44d0384a6b249277ef4 --- /dev/null +++ b/fairseq/fairseq/models/roberta/hub_interface.py @@ -0,0 +1,235 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.data import encoders + + +class RobertaHubInterface(nn.Module): + """A simple PyTorch Hub interface to RoBERTa. + + Usage: https://github.com/pytorch/fairseq/tree/main/examples/roberta + """ + + def __init__(self, cfg, task, model): + super().__init__() + self.cfg = cfg + self.task = task + self.model = model + + self.bpe = encoders.build_bpe(cfg.bpe) + + # this is useful for determining the device + self.register_buffer("_float_tensor", torch.tensor([0], dtype=torch.float)) + + @property + def device(self): + return self._float_tensor.device + + def encode( + self, sentence: str, *addl_sentences, no_separator=False + ) -> torch.LongTensor: + """ + BPE-encode a sentence (or multiple sentences). + + Every sequence begins with a beginning-of-sentence (`<s>`) symbol. + Every sentence ends with an end-of-sentence (`</s>`) and we use an + extra end-of-sentence (`</s>`) as a separator. + + Example (single sentence): `<s> a b c </s>` + Example (sentence pair): `<s> d e f </s> </s> 1 2 3 </s>` + + The BPE encoding follows GPT-2. One subtle detail is that the GPT-2 BPE + requires leading spaces. For example:: + + >>> roberta.encode('Hello world').tolist() + [0, 31414, 232, 2] + >>> roberta.encode(' world').tolist() + [0, 232, 2] + >>> roberta.encode('world').tolist() + [0, 8331, 2] + """ + bpe_sentence = "<s> " + self.bpe.encode(sentence) + " </s>" + for s in addl_sentences: + bpe_sentence += " </s>" if not no_separator else "" + bpe_sentence += " " + self.bpe.encode(s) + " </s>" + tokens = self.task.source_dictionary.encode_line( + bpe_sentence, append_eos=False, add_if_not_exist=False + ) + return tokens.long() + + def decode(self, tokens: torch.LongTensor): + assert tokens.dim() == 1 + tokens = tokens.numpy() + if tokens[0] == self.task.source_dictionary.bos(): + tokens = tokens[1:] # remove <s> + eos_mask = tokens == self.task.source_dictionary.eos() + doc_mask = eos_mask[1:] & eos_mask[:-1] + sentences = np.split(tokens, doc_mask.nonzero()[0] + 1) + sentences = [ + self.bpe.decode(self.task.source_dictionary.string(s)) for s in sentences + ] + if len(sentences) == 1: + return sentences[0] + return sentences + + def extract_features( + self, tokens: torch.LongTensor, return_all_hiddens: bool = False + ) -> torch.Tensor: + if tokens.dim() == 1: + tokens = tokens.unsqueeze(0) + if tokens.size(-1) > self.model.max_positions(): + raise ValueError( + "tokens exceeds maximum length: {} > {}".format( + tokens.size(-1), self.model.max_positions() + ) + ) + features, extra = self.model( + tokens.to(device=self.device), + features_only=True, + return_all_hiddens=return_all_hiddens, + ) + if return_all_hiddens: + # convert from T x B x C -> B x T x C + inner_states = extra["inner_states"] + return [inner_state.transpose(0, 1) for inner_state in inner_states] + else: + return features # just the last layer's features + + def register_classification_head( + self, name: str, num_classes: int = None, embedding_size: int = None, **kwargs + ): + self.model.register_classification_head( + name, num_classes=num_classes, embedding_size=embedding_size, **kwargs + ) + + def predict(self, head: str, tokens: torch.LongTensor, return_logits: bool = False): + features = self.extract_features(tokens.to(device=self.device)) + logits = self.model.classification_heads[head](features) + if return_logits: + return logits + return F.log_softmax(logits, dim=-1) + + def extract_features_aligned_to_words( + self, sentence: str, return_all_hiddens: bool = False + ) -> torch.Tensor: + """Extract RoBERTa features, aligned to spaCy's word-level tokenizer.""" + from fairseq.models.roberta import alignment_utils + from spacy.tokens import Doc + + nlp = alignment_utils.spacy_nlp() + tokenizer = alignment_utils.spacy_tokenizer() + + # tokenize both with GPT-2 BPE and spaCy + bpe_toks = self.encode(sentence) + spacy_toks = tokenizer(sentence) + spacy_toks_ws = [t.text_with_ws for t in tokenizer(sentence)] + alignment = alignment_utils.align_bpe_to_words(self, bpe_toks, spacy_toks_ws) + + # extract features and align them + features = self.extract_features( + bpe_toks, return_all_hiddens=return_all_hiddens + ) + features = features.squeeze(0) + aligned_feats = alignment_utils.align_features_to_words( + self, features, alignment + ) + + # wrap in spaCy Doc + doc = Doc( + nlp.vocab, + words=["<s>"] + [x.text for x in spacy_toks] + ["</s>"], + spaces=[True] + + [x.endswith(" ") for x in spacy_toks_ws[:-1]] + + [True, False], + ) + assert len(doc) == aligned_feats.size(0) + doc.user_token_hooks["vector"] = lambda token: aligned_feats[token.i] + return doc + + def fill_mask(self, masked_input: str, topk: int = 5): + masked_token = "<mask>" + assert ( + masked_token in masked_input and masked_input.count(masked_token) == 1 + ), "Please add one {0} token for the input, eg: 'He is a {0} guy'".format( + masked_token + ) + + text_spans = masked_input.split(masked_token) + text_spans_bpe = ( + (" {0} ".format(masked_token)) + .join([self.bpe.encode(text_span.rstrip()) for text_span in text_spans]) + .strip() + ) + tokens = self.task.source_dictionary.encode_line( + "<s> " + text_spans_bpe + " </s>", + append_eos=False, + add_if_not_exist=False, + ) + + masked_index = (tokens == self.task.mask_idx).nonzero(as_tuple=False) + if tokens.dim() == 1: + tokens = tokens.unsqueeze(0) + + with utils.model_eval(self.model): + features, extra = self.model( + tokens.long().to(device=self.device), + features_only=False, + return_all_hiddens=False, + ) + logits = features[0, masked_index, :].squeeze() + prob = logits.softmax(dim=0) + values, index = prob.topk(k=topk, dim=0) + topk_predicted_token_bpe = self.task.source_dictionary.string(index) + + topk_filled_outputs = [] + for index, predicted_token_bpe in enumerate( + topk_predicted_token_bpe.split(" ") + ): + predicted_token = self.bpe.decode(predicted_token_bpe) + # Quick hack to fix https://github.com/pytorch/fairseq/issues/1306 + if predicted_token_bpe.startswith("\u2581"): + predicted_token = " " + predicted_token + if " {0}".format(masked_token) in masked_input: + topk_filled_outputs.append( + ( + masked_input.replace( + " {0}".format(masked_token), predicted_token + ), + values[index].item(), + predicted_token, + ) + ) + else: + topk_filled_outputs.append( + ( + masked_input.replace(masked_token, predicted_token), + values[index].item(), + predicted_token, + ) + ) + return topk_filled_outputs + + def disambiguate_pronoun(self, sentence: str) -> bool: + """ + Usage:: + + >>> disambiguate_pronoun('The _trophy_ would not fit in the brown suitcase because [it] was too big.') + True + + >>> disambiguate_pronoun('The trophy would not fit in the brown suitcase because [it] was too big.') + 'The trophy' + """ + assert hasattr( + self.task, "disambiguate_pronoun" + ), "roberta.disambiguate_pronoun() requires a model trained with the WSC task." + with utils.model_eval(self.model): + return self.task.disambiguate_pronoun( + self.model, sentence, use_cuda=self.device.type == "cuda" + ) diff --git a/fairseq/fairseq/models/roberta/model.py b/fairseq/fairseq/models/roberta/model.py new file mode 100644 index 0000000000000000000000000000000000000000..bb205b910daaecd55effd1e77e77d0b43952624f --- /dev/null +++ b/fairseq/fairseq/models/roberta/model.py @@ -0,0 +1,594 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +RoBERTa: A Robustly Optimized BERT Pretraining Approach. +""" + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import DEFAULT_MIN_PARAMS_TO_WRAP, TransformerEncoder +from fairseq.modules import LayerNorm +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ +from fairseq.modules.transformer_sentence_encoder import init_bert_params +from fairseq.utils import safe_getattr, safe_hasattr + +from .hub_interface import RobertaHubInterface + + +logger = logging.getLogger(__name__) + + +@register_model("roberta") +class RobertaModel(FairseqEncoderModel): + @classmethod + def hub_models(cls): + return { + "roberta.base": "http://dl.fbaipublicfiles.com/fairseq/models/roberta.base.tar.gz", + "roberta.large": "http://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz", + "roberta.large.mnli": "http://dl.fbaipublicfiles.com/fairseq/models/roberta.large.mnli.tar.gz", + "roberta.large.wsc": "http://dl.fbaipublicfiles.com/fairseq/models/roberta.large.wsc.tar.gz", + } + + def __init__(self, args, encoder): + super().__init__(encoder) + self.args = args + + # We follow BERT's random weight initialization + self.apply(init_bert_params) + + self.classification_heads = nn.ModuleDict() + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--encoder-layers", type=int, metavar="L", help="num encoder layers" + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="H", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="F", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="A", + help="num encoder attention heads", + ) + parser.add_argument( + "--activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + parser.add_argument( + "--pooler-activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use for pooler layer", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + parser.add_argument( + "--layernorm-embedding", + action="store_true", + help="add layernorm to embedding", + ) + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--activation-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN", + ) + parser.add_argument( + "--pooler-dropout", + type=float, + metavar="D", + help="dropout probability in the masked_lm pooler layers", + ) + parser.add_argument( + "--max-positions", type=int, help="number of positional embeddings to learn" + ) + parser.add_argument( + "--load-checkpoint-heads", + action="store_true", + help="(re-)register and load heads when loading checkpoints", + ) + parser.add_argument( + "--untie-weights-roberta", + action="store_true", + help="Untie weights between embeddings and classifiers in RoBERTa", + ) + # args for "Reducing Transformer Depth on Demand with Structured Dropout" (Fan et al., 2019) + parser.add_argument( + "--encoder-layerdrop", + type=float, + metavar="D", + default=0, + help="LayerDrop probability for encoder", + ) + parser.add_argument( + "--encoder-layers-to-keep", + default=None, + help="which layers to *keep* when pruning as a comma-separated list", + ) + # args for Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020) + parser.add_argument( + "--quant-noise-pq", + type=float, + metavar="D", + default=0, + help="iterative PQ quantization noise at training time", + ) + parser.add_argument( + "--quant-noise-pq-block-size", + type=int, + metavar="D", + default=8, + help="block size of quantization noise at training time", + ) + parser.add_argument( + "--quant-noise-scalar", + type=float, + metavar="D", + default=0, + help="scalar quantization noise and scalar quantization at training time", + ) + # args for "Better Fine-Tuning by Reducing Representational Collapse" (Aghajanyan et al. 2020) + parser.add_argument( + "--spectral-norm-classification-head", + action="store_true", + default=False, + help="Apply spectral normalization on the classification head", + ) + # args for Fully Sharded Data Parallel (FSDP) training + parser.add_argument( + "--min-params-to-wrap", + type=int, + metavar="D", + default=DEFAULT_MIN_PARAMS_TO_WRAP, + help=( + "minimum number of params for a layer to be wrapped with FSDP() when " + "training with --ddp-backend=fully_sharded. Smaller values will " + "improve memory efficiency, but may make torch.distributed " + "communication less efficient due to smaller input sizes. This option " + "is set to 0 (i.e., always wrap) when --checkpoint-activations or " + "--offload-activations are passed." + ) + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + from omegaconf import OmegaConf + + if OmegaConf.is_config(args): + OmegaConf.set_struct(args, False) + + # make sure all arguments are present + base_architecture(args) + + if not safe_hasattr(args, "max_positions"): + if not safe_hasattr(args, "tokens_per_sample"): + args.tokens_per_sample = task.max_positions() + args.max_positions = args.tokens_per_sample + + encoder = RobertaEncoder(args, task.source_dictionary) + + if OmegaConf.is_config(args): + OmegaConf.set_struct(args, True) + + return cls(args, encoder) + + def forward( + self, + src_tokens, + features_only=False, + return_all_hiddens=False, + classification_head_name=None, + **kwargs, + ): + if classification_head_name is not None: + features_only = True + + x, extra = self.encoder(src_tokens, features_only, return_all_hiddens, **kwargs) + + if classification_head_name is not None: + x = self.classification_heads[classification_head_name](x) + return x, extra + + def get_normalized_probs(self, net_output, log_probs, sample=None): + """Get normalized probabilities (or log probs) from a net's output.""" + logits = net_output[0].float() + if log_probs: + return F.log_softmax(logits, dim=-1) + else: + return F.softmax(logits, dim=-1) + + def register_classification_head( + self, name, num_classes=None, inner_dim=None, **kwargs + ): + """Register a classification head.""" + if name in self.classification_heads: + prev_num_classes = self.classification_heads[name].out_proj.out_features + prev_inner_dim = self.classification_heads[name].dense.out_features + if num_classes != prev_num_classes or inner_dim != prev_inner_dim: + logger.warning( + 're-registering head "{}" with num_classes {} (prev: {}) ' + "and inner_dim {} (prev: {})".format( + name, num_classes, prev_num_classes, inner_dim, prev_inner_dim + ) + ) + self.classification_heads[name] = RobertaClassificationHead( + input_dim=self.args.encoder_embed_dim, + inner_dim=inner_dim or self.args.encoder_embed_dim, + num_classes=num_classes, + activation_fn=self.args.pooler_activation_fn, + pooler_dropout=self.args.pooler_dropout, + q_noise=self.args.quant_noise_pq, + qn_block_size=self.args.quant_noise_pq_block_size, + do_spectral_norm=self.args.spectral_norm_classification_head, + ) + + @property + def supported_targets(self): + return {"self"} + + @classmethod + def from_pretrained( + cls, + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + bpe="gpt2", + **kwargs, + ): + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + bpe=bpe, + load_checkpoint_heads=True, + **kwargs, + ) + + logger.info(x["args"]) + return RobertaHubInterface(x["args"], x["task"], x["models"][0]) + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + + # rename decoder -> encoder before upgrading children modules + for k in list(state_dict.keys()): + if k.startswith(prefix + "decoder"): + new_k = prefix + "encoder" + k[len(prefix + "decoder") :] + state_dict[new_k] = state_dict[k] + del state_dict[k] + + # rename emb_layer_norm -> layernorm_embedding + for k in list(state_dict.keys()): + if ".emb_layer_norm." in k: + new_k = k.replace(".emb_layer_norm.", ".layernorm_embedding.") + state_dict[new_k] = state_dict[k] + del state_dict[k] + + # upgrade children modules + super().upgrade_state_dict_named(state_dict, name) + + # Handle new classification heads present in the state dict. + current_head_names = ( + [] + if not hasattr(self, "classification_heads") + else self.classification_heads.keys() + ) + keys_to_delete = [] + for k in state_dict.keys(): + if not k.startswith(prefix + "classification_heads."): + continue + + head_name = k[len(prefix + "classification_heads.") :].split(".")[0] + num_classes = state_dict[ + prefix + "classification_heads." + head_name + ".out_proj.weight" + ].size(0) + inner_dim = state_dict[ + prefix + "classification_heads." + head_name + ".dense.weight" + ].size(0) + + if getattr(self.args, "load_checkpoint_heads", False): + if head_name not in current_head_names: + self.register_classification_head(head_name, num_classes, inner_dim) + else: + if head_name not in current_head_names: + logger.warning( + "deleting classification head ({}) from checkpoint " + "not present in current model: {}".format(head_name, k) + ) + keys_to_delete.append(k) + elif ( + num_classes + != self.classification_heads[head_name].out_proj.out_features + or inner_dim + != self.classification_heads[head_name].dense.out_features + ): + logger.warning( + "deleting classification head ({}) from checkpoint " + "with different dimensions than current model: {}".format( + head_name, k + ) + ) + keys_to_delete.append(k) + for k in keys_to_delete: + del state_dict[k] + + # Copy any newly-added classification heads into the state dict + # with their current weights. + if hasattr(self, "classification_heads"): + cur_state = self.classification_heads.state_dict() + for k, v in cur_state.items(): + if prefix + "classification_heads." + k not in state_dict: + logger.info("Overwriting " + prefix + "classification_heads." + k) + state_dict[prefix + "classification_heads." + k] = v + + +class RobertaLMHead(nn.Module): + """Head for masked language modeling.""" + + def __init__(self, embed_dim, output_dim, activation_fn, weight=None): + super().__init__() + self.dense = nn.Linear(embed_dim, embed_dim) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.layer_norm = LayerNorm(embed_dim) + + if weight is None: + weight = nn.Linear(embed_dim, output_dim, bias=False).weight + self.weight = weight + self.bias = nn.Parameter(torch.zeros(output_dim)) + + def forward(self, features, masked_tokens=None, **kwargs): + # Only project the masked tokens while training, + # saves both memory and computation + if masked_tokens is not None: + features = features[masked_tokens, :] + + x = self.dense(features) + x = self.activation_fn(x) + x = self.layer_norm(x) + # project back to size of vocabulary with bias + x = F.linear(x, self.weight) + self.bias + return x + + +class RobertaClassificationHead(nn.Module): + """Head for sentence-level classification tasks.""" + + def __init__( + self, + input_dim, + inner_dim, + num_classes, + activation_fn, + pooler_dropout, + q_noise=0, + qn_block_size=8, + do_spectral_norm=False, + ): + super().__init__() + self.dense = nn.Linear(input_dim, inner_dim) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = apply_quant_noise_( + nn.Linear(inner_dim, num_classes), q_noise, qn_block_size + ) + if do_spectral_norm: + if q_noise != 0: + raise NotImplementedError( + "Attempting to use Spectral Normalization with Quant Noise. This is not officially supported" + ) + self.out_proj = torch.nn.utils.spectral_norm(self.out_proj) + + def forward(self, features, **kwargs): + x = features[:, 0, :] # take <s> token (equiv. to [CLS]) + x = self.dropout(x) + x = self.dense(x) + x = self.activation_fn(x) + x = self.dropout(x) + x = self.out_proj(x) + return x + + +class RobertaEncoder(FairseqEncoder): + """RoBERTa encoder.""" + + def __init__(self, args, dictionary): + super().__init__(dictionary) + + # set any missing default values + base_architecture(args) + self.args = args + + if args.encoder_layers_to_keep: + args.encoder_layers = len(args.encoder_layers_to_keep.split(",")) + + embed_tokens = self.build_embedding( + len(dictionary), args.encoder_embed_dim, dictionary.pad() + ) + + self.sentence_encoder = self.build_encoder(args, dictionary, embed_tokens) + + self.lm_head = self.build_lm_head( + embed_dim=args.encoder_embed_dim, + output_dim=len(dictionary), + activation_fn=args.activation_fn, + weight=( + self.sentence_encoder.embed_tokens.weight + if not args.untie_weights_roberta + else None + ), + ) + + def build_embedding(self, vocab_size, embedding_dim, padding_idx): + return nn.Embedding(vocab_size, embedding_dim, padding_idx) + + def build_encoder(self, args, dictionary, embed_tokens): + encoder = TransformerEncoder(args, dictionary, embed_tokens) + encoder.apply(init_bert_params) + return encoder + + def build_lm_head(self, embed_dim, output_dim, activation_fn, weight): + return RobertaLMHead(embed_dim, output_dim, activation_fn, weight) + + def forward( + self, + src_tokens, + features_only=False, + return_all_hiddens=False, + masked_tokens=None, + **unused, + ): + """ + Args: + src_tokens (LongTensor): input tokens of shape `(batch, src_len)` + features_only (bool, optional): skip LM head and just return + features. If True, the output will be of shape + `(batch, src_len, embed_dim)`. + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + + Returns: + tuple: + - the LM output of shape `(batch, src_len, vocab)` + - a dictionary of additional data, where 'inner_states' + is a list of hidden states. Note that the hidden + states have shape `(src_len, batch, vocab)`. + """ + x, extra = self.extract_features( + src_tokens, return_all_hiddens=return_all_hiddens + ) + if not features_only: + x = self.output_layer(x, masked_tokens=masked_tokens) + return x, extra + + def extract_features(self, src_tokens, return_all_hiddens=False, **kwargs): + encoder_out = self.sentence_encoder( + src_tokens, + return_all_hiddens=return_all_hiddens, + token_embeddings=kwargs.get("token_embeddings", None), + ) + # T x B x C -> B x T x C + features = encoder_out["encoder_out"][0].transpose(0, 1) + inner_states = encoder_out["encoder_states"] if return_all_hiddens else None + return features, {"inner_states": inner_states} + + def output_layer(self, features, masked_tokens=None, **unused): + return self.lm_head(features, masked_tokens) + + def max_positions(self): + """Maximum output length supported by the encoder.""" + return self.args.max_positions + + +@register_model_architecture("roberta", "roberta") +def base_architecture(args): + args.encoder_layers = safe_getattr(args, "encoder_layers", 12) + args.encoder_embed_dim = safe_getattr(args, "encoder_embed_dim", 768) + args.encoder_ffn_embed_dim = safe_getattr(args, "encoder_ffn_embed_dim", 3072) + args.encoder_attention_heads = safe_getattr(args, "encoder_attention_heads", 12) + + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_dropout = safe_getattr(args, "activation_dropout", 0.0) + args.pooler_dropout = safe_getattr(args, "pooler_dropout", 0.0) + + args.max_source_positions = safe_getattr(args, "max_positions", 512) + args.no_token_positional_embeddings = safe_getattr( + args, "no_token_positional_embeddings", False + ) + + # BERT has a few structural differences compared to the original Transformer + args.encoder_learned_pos = safe_getattr(args, "encoder_learned_pos", True) + args.layernorm_embedding = safe_getattr(args, "layernorm_embedding", True) + args.no_scale_embedding = safe_getattr(args, "no_scale_embedding", True) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + args.encoder_normalize_before = safe_getattr(args, "encoder_normalize_before", False) + args.pooler_activation_fn = safe_getattr(args, "pooler_activation_fn", "tanh") + args.untie_weights_roberta = safe_getattr(args, "untie_weights_roberta", False) + + # Adaptive input config + args.adaptive_input = safe_getattr(args, "adaptive_input", False) + + # LayerDrop config + args.encoder_layerdrop = safe_getattr(args, "encoder_layerdrop", 0.0) + args.encoder_layers_to_keep = safe_getattr(args, "encoder_layers_to_keep", None) + + # Quantization noise config + args.quant_noise_pq = safe_getattr(args, "quant_noise_pq", 0) + args.quant_noise_pq_block_size = safe_getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = safe_getattr(args, "quant_noise_scalar", 0) + + # R4F config + args.spectral_norm_classification_head = safe_getattr( + args, "spectral_norm_classification_head", False + ) + + +@register_model_architecture("roberta", "roberta_prenorm") +def roberta_prenorm_architecture(args): + args.layernorm_embedding = safe_getattr(args, "layernorm_embedding", False) + args.encoder_normalize_before = safe_getattr(args, "encoder_normalize_before", True) + base_architecture(args) + + +@register_model_architecture("roberta", "roberta_base") +def roberta_base_architecture(args): + base_architecture(args) + + +@register_model_architecture("roberta", "roberta_large") +def roberta_large_architecture(args): + args.encoder_layers = safe_getattr(args, "encoder_layers", 24) + args.encoder_embed_dim = safe_getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = safe_getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = safe_getattr(args, "encoder_attention_heads", 16) + base_architecture(args) + + +@register_model_architecture("roberta", "xlm") +def xlm_architecture(args): + args.encoder_layers = safe_getattr(args, "encoder_layers", 16) + args.encoder_embed_dim = safe_getattr(args, "encoder_embed_dim", 1280) + args.encoder_ffn_embed_dim = safe_getattr(args, "encoder_ffn_embed_dim", 1280 * 4) + args.encoder_attention_heads = safe_getattr(args, "encoder_attention_heads", 16) + base_architecture(args) diff --git a/fairseq/fairseq/models/roberta/model_camembert.py b/fairseq/fairseq/models/roberta/model_camembert.py new file mode 100644 index 0000000000000000000000000000000000000000..46447546fafb4a0a887b481022cac07631047c80 --- /dev/null +++ b/fairseq/fairseq/models/roberta/model_camembert.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +CamemBERT: a Tasty French Language Model +""" + +from fairseq.models import register_model + +from .hub_interface import RobertaHubInterface +from .model import RobertaModel + + +@register_model("camembert") +class CamembertModel(RobertaModel): + @classmethod + def hub_models(cls): + return { + "camembert": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz", + "camembert.v0": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz", + "camembert-base": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base.tar.gz", + "camembert-large": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-large.tar.gz", + "camembert-base-ccnet": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet.tar.gz", + "camembert-base-ccnet-4gb": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base-ccnet-4gb.tar.gz", + "camembert-base-wikipedia-4gb": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base-wikipedia-4gb.tar.gz", + "camembert-base-oscar-4gb": "http://dl.fbaipublicfiles.com/fairseq/models/camembert-base-oscar-4gb.tar.gz", + } + + @classmethod + def from_pretrained( + cls, + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + bpe="sentencepiece", + **kwargs + ): + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + bpe=bpe, + load_checkpoint_heads=True, + **kwargs, + ) + return RobertaHubInterface(x["args"], x["task"], x["models"][0]) diff --git a/fairseq/fairseq/models/roberta/model_gottbert.py b/fairseq/fairseq/models/roberta/model_gottbert.py new file mode 100644 index 0000000000000000000000000000000000000000..2e8c66354ac7ce7309226bb091a7baa4776fbfdc --- /dev/null +++ b/fairseq/fairseq/models/roberta/model_gottbert.py @@ -0,0 +1,49 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +GottBERT: a pure German Language Model +""" + +from fairseq.models import register_model + +from .hub_interface import RobertaHubInterface +from .model import RobertaModel + + +@register_model('gottbert') +class GottbertModel(RobertaModel): + + @classmethod + def hub_models(cls): + return { + 'gottbert-base': 'https://dl.gottbert.de/fairseq/models/gottbert-base.tar.gz', + } + + @classmethod + def from_pretrained(cls, + model_name_or_path, + checkpoint_file='model.pt', + data_name_or_path='.', + bpe='hf_byte_bpe', + bpe_vocab='vocab.json', + bpe_merges='merges.txt', + bpe_add_prefix_space=False, + **kwargs + ): + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + bpe=bpe, + load_checkpoint_heads=True, + bpe_vocab=bpe_vocab, + bpe_merges=bpe_merges, + bpe_add_prefix_space=bpe_add_prefix_space, + **kwargs, + ) + return RobertaHubInterface(x['args'], x['task'], x['models'][0]) diff --git a/fairseq/fairseq/models/roberta/model_xlmr.py b/fairseq/fairseq/models/roberta/model_xlmr.py new file mode 100644 index 0000000000000000000000000000000000000000..cf6e354d53b918dd4c7c78bfcd38ac0d63cab3bd --- /dev/null +++ b/fairseq/fairseq/models/roberta/model_xlmr.py @@ -0,0 +1,46 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Unsupervised Cross-lingual Representation Learning at Scale +""" + +from fairseq.models import register_model + +from .hub_interface import RobertaHubInterface +from .model import RobertaModel + + +@register_model("xlmr") +class XLMRModel(RobertaModel): + @classmethod + def hub_models(cls): + return { + "xlmr.base": "http://dl.fbaipublicfiles.com/fairseq/models/xlmr.base.tar.gz", + "xlmr.large": "http://dl.fbaipublicfiles.com/fairseq/models/xlmr.large.tar.gz", + "xlmr.xl": "http://dl.fbaipublicfiles.com/fairseq/models/xlmr/xlmr.xl.tar.gz", + "xlmr.xxl": "http://dl.fbaipublicfiles.com/fairseq/models/xlmr/xlmr.xxl.tar.gz", + } + + @classmethod + def from_pretrained( + cls, + model_name_or_path, + checkpoint_file="model.pt", + data_name_or_path=".", + bpe="sentencepiece", + **kwargs + ): + from fairseq import hub_utils + + x = hub_utils.from_pretrained( + model_name_or_path, + checkpoint_file, + data_name_or_path, + archive_map=cls.hub_models(), + bpe=bpe, + load_checkpoint_heads=True, + **kwargs, + ) + return RobertaHubInterface(x["args"], x["task"], x["models"][0]) diff --git a/fairseq/fairseq/models/speech_to_text/__init__.py b/fairseq/fairseq/models/speech_to_text/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1c5189c0f7fb4d66077d9d6498cb78cacff76de8 --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .berard import * # noqa +from .convtransformer import * # noqa +from .s2t_transformer import * # noqa +from .xm_transformer import * # noqa diff --git a/fairseq/fairseq/models/speech_to_text/berard.py b/fairseq/fairseq/models/speech_to_text/berard.py new file mode 100644 index 0000000000000000000000000000000000000000..c505e3acaa84e5f3263ccbfaf9556f77123f09fc --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/berard.py @@ -0,0 +1,606 @@ +#!/usr/bin/env python3 + +from ast import literal_eval +from typing import List, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import checkpoint_utils, utils +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) + + +@register_model("s2t_berard") +class BerardModel(FairseqEncoderDecoderModel): + """Implementation of a model similar to https://arxiv.org/abs/1802.04200 + + Paper title: End-to-End Automatic Speech Translation of Audiobooks + An implementation is available in tensorflow at + https://github.com/eske/seq2seq + Relevant files in this implementation are the config + (https://github.com/eske/seq2seq/blob/master/config/LibriSpeech/AST.yaml) + and the model code + (https://github.com/eske/seq2seq/blob/master/translate/models.py). + The encoder and decoder try to be close to the original implementation. + The attention is an MLP as in Bahdanau et al. + (https://arxiv.org/abs/1409.0473). + There is no state initialization by averaging the encoder outputs. + """ + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + parser.add_argument( + "--input-layers", + type=str, + metavar="EXPR", + help="List of linear layer dimensions. These " + "layers are applied to the input features and " + "are followed by tanh and possibly dropout.", + ) + parser.add_argument( + "--dropout", + type=float, + metavar="D", + help="Dropout probability to use in the encoder/decoder. " + "Note that this parameters control dropout in various places, " + "there is no fine-grained control for dropout for embeddings " + "vs LSTM layers for example.", + ) + parser.add_argument( + "--in-channels", + type=int, + metavar="N", + help="Number of encoder input channels. " "Typically value is 1.", + ) + parser.add_argument( + "--conv-layers", + type=str, + metavar="EXPR", + help="List of conv layers " "(format: (channels, kernel, stride)).", + ) + parser.add_argument( + "--num-blstm-layers", + type=int, + metavar="N", + help="Number of encoder bi-LSTM layers.", + ) + parser.add_argument( + "--lstm-size", type=int, metavar="N", help="LSTM hidden size." + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="Embedding dimension of the decoder target tokens.", + ) + parser.add_argument( + "--decoder-hidden-dim", + type=int, + metavar="N", + help="Decoder LSTM hidden dimension.", + ) + parser.add_argument( + "--decoder-num-layers", + type=int, + metavar="N", + help="Number of decoder LSTM layers.", + ) + parser.add_argument( + "--attention-dim", + type=int, + metavar="N", + help="Hidden layer dimension in MLP attention.", + ) + parser.add_argument( + "--output-layer-dim", + type=int, + metavar="N", + help="Hidden layer dim for linear layer prior to output projection.", + ) + parser.add_argument( + "--load-pretrained-encoder-from", + type=str, + metavar="STR", + help="model to take encoder weights from (for initialization)", + ) + parser.add_argument( + "--load-pretrained-decoder-from", + type=str, + metavar="STR", + help="model to take decoder weights from (for initialization)", + ) + + @classmethod + def build_encoder(cls, args, task): + encoder = BerardEncoder( + input_layers=literal_eval(args.input_layers), + conv_layers=literal_eval(args.conv_layers), + in_channels=args.input_channels, + input_feat_per_channel=args.input_feat_per_channel, + num_blstm_layers=args.num_blstm_layers, + lstm_size=args.lstm_size, + dropout=args.dropout, + ) + if getattr(args, "load_pretrained_encoder_from", None): + encoder = checkpoint_utils.load_pretrained_component_from_model( + component=encoder, checkpoint=args.load_pretrained_encoder_from + ) + return encoder + + @classmethod + def build_decoder(cls, args, task): + decoder = LSTMDecoder( + dictionary=task.target_dictionary, + embed_dim=args.decoder_embed_dim, + num_layers=args.decoder_num_layers, + hidden_size=args.decoder_hidden_dim, + dropout=args.dropout, + encoder_output_dim=2 * args.lstm_size, # bidirectional + attention_dim=args.attention_dim, + output_layer_dim=args.output_layer_dim, + ) + if getattr(args, "load_pretrained_decoder_from", None): + decoder = checkpoint_utils.load_pretrained_component_from_model( + component=decoder, checkpoint=args.load_pretrained_decoder_from + ) + return decoder + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + encoder = cls.build_encoder(args, task) + decoder = cls.build_decoder(args, task) + + return cls(encoder, decoder) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = super().get_normalized_probs(net_output, log_probs, sample) + # lprobs is a (B, T, D) tensor + lprobs.batch_first = True + return lprobs + + +class BerardEncoder(FairseqEncoder): + def __init__( + self, + input_layers: List[int], + conv_layers: List[Tuple[int]], + in_channels: int, + input_feat_per_channel: int, + num_blstm_layers: int, + lstm_size: int, + dropout: float, + ): + """ + Args: + input_layers: list of linear layer dimensions. These layers are + applied to the input features and are followed by tanh and + possibly dropout. + conv_layers: list of conv2d layer configurations. A configuration is + a tuple (out_channels, conv_kernel_size, stride). + in_channels: number of input channels. + input_feat_per_channel: number of input features per channel. These + are speech features, typically 40 or 80. + num_blstm_layers: number of bidirectional LSTM layers. + lstm_size: size of the LSTM hidden (and cell) size. + dropout: dropout probability. Dropout can be applied after the + linear layers and LSTM layers but not to the convolutional + layers. + """ + super().__init__(None) + + self.input_layers = nn.ModuleList() + in_features = input_feat_per_channel + for out_features in input_layers: + if dropout > 0: + self.input_layers.append( + nn.Sequential( + nn.Linear(in_features, out_features), nn.Dropout(p=dropout) + ) + ) + else: + self.input_layers.append(nn.Linear(in_features, out_features)) + in_features = out_features + + self.in_channels = in_channels + self.input_dim = input_feat_per_channel + self.conv_kernel_sizes_and_strides = [] + self.conv_layers = nn.ModuleList() + lstm_input_dim = input_layers[-1] + for conv_layer in conv_layers: + out_channels, conv_kernel_size, conv_stride = conv_layer + self.conv_layers.append( + nn.Conv2d( + in_channels, + out_channels, + conv_kernel_size, + stride=conv_stride, + padding=conv_kernel_size // 2, + ) + ) + self.conv_kernel_sizes_and_strides.append((conv_kernel_size, conv_stride)) + in_channels = out_channels + lstm_input_dim //= conv_stride + + lstm_input_dim *= conv_layers[-1][0] + self.lstm_size = lstm_size + self.num_blstm_layers = num_blstm_layers + self.lstm = nn.LSTM( + input_size=lstm_input_dim, + hidden_size=lstm_size, + num_layers=num_blstm_layers, + dropout=dropout, + bidirectional=True, + ) + self.output_dim = 2 * lstm_size # bidirectional + if dropout > 0: + self.dropout = nn.Dropout(p=dropout) + else: + self.dropout = None + + def forward(self, src_tokens, src_lengths=None, **kwargs): + """ + Args + src_tokens: padded tensor (B, T, C * feat) + src_lengths: tensor of original lengths of input utterances (B,) + """ + bsz, max_seq_len, _ = src_tokens.size() + # (B, C, T, feat) + x = ( + src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim) + .transpose(1, 2) + .contiguous() + ) + + for input_layer in self.input_layers: + x = input_layer(x) + x = torch.tanh(x) + + for conv_layer in self.conv_layers: + x = conv_layer(x) + + bsz, _, output_seq_len, _ = x.size() + + # (B, C, T, feat) -> (B, T, C, feat) -> (T, B, C, feat) -> + # (T, B, C * feat) + x = x.transpose(1, 2).transpose(0, 1).contiguous().view(output_seq_len, bsz, -1) + + input_lengths = src_lengths.clone() + for k, s in self.conv_kernel_sizes_and_strides: + p = k // 2 + input_lengths = (input_lengths.float() + 2 * p - k) / s + 1 + input_lengths = input_lengths.floor().long() + + packed_x = nn.utils.rnn.pack_padded_sequence(x, input_lengths) + + h0 = x.new(2 * self.num_blstm_layers, bsz, self.lstm_size).zero_() + c0 = x.new(2 * self.num_blstm_layers, bsz, self.lstm_size).zero_() + packed_outs, _ = self.lstm(packed_x, (h0, c0)) + + # unpack outputs and apply dropout + x, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_outs) + if self.dropout is not None: + x = self.dropout(x) + + encoder_padding_mask = ( + lengths_to_padding_mask(output_lengths).to(src_tokens.device).t() + ) + + return { + "encoder_out": x, # (T, B, C) + "encoder_padding_mask": encoder_padding_mask, # (T, B) + } + + def reorder_encoder_out(self, encoder_out, new_order): + encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select( + 1, new_order + ) + encoder_out["encoder_padding_mask"] = encoder_out[ + "encoder_padding_mask" + ].index_select(1, new_order) + return encoder_out + + +class MLPAttention(nn.Module): + """The original attention from Badhanau et al. (2014) + + https://arxiv.org/abs/1409.0473, based on a Multi-Layer Perceptron. + The attention score between position i in the encoder and position j in the + decoder is: alpha_ij = V_a * tanh(W_ae * enc_i + W_ad * dec_j + b_a) + """ + + def __init__(self, decoder_hidden_state_dim, context_dim, attention_dim): + super().__init__() + + self.context_dim = context_dim + self.attention_dim = attention_dim + # W_ae and b_a + self.encoder_proj = nn.Linear(context_dim, self.attention_dim, bias=True) + # W_ad + self.decoder_proj = nn.Linear( + decoder_hidden_state_dim, self.attention_dim, bias=False + ) + # V_a + self.to_scores = nn.Linear(self.attention_dim, 1, bias=False) + + def forward(self, decoder_state, source_hids, encoder_padding_mask): + """The expected input dimensions are: + decoder_state: bsz x decoder_hidden_state_dim + source_hids: src_len x bsz x context_dim + encoder_padding_mask: src_len x bsz + """ + src_len, bsz, _ = source_hids.size() + # (src_len*bsz) x context_dim (to feed through linear) + flat_source_hids = source_hids.view(-1, self.context_dim) + # (src_len*bsz) x attention_dim + encoder_component = self.encoder_proj(flat_source_hids) + # src_len x bsz x attention_dim + encoder_component = encoder_component.view(src_len, bsz, self.attention_dim) + # 1 x bsz x attention_dim + decoder_component = self.decoder_proj(decoder_state).unsqueeze(0) + # Sum with broadcasting and apply the non linearity + # src_len x bsz x attention_dim + hidden_att = torch.tanh( + (decoder_component + encoder_component).view(-1, self.attention_dim) + ) + # Project onto the reals to get attentions scores (src_len x bsz) + attn_scores = self.to_scores(hidden_att).view(src_len, bsz) + + # Mask + softmax (src_len x bsz) + if encoder_padding_mask is not None: + attn_scores = ( + attn_scores.float() + .masked_fill_(encoder_padding_mask, float("-inf")) + .type_as(attn_scores) + ) # FP16 support: cast to float and back + # srclen x bsz + normalized_masked_attn_scores = F.softmax(attn_scores, dim=0) + + # Sum weighted sources (bsz x context_dim) + attn_weighted_context = ( + source_hids * normalized_masked_attn_scores.unsqueeze(2) + ).sum(dim=0) + + return attn_weighted_context, normalized_masked_attn_scores + + +class LSTMDecoder(FairseqIncrementalDecoder): + def __init__( + self, + dictionary, + embed_dim, + num_layers, + hidden_size, + dropout, + encoder_output_dim, + attention_dim, + output_layer_dim, + ): + """ + Args: + dictionary: target text dictionary. + embed_dim: embedding dimension for target tokens. + num_layers: number of LSTM layers. + hidden_size: hidden size for LSTM layers. + dropout: dropout probability. Dropout can be applied to the + embeddings, the LSTM layers, and the context vector. + encoder_output_dim: encoder output dimension (hidden size of + encoder LSTM). + attention_dim: attention dimension for MLP attention. + output_layer_dim: size of the linear layer prior to output + projection. + """ + super().__init__(dictionary) + self.num_layers = num_layers + self.hidden_size = hidden_size + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + self.embed_tokens = nn.Embedding(num_embeddings, embed_dim, padding_idx) + if dropout > 0: + self.dropout = nn.Dropout(p=dropout) + else: + self.dropout = None + + self.layers = nn.ModuleList() + for layer_id in range(num_layers): + input_size = embed_dim if layer_id == 0 else encoder_output_dim + self.layers.append( + nn.LSTMCell(input_size=input_size, hidden_size=hidden_size) + ) + + self.context_dim = encoder_output_dim + self.attention = MLPAttention( + decoder_hidden_state_dim=hidden_size, + context_dim=encoder_output_dim, + attention_dim=attention_dim, + ) + + self.deep_output_layer = nn.Linear( + hidden_size + encoder_output_dim + embed_dim, output_layer_dim + ) + self.output_projection = nn.Linear(output_layer_dim, num_embeddings) + + def forward( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **kwargs + ): + encoder_padding_mask = encoder_out["encoder_padding_mask"] + encoder_outs = encoder_out["encoder_out"] + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + bsz, seqlen = prev_output_tokens.size() + + srclen = encoder_outs.size(0) + + # embed tokens + embeddings = self.embed_tokens(prev_output_tokens) + x = embeddings + if self.dropout is not None: + x = self.dropout(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + # initialize previous states (or get from cache during incremental + # generation) + cached_state = utils.get_incremental_state( + self, incremental_state, "cached_state" + ) + if cached_state is not None: + prev_hiddens, prev_cells = cached_state + else: + prev_hiddens = [encoder_out["encoder_out"].mean(dim=0)] * self.num_layers + prev_cells = [x.new_zeros(bsz, self.hidden_size)] * self.num_layers + + attn_scores = x.new_zeros(bsz, srclen) + attention_outs = [] + outs = [] + for j in range(seqlen): + input = x[j, :, :] + attention_out = None + for i, layer in enumerate(self.layers): + # the previous state is one layer below except for the bottom + # layer where the previous state is the state emitted by the + # top layer + hidden, cell = layer( + input, + ( + prev_hiddens[(i - 1) % self.num_layers], + prev_cells[(i - 1) % self.num_layers], + ), + ) + if self.dropout is not None: + hidden = self.dropout(hidden) + prev_hiddens[i] = hidden + prev_cells[i] = cell + if attention_out is None: + attention_out, attn_scores = self.attention( + hidden, encoder_outs, encoder_padding_mask + ) + if self.dropout is not None: + attention_out = self.dropout(attention_out) + attention_outs.append(attention_out) + input = attention_out + + # collect the output of the top layer + outs.append(hidden) + + # cache previous states (no-op except during incremental generation) + utils.set_incremental_state( + self, incremental_state, "cached_state", (prev_hiddens, prev_cells) + ) + + # collect outputs across time steps + x = torch.cat(outs, dim=0).view(seqlen, bsz, self.hidden_size) + attention_outs_concat = torch.cat(attention_outs, dim=0).view( + seqlen, bsz, self.context_dim + ) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + attention_outs_concat = attention_outs_concat.transpose(0, 1) + + # concat LSTM output, attention output and embedding + # before output projection + x = torch.cat((x, attention_outs_concat, embeddings), dim=2) + x = self.deep_output_layer(x) + x = torch.tanh(x) + if self.dropout is not None: + x = self.dropout(x) + # project back to size of vocabulary + x = self.output_projection(x) + + # to return the full attn_scores tensor, we need to fix the decoder + # to account for subsampling input frames + # return x, attn_scores + return x, None + + def reorder_incremental_state(self, incremental_state, new_order): + super().reorder_incremental_state(incremental_state, new_order) + cached_state = utils.get_incremental_state( + self, incremental_state, "cached_state" + ) + if cached_state is None: + return + + def reorder_state(state): + if isinstance(state, list): + return [reorder_state(state_i) for state_i in state] + return state.index_select(0, new_order) + + new_state = tuple(map(reorder_state, cached_state)) + utils.set_incremental_state(self, incremental_state, "cached_state", new_state) + + +@register_model_architecture(model_name="s2t_berard", arch_name="s2t_berard") +def berard(args): + """The original version: "End-to-End Automatic Speech Translation of + Audiobooks" (https://arxiv.org/abs/1802.04200) + """ + args.input_layers = getattr(args, "input_layers", "[256, 128]") + args.conv_layers = getattr(args, "conv_layers", "[(16, 3, 2), (16, 3, 2)]") + args.num_blstm_layers = getattr(args, "num_blstm_layers", 3) + args.lstm_size = getattr(args, "lstm_size", 256) + args.dropout = getattr(args, "dropout", 0.2) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 128) + args.decoder_num_layers = getattr(args, "decoder_num_layers", 2) + args.decoder_hidden_dim = getattr(args, "decoder_hidden_dim", 512) + args.attention_dim = getattr(args, "attention_dim", 512) + args.output_layer_dim = getattr(args, "output_layer_dim", 128) + args.load_pretrained_encoder_from = getattr( + args, "load_pretrained_encoder_from", None + ) + args.load_pretrained_decoder_from = getattr( + args, "load_pretrained_decoder_from", None + ) + + +@register_model_architecture(model_name="s2t_berard", arch_name="s2t_berard_256_3_3") +def berard_256_3_3(args): + """Used in + * "Harnessing Indirect Training Data for End-to-End Automatic Speech + Translation: Tricks of the Trade" (https://arxiv.org/abs/1909.06515) + * "CoVoST: A Diverse Multilingual Speech-To-Text Translation Corpus" + (https://arxiv.org/pdf/2002.01320.pdf) + * "Self-Supervised Representations Improve End-to-End Speech Translation" + (https://arxiv.org/abs/2006.12124) + """ + args.decoder_num_layers = getattr(args, "decoder_num_layers", 3) + berard(args) + + +@register_model_architecture(model_name="s2t_berard", arch_name="s2t_berard_512_3_2") +def berard_512_3_2(args): + args.num_blstm_layers = getattr(args, "num_blstm_layers", 3) + args.lstm_size = getattr(args, "lstm_size", 512) + args.dropout = getattr(args, "dropout", 0.3) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_num_layers = getattr(args, "decoder_num_layers", 2) + args.decoder_hidden_dim = getattr(args, "decoder_hidden_dim", 1024) + args.attention_dim = getattr(args, "attention_dim", 512) + args.output_layer_dim = getattr(args, "output_layer_dim", 256) + berard(args) + + +@register_model_architecture(model_name="s2t_berard", arch_name="s2t_berard_512_5_3") +def berard_512_5_3(args): + args.num_blstm_layers = getattr(args, "num_blstm_layers", 5) + args.lstm_size = getattr(args, "lstm_size", 512) + args.dropout = getattr(args, "dropout", 0.3) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_num_layers = getattr(args, "decoder_num_layers", 3) + args.decoder_hidden_dim = getattr(args, "decoder_hidden_dim", 1024) + args.attention_dim = getattr(args, "attention_dim", 512) + args.output_layer_dim = getattr(args, "output_layer_dim", 256) + berard(args) diff --git a/fairseq/fairseq/models/speech_to_text/convtransformer.py b/fairseq/fairseq/models/speech_to_text/convtransformer.py new file mode 100644 index 0000000000000000000000000000000000000000..eba000d7b0826d2ecf5dc471156f8f8cc9f5e402 --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/convtransformer.py @@ -0,0 +1,448 @@ +#!/usr/bin/env python3 + +import logging +import math +from typing import Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import checkpoint_utils, utils +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import Embedding, TransformerDecoder +from fairseq.modules import LayerNorm, PositionalEmbedding, TransformerEncoderLayer +from torch import Tensor + +logger = logging.getLogger(__name__) + + +@register_model("convtransformer") +class ConvTransformerModel(FairseqEncoderDecoderModel): + """ + Transformer-based Speech translation model from ESPNet-ST + https://arxiv.org/abs/2004.10234 + """ + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + parser.add_argument( + "--input-feat-per-channel", + type=int, + metavar="N", + help="encoder input dimension per input channel", + ) + parser.add_argument( + "--activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--activation-dropout", + "--relu-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN.", + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="num encoder layers" + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads", + ) + parser.add_argument( + "--decoder-normalize-before", + action="store_true", + help="apply layernorm before each decoder block", + ) + parser.add_argument( + "--decoder-output-dim", + type=int, + metavar="N", + help="decoder output dimension (extra linear layer if different from decoder embed dim)", + ) + parser.add_argument( + "--share-decoder-input-output-embed", + action="store_true", + help="share decoder input and output embeddings", + ) + parser.add_argument( + "--layernorm-embedding", + action="store_true", + help="add layernorm to embedding", + ) + parser.add_argument( + "--no-scale-embedding", + action="store_true", + help="if True, dont scale embeddings", + ) + parser.add_argument( + "--load-pretrained-encoder-from", + type=str, + metavar="STR", + help="model to take encoder weights from (for initialization)", + ) + parser.add_argument( + "--load-pretrained-decoder-from", + type=str, + metavar="STR", + help="model to take decoder weights from (for initialization)", + ) + parser.add_argument( + "--conv-out-channels", + type=int, + metavar="INT", + help="the number of output channels of conv layer", + ) + + @classmethod + def build_encoder(cls, args): + encoder = ConvTransformerEncoder(args) + if getattr(args, "load_pretrained_encoder_from", None): + encoder = checkpoint_utils.load_pretrained_component_from_model( + component=encoder, checkpoint=args.load_pretrained_encoder_from + ) + return encoder + + @classmethod + def build_decoder(cls, args, task, embed_tokens): + decoder = TransformerDecoderNoExtra(args, task.target_dictionary, embed_tokens) + if getattr(args, "load_pretrained_decoder_from", None): + decoder = checkpoint_utils.load_pretrained_component_from_model( + component=decoder, checkpoint=args.load_pretrained_decoder_from + ) + return decoder + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + def build_embedding(dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + return Embedding(num_embeddings, embed_dim, padding_idx) + + decoder_embed_tokens = build_embedding( + task.target_dictionary, args.decoder_embed_dim + ) + encoder = cls.build_encoder(args) + decoder = cls.build_decoder(args, task, decoder_embed_tokens) + return cls(encoder, decoder) + + @staticmethod + @torch.jit.unused + def set_batch_first(lprobs): + lprobs.batch_first = True + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = self.get_normalized_probs_scriptable(net_output, log_probs, sample) + if self.training: + self.set_batch_first(lprobs) + return lprobs + + def output_layout(self): + return "BTD" + + """ + The forward method inherited from the base class has a **kwargs argument in + its input, which is not supported in torchscript. This method overrites the forward + method definition without **kwargs. + """ + + def forward(self, src_tokens, src_lengths, prev_output_tokens): + encoder_out = self.encoder(src_tokens=src_tokens, src_lengths=src_lengths) + decoder_out = self.decoder( + prev_output_tokens=prev_output_tokens, encoder_out=encoder_out + ) + return decoder_out + + +class ConvTransformerEncoder(FairseqEncoder): + """Conv + Transformer encoder""" + + def __init__(self, args): + """Construct an Encoder object.""" + super().__init__(None) + + self.dropout = args.dropout + self.embed_scale = ( + 1.0 if args.no_scale_embedding else math.sqrt(args.encoder_embed_dim) + ) + self.padding_idx = 1 + self.in_channels = 1 + self.input_dim = args.input_feat_per_channel + self.conv = torch.nn.Sequential( + torch.nn.Conv2d(1, args.conv_out_channels, 3, stride=2, padding=3 // 2), + torch.nn.ReLU(), + torch.nn.Conv2d( + args.conv_out_channels, + args.conv_out_channels, + 3, + stride=2, + padding=3 // 2, + ), + torch.nn.ReLU(), + ) + transformer_input_dim = self.infer_conv_output_dim( + self.in_channels, self.input_dim, args.conv_out_channels + ) + self.out = torch.nn.Linear(transformer_input_dim, args.encoder_embed_dim) + self.embed_positions = PositionalEmbedding( + args.max_source_positions, + args.encoder_embed_dim, + self.padding_idx, + learned=False, + ) + + self.transformer_layers = nn.ModuleList([]) + self.transformer_layers.extend( + [TransformerEncoderLayer(args) for i in range(args.encoder_layers)] + ) + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(args.encoder_embed_dim) + else: + self.layer_norm = None + + def pooling_ratio(self): + return 4 + + def infer_conv_output_dim(self, in_channels, input_dim, out_channels): + sample_seq_len = 200 + sample_bsz = 10 + x = torch.randn(sample_bsz, in_channels, sample_seq_len, input_dim) + x = torch.nn.Conv2d(1, out_channels, 3, stride=2, padding=3 // 2)(x) + x = torch.nn.Conv2d(out_channels, out_channels, 3, stride=2, padding=3 // 2)(x) + x = x.transpose(1, 2) + mb, seq = x.size()[:2] + return x.contiguous().view(mb, seq, -1).size(-1) + + def forward(self, src_tokens, src_lengths): + """Encode input sequence. + :param torch.Tensor xs: input tensor + :param torch.Tensor masks: input mask + :return: position embedded tensor and mask + :rtype Tuple[torch.Tensor, torch.Tensor]: + """ + bsz, max_seq_len, _ = src_tokens.size() + x = ( + src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim) + .transpose(1, 2) + .contiguous() + ) + x = self.conv(x) + bsz, _, output_seq_len, _ = x.size() + x = x.transpose(1, 2).transpose(0, 1).contiguous().view(output_seq_len, bsz, -1) + x = self.out(x) + x = self.embed_scale * x + + subsampling_factor = int(max_seq_len * 1.0 / output_seq_len + 0.5) + input_len_0 = (src_lengths.float() / subsampling_factor).ceil().long() + input_len_1 = x.size(0) * torch.ones([src_lengths.size(0)]).long().to( + input_len_0.device + ) + input_lengths = torch.min(input_len_0, input_len_1) + + encoder_padding_mask = lengths_to_padding_mask(input_lengths) + + positions = self.embed_positions(encoder_padding_mask).transpose(0, 1) + x += positions + x = F.dropout(x, p=self.dropout, training=self.training) + + for layer in self.transformer_layers: + x = layer(x, encoder_padding_mask) + + if not encoder_padding_mask.any(): + maybe_encoder_padding_mask = None + else: + maybe_encoder_padding_mask = encoder_padding_mask + + return { + "encoder_out": [x], + "encoder_padding_mask": [maybe_encoder_padding_mask] + if maybe_encoder_padding_mask is not None + else [], + "encoder_embedding": [], + "encoder_states": [], + "src_tokens": [], + "src_lengths": [], + } + + @torch.jit.export + def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + new_encoder_out = [encoder_out["encoder_out"][0].index_select(1, new_order)] + if len(encoder_out["encoder_padding_mask"]) == 0: + new_encoder_padding_mask = [] + else: + new_encoder_padding_mask = [ + (encoder_out["encoder_padding_mask"][0]).index_select(0, new_order) + ] + if len(encoder_out["encoder_embedding"]) == 0: + new_encoder_embedding = [] + else: + new_encoder_embedding = [ + (encoder_out["encoder_embedding"][0]).index_select(0, new_order) + ] + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, + "encoder_padding_mask": new_encoder_padding_mask, + "encoder_embedding": new_encoder_embedding, + "encoder_states": encoder_states, + "src_tokens": [], + "src_lengths": [], + } + + +class TransformerDecoderNoExtra(TransformerDecoder): + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + # call scriptable method from parent class + x, _ = self.extract_features_scriptable( + prev_output_tokens, + encoder_out, + incremental_state, + full_context_alignment, + alignment_layer, + alignment_heads, + ) + return x, None + + +@register_model_architecture(model_name="convtransformer", arch_name="convtransformer") +def base_architecture(args): + args.input_feat_per_channel = getattr(args, "input_feat_per_channel", 80) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.max_source_positions = getattr(args, "max_source_positions", 3000) + args.max_target_positions = getattr(args, "max_target_positions", 1024) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.conv_out_channels = getattr(args, "conv_out_channels", args.encoder_embed_dim) + + +@register_model_architecture("convtransformer", "convtransformer_espnet") +def convtransformer_espnet(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) diff --git a/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py b/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..e7465bc889fd1ba6ca2c60905a2eb6ff5cc62b9d --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py @@ -0,0 +1,488 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Tuple, List + +import torch +import torch.nn.functional as F +from fairseq.models import FairseqEncoder +from fairseq.models.speech_to_text import ( + ConvTransformerEncoder, +) +from fairseq.models.speech_to_text.utils import attention_suppression +from fairseq.models.speech_to_text.utils import ( + lengths_to_encoder_padding_mask, + segments_to_sequence, + sequence_to_segments, +) +from fairseq.modules import MultiheadAttention, TransformerEncoderLayer +from torch import nn, Tensor + +# ------------------------------------------------------------------------------ +# AugmentedMemoryConvTransformerEncoder +# ------------------------------------------------------------------------------ + + +class AugmentedMemoryConvTransformerEncoder(ConvTransformerEncoder): + def __init__(self, args): + super().__init__(args) + + args.encoder_stride = self.stride() + + self.left_context = args.left_context // args.encoder_stride + + self.right_context = args.right_context // args.encoder_stride + + self.left_context_after_stride = args.left_context // args.encoder_stride + self.right_context_after_stride = args.right_context // args.encoder_stride + + self.transformer_layers = nn.ModuleList([]) + self.transformer_layers.extend( + [ + AugmentedMemoryTransformerEncoderLayer(args) + for i in range(args.encoder_layers) + ] + ) + + def stride(self): + # Hard coded here. Should infer from convs in future + stride = 4 + return stride + + def forward(self, src_tokens, src_lengths, states=None): + """Encode input sequence. + :param torch.Tensor xs: input tensor + :param torch.Tensor masks: input mask + :return: position embedded tensor and mask + :rtype Tuple[torch.Tensor, torch.Tensor]: + """ + bsz, max_seq_len, _ = src_tokens.size() + x = ( + src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim) + .transpose(1, 2) + .contiguous() + ) + x = self.conv(x) + bsz, _, output_seq_len, _ = x.size() + x = x.transpose(1, 2).transpose(0, 1).contiguous().view(output_seq_len, bsz, -1) + x = self.out(x) + x = self.embed_scale * x + + subsampling_factor = 1.0 * max_seq_len / output_seq_len + input_lengths = torch.max( + (src_lengths.float() / subsampling_factor).ceil().long(), + x.size(0) * src_lengths.new_ones([src_lengths.size(0)]).long(), + ) + + encoder_padding_mask, _ = lengths_to_encoder_padding_mask( + input_lengths, batch_first=True + ) + + # TODO: fix positional embedding + positions = self.embed_positions(encoder_padding_mask).transpose(0, 1) + + x += positions + x = F.dropout(x, p=self.dropout, training=self.training) + + # State to store memory banks etc. + if states is None: + states = [ + {"memory_banks": None, "encoder_states": None} + for i in range(len(self.transformer_layers)) + ] + + for i, layer in enumerate(self.transformer_layers): + # x size: + # (self.left_size + self.segment_size + self.right_size) + # / self.stride, num_heads, dim + # TODO: Consider mask here + x = layer(x, states[i]) + states[i]["encoder_states"] = x[ + self.left_context_after_stride : -self.right_context_after_stride + ] + + lengths = ( + ( + ~encoder_padding_mask[ + :, self.left_context_after_stride : -self.right_context_after_stride + ] + ) + .sum(dim=1, keepdim=True) + .long() + ) + + return states[-1]["encoder_states"], lengths, states + + +# ------------------------------------------------------------------------------ +# AugmentedMemoryTransformerEncoderLayer +# ------------------------------------------------------------------------------ +class AugmentedMemoryTransformerEncoderLayer(TransformerEncoderLayer): + def __init__(self, args): + super().__init__(args) + + self.left_context = args.left_context // args.encoder_stride + self.right_context = args.right_context // args.encoder_stride + + def forward(self, x, state): + + length, batch_size, x_dim = x.size() + + residual = x + + if self.normalize_before: + x = self.self_attn_layer_norm(x) + + # init_state + if state.get("memory_banks", None) is None: + state["memory_banks"] = [] + + # TODO reseach new sum_query method + seg_start = self.left_context + seg_end = length - self.right_context + if seg_start < seg_end: + summarization_query = torch.mean(x[seg_start:seg_end], keepdim=True, dim=0) + else: + summarization_query = x.new_zeros(1, batch_size, x_dim) + + x = torch.cat([x, summarization_query], dim=0) + + x = self.self_attn(input_and_summary=x, state=state) + + x = self.dropout_module(x) + x = residual + x + + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = residual + x + if not self.normalize_before: + x = self.final_layer_norm(x) + + return x + + def build_self_attention(self, embed_dim, args): + return AugmentedMemoryMultiheadAttention( + embed_dim=embed_dim, + num_heads=args.encoder_attention_heads, + dropout=args.attention_dropout, + self_attention=True, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + tanh_on_mem=True, + max_memory_size=args.max_memory_size, + ) + + +# ------------------------------------------------------------------------------ +# AugmentedMemoryMultiheadAttention +# ------------------------------------------------------------------------------ +class AugmentedMemoryMultiheadAttention(MultiheadAttention): + """ + Augmented Memory Attention from + Streaming Transformer-based Acoustic Models + Using Self-attention with Augmented Memory + https://arxiv.org/abs/2005.08042 + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + self_attention=False, + encoder_decoder_attention=False, + q_noise=0.0, + qn_block_size=8, + tanh_on_mem=False, + memory_dim=None, + std_scale=0.5, # 0.5 based on https://arxiv.org/abs/2005.09137 + max_memory_size=-1, + disable_mem_on_mem_attn=True, + ): + super().__init__( + embed_dim, + num_heads, + kdim, + vdim, + dropout, + bias, + add_bias_kv, + add_zero_attn, + self_attention, + encoder_decoder_attention, + q_noise, + qn_block_size, + ) + + self.memory_dim = memory_dim if memory_dim is not None else embed_dim + self.std_scale = std_scale + self.disable_mem_on_mem_attn = disable_mem_on_mem_attn + + # This Operator was used for factorization in PySpeech + self.v2e = lambda x: x + + if tanh_on_mem: + self.squash_mem = torch.tanh + self.nonlinear_squash_mem = True + else: + self.squash_mem = lambda x: x + self.nonlinear_squash_mem = False + + self.max_memory_size = max_memory_size + + def forward(self, input_and_summary, state): + """ + input: Encoder states of current segment with left or right context, + plus one summarization query + + """ + + length, batch_size, _ = input_and_summary.shape + length = length - 1 # not include sum_query, last index + + memory = state["memory_banks"] + # TODO: positional embedding on memory + + if self.max_memory_size > -1 and len(memory) > self.max_memory_size: + # TODO: need to fix here + if self.max_memory_size == 0: + memory = memory.new_zeros(1, memory.size(1), self.memory_dim) + else: + memory = memory[-self.max_memory_size :] + + memory_and_input = torch.cat(memory + [input_and_summary[:-1]], dim=0) + input_and_sum_query = input_and_summary + + q = self.q_proj(self.v2e(input_and_sum_query)) + k = self.k_proj(self.v2e(memory_and_input)) + v = self.v_proj(self.v2e(memory_and_input)) + + q = ( + q.contiguous() + .view(-1, batch_size * self.num_heads, self.head_dim) + .transpose(0, 1) + * self.scaling + ) + k = ( + k.contiguous() + .view(-1, batch_size * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + v = ( + v.contiguous() + .view(-1, batch_size * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + attention_weights = torch.bmm(q, k.transpose(1, 2)) + + if self.disable_mem_on_mem_attn: + attention_weights = self.suppress_mem_on_mem_attention( + batch_size, self.num_heads, len(memory), attention_weights + ) + + if self.std_scale is not None: + attention_weights = attention_suppression(attention_weights, self.std_scale) + + assert list(attention_weights.shape) == [ + batch_size * self.num_heads, + length + 1, + length + len(memory), + ] + + attention_weights = torch.nn.functional.softmax( + attention_weights.float(), dim=-1 + ).type_as(attention_weights) + + attention_probs = self.dropout_module(attention_weights) + + # [T, T, B, n_head] + [T, B, n_head, d_head] -> [T, B, n_head, d_head] + attention = torch.bmm(attention_probs, v) + + assert list(attention.shape) == [ + batch_size * self.num_heads, + length + 1, + self.head_dim, + ] + + attention = ( + attention.transpose(0, 1) + .contiguous() + .view(length + 1, batch_size, self.embed_dim) + ) + + output_and_memory = self.out_proj(attention) + + next_m = output_and_memory[-1:] + next_m = self.squash_mem(next_m) + output = output_and_memory[:-1] + + state["memory_banks"].append(next_m) + + return output + + def suppress_mem_on_mem_attention( + self, B: int, num_heads: int, mem_size: int, attention_weight: Tensor + ): + """ + Arguments: + - B: batch size + - num_heads: number of attention heads + - mem_size: size of memory bank + - attention_weight: a [B*num_heads, T + 1, T + mem_size] vector + + Return: + modified attention_weight with [B*num_heads, -1, :mem_size] = -inf + """ + attention_weight[:, -1, :mem_size] = float("-inf") + return attention_weight + + +# ------------------------------------------------------------------------------ +# SequenceEncoder +# ------------------------------------------------------------------------------ +class SequenceEncoder(FairseqEncoder): + """ + SequenceEncoder encodes sequences. + + More specifically, `src_tokens` and `src_lengths` in `forward()` should + describe a batch of "complete" sequences rather than segments. + + Segment-by-segment inference can be triggered by `segment_size`: + 1) `segment_size` is None: + SequenceEncoder treats the input sequence as one single segment. + 2) `segment_size` is not None (some int instead): + SequenceEncoder does the following: + 1. breaks the input sequence into several segments + 2. inference on each segment and collect the outputs + 3. concatanete segment outputs into the output sequence. + Note that `segment_size` here shouldn't include additional left/right + contexts needed, for example if we wish to infer with LC-BLSTM where the + middle chunk size is 100 and right context is 20, `segment_size` should be + 100. + """ + + def __init__(self, args, module): + super().__init__(None) + + self.module = module + self.input_time_axis = 1 + self.output_time_axis = 0 + self.segment_size = args.segment_size + self.left_context = args.left_context + self.right_context = args.right_context + + def forward( + self, + src_tokens: Tensor, + src_lengths: Tensor, + states=None, + ): + + seg_src_tokens_lengths = sequence_to_segments( + sequence=src_tokens, + time_axis=self.input_time_axis, + lengths=src_lengths, + segment_size=self.segment_size, + extra_left_context=self.left_context, + extra_right_context=self.right_context, + ) + + seg_encoder_states_lengths: List[Tuple[Tensor, Tensor]] = [] + + for seg_src_tokens, seg_src_lengths in seg_src_tokens_lengths: + (seg_encoder_states, seg_enc_lengths, states) = self.module( + seg_src_tokens, + seg_src_lengths, + states=states, + ) + + seg_encoder_states_lengths.append((seg_encoder_states, seg_enc_lengths)) + + encoder_out, enc_lengths = segments_to_sequence( + segments=seg_encoder_states_lengths, time_axis=self.output_time_axis + ) + + encoder_padding_mask, _ = lengths_to_encoder_padding_mask( + enc_lengths, batch_first=True + ) + + if not encoder_padding_mask.any(): + encoder_padding_mask = None + + return { + "encoder_out": [encoder_out], + "encoder_padding_mask": [encoder_padding_mask], + "encoder_embedding": [], + "encoder_states": [states], + "src_tokens": [], + "src_lengths": [], + } + + def incremental_encode( + self, + seg_src_tokens: Tensor, + seg_src_lengths: Tensor, + states=None, + ): + """ + Different from forward function, this function takes segmented speech + as input, and append encoder states to previous states + """ + (seg_encoder_states, seg_enc_lengths, states) = self.module( + seg_src_tokens, + seg_src_lengths, + states=states, + ) + return seg_encoder_states, seg_enc_lengths, states + + +# ------------------------------------------------------------------------------ +# Augmented memory model decorator +# ------------------------------------------------------------------------------ +def augmented_memory(klass): + class StreamSeq2SeqModel(klass): + @staticmethod + def add_args(parser): + super(StreamSeq2SeqModel, StreamSeq2SeqModel).add_args(parser) + parser.add_argument( + "--segment-size", type=int, required=True, help="Length of the segment." + ) + parser.add_argument( + "--left-context", + type=int, + default=0, + help="Left context for the segment.", + ) + parser.add_argument( + "--right-context", + type=int, + default=0, + help="Right context for the segment.", + ) + parser.add_argument( + "--max-memory-size", + type=int, + default=-1, + help="Right context for the segment.", + ) + + StreamSeq2SeqModel.__name__ = klass.__name__ + return StreamSeq2SeqModel diff --git a/fairseq/fairseq/models/speech_to_text/modules/emformer.py b/fairseq/fairseq/models/speech_to_text/modules/emformer.py new file mode 100644 index 0000000000000000000000000000000000000000..6ef76bd012ba40b0395fec2ca9ae9e9c136ffe40 --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/modules/emformer.py @@ -0,0 +1,1837 @@ +#!/usr/bin/env python3 +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + + +import math +import re +from functools import partial +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn +from fairseq.models import ( + FairseqEncoder, +) +from fairseq.models.speech_to_text.utils import ( + NoOp, + lengths_to_padding_mask, + segments_to_sequence, +) +from fairseq.models.speech_to_text.utils import ( + attention_suppression, + layer_norm_backward_hook, +) +from torch import Tensor, device as Device +from torch.quantization.qconfig import ( + default_dynamic_qconfig, + per_channel_dynamic_qconfig, +) + + +class RelativePositionEmbedding(nn.Module): + """ + Implementation according to https://arxiv.org/abs/1803.02155 + """ + + def __init__(self, head_dim, max_position, norm_init=True): + super().__init__() + self.head_dim = head_dim + self.max_position = max_position + self.embeddings = nn.Parameter(torch.Tensor(max_position * 2 + 1, head_dim)) + if norm_init: + nn.init.xavier_normal_(self.embeddings) + else: + nn.init.xavier_uniform_(self.embeddings) + + def forward(self, input: Tensor): + output = nn.functional.embedding(input.long(), self.embeddings) + return output + + +class Fp32LayerNorm(nn.Module): + def __init__( + self, + input_dim, + clamp_grad=True, + max_grad_value=256, + eps=1e-5, + elementwise_affine=True, + ): + super().__init__() + self.torch_module = torch.nn.LayerNorm( + input_dim, eps=eps, elementwise_affine=elementwise_affine + ) + if clamp_grad: + hook = partial(layer_norm_backward_hook, clamp_value=max_grad_value) + self.torch_module.register_backward_hook(hook) + + def forward(self, input): + output = torch.nn.functional.layer_norm( + input.float(), + self.torch_module.normalized_shape, + self.torch_module.weight.float() + if self.torch_module.weight is not None + else None, + self.torch_module.bias.float() + if self.torch_module.bias is not None + else None, + self.torch_module.eps, + ).type_as(input) + return output + + +# ------------------------------------------------------------------------------ +# PositionwiseFF +# ------------------------------------------------------------------------------ + + +class PositionwiseFF(nn.Module): + """ + FFN layer in transformer. + + Args: + input_dim: input embedding dimension + ffn_dim: FFN layer inner dimension + dropout_on_fc1: dropout for first linear layer + dropout_on_fc2: dropout fr second linear layer + activation_fn: activation function used after first linear layer. \ + Only relu or gelu is supported. + + """ + + def __init__( + self, input_dim, ffn_dim, dropout_on_fc1, dropout_on_fc2, activation_fn + ): + super(PositionwiseFF, self).__init__() + + self.input_dim = input_dim + self.ffn_dim = ffn_dim + if activation_fn == "relu": + ac = nn.ReLU() + elif activation_fn == "gelu": + ac = nn.GELU() + else: + raise ValueError("Unsupported activation_fn = ({})".format(activation_fn)) + + # fc1 -> ac -> dropout -> fc2 -> dropout + self.module = nn.Sequential( + nn.Linear(input_dim, ffn_dim), + ac, + nn.Dropout(dropout_on_fc1), + nn.Linear(ffn_dim, input_dim), + nn.Dropout(dropout_on_fc2), + ) + + self.layer_norm = Fp32LayerNorm(input_dim) + + def forward(self, input): + module_out = self.module(self.layer_norm(input)) + output = module_out + input + + return output + + def quantize_(self, params=None): + if params and "per_channel" in params and params["per_channel"]: + qconfig = per_channel_dynamic_qconfig + else: + qconfig = default_dynamic_qconfig + torch.quantization.quantize_dynamic( + self, {torch.nn.Linear: qconfig}, dtype=torch.qint8, inplace=True + ) + return self + + +# ------------------------------------------------------------------------------ +# SummarizationLayer +# ------------------------------------------------------------------------------ + + +class SummarizationLayer(nn.Module): + def __init__(self, method, segment_size, embedding_dim): + super(SummarizationLayer, self).__init__() + self.segment_size = segment_size + self.embedding_dim = embedding_dim + nonlin_match = re.match(r"nonlinear\((?P<act>[a-z]+),(?P<dim>[0-9]+)\)", method) + self.method = method + if method == "mean": + self.module = nn.AvgPool1d( + kernel_size=segment_size, + stride=segment_size, + ceil_mode=True, + ) + elif method == "max": + self.module = nn.MaxPool1d( + kernel_size=segment_size, + stride=segment_size, + ceil_mode=True, + ) + elif method == "linear": + self.module = nn.Linear(segment_size, 1) + elif nonlin_match: + nonlin_args = nonlin_match.groupdict() + act_type = nonlin_args["act"] + hid_dim = int(nonlin_args["dim"]) + if act_type == "relu": + act = nn.ReLU() + elif act_type == "gelu": + act = nn.GELU() + else: + raise ValueError("Unsupported activation_fn = ({})".format(act_type)) + self.module = nn.Sequential( + nn.Linear(segment_size, hid_dim), + act, + nn.Linear(hid_dim, 1), + ) + else: + raise ValueError("Unsupported summarization method = ({})".format(method)) + + def forward(self, input): + # T, B, D -> B, D, T + input = input.permute(1, 2, 0) + + if self.method == "mean" or self.method == "max": + output = self.module(input) + output = output.permute(2, 0, 1) + return output + + full_seg_length = input.size(2) // self.segment_size * self.segment_size + if full_seg_length > 0: + # at least one seg is full + B = input.size(0) + D = input.size(1) + input_todo = ( + input[:, :, :full_seg_length] + .contiguous() + .view(B, -1, self.segment_size) + ) + output = self.module(input_todo) + output = output.view(B, D, -1) + else: + output = input.new_zeros(input.size(0), input.size(1), 0) + left = input.size(2) - full_seg_length + if left > 0: + # when last seg is not full, use zeros as last memory placeholder + zeros = input.new_zeros(input.size(0), input.size(1), 1) + output = torch.cat([output, zeros], dim=2) + output = output.permute(2, 0, 1) + return output + + +# ------------------------------------------------------------------------------ +# NoSegAugmentedMemoryMultiheadAttentionBmm +# ------------------------------------------------------------------------------ + + +class NoSegAugmentedMemoryMultiheadAttentionBmm(nn.Module): + """ + Whole utterance augmented memory multihead attention using BMM. + + Different with previous augmented memory multihead attention where + the utterance is chunked into segments. Here we use attention mask + achieve so. The input embedding [right_context, utterance, summary] + is a concatenation of right context, utterance and summary. + + Right context block is the concatenation of all the right context for + each segments. [right_context_0, right_context_1, ..., right_context_n] + For example, if we have utterance = [v0, v1, v2, ...., v20]. segment + size 8, right_context size 4. Then the right context blocks = + [v8, v9, v10, v11, v16, v17, v18, v19, 0, 0, 0, 0], where v8, v9, v10, + and v11 are the right context for first segment. v16, v17, v18 and v19 + are the right context for second segment. 0, 0, 0 and 0 are right context + for the last segment. + + utterance is corresponding to input embedding sequence + + summary is concatenation of average of each segments. [summary_0, + summary_1, ..., ]. + + In augmented memory multihead attention, the query is [right_context, + utterance, summary], key is [memory, right_context, utterance]. Different + with AugmentedMemoryMultiheadAttentionBmm, memory here is passed from + previous attention layer. For the first attention layer, memory is average + of each segment. + + Memory is a concatenation of memory from each segments in previous attention + layer. For example, current layer is i, then memory is [m_0, m_1, ..., m_n]. + Each m_k is the output from seg_k in layer i-1. + + args: + input_dim: input embedding dimension + num_heads: number of heads in multihead self-attention + dropout: attention dropout + std_scale: if std_scale is not None. The weak attention suppression is + turned on. For std_scale = 0.5, all the attention smaller than + mean + 0.5 * std will be suppressed. + scaled_init: whether to use scaled init for linear weight + tanh_on_mem: whether to use tanh on memory output + use_mem: whether to use memory or not. When max_memory_size is 0, then + we don't have memory anymore. + layer_index: current self-attention layer index that is used in depth + initialization + max_relative_position: max relative position used in relative position + embedding + rpe_old_option: To be compatible with previous model. The previous model + was trained with attention += attention + rpe. The correct equation + should be attention = attention + rpe + + """ + + def __init__( + self, + input_dim, + num_heads, + dropout=0.0, + std_scale=None, + scaled_init=False, + tanh_on_mem=False, + use_mem=True, + mini_batches=False, + negative_inf="-inf", + layer_index=-1, + max_relative_position=0, + rpe_old_option=True, + ): + if input_dim % num_heads: + raise ValueError( + "input_dim ({}) must be divisible by num_heads ({})".format( + input_dim, num_heads + ) + ) + + super().__init__() + + embed_dim = input_dim + self.e2h_kv = torch.nn.Linear(input_dim, 2 * input_dim, bias=True) + self.e2h_q = torch.nn.Linear(input_dim, input_dim, bias=True) + self.rpe_old_option = rpe_old_option + if max_relative_position > 0: + self.use_rpe = True + self.rpe_k = RelativePositionEmbedding( + head_dim=input_dim // num_heads, + max_position=max_relative_position, + ) + self.rpe_v = RelativePositionEmbedding( + head_dim=input_dim // num_heads, + max_position=max_relative_position, + ) + else: + self.use_rpe = False + self.rpe_k = None + self.rpe_v = None + if scaled_init: + if layer_index == -1: + gain = 1.0 / math.sqrt(2) + else: + # https://arxiv.org/abs/2005.09684 depthwise initialization + # stablize the training greatly. Use depthwise initialization to + # replace incremental loss. + gain = 1.0 / math.sqrt(layer_index + 1) + torch.nn.init.xavier_uniform_(self.e2h_kv.weight, gain=gain) + torch.nn.init.xavier_uniform_(self.e2h_q.weight, gain=gain) + + self.out_proj = torch.nn.Linear(embed_dim, embed_dim, bias=True) + + self.embed_dim = embed_dim + self.num_heads = num_heads + self.dropout = dropout + + self.head_dim = embed_dim // num_heads + self.scaling = self.head_dim ** -0.5 + + self.std_scale = std_scale + self.use_mem = use_mem + self.mini_batches = mini_batches + self.negative_inf = negative_inf + + if tanh_on_mem: + self.squash_mem = torch.tanh + self.nonlinear_squash_mem = True + else: + self.squash_mem = NoOp() + self.nonlinear_squash_mem = False + + def prepare_qkv( + self, + input: Tensor, + mems: Tensor, + lengths: Tensor, + summary_length: int, + lc_length: int, + ): + # T: right_context length + utterance_length + summary_length + T, B, D = input.shape + mem_length = mems.size(0) + utterance_length = torch.max(lengths) + + right_context_blocks_length = T - utterance_length - summary_length + rc_block = input[:right_context_blocks_length, :, :] + utterance_block = input[right_context_blocks_length : T - summary_length, :, :] + + if B == 1: + padding_mask = None + else: + klengths = lengths + mem_length + right_context_blocks_length + lc_length + padding_mask = lengths_to_padding_mask(lengths=klengths) + + mem_rc_input = torch.cat([mems, rc_block, utterance_block], dim=0) + + # In training lc_length = 0 + key_length = mem_rc_input.size(0) + lc_length + rc_input_sum = input + q = self.e2h_q(rc_input_sum) + kv = self.e2h_kv(mem_rc_input) + k, v = kv.chunk(chunks=2, dim=2) + result_qkv = (q, k, v) + input_shape = (T, B, D) + result_lengths_info = ( + mem_length, + utterance_length, + right_context_blocks_length, + key_length, + ) + if padding_mask is not None: + assert padding_mask.size(0) == B + assert padding_mask.size(1) == key_length + + return result_qkv, input_shape, result_lengths_info, padding_mask + + def prepare_attention_weights( + self, + q: Tensor, + new_k: Tensor, + new_v: Tensor, + input_shape: Tuple[int, int, int], + rpe: Optional[Tensor], + ) -> Tuple[Tensor, Tensor, Tensor]: + T, B, D = input_shape + q = ( + q.contiguous().view(-1, B * self.num_heads, self.head_dim).transpose(0, 1) + * self.scaling + ) + + k = ( + new_k.contiguous() + .view(-1, B * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + v = ( + new_v.contiguous() + .view(-1, B * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + attention_weights = torch.bmm(q, k.transpose(1, 2)) + if self.use_rpe and rpe is not None and self.rpe_v is not None: + r_k = self.rpe_k(rpe) + # [q, B*h, d] * [q, k, d] -> [B*h, q, k] + attention_weights_rpe = torch.matmul( + q.transpose(0, 1), r_k.transpose(1, 2) + ).transpose(0, 1) + attention_weights = attention_weights + attention_weights_rpe + attention_weights_float = attention_weights.float() + + return attention_weights, attention_weights_float, v + + def prepare_attention_output( + self, + attention_weights: Tensor, + attention_weights_float: Tensor, + v: Tensor, + input_shape: Tuple[int, int, int], + key_length: int, + padding_mask: Optional[Tensor], + rpe: Optional[Tensor], + ) -> Tensor: + T, B, D = input_shape + if padding_mask is not None: + attention_weights_float = attention_weights_float.view( + B, self.num_heads, T, key_length + ) + attention_weights_float = attention_weights_float.masked_fill( + padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool), float("-inf") + ) + attention_weights_float = attention_weights_float.view( + B * self.num_heads, T, key_length + ) + + if self.std_scale is not None: + attention_weights_float = attention_suppression( + attention_weights_float, self.std_scale + ) + + attention_weights_float = torch.nn.functional.softmax( + attention_weights_float, dim=-1 + ) + attention_weights = attention_weights_float.type_as(attention_weights) + + attention_probs = torch.nn.functional.dropout( + attention_weights, p=self.dropout, training=self.training + ) + + # [T, key_length, B, n_head]+ [key_length, B, n_head, d_head] + # -> [T, B, n_head, d_head] + attention = torch.bmm(attention_probs, v) + if self.use_rpe and rpe is not None and self.rpe_v is not None: + r_v = self.rpe_v(rpe) + attention_rpe = torch.matmul( + attention_probs.transpose(0, 1), r_v + ).transpose(0, 1) + + if self.rpe_old_option: + attention += attention + attention_rpe + else: + attention = attention + attention_rpe + + assert list(attention.shape) == [B * self.num_heads, T, self.head_dim] + + attention = attention.transpose(0, 1).contiguous().view(T, B, self.embed_dim) + + rc_output_memory = self.out_proj(attention) + return rc_output_memory + + @torch.jit.unused + def forward( + self, + input: Tensor, + lengths: Tensor, + mems: Tensor, + attention_mask: Tensor, + pre_mems: Optional[Tensor] = None, + left_context_key: Optional[Tensor] = None, + left_context_val: Optional[Tensor] = None, + rpe: Optional[Tensor] = None, + ) -> Tuple[Tensor, Tensor, Tensor, Tensor]: + """ + forward function for NoSegAugmentedMemoryMultiheadAttentionBmm in training. + + args: + input: formed in the following way + [right_context_0, right_contex_1, ..., seg_0, seg_1, + ..., summary_0, summary_1,..] + lengths: the length of query which is [seg_0, seg_1, ....] + mems: [mem_0, mem_1, ...]. + attention_mask: attention mask for query = [right_context, query, summary] + key = [mem, right_context, query]. This is only used for traing. + + """ + if self.use_mem: + mem_length = mems.size(0) + summary_length = mem_length + 1 + if pre_mems is not None: + mems = torch.cat([pre_mems, mems], dim=0) + else: + mem_length = 0 + summary_length = 0 + + # In training, lc_length = 0 + if left_context_key is not None: + lc_length = left_context_key.size(0) + else: + lc_length = 0 + results = self.prepare_qkv( + input=input, + mems=mems, + lengths=lengths, + summary_length=summary_length, + lc_length=lc_length, + ) + result_qkv, input_shape, result_lengths_info, padding_mask = results + q, k, v = result_qkv + ( + mem_length, + utterance_length, + right_context_blocks_length, + key_length, + ) = result_lengths_info + + if left_context_key is not None: + # add the cache key and value + new_k = torch.cat( + [ + k[: mem_length + right_context_blocks_length, :, :], + left_context_key, + k[-utterance_length:, :, :], + ], + dim=0, + ) + new_v = torch.cat( + [ + v[: mem_length + right_context_blocks_length, :, :], + left_context_val, + v[-utterance_length:, :, :], + ], + dim=0, + ) + next_k = new_k[mem_length + right_context_blocks_length :, :, :] + next_v = new_v[mem_length + right_context_blocks_length :, :, :] + else: + new_k = k + new_v = v + next_k = None + next_v = None + + attention_weights, attention_weights_float, v = self.prepare_attention_weights( + q=q, + new_k=new_k, + new_v=new_v, + input_shape=input_shape, + rpe=rpe, + ) + + # mask attention + attention_mask = attention_mask.unsqueeze(0) + attention_weights_float = attention_weights_float.masked_fill( + attention_mask, float(self.negative_inf) + ) + + rc_output_memory = self.prepare_attention_output( + attention_weights=attention_weights, + attention_weights_float=attention_weights_float, + v=v, + input_shape=input_shape, + key_length=key_length, + padding_mask=padding_mask, + rpe=rpe, + ) + + if self.use_mem: + # next_m length equals to summary length - 1 + # last memory is ignored + if self.mini_batches: + next_m = rc_output_memory[-summary_length:] + else: + next_m = rc_output_memory[-summary_length:-1] + + next_m = self.squash_mem(next_m) + # rc and output + rc_output = rc_output_memory[:-summary_length] + if not self.nonlinear_squash_mem: + next_m = torch.clamp(next_m, min=-10, max=10) + else: + next_m = mems + rc_output = rc_output_memory + + return rc_output, next_m, next_k, next_v + + @torch.jit.export + def forward_jit( + self, + input: Tensor, + lengths: Tensor, + mems: Tensor, + left_context_key: Tensor, + left_context_val: Tensor, + rpe: Optional[Tensor], + ) -> Tuple[Tensor, Tensor, Tensor, Tensor]: + """ + forward function for NoSegAugmentedMemoryMultiheadAttentionBmm in decoding. + + args: + input: formed in the following way + [right_context_0, right_contex_1, ..., seg_0, seg_1, + ..., summary_0, summary_1,..] + lengths: the length of query which is [seg_0, seg_1, ....] + mems: [mem_0, mem_1, ...]. + left_context_key: left_context for key part. This is only used for online + decoding. In training, this is empty tensor + left_context_val: left_context for value part. This is only used for online + decoding. In training, this is empty tensor + + """ + lc_length = left_context_key.size(0) + + # In decoding, summary_length = 1 or 0 + if self.use_mem: + summary_length = 1 + else: + summary_length = 0 + + results = self.prepare_qkv( + input=input, + mems=mems, + lengths=lengths, + summary_length=summary_length, + lc_length=lc_length, + ) + result_qkv, input_shape, result_lengths_info, padding_mask = results + q, k, v = result_qkv + ( + mem_length, + utterance_length, + right_context_blocks_length, + key_length, + ) = result_lengths_info + + # add the cache key and value + new_k = torch.cat( + [ + k[: mem_length + right_context_blocks_length, :, :], + left_context_key, + k[-utterance_length:, :, :], + ], + dim=0, + ) + new_v = torch.cat( + [ + v[: mem_length + right_context_blocks_length, :, :], + left_context_val, + v[-utterance_length:, :, :], + ], + dim=0, + ) + next_k = new_k[mem_length + right_context_blocks_length :, :, :] + next_v = new_v[mem_length + right_context_blocks_length :, :, :] + + attention_weights, attention_weights_float, v = self.prepare_attention_weights( + q=q, + new_k=new_k, + new_v=new_v, + input_shape=input_shape, + rpe=rpe, + ) + # In online decoding, we don't have attention mask. But we still need + # to disable the attention from summary query to memory + attention_weights_float[:, -1, :mem_length] = float(self.negative_inf) + rc_output_memory = self.prepare_attention_output( + attention_weights=attention_weights, + attention_weights_float=attention_weights_float, + v=v, + input_shape=input_shape, + key_length=key_length, + padding_mask=padding_mask, + rpe=rpe, + ) + + # In decoding, summary length is 1 + if self.use_mem: + next_m = rc_output_memory[-1:] + next_m = self.squash_mem(next_m) + # rc and output + rc_output = rc_output_memory[:-1] + if not self.nonlinear_squash_mem: + next_m = torch.clamp(next_m, min=-10, max=10) + else: + rc_output = rc_output_memory + # empty tensor as input mems + next_m = mems + + return rc_output, next_m, next_k, next_v + + def quantize_(self, params=None): + if params and "per_channel" in params and params["per_channel"]: + qconfig = per_channel_dynamic_qconfig + else: + qconfig = default_dynamic_qconfig + torch.quantization.quantize_dynamic( + self, {torch.nn.Linear: qconfig}, dtype=torch.qint8, inplace=True + ) + return self + + +class NoSegAugmentedMemoryTransformer(nn.Module): + """ + Whole utterance augmented memory transformer. + + This is not pyspeech nn layer. It is used as a module in a master layer where + multiple transformers is used. + """ + + def __init__( + self, + input_dim, + num_heads, + ffn_dim, + dropout_in_attn=0.0, + dropout_on_attn=None, + dropout_on_fc1=None, + dropout_on_fc2=None, + activation_fn="relu", + tanh_on_mem=False, + std_scale=None, + scaled_init=False, + segment_size=128, + use_mem=True, + mini_batches=False, + negative_inf="-inf", + layer_index=-1, + summarization_method="mean", + max_relative_position=0, + rpe_old_option=True, + ): + super(NoSegAugmentedMemoryTransformer, self).__init__() + + self.attention = NoSegAugmentedMemoryMultiheadAttentionBmm( + input_dim=input_dim, + num_heads=num_heads, + dropout=dropout_in_attn, + scaled_init=scaled_init, + tanh_on_mem=tanh_on_mem, + std_scale=std_scale, + use_mem=use_mem, + mini_batches=mini_batches, + negative_inf=negative_inf, + layer_index=layer_index, + max_relative_position=max_relative_position, + ) + self.dropout = nn.Dropout(dropout_on_attn) + self.pos_ff = PositionwiseFF( + input_dim=input_dim, + ffn_dim=ffn_dim, + dropout_on_fc1=dropout_on_fc1, + dropout_on_fc2=dropout_on_fc2, + activation_fn=activation_fn, + ) + self.layer_norm_pre = Fp32LayerNorm(input_dim) + self.layer_norm = Fp32LayerNorm(input_dim) + self.segment_size = segment_size + self.use_mem = use_mem + + self.memory_op = SummarizationLayer( + summarization_method, segment_size, input_dim + ) + + def set_mini_batches(self, mini_batches): + self.attention.mini_batches = mini_batches + + def gen_summary_queries(self, input): + sum_input = self.memory_op(input) + return sum_input + + def pre_attention_ops(self, input, right_context_blocks): + rc_length = right_context_blocks.size(0) + input_length = input.size(0) + + rc_and_input = torch.cat([right_context_blocks, input], dim=0) + residual_input = rc_and_input + rc_and_input = self.layer_norm_pre(rc_and_input) + + query_input = rc_and_input[-input_length:, :, :] + return rc_length, input_length, residual_input, query_input, rc_and_input + + def after_attention_ops(self, attention_output, residual_input): + output = self.dropout(attention_output) + output = output + residual_input + output = self.pos_ff(output) + output = self.layer_norm(output) + return output + + @torch.jit.export + def forward_jit( + self, + input: Tensor, + lengths: Tensor, + mems: Tensor, + left_context_key: Tensor, + left_context_val: Tensor, + right_context_blocks: Tensor, + rpe: Optional[Tensor], + ) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]: + + results = self.pre_attention_ops(input, right_context_blocks) + rc_length, input_length, residual_input, query_input, rc_and_input = results + + # In online decoding, the summary query size is always 1 or 0 + if self.use_mem: + summary_query = self.gen_summary_queries(query_input) + summary_query = summary_query[0:1, :, :] + rc_qu_su = torch.cat([rc_and_input, summary_query], dim=0) + else: + rc_qu_su = rc_and_input + + rc_output, next_m, next_k, next_v = self.attention.forward_jit( + input=rc_qu_su, + lengths=lengths, + mems=mems, + left_context_key=left_context_key, + left_context_val=left_context_val, + rpe=rpe, + ) + rc_output = self.after_attention_ops(rc_output, residual_input) + results = ( + rc_output[-input_length:, :, :], + next_m, + rc_output[0:rc_length, :, :], + next_k, + next_v, + ) + return results + + @torch.jit.unused + def forward( + self, + input, + lengths, + mems, + right_context_blocks, + attention_mask, + pre_mems, + left_context_key, + left_context_val, + rpe, + ): + + results = self.pre_attention_ops(input, right_context_blocks) + rc_length, input_length, residual_input, query_input, rc_and_input = results + if self.use_mem: + summary_query = self.gen_summary_queries(query_input) + rc_qu_su = torch.cat([rc_and_input, summary_query], dim=0) + else: + rc_qu_su = rc_and_input + + rc_output, next_m, next_k, next_v = self.attention( + input=rc_qu_su, + lengths=lengths, + mems=mems, + attention_mask=attention_mask, + pre_mems=pre_mems, + left_context_key=left_context_key, + left_context_val=left_context_val, + rpe=rpe, + ) + + # [TODO] Note memory did not go through pos_ff. What happen if we pass + # memory through the pos_ff as well? + rc_output = self.after_attention_ops(rc_output, residual_input) + results = ( + rc_output[-input_length:, :, :], + next_m, + rc_output[0:rc_length, :, :], + next_k, + next_v, + ) + + return results + + +class NoSegAugmentedMemoryTransformerEncoderLayer(FairseqEncoder): + """ + Whole utterance augmented memory transformer encoder layer. This is a master layer + where we can define multiple augmented memory transformers. There are two reasons + to setup the master layer. + 1. We only need to define once about the attention mask. All the layers in the master + layer share the same mask. + 2. pyspeech nn layer has special input and output format. Defining one master layer is + easier to passing memory between different layes inside the master layer + + args: + input_dim: input embedding dimension + num_heads: number of heads in multihead self-attention + ffn_dim: ffn dimension in FFN layer + num_layers: number of augmented memory transformer layers + dropout_in_attn: dropout used in multi-head self-attention + dropout_on_attn: dropout used for output from te multihead self-attention + dropout_on_fc1: dropout used in FFN layer for the first linear layer + dropout_on_fc2: dropout used in FFN layer for the second linear layer + segment_size: segment size for each segment + context_config: (left_context_size, right_context_size) defines the surround context size + for each segment + max_memory_size: maximum memory size used for each segment + scaled_init: whether use scaled init for weight initialization in attention layer + std_scale: if std_scale is not None. The weak attention suppression is + turned on. For std_scale = 0.5, all the attention smaller than + mean + 0.5 * std will be suppressed. + activation_fn: activation function used in FFN layer. [ReLU, GELU] supported + tanh_on_mem: whether use tanh on memory + mini_batches: use mini-btach training + negative_inf: the negative infinity value used in attention masking. default is "-inf". + For some situation, e.g. LM. it is better to use "-1e8" to avoid nan issue. + summarization_method: method to generate segment summrization embedding + max_relative_position: max relatie position for relative position embedding + rpe_old_option: To be compatible with previous model. The previous model + was trained with attention += attention + rpe. The correct equation + should be attention = attention + rpe + [TODO]: remove the rpe_old_option by the end of 2021 Q1. + + """ + + def __init__( + self, + input_dim, + num_heads, + ffn_dim, + num_layers=1, + dropout_in_attn=0.0, + dropout_on_attn=0.0, + dropout_on_fc1=0.0, + dropout_on_fc2=0.0, + segment_size=128, + context_config=(0, 0), + max_memory_size=0, + scaled_init=True, + std_scale=None, + activation_fn="relu", + tanh_on_mem=False, + mini_batches=False, + negative_inf="-inf", + deep_init=True, + summarization_method="mean", + max_relative_position=0, + rpe_old_option=True, + ): + super().__init__(None) + if input_dim % num_heads: + raise ValueError( + "input_dim ({}) must be divisible by num_heads ({})".format( + input_dim, num_heads + ) + ) + + # we used to support growing memory size. However, it will cause + # cross stream batching failure. Now we need to have exact max memory size + if max_memory_size < 0: + raise ValueError("max_memory_size must be >= 0") + + # Only assign right_context. In decoding, left context will be cached. + # No need to let the online decoder to re-assign the left context + self.left_context, self.right_context = context_config + self.segment_size = segment_size + self.memory_dim = input_dim + self.max_memory_size = max_memory_size + self.mini_batches = mini_batches + if self.max_memory_size != 0: + self.use_mem = True + else: + self.use_mem = False + + self.memory_op = SummarizationLayer( + summarization_method, segment_size, input_dim + ) + + self.layers = torch.nn.ModuleList() + self.num_layers = num_layers + self.max_relative_position = max_relative_position + if self.max_relative_position > 0: + self.use_rpe = True + else: + self.use_rpe = False + for i in range(self.num_layers): + if deep_init: + layer_index = i + else: + layer_index = -1 + + self.layers.append( + NoSegAugmentedMemoryTransformer( + num_heads=num_heads, + input_dim=input_dim, + ffn_dim=ffn_dim, + dropout_in_attn=dropout_in_attn, + dropout_on_attn=dropout_on_attn, + dropout_on_fc1=dropout_on_fc1, + dropout_on_fc2=dropout_on_fc2, + segment_size=segment_size, + std_scale=std_scale, + activation_fn=activation_fn, + tanh_on_mem=tanh_on_mem, + scaled_init=scaled_init, + use_mem=self.use_mem, + mini_batches=mini_batches, + negative_inf=negative_inf, + layer_index=layer_index, + summarization_method=summarization_method, + max_relative_position=max_relative_position, + rpe_old_option=rpe_old_option, + ) + ) + + def set_mini_batches(self, mini_batches): + # handy function only used for unit test + self.mini_batches = mini_batches + for layer in self.layers: + layer.set_mini_batches(mini_batches) + + def _get_relative_position( + self, + input: Tensor, + max_relative_position: int, + left_context_length: int, + past_length: int, + is_decoding: bool, + ): + # For training, we copy the right context to the start of the utterance + # First dimension in distance is corresponding to query. + # [right context, utterance, summary vector] + # Second dimension in distance is corresponding to key. + # [Memory bank, right context, utterance] + # For summary vector in query part, the distance with + # all other position is 2*max_position. For memory bank in key, + # the distance with all other positions is 0. + + T, B, D = input.shape + num_segs = math.ceil((T - self.right_context) / self.segment_size) + + # utterance + u_st = past_length * self.segment_size + u_ed = u_st + T + utterance_ranges = torch.arange(u_st, u_ed - self.right_context) + + # left context. Only in minibatch or decoding + left_context_ranges = torch.arange(u_st - left_context_length, u_st) + + # Right context block + # right context + utterance + right_context_blocks = [] + for i in range(0, num_segs - 1): + st = (i + 1) * self.segment_size + u_st + ed = st + self.right_context + assert ed < u_ed + temp = torch.arange(st, ed) + right_context_blocks.append(temp) + right_context_blocks.append(torch.arange(u_ed - self.right_context, u_ed)) + right_context_ranges = torch.cat(right_context_blocks) + + if self.use_mem: + # Memory bank + # The position for memory -n, .., -1 + if is_decoding: + memory_size = min(past_length, self.max_memory_size) + else: + memory_size = num_segs + past_length - 1 + memory_bank_ranges = torch.arange( + -max_relative_position - 1, -max_relative_position - 1 - memory_size, -1 + ) + + # summary vector + # The position for summary vector as the T+max_relative_position+1. + # After the clamping, the relative position is max_relative_position + summary_pos_st = u_ed + max_relative_position + 1 + summary_vector_ranges = torch.arange( + summary_pos_st, summary_pos_st + num_segs + ) + + key_ranges = torch.cat( + [ + memory_bank_ranges, + right_context_ranges, + left_context_ranges, + utterance_ranges, + ] + ) + + query_ranges = torch.cat( + [right_context_ranges, utterance_ranges, summary_vector_ranges] + ) + else: + key_ranges = torch.cat( + [right_context_ranges, left_context_ranges, utterance_ranges] + ) + + query_ranges = torch.cat([right_context_ranges, utterance_ranges]) + + distance = key_ranges[None, :] - query_ranges[:, None] + distance_clamp = ( + torch.clamp(distance, -max_relative_position, max_relative_position) + + max_relative_position + ) + distance_clamp = distance_clamp.to(input.device).long().detach() + return distance_clamp + + def _get_attention_mask(self, input, past_length=0, left_context_cache=0): + # attention mask for each query contains three parts: + # 1. memory part + # 2. left_context + segment + # 3. right_context_block + # so for each segment and its correspoinding right context block, + # the attention matrix is formed by 9 parts: + # [0, m, 0, 0, right_context, 0, 0, seg, 0] + # [before memory, memory, after memory, before right context, right_context, + # after right context, before seg, seg, after seg] + # + # Query is formed in the way as [right_context_blocks, utterance, summary] + # + # Note: put m and right_context before segment is convenient + # for padding_mask operation. + # Key lengths = m_length + right_context_block_length + lengths + utterance_length, batch_size, _ = input.shape + summary_length = math.ceil(utterance_length / self.segment_size) + num_segs = summary_length + rc_length = self.right_context * num_segs + rc = self.right_context + lc = self.left_context + + # using mini-batches, there is left context cache available for current + # sequence. + lcc = left_context_cache + + # max_memory_size is 0 then we don't have memory and summary + # past_length is the memory carry from previous sequence + if self.use_mem: + mem_length = num_segs - 1 + past_length + else: + mem_length = 0 + rc_mask = [] + query_mask = [] + summary_mask = [] + for j in range(0, num_segs): + ssize = min(self.segment_size, utterance_length - j * self.segment_size) + + rc_size = rc + rc_mat = [] + q_mat = [] + s_mat = [] + m_start = max(j + past_length - self.max_memory_size, 0) + + # max_memory_size is 0, then we don't use memory + if self.use_mem: + # part 0: before memory + rc_mat.append(input.new_zeros(rc_size, m_start)) + q_mat.append(input.new_zeros(ssize, m_start)) + s_mat.append(input.new_zeros(1, m_start)) + + # part 1: memory + col_1 = j + past_length - m_start + rc_mat.append(torch.ones(rc_size, col_1, device=input.device)) + q_mat.append(torch.ones(ssize, col_1, device=input.device)) + # based on D22875746, disable summary query attention + # on memeory is better for long form utterance + s_mat.append(input.new_zeros(1, col_1)) + + # part 2: after memory + col_2 = mem_length - (j + past_length) + rc_mat.append(input.new_zeros(rc_size, col_2)) + q_mat.append(input.new_zeros(ssize, col_2)) + s_mat.append(input.new_zeros(1, col_2)) + + # part 3: before right context + rc_start = j * rc + rc_mat.append(input.new_zeros(rc_size, rc_start)) + q_mat.append(input.new_zeros(ssize, rc_start)) + s_mat.append(input.new_zeros(1, rc_start)) + + # part 4: right context + rc_end = rc_start + rc + col_4 = rc + rc_mat.append(torch.ones(rc_size, col_4, device=input.device)) + q_mat.append(torch.ones(ssize, col_4, device=input.device)) + s_mat.append(torch.ones(1, col_4, device=input.device)) + + # part 5: after right context + col_5 = rc_length - rc_end + rc_mat.append(input.new_zeros(rc_size, col_5)) + q_mat.append(input.new_zeros(ssize, col_5)) + s_mat.append(input.new_zeros(1, col_5)) + + # part 6: before query segment + seg_start = max(j * self.segment_size + lcc - lc, 0) + rc_mat.append(input.new_zeros(rc_size, seg_start)) + q_mat.append(input.new_zeros(ssize, seg_start)) + s_mat.append(input.new_zeros(1, seg_start)) + + # part 7: query segment + # note: right context is put in right context block + # here we only need to consider about left context + seg_end = min((j + 1) * self.segment_size + lcc, utterance_length + lcc) + col_7 = seg_end - seg_start + rc_mat.append(torch.ones(rc_size, col_7, device=input.device)) + q_mat.append(torch.ones(ssize, col_7, device=input.device)) + s_mat.append(torch.ones(1, col_7, device=input.device)) + + # part 8: after query segment + col_8 = utterance_length + lcc - seg_end + rc_mat.append(input.new_zeros(rc_size, col_8)) + q_mat.append(input.new_zeros(ssize, col_8)) + s_mat.append(input.new_zeros(1, col_8)) + + rc_mask.append(torch.cat(rc_mat, dim=1)) + query_mask.append(torch.cat(q_mat, dim=1)) + summary_mask.append(torch.cat(s_mat, dim=1)) + + # no memory, then we don't need summary either + if self.use_mem: + attention_mask = ( + 1 + - torch.cat( + [ + torch.cat(rc_mask, dim=0), + torch.cat(query_mask, dim=0), + torch.cat(summary_mask, dim=0), + ], + dim=0, + ) + ).to(torch.bool) + else: + attention_mask = ( + 1 + - torch.cat( + [torch.cat(rc_mask, dim=0), torch.cat(query_mask, dim=0)], dim=0 + ) + ).to(torch.bool) + + return attention_mask + + @torch.jit.export + def init_state( + self, batch_size: int, device: Optional[Device] = None + ) -> List[Tensor]: + empty_memory = torch.zeros( + self.num_layers, + self.max_memory_size, + batch_size, + self.memory_dim, + device=device, + ) + left_context_key = torch.zeros( + self.num_layers, + self.left_context, + batch_size, + self.memory_dim, + device=device, + ) + left_context_val = torch.zeros( + self.num_layers, + self.left_context, + batch_size, + self.memory_dim, + device=device, + ) + past_length = torch.zeros(1, batch_size, dtype=torch.int32, device=device) + + return [empty_memory, left_context_key, left_context_val, past_length] + + @torch.jit.export + def batch_state(self, states: List[List[Tensor]]) -> List[Tensor]: + if len(states) == 0: + return [] + batched_m = [] + batched_lc_key = [] + batched_lc_val = [] + batched_past_length = [] + for state in states: + if len(state) == 0: + continue + m, lc_key, lc_val, past_length = state + batched_m.append(m) + batched_lc_key.append(lc_key) + batched_lc_val.append(lc_val) + batched_past_length.append(past_length) + + if ( + (len(batched_m) == 0) + or (len(batched_lc_key) == 0) + or (len(batched_lc_val) == 0) + or (len(batched_past_length) == 0) + ): + return [ + torch.tensor([]), + torch.tensor([]), + torch.tensor([]), + torch.tensor([]), + ] + + batched_m = torch.cat(batched_m, dim=2) + batched_lc_key = torch.cat(batched_lc_key, dim=2) + batched_lc_val = torch.cat(batched_lc_val, dim=2) + batched_past_length = torch.cat(batched_past_length, dim=1) + return [batched_m, batched_lc_key, batched_lc_val, batched_past_length] + + @torch.jit.export + def reorder_state(self, state: List[Tensor], indices: Tensor) -> List[Tensor]: + if len(state) == 0: + return [] + m, lc_key, lc_val, past_length = state + indices = indices.to(device=m.device) + reord_m = torch.index_select(m, 2, indices) + reord_lc_key = torch.index_select(lc_key, 2, indices) + reord_lc_val = torch.index_select(lc_val, 2, indices) + reord_past_length = torch.index_select(past_length, 1, indices) + return [reord_m, reord_lc_key, reord_lc_val, reord_past_length] + + @torch.jit.export + def reset_state(self, state: List[Tensor], indices: Tensor) -> List[Tensor]: + m, lc_key, lc_val, past_length = state + m = m.index_fill(dim=2, index=indices, value=0.0) + lc_key = lc_key.index_fill(dim=2, index=indices, value=0.0) + lc_val = lc_val.index_fill(dim=2, index=indices, value=0.0) + past_length = past_length.index_fill(dim=1, index=indices, value=0) + + return [m, lc_key, lc_val, past_length] + + @torch.jit.export + def state_size(self) -> int: + return 4 + + @torch.jit.export + def batch_size_in_state( + self, state: Optional[List[Tensor]], sloppy: bool = True + ) -> Optional[int]: + if state is None: + return None + return state[0].size(2) + + def gen_summary_queries(self, input): + sum_input = self.memory_op(input) + return sum_input + + def _gen_right_context_padded_input(self, input): + # This function deals with input that is already + # padded with right context (e.g. minibatch training) + right_context_blocks = [] + T, B, D = input.shape + num_segs = math.ceil((T - self.right_context) / self.segment_size) + for i in range(0, num_segs - 1): + st = (i + 1) * self.segment_size + ed = st + self.right_context + assert ed < T + temp = input[st:ed, :, :] + right_context_blocks.append(temp) + + # last segment right context is already available + right_context_blocks.append(input[T - self.right_context :, :, :]) + return torch.cat(right_context_blocks, dim=0) + + def _gen_segs_right_context(self, input, lengths): + segments = [] + T, B, D = input.size() + nT = T - self.right_context + + # assume input is right context padded + num_segs = math.ceil(nT / self.segment_size) + # pad zeros to the utterance to make sure each + # segment has the same right context. For the + for i in range(0, num_segs - 1): + st = i * self.segment_size + ed = min(T, st + self.segment_size + self.right_context) + temp = input[st:ed, :, :] + rest_lengths = torch.clamp( + lengths - self.segment_size, min=0, max=nT - (i + 1) * self.segment_size + ) + segments.append((temp, lengths - rest_lengths + self.right_context)) + lengths = rest_lengths + + last_seg = input[st + self.segment_size :, :, :] + segments.append((last_seg, rest_lengths + self.right_context)) + + return segments + + @torch.jit.unused + def forward( + self, input: Tensor, padding_masks: Tensor, state: Optional[List[Tensor]] = None + ) -> Tuple[Tensor, Tensor, List[Tensor], List[Tensor]]: + # Xutai: originally the second argument is lengths. + lengths = (~padding_masks).sum(dim=1).long() + # mini batch training. + if self.mini_batches: + return self.forward_mini_batches(input, lengths, state) + + # regular full sequence training. Note, assume the right context in provided + # in the input. + T, B, D = input.size() + right_context_blocks = self._gen_right_context_padded_input(input) + + # generate the relative positional embedding + if self.use_rpe: + rpe = self._get_relative_position( + input=input, + max_relative_position=self.max_relative_position, + left_context_length=0, + past_length=0, + is_decoding=False, + ) + else: + rpe = None + input = input[: T - self.right_context, :, :] + + attention_mask = self._get_attention_mask(input) + + # firt layer use each segment mean as memory + # ignore the last one seg average + if self.use_mem: + mems = self.gen_summary_queries(input)[:-1, :, :] + else: + mems = torch.zeros(0, input.size(1), input.size(2), device=input.device) + mems = mems.type_as(input) + + output = input + all_outputs = [] + + for layer in self.layers: + output, mems, right_context_blocks, _, _ = layer( + input=output, + lengths=lengths, + attention_mask=attention_mask, + mems=mems, + right_context_blocks=right_context_blocks, + pre_mems=None, + left_context_key=None, + left_context_val=None, + rpe=rpe, + ) + all_outputs.append(output) + return output, padding_masks, [], all_outputs + + def forward_jit_mini_batch_init( + self, + seg: Tensor, + state: Optional[List[Tensor]] = None, + is_decoding: bool = False, + ): + # Prepare state. In whole sequence training, state is ignored. + # For minibatch training, we need to prepare state + if state is None: + state = self.init_state(batch_size=seg.size(1), device=seg.device) + if seg.dtype == torch.half: + state = [state[0].half(), state[1].half(), state[2].half(), state[3]] + + if self.use_mem: + # note input average only on seg, not on right context + # first layer use each segmetn mean as memory. the last + # one segment average is used in state + full_mems = self.gen_summary_queries(seg) + if is_decoding: + mems = full_mems[0:1, :, :] + state_mems = torch.cat([state[0][0], mems], dim=0) + else: + mems = full_mems[:-1, :, :] + state_mems = torch.cat([state[0][0], full_mems], dim=0) + else: + mems = state[0][0] + state_mems = mems + + # track processed segment number or memory number + # the same batch as the same bumber of past length + past_length = state[3][0][0].item() + past_left_context = min(past_length * self.segment_size, self.left_context) + past_length = min(self.max_memory_size, past_length) + + return state, mems, state_mems, past_length, past_left_context + + def state_update_before( + self, layer: int, state: List[Tensor], past_length: int, past_left_context: int + ): + pre_mems = state[0][layer][self.max_memory_size - past_length :, :, :] + lc_key = state[1][layer][self.left_context - past_left_context :, :, :] + lc_val = state[2][layer][self.left_context - past_left_context :, :, :] + return pre_mems, lc_key, lc_val + + def state_update_after( + self, + layer: int, + state: List[Tensor], + mems: Tensor, + next_key: Tensor, + next_val: Tensor, + mems_list: List[Tensor], + lc_key_list: List[Tensor], + lc_val_list: List[Tensor], + ): + # mems is used for next layer + if layer < self.num_layers - 1: + state_mems = torch.cat([state[0][layer + 1], mems], dim=0) + mems_list.append(state_mems[-self.max_memory_size :, :, :]) + + # when mems pass to next sequence, we need the last memory. when mems + # use for the next layer, we can ignore the last memory + mems = mems[:-1, :, :] + + # note state[1][i] and state[2][i] original length equals to self.left_context + new_k = torch.cat([state[1][layer], next_key], dim=0) + new_v = torch.cat([state[2][layer], next_val], dim=0) + lc_key_list.append(new_k[-self.left_context :, :, :]) + lc_val_list.append(new_v[-self.left_context :, :, :]) + return mems_list, lc_key_list, lc_val_list, mems + + def state_update_after_loop( + self, + state: List[Tensor], + mems_list: List[Tensor], + lc_key_list: List[Tensor], + lc_val_list: List[Tensor], + update_length: int, + ): + state[0] = torch.stack(mems_list, dim=0) + state[1] = torch.stack(lc_key_list, dim=0) + state[2] = torch.stack(lc_val_list, dim=0) + state[3] = state[3] + update_length + return state + + @torch.jit.unused + def forward_mini_batches( + self, input: Tensor, lengths: Tensor, state: Optional[List[Tensor]] = None + ) -> Tuple[Tensor, Tensor, List[Tensor], List[Tensor]]: + T, B, D = input.size() + + # input without right context + seg = input[: T - self.right_context, :, :] + + # get right context blocks + right_context_blocks = self._gen_right_context_padded_input(input) + + mems_list = [] + lc_key_list = [] + lc_val_list = [] + results = self.forward_jit_mini_batch_init(seg, state, False) + state, mems, state_mems, past_length, past_left_context = results + + # relative position embedding + if self.use_rpe: + rpe = self._get_relative_position( + input=input, + max_relative_position=self.max_relative_position, + left_context_length=past_left_context, + past_length=past_length, + is_decoding=False, + ) + else: + rpe = None + + # get attention mask based on seg (not include right context) and available + # left context + attention_mask = self._get_attention_mask(seg, past_length, past_left_context) + mems_list.append(state_mems[-self.max_memory_size :, :, :]) + output = seg + i = 0 + all_outputs = [] + for layer in self.layers: + # In order to make cross stream batching work, mem, left context key + # and left context value in the state should always be the same shape. + # We use the past length to track the processed segment number. In this + # way, we take out the essential memory, left context key and left + # context val from the state. After finish the forward for current segment + # we add the new memory, left context key and left context value into the + # staate and trim out the oldest part to keep the shape consistent. + pre_mems, lc_key, lc_val = self.state_update_before( + i, state, past_length, past_left_context + ) + + output, mems, right_context_blocks, next_key, next_val = layer.forward( + input=output, + lengths=lengths, + attention_mask=attention_mask, + mems=mems, + right_context_blocks=right_context_blocks, + pre_mems=pre_mems, + left_context_key=lc_key, + left_context_val=lc_val, + rpe=rpe, + ) + all_outputs.append(output) + mems_list, lc_key_list, lc_val_list, mems = self.state_update_after( + layer=i, + state=state, + mems=mems, + next_key=next_key, + next_val=next_val, + mems_list=mems_list, + lc_key_list=lc_key_list, + lc_val_list=lc_val_list, + ) + + i += 1 + + # update state + update_length = math.ceil((T - self.right_context) / self.segment_size) + state = self.state_update_after_loop( + state=state, + mems_list=mems_list, + lc_key_list=lc_key_list, + lc_val_list=lc_val_list, + update_length=update_length, + ) + + return output, lengths, state, all_outputs + + def forward_jit_test( + self, input: Tensor, lengths: Tensor, state: Optional[List[Tensor]] = None + ) -> Tuple[Tensor, Tensor, List[Tensor]]: + """ + This one simulate sequence encoder forward jit. This is for unit test purpose. + It is not used in training or decoding. Note, extra_right_context is set in + the model. In unit test, input = [utterance, right_context], lengths = + [utterance_length]. + args: + input: input utterance + lengths: utterance input length + state: None here. input is whole utterance + """ + # [TODO] sequence_to_segment has bug in lengths. + seg_src_tokens_lengths = self._gen_segs_right_context(input, lengths) + + seg_enc_tokens_lengths: List[Tuple[Tensor, Tensor]] = [] + state: Optional[List[Tensor]] = None + for seg_src_tokens, seg_src_lengths in seg_src_tokens_lengths: + seg_enc_tokens, seg_enc_lengths, state = self.forward_jit( + input=seg_src_tokens, lengths=seg_src_lengths, state=state + ) + seg_enc_tokens_lengths.append((seg_enc_tokens, seg_enc_lengths)) + + enc_tokens, enc_lengths = segments_to_sequence( + segments=seg_enc_tokens_lengths, time_axis=0 + ) + + state = [] # returns trivial state + + return enc_tokens, enc_lengths, state + + @torch.jit.export + def forward_jit( + self, input: Tensor, lengths: Tensor, state: Optional[List[Tensor]] = None + ) -> Tuple[Tensor, Tensor, List[Tensor]]: + """ + Forward helper for online decoding. + + args: + input: [seg, right_context]. We assume in online we + always padding the right context to the preset right context size. + For the last segment, we may have short segment size, but right + context size is the same as other segments + lengths: utterance input length is the utterance segment length and + right context size + state: [memory, left_context_key, left_context_val]. To improve throughput, + in addition to memory, we also cache key and value for left_context in + multihead self-attention + """ + # In online decoding, input = [segment, right_context] + # Lengths = [segment_length, right_context_length] + # so we need strip right context in output + T, B, D = input.size() + rc_str = T - self.right_context + rc_end = T + right_context_blocks = input[rc_str:rc_end, :, :] + seg = input[:rc_str, :, :] + lengths = torch.clamp(lengths - self.right_context, min=0) + mems_list = [] + lc_key_list = [] + lc_val_list = [] + + results = self.forward_jit_mini_batch_init(seg, state, True) + state, mems, state_mems, past_length, past_left_context = results + + # relative position embedding + if self.use_rpe: + rpe = self._get_relative_position( + input=input, + max_relative_position=self.max_relative_position, + left_context_length=past_left_context, + past_length=past_length, + is_decoding=True, + ) + else: + rpe = None + + # memory for first layer. + mems_list.append(state_mems[-self.max_memory_size :, :, :]) + output = seg + i = 0 + for layer in self.layers: + # In order to make cross stream batching work, mem, left context key + # and left context value in the state should always be the same shape. + # We use the past length to track the processed segment number. In this + # way, we take out the essential memory, left context key and left + # context val from the state. After finish the forward for current segment + # we add the new memory, left context key and left context value into the + # staate and trim out the oldest part to keep the shape consistent. + true_mems, lc_key, lc_val = self.state_update_before( + layer=i, + state=state, + past_length=past_length, + past_left_context=past_left_context, + ) + + output, mems, right_context_blocks, next_key, next_val = layer.forward_jit( + input=output, + lengths=lengths, + mems=true_mems, + right_context_blocks=right_context_blocks, + left_context_key=lc_key, + left_context_val=lc_val, + rpe=rpe, + ) + # mems is used for next layer + mems_list, lc_key_list, lc_val_list, _ = self.state_update_after( + layer=i, + state=state, + mems_list=mems_list, + mems=mems, + next_key=next_key, + next_val=next_val, + lc_key_list=lc_key_list, + lc_val_list=lc_val_list, + ) + i += 1 + + # update state + state = self.state_update_after_loop( + state=state, + mems_list=mems_list, + lc_key_list=lc_key_list, + lc_val_list=lc_val_list, + update_length=1, + ) + + return output, lengths, state + + def quantize_(self, params=None): + if params and "per_channel" in params and params["per_channel"]: + qconfig = per_channel_dynamic_qconfig + else: + qconfig = default_dynamic_qconfig + torch.quantization.quantize_dynamic( + self, {torch.nn.Linear: qconfig}, dtype=torch.qint8, inplace=True + ) + return self + + +# ------------------------------------------------------------------------------ +# Emformer encoder for seq2seq model +# This is a wrapper over the original emformer +# ------------------------------------------------------------------------------ +def emformer_encoder(klass): + class SpeechEncoder(klass): + def __init__(self, args): + super().__init__(args) + stride = SpeechEncoder.conv_layer_stride(args) + trf_left_context = args.segment_left_context // stride + trf_right_context = args.segment_right_context // stride + context_config = [trf_left_context, trf_right_context] + self.transformer_layers = nn.ModuleList( + [ + NoSegAugmentedMemoryTransformerEncoderLayer( + input_dim=args.encoder_embed_dim, + num_heads=args.encoder_attention_heads, + ffn_dim=args.encoder_ffn_embed_dim, + num_layers=args.encoder_layers, + dropout_in_attn=args.dropout, + dropout_on_attn=args.dropout, + dropout_on_fc1=args.dropout, + dropout_on_fc2=args.dropout, + activation_fn=args.activation_fn, + context_config=context_config, + segment_size=args.segment_length, + max_memory_size=args.max_memory_size, + scaled_init=True, # TODO: use constant for now. + tanh_on_mem=args.amtrf_tanh_on_mem, + ) + ] + ) + + def forward(self, src_tokens, src_lengths): + encoder_out = super().forward(src_tokens, src_lengths) + output = encoder_out["encoder_out"][0] + encoder_padding_masks = encoder_out["encoder_padding_mask"][0] + + # This is because that in the original implementation + # the output didn't consider the last segment as right context. + encoder_padding_masks = encoder_padding_masks[:, : output.size(0)] + + return { + "encoder_out": [output], + "encoder_padding_mask": [encoder_padding_masks], + "encoder_embedding": [], + "encoder_states": [], + "src_tokens": [], + "src_lengths": [], + } + + @staticmethod + def conv_layer_stride(args): + # TODO: make it configurable from the args + return 4 + + SpeechEncoder.__name__ = klass.__name__ + return SpeechEncoder diff --git a/fairseq/fairseq/models/speech_to_text/s2t_transformer.py b/fairseq/fairseq/models/speech_to_text/s2t_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..aff9d0ffc7b7e671c476ff28d1cd945e9ff41519 --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/s2t_transformer.py @@ -0,0 +1,502 @@ +#!/usr/bin/env python3 + +import logging +import math +from typing import Dict, List, Optional, Tuple +from pathlib import Path + +import torch +import torch.nn as nn +from fairseq import checkpoint_utils, utils +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import Embedding, TransformerDecoder +from fairseq.modules import ( + FairseqDropout, + LayerNorm, + PositionalEmbedding, + TransformerEncoderLayer, +) +from torch import Tensor + + +logger = logging.getLogger(__name__) + + +class Conv1dSubsampler(nn.Module): + """Convolutional subsampler: a stack of 1D convolution (along temporal + dimension) followed by non-linear activation via gated linear units + (https://arxiv.org/abs/1911.08460) + + Args: + in_channels (int): the number of input channels + mid_channels (int): the number of intermediate channels + out_channels (int): the number of output channels + kernel_sizes (List[int]): the kernel size for each convolutional layer + """ + + def __init__( + self, + in_channels: int, + mid_channels: int, + out_channels: int, + kernel_sizes: List[int] = (3, 3), + ): + super(Conv1dSubsampler, self).__init__() + self.n_layers = len(kernel_sizes) + self.conv_layers = nn.ModuleList( + nn.Conv1d( + in_channels if i == 0 else mid_channels // 2, + mid_channels if i < self.n_layers - 1 else out_channels * 2, + k, + stride=2, + padding=k // 2, + ) + for i, k in enumerate(kernel_sizes) + ) + + def get_out_seq_lens_tensor(self, in_seq_lens_tensor): + out = in_seq_lens_tensor.clone() + for _ in range(self.n_layers): + out = ((out.float() - 1) / 2 + 1).floor().long() + return out + + def forward(self, src_tokens, src_lengths): + bsz, in_seq_len, _ = src_tokens.size() # B x T x (C x D) + x = src_tokens.transpose(1, 2).contiguous() # -> B x (C x D) x T + for conv in self.conv_layers: + x = conv(x) + x = nn.functional.glu(x, dim=1) + _, _, out_seq_len = x.size() + x = x.transpose(1, 2).transpose(0, 1).contiguous() # -> T x B x (C x D) + return x, self.get_out_seq_lens_tensor(src_lengths) + + +@register_model("s2t_transformer") +class S2TTransformerModel(FairseqEncoderDecoderModel): + """Adapted Transformer model (https://arxiv.org/abs/1706.03762) for + speech-to-text tasks. The Transformer encoder/decoder remains the same. + A trainable input subsampler is prepended to the Transformer encoder to + project inputs into the encoder dimension as well as downsample input + sequence for computational efficiency.""" + + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # input + parser.add_argument( + "--conv-kernel-sizes", + type=str, + metavar="N", + help="kernel sizes of Conv1d subsampling layers", + ) + parser.add_argument( + "--conv-channels", + type=int, + metavar="N", + help="# of channels in Conv1d subsampling layers", + ) + # Transformer + parser.add_argument( + "--activation-fn", + type=str, + default="relu", + choices=utils.get_available_activation_fns(), + help="activation function to use", + ) + parser.add_argument( + "--dropout", type=float, metavar="D", help="dropout probability" + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights", + ) + parser.add_argument( + "--activation-dropout", + "--relu-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN.", + ) + parser.add_argument( + "--encoder-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension", + ) + parser.add_argument( + "--encoder-ffn-embed-dim", + type=int, + metavar="N", + help="encoder embedding dimension for FFN", + ) + parser.add_argument( + "--encoder-layers", type=int, metavar="N", help="num encoder layers" + ) + parser.add_argument( + "--encoder-attention-heads", + type=int, + metavar="N", + help="num encoder attention heads", + ) + parser.add_argument( + "--encoder-normalize-before", + action="store_true", + help="apply layernorm before each encoder block", + ) + parser.add_argument( + "--decoder-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension", + ) + parser.add_argument( + "--decoder-ffn-embed-dim", + type=int, + metavar="N", + help="decoder embedding dimension for FFN", + ) + parser.add_argument( + "--decoder-layers", type=int, metavar="N", help="num decoder layers" + ) + parser.add_argument( + "--decoder-attention-heads", + type=int, + metavar="N", + help="num decoder attention heads", + ) + parser.add_argument( + "--decoder-normalize-before", + action="store_true", + help="apply layernorm before each decoder block", + ) + parser.add_argument( + "--share-decoder-input-output-embed", + action="store_true", + help="share decoder input and output embeddings", + ) + parser.add_argument( + "--layernorm-embedding", + action="store_true", + help="add layernorm to embedding", + ) + parser.add_argument( + "--no-scale-embedding", + action="store_true", + help="if True, dont scale embeddings", + ) + parser.add_argument( + "--load-pretrained-encoder-from", + type=str, + metavar="STR", + help="model to take encoder weights from (for initialization)", + ) + parser.add_argument( + '--encoder-freezing-updates', + type=int, + metavar='N', + help='freeze encoder for first N updates' + ) + + @classmethod + def build_encoder(cls, args): + encoder = S2TTransformerEncoder(args) + pretraining_path = getattr(args, "load_pretrained_encoder_from", None) + if pretraining_path is not None: + if not Path(pretraining_path).exists(): + logger.warning( + f"skipped pretraining because {pretraining_path} does not exist" + ) + else: + encoder = checkpoint_utils.load_pretrained_component_from_model( + component=encoder, checkpoint=pretraining_path + ) + logger.info(f"loaded pretrained encoder from: {pretraining_path}") + return encoder + + @classmethod + def build_decoder(cls, args, task, embed_tokens): + return TransformerDecoderScriptable(args, task.target_dictionary, embed_tokens) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + def build_embedding(dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + return Embedding(num_embeddings, embed_dim, padding_idx) + + decoder_embed_tokens = build_embedding( + task.target_dictionary, args.decoder_embed_dim + ) + encoder = cls.build_encoder(args) + decoder = cls.build_decoder(args, task, decoder_embed_tokens) + return cls(encoder, decoder) + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = self.get_normalized_probs_scriptable(net_output, log_probs, sample) + lprobs.batch_first = True + return lprobs + + def forward(self, src_tokens, src_lengths, prev_output_tokens): + """ + The forward method inherited from the base class has a **kwargs + argument in its input, which is not supported in torchscript. This + method overwrites the forward method definition without **kwargs. + """ + encoder_out = self.encoder(src_tokens=src_tokens, src_lengths=src_lengths) + decoder_out = self.decoder( + prev_output_tokens=prev_output_tokens, encoder_out=encoder_out + ) + return decoder_out + + +class S2TTransformerEncoder(FairseqEncoder): + """Speech-to-text Transformer encoder that consists of input subsampler and + Transformer encoder.""" + + def __init__(self, args): + super().__init__(None) + + self.encoder_freezing_updates = args.encoder_freezing_updates + self.num_updates = 0 + + self.dropout_module = FairseqDropout( + p=args.dropout, module_name=self.__class__.__name__ + ) + self.embed_scale = math.sqrt(args.encoder_embed_dim) + if args.no_scale_embedding: + self.embed_scale = 1.0 + self.padding_idx = 1 + + self.subsample = Conv1dSubsampler( + args.input_feat_per_channel * args.input_channels, + args.conv_channels, + args.encoder_embed_dim, + [int(k) for k in args.conv_kernel_sizes.split(",")], + ) + + self.embed_positions = PositionalEmbedding( + args.max_source_positions, args.encoder_embed_dim, self.padding_idx + ) + + self.transformer_layers = nn.ModuleList( + [TransformerEncoderLayer(args) for _ in range(args.encoder_layers)] + ) + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(args.encoder_embed_dim) + else: + self.layer_norm = None + + def _forward(self, src_tokens, src_lengths, return_all_hiddens=False): + x, input_lengths = self.subsample(src_tokens, src_lengths) + x = self.embed_scale * x + + encoder_padding_mask = lengths_to_padding_mask(input_lengths) + positions = self.embed_positions(encoder_padding_mask).transpose(0, 1) + x += positions + x = self.dropout_module(x) + + encoder_states = [] + + for layer in self.transformer_layers: + x = layer(x, encoder_padding_mask) + if return_all_hiddens: + encoder_states.append(x) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [encoder_padding_mask] if encoder_padding_mask.any() else [], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + } + + def forward(self, src_tokens, src_lengths, return_all_hiddens=False): + if self.num_updates < self.encoder_freezing_updates: + with torch.no_grad(): + x = self._forward(src_tokens, src_lengths, + return_all_hiddens=return_all_hiddens) + else: + x = self._forward(src_tokens, src_lengths, + return_all_hiddens=return_all_hiddens) + return x + + def reorder_encoder_out(self, encoder_out, new_order): + new_encoder_out = ( + [] if len(encoder_out["encoder_out"]) == 0 + else [x.index_select(1, new_order) for x in encoder_out["encoder_out"]] + ) + + new_encoder_padding_mask = ( + [] if len(encoder_out["encoder_padding_mask"]) == 0 + else [x.index_select(0, new_order) for x in encoder_out["encoder_padding_mask"]] + ) + + new_encoder_embedding = ( + [] if len(encoder_out["encoder_embedding"]) == 0 + else [x.index_select(0, new_order) for x in encoder_out["encoder_embedding"]] + ) + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], # B x T + "src_lengths": [], # B x 1 + } + + def set_num_updates(self, num_updates): + super().set_num_updates(num_updates) + self.num_updates = num_updates + + +class TransformerDecoderScriptable(TransformerDecoder): + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + # call scriptable method from parent class + x, _ = self.extract_features_scriptable( + prev_output_tokens, + encoder_out, + incremental_state, + full_context_alignment, + alignment_layer, + alignment_heads, + ) + return x, None + + +@register_model_architecture(model_name="s2t_transformer", arch_name="s2t_transformer") +def base_architecture(args): + args.encoder_freezing_updates = getattr(args, "encoder_freezing_updates", 0) + # Convolutional subsampler + args.conv_kernel_sizes = getattr(args, "conv_kernel_sizes", "5,5") + args.conv_channels = getattr(args, "conv_channels", 1024) + # Transformer + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.dropout = getattr(args, "dropout", 0.1) + args.attention_dropout = getattr(args, "attention_dropout", args.dropout) + args.activation_dropout = getattr(args, "activation_dropout", args.dropout) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_s") +def s2t_transformer_s(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 256 * 8) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.dropout = getattr(args, "dropout", 0.1) + base_architecture(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_xs") +def s2t_transformer_xs(args): + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.decoder_layers = getattr(args, "decoder_layers", 3) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 256 * 4) + args.dropout = getattr(args, "dropout", 0.3) + s2t_transformer_s(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_sp") +def s2t_transformer_sp(args): + args.encoder_layers = getattr(args, "encoder_layers", 16) + s2t_transformer_s(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_m") +def s2t_transformer_m(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 512 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.dropout = getattr(args, "dropout", 0.15) + base_architecture(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_mp") +def s2t_transformer_mp(args): + args.encoder_layers = getattr(args, "encoder_layers", 16) + s2t_transformer_m(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_l") +def s2t_transformer_l(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024 * 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.2) + base_architecture(args) + + +@register_model_architecture("s2t_transformer", "s2t_transformer_lp") +def s2t_transformer_lp(args): + args.encoder_layers = getattr(args, "encoder_layers", 16) + s2t_transformer_l(args) diff --git a/fairseq/fairseq/models/speech_to_text/utils.py b/fairseq/fairseq/models/speech_to_text/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..168b8bf13b0e734eee3f6989ff0f28a016a09c2b --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/utils.py @@ -0,0 +1,563 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + + +import logging +from collections.abc import Iterable +from itertools import repeat +from typing import List, Optional, Tuple + +import torch +from torch import Tensor + + +# ------------------------------------------------------------------------------ +# assert_equal() +# ------------------------------------------------------------------------------ + + +def assert_equal(value1, value2, name1=None, name2=None): + """Asserts two values are equal otherwise raise an error.""" + + str_name1 = "" if name1 is None else "{} ".format(name1) + str_name2 = "" if name2 is None else "{} ".format(name2) + if value1 != value2: + str_value1 = "{}" if name1 is None else "({})" + str_value1 = str_value1.format(value1) + str_value2 = "{}" if name2 is None else "({})" + str_value2 = str_value2.format(value2) + raise ValueError( + "Expected {}{} == {}{}".format(str_name1, str_value1, str_name2, str_value2) + ) + + +def fill_config(config, key, value): + if value is not None: + if key not in config or config[key] is None: + config[key] = value + assert_equal(value, config[key], "value", f'config["{key}"]') + + +# ------------------------------------------------------------------------------ +# check_and_return_expected() +# ------------------------------------------------------------------------------ + + +def check_and_return_expected(value, undefined_value, expected_value, name=None): + """ + Return the expected value while checking if the given value is undefined or + equal to the expected value. + """ + if (undefined_value is None and value is None) or (undefined_value == value): + return expected_value + if value != expected_value: + str_name = "" if name is None else "{} ".format(name) + str_value = "{}" if name is None else "({})" + str_value = str_value.format(value) + raise ValueError( + "Expected {}{} == {}".format(str_name, str_value, expected_value) + ) + return expected_value + + +# ------------------------------------------------------------------------------ +# get_time_axis() +# ------------------------------------------------------------------------------ + + +def get_time_axis(layout): + """ + Extract the time axis from the layout, for example for breaking sequence into + segments. + """ + if layout in ["TB", "TBD"]: + return 0 + if layout in ["BT", "BTD"]: + return 1 + if layout in ["BCTD"]: + return 2 + raise ValueError("Unsupported layout = {}".format(layout)) + + +# ------------------------------------------------------------------------------ +# get_batch_axis() +# ------------------------------------------------------------------------------ + + +def get_batch_axis(layout): + """ + Extract the batch axis from the layout + """ + if layout in ["TB", "TBD"]: + return 1 + if layout in ["BT", "BTD", "BCTD"]: + return 0 + raise ValueError("Unsupported layout = {}".format(layout)) + + +# ------------------------------------------------------------------------------ +# monotonically_increasing_and_bounded() +# ------------------------------------------------------------------------------ + + +def monotonically_increasing_and_bounded(iterable, min=None, max=None): + """ + Check if the elements in the given iterable are monotonically increasing and + bounded by upper/lower bounds. + """ + if not isinstance(iterable, Iterable): + raise TypeError( + "Expected iterable to be of type Iterable, got ({})".format( + iterable.__class__.__name__ + ) + ) + for i in range(len(iterable)): + if min is not None and iterable[i] < min: + return False + if max is not None and iterable[i] > max: + return False + if i > 0 and iterable[i] <= iterable[i - 1]: + return False + return True + + +# ------------------------------------------------------------------------------ +# to_pair() +# ------------------------------------------------------------------------------ + + +def to_pair(value, name): + """Make a pair (of type tuple) of given value.""" + if isinstance(value, Iterable): + if len(value) != 2: + raise ValueError( + "Expected `{}` to have exactly 2 elements, got: ({})".format( + name, value + ) + ) + return value + return tuple(repeat(value, 2)) + + +# ------------------------------------------------------------------------------ +# infer_conv_output_attrs() +# ------------------------------------------------------------------------------ + + +# TODO(cfyeh): figure out if we can get `output_dim` without calling the module. +def infer_conv_output_attrs( + module, input_channels, input_dim, batch_size=1, max_length=8 +): + """Get output attributes of a module with input.""" + input = torch.randn(batch_size, input_channels, max_length, input_dim) + output = module(input) + output_channels = output.shape[1] + output_dim = output.shape[-1] + return output_channels, output_dim + + +# ------------------------------------------------------------------------------ +# NoOp +# ------------------------------------------------------------------------------ + + +class NoOp(torch.nn.Module): + """ + NoOp simply passes the input as the output. + """ + + def __init__(self): + super().__init__() + + def forward(self, input: Tensor) -> Tensor: + return input + + +# ------------------------------------------------------------------------------ +# Permute: a torch.nn.Module applies permutation on the input tensor. +# ------------------------------------------------------------------------------ + + +class Permute(torch.nn.Module): + def __init__(self, dims): + super().__init__() + self.dims = dims + + def forward(self, input: Tensor) -> Tensor: + return input.permute(self.dims).contiguous() + + +# ------------------------------------------------------------------------------ +# lengths_to_padding_mask() +# ------------------------------------------------------------------------------ + + +def lengths_to_padding_mask(lengths: Tensor) -> Tensor: + """Convert lengths of shape (B, ) to padding mask.""" + batch_size = lengths.shape[0] + max_length = int(torch.max(lengths).item()) + padding_mask = torch.arange( # [0, ..., T-1] + max_length, device=lengths.device, dtype=lengths.dtype + ).expand(batch_size, max_length) >= lengths.unsqueeze(1) + + return padding_mask + + +# ------------------------------------------------------------------------------ +# lengths_to_attention_mask() +# ------------------------------------------------------------------------------ + + +def lengths_to_attention_mask( + lengths: Tensor, + left_context: Optional[int] = None, + right_context: Optional[int] = None, +) -> Optional[Tensor]: + """ + Generate attention mask based on (lengths, left_context, right_context). + left_context is None means unlimited left context. + right_context is None means unlimited right context. + """ + + if left_context is None and right_context is None: + return None + + max_length = int(torch.max(lengths).item()) + + # For example, with `max_length` == 5, + # indices = tensor([ + # [ 0, 1, 2, 3, 4, 5], + # [-1, 0, 1, 2, 3, 4], + # [-2, -1, 0, 1, 2, 3], + # [-3, -2, -1, 0, 1, 2], + # [-4, -3, -2, -1, 0, 1], + # [-5, -4, -3, -2, -1, 0], + # ]) + + # In some cases the second torch.arange is created on cpu which causes a + # failure. Adding the device option to guard against it. + indices = torch.arange( + max_length, device=lengths.device, dtype=lengths.dtype + ).expand(max_length, max_length) - torch.arange( + max_length, device=lengths.device + ).view( + max_length, -1 + ) + + # For example, with `max_length` == 5, + # bool_mask = tensor([ + # [True, True, True, True, True], + # [True, True, True, True, True], + # [True, True, True, True, True], + # [True, True, True, True, True], + # [True, True, True, True, True], + # ]) + bool_mask = ( + torch.tensor([True]).to(device=lengths.device).expand(max_length, max_length) + ) + + # For example, with `max_length` == 5, left_context == 2 + # left_mask = tensor([ + # [ True, True, True, True, True], + # [ True, True, True, True, True], + # [ True, True, True, True, True], + # [False, True, True, True, True], + # [False, False, True, True, True], + # ]) + if left_context is not None: + left_mask = indices >= -left_context + bool_mask = bool_mask & left_mask + + # For example, with `max_length` == 5, right_context == 1 + # right_mask = tensor([ + # [True, True, False, False, False], + # [True, True, True, False, False], + # [True, True, True, True, False], + # [True, True, True, True, True], + # [True, True, True, True, True], + # ]) + if right_context is not None: + right_mask = indices <= right_context + bool_mask = bool_mask & right_mask + + bool_mask = (~bool_mask).to(device=lengths.device) + return bool_mask + + +# ------------------------------------------------------------------------------ +# infer_output_norm() +# ------------------------------------------------------------------------------ + + +def infer_output_norm(module, output_norm=None): + """ + Infer the output norm (string and module) needed on the module gvien desired + output normalization. + """ + if output_norm == module.output_norm(): + # output_norm already matches module.output_norm(). + return (None, NoOp()) + + if output_norm is None and module.output_norm() is not None: + logger = logging.getLogger("infer_output_norm()") + logger.warning( + "trying to set output_norm ({}) ".format(output_norm) + + "but got module.output_norm() ({}), ".format(module.output_norm()) + + "the combined output_norm() will be ({})".format(module.output_norm()) + ) + return (None, NoOp()) + + if output_norm == "log_softmax": + if module.output_norm() is not None: + raise ValueError( + "incompatible output_norm ({}) ".format(output_norm) + + "and module.output_norm() ({})".format(module.output_norm()) + ) + else: + return ("log_softmax", torch.nn.LogSoftmax(dim=-1)) + + if output_norm == "softmax": + if module.output_norm() is not None: + raise ValueError( + "incompatible output_norm ({}) ".format(output_norm) + + "and module.output_norm() ({})".format(module.output_norm()) + ) + else: + return ("softmax", torch.nn.Softmax(dim=-1)) + + raise ValueError( + "output_norm ({}) not in ".format(output_norm) + + "supported list = [None, softmax, log_softmax]" + ) + + +# ------------------------------------------------------------------------------ +# infer_channels_from_layout() +# ------------------------------------------------------------------------------ + + +def infer_channels_from_layout(layout, channels): + """Extract the number of channels from the layout.""" + if layout in ("TBD", "BTD"): + if channels is not None and channels != 1: + raise ValueError( + "Expected channels ({}) to be 1 for layout = {}".format( + channels, layout + ) + ) + if channels is None: + return 1 + return channels + + +# ------------------------------------------------------------------------------ +# pad_sequence() +# ------------------------------------------------------------------------------ + + +@torch.jit.export +def pad_sequence( + sequence: Tensor, + time_axis: int, + extra_left_context: int = 0, + extra_right_context: int = 0, +) -> Tensor: + """Pad extra left/right contexts to the sequence.""" + + if extra_left_context == 0 and extra_right_context == 0: + return sequence + + tensors_to_concat = [] + + if extra_left_context: + size = (extra_left_context,) + fill_value = 0 + indices = torch.full( + size=size, + fill_value=fill_value, + dtype=torch.long, + device=sequence.device, + ) + left_padding = torch.index_select(sequence, time_axis, indices) + tensors_to_concat.append(left_padding) + + tensors_to_concat.append(sequence) + + # NOTE(cfyeh): for efficiency reason we pad 0 instead of the last frame for + # extra right contexts. + if extra_right_context: + size = list(sequence.shape) + size[time_axis] = extra_right_context + right_padding = torch.zeros(size, dtype=sequence.dtype, device=sequence.device) + tensors_to_concat.append(right_padding) + + padded_sequence = torch.cat(tensors_to_concat, dim=time_axis) + return padded_sequence + + +# ------------------------------------------------------------------------------ +# sequence_to_segments() +# ------------------------------------------------------------------------------ + + +@torch.jit.export +def sequence_to_segments( + sequence: Tensor, + time_axis: int, + lengths: Tensor, + segment_size: Optional[int] = None, + extra_left_context: int = 0, + extra_right_context: int = 0, +) -> List[Tuple[Tensor, Tensor]]: + """Breaks sequence into segments.""" + + sequence = pad_sequence( + sequence=sequence, + time_axis=time_axis, + extra_left_context=extra_left_context, + extra_right_context=extra_right_context, + ) + + lengths = lengths + extra_left_context + extra_right_context + + segments: List[Tuple[Tensor, Tensor]] = [] + + if segment_size is None: + segments.append((sequence, lengths)) + return segments + + offset = 0 + end = sequence.shape[time_axis] + step = segment_size + size = extra_left_context + segment_size + extra_right_context + + while offset + extra_left_context + extra_right_context < end: + clamped_size = min(size, end - offset) + segment_lengths = torch.clamp(lengths - offset, min=0, max=clamped_size) + indices = torch.arange( + start=offset, + end=(offset + clamped_size), + step=1, + dtype=torch.long, + device=sequence.device, + ) + segment_tensor = torch.index_select(sequence, time_axis, indices) + segments.append((segment_tensor, segment_lengths)) + offset = offset + step + + return segments + + +# ------------------------------------------------------------------------------ +# segments_to_sequence() +# ------------------------------------------------------------------------------ + + +@torch.jit.export +def segments_to_sequence( + segments: List[Tuple[Tensor, Tensor]], time_axis: int +) -> Tuple[Tensor, Tensor]: + """Concatenate segments into a full sequence.""" + if len(segments) == 1: + return segments[0] + + tensors_to_concat: List[Tensor] = [] + lengths_to_stack: List[Tensor] = [] + + for tensor, lengths in segments: + tensors_to_concat.append(tensor) + lengths_to_stack.append(lengths) + + sequence = torch.cat(tensors_to_concat, dim=time_axis) + lengths = torch.stack(lengths_to_stack, dim=0) + lengths = torch.sum(lengths, dim=0) + + return sequence, lengths + + +def lengths_to_encoder_padding_mask(lengths, batch_first: bool = False): + """ + convert lengths (a 1-D Long/Int tensor) to 2-D binary tensor + + Args: + lengths: a (B, )-shaped tensor + batch_first: whether to return a (B, T) tensor + + Return: + max_length: maximum length of B sequences + encoder_padding_mask: a (max_length, B) binary mask, where + [t, b] = False for t < lengths[b] and True otherwise + + TODO: + kernelize this function if benchmarking shows this function is slow + """ + max_lengths = torch.max(lengths).item() + bsz = lengths.size(0) + encoder_padding_mask = torch.arange( + max_lengths + ).to( # a (T, ) tensor with [0, ..., T-1] + lengths.device + ).view( # move to the right device + 1, max_lengths + ).expand( # reshape to (1, T)-shaped tensor + bsz, -1 + ) > lengths.view( # expand to (B, T)-shaped tensor + bsz, 1 + ).expand( + -1, max_lengths + ) + if not batch_first: + return encoder_padding_mask.t(), max_lengths + else: + return encoder_padding_mask, max_lengths + + +# ------------------------------------------------------------------------------ +# attention suppression +# ------------------------------------------------------------------------------ + + +def attention_suppression(attention_weights: Tensor, scale: float): + # B, H, qlen, klen -> B, H, qlen, 1 + attention_prob = torch.nn.functional.softmax(attention_weights.float(), dim=-1) + attention_nozeros = attention_prob.to(torch.bool) + nozeros_sum = torch.sum(attention_nozeros.to(torch.float), dim=-1, keepdim=True) + + # For very sparse situation, we need get round about 0s + key_sum = torch.sum(attention_prob, dim=-1, keepdim=True) + + # nozeros_sum should > 1 + key_mean = key_sum / (nozeros_sum + 1e-8) + + # std calculation + dis = (attention_prob - key_mean) * (attention_prob - key_mean) + + # if attention_prob[i] < threshold, then dis_masked[i] = 0; for all i + dis_masked = torch.where( + attention_nozeros, dis, attention_prob.new_zeros(attention_prob.size()) + ) + + key_var = torch.sum(dis_masked, dim=-1, keepdim=True) + key_var = key_var / (nozeros_sum - 1.0 + 1e-8) + key_std = torch.sqrt(key_var) + key_thread = key_mean - scale * key_std + + # if attention_prob[i] >= key_thread, then attention_prob[i] + # , otherwise "-inf" + inf_tensor = attention_prob.new_zeros(attention_prob.size()).detach() + inf_tensor[:] = float("-inf") + attention_weights_float = torch.where( + attention_prob < key_thread, + inf_tensor, + attention_weights.float(), + ) + + return attention_weights_float.type_as(attention_weights) + + +def layer_norm_backward_hook(module, grad_input, grad_output, clamp_value): + return tuple(torch.clamp(v, min=-clamp_value, max=clamp_value) for v in grad_input) diff --git a/fairseq/fairseq/models/speech_to_text/xm_transformer.py b/fairseq/fairseq/models/speech_to_text/xm_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..5eecbfa2158dcbee90eef6d395bb5611ff8ee8de --- /dev/null +++ b/fairseq/fairseq/models/speech_to_text/xm_transformer.py @@ -0,0 +1,505 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import copy +from typing import Dict, List, Optional, Tuple + +from fairseq import utils, checkpoint_utils +from fairseq.models import (FairseqEncoderDecoderModel, FairseqEncoder, + register_model, register_model_architecture) +from fairseq.models.transformer import Embedding, TransformerDecoder +from fairseq.models.wav2vec import Wav2VecEncoder +from fairseq.modules.layer_norm import LayerNorm +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq.utils import safe_hasattr +from torch import Tensor +import torch.nn as nn + + +logger = logging.getLogger(__name__) + + +class Conv1dAdaptor(nn.Module): + def __init__(self, in_dim, out_dim, n_layers=3, kernel_size=3, stride=2, + add_layernorm=False): + super().__init__() + self.layers = nn.ModuleList( + nn.Conv1d(in_dim if i == 0 else out_dim, out_dim * 2, kernel_size, + stride=stride, padding=kernel_size // 2) + for i in range(n_layers) + ) + self.layernorms = None + if add_layernorm: + self.layernorms = nn.ModuleList(LayerNorm(out_dim) + for _ in range(n_layers)) + self.stride = stride + + @classmethod + def add_args(cls, parser): + parser.add_argument("--adaptor-n-layers", type=int) + parser.add_argument("--adaptor-kernel-size", type=int) + parser.add_argument("--adaptor-stride", type=int) + parser.add_argument("--adaptor-layernorm", action='store_true') + + def get_out_seq_lens_tensor(self, in_seq_lens_tensor): + out = in_seq_lens_tensor.clone() + for _ in self.layers: + out = ((out.float() - 1) / self.stride + 1).floor().long() + return out + + def forward(self, x, padding_mask): + # T x B x C -> B x C x T + x = x.transpose(0, 1).transpose(1, 2) + for i, layer in enumerate(self.layers): + x = nn.functional.glu(layer(x), dim=1) + if self.layernorms is not None: + x = self.layernorms[i](x.transpose(1, 2)).transpose(1, 2) + # B x C x T -> T x B x C + x = x.transpose(1, 2).transpose(0, 1) + + if padding_mask is None: + out_padding_mask = None + else: + out_lengths = self.get_out_seq_lens_tensor((~padding_mask).sum(1)) + out_padding_mask = lengths_to_padding_mask(out_lengths) + return x, out_padding_mask + + +def add_wav2vec_asr_args(parser): + parser.add_argument("--w2v-path", help="path to wav2vec 2.0 model") + parser.add_argument( + "--no-pretrained-weights", + action="store_true", + help="if true, does not load pretrained weights", + ) + parser.add_argument( + "--dropout-input", + type=float, + metavar="D", + help="dropout to apply to the input (after feat extr)", + ) + parser.add_argument( + "--final-dropout", + type=float, + metavar="D", + help="dropout after transformer and before final projection", + ) + parser.add_argument( + "--apply-mask", action="store_true", help="apply masking during fine-tuning" + ) + parser.add_argument( + "--dropout", + type=float, + metavar="D", + help="dropout probability inside wav2vec 2.0 model", + ) + parser.add_argument( + "--attention-dropout", + type=float, + metavar="D", + help="dropout probability for attention weights inside wav2vec 2.0 model", + ) + parser.add_argument( + "--activation-dropout", + "--relu-dropout", + type=float, + metavar="D", + help="dropout probability after activation in FFN inside wav2vec 2.0 model", + ) + + parser.add_argument( + "--mask-length", type=int, help="repeat the mask indices multiple times" + ) + + parser.add_argument( + "--mask-prob", type=float, help="probability of replacing a token with mask" + ) + + parser.add_argument( + "--mask-selection", + type=str, + choices=["static", "uniform", "normal", "poisson"], + help="how to choose masks", + ) + + parser.add_argument( + "--mask-other", + type=float, + help="stdev of the mask length in case of 'normal' selection strategy", + ) + + parser.add_argument( + "--no-mask-overlap", + action="store_true", + help="whether to allow masks to overlap", + ) + + parser.add_argument( + "--mask-channel-length", type=int, help="repeat the mask indices multiple times" + ) + + parser.add_argument( + "--mask-channel-prob", + type=float, + help="probability of replacing a token with mask", + ) + + parser.add_argument( + "--mask-channel-selection", + type=str, + choices=["static", "uniform", "normal", "poisson"], + help="how to choose masks", + ) + + parser.add_argument( + "--mask-channel-other", + type=float, + help="stdev of the mask length in case of 'normal' selection strategy", + ) + + parser.add_argument( + "--no-mask-channel-overlap", + action="store_true", + help="whether to allow masks to overlap", + ) + + parser.add_argument( + "--freeze-finetune-updates", + default=0, + type=int, + help="dont finetune wav2vec for this many updates", + ) + + parser.add_argument( + "--feature-grad-mult", + default=None, + type=float, + help="reset feature grad mult in wav2vec 2.0 to this", + ) + + parser.add_argument( + "--layerdrop", + default=0.0, + type=float, + help="probability of dropping a layer in wav2vec 2.0", + ) + parser.add_argument("--w2v-args", default=None) + + +class Wav2VecEncoderWithAdaptor(FairseqEncoder): + def __init__(self, args): + super().__init__(None) + self.w2v_encoder = Wav2VecEncoder(args) + encoder_out_dim = self.w2v_encoder.w2v_model.encoder.embedding_dim + # Projection + 8x shrinking + self.adaptor = Conv1dAdaptor( + encoder_out_dim, args.decoder_embed_dim, + n_layers=args.adaptor_n_layers, + kernel_size=args.adaptor_kernel_size, stride=args.adaptor_stride, + add_layernorm=args.adaptor_layernorm + ) + for k, p in self.w2v_encoder.w2v_model.named_parameters(): + # Freeze pretrained models by default + if safe_hasattr(args, 'finetune_w2v_params') and XMTransformerModel.finetune_params( + args.finetune_w2v_params, k): + p.requires_grad = True + else: + p.requires_grad = False + + @classmethod + def add_args(cls, parser): + add_wav2vec_asr_args(parser) + parser.add_argument( + "--normalize", action="store_true", + help="if set, normalizes input to have 0 mean and unit variance", + ) + parser.add_argument("--finetune-w2v-params", type=str, metavar="STR", + help="comma-separated param strings to finetune.") + Conv1dAdaptor.add_args(parser) + + def forward(self, src_tokens, src_lengths=None, **kwargs): + padding_mask = lengths_to_padding_mask(src_lengths) + out = self.w2v_encoder.forward(src_tokens, padding_mask, tbc=True) + x = out["encoder_out"] + enc_padding_mask = None + if out["encoder_padding_mask"] is not None: + enc_padding_mask = out["encoder_padding_mask"].transpose(0, 1) # T X B --> B X T + + x, enc_padding_mask = self.adaptor(x, enc_padding_mask) + + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [enc_padding_mask] if enc_padding_mask.any() else [], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": [], # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + } + + def reorder_encoder_out(self, encoder_out, new_order): + new_encoder_out = ( + [] if len(encoder_out["encoder_out"]) == 0 + else [x.index_select(1, new_order) for x in encoder_out["encoder_out"]] + ) + + new_encoder_padding_mask = ( + [] if len(encoder_out["encoder_padding_mask"]) == 0 + else [x.index_select(0, new_order) for x in + encoder_out["encoder_padding_mask"]] + ) + + new_encoder_embedding = ( + [] if len(encoder_out["encoder_embedding"]) == 0 + else [x.index_select(0, new_order) for x in + encoder_out["encoder_embedding"]] + ) + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], # B x T + "src_lengths": [], # B x 1 + } + + +def add_decoder_args(parser): + parser.add_argument("--activation-fn", type=str, default='relu', + choices=utils.get_available_activation_fns(), + help="activation function to use") + parser.add_argument("--decoder-dropout", type=float, metavar="D", + help="dropout probability") + parser.add_argument("--decoder-attention-dropout", type=float, + metavar="D", + help="dropout probability for attention weights") + parser.add_argument("--decoder-activation-dropout", type=float, + metavar="D", + help="dropout probability after activation in FFN.") + parser.add_argument("--decoder-embed-dim", type=int, metavar="N", + help="decoder embedding dimension") + parser.add_argument("--decoder-ffn-embed-dim", type=int, metavar="N", + help="decoder embedding dimension for FFN") + parser.add_argument("--decoder-layers", type=int, metavar="N", + help="num decoder layers") + parser.add_argument("--decoder-attention-heads", type=int, metavar="N", + help="num decoder attention heads") + parser.add_argument("--decoder-normalize-before", action="store_true", + help="apply layernorm before each decoder block") + parser.add_argument("--layernorm-embedding", action="store_true", + help="add layernorm to embedding") + parser.add_argument("--no-scale-embedding", action="store_true", + help="if True, dont scale embeddings") + parser.add_argument( + "--load-pretrained-decoder-from", type=str, metavar="STR", + help="model to take decoder weights from (for initialization)" + ) + parser.add_argument("--finetune-decoder-params", type=str, + metavar="STR", + help="comma-separated param strings to finetune.") + parser.add_argument("--checkpoint-activations", action="store_true") + + +@register_model("xm_transformer") +class XMTransformerModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @classmethod + def add_args(cls, parser): + """Add model-specific arguments to the parser.""" + Wav2VecEncoderWithAdaptor.add_args(parser) + add_decoder_args(parser) + + @classmethod + def build_encoder(cls, args): + _args = copy.deepcopy(args) + state = checkpoint_utils.load_checkpoint_to_cpu(args.w2v_path) + if state.get("cfg") is not None: + encoder_embed_dim = state["cfg"]._content["model"]["encoder_embed_dim"] + elif state.get("args") is not None: + encoder_embed_dim = state["args"].encoder_embed_dim + else: + raise ValueError(f"Invalid config in {args.w2v_path}") + _args.decoder_embed_dim = encoder_embed_dim + encoder = Wav2VecEncoderWithAdaptor(_args) + return encoder + + @classmethod + def build_decoder(cls, args, task, embed_tokens): + _args = copy.deepcopy(args) + _args.dropout = args.decoder_dropout + _args.attention_dropout = args.decoder_attention_dropout + _args.activation_dropout = args.decoder_activation_dropout + _args.max_target_positions = 1024 + + decoder = TransformerDecoder(_args, task.target_dictionary, + embed_tokens) + if getattr(args, "load_pretrained_decoder_from", None): + decoder = checkpoint_utils.load_pretrained_component_from_model( + component=decoder, checkpoint=args.load_pretrained_decoder_from + ) + for k, p in decoder.named_parameters(): + # Freeze pretrained models by default + if safe_hasattr(args, 'finetune_decoder_params') and XMTransformerModel.finetune_params( + args.finetune_decoder_params, k): + p.requires_grad = True + else: + p.requires_grad = False + return decoder + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + def build_embedding(dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + return Embedding(num_embeddings, embed_dim, padding_idx) + + decoder_embed_tokens = build_embedding(task.target_dictionary, + args.decoder_embed_dim) + encoder = cls.build_encoder(args) + decoder = cls.build_decoder(args, task, decoder_embed_tokens) + return cls(encoder, decoder) + + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + # net_output['encoder_out'] is a (B, T, D) tensor + lprobs = self.get_normalized_probs_scriptable(net_output, log_probs, + sample) + lprobs.batch_first = True + return lprobs + + def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): + """ + The forward method inherited from the base class has a **kwargs + argument in its input, which is not supported in torchscript. This + method overrites the forward method definition without **kwargs. + """ + encoder_out = self.encoder(src_tokens=src_tokens, + src_lengths=src_lengths, **kwargs) + decoder_out = self.decoder(prev_output_tokens=prev_output_tokens, + encoder_out=encoder_out) + return decoder_out + + def upgrade_state_dict(self, state_dict): + for k, _ in state_dict.items(): + if 'adaptor.layers' in state_dict: + print(k) + new = k.replace('adaptor.layers', 'adaptor_layers') + state_dict[new] = state_dict[k] + del state_dict[k] + + @staticmethod + def finetune_params(finetune_params, param_name): + if finetune_params == "all": + return True + finetune_params_list = finetune_params.split(",") + for finetune_param in finetune_params_list: + if finetune_param in param_name: + return True + return False + + +def set_default_w2v_encoder_args(args): + args.no_pretrained_weights = getattr(args, "no_pretrained_weights", False) + args.dropout_input = getattr(args, "dropout_input", 0) + args.final_dropout = getattr(args, "final_dropout", 0) + args.apply_mask = getattr(args, "apply_mask", False) + args.dropout = getattr(args, "dropout", 0) + args.attention_dropout = getattr(args, "attention_dropout", 0) + args.activation_dropout = getattr(args, "activation_dropout", 0) + + args.mask_length = getattr(args, "mask_length", 10) + args.mask_prob = getattr(args, "mask_prob", 0.5) + args.mask_selection = getattr(args, "mask_selection", "static") + args.mask_other = getattr(args, "mask_other", 0) + args.no_mask_overlap = getattr(args, "no_mask_overlap", False) + args.mask_channel_length = getattr(args, "mask_channel_length", 10) + args.mask_channel_prob = getattr(args, "mask_channel_prob", 0.5) + args.mask_channel_before = getattr(args, "mask_channel_before", False) + args.mask_channel_selection = getattr(args, "mask_channel_selection", + "static") + args.mask_channel_other = getattr(args, "mask_channel_other", 0) + args.no_mask_channel_overlap = getattr(args, "no_mask_channel_overlap", + False) + + args.freeze_finetune_updates = getattr(args, "freeze_finetune_updates", 0) + args.feature_grad_mult = 0.1 + args.layerdrop = getattr(args, "layerdrop", 0.0) + + args.normalize = getattr(args, "normalize", False) + + +def set_default_adaptor_args(args): + args.adaptor_n_layers = getattr(args, "adaptor_n_layers", 3) + args.adaptor_kernel_size = getattr(args, "adaptor_kernel_size", 3) + args.adaptor_stride = getattr(args, "adaptor_stride", 2) + args.adaptor_layernorm = getattr(args, "adaptor_layernorm", False) + + +def set_default_mbart_decoder_args(args): + args.decoder_embed_path = getattr(args, 'decoder_embed_path', None) + args.decoder_embed_dim = getattr(args, 'decoder_embed_dim', 1024) + args.decoder_ffn_embed_dim = getattr(args, 'decoder_ffn_embed_dim', + 4 * 1024) + args.decoder_layers = getattr(args, 'decoder_layers', 12) + args.decoder_attention_heads = getattr(args, 'decoder_attention_heads', 16) + args.decoder_normalize_before = getattr(args, 'decoder_normalize_before', + True) + args.decoder_learned_pos = getattr(args, 'decoder_learned_pos', True) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0.0) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.decoder_attention_dropout = getattr(args, 'decoder_attention_dropout', + 0.) + args.decoder_activation_dropout = getattr(args, + 'decoder_activation_dropout', 0.) + args.decoder_dropout = getattr(args, 'decoder_dropout', 0.1) + args.adaptive_softmax_cutoff = getattr(args, 'adaptive_softmax_cutoff', + None) + args.adaptive_softmax_dropout = getattr(args, 'adaptive_softmax_dropout', 0) + args.share_decoder_input_output_embed = getattr( + args, 'share_decoder_input_output_embed', True + ) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + + args.decoder_output_dim = getattr(args, 'decoder_output_dim', + args.decoder_embed_dim) + args.decoder_input_dim = getattr(args, 'decoder_input_dim', + args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, 'no_scale_embedding', False) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.layernorm_embedding = getattr(args, 'layernorm_embedding', True) + + args.activation_fn = getattr(args, 'activation_fn', 'gelu') + args.pooler_activation_fn = getattr(args, 'pooler_activation_fn', 'tanh') + args.pooler_dropout = getattr(args, 'pooler_dropout', 0.0) + args.checkpoint_activations = getattr(args, "checkpoint_activations", False) + + +@register_model_architecture(model_name="xm_transformer", + arch_name="xm_transformer") +def base_architecture(args): + set_default_w2v_encoder_args(args) + set_default_adaptor_args(args) + set_default_mbart_decoder_args(args) diff --git a/fairseq/fairseq/models/text_to_speech/__init__.py b/fairseq/fairseq/models/text_to_speech/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..652fee0d685b61af47b314367037888fa640e1a7 --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .tacotron2 import * # noqa +from .tts_transformer import * # noqa +from .fastspeech2 import * # noqa diff --git a/fairseq/fairseq/models/text_to_speech/fastspeech2.py b/fairseq/fairseq/models/text_to_speech/fastspeech2.py new file mode 100644 index 0000000000000000000000000000000000000000..9c38d0917d997ed5e255ec7a5ed8882b405baffa --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/fastspeech2.py @@ -0,0 +1,352 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +from torch import nn + +from fairseq.models import (FairseqEncoder, FairseqEncoderModel, register_model, + register_model_architecture) +from fairseq.modules import ( + LayerNorm, PositionalEmbedding, FairseqDropout, MultiheadAttention +) +from fairseq import utils +from fairseq.data.data_utils import lengths_to_padding_mask + + +logger = logging.getLogger(__name__) + + +def model_init(m): + if isinstance(m, nn.Conv1d): + nn.init.xavier_uniform_(m.weight, torch.nn.init.calculate_gain("relu")) + + +def Embedding(num_embeddings, embedding_dim, padding_idx=None): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + return m + + +class PositionwiseFeedForward(nn.Module): + def __init__(self, in_dim, hidden_dim, kernel_size, dropout): + super().__init__() + self.ffn = nn.Sequential( + nn.Conv1d(in_dim, hidden_dim, kernel_size=kernel_size, + padding=(kernel_size - 1) // 2), + nn.ReLU(), + nn.Conv1d(hidden_dim, in_dim, kernel_size=kernel_size, + padding=(kernel_size - 1) // 2) + ) + self.layer_norm = LayerNorm(in_dim) + self.dropout = self.dropout_module = FairseqDropout( + p=dropout, module_name=self.__class__.__name__ + ) + + def forward(self, x): + # B x T x C + residual = x + x = self.ffn(x.transpose(1, 2)).transpose(1, 2) + x = self.dropout(x) + return self.layer_norm(x + residual) + + +class FFTLayer(torch.nn.Module): + def __init__( + self, embed_dim, n_heads, hidden_dim, kernel_size, dropout, + attention_dropout + ): + super().__init__() + self.self_attn = MultiheadAttention( + embed_dim, n_heads, dropout=attention_dropout, self_attention=True + ) + self.layer_norm = LayerNorm(embed_dim) + self.ffn = PositionwiseFeedForward( + embed_dim, hidden_dim, kernel_size, dropout=dropout + ) + + def forward(self, x, padding_mask=None): + # B x T x C + residual = x + x = x.transpose(0, 1) + x, _ = self.self_attn( + query=x, key=x, value=x, key_padding_mask=padding_mask, + need_weights=False + ) + x = x.transpose(0, 1) + x = self.layer_norm(x + residual) + return self.ffn(x) + + +class LengthRegulator(nn.Module): + def forward(self, x, durations): + # x: B x T x C + out_lens = durations.sum(dim=1) + max_len = out_lens.max() + bsz, seq_len, dim = x.size() + out = x.new_zeros((bsz, max_len, dim)) + + for b in range(bsz): + indices = [] + for t in range(seq_len): + indices.extend([t] * utils.item(durations[b, t])) + indices = torch.tensor(indices, dtype=torch.long).to(x.device) + out_len = utils.item(out_lens[b]) + out[b, :out_len] = x[b].index_select(0, indices) + + return out, out_lens + + +class VariancePredictor(nn.Module): + def __init__(self, args): + super().__init__() + self.conv1 = nn.Sequential( + nn.Conv1d( + args.encoder_embed_dim, args.var_pred_hidden_dim, + kernel_size=args.var_pred_kernel_size, + padding=(args.var_pred_kernel_size - 1) // 2 + ), + nn.ReLU() + ) + self.ln1 = nn.LayerNorm(args.var_pred_hidden_dim) + self.dropout_module = FairseqDropout( + p=args.var_pred_dropout, module_name=self.__class__.__name__ + ) + self.conv2 = nn.Sequential( + nn.Conv1d( + args.var_pred_hidden_dim, args.var_pred_hidden_dim, + kernel_size=args.var_pred_kernel_size, padding=1 + ), + nn.ReLU() + ) + self.ln2 = nn.LayerNorm(args.var_pred_hidden_dim) + self.proj = nn.Linear(args.var_pred_hidden_dim, 1) + + def forward(self, x): + # Input: B x T x C; Output: B x T + x = self.conv1(x.transpose(1, 2)).transpose(1, 2) + x = self.dropout_module(self.ln1(x)) + x = self.conv2(x.transpose(1, 2)).transpose(1, 2) + x = self.dropout_module(self.ln2(x)) + return self.proj(x).squeeze(dim=2) + + +class VarianceAdaptor(nn.Module): + def __init__(self, args): + super().__init__() + self.args = args + self.length_regulator = LengthRegulator() + self.duration_predictor = VariancePredictor(args) + self.pitch_predictor = VariancePredictor(args) + self.energy_predictor = VariancePredictor(args) + + n_bins, steps = self.args.var_pred_n_bins, self.args.var_pred_n_bins - 1 + self.pitch_bins = torch.linspace(args.pitch_min, args.pitch_max, steps) + self.embed_pitch = Embedding(n_bins, args.encoder_embed_dim) + self.energy_bins = torch.linspace(args.energy_min, args.energy_max, steps) + self.embed_energy = Embedding(n_bins, args.encoder_embed_dim) + + def get_pitch_emb(self, x, tgt=None, factor=1.0): + out = self.pitch_predictor(x) + bins = self.pitch_bins.to(x.device) + if tgt is None: + out = out * factor + emb = self.embed_pitch(torch.bucketize(out, bins)) + else: + emb = self.embed_pitch(torch.bucketize(tgt, bins)) + return out, emb + + def get_energy_emb(self, x, tgt=None, factor=1.0): + out = self.energy_predictor(x) + bins = self.energy_bins.to(x.device) + if tgt is None: + out = out * factor + emb = self.embed_energy(torch.bucketize(out, bins)) + else: + emb = self.embed_energy(torch.bucketize(tgt, bins)) + return out, emb + + def forward( + self, x, padding_mask, durations=None, pitches=None, energies=None, + d_factor=1.0, p_factor=1.0, e_factor=1.0 + ): + # x: B x T x C + log_dur_out = self.duration_predictor(x) + dur_out = torch.clamp( + torch.round((torch.exp(log_dur_out) - 1) * d_factor).long(), min=0 + ) + dur_out.masked_fill_(padding_mask, 0) + + pitch_out, pitch_emb = self.get_pitch_emb(x, pitches, p_factor) + x = x + pitch_emb + energy_out, energy_emb = self.get_energy_emb(x, energies, e_factor) + x = x + energy_emb + + x, out_lens = self.length_regulator( + x, dur_out if durations is None else durations + ) + + return x, out_lens, log_dur_out, pitch_out, energy_out + + +class FastSpeech2Encoder(FairseqEncoder): + def __init__(self, args, src_dict, embed_speaker): + super().__init__(src_dict) + self.args = args + self.padding_idx = src_dict.pad() + self.n_frames_per_step = args.n_frames_per_step + self.out_dim = args.output_frame_dim * args.n_frames_per_step + + self.embed_speaker = embed_speaker + self.spk_emb_proj = None + if embed_speaker is not None: + self.spk_emb_proj = nn.Linear( + args.encoder_embed_dim + args.speaker_embed_dim, + args.encoder_embed_dim + ) + + self.dropout_module = FairseqDropout( + p=args.dropout, module_name=self.__class__.__name__ + ) + self.embed_tokens = Embedding( + len(src_dict), args.encoder_embed_dim, padding_idx=self.padding_idx + ) + + self.embed_positions = PositionalEmbedding( + args.max_source_positions, args.encoder_embed_dim, self.padding_idx + ) + self.pos_emb_alpha = nn.Parameter(torch.ones(1)) + self.dec_pos_emb_alpha = nn.Parameter(torch.ones(1)) + + self.encoder_fft_layers = nn.ModuleList( + FFTLayer( + args.encoder_embed_dim, args.encoder_attention_heads, + args.fft_hidden_dim, args.fft_kernel_size, + dropout=args.dropout, attention_dropout=args.attention_dropout + ) + for _ in range(args.encoder_layers) + ) + + self.var_adaptor = VarianceAdaptor(args) + + self.decoder_fft_layers = nn.ModuleList( + FFTLayer( + args.decoder_embed_dim, args.decoder_attention_heads, + args.fft_hidden_dim, args.fft_kernel_size, + dropout=args.dropout, attention_dropout=args.attention_dropout + ) + for _ in range(args.decoder_layers) + ) + + self.out_proj = nn.Linear(args.decoder_embed_dim, self.out_dim) + + self.apply(model_init) + + def forward(self, src_tokens, src_lengths=None, speaker=None, + durations=None, pitches=None, energies=None, **kwargs): + x = self.embed_tokens(src_tokens) + + enc_padding_mask = src_tokens.eq(self.padding_idx) + x += self.pos_emb_alpha * self.embed_positions(enc_padding_mask) + x = self.dropout_module(x) + + for layer in self.encoder_fft_layers: + x = layer(x, enc_padding_mask) + + if self.embed_speaker is not None: + bsz, seq_len, _ = x.size() + emb = self.embed_speaker(speaker).expand(bsz, seq_len, -1) + x = self.spk_emb_proj(torch.cat([x, emb], dim=2)) + + x, out_lens, log_dur_out, pitch_out, energy_out = \ + self.var_adaptor(x, enc_padding_mask, durations, pitches, energies) + + dec_padding_mask = lengths_to_padding_mask(out_lens) + x += self.dec_pos_emb_alpha * self.embed_positions(dec_padding_mask) + for layer in self.decoder_fft_layers: + x = layer(x, dec_padding_mask) + + x = self.out_proj(x) + + return x, out_lens, log_dur_out, pitch_out, energy_out + + +@register_model("fastspeech2") +class FastSpeech2Model(FairseqEncoderModel): + """ + Implementation for https://arxiv.org/abs/2006.04558 + """ + + NON_AUTOREGRESSIVE = True + + @staticmethod + def add_args(parser): + parser.add_argument("--dropout", type=float) + parser.add_argument("--output-frame-dim", type=int) + parser.add_argument("--speaker-embed-dim", type=int) + # FFT blocks + parser.add_argument("--fft-hidden-dim", type=int) + parser.add_argument("--fft-kernel-size", type=int) + parser.add_argument("--attention-dropout", type=float) + parser.add_argument("--encoder-layers", type=int) + parser.add_argument("--encoder-embed-dim", type=int) + parser.add_argument("--encoder-attention-heads", type=int) + parser.add_argument("--decoder-layers", type=int) + parser.add_argument("--decoder-embed-dim", type=int) + parser.add_argument("--decoder-attention-heads", type=int) + # variance predictor + parser.add_argument("--var-pred-n-bins", type=int) + parser.add_argument("--var-pred-hidden-dim", type=int) + parser.add_argument("--var-pred-kernel-size", type=int) + parser.add_argument("--var-pred-dropout", type=float) + + def __init__(self, encoder, args, src_dict): + super().__init__(encoder) + self._num_updates = 0 + + out_dim = args.output_frame_dim * args.n_frames_per_step + self.ctc_proj = None + if getattr(args, "ctc_weight", 0.) > 0.: + self.ctc_proj = nn.Linear(out_dim, len(src_dict)) + + @classmethod + def build_model(cls, args, task): + embed_speaker = task.get_speaker_embeddings(args) + encoder = FastSpeech2Encoder(args, task.src_dict, embed_speaker) + return cls(encoder, args, task.src_dict) + + def set_num_updates(self, num_updates): + super().set_num_updates(num_updates) + self._num_updates = num_updates + + def get_normalized_probs(self, net_output, log_probs, sample=None): + logits = self.ctc_proj(net_output[0]) + if log_probs: + return utils.log_softmax(logits.float(), dim=-1) + else: + return utils.softmax(logits.float(), dim=-1) + + +@register_model_architecture("fastspeech2", "fastspeech2") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.2) + args.output_frame_dim = getattr(args, "output_frame_dim", 80) + args.speaker_embed_dim = getattr(args, "speaker_embed_dim", 64) + # FFT blocks + args.fft_hidden_dim = getattr(args, "fft_hidden_dim", 1024) + args.fft_kernel_size = getattr(args, "fft_kernel_size", 9) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.encoder_layers = getattr(args, "encoder_layers", 4) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 2) + args.decoder_layers = getattr(args, "decoder_layers", 4) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 256) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 2) + # variance predictor + args.var_pred_n_bins = getattr(args, "var_pred_n_bins", 256) + args.var_pred_hidden_dim = getattr(args, "var_pred_hidden_dim", 256) + args.var_pred_kernel_size = getattr(args, "var_pred_kernel_size", 3) + args.var_pred_dropout = getattr(args, "var_pred_dropout", 0.5) diff --git a/fairseq/fairseq/models/text_to_speech/hifigan.py b/fairseq/fairseq/models/text_to_speech/hifigan.py new file mode 100644 index 0000000000000000000000000000000000000000..edc7db6015ebea18f40c8949ae78c0b5b61e1297 --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/hifigan.py @@ -0,0 +1,173 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn import Conv1d, ConvTranspose1d +from torch.nn.utils import weight_norm, remove_weight_norm + +LRELU_SLOPE = 0.1 + + +def init_weights(m, mean=0.0, std=0.01): + classname = m.__class__.__name__ + if classname.find("Conv") != -1: + m.weight.data.normal_(mean, std) + + +def get_padding(kernel_size, dilation=1): + return (kernel_size * dilation - dilation) // 2 + + +class ResBlock(torch.nn.Module): + def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)): + super(ResBlock, self).__init__() + self.convs1 = nn.ModuleList( + [ + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=dilation[0], + padding=get_padding(kernel_size, dilation[0]), + ) + ), + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=dilation[1], + padding=get_padding(kernel_size, dilation[1]), + ) + ), + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=dilation[2], + padding=get_padding(kernel_size, dilation[2]), + ) + ), + ] + ) + self.convs1.apply(init_weights) + + self.convs2 = nn.ModuleList( + [ + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=1, + padding=get_padding(kernel_size, 1), + ) + ), + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=1, + padding=get_padding(kernel_size, 1), + ) + ), + weight_norm( + Conv1d( + channels, + channels, + kernel_size, + 1, + dilation=1, + padding=get_padding(kernel_size, 1), + ) + ), + ] + ) + self.convs2.apply(init_weights) + + def forward(self, x): + for c1, c2 in zip(self.convs1, self.convs2): + xt = F.leaky_relu(x, LRELU_SLOPE) + xt = c1(xt) + xt = F.leaky_relu(xt, LRELU_SLOPE) + xt = c2(xt) + x = xt + x + return x + + def remove_weight_norm(self): + for layer in self.convs1: + remove_weight_norm(layer) + for layer in self.convs2: + remove_weight_norm(layer) + + +class Generator(torch.nn.Module): + def __init__(self, cfg): + super(Generator, self).__init__() + self.num_kernels = len(cfg["resblock_kernel_sizes"]) + self.num_upsamples = len(cfg["upsample_rates"]) + self.conv_pre = weight_norm( + Conv1d(80, cfg["upsample_initial_channel"], 7, 1, padding=3) + ) + + self.ups = nn.ModuleList() + for i, (u, k) in enumerate( + zip(cfg["upsample_rates"], cfg["upsample_kernel_sizes"]) + ): + self.ups.append( + weight_norm( + ConvTranspose1d( + cfg["upsample_initial_channel"] // (2 ** i), + cfg["upsample_initial_channel"] // (2 ** (i + 1)), + k, + u, + padding=(k - u) // 2, + ) + ) + ) + + self.resblocks = nn.ModuleList() + for i in range(len(self.ups)): + ch = cfg["upsample_initial_channel"] // (2 ** (i + 1)) + for k, d in zip( + cfg["resblock_kernel_sizes"], cfg["resblock_dilation_sizes"] + ): + self.resblocks.append(ResBlock(ch, k, d)) + + self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3)) + self.ups.apply(init_weights) + self.conv_post.apply(init_weights) + + def forward(self, x): + x = self.conv_pre(x) + for i in range(self.num_upsamples): + x = F.leaky_relu(x, LRELU_SLOPE) + x = self.ups[i](x) + xs = None + for j in range(self.num_kernels): + if xs is None: + xs = self.resblocks[i * self.num_kernels + j](x) + else: + xs += self.resblocks[i * self.num_kernels + j](x) + x = xs / self.num_kernels + x = F.leaky_relu(x) + x = self.conv_post(x) + x = torch.tanh(x) + + return x + + def remove_weight_norm(self): + print("Removing weight norm...") + for layer in self.ups: + remove_weight_norm(layer) + for layer in self.resblocks: + layer.remove_weight_norm() + remove_weight_norm(self.conv_pre) + remove_weight_norm(self.conv_post) diff --git a/fairseq/fairseq/models/text_to_speech/tacotron2.py b/fairseq/fairseq/models/text_to_speech/tacotron2.py new file mode 100644 index 0000000000000000000000000000000000000000..bb327e81e74900349e1357261bf2f14bc037ccd6 --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/tacotron2.py @@ -0,0 +1,350 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +from torch import nn +from torch.nn import functional as F + +from fairseq.models import (FairseqEncoder, FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, register_model, + register_model_architecture) +from fairseq.modules import LSTMCellWithZoneOut, LocationAttention + + +logger = logging.getLogger(__name__) + + +def encoder_init(m): + if isinstance(m, nn.Conv1d): + nn.init.xavier_uniform_(m.weight, torch.nn.init.calculate_gain("relu")) + + +class Tacotron2Encoder(FairseqEncoder): + def __init__(self, args, src_dict, embed_speaker): + super().__init__(src_dict) + self.padding_idx = src_dict.pad() + self.embed_speaker = embed_speaker + self.spk_emb_proj = None + if embed_speaker is not None: + self.spk_emb_proj = nn.Linear( + args.encoder_embed_dim + args.speaker_embed_dim, + args.encoder_embed_dim + ) + + self.embed_tokens = nn.Embedding(len(src_dict), args.encoder_embed_dim, + padding_idx=self.padding_idx) + + assert(args.encoder_conv_kernel_size % 2 == 1) + self.convolutions = nn.ModuleList( + nn.Sequential( + nn.Conv1d(args.encoder_embed_dim, args.encoder_embed_dim, + kernel_size=args.encoder_conv_kernel_size, + padding=((args.encoder_conv_kernel_size - 1) // 2)), + nn.BatchNorm1d(args.encoder_embed_dim), + nn.ReLU(), + nn.Dropout(args.encoder_dropout) + ) + for _ in range(args.encoder_conv_layers) + ) + + self.lstm = nn.LSTM(args.encoder_embed_dim, args.encoder_embed_dim // 2, + num_layers=args.encoder_lstm_layers, + batch_first=True, bidirectional=True) + + self.apply(encoder_init) + + def forward(self, src_tokens, src_lengths=None, speaker=None, **kwargs): + x = self.embed_tokens(src_tokens) + x = x.transpose(1, 2).contiguous() # B x T x C -> B x C x T + for conv in self.convolutions: + x = conv(x) + x = x.transpose(1, 2).contiguous() # B x C x T -> B x T x C + + src_lengths = src_lengths.cpu().long() + x = nn.utils.rnn.pack_padded_sequence(x, src_lengths, batch_first=True) + x = self.lstm(x)[0] + x = nn.utils.rnn.pad_packed_sequence(x, batch_first=True)[0] + + encoder_padding_mask = src_tokens.eq(self.padding_idx) + + if self.embed_speaker is not None: + seq_len, bsz, _ = x.size() + emb = self.embed_speaker(speaker).expand(seq_len, bsz, -1) + x = self.spk_emb_proj(torch.cat([x, emb], dim=2)) + + return { + "encoder_out": [x], # B x T x C + "encoder_padding_mask": encoder_padding_mask, # B x T + } + + +class Prenet(nn.Module): + def __init__(self, in_dim, n_layers, n_units, dropout): + super().__init__() + self.layers = nn.ModuleList( + nn.Sequential(nn.Linear(in_dim if i == 0 else n_units, n_units), + nn.ReLU()) + for i in range(n_layers) + ) + self.dropout = dropout + + def forward(self, x): + for layer in self.layers: + x = F.dropout(layer(x), p=self.dropout) # always applies dropout + return x + + +class Postnet(nn.Module): + def __init__(self, in_dim, n_channels, kernel_size, n_layers, dropout): + super(Postnet, self).__init__() + self.convolutions = nn.ModuleList() + assert(kernel_size % 2 == 1) + for i in range(n_layers): + cur_layers = [ + nn.Conv1d(in_dim if i == 0 else n_channels, + n_channels if i < n_layers - 1 else in_dim, + kernel_size=kernel_size, + padding=((kernel_size - 1) // 2)), + nn.BatchNorm1d(n_channels if i < n_layers - 1 else in_dim) + ] + ([nn.Tanh()] if i < n_layers - 1 else []) + [nn.Dropout(dropout)] + nn.init.xavier_uniform_( + cur_layers[0].weight, + torch.nn.init.calculate_gain( + "tanh" if i < n_layers - 1 else "linear" + ) + ) + self.convolutions.append(nn.Sequential(*cur_layers)) + + def forward(self, x): + x = x.transpose(1, 2) # B x T x C -> B x C x T + for conv in self.convolutions: + x = conv(x) + return x.transpose(1, 2) + + +def decoder_init(m): + if isinstance(m, torch.nn.Conv1d): + nn.init.xavier_uniform_(m.weight, torch.nn.init.calculate_gain("tanh")) + + +class Tacotron2Decoder(FairseqIncrementalDecoder): + def __init__(self, args, src_dict): + super().__init__(None) + self.args = args + self.n_frames_per_step = args.n_frames_per_step + self.out_dim = args.output_frame_dim * args.n_frames_per_step + + self.prenet = Prenet(self.out_dim, args.prenet_layers, args.prenet_dim, + args.prenet_dropout) + + # take prev_context, prev_frame, (speaker embedding) as input + self.attention_lstm = LSTMCellWithZoneOut( + args.zoneout, + args.prenet_dim + args.encoder_embed_dim, + args.decoder_lstm_dim + ) + + # take attention_lstm output, attention_state, encoder_out as input + self.attention = LocationAttention( + args.attention_dim, args.encoder_embed_dim, args.decoder_lstm_dim, + (1 + int(args.attention_use_cumprob)), + args.attention_conv_dim, args.attention_conv_kernel_size + ) + + # take attention_lstm output, context, (gated_latent) as input + self.lstm = nn.ModuleList( + LSTMCellWithZoneOut( + args.zoneout, + args.encoder_embed_dim + args.decoder_lstm_dim, + args.decoder_lstm_dim + ) + for i in range(args.decoder_lstm_layers) + ) + + proj_in_dim = args.encoder_embed_dim + args.decoder_lstm_dim + self.feat_proj = nn.Linear(proj_in_dim, self.out_dim) + self.eos_proj = nn.Linear(proj_in_dim, 1) + + self.postnet = Postnet(self.out_dim, args.postnet_conv_dim, + args.postnet_conv_kernel_size, + args.postnet_layers, args.postnet_dropout) + + self.ctc_proj = None + if getattr(args, "ctc_weight", 0.) > 0.: + self.ctc_proj = nn.Linear(self.out_dim, len(src_dict)) + + self.apply(decoder_init) + + def _get_states(self, incremental_state, enc_out): + bsz, in_len, _ = enc_out.size() + alstm_h = self.get_incremental_state(incremental_state, "alstm_h") + if alstm_h is None: + alstm_h = enc_out.new_zeros(bsz, self.args.decoder_lstm_dim) + alstm_c = self.get_incremental_state(incremental_state, "alstm_c") + if alstm_c is None: + alstm_c = enc_out.new_zeros(bsz, self.args.decoder_lstm_dim) + + lstm_h = self.get_incremental_state(incremental_state, "lstm_h") + if lstm_h is None: + lstm_h = [enc_out.new_zeros(bsz, self.args.decoder_lstm_dim) + for _ in range(self.args.decoder_lstm_layers)] + lstm_c = self.get_incremental_state(incremental_state, "lstm_c") + if lstm_c is None: + lstm_c = [enc_out.new_zeros(bsz, self.args.decoder_lstm_dim) + for _ in range(self.args.decoder_lstm_layers)] + + attn_w = self.get_incremental_state(incremental_state, "attn_w") + if attn_w is None: + attn_w = enc_out.new_zeros(bsz, in_len) + attn_w_cum = self.get_incremental_state(incremental_state, "attn_w_cum") + if attn_w_cum is None: + attn_w_cum = enc_out.new_zeros(bsz, in_len) + return alstm_h, alstm_c, lstm_h, lstm_c, attn_w, attn_w_cum + + def _get_init_attn_c(self, enc_out, enc_mask): + bsz = enc_out.size(0) + if self.args.init_attn_c == "zero": + return enc_out.new_zeros(bsz, self.args.encoder_embed_dim) + elif self.args.init_attn_c == "avg": + enc_w = (~enc_mask).type(enc_out.type()) + enc_w = enc_w / enc_w.sum(dim=1, keepdim=True) + return torch.sum(enc_out * enc_w.unsqueeze(2), dim=1) + else: + raise ValueError(f"{self.args.init_attn_c} not supported") + + def forward(self, prev_output_tokens, encoder_out=None, + incremental_state=None, target_lengths=None, **kwargs): + enc_mask = encoder_out["encoder_padding_mask"] + enc_out = encoder_out["encoder_out"][0] + in_len = enc_out.size(1) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:, :] + bsz, out_len, _ = prev_output_tokens.size() + + prenet_out = self.prenet(prev_output_tokens) + (alstm_h, alstm_c, lstm_h, lstm_c, + attn_w, attn_w_cum) = self._get_states(incremental_state, enc_out) + attn_ctx = self._get_init_attn_c(enc_out, enc_mask) + + attn_out = enc_out.new_zeros(bsz, in_len, out_len) + feat_out = enc_out.new_zeros(bsz, out_len, self.out_dim) + eos_out = enc_out.new_zeros(bsz, out_len) + for t in range(out_len): + alstm_in = torch.cat((attn_ctx, prenet_out[:, t, :]), dim=1) + alstm_h, alstm_c = self.attention_lstm(alstm_in, (alstm_h, alstm_c)) + + attn_state = attn_w.unsqueeze(1) + if self.args.attention_use_cumprob: + attn_state = torch.stack((attn_w, attn_w_cum), dim=1) + attn_ctx, attn_w = self.attention( + enc_out, enc_mask, alstm_h, attn_state + ) + attn_w_cum = attn_w_cum + attn_w + attn_out[:, :, t] = attn_w + + for i, cur_lstm in enumerate(self.lstm): + if i == 0: + lstm_in = torch.cat((attn_ctx, alstm_h), dim=1) + else: + lstm_in = torch.cat((attn_ctx, lstm_h[i - 1]), dim=1) + lstm_h[i], lstm_c[i] = cur_lstm(lstm_in, (lstm_h[i], lstm_c[i])) + + proj_in = torch.cat((attn_ctx, lstm_h[-1]), dim=1) + feat_out[:, t, :] = self.feat_proj(proj_in) + eos_out[:, t] = self.eos_proj(proj_in).squeeze(1) + self.attention.clear_cache() + + self.set_incremental_state(incremental_state, "alstm_h", alstm_h) + self.set_incremental_state(incremental_state, "alstm_c", alstm_c) + self.set_incremental_state(incremental_state, "lstm_h", lstm_h) + self.set_incremental_state(incremental_state, "lstm_c", lstm_c) + self.set_incremental_state(incremental_state, "attn_w", attn_w) + self.set_incremental_state(incremental_state, "attn_w_cum", attn_w_cum) + + post_feat_out = feat_out + self.postnet(feat_out) + eos_out = eos_out.view(bsz, out_len, 1) + return post_feat_out, eos_out, {"attn": attn_out, "feature_out": feat_out} + + +@register_model("tacotron_2") +class Tacotron2Model(FairseqEncoderDecoderModel): + """ + Implementation for https://arxiv.org/pdf/1712.05884.pdf + """ + + @staticmethod + def add_args(parser): + # encoder + parser.add_argument("--encoder-dropout", type=float) + parser.add_argument("--encoder-embed-dim", type=int) + parser.add_argument("--encoder-conv-layers", type=int) + parser.add_argument("--encoder-conv-kernel-size", type=int) + parser.add_argument("--encoder-lstm-layers", type=int) + # decoder + parser.add_argument("--attention-dim", type=int) + parser.add_argument("--attention-conv-dim", type=int) + parser.add_argument("--attention-conv-kernel-size", type=int) + parser.add_argument("--prenet-dropout", type=float) + parser.add_argument("--prenet-layers", type=int) + parser.add_argument("--prenet-dim", type=int) + parser.add_argument("--postnet-dropout", type=float) + parser.add_argument("--postnet-layers", type=int) + parser.add_argument("--postnet-conv-dim", type=int) + parser.add_argument("--postnet-conv-kernel-size", type=int) + parser.add_argument("--init-attn-c", type=str) + parser.add_argument("--attention-use-cumprob", action='store_true') + parser.add_argument("--zoneout", type=float) + parser.add_argument("--decoder-lstm-layers", type=int) + parser.add_argument("--decoder-lstm-dim", type=int) + parser.add_argument("--output-frame-dim", type=int) + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._num_updates = 0 + + @classmethod + def build_model(cls, args, task): + embed_speaker = task.get_speaker_embeddings(args) + encoder = Tacotron2Encoder(args, task.src_dict, embed_speaker) + decoder = Tacotron2Decoder(args, task.src_dict) + return cls(encoder, decoder) + + def forward_encoder(self, src_tokens, src_lengths, **kwargs): + return self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + + def set_num_updates(self, num_updates): + super().set_num_updates(num_updates) + self._num_updates = num_updates + + +@register_model_architecture("tacotron_2", "tacotron_2") +def base_architecture(args): + # encoder + args.encoder_dropout = getattr(args, "encoder_dropout", 0.5) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_conv_layers = getattr(args, "encoder_conv_layers", 3) + args.encoder_conv_kernel_size = getattr(args, "encoder_conv_kernel_size", 5) + args.encoder_lstm_layers = getattr(args, "encoder_lstm_layers", 1) + # decoder + args.attention_dim = getattr(args, "attention_dim", 128) + args.attention_conv_dim = getattr(args, "attention_conv_dim", 32) + args.attention_conv_kernel_size = getattr(args, + "attention_conv_kernel_size", 15) + args.prenet_dropout = getattr(args, "prenet_dropout", 0.5) + args.prenet_layers = getattr(args, "prenet_layers", 2) + args.prenet_dim = getattr(args, "prenet_dim", 256) + args.postnet_dropout = getattr(args, "postnet_dropout", 0.5) + args.postnet_layers = getattr(args, "postnet_layers", 5) + args.postnet_conv_dim = getattr(args, "postnet_conv_dim", 512) + args.postnet_conv_kernel_size = getattr(args, "postnet_conv_kernel_size", 5) + args.init_attn_c = getattr(args, "init_attn_c", "zero") + args.attention_use_cumprob = getattr(args, "attention_use_cumprob", True) + args.zoneout = getattr(args, "zoneout", 0.1) + args.decoder_lstm_layers = getattr(args, "decoder_lstm_layers", 2) + args.decoder_lstm_dim = getattr(args, "decoder_lstm_dim", 1024) + args.output_frame_dim = getattr(args, "output_frame_dim", 80) diff --git a/fairseq/fairseq/models/text_to_speech/tts_transformer.py b/fairseq/fairseq/models/text_to_speech/tts_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..ff7af78bd49708cc5429cd3d481d3866b4612779 --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/tts_transformer.py @@ -0,0 +1,371 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import List, Optional + +import torch +from torch import nn + +from fairseq.models import (FairseqEncoder, FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, register_model, + register_model_architecture) +from fairseq.modules import ( + TransformerEncoderLayer, TransformerDecoderLayer +) +from fairseq.models.text_to_speech.tacotron2 import Prenet, Postnet +from fairseq.modules import LayerNorm, PositionalEmbedding, FairseqDropout +from fairseq.data.data_utils import lengths_to_padding_mask +from fairseq import utils + +logger = logging.getLogger(__name__) + + +def encoder_init(m): + if isinstance(m, nn.Conv1d): + nn.init.xavier_uniform_(m.weight, torch.nn.init.calculate_gain("relu")) + + +def Embedding(num_embeddings, embedding_dim): + m = nn.Embedding(num_embeddings, embedding_dim) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + return m + + +class TTSTransformerEncoder(FairseqEncoder): + def __init__(self, args, src_dict, embed_speaker): + super().__init__(src_dict) + self.padding_idx = src_dict.pad() + self.embed_speaker = embed_speaker + self.spk_emb_proj = None + if embed_speaker is not None: + self.spk_emb_proj = nn.Linear( + args.encoder_embed_dim + args.speaker_embed_dim, + args.encoder_embed_dim + ) + + self.dropout_module = FairseqDropout( + p=args.dropout, module_name=self.__class__.__name__ + ) + self.embed_tokens = nn.Embedding(len(src_dict), args.encoder_embed_dim, + padding_idx=self.padding_idx) + assert(args.encoder_conv_kernel_size % 2 == 1) + self.prenet = nn.ModuleList( + nn.Sequential( + nn.Conv1d(args.encoder_embed_dim, args.encoder_embed_dim, + kernel_size=args.encoder_conv_kernel_size, + padding=((args.encoder_conv_kernel_size - 1) // 2)), + nn.BatchNorm1d(args.encoder_embed_dim), + nn.ReLU(), + nn.Dropout(args.encoder_dropout), + ) + for _ in range(args.encoder_conv_layers) + ) + self.prenet_proj = nn.Linear( + args.encoder_embed_dim, args.encoder_embed_dim + ) + self.embed_positions = PositionalEmbedding( + args.max_source_positions, args.encoder_embed_dim, self.padding_idx + ) + self.pos_emb_alpha = nn.Parameter(torch.ones(1)) + + self.transformer_layers = nn.ModuleList( + TransformerEncoderLayer(args) + for _ in range(args.encoder_transformer_layers) + ) + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(args.encoder_embed_dim) + else: + self.layer_norm = None + + self.apply(encoder_init) + + def forward(self, src_tokens, src_lengths=None, speaker=None, **kwargs): + x = self.embed_tokens(src_tokens) + x = x.transpose(1, 2).contiguous() # B x T x C -> B x C x T + for conv in self.prenet: + x = conv(x) + x = x.transpose(1, 2).contiguous() # B x C x T -> B x T x C + x = self.prenet_proj(x) + + padding_mask = src_tokens.eq(self.padding_idx) + positions = self.embed_positions(padding_mask) + x += self.pos_emb_alpha * positions + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + for layer in self.transformer_layers: + x = layer(x, padding_mask) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + if self.embed_speaker is not None: + seq_len, bsz, _ = x.size() + emb = self.embed_speaker(speaker).transpose(0, 1) + emb = emb.expand(seq_len, bsz, -1) + x = self.spk_emb_proj(torch.cat([x, emb], dim=2)) + + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [padding_mask] if padding_mask.any() else [], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": [], # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + } + + +def decoder_init(m): + if isinstance(m, torch.nn.Conv1d): + nn.init.xavier_uniform_(m.weight, torch.nn.init.calculate_gain("tanh")) + + +class TTSTransformerDecoder(FairseqIncrementalDecoder): + def __init__(self, args, src_dict): + super().__init__(None) + self._future_mask = torch.empty(0) + + self.args = args + self.padding_idx = src_dict.pad() + self.n_frames_per_step = args.n_frames_per_step + self.out_dim = args.output_frame_dim * args.n_frames_per_step + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.embed_positions = PositionalEmbedding( + args.max_target_positions, args.decoder_embed_dim, self.padding_idx + ) + self.pos_emb_alpha = nn.Parameter(torch.ones(1)) + self.prenet = nn.Sequential( + Prenet(self.out_dim, args.prenet_layers, args.prenet_dim, + args.prenet_dropout), + nn.Linear(args.prenet_dim, args.decoder_embed_dim), + ) + + self.n_transformer_layers = args.decoder_transformer_layers + self.transformer_layers = nn.ModuleList( + TransformerDecoderLayer(args) + for _ in range(self.n_transformer_layers) + ) + if args.decoder_normalize_before: + self.layer_norm = LayerNorm(args.decoder_embed_dim) + else: + self.layer_norm = None + + self.feat_proj = nn.Linear(args.decoder_embed_dim, self.out_dim) + self.eos_proj = nn.Linear(args.decoder_embed_dim, 1) + + self.postnet = Postnet(self.out_dim, args.postnet_conv_dim, + args.postnet_conv_kernel_size, + args.postnet_layers, args.postnet_dropout) + + self.ctc_proj = None + if getattr(args, "ctc_weight", 0.) > 0.: + self.ctc_proj = nn.Linear(self.out_dim, len(src_dict)) + + self.apply(decoder_init) + + def extract_features( + self, prev_outputs, encoder_out=None, incremental_state=None, + target_lengths=None, speaker=None, **kwargs + ): + alignment_layer = self.n_transformer_layers - 1 + self_attn_padding_mask = lengths_to_padding_mask(target_lengths) + positions = self.embed_positions( + self_attn_padding_mask, incremental_state=incremental_state + ) + + if incremental_state is not None: + prev_outputs = prev_outputs[:, -1:, :] + self_attn_padding_mask = self_attn_padding_mask[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + x = self.prenet(prev_outputs) + x += self.pos_emb_alpha * positions + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + if not self_attn_padding_mask.any(): + self_attn_padding_mask = None + + attn: Optional[torch.Tensor] = None + inner_states: List[Optional[torch.Tensor]] = [x] + for idx, transformer_layer in enumerate(self.transformer_layers): + if incremental_state is None: + self_attn_mask = self.buffered_future_mask(x) + else: + self_attn_mask = None + + x, layer_attn, _ = transformer_layer( + x, + encoder_out["encoder_out"][0] + if (encoder_out is not None and len(encoder_out["encoder_out"]) > 0) + else None, + encoder_out["encoder_padding_mask"][0] + if ( + encoder_out is not None + and len(encoder_out["encoder_padding_mask"]) > 0 + ) + else None, + incremental_state, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=self_attn_padding_mask, + need_attn=bool((idx == alignment_layer)), + need_head_weights=bool((idx == alignment_layer)), + ) + inner_states.append(x) + if layer_attn is not None and idx == alignment_layer: + attn = layer_attn.float().to(x) + + if attn is not None: + # average probabilities over heads, transpose to + # (B, src_len, tgt_len) + attn = attn.mean(dim=0).transpose(2, 1) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + return x, {"attn": attn, "inner_states": inner_states} + + def forward(self, prev_output_tokens, encoder_out=None, + incremental_state=None, target_lengths=None, speaker=None, + **kwargs): + x, extra = self.extract_features( + prev_output_tokens, encoder_out=encoder_out, + incremental_state=incremental_state, target_lengths=target_lengths, + speaker=speaker, **kwargs + ) + attn = extra["attn"] + feat_out = self.feat_proj(x) + bsz, seq_len, _ = x.size() + eos_out = self.eos_proj(x) + post_feat_out = feat_out + self.postnet(feat_out) + return post_feat_out, eos_out, {"attn": attn, "feature_out": feat_out} + + def get_normalized_probs(self, net_output, log_probs, sample): + logits = self.ctc_proj(net_output[2]["feature_out"]) + if log_probs: + return utils.log_softmax(logits.float(), dim=-1) + else: + return utils.softmax(logits.float(), dim=-1) + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + # self._future_mask.device != tensor.device is not working in TorchScript. This is a workaround. + if ( + self._future_mask.size(0) == 0 + or (not self._future_mask.device == tensor.device) + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(torch.zeros([dim, dim])), 1 + ) + self._future_mask = self._future_mask.to(tensor) + return self._future_mask[:dim, :dim] + + +@register_model("tts_transformer") +class TTSTransformerModel(FairseqEncoderDecoderModel): + """ + Implementation for https://arxiv.org/pdf/1809.08895.pdf + """ + + @staticmethod + def add_args(parser): + parser.add_argument("--dropout", type=float) + parser.add_argument("--output-frame-dim", type=int) + parser.add_argument("--speaker-embed-dim", type=int) + # encoder prenet + parser.add_argument("--encoder-dropout", type=float) + parser.add_argument("--encoder-conv-layers", type=int) + parser.add_argument("--encoder-conv-kernel-size", type=int) + # encoder transformer layers + parser.add_argument("--encoder-transformer-layers", type=int) + parser.add_argument("--encoder-embed-dim", type=int) + parser.add_argument("--encoder-ffn-embed-dim", type=int) + parser.add_argument("--encoder-normalize-before", action="store_true") + parser.add_argument("--encoder-attention-heads", type=int) + parser.add_argument("--attention-dropout", type=float) + parser.add_argument("--activation-dropout", "--relu-dropout", type=float) + parser.add_argument("--activation-fn", type=str, default="relu") + # decoder prenet + parser.add_argument("--prenet-dropout", type=float) + parser.add_argument("--prenet-layers", type=int) + parser.add_argument("--prenet-dim", type=int) + # decoder postnet + parser.add_argument("--postnet-dropout", type=float) + parser.add_argument("--postnet-layers", type=int) + parser.add_argument("--postnet-conv-dim", type=int) + parser.add_argument("--postnet-conv-kernel-size", type=int) + # decoder transformer layers + parser.add_argument("--decoder-transformer-layers", type=int) + parser.add_argument("--decoder-embed-dim", type=int) + parser.add_argument("--decoder-ffn-embed-dim", type=int) + parser.add_argument("--decoder-normalize-before", action="store_true") + parser.add_argument("--decoder-attention-heads", type=int) + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._num_updates = 0 + + @classmethod + def build_model(cls, args, task): + embed_speaker = task.get_speaker_embeddings(args) + encoder = TTSTransformerEncoder(args, task.src_dict, embed_speaker) + decoder = TTSTransformerDecoder(args, task.src_dict) + return cls(encoder, decoder) + + def forward_encoder(self, src_tokens, src_lengths, speaker=None, **kwargs): + return self.encoder(src_tokens, src_lengths=src_lengths, + speaker=speaker, **kwargs) + + def set_num_updates(self, num_updates): + super().set_num_updates(num_updates) + self._num_updates = num_updates + + +@register_model_architecture("tts_transformer", "tts_transformer") +def base_architecture(args): + args.dropout = getattr(args, "dropout", 0.1) + args.output_frame_dim = getattr(args, "output_frame_dim", 80) + args.speaker_embed_dim = getattr(args, "speaker_embed_dim", 64) + # encoder prenet + args.encoder_dropout = getattr(args, "encoder_dropout", 0.5) + args.encoder_conv_layers = getattr(args, "encoder_conv_layers", 3) + args.encoder_conv_kernel_size = getattr(args, "encoder_conv_kernel_size", 5) + # encoder transformer layers + args.encoder_transformer_layers = getattr(args, "encoder_transformer_layers", 6) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * args.encoder_embed_dim) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + # decoder prenet + args.prenet_dropout = getattr(args, "prenet_dropout", 0.5) + args.prenet_layers = getattr(args, "prenet_layers", 2) + args.prenet_dim = getattr(args, "prenet_dim", 256) + # decoder postnet + args.postnet_dropout = getattr(args, "postnet_dropout", 0.5) + args.postnet_layers = getattr(args, "postnet_layers", 5) + args.postnet_conv_dim = getattr(args, "postnet_conv_dim", 512) + args.postnet_conv_kernel_size = getattr(args, "postnet_conv_kernel_size", 5) + # decoder transformer layers + args.decoder_transformer_layers = getattr(args, "decoder_transformer_layers", 6) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4 * args.decoder_embed_dim) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) diff --git a/fairseq/fairseq/models/text_to_speech/vocoder.py b/fairseq/fairseq/models/text_to_speech/vocoder.py new file mode 100644 index 0000000000000000000000000000000000000000..65d9f9f06bfe7ffa3ed332bb41c4cdd65ac2b916 --- /dev/null +++ b/fairseq/fairseq/models/text_to_speech/vocoder.py @@ -0,0 +1,197 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import json +from typing import Dict + +import numpy as np +import torch +from torch import nn +import torch.nn.functional as F + +from fairseq.data.audio.audio_utils import ( + get_window, get_fourier_basis, get_mel_filters, TTSSpectrogram +) +from fairseq.data.audio.speech_to_text_dataset import S2TDataConfig +from fairseq.models.text_to_speech.hifigan import Generator as HiFiGANModel + +logger = logging.getLogger(__name__) + + +class PseudoInverseMelScale(torch.nn.Module): + def __init__(self, n_stft, n_mels, sample_rate, f_min, f_max) -> None: + super(PseudoInverseMelScale, self).__init__() + self.n_mels = n_mels + basis = get_mel_filters( + sample_rate, (n_stft - 1) * 2, n_mels, f_min, f_max + ) + basis = torch.pinverse(basis) # F x F_mel + self.register_buffer('basis', basis) + + def forward(self, melspec: torch.Tensor) -> torch.Tensor: + # pack batch + shape = melspec.shape # B_1 x ... x B_K x F_mel x T + n_mels, time = shape[-2], shape[-1] + melspec = melspec.view(-1, n_mels, time) + + freq, _ = self.basis.size() # F x F_mel + assert self.n_mels == n_mels, (self.n_mels, n_mels) + specgram = self.basis.matmul(melspec).clamp(min=0) + + # unpack batch + specgram = specgram.view(shape[:-2] + (freq, time)) + return specgram + + +class GriffinLim(torch.nn.Module): + def __init__( + self, n_fft: int, win_length: int, hop_length: int, n_iter: int, + window_fn=torch.hann_window + ): + super(GriffinLim, self).__init__() + self.transform = TTSSpectrogram( + n_fft, win_length, hop_length, return_phase=True + ) + + basis = get_fourier_basis(n_fft) + basis = torch.pinverse(n_fft / hop_length * basis).T[:, None, :] + basis *= get_window(window_fn, n_fft, win_length) + self.register_buffer('basis', basis) + + self.n_fft = n_fft + self.win_length = win_length + self.hop_length = hop_length + self.n_iter = n_iter + + self.tiny = 1.1754944e-38 + + @classmethod + def get_window_sum_square( + cls, n_frames, hop_length, win_length, n_fft, + window_fn=torch.hann_window + ) -> torch.Tensor: + w_sq = get_window(window_fn, n_fft, win_length) ** 2 + n = n_fft + hop_length * (n_frames - 1) + x = torch.zeros(n, dtype=torch.float32) + for i in range(n_frames): + ofst = i * hop_length + x[ofst: min(n, ofst + n_fft)] += w_sq[:max(0, min(n_fft, n - ofst))] + return x + + def inverse(self, magnitude: torch.Tensor, phase) -> torch.Tensor: + x = torch.cat( + [magnitude * torch.cos(phase), magnitude * torch.sin(phase)], + dim=1 + ) + x = F.conv_transpose1d(x, self.basis, stride=self.hop_length) + win_sum_sq = self.get_window_sum_square( + magnitude.shape[-1], hop_length=self.hop_length, + win_length=self.win_length, n_fft=self.n_fft + ).to(magnitude.device) + # remove modulation effects + approx_nonzero_indices = win_sum_sq > self.tiny + x[:, :, approx_nonzero_indices] /= win_sum_sq[approx_nonzero_indices] + x *= self.n_fft / self.hop_length + x = x[:, :, self.n_fft // 2:] + x = x[:, :, :-self.n_fft // 2:] + return x + + def forward(self, specgram: torch.Tensor) -> torch.Tensor: + angles = np.angle(np.exp(2j * np.pi * np.random.rand(*specgram.shape))) + angles = torch.from_numpy(angles).to(specgram) + _specgram = specgram.view(-1, specgram.shape[-2], specgram.shape[-1]) + waveform = self.inverse(_specgram, angles).squeeze(1) + for _ in range(self.n_iter): + _, angles = self.transform(waveform) + waveform = self.inverse(_specgram, angles).squeeze(1) + return waveform.squeeze(0) + + +class GriffinLimVocoder(nn.Module): + def __init__(self, sample_rate, win_size, hop_size, n_fft, + n_mels, f_min, f_max, window_fn, + spec_bwd_max_iter=32, + fp16=False): + super().__init__() + self.inv_mel_transform = PseudoInverseMelScale( + n_stft=n_fft // 2 + 1, n_mels=n_mels, sample_rate=sample_rate, + f_min=f_min, f_max=f_max + ) + self.gl_transform = GriffinLim( + n_fft=n_fft, win_length=win_size, hop_length=hop_size, + window_fn=window_fn, n_iter=spec_bwd_max_iter + ) + if fp16: + self.half() + self.inv_mel_transform.half() + self.gl_transform.half() + else: + self.float() + self.inv_mel_transform.float() + self.gl_transform.float() + + def forward(self, x): + # x: (B x) T x D -> (B x) 1 x T + # NOTE: batched forward produces noisier waveform. recommend running + # one utterance at a time + self.eval() + x = x.exp().transpose(-1, -2) + x = self.inv_mel_transform(x) + x = self.gl_transform(x) + return x + + @classmethod + def from_data_cfg(cls, args, data_cfg: S2TDataConfig): + feat_cfg = data_cfg.config["features"] + window_fn = getattr(torch, feat_cfg["window_fn"] + "_window") + return cls( + sample_rate=feat_cfg["sample_rate"], + win_size=int(feat_cfg["win_len_t"] * feat_cfg["sample_rate"]), + hop_size=int(feat_cfg["hop_len_t"] * feat_cfg["sample_rate"]), + n_fft=feat_cfg["n_fft"], n_mels=feat_cfg["n_mels"], + f_min=feat_cfg["f_min"], f_max=feat_cfg["f_max"], + window_fn=window_fn, spec_bwd_max_iter=args.spec_bwd_max_iter, + fp16=args.fp16 + ) + + +class HiFiGANVocoder(nn.Module): + def __init__( + self, checkpoint_path: str, model_cfg: Dict[str, str], + fp16: bool = False + ) -> None: + super().__init__() + self.model = HiFiGANModel(model_cfg) + state_dict = torch.load(checkpoint_path) + self.model.load_state_dict(state_dict["generator"]) + if fp16: + self.model.half() + logger.info(f"loaded HiFiGAN checkpoint from {checkpoint_path}") + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # (B x) T x D -> (B x) 1 x T + model = self.model.eval() + if len(x.shape) == 2: + return model(x.unsqueeze(0).transpose(1, 2)).detach().squeeze(0) + else: + return model(x.transpose(-1, -2)).detach() + + @classmethod + def from_data_cfg(cls, args, data_cfg: S2TDataConfig): + vocoder_cfg = data_cfg.vocoder + assert vocoder_cfg.get("type", "griffin_lim") == "hifigan" + with open(vocoder_cfg["config"]) as f: + model_cfg = json.load(f) + return cls(vocoder_cfg["checkpoint"], model_cfg, fp16=args.fp16) + + +def get_vocoder(args, data_cfg: S2TDataConfig): + if args.vocoder == "griffin_lim": + return GriffinLimVocoder.from_data_cfg(args, data_cfg) + elif args.vocoder == "hifigan": + return HiFiGANVocoder.from_data_cfg(args, data_cfg) + else: + raise ValueError("Unknown vocoder") diff --git a/fairseq/fairseq/models/transformer/__init__.py b/fairseq/fairseq/models/transformer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..681fca3d4553f6832a65f61fc186793bc4ee0679 --- /dev/null +++ b/fairseq/fairseq/models/transformer/__init__.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +from .transformer_config import ( + TransformerConfig, + DEFAULT_MAX_SOURCE_POSITIONS, + DEFAULT_MAX_TARGET_POSITIONS, + DEFAULT_MIN_PARAMS_TO_WRAP, +) +from .transformer_decoder import TransformerDecoder, TransformerDecoderBase, Linear +from .transformer_encoder import TransformerEncoder, TransformerEncoderBase +from .transformer_legacy import ( + TransformerModel, + base_architecture, + tiny_architecture, + transformer_iwslt_de_en, + transformer_wmt_en_de, + transformer_vaswani_wmt_en_de_big, + transformer_vaswani_wmt_en_fr_big, + transformer_wmt_en_de_big, + transformer_wmt_en_de_big_t2t, +) +from .transformer_base import TransformerModelBase, Embedding + + +__all__ = [ + "TransformerModelBase", + "TransformerConfig", + "TransformerDecoder", + "TransformerDecoderBase", + "TransformerEncoder", + "TransformerEncoderBase", + "TransformerModel", + "Embedding", + "Linear", + "base_architecture", + "tiny_architecture", + "transformer_iwslt_de_en", + "transformer_wmt_en_de", + "transformer_vaswani_wmt_en_de_big", + "transformer_vaswani_wmt_en_fr_big", + "transformer_wmt_en_de_big", + "transformer_wmt_en_de_big_t2t", + "DEFAULT_MAX_SOURCE_POSITIONS", + "DEFAULT_MAX_TARGET_POSITIONS", + "DEFAULT_MIN_PARAMS_TO_WRAP", +] diff --git a/fairseq/fairseq/models/transformer/transformer_base.py b/fairseq/fairseq/models/transformer/transformer_base.py new file mode 100644 index 0000000000000000000000000000000000000000..b4d5604dbbae979b424650882d33b45ebab323e6 --- /dev/null +++ b/fairseq/fairseq/models/transformer/transformer_base.py @@ -0,0 +1,179 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.dataclass.utils import gen_parser_from_dataclass +from fairseq.distributed import fsdp_wrap +from fairseq.models import FairseqEncoderDecoderModel +from fairseq.models.transformer import ( + TransformerEncoderBase, + TransformerDecoderBase, + TransformerConfig, +) +from torch import Tensor + + +class TransformerModelBase(FairseqEncoderDecoderModel): + """ + Transformer model from `"Attention Is All You Need" (Vaswani, et al, 2017) + <https://arxiv.org/abs/1706.03762>`_. + + Args: + encoder (TransformerEncoder): the encoder + decoder (TransformerDecoder): the decoder + + The Transformer model provides the following named architectures and + command-line arguments: + + .. argparse:: + :ref: fairseq.models.transformer_parser + :prog: + """ + + def __init__(self, cfg, encoder, decoder): + super().__init__(encoder, decoder) + self.cfg = cfg + self.supports_align_args = True + + @classmethod + def add_args(cls, parser): + """Add model-specific arguments to the parser.""" + # we want to build the args recursively in this case. + gen_parser_from_dataclass( + parser, TransformerConfig(), delete_default=False, with_prefix="" + ) + + @classmethod + def build_model(cls, cfg, task): + """Build a new model instance.""" + + # -- TODO T96535332 + # bug caused by interaction between OmegaConf II and argparsing + cfg.decoder.input_dim = int(cfg.decoder.input_dim) + cfg.decoder.output_dim = int(cfg.decoder.output_dim) + # -- + + if cfg.encoder.layers_to_keep: + cfg.encoder.layers = len(cfg.encoder.layers_to_keep.split(",")) + if cfg.decoder.layers_to_keep: + cfg.decoder.layers = len(cfg.decoder.layers_to_keep.split(",")) + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + if cfg.share_all_embeddings: + if src_dict != tgt_dict: + raise ValueError("--share-all-embeddings requires a joined dictionary") + if cfg.encoder.embed_dim != cfg.decoder.embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if cfg.decoder.embed_path and ( + cfg.decoder.embed_path != cfg.encoder.embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = cls.build_embedding( + cfg, src_dict, cfg.encoder.embed_dim, cfg.encoder.embed_path + ) + decoder_embed_tokens = encoder_embed_tokens + cfg.share_decoder_input_output_embed = True + else: + encoder_embed_tokens = cls.build_embedding( + cfg, src_dict, cfg.encoder.embed_dim, cfg.encoder.embed_path + ) + decoder_embed_tokens = cls.build_embedding( + cfg, tgt_dict, cfg.decoder.embed_dim, cfg.decoder.embed_path + ) + if cfg.offload_activations: + cfg.checkpoint_activations = True # offloading implies checkpointing + encoder = cls.build_encoder(cfg, src_dict, encoder_embed_tokens) + decoder = cls.build_decoder(cfg, tgt_dict, decoder_embed_tokens) + if not cfg.share_all_embeddings: + # fsdp_wrap is a no-op when --ddp-backend != fully_sharded + encoder = fsdp_wrap(encoder, min_num_params=cfg.min_params_to_wrap) + decoder = fsdp_wrap(decoder, min_num_params=cfg.min_params_to_wrap) + return cls(cfg, encoder, decoder) + + @classmethod + def build_embedding(cls, cfg, dictionary, embed_dim, path=None): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + + emb = Embedding(num_embeddings, embed_dim, padding_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + @classmethod + def build_encoder(cls, cfg, src_dict, embed_tokens): + return TransformerEncoderBase(cfg, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, cfg, tgt_dict, embed_tokens): + return TransformerDecoderBase( + cfg, + tgt_dict, + embed_tokens, + no_encoder_attn=cfg.no_cross_attention, + ) + + # TorchScript doesn't support optional arguments with variable length (**kwargs). + # Current workaround is to add union of all arguments in child classes. + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + return_all_hiddens: bool = True, + features_only: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Run the forward pass for an encoder-decoder model. + + Copied from the base class, but without ``**kwargs``, + which are not supported by TorchScript. + """ + encoder_out = self.encoder( + src_tokens, src_lengths=src_lengths, return_all_hiddens=return_all_hiddens + ) + decoder_out = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + return decoder_out + + # Since get_normalized_probs is in the Fairseq Model which is not scriptable, + # I rewrite the get_normalized_probs from Base Class to call the + # helper function in the Base Class. + @torch.jit.export + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + return self.get_normalized_probs_scriptable(net_output, log_probs, sample) + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + return m diff --git a/fairseq/fairseq/models/transformer/transformer_config.py b/fairseq/fairseq/models/transformer/transformer_config.py new file mode 100644 index 0000000000000000000000000000000000000000..2580d20aacc5be4680971646d9523489d903c56c --- /dev/null +++ b/fairseq/fairseq/models/transformer/transformer_config.py @@ -0,0 +1,318 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import re +from dataclasses import dataclass, field, fields +from typing import List, Optional + +from fairseq import utils +from fairseq.dataclass import FairseqDataclass, ChoiceEnum +from omegaconf import II + +DEFAULT_MAX_SOURCE_POSITIONS = 1024 +DEFAULT_MAX_TARGET_POSITIONS = 1024 + +DEFAULT_MIN_PARAMS_TO_WRAP = int(1e8) + +_NAME_PARSER = r"(decoder|encoder|quant_noise)_(.*)" + + +@dataclass +class EncDecBaseConfig(FairseqDataclass): + embed_path: Optional[str] = field( + default=None, metadata={"help": "path to pre-trained embedding"} + ) + embed_dim: Optional[int] = field( + default=512, metadata={"help": "embedding dimension"} + ) + ffn_embed_dim: int = field( + default=2048, metadata={"help": "embedding dimension for FFN"} + ) + layers: int = field(default=6, metadata={"help": "number of layers"}) + attention_heads: int = field( + default=8, metadata={"help": "number of attention heads"} + ) + normalize_before: bool = field( + default=False, metadata={"help": "apply layernorm before each block"} + ) + learned_pos: bool = field( + default=False, metadata={"help": "use learned positional embeddings"} + ) + # args for "Reducing Transformer Depth on Demand with Structured Dropout" (Fan et al., 2019) + layerdrop: float = field(default=0, metadata={"help": "LayerDrop probability"}) + layers_to_keep: Optional[List[int]] = field( + default=None, metadata={"help": "which layers to *keep* when pruning"} + ) + + +@dataclass +class DecoderConfig(EncDecBaseConfig): + input_dim: int = II("model.decoder.embed_dim") + output_dim: int = field( + default=II("model.decoder.embed_dim"), + metadata={ + "help": "decoder output dimension (extra linear layer if different from decoder embed dim)" + }, + ) + + def __post_init__(self): + # II doesn't work if we are just creating the object outside of hydra so fix that + if self.input_dim == II("model.decoder.embed_dim"): + self.input_dim = self.embed_dim + if self.output_dim == II("model.decoder.embed_dim"): + self.output_dim = self.embed_dim + + +@dataclass +class QuantNoiseConfig(FairseqDataclass): + pq: float = field( + default=0.0, + metadata={"help": "iterative PQ quantization noise at training time"}, + ) + pq_block_size: int = field( + default=8, + metadata={"help": "block size of quantization noise at training time"}, + ) + scalar: float = field( + default=0.0, + metadata={ + "help": "scalar quantization noise and scalar quantization at training time" + }, + ) + + +@dataclass +class TransformerConfig(FairseqDataclass): + activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field( + default="relu", + metadata={"help": "activation function to use"}, + ) + dropout: float = field(default=0.1, metadata={"help": "dropout probability"}) + attention_dropout: float = field( + default=0.0, metadata={"help": "dropout probability for attention weights"} + ) + activation_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability after activation in FFN.", + "alias": "--relu-dropout", + }, + ) + adaptive_input: bool = False + encoder: EncDecBaseConfig = EncDecBaseConfig() + # TODO should really be in the encoder config + max_source_positions: int = field( + default=DEFAULT_MAX_SOURCE_POSITIONS, + metadata={"help": "Maximum input length supported by the encoder"}, + ) + decoder: DecoderConfig = DecoderConfig() + # TODO should really be in the decoder config + max_target_positions: int = field( + default=DEFAULT_MAX_TARGET_POSITIONS, + metadata={"help": "Maximum output length supported by the decoder"}, + ) + share_decoder_input_output_embed: bool = field( + default=False, metadata={"help": "share decoder input and output embeddings"} + ) + share_all_embeddings: bool = field( + default=False, + metadata={ + "help": "share encoder, decoder and output embeddings (requires shared dictionary and embed dim)" + }, + ) + no_token_positional_embeddings: bool = field( + default=False, + metadata={ + "help": "if True, disables positional embeddings (outside self attention)" + }, + ) + adaptive_softmax_cutoff: Optional[List[int]] = field( + default=None, + metadata={ + "help": "list of adaptive softmax cutoff points. Must be used with adaptive_loss criterion" + }, + ) + adaptive_softmax_dropout: float = field( + default=0.0, + metadata={"help": "sets adaptive softmax dropout for the tail projections"}, + ) + adaptive_softmax_factor: float = field( + default=4, metadata={"help": "adaptive input factor"} + ) + layernorm_embedding: bool = field( + default=False, metadata={"help": "add layernorm to embedding"} + ) + tie_adaptive_weights: bool = field( + default=False, + metadata={ + "help": "if set, ties the weights of adaptive softmax and adaptive input" + }, + ) + tie_adaptive_proj: bool = field( + default=False, + metadata={ + "help": "if set, ties the projection weights of adaptive softmax and adaptive input" + }, + ) + no_scale_embedding: bool = field( + default=False, metadata={"help": "if True, dont scale embeddings"} + ) + checkpoint_activations: bool = field( + default=False, + metadata={ + "help": "checkpoint activations at each layer, which saves GPU memory usage at the cost of some additional compute" + }, + ) + offload_activations: bool = field( + default=False, + metadata={ + "help": "checkpoint activations at each layer, then save to gpu. Sets --checkpoint-activations." + }, + ) + # args for "Cross+Self-Attention for Transformer Models" (Peitz et al., 2019) + no_cross_attention: bool = field( + default=False, metadata={"help": "do not perform cross-attention"} + ) + cross_self_attention: bool = field( + default=False, metadata={"help": "perform cross+self-attention"} + ) + # args for Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020) + quant_noise: QuantNoiseConfig = field(default=QuantNoiseConfig()) + min_params_to_wrap: int = field( + default=DEFAULT_MIN_PARAMS_TO_WRAP, + metadata={ + "help": "minimum number of params for a layer to be wrapped with FSDP() when " + "training with --ddp-backend=fully_sharded. Smaller values will " + "improve memory efficiency, but may make torch.distributed " + "communication less efficient due to smaller input sizes. This option " + "is set to 0 (i.e., always wrap) when --checkpoint-activations or " + "--offload-activations are passed." + }, + ) + # DEPRECATED field, but some old checkpoints might have it + char_inputs: bool = field( + default=False, metadata={"help": "if set, model takes character ids as input"} + ) + relu_dropout: float = 0.0 + # config for "BASE Layers: Simplifying Training of Large, Sparse Models" + base_layers: Optional[int] = field( + default=0, metadata={"help": "number of BASE layers in total"} + ) + base_sublayers: Optional[int] = field( + default=1, metadata={"help": "number of sublayers in each BASE layer"} + ) + base_shuffle: Optional[int] = field( + default=1, + metadata={"help": "shuffle tokens between workers before computing assignment"}, + ) + + export: bool = field( + default=False, + metadata={"help": "make the layernorm exportable with torchscript."}, + ) + + # copied from transformer_lm but expected in transformer_decoder: + no_decoder_final_norm: bool = field( + default=False, + metadata={"help": "don't add an extra layernorm after the last decoder block"}, + ) + + # We need to make this hierarchical dataclass like the flat namespace + # __getattr__ and __setattr__ here allow backward compatibility + # for subclasses of Transformer(Legacy) that depend on read/write on + # the flat namespace. + + def __getattr__(self, name): + match = re.match(_NAME_PARSER, name) + if match: + sub = getattr(self, match[1]) + return getattr(sub, match[2]) + raise AttributeError(f"invalid argument {name}.") + + def __setattr__(self, name, value): + match = re.match(_NAME_PARSER, name) + if match: + sub = getattr(self, match[1]) + setattr(sub, match[2], value) + else: + super().__setattr__(name, value) + + @staticmethod + def _copy_keys(args, cls, prefix, seen): + """ + copy the prefixed keys (decoder_embed_dim) to the DC fields: decoder.embed_dim + """ + cfg = cls() + for fld in fields(cls): + # for all the fields in the DC, find the fields (e.g. embed_dim) + # in the namespace with the prefix (e.g. decoder) + # and set it on the dc. + args_key = f"{prefix}_{fld.name}" + if hasattr(args, args_key): + seen.add(args_key) + setattr(cfg, fld.name, getattr(args, args_key)) + if hasattr(args, fld.name): + seen.add(fld.name) + setattr(cfg, fld.name, getattr(args, fld.name)) + return cfg + + @classmethod + def from_namespace(cls, args): + if args is None: + return None + if not isinstance(args, cls): + seen = set() + config = cls() + # currently, we can go generically from DC fields to args hierarchically + # but we can't easily deconstruct a flat namespace to a hierarchical + # DC. Mostly because we could have a sub-dc called `decoder-foo` that should not + # go to the sub struct called `decoder`. There are ways to go around this, but let's keep it simple + # for now. + for fld in fields(cls): + # concretelly, the transformer_config know what sub-dc it has, so we go through all the dc fields + # and if it's one that has a sub-dc, we build that sub-dc with `copy_keys()` + if fld.name == "decoder": + if hasattr(args, "decoder"): + # in some cases, the args we receive is already structured (as DictConfigs), so let's just build the correct DC + seen.add("decoder") + config.decoder = DecoderConfig(**args.decoder) + else: + config.decoder = cls._copy_keys( + args, DecoderConfig, "decoder", seen + ) + elif fld.name == "encoder": + # same but for encoder + if hasattr(args, "encoder"): + seen.add("encoder") + config.encoder = EncDecBaseConfig(**args.encoder) + else: + config.encoder = cls._copy_keys( + args, EncDecBaseConfig, "encoder", seen + ) + elif fld.name == "quant_noise": + # same but for quant_noise + if hasattr(args, "quant_noise"): + seen.add("quant_noise") + config.quant_noise = QuantNoiseConfig(**args.quant_noise) + else: + config.quant_noise = cls._copy_keys( + args, QuantNoiseConfig, "quant_noise", seen + ) + elif hasattr(args, fld.name): + # if it's not a structure field, it's just a normal field, copy it over + seen.add(fld.name) + setattr(config, fld.name, getattr(args, fld.name)) + # we got all the fields defined in the dataclass, but + # the argparse namespace might have extra args for two reasons: + # - we are in a legacy class so all the args are not declared in the dataclass. Ideally once everyone has defined a dataclass for their model, we won't need this + # - some places expect args to be there but never define them + args_dict = args._asdict() if hasattr(args, '_asdict') else vars(args) if hasattr(args, '__dict__') else {} # namedtupled doesn't have __dict__ :-/ + for key, value in args_dict.items(): + if key not in seen: + setattr(config, key, value) + return config + else: + return args diff --git a/fairseq/fairseq/models/transformer/transformer_decoder.py b/fairseq/fairseq/models/transformer/transformer_decoder.py new file mode 100644 index 0000000000000000000000000000000000000000..49e37917ccca2e847917ad25ed15cc6df716ccd8 --- /dev/null +++ b/fairseq/fairseq/models/transformer/transformer_decoder.py @@ -0,0 +1,482 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Any, Dict, List, Optional + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.distributed import fsdp_wrap +from fairseq.models import FairseqIncrementalDecoder +from fairseq.models.transformer import TransformerConfig +from fairseq.modules import ( + AdaptiveSoftmax, + BaseLayer, + FairseqDropout, + LayerDropModuleList, + LayerNorm, + PositionalEmbedding, + SinusoidalPositionalEmbedding, +) +from fairseq.modules import transformer_layer +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ +from torch import Tensor + + +# rewrite name for backward compatibility in `make_generation_fast_` +def module_name_fordropout(module_name: str) -> str: + if module_name == 'TransformerDecoderBase': + return 'TransformerDecoder' + else: + return module_name + + +class TransformerDecoderBase(FairseqIncrementalDecoder): + """ + Transformer decoder consisting of *cfg.decoder.layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, + cfg, + dictionary, + embed_tokens, + no_encoder_attn=False, + output_projection=None, + ): + self.cfg = cfg + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + self._future_mask = torch.empty(0) + + self.dropout_module = FairseqDropout( + cfg.dropout, module_name=module_name_fordropout(self.__class__.__name__) + ) + self.decoder_layerdrop = cfg.decoder.layerdrop + self.share_input_output_embed = cfg.share_decoder_input_output_embed + + input_embed_dim = embed_tokens.embedding_dim + embed_dim = cfg.decoder.embed_dim + self.embed_dim = embed_dim + self.output_embed_dim = cfg.decoder.output_dim + + self.padding_idx = embed_tokens.padding_idx + self.max_target_positions = cfg.max_target_positions + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if cfg.no_scale_embedding else math.sqrt(embed_dim) + + if not cfg.adaptive_input and cfg.quant_noise.pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + cfg.quant_noise.pq, + cfg.quant_noise.pq_block_size, + ) + else: + self.quant_noise = None + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + self.embed_positions = ( + PositionalEmbedding( + self.max_target_positions, + embed_dim, + self.padding_idx, + learned=cfg.decoder.learned_pos, + ) + if not cfg.no_token_positional_embeddings + else None + ) + if cfg.layernorm_embedding: + self.layernorm_embedding = LayerNorm(embed_dim, export=cfg.export) + else: + self.layernorm_embedding = None + + self.cross_self_attention = cfg.cross_self_attention + + if self.decoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.decoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + self.build_decoder_layer(cfg, no_encoder_attn) + for _ in range(cfg.decoder.layers) + ] + ) + self.num_layers = len(self.layers) + + if cfg.decoder.normalize_before and not cfg.no_decoder_final_norm: + self.layer_norm = LayerNorm(embed_dim, export=cfg.export) + else: + self.layer_norm = None + + self.project_out_dim = ( + Linear(embed_dim, self.output_embed_dim, bias=False) + if embed_dim != self.output_embed_dim and not cfg.tie_adaptive_weights + else None + ) + + self.adaptive_softmax = None + self.output_projection = output_projection + if self.output_projection is None: + self.build_output_projection(cfg, dictionary, embed_tokens) + + def build_output_projection(self, cfg, dictionary, embed_tokens): + if cfg.adaptive_softmax_cutoff is not None: + self.adaptive_softmax = AdaptiveSoftmax( + len(dictionary), + self.output_embed_dim, + utils.eval_str_list(cfg.adaptive_softmax_cutoff, type=int), + dropout=cfg.adaptive_softmax_dropout, + adaptive_inputs=embed_tokens if cfg.tie_adaptive_weights else None, + factor=cfg.adaptive_softmax_factor, + tie_proj=cfg.tie_adaptive_proj, + ) + elif self.share_input_output_embed: + self.output_projection = nn.Linear( + self.embed_tokens.weight.shape[1], + self.embed_tokens.weight.shape[0], + bias=False, + ) + self.output_projection.weight = self.embed_tokens.weight + else: + self.output_projection = nn.Linear( + self.output_embed_dim, len(dictionary), bias=False + ) + nn.init.normal_( + self.output_projection.weight, mean=0, std=self.output_embed_dim ** -0.5 + ) + num_base_layers = cfg.base_layers + for i in range(num_base_layers): + self.layers.insert( + ((i + 1) * cfg.decoder.layers) // (num_base_layers + 1), + BaseLayer(cfg), + ) + + def build_decoder_layer(self, cfg, no_encoder_attn=False): + layer = transformer_layer.TransformerDecoderLayerBase(cfg, no_encoder_attn) + checkpoint = cfg.checkpoint_activations + if checkpoint: + offload_to_cpu = cfg.offload_activations + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = cfg.min_params_to_wrap if not checkpoint else 0 + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def forward( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention, should be of size T x B x C + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False). + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + + x, extra = self.extract_features( + prev_output_tokens, + encoder_out=encoder_out, + incremental_state=incremental_state, + full_context_alignment=full_context_alignment, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + ) + + if not features_only: + x = self.output_layer(x) + return x, extra + + def extract_features( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + return self.extract_features_scriptable( + prev_output_tokens, + encoder_out, + incremental_state, + full_context_alignment, + alignment_layer, + alignment_heads, + ) + + """ + A scriptable subclass of this class has an extract_features method and calls + super().extract_features, but super() is not supported in torchscript. A copy of + this function is made to be used in the subclass instead. + """ + + def extract_features_scriptable( + self, + prev_output_tokens, + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Similar to *forward* but only return features. + + Includes several features from "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + alignment_layer (int, optional): return mean alignment over + heads at this layer (default: last layer). + alignment_heads (int, optional): only average alignment over + this many heads (default: all heads). + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + bs, slen = prev_output_tokens.size() + if alignment_layer is None: + alignment_layer = self.num_layers - 1 + + enc: Optional[Tensor] = None + padding_mask: Optional[Tensor] = None + if encoder_out is not None and len(encoder_out["encoder_out"]) > 0: + enc = encoder_out["encoder_out"][0] + assert ( + enc.size()[1] == bs + ), f"Expected enc.shape == (t, {bs}, c) got {enc.shape}" + if encoder_out is not None and len(encoder_out["encoder_padding_mask"]) > 0: + padding_mask = encoder_out["encoder_padding_mask"][0] + + # embed positions + positions = None + if self.embed_positions is not None: + positions = self.embed_positions( + prev_output_tokens, incremental_state=incremental_state + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.quant_noise is not None: + x = self.quant_noise(x) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + self_attn_padding_mask: Optional[Tensor] = None + if self.cross_self_attention or prev_output_tokens.eq(self.padding_idx).any(): + self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx) + + # decoder layers + attn: Optional[Tensor] = None + inner_states: List[Optional[Tensor]] = [x] + for idx, layer in enumerate(self.layers): + if incremental_state is None and not full_context_alignment: + self_attn_mask = self.buffered_future_mask(x) + else: + self_attn_mask = None + + x, layer_attn, _ = layer( + x, + enc, + padding_mask, + incremental_state, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=self_attn_padding_mask, + need_attn=bool((idx == alignment_layer)), + need_head_weights=bool((idx == alignment_layer)), + ) + inner_states.append(x) + if layer_attn is not None and idx == alignment_layer: + attn = layer_attn.float().to(x) + + if attn is not None: + if alignment_heads is not None: + attn = attn[:alignment_heads] + + # average probabilities over heads + attn = attn.mean(dim=0) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": [attn], "inner_states": inner_states} + + def output_layer(self, features): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + # project back to size of vocabulary + return self.output_projection(features) + else: + return features + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embed_positions is None: + return self.max_target_positions + return min(self.max_target_positions, self.embed_positions.max_positions) + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + # self._future_mask.device != tensor.device is not working in TorchScript. This is a workaround. + if ( + self._future_mask.size(0) == 0 + or (not self._future_mask.device == tensor.device) + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(torch.zeros([dim, dim])), 1 + ) + self._future_mask = self._future_mask.to(tensor) + return self._future_mask[:dim, :dim] + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + + if f"{name}.output_projection.weight" not in state_dict: + if self.share_input_output_embed: + embed_out_key = f"{name}.embed_tokens.weight" + else: + embed_out_key = f"{name}.embed_out" + if embed_out_key in state_dict: + state_dict[f"{name}.output_projection.weight"] = state_dict[ + embed_out_key + ] + if not self.share_input_output_embed: + del state_dict[embed_out_key] + + for i in range(self.num_layers): + # update layer norms + layer_norm_map = { + "0": "self_attn_layer_norm", + "1": "encoder_attn_layer_norm", + "2": "final_layer_norm", + } + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layers.{}.layer_norms.{}.{}".format(name, i, old, m) + if k in state_dict: + state_dict[ + "{}.layers.{}.{}.{}".format(name, i, new, m) + ] = state_dict[k] + del state_dict[k] + + version_key = "{}.version".format(name) + if utils.item(state_dict.get(version_key, torch.Tensor([1]))[0]) <= 2: + # earlier checkpoints did not normalize after the stack of layers + self.layer_norm = None + self.normalize = False + state_dict[version_key] = torch.Tensor([1]) + + return state_dict + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m + + +class TransformerDecoder(TransformerDecoderBase): + def __init__( + self, + args, + dictionary, + embed_tokens, + no_encoder_attn=False, + output_projection=None, + ): + self.args = args + super().__init__( + TransformerConfig.from_namespace(args), + dictionary, + embed_tokens, + no_encoder_attn=no_encoder_attn, + output_projection=output_projection, + ) + + def build_output_projection(self, args, dictionary, embed_tokens): + super().build_output_projection( + TransformerConfig.from_namespace(args), dictionary, embed_tokens + ) + + def build_decoder_layer(self, args, no_encoder_attn=False): + return super().build_decoder_layer( + TransformerConfig.from_namespace(args), no_encoder_attn=no_encoder_attn + ) diff --git a/fairseq/fairseq/models/transformer/transformer_encoder.py b/fairseq/fairseq/models/transformer/transformer_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..f007776a6f3b7e6731edc01d95aa24eed255d0e8 --- /dev/null +++ b/fairseq/fairseq/models/transformer/transformer_encoder.py @@ -0,0 +1,341 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Dict, List, Optional + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.distributed import fsdp_wrap +from fairseq.models import FairseqEncoder +from fairseq.modules import ( + FairseqDropout, + LayerDropModuleList, + LayerNorm, + PositionalEmbedding, + SinusoidalPositionalEmbedding, +) +from fairseq.modules import transformer_layer +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ +from torch import Tensor +from fairseq.models.transformer import ( + TransformerConfig, +) + + +# rewrite name for backward compatibility in `make_generation_fast_` +def module_name_fordropout(module_name: str) -> str: + if module_name == 'TransformerEncoderBase': + return 'TransformerEncoder' + else: + return module_name + + +class TransformerEncoderBase(FairseqEncoder): + """ + Transformer encoder consisting of *cfg.encoder.layers* layers. Each layer + is a :class:`TransformerEncoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_tokens (torch.nn.Embedding): input embedding + """ + + def __init__(self, cfg, dictionary, embed_tokens): + self.cfg = cfg + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + + self.dropout_module = FairseqDropout( + cfg.dropout, module_name=module_name_fordropout(self.__class__.__name__) + ) + self.encoder_layerdrop = cfg.encoder.layerdrop + + embed_dim = embed_tokens.embedding_dim + self.padding_idx = embed_tokens.padding_idx + self.max_source_positions = cfg.max_source_positions + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if cfg.no_scale_embedding else math.sqrt(embed_dim) + + self.embed_positions = ( + PositionalEmbedding( + cfg.max_source_positions, + embed_dim, + self.padding_idx, + learned=cfg.encoder.learned_pos, + ) + if not cfg.no_token_positional_embeddings + else None + ) + if cfg.layernorm_embedding: + self.layernorm_embedding = LayerNorm(embed_dim, export=cfg.export) + else: + self.layernorm_embedding = None + + if not cfg.adaptive_input and cfg.quant_noise.pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + cfg.quant_noise.pq, + cfg.quant_noise.pq_block_size, + ) + else: + self.quant_noise = None + + if self.encoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.encoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + self.layers.extend( + [self.build_encoder_layer(cfg) for i in range(cfg.encoder.layers)] + ) + self.num_layers = len(self.layers) + + if cfg.encoder.normalize_before: + self.layer_norm = LayerNorm(embed_dim, export=cfg.export) + else: + self.layer_norm = None + + def build_encoder_layer(self, cfg): + layer = transformer_layer.TransformerEncoderLayerBase(cfg) + checkpoint = cfg.checkpoint_activations + if checkpoint: + offload_to_cpu = cfg.offload_activations + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = cfg.min_params_to_wrap if not checkpoint else 0 + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def forward_embedding( + self, src_tokens, token_embedding: Optional[torch.Tensor] = None + ): + # embed tokens and positions + if token_embedding is None: + token_embedding = self.embed_tokens(src_tokens) + x = embed = self.embed_scale * token_embedding + if self.embed_positions is not None: + x = embed + self.embed_positions(src_tokens) + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + x = self.dropout_module(x) + if self.quant_noise is not None: + x = self.quant_noise(x) + return x, embed + + def forward( + self, + src_tokens, + src_lengths: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + return self.forward_scriptable( + src_tokens, src_lengths, return_all_hiddens, token_embeddings + ) + + # TorchScript doesn't support super() method so that the scriptable Subclass + # can't access the base class model in Torchscript. + # Current workaround is to add a helper function with different name and + # call the helper function from scriptable Subclass. + def forward_scriptable( + self, + src_tokens, + src_lengths: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + # compute padding mask + encoder_padding_mask = src_tokens.eq(self.padding_idx) + has_pads = src_tokens.device.type == "xla" or encoder_padding_mask.any() + + x, encoder_embedding = self.forward_embedding(src_tokens, token_embeddings) + + # account for padding while computing the representation + if has_pads: + x = x * (1 - encoder_padding_mask.unsqueeze(-1).type_as(x)) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + encoder_states = [] + + if return_all_hiddens: + encoder_states.append(x) + + # encoder layers + for layer in self.layers: + x = layer( + x, encoder_padding_mask=encoder_padding_mask if has_pads else None + ) + if return_all_hiddens: + assert encoder_states is not None + encoder_states.append(x) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in + # `forward` so we use a dictionary instead. + # TorchScript does not support mixed values so the values are all lists. + # The empty list is equivalent to None. + src_lengths = src_tokens.ne(self.padding_idx).sum(dim=1, dtype=torch.int32).reshape(-1, 1).contiguous() + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [encoder_padding_mask], # B x T + "encoder_embedding": [encoder_embedding], # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], + "src_lengths": [src_lengths], + } + + @torch.jit.export + def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + if len(encoder_out["encoder_out"]) == 0: + new_encoder_out = [] + else: + new_encoder_out = [encoder_out["encoder_out"][0].index_select(1, new_order)] + if len(encoder_out["encoder_padding_mask"]) == 0: + new_encoder_padding_mask = [] + else: + new_encoder_padding_mask = [ + encoder_out["encoder_padding_mask"][0].index_select(0, new_order) + ] + if len(encoder_out["encoder_embedding"]) == 0: + new_encoder_embedding = [] + else: + new_encoder_embedding = [ + encoder_out["encoder_embedding"][0].index_select(0, new_order) + ] + + if len(encoder_out["src_tokens"]) == 0: + src_tokens = [] + else: + src_tokens = [(encoder_out["src_tokens"][0]).index_select(0, new_order)] + + if len(encoder_out["src_lengths"]) == 0: + src_lengths = [] + else: + src_lengths = [(encoder_out["src_lengths"][0]).index_select(0, new_order)] + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": src_tokens, # B x T + "src_lengths": src_lengths, # B x 1 + } + + def max_positions(self): + """Maximum input length supported by the encoder.""" + if self.embed_positions is None: + return self.max_source_positions + return min(self.max_source_positions, self.embed_positions.max_positions) + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + print("deleting {0}".format(weights_key)) + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + for i in range(self.num_layers): + # update layer norms + self.layers[i].upgrade_state_dict_named( + state_dict, "{}.layers.{}".format(name, i) + ) + + version_key = "{}.version".format(name) + if utils.item(state_dict.get(version_key, torch.Tensor([1]))[0]) < 2: + # earlier checkpoints did not normalize after the stack of layers + self.layer_norm = None + self.normalize = False + state_dict[version_key] = torch.Tensor([1]) + return state_dict + + +class TransformerEncoder(TransformerEncoderBase): + def __init__(self, args, dictionary, embed_tokens): + self.args = args + super().__init__( + TransformerConfig.from_namespace(args), + dictionary, + embed_tokens, + ) + + def build_encoder_layer(self, args): + return super().build_encoder_layer( + TransformerConfig.from_namespace(args), + ) diff --git a/fairseq/fairseq/models/transformer/transformer_legacy.py b/fairseq/fairseq/models/transformer/transformer_legacy.py new file mode 100644 index 0000000000000000000000000000000000000000..af9646740a79ce720eeba513e2d994b39509ac49 --- /dev/null +++ b/fairseq/fairseq/models/transformer/transformer_legacy.py @@ -0,0 +1,275 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.dataclass.utils import gen_parser_from_dataclass +from fairseq.models import ( + register_model, + register_model_architecture, +) +from fairseq.models.transformer.transformer_config import ( + TransformerConfig, + DEFAULT_MAX_SOURCE_POSITIONS, + DEFAULT_MAX_TARGET_POSITIONS, + DEFAULT_MIN_PARAMS_TO_WRAP, +) +from fairseq.models.transformer.transformer_base import ( + TransformerModelBase, +) + + +@register_model("transformer") +class TransformerModel(TransformerModelBase): + """ + This is the legacy implementation of the transformer model that + uses argparse for configuration. + """ + + @classmethod + def hub_models(cls): + # fmt: off + + def moses_subword(path): + return { + 'path': path, + 'tokenizer': 'moses', + 'bpe': 'subword_nmt', + } + + def moses_fastbpe(path): + return { + 'path': path, + 'tokenizer': 'moses', + 'bpe': 'fastbpe', + } + + def spm(path): + return { + 'path': path, + 'bpe': 'sentencepiece', + 'tokenizer': 'space', + } + + return { + 'transformer.wmt14.en-fr': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/wmt14.en-fr.joined-dict.transformer.tar.bz2'), + 'transformer.wmt16.en-de': 'https://dl.fbaipublicfiles.com/fairseq/models/wmt16.en-de.joined-dict.transformer.tar.bz2', + 'transformer.wmt18.en-de': moses_subword('https://dl.fbaipublicfiles.com/fairseq/models/wmt18.en-de.ensemble.tar.gz'), + 'transformer.wmt19.en-de': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-de.joined-dict.ensemble.tar.gz'), + 'transformer.wmt19.en-ru': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-ru.ensemble.tar.gz'), + 'transformer.wmt19.de-en': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.de-en.joined-dict.ensemble.tar.gz'), + 'transformer.wmt19.ru-en': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.ru-en.ensemble.tar.gz'), + 'transformer.wmt19.en-de.single_model': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-de.joined-dict.single_model.tar.gz'), + 'transformer.wmt19.en-ru.single_model': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.en-ru.single_model.tar.gz'), + 'transformer.wmt19.de-en.single_model': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.de-en.joined-dict.single_model.tar.gz'), + 'transformer.wmt19.ru-en.single_model': moses_fastbpe('https://dl.fbaipublicfiles.com/fairseq/models/wmt19.ru-en.single_model.tar.gz'), + 'transformer.wmt20.en-ta': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-ta.single.tar.gz'), + 'transformer.wmt20.en-iu.news': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-iu.news.single.tar.gz'), + 'transformer.wmt20.en-iu.nh': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.en-iu.nh.single.tar.gz'), + 'transformer.wmt20.ta-en': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.ta-en.single.tar.gz'), + 'transformer.wmt20.iu-en.news': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu-en.news.single.tar.gz'), + 'transformer.wmt20.iu-en.nh': spm('https://dl.fbaipublicfiles.com/fairseq/models/wmt20.iu-en.nh.single.tar.gz'), + 'transformer.flores101.mm100.615M': spm('https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_615M.tar.gz'), + 'transformer.flores101.mm100.175M': spm('https://dl.fbaipublicfiles.com/flores101/pretrained_models/flores101_mm100_175M.tar.gz'), + } + # fmt: on + + def __init__(self, args, encoder, decoder): + cfg = TransformerConfig.from_namespace(args) + super().__init__(cfg, encoder, decoder) + self.args = args + + @classmethod + def add_args(cls, parser): + """Add model-specific arguments to the parser.""" + # we want to build the args recursively in this case. + # do not set defaults so that settings defaults from various architectures still works + gen_parser_from_dataclass( + parser, TransformerConfig(), delete_default=True, with_prefix="" + ) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if args.encoder_layers_to_keep: + args.encoder_layers = len(args.encoder_layers_to_keep.split(",")) + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if getattr(args, "max_source_positions", None) is None: + args.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = DEFAULT_MAX_TARGET_POSITIONS + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + if args.share_all_embeddings: + if src_dict != tgt_dict: + raise ValueError("--share-all-embeddings requires a joined dictionary") + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + args.share_decoder_input_output_embed = True + + if getattr(args, "offload_activations", False): + args.checkpoint_activations = True # offloading implies checkpointing + + if not args.share_all_embeddings: + args.min_params_to_wrap = getattr( + args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP + ) + cfg = TransformerConfig.from_namespace(args) + return super().build_model(cfg, task) + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + return super().build_embedding( + TransformerConfig.from_namespace(args), dictionary, embed_dim, path + ) + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return super().build_encoder( + TransformerConfig.from_namespace(args), src_dict, embed_tokens + ) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return super().build_decoder( + TransformerConfig.from_namespace(args), tgt_dict, embed_tokens + ) + + +# architectures + + +@register_model_architecture("transformer", "transformer_tiny") +def tiny_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 64) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 64) + args.encoder_layers = getattr(args, "encoder_layers", 2) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 2) + args.decoder_layers = getattr(args, "decoder_layers", 2) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 2) + return base_architecture(args) + + +@register_model_architecture("transformer", "transformer") +def base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.no_cross_attention = getattr(args, "no_cross_attention", False) + args.cross_self_attention = getattr(args, "cross_self_attention", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.checkpoint_activations = getattr(args, "checkpoint_activations", False) + args.offload_activations = getattr(args, "offload_activations", False) + if args.offload_activations: + args.checkpoint_activations = True + args.encoder_layers_to_keep = getattr(args, "encoder_layers_to_keep", None) + args.decoder_layers_to_keep = getattr(args, "decoder_layers_to_keep", None) + args.encoder_layerdrop = getattr(args, "encoder_layerdrop", 0) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.quant_noise_pq_block_size = getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = getattr(args, "quant_noise_scalar", 0) + + +@register_model_architecture("transformer", "transformer_iwslt_de_en") +def transformer_iwslt_de_en(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 1024) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 1024) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 6) + base_architecture(args) + + +@register_model_architecture("transformer", "transformer_wmt_en_de") +def transformer_wmt_en_de(args): + base_architecture(args) + + +# parameters used in the "Attention Is All You Need" paper (Vaswani et al., 2017) +@register_model_architecture("transformer", "transformer_vaswani_wmt_en_de_big") +def transformer_vaswani_wmt_en_de_big(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4096) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.dropout = getattr(args, "dropout", 0.3) + base_architecture(args) + + +@register_model_architecture("transformer", "transformer_vaswani_wmt_en_fr_big") +def transformer_vaswani_wmt_en_fr_big(args): + args.dropout = getattr(args, "dropout", 0.1) + transformer_vaswani_wmt_en_de_big(args) + + +@register_model_architecture("transformer", "transformer_wmt_en_de_big") +def transformer_wmt_en_de_big(args): + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + transformer_vaswani_wmt_en_de_big(args) + + +# default parameters used in tensor2tensor implementation +@register_model_architecture("transformer", "transformer_wmt_en_de_big_t2t") +def transformer_wmt_en_de_big_t2t(args): + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.1) + args.activation_dropout = getattr(args, "activation_dropout", 0.1) + transformer_vaswani_wmt_en_de_big(args) diff --git a/fairseq/fairseq/models/transformer_align.py b/fairseq/fairseq/models/transformer_align.py new file mode 100644 index 0000000000000000000000000000000000000000..eaf585bd10e630ae6cd89920f197cd165f55ad58 --- /dev/null +++ b/fairseq/fairseq/models/transformer_align.py @@ -0,0 +1,93 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer import ( + TransformerModel, + base_architecture, + transformer_wmt_en_de_big, +) + + +@register_model("transformer_align") +class TransformerAlignModel(TransformerModel): + """ + See "Jointly Learning to Align and Translate with Transformer + Models" (Garg et al., EMNLP 2019). + """ + + def __init__(self, encoder, decoder, args): + super().__init__(args, encoder, decoder) + self.alignment_heads = args.alignment_heads + self.alignment_layer = args.alignment_layer + self.full_context_alignment = args.full_context_alignment + + @staticmethod + def add_args(parser): + # fmt: off + super(TransformerAlignModel, TransformerAlignModel).add_args(parser) + parser.add_argument('--alignment-heads', type=int, metavar='D', + help='Number of cross attention heads per layer to supervised with alignments') + parser.add_argument('--alignment-layer', type=int, metavar='D', + help='Layer number which has to be supervised. 0 corresponding to the bottommost layer.') + parser.add_argument('--full-context-alignment', action='store_true', + help='Whether or not alignment is supervised conditioned on the full target context.') + # fmt: on + + @classmethod + def build_model(cls, args, task): + # set any default arguments + transformer_align(args) + + transformer_model = TransformerModel.build_model(args, task) + return TransformerAlignModel( + transformer_model.encoder, transformer_model.decoder, args + ) + + def forward(self, src_tokens, src_lengths, prev_output_tokens): + encoder_out = self.encoder(src_tokens, src_lengths) + return self.forward_decoder(prev_output_tokens, encoder_out) + + def forward_decoder( + self, + prev_output_tokens, + encoder_out=None, + incremental_state=None, + features_only=False, + **extra_args, + ): + attn_args = { + "alignment_layer": self.alignment_layer, + "alignment_heads": self.alignment_heads, + } + decoder_out = self.decoder(prev_output_tokens, encoder_out, **attn_args) + + if self.full_context_alignment: + attn_args["full_context_alignment"] = self.full_context_alignment + _, alignment_out = self.decoder( + prev_output_tokens, + encoder_out, + features_only=True, + **attn_args, + **extra_args, + ) + decoder_out[1]["attn"] = alignment_out["attn"] + + return decoder_out + + +@register_model_architecture("transformer_align", "transformer_align") +def transformer_align(args): + args.alignment_heads = getattr(args, "alignment_heads", 1) + args.alignment_layer = getattr(args, "alignment_layer", 4) + args.full_context_alignment = getattr(args, "full_context_alignment", False) + base_architecture(args) + + +@register_model_architecture("transformer_align", "transformer_wmt_en_de_big_align") +def transformer_wmt_en_de_big_align(args): + args.alignment_heads = getattr(args, "alignment_heads", 1) + args.alignment_layer = getattr(args, "alignment_layer", 4) + transformer_wmt_en_de_big(args) diff --git a/fairseq/fairseq/models/transformer_from_pretrained_xlm.py b/fairseq/fairseq/models/transformer_from_pretrained_xlm.py new file mode 100644 index 0000000000000000000000000000000000000000..236d9942e1fb0238cc92e2b4f160520b5cdd6504 --- /dev/null +++ b/fairseq/fairseq/models/transformer_from_pretrained_xlm.py @@ -0,0 +1,152 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +from typing import Any, Dict + +from fairseq import checkpoint_utils +from fairseq.data.legacy.masked_lm_dictionary import MaskedLMDictionary +from fairseq.models import register_model, register_model_architecture +from fairseq.models.transformer import ( + TransformerDecoder, + TransformerEncoder, + TransformerModel, + base_architecture as transformer_base_architecture, +) + + +@register_model("transformer_from_pretrained_xlm") +class TransformerFromPretrainedXLMModel(TransformerModel): + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + TransformerModel.add_args(parser) + parser.add_argument( + "--pretrained-xlm-checkpoint", + type=str, + metavar="STR", + help="XLM model to use for initializing transformer encoder and/or decoder", + ) + parser.add_argument( + "--init-encoder-only", + action="store_true", + help="if set, don't load the XLM weights and embeddings into decoder", + ) + parser.add_argument( + "--init-decoder-only", + action="store_true", + help="if set, don't load the XLM weights and embeddings into encoder", + ) + + @classmethod + def build_model(self, args, task, cls_dictionary=MaskedLMDictionary): + assert hasattr(args, "pretrained_xlm_checkpoint"), ( + "You must specify a path for --pretrained-xlm-checkpoint to use " + "--arch transformer_from_pretrained_xlm" + ) + assert isinstance(task.source_dictionary, cls_dictionary) and isinstance( + task.target_dictionary, cls_dictionary + ), ( + "You should use a MaskedLMDictionary when using --arch " + "transformer_from_pretrained_xlm because the pretrained XLM model " + "was trained using data binarized with MaskedLMDictionary. " + "For translation, you may want to use --task " + "translation_from_pretrained_xlm" + ) + assert not ( + getattr(args, "init_encoder_only", False) + and getattr(args, "init_decoder_only", False) + ), "Only one of --init-encoder-only and --init-decoder-only can be set." + return super().build_model(args, task) + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerEncoderFromPretrainedXLM(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerDecoderFromPretrainedXLM(args, tgt_dict, embed_tokens) + + +def upgrade_state_dict_with_xlm_weights( + state_dict: Dict[str, Any], pretrained_xlm_checkpoint: str +) -> Dict[str, Any]: + """ + Load XLM weights into a Transformer encoder or decoder model. + + Args: + state_dict: state dict for either TransformerEncoder or + TransformerDecoder + pretrained_xlm_checkpoint: checkpoint to load XLM weights from + + Raises: + AssertionError: If architecture (num layers, attention heads, etc.) + does not match between the current Transformer encoder or + decoder and the pretrained_xlm_checkpoint + """ + if not os.path.exists(pretrained_xlm_checkpoint): + raise IOError("Model file not found: {}".format(pretrained_xlm_checkpoint)) + + state = checkpoint_utils.load_checkpoint_to_cpu(pretrained_xlm_checkpoint) + xlm_state_dict = state["model"] + for key in xlm_state_dict.keys(): + + for search_key in ["embed_tokens", "embed_positions", "layers"]: + if search_key in key: + subkey = key[key.find(search_key) :] + assert subkey in state_dict, ( + "{} Transformer encoder / decoder " + "state_dict does not contain {}. Cannot " + "load {} from pretrained XLM checkpoint " + "{} into Transformer.".format( + str(state_dict.keys()), subkey, key, pretrained_xlm_checkpoint + ) + ) + + state_dict[subkey] = xlm_state_dict[key] + return state_dict + + +class TransformerEncoderFromPretrainedXLM(TransformerEncoder): + def __init__(self, args, dictionary, embed_tokens): + super().__init__(args, dictionary, embed_tokens) + if getattr(args, "init_decoder_only", False): + # Don't load XLM weights for encoder if --init-decoder-only + return + + assert hasattr(args, "pretrained_xlm_checkpoint"), ( + "--pretrained-xlm-checkpoint must be specified to load Transformer " + "encoder from pretrained XLM" + ) + xlm_loaded_state_dict = upgrade_state_dict_with_xlm_weights( + state_dict=self.state_dict(), + pretrained_xlm_checkpoint=args.pretrained_xlm_checkpoint, + ) + self.load_state_dict(xlm_loaded_state_dict, strict=True) + + +class TransformerDecoderFromPretrainedXLM(TransformerDecoder): + def __init__(self, args, dictionary, embed_tokens, no_encoder_attn=False): + super().__init__(args, dictionary, embed_tokens, no_encoder_attn) + if getattr(args, "init_encoder_only", False): + # Don't load XLM weights for decoder if --init-encoder-only + return + assert hasattr(args, "pretrained_xlm_checkpoint"), ( + "--pretrained-xlm-checkpoint must be specified to load Transformer " + "decoder from pretrained XLM" + ) + + xlm_loaded_state_dict = upgrade_state_dict_with_xlm_weights( + state_dict=self.state_dict(), + pretrained_xlm_checkpoint=args.pretrained_xlm_checkpoint, + ) + self.load_state_dict(xlm_loaded_state_dict, strict=True) + + +@register_model_architecture( + "transformer_from_pretrained_xlm", "transformer_from_pretrained_xlm" +) +def base_architecture(args): + transformer_base_architecture(args) diff --git a/fairseq/fairseq/models/transformer_lm.py b/fairseq/fairseq/models/transformer_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..eedd5151ba5b1a7050b37639023cf8a158fae8d4 --- /dev/null +++ b/fairseq/fairseq/models/transformer_lm.py @@ -0,0 +1,545 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from dataclasses import dataclass, field +from typing import Optional + +from fairseq import options, utils +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.models import ( + FairseqLanguageModel, + register_model, + register_model_architecture, +) +from fairseq.models.transformer import ( + DEFAULT_MIN_PARAMS_TO_WRAP, Embedding, TransformerDecoder +) +from fairseq.modules import AdaptiveInput, CharacterTokenEmbedder +from fairseq.utils import safe_getattr, safe_hasattr +from omegaconf import II + + +DEFAULT_MAX_TARGET_POSITIONS = 1024 + + +@dataclass +class TransformerLanguageModelConfig(FairseqDataclass): + activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field( + default="relu", metadata={"help": "activation function to use"} + ) + dropout: float = field(default=0.1, metadata={"help": "dropout probability"}) + attention_dropout: float = field( + default=0.0, metadata={"help": "dropout probability for attention weights"} + ) + activation_dropout: float = field( + default=0.0, metadata={"help": "dropout probability after activation in FFN."} + ) + relu_dropout: float = field( + default=0.0, metadata={"help": "dropout probability after activation in FFN."} + ) + decoder_embed_dim: int = field( + default=512, metadata={"help": "decoder embedding dimension"} + ) + decoder_output_dim: int = field( + default=512, metadata={"help": "decoder output dimension"} + ) + decoder_input_dim: int = field( + default=512, metadata={"help": "decoder input dimension"} + ) + decoder_ffn_embed_dim: int = field( + default=2048, metadata={"help": "decoder embedding dimension for FFN"} + ) + decoder_layers: int = field(default=6, metadata={"help": "num decoder layers"}) + decoder_attention_heads: int = field( + default=8, metadata={"help": "num decoder attention heads"} + ) + decoder_normalize_before: bool = field( + default=False, metadata={"help": "apply layernorm before each decoder block"} + ) + no_decoder_final_norm: bool = field( + default=False, + metadata={"help": "don't add an extra layernorm after the last decoder block"}, + ) + adaptive_softmax_cutoff: Optional[str] = field( + default=None, + metadata={ + "help": "comma separated list of adaptive softmax cutoff points. " + "Must be used with adaptive_loss criterion" + }, + ) + adaptive_softmax_dropout: float = field( + default=0, + metadata={"help": "sets adaptive softmax dropout for the tail projections"}, + ) + adaptive_softmax_factor: float = field( + default=4, metadata={"help": "adaptive input factor"} + ) + no_token_positional_embeddings: bool = field( + default=False, + metadata={ + "help": "if set, disables positional embeddings (outside self attention)" + }, + ) + share_decoder_input_output_embed: bool = field( + default=False, metadata={"help": "share decoder input and output embeddings"} + ) + character_embeddings: bool = field( + default=False, + metadata={ + "help": "if set, uses character embedding convolutions to produce token embeddings" + }, + ) + character_filters: str = field( + default="[(1, 64), (2, 128), (3, 192), (4, 256), (5, 256), (6, 256), (7, 256)]", + metadata={"help": "size of character embeddings"}, + ) + character_embedding_dim: int = field( + default=4, metadata={"help": "size of character embeddings"} + ) + char_embedder_highway_layers: int = field( + default=2, + metadata={"help": "number of highway layers for character token embeddder"}, + ) + adaptive_input: bool = field( + default=False, metadata={"help": "if set, uses adaptive input"} + ) + adaptive_input_factor: float = field( + default=4, metadata={"help": "adaptive input factor"} + ) + adaptive_input_cutoff: Optional[str] = field( + default=None, + metadata={"help": "comma separated list of adaptive input cutoff points."}, + ) + tie_adaptive_weights: bool = field( + default=False, + metadata={ + "help": "if set, ties the weights of adaptive softmax and adaptive input" + }, + ) + tie_adaptive_proj: bool = field( + default=False, + metadata={ + "help": "if set, ties the projection weights of adaptive softmax and adaptive input" + }, + ) + decoder_learned_pos: bool = field( + default=False, + metadata={"help": "use learned positional embeddings in the decoder"}, + ) + layernorm_embedding: bool = field( + default=False, metadata={"help": "add layernorm to embedding"} + ) + no_scale_embedding: bool = field( + default=False, metadata={"help": "if True, dont scale embeddings"} + ) + checkpoint_activations: bool = field( + default=False, metadata={"help": "checkpoint activations at each layer"} + ) + offload_activations: bool = field( + default=False, + metadata={"help": "move checkpointed activations to CPU after they are used."}, + ) + # config for "Reducing Transformer Depth on Demand with Structured Dropout" (Fan et al., 2019) + decoder_layerdrop: float = field( + default=0.0, metadata={"help": "LayerDrop probability for decoder"} + ) + decoder_layers_to_keep: Optional[str] = field( + default=None, + metadata={ + "help": "which layers to *keep* when pruning as a comma-separated list" + }, + ) + # config for Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020) + quant_noise_pq: float = field( + default=0.0, + metadata={"help": "iterative PQ quantization noise at training time"}, + ) + quant_noise_pq_block_size: int = field( + default=8, + metadata={"help": "block size of quantization noise at training time"}, + ) + quant_noise_scalar: float = field( + default=0.0, + metadata={ + "help": "scalar quantization noise and scalar quantization at training time" + }, + ) + # config for Fully Sharded Data Parallel (FSDP) training + min_params_to_wrap: int = field( + default=DEFAULT_MIN_PARAMS_TO_WRAP, + metadata={ + "help": ( + "minimum number of params for a layer to be wrapped with FSDP() when " + "training with --ddp-backend=fully_sharded. Smaller values will " + "improve memory efficiency, but may make torch.distributed " + "communication less efficient due to smaller input sizes. This option " + "is set to 0 (i.e., always wrap) when --checkpoint-activations or " + "--offload-activations are passed." + ) + } + ) + # config for "BASE Layers: Simplifying Training of Large, Sparse Models" + base_layers: Optional[int] = field( + default=0, metadata={"help": "number of BASE layers in total"} + ) + base_sublayers: Optional[int] = field( + default=1, metadata={"help": "number of sublayers in each BASE layer"} + ) + base_shuffle: Optional[int] = field( + default=1, metadata={"help": "shuffle tokens between workers before computing assignment"} + ) + # options from other parts of the config + add_bos_token: bool = II("task.add_bos_token") + tokens_per_sample: int = II("task.tokens_per_sample") + max_target_positions: Optional[int] = II("task.max_target_positions") + tpu: bool = II("common.tpu") + + +@register_model("transformer_lm", dataclass=TransformerLanguageModelConfig) +class TransformerLanguageModel(FairseqLanguageModel): + @classmethod + def hub_models(cls): + def moses_fastbpe(path): + return {"path": path, "tokenizer": "moses", "bpe": "fastbpe"} + + def spm(path): + return {"path": path, "tokenizer": "space", "bpe": "sentencepiece"} + + return { + "transformer_lm.gbw.adaptive_huge": "https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_gbw_huge.tar.bz2", + "transformer_lm.wiki103.adaptive": "https://dl.fbaipublicfiles.com/fairseq/models/lm/adaptive_lm_wiki103.v2.tar.bz2", + "transformer_lm.wmt19.en": moses_fastbpe( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.en.tar.bz2" + ), + "transformer_lm.wmt19.de": moses_fastbpe( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.de.tar.bz2" + ), + "transformer_lm.wmt19.ru": moses_fastbpe( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt19.ru.tar.bz2" + ), + "transformer_lm.wmt20.en": spm( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt20.en.tar.gz" + ), + "transformer_lm.wmt20.ta": spm( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt20.ta.tar.gz" + ), + "transformer_lm.wmt20.iu.news": spm( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt20.iu.news.tar.gz" + ), + "transformer_lm.wmt20.iu.nh": spm( + "https://dl.fbaipublicfiles.com/fairseq/models/lm/wmt20.iu.nh.tar.gz" + ), + } + + def __init__(self, decoder): + super().__init__(decoder) + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if safe_getattr(args, "max_target_positions", None) is None: + args.max_target_positions = safe_getattr( + args, "tokens_per_sample", DEFAULT_MAX_TARGET_POSITIONS + ) + + if args.character_embeddings: + embed_tokens = CharacterTokenEmbedder( + task.source_dictionary, + eval(args.character_filters), + args.character_embedding_dim, + args.decoder_embed_dim, + args.char_embedder_highway_layers, + ) + elif args.adaptive_input: + embed_tokens = AdaptiveInput( + len(task.source_dictionary), + task.source_dictionary.pad(), + args.decoder_input_dim, + args.adaptive_input_factor, + args.decoder_embed_dim, + options.eval_str_list(args.adaptive_input_cutoff, type=int), + args.quant_noise_pq, + args.quant_noise_pq_block_size, + ) + else: + embed_tokens = cls.build_embedding( + args, task.source_dictionary, args.decoder_input_dim + ) + + if args.tie_adaptive_weights: + assert args.adaptive_input + assert args.adaptive_input_factor == args.adaptive_softmax_factor + assert ( + args.adaptive_softmax_cutoff == args.adaptive_input_cutoff + ), "{} != {}".format( + args.adaptive_softmax_cutoff, args.adaptive_input_cutoff + ) + assert args.decoder_input_dim == args.decoder_output_dim + + decoder = TransformerDecoder( + args, task.target_dictionary, embed_tokens, no_encoder_attn=True + ) + return cls(decoder) + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + embed_tokens = Embedding(len(dictionary), embed_dim, dictionary.pad()) + return embed_tokens + + +def base_lm_architecture(args): + # backward compatibility for older model checkpoints + if safe_hasattr(args, "no_tie_adaptive_proj"): + # previous models defined --no-tie-adaptive-proj, so use the existence of + # that option to determine if this is an "old" model checkpoint + args.no_decoder_final_norm = True # old models always set this to True + if args.no_tie_adaptive_proj is False: + args.tie_adaptive_proj = True + if safe_hasattr(args, "decoder_final_norm"): + args.no_decoder_final_norm = not args.decoder_final_norm + + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.0) + + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 512) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 2048) + args.decoder_layers = safe_getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 8) + args.adaptive_softmax_cutoff = safe_getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = safe_getattr(args, "adaptive_softmax_dropout", 0) + args.adaptive_softmax_factor = safe_getattr(args, "adaptive_softmax_factor", 4) + args.decoder_learned_pos = safe_getattr(args, "decoder_learned_pos", False) + args.activation_fn = safe_getattr(args, "activation_fn", "relu") + + args.decoder_layerdrop = safe_getattr(args, "decoder_layerdrop", 0) + args.decoder_layers_to_keep = safe_getattr(args, "decoder_layers_to_keep", None) + args.quant_noise_pq = safe_getattr(args, "quant_noise_pq", 0) + args.quant_noise_pq_block_size = safe_getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = safe_getattr(args, "quant_noise_scalar", 0) + + args.base_layers = safe_getattr(args, "base_layers", 0) + args.base_sublayers = safe_getattr(args, "base_sublayers", 1) + args.base_shuffle = safe_getattr(args, "base_shuffle", False) + + args.add_bos_token = safe_getattr(args, "add_bos_token", False) + args.no_token_positional_embeddings = safe_getattr( + args, "no_token_positional_embeddings", False + ) + args.share_decoder_input_output_embed = safe_getattr( + args, "share_decoder_input_output_embed", False + ) + args.character_embeddings = safe_getattr(args, "character_embeddings", False) + + args.decoder_output_dim = safe_getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = safe_getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + # Model training is not stable without this + args.decoder_normalize_before = True + args.no_decoder_final_norm = safe_getattr(args, "no_decoder_final_norm", False) + + args.adaptive_input = safe_getattr(args, "adaptive_input", False) + args.adaptive_input_factor = safe_getattr(args, "adaptive_input_factor", 4) + args.adaptive_input_cutoff = safe_getattr(args, "adaptive_input_cutoff", None) + + args.tie_adaptive_weights = safe_getattr(args, "tie_adaptive_weights", False) + args.tie_adaptive_proj = safe_getattr(args, "tie_adaptive_proj", False) + + args.no_scale_embedding = safe_getattr(args, "no_scale_embedding", False) + args.layernorm_embedding = safe_getattr(args, "layernorm_embedding", False) + args.checkpoint_activations = safe_getattr(args, "checkpoint_activations", False) + args.offload_activations = safe_getattr(args, "offload_activations", False) + if args.offload_activations: + args.checkpoint_activations = True + + +@register_model_architecture("transformer_lm", "transformer_lm_big") +def transformer_lm_big(args): + args.decoder_layers = safe_getattr(args, "decoder_layers", 12) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 16) + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_wiki103") +@register_model_architecture("transformer_lm", "transformer_lm_baevski_wiki103") +def transformer_lm_baevski_wiki103(args): + args.decoder_layers = safe_getattr(args, "decoder_layers", 16) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 8) + args.dropout = safe_getattr(args, "dropout", 0.3) + args.adaptive_input = safe_getattr(args, "adaptive_input", True) + args.tie_adaptive_weights = safe_getattr(args, "tie_adaptive_weights", True) + args.adaptive_input_cutoff = safe_getattr(args, "adaptive_input_cutoff", "20000,60000") + args.adaptive_softmax_cutoff = safe_getattr( + args, "adaptive_softmax_cutoff", "20000,60000" + ) + args.adaptive_softmax_dropout = safe_getattr(args, "adaptive_softmax_dropout", 0.2) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_dropout = safe_getattr(args, "activation_dropout", 0.1) + args.no_decoder_final_norm = safe_getattr(args, "no_decoder_final_norm", True) + args.tie_adaptive_proj = safe_getattr(args, "tie_adaptive_proj", True) + transformer_lm_big(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gbw") +@register_model_architecture("transformer_lm", "transformer_lm_baevski_gbw") +def transformer_lm_baevski_gbw(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 512) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.no_decoder_final_norm = safe_getattr(args, "no_decoder_final_norm", True) + transformer_lm_big(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt") +def transformer_lm_gpt(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 768) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 3072) + args.decoder_layers = safe_getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 12) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt2_small") +def transformer_lm_gpt2_small(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1024) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 4096) + args.decoder_layers = safe_getattr(args, "decoder_layers", 24) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 16) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt2_tiny") +def transformer_lm_gpt2_tiny(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 64) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 64) + args.decoder_layers = safe_getattr(args, "decoder_layers", 2) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 1) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt2_medium") +def transformer_lm_gpt2_medium(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1280) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 5120) + args.decoder_layers = safe_getattr(args, "decoder_layers", 36) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 20) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt2_big") +def transformer_lm_gpt2_big(args): + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1600) + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", 6400) + args.decoder_layers = safe_getattr(args, "decoder_layers", 48) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 25) + args.dropout = safe_getattr(args, "dropout", 0.1) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.1) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + base_lm_architecture(args) + + +def base_gpt3_architecture(args): + args.decoder_input_dim = args.decoder_embed_dim + args.decoder_output_dim = args.decoder_embed_dim + args.decoder_ffn_embed_dim = safe_getattr(args, "decoder_ffn_embed_dim", args.decoder_embed_dim * 4) + # GPT-3 used learned positional embeddings, rather than sinusoidal + args.decoder_learned_pos = safe_getattr(args, "decoder_learned_pos", True) + args.dropout = safe_getattr(args, "dropout", 0.0) + args.attention_dropout = safe_getattr(args, "attention_dropout", 0.0) + args.activation_fn = safe_getattr(args, "activation_fn", "gelu") + args.share_decoder_input_output_embed = True + base_lm_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_small") +def transformer_lm_gpt3_small(args): + # 125M params + args.decoder_layers = safe_getattr(args, "decoder_layers", 12) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 768) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 12) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_medium") +def transformer_lm_gpt3_medium(args): + # 350M params + args.decoder_layers = safe_getattr(args, "decoder_layers", 24) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1024) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 16) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_large") +def transformer_lm_gpt3_large(args): + # 760M params + args.decoder_layers = safe_getattr(args, "decoder_layers", 24) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 1536) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 16) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_xl") +def transformer_lm_gpt3_xl(args): + # 1.3B params + args.decoder_layers = safe_getattr(args, "decoder_layers", 24) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 2048) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 32) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_2_7") +def transformer_lm_gpt3_2_7(args): + # 2.7B params + args.decoder_layers = safe_getattr(args, "decoder_layers", 32) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 2560) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 32) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_6_7") +def transformer_lm_gpt3_6_7(args): + # 6.7B params + args.decoder_layers = safe_getattr(args, "decoder_layers", 32) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 4096) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 32) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_13") +def transformer_lm_gpt3_13(args): + # 13B params + args.decoder_layers = safe_getattr(args, "decoder_layers", 40) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 5120) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 40) + base_gpt3_architecture(args) + + +@register_model_architecture("transformer_lm", "transformer_lm_gpt3_175") +def transformer_lm_gpt3_175(args): + # 175B params + args.decoder_layers = safe_getattr(args, "decoder_layers", 96) + args.decoder_embed_dim = safe_getattr(args, "decoder_embed_dim", 12288) + args.decoder_attention_heads = safe_getattr(args, "decoder_attention_heads", 96) + base_gpt3_architecture(args) diff --git a/fairseq/fairseq/models/wav2vec/__init__.py b/fairseq/fairseq/models/wav2vec/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..06cec18183ca14cd534d14558e8b44e25f3e69d5 --- /dev/null +++ b/fairseq/fairseq/models/wav2vec/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .wav2vec import * # noqa +from .wav2vec2 import * # noqa +from .wav2vec2_asr import * # noqa diff --git a/fairseq/fairseq/models/wav2vec/wav2vec.py b/fairseq/fairseq/models/wav2vec/wav2vec.py new file mode 100644 index 0000000000000000000000000000000000000000..af6604da10f504baabff50bf14a6eb2214bffef3 --- /dev/null +++ b/fairseq/fairseq/models/wav2vec/wav2vec.py @@ -0,0 +1,630 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import logging +import math +from typing import Optional, Tuple +from omegaconf import II +import sys + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.models import BaseFairseqModel, register_model +from fairseq.modules import ( + Fp32GroupNorm, + Fp32LayerNorm, + GumbelVectorQuantizer, + KmeansVectorQuantizer, + TransposeLast, +) +from fairseq.tasks import FairseqTask +from fairseq.utils import buffered_arange + + +logger = logging.getLogger(__name__) + + +AGGREGATOR_CHOICES = ChoiceEnum(["cnn", "gru"]) +PROJECT_FEATURES_CHOICES = ChoiceEnum(["none", "same", "new"]) +ACTIVATION_CHOICES = ChoiceEnum(["relu", "gelu"]) +VQ_TYPE_CHOICES = ChoiceEnum(["none", "gumbel", "kmeans"]) + + +@dataclass +class Wav2VecConfig(FairseqDataclass): + prediction_steps: int = field( + default=12, metadata={"help": "number of steps ahead to predict"} + ) + sample_distance: Optional[int] = field( + default=None, + metadata={ + "help": "sample distance from target. does not work properly with cross-sampling" + }, + ) + cross_sample_negatives: int = field( + default=0, metadata={"help": "num of cross sampled negatives"} + ) + num_negatives: int = field( + default=10, metadata={"help": "num of sampled negatives"} + ) + conv_feature_layers: str = field( + default="[(512, 10, 5), (512, 8, 4), (512, 4, 2), (512, 4, 2), (512, 4, 2), (512, 1, 1), (512, 1, 1), (512, 1, 1)]", + metadata={ + "help": "convolutional feature extraction layers [(dim, kernel_size, stride), ...]" + }, + ) + conv_aggregator_layers: str = field( + default="[(512, 2, 1), (512, 3, 1), (512, 4, 1), (512, 5, 1), (512, 6, 1), (512, 7, 1), (512, 8, 1), (512, 9, 1), (512, 10, 1), (512, 11, 1), (512, 12, 1), (512, 13, 1)]", + metadata={ + "help": "convolutional aggregator layers [(dim, kernel_size, stride), ...]" + }, + ) + dropout: float = field( + default=0.0, metadata={"help": "dropout to apply within the model"} + ) + dropout_features: float = field( + default=0.0, metadata={"help": "dropout to apply to the features"} + ) + dropout_agg: float = field( + default=0.0, metadata={"help": "dropout to apply after aggregation step"} + ) + aggregator: AGGREGATOR_CHOICES = field( + default="cnn", metadata={"help": "type of aggregator to use"} + ) + gru_dim: int = field(default=512, metadata={"help": "GRU dimensionality"}) + no_conv_bias: bool = field( + default=False, metadata={"help": "if set, does not learn bias for conv layers"} + ) + agg_zero_pad: bool = field( + default=False, + metadata={"help": "if set, zero pads in aggregator instead of repl pad"}, + ) + skip_connections_feat: bool = field( + default=False, + metadata={"help": "if set, adds skip connections to the feature extractor"}, + ) + skip_connections_agg: bool = field( + default=True, + metadata={"help": "if set, adds skip connections to the aggregator"}, + ) + residual_scale: float = field( + default=0.5, metadata={"help": "scales residual by sqrt(value)"} + ) + log_compression: bool = field( + default=True, + metadata={"help": "if set, adds a log compression to feature extractor"}, + ) + balanced_classes: bool = field( + default=False, + metadata={"help": "if set, loss is scaled to balance for number of negatives"}, + ) + project_features: PROJECT_FEATURES_CHOICES = field( + default="none", + metadata={ + "help": "if not none, features are projected using the (same or new) aggregator" + }, + ) + non_affine_group_norm: bool = field( + default=False, metadata={"help": "if set, group norm is not affine"} + ) + offset: str = field( + default="auto", + metadata={ + "help": "if set to 'auto', it is computed automatically from the receptive field, else set to int value" + }, + ) + activation: ACTIVATION_CHOICES = field( + default="relu", + metadata={ + "help": "if set to 'auto', it is computed automatically from the receptive field, else set to int value" + }, + ) + vq_type: VQ_TYPE_CHOICES = field( + default="none", metadata={"help": "which type of quantizer to use"} + ) + vq_vars: int = field( + default=320, + metadata={"help": "project to this many vector quantized variables per group"}, + ) + vq_groups: int = field( + default=2, metadata={"help": "number of groups of latent variables"} + ) + vq_dim: int = field( + default=0, + metadata={ + "help": "uses this dimensionality for quantized vectors. 0 to use model dim // groups" + }, + ) + vq_depth: int = field( + default=1, metadata={"help": "number of layers for vq weight projection"} + ) + combine_groups: bool = field( + default=False, metadata={"help": "if set, variables are shared among groups"} + ) + vq_temp: Tuple[float, float, float] = field( + default=(2.0, 0.5, 0.999995), + metadata={ + "help": "temperature for latent variable sampling with gumbel softmax. should be a tuple of 3 values (start, end, decay)" + }, + ) + vq_gamma: float = field( + default=0.25, + metadata={"help": "gamma parameter for kmeans style vector quantization"}, + ) + infonce: bool = II("criterion.infonce") + + +@register_model("wav2vec", dataclass=Wav2VecConfig) +class Wav2VecModel(BaseFairseqModel): + @classmethod + def build_model(cls, cfg: Wav2VecConfig, task: FairseqTask): + """Build a new model instance.""" + + model = Wav2VecModel(cfg) + logger.info(model) + return model + + def __init__(self, cfg: Wav2VecConfig): + super().__init__() + + self.prediction_steps = cfg.prediction_steps + offset = cfg.offset + + if cfg.activation == "relu": + activation = nn.ReLU() + elif cfg.activation == "gelu": + activation = nn.GELU() + else: + raise Exception("unknown activation " + cfg.activation) + + feature_enc_layers = eval(cfg.conv_feature_layers) + self.feature_extractor = ConvFeatureExtractionModel( + conv_layers=feature_enc_layers, + dropout=0.0, + log_compression=cfg.log_compression, + skip_connections=cfg.skip_connections_feat, + residual_scale=cfg.residual_scale, + non_affine_group_norm=cfg.non_affine_group_norm, + activation=activation, + ) + embed = feature_enc_layers[-1][0] + + self.vector_quantizer = None + if cfg.vq_type == "gumbel": + self.vector_quantizer = GumbelVectorQuantizer( + dim=embed, + num_vars=cfg.vq_vars, + temp=cfg.vq_temp, + groups=cfg.vq_groups, + combine_groups=cfg.combine_groups, + vq_dim=cfg.vq_dim if cfg.vq_dim > 0 else embed, + time_first=False, + activation=activation, + weight_proj_depth=cfg.vq_depth, + weight_proj_factor=2, + ) + elif cfg.vq_type == "kmeans": + self.vector_quantizer = KmeansVectorQuantizer( + dim=embed, + num_vars=cfg.vq_vars, + groups=cfg.vq_groups, + combine_groups=cfg.combine_groups, + vq_dim=cfg.vq_dim if cfg.vq_dim > 0 else embed, + time_first=False, + gamma=cfg.vq_gamma, + ) + else: + assert ( + cfg.vq_type == "none" or cfg.vq_type is None + ), "Unknown quantizer type" + + if cfg.offset == "auto": + jin = 0 + rin = 0 + for _, k, stride in feature_enc_layers: + if rin == 0: + rin = k + rin = rin + (k - 1) * jin + if jin == 0: + jin = stride + else: + jin *= stride + offset = math.ceil(rin / jin) + + offset = int(offset) + + def make_aggregator(): + if cfg.aggregator == "cnn": + agg_layers = eval(cfg.conv_aggregator_layers) + agg_dim = agg_layers[-1][0] + feature_aggregator = ConvAggegator( + conv_layers=agg_layers, + embed=embed, + dropout=cfg.dropout, + skip_connections=cfg.skip_connections_agg, + residual_scale=cfg.residual_scale, + non_affine_group_norm=cfg.non_affine_group_norm, + conv_bias=not cfg.no_conv_bias, + zero_pad=cfg.agg_zero_pad, + activation=activation, + ) + elif cfg.aggregator == "gru": + agg_dim = cfg.gru_dim + feature_aggregator = nn.Sequential( + TransposeLast(), + nn.GRU( + input_size=embed, + hidden_size=agg_dim, + num_layers=1, + dropout=cfg.dropout, + ), + TransposeLast(deconstruct_idx=0), + ) + else: + raise Exception("unknown aggregator type " + cfg.aggregator) + + return feature_aggregator, agg_dim + + self.feature_aggregator, agg_dim = make_aggregator() + + self.wav2vec_predictions = Wav2VecPredictionsModel( + in_dim=agg_dim, + out_dim=embed, + prediction_steps=cfg.prediction_steps, + n_negatives=cfg.num_negatives, + cross_sample_negatives=cfg.cross_sample_negatives, + sample_distance=cfg.sample_distance, + dropout=cfg.dropout, + offset=offset, + balanced_classes=cfg.balanced_classes, + infonce=cfg.infonce, + ) + + self.dropout_feats = nn.Dropout(p=cfg.dropout_features) + self.dropout_agg = nn.Dropout(p=cfg.dropout_agg) + + if cfg.project_features == "none": + self.project_features = None + elif cfg.project_features == "same": + self.project_features = self.feature_aggregator + elif cfg.project_features == "new": + self.project_features, _ = make_aggregator() + + def forward(self, source): + result = {} + + features = self.feature_extractor(source) + if self.vector_quantizer: + q_res = self.vector_quantizer(features) + features = q_res["x"] + for k in q_res.keys(): + if k != "x": + result[k] = q_res[k] + + x = self.dropout_feats(features) + x = self.feature_aggregator(x) + x = self.dropout_agg(x) + + if self.project_features is not None: + features = self.project_features(features) + x, targets = self.wav2vec_predictions(x, features) + result["cpc_logits"] = x + result["cpc_targets"] = targets + + return result + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + + def max_positions(self): + """Maximum length supported by the model.""" + return sys.maxsize + + def get_logits(self, net_output): + logits = net_output["cpc_logits"] + return logits + + def get_targets(self, sample, net_output): + t = net_output["cpc_targets"] + if isinstance(t, tuple): + t = t[0] + return t.contiguous() + + def get_target_weights(self, targets, net_output): + targets = net_output["cpc_targets"] + if isinstance(targets, tuple) and targets[-1] is not None: + return targets[-1] + return None + + def get_extra_losses(self, net_output): + loss = None + if "prob_perplexity" in net_output: + loss = net_output["num_vars"] - net_output["prob_perplexity"] + elif "kmeans_loss" in net_output: + loss = net_output["kmeans_loss"] + + return loss + + +def norm_block(is_layer_norm, dim, affine=True): + if is_layer_norm: + mod = nn.Sequential( + TransposeLast(), + Fp32LayerNorm(dim, elementwise_affine=affine), + TransposeLast(), + ) + else: + mod = Fp32GroupNorm(1, dim, affine=affine) + + return mod + + +class ConvFeatureExtractionModel(nn.Module): + def __init__( + self, + conv_layers, + dropout, + log_compression, + skip_connections, + residual_scale, + non_affine_group_norm, + activation, + ): + super().__init__() + + def block(n_in, n_out, k, stride): + return nn.Sequential( + nn.Conv1d(n_in, n_out, k, stride=stride, bias=False), + nn.Dropout(p=dropout), + norm_block( + is_layer_norm=False, dim=n_out, affine=not non_affine_group_norm + ), + activation, + ) + + in_d = 1 + self.conv_layers = nn.ModuleList() + for dim, k, stride in conv_layers: + self.conv_layers.append(block(in_d, dim, k, stride)) + in_d = dim + + self.log_compression = log_compression + self.skip_connections = skip_connections + self.residual_scale = math.sqrt(residual_scale) + + def forward(self, x): + # BxT -> BxCxT + x = x.unsqueeze(1) + + for conv in self.conv_layers: + residual = x + x = conv(x) + if self.skip_connections and x.size(1) == residual.size(1): + tsz = x.size(2) + r_tsz = residual.size(2) + residual = residual[..., :: r_tsz // tsz][..., :tsz] + x = (x + residual) * self.residual_scale + + if self.log_compression: + x = x.abs() + x = x + 1 + x = x.log() + + return x + + +class ZeroPad1d(nn.Module): + def __init__(self, pad_left, pad_right): + super().__init__() + self.pad_left = pad_left + self.pad_right = pad_right + + def forward(self, x): + return F.pad(x, (self.pad_left, self.pad_right)) + + +class ConvAggegator(nn.Module): + def __init__( + self, + conv_layers, + embed, + dropout, + skip_connections, + residual_scale, + non_affine_group_norm, + conv_bias, + zero_pad, + activation, + ): + super().__init__() + + def block(n_in, n_out, k, stride): + # padding dims only really make sense for stride = 1 + ka = k // 2 + kb = ka - 1 if k % 2 == 0 else ka + + pad = ( + ZeroPad1d(ka + kb, 0) if zero_pad else nn.ReplicationPad1d((ka + kb, 0)) + ) + + return nn.Sequential( + pad, + nn.Conv1d(n_in, n_out, k, stride=stride, bias=conv_bias), + nn.Dropout(p=dropout), + norm_block(False, n_out, affine=not non_affine_group_norm), + activation, + ) + + in_d = embed + self.conv_layers = nn.ModuleList() + self.residual_proj = nn.ModuleList() + for dim, k, stride in conv_layers: + if in_d != dim and skip_connections: + self.residual_proj.append(nn.Conv1d(in_d, dim, 1, bias=False)) + else: + self.residual_proj.append(None) + + self.conv_layers.append(block(in_d, dim, k, stride)) + in_d = dim + self.conv_layers = nn.Sequential(*self.conv_layers) + self.skip_connections = skip_connections + self.residual_scale = math.sqrt(residual_scale) + + def forward(self, x): + for rproj, conv in zip(self.residual_proj, self.conv_layers): + residual = x + x = conv(x) + if self.skip_connections: + if rproj is not None: + residual = rproj(residual) + x = (x + residual) * self.residual_scale + return x + + +class Wav2VecPredictionsModel(nn.Module): + def __init__( + self, + in_dim, + out_dim, + prediction_steps, + n_negatives, + cross_sample_negatives, + sample_distance, + dropout, + offset, + balanced_classes, + infonce, + ): + super().__init__() + + self.n_negatives = n_negatives + self.cross_sample_negatives = cross_sample_negatives + self.sample_distance = sample_distance + self.project_to_steps = nn.ConvTranspose2d( + in_dim, out_dim, (1, prediction_steps) + ) + self.dropout = nn.Dropout(p=dropout) + self.offset = offset + self.balanced_classes = balanced_classes + self.infonce = infonce + + def sample_negatives(self, y): + bsz, fsz, tsz = y.shape + + y = y.transpose(0, 1) # BCT -> CBT + y = y.contiguous().view(fsz, -1) # CBT => C(BxT) + + cross_high = tsz * bsz + high = tsz if self.sample_distance is None else min(tsz, self.sample_distance) + assert high > 1 + + neg_idxs = torch.randint(low=0, high=high, size=(bsz, self.n_negatives * tsz)) + + with torch.no_grad(): + if self.n_negatives > 0: + tszs = ( + buffered_arange(tsz) + .unsqueeze(-1) + .expand(-1, self.n_negatives) + .flatten() + ) + + neg_idxs = torch.randint( + low=0, high=high - 1, size=(bsz, self.n_negatives * tsz) + ) + neg_idxs[neg_idxs >= tszs] += 1 + + if self.cross_sample_negatives > 0: + tszs = ( + buffered_arange(tsz) + .unsqueeze(-1) + .expand(-1, self.cross_sample_negatives) + .flatten() + ) + + cross_neg_idxs = torch.randint( + low=0, + high=cross_high - 1, + size=(bsz, self.cross_sample_negatives * tsz), + ) + cross_neg_idxs[cross_neg_idxs >= tszs] += 1 + + if self.n_negatives > 0: + for i in range(1, bsz): + neg_idxs[i] += i * high + else: + neg_idxs = cross_neg_idxs + + if self.cross_sample_negatives > 0 and self.n_negatives > 0: + neg_idxs = torch.cat([neg_idxs, cross_neg_idxs], dim=1) + + negs = y[..., neg_idxs.view(-1)] + negs = negs.view( + fsz, bsz, self.n_negatives + self.cross_sample_negatives, tsz + ).permute( + 2, 1, 0, 3 + ) # to NxBxCxT + + return negs + + def forward(self, x, y): + + x = x.unsqueeze(-1) + x = self.project_to_steps(x) # BxCxTxS + x = self.dropout(x) + + negatives = self.sample_negatives(y) + y = y.unsqueeze(0) + targets = torch.cat([y, negatives], dim=0) # Copies x B x C x T + + copies = targets.size(0) + bsz, dim, tsz, steps = x.shape + steps = min(steps, tsz - self.offset) + + predictions = x.new( + bsz * copies * (tsz - self.offset + 1) * steps + - ((steps + 1) * steps // 2) * copies * bsz + ) + if self.infonce: + labels = predictions.new_full( + (predictions.shape[0] // copies,), 0, dtype=torch.long + ) + else: + labels = torch.zeros_like(predictions) + weights = ( + torch.full_like(labels, 1 / self.n_negatives) + if self.balanced_classes and not self.infonce + else None + ) + + start = end = 0 + for i in range(steps): + offset = i + self.offset + end = start + (tsz - offset) * bsz * copies + if self.infonce: + predictions[start:end] = torch.einsum( + "bct,nbct->tbn", x[..., :-offset, i], targets[..., offset:] + ).flatten() + else: + pos_num = (end - start) // copies + predictions[start:end] = torch.einsum( + "bct,nbct->nbt", x[..., :-offset, i], targets[..., offset:] + ).flatten() + labels[start : start + pos_num] = 1.0 + if weights is not None: + weights[start : start + pos_num] = 1.0 + start = end + assert end == predictions.numel(), "{} != {}".format(end, predictions.numel()) + + if self.infonce: + predictions = predictions.view(-1, copies) + else: + if weights is not None: + labels = (labels, weights) + + return predictions, labels diff --git a/fairseq/fairseq/models/wav2vec/wav2vec2.py b/fairseq/fairseq/models/wav2vec/wav2vec2.py new file mode 100644 index 0000000000000000000000000000000000000000..714fd3ab50443b8d15715b1cf5abd4eb517298c4 --- /dev/null +++ b/fairseq/fairseq/models/wav2vec/wav2vec2.py @@ -0,0 +1,1016 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import List, Tuple + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.data.data_utils import compute_mask_indices +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.models import BaseFairseqModel, register_model +from fairseq.modules import ( + Fp32GroupNorm, + Fp32LayerNorm, + GradMultiply, + GumbelVectorQuantizer, + LayerNorm, + MultiheadAttention, + SamePad, + TransposeLast, +) +from fairseq.modules.transformer_sentence_encoder import init_bert_params +from fairseq.utils import buffered_arange, index_put, is_xla_tensor + + +EXTRACTOR_MODE_CHOICES = ChoiceEnum(["default", "layer_norm"]) +MASKING_DISTRIBUTION_CHOICES = ChoiceEnum(["static", "uniform", "normal", "poisson"]) + + +@dataclass +class Wav2Vec2Config(FairseqDataclass): + extractor_mode: EXTRACTOR_MODE_CHOICES = field( + default="default", + metadata={ + "help": "mode for feature extractor. default has a single group norm with d " + "groups in the first conv block, whereas layer_norm has layer norms in " + "every block (meant to use with normalize=True)" + }, + ) + encoder_layers: int = field( + default=12, metadata={"help": "num encoder layers in the transformer"} + ) + encoder_embed_dim: int = field( + default=768, metadata={"help": "encoder embedding dimension"} + ) + encoder_ffn_embed_dim: int = field( + default=3072, metadata={"help": "encoder embedding dimension for FFN"} + ) + encoder_attention_heads: int = field( + default=12, metadata={"help": "num encoder attention heads"} + ) + activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field( + default="gelu", metadata={"help": "activation function to use"} + ) + + # dropouts + dropout: float = field( + default=0.1, metadata={"help": "dropout probability for the transformer"} + ) + attention_dropout: float = field( + default=0.1, metadata={"help": "dropout probability for attention weights"} + ) + activation_dropout: float = field( + default=0.0, metadata={"help": "dropout probability after activation in FFN"} + ) + encoder_layerdrop: float = field( + default=0.0, metadata={"help": "probability of dropping a tarnsformer layer"} + ) + dropout_input: float = field( + default=0.0, + metadata={"help": "dropout to apply to the input (after feat extr)"}, + ) + dropout_features: float = field( + default=0.0, + metadata={"help": "dropout to apply to the features (after feat extr)"}, + ) + + final_dim: int = field( + default=0, + metadata={ + "help": "project final representations and targets to this many dimensions." + "set to encoder_embed_dim is <= 0" + }, + ) + layer_norm_first: bool = field( + default=False, metadata={"help": "apply layernorm first in the transformer"} + ) + conv_feature_layers: str = field( + default="[(512, 10, 5)] + [(512, 3, 2)] * 4 + [(512,2,2)] + [(512,2,2)]", + metadata={ + "help": "string describing convolutional feature extraction layers in form of a python list that contains " + "[(dim, kernel_size, stride), ...]" + }, + ) + conv_bias: bool = field( + default=False, metadata={"help": "include bias in conv encoder"} + ) + logit_temp: float = field( + default=0.1, metadata={"help": "temperature to divide logits by"} + ) + quantize_targets: bool = field( + default=False, metadata={"help": "use quantized targets"} + ) + quantize_input: bool = field( + default=False, metadata={"help": "use quantized inputs"} + ) + same_quantizer: bool = field( + default=False, metadata={"help": "use same quantizer for inputs and targets"} + ) + target_glu: bool = field( + default=False, metadata={"help": "adds projection + glu to targets"} + ) + feature_grad_mult: float = field( + default=1.0, metadata={"help": "multiply feature extractor var grads by this"} + ) + quantizer_depth: int = field( + default=1, + metadata={"help": "number of quantizer layers"}, + ) + quantizer_factor: int = field( + default=3, + metadata={ + "help": "dimensionality increase for inner quantizer layers (if depth > 1)" + }, + ) + latent_vars: int = field( + default=320, + metadata={"help": "number of latent variables V in each group of the codebook"}, + ) + latent_groups: int = field( + default=2, + metadata={"help": "number of groups G of latent variables in the codebook"}, + ) + latent_dim: int = field( + default=0, + metadata={ + "help": "if > 0, uses this dimensionality for latent variables. " + "otherwise uses final_dim / latent_groups" + }, + ) + + # masking + mask_length: int = field(default=10, metadata={"help": "mask length"}) + mask_prob: float = field( + default=0.65, metadata={"help": "probability of replacing a token with mask"} + ) + mask_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", metadata={"help": "how to choose mask length"} + ) + mask_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument (used for more complex distributions), " + "see help in compute_mask_indices" + }, + ) + no_mask_overlap: bool = field( + default=False, metadata={"help": "whether to allow masks to overlap"} + ) + mask_min_space: int = field( + default=1, + metadata={"help": "min space between spans (if no overlap is enabled)"}, + ) + + # channel masking + mask_channel_length: int = field( + default=10, metadata={"help": "length of the mask for features (channels)"} + ) + mask_channel_prob: float = field( + default=0.0, metadata={"help": "probability of replacing a feature with 0"} + ) + mask_channel_before: bool = False + mask_channel_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", + metadata={"help": "how to choose mask length for channel masking"}, + ) + mask_channel_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument (used for more complex distributions), " + "see help in compute_mask_indicesh" + }, + ) + no_mask_channel_overlap: bool = field( + default=False, metadata={"help": "whether to allow channel masks to overlap"} + ) + mask_channel_min_space: int = field( + default=1, + metadata={"help": "min space between spans (if no overlap is enabled)"}, + ) + + # negative selection + num_negatives: int = field( + default=100, + metadata={"help": "number of negative examples from the same sample"}, + ) + negatives_from_everywhere: bool = field( + default=False, + metadata={"help": "sample negatives from everywhere, not just masked states"}, + ) + cross_sample_negatives: int = field( + default=0, metadata={"help": "number of negative examples from the any sample"} + ) + codebook_negatives: int = field( + default=0, metadata={"help": "number of negative examples codebook"} + ) + + # positional embeddings + conv_pos: int = field( + default=128, + metadata={"help": "number of filters for convolutional positional embeddings"}, + ) + conv_pos_groups: int = field( + default=16, + metadata={"help": "number of groups for convolutional positional embedding"}, + ) + + latent_temp: Tuple[float, float, float] = field( + default=(2, 0.5, 0.999995), + metadata={ + "help": "temperature for latent variable sampling. " + "can be tuple of 3 values (start, end, decay)" + }, + ) + + +@register_model("wav2vec2", dataclass=Wav2Vec2Config) +class Wav2Vec2Model(BaseFairseqModel): + def __init__(self, cfg: Wav2Vec2Config): + super().__init__() + self.cfg = cfg + + feature_enc_layers = eval(cfg.conv_feature_layers) + self.embed = feature_enc_layers[-1][0] + + self.feature_extractor = ConvFeatureExtractionModel( + conv_layers=feature_enc_layers, + dropout=0.0, + mode=cfg.extractor_mode, + conv_bias=cfg.conv_bias, + ) + + self.post_extract_proj = ( + nn.Linear(self.embed, cfg.encoder_embed_dim) + if self.embed != cfg.encoder_embed_dim and not cfg.quantize_input + else None + ) + + self.mask_prob = cfg.mask_prob + self.mask_selection = cfg.mask_selection + self.mask_other = cfg.mask_other + self.mask_length = cfg.mask_length + self.no_mask_overlap = cfg.no_mask_overlap + self.mask_min_space = cfg.mask_min_space + + self.mask_channel_prob = cfg.mask_channel_prob + self.mask_channel_before = cfg.mask_channel_before + self.mask_channel_selection = cfg.mask_channel_selection + self.mask_channel_other = cfg.mask_channel_other + self.mask_channel_length = cfg.mask_channel_length + self.no_mask_channel_overlap = cfg.no_mask_channel_overlap + self.mask_channel_min_space = cfg.mask_channel_min_space + + self.dropout_input = nn.Dropout(cfg.dropout_input) + self.dropout_features = nn.Dropout(cfg.dropout_features) + + self.feature_grad_mult = cfg.feature_grad_mult + + self.quantizer = None + self.input_quantizer = None + + self.n_negatives = cfg.num_negatives + self.cross_sample_negatives = cfg.cross_sample_negatives + self.codebook_negatives = cfg.codebook_negatives + self.negatives_from_everywhere = cfg.negatives_from_everywhere + + self.logit_temp = cfg.logit_temp + + final_dim = cfg.final_dim if cfg.final_dim > 0 else cfg.encoder_embed_dim + + if cfg.quantize_targets: + vq_dim = cfg.latent_dim if cfg.latent_dim > 0 else final_dim + self.quantizer = GumbelVectorQuantizer( + dim=self.embed, + num_vars=cfg.latent_vars, + temp=cfg.latent_temp, + groups=cfg.latent_groups, + combine_groups=False, + vq_dim=vq_dim, + time_first=True, + weight_proj_depth=cfg.quantizer_depth, + weight_proj_factor=cfg.quantizer_factor, + ) + self.project_q = nn.Linear(vq_dim, final_dim) + else: + self.project_q = nn.Linear(self.embed, final_dim) + + if cfg.quantize_input: + if cfg.same_quantizer and self.quantizer is not None: + vq_dim = final_dim + self.input_quantizer = self.quantizer + else: + vq_dim = cfg.latent_dim if cfg.latent_dim > 0 else cfg.encoder_embed_dim + self.input_quantizer = GumbelVectorQuantizer( + dim=self.embed, + num_vars=cfg.latent_vars, + temp=cfg.latent_temp, + groups=cfg.latent_groups, + combine_groups=False, + vq_dim=vq_dim, + time_first=True, + weight_proj_depth=cfg.quantizer_depth, + weight_proj_factor=cfg.quantizer_factor, + ) + self.project_inp = nn.Linear(vq_dim, cfg.encoder_embed_dim) + + self.mask_emb = nn.Parameter( + torch.FloatTensor(cfg.encoder_embed_dim).uniform_() + ) + + self.encoder = TransformerEncoder(cfg) + self.layer_norm = LayerNorm(self.embed) + + self.target_glu = None + if cfg.target_glu: + self.target_glu = nn.Sequential( + nn.Linear(final_dim, final_dim * 2), nn.GLU() + ) + + self.final_proj = nn.Linear(cfg.encoder_embed_dim, final_dim) + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + return state_dict + + @classmethod + def build_model(cls, cfg: Wav2Vec2Config, task=None): + """Build a new model instance.""" + + return cls(cfg) + + def apply_mask( + self, + x, + padding_mask, + mask_indices=None, + mask_channel_indices=None, + ): + B, T, C = x.shape + + if self.mask_channel_prob > 0 and self.mask_channel_before: + mask_channel_indices = compute_mask_indices( + (B, C), + None, + self.mask_channel_prob, + self.mask_channel_length, + self.mask_channel_selection, + self.mask_channel_other, + no_overlap=self.no_mask_channel_overlap, + min_space=self.mask_channel_min_space, + ) + mask_channel_indices = ( + torch.from_numpy(mask_channel_indices) + .to(x.device) + .unsqueeze(1) + .expand(-1, T, -1) + ) + x[mask_channel_indices] = 0 + + if self.mask_prob > 0: + if mask_indices is None: + mask_indices = compute_mask_indices( + (B, T), + padding_mask, + self.mask_prob, + self.mask_length, + self.mask_selection, + self.mask_other, + min_masks=2, + no_overlap=self.no_mask_overlap, + min_space=self.mask_min_space, + ) + mask_indices = torch.from_numpy(mask_indices).to(x.device) + x = index_put(x, mask_indices, self.mask_emb) + else: + mask_indices = None + + if self.mask_channel_prob > 0 and not self.mask_channel_before: + if mask_channel_indices is None: + mask_channel_indices = compute_mask_indices( + (B, C), + None, + self.mask_channel_prob, + self.mask_channel_length, + self.mask_channel_selection, + self.mask_channel_other, + no_overlap=self.no_mask_channel_overlap, + min_space=self.mask_channel_min_space, + ) + mask_channel_indices = ( + torch.from_numpy(mask_channel_indices) + .to(x.device) + .unsqueeze(1) + .expand(-1, T, -1) + ) + x = index_put(x, mask_channel_indices, 0) + + return x, mask_indices + + def sample_negatives(self, y, num, padding_count=None): + + if self.n_negatives == 0 and self.cross_sample_negatives == 0: + return y.new(0) + + bsz, tsz, fsz = y.shape + y = y.view(-1, fsz) # BTC => (BxT)C + + # FIXME: what happens if padding_count is specified? + cross_high = tsz * bsz + high = tsz - (padding_count or 0) + with torch.no_grad(): + assert high > 1, f"{bsz,tsz,fsz}" + + if self.n_negatives > 0: + tszs = ( + buffered_arange(num) + .unsqueeze(-1) + .expand(-1, self.n_negatives) + .flatten() + ) + + neg_idxs = torch.randint( + low=0, high=high - 1, size=(bsz, self.n_negatives * num) + ) + neg_idxs[neg_idxs >= tszs] += 1 + + if self.cross_sample_negatives > 0: + tszs = ( + buffered_arange(num) + .unsqueeze(-1) + .expand(-1, self.cross_sample_negatives) + .flatten() + ) + + cross_neg_idxs = torch.randint( + low=0, + high=cross_high - 1, + size=(bsz, self.cross_sample_negatives * num), + ) + cross_neg_idxs[cross_neg_idxs >= tszs] += 1 + + if self.n_negatives > 0: + for i in range(1, bsz): + neg_idxs[i] += i * high + else: + neg_idxs = cross_neg_idxs + + if self.cross_sample_negatives > 0 and self.n_negatives > 0: + neg_idxs = torch.cat([neg_idxs, cross_neg_idxs], dim=1) + + negs = y[neg_idxs.view(-1)] + negs = negs.view( + bsz, num, self.n_negatives + self.cross_sample_negatives, fsz + ).permute( + 2, 0, 1, 3 + ) # to NxBxTxC + return negs, neg_idxs + + def compute_preds(self, x, y, negatives): + + neg_is_pos = (y == negatives).all(-1) + y = y.unsqueeze(0) + targets = torch.cat([y, negatives], dim=0) + + logits = torch.cosine_similarity(x.float(), targets.float(), dim=-1).type_as(x) + + logits = logits / self.logit_temp + + if is_xla_tensor(logits) or neg_is_pos.any(): + fillval = -float(2 ** 30) + if not hasattr(self, "_inftensor"): + self._inftensor = ( + torch.tensor(fillval).to(x.device) + if is_xla_tensor(logits) + else float("-inf") + ) + logits[1:] = index_put(logits[1:], neg_is_pos, self._inftensor) + + return logits + + def _get_feat_extract_output_lengths(self, input_lengths: torch.LongTensor): + """ + Computes the output length of the convolutional layers + """ + + def _conv_out_length(input_length, kernel_size, stride): + return torch.floor((input_length - kernel_size) / stride + 1) + + conv_cfg_list = eval(self.cfg.conv_feature_layers) + + for i in range(len(conv_cfg_list)): + input_lengths = _conv_out_length( + input_lengths, conv_cfg_list[i][1], conv_cfg_list[i][2] + ) + + return input_lengths.to(torch.long) + + def forward( + self, + source, + padding_mask=None, + mask=True, + features_only=False, + layer=None, + mask_indices=None, + mask_channel_indices=None, + padding_count=None, + ): + + if self.feature_grad_mult > 0: + features = self.feature_extractor(source) + if self.feature_grad_mult != 1.0: + features = GradMultiply.apply(features, self.feature_grad_mult) + else: + with torch.no_grad(): + features = self.feature_extractor(source) + + features_pen = features.float().pow(2).mean() + + features = features.transpose(1, 2) + features = self.layer_norm(features) + unmasked_features = features.clone() + + if padding_mask is not None and padding_mask.any(): + input_lengths = (1 - padding_mask.long()).sum(-1) + # apply conv formula to get real output_lengths + output_lengths = self._get_feat_extract_output_lengths(input_lengths) + + padding_mask = torch.zeros( + features.shape[:2], dtype=features.dtype, device=features.device + ) + + # these two operations makes sure that all values + # before the output lengths indices are attended to + padding_mask[ + ( + torch.arange(padding_mask.shape[0], device=padding_mask.device), + output_lengths - 1, + ) + ] = 1 + padding_mask = (1 - padding_mask.flip([-1]).cumsum(-1).flip([-1])).bool() + else: + padding_mask = None + + if self.post_extract_proj is not None: + features = self.post_extract_proj(features) + + features = self.dropout_input(features) + unmasked_features = self.dropout_features(unmasked_features) + + num_vars = None + code_ppl = None + prob_ppl = None + curr_temp = None + + if self.input_quantizer: + q = self.input_quantizer(features, produce_targets=False) + features = q["x"] + num_vars = q["num_vars"] + code_ppl = q["code_perplexity"] + prob_ppl = q["prob_perplexity"] + curr_temp = q["temp"] + features = self.project_inp(features) + + if mask: + x, mask_indices = self.apply_mask( + features, + padding_mask, + mask_indices=mask_indices, + mask_channel_indices=mask_channel_indices, + ) + if not is_xla_tensor(x) and mask_indices is not None: + # tpu-comment: reducing the size in a dynamic way causes + # too many recompilations on xla. + y = unmasked_features[mask_indices].view( + unmasked_features.size(0), -1, unmasked_features.size(-1) + ) + else: + y = unmasked_features + else: + x = features + y = unmasked_features + mask_indices = None + + x, layer_results = self.encoder(x, padding_mask=padding_mask, layer=layer) + + if features_only: + return { + "x": x, + "padding_mask": padding_mask, + "features": unmasked_features, + "layer_results": layer_results, + } + + if self.quantizer: + q = self.quantizer(y, produce_targets=False) + y = q["x"] + num_vars = q["num_vars"] + code_ppl = q["code_perplexity"] + prob_ppl = q["prob_perplexity"] + curr_temp = q["temp"] + + y = self.project_q(y) + + if self.negatives_from_everywhere: + neg_cands = self.quantizer(unmasked_features, produce_targets=False)[ + "x" + ] + negs, _ = self.sample_negatives( + neg_cands, + y.size(1), + padding_count=padding_count, + ) + negs = self.project_q(negs) + + else: + negs, _ = self.sample_negatives( + y, + y.size(1), + padding_count=padding_count, + ) + + if self.codebook_negatives > 0: + cb_negs = self.quantizer.sample_from_codebook( + y.size(0) * y.size(1), self.codebook_negatives + ) + cb_negs = cb_negs.view( + self.codebook_negatives, y.size(0), y.size(1), -1 + ) # order doesnt matter + cb_negs = self.project_q(cb_negs) + negs = torch.cat([negs, cb_negs], dim=0) + else: + y = self.project_q(y) + + if self.negatives_from_everywhere: + negs, _ = self.sample_negatives( + unmasked_features, + y.size(1), + padding_count=padding_count, + ) + negs = self.project_q(negs) + else: + negs, _ = self.sample_negatives( + y, + y.size(1), + padding_count=padding_count, + ) + + if not is_xla_tensor(x): + # tpu-comment: reducing the size in a dynamic way causes + # too many recompilations on xla. + x = x[mask_indices].view(x.size(0), -1, x.size(-1)) + + if self.target_glu: + y = self.target_glu(y) + negs = self.target_glu(negs) + + x = self.final_proj(x) + x = self.compute_preds(x, y, negs) + + result = { + "x": x, + "padding_mask": padding_mask, + "features_pen": features_pen, + } + + if prob_ppl is not None: + result["prob_perplexity"] = prob_ppl + result["code_perplexity"] = code_ppl + result["num_vars"] = num_vars + result["temp"] = curr_temp + + return result + + def quantize(self, x): + assert self.quantizer is not None + x = self.feature_extractor(x) + x = x.transpose(1, 2) + x = self.layer_norm(x) + return self.quantizer.forward_idx(x) + + def extract_features(self, source, padding_mask, mask=False, layer=None): + res = self.forward( + source, padding_mask, mask=mask, features_only=True, layer=layer + ) + return res + + def get_logits(self, net_output): + logits = net_output["x"] + logits = logits.transpose(0, 2) + logits = logits.reshape(-1, logits.size(-1)) + return logits + + def get_targets(self, sample, net_output, expand_steps=True): + x = net_output["x"] + return x.new_zeros(x.size(1) * x.size(2), dtype=torch.long) + + def get_extra_losses(self, net_output): + pen = [] + + if "prob_perplexity" in net_output: + pen.append( + (net_output["num_vars"] - net_output["prob_perplexity"]) + / net_output["num_vars"] + ) + + if "features_pen" in net_output: + pen.append(net_output["features_pen"]) + + return pen + + def remove_pretraining_modules(self): + self.quantizer = None + self.project_q = None + self.target_glu = None + self.final_proj = None + + +class ConvFeatureExtractionModel(nn.Module): + def __init__( + self, + conv_layers: List[Tuple[int, int, int]], + dropout: float = 0.0, + mode: str = "default", + conv_bias: bool = False, + ): + super().__init__() + + assert mode in {"default", "layer_norm"} + + def block( + n_in, + n_out, + k, + stride, + is_layer_norm=False, + is_group_norm=False, + conv_bias=False, + ): + def make_conv(): + conv = nn.Conv1d(n_in, n_out, k, stride=stride, bias=conv_bias) + nn.init.kaiming_normal_(conv.weight) + return conv + + assert ( + is_layer_norm and is_group_norm + ) == False, "layer norm and group norm are exclusive" + + if is_layer_norm: + return nn.Sequential( + make_conv(), + nn.Dropout(p=dropout), + nn.Sequential( + TransposeLast(), + Fp32LayerNorm(dim, elementwise_affine=True), + TransposeLast(), + ), + nn.GELU(), + ) + elif is_group_norm: + return nn.Sequential( + make_conv(), + nn.Dropout(p=dropout), + Fp32GroupNorm(dim, dim, affine=True), + nn.GELU(), + ) + else: + return nn.Sequential(make_conv(), nn.Dropout(p=dropout), nn.GELU()) + + in_d = 1 + self.conv_layers = nn.ModuleList() + for i, cl in enumerate(conv_layers): + assert len(cl) == 3, "invalid conv definition: " + str(cl) + (dim, k, stride) = cl + + self.conv_layers.append( + block( + in_d, + dim, + k, + stride, + is_layer_norm=mode == "layer_norm", + is_group_norm=mode == "default" and i == 0, + conv_bias=conv_bias, + ) + ) + in_d = dim + + def forward(self, x): + + # BxT -> BxCxT + x = x.unsqueeze(1) + + for conv in self.conv_layers: + x = conv(x) + + return x + + +class TransformerEncoder(nn.Module): + def __init__(self, args): + super().__init__() + + self.dropout = args.dropout + self.embedding_dim = args.encoder_embed_dim + + self.pos_conv = nn.Conv1d( + self.embedding_dim, + self.embedding_dim, + kernel_size=args.conv_pos, + padding=args.conv_pos // 2, + groups=args.conv_pos_groups, + ) + dropout = 0 + std = math.sqrt((4 * (1.0 - dropout)) / (args.conv_pos * self.embedding_dim)) + nn.init.normal_(self.pos_conv.weight, mean=0, std=std) + nn.init.constant_(self.pos_conv.bias, 0) + + self.pos_conv = nn.utils.weight_norm(self.pos_conv, name="weight", dim=2) + self.pos_conv = nn.Sequential(self.pos_conv, SamePad(args.conv_pos), nn.GELU()) + + self.layers = nn.ModuleList( + [ + TransformerSentenceEncoderLayer( + embedding_dim=self.embedding_dim, + ffn_embedding_dim=args.encoder_ffn_embed_dim, + num_attention_heads=args.encoder_attention_heads, + dropout=self.dropout, + attention_dropout=args.attention_dropout, + activation_dropout=args.activation_dropout, + activation_fn=args.activation_fn, + layer_norm_first=args.layer_norm_first, + ) + for _ in range(args.encoder_layers) + ] + ) + + self.layer_norm_first = args.layer_norm_first + self.layer_norm = LayerNorm(self.embedding_dim) + self.layerdrop = args.encoder_layerdrop + + self.apply(init_bert_params) + + def forward(self, x, padding_mask=None, layer=None): + x, layer_results = self.extract_features(x, padding_mask, layer) + + if self.layer_norm_first and layer is None: + x = self.layer_norm(x) + + return x, layer_results + + def extract_features(self, x, padding_mask=None, tgt_layer=None): + + if padding_mask is not None: + x = index_put(x, padding_mask, 0) + + x_conv = self.pos_conv(x.transpose(1, 2)) + x_conv = x_conv.transpose(1, 2) + x = x + x_conv + + if not self.layer_norm_first: + x = self.layer_norm(x) + + x = F.dropout(x, p=self.dropout, training=self.training) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + layer_results = [] + r = None + for i, layer in enumerate(self.layers): + dropout_probability = np.random.random() + if not self.training or (dropout_probability > self.layerdrop): + x, z = layer(x, self_attn_padding_mask=padding_mask, need_weights=False) + if tgt_layer is not None: + layer_results.append((x, z)) + if i == tgt_layer: + r = x + break + + if r is not None: + x = r + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + return x, layer_results + + def max_positions(self): + """Maximum output length supported by the encoder.""" + return self.args.max_positions + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + return state_dict + + +class TransformerSentenceEncoderLayer(nn.Module): + """ + Implements a Transformer Encoder Layer used in BERT/XLM style pre-trained + models. + """ + + def __init__( + self, + embedding_dim: float = 768, + ffn_embedding_dim: float = 3072, + num_attention_heads: float = 8, + dropout: float = 0.1, + attention_dropout: float = 0.1, + activation_dropout: float = 0.1, + activation_fn: str = "relu", + layer_norm_first: bool = False, + ) -> None: + + super().__init__() + # Initialize parameters + self.embedding_dim = embedding_dim + self.dropout = dropout + self.activation_dropout = activation_dropout + + # Initialize blocks + self.activation_fn = utils.get_activation_fn(activation_fn) + self.self_attn = MultiheadAttention( + self.embedding_dim, + num_attention_heads, + dropout=attention_dropout, + self_attention=True, + ) + + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(self.activation_dropout) + self.dropout3 = nn.Dropout(dropout) + + self.layer_norm_first = layer_norm_first + + # layer norm associated with the self attention layer + self.self_attn_layer_norm = LayerNorm(self.embedding_dim) + self.fc1 = nn.Linear(self.embedding_dim, ffn_embedding_dim) + self.fc2 = nn.Linear(ffn_embedding_dim, self.embedding_dim) + + # layer norm associated with the position wise feed-forward NN + self.final_layer_norm = LayerNorm(self.embedding_dim) + + def forward( + self, + x: torch.Tensor, + self_attn_mask: torch.Tensor = None, + self_attn_padding_mask: torch.Tensor = None, + need_weights: bool = False, + att_args=None, + ): + """ + LayerNorm is applied either before or after the self-attention/ffn + modules similar to the original Transformer imlementation. + """ + residual = x + + if self.layer_norm_first: + x = self.self_attn_layer_norm(x) + x, attn = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=self_attn_padding_mask, + attn_mask=self_attn_mask, + ) + x = self.dropout1(x) + x = residual + x + + residual = x + x = self.final_layer_norm(x) + x = self.activation_fn(self.fc1(x)) + x = self.dropout2(x) + x = self.fc2(x) + x = self.dropout3(x) + x = residual + x + else: + x, attn = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=self_attn_padding_mask, + ) + + x = self.dropout1(x) + x = residual + x + + x = self.self_attn_layer_norm(x) + + residual = x + x = self.activation_fn(self.fc1(x)) + x = self.dropout2(x) + x = self.fc2(x) + x = self.dropout3(x) + x = residual + x + x = self.final_layer_norm(x) + + return x, attn diff --git a/fairseq/fairseq/models/wav2vec/wav2vec2_asr.py b/fairseq/fairseq/models/wav2vec/wav2vec2_asr.py new file mode 100644 index 0000000000000000000000000000000000000000..eb5d819da5121a243e345b3812292ef0b13ccf98 --- /dev/null +++ b/fairseq/fairseq/models/wav2vec/wav2vec2_asr.py @@ -0,0 +1,664 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from argparse import Namespace +import contextlib +import copy +import math +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from dataclasses import dataclass, field +from omegaconf import MISSING, II, open_dict +from typing import Any, Optional + +from fairseq import checkpoint_utils, tasks, utils +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.tasks import FairseqTask +from fairseq.models import ( + BaseFairseqModel, + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, +) +from fairseq.models.wav2vec.wav2vec2 import MASKING_DISTRIBUTION_CHOICES +from fairseq.modules import ( + LayerNorm, + PositionalEmbedding, + TransformerDecoderLayer, +) + + +@dataclass +class Wav2Vec2AsrConfig(FairseqDataclass): + w2v_path: str = field( + default=MISSING, metadata={"help": "path to wav2vec 2.0 model"} + ) + no_pretrained_weights: bool = field( + default=False, metadata={"help": "if true, does not load pretrained weights"} + ) + dropout_input: float = field( + default=0.0, + metadata={"help": "dropout to apply to the input (after feat extr)"}, + ) + final_dropout: float = field( + default=0.0, + metadata={"help": "dropout after transformer and before final projection"}, + ) + dropout: float = field( + default=0.0, metadata={"help": "dropout probability inside wav2vec 2.0 model"} + ) + attention_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability for attention weights inside wav2vec 2.0 model" + }, + ) + activation_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability after activation in FFN inside wav2vec 2.0 model" + }, + ) + conv_feature_layers: Optional[str] = field( + default="[(512, 10, 5)] + [(512, 3, 2)] * 4 + [(512,2,2)] + [(512,2,2)]", + metadata={ + "help": ( + "string describing convolutional feature extraction " + "layers in form of a python list that contains " + "[(dim, kernel_size, stride), ...]" + ), + }, + ) + encoder_embed_dim: Optional[int] = field( + default=768, metadata={"help": "encoder embedding dimension"} + ) + + # masking + apply_mask: bool = field( + default=False, metadata={"help": "apply masking during fine-tuning"} + ) + mask_length: int = field( + default=10, metadata={"help": "repeat the mask indices multiple times"} + ) + mask_prob: float = field( + default=0.5, + metadata={ + "help": "probability of replacing a token with mask (normalized by length)" + }, + ) + mask_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", metadata={"help": "how to choose masks"} + ) + mask_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument (used for more complex distributions), " + "see help in compute_mask_indices" + }, + ) + no_mask_overlap: bool = field( + default=False, metadata={"help": "whether to allow masks to overlap"} + ) + mask_min_space: Optional[int] = field( + default=1, + metadata={"help": "min space between spans (if no overlap is enabled)"}, + ) + + # channel masking + mask_channel_length: int = field( + default=10, metadata={"help": "length of the mask for features (channels)"} + ) + mask_channel_prob: float = field( + default=0.0, metadata={"help": "probability of replacing a feature with 0"} + ) + mask_channel_selection: MASKING_DISTRIBUTION_CHOICES = field( + default="static", + metadata={"help": "how to choose mask length for channel masking"}, + ) + mask_channel_other: float = field( + default=0, + metadata={ + "help": "secondary mask argument (used for more complex distributions), " + "see help in compute_mask_indicesh" + }, + ) + no_mask_channel_overlap: bool = field( + default=False, metadata={"help": "whether to allow channel masks to overlap"} + ) + freeze_finetune_updates: int = field( + default=0, metadata={"help": "dont finetune wav2vec for this many updates"} + ) + feature_grad_mult: float = field( + default=0.0, metadata={"help": "reset feature grad mult in wav2vec 2.0 to this"} + ) + layerdrop: float = field( + default=0.0, metadata={"help": "probability of dropping a layer in wav2vec 2.0"} + ) + mask_channel_min_space: Optional[int] = field( + default=1, + metadata={"help": "min space between spans (if no overlap is enabled)"}, + ) + mask_channel_before: bool = False + normalize: bool = II("task.normalize") + data: str = II("task.data") + # this holds the loaded wav2vec args + w2v_args: Any = None + + +@dataclass +class Wav2Vec2CtcConfig(Wav2Vec2AsrConfig): + blank_weight: float = 0 + blank_mode: str = "add" + + +@register_model("wav2vec_ctc", dataclass=Wav2Vec2CtcConfig) +class Wav2VecCtc(BaseFairseqModel): + def __init__(self, cfg: Wav2Vec2CtcConfig, w2v_encoder: BaseFairseqModel): + super().__init__() + self.cfg = cfg + self.w2v_encoder = w2v_encoder + self.blank_weight = cfg.blank_weight + self.blank_mode = cfg.blank_mode + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + return state_dict + + @classmethod + def build_model(cls, cfg: Wav2Vec2CtcConfig, task: FairseqTask): + """Build a new model instance.""" + w2v_encoder = Wav2VecEncoder(cfg, len(task.target_dictionary)) + return cls(cfg, w2v_encoder) + + def get_logits(self, net_output, normalize=False): + logits = net_output["encoder_out"] + if self.blank_weight != 0: + if self.blank_mode == "add": + logits[..., 0] += self.blank_weight + elif self.blank_mode == "set": + logits[..., 0] = self.blank_weight + else: + raise Exception(f"invalid blank mode {self.blank_mode}") + + if net_output["padding_mask"] is not None and net_output["padding_mask"].any(): + logits[net_output["padding_mask"].T][..., 0] = float("inf") + logits[net_output["padding_mask"].T][..., 1:] = float("-inf") + + if normalize: + logits = utils.log_softmax(logits.float(), dim=-1) + + return logits + + def get_normalized_probs(self, net_output, log_probs): + """Get normalized probabilities (or log probs) from a net's output.""" + + logits = self.get_logits(net_output) + + if log_probs: + return utils.log_softmax(logits.float(), dim=-1) + else: + return utils.softmax(logits.float(), dim=-1) + + def forward(self, **kwargs): + x = self.w2v_encoder(**kwargs) + return x + + +@dataclass +class Wav2Vec2Seq2SeqConfig(Wav2Vec2AsrConfig): + decoder_embed_dim: int = field( + default=768, metadata={"help": "decoder embedding dimension"} + ) + decoder_ffn_embed_dim: int = field( + default=3072, metadata={"help": "decoder embedding dimension for FFN"} + ) + decoder_layers: int = field(default=6, metadata={"help": "num of decoder layers"}) + decoder_layerdrop: float = field( + default=0.0, metadata={"help": "decoder layerdrop chance"} + ) + decoder_attention_heads: int = field( + default=4, metadata={"help": "num decoder attention heads"} + ) + decoder_learned_pos: bool = field( + default=False, + metadata={"help": "use learned positional embeddings in the decoder"}, + ) + decoder_normalize_before: bool = field( + default=False, metadata={"help": "apply layernorm before each decoder block"} + ) + no_token_positional_embeddings: bool = field( + default=False, + metadata={ + "help": "if set, disables positional embeddings (outside self attention)" + }, + ) + decoder_dropout: float = field( + default=0.0, metadata={"help": "dropout probability in the decoder"} + ) + decoder_attention_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability for attention weights inside the decoder" + }, + ) + decoder_activation_dropout: float = field( + default=0.0, + metadata={ + "help": "dropout probability after activation in FFN inside the decoder" + }, + ) + max_target_positions: int = field( + default=2048, metadata={"help": "max target positions"} + ) + share_decoder_input_output_embed: bool = field( + default=False, metadata={"help": "share decoder input and output embeddings"} + ) + autoregressive: bool = II("task.autoregressive") + + +@register_model("wav2vec_seq2seq", dataclass=Wav2Vec2Seq2SeqConfig) +class Wav2Vec2Seq2SeqModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @classmethod + def build_model(cls, cfg: Wav2Vec2Seq2SeqConfig, task: FairseqTask): + """Build a new model instance.""" + + assert ( + cfg.autoregressive + ), "Please set task.autoregressive=true for seq2seq asr models" + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + def build_embedding(dictionary, embed_dim): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + emb = Embedding(num_embeddings, embed_dim, padding_idx) + return emb + + decoder_embed_tokens = build_embedding(tgt_dict, cfg.decoder_embed_dim) + + encoder = cls.build_encoder(cfg) + decoder = cls.build_decoder(cfg, tgt_dict, decoder_embed_tokens) + + return Wav2Vec2Seq2SeqModel(encoder, decoder) + + @classmethod + def build_encoder(cls, cfg: Wav2Vec2AsrConfig): + return Wav2VecEncoder(cfg) + + @classmethod + def build_decoder(cls, cfg: Wav2Vec2Seq2SeqConfig, tgt_dict, embed_tokens): + return TransformerDecoder(cfg, tgt_dict, embed_tokens) + + def forward(self, **kwargs): + encoder_out = self.encoder(**kwargs) + decoder_out = self.decoder(encoder_out=encoder_out, **kwargs) + return decoder_out + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + return state_dict + + +class Wav2VecEncoder(FairseqEncoder): + def __init__(self, cfg: Wav2Vec2AsrConfig, output_size=None): + self.apply_mask = cfg.apply_mask + + arg_overrides = { + "dropout": cfg.dropout, + "activation_dropout": cfg.activation_dropout, + "dropout_input": cfg.dropout_input, + "attention_dropout": cfg.attention_dropout, + "mask_length": cfg.mask_length, + "mask_prob": cfg.mask_prob, + "mask_selection": cfg.mask_selection, + "mask_other": cfg.mask_other, + "no_mask_overlap": cfg.no_mask_overlap, + "mask_channel_length": cfg.mask_channel_length, + "mask_channel_prob": cfg.mask_channel_prob, + "mask_channel_before": cfg.mask_channel_before, + "mask_channel_selection": cfg.mask_channel_selection, + "mask_channel_other": cfg.mask_channel_other, + "no_mask_channel_overlap": cfg.no_mask_channel_overlap, + "encoder_layerdrop": cfg.layerdrop, + "feature_grad_mult": cfg.feature_grad_mult, + } + + if cfg.w2v_args is None: + state = checkpoint_utils.load_checkpoint_to_cpu(cfg.w2v_path, arg_overrides) + w2v_args = state.get("cfg", None) + if w2v_args is None: + w2v_args = convert_namespace_to_omegaconf(state["args"]) + w2v_args.criterion = None + w2v_args.lr_scheduler = None + cfg.w2v_args = w2v_args + else: + state = None + w2v_args = cfg.w2v_args + if isinstance(w2v_args, Namespace): + cfg.w2v_args = w2v_args = convert_namespace_to_omegaconf(w2v_args) + + assert cfg.normalize == w2v_args.task.normalize, ( + "Fine-tuning works best when data normalization is the same. " + "Please check that --normalize is set or unset for both pre-training and here" + ) + + w2v_args.task.data = cfg.data + task = tasks.setup_task(w2v_args.task) + model = task.build_model(w2v_args.model) + + if state is not None and not cfg.no_pretrained_weights: + model.load_state_dict(state["model"], strict=True) + + model.remove_pretraining_modules() + + super().__init__(task.source_dictionary) + + d = w2v_args.model.encoder_embed_dim + + self.w2v_model = model + + self.final_dropout = nn.Dropout(cfg.final_dropout) + self.freeze_finetune_updates = cfg.freeze_finetune_updates + self.num_updates = 0 + + targ_d = None + self.proj = None + + if output_size is not None: + targ_d = output_size + elif getattr(cfg, "decoder_embed_dim", d) != d: + targ_d = cfg.decoder_embed_dim + + if targ_d is not None: + self.proj = Linear(d, targ_d) + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + super().set_num_updates(num_updates) + self.num_updates = num_updates + + def forward(self, source, padding_mask, **kwargs): + + w2v_args = { + "source": source, + "padding_mask": padding_mask, + "mask": self.apply_mask and self.training, + } + + ft = self.freeze_finetune_updates <= self.num_updates + + with torch.no_grad() if not ft else contextlib.ExitStack(): + res = self.w2v_model.extract_features(**w2v_args) + + x = res["x"] + padding_mask = res["padding_mask"] + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + x = self.final_dropout(x) + + if self.proj: + x = self.proj(x) + + return { + "encoder_out": x, # T x B x C + "padding_mask": padding_mask, # B x T, + "layer_results": res["layer_results"], + } + + def forward_torchscript(self, net_input): + if torch.jit.is_scripting(): + return self.forward(net_input["source"], net_input["padding_mask"]) + else: + return self.forward_non_torchscript(net_input) + + def reorder_encoder_out(self, encoder_out, new_order): + if encoder_out["encoder_out"] is not None: + encoder_out["encoder_out"] = encoder_out["encoder_out"].index_select( + 1, new_order + ) + if encoder_out["padding_mask"] is not None: + encoder_out["padding_mask"] = encoder_out[ + "padding_mask" + ].index_select(0, new_order) + return encoder_out + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return None + + def upgrade_state_dict_named(self, state_dict, name): + return state_dict + + +class TransformerDecoder(FairseqIncrementalDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, + cfg: Wav2Vec2Seq2SeqConfig, + dictionary, + embed_tokens, + no_encoder_attn=False, + ): + super().__init__(dictionary) + + self.dropout = cfg.decoder_dropout + self.share_input_output_embed = cfg.share_decoder_input_output_embed + + input_embed_dim = embed_tokens.embedding_dim + embed_dim = cfg.decoder_embed_dim + self.output_embed_dim = cfg.decoder_embed_dim + + self.layerdrop = cfg.decoder_layerdrop + + self.padding_idx = embed_tokens.padding_idx + self.max_target_positions = cfg.max_target_positions + + self.embed_tokens = embed_tokens + self.embed_scale = math.sqrt(embed_dim) # todo: try with input_embed_dim + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + + self.embed_positions = ( + PositionalEmbedding( + cfg.max_target_positions, + embed_dim, + self.padding_idx, + learned=cfg.decoder_learned_pos, + ) + if not cfg.no_token_positional_embeddings + else None + ) + + # TODO: update this when transformer gets converted to dataclass configs + transformer_cfg = copy.deepcopy(cfg) + with open_dict(transformer_cfg): + transformer_cfg.dropout = transformer_cfg.decoder_dropout + transformer_cfg.attention_dropout = ( + transformer_cfg.decoder_attention_dropout + ) + transformer_cfg.activation_dropout = ( + transformer_cfg.decoder_activation_dropout + ) + + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + TransformerDecoderLayer(transformer_cfg, no_encoder_attn) + for _ in range(transformer_cfg.decoder_layers) + ] + ) + + if not self.share_input_output_embed: + self.embed_out = nn.Parameter( + torch.Tensor(len(dictionary), self.output_embed_dim) + ) + nn.init.normal_(self.embed_out, mean=0, std=self.output_embed_dim ** -0.5) + + if transformer_cfg.decoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + def forward( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **unused + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (Tensor, optional): output from the encoder, used for + encoder-side attention + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + prev_output_tokens = prev_output_tokens.long() + x, extra = self.extract_features( + prev_output_tokens, encoder_out, incremental_state + ) + x = self.output_layer(x) + return x, extra + + def extract_features( + self, prev_output_tokens, encoder_out=None, incremental_state=None, **unused + ): + """ + Similar to *forward* but only return features. + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + + # embed positions + positions = ( + self.embed_positions( + prev_output_tokens, incremental_state=incremental_state + ) + if self.embed_positions is not None + else None + ) + + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + if positions is not None: + positions = positions[:, -1:] + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if positions is not None: + x += positions + x = F.dropout(x, p=self.dropout, training=self.training) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + attn = None + + inner_states = [x] + + # decoder layers + self_attn_padding_mask = None + if prev_output_tokens.eq(self.padding_idx).any(): + self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx) + for layer in self.layers: + dropout_probability = np.random.random() + if not self.training or (dropout_probability > self.layerdrop): + x, attn, _ = layer( + x, + encoder_out["encoder_out"] if encoder_out is not None else None, + encoder_out["padding_mask"] if encoder_out is not None else None, + incremental_state, + self_attn_mask=self.buffered_future_mask(x) + if incremental_state is None + else None, + self_attn_padding_mask=self_attn_padding_mask + ) + inner_states.append(x) + + if self.layer_norm: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + return x, {"attn": attn, "inner_states": inner_states} + + def output_layer(self, features, **kwargs): + """Project features to the vocabulary size.""" + # project back to size of vocabulary + if self.share_input_output_embed: + return F.linear(features, self.embed_tokens.weight) + else: + return F.linear(features, self.embed_out) + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embed_positions is None: + return self.max_target_positions + return min(self.max_target_positions, self.embed_positions.max_positions) + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + not hasattr(self, "_future_mask") + or self._future_mask is None + or self._future_mask.device != tensor.device + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(tensor.new(dim, dim)), 1 + ) + return self._future_mask[:dim, :dim] + + def upgrade_state_dict_named(self, state_dict, name): + return state_dict + + +def Embedding(num_embeddings, embedding_dim, padding_idx): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m diff --git a/fairseq/fairseq/modules/__init__.py b/fairseq/fairseq/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d7a030e2b5cbca30e6a4ca4f8a17a62a8cf197af --- /dev/null +++ b/fairseq/fairseq/modules/__init__.py @@ -0,0 +1,82 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +from .adaptive_input import AdaptiveInput +from .adaptive_softmax import AdaptiveSoftmax +from .base_layer import BaseLayer +from .beamable_mm import BeamableMM +from .character_token_embedder import CharacterTokenEmbedder +from .conv_tbc import ConvTBC +from .cross_entropy import cross_entropy +from .downsampled_multihead_attention import DownsampledMultiHeadAttention +from .dynamic_convolution import DynamicConv, DynamicConv1dTBC +from .dynamic_crf_layer import DynamicCRF +from .fairseq_dropout import FairseqDropout +from .fp32_group_norm import Fp32GroupNorm +from .gelu import gelu, gelu_accurate +from .grad_multiply import GradMultiply +from .gumbel_vector_quantizer import GumbelVectorQuantizer +from .kmeans_vector_quantizer import KmeansVectorQuantizer +from .layer_drop import LayerDropModuleList +from .layer_norm import Fp32LayerNorm, LayerNorm +from .learned_positional_embedding import LearnedPositionalEmbedding +from .lightweight_convolution import LightweightConv, LightweightConv1dTBC +from .linearized_convolution import LinearizedConvolution +from .location_attention import LocationAttention +from .lstm_cell_with_zoneout import LSTMCellWithZoneOut +from .multihead_attention import MultiheadAttention +from .positional_embedding import PositionalEmbedding +from .same_pad import SamePad +from .scalar_bias import ScalarBias +from .sinusoidal_positional_embedding import SinusoidalPositionalEmbedding +from .transformer_sentence_encoder_layer import TransformerSentenceEncoderLayer +from .transformer_sentence_encoder import TransformerSentenceEncoder +from .transpose_last import TransposeLast +from .unfold import unfold1d +from .transformer_layer import TransformerDecoderLayer, TransformerEncoderLayer +from .vggblock import VGGBlock + +__all__ = [ + "AdaptiveInput", + "AdaptiveSoftmax", + "BaseLayer", + "BeamableMM", + "CharacterTokenEmbedder", + "ConvTBC", + "cross_entropy", + "DownsampledMultiHeadAttention", + "DynamicConv1dTBC", + "DynamicConv", + "DynamicCRF", + "FairseqDropout", + "Fp32GroupNorm", + "Fp32LayerNorm", + "gelu", + "gelu_accurate", + "GradMultiply", + "GumbelVectorQuantizer", + "KmeansVectorQuantizer", + "LayerDropModuleList", + "LayerNorm", + "LearnedPositionalEmbedding", + "LightweightConv1dTBC", + "LightweightConv", + "LinearizedConvolution", + "LocationAttention", + "LSTMCellWithZoneOut", + "MultiheadAttention", + "PositionalEmbedding", + "SamePad", + "ScalarBias", + "SinusoidalPositionalEmbedding", + "TransformerSentenceEncoderLayer", + "TransformerSentenceEncoder", + "TransformerDecoderLayer", + "TransformerEncoderLayer", + "TransposeLast", + "VGGBlock", + "unfold1d", +] diff --git a/fairseq/fairseq/modules/adaptive_input.py b/fairseq/fairseq/modules/adaptive_input.py new file mode 100644 index 0000000000000000000000000000000000000000..446534a9f8b87337a4dd752944ea386ff7cf7965 --- /dev/null +++ b/fairseq/fairseq/modules/adaptive_input.py @@ -0,0 +1,80 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from typing import List + +import torch +from fairseq.modules.quant_noise import quant_noise +from torch import nn + + +class AdaptiveInput(nn.Module): + def __init__( + self, + vocab_size: int, + padding_idx: int, + initial_dim: int, + factor: float, + output_dim: int, + cutoff: List[int], + q_noise: float = 0, + qn_block_size: int = 8, + ): + super().__init__() + + if vocab_size > cutoff[-1]: + cutoff = cutoff + [vocab_size] + else: + assert ( + vocab_size == cutoff[-1] + ), "cannot specify cutoff larger than vocab size" + + self.cutoff = cutoff + self.embedding_dim = output_dim + self.padding_idx = padding_idx + + self.embeddings = nn.ModuleList() + for i in range(len(self.cutoff)): + prev = self.cutoff[i - 1] if i > 0 else 0 + size = self.cutoff[i] - prev + dim = int(initial_dim // (factor ** i)) + seq = nn.Sequential( + nn.Embedding(size, dim, self.padding_idx), + quant_noise( + nn.Linear(dim, output_dim, bias=False), q_noise, qn_block_size + ), + ) + + self.embeddings.append(seq) + self.padding_idx = None + self.padding_idx = padding_idx + + def init_weights(m): + if isinstance(m, nn.Embedding): + nn.init.normal_(m.weight, mean=0, std=m.weight.shape[1] ** -0.5) + nn.init.constant_(m.weight[padding_idx], 0) + elif hasattr(m, "weight"): + nn.init.xavier_uniform_(m.weight) + + self.apply(init_weights) + + self.register_buffer("_float_tensor", torch.FloatTensor(1)) + + def weights_for_band(self, band: int): + return self.embeddings[band][0].weight, self.embeddings[band][1].weight + + def forward(self, input: torch.Tensor): + result = self._float_tensor.new(input.shape + (self.embedding_dim,)) + for i in range(len(self.cutoff)): + mask = input.lt(self.cutoff[i]) + if i > 0: + mask.mul_(input.ge(self.cutoff[i - 1])) + chunk_input = input[mask] - self.cutoff[i - 1] + else: + chunk_input = input[mask] + if mask.any(): + result[mask] = self.embeddings[i](chunk_input) + return result diff --git a/fairseq/fairseq/modules/adaptive_softmax.py b/fairseq/fairseq/modules/adaptive_softmax.py new file mode 100644 index 0000000000000000000000000000000000000000..ae0c77ba0f6ee98501306d66cbc4a948b4ade0f7 --- /dev/null +++ b/fairseq/fairseq/modules/adaptive_softmax.py @@ -0,0 +1,268 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import functools +import operator + +import torch +import torch.nn.functional as F +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise +from torch import nn + + +class TiedLinear(nn.Module): + def __init__(self, weight, transpose): + super().__init__() + self.weight = weight + self.transpose = transpose + + def forward(self, input): + return F.linear(input, self.weight.t() if self.transpose else self.weight) + + +class TiedHeadModule(nn.Module): + def __init__(self, weights, input_dim, num_classes, q_noise, qn_block_size): + super().__init__() + tied_emb, _ = weights + self.num_words, emb_dim = tied_emb.size() + + self.word_proj = quant_noise( + TiedLinear(tied_emb, transpose=False), q_noise, qn_block_size + ) + if input_dim != emb_dim: + self.word_proj = nn.Sequential( + quant_noise( + nn.Linear(input_dim, emb_dim, bias=False), q_noise, qn_block_size + ), + self.word_proj, + ) + + self.class_proj = quant_noise( + nn.Linear(input_dim, num_classes, bias=False), q_noise, qn_block_size + ) + self.out_dim = self.num_words + num_classes + + self.register_buffer("_float_tensor", torch.FloatTensor(1)) + + def forward(self, input): + inp_sz = functools.reduce(operator.mul, input.shape[:-1], 1) + out = self._float_tensor.new(inp_sz, self.out_dim) + out[:, : self.num_words] = self.word_proj(input.view(inp_sz, -1)) + out[:, self.num_words :] = self.class_proj(input.view(inp_sz, -1)) + return out + + +class AdaptiveSoftmax(nn.Module): + """ + This is an implementation of the efficient softmax approximation for + graphical processing units (GPU), described in the paper "Efficient softmax + approximation for GPUs" (http://arxiv.org/abs/1609.04309). + """ + + def __init__( + self, + vocab_size, + input_dim, + cutoff, + dropout, + factor=4.0, + adaptive_inputs=None, + tie_proj=False, + q_noise=0, + qn_block_size=8, + ): + super().__init__() + + if vocab_size > cutoff[-1]: + cutoff = cutoff + [vocab_size] + else: + assert ( + vocab_size == cutoff[-1] + ), "cannot specify cutoff larger than vocab size" + + output_dim = cutoff[0] + len(cutoff) - 1 + + self.vocab_size = vocab_size + self.cutoff = cutoff + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.input_dim = input_dim + self.factor = factor + self.q_noise = q_noise + self.qn_block_size = qn_block_size + + self.lsm = nn.LogSoftmax(dim=1) + + if adaptive_inputs is not None: + self.head = TiedHeadModule( + adaptive_inputs.weights_for_band(0), + input_dim, + len(cutoff) - 1, + self.q_noise, + self.qn_block_size, + ) + else: + self.head = quant_noise( + nn.Linear(input_dim, output_dim, bias=False), + self.q_noise, + self.qn_block_size, + ) + + self._make_tail(adaptive_inputs, tie_proj) + + def init_weights(m): + if ( + hasattr(m, "weight") + and not isinstance(m, TiedLinear) + and not isinstance(m, TiedHeadModule) + ): + nn.init.xavier_uniform_(m.weight) + + self.apply(init_weights) + + self.register_buffer("version", torch.LongTensor([1])) + + def _make_tail(self, adaptive_inputs=None, tie_proj=False): + self.tail = nn.ModuleList() + for i in range(len(self.cutoff) - 1): + dim = int(self.input_dim // self.factor ** (i + 1)) + + tied_emb, tied_proj = ( + adaptive_inputs.weights_for_band(i + 1) + if adaptive_inputs is not None + else (None, None) + ) + + if tied_proj is not None: + if tie_proj: + proj = quant_noise( + TiedLinear(tied_proj, transpose=True), + self.q_noise, + self.qn_block_size, + ) + else: + proj = quant_noise( + nn.Linear(tied_proj.size(0), tied_proj.size(1), bias=False), + self.q_noise, + self.qn_block_size, + ) + else: + proj = quant_noise( + nn.Linear(self.input_dim, dim, bias=False), + self.q_noise, + self.qn_block_size, + ) + + if tied_emb is None: + out_proj = nn.Linear( + dim, self.cutoff[i + 1] - self.cutoff[i], bias=False + ) + else: + out_proj = TiedLinear(tied_emb, transpose=False) + + m = nn.Sequential( + proj, + nn.Dropout(self.dropout_module.p), + quant_noise(out_proj, self.q_noise, self.qn_block_size), + ) + + self.tail.append(m) + + def upgrade_state_dict_named(self, state_dict, name): + version_name = name + ".version" + if version_name not in state_dict: + raise Exception("This version of the model is no longer supported") + + def adapt_target(self, target): + """ + In order to be efficient, the AdaptiveSoftMax does not compute the + scores for all the word of the vocabulary for all the examples. It is + thus necessary to call the method adapt_target of the AdaptiveSoftMax + layer inside each forward pass. + """ + + target = target.view(-1) + new_target = [target.clone()] + target_idxs = [] + + for i in range(len(self.cutoff) - 1): + mask = target.ge(self.cutoff[i]).mul(target.lt(self.cutoff[i + 1])) + new_target[0][mask] = self.cutoff[0] + i + + if mask.any(): + target_idxs.append(mask.nonzero(as_tuple=False).squeeze(1)) + new_target.append(target[mask].add(-self.cutoff[i])) + else: + target_idxs.append(None) + new_target.append(None) + + return new_target, target_idxs + + def forward(self, input, target): + """ + Args: + input: (b x t x d) + target: (b x t) + Returns: + 2 lists: output for each cutoff section and new targets by cut off + """ + + input = input.contiguous().view(-1, input.size(-1)) + input = self.dropout_module(input) + + new_target, target_idxs = self.adapt_target(target) + output = [self.head(input)] + + for i in range(len(target_idxs)): + if target_idxs[i] is not None: + output.append(self.tail[i](input.index_select(0, target_idxs[i]))) + else: + output.append(None) + + return output, new_target + + def get_log_prob(self, input, target): + """ + Computes the log probabilities for all the words of the vocabulary, + given a 2D tensor of hidden vectors. + """ + + bsz, length, dim = input.size() + input = input.contiguous().view(-1, dim) + + if target is not None: + _, target_idxs = self.adapt_target(target) + else: + target_idxs = None + + head_y = self.head(input) + log_probs = head_y.new_zeros(input.size(0), self.vocab_size) + + head_sz = self.cutoff[0] + len(self.tail) + log_probs[:, :head_sz] = self.lsm(head_y) + tail_priors = log_probs[:, self.cutoff[0] : head_sz].clone() + + for i in range(len(self.tail)): + start = self.cutoff[i] + end = self.cutoff[i + 1] + + if target_idxs is None: + tail_out = log_probs[:, start:end] + tail_out.copy_(self.tail[i](input)) + log_probs[:, start:end] = self.lsm(tail_out).add_( + tail_priors[:, i, None] + ) + elif target_idxs[i] is not None: + idxs = target_idxs[i] + tail_out = log_probs[idxs, start:end] + tail_out.copy_(self.tail[i](input[idxs])) + log_probs[idxs, start:end] = self.lsm(tail_out).add_( + tail_priors[idxs, i, None] + ) + + log_probs = log_probs.view(bsz, length, -1) + return log_probs diff --git a/fairseq/fairseq/modules/base_layer.py b/fairseq/fairseq/modules/base_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..e7ef155b25fc73e74780879f665288c9bc95fd80 --- /dev/null +++ b/fairseq/fairseq/modules/base_layer.py @@ -0,0 +1,135 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +import torch +import sys +from fairseq import utils +from fairseq.distributed import utils as distributed_utils +from fairseq.modules.layer_norm import LayerNorm + + +class BaseLayer(nn.Module): + + def __init__(self, args): + super().__init__() + self.num_workers = distributed_utils.get_data_parallel_world_size() + expert_centroids = torch.empty(self.num_workers, args.decoder_embed_dim) + torch.nn.init.orthogonal_(expert_centroids, gain=0.1) + self.register_parameter("expert_centroids", torch.nn.Parameter(expert_centroids)) + self.expert_network = nn.Sequential(*([BaseSublayer(args) for _ in range(args.base_sublayers)])) + self.expert_id = distributed_utils.get_data_parallel_rank() + self.shuffle = args.base_shuffle + self.cpp = self.load_assignment() + + # Add a special attribute to the expert parameters, so we know not to sync their gradients + for param in self.expert_network.parameters(): + param.expert = True + + def forward(self, input_features, *args, **kwargs): + features = input_features.reshape(-1, input_features.size(-1)) + is_training = input_features.requires_grad + + if self.shuffle and is_training: + # Send each token to a random worker, to break correlations within the batch + shuffle_sort = torch.randperm(features.size(0), device=features.device) + features = All2All.apply(features[shuffle_sort]) + + with torch.no_grad(): + # Compute similarity of each token to each expert, for routing + token_expert_affinities = features.matmul(self.expert_centroids.transpose(0, 1)) + + # Compute which token goes to which expert + sort_by_expert, input_splits, output_splits = self.balanced_assignment(token_expert_affinities) \ + if is_training else self.greedy_assignment(token_expert_affinities) + # Swap these tokens for the right ones for our expert + routed_features = All2All.apply(features[sort_by_expert], output_splits, input_splits) + + if routed_features.size(0) > 0: + # Mix in the expert network based on how appropriate it is for these tokens + alpha = torch.sigmoid(routed_features.mv(self.expert_centroids[self.expert_id])).unsqueeze(1) + routed_features = alpha * self.expert_network(routed_features) + (1 - alpha) * routed_features + # Return to original worker and ordering + result = All2All.apply(routed_features, input_splits, output_splits)[self.inverse_sort(sort_by_expert)] + + if self.shuffle and is_training: + # Undo shuffling + result = All2All.apply(result)[self.inverse_sort(shuffle_sort)] + + # Return additional Nones for compatibility with TransformerDecoderLayer + return result.view(input_features.size()), None, None + + def inverse_sort(self, order): + # Creates an index that undoes a sort: xs==xs[order][inverse_sort(order)] + return torch.empty_like(order).scatter_(0, order, torch.arange(0, order.size(0), device=order.device)) + + def balanced_assignment(self, scores): + ok = scores.isfinite() + if not ok.all(): + # NaNs here can break the assignment algorithm + scores[~ok] = scores[ok].min() + return self.cpp.balanced_assignment(scores), None, None + + # Assigns each token to the top k experts + def greedy_assignment(self, scores, k=1): + token_to_workers = torch.topk(scores, dim=1, k=k, largest=True).indices.view(-1) + token_to_workers, sort_ordering = torch.sort(token_to_workers) + worker2token = sort_ordering // k + + # Find how many tokens we're sending to each other worker (being careful for sending 0 tokens to some workers) + output_splits = torch.zeros((self.num_workers,), dtype=torch.long, device=scores.device) + workers, counts = torch.unique_consecutive(token_to_workers, return_counts=True) + output_splits[workers] = counts + # Tell other workers how many tokens to expect from us + input_splits = All2All.apply(output_splits) + return worker2token, input_splits.tolist(), output_splits.tolist() + + def load_assignment(self): + try: + from fairseq import libbase + + return libbase + + except ImportError as e: + sys.stderr.write( + "ERROR: missing libbase. run `python setup.py build_ext --inplace`\n" + ) + raise e + + +class BaseSublayer(nn.Module): + def __init__(self, args): + super().__init__() + self.activation_fn = utils.get_activation_fn( + activation=getattr(args, 'activation_fn', 'relu') or "relu" + ) + self.norm = LayerNorm(args.decoder_embed_dim, export=False) + self.ff1 = torch.nn.Linear(args.decoder_embed_dim, args.decoder_ffn_embed_dim) + self.ff2 = torch.nn.Linear(args.decoder_ffn_embed_dim, args.decoder_embed_dim) + self.ff2.weight.data.zero_() + + def forward(self, xs): + return xs + self.ff2(self.activation_fn(self.ff1(self.norm(xs)))) + + +# Wraps torch.distributed.all_to_all_single as a function that supports autograd +class All2All(torch.autograd.Function): + @staticmethod + def forward(ctx, xs, input_splits=None, output_splits=None): + ctx.input_splits = input_splits + ctx.output_splits = output_splits + + ys = torch.empty_like(xs) if output_splits is None else \ + xs.new_empty(size=[sum(output_splits)] + list(xs.size()[1:])) + torch.distributed.all_to_all_single(ys, xs, output_split_sizes=output_splits, input_split_sizes=input_splits) + return ys + + @staticmethod + def backward(ctx, grad_output): + result = torch.empty_like(grad_output) if ctx.input_splits is None else \ + grad_output.new_empty(size=[sum(ctx.input_splits)] + list(grad_output.size()[1:])) + torch.distributed.all_to_all_single(result, grad_output, + output_split_sizes=ctx.input_splits, input_split_sizes=ctx.output_splits) + return result, None, None diff --git a/fairseq/fairseq/modules/beamable_mm.py b/fairseq/fairseq/modules/beamable_mm.py new file mode 100644 index 0000000000000000000000000000000000000000..eff1a4607f600c71210e6b914985dc48731aae86 --- /dev/null +++ b/fairseq/fairseq/modules/beamable_mm.py @@ -0,0 +1,49 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + + +class BeamableMM(nn.Module): + """This module provides an optimized MM for beam decoding with attention. + + It leverage the fact that the source-side of the input is replicated beam + times and the target-side of the input is of width one. This layer speeds up + inference by replacing the inputs {(bsz x 1 x nhu), (bsz x sz2 x nhu)} + with smaller inputs {(bsz/beam x beam x nhu), (bsz/beam x sz2 x nhu)}. + """ + + def __init__(self, beam_size=None): + super(BeamableMM, self).__init__() + self.beam_size = beam_size + + def forward(self, input1, input2): + if ( + not self.training + and self.beam_size is not None # test mode + and input1.dim() == 3 # beam size is set + and input1.size(1) # only support batched input + == 1 # single time step update + ): + bsz, beam = input1.size(0), self.beam_size + + # bsz x 1 x nhu --> bsz/beam x beam x nhu + input1 = input1[:, 0, :].unfold(0, beam, beam).transpose(2, 1) + + # bsz x sz2 x nhu --> bsz/beam x sz2 x nhu + input2 = input2.unfold(0, beam, beam)[:, :, :, 0] + + # use non batched operation if bsz = beam + if input1.size(0) == 1: + output = torch.mm(input1[0, :, :], input2[0, :, :]) + else: + output = input1.bmm(input2) + return output.view(bsz, 1, -1) + else: + return input1.bmm(input2) + + def set_beam_size(self, beam_size): + self.beam_size = beam_size diff --git a/fairseq/fairseq/modules/character_token_embedder.py b/fairseq/fairseq/modules/character_token_embedder.py new file mode 100644 index 0000000000000000000000000000000000000000..181221b61b9f76453b67e3b848b198620dce912c --- /dev/null +++ b/fairseq/fairseq/modules/character_token_embedder.py @@ -0,0 +1,214 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import List, Tuple + +import torch +import torch.nn.functional as F +from fairseq.data import Dictionary +from torch import nn + + +CHAR_PAD_IDX = 0 +CHAR_EOS_IDX = 257 + + +logger = logging.getLogger(__name__) + + +class CharacterTokenEmbedder(torch.nn.Module): + def __init__( + self, + vocab: Dictionary, + filters: List[Tuple[int, int]], + char_embed_dim: int, + word_embed_dim: int, + highway_layers: int, + max_char_len: int = 50, + char_inputs: bool = False, + ): + super(CharacterTokenEmbedder, self).__init__() + + self.onnx_trace = False + self.embedding_dim = word_embed_dim + self.max_char_len = max_char_len + self.char_embeddings = nn.Embedding(257, char_embed_dim, padding_idx=0) + self.symbol_embeddings = nn.Parameter(torch.FloatTensor(2, word_embed_dim)) + self.eos_idx, self.unk_idx = 0, 1 + self.char_inputs = char_inputs + + self.convolutions = nn.ModuleList() + for width, out_c in filters: + self.convolutions.append( + nn.Conv1d(char_embed_dim, out_c, kernel_size=width) + ) + + last_dim = sum(f[1] for f in filters) + + self.highway = Highway(last_dim, highway_layers) if highway_layers > 0 else None + + self.projection = nn.Linear(last_dim, word_embed_dim) + + assert ( + vocab is not None or char_inputs + ), "vocab must be set if not using char inputs" + self.vocab = None + if vocab is not None: + self.set_vocab(vocab, max_char_len) + + self.reset_parameters() + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def set_vocab(self, vocab, max_char_len): + word_to_char = torch.LongTensor(len(vocab), max_char_len) + + truncated = 0 + for i in range(len(vocab)): + if i < vocab.nspecial: + char_idxs = [0] * max_char_len + else: + chars = vocab[i].encode() + # +1 for padding + char_idxs = [c + 1 for c in chars] + [0] * (max_char_len - len(chars)) + if len(char_idxs) > max_char_len: + truncated += 1 + char_idxs = char_idxs[:max_char_len] + word_to_char[i] = torch.LongTensor(char_idxs) + + if truncated > 0: + logger.info( + "truncated {} words longer than {} characters".format( + truncated, max_char_len + ) + ) + + self.vocab = vocab + self.word_to_char = word_to_char + + @property + def padding_idx(self): + return Dictionary().pad() if self.vocab is None else self.vocab.pad() + + def reset_parameters(self): + nn.init.xavier_normal_(self.char_embeddings.weight) + nn.init.xavier_normal_(self.symbol_embeddings) + nn.init.xavier_uniform_(self.projection.weight) + + nn.init.constant_( + self.char_embeddings.weight[self.char_embeddings.padding_idx], 0.0 + ) + nn.init.constant_(self.projection.bias, 0.0) + + def forward( + self, + input: torch.Tensor, + ): + if self.char_inputs: + chars = input.view(-1, self.max_char_len) + pads = chars[:, 0].eq(CHAR_PAD_IDX) + eos = chars[:, 0].eq(CHAR_EOS_IDX) + if eos.any(): + if self.onnx_trace: + chars = torch.where(eos.unsqueeze(1), chars.new_zeros(1), chars) + else: + chars[eos] = 0 + + unk = None + else: + flat_words = input.view(-1) + chars = self.word_to_char[flat_words.type_as(self.word_to_char)].type_as( + input + ) + pads = flat_words.eq(self.vocab.pad()) + eos = flat_words.eq(self.vocab.eos()) + unk = flat_words.eq(self.vocab.unk()) + + word_embs = self._convolve(chars) + if self.onnx_trace: + if pads.any(): + word_embs = torch.where( + pads.unsqueeze(1), word_embs.new_zeros(1), word_embs + ) + if eos.any(): + word_embs = torch.where( + eos.unsqueeze(1), self.symbol_embeddings[self.eos_idx], word_embs + ) + if unk is not None and unk.any(): + word_embs = torch.where( + unk.unsqueeze(1), self.symbol_embeddings[self.unk_idx], word_embs + ) + else: + if pads.any(): + word_embs[pads] = 0 + if eos.any(): + word_embs[eos] = self.symbol_embeddings[self.eos_idx] + if unk is not None and unk.any(): + word_embs[unk] = self.symbol_embeddings[self.unk_idx] + + return word_embs.view(input.size()[:2] + (-1,)) + + def _convolve( + self, + char_idxs: torch.Tensor, + ): + char_embs = self.char_embeddings(char_idxs) + char_embs = char_embs.transpose(1, 2) # BTC -> BCT + + conv_result = [] + + for conv in self.convolutions: + x = conv(char_embs) + x, _ = torch.max(x, -1) + x = F.relu(x) + conv_result.append(x) + + x = torch.cat(conv_result, dim=-1) + + if self.highway is not None: + x = self.highway(x) + x = self.projection(x) + + return x + + +class Highway(torch.nn.Module): + """ + A `Highway layer <https://arxiv.org/abs/1505.00387>`_. + Adopted from the AllenNLP implementation. + """ + + def __init__(self, input_dim: int, num_layers: int = 1): + super(Highway, self).__init__() + self.input_dim = input_dim + self.layers = nn.ModuleList( + [nn.Linear(input_dim, input_dim * 2) for _ in range(num_layers)] + ) + self.activation = nn.ReLU() + + self.reset_parameters() + + def reset_parameters(self): + for layer in self.layers: + # As per comment in AllenNLP: + # We should bias the highway layer to just carry its input forward. We do that by + # setting the bias on `B(x)` to be positive, because that means `g` will be biased to + # be high, so we will carry the input forward. The bias on `B(x)` is the second half + # of the bias vector in each Linear layer. + nn.init.constant_(layer.bias[self.input_dim :], 1) + + nn.init.constant_(layer.bias[: self.input_dim], 0) + nn.init.xavier_normal_(layer.weight) + + def forward(self, x: torch.Tensor): + for layer in self.layers: + projection = layer(x) + proj_x, gate = projection.chunk(2, dim=-1) + proj_x = self.activation(proj_x) + gate = torch.sigmoid(gate) + x = gate * x + (gate.new_tensor([1]) - gate) * proj_x + return x diff --git a/fairseq/fairseq/modules/checkpoint_activations.py b/fairseq/fairseq/modules/checkpoint_activations.py new file mode 100644 index 0000000000000000000000000000000000000000..7489e09eb79b595aef674914556018d7f0a4efbf --- /dev/null +++ b/fairseq/fairseq/modules/checkpoint_activations.py @@ -0,0 +1,236 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import functools +from typing import Any, Dict, List, Tuple, Union + +import torch +import torch.utils.checkpoint as checkpoint +from fairseq import utils + + +def checkpoint_wrapper(m, offload_to_cpu=False): + """ + A friendlier wrapper for performing activation checkpointing. + + Compared to the PyTorch version, this version: + - wraps an nn.Module, so that all subsequent calls will use checkpointing + - handles keyword arguments in the forward + - handles non-Tensor outputs from the forward + + Usage:: + + checkpointed_module = checkpoint_wrapper(my_module, offload_to_cpu=True) + a, b = checkpointed_module(x, y=3, z=torch.Tensor([1])) + """ + # should I check whether original_forward has already been set? + assert not hasattr( + m, "precheckpoint_forward" + ), "checkpoint function has already been applied?" + m.precheckpoint_forward = m.forward + m.forward = functools.partial( + _checkpointed_forward, + m.precheckpoint_forward, # original_forward + offload_to_cpu, + ) + return m + + +def unwrap_checkpoint(m: torch.nn.Module): + """ + unwrap a module and its children from checkpoint_wrapper + """ + for module in m.modules(): + if hasattr(module, "precheckpoint_forward"): + module.forward = module.precheckpoint_forward + del module.precheckpoint_forward + return m + + +def _checkpointed_forward(original_forward, offload_to_cpu, *args, **kwargs): + # Autograd Functions in PyTorch work best with positional args, since + # the backward must return gradients (or None) for every input argument. + # We can flatten keyword arguments to make this easier. + kwarg_keys, flat_args = pack_kwargs(*args, **kwargs) + parent_ctx_dict = {"offload": offload_to_cpu} + output = CheckpointFunction.apply( + original_forward, parent_ctx_dict, kwarg_keys, *flat_args + ) + if isinstance(output, torch.Tensor): + return output + else: + packed_non_tensor_outputs = parent_ctx_dict["packed_non_tensor_outputs"] + if packed_non_tensor_outputs: + output = unpack_non_tensors(output, packed_non_tensor_outputs) + return output + + +def pack_kwargs(*args, **kwargs) -> Tuple[List[str], List[Any]]: + """ + Usage:: + + kwarg_keys, flat_args = pack_kwargs(1, 2, a=3, b=4) + args, kwargs = unpack_kwargs(kwarg_keys, flat_args) + assert args == [1, 2] + assert kwargs == {"a": 3, "b": 4} + """ + kwarg_keys = [] + flat_args = list(args) + for k, v in kwargs.items(): + kwarg_keys.append(k) + flat_args.append(v) + return kwarg_keys, flat_args + + +def unpack_kwargs( + kwarg_keys: List[str], flat_args: List[Any] +) -> Tuple[List[Any], Dict[str, Any]]: + if len(kwarg_keys) == 0: + return flat_args, {} + args = flat_args[: -len(kwarg_keys)] + kwargs = {k: v for k, v in zip(kwarg_keys, flat_args[-len(kwarg_keys) :])} + return args, kwargs + + +def split_non_tensors( + mixed: Union[torch.Tensor, Tuple[Any]] +) -> Tuple[Tuple[torch.Tensor], Dict[str, List[Any]]]: + """ + Usage:: + + x = torch.Tensor([1]) + y = torch.Tensor([2]) + tensors, packed_non_tensors = split_non_tensors((x, y, None, 3)) + recon = unpack_non_tensors(tensors, packed_non_tensors) + assert recon == (x, y, None, 3) + """ + if isinstance(mixed, torch.Tensor): + return (mixed,), None + tensors = [] + packed_non_tensors = {"is_tensor": [], "objects": []} + for o in mixed: + if isinstance(o, torch.Tensor): + packed_non_tensors["is_tensor"].append(True) + tensors.append(o) + else: + packed_non_tensors["is_tensor"].append(False) + packed_non_tensors["objects"].append(o) + return tuple(tensors), packed_non_tensors + + +def unpack_non_tensors( + tensors: Tuple[torch.Tensor], + packed_non_tensors: Dict[str, List[Any]], +) -> Tuple[Any]: + if packed_non_tensors is None: + return tensors + assert isinstance(packed_non_tensors, dict) + mixed = [] + is_tensor_list = packed_non_tensors["is_tensor"] + objects = packed_non_tensors["objects"] + assert len(tensors) + len(objects) == len(is_tensor_list) + obj_i = tnsr_i = 0 + for is_tensor in is_tensor_list: + if is_tensor: + mixed.append(tensors[tnsr_i]) + tnsr_i += 1 + else: + mixed.append(objects[obj_i]) + obj_i += 1 + return tuple(mixed) + + +class CheckpointFunction(torch.autograd.Function): + """Similar to the torch version, but support non-Tensor outputs. + + The caller is expected to provide a dict (*parent_ctx_dict*) that will hold + the non-Tensor outputs. These should be combined with the Tensor *outputs* + by calling ``unpack_non_tensors``. + """ + + @staticmethod + def forward(ctx, run_function, parent_ctx_dict, kwarg_keys, *args): + if torch.is_grad_enabled(): # grad may be disabled, e.g., during validation + checkpoint.check_backward_validity(args) + + ctx.run_function = run_function + ctx.kwarg_keys = kwarg_keys + ctx.fwd_rng_state = utils.get_rng_state() + + tensor_inputs, packed_non_tensor_inputs = split_non_tensors(args) + if parent_ctx_dict["offload"]: + ctx.fwd_device = tuple(x.device for x in tensor_inputs) + ctx.grad_requirements = tuple(x.requires_grad for x in tensor_inputs) + tensor_inputs = tuple(x.to(torch.device("cpu"), non_blocking=True) for x in tensor_inputs) + + else: + ctx.fwd_device, ctx.grad_requirements = None, None + + ctx.save_for_backward(*tensor_inputs) + ctx.packed_non_tensor_inputs = packed_non_tensor_inputs + + with torch.no_grad(): + unpacked_args, unpacked_kwargs = unpack_kwargs(kwarg_keys, args) + outputs = run_function(*unpacked_args, **unpacked_kwargs) + + if isinstance(outputs, torch.Tensor): + return outputs + else: + # Autograd Functions don't like non-Tensor outputs. We can split the + # non-Tensor and Tensor outputs, returning the former by reference + # through *parent_ctx_dict* and returning the latter directly. + outputs, packed_non_tensor_outputs = split_non_tensors(outputs) + parent_ctx_dict["packed_non_tensor_outputs"] = packed_non_tensor_outputs + return outputs + + @staticmethod + def backward(ctx, *args): + if not torch.autograd._is_checkpoint_valid(): + raise RuntimeError( + "Checkpointing is not compatible with .grad(), please use .backward() if possible" + ) + + tensor_inputs: Tuple = ctx.saved_tensors + tensor_inputs = checkpoint.detach_variable(tensor_inputs) + if ctx.fwd_device is not None: + tensor_inputs = [ + t.to(ctx.fwd_device[i], non_blocking=True) for i, t in enumerate(tensor_inputs) + ] + for i, need_grad in enumerate(ctx.grad_requirements): + tensor_inputs[i].requires_grad = need_grad + inputs = unpack_non_tensors(tensor_inputs, ctx.packed_non_tensor_inputs) + + # Store the current states. + bwd_rng_state = utils.get_rng_state() + + # Set the states to what it used to be before the forward pass. + utils.set_rng_state(ctx.fwd_rng_state) + + with torch.enable_grad(): + unpacked_args, unpacked_kwargs = unpack_kwargs(ctx.kwarg_keys, inputs) + outputs = ctx.run_function(*unpacked_args, **unpacked_kwargs) + tensor_outputs, _ = split_non_tensors(outputs) + # Set the states back to what it was at the start of this function. + utils.set_rng_state(bwd_rng_state) + + # Run backward() with only Tensors that require grad + outputs_with_grad = [] + args_with_grad = [] + for i in range(len(tensor_outputs)): + if tensor_outputs[i].requires_grad: + outputs_with_grad.append(tensor_outputs[i]) + args_with_grad.append(args[i]) + if len(outputs_with_grad) == 0: + raise RuntimeError( + "None of the outputs have requires_grad=True, " + "this checkpoint() is not necessary" + ) + + torch.autograd.backward(outputs_with_grad, args_with_grad) + + grads = tuple( + inp.grad if isinstance(inp, torch.Tensor) else None for inp in inputs + ) + return (None, None, None) + grads diff --git a/fairseq/fairseq/modules/conv_tbc.py b/fairseq/fairseq/modules/conv_tbc.py new file mode 100644 index 0000000000000000000000000000000000000000..65e17ec94f7e595cb657b3d2daaa1052a95d0677 --- /dev/null +++ b/fairseq/fairseq/modules/conv_tbc.py @@ -0,0 +1,53 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from torch import nn +from torch.nn.modules.utils import _single +from torch import Tensor + + +class ConvTBC(torch.nn.Module): + """1D convolution over an input of shape (time x batch x channel) + + The implementation uses gemm to perform the convolution. This implementation + is faster than cuDNN for small kernel sizes. + """ + + def __init__(self, in_channels, out_channels, kernel_size, padding=0): + super(ConvTBC, self).__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.kernel_size = _single(kernel_size) + self.padding = _single(padding) + + self.weight = torch.nn.Parameter( + torch.Tensor(self.kernel_size[0], in_channels, out_channels) + ) + self.bias = torch.nn.Parameter(torch.Tensor(out_channels)) + + self.reset_parameters() + + def reset_parameters(self): + nn.init.xavier_normal_(self.weight) + nn.init.zeros_(self.bias) + + def conv_tbc(self, input: Tensor): + return torch.conv_tbc( + input.contiguous(), self.weight, self.bias, self.padding[0] + ) + + def forward(self, input: Tensor): + return self.conv_tbc(input) + + def __repr__(self): + s = ( + "{name}({in_channels}, {out_channels}, kernel_size={kernel_size}" + ", padding={padding}" + ) + if self.bias is None: + s += ", bias=False" + s += ")" + return s.format(name=self.__class__.__name__, **self.__dict__) diff --git a/fairseq/fairseq/modules/cross_entropy.py b/fairseq/fairseq/modules/cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..6f33c24cb56e25f91595009af38e63784c2263a0 --- /dev/null +++ b/fairseq/fairseq/modules/cross_entropy.py @@ -0,0 +1,61 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +import torch.nn.functional as F + + +logger = logging.getLogger(__name__) + + +def _cross_entropy_pytorch(logits, target, ignore_index=None, reduction="mean"): + lprobs = F.log_softmax(logits, dim=-1, dtype=torch.float32) + return F.nll_loss( + lprobs, + target, + ignore_index=ignore_index, + reduction=reduction, + ) + + +try: + import xentropy_cuda + from apex.contrib import xentropy + + def cross_entropy(logits, target, ignore_index=-100, reduction="mean"): + if logits.device == torch.device("cpu"): + return _cross_entropy_pytorch(logits, target, ignore_index, reduction) + else: + if not getattr(cross_entropy, "_has_logged_once", False): + logger.info("using fused cross entropy") + cross_entropy._has_logged_once = True + + half_to_float = logits.dtype == torch.half + losses = xentropy.SoftmaxCrossEntropyLoss.apply( + logits, + target, + 0.0, + ignore_index, + half_to_float, + ) + if reduction == "sum": + return losses.sum() + elif reduction == "mean": + if ignore_index >= 0: + return losses.sum() / target.ne(ignore_index).sum() + else: + return losses.mean() + elif reduction == "none": + return losses + else: + raise NotImplementedError + + +except ImportError: + + def cross_entropy(logits, target, ignore_index=-100, reduction="mean"): + return _cross_entropy_pytorch(logits, target, ignore_index, reduction) diff --git a/fairseq/fairseq/modules/cuda_utils.cu b/fairseq/fairseq/modules/cuda_utils.cu new file mode 100644 index 0000000000000000000000000000000000000000..924f852758ee654e462546274db4b5e7199a9c90 --- /dev/null +++ b/fairseq/fairseq/modules/cuda_utils.cu @@ -0,0 +1,202 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +template <typename U, typename V> +constexpr __host__ __device__ auto divUp(U a, V b) -> decltype(a + b) { + return (a + b - 1) / b; +} + +template <int FS, int SB, int padding_l, typename scalar_t> +__inline__ __device__ void zeroSharedMem(scalar_t* data) { + /* + Given an array of length FS + SB, zero out the first padding_l and last + (FS - padding_l) values in the array + */ + + int tid = threadIdx.x; + + if (FS < SB) { + // zero all if we have enough threads in a block to do all of them + if (tid < padding_l || tid > SB - FS + padding_l - 1) { + data[tid] = scalar_t(0.0); + } + } else { + // otherwise zero out one block at a time + const int numIterations = divUp<int, int>(FS, SB); + for (int i = 0; i < numIterations; i++) { + int offset = i * SB; + if (tid + offset < padding_l) { + data[tid + offset] = scalar_t(0.0); + } else if (tid + offset < FS) { + data[SB + tid + offset] = scalar_t(0.0); + } + } + } +} + +template <typename scalar_t> +__inline__ __device__ scalar_t warpReduce(scalar_t data) { + /* + Reduce an array within each warp. After processing all values in warp will + caontain the sum of all original values in that warp. + + data - pointer to data to reduce + */ + data += __shfl_xor_sync(SHFL_MASK, data, 16); + data += __shfl_xor_sync(SHFL_MASK, data, 8); + data += __shfl_xor_sync(SHFL_MASK, data, 4); + data += __shfl_xor_sync(SHFL_MASK, data, 2); + data += __shfl_xor_sync(SHFL_MASK, data, 1); + return data; +} + +template <typename scalar_t> +__inline__ __device__ scalar_t blockReduce(scalar_t data) { + /* + Reduce an entire array on the block level. After processing, the + first value in the array will contain the reduced sum. + + data - pointer to data to reduce + */ + + static __shared__ scalar_t warpSum[32]; + const int tid = threadIdx.x; + int wid = tid / 32; + int lane = tid % 32; + + __syncthreads(); + + // reduce each warp then write to shared memory + scalar_t sum = warpReduce(data); + if (lane == 0) { + warpSum[wid] = sum; + } + + __syncthreads(); + + scalar_t v; + // perform final sum of partial warp sums + if (tid < blockDim.x / 32) { + v = warpSum[lane]; + } else { + v = scalar_t(0.0); + } + + if (wid == 0) { + v = warpReduce(v); + } + __syncthreads(); + + return v; +} + +void checkCudaStatus(cudaError_t status, int lineNumber = -1) { + if (status != cudaSuccess) { + std::cout << cudaGetErrorString(status) << " at line " << lineNumber + << std::endl; + std::cout << "Exiting" << std::endl; + exit(1); + } +} + +template <int FS, int SB, int padding_l, typename scalar_t> +__device__ void load_input_to_shared( + const scalar_t* input, // global memory + int inputOffset, + int sequenceLength, + int iteration, + int numIterations, + bool no_prev, + scalar_t* output /* shared memory */) { + /* + Load a block size of input into shared memory with + right and left overhang of total size FS. If previously + loaded memory, overlap will be shifted over to reduce + global memory access + + input - pointer to start of channel sequence + inputOffset - how far in the sequence to start loading + sequenceLength - total length of sequence + iteration - which block of sequence we are loading + numIterations - total number of blocks to load + no_prev - whether to load the whole block if the previous block + wasn't loaded + output - shared memory to write input to + */ + + const int tid = threadIdx.x; + + // Load the left "overhang" of input + if (iteration > 0) { + if (padding_l < SB) { + // load all at once + if (tid < padding_l) { + output[tid] = + (no_prev) ? input[inputOffset - padding_l + tid] : output[tid + SB]; + } + } else { + // load in chunks of size SB + int numIterations = divUp<int, int>(padding_l, SB); + for (int i = 0; i < numIterations; i++) { + int offset = i * SB; + if ((tid + offset) < padding_l) { + output[tid + offset] = (no_prev) + ? input[inputOffset - padding_l + tid + offset] + : output[tid + offset + SB]; + } + } + } + } + + // Load the right "overhang" of input + if (iteration < (numIterations - 1)) { + const int elementsLeft = sequenceLength - (iteration + 1) * SB; + + if ((FS - padding_l) < SB) { + // load all at once + if (tid < (FS - padding_l)) { + output[padding_l + SB + tid] = (tid < elementsLeft) + ? input[inputOffset + SB + tid] + : scalar_t(0.0); + } + } else { + // load in chunks of size SB + int numIterations = divUp<int, int>(FS - padding_l, SB); + for (int i = 0; i < numIterations; i++) { + int offset = i * SB; + if ((tid + offset) < (FS - padding_l)) { + output[padding_l + SB + tid + offset] = + ((tid + offset) < elementsLeft) + ? input[inputOffset + SB + tid + offset] + : scalar_t(0.0); + } + } + } + } + + // We should also clear out the right "overhang" + if (iteration == (numIterations - 1)) { + if ((FS - padding_l) < SB) { + // clear out all at once + if (tid < (FS - padding_l)) { + output[padding_l + SB + tid] = scalar_t(0.0); + } + } else { + // clear in chunks of size SB + int numIterations = divUp<int, int>(FS - padding_l, SB); + for (int i = 0; i < numIterations; i++) { + int offset = i * SB; + if ((tid + offset) < (FS - padding_l)) { + output[padding_l + SB + tid + offset] = scalar_t(0.0); + } + } + } + } + output[tid + padding_l] = ((inputOffset + tid) < sequenceLength) + ? input[inputOffset + tid] + : scalar_t(0.0); +} diff --git a/fairseq/fairseq/modules/downsampled_multihead_attention.py b/fairseq/fairseq/modules/downsampled_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..2cdece3f7fca2b830eb72999ce93f58667ed595b --- /dev/null +++ b/fairseq/fairseq/modules/downsampled_multihead_attention.py @@ -0,0 +1,316 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +# + +import math + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.scalar_bias import scalar_bias + + +class SingleHeadAttention(nn.Module): + """ + Single-head attention that supports Gating and Downsampling + """ + + def __init__( + self, + out_channels, + embed_dim, + head_dim, + head_index, + dropout=0.0, + bias=True, + project_input=True, + gated=False, + downsample=False, + num_heads=1, + ): + super().__init__() + self.embed_dim = embed_dim + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.head_index = head_index + self.head_dim = head_dim + self.project_input = project_input + self.gated = gated + self.downsample = downsample + self.num_heads = num_heads + self.projection = None + + k_layers = [] + v_layers = [] + if self.downsample: + k_layers.append(Downsample(self.head_index)) + v_layers.append(Downsample(self.head_index)) + out_proj_size = self.head_dim + else: + out_proj_size = self.head_dim * self.num_heads + if self.gated: + k_layers.append(GatedLinear(self.embed_dim, out_proj_size, bias=bias)) + self.in_proj_q = GatedLinear(self.embed_dim, out_proj_size, bias=bias) + v_layers.append(GatedLinear(self.embed_dim, out_proj_size, bias=bias)) + else: + k_layers.append(Linear(self.embed_dim, out_proj_size, bias=bias)) + self.in_proj_q = Linear(self.embed_dim, out_proj_size, bias=bias) + v_layers.append(Linear(self.embed_dim, out_proj_size, bias=bias)) + + self.in_proj_k = nn.Sequential(*k_layers) + self.in_proj_v = nn.Sequential(*v_layers) + + if self.downsample: + self.out_proj = Linear(out_proj_size, self.head_dim, bias=bias) + else: + self.out_proj = Linear(out_proj_size, out_channels, bias=bias) + + self.scaling = self.head_dim ** -0.5 + + def forward( + self, + query, + key, + value, + mask_future_timesteps=False, + key_padding_mask=None, + use_scalar_bias=False, + ): + """Input shape: Time x Batch x Channel + Self-attention can be implemented by passing in the same arguments for + query, key and value. Future timesteps can be masked with the + `mask_future_timesteps` argument. Padding elements can be excluded from + the key by passing a binary ByteTensor (`key_padding_mask`) with shape: + batch x src_len, where padding elements are indicated by 1s. + """ + src_len, bsz, out_channels = key.size() + tgt_len = query.size(0) + assert list(query.size()) == [tgt_len, bsz, out_channels] + assert key.size() == value.size() + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if self.downsample: + size = bsz + else: + size = bsz * self.num_heads + + k = key + v = value + q = query + if self.project_input: + q = self.in_proj_q(q) + k = self.in_proj_k(k) + v = self.in_proj_v(v) + src_len = k.size()[0] + q *= self.scaling + + if not self.downsample: + q = q.view(tgt_len, size, self.head_dim) + k = k.view(src_len, size, self.head_dim) + v = v.view(src_len, size, self.head_dim) + + q = q.transpose(0, 1) + k = k.transpose(0, 1) + v = v.transpose(0, 1) + + attn_weights = torch.bmm(q, k.transpose(1, 2)) + if mask_future_timesteps: + assert ( + query.size() == key.size() + ), "mask_future_timesteps only applies to self-attention" + attn_weights *= torch.tril( + attn_weights.data.new([1]).expand(tgt_len, tgt_len).clone(), + diagonal=-1, + )[:, :: self.head_index + 1 if self.downsample else 1].unsqueeze(0) + attn_weights += torch.triu( + attn_weights.data.new([-math.inf]).expand(tgt_len, tgt_len).clone(), + diagonal=0, + )[:, :: self.head_index + 1 if self.downsample else 1].unsqueeze(0) + tgt_size = tgt_len + if use_scalar_bias: + attn_weights = scalar_bias(attn_weights, 2) + v = scalar_bias(v, 1) + tgt_size += 1 + + if key_padding_mask is not None: + # don't attend to padding symbols + if key_padding_mask.max() > 0: + if self.downsample: + attn_weights = attn_weights.view(bsz, 1, tgt_len, src_len) + else: + attn_weights = attn_weights.view( + size, self.num_heads, tgt_len, src_len + ) + attn_weights = attn_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), + -math.inf, + ) + attn_weights = attn_weights.view(size, tgt_len, src_len) + attn_weights = F.softmax(attn_weights, dim=-1) + attn_weights = self.dropout_module(attn_weights) + + attn = torch.bmm(attn_weights, v) + if self.downsample: + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, self.head_dim) + else: + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, self.embed_dim) + + attn = self.out_proj(attn) + + return attn, attn_weights + + +class DownsampledMultiHeadAttention(nn.ModuleList): + """ + Multi-headed attention with Gating and Downsampling + """ + + def __init__( + self, + out_channels, + embed_dim, + num_heads, + dropout=0.0, + bias=True, + project_input=True, + gated=False, + downsample=False, + ): + self.embed_dim = embed_dim + self.num_heads = num_heads + self.head_dim = embed_dim // num_heads + self.downsample = downsample + self.gated = gated + self.project_input = project_input + assert self.head_dim * num_heads == embed_dim + + if self.downsample: + attention_heads = [] + for index in range(self.num_heads): + attention_heads.append( + SingleHeadAttention( + out_channels, + self.embed_dim, + self.head_dim, + index, + dropout, + bias, + self.project_input, + self.gated, + self.downsample, + self.num_heads, + ) + ) + super().__init__(modules=attention_heads) + self.out_proj = Linear(embed_dim, out_channels, bias=bias) + else: + # either we have a list of attention heads, or just one attention head + # if not being downsampled, we can do the heads with one linear layer instead of separate ones + super().__init__() + self.attention_module = SingleHeadAttention( + out_channels, + self.embed_dim, + self.head_dim, + 1, + dropout, + bias, + self.project_input, + self.gated, + self.downsample, + self.num_heads, + ) + + def forward( + self, + query, + key, + value, + mask_future_timesteps=False, + key_padding_mask=None, + use_scalar_bias=False, + ): + src_len, bsz, embed_dim = key.size() + tgt_len = query.size(0) + assert embed_dim == self.embed_dim + assert list(query.size()) == [tgt_len, bsz, embed_dim] + assert key.size() == value.size() + + tgt_size = tgt_len + if use_scalar_bias: + tgt_size += 1 + + attn = [] + attn_weights = [] + if self.downsample: + for attention_head_number in range(self.num_heads): + # call the forward of each attention head + _attn, _attn_weight = self[attention_head_number]( + query, + key, + value, + mask_future_timesteps, + key_padding_mask, + use_scalar_bias, + ) + attn.append(_attn) + attn_weights.append(_attn_weight) + full_attn = torch.cat(attn, dim=2) + full_attn = self.out_proj(full_attn) + return full_attn, attn_weights[0].clone() + else: + _attn, _attn_weight = self.attention_module( + query, + key, + value, + mask_future_timesteps, + key_padding_mask, + use_scalar_bias, + ) + attn.append(_attn) + attn_weights.append(_attn_weight) + full_attn = torch.cat(attn, dim=2) + full_attn_weights = torch.cat(attn_weights) + full_attn_weights = full_attn_weights.view( + bsz, self.num_heads, tgt_size, src_len + ) + full_attn_weights = full_attn_weights.sum(dim=1) / self.num_heads + return full_attn, full_attn_weights + + +class Downsample(nn.Module): + """ + Selects every nth element, where n is the index + """ + + def __init__(self, index): + super().__init__() + self.index = index + + def forward(self, x): + return x[:: self.index + 1] + + +def Linear(in_features, out_features, dropout=0.0, bias=True): + """Weight-normalized Linear layer (input: B x T x C)""" + m = nn.Linear(in_features, out_features, bias=bias) + m.weight.data.normal_(mean=0, std=math.sqrt((1 - dropout) / in_features)) + m.bias.data.zero_() + return nn.utils.weight_norm(m) + + +def GatedLinear(in_features, out_features, dropout=0.0, bias=True): + """Weight-normalized Linear layer (input: B x T x C) with interspersed GLU units""" + return nn.Sequential( + Linear(in_features, out_features * 4, dropout, bias), + nn.GLU(), + Linear(out_features * 2, out_features * 2, dropout, bias), + nn.GLU(), + Linear(out_features, out_features, dropout, bias), + ) diff --git a/fairseq/fairseq/modules/dynamic_convolution.py b/fairseq/fairseq/modules/dynamic_convolution.py new file mode 100644 index 0000000000000000000000000000000000000000..0121d453b9e026f5128dd41fce691aa1b4486448 --- /dev/null +++ b/fairseq/fairseq/modules/dynamic_convolution.py @@ -0,0 +1,310 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout + +from .unfold import unfold1d + + +def DynamicConv( + input_size, + kernel_size=1, + padding_l=None, + num_heads=1, + weight_dropout=0.0, + weight_softmax=False, + renorm_padding=False, + bias=False, + conv_bias=False, + query_size=None, + in_proj=False, +): + if torch.cuda.is_available(): + try: + from fairseq.modules.dynamicconv_layer import DynamicconvLayer + + return DynamicconvLayer( + input_size, + kernel_size=kernel_size, + padding_l=padding_l, + num_heads=num_heads, + weight_dropout=weight_dropout, + weight_softmax=weight_softmax, + renorm_padding=renorm_padding, + bias=bias, + conv_bias=conv_bias, + query_size=query_size, + ) + except ImportError as e: + print(e) + return DynamicConv1dTBC( + input_size, + kernel_size=kernel_size, + padding_l=padding_l, + num_heads=num_heads, + weight_dropout=weight_dropout, + weight_softmax=weight_softmax, + renorm_padding=renorm_padding, + bias=bias, + conv_bias=conv_bias, + query_size=query_size, + ) + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m + + +@with_incremental_state +class DynamicConv1dTBC(nn.Module): + """Dynamic lightweight convolution taking T x B x C inputs + Args: + input_size: # of channels of the input + kernel_size: convolution channels + padding_l: padding to the left when using "same" padding + num_heads: number of heads used. The weight is of shape (num_heads, 1, kernel_size) + weight_dropout: the drop rate of the DropConnect to drop the weight + weight_softmax: normalize the weight with softmax before the convolution + renorm_padding: re-normalize the filters to ignore the padded part (only the non-padding parts sum up to 1) + bias: use bias + conv_bias: bias of the convolution + query_size: specified when feeding a different input as the query + in_proj: project the input and generate the filter together + + Shape: + Input: TxBxC, i.e. (timesteps, batch_size, input_size) + Output: TxBxC, i.e. (timesteps, batch_size, input_size) + + Attributes: + weight: the learnable weights of the module of shape + `(num_heads, 1, kernel_size)` + bias: the learnable bias of the module of shape `(input_size)` + """ + + def __init__( + self, + input_size, + kernel_size=1, + padding_l=None, + num_heads=1, + weight_dropout=0.0, + weight_softmax=False, + renorm_padding=False, + bias=False, + conv_bias=False, + query_size=None, + in_proj=False, + ): + super().__init__() + self.input_size = input_size + self.query_size = input_size if query_size is None else query_size + self.kernel_size = kernel_size + self.padding_l = padding_l + self.num_heads = num_heads + self.weight_dropout_module = FairseqDropout( + weight_dropout, module_name=self.__class__.__name__ + ) + self.weight_softmax = weight_softmax + self.renorm_padding = renorm_padding + + if in_proj: + self.weight_linear = Linear( + self.input_size, self.input_size + num_heads * kernel_size * 1 + ) + else: + self.weight_linear = Linear( + self.query_size, num_heads * kernel_size * 1, bias=bias + ) + if conv_bias: + self.conv_bias = nn.Parameter(torch.Tensor(input_size)) + else: + self.conv_bias = None + self.reset_parameters() + + @property + def in_proj(self): + return ( + self.weight_linear.out_features + == self.input_size + self.num_heads * self.kernel_size + ) + + def reset_parameters(self): + self.weight_linear.reset_parameters() + if self.conv_bias is not None: + nn.init.constant_(self.conv_bias, 0.0) + + def forward(self, x, incremental_state=None, query=None, unfold=None): + """Assuming the input, x, of the shape T x B x C and producing an output in the shape T x B x C + args: + x: Input of shape T x B x C, i.e. (timesteps, batch_size, input_size) + incremental_state: A dict to keep the state + unfold: unfold the input or not. If not, we use the matrix trick instead + query: use the specified query to predict the conv filters + """ + unfold = ( + x.size(0) > 512 if unfold is None else unfold + ) # use unfold mode as default for long sequence to save memory + unfold = unfold or (incremental_state is not None) + assert query is None or not self.in_proj + + if query is None: + query = x + if unfold: + output = self._forward_unfolded(x, incremental_state, query) + else: + output = self._forward_expanded(x, incremental_state, query) + + if self.conv_bias is not None: + output = output + self.conv_bias.view(1, 1, -1) + return output + + def _forward_unfolded(self, x, incremental_state, query): + """The conventional implementation of convolutions. + Unfolding the input by having a window shifting to the right.""" + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + + if self.in_proj: + proj = self.weight_linear(x) + x = proj.narrow(2, 0, self.input_size).contiguous() + weight = ( + proj.narrow(2, self.input_size, H * K).contiguous().view(T * B * H, -1) + ) + else: + weight = self.weight_linear(query).view(T * B * H, -1) + + # renorm_padding is only implemented in _forward_expanded + assert not self.renorm_padding or incremental_state is not None + + if incremental_state is not None: + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is None: + input_buffer = x.new() + x_unfold = torch.cat([input_buffer, x.unsqueeze(3)], dim=3) + if self.kernel_size > 1: + self._set_input_buffer( + incremental_state, x_unfold[:, :, :, -self.kernel_size + 1 :] + ) + x_unfold = x_unfold.view(T * B * H, R, -1) + else: + padding_l = self.padding_l + if K > T and padding_l == K - 1: + weight = weight.narrow(1, K - T, T) + K, padding_l = T, T - 1 + # unfold the input: T x B x C --> T' x B x C x K + x_unfold = unfold1d(x, K, padding_l, 0) + x_unfold = x_unfold.view(T * B * H, R, K) + + if self.weight_softmax and not self.renorm_padding: + weight = F.softmax(weight, dim=1) + weight = weight.narrow(1, 0, K) + + if incremental_state is not None: + weight = weight[:, -x_unfold.size(2) :] + K = weight.size(1) + + if self.weight_softmax and self.renorm_padding: + weight = F.softmax(weight, dim=1) + + weight = self.weight_dropout_module(weight, inplace=False) + + output = torch.bmm(x_unfold, weight.unsqueeze(2)) # T*B*H x R x 1 + output = output.view(T, B, C) + return output + + def _forward_expanded(self, x, incremental_stat, query): + """Turn the convolution filters into band matrices and do matrix multiplication. + This is faster when the sequence is short, but less memory efficient. + This is not used in the decoder during inference. + """ + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + if self.in_proj: + proj = self.weight_linear(x) + x = proj.narrow(2, 0, self.input_size).contiguous() + weight = ( + proj.narrow(2, self.input_size, H * K).contiguous().view(T * B * H, -1) + ) + else: + weight = self.weight_linear(query).view(T * B * H, -1) + + if not self.renorm_padding: + if self.weight_softmax: + weight = F.softmax(weight, dim=1) + weight = self.weight_dropout_module(weight, inplace=False) + weight = weight.narrow(1, 0, K).contiguous() + weight = weight.view(T, B * H, K).transpose(0, 1) + + x = x.view(T, B * H, R).transpose(0, 1) + if self.weight_softmax and self.renorm_padding: + # turn the convolution filters into band matrices + weight_expanded = weight.new(B * H, T, T + K - 1).fill_(float("-inf")) + weight_expanded.as_strided( + (B * H, T, K), (T * (T + K - 1), T + K, 1) + ).copy_(weight) + weight_expanded = weight_expanded.narrow(2, self.padding_l, T) + # normalize the weight over valid positions like self-attention + weight_expanded = F.softmax(weight_expanded, dim=2) + weight_expanded = self.weight_dropout_module(weight_expanded, inplace=False) + else: + P = self.padding_l + # For efficiency, we cut the kernel size and reduce the padding when the kernel is larger than the length + if K > T and P == K - 1: + weight = weight.narrow(2, K - T, T) + K, P = T, T - 1 + # turn the convolution filters into band matrices + weight_expanded = weight.new_zeros(B * H, T, T + K - 1, requires_grad=False) + weight_expanded.as_strided( + (B * H, T, K), (T * (T + K - 1), T + K, 1) + ).copy_(weight) + weight_expanded = weight_expanded.narrow(2, P, T) # B*H x T x T + output = torch.bmm(weight_expanded, x) + output = output.transpose(0, 1).contiguous().view(T, B, C) + return output + + def reorder_incremental_state(self, incremental_state, new_order): + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + input_buffer = input_buffer.index_select(1, new_order) + self._set_input_buffer(incremental_state, input_buffer) + + def _get_input_buffer(self, incremental_state): + return utils.get_incremental_state(self, incremental_state, "input_buffer") + + def _set_input_buffer(self, incremental_state, new_buffer): + return utils.set_incremental_state( + self, incremental_state, "input_buffer", new_buffer + ) + + def extra_repr(self): + s = "{}, kernel_size={}, padding_l={}, num_heads={}, weight_softmax={}, conv_bias={}, renorm_padding={}, in_proj={}".format( + self.input_size, + self.kernel_size, + self.padding_l, + self.num_heads, + self.weight_softmax, + self.conv_bias is not None, + self.renorm_padding, + self.in_proj, + ) + + if self.query_size != self.input_size: + s += ", query_size={}".format(self.query_size) + if self.weight_dropout_module.p > 0.0: + s += ", weight_dropout={}".format(self.weight_dropout_module.p) + return s diff --git a/fairseq/fairseq/modules/dynamic_crf_layer.py b/fairseq/fairseq/modules/dynamic_crf_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..8fcc6b8d2672d2eacc6d01b9688bac44d5e1ce26 --- /dev/null +++ b/fairseq/fairseq/modules/dynamic_crf_layer.py @@ -0,0 +1,189 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +This file is to re-implemented the low-rank and beam approximation of CRF layer +Proposed by: + +Sun, Zhiqing, et al. +Fast Structured Decoding for Sequence Models +https://arxiv.org/abs/1910.11555 + +The CRF implementation is mainly borrowed from +https://github.com/kmkurn/pytorch-crf/blob/master/torchcrf/__init__.py + +""" + +import numpy as np +import torch +import torch.nn as nn + + +def logsumexp(x, dim=1): + return torch.logsumexp(x.float(), dim=dim).type_as(x) + + +class DynamicCRF(nn.Module): + """Dynamic CRF layer is used to approximate the traditional + Conditional Random Fields (CRF) + $P(y | x) = 1/Z(x) exp(sum_i s(y_i, x) + sum_i t(y_{i-1}, y_i, x))$ + + where in this function, we assume the emition scores (s) are given, + and the transition score is a |V| x |V| matrix $M$ + + in the following two aspects: + (1) it used a low-rank approximation for the transition matrix: + $M = E_1 E_2^T$ + (2) it used a beam to estimate the normalizing factor Z(x) + """ + + def __init__(self, num_embedding, low_rank=32, beam_size=64): + super().__init__() + + self.E1 = nn.Embedding(num_embedding, low_rank) + self.E2 = nn.Embedding(num_embedding, low_rank) + + self.vocb = num_embedding + self.rank = low_rank + self.beam = beam_size + + def extra_repr(self): + return "vocab_size={}, low_rank={}, beam_size={}".format( + self.vocb, self.rank, self.beam + ) + + def forward(self, emissions, targets, masks, beam=None): + """ + Compute the conditional log-likelihood of a sequence of target tokens given emission scores + + Args: + emissions (`~torch.Tensor`): Emission score are usually the unnormalized decoder output + ``(batch_size, seq_len, vocab_size)``. We assume batch-first + targets (`~torch.LongTensor`): Sequence of target token indices + ``(batch_size, seq_len) + masks (`~torch.ByteTensor`): Mask tensor with the same size as targets + + Returns: + `~torch.Tensor`: approximated log-likelihood + """ + numerator = self._compute_score(emissions, targets, masks) + denominator = self._compute_normalizer(emissions, targets, masks, beam) + return numerator - denominator + + def forward_decoder(self, emissions, masks=None, beam=None): + """ + Find the most likely output sequence using Viterbi algorithm. + + Args: + emissions (`~torch.Tensor`): Emission score are usually the unnormalized decoder output + ``(batch_size, seq_len, vocab_size)``. We assume batch-first + masks (`~torch.ByteTensor`): Mask tensor with the same size as targets + + Returns: + `~torch.LongTensor`: decoded sequence from the CRF model + """ + return self._viterbi_decode(emissions, masks, beam) + + def _compute_score(self, emissions, targets, masks=None): + batch_size, seq_len = targets.size() + emission_scores = emissions.gather(2, targets[:, :, None])[:, :, 0] # B x T + transition_scores = (self.E1(targets[:, :-1]) * self.E2(targets[:, 1:])).sum(2) + + scores = emission_scores + scores[:, 1:] += transition_scores + + if masks is not None: + scores = scores * masks.type_as(scores) + return scores.sum(-1) + + def _compute_normalizer(self, emissions, targets=None, masks=None, beam=None): + # HACK: we include "target" which is a hueristic for training + # HACK: we use a beam of tokens to approximate the normalizing factor (which is bad?) + + beam = beam if beam is not None else self.beam + batch_size, seq_len = emissions.size()[:2] + if targets is not None: + _emissions = emissions.scatter(2, targets[:, :, None], np.float("inf")) + beam_targets = _emissions.topk(beam, 2)[1] + beam_emission_scores = emissions.gather(2, beam_targets) + else: + beam_emission_scores, beam_targets = emissions.topk(beam, 2) + beam_transition_score1 = self.E1(beam_targets[:, :-1]) # B x (T-1) x K x D + beam_transition_score2 = self.E2(beam_targets[:, 1:]) # B x (T-1) x K x D + beam_transition_matrix = torch.bmm( + beam_transition_score1.view(-1, beam, self.rank), + beam_transition_score2.view(-1, beam, self.rank).transpose(1, 2), + ) + beam_transition_matrix = beam_transition_matrix.view(batch_size, -1, beam, beam) + + # compute the normalizer in the log-space + score = beam_emission_scores[:, 0] # B x K + for i in range(1, seq_len): + next_score = score[:, :, None] + beam_transition_matrix[:, i - 1] + next_score = logsumexp(next_score, dim=1) + beam_emission_scores[:, i] + + if masks is not None: + score = torch.where(masks[:, i : i + 1], next_score, score) + else: + score = next_score + + # Sum (log-sum-exp) over all possible tags + return logsumexp(score, dim=1) + + def _viterbi_decode(self, emissions, masks=None, beam=None): + # HACK: we use a beam of tokens to approximate the normalizing factor (which is bad?) + + beam = beam if beam is not None else self.beam + batch_size, seq_len = emissions.size()[:2] + beam_emission_scores, beam_targets = emissions.topk(beam, 2) + beam_transition_score1 = self.E1(beam_targets[:, :-1]) # B x (T-1) x K x D + beam_transition_score2 = self.E2(beam_targets[:, 1:]) # B x (T-1) x K x D + beam_transition_matrix = torch.bmm( + beam_transition_score1.view(-1, beam, self.rank), + beam_transition_score2.view(-1, beam, self.rank).transpose(1, 2), + ) + beam_transition_matrix = beam_transition_matrix.view(batch_size, -1, beam, beam) + + traj_tokens, traj_scores = [], [] + finalized_tokens, finalized_scores = [], [] + + # compute the normalizer in the log-space + score = beam_emission_scores[:, 0] # B x K + dummy = ( + torch.arange(beam, device=score.device).expand(*score.size()).contiguous() + ) + + for i in range(1, seq_len): + traj_scores.append(score) + _score = score[:, :, None] + beam_transition_matrix[:, i - 1] + _score, _index = _score.max(dim=1) + _score = _score + beam_emission_scores[:, i] + + if masks is not None: + score = torch.where(masks[:, i : i + 1], _score, score) + index = torch.where(masks[:, i : i + 1], _index, dummy) + else: + score, index = _score, _index + traj_tokens.append(index) + + # now running the back-tracing and find the best + best_score, best_index = score.max(dim=1) + finalized_tokens.append(best_index[:, None]) + finalized_scores.append(best_score[:, None]) + + for idx, scs in zip(reversed(traj_tokens), reversed(traj_scores)): + previous_index = finalized_tokens[-1] + finalized_tokens.append(idx.gather(1, previous_index)) + finalized_scores.append(scs.gather(1, previous_index)) + + finalized_tokens.reverse() + finalized_tokens = torch.cat(finalized_tokens, 1) + finalized_tokens = beam_targets.gather(2, finalized_tokens[:, :, None])[:, :, 0] + + finalized_scores.reverse() + finalized_scores = torch.cat(finalized_scores, 1) + finalized_scores[:, 1:] = finalized_scores[:, 1:] - finalized_scores[:, :-1] + + return finalized_scores, finalized_tokens diff --git a/fairseq/fairseq/modules/dynamicconv_layer/__init__.py b/fairseq/fairseq/modules/dynamicconv_layer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..22dc6f403d2a0ecdb1b9e7e69ed96bd560e93b2c --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .dynamicconv_layer import DynamicconvLayer # noqa diff --git a/fairseq/fairseq/modules/dynamicconv_layer/cuda_function_gen.py b/fairseq/fairseq/modules/dynamicconv_layer/cuda_function_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..9304f99eb8169a614f39babc830c84cac80e080b --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/cuda_function_gen.py @@ -0,0 +1,223 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +def gen_forward(): + + kernels = [3, 5, 7, 15, 31, 63, 127, 255] + blocks = [32, 64, 128, 256] + + head = """ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "dynamicconv_cuda.cuh" + +std::vector<at::Tensor> dynamicconv_cuda_forward(at::Tensor input, at::Tensor weight, int padding_l) { + + at::DeviceGuard g(input.device()); + const auto minibatch = input.size(0); + const auto numFeatures = input.size(1); + const auto sequenceLength = input.size(2); + + const auto numHeads = weight.size(1); + const auto filterSize = weight.size(2); + + const auto numFiltersInBlock = numFeatures / numHeads; + const dim3 blocks(minibatch, numFeatures); + + auto output = at::zeros_like(input); + auto stream = at::cuda::getCurrentCUDAStream(); +""" + + switch = """ + switch(filterSize) { +""" + + case_k = """ + case {k}: +""" + + main_block = """ + if (padding_l == {pad}) {{ + AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.scalar_type(), "dynamicconv_forward", ([&] {{ + dynamicconv_forward_kernel<{k}, {b_size}, {pad}, scalar_t> + <<<blocks, {b_size}, 0, stream>>>( + input.data<scalar_t>(), + weight.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + numHeads, + output.data<scalar_t>()); + }})); + }} else +""" + + bad_padding = """ + { + std::cout << "WARNING: Unsupported padding size - skipping forward pass" << std::endl; + } + break;\n +""" + + end = """ + default: + std::cout << "WARNING: Unsupported filter length passed - skipping forward pass" << std::endl; + } + + return {output}; +} +""" + + with open("dynamicconv_cuda_forward.cu", "w") as forward: + forward.write(head) + forward.write(switch) + for k in kernels: + b_size = 32 + for b in blocks: + if b > k: + b_size = b + break + forward.write(case_k.format(k=k)) + for pad in [k // 2, k - 1]: + forward.write(main_block.format(k=k, b_size=b_size, pad=pad)) + forward.write(bad_padding) + forward.write(end) + + +def gen_backward(): + + kernels = [3, 5, 7, 15, 31, 63, 127, 255] + thresh = [512, 512, 512, 512, 512, 380, 256, 256] + min_block = [64, 64, 64, 64, 64, 64, 128, 256] + seqs = [32 * x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]] + + head = """ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "dynamicconv_cuda.cuh" + +std::vector<at::Tensor> dynamicconv_cuda_backward(at::Tensor gradOutput, int padding_l, at::Tensor input, at::Tensor weight) { + + at::DeviceGuard g(input.device()); + const auto minibatch = input.size(0); + const auto numFeatures = input.size(1); + const auto sequenceLength = input.size(2); + + const auto numHeads = weight.size(1); + const auto filterSize = weight.size(2); + + const auto numFiltersInBlock = numFeatures / numHeads; + auto numChunks = 1; + + auto gradInput = at::zeros_like(input); + auto gradWeight = at::zeros_like(weight); + auto stream = at::cuda::getCurrentCUDAStream(); + + dim3 blocks(minibatch, numHeads, numChunks); +""" + + sequence_if = """ + if (sequenceLength < {seq}) {{ + switch(filterSize) {{ +""" + + case_k = """ + case {k}: +""" + + chunks_reset = """ + numChunks = int(ceilf(sequenceLength/float({b_size}))); + blocks = dim3(minibatch, numHeads, numChunks); +""" + + main_block = """ + if (padding_l == {p}) {{ + AT_DISPATCH_FLOATING_TYPES_AND_HALF(gradOutput.scalar_type(), "dynamicconv_backward", ([&] {{ + dynamicconv_backward_kernel<{k}, {b_size}, {p}, scalar_t> + <<<blocks, {b_size}, 0, stream>>>( + gradOutput.data<scalar_t>(), + input.data<scalar_t>(), + weight.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + numHeads, + gradWeight.data<scalar_t>(), + gradInput.data<scalar_t>()); + }})); + }} else +""" + + bad_padding = """ + { + std::cout << "WARNING: Unsupported padding size - skipping backward pass" << std::endl; + } + break;\n +""" + + bad_filter = """ + default: + std::cout << "WARNING: Unsupported filter length passed - skipping backward pass" << std::endl; + } +""" + + con_else = """ + } else +""" + + final_else = """ + { + switch(filterSize) { +""" + + last_return = """ + } + return {gradInput, gradWeight}; +} +""" + + with open("dynamicconv_cuda_backward.cu", "w") as backward: + backward.write(head) + for seq in seqs: + backward.write(sequence_if.format(seq=seq)) + for k, t, m in zip(kernels, thresh, min_block): + backward.write(case_k.format(k=k)) + if seq <= t: + b_size = seq + else: + b_size = m + backward.write(chunks_reset.format(b_size=b_size)) + for p in [k // 2, k - 1]: + backward.write(main_block.format(k=k, b_size=b_size, p=p)) + backward.write(bad_padding) + backward.write(bad_filter) + backward.write(con_else) + backward.write(final_else) + for k, m in zip(kernels, min_block): + backward.write(case_k.format(k=k)) + backward.write(chunks_reset.format(b_size=m)) + for p in [k // 2, k - 1]: + backward.write(main_block.format(k=k, b_size=m, p=p)) + backward.write(bad_padding) + backward.write(bad_filter) + backward.write(last_return) + + +if __name__ == "__main__": + gen_forward() + gen_backward() diff --git a/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cpp b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cpp new file mode 100644 index 0000000000000000000000000000000000000000..744c363e550231b8e0fbb94f998d46039daf5c00 --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cpp @@ -0,0 +1,51 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <torch/extension.h> +#include <vector> + +std::vector<at::Tensor> +dynamicconv_cuda_forward(at::Tensor input, at::Tensor filters, int padding_l); + +std::vector<at::Tensor> dynamicconv_cuda_backward( + at::Tensor gradOutput, + int padding_l, + at::Tensor input, + at::Tensor filters); + +#define CHECK_CUDA(x) \ + AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + AT_ASSERTM(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +std::vector<at::Tensor> +dynamicconv_forward(at::Tensor input, at::Tensor filters, int padding_l) { + CHECK_INPUT(input); + CHECK_INPUT(filters); + + return dynamicconv_cuda_forward(input, filters, padding_l); +} + +std::vector<at::Tensor> dynamicconv_backward( + at::Tensor gradOutput, + int padding_l, + at::Tensor input, + at::Tensor filters) { + CHECK_INPUT(gradOutput); + CHECK_INPUT(input); + CHECK_INPUT(filters); + + return dynamicconv_cuda_backward(gradOutput, padding_l, input, filters); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &dynamicconv_forward, "dynamicconv forward (CUDA)"); + m.def("backward", &dynamicconv_backward, "dynamicconv backward (CUDA)"); +} diff --git a/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cuh b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cuh new file mode 100644 index 0000000000000000000000000000000000000000..44baf21bdd2d4a7a692ae6f7953a413ea6513268 --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda.cuh @@ -0,0 +1,50 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <ATen/ATen.h> +#include <c10/cuda/CUDAStream.h> + +#include <cuda.h> +#include <cuda_fp16.h> +#include <cuda_runtime.h> + +#include <algorithm> +#include <functional> +#include <iostream> +#include <stdexcept> +#include <utility> +#include <vector> + +#include <assert.h> +#include <math.h> +#include <stdlib.h> + +#define SHFL_MASK 0xffffffff + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void dynamicconv_forward_kernel( + const scalar_t* input, + const scalar_t* weight, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + scalar_t* output); + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void dynamicconv_backward_kernel( + const scalar_t* gradOutput, // B * C * T + const scalar_t* input, // B * C * T + const scalar_t* weight, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + scalar_t* gradWeight, + scalar_t* gradInput); // B * H * k * T diff --git a/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda_kernel.cu b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..4630f1e9826aea61973f2e82feb57ac0a4390735 --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_cuda_kernel.cu @@ -0,0 +1,176 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "../cuda_utils.cu" +#include "dynamicconv_cuda.cuh" +#include "dynamicconv_cuda_backward.cu" +#include "dynamicconv_cuda_forward.cu" + +// FS is filter size and kernels are specialized for filter sizes +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void dynamicconv_forward_kernel( + const scalar_t* input, + const scalar_t* weight, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + scalar_t* output) { + assert(blockDim.x == SB); + + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int featureIdx = blockIdx.y; + const int head = featureIdx / numFiltersInBlock; + + const int IOOffset = + batchIdx * numFeatures * sequenceLength + featureIdx * sequenceLength; + const scalar_t* inputFeature = &input[IOOffset]; + scalar_t* outputFeature = &output[IOOffset]; + + scalar_t filter[FS]; + + __shared__ scalar_t tempInput[SB + FS]; + zeroSharedMem<FS, SB, padding_l>(tempInput); + + const int numIterations = divUp<int, int>(sequenceLength, SB); + + for (int i = 0; i < numIterations; ++i) { + __syncthreads(); + const int inputOffset = i * SB; + load_input_to_shared<FS, SB, padding_l>( + inputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + tempInput); + __syncthreads(); + if (inputOffset + tid < sequenceLength) { +#pragma unroll + for (int k = 0; k < FS; ++k) { + const int filterOffset = batchIdx * numHeads * FS * sequenceLength + + head * FS * sequenceLength + k * sequenceLength + i * SB + tid; + filter[k] = weight[filterOffset]; + } + + scalar_t out = scalar_t(0.0); +#pragma unroll + for (int k = 0; k < FS; ++k) { + out += filter[k] * tempInput[tid + k]; + } + + outputFeature[inputOffset + tid] = out; + } + } +} + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void dynamicconv_backward_kernel( + const scalar_t* gradOutput, // B * C * T + const scalar_t* input, // B * C * T + const scalar_t* weight, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + scalar_t* gradWeight, + scalar_t* gradInput) { // B * H * k * T + + assert(blockDim.x == SB); + + // each block operates on a single batch and filter head + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int headIdx = blockIdx.y; + const int chunkIdx = blockIdx.z; + + const int numChunks = divUp<int, int>(sequenceLength, SB); + const int inputOffset = chunkIdx * SB; + + // initialize shared memory for output gradient and input + __shared__ scalar_t tempGradOutput[SB + FS]; + __shared__ scalar_t tempInput[SB + FS]; + const int padding = FS - padding_l - 1; + + zeroSharedMem<FS, SB, padding>(tempGradOutput); + zeroSharedMem<FS, SB, padding_l>(tempInput); + + // initialize local filter and weight gradient sum arrays + scalar_t tempGradSum[FS]; + scalar_t bfilter[FS]; + for (int k = 0; k < FS; ++k) { + tempGradSum[k] = scalar_t(0.0); + + int idxOffset = inputOffset + tid + k - padding; + if (idxOffset >= 0 && idxOffset < sequenceLength) { + int bfilterOffset = batchIdx * numHeads * FS * sequenceLength + + headIdx * FS * sequenceLength + (FS - k - 1) * sequenceLength + + idxOffset; + bfilter[k] = weight[bfilterOffset]; + } else { + bfilter[k] = scalar_t(0.0); + } + } + + // iterate over filter block + for (int featureIdx = 0; featureIdx < numFiltersInBlock; ++featureIdx) { + __syncthreads(); + + // load input and output gradient for this channel and chunk + const int IOOffset = batchIdx * numFeatures * sequenceLength + + (headIdx * numFiltersInBlock + featureIdx) * sequenceLength; + const scalar_t* inputFeature = &input[IOOffset]; + const scalar_t* gradOutputFeature = &gradOutput[IOOffset]; + scalar_t* gradInputFeature = &gradInput[IOOffset]; + + load_input_to_shared<FS, SB, padding>( + gradOutputFeature, + inputOffset, + sequenceLength, + chunkIdx, + numChunks, + true, + tempGradOutput); + load_input_to_shared<FS, SB, padding_l>( + inputFeature, + inputOffset, + sequenceLength, + chunkIdx, + numChunks, + true, + tempInput); + __syncthreads(); + + // sum input and weight gradients + scalar_t out = scalar_t(0.0); +#pragma unroll + for (int k = 0; k < FS; ++k) { + tempGradSum[k] += tempInput[tid + k] * tempGradOutput[tid + padding]; + out += bfilter[k] * tempGradOutput[tid + k]; + } + + if (inputOffset + tid < sequenceLength) { + gradInputFeature[inputOffset + tid] = out; + } + } + + const int gradOffset = + batchIdx * numHeads * FS * sequenceLength + headIdx * FS * sequenceLength; + scalar_t* gradWeightFeature = &gradWeight[gradOffset]; + + // write weight gradient + if (inputOffset + tid < sequenceLength) { + for (int k = 0; k < FS; ++k) { + const int outputOffset = k * sequenceLength + inputOffset + tid; + gradWeightFeature[outputOffset] = tempGradSum[k]; + } + } +} diff --git a/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_layer.py b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..711ed03483f4089dbe91964a89021b49eeffbedc --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/dynamicconv_layer.py @@ -0,0 +1,227 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import dynamicconv_cuda +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.unfold import unfold1d +from torch import nn +from torch.autograd import Function + + +class dynamicconvFunction(Function): + @staticmethod + def forward(ctx, x, weights, padding_l): + ctx.padding_l = padding_l + outputs = dynamicconv_cuda.forward(x, weights, padding_l) + variables = [x, weights] + ctx.save_for_backward(*variables) + return outputs[0] + + @staticmethod + def backward(ctx, grad_output): + outputs = dynamicconv_cuda.backward( + grad_output.contiguous(), ctx.padding_l, *ctx.saved_tensors + ) + grad_input, grad_weights = outputs + return grad_input, grad_weights, None + + +@with_incremental_state +class DynamicconvLayer(nn.Module): + def __init__( + self, + input_size, + kernel_size=1, + padding_l=None, + weight_softmax=False, + num_heads=1, + weight_dropout=0.0, + bias=False, + renorm_padding=False, + conv_bias=False, + query_size=None, + ): + + super(DynamicconvLayer, self).__init__() + self.input_size = input_size + self.query_size = input_size if query_size is None else query_size + self.kernel_size = kernel_size + self.padding_l = padding_l + self.num_heads = num_heads + self.weight_softmax = weight_softmax + self.weight_dropout_module = FairseqDropout( + weight_dropout, module_name=self.__class__.__name__ + ) + self.renorm_padding = renorm_padding + self.bias = bias + + self.weight_linear = nn.Linear(input_size, num_heads * kernel_size, bias) + if conv_bias: + self.conv_bias = nn.Parameter(torch.Tensor(input_size)) + else: + self.conv_bias = None + self.reset_parameters() + + def reset_parameters(self): + nn.init.xavier_uniform_(self.weight_linear.weight) + if self.conv_bias is not None: + nn.init.constant_(self.conv_bias, 0.0) + nn.init.constant_(self.weight_linaer.bias, 0.0) + + def forward(self, x, incremental_state=None, query=None, unfold=None): + + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + # R = C // H + + # during inference time, incremental BMM is faster + if incremental_state is not None: + unfold = ( + x.size(0) > 512 if unfold is None else unfold + ) # use unfold mode as default for long sequence to save memory + unfold = unfold or (incremental_state is not None) + assert query is None + + if query is None: + query = x + if unfold: + output = self._forward_unfolded(x, incremental_state, query) + else: + output = self._forward_expanded(x, incremental_state, query) + + if self.conv_bias is not None: + output = output + self.conv_bias.view(1, 1, -1) + + return output + + # during training time, use CUDA kernel + else: + weight = self.weight_linear(x).view(T, B, H, K) + if self.weight_softmax: + weight = F.softmax(weight, dim=-1) + if self.weight_dropout_module.p: + weight = self.weight_dropout_module(weight) + + weight = weight.permute(1, 2, 3, 0).contiguous() + self.filters = weight + x = x.permute(1, 2, 0).contiguous() + output = dynamicconvFunction.apply(x, weight, self.padding_l).permute( + 2, 0, 1 + ) + if self.conv_bias is not None: + output = output + self.conv_bias.view(1, 1, -1) + return output + + def reorder_incremental_state(self, incremental_state, new_order): + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + input_buffer = input_buffer.index_select(1, new_order) + self._set_input_buffer(incremental_state, input_buffer) + + def _get_input_buffer(self, incremental_state): + return utils.get_incremental_state(self, incremental_state, "input_buffer") + + def _set_input_buffer(self, incremental_state, new_buffer): + return utils.set_incremental_state( + self, incremental_state, "input_buffer", new_buffer + ) + + def _forward_unfolded(self, x, incremental_state, query): + """The conventional implementation of convolutions. + Unfolding the input by having a window shifting to the right.""" + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + + weight = self.weight_linear(query).view(T * B * H, -1) + + # renorm_padding is only implemented in _forward_expanded + assert not self.renorm_padding or incremental_state is not None + + if incremental_state is not None: + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is None: + input_buffer = x.new() + x_unfold = torch.cat([input_buffer, x.unsqueeze(3)], dim=3) + if self.kernel_size > 1: + self._set_input_buffer( + incremental_state, x_unfold[:, :, :, -self.kernel_size + 1 :] + ) + x_unfold = x_unfold.view(T * B * H, R, -1) + else: + padding_l = self.padding_l + if K > T and padding_l == K - 1: + weight = weight.narrow(1, K - T, T) + K, padding_l = T, T - 1 + # unfold the input: T x B x C --> T' x B x C x K + x_unfold = unfold1d(x, K, padding_l, 0) + x_unfold = x_unfold.view(T * B * H, R, K) + + if self.weight_softmax and not self.renorm_padding: + weight = F.softmax(weight, dim=1) + weight = weight.narrow(1, 0, K) + + if incremental_state is not None: + weight = weight[:, -x_unfold.size(2) :] + K = weight.size(1) + + if self.weight_softmax and self.renorm_padding: + weight = F.softmax(weight, dim=1) + + weight = self.weight_dropout_module(weight, inplace=False) + + output = torch.bmm(x_unfold, weight.unsqueeze(2)) # T*B*H x R x 1 + output = output.view(T, B, C) + return output + + def _forward_expanded(self, x, incremental_stat, query): + """Turn the convolution filters into band matrices and do matrix multiplication. + This is faster when the sequence is short, but less memory efficient. + This is not used in the decoder during inference. + """ + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + weight = self.weight_linear(query).view(T * B * H, -1) + + if not self.renorm_padding: + if self.weight_softmax: + weight = F.softmax(weight, dim=1) + weight = self.weight_dropout_module(weight, inplace=False) + weight = weight.narrow(1, 0, K).contiguous() + weight = weight.view(T, B * H, K).transpose(0, 1) + + x = x.view(T, B * H, R).transpose(0, 1) + if self.weight_softmax and self.renorm_padding: + # turn the convolution filters into band matrices + weight_expanded = weight.new(B * H, T, T + K - 1).fill_(float("-inf")) + weight_expanded.as_strided( + (B * H, T, K), (T * (T + K - 1), T + K, 1) + ).copy_(weight) + weight_expanded = weight_expanded.narrow(2, self.padding_l, T) + # normalize the weight over valid positions like self-attention + weight_expanded = F.softmax(weight_expanded, dim=2) + weight_expanded = self.weight_dropout_module(weight_expanded, inplace=False) + else: + P = self.padding_l + # For efficiency, we cut the kernel size and reduce the padding when the kernel is larger than the length + if K > T and P == K - 1: + weight = weight.narrow(2, K - T, T) + K, P = T, T - 1 + # turn the convolution filters into band matrices + weight_expanded = weight.new_zeros(B * H, T, T + K - 1, requires_grad=False) + weight_expanded.as_strided( + (B * H, T, K), (T * (T + K - 1), T + K, 1) + ).copy_(weight) + weight_expanded = weight_expanded.narrow(2, P, T) # B*H x T x T + output = torch.bmm(weight_expanded, x) + output = output.transpose(0, 1).contiguous().view(T, B, C) + return output diff --git a/fairseq/fairseq/modules/dynamicconv_layer/dynamiconv_cpu.cpp b/fairseq/fairseq/modules/dynamicconv_layer/dynamiconv_cpu.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d7e57c859085f98ec10960330ca763ae2764585a --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/dynamiconv_cpu.cpp @@ -0,0 +1,29 @@ +#include <torch/torch.h> +#include <vector> + +std::vector<float*> +dynamicconv_cpu_forward(float* input, float* filters, int padding_l); + +std::vector<float*> dynamicconv_cpu_backward( + float* gradOutput, + int padding_l, + float* input, + float* filters); + +std::vector<float*> +dynamicconv_forward(float* input, float* filters, int padding_l) { + return dynamicconv_cpu_forward(input, filters, padding_l); +} + +std::vector<float*> dynamicconv_backward( + float* gradOutput, + int padding_l, + float* input, + float* filters) { + return dynamicconv_cpu_backward(gradOutput, padding_l, input, filters); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &dynamicconv_forward, "dynamicconv forward (CPU)"); + m.def("backward", &dynamicconv_backward, "dynamicconv backward (CPU)"); +} diff --git a/fairseq/fairseq/modules/dynamicconv_layer/setup.py b/fairseq/fairseq/modules/dynamicconv_layer/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..6a21f7e2ee0840a3b251522275a0b32a856951d7 --- /dev/null +++ b/fairseq/fairseq/modules/dynamicconv_layer/setup.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + + +setup( + name="dynamicconv_layer", + ext_modules=[ + CUDAExtension( + name="dynamicconv_cuda", + sources=[ + "dynamicconv_cuda.cpp", + "dynamicconv_cuda_kernel.cu", + ], + ), + ], + cmdclass={"build_ext": BuildExtension}, +) diff --git a/fairseq/fairseq/modules/fairseq_dropout.py b/fairseq/fairseq/modules/fairseq_dropout.py new file mode 100644 index 0000000000000000000000000000000000000000..3cddca77186f5ddd5cfb9c0ed6def9bafdf3bf1e --- /dev/null +++ b/fairseq/fairseq/modules/fairseq_dropout.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from typing import List, Optional + +import torch.nn as nn +import torch.nn.functional as F + + +logger = logging.getLogger(__name__) + + +class FairseqDropout(nn.Module): + def __init__(self, p, module_name=None): + super().__init__() + self.p = p + self.module_name = module_name + self.apply_during_inference = False + + def forward(self, x, inplace: bool = False): + if self.p > 0 and (self.training or self.apply_during_inference): + return F.dropout(x, p=self.p, training=True, inplace=inplace) + else: + return x + + def make_generation_fast_( + self, + name: str, + retain_dropout: bool = False, + retain_dropout_modules: Optional[List[str]] = None, + **kwargs + ): + if retain_dropout: + if retain_dropout_modules is not None and self.module_name is None: + logger.warning( + "Cannot enable dropout during inference for module {} " + "because module_name was not set".format(name) + ) + elif ( + retain_dropout_modules is None # if None, apply to all modules + or self.module_name in retain_dropout_modules + ): + logger.info( + "Enabling dropout during inference for module: {}".format(name) + ) + self.apply_during_inference = True + else: + logger.info("Disabling dropout for module: {}".format(name)) diff --git a/fairseq/fairseq/modules/fp32_group_norm.py b/fairseq/fairseq/modules/fp32_group_norm.py new file mode 100644 index 0000000000000000000000000000000000000000..d03aac022e30c8c14a600062d1d86429504ba003 --- /dev/null +++ b/fairseq/fairseq/modules/fp32_group_norm.py @@ -0,0 +1,25 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Layer norm done in fp32 (for fp16 training) +""" + +import torch.nn as nn +import torch.nn.functional as F + + +class Fp32GroupNorm(nn.GroupNorm): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def forward(self, input): + output = F.group_norm( + input.float(), + self.num_groups, + self.weight.float() if self.weight is not None else None, + self.bias.float() if self.bias is not None else None, + self.eps, + ) + return output.type_as(input) diff --git a/fairseq/fairseq/modules/gelu.py b/fairseq/fairseq/modules/gelu.py new file mode 100644 index 0000000000000000000000000000000000000000..a2f1ecff4a3ae3de3eb7d327b9163c46b18a15ed --- /dev/null +++ b/fairseq/fairseq/modules/gelu.py @@ -0,0 +1,25 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +See "Gaussian Error Linear Units (GELUs)" by Dan Hendrycks and Kevin Gimpel with +the corresponding GitHub repo: https://github.com/hendrycks/GELUs +""" + +import math + +import torch +import torch.nn as nn + + +def gelu_accurate(x): + if not hasattr(gelu_accurate, "_a"): + gelu_accurate._a = math.sqrt(2 / math.pi) + return ( + 0.5 * x * (1 + torch.tanh(gelu_accurate._a * (x + 0.044715 * torch.pow(x, 3)))) + ) + + +def gelu(x: torch.Tensor) -> torch.Tensor: + return torch.nn.functional.gelu(x.float()).type_as(x) diff --git a/fairseq/fairseq/modules/grad_multiply.py b/fairseq/fairseq/modules/grad_multiply.py new file mode 100644 index 0000000000000000000000000000000000000000..08d15f55dfda9c61a1cf8641ea31424fe1d97f57 --- /dev/null +++ b/fairseq/fairseq/modules/grad_multiply.py @@ -0,0 +1,18 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + + +class GradMultiply(torch.autograd.Function): + @staticmethod + def forward(ctx, x, scale): + ctx.scale = scale + res = x.new(x) + return res + + @staticmethod + def backward(ctx, grad): + return grad * ctx.scale, None diff --git a/fairseq/fairseq/modules/gumbel_vector_quantizer.py b/fairseq/fairseq/modules/gumbel_vector_quantizer.py new file mode 100644 index 0000000000000000000000000000000000000000..71134388889d7f224655957256e78fd6c02d72a3 --- /dev/null +++ b/fairseq/fairseq/modules/gumbel_vector_quantizer.py @@ -0,0 +1,202 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class GumbelVectorQuantizer(nn.Module): + def __init__( + self, + dim, + num_vars, + temp, + groups, + combine_groups, + vq_dim, + time_first, + activation=nn.GELU(), + weight_proj_depth=1, + weight_proj_factor=1, + ): + """Vector quantization using gumbel softmax + + Args: + dim: input dimension (channels) + num_vars: number of quantized vectors per group + temp: temperature for training. this should be a tuple of 3 elements: (start, stop, decay factor) + groups: number of groups for vector quantization + combine_groups: whether to use the vectors for all groups + vq_dim: dimensionality of the resulting quantized vector + time_first: if true, expect input in BxTxC format, otherwise in BxCxT + activation: what activation to use (should be a module). this is only used if weight_proj_depth is > 1 + weight_proj_depth: number of layers (with activation in between) to project input before computing logits + weight_proj_factor: this is used only if weight_proj_depth is > 1. scales the inner dimensionality of + projections by this factor + """ + super().__init__() + + self.groups = groups + self.combine_groups = combine_groups + self.input_dim = dim + self.num_vars = num_vars + self.time_first = time_first + + assert ( + vq_dim % groups == 0 + ), f"dim {vq_dim} must be divisible by groups {groups} for concatenation" + + var_dim = vq_dim // groups + num_groups = groups if not combine_groups else 1 + + self.vars = nn.Parameter(torch.FloatTensor(1, num_groups * num_vars, var_dim)) + nn.init.uniform_(self.vars) + + if weight_proj_depth > 1: + + def block(input_dim, output_dim): + return nn.Sequential(nn.Linear(input_dim, output_dim), activation) + + inner_dim = self.input_dim * weight_proj_factor + self.weight_proj = nn.Sequential( + *[ + block(self.input_dim if i == 0 else inner_dim, inner_dim) + for i in range(weight_proj_depth - 1) + ], + nn.Linear(inner_dim, groups * num_vars), + ) + else: + self.weight_proj = nn.Linear(self.input_dim, groups * num_vars) + nn.init.normal_(self.weight_proj.weight, mean=0, std=1) + nn.init.zeros_(self.weight_proj.bias) + + if isinstance(temp, str): + import ast + temp = ast.literal_eval(temp) + assert len(temp) == 3, f"{temp}, {len(temp)}" + + self.max_temp, self.min_temp, self.temp_decay = temp + self.curr_temp = self.max_temp + self.codebook_indices = None + + def set_num_updates(self, num_updates): + self.curr_temp = max( + self.max_temp * self.temp_decay ** num_updates, self.min_temp + ) + + def get_codebook_indices(self): + if self.codebook_indices is None: + from itertools import product + + p = [range(self.num_vars)] * self.groups + inds = list(product(*p)) + self.codebook_indices = torch.tensor( + inds, dtype=torch.long, device=self.vars.device + ).flatten() + + if not self.combine_groups: + self.codebook_indices = self.codebook_indices.view( + self.num_vars ** self.groups, -1 + ) + for b in range(1, self.groups): + self.codebook_indices[:, b] += self.num_vars * b + self.codebook_indices = self.codebook_indices.flatten() + return self.codebook_indices + + def codebook(self): + indices = self.get_codebook_indices() + return ( + self.vars.squeeze(0) + .index_select(0, indices) + .view(self.num_vars ** self.groups, -1) + ) + + def sample_from_codebook(self, b, n): + indices = self.get_codebook_indices() + indices = indices.view(-1, self.groups) + cb_size = indices.size(0) + assert ( + n < cb_size + ), f"sample size {n} is greater than size of codebook {cb_size}" + sample_idx = torch.randint(low=0, high=cb_size, size=(b * n,)) + indices = indices[sample_idx] + + z = self.vars.squeeze(0).index_select(0, indices.flatten()).view(b, n, -1) + return z + + def to_codebook_index(self, indices): + res = indices.new_full(indices.shape[:-1], 0) + for i in range(self.groups): + exponent = self.groups - i - 1 + res += indices[..., i] * (self.num_vars ** exponent) + return res + + def forward_idx(self, x): + res = self.forward(x, produce_targets=True) + return res["x"], res["targets"] + + def forward(self, x, produce_targets=False): + + result = {"num_vars": self.num_vars * self.groups} + + if not self.time_first: + x = x.transpose(1, 2) + + bsz, tsz, fsz = x.shape + x = x.reshape(-1, fsz) + x = self.weight_proj(x) + x = x.view(bsz * tsz * self.groups, -1) + + _, k = x.max(-1) + hard_x = ( + x.new_zeros(*x.shape) + .scatter_(-1, k.view(-1, 1), 1.0) + .view(bsz * tsz, self.groups, -1) + ) + hard_probs = torch.mean(hard_x.float(), dim=0) + result["code_perplexity"] = torch.exp( + -torch.sum(hard_probs * torch.log(hard_probs + 1e-7), dim=-1) + ).sum() + + avg_probs = torch.softmax( + x.view(bsz * tsz, self.groups, -1).float(), dim=-1 + ).mean(dim=0) + result["prob_perplexity"] = torch.exp( + -torch.sum(avg_probs * torch.log(avg_probs + 1e-7), dim=-1) + ).sum() + + result["temp"] = self.curr_temp + + if self.training: + x = F.gumbel_softmax(x.float(), tau=self.curr_temp, hard=True).type_as(x) + else: + x = hard_x + + x = x.view(bsz * tsz, -1) + + vars = self.vars + if self.combine_groups: + vars = vars.repeat(1, self.groups, 1) + + if produce_targets: + result["targets"] = ( + x.view(bsz * tsz * self.groups, -1) + .argmax(dim=-1) + .view(bsz, tsz, self.groups) + .detach() + ) + + x = x.unsqueeze(-1) * vars + x = x.view(bsz * tsz, self.groups, self.num_vars, -1) + x = x.sum(-2) + x = x.view(bsz, tsz, -1) + + if not self.time_first: + x = x.transpose(1, 2) # BTC -> BCT + + result["x"] = x + + return result diff --git a/fairseq/fairseq/modules/kmeans_attention.py b/fairseq/fairseq/modules/kmeans_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..11a7debcf2ac025fb02ba5e672987f87dbbc49a4 --- /dev/null +++ b/fairseq/fairseq/modules/kmeans_attention.py @@ -0,0 +1,609 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import math +from inspect import isfunction +from operator import mul +from functools import reduce, wraps + +from aml.multimodal_video.utils.einops.lib import rearrange, repeat +from aml.multimodal_video.utils.einops.lib.layers.torch import Rearrange + +from fairseq.modules.local_attention import LocalAttention + +# constants + +TOKEN_SELF_ATTN_VALUE = -5e4 +KMEAN_INIT_ITERS = 10 + +# helper functions + + +def exists(val): + return val is not None + + +def identity(x, *args, **kwargs): + return x + + +def default(x, d): + if not exists(x): + return d if not isfunction(d) else d() + return x + + +def cast_tuple(x): + return x if isinstance(x, tuple) else (x,) + + +def cache_fn(f): + cache = None + + @wraps(f) + def cached_fn(*args, **kwargs): + nonlocal cache + if exists(cache): + return cache + cache = f(*args, **kwargs) + return cache + return cached_fn + + +def to(t): + return {'device': t.device, 'dtype': t.dtype} + + +def find_modules(nn_module, type): + return [module for module in nn_module.modules() if isinstance(module, type)] + + +def is_empty(t): + return t.nelement() == 0 + + +def max_neg_value(tensor): + return -torch.finfo(tensor.dtype).max + + +def batched_index_select(values, indices): + last_dim = values.shape[-1] + return values.gather(2, expand_dim(indices, -1, last_dim)) + + +def merge_dims(ind_from, ind_to, tensor): + shape = list(tensor.shape) + arr_slice = slice(ind_from, ind_to + 1) + shape[arr_slice] = [reduce(mul, shape[arr_slice])] + return tensor.reshape(*shape) + + +def expand_dim(t, dim, k): + t = t.unsqueeze(dim) + expand_shape = [-1] * len(t.shape) + expand_shape[dim] = k + return t.expand(*expand_shape) + + +def scatter_mean(src, t, index, dim, eps=1e-5): + numer = src.scatter_add(dim, index, t) + denom = src.scatter_add(dim, index, torch.ones_like(t)) + return numer / (denom + eps) + + +def split_at_index(dim, index, t): + pre_slices = (slice(None),) * dim + l = (*pre_slices, slice(None, index)) + r = (*pre_slices, slice(index, None)) + return t[l], t[r] + + +def reshape_dim(t, dim, split_dims): + shape = list(t.shape) + num_dims = len(shape) + dim = (dim + num_dims) % num_dims + shape[dim:dim+1] = split_dims + return t.reshape(shape) + + +def ema(old, new, decay): + if not exists(old): + return new + return old * decay + new * (1 - decay) + + +def ema_inplace(moving_avg, new, decay): + if is_empty(moving_avg): + moving_avg.data.copy_(new) + return + moving_avg.data.mul_(decay).add_(new, alpha=(1 - decay)) + +# helper classes + + +def map_first_tuple_or_el(x, fn): + if isinstance(x, tuple): + return (fn(x[0]),) + x[1:] + return fn(x) + + +class Chunk(nn.Module): + def __init__(self, chunks, fn, along_dim=-1): + super().__init__() + self.dim = along_dim + self.chunks = chunks + self.fn = fn + + def forward(self, x, **kwargs): + if self.chunks <= 1: + return self.fn(x, **kwargs) + chunks = x.chunk(self.chunks, dim=self.dim) + return torch.cat([self.fn(c, **kwargs) for c in chunks], dim=self.dim) + + +class PreNorm(nn.ModuleList): + def __init__(self, norm_class, dim, fn): + super().__init__() + self.norm = norm_class(dim) + self.fn = fn + + def forward(self, x, **kwargs): + x = self.norm(x) + return self.fn(x, **kwargs) + + +class ReZero(nn.Module): + def __init__(self, fn): + super().__init__() + self.residual_weight = nn.Parameter(torch.zeros(1)) + self.fn = fn + + def forward(self, x, **kwargs): + x = self.fn(x, **kwargs) + return map_first_tuple_or_el(x, lambda t: t * self.residual_weight) + + +class ScaleNorm(nn.Module): + def __init__(self, dim, eps=1e-5): + super().__init__() + self.g = nn.Parameter(torch.ones(1)) + self.eps = eps + + def forward(self, x): + def norm(t): + n = torch.norm(t, dim=-1, keepdim=True).clamp(min=self.eps) + return t / n * self.g + return map_first_tuple_or_el(x, norm) + + +class ProjectInOut(nn.Module): + def __init__(self, fn, dim_in, dim_out, project_out=True): + super().__init__() + self.fn = fn + self.project_in = nn.Linear(dim_in, dim_out) + self.project_out = nn.Linear(dim_out, dim_in) if project_out else identity + + def forward(self, x, **kwargs): + x = self.project_in(x) + x, loss = self.fn(x, **kwargs) + x = self.project_out(x) + return x, loss + + +class MatrixMultiply(nn.Module): + def __init__(self, tensor, transpose=False): + super().__init__() + self.tensor = tensor + self.transpose = transpose + + def forward(self, x): + tensor = self.tensor + if self.transpose: + tensor = tensor.t() + return x @ tensor + +# positional embeddings + + +class DepthWiseConv1d(nn.Module): + def __init__(self, dim_in, dim_out, kernel_size, stride=1, bias=True, causal=False): + super().__init__() + self.padding = ((kernel_size - 1), 0) if causal else (kernel_size // 2, kernel_size // 2) + + self.net = nn.Sequential( + nn.Conv1d(dim_in, dim_in, kernel_size=kernel_size, groups=dim_in, stride=stride, bias=bias), + nn.Conv1d(dim_in, dim_out, 1, bias=bias) + ) + + def forward(self, x): + x = F.pad(x, self.padding, value=0.) + return self.net(x) + + +class FixedPositionalEmbedding(nn.Module): + def __init__(self, dim, max_seq_len): + super().__init__() + inv_freq = 1. / (10000 ** (torch.arange(0, dim, 2).float() / dim)) + position = torch.arange(0, max_seq_len, dtype=torch.float) + sinusoid_inp = torch.einsum("i,j->ij", position, inv_freq) + emb = torch.cat((sinusoid_inp.sin(), sinusoid_inp.cos()), dim=-1) + self.register_buffer('emb', emb) + + def forward(self, x): + return self.emb[None, :x.shape[1], :].to(x) + + +def rotate_every_two(x): + x = rearrange(x, '... (d j) -> ... d j', j=2) + x1, x2 = x.unbind(dim=-1) + x = torch.stack((-x2, x1), dim=-1) + return rearrange(x, '... d j -> ... (d j)') + + +def apply_rotary_pos_emb(q, k, sinu_pos): + sinu_pos = rearrange(sinu_pos, '() n (j d) -> n j d', j=2) + sin, cos = sinu_pos.unbind(dim=-2) + sin, cos = map(lambda t: repeat(t, 'b n -> b (n j)', j=2), (sin, cos)) + q, k = map(lambda t: (t * cos) + (rotate_every_two(t) * sin), (q, k)) + return q, k + +# kmeans related function and class + + +def update_kmeans_on_backwards(module): + module.kmean_modules = find_modules(module, Kmeans) + + def hook(_, grad_in, grad_out): + for m in module.kmean_modules: + m.update() + + return module.register_backward_hook(hook) + + +def similarity(x, means): + return torch.einsum('bhld,hcd->bhlc', x, means) + + +def dists_and_buckets(x, means): + dists = similarity(x, means) + _, buckets = torch.max(dists, dim=-1) + return dists, buckets + + +def batched_bincount(index, num_classes, dim=-1): + shape = list(index.shape) + shape[dim] = num_classes + out = index.new_zeros(shape) + out.scatter_add_(dim, index, torch.ones_like(index, dtype=index.dtype)) + return out + + +def kmeans_iter(x, means, buckets=None): + b, h, _, d, dtype, num_clusters = *x.shape, x.dtype, means.shape[1] + + if not exists(buckets): + _, buckets = dists_and_buckets(x, means) + + bins = batched_bincount(buckets, num_clusters).sum(0, keepdim=True) + zero_mask = bins.long() == 0 + + means_ = buckets.new_zeros(b, h, num_clusters, d, dtype=dtype) + means_.scatter_add_(-2, expand_dim(buckets, -1, d), x) + means_ = F.normalize(means_.sum(0, keepdim=True), dim=-1).type(dtype) + + means = torch.where(zero_mask.unsqueeze(-1), means, means_) + means = means.squeeze(0) + return means + + +def distribution(dists, window_size): + _, topk_indices = dists.topk(k=window_size, dim=-2) + indices = topk_indices.transpose(-2, -1) + return indices.reshape(*indices.size()[:2], -1) + + +class Kmeans(nn.Module): + def __init__(self, num_heads, head_dim, num_clusters, ema_decay=0.999, commitment=1e-4): + super().__init__() + self.commitment = commitment + self.ema_decay = ema_decay + + self.register_buffer('means', torch.randn(num_heads, num_clusters, head_dim)) + self.register_buffer('initted', torch.tensor(False)) + self.num_new_means = 0 + self.new_means = None + + @torch.no_grad() + def init(self, x): + if self.initted: + return + _, h, _, d, device, _ = *x.shape, x.device, x.dtype + + num_clusters = self.means.shape[1] + + means = x.transpose(0, 1).contiguous().view(h, -1, d) + num_samples = means.shape[1] + + if num_samples >= num_clusters: + indices = torch.randperm(num_samples, device=device)[:num_clusters] + else: + indices = torch.randint(0, num_samples, (num_clusters,), device=device) + + means = means[:, indices] + + for _ in range(KMEAN_INIT_ITERS): + means = kmeans_iter(x, means) + + self.num_new_means = 0 + self.means.data.copy_(means) + self.initted.data.copy_(torch.tensor(True)) + + @torch.no_grad() + def update(self, new_means=None): + new_means = default(new_means, self.new_means) + assert exists(new_means), 'new kmeans has not been supplied' + ema_inplace(self.means, new_means, self.ema_decay) + + del self.new_means + self.new_means = None + self.num_new_means = 0 + + def forward(self, x, update_means=False): + self.init(x) + + b, dtype = x.shape[0], x.dtype + means = self.means.type(dtype) + x = F.normalize(x, 2, dim=-1).type(dtype) + + with torch.no_grad(): + dists, buckets = dists_and_buckets(x, means) + + routed_means = batched_index_select(expand_dim(means, 0, b), buckets) + loss = F.mse_loss(x, routed_means) * self.commitment + + if update_means: + with torch.no_grad(): + means = kmeans_iter(x, means, buckets) + self.new_means = ema(self.new_means, means, self.num_new_means / (self.num_new_means + 1)) + self.num_new_means += 1 + + return dists, loss + +# kmeans attention class + + +class KmeansAttention(nn.Module): + def __init__(self, num_clusters, window_size, num_heads, head_dim, causal=False, dropout=0., ema_decay=0.999, commitment=1e-4, context_window_size=None, receives_context=False, num_mem_kv=0, shared_qk=False): + super().__init__() + self.num_heads = num_heads + self.num_clusters = num_clusters + self.head_dim = head_dim + + self.window_size = window_size + self.context_window_size = default(context_window_size, window_size) + self.causal = causal + + self.shared_qk = shared_qk + self.receives_context = receives_context + self.kmeans = Kmeans(num_heads, head_dim, num_clusters, ema_decay, commitment) + self.dropout = nn.Dropout(dropout) + + self.num_mem_kv = max(num_mem_kv, 1 if causal and not shared_qk else 0) + self.mem_key = nn.Parameter(torch.randn(num_heads, num_clusters, self.num_mem_kv, head_dim)) + self.mem_value = nn.Parameter(torch.randn(num_heads, num_clusters, self.num_mem_kv, head_dim)) + + def forward(self, q, k, v, query_mask=None, key_mask=None, **kwargs): + b, h, t, d, kv_t, wsz, c_wsz, nc, device, dtype = *q.shape, k.shape[2], self.window_size, self.context_window_size, self.num_clusters, q.device, q.dtype + is_reverse = kwargs.pop('_reverse', False) + + out = torch.zeros_like(q, dtype=dtype) + + update_kmeans = self.training and not is_reverse + + key_mask = default(key_mask, query_mask) if not self.receives_context else key_mask + kv_wsz = wsz if not self.receives_context else c_wsz + + wsz = min(wsz, t) + kv_wsz = min(kv_wsz, kv_t) + + if not self.shared_qk or self.receives_context: + dists, aux_loss = self.kmeans(torch.cat((q, k), dim=2), update_kmeans) + q_dists, k_dists = split_at_index(2, t, dists) + indices = distribution(q_dists, wsz) + kv_indices = distribution(k_dists, kv_wsz) + else: + dists, aux_loss = self.kmeans(q, update_kmeans) + k = F.normalize(k, dim=-1).to(q) + indices = distribution(dists, wsz) + kv_indices = indices + + q = batched_index_select(q, indices) + k = batched_index_select(k, kv_indices) + v = batched_index_select(v, kv_indices) + + reshape_with_window = lambda x: x.reshape(b, h, nc, -1, d) + q, k, v = map(reshape_with_window, (q, k, v)) + + m_k, m_v = map(lambda x: expand_dim(x, 0, b).to(q), (self.mem_key, self.mem_value)) + k, v = map(lambda x: torch.cat(x, dim=3), ((m_k, k), (m_v, v))) + + dots = torch.einsum('bhnid,bhnjd->bhnij', q, k) * (d ** -0.5) + + mask_value = max_neg_value(dots) + + if exists(query_mask) or exists(key_mask): + query_mask = default(query_mask, lambda: torch.ones((b, t), device=device).bool()) + key_mask = default(key_mask, lambda: torch.ones((b, kv_t), device=device).bool()) + + q_mask = expand_dim(query_mask, 1, h).gather(2, indices) + kv_mask = expand_dim(key_mask, 1, h).gather(2, kv_indices) + q_mask, kv_mask = map(lambda t: t.reshape(b, h, nc, -1), (q_mask, kv_mask)) + mask = q_mask[:, :, :, :, None] * kv_mask[:, :, :, None, :] + mask = F.pad(mask, (self.num_mem_kv, 0), value=1) + dots.masked_fill_(~mask, mask_value) + del mask + + if self.causal: + q_mask, kv_mask = map(lambda t: t.reshape(b, h, nc, -1), (indices, kv_indices)) + mask = q_mask[:, :, :, :, None] >= kv_mask[:, :, :, None, :] + mask = F.pad(mask, (self.num_mem_kv, 0), value=1) + dots.masked_fill_(~mask, mask_value) + del mask + + if self.shared_qk: + q_mask, kv_mask = map(lambda t: t.reshape(b, h, nc, -1), (indices, kv_indices)) + mask = q_mask[:, :, :, :, None] == kv_mask[:, :, :, None, :] + mask = F.pad(mask, (self.num_mem_kv, 0), value=0) + dots.masked_fill_(mask, TOKEN_SELF_ATTN_VALUE) + del mask + + dots = dots.softmax(dim=-1) + dots = self.dropout(dots) + + bo = torch.einsum('bhcij,bhcjd->bhcid', dots, v) + so = torch.reshape(bo, (b, h, -1, bo.shape[-1])).type(dtype) + out = scatter_mean(out, so, indices.unsqueeze(-1).expand_as(so), -2) + return out, aux_loss + +# feedforward + + +class GELU_(nn.Module): + def forward(self, x): + return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))) + + +GELU = nn.GELU if hasattr(nn, 'GELU') else GELU_ + + +class FeedForward(nn.Module): + def __init__(self, dim, mult=4, dropout=0., activation=None, glu=False): + super().__init__() + activation = default(activation, GELU) + + self.glu = glu + self.w1 = nn.Linear(dim, dim * mult * (2 if glu else 1)) + self.act = activation() + self.dropout = nn.Dropout(dropout) + self.w2 = nn.Linear(dim * mult, dim) + + def forward(self, x, **kwargs): + if not self.glu: + x = self.w1(x) + x = self.act(x) + else: + x, v = self.w1(x).chunk(2, dim=-1) + x = self.act(x) * v + + x = self.dropout(x) + x = self.w2(x) + return x + +# self attention + + +class SelfAttention(nn.Module): + def __init__(self, dim, max_seq_len, heads, local_attn_heads, window_size, dim_head=None, local_attn_window_size=None, local_attn_radius_blocks=1, causal=False, attn_dropout=0., dropout=0., kmeans_ema_decay=0.999, commitment_factor=1e-4, receives_context=False, context_window_size=None, rel_pos_emb=True, num_mem_kv=0, shared_qk=False, conv_query_kernel=9): + super().__init__() + assert dim_head or (dim % heads) == 0, 'hidden dimension must be divisible by number of heads' + assert (max_seq_len % window_size) == 0, 'maximum sequence length must be divisible by the target window size' + assert local_attn_heads <= heads, 'number of local attention heads must be less than total heads' + assert not (receives_context and local_attn_heads > 0), 'local attention cannot be used for self attention with context' + assert not (receives_context and causal), 'contextual attention layer cannot be causal' + + local_attn_window_size = default(local_attn_window_size, window_size) + context_window_size = default(context_window_size, window_size) + + self.shared_qk = shared_qk + self.receives_context = receives_context + self.heads = heads + self.local_attn_heads = local_attn_heads + self.global_attn_heads = heads - local_attn_heads + + self.causal = causal + self.window_size = window_size + + dim_head = default(dim_head, dim // heads) + dim_heads = dim_head * heads + self.dim_head = dim_head + + num_clusters = max_seq_len // window_size + + # local + + local_dim_heads = dim_head * self.local_attn_heads + + if self.local_attn_heads > 0: + rel_pos_emb_config = (dim_head, local_attn_heads) if rel_pos_emb else None + self.local_attn = LocalAttention(dim=dim_head, window_size=local_attn_window_size, causal=causal, dropout=attn_dropout, rel_pos_emb_config=rel_pos_emb_config, look_backward=local_attn_radius_blocks, look_forward=0 if causal else local_attn_radius_blocks) + self.local_to_qkv = nn.Linear(dim, 3 * local_dim_heads) + + # global + + global_dim_heads = dim_head * self.global_attn_heads + + if self.global_attn_heads > 0: + self.global_attn = KmeansAttention(num_clusters, window_size, self.global_attn_heads, dim_head, causal=causal, dropout=attn_dropout, ema_decay=kmeans_ema_decay, commitment=commitment_factor, receives_context=receives_context, num_mem_kv=num_mem_kv, shared_qk=shared_qk) + + self.to_q = nn.Sequential( + Rearrange('b n c -> b c n'), + DepthWiseConv1d(dim, global_dim_heads, conv_query_kernel, causal=causal), + Rearrange('b c n -> b n c') + ) + + self.to_v = nn.Linear(dim, global_dim_heads, bias=False) + + if not self.shared_qk: + self.to_k = nn.Linear(dim, global_dim_heads, bias=False) + + # out + + self.to_out = nn.Linear(dim_heads, dim, bias=False) + self.dropout = nn.Dropout(dropout) + + def forward(self, query, key, value, context=None, key_padding_mask=None, context_mask=None, pos_emb=None, **kwargs): + assert not (self.receives_context and not exists(context)), 'context must be passed if self attention is set to receive context' + input_mask = key_padding_mask + x = query.transpose(0, 1) + b, t, _, h, dh = *x.shape, self.heads, self.dim_head + has_local, has_global = map(lambda x: x > 0, (self.local_attn_heads, self.global_attn_heads)) + + split_heads = lambda v: reshape_dim(v, -1, (-1, dh)).transpose(1, 2).contiguous() + + if has_local: + local_qkv = self.local_to_qkv(x).chunk(3, dim=-1) + lq, lk, lv = map(split_heads, local_qkv) + + if has_global: + kv_input = x if not self.receives_context else context + + q, v = self.to_q(x), self.to_v(kv_input) + + if not self.shared_qk: + k = self.to_k(kv_input) + else: + k = self.to_q(kv_input) if self.receives_context else q + + q, k, v = map(split_heads, (q, k, v)) + + out = [] + total_loss = torch.tensor(0., requires_grad=True, **to(x)) + + if has_local: + local_out = self.local_attn(lq, lk, lv, input_mask=input_mask) + out.append(local_out) + + if has_global: + if not self.receives_context and exists(pos_emb): + q, k = apply_rotary_pos_emb(q, k, pos_emb) + + global_out, loss = self.global_attn(q, k, v, query_mask=input_mask, key_mask=context_mask) + total_loss = total_loss + loss + + out.append(global_out) + + out = torch.cat(out, dim=1) + out = out.reshape(b, h, t, -1).transpose(1, 2).reshape(b, t, -1) + out = self.dropout(out.transpose(0, 1)) + # out = self.to_out(out) + return out, total_loss diff --git a/fairseq/fairseq/modules/kmeans_vector_quantizer.py b/fairseq/fairseq/modules/kmeans_vector_quantizer.py new file mode 100644 index 0000000000000000000000000000000000000000..040db1e83e775a3bb59d5263d22aae9276a83f22 --- /dev/null +++ b/fairseq/fairseq/modules/kmeans_vector_quantizer.py @@ -0,0 +1,127 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +from fairseq.modules import Fp32GroupNorm + + +class KmeansVectorQuantizer(nn.Module): + def __init__( + self, dim, num_vars, groups, combine_groups, vq_dim, time_first, gamma=0.25 + ): + """Vector quantization using straight pass-through estimator (i.e. kmeans) + + Args: + dim: input dimension (channels) + num_vars: number of quantized vectors per group + groups: number of groups for vector quantization + combine_groups: whether to use the vectors for all groups + vq_dim: dimensionality of the resulting quantized vector + time_first: if true, expect input in BxTxC format, otherwise in BxCxT + gamma: commitment loss coefficient + """ + super().__init__() + + self.groups = groups + self.combine_groups = combine_groups + self.input_dim = dim + self.num_vars = num_vars + self.vq_dim = vq_dim + self.time_first = time_first + + assert ( + vq_dim % groups == 0 + ), f"dim {vq_dim} must be divisible by groups {groups} for concatenation" + + self.var_dim = vq_dim // groups + num_groups = groups if not combine_groups else 1 + + self.embedding = nn.Parameter( + 0.01 * torch.randn(num_vars, num_groups, self.var_dim) + ) + self.projection = nn.Sequential( + nn.Conv1d(dim, dim, kernel_size=1, groups=groups, bias=False), + Fp32GroupNorm(groups, dim), + ) + self.gamma = gamma + self.mse_mean = nn.MSELoss(reduction="mean") + + def _pass_grad(self, x, y): + """Manually set gradient for backward pass. + for y = f(x), ensure that during the backward pass, + dL/dy = dL/dx regardless of f(x). + Returns: + y, with the gradient forced to be dL/dy = dL/dx. + """ + + return y.detach() + (x - x.detach()) + + @property + def expand_embedding(self): + if self.combine_groups: + return self.embedding.expand(self.num_vars, self.groups, self.var_dim) + return self.embedding + + def forward_idx(self, x): + res = self.forward(x, produce_targets=True) + return res["x"], res["targets"] + + def forward(self, x, produce_targets=False): + + result = {"num_vars": self.num_vars} + + if self.time_first: + x = x.transpose(1, 2) + + bsz, fsz, tsz = x.shape + + ze = self.projection(x) + ze_ = ze.view(bsz, self.groups, self.var_dim, tsz).permute(0, 3, 1, 2) + d = ( + (ze_.unsqueeze(0) - self.expand_embedding.unsqueeze(1).unsqueeze(1)) + .view(self.num_vars, bsz, tsz, self.groups, -1) + .norm(dim=-1, p=2) + ) + idx = d.argmin(dim=0) + zq = ( + torch.stack( + [ + self.expand_embedding[idx[..., group], group] + for group in range(self.groups) + ], + dim=-2, + ) + .view(bsz, tsz, self.groups * self.var_dim) + .permute(0, 2, 1) + ) + assert ze.shape == zq.shape, (ze.shape, zq.shape) + x = self._pass_grad(ze, zq) + + hard_x = ( + idx.new_zeros(bsz * tsz * self.groups, self.num_vars) + .scatter_(-1, idx.view(-1, 1), 1.0) + .view(bsz * tsz, self.groups, -1) + ) + hard_probs = torch.mean(hard_x.float(), dim=0) + result["code_perplexity"] = torch.exp( + -torch.sum(hard_probs * torch.log(hard_probs + 1e-7), dim=-1) + ).sum() + + if produce_targets: + result["targets"] = idx + + if self.time_first: + x = x.transpose(1, 2) # BCT -> BTC + result["x"] = x + + ze = ze.float() + zq = zq.float() + latent_loss = self.mse_mean(zq, ze.detach()) + commitment_loss = self.mse_mean(ze, zq.detach()) + + result["kmeans_loss"] = latent_loss + self.gamma * commitment_loss + + return result diff --git a/fairseq/fairseq/modules/layer_drop.py b/fairseq/fairseq/modules/layer_drop.py new file mode 100644 index 0000000000000000000000000000000000000000..8961d8bcbc492c40c6b30973234416ce5a414f5a --- /dev/null +++ b/fairseq/fairseq/modules/layer_drop.py @@ -0,0 +1,44 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +LayerDrop as described in https://arxiv.org/abs/1909.11556. +""" + +import torch +import torch.nn as nn + + +class LayerDropModuleList(nn.ModuleList): + """ + A LayerDrop implementation based on :class:`torch.nn.ModuleList`. + + We refresh the choice of which layers to drop every time we iterate + over the LayerDropModuleList instance. During evaluation we always + iterate over all layers. + + Usage:: + + layers = LayerDropList(p=0.5, modules=[layer1, layer2, layer3]) + for layer in layers: # this might iterate over layers 1 and 3 + x = layer(x) + for layer in layers: # this might iterate over all layers + x = layer(x) + for layer in layers: # this might not iterate over any layers + x = layer(x) + + Args: + p (float): probability of dropping out each layer + modules (iterable, optional): an iterable of modules to add + """ + + def __init__(self, p, modules=None): + super().__init__(modules) + self.p = p + + def __iter__(self): + dropout_probs = torch.empty(len(self)).uniform_() + for i, m in enumerate(super().__iter__()): + if not self.training or (dropout_probs[i] > self.p): + yield m diff --git a/fairseq/fairseq/modules/layer_norm.py b/fairseq/fairseq/modules/layer_norm.py new file mode 100644 index 0000000000000000000000000000000000000000..234609d9e213a650e0032aaa0ca0462a818bfead --- /dev/null +++ b/fairseq/fairseq/modules/layer_norm.py @@ -0,0 +1,50 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +try: + from apex.normalization import FusedLayerNorm as _FusedLayerNorm + + has_fused_layernorm = True + + class FusedLayerNorm(_FusedLayerNorm): + @torch.jit.unused + def forward(self, x): + if not x.is_cuda: + return super().forward(x) + else: + with torch.cuda.device(x.device): + return super().forward(x) + + +except ImportError: + has_fused_layernorm = False + + +def LayerNorm(normalized_shape, eps=1e-5, elementwise_affine=True, export=False): + if torch.jit.is_scripting(): + export = True + if not export and torch.cuda.is_available() and has_fused_layernorm: + return FusedLayerNorm(normalized_shape, eps, elementwise_affine) + return torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine) + + +class Fp32LayerNorm(nn.LayerNorm): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def forward(self, input): + output = F.layer_norm( + input.float(), + self.normalized_shape, + self.weight.float() if self.weight is not None else None, + self.bias.float() if self.bias is not None else None, + self.eps, + ) + return output.type_as(input) diff --git a/fairseq/fairseq/modules/learned_positional_embedding.py b/fairseq/fairseq/modules/learned_positional_embedding.py new file mode 100644 index 0000000000000000000000000000000000000000..378d0f707183dd344dbb9288dda394b11053acf0 --- /dev/null +++ b/fairseq/fairseq/modules/learned_positional_embedding.py @@ -0,0 +1,61 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from torch import Tensor + + +class LearnedPositionalEmbedding(nn.Embedding): + """ + This module learns positional embeddings up to a fixed maximum size. + Padding ids are ignored by either offsetting based on padding_idx + or by setting padding_idx to None and ensuring that the appropriate + position ids are passed to the forward function. + """ + + def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int): + super().__init__(num_embeddings, embedding_dim, padding_idx) + self.onnx_trace = False + if self.padding_idx is not None: + self.max_positions = self.num_embeddings - self.padding_idx - 1 + else: + self.max_positions = self.num_embeddings + + def forward( + self, + input: Tensor, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + positions: Optional[Tensor] = None, + ): + """Input is expected to be of size [bsz x seqlen].""" + assert (positions is None) or ( + self.padding_idx is None + ), "If positions is pre-computed then padding_idx should not be set." + + if positions is None: + if incremental_state is not None: + # positions is the same for every token when decoding a single step + # Without the int() cast, it doesn't work in some cases when exporting to ONNX + positions = torch.zeros( + (1, 1), device=input.device, dtype=input.dtype + ).fill_(int(self.padding_idx + input.size(1))) + else: + positions = utils.make_positions( + input, self.padding_idx, onnx_trace=self.onnx_trace + ) + return F.embedding( + positions, + self.weight, + self.padding_idx, + self.max_norm, + self.norm_type, + self.scale_grad_by_freq, + self.sparse, + ) diff --git a/fairseq/fairseq/modules/lightconv_layer/__init__.py b/fairseq/fairseq/modules/lightconv_layer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3b2a99c1227f827768911e5e22e79f6865ffbfd3 --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .lightconv_layer import LightconvLayer # noqa diff --git a/fairseq/fairseq/modules/lightconv_layer/cuda_function_gen.py b/fairseq/fairseq/modules/lightconv_layer/cuda_function_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..a25433dd8edae2f0b52d7d0eeeb829cabc6b4b89 --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/cuda_function_gen.py @@ -0,0 +1,289 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +def gen_forward(): + + kernels = [3, 5, 7, 15, 31, 63, 127, 255] + seqs = [32 * x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]] + + head = """ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "lightconv_cuda.cuh" + +std::vector<at::Tensor> lightconv_cuda_forward(at::Tensor input, at::Tensor filters, int padding_l) { + + at::DeviceGuard g(input.device()); + const auto minibatch = input.size(0); + const auto numFeatures = input.size(1); + const auto sequenceLength = input.size(2); + + const auto numHeads = filters.size(0); + const auto filterSize = filters.size(1); + + const auto numFiltersInBlock = numFeatures / numHeads; + + const dim3 blocks(minibatch, numFeatures); + + auto output = at::zeros_like(input); + auto stream = at::cuda::getCurrentCUDAStream(); +""" + + sequence_if = """ + if (sequenceLength <= {seq}) {{ + switch(filterSize) {{ +""" + + case_k = """ + case {k}: +""" + + main_block = """ + if (padding_l == {pad}) {{ + AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.scalar_type(), "lightconv_forward", ([&] {{ + lightconv_forward_kernel<{k}, {b_size}, {pad}, scalar_t> + <<<blocks, {b_size}, 0, stream>>>( + input.data<scalar_t>(), + filters.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + output.data<scalar_t>()); + }})); + }} else +""" + + bad_padding = """ + { + std::cout << "WARNING: Unsupported padding size - skipping forward pass" << std::endl; + } + break; +""" + + bad_filter = """ + default: + std::cout << "WARNING: Unsupported filter length passed - skipping forward pass" << std::endl; + } +""" + + con_else = """ + } else +""" + + final_else = """ + { + switch(filterSize) { +""" + + final_return = """ + } + + return {output}; +} +""" + + with open("lightconv_cuda_forward.cu", "w") as forward: + forward.write(head) + for seq in seqs: + forward.write(sequence_if.format(seq=seq)) + for k in kernels: + forward.write(case_k.format(k=k)) + for pad in [k // 2, k - 1]: + forward.write(main_block.format(k=k, b_size=seq, pad=pad)) + forward.write(bad_padding) + forward.write(bad_filter) + forward.write(con_else) + + forward.write(final_else) + for k in kernels: + forward.write(case_k.format(k=k)) + for pad in [k // 2, k - 1]: + forward.write(main_block.format(k=k, b_size=seq, pad=pad)) + forward.write(bad_padding) + forward.write(bad_filter) + forward.write(final_return) + + +def gen_backward(): + + head = """ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "lightconv_cuda.cuh" + +std::vector<at::Tensor> lightconv_cuda_backward( + at::Tensor gradOutput, + int padding_l, + at::Tensor input, + at::Tensor filters) { + + // gradWrtInput + const int minibatch = input.size(0); + const int numFeatures = input.size(1); + const int sequenceLength = input.size(2); + + const int numHeads = filters.size(0); + const int filterSize = filters.size(1); + + const dim3 gradBlocks(minibatch, numFeatures); + const dim3 weightGradFirstpassShortBlocks(minibatch, numHeads); + const dim3 weightGradSecondpassBlocks(numHeads, filterSize); + + const int numFiltersInBlock = numFeatures / numHeads; + + auto gradInput = at::zeros_like(input); + auto gradFilters = at::zeros_like(filters); + + at::DeviceGuard g(input.device()); + auto stream = at::cuda::getCurrentCUDAStream(); + + switch(filterSize) { +""" + + sequence_if = """ + if (sequenceLength <= {seq}) {{ +""" + + case_k = """ + case {k}: +""" + + main_block = """ + if (padding_l == {p}) {{ + AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.scalar_type(), "lightconv_backward", ([&] {{ + lightconv_grad_wrt_input_kernel<{k}, {b_size}, {p}, scalar_t> + <<<gradBlocks, {b_size}, 0, stream>>>( + gradOutput.data<scalar_t>(), + filters.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + gradInput.data<scalar_t>()); + +""" + + weight_grad_short = """ + at::Tensor tempSumGradFilters = at::zeros({{minibatch, numHeads, filterSize}}, input.options().dtype(at::kFloat)); + lightconv_grad_wrt_weights_firstpass_short_kernel<{k}, {b_size}, {p}, scalar_t> + <<<weightGradFirstpassShortBlocks, {b_size}, 0, stream>>>( + input.data<scalar_t>(), + gradOutput.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + numHeads, + tempSumGradFilters.data<float>() + ); + + lightconv_grad_wrt_weights_secondpass_short_kernel<{k}, {b_size}, scalar_t> + <<<weightGradSecondpassBlocks, {b_size}, 0, stream>>>( + tempSumGradFilters.data<float>(), + minibatch, + numFiltersInBlock, + gradFilters.data<scalar_t>() + ); + }})); + }} else +""" + + weight_grad = """ + at::Tensor tempSumGradFilters = at::zeros({{minibatch, numFeatures, filterSize}}, input.options().dtype(at::kFloat)); + lightconv_grad_wrt_weights_firstpass_kernel<{k}, {b_size}, {p}, scalar_t> + <<<gradBlocks, {b_size}, 0, stream>>>( + input.data<scalar_t>(), + gradOutput.data<scalar_t>(), + minibatch, + sequenceLength, + numFeatures, + numFiltersInBlock, + tempSumGradFilters.data<float>() + ); + + lightconv_grad_wrt_weights_secondpass_kernel<{k}, {b_size}, scalar_t> + <<<weightGradSecondpassBlocks, {b_size}, 0, stream>>>( + tempSumGradFilters.data<float>(), + minibatch, + numFiltersInBlock, + gradFilters.data<scalar_t>() + ); + }})); + }} else +""" + + bad_padding = """ + { + std::cout << "WARNING: Unsupported padding size - skipping backward pass" << std::endl; + } +""" + + breakout = """ + break; +""" + + bad_filter = """ + default: + std::cout << "WARNING: Unsupported filter length passed - skipping backward pass" << std::endl; +""" + + con_else = """ + } else +""" + + final_else = """ + { + switch(filterSize) { +""" + + last_return = """ + } + return {gradInput, gradFilters}; +} +""" + + kernels = [3, 5, 7, 15, 31, 63, 127, 255] + seqs = [32 * x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]] + thresh = [32, 32, 64, 128, 256, -1, -1, -1] + max_mem = [-1, -1, -1, -1, -1, 192, 96, 64] + + with open("lightconv_cuda_backward.cu", "w") as backward: + backward.write(head) + for (k, t, mem) in zip(kernels, thresh, max_mem): + backward.write(case_k.format(k=k)) + for seq in seqs: + if (t == -1 or seq <= t) and (mem == -1 or seq < mem): + backward.write(sequence_if.format(seq=seq)) + for p in [k // 2, k - 1]: + backward.write(main_block.format(k=k, b_size=seq, p=p)) + backward.write(weight_grad_short.format(k=k, b_size=seq, p=p)) + backward.write(bad_padding) + else: + for p in [k // 2, k - 1]: + backward.write(main_block.format(k=k, b_size=32, p=p)) + backward.write(weight_grad.format(k=k, b_size=32, p=p)) + backward.write(bad_padding) + backward.write(breakout) + break + backward.write(con_else) + backward.write(bad_filter) + backward.write(last_return) + + +if __name__ == "__main__": + gen_forward() + gen_backward() diff --git a/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cpp b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ece47a8d908b93cec102743070c9057986d39d3f --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cpp @@ -0,0 +1,51 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <torch/extension.h> +#include <vector> + +std::vector<at::Tensor> +lightconv_cuda_forward(at::Tensor input, at::Tensor filters, int padding_l); + +std::vector<at::Tensor> lightconv_cuda_backward( + at::Tensor gradOutput, + int padding_l, + at::Tensor input, + at::Tensor filters); + +#define CHECK_CUDA(x) \ + AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) \ + AT_ASSERTM(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +std::vector<at::Tensor> +lightconv_forward(at::Tensor input, at::Tensor filters, int padding_l) { + CHECK_INPUT(input); + CHECK_INPUT(filters); + + return lightconv_cuda_forward(input, filters, padding_l); +} + +std::vector<at::Tensor> lightconv_backward( + at::Tensor gradOutput, + int padding_l, + at::Tensor input, + at::Tensor filters) { + CHECK_INPUT(gradOutput); + CHECK_INPUT(input); + CHECK_INPUT(filters); + + return lightconv_cuda_backward(gradOutput, padding_l, input, filters); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &lightconv_forward, "lighconv forward (CUDA)"); + m.def("backward", &lightconv_backward, "lighconv backward (CUDA)"); +} diff --git a/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cuh b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cuh new file mode 100644 index 0000000000000000000000000000000000000000..610ab399e9b201cd8b0fb87a91e09b6f7aab9803 --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda.cuh @@ -0,0 +1,79 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include <ATen/ATen.h> +#include <c10/cuda/CUDAStream.h> + +#include <cuda.h> +#include <cuda_runtime.h> + +#include <algorithm> +#include <functional> +#include <iostream> +#include <stdexcept> +#include <utility> +#include <vector> + +#include <assert.h> +#include <stdlib.h> + +#define SHFL_MASK 0xffffffff + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_forward_kernel( + const scalar_t* input, + const scalar_t* filters, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + scalar_t* output); + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_input_kernel( + const scalar_t* input, + const scalar_t* filters, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + scalar_t* output); + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_firstpass_short_kernel( + const scalar_t* input, + const scalar_t* gradInput, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + float* output); + +template <int FS, int SB, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_secondpass_short_kernel( + const float* input, + const int minibatch, + const int numFiltersInBlock, + scalar_t* output); + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_firstpass_kernel( + const scalar_t* input, + const scalar_t* gradInput, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + float* output); + +template <int FS, int SB, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_secondpass_kernel( + const float* input, + const int minibatch, + const int numFiltersInBlock, + scalar_t* output); diff --git a/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda_kernel.cu b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..cdf31d5d2df2d3433c66e167f098e48a99f96db2 --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/lightconv_cuda_kernel.cu @@ -0,0 +1,400 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include "../cuda_utils.cu" +#include "lightconv_cuda.cuh" +#include "lightconv_cuda_backward.cu" +#include "lightconv_cuda_forward.cu" + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_forward_kernel( + const scalar_t* input, + const scalar_t* filters, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + scalar_t* output) { + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int featureIdx = blockIdx.y; + const int filterIdx = featureIdx / numFiltersInBlock; + + const int IOOffset = + numFeatures * sequenceLength * batchIdx + featureIdx * sequenceLength; + const scalar_t* inputFeature = &input[IOOffset]; + scalar_t* outputFeature = &output[IOOffset]; + const scalar_t* inputFilter = &filters[filterIdx * FS]; + + assert(blockDim.x == SB); + + scalar_t filter[FS]; +#pragma unroll + for (int i = 0; i < FS; ++i) { + filter[i] = inputFilter[i]; + } + + __shared__ scalar_t temp[SB + FS]; + zeroSharedMem<FS, SB, padding_l>(temp); + + const int numIterations = divUp<int, int>(sequenceLength, SB); + + for (int i = 0; i < numIterations; ++i) { + // Read input into shared memory + const int inputOffset = i * SB; + + load_input_to_shared<FS, SB, padding_l>( + inputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + (numIterations == 1), + temp); + + __syncthreads(); + + scalar_t out = 0; +#pragma unroll + for (int j = 0; j < FS; ++j) { + out += filter[j] * temp[tid + j]; + } + + // Write output + const int outputOffset = inputOffset; + if ((outputOffset + tid) < sequenceLength) { + outputFeature[outputOffset + tid] = out; + } + + __syncthreads(); + } +} + +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_input_kernel( + const scalar_t* input, + const scalar_t* filters, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + scalar_t* output) { + // input grad kernel is similar to forward kernel + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int featureIdx = blockIdx.y; + const int filterIdx = featureIdx / numFiltersInBlock; + + const int IOOffset = + numFeatures * sequenceLength * batchIdx + featureIdx * sequenceLength; + const scalar_t* inputFeature = &input[IOOffset]; + scalar_t* outputFeature = &output[IOOffset]; + const scalar_t* inputFilter = &filters[filterIdx * FS]; + + assert(blockDim.x == SB); + + scalar_t filter[FS]; + +// The only change is loading the filter in reverse +#pragma unroll + for (int i = 0; i < FS; ++i) { + filter[i] = inputFilter[FS - i - 1]; + } + + __shared__ scalar_t temp[SB + FS]; + const int padding = FS - padding_l - 1; + zeroSharedMem<FS, SB, padding>(temp); + + __syncthreads(); + + const int numIterations = divUp<int, int>(sequenceLength, SB); + + for (int i = 0; i < numIterations; ++i) { + // Read input into shared memory + const int inputOffset = i * SB; + + load_input_to_shared<FS, SB, padding>( + inputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + temp); + + __syncthreads(); + + scalar_t out = 0; +#pragma unroll + for (int j = 0; j < FS; ++j) { + out += filter[j] * temp[tid + j]; + } + + // Write output + const int outputOffset = inputOffset; + if ((outputOffset + tid) < sequenceLength) { + outputFeature[outputOffset + tid] = out; + } + + __syncthreads(); + } +} + +// This is by far the most expensive kernel in terms of time taken. +// Can be 16x slower than the forward or grad_wrt_input when filter size is 31 +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_firstpass_short_kernel( + const scalar_t* input, + const scalar_t* gradInput, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + int numHeads, + float* output) { + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int filterIdx = blockIdx.y; + + const int numIterations = divUp<int, int>(sequenceLength, SB); + + float* tempOutputGradWeight = &output[filterIdx * FS * minibatch]; + + assert(blockDim.x == SB); + + __shared__ scalar_t tempInput[SB + FS]; + __shared__ scalar_t tempGradInput[SB + FS]; + + // local weight accumulation + float accumWeights[FS]; + + // Initialize memory + for (int i = 0; i < FS; ++i) { + accumWeights[i] = float(0.0); + } + + // loop over each sequence within filterblock + for (int idxInFilterBlock = 0; idxInFilterBlock < numFiltersInBlock; + ++idxInFilterBlock) { + const int featureOffset = batchIdx * numFeatures * sequenceLength + + (filterIdx * numFiltersInBlock + idxInFilterBlock) * sequenceLength; + const scalar_t* inputFeature = &input[featureOffset]; + const scalar_t* gradInputFeature = &gradInput[featureOffset]; + + zeroSharedMem<FS, SB, padding_l>(tempInput); + zeroSharedMem<FS, SB, (FS / 2)>(tempGradInput); + __syncthreads(); + + for (int i = 0; i < numIterations; ++i) { + const int inputOffset = i * SB; + + load_input_to_shared<FS, SB, padding_l>( + inputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + tempInput); + load_input_to_shared<FS, SB, (FS / 2)>( + gradInputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + tempGradInput); + + __syncthreads(); + + const int gradIndex = (FS / 2) + tid; + scalar_t tempGrad = tempGradInput[gradIndex]; + +#pragma unroll + for (int j = 0; j < FS; j++) { + const int inputIndex = tid + j; + accumWeights[j] += tempInput[inputIndex] * tempGrad; + } + + __syncthreads(); + } + } + + // Row-major sum + for (int filterWeightIdx = 0; filterWeightIdx < FS; ++filterWeightIdx) { + float temp; + if (tid < sequenceLength) { + temp = accumWeights[filterWeightIdx]; + } else { + temp = float(0.0); + } + + const int outputOffset = filterWeightIdx * minibatch + batchIdx; + + temp = blockReduce(temp); + + if (tid == 0) { + tempOutputGradWeight[outputOffset] = temp; + } + } +} + +template <int FS, int SB, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_secondpass_short_kernel( + const float* input, + const int minibatch, + const int numFiltersInBlock, + scalar_t* output) { + assert(blockDim.x == SB); + + const int tid = threadIdx.x; + + const int filterIdx = blockIdx.x; + const int filterWeightIdx = blockIdx.y; + + const int inputOffset = + filterIdx * FS * minibatch + filterWeightIdx * minibatch; + const float* tempInput = &input[inputOffset]; + + // read into shared memory for reduction + int readIndex = tid; + + float sum = 0.0; + while (readIndex < minibatch) { + sum += tempInput[readIndex]; + readIndex += SB; + } + + float temp = blockReduce(sum); + + if (tid == 0) { + output[blockIdx.x * FS + blockIdx.y] = temp; + } +} + +// This is by far the most expensive kernel in terms of time taken. +// Can be 16x slower than the forward or grad_wrt_input when filter size is 31 +template <int FS, int SB, int padding_l, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_firstpass_kernel( + const scalar_t* input, + const scalar_t* gradInput, + int minibatch, + int sequenceLength, + int numFeatures, + int numFiltersInBlock, + float* output) { + assert(blockDim.x == SB); + + const int tid = threadIdx.x; + const int batchIdx = blockIdx.x; + const int featureIdx = blockIdx.y; + const int filterIdx = featureIdx / numFiltersInBlock; + const int idxInFilterBlock = featureIdx % numFiltersInBlock; + + const int numIterations = divUp<int, int>(sequenceLength, SB); + + float temp; + + __shared__ scalar_t tempInput[SB + FS]; + __shared__ scalar_t tempGradInput[SB + FS]; + zeroSharedMem<FS, SB, padding_l>(tempInput); + zeroSharedMem<FS, SB, (FS / 2)>(tempGradInput); + __syncthreads(); + + float accumWeights[FS]; + + for (int i = 0; i < FS; ++i) { + accumWeights[i] = float(0.0); + } + + const int IOOffset = + batchIdx * numFeatures * sequenceLength + featureIdx * sequenceLength; + const scalar_t* inputFeature = &input[IOOffset]; + const scalar_t* gradInputFeature = &gradInput[IOOffset]; + float* tempOutputGradWeight = + &output[filterIdx * FS * minibatch * numFiltersInBlock]; + + for (int i = 0; i < numIterations; ++i) { + const int inputOffset = i * SB; + + load_input_to_shared<FS, SB, padding_l>( + inputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + tempInput); + load_input_to_shared<FS, SB, (FS / 2)>( + gradInputFeature, + inputOffset, + sequenceLength, + i, + numIterations, + false, + tempGradInput); + __syncthreads(); + +#pragma unroll + for (int j = 0; j < FS; ++j) { + accumWeights[j] += tempInput[tid + j] * tempGradInput[tid + (FS / 2)]; + } + + __syncthreads(); + } + + // Row-major sum + for (int filterWeightIdx = 0; filterWeightIdx < FS; ++filterWeightIdx) { + // Write to shared memory before reduction + if (tid < sequenceLength) { + temp = accumWeights[filterWeightIdx]; + } else { + temp = float(0.0); + } + + temp = blockReduce(temp); + + const int outputOffset = filterWeightIdx * minibatch * numFiltersInBlock + + batchIdx * numFiltersInBlock + idxInFilterBlock; + + if (tid == 0) { + tempOutputGradWeight[outputOffset] = temp; + } + } +} + +template <int FS, int SB, typename scalar_t> +__global__ void lightconv_grad_wrt_weights_secondpass_kernel( + const float* input, + const int minibatch, + const int numFiltersInBlock, + scalar_t* output) { + assert(blockDim.x == SB); + const int tid = threadIdx.x; + + // What is the id within a minibatch + const int filterIdx = blockIdx.x; + const int filterWeightIdx = blockIdx.y; + + const int inputOffset = filterIdx * FS * minibatch * numFiltersInBlock + + filterWeightIdx * minibatch * numFiltersInBlock; + const float* tempInput = &input[inputOffset]; + + int readIndex = tid; + + float sum = float(0.0); + while (readIndex < (minibatch * numFiltersInBlock)) { + sum += tempInput[readIndex]; + readIndex += SB; + } + + float temp = blockReduce(sum); + + if (tid == 0) { + output[blockIdx.x * FS + blockIdx.y] = temp; + } +} diff --git a/fairseq/fairseq/modules/lightconv_layer/lightconv_layer.py b/fairseq/fairseq/modules/lightconv_layer/lightconv_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..e7e597f4749c591b057d776aacec39b44d99c037 --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/lightconv_layer.py @@ -0,0 +1,137 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import lightconv_cuda +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from torch import nn +from torch.autograd import Function + + +class lightconvFunction(Function): + @staticmethod + def forward(ctx, x, weights, padding_l): + ctx.padding_l = padding_l + outputs = lightconv_cuda.forward(x, weights, padding_l) + variables = [x, weights] + ctx.save_for_backward(*variables) + return outputs[0] + + @staticmethod + def backward(ctx, grad_output): + outputs = lightconv_cuda.backward( + grad_output.contiguous(), ctx.padding_l, *ctx.saved_tensors + ) + grad_input, grad_weights = outputs + return grad_input, grad_weights, None + + +@with_incremental_state +class LightconvLayer(nn.Module): + def __init__( + self, + input_size, + kernel_size=1, + padding_l=None, + weight_softmax=False, + num_heads=1, + weight_dropout=0.0, + bias=False, + ): + super(LightconvLayer, self).__init__() + self.input_size = input_size + self.kernel_size = kernel_size + self.padding_l = padding_l + self.num_heads = num_heads + self.weight_softmax = weight_softmax + self.weight_dropout_module = FairseqDropout( + weight_dropout, module_name=self.__class__.__name__ + ) + + self.weight = nn.Parameter(torch.Tensor(num_heads, kernel_size)) + if bias: + self.bias = nn.Parameter(torch.Tensor(input_size)) + else: + self.bias = None + self.reset_parameters() + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + for k, v in state_dict.items(): + if k.endswith(prefix + "weight"): + if v.dim() == 3 and v.size(1) == 1: + state_dict[k] = v.squeeze(1) + + def reset_parameters(self): + nn.init.xavier_uniform_(self.weight) + if self.bias is not None: + nn.init.constant_(self.bias, 0.0) + + def forward(self, x, incremental_state=None): + + # during inference time, incremental BMM is faster + if incremental_state is not None: + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is None: + input_buffer = x.new() + x_unfold = torch.cat([input_buffer, x.unsqueeze(3)], dim=3) + if self.kernel_size > 1: + self._set_input_buffer( + incremental_state, x_unfold[:, :, :, -self.kernel_size + 1 :] + ) + x_unfold = x_unfold.view(T * B * H, R, -1) + + weight = self.weight + if self.weight_softmax: + weight = F.softmax(weight.float(), dim=1).type_as(weight) + + weight = weight[:, -x_unfold.size(2) :] + + K = weight.size(1) + + weight = ( + weight.view(1, H, K) + .expand(T * B, H, K) + .contiguous() + .view(T * B * H, K, 1) + ) + + weight = self.weight_dropout_module(weight) + output = torch.bmm(x_unfold, weight) # T*B*H x R x 1 + output = output.view(T, B, C) + return output + + # during training time, use CUDA kernel + else: + x = x.permute(1, 2, 0).contiguous() + weight = self.weight + if self.weight_softmax: + weight = F.softmax(self.weight, -1) + if self.weight_dropout_module.p: + weight = self.weight_dropout_module(weight) + return lightconvFunction.apply(x, weight, self.padding_l).permute(2, 0, 1) + + def reorder_incremental_state(self, incremental_state, new_order): + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + input_buffer = input_buffer.index_select(1, new_order) + self._set_input_buffer(incremental_state, input_buffer) + + def _get_input_buffer(self, incremental_state): + return utils.get_incremental_state(self, incremental_state, "input_buffer") + + def _set_input_buffer(self, incremental_state, new_buffer): + return utils.set_incremental_state( + self, incremental_state, "input_buffer", new_buffer + ) + + def half(self): + return self._apply(lambda t: t.half() if t.is_floating_point() else t) diff --git a/fairseq/fairseq/modules/lightconv_layer/setup.py b/fairseq/fairseq/modules/lightconv_layer/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..052635be79b466d0ad56cf5cf607bd10c2297ecf --- /dev/null +++ b/fairseq/fairseq/modules/lightconv_layer/setup.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + + +setup( + name="lightconv_layer", + ext_modules=[ + CUDAExtension( + "lightconv_cuda", + [ + "lightconv_cuda.cpp", + "lightconv_cuda_kernel.cu", + ], + ), + ], + cmdclass={"build_ext": BuildExtension}, +) diff --git a/fairseq/fairseq/modules/lightweight_convolution.py b/fairseq/fairseq/modules/lightweight_convolution.py new file mode 100644 index 0000000000000000000000000000000000000000..ec11a9507951c9e8f3564753841dd9c74a4900e0 --- /dev/null +++ b/fairseq/fairseq/modules/lightweight_convolution.py @@ -0,0 +1,310 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.unfold import unfold1d + + +def LightweightConv( + input_size, + kernel_size=1, + padding_l=None, + num_heads=1, + weight_dropout=0.0, + weight_softmax=False, + bias=False, +): + if torch.cuda.is_available(): + try: + from fairseq.modules.lightconv_layer import LightconvLayer + + return LightconvLayer( + input_size, + kernel_size=kernel_size, + padding_l=padding_l, + num_heads=num_heads, + weight_dropout=weight_dropout, + weight_softmax=weight_softmax, + bias=bias, + ) + except ImportError as e: + print(e) + return LightweightConv1dTBC( + input_size, + kernel_size=kernel_size, + padding_l=padding_l, + num_heads=num_heads, + weight_dropout=weight_dropout, + weight_softmax=weight_softmax, + bias=bias, + ) + + +class LightweightConv1d(nn.Module): + """Lightweight Convolution assuming the input is BxCxT + This is just an example that explains LightConv clearer than the TBC version. + We don't use this module in the model. + + Args: + input_size: # of channels of the input and output + kernel_size: convolution channels + padding: padding + num_heads: number of heads used. The weight is of shape + `(num_heads, 1, kernel_size)` + weight_softmax: normalize the weight with softmax before the convolution + + Shape: + Input: BxCxT, i.e. (batch_size, input_size, timesteps) + Output: BxCxT, i.e. (batch_size, input_size, timesteps) + + Attributes: + weight: the learnable weights of the module of shape + `(num_heads, 1, kernel_size)` + bias: the learnable bias of the module of shape `(input_size)` + """ + + def __init__( + self, + input_size, + kernel_size=1, + padding=0, + num_heads=1, + weight_softmax=False, + bias=False, + weight_dropout=0.0, + ): + super().__init__() + self.input_size = input_size + self.kernel_size = kernel_size + self.num_heads = num_heads + self.padding = padding + self.weight_softmax = weight_softmax + self.weight = nn.Parameter(torch.Tensor(num_heads, 1, kernel_size)) + + if bias: + self.bias = nn.Parameter(torch.Tensor(input_size)) + else: + self.bias = None + self.weight_dropout_module = FairseqDropout( + weight_dropout, module_name=self.__class__.__name__ + ) + self.reset_parameters() + + def reset_parameters(self): + nn.init.xavier_uniform_(self.weight) + if self.bias is not None: + nn.init.constant_(self.bias, 0.0) + + def forward(self, input): + """ + input size: B x C x T + output size: B x C x T + """ + B, C, T = input.size() + H = self.num_heads + + weight = self.weight + if self.weight_softmax: + weight = F.softmax(weight, dim=-1) + + weight = self.weight_dropout_module(weight) + # Merge every C/H entries into the batch dimension (C = self.input_size) + # B x C x T -> (B * C/H) x H x T + # One can also expand the weight to C x 1 x K by a factor of C/H + # and do not reshape the input instead, which is slow though + input = input.view(-1, H, T) + output = F.conv1d(input, weight, padding=self.padding, groups=self.num_heads) + output = output.view(B, C, T) + if self.bias is not None: + output = output + self.bias.view(1, -1, 1) + + return output + + +@with_incremental_state +class LightweightConv1dTBC(nn.Module): + """Lightweight Convolution assuming the input is TxBxC + Args: + input_size: # of channels of the input + kernel_size: convolution channels + padding_l: padding to the left when using "same" padding + num_heads: number of heads used. The weight is of shape (num_heads, 1, kernel_size) + weight_dropout: the drop rate of the DropConnect to drop the weight + weight_softmax: normalize the weight with softmax before the convolution + bias: use bias + + Shape: + Input: TxBxC, i.e. (timesteps, batch_size, input_size) + Output: TxBxC, i.e. (timesteps, batch_size, input_size) + + Attributes: + weight: the learnable weights of the module of shape + `(num_heads, 1, kernel_size)` + bias: the learnable bias of the module of shape `(input_size)` + """ + + def __init__( + self, + input_size, + kernel_size=1, + padding_l=None, + num_heads=1, + weight_dropout=0.0, + weight_softmax=False, + bias=False, + ): + super().__init__() + self.input_size = input_size + self.kernel_size = kernel_size + self.padding_l = padding_l + self.num_heads = num_heads + self.weight_dropout_module = FairseqDropout( + weight_dropout, module_name=self.__class__.__name__ + ) + self.weight_softmax = weight_softmax + + self.weight = nn.Parameter(torch.Tensor(num_heads, 1, kernel_size)) + if bias: + self.bias = nn.Parameter(torch.Tensor(input_size)) + else: + self.bias = None + + self.reset_parameters() + self.onnx_trace = False + + def reset_parameters(self): + nn.init.xavier_uniform_(self.weight) + if self.bias is not None: + nn.init.constant_(self.bias, 0.0) + + def forward(self, x, incremental_state=None, unfold=False): + """Assuming the input, x, of the shape T x B x C and producing an output in the shape T x B x C + args: + x: Input of shape T x B x C, i.e. (timesteps, batch_size, input_size) + incremental_state: A dict to keep the state + unfold: unfold the input or not. If not, we use the matrix trick instead + """ + unfold = unfold or (incremental_state is not None) + + if unfold: + output = self._forward_unfolded(x, incremental_state) + else: + output = self._forward_expanded(x, incremental_state) + + if self.bias is not None: + output = output + self.bias.view(1, 1, -1) + return output + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def _forward_unfolded(self, x, incremental_state): + """The conventional implementation of convolutions. + Unfolding the input by having a window shifting to the right.""" + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + + weight = self.weight.view(H, K) + if incremental_state is not None: + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is None: + input_buffer = x.new() + x_unfold = torch.cat([input_buffer, x.unsqueeze(3)], dim=3) + if self.kernel_size > 1: + self._set_input_buffer( + incremental_state, x_unfold[:, :, :, -self.kernel_size + 1 :] + ) + x_unfold = x_unfold.view(T * B * H, R, -1) + else: + # unfold the input: T x B x C --> T' x B x C x K + x_unfold = unfold1d(x, self.kernel_size, self.padding_l, 0) + x_unfold = x_unfold.view(T * B * H, R, K) + + if self.weight_softmax: + weight = utils.softmax(weight, dim=1, onnx_trace=self.onnx_trace).type_as( + weight + ) + + if incremental_state is not None: + weight = weight[:, -x_unfold.size(2) :] + K = weight.size(1) + + weight = ( + weight.view(1, H, K).expand(T * B, H, K).contiguous().view(T * B * H, K, 1) + ) + + weight = self.weight_dropout_module(weight) + output = torch.bmm(x_unfold, weight) # T*B*H x R x 1 + output = output.view(T, B, C) + return output + + def _forward_expanded(self, x, incremental_state): + """Turn the convolution filters into band matrices and do matrix multiplication. + This is faster when the sequence is short, but less memory efficient. + This is not used in the decoder during inference. + """ + T, B, C = x.size() + K, H = self.kernel_size, self.num_heads + R = C // H + assert R * H == C == self.input_size + + weight = self.weight.view(H, K) + if self.weight_softmax: + weight = utils.softmax(weight, dim=1, onnx_trace=self.onnx_trace).type_as( + weight + ) + weight = weight.view(1, H, K).expand(T * B, H, K).contiguous() + weight = weight.view(T, B * H, K).transpose(0, 1) + + x = x.view(T, B * H, R).transpose(0, 1) + P = self.padding_l + if K > T and P == K - 1: + weight = weight.narrow(2, K - T, T) + K, P = T, T - 1 + # turn the convolution filters into band matrices + weight_expanded = weight.new_zeros(B * H, T, T + K - 1, requires_grad=False) + weight_expanded.as_strided((B * H, T, K), (T * (T + K - 1), T + K, 1)).copy_( + weight + ) + weight_expanded = weight_expanded.narrow(2, P, T) + weight_expanded = self.weight_dropout_module(weight_expanded) + + output = torch.bmm(weight_expanded, x) + output = output.transpose(0, 1).contiguous().view(T, B, C) + return output + + def reorder_incremental_state(self, incremental_state, new_order): + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + input_buffer = input_buffer.index_select(1, new_order) + self._set_input_buffer(incremental_state, input_buffer) + + def _get_input_buffer(self, incremental_state): + return utils.get_incremental_state(self, incremental_state, "input_buffer") + + def _set_input_buffer(self, incremental_state, new_buffer): + return utils.set_incremental_state( + self, incremental_state, "input_buffer", new_buffer + ) + + def extra_repr(self): + s = "{}, kernel_size={}, padding_l={}, num_heads={}, weight_softmax={}, bias={}".format( + self.input_size, + self.kernel_size, + self.padding_l, + self.num_heads, + self.weight_softmax, + self.bias is not None, + ) + if self.weight_dropout_module.p > 0.0: + s += ", weight_dropout={}".format(self.weight_dropout_module.p) + return s diff --git a/fairseq/fairseq/modules/linearized_convolution.py b/fairseq/fairseq/modules/linearized_convolution.py new file mode 100644 index 0000000000000000000000000000000000000000..f7e156cb0c75cb375447859c8b6749311372c35e --- /dev/null +++ b/fairseq/fairseq/modules/linearized_convolution.py @@ -0,0 +1,110 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state + +from .conv_tbc import ConvTBC + +from typing import Dict, Optional +from torch import Tensor + +@with_incremental_state +class LinearizedConvolution(ConvTBC): + """An optimized version of nn.Conv1d. + + At training time, this module uses ConvTBC, which is an optimized version + of Conv1d. At inference time, it optimizes incremental generation (i.e., + one time step at a time) by replacing the convolutions with linear layers. + Note that the input order changes from training to inference. + """ + + def __init__(self, in_channels, out_channels, kernel_size, **kwargs): + super().__init__(in_channels, out_channels, kernel_size, **kwargs) + self._linearized_weight = None + self.register_backward_hook(self._clear_linearized_weight) + + def state_dict(self, destination=None, prefix="", keep_vars=False): + state = ConvTBC.state_dict(self, destination, prefix, keep_vars=keep_vars) + # don't store redundant _linearized_weight in checkpoints + if prefix + "_linearized_weight" in state: + del state[prefix + "_linearized_weight"] + return state + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + if prefix + "_linearized_weight" in state_dict: + del state_dict[prefix + "_linearized_weight"] + + @torch.jit.export + def forward(self, input, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None): + """ + Args: + incremental_state: Used to buffer signal; if not None, then input is + expected to contain a single frame. If the input order changes + between time steps, call reorder_incremental_state. + Input: + Time x Batch x Channel during training + Batch x Time x Channel during inference + """ + if incremental_state is None: + output = self.conv_tbc(input) + if self.kernel_size[0] > 1 and self.padding[0] > 0: + # remove future timesteps added by padding + output = output[: -self.padding[0], :, :] + return output + + # reshape weight + weight = self._get_linearized_weight() + kw = self.kernel_size[0] + + bsz = input.size(0) # input: bsz x len x dim + if kw > 1: + input = input.data + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is None: + input_buffer = input.new(bsz, kw, input.size(2)).zero_() + self._set_input_buffer(incremental_state, input_buffer) + else: + # shift buffer + input_buffer[:, :-1, :] = input_buffer[:, 1:, :].clone() + # append next input + input_buffer[:, -1, :] = input[:, -1, :] + input = input_buffer + with torch.no_grad(): + output = F.linear(input.view(bsz, -1), weight, self.bias) + return output.view(bsz, 1, -1) + + @torch.jit.unused + def reorder_incremental_state(self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], new_order): + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + input_buffer = input_buffer.index_select(0, new_order) + self._set_input_buffer(incremental_state, input_buffer) + + @torch.jit.unused + def _get_input_buffer(self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]): + return utils.get_incremental_state(self, incremental_state, "input_buffer") + + @torch.jit.unused + def _set_input_buffer(self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], new_buffer): + return utils.set_incremental_state( + self, incremental_state, "input_buffer", new_buffer + ) + + @torch.jit.unused + def _get_linearized_weight(self): + if self._linearized_weight is None: + kw = self.kernel_size[0] + weight = self.weight.transpose(2, 1).transpose(1, 0).contiguous() + assert weight.size() == (self.out_channels, kw, self.in_channels) + return weight.view(self.out_channels, -1) + return self._linearized_weight + + @torch.jit.unused + def _clear_linearized_weight(self, *args): + self._linearized_weight = None diff --git a/fairseq/fairseq/modules/location_attention.py b/fairseq/fairseq/modules/location_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..a970876bba4369a93245fe73bd963566bfe4d63d --- /dev/null +++ b/fairseq/fairseq/modules/location_attention.py @@ -0,0 +1,72 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +import torch +import torch.nn.functional as F + + +class LocationAttention(nn.Module): + """ + Attention-Based Models for Speech Recognition + https://arxiv.org/pdf/1506.07503.pdf + + :param int encoder_dim: # projection-units of encoder + :param int decoder_dim: # units of decoder + :param int attn_dim: attention dimension + :param int conv_dim: # channels of attention convolution + :param int conv_kernel_size: filter size of attention convolution + """ + + def __init__(self, attn_dim, encoder_dim, decoder_dim, + attn_state_kernel_size, conv_dim, conv_kernel_size, + scaling=2.0): + super(LocationAttention, self).__init__() + self.attn_dim = attn_dim + self.decoder_dim = decoder_dim + self.scaling = scaling + self.proj_enc = nn.Linear(encoder_dim, attn_dim) + self.proj_dec = nn.Linear(decoder_dim, attn_dim, bias=False) + self.proj_attn = nn.Linear(conv_dim, attn_dim, bias=False) + self.conv = nn.Conv1d(attn_state_kernel_size, conv_dim, + 2 * conv_kernel_size + 1, + padding=conv_kernel_size, bias=False) + self.proj_out = nn.Sequential(nn.Tanh(), nn.Linear(attn_dim, 1)) + + self.proj_enc_out = None # cache + + def clear_cache(self): + self.proj_enc_out = None + + def forward(self, encoder_out, encoder_padding_mask, decoder_h, attn_state): + """ + :param torch.Tensor encoder_out: padded encoder hidden state B x T x D + :param torch.Tensor encoder_padding_mask: encoder padding mask + :param torch.Tensor decoder_h: decoder hidden state B x D + :param torch.Tensor attn_prev: previous attention weight B x K x T + :return: attention weighted encoder state (B, D) + :rtype: torch.Tensor + :return: previous attention weights (B x T) + :rtype: torch.Tensor + """ + bsz, seq_len, _ = encoder_out.size() + if self.proj_enc_out is None: + self.proj_enc_out = self.proj_enc(encoder_out) + + # B x K x T -> B x C x T + attn = self.conv(attn_state) + # B x C x T -> B x T x C -> B x T x D + attn = self.proj_attn(attn.transpose(1, 2)) + + if decoder_h is None: + decoder_h = encoder_out.new_zeros(bsz, self.decoder_dim) + dec_h = self.proj_dec(decoder_h).view(bsz, 1, self.attn_dim) + + out = self.proj_out(attn + self.proj_enc_out + dec_h).squeeze(2) + out.masked_fill_(encoder_padding_mask, -float("inf")) + + w = F.softmax(self.scaling * out, dim=1) + c = torch.sum(encoder_out * w.view(bsz, seq_len, 1), dim=1) + return c, w diff --git a/fairseq/fairseq/modules/lstm_cell_with_zoneout.py b/fairseq/fairseq/modules/lstm_cell_with_zoneout.py new file mode 100644 index 0000000000000000000000000000000000000000..f04e5db255c62bbe0faebbc641f579f92be5580c --- /dev/null +++ b/fairseq/fairseq/modules/lstm_cell_with_zoneout.py @@ -0,0 +1,37 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn + + +class LSTMCellWithZoneOut(nn.Module): + """ + Zoneout: Regularizing RNNs by Randomly Preserving Hidden Activations + https://arxiv.org/abs/1606.01305 + """ + + def __init__(self, prob: float, input_size: int, hidden_size: int, + bias: bool = True): + super(LSTMCellWithZoneOut, self).__init__() + self.lstm_cell = nn.LSTMCell(input_size, hidden_size, bias=bias) + self.prob = prob + if prob > 1.0 or prob < 0.0: + raise ValueError("zoneout probability must be in the range from " + "0.0 to 1.0.") + + def zoneout(self, h, next_h, prob): + if isinstance(h, tuple): + return tuple( + [self.zoneout(h[i], next_h[i], prob) for i in range(len(h))] + ) + + if self.training: + mask = h.new_zeros(*h.size()).bernoulli_(prob) + return mask * h + (1 - mask) * next_h + + return prob * h + (1 - prob) * next_h + + def forward(self, x, h): + return self.zoneout(h, self.lstm_cell(x, h), self.prob) diff --git a/fairseq/fairseq/modules/multihead_attention.py b/fairseq/fairseq/modules/multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..a2516356117847b0d46d965ee942354a2ed23189 --- /dev/null +++ b/fairseq/fairseq/modules/multihead_attention.py @@ -0,0 +1,500 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Dict, Optional, Tuple + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise +from torch import Tensor, nn +from torch.nn import Parameter + + +@with_incremental_state +class MultiheadAttention(nn.Module): + """Multi-headed attention. + + See "Attention Is All You Need" for more details. + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + self_attention=False, + encoder_decoder_attention=False, + q_noise=0.0, + qn_block_size=8, + ): + super().__init__() + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim + + self.num_heads = num_heads + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.scaling = self.head_dim ** -0.5 + + self.self_attention = self_attention + self.encoder_decoder_attention = encoder_decoder_attention + + assert not self.self_attention or self.qkv_same_dim, ( + "Self-attention requires query, key and " "value to be of the same size" + ) + + self.k_proj = quant_noise( + nn.Linear(self.kdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.v_proj = quant_noise( + nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.q_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + self.out_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + if add_bias_kv: + self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim)) + self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim)) + else: + self.bias_k = self.bias_v = None + + self.add_zero_attn = add_zero_attn + + self.reset_parameters() + + self.onnx_trace = False + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def reset_parameters(self): + if self.qkv_same_dim: + # Empirically observed the convergence to be much better with + # the scaled initialization + nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2)) + else: + nn.init.xavier_uniform_(self.k_proj.weight) + nn.init.xavier_uniform_(self.v_proj.weight) + nn.init.xavier_uniform_(self.q_proj.weight) + + nn.init.xavier_uniform_(self.out_proj.weight) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.xavier_normal_(self.bias_k) + if self.bias_v is not None: + nn.init.xavier_normal_(self.bias_v) + + def forward( + self, + query, + key: Optional[Tensor], + value: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + need_weights: bool = True, + static_kv: bool = False, + attn_mask: Optional[Tensor] = None, + before_softmax: bool = False, + need_head_weights: bool = False, + ) -> Tuple[Tensor, Optional[Tensor]]: + """Input shape: Time x Batch x Channel + + Args: + key_padding_mask (ByteTensor, optional): mask to exclude + keys that are pads, of shape `(batch, src_len)`, where + padding elements are indicated by 1s. + need_weights (bool, optional): return the attention weights, + averaged over heads (default: False). + attn_mask (ByteTensor, optional): typically used to + implement causal attention, where the mask prevents the + attention from looking forward in time (default: None). + before_softmax (bool, optional): return the raw attention + weights and values before the attention softmax. + need_head_weights (bool, optional): return the attention + weights for each head. Implies *need_weights*. Default: + return the average attention weights over all heads. + """ + if need_head_weights: + need_weights = True + + is_tpu = query.device.type == "xla" + + tgt_len, bsz, embed_dim = query.size() + src_len = tgt_len + assert embed_dim == self.embed_dim, f"query dim {embed_dim} != {self.embed_dim}" + assert list(query.size()) == [tgt_len, bsz, embed_dim] + if key is not None: + src_len, key_bsz, _ = key.size() + if not torch.jit.is_scripting(): + assert key_bsz == bsz + assert value is not None + assert src_len, bsz == value.shape[:2] + + if ( + not self.onnx_trace + and not is_tpu # don't use PyTorch version on TPUs + and incremental_state is None + and not static_kv + # A workaround for quantization to work. Otherwise JIT compilation + # treats bias in linear module as method. + and not torch.jit.is_scripting() + ): + assert key is not None and value is not None + return F.multi_head_attention_forward( + query, + key, + value, + self.embed_dim, + self.num_heads, + torch.empty([0]), + torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)), + self.bias_k, + self.bias_v, + self.add_zero_attn, + self.dropout_module.p, + self.out_proj.weight, + self.out_proj.bias, + self.training or self.dropout_module.apply_during_inference, + key_padding_mask, + need_weights, + attn_mask, + use_separate_proj_weight=True, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + ) + + if incremental_state is not None: + saved_state = self._get_input_buffer(incremental_state) + if saved_state is not None and "prev_key" in saved_state: + # previous time steps are cached - no need to recompute + # key and value if they are static + if static_kv: + assert self.encoder_decoder_attention and not self.self_attention + key = value = None + else: + saved_state = None + + if self.self_attention: + q = self.q_proj(query) + k = self.k_proj(query) + v = self.v_proj(query) + elif self.encoder_decoder_attention: + # encoder-decoder attention + q = self.q_proj(query) + if key is None: + assert value is None + k = v = None + else: + k = self.k_proj(key) + v = self.v_proj(key) + + else: + assert key is not None and value is not None + q = self.q_proj(query) + k = self.k_proj(key) + v = self.v_proj(value) + q *= self.scaling + + if self.bias_k is not None: + assert self.bias_v is not None + k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + if key_padding_mask is not None: + key_padding_mask = torch.cat( + [ + key_padding_mask, + key_padding_mask.new_zeros(key_padding_mask.size(0), 1), + ], + dim=1, + ) + + q = ( + q.contiguous() + .view(tgt_len, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if k is not None: + k = ( + k.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if v is not None: + v = ( + v.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + if saved_state is not None: + # saved states are stored with shape (bsz, num_heads, seq_len, head_dim) + if "prev_key" in saved_state: + _prev_key = saved_state["prev_key"] + assert _prev_key is not None + prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + k = prev_key + else: + assert k is not None + k = torch.cat([prev_key, k], dim=1) + src_len = k.size(1) + if "prev_value" in saved_state: + _prev_value = saved_state["prev_value"] + assert _prev_value is not None + prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + v = prev_value + else: + assert v is not None + v = torch.cat([prev_value, v], dim=1) + prev_key_padding_mask: Optional[Tensor] = None + if "prev_key_padding_mask" in saved_state: + prev_key_padding_mask = saved_state["prev_key_padding_mask"] + assert k is not None and v is not None + key_padding_mask = MultiheadAttention._append_prev_key_padding_mask( + key_padding_mask=key_padding_mask, + prev_key_padding_mask=prev_key_padding_mask, + batch_size=bsz, + src_len=k.size(1), + static_kv=static_kv, + ) + + saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_key_padding_mask"] = key_padding_mask + # In this branch incremental_state is never None + assert incremental_state is not None + incremental_state = self._set_input_buffer(incremental_state, saved_state) + assert k is not None + assert k.size(1) == src_len + + # This is part of a workaround to get around fork/join parallelism + # not supporting Optional types. + if key_padding_mask is not None and key_padding_mask.dim() == 0: + key_padding_mask = None + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == src_len + + if self.add_zero_attn: + assert v is not None + src_len += 1 + k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1) + v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + if key_padding_mask is not None: + key_padding_mask = torch.cat( + [ + key_padding_mask, + torch.zeros(key_padding_mask.size(0), 1).type_as( + key_padding_mask + ), + ], + dim=1, + ) + + attn_weights = torch.bmm(q, k.transpose(1, 2)) + attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz) + + assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len] + + if attn_mask is not None: + attn_mask = attn_mask.unsqueeze(0) + if self.onnx_trace: + attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1) + attn_weights += attn_mask + + if key_padding_mask is not None: + # don't attend to padding symbols + attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + if not is_tpu: + attn_weights = attn_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool), + float("-inf"), + ) + else: + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf")) + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len) + + if before_softmax: + return attn_weights, v + + attn_weights_float = utils.softmax( + attn_weights, dim=-1, onnx_trace=self.onnx_trace + ) + attn_weights = attn_weights_float.type_as(attn_weights) + attn_probs = self.dropout_module(attn_weights) + + assert v is not None + attn = torch.bmm(attn_probs, v) + assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim] + if self.onnx_trace and attn.size(1) == 1: + # when ONNX tracing a single decoder step (sequence length == 1) + # the transpose is a no-op copy before view, thus unnecessary + attn = attn.contiguous().view(tgt_len, bsz, embed_dim) + else: + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim) + attn = self.out_proj(attn) + attn_weights: Optional[Tensor] = None + if need_weights: + attn_weights = attn_weights_float.view( + bsz, self.num_heads, tgt_len, src_len + ).transpose(1, 0) + if not need_head_weights: + # average attention weights over heads + attn_weights = attn_weights.mean(dim=0) + + return attn, attn_weights + + @staticmethod + def _append_prev_key_padding_mask( + key_padding_mask: Optional[Tensor], + prev_key_padding_mask: Optional[Tensor], + batch_size: int, + src_len: int, + static_kv: bool, + ) -> Optional[Tensor]: + # saved key padding masks have shape (bsz, seq_len) + if prev_key_padding_mask is not None and static_kv: + new_key_padding_mask = prev_key_padding_mask + elif prev_key_padding_mask is not None and key_padding_mask is not None: + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1 + ) + # During incremental decoding, as the padding token enters and + # leaves the frame, there will be a time when prev or current + # is None + elif prev_key_padding_mask is not None: + if src_len > prev_key_padding_mask.size(1): + filler = torch.zeros( + (batch_size, src_len - prev_key_padding_mask.size(1)), + device=prev_key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), filler.float()], dim=1 + ) + else: + new_key_padding_mask = prev_key_padding_mask.float() + elif key_padding_mask is not None: + if src_len > key_padding_mask.size(1): + filler = torch.zeros( + (batch_size, src_len - key_padding_mask.size(1)), + device=key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [filler.float(), key_padding_mask.float()], dim=1 + ) + else: + new_key_padding_mask = key_padding_mask.float() + else: + new_key_padding_mask = prev_key_padding_mask + return new_key_padding_mask + + @torch.jit.export + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + """Reorder buffered internal state (for incremental generation).""" + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + for k in input_buffer.keys(): + input_buffer_k = input_buffer[k] + if input_buffer_k is not None: + if self.encoder_decoder_attention and input_buffer_k.size( + 0 + ) == new_order.size(0): + break + input_buffer[k] = input_buffer_k.index_select(0, new_order) + incremental_state = self._set_input_buffer(incremental_state, input_buffer) + return incremental_state + + def _get_input_buffer( + self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] + ) -> Dict[str, Optional[Tensor]]: + result = self.get_incremental_state(incremental_state, "attn_state") + if result is not None: + return result + else: + empty_result: Dict[str, Optional[Tensor]] = {} + return empty_result + + def _set_input_buffer( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + buffer: Dict[str, Optional[Tensor]], + ): + return self.set_incremental_state(incremental_state, "attn_state", buffer) + + def apply_sparse_mask(self, attn_weights, tgt_len: int, src_len: int, bsz: int): + return attn_weights + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + items_to_add = {} + keys_to_remove = [] + for k in state_dict.keys(): + if k.endswith(prefix + "in_proj_weight"): + # in_proj_weight used to be q + k + v with same dimensions + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim] + items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim] + items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :] + + keys_to_remove.append(k) + + k_bias = prefix + "in_proj_bias" + if k_bias in state_dict.keys(): + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim] + items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][ + dim : 2 * dim + ] + items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :] + + keys_to_remove.append(prefix + "in_proj_bias") + + for k in keys_to_remove: + del state_dict[k] + + for key, value in items_to_add.items(): + state_dict[key] = value diff --git a/fairseq/fairseq/modules/positional_embedding.py b/fairseq/fairseq/modules/positional_embedding.py new file mode 100644 index 0000000000000000000000000000000000000000..8e94e35edb46bf9dea911fe74577d8ecbe9b5ff1 --- /dev/null +++ b/fairseq/fairseq/modules/positional_embedding.py @@ -0,0 +1,35 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn + +from .learned_positional_embedding import LearnedPositionalEmbedding +from .sinusoidal_positional_embedding import SinusoidalPositionalEmbedding + + +def PositionalEmbedding( + num_embeddings: int, + embedding_dim: int, + padding_idx: int, + learned: bool = False, +): + if learned: + # if padding_idx is specified then offset the embedding ids by + # this index and adjust num_embeddings appropriately + # TODO: The right place for this offset would be inside + # LearnedPositionalEmbedding. Move this there for a cleaner implementation. + if padding_idx is not None: + num_embeddings = num_embeddings + padding_idx + 1 + m = LearnedPositionalEmbedding(num_embeddings, embedding_dim, padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + if padding_idx is not None: + nn.init.constant_(m.weight[padding_idx], 0) + else: + m = SinusoidalPositionalEmbedding( + embedding_dim, + padding_idx, + init_size=num_embeddings + padding_idx + 1, + ) + return m diff --git a/fairseq/fairseq/modules/quant_noise.py b/fairseq/fairseq/modules/quant_noise.py new file mode 100644 index 0000000000000000000000000000000000000000..d777dfbb6c1bf6a9b769dfdaec35d5ef084c8a8b --- /dev/null +++ b/fairseq/fairseq/modules/quant_noise.py @@ -0,0 +1,107 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn + + +def quant_noise(module, p, block_size): + """ + Wraps modules and applies quantization noise to the weights for + subsequent quantization with Iterative Product Quantization as + described in "Training with Quantization Noise for Extreme Model Compression" + + Args: + - module: nn.Module + - p: amount of Quantization Noise + - block_size: size of the blocks for subsequent quantization with iPQ + + Remarks: + - Module weights must have the right sizes wrt the block size + - Only Linear, Embedding and Conv2d modules are supported for the moment + - For more detail on how to quantize by blocks with convolutional weights, + see "And the Bit Goes Down: Revisiting the Quantization of Neural Networks" + - We implement the simplest form of noise here as stated in the paper + which consists in randomly dropping blocks + """ + + # if no quantization noise, don't register hook + if p <= 0: + return module + + # supported modules + assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d)) + + # test whether module.weight has the right sizes wrt block_size + is_conv = module.weight.ndim == 4 + + # 2D matrix + if not is_conv: + assert ( + module.weight.size(1) % block_size == 0 + ), "Input features must be a multiple of block sizes" + + # 4D matrix + else: + # 1x1 convolutions + if module.kernel_size == (1, 1): + assert ( + module.in_channels % block_size == 0 + ), "Input channels must be a multiple of block sizes" + # regular convolutions + else: + k = module.kernel_size[0] * module.kernel_size[1] + assert k % block_size == 0, "Kernel size must be a multiple of block size" + + def _forward_pre_hook(mod, input): + # no noise for evaluation + if mod.training: + if not is_conv: + # gather weight and sizes + weight = mod.weight + in_features = weight.size(1) + out_features = weight.size(0) + + # split weight matrix into blocks and randomly drop selected blocks + mask = torch.zeros( + in_features // block_size * out_features, device=weight.device + ) + mask.bernoulli_(p) + mask = mask.repeat_interleave(block_size, -1).view(-1, in_features) + + else: + # gather weight and sizes + weight = mod.weight + in_channels = mod.in_channels + out_channels = mod.out_channels + + # split weight matrix into blocks and randomly drop selected blocks + if mod.kernel_size == (1, 1): + mask = torch.zeros( + int(in_channels // block_size * out_channels), + device=weight.device, + ) + mask.bernoulli_(p) + mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels) + else: + mask = torch.zeros( + weight.size(0), weight.size(1), device=weight.device + ) + mask.bernoulli_(p) + mask = ( + mask.unsqueeze(2) + .unsqueeze(3) + .repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1]) + ) + + # scale weights and apply mask + mask = mask.to( + torch.bool + ) # x.bool() is not currently supported in TorchScript + s = 1 / (1 - p) + mod.weight.data = s * weight.masked_fill(mask, 0) + + module.register_forward_pre_hook(_forward_pre_hook) + return module diff --git a/fairseq/fairseq/modules/quantization/__init__.py b/fairseq/fairseq/modules/quantization/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/fairseq/modules/quantization/pq/__init__.py b/fairseq/fairseq/modules/quantization/pq/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c142a802e05ec7ecfa5dba7d9a98c26a60ac75d2 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .utils import SizeTracker, get_param, attrsetter, quantize_model_ # NOQA diff --git a/fairseq/fairseq/modules/quantization/pq/em.py b/fairseq/fairseq/modules/quantization/pq/em.py new file mode 100644 index 0000000000000000000000000000000000000000..6f15c3e46bd052b1e00929e7ece9355fb03846c7 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/em.py @@ -0,0 +1,211 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import random +from collections import Counter + +import torch + + +class EM: + """ + EM algorithm used to quantize the columns of W to minimize + + ||W - W_hat||^2 + + Args: + - W: weight matrix of size (in_features x out_features) + - n_iter: number of k-means iterations + - n_centroids: number of centroids (size of codebook) + - eps: for cluster reassignment when an empty cluster is found + - max_tentatives for cluster reassignment when an empty cluster is found + - verbose: print error after each iteration + + Remarks: + - If one cluster is empty, the most populated cluster is split into + two clusters + - All the relevant dimensions are specified in the code + """ + + def __init__( + self, W, n_centroids=256, n_iter=20, eps=1e-6, max_tentatives=30, verbose=True + ): + self.W = W + self.n_centroids = n_centroids + self.n_iter = n_iter + self.eps = eps + self.max_tentatives = max_tentatives + self.verbose = verbose + self.centroids = torch.Tensor() + self.assignments = torch.Tensor() + self.objective = [] + + def initialize_centroids(self): + """ + Initializes the centroids by sampling random columns from W. + """ + + in_features, out_features = self.W.size() + indices = torch.randint( + low=0, high=out_features, size=(self.n_centroids,) + ).long() + self.centroids = self.W[:, indices].t() # (n_centroids x in_features) + + def step(self, i): + """ + There are two standard steps for each iteration: expectation (E) and + minimization (M). The E-step (assignment) is performed with an exhaustive + search and the M-step (centroid computation) is performed with + the exact solution. + + Args: + - i: step number + + Remarks: + - The E-step heavily uses PyTorch broadcasting to speed up computations + and reduce the memory overhead + """ + + # assignments (E-step) + distances = self.compute_distances() # (n_centroids x out_features) + self.assignments = torch.argmin(distances, dim=0) # (out_features) + n_empty_clusters = self.resolve_empty_clusters() + + # centroids (M-step) + for k in range(self.n_centroids): + W_k = self.W[:, self.assignments == k] # (in_features x size_of_cluster_k) + self.centroids[k] = W_k.mean(dim=1) # (in_features) + + # book-keeping + obj = (self.centroids[self.assignments].t() - self.W).norm(p=2).item() + self.objective.append(obj) + if self.verbose: + logging.info( + f"Iteration: {i},\t" + f"objective: {obj:.6f},\t" + f"resolved empty clusters: {n_empty_clusters}" + ) + + def resolve_empty_clusters(self): + """ + If one cluster is empty, the most populated cluster is split into + two clusters by shifting the respective centroids. This is done + iteratively for a fixed number of tentatives. + """ + + # empty clusters + counts = Counter(map(lambda x: x.item(), self.assignments)) + empty_clusters = set(range(self.n_centroids)) - set(counts.keys()) + n_empty_clusters = len(empty_clusters) + + tentatives = 0 + while len(empty_clusters) > 0: + # given an empty cluster, find most populated cluster and split it into two + k = random.choice(list(empty_clusters)) + m = counts.most_common(1)[0][0] + e = torch.randn_like(self.centroids[m]) * self.eps + self.centroids[k] = self.centroids[m].clone() + self.centroids[k] += e + self.centroids[m] -= e + + # recompute assignments + distances = self.compute_distances() # (n_centroids x out_features) + self.assignments = torch.argmin(distances, dim=0) # (out_features) + + # check for empty clusters + counts = Counter(map(lambda x: x.item(), self.assignments)) + empty_clusters = set(range(self.n_centroids)) - set(counts.keys()) + + # increment tentatives + if tentatives == self.max_tentatives: + logging.info( + f"Could not resolve all empty clusters, {len(empty_clusters)} remaining" + ) + raise EmptyClusterResolveError + tentatives += 1 + + return n_empty_clusters + + def compute_distances(self): + """ + For every centroid m, computes + + ||M - m[None, :]||_2 + + Remarks: + - We rely on PyTorch's broadcasting to speed up computations + and reduce the memory overhead + - Without chunking, the sizes in the broadcasting are modified as: + (n_centroids x n_samples x out_features) -> (n_centroids x out_features) + - The broadcasting computation is automatically chunked so that + the tensors fit into the memory of the GPU + """ + + nb_centroids_chunks = 1 + + while True: + try: + return torch.cat( + [ + (self.W[None, :, :] - centroids_c[:, :, None]).norm(p=2, dim=1) + for centroids_c in self.centroids.chunk( + nb_centroids_chunks, dim=0 + ) + ], + dim=0, + ) + except RuntimeError: + nb_centroids_chunks *= 2 + + def assign(self): + """ + Assigns each column of W to its closest centroid, thus essentially + performing the E-step in train(). + + Remarks: + - The function must be called after train() or after loading + centroids using self.load(), otherwise it will return empty tensors + """ + + distances = self.compute_distances() # (n_centroids x out_features) + self.assignments = torch.argmin(distances, dim=0) # (out_features) + + def save(self, path, layer): + """ + Saves centroids and assignments. + + Args: + - path: folder used to save centroids and assignments + """ + + torch.save(self.centroids, os.path.join(path, "{}_centroids.pth".format(layer))) + torch.save( + self.assignments, os.path.join(path, "{}_assignments.pth".format(layer)) + ) + torch.save(self.objective, os.path.join(path, "{}_objective.pth".format(layer))) + + def load(self, path, layer): + """ + Loads centroids and assignments from a given path + + Args: + - path: folder use to load centroids and assignments + """ + + self.centroids = torch.load( + os.path.join(path, "{}_centroids.pth".format(layer)) + ) + self.assignments = torch.load( + os.path.join(path, "{}_assignments.pth".format(layer)) + ) + self.objective = torch.load( + os.path.join(path, "{}_objective.pth".format(layer)) + ) + + +class EmptyClusterResolveError(Exception): + pass diff --git a/fairseq/fairseq/modules/quantization/pq/modules/__init__.py b/fairseq/fairseq/modules/quantization/pq/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b67c8e8ad691aa01e9e10e904d69d94595387668 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/modules/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .qconv import PQConv2d # NOQA +from .qemb import PQEmbedding # NOQA +from .qlinear import PQLinear # NOQA diff --git a/fairseq/fairseq/modules/quantization/pq/modules/qconv.py b/fairseq/fairseq/modules/quantization/pq/modules/qconv.py new file mode 100644 index 0000000000000000000000000000000000000000..d15ec192e8cda6265a198e583a9bf7fb194dd129 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/modules/qconv.py @@ -0,0 +1,115 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn.modules.utils import _pair + + +class PQConv2d(nn.Module): + """ + Quantized counterpart of nn.Conv2d module. Stores the centroid, the assignments + and the non-quantized biases. The full weight is re-instantiated at each forward + pass and autograd automatically computes the gradients with respect to the + centroids. + + Args: + - centroids: centroids of size n_centroids x block_size + - assignments: assignments of the centroids to the subvectors + of size self.out_channels x n_blocks + - bias: the non-quantized bias, must be either torch.Tensor or None + + Remarks: + - We refer the reader to the official documentation of the nn.Conv2d module + for the other arguments and the behavior of the module. + - Performance tests on GPU show that this implementation is 10% slower than + the non-quantized nn.Conv2d module for a standard training loop. + - During the backward, the gradients are averaged by cluster and not summed. + This explains the hook registered to the centroids. + """ + + def __init__( + self, + centroids, + assignments, + bias, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + padding_mode="zeros", + ): + super(PQConv2d, self).__init__() + self.block_size = centroids.size(1) + self.n_centroids = centroids.size(0) + self.in_channels = in_channels + self.out_channels = out_channels + self.kernel_size = _pair(kernel_size) + self.stride = _pair(stride) + self.padding = _pair(padding) + self.dilation = _pair(dilation) + self.groups = groups + self.padding_mode = padding_mode + # check compatibility + if in_channels // groups * np.prod(self.kernel_size) % self.block_size != 0: + raise ValueError("Wrong PQ sizes") + if len(assignments) % out_channels != 0: + raise ValueError("Wrong PQ sizes") + if in_channels % groups != 0: + raise ValueError("in_channels must be divisible by groups") + if out_channels % groups != 0: + raise ValueError("out_channels must be divisible by groups") + # define parameters + self.centroids = nn.Parameter(centroids, requires_grad=True) + self.register_buffer("assignments", assignments) + self.register_buffer("counts", torch.bincount(assignments).type_as(centroids)) + if bias is not None: + self.bias = nn.Parameter(bias) + else: + self.register_parameter("bias", None) + # register hook for averaging gradients per centroids instead of summing + self.centroids.register_hook(lambda x: x / self.counts[:, None]) + + @property + def weight(self): + return ( + self.centroids[self.assignments] + .reshape(-1, self.out_channels, self.block_size) + .permute(1, 0, 2) + .reshape( + self.out_channels, self.in_channels // self.groups, *self.kernel_size + ) + ) + + def forward(self, x): + return F.conv2d( + x, + self.weight, + self.bias, + self.stride, + self.padding, + self.dilation, + self.groups, + ) + + def extra_repr(self): + s = "{in_channels}, {out_channels}, kernel_size={kernel_size}, stride={stride}" + if self.padding != (0,) * len(self.padding): + s += ", padding={padding}" + if self.dilation != (1,) * len(self.dilation): + s += ", dilation={dilation}" + if self.groups != 1: + s += ", groups={groups}" + if self.bias is None: + s += ", bias=False" + if self.padding_mode != "zeros": + s += ", padding_mode={padding_mode}" + s += ", n_centroids={n_centroids}, block_size={block_size}" + return s.format(**self.__dict__) diff --git a/fairseq/fairseq/modules/quantization/pq/modules/qemb.py b/fairseq/fairseq/modules/quantization/pq/modules/qemb.py new file mode 100644 index 0000000000000000000000000000000000000000..3a74ad3c4c7c9d3203d26e7885864ba578951bfe --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/modules/qemb.py @@ -0,0 +1,107 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class PQEmbedding(nn.Module): + """ + Quantized counterpart of nn.Embedding module. Stores the centroids and + the assignments. The full weight is re-instantiated at each forward + pass. + + Args: + - centroids: centroids of size n_centroids x block_size + - assignments: assignments of the centroids to the subvectors + of size self.out_features x n_blocks + - bias: the non-quantized bias + + Remarks: + - We refer the reader to the official documentation of the nn.Embedding module + for the other arguments and the behavior of the module + - Performance tests on GPU show that this implementation is 10% slower than + the non-quantized nn.Embedding module for a standard training loop. + """ + + def __init__( + self, + centroids, + assignments, + num_embeddings, + embedding_dim, + padding_idx=None, + max_norm=None, + norm_type=2.0, + scale_grad_by_freq=False, + sparse=False, + _weight=None, + ): + super(PQEmbedding, self).__init__() + self.block_size = centroids.size(1) + self.n_centroids = centroids.size(0) + self.num_embeddings = num_embeddings + self.embedding_dim = embedding_dim + if padding_idx is not None: + if padding_idx > 0: + assert ( + padding_idx < self.num_embeddings + ), "Padding_idx must be within num_embeddings" + elif padding_idx < 0: + assert ( + padding_idx >= -self.num_embeddings + ), "Padding_idx must be within num_embeddings" + padding_idx = self.num_embeddings + padding_idx + self.padding_idx = padding_idx + self.max_norm = max_norm + self.norm_type = norm_type + self.scale_grad_by_freq = scale_grad_by_freq + self.sparse = sparse + # check compatibility + if self.embedding_dim % self.block_size != 0: + raise ValueError("Wrong PQ sizes") + if len(assignments) % self.num_embeddings != 0: + raise ValueError("Wrong PQ sizes") + # define parameters + self.centroids = nn.Parameter(centroids, requires_grad=True) + self.register_buffer("assignments", assignments) + self.register_buffer("counts", torch.bincount(assignments).type_as(centroids)) + + @property + def weight(self): + return ( + self.centroids[self.assignments] + .reshape(-1, self.num_embeddings, self.block_size) + .permute(1, 0, 2) + .flatten(1, 2) + ) + + def forward(self, input): + return F.embedding( + input, + self.weight, + self.padding_idx, + self.max_norm, + self.norm_type, + self.scale_grad_by_freq, + self.sparse, + ) + + def extra_repr(self): + s = "{num_embeddings}, {embedding_dim}" + if self.padding_idx is not None: + s += ", padding_idx={padding_idx}" + if self.max_norm is not None: + s += ", max_norm={max_norm}" + if self.norm_type != 2: + s += ", norm_type={norm_type}" + if self.scale_grad_by_freq is not False: + s += ", scale_grad_by_freq={scale_grad_by_freq}" + if self.sparse is not False: + s += ", sparse=True" + s += ", n_centroids={n_centroids}, block_size={block_size}" + + return s.format(**self.__dict__) diff --git a/fairseq/fairseq/modules/quantization/pq/modules/qlinear.py b/fairseq/fairseq/modules/quantization/pq/modules/qlinear.py new file mode 100644 index 0000000000000000000000000000000000000000..9bdd25a8685bb7c7b32e1f02372aaeb26d8ba53a --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/modules/qlinear.py @@ -0,0 +1,71 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class PQLinear(nn.Module): + """ + Quantized counterpart of nn.Linear module. Stores the centroid, the assignments + and the non-quantized biases. The full weight is re-instantiated at each forward + pass. + + Args: + - centroids: centroids of size n_centroids x block_size + - assignments: assignments of the centroids to the subvectors + of size self.out_features x n_blocks + - bias: the non-quantized bias + + Remarks: + - We refer the reader to the official documentation of the nn.Linear module + for the other arguments and the behavior of the module + - Performance tests on GPU show that this implementation is 15% slower than + the non-quantized nn.Linear module for a standard training loop. + """ + + def __init__(self, centroids, assignments, bias, in_features, out_features): + super(PQLinear, self).__init__() + self.block_size = centroids.size(1) + self.n_centroids = centroids.size(0) + self.in_features = in_features + self.out_features = out_features + # check compatibility + if self.in_features % self.block_size != 0: + raise ValueError("Wrong PQ sizes") + if len(assignments) % self.out_features != 0: + raise ValueError("Wrong PQ sizes") + # define parameters + self.centroids = nn.Parameter(centroids, requires_grad=True) + self.register_buffer("assignments", assignments) + self.register_buffer("counts", torch.bincount(assignments).type_as(centroids)) + if bias is not None: + self.bias = nn.Parameter(bias) + else: + self.register_parameter("bias", None) + + @property + def weight(self): + return ( + self.centroids[self.assignments] + .reshape(-1, self.out_features, self.block_size) + .permute(1, 0, 2) + .flatten(1, 2) + ) + + def forward(self, x): + return F.linear( + x, + self.weight, + self.bias, + ) + + def extra_repr(self): + return f"in_features={self.in_features},\ + out_features={self.out_features},\ + n_centroids={self.n_centroids},\ + block_size={self.block_size},\ + bias={self.bias is not None}" diff --git a/fairseq/fairseq/modules/quantization/pq/pq.py b/fairseq/fairseq/modules/quantization/pq/pq.py new file mode 100644 index 0000000000000000000000000000000000000000..eddc2eb34602403f10979f54cd23a45bc2f104d5 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/pq.py @@ -0,0 +1,128 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .em import EM, EmptyClusterResolveError + + +class PQ(EM): + """ + Quantizes the layer weights W with the standard Product Quantization + technique. This learns a codebook of codewords or centroids of size + block_size from W. For further reference on using PQ to quantize + neural networks, see "And the Bit Goes Down: Revisiting the Quantization + of Neural Networks", Stock et al., ICLR 2020. + + PQ is performed in two steps: + (1) The matrix W (weights or fully-connected or convolutional layer) + is reshaped to (block_size, -1). + - If W is fully-connected (2D), its columns are split into + blocks of size block_size. + - If W is convolutional (4D), its filters are split along the + spatial dimension. + (2) We apply the standard EM/k-means algorithm to the resulting reshaped matrix. + + Args: + - W: weight matrix to quantize of size (in_features x out_features) + - block_size: size of the blocks (subvectors) + - n_centroids: number of centroids + - n_iter: number of k-means iterations + - eps: for cluster reassignment when an empty cluster is found + - max_tentatives for cluster reassignment when an empty cluster is found + - verbose: print information after each iteration + + Remarks: + - block_size be compatible with the shape of W + """ + + def __init__( + self, + W, + block_size, + n_centroids=256, + n_iter=20, + eps=1e-6, + max_tentatives=30, + verbose=True, + ): + self.block_size = block_size + W_reshaped = self._reshape(W) + super(PQ, self).__init__( + W_reshaped, + n_centroids=n_centroids, + n_iter=n_iter, + eps=eps, + max_tentatives=max_tentatives, + verbose=verbose, + ) + + def _reshape(self, W): + """ + Reshapes the matrix W as expained in step (1). + """ + + # fully connected: by convention the weight has size out_features x in_features + if len(W.size()) == 2: + self.out_features, self.in_features = W.size() + assert ( + self.in_features % self.block_size == 0 + ), "Linear: n_blocks must be a multiple of in_features" + return ( + W.reshape(self.out_features, -1, self.block_size) + .permute(2, 1, 0) + .flatten(1, 2) + ) + + # convolutional: we reshape along the spatial dimension + elif len(W.size()) == 4: + self.out_channels, self.in_channels, self.k_h, self.k_w = W.size() + assert ( + self.in_channels * self.k_h * self.k_w + ) % self.block_size == 0, ( + "Conv2d: n_blocks must be a multiple of in_channels * k_h * k_w" + ) + return ( + W.reshape(self.out_channels, -1, self.block_size) + .permute(2, 1, 0) + .flatten(1, 2) + ) + # not implemented + else: + raise NotImplementedError(W.size()) + + def encode(self): + """ + Performs self.n_iter EM steps. + """ + + self.initialize_centroids() + for i in range(self.n_iter): + try: + self.step(i) + except EmptyClusterResolveError: + break + + def decode(self): + """ + Returns the encoded full weight matrix. Must be called after + the encode function. + """ + + # fully connected case + if "k_h" not in self.__dict__: + return ( + self.centroids[self.assignments] + .reshape(-1, self.out_features, self.block_size) + .permute(1, 0, 2) + .flatten(1, 2) + ) + + # convolutional case + else: + return ( + self.centroids[self.assignments] + .reshape(-1, self.out_channels, self.block_size) + .permute(1, 0, 2) + .reshape(self.out_channels, self.in_channels, self.k_h, self.k_w) + ) diff --git a/fairseq/fairseq/modules/quantization/pq/utils.py b/fairseq/fairseq/modules/quantization/pq/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..14c015b7c19aae65812e864cf1d95ef3d39de606 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/pq/utils.py @@ -0,0 +1,374 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import re +from operator import attrgetter, itemgetter +import torch +import numpy as np +import torch.distributed as dist +import torch.nn as nn + +from .modules import PQConv2d, PQEmbedding, PQLinear +from .pq import PQ + + +def quantize_model_( + model, + size_tracker, + layers_to_quantize, + block_sizes_config, + n_centroids_config, + step=0, + n_iter=15, + eps=1e-6, + max_tentatives=100, + remove_weights=False, + verbose=True, + state_dict=None, +): + """ + Quantize a model in-place by stages. All the targeted + layers are replaced by their quantized counterpart, + and the model is ready for the finetuning of the + centroids in a standard training loop (no modifications + required). Note that we do not quantize biases. + + Args: + - model: a nn.Module + - size_tracker: useful for tracking quatization statistics + - layers_to_quantize: a list containing regexps for + filtering the layers to quantize at each stage according + to their name (as in model.named_parameters()) + - block_sizes_config: dict like + { + 'Conv2d': ('kernel_size', {'(3, 3)': 9, '(1, 1)': 4}), + 'Linear': ('in_features', {'*': 8}) + } + For instance, all conv2d layers with kernel size 3x3 have + a block size of 9 and all Linear layers are quantized with + a block size of 8, irrespective of their size. + - n_centroids_config: dict like + { + 'Conv2d': ('kernel_size', {'*': 256}), + 'Linear': ('in_features', {'*': 256}) + } + For instance, all conv2d layers are quantized with 256 centroids + - step: the layers to quantize inplace corresponding + to layers_to_quantize[step] + """ + + quantized_layers = get_layers(model, layers_to_quantize[step], remove_weights=remove_weights) + + for layer in quantized_layers: + + # book-keeping + is_master_process = (not dist.is_initialized()) or ( + dist.is_initialized() and dist.get_rank() == 0 + ) + verbose = verbose and is_master_process + + # get block size and centroids + module = attrgetter(layer)(model) + block_size = get_param(module, layer, block_sizes_config) + n_centroids = get_param(module, layer, n_centroids_config) + if verbose: + logging.info( + f"Quantizing layer {layer} with block size {block_size} and {n_centroids} centroids" + ) + + # quantize layer + weight = module.weight.data.clone() + is_bias = "bias" in [x[0] for x in module.named_parameters()] + bias = module.bias.data.clone() if is_bias else None + quantizer = PQ( + weight, + block_size, + n_centroids=n_centroids, + n_iter=n_iter, + eps=eps, + max_tentatives=max_tentatives, + verbose=verbose, + ) + + # quantization performed on all GPUs with same seed + quantizer.encode() + centroids = quantizer.centroids.contiguous() + assignments = quantizer.assignments.contiguous() + + # If n_iter = 0 and state_dict is provided, then + # we initialize random assignments and centroids to + # random values of the appropriate dimensions + # because the quantized model parameters will + # overwritten by the state_dict later on. + if n_iter == 0 and state_dict: + # Initialize random centroids of the correct size + centroids = torch.rand(centroids.size()) + centroids.cuda() + # Get counts and assignment keys from layer in loaded checkpoint. + counts_key = layer+"."+"counts" + assignment_key = layer+"."+"assignments" + # Get number of different bins to include. + counts = list(state_dict[counts_key].shape)[0] + print(layer) + print(state_dict[counts_key]) + print(counts) + # Initialize random assignments of the correct size + # with an appropriate number of bins. + num_assignments = list(state_dict[assignment_key].shape)[0] + num_extra = num_assignments - counts + print(num_assignments) + print(num_extra) + assignments_bins = torch.arange(counts) + assignments_rand = torch.randint(0, counts-1, (num_extra, )) + assignments = torch.cat((assignments_bins, assignments_rand), 0) + # assignments = assignments.type(torch.IntTensor) + assignments.cuda() + print("assignments") + print(assignments) + + # broadcast results to make sure weights are up-to-date + if dist.is_initialized(): + dist.broadcast(centroids, 0) + dist.broadcast(assignments, 0) + + # instantiate the quantized counterpart + if isinstance(module, nn.Linear): + out_features, in_features = map( + lambda k: module.__dict__[k], ["out_features", "in_features"] + ) + quantized_module = PQLinear( + centroids, assignments, bias, in_features, out_features + ) + elif isinstance(module, nn.Embedding): + num_embeddings, embedding_dim = map( + lambda k: module.__dict__[k], ["num_embeddings", "embedding_dim"] + ) + quantized_module = PQEmbedding( + centroids, assignments, num_embeddings, embedding_dim + ) + elif isinstance(module, nn.Conv2d): + out_channels, in_channels, kernel_size = map( + lambda k: module.__dict__[k], + ["out_channels", "in_channels", "kernel_size"], + ) + stride, padding, dilation, groups, padding_mode = map( + lambda k: module.__dict__[k], + ["stride", "padding", "dilation", "groups", "padding_mode"], + ) + + quantized_module = PQConv2d( + centroids, + assignments, + bias, + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + padding_mode=padding_mode, + ) + else: + raise ValueError(f"Module {module} not yet supported for quantization") + + # replace layer by its quantized counterpart + attrsetter(layer)(model, quantized_module) + + # update statistics + size_tracker.update(weight, block_size, n_centroids) + + # return name of quantized layers + return quantized_layers + + +def get_layers(model, filter_regexp, remove_weights=False): + """ + Filters out the layers according to a regexp. Note that + we omit biases. + + Args: + - model: a nn.Module + - filter_regexp: a regexp to filter the layers to keep + according to their name in model.named_parameters(). + For instance, the regexp: + + down_layers\\.[123456]\\.(conv[12]|identity\\.conv)) + + is keeping blocks down_layers from 1 to 6, and inside + each block is keeping conv1, conv2 and identity.conv. + + Remarks: + - We add (module\\.)? at the beginning of the regexp to + account for the possible use of nn.parallel.DataParallel + """ + + # get all parameter names + all_layers = map(itemgetter(0), model.named_parameters()) + + # remove biases + all_layers = filter(lambda x: "bias" not in x, all_layers) + + # remove .weight in all other names (or .weight_orig is spectral norm) + all_layers = map(lambda x: x.replace(".weight_orig", ""), all_layers) + # remove weights indicates whether the weights extension should be removed, in addition to + # weight_orig and weight extension on names + if remove_weights: + all_layers = map(lambda x: x.replace(".weights", ""), all_layers) + all_layers = map(lambda x: x.replace(".weight", ""), all_layers) + + # return filtered layers + filter_regexp = "(module\\.)?" + "(" + filter_regexp + ")" + r = re.compile(filter_regexp) + + return list(filter(r.match, all_layers)) + + +def get_param(module, layer_name, param_config): + """ + Given a quantization configuration, get the right parameter + for the module to be quantized. + + Args: + - module: a nn.Module + - layer_name: the name of the layer + - param_config: a dict like + { + 'Conv2d': ('kernel_size', {'(3, 3)': 9, '(1, 1)': 4}), + 'Linear': ('in_features', {'*': 8}) + } + For instance, all conv2d layers with kernel size 3x3 have + a block size of 9 and all Linear layers are quantized with + a block size of 8, irrespective of their size. + + Remarks: + - if 'fuzzy_name' is passed as a parameter, layers whose layer_name + include 'fuzzy_name' will be assigned the given parameter. + In the following example, conv.expand layers will have a block + size of 9 while conv.reduce will have a block size of 4 and all + other layers will have a block size of 2. + { + 'Conv2d': ('fuzzy_name', {'expand': 9, 'reduce': 4, '*': 2}), + 'Linear': ('fuzzy_name', {'classifier': 8, 'projection': 4}) + } + + """ + + layer_type = module.__class__.__name__ + + if layer_type not in param_config: + raise KeyError(f"Layer type {layer_type} not in config for layer {module}") + + feature, params = param_config[module.__class__.__name__] + + if feature != "fuzzy_name": + feature_value = str(getattr(module, feature)) + if feature_value not in params: + if "*" in params: + feature_value = "*" + else: + raise KeyError( + f"{feature}={feature_value} not in config for layer {module}" + ) + else: + feature_values = [name for name in params if name in layer_name] + if len(feature_values) == 0: + if "*" in params: + feature_value = "*" + else: + raise KeyError(f"name={layer_name} not in config for {module}") + else: + feature_value = feature_values[0] + + return params[feature_value] + + +class SizeTracker(object): + """ + Class to keep track of the compressed network size with iPQ. + + Args: + - model: a nn.Module + + Remarks: + - The compressed size is the sum of three components + for each layer in the network: + (1) Storing the centroids given by iPQ in fp16 + (2) Storing the assignments of the blocks in int8 + (3) Storing all non-compressed elements such as biases + - This cost in only valid if we use 256 centroids (then + indexing can indeed by done with int8). + """ + + def __init__(self, model): + self.model = model + self.size_non_compressed_model = self.compute_size() + self.size_non_quantized = self.size_non_compressed_model + self.size_index = 0 + self.size_centroids = 0 + self.n_quantized_layers = 0 + + def compute_size(self): + """ + Computes the size of the model (in MB). + """ + + res = 0 + for _, p in self.model.named_parameters(): + res += p.numel() + return res * 4 / 1024 / 1024 + + def update(self, W, block_size, n_centroids): + """ + Updates the running statistics when quantizing a new layer. + """ + + # bits per weights + bits_per_weight = np.log2(n_centroids) / block_size + self.n_quantized_layers += 1 + + # size of indexing the subvectors of size block_size (in MB) + size_index_layer = bits_per_weight * W.numel() / 8 / 1024 / 1024 + self.size_index += size_index_layer + + # size of the centroids stored in float16 (in MB) + size_centroids_layer = n_centroids * block_size * 2 / 1024 / 1024 + self.size_centroids += size_centroids_layer + + # size of non-compressed layers, e.g. LayerNorms or biases (in MB) + size_uncompressed_layer = W.numel() * 4 / 1024 / 1024 + self.size_non_quantized -= size_uncompressed_layer + + def __repr__(self): + size_compressed = ( + self.size_index + self.size_centroids + self.size_non_quantized + ) + compression_ratio = self.size_non_compressed_model / size_compressed # NOQA + return ( + f"Non-compressed model size: {self.size_non_compressed_model:.2f} MB. " + f"After quantizing {self.n_quantized_layers} layers, size " + f"(indexing + centroids + other): {self.size_index:.2f} MB + " + f"{self.size_centroids:.2f} MB + {self.size_non_quantized:.2f} MB = " + f"{size_compressed:.2f} MB, compression ratio: {compression_ratio:.2f}x" + ) + + +def attrsetter(*items): + def resolve_attr(obj, attr): + attrs = attr.split(".") + head = attrs[:-1] + tail = attrs[-1] + + for name in head: + obj = getattr(obj, name) + return obj, tail + + def g(obj, val): + for attr in items: + resolved_obj, resolved_attr = resolve_attr(obj, attr) + setattr(resolved_obj, resolved_attr, val) + + return g diff --git a/fairseq/fairseq/modules/quantization/quantization_options.py b/fairseq/fairseq/modules/quantization/quantization_options.py new file mode 100644 index 0000000000000000000000000000000000000000..b46d682c0edaeaaf2a230e51d50da2a32d4bda98 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/quantization_options.py @@ -0,0 +1,44 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +def parse_config_yaml(yaml_data): + # Initialize to default options. + quantization_options = { + "n_centroids": { + "Linear": ["in_features", {"*": 256}], + "Embedding": ["embedding_dim", {"*": 256}], + }, + "block_sizes": { + "Linear": ["fuzzy_name", {"fc": 8, "attn": 4, "emb": 4}], + "Embedding": ["fuzzy_name", {"emb": 8}], + }, + "layers_to_quantize": [ + "decoder\\.layers\\.\\d+\\.fc[12]", + "decoder\\.embed_tokens\\.embeddings\\.[012]\\.[01]", + "decoder\\.layers\\.\\d+\\.self_attn\\.(k_proj|v_proj|q_proj|out_proj)", + ], + } + + if "n_centroids" in yaml_data: + quantization_options["n_centroids"] = { + layer: convert_yaml_to_tuple(layer_data) + for layer, layer_data in yaml_data["n_centroids"].items() + } + if "block_sizes" in yaml_data: + quantization_options["block_sizes"] = { + layer: convert_yaml_to_tuple(layer_data) + for layer, layer_data in yaml_data["block_sizes"].items() + } + if "layers_to_quantize" in yaml_data: + quantization_options["layers_to_quantize"] = yaml_data["layers_to_quantize"] + + return quantization_options + + +def convert_yaml_to_tuple(yaml_dictionary): + """Converts a yaml dictionary with two keys: `key` and `value` into a two + argument tuple of those values.""" + return (yaml_dictionary["key"], yaml_dictionary["value"]) diff --git a/fairseq/fairseq/modules/quantization/scalar/__init__.py b/fairseq/fairseq/modules/quantization/scalar/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..143834f3d036780eb6844c82f0c6f2d10cfe2f61 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .utils import quantize_model_ # NOQA diff --git a/fairseq/fairseq/modules/quantization/scalar/modules/__init__.py b/fairseq/fairseq/modules/quantization/scalar/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8031d9cdb23f2bc72596f8bc9cfa4965f96e3e6c --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/modules/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from .qact import ActivationQuantizer # NOQA +from .qconv import IntConv2d # NOQA +from .qemb import IntEmbedding # NOQA +from .qlinear import IntLinear # NOQA diff --git a/fairseq/fairseq/modules/quantization/scalar/modules/qact.py b/fairseq/fairseq/modules/quantization/scalar/modules/qact.py new file mode 100644 index 0000000000000000000000000000000000000000..c5dd1d63362423ab0cfc381dddabb547a3b44c72 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/modules/qact.py @@ -0,0 +1,88 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + +from ..ops import emulate_int + + +class ActivationQuantizer: + """ + Fake scalar quantization of the activations using a forward hook. + + Args: + - module. a nn.Module for which we quantize the *post-activations* + - p: proportion of activations to quantize, set by default to 1 + - update_step: to recompute quantization parameters + - bits: number of bits for quantization + - method: choose among {"tensor", "histogram", "channel"} + - clamp_threshold: to prevent gradients overflow + + Remarks: + - Parameters scale and zero_point are recomputed every update_step + forward pass to reduce the overhead + - For the list of quantization methods and number of bits, see ops.py + - To remove the hook from the module, simply call self.handle.remove() + - At test time, the activations are fully quantized + - We use the straight-through estimator so that the gradients + back-propagate nicely in the network, this is implemented with + the detach() trick + - The activations are hard-clamped in [-clamp_threshold, clamp_threshold] + to prevent overflow during the backward pass + """ + + def __init__( + self, + module, + p=1, + update_step=1000, + bits=8, + method="histogram", + clamp_threshold=5, + ): + self.module = module + self.p = p + self.update_step = update_step + self.counter = 0 + self.bits = bits + self.method = method + self.clamp_threshold = clamp_threshold + self.handle = None + self.register_hook() + + def register_hook(self): + # forward hook + def quantize_hook(module, x, y): + + # update parameters every 1000 iterations + if self.counter % self.update_step == 0: + self.scale = None + self.zero_point = None + self.counter += 1 + + # train with QuantNoise and evaluate the fully quantized network + p = self.p if self.module.training else 1 + + # quantize activations + y_q, self.scale, self.zero_point = emulate_int( + y.detach(), + bits=self.bits, + method=self.method, + scale=self.scale, + zero_point=self.zero_point, + ) + + # mask to apply noise + mask = torch.zeros_like(y) + mask.bernoulli_(1 - p) + noise = (y_q - y).masked_fill(mask.bool(), 0) + + # using straight-through estimator (STE) + clamp_low = -self.scale * self.zero_point + clamp_high = self.scale * (2 ** self.bits - 1 - self.zero_point) + return torch.clamp(y, clamp_low.item(), clamp_high.item()) + noise.detach() + + # register hook + self.handle = self.module.register_forward_hook(quantize_hook) diff --git a/fairseq/fairseq/modules/quantization/scalar/modules/qconv.py b/fairseq/fairseq/modules/quantization/scalar/modules/qconv.py new file mode 100644 index 0000000000000000000000000000000000000000..83788c6f71fd41e61fd115681a22d53ce8b8362c --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/modules/qconv.py @@ -0,0 +1,149 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn.functional as F +from torch.nn.modules.conv import _ConvNd +from torch.nn.modules.utils import _pair + +from ..ops import emulate_int + + +class IntConv2d(_ConvNd): + """ + Quantized counterpart of the nn.Conv2d module that applies QuantNoise during training. + + Args: + - standard nn.Conv2d parameters + - p: amount of noise to inject (0 = no quantization, 1 = quantize all the weights) + - bits: number of bits + - method: choose among {"tensor", "histogram", "channel"} + - update_step: recompute scale and zero_point every update_steps iterations + + Remarks: + - We use the straight-thgourh estimator so that the gradients + back-propagate nicely in the network, this is implemented with + the detach() trick + - Parameters scale and zero_point are recomputed every update_step + forward pass to reduce the overhead + - At test time, the weights are fully quantized + """ + + def __init__( + self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias=True, + padding_mode="zeros", + p=0, + bits=8, + method="histogram", + update_step=1000, + ): + kernel_size = _pair(kernel_size) + stride = _pair(stride) + padding = _pair(padding) + dilation = _pair(dilation) + super(IntConv2d, self).__init__( + in_channels, + out_channels, + kernel_size, + stride, + padding, + dilation, + False, + _pair(0), + groups, + bias, + padding_mode, + ) + + # quantization parameters + self.p = p + self.bits = bits + self.method = method + self.update_step = update_step + self.counter = 0 + + def _conv_forward(self, input, weight): + if self.padding_mode != "zeros": + return F.conv2d( + F.pad(input, self._padding_repeated_twice, mode=self.padding_mode), + weight, + self.bias, + self.stride, + _pair(0), + self.dilation, + self.groups, + ) + return F.conv2d( + input, + weight, + self.bias, + self.stride, + self.padding, + self.dilation, + self.groups, + ) + + def forward(self, input): + # train with QuantNoise and evaluate the fully quantized network + p = self.p if self.training else 1 + + # update parameters every 100 iterations + if self.counter % self.update_step == 0: + self.scale = None + self.zero_point = None + self.counter += 1 + + # quantize weight + weight_quantized, self.scale, self.zero_point = emulate_int( + self.weight.detach(), + bits=self.bits, + method=self.method, + scale=self.scale, + zero_point=self.zero_point, + ) + + # mask to apply noise + mask = torch.zeros_like(self.weight) + mask.bernoulli_(1 - p) + noise = (weight_quantized - self.weight).masked_fill(mask.bool(), 0) + + # using straight-through estimator (STE) + clamp_low = -self.scale * self.zero_point + clamp_high = self.scale * (2 ** self.bits - 1 - self.zero_point) + weight = ( + torch.clamp(self.weight, clamp_low.item(), clamp_high.item()) + + noise.detach() + ) + + # return output + output = self._conv_forward(input, weight) + return output + + def extra_repr(self): + return ( + "in_channels={}, out_channels={}, kernel_size={}, stride={}, " + "padding={}, dilation={}, groups={}, bias={}, quant_noise={}, " + "bits={}, method={}".format( + self.in_channels, + self.out_channels, + self.kernel_size, + self.stride, + self.padding, + self.dilation, + self.groups, + self.bias is not None, + self.p, + self.bits, + self.method, + ) + ) diff --git a/fairseq/fairseq/modules/quantization/scalar/modules/qemb.py b/fairseq/fairseq/modules/quantization/scalar/modules/qemb.py new file mode 100644 index 0000000000000000000000000000000000000000..d6cf06e5872cb86e5c2e726153c7a80c78db9d1e --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/modules/qemb.py @@ -0,0 +1,147 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from ..ops import emulate_int + + +class IntEmbedding(nn.Module): + """ + Quantized counterpart of the nn.Embedding module that applies QuantNoise during training. + + Args: + - num_embeddings: number of tokens + - embedding_dim: embedding dimension + - p: amount of noise to inject (0 = no quantization, 1 = quantize all the weights) + - bits: number of bits + - method: choose among {"tensor", "histogram", "channel"} + - update_step: recompute scale and zero_point every update_steps iterations + + Remarks: + - We use the straight-through estimator so that the gradients + back-propagate nicely in the network, this is implemented with + the detach() trick + - Parameters scale and zero_point are recomputed every update_step + forward pass to reduce the overhead + - At test time, the weights are fully quantized + """ + + def __init__( + self, + num_embeddings, + embedding_dim, + padding_idx=None, + max_norm=None, + norm_type=2.0, + scale_grad_by_freq=False, + sparse=False, + _weight=None, + p=0, + update_step=1000, + bits=8, + method="histogram", + ): + super(IntEmbedding, self).__init__() + self.num_embeddings = num_embeddings + self.embedding_dim = embedding_dim + if padding_idx is not None: + if padding_idx > 0: + assert ( + padding_idx < self.num_embeddings + ), "Padding_idx must be within num_embeddings" + elif padding_idx < 0: + assert ( + padding_idx >= -self.num_embeddings + ), "Padding_idx must be within num_embeddings" + padding_idx = self.num_embeddings + padding_idx + self.padding_idx = padding_idx + self.max_norm = max_norm + self.norm_type = norm_type + self.scale_grad_by_freq = scale_grad_by_freq + if _weight is None: + self.weight = nn.Parameter(torch.Tensor(num_embeddings, embedding_dim)) + self.reset_parameters() + else: + assert list(_weight.shape) == [ + num_embeddings, + embedding_dim, + ], "Shape of weight does not match num_embeddings and embedding_dim" + self.weight = nn.Parameter(_weight) + self.sparse = sparse + + # quantization parameters + self.p = p + self.bits = bits + self.method = method + self.update_step = update_step + self.counter = 0 + + def reset_parameters(self): + nn.init.normal_(self.weight) + if self.padding_idx is not None: + with torch.no_grad(): + self.weight[self.padding_idx].fill_(0) + + def forward(self, input): + # train with QuantNoise and evaluate the fully quantized network + p = self.p if self.training else 1 + + # update parameters every 1000 iterations + if self.counter % self.update_step == 0: + self.scale = None + self.zero_point = None + self.counter += 1 + + # quantize weight + weight_quantized, self.scale, self.zero_point = emulate_int( + self.weight.detach(), + bits=self.bits, + method=self.method, + scale=self.scale, + zero_point=self.zero_point, + ) + + # mask to apply noise + mask = torch.zeros_like(self.weight) + mask.bernoulli_(1 - p) + noise = (weight_quantized - self.weight).masked_fill(mask.bool(), 0) + + # using straight-through estimator (STE) + clamp_low = -self.scale * self.zero_point + clamp_high = self.scale * (2 ** self.bits - 1 - self.zero_point) + weight = ( + torch.clamp(self.weight, clamp_low.item(), clamp_high.item()) + + noise.detach() + ) + + # return output + output = F.embedding( + input, + weight, + self.padding_idx, + self.max_norm, + self.norm_type, + self.scale_grad_by_freq, + self.sparse, + ) + return output + + def extra_repr(self): + s = "{num_embeddings}, {embedding_dim}" + if self.padding_idx is not None: + s += ", padding_idx={padding_idx}" + if self.max_norm is not None: + s += ", max_norm={max_norm}" + if self.norm_type != 2: + s += ", norm_type={norm_type}" + if self.scale_grad_by_freq is not False: + s += ", scale_grad_by_freq={scale_grad_by_freq}" + if self.sparse is not False: + s += ", sparse=True" + s += "quant_noise={p}, bits={bits}, method={method}" + return s.format(**self.__dict__) diff --git a/fairseq/fairseq/modules/quantization/scalar/modules/qlinear.py b/fairseq/fairseq/modules/quantization/scalar/modules/qlinear.py new file mode 100644 index 0000000000000000000000000000000000000000..9db1559386bce286301d31435851dc4ea76687a5 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/modules/qlinear.py @@ -0,0 +1,113 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from ..ops import emulate_int + + +class IntLinear(nn.Module): + """ + Quantized counterpart of the nn.Linear module that applies QuantNoise during training. + + Args: + - in_features: input features + - out_features: output features + - bias: bias or not + - p: amount of noise to inject (0 = no quantization, 1 = quantize all the weights) + - bits: number of bits + - method: choose among {"tensor", "histogram", "channel"} + - update_step: recompute scale and zero_point every update_steps iterations + + Remarks: + - We use the straight-through estimator so that the gradients + back-propagate nicely in the network, this is implemented with + the detach() trick. + - Parameters scale and zero_point are recomputed every update_step + forward pass to reduce the overhead + - At test time, the weights are fully quantized + """ + + def __init__( + self, + in_features, + out_features, + bias=True, + p=0, + update_step=3000, + bits=8, + method="histogram", + ): + super(IntLinear, self).__init__() + self.in_features = int(in_features) + self.out_features = int(out_features) + self.weight = torch.nn.Parameter(torch.Tensor(out_features, in_features)) + self.chosen_bias = bias + if self.chosen_bias: + self.bias = torch.nn.Parameter(torch.Tensor(out_features)) + else: + self.register_parameter("bias", None) + self.reset_parameters() + + # quantization parameters + self.p = p + self.bits = bits + self.method = method + self.update_step = update_step + self.counter = 0 + + def reset_parameters(self): + nn.init.xavier_uniform_(self.weight) + if self.chosen_bias: + nn.init.constant_(self.bias, 0.0) + return + + def forward(self, input): + # train with QuantNoise and evaluate the fully quantized network + p = self.p if self.training else 1 + + # update parameters every 100 iterations + if self.counter % self.update_step == 0: + self.scale = None + self.zero_point = None + self.counter += 1 + + # quantize weight + weight_quantized, self.scale, self.zero_point = emulate_int( + self.weight.detach(), + bits=self.bits, + method=self.method, + scale=self.scale, + zero_point=self.zero_point, + ) + + # mask to apply noise + mask = torch.zeros_like(self.weight) + mask.bernoulli_(1 - p) + noise = (weight_quantized - self.weight).masked_fill(mask.bool(), 0) + + # using straight-through estimator (STE) + clamp_low = -self.scale * self.zero_point + clamp_high = self.scale * (2 ** self.bits - 1 - self.zero_point) + weight = ( + torch.clamp(self.weight, clamp_low.item(), clamp_high.item()) + + noise.detach() + ) + + # return output + output = F.linear(input, weight, self.bias) + return output + + def extra_repr(self): + return "in_features={}, out_features={}, bias={}, quant_noise={}, bits={}, method={}".format( + self.in_features, + self.out_features, + self.bias is not None, + self.p, + self.bits, + self.method, + ) diff --git a/fairseq/fairseq/modules/quantization/scalar/ops.py b/fairseq/fairseq/modules/quantization/scalar/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..c74f530380b393ffc53ecfb1398000079495772f --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/ops.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch + + +def emulate_int(w, bits, method, scale=None, zero_point=None): + q = globals()[f"emulate_int8_{method}"] + return q(w, scale=scale, zero_point=zero_point, bits=bits) + + +def quantize(w, scale, zero_point, bits=8): + # In the default behavior, max_val = 255. + max_val = 2 ** bits - 1 + return ( + torch.clamp(torch.round(w / scale + zero_point), 0, max_val) - zero_point + ) * scale + + +def emulate_int8_histogram(w, scale=None, zero_point=None, bits=8): + if scale is None: + obs = torch.quantization.observer.HistogramObserver() + obs.to(device=w.device) + _ = obs(w.float()) + scale, zero_point = obs.calculate_qparams() + scale = scale.cuda().type_as(w) + zero_point = zero_point.cuda().type_as(w) + return quantize(w, scale, zero_point, bits=bits), scale, zero_point + + +def emulate_int8_channel(w, scale=None, zero_point=None, bits=8): + if scale is None: + obs = torch.quantization.observer.PerChannelMinMaxObserver( + ch_axis=-1, qscheme=torch.per_channel_symmetric + ) + obs.to(device=w.device) + _ = obs(w) + scale, zero_point, ch_axis = obs.get_qparams() + scale = scale.cuda().type_as(w) + zero_point = zero_point.cuda().type_as(w) + return quantize(w, scale, zero_point, bits=bits), scale, zero_point + + +def emulate_int8_tensor(w, scale=None, zero_point=None, bits=8): + if scale is None: + obs = torch.quantization.observer.MinMaxObserver() + obs.to(device=w.device) + _ = obs(w) + scale, zero_point = obs.calculate_qparams() + scale = scale.cuda().type_as(w) + zero_point = zero_point.cuda().type_as(w) + return quantize(w, scale, zero_point, bits=bits), scale, zero_point diff --git a/fairseq/fairseq/modules/quantization/scalar/utils.py b/fairseq/fairseq/modules/quantization/scalar/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2ec6af3fcb09ccaf853be15a84ed8181f9e2f546 --- /dev/null +++ b/fairseq/fairseq/modules/quantization/scalar/utils.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from operator import attrgetter + +import torch.distributed as dist +import torch.nn as nn + +from ..pq.utils import attrsetter, get_layers +from .modules import ActivationQuantizer, IntConv2d, IntEmbedding, IntLinear + + +MAPPING = {nn.Linear: IntLinear, nn.Embedding: IntEmbedding, nn.Conv2d: IntConv2d} + + +def quantize_model_(model, p=0.2, bits=8, update_step=3000, method="histogram", remove_weights=False): + """ + Replaces all modules with their scalar quantized counterpart and + registers hooks to quantize the post-ativations of those modules. + + Args: + - model: a nn.Module + - p: amount of noise (0 for no noise, 1 to quantize all the weights/activations) + - bits: number of bits + - update_step: update quantization parameters every update_step steps + """ + # quantize all layers + # remove weights indicates whether the weights extension should be removed, in addition to + # weight_orig and weight extension on names + quantized_layers = get_layers(model, "(.*?)", remove_weights=remove_weights) + + for layer in quantized_layers: + + # book-keeping + is_master_process = (not dist.is_initialized()) or ( + dist.is_initialized() and dist.get_rank() == 0 + ) + + # recover module + module = attrgetter(layer)(model) + if is_master_process: + logging.info( + f"Quantizing layer {layer} with bits={bits} and QuantNoise={p}" + ) + + # quantization params + q_params = { + "p": p, + "update_step": update_step, + "bits": bits, + "method": method, + "counter": 0, + } + + # instantiate the quantized counterpart + if isinstance(module, tuple(MAPPING.keys())): + QuantizedModule = MAPPING[module.__class__] + quantized_module = QuantizedModule.__new__(QuantizedModule) + params = module.__dict__ + params.update(q_params) + quantized_module.__dict__.update(params) + + else: + if is_master_process: + logging.info(f"Module {module} not yet supported for quantization") + continue + + # activation quantization + a_q = ActivationQuantizer(quantized_module, p=0, bits=bits, method=method) + + # replace layer by its quantized counterpart + attrsetter(layer)(model, quantized_module) + + # return name of quantized layers + return quantized_layers diff --git a/fairseq/fairseq/modules/same_pad.py b/fairseq/fairseq/modules/same_pad.py new file mode 100644 index 0000000000000000000000000000000000000000..4c04990ea6fdb291f162ee8ac3d17a92483daf8e --- /dev/null +++ b/fairseq/fairseq/modules/same_pad.py @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +from torch import nn + + +class SamePad(nn.Module): + def __init__(self, kernel_size, causal=False): + super().__init__() + if causal: + self.remove = kernel_size - 1 + else: + self.remove = 1 if kernel_size % 2 == 0 else 0 + + def forward(self, x): + if self.remove > 0: + x = x[:, :, : -self.remove] + return x diff --git a/fairseq/fairseq/modules/scalar_bias.py b/fairseq/fairseq/modules/scalar_bias.py new file mode 100644 index 0000000000000000000000000000000000000000..c96247c75914fabb8a2b7ff731bb82b588f72690 --- /dev/null +++ b/fairseq/fairseq/modules/scalar_bias.py @@ -0,0 +1,31 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +# + +import torch + + +class ScalarBias(torch.autograd.Function): + """ + Adds a vector of scalars, used in self-attention mechanism to allow + the model to optionally attend to this vector instead of the past + """ + + @staticmethod + def forward(ctx, input, dim, bias_init): + size = list(input.size()) + size[dim] += 1 + output = input.new(*size).fill_(bias_init) + output.narrow(dim, 1, size[dim] - 1).copy_(input) + ctx.dim = dim + return output + + @staticmethod + def backward(ctx, grad): + return grad.narrow(ctx.dim, 1, grad.size(ctx.dim) - 1), None, None + + +def scalar_bias(input, dim, bias_init=0): + return ScalarBias.apply(input, dim, bias_init) diff --git a/fairseq/fairseq/modules/sinusoidal_positional_embedding.py b/fairseq/fairseq/modules/sinusoidal_positional_embedding.py new file mode 100644 index 0000000000000000000000000000000000000000..4793ecfb522d0729fc2d24a3ddf0c6a774d67773 --- /dev/null +++ b/fairseq/fairseq/modules/sinusoidal_positional_embedding.py @@ -0,0 +1,105 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Any, Optional + +import torch +import torch.onnx.operators +from fairseq import utils +from torch import Tensor, nn + + +class SinusoidalPositionalEmbedding(nn.Module): + """This module produces sinusoidal positional embeddings of any length. + + Padding symbols are ignored. + """ + + def __init__(self, embedding_dim, padding_idx, init_size=1024): + super().__init__() + self.embedding_dim = embedding_dim + self.padding_idx = padding_idx if padding_idx is not None else 0 + self.weights = SinusoidalPositionalEmbedding.get_embedding( + init_size, embedding_dim, padding_idx + ) + self.onnx_trace = False + self.register_buffer("_float_tensor", torch.FloatTensor(1)) + self.max_positions = int(1e5) + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + @staticmethod + def get_embedding( + num_embeddings: int, embedding_dim: int, padding_idx: Optional[int] = None + ): + """Build sinusoidal embeddings. + + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb) + emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze( + 1 + ) * emb.unsqueeze(0) + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view( + num_embeddings, -1 + ) + if embedding_dim % 2 == 1: + # zero pad + emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1) + if padding_idx is not None: + emb[padding_idx, :] = 0 + return emb + + def forward( + self, + input, + incremental_state: Optional[Any] = None, + timestep: Optional[Tensor] = None, + positions: Optional[Any] = None, + ): + """Input is expected to be of size [bsz x seqlen].""" + bspair = torch.onnx.operators.shape_as_tensor(input) + bsz, seq_len = bspair[0], bspair[1] + max_pos = self.padding_idx + 1 + seq_len + if self.weights is None or max_pos > self.weights.size(0): + # recompute/expand embeddings if needed + self.weights = SinusoidalPositionalEmbedding.get_embedding( + max_pos, self.embedding_dim, self.padding_idx + ) + self.weights = self.weights.to(self._float_tensor) + + if incremental_state is not None: + # positions is the same for every token when decoding a single step + pos = timestep.view(-1)[0] + 1 if timestep is not None else seq_len + if self.onnx_trace: + return ( + self.weights.index_select(index=self.padding_idx + pos, dim=0) + .unsqueeze(1) + .repeat(bsz, 1, 1) + ) + return self.weights[self.padding_idx + pos, :].expand(bsz, 1, -1) + + positions = utils.make_positions( + input, self.padding_idx, onnx_trace=self.onnx_trace + ) + if self.onnx_trace: + flat_embeddings = self.weights.detach().index_select(0, positions.view(-1)) + embedding_shape = torch.cat( + (bsz.view(1), seq_len.view(1), torch.tensor([-1], dtype=torch.long)) + ) + embeddings = torch.onnx.operators.reshape_from_tensor_shape( + flat_embeddings, embedding_shape + ) + return embeddings + return ( + self.weights.index_select(0, positions.view(-1)) + .view(bsz, seq_len, -1) + .detach() + ) diff --git a/fairseq/fairseq/modules/sparse_multihead_attention.py b/fairseq/fairseq/modules/sparse_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..3cbd9d6785886e319aab0601517e27df733b6f97 --- /dev/null +++ b/fairseq/fairseq/modules/sparse_multihead_attention.py @@ -0,0 +1,140 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch + +from .multihead_attention import MultiheadAttention + + +class SparseMultiheadAttention(MultiheadAttention): + """Sparse Multi-Headed Attention. + + "Generating Long Sequences with Sparse Transformers". Implements + fixed factorized self attention, where l=stride and c=expressivity. + A(1) includes all words in the stride window and A(2) takes a summary of c + words from the end of each stride window. + If is_bidirectional=False, we do not include any words past the current word, + as in the paper. + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + self_attention=False, + encoder_decoder_attention=False, + stride=32, + expressivity=8, + is_bidirectional=True, + ): + + super().__init__( + embed_dim, + num_heads, + kdim, + vdim, + dropout, + bias, + add_bias_kv, + add_zero_attn, + self_attention, + encoder_decoder_attention, + ) + + self.is_bidirectional = is_bidirectional + self.stride = stride + self.expressivity = expressivity + assert self.stride > 0 and self.stride >= self.expressivity + + # Used for Ai(2) calculations - beginning of [l-c, l] range + def compute_checkpoint(self, word_index): + if word_index % self.stride == 0 and word_index != 0: + checkpoint_index = word_index - self.expressivity + else: + checkpoint_index = ( + math.floor(word_index / self.stride) * self.stride + + self.stride + - self.expressivity + ) + return checkpoint_index + + # Computes Ai(2) + def compute_subset_summaries(self, absolute_max): + checkpoint_index = self.compute_checkpoint(0) + subset_two = set() + while checkpoint_index <= absolute_max - 1: + summary = set( + range( + checkpoint_index, + min(checkpoint_index + self.expressivity + 1, absolute_max), + ) + ) + subset_two = subset_two.union(summary) + checkpoint_index = self.compute_checkpoint(checkpoint_index + self.stride) + return subset_two + + # Sparse Transformer Fixed Attention Pattern: https://arxiv.org/pdf/1904.10509.pdf + def compute_fixed_attention_subset(self, word_index, tgt_len): + # +1s account for range function; [min, max) -> [min, max] + if not self.is_bidirectional: + absolute_max = word_index + 1 + else: + absolute_max = tgt_len + + # Subset 1 - whole window + rounded_index = ( + math.floor((word_index + self.stride) / self.stride) * self.stride + ) + if word_index % self.stride == 0 and word_index != 0: + subset_one = set( + range(word_index - self.stride, min(absolute_max, word_index + 1)) + ) + else: + subset_one = set( + range( + max(0, rounded_index - self.stride), + min(absolute_max, rounded_index + 1), + ) + ) + + # Subset 2 - summary per window + # If bidirectional, subset 2 is the same for every index + subset_two = set() + if not self.is_bidirectional: + subset_two = self.compute_subset_summaries(absolute_max) + + return subset_one.union(subset_two) + + # Compute sparse mask - if bidirectional, can pre-compute and store + def buffered_sparse_mask(self, tensor, tgt_len, src_len): + assert tgt_len > self.stride + sparse_mask = torch.empty((tgt_len, src_len)).float().fill_(float("-inf")) + + # If bidirectional, subset 2 is the same for every index + subset_summaries = set() + if self.is_bidirectional: + subset_summaries = self.compute_subset_summaries(tgt_len) + + for i in range(tgt_len): + fixed_attention_subset = self.compute_fixed_attention_subset(i, tgt_len) + fixed_attention_subset = fixed_attention_subset.union(subset_summaries) + included_word_indices = torch.LongTensor(list(fixed_attention_subset)) + sparse_mask[i].index_fill_(0, included_word_indices, 0) + return sparse_mask.type_as(tensor) + + def apply_sparse_mask(self, attn_weights, tgt_len, src_len, bsz): + sparse_mask = self.buffered_sparse_mask(attn_weights, tgt_len, src_len) + sparse_mask = sparse_mask.unsqueeze(0).expand( + bsz * self.num_heads, tgt_len, src_len + ) + attn_weights += sparse_mask diff --git a/fairseq/fairseq/modules/sparse_transformer_sentence_encoder.py b/fairseq/fairseq/modules/sparse_transformer_sentence_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..f41ec09327fe80b50d20674e7482794ce45c531c --- /dev/null +++ b/fairseq/fairseq/modules/sparse_transformer_sentence_encoder.py @@ -0,0 +1,96 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn as nn +from fairseq.modules import TransformerSentenceEncoder +from fairseq.modules.sparse_transformer_sentence_encoder_layer import ( + SparseTransformerSentenceEncoderLayer, +) + + +class SparseTransformerSentenceEncoder(TransformerSentenceEncoder): + """ + Sparse implementation of the TransformerSentenceEncoder + - see SparseMultiheadAttention + """ + + def __init__( + self, + padding_idx: int, + vocab_size: int, + num_encoder_layers: int = 6, + embedding_dim: int = 768, + ffn_embedding_dim: int = 3072, + num_attention_heads: int = 8, + dropout: float = 0.1, + attention_dropout: float = 0.1, + activation_dropout: float = 0.1, + max_seq_len: int = 256, + num_segments: int = 2, + use_position_embeddings: bool = True, + offset_positions_by_padding: bool = True, + encoder_normalize_before: bool = False, + apply_bert_init: bool = False, + activation_fn: str = "relu", + learned_pos_embedding: bool = True, + embed_scale: float = None, + freeze_embeddings: bool = False, + n_trans_layers_to_freeze: int = 0, + export: bool = False, + is_bidirectional: bool = True, + stride: int = 32, + expressivity: int = 8, + ) -> None: + + super().__init__( + padding_idx, + vocab_size, + num_encoder_layers, + embedding_dim, + ffn_embedding_dim, + num_attention_heads, + dropout, + attention_dropout, + activation_dropout, + max_seq_len, + num_segments, + use_position_embeddings, + offset_positions_by_padding, + encoder_normalize_before, + apply_bert_init, + activation_fn, + learned_pos_embedding, + embed_scale, + freeze_embeddings, + n_trans_layers_to_freeze, + export, + ) + + self.layers = nn.ModuleList( + [ + SparseTransformerSentenceEncoderLayer( + embedding_dim=self.embedding_dim, + ffn_embedding_dim=ffn_embedding_dim, + num_attention_heads=num_attention_heads, + dropout=dropout, + attention_dropout=attention_dropout, + activation_dropout=activation_dropout, + activation_fn=activation_fn, + export=export, + is_bidirectional=is_bidirectional, + stride=stride, + expressivity=expressivity, + ) + for _ in range(num_encoder_layers) + ] + ) + + def freeze_module_params(m): + if m is not None: + for p in m.parameters(): + p.requires_grad = False + + for layer in range(n_trans_layers_to_freeze): + freeze_module_params(self.layers[layer]) diff --git a/fairseq/fairseq/modules/sparse_transformer_sentence_encoder_layer.py b/fairseq/fairseq/modules/sparse_transformer_sentence_encoder_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..d95da59c2471bfa858fd627605196d7f41f9ec12 --- /dev/null +++ b/fairseq/fairseq/modules/sparse_transformer_sentence_encoder_layer.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.modules import TransformerSentenceEncoderLayer +from fairseq.modules.sparse_multihead_attention import SparseMultiheadAttention + + +class SparseTransformerSentenceEncoderLayer(TransformerSentenceEncoderLayer): + """ + Implements a Sprase Transformer Encoder Layer (see SparseMultiheadAttention) + """ + + def __init__( + self, + embedding_dim: int = 768, + ffn_embedding_dim: int = 3072, + num_attention_heads: int = 8, + dropout: float = 0.1, + attention_dropout: float = 0.1, + activation_dropout: float = 0.1, + activation_fn: str = "relu", + export: bool = False, + is_bidirectional: bool = True, + stride: int = 32, + expressivity: int = 8, + ) -> None: + + super().__init__( + embedding_dim, + ffn_embedding_dim, + num_attention_heads, + dropout, + attention_dropout, + activation_dropout, + activation_fn, + export, + ) + + self.self_attn = SparseMultiheadAttention( + self.embedding_dim, + num_attention_heads, + dropout=attention_dropout, + add_bias_kv=False, + add_zero_attn=False, + self_attention=True, + is_bidirectional=is_bidirectional, + stride=stride, + expressivity=expressivity, + ) diff --git a/fairseq/fairseq/modules/transformer_layer.py b/fairseq/fairseq/modules/transformer_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..347b8118daa2818af5e0230a793f2fa8fcd63b3a --- /dev/null +++ b/fairseq/fairseq/modules/transformer_layer.py @@ -0,0 +1,459 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Dict, List, Optional + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.modules import LayerNorm, MultiheadAttention +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise +from torch import Tensor +from fairseq.models.transformer import ( + TransformerConfig, +) + + +class TransformerEncoderLayerBase(nn.Module): + """Encoder layer block. + + In the original paper each operation (multi-head attention or FFN) is + postprocessed with: `dropout -> add residual -> layernorm`. In the + tensor2tensor code they suggest that learning is more robust when + preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *cfg.encoder.normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + + def __init__(self, cfg): + super().__init__() + self.cfg = cfg + self.embed_dim = cfg.encoder.embed_dim + self.quant_noise = cfg.quant_noise.pq + self.quant_noise_block_size = cfg.quant_noise.pq_block_size + self.self_attn = self.build_self_attention(self.embed_dim, cfg) + self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export) + self.dropout_module = FairseqDropout( + cfg.dropout, module_name=self.__class__.__name__ + ) + self.activation_fn = utils.get_activation_fn(activation=cfg.activation_fn) + activation_dropout_p = cfg.activation_dropout + if activation_dropout_p == 0: + # for backwards compatibility with models that use cfg.relu_dropout + activation_dropout_p = cfg.relu_dropout or 0 + self.activation_dropout_module = FairseqDropout( + float(activation_dropout_p), module_name=self.__class__.__name__ + ) + self.normalize_before = cfg.encoder.normalize_before + self.fc1 = self.build_fc1( + self.embed_dim, + cfg.encoder.ffn_embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + self.fc2 = self.build_fc2( + cfg.encoder.ffn_embed_dim, + self.embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + + self.final_layer_norm = LayerNorm(self.embed_dim, export=cfg.export) + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise( + nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size + ) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise( + nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size + ) + + def build_self_attention(self, embed_dim, cfg): + return MultiheadAttention( + embed_dim, + cfg.encoder.attention_heads, + dropout=cfg.attention_dropout, + self_attention=True, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + ) + + def residual_connection(self, x, residual): + return residual + x + + def upgrade_state_dict_named(self, state_dict, name): + """ + Rename layer norm states from `...layer_norms.0.weight` to + `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to + `...final_layer_norm.weight` + """ + layer_norm_map = {"0": "self_attn_layer_norm", "1": "final_layer_norm"} + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layer_norms.{}.{}".format(name, old, m) + if k in state_dict: + state_dict["{}.{}.{}".format(name, new, m)] = state_dict[k] + del state_dict[k] + + def forward( + self, + x, + encoder_padding_mask: Optional[Tensor], + attn_mask: Optional[Tensor] = None, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor): binary ByteTensor of shape + `(batch, seq_len)` where padding elements are indicated by ``1``. + attn_mask (ByteTensor): binary tensor of shape `(tgt_len, src_len)`, + where `tgt_len` is the length of output and `src_len` is the + length of input, though here both are equal to `seq_len`. + `attn_mask[tgt_i, src_j] = 1` means that when calculating the + embedding for `tgt_i`, we exclude (mask out) `src_j`. This is + useful for strided self-attention. + + Returns: + encoded output of shape `(seq_len, batch, embed_dim)` + """ + # anything in original attn_mask = 1, becomes -1e8 + # anything in original attn_mask = 0, becomes 0 + # Note that we cannot use -inf here, because at some edge cases, + # the attention weight (before softmax) for some padded element in query + # will become -inf, which results in NaN in model parameters + if attn_mask is not None: + attn_mask = attn_mask.masked_fill( + attn_mask.to(torch.bool), + -1e8 if x.dtype == torch.float32 else -1e4 + ) + + residual = x + if self.normalize_before: + x = self.self_attn_layer_norm(x) + x, _ = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=encoder_padding_mask, + need_weights=False, + attn_mask=attn_mask, + ) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.final_layer_norm(x) + return x + + +# backward compatible with the legacy argparse format +class TransformerEncoderLayer(TransformerEncoderLayerBase): + def __init__(self, args): + super().__init__(TransformerConfig.from_namespace(args)) + self.args = args + + def build_self_attention(self, embed_dim, args): + return super().build_self_attention( + embed_dim, TransformerConfig.from_namespace(args) + ) + + +class TransformerDecoderLayerBase(nn.Module): + """Decoder layer block. + + In the original paper each operation (multi-head attention, encoder + attention or FFN) is postprocessed with: `dropout -> add residual -> + layernorm`. In the tensor2tensor code they suggest that learning is more + robust when preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *cfg.decoder.normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, cfg, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False + ): + super().__init__() + self.embed_dim = cfg.decoder.embed_dim + self.dropout_module = FairseqDropout( + cfg.dropout, module_name=self.__class__.__name__ + ) + self.quant_noise = cfg.quant_noise.pq + self.quant_noise_block_size = cfg.quant_noise.pq_block_size + + self.cross_self_attention = cfg.cross_self_attention + + self.self_attn = self.build_self_attention( + self.embed_dim, + cfg, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + ) + + self.activation_fn = utils.get_activation_fn(activation=cfg.activation_fn) + activation_dropout_p = cfg.activation_dropout + if activation_dropout_p == 0: + # for backwards compatibility with models that use cfg.relu_dropout + activation_dropout_p = cfg.relu_dropout or 0 + self.activation_dropout_module = FairseqDropout( + float(activation_dropout_p), module_name=self.__class__.__name__ + ) + self.normalize_before = cfg.decoder.normalize_before + + self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export) + + if no_encoder_attn: + self.encoder_attn = None + self.encoder_attn_layer_norm = None + else: + self.encoder_attn = self.build_encoder_attention(self.embed_dim, cfg) + self.encoder_attn_layer_norm = LayerNorm(self.embed_dim, export=cfg.export) + + self.fc1 = self.build_fc1( + self.embed_dim, + cfg.decoder.ffn_embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + self.fc2 = self.build_fc2( + cfg.decoder.ffn_embed_dim, + self.embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + + self.final_layer_norm = LayerNorm(self.embed_dim, export=cfg.export) + self.need_attn = True + + self.onnx_trace = False + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_self_attention( + self, embed_dim, cfg, add_bias_kv=False, add_zero_attn=False + ): + return MultiheadAttention( + embed_dim, + cfg.decoder.attention_heads, + dropout=cfg.attention_dropout, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + self_attention=not cfg.cross_self_attention, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + ) + + def build_encoder_attention(self, embed_dim, cfg): + return MultiheadAttention( + embed_dim, + cfg.decoder.attention_heads, + kdim=cfg.encoder.embed_dim, + vdim=cfg.encoder.embed_dim, + dropout=cfg.attention_dropout, + encoder_decoder_attention=True, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + ) + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def residual_connection(self, x, residual): + return residual + x + + def forward( + self, + x, + encoder_out: Optional[torch.Tensor] = None, + encoder_padding_mask: Optional[torch.Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + prev_self_attn_state: Optional[List[torch.Tensor]] = None, + prev_attn_state: Optional[List[torch.Tensor]] = None, + self_attn_mask: Optional[torch.Tensor] = None, + self_attn_padding_mask: Optional[torch.Tensor] = None, + need_attn: bool = False, + need_head_weights: bool = False, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor, optional): binary + ByteTensor of shape `(batch, src_len)` where padding + elements are indicated by ``1``. + need_attn (bool, optional): return attention weights + need_head_weights (bool, optional): return attention weights + for each head (default: return average over heads). + + Returns: + encoded output of shape `(seq_len, batch, embed_dim)` + """ + if need_head_weights: + need_attn = True + + residual = x + if self.normalize_before: + x = self.self_attn_layer_norm(x) + if prev_self_attn_state is not None: + prev_key, prev_value = prev_self_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_self_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_self_attn_state[2] + assert incremental_state is not None + self.self_attn._set_input_buffer(incremental_state, saved_state) + _self_attn_input_buffer = self.self_attn._get_input_buffer(incremental_state) + if self.cross_self_attention and not ( + incremental_state is not None + and _self_attn_input_buffer is not None + and "prev_key" in _self_attn_input_buffer + ): + if self_attn_mask is not None: + assert encoder_out is not None + self_attn_mask = torch.cat( + (x.new_zeros(x.size(0), encoder_out.size(0)), self_attn_mask), dim=1 + ) + if self_attn_padding_mask is not None: + if encoder_padding_mask is None: + assert encoder_out is not None + encoder_padding_mask = self_attn_padding_mask.new_zeros( + encoder_out.size(1), encoder_out.size(0) + ) + self_attn_padding_mask = torch.cat( + (encoder_padding_mask, self_attn_padding_mask), dim=1 + ) + assert encoder_out is not None + y = torch.cat((encoder_out, x), dim=0) + else: + y = x + + x, attn = self.self_attn( + query=x, + key=y, + value=y, + key_padding_mask=self_attn_padding_mask, + incremental_state=incremental_state, + need_weights=False, + attn_mask=self_attn_mask, + ) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + if self.encoder_attn is not None and encoder_out is not None: + residual = x + if self.normalize_before: + x = self.encoder_attn_layer_norm(x) + if prev_attn_state is not None: + prev_key, prev_value = prev_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_attn_state[2] + assert incremental_state is not None + self.encoder_attn._set_input_buffer(incremental_state, saved_state) + + x, attn = self.encoder_attn( + query=x, + key=encoder_out, + value=encoder_out, + key_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + static_kv=True, + need_weights=need_attn or (not self.training and self.need_attn), + need_head_weights=need_head_weights, + ) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.encoder_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.final_layer_norm(x) + if self.onnx_trace and incremental_state is not None: + saved_state = self.self_attn._get_input_buffer(incremental_state) + assert saved_state is not None + if self_attn_padding_mask is not None: + self_attn_state = [ + saved_state["prev_key"], + saved_state["prev_value"], + saved_state["prev_key_padding_mask"], + ] + else: + self_attn_state = [saved_state["prev_key"], saved_state["prev_value"]] + return x, attn, self_attn_state + return x, attn, None + + def make_generation_fast_(self, need_attn: bool = False, **kwargs): + self.need_attn = need_attn + + +# backward compatible with the legacy argparse format +class TransformerDecoderLayer(TransformerDecoderLayerBase): + def __init__( + self, args, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False + ): + super().__init__( + TransformerConfig.from_namespace(args), + no_encoder_attn=no_encoder_attn, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + ) + self.args = args + + def build_self_attention( + self, embed_dim, args, add_bias_kv=False, add_zero_attn=False + ): + return super().build_self_attention( + embed_dim, + TransformerConfig.from_namespace(args), + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + ) + + def build_encoder_attention(self, embed_dim, args): + return super().build_encoder_attention( + embed_dim, + TransformerConfig.from_namespace(args), + ) diff --git a/fairseq/fairseq/modules/transformer_sentence_encoder.py b/fairseq/fairseq/modules/transformer_sentence_encoder.py new file mode 100644 index 0000000000000000000000000000000000000000..d0540d69229fb994b9e573a5016c9f239b7929e2 --- /dev/null +++ b/fairseq/fairseq/modules/transformer_sentence_encoder.py @@ -0,0 +1,291 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Optional, Tuple + +import torch +import torch.nn as nn +from fairseq.modules import ( + FairseqDropout, + LayerDropModuleList, + LayerNorm, + MultiheadAttention, + PositionalEmbedding, + TransformerSentenceEncoderLayer, +) +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ + + +def init_bert_params(module): + """ + Initialize the weights specific to the BERT Model. + This overrides the default initializations depending on the specified arguments. + 1. If normal_init_linear_weights is set then weights of linear + layer will be initialized using the normal distribution and + bais will be set to the specified value. + 2. If normal_init_embed_weights is set then weights of embedding + layer will be initialized using the normal distribution. + 3. If normal_init_proj_weights is set then weights of + in_project_weight for MultiHeadAttention initialized using + the normal distribution (to be validated). + """ + + def normal_(data): + # with FSDP, module params will be on CUDA, so we cast them back to CPU + # so that the RNG is consistent with and without FSDP + data.copy_( + data.cpu().normal_(mean=0.0, std=0.02).to(data.device) + ) + + if isinstance(module, nn.Linear): + normal_(module.weight.data) + if module.bias is not None: + module.bias.data.zero_() + if isinstance(module, nn.Embedding): + normal_(module.weight.data) + if module.padding_idx is not None: + module.weight.data[module.padding_idx].zero_() + if isinstance(module, MultiheadAttention): + normal_(module.q_proj.weight.data) + normal_(module.k_proj.weight.data) + normal_(module.v_proj.weight.data) + + +class TransformerSentenceEncoder(nn.Module): + """ + Implementation for a Bi-directional Transformer based Sentence Encoder used + in BERT/XLM style pre-trained models. + + This first computes the token embedding using the token embedding matrix, + position embeddings (if specified) and segment embeddings + (if specified). After applying the specified number of + TransformerEncoderLayers, it outputs all the internal states of the + encoder as well as the final representation associated with the first + token (usually CLS token). + + Input: + - tokens: B x T matrix representing sentences + - segment_labels: B x T matrix representing segment label for tokens + + Output: + - a tuple of the following: + - a list of internal model states used to compute the + predictions where each tensor has shape T x B x C + - sentence representation associated with first input token + in format B x C. + """ + + def __init__( + self, + padding_idx: int, + vocab_size: int, + num_encoder_layers: int = 6, + embedding_dim: int = 768, + ffn_embedding_dim: int = 3072, + num_attention_heads: int = 8, + dropout: float = 0.1, + attention_dropout: float = 0.1, + activation_dropout: float = 0.1, + layerdrop: float = 0.0, + max_seq_len: int = 256, + num_segments: int = 2, + use_position_embeddings: bool = True, + offset_positions_by_padding: bool = True, + encoder_normalize_before: bool = False, + apply_bert_init: bool = False, + activation_fn: str = "relu", + learned_pos_embedding: bool = True, + embed_scale: float = None, + freeze_embeddings: bool = False, + n_trans_layers_to_freeze: int = 0, + export: bool = False, + traceable: bool = False, + q_noise: float = 0.0, + qn_block_size: int = 8, + ) -> None: + + super().__init__() + self.padding_idx = padding_idx + self.vocab_size = vocab_size + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.layerdrop = layerdrop + self.max_seq_len = max_seq_len + self.embedding_dim = embedding_dim + self.num_segments = num_segments + self.use_position_embeddings = use_position_embeddings + self.apply_bert_init = apply_bert_init + self.learned_pos_embedding = learned_pos_embedding + self.traceable = traceable + + self.embed_tokens = self.build_embedding( + self.vocab_size, self.embedding_dim, self.padding_idx + ) + self.embed_scale = embed_scale + + if q_noise > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(self.embedding_dim, self.embedding_dim, bias=False), + q_noise, + qn_block_size, + ) + else: + self.quant_noise = None + + self.segment_embeddings = ( + nn.Embedding(self.num_segments, self.embedding_dim, padding_idx=None) + if self.num_segments > 0 + else None + ) + + self.embed_positions = ( + PositionalEmbedding( + self.max_seq_len, + self.embedding_dim, + padding_idx=(self.padding_idx if offset_positions_by_padding else None), + learned=self.learned_pos_embedding, + ) + if self.use_position_embeddings + else None + ) + + if encoder_normalize_before: + self.emb_layer_norm = LayerNorm(self.embedding_dim, export=export) + else: + self.emb_layer_norm = None + + if self.layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.layerdrop) + else: + self.layers = nn.ModuleList([]) + self.layers.extend( + [ + self.build_transformer_sentence_encoder_layer( + embedding_dim=self.embedding_dim, + ffn_embedding_dim=ffn_embedding_dim, + num_attention_heads=num_attention_heads, + dropout=self.dropout_module.p, + attention_dropout=attention_dropout, + activation_dropout=activation_dropout, + activation_fn=activation_fn, + export=export, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + for _ in range(num_encoder_layers) + ] + ) + + # Apply initialization of model params after building the model + if self.apply_bert_init: + self.apply(init_bert_params) + + def freeze_module_params(m): + if m is not None: + for p in m.parameters(): + p.requires_grad = False + + if freeze_embeddings: + freeze_module_params(self.embed_tokens) + freeze_module_params(self.segment_embeddings) + freeze_module_params(self.embed_positions) + freeze_module_params(self.emb_layer_norm) + + for layer in range(n_trans_layers_to_freeze): + freeze_module_params(self.layers[layer]) + + def build_embedding(self, vocab_size, embedding_dim, padding_idx): + return nn.Embedding(vocab_size, embedding_dim, padding_idx) + + def build_transformer_sentence_encoder_layer( + self, + embedding_dim, + ffn_embedding_dim, + num_attention_heads, + dropout, + attention_dropout, + activation_dropout, + activation_fn, + export, + q_noise, + qn_block_size, + ): + return TransformerSentenceEncoderLayer( + embedding_dim=embedding_dim, + ffn_embedding_dim=ffn_embedding_dim, + num_attention_heads=num_attention_heads, + dropout=dropout, + attention_dropout=attention_dropout, + activation_dropout=activation_dropout, + activation_fn=activation_fn, + export=export, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + + def forward( + self, + tokens: torch.Tensor, + segment_labels: torch.Tensor = None, + last_state_only: bool = False, + positions: Optional[torch.Tensor] = None, + token_embeddings: Optional[torch.Tensor] = None, + attn_mask: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + is_tpu = tokens.device.type == "xla" + + # compute padding mask. This is needed for multi-head attention + padding_mask = tokens.eq(self.padding_idx) + if not self.traceable and not is_tpu and not padding_mask.any(): + padding_mask = None + + if token_embeddings is not None: + x = token_embeddings + else: + x = self.embed_tokens(tokens) + + if self.embed_scale is not None: + x = x * self.embed_scale + + if self.embed_positions is not None: + x = x + self.embed_positions(tokens, positions=positions) + + if self.segment_embeddings is not None and segment_labels is not None: + x = x + self.segment_embeddings(segment_labels) + + if self.quant_noise is not None: + x = self.quant_noise(x) + + if self.emb_layer_norm is not None: + x = self.emb_layer_norm(x) + + x = self.dropout_module(x) + + # account for padding while computing the representation + if padding_mask is not None: + x = x * (1 - padding_mask.unsqueeze(-1).type_as(x)) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + inner_states = [] + if not last_state_only: + inner_states.append(x) + + for layer in self.layers: + x, _ = layer(x, self_attn_padding_mask=padding_mask, self_attn_mask=attn_mask) + if not last_state_only: + inner_states.append(x) + + sentence_rep = x[0, :, :] + + if last_state_only: + inner_states = [x] + + if self.traceable: + return torch.stack(inner_states), sentence_rep + else: + return inner_states, sentence_rep diff --git a/fairseq/fairseq/modules/transformer_sentence_encoder_layer.py b/fairseq/fairseq/modules/transformer_sentence_encoder_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..f869c4b2f8fb15f96a292e39bd293df7898a4fce --- /dev/null +++ b/fairseq/fairseq/modules/transformer_sentence_encoder_layer.py @@ -0,0 +1,139 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Callable, Optional + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.modules import LayerNorm, MultiheadAttention +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise + + +class TransformerSentenceEncoderLayer(nn.Module): + """ + Implements a Transformer Encoder Layer used in BERT/XLM style pre-trained + models. + """ + + def __init__( + self, + embedding_dim: int = 768, + ffn_embedding_dim: int = 3072, + num_attention_heads: int = 8, + dropout: float = 0.1, + attention_dropout: float = 0.1, + activation_dropout: float = 0.1, + activation_fn: str = "relu", + export: bool = False, + q_noise: float = 0.0, + qn_block_size: int = 8, + init_fn: Callable = None, + ) -> None: + super().__init__() + + if init_fn is not None: + init_fn() + + # Initialize parameters + self.embedding_dim = embedding_dim + self.num_attention_heads = num_attention_heads + self.attention_dropout = attention_dropout + self.q_noise = q_noise + self.qn_block_size = qn_block_size + + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + self.activation_dropout_module = FairseqDropout( + activation_dropout, module_name=self.__class__.__name__ + ) + + # Initialize blocks + self.activation_fn = utils.get_activation_fn(activation_fn) + self.self_attn = self.build_self_attention( + self.embedding_dim, + num_attention_heads, + dropout=attention_dropout, + self_attention=True, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + + # layer norm associated with the self attention layer + self.self_attn_layer_norm = LayerNorm(self.embedding_dim, export=export) + + self.fc1 = self.build_fc1( + self.embedding_dim, + ffn_embedding_dim, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + self.fc2 = self.build_fc2( + ffn_embedding_dim, + self.embedding_dim, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + + # layer norm associated with the position wise feed-forward NN + self.final_layer_norm = LayerNorm(self.embedding_dim, export=export) + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_self_attention( + self, + embed_dim, + num_attention_heads, + dropout, + self_attention, + q_noise, + qn_block_size, + ): + return MultiheadAttention( + embed_dim, + num_attention_heads, + dropout=dropout, + self_attention=True, + q_noise=q_noise, + qn_block_size=qn_block_size, + ) + + def forward( + self, + x: torch.Tensor, + self_attn_mask: Optional[torch.Tensor] = None, + self_attn_padding_mask: Optional[torch.Tensor] = None, + ): + """ + LayerNorm is applied either before or after the self-attention/ffn + modules similar to the original Transformer implementation. + """ + residual = x + x, attn = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=self_attn_padding_mask, + need_weights=False, + attn_mask=self_attn_mask, + ) + x = self.dropout_module(x) + x = residual + x + x = self.self_attn_layer_norm(x) + + residual = x + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + x = self.fc2(x) + x = self.dropout_module(x) + x = residual + x + x = self.final_layer_norm(x) + return x, attn diff --git a/fairseq/fairseq/modules/transpose_last.py b/fairseq/fairseq/modules/transpose_last.py new file mode 100644 index 0000000000000000000000000000000000000000..e578b3ec5097bfac5c976b207ea46bec1d9bd4f5 --- /dev/null +++ b/fairseq/fairseq/modules/transpose_last.py @@ -0,0 +1,20 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +transpose last 2 dimensions of the input +""" + +import torch.nn as nn + + +class TransposeLast(nn.Module): + def __init__(self, deconstruct_idx=None): + super().__init__() + self.deconstruct_idx = deconstruct_idx + + def forward(self, x): + if self.deconstruct_idx is not None: + x = x[self.deconstruct_idx] + return x.transpose(-2, -1) diff --git a/fairseq/fairseq/modules/unfold.py b/fairseq/fairseq/modules/unfold.py new file mode 100644 index 0000000000000000000000000000000000000000..138272f1ef4f673b29e36aed4531106f7ce95968 --- /dev/null +++ b/fairseq/fairseq/modules/unfold.py @@ -0,0 +1,19 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.nn.functional as F + + +def unfold1d(x, kernel_size, padding_l, pad_value=0): + """unfold T x B x C to T x B x C x K""" + if kernel_size > 1: + T, B, C = x.size() + x = F.pad( + x, (0, 0, 0, 0, padding_l, kernel_size - 1 - padding_l), value=pad_value + ) + x = x.as_strided((T, B, C, kernel_size), (B * C, C, 1, B * C)) + else: + x = x.unsqueeze(3) + return x diff --git a/fairseq/fairseq/modules/vggblock.py b/fairseq/fairseq/modules/vggblock.py new file mode 100644 index 0000000000000000000000000000000000000000..ee5ee19a34816c7350c21fba7c4907fec8ca7a61 --- /dev/null +++ b/fairseq/fairseq/modules/vggblock.py @@ -0,0 +1,116 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +from collections.abc import Iterable +from itertools import repeat + +import torch +import torch.nn as nn + + +def _pair(v): + if isinstance(v, Iterable): + assert len(v) == 2, "len(v) != 2" + return v + return tuple(repeat(v, 2)) + + +def infer_conv_output_dim(conv_op, input_dim, sample_inchannel): + sample_seq_len = 200 + sample_bsz = 10 + x = torch.randn(sample_bsz, sample_inchannel, sample_seq_len, input_dim) + # N x C x H x W + # N: sample_bsz, C: sample_inchannel, H: sample_seq_len, W: input_dim + x = conv_op(x) + # N x C x H x W + x = x.transpose(1, 2) + # N x H x C x W + bsz, seq = x.size()[:2] + per_channel_dim = x.size()[3] + # bsz: N, seq: H, CxW the rest + return x.contiguous().view(bsz, seq, -1).size(-1), per_channel_dim + + +class VGGBlock(torch.nn.Module): + """ + VGG motibated cnn module https://arxiv.org/pdf/1409.1556.pdf + + Args: + in_channels: (int) number of input channels (typically 1) + out_channels: (int) number of output channels + conv_kernel_size: convolution channels + pooling_kernel_size: the size of the pooling window to take a max over + num_conv_layers: (int) number of convolution layers + input_dim: (int) input dimension + conv_stride: the stride of the convolving kernel. + Can be a single number or a tuple (sH, sW) Default: 1 + padding: implicit paddings on both sides of the input. + Can be a single number or a tuple (padH, padW). Default: None + layer_norm: (bool) if layer norm is going to be applied. Default: False + + Shape: + Input: BxCxTxfeat, i.e. (batch_size, input_size, timesteps, features) + Output: BxCxTxfeat, i.e. (batch_size, input_size, timesteps, features) + """ + + def __init__( + self, + in_channels, + out_channels, + conv_kernel_size, + pooling_kernel_size, + num_conv_layers, + input_dim, + conv_stride=1, + padding=None, + layer_norm=False, + ): + assert ( + input_dim is not None + ), "Need input_dim for LayerNorm and infer_conv_output_dim" + super(VGGBlock, self).__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.conv_kernel_size = _pair(conv_kernel_size) + self.pooling_kernel_size = _pair(pooling_kernel_size) + self.num_conv_layers = num_conv_layers + self.padding = ( + tuple(e // 2 for e in self.conv_kernel_size) + if padding is None + else _pair(padding) + ) + self.conv_stride = _pair(conv_stride) + + self.layers = nn.ModuleList() + for layer in range(num_conv_layers): + conv_op = nn.Conv2d( + in_channels if layer == 0 else out_channels, + out_channels, + self.conv_kernel_size, + stride=self.conv_stride, + padding=self.padding, + ) + self.layers.append(conv_op) + if layer_norm: + conv_output_dim, per_channel_dim = infer_conv_output_dim( + conv_op, input_dim, in_channels if layer == 0 else out_channels + ) + self.layers.append(nn.LayerNorm(per_channel_dim)) + input_dim = per_channel_dim + self.layers.append(nn.ReLU()) + + if self.pooling_kernel_size is not None: + pool_op = nn.MaxPool2d(kernel_size=self.pooling_kernel_size, ceil_mode=True) + self.layers.append(pool_op) + self.total_output_dim, self.output_dim = infer_conv_output_dim( + pool_op, input_dim, out_channels + ) + + def forward(self, x): + for i, _ in enumerate(self.layers): + x = self.layers[i](x) + return x diff --git a/fairseq/fairseq/nan_detector.py b/fairseq/fairseq/nan_detector.py new file mode 100644 index 0000000000000000000000000000000000000000..faa8031d4666c9ba9837919fe1c884dacf47ac3a --- /dev/null +++ b/fairseq/fairseq/nan_detector.py @@ -0,0 +1,108 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch + + +logger = logging.getLogger(__name__) + + +class NanDetector: + """ + Detects the first NaN or Inf in forward and/or backward pass and logs, together with the module name + """ + + def __init__(self, model, forward=True, backward=True): + self.bhooks = [] + self.fhooks = [] + self.forward = forward + self.backward = backward + self.named_parameters = list(model.named_parameters()) + self.reset() + + for name, mod in model.named_modules(): + mod.__module_name = name + self.add_hooks(mod) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, exc_traceback): + # Dump out all model gnorms to enable better debugging + norm = {} + gradients = {} + for name, param in self.named_parameters: + if param.grad is not None: + grad_norm = torch.norm(param.grad.data, p=2, dtype=torch.float32) + norm[name] = grad_norm.item() + if torch.isnan(grad_norm).any() or torch.isinf(grad_norm).any(): + gradients[name] = param.grad.data + if len(gradients) > 0: + logger.info("Detected nan/inf grad norm, dumping norms...") + logger.info(f"norms: {norm}") + logger.info(f"gradients: {gradients}") + + self.close() + + def add_hooks(self, module): + if self.forward: + self.fhooks.append(module.register_forward_hook(self.fhook_fn)) + if self.backward: + self.bhooks.append(module.register_backward_hook(self.bhook_fn)) + + def reset(self): + self.has_printed_f = False + self.has_printed_b = False + + def _detect(self, tensor, name, backward): + err = None + if ( + torch.is_floating_point(tensor) + # single value tensors (like the loss) will not provide much info + and tensor.numel() >= 2 + ): + with torch.no_grad(): + if torch.isnan(tensor).any(): + err = "NaN" + elif torch.isinf(tensor).any(): + err = "Inf" + if err is not None: + err = f"{err} detected in output of {name}, shape: {tensor.shape}, {'backward' if backward else 'forward'}" + return err + + def _apply(self, module, inp, x, backward): + if torch.is_tensor(x): + if isinstance(inp, tuple) and len(inp) > 0: + inp = inp[0] + err = self._detect(x, module.__module_name, backward) + if err is not None: + if torch.is_tensor(inp) and not backward: + err += ( + f" input max: {inp.max().item()}, input min: {inp.min().item()}" + ) + + has_printed_attr = "has_printed_b" if backward else "has_printed_f" + logger.warning(err) + setattr(self, has_printed_attr, True) + elif isinstance(x, dict): + for v in x.values(): + self._apply(module, inp, v, backward) + elif isinstance(x, list) or isinstance(x, tuple): + for v in x: + self._apply(module, inp, v, backward) + + def fhook_fn(self, module, inp, output): + if not self.has_printed_f: + self._apply(module, inp, output, backward=False) + + def bhook_fn(self, module, inp, output): + if not self.has_printed_b: + self._apply(module, inp, output, backward=True) + + def close(self): + for hook in self.fhooks + self.bhooks: + hook.remove() diff --git a/fairseq/fairseq/ngram_repeat_block.py b/fairseq/fairseq/ngram_repeat_block.py new file mode 100644 index 0000000000000000000000000000000000000000..854125149448a2d37ad2773cd1e6d614e73e0e79 --- /dev/null +++ b/fairseq/fairseq/ngram_repeat_block.py @@ -0,0 +1,150 @@ +# Originally from Microsoft Corporation. +# Licensed under the MIT License. + +""" Wrapper for ngram_repeat_block cuda extension """ +import torch +from torch import nn + +import math +from typing import Dict, List, Optional +import warnings + +try: + from fairseq import ngram_repeat_block_cuda + + EXTENSION_BUILT = True +except ImportError: + EXTENSION_BUILT = False + + +def is_cuda_extension_usable() -> bool: + """Check whether ngram_repeat_block_cuda is built properly""" + if not EXTENSION_BUILT or not torch.cuda.is_available(): + return False + bsz = 2 + tokens = torch.tensor([[4, 4, 3, 2], [1, 2, 3, 4]], dtype=torch.long, device="cuda") + lprobs = torch.rand((8, 12), device="cuda") + try: + outputs = ngram_repeat_block_cuda.forward(tokens, lprobs, bsz, 3, 4, 3) + outputs = outputs + 4 # This line breaks if the extension is built incorrectly. + return True + except RuntimeError: + warnings.warn( + "NGramRepeatBlock extension must be rebuilt." + 'Run TORCH_CUDA_ARCH_LIST="6.0;6.1;7.0" python setup.py build_ext --inplace' + ) + return False + + +class NGramRepeatBlock(nn.Module): + """ Wrapper class for calling ngram_repeat_block cuda extension """ + + def __init__(self, no_repeat_ngram_size: int, use_extension: bool = True): + super().__init__() + self.use_extension = is_cuda_extension_usable() if use_extension else False + self.no_repeat_ngram_size = no_repeat_ngram_size + + def reset_parameters(self): + pass + + @torch.jit.unused + def call_cuda_extension( + self, + tokens, + lprobs, + bsz: int, + beam_size: int, + step: int, + ): + return ngram_repeat_block_cuda.forward( + tokens, lprobs, bsz, step, beam_size, self.no_repeat_ngram_size + ) + + def forward( + self, + tokens, + lprobs, + bsz: int, + beam_size: int, + step: int, + ): + """ + Args: + tokens(Tensor): Input tokens(Bsz*beam, seq_len) + lprobs(Tensor): likelihood probability, + Expected to be updated in place.(Bsz*beam, vocab_size) + bsz(int): batch size + step(int): current step + beam_size(int): beam size + no_repeat_ngram_size(int): Ngram size + """ + msg = f"expected {bsz *beam_size} got" + assert tokens.size(0) == bsz * beam_size, f"{msg} {tokens.size(0)}" + assert lprobs.size(0) == bsz * beam_size, f"{msg} {lprobs.size(0)}" + if self.use_extension: + return self.call_cuda_extension(tokens, lprobs, bsz, beam_size, step) + + else: + return self._no_repeat_ngram( + tokens, + lprobs, + bsz, + beam_size, + step, + ) + + def _no_repeat_ngram(self, tokens, lprobs, bsz: int, beam_size: int, step: int): + """For each hypothesis generate a list of previous ngrams and set associated lprobs to -inf""" + gen_ngrams: List[Dict[str, List[int]]] = [ + torch.jit.annotate(Dict[str, List[int]], {}) + for bbsz_idx in range(bsz * beam_size) + ] + cpu_tokens = tokens.cpu() + for bbsz_idx in range(bsz * beam_size): + gen_tokens: List[int] = cpu_tokens[bbsz_idx].tolist() + for ngram in self.transpose_list( + [gen_tokens[i:] for i in range(self.no_repeat_ngram_size)] + ): + key = ",".join([str(x) for x in ngram[:-1]]) + gen_ngrams[bbsz_idx][key] = gen_ngrams[bbsz_idx].get( + key, torch.jit.annotate(List[int], []) + ) + [ngram[-1]] + if step + 2 - self.no_repeat_ngram_size >= 0: + # no banned tokens if we haven't generated no_repeat_ngram_size tokens yet + banned_tokens = [ + self.calculate_banned_tokens( + tokens, step, gen_ngrams, self.no_repeat_ngram_size, bbsz_idx + ) + for bbsz_idx in range(bsz * beam_size) + ] + else: + banned_tokens = [ + torch.jit.annotate(List[int], []) for bbsz_idx in range(bsz * beam_size) + ] + for bbsz_idx in range(bsz * beam_size): + lprobs[bbsz_idx][ + torch.tensor(banned_tokens[bbsz_idx], dtype=torch.int64) + ] = torch.tensor(-math.inf).to(lprobs) + return lprobs + + @staticmethod + def calculate_banned_tokens( + tokens, + step: int, + gen_ngrams: List[Dict[str, List[int]]], + no_repeat_ngram_size: int, + bbsz_idx: int, + ): + tokens_list: List[int] = tokens[ + bbsz_idx, step + 2 - no_repeat_ngram_size : step + 1 + ].tolist() + # before decoding the next token, prevent decoding of ngrams that have already appeared + ngram_index = ",".join([str(x) for x in tokens_list]) + return gen_ngrams[bbsz_idx].get(ngram_index, torch.jit.annotate(List[int], [])) + + @staticmethod + def transpose_list(l: List[List[int]]): + # GeneratorExp aren't supported in TS so ignoring the lint + min_len = min([len(x) for x in l]) # noqa + l2 = [[row[i] for row in l] for i in range(min_len)] + return l2 diff --git a/fairseq/fairseq/optim/__init__.py b/fairseq/fairseq/optim/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..be783be896396ff659c0bd173a7acebb8a2d165d --- /dev/null +++ b/fairseq/fairseq/optim/__init__.py @@ -0,0 +1,48 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import importlib +import os + +from fairseq import registry +from fairseq.optim.bmuf import FairseqBMUF # noqa +from fairseq.optim.fairseq_optimizer import ( # noqa + FairseqOptimizer, + LegacyFairseqOptimizer, +) +from fairseq.optim.amp_optimizer import AMPOptimizer +from fairseq.optim.fp16_optimizer import FP16Optimizer, MemoryEfficientFP16Optimizer +from fairseq.optim.shard import shard_ +from omegaconf import DictConfig + +__all__ = [ + "AMPOptimizer", + "FairseqOptimizer", + "FP16Optimizer", + "MemoryEfficientFP16Optimizer", + "shard_", +] + +( + _build_optimizer, + register_optimizer, + OPTIMIZER_REGISTRY, + OPTIMIZER_DATACLASS_REGISTRY, +) = registry.setup_registry("--optimizer", base_class=FairseqOptimizer, required=True) + + +def build_optimizer(cfg: DictConfig, params, *extra_args, **extra_kwargs): + if all(isinstance(p, dict) for p in params): + params = [t for p in params for t in p.values()] + params = list(filter(lambda p: p.requires_grad, params)) + return _build_optimizer(cfg, params, *extra_args, **extra_kwargs) + + +# automatically import any Python files in the optim/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + file_name = file[: file.find(".py")] + importlib.import_module("fairseq.optim." + file_name) diff --git a/fairseq/fairseq/optim/adadelta.py b/fairseq/fairseq/optim/adadelta.py new file mode 100644 index 0000000000000000000000000000000000000000..f1a21549770f0904a6a40a42ff7eb52811f1bfbe --- /dev/null +++ b/fairseq/fairseq/optim/adadelta.py @@ -0,0 +1,47 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.optim + +from . import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("adadelta") +class Adadelta(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = torch.optim.Adadelta(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--adadelta-rho', type=float, default=0.9, metavar='RHO', + help='coefficient used for computing a running average of squared gradients') + parser.add_argument('--adadelta-eps', type=float, default=1e-6, metavar='EPS', + help='term added to the denominator to improve numerical stability') + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + parser.add_argument('--anneal-eps', action='store_true', help='flag to anneal eps') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "rho": self.args.adadelta_rho, + "eps": self.args.adadelta_eps, + "weight_decay": self.args.weight_decay, + } + + @property + def supports_flat_params(self): + return True diff --git a/fairseq/fairseq/optim/adafactor.py b/fairseq/fairseq/optim/adafactor.py new file mode 100644 index 0000000000000000000000000000000000000000..c969b9fbc0d229a25f2046ec67c53c57a433814b --- /dev/null +++ b/fairseq/fairseq/optim/adafactor.py @@ -0,0 +1,268 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math + +import torch +import torch.optim + +from . import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("adafactor") +class FairseqAdafactor(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = Adafactor(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--adafactor-eps', default='(1e-30, 1e-3)', metavar="E", + help='epsilons for Adafactor optimizer') + parser.add_argument('--clip-threshold', type=float, default=1.0, metavar="C", + help='threshold for clipping update root mean square') + parser.add_argument('--decay-rate', type=float, default=-0.8, metavar="D", + help='decay rate of the second moment estimator') + parser.add_argument('--beta1', type=float, default=None, metavar="B", + help='beta for first moment estimator. Optional') + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + parser.add_argument('--scale-parameter', action='store_true', + help='scale learning rate by root mean square of parameter') + parser.add_argument('--relative-step', action='store_true', + help='set learning rate to inverse square root of timestep,' + 'otherwise use external learning rate') + parser.add_argument('--warmup-init', action='store_true', + help='use relative step for warm-up learning rate schedule') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + Note : Convergence issues empirically observed with fp16 on. + Might require search for appropriate configuration. + """ + return { + "lr": self.args.lr[0], + "eps": eval(self.args.adafactor_eps), + "clip_threshold": self.args.clip_threshold, + "decay_rate": self.args.decay_rate, + "beta1": self.args.beta1, + "weight_decay": self.args.weight_decay, + "scale_parameter": self.args.scale_parameter, # defaults to False + "relative_step": self.args.relative_step, # defaults to False + "warmup_init": self.args.warmup_init, + } + + +class Adafactor(torch.optim.Optimizer): + """Implements Adafactor algorithm. + + This implementation is based on: + `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost` + (see https://arxiv.org/abs/1804.04235) + + Note that this optimizer internally adjusts the learning rate + depending on the *scale_parameter*, *relative_step* and + *warmup_init* options. To use a manual (external) learning rate + schedule you should set `scale_parameter=False` and + `relative_step=False`. + + Args: + params (iterable): iterable of parameters to optimize or dicts defining + parameter groups + lr (float, optional): external learning rate (default: None) + eps (tuple[float, float]): regularization constans for square gradient + and parameter scale respectively (default: (1e-30, 1e-3)) + clip_threshold (float): threshold of root mean square of + final gradient update (default: 1.0) + decay_rate (float): coefficient used to compute running averages of square + gradient (default: -0.8) + beta1 (float): coefficient used for computing running averages of gradient + (default: None) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + scale_parameter (bool): if True, learning rate is scaled by root mean square of + parameter (default: True) + relative_step (bool): if True, time-dependent learning rate is computed + instead of external learning rate (default: True) + warmup_init (bool): time-dependent learning rate computation depends on + whether warm-up initialization is being used (default: False) + """ + + def __init__( + self, + params, + lr=None, + eps=(1e-30, 1e-3), + clip_threshold=1.0, + decay_rate=-0.8, + beta1=None, + weight_decay=0.0, + scale_parameter=True, + relative_step=True, + warmup_init=False, + ): + if lr is not None and relative_step: + raise ValueError("Cannot combine manual lr and relative_step options") + if warmup_init and not relative_step: + raise ValueError("warmup_init requires relative_step=True") + + defaults = dict( + lr=lr, + eps=eps, + clip_threshold=clip_threshold, + decay_rate=decay_rate, + beta1=beta1, + weight_decay=weight_decay, + scale_parameter=scale_parameter, + relative_step=relative_step, + warmup_init=warmup_init, + ) + super(Adafactor, self).__init__(params, defaults) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return False + + def _get_lr(self, param_group, param_state): + rel_step_sz = param_group["lr"] + if param_group["relative_step"]: + min_step = ( + 1e-6 * param_state["step"] if param_group["warmup_init"] else 1e-2 + ) + rel_step_sz = min(min_step, 1.0 / math.sqrt(param_state["step"])) + param_scale = 1.0 + if param_group["scale_parameter"]: + param_scale = max(param_group["eps"][1], param_state["RMS"]) + return param_scale * rel_step_sz + + def _get_options(self, param_group, param_shape): + factored = len(param_shape) >= 2 + use_first_moment = param_group["beta1"] is not None + return factored, use_first_moment + + def _rms(self, tensor): + return tensor.norm(2) / (tensor.numel() ** 0.5) + + def _approx_sq_grad(self, exp_avg_sq_row, exp_avg_sq_col): + r_factor = ( + (exp_avg_sq_row / exp_avg_sq_row.mean(dim=-1, keepdim=True)) + .rsqrt_() + .unsqueeze(-1) + ) + c_factor = exp_avg_sq_col.unsqueeze(-2).rsqrt() + return torch.mul(r_factor, c_factor) + + def step(self, closure=None): + """Performs a single optimization step. + + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None: + continue + grad = p.grad.data + if grad.dtype in {torch.float16, torch.bfloat16}: + grad = grad.float() + if grad.is_sparse: + raise RuntimeError("Adafactor does not support sparse gradients.") + + state = self.state[p] + grad_shape = grad.shape + + factored, use_first_moment = self._get_options(group, grad_shape) + # State Initialization + if len(state) == 0: + state["step"] = 0 + + if use_first_moment: + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(grad) + if factored: + state["exp_avg_sq_row"] = torch.zeros(grad_shape[:-1]).to(grad) + state["exp_avg_sq_col"] = torch.zeros( + grad_shape[:-2] + grad_shape[-1:] + ).to(grad) + else: + state["exp_avg_sq"] = torch.zeros_like(grad) + + state["RMS"] = 0 + else: + if use_first_moment: + state["exp_avg"] = state["exp_avg"].to(grad) + if factored: + state["exp_avg_sq_row"] = state["exp_avg_sq_row"].to(grad) + state["exp_avg_sq_col"] = state["exp_avg_sq_col"].to(grad) + else: + state["exp_avg_sq"] = state["exp_avg_sq"].to(grad) + + p_data_fp32 = p.data + if p.data.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + state["step"] += 1 + state["RMS"] = self._rms(p_data_fp32) + group["lr"] = self._get_lr(group, state) + + beta2t = 1.0 - math.pow(state["step"], group["decay_rate"]) + update = (grad ** 2) + group["eps"][0] + if factored: + exp_avg_sq_row = state["exp_avg_sq_row"] + exp_avg_sq_col = state["exp_avg_sq_col"] + + exp_avg_sq_row.mul_(beta2t).add_( + update.mean(dim=-1), alpha=1.0 - beta2t + ) + exp_avg_sq_col.mul_(beta2t).add_( + update.mean(dim=-2), alpha=1.0 - beta2t + ) + + # Approximation of exponential moving average of square of gradient + update = self._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col) + update.mul_(grad) + else: + exp_avg_sq = state["exp_avg_sq"] + + exp_avg_sq.mul_(beta2t).add_(update, alpha=1.0 - beta2t) + update = exp_avg_sq.rsqrt().mul_(grad) + + update.div_( + (self._rms(update) / group["clip_threshold"]).clamp_(min=1.0) + ) + update.mul_(group["lr"]) + + if use_first_moment: + exp_avg = state["exp_avg"] + exp_avg.mul_(group["beta1"]).add_(update, alpha=1 - group["beta1"]) + update = exp_avg + + if group["weight_decay"] != 0: + p_data_fp32.add_( + p_data_fp32, alpha=-group["weight_decay"] * group["lr"] + ) + + p_data_fp32.add_(-update) + + if p.data.dtype in {torch.float16, torch.bfloat16}: + p.data.copy_(p_data_fp32) + + return loss diff --git a/fairseq/fairseq/optim/adagrad.py b/fairseq/fairseq/optim/adagrad.py new file mode 100644 index 0000000000000000000000000000000000000000..4f539541c1c91d8c822f7ce624fa6eabf744f60e --- /dev/null +++ b/fairseq/fairseq/optim/adagrad.py @@ -0,0 +1,40 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.optim + +from . import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("adagrad") +class Adagrad(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = torch.optim.Adagrad(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "weight_decay": self.args.weight_decay, + } + + @property + def supports_flat_params(self): + return False diff --git a/fairseq/fairseq/optim/adam.py b/fairseq/fairseq/optim/adam.py new file mode 100644 index 0000000000000000000000000000000000000000..d3ae9e64a74774310adcd9968d2eae23368890f9 --- /dev/null +++ b/fairseq/fairseq/optim/adam.py @@ -0,0 +1,239 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import math +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import Any, List + +import torch +import torch.distributed as dist +import torch.optim +from fairseq.dataclass import FairseqDataclass +from fairseq.optim import FairseqOptimizer, register_optimizer +from fairseq.optim.fused_adam import get_fused_adam_class +from omegaconf import II, OmegaConf + + +logger = logging.getLogger(__name__) + + +@dataclass +class FairseqAdamConfig(FairseqDataclass): + adam_betas: Any = field( + default=(0.9, 0.999), metadata={"help": "betas for Adam optimizer"} + ) + adam_eps: float = field( + default=1e-8, metadata={"help": "epsilon for Adam optimizer"} + ) + weight_decay: float = field(default=0.0, metadata={"help": "weight decay"}) + use_old_adam: bool = field( + default=False, metadata={"help": "Use fairseq.optim.adam.Adam"} + ) + fp16_adam_stats: bool = field( + default=False, metadata={"help": "use FP16 stats (with automatic scaling)"} + ) + # TODO common vars below in parent + tpu: bool = II("common.tpu") + lr: List[float] = II("optimization.lr") + + +@register_optimizer("adam", dataclass=FairseqAdamConfig) +class FairseqAdam(FairseqOptimizer): + """Adam optimizer for fairseq. + + Important note: this optimizer corresponds to the "AdamW" variant of + Adam in its weight decay behavior. As such, it is most closely + analogous to torch.optim.AdamW from PyTorch. + """ + + def __init__(self, cfg: FairseqAdamConfig, params): + super().__init__(cfg) + fused_adam_cls = get_fused_adam_class() + use_fused_adam = ( + not getattr(cfg, "use_old_adam", False) + and fused_adam_cls is not None + and torch.cuda.is_available() + ) + if getattr(cfg, "tpu", False): + if self.cfg.fp16_adam_stats: + raise NotImplementedError("--fp16-adam-stats is only supported on GPU") + # on TPUs we use the Adam defined here, since it + # automatically casts gradients to FP32 + self._optimizer = Adam(params, **self.optimizer_config) + elif use_fused_adam: + logger.info("using FusedAdam") + self._optimizer = fused_adam_cls( + params, + use_fp16_stats=self.cfg.fp16_adam_stats, + **self.optimizer_config + ) + else: + if self.cfg.fp16_adam_stats: + raise NotImplementedError("--fp16-adam-stats is only supported with FusedAdamV1") + self._optimizer = Adam(params, **self.optimizer_config) + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.cfg.lr[0] + if isinstance(self.cfg.lr, Collection) + else self.cfg.lr, + "betas": eval(self.cfg.adam_betas) + if isinstance(self.cfg.adam_betas, str) + else OmegaConf.to_container(self.cfg.adam_betas), + "eps": self.cfg.adam_eps, + "weight_decay": self.cfg.weight_decay, + } + + def average_params(self): + """Reduce Params is only used during BMUF distributed training.""" + state_dict = self.optimizer.state_dict() + total_gpus = float(dist.get_world_size()) + + for _, value in state_dict["state"].items(): + value["exp_avg"] /= total_gpus + value["exp_avg_sq"] /= total_gpus + dist.all_reduce(value["exp_avg"], op=dist.ReduceOp.SUM) + dist.all_reduce(value["exp_avg_sq"], op=dist.ReduceOp.SUM) + + +class Adam(torch.optim.Optimizer): + r"""Implements Adam algorithm. + + This implementation is modified from torch.optim.Adam based on: + `Fixed Weight Decay Regularization in Adam` + (see https://arxiv.org/abs/1711.05101) + + It has been proposed in `Adam: A Method for Stochastic Optimization`_. + + Args: + params (iterable): iterable of parameters to optimize or dicts defining + parameter groups + lr (float, optional): learning rate (default: 1e-3) + betas (Tuple[float, float], optional): coefficients used for computing + running averages of gradient and its square (default: (0.9, 0.999)) + eps (float, optional): term added to the denominator to improve + numerical stability (default: 1e-8) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + amsgrad (boolean, optional): whether to use the AMSGrad variant of this + algorithm from the paper `On the Convergence of Adam and Beyond`_ + + .. _Adam\: A Method for Stochastic Optimization: + https://arxiv.org/abs/1412.6980 + .. _On the Convergence of Adam and Beyond: + https://openreview.net/forum?id=ryQu7f-RZ + """ + + def __init__( + self, + params, + lr=1e-3, + betas=(0.9, 0.999), + eps=1e-8, + weight_decay=0, + amsgrad=False, + ): + defaults = dict( + lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, amsgrad=amsgrad + ) + super(Adam, self).__init__(params, defaults) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + def step(self, closure=None): + """Performs a single optimization step. + + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None: + continue + grad = p.grad.data + if grad.dtype in {torch.float16, torch.bfloat16}: + grad = grad.float() + if grad.is_sparse: + raise RuntimeError( + "Adam does not support sparse gradients, please consider SparseAdam instead" + ) + amsgrad = group.get("amsgrad", False) + + p_data_fp32 = p.data + if p.data.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + state = self.state[p] + + # State initialization + if len(state) == 0: + state["step"] = 0 + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(p_data_fp32) + # Exponential moving average of squared gradient values + state["exp_avg_sq"] = torch.zeros_like(p_data_fp32) + if amsgrad: + # Maintains max of all exp. moving avg. of sq. grad. values + state["max_exp_avg_sq"] = torch.zeros_like(p_data_fp32) + else: + state["exp_avg"] = state["exp_avg"].to(p_data_fp32) + state["exp_avg_sq"] = state["exp_avg_sq"].to(p_data_fp32) + if amsgrad: + state["max_exp_avg_sq"] = state["max_exp_avg_sq"].to( + p_data_fp32 + ) + + exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"] + if amsgrad: + max_exp_avg_sq = state["max_exp_avg_sq"] + beta1, beta2 = group["betas"] + + state["step"] += 1 + + # Decay the first and second moment running average coefficient + exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1) + exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2) + if amsgrad: + # Maintains the maximum of all 2nd moment running avg. till now + torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq) + # Use the max. for normalizing running avg. of gradient + denom = max_exp_avg_sq.sqrt().add_(group["eps"]) + else: + denom = exp_avg_sq.sqrt().add_(group["eps"]) + + bias_correction1 = 1 - beta1 ** state["step"] + bias_correction2 = 1 - beta2 ** state["step"] + step_size = group["lr"] * math.sqrt(bias_correction2) / bias_correction1 + + if group["weight_decay"] != 0: + p_data_fp32.add_( + p_data_fp32, alpha=-group["weight_decay"] * group["lr"] + ) + + p_data_fp32.addcdiv_(exp_avg, denom, value=-step_size) + + if p.data.dtype in {torch.float16, torch.bfloat16}: + p.data.copy_(p_data_fp32) + + return loss diff --git a/fairseq/fairseq/optim/adamax.py b/fairseq/fairseq/optim/adamax.py new file mode 100644 index 0000000000000000000000000000000000000000..98ff8ad7ad6c12ab5efc53ca76db2f1663be7906 --- /dev/null +++ b/fairseq/fairseq/optim/adamax.py @@ -0,0 +1,172 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import torch.optim + +from . import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("adamax") +class FairseqAdamax(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = Adamax(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--adamax-betas', default='(0.9, 0.999)', metavar='B', + help='betas for Adam optimizer') + parser.add_argument('--adamax-eps', type=float, default=1e-8, metavar='D', + help='epsilon for Adam optimizer') + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + parser.add_argument('--no-bias-correction', default=False, action='store_true', + help='disable bias correction') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "betas": eval(self.args.adamax_betas), + "eps": self.args.adamax_eps, + "weight_decay": self.args.weight_decay, + "bias_correction": not self.args.no_bias_correction, + } + + +class Adamax(torch.optim.Optimizer): + """Implements Adamax algorithm (a variant of Adam based on infinity norm). + + It has been proposed in `Adam: A Method for Stochastic Optimization`__. + + Compared to the version in PyTorch, this version implements a fix for weight decay. + + Args: + params (iterable): iterable of parameters to optimize or dicts defining + parameter groups + lr (float, optional): learning rate (default: 2e-3) + betas (Tuple[float, float], optional): coefficients used for computing + running averages of gradient and its square + eps (float, optional): term added to the denominator to improve + numerical stability (default: 1e-8) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + bias_correction (bool, optional): enable bias correction (default: True) + + __ https://arxiv.org/abs/1412.6980 + """ + + def __init__( + self, + params, + lr=2e-3, + betas=(0.9, 0.999), + eps=1e-8, + weight_decay=0, + bias_correction=True, + ): + if not 0.0 <= lr: + raise ValueError("Invalid learning rate: {}".format(lr)) + if not 0.0 <= eps: + raise ValueError("Invalid epsilon value: {}".format(eps)) + if not 0.0 <= betas[0] < 1.0: + raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0])) + if not 0.0 <= betas[1] < 1.0: + raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1])) + if not 0.0 <= weight_decay: + raise ValueError("Invalid weight_decay value: {}".format(weight_decay)) + + defaults = dict( + lr=lr, + betas=betas, + eps=eps, + weight_decay=weight_decay, + bias_correction=bias_correction, + ) + super(Adamax, self).__init__(params, defaults) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + def step(self, closure=None): + """Performs a single optimization step. + + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None: + continue + grad = p.grad.data.float() + if grad.is_sparse: + raise RuntimeError("Adamax does not support sparse gradients") + + p_data_fp32 = p.data + if p.data.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + state = self.state[p] + + # State initialization + if len(state) == 0: + state["step"] = 0 + state["exp_avg"] = torch.zeros_like(p_data_fp32) + state["exp_inf"] = torch.zeros_like(p_data_fp32) + else: + state["exp_avg"] = state["exp_avg"].to(p_data_fp32) + state["exp_inf"] = state["exp_inf"].to(p_data_fp32) + + exp_avg, exp_inf = state["exp_avg"], state["exp_inf"] + beta1, beta2 = group["betas"] + eps = group["eps"] + + state["step"] += 1 + + # Update biased first moment estimate. + exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1) + + # Update the exponentially weighted infinity norm. + torch.max( + exp_inf.mul_(beta2), + grad.abs_(), + out=exp_inf, + ) + + step_size = group["lr"] + if group["bias_correction"]: + bias_correction = 1 - beta1 ** state["step"] + step_size /= bias_correction + + if group["weight_decay"] != 0: + p_data_fp32.add_( + p_data_fp32, alpha=-group["weight_decay"] * group["lr"] + ) + + p_data_fp32.addcdiv_(exp_avg, exp_inf.add(eps), value=-step_size) + + if p.data.dtype in {torch.float16, torch.bfloat16}: + p.data.copy_(p_data_fp32) + + return loss diff --git a/fairseq/fairseq/optim/amp_optimizer.py b/fairseq/fairseq/optim/amp_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..3b7958e50ce444474c48d1f5aeff05d66c19e5b6 --- /dev/null +++ b/fairseq/fairseq/optim/amp_optimizer.py @@ -0,0 +1,105 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +import torch +from fairseq import optim +from omegaconf import DictConfig + +logger = logging.getLogger(__name__) + + +class AMPOptimizer(optim.FairseqOptimizer): + """ + Wrap an *optimizer* to support AMP (automatic mixed precision) training. + """ + + def __init__(self, cfg: DictConfig, params, fp32_optimizer, **kwargs): + super().__init__(cfg.optimizer) + self.fp32_optimizer = fp32_optimizer + amp_kwargs = {"init_scale": cfg.common.fp16_init_scale} + if getattr(cfg.common, "amp_scale_window", None) is not None: + amp_kwargs["growth_interval"] = cfg.common.amp_init_scale + self._grad_scaler = torch.cuda.amp.GradScaler(**amp_kwargs) + self.min_loss_scale = cfg.common.min_loss_scale + + @classmethod + def build_optimizer(cls, cfg: DictConfig, params, **kwargs): + """ + Args: + cfg (omegaconf.DictConfig): fairseq args + params (iterable): iterable of parameters to optimize + """ + fp32_optimizer = optim.build_optimizer(cfg.optimizer, params) + return cls(cfg, params, fp32_optimizer, **kwargs) + + def backward(self, loss): + """Computes the sum of gradients of the given tensor w.r.t. graph leaves. + + Compared to :func:`fairseq.optim.FairseqOptimizer.backward`, this + function additionally dynamically scales the loss to avoid gradient + underflow. + """ + self._grad_scaler.scale(loss).backward() + + def step(self): + self.scaler.step(self.fp32_optimizer) + self.scaler.update() + + def clip_grad_norm(self, max_norm, aggregate_norm_fn=None): + """Clips gradient norm.""" + self.scaler.unscale_(self.optimizer) + grad_norm = self.fp32_optimizer.clip_grad_norm(max_norm, aggregate_norm_fn) + if not torch.isfinite(grad_norm).all(): + new_loss_scale = self.next_loss_scale + if new_loss_scale <= self.min_loss_scale: + raise FloatingPointError( + ( + "AMP: Minimum loss scale reached ({}). Your loss is probably exploding. " + "Try restarting training or use fp32. {}" + ).format(self.min_loss_scale, new_loss_scale) + ) + else: + logger.info("AMP: overflow detected, setting scale to " + f"to {new_loss_scale}") + return grad_norm + + @property + def scaler(self): + return self._grad_scaler + + @property + def next_loss_scale(self): + return self.scaler.get_scale() * self.scaler.get_backoff_factor() + + @property + def optimizer(self): + return self.fp32_optimizer.optimizer + + @optimizer.setter + def optimizer(self, optimizer): + self.fp32_optimizer.optimizer = optimizer + + @property + def lr_scheduler(self): + return getattr(self.fp32_optimizer, "lr_scheduler", None) + + @property + def optimizer_config(self): + return self.fp32_optimizer.optimizer_config + + def get_lr(self): + return self.fp32_optimizer.get_lr() + + def set_lr(self, lr): + self.fp32_optimizer.set_lr(lr) + + def all_reduce_grads(self, module): + self.fp32_optimizer.all_reduce_grads(module) + + @property + def supports_flat_params(self): + return self.fp32_optimizer.supports_flat_params diff --git a/fairseq/fairseq/optim/bmuf.py b/fairseq/fairseq/optim/bmuf.py new file mode 100644 index 0000000000000000000000000000000000000000..d6d0e04e86eb894efe59e13a78843d01ca9e651d --- /dev/null +++ b/fairseq/fairseq/optim/bmuf.py @@ -0,0 +1,200 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +import torch +import torch.distributed as dist +from fairseq.dataclass.configs import FairseqBMUFConfig +from fairseq.dataclass.utils import gen_parser_from_dataclass +from fairseq.optim.fairseq_optimizer import FairseqOptimizer + + +class FairseqBMUF(FairseqOptimizer): + """ + Implements incremental block distributed data parallelism similar to + https://ieeexplore.ieee.org/document/7472805 + + Paper title: Scalable training of deep learning machines by incremental + block training with intra-block parallel optimization and blockwise + model-update filtering + """ + + def __init__(self, cfg: FairseqBMUFConfig, optimizer): + super().__init__(cfg) + self._optimizer = optimizer + self._num_updates = 0 + self.sync_iter = cfg.global_sync_iter + self.block_momentum = cfg.block_momentum + self.block_lr = cfg.block_lr + self._reset_local_data() + self.warmup_iteration = cfg.warmup_iterations + self.use_nbm = cfg.use_nbm + self.initial_state = self._optimizer.state_dict() + self.average_sync = self.cfg.average_sync + self.world_size = self.cfg.distributed_world_size + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + gen_parser_from_dataclass(parser, FairseqBMUFConfig()) + + @property + def optimizer(self): + return self._optimizer.optimizer + + @property + def optimizer_config(self): + return self._optimizer.optimizer_config + + def get_lr(self): + return self._optimizer.get_lr() + + def set_lr(self, lr): + self._optimizer.set_lr(lr) + + def state_dict(self): + return self._optimizer.state_dict() + + def load_state_dict(self, state_dict, optimizer_overrides=None): + self._optimizer.load_state_dict(state_dict, optimizer_overrides) + self.initial_state = self._optimizer.state_dict() + + def multiply_grads(self, c): + """Multiplies grads by a constant *c*.""" + self._optimizer.multiply_grads(c) + + def clip_grad_norm(self, max_norm, aggregate_norm_fn=None): + """Clips gradient norm.""" + return self._optimizer.clip_grad_norm(max_norm, aggregate_norm_fn) + + def average_params(self): + self._optimizer.average_params() + + def _block_sync(self): + if self.world_size <= 1: + return + # Update the global model using local models from all GPUs + # (Step-1) Calculate grad between previously synced model and + # currrent local model + if self.block_momentum != 0: + self._calc_grad() + + # (Step-2) Average gradient from all GPUs + self._avg_grad_from_all_gpus() + + # (Step-3) Calculate global momentum and update the global model + if self.block_momentum != 0: + self._update_global_model() + + # (Step-4) Average local optimizer params + if self.average_sync: + self.average_params() + + def _is_warmup_end(self): + # Check whether train iterations is equal to warmup iter + if self.get_num_updates() == self.warmup_iteration: + return True + return False + + def _is_bmuf_iter(self): + # Check whether train iterations is equal to bmuf sync iter + if (self.get_num_updates() > self.warmup_iteration) and ( + self.get_num_updates() % self.sync_iter == 0 + ): + return True + return False + + def _warmup_sync(self, root_rank=0): + if self.world_size <= 1: + return + # Broadcast the local model to all gpus + for param in self.params: + dist.broadcast(param.data, src=root_rank) + + # Update local optimizer state + if self.average_sync: + self._optimizer.average_params() + else: + self._optimizer.load_state_dict(self.initial_state) + + self._reset_local_data() + + def step(self, closure=None): + """Performs a single optimization step.""" + self._optimizer.step(closure) + self.set_num_updates(self.get_num_updates() + 1) + if self._is_warmup_end(): + self._warmup_sync() + elif self._is_bmuf_iter(): + self._block_sync() + + def zero_grad(self): + """Clears the gradients of all optimized parameters.""" + self._optimizer.zero_grad() + + def get_num_updates(self): + """Get the number of parameters updates.""" + return self._num_updates + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + self._num_updates = num_updates + + @torch.no_grad() + def _reset_local_data(self): + # (Step-0) Initialize global momentum parameters and store global copy on each gpu + self.global_params = [torch.zeros_like(p.data) for p in self.params] + self.smoothed_grads = [p.data.new_zeros(p.data.size()) for p in self.params] + self.grads = [p.data.new_zeros(p.data.size()) for p in self.params] + + # saving the global model locally for calculating gradient during bmuf sync + for param, global_param in zip(self.params, self.global_params): + global_param.copy_(param.data) + + @torch.no_grad() + def _calc_grad(self): + # global_params is basically the global copy from the previously finished + # synchronisation. param.data is local parameter after block_sync_freq + # for the local gpu. so grad is difference between previously synced + # model and currrent local model. + for index, (param, global_param) in enumerate( + zip(self.params, self.global_params) + ): + self.grads[index] = global_param - param.data + + def _avg_grad_from_all_gpus(self): + for index, param in enumerate(self.params): + sync_para = param.data if self.block_momentum == 0 else self.grads[index] + sync_para /= float(dist.get_world_size()) + dist.all_reduce(sync_para, op=dist.ReduceOp.SUM) + + @torch.no_grad() + def _update_global_model(self): + for index, (param, global_param, smoothed_grad, grad) in enumerate( + zip( + self.params, + self.global_params, + self.smoothed_grads, + # all gpus would share the same value of smoothed_grad, since it is + # always computed on synchronized gradients. + self.grads, + ) + ): + # global_param is basically last syncrhornized parameter. though + # smoothed_grad is local, all processes will have same value of + # smoothed_grad and hence param is globally synchronized copy. + # smoothed_grad(t) = BM * smoothed_grad(t-1) + BM_lr * grad(t) + smoothed_grad = self.block_momentum * smoothed_grad + self.block_lr * grad + param.data.copy_(global_param - smoothed_grad) + + # A Nesterov momentum here is to do a partial weight update before + # calculating the gradient + if self.use_nbm: + param.data.copy_(param.data - self.block_momentum * smoothed_grad) + + # backup for the next synchronization. + self.smoothed_grads[index] = smoothed_grad + global_param.copy_(param.data) diff --git a/fairseq/fairseq/optim/composite.py b/fairseq/fairseq/optim/composite.py new file mode 100644 index 0000000000000000000000000000000000000000..a5366d62434a4400ba9cc524f4286f99f733d121 --- /dev/null +++ b/fairseq/fairseq/optim/composite.py @@ -0,0 +1,188 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from collections import defaultdict +from dataclasses import dataclass, field +from typing import Dict, Any, List, Optional + +import torch.optim +from fairseq.dataclass import FairseqDataclass +from fairseq.optim import FairseqOptimizer, register_optimizer, _build_optimizer +from fairseq.optim.lr_scheduler import FairseqLRScheduler, build_lr_scheduler +from omegaconf import II, open_dict + + +logger = logging.getLogger(__name__) + + +@dataclass +class OptimizerAndSchedulerConfig(FairseqDataclass): + optimizer: Any = None + lr_scheduler: Optional[Any] = None + lr: List = II("optimization.lr") + lr_float: Optional[float] = None # this makes it easier to sweep on learning rate with auto sweepers + + +@dataclass +class CompositeOptimizerConfig(FairseqDataclass): + groups: Dict[str, Any] = field( + default_factory=lambda: {}, + metadata={ + "help": "optimizer name -> optimizer OptimizerAndSchedulerConfig. " + "Configures a different optimizer and (optionally) lr scheduler for each parameter group" + }, + ) + + +@register_optimizer("composite", dataclass=CompositeOptimizerConfig) +class FairseqCompositeOptimizer(FairseqOptimizer): + + optimizers: Dict[str, FairseqOptimizer] = {} + lr_schedulers: Dict[str, FairseqLRScheduler] = {} + lr_scheduler: FairseqLRScheduler = None + _optimizer: torch.optim.Optimizer + + def __init__(self, cfg: CompositeOptimizerConfig, params): + super().__init__(cfg) + + assert ( + len(params) > 1 + ), "Composite optimizer only works when there are multiple parameter groups (try fp16_no_flatten_grads: true)" + + groupped_params = defaultdict(list) + for p in params: + group = getattr(p, "param_group", "default") + groupped_params[group].append(p) + + assert groupped_params.keys() == cfg.groups.keys(), ( + f"Parameter groups {groupped_params.keys()} and optimizer groups {cfg.groups.keys()} are not the same! " + "Try setting 'param_group' on your parameters in the model." + ) + + for group, group_params in groupped_params.items(): + group_cfg = cfg.groups[group] + with open_dict(group_cfg): + if group_cfg.lr_float is not None: + group_cfg.optimizer.lr = [group_cfg.lr_float] + group_cfg.lr_scheduler.lr = [group_cfg.lr_float] + else: + group_cfg.optimizer.lr = group_cfg.lr + group_cfg.lr_scheduler.lr = group_cfg.lr + self.optimizers[group] = _build_optimizer(group_cfg.optimizer, group_params) + if group_cfg.lr_scheduler is not None: + self.lr_schedulers[group] = build_lr_scheduler( + group_cfg.lr_scheduler, self.optimizers[group] + ) + + if len(self.lr_schedulers) > 0: + assert len(self.lr_schedulers) == len(self.optimizers), ( + f"Please provide an lr scheduler for each optimizer to use pass_through scheduler. " + f"Optimizers: {self.optimizers}; Lr scheds: {self.lr_schedulers}" + ) + self.lr_scheduler = CompositeLRScheduler(self.lr_schedulers) + + self._optimizer = CompositeOptimizer(self.optimizers) + + @property + def supports_groups(self): + return True + + @property + def param_groups(self): + for opt in self.optimizers.values(): + for group in opt.param_groups: + yield group + + def get_lr(self): + """Return the current learning rate.""" + k = ( + "default" + if "default" in self.optimizers + else next(iter(self.optimizers.keys())) + ) + return self.optimizers[k].param_groups[0]["lr"] + + def state_dict(self): + """Return the LR scheduler state dict.""" + return {k: s.state_dict() for k, s in self.optimizers.items()} + + def load_state_dict(self, state_dict, optimizer_overrides=None): + """Load an LR scheduler state dict.""" + for k, state in state_dict.items(): + if k not in self.optimizers: + # skip extra keys like "loss_scale" added by fp16 optimizer + continue + + overrides = ( + optimizer_overrides[k] + if isinstance(optimizer_overrides, dict) and k in optimizer_overrides + else None + ) + self.optimizers[k].load_state_dict(state, optimizer_overrides=overrides) + + +class CompositeOptimizer(torch.optim.Optimizer): + def __init__(self, optimizers: Dict[str, FairseqOptimizer]): + self.optimizers = optimizers + + @property + def supports_memory_efficient_fp16(self): + return all(o.supports_memory_efficient_fp16 for o in self.optimizers.values()) + + @property + def supports_flat_params(self): + return all(o.supports_flat_params for o in self.optimizers.values()) + + def step(self, closure=None, groups=None): + """Performs a single optimization step. + + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for k, opt in self.optimizers.items(): + if groups is None or k in groups: + opt.step() + + return loss + + def zero_grad(self): + for opt in self.optimizers.values(): + opt.zero_grad() + + +class CompositeLRScheduler(FairseqLRScheduler): + def __init__(self, lr_schedulers): + super().__init__(None, None) + + self.lr_schedulers = lr_schedulers + + def state_dict(self): + """Return the LR scheduler state dict.""" + return {k: s.state_dict() for k, s in self.lr_schedulers.items()} + + def load_state_dict(self, state_dict): + """Load an LR scheduler state dict.""" + for k, state in state_dict.items(): + self.lr_schedulers[k].load_state_dict(state) + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + for s in self.lr_schedulers.values(): + s.step_begin_epoch(epoch) + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + for s in self.lr_schedulers.values(): + s.step(epoch) + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + return {k: s.step_update(num_updates) for k, s in self.lr_schedulers.items()} diff --git a/fairseq/fairseq/optim/cpu_adam.py b/fairseq/fairseq/optim/cpu_adam.py new file mode 100644 index 0000000000000000000000000000000000000000..b2f893aeda69ee1741e5e3af406ff4182b6f2416 --- /dev/null +++ b/fairseq/fairseq/optim/cpu_adam.py @@ -0,0 +1,206 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import importlib +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import List + +import torch +from fairseq.dataclass import FairseqDataclass +from fairseq.optim import FairseqOptimizer, register_optimizer +from omegaconf import II, DictConfig + + +try: + import deepspeed + has_deepspeed = True +except ImportError as e: + has_deepspeed = False + + +def _get_cpu_adam(): + try: + from deepspeed.ops.op_builder import CPUAdamBuilder + return CPUAdamBuilder().load() + except ImportError: + # fbcode + from deepspeed.ops.adam import DeepSpeedCPUAdam as ds_opt_adam + return ds_opt_adam + +@dataclass +class FairseqCPUAdamConfig(FairseqDataclass): + adam_betas: str = field( + default="(0.9, 0.999)", metadata={"help": "betas for Adam optimizer"} + ) + adam_eps: float = field( + default=1e-8, metadata={"help": "epsilon for Adam optimizer"} + ) + weight_decay: float = field(default=0.0, metadata={"help": "weight decay"}) + fp16_adam_stats: bool = field( + default=False, metadata={"help": "use FP16 stats (with automatic scaling)"} + ) + # TODO common vars below in parent + lr: List[float] = II("optimization.lr") + + +@register_optimizer("cpu_adam", dataclass=FairseqCPUAdamConfig) +class FairseqCPUAdam(FairseqOptimizer): + """Adam optimizer for fairseq, optimized for CPU tensors. + + Important note: this optimizer corresponds to the "AdamW" variant of + Adam in its weight decay behavior. As such, it is most closely + analogous to torch.optim.AdamW from PyTorch. + """ + + def __init__(self, cfg: DictConfig, params): + super().__init__(cfg) + self._optimizer = CPUAdam(params, **self.optimizer_config) + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.cfg.lr[0] + if isinstance(self.cfg.lr, Collection) + else self.cfg.lr, + "betas": eval(self.cfg.adam_betas), + "eps": self.cfg.adam_eps, + "weight_decay": self.cfg.weight_decay, + "use_fp16_stats": self.cfg.fp16_adam_stats, + } + + +class CPUAdam(torch.optim.Optimizer): + + optimizer_id = 0 + + def __init__( + self, + params, + lr=1e-3, + bias_correction=True, + betas=(0.9, 0.999), + eps=1e-8, + weight_decay=0, + use_fp16_stats=False, + ): + defaults = { + "lr": lr, + "bias_correction": bias_correction, + "betas": betas, + "eps": eps, + "weight_decay": weight_decay, + } + super().__init__(params, defaults) + + self.use_fp16_stats = use_fp16_stats + self.FLOAT16_MAX = 65504.0 + + if not has_deepspeed: + raise ImportError("Please install DeepSpeed: pip install deepspeed") + + self.opt_id = CPUAdam.optimizer_id + CPUAdam.optimizer_id = CPUAdam.optimizer_id + 1 + + self.ds_opt_adam = _get_cpu_adam() + adamw_mode = True + self.ds_opt_adam.create_adam( + self.opt_id, lr, betas[0], betas[1], eps, weight_decay, adamw_mode + ) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + @torch.no_grad() + def step(self, closure=None): + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + torch.cuda.synchronize() + + for group_id, group in enumerate(self.param_groups): + for param_id, p in enumerate(group["params"]): + if p.grad is None: + continue + + state = self.state[p] + if len(state) == 0: + state["step"] = 0 + dtype = torch.float16 if self.use_fp16_stats else p.data.dtype + # gradient momentums + state["exp_avg"] = torch.zeros_like( + p.data, dtype=dtype, device="cpu" + ) + # gradient variances + state["exp_avg_sq"] = torch.zeros_like( + p.data, dtype=dtype, device="cpu" + ) + if self.use_fp16_stats: + assert torch.is_floating_point(p.data) + state["exp_avg_scale"] = 1.0 + state["exp_avg_sq_scale"] = 1.0 + + exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"] + + p_data_bak = p.data # backup of the original data pointer + + p.data = p.data.to(dtype=torch.float32, device="cpu") + p.grad.data = p.grad.data.to(dtype=torch.float32, device="cpu") + + if self.use_fp16_stats: + exp_avg = exp_avg.float() * state["exp_avg_scale"] + exp_avg_sq = exp_avg_sq.float() * state["exp_avg_sq_scale"] + + state["step"] += 1 + beta1, beta2 = group["betas"] + + self.ds_opt_adam.adam_update( + self.opt_id, + state["step"], + group["lr"], + beta1, + beta2, + group["eps"], + group["weight_decay"], + group["bias_correction"], + p.data, + p.grad.data, + exp_avg, + exp_avg_sq, + ) + + if p_data_bak.data_ptr() != p.data.data_ptr(): + p_data_bak.copy_(p.data) + p.data = p_data_bak + + if self.use_fp16_stats: + + def inf_norm(t): + return torch.norm(t, float("inf")) + + # from github.com/openai/jukebox/blob/master/jukebox/utils/fp16.py + state["exp_avg_scale"], state["exp_avg_sq_scale"] = ( + 1e-8 + inf_norm(exp_avg) / self.FLOAT16_MAX, + 1e-8 + inf_norm(exp_avg_sq) / self.FLOAT16_MAX, + ) + state["exp_avg"], state["exp_avg_sq"] = ( + (exp_avg / state["exp_avg_scale"]).half(), + (exp_avg_sq / state["exp_avg_sq_scale"]).half(), + ) + + return loss diff --git a/fairseq/fairseq/optim/dynamic_loss_scaler.py b/fairseq/fairseq/optim/dynamic_loss_scaler.py new file mode 100644 index 0000000000000000000000000000000000000000..43f9be37b9067c520cd794b9a941c57adae25e97 --- /dev/null +++ b/fairseq/fairseq/optim/dynamic_loss_scaler.py @@ -0,0 +1,70 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +class DynamicLossScaler(object): + def __init__( + self, + init_scale=2.0 ** 15, + scale_factor=2.0, + scale_window=2000, + tolerance=0.0, + threshold=None, + min_loss_scale=1e-4, + ): + self.loss_scale = init_scale + self.scale_factor = scale_factor + self.scale_window = scale_window + self.tolerance = tolerance + self.threshold = threshold + self._iter = 0 + self._last_overflow_iter = -1 + self._last_rescale_iter = -1 + self._overflows_since_rescale = 0 + self.min_loss_scale = min_loss_scale + + def scale(self, outputs): + return self.loss_scale * outputs + + def update(self): + if (self._iter - self._last_overflow_iter) % self.scale_window == 0: + self.loss_scale *= self.scale_factor + self._last_rescale_iter = self._iter + self._iter += 1 + + def _decrease_loss_scale(self): + self.loss_scale /= self.scale_factor + if self.threshold is not None: + self.loss_scale = max(self.loss_scale, self.threshold) + + def check_overflow(self, grad_norm): + # detect inf and nan + if grad_norm == float("inf") or grad_norm != grad_norm: + # overflow has occured + prev_scale = self.loss_scale + iter_since_rescale = self._iter - self._last_rescale_iter + + self._last_overflow_iter = self._iter + self._overflows_since_rescale += 1 + pct_overflow = self._overflows_since_rescale / float(iter_since_rescale) + if pct_overflow >= self.tolerance: + self._decrease_loss_scale() + self._last_rescale_iter = self._iter + self._overflows_since_rescale = 0 + + if self.loss_scale <= self.min_loss_scale: + # Use FloatingPointError as an uncommon error that parent + # functions can safely catch to stop training. + self.loss_scale = prev_scale + raise FloatingPointError( + ( + "Minimum loss scale reached ({}). Your loss is probably exploding. " + "Try lowering the learning rate, using gradient clipping or " + "increasing the batch size." + ).format(self.min_loss_scale) + ) + + self._iter += 1 + raise OverflowError("setting loss scale to: " + str(self.loss_scale)) diff --git a/fairseq/fairseq/optim/fairseq_optimizer.py b/fairseq/fairseq/optim/fairseq_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..7e5411753a2ba94f3a7a68316131530b8b17d22a --- /dev/null +++ b/fairseq/fairseq/optim/fairseq_optimizer.py @@ -0,0 +1,179 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq import utils +from fairseq.dataclass.utils import gen_parser_from_dataclass + + +class FairseqOptimizer(object): + def __init__(self, cfg): + super().__init__() + self.cfg = cfg + + @classmethod + def add_args(cls, parser): + """Add optimizer-specific arguments to the parser.""" + dc = getattr(cls, "__dataclass", None) + if dc is not None: + gen_parser_from_dataclass(parser, dc()) + + @property + def optimizer(self): + """Return a torch.optim.optimizer.Optimizer instance.""" + if not hasattr(self, "_optimizer"): + raise NotImplementedError + if not isinstance(self._optimizer, torch.optim.Optimizer): + raise ValueError("_optimizer must be an instance of torch.optim.Optimizer") + return self._optimizer + + @optimizer.setter + def optimizer(self, optimizer): + """Reset optimizer instance.""" + if not hasattr(self, "_optimizer"): + raise NotImplementedError + if not isinstance(self._optimizer, torch.optim.Optimizer): + raise ValueError("_optimizer must be an instance of torch.optim.Optimizer") + self._optimizer = optimizer + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + raise NotImplementedError + + @property + def params(self): + """Return an iterable of the parameters held by the optimizer.""" + for param_group in self.param_groups: + for p in param_group["params"]: + yield p + + @property + def param_groups(self): + return self.optimizer.param_groups + + def __getstate__(self): + return self._optimizer.__getstate__() + + def get_lr(self): + """Return the current learning rate.""" + return self.param_groups[0]["lr"] + + def set_lr(self, lr): + """Set the learning rate.""" + for param_group in self.param_groups: + param_group["lr"] = lr + + def state_dict(self): + """Return the optimizer's state dict.""" + return self.optimizer.state_dict() + + def load_state_dict(self, state_dict, optimizer_overrides=None): + """Load an optimizer state dict. + + In general we should prefer the configuration of the existing optimizer + instance (e.g., learning rate) over that found in the state_dict. This + allows us to resume training from a checkpoint using a new set of + optimizer args. + """ + self.optimizer.load_state_dict(state_dict) + + if optimizer_overrides is not None and len(optimizer_overrides) > 0: + # override learning rate, momentum, etc. with latest values + for group in self.param_groups: + group.update(optimizer_overrides) + + def backward(self, loss): + """Computes the sum of gradients of the given tensor w.r.t. graph leaves.""" + loss.backward() + + def all_reduce_grads(self, module): + """Manually all-reduce gradients (if required).""" + if hasattr(module, "all_reduce_grads"): + module.all_reduce_grads() + + def multiply_grads(self, c): + """Multiplies grads by a constant *c*.""" + for p in self.params: + if p.grad is not None: + if torch.is_tensor(c): + c = c.to(p.grad.device) + p.grad.data.mul_(c) + + def clip_grad_norm(self, max_norm, aggregate_norm_fn=None): + """Clips gradient norm.""" + return utils.clip_grad_norm_(self.params, max_norm, aggregate_norm_fn) + + def step(self, closure=None, scale=1.0, groups=None): + """Performs a single optimization step.""" + if self.supports_step_with_scale: + if self.supports_groups: + self.optimizer.step(closure, scale=scale, groups=groups) + else: + self.optimizer.step(closure, scale=scale) + else: + if scale != 1.0: + self.multiply_grads(1.0 / scale) + if self.supports_groups: + self.optimizer.step(closure, groups=groups) + else: + self.optimizer.step(closure) + + def zero_grad(self): + """Clears the gradients of all optimized parameters.""" + for p in self.params: + p.grad = None + self.optimizer.zero_grad() + + @property + def supports_memory_efficient_fp16(self): + if hasattr(self.optimizer, "supports_memory_efficient_fp16"): + return self.optimizer.supports_memory_efficient_fp16 + return False + + @property + def supports_step_with_scale(self): + if hasattr(self.optimizer, "supports_step_with_scale"): + return self.optimizer.supports_step_with_scale + return False + + @property + def supports_groups(self): + if hasattr(self.optimizer, "supports_groups"): + return self.optimizer.supports_groups + return False + + @property + def supports_flat_params(self): + """ + Whether the optimizer supports collapsing of the model + parameters/gradients into a single contiguous Tensor. + """ + if hasattr(self.optimizer, "supports_flat_params"): + return self.optimizer.supports_flat_params + return False + + def average_params(self): + pass + + def broadcast_global_state_dict(self, state_dict): + """ + Broadcasts a global state dict to all ranks. + Useful for optimizers that shard state between ranks. + """ + if hasattr(self.optimizer, "broadcast_global_state_dict"): + return self.optimizer.broadcast_global_state_dict(state_dict) + else: + return state_dict + + +class LegacyFairseqOptimizer(FairseqOptimizer): + def __init__(self, args): + self.args = args diff --git a/fairseq/fairseq/optim/fp16_optimizer.py b/fairseq/fairseq/optim/fp16_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..b9ca9270bea067ad41881febf84a7da6e6b9049e --- /dev/null +++ b/fairseq/fairseq/optim/fp16_optimizer.py @@ -0,0 +1,548 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections import defaultdict +from itertools import chain + +import torch +from fairseq import optim +from omegaconf import DictConfig + +from .dynamic_loss_scaler import DynamicLossScaler + + +class _FP16OptimizerMixin(object): + def __init__(self, *args, **kwargs): + # forward __init__ call to the next class in mro(method resolution order) + super().__init__(*args, **kwargs) + self._multiply_factor = 1.0 + + @property + def has_flat_params(self): + return torch.is_tensor(self.fp32_params) or ( + isinstance(self.fp32_params, dict) + and all(torch.is_tensor(t) for t in self.fp32_params.values()) + ) + + @classmethod + def build_fp32_params(cls, args, params, flatten=True): + # create FP32 copy of parameters and grads + if flatten: + is_pipeline_parallel = getattr( + args, "pipeline_model_parallel", False + ) and getattr(args, "distributed_no_spawn", False) + total_param_size = sum(p.data.numel() for p in params) + devices = [torch.cuda.current_device()] + if is_pipeline_parallel: + devices = list(set(args.pipeline_devices)) + fp32_params = {} + for device in devices: + if is_pipeline_parallel: + device_param_size = sum( + p.data.numel() for p in params if p.device.index == device + ) + device_params = [p for p in params if p.device.index == device] + else: + device_param_size = total_param_size + device_params = params + fp32_params[device] = ( + device_params[0].new(0).float().new(device_param_size) + ) + offset = 0 + for p in device_params: + numel = p.data.numel() + fp32_params[device][offset : offset + numel].copy_(p.data.reshape(-1)) + offset += numel + fp32_params[device] = torch.nn.Parameter(fp32_params[device]) + fp32_params[device].grad = fp32_params[device].data.new( + device_param_size + ) + return fp32_params + else: + fp32_params = [] + for p in params: + p32 = torch.nn.Parameter(p.data.float()) + if hasattr(p, 'expert'): + p32.expert = True + elif hasattr(p, 'base_expert'): + p32.base_expert = True + p32.grad = torch.zeros_like(p32.data) + if hasattr(p, "param_group"): + p32.param_group = p.param_group + fp32_params.append(p32) + return fp32_params + + def state_dict(self): + """Return the optimizer's state dict.""" + state_dict = self.fp32_optimizer.state_dict() + if self.scaler is not None: + state_dict["loss_scale"] = self.scaler.loss_scale + return state_dict + + def load_state_dict(self, state_dict, optimizer_overrides=None): + """Load an optimizer state dict. + + In general we should prefer the configuration of the existing optimizer + instance (e.g., learning rate) over that found in the state_dict. This + allows us to resume training from a checkpoint using a new set of + optimizer args. + """ + if "loss_scale" in state_dict and self.scaler is not None: + self.scaler.loss_scale = state_dict["loss_scale"] + self.fp32_optimizer.load_state_dict(state_dict, optimizer_overrides) + + def backward(self, loss): + """Computes the sum of gradients of the given tensor w.r.t. graph leaves. + + Compared to :func:`fairseq.optim.FairseqOptimizer.backward`, this + function additionally dynamically scales the loss to avoid gradient + underflow. + """ + if self.scaler is not None: + loss = self.scaler.scale(loss) + loss.backward() + self._needs_sync = True + + def _sync_fp16_grads_to_fp32(self): + if self._needs_sync: + # copy FP16 grads to FP32 + if self.has_flat_params: + devices = list(self.fp32_params.keys()) + device_params_dict = defaultdict(list) + for p in self.fp16_params: + if p.requires_grad: + device_params_dict[p.device.index].append(p) + for device in devices: + device_params = device_params_dict[device] + offset = 0 + for p in device_params: + grad_data = ( + p.grad.data + if p.grad is not None + else p.data.new_zeros(p.data.shape) + ) + numel = grad_data.numel() + self.fp32_params[device].grad.data[ + offset : offset + numel + ].copy_(grad_data.reshape(-1)) + offset += numel + else: + for p, p32 in zip(self.fp16_params, self.fp32_params): + if not p.requires_grad: + continue + if p.grad is not None: + if p32.grad is None: + p32.grad = p.grad.data.float() + else: + p32.grad.data.copy_(p.grad.data) + else: + p32.grad = torch.zeros_like(p.data, dtype=torch.float) + + self._needs_sync = False + + def _sync_fp32_params_to_fp16(self): + # copy FP32 params back into FP16 model + if self.has_flat_params: + devices = list(self.fp32_params.keys()) + device_params_dict = defaultdict(list) + for p in self.fp16_params: + device_params_dict[p.device.index].append(p) + for device in devices: + device_params = device_params_dict[device] + offset = 0 + for p in device_params: + numel = p.data.numel() + p.data.copy_( + self.fp32_params[device] + .data[offset : offset + numel] + .view_as(p.data) + ) + offset += numel + else: + for p, p32 in zip(self.fp16_params, self.fp32_params): + if not p.requires_grad: + continue + p.data.copy_(p32.data) + + def _unscale_grads(self): + self._sync_fp16_grads_to_fp32() + if ( + # Skip the multiplication if it's a no-op (i.e., if _multiply_factor + # is 1.0). At the same time, we want to avoid the device-to-host + # transfer by comparing it to 1.0. Since _multiply_factor starts as + # a Python float, we roughly assume that if it's a tensor then it's + # probably not =1.0 anymore and we do the multiplication. Otherwise + # we can safely check the value without a D2H transfer. + torch.is_tensor(self._multiply_factor) + or self._multiply_factor != 1.0 + ): + self.fp32_optimizer.multiply_grads(self._multiply_factor) + self._multiply_factor = 1.0 + + def multiply_grads(self, c): + """Multiplies grads by a constant ``c``.""" + self._multiply_factor *= c + + def clip_grad_norm(self, max_norm, aggregate_norm_fn=None): + """Clips gradient norm and updates dynamic loss scaler.""" + self._sync_fp16_grads_to_fp32() + + grad_norm = self._multiply_factor * self.fp32_optimizer.clip_grad_norm( + 0, aggregate_norm_fn + ) + + if self.scaler is not None: + if grad_norm > max_norm > 0.0: + self._multiply_factor *= max_norm / grad_norm + + self.scaler.check_overflow(grad_norm) + elif max_norm > 0.0: + clip_coef = (max_norm / (grad_norm + 1e-6)).clamp_(max=1) + self._multiply_factor *= clip_coef + + return grad_norm + + def step(self, closure=None, groups=None): + """Performs a single optimization step.""" + self._sync_fp16_grads_to_fp32() + + if getattr(self, "supports_step_with_scale", False): + self.fp32_optimizer.step(closure, scale=(1.0 / self._multiply_factor), groups=groups) + else: + self._unscale_grads() + self.fp32_optimizer.step(closure, groups=groups) + + if self.scaler is not None: + self.scaler.update() + + self._sync_fp32_params_to_fp16() + + def zero_grad(self): + """Clears the gradients of all optimized parameters.""" + for p in self.fp16_params: + p.grad = None + if self.has_flat_params: + if torch.is_tensor(self.fp32_params): + self.fp32_params.grad.zero_() + elif isinstance(self.fp32_params, dict): + for fp32_params in self.fp32_params.values(): + fp32_params.grad.zero_() + else: + raise RuntimeError("self.fp32_params must be a tensor or dict") + else: + for p32 in self.fp32_params: + if p32.grad is not None: + p32.grad.zero_() + self._needs_sync = False + + if self.scaler is not None: + self._multiply_factor = 1.0 / float(self.scaler.loss_scale) + + +class FP16Optimizer(_FP16OptimizerMixin, optim.FairseqOptimizer): + """ + Wrap an *optimizer* to support FP16 (mixed precision) training. + """ + + def __init__(self, cfg: DictConfig, params, fp32_optimizer, fp32_params, **kwargs): + super().__init__(cfg.optimizer) + self.fp16_params = params + self.fp32_optimizer = fp32_optimizer + self.fp32_params = fp32_params + + if getattr(cfg.common, "fp16_scale_window", None) is None: + if len(cfg.optimization.update_freq) > 1: + raise ValueError( + "--fp16-scale-window must be given explicitly when using a " + "custom --update-freq schedule" + ) + data_parallel_size = int( + cfg.distributed_training.distributed_world_size + / cfg.common.model_parallel_size + ) + scale_window = int( + 2 ** 14 / data_parallel_size / cfg.optimization.update_freq[0] + ) + else: + scale_window = cfg.common.fp16_scale_window + + if not getattr(cfg.common, "bf16", False): + self.scaler = DynamicLossScaler( + init_scale=cfg.common.fp16_init_scale, + scale_window=scale_window, + tolerance=cfg.common.fp16_scale_tolerance, + threshold=cfg.common.threshold_loss_scale, + min_loss_scale=cfg.common.min_loss_scale, + ) + else: + # disable loss scaling for bfloat16 + self.scaler = None + + @classmethod + def build_optimizer(cls, cfg: DictConfig, params, **kwargs): + """ + Args: + cfg (omegaconf.DictConfig): fairseq args + params (iterable): iterable of parameters to optimize + """ + flatten = not getattr(cfg.common, "fp16_no_flatten_grads", False) + if getattr(cfg.common, "bf16", False): + flatten = False # mixed precision is faster on TPUs without flat grads + fp32_params = cls.build_fp32_params(cfg.optimizer, params, flatten=flatten) + if flatten: + fp32_optimizer = optim.build_optimizer(cfg.optimizer, [fp32_params]) + else: + fp32_optimizer = optim.build_optimizer(cfg.optimizer, fp32_params) + if flatten and not fp32_optimizer.supports_flat_params: + raise RuntimeError( + f"chosen optimizer {fp32_optimizer.__class__.__name__} does not support flat params, please set --fp16-no-flatten-grads" + ) + return cls(cfg, params, fp32_optimizer, fp32_params, **kwargs) + + @property + def optimizer(self): + return self.fp32_optimizer.optimizer + + @optimizer.setter + def optimizer(self, optimizer): + self.fp32_optimizer.optimizer = optimizer + + @property + def lr_scheduler(self): + return getattr(self.fp32_optimizer, "lr_scheduler", None) + + @property + def optimizer_config(self): + return self.fp32_optimizer.optimizer_config + + def get_lr(self): + return self.fp32_optimizer.get_lr() + + def set_lr(self, lr): + self.fp32_optimizer.set_lr(lr) + + def all_reduce_grads(self, module): + self.fp32_optimizer.all_reduce_grads(module) + + @property + def supports_flat_params(self): + return self.fp32_optimizer.supports_flat_params + + +class _MemoryEfficientFP16OptimizerMixin(object): + def __init__(self, *args, **kwargs): + # forward __init__ call to the next class in MRO (method resolution order) + super().__init__(*args, **kwargs) + self._multiply_factor = 1.0 + + @property + def has_flat_params(self): + return False + + def state_dict(self): + """Return the optimizer's state dict.""" + state_dict = self.wrapped_optimizer.state_dict() + if self.scaler is not None: + state_dict["loss_scale"] = self.scaler.loss_scale + return state_dict + + def load_state_dict(self, state_dict, optimizer_overrides=None): + """Load an optimizer state dict. + + In general we should prefer the configuration of the existing optimizer + instance (e.g., learning rate) over that found in the state_dict. This + allows us to resume training from a checkpoint using a new set of + optimizer args. + """ + if "loss_scale" in state_dict and self.scaler is not None: + self.scaler.loss_scale = state_dict["loss_scale"] + + self.wrapped_optimizer.load_state_dict(state_dict, optimizer_overrides) + + # Hack: PyTorch automatically casts the optimizer state to match the + # type of the current parameters. But with --memory-efficient-fp16 the + # params are FP16 while the optimizer state is FP32 and we don't want + # to cast. A workaround is to manually copy back the original state + # after the optimizer has been loaded. + if not getattr(self.optimizer, "disable_mem_eff_fp16_loading_hack", False): + groups = self.optimizer.param_groups + saved_groups = state_dict["param_groups"] + id_map = { + old_id: p + for old_id, p in zip( + chain(*(g["params"] for g in saved_groups)), + chain(*(g["params"] for g in groups)), + ) + } + for k, v in state_dict["state"].items(): + if k in id_map: + param = id_map[k] + self.optimizer.state[param] = v + + def backward(self, loss): + """Computes the sum of gradients of the given tensor w.r.t. graph leaves. + + Compared to :func:`fairseq.optim.FairseqOptimizer.backward`, this + function additionally dynamically scales the loss to avoid gradient + underflow. + """ + if self.scaler is not None: + loss = self.scaler.scale(loss) + loss.backward() + + def _unscale_grads(self): + if ( + # Skip the multiplication if it's a no-op (i.e., if _multiply_factor + # is 1.0). At the same time, we want to avoid the device-to-host + # transfer by comparing it to 1.0. Since _multiply_factor starts as + # a Python float, we roughly assume that if it's a tensor then it's + # probably not =1.0 anymore and we do the multiplication. Otherwise + # we can safely check the value without a D2H transfer. + torch.is_tensor(self._multiply_factor) + or self._multiply_factor != 1.0 + ): + self.wrapped_optimizer.multiply_grads(self._multiply_factor) + self._multiply_factor = 1.0 + + def multiply_grads(self, c): + """Multiplies grads by a constant *c*.""" + self._multiply_factor *= c + + def clip_grad_norm(self, max_norm, aggregate_norm_fn=None): + """Clips gradient norm and updates dynamic loss scaler.""" + max_norm = float(max_norm) + grad_norm = self._multiply_factor * self.wrapped_optimizer.clip_grad_norm( + 0, aggregate_norm_fn + ) + + if self.scaler is not None: + grad_norm_cpu = float(grad_norm) + if grad_norm_cpu > max_norm > 0.0: + self._multiply_factor *= max_norm / grad_norm_cpu + + # detect overflow and adjust loss scale + self.scaler.check_overflow(grad_norm_cpu) + elif max_norm > 0.0: + clip_coef = (max_norm / (grad_norm + 1e-6)).clamp_(max=1) + self._multiply_factor *= clip_coef + + return grad_norm + + def step(self, closure=None, groups=None): + """Performs a single optimization step.""" + if getattr(self, "supports_step_with_scale", False): + # NOTE(msb) optimizer divides by scale factor + self.wrapped_optimizer.step(closure, scale=(1.0 / self._multiply_factor), groups=groups) + else: + self._unscale_grads() + self.wrapped_optimizer.step(closure, groups=groups) + + if self.scaler is not None: + self.scaler.update() + + def zero_grad(self): + """Clears the gradients of all optimized parameters.""" + self.wrapped_optimizer.zero_grad() + if self.scaler is not None: + self._multiply_factor = 1.0 / float(self.scaler.loss_scale) + else: + self._multiply_factor = 1.0 + + @property + def supports_flat_params(self): + return self.wrapped_optimizer.supports_flat_params + + +class MemoryEfficientFP16Optimizer( + _MemoryEfficientFP16OptimizerMixin, optim.FairseqOptimizer +): + """ + Wrap an *optimizer* to support FP16 (mixed precision) training. + + Compared to :class:`fairseq.optim.FP16Optimizer`, this version does not + maintain an FP32 copy of the model. We instead expect the optimizer to + convert the gradients to FP32 internally and sync the results back to the + FP16 model params. This significantly reduces memory usage but slightly + increases the time spent in the optimizer. + + Since this wrapper depends on specific functionality in the wrapped + optimizer (i.e., on-the-fly conversion of grads to FP32), only certain + optimizers can be wrapped. This is determined by the + *supports_memory_efficient_fp16* property. + """ + + def __init__( + self, cfg: DictConfig, params, optimizer, allow_unsupported=False, **kwargs + ): + if not allow_unsupported and not optimizer.supports_memory_efficient_fp16: + raise ValueError( + "Unsupported optimizer: {}".format(optimizer.__class__.__name__) + ) + + super().__init__(getattr(cfg, "optimizer", None)) + self.wrapped_optimizer = optimizer + + if getattr(cfg.common, "fp16_scale_window", None) is None: + if len(cfg.optimization.update_freq) > 1: + raise ValueError( + "--fp16-scale-window must be given explicitly when using a " + "custom --update-freq schedule" + ) + data_parallel_size = int( + cfg.distributed_training.distributed_world_size + / cfg.common.model_parallel_size + ) + scale_window = int( + 2 ** 14 / data_parallel_size / cfg.optimization.update_freq[0] + ) + else: + scale_window = cfg.common.fp16_scale_window + + if not getattr(cfg.common, "bf16", False): + self.scaler = DynamicLossScaler( + init_scale=cfg.common.fp16_init_scale, + scale_window=scale_window, + tolerance=cfg.common.fp16_scale_tolerance, + threshold=cfg.common.threshold_loss_scale, + min_loss_scale=cfg.common.min_loss_scale, + ) + else: + # disable loss scaling for bfloat16 + self.scaler = None + + @classmethod + def build_optimizer(cls, cfg: DictConfig, params, **kwargs): + """ + Args: + args (argparse.Namespace): fairseq args + params (iterable): iterable of parameters to optimize + """ + fp16_optimizer = optim.build_optimizer(cfg.optimizer, params) + return cls(cfg, params, fp16_optimizer, **kwargs) + + @property + def optimizer(self): + return self.wrapped_optimizer.optimizer + + @optimizer.setter + def optimizer(self, optimizer): + self.wrapped_optimizer.optimizer = optimizer + + @property + def optimizer_config(self): + return self.wrapped_optimizer.optimizer_config + + @property + def lr_scheduler(self): + return getattr(self.wrapped_optimizer, "lr_scheduler", None) + + def get_lr(self): + return self.wrapped_optimizer.get_lr() + + def set_lr(self, lr): + self.wrapped_optimizer.set_lr(lr) + + def all_reduce_grads(self, module): + self.wrapped_optimizer.all_reduce_grads(module) diff --git a/fairseq/fairseq/optim/fused_adam.py b/fairseq/fairseq/optim/fused_adam.py new file mode 100644 index 0000000000000000000000000000000000000000..7a6d1f73d53cae24ff94bb0bbc42bcc1de75548a --- /dev/null +++ b/fairseq/fairseq/optim/fused_adam.py @@ -0,0 +1,384 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import types + +import torch + + +def get_fused_adam_class(): + """ + Look for the FusedAdam optimizer from apex. We first try to load the + "contrib" interface, which is a bit faster than the main interface, + but is technically deprecated. + """ + try: + # The "deprecated" interface in recent versions of apex is a bit + # faster than the main interface, since we don't use the apex + # optimizer. This can be installed by passing the + # `--deprecated_fused_adam` option when building apex. + global fused_adam_cuda + import importlib + + fused_adam_cuda = importlib.import_module("fused_adam_cuda") + return FusedAdamV1 + except ImportError: + try: + # fallback to the newer interface + from apex.optimizers import FusedAdam as _FusedAdam # noqa + from apex.multi_tensor_apply import multi_tensor_applier + + if multi_tensor_applier.available: + return FusedAdamV2 + except ImportError: + pass + return None + + +class FusedAdamV1(torch.optim.Optimizer): + """ + Implements Adam algorithm. Currently GPU-only. Requires Apex to be installed via + ``python setup.py install --cuda_ext --cpp_ext``. + + It has been proposed in `Adam: A Method for Stochastic Optimization`_. + + Compared to the original version in Apex, the fairseq version casts grads + and params to FP32 internally to support ``--memory-efficient-fp16``. + + Args: + params (iterable): iterable of parameters to optimize or dicts defining + parameter groups. + lr (float, optional): learning rate. (default: 1e-3) + betas (Tuple[float, float], optional): coefficients used for computing + running averages of gradient and its square. (default: (0.9, 0.999)) + eps (float, optional): term added to the denominator to improve + numerical stability. (default: 1e-8) + weight_decay (float, optional): weight decay (L2 penalty) (default: 0) + amsgrad (boolean, optional): whether to use the AMSGrad variant of this + algorithm from the paper `On the Convergence of Adam and Beyond`_ + (default: False) NOT SUPPORTED in FusedAdam! + eps_inside_sqrt (boolean, optional): in the 'update parameters' step, + adds eps to the bias-corrected second moment estimate before + evaluating square root instead of adding it to the square root of + second moment estimate as in the original paper. (default: False) + .. _Adam: A Method for Stochastic Optimization: + https://arxiv.org/abs/1412.6980 + .. _On the Convergence of Adam and Beyond: + https://openreview.net/forum?id=ryQu7f-RZ + """ + + def __init__( + self, + params, + lr=1e-3, + bias_correction=True, + betas=(0.9, 0.999), + eps=1e-8, + eps_inside_sqrt=False, + weight_decay=0.0, + max_grad_norm=0.0, + amsgrad=False, + use_fp16_stats=False, + ): + global fused_adam_cuda + import importlib + + fused_adam_cuda = importlib.import_module("fused_adam_cuda") + + if amsgrad: + raise RuntimeError("FusedAdam does not support the AMSGrad variant.") + defaults = { + "lr": lr, + "bias_correction": bias_correction, + "betas": betas, + "eps": eps, + "weight_decay": weight_decay, + "max_grad_norm": max_grad_norm, + } + super().__init__(params, defaults) + self.eps_mode = 0 if eps_inside_sqrt else 1 + + self.use_fp16_stats = use_fp16_stats + self.FLOAT16_MAX = 65504.0 + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + @property + def supports_step_with_scale(self): + return True + + def step(self, closure=None, grads=None, scale=1.0, grad_norms=None): + """Performs a single optimization step. + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + grads (list of tensors, optional): weight gradient to use for the + optimizer update. If gradients have type torch.half, parameters + are expected to be in type torch.float. (default: None) + output params (list of tensors, optional): A reduced precision copy + of the updated weights written out in addition to the regular + updated weights. Have to be of same type as gradients. (default: None) + scale (float, optional): factor to divide gradient tensor values + by before applying to weights. (default: 1) + """ + loss = None + if closure is not None: + loss = closure() + + if grads is None: + grads_group = [None] * len(self.param_groups) + # backward compatibility + # assuming a list/generator of parameter means single group + elif isinstance(grads, types.GeneratorType): + grads_group = [grads] + elif type(grads[0]) != list: + grads_group = [grads] + else: + grads_group = grads + + if grad_norms is None: + grad_norms = [None] * len(self.param_groups) + + for group, grads_this_group, grad_norm in zip( + self.param_groups, grads_group, grad_norms + ): + if grads_this_group is None: + grads_this_group = [None] * len(group["params"]) + + # compute combined scale factor for this group + combined_scale = scale + if group.get("max_grad_norm", 0) > 0: + # norm is in fact norm*scale + clip = ((grad_norm / scale) + 1e-6) / group["max_grad_norm"] + if clip > 1: + combined_scale = clip * scale + + bias_correction = 1 if group.get("bias_correction", 1) else 0 + + for p, grad in zip(group["params"], grads_this_group): + # note: p.grad should not ever be set for correct + # operation of mixed precision optimizer that sometimes + # sends None gradients + if p.grad is None and grad is None: + continue + if grad is None: + grad = p.grad.data + if grad.is_sparse: + raise RuntimeError( + "FusedAdam does not support sparse gradients, " + "please consider SparseAdam instead" + ) + + if p.device.type == "cpu": + p_data_fp32 = p.data.cuda(non_blocking=True).float() + out_p = torch.tensor([], dtype = torch.float) + else: + p_data_fp32 = p.data.float() + out_p = p.data + + state = self.state[p] + + # State initialization + dtype = torch.float16 if self.use_fp16_stats else p_data_fp32.dtype + if len(state) == 0: + state["step"] = 0 + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(p_data_fp32, dtype=dtype) + # Exponential moving average of squared gradient values + state["exp_avg_sq"] = torch.zeros_like(p_data_fp32, dtype=dtype) + if self.use_fp16_stats: + state["exp_avg_scale"] = 1.0 + state["exp_avg_sq_scale"] = 1.0 + else: + device = p_data_fp32.device + state["exp_avg"] = state["exp_avg"].to(device, dtype) + state["exp_avg_sq"] = state["exp_avg_sq"].to(device, dtype) + + exp_avg = state["exp_avg"] + exp_avg_sq = state["exp_avg_sq"] + if self.use_fp16_stats: + assert exp_avg.dtype == torch.float16 + exp_avg = exp_avg.float() * state["exp_avg_scale"] + exp_avg_sq = exp_avg_sq.float() * state["exp_avg_sq_scale"] + beta1, beta2 = group["betas"] + + state["step"] += 1 + + with torch.cuda.device(p_data_fp32.device): + fused_adam_cuda.adam( + p_data_fp32, + out_p, + exp_avg, + exp_avg_sq, + grad, + group["lr"], + beta1, + beta2, + group["eps"], + combined_scale, + state["step"], + self.eps_mode, + bias_correction, + group["weight_decay"], + ) + + if p.device.type == "cpu": + p.data.copy_(p_data_fp32, non_blocking=True) + + if self.use_fp16_stats: + def inf_norm(t): + return torch.norm(t, float("inf")) + + # from github.com/openai/jukebox/blob/master/jukebox/utils/fp16.py + state["exp_avg_scale"], state["exp_avg_sq_scale"] = ( + 1e-8 + inf_norm(exp_avg) / self.FLOAT16_MAX, + 1e-8 + inf_norm(exp_avg_sq) / self.FLOAT16_MAX, + ) + state["exp_avg"], state["exp_avg_sq"] = ( + (exp_avg / state["exp_avg_scale"]).half(), + (exp_avg_sq / state["exp_avg_sq_scale"]).half(), + ) + + return loss + + +try: + from apex.optimizers import FusedAdam + from apex.multi_tensor_apply import multi_tensor_applier + + class FusedAdamV2(FusedAdam): + """ + Compared to the original version in Apex, the fairseq version casts grads + and params to FP32 internally to support ``--memory-efficient-fp16``. + """ + + def __init__(self, *args, use_fp16_stats=False, **kwargs): + if use_fp16_stats: + raise NotImplementedError("--fp16-adam-stats is only supported with FusedAdamV1") + super().__init__(*args, **kwargs) + if not hasattr(self, "multi_tensor_adam"): + raise Exception( + "Apex installation is outdated. Please install an updated version of apex." + ) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + def step( + self, + closure=None, + grads=None, + output_params=None, + scale=None, + grad_norms=None, + ): + """Performs a single optimization step.""" + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + bias_correction = 1 if group["bias_correction"] else 0 + beta1, beta2 = group["betas"] + + # assume same step across group now to simplify things + # per parameter step can be easily support by making it tensor, or pass list into kernel + if "step" in group: + group["step"] += 1 + else: + group["step"] = 1 + + # create lists for multi-tensor apply + g_16, p_16, orig_p_16, m_16, v_16 = [], [], [], [], [] + g_32, p_32, m_32, v_32 = [], [], [], [] + + for p in group["params"]: + if p.grad is None: + continue + if p.grad.data.is_sparse: + raise RuntimeError( + "FusedAdam does not support sparse gradients, " + "please consider SparseAdam instead" + ) + + state = self.state[p] + # State initialization + if len(state) == 0: + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(p.data, dtype=torch.float) + # Exponential moving average of squared gradient values + state["exp_avg_sq"] = torch.zeros_like( + p.data, dtype=torch.float + ) + else: + state["exp_avg"] = state["exp_avg"].to( + device=p.data.device, dtype=torch.float + ) + state["exp_avg_sq"] = state["exp_avg_sq"].to( + device=p.data.device, dtype=torch.float + ) + + if p.dtype == torch.float16: + g_16.append(p.grad.data.float()) + p_16.append(p.data.float()) + orig_p_16.append(p.data) + m_16.append(state["exp_avg"]) + v_16.append(state["exp_avg_sq"]) + elif p.dtype == torch.float32: + g_32.append(p.grad.data) + p_32.append(p.data) + m_32.append(state["exp_avg"]) + v_32.append(state["exp_avg_sq"]) + else: + raise RuntimeError("FusedAdam only support fp16 and fp32.") + + with torch.cuda.device(p.device): + if len(g_16) > 0: + multi_tensor_applier( + self.multi_tensor_adam, + self._dummy_overflow_buf, + [g_16, p_16, m_16, v_16], + group["lr"], + beta1, + beta2, + group["eps"], + group["step"], + self.adam_w_mode, + bias_correction, + group["weight_decay"], + ) + for orig_p, p in zip(orig_p_16, p_16): + orig_p.copy_(p.data) + if len(g_32) > 0: + multi_tensor_applier( + self.multi_tensor_adam, + self._dummy_overflow_buf, + [g_32, p_32, m_32, v_32], + group["lr"], + beta1, + beta2, + group["eps"], + group["step"], + self.adam_w_mode, + bias_correction, + group["weight_decay"], + ) + + return loss + + +except ImportError: + pass diff --git a/fairseq/fairseq/optim/fused_lamb.py b/fairseq/fairseq/optim/fused_lamb.py new file mode 100644 index 0000000000000000000000000000000000000000..f4f2bdb0c6c65f7758509b6d4d2f2c48cb6e8b4f --- /dev/null +++ b/fairseq/fairseq/optim/fused_lamb.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.optim import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("lamb") +class FairseqLAMB(LegacyFairseqOptimizer): + """LAMB optimizer.""" + + def __init__(self, args, params): + super().__init__(args) + try: + from apex.optimizers import FusedLAMB + + self._optimizer = FusedLAMB(params, **self.optimizer_config) + except ImportError: + raise ImportError("Please install apex to use LAMB optimizer") + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--lamb-betas', default='(0.9, 0.999)', metavar='B', + help='betas for LAMB optimizer') + parser.add_argument('--lamb-eps', type=float, default=1e-8, metavar='D', + help='epsilon for LAMB optimizer') + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "betas": eval(self.args.lamb_betas), + "eps": self.args.lamb_eps, + "weight_decay": self.args.weight_decay, + } + + @property + def supports_flat_params(self): + return False diff --git a/fairseq/fairseq/optim/lr_scheduler/__init__.py b/fairseq/fairseq/optim/lr_scheduler/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5b3dbc023aa4a6f7bfb8403b8204d71ca432f79c --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/__init__.py @@ -0,0 +1,36 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import importlib +import os + +from fairseq import registry +from fairseq.optim.lr_scheduler.fairseq_lr_scheduler import ( # noqa + FairseqLRScheduler, + LegacyFairseqLRScheduler, +) +from omegaconf import DictConfig + + +( + build_lr_scheduler_, + register_lr_scheduler, + LR_SCHEDULER_REGISTRY, + LR_SCHEDULER_DATACLASS_REGISTRY, +) = registry.setup_registry( + "--lr-scheduler", base_class=FairseqLRScheduler, default="fixed" +) + + +def build_lr_scheduler(cfg: DictConfig, optimizer): + return build_lr_scheduler_(cfg, optimizer) + + +# automatically import any Python files in the optim/lr_scheduler/ directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + file_name = file[: file.find(".py")] + importlib.import_module("fairseq.optim.lr_scheduler." + file_name) diff --git a/fairseq/fairseq/optim/lr_scheduler/cosine_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/cosine_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..51f58359eda387d67748f48217906ac6d16ccd08 --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/cosine_lr_scheduler.py @@ -0,0 +1,147 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import List + +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class CosineLRScheduleConfig(FairseqDataclass): + warmup_updates: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + warmup_init_lr: float = field( + default=-1, + metadata={ + "help": "initial learning rate during warmup phase; default is cfg.lr" + }, + ) + lr: List[float] = field( + default=II("optimization.lr"), + metadata={"help": "max learning rate, must be more than cfg.min_lr"}, + ) + min_lr: float = field(default=0.0, metadata={"help": "min learning rate"}) + t_mult: float = field( + default=1.0, metadata={"help": "factor to grow the length of each period"} + ) + lr_period_updates: float = field( + default=-1, metadata={"help": "initial number of updates per period"} + ) + lr_shrink: float = field( + default=0.1, metadata={"help": "shrink factor for annealing"} + ) + # This is not required, but is for convenience in inferring lr_period_updates + max_update: int = II("optimization.max_update") + + +@register_lr_scheduler("cosine", dataclass=CosineLRScheduleConfig) +class CosineLRSchedule(FairseqLRScheduler): + """Assign LR based on a cyclical schedule that follows the cosine function. + + See https://arxiv.org/pdf/1608.03983.pdf for details. + + We also support a warmup phase where we linearly increase the learning rate + from some initial learning rate (``--warmup-init-lr``) until the configured + max learning rate (``--lr``). + + During warmup:: + + lrs = torch.linspace(cfg.warmup_init_lr, cfg.lr, cfg.warmup_updates) + lr = lrs[update_num] + + After warmup:: + + lr = cfg.min_lr + 0.5*(cfg.lr - cfg.min_lr)*(1 + cos(t_curr / t_i)) + + where ``t_curr`` is current percentage of updates within the current period + range and ``t_i`` is the current period range, which is scaled by ``t_mul`` + after every iteration. + """ + + def __init__(self, cfg: CosineLRScheduleConfig, fairseq_optimizer): + super().__init__(cfg, fairseq_optimizer) + if isinstance(cfg.lr, Collection) and len(cfg.lr) > 1: + raise ValueError( + "Cannot use a fixed learning rate schedule with cosine." + f" Consider --lr-scheduler=fixed instead. ({cfg.lr})" + ) + + self.max_lr = cfg.lr[0] if isinstance(cfg.lr, Collection) else cfg.lr + assert ( + self.max_lr > cfg.min_lr + ), f"max_lr (={cfg.lr}) must be more than min_lr (={cfg.min_lr})" + + warmup_end_lr = self.max_lr + if cfg.warmup_init_lr < 0: + cfg.warmup_init_lr = cfg.min_lr + + self.t_mult = cfg.t_mult + self.period = cfg.lr_period_updates + + if self.period <= 0: + assert ( + cfg.max_update > 0 + ), "Either --max_update or --lr-period-updates must be set" + self.period = cfg.max_update - cfg.warmup_updates + + if cfg.warmup_updates > 0: + # linearly warmup for the first cfg.warmup_updates + self.lr_step = (warmup_end_lr - cfg.warmup_init_lr) / cfg.warmup_updates + else: + self.lr_step = 1 + + self.warmup_updates = cfg.warmup_updates + self.lr_shrink = cfg.lr_shrink + + # initial learning rate + self.lr = cfg.warmup_init_lr + self.optimizer.set_lr(self.lr) + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + super().step(epoch, val_loss) + # we don't change the learning rate at epoch boundaries + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + if num_updates < self.cfg.warmup_updates: + self.lr = self.cfg.warmup_init_lr + num_updates * self.lr_step + else: + curr_updates = num_updates - self.cfg.warmup_updates + if self.t_mult != 1: + i = math.floor( + math.log( + 1 - curr_updates / self.period * (1 - self.t_mult), self.t_mult + ) + ) + t_i = self.t_mult ** i * self.period + t_curr = ( + curr_updates + - (1 - self.t_mult ** i) / (1 - self.t_mult) * self.period + ) + else: + i = math.floor(curr_updates / self.period) + t_i = self.period + t_curr = curr_updates - (self.period * i) + + lr_shrink = self.lr_shrink ** i + min_lr = self.cfg.min_lr * lr_shrink + max_lr = self.max_lr * lr_shrink + + self.lr = min_lr + 0.5 * (max_lr - min_lr) * ( + 1 + math.cos(math.pi * t_curr / t_i) + ) + + self.optimizer.set_lr(self.lr) + return self.lr diff --git a/fairseq/fairseq/optim/lr_scheduler/fairseq_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/fairseq_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..ac6340fa0744a08d2b527972dfc669573fb4e1c3 --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/fairseq_lr_scheduler.py @@ -0,0 +1,62 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from argparse import Namespace + +from fairseq.dataclass.utils import gen_parser_from_dataclass +from fairseq.optim import FairseqOptimizer + + +class FairseqLRScheduler(object): + def __init__(self, cfg, optimizer): + super().__init__() + if optimizer is not None and not isinstance(optimizer, FairseqOptimizer): + raise ValueError("optimizer must be an instance of FairseqOptimizer") + self.cfg = cfg + self.optimizer = optimizer + self.best = None + + @classmethod + def add_args(cls, parser): + """Add arguments to the parser for this LR scheduler.""" + dc = getattr(cls, "__dataclass", None) + if dc is not None: + gen_parser_from_dataclass(parser, dc()) + + def state_dict(self): + """Return the LR scheduler state dict.""" + return {"best": self.best} + + def load_state_dict(self, state_dict): + """Load an LR scheduler state dict.""" + self.best = state_dict["best"] + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + pass + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + if val_loss is not None: + if self.best is None: + self.best = val_loss + else: + self.best = min(self.best, val_loss) + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + return self.optimizer.get_lr() + + def reinit(self, total_num_update, num_updates): + pass + + +class LegacyFairseqLRScheduler(FairseqLRScheduler): + def __init__(self, args: Namespace, optimizer): + if not isinstance(optimizer, FairseqOptimizer): + raise ValueError("optimizer must be an instance of FairseqOptimizer") + self.args = args + self.optimizer = optimizer + self.best = None diff --git a/fairseq/fairseq/optim/lr_scheduler/fixed_schedule.py b/fairseq/fairseq/optim/lr_scheduler/fixed_schedule.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e7e14b7e72b1151f7d7f19094430bbab64f8f0 --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/fixed_schedule.py @@ -0,0 +1,76 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +from typing import Optional, List +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class FixedLRScheduleConfig(FairseqDataclass): + force_anneal: Optional[int] = field( + default=None, + metadata={"help": "force annealing at specified epoch"}, + ) + lr_shrink: float = field( + default=0.1, + metadata={"help": "shrink factor for annealing, lr_new = (lr * lr_shrink)"}, + ) + warmup_updates: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + lr: List[float] = II("optimization.lr") + + +@register_lr_scheduler("fixed", dataclass=FixedLRScheduleConfig) +class FixedLRSchedule(FairseqLRScheduler): + """Decay the LR on a fixed schedule.""" + + def __init__(self, cfg: FixedLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + + self.lr = cfg.lr[0] + if cfg.warmup_updates > 0: + self.warmup_factor = 1.0 / cfg.warmup_updates + else: + self.warmup_factor = 1 + + def state_dict(self): + return {"lr": self.lr} + + def load_state_dict(self, state_dict): + if "lr" in state_dict: + self.lr = state_dict["lr"] + + def get_next_lr(self, epoch): + lrs = self.cfg.lr + if self.cfg.force_anneal is None or epoch < self.cfg.force_anneal: + # use fixed LR schedule + next_lr = lrs[min(epoch - 1, len(lrs) - 1)] + else: + # annneal based on lr_shrink + next_lr = lrs[-1] * self.cfg.lr_shrink ** ( + epoch + 1 - self.cfg.force_anneal + ) + return next_lr + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + self.lr = self.get_next_lr(epoch) + self.optimizer.set_lr(self.warmup_factor * self.lr) + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + if self.cfg.warmup_updates > 0 and num_updates < self.cfg.warmup_updates: + self.warmup_factor = (num_updates + 1) / float(self.cfg.warmup_updates) + self.optimizer.set_lr(self.warmup_factor * self.lr) + else: + self.optimizer.set_lr(self.lr) + return self.optimizer.get_lr() diff --git a/fairseq/fairseq/optim/lr_scheduler/inverse_square_root_schedule.py b/fairseq/fairseq/optim/lr_scheduler/inverse_square_root_schedule.py new file mode 100644 index 0000000000000000000000000000000000000000..0f87bb5d7ed5c7eb8011d4c651f2ecbf0ae700ac --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/inverse_square_root_schedule.py @@ -0,0 +1,85 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import List + +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class InverseSquareRootLRScheduleConfig(FairseqDataclass): + warmup_updates: int = field( + default=4000, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + warmup_init_lr: float = field( + default=-1, + metadata={ + "help": "initial learning rate during warmup phase; default is cfg.lr" + }, + ) + lr: List[float] = II("optimization.lr") + + +@register_lr_scheduler("inverse_sqrt", dataclass=InverseSquareRootLRScheduleConfig) +class InverseSquareRootSchedule(FairseqLRScheduler): + """Decay the LR based on the inverse square root of the update number. + + We also support a warmup phase where we linearly increase the learning rate + from some initial learning rate (``--warmup-init-lr``) until the configured + learning rate (``--lr``). Thereafter we decay proportional to the number of + updates, with a decay factor set to align with the configured learning rate. + + During warmup:: + + lrs = torch.linspace(cfg.warmup_init_lr, cfg.lr, cfg.warmup_updates) + lr = lrs[update_num] + + After warmup:: + + decay_factor = cfg.lr * sqrt(cfg.warmup_updates) + lr = decay_factor / sqrt(update_num) + """ + + def __init__(self, cfg: InverseSquareRootLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + if isinstance(cfg.lr, Collection) and len(cfg.lr) > 1: + raise ValueError( + "Cannot use a fixed learning rate schedule with inverse_sqrt." + " Consider --lr-scheduler=fixed instead." + ) + warmup_end_lr = cfg.lr[0] if isinstance(cfg.lr, Collection) else cfg.lr + if cfg.warmup_init_lr < 0: + cfg.warmup_init_lr = 0 if cfg.warmup_updates > 0 else warmup_end_lr + + # linearly warmup for the first cfg.warmup_updates + self.lr_step = (warmup_end_lr - cfg.warmup_init_lr) / cfg.warmup_updates + + # then, decay prop. to the inverse square root of the update number + self.decay_factor = warmup_end_lr * cfg.warmup_updates ** 0.5 + + # initial learning rate + self.lr = cfg.warmup_init_lr + self.optimizer.set_lr(self.lr) + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + super().step(epoch, val_loss) + # we don't change the learning rate at epoch boundaries + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + if num_updates < self.cfg.warmup_updates: + self.lr = self.cfg.warmup_init_lr + num_updates * self.lr_step + else: + self.lr = self.decay_factor * num_updates ** -0.5 + self.optimizer.set_lr(self.lr) + return self.lr diff --git a/fairseq/fairseq/optim/lr_scheduler/manual_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/manual_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..0269a1e2853854745e23b07931294f37b67d0295 --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/manual_lr_scheduler.py @@ -0,0 +1,110 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from . import LegacyFairseqLRScheduler, register_lr_scheduler +import logging +import ast + +logger = logging.getLogger(__name__) +logger.setLevel(logging.WARNING) + + +@register_lr_scheduler("manual") +class ManualSchedule(LegacyFairseqLRScheduler): + """Decay the LR on a manual schedule.""" + + def __init__(self, args, optimizer): + super().__init__(args, optimizer) + + self.epoch2lr = self.parse_manuallr_args(args.epoch2lr) + self.update2lr = self.parse_manuallr_args(args.update2lr) + logger.info("@@@ ManualSchedule epoch2lr={}".format(self.epoch2lr)) + logger.info("@@@ ManualSchedule update2lr={}".format(self.update2lr)) + + if 1 in self.epoch2lr: + self.lr = self.epoch2lr[1] + elif 1 in self.update2lr: + self.lr = self.update2lr[1] + else: + self.lr = args.lr[0] + self.optimizer.set_lr(self.lr) # Set the beginning of the epoch. + + def parse_manuallr_args(self, lr_args_str): + lr_dict = ast.literal_eval(lr_args_str.replace(' ', '')) + if not isinstance(lr_dict, dict): + raise ValueError("epoch2lr/update2lr must be abel to evaluated to a dict") + + lr_args = {} + logger.info("@@@ after parsing input dictionary lr_dict = {}".format(lr_dict)) + for key, val in lr_dict.items(): + if "," in key: + for k in key.split(","): + lr_args[int(k)] = float(val) + elif "-" in key: + s = int(key.split("-")[0]) + e = int(key.split("-")[1]) + for k in range(s, e + 1, 1): + lr_args[k] = float(val) + else: + lr_args[int(key)] = float(val) + + return lr_args + + @staticmethod + def add_args(parser): + """Add arguments to the parser for this LR scheduler.""" + # fmt: off + parser.add_argument( + "--epoch2lr", + type=str, + metavar="DICT", + default="{}", + help="a dictionary used to set lr for each epoch manually", + ) + parser.add_argument( + "--update2lr", + type=str, + metavar="DICT", + default="{}", + help="a dictionary used to set lr for each update manually", + ) + # fmt: on + + def state_dict(self): + return {"lr": self.lr} + + def load_state_dict(self, state_dict): + if "lr" in state_dict: + self.lr = state_dict["lr"] + + def get_next_lr(self, epoch): + manual_keys = [k for k in self.epoch2lr if k <= epoch] + if manual_keys: + manual_lr = self.epoch2lr[max(manual_keys)] + else: + logger.warning("@@@ epoch={} does not exist in manual lr input. epoch2lr={}...".format( + epoch, list(self.epoch2lr.items())[:min(10, len(self.epoch2lr.keys())-1)] + )) + manual_lr = self.optimizer.get_lr() + return manual_lr + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + self.lr = self.get_next_lr(epoch) + self.optimizer.set_lr(self.lr) + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + manual_keys = [k for k in self.update2lr if k <= num_updates] + if manual_keys: + manual_lr = self.update2lr[max(manual_keys)] + else: + logger.warning("epoch={} does not exist in manual lr input update2lr={}...".format( + num_updates, list(self.update2lr.items())[:min(10, len(self.update2lr.keys())-1)])) + manual_lr = self.optimizer.get_lr() + + self.optimizer.set_lr(manual_lr) + return self.optimizer.get_lr() diff --git a/fairseq/fairseq/optim/lr_scheduler/pass_through.py b/fairseq/fairseq/optim/lr_scheduler/pass_through.py new file mode 100644 index 0000000000000000000000000000000000000000..2f93db328c1de9b268e8ee1c0c1cad558fd089aa --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/pass_through.py @@ -0,0 +1,39 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class PassThroughScheduleConfig(FairseqDataclass): + pass + + +@register_lr_scheduler("pass_through", dataclass=PassThroughScheduleConfig) +class PassThroughScheduleSchedule(FairseqLRScheduler): + """Delegate lr scheduling to the optimizer.""" + + def __init__(self, cfg: PassThroughScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + assert ( + hasattr(optimizer, "lr_scheduler") and optimizer.lr_scheduler is not None + ), "Pass-through schedule can only be used with optimizers with their own schedulers" + + def state_dict(self): + return self.optimizer.lr_scheduler.state_dict() + + def load_state_dict(self, state_dict): + self.optimizer.lr_scheduler.load_state_dict(state_dict) + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + return self.optimizer.lr_scheduler.step_begin_epoch(epoch) + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + return self.optimizer.lr_scheduler.step_update(num_updates) diff --git a/fairseq/fairseq/optim/lr_scheduler/polynomial_decay_schedule.py b/fairseq/fairseq/optim/lr_scheduler/polynomial_decay_schedule.py new file mode 100644 index 0000000000000000000000000000000000000000..73c3c8ea3435d6050401c45e737e4ecf5662825c --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/polynomial_decay_schedule.py @@ -0,0 +1,110 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +from typing import Optional, List +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class PolynomialDecayLRScheduleConfig(FairseqDataclass): + warmup_updates: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + warmup_ratio: float = field( + default=0, + metadata={"help": "warmup ratio"}, + ) + force_anneal: Optional[int] = field( + default=None, + metadata={"help": "force annealing at specified epoch"}, + ) + end_learning_rate: float = field( + default=0.0, + metadata={"help": "learning rate to decay to"}, + ) + power: float = field( + default=1.0, + metadata={"help": "decay exponent"}, + ) + total_num_update: Optional[float] = field( + default=1000000, + metadata={"help": "total number of updates over which to decay learning rate"}, + ) + lr: List[float] = II("optimization.lr") + + +@register_lr_scheduler("polynomial_decay", dataclass=PolynomialDecayLRScheduleConfig) +class PolynomialDecayLRSchedule(FairseqLRScheduler): + """Decay the LR on a fixed schedule.""" + + def __init__(self, cfg: PolynomialDecayLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + + assert cfg.total_num_update > 0 + # set defaults + cfg.warmup_updates = getattr(cfg, 'warmup_updates', 0) or 0 + + self.lr = cfg.lr[0] + self.warmup_updates = cfg.warmup_updates + if self.warmup_updates > 0: + self.warmup_factor = 1.0 / self.warmup_updates + else: + self.warmup_factor = 1 + self.end_learning_rate = cfg.end_learning_rate + self.total_num_update = cfg.total_num_update + self.power = cfg.power + self.optimizer.set_lr(self.warmup_factor * self.lr) + + def get_next_lr(self, epoch): + lrs = self.cfg.lr + if self.cfg.force_anneal is None or epoch < self.cfg.force_anneal: + # use fixed LR schedule + next_lr = lrs[min(epoch, len(lrs) - 1)] + else: + # annneal based on lr_shrink + next_lr = self.optimizer.get_lr() + return next_lr + + def step_begin_epoch(self, epoch): + """Update the learning rate at the beginning of the given epoch.""" + self.lr = self.get_next_lr(epoch) + self.optimizer.set_lr(self.warmup_factor * self.lr) + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + if self.warmup_updates > 0 and num_updates <= self.warmup_updates: + self.warmup_factor = num_updates / float(self.warmup_updates) + lr = self.warmup_factor * self.lr + elif num_updates >= self.total_num_update: + lr = self.end_learning_rate + else: + warmup = self.warmup_updates + lr_range = self.lr - self.end_learning_rate + pct_remaining = 1 - (num_updates - warmup) / (self.total_num_update - warmup) + lr = lr_range * pct_remaining ** (self.power) + self.end_learning_rate + self.optimizer.set_lr(lr) + return self.optimizer.get_lr() + + def reinit(self, total_num_update, num_updates): + # only enable this when set warmup_ratio + if self.cfg.warmup_ratio <= 0: + return + # re init this according to the real number of updates + self.total_num_update = total_num_update + self.warmup_updates = int(self.total_num_update * self.cfg.warmup_ratio) + if num_updates > 0: + self.warmup_factor = min(1.0, num_updates / float(self.warmup_updates)) + self.step_update(num_updates) + else: + self.warmup_factor = 1.0 / self.warmup_updates + self.optimizer.set_lr(self.warmup_factor * self.lr) + print('Total steps {}, warmup steps {}, warmup_factor {}'.format(self.total_num_update, self.warmup_updates, + self.warmup_factor)) \ No newline at end of file diff --git a/fairseq/fairseq/optim/lr_scheduler/reduce_lr_on_plateau.py b/fairseq/fairseq/optim/lr_scheduler/reduce_lr_on_plateau.py new file mode 100644 index 0000000000000000000000000000000000000000..5ee9c1be4a59ad3d072412827ab4e9b62dc7434e --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/reduce_lr_on_plateau.py @@ -0,0 +1,143 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +from typing import List + +import torch.optim.lr_scheduler +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class ReduceLROnPlateauLRScheduleConfig(FairseqDataclass): + lr_shrink: float = field( + default=0.1, metadata={"help": "shrink factor for annealing"} + ) + lr_threshold: float = field( + default=1e-4, + metadata={ + "help": ( + "threshold for measuring the new optimum, to only focus on " + "significant changes" + ) + }, + ) + lr_patience: int = field( + default=0, + metadata={ + "help": ( + "number of epochs with no improvement after which learning rate will " + "be reduced" + ) + }, + ) + warmup_updates: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + warmup_init_lr: float = field( + default=-1, + metadata={ + "help": "initial learning rate during warmup phase; default is cfg.lr" + }, + ) + lr: List[float] = II("optimization.lr") + maximize_best_checkpoint_metric: bool = II( + "checkpoint.maximize_best_checkpoint_metric" + ) + + +@register_lr_scheduler( + "reduce_lr_on_plateau", dataclass=ReduceLROnPlateauLRScheduleConfig +) +class ReduceLROnPlateauLRSchedule(FairseqLRScheduler): + """ + Decay the LR by a factor every time the validation loss plateaus. + Also comes with optional warmup phase, where we linearly increase + the learning rate from some initial learning rate + (``--warmup-init-lr``) until the configured learning rate + (``--lr``). Thereafter the lr is adjusted according to original + reduce_on_plateau scheme. + + During warmup:: + + lrs = torch.linspace( + cfg.warmup_init_lr, cfg.lr, cfg.warmup_updates + ) + lr = lrs[update_num] + """ + + def __init__(self, cfg: ReduceLROnPlateauLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + if len(cfg.lr) > 1: + raise ValueError( + "Cannot use a fixed learning rate schedule with reduce_lr_on_plateau." + " Consider --lr-scheduler=fixed instead." + ) + self.lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + self.optimizer.optimizer, + patience=cfg.lr_patience, + factor=cfg.lr_shrink, + mode="max" if cfg.maximize_best_checkpoint_metric else "min", + threshold=cfg.lr_threshold, + ) + warmup_end_lr = cfg.lr[0] + # if no warm up, sets initial lr to be cfg.lr[0] + if cfg.warmup_init_lr < 0: + cfg.warmup_init_lr = 0 if cfg.warmup_updates > 0 else warmup_end_lr + + # linearly warmup for the first cfg.warmup_updates + if cfg.warmup_updates > 0: + self.lr_step = (warmup_end_lr - cfg.warmup_init_lr) / cfg.warmup_updates + + # this flag is either set from arg when no warm up, or set by + # step_update() when warmup finishes + self.warmup_end = True if cfg.warmup_updates <= 0 else False + + # initial learning rate + # this self.lr is used only during init and/or warm up period + self.lr = warmup_end_lr if self.warmup_end else cfg.warmup_init_lr + self.optimizer.set_lr(self.lr) + + def state_dict(self): + """Return the LR scheduler state dict.""" + return { + "best": self.lr_scheduler.best, + "last_epoch": self.lr_scheduler.last_epoch, + } + + def load_state_dict(self, state_dict): + """Load an LR scheduler state dict.""" + self.lr_scheduler.best = state_dict["best"] + if "last_epoch" in state_dict: + self.lr_scheduler.last_epoch = state_dict["last_epoch"] + + def step(self, epoch, val_loss=None): + """ + Update the learning rate at the end of the given epoch if warmup + finishes otherwise no update of lr on epoch boundaries + """ + if val_loss is not None and self.warmup_end is True: + self.lr_scheduler.step(val_loss) + else: + self.lr_scheduler.last_epoch = epoch + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """ + Update the learning rate after each update.""" + # if there is warmup + if self.cfg.warmup_updates > 0: + if num_updates <= self.cfg.warmup_updates: + self.lr = self.cfg.warmup_init_lr + num_updates * self.lr_step + self.optimizer.set_lr(self.lr) + else: + if self.warmup_end is False: + self.warmup_end = True + # else do nothing + return self.optimizer.get_lr() diff --git a/fairseq/fairseq/optim/lr_scheduler/step_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/step_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..8cb20068606a4afd2983430b794fa24647de2e7b --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/step_lr_scheduler.py @@ -0,0 +1,86 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import List + +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class StepLRScheduleConfig(FairseqDataclass): + warmup_updates: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + warmup_init_lr: float = field( + default=-1, + metadata={ + "help": "initial learning rate during warmup phase; default is cfg.lr" + }, + ) + lr: List[float] = field( + default=II("optimization.lr"), + metadata={"help": "max learning rate, must be more than cfg.min_lr"}, + ) + min_lr: float = field(default=0.0, metadata={"help": "min learning rate"}) + lr_deacy_period: int = field(default=25000, metadata={"help": "decay period"}) + lr_decay: float = field(default=0.5, metadata={"help": "decay factor"}) + + +@register_lr_scheduler("step", dataclass=StepLRScheduleConfig) +class StepLRSchedule(FairseqLRScheduler): + """Decay learning rate every k updates by a fixed factor + """ + + def __init__(self, cfg: StepLRScheduleConfig, fairseq_optimizer): + super().__init__(cfg, fairseq_optimizer) + self.max_lr = cfg.lr[0] if isinstance(cfg.lr, Collection) else cfg.lr + self.min_lr = cfg.min_lr + self.lr_deacy_period = cfg.lr_deacy_period + self.lr_decay = cfg.lr_decay + self.warmup_updates = cfg.warmup_updates + self.warmup_init_lr = ( + cfg.warmup_init_lr if cfg.warmup_init_lr >= 0 else self.min_lr + ) + + assert(self.lr_deacy_period > 0) + assert(self.lr_decay <= 1) + assert(self.min_lr >= 0) + assert(self.max_lr > self.min_lr) + + if cfg.warmup_updates > 0: + # linearly warmup for the first cfg.warmup_updates + self.warmup_lr_step = ( + (self.max_lr - self.warmup_init_lr) / self.warmup_updates + ) + else: + self.warmup_lr_step = 1 + + # initial learning rate + self.lr = self.warmup_init_lr + self.optimizer.set_lr(self.lr) + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + super().step(epoch, val_loss) + # we don't change the learning rate at epoch boundaries + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + if num_updates < self.cfg.warmup_updates: + self.lr = self.warmup_init_lr + num_updates * self.warmup_lr_step + else: + curr_updates = num_updates - self.cfg.warmup_updates + lr_mult = self.lr_decay ** (curr_updates // self.lr_deacy_period) + self.lr = max(self.max_lr * lr_mult, self.min_lr) + + self.optimizer.set_lr(self.lr) + return self.lr diff --git a/fairseq/fairseq/optim/lr_scheduler/tri_stage_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/tri_stage_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..4d5547c39b14f62acbd4f4b9ab3abfb3009c0e6d --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/tri_stage_lr_scheduler.py @@ -0,0 +1,175 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import Optional, List, Tuple +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class TriStageLRScheduleConfig(FairseqDataclass): + warmup_steps: int = field( + default=0, + metadata={"help": "warmup the learning rate linearly for the first N updates"}, + ) + hold_steps: int = field( + default=0, + metadata={"help": "steps in hold stage"}, + ) + decay_steps: int = field( + default=0, + metadata={"help": "steps in decay stages"}, + ) + phase_ratio: Optional[Tuple[float, float, float]] = field( + default=None, + metadata={ + "help": ( + "if set, automatically sets warmup/hold/decay steps to the ratio " + "specified here from max_updates. the ratios must add up to 1.0" + ) + }, + ) + init_lr_scale: float = field( + default=0.01, + metadata={"help": "initial learning rate scale during warmup phase"}, + ) + final_lr_scale: float = field( + default=0.01, + metadata={"help": "final learning rate scale"}, + ) + max_update: float = II("optimization.max_update") + lr: List[float] = II("optimization.lr") + + +@register_lr_scheduler("tri_stage", dataclass=TriStageLRScheduleConfig) +class TriStageLRSchedule(FairseqLRScheduler): + """Tristage learning rate schedulr + + Implement the learning rate scheduler in https://arxiv.org/pdf/1904.08779.pdf + + Similar to inverse_squre_root scheduler, but tri_stage learning rate employs + three stages LR scheduling: + + - warmup stage, starting from `lr` * `init_lr_scale`, linearly + increased to `lr` in `warmup_steps` iterations + + - hold stage, after `warmup_steps`, keep the LR as `lr` for `hold_steps` + iterations + + - decay stage, after hold stage, decay LR exponetially to + `lr` * `final_lr_scale` in `decay_steps`; + after that LR is keep as `final_lr_scale` * `lr` + + During warmup:: + + init_lr = cfg.init_lr_scale * cfg.lr + lrs = torch.linspace(init_lr, cfg.lr, cfg.warmup_steps) + lr = lrs[update_num] + + During hold:: + + lr = cfg.lr + + During decay:: + + decay_factor = - math.log(cfg.final_lr_scale) / cfg.decay_steps + lr = cfg.lr * exp(- (update_num - warmup_steps - decay_steps) * decay_factor) + + After that:: + + lr = cfg.lr * cfg.final_lr_scale + """ + + def __init__(self, cfg: TriStageLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + if len(cfg.lr) > 1: + raise ValueError( + "Cannot use a fixed learning rate schedule with tri-stage lr." + " Consider --lr-scheduler=fixed instead." + ) + + # calculate LR at each point + self.peak_lr = cfg.lr[0] + self.init_lr = cfg.init_lr_scale * cfg.lr[0] + self.final_lr = cfg.final_lr_scale * cfg.lr[0] + + if cfg.phase_ratio is not None: + assert cfg.max_update > 0 + assert sum(cfg.phase_ratio) == 1, "phase ratios must add up to 1" + self.warmup_steps = int(cfg.max_update * cfg.phase_ratio[0]) + self.hold_steps = int(cfg.max_update * cfg.phase_ratio[1]) + self.decay_steps = int(cfg.max_update * cfg.phase_ratio[2]) + else: + self.warmup_steps = cfg.warmup_steps + self.hold_steps = cfg.hold_steps + self.decay_steps = cfg.decay_steps + + assert ( + self.warmup_steps + self.hold_steps + self.decay_steps > 0 + ), "please specify steps or phase_ratio" + + self.warmup_rate = ( + (self.peak_lr - self.init_lr) / self.warmup_steps + if self.warmup_steps != 0 + else 0 + ) + self.decay_factor = -math.log(cfg.final_lr_scale) / self.decay_steps + + # initial learning rate + self.lr = self.init_lr + self.optimizer.set_lr(self.lr) + + def _decide_stage(self, update_step): + """ + return stage, and the corresponding steps within the current stage + """ + if update_step < self.warmup_steps: + # warmup state + return 0, update_step + + offset = self.warmup_steps + + if update_step < offset + self.hold_steps: + # hold stage + return 1, update_step - offset + + offset += self.hold_steps + + if update_step <= offset + self.decay_steps: + # decay stage + return 2, update_step - offset + + offset += self.decay_steps + + # still here ? constant lr stage + return 3, update_step - offset + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + super().step(epoch, val_loss) + # we don't change the learning rate at epoch boundaries + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + stage, steps_in_stage = self._decide_stage(num_updates) + if stage == 0: + self.lr = self.init_lr + self.warmup_rate * steps_in_stage + elif stage == 1: + self.lr = self.peak_lr + elif stage == 2: + self.lr = self.peak_lr * math.exp(-self.decay_factor * steps_in_stage) + elif stage == 3: + self.lr = self.final_lr + else: + raise ValueError("Undefined stage") + + self.optimizer.set_lr(self.lr) + + return self.lr diff --git a/fairseq/fairseq/optim/lr_scheduler/triangular_lr_scheduler.py b/fairseq/fairseq/optim/lr_scheduler/triangular_lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..bfe2a0d381f28525f90ee120b31a69210338eb1b --- /dev/null +++ b/fairseq/fairseq/optim/lr_scheduler/triangular_lr_scheduler.py @@ -0,0 +1,83 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from dataclasses import dataclass, field +from typing import List + +from omegaconf import II + +from fairseq.dataclass import FairseqDataclass +from fairseq.optim.lr_scheduler import FairseqLRScheduler, register_lr_scheduler + + +@dataclass +class TriangularLRScheduleConfig(FairseqDataclass): + max_lr: float = field( + default="???", metadata={"help": "max learning rate, must be more than cfg.lr"} + ) + lr_period_updates: float = field( + default=5000, + metadata={"help": "initial number of updates per period (cycle length)"}, + ) + lr_shrink: float = field( + default=0.1, metadata={"help": "shrink factor for annealing"} + ) + shrink_min: bool = field( + default=False, metadata={"help": "if set, also shrinks min lr"} + ) + lr: List[float] = II("optimization.lr") + + +@register_lr_scheduler("triangular", dataclass=TriangularLRScheduleConfig) +class TriangularLRSchedule(FairseqLRScheduler): + """Assign LR based on a triangular cyclical schedule. + + See https://arxiv.org/pdf/1506.01186.pdf for details. + """ + + def __init__(self, cfg: TriangularLRScheduleConfig, optimizer): + super().__init__(cfg, optimizer) + if len(cfg.lr) > 1: + raise ValueError( + "Cannot use a fixed learning rate schedule with triangular." + " Consider --lr-scheduler=fixed instead." + ) + + lr = cfg.lr[0] + + assert cfg.max_lr > lr, "max_lr must be more than lr" + self.min_lr = lr + self.max_lr = cfg.max_lr + self.stepsize = cfg.lr_period_updates // 2 + self.lr_shrink = cfg.lr_shrink + self.shrink_min = cfg.shrink_min + + # initial learning rate + self.lr = self.min_lr + self.optimizer.set_lr(self.lr) + + def step(self, epoch, val_loss=None): + """Update the learning rate at the end of the given epoch.""" + super().step(epoch, val_loss) + # we don't change the learning rate at epoch boundaries + return self.optimizer.get_lr() + + def step_update(self, num_updates): + """Update the learning rate after each update.""" + cycle = math.floor(num_updates / (2 * self.stepsize)) + + lr_shrink = self.lr_shrink ** cycle + max_lr = self.max_lr * lr_shrink + if self.shrink_min: + min_lr = self.min_lr * lr_shrink + else: + min_lr = self.min_lr + + x = abs(num_updates / self.stepsize - 2 * (cycle + 1) + 1) + self.lr = min_lr + (max_lr - min_lr) * max(0, (1 - x)) + + self.optimizer.set_lr(self.lr) + return self.lr diff --git a/fairseq/fairseq/optim/nag.py b/fairseq/fairseq/optim/nag.py new file mode 100644 index 0000000000000000000000000000000000000000..c30a6c0fb1e8d5dc7edd5b53ba15a6acd46ecbff --- /dev/null +++ b/fairseq/fairseq/optim/nag.py @@ -0,0 +1,111 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from collections.abc import Collection +from dataclasses import dataclass, field +from typing import List + +import torch +from fairseq.dataclass import FairseqDataclass +from omegaconf import II, DictConfig +from torch.optim.optimizer import Optimizer, required + +from . import FairseqOptimizer, register_optimizer + + +@dataclass +class FairseqNAGConfig(FairseqDataclass): + momentum: float = field(default=0.99, metadata={"help": "momentum factor"}) + weight_decay: float = field(default=0.0, metadata={"help": "weight decay"}) + # TODO common vars in parent class + lr: List[float] = II("optimization.lr") + + +@register_optimizer("nag", dataclass=FairseqNAGConfig) +class FairseqNAG(FairseqOptimizer): + def __init__(self, cfg: DictConfig, params): + super().__init__(cfg) + self._optimizer = NAG(params, **self.optimizer_config) + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.cfg.lr[0] + if isinstance(self.cfg.lr, Collection) + else self.cfg.lr, + "momentum": self.cfg.momentum, + "weight_decay": self.cfg.weight_decay, + } + + +class NAG(Optimizer): + def __init__(self, params, lr=required, momentum=0, weight_decay=0): + defaults = dict(lr=lr, lr_old=lr, momentum=momentum, weight_decay=weight_decay) + super(NAG, self).__init__(params, defaults) + + @property + def supports_memory_efficient_fp16(self): + return True + + @property + def supports_flat_params(self): + return True + + def step(self, closure=None): + """Performs a single optimization step. + + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + weight_decay = group["weight_decay"] + momentum = group["momentum"] + lr = group["lr"] + lr_old = group.get("lr_old", lr) + lr_correct = lr / lr_old if lr_old > 0 else lr + + for p in group["params"]: + if p.grad is None: + continue + + p_data_fp32 = p.data + if p_data_fp32.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + d_p = p.grad.data.float() + param_state = self.state[p] + if "momentum_buffer" not in param_state: + param_state["momentum_buffer"] = torch.zeros_like(d_p) + else: + param_state["momentum_buffer"] = param_state["momentum_buffer"].to( + d_p + ) + + buf = param_state["momentum_buffer"] + + if weight_decay != 0: + p_data_fp32.mul_(1 - lr * weight_decay) + p_data_fp32.add_(buf, alpha=momentum * momentum * lr_correct) + p_data_fp32.add_(d_p, alpha=-(1 + momentum) * lr) + + buf.mul_(momentum * lr_correct).add_(d_p, alpha=-lr) + + if p.data.dtype in {torch.float16, torch.bfloat16}: + p.data.copy_(p_data_fp32) + + group["lr_old"] = lr + + return loss diff --git a/fairseq/fairseq/optim/sgd.py b/fairseq/fairseq/optim/sgd.py new file mode 100644 index 0000000000000000000000000000000000000000..8e34fb99a18fff12ab76be5894a84cbbb2f48176 --- /dev/null +++ b/fairseq/fairseq/optim/sgd.py @@ -0,0 +1,43 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch.optim + +from . import LegacyFairseqOptimizer, register_optimizer + + +@register_optimizer("sgd") +class SGD(LegacyFairseqOptimizer): + def __init__(self, args, params): + super().__init__(args) + self._optimizer = torch.optim.SGD(params, **self.optimizer_config) + + @staticmethod + def add_args(parser): + """Add optimizer-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--momentum', default=0.0, type=float, metavar='M', + help='momentum factor') + parser.add_argument('--weight-decay', '--wd', default=0.0, type=float, metavar='WD', + help='weight decay') + # fmt: on + + @property + def optimizer_config(self): + """ + Return a kwarg dictionary that will be used to override optimizer + args stored in checkpoints. This allows us to load a checkpoint and + resume training using a different set of optimizer args, e.g., with a + different learning rate. + """ + return { + "lr": self.args.lr[0], + "momentum": self.args.momentum, + "weight_decay": self.args.weight_decay, + } + + @property + def supports_flat_params(self): + return True diff --git a/fairseq/fairseq/optim/shard.py b/fairseq/fairseq/optim/shard.py new file mode 100644 index 0000000000000000000000000000000000000000..9d7f2eb9e5de6086fe2435d432bde7521ebb8155 --- /dev/null +++ b/fairseq/fairseq/optim/shard.py @@ -0,0 +1,58 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from typing import Any, Dict + +from fairseq.distributed import utils + + +try: + from fairscale.optim import OSS + + _has_fairscale = True +except ImportError: + _has_fairscale = False + + +def shard_(optimizer, group): + if not _has_fairscale: + raise ImportError( + "\n\nPlease install the fairscale package:" "\n\n pip install fairscale" + ) + + class FairseqOSS(OSS): + @property + def disable_mem_eff_fp16_loading_hack(self): + return True + + def __getattr__(self, name): + if name.startswith("supports") and hasattr(self.optim, name): + return getattr(self.optim, name) + raise AttributeError( + "'FairseqOSS' object has no attribute {0!r}".format(name) + ) + + def broadcast_global_state_dict( + self, state_dict: Dict[str, Any] + ) -> Dict[str, Any]: + """ + Broadcasts the entire state_dict to all other ranks + each rank is responsible to load their own partition of data + """ + return utils.broadcast_object( + state_dict, + src_rank=0, + group=self.group, + ) + + torch_optimizer = optimizer.optimizer + optim_cls = type(torch_optimizer) + + optimizer.optimizer = FairseqOSS( + torch_optimizer.param_groups, + optim_cls, + group=group, + **optimizer.optimizer_config + ) diff --git a/fairseq/fairseq/options.py b/fairseq/fairseq/options.py new file mode 100644 index 0000000000000000000000000000000000000000..0743e3cd5c0fc1f375b0e22c29620395d3fcce70 --- /dev/null +++ b/fairseq/fairseq/options.py @@ -0,0 +1,406 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +from pathlib import Path +from typing import Callable, List, Optional, Union + +import torch +from fairseq import utils +from fairseq.data.indexed_dataset import get_available_dataset_impl +from fairseq.dataclass.configs import ( + CheckpointConfig, + CommonConfig, + CommonEvalConfig, + DatasetConfig, + DistributedTrainingConfig, + EvalLMConfig, + GenerationConfig, + InteractiveConfig, + OptimizationConfig, + EMAConfig, +) +from fairseq.dataclass.utils import gen_parser_from_dataclass + +# this import is for backward compatibility +from fairseq.utils import csv_str_list, eval_bool, eval_str_dict, eval_str_list # noqa + + +def get_preprocessing_parser(default_task="translation"): + parser = get_parser("Preprocessing", default_task) + add_preprocess_args(parser) + return parser + + +def get_training_parser(default_task="translation"): + parser = get_parser("Trainer", default_task) + add_dataset_args(parser, train=True) + add_distributed_training_args(parser) + add_model_args(parser) + add_optimization_args(parser) + add_checkpoint_args(parser) + add_ema_args(parser) + return parser + + +def get_generation_parser(interactive=False, default_task="translation"): + parser = get_parser("Generation", default_task) + add_dataset_args(parser, gen=True) + add_distributed_training_args(parser) + add_generation_args(parser) + add_checkpoint_args(parser) + if interactive: + add_interactive_args(parser) + return parser + + +def get_speech_generation_parser(default_task="text_to_speech"): + parser = get_parser("Speech Generation", default_task) + add_dataset_args(parser, gen=True) + add_distributed_training_args(parser, default_world_size=1) + add_speech_generation_args(parser) + return parser + + +def get_interactive_generation_parser(default_task="translation"): + return get_generation_parser(interactive=True, default_task=default_task) + + +def get_eval_lm_parser(default_task="language_modeling"): + parser = get_parser("Evaluate Language Model", default_task) + add_dataset_args(parser, gen=True) + add_distributed_training_args(parser, default_world_size=1) + add_eval_lm_args(parser) + return parser + + +def get_validation_parser(default_task=None): + parser = get_parser("Validation", default_task) + add_dataset_args(parser, train=True) + add_distributed_training_args(parser, default_world_size=1) + group = parser.add_argument_group("Evaluation") + gen_parser_from_dataclass(group, CommonEvalConfig()) + return parser + + +def parse_args_and_arch( + parser: argparse.ArgumentParser, + input_args: List[str] = None, + parse_known: bool = False, + suppress_defaults: bool = False, + modify_parser: Optional[Callable[[argparse.ArgumentParser], None]] = None, +): + """ + Args: + parser (ArgumentParser): the parser + input_args (List[str]): strings to parse, defaults to sys.argv + parse_known (bool): only parse known arguments, similar to + `ArgumentParser.parse_known_args` + suppress_defaults (bool): parse while ignoring all default values + modify_parser (Optional[Callable[[ArgumentParser], None]]): + function to modify the parser, e.g., to set default values + """ + if suppress_defaults: + # Parse args without any default values. This requires us to parse + # twice, once to identify all the necessary task/model args, and a second + # time with all defaults set to None. + args = parse_args_and_arch( + parser, + input_args=input_args, + parse_known=parse_known, + suppress_defaults=False, + ) + suppressed_parser = argparse.ArgumentParser(add_help=False, parents=[parser]) + suppressed_parser.set_defaults(**{k: None for k, v in vars(args).items()}) + args = suppressed_parser.parse_args(input_args) + return argparse.Namespace( + **{k: v for k, v in vars(args).items() if v is not None} + ) + + from fairseq.models import ARCH_MODEL_REGISTRY, ARCH_CONFIG_REGISTRY, MODEL_REGISTRY + + # Before creating the true parser, we need to import optional user module + # in order to eagerly import custom tasks, optimizers, architectures, etc. + usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False) + usr_parser.add_argument("--user-dir", default=None) + usr_args, _ = usr_parser.parse_known_args(input_args) + utils.import_user_module(usr_args) + + if modify_parser is not None: + modify_parser(parser) + + # The parser doesn't know about model/criterion/optimizer-specific args, so + # we parse twice. First we parse the model/criterion/optimizer, then we + # parse a second time after adding the *-specific arguments. + # If input_args is given, we will parse those args instead of sys.argv. + args, _ = parser.parse_known_args(input_args) + + # Add model-specific args to parser. + if hasattr(args, "arch"): + model_specific_group = parser.add_argument_group( + "Model-specific configuration", + # Only include attributes which are explicitly given as command-line + # arguments or which have default values. + argument_default=argparse.SUPPRESS, + ) + if args.arch in ARCH_MODEL_REGISTRY: + ARCH_MODEL_REGISTRY[args.arch].add_args(model_specific_group) + elif args.arch in MODEL_REGISTRY: + MODEL_REGISTRY[args.arch].add_args(model_specific_group) + else: + raise RuntimeError() + + if hasattr(args, "task"): + from fairseq.tasks import TASK_REGISTRY + + TASK_REGISTRY[args.task].add_args(parser) + if getattr(args, "use_bmuf", False): + # hack to support extra args for block distributed data parallelism + from fairseq.optim.bmuf import FairseqBMUF + + FairseqBMUF.add_args(parser) + + # Add *-specific args to parser. + from fairseq.registry import REGISTRIES + + for registry_name, REGISTRY in REGISTRIES.items(): + choice = getattr(args, registry_name, None) + if choice is not None: + cls = REGISTRY["registry"][choice] + if hasattr(cls, "add_args"): + cls.add_args(parser) + elif hasattr(cls, "__dataclass"): + gen_parser_from_dataclass(parser, cls.__dataclass()) + + # Modify the parser a second time, since defaults may have been reset + if modify_parser is not None: + modify_parser(parser) + + # Parse a second time. + if parse_known: + args, extra = parser.parse_known_args(input_args) + else: + args = parser.parse_args(input_args) + extra = None + # Post-process args. + if ( + hasattr(args, "batch_size_valid") and args.batch_size_valid is None + ) or not hasattr(args, "batch_size_valid"): + args.batch_size_valid = args.batch_size + if hasattr(args, "max_tokens_valid") and args.max_tokens_valid is None: + args.max_tokens_valid = args.max_tokens + if getattr(args, "memory_efficient_fp16", False): + args.fp16 = True + if getattr(args, "memory_efficient_bf16", False): + args.bf16 = True + args.tpu = getattr(args, "tpu", False) + args.bf16 = getattr(args, "bf16", False) + if args.bf16: + args.tpu = True + if args.tpu and args.fp16: + raise ValueError("Cannot combine --fp16 and --tpu, use --bf16 on TPUs") + + if getattr(args, "seed", None) is None: + args.seed = 1 # default seed for training + args.no_seed_provided = True + else: + args.no_seed_provided = False + + # Apply architecture configuration. + if hasattr(args, "arch") and args.arch in ARCH_CONFIG_REGISTRY: + ARCH_CONFIG_REGISTRY[args.arch](args) + + if parse_known: + return args, extra + else: + return args + + +def get_parser(desc, default_task="translation"): + # Before creating the true parser, we need to import optional user module + # in order to eagerly import custom tasks, optimizers, architectures, etc. + usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False) + usr_parser.add_argument("--user-dir", default=None) + usr_args, _ = usr_parser.parse_known_args() + utils.import_user_module(usr_args) + + parser = argparse.ArgumentParser(allow_abbrev=False) + gen_parser_from_dataclass(parser, CommonConfig()) + + from fairseq.registry import REGISTRIES + + for registry_name, REGISTRY in REGISTRIES.items(): + parser.add_argument( + "--" + registry_name.replace("_", "-"), + default=REGISTRY["default"], + choices=REGISTRY["registry"].keys(), + ) + + # Task definitions can be found under fairseq/tasks/ + from fairseq.tasks import TASK_REGISTRY + + parser.add_argument( + "--task", + metavar="TASK", + default=default_task, + choices=TASK_REGISTRY.keys(), + help="task", + ) + # fmt: on + return parser + + +def add_preprocess_args(parser): + group = parser.add_argument_group("Preprocessing") + # fmt: off + group.add_argument("-s", "--source-lang", default=None, metavar="SRC", + help="source language") + group.add_argument("-t", "--target-lang", default=None, metavar="TARGET", + help="target language") + group.add_argument("--trainpref", metavar="FP", default=None, + help="train file prefix (also used to build dictionaries)") + group.add_argument("--validpref", metavar="FP", default=None, + help="comma separated, valid file prefixes " + "(words missing from train set are replaced with <unk>)") + group.add_argument("--testpref", metavar="FP", default=None, + help="comma separated, test file prefixes " + "(words missing from train set are replaced with <unk>)") + group.add_argument("--align-suffix", metavar="FP", default=None, + help="alignment file suffix") + group.add_argument("--destdir", metavar="DIR", default="data-bin", + help="destination dir") + group.add_argument("--thresholdtgt", metavar="N", default=0, type=int, + help="map words appearing less than threshold times to unknown") + group.add_argument("--thresholdsrc", metavar="N", default=0, type=int, + help="map words appearing less than threshold times to unknown") + group.add_argument("--tgtdict", metavar="FP", + help="reuse given target dictionary") + group.add_argument("--srcdict", metavar="FP", + help="reuse given source dictionary") + group.add_argument("--nwordstgt", metavar="N", default=-1, type=int, + help="number of target words to retain") + group.add_argument("--nwordssrc", metavar="N", default=-1, type=int, + help="number of source words to retain") + group.add_argument("--alignfile", metavar="ALIGN", default=None, + help="an alignment file (optional)") + parser.add_argument('--dataset-impl', metavar='FORMAT', default='mmap', + choices=get_available_dataset_impl(), + help='output dataset implementation') + group.add_argument("--joined-dictionary", action="store_true", + help="Generate joined dictionary") + group.add_argument("--only-source", action="store_true", + help="Only process the source language") + group.add_argument("--padding-factor", metavar="N", default=8, type=int, + help="Pad dictionary size to be multiple of N") + group.add_argument("--workers", metavar="N", default=1, type=int, + help="number of parallel workers") + group.add_argument("--dict-only", action='store_true', + help="if true, only builds a dictionary and then exits") + # fmt: on + return parser + + +def add_dataset_args(parser, train=False, gen=False): + group = parser.add_argument_group("dataset_data_loading") + gen_parser_from_dataclass(group, DatasetConfig()) + # fmt: on + return group + + +def add_distributed_training_args(parser, default_world_size=None): + group = parser.add_argument_group("distributed_training") + if default_world_size is None: + default_world_size = max(1, torch.cuda.device_count()) + gen_parser_from_dataclass( + group, DistributedTrainingConfig(distributed_world_size=default_world_size) + ) + return group + + +def add_optimization_args(parser): + group = parser.add_argument_group("optimization") + # fmt: off + gen_parser_from_dataclass(group, OptimizationConfig()) + # fmt: on + return group + + +def add_checkpoint_args(parser): + group = parser.add_argument_group("checkpoint") + # fmt: off + gen_parser_from_dataclass(group, CheckpointConfig()) + # fmt: on + return group + + +def add_common_eval_args(group): + gen_parser_from_dataclass(group, CommonEvalConfig()) + + +def add_eval_lm_args(parser): + group = parser.add_argument_group("LM Evaluation") + add_common_eval_args(group) + gen_parser_from_dataclass(group, EvalLMConfig()) + + +def add_generation_args(parser): + group = parser.add_argument_group("Generation") + add_common_eval_args(group) + gen_parser_from_dataclass(group, GenerationConfig()) + return group + + +def add_speech_generation_args(parser): + group = parser.add_argument_group("Speech Generation") + add_common_eval_args(group) # NOTE: remove_bpe is not needed + # fmt: off + group.add_argument('--eos_prob_threshold', default=0.5, type=float, + help='terminate when eos probability exceeds this') + # fmt: on + return group + + +def add_interactive_args(parser): + group = parser.add_argument_group("Interactive") + gen_parser_from_dataclass(group, InteractiveConfig()) + + +def add_model_args(parser): + group = parser.add_argument_group("Model configuration") + # fmt: off + + # Model definitions can be found under fairseq/models/ + # + # The model architecture can be specified in several ways. + # In increasing order of priority: + # 1) model defaults (lowest priority) + # 2) --arch argument + # 3) --encoder/decoder-* arguments (highest priority) + from fairseq.models import ARCH_MODEL_REGISTRY + group.add_argument('--arch', '-a', metavar='ARCH', + choices=ARCH_MODEL_REGISTRY.keys(), + help='model architecture') + # fmt: on + return group + + +def get_args( + data: Union[str, Path], + task: str = "translation", + arch: str = "transformer", + **overrides +): + parser = get_training_parser(task) + args = parse_args_and_arch(parser, [str(data), "--task", task, "--arch", arch]) + + for k, v in overrides.items(): + setattr(args, k, v) + + return args + + +def add_ema_args(parser): + group = parser.add_argument_group("EMA configuration") + gen_parser_from_dataclass(group, EMAConfig()) diff --git a/fairseq/fairseq/pdb.py b/fairseq/fairseq/pdb.py new file mode 100644 index 0000000000000000000000000000000000000000..1ba6ef0d336b30717cfdde94e1b838cfe2bfeb20 --- /dev/null +++ b/fairseq/fairseq/pdb.py @@ -0,0 +1,47 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import multiprocessing +import os +import pdb +import sys + + +__all__ = ["set_trace"] + + +_stdin = [None] +_stdin_lock = multiprocessing.Lock() +try: + _stdin_fd = sys.stdin.fileno() +except Exception: + _stdin_fd = None + + +class MultiprocessingPdb(pdb.Pdb): + """A Pdb wrapper that works in a multiprocessing environment. + + Usage: `from fairseq import pdb; pdb.set_trace()` + """ + + def __init__(self): + pdb.Pdb.__init__(self, nosigint=True) + + def _cmdloop(self): + stdin_bak = sys.stdin + with _stdin_lock: + try: + if _stdin_fd is not None: + if not _stdin[0]: + _stdin[0] = os.fdopen(_stdin_fd) + sys.stdin = _stdin[0] + self.cmdloop() + finally: + sys.stdin = stdin_bak + + +def set_trace(): + pdb = MultiprocessingPdb() + pdb.set_trace(sys._getframe().f_back) diff --git a/fairseq/fairseq/quantization_utils.py b/fairseq/fairseq/quantization_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..11fc414c852b199b80a569bf024272535929abcc --- /dev/null +++ b/fairseq/fairseq/quantization_utils.py @@ -0,0 +1,143 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +from fairseq.modules.quantization import pq, quantization_options, scalar +from omegaconf import DictConfig + + +logger = logging.getLogger(__name__) + + +def quantize_model_scalar(model, model_cfg: DictConfig): + quant_noise_scalar = getattr(model_cfg, "quant_noise_scalar", 0) or 0 + if quant_noise_scalar > 0: + # quantize_model edits the model in place + scalar.quantize_model_(model, p=quant_noise_scalar, bits=8, update_step=1000) + return model + + +class Quantizer(object): + def __init__(self, config_path, max_epoch, max_update): + try: + import yaml + except ImportError: + raise ImportError("Please install yaml with: pip install yaml") + + # parse config + if config_path: + with open(config_path) as config_file: + config = quantization_options.parse_config_yaml( + yaml.safe_load(config_file) + ) + else: + config = quantization_options.parse_config_yaml({}) + + self.n_centroids_config = config["n_centroids"] + self.block_sizes_config = config["block_sizes"] + self.layers_to_quantize = config["layers_to_quantize"] + + # We assume that training will run for a fixed number of epochs + # (or updates) and that we should train for equal durations + # between iterations of PQ. + num_iterations = len(self.layers_to_quantize) + if max_epoch > 0: + assert max_epoch % num_iterations == 0, ( + "for iterative PQ, --max-epoch (={}) must be evenly divisible by " + "len(layers_to_quantize) (={})".format(max_epoch, num_iterations) + ) + self.epoch_schedule = max_epoch // num_iterations + else: + self.epoch_schedule = None + if max_update > 0: + assert max_update % num_iterations == 0, ( + "for iterative PQ, --max-update (={}) must be evenly divisible by " + "len(layers_to_quantize) (={})".format(max_update, num_iterations) + ) + self.update_schedule = max_update // num_iterations + else: + self.update_schedule = None + assert (self.epoch_schedule is not None) ^ ( + self.update_schedule is not None + ), "for iterative PQ, cannot specify both --max-update and --max-epoch" + + # 0 is a special value for quantization step, which will force + # the first call to begin_epoch() to call step() + self.quantization_step = 0 + + def set_trainer(self, trainer): + self.trainer = trainer + self.size_tracker = pq.SizeTracker(self.trainer.get_model()) + + def step(self): + """Move to the next stage of quantization.""" + if self.quantization_step >= len(self.layers_to_quantize): + # Maybe we just finished the last training step or we loaded + # a checkpoint for an iterative PQ model which previously + # finished training. Either way, don't quantize again. + return + + logger.info( + "quantizing model (step={}; layers_to_quantize[step]={})".format( + self.quantization_step, self.layers_to_quantize[self.quantization_step] + ) + ) + quantized_layers = pq.quantize_model_( + self.trainer.get_model(), + self.size_tracker, + self.layers_to_quantize, + self.block_sizes_config, + self.n_centroids_config, + step=self.quantization_step, + ) + logger.info("quantized layers: {}".format(quantized_layers)) + logger.info(self.size_tracker) + + self.quantization_step += 1 + + # reintialize the Trainer since model parameters have changed + self.trainer.reinitialize() + + def begin_epoch(self, epoch): + """Called at the beginning of each epoch (epochs start at 1).""" + if ( + ( + self.epoch_schedule is not None + and epoch > 0 + and (epoch - 1) % self.epoch_schedule == 0 + ) + # we always step once in the beginning, even if using + # update-based quantization + or self.quantization_step == 0 + ): + self.step() + + def step_update(self, num_updates): + """Called at the end of each step.""" + if ( + self.update_schedule is not None + and num_updates > 0 + and num_updates % self.update_schedule == 0 + ): + self.step() + + def state_dict(self): + return { + "n_centroids_config": self.n_centroids_config, + "block_sizes_config": self.block_sizes_config, + "layers_to_quantize": self.layers_to_quantize, + "epoch_schedule": self.epoch_schedule, + "update_schedule": self.update_schedule, + "quantization_step": self.quantization_step, + } + + def load_state_dict(self, state_dict): + self.n_centroids_config = state_dict["n_centroids_config"] + self.block_sizes_config = state_dict["block_sizes_config"] + self.layers_to_quantize = state_dict["layers_to_quantize"] + self.epoch_schedule = state_dict["epoch_schedule"] + self.update_schedule = state_dict["update_schedule"] + self.quantization_step = state_dict["quantization_step"] diff --git a/fairseq/fairseq/registry.py b/fairseq/fairseq/registry.py new file mode 100644 index 0000000000000000000000000000000000000000..f3b9406043d75a51d7bf4af5294f82b33a8f9a5e --- /dev/null +++ b/fairseq/fairseq/registry.py @@ -0,0 +1,100 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from argparse import Namespace + +from typing import Union +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import merge_with_parent +from hydra.core.config_store import ConfigStore +from omegaconf import DictConfig + +REGISTRIES = {} + + +def setup_registry(registry_name: str, base_class=None, default=None, required=False): + assert registry_name.startswith("--") + registry_name = registry_name[2:].replace("-", "_") + + REGISTRY = {} + REGISTRY_CLASS_NAMES = set() + DATACLASS_REGISTRY = {} + + # maintain a registry of all registries + if registry_name in REGISTRIES: + return # registry already exists + REGISTRIES[registry_name] = { + "registry": REGISTRY, + "default": default, + "dataclass_registry": DATACLASS_REGISTRY, + } + + def build_x(cfg: Union[DictConfig, str, Namespace], *extra_args, **extra_kwargs): + if isinstance(cfg, DictConfig): + choice = cfg._name + + if choice and choice in DATACLASS_REGISTRY: + dc = DATACLASS_REGISTRY[choice] + cfg = merge_with_parent(dc(), cfg) + elif isinstance(cfg, str): + choice = cfg + if choice in DATACLASS_REGISTRY: + cfg = DATACLASS_REGISTRY[choice]() + else: + choice = getattr(cfg, registry_name, None) + if choice in DATACLASS_REGISTRY: + cfg = DATACLASS_REGISTRY[choice].from_namespace(cfg) + + if choice is None: + if required: + raise ValueError("{} is required!".format(registry_name)) + return None + + cls = REGISTRY[choice] + if hasattr(cls, "build_" + registry_name): + builder = getattr(cls, "build_" + registry_name) + else: + builder = cls + + return builder(cfg, *extra_args, **extra_kwargs) + + def register_x(name, dataclass=None): + def register_x_cls(cls): + if name in REGISTRY: + raise ValueError( + "Cannot register duplicate {} ({})".format(registry_name, name) + ) + if cls.__name__ in REGISTRY_CLASS_NAMES: + raise ValueError( + "Cannot register {} with duplicate class name ({})".format( + registry_name, cls.__name__ + ) + ) + if base_class is not None and not issubclass(cls, base_class): + raise ValueError( + "{} must extend {}".format(cls.__name__, base_class.__name__) + ) + + if dataclass is not None and not issubclass(dataclass, FairseqDataclass): + raise ValueError( + "Dataclass {} must extend FairseqDataclass".format(dataclass) + ) + + cls.__dataclass = dataclass + if cls.__dataclass is not None: + DATACLASS_REGISTRY[name] = cls.__dataclass + + cs = ConfigStore.instance() + node = dataclass() + node._name = name + cs.store(name=name, group=registry_name, node=node, provider="fairseq") + + REGISTRY[name] = cls + + return cls + + return register_x_cls + + return build_x, register_x, REGISTRY, DATACLASS_REGISTRY diff --git a/fairseq/fairseq/scoring/__init__.py b/fairseq/fairseq/scoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..58f2f563e493327394dff1265030d18f0814b5a2 --- /dev/null +++ b/fairseq/fairseq/scoring/__init__.py @@ -0,0 +1,55 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + + +import importlib +import os +from abc import ABC, abstractmethod + +from fairseq import registry +from omegaconf import DictConfig + + +class BaseScorer(ABC): + def __init__(self, cfg): + self.cfg = cfg + self.ref = [] + self.pred = [] + + def add_string(self, ref, pred): + self.ref.append(ref) + self.pred.append(pred) + + @abstractmethod + def score(self) -> float: + pass + + @abstractmethod + def result_string(self) -> str: + pass + + +_build_scorer, register_scorer, SCORER_REGISTRY, _ = registry.setup_registry( + "--scoring", default="bleu" +) + + +def build_scorer(choice, tgt_dict): + _choice = choice._name if isinstance(choice, DictConfig) else choice + + if _choice == "bleu": + from fairseq.scoring import bleu + + return bleu.Scorer( + bleu.BleuConfig(pad=tgt_dict.pad(), eos=tgt_dict.eos(), unk=tgt_dict.unk()) + ) + return _build_scorer(choice) + + +# automatically import any Python files in the current directory +for file in sorted(os.listdir(os.path.dirname(__file__))): + if file.endswith(".py") and not file.startswith("_"): + module = file[: file.find(".py")] + importlib.import_module("fairseq.scoring." + module) diff --git a/fairseq/fairseq/scoring/bleu.py b/fairseq/fairseq/scoring/bleu.py new file mode 100644 index 0000000000000000000000000000000000000000..97de5f966ec08e5a304c41358e67755c601622b7 --- /dev/null +++ b/fairseq/fairseq/scoring/bleu.py @@ -0,0 +1,167 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import ctypes +import math +import sys +from dataclasses import dataclass, field + +import torch +from fairseq.dataclass import FairseqDataclass +from fairseq.scoring import BaseScorer, register_scorer +from fairseq.scoring.tokenizer import EvaluationTokenizer + + +class BleuStat(ctypes.Structure): + _fields_ = [ + ("reflen", ctypes.c_size_t), + ("predlen", ctypes.c_size_t), + ("match1", ctypes.c_size_t), + ("count1", ctypes.c_size_t), + ("match2", ctypes.c_size_t), + ("count2", ctypes.c_size_t), + ("match3", ctypes.c_size_t), + ("count3", ctypes.c_size_t), + ("match4", ctypes.c_size_t), + ("count4", ctypes.c_size_t), + ] + + +@dataclass +class SacrebleuConfig(FairseqDataclass): + sacrebleu_tokenizer: EvaluationTokenizer.ALL_TOKENIZER_TYPES = field( + default="13a", metadata={"help": "tokenizer"} + ) + sacrebleu_lowercase: bool = field( + default=False, metadata={"help": "apply lowercasing"} + ) + sacrebleu_char_level: bool = field( + default=False, metadata={"help": "evaluate at character level"} + ) + + +@register_scorer("sacrebleu", dataclass=SacrebleuConfig) +class SacrebleuScorer(BaseScorer): + def __init__(self, cfg): + super(SacrebleuScorer, self).__init__(cfg) + import sacrebleu + + self.sacrebleu = sacrebleu + self.tokenizer = EvaluationTokenizer( + tokenizer_type=cfg.sacrebleu_tokenizer, + lowercase=cfg.sacrebleu_lowercase, + character_tokenization=cfg.sacrebleu_char_level, + ) + + def add_string(self, ref, pred): + self.ref.append(self.tokenizer.tokenize(ref)) + self.pred.append(self.tokenizer.tokenize(pred)) + + def score(self, order=4): + return self.result_string(order).score + + def result_string(self, order=4): + if order != 4: + raise NotImplementedError + # tokenization and lowercasing are performed by self.tokenizer instead. + return self.sacrebleu.corpus_bleu( + self.pred, [self.ref], tokenize="none" + ).format() + + +@dataclass +class BleuConfig(FairseqDataclass): + pad: int = field(default=1, metadata={"help": "padding index"}) + eos: int = field(default=2, metadata={"help": "eos index"}) + unk: int = field(default=3, metadata={"help": "unk index"}) + + +@register_scorer("bleu", dataclass=BleuConfig) +class Scorer(object): + def __init__(self, cfg): + self.stat = BleuStat() + self.pad = cfg.pad + self.eos = cfg.eos + self.unk = cfg.unk + + try: + from fairseq import libbleu + except ImportError as e: + sys.stderr.write( + "ERROR: missing libbleu.so. run `pip install --editable .`\n" + ) + raise e + + self.C = ctypes.cdll.LoadLibrary(libbleu.__file__) + + self.reset() + + def reset(self, one_init=False): + if one_init: + self.C.bleu_one_init(ctypes.byref(self.stat)) + else: + self.C.bleu_zero_init(ctypes.byref(self.stat)) + + def add(self, ref, pred): + if not isinstance(ref, torch.IntTensor): + raise TypeError("ref must be a torch.IntTensor (got {})".format(type(ref))) + if not isinstance(pred, torch.IntTensor): + raise TypeError("pred must be a torch.IntTensor(got {})".format(type(pred))) + + # don't match unknown words + rref = ref.clone() + assert not rref.lt(0).any() + rref[rref.eq(self.unk)] = -999 + + rref = rref.contiguous().view(-1) + pred = pred.contiguous().view(-1) + + self.C.bleu_add( + ctypes.byref(self.stat), + ctypes.c_size_t(rref.size(0)), + ctypes.c_void_p(rref.data_ptr()), + ctypes.c_size_t(pred.size(0)), + ctypes.c_void_p(pred.data_ptr()), + ctypes.c_int(self.pad), + ctypes.c_int(self.eos), + ) + + def score(self, order=4): + psum = sum( + math.log(p) if p > 0 else float("-Inf") for p in self.precision()[:order] + ) + return self.brevity() * math.exp(psum / order) * 100 + + def precision(self): + def ratio(a, b): + return a / b if b > 0 else 0 + + return [ + ratio(self.stat.match1, self.stat.count1), + ratio(self.stat.match2, self.stat.count2), + ratio(self.stat.match3, self.stat.count3), + ratio(self.stat.match4, self.stat.count4), + ] + + def brevity(self): + r = self.stat.reflen / self.stat.predlen + return min(1, math.exp(1 - r)) + + def result_string(self, order=4): + assert order <= 4, "BLEU scores for order > 4 aren't supported" + fmt = "BLEU{} = {:2.2f}, {:2.1f}" + for _ in range(1, order): + fmt += "/{:2.1f}" + fmt += " (BP={:.3f}, ratio={:.3f}, syslen={}, reflen={})" + bleup = [p * 100 for p in self.precision()[:order]] + return fmt.format( + order, + self.score(order=order), + *bleup, + self.brevity(), + self.stat.predlen / self.stat.reflen, + self.stat.predlen, + self.stat.reflen + ) diff --git a/fairseq/fairseq/scoring/chrf.py b/fairseq/fairseq/scoring/chrf.py new file mode 100644 index 0000000000000000000000000000000000000000..0d6cb77383a44d9ac739958b79a30764f1fbf7f3 --- /dev/null +++ b/fairseq/fairseq/scoring/chrf.py @@ -0,0 +1,27 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from fairseq.scoring import BaseScorer, register_scorer + + +@register_scorer("chrf") +class ChrFScorer(BaseScorer): + def __init__(self, args): + super(ChrFScorer, self).__init__(args) + import sacrebleu + + self.sacrebleu = sacrebleu + + def add_string(self, ref, pred): + self.ref.append(ref) + self.pred.append(pred) + + def score(self, order=4): + return self.result_string(order).score + + def result_string(self, order=4): + if order != 4: + raise NotImplementedError + return self.sacrebleu.corpus_chrf(self.pred, [self.ref]).format() diff --git a/fairseq/fairseq/scoring/tokenizer.py b/fairseq/fairseq/scoring/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..61cf6d4a7cc698258caad9f68f2e8559dd510eee --- /dev/null +++ b/fairseq/fairseq/scoring/tokenizer.py @@ -0,0 +1,67 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unicodedata + +from fairseq.dataclass import ChoiceEnum + + +class EvaluationTokenizer(object): + """A generic evaluation-time tokenizer, which leverages built-in tokenizers + in sacreBLEU (https://github.com/mjpost/sacrebleu). It additionally provides + lowercasing, punctuation removal and character tokenization, which are + applied after sacreBLEU tokenization. + + Args: + tokenizer_type (str): the type of sacreBLEU tokenizer to apply. + lowercase (bool): lowercase the text. + punctuation_removal (bool): remove punctuation (based on unicode + category) from text. + character_tokenization (bool): tokenize the text to characters. + """ + + SPACE = chr(32) + SPACE_ESCAPE = chr(9601) + ALL_TOKENIZER_TYPES = ChoiceEnum(["none", "13a", "intl", "zh", "ja-mecab"]) + + def __init__( + self, + tokenizer_type: str = "13a", + lowercase: bool = False, + punctuation_removal: bool = False, + character_tokenization: bool = False, + ): + from sacrebleu.tokenizers import TOKENIZERS + + assert tokenizer_type in TOKENIZERS, f"{tokenizer_type}, {TOKENIZERS}" + self.lowercase = lowercase + self.punctuation_removal = punctuation_removal + self.character_tokenization = character_tokenization + self.tokenizer = TOKENIZERS[tokenizer_type] + + @classmethod + def remove_punctuation(cls, sent: str): + """Remove punctuation based on Unicode category.""" + return cls.SPACE.join( + t + for t in sent.split(cls.SPACE) + if not all(unicodedata.category(c)[0] == "P" for c in t) + ) + + def tokenize(self, sent: str): + tokenized = self.tokenizer()(sent) + + if self.punctuation_removal: + tokenized = self.remove_punctuation(tokenized) + + if self.character_tokenization: + tokenized = self.SPACE.join( + list(tokenized.replace(self.SPACE, self.SPACE_ESCAPE)) + ) + + if self.lowercase: + tokenized = tokenized.lower() + + return tokenized diff --git a/fairseq/fairseq/scoring/wer.py b/fairseq/fairseq/scoring/wer.py new file mode 100644 index 0000000000000000000000000000000000000000..633dc47c247691c4c9e36cbdbab7d7cb74b38452 --- /dev/null +++ b/fairseq/fairseq/scoring/wer.py @@ -0,0 +1,58 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field + +from fairseq.dataclass import FairseqDataclass +from fairseq.scoring import BaseScorer, register_scorer +from fairseq.scoring.tokenizer import EvaluationTokenizer + + +@dataclass +class WerScorerConfig(FairseqDataclass): + wer_tokenizer: EvaluationTokenizer.ALL_TOKENIZER_TYPES = field( + default="none", metadata={"help": "sacreBLEU tokenizer to use for evaluation"} + ) + wer_remove_punct: bool = field( + default=False, metadata={"help": "remove punctuation"} + ) + wer_char_level: bool = field( + default=False, metadata={"help": "evaluate at character level"} + ) + wer_lowercase: bool = field(default=False, metadata={"help": "lowercasing"}) + + +@register_scorer("wer", dataclass=WerScorerConfig) +class WerScorer(BaseScorer): + def __init__(self, cfg): + super().__init__(cfg) + self.reset() + try: + import editdistance as ed + except ImportError: + raise ImportError("Please install editdistance to use WER scorer") + self.ed = ed + self.tokenizer = EvaluationTokenizer( + tokenizer_type=self.cfg.wer_tokenizer, + lowercase=self.cfg.wer_lowercase, + punctuation_removal=self.cfg.wer_remove_punct, + character_tokenization=self.cfg.wer_char_level, + ) + + def reset(self): + self.distance = 0 + self.ref_length = 0 + + def add_string(self, ref, pred): + ref_items = self.tokenizer.tokenize(ref).split() + pred_items = self.tokenizer.tokenize(pred).split() + self.distance += self.ed.eval(ref_items, pred_items) + self.ref_length += len(ref_items) + + def result_string(self): + return f"WER: {self.score():.2f}" + + def score(self): + return 100.0 * self.distance / self.ref_length if self.ref_length > 0 else 0 diff --git a/fairseq/fairseq/search.py b/fairseq/fairseq/search.py new file mode 100644 index 0000000000000000000000000000000000000000..d5ea68b4ce04409c504c1d22098b7968a9ce596a --- /dev/null +++ b/fairseq/fairseq/search.py @@ -0,0 +1,814 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import List, Optional + +import torch +import torch.nn as nn +from fairseq.token_generation_constraints import ( + ConstraintState, + OrderedConstraintState, + UnorderedConstraintState, +) +from torch import Tensor + + +class Search(nn.Module): + def __init__(self, tgt_dict): + super().__init__() + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.eos = tgt_dict.eos() + self.vocab_size = len(tgt_dict) + self.src_lengths = torch.tensor(-1) + self.supports_constraints = False + self.stop_on_max_len = False + + def step( + self, step, lprobs, scores, prev_output_tokens=None, original_batch_idxs=None + ): + """Take a single search step. + + Args: + step: the current search step, starting at 0 + lprobs: (bsz x input_beam_size x vocab_size) + the model's log-probabilities over the vocabulary at the current step + scores: (bsz x input_beam_size x step) + the historical model scores of each hypothesis up to this point + prev_output_tokens: (bsz x step) + the previously generated oputput tokens + original_batch_idxs: (bsz) + the tensor with the batch indices, in the range [0, bsz) + this is useful in case there has been applied a re-ordering + and we need to know the orignal indices + + Return: A tuple of (scores, indices, beams) where: + scores: (bsz x output_beam_size) + the scores of the chosen elements; output_beam_size can be + larger than input_beam_size, e.g., we may return + 2*input_beam_size to account for EOS + indices: (bsz x output_beam_size) + the indices of the chosen elements + beams: (bsz x output_beam_size) + the hypothesis ids of the chosen elements, in the range [0, input_beam_size) + """ + raise NotImplementedError + + @torch.jit.export + def set_src_lengths(self, src_lengths): + self.src_lengths = src_lengths + + @torch.jit.export + def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int): + """Initialize constraint states for constrained decoding (if supported). + + Args: + batch_constraints: (torch.Tensor, optional) + the list of constraints, in packed form + beam_size: (int) + the beam size + Returns: + *encoder_out* rearranged according to *new_order* + """ + pass + + def prune_sentences(self, batch_idxs: Tensor): + """ + Removes constraint states for completed sentences (if supported). + This is called from sequence_generator._generate() when sentences are + deleted from the batch. + + Args: + batch_idxs: Indices of *sentences* whose constraint state should be *kept*. + """ + pass + + def update_constraints(self, active_hypos: Tensor): + """ + Updates the constraint states by selecting the beam items that are retained. + This is called at each time step of sequence_generator._generate() when + the set of 2 * {beam_size} candidate hypotheses are reduced to the beam size. + + Args: + active_hypos: (batch size, beam size) + list of integers denoting, for each sentence, which beam candidate items + should be kept. + """ + pass + + +class BeamSearch(Search): + def __init__(self, tgt_dict): + super().__init__(tgt_dict) + self.constraint_states = None + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores: Optional[Tensor], + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(bsz, -1), + k=min( + # Take the best 2 x beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size * 2, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ), + ) + scores_buf = top_prediction[0] + indices_buf = top_prediction[1] + # Project back into relative indices and beams + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + + # At this point, beams_buf and indices_buf are single-dim and contain relative indices + return scores_buf, indices_buf, beams_buf + + +class PrefixConstrainedBeamSearch(Search): + def __init__(self, tgt_dict, prefix_allowed_tokens_fn): + super().__init__(tgt_dict) + self.prefix_allowed_tokens_fn = prefix_allowed_tokens_fn + self.stop_on_max_len = True + + @torch.jit.export + def apply_mask(self, x, prev_output_tokens, original_batch_idxs): + beam_size = x.shape[0] // original_batch_idxs.shape[0] + original_batch_idxs = ( + original_batch_idxs.unsqueeze(-1).repeat((1, beam_size)).flatten().tolist() + ) + + mask = torch.full_like(x, -math.inf) + for sent_i, (sent, batch_i) in enumerate( + zip(prev_output_tokens, original_batch_idxs) + ): + mask[sent_i, :, self.prefix_allowed_tokens_fn(batch_i, sent)] = 0 + + return mask + + @torch.jit.export + def step( + self, + step: int, + lprobs: Tensor, + scores: Tensor, + prev_output_tokens: Tensor, + original_batch_idxs: Tensor, + ): + bsz, beam_size, vocab_size = lprobs.size() + + lprobs += self.apply_mask( + lprobs.view(bsz * beam_size, 1, vocab_size), + prev_output_tokens, + original_batch_idxs, + ).view(bsz, beam_size, vocab_size) + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(bsz, -1), + k=min( + # Take the best beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ), + ) + scores_buf = top_prediction[0] + indices_buf = top_prediction[1] + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + return scores_buf, indices_buf, beams_buf + + +class LexicallyConstrainedBeamSearch(Search): + """Implements lexically constrained beam search as described in + + Fast Lexically Constrained Decoding with Dynamic Beam + Allocation for Neural Machine Translation. Post & Vilar, + NAACL 2018. https://www.aclweb.org/anthology/N18-1119/ + + and + + Improved Lexically Constrained Decoding for Translation and + Monolingual Rewriting. Hu et al, NAACL + 2019. https://www.aclweb.org/anthology/N19-1090/ + + This is accomplished by maintaining, for each beam hypothesis, a + ConstraintState object (see constraints.py) that tracks which + constraints have been generated and using this information to + shape the beam for each input sentence. + """ + + def __init__(self, tgt_dict, representation): + super().__init__(tgt_dict) + self.representation = representation + self.vocab_size = len(tgt_dict) + self.num_cands = 0 + self.supports_constraints = True + + @torch.jit.export + def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int): + self.constraint_states = [] + for constraint_tensor in batch_constraints: + if self.representation == "ordered": + constraint_state = OrderedConstraintState.create(constraint_tensor) + elif self.representation == "unordered": + constraint_state = UnorderedConstraintState.create(constraint_tensor) + + self.constraint_states.append([constraint_state for i in range(beam_size)]) + + @torch.jit.export + def prune_sentences(self, batch_idxs: Tensor): + self.constraint_states = [ + self.constraint_states[i] for i in batch_idxs.tolist() + ] + + @torch.jit.export + def update_constraints(self, active_hypos: Tensor): + if self.constraint_states: + batch_size = active_hypos.size(0) + for sentid in range(batch_size): + self.constraint_states[sentid] = [ + self.constraint_states[sentid][i] for i in active_hypos[sentid] + ] + + @torch.jit.export + def step( + self, + step: int, + lprobs: Tensor, + scores: Optional[Tensor], + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + """ + A constrained step builds a large candidates list from the following: + - the top 2 * {beam_size} items over the whole beam + - for each item in the beam + - the top {each_k} (default 1) + - all next constraints + We then compute the constrained state of each beam item, and assign + stripe codes: 0 to the best in each bank, 1 to the 2nd-best, and so + on. We then sort by (stripe, score), and truncate the list at + 2 * beam size. + + Args: + step: the decoder step + lprobs: (batch size, beam size, target vocab) + the target-vocab distributions for each item in the beam. + Retrun: A tuple of (scores, indices, beams, constraints) where: + scores: (batch, output beam size) + the scores of the chosen elements + indices: (batch, output beam size) + the target vocab indices of the chosen elements + beams: (batch, output beam size) + the 0-indexed hypothesis ids of the chosen elements + constraints: (batch, output beam size) + the new constraint states + """ + each_k = 1 + device = lprobs.device + + batch_size, beam_size, vocab_size = lprobs.size() + + self.num_cands = min( + # Just take the k-best. We'll get another k from the 1-best from each + # row, plus more from the constraints + beam_size * 2, + lprobs.view(batch_size, -1).size(1) - 1, # -1 so we never select pad + ) + + # STEP 0: Preliminary. Prevent EOS for unfinished hyps across all batch items + constraint_states = self.constraint_states + if constraint_states and step > 0: + not_finished_indices = [] + for sentno, sent_constraints in enumerate(constraint_states): + for beamno, state in enumerate(sent_constraints): + index = sentno * beam_size + beamno + if not state.finished: + not_finished_indices.append(index) + not_finished_indices = torch.tensor(not_finished_indices) + if not_finished_indices.numel() > 0: + lprobs.view(batch_size * beam_size, -1)[ + not_finished_indices, self.eos + ] = -math.inf + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam entry for each batch item + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(batch_size, -1), + self.num_cands, + ) + scores_buf, indices_buf = top_prediction + # Project back into relative indices and beams + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + + # Short circuit if there are no constraints in this batch + if not constraint_states: + return scores_buf, indices_buf, beams_buf + + # STEP 1: get top-1 from each hypothesis across all sentences in the batch + if step > 0: + top_scores, top_indices = torch.topk( + lprobs.view(batch_size * beam_size, -1), + k=each_k, + dim=1, + ) + top_scores = top_scores.view(batch_size, -1) + top_indices = top_indices.view(batch_size, -1) + scores_buf = torch.cat((scores_buf, top_scores), dim=1) + indices_buf = torch.cat((indices_buf, top_indices), dim=1) + new_beams = torch.arange(0, beam_size, device=device).repeat(batch_size, 1) + beams_buf = torch.cat((beams_buf, new_beams), dim=1) + + # Now, process sentences in the batch one by one. + new_scores_buf = torch.zeros((batch_size, 2 * beam_size), device=device) + new_indices_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long() + new_beams_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long() + for sentno, states in enumerate(constraint_states): + scores, indices, beams, new_states = self.step_sentence( + step, + sentno, + lprobs[sentno], + constraint_states[sentno], + beams_buf[sentno].clone(), + indices_buf[sentno].clone(), + scores_buf[sentno].clone(), + ) + new_scores_buf[sentno] = scores + new_indices_buf[sentno] = indices + new_beams_buf[sentno] = beams + self.constraint_states[sentno] = new_states + + return new_scores_buf, new_indices_buf, new_beams_buf + + @torch.jit.export + def step_sentence( + self, + step: int, + sentno: int, + lprobs: Tensor, + constraint_states: List[List[ConstraintState]], + beams_buf: Tensor, + indices_buf: Tensor, + scores_buf: Tensor, + ): + """Does per-sentence processing. Adds all constraints for each + hypothesis to the list of candidates; then removes duplicates, + sorts, and dynamically stripes across the banks. All tensor inputs + are collapsed to those pertaining to a single input sentence. + """ + device = lprobs.device + + # STEP 2: Add all constraints for each beam item + for beamno, state in enumerate(constraint_states): + next_tokens = torch.tensor(list(state.next_tokens()), device=device).long() + if next_tokens.numel() != 0: + indices_buf = torch.cat((indices_buf, next_tokens)) + next_beams = ( + torch.tensor(beamno, device=device) + .repeat(next_tokens.size(0)) + .long() + ) + beams_buf = torch.cat((beams_buf, next_beams)) + next_values = lprobs[beamno].take(next_tokens.view(-1)) + scores_buf = torch.cat((scores_buf, next_values)) + + # At the 0th time step, there is just one beam item + if step == 0: + break + + # STEP 3: Compute the "bank" for each candidate. This is the + # number of constraints it's generated. We need this so that + # we can do round-robin allocation of the beam across these + # banks. If C is the number of constraints, we select the best + # item in bank C, then the best in bank C-1, etc, followed by + # the 2nd-best in bank C, the 2nd-best in bank C-1, etc, and so + # on, until the maximum beam size. We accomplish this by + # creating a sort key and striping across the banks. + + # Compute the new states for all candidates + cands_size = indices_buf.size(0) + constraint_states = [ + constraint_states[beams_buf[i]].advance(indices_buf[i]) + for i in range(cands_size) + ] + + banks = torch.tensor([state.bank for state in constraint_states], device=device) + + # STEP 4: Sort + num_constraint_tokens = len(state.tokens) + + # Sort by keys (bank, score) (i.e., sort banks together, and scores + # within banks). AFAIK pytorch doesn't support either stable sort or + # multi-key sorting, so we have to hack this. + MAX_SCORE = -100 + sort_key = (num_constraint_tokens - banks) * MAX_SCORE + scores_buf + sort_values, sort_indices = sort_key.sort(dim=0, descending=True) + scores_buf = scores_buf[sort_indices] + indices_buf = indices_buf[sort_indices] + beams_buf = beams_buf[sort_indices] + banks = banks[sort_indices] + + # Sort the constraints to follow suit + constraint_states = [constraint_states[i] for i in sort_indices] + + # STEP 5: Remove duplicates. The topk calls (overall and + # per-row) plus the per-row generation of constraints will + # produce duplicates. Here we remove them. + + def roll(t): + """Rolls a 1d tensor left by 1. + + [0, 1, 2, 3, 4] becomes [4, 0, 1, 2, 3] + """ + return torch.cat((t[-1].unsqueeze(0), t[0:-1]), dim=0) + + # We map candidates (beam, token_id) to a single dimension. + # This is then shifted by 1. We can then easily identify + # duplicates and create a mask that identifies unique + # extensions. + uniques_mask = beams_buf * (self.vocab_size + 1) + indices_buf + uniques_mask = roll(uniques_mask) != uniques_mask + + # Use the mask to pare down the data structures + scores_buf = torch.masked_select(scores_buf, uniques_mask) + indices_buf = torch.masked_select(indices_buf, uniques_mask) + beams_buf = torch.masked_select(beams_buf, uniques_mask) + banks = torch.masked_select(banks, uniques_mask) + i = 1 + for mask in uniques_mask[1:]: + if not mask: + constraint_states.pop(i) + i += mask + + # STEP 6: Assign IDs round-robin across banks, sort, and + # truncate. Now that the candidates are sorted by (bank, + # score) and uniqed, we dynamically allocate the {beam_size} + # beam by striping across the candidates. These stripes will + # be used as sort keys to do round-robin selection. This is + # accomplished in a single pass with offsets. Sorting by + # highest-banks (furthest-along hypotheses) first ensures + # progress through the constraints. + # + # e.g., BANKS: 3 3 3 2 2 2 2 1 1 1 0 0 + # OLD STRIPES: 0 1 2 0 1 2 3 0 1 2 0 1 + # NEW STRIPES: 0 1+4 2+8 0+1 1+5 2+9 3+11 0+2 1+6 2+10 0+3 1+7 + # = 0 5 10 1 6 11 13 2 7 12 3 8 + # + # Sorting by this then gives the following banks: + # + # 3 2 1 0 3 2 1 0 3 2 1 2 + # + # We'll take the top {beam_size} of these. + stripe_offsets = [offset * (len(banks) + 1) for offset in range(len(banks) + 1)] + stripes = torch.zeros_like(banks) + cur_bank_count = -1 + cur_bank = banks[0] + for i, bank in enumerate(banks): + if bank != cur_bank: + cur_bank_count = 0 + cur_bank = bank + else: + cur_bank_count += 1 + stripes[i] = num_constraint_tokens - bank + stripe_offsets[cur_bank_count] + + # STEP 7: Sort by the stripes values + sort_values, sort_indices = stripes.sort(dim=0) + scores_buf = scores_buf[sort_indices] + indices_buf = indices_buf[sort_indices] + beams_buf = beams_buf[sort_indices] + constraint_states = [constraint_states[i] for i in sort_indices] + + # STEP 8: Truncate to the candidates size! + scores_buf = scores_buf[: self.num_cands] + indices_buf = indices_buf[: self.num_cands] + beams_buf = beams_buf[: self.num_cands] + + return scores_buf, indices_buf, beams_buf, constraint_states + + +class LengthConstrainedBeamSearch(Search): + def __init__(self, tgt_dict, min_len_a, min_len_b, max_len_a, max_len_b): + super().__init__(tgt_dict) + self.min_len_a = min_len_a + self.min_len_b = min_len_b + self.max_len_a = max_len_a + self.max_len_b = max_len_b + self.beam = BeamSearch(tgt_dict) + self.needs_src_lengths = True + + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + min_lens = self.min_len_a * self.src_lengths + self.min_len_b + max_lens = self.max_len_a * self.src_lengths + self.max_len_b + lprobs[step < min_lens, :, self.eos] = -math.inf + lprobs[step >= max_lens, :, self.eos] = 0 + return self.beam.step(step, lprobs, scores) + + +class DiverseBeamSearch(Search): + """Diverse Beam Search. + + See "Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence + Models" for details. + + We only implement the Hamming Diversity penalty here, which performed best + in the original paper. + """ + + def __init__(self, tgt_dict, num_groups, diversity_strength): + super().__init__(tgt_dict) + self.num_groups = num_groups + self.diversity_strength = -diversity_strength + self.beam = BeamSearch(tgt_dict) + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + if beam_size % self.num_groups != 0: + raise ValueError( + "DiverseBeamSearch requires --beam to be divisible by the number of groups" + ) + + # initialize diversity penalty + diversity_buf = torch.zeros(lprobs[:, 0, :].size()).to(lprobs) + + scores_G, indices_G, beams_G = [], [], [] + for g in range(self.num_groups): + lprobs_g = lprobs[:, g :: self.num_groups, :] + scores_g = scores[:, g :: self.num_groups, :] if step > 0 else None + + # apply diversity penalty + if g > 0: + lprobs_g = torch.add( + lprobs_g, + other=diversity_buf.unsqueeze(1), + alpha=self.diversity_strength, + ) + else: + lprobs_g = lprobs_g.contiguous() + + scores_buf, indices_buf, beams_buf = self.beam.step( + step, lprobs_g, scores_g + ) + beams_buf.mul_(self.num_groups).add_(g) + + scores_G.append(scores_buf.clone()) + indices_G.append(indices_buf.clone()) + beams_G.append(beams_buf.clone()) + + # update diversity penalty + diversity_buf.scatter_add_( + 1, indices_buf, torch.ones(indices_buf.size()).to(diversity_buf) + ) + + # interleave results from different groups + scores_buf = torch.stack(scores_G, dim=2).view(bsz, -1) + indices_buf = torch.stack(indices_G, dim=2).view(bsz, -1) + beams_buf = torch.stack(beams_G, dim=2).view(bsz, -1) + return scores_buf, indices_buf, beams_buf + + +class Sampling(Search): + sampling_topk: int + sampling_topp: float + + def __init__(self, tgt_dict, sampling_topk=-1, sampling_topp=-1.0): + super().__init__(tgt_dict) + self.sampling_topk = sampling_topk + self.sampling_topp = sampling_topp + + def _sample_topp(self, lprobs): + """Sample among the smallest set of elements whose cumulative probability mass exceeds p. + + See `"The Curious Case of Neural Text Degeneration" + (Holtzman et al., 2019) <https://arxiv.org/abs/1904.09751>`_. + + Args: + lprobs: (bsz x input_beam_size x vocab_size) + the model's log-probabilities over the vocabulary at the current step + + Return: A tuple of (trimed_probs, truncated_indices) where: + trimed_probs: (bsz x input_beam_size x ?) + the model's probabilities over the elements selected to sample from. The + width of the third dimension is determined by top-P. + truncated_indices: (bsz x input_beam_size x ?) + the indices of the chosen elements. + """ + probs = lprobs.exp_() + + # sort the last dimension (vocab dimension) in descending order + sorted_probs, sorted_indices = probs.sort(descending=True) + + # compute a mask to indicate the words to be included in the top-P set. + cumsum_probs = sorted_probs.cumsum(dim=2) + mask = cumsum_probs.lt(self.sampling_topp) + + # note that mask was computed by 'lt'. One more word needs to be included + # so that the cumulative probability mass can exceed p. + cumsum_mask = mask.cumsum(dim=2) + last_included = cumsum_mask[:, :, -1:] + last_included.clamp_(0, mask.size()[2] - 1) + mask = mask.scatter_(2, last_included, 1) + + # truncate unnecessary dims. + max_dim = last_included.max() + truncated_mask = mask[:, :, : max_dim + 1] + truncated_probs = sorted_probs[:, :, : max_dim + 1] + truncated_indices = sorted_indices[:, :, : max_dim + 1] + + # trim the words that are not in top-P by setting their probabilities + # to 0, so that they would not be sampled later. + trim_mask = ~truncated_mask + trimed_probs = truncated_probs.masked_fill_(trim_mask, 0) + return trimed_probs, truncated_indices + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + + if self.sampling_topp > 0: + # only sample from the smallest set of words whose cumulative probability mass exceeds p + probs, top_indices = self._sample_topp(lprobs) + elif self.sampling_topk > 0: + # only sample from top-k candidates + lprobs, top_indices = lprobs.topk(self.sampling_topk) + probs = lprobs.exp_() + else: + probs = lprobs.exp_() + + # dummy data to be consistent with true branch for type check + top_indices = torch.empty(0).to(probs) + # sample + if step == 0: + indices_buf = torch.multinomial( + probs.view(bsz, -1), + beam_size, + replacement=True, + ).view(bsz, beam_size) + else: + indices_buf = torch.multinomial( + probs.view(bsz * beam_size, -1), + 1, + replacement=True, + ).view(bsz, beam_size) + + if step == 0: + # expand to beam size + probs = probs.expand(bsz, beam_size, -1) + + # gather scores + scores_buf = torch.gather(probs, dim=2, index=indices_buf.unsqueeze(-1)) + scores_buf = scores_buf.log_().view(bsz, -1) + + # remap indices if using top-k or top-P sampling + if self.sampling_topk > 0 or self.sampling_topp > 0: + indices_buf = torch.gather( + top_indices.expand(bsz, beam_size, -1), + dim=2, + index=indices_buf.unsqueeze(-1), + ).squeeze(2) + + if step == 0: + beams_buf = indices_buf.new_zeros(bsz, beam_size) + else: + beams_buf = torch.arange(0, beam_size).to(indices_buf).repeat(bsz, 1) + # make scores cumulative + scores_buf.add_( + torch.gather(scores[:, :, step - 1], dim=1, index=beams_buf) + ) + + return scores_buf, indices_buf, beams_buf + + +class DiverseSiblingsSearch(Search): + """ + Beam search with diverse siblings. + + See "A Simple, Fast Diverse Decoding Algorithm for Neural Generation" for details. + https://arxiv.org/abs/1611.08562 + + 1/ Calculate hypotheses for each beam + 2/ Intra-sibling ordering + 3/ Rewrite scores + 4/ Choose top K hypotheses + + if diversity_rate == 0 is equivalent to BeamSearch + """ + + def __init__(self, tgt_dict, diversity_rate): + super().__init__(tgt_dict) + self.diversity_rate = diversity_rate + self.beam = BeamSearch(tgt_dict) + + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + k = min( + # Take the best 2 x beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size * 2, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ) + s_list: List[Tensor] + i_list: List[Tensor] + s_list = [torch.empty(0).to(lprobs) for i in range(beam_size)] + i_list = [torch.LongTensor().to(device=lprobs.device) for i in range(beam_size)] + sibling_score = torch.arange(1, k + 1).to(lprobs) * self.diversity_rate + + if step == 0: + return self.beam.step(step, lprobs, scores) + lprobs.add_(scores[:, :, step - 1].unsqueeze(-1)) + + # 1/ Calculate hypotheses for each beam + for i in range(beam_size): + torch.topk(lprobs[:, i, :].view(bsz, -1), k, out=(s_list[i], i_list[i])) + i_list[i].fmod_(vocab_size) + + # 2/ Intra-sibling ordering by default from topk + 3/ Rewrite scores + s_list[i].sub_(sibling_score) + + # 4/ Choose top K hypotheses + indices = torch.stack(i_list, dim=1).view(bsz, -1) + + final_scores = torch.empty(0).to(lprobs) + final_indices = torch.LongTensor().to(device=lprobs.device) + final_beams = torch.LongTensor().to(device=lprobs.device) + (final_scores, final_indices) = torch.topk( + torch.stack(s_list, dim=1).view(bsz, -1), + k, + ) + + final_beams = final_indices // k + + for i in range(bsz): + final_indices[i] = indices[i][final_indices[i]] + + return final_scores, final_indices, final_beams diff --git a/fairseq/fairseq/sequence_generator.py b/fairseq/fairseq/sequence_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..2e61140dd834210cfd7ecc14808951f4709c3519 --- /dev/null +++ b/fairseq/fairseq/sequence_generator.py @@ -0,0 +1,973 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import math +from typing import Dict, List, Optional +import sys + +import torch +import torch.nn as nn +from fairseq import search, utils +from fairseq.data import data_utils +from fairseq.models import FairseqIncrementalDecoder +from torch import Tensor +from fairseq.ngram_repeat_block import NGramRepeatBlock + + +class SequenceGenerator(nn.Module): + def __init__( + self, + models, + tgt_dict, + beam_size=1, + max_len_a=0, + max_len_b=200, + max_len=0, + min_len=1, + normalize_scores=True, + len_penalty=1.0, + unk_penalty=0.0, + temperature=1.0, + match_source_len=False, + no_repeat_ngram_size=0, + search_strategy=None, + eos=None, + symbols_to_strip_from_output=None, + lm_model=None, + lm_weight=1.0, + ): + """Generates translations of a given source sentence. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models, + currently support fairseq.models.TransformerModel for scripting + beam_size (int, optional): beam width (default: 1) + max_len_a/b (int, optional): generate sequences of maximum length + ax + b, where x is the source length + max_len (int, optional): the maximum length of the generated output + (not including end-of-sentence) + min_len (int, optional): the minimum length of the generated output + (not including end-of-sentence) + normalize_scores (bool, optional): normalize scores by the length + of the output (default: True) + len_penalty (float, optional): length penalty, where <1.0 favors + shorter, >1.0 favors longer sentences (default: 1.0) + unk_penalty (float, optional): unknown word penalty, where <0 + produces more unks, >0 produces fewer (default: 0.0) + temperature (float, optional): temperature, where values + >1.0 produce more uniform samples and values <1.0 produce + sharper samples (default: 1.0) + match_source_len (bool, optional): outputs should match the source + length (default: False) + """ + super().__init__() + if isinstance(models, EnsembleModel): + self.model = models + else: + self.model = EnsembleModel(models) + self.tgt_dict = tgt_dict + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.eos = tgt_dict.eos() if eos is None else eos + self.symbols_to_strip_from_output = ( + symbols_to_strip_from_output.union({self.eos}) + if symbols_to_strip_from_output is not None + else {self.eos} + ) + self.vocab_size = len(tgt_dict) + self.beam_size = beam_size + # the max beam size is the dictionary size - 1, since we never select pad + self.beam_size = min(beam_size, self.vocab_size - 1) + self.max_len_a = max_len_a + self.max_len_b = max_len_b + self.min_len = min_len + self.max_len = max_len or self.model.max_decoder_positions() + + self.normalize_scores = normalize_scores + self.len_penalty = len_penalty + self.unk_penalty = unk_penalty + self.temperature = temperature + self.match_source_len = match_source_len + + if no_repeat_ngram_size > 0: + self.repeat_ngram_blocker = NGramRepeatBlock(no_repeat_ngram_size) + else: + self.repeat_ngram_blocker = None + + assert temperature > 0, "--temperature must be greater than 0" + + self.search = ( + search.BeamSearch(tgt_dict) if search_strategy is None else search_strategy + ) + # We only need to set src_lengths in LengthConstrainedBeamSearch. + # As a module attribute, setting it would break in multithread + # settings when the model is shared. + self.should_set_src_lengths = ( + hasattr(self.search, "needs_src_lengths") and self.search.needs_src_lengths + ) + + self.model.eval() + + self.lm_model = lm_model + self.lm_weight = lm_weight + if self.lm_model is not None: + self.lm_model.eval() + + def cuda(self): + self.model.cuda() + return self + + @torch.no_grad() + def forward( + self, + sample: Dict[str, Dict[str, Tensor]], + prefix_tokens: Optional[Tensor] = None, + bos_token: Optional[int] = None, + ): + """Generate a batch of translations. + + Args: + sample (dict): batch + prefix_tokens (torch.LongTensor, optional): force decoder to begin + with these tokens + bos_token (int, optional): beginning of sentence token + (default: self.eos) + """ + return self._generate(sample, prefix_tokens, bos_token=bos_token) + + # TODO(myleott): unused, deprecate after pytorch-translate migration + def generate_batched_itr(self, data_itr, beam_size=None, cuda=False, timer=None): + """Iterate over a batched dataset and yield individual translations. + Args: + cuda (bool, optional): use GPU for generation + timer (StopwatchMeter, optional): time generations + """ + for sample in data_itr: + s = utils.move_to_cuda(sample) if cuda else sample + if "net_input" not in s: + continue + input = s["net_input"] + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in input.items() if k != "prev_output_tokens" + } + if timer is not None: + timer.start() + with torch.no_grad(): + hypos = self.generate(encoder_input) + if timer is not None: + timer.stop(sum(len(h[0]["tokens"]) for h in hypos)) + for i, id in enumerate(s["id"].data): + # remove padding + src = utils.strip_pad(input["src_tokens"].data[i, :], self.pad) + ref = ( + utils.strip_pad(s["target"].data[i, :], self.pad) + if s["target"] is not None + else None + ) + yield id, src, ref, hypos[i] + + @torch.no_grad() + def generate(self, models, sample: Dict[str, Dict[str, Tensor]], **kwargs) -> List[List[Dict[str, Tensor]]]: + """Generate translations. Match the api of other fairseq generators. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + sample (dict): batch + prefix_tokens (torch.LongTensor, optional): force decoder to begin + with these tokens + constraints (torch.LongTensor, optional): force decoder to include + the list of constraints + bos_token (int, optional): beginning of sentence token + (default: self.eos) + """ + return self._generate(sample, **kwargs) + + def _generate( + self, + sample: Dict[str, Dict[str, Tensor]], + prefix_tokens: Optional[Tensor] = None, + constraints: Optional[Tensor] = None, + bos_token: Optional[int] = None, + ): + incremental_states = torch.jit.annotate( + List[Dict[str, Dict[str, Optional[Tensor]]]], + [ + torch.jit.annotate(Dict[str, Dict[str, Optional[Tensor]]], {}) + for i in range(self.model.models_size) + ], + ) + net_input = sample["net_input"] + + if "src_tokens" in net_input: + src_tokens = net_input["src_tokens"] + # length of the source text being the character length except EndOfSentence and pad + src_lengths = ( + (src_tokens.ne(self.eos) & src_tokens.ne(self.pad)).long().sum(dim=1) + ) + elif "source" in net_input: + src_tokens = net_input["source"] + src_lengths = ( + net_input["padding_mask"].size(-1) - net_input["padding_mask"].sum(-1) + if net_input["padding_mask"] is not None + else torch.tensor(src_tokens.size(-1)).to(src_tokens) + ) + elif "features" in net_input: + src_tokens = net_input["features"] + src_lengths = ( + net_input["padding_mask"].size(-1) - net_input["padding_mask"].sum(-1) + if net_input["padding_mask"] is not None + else torch.tensor(src_tokens.size(-1)).to(src_tokens) + ) + else: + raise Exception("expected src_tokens or source in net input. input keys: " + str(net_input.keys())) + + # bsz: total number of sentences in beam + # Note that src_tokens may have more than 2 dimensions (i.e. audio features) + bsz, src_len = src_tokens.size()[:2] + beam_size = self.beam_size + + if constraints is not None and not self.search.supports_constraints: + raise NotImplementedError( + "Target-side constraints were provided, but search method doesn't support them" + ) + + # Initialize constraints, when active + self.search.init_constraints(constraints, beam_size) + + max_len: int = -1 + if self.match_source_len: + max_len = src_lengths.max().item() + else: + max_len = min( + int(self.max_len_a * src_len + self.max_len_b), + self.max_len - 1, + ) + assert ( + self.min_len <= max_len + ), "min_len cannot be larger than max_len, please adjust these!" + # compute the encoder output for each beam + with torch.autograd.profiler.record_function("EnsembleModel: forward_encoder"): + encoder_outs = self.model.forward_encoder(net_input) + + # placeholder of indices for bsz * beam_size to hold tokens and accumulative scores + new_order = torch.arange(bsz).view(-1, 1).repeat(1, beam_size).view(-1) + new_order = new_order.to(src_tokens.device).long() + encoder_outs = self.model.reorder_encoder_out(encoder_outs, new_order) + # ensure encoder_outs is a List. + assert encoder_outs is not None + + # initialize buffers + scores = ( + torch.zeros(bsz * beam_size, max_len + 1).to(src_tokens).float() + ) # +1 for eos; pad is never chosen for scoring + tokens = ( + torch.zeros(bsz * beam_size, max_len + 2) + .to(src_tokens) + .long() + .fill_(self.pad) + ) # +2 for eos and pad + tokens[:, 0] = self.eos if bos_token is None else bos_token + attn: Optional[Tensor] = None + + # A list that indicates candidates that should be ignored. + # For example, suppose we're sampling and have already finalized 2/5 + # samples. Then cands_to_ignore would mark 2 positions as being ignored, + # so that we only finalize the remaining 3 samples. + cands_to_ignore = ( + torch.zeros(bsz, beam_size).to(src_tokens).eq(-1) + ) # forward and backward-compatible False mask + + # list of completed sentences + finalized = torch.jit.annotate( + List[List[Dict[str, Tensor]]], + [torch.jit.annotate(List[Dict[str, Tensor]], []) for i in range(bsz)], + ) # contains lists of dictionaries of infomation about the hypothesis being finalized at each step + + # a boolean array indicating if the sentence at the index is finished or not + finished = [False for i in range(bsz)] + num_remaining_sent = bsz # number of sentences remaining + + # number of candidate hypos per step + cand_size = 2 * beam_size # 2 x beam size in case half are EOS + + # offset arrays for converting between different indexing schemes + bbsz_offsets = ( + (torch.arange(0, bsz) * beam_size) + .unsqueeze(1) + .type_as(tokens) + .to(src_tokens.device) + ) + cand_offsets = torch.arange(0, cand_size).type_as(tokens).to(src_tokens.device) + + reorder_state: Optional[Tensor] = None + batch_idxs: Optional[Tensor] = None + + original_batch_idxs: Optional[Tensor] = None + if "id" in sample and isinstance(sample["id"], Tensor): + original_batch_idxs = sample["id"] + else: + original_batch_idxs = torch.arange(0, bsz).type_as(tokens) + + for step in range(max_len + 1): # one extra step for EOS marker + # reorder decoder internal states based on the prev choice of beams + if reorder_state is not None: + if batch_idxs is not None: + # update beam indices to take into account removed sentences + corr = batch_idxs - torch.arange(batch_idxs.numel()).type_as( + batch_idxs + ) + reorder_state.view(-1, beam_size).add_( + corr.unsqueeze(-1) * beam_size + ) + original_batch_idxs = original_batch_idxs[batch_idxs] + self.model.reorder_incremental_state(incremental_states, reorder_state) + encoder_outs = self.model.reorder_encoder_out( + encoder_outs, reorder_state + ) + with torch.autograd.profiler.record_function("EnsembleModel: forward_decoder"): + lprobs, avg_attn_scores = self.model.forward_decoder( + tokens[:, : step + 1], + encoder_outs, + incremental_states, + self.temperature, + ) + + if self.lm_model is not None: + lm_out = self.lm_model(tokens[:, : step + 1]) + probs = self.lm_model.get_normalized_probs( + lm_out, log_probs=True, sample=None + ) + probs = probs[:, -1, :] * self.lm_weight + lprobs += probs + # handle prefix tokens (possibly with different lengths) + if ( + prefix_tokens is not None + and step < prefix_tokens.size(1) + and step < max_len + ): + lprobs, tokens, scores = self._prefix_tokens( + step, lprobs, scores, tokens, prefix_tokens, beam_size + ) + elif step < self.min_len: + # minimum length constraint (does not apply if using prefix_tokens) + lprobs[:, self.eos] = -math.inf + + lprobs[lprobs != lprobs] = torch.tensor(-math.inf).to(lprobs) + + lprobs[:, self.pad] = -math.inf # never select pad + lprobs[:, self.unk] -= self.unk_penalty # apply unk penalty + + # handle max length constraint + if step >= max_len: + lprobs[:, : self.eos] = -math.inf + lprobs[:, self.eos + 1 :] = -math.inf + + # Record attention scores, only support avg_attn_scores is a Tensor + if avg_attn_scores is not None: + if attn is None: + attn = torch.empty( + bsz * beam_size, avg_attn_scores.size(1), max_len + 2 + ).to(scores) + attn[:, :, step + 1].copy_(avg_attn_scores) + + scores = scores.type_as(lprobs) + eos_bbsz_idx = torch.empty(0).to( + tokens + ) # indices of hypothesis ending with eos (finished sentences) + eos_scores = torch.empty(0).to( + scores + ) # scores of hypothesis ending with eos (finished sentences) + + if self.should_set_src_lengths: + self.search.set_src_lengths(src_lengths) + + if self.repeat_ngram_blocker is not None: + lprobs = self.repeat_ngram_blocker(tokens, lprobs, bsz, beam_size, step) + + # Shape: (batch, cand_size) + cand_scores, cand_indices, cand_beams = self.search.step( + step, + lprobs.view(bsz, -1, self.vocab_size), + scores.view(bsz, beam_size, -1)[:, :, :step], + tokens[:, : step + 1], + original_batch_idxs, + ) + + # cand_bbsz_idx contains beam indices for the top candidate + # hypotheses, with a range of values: [0, bsz*beam_size), + # and dimensions: [bsz, cand_size] + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + + # finalize hypotheses that end in eos + # Shape of eos_mask: (batch size, beam size) + eos_mask = cand_indices.eq(self.eos) & cand_scores.ne(-math.inf) + eos_mask[:, :beam_size][cands_to_ignore] = torch.tensor(0).to(eos_mask) + + # only consider eos when it's among the top beam_size indices + # Now we know what beam item(s) to finish + # Shape: 1d list of absolute-numbered + eos_bbsz_idx = torch.masked_select( + cand_bbsz_idx[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + + finalized_sents: List[int] = [] + if eos_bbsz_idx.numel() > 0: + eos_scores = torch.masked_select( + cand_scores[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + + finalized_sents = self.finalize_hypos( + step, + eos_bbsz_idx, + eos_scores, + tokens, + scores, + finalized, + finished, + beam_size, + attn, + src_lengths, + max_len, + ) + num_remaining_sent -= len(finalized_sents) + + assert num_remaining_sent >= 0 + if num_remaining_sent == 0: + break + if self.search.stop_on_max_len and step >= max_len: + break + assert step < max_len, f"{step} < {max_len}" + + # Remove finalized sentences (ones for which {beam_size} + # finished hypotheses have been generated) from the batch. + if len(finalized_sents) > 0: + new_bsz = bsz - len(finalized_sents) + + # construct batch_idxs which holds indices of batches to keep for the next pass + batch_mask = torch.ones( + bsz, dtype=torch.bool, device=cand_indices.device + ) + batch_mask[finalized_sents] = False + # TODO replace `nonzero(as_tuple=False)` after TorchScript supports it + batch_idxs = torch.arange( + bsz, device=cand_indices.device + ).masked_select(batch_mask) + + # Choose the subset of the hypothesized constraints that will continue + self.search.prune_sentences(batch_idxs) + + eos_mask = eos_mask[batch_idxs] + cand_beams = cand_beams[batch_idxs] + bbsz_offsets.resize_(new_bsz, 1) + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + cand_scores = cand_scores[batch_idxs] + cand_indices = cand_indices[batch_idxs] + + if prefix_tokens is not None: + prefix_tokens = prefix_tokens[batch_idxs] + src_lengths = src_lengths[batch_idxs] + cands_to_ignore = cands_to_ignore[batch_idxs] + + scores = scores.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + tokens = tokens.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + if attn is not None: + attn = attn.view(bsz, -1)[batch_idxs].view( + new_bsz * beam_size, attn.size(1), -1 + ) + bsz = new_bsz + else: + batch_idxs = None + + # Set active_mask so that values > cand_size indicate eos hypos + # and values < cand_size indicate candidate active hypos. + # After, the min values per row are the top candidate active hypos + + # Rewrite the operator since the element wise or is not supported in torchscript. + + eos_mask[:, :beam_size] = ~((~cands_to_ignore) & (~eos_mask[:, :beam_size])) + active_mask = torch.add( + eos_mask.type_as(cand_offsets) * cand_size, + cand_offsets[: eos_mask.size(1)], + ) + + # get the top beam_size active hypotheses, which are just + # the hypos with the smallest values in active_mask. + # {active_hypos} indicates which {beam_size} hypotheses + # from the list of {2 * beam_size} candidates were + # selected. Shapes: (batch size, beam size) + new_cands_to_ignore, active_hypos = torch.topk( + active_mask, k=beam_size, dim=1, largest=False + ) + + # update cands_to_ignore to ignore any finalized hypos. + cands_to_ignore = new_cands_to_ignore.ge(cand_size)[:, :beam_size] + # Make sure there is at least one active item for each sentence in the batch. + assert (~cands_to_ignore).any(dim=1).all() + + # update cands_to_ignore to ignore any finalized hypos + + # {active_bbsz_idx} denotes which beam number is continued for each new hypothesis (a beam + # can be selected more than once). + active_bbsz_idx = torch.gather(cand_bbsz_idx, dim=1, index=active_hypos) + active_scores = torch.gather(cand_scores, dim=1, index=active_hypos) + + active_bbsz_idx = active_bbsz_idx.view(-1) + active_scores = active_scores.view(-1) + + # copy tokens and scores for active hypotheses + + # Set the tokens for each beam (can select the same row more than once) + tokens[:, : step + 1] = torch.index_select( + tokens[:, : step + 1], dim=0, index=active_bbsz_idx + ) + # Select the next token for each of them + tokens.view(bsz, beam_size, -1)[:, :, step + 1] = torch.gather( + cand_indices, dim=1, index=active_hypos + ) + if step > 0: + scores[:, :step] = torch.index_select( + scores[:, :step], dim=0, index=active_bbsz_idx + ) + scores.view(bsz, beam_size, -1)[:, :, step] = torch.gather( + cand_scores, dim=1, index=active_hypos + ) + + # Update constraints based on which candidates were selected for the next beam + self.search.update_constraints(active_hypos) + + # copy attention for active hypotheses + if attn is not None: + attn[:, :, : step + 2] = torch.index_select( + attn[:, :, : step + 2], dim=0, index=active_bbsz_idx + ) + + # reorder incremental state in decoder + reorder_state = active_bbsz_idx + + # sort by score descending + for sent in range(len(finalized)): + scores = torch.tensor( + [float(elem["score"].item()) for elem in finalized[sent]] + ) + _, sorted_scores_indices = torch.sort(scores, descending=True) + finalized[sent] = [finalized[sent][ssi] for ssi in sorted_scores_indices] + finalized[sent] = torch.jit.annotate( + List[Dict[str, Tensor]], finalized[sent] + ) + return finalized + + def _prefix_tokens( + self, step: int, lprobs, scores, tokens, prefix_tokens, beam_size: int + ): + """Handle prefix tokens""" + prefix_toks = prefix_tokens[:, step].unsqueeze(-1).repeat(1, beam_size).view(-1) + prefix_lprobs = lprobs.gather(-1, prefix_toks.unsqueeze(-1)) + prefix_mask = prefix_toks.ne(self.pad) + lprobs[prefix_mask] = torch.min(prefix_lprobs) - 1 + lprobs[prefix_mask] = lprobs[prefix_mask].scatter( + -1, prefix_toks[prefix_mask].unsqueeze(-1), prefix_lprobs[prefix_mask] + ) + # if prefix includes eos, then we should make sure tokens and + # scores are the same across all beams + eos_mask = prefix_toks.eq(self.eos) + if eos_mask.any(): + # validate that the first beam matches the prefix + first_beam = tokens[eos_mask].view(-1, beam_size, tokens.size(-1))[ + :, 0, 1 : step + 1 + ] + eos_mask_batch_dim = eos_mask.view(-1, beam_size)[:, 0] + target_prefix = prefix_tokens[eos_mask_batch_dim][:, :step] + assert (first_beam == target_prefix).all() + + # copy tokens, scores and lprobs from the first beam to all beams + tokens = self.replicate_first_beam(tokens, eos_mask_batch_dim, beam_size) + scores = self.replicate_first_beam(scores, eos_mask_batch_dim, beam_size) + lprobs = self.replicate_first_beam(lprobs, eos_mask_batch_dim, beam_size) + return lprobs, tokens, scores + + def replicate_first_beam(self, tensor, mask, beam_size: int): + tensor = tensor.view(-1, beam_size, tensor.size(-1)) + tensor[mask] = tensor[mask][:, :1, :] + return tensor.view(-1, tensor.size(-1)) + + def finalize_hypos( + self, + step: int, + bbsz_idx, + eos_scores, + tokens, + scores, + finalized: List[List[Dict[str, Tensor]]], + finished: List[bool], + beam_size: int, + attn: Optional[Tensor], + src_lengths, + max_len: int, + ): + """Finalize hypothesis, store finalized information in `finalized`, and change `finished` accordingly. + A sentence is finalized when {beam_size} finished items have been collected for it. + + Returns number of sentences (not beam items) being finalized. + These will be removed from the batch and not processed further. + Args: + bbsz_idx (Tensor): + """ + assert bbsz_idx.numel() == eos_scores.numel() + + # clone relevant token and attention tensors. + # tokens is (batch * beam, max_len). So the index_select + # gets the newly EOS rows, then selects cols 1..{step + 2} + tokens_clone = tokens.index_select(0, bbsz_idx)[ + :, 1 : step + 2 + ] # skip the first index, which is EOS + + tokens_clone[:, step] = self.eos + attn_clone = ( + attn.index_select(0, bbsz_idx)[:, :, 1 : step + 2] + if attn is not None + else None + ) + + # compute scores per token position + pos_scores = scores.index_select(0, bbsz_idx)[:, : step + 1] + pos_scores[:, step] = eos_scores + # convert from cumulative to per-position scores + pos_scores[:, 1:] = pos_scores[:, 1:] - pos_scores[:, :-1] + + # normalize sentence-level scores + if self.normalize_scores: + eos_scores /= (step + 1) ** self.len_penalty + + # cum_unfin records which sentences in the batch are finished. + # It helps match indexing between (a) the original sentences + # in the batch and (b) the current, possibly-reduced set of + # sentences. + cum_unfin: List[int] = [] + prev = 0 + for f in finished: + if f: + prev += 1 + else: + cum_unfin.append(prev) + cum_fin_tensor = torch.tensor(cum_unfin, dtype=torch.int).to(bbsz_idx) + + unfin_idx = bbsz_idx // beam_size + sent = unfin_idx + torch.index_select(cum_fin_tensor, 0, unfin_idx) + + # Create a set of "{sent}{unfin_idx}", where + # "unfin_idx" is the index in the current (possibly reduced) + # list of sentences, and "sent" is the index in the original, + # unreduced batch + # For every finished beam item + # sentence index in the current (possibly reduced) batch + seen = (sent << 32) + unfin_idx + unique_seen: List[int] = torch.unique(seen).tolist() + + if self.match_source_len: + condition = step > torch.index_select(src_lengths, 0, unfin_idx) + eos_scores = torch.where(condition, torch.tensor(-math.inf), eos_scores) + sent_list: List[int] = sent.tolist() + for i in range(bbsz_idx.size()[0]): + # An input sentence (among those in a batch) is finished when + # beam_size hypotheses have been collected for it + if len(finalized[sent_list[i]]) < beam_size: + if attn_clone is not None: + # remove padding tokens from attn scores + hypo_attn = attn_clone[i] + else: + hypo_attn = torch.empty(0) + + finalized[sent_list[i]].append( + { + "tokens": tokens_clone[i], + "score": eos_scores[i], + "attention": hypo_attn, # src_len x tgt_len + "alignment": torch.empty(0), + "positional_scores": pos_scores[i], + } + ) + + newly_finished: List[int] = [] + for unique_s in unique_seen: + # check termination conditions for this sentence + unique_sent: int = unique_s >> 32 + unique_unfin_idx: int = unique_s - (unique_sent << 32) + + if not finished[unique_sent] and self.is_finished( + step, unique_unfin_idx, max_len, len(finalized[unique_sent]), beam_size + ): + finished[unique_sent] = True + newly_finished.append(unique_unfin_idx) + + return newly_finished + + def is_finished( + self, + step: int, + unfin_idx: int, + max_len: int, + finalized_sent_len: int, + beam_size: int, + ): + """ + Check whether decoding for a sentence is finished, which + occurs when the list of finalized sentences has reached the + beam size, or when we reach the maximum length. + """ + assert finalized_sent_len <= beam_size + if finalized_sent_len == beam_size or step == max_len: + return True + return False + + +class EnsembleModel(nn.Module): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__() + self.models_size = len(models) + # method '__len__' is not supported in ModuleList for torch script + self.single_model = models[0] + self.models = nn.ModuleList(models) + + self.has_incremental: bool = False + if all( + hasattr(m, "decoder") and isinstance(m.decoder, FairseqIncrementalDecoder) + for m in models + ): + self.has_incremental = True + + def forward(self): + pass + + def has_encoder(self): + return hasattr(self.single_model, "encoder") + + def has_incremental_states(self): + return self.has_incremental + + def max_decoder_positions(self): + return min([m.max_decoder_positions() for m in self.models if hasattr(m, "max_decoder_positions")] + [sys.maxsize]) + + @torch.jit.export + def forward_encoder(self, net_input: Dict[str, Tensor]): + if not self.has_encoder(): + return None + return [model.encoder.forward_torchscript(net_input) for model in self.models] + + @torch.jit.export + def forward_decoder( + self, + tokens, + encoder_outs: List[Dict[str, List[Tensor]]], + incremental_states: List[Dict[str, Dict[str, Optional[Tensor]]]], + temperature: float = 1.0, + ): + log_probs = [] + avg_attn: Optional[Tensor] = None + encoder_out: Optional[Dict[str, List[Tensor]]] = None + for i, model in enumerate(self.models): + if self.has_encoder(): + encoder_out = encoder_outs[i] + # decode each model + if self.has_incremental_states(): + decoder_out = model.decoder.forward( + tokens, + encoder_out=encoder_out, + incremental_state=incremental_states[i], + ) + else: + if hasattr(model, "decoder"): + decoder_out = model.decoder.forward(tokens, encoder_out=encoder_out) + else: + decoder_out = model.forward(tokens) + + attn: Optional[Tensor] = None + decoder_len = len(decoder_out) + if decoder_len > 1 and decoder_out[1] is not None: + if isinstance(decoder_out[1], Tensor): + attn = decoder_out[1] + else: + attn_holder = decoder_out[1]["attn"] + if isinstance(attn_holder, Tensor): + attn = attn_holder + elif attn_holder is not None: + attn = attn_holder[0] + if attn is not None: + attn = attn[:, -1, :] + + decoder_out_tuple = ( + decoder_out[0][:, -1:, :].div_(temperature), + None if decoder_len <= 1 else decoder_out[1], + ) + probs = model.get_normalized_probs( + decoder_out_tuple, log_probs=True, sample=None + ) + probs = probs[:, -1, :] + if self.models_size == 1: + return probs, attn + + log_probs.append(probs) + if attn is not None: + if avg_attn is None: + avg_attn = attn + else: + avg_attn.add_(attn) + + avg_probs = torch.logsumexp(torch.stack(log_probs, dim=0), dim=0) - math.log( + self.models_size + ) + + if avg_attn is not None: + avg_attn.div_(self.models_size) + return avg_probs, avg_attn + + @torch.jit.export + def reorder_encoder_out( + self, encoder_outs: Optional[List[Dict[str, List[Tensor]]]], new_order + ): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + new_outs: List[Dict[str, List[Tensor]]] = [] + if not self.has_encoder(): + return new_outs + for i, model in enumerate(self.models): + assert encoder_outs is not None + new_outs.append( + model.encoder.reorder_encoder_out(encoder_outs[i], new_order) + ) + return new_outs + + @torch.jit.export + def reorder_incremental_state( + self, + incremental_states: List[Dict[str, Dict[str, Optional[Tensor]]]], + new_order, + ): + if not self.has_incremental_states(): + return + for i, model in enumerate(self.models): + model.decoder.reorder_incremental_state_scripting( + incremental_states[i], new_order + ) + + +class SequenceGeneratorWithAlignment(SequenceGenerator): + def __init__( + self, models, tgt_dict, left_pad_target=False, print_alignment="hard", **kwargs + ): + """Generates translations of a given source sentence. + + Produces alignments following "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + left_pad_target (bool, optional): Whether or not the + hypothesis should be left padded or not when they are + teacher forced for generating alignments. + """ + super().__init__(EnsembleModelWithAlignment(models), tgt_dict, **kwargs) + self.left_pad_target = left_pad_target + + if print_alignment == "hard": + self.extract_alignment = utils.extract_hard_alignment + elif print_alignment == "soft": + self.extract_alignment = utils.extract_soft_alignment + + @torch.no_grad() + def generate(self, models, sample, **kwargs): + finalized = super()._generate(sample, **kwargs) + + src_tokens = sample["net_input"]["src_tokens"] + bsz = src_tokens.shape[0] + beam_size = self.beam_size + ( + src_tokens, + src_lengths, + prev_output_tokens, + tgt_tokens, + ) = self._prepare_batch_for_alignment(sample, finalized) + if any(getattr(m, "full_context_alignment", False) for m in self.model.models): + attn = self.model.forward_align(src_tokens, src_lengths, prev_output_tokens) + else: + attn = [ + finalized[i // beam_size][i % beam_size]["attention"].transpose(1, 0) + for i in range(bsz * beam_size) + ] + + if src_tokens.device != "cpu": + src_tokens = src_tokens.to("cpu") + tgt_tokens = tgt_tokens.to("cpu") + attn = [i.to("cpu") for i in attn] + + # Process the attn matrix to extract hard alignments. + for i in range(bsz * beam_size): + alignment = self.extract_alignment( + attn[i], src_tokens[i], tgt_tokens[i], self.pad, self.eos + ) + finalized[i // beam_size][i % beam_size]["alignment"] = alignment + return finalized + + def _prepare_batch_for_alignment(self, sample, hypothesis): + src_tokens = sample["net_input"]["src_tokens"] + bsz = src_tokens.shape[0] + src_tokens = ( + src_tokens[:, None, :] + .expand(-1, self.beam_size, -1) + .contiguous() + .view(bsz * self.beam_size, -1) + ) + src_lengths = sample["net_input"]["src_lengths"] + src_lengths = ( + src_lengths[:, None] + .expand(-1, self.beam_size) + .contiguous() + .view(bsz * self.beam_size) + ) + prev_output_tokens = data_utils.collate_tokens( + [beam["tokens"] for example in hypothesis for beam in example], + self.pad, + self.eos, + self.left_pad_target, + move_eos_to_beginning=True, + ) + tgt_tokens = data_utils.collate_tokens( + [beam["tokens"] for example in hypothesis for beam in example], + self.pad, + self.eos, + self.left_pad_target, + move_eos_to_beginning=False, + ) + return src_tokens, src_lengths, prev_output_tokens, tgt_tokens + + +class EnsembleModelWithAlignment(EnsembleModel): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__(models) + + def forward_align(self, src_tokens, src_lengths, prev_output_tokens): + avg_attn = None + for model in self.models: + decoder_out = model(src_tokens, src_lengths, prev_output_tokens) + attn = decoder_out[1]["attn"][0] + if avg_attn is None: + avg_attn = attn + else: + avg_attn.add_(attn) + if len(self.models) > 1: + avg_attn.div_(len(self.models)) + return avg_attn diff --git a/fairseq/fairseq/sequence_scorer.py b/fairseq/fairseq/sequence_scorer.py new file mode 100644 index 0000000000000000000000000000000000000000..411d4df4445ef8dd3f1907ad56f9de6943d1fed8 --- /dev/null +++ b/fairseq/fairseq/sequence_scorer.py @@ -0,0 +1,153 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + +import torch +from fairseq import utils + + +class SequenceScorer(object): + """Scores the target for a given source sentence.""" + + def __init__( + self, + tgt_dict, + softmax_batch=None, + compute_alignment=False, + eos=None, + symbols_to_strip_from_output=None, + ): + self.pad = tgt_dict.pad() + self.eos = tgt_dict.eos() if eos is None else eos + self.softmax_batch = softmax_batch or sys.maxsize + assert self.softmax_batch > 0 + self.compute_alignment = compute_alignment + self.symbols_to_strip_from_output = ( + symbols_to_strip_from_output.union({self.eos}) + if symbols_to_strip_from_output is not None + else {self.eos} + ) + + @torch.no_grad() + def generate(self, models, sample, **kwargs): + """Score a batch of translations.""" + net_input = sample["net_input"] + + def batch_for_softmax(dec_out, target): + # assumes decoder_out[0] is the only thing needed (may not be correct for future models!) + first, rest = dec_out[0], dec_out[1:] + bsz, tsz, dim = first.shape + if bsz * tsz < self.softmax_batch: + yield dec_out, target, True + else: + flat = first.contiguous().view(1, -1, dim) + flat_tgt = target.contiguous().view(flat.shape[:-1]) + s = 0 + while s < flat.size(1): + e = s + self.softmax_batch + yield (flat[:, s:e],) + rest, flat_tgt[:, s:e], False + s = e + + def gather_target_probs(probs, target): + probs = probs.gather( + dim=2, + index=target.unsqueeze(-1), + ) + return probs + + orig_target = sample["target"] + + # compute scores for each model in the ensemble + avg_probs = None + avg_attn = None + for model in models: + model.eval() + decoder_out = model(**net_input) + attn = decoder_out[1] if len(decoder_out) > 1 else None + if type(attn) is dict: + attn = attn.get("attn", None) + + batched = batch_for_softmax(decoder_out, orig_target) + probs, idx = None, 0 + for bd, tgt, is_single in batched: + sample["target"] = tgt + curr_prob = model.get_normalized_probs( + bd, log_probs=len(models) == 1, sample=sample + ).data + if is_single: + probs = gather_target_probs(curr_prob, orig_target) + else: + if probs is None: + probs = curr_prob.new(orig_target.numel()) + step = curr_prob.size(0) * curr_prob.size(1) + end = step + idx + tgt_probs = gather_target_probs( + curr_prob.view(tgt.shape + (curr_prob.size(-1),)), tgt + ) + probs[idx:end] = tgt_probs.view(-1) + idx = end + sample["target"] = orig_target + + probs = probs.view(sample["target"].shape) + + if avg_probs is None: + avg_probs = probs + else: + avg_probs.add_(probs) + if attn is not None: + if torch.is_tensor(attn): + attn = attn.data + else: + attn = attn[0] + if avg_attn is None: + avg_attn = attn + else: + avg_attn.add_(attn) + if len(models) > 1: + avg_probs.div_(len(models)) + avg_probs.log_() + if avg_attn is not None: + avg_attn.div_(len(models)) + + bsz = avg_probs.size(0) + hypos = [] + start_idxs = sample["start_indices"] if "start_indices" in sample else [0] * bsz + for i in range(bsz): + # remove padding from ref + ref = ( + utils.strip_pad(sample["target"][i, start_idxs[i] :], self.pad) + if sample["target"] is not None + else None + ) + tgt_len = ref.numel() + avg_probs_i = avg_probs[i][start_idxs[i] : start_idxs[i] + tgt_len] + score_i = avg_probs_i.sum() / tgt_len + if avg_attn is not None: + avg_attn_i = avg_attn[i] + if self.compute_alignment: + alignment = utils.extract_hard_alignment( + avg_attn_i, + sample["net_input"]["src_tokens"][i], + sample["target"][i], + self.pad, + self.eos, + ) + else: + alignment = None + else: + avg_attn_i = alignment = None + hypos.append( + [ + { + "tokens": ref, + "score": score_i, + "attention": avg_attn_i, + "alignment": alignment, + "positional_scores": avg_probs_i, + } + ] + ) + return hypos diff --git a/fairseq/fairseq/speech_generator.py b/fairseq/fairseq/speech_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..8086e34d2b56fa808d0905b1a00e87e6736fcf04 --- /dev/null +++ b/fairseq/fairseq/speech_generator.py @@ -0,0 +1,219 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +import numpy as np + +from fairseq.data.audio.speech_to_text_dataset import S2TDataConfig + + +class SpeechGenerator(object): + def __init__(self, model, vocoder, data_cfg: S2TDataConfig): + self.model = model + self.vocoder = vocoder + stats_npz_path = data_cfg.global_cmvn_stats_npz + self.gcmvn_stats = None + if stats_npz_path is not None: + self.gcmvn_stats = np.load(stats_npz_path) + + def gcmvn_denormalize(self, x): + # x: B x T x C + if self.gcmvn_stats is None: + return x + mean = torch.from_numpy(self.gcmvn_stats["mean"]).to(x) + std = torch.from_numpy(self.gcmvn_stats["std"]).to(x) + assert len(x.shape) == 3 and mean.shape[0] == std.shape[0] == x.shape[2] + x = x * std.view(1, 1, -1).expand_as(x) + return x + mean.view(1, 1, -1).expand_as(x) + + def get_waveform(self, feat): + # T x C -> T + return None if self.vocoder is None else self.vocoder(feat).squeeze(0) + + +class AutoRegressiveSpeechGenerator(SpeechGenerator): + def __init__( + self, model, vocoder, data_cfg, max_iter: int = 6000, + eos_prob_threshold: float = 0.5, + ): + super().__init__(model, vocoder, data_cfg) + self.max_iter = max_iter + self.eos_prob_threshold = eos_prob_threshold + + @torch.no_grad() + def generate(self, model, sample, has_targ=False, **kwargs): + model.eval() + + src_tokens = sample["net_input"]["src_tokens"] + src_lengths = sample["net_input"]["src_lengths"] + bsz, src_len = src_tokens.size() + n_frames_per_step = model.decoder.n_frames_per_step + out_dim = model.decoder.out_dim + raw_dim = out_dim // n_frames_per_step + + # initialize + encoder_out = model.forward_encoder(src_tokens, src_lengths, + speaker=sample["speaker"]) + incremental_state = {} + feat, attn, eos_prob = [], [], [] + finished = src_tokens.new_zeros((bsz,)).bool() + out_lens = src_lengths.new_zeros((bsz,)).long().fill_(self.max_iter) + + prev_feat_out = encoder_out["encoder_out"][0].new_zeros(bsz, 1, out_dim) + for step in range(self.max_iter): + cur_out_lens = out_lens.clone() + cur_out_lens.masked_fill_(cur_out_lens.eq(self.max_iter), step + 1) + _, cur_eos_out, cur_extra = model.forward_decoder( + prev_feat_out, encoder_out=encoder_out, + incremental_state=incremental_state, + target_lengths=cur_out_lens, speaker=sample["speaker"], **kwargs + ) + cur_eos_prob = torch.sigmoid(cur_eos_out).squeeze(2) + feat.append(cur_extra['feature_out']) + attn.append(cur_extra['attn']) + eos_prob.append(cur_eos_prob) + + cur_finished = (cur_eos_prob.squeeze(1) > self.eos_prob_threshold) + out_lens.masked_fill_((~finished) & cur_finished, step + 1) + finished = finished | cur_finished + if finished.sum().item() == bsz: + break + prev_feat_out = cur_extra['feature_out'] + + feat = torch.cat(feat, dim=1) + feat = model.decoder.postnet(feat) + feat + eos_prob = torch.cat(eos_prob, dim=1) + attn = torch.cat(attn, dim=2) + alignment = attn.max(dim=1)[1] + + feat = feat.reshape(bsz, -1, raw_dim) + feat = self.gcmvn_denormalize(feat) + + eos_prob = eos_prob.repeat_interleave(n_frames_per_step, dim=1) + attn = attn.repeat_interleave(n_frames_per_step, dim=2) + alignment = alignment.repeat_interleave(n_frames_per_step, dim=1) + out_lens = out_lens * n_frames_per_step + + finalized = [ + { + 'feature': feat[b, :out_len], + 'eos_prob': eos_prob[b, :out_len], + 'attn': attn[b, :, :out_len], + 'alignment': alignment[b, :out_len], + 'waveform': self.get_waveform(feat[b, :out_len]), + } + for b, out_len in zip(range(bsz), out_lens) + ] + + if has_targ: + assert sample["target"].size(-1) == out_dim + tgt_feats = sample["target"].view(bsz, -1, raw_dim) + tgt_feats = self.gcmvn_denormalize(tgt_feats) + tgt_lens = sample["target_lengths"] * n_frames_per_step + for b, (f, l) in enumerate(zip(tgt_feats, tgt_lens)): + finalized[b]["targ_feature"] = f[:l] + finalized[b]["targ_waveform"] = self.get_waveform(f[:l]) + return finalized + + +class NonAutoregressiveSpeechGenerator(SpeechGenerator): + @torch.no_grad() + def generate(self, model, sample, has_targ=False, **kwargs): + model.eval() + + bsz, max_src_len = sample["net_input"]["src_tokens"].size() + n_frames_per_step = model.encoder.n_frames_per_step + out_dim = model.encoder.out_dim + raw_dim = out_dim // n_frames_per_step + + feat, out_lens, log_dur_out, _, _ = model( + src_tokens=sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + prev_output_tokens=sample["net_input"]["prev_output_tokens"], + incremental_state=None, + target_lengths=sample["target_lengths"], + speaker=sample["speaker"] + ) + + feat = feat.view(bsz, -1, raw_dim) + feat = self.gcmvn_denormalize(feat) + + dur_out = torch.clamp( + torch.round(torch.exp(log_dur_out) - 1).long(), min=0 + ) + + def get_dur_plot_data(d): + r = [] + for i, dd in enumerate(d): + r += [i + 1] * dd.item() + return r + + out_lens = out_lens * n_frames_per_step + finalized = [ + { + 'feature': feat[b, :l] if l > 0 else feat.new_zeros([1, raw_dim]), + 'waveform': self.get_waveform( + feat[b, :l] if l > 0 else feat.new_zeros([1, raw_dim]) + ), + 'attn': feat.new_tensor(get_dur_plot_data(dur_out[b])), + } + for b, l in zip(range(bsz), out_lens) + ] + + if has_targ: + tgt_feats = sample["target"].view(bsz, -1, raw_dim) + tgt_feats = self.gcmvn_denormalize(tgt_feats) + tgt_lens = sample["target_lengths"] * n_frames_per_step + for b, (f, l) in enumerate(zip(tgt_feats, tgt_lens)): + finalized[b]["targ_feature"] = f[:l] + finalized[b]["targ_waveform"] = self.get_waveform(f[:l]) + return finalized + + +class TeacherForcingAutoRegressiveSpeechGenerator(AutoRegressiveSpeechGenerator): + @torch.no_grad() + def generate(self, model, sample, has_targ=False, **kwargs): + model.eval() + + src_tokens = sample["net_input"]["src_tokens"] + src_lens = sample["net_input"]["src_lengths"] + prev_out_tokens = sample["net_input"]["prev_output_tokens"] + tgt_lens = sample["target_lengths"] + n_frames_per_step = model.decoder.n_frames_per_step + raw_dim = model.decoder.out_dim // n_frames_per_step + bsz = src_tokens.shape[0] + + feat, eos_prob, extra = model( + src_tokens, src_lens, prev_out_tokens, incremental_state=None, + target_lengths=tgt_lens, speaker=sample["speaker"] + ) + + attn = extra["attn"] # B x T_s x T_t + alignment = attn.max(dim=1)[1] + feat = feat.reshape(bsz, -1, raw_dim) + feat = self.gcmvn_denormalize(feat) + eos_prob = eos_prob.repeat_interleave(n_frames_per_step, dim=1) + attn = attn.repeat_interleave(n_frames_per_step, dim=2) + alignment = alignment.repeat_interleave(n_frames_per_step, dim=1) + tgt_lens = sample["target_lengths"] * n_frames_per_step + + finalized = [ + { + 'feature': feat[b, :tgt_len], + 'eos_prob': eos_prob[b, :tgt_len], + 'attn': attn[b, :, :tgt_len], + 'alignment': alignment[b, :tgt_len], + 'waveform': self.get_waveform(feat[b, :tgt_len]), + } + for b, tgt_len in zip(range(bsz), tgt_lens) + ] + + if has_targ: + tgt_feats = sample["target"].view(bsz, -1, raw_dim) + tgt_feats = self.gcmvn_denormalize(tgt_feats) + for b, (f, l) in enumerate(zip(tgt_feats, tgt_lens)): + finalized[b]["targ_feature"] = f[:l] + finalized[b]["targ_waveform"] = self.get_waveform(f[:l]) + return finalized diff --git a/fairseq/fairseq/tasks/__init__.py b/fairseq/fairseq/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9a46b012c573a76e00e489307720fc3fa462c296 --- /dev/null +++ b/fairseq/fairseq/tasks/__init__.py @@ -0,0 +1,136 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import argparse +import importlib +import os + +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import merge_with_parent +from hydra.core.config_store import ConfigStore + +from .fairseq_task import FairseqTask, LegacyFairseqTask # noqa + + +# register dataclass +TASK_DATACLASS_REGISTRY = {} +TASK_REGISTRY = {} +TASK_CLASS_NAMES = set() + + +def setup_task(cfg: FairseqDataclass, **kwargs): + task = None + task_name = getattr(cfg, "task", None) + + if isinstance(task_name, str): + # legacy tasks + task = TASK_REGISTRY[task_name] + if task_name in TASK_DATACLASS_REGISTRY: + dc = TASK_DATACLASS_REGISTRY[task_name] + cfg = dc.from_namespace(cfg) + else: + task_name = getattr(cfg, "_name", None) + + if task_name and task_name in TASK_DATACLASS_REGISTRY: + dc = TASK_DATACLASS_REGISTRY[task_name] + cfg = merge_with_parent(dc(), cfg) + task = TASK_REGISTRY[task_name] + + assert ( + task is not None + ), f"Could not infer task type from {cfg}. Available argparse tasks: {TASK_REGISTRY.keys()}. Available hydra tasks: {TASK_DATACLASS_REGISTRY.keys()}" + + return task.setup_task(cfg, **kwargs) + + +def register_task(name, dataclass=None): + """ + New tasks can be added to fairseq with the + :func:`~fairseq.tasks.register_task` function decorator. + + For example:: + + @register_task('classification') + class ClassificationTask(FairseqTask): + (...) + + .. note:: + + All Tasks must implement the :class:`~fairseq.tasks.FairseqTask` + interface. + + Args: + name (str): the name of the task + """ + + def register_task_cls(cls): + if name in TASK_REGISTRY: + raise ValueError("Cannot register duplicate task ({})".format(name)) + if not issubclass(cls, FairseqTask): + raise ValueError( + "Task ({}: {}) must extend FairseqTask".format(name, cls.__name__) + ) + if cls.__name__ in TASK_CLASS_NAMES: + raise ValueError( + "Cannot register task with duplicate class name ({})".format( + cls.__name__ + ) + ) + TASK_REGISTRY[name] = cls + TASK_CLASS_NAMES.add(cls.__name__) + + if dataclass is not None and not issubclass(dataclass, FairseqDataclass): + raise ValueError( + "Dataclass {} must extend FairseqDataclass".format(dataclass) + ) + + cls.__dataclass = dataclass + if dataclass is not None: + TASK_DATACLASS_REGISTRY[name] = dataclass + + cs = ConfigStore.instance() + node = dataclass() + node._name = name + cs.store(name=name, group="task", node=node, provider="fairseq") + + return cls + + return register_task_cls + + +def get_task(name): + return TASK_REGISTRY[name] + + +def import_tasks(tasks_dir, namespace): + for file in os.listdir(tasks_dir): + path = os.path.join(tasks_dir, file) + if ( + not file.startswith("_") + and not file.startswith(".") + and (file.endswith(".py") or os.path.isdir(path)) + ): + task_name = file[: file.find(".py")] if file.endswith(".py") else file + importlib.import_module(namespace + "." + task_name) + + # expose `task_parser` for sphinx + if task_name in TASK_REGISTRY: + parser = argparse.ArgumentParser(add_help=False) + group_task = parser.add_argument_group("Task name") + # fmt: off + group_task.add_argument('--task', metavar=task_name, + help='Enable this task with: ``--task=' + task_name + '``') + # fmt: on + group_args = parser.add_argument_group( + "Additional command-line arguments" + ) + TASK_REGISTRY[task_name].add_args(group_args) + globals()[task_name + "_parser"] = parser + + +# automatically import any Python files in the tasks/ directory +tasks_dir = os.path.dirname(__file__) +import_tasks(tasks_dir, "fairseq.tasks") diff --git a/fairseq/fairseq/tasks/audio_finetuning.py b/fairseq/fairseq/tasks/audio_finetuning.py new file mode 100644 index 0000000000000000000000000000000000000000..4ef87c604f00581f03075e9ebe10a43dd51d6e45 --- /dev/null +++ b/fairseq/fairseq/tasks/audio_finetuning.py @@ -0,0 +1,346 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import logging +import os +import torch +import json + +from argparse import Namespace +from dataclasses import dataclass, field +from typing import Optional, Any + +from fairseq.data import AddTargetDataset, Dictionary, encoders +from fairseq.tasks.audio_pretraining import AudioPretrainingTask, AudioPretrainingConfig +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.configs import GenerationConfig +from fairseq.data.text_compressor import TextCompressor, TextCompressionLevel + +from . import register_task +from .. import utils +from ..logging import metrics + + +logger = logging.getLogger(__name__) + + +class LabelEncoder(object): + def __init__(self, dictionary): + self.dictionary = dictionary + + def __call__(self, label): + return self.dictionary.encode_line( + label, append_eos=False, add_if_not_exist=False + ) + + +def label_len_fn(label): + return len(label.split(" ")) + + +@dataclass +class AudioFinetuningConfig(AudioPretrainingConfig): + # Options for reporting WER metrics during validation. Only applicable to + # Seq2Seq models during fine-tuning + eval_wer: bool = field( + default=False, metadata={"help": "compute WER for Seq2Seq models"} + ) + eval_wer_config: GenerationConfig = field( + default_factory=lambda: GenerationConfig(), + metadata={"help": "beam search config for evaluating wer during training"}, + ) + eval_wer_tokenizer: Any = field( + default=None, + metadata={"help": "tokenizer config for evaluating wer during training"}, + ) + eval_wer_post_process: str = field( + default="letter", + metadata={ + "help": "remove BPE tokens before scoring (can be sentencepiece, letter, and more)" + }, + ) + eval_bleu: bool = field( + default=False, metadata={"help": "evaluation with BLEU scores"} + ) + eval_bleu_detok: Optional[str] = field( + default=None, metadata={ + "help": "detokenize before computing BLEU (e.g., 'moses'); " + "required if using --eval-bleu; use 'space' to disable " + "detokenization; see fairseq.data.encoders for other options" + } + ) + eval_bleu_detok_args: str = field( + default="{}", + metadata={"help": "args for building the tokenizer, if needed"} + ) + eval_tokenized_bleu: bool = field( + default=False, + metadata={"help": "compute tokenized BLEU instead of sacrebleu"} + ) + eval_bleu_remove_bpe: Optional[str] = field( + default=None, metadata={"help": "remove BPE before computing BLEU"} + ) + eval_bleu_args: str = field( + default="{}", + metadata={"help": "generation args for BLUE scoring, e.g., " + "'{\"beam\": 4, \"lenpen\": 0.6}'"} + ) + eval_bleu_print_samples: bool = field( + default=False, + metadata={"help": "print sample generations during validation"} + ) + autoregressive: bool = field( + default=False, + metadata={ + "help": "required for autoregressive decoders (like seq2seq models); " + "adds 'prev_output_tokens' to input and appends eos to target" + }, + ) + + +@register_task("audio_finetuning", dataclass=AudioFinetuningConfig) +class AudioFinetuningTask(AudioPretrainingTask): + """ """ + + cfg: AudioFinetuningConfig + + def __init__( + self, + cfg: AudioFinetuningConfig, + ): + super().__init__(cfg) + self.blank_symbol = "<s>" + + self.state.add_factory("target_dictionary", self.load_target_dictionary) + + def load_target_dictionary(self): + if self.cfg.labels: + dict_path = os.path.join(self.cfg.data, f"dict.{self.cfg.labels}.txt") + return Dictionary.load(dict_path) + return None + + def load_dataset(self, split: str, task_cfg: AudioFinetuningConfig = None, **kwargs): + super().load_dataset(split, task_cfg, **kwargs) + + task_cfg = task_cfg or self.cfg + assert task_cfg.labels is not None + text_compression_level = getattr( + TextCompressionLevel, str(self.cfg.text_compression_level) + ) + data_path = self.cfg.data + label_path = os.path.join(data_path, f"{split}.{task_cfg.labels}") + skipped_indices = getattr(self.datasets[split], "skipped_indices", set()) + text_compressor = TextCompressor(level=text_compression_level) + with open(label_path, "r") as f: + labels = [ + text_compressor.compress(l) + for i, l in enumerate(f) if i not in skipped_indices + ] + + assert len(labels) == len(self.datasets[split]), ( + f"labels length ({len(labels)}) and dataset length " + f"({len(self.datasets[split])}) do not match" + ) + + process_label = LabelEncoder(self.target_dictionary) + + self.datasets[split] = AddTargetDataset( + self.datasets[split], + labels, + pad=self.target_dictionary.pad(), + eos=self.target_dictionary.eos(), + batch_targets=True, + process_label=process_label, + label_len_fn=label_len_fn, + add_to_input=task_cfg.get("autoregressive", False), + text_compression_level=text_compression_level + ) + + @property + def target_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self.state.target_dictionary + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + if self.cfg.eval_wer and self.cfg.autoregressive: + metrics = self._inference_with_wer(self.sequence_generator, sample, model) + logging_output["_num_char_errors"] = metrics["num_char_errors"] + logging_output["_num_chars"] = metrics["num_chars"] + logging_output["_num_word_errors"] = metrics["num_word_errors"] + logging_output["_num_words"] = metrics["num_words"] + if self.cfg.eval_bleu and self.cfg.autoregressive: + metrics = self._inference_with_bleu(self.sequence_generator, sample, model) + logging_output['_bleu_sys_len'] = metrics.sys_len + logging_output['_bleu_ref_len'] = metrics.ref_len + # we split counts into separate entries so that they can be + # summed efficiently across workers using fast-stat-sync + assert len(metrics.counts) == 4 + for i in range(4): + logging_output[f"_bleu_counts_{i}"] = metrics.counts[i] + logging_output[f"_bleu_totals_{i}"] = metrics.totals[i] + return loss, sample_size, logging_output + + def build_model(self, model_cfg: FairseqDataclass): + model = super().build_model(model_cfg) + + if self.cfg.eval_wer and self.cfg.autoregressive: + self.sequence_generator = self.build_generator( + [model], + self.cfg.eval_wer_config, + ) + if self.cfg.eval_wer_tokenizer: + self.tokenizer = encoders.build_tokenizer(self.cfg.eval_wer_tokenizer) + else: + self.tokenizer = None + if self.cfg.eval_bleu and self.cfg.autoregressive: + assert self.cfg.eval_bleu_detok is not None, ( + '--eval-bleu-detok is required if using --eval-bleu; ' + 'try --eval-bleu-detok=moses (or --eval-bleu-detok=space ' + 'to disable detokenization, e.g., when using sentencepiece)' + ) + detok_args = json.loads(self.cfg.eval_bleu_detok_args) + self.tokenizer = encoders.build_tokenizer( + Namespace(tokenizer=self.cfg.eval_bleu_detok, **detok_args) + ) + gen_args = json.loads(self.cfg.eval_bleu_args) + gen_args = Namespace(**gen_args) + self.sequence_generator = self.build_generator([model], gen_args) + + return model + + def _inference_with_wer(self, generator, sample, model): + import editdistance + + def decode(toks): + s = self.target_dictionary.string( + toks.int().cpu(), + self.cfg.eval_wer_post_process, + escape_unk=True, + ) + if self.tokenizer: + s = self.tokenizer.decode(s) + return s + + num_word_errors, num_char_errors = 0, 0 + num_chars, num_words = 0, 0 + gen_out = self.inference_step(generator, [model], sample, None) + for i in range(len(gen_out)): + hyp = decode(gen_out[i][0]["tokens"]) + ref = decode( + utils.strip_pad(sample["target"][i], self.target_dictionary.pad()), + ) + num_char_errors += editdistance.eval(hyp, ref) + num_chars += len(ref) + hyp_words = hyp.split() + ref_words = ref.split() + num_word_errors += editdistance.eval(hyp_words, ref_words) + num_words += len(ref_words) + + return { + "num_char_errors": num_char_errors, + "num_chars": num_chars, + "num_word_errors": num_word_errors, + "num_words": num_words, + } + + def _inference_with_bleu(self, generator, sample, model): + import sacrebleu + + def decode(toks, is_ref): + s = self.target_dictionary.string( + toks.int().cpu(), + self.cfg.eval_bleu_remove_bpe, + # The default unknown string in fairseq is `<unk>`, but + # this is tokenized by sacrebleu as `< unk >`, inflating + # BLEU scores. Instead, we use a somewhat more verbose + # alternative that is unlikely to appear in the real + # reference, but doesn't get split into multiple tokens. + unk_string=( + "UNKNOWNTOKENINREF" if is_ref else "UNKNOWNTOKENINHYP" + ), + ) + if self.tokenizer: + s = self.tokenizer.decode(s) + return s + + gen_out = self.inference_step(generator, [model], sample) + hyps, refs = [], [] + for i in range(len(gen_out)): + hyps.append(decode(gen_out[i][0]['tokens'], is_ref=False)) + refs.append( + decode( + utils.strip_pad( + sample['target'][i], + self.target_dictionary.pad() + ), + is_ref=True, # don't count <unk> as matches to the hypo + ) + ) + if self.cfg.eval_bleu_print_samples: + logger.info('H-{} {}'.format(sample["id"][0], hyps[0])) + logger.info('T-{} {}'.format(sample["id"][0], refs[0])) + + eval_tokenization = 'none' if self.cfg.eval_tokenized_bleu else '13a' + return sacrebleu.corpus_bleu(hyps, [refs], tokenize=eval_tokenization) + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + if self.cfg.eval_wer: + zero = torch.scalar_tensor(0.0) + num_char_errors = sum( + log.get("_num_char_errors", zero) for log in logging_outputs + ) + num_chars = sum(log.get("_num_chars", zero) for log in logging_outputs) + num_word_errors = sum( + log.get("_num_word_errors", zero) for log in logging_outputs + ) + num_words = sum(log.get("_num_words", zero) for log in logging_outputs) + metrics.log_scalar("_num_char_errors", num_char_errors) + metrics.log_scalar("_num_chars", num_chars) + metrics.log_scalar("_num_word_errors", num_word_errors) + metrics.log_scalar("_num_words", num_words) + if num_chars > 0: + metrics.log_derived( + "uer", + lambda meters: meters["_num_char_errors"].sum + * 100.0 + / meters["_num_chars"].sum + if meters["_num_chars"].sum > 0 + else float("nan"), + ) + if num_words > 0: + metrics.log_derived( + "wer", + lambda meters: meters["_num_word_errors"].sum + * 100.0 + / meters["_num_words"].sum + if meters["_num_words"].sum > 0 + else float("nan"), + ) + if self.cfg.eval_bleu: + len_keys = ["_bleu_sys_len", "_bleu_ref_len"] + count_keys = [f"_bleu_counts_{i}" for i in range(4)] + total_keys = [f"_bleu_totals_{i}" for i in range(4)] + for k in len_keys + count_keys + total_keys: + metrics.log_scalar( + k, sum(log.get(k, 0) for log in logging_outputs) + ) + + import sacrebleu + metrics.log_derived( + 'bleu', + lambda meters: sacrebleu.compute_bleu( + correct=[meters[k].sum for k in count_keys], + total=[meters[k].sum for k in total_keys], + sys_len=meters['_bleu_sys_len'].sum, + ref_len=meters['_bleu_ref_len'].sum, + smooth_method="exp" + ).score + ) diff --git a/fairseq/fairseq/tasks/audio_pretraining.py b/fairseq/fairseq/tasks/audio_pretraining.py new file mode 100644 index 0000000000000000000000000000000000000000..cc310088db8852e80cd2e65d51f06f8f7cb592e3 --- /dev/null +++ b/fairseq/fairseq/tasks/audio_pretraining.py @@ -0,0 +1,206 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import logging +import os +import sys + +from argparse import Namespace +from dataclasses import dataclass, field +from typing import Optional +from omegaconf import MISSING, II, OmegaConf + +from fairseq.data import BinarizedAudioDataset, FileAudioDataset +from fairseq.dataclass import FairseqDataclass, ChoiceEnum +from fairseq.data.text_compressor import TextCompressionLevel + +from . import FairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@dataclass +class InferredW2vConfig: + # The following are needed to precompute mask and mask channel indices + # before model's forward. + mask_length: Optional[int] = II("model.mask_length") + mask_prob: Optional[float] = II("model.mask_prob") + mask_selection: Optional[str] = II("model.mask_selection") + mask_other: Optional[float] = II("model.mask_other") + no_mask_overlap: Optional[bool] = II("model.no_mask_overlap") + mask_min_space: Optional[int] = II("model.mask_min_space") + mask_channel_length: Optional[int] = II("model.mask_channel_length") + mask_channel_prob: Optional[float] = II("model.mask_channel_prob") + mask_channel_selection: Optional[str] = II("model.mask_channel_selection") + mask_channel_other: Optional[float] = II("model.mask_channel_other") + no_mask_channel_overlap: Optional[bool] = II("model.no_mask_channel_overlap") + mask_channel_min_space: Optional[int] = II("model.mask_channel_min_space") + + conv_feature_layers: Optional[str] = II("model.conv_feature_layers") + encoder_embed_dim: Optional[int] = II("model.encoder_embed_dim") + + +@dataclass +class AudioPretrainingConfig(FairseqDataclass): + data: str = field(default=MISSING, metadata={"help": "path to data directory"}) + labels: Optional[str] = field( + default=None, + metadata={ + "help": "extension of the label file to load, used for fine-tuning"}, + ) + binarized_dataset: bool = field( + default=False, + metadata={ + "help": "if true, loads binarized dataset (useful for very large datasets). " + "See examples/wav2vec/scripts/binarize_manifest.sh" + }, + ) + sample_rate: int = field( + default=16_000, + metadata={ + "help": "target sample rate. audio files will be up/down sampled to this rate" + }, + ) + normalize: bool = field( + default=False, + metadata={"help": "if set, normalizes input to have 0 mean and unit variance"}, + ) + enable_padding: bool = field( + default=False, metadata={"help": "pad shorter samples instead of cropping"} + ) + max_sample_size: Optional[int] = field( + default=None, metadata={"help": "max sample size to crop to for batching"} + ) + min_sample_size: Optional[int] = field( + default=None, metadata={"help": "min sample size to skip small examples"} + ) + num_batch_buckets: int = field( + default=0, + metadata={"help": "number of buckets"}, + ) + precompute_mask_indices: bool = field( + default=False, + metadata={ + "help": "flag to compute mask indices in data preparation.", + }, + ) + + inferred_w2v_config: Optional[InferredW2vConfig] = field( + default=None, + metadata={ + "help": "wav2vec 2.0 masking arguments used to pre-compute masks (required for TPU)", + }, + ) + + tpu: bool = II("common.tpu") + text_compression_level: ChoiceEnum([x.name for x in TextCompressionLevel]) = field( + default="none", + metadata={ + "help": "compression level for texts (e.g. audio filenames, " + "target texts): none/low/high (default: none). " + } + ) + + +@register_task("audio_pretraining", dataclass=AudioPretrainingConfig) +class AudioPretrainingTask(FairseqTask): + """ """ + + cfg: AudioPretrainingConfig + + @classmethod + def setup_task(cls, cfg: AudioPretrainingConfig, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + cfg (AudioPretrainingConfig): configuration of this task + """ + + return cls(cfg) + + def _get_mask_precompute_kwargs(self, cfg): + if self.cfg.precompute_mask_indices or self.cfg.tpu: + assert ( + cfg.inferred_w2v_config is not None + ), "inferred_w2v_config must be set" + return OmegaConf.to_container( + cfg.inferred_w2v_config, resolve=True, enum_to_str=True + ) + else: + return {} + + def load_dataset(self, split: str, task_cfg: FairseqDataclass = None, **kwargs): + data_path = self.cfg.data + task_cfg = task_cfg or self.cfg + + # upgrade old task + if isinstance(task_cfg, Namespace): + if not hasattr(task_cfg, "autoregressive"): + task_cfg.autoregressive = not task_cfg.criterion == "ctc" + + text_compression_level = getattr( + TextCompressionLevel, str(self.cfg.text_compression_level) + ) + if getattr(task_cfg, "binarized_dataset", False): + self.datasets[split] = BinarizedAudioDataset( + data_path, + split=split, + sample_rate=task_cfg.get("sample_rate", self.cfg.sample_rate), + max_sample_size=self.cfg.max_sample_size, + min_sample_size=self.cfg.min_sample_size, + pad=task_cfg.labels is not None or task_cfg.enable_padding, + normalize=task_cfg.normalize, + num_buckets=self.cfg.num_batch_buckets or int(self.cfg.tpu), + compute_mask_indices=(self.cfg.precompute_mask_indices or self.cfg.tpu), + **self._get_mask_precompute_kwargs(task_cfg), + ) + else: + manifest_path = os.path.join(data_path, "{}.tsv".format(split)) + + self.datasets[split] = FileAudioDataset( + manifest_path=manifest_path, + sample_rate=task_cfg.get("sample_rate", self.cfg.sample_rate), + max_sample_size=self.cfg.max_sample_size, + min_sample_size=self.cfg.min_sample_size, + pad=task_cfg.labels is not None or task_cfg.enable_padding, + normalize=task_cfg.normalize, + num_buckets=self.cfg.num_batch_buckets or int(self.cfg.tpu), + compute_mask_indices=(self.cfg.precompute_mask_indices or self.cfg.tpu), + text_compression_level=text_compression_level, + **self._get_mask_precompute_kwargs(task_cfg), + ) + + if self.cfg.tpu and task_cfg.inferred_w2v_config.mask_channel_prob == 0.0: + logger.info( + "Pretraining on TPUs may suffer convergence " + "issues when training with `mask_channel_prob` value of " + "0. You may want to set this to a low value close to 0." + ) + + @property + def source_dictionary(self): + return None + + @property + def target_dictionary(self): + return None + + def max_positions(self): + """Maximum input length supported by the encoder.""" + return sys.maxsize, sys.maxsize + + def build_model(self, model_cfg: FairseqDataclass): + model = super().build_model(model_cfg) + + actualized_cfg = getattr(model, "cfg", None) + if actualized_cfg is not None: + # if "w2v_args" in actualized_cfg: + if hasattr(actualized_cfg, "w2v_args"): + model_cfg.w2v_args = actualized_cfg.w2v_args + + return model diff --git a/fairseq/fairseq/tasks/cross_lingual_lm.py b/fairseq/fairseq/tasks/cross_lingual_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..8f8fe7e2de181e41bd0e6a2bf96948ee78de5ae8 --- /dev/null +++ b/fairseq/fairseq/tasks/cross_lingual_lm.py @@ -0,0 +1,191 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools +import logging +import os +from collections import OrderedDict + +import numpy as np +from fairseq import tokenizer, utils +from fairseq.data import ConcatDataset, Dictionary, TokenBlockDataset, data_utils +from fairseq.data.legacy.masked_lm_dataset import MaskedLMDataset +from fairseq.data.legacy.masked_lm_dictionary import MaskedLMDictionary +from fairseq.data.multi_corpus_sampled_dataset import MultiCorpusSampledDataset +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("cross_lingual_lm") +class CrossLingualLMTask(LegacyFairseqTask): + """ + Task for training cross-lingual language models. + + For more details look at: https://arxiv.org/pdf/1901.07291.pdf + + Args: + dictionary (Dictionary): the dictionary for the input of the task + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "data", + help="colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner", + ) + parser.add_argument( + "--tokens-per-sample", + default=512, + type=int, + help="max number of total tokens over all segments" " per sample", + ) + parser.add_argument( + "--monolingual-langs", + default="en", + type=str, + help="comma separated list of languages for which we" + " want to train XLM on", + ) + parser.add_argument( + "--shuffle", + action="store_true", + help="shuffle each monolingual dataset while" " training", + ) + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + self.seed = args.seed + self.distributed_world_size = args.distributed_world_size + self.langs2id = self._lang_to_id(args.monolingual_langs) + + def _lang_to_id(self, languages: str): + """ + Build a map from languages to ids. These ids are used as segment labels + for cross-lingual LM training. + """ + lang2id = {} + langs = [l.strip() for l in languages.split(",")] + for id, lang in enumerate(langs): + lang2id[lang] = id + return lang2id + + @classmethod + def load_dictionary(cls, filename): + return MaskedLMDictionary.load(filename) + + @classmethod + def build_dictionary( + cls, filenames, workers=1, threshold=-1, nwords=-1, padding_factor=8 + ): + d = MaskedLMDictionary() + for filename in filenames: + Dictionary.add_file_to_dictionary( + filename, d, tokenizer.tokenize_line, workers + ) + d.finalize(threshold=threshold, nwords=nwords, padding_factor=padding_factor) + return d + + @property + def target_dictionary(self): + return self.dictionary + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task.""" + dictionary = MaskedLMDictionary.load(os.path.join(args.data, "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + return cls(args, dictionary) + + def _load_single_lang_dataset(self, split, epoch): + loaded_datasets = [] + + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + for k in itertools.count(): + split_k = split + (str(k) if k > 0 else "") + path = os.path.join(data_path, split_k) + + ds = data_utils.load_indexed_dataset( + path, self.dictionary, self.args.dataset_impl + ) + if ds is None: + if k > 0: + break + else: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, data_path) + ) + + # Since we append each block with the classification_token, + # we need to effectively create blocks of length + # tokens_per_sample-1 + loaded_datasets.append( + TokenBlockDataset( + ds, + ds.sizes, + self.args.tokens_per_sample - 1, + pad=self.dictionary.pad(), + eos=self.dictionary.eos(), + ) + ) + + logger.info( + "{} {} {} examples".format(data_path, split_k, len(loaded_datasets[-1])) + ) + + if len(loaded_datasets) == 1: + dataset = loaded_datasets[0] + sizes = dataset.sizes + else: + dataset = ConcatDataset(loaded_datasets) + sizes = np.concatenate([ds.sizes for ds in loaded_datasets]) + + return dataset, sizes + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + dataset_map = OrderedDict() + + for lang in self.langs2id.keys(): + # Datasets are expected to be in "split.lang" format (Eg: train.en) + language_split = "{}.{}".format(split, lang) + + block_dataset, sizes = self._load_single_lang_dataset( + split=language_split, epoch=epoch + ) + + dataset_map[lang] = MaskedLMDataset( + dataset=block_dataset, + sizes=sizes, + vocab=self.dictionary, + pad_idx=self.dictionary.pad(), + mask_idx=self.dictionary.mask(), + classif_token_idx=self.dictionary.eos(), + sep_token_idx=self.dictionary.eos(), + shuffle=getattr(self.args, "shuffle", False), + has_pairs=False, + segment_id=self.langs2id[lang], + seed=self.seed, + ) + + self.datasets[split] = MultiCorpusSampledDataset(dataset_map) + logger.info( + "{} {} {} examples".format( + utils.split_paths(self.args.data)[epoch - 1], + split, + len(self.datasets[split]), + ) + ) diff --git a/fairseq/fairseq/tasks/denoising.py b/fairseq/fairseq/tasks/denoising.py new file mode 100644 index 0000000000000000000000000000000000000000..d1dff26c36d51e394e1c955c6683fa4a20c52395 --- /dev/null +++ b/fairseq/fairseq/tasks/denoising.py @@ -0,0 +1,277 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +from fairseq import utils +from fairseq.data import ( + AppendTokenDataset, + DenoisingDataset, + Dictionary, + IdDataset, + NestedDictionaryDataset, + NumelDataset, + PadDataset, + PrependTokenDataset, + StripTokenDataset, + TokenBlockDataset, + data_utils, +) +from fairseq.data.encoders.utils import get_whole_word_mask +from fairseq.data.shorten_dataset import maybe_shorten_dataset +from fairseq.tasks import LegacyFairseqTask, register_task +import numpy as np + + +logger = logging.getLogger(__name__) + + +@register_task("denoising") +class DenoisingTask(LegacyFairseqTask): + """ + Denoising task for applying sequence to sequence denoising. (ie. BART) + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument("data", help="path to data directory") + parser.add_argument( + "--tokens-per-sample", + default=512, + type=int, + help="max number of total tokens over all segments" + " per sample for dataset", + ) + parser.add_argument( + "--sample-break-mode", + default="complete_doc", + type=str, + help="mode for breaking sentence", + ) + parser.add_argument( + "--mask", + default=0.0, + type=float, + help="fraction of words/subwords that will be masked", + ) + parser.add_argument( + "--mask-random", + default=0.0, + type=float, + help="instead of using [MASK], use random token this often", + ) + parser.add_argument( + "--insert", + default=0.0, + type=float, + help="insert this percentage of additional random tokens", + ) + parser.add_argument( + "--permute", + default=0.0, + type=float, + help="take this proportion of subwords and permute them", + ) + parser.add_argument( + "--rotate", + default=0.5, + type=float, + help="rotate this proportion of inputs", + ) + parser.add_argument( + "--poisson-lambda", + default=3.0, + type=float, + help="randomly shuffle sentences for this proportion of inputs", + ) + parser.add_argument( + "--permute-sentences", + default=0.0, + type=float, + help="shuffle this proportion of sentences in all inputs", + ) + parser.add_argument( + "--mask-length", + default="subword", + type=str, + choices=["subword", "word", "span-poisson"], + help="mask length to choose", + ) + parser.add_argument( + "--replace-length", + default=-1, + type=int, + help="when masking N tokens, replace with 0, 1, or N tokens (use -1 for N)", + ) + parser.add_argument( + "--max-source-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the source sequence", + ) + parser.add_argument( + "--max-target-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the target sequence", + ) + + parser.add_argument( + "--shorten-method", + default="none", + choices=["none", "truncate", "random_crop"], + help="if not none, shorten sequences that exceed --tokens-per-sample", + ) + parser.add_argument( + "--shorten-data-split-list", + default="", + help="comma-separated list of dataset splits to apply shortening to, " + 'e.g., "train,valid" (default: all dataset splits)', + ) + + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + self.seed = args.seed + + # add mask token + self.mask_idx = self.dictionary.add_symbol("<mask>") + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task.""" + paths = utils.split_paths(args.data) + assert len(paths) > 0 + dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + if not hasattr(args, "shuffle_instance"): + args.shuffle_instance = False + return cls(args, dictionary) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + dataset = data_utils.load_indexed_dataset( + split_path, + self.dictionary, + self.args.dataset_impl, + combine=combine, + ) + if dataset is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + dataset = StripTokenDataset(dataset, self.dictionary.eos()) + + dataset = maybe_shorten_dataset( + dataset, + split, + self.args.shorten_data_split_list, + self.args.shorten_method, + self.args.tokens_per_sample, + self.args.seed, + ) + + # create continuous blocks of tokens + dataset = TokenBlockDataset( + dataset, + dataset.sizes, + self.args.tokens_per_sample - 2, # one less for <s> and one for </s> + pad=self.dictionary.pad(), + eos=self.dictionary.eos(), + break_mode=self.args.sample_break_mode, + document_sep_len=0, + ) + logger.info("loaded {} blocks from: {}".format(len(dataset), split_path)) + + # prepend beginning-of-sentence token (<s>, equiv. to [CLS] in BERT) + dataset = PrependTokenDataset(dataset, self.source_dictionary.bos()) + dataset = AppendTokenDataset(dataset, self.source_dictionary.eos()) + + mask_whole_words = ( + get_whole_word_mask(self.args, self.source_dictionary) + if self.args.mask_length != "subword" + else None + ) + + self.datasets[split] = DenoisingDataset( + dataset, + dataset.sizes, + self.dictionary, + self.mask_idx, + mask_whole_words, + shuffle=self.args.shuffle_instance, + seed=self.seed, + args=self.args, + ) + logger.info( + "Split: {0}, Loaded {1} samples of denoising_dataset".format( + split, + len(self.datasets[split]), + ) + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, **kwargs): + """ + Generate batches for inference. We assume that the input begins with a + bos symbol (`<s>`) and ends with an eos symbol (`</s>`). + """ + pad = self.source_dictionary.pad() + eos = self.source_dictionary.eos() + src_dataset = TokenBlockDataset( + src_tokens, + src_lengths, + block_size=self.args.tokens_per_sample - 2, # for <s> and </s> + pad=pad, + eos=eos, + break_mode=self.args.sample_break_mode, + document_sep_len=0, + ) + prev_output_tokens = PrependTokenDataset( + StripTokenDataset(src_dataset, eos), eos + ) + src_dataset = PadDataset(src_dataset, pad_idx=pad, left_pad=False) + return NestedDictionaryDataset( + { + "id": IdDataset(), + "net_input": { + "src_tokens": src_dataset, + "src_lengths": NumelDataset(src_dataset, reduce=False), + "prev_output_tokens": PadDataset( + prev_output_tokens, pad_idx=pad, left_pad=False + ), + }, + "target": src_dataset, + }, + sizes=[np.array(src_lengths)], + ) + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.args.max_source_positions, self.args.max_target_positions) + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.dictionary + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary`.""" + return self.dictionary diff --git a/fairseq/fairseq/tasks/fairseq_task.py b/fairseq/fairseq/tasks/fairseq_task.py new file mode 100644 index 0000000000000000000000000000000000000000..e94ac54c6a7e4bfe22c189f95d7041dcc41333ab --- /dev/null +++ b/fairseq/fairseq/tasks/fairseq_task.py @@ -0,0 +1,668 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import warnings +from argparse import Namespace +from typing import Any, Callable, Dict, List + +import torch +from fairseq import metrics, search, tokenizer, utils +from fairseq.data import Dictionary, FairseqDataset, data_utils, encoders, iterators +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import gen_parser_from_dataclass +from fairseq.optim.amp_optimizer import AMPOptimizer +from omegaconf import DictConfig + + +logger = logging.getLogger(__name__) + + +class StatefulContainer(object): + + def __init__(self): + self._state = dict() + self._factories = dict() + + def add_factory(self, name, factory: Callable[[], Any]): + self._factories[name] = factory + + def merge_state_dict(self, state_dict: Dict[str, Any]): + self._state.update(state_dict) + + @property + def state_dict(self) -> Dict[str, Any]: + return self._state + + def __getattr__(self, name): + if name not in self._state and name in self._factories: + self._state[name] = self._factories[name]() + + if name in self._state: + return self._state[name] + + raise AttributeError(f"Task state has no factory for attribute {name}") + + +class FairseqTask(object): + """ + Tasks store dictionaries and provide helpers for loading/iterating over + Datasets, initializing the Model/Criterion and calculating the loss. + + Tasks have limited statefulness. In particular, state that needs to be + saved to/loaded from checkpoints needs to be stored in the `self.state` + :class:`StatefulContainer` object. For example:: + + self.state.add_factory("dictionary", self.load_dictionary) + print(self.state.dictionary) # calls self.load_dictionary() + + This is necessary so that when loading checkpoints, we can properly + recreate the task state after initializing the task instance. + """ + + @classmethod + def add_args(cls, parser): + """Add task-specific arguments to the parser.""" + dc = getattr(cls, "__dataclass", None) + if dc is not None: + gen_parser_from_dataclass(parser, dc()) + + @staticmethod + def logging_outputs_can_be_summed(criterion) -> bool: + """ + Whether the logging outputs returned by `train_step` and `valid_step` can + be summed across workers prior to calling `aggregate_logging_outputs`. + Setting this to True will improves distributed training speed. + """ + return criterion.logging_outputs_can_be_summed() + + def __init__(self, cfg: FairseqDataclass, **kwargs): + self.cfg = cfg + self.datasets = dict() + self.dataset_to_epoch_iter = dict() + self.state = StatefulContainer() + + @classmethod + def load_dictionary(cls, filename): + """Load the dictionary from the filename + + Args: + filename (str): the filename + """ + return Dictionary.load(filename) + + @classmethod + def build_dictionary( + cls, filenames, workers=1, threshold=-1, nwords=-1, padding_factor=8 + ): + """Build the dictionary + + Args: + filenames (list): list of filenames + workers (int): number of concurrent workers + threshold (int): defines the minimum word count + nwords (int): defines the total number of words in the final dictionary, + including special symbols + padding_factor (int): can be used to pad the dictionary size to be a + multiple of 8, which is important on some hardware (e.g., Nvidia + Tensor Cores). + """ + d = Dictionary() + for filename in filenames: + Dictionary.add_file_to_dictionary( + filename, d, tokenizer.tokenize_line, workers + ) + d.finalize(threshold=threshold, nwords=nwords, padding_factor=padding_factor) + return d + + @classmethod + def setup_task(cls, cfg: DictConfig, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + cfg (omegaconf.DictConfig): parsed command-line arguments + """ + return cls(cfg, **kwargs) + + def has_sharded_data(self, split): + return os.pathsep in getattr(self.cfg, "data", "") + + def load_dataset( + self, + split: str, + combine: bool = False, + task_cfg: FairseqDataclass = None, + **kwargs + ): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + combine (bool): combines a split segmented into pieces into one dataset + task_cfg (FairseqDataclass): optional task configuration stored in the checkpoint that can be used + to load datasets + """ + raise NotImplementedError + + def dataset(self, split): + """ + Return a loaded dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + + Returns: + a :class:`~fairseq.data.FairseqDataset` corresponding to *split* + """ + from fairseq.data import FairseqDataset + + if split not in self.datasets: + raise KeyError("Dataset not loaded: " + split) + if not isinstance(self.datasets[split], FairseqDataset): + raise TypeError("Datasets are expected to be of type FairseqDataset") + return self.datasets[split] + + def filter_indices_by_size( + self, indices, dataset, max_positions=None, ignore_invalid_inputs=False + ): + """ + Filter examples that are too large + + Args: + indices (np.array): original array of sample indices + dataset (~fairseq.data.FairseqDataset): dataset to batch + max_positions (optional): max sentence length supported by the + model (default: None). + ignore_invalid_inputs (bool, optional): don't raise Exception for + sentences that are too long (default: False). + Returns: + np.array: array of filtered sample indices + """ + indices, ignored = dataset.filter_indices_by_size(indices, max_positions) + if len(ignored) > 0: + if not ignore_invalid_inputs: + raise Exception( + ( + "Size of sample #{} is invalid (={}) since max_positions={}, " + "skip this example with --skip-invalid-size-inputs-valid-test" + ).format(ignored[0], dataset.size(ignored[0]), max_positions) + ) + logger.warning( + ( + "{:,} samples have invalid sizes and will be skipped, " + "max_positions={}, first few sample ids={}" + ).format(len(ignored), max_positions, ignored[:10]) + ) + return indices + + def can_reuse_epoch_itr(self, dataset): + # We can reuse the epoch iterator across epochs as long as the dataset + # hasn't disabled it. We default to ``False`` here, although in practice + # this will be ``True`` for most datasets that inherit from + # ``FairseqDataset`` due to the base implementation there. + return getattr(dataset, "can_reuse_epoch_itr_across_epochs", False) + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + """ + Get an iterator that yields batches of data from the given dataset. + + Args: + dataset (~fairseq.data.FairseqDataset): dataset to batch + max_tokens (int, optional): max number of tokens in each batch + (default: None). + max_sentences (int, optional): max number of sentences in each + batch (default: None). + max_positions (optional): max sentence length supported by the + model (default: None). + ignore_invalid_inputs (bool, optional): don't raise Exception for + sentences that are too long (default: False). + required_batch_size_multiple (int, optional): require batch size to + be a multiple of N (default: 1). + seed (int, optional): seed for random number generator for + reproducibility (default: 1). + num_shards (int, optional): shard the data iterator into N + shards (default: 1). + shard_id (int, optional): which shard of the data iterator to + return (default: 0). + num_workers (int, optional): how many subprocesses to use for data + loading. 0 means the data will be loaded in the main process + (default: 0). + epoch (int, optional): the epoch to start the iterator from + (default: 1). + data_buffer_size (int, optional): number of batches to + preload (default: 0). + disable_iterator_cache (bool, optional): don't cache the + EpochBatchIterator (ignores `FairseqTask::can_reuse_epoch_itr`) + (default: False). + Returns: + ~fairseq.iterators.EpochBatchIterator: a batched iterator over the + given dataset split + """ + can_reuse_epoch_itr = not disable_iterator_cache and self.can_reuse_epoch_itr( + dataset + ) + if can_reuse_epoch_itr and dataset in self.dataset_to_epoch_iter: + logger.debug("reusing EpochBatchIterator for epoch {}".format(epoch)) + return self.dataset_to_epoch_iter[dataset] + + assert isinstance(dataset, FairseqDataset) + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # get indices ordered by example size + with data_utils.numpy_seed(seed): + indices = dataset.ordered_indices() + + # filter examples that are too large + if max_positions is not None: + indices = self.filter_indices_by_size( + indices, dataset, max_positions, ignore_invalid_inputs + ) + + # create mini-batches with given size constraints + batch_sampler = dataset.batch_by_size( + indices, + max_tokens=max_tokens, + max_sentences=max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + ) + + # return a reusable, sharded iterator + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=batch_sampler, + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size, + ) + + if can_reuse_epoch_itr: + self.dataset_to_epoch_iter[dataset] = epoch_iter + + return epoch_iter + + def build_model(self, cfg: FairseqDataclass): + """ + Build the :class:`~fairseq.models.BaseFairseqModel` instance for this + task. + + Args: + cfg (FairseqDataclass): configuration object + + Returns: + a :class:`~fairseq.models.BaseFairseqModel` instance + """ + from fairseq import models, quantization_utils + + model = models.build_model(cfg, self) + model = quantization_utils.quantize_model_scalar(model, cfg) + return model + + def build_criterion(self, cfg: DictConfig): + """ + Build the :class:`~fairseq.criterions.FairseqCriterion` instance for + this task. + + Args: + cfg (omegaconf.DictConfig): configration object + + Returns: + a :class:`~fairseq.criterions.FairseqCriterion` instance + """ + from fairseq import criterions + + return criterions.build_criterion(cfg, self) + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + """ + Build a :class:`~fairseq.SequenceGenerator` instance for this + task. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + args (fairseq.dataclass.configs.GenerationConfig): + configuration object (dataclass) for generation + extra_gen_cls_kwargs (Dict[str, Any]): extra options to pass + through to SequenceGenerator + prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]): + If provided, this function constrains the beam search to + allowed tokens only at each step. The provided function + should take 2 arguments: the batch ID (`batch_id: int`) + and a unidimensional tensor of token ids (`inputs_ids: + torch.Tensor`). It has to return a `List[int]` with the + allowed tokens for the next generation step conditioned + on the previously generated tokens (`inputs_ids`) and + the batch ID (`batch_id`). This argument is useful for + constrained generation conditioned on the prefix, as + described in "Autoregressive Entity Retrieval" + (https://arxiv.org/abs/2010.00904) and + https://github.com/facebookresearch/GENRE. + """ + if getattr(args, "score_reference", False): + from fairseq.sequence_scorer import SequenceScorer + + return SequenceScorer( + self.target_dictionary, + compute_alignment=getattr(args, "print_alignment", False), + ) + + from fairseq.sequence_generator import ( + SequenceGenerator, + SequenceGeneratorWithAlignment, + ) + + # Choose search strategy. Defaults to Beam Search. + sampling = getattr(args, "sampling", False) + sampling_topk = getattr(args, "sampling_topk", -1) + sampling_topp = getattr(args, "sampling_topp", -1.0) + diverse_beam_groups = getattr(args, "diverse_beam_groups", -1) + diverse_beam_strength = getattr(args, "diverse_beam_strength", 0.5) + match_source_len = getattr(args, "match_source_len", False) + diversity_rate = getattr(args, "diversity_rate", -1) + constrained = getattr(args, "constraints", False) + if prefix_allowed_tokens_fn is None: + prefix_allowed_tokens_fn = getattr(args, "prefix_allowed_tokens_fn", None) + if ( + sum( + int(cond) + for cond in [ + sampling, + diverse_beam_groups > 0, + match_source_len, + diversity_rate > 0, + ] + ) + > 1 + ): + raise ValueError("Provided Search parameters are mutually exclusive.") + assert sampling_topk < 0 or sampling, "--sampling-topk requires --sampling" + assert sampling_topp < 0 or sampling, "--sampling-topp requires --sampling" + + if sampling: + search_strategy = search.Sampling( + self.target_dictionary, sampling_topk, sampling_topp + ) + elif diverse_beam_groups > 0: + search_strategy = search.DiverseBeamSearch( + self.target_dictionary, diverse_beam_groups, diverse_beam_strength + ) + elif match_source_len: + # this is useful for tagging applications where the output + # length should match the input length, so we hardcode the + # length constraints for simplicity + search_strategy = search.LengthConstrainedBeamSearch( + self.target_dictionary, + min_len_a=1, + min_len_b=0, + max_len_a=1, + max_len_b=0, + ) + elif diversity_rate > -1: + search_strategy = search.DiverseSiblingsSearch( + self.target_dictionary, diversity_rate + ) + elif constrained: + search_strategy = search.LexicallyConstrainedBeamSearch( + self.target_dictionary, args.constraints + ) + elif prefix_allowed_tokens_fn: + search_strategy = search.PrefixConstrainedBeamSearch( + self.target_dictionary, prefix_allowed_tokens_fn + ) + else: + search_strategy = search.BeamSearch(self.target_dictionary) + + extra_gen_cls_kwargs = extra_gen_cls_kwargs or {} + if seq_gen_cls is None: + if getattr(args, "print_alignment", False): + seq_gen_cls = SequenceGeneratorWithAlignment + extra_gen_cls_kwargs["print_alignment"] = args.print_alignment + else: + seq_gen_cls = SequenceGenerator + + return seq_gen_cls( + models, + self.target_dictionary, + beam_size=getattr(args, "beam", 5), + max_len_a=getattr(args, "max_len_a", 0), + max_len_b=getattr(args, "max_len_b", 200), + min_len=getattr(args, "min_len", 1), + normalize_scores=(not getattr(args, "unnormalized", False)), + len_penalty=getattr(args, "lenpen", 1), + unk_penalty=getattr(args, "unkpen", 0), + temperature=getattr(args, "temperature", 1.0), + match_source_len=getattr(args, "match_source_len", False), + no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0), + search_strategy=search_strategy, + **extra_gen_cls_kwargs, + ) + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False, **extra_kwargs + ): + """ + Do forward and backward, and return the loss as computed by *criterion* + for the given *model* and *sample*. + + Args: + sample (dict): the mini-batch. The format is defined by the + :class:`~fairseq.data.FairseqDataset`. + model (~fairseq.models.BaseFairseqModel): the model + criterion (~fairseq.criterions.FairseqCriterion): the criterion + optimizer (~fairseq.optim.FairseqOptimizer): the optimizer + update_num (int): the current update + ignore_grad (bool): multiply loss by 0 if this is set to True + + Returns: + tuple: + - the loss + - the sample size, which is used as the denominator for the + gradient + - logging outputs to display while training + """ + model.train() + model.set_num_updates(update_num) + with torch.autograd.profiler.record_function("forward"): + with torch.cuda.amp.autocast(enabled=(isinstance(optimizer, AMPOptimizer))): + loss, sample_size, logging_output = criterion(model, sample, update_num=update_num) + if ignore_grad: + loss *= 0 + with torch.autograd.profiler.record_function("backward"): + optimizer.backward(loss) + return loss, sample_size, logging_output + + def valid_step(self, sample, model, criterion, **extra_kwargs): + model.eval() + with torch.no_grad(): + loss, sample_size, logging_output = criterion(model, sample) + return loss, sample_size, logging_output + + def optimizer_step(self, optimizer, model, update_num): + optimizer.step() + + def build_dataset_for_inference( + self, src_tokens: List[torch.Tensor], src_lengths: List[int], **kwargs + ) -> torch.utils.data.Dataset: + raise NotImplementedError + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + return generator.generate( + models, sample, prefix_tokens=prefix_tokens, constraints=constraints + ) + + def begin_epoch(self, epoch, model): + """Hook function called before the start of each epoch.""" + pass + + def begin_valid_epoch(self, epoch, model): + """Hook function called before the start of each validation epoch.""" + pass + + def aggregate_logging_outputs(self, logging_outputs, criterion): + """[deprecated] Aggregate logging outputs from data parallel training.""" + utils.deprecation_warning( + "The aggregate_logging_outputs API is deprecated. " + "Please use the reduce_metrics API instead." + ) + with metrics.aggregate() as agg: + self.reduce_metrics(logging_outputs, criterion) + return agg.get_smoothed_values() + + def reduce_metrics(self, logging_outputs, criterion): + """Aggregate logging outputs from data parallel training.""" + # backward compatibility for tasks that override aggregate_logging_outputs + base_func = FairseqTask.aggregate_logging_outputs + self_func = getattr(self, "aggregate_logging_outputs").__func__ + if self_func is not base_func: + utils.deprecation_warning( + "Tasks should implement the reduce_metrics API. " + "Falling back to deprecated aggregate_logging_outputs API." + ) + agg_logging_outputs = self.aggregate_logging_outputs( + logging_outputs, criterion + ) + for k, v in agg_logging_outputs.items(): + metrics.log_scalar(k, v) + return + + if not any("ntokens" in log for log in logging_outputs): + warnings.warn( + "ntokens not found in Criterion logging outputs, cannot log wpb or wps" + ) + else: + ntokens = sum(log.get("ntokens", 0) for log in logging_outputs) + metrics.log_scalar("wpb", ntokens, priority=180, round=1) + metrics.log_speed("wps", ntokens, priority=90, round=1) + + if not any("nsentences" in log for log in logging_outputs): + warnings.warn( + "nsentences not found in Criterion logging outputs, cannot log bsz" + ) + else: + nsentences = sum(log.get("nsentences", 0) for log in logging_outputs) + metrics.log_scalar("bsz", nsentences, priority=190, round=1) + + criterion.__class__.reduce_metrics(logging_outputs) + + def state_dict(self): + if self.state is not None: + return self.state.state_dict + return {} + + def load_state_dict(self, state_dict: Dict[str, Any]): + if self.state is not None: + self.state.merge_state_dict(state_dict) + + def max_positions(self): + """Return the max input length allowed by the task.""" + return None + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary` (if applicable + for this task).""" + raise NotImplementedError + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary` (if applicable + for this task).""" + raise NotImplementedError + + def build_tokenizer(self, args): + """Build the pre-tokenizer for this task.""" + return encoders.build_tokenizer(args) + + def build_bpe(self, args): + """Build the tokenizer for this task.""" + return encoders.build_bpe(args) + + def get_interactive_tokens_and_lengths(self, lines, encode_fn): + tokens = [ + self.source_dictionary.encode_line( + encode_fn(src_str), add_if_not_exist=False + ).long() + for src_str in lines + ] + lengths = [t.numel() for t in tokens] + return tokens, lengths + + +class LegacyFairseqTask(FairseqTask): + def __init__(self, args: Namespace): + super().__init__(None) + self.args = args + self.datasets = {} + self.dataset_to_epoch_iter = {} + + @classmethod + def setup_task(cls, args: Namespace, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + return cls(args, **kwargs) + + def has_sharded_data(self, split): + return os.pathsep in getattr(self.args, "data", "") + + def build_model(self, args: Namespace): + """ + Build the :class:`~fairseq.models.BaseFairseqModel` instance for this + task. + + Args: + args (argparse.Namespace): parsed command-line arguments + + Returns: + a :class:`~fairseq.models.BaseFairseqModel` instance + """ + from fairseq import models, quantization_utils + + model = models.build_model(args, self) + model = quantization_utils.quantize_model_scalar(model, args) + return model + + def build_criterion(self, args: Namespace): + """ + Build the :class:`~fairseq.criterions.FairseqCriterion` instance for + this task. + + Args: + args (argparse.Namespace): parsed command-line arguments + + Returns: + a :class:`~fairseq.criterions.FairseqCriterion` instance + """ + from fairseq import criterions + + return criterions.build_criterion(args, self) diff --git a/fairseq/fairseq/tasks/frm_text_to_speech.py b/fairseq/fairseq/tasks/frm_text_to_speech.py new file mode 100644 index 0000000000000000000000000000000000000000..1fa9b0f83e742aefce764e2858a81f99db911afd --- /dev/null +++ b/fairseq/fairseq/tasks/frm_text_to_speech.py @@ -0,0 +1,56 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging + +from fairseq.data.audio.frm_text_to_speech_dataset import FrmTextToSpeechDatasetCreator +from fairseq.tasks import register_task +from fairseq.tasks.text_to_speech import TextToSpeechTask + + +logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(name)s | %(message)s', + datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO +) +logger = logging.getLogger(__name__) + + +@register_task('frm_text_to_speech') +class FrmTextToSpeechTask(TextToSpeechTask): + @staticmethod + def add_args(parser): + TextToSpeechTask.add_args(parser) + parser.add_argument( + "--do_chunk", action="store_true", help="train on chunks" + ) + parser.add_argument("--chunk_bound", default=-1, type=int) + parser.add_argument("--chunk_init", default=50, type=int) + parser.add_argument("--chunk_incr", default=5, type=int) + parser.add_argument("--add_eos", action="store_true") + parser.add_argument("--dedup", action="store_true") + parser.add_argument("--ref_fpu", default=-1, type=float) + + def load_dataset(self, split, **unused_kwargs): + is_train_split = split.startswith("train") + pre_tokenizer = self.build_tokenizer(self.args) + bpe_tokenizer = self.build_bpe(self.args) + self.datasets[split] = FrmTextToSpeechDatasetCreator.from_tsv( + self.args.data, + self.data_cfg, + split, + self.src_dict, + pre_tokenizer, + bpe_tokenizer, + is_train_split=is_train_split, + n_frames_per_step=self.args.n_frames_per_step, + speaker_to_id=self.speaker_to_id, + do_chunk=self.args.do_chunk, + chunk_bound=self.args.chunk_bound, + chunk_init=self.args.chunk_init, + chunk_incr=self.args.chunk_incr, + add_eos=self.args.add_eos, + dedup=self.args.dedup, + ref_fpu=self.args.ref_fpu + ) diff --git a/fairseq/fairseq/tasks/hubert_pretraining.py b/fairseq/fairseq/tasks/hubert_pretraining.py new file mode 100644 index 0000000000000000000000000000000000000000..f756080dd17b380d004420c045a8744411c0e93d --- /dev/null +++ b/fairseq/fairseq/tasks/hubert_pretraining.py @@ -0,0 +1,195 @@ +# Copyright (c) 2017-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the LICENSE file in +# the root directory of this source tree. An additional grant of patent rights +# can be found in the PATENTS file in the same directory. + +import logging +import os +import sys +from typing import Dict, List, Optional, Tuple + +import numpy as np + +from dataclasses import dataclass, field +from fairseq.data import Dictionary, HubertDataset +from fairseq.dataclass.configs import FairseqDataclass +from fairseq.tasks import register_task +from fairseq.tasks.fairseq_task import FairseqTask +from omegaconf import MISSING + +logger = logging.getLogger(__name__) + + +class LabelEncoder(object): + def __init__(self, dictionary: Dictionary) -> None: + self.dictionary = dictionary + + def __call__(self, label: str) -> List[str]: + return self.dictionary.encode_line( + label, append_eos=False, add_if_not_exist=False, + ) + + +@dataclass +class HubertPretrainingConfig(FairseqDataclass): + data: str = field( + default=MISSING, metadata={"help": "path to data directory"} + ) + fine_tuning: bool = field( + default=False, metadata={"help": "set to true if fine-tuning Hubert"} + ) + labels: List[str] = field( + default_factory=lambda: ["ltr"], + metadata={ + "help": ( + "extension of the label files to load, frame-level labels for" + " pre-training, and sequence-level label for fine-tuning" + ) + }, + ) + label_dir: Optional[str] = field( + default=None, + metadata={ + "help": "if set, looks for labels in this directory instead", + }, + ) + label_rate: int = field( + default=-1, + metadata={"help": "label frame rate. -1 for sequence label"}, + ) + sample_rate: int = field( + default=16_000, + metadata={ + "help": "target sample rate. audio files will be up/down " + "sampled to this rate" + }, + ) + normalize: bool = field( + default=False, + metadata={ + "help": "if set, normalizes input to have 0 mean and unit variance" + }, + ) + enable_padding: bool = field( + default=False, + metadata={"help": "pad shorter samples instead of cropping"}, + ) + max_keep_size: Optional[int] = field( + default=None, + metadata={"help": "exclude sample longer than this"}, + ) + max_sample_size: Optional[int] = field( + default=None, + metadata={"help": "max sample size to crop to for batching"}, + ) + min_sample_size: Optional[int] = field( + default=None, + metadata={"help": "min sample size to crop to for batching"}, + ) + single_target: Optional[bool] = field( + default=False, + metadata={ + "help": "if set, AddTargetDatasets outputs same keys " + "as AddTargetDataset" + }, + ) + random_crop: Optional[bool] = field( + default=True, + metadata={"help": "always crop from the beginning if false"}, + ) + pad_audio: Optional[bool] = field( + default=False, + metadata={"help": "pad audio to the longest one in the batch if true"}, + ) + + +@register_task("hubert_pretraining", dataclass=HubertPretrainingConfig) +class HubertPretrainingTask(FairseqTask): + + cfg: HubertPretrainingConfig + + def __init__( + self, + cfg: HubertPretrainingConfig, + ) -> None: + super().__init__(cfg) + + logger.info(f"current directory is {os.getcwd()}") + logger.info(f"HubertPretrainingTask Config {cfg}") + + self.cfg = cfg + self.fine_tuning = cfg.fine_tuning + + if cfg.fine_tuning: + self.state.add_factory("target_dictionary", self.load_dictionaries) + else: + self.state.add_factory("dictionaries", self.load_dictionaries) + + self.blank_symbol = "<s>" + + @property + def source_dictionary(self) -> Optional[Dictionary]: + return None + + @property + def target_dictionary(self) -> Optional[Dictionary]: + return self.state.target_dictionary + + @property + def dictionaries(self) -> List[Dictionary]: + return self.state.dictionaries + + @classmethod + def setup_task( + cls, cfg: HubertPretrainingConfig, **kwargs + ) -> "HubertPretrainingTask": + return cls(cfg) + + def load_dictionaries(self): + label_dir = self.cfg.data if self.cfg.label_dir is None else self.cfg.label_dir + dictionaries = [Dictionary.load(f"{label_dir}/dict.{label}.txt") for label in self.cfg.labels] + return dictionaries[0] if self.cfg.fine_tuning else dictionaries + + def get_label_dir(self) -> str: + if self.cfg.label_dir is None: + return self.cfg.data + return self.cfg.label_dir + + def load_dataset(self, split: str, **kwargs) -> None: + manifest = f"{self.cfg.data}/{split}.tsv" + dicts = [self.target_dictionary] if self.cfg.fine_tuning else self.dictionaries + pad_list = [dict.pad() for dict in dicts] + eos_list = [dict.eos() for dict in dicts] + procs = [LabelEncoder(dict) for dict in dicts] + paths = [ + f"{self.get_label_dir()}/{split}.{l}" for l in self.cfg.labels + ] + + # hubert v1: pad_audio=True, random_crop=False; + self.datasets[split] = HubertDataset( + manifest, + sample_rate=self.cfg.sample_rate, + label_paths=paths, + label_rates=self.cfg.label_rate, + pad_list=pad_list, + eos_list=eos_list, + label_processors=procs, + max_keep_sample_size=self.cfg.max_keep_size, + min_keep_sample_size=self.cfg.min_sample_size, + max_sample_size=self.cfg.max_sample_size, + pad_audio=self.cfg.pad_audio, + normalize=self.cfg.normalize, + store_labels=False, + random_crop=self.cfg.random_crop, + single_target=self.cfg.single_target, + ) + + def max_positions(self) -> Tuple[int, int]: + return (sys.maxsize, sys.maxsize) + + def filter_indices_by_size( + self, indices: np.array, *args, **kwargs + ) -> np.array: + return indices diff --git a/fairseq/fairseq/tasks/language_modeling.py b/fairseq/fairseq/tasks/language_modeling.py new file mode 100644 index 0000000000000000000000000000000000000000..4b76a51c61d71c4358de07bdd4eb3f93894737a8 --- /dev/null +++ b/fairseq/fairseq/tasks/language_modeling.py @@ -0,0 +1,379 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +from dataclasses import dataclass, field +from typing import Optional + +import numpy as np +import torch +from fairseq import utils +from fairseq.data import ( + AppendTokenDataset, + Dictionary, + IdDataset, + LMContextWindowDataset, + MonolingualDataset, + NestedDictionaryDataset, + NumelDataset, + PadDataset, + PrependTokenDataset, + StripTokenDataset, + TokenBlockDataset, + TruncatedDictionary, + data_utils, +) +from fairseq.data.indexed_dataset import get_available_dataset_impl +from fairseq.data.shorten_dataset import maybe_shorten_dataset +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.tasks import LegacyFairseqTask, register_task +from omegaconf import II + + +SAMPLE_BREAK_MODE_CHOICES = ChoiceEnum(["none", "complete", "complete_doc", "eos"]) +SHORTEN_METHOD_CHOICES = ChoiceEnum(["none", "truncate", "random_crop"]) +logger = logging.getLogger(__name__) + + +@dataclass +class LanguageModelingConfig(FairseqDataclass): + data: Optional[str] = field( + default=None, metadata={"help": "path to data directory"} + ) + sample_break_mode: SAMPLE_BREAK_MODE_CHOICES = field( + default="none", + metadata={ + "help": 'If omitted or "none", fills each sample with tokens-per-sample ' + 'tokens. If set to "complete", splits samples only at the end ' + "of sentence, but may include multiple sentences per sample. " + '"complete_doc" is similar but respects doc boundaries. ' + 'If set to "eos", includes only one sentence per sample.' + }, + ) + tokens_per_sample: int = field( + default=1024, + metadata={"help": "max number of tokens per sample for LM dataset"}, + ) + output_dictionary_size: int = field( + default=-1, metadata={"help": "limit the size of output dictionary"} + ) + self_target: bool = field(default=False, metadata={"help": "include self target"}) + future_target: bool = field( + default=False, metadata={"help": "include future target"} + ) + past_target: bool = field(default=False, metadata={"help": "include past target"}) + add_bos_token: bool = field( + default=False, metadata={"help": "prepend beginning of sentence token (<s>)"} + ) + max_target_positions: Optional[int] = field( + default=None, metadata={"help": "max number of tokens in the target sequence"} + ) + shorten_method: SHORTEN_METHOD_CHOICES = field( + default="none", + metadata={ + "help": "if not none, shorten sequences that exceed --tokens-per-sample" + }, + ) + shorten_data_split_list: str = field( + default="", + metadata={ + "help": "comma-separated list of dataset splits to apply shortening to, " + 'e.g., "train,valid" (default: all dataset splits)' + }, + ) + pad_to_fixed_length: Optional[bool] = field( + default=False, metadata={"help": "pad to fixed length"}, + ) + pad_to_fixed_bsz: Optional[bool] = field( + default=False, metadata={"help": "boolean to pad to fixed batch size"}, + ) + + # TODO common vars below add to parent + seed: int = II("common.seed") + batch_size: Optional[int] = II("dataset.batch_size") + batch_size_valid: Optional[int] = II("dataset.batch_size_valid") + dataset_impl: Optional[ChoiceEnum(get_available_dataset_impl())] = II( + "dataset.dataset_impl" + ) + data_buffer_size: int = II("dataset.data_buffer_size") + tpu: bool = II("common.tpu") + use_plasma_view: bool = II("common.use_plasma_view") + plasma_path: str = II("common.plasma_path") + + +@register_task("language_modeling", dataclass=LanguageModelingConfig) +class LanguageModelingTask(LegacyFairseqTask): + """ + Train a language model. + + Args: + dictionary (~fairseq.data.Dictionary): the dictionary for the input of + the language model + output_dictionary (~fairseq.data.Dictionary): the dictionary for the + output of the language model. In most cases it will be the same as + *dictionary*, but could possibly be a more limited version of the + dictionary (if ``--output-dictionary-size`` is used). + targets (List[str]): list of the target types that the language model + should predict. Can be one of "self", "future", and "past". + Defaults to "future". + + .. note:: + + The language modeling task is compatible with :mod:`fairseq-train`, + :mod:`fairseq-generate`, :mod:`fairseq-interactive` and + :mod:`fairseq-eval-lm`. + + The language modeling task provides the following additional command-line + arguments: + + .. argparse:: + :ref: fairseq.tasks.language_modeling_parser + :prog: + """ + + def __init__(self, args, dictionary, output_dictionary=None, targets=None): + super().__init__(args) + self.dictionary = dictionary + self.output_dictionary = output_dictionary or dictionary + + if targets is None: + targets = ["future"] + self.targets = targets + + @classmethod + def setup_dictionary(cls, args, **kwargs): + dictionary = None + output_dictionary = None + if args.data: + paths = utils.split_paths(args.data) + assert len(paths) > 0 + dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + output_dictionary = dictionary + if args.output_dictionary_size >= 0: + output_dictionary = TruncatedDictionary( + dictionary, args.output_dictionary_size + ) + return (dictionary, output_dictionary) + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + dictionary, output_dictionary = cls.setup_dictionary(args, **kwargs) + + # upgrade old checkpoints + if getattr(args, "exclude_self_target", False): + args.self_target = False + + targets = [] + if getattr(args, "self_target", False): + targets.append("self") + if getattr(args, "future_target", False): + targets.append("future") + if getattr(args, "past_target", False): + targets.append("past") + if len(targets) == 0: + # standard language modeling + targets = ["future"] + + return cls(args, dictionary, output_dictionary, targets=targets) + + def build_model(self, args): + model = super().build_model(args) + for target in self.targets: + if target not in model.supported_targets: + raise ValueError( + "Unsupported language modeling target: {}".format(target) + ) + + return model + + def load_dataset( + self, split: str, epoch=1, combine=False, **kwargs + ) -> MonolingualDataset: + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, valid1, test) + """ + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + # each process has its own copy of the raw data (likely to be an np.memmap) + dataset = data_utils.load_indexed_dataset( + split_path, self.dictionary, self.args.dataset_impl, combine=combine + ) + if dataset is None: + raise FileNotFoundError(f"Dataset not found: {split} ({split_path})") + + dataset = maybe_shorten_dataset( + dataset, + split, + self.args.shorten_data_split_list, + self.args.shorten_method, + self.args.tokens_per_sample, + self.args.seed, + ) + dataset = TokenBlockDataset( + dataset, + dataset.sizes, + self.args.tokens_per_sample, + pad=self.dictionary.pad(), + eos=self.dictionary.eos(), + break_mode=self.args.sample_break_mode, + include_targets=True, + use_plasma_view=self.args.use_plasma_view, + split_path=split_path, + plasma_path=self.args.plasma_path, + ) + + add_eos_for_other_targets = ( + self.args.sample_break_mode is not None + and self.args.sample_break_mode != "none" + ) + fixed_pad_length = None + if self.args.pad_to_fixed_length: + fixed_pad_length = self.args.tokens_per_sample + + pad_to_bsz = None + if self.args.pad_to_fixed_bsz: + pad_to_bsz = self.args.batch_size_valid if 'valid' in split else self.args.batch_size + + self.datasets[split] = MonolingualDataset( + dataset=dataset, + sizes=dataset.sizes, + src_vocab=self.dictionary, + tgt_vocab=self.output_dictionary, + add_eos_for_other_targets=add_eos_for_other_targets, + shuffle=True, + targets=self.targets, + add_bos_token=self.args.add_bos_token, + fixed_pad_length=fixed_pad_length, + pad_to_bsz=pad_to_bsz, + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, **kwargs): + """ + Generate batches for inference. We prepend an eos token to src_tokens + (or bos if `--add-bos-token` is set) and we append a <pad> to target. + This is convenient both for generation with a prefix and LM scoring. + """ + dataset = StripTokenDataset( + TokenBlockDataset( + src_tokens, + src_lengths, + block_size=None, # ignored for "eos" break mode + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode="eos", + ), + # remove eos from (end of) target sequence + self.source_dictionary.eos(), + ) + src_dataset = PrependTokenDataset( + dataset, + token=( + self.source_dictionary.bos() + if getattr(self.args, "add_bos_token", False) + else self.source_dictionary.eos() + ), + ) + tgt_dataset = AppendTokenDataset(dataset, token=self.source_dictionary.pad()) + return NestedDictionaryDataset( + { + "id": IdDataset(), + "net_input": { + "src_tokens": PadDataset( + src_dataset, + pad_idx=self.source_dictionary.pad(), + left_pad=False, + ), + "src_lengths": NumelDataset(src_dataset, reduce=False), + }, + "target": PadDataset( + tgt_dataset, pad_idx=self.source_dictionary.pad(), left_pad=False + ), + }, + sizes=[np.array(src_lengths)], + ) + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + # Generation will always be conditioned on bos_token + if getattr(self.args, "add_bos_token", False): + bos_token = self.source_dictionary.bos() + else: + bos_token = self.source_dictionary.eos() + + if constraints is not None: + raise NotImplementedError( + "Constrained decoding with the language_modeling task is not supported" + ) + + # SequenceGenerator doesn't use src_tokens directly, we need to + # pass the `prefix_tokens` argument instead + if prefix_tokens is None and sample["net_input"]["src_tokens"].nelement(): + prefix_tokens = sample["net_input"]["src_tokens"] + if prefix_tokens[:, 0].eq(bos_token).all(): + prefix_tokens = prefix_tokens[:, 1:] + + return generator.generate( + models, sample, prefix_tokens=prefix_tokens, bos_token=bos_token + ) + + def eval_lm_dataloader( + self, + dataset, + max_tokens: Optional[int] = 36000, + batch_size: Optional[int] = None, + max_positions: Optional[int] = None, + num_shards: int = 1, + shard_id: int = 0, + num_workers: int = 1, + data_buffer_size: int = 10, + # ensures that every evaluated token has access to a context of at least + # this size, if possible + context_window: int = 0, + ): + if context_window > 0: + dataset = LMContextWindowDataset( + dataset=dataset, + tokens_per_sample=self.args.tokens_per_sample, + context_window=context_window, + pad_idx=self.source_dictionary.pad(), + ) + return self.get_batch_iterator( + dataset=dataset, + max_tokens=max_tokens, + max_sentences=batch_size, + max_positions=max_positions, + ignore_invalid_inputs=True, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + data_buffer_size=data_buffer_size, + ).next_epoch_itr(shuffle=False) + + @property + def source_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self.dictionary + + @property + def target_dictionary(self): + """Return the :class:`~fairseq.data.Dictionary` for the language + model.""" + return self.output_dictionary diff --git a/fairseq/fairseq/tasks/legacy_masked_lm.py b/fairseq/fairseq/tasks/legacy_masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..975497654926b64fff6c4960f54c4e6932e7fce1 --- /dev/null +++ b/fairseq/fairseq/tasks/legacy_masked_lm.py @@ -0,0 +1,152 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import itertools +import logging +import os + +import numpy as np +from fairseq import tokenizer, utils +from fairseq.data import ConcatDataset, Dictionary, data_utils, indexed_dataset +from fairseq.data.legacy.block_pair_dataset import BlockPairDataset +from fairseq.data.legacy.masked_lm_dataset import MaskedLMDataset +from fairseq.data.legacy.masked_lm_dictionary import BertDictionary +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("legacy_masked_lm") +class LegacyMaskedLMTask(LegacyFairseqTask): + """ + Task for training Masked LM (BERT) model. + Args: + dictionary (Dictionary): the dictionary for the input of the task + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "data", + help="colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner", + ) + parser.add_argument( + "--tokens-per-sample", + default=512, + type=int, + help="max number of total tokens over all segments" + " per sample for BERT dataset", + ) + parser.add_argument( + "--break-mode", default="doc", type=str, help="mode for breaking sentence" + ) + parser.add_argument("--shuffle-dataset", action="store_true", default=False) + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + self.seed = args.seed + + @classmethod + def load_dictionary(cls, filename): + return BertDictionary.load(filename) + + @classmethod + def build_dictionary( + cls, filenames, workers=1, threshold=-1, nwords=-1, padding_factor=8 + ): + d = BertDictionary() + for filename in filenames: + Dictionary.add_file_to_dictionary( + filename, d, tokenizer.tokenize_line, workers + ) + d.finalize(threshold=threshold, nwords=nwords, padding_factor=padding_factor) + return d + + @property + def target_dictionary(self): + return self.dictionary + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task.""" + paths = utils.split_paths(args.data) + assert len(paths) > 0 + dictionary = BertDictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + + return cls(args, dictionary) + + def load_dataset(self, split, epoch=1, combine=False): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + loaded_datasets = [] + + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + logger.info("data_path", data_path) + + for k in itertools.count(): + split_k = split + (str(k) if k > 0 else "") + path = os.path.join(data_path, split_k) + ds = indexed_dataset.make_dataset( + path, + impl=self.args.dataset_impl, + fix_lua_indexing=True, + dictionary=self.dictionary, + ) + + if ds is None: + if k > 0: + break + else: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, data_path) + ) + + with data_utils.numpy_seed(self.seed + k): + loaded_datasets.append( + BlockPairDataset( + ds, + self.dictionary, + ds.sizes, + self.args.tokens_per_sample, + break_mode=self.args.break_mode, + doc_break_size=1, + ) + ) + + logger.info( + "{} {} {} examples".format(data_path, split_k, len(loaded_datasets[-1])) + ) + + if not combine: + break + + if len(loaded_datasets) == 1: + dataset = loaded_datasets[0] + sizes = dataset.sizes + else: + dataset = ConcatDataset(loaded_datasets) + sizes = np.concatenate([ds.sizes for ds in loaded_datasets]) + + self.datasets[split] = MaskedLMDataset( + dataset=dataset, + sizes=sizes, + vocab=self.dictionary, + pad_idx=self.dictionary.pad(), + mask_idx=self.dictionary.mask(), + classif_token_idx=self.dictionary.cls(), + sep_token_idx=self.dictionary.sep(), + shuffle=self.args.shuffle_dataset, + seed=self.seed, + ) diff --git a/fairseq/fairseq/tasks/masked_lm.py b/fairseq/fairseq/tasks/masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..0c08132fb742de3d3d1beea0b8fce979ff408ebb --- /dev/null +++ b/fairseq/fairseq/tasks/masked_lm.py @@ -0,0 +1,255 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import logging +import os + +from omegaconf import MISSING, II, OmegaConf + +import numpy as np +from fairseq import utils +from fairseq.data import ( + Dictionary, + IdDataset, + MaskTokensDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + PrependTokenDataset, + RightPadDataset, + SortDataset, + TokenBlockDataset, + data_utils, +) +from fairseq.data.encoders.utils import get_whole_word_mask +from fairseq.data.shorten_dataset import maybe_shorten_dataset +from fairseq.dataclass import FairseqDataclass +from fairseq.tasks import FairseqTask, register_task + +from .language_modeling import SAMPLE_BREAK_MODE_CHOICES, SHORTEN_METHOD_CHOICES + + +logger = logging.getLogger(__name__) + + +@dataclass +class MaskedLMConfig(FairseqDataclass): + data: str = field( + default=MISSING, + metadata={ + "help": "colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner" + }, + ) + sample_break_mode: SAMPLE_BREAK_MODE_CHOICES = field( + default="none", + metadata={ + "help": 'If omitted or "none", fills each sample with tokens-per-sample ' + 'tokens. If set to "complete", splits samples only at the end ' + "of sentence, but may include multiple sentences per sample. " + '"complete_doc" is similar but respects doc boundaries. ' + 'If set to "eos", includes only one sentence per sample.' + }, + ) + tokens_per_sample: int = field( + default=1024, + metadata={"help": "max number of tokens per sample for LM dataset"}, + ) + mask_prob: float = field( + default=0.15, + metadata={"help": "probability of replacing a token with mask"}, + ) + leave_unmasked_prob: float = field( + default=0.1, + metadata={"help": "probability that a masked token is unmasked"}, + ) + random_token_prob: float = field( + default=0.1, + metadata={"help": "probability of replacing a token with a random token"}, + ) + freq_weighted_replacement: bool = field( + default=False, + metadata={"help": "sample random replacement words based on word frequencies"}, + ) + mask_whole_words: bool = field( + default=False, + metadata={"help": "mask whole words; you may also want to set --bpe"}, + ) + mask_multiple_length: int = field( + default=1, + metadata={"help": "repeat the mask indices multiple times"}, + ) + mask_stdev: float = field( + default=0.0, + metadata={"help": "stdev of the mask length"}, + ) + shorten_method: SHORTEN_METHOD_CHOICES = field( + default="none", + metadata={ + "help": "if not none, shorten sequences that exceed --tokens-per-sample" + }, + ) + shorten_data_split_list: str = field( + default="", + metadata={ + "help": "comma-separated list of dataset splits to apply shortening to, " + 'e.g., "train,valid" (default: all dataset splits)' + }, + ) + seed: int = II("common.seed") + + +@register_task("masked_lm", dataclass=MaskedLMConfig) +class MaskedLMTask(FairseqTask): + + cfg: MaskedLMConfig + + """Task for training masked language models (e.g., BERT, RoBERTa).""" + + def __init__(self, cfg: MaskedLMConfig, dictionary): + super().__init__(cfg) + self.dictionary = dictionary + + # add mask token + self.mask_idx = dictionary.add_symbol("<mask>") + + @classmethod + def setup_task(cls, cfg: MaskedLMConfig, **kwargs): + paths = utils.split_paths(cfg.data) + assert len(paths) > 0 + dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + return cls(cfg, dictionary) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.cfg.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + dataset = data_utils.load_indexed_dataset( + split_path, + self.source_dictionary, + combine=combine, + ) + if dataset is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + dataset = maybe_shorten_dataset( + dataset, + split, + self.cfg.shorten_data_split_list, + self.cfg.shorten_method, + self.cfg.tokens_per_sample, + self.cfg.seed, + ) + + # create continuous blocks of tokens + dataset = TokenBlockDataset( + dataset, + dataset.sizes, + self.cfg.tokens_per_sample - 1, # one less for <s> + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode=self.cfg.sample_break_mode, + ) + logger.info("loaded {} blocks from: {}".format(len(dataset), split_path)) + + # prepend beginning-of-sentence token (<s>, equiv. to [CLS] in BERT) + dataset = PrependTokenDataset(dataset, self.source_dictionary.bos()) + + # create masked input and targets + mask_whole_words = ( + get_whole_word_mask(self.args, self.source_dictionary) + if self.cfg.mask_whole_words + else None + ) + + src_dataset, tgt_dataset = MaskTokensDataset.apply_mask( + dataset, + self.source_dictionary, + pad_idx=self.source_dictionary.pad(), + mask_idx=self.mask_idx, + seed=self.cfg.seed, + mask_prob=self.cfg.mask_prob, + leave_unmasked_prob=self.cfg.leave_unmasked_prob, + random_token_prob=self.cfg.random_token_prob, + freq_weighted_replacement=self.cfg.freq_weighted_replacement, + mask_whole_words=mask_whole_words, + mask_multiple_length=self.cfg.mask_multiple_length, + mask_stdev=self.cfg.mask_stdev, + ) + + with data_utils.numpy_seed(self.cfg.seed): + shuffle = np.random.permutation(len(src_dataset)) + + self.datasets[split] = SortDataset( + NestedDictionaryDataset( + { + "id": IdDataset(), + "net_input": { + "src_tokens": RightPadDataset( + src_dataset, + pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": NumelDataset(src_dataset, reduce=False), + }, + "target": RightPadDataset( + tgt_dataset, + pad_idx=self.source_dictionary.pad(), + ), + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_dataset, reduce=True), + }, + sizes=[src_dataset.sizes], + ), + sort_order=[ + shuffle, + src_dataset.sizes, + ], + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, sort=True): + src_dataset = RightPadDataset( + TokenBlockDataset( + src_tokens, + src_lengths, + self.cfg.tokens_per_sample - 1, # one less for <s> + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode="eos", + ), + pad_idx=self.source_dictionary.pad(), + ) + src_dataset = PrependTokenDataset(src_dataset, self.source_dictionary.bos()) + src_dataset = NestedDictionaryDataset( + { + "id": IdDataset(), + "net_input": { + "src_tokens": src_dataset, + "src_lengths": NumelDataset(src_dataset, reduce=False), + }, + }, + sizes=src_lengths, + ) + if sort: + src_dataset = SortDataset(src_dataset, sort_order=[src_lengths]) + return src_dataset + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary diff --git a/fairseq/fairseq/tasks/multilingual_denoising.py b/fairseq/fairseq/tasks/multilingual_denoising.py new file mode 100644 index 0000000000000000000000000000000000000000..d1c914917feb5165aad7482cd1377f5f65b21635 --- /dev/null +++ b/fairseq/fairseq/tasks/multilingual_denoising.py @@ -0,0 +1,254 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +import numpy as np +from fairseq.data import ( + AppendTokenDataset, + ConcatDataset, + DenoisingDataset, + Dictionary, + PrependTokenDataset, + ResamplingDataset, + SortDataset, + TokenBlockDataset, + data_utils, +) +from fairseq.data.encoders.utils import get_whole_word_mask +from fairseq.tasks import register_task + +from .denoising import DenoisingTask + + +logger = logging.getLogger(__name__) + + +@register_task("multilingual_denoising") +class MultilingualDenoisingTask(DenoisingTask): + @staticmethod + def add_args(parser): + DenoisingTask.add_args(parser) + parser.add_argument( + "--multilang-sampling-alpha", + type=float, + default=1.0, + help="smoothing alpha for sample ratios across multiple datasets", + ) + parser.add_argument("--add-lang-token", default=False, action="store_true") + parser.add_argument( + "--langs", type=str, help="language ids we are considering", default=None + ) + parser.add_argument( + "--no-whole-word-mask-langs", + type=str, + default="", + metavar="N", + help="languages without spacing between words dont support whole word masking", + ) + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task.""" + paths = args.data.split(":") + assert len(paths) > 0 + dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + + data_path = paths[0] + if args.langs is None: + languages = sorted( + [ + name + for name in os.listdir(data_path) + if os.path.isdir(os.path.join(data_path, name)) + ] + ) + else: + languages = args.langs.split(",") + + if args.add_lang_token: + for lang in languages: + dictionary.add_symbol("[{}]".format(lang)) + + logger.info("dictionary: {} types".format(len(dictionary))) + if not hasattr(args, "shuffle_instance"): + args.shuffle_instance = False + return cls(args, dictionary) + + def __init__(self, args, dictionary): + super().__init__(args, dictionary) + self.dictionary = dictionary + self.seed = args.seed + + # add mask token + self.mask_idx = self.dictionary.add_symbol("<mask>") + self.langs = args.langs + self.args = args + + def _get_sample_prob(self, dataset_lens): + """ + Get smoothed sampling porbability by languages. This helps low resource + languages by upsampling them. + """ + prob = dataset_lens / dataset_lens.sum() + smoothed_prob = prob ** self.args.multilang_sampling_alpha + smoothed_prob = smoothed_prob / smoothed_prob.sum() + return smoothed_prob + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = self.args.data.split(":") + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + split_path = os.path.join(data_path, split) + + if self.langs is None: + languages = sorted( + [ + name + for name in os.listdir(data_path) + if os.path.isdir(os.path.join(data_path, name)) + ] + ) + else: + languages = self.langs.split(",") + for name in languages: + p = os.path.join(data_path, name) + assert os.path.exists(p), "data not found: {}".format(p) + + logger.info("Training on {0} languages: {1}".format(len(languages), languages)) + logger.info( + "Language to id mapping: ", {lang: id for id, lang in enumerate(languages)} + ) + + mask_whole_words = get_whole_word_mask(self.args, self.dictionary) + language_without_segmentations = self.args.no_whole_word_mask_langs.split(",") + lang_datasets = [] + for language in languages: + split_path = os.path.join(data_path, language, split) + + dataset = data_utils.load_indexed_dataset( + split_path, + self.source_dictionary, + self.args.dataset_impl, + combine=combine, + ) + if dataset is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + end_token = ( + self.source_dictionary.index("[{}]".format(language)) + if self.args.add_lang_token + else self.source_dictionary.eos() + ) + + # create continuous blocks of tokens + dataset = TokenBlockDataset( + dataset, + dataset.sizes, + self.args.tokens_per_sample - 2, # one less for <s> + pad=self.source_dictionary.pad(), + eos=end_token, + break_mode=self.args.sample_break_mode, + ) + logger.info("loaded {} blocks from: {}".format(len(dataset), split_path)) + + # prepend beginning-of-sentence token (<s>, equiv. to [CLS] in BERT) + dataset = PrependTokenDataset(dataset, self.source_dictionary.bos()) + dataset = AppendTokenDataset(dataset, end_token) + + lang_mask_whole_words = ( + mask_whole_words + if language not in language_without_segmentations + else None + ) + lang_dataset = DenoisingDataset( + dataset, + dataset.sizes, + self.dictionary, + self.mask_idx, + lang_mask_whole_words, + shuffle=self.args.shuffle_instance, + seed=self.seed, + args=self.args, + eos=None + if not self.args.add_lang_token + else self.source_dictionary.index("[{}]".format(language)), + ) + lang_datasets.append(lang_dataset) + + dataset_lengths = np.array( + [len(d) for d in lang_datasets], + dtype=float, + ) + logger.info( + "loaded total {} blocks for all languages".format( + int(dataset_lengths.sum()), + ) + ) + if split == self.args.train_subset: + # For train subset, additionally up or down sample languages. + sample_probs = self._get_sample_prob(dataset_lengths) + logger.info( + "Sample probability by language: {}".format( + { + lang: "{0:.4f}".format(sample_probs[id]) + for id, lang in enumerate(languages) + } + ) + ) + size_ratio = (sample_probs * dataset_lengths.sum()) / dataset_lengths + logger.info( + "Up/Down Sampling ratio by language: {}".format( + { + lang: "{0:.2f}".format(size_ratio[id]) + for id, lang in enumerate(languages) + } + ) + ) + + resampled_lang_datasets = [ + ResamplingDataset( + lang_datasets[i], + size_ratio=size_ratio[i], + seed=self.args.seed, + epoch=epoch, + replace=size_ratio[i] >= 1.0, + ) + for i, d in enumerate(lang_datasets) + ] + dataset = ConcatDataset( + resampled_lang_datasets, + ) + else: + dataset = ConcatDataset(lang_datasets) + lang_splits = [split] + for lang_id, lang_dataset in enumerate(lang_datasets): + split_name = split + "_" + languages[lang_id] + lang_splits.append(split_name) + self.datasets[split_name] = lang_dataset + + if split in self.args.valid_subset: + self.args.valid_subset = self.args.valid_subset.replace( + split, ",".join(lang_splits) + ) + + with data_utils.numpy_seed(self.args.seed + epoch): + shuffle = np.random.permutation(len(dataset)) + + self.datasets[split] = SortDataset( + dataset, + sort_order=[ + shuffle, + dataset.sizes, + ], + ) diff --git a/fairseq/fairseq/tasks/multilingual_masked_lm.py b/fairseq/fairseq/tasks/multilingual_masked_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..9e6ce4b8a2f77ed889a6e1451321a8e3ac21dc67 --- /dev/null +++ b/fairseq/fairseq/tasks/multilingual_masked_lm.py @@ -0,0 +1,338 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +import numpy as np +import torch +from fairseq import utils +from fairseq.data import ( + ConcatDataset, + Dictionary, + IdDataset, + MaskTokensDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + PadDataset, + PrependTokenDataset, + RawLabelDataset, + ResamplingDataset, + SortDataset, + TokenBlockDataset, + data_utils, + encoders, +) +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("multilingual_masked_lm") +class MultiLingualMaskedLMTask(LegacyFairseqTask): + """Task for training masked language models (e.g., BERT, RoBERTa).""" + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument( + "data", + help="colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner", + ) + parser.add_argument( + "--sample-break-mode", + default="complete", + choices=["none", "complete", "complete_doc", "eos"], + help='If omitted or "none", fills each sample with tokens-per-sample ' + 'tokens. If set to "complete", splits samples only at the end ' + "of sentence, but may include multiple sentences per sample. " + '"complete_doc" is similar but respects doc boundaries. ' + 'If set to "eos", includes only one sentence per sample.', + ) + parser.add_argument( + "--tokens-per-sample", + default=512, + type=int, + help="max number of total tokens over all segments " + "per sample for BERT dataset", + ) + parser.add_argument( + "--mask-prob", + default=0.15, + type=float, + help="probability of replacing a token with mask", + ) + parser.add_argument( + "--leave-unmasked-prob", + default=0.1, + type=float, + help="probability that a masked token is unmasked", + ) + parser.add_argument( + "--random-token-prob", + default=0.1, + type=float, + help="probability of replacing a token with a random token", + ) + parser.add_argument( + "--freq-weighted-replacement", + action="store_true", + help="sample random replacement words based on word frequencies", + ) + parser.add_argument( + "--mask-whole-words", + default=False, + action="store_true", + help="mask whole words; you may also want to set --bpe", + ) + parser.add_argument( + "--multilang-sampling-alpha", + type=float, + default=1.0, + help="smoothing alpha for sample rations across multiple datasets", + ) + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + self.seed = args.seed + + # add mask token + self.mask_idx = dictionary.add_symbol("<mask>") + + @classmethod + def setup_task(cls, args, **kwargs): + paths = utils.split_paths(args.data) + assert len(paths) > 0 + dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt")) + logger.info("dictionary: {} types".format(len(dictionary))) + return cls(args, dictionary) + + def _get_whole_word_mask(self): + # create masked input and targets + if self.args.mask_whole_words: + bpe = encoders.build_bpe(self.args) + if bpe is not None: + + def is_beginning_of_word(i): + if i < self.source_dictionary.nspecial: + # special elements are always considered beginnings + return True + tok = self.source_dictionary[i] + if tok.startswith("madeupword"): + return True + try: + return bpe.is_beginning_of_word(tok) + except ValueError: + return True + + mask_whole_words = torch.ByteTensor( + list(map(is_beginning_of_word, range(len(self.source_dictionary)))) + ) + else: + mask_whole_words = None + return mask_whole_words + + def _get_sample_prob(self, dataset_lens): + """ + Get smoothed sampling porbability by languages. This helps low resource + languages by upsampling them. + """ + prob = dataset_lens / dataset_lens.sum() + smoothed_prob = prob ** self.args.multilang_sampling_alpha + smoothed_prob = smoothed_prob / smoothed_prob.sum() + return smoothed_prob + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + languages = sorted( + name + for name in os.listdir(data_path) + if os.path.isdir(os.path.join(data_path, name)) + ) + + logger.info("Training on {0} languages: {1}".format(len(languages), languages)) + logger.info( + "Language to id mapping: ", {lang: id for id, lang in enumerate(languages)} + ) + + mask_whole_words = self._get_whole_word_mask() + lang_datasets = [] + for lang_id, language in enumerate(languages): + split_path = os.path.join(data_path, language, split) + + dataset = data_utils.load_indexed_dataset( + split_path, + self.source_dictionary, + self.args.dataset_impl, + combine=combine, + ) + if dataset is None: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, split_path) + ) + + # create continuous blocks of tokens + dataset = TokenBlockDataset( + dataset, + dataset.sizes, + self.args.tokens_per_sample - 1, # one less for <s> + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode=self.args.sample_break_mode, + ) + logger.info("loaded {} blocks from: {}".format(len(dataset), split_path)) + + # prepend beginning-of-sentence token (<s>, equiv. to [CLS] in BERT) + dataset = PrependTokenDataset(dataset, self.source_dictionary.bos()) + + src_dataset, tgt_dataset = MaskTokensDataset.apply_mask( + dataset, + self.source_dictionary, + pad_idx=self.source_dictionary.pad(), + mask_idx=self.mask_idx, + seed=self.args.seed, + mask_prob=self.args.mask_prob, + leave_unmasked_prob=self.args.leave_unmasked_prob, + random_token_prob=self.args.random_token_prob, + freq_weighted_replacement=self.args.freq_weighted_replacement, + mask_whole_words=mask_whole_words, + ) + + lang_dataset = NestedDictionaryDataset( + { + "net_input": { + "src_tokens": PadDataset( + src_dataset, + pad_idx=self.source_dictionary.pad(), + left_pad=False, + ), + "src_lengths": NumelDataset(src_dataset, reduce=False), + }, + "target": PadDataset( + tgt_dataset, + pad_idx=self.source_dictionary.pad(), + left_pad=False, + ), + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_dataset, reduce=True), + "lang_id": RawLabelDataset([lang_id] * src_dataset.sizes.shape[0]), + }, + sizes=[src_dataset.sizes], + ) + lang_datasets.append(lang_dataset) + + dataset_lengths = np.array( + [len(d) for d in lang_datasets], + dtype=float, + ) + logger.info( + "loaded total {} blocks for all languages".format( + dataset_lengths.sum(), + ) + ) + if split == self.args.train_subset: + # For train subset, additionally up or down sample languages. + sample_probs = self._get_sample_prob(dataset_lengths) + logger.info( + "Sample probability by language: ", + { + lang: "{0:.4f}".format(sample_probs[id]) + for id, lang in enumerate(languages) + }, + ) + size_ratio = (sample_probs * dataset_lengths.sum()) / dataset_lengths + logger.info( + "Up/Down Sampling ratio by language: ", + { + lang: "{0:.2f}".format(size_ratio[id]) + for id, lang in enumerate(languages) + }, + ) + + resampled_lang_datasets = [ + ResamplingDataset( + lang_datasets[i], + size_ratio=size_ratio[i], + seed=self.args.seed, + epoch=epoch, + replace=size_ratio[i] >= 1.0, + ) + for i, d in enumerate(lang_datasets) + ] + dataset = ConcatDataset(resampled_lang_datasets) + else: + dataset = ConcatDataset(lang_datasets) + lang_splits = [split] + for lang_id, lang_dataset in enumerate(lang_datasets): + split_name = split + "_" + languages[lang_id] + lang_splits.append(split_name) + self.datasets[split_name] = lang_dataset + + # [TODO]: This is hacky for now to print validation ppl for each + # language individually. Maybe need task API changes to allow it + # in more generic ways. + if split in self.args.valid_subset: + self.args.valid_subset = self.args.valid_subset.replace( + split, ",".join(lang_splits) + ) + + with data_utils.numpy_seed(self.args.seed + epoch): + shuffle = np.random.permutation(len(dataset)) + + self.datasets[split] = SortDataset( + dataset, + sort_order=[ + shuffle, + dataset.sizes, + ], + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, sort=True): + src_dataset = PadDataset( + TokenBlockDataset( + src_tokens, + src_lengths, + self.args.tokens_per_sample - 1, # one less for <s> + pad=self.source_dictionary.pad(), + eos=self.source_dictionary.eos(), + break_mode="eos", + ), + pad_idx=self.source_dictionary.pad(), + left_pad=False, + ) + src_dataset = PrependTokenDataset(src_dataset, self.source_dictionary.bos()) + src_dataset = NestedDictionaryDataset( + { + "id": IdDataset(), + "net_input": { + "src_tokens": src_dataset, + "src_lengths": NumelDataset(src_dataset, reduce=False), + }, + }, + sizes=src_lengths, + ) + if sort: + src_dataset = SortDataset(src_dataset, sort_order=[src_lengths]) + return src_dataset + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary diff --git a/fairseq/fairseq/tasks/multilingual_translation.py b/fairseq/fairseq/tasks/multilingual_translation.py new file mode 100644 index 0000000000000000000000000000000000000000..4f85ab4832a6c7cbe57a99a3efc6987125d956fc --- /dev/null +++ b/fairseq/fairseq/tasks/multilingual_translation.py @@ -0,0 +1,462 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import logging +import os +from collections import OrderedDict +from argparse import ArgumentError + +import torch +from fairseq import metrics, options, utils +from fairseq.data import ( + Dictionary, + LanguagePairDataset, + RoundRobinZipDatasets, + TransformEosLangPairDataset, +) +from fairseq.models import FairseqMultiModel +from fairseq.tasks.translation import load_langpair_dataset + +from . import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +def _lang_token(lang: str): + return "__{}__".format(lang) + + +def _lang_token_index(dic: Dictionary, lang: str): + """Return language token index.""" + idx = dic.index(_lang_token(lang)) + assert idx != dic.unk_index, "cannot find language token for lang {}".format(lang) + return idx + + +@register_task("multilingual_translation") +class MultilingualTranslationTask(LegacyFairseqTask): + """A task for training multiple translation models simultaneously. + + We iterate round-robin over batches from multiple language pairs, ordered + according to the `--lang-pairs` argument. + + The training loop is roughly: + + for i in range(len(epoch)): + for lang_pair in args.lang_pairs: + batch = next_batch_for_lang_pair(lang_pair) + loss = criterion(model_for_lang_pair(lang_pair), batch) + loss.backward() + optimizer.step() + + In practice, `next_batch_for_lang_pair` is abstracted in a FairseqDataset + (e.g., `RoundRobinZipDatasets`) and `model_for_lang_pair` is a model that + implements the `FairseqMultiModel` interface. + + During inference it is required to specify a single `--source-lang` and + `--target-lang`, which indicates the inference langauge direction. + `--lang-pairs`, `--encoder-langtok`, `--decoder-langtok` have to be set to + the same value as training. + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + parser.add_argument('data', metavar='DIR', help='path to data directory') + parser.add_argument('--lang-pairs', default=None, metavar='PAIRS', + help='comma-separated list of language pairs (in training order): en-de,en-fr,de-fr') + parser.add_argument('-s', '--source-lang', default=None, metavar='SRC', + help='source language (only needed for inference)') + parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET', + help='target language (only needed for inference)') + parser.add_argument('--left-pad-source', default='True', type=str, metavar='BOOL', + help='pad the source on the left (default: True)') + parser.add_argument('--left-pad-target', default='False', type=str, metavar='BOOL', + help='pad the target on the left (default: False)') + try: + parser.add_argument('--max-source-positions', default=1024, type=int, metavar='N', + help='max number of tokens in the source sequence') + parser.add_argument('--max-target-positions', default=1024, type=int, metavar='N', + help='max number of tokens in the target sequence') + except ArgumentError: + # this might have already been defined. Once we transition this to hydra it should be fine to add it here. + pass + parser.add_argument('--upsample-primary', default=1, type=int, + help='amount to upsample primary dataset') + parser.add_argument('--encoder-langtok', default=None, type=str, choices=['src', 'tgt'], + metavar='SRCTGT', + help='replace beginning-of-sentence in source sentence with source or target ' + 'language token. (src/tgt)') + parser.add_argument('--decoder-langtok', action='store_true', + help='replace beginning-of-sentence in target sentence with target language token') + # fmt: on + + def __init__(self, args, dicts, training): + super().__init__(args) + self.dicts = dicts + self.training = training + if training: + self.lang_pairs = args.lang_pairs + else: + self.lang_pairs = ["{}-{}".format(args.source_lang, args.target_lang)] + # eval_lang_pairs for multilingual translation is usually all of the + # lang_pairs. However for other multitask settings or when we want to + # optimize for certain languages we want to use a different subset. Thus + # the eval_lang_pairs class variable is provided for classes that extend + # this class. + self.eval_lang_pairs = self.lang_pairs + # model_lang_pairs will be used to build encoder-decoder model pairs in + # models.build_model(). This allows multitask type of sub-class can + # build models other than the input lang_pairs + self.model_lang_pairs = self.lang_pairs + self.langs = list(dicts.keys()) + + @classmethod + def setup_task(cls, args, **kwargs): + dicts, training = cls.prepare(args, **kwargs) + return cls(args, dicts, training) + + @classmethod + def update_args(cls, args): + args.left_pad_source = utils.eval_bool(args.left_pad_source) + args.left_pad_target = utils.eval_bool(args.left_pad_target) + + if args.lang_pairs is None: + raise ValueError( + "--lang-pairs is required. List all the language pairs in the training objective." + ) + if isinstance(args.lang_pairs, str): + args.lang_pairs = args.lang_pairs.split(",") + + @classmethod + def prepare(cls, args, **kargs): + cls.update_args(args) + sorted_langs = sorted( + list({x for lang_pair in args.lang_pairs for x in lang_pair.split("-")}) + ) + if args.source_lang is not None or args.target_lang is not None: + training = False + else: + training = True + + # load dictionaries + dicts = OrderedDict() + for lang in sorted_langs: + paths = utils.split_paths(args.data) + assert len(paths) > 0 + dicts[lang] = cls.load_dictionary( + os.path.join(paths[0], "dict.{}.txt".format(lang)) + ) + if len(dicts) > 0: + assert dicts[lang].pad() == dicts[sorted_langs[0]].pad() + assert dicts[lang].eos() == dicts[sorted_langs[0]].eos() + assert dicts[lang].unk() == dicts[sorted_langs[0]].unk() + if args.encoder_langtok is not None or args.decoder_langtok: + for lang_to_add in sorted_langs: + dicts[lang].add_symbol(_lang_token(lang_to_add)) + logger.info("[{}] dictionary: {} types".format(lang, len(dicts[lang]))) + return dicts, training + + def get_encoder_langtok(self, src_lang, tgt_lang): + if self.args.encoder_langtok is None: + return self.dicts[src_lang].eos() + if self.args.encoder_langtok == "src": + return _lang_token_index(self.dicts[src_lang], src_lang) + else: + return _lang_token_index(self.dicts[src_lang], tgt_lang) + + def get_decoder_langtok(self, tgt_lang): + if not self.args.decoder_langtok: + return self.dicts[tgt_lang].eos() + return _lang_token_index(self.dicts[tgt_lang], tgt_lang) + + def alter_dataset_langtok( + self, + lang_pair_dataset, + src_eos=None, + src_lang=None, + tgt_eos=None, + tgt_lang=None, + ): + if self.args.encoder_langtok is None and not self.args.decoder_langtok: + return lang_pair_dataset + + new_src_eos = None + if ( + self.args.encoder_langtok is not None + and src_eos is not None + and src_lang is not None + and tgt_lang is not None + ): + new_src_eos = self.get_encoder_langtok(src_lang, tgt_lang) + else: + src_eos = None + + new_tgt_bos = None + if self.args.decoder_langtok and tgt_eos is not None and tgt_lang is not None: + new_tgt_bos = self.get_decoder_langtok(tgt_lang) + else: + tgt_eos = None + + return TransformEosLangPairDataset( + lang_pair_dataset, + src_eos=src_eos, + new_src_eos=new_src_eos, + tgt_bos=tgt_eos, + new_tgt_bos=new_tgt_bos, + ) + + def load_dataset(self, split, epoch=1, **kwargs): + """Load a dataset split.""" + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + def language_pair_dataset(lang_pair): + src, tgt = lang_pair.split("-") + langpair_dataset = load_langpair_dataset( + data_path, + split, + src, + self.dicts[src], + tgt, + self.dicts[tgt], + combine=True, + dataset_impl=self.args.dataset_impl, + upsample_primary=self.args.upsample_primary, + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + max_source_positions=self.args.max_source_positions, + max_target_positions=self.args.max_target_positions, + ) + return self.alter_dataset_langtok( + langpair_dataset, + src_eos=self.dicts[src].eos(), + src_lang=src, + tgt_eos=self.dicts[tgt].eos(), + tgt_lang=tgt, + ) + + self.datasets[split] = RoundRobinZipDatasets( + OrderedDict( + [ + (lang_pair, language_pair_dataset(lang_pair)) + for lang_pair in self.lang_pairs + ] + ), + eval_key=None + if self.training + else "%s-%s" % (self.args.source_lang, self.args.target_lang), + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + if constraints is not None: + raise NotImplementedError( + "Constrained decoding with the multilingual_translation task is not supported" + ) + + lang_pair = "%s-%s" % (self.args.source_lang, self.args.target_lang) + return RoundRobinZipDatasets( + OrderedDict( + [ + ( + lang_pair, + self.alter_dataset_langtok( + LanguagePairDataset( + src_tokens, src_lengths, self.source_dictionary + ), + src_eos=self.source_dictionary.eos(), + src_lang=self.args.source_lang, + tgt_eos=self.target_dictionary.eos(), + tgt_lang=self.args.target_lang, + ), + ) + ] + ), + eval_key=lang_pair, + ) + + def build_model(self, args): + def check_args(): + messages = [] + if ( + len(set(self.args.lang_pairs).symmetric_difference(args.lang_pairs)) + != 0 + ): + messages.append( + "--lang-pairs should include all the language pairs {}.".format( + args.lang_pairs + ) + ) + if self.args.encoder_langtok != args.encoder_langtok: + messages.append( + "--encoder-langtok should be {}.".format(args.encoder_langtok) + ) + if self.args.decoder_langtok != args.decoder_langtok: + messages.append( + "--decoder-langtok should {} be set.".format( + "" if args.decoder_langtok else "not" + ) + ) + + if len(messages) > 0: + raise ValueError(" ".join(messages)) + + # Update args -> the fact that the constructor here + # changes the args object doesn't mean you get the same one here + self.update_args(args) + + # Check if task args are consistant with model args + check_args() + + from fairseq import models + + model = models.build_model(args, self) + if not isinstance(model, FairseqMultiModel): + raise ValueError( + "MultilingualTranslationTask requires a FairseqMultiModel architecture" + ) + return model + + def _per_lang_pair_train_loss( + self, lang_pair, model, update_num, criterion, sample, optimizer, ignore_grad + ): + loss, sample_size, logging_output = criterion( + model.models[lang_pair], sample[lang_pair] + ) + if ignore_grad: + loss *= 0 + optimizer.backward(loss) + return loss, sample_size, logging_output + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + model.train() + from collections import defaultdict + + agg_loss, agg_sample_size, agg_logging_output = 0.0, 0.0, defaultdict(float) + curr_lang_pairs = [ + lang_pair + for lang_pair in self.model_lang_pairs + if sample[lang_pair] is not None and len(sample[lang_pair]) != 0 + ] + + for idx, lang_pair in enumerate(curr_lang_pairs): + + def maybe_no_sync(): + if ( + self.args.distributed_world_size > 1 + and hasattr(model, "no_sync") + and idx < len(curr_lang_pairs) - 1 + ): + return model.no_sync() + else: + return contextlib.ExitStack() # dummy contextmanager + + with maybe_no_sync(): + loss, sample_size, logging_output = self._per_lang_pair_train_loss( + lang_pair, + model, + update_num, + criterion, + sample, + optimizer, + ignore_grad, + ) + agg_loss += loss.detach().item() + # TODO make summing of the sample sizes configurable + agg_sample_size += sample_size + for k in logging_output: + agg_logging_output[k] += logging_output[k] + agg_logging_output[f"{lang_pair}:{k}"] += logging_output[k] + return agg_loss, agg_sample_size, agg_logging_output + + def _per_lang_pair_valid_loss(self, lang_pair, model, criterion, sample): + return criterion(model.models[lang_pair], sample[lang_pair]) + + def valid_step(self, sample, model, criterion): + model.eval() + with torch.no_grad(): + from collections import defaultdict + + agg_loss, agg_sample_size, agg_logging_output = 0.0, 0.0, defaultdict(float) + for lang_pair in self.eval_lang_pairs: + if ( + lang_pair not in sample + or sample[lang_pair] is None + or len(sample[lang_pair]) == 0 + ): + continue + loss, sample_size, logging_output = self._per_lang_pair_valid_loss( + lang_pair, model, criterion, sample + ) + agg_loss += loss.data.item() + # TODO make summing of the sample sizes configurable + agg_sample_size += sample_size + for k in logging_output: + agg_logging_output[k] += logging_output[k] + agg_logging_output[f"{lang_pair}:{k}"] += logging_output[k] + return agg_loss, agg_sample_size, agg_logging_output + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + if self.args.decoder_langtok: + bos_token = _lang_token_index( + self.target_dictionary, self.args.target_lang + ) + else: + bos_token = self.target_dictionary.eos() + return generator.generate( + models, + sample, + prefix_tokens=prefix_tokens, + constraints=constraints, + bos_token=bos_token, + ) + + def reduce_metrics(self, logging_outputs, criterion): + with metrics.aggregate(): + # pass 'sample_size', 'nsentences', 'ntokens' stats to fairseq_task + super().reduce_metrics(logging_outputs, criterion) + for k in ["sample_size", "nsentences", "ntokens"]: + metrics.log_scalar(k, sum(l[k] for l in logging_outputs)) + + @property + def source_dictionary(self): + if self.training: + return next(iter(self.dicts.values())) + else: + return self.dicts[self.args.source_lang] + + @property + def target_dictionary(self): + if self.training: + return next(iter(self.dicts.values())) + else: + return self.dicts[self.args.target_lang] + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + if len(self.datasets.values()) == 0: + return { + "%s-%s" + % (self.args.source_lang, self.args.target_lang): ( + self.args.max_source_positions, + self.args.max_target_positions, + ) + } + return OrderedDict( + [ + (key, (self.args.max_source_positions, self.args.max_target_positions)) + for split in self.datasets.keys() + for key in self.datasets[split].datasets.keys() + ] + ) diff --git a/fairseq/fairseq/tasks/online_backtranslation.py b/fairseq/fairseq/tasks/online_backtranslation.py new file mode 100644 index 0000000000000000000000000000000000000000..2e27ca237cde1980b2c3ca497e12f458da230c37 --- /dev/null +++ b/fairseq/fairseq/tasks/online_backtranslation.py @@ -0,0 +1,682 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import json +import logging +import math +import os +from argparse import Namespace +from collections import OrderedDict, defaultdict +from pathlib import Path +from typing import Dict, Sequence, Tuple +from argparse import ArgumentError + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +import fairseq +from fairseq import metrics, options, utils +from fairseq.data import ( + FairseqDataset, + LanguagePairDataset, + NoisingDataset, + PrependTokenDataset, + RoundRobinZipDatasets, + TransformEosLangPairDataset, + data_utils, + encoders, +) +from fairseq.sequence_generator import SequenceGenerator +from fairseq.tasks import register_task +from fairseq.tasks.translation import TranslationTask, load_langpair_dataset + +logger = logging.getLogger(__name__) + + +class PiecewiseLinearFn: + """Piecewise linear function. Can be configured with a string.""" + + def __init__(self, pieces: Sequence[Tuple[int, float]]): + assert pieces == sorted( + pieces + ), f"PiecewiseLinearFn configuration should be sorted, received: {pieces}" + + self.pieces = pieces + + def __call__(self, x: int) -> float: + for i, (x_a, y_a) in enumerate(self.pieces[:-1]): + x_b, y_b = self.pieces[i + 1] + if x_a <= x <= x_b: + return y_a + (x - x_a) * (y_b - y_a) / (x_b - x_a) + + return self.pieces[-1][1] + + @staticmethod + def from_string(configuration: str) -> "PiecewiseLinearFn": + """ + Parse the configuration of lambda coefficient (for scheduling). + x = "3" # lambda will be a constant equal to x + x = "0:1,1000:0" # lambda will start from 1 and linearly decrease + # to 0 during the first 1000 iterations + x = "0:0,1000:0,2000:1" # lambda will be equal to 0 for the first 1000 + # iterations, then will linearly increase to 1 until iteration 2000 + """ + if isinstance(configuration, float): + return PiecewiseLinearFn([(0, configuration)]) + + try: + parts = configuration.split(",") + if len(parts) == 1: + v = float(configuration) + return PiecewiseLinearFn([(0, v)]) + + split = [s.split(":") for s in parts] + pieces = [(int(t), float(v)) for t, v in split] + return PiecewiseLinearFn(pieces) + except Exception: + raise ValueError( + f"Invalid PiecewiseLinearFn configuration: {configuration!r}" + ) + + @staticmethod + def one() -> "PiecewiseLinearFn": + return PiecewiseLinearFn([(0, 1.0)]) + + +@register_task("online_backtranslation") +class OnlineBackTranslationTask(TranslationTask): + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + # Generic translation args + parser.add_argument('data', help='colon separated path to data directories list, \ + will be iterated upon during epochs in round-robin manner; \ + however, valid and test data are always in the first directory to \ + avoid the need for repeating them in all directories') + parser.add_argument('--mono-langs', metavar='MONO_LANGS', + help='monolingual languages for training') + parser.add_argument('--valid-lang-pairs', default=None, metavar='VALID_LANG_PAIRS', + help='language pairs for validation') + parser.add_argument('--load-alignments', action='store_true', + help='load the binarized alignments') + parser.add_argument('--left-pad-source', default='False', type=str, metavar='BOOL', + help='pad the source on the left') + parser.add_argument('--left-pad-target', default='False', type=str, metavar='BOOL', + help='pad the target on the left') + parser.add_argument('--upsample-primary', default=1, type=int, + help='amount to upsample primary dataset') + try: + parser.add_argument('--max-source-positions', default=1024, type=int, metavar='N', + help='max number of tokens in the source sequence') + parser.add_argument('--max-target-positions', default=1024, type=int, metavar='N', + help='max number of tokens in the target sequence') + except ArgumentError: + # this might have already been defined. Once we transition this to hydra it should be fine to add it here. + pass + parser.add_argument('--truncate-source', action='store_true', default=False, + help='truncate source to max-source-positions') + parser.add_argument('--num-batch-buckets', default=0, type=int, metavar='N', + help='if >0, then bucket source and target lengths into N ' + 'buckets and pad accordingly; this is useful on TPUs ' + 'to minimize the number of compilations') + + # Denoising args + parser.add_argument('--max-word-shuffle-distance', default=3.0, type=float, metavar='N', + help='maximum word shuffle distance for denoising autoencoding data generation') + parser.add_argument('--word-dropout-prob', default=0.1, type=float, metavar='N', + help='word dropout probability for denoising autoencoding data generation') + parser.add_argument('--word-blanking-prob', default=0.2, type=float, metavar='N', + help='word blanking probability for denoising autoencoding data generation') + + # Backtranslation args + parser.add_argument('--lambda-bt', default="1.0", type=str, metavar='N', + help='back-translation weight') + parser.add_argument('--lambda-dae', default="1.0", type=str, metavar='N', + help='denoising auto-encoder weight') + + # Evaluation args + parser.add_argument('--generate-one-by-one', action='store_true', + help='generate one sentence at a time for backtranslation') + + parser.add_argument('--eval-bleu', action='store_true', + help='evaluation with BLEU scores') + parser.add_argument('--eval-bleu-detok', type=str, default="space", + help='detokenize before computing BLEU (e.g., "moses"); ' + 'required if using --eval-bleu; use "space" to ' + 'disable detokenization; see fairseq.data.encoders ' + 'for other options') + parser.add_argument('--eval-bleu-detok-args', type=str, metavar='JSON', + help='args for building the tokenizer, if needed') + parser.add_argument('--eval-tokenized-bleu', action='store_true', default=False, + help='compute tokenized BLEU instead of sacrebleu') + parser.add_argument('--eval-bleu-remove-bpe', nargs='?', const='@@ ', default=None, + help='remove BPE before computing BLEU') + parser.add_argument('--eval-bleu-args', type=str, metavar='JSON', + help='generation args for BLUE scoring, ' + 'e.g., \'{"beam": 4, "lenpen": 0.6}\'') + parser.add_argument('--eval-bleu-print-samples', action='store_true', + help='print sample generations during validation') + # fmt: on + + def __init__(self, args, common_dict, mono_langs, valid_lang_pairs): + super().__init__(args, common_dict, common_dict) + self.common_dict = common_dict + self.mono_langs = mono_langs + self.valid_lang_pairs = valid_lang_pairs + + self.SHOW_SAMPLES_INTERVAL = 1000 + # Start by showing samples + self._show_samples_ctr = self.SHOW_SAMPLES_INTERVAL + self.SHOW_SAMPLES_NUMBER = 5 + self.lambda_bt = PiecewiseLinearFn.from_string(args.lambda_bt) + self.lambda_dae = PiecewiseLinearFn.from_string(args.lambda_dae) + + self.args = args + self.data = utils.split_paths(self.args.data) + if len(self.data) == 1: + shards = list(Path(self.data[0]).glob("shard*")) + if len(shards) > 0: + # keep this as strings, since it can also be a manifold path + old_data = self.data + self.data = [str(shard) for shard in shards] + logging.warning(f"Expanded data directory {old_data} to {self.data}") + + @classmethod + def setup_task(cls, args, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + args.left_pad_source = options.eval_bool(args.left_pad_source) + args.left_pad_target = options.eval_bool(args.left_pad_target) + + paths = utils.split_paths(args.data) + assert len(paths) > 0 + assert args.mono_langs is not None + + mono_langs = args.mono_langs.split(",") + valid_lang_pairs = args.valid_lang_pairs.split(",") + + # load dictionary + dict_path = os.path.join(paths[0], "dict.txt") + common_dict = cls.load_dictionary(dict_path) + + return cls(args, common_dict, mono_langs, valid_lang_pairs) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs) -> FairseqDataset: + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if split == "train": + data_path = self.data[(epoch - 1) % len(self.data)] + dataset = self.load_train_dataset(data_path) + else: + # valid/test should always be the same. + dataset = self.load_translation_dataset(split, self.data[0]) + + self.datasets[split] = dataset + return dataset + + def load_train_dataset(self, data_path: str) -> FairseqDataset: + """The training dataset is made of backtranslation dataset and denoising dataset.""" + data = [] + for lang in self.mono_langs: + train_path = os.path.join(data_path, lang, "train") + # TODO: could we do the BT using denoise sample ? + # this would half the data loading work + data.append((f"{lang}-BT", self.load_bt_dataset(train_path, lang))) + data.append( + (f"{lang}-DENOISE", self.load_denoise_dataset(train_path, lang)) + ) + + return RoundRobinZipDatasets(OrderedDict(data)) + + def _langpair_dataset( + self, src: FairseqDataset, tgt: FairseqDataset + ) -> LanguagePairDataset: + return LanguagePairDataset( + src, + src.sizes, + self.dictionary, + tgt=tgt, + tgt_sizes=tgt.sizes, + tgt_dict=self.dictionary, + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + # TODO: should we shuffle ? we are already sorting batch by sizes so ? + # shuffle=True, + ) + + def _prepend_lang_bos_to_target( + self, dataset: LanguagePairDataset, lang: str + ) -> LanguagePairDataset: + bos = _lang_token_index(self.dictionary, lang) + return TransformEosLangPairDataset( + dataset, + src_eos=self.dictionary.eos(), + new_src_eos=self.dictionary.eos(), + tgt_bos=self.dictionary.eos(), + new_tgt_bos=bos, + ) + + def load_bt_dataset(self, data_path: str, lang: str) -> FairseqDataset: + """The BT dataset is generated with (tgt, tgt) pairs. + The actual translation to a (generated_src, tgt) pair + is done on the fly during training. + """ + mono_dataset = data_utils.load_indexed_dataset( + data_path, self.common_dict, self.args.dataset_impl + ) + assert mono_dataset is not None, f"No dataset found for {lang}" + + mono_dataset_src = PrependTokenDataset( + mono_dataset, _lang_token_index(self.dictionary, lang) + ) + + mono_dataset_bt = self._langpair_dataset(mono_dataset_src, mono_dataset) + logger.info( + f"mono_lang = {lang} " + f"lang token index = {_lang_token_index(self.dictionary, lang)} " + f"lang token = {_lang_token(lang)}" + ) + + mono_dataset_bt = self._prepend_lang_bos_to_target(mono_dataset_bt, lang) + return mono_dataset_bt + + def load_denoise_dataset(self, data_path: str, lang: str) -> FairseqDataset: + """Classic denoising dataset""" + dataset = data_utils.load_indexed_dataset( + data_path, self.common_dict, self.args.dataset_impl + ) + noisy_dataset = NoisingDataset( + dataset, + self.dictionary, + seed=1, + max_word_shuffle_distance=self.args.max_word_shuffle_distance, + word_dropout_prob=self.args.word_dropout_prob, + word_blanking_prob=self.args.word_blanking_prob, + ) + noisy_dataset = PrependTokenDataset( + noisy_dataset, _lang_token_index(self.dictionary, lang) + ) + + clean_dataset = data_utils.load_indexed_dataset( + data_path, self.common_dict, self.args.dataset_impl + ) + denoising_dataset = self._langpair_dataset(noisy_dataset, clean_dataset) + denoising_dataset = self._prepend_lang_bos_to_target(denoising_dataset, lang) + return denoising_dataset + + def load_translation_dataset( + self, split: str, data_path: str, combine: bool = False + ): + # only judging with one language pair for the moment, + # since ConcatDataset doesn't work as expected + assert len(self.valid_lang_pairs) == 1, "For now..." + valid_lang_pair = self.valid_lang_pairs[0] + src, tgt = valid_lang_pair.split("-") + + # use the same function than TranslationTask + src_tgt_dt = load_langpair_dataset( + data_path, + split, + src, + self.common_dict, + tgt, + self.common_dict, + combine=combine, + dataset_impl=self.args.dataset_impl, + upsample_primary=self.args.upsample_primary, + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + max_source_positions=self.args.max_source_positions, + max_target_positions=self.args.max_target_positions, + load_alignments=self.args.load_alignments, + truncate_source=self.args.truncate_source, + num_buckets=self.args.num_batch_buckets, + shuffle=(split != "test"), + prepend_bos_src=_lang_token_index(self.dictionary, src), + ) + + src_tgt_eos_dt = self._prepend_lang_bos_to_target(src_tgt_dt, tgt) + src_tgt_eos_dt.args = self.args + return src_tgt_eos_dt + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + raise NotImplementedError + + def build_model(self, args): + # torch.autograd.set_detect_anomaly(True) + model = super().build_model(args) + + add_secial_tokens_to_dict_and_model(self.common_dict, model, self.mono_langs) + + self.sequence_generators = {} + for mono_lang in self.mono_langs: + self.sequence_generators[mono_lang] = SequenceGenerator( + [model], + tgt_dict=self.dictionary, + beam_size=1, + max_len_a=1.3, + max_len_b=5, + min_len=5, + # keep 1 to be able to prepend bos + max_len=model.max_decoder_positions() - 1, + ) + + if getattr(args, "eval_bleu", False): + assert getattr(args, "eval_bleu_detok", None) is not None, ( + "--eval-bleu-detok is required if using --eval-bleu; " + "try --eval-bleu-detok=moses (or --eval-bleu-detok=space " + "to disable detokenization, e.g., when using sentencepiece)" + ) + detok_args = json.loads(getattr(args, "eval_bleu_detok_args", "{}") or "{}") + self.tokenizer = encoders.build_tokenizer( + Namespace( + tokenizer=getattr(args, "eval_bleu_detok", None), **detok_args + ) + ) + + gen_args = json.loads(getattr(args, "eval_bleu_args", "{}") or "{}") + self.bleu_sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + + return model + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.args.max_source_positions, self.args.max_target_positions) + + @property + def dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.common_dict + + def display_samples_once_in_a_while(self, smp, mono_lang, other_lang): + self._show_samples_ctr += 1 + if self._show_samples_ctr < self.SHOW_SAMPLES_INTERVAL: + return + self._show_samples_ctr = 0 + + ln = smp["net_input"]["src_tokens"].shape[0] + + logger.info( + f"(r:{self.args.distributed_rank}) : " + f"{other_lang} ---> {mono_lang} " + f"({other_lang} was generated by back-translation.) {ln} samples" + ) + + for i in range(min(ln, self.SHOW_SAMPLES_NUMBER)): + src_tokens = smp["net_input"]["src_tokens"][i] + tgt_tokens = smp["target"][i] + + src_str = self.dictionary.string(src_tokens, "sentencepiece") + tgt_str = self.dictionary.string(tgt_tokens, "sentencepiece") + logger.info( + f"\n{i}\t\t[{other_lang} generated] {src_str}\n" + f"\t\t[{mono_lang} original ] {tgt_str}\n" + f"\t\t[ src tokens] {src_tokens}\n" + ) + + def backtranslate_sample(self, smp, orig_lang, other_lang) -> None: + """ + * WARNING: smp is modified in place. + * At the start of this function, `smp` has the same input and target: + |--------------------------------------------------------| + | smp['net_input']['src_tokens'] | smp['target'] | + | (from data) __en__ hello world | __en__ hello world | + |--------------------------------------------------------| + + * We call generator.generate(smp, bos_token = token("ro")), + and copy the result as input + * At the end, `smp` has the translation to other language. + |--------------------------------------------------------| + | smp['net_input']['src_tokens'] | smp['target'] | + | (generated) __ro__ salut lume | __en__ hello world | + |--------------------------------------------------------| + + """ + bos_token = _lang_token_index(self.dictionary, other_lang) + generated = self.sequence_generators[orig_lang].generate( + models=[], sample=smp, bos_token=bos_token + ) + + max_lngth = max([gn[0]["tokens"].size(0) for gn in generated]) + net_input = smp["net_input"] + n_src_tokens = torch.empty( + size=(len(generated), max_lngth + 1), dtype=net_input["src_tokens"].dtype + ) + n_src_lengths = torch.empty( + len(generated), dtype=net_input["src_lengths"].dtype + ) + + for i, gn in enumerate(generated): + tokens = gn[0]["tokens"] + tokens_size = tokens.size(0) + padding_needed = max_lngth - tokens_size + tokens = torch.cat([tokens.new([bos_token]), tokens]) + tokens = F.pad(tokens, (0, padding_needed), value=self.dictionary.pad()) + n_src_tokens[i] = tokens + n_src_lengths[i] = tokens_size + 1 + + device = net_input["src_tokens"].device + # This seems to be important + del net_input["src_tokens"] + del net_input["src_lengths"] + net_input["src_tokens"] = n_src_tokens.to(device) + net_input["src_lengths"] = n_src_lengths.to(device) + + def generate(self, smp, model): + model.eval() + orig_lang = ( + self.dictionary[smp["net_input"]["src_tokens"][0][0]] + .replace(" ", "") + .replace("_", "") + ) + bos_token = smp["net_input"]["prev_output_tokens"][0][0] + with torch.no_grad(): + generated = self.sequence_generators[orig_lang].generate( + models=[model], sample=smp, bos_token=bos_token + ) + return generated + + def get_other_lang(self, lang): + # TODO: allow more complex mapping + if lang != self.mono_langs[0]: + return self.mono_langs[0] + if len(self.mono_langs) == 2: + return self.mono_langs[1] + return self.mono_langs[np.random.randint(1, len(self.mono_langs))] + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + + model.train() + model.set_num_updates(update_num) + + agg_loss, agg_sample_size = 0.0, 0.0 + agg_logging_output: Dict[str, float] = defaultdict(float) + + dataset_keys = self.datasets["train"].datasets.keys() + + weights = { + "BT": self.lambda_bt(update_num), + "DENOISE": self.lambda_dae(update_num), + } + log_keys = {"BT": "bt_", "DENOISE": "dae_"} + + for dataset_key in dataset_keys: + smp = sample[dataset_key] + mono_lang, task_subtype = dataset_key.split("-") + if weights[task_subtype] == 0: + continue + + if task_subtype == "BT": + with torch.autograd.profiler.record_function("backtranslation"): + model.eval() + # TODO: Could we translate to several language at once ? + # this would allow to share encoder_out and maximize GPU usage. + other_lang = self.get_other_lang(mono_lang) + self.backtranslate_sample(smp, mono_lang, other_lang) + self.display_samples_once_in_a_while(smp, mono_lang, other_lang) + model.train() + + # Like in FairseqTask.train_step + with torch.autograd.profiler.record_function("forward"): + loss, sample_size, logging_output = criterion(model, smp) + loss *= weights[task_subtype] + if ignore_grad: + loss *= 0 + with torch.autograd.profiler.record_function("backward"): + optimizer.backward(loss) + + agg_loss += loss.item() + agg_sample_size += sample_size + for k in logging_output: + agg_logging_output[log_keys[task_subtype] + k] += logging_output[k] + agg_logging_output[k] += logging_output[k] + + return agg_loss, agg_sample_size, agg_logging_output + + def get_bos_token_from_sample(self, sample): + net_input = sample["net_input"] + source_lang_token_id = torch.unique(net_input["src_tokens"][:, 0]).item() + source_lang_token = self.dictionary[source_lang_token_id].replace("_", "") + target_lang_token_id = _lang_token_index( + self.dictionary, self.get_other_lang(source_lang_token) + ) + + return target_lang_token_id + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + bt_sample_size = sum(x.get("bt_sample_size", 0) for x in logging_outputs) + if bt_sample_size: + bt_loss_sum = sum(x.get("bt_loss", 0) for x in logging_outputs) + bt_loss_sum *= 1 / bt_sample_size / math.log(2) + metrics.log_scalar("bt_loss", bt_loss_sum, bt_sample_size, round=3) + + bt_nll_loss_sum = sum(x.get("bt_nll_loss", 0) for x in logging_outputs) + bt_ntokens = sum(x.get("bt_ntokens", 0) for x in logging_outputs) + bt_nll_loss_sum *= 1 / bt_ntokens / math.log(2) + metrics.log_scalar("bt_nll_loss", bt_nll_loss_sum, bt_ntokens, round=3) + metrics.log_derived( + "bt_ppl", lambda meters: utils.get_perplexity(meters["bt_nll_loss"].avg) + ) + + dae_sample_size = sum(x.get("dae_sample_size", 0) for x in logging_outputs) + if dae_sample_size: + dae_loss_sum = sum(x.get("dae_loss", 0) for x in logging_outputs) + dae_loss_sum *= 1 / dae_sample_size / math.log(2) + metrics.log_scalar("dae_loss", dae_loss_sum, dae_sample_size, round=3) + + dae_nll_loss_sum = sum(x.get("dae_nll_loss", 0) for x in logging_outputs) + dae_ntokens = sum(x.get("dae_ntokens", 0) for x in logging_outputs) + dae_nll_loss_sum *= 1 / dae_ntokens / math.log(2) + metrics.log_scalar("dae_nll_loss", dae_nll_loss_sum, dae_ntokens, round=3) + metrics.log_derived( + "dae_ppl", + lambda meters: utils.get_perplexity(meters["dae_nll_loss"].avg), + ) + + +@torch.no_grad() +def extend_embedding( + emb: nn.Module, new_vocab_size: int, copy_from_token_id: int +) -> None: + old_emb_data = emb.weight.data + (old_vocab_size, dim) = old_emb_data.shape + assert new_vocab_size >= old_vocab_size + + if new_vocab_size > old_vocab_size: + emb.weight.data = torch.zeros((new_vocab_size, dim)) + emb.weight.data[:old_vocab_size, :] = old_emb_data + # initialize new embeddings + emb.weight.data[old_vocab_size:, :] = old_emb_data[copy_from_token_id] + if hasattr(emb, "num_embeddings"): + emb.num_embeddings = new_vocab_size + if hasattr(emb, "out_features"): + emb.out_features = new_vocab_size + + if getattr(emb, "bias", None) is None: + return + + # Fix the bias. + # Bias shape can be different from the previous vocab size + # if the weight matrix was shared and alread extended but not the bias. + (old_vocab_size,) = emb.bias.shape + assert new_vocab_size >= old_vocab_size + if new_vocab_size > old_vocab_size: + old_bias = emb.bias.data + new_bias = torch.zeros( + (new_vocab_size,), dtype=old_bias.dtype, device=old_bias.device + ) + new_bias[:old_vocab_size] = old_bias + emb.bias.data = new_bias + + +def add_secial_tokens_to_dict_and_model( + dictionary: "fairseq.data.Dictionary", + model: nn.Module, + mono_langs: Sequence[str], +) -> None: + embs = model.encoder.embed_tokens + vocab_size, embedding_dim = embs.weight.shape + + # The model may or may not have a '<mask>' embedding yet + assert ( + len(dictionary) <= vocab_size <= len(dictionary) + 1 + ), f"Dictionary len ({len(dictionary)}) doesn't match embs shape ({embs.weight.shape})" + # TODO: we should reuse the pretrained model dict which already has <mask> + dictionary.add_symbol("<mask>") + + for lang in mono_langs: + lang_token = _lang_token(lang) + dictionary.add_symbol(lang_token) + logger.info( + f"dictionary: {len(dictionary)} -> {vocab_size} tokens " + f"after adding {len(mono_langs)} lang tokens." + ) + + if len(dictionary) <= vocab_size: + return + + extend_embedding(embs, len(dictionary), dictionary.bos()) + dec_embs = model.decoder.embed_tokens + extend_embedding(dec_embs, len(dictionary), dictionary.bos()) + lm_head = model.decoder.output_projection + extend_embedding(lm_head, len(dictionary), dictionary.bos()) + assert lm_head.weight.shape == (len(dictionary), embedding_dim) + + +def _lang_token(lang: str) -> str: + return f"__{lang}__" + + +def _lang_token_index(dictionary, lang: str) -> int: + return dictionary.index(_lang_token(lang)) + + +@contextlib.contextmanager +def assert_weights_have_changed(model: nn.Module): + def checksum(model: nn.Module) -> float: + return sum(p.sum().item() for p in model.parameters()) + + initial_checksum = checksum(model) + yield model + final_checksum = checksum(model) + logger.info( + f"initial_checksum={initial_checksum} -> final_checksum={final_checksum}" + ) + assert initial_checksum != final_checksum, "Model hasn't changed !" diff --git a/fairseq/fairseq/tasks/semisupervised_translation.py b/fairseq/fairseq/tasks/semisupervised_translation.py new file mode 100644 index 0000000000000000000000000000000000000000..b2f9bf9a733d94e50b588e4316b4a02e1c8bcf51 --- /dev/null +++ b/fairseq/fairseq/tasks/semisupervised_translation.py @@ -0,0 +1,485 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +from collections import OrderedDict + +from fairseq import utils +from fairseq.data import ( + BacktranslationDataset, + IndexedCachedDataset, + IndexedDataset, + IndexedRawTextDataset, + LanguagePairDataset, + NoisingDataset, + RoundRobinZipDatasets, + data_utils, + indexed_dataset, +) +from fairseq.models import FairseqMultiModel +from fairseq.sequence_generator import SequenceGenerator + +from . import register_task +from .multilingual_translation import MultilingualTranslationTask + + +logger = logging.getLogger(__name__) + + +def _get_bt_dataset_key(lang_pair): + return "bt:" + lang_pair + + +def _get_denoising_dataset_key(lang_pair): + return "denoising:" + lang_pair + + +# ported from UnsupervisedMT +def parse_lambda_config(x): + """ + Parse the configuration of lambda coefficient (for scheduling). + x = "3" # lambda will be a constant equal to x + x = "0:1,1000:0" # lambda will start from 1 and linearly decrease + # to 0 during the first 1000 iterations + x = "0:0,1000:0,2000:1" # lambda will be equal to 0 for the first 1000 + # iterations, then will linearly increase to 1 until iteration 2000 + """ + split = x.split(",") + if len(split) == 1: + return float(x), None + else: + split = [s.split(os.pathsep) for s in split] + assert all(len(s) == 2 for s in split) + assert all(k.isdigit() for k, _ in split) + assert all( + int(split[i][0]) < int(split[i + 1][0]) for i in range(len(split) - 1) + ) + return float(split[0][1]), [(int(k), float(v)) for k, v in split] + + +@register_task("semisupervised_translation") +class SemisupervisedTranslationTask(MultilingualTranslationTask): + """A task for training multiple translation models simultaneously. + + We iterate round-robin over batches from multiple language pairs, ordered + according to the `--lang-pairs` argument. + + The training loop is roughly: + + for i in range(len(epoch)): + for lang_pair in args.lang_pairs: + batch = next_batch_for_lang_pair(lang_pair) + loss = criterion(model_for_lang_pair(lang_pair), batch) + loss.backward() + optimizer.step() + + In practice, `next_batch_for_lang_pair` is abstracted in a FairseqDataset + (e.g., `RoundRobinZipDatasets`) and `model_for_lang_pair` is a model that + implements the `FairseqMultiModel` interface. + + During inference it is required to specify a single `--source-lang` and + `--target-lang`, instead of `--lang-pairs`. + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + MultilingualTranslationTask.add_args(parser) + parser.add_argument('--lambda-parallel-config', default="1.0", type=str, metavar='CONFIG', + help='cross-entropy reconstruction coefficient (parallel data). ' + 'use fixed weight during training if set to floating point number. ' + 'use piecewise linear function over number of updates to schedule the ' + 'weight with the format: w0:step0,w1:step1,...') + parser.add_argument('--lambda-denoising-config', default="0.0", type=str, metavar='CONFIG', + help='Cross-entropy reconstruction coefficient (denoising autoencoding)' + 'use fixed weight during training if set to floating point number. ' + 'use piecewise linear function over number of updates to schedule the ' + 'weight with the format: w0:step0,w1:step1,...') + parser.add_argument('--lambda-otf-bt-config', default="0.0", type=str, metavar='CONFIG', + help='cross-entropy reconstruction coefficient (on-the-fly back-translation parallel data)' + 'use fixed weight during training if set to floating point number. ' + 'use piecewise linear function over number of updates to schedule the ' + 'weight with the format: w0:step0,w1:step1,...') + parser.add_argument('--bt-max-len-a', default=1.1, type=float, metavar='N', + help='generate back-translated sequences of maximum length ax + b, where x is the ' + 'source length') + parser.add_argument('--bt-max-len-b', default=10.0, type=float, metavar='N', + help='generate back-translated sequences of maximum length ax + b, where x is the ' + 'source length') + parser.add_argument('--bt-beam-size', default=1, type=int, metavar='N', + help='beam size used in beam search of online back-translation') + parser.add_argument('--max-word-shuffle-distance', default=3.0, type=float, metavar='N', + help='maximum word shuffle distance for denoising autoencoding data generation') + parser.add_argument('--word-dropout-prob', default=0.1, type=float, metavar='N', + help='word dropout probability for denoising autoencoding data generation') + parser.add_argument('--word-blanking-prob', default=0.2, type=float, metavar='N', + help='word blanking probability for denoising autoencoding data generation') + # fmt: on + + def __init__(self, args, dicts, training): + super().__init__(args, dicts, training) + self.lambda_parallel, self.lambda_parallel_steps = parse_lambda_config( + args.lambda_parallel_config + ) + self.lambda_otf_bt, self.lambda_otf_bt_steps = parse_lambda_config( + args.lambda_otf_bt_config + ) + self.lambda_denoising, self.lambda_denoising_steps = parse_lambda_config( + args.lambda_denoising_config + ) + if self.lambda_denoising > 0.0 or self.lambda_denoising_steps is not None: + denoising_lang_pairs = [ + "%s-%s" % (tgt, tgt) + for tgt in {lang_pair.split("-")[1] for lang_pair in args.lang_pairs} + ] + self.model_lang_pairs = self.model_lang_pairs + denoising_lang_pairs + self.backtranslate_datasets = {} + self.backtranslators = {} + + @classmethod + def setup_task(cls, args, **kwargs): + dicts, training = MultilingualTranslationTask.prepare(args, **kwargs) + return cls(args, dicts, training) + + def load_dataset(self, split, epoch=1, **kwargs): + """Load a dataset split.""" + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + def split_exists(split, src, tgt, lang): + if src is not None: + filename = os.path.join( + data_path, "{}.{}-{}.{}".format(split, src, tgt, lang) + ) + else: + filename = os.path.join( + data_path, "{}.{}-None.{}".format(split, src, tgt) + ) + return indexed_dataset.dataset_exists(filename, impl=self.args.dataset_impl) + + def load_indexed_dataset(path, dictionary): + return data_utils.load_indexed_dataset( + path, dictionary, self.args.dataset_impl + ) + + # load parallel datasets + src_datasets, tgt_datasets = {}, {} + if ( + self.lambda_parallel > 0.0 + or self.lambda_parallel_steps is not None + or not split.startswith("train") + ): + for lang_pair in self.lang_pairs: + src, tgt = lang_pair.split("-") + if split_exists(split, src, tgt, src): + prefix = os.path.join( + data_path, "{}.{}-{}.".format(split, src, tgt) + ) + elif split_exists(split, tgt, src, src): + prefix = os.path.join( + data_path, "{}.{}-{}.".format(split, tgt, src) + ) + else: + continue + src_datasets[lang_pair] = load_indexed_dataset( + prefix + src, self.dicts[src] + ) + tgt_datasets[lang_pair] = load_indexed_dataset( + prefix + tgt, self.dicts[tgt] + ) + logger.info( + "parallel-{} {} {} examples".format( + data_path, split, len(src_datasets[lang_pair]) + ) + ) + if len(src_datasets) == 0: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, data_path) + ) + + # back translation datasets + backtranslate_datasets = {} + if ( + self.lambda_otf_bt > 0.0 or self.lambda_otf_bt_steps is not None + ) and split.startswith("train"): + for lang_pair in self.lang_pairs: + src, tgt = lang_pair.split("-") + if not split_exists(split, tgt, None, tgt): + raise FileNotFoundError( + "Dataset not found: backtranslation {} ({})".format( + split, data_path + ) + ) + filename = os.path.join( + data_path, "{}.{}-None.{}".format(split, tgt, tgt) + ) + dataset = load_indexed_dataset(filename, self.dicts[tgt]) + lang_pair_dataset_tgt = LanguagePairDataset( + dataset, + dataset.sizes, + self.dicts[tgt], + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + ) + lang_pair_dataset = LanguagePairDataset( + dataset, + dataset.sizes, + src_dict=self.dicts[src], + tgt=dataset, + tgt_sizes=dataset.sizes, + tgt_dict=self.dicts[tgt], + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + ) + backtranslate_datasets[lang_pair] = BacktranslationDataset( + tgt_dataset=self.alter_dataset_langtok( + lang_pair_dataset_tgt, + src_eos=self.dicts[tgt].eos(), + src_lang=tgt, + tgt_lang=src, + ), + backtranslation_fn=self.backtranslators[lang_pair], + src_dict=self.dicts[src], + tgt_dict=self.dicts[tgt], + output_collater=self.alter_dataset_langtok( + lang_pair_dataset=lang_pair_dataset, + src_eos=self.dicts[src].eos(), + src_lang=src, + tgt_eos=self.dicts[tgt].eos(), + tgt_lang=tgt, + ).collater, + ) + logger.info( + "backtranslate-{}: {} {} {} examples".format( + tgt, + data_path, + split, + len(backtranslate_datasets[lang_pair]), + ) + ) + self.backtranslate_datasets[lang_pair] = backtranslate_datasets[ + lang_pair + ] + + # denoising autoencoder + noising_datasets = {} + if ( + self.lambda_denoising > 0.0 or self.lambda_denoising_steps is not None + ) and split.startswith("train"): + for lang_pair in self.lang_pairs: + _, tgt = lang_pair.split("-") + if not split_exists(split, tgt, None, tgt): + continue + filename = os.path.join( + data_path, "{}.{}-None.{}".format(split, tgt, tgt) + ) + tgt_dataset1 = load_indexed_dataset(filename, self.dicts[tgt]) + tgt_dataset2 = load_indexed_dataset(filename, self.dicts[tgt]) + noising_dataset = NoisingDataset( + tgt_dataset1, + self.dicts[tgt], + seed=1, + max_word_shuffle_distance=self.args.max_word_shuffle_distance, + word_dropout_prob=self.args.word_dropout_prob, + word_blanking_prob=self.args.word_blanking_prob, + ) + noising_datasets[lang_pair] = self.alter_dataset_langtok( + LanguagePairDataset( + noising_dataset, + tgt_dataset1.sizes, + self.dicts[tgt], + tgt_dataset2, + tgt_dataset2.sizes, + self.dicts[tgt], + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + ), + src_eos=self.dicts[tgt].eos(), + src_lang=tgt, + tgt_eos=self.dicts[tgt].eos(), + tgt_lang=tgt, + ) + logger.info( + "denoising-{}: {} {} {} examples".format( + tgt, + data_path, + split, + len(noising_datasets[lang_pair]), + ) + ) + + def language_pair_dataset(lang_pair): + src, tgt = lang_pair.split("-") + src_dataset, tgt_dataset = src_datasets[lang_pair], tgt_datasets[lang_pair] + return self.alter_dataset_langtok( + LanguagePairDataset( + src_dataset, + src_dataset.sizes, + self.dicts[src], + tgt_dataset, + tgt_dataset.sizes, + self.dicts[tgt], + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + ), + self.dicts[src].eos(), + src, + self.dicts[tgt].eos(), + tgt, + ) + + self.datasets[split] = RoundRobinZipDatasets( + OrderedDict( + [ + (lang_pair, language_pair_dataset(lang_pair)) + for lang_pair in src_datasets.keys() + ] + + [ + (_get_bt_dataset_key(lang_pair), dataset) + for lang_pair, dataset in backtranslate_datasets.items() + ] + + [ + (_get_denoising_dataset_key(lang_pair), dataset) + for lang_pair, dataset in noising_datasets.items() + ] + ), + eval_key=None + if self.training + else "%s-%s" % (self.args.source_lang, self.args.target_lang), + ) + + def build_model(self, args): + from fairseq import models + + model = models.build_model(args, self) + if not isinstance(model, FairseqMultiModel): + raise ValueError( + "SemisupervisedTranslationTask requires a FairseqMultiModel architecture" + ) + + # create SequenceGenerator for each model that has backtranslation dependency on it + self.sequence_generators = {} + if ( + self.lambda_otf_bt > 0.0 or self.lambda_otf_bt_steps is not None + ) and self.training: + for lang_pair in self.lang_pairs: + src, tgt = lang_pair.split("-") + key = "{}-{}".format(tgt, src) + self.sequence_generators[key] = SequenceGenerator( + [model.models[key]], + tgt_dict=self.dicts[src], + beam_size=args.bt_beam_size, + max_len_a=args.bt_max_len_a, + max_len_b=args.bt_max_len_b, + ) + decoder_lang_tok_idx = self.get_decoder_langtok(src) + + def backtranslate_fn( + sample, + model=model.models[key], + bos_token=decoder_lang_tok_idx, + sequence_generator=self.sequence_generators[key], + ): + return sequence_generator.generate( + [model], + sample, + bos_token=bos_token, + ) + + self.backtranslators[lang_pair] = backtranslate_fn + + return model + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + model.train() + + if update_num > 0: + self.update_step(update_num) + + agg_loss, agg_sample_size, agg_logging_output = 0.0, 0.0, {} + + def forward_backward(model, samples, logging_output_key, weight): + nonlocal agg_loss, agg_sample_size, agg_logging_output + if samples is None or len(samples) == 0: + return + loss, sample_size, logging_output = criterion(model, samples) + if ignore_grad: + loss *= 0 + else: + loss *= weight + optimizer.backward(loss) + agg_loss += loss.detach().item() + # TODO make summing of the sample sizes configurable + agg_sample_size += sample_size + for k in logging_output: + agg_logging_output[k] += logging_output[k] + agg_logging_output[logging_output_key] += logging_output[k] + + if self.lambda_parallel > 0.0: + for lang_pair in self.lang_pairs: + forward_backward( + model.models[lang_pair], + sample[lang_pair], + lang_pair, + self.lambda_parallel, + ) + + if self.lambda_otf_bt > 0.0: + for lang_pair in self.lang_pairs: + sample_key = _get_bt_dataset_key(lang_pair) + forward_backward( + model.models[lang_pair], + sample[sample_key], + sample_key, + self.lambda_otf_bt, + ) + + if self.lambda_denoising > 0.0: + for lang_pair in self.lang_pairs: + _, tgt = lang_pair.split("-") + sample_key = _get_denoising_dataset_key(lang_pair) + forward_backward( + model.models["{0}-{0}".format(tgt)], + sample[sample_key], + sample_key, + self.lambda_denoising, + ) + + return agg_loss, agg_sample_size, agg_logging_output + + def update_step(self, num_updates): + def lambda_step_func(config, n_iter): + """ + Update a lambda value according to its schedule configuration. + """ + ranges = [ + i + for i in range(len(config) - 1) + if config[i][0] <= n_iter < config[i + 1][0] + ] + if len(ranges) == 0: + assert n_iter >= config[-1][0] + return config[-1][1] + assert len(ranges) == 1 + i = ranges[0] + x_a, y_a = config[i] + x_b, y_b = config[i + 1] + return y_a + (n_iter - x_a) * float(y_b - y_a) / float(x_b - x_a) + + if self.lambda_parallel_steps is not None: + self.lambda_parallel = lambda_step_func( + self.lambda_parallel_steps, num_updates + ) + if self.lambda_denoising_steps is not None: + self.lambda_denoising = lambda_step_func( + self.lambda_denoising_steps, num_updates + ) + if self.lambda_otf_bt_steps is not None: + self.lambda_otf_bt = lambda_step_func(self.lambda_otf_bt_steps, num_updates) diff --git a/fairseq/fairseq/tasks/sentence_prediction.py b/fairseq/fairseq/tasks/sentence_prediction.py new file mode 100644 index 0000000000000000000000000000000000000000..d5f9302c10b3410e7650433d54f70aad4fd1cfc4 --- /dev/null +++ b/fairseq/fairseq/tasks/sentence_prediction.py @@ -0,0 +1,286 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +import contextlib +from dataclasses import dataclass, field +from typing import Optional +from omegaconf import MISSING, II, open_dict, OmegaConf + +import numpy as np +from fairseq.data import ( + ConcatSentencesDataset, + Dictionary, + IdDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + OffsetTokensDataset, + PrependTokenDataset, + RawLabelDataset, + RightPadDataset, + RollDataset, + SortDataset, + StripTokenDataset, + data_utils, +) +from fairseq.data.shorten_dataset import maybe_shorten_dataset +from fairseq.tasks import FairseqDataclass, FairseqTask, register_task +from fairseq.dataclass import ChoiceEnum + + +logger = logging.getLogger(__name__) +SHORTEN_METHOD_CHOICES = ChoiceEnum(["none", "truncate", "random_crop"]) + + +@dataclass +class SentencePredictionConfig(FairseqDataclass): + data: str = field(default=MISSING, metadata={"help": "path to data directory"}) + num_classes: int = field( + default=-1, + metadata={"help": "number of classes or regression targets"}, + ) + init_token: Optional[int] = field( + default=None, + metadata={"help": "add token at the beginning of each batch item"}, + ) + separator_token: Optional[int] = field( + default=None, + metadata={"help": "add separator token between inputs"}, + ) + no_shuffle: bool = field( + default=False, + ) + shorten_method: SHORTEN_METHOD_CHOICES = field( + default="none", + metadata={ + "help": "if not none, shorten sequences that exceed tokens_per_sample" + }, + ) + shorten_data_split_list: str = field( + default="", + metadata={ + "help": "comma-separated list of dataset splits to apply shortening to, " + 'e.g., "train,valid" (default: all dataset splits)' + }, + ) + add_prev_output_tokens: bool = field( + default=False, + metadata={ + "help": "add prev_output_tokens to sample, used for encoder-decoder arch" + }, + ) + max_positions: int = field( + default=512, + metadata={"help": "max tokens per example"}, + ) + + regression_target: bool = II("criterion.regression_target") + classification_head_name: str = II("criterion.classification_head_name") + seed: int = II("common.seed") + + +@register_task("sentence_prediction", dataclass=SentencePredictionConfig) +class SentencePredictionTask(FairseqTask): + """ + Sentence (or sentence pair) prediction (classification or regression) task. + + Args: + dictionary (Dictionary): the dictionary for the input of the task + """ + + def __init__(self, cfg, data_dictionary, label_dictionary): + super().__init__(cfg) + self.dictionary = data_dictionary + self._label_dictionary = label_dictionary + + @classmethod + def load_dictionary(cls, filename): + """Load the dictionary from the filename + + Args: + filename (str): the filename + """ + dictionary = Dictionary.load(filename) + dictionary.add_symbol("<mask>") + return dictionary + + @classmethod + def setup_task(cls, cfg, **kwargs): + assert cfg.num_classes > 0, "Must set task.num_classes" + + # load data dictionary + data_dict = cls.load_dictionary( + os.path.join(cfg.data, "input0", "dict.txt"), + ) + logger.info("[input] dictionary: {} types".format(len(data_dict))) + + # load label dictionary + if not cfg.regression_target: + label_dict = cls.load_dictionary( + os.path.join(cfg.data, "label", "dict.txt"), + ) + logger.info("[label] dictionary: {} types".format(len(label_dict))) + else: + label_dict = data_dict + return cls(cfg, data_dict, label_dict) + + def load_dataset(self, split, combine=False, **kwargs): + """Load a given dataset split (e.g., train, valid, test).""" + + def get_path(key, split): + return os.path.join(self.cfg.data, key, split) + + def make_dataset(key, dictionary): + split_path = get_path(key, split) + + try: + dataset = data_utils.load_indexed_dataset( + split_path, + dictionary, + combine=combine, + ) + except Exception as e: + if "StorageException: [404] Path not found" in str(e): + logger.warning(f"dataset {e} not found") + dataset = None + else: + raise e + return dataset + + input0 = make_dataset("input0", self.source_dictionary) + assert input0 is not None, "could not find dataset: {}".format( + get_path("input0", split) + ) + input1 = make_dataset("input1", self.source_dictionary) + + if self.cfg.init_token is not None: + input0 = PrependTokenDataset(input0, self.cfg.init_token) + + if input1 is None: + src_tokens = input0 + else: + if self.cfg.separator_token is not None: + input1 = PrependTokenDataset(input1, self.cfg.separator_token) + + src_tokens = ConcatSentencesDataset(input0, input1) + + with data_utils.numpy_seed(self.cfg.seed): + shuffle = np.random.permutation(len(src_tokens)) + + src_tokens = maybe_shorten_dataset( + src_tokens, + split, + self.cfg.shorten_data_split_list, + self.cfg.shorten_method, + self.max_positions(), + self.cfg.seed, + ) + + dataset = { + "id": IdDataset(), + "net_input": { + "src_tokens": RightPadDataset( + src_tokens, + pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": NumelDataset(src_tokens, reduce=False), + }, + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_tokens, reduce=True), + } + + if self.cfg.add_prev_output_tokens: + prev_tokens_dataset = RightPadDataset( + RollDataset(src_tokens, 1), + pad_idx=self.dictionary.pad(), + ) + dataset["net_input"].update( + prev_output_tokens=prev_tokens_dataset, + ) + + if not self.cfg.regression_target: + label_dataset = make_dataset("label", self.label_dictionary) + if label_dataset is not None: + dataset.update( + target=OffsetTokensDataset( + StripTokenDataset( + label_dataset, + id_to_strip=self.label_dictionary.eos(), + ), + offset=-self.label_dictionary.nspecial, + ) + ) + else: + label_path = "{0}.label".format(get_path("label", split)) + if os.path.exists(label_path): + + def parse_regression_target(i, line): + values = line.split() + assert ( + len(values) == self.cfg.num_classes + ), f'expected num_classes={self.cfg.num_classes} regression target values on line {i}, found: "{line}"' + return [float(x) for x in values] + + with open(label_path) as h: + dataset.update( + target=RawLabelDataset( + [ + parse_regression_target(i, line.strip()) + for i, line in enumerate(h.readlines()) + ] + ) + ) + + nested_dataset = NestedDictionaryDataset( + dataset, + sizes=[src_tokens.sizes], + ) + + if self.cfg.no_shuffle: + dataset = nested_dataset + else: + dataset = SortDataset( + nested_dataset, + # shuffle + sort_order=[shuffle], + ) + + logger.info("Loaded {0} with #samples: {1}".format(split, len(dataset))) + + self.datasets[split] = dataset + return self.datasets[split] + + def build_model(self, cfg): + from fairseq import models + + with open_dict(cfg) if OmegaConf.is_config(cfg) else contextlib.ExitStack(): + cfg.max_positions = self.cfg.max_positions + + model = models.build_model(cfg, self) + + model.register_classification_head( + self.cfg.classification_head_name, + num_classes=self.cfg.num_classes, + ) + + return model + + def max_positions(self): + return self.cfg.max_positions + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + @property + def label_dictionary(self): + return self._label_dictionary diff --git a/fairseq/fairseq/tasks/sentence_ranking.py b/fairseq/fairseq/tasks/sentence_ranking.py new file mode 100644 index 0000000000000000000000000000000000000000..bed44f34e5f8e506b6ae7ba30ddaa661bf4a7522 --- /dev/null +++ b/fairseq/fairseq/tasks/sentence_ranking.py @@ -0,0 +1,219 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +import numpy as np +from fairseq import utils +from fairseq.data import ( + ConcatSentencesDataset, + Dictionary, + IdDataset, + NestedDictionaryDataset, + NumelDataset, + NumSamplesDataset, + PrependTokenDataset, + RawLabelDataset, + RightPadDataset, + SortDataset, + TruncateDataset, + data_utils, +) +from fairseq.data.shorten_dataset import maybe_shorten_dataset +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("sentence_ranking") +class SentenceRankingTask(LegacyFairseqTask): + """ + Ranking task on multiple sentences. + + Args: + dictionary (Dictionary): the dictionary for the input of the task + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + parser.add_argument("data", metavar="FILE", help="file prefix for data") + parser.add_argument( + "--num-classes", type=int, help="number of sentences to be ranked" + ) + parser.add_argument( + "--init-token", + type=int, + help="add token at the beginning of each batch item", + ) + parser.add_argument( + "--separator-token", type=int, help="add separator token between inputs" + ) + parser.add_argument("--no-shuffle", action="store_true") + parser.add_argument( + "--shorten-method", + default="none", + choices=["none", "truncate", "random_crop"], + help="if not none, shorten sequences that exceed --tokens-per-sample", + ) + parser.add_argument( + "--shorten-data-split-list", + default="", + help="comma-separated list of dataset splits to apply shortening to, " + 'e.g., "train,valid" (default: all dataset splits)', + ) + parser.add_argument( + "--max-option-length", type=int, help="max length for each option" + ) + + def __init__(self, args, dictionary): + super().__init__(args) + self.dictionary = dictionary + + @classmethod + def load_dictionary(cls, args, filename, source=True): + """Load the dictionary from the filename + + Args: + filename (str): the filename + """ + dictionary = Dictionary.load(filename) + dictionary.add_symbol("<mask>") + return dictionary + + @classmethod + def setup_task(cls, args, **kwargs): + assert ( + args.criterion == "sentence_ranking" + ), "Must set --criterion=sentence_ranking" + + # load data dictionary + data_dict = cls.load_dictionary( + args, + os.path.join(args.data, "input0", "dict.txt"), + source=True, + ) + logger.info("[input] dictionary: {} types".format(len(data_dict))) + return SentenceRankingTask(args, data_dict) + + def load_dataset(self, split, combine=False, **kwargs): + """Load a given dataset split (e.g., train, valid, test).""" + + def get_path(type, split): + return os.path.join(self.args.data, type, split) + + def make_dataset(type, dictionary): + split_path = get_path(type, split) + + dataset = data_utils.load_indexed_dataset( + split_path, + self.source_dictionary, + self.args.dataset_impl, + combine=combine, + ) + return dataset + + input0 = make_dataset("input0", self.source_dictionary) + input_options = [ + make_dataset("input{idx}".format(idx=idx + 1), self.source_dictionary) + for idx in range(self.args.num_classes) + ] + + if self.args.separator_token is not None: + input0 = PrependTokenDataset(input0, self.args.separator_token) + + src_tokens = [] + for input_option in input_options: + if self.args.init_token is not None: + input_option = PrependTokenDataset(input_option, self.args.init_token) + if self.args.max_option_length is not None: + input_option = TruncateDataset( + input_option, self.args.max_option_length + ) + src_token = ConcatSentencesDataset(input_option, input0) + src_token = maybe_shorten_dataset( + src_token, + split, + self.args.shorten_data_split_list, + self.args.shorten_method, + self.args.max_positions, + self.args.seed, + ) + src_tokens.append(src_token) + + with data_utils.numpy_seed(self.args.seed): + shuffle = np.random.permutation(len(src_tokens[0])) + + dataset = { + "id": IdDataset(), + "nsentences": NumSamplesDataset(), + "ntokens": NumelDataset(src_tokens[0], reduce=True), + } + + for src_token_idx in range(len(src_tokens)): + dataset.update( + { + "net_input{idx}".format(idx=src_token_idx + 1): { + "src_tokens": RightPadDataset( + src_tokens[src_token_idx], + pad_idx=self.source_dictionary.pad(), + ), + "src_lengths": NumelDataset( + src_tokens[src_token_idx], reduce=False + ), + } + } + ) + + label_path = "{}.label".format(get_path("label", split)) + if os.path.exists(label_path): + with open(label_path) as h: + dataset.update( + target=RawLabelDataset([int(x.strip()) for x in h.readlines()]) + ) + + nested_dataset = NestedDictionaryDataset( + dataset, + sizes=[np.maximum.reduce([src_token.sizes for src_token in src_tokens])], + ) + + if self.args.no_shuffle: + dataset = nested_dataset + else: + dataset = SortDataset( + nested_dataset, + # shuffle + sort_order=[shuffle], + ) + + logger.info("Loaded {0} with #samples: {1}".format(split, len(dataset))) + + self.datasets[split] = dataset + return self.datasets[split] + + def build_model(self, args): + from fairseq import models + + model = models.build_model(args, self) + + model.register_classification_head( + getattr(args, "ranking_head_name", "sentence_classification_head"), + num_classes=1, + ) + + return model + + def max_positions(self): + return self.args.max_positions + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary diff --git a/fairseq/fairseq/tasks/simultaneous_translation.py b/fairseq/fairseq/tasks/simultaneous_translation.py new file mode 100644 index 0000000000000000000000000000000000000000..11c7dc1ea966a54f8915ef164377e40f90e851a1 --- /dev/null +++ b/fairseq/fairseq/tasks/simultaneous_translation.py @@ -0,0 +1,42 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from fairseq.tasks import register_task +from fairseq.tasks.speech_to_text import SpeechToTextTask +from fairseq.tasks.translation import ( + TranslationTask, TranslationConfig +) + +try: + import examples.simultaneous_translation # noqa + import_successful = True +except BaseException: + import_successful = False + + +logger = logging.getLogger(__name__) + + +def check_import(flag): + if not flag: + raise ImportError( + "'examples.simultaneous_translation' is not correctly imported. " + "Please considering `pip install -e $FAIRSEQ_DIR`." + ) + + +@register_task("simul_speech_to_text") +class SimulSpeechToTextTask(SpeechToTextTask): + def __init__(self, args, tgt_dict): + check_import(import_successful) + super().__init__(args, tgt_dict) + + +@register_task("simul_text_to_text", dataclass=TranslationConfig) +class SimulTextToTextTask(TranslationTask): + def __init__(self, cfg, src_dict, tgt_dict): + check_import(import_successful) + super().__init__(cfg, src_dict, tgt_dict) diff --git a/fairseq/fairseq/tasks/speech_to_text.py b/fairseq/fairseq/tasks/speech_to_text.py new file mode 100644 index 0000000000000000000000000000000000000000..06e292103ef898d607eb23441ce840de1fc800a1 --- /dev/null +++ b/fairseq/fairseq/tasks/speech_to_text.py @@ -0,0 +1,165 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +from pathlib import Path +from argparse import Namespace + +from fairseq.data import Dictionary, encoders +from fairseq.data.audio.speech_to_text_dataset import ( + S2TDataConfig, + SpeechToTextDataset, + SpeechToTextDatasetCreator, + get_features_or_waveform +) +from fairseq.tasks import LegacyFairseqTask, register_task + + +logger = logging.getLogger(__name__) + + +@register_task("speech_to_text") +class SpeechToTextTask(LegacyFairseqTask): + @classmethod + def add_args(cls, parser): + parser.add_argument("data", help="manifest root path") + parser.add_argument( + "--config-yaml", + type=str, + default="config.yaml", + help="Configuration YAML filename (under manifest root)", + ) + parser.add_argument( + "--max-source-positions", + default=6000, + type=int, + metavar="N", + help="max number of tokens in the source sequence", + ) + parser.add_argument( + "--max-target-positions", + default=1024, + type=int, + metavar="N", + help="max number of tokens in the target sequence", + ) + + def __init__(self, args, tgt_dict): + super().__init__(args) + self.tgt_dict = tgt_dict + self.data_cfg = S2TDataConfig(Path(args.data) / args.config_yaml) + self.speaker_to_id = self._get_speaker_to_id() + + def _get_speaker_to_id(self): + speaker_to_id = None + speaker_set_filename = self.data_cfg.config.get("speaker_set_filename") + if speaker_set_filename is not None: + speaker_set_path = Path(self.args.data) / speaker_set_filename + with open(speaker_set_path) as f: + speaker_to_id = {r.strip(): i for i, r in enumerate(f)} + return speaker_to_id + + @classmethod + def setup_task(cls, args, **kwargs): + data_cfg = S2TDataConfig(Path(args.data) / args.config_yaml) + dict_path = Path(args.data) / data_cfg.vocab_filename + if not dict_path.is_file(): + raise FileNotFoundError(f"Dict not found: {dict_path.as_posix()}") + tgt_dict = Dictionary.load(dict_path.as_posix()) + logger.info( + f"dictionary size ({data_cfg.vocab_filename}): " f"{len(tgt_dict):,}" + ) + + if getattr(args, "train_subset", None) is not None: + if not all(s.startswith("train") for s in args.train_subset.split(",")): + raise ValueError('Train splits should be named like "train*".') + return cls(args, tgt_dict) + + def build_criterion(self, args): + from fairseq import criterions + + if self.data_cfg.prepend_tgt_lang_tag and args.ignore_prefix_size != 1: + raise ValueError( + 'Please set "--ignore-prefix-size 1" since ' + "target language ID token is prepended as BOS." + ) + return criterions.build_criterion(args, self) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + is_train_split = split.startswith("train") + pre_tokenizer = self.build_tokenizer(self.args) + bpe_tokenizer = self.build_bpe(self.args) + self.datasets[split] = SpeechToTextDatasetCreator.from_tsv( + self.args.data, + self.data_cfg, + split, + self.tgt_dict, + pre_tokenizer, + bpe_tokenizer, + is_train_split=is_train_split, + epoch=epoch, + seed=self.args.seed, + speaker_to_id=self.speaker_to_id + ) + + @property + def target_dictionary(self): + return self.tgt_dict + + @property + def source_dictionary(self): + return None + + def max_positions(self): + return self.args.max_source_positions, self.args.max_target_positions + + def build_model(self, args): + args.input_feat_per_channel = self.data_cfg.input_feat_per_channel + args.input_channels = self.data_cfg.input_channels + args.speaker_to_id = self.speaker_to_id + return super(SpeechToTextTask, self).build_model(args) + + def build_generator( + self, + models, + args, + seq_gen_cls=None, + extra_gen_cls_kwargs=None, + ): + if self.data_cfg.prepend_tgt_lang_tag and args.prefix_size != 1: + raise ValueError( + 'Please set "--prefix-size 1" since ' + "target language ID token is prepended as BOS." + ) + lang_token_ids = { + i + for s, i in self.tgt_dict.indices.items() + if SpeechToTextDataset.is_lang_tag(s) + } + + if extra_gen_cls_kwargs is None: + extra_gen_cls_kwargs = {} + extra_gen_cls_kwargs["symbols_to_strip_from_output"] = lang_token_ids + return super().build_generator( + models, args, seq_gen_cls=None, + extra_gen_cls_kwargs=extra_gen_cls_kwargs + ) + + def build_tokenizer(self, args): + logger.info(f"pre-tokenizer: {self.data_cfg.pre_tokenizer}") + return encoders.build_tokenizer(Namespace(**self.data_cfg.pre_tokenizer)) + + def build_bpe(self, args): + logger.info(f"tokenizer: {self.data_cfg.bpe_tokenizer}") + return encoders.build_bpe(Namespace(**self.data_cfg.bpe_tokenizer)) + + def get_interactive_tokens_and_lengths(self, lines, encode_fn): + n_frames = [get_features_or_waveform(p).shape[0] for p in lines] + return lines, n_frames + + def build_dataset_for_inference(self, src_tokens, src_lengths, **kwargs): + return SpeechToTextDataset( + "interactive", False, self.data_cfg, src_tokens, src_lengths + ) diff --git a/fairseq/fairseq/tasks/text_to_speech.py b/fairseq/fairseq/tasks/text_to_speech.py new file mode 100644 index 0000000000000000000000000000000000000000..5646e41d39f6e39d4b046ee34ff69b998dab160d --- /dev/null +++ b/fairseq/fairseq/tasks/text_to_speech.py @@ -0,0 +1,467 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import os.path as op + +import torch +import torch.nn.functional as F +import numpy as np + +from fairseq.data.audio.text_to_speech_dataset import TextToSpeechDatasetCreator +from fairseq.tasks import register_task +from fairseq.tasks.speech_to_text import SpeechToTextTask +from fairseq.speech_generator import ( + AutoRegressiveSpeechGenerator, NonAutoregressiveSpeechGenerator, + TeacherForcingAutoRegressiveSpeechGenerator +) + +logging.basicConfig( + format='%(asctime)s | %(levelname)s | %(name)s | %(message)s', + datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO +) +logger = logging.getLogger(__name__) + + +try: + from tensorboardX import SummaryWriter +except ImportError: + logger.info("Please install tensorboardX: pip install tensorboardX") + SummaryWriter = None + + +@register_task('text_to_speech') +class TextToSpeechTask(SpeechToTextTask): + @staticmethod + def add_args(parser): + parser.add_argument('data', help='manifest root path') + parser.add_argument( + '--config-yaml', type=str, default='config.yaml', + help='Configuration YAML filename (under manifest root)' + ) + parser.add_argument('--max-source-positions', default=1024, type=int, + metavar='N', + help='max number of tokens in the source sequence') + parser.add_argument('--max-target-positions', default=1200, type=int, + metavar='N', + help='max number of tokens in the target sequence') + parser.add_argument("--n-frames-per-step", type=int, default=1) + parser.add_argument("--eos-prob-threshold", type=float, default=0.5) + parser.add_argument("--eval-inference", action="store_true") + parser.add_argument("--eval-tb-nsample", type=int, default=8) + parser.add_argument("--vocoder", type=str, default="griffin_lim") + parser.add_argument("--spec-bwd-max-iter", type=int, default=8) + + def __init__(self, args, src_dict): + super().__init__(args, src_dict) + self.src_dict = src_dict + self.sr = self.data_cfg.config.get("features").get("sample_rate") + + self.tensorboard_writer = None + self.tensorboard_dir = "" + if args.tensorboard_logdir and SummaryWriter is not None: + self.tensorboard_dir = os.path.join(args.tensorboard_logdir, + "valid_extra") + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + is_train_split = split.startswith('train') + pre_tokenizer = self.build_tokenizer(self.args) + bpe_tokenizer = self.build_bpe(self.args) + self.datasets[split] = TextToSpeechDatasetCreator.from_tsv( + self.args.data, self.data_cfg, split, self.src_dict, + pre_tokenizer, bpe_tokenizer, is_train_split=is_train_split, + epoch=epoch, seed=self.args.seed, + n_frames_per_step=self.args.n_frames_per_step, + speaker_to_id=self.speaker_to_id + ) + + @property + def target_dictionary(self): + return None + + @property + def source_dictionary(self): + return self.src_dict + + def get_speaker_embeddings_path(self): + speaker_emb_path = None + if self.data_cfg.config.get("speaker_emb_filename") is not None: + speaker_emb_path = op.join( + self.args.data, self.data_cfg.config.get("speaker_emb_filename") + ) + return speaker_emb_path + + @classmethod + def get_speaker_embeddings(cls, args): + embed_speaker = None + if args.speaker_to_id is not None: + if args.speaker_emb_path is None: + embed_speaker = torch.nn.Embedding( + len(args.speaker_to_id), args.speaker_embed_dim + ) + else: + speaker_emb_mat = np.load(args.speaker_emb_path) + assert speaker_emb_mat.shape[1] == args.speaker_embed_dim + embed_speaker = torch.nn.Embedding.from_pretrained( + torch.from_numpy(speaker_emb_mat), freeze=True, + ) + logger.info( + f"load speaker embeddings from {args.speaker_emb_path}. " + f"train embedding? {embed_speaker.weight.requires_grad}\n" + f"embeddings:\n{speaker_emb_mat}" + ) + return embed_speaker + + def build_model(self, cfg): + cfg.pitch_min = self.data_cfg.config["features"].get("pitch_min", None) + cfg.pitch_max = self.data_cfg.config["features"].get("pitch_max", None) + cfg.energy_min = self.data_cfg.config["features"].get("energy_min", None) + cfg.energy_max = self.data_cfg.config["features"].get("energy_max", None) + cfg.speaker_emb_path = self.get_speaker_embeddings_path() + model = super().build_model(cfg) + self.generator = None + if getattr(cfg, "eval_inference", False): + self.generator = self.build_generator([model], cfg) + return model + + def build_generator(self, models, cfg, vocoder=None, **unused): + if vocoder is None: + vocoder = self.build_default_vocoder() + model = models[0] + if getattr(model, "NON_AUTOREGRESSIVE", False): + return NonAutoregressiveSpeechGenerator( + model, vocoder, self.data_cfg + ) + else: + generator = AutoRegressiveSpeechGenerator + if getattr(cfg, "teacher_forcing", False): + generator = TeacherForcingAutoRegressiveSpeechGenerator + logger.info("Teacher forcing mode for generation") + return generator( + model, vocoder, self.data_cfg, + max_iter=self.args.max_target_positions, + eos_prob_threshold=self.args.eos_prob_threshold + ) + + def build_default_vocoder(self): + from fairseq.models.text_to_speech.vocoder import get_vocoder + vocoder = get_vocoder(self.args, self.data_cfg) + if torch.cuda.is_available() and not self.args.cpu: + vocoder = vocoder.cuda() + else: + vocoder = vocoder.cpu() + return vocoder + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = super().valid_step( + sample, model, criterion + ) + + if getattr(self.args, "eval_inference", False): + hypos, inference_losses = self.valid_step_with_inference( + sample, model, self.generator + ) + for k, v in inference_losses.items(): + assert(k not in logging_output) + logging_output[k] = v + + picked_id = 0 + if self.tensorboard_dir and (sample["id"] == picked_id).any(): + self.log_tensorboard( + sample, + hypos[:self.args.eval_tb_nsample], + model._num_updates, + is_na_model=getattr(model, "NON_AUTOREGRESSIVE", False) + ) + return loss, sample_size, logging_output + + def valid_step_with_inference(self, sample, model, generator): + hypos = generator.generate(model, sample, has_targ=True) + + losses = { + "mcd_loss": 0., + "targ_frames": 0., + "pred_frames": 0., + "nins": 0., + "ndel": 0., + } + rets = batch_mel_cepstral_distortion( + [hypo["targ_waveform"] for hypo in hypos], + [hypo["waveform"] for hypo in hypos], + self.sr, + normalize_type=None + ) + for d, extra in rets: + pathmap = extra[-1] + losses["mcd_loss"] += d.item() + losses["targ_frames"] += pathmap.size(0) + losses["pred_frames"] += pathmap.size(1) + losses["nins"] += (pathmap.sum(dim=1) - 1).sum().item() + losses["ndel"] += (pathmap.sum(dim=0) - 1).sum().item() + + return hypos, losses + + def log_tensorboard(self, sample, hypos, num_updates, is_na_model=False): + if self.tensorboard_writer is None: + self.tensorboard_writer = SummaryWriter(self.tensorboard_dir) + tb_writer = self.tensorboard_writer + for b in range(len(hypos)): + idx = sample["id"][b] + text = sample["src_texts"][b] + targ = hypos[b]["targ_feature"] + pred = hypos[b]["feature"] + attn = hypos[b]["attn"] + + if is_na_model: + data = plot_tts_output( + [targ.transpose(0, 1), pred.transpose(0, 1)], + [f"target (idx={idx})", "output"], attn, + "alignment", ret_np=True, suptitle=text, + ) + else: + eos_prob = hypos[b]["eos_prob"] + data = plot_tts_output( + [targ.transpose(0, 1), pred.transpose(0, 1), attn], + [f"target (idx={idx})", "output", "alignment"], eos_prob, + "eos prob", ret_np=True, suptitle=text, + ) + + tb_writer.add_image( + f"inference_sample_{b}", data, num_updates, + dataformats="HWC" + ) + + if hypos[b]["waveform"] is not None: + targ_wave = hypos[b]["targ_waveform"].detach().cpu().float() + pred_wave = hypos[b]["waveform"].detach().cpu().float() + tb_writer.add_audio( + f"inference_targ_{b}", + targ_wave, + num_updates, + sample_rate=self.sr + ) + tb_writer.add_audio( + f"inference_pred_{b}", + pred_wave, + num_updates, + sample_rate=self.sr + ) + + +def save_figure_to_numpy(fig): + data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='') + data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,)) + return data + + +DEFAULT_V_MIN = np.log(1e-5) + + +def plot_tts_output( + data_2d, title_2d, data_1d, title_1d, figsize=(24, 4), + v_min=DEFAULT_V_MIN, v_max=3, ret_np=False, suptitle="" +): + try: + import matplotlib.pyplot as plt + from mpl_toolkits.axes_grid1 import make_axes_locatable + except ImportError: + raise ImportError("Please install Matplotlib: pip install matplotlib") + + data_2d = [ + x.detach().cpu().float().numpy() + if isinstance(x, torch.Tensor) else x for x in data_2d + ] + fig, axes = plt.subplots(1, len(data_2d) + 1, figsize=figsize) + if suptitle: + fig.suptitle(suptitle[:400]) # capped at 400 chars + axes = [axes] if len(data_2d) == 0 else axes + for ax, x, name in zip(axes, data_2d, title_2d): + ax.set_title(name) + divider = make_axes_locatable(ax) + cax = divider.append_axes('right', size='5%', pad=0.05) + im = ax.imshow( + x, origin="lower", aspect="auto", vmin=max(x.min(), v_min), + vmax=min(x.max(), v_max) + ) + fig.colorbar(im, cax=cax, orientation='vertical') + + if isinstance(data_1d, torch.Tensor): + data_1d = data_1d.detach().cpu().numpy() + axes[-1].plot(data_1d) + axes[-1].set_title(title_1d) + plt.tight_layout() + + if ret_np: + fig.canvas.draw() + data = save_figure_to_numpy(fig) + plt.close(fig) + return data + + +def antidiag_indices(offset, min_i=0, max_i=None, min_j=0, max_j=None): + """ + for a (3, 4) matrix with min_i=1, max_i=3, min_j=1, max_j=4, outputs + + offset=2 (1, 1), + offset=3 (2, 1), (1, 2) + offset=4 (2, 2), (1, 3) + offset=5 (2, 3) + + constraints: + i + j = offset + min_j <= j < max_j + min_i <= offset - j < max_i + """ + if max_i is None: + max_i = offset + 1 + if max_j is None: + max_j = offset + 1 + min_j = max(min_j, offset - max_i + 1, 0) + max_j = min(max_j, offset - min_i + 1, offset + 1) + j = torch.arange(min_j, max_j) + i = offset - j + return torch.stack([i, j]) + + +def batch_dynamic_time_warping(distance, shapes=None): + """full batched DTW without any constraints + + distance: (batchsize, max_M, max_N) matrix + shapes: (batchsize,) vector specifying (M, N) for each entry + """ + # ptr: 0=left, 1=up-left, 2=up + ptr2dij = {0: (0, -1), 1: (-1, -1), 2: (-1, 0)} + + bsz, m, n = distance.size() + cumdist = torch.zeros_like(distance) + backptr = torch.zeros_like(distance).type(torch.int32) - 1 + + # initialize + cumdist[:, 0, :] = distance[:, 0, :].cumsum(dim=-1) + cumdist[:, :, 0] = distance[:, :, 0].cumsum(dim=-1) + backptr[:, 0, :] = 0 + backptr[:, :, 0] = 2 + + # DP with optimized anti-diagonal parallelization, O(M+N) steps + for offset in range(2, m + n - 1): + ind = antidiag_indices(offset, 1, m, 1, n) + c = torch.stack( + [cumdist[:, ind[0], ind[1] - 1], cumdist[:, ind[0] - 1, ind[1] - 1], + cumdist[:, ind[0] - 1, ind[1]], ], + dim=2 + ) + v, b = c.min(axis=-1) + backptr[:, ind[0], ind[1]] = b.int() + cumdist[:, ind[0], ind[1]] = v + distance[:, ind[0], ind[1]] + + # backtrace + pathmap = torch.zeros_like(backptr) + for b in range(bsz): + i = m - 1 if shapes is None else (shapes[b][0] - 1).item() + j = n - 1 if shapes is None else (shapes[b][1] - 1).item() + dtwpath = [(i, j)] + while (i != 0 or j != 0) and len(dtwpath) < 10000: + assert (i >= 0 and j >= 0) + di, dj = ptr2dij[backptr[b, i, j].item()] + i, j = i + di, j + dj + dtwpath.append((i, j)) + dtwpath = dtwpath[::-1] + indices = torch.from_numpy(np.array(dtwpath)) + pathmap[b, indices[:, 0], indices[:, 1]] = 1 + + return cumdist, backptr, pathmap + + +def compute_l2_dist(x1, x2): + """compute an (m, n) L2 distance matrix from (m, d) and (n, d) matrices""" + return torch.cdist(x1.unsqueeze(0), x2.unsqueeze(0), p=2).squeeze(0).pow(2) + + +def compute_rms_dist(x1, x2): + l2_dist = compute_l2_dist(x1, x2) + return (l2_dist / x1.size(1)).pow(0.5) + + +def get_divisor(pathmap, normalize_type): + if normalize_type is None: + return 1 + elif normalize_type == "len1": + return pathmap.size(0) + elif normalize_type == "len2": + return pathmap.size(1) + elif normalize_type == "path": + return pathmap.sum().item() + else: + raise ValueError(f"normalize_type {normalize_type} not supported") + + +def batch_compute_distortion(y1, y2, sr, feat_fn, dist_fn, normalize_type): + d, s, x1, x2 = [], [], [], [] + for cur_y1, cur_y2 in zip(y1, y2): + assert (cur_y1.ndim == 1 and cur_y2.ndim == 1) + cur_x1 = feat_fn(cur_y1) + cur_x2 = feat_fn(cur_y2) + x1.append(cur_x1) + x2.append(cur_x2) + + cur_d = dist_fn(cur_x1, cur_x2) + d.append(cur_d) + s.append(d[-1].size()) + max_m = max(ss[0] for ss in s) + max_n = max(ss[1] for ss in s) + d = torch.stack( + [F.pad(dd, (0, max_n - dd.size(1), 0, max_m - dd.size(0))) for dd in d] + ) + s = torch.LongTensor(s).to(d.device) + cumdists, backptrs, pathmaps = batch_dynamic_time_warping(d, s) + + rets = [] + itr = zip(s, x1, x2, d, cumdists, backptrs, pathmaps) + for (m, n), cur_x1, cur_x2, dist, cumdist, backptr, pathmap in itr: + cumdist = cumdist[:m, :n] + backptr = backptr[:m, :n] + pathmap = pathmap[:m, :n] + divisor = get_divisor(pathmap, normalize_type) + + distortion = cumdist[-1, -1] / divisor + ret = distortion, (cur_x1, cur_x2, dist, cumdist, backptr, pathmap) + rets.append(ret) + return rets + + +def batch_mel_cepstral_distortion( + y1, y2, sr, normalize_type="path", mfcc_fn=None +): + """ + https://arxiv.org/pdf/2011.03568.pdf + + The root mean squared error computed on 13-dimensional MFCC using DTW for + alignment. MFCC features are computed from an 80-channel log-mel + spectrogram using a 50ms Hann window and hop of 12.5ms. + + y1: list of waveforms + y2: list of waveforms + sr: sampling rate + """ + + try: + import torchaudio + except ImportError: + raise ImportError("Please install torchaudio: pip install torchaudio") + + if mfcc_fn is None or mfcc_fn.sample_rate != sr: + melkwargs = { + "n_fft": int(0.05 * sr), "win_length": int(0.05 * sr), + "hop_length": int(0.0125 * sr), "f_min": 20, + "n_mels": 80, "window_fn": torch.hann_window + } + mfcc_fn = torchaudio.transforms.MFCC( + sr, n_mfcc=13, log_mels=True, melkwargs=melkwargs + ).to(y1[0].device) + return batch_compute_distortion( + y1, y2, sr, lambda y: mfcc_fn(y).transpose(-1, -2), compute_rms_dist, + normalize_type + ) diff --git a/fairseq/fairseq/tasks/translation.py b/fairseq/fairseq/tasks/translation.py new file mode 100644 index 0000000000000000000000000000000000000000..86473608677c62b063cd9889ed29d59002523be7 --- /dev/null +++ b/fairseq/fairseq/tasks/translation.py @@ -0,0 +1,493 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import itertools +import json +import logging +import os +from typing import Optional +from argparse import Namespace +from omegaconf import II + +import numpy as np +from fairseq import metrics, utils +from fairseq.data import ( + AppendTokenDataset, + ConcatDataset, + LanguagePairDataset, + PrependTokenDataset, + StripTokenDataset, + TruncateDataset, + data_utils, + encoders, + indexed_dataset, +) +from fairseq.data.indexed_dataset import get_available_dataset_impl +from fairseq.dataclass import ChoiceEnum, FairseqDataclass +from fairseq.tasks import FairseqTask, register_task + + +EVAL_BLEU_ORDER = 4 + + +logger = logging.getLogger(__name__) + + +def load_langpair_dataset( + data_path, + split, + src, + src_dict, + tgt, + tgt_dict, + combine, + dataset_impl, + upsample_primary, + left_pad_source, + left_pad_target, + max_source_positions, + max_target_positions, + prepend_bos=False, + load_alignments=False, + truncate_source=False, + append_source_id=False, + num_buckets=0, + shuffle=True, + pad_to_multiple=1, + prepend_bos_src=None, +): + def split_exists(split, src, tgt, lang, data_path): + filename = os.path.join(data_path, "{}.{}-{}.{}".format(split, src, tgt, lang)) + return indexed_dataset.dataset_exists(filename, impl=dataset_impl) + + src_datasets = [] + tgt_datasets = [] + + for k in itertools.count(): + split_k = split + (str(k) if k > 0 else "") + + # infer langcode + if split_exists(split_k, src, tgt, src, data_path): + prefix = os.path.join(data_path, "{}.{}-{}.".format(split_k, src, tgt)) + elif split_exists(split_k, tgt, src, src, data_path): + prefix = os.path.join(data_path, "{}.{}-{}.".format(split_k, tgt, src)) + else: + if k > 0: + break + else: + raise FileNotFoundError( + "Dataset not found: {} ({})".format(split, data_path) + ) + + src_dataset = data_utils.load_indexed_dataset( + prefix + src, src_dict, dataset_impl + ) + if truncate_source: + src_dataset = AppendTokenDataset( + TruncateDataset( + StripTokenDataset(src_dataset, src_dict.eos()), + max_source_positions - 1, + ), + src_dict.eos(), + ) + src_datasets.append(src_dataset) + + tgt_dataset = data_utils.load_indexed_dataset( + prefix + tgt, tgt_dict, dataset_impl + ) + if tgt_dataset is not None: + tgt_datasets.append(tgt_dataset) + + logger.info( + "{} {} {}-{} {} examples".format( + data_path, split_k, src, tgt, len(src_datasets[-1]) + ) + ) + + if not combine: + break + + assert len(src_datasets) == len(tgt_datasets) or len(tgt_datasets) == 0 + + if len(src_datasets) == 1: + src_dataset = src_datasets[0] + tgt_dataset = tgt_datasets[0] if len(tgt_datasets) > 0 else None + else: + sample_ratios = [1] * len(src_datasets) + sample_ratios[0] = upsample_primary + src_dataset = ConcatDataset(src_datasets, sample_ratios) + if len(tgt_datasets) > 0: + tgt_dataset = ConcatDataset(tgt_datasets, sample_ratios) + else: + tgt_dataset = None + + if prepend_bos: + assert hasattr(src_dict, "bos_index") and hasattr(tgt_dict, "bos_index") + src_dataset = PrependTokenDataset(src_dataset, src_dict.bos()) + if tgt_dataset is not None: + tgt_dataset = PrependTokenDataset(tgt_dataset, tgt_dict.bos()) + elif prepend_bos_src is not None: + logger.info(f"prepending src bos: {prepend_bos_src}") + src_dataset = PrependTokenDataset(src_dataset, prepend_bos_src) + + eos = None + if append_source_id: + src_dataset = AppendTokenDataset( + src_dataset, src_dict.index("[{}]".format(src)) + ) + if tgt_dataset is not None: + tgt_dataset = AppendTokenDataset( + tgt_dataset, tgt_dict.index("[{}]".format(tgt)) + ) + eos = tgt_dict.index("[{}]".format(tgt)) + + align_dataset = None + if load_alignments: + align_path = os.path.join(data_path, "{}.align.{}-{}".format(split, src, tgt)) + if indexed_dataset.dataset_exists(align_path, impl=dataset_impl): + align_dataset = data_utils.load_indexed_dataset( + align_path, None, dataset_impl + ) + + tgt_dataset_sizes = tgt_dataset.sizes if tgt_dataset is not None else None + return LanguagePairDataset( + src_dataset, + src_dataset.sizes, + src_dict, + tgt_dataset, + tgt_dataset_sizes, + tgt_dict, + left_pad_source=left_pad_source, + left_pad_target=left_pad_target, + align_dataset=align_dataset, + eos=eos, + num_buckets=num_buckets, + shuffle=shuffle, + pad_to_multiple=pad_to_multiple, + ) + + +@dataclass +class TranslationConfig(FairseqDataclass): + data: Optional[str] = field( + default=None, + metadata={ + "help": "colon separated path to data directories list, will be iterated upon during epochs " + "in round-robin manner; however, valid and test data are always in the first directory " + "to avoid the need for repeating them in all directories" + }, + ) + source_lang: Optional[str] = field( + default=None, + metadata={ + "help": "source language", + "argparse_alias": "-s", + }, + ) + target_lang: Optional[str] = field( + default=None, + metadata={ + "help": "target language", + "argparse_alias": "-t", + }, + ) + load_alignments: bool = field( + default=False, metadata={"help": "load the binarized alignments"} + ) + left_pad_source: bool = field( + default=True, metadata={"help": "pad the source on the left"} + ) + left_pad_target: bool = field( + default=False, metadata={"help": "pad the target on the left"} + ) + max_source_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the source sequence"} + ) + max_target_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the target sequence"} + ) + upsample_primary: int = field( + default=-1, metadata={"help": "the amount of upsample primary dataset"} + ) + truncate_source: bool = field( + default=False, metadata={"help": "truncate source to max-source-positions"} + ) + num_batch_buckets: int = field( + default=0, + metadata={ + "help": "if >0, then bucket source and target lengths into " + "N buckets and pad accordingly; this is useful on TPUs to minimize the number of compilations" + }, + ) + train_subset: str = II("dataset.train_subset") + dataset_impl: Optional[ChoiceEnum(get_available_dataset_impl())] = II( + "dataset.dataset_impl" + ) + required_seq_len_multiple: int = II("dataset.required_seq_len_multiple") + + # options for reporting BLEU during validation + eval_bleu: bool = field( + default=False, metadata={"help": "evaluation with BLEU scores"} + ) + eval_bleu_args: Optional[str] = field( + default="{}", + metadata={ + "help": 'generation args for BLUE scoring, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + eval_bleu_detok: str = field( + default="space", + metadata={ + "help": "detokenize before computing BLEU (e.g., 'moses'); required if using --eval-bleu; " + "use 'space' to disable detokenization; see fairseq.data.encoders for other options" + }, + ) + eval_bleu_detok_args: Optional[str] = field( + default="{}", + metadata={"help": "args for building the tokenizer, if needed, as JSON string"}, + ) + eval_tokenized_bleu: bool = field( + default=False, metadata={"help": "compute tokenized BLEU instead of sacrebleu"} + ) + eval_bleu_remove_bpe: Optional[str] = field( + default=None, + metadata={ + "help": "remove BPE before computing BLEU", + "argparse_const": "@@ ", + }, + ) + eval_bleu_print_samples: bool = field( + default=False, metadata={"help": "print sample generations during validation"} + ) + + +@register_task("translation", dataclass=TranslationConfig) +class TranslationTask(FairseqTask): + """ + Translate from one (source) language to another (target) language. + + Args: + src_dict (~fairseq.data.Dictionary): dictionary for the source language + tgt_dict (~fairseq.data.Dictionary): dictionary for the target language + + .. note:: + + The translation task is compatible with :mod:`fairseq-train`, + :mod:`fairseq-generate` and :mod:`fairseq-interactive`. + """ + + cfg: TranslationConfig + + def __init__(self, cfg: TranslationConfig, src_dict, tgt_dict): + super().__init__(cfg) + self.src_dict = src_dict + self.tgt_dict = tgt_dict + + @classmethod + def setup_task(cls, cfg: TranslationConfig, **kwargs): + """Setup the task (e.g., load dictionaries). + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + + paths = utils.split_paths(cfg.data) + assert len(paths) > 0 + # find language pair automatically + if cfg.source_lang is None or cfg.target_lang is None: + cfg.source_lang, cfg.target_lang = data_utils.infer_language_pair(paths[0]) + if cfg.source_lang is None or cfg.target_lang is None: + raise Exception( + "Could not infer language pair, please provide it explicitly" + ) + + # load dictionaries + src_dict = cls.load_dictionary( + os.path.join(paths[0], "dict.{}.txt".format(cfg.source_lang)) + ) + tgt_dict = cls.load_dictionary( + os.path.join(paths[0], "dict.{}.txt".format(cfg.target_lang)) + ) + assert src_dict.pad() == tgt_dict.pad() + assert src_dict.eos() == tgt_dict.eos() + assert src_dict.unk() == tgt_dict.unk() + logger.info("[{}] dictionary: {} types".format(cfg.source_lang, len(src_dict))) + logger.info("[{}] dictionary: {} types".format(cfg.target_lang, len(tgt_dict))) + + return cls(cfg, src_dict, tgt_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.cfg.data) + assert len(paths) > 0 + if split != self.cfg.train_subset: + # if not training data set, use the first shard for valid and test + paths = paths[:1] + data_path = paths[(epoch - 1) % len(paths)] + + # infer langcode + src, tgt = self.cfg.source_lang, self.cfg.target_lang + + self.datasets[split] = load_langpair_dataset( + data_path, + split, + src, + self.src_dict, + tgt, + self.tgt_dict, + combine=combine, + dataset_impl=self.cfg.dataset_impl, + upsample_primary=self.cfg.upsample_primary, + left_pad_source=self.cfg.left_pad_source, + left_pad_target=self.cfg.left_pad_target, + max_source_positions=self.cfg.max_source_positions, + max_target_positions=self.cfg.max_target_positions, + load_alignments=self.cfg.load_alignments, + truncate_source=self.cfg.truncate_source, + num_buckets=self.cfg.num_batch_buckets, + shuffle=(split != "test"), + pad_to_multiple=self.cfg.required_seq_len_multiple, + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + return LanguagePairDataset( + src_tokens, + src_lengths, + self.source_dictionary, + tgt_dict=self.target_dictionary, + constraints=constraints, + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + if self.cfg.eval_bleu: + detok_args = json.loads(self.cfg.eval_bleu_detok_args) + self.tokenizer = encoders.build_tokenizer( + Namespace(tokenizer=self.cfg.eval_bleu_detok, **detok_args) + ) + + gen_args = json.loads(self.cfg.eval_bleu_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + return model + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + if self.cfg.eval_bleu: + bleu = self._inference_with_bleu(self.sequence_generator, sample, model) + logging_output["_bleu_sys_len"] = bleu.sys_len + logging_output["_bleu_ref_len"] = bleu.ref_len + # we split counts into separate entries so that they can be + # summed efficiently across workers using fast-stat-sync + assert len(bleu.counts) == EVAL_BLEU_ORDER + for i in range(EVAL_BLEU_ORDER): + logging_output["_bleu_counts_" + str(i)] = bleu.counts[i] + logging_output["_bleu_totals_" + str(i)] = bleu.totals[i] + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + if self.cfg.eval_bleu: + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + counts, totals = [], [] + for i in range(EVAL_BLEU_ORDER): + counts.append(sum_logs("_bleu_counts_" + str(i))) + totals.append(sum_logs("_bleu_totals_" + str(i))) + + if max(totals) > 0: + # log counts as numpy arrays -- log_scalar will sum them correctly + metrics.log_scalar("_bleu_counts", np.array(counts)) + metrics.log_scalar("_bleu_totals", np.array(totals)) + metrics.log_scalar("_bleu_sys_len", sum_logs("_bleu_sys_len")) + metrics.log_scalar("_bleu_ref_len", sum_logs("_bleu_ref_len")) + + def compute_bleu(meters): + import inspect + try: + from sacrebleu.metrics import BLEU + comp_bleu = BLEU.compute_bleu + except ImportError: + # compatibility API for sacrebleu 1.x + import sacrebleu + comp_bleu = sacrebleu.compute_bleu + + fn_sig = inspect.getfullargspec(comp_bleu)[0] + if "smooth_method" in fn_sig: + smooth = {"smooth_method": "exp"} + else: + smooth = {"smooth": "exp"} + bleu = comp_bleu( + correct=meters["_bleu_counts"].sum, + total=meters["_bleu_totals"].sum, + sys_len=meters["_bleu_sys_len"].sum, + ref_len=meters["_bleu_ref_len"].sum, + **smooth + ) + return round(bleu.score, 2) + + metrics.log_derived("bleu", compute_bleu) + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.cfg.max_source_positions, self.cfg.max_target_positions) + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.src_dict + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary`.""" + return self.tgt_dict + + def _inference_with_bleu(self, generator, sample, model): + import sacrebleu + + def decode(toks, escape_unk=False): + s = self.tgt_dict.string( + toks.int().cpu(), + self.cfg.eval_bleu_remove_bpe, + # The default unknown string in fairseq is `<unk>`, but + # this is tokenized by sacrebleu as `< unk >`, inflating + # BLEU scores. Instead, we use a somewhat more verbose + # alternative that is unlikely to appear in the real + # reference, but doesn't get split into multiple tokens. + unk_string=("UNKNOWNTOKENINREF" if escape_unk else "UNKNOWNTOKENINHYP"), + ) + if self.tokenizer: + s = self.tokenizer.decode(s) + return s + + gen_out = self.inference_step(generator, [model], sample, prefix_tokens=None) + hyps, refs = [], [] + for i in range(len(gen_out)): + hyps.append(decode(gen_out[i][0]["tokens"])) + refs.append( + decode( + utils.strip_pad(sample["target"][i], self.tgt_dict.pad()), + escape_unk=True, # don't count <unk> as matches to the hypo + ) + ) + if self.cfg.eval_bleu_print_samples: + logger.info("example hypothesis: " + hyps[0]) + logger.info("example reference: " + refs[0]) + if self.cfg.eval_tokenized_bleu: + return sacrebleu.corpus_bleu(hyps, [refs], tokenize="none") + else: + return sacrebleu.corpus_bleu(hyps, [refs]) diff --git a/fairseq/fairseq/tasks/translation_from_pretrained_bart.py b/fairseq/fairseq/tasks/translation_from_pretrained_bart.py new file mode 100644 index 0000000000000000000000000000000000000000..0fd7a5b29f0e34699b5d5ef7574bc39b8c6052c9 --- /dev/null +++ b/fairseq/fairseq/tasks/translation_from_pretrained_bart.py @@ -0,0 +1,132 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import torch +from fairseq import utils +from fairseq.data import LanguagePairDataset + +from . import register_task +from .translation import TranslationTask, load_langpair_dataset + + +@register_task("translation_from_pretrained_bart") +class TranslationFromPretrainedBARTTask(TranslationTask): + """ + Translate from source language to target language with a model initialized with a multilingual pretrain. + + Args: + src_dict (~fairseq.data.Dictionary): dictionary for the source language + tgt_dict (~fairseq.data.Dictionary): dictionary for the target language + + .. note:: + + The translation task is compatible with :mod:`fairseq-train`, + :mod:`fairseq-generate` and :mod:`fairseq-interactive`. + + The translation task provides the following additional command-line + arguments: + + .. argparse:: + :ref: fairseq.tasks.translation_parser + :prog: + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + TranslationTask.add_args(parser) + parser.add_argument('--langs', type=str, metavar='LANG', + help='comma-separated list of monolingual language, ' + 'for example, "en,de,fr". These should match the ' + 'langs from pretraining (and be in the same order). ' + 'You should always add all pretraining language idx ' + 'during finetuning.') + parser.add_argument('--prepend-bos', action='store_true', + help='prepend bos token to each sentence, which matches ' + 'mBART pretraining') + # fmt: on + + def __init__(self, args, src_dict, tgt_dict): + super().__init__(args, src_dict, tgt_dict) + self.langs = args.langs.split(",") + for d in [src_dict, tgt_dict]: + for l in self.langs: + d.add_symbol("[{}]".format(l)) + d.add_symbol("<mask>") + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.args.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + # infer langcode + src, tgt = self.args.source_lang, self.args.target_lang + + self.datasets[split] = load_langpair_dataset( + data_path, + split, + src, + self.src_dict, + tgt, + self.tgt_dict, + combine=combine, + dataset_impl=self.args.dataset_impl, + upsample_primary=self.args.upsample_primary, + left_pad_source=self.args.left_pad_source, + left_pad_target=self.args.left_pad_target, + max_source_positions=getattr(self.args, "max_source_positions", 1024), + max_target_positions=getattr(self.args, "max_target_positions", 1024), + load_alignments=self.args.load_alignments, + prepend_bos=getattr(self.args, "prepend_bos", False), + append_source_id=True, + ) + + def build_generator(self, models, args, **unused): + if getattr(args, "score_reference", False): + from fairseq.sequence_scorer import SequenceScorer + + return SequenceScorer( + self.target_dictionary, + eos=self.tgt_dict.index("[{}]".format(self.args.target_lang)), + ) + else: + from fairseq.sequence_generator import SequenceGenerator + + return SequenceGenerator( + models, + self.target_dictionary, + beam_size=getattr(args, "beam", 5), + max_len_a=getattr(args, "max_len_a", 0), + max_len_b=getattr(args, "max_len_b", 200), + min_len=getattr(args, "min_len", 1), + normalize_scores=(not getattr(args, "unnormalized", False)), + len_penalty=getattr(args, "lenpen", 1), + unk_penalty=getattr(args, "unkpen", 0), + temperature=getattr(args, "temperature", 1.0), + match_source_len=getattr(args, "match_source_len", False), + no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0), + eos=self.tgt_dict.index("[{}]".format(self.args.target_lang)), + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + src_lang_id = self.source_dictionary.index("[{}]".format(self.args.source_lang)) + source_tokens = [] + for s_t in src_tokens: + s_t = torch.cat([s_t, s_t.new(1).fill_(src_lang_id)]) + source_tokens.append(s_t) + dataset = LanguagePairDataset( + source_tokens, + src_lengths, + self.source_dictionary, + tgt_dict=self.target_dictionary, + constraints=constraints, + ) + return dataset diff --git a/fairseq/fairseq/tasks/translation_from_pretrained_xlm.py b/fairseq/fairseq/tasks/translation_from_pretrained_xlm.py new file mode 100644 index 0000000000000000000000000000000000000000..a05f2891524a8b23482e206c1742c3b816b77afb --- /dev/null +++ b/fairseq/fairseq/tasks/translation_from_pretrained_xlm.py @@ -0,0 +1,39 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass +from fairseq.data.legacy.masked_lm_dictionary import MaskedLMDictionary +from fairseq.tasks.translation import TranslationConfig, TranslationTask + +from . import register_task + + +@dataclass +class TranslationFromPretrainedXLMConfig(TranslationConfig): + pass + + +@register_task( + "translation_from_pretrained_xlm", dataclass=TranslationFromPretrainedXLMConfig +) +class TranslationFromPretrainedXLMTask(TranslationTask): + """ + Same as TranslationTask except use the MaskedLMDictionary class so that + we can load data that was binarized with the MaskedLMDictionary class. + + This task should be used for the entire training pipeline when we want to + train an NMT model from a pretrained XLM checkpoint: binarizing NMT data, + training NMT with the pretrained XLM checkpoint, and subsequent evaluation + of that trained model. + """ + + @classmethod + def load_dictionary(cls, filename): + """Load the masked LM dictionary from the filename + + Args: + filename (str): the filename + """ + return MaskedLMDictionary.load(filename) diff --git a/fairseq/fairseq/tasks/translation_lev.py b/fairseq/fairseq/tasks/translation_lev.py new file mode 100644 index 0000000000000000000000000000000000000000..041279305dc4978f6a3a4178c5ec4c72c5fb2b5c --- /dev/null +++ b/fairseq/fairseq/tasks/translation_lev.py @@ -0,0 +1,191 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from dataclasses import dataclass, field +import torch +from fairseq import utils +from fairseq.data import LanguagePairDataset +from fairseq.dataclass import ChoiceEnum +from fairseq.tasks import register_task +from fairseq.tasks.translation import TranslationConfig, TranslationTask, load_langpair_dataset +from fairseq.utils import new_arange + + +NOISE_CHOICES = ChoiceEnum(["random_delete", "random_mask", "no_noise", "full_mask"]) + +@dataclass +class TranslationLevenshteinConfig(TranslationConfig): + noise: NOISE_CHOICES = field( + default="random_delete", + metadata={ + "help": "type of noise" + }, + ) + +@register_task("translation_lev", dataclass=TranslationLevenshteinConfig) +class TranslationLevenshteinTask(TranslationTask): + """ + Translation (Sequence Generation) task for Levenshtein Transformer + See `"Levenshtein Transformer" <https://arxiv.org/abs/1905.11006>`_. + """ + + cfg: TranslationLevenshteinConfig + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + paths = utils.split_paths(self.cfg.data) + assert len(paths) > 0 + data_path = paths[(epoch - 1) % len(paths)] + + # infer langcode + src, tgt = self.cfg.source_lang, self.cfg.target_lang + + self.datasets[split] = load_langpair_dataset( + data_path, + split, + src, + self.src_dict, + tgt, + self.tgt_dict, + combine=combine, + dataset_impl=self.cfg.dataset_impl, + upsample_primary=self.cfg.upsample_primary, + left_pad_source=self.cfg.left_pad_source, + left_pad_target=self.cfg.left_pad_target, + max_source_positions=self.cfg.max_source_positions, + max_target_positions=self.cfg.max_target_positions, + prepend_bos=True, + ) + + def inject_noise(self, target_tokens): + def _random_delete(target_tokens): + pad = self.tgt_dict.pad() + bos = self.tgt_dict.bos() + eos = self.tgt_dict.eos() + + max_len = target_tokens.size(1) + target_mask = target_tokens.eq(pad) + target_score = target_tokens.clone().float().uniform_() + target_score.masked_fill_( + target_tokens.eq(bos) | target_tokens.eq(eos), 0.0 + ) + target_score.masked_fill_(target_mask, 1) + target_score, target_rank = target_score.sort(1) + target_length = target_mask.size(1) - target_mask.float().sum( + 1, keepdim=True + ) + + # do not delete <bos> and <eos> (we assign 0 score for them) + target_cutoff = ( + 2 + + ( + (target_length - 2) + * target_score.new_zeros(target_score.size(0), 1).uniform_() + ).long() + ) + target_cutoff = target_score.sort(1)[1] >= target_cutoff + + prev_target_tokens = ( + target_tokens.gather(1, target_rank) + .masked_fill_(target_cutoff, pad) + .gather(1, target_rank.masked_fill_(target_cutoff, max_len).sort(1)[1]) + ) + prev_target_tokens = prev_target_tokens[ + :, : prev_target_tokens.ne(pad).sum(1).max() + ] + + return prev_target_tokens + + def _random_mask(target_tokens): + pad = self.tgt_dict.pad() + bos = self.tgt_dict.bos() + eos = self.tgt_dict.eos() + unk = self.tgt_dict.unk() + + target_masks = ( + target_tokens.ne(pad) & target_tokens.ne(bos) & target_tokens.ne(eos) + ) + target_score = target_tokens.clone().float().uniform_() + target_score.masked_fill_(~target_masks, 2.0) + target_length = target_masks.sum(1).float() + target_length = target_length * target_length.clone().uniform_() + target_length = target_length + 1 # make sure to mask at least one token. + + _, target_rank = target_score.sort(1) + target_cutoff = new_arange(target_rank) < target_length[:, None].long() + prev_target_tokens = target_tokens.masked_fill( + target_cutoff.scatter(1, target_rank, target_cutoff), unk + ) + return prev_target_tokens + + def _full_mask(target_tokens): + pad = self.tgt_dict.pad() + bos = self.tgt_dict.bos() + eos = self.tgt_dict.eos() + unk = self.tgt_dict.unk() + + target_mask = ( + target_tokens.eq(bos) | target_tokens.eq(eos) | target_tokens.eq(pad) + ) + return target_tokens.masked_fill(~target_mask, unk) + + if self.cfg.noise == "random_delete": + return _random_delete(target_tokens) + elif self.cfg.noise == "random_mask": + return _random_mask(target_tokens) + elif self.cfg.noise == "full_mask": + return _full_mask(target_tokens) + elif self.cfg.noise == "no_noise": + return target_tokens + else: + raise NotImplementedError + + def build_generator(self, models, args, **unused): + # add models input to match the API for SequenceGenerator + from fairseq.iterative_refinement_generator import IterativeRefinementGenerator + + return IterativeRefinementGenerator( + self.target_dictionary, + eos_penalty=getattr(args, "iter_decode_eos_penalty", 0.0), + max_iter=getattr(args, "iter_decode_max_iter", 10), + beam_size=getattr(args, "iter_decode_with_beam", 1), + reranking=getattr(args, "iter_decode_with_external_reranker", False), + decoding_format=getattr(args, "decoding_format", None), + adaptive=not getattr(args, "iter_decode_force_max_iter", False), + retain_history=getattr(args, "retain_iter_history", False), + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + if constraints is not None: + # Though see Susanto et al. (ACL 2020): https://www.aclweb.org/anthology/2020.acl-main.325/ + raise NotImplementedError( + "Constrained decoding with the translation_lev task is not supported" + ) + + return LanguagePairDataset( + src_tokens, src_lengths, self.source_dictionary, append_bos=True + ) + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False + ): + model.train() + sample["prev_target"] = self.inject_noise(sample["target"]) + loss, sample_size, logging_output = criterion(model, sample) + if ignore_grad: + loss *= 0 + optimizer.backward(loss) + return loss, sample_size, logging_output + + def valid_step(self, sample, model, criterion): + model.eval() + with torch.no_grad(): + sample["prev_target"] = self.inject_noise(sample["target"]) + loss, sample_size, logging_output = criterion(model, sample) + return loss, sample_size, logging_output diff --git a/fairseq/fairseq/tasks/translation_multi_simple_epoch.py b/fairseq/fairseq/tasks/translation_multi_simple_epoch.py new file mode 100644 index 0000000000000000000000000000000000000000..6f36e5b93e98497de31969d203ae04dbb4bd9306 --- /dev/null +++ b/fairseq/fairseq/tasks/translation_multi_simple_epoch.py @@ -0,0 +1,430 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import datetime +import logging +import time + +import torch +from fairseq.data import ( + FairseqDataset, + LanguagePairDataset, + ListDataset, + data_utils, + iterators, +) +from fairseq.data.multilingual.multilingual_data_manager import ( + MultilingualDatasetManager, +) +from fairseq.data.multilingual.sampling_method import SamplingMethod +from fairseq.tasks import LegacyFairseqTask, register_task +from fairseq.utils import FileContentsAction + + +### +def get_time_gap(s, e): + return ( + datetime.datetime.fromtimestamp(e) - datetime.datetime.fromtimestamp(s) + ).__str__() + + +### + + +logger = logging.getLogger(__name__) + + +@register_task("translation_multi_simple_epoch") +class TranslationMultiSimpleEpochTask(LegacyFairseqTask): + """ + Translate from one (source) language to another (target) language. + + Args: + langs (List[str]): a list of languages that are being supported + dicts (Dict[str, fairseq.data.Dictionary]): mapping from supported languages to their dictionaries + training (bool): whether the task should be configured for training or not + + .. note:: + + The translation task is compatible with :mod:`fairseq-train`, + :mod:`fairseq-generate` and :mod:`fairseq-interactive`. + + The translation task provides the following additional command-line + arguments: + + .. argparse:: + :ref: fairseq.tasks.translation_parser + :prog: + """ + + @staticmethod + def add_args(parser): + """Add task-specific arguments to the parser.""" + # fmt: off + parser.add_argument('-s', '--source-lang', default=None, metavar='SRC', + help='inference source language') + parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET', + help='inference target language') + parser.add_argument('--lang-pairs', default=None, metavar='PAIRS', + help='comma-separated list of language pairs (in training order): en-de,en-fr,de-fr', + action=FileContentsAction) + parser.add_argument('--keep-inference-langtok', action='store_true', + help='keep language tokens in inference output (e.g. for analysis or debugging)') + + SamplingMethod.add_arguments(parser) + MultilingualDatasetManager.add_args(parser) + # fmt: on + + def __init__(self, args, langs, dicts, training): + super().__init__(args) + self.langs = langs + self.dicts = dicts + self.training = training + if training: + self.lang_pairs = args.lang_pairs + else: + self.lang_pairs = ["{}-{}".format(args.source_lang, args.target_lang)] + # eval_lang_pairs for multilingual translation is usually all of the + # lang_pairs. However for other multitask settings or when we want to + # optimize for certain languages we want to use a different subset. Thus + # the eval_lang_pairs class variable is provided for classes that extend + # this class. + self.eval_lang_pairs = self.lang_pairs + # model_lang_pairs will be used to build encoder-decoder model pairs in + # models.build_model(). This allows multitask type of sub-class can + # build models other than the input lang_pairs + self.model_lang_pairs = self.lang_pairs + self.source_langs = [d.split("-")[0] for d in self.lang_pairs] + self.target_langs = [d.split("-")[1] for d in self.lang_pairs] + self.check_dicts(self.dicts, self.source_langs, self.target_langs) + + self.sampling_method = SamplingMethod.build_sampler(args, self) + self.data_manager = MultilingualDatasetManager.setup_data_manager( + args, self.lang_pairs, langs, dicts, self.sampling_method + ) + + def check_dicts(self, dicts, source_langs, target_langs): + if self.args.source_dict is not None or self.args.target_dict is not None: + # no need to check whether the source side and target side are sharing dictionaries + return + src_dict = dicts[source_langs[0]] + tgt_dict = dicts[target_langs[0]] + for src_lang in source_langs: + assert ( + src_dict == dicts[src_lang] + ), "Diffrent dictionary are specified for different source languages; " + "TranslationMultiSimpleEpochTask only supports one shared dictionary across all source languages" + for tgt_lang in target_langs: + assert ( + tgt_dict == dicts[tgt_lang] + ), "Diffrent dictionary are specified for different target languages; " + "TranslationMultiSimpleEpochTask only supports one shared dictionary across all target languages" + + @classmethod + def setup_task(cls, args, **kwargs): + langs, dicts, training = MultilingualDatasetManager.prepare( + cls.load_dictionary, args, **kwargs + ) + return cls(args, langs, dicts, training) + + def has_sharded_data(self, split): + return self.data_manager.has_sharded_data(split) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + """Load a given dataset split. + + Args: + split (str): name of the split (e.g., train, valid, test) + """ + if split in self.datasets: + dataset = self.datasets[split] + if self.has_sharded_data(split): + if self.args.virtual_epoch_size is not None: + if dataset.load_next_shard: + shard_epoch = dataset.shard_epoch + else: + # no need to load next shard so skip loading + # also this avoid always loading from beginning of the data + return + else: + shard_epoch = epoch + else: + # estimate the shard epoch from virtual data size and virtual epoch size + shard_epoch = self.data_manager.estimate_global_pass_epoch(epoch) + logger.info(f"loading data for {split} epoch={epoch}/{shard_epoch}") + logger.info(f"mem usage: {data_utils.get_mem_usage()}") + if split in self.datasets: + del self.datasets[split] + logger.info("old dataset deleted manually") + logger.info(f"mem usage: {data_utils.get_mem_usage()}") + self.datasets[split] = self.data_manager.load_dataset( + split, + self.training, + epoch=epoch, + combine=combine, + shard_epoch=shard_epoch, + **kwargs, + ) + + def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None): + if constraints is not None: + raise NotImplementedError( + "Constrained decoding with the multilingual_translation task is not supported" + ) + + src_data = ListDataset(src_tokens, src_lengths) + dataset = LanguagePairDataset(src_data, src_lengths, self.source_dictionary) + src_langtok_spec, tgt_langtok_spec = self.args.langtoks["main"] + if self.args.lang_tok_replacing_bos_eos: + dataset = self.data_manager.alter_dataset_langtok( + dataset, + src_eos=self.source_dictionary.eos(), + src_lang=self.args.source_lang, + tgt_eos=self.target_dictionary.eos(), + tgt_lang=self.args.target_lang, + src_langtok_spec=src_langtok_spec, + tgt_langtok_spec=tgt_langtok_spec, + ) + else: + dataset.src = self.data_manager.src_dataset_tranform_func( + self.args.source_lang, + self.args.target_lang, + dataset=dataset.src, + spec=src_langtok_spec, + ) + return dataset + + def build_generator( + self, + models, + args, + seq_gen_cls=None, + extra_gen_cls_kwargs=None, + ): + if not getattr(args, "keep_inference_langtok", False): + _, tgt_langtok_spec = self.args.langtoks["main"] + if tgt_langtok_spec: + tgt_lang_tok = self.data_manager.get_decoder_langtok( + self.args.target_lang, tgt_langtok_spec + ) + extra_gen_cls_kwargs = extra_gen_cls_kwargs or {} + extra_gen_cls_kwargs["symbols_to_strip_from_output"] = {tgt_lang_tok} + + return super().build_generator( + models, args, seq_gen_cls=None, extra_gen_cls_kwargs=extra_gen_cls_kwargs + ) + + def build_model(self, args): + return super().build_model(args) + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + return loss, sample_size, logging_output + + def inference_step( + self, generator, models, sample, prefix_tokens=None, constraints=None + ): + with torch.no_grad(): + _, tgt_langtok_spec = self.args.langtoks["main"] + if not self.args.lang_tok_replacing_bos_eos: + if prefix_tokens is None and tgt_langtok_spec: + tgt_lang_tok = self.data_manager.get_decoder_langtok( + self.args.target_lang, tgt_langtok_spec + ) + src_tokens = sample["net_input"]["src_tokens"] + bsz = src_tokens.size(0) + prefix_tokens = ( + torch.LongTensor([[tgt_lang_tok]]).expand(bsz, 1).to(src_tokens) + ) + return generator.generate( + models, + sample, + prefix_tokens=prefix_tokens, + constraints=constraints, + ) + else: + return generator.generate( + models, + sample, + prefix_tokens=prefix_tokens, + bos_token=self.data_manager.get_decoder_langtok( + self.args.target_lang, tgt_langtok_spec + ) + if tgt_langtok_spec + else self.target_dictionary.eos(), + ) + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.args.max_source_positions, self.args.max_target_positions) + + @property + def source_dictionary(self): + return self.data_manager.get_source_dictionary(self.source_langs[0]) + + @property + def target_dictionary(self): + return self.data_manager.get_target_dictionary(self.target_langs[0]) + + def create_batch_sampler_func( + self, + max_positions, + ignore_invalid_inputs, + max_tokens, + max_sentences, + required_batch_size_multiple=1, + seed=1, + ): + def construct_batch_sampler(dataset, epoch): + splits = [ + s for s, _ in self.datasets.items() if self.datasets[s] == dataset + ] + split = splits[0] if len(splits) > 0 else None + # NEW implementation + if epoch is not None: + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # get indices ordered by example size + start_time = time.time() + logger.info(f"start batch sampler: mem usage: {data_utils.get_mem_usage()}") + + with data_utils.numpy_seed(seed): + indices = dataset.ordered_indices() + logger.info( + f"[{split}] @batch_sampler order indices time: {get_time_gap(start_time, time.time())}" + ) + logger.info(f"mem usage: {data_utils.get_mem_usage()}") + + # filter examples that are too large + if max_positions is not None: + my_time = time.time() + indices = self.filter_indices_by_size( + indices, dataset, max_positions, ignore_invalid_inputs + ) + logger.info( + f"[{split}] @batch_sampler filter_by_size time: {get_time_gap(my_time, time.time())}" + ) + logger.info(f"mem usage: {data_utils.get_mem_usage()}") + + # create mini-batches with given size constraints + my_time = time.time() + batch_sampler = dataset.batch_by_size( + indices, + max_tokens=max_tokens, + max_sentences=max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + ) + + logger.info( + f"[{split}] @batch_sampler batch_by_size time: {get_time_gap(my_time, time.time())}" + ) + logger.info( + f"[{split}] per epoch batch_sampler set-up time: {get_time_gap(start_time, time.time())}" + ) + logger.info(f"mem usage: {data_utils.get_mem_usage()}") + + return batch_sampler + + return construct_batch_sampler + + # we need to override get_batch_iterator because we want to reset the epoch iterator each time + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + """ + Get an iterator that yields batches of data from the given dataset. + + Args: + dataset (~fairseq.data.FairseqDataset): dataset to batch + max_tokens (int, optional): max number of tokens in each batch + (default: None). + max_sentences (int, optional): max number of sentences in each + batch (default: None). + max_positions (optional): max sentence length supported by the + model (default: None). + ignore_invalid_inputs (bool, optional): don't raise Exception for + sentences that are too long (default: False). + required_batch_size_multiple (int, optional): require batch size to + be a multiple of N (default: 1). + seed (int, optional): seed for random number generator for + reproducibility (default: 1). + num_shards (int, optional): shard the data iterator into N + shards (default: 1). + shard_id (int, optional): which shard of the data iterator to + return (default: 0). + num_workers (int, optional): how many subprocesses to use for data + loading. 0 means the data will be loaded in the main process + (default: 0). + epoch (int, optional): the epoch to start the iterator from + (default: 0). + data_buffer_size (int, optional): number of batches to + preload (default: 0). + disable_iterator_cache (bool, optional): don't cache the + EpochBatchIterator (ignores `FairseqTask::can_reuse_epoch_itr`) + (default: False). + Returns: + ~fairseq.iterators.EpochBatchIterator: a batched iterator over the + given dataset split + """ + # initialize the dataset with the correct starting epoch + assert isinstance(dataset, FairseqDataset) + if dataset in self.dataset_to_epoch_iter: + return self.dataset_to_epoch_iter[dataset] + if self.args.sampling_method == "RoundRobin": + batch_iter = super().get_batch_iterator( + dataset, + max_tokens=max_tokens, + max_sentences=max_sentences, + max_positions=max_positions, + ignore_invalid_inputs=ignore_invalid_inputs, + required_batch_size_multiple=required_batch_size_multiple, + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + epoch=epoch, + data_buffer_size=data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ) + self.dataset_to_epoch_iter[dataset] = batch_iter + return batch_iter + + construct_batch_sampler = self.create_batch_sampler_func( + max_positions, + ignore_invalid_inputs, + max_tokens, + max_sentences, + required_batch_size_multiple=required_batch_size_multiple, + seed=seed, + ) + + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=construct_batch_sampler, + seed=seed, + num_shards=num_shards, + shard_id=shard_id, + num_workers=num_workers, + epoch=epoch, + ) + return epoch_iter diff --git a/fairseq/fairseq/token_generation_constraints.py b/fairseq/fairseq/token_generation_constraints.py new file mode 100644 index 0000000000000000000000000000000000000000..e708dc51bcb0ffb7b411496239c74d5e6f3c2448 --- /dev/null +++ b/fairseq/fairseq/token_generation_constraints.py @@ -0,0 +1,506 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +"""Implements tracking of constraints for a beam item. + +A list of constraints is given as a list of one or more token +sequences, each of length at least one token. For example, for an input sentence + +> Die maschinelle Übersetzung ist schwer zu kontrollieren. + +We could have the constraints: +* to influence +* hard + +There are two implementations: +* OrderedConstraintState: Tracks progress through an ordered list of multitoken constraints. +* UnorderedConstraintState: Tracks progress through an unordered list of multitoken constraints. + +The difference is that in the first, the constraints are assumed to be +in order; the algorithm will permit zero or more tokens between them. +In the second, the constraints are not ordered, so many orderings will +be explored. + +The same sequence can be present any number of times, and will appear +that many times in the output. +""" + +from collections import Counter +from typing import List, Optional, Set, Tuple + +import torch + + +class ConstraintState: + def __init__(self): + pass + + +def pack_constraints(batch_constraints: List[List[torch.Tensor]]) -> torch.Tensor: + """Takes a list of list of constraints in tensor form (a list of + tensor constraints for each sentence) and transforms it into a + packed Tensor. For example, here is a batch of size 3 with 3, 0, + and 1 constraints: + + [ [ [3 1 2], [3], [4 5 6 7], ] + [], + [ [1 8 9 10 1 4 11 12], ] + ] + + Its corresponding packed structure is: + + [ [ 3 3 1 2 0 3 0 4 5 6 7 0], + [ 0 0 0 0 0 0 0 0 0 0 0 0], + [ 1 1 8 9 10 1 4 11 12 0 0 0] ] + + The packed tensor has shape (batch size, maxlen), where + maxlen is defined below. Each row contains concatenated + constraint tokens for that sentence, with 0 appended after + each constraint. The first item in each row is the number + of constraints for that sentence. So maxlen is the maximum + of + + (number of constraints) + (sum length of constraints) + 1. + + across all sentences in the batch. + """ + # The maximum word length of concatenated constraints for any sentence + max_constraints_len = 1 + for sentence_constraints in batch_constraints: + if len(sentence_constraints): + # number of constraints, plus sum of constrain lens, plus a zero after each + constraints_len = ( + 1 + + sum([c.size(0) for c in sentence_constraints]) + + len(sentence_constraints) + ) + max_constraints_len = max(max_constraints_len, constraints_len) + + batch_size = len(batch_constraints) + constraints_tensor = torch.zeros((batch_size, max_constraints_len)).long() + for i, sentence_constraints in enumerate(batch_constraints): + constraints_tensor[i, 0] = len(sentence_constraints) + offset = 1 + for j, constraint in enumerate(sentence_constraints): + this_len = constraint.size(0) + constraints_tensor[i, offset : offset + this_len] = constraint + offset += this_len + 1 + + return constraints_tensor.long() + + +def unpack_constraints(constraint_tensor: torch.Tensor) -> List[torch.Tensor]: + """ + Transforms *one row* of a packed constraint tensor (e.g., for one + sentence in the batch) into a list of constraint tensors. + """ + constraint_list = [] + num_constraints = constraint_tensor[0] + constraints = constraint_tensor.tolist() + offset = 1 + for i in range(num_constraints): + where = constraints.index(0, offset) + constraint_list.append(constraint_tensor[offset:where]) + offset = where + 1 + + return constraint_list + + +class ConstraintNode: + """ + Represents a node in a trie managing unordered constraints. + """ + + def __init__(self, token: int = None, parent=None): + # The token associate with this node (None for the root) + self.token = int(token) if token is not None else None + # The parent (None at the root) + self.parent = parent + # Whether this node is a completed constraint + self.terminal = 0 + # List of child nodes + self.children = {} + + # The cumulative number of constraints from this point in the + # trie forward + self.num_constraints = 0 + + @property + def id(self): + return self.token + + def __str__(self): + term = self.terminal != 0 + return f"[{self.token}].{term}#{self.num_constraints}" + + def __getitem__(self, key: int): + return self.children.get(key, None) + + def next_tokens(self) -> Set[int]: + """The set of child labels.""" + return set(self.children.keys()) + + @staticmethod + def create(constraints: List[List[int]]): + root = ConstraintNode() + for sequence in constraints: + root.add_sequence(sequence) + + return root + + @staticmethod + def print_graph(node: "ConstraintNode"): + if len(node.children) == 0: + return str(node) + else: + s = f"({node}" + for child in node.children.values(): + s += " " + ConstraintNode.print_graph(child) + s += ")" + return s + + def token_counts(self) -> Counter: + """Returns a counter of the number of times each token is used + in a constraint. + """ + token_counts = Counter() + kids = list(self.children.values()) + while len(kids) > 0: + kid = kids.pop() + token_counts[kid.id] += kid.num_constraints + kids += list(kid.children.values()) + + return token_counts + + def tokens(self) -> Set[int]: + """Returns the set of tokens in constraints.""" + return set(self.token_counts().keys()) + + def add_sequence(self, sequence: List[int]): + """Adds a constraint, represented as a list of integers, to + the trie.""" + assert len(sequence) > 0 + + token = int(sequence[0]) + if token not in self.children: + self.children[token] = ConstraintNode(token, parent=self) + + node = self.children[token] + if len(sequence) == 1: + node.terminal += 1 + node.num_constraints += 1 + parent = node.parent + while parent is not None: + parent.num_constraints += 1 + parent = parent.parent + else: + node.add_sequence(sequence[1:]) + + +class UnorderedConstraintState(ConstraintState): + """ + Records progress through the set of constraints for each item in the beam + using a trie. + """ + + def __init__(self, node: ConstraintNode, copy_from: "ConstraintState" = None): + self.node = node + + if copy_from is None: + # The root node + self.root = node + # The set of states in the graph that have been completed + self.completed = Counter() + # The... + self.generated = Counter() + # The list of tokens we need to generate + self.needed_tokens = self.root.tokens() + else: + self.completed = Counter(copy_from.completed) + self.generated = Counter(copy_from.generated) + self.root = copy_from.root + + # Mark the node as generated + if self.node != self.root: + self.generated[node] += 1 + + @staticmethod + def create(constraint_tensor: torch.Tensor): + constraint_list = unpack_constraints(constraint_tensor) + constraint_trie_root = ConstraintNode.create(constraint_list) + return UnorderedConstraintState(constraint_trie_root) + + def __str__(self): + gen_str = ",".join([str(node) for node in self.generated]) + return f"{self.name}/{self.bank}({gen_str})x{self.num_completed}" + + def __copy__(self): + copied_state = UnorderedConstraintState(self.node, copy_from=self) + return copied_state + + def copy(self): + return self.__copy__() + + @property + def name(self): + if self.node.id is None: + return "ROOT" + else: + return str(self.node.id) + + @property + def is_root(self): + return self.node == self.root + + @property + def bank(self): + return sum(self.generated.values()) + + @property + def num_completed(self): + """The number of constraints (not constraint tokens) that are completed. + In addition to the already-completed states, we need to account for the + current state, which might get marked as completed when another token + is generated. + """ + in_final = self.node.terminal and self.completed[self.node] < self.node.terminal + return sum(self.completed.values()) + in_final + + @property + def finished(self): + return self.root.num_constraints - self.num_completed == 0 + + @property + def token_counts(self): + return self.root.token_counts() + + @property + def tokens(self): + return self.root.tokens() + + @property + def num_constraint_tokens(self): + return sum(self.token_counts.values()) + + def next_tokens(self) -> Set[int]: + """Returns the list of tokens that could come next. + These are (a) all tokens extending the root state and, for + non-root states, additionally all tokens extending the current + state.""" + + if self.node != self.root: + return self.root.next_tokens().union(self.node.next_tokens()) + else: + return self.root.next_tokens() + + def advance(self, token: int): + """Reads in a token and advances the state. Here's how it works. + + We can advance to the next state if: + - there is a matching child + - its path isn't blocked + + A path is blocked when all constraints that are descendants of + that node have already been generated, in the current state. + + If we are not able to advance from the current state, we "fall + off the graph" and return to the root state. There, we again + try to advance, checking the same criteria. + + In any case, when falling off the graph, we need to do some + bookkeeping. We: + - check whether any constraints were met (all prefixes of + current state) + - if one is found, mark it as completed + - adjust visited nodes accordingly + """ + token = int(token) + + next_state = None + child = self.node[token] + if child is not None and self.generated[child] < child.num_constraints: + next_state = UnorderedConstraintState(child, copy_from=self) + + def rewind(): + """If we're mid-trie and an "illegal" token is chosen next, we need + to reset our state to the root state. However, along the way, we need + to check whether a prefix of the current trie state represents a state + we could mark as completed. + """ + node = self.node + while node != self.root: + if node.terminal and self.completed[node] < node.terminal: + next_state.completed[node] += 1 + return + + next_state.generated[node] -= 1 + node = node.parent + + # Fall off the graph, check the root + if next_state is None and token in self.root.next_tokens(): + child = self.root[token] + # We can only traverse this edge if it's not saturated + if self.generated[child] < child.num_constraints: + next_state = UnorderedConstraintState(child, copy_from=self) + else: + next_state = UnorderedConstraintState(self.root, copy_from=self) + + # Rewind + rewind() + + elif next_state is None: + next_state = UnorderedConstraintState(self.root, copy_from=self) + # Rewind + rewind() + + return next_state + + +class ConstraintSequence: + def __init__(self, sequences: List[List[int]]): + """Represents a set of possibly multitoken constraints by + concatenating them and internally recording the end points. + """ + self.sequences = [] + self.endpoints = [] + self.num_tokens = 0 + self.tokens = set() + for sequence in sequences: + for token in sequence: + self.tokens.add(token) + self.num_tokens += len(sequence) + self.endpoints += [False for x in range(len(sequence) - 1)] + [True] + self.sequences += sequence + + def __getitem__(self, key: int): + return self.sequences[key] + + def __len__(self): + return len(self.sequences) + + def __str__(self): + return str(self.sequences) + + +class OrderedConstraintState(ConstraintState): + """ + Records progress through the set of linear nonbranching constraints with gaps. + """ + + def __init__(self, sequence: ConstraintSequence, state: int = -1): + self.sequence = sequence + self.state = state + + @staticmethod + def create(constraint_tensor: torch.Tensor): + constraint_list = unpack_constraints(constraint_tensor) + return OrderedConstraintState(ConstraintSequence(constraint_list), -1) + + def __str__(self): + return f"{self.state}/{self.bank}x{self.num_completed}" + + def __copy__(self): + return OrderedConstraintState(self.sequence, self.state) + + def copy(self): + return self.__copy__() + + @property + def num_completed(self): + if self.state == -1: + return 0 + count = len( + list(filter(lambda x: x, self.sequence.endpoints[0 : self.state + 1])) + ) + return count + + @property + def is_root(self): + return self.state == -1 + + @property + def name(self): + if self.state == -1: + return "ROOT" + else: + return str(self.sequence[self.state]) + + @property + def bank(self) -> int: + return self.state + 1 + + @property + def finished(self): + return self.state + 1 == len(self.sequence) + + @property + def token_counts(self): + return self.sequence.token_counts() + + @property + def tokens(self): + return self.sequence.tokens + + @property + def num_constraint_tokens(self): + return sum(self.token_counts.values()) + + def next_tokens(self) -> Set[int]: + """Returns the list of tokens that could come next. + These are (a) all tokens extending the root state and, for + non-root states, additionally all tokens extending the current + state.""" + + tokens = set() + if self.state > 0: + tokens.add(self.sequence[0]) + if not self.finished: + tokens.add(self.sequence[self.state + 1]) + return tokens + + def advance(self, token: int): + """Reads in a token and advances the state. Here's how it works. + + We can advance to the next state if: + - there is a matching child + - its path isn't blocked + + A path is blocked when all constraints that are descendants of + that node have already been generated, in the current state. + + If we are not able to advance from the current state, we "fall + off the graph" and return to the root state. There, we again + try to advance, checking the same criteria. + + In any case, when falling off the graph, we need to do some + bookkeeping. We: + - check whether any constraints were met (all prefixes of + current state) + - if one is found, mark it as completed + - adjust visited nodes accordingly + """ + token = int(token) + # print(f"{self} ADVANCE({token}) {self.sequence} -> ", end="") + + if self.finished: + # Accept anything + next_state = self.copy() + + elif self.sequence[self.state + 1] == token: + # Advance to the next token + next_state = OrderedConstraintState(self.sequence, self.state + 1) + + elif self.sequence.endpoints[self.state]: + # Accept anything between constraints (*) + next_state = self.copy() + + elif token == self.sequence[0]: + # Start over having generated the first token + next_state = OrderedConstraintState(self.sequence, 0) + else: + # Start over from the root + next_state = OrderedConstraintState(self.sequence, -1) + + return next_state diff --git a/fairseq/fairseq/tokenizer.py b/fairseq/fairseq/tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..42131f7b1d334020c3b48a6e44d4139f7c62ad28 --- /dev/null +++ b/fairseq/fairseq/tokenizer.py @@ -0,0 +1,15 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import re + + +SPACE_NORMALIZER = re.compile(r"\s+") + + +def tokenize_line(line): + line = SPACE_NORMALIZER.sub(" ", line) + line = line.strip() + return line.split() diff --git a/fairseq/fairseq/trainer.py b/fairseq/fairseq/trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..e46ccfe0b8d3a224586fb16c69168321f60ce30e --- /dev/null +++ b/fairseq/fairseq/trainer.py @@ -0,0 +1,1509 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Train a network across multiple GPUs. +""" + +import contextlib +import logging +import sys +import time +from argparse import Namespace +from itertools import chain +from typing import Any, Dict, List + +import torch +from fairseq import checkpoint_utils, models, optim, utils +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.distributed import utils as distributed_utils +from fairseq.file_io import PathManager +from fairseq.logging import meters, metrics +from fairseq.models.ema import build_ema +from fairseq.nan_detector import NanDetector +from fairseq.optim import lr_scheduler +from omegaconf import OmegaConf + +logger = logging.getLogger(__name__) + + +class Trainer(object): + """Main class for data parallel training. + + This class supports synchronous distributed data parallel training, + where multiple workers each have a full model replica and gradients + are accumulated across workers before each update. We use + :class:`~torch.nn.parallel.DistributedDataParallel` to handle + communication of the gradients across workers. + """ + + def __init__(self, cfg: FairseqConfig, task, model, criterion, quantizer=None): + + if isinstance(cfg, Namespace): + logger.warning( + "argparse.Namespace configuration is deprecated! Automatically converting to OmegaConf" + ) + cfg = convert_namespace_to_omegaconf(cfg) + + self.cfg = cfg + self.task = task + + # catalog shared parameters + shared_params = _catalog_shared_params(model) + self.tpu = cfg.common.tpu + self.cuda = torch.cuda.is_available() and not cfg.common.cpu and not self.tpu + if self.cuda: + self.device = torch.device("cuda") + elif self.tpu: + self.device = utils.get_tpu_device() + else: + self.device = torch.device("cpu") + + if self.is_fsdp: + import fairscale + if self.cfg.common.bf16: + raise ValueError( + "FullyShardedDataParallel is not compatible with --bf16 or " + "--memory-efficient-bf16" + ) + if self.cfg.distributed_training.zero_sharding != "none": + raise ValueError( + "FullyShardedDataParallel is not compatible with --zero-sharding " + "option (it's already built in)" + ) + if max(self.cfg.optimization.update_freq) > 1 and fairscale.__version__ < "0.4.0": + raise RuntimeError( + "Please update to fairscale 0.4.0 or newer when combining " + "--update-freq with FullyShardedDataParallel" + ) + else: + if ( + hasattr(self.cfg.distributed_training, "cpu_offload") + and self.cfg.distributed_training.cpu_offload + ): + raise ValueError("--cpu-offload requires --ddp-backend=fully_sharded") + + # copy model and criterion to current device/dtype + self._criterion = criterion + self._model = model + if not self.is_fsdp: + if cfg.common.fp16: + assert not cfg.common.amp, "Cannot use fp16 and AMP together" + self._criterion = self._criterion.half() + self._model = self._model.half() + elif cfg.common.bf16: + self._criterion = self._criterion.to(dtype=torch.bfloat16) + self._model = self._model.to(dtype=torch.bfloat16) + elif cfg.common.amp: + self._amp_retries = 0 + if ( + not cfg.distributed_training.pipeline_model_parallel + # the DistributedFairseqModel wrapper will handle moving to device, + # so only handle cases which don't use the wrapper + and not self.use_distributed_wrapper + ): + self._criterion = self._criterion.to(device=self.device) + self._model = self._model.to(device=self.device) + self.pipeline_model_parallel = cfg.distributed_training.pipeline_model_parallel + self.last_device = None + if self.cuda and self.pipeline_model_parallel: + self.last_device = torch.device( + cfg.distributed_training.pipeline_devices[-1] + ) + + # check that shared parameters are preserved after device transfer + for shared_param in shared_params: + ref = _get_module_by_path(self._model, shared_param[0]) + for path in shared_param[1:]: + logger.info( + "detected shared parameter: {} <- {}".format(shared_param[0], path) + ) + _set_module_by_path(self._model, path, ref) + + self._dummy_batch = None # indicates we don't have a dummy batch at first + self._lr_scheduler = None + self._num_updates = 0 + self._num_xla_compiles = 0 # for TPUs + self._optim_history = None + self._optimizer = None + self._warn_once = set() + self._wrapped_criterion = None + self._wrapped_model = None + self._ema = None + + # TODO(myleott): support tpu + if self.cuda and self.data_parallel_world_size > 1: + self._grad_norm_buf = torch.cuda.DoubleTensor(self.data_parallel_world_size) + else: + self._grad_norm_buf = None + + self.quantizer = quantizer + if self.quantizer is not None: + self.quantizer.set_trainer(self) + + # get detailed cuda environment + if self.cuda: + self.cuda_env = utils.CudaEnvironment() + if self.data_parallel_world_size > 1: + self.cuda_env_arr = distributed_utils.all_gather_list( + self.cuda_env, group=distributed_utils.get_global_group() + ) + else: + self.cuda_env_arr = [self.cuda_env] + if self.data_parallel_rank == 0: + utils.CudaEnvironment.pretty_print_cuda_env_list(self.cuda_env_arr) + else: + self.cuda_env = None + self.cuda_env_arr = None + + metrics.log_start_time("wall", priority=790, round=0) + + self._start_time = time.time() + self._previous_training_time = 0 + self._cumulative_training_time = None + + def reinitialize(self): + """Reinitialize the Trainer, typically after model params change.""" + self._lr_scheduler = None + self._optimizer = None + self._wrapped_criterion = None + self._wrapped_model = None + + @property + def data_parallel_world_size(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 1 + return distributed_utils.get_data_parallel_world_size() + + @property + def data_parallel_process_group(self): + return distributed_utils.get_data_parallel_group() + + @property + def data_parallel_rank(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 0 + return distributed_utils.get_data_parallel_rank() + + @property + def is_data_parallel_master(self): + # NOTE: this returns true for all model parallel replicas with data + # parallel rank 0 + return self.data_parallel_rank == 0 + + @property + def use_distributed_wrapper(self) -> bool: + return ( + self.data_parallel_world_size > 1 and not self.cfg.optimization.use_bmuf + ) or ( + self.is_fsdp and self.cfg.distributed_training.cpu_offload + ) + + @property + def should_save_checkpoint_on_current_rank(self) -> bool: + """Indicates whether to save checkpoints on the current DDP rank.""" + if ( + self.is_fsdp and self.cfg.distributed_training.use_sharded_state + ) or getattr(self.cfg.model, "base_layers", 0) > 0: + return True + else: + return self.is_data_parallel_master + + @property + def always_call_state_dict_during_save_checkpoint(self) -> bool: + if self.is_fsdp and not self.cfg.distributed_training.use_sharded_state: + # FSDP calls communication collective when consolidating checkpoints + return True + else: + return False + + @property + def checkpoint_suffix(self) -> str: + """Suffix to add to the checkpoint file name.""" + if self.is_fsdp and self.cfg.distributed_training.use_sharded_state: + return self.cfg.checkpoint.checkpoint_suffix + "-shard{0}".format( + self.data_parallel_rank + ) + else: + return self.cfg.checkpoint.checkpoint_suffix or "" + + @property + def criterion(self): + if self._wrapped_criterion is None: + if utils.has_parameters(self._criterion) and self.use_distributed_wrapper: + self._wrapped_criterion = models.DistributedFairseqModel( + self.cfg.distributed_training, + self._criterion, + process_group=self.data_parallel_process_group, + device=self.device, + ) + else: + self._wrapped_criterion = self._criterion + return self._wrapped_criterion + + @property + def model(self): + if self._wrapped_model is None: + if self.use_distributed_wrapper: + self._wrapped_model = models.DistributedFairseqModel( + self.cfg.distributed_training, + self._model, + process_group=self.data_parallel_process_group, + device=self.device, + ) + else: + self._wrapped_model = self._model + return self._wrapped_model + + @property + def ema(self): + if self._ema is None: + self._build_ema() + return self._ema + + def _build_ema(self): + if self.cfg.ema.store_ema: + self._ema = build_ema(self._model, self.cfg.ema, self.device) + logger.info( + "Exponential Moving Average Shadow Model is initialized." + ) + + @property + def optimizer(self): + if self._optimizer is None: + self._build_optimizer() + return self._optimizer + + @property + def lr_scheduler(self): + if self._lr_scheduler is None: + self._build_optimizer() # this will initialize self._lr_scheduler + return self._lr_scheduler + + def _build_optimizer(self): + params = list( + filter( + lambda p: p.requires_grad, + chain(self.model.parameters(), self.criterion.parameters()), + ) + ) + + if self.is_fsdp and self.cfg.common.fp16: + # FullyShardedDataParallel always uses MemoryEfficientFP16 wrapper, + # mostly for the grad scaling. But if we don't have the + # --memory-efficient-fp16 flag set, then we're effectively doing + # regular --fp16 and can allow the use of optimizers that would + # otherwise be unsupported by MemoryEfficientFP16Optimizer. + allow_unsupported = not self.cfg.common.memory_efficient_fp16 + self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer( + self.cfg, params, allow_unsupported=allow_unsupported + ) + elif self.cfg.common.fp16 or self.cfg.common.bf16 or self.cfg.common.amp: + if self.cuda and torch.cuda.get_device_capability(0)[0] < 7: + logger.info( + "NOTE: your device does NOT support faster training with --fp16 or --amp, " + "please switch to FP32 which is likely to be faster" + ) + if ( + self.cfg.common.memory_efficient_fp16 + or self.cfg.common.memory_efficient_bf16 + ): + self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer( + self.cfg, params + ) + elif self.cfg.common.amp: + self._optimizer = optim.AMPOptimizer.build_optimizer(self.cfg, params) + else: + self._optimizer = optim.FP16Optimizer.build_optimizer(self.cfg, params) + else: + if self.cuda and torch.cuda.get_device_capability(0)[0] >= 7: + logger.info("NOTE: your device may support faster training with --fp16 or --amp") + self._optimizer = optim.build_optimizer(self.cfg.optimizer, params) + + if self.is_fsdp: + assert ( + not self.cfg.optimization.use_bmuf + ), "--ddp-backend=fully_sharded is not compatible with BMUF" + assert self._optimizer.supports_flat_params, ( + "--ddp-backend=fully_sharded is only compatible with pointwise " + "optimizers (e.g., Adam, AdamW, Adadelta, Adamax, SGD, etc.). " + "However, the sharding will result in slightly different results when " + "using non-pointwise optimizers (e.g., Adagrad, Adafactor, LAMB)" + ) + + if self.cfg.optimization.use_bmuf: + self._optimizer = optim.FairseqBMUF( + self.cfg.bmuf, + self._optimizer, + ) + + if self.cfg.distributed_training.zero_sharding == "os": + if ( + self.cfg.common.fp16 + and not self.cfg.common.memory_efficient_fp16 + and not self.cfg.common.memory_efficient_bf16 + ) and not self.cfg.common.fp16_no_flatten_grads: + raise ValueError( + "ZeRO is incomptabile with fp16 and flattened grads. " + "Please use --fp16-no-flatten-grads" + ) + else: + optim.shard_(self._optimizer, self.data_parallel_process_group) + + # We should initialize the learning rate scheduler immediately after + # building the optimizer, so that the initial learning rate is set. + self._lr_scheduler = lr_scheduler.build_lr_scheduler( + self.cfg.lr_scheduler, + self.optimizer, + ) + self._lr_scheduler.step_update(0) + + @property + def is_fsdp(self): + return self.cfg.distributed_training.ddp_backend == "fully_sharded" + + def consolidate_optimizer(self): + """For OSS, we need to consolidate the state dict.""" + if self.cfg.checkpoint.no_save_optimizer_state: + return + self._gathered_optim_state = None + if hasattr(self.optimizer.optimizer, "consolidate_state_dict"): + self.optimizer.optimizer.consolidate_state_dict() + elif self.is_fsdp and not self.model.use_sharded_state: + st = self.model.gather_full_optim_state_dict( + self.optimizer + ) # only returns on rank 0 + self._gathered_optim_state = st + + def state_dict(self): + state_dict = { + "args": None, # legacy + "cfg": ( + OmegaConf.to_container(self.cfg, resolve=True, enum_to_str=True) + if OmegaConf.is_config(self.cfg) + else self.cfg + ), + "model": self.model.state_dict(), + "criterion": ( + self.criterion.state_dict() + if utils.has_parameters(self.criterion) + else None + ), + "optimizer_history": (self._optim_history or []) + + [ + { + "criterion_name": self.get_criterion().__class__.__name__, + "optimizer_name": self.optimizer.__class__.__name__, + "lr_scheduler_state": self.lr_scheduler.state_dict(), + "num_updates": self.get_num_updates(), + } + ], + "task_state": self.task.state_dict() if self.task is not None else {}, + "extra_state": { + "metrics": metrics.state_dict(), + "previous_training_time": self.cumulative_training_time(), + }, + } + if self.cfg.ema.store_ema: + # Save EMA model state as extra state + state_dict["extra_state"]["ema"] = self.ema.get_model().state_dict() + if self.cfg.ema.ema_fp32: + # Save EMA params in fp32 + state_dict["extra_state"]["ema_fp32_params"] = self.ema.fp32_params + if not self.cfg.checkpoint.no_save_optimizer_state: + if self._gathered_optim_state is not None: + state_dict["last_optimizer_state"] = self._gathered_optim_state + self._gathered_optim_state = None + else: + state_dict["last_optimizer_state"] = self.optimizer.state_dict() + if self.is_fsdp: + # save meta data for recombining checkpoint upon loading + state_dict["fsdp_metadata"] = self.model.local_metadata_dict() + return state_dict + + def save_checkpoint(self, filename, extra_state): + """Save all training state in a checkpoint file.""" + logger.info(f"Saving checkpoint to {filename}") + # call state_dict on all ranks in case it needs internal communication + state_dict = utils.move_to_cpu(self.state_dict()) + state_dict["extra_state"].update(extra_state) + if self.should_save_checkpoint_on_current_rank: + checkpoint_utils.torch_persistent_save( + state_dict, + filename, + async_write=self.cfg.checkpoint.write_checkpoints_asynchronously, + ) + logger.info(f"Finished saving checkpoint to {filename}") + + def load_checkpoint( + self, + filename, + reset_optimizer=False, + reset_lr_scheduler=False, + optimizer_overrides=None, + reset_meters=False, + ): + """ + Load all training state from a checkpoint file. + rank = 0 will load the checkpoint, and then broadcast it to all + other ranks. + """ + extra_state, self._optim_history, last_optim_state = None, [], None + + logger.info(f"Preparing to load checkpoint {filename}") + is_distributed = self.data_parallel_world_size > 1 + bexists = PathManager.isfile(filename) + if bexists: + load_on_all_ranks = ( + self.cfg.checkpoint.load_checkpoint_on_all_dp_ranks + # TPUs don't support broadcast yet, so load checkpoints + # on every worker for now + or self.tpu + # FSDP requires loading checkpoint shards on all ranks + or (self.is_fsdp and self.cfg.distributed_training.use_sharded_state) + or getattr(self.cfg.model, "base_layers", 0) > 0 + ) + + if load_on_all_ranks or self.data_parallel_rank == 0: + state = checkpoint_utils.load_checkpoint_to_cpu( + filename, load_on_all_ranks=load_on_all_ranks + ) + last_optim_state = state.get("last_optimizer_state", None) + + # If doing zero_sharding, do not broadcast global optimizer + # state. Later we will broadcast sharded states to each rank + # to avoid memory from exploding. + if ( + not load_on_all_ranks + and self.cfg.distributed_training.zero_sharding == "os" + and "last_optimizer_state" in state + and is_distributed + ): + state["last_optimizer_state"] = "SHARDED" + else: + last_optim_state = None + state = None + + if is_distributed and not load_on_all_ranks: + state = distributed_utils.broadcast_object( + state, + src_rank=0, + group=self.data_parallel_process_group, + dist_device=self.device, + ) + if self.data_parallel_rank > 0: + last_optim_state = state.get("last_optimizer_state", None) + + # load model parameters + try: + self.model.load_state_dict( + state["model"], strict=True, model_cfg=self.cfg.model + ) + # save memory for later steps + del state["model"] + if utils.has_parameters(self.get_criterion()): + self.get_criterion().load_state_dict( + state["criterion"], strict=True + ) + del state["criterion"] + + except Exception: + raise Exception( + "Cannot load model parameters from checkpoint {}; " + "please ensure that the architectures match.".format(filename) + ) + extra_state = state["extra_state"] + self._optim_history = state["optimizer_history"] + + if last_optim_state is not None and not reset_optimizer: + # rebuild optimizer after loading model, since params may have changed + self._build_optimizer() + + # only reload optimizer and lr_scheduler if they match + last_optim = self._optim_history[-1] + assert ( + last_optim["criterion_name"] == self.get_criterion().__class__.__name__ + ), f"Criterion does not match; please reset the optimizer (--reset-optimizer). {last_optim['criterion_name']} vs {self.get_criterion().__class__.__name__}" + assert ( + last_optim["optimizer_name"] == self.optimizer.__class__.__name__ + ), f"Optimizer does not match; please reset the optimizer (--reset-optimizer). {last_optim['optimizer_name']} vs {self.optimizer.__class__.__name__}" + + if not reset_lr_scheduler: + self.lr_scheduler.load_state_dict(last_optim["lr_scheduler_state"]) + + if self.is_fsdp and not self.model.use_sharded_state: + # if use_sharded_state, the last_optim_state is already sharded, skip this + last_optim_state = self.model.get_shard_from_optim_state_dict( + last_optim_state + ) + elif not load_on_all_ranks and is_distributed: + last_optim_state = self.optimizer.broadcast_global_state_dict( + last_optim_state + ) + + self.optimizer.load_state_dict(last_optim_state, optimizer_overrides) + + self.set_num_updates(last_optim["num_updates"]) + + if extra_state is not None: + itr_state = extra_state["train_iterator"] + epoch = itr_state["epoch"] + + if "previous_training_time" in extra_state: + self._previous_training_time = extra_state["previous_training_time"] + self._start_time = time.time() + + self.lr_step(epoch) + + if ( + itr_state.get("version", 1) >= 2 + and itr_state["iterations_in_epoch"] == 0 + ): + # reset meters at start of epoch + reset_meters = True + + if "metrics" in extra_state and not reset_meters: + metrics.load_state_dict(extra_state["metrics"]) + + # reset TimeMeters, since their start times don't make sense anymore + for meter in metrics.get_meters("default"): + if isinstance(meter, meters.TimeMeter): + meter.reset() + + if self.cfg.ema.store_ema: + if "ema" not in extra_state: + logger.warn( + "EMA not found in checkpoint. But store_ema is True. " + "EMA is re-initialized from checkpoint." + ) + self.ema.restore(state["model"], build_fp32_params=self.cfg.ema.ema_fp32) + else: + logger.info( + "Loading EMA from checkpoint" + ) + self.ema.restore(extra_state["ema"], build_fp32_params=False) + + if self.cfg.ema.ema_fp32: + if "ema_fp32_params" in extra_state: + logger.info( + "Loading EMA fp32 params from checkpoint" + ) + self.ema.build_fp32_params(extra_state["ema_fp32_params"]) + else: + logger.info( + "Building EMA fp32 params from EMA model in checkpoint" + ) + self.ema.build_fp32_params() + + logger.info( + "Loaded checkpoint {} (epoch {} @ {} updates)".format( + filename, epoch, self.get_num_updates() + ) + ) + + else: + logger.info("No existing checkpoint found {}".format(filename)) + + return extra_state + + def get_train_iterator( + self, + epoch, + combine=True, + load_dataset=True, + data_selector=None, + shard_batch_itr=True, + disable_iterator_cache=False, + ): + """Return an EpochBatchIterator over the training set for a given epoch.""" + if load_dataset: + logger.info("loading train data for epoch {}".format(epoch)) + self.task.load_dataset( + self.cfg.dataset.train_subset, + epoch=epoch, + combine=combine, + data_selector=data_selector, + tpu=self.tpu, + ) + batch_iterator = self.task.get_batch_iterator( + dataset=self.task.dataset(self.cfg.dataset.train_subset), + max_tokens=self.cfg.dataset.max_tokens, + max_sentences=self.cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + self.task.max_positions(), + self.model.max_positions(), + self.cfg.dataset.max_tokens, + ), + ignore_invalid_inputs=True, + required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple, + seed=self.cfg.common.seed, + num_shards=self.data_parallel_world_size if shard_batch_itr else 1, + shard_id=self.data_parallel_rank if shard_batch_itr else 0, + num_workers=self.cfg.dataset.num_workers, + epoch=epoch, + data_buffer_size=self.cfg.dataset.data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ) + self.reset_dummy_batch(batch_iterator.first_batch) + return batch_iterator + + def get_valid_iterator( + self, + subset, + disable_iterator_cache=False, + ): + """Return an EpochBatchIterator over given validation subset for a given epoch.""" + batch_iterator = self.task.get_batch_iterator( + dataset=self.task.dataset(subset), + max_tokens=self.cfg.dataset.max_tokens_valid, + max_sentences=self.cfg.dataset.batch_size_valid, + max_positions=utils.resolve_max_positions( + self.task.max_positions(), + self.model.max_positions(), + ), + ignore_invalid_inputs=self.cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple, + seed=self.cfg.common.seed, + num_shards=self.data_parallel_world_size, + shard_id=self.data_parallel_rank, + num_workers=self.cfg.dataset.num_workers, + # always pass a fixed "epoch" to keep validation data consistent + # across training epochs + epoch=1, + data_buffer_size=self.cfg.dataset.data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ) + self.reset_dummy_batch(batch_iterator.first_batch) + return batch_iterator + + def begin_epoch(self, epoch): + """Called at the beginning of each epoch.""" + logger.info("begin training epoch {}".format(epoch)) + + self.lr_step_begin_epoch(epoch) + + if self.quantizer is not None: + self.quantizer.begin_epoch(epoch) + + # task specific setup per epoch + self.task.begin_epoch(epoch, self.get_model()) + + if self.tpu: + import torch_xla.core.xla_model as xm + + xm.rendezvous("begin_epoch") # wait for all workers + xm.mark_step() + + def begin_valid_epoch(self, epoch): + """Called at the beginning of each validation epoch.""" + + # task specific setup per validation epoch + self.task.begin_valid_epoch(epoch, self.get_model()) + + def reset_dummy_batch(self, batch): + self._dummy_batch = batch + + @metrics.aggregate("train") + def train_step(self, samples, raise_oom=False): + """Do forward, backward and parameter update.""" + self._set_seed() + self.model.train() + self.criterion.train() + self.zero_grad() + + metrics.log_start_time("train_wall", priority=800, round=0) + + # If EMA is enabled through store_ema=True + # and task.uses_ema is True, pass the EMA model as a keyword + # argument to the task. + extra_kwargs = {} + if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False): + extra_kwargs["ema_model"] = self.ema.get_model() + + # forward and backward pass + logging_outputs, sample_size, ooms = [], 0, 0 + for i, sample in enumerate(samples): # delayed update loop + sample, is_dummy_batch = self._prepare_sample(sample) + + def maybe_no_sync(): + """ + Whenever *samples* contains more than one mini-batch, we + want to accumulate gradients locally and only call + all-reduce in the last backwards pass. + """ + if ( + self.data_parallel_world_size > 1 + and hasattr(self.model, "no_sync") + and i < len(samples) - 1 + # The no_sync context manager results in increased memory + # usage with FSDP, since full-size gradients will be + # accumulated on each GPU. It's typically a better tradeoff + # to do the extra communication with FSDP. + and not self.is_fsdp + ): + return self.model.no_sync() + else: + return contextlib.ExitStack() # dummy contextmanager + + try: + with maybe_no_sync(): + # forward and backward + loss, sample_size_i, logging_output = self.task.train_step( + sample=sample, + model=self.model, + criterion=self.criterion, + optimizer=self.optimizer, + update_num=self.get_num_updates(), + ignore_grad=is_dummy_batch, + **extra_kwargs, + ) + del loss + + logging_outputs.append(logging_output) + sample_size += sample_size_i + + # emptying the CUDA cache after the first step can + # reduce the chance of OOM + if self.cuda and self.get_num_updates() == 0: + torch.cuda.empty_cache() + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + if raise_oom: + raise e + logger.warning( + "attempting to recover from OOM in forward/backward pass" + ) + ooms += 1 + self.zero_grad() + if self.cuda: + torch.cuda.empty_cache() + if self.cfg.distributed_training.distributed_world_size == 1: + return None + else: + raise e + + if self.tpu and i < len(samples) - 1: + # tpu-comment: every XLA operation before marking step is + # appended to the IR graph, and processing too many batches + # before marking step can lead to OOM errors. + # To handle gradient accumulation use case, we explicitly + # mark step here for every forward pass without a backward pass + self._xla_markstep_and_send_to_cpu() + + if is_dummy_batch: + if torch.is_tensor(sample_size): + sample_size.zero_() + else: + sample_size *= 0.0 + + if torch.is_tensor(sample_size): + sample_size = sample_size.float() + else: + sample_size = float(sample_size) + + # gather logging outputs from all replicas + if self._sync_stats(): + train_time = self._local_cumulative_training_time() + logging_outputs, ( + sample_size, + ooms, + total_train_time, + ) = self._aggregate_logging_outputs( + logging_outputs, sample_size, ooms, train_time, ignore=is_dummy_batch + ) + self._cumulative_training_time = ( + total_train_time / self.data_parallel_world_size + ) + + overflow = False + try: + with torch.autograd.profiler.record_function("reduce-grads"): + # reduce gradients across workers + self.optimizer.all_reduce_grads(self.model) + if utils.has_parameters(self.criterion): + self.optimizer.all_reduce_grads(self.criterion) + + with torch.autograd.profiler.record_function("multiply-grads"): + # multiply gradients by (data_parallel_size / sample_size) since + # DDP normalizes by the number of data parallel workers for + # improved fp16 precision. + # Thus we get (sum_of_gradients / sample_size) at the end. + # In case of fp16, this step also undoes loss scaling. + # (Debugging note: Some optimizers perform this scaling on the + # fly, so inspecting model.parameters() or optimizer.params may + # still show the original, unscaled gradients.) + numer = ( + self.data_parallel_world_size + if not self.cfg.optimization.use_bmuf or self._sync_stats() + else 1 + ) + self.optimizer.multiply_grads(numer / (sample_size or 1.0)) + # Note: (sample_size or 1.0) handles the case of a zero gradient, in a + # way that avoids CPU/device transfers in case sample_size is a GPU or + # TPU object. The assumption is that the gradient itself is also 0. + + with torch.autograd.profiler.record_function("clip-grads"): + # clip grads + grad_norm = self.clip_grad_norm(self.cfg.optimization.clip_norm) + + # check that grad norms are consistent across workers + # on tpu check tensor is slow + if not self.tpu: + if ( + not self.cfg.optimization.use_bmuf + and self.cfg.distributed_training.ddp_backend != "slow_mo" + ): + self._check_grad_norms(grad_norm) + if not torch.isfinite(grad_norm).all(): + # in case of AMP, if gradients are Nan/Inf then + # optimizer step is still required + if self.cfg.common.amp: + overflow = True + else: + # check local gradnorm single GPU case, trigger NanDetector + raise FloatingPointError("gradients are Nan/Inf") + + with torch.autograd.profiler.record_function("optimizer"): + # take an optimization step + self.task.optimizer_step( + self.optimizer, model=self.model, update_num=self.get_num_updates() + ) + if self.cfg.common.amp and overflow: + if self._amp_retries == self.cfg.common.amp_batch_retries: + logger.info("AMP: skipping this batch.") + self._amp_retries = 0 + else: + self._amp_retries += 1 + return self.train_step(samples, raise_oom) # recursion to feed in same batch + + except FloatingPointError: + # re-run the forward and backward pass with hooks attached to print + # out where it fails + self.zero_grad() + with NanDetector(self.get_model()): + for _, sample in enumerate(samples): + sample, _ = self._prepare_sample(sample) + self.task.train_step( + sample, + self.model, + self.criterion, + self.optimizer, + self.get_num_updates(), + ignore_grad=False, + **extra_kwargs, + ) + raise + except OverflowError as e: + overflow = True + logger.info( + f"NOTE: gradient overflow detected, ignoring gradient, {str(e)}" + ) + grad_norm = torch.tensor(0.0).cuda() + self.zero_grad() + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + logger.error("OOM during optimization, irrecoverable") + raise e + + # Some distributed wrappers (e.g., SlowMo) need access to the optimizer + # after the step + if hasattr(self.model, "perform_additional_optimizer_actions"): + if hasattr(self.optimizer, "fp32_params"): + self.model.perform_additional_optimizer_actions( + self.optimizer.optimizer, self.optimizer.fp32_params + ) + else: + self.model.perform_additional_optimizer_actions( + self.optimizer.optimizer + ) + + logging_output = None + if not overflow or self.cfg.distributed_training.ddp_backend == "slow_mo": + self.set_num_updates(self.get_num_updates() + 1) + + if self.cfg.ema.store_ema: + # Step EMA forward with new model. + self.ema.step( + self.get_model(), + self.get_num_updates(), + ) + metrics.log_scalar( + "ema_decay", + self.ema.get_decay(), + priority=10000, + round=5, + weight=0, + ) + + if self.tpu: + import torch_xla.core.xla_model as xm + + # mark step on TPUs + self._xla_markstep_and_send_to_cpu() + + # only log stats every log_interval steps + # this causes wps to be misreported when log_interval > 1 + logging_output = {} + if self.get_num_updates() % self.cfg.common.log_interval == 0: + # log memory usage + mem_info = xm.get_memory_info(self.device) + gb_free = mem_info["kb_free"] / 1024 / 1024 + gb_total = mem_info["kb_total"] / 1024 / 1024 + metrics.log_scalar( + "gb_free", gb_free, priority=1500, round=1, weight=0 + ) + metrics.log_scalar( + "gb_total", gb_total, priority=1600, round=1, weight=0 + ) + logging_outputs = self._xla_markstep_and_send_to_cpu( + logging_outputs + ) + logging_output = self._reduce_and_log_stats( + logging_outputs, sample_size, grad_norm + ) + + # log whenever there's an XLA compilation, since these + # slow down training and may indicate opportunities for + # optimization + self._check_xla_compilation() + else: + if self.cuda and self.cuda_env is not None: + # log minimum free memory over the iteration + gb_used = torch.cuda.max_memory_allocated() / 1024 / 1024 / 1024 + torch.cuda.reset_peak_memory_stats() + gb_free = self.cuda_env.total_memory_in_GB - gb_used + metrics.log_scalar( + "gb_free", gb_free, priority=1500, round=1, weight=0 + ) + + # log stats + logging_output = self._reduce_and_log_stats( + logging_outputs, sample_size, grad_norm + ) + + # clear CUDA cache to reduce memory fragmentation + if ( + self.cuda + and self.cfg.common.empty_cache_freq > 0 + and ( + (self.get_num_updates() + self.cfg.common.empty_cache_freq - 1) + % self.cfg.common.empty_cache_freq + ) + == 0 + ): + torch.cuda.empty_cache() + + if self.cfg.common.fp16 or self.cfg.common.amp: + metrics.log_scalar( + "loss_scale", + ( + self.optimizer.scaler.loss_scale + if self.cfg.common.fp16 + else self.optimizer.scaler.get_scale() + ), + priority=700, + round=4, + weight=0, + ) + + metrics.log_stop_time("train_wall") + return logging_output + + @metrics.aggregate("valid") + def valid_step(self, sample, raise_oom=False): + """Do forward pass in evaluation mode.""" + if self.tpu: + import torch_xla.core.xla_model as xm + + xm.rendezvous("valid_step") # wait for all workers + + # If EMA is enabled through store_ema=True + # and task.uses_ema is True, pass the EMA model as a keyword + # argument to the task. + extra_kwargs = {} + if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False): + extra_kwargs["ema_model"] = self.ema.get_model() + + with torch.no_grad(): + self.model.eval() + self.criterion.eval() + + sample, is_dummy_batch = self._prepare_sample(sample) + + try: + _loss, sample_size, logging_output = self.task.valid_step( + sample, self.model, self.criterion, **extra_kwargs + ) + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + if not raise_oom: + logger.warning( + "ran out of memory in validation step, retrying batch" + ) + for p in self.model.parameters(): + if p.grad is not None: + p.grad = None # free some memory + if self.cuda: + torch.cuda.empty_cache() + return self.valid_step(sample, raise_oom=True) + raise e + + logging_outputs = [logging_output] + if is_dummy_batch: + if torch.is_tensor(sample_size): + sample_size.zero_() + else: + sample_size *= 0.0 + + # gather logging outputs from all replicas + if self.data_parallel_world_size > 1: + logging_outputs, (sample_size,) = self._aggregate_logging_outputs( + logging_outputs, + sample_size, + ignore=is_dummy_batch, + ) + + # log validation stats + if self.tpu: + logging_outputs = self._xla_markstep_and_send_to_cpu(logging_outputs) + logging_output = self._reduce_and_log_stats(logging_outputs, sample_size) + + return logging_output + + def zero_grad(self): + self.optimizer.zero_grad() + + def lr_step_begin_epoch(self, epoch): + """Adjust the learning rate at the beginning of the epoch.""" + self.lr_scheduler.step_begin_epoch(epoch) + # prefer updating the LR based on the number of steps + return self.lr_step_update() + + def lr_step(self, epoch, val_loss=None): + """Adjust the learning rate at the end of the epoch.""" + self.lr_scheduler.step(epoch, val_loss) + # prefer updating the LR based on the number of steps + return self.lr_step_update() + + def lr_step_update(self): + """Update the learning rate after each update.""" + new_lr = self.lr_scheduler.step_update(self.get_num_updates()) + if isinstance(new_lr, dict): + for k, v in new_lr.items(): + metrics.log_scalar(f"lr_{k}", v, weight=0, priority=300) + new_lr = new_lr.get("default", next(iter(new_lr.values()))) + else: + metrics.log_scalar("lr", new_lr, weight=0, priority=300) + return new_lr + + def get_lr(self): + """Get the current learning rate.""" + return self.optimizer.get_lr() + + def get_model(self): + """Get the (non-wrapped) model instance.""" + return self._model + + def get_criterion(self): + """Get the (non-wrapped) criterion instance.""" + return self._criterion + + def get_meter(self, name): + """[deprecated] Get a specific meter by name.""" + from fairseq import meters + + if "get_meter" not in self._warn_once: + self._warn_once.add("get_meter") + utils.deprecation_warning( + "Trainer.get_meter is deprecated. Please use fairseq.metrics instead." + ) + + train_meters = metrics.get_meters("train") + if train_meters is None: + train_meters = {} + + if name == "train_loss" and "loss" in train_meters: + return train_meters["loss"] + elif name == "train_nll_loss": + # support for legacy train.py, which assumed this meter is + # always initialized + m = train_meters.get("nll_loss", None) + return m or meters.AverageMeter() + elif name == "wall": + # support for legacy train.py, which assumed this meter is + # always initialized + m = metrics.get_meter("default", "wall") + return m or meters.TimeMeter() + elif name == "wps": + m = metrics.get_meter("train", "wps") + return m or meters.TimeMeter() + elif name in {"valid_loss", "valid_nll_loss"}: + # support for legacy train.py, which assumed these meters + # are always initialized + k = name[len("valid_") :] + m = metrics.get_meter("valid", k) + return m or meters.AverageMeter() + elif name == "oom": + return meters.AverageMeter() + elif name in train_meters: + return train_meters[name] + return None + + def get_num_updates(self): + """Get the number of parameters updates.""" + return self._num_updates + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + self._num_updates = num_updates + self.lr_step_update() + if self.quantizer: + self.quantizer.step_update(self._num_updates) + metrics.log_scalar("num_updates", self._num_updates, weight=0, priority=200) + + def clip_grad_norm(self, clip_norm): + def agg_norm_fn(total_norm): + total_norm = total_norm.cuda().float() ** 2 + total_norm = distributed_utils.all_reduce( + total_norm, group=self.data_parallel_process_group + ) + return total_norm ** 0.5 + + should_agg_norm = ( + self.is_fsdp + and ( + self.data_parallel_process_group is not None + or torch.distributed.is_initialized() + ) + ) + return self.optimizer.clip_grad_norm( + clip_norm, aggregate_norm_fn=agg_norm_fn if should_agg_norm else None + ) + + def cumulative_training_time(self): + if self._cumulative_training_time is None: + # single GPU + return self._local_cumulative_training_time() + else: + return self._cumulative_training_time + + def _local_cumulative_training_time(self): + """Aggregate training time in seconds.""" + return time.time() - self._start_time + self._previous_training_time + + def _fp_convert_sample(self, sample): + def apply_half(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.half) + return t + + def apply_bfloat16(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.bfloat16) + return t + + if self.cfg.common.fp16: + sample = utils.apply_to_sample(apply_half, sample) + + if self.cfg.common.bf16: + sample = utils.apply_to_sample(apply_bfloat16, sample) + + return sample + + def _prepare_sample(self, sample, is_dummy=False): + if sample == "DUMMY": + raise Exception( + "Trying to use an uninitialized 'dummy' batch. This usually indicates " + "that the total number of batches is smaller than the number of " + "participating GPUs. Try reducing the batch size or using fewer GPUs." + ) + + if sample is None or len(sample) == 0: + assert ( + self._dummy_batch is not None and len(self._dummy_batch) > 0 + ), "Invalid dummy batch: {}".format(self._dummy_batch) + sample, _ = self._prepare_sample(self._dummy_batch, is_dummy=True) + return sample, True + + # Given that PCIe/NVLink bandwidth is significantly smaller than DRAM bandwidth + # it makes sense to do the format conversion on the CPU and then transfer + # a smaller buffer to the device. This also saves GPU memory capacity. + + if self.cfg.common.on_cpu_convert_precision: + sample = self._fp_convert_sample(sample) + + if self.cuda: + if self.pipeline_model_parallel: + if 'target' in sample: + sample['target'] = utils.move_to_cuda(sample['target'], device=self.last_device) + else: + sample = utils.move_to_cuda(sample) + elif self.tpu and is_dummy: + # the dummy batch may not be on the appropriate device + sample = utils.move_to_cuda(sample, device=self.device) + + if not self.cfg.common.on_cpu_convert_precision: + sample = self._fp_convert_sample(sample) + + if self._dummy_batch == "DUMMY": + self._dummy_batch = sample + + return sample, False + + def _set_seed(self): + # Set seed based on args.seed and the update number so that we get + # reproducible results when resuming from checkpoints + seed = self.cfg.common.seed + self.get_num_updates() + utils.set_torch_seed(seed) + + def _sync_stats(self): + # Return True if it's using multiple GPUs and DDP or multiple GPUs with + # BMUF and it's a bmuf sync with warmup iterations completed before. + if self.data_parallel_world_size == 1: + return False + elif self.cfg.optimization.use_bmuf: + return ( + self.get_num_updates() + 1 + ) % self.cfg.bmuf.global_sync_iter == 0 and ( + self.get_num_updates() + 1 + ) > self.cfg.bmuf.warmup_iterations + else: + return True + + def _log_oom(self, exc): + msg = "OOM: Ran out of memory with exception: {}".format(exc) + logger.warning(msg) + if torch.cuda.is_available() and hasattr(torch.cuda, "memory_summary"): + for device_idx in range(torch.cuda.device_count()): + logger.warning(torch.cuda.memory_summary(device=device_idx)) + sys.stderr.flush() + + def _aggregate_logging_outputs( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + if self.task.__class__.logging_outputs_can_be_summed(self.get_criterion()): + return self._fast_stat_sync_sum( + logging_outputs, *extra_stats_to_sum, ignore=ignore + ) + else: + return self._all_gather_list_sync( + logging_outputs, *extra_stats_to_sum, ignore=ignore + ) + + def _all_gather_list_sync( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + """ + Sync logging outputs across workers. all_gather_list_sync is + suitable when logging outputs are complex types. + """ + if self.tpu: + raise NotImplementedError + if ignore: + logging_outputs = [] + results = list( + zip( + *distributed_utils.all_gather_list( + [logging_outputs] + list(extra_stats_to_sum), + max_size=getattr(self.cfg.common, "all_gather_list_size", 16384), + group=self.data_parallel_process_group, + ) + ) + ) + logging_outputs, extra_stats_to_sum = results[0], results[1:] + logging_outputs = list(chain.from_iterable(logging_outputs)) + extra_stats_to_sum = [sum(s) for s in extra_stats_to_sum] + return logging_outputs, extra_stats_to_sum + + def _fast_stat_sync_sum( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + """ + Sync logging outputs across workers. fast_stat_sync_sum is + faster than all_gather_list_sync, but is only suitable when + logging outputs are scalars and can be summed. Note that + *logging_outputs* cannot contain any nested dicts/lists. + """ + data = {} + for i, stat in enumerate(extra_stats_to_sum): + data["extra_stats_" + str(i)] = stat + if len(logging_outputs) > 0: + log_keys = list(logging_outputs[0].keys()) + for k in log_keys: + if not ignore: + v = sum(log[k] for log in logging_outputs if k in log) + else: + v = logging_outputs[0][k] + v = torch.zeros_like(v) if torch.is_tensor(v) else 0 + data["logging_outputs_" + k] = v + else: + log_keys = None + + data = distributed_utils.all_reduce_dict( + data, device=self.device, group=self.data_parallel_process_group + ) + + extra_stats_to_sum = [ + data["extra_stats_" + str(i)] for i in range(len(extra_stats_to_sum)) + ] + if log_keys is not None: + logging_outputs = [{k: data["logging_outputs_" + k] for k in log_keys}] + else: + logging_outputs = [] + return logging_outputs, extra_stats_to_sum + + def _check_grad_norms(self, grad_norm): + """Check that grad norms are consistent across workers.""" + if self._grad_norm_buf is not None: + self._grad_norm_buf.zero_() + self._grad_norm_buf[self.data_parallel_rank] = grad_norm + distributed_utils.all_reduce( + self._grad_norm_buf, group=self.data_parallel_process_group + ) + + def is_consistent(tensor): + max_abs_diff = torch.max(torch.abs(tensor - tensor[0])) + return ( + (torch.isfinite(tensor).all() + and (max_abs_diff / (tensor[0] + 1e-6) < 1e-6).all()) + or + (self.cfg.common.amp and not torch.isfinite(tensor).all()) + # in case of amp non-finite grads are fine + ) + + if not is_consistent(self._grad_norm_buf): + pretty_detail = "\n".join( + "rank {:3d} = {:.8f}".format(r, n) + for r, n in enumerate(self._grad_norm_buf.tolist()) + ) + error_detail = "grad_norm across the workers:\n{}\n".format( + pretty_detail + ) + # use FloatingPointError to trigger NanDetector + raise FloatingPointError( + "Fatal error: gradients are inconsistent between workers. " + "Try --ddp-backend=legacy_ddp. " + "Or are you mixing up different generation of GPUs in training?" + + "\n" + + "-" * 80 + + "\n{}\n".format(error_detail) + + "-" * 80 + ) + + def _reduce_and_log_stats(self, logging_outputs, sample_size, grad_norm=None): + if grad_norm is not None and ( + not torch.is_tensor(grad_norm) or torch.isfinite(grad_norm) + ): + metrics.log_speed("ups", 1.0, priority=100, round=2) + metrics.log_scalar("gnorm", grad_norm, priority=400, round=3) + if self.cfg.optimization.clip_norm > 0: + metrics.log_scalar( + "clip", + torch.where( + grad_norm > self.cfg.optimization.clip_norm, + grad_norm.new_tensor(100), + grad_norm.new_tensor(0), + ), + priority=500, + round=1, + ) + + with metrics.aggregate() as agg: + if logging_outputs is not None: + self.task.reduce_metrics(logging_outputs, self.get_criterion()) + del logging_outputs + + # extra warning for criterions that don't properly log a loss value + if "loss" not in agg: + if "loss" not in self._warn_once: + self._warn_once.add("loss") + logger.warning( + "Criterion.reduce_metrics did not log a 'loss' value, " + "which may break some functionality" + ) + metrics.log_scalar("loss", -1) + + # support legacy interface + if self.tpu: + logging_output = {} + else: + logging_output = agg.get_smoothed_values() + logging_output["sample_size"] = sample_size + for key_to_delete in ["ppl", "wps", "wpb", "bsz"]: + if key_to_delete in logging_output: + del logging_output[key_to_delete] + return logging_output + + def _check_xla_compilation(self): + import torch_xla.debug.metrics as met + + compile_stats = met.metric_data("CompileTime") + if compile_stats is None: + return + num_xla_compiles = compile_stats[0] + if num_xla_compiles > self._num_xla_compiles: + logger.warning( + "XLA compilation detected on device #{}; too many of these can lead " + "to slow training, but we expect a few in the beginning".format( + self.cfg.distributed_training.distributed_rank + ) + ) + self._num_xla_compiles = num_xla_compiles + + def _xla_markstep_and_send_to_cpu(self, data=None): + import torch_xla.core.xla_model as xm + + xm.mark_step() + if data is not None: + from fairseq.utils import xla_device_to_cpu + + return xla_device_to_cpu(data) + + +def _catalog_shared_params(module, memo=None, prefix=""): + if memo is None: + first_call = True + memo = {} + else: + first_call = False + for name, param in module._parameters.items(): + param_prefix = prefix + ("." if prefix else "") + name + if param not in memo: + memo[param] = [] + memo[param].append(param_prefix) + for name, m in module._modules.items(): + if m is None: + continue + submodule_prefix = prefix + ("." if prefix else "") + name + _catalog_shared_params(m, memo, submodule_prefix) + if first_call: + return [x for x in memo.values() if len(x) > 1] + + +def _get_module_by_path(module, path): + path = path.split(".") + for name in path: + module = getattr(module, name) + return module + + +def _set_module_by_path(module, path, value): + path = path.split(".") + for name in path[:-1]: + module = getattr(module, name) + setattr(module, path[-1], value) diff --git a/fairseq/fairseq/utils.py b/fairseq/fairseq/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f61a8d38d456edf7605c31a87d09413e778658f3 --- /dev/null +++ b/fairseq/fairseq/utils.py @@ -0,0 +1,829 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import contextlib +import copy +import importlib +import logging +import os +import sys +import warnings +from itertools import accumulate +from typing import Callable, Dict, List, Optional, TYPE_CHECKING + +import torch +import torch.nn.functional as F +from torch import Tensor +import collections + +if TYPE_CHECKING: + from fairseq.modules.multihead_attention import MultiheadAttention + +try: + from amp_C import multi_tensor_l2norm + + multi_tensor_l2norm_available = True +except ImportError: + multi_tensor_l2norm_available = False + +try: + import torch_xla.core.xla_model as xm +except ImportError: + xm = None + + +logger = logging.getLogger(__name__) + + +MANIFOLD_PATH_SEP = "|" + + +class FileContentsAction(argparse.Action): + def __init__(self, option_strings, dest, nargs=None, **kwargs): + if nargs is not None: + raise ValueError("nargs not allowed") + super(FileContentsAction, self).__init__(option_strings, dest, **kwargs) + + def __call__(self, parser, namespace, values, option_string=None): + from fairseq.file_io import PathManager + + if PathManager.isfile(values): + with PathManager.open(values) as f: + argument = f.read().strip() + else: + argument = values + setattr(namespace, self.dest, argument) + + +def split_paths(paths: str, separator=os.pathsep) -> List[str]: + return ( + paths.split(separator) if "://" not in paths else paths.split(MANIFOLD_PATH_SEP) + ) + + +def load_ensemble_for_inference(filenames, task, model_arg_overrides=None): + from fairseq import checkpoint_utils + + deprecation_warning( + "utils.load_ensemble_for_inference is deprecated. " + "Please use checkpoint_utils.load_model_ensemble instead." + ) + return checkpoint_utils.load_model_ensemble( + filenames, arg_overrides=model_arg_overrides, task=task + ) + + +def apply_to_sample(f, sample): + if hasattr(sample, "__len__") and len(sample) == 0: + return {} + + def _apply(x): + if torch.is_tensor(x): + return f(x) + elif isinstance(x, collections.OrderedDict): + # OrderedDict has attributes that needs to be preserved + od = collections.OrderedDict((key, _apply(value)) for key, value in x.items()) + od.__dict__ = x.__dict__ + return od + elif isinstance(x, dict): + return {key: _apply(value) for key, value in x.items()} + elif isinstance(x, list): + return [_apply(x) for x in x] + elif isinstance(x, tuple): + return tuple(_apply(x) for x in x) + elif isinstance(x, set): + return {_apply(x) for x in x} + else: + return x + + return _apply(sample) + + +def move_to_cuda(sample, device=None): + device = device or torch.cuda.current_device() + + def _move_to_cuda(tensor): + # non_blocking is ignored if tensor is not pinned, so we can always set + # to True (see github.com/PyTorchLightning/pytorch-lightning/issues/620) + return tensor.to(device=device, non_blocking=True) + + return apply_to_sample(_move_to_cuda, sample) + + +def move_to_cpu(sample): + def _move_to_cpu(tensor): + # PyTorch has poor support for half tensors (float16) on CPU. + # Move any such tensors to float32. + if tensor.dtype in {torch.bfloat16, torch.float16}: + tensor = tensor.to(dtype=torch.float32) + return tensor.cpu() + + return apply_to_sample(_move_to_cpu, sample) + + +def move_to_tpu(sample): + + import torch_xla.core.xla_model as xm + + device = xm.xla_device() + + def _move_to_tpu(tensor): + return tensor.to(device) + + return apply_to_sample(_move_to_tpu, sample) + + +def get_incremental_state( + module: "MultiheadAttention", + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + key: str, +) -> Optional[Dict[str, Optional[Tensor]]]: + """Helper for getting incremental state for an nn.Module.""" + return module.get_incremental_state(incremental_state, key) + + +def set_incremental_state( + module: "MultiheadAttention", + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]], + key: str, + value: Dict[str, Optional[Tensor]], +) -> Optional[Dict[str, Dict[str, Optional[Tensor]]]]: + """Helper for setting incremental state for an nn.Module.""" + if incremental_state is not None: + result = module.set_incremental_state(incremental_state, key, value) + if result is not None: + incremental_state = result + return incremental_state + + +def load_align_dict(replace_unk): + if replace_unk is None: + align_dict = None + elif isinstance(replace_unk, str) and len(replace_unk) > 0: + # Load alignment dictionary for unknown word replacement if it was passed as an argument. + align_dict = {} + with open(replace_unk, "r") as f: + for line in f: + cols = line.split() + align_dict[cols[0]] = cols[1] + else: + # No alignment dictionary provided but we still want to perform unknown word replacement by copying the + # original source word. + align_dict = {} + return align_dict + + +def print_embed_overlap(embed_dict, vocab_dict): + embed_keys = set(embed_dict.keys()) + vocab_keys = set(vocab_dict.symbols) + overlap = len(embed_keys & vocab_keys) + logger.info("found {}/{} types in embedding file".format(overlap, len(vocab_dict))) + + +def parse_embedding(embed_path): + """Parse embedding text file into a dictionary of word and embedding tensors. + + The first line can have vocabulary size and dimension. The following lines + should contain word and embedding separated by spaces. + + Example: + 2 5 + the -0.0230 -0.0264 0.0287 0.0171 0.1403 + at -0.0395 -0.1286 0.0275 0.0254 -0.0932 + """ + embed_dict = {} + with open(embed_path) as f_embed: + next(f_embed) # skip header + for line in f_embed: + pieces = line.rstrip().split(" ") + embed_dict[pieces[0]] = torch.Tensor( + [float(weight) for weight in pieces[1:]] + ) + return embed_dict + + +def load_embedding(embed_dict, vocab, embedding): + for idx in range(len(vocab)): + token = vocab[idx] + if token in embed_dict: + embedding.weight.data[idx] = embed_dict[token] + return embedding + + +def replace_unk(hypo_str, src_str, alignment, align_dict, unk): + from fairseq import tokenizer + + # Tokens are strings here + hypo_tokens = tokenizer.tokenize_line(hypo_str) + # TODO: Very rare cases where the replacement is '<eos>' should be handled gracefully + src_tokens = tokenizer.tokenize_line(src_str) + ["<eos>"] + for i, ht in enumerate(hypo_tokens): + if ht == unk: + src_token = src_tokens[alignment[i]] + # Either take the corresponding value in the aligned dictionary or just copy the original value. + hypo_tokens[i] = align_dict.get(src_token, src_token) + return " ".join(hypo_tokens) + + +def post_process_prediction( + hypo_tokens, + src_str, + alignment, + align_dict, + tgt_dict, + remove_bpe=None, + extra_symbols_to_ignore=None, +): + hypo_str = tgt_dict.string( + hypo_tokens, remove_bpe, extra_symbols_to_ignore=extra_symbols_to_ignore + ) + if align_dict is not None: + hypo_str = replace_unk( + hypo_str, src_str, alignment, align_dict, tgt_dict.unk_string() + ) + if align_dict is not None or remove_bpe is not None: + # Convert back to tokens for evaluating with unk replacement or without BPE + # Note that the dictionary can be modified inside the method. + hypo_tokens = tgt_dict.encode_line(hypo_str, add_if_not_exist=True) + return hypo_tokens, hypo_str, alignment + + +def make_positions(tensor, padding_idx: int, onnx_trace: bool = False): + """Replace non-padding symbols with their position numbers. + + Position numbers begin at padding_idx+1. Padding symbols are ignored. + """ + # The series of casts and type-conversions here are carefully + # balanced to both work with ONNX export and XLA. In particular XLA + # prefers ints, cumsum defaults to output longs, and ONNX doesn't know + # how to handle the dtype kwarg in cumsum. + mask = tensor.ne(padding_idx).int() + return (torch.cumsum(mask, dim=1).type_as(mask) * mask).long() + padding_idx + + +def strip_pad(tensor, pad): + return tensor[tensor.ne(pad)] + + +def buffered_arange(max): + if not hasattr(buffered_arange, "buf"): + buffered_arange.buf = torch.LongTensor() + if max > buffered_arange.buf.numel(): + buffered_arange.buf.resize_(max) + torch.arange(max, out=buffered_arange.buf) + return buffered_arange.buf[:max] + + +def convert_padding_direction( + src_tokens, padding_idx, right_to_left: bool = False, left_to_right: bool = False +): + assert right_to_left ^ left_to_right + pad_mask = src_tokens.eq(padding_idx) + if not pad_mask.any(): + # no padding, return early + return src_tokens + if left_to_right and not pad_mask[:, 0].any(): + # already right padded + return src_tokens + if right_to_left and not pad_mask[:, -1].any(): + # already left padded + return src_tokens + max_len = src_tokens.size(1) + buffered = torch.empty(0).long() + if max_len > 0: + torch.arange(max_len, out=buffered) + range = buffered.type_as(src_tokens).expand_as(src_tokens) + num_pads = pad_mask.long().sum(dim=1, keepdim=True) + if right_to_left: + index = torch.remainder(range - num_pads, max_len) + else: + index = torch.remainder(range + num_pads, max_len) + return src_tokens.gather(1, index) + + +def item(tensor): + # tpu-comment: making this a no-op for xla devices. + if torch.is_tensor(tensor) and tensor.device.type == "xla": + return tensor.detach() + if hasattr(tensor, "item"): + return tensor.item() + if hasattr(tensor, "__getitem__"): + return tensor[0] + return tensor + + +def multi_tensor_total_norm(grads, chunk_size=2048 * 32) -> torch.Tensor: + per_device_grads = {} + norms = [] + for grad in grads: + device = grad.device + cur_device_grads = per_device_grads.get(device) + if cur_device_grads is None: + cur_device_grads = [] + per_device_grads[device] = cur_device_grads + cur_device_grads.append(grad) + for device in per_device_grads.keys(): + cur_device_grads = per_device_grads[device] + if device.type == "cuda": + # TODO(msb) return has_inf + has_inf = torch.zeros((1, 1), dtype=torch.int, device=device) + with torch.cuda.device(device): + norm = multi_tensor_l2norm( + chunk_size, has_inf, [cur_device_grads], False + ) + norms.append(norm[0].to(torch.cuda.current_device())) + else: + norms += [torch.norm(g, p=2, dtype=torch.float32) for g in cur_device_grads] + total_norm = torch.norm(torch.stack(norms)) + return total_norm + + +@torch.no_grad() +def clip_grad_norm_(params, max_norm, aggregate_norm_fn=None) -> torch.Tensor: + def grad_exists(p): + return p is not None and getattr(p, "grad", None) is not None + + if isinstance(params, torch.Tensor): + params = [params] + params = list(params) + grads = [ + p.grad.detach() for p in params if grad_exists(p) and not hasattr(p, "expert") + ] + expert_grads = [ + p.grad.detach() for p in params if grad_exists(p) and hasattr(p, "expert") + ] + + if len(grads) == 0: + if len(params) > 0: + return params[0].new_tensor(0.0) + else: + return torch.tensor(0.0) + + if len(grads) == 1: + total_norm = torch.norm(grads[0], p=2, dtype=torch.float32) + else: + if multi_tensor_l2norm_available: + total_norm = multi_tensor_total_norm(grads) + else: + if torch.cuda.is_available(): + warnings.warn( + "amp_C fused kernels unavailable, disabling multi_tensor_l2norm; " + "you may get better performance by installing NVIDIA's apex library" + ) + device = torch.cuda.current_device() + elif grads[0].device.type == "xla": + device = grads[0].device + else: + device = torch.device("cpu") + total_norm = torch.norm( + torch.stack( + [torch.norm(g, p=2, dtype=torch.float32).to(device) for g in grads] + ) + ) + + if aggregate_norm_fn is not None: + total_norm = aggregate_norm_fn(total_norm) + + if max_norm > 0: + max_norm = float(max_norm) + clip_coef = (max_norm / (total_norm + 1e-6)).clamp_(max=1) + for g in grads + expert_grads: + g.mul_(clip_coef) + return total_norm + + +def fill_with_neg_inf(t): + """FP16-compatible function that fills a tensor with -inf.""" + return t.float().fill_(float("-inf")).type_as(t) + + +def _match_types(arg1, arg2): + """Convert the numerical argument to the same type as the other argument""" + + def upgrade(arg_number, arg_structure): + if isinstance(arg_structure, tuple): + return tuple([arg_number] * len(arg_structure)) + elif isinstance(arg_structure, dict): + arg = copy.deepcopy(arg_structure) + for k in arg: + arg[k] = upgrade(arg_number, arg_structure[k]) + return arg + else: + return arg_number + + if isinstance(arg1, float) or isinstance(arg1, int): + return upgrade(arg1, arg2), arg2 + elif isinstance(arg2, float) or isinstance(arg2, int): + return arg1, upgrade(arg2, arg1) + + return arg1, arg2 + + +def resolve_max_positions(*args): + """Resolve max position constraints from multiple sources.""" + + def map_value_update(d1, d2): + updated_value = copy.deepcopy(d1) + for key in d2: + if key not in updated_value: + updated_value[key] = d2[key] + else: + updated_value[key] = min(d1[key], d2[key]) + return updated_value + + def nullsafe_min(l): + minim = None + for item in l: + if minim is None: + minim = item + elif item is not None and item < minim: + minim = item + return minim + + max_positions = None + for arg in args: + if max_positions is None: + max_positions = arg + elif arg is not None: + max_positions, arg = _match_types(max_positions, arg) + if isinstance(arg, float) or isinstance(arg, int): + max_positions = min(max_positions, arg) + elif isinstance(arg, dict): + max_positions = map_value_update(max_positions, arg) + else: + max_positions = tuple(map(nullsafe_min, zip(max_positions, arg))) + + return max_positions + + +def import_user_module(args): + module_path = getattr(args, "user_dir", None) + if module_path is not None: + module_path = os.path.abspath(args.user_dir) + if not os.path.exists(module_path) and not os.path.isfile( + os.path.dirname(module_path) + ): + fairseq_rel_path = os.path.join(os.path.dirname(__file__), args.user_dir) + if os.path.exists(fairseq_rel_path): + module_path = fairseq_rel_path + else: + fairseq_rel_path = os.path.join( + os.path.dirname(__file__), "..", args.user_dir + ) + if os.path.exists(fairseq_rel_path): + module_path = fairseq_rel_path + else: + raise FileNotFoundError(module_path) + + # ensure that user modules are only imported once + import_user_module.memo = getattr(import_user_module, "memo", set()) + if module_path not in import_user_module.memo: + import_user_module.memo.add(module_path) + + module_parent, module_name = os.path.split(module_path) + if module_name not in sys.modules: + sys.path.insert(0, module_parent) + importlib.import_module(module_name) + + tasks_path = os.path.join(module_path, "tasks") + if os.path.exists(tasks_path): + from fairseq.tasks import import_tasks + + import_tasks(tasks_path, f"{module_name}.tasks") + + models_path = os.path.join(module_path, "models") + if os.path.exists(models_path): + from fairseq.models import import_models + + import_models(models_path, f"{module_name}.models") + else: + raise ImportError( + "Failed to import --user-dir={} because the corresponding module name " + "({}) is not globally unique. Please rename the directory to " + "something unique and try again.".format(module_path, module_name) + ) + + +def softmax(x, dim: int, onnx_trace: bool = False): + if onnx_trace: + return F.softmax(x.float(), dim=dim) + else: + return F.softmax(x, dim=dim, dtype=torch.float32) + + +def log_softmax(x, dim: int, onnx_trace: bool = False): + if onnx_trace: + return F.log_softmax(x.float(), dim=dim) + else: + return F.log_softmax(x, dim=dim, dtype=torch.float32) + + +def get_perplexity(loss, round=2, base=2): + from fairseq.logging.meters import safe_round + + if loss is None: + return 0.0 + try: + return safe_round(base ** loss, round) + except OverflowError: + return float("inf") + + +def deprecation_warning(message, stacklevel=3): + # don't use DeprecationWarning, since it's ignored by default + warnings.warn(message, stacklevel=stacklevel) + + +def get_activation_fn(activation: str) -> Callable: + """Returns the activation function corresponding to `activation`""" + from fairseq.modules import gelu, gelu_accurate + + if activation == "relu": + return F.relu + elif activation == "gelu": + return gelu + elif activation == "gelu_fast": + deprecation_warning( + "--activation-fn=gelu_fast has been renamed to gelu_accurate" + ) + return gelu_accurate + elif activation == "gelu_accurate": + return gelu_accurate + elif activation == "tanh": + return torch.tanh + elif activation == "linear": + return lambda x: x + else: + raise RuntimeError("--activation-fn {} not supported".format(activation)) + + +def get_available_activation_fns() -> List: + return [ + "relu", + "gelu", + "gelu_fast", # deprecated + "gelu_accurate", + "tanh", + "linear", + ] + + +@contextlib.contextmanager +def model_eval(model): + is_training = model.training + model.eval() + yield + model.train(is_training) + + +def has_parameters(module): + try: + next(module.parameters()) + return True + except StopIteration: + return False + + +def get_rng_state(): + state = {"torch_rng_state": torch.get_rng_state()} + if xm is not None: + state["xla_rng_state"] = xm.get_rng_state() + if torch.cuda.is_available(): + state["cuda_rng_state"] = torch.cuda.get_rng_state() + return state + + +def set_rng_state(state): + torch.set_rng_state(state["torch_rng_state"]) + if xm is not None: + xm.set_rng_state(state["xla_rng_state"]) + if torch.cuda.is_available(): + torch.cuda.set_rng_state(state["cuda_rng_state"]) + + +class set_torch_seed(object): + def __init__(self, seed): + assert isinstance(seed, int) + self.rng_state = get_rng_state() + + torch.manual_seed(seed) + if xm is not None: + xm.set_rng_state(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed(seed) + + def __enter__(self): + return self + + def __exit__(self, *exc): + set_rng_state(self.rng_state) + + +def parse_alignment(line): + """ + Parses a single line from the alingment file. + + Args: + line (str): String containing the alignment of the format: + <src_idx_1>-<tgt_idx_1> <src_idx_2>-<tgt_idx_2> .. + <src_idx_m>-<tgt_idx_m>. All indices are 0 indexed. + + Returns: + torch.IntTensor: packed alignments of shape (2 * m). + """ + alignments = line.strip().split() + parsed_alignment = torch.IntTensor(2 * len(alignments)) + for idx, alignment in enumerate(alignments): + src_idx, tgt_idx = alignment.split("-") + parsed_alignment[2 * idx] = int(src_idx) + parsed_alignment[2 * idx + 1] = int(tgt_idx) + return parsed_alignment + + +def get_token_to_word_mapping(tokens, exclude_list): + n = len(tokens) + word_start = [int(token not in exclude_list) for token in tokens] + word_idx = list(accumulate(word_start)) + token_to_word = {i: word_idx[i] for i in range(n)} + return token_to_word + + +def extract_hard_alignment(attn, src_sent, tgt_sent, pad, eos): + tgt_valid = ( + ((tgt_sent != pad) & (tgt_sent != eos)).nonzero(as_tuple=False).squeeze(dim=-1) + ) + src_invalid = ( + ((src_sent == pad) | (src_sent == eos)).nonzero(as_tuple=False).squeeze(dim=-1) + ) + src_token_to_word = get_token_to_word_mapping(src_sent, [eos, pad]) + tgt_token_to_word = get_token_to_word_mapping(tgt_sent, [eos, pad]) + alignment = [] + if len(tgt_valid) != 0 and len(src_invalid) < len(src_sent): + attn_valid = attn[tgt_valid] + attn_valid[:, src_invalid] = float("-inf") + _, src_indices = attn_valid.max(dim=1) + for tgt_idx, src_idx in zip(tgt_valid, src_indices): + alignment.append( + ( + src_token_to_word[src_idx.item()] - 1, + tgt_token_to_word[tgt_idx.item()] - 1, + ) + ) + return alignment + + +def extract_soft_alignment(attn, src_sent, tgt_sent, pad, eos): + tgt_valid = ((tgt_sent != pad)).nonzero(as_tuple=False) + src_valid = ((src_sent != pad)).nonzero(as_tuple=False).squeeze(dim=-1) + alignment = [] + if len(tgt_valid) != 0 and len(src_valid) != 0: + attn_valid = attn[tgt_valid, src_valid] + alignment = [ + ["{:.6f}".format(p) for p in src_probs.tolist()] for src_probs in attn_valid + ] + return alignment + + +def new_arange(x, *size): + """ + Return a Tensor of `size` filled with a range function on the device of x. + If size is empty, using the size of the variable x. + """ + if len(size) == 0: + size = x.size() + return torch.arange(size[-1], device=x.device).expand(*size).contiguous() + + +def get_tpu_device(): + return xm.xla_device() + + +def tpu_data_loader(itr): + import torch_xla.core.xla_model as xm + import torch_xla.distributed.parallel_loader as pl + from fairseq.data import iterators + + xm.rendezvous("tpu_data_loader") # wait for all workers + xm.mark_step() + device = xm.xla_device() + return iterators.CountingIterator( + pl.ParallelLoader(itr, [device]).per_device_loader(device), + start=getattr(itr, "n", 0), + total=len(itr), + ) + + +def is_xla_tensor(tensor): + return torch.is_tensor(tensor) and tensor.device.type == "xla" + + +def index_put(tensor, indices, value): + if is_xla_tensor(tensor): + for _ in range(indices.dim(), tensor.dim()): + indices = indices.unsqueeze(-1) + if indices.size(-1) < tensor.size(-1): + indices = indices.expand_as(tensor) + tensor = torch.mul(tensor, ~indices) + torch.mul(value, indices) + else: + tensor[indices] = value + return tensor + + +def xla_device_to_cpu(dat): + import torch_xla.core.xla_model as xm + + return xm._maybe_convert_to_cpu(dat) + + +class CudaEnvironment(object): + def __init__(self): + cur_device = torch.cuda.current_device() + prop = torch.cuda.get_device_properties("cuda:{}".format(cur_device)) + self.name = prop.name + self.major = prop.major + self.minor = prop.minor + self.total_memory_in_GB = prop.total_memory / 1024 / 1024 / 1024 + + @staticmethod + def pretty_print_cuda_env_list(cuda_env_list): + """ + Given a list of CudaEnviorments, pretty print them + """ + num_workers = len(cuda_env_list) + center = "CUDA enviroments for all {} workers".format(num_workers) + banner_len = 40 - len(center) // 2 + first_line = "*" * banner_len + center + "*" * banner_len + logger.info(first_line) + for r, env in enumerate(cuda_env_list): + logger.info( + "rank {:3d}: ".format(r) + + "capabilities = {:2d}.{:<2d} ; ".format(env.major, env.minor) + + "total memory = {:.3f} GB ; ".format(env.total_memory_in_GB) + + "name = {:40s}".format(env.name) + ) + logger.info(first_line) + + +def csv_str_list(x): + return x.split(",") + + +def eval_str_list(x, type=float): + if x is None: + return None + if isinstance(x, str): + x = eval(x) + try: + return list(map(type, x)) + except TypeError: + return [type(x)] + + +def eval_str_dict(x, type=dict): + if x is None: + return None + if isinstance(x, str): + x = eval(x) + return x + + +def eval_bool(x, default=False): + if x is None: + return default + try: + return bool(eval(x)) + except TypeError: + return default + + +def reset_logging(): + root = logging.getLogger() + for handler in root.handlers: + root.removeHandler(handler) + root.setLevel(os.environ.get("LOGLEVEL", "INFO").upper()) + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter( + logging.Formatter( + fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + ) + root.addHandler(handler) + + +def safe_getattr(obj, k, default=None): + """Returns obj[k] if it exists and is not None, otherwise returns default.""" + from omegaconf import OmegaConf + + if OmegaConf.is_config(obj): + return obj[k] if k in obj and obj[k] is not None else default + + return getattr(obj, k, default) + + +def safe_hasattr(obj, k): + """Returns True if the given key exists and is not None.""" + return getattr(obj, k, None) is not None diff --git a/fairseq/fairseq/version.txt b/fairseq/fairseq/version.txt new file mode 100644 index 0000000000000000000000000000000000000000..41432f00d9ce57fadd55cc7dd27b391ddf5ca0b9 --- /dev/null +++ b/fairseq/fairseq/version.txt @@ -0,0 +1 @@ +1.0.0a0 diff --git a/fairseq/fairseq_cli/__init__.py b/fairseq/fairseq_cli/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/fairseq_cli/eval_lm.py b/fairseq/fairseq_cli/eval_lm.py new file mode 100644 index 0000000000000000000000000000000000000000..ab6e77029ef738291efd190b1cfe2435dd403dea --- /dev/null +++ b/fairseq/fairseq_cli/eval_lm.py @@ -0,0 +1,347 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +Evaluate the perplexity of a trained language model. +""" + +import logging +import math +import os +import sys +from argparse import Namespace +from typing import Iterable, List, Optional + +import torch +import fairseq +from fairseq import checkpoint_utils, distributed_utils, options, tasks, utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.logging import progress_bar +from fairseq.logging.meters import StopwatchMeter +from fairseq.sequence_scorer import SequenceScorer +from omegaconf import DictConfig + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.eval_lm") + + +def eval_lm( + models: List[fairseq.models.FairseqModel], + source_dictionary: fairseq.data.Dictionary, + batch_iterator: Iterable, + post_process: Optional[str] = None, + output_word_probs: bool = False, + output_word_stats: bool = False, + target_dictionary: Optional[fairseq.data.Dictionary] = None, + softmax_batch: int = 0, + remove_bos_token: bool = False, + device: Optional[torch.device] = None, +): + """ + Args: + models (List[~fairseq.models.FairseqModel]): list of models to + evaluate. Models are essentially `nn.Module` instances, but + must be compatible with fairseq's `SequenceScorer`. + source_dictionary (~fairseq.data.Dictionary): dictionary for + applying any relevant post processing or outputing word + probs/stats. + batch_iterator (Iterable): yield batches of data + post_process (Optional[str]): post-process text by removing BPE, + letter segmentation, etc. Valid options can be found in + fairseq.data.utils.post_process, although not all options + are implemented here. + output_word_probs (Optional[bool]): output words and their + predicted log probabilities + output_word_stats (Optional[bool]): output word statistics such + as word count and average probability + target_dictionary (Optional[~fairseq.data.Dictionary]): output + dictionary (defaults to *source_dictionary*) + softmax_batch (Optional[bool]): if BxT is more than this, will + batch the softmax over vocab to this amount of tokens, in + order to fit into GPU memory + remove_bos_token (Optional[bool]): if True, confirm that the + first token is the beginning-of-sentence symbol (according + to the relevant dictionary) and remove it from the output + device (Optional[torch.device]): device to use for evaluation + (defaults to device of first model parameter) + """ + if target_dictionary is None: + target_dictionary = source_dictionary + if device is None: + device = next(models[0].parameters()).device + + gen_timer = StopwatchMeter() + scorer = SequenceScorer(target_dictionary, softmax_batch) + + score_sum = 0.0 + count = 0 + + if post_process is not None: + if post_process in {"subword_nmt", "@@ "}: + bpe_cont = post_process.rstrip() + bpe_toks = { + i + for i in range(len(source_dictionary)) + if source_dictionary[i].endswith(bpe_cont) + } + else: + raise NotImplementedError( + "--post-process={post_process} is not implemented" + ) + bpe_len = len(bpe_cont) + else: + bpe_toks = None + bpe_len = 0 + + word_stats = dict() + + for sample in batch_iterator: + if "net_input" not in sample: + continue + + sample = utils.move_to_cuda(sample, device=device) + + gen_timer.start() + hypos = scorer.generate(models, sample) + gen_timer.stop(sample["ntokens"]) + + for i, hypos_i in enumerate(hypos): + hypo = hypos_i[0] + sample_id = sample["id"][i] + + tokens = hypo["tokens"] + tgt_len = tokens.numel() + pos_scores = hypo["positional_scores"].float() + + if remove_bos_token: + assert hypo["tokens"][0].item() == target_dictionary.bos() + tokens = tokens[1:] + pos_scores = pos_scores[1:] + + skipped_toks = 0 + if bpe_toks is not None: + for i in range(tgt_len - 1): + if tokens[i].item() in bpe_toks: + skipped_toks += 1 + pos_scores[i + 1] += pos_scores[i] + pos_scores[i] = 0 + + inf_scores = pos_scores.eq(float("inf")) | pos_scores.eq(float("-inf")) + if inf_scores.any(): + logger.info( + "skipping tokens with inf scores:", + target_dictionary.string(tokens[inf_scores.nonzero()]), + ) + pos_scores = pos_scores[(~inf_scores).nonzero()] + score_sum += pos_scores.sum().cpu() + count += pos_scores.numel() - skipped_toks + + if output_word_probs or output_word_stats: + w = "" + word_prob = [] + is_bpe = False + for i in range(len(tokens)): + w_ind = tokens[i].item() + w += source_dictionary[w_ind] + if bpe_toks is not None and w_ind in bpe_toks: + w = w[:-bpe_len] + is_bpe = True + else: + word_prob.append((w, pos_scores[i].item())) + + next_prob = None + ind = i + 1 + while ind < len(tokens): + if pos_scores[ind].item() != 0: + next_prob = pos_scores[ind] + break + ind += 1 + + word_stats.setdefault(w, WordStat(w, is_bpe)).add( + pos_scores[i].item(), next_prob + ) + is_bpe = False + w = "" + if output_word_probs: + logger.info( + str(int(sample_id)) + + " " + + ( + "\t".join( + "{} [{:2f}]".format(x[0], x[1]) for x in word_prob + ) + ) + ) + + avg_nll_loss = ( + -score_sum / count / math.log(2) if count > 0 else 0 + ) # convert to base 2 + logger.info( + "Evaluated {:,} tokens in {:.1f}s ({:.2f} tokens/s)".format( + gen_timer.n, gen_timer.sum, 1.0 / gen_timer.avg if gen_timer.avg > 0 else 0 + ) + ) + + if output_word_stats: + for ws in sorted(word_stats.values(), key=lambda x: x.count, reverse=True): + logger.info(ws) + + return { + "loss": avg_nll_loss, + "perplexity": 2 ** avg_nll_loss, + } + + +class WordStat(object): + def __init__(self, word, is_bpe): + self.word = word + self.is_bpe = is_bpe + self.log_prob = 0 + self.next_word_prob = 0 + self.count = 0 + self.missing_next_words = 0 + + def add(self, log_prob, next_word_prob): + """increments counters for the sum of log probs of current word and next + word (given context ending at current word). Since the next word might be at the end of the example, + or it might be not counted because it is not an ending subword unit, + also keeps track of how many of those we have seen""" + if next_word_prob is not None: + self.next_word_prob += next_word_prob + else: + self.missing_next_words += 1 + self.log_prob += log_prob + self.count += 1 + + def __str__(self): + return "{}\t{}\t{}\t{}\t{}\t{}".format( + self.word, + self.count, + self.log_prob, + self.is_bpe, + self.next_word_prob, + self.count - self.missing_next_words, + ) + + +def main(cfg: DictConfig, **unused_kwargs): + if isinstance(cfg, Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + utils.import_user_module(cfg.common) + + logger.info(cfg) + + if cfg.eval_lm.context_window > 0: + # reduce tokens per sample by the required context window size + cfg.task.tokens_per_sample -= cfg.eval_lm.context_window + + # Initialize the task using the current *cfg* + task = tasks.setup_task(cfg.task) + + # Load ensemble + logger.info("loading model(s) from {}".format(cfg.common_eval.path)) + models, model_args, task = checkpoint_utils.load_model_ensemble_and_task( + [cfg.common_eval.path], + arg_overrides=eval(cfg.common_eval.model_overrides), + suffix=cfg.checkpoint.checkpoint_suffix, + strict=(cfg.checkpoint.checkpoint_shard_count == 1), + num_shards=cfg.checkpoint.checkpoint_shard_count, + task=task, + ) + + use_fp16 = cfg.common.fp16 + use_cuda = torch.cuda.is_available() and not cfg.common.cpu + if use_cuda: + torch.cuda.set_device(cfg.distributed_training.device_id) + + # Optimize ensemble for generation and set the source and dest dicts on the model + # (required by scorer) + for model in models: + if use_fp16: + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + + assert len(models) > 0 + + logger.info( + "num. model params: {:,}".format(sum(p.numel() for p in models[0].parameters())) + ) + + # Load dataset splits + task.load_dataset(cfg.dataset.gen_subset) + dataset = task.dataset(cfg.dataset.gen_subset) + logger.info( + "{} {} {:,} examples".format( + cfg.task.data, cfg.dataset.gen_subset, len(dataset) + ) + ) + + itr = task.eval_lm_dataloader( + dataset=dataset, + max_tokens=cfg.dataset.max_tokens or 36000, + batch_size=cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + *[model.max_positions() for model in models] + ), + num_shards=max( + cfg.dataset.num_shards, + cfg.distributed_training.distributed_world_size, + ), + shard_id=max( + cfg.dataset.shard_id, + cfg.distributed_training.distributed_rank, + ), + num_workers=cfg.dataset.num_workers, + data_buffer_size=cfg.dataset.data_buffer_size, + context_window=cfg.eval_lm.context_window, + ) + + itr = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + ) + + results = eval_lm( + models=models, + source_dictionary=task.source_dictionary, + batch_iterator=itr, + post_process=cfg.common_eval.post_process, + output_word_probs=cfg.eval_lm.output_word_probs, + output_word_stats=cfg.eval_lm.output_word_stats, + target_dictionary=task.target_dictionary, + softmax_batch=cfg.eval_lm.softmax_batch, + remove_bos_token=getattr(cfg.task, "add_bos_token", False), + ) + + logger.info( + "Loss (base 2): {:.4f}, Perplexity: {:.2f}".format( + results["loss"], results["perplexity"] + ) + ) + + return results + + +def cli_main(): + parser = options.get_eval_lm_parser() + args = options.parse_args_and_arch(parser) + + distributed_utils.call_main(convert_namespace_to_omegaconf(args), main) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/generate.py b/fairseq/fairseq_cli/generate.py new file mode 100644 index 0000000000000000000000000000000000000000..7e887e88649fef784b366abe518babd25a30feee --- /dev/null +++ b/fairseq/fairseq_cli/generate.py @@ -0,0 +1,414 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Translate pre-processed data with a trained model. +""" + +import ast +import logging +import math +import os +import sys +from argparse import Namespace +from itertools import chain + +import numpy as np +import torch +from fairseq import checkpoint_utils, options, scoring, tasks, utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.logging import progress_bar +from fairseq.logging.meters import StopwatchMeter, TimeMeter +from omegaconf import DictConfig + + +def main(cfg: DictConfig): + + if isinstance(cfg, Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + assert cfg.common_eval.path is not None, "--path required for generation!" + assert ( + not cfg.generation.sampling or cfg.generation.nbest == cfg.generation.beam + ), "--sampling requires --nbest to be equal to --beam" + assert ( + cfg.generation.replace_unk is None or cfg.dataset.dataset_impl == "raw" + ), "--replace-unk requires a raw text dataset (--dataset-impl=raw)" + + if cfg.common_eval.results_path is not None: + os.makedirs(cfg.common_eval.results_path, exist_ok=True) + output_path = os.path.join( + cfg.common_eval.results_path, + "generate-{}.txt".format(cfg.dataset.gen_subset), + ) + with open(output_path, "w", buffering=1, encoding="utf-8") as h: + return _main(cfg, h) + else: + return _main(cfg, sys.stdout) + + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.eos} + + +def _main(cfg: DictConfig, output_file): + logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=output_file, + ) + logger = logging.getLogger("fairseq_cli.generate") + + utils.import_user_module(cfg.common) + + if cfg.dataset.max_tokens is None and cfg.dataset.batch_size is None: + cfg.dataset.max_tokens = 12000 + logger.info(cfg) + + # Fix seed for stochastic decoding + if cfg.common.seed is not None and not cfg.generation.no_seed_provided: + np.random.seed(cfg.common.seed) + utils.set_torch_seed(cfg.common.seed) + + use_cuda = torch.cuda.is_available() and not cfg.common.cpu + + # Load dataset splits + task = tasks.setup_task(cfg.task) + + + # Set dictionaries + try: + src_dict = getattr(task, "source_dictionary", None) + except NotImplementedError: + src_dict = None + tgt_dict = task.target_dictionary + + overrides = ast.literal_eval(cfg.common_eval.model_overrides) + + # Load ensemble + logger.info("loading model(s) from {}".format(cfg.common_eval.path)) + models, saved_cfg = checkpoint_utils.load_model_ensemble( + utils.split_paths(cfg.common_eval.path), + arg_overrides=overrides, + task=task, + suffix=cfg.checkpoint.checkpoint_suffix, + strict=(cfg.checkpoint.checkpoint_shard_count == 1), + num_shards=cfg.checkpoint.checkpoint_shard_count, + ) + + # loading the dataset should happen after the checkpoint has been loaded so we can give it the saved task config + task.load_dataset(cfg.dataset.gen_subset, task_cfg=saved_cfg.task) + + if cfg.generation.lm_path is not None: + overrides["data"] = cfg.task.data + + try: + lms, _ = checkpoint_utils.load_model_ensemble( + [cfg.generation.lm_path], arg_overrides=overrides, task=None + ) + except: + logger.warning( + f"Failed to load language model! Please make sure that the language model dict is the same " + f"as target dict and is located in the data dir ({cfg.task.data})" + ) + raise + + assert len(lms) == 1 + else: + lms = [None] + + # Optimize ensemble for generation + for model in chain(models, lms): + if model is None: + continue + if cfg.common.fp16: + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + + # Load alignment dictionary for unknown word replacement + # (None if no unknown word replacement, empty if no path to align dictionary) + align_dict = utils.load_align_dict(cfg.generation.replace_unk) + + # Load dataset (possibly sharded) + itr = task.get_batch_iterator( + dataset=task.dataset(cfg.dataset.gen_subset), + max_tokens=cfg.dataset.max_tokens, + max_sentences=cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + task.max_positions(), *[m.max_positions() for m in models] + ), + ignore_invalid_inputs=cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=cfg.dataset.required_batch_size_multiple, + seed=cfg.common.seed, + num_shards=cfg.distributed_training.distributed_world_size, + shard_id=cfg.distributed_training.distributed_rank, + num_workers=cfg.dataset.num_workers, + data_buffer_size=cfg.dataset.data_buffer_size, + ).next_epoch_itr(shuffle=False) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + ) + + # Initialize generator + gen_timer = StopwatchMeter() + + extra_gen_cls_kwargs = {"lm_model": lms[0], "lm_weight": cfg.generation.lm_weight} + generator = task.build_generator( + models, cfg.generation, extra_gen_cls_kwargs=extra_gen_cls_kwargs + ) + + # Handle tokenization and BPE + tokenizer = task.build_tokenizer(cfg.tokenizer) + bpe = task.build_bpe(cfg.bpe) + + def decode_fn(x): + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + scorer = scoring.build_scorer(cfg.scoring, tgt_dict) + + num_sentences = 0 + has_target = True + wps_meter = TimeMeter() + for sample in progress: + sample = utils.move_to_cuda(sample) if use_cuda else sample + if "net_input" not in sample: + continue + + prefix_tokens = None + if cfg.generation.prefix_size > 0: + prefix_tokens = sample["target"][:, : cfg.generation.prefix_size] + + constraints = None + if "constraints" in sample: + constraints = sample["constraints"] + + gen_timer.start() + hypos = task.inference_step( + generator, + models, + sample, + prefix_tokens=prefix_tokens, + constraints=constraints, + ) + num_generated_tokens = sum(len(h[0]["tokens"]) for h in hypos) + gen_timer.stop(num_generated_tokens) + + for i, sample_id in enumerate(sample["id"].tolist()): + has_target = sample["target"] is not None + + # Remove padding + if "src_tokens" in sample["net_input"]: + src_tokens = utils.strip_pad( + sample["net_input"]["src_tokens"][i, :], tgt_dict.pad() + ) + else: + src_tokens = None + + target_tokens = None + if has_target: + target_tokens = ( + utils.strip_pad(sample["target"][i, :], tgt_dict.pad()).int().cpu() + ) + + # Either retrieve the original sentences or regenerate them from tokens. + if align_dict is not None: + src_str = task.dataset(cfg.dataset.gen_subset).src.get_original_text( + sample_id + ) + target_str = task.dataset(cfg.dataset.gen_subset).tgt.get_original_text( + sample_id + ) + else: + if src_dict is not None: + src_str = src_dict.string(src_tokens, cfg.common_eval.post_process) + else: + src_str = "" + if has_target: + target_str = tgt_dict.string( + target_tokens, + cfg.common_eval.post_process, + escape_unk=True, + extra_symbols_to_ignore=get_symbols_to_strip_from_output( + generator + ), + ) + + src_str = decode_fn(src_str) + if has_target: + target_str = decode_fn(target_str) + + if not cfg.common_eval.quiet: + if src_dict is not None: + print("S-{}\t{}".format(sample_id, src_str), file=output_file) + if has_target: + print("T-{}\t{}".format(sample_id, target_str), file=output_file) + + # Process top predictions + for j, hypo in enumerate(hypos[i][: cfg.generation.nbest]): + hypo_tokens, hypo_str, alignment = utils.post_process_prediction( + hypo_tokens=hypo["tokens"].int().cpu(), + src_str=src_str, + alignment=hypo["alignment"], + align_dict=align_dict, + tgt_dict=tgt_dict, + remove_bpe=cfg.common_eval.post_process, + extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator), + ) + detok_hypo_str = decode_fn(hypo_str) + if not cfg.common_eval.quiet: + score = hypo["score"] / math.log(2) # convert to base 2 + # original hypothesis (after tokenization and BPE) + print( + "H-{}\t{}\t{}".format(sample_id, score, hypo_str), + file=output_file, + ) + # detokenized hypothesis + print( + "D-{}\t{}\t{}".format(sample_id, score, detok_hypo_str), + file=output_file, + ) + print( + "P-{}\t{}".format( + sample_id, + " ".join( + map( + lambda x: "{:.4f}".format(x), + # convert from base e to base 2 + hypo["positional_scores"] + .div_(math.log(2)) + .tolist(), + ) + ), + ), + file=output_file, + ) + + if cfg.generation.print_alignment == "hard": + print( + "A-{}\t{}".format( + sample_id, + " ".join( + [ + "{}-{}".format(src_idx, tgt_idx) + for src_idx, tgt_idx in alignment + ] + ), + ), + file=output_file, + ) + if cfg.generation.print_alignment == "soft": + print( + "A-{}\t{}".format( + sample_id, + " ".join( + [ + ",".join(src_probs) + for src_probs in alignment + ] + ), + ), + file=output_file, + ) + + if cfg.generation.print_step: + print( + "I-{}\t{}".format(sample_id, hypo["steps"]), + file=output_file, + ) + + if cfg.generation.retain_iter_history: + for step, h in enumerate(hypo["history"]): + _, h_str, _ = utils.post_process_prediction( + hypo_tokens=h["tokens"].int().cpu(), + src_str=src_str, + alignment=None, + align_dict=None, + tgt_dict=tgt_dict, + remove_bpe=None, + ) + print( + "E-{}_{}\t{}".format(sample_id, step, h_str), + file=output_file, + ) + + # Score only the top hypothesis + if has_target and j == 0: + if align_dict is not None or cfg.common_eval.post_process is not None: + # Convert back to tokens for evaluation with unk replacement and/or without BPE + target_tokens = tgt_dict.encode_line( + target_str, add_if_not_exist=True + ) + hypo_tokens = tgt_dict.encode_line( + detok_hypo_str, add_if_not_exist=True + ) + if hasattr(scorer, "add_string"): + scorer.add_string(target_str, detok_hypo_str) + else: + scorer.add(target_tokens, hypo_tokens) + + wps_meter.update(num_generated_tokens) + progress.log({"wps": round(wps_meter.avg)}) + num_sentences += ( + sample["nsentences"] if "nsentences" in sample else sample["id"].numel() + ) + + logger.info("NOTE: hypothesis and token scores are output in base 2") + logger.info( + "Translated {:,} sentences ({:,} tokens) in {:.1f}s ({:.2f} sentences/s, {:.2f} tokens/s)".format( + num_sentences, + gen_timer.n, + gen_timer.sum, + num_sentences / gen_timer.sum, + 1.0 / gen_timer.avg, + ) + ) + if has_target: + if cfg.bpe and not cfg.generation.sacrebleu: + if cfg.common_eval.post_process: + logger.warning( + "BLEU score is being computed by splitting detokenized string on spaces, this is probably not what you want. Use --sacrebleu for standard 13a BLEU tokenization" + ) + else: + logger.warning( + "If you are using BPE on the target side, the BLEU score is computed on BPE tokens, not on proper words. Use --sacrebleu for standard 13a BLEU tokenization" + ) + # use print to be consistent with other main outputs: S-, H-, T-, D- and so on + print( + "Generate {} with beam={}: {}".format( + cfg.dataset.gen_subset, cfg.generation.beam, scorer.result_string() + ), + file=output_file, + ) + + return scorer + + +def cli_main(): + parser = options.get_generation_parser() + # TODO: replace this workaround with refactoring of `AudioPretraining` + parser.add_argument( + '--arch', '-a', metavar='ARCH', default="wav2vec2", + help='Model architecture. For constructing tasks that rely on ' + 'model args (e.g. `AudioPretraining`)' + ) + args = options.parse_args_and_arch(parser) + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/hydra_train.py b/fairseq/fairseq_cli/hydra_train.py new file mode 100644 index 0000000000000000000000000000000000000000..6555ab415e82c1156c85d000ff030e6107c55d73 --- /dev/null +++ b/fairseq/fairseq_cli/hydra_train.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os + +from fairseq.dataclass.initialize import add_defaults, hydra_init +from fairseq_cli.train import main as pre_main +from fairseq import distributed_utils, metrics +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import omegaconf_no_object_check +from fairseq.utils import reset_logging + +import hydra +from hydra.core.hydra_config import HydraConfig +import torch +from omegaconf import OmegaConf, open_dict + + +logger = logging.getLogger("fairseq_cli.hydra_train") + + +@hydra.main(config_path=os.path.join("..", "fairseq", "config"), config_name="config") +def hydra_main(cfg: FairseqConfig) -> float: + _hydra_main(cfg) + + +def _hydra_main(cfg: FairseqConfig, **kwargs) -> float: + add_defaults(cfg) + + if cfg.common.reset_logging: + reset_logging() # Hydra hijacks logging, fix that + else: + # check if directly called or called through hydra_main + if HydraConfig.initialized(): + with open_dict(cfg): + # make hydra logging work with ddp (see # see https://github.com/facebookresearch/hydra/issues/1126) + cfg.job_logging_cfg = OmegaConf.to_container(HydraConfig.get().job_logging, resolve=True) + + with omegaconf_no_object_check(): + cfg = OmegaConf.create(OmegaConf.to_container(cfg, resolve=True, enum_to_str=True)) + OmegaConf.set_struct(cfg, True) + + try: + if cfg.common.profile: + with torch.cuda.profiler.profile(): + with torch.autograd.profiler.emit_nvtx(): + distributed_utils.call_main(cfg, pre_main, **kwargs) + else: + distributed_utils.call_main(cfg, pre_main, **kwargs) + except BaseException as e: + if not cfg.common.suppress_crashes: + raise + else: + logger.error("Crashed! " + str(e)) + + # get best val and return - useful for sweepers + try: + best_val = metrics.get_smoothed_value( + "valid", cfg.checkpoint.best_checkpoint_metric + ) + except: + best_val = None + + if best_val is None: + best_val = float("inf") + + return best_val + + +def cli_main(): + try: + from hydra._internal.utils import get_args + + cfg_name = get_args().config_name or "config" + except: + logger.warning("Failed to get config name from hydra args") + cfg_name = "config" + + hydra_init(cfg_name) + hydra_main() + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/interactive.py b/fairseq/fairseq_cli/interactive.py new file mode 100644 index 0000000000000000000000000000000000000000..cadef2821a74a3b2f051c792d835129bf775714f --- /dev/null +++ b/fairseq/fairseq_cli/interactive.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Translate raw text with a trained model. Batches data on-the-fly. +""" + +import ast +import fileinput +import logging +import math +import os +import sys +import time +from argparse import Namespace +from collections import namedtuple + +import numpy as np +import torch +from fairseq import checkpoint_utils, distributed_utils, options, tasks, utils +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.token_generation_constraints import pack_constraints, unpack_constraints +from fairseq_cli.generate import get_symbols_to_strip_from_output + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.interactive") + + +Batch = namedtuple("Batch", "ids src_tokens src_lengths constraints") +Translation = namedtuple("Translation", "src_str hypos pos_scores alignments") + + +def buffered_read(input, buffer_size): + buffer = [] + with fileinput.input(files=[input], openhook=fileinput.hook_encoded("utf-8")) as h: + for src_str in h: + buffer.append(src_str.strip()) + if len(buffer) >= buffer_size: + yield buffer + buffer = [] + + if len(buffer) > 0: + yield buffer + + +def make_batches(lines, cfg, task, max_positions, encode_fn): + def encode_fn_target(x): + return encode_fn(x) + + if cfg.generation.constraints: + # Strip (tab-delimited) contraints, if present, from input lines, + # store them in batch_constraints + batch_constraints = [list() for _ in lines] + for i, line in enumerate(lines): + if "\t" in line: + lines[i], *batch_constraints[i] = line.split("\t") + + # Convert each List[str] to List[Tensor] + for i, constraint_list in enumerate(batch_constraints): + batch_constraints[i] = [ + task.target_dictionary.encode_line( + encode_fn_target(constraint), + append_eos=False, + add_if_not_exist=False, + ) + for constraint in constraint_list + ] + + if cfg.generation.constraints: + constraints_tensor = pack_constraints(batch_constraints) + else: + constraints_tensor = None + + tokens, lengths = task.get_interactive_tokens_and_lengths(lines, encode_fn) + + itr = task.get_batch_iterator( + dataset=task.build_dataset_for_inference( + tokens, lengths, constraints=constraints_tensor + ), + max_tokens=cfg.dataset.max_tokens, + max_sentences=cfg.dataset.batch_size, + max_positions=max_positions, + ignore_invalid_inputs=cfg.dataset.skip_invalid_size_inputs_valid_test, + ).next_epoch_itr(shuffle=False) + for batch in itr: + ids = batch["id"] + src_tokens = batch["net_input"]["src_tokens"] + src_lengths = batch["net_input"]["src_lengths"] + constraints = batch.get("constraints", None) + + yield Batch( + ids=ids, + src_tokens=src_tokens, + src_lengths=src_lengths, + constraints=constraints, + ) + + +def main(cfg: FairseqConfig): + if isinstance(cfg, Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + start_time = time.time() + total_translate_time = 0 + + utils.import_user_module(cfg.common) + + if cfg.interactive.buffer_size < 1: + cfg.interactive.buffer_size = 1 + if cfg.dataset.max_tokens is None and cfg.dataset.batch_size is None: + cfg.dataset.batch_size = 1 + + assert ( + not cfg.generation.sampling or cfg.generation.nbest == cfg.generation.beam + ), "--sampling requires --nbest to be equal to --beam" + assert ( + not cfg.dataset.batch_size + or cfg.dataset.batch_size <= cfg.interactive.buffer_size + ), "--batch-size cannot be larger than --buffer-size" + + logger.info(cfg) + + # Fix seed for stochastic decoding + if cfg.common.seed is not None and not cfg.generation.no_seed_provided: + np.random.seed(cfg.common.seed) + utils.set_torch_seed(cfg.common.seed) + + use_cuda = torch.cuda.is_available() and not cfg.common.cpu + + # Setup task, e.g., translation + task = tasks.setup_task(cfg.task) + + # Load ensemble + overrides = ast.literal_eval(cfg.common_eval.model_overrides) + logger.info("loading model(s) from {}".format(cfg.common_eval.path)) + models, _model_args = checkpoint_utils.load_model_ensemble( + utils.split_paths(cfg.common_eval.path), + arg_overrides=overrides, + task=task, + suffix=cfg.checkpoint.checkpoint_suffix, + strict=(cfg.checkpoint.checkpoint_shard_count == 1), + num_shards=cfg.checkpoint.checkpoint_shard_count, + ) + + # Set dictionaries + src_dict = task.source_dictionary + tgt_dict = task.target_dictionary + + # Optimize ensemble for generation + for model in models: + if model is None: + continue + if cfg.common.fp16: + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + + # Initialize generator + generator = task.build_generator(models, cfg.generation) + + # Handle tokenization and BPE + tokenizer = task.build_tokenizer(cfg.tokenizer) + bpe = task.build_bpe(cfg.bpe) + + def encode_fn(x): + if tokenizer is not None: + x = tokenizer.encode(x) + if bpe is not None: + x = bpe.encode(x) + return x + + def decode_fn(x): + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + # Load alignment dictionary for unknown word replacement + # (None if no unknown word replacement, empty if no path to align dictionary) + align_dict = utils.load_align_dict(cfg.generation.replace_unk) + + max_positions = utils.resolve_max_positions( + task.max_positions(), *[model.max_positions() for model in models] + ) + + if cfg.generation.constraints: + logger.warning( + "NOTE: Constrained decoding currently assumes a shared subword vocabulary." + ) + + if cfg.interactive.buffer_size > 1: + logger.info("Sentence buffer size: %s", cfg.interactive.buffer_size) + logger.info("NOTE: hypothesis and token scores are output in base 2") + logger.info("Type the input sentence and press return:") + start_id = 0 + for inputs in buffered_read(cfg.interactive.input, cfg.interactive.buffer_size): + results = [] + for batch in make_batches(inputs, cfg, task, max_positions, encode_fn): + bsz = batch.src_tokens.size(0) + src_tokens = batch.src_tokens + src_lengths = batch.src_lengths + constraints = batch.constraints + if use_cuda: + src_tokens = src_tokens.cuda() + src_lengths = src_lengths.cuda() + if constraints is not None: + constraints = constraints.cuda() + + sample = { + "net_input": { + "src_tokens": src_tokens, + "src_lengths": src_lengths, + }, + } + translate_start_time = time.time() + translations = task.inference_step( + generator, models, sample, constraints=constraints + ) + translate_time = time.time() - translate_start_time + total_translate_time += translate_time + list_constraints = [[] for _ in range(bsz)] + if cfg.generation.constraints: + list_constraints = [unpack_constraints(c) for c in constraints] + for i, (id, hypos) in enumerate(zip(batch.ids.tolist(), translations)): + src_tokens_i = utils.strip_pad(src_tokens[i], tgt_dict.pad()) + constraints = list_constraints[i] + results.append( + ( + start_id + id, + src_tokens_i, + hypos, + { + "constraints": constraints, + "time": translate_time / len(translations), + }, + ) + ) + + # sort output to match input order + for id_, src_tokens, hypos, info in sorted(results, key=lambda x: x[0]): + src_str = '' + if src_dict is not None: + src_str = src_dict.string(src_tokens, cfg.common_eval.post_process) + print("S-{}\t{}".format(id_, src_str)) + print("W-{}\t{:.3f}\tseconds".format(id_, info["time"])) + for constraint in info["constraints"]: + print( + "C-{}\t{}".format( + id_, tgt_dict.string(constraint, cfg.common_eval.post_process) + ) + ) + + # Process top predictions + for hypo in hypos[: min(len(hypos), cfg.generation.nbest)]: + hypo_tokens, hypo_str, alignment = utils.post_process_prediction( + hypo_tokens=hypo["tokens"].int().cpu(), + src_str=src_str, + alignment=hypo["alignment"], + align_dict=align_dict, + tgt_dict=tgt_dict, + remove_bpe=cfg.common_eval.post_process, + extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator), + ) + detok_hypo_str = decode_fn(hypo_str) + score = hypo["score"] / math.log(2) # convert to base 2 + # original hypothesis (after tokenization and BPE) + print("H-{}\t{}\t{}".format(id_, score, hypo_str)) + # detokenized hypothesis + print("D-{}\t{}\t{}".format(id_, score, detok_hypo_str)) + print( + "P-{}\t{}".format( + id_, + " ".join( + map( + lambda x: "{:.4f}".format(x), + # convert from base e to base 2 + hypo["positional_scores"].div_(math.log(2)).tolist(), + ) + ), + ) + ) + if cfg.generation.print_alignment: + alignment_str = " ".join( + ["{}-{}".format(src, tgt) for src, tgt in alignment] + ) + print("A-{}\t{}".format(id_, alignment_str)) + + # update running id_ counter + start_id += len(inputs) + + logger.info( + "Total time: {:.3f} seconds; translation time: {:.3f}".format( + time.time() - start_time, total_translate_time + ) + ) + + +def cli_main(): + parser = options.get_interactive_generation_parser() + args = options.parse_args_and_arch(parser) + distributed_utils.call_main(convert_namespace_to_omegaconf(args), main) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/preprocess.py b/fairseq/fairseq_cli/preprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..4ee9a1e3ba08f9f6ef4c01b9ee34374c9528eb19 --- /dev/null +++ b/fairseq/fairseq_cli/preprocess.py @@ -0,0 +1,409 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Data pre-processing: build vocabularies and binarize training data. +""" + +import logging +import os +import shutil +import sys +from collections import Counter +from itertools import zip_longest +from multiprocessing import Pool + +from fairseq import options, tasks, utils +from fairseq.binarizer import Binarizer +from fairseq.data import indexed_dataset +from fairseq.file_chunker_utils import find_offsets + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.preprocess") + + +def main(args): + utils.import_user_module(args) + + os.makedirs(args.destdir, exist_ok=True) + + logger.addHandler( + logging.FileHandler( + filename=os.path.join(args.destdir, "preprocess.log"), + ) + ) + logger.info(args) + + assert args.dataset_impl != "huffman", "preprocessing.py doesn't support Huffman yet, use HuffmanCodeBuilder directly." + + task = tasks.get_task(args.task) + + def train_path(lang): + return "{}{}".format(args.trainpref, ("." + lang) if lang else "") + + def file_name(prefix, lang): + fname = prefix + if lang is not None: + fname += ".{lang}".format(lang=lang) + return fname + + def dest_path(prefix, lang): + return os.path.join(args.destdir, file_name(prefix, lang)) + + def dict_path(lang): + return dest_path("dict", lang) + ".txt" + + def build_dictionary(filenames, src=False, tgt=False): + assert src ^ tgt + return task.build_dictionary( + filenames, + workers=args.workers, + threshold=args.thresholdsrc if src else args.thresholdtgt, + nwords=args.nwordssrc if src else args.nwordstgt, + padding_factor=args.padding_factor, + ) + + target = not args.only_source + + if not args.srcdict and os.path.exists(dict_path(args.source_lang)): + raise FileExistsError(dict_path(args.source_lang)) + if target and not args.tgtdict and os.path.exists(dict_path(args.target_lang)): + raise FileExistsError(dict_path(args.target_lang)) + + if args.joined_dictionary: + assert ( + not args.srcdict or not args.tgtdict + ), "cannot use both --srcdict and --tgtdict with --joined-dictionary" + + if args.srcdict: + src_dict = task.load_dictionary(args.srcdict) + elif args.tgtdict: + src_dict = task.load_dictionary(args.tgtdict) + else: + assert ( + args.trainpref + ), "--trainpref must be set if --srcdict is not specified" + src_dict = build_dictionary( + {train_path(lang) for lang in [args.source_lang, args.target_lang]}, + src=True, + ) + tgt_dict = src_dict + else: + if args.srcdict: + src_dict = task.load_dictionary(args.srcdict) + else: + assert ( + args.trainpref + ), "--trainpref must be set if --srcdict is not specified" + src_dict = build_dictionary([train_path(args.source_lang)], src=True) + + if target: + if args.tgtdict: + tgt_dict = task.load_dictionary(args.tgtdict) + else: + assert ( + args.trainpref + ), "--trainpref must be set if --tgtdict is not specified" + tgt_dict = build_dictionary([train_path(args.target_lang)], tgt=True) + else: + tgt_dict = None + + src_dict.save(dict_path(args.source_lang)) + if target and tgt_dict is not None: + tgt_dict.save(dict_path(args.target_lang)) + + if args.dict_only: + return + + def make_binary_dataset(vocab, input_prefix, output_prefix, lang, num_workers): + logger.info("[{}] Dictionary: {} types".format(lang, len(vocab))) + n_seq_tok = [0, 0] + replaced = Counter() + + def merge_result(worker_result): + replaced.update(worker_result["replaced"]) + n_seq_tok[0] += worker_result["nseq"] + n_seq_tok[1] += worker_result["ntok"] + + input_file = "{}{}".format( + input_prefix, ("." + lang) if lang is not None else "" + ) + offsets = find_offsets(input_file, num_workers) + (first_chunk, *more_chunks) = zip(offsets, offsets[1:]) + pool = None + if num_workers > 1: + pool = Pool(processes=num_workers - 1) + for worker_id, (start_offset, end_offset) in enumerate( + more_chunks, start=1 + ): + prefix = "{}{}".format(output_prefix, worker_id) + pool.apply_async( + binarize, + ( + args, + input_file, + vocab, + prefix, + lang, + start_offset, + end_offset, + ), + callback=merge_result, + ) + pool.close() + + ds = indexed_dataset.make_builder( + dataset_dest_file(args, output_prefix, lang, "bin"), + impl=args.dataset_impl, + vocab_size=len(vocab), + ) + merge_result( + Binarizer.binarize( + input_file, + vocab, + lambda t: ds.add_item(t), + offset=first_chunk[0], + end=first_chunk[1], + ) + ) + if num_workers > 1: + pool.join() + for worker_id in range(1, num_workers): + prefix = "{}{}".format(output_prefix, worker_id) + temp_file_path = dataset_dest_prefix(args, prefix, lang) + ds.merge_file_(temp_file_path) + os.remove(indexed_dataset.data_file_path(temp_file_path)) + os.remove(indexed_dataset.index_file_path(temp_file_path)) + + ds.finalize(dataset_dest_file(args, output_prefix, lang, "idx")) + + logger.info( + "[{}] {}: {} sents, {} tokens, {:.3}% replaced by {}".format( + lang, + input_file, + n_seq_tok[0], + n_seq_tok[1], + 100 * sum(replaced.values()) / n_seq_tok[1], + vocab.unk_word, + ) + ) + + def make_binary_alignment_dataset(input_prefix, output_prefix, num_workers): + nseq = [0] + + def merge_result(worker_result): + nseq[0] += worker_result["nseq"] + + input_file = input_prefix + offsets = find_offsets(input_file, num_workers) + (first_chunk, *more_chunks) = zip(offsets, offsets[1:]) + pool = None + if num_workers > 1: + pool = Pool(processes=num_workers - 1) + for worker_id, (start_offset, end_offset) in enumerate( + more_chunks, start=1 + ): + prefix = "{}{}".format(output_prefix, worker_id) + pool.apply_async( + binarize_alignments, + ( + args, + input_file, + utils.parse_alignment, + prefix, + start_offset, + end_offset, + ), + callback=merge_result, + ) + pool.close() + + ds = indexed_dataset.make_builder( + dataset_dest_file(args, output_prefix, None, "bin"), impl=args.dataset_impl + ) + + merge_result( + Binarizer.binarize_alignments( + input_file, + utils.parse_alignment, + lambda t: ds.add_item(t), + offset=first_chunk[0], + end=first_chunk[1], + ) + ) + if num_workers > 1: + pool.join() + for worker_id in range(1, num_workers): + prefix = "{}{}".format(output_prefix, worker_id) + temp_file_path = dataset_dest_prefix(args, prefix, None) + ds.merge_file_(temp_file_path) + os.remove(indexed_dataset.data_file_path(temp_file_path)) + os.remove(indexed_dataset.index_file_path(temp_file_path)) + + ds.finalize(dataset_dest_file(args, output_prefix, None, "idx")) + + logger.info("[alignments] {}: parsed {} alignments".format(input_file, nseq[0])) + + def make_dataset(vocab, input_prefix, output_prefix, lang, num_workers=1): + if args.dataset_impl == "raw": + # Copy original text file to destination folder + output_text_file = dest_path( + output_prefix + ".{}-{}".format(args.source_lang, args.target_lang), + lang, + ) + shutil.copyfile(file_name(input_prefix, lang), output_text_file) + else: + make_binary_dataset(vocab, input_prefix, output_prefix, lang, num_workers) + + def make_all(lang, vocab): + if args.trainpref: + make_dataset(vocab, args.trainpref, "train", lang, num_workers=args.workers) + if args.validpref: + for k, validpref in enumerate(args.validpref.split(",")): + outprefix = "valid{}".format(k) if k > 0 else "valid" + make_dataset( + vocab, validpref, outprefix, lang, num_workers=args.workers + ) + if args.testpref: + for k, testpref in enumerate(args.testpref.split(",")): + outprefix = "test{}".format(k) if k > 0 else "test" + make_dataset(vocab, testpref, outprefix, lang, num_workers=args.workers) + + def make_all_alignments(): + if args.trainpref and os.path.exists(args.trainpref + "." + args.align_suffix): + make_binary_alignment_dataset( + args.trainpref + "." + args.align_suffix, + "train.align", + num_workers=args.workers, + ) + if args.validpref and os.path.exists(args.validpref + "." + args.align_suffix): + make_binary_alignment_dataset( + args.validpref + "." + args.align_suffix, + "valid.align", + num_workers=args.workers, + ) + if args.testpref and os.path.exists(args.testpref + "." + args.align_suffix): + make_binary_alignment_dataset( + args.testpref + "." + args.align_suffix, + "test.align", + num_workers=args.workers, + ) + + make_all(args.source_lang, src_dict) + if target: + make_all(args.target_lang, tgt_dict) + if args.align_suffix: + make_all_alignments() + + logger.info("Wrote preprocessed data to {}".format(args.destdir)) + + if args.alignfile: + assert args.trainpref, "--trainpref must be set if --alignfile is specified" + src_file_name = train_path(args.source_lang) + tgt_file_name = train_path(args.target_lang) + freq_map = {} + with open(args.alignfile, "r", encoding="utf-8") as align_file: + with open(src_file_name, "r", encoding="utf-8") as src_file: + with open(tgt_file_name, "r", encoding="utf-8") as tgt_file: + for a, s, t in zip_longest(align_file, src_file, tgt_file): + si = src_dict.encode_line(s, add_if_not_exist=False) + ti = tgt_dict.encode_line(t, add_if_not_exist=False) + ai = list(map(lambda x: tuple(x.split("-")), a.split())) + for sai, tai in ai: + srcidx = si[int(sai)] + tgtidx = ti[int(tai)] + if srcidx != src_dict.unk() and tgtidx != tgt_dict.unk(): + assert srcidx != src_dict.pad() + assert srcidx != src_dict.eos() + assert tgtidx != tgt_dict.pad() + assert tgtidx != tgt_dict.eos() + + if srcidx not in freq_map: + freq_map[srcidx] = {} + if tgtidx not in freq_map[srcidx]: + freq_map[srcidx][tgtidx] = 1 + else: + freq_map[srcidx][tgtidx] += 1 + + align_dict = {} + for srcidx in freq_map.keys(): + align_dict[srcidx] = max(freq_map[srcidx], key=freq_map[srcidx].get) + + with open( + os.path.join( + args.destdir, + "alignment.{}-{}.txt".format(args.source_lang, args.target_lang), + ), + "w", + encoding="utf-8", + ) as f: + for k, v in align_dict.items(): + print("{} {}".format(src_dict[k], tgt_dict[v]), file=f) + + +def binarize(args, filename, vocab, output_prefix, lang, offset, end, append_eos=True): + ds = indexed_dataset.make_builder( + dataset_dest_file(args, output_prefix, lang, "bin"), + impl=args.dataset_impl, + vocab_size=len(vocab), + ) + + def consumer(tensor): + ds.add_item(tensor) + + res = Binarizer.binarize( + filename, vocab, consumer, append_eos=append_eos, offset=offset, end=end + ) + ds.finalize(dataset_dest_file(args, output_prefix, lang, "idx")) + return res + + +def binarize_alignments(args, filename, parse_alignment, output_prefix, offset, end): + ds = indexed_dataset.make_builder( + dataset_dest_file(args, output_prefix, None, "bin"), + impl=args.dataset_impl, + vocab_size=None, + ) + + def consumer(tensor): + ds.add_item(tensor) + + res = Binarizer.binarize_alignments( + filename, parse_alignment, consumer, offset=offset, end=end + ) + ds.finalize(dataset_dest_file(args, output_prefix, None, "idx")) + return res + + +def dataset_dest_prefix(args, output_prefix, lang): + base = "{}/{}".format(args.destdir, output_prefix) + if lang is not None: + lang_part = ".{}-{}.{}".format(args.source_lang, args.target_lang, lang) + elif args.only_source: + lang_part = "" + else: + lang_part = ".{}-{}".format(args.source_lang, args.target_lang) + + return "{}{}".format(base, lang_part) + + +def dataset_dest_file(args, output_prefix, lang, extension): + base = dataset_dest_prefix(args, output_prefix, lang) + return "{}.{}".format(base, extension) + + +def cli_main(): + parser = options.get_preprocessing_parser() + args = parser.parse_args() + main(args) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/score.py b/fairseq/fairseq_cli/score.py new file mode 100644 index 0000000000000000000000000000000000000000..0b207be959d55f6a56d8c5eb7db3dbe0c1ac977e --- /dev/null +++ b/fairseq/fairseq_cli/score.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +BLEU scoring of generated translations against reference translations. +""" + +import argparse +import os +import sys + +from fairseq.data import dictionary +from fairseq.scoring import bleu + + +def get_parser(): + parser = argparse.ArgumentParser( + description="Command-line script for BLEU scoring." + ) + # fmt: off + parser.add_argument('-s', '--sys', default='-', help='system output') + parser.add_argument('-r', '--ref', required=True, help='references') + parser.add_argument('-o', '--order', default=4, metavar='N', + type=int, help='consider ngrams up to this order') + parser.add_argument('--ignore-case', action='store_true', + help='case-insensitive scoring') + parser.add_argument('--sacrebleu', action='store_true', + help='score with sacrebleu') + parser.add_argument('--sentence-bleu', action='store_true', + help='report sentence-level BLEUs (i.e., with +1 smoothing)') + # fmt: on + return parser + + +def cli_main(): + parser = get_parser() + args = parser.parse_args() + print(args) + + assert args.sys == "-" or os.path.exists( + args.sys + ), "System output file {} does not exist".format(args.sys) + assert os.path.exists(args.ref), "Reference file {} does not exist".format(args.ref) + + dict = dictionary.Dictionary() + + def readlines(fd): + for line in fd.readlines(): + if args.ignore_case: + yield line.lower() + else: + yield line + + if args.sacrebleu: + import sacrebleu + + def score(fdsys): + with open(args.ref) as fdref: + print(sacrebleu.corpus_bleu(fdsys, [fdref]).format()) + + elif args.sentence_bleu: + + def score(fdsys): + with open(args.ref) as fdref: + scorer = bleu.Scorer(dict.pad(), dict.eos(), dict.unk()) + for i, (sys_tok, ref_tok) in enumerate( + zip(readlines(fdsys), readlines(fdref)) + ): + scorer.reset(one_init=True) + sys_tok = dict.encode_line(sys_tok) + ref_tok = dict.encode_line(ref_tok) + scorer.add(ref_tok, sys_tok) + print(i, scorer.result_string(args.order)) + + else: + + def score(fdsys): + with open(args.ref) as fdref: + scorer = bleu.Scorer( + bleu.BleuConfig( + pad=dict.pad(), + eos=dict.eos(), + unk=dict.unk(), + ) + ) + for sys_tok, ref_tok in zip(readlines(fdsys), readlines(fdref)): + sys_tok = dict.encode_line(sys_tok) + ref_tok = dict.encode_line(ref_tok) + scorer.add(ref_tok, sys_tok) + print(scorer.result_string(args.order)) + + if args.sys == "-": + score(sys.stdin) + else: + with open(args.sys, "r") as f: + score(f) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/train.py b/fairseq/fairseq_cli/train.py new file mode 100644 index 0000000000000000000000000000000000000000..83475873138c5d1bac288c234afb6b4a1a7882d7 --- /dev/null +++ b/fairseq/fairseq_cli/train.py @@ -0,0 +1,514 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Train a new model on one or across multiple GPUs. +""" + +import argparse +import logging +import math +import os +import sys +from typing import Dict, Optional, Any, List, Tuple, Callable + +# We need to setup root logger before importing any fairseq libraries. +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.train") + +import numpy as np +import torch +from fairseq import ( + checkpoint_utils, + options, + quantization_utils, + tasks, + utils, +) +from fairseq.data import iterators, data_utils +from fairseq.data.plasma_utils import PlasmaStore +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.distributed import fsdp_enable_wrap, fsdp_wrap, utils as distributed_utils +from fairseq.file_io import PathManager +from fairseq.logging import meters, metrics, progress_bar +from fairseq.model_parallel.megatron_trainer import MegatronTrainer +from fairseq.trainer import Trainer +from omegaconf import DictConfig, OmegaConf + + + + +def main(cfg: FairseqConfig) -> None: + if isinstance(cfg, argparse.Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + utils.import_user_module(cfg.common) + + if distributed_utils.is_master(cfg.distributed_training) and "job_logging_cfg" in cfg: + # make hydra logging work with ddp (see # see https://github.com/facebookresearch/hydra/issues/1126) + logging.config.dictConfig(OmegaConf.to_container(cfg.job_logging_cfg)) + + assert ( + cfg.dataset.max_tokens is not None or cfg.dataset.batch_size is not None + ), "Must specify batch size either with --max-tokens or --batch-size" + metrics.reset() + + if cfg.common.log_file is not None: + handler = logging.FileHandler(filename=cfg.common.log_file) + logger.addHandler(handler) + + np.random.seed(cfg.common.seed) + utils.set_torch_seed(cfg.common.seed) + + if distributed_utils.is_master(cfg.distributed_training): + checkpoint_utils.verify_checkpoint_directory(cfg.checkpoint.save_dir) + + # Print args + logger.info(cfg) + + if cfg.checkpoint.write_checkpoints_asynchronously: + try: + import iopath # noqa: F401 + except ImportError: + logging.exception( + "Asynchronous checkpoint writing is specified but iopath is " + "not installed: `pip install iopath`" + ) + return + + # Setup task, e.g., translation, language modeling, etc. + task = tasks.setup_task(cfg.task) + + assert cfg.criterion, "Please specify criterion to train a model" + + # Build model and criterion + if cfg.distributed_training.ddp_backend == "fully_sharded": + with fsdp_enable_wrap(cfg.distributed_training): + model = fsdp_wrap(task.build_model(cfg.model)) + else: + model = task.build_model(cfg.model) + criterion = task.build_criterion(cfg.criterion) + logger.info(model) + logger.info("task: {}".format(task.__class__.__name__)) + logger.info("model: {}".format(model.__class__.__name__)) + logger.info("criterion: {}".format(criterion.__class__.__name__)) + logger.info( + "num. shared model params: {:,} (num. trained: {:,})".format( + sum(p.numel() for p in model.parameters() if not getattr(p, "expert", False)), + sum(p.numel() for p in model.parameters() if not getattr(p, "expert", False) and p.requires_grad) + ) + ) + + logger.info( + "num. expert model params: {} (num. trained: {})".format( + sum(p.numel() for p in model.parameters() if getattr(p, "expert", False)), + sum(p.numel() for p in model.parameters() if getattr(p, "expert", False) and p.requires_grad), + ) + ) + + # Load valid dataset (we load training data below, based on the latest checkpoint) + # We load the valid dataset AFTER building the model + data_utils.raise_if_valid_subsets_unintentionally_ignored(cfg) + if cfg.dataset.combine_valid_subsets: + task.load_dataset("valid", combine=True, epoch=1) + else: + for valid_sub_split in cfg.dataset.valid_subset.split(","): + task.load_dataset(valid_sub_split, combine=False, epoch=1) + + # (optionally) Configure quantization + if cfg.common.quantization_config_path is not None: + quantizer = quantization_utils.Quantizer( + config_path=cfg.common.quantization_config_path, + max_epoch=cfg.optimization.max_epoch, + max_update=cfg.optimization.max_update, + ) + else: + quantizer = None + + # Build trainer + if cfg.common.model_parallel_size == 1: + trainer = Trainer(cfg, task, model, criterion, quantizer) + else: + trainer = MegatronTrainer(cfg, task, model, criterion) + logger.info( + "training on {} devices (GPUs/TPUs)".format( + cfg.distributed_training.distributed_world_size + ) + ) + logger.info( + "max tokens per device = {} and max sentences per device = {}".format( + cfg.dataset.max_tokens, + cfg.dataset.batch_size, + ) + ) + + # Load the latest checkpoint if one is available and restore the + # corresponding train iterator + extra_state, epoch_itr = checkpoint_utils.load_checkpoint( + cfg.checkpoint, + trainer, + # don't cache epoch iterators for sharded datasets + disable_iterator_cache=task.has_sharded_data("train"), + ) + if cfg.common.tpu: + import torch_xla.core.xla_model as xm + xm.rendezvous("load_checkpoint") # wait for all workers + + max_epoch = cfg.optimization.max_epoch or math.inf + lr = trainer.get_lr() + + train_meter = meters.StopwatchMeter() + train_meter.start() + while epoch_itr.next_epoch_idx <= max_epoch: + if lr <= cfg.optimization.stop_min_lr: + logger.info( + f"stopping training because current learning rate ({lr}) is smaller " + "than or equal to minimum learning rate " + f"(--stop-min-lr={cfg.optimization.stop_min_lr})" + ) + break + + # train for one epoch + valid_losses, should_stop = train(cfg, trainer, task, epoch_itr) + if should_stop: + break + + # only use first validation loss to update the learning rate + lr = trainer.lr_step(epoch_itr.epoch, valid_losses[0]) + + epoch_itr = trainer.get_train_iterator( + epoch_itr.next_epoch_idx, + # sharded data: get train iterator for next epoch + load_dataset=task.has_sharded_data("train"), + # don't cache epoch iterators for sharded datasets + disable_iterator_cache=task.has_sharded_data("train"), + ) + train_meter.stop() + logger.info("done training in {:.1f} seconds".format(train_meter.sum)) + + # ioPath implementation to wait for all asynchronous file writes to complete. + if cfg.checkpoint.write_checkpoints_asynchronously: + logger.info( + "ioPath PathManager waiting for all asynchronous checkpoint " + "writes to finish." + ) + PathManager.async_close() + logger.info("ioPath PathManager finished waiting.") + + +def should_stop_early(cfg: DictConfig, valid_loss: float) -> bool: + # skip check if no validation was done in the current epoch + if valid_loss is None: + return False + if cfg.checkpoint.patience <= 0: + return False + + def is_better(a, b): + return a > b if cfg.checkpoint.maximize_best_checkpoint_metric else a < b + + prev_best = getattr(should_stop_early, "best", None) + if prev_best is None or is_better(valid_loss, prev_best): + should_stop_early.best = valid_loss + should_stop_early.num_runs = 0 + return False + else: + should_stop_early.num_runs += 1 + if should_stop_early.num_runs >= cfg.checkpoint.patience: + logger.info( + "early stop since valid performance hasn't improved for last {} runs".format( + cfg.checkpoint.patience + ) + ) + return True + else: + return False + + +@metrics.aggregate("train") +def train( + cfg: DictConfig, trainer: Trainer, task: tasks.FairseqTask, epoch_itr +) -> Tuple[List[Optional[float]], bool]: + """Train the model for one epoch and return validation losses.""" + # Initialize data iterator + itr = epoch_itr.next_epoch_itr( + fix_batches_to_gpus=cfg.distributed_training.fix_batches_to_gpus, + shuffle=(epoch_itr.next_epoch_idx > cfg.dataset.curriculum), + ) + update_freq = ( + cfg.optimization.update_freq[epoch_itr.epoch - 1] + if epoch_itr.epoch <= len(cfg.optimization.update_freq) + else cfg.optimization.update_freq[-1] + ) + itr = iterators.GroupedIterator(itr, update_freq) + if cfg.common.tpu: + itr = utils.tpu_data_loader(itr) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_file=cfg.common.log_file, + log_interval=cfg.common.log_interval, + epoch=epoch_itr.epoch, + tensorboard_logdir=( + cfg.common.tensorboard_logdir + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + wandb_project=( + cfg.common.wandb_project + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + wandb_run_name=os.environ.get( + "WANDB_NAME", os.path.basename(cfg.checkpoint.save_dir) + ), + azureml_logging=( + cfg.common.azureml_logging + if distributed_utils.is_master(cfg.distributed_training) + else False + ), + ) + progress.update_config(_flatten_config(cfg)) + + trainer.begin_epoch(epoch_itr.epoch) + + valid_subsets = cfg.dataset.valid_subset.split(",") + should_stop = False + num_updates = trainer.get_num_updates() + logger.info("Start iterating over samples") + for i, samples in enumerate(progress): + with metrics.aggregate("train_inner"), torch.autograd.profiler.record_function( + "train_step-%d" % i + ): + log_output = trainer.train_step(samples) + + if log_output is not None: # not OOM, overflow, ... + # log mid-epoch stats + num_updates = trainer.get_num_updates() + if num_updates % cfg.common.log_interval == 0: + stats = get_training_stats(metrics.get_smoothed_values("train_inner")) + progress.log(stats, tag="train_inner", step=num_updates) + + # reset mid-epoch stats after each log interval + # the end-of-epoch stats will still be preserved + metrics.reset_meters("train_inner") + + end_of_epoch = not itr.has_next() + valid_losses, should_stop = validate_and_save( + cfg, trainer, task, epoch_itr, valid_subsets, end_of_epoch + ) + + if should_stop: + break + + # log end-of-epoch stats + logger.info("end of epoch {} (average epoch stats below)".format(epoch_itr.epoch)) + stats = get_training_stats(metrics.get_smoothed_values("train")) + progress.print(stats, tag="train", step=num_updates) + + # reset epoch-level meters + metrics.reset_meters("train") + return valid_losses, should_stop + + +def _flatten_config(cfg: DictConfig): + config = OmegaConf.to_container(cfg) + # remove any legacy Namespaces and replace with a single "args" + namespace = None + for k, v in list(config.items()): + if isinstance(v, argparse.Namespace): + namespace = v + del config[k] + if namespace is not None: + config["args"] = vars(namespace) + return config + + +def validate_and_save( + cfg: DictConfig, + trainer: Trainer, + task: tasks.FairseqTask, + epoch_itr, + valid_subsets: List[str], + end_of_epoch: bool, +) -> Tuple[List[Optional[float]], bool]: + num_updates = trainer.get_num_updates() + max_update = cfg.optimization.max_update or math.inf + + # Stopping conditions (and an additional one based on validation loss later + # on) + should_stop = False + if num_updates >= max_update: + should_stop = True + logger.info( + f"Stopping training due to " + f"num_updates: {num_updates} >= max_update: {max_update}" + ) + + training_time_hours = trainer.cumulative_training_time() / (60 * 60) + if ( + cfg.optimization.stop_time_hours > 0 + and training_time_hours > cfg.optimization.stop_time_hours + ): + should_stop = True + logger.info( + f"Stopping training due to " + f"cumulative_training_time: {training_time_hours} > " + f"stop_time_hours: {cfg.optimization.stop_time_hours} hour(s)" + ) + + do_save = ( + (end_of_epoch and epoch_itr.epoch % cfg.checkpoint.save_interval == 0) + or should_stop + or ( + cfg.checkpoint.save_interval_updates > 0 + and num_updates > 0 + and num_updates % cfg.checkpoint.save_interval_updates == 0 + and num_updates >= cfg.dataset.validate_after_updates + ) + ) + do_validate = ( + (not end_of_epoch and do_save) # validate during mid-epoch saves + or (end_of_epoch and epoch_itr.epoch % cfg.dataset.validate_interval == 0) + or should_stop + or ( + cfg.dataset.validate_interval_updates > 0 + and num_updates > 0 + and num_updates % cfg.dataset.validate_interval_updates == 0 + ) + ) and not cfg.dataset.disable_validation and num_updates >= cfg.dataset.validate_after_updates + + # Validate + valid_losses = [None] + if do_validate: + valid_losses = validate(cfg, trainer, task, epoch_itr, valid_subsets) + + should_stop |= should_stop_early(cfg, valid_losses[0]) + + # Save checkpoint + if do_save or should_stop: + checkpoint_utils.save_checkpoint( + cfg.checkpoint, trainer, epoch_itr, valid_losses[0] + ) + + return valid_losses, should_stop + + +def get_training_stats(stats: Dict[str, Any]) -> Dict[str, Any]: + stats["wall"] = round(metrics.get_meter("default", "wall").elapsed_time, 0) + return stats + + +def validate( + cfg: DictConfig, + trainer: Trainer, + task: tasks.FairseqTask, + epoch_itr, + subsets: List[str], +) -> List[Optional[float]]: + """Evaluate the model on the validation set(s) and return the losses.""" + + if cfg.dataset.fixed_validation_seed is not None: + # set fixed seed for every validation + utils.set_torch_seed(cfg.dataset.fixed_validation_seed) + + trainer.begin_valid_epoch(epoch_itr.epoch) + valid_losses = [] + for subset in subsets: + logger.info('begin validation on "{}" subset'.format(subset)) + + # Initialize data iterator + itr = trainer.get_valid_iterator(subset).next_epoch_itr( + shuffle=False, set_dataset_epoch=False # use a fixed valid set + ) + if cfg.common.tpu: + itr = utils.tpu_data_loader(itr) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + epoch=epoch_itr.epoch, + prefix=f"valid on '{subset}' subset", + tensorboard_logdir=( + cfg.common.tensorboard_logdir + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + wandb_project=( + cfg.common.wandb_project + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + wandb_run_name=os.environ.get( + "WANDB_NAME", os.path.basename(cfg.checkpoint.save_dir) + ), + ) + + # create a new root metrics aggregator so validation metrics + # don't pollute other aggregators (e.g., train meters) + with metrics.aggregate(new_root=True) as agg: + for i, sample in enumerate(progress): + if cfg.dataset.max_valid_steps is not None and i > cfg.dataset.max_valid_steps: + break + trainer.valid_step(sample) + + # log validation stats + stats = get_valid_stats(cfg, trainer, agg.get_smoothed_values()) + + if hasattr(task, "post_validate"): + task.post_validate(trainer.get_model(), stats, agg) + + progress.print(stats, tag=subset, step=trainer.get_num_updates()) + + valid_losses.append(stats[cfg.checkpoint.best_checkpoint_metric]) + return valid_losses + + +def get_valid_stats( + cfg: DictConfig, trainer: Trainer, stats: Dict[str, Any] +) -> Dict[str, Any]: + stats["num_updates"] = trainer.get_num_updates() + if hasattr(checkpoint_utils.save_checkpoint, "best"): + key = "best_{0}".format(cfg.checkpoint.best_checkpoint_metric) + best_function = max if cfg.checkpoint.maximize_best_checkpoint_metric else min + stats[key] = best_function( + checkpoint_utils.save_checkpoint.best, + stats[cfg.checkpoint.best_checkpoint_metric], + ) + return stats + + +def cli_main( + modify_parser: Optional[Callable[[argparse.ArgumentParser], None]] = None +) -> None: + parser = options.get_training_parser() + args = options.parse_args_and_arch(parser, modify_parser=modify_parser) + + cfg = convert_namespace_to_omegaconf(args) + + if cfg.common.use_plasma_view: + server = PlasmaStore(path=cfg.common.plasma_path) + logger.info(f"Started plasma server pid {server.server.pid} {cfg.common.plasma_path}") + + if args.profile: + with torch.cuda.profiler.profile(): + with torch.autograd.profiler.emit_nvtx(): + distributed_utils.call_main(cfg, main) + else: + distributed_utils.call_main(cfg, main) + + # if cfg.common.use_plasma_view: + # server.server.kill() + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/fairseq_cli/validate.py b/fairseq/fairseq_cli/validate.py new file mode 100644 index 0000000000000000000000000000000000000000..22b93e9a6a1e1fbcff67075019177110905270f2 --- /dev/null +++ b/fairseq/fairseq_cli/validate.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import os +import sys +from argparse import Namespace +from itertools import chain + +import torch +from fairseq import checkpoint_utils, distributed_utils, options, utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.logging import metrics, progress_bar +from fairseq.utils import reset_logging +from omegaconf import DictConfig + + +logging.basicConfig( + format="%(asctime)s | %(levelname)s | %(name)s | %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.validate") + + +def main(cfg: DictConfig, override_args=None): + if isinstance(cfg, Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + utils.import_user_module(cfg.common) + + reset_logging() + + assert ( + cfg.dataset.max_tokens is not None or cfg.dataset.batch_size is not None + ), "Must specify batch size either with --max-tokens or --batch-size" + + use_fp16 = cfg.common.fp16 + use_cuda = torch.cuda.is_available() and not cfg.common.cpu + + if use_cuda: + torch.cuda.set_device(cfg.distributed_training.device_id) + + if cfg.distributed_training.distributed_world_size > 1: + data_parallel_world_size = distributed_utils.get_data_parallel_world_size() + data_parallel_rank = distributed_utils.get_data_parallel_rank() + else: + data_parallel_world_size = 1 + data_parallel_rank = 0 + + if override_args is not None: + overrides = vars(override_args) + overrides.update(eval(getattr(override_args, "model_overrides", "{}"))) + else: + overrides = None + + # Load ensemble + logger.info("loading model(s) from {}".format(cfg.common_eval.path)) + models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task( + [cfg.common_eval.path], + arg_overrides=overrides, + suffix=cfg.checkpoint.checkpoint_suffix, + ) + model = models[0] + + # Move models to GPU + for model in models: + model.eval() + if use_fp16: + model.half() + if use_cuda: + model.cuda() + + # Print args + logger.info(saved_cfg) + + # Build criterion + criterion = task.build_criterion(saved_cfg.criterion) + criterion.eval() + + for subset in cfg.dataset.valid_subset.split(","): + try: + task.load_dataset(subset, combine=False, epoch=1, task_cfg=saved_cfg.task) + dataset = task.dataset(subset) + except KeyError: + raise Exception("Cannot find dataset: " + subset) + + # Initialize data iterator + itr = task.get_batch_iterator( + dataset=dataset, + max_tokens=cfg.dataset.max_tokens, + max_sentences=cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + task.max_positions(), + *[m.max_positions() for m in models], + ), + ignore_invalid_inputs=cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=cfg.dataset.required_batch_size_multiple, + seed=cfg.common.seed, + num_shards=data_parallel_world_size, + shard_id=data_parallel_rank, + num_workers=cfg.dataset.num_workers, + data_buffer_size=cfg.dataset.data_buffer_size, + ).next_epoch_itr(shuffle=False) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + prefix=f"valid on '{subset}' subset", + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + ) + + log_outputs = [] + for i, sample in enumerate(progress): + sample = utils.move_to_cuda(sample) if use_cuda else sample + _loss, _sample_size, log_output = task.valid_step(sample, model, criterion) + progress.log(log_output, step=i) + log_outputs.append(log_output) + + if data_parallel_world_size > 1: + log_outputs = distributed_utils.all_gather_list( + log_outputs, + max_size=cfg.common.all_gather_list_size, + group=distributed_utils.get_data_parallel_group(), + ) + log_outputs = list(chain.from_iterable(log_outputs)) + + with metrics.aggregate() as agg: + task.reduce_metrics(log_outputs, criterion) + log_output = agg.get_smoothed_values() + + progress.print(log_output, tag=subset, step=i) + + +def cli_main(): + parser = options.get_validation_parser() + args = options.parse_args_and_arch(parser) + + # only override args that are explicitly given on the command line + override_parser = options.get_validation_parser() + override_args = options.parse_args_and_arch( + override_parser, suppress_defaults=True + ) + + distributed_utils.call_main( + convert_namespace_to_omegaconf(args), main, override_args=override_args + ) + + +if __name__ == "__main__": + cli_main() diff --git a/fairseq/hubconf.py b/fairseq/hubconf.py new file mode 100644 index 0000000000000000000000000000000000000000..5949e274edd02e86cb323331211641ce0d0b9b93 --- /dev/null +++ b/fairseq/hubconf.py @@ -0,0 +1,73 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +"""isort:skip_file""" + +import functools +import importlib + + +dependencies = [ + "dataclasses", + "hydra", + "numpy", + "omegaconf", + "regex", + "requests", + "torch", +] + + +# Check for required dependencies and raise a RuntimeError if any are missing. +missing_deps = [] +for dep in dependencies: + try: + importlib.import_module(dep) + except ImportError: + # Hack: the hydra package is provided under the "hydra-core" name in + # pypi. We don't want the user mistakenly calling `pip install hydra` + # since that will install an unrelated package. + if dep == "hydra": + dep = "hydra-core" + missing_deps.append(dep) +if len(missing_deps) > 0: + raise RuntimeError("Missing dependencies: {}".format(", ".join(missing_deps))) + + +# only do fairseq imports after checking for dependencies +from fairseq.hub_utils import ( # noqa; noqa + BPEHubInterface as bpe, + TokenizerHubInterface as tokenizer, +) +from fairseq.models import MODEL_REGISTRY # noqa + + +# torch.hub doesn't build Cython components, so if they are not found then try +# to build them here +try: + import fairseq.data.token_block_utils_fast # noqa +except ImportError: + try: + import cython # noqa + import os + from setuptools import sandbox + + sandbox.run_setup( + os.path.join(os.path.dirname(__file__), "setup.py"), + ["build_ext", "--inplace"], + ) + except ImportError: + print( + "Unable to build Cython components. Please make sure Cython is " + "installed if the torch.hub model you are loading depends on it." + ) + + +# automatically expose models defined in FairseqModel::hub_models +for _model_type, _cls in MODEL_REGISTRY.items(): + for model_name in _cls.hub_models().keys(): + globals()[model_name] = functools.partial( + _cls.from_pretrained, + model_name, + ) diff --git a/fairseq/pyproject.toml b/fairseq/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..6d1b4c5b6fb56a63069147e3a1de922ce71a45d8 --- /dev/null +++ b/fairseq/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools", "wheel", "cython"] +build-backend = "setuptools.build_meta" diff --git a/fairseq/scripts/__init__.py b/fairseq/scripts/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/scripts/average_checkpoints.py b/fairseq/scripts/average_checkpoints.py new file mode 100644 index 0000000000000000000000000000000000000000..c512f802bce6b3395cc42a0e4eb39181e9f8c873 --- /dev/null +++ b/fairseq/scripts/average_checkpoints.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import collections +import os +import re + +import torch +from fairseq.file_io import PathManager + + +def average_checkpoints(inputs): + """Loads checkpoints from inputs and returns a model with averaged weights. + + Args: + inputs: An iterable of string paths of checkpoints to load from. + + Returns: + A dict of string keys mapping to various values. The 'model' key + from the returned dict should correspond to an OrderedDict mapping + string parameter names to torch Tensors. + """ + params_dict = collections.OrderedDict() + params_keys = None + new_state = None + num_models = len(inputs) + + for fpath in inputs: + with PathManager.open(fpath, "rb") as f: + state = torch.load( + f, + map_location=( + lambda s, _: torch.serialization.default_restore_location(s, "cpu") + ), + ) + # Copies over the settings from the first checkpoint + if new_state is None: + new_state = state + + model_params = state["model"] + + model_params_keys = list(model_params.keys()) + if params_keys is None: + params_keys = model_params_keys + elif params_keys != model_params_keys: + raise KeyError( + "For checkpoint {}, expected list of params: {}, " + "but found: {}".format(f, params_keys, model_params_keys) + ) + + for k in params_keys: + p = model_params[k] + if isinstance(p, torch.HalfTensor): + p = p.float() + if k not in params_dict: + params_dict[k] = p.clone() + # NOTE: clone() is needed in case of p is a shared parameter + else: + params_dict[k] += p + + averaged_params = collections.OrderedDict() + for k, v in params_dict.items(): + averaged_params[k] = v + if averaged_params[k].is_floating_point(): + averaged_params[k].div_(num_models) + else: + averaged_params[k] //= num_models + new_state["model"] = averaged_params + return new_state + + +def last_n_checkpoints(paths, n, update_based, upper_bound=None): + assert len(paths) == 1 + path = paths[0] + if update_based: + pt_regexp = re.compile(r"checkpoint_\d+_(\d+)\.pt") + else: + pt_regexp = re.compile(r"checkpoint(\d+)\.pt") + files = PathManager.ls(path) + + entries = [] + for f in files: + m = pt_regexp.fullmatch(f) + if m is not None: + sort_key = int(m.group(1)) + if upper_bound is None or sort_key <= upper_bound: + entries.append((sort_key, m.group(0))) + if len(entries) < n: + raise Exception( + "Found {} checkpoint files but need at least {}", len(entries), n + ) + return [os.path.join(path, x[1]) for x in sorted(entries, reverse=True)[:n]] + + +def main(): + parser = argparse.ArgumentParser( + description="Tool to average the params of input checkpoints to " + "produce a new checkpoint", + ) + # fmt: off + parser.add_argument('--inputs', required=True, nargs='+', + help='Input checkpoint file paths.') + parser.add_argument('--output', required=True, metavar='FILE', + help='Write the new checkpoint containing the averaged weights to this path.') + num_group = parser.add_mutually_exclusive_group() + num_group.add_argument('--num-epoch-checkpoints', type=int, + help='if set, will try to find checkpoints with names checkpoint_xx.pt in the path specified by input, ' + 'and average last this many of them.') + num_group.add_argument('--num-update-checkpoints', type=int, + help='if set, will try to find checkpoints with names checkpoint_ee_xx.pt in the path specified by input, ' + 'and average last this many of them.') + parser.add_argument('--checkpoint-upper-bound', type=int, + help='when using --num-epoch-checkpoints, this will set an upper bound on which epoch to use, ' + 'when using --num-update-checkpoints, this will set an upper bound on which update to use' + 'e.g., with --num-epoch-checkpoints=10 --checkpoint-upper-bound=50, checkpoints 41-50 would be averaged.' + 'e.g., with --num-update-checkpoints=10 --checkpoint-upper-bound=50000, checkpoints 40500-50000 would be averaged assuming --save-interval-updates 500' + ) + # fmt: on + args = parser.parse_args() + print(args) + + num = None + is_update_based = False + if args.num_update_checkpoints is not None: + num = args.num_update_checkpoints + is_update_based = True + elif args.num_epoch_checkpoints is not None: + num = args.num_epoch_checkpoints + + assert args.checkpoint_upper_bound is None or ( + args.num_epoch_checkpoints is not None + or args.num_update_checkpoints is not None + ), "--checkpoint-upper-bound requires --num-epoch-checkpoints or --num-update-checkpoints" + assert ( + args.num_epoch_checkpoints is None or args.num_update_checkpoints is None + ), "Cannot combine --num-epoch-checkpoints and --num-update-checkpoints" + + if num is not None: + args.inputs = last_n_checkpoints( + args.inputs, + num, + is_update_based, + upper_bound=args.checkpoint_upper_bound, + ) + print("averaging checkpoints: ", args.inputs) + + new_state = average_checkpoints(args.inputs) + with PathManager.open(args.output, "wb") as f: + torch.save(new_state, f) + print("Finished writing averaged checkpoint to {}".format(args.output)) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/build_sym_alignment.py b/fairseq/scripts/build_sym_alignment.py new file mode 100644 index 0000000000000000000000000000000000000000..0ca5c18f7bd4b0fbf58b203793506ca395466129 --- /dev/null +++ b/fairseq/scripts/build_sym_alignment.py @@ -0,0 +1,97 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Use this script in order to build symmetric alignments for your translation +dataset. +This script depends on fast_align and mosesdecoder tools. You will need to +build those before running the script. +fast_align: + github: http://github.com/clab/fast_align + instructions: follow the instructions in README.md +mosesdecoder: + github: http://github.com/moses-smt/mosesdecoder + instructions: http://www.statmt.org/moses/?n=Development.GetStarted +The script produces the following files under --output_dir: + text.joined - concatenation of lines from the source_file and the + target_file. + align.forward - forward pass of fast_align. + align.backward - backward pass of fast_align. + aligned.sym_heuristic - symmetrized alignment. +""" + +import argparse +import os +from itertools import zip_longest + + +def main(): + parser = argparse.ArgumentParser(description="symmetric alignment builer") + # fmt: off + parser.add_argument('--fast_align_dir', + help='path to fast_align build directory') + parser.add_argument('--mosesdecoder_dir', + help='path to mosesdecoder root directory') + parser.add_argument('--sym_heuristic', + help='heuristic to use for symmetrization', + default='grow-diag-final-and') + parser.add_argument('--source_file', + help='path to a file with sentences ' + 'in the source language') + parser.add_argument('--target_file', + help='path to a file with sentences ' + 'in the target language') + parser.add_argument('--output_dir', + help='output directory') + # fmt: on + args = parser.parse_args() + + fast_align_bin = os.path.join(args.fast_align_dir, "fast_align") + symal_bin = os.path.join(args.mosesdecoder_dir, "bin", "symal") + sym_fast_align_bin = os.path.join( + args.mosesdecoder_dir, "scripts", "ems", "support", "symmetrize-fast-align.perl" + ) + + # create joined file + joined_file = os.path.join(args.output_dir, "text.joined") + with open(args.source_file, "r", encoding="utf-8") as src, open( + args.target_file, "r", encoding="utf-8" + ) as tgt: + with open(joined_file, "w", encoding="utf-8") as joined: + for s, t in zip_longest(src, tgt): + print("{} ||| {}".format(s.strip(), t.strip()), file=joined) + + bwd_align_file = os.path.join(args.output_dir, "align.backward") + + # run forward alignment + fwd_align_file = os.path.join(args.output_dir, "align.forward") + fwd_fast_align_cmd = "{FASTALIGN} -i {JOINED} -d -o -v > {FWD}".format( + FASTALIGN=fast_align_bin, JOINED=joined_file, FWD=fwd_align_file + ) + assert os.system(fwd_fast_align_cmd) == 0 + + # run backward alignment + bwd_align_file = os.path.join(args.output_dir, "align.backward") + bwd_fast_align_cmd = "{FASTALIGN} -i {JOINED} -d -o -v -r > {BWD}".format( + FASTALIGN=fast_align_bin, JOINED=joined_file, BWD=bwd_align_file + ) + assert os.system(bwd_fast_align_cmd) == 0 + + # run symmetrization + sym_out_file = os.path.join(args.output_dir, "aligned") + sym_cmd = "{SYMFASTALIGN} {FWD} {BWD} {SRC} {TGT} {OUT} {HEURISTIC} {SYMAL}".format( + SYMFASTALIGN=sym_fast_align_bin, + FWD=fwd_align_file, + BWD=bwd_align_file, + SRC=args.source_file, + TGT=args.target_file, + OUT=sym_out_file, + HEURISTIC=args.sym_heuristic, + SYMAL=symal_bin, + ) + assert os.system(sym_cmd) == 0 + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/compare_namespaces.py b/fairseq/scripts/compare_namespaces.py new file mode 100644 index 0000000000000000000000000000000000000000..bc24db624f8db36f546c263ba3a806dae6d466bf --- /dev/null +++ b/fairseq/scripts/compare_namespaces.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python +"""Helper script to compare two argparse.Namespace objects.""" + +from argparse import Namespace # noqa + + +def main(): + + ns1 = eval(input("Namespace 1: ")) + ns2 = eval(input("Namespace 2: ")) + + def keys(ns): + ks = set() + for k in dir(ns): + if not k.startswith("_"): + ks.add(k) + return ks + + k1 = keys(ns1) + k2 = keys(ns2) + + def print_keys(ks, ns1, ns2=None): + for k in ks: + if ns2 is None: + print("{}\t{}".format(k, getattr(ns1, k, None))) + else: + print( + "{}\t{}\t{}".format(k, getattr(ns1, k, None), getattr(ns2, k, None)) + ) + + print("Keys unique to namespace 1:") + print_keys(k1 - k2, ns1) + print() + + print("Keys unique to namespace 2:") + print_keys(k2 - k1, ns2) + print() + + print("Overlapping keys with different values:") + ks = [k for k in k1 & k2 if getattr(ns1, k, "None") != getattr(ns2, k, "None")] + print_keys(ks, ns1, ns2) + print() + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/compound_split_bleu.sh b/fairseq/scripts/compound_split_bleu.sh new file mode 100644 index 0000000000000000000000000000000000000000..1972fddcebff9a43a70bcf14c287175c68f60e3f --- /dev/null +++ b/fairseq/scripts/compound_split_bleu.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +if [ $# -ne 1 ]; then + echo "usage: $0 GENERATE_PY_OUTPUT" + exit 1 +fi + +GEN=$1 + +SYS=$GEN.sys +REF=$GEN.ref + +if [ $(tail -n 1 $GEN | grep BLEU | wc -l) -ne 1 ]; then + echo "not done generating" + exit +fi + +grep ^H $GEN | awk -F '\t' '{print $NF}' | perl -ple 's{(\S)-(\S)}{$1 ##AT##-##AT## $2}g' > $SYS +grep ^T $GEN | cut -f2- | perl -ple 's{(\S)-(\S)}{$1 ##AT##-##AT## $2}g' > $REF +fairseq-score --sys $SYS --ref $REF diff --git a/fairseq/scripts/constraints/extract.py b/fairseq/scripts/constraints/extract.py new file mode 100755 index 0000000000000000000000000000000000000000..f6155d0a0538aadb46bf612256b6b949728de69e --- /dev/null +++ b/fairseq/scripts/constraints/extract.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +# +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +"""Extracts random constraints from reference files.""" + +import argparse +import random +import sys + +from sacrebleu import extract_ngrams + + +def get_phrase(words, index, length): + assert index < len(words) - length + 1 + phr = " ".join(words[index : index + length]) + for i in range(index, index + length): + words.pop(index) + return phr + + +def main(args): + + if args.seed: + random.seed(args.seed) + + for line in sys.stdin: + constraints = [] + + def add_constraint(constraint): + constraints.append(constraint) + + source = line.rstrip() + if "\t" in line: + source, target = line.split("\t") + if args.add_sos: + target = f"<s> {target}" + if args.add_eos: + target = f"{target} </s>" + + if len(target.split()) >= args.len: + words = [target] + + num = args.number + + choices = {} + for i in range(num): + if len(words) == 0: + break + segmentno = random.choice(range(len(words))) + segment = words.pop(segmentno) + tokens = segment.split() + phrase_index = random.choice(range(len(tokens))) + choice = " ".join( + tokens[phrase_index : min(len(tokens), phrase_index + args.len)] + ) + for j in range( + phrase_index, min(len(tokens), phrase_index + args.len) + ): + tokens.pop(phrase_index) + if phrase_index > 0: + words.append(" ".join(tokens[0:phrase_index])) + if phrase_index + 1 < len(tokens): + words.append(" ".join(tokens[phrase_index:])) + choices[target.find(choice)] = choice + + # mask out with spaces + target = target.replace(choice, " " * len(choice), 1) + + for key in sorted(choices.keys()): + add_constraint(choices[key]) + + print(source, *constraints, sep="\t") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--number", "-n", type=int, default=1, help="number of phrases") + parser.add_argument("--len", "-l", type=int, default=1, help="phrase length") + parser.add_argument( + "--add-sos", default=False, action="store_true", help="add <s> token" + ) + parser.add_argument( + "--add-eos", default=False, action="store_true", help="add </s> token" + ) + parser.add_argument("--seed", "-s", default=0, type=int) + args = parser.parse_args() + + main(args) diff --git a/fairseq/scripts/constraints/validate.py b/fairseq/scripts/constraints/validate.py new file mode 100755 index 0000000000000000000000000000000000000000..d531ad9f39b1df42c98fe8f26ad61fe53a9ac0c5 --- /dev/null +++ b/fairseq/scripts/constraints/validate.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +# +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys + + +"""Reads in a fairseq output file, and verifies that the constraints +(C- lines) are present in the output (the first H- line). Assumes that +constraints are listed prior to the first hypothesis. +""" + +constraints = [] +found = 0 +total = 0 +for line in sys.stdin: + if line.startswith("C-"): + constraints.append(line.rstrip().split("\t")[1]) + elif line.startswith("H-"): + text = line.split("\t")[2] + + for constraint in constraints: + total += 1 + if constraint in text: + found += 1 + else: + print(f"No {constraint} in {text}", file=sys.stderr) + + constraints = [] + +print(f"Found {found} / {total} = {100 * found / total:.1f}%") diff --git a/fairseq/scripts/convert_dictionary.lua b/fairseq/scripts/convert_dictionary.lua new file mode 100644 index 0000000000000000000000000000000000000000..14ee8c997f642c8ff196617c2dcd0584037a60c4 --- /dev/null +++ b/fairseq/scripts/convert_dictionary.lua @@ -0,0 +1,34 @@ +-- Copyright (c) Facebook, Inc. and its affiliates. +-- +-- This source code is licensed under the MIT license found in the +-- LICENSE file in the root directory of this source tree. +-- +-- Usage: convert_dictionary.lua <dict.th7> +require 'fairseq' +require 'torch' +require 'paths' + +if #arg < 1 then + print('usage: convert_dictionary.lua <dict.th7>') + os.exit(1) +end +if not paths.filep(arg[1]) then + print('error: file does not exit: ' .. arg[1]) + os.exit(1) +end + +dict = torch.load(arg[1]) +dst = paths.basename(arg[1]):gsub('.th7', '.txt') +assert(dst:match('.txt$')) + +f = io.open(dst, 'w') +for idx, symbol in ipairs(dict.index_to_symbol) do + if idx > dict.cutoff then + break + end + f:write(symbol) + f:write(' ') + f:write(dict.index_to_freq[idx]) + f:write('\n') +end +f:close() diff --git a/fairseq/scripts/convert_model.lua b/fairseq/scripts/convert_model.lua new file mode 100644 index 0000000000000000000000000000000000000000..61b92139294fb90a25989ebd2ee52a765fb278a2 --- /dev/null +++ b/fairseq/scripts/convert_model.lua @@ -0,0 +1,108 @@ +-- Copyright (c) Facebook, Inc. and its affiliates. +-- +-- This source code is licensed under the MIT license found in the +-- LICENSE file in the root directory of this source tree. +-- +-- Usage: convert_model.lua <model_epoch1.th7> +require 'torch' +local fairseq = require 'fairseq' + +model = torch.load(arg[1]) + +function find_weight_norm(container, module) + for _, wn in ipairs(container:listModules()) do + if torch.type(wn) == 'nn.WeightNorm' and wn.modules[1] == module then + return wn + end + end +end + +function push_state(dict, key, module) + if torch.type(module) == 'nn.Linear' then + local wn = find_weight_norm(model.module, module) + assert(wn) + dict[key .. '.weight_v'] = wn.v:float() + dict[key .. '.weight_g'] = wn.g:float() + elseif torch.type(module) == 'nn.TemporalConvolutionTBC' then + local wn = find_weight_norm(model.module, module) + assert(wn) + local v = wn.v:float():view(wn.viewOut):transpose(2, 3) + dict[key .. '.weight_v'] = v + dict[key .. '.weight_g'] = wn.g:float():view(module.weight:size(3), 1, 1) + else + dict[key .. '.weight'] = module.weight:float() + end + if module.bias then + dict[key .. '.bias'] = module.bias:float() + end +end + +encoder_dict = {} +decoder_dict = {} +combined_dict = {} + +function encoder_state(encoder) + luts = encoder:findModules('nn.LookupTable') + push_state(encoder_dict, 'embed_tokens', luts[1]) + push_state(encoder_dict, 'embed_positions', luts[2]) + + fcs = encoder:findModules('nn.Linear') + assert(#fcs >= 2) + local nInputPlane = fcs[1].weight:size(1) + push_state(encoder_dict, 'fc1', table.remove(fcs, 1)) + push_state(encoder_dict, 'fc2', table.remove(fcs, #fcs)) + + for i, module in ipairs(encoder:findModules('nn.TemporalConvolutionTBC')) do + push_state(encoder_dict, 'convolutions.' .. tostring(i - 1), module) + if nInputPlane ~= module.weight:size(3) / 2 then + push_state(encoder_dict, 'projections.' .. tostring(i - 1), table.remove(fcs, 1)) + end + nInputPlane = module.weight:size(3) / 2 + end + assert(#fcs == 0) +end + +function decoder_state(decoder) + luts = decoder:findModules('nn.LookupTable') + push_state(decoder_dict, 'embed_tokens', luts[1]) + push_state(decoder_dict, 'embed_positions', luts[2]) + + fcs = decoder:findModules('nn.Linear') + local nInputPlane = fcs[1].weight:size(1) + push_state(decoder_dict, 'fc1', table.remove(fcs, 1)) + push_state(decoder_dict, 'fc2', fcs[#fcs - 1]) + push_state(decoder_dict, 'fc3', fcs[#fcs]) + + table.remove(fcs, #fcs) + table.remove(fcs, #fcs) + + for i, module in ipairs(decoder:findModules('nn.TemporalConvolutionTBC')) do + if nInputPlane ~= module.weight:size(3) / 2 then + push_state(decoder_dict, 'projections.' .. tostring(i - 1), table.remove(fcs, 1)) + end + nInputPlane = module.weight:size(3) / 2 + + local prefix = 'attention.' .. tostring(i - 1) + push_state(decoder_dict, prefix .. '.in_projection', table.remove(fcs, 1)) + push_state(decoder_dict, prefix .. '.out_projection', table.remove(fcs, 1)) + push_state(decoder_dict, 'convolutions.' .. tostring(i - 1), module) + end + assert(#fcs == 0) +end + + +_encoder = model.module.modules[2] +_decoder = model.module.modules[3] + +encoder_state(_encoder) +decoder_state(_decoder) + +for k, v in pairs(encoder_dict) do + combined_dict['encoder.' .. k] = v +end +for k, v in pairs(decoder_dict) do + combined_dict['decoder.' .. k] = v +end + + +torch.save('state_dict.t7', combined_dict) diff --git a/fairseq/scripts/count_docs.py b/fairseq/scripts/count_docs.py new file mode 100644 index 0000000000000000000000000000000000000000..58d85af85e91377a34dbd01f7674436152fd08e8 --- /dev/null +++ b/fairseq/scripts/count_docs.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Count the number of documents and average number of lines and tokens per +document in a large file. Documents should be separated by a single empty line. +""" + +import argparse +import gzip +import sys + +import numpy as np + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("input") + parser.add_argument("--gzip", action="store_true") + args = parser.parse_args() + + def gopen(): + if args.gzip: + return gzip.open(args.input, "r") + else: + return open(args.input, "r", encoding="utf-8") + + num_lines = [] + num_toks = [] + with gopen() as h: + num_docs = 1 + num_lines_in_doc = 0 + num_toks_in_doc = 0 + for i, line in enumerate(h): + if len(line.strip()) == 0: # empty line indicates new document + num_docs += 1 + num_lines.append(num_lines_in_doc) + num_toks.append(num_toks_in_doc) + num_lines_in_doc = 0 + num_toks_in_doc = 0 + else: + num_lines_in_doc += 1 + num_toks_in_doc += len(line.rstrip().split()) + if i % 1000000 == 0: + print(i, file=sys.stderr, end="", flush=True) + elif i % 100000 == 0: + print(".", file=sys.stderr, end="", flush=True) + print(file=sys.stderr, flush=True) + + print("found {} docs".format(num_docs)) + print("average num lines per doc: {}".format(np.mean(num_lines))) + print("average num toks per doc: {}".format(np.mean(num_toks))) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/read_binarized.py b/fairseq/scripts/read_binarized.py new file mode 100644 index 0000000000000000000000000000000000000000..a414095d03fb022a6753e816fc8bfd80e11db24d --- /dev/null +++ b/fairseq/scripts/read_binarized.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse + +from fairseq.data import Dictionary, data_utils, indexed_dataset + + +def get_parser(): + parser = argparse.ArgumentParser( + description="writes text from binarized file to stdout" + ) + # fmt: off + parser.add_argument('--dataset-impl', help='dataset implementation', + choices=indexed_dataset.get_available_dataset_impl()) + parser.add_argument('--dict', metavar='FP', help='dictionary containing known words', default=None) + parser.add_argument('--input', metavar='FP', required=True, help='binarized file to read') + # fmt: on + + return parser + + +def main(): + parser = get_parser() + args = parser.parse_args() + + dictionary = Dictionary.load(args.dict) if args.dict is not None else None + dataset = data_utils.load_indexed_dataset( + args.input, + dictionary, + dataset_impl=args.dataset_impl, + default="lazy", + ) + + for tensor_line in dataset: + if dictionary is None: + line = " ".join([str(int(x)) for x in tensor_line]) + else: + line = dictionary.string(tensor_line) + + print(line) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/rm_pt.py b/fairseq/scripts/rm_pt.py new file mode 100644 index 0000000000000000000000000000000000000000..6cd063d21f0610fa7c42c2cfb2ee8af7c9c78677 --- /dev/null +++ b/fairseq/scripts/rm_pt.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +import re +import shutil +import sys + + +pt_regexp = re.compile(r"checkpoint(\d+|_\d+_\d+|_[a-z]+)\.pt") +pt_regexp_epoch_based = re.compile(r"checkpoint(\d+)\.pt") +pt_regexp_update_based = re.compile(r"checkpoint_\d+_(\d+)\.pt") + + +def parse_checkpoints(files): + entries = [] + for f in files: + m = pt_regexp_epoch_based.fullmatch(f) + if m is not None: + entries.append((int(m.group(1)), m.group(0))) + else: + m = pt_regexp_update_based.fullmatch(f) + if m is not None: + entries.append((int(m.group(1)), m.group(0))) + return entries + + +def last_n_checkpoints(files, n): + entries = parse_checkpoints(files) + return [x[1] for x in sorted(entries, reverse=True)[:n]] + + +def every_n_checkpoints(files, n): + entries = parse_checkpoints(files) + return [x[1] for x in sorted(sorted(entries)[::-n])] + + +def main(): + parser = argparse.ArgumentParser( + description=( + "Recursively delete checkpoint files from `root_dir`, " + "but preserve checkpoint_best.pt and checkpoint_last.pt" + ) + ) + parser.add_argument("root_dirs", nargs="*") + parser.add_argument( + "--save-last", type=int, default=0, help="number of last checkpoints to save" + ) + parser.add_argument( + "--save-every", type=int, default=0, help="interval of checkpoints to save" + ) + parser.add_argument( + "--preserve-test", + action="store_true", + help="preserve checkpoints in dirs that start with test_ prefix (default: delete them)", + ) + parser.add_argument( + "--delete-best", action="store_true", help="delete checkpoint_best.pt" + ) + parser.add_argument( + "--delete-last", action="store_true", help="delete checkpoint_last.pt" + ) + parser.add_argument( + "--no-dereference", action="store_true", help="don't dereference symlinks" + ) + args = parser.parse_args() + + files_to_desymlink = [] + files_to_preserve = [] + files_to_delete = [] + for root_dir in args.root_dirs: + for root, _subdirs, files in os.walk(root_dir): + if args.save_last > 0: + to_save = last_n_checkpoints(files, args.save_last) + else: + to_save = [] + if args.save_every > 0: + to_save += every_n_checkpoints(files, args.save_every) + for file in files: + if not pt_regexp.fullmatch(file): + continue + full_path = os.path.join(root, file) + if ( + not os.path.basename(root).startswith("test_") or args.preserve_test + ) and ( + (file == "checkpoint_last.pt" and not args.delete_last) + or (file == "checkpoint_best.pt" and not args.delete_best) + or file in to_save + ): + if os.path.islink(full_path) and not args.no_dereference: + files_to_desymlink.append(full_path) + else: + files_to_preserve.append(full_path) + else: + files_to_delete.append(full_path) + + if len(files_to_desymlink) == 0 and len(files_to_delete) == 0: + print("Nothing to do.") + sys.exit(0) + + files_to_desymlink = sorted(files_to_desymlink) + files_to_preserve = sorted(files_to_preserve) + files_to_delete = sorted(files_to_delete) + + print("Operations to perform (in order):") + if len(files_to_desymlink) > 0: + for file in files_to_desymlink: + print(" - preserve (and dereference symlink): " + file) + if len(files_to_preserve) > 0: + for file in files_to_preserve: + print(" - preserve: " + file) + if len(files_to_delete) > 0: + for file in files_to_delete: + print(" - delete: " + file) + while True: + resp = input("Continue? (Y/N): ") + if resp.strip().lower() == "y": + break + elif resp.strip().lower() == "n": + sys.exit(0) + + print("Executing...") + if len(files_to_desymlink) > 0: + for file in files_to_desymlink: + realpath = os.path.realpath(file) + print("rm " + file) + os.remove(file) + print("cp {} {}".format(realpath, file)) + shutil.copyfile(realpath, file) + if len(files_to_delete) > 0: + for file in files_to_delete: + print("rm " + file) + os.remove(file) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/sacrebleu.sh b/fairseq/scripts/sacrebleu.sh new file mode 100644 index 0000000000000000000000000000000000000000..c10bf2b76ea032deabab6f5c9d8a3e1e884f1642 --- /dev/null +++ b/fairseq/scripts/sacrebleu.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +if [ $# -ne 4 ]; then + echo "usage: $0 TESTSET SRCLANG TGTLANG GEN" + exit 1 +fi + +TESTSET=$1 +SRCLANG=$2 +TGTLANG=$3 + +GEN=$4 + +if ! command -v sacremoses &> /dev/null +then + echo "sacremoses could not be found, please install with: pip install sacremoses" + exit +fi + +grep ^H $GEN \ +| sed 's/^H\-//' \ +| sort -n -k 1 \ +| cut -f 3 \ +| sacremoses detokenize \ +> $GEN.sorted.detok + +sacrebleu --test-set $TESTSET --language-pair "${SRCLANG}-${TGTLANG}" < $GEN.sorted.detok diff --git a/fairseq/scripts/shard_docs.py b/fairseq/scripts/shard_docs.py new file mode 100644 index 0000000000000000000000000000000000000000..97232c3c845ee01dc5ab627388934cc0f9588280 --- /dev/null +++ b/fairseq/scripts/shard_docs.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Split a large file into shards while respecting document boundaries. Documents +should be separated by a single empty line. +""" + +import argparse +import contextlib + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("input") + parser.add_argument("--num-shards", type=int) + args = parser.parse_args() + + assert args.num_shards is not None and args.num_shards > 1 + + with open(args.input, "r", encoding="utf-8") as h: + with contextlib.ExitStack() as stack: + outputs = [ + stack.enter_context( + open(args.input + ".shard" + str(i), "w", encoding="utf-8") + ) + for i in range(args.num_shards) + ] + + doc = [] + first_doc = [True] * args.num_shards + + def output_doc(i): + if not first_doc[i]: + outputs[i].write("\n") + first_doc[i] = False + for line in doc: + outputs[i].write(line) + doc.clear() + + num_docs = 0 + for line in h: + if line.strip() == "": # empty line indicates new document + output_doc(num_docs % args.num_shards) + num_docs += 1 + else: + doc.append(line) + output_doc(num_docs % args.num_shards) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/split_train_valid_docs.py b/fairseq/scripts/split_train_valid_docs.py new file mode 100644 index 0000000000000000000000000000000000000000..ff159785284a13b44626b207d84430c592acaf8f --- /dev/null +++ b/fairseq/scripts/split_train_valid_docs.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Split a large file into a train and valid set while respecting document +boundaries. Documents should be separated by a single empty line. +""" + +import argparse +import random +import sys + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("input") + parser.add_argument("sample_output", help="train output file") + parser.add_argument("remainder_output", help="valid output file") + parser.add_argument("-k", type=int, help="remainder size") + parser.add_argument( + "--lines", action="store_true", help="split lines instead of docs" + ) + args = parser.parse_args() + + assert args.k is not None + + sample = [] + remainder = [] + num_docs = [0] + + def update_sample(doc): + if len(sample) < args.k: + sample.append(doc.copy()) + else: + i = num_docs[0] + j = random.randrange(i + 1) + if j < args.k: + remainder.append(sample[j]) + sample[j] = doc.copy() + else: + remainder.append(doc.copy()) + num_docs[0] += 1 + doc.clear() + + with open(args.input, "r", encoding="utf-8") as h: + doc = [] + for i, line in enumerate(h): + if line.strip() == "": # empty line indicates new document + update_sample(doc) + else: + doc.append(line) + if args.lines: + update_sample(doc) + if i % 1000000 == 0: + print(i, file=sys.stderr, end="", flush=True) + elif i % 100000 == 0: + print(".", file=sys.stderr, end="", flush=True) + if len(doc) > 0: + update_sample(doc) + print(file=sys.stderr, flush=True) + + assert len(sample) == args.k + + with open(args.sample_output, "w", encoding="utf-8") as out: + first = True + for doc in sample: + if not first and not args.lines: + out.write("\n") + first = False + for line in doc: + out.write(line) + + with open(args.remainder_output, "w", encoding="utf-8") as out: + first = True + for doc in remainder: + if not first and not args.lines: + out.write("\n") + first = False + for line in doc: + out.write(line) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/spm_decode.py b/fairseq/scripts/spm_decode.py new file mode 100644 index 0000000000000000000000000000000000000000..1c18b1d2a7d7628b7aeb6fdb6c4ab5a096e9edf8 --- /dev/null +++ b/fairseq/scripts/spm_decode.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import argparse + +import sentencepiece as spm + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--model", required=True, help="sentencepiece model to use for decoding" + ) + parser.add_argument("--input", required=True, help="input file to decode") + parser.add_argument("--input_format", choices=["piece", "id"], default="piece") + args = parser.parse_args() + + sp = spm.SentencePieceProcessor() + sp.Load(args.model) + + if args.input_format == "piece": + + def decode(l): + return "".join(sp.DecodePieces(l)) + + elif args.input_format == "id": + + def decode(l): + return "".join(sp.DecodeIds(l)) + + else: + raise NotImplementedError + + def tok2int(tok): + # remap reference-side <unk> (represented as <<unk>>) to 0 + return int(tok) if tok != "<<unk>>" else 0 + + with open(args.input, "r", encoding="utf-8") as h: + for line in h: + if args.input_format == "id": + print(decode(list(map(tok2int, line.rstrip().split())))) + elif args.input_format == "piece": + print(decode(line.rstrip().split())) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/spm_encode.py b/fairseq/scripts/spm_encode.py new file mode 100644 index 0000000000000000000000000000000000000000..83facfb3b184aff8b9cc3f0c82dd53668c63e57b --- /dev/null +++ b/fairseq/scripts/spm_encode.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import argparse +import contextlib +import sys + +import sentencepiece as spm + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--model", required=True, help="sentencepiece model to use for encoding" + ) + parser.add_argument( + "--inputs", nargs="+", default=["-"], help="input files to filter/encode" + ) + parser.add_argument( + "--outputs", nargs="+", default=["-"], help="path to save encoded outputs" + ) + parser.add_argument("--output_format", choices=["piece", "id"], default="piece") + parser.add_argument( + "--min-len", + type=int, + metavar="N", + help="filter sentence pairs with fewer than N tokens", + ) + parser.add_argument( + "--max-len", + type=int, + metavar="N", + help="filter sentence pairs with more than N tokens", + ) + args = parser.parse_args() + + assert len(args.inputs) == len( + args.outputs + ), "number of input and output paths should match" + + sp = spm.SentencePieceProcessor() + sp.Load(args.model) + + if args.output_format == "piece": + + def encode(l): + return sp.EncodeAsPieces(l) + + elif args.output_format == "id": + + def encode(l): + return list(map(str, sp.EncodeAsIds(l))) + + else: + raise NotImplementedError + + if args.min_len is not None or args.max_len is not None: + + def valid(line): + return (args.min_len is None or len(line) >= args.min_len) and ( + args.max_len is None or len(line) <= args.max_len + ) + + else: + + def valid(lines): + return True + + with contextlib.ExitStack() as stack: + inputs = [ + stack.enter_context(open(input, "r", encoding="utf-8")) + if input != "-" + else sys.stdin + for input in args.inputs + ] + outputs = [ + stack.enter_context(open(output, "w", encoding="utf-8")) + if output != "-" + else sys.stdout + for output in args.outputs + ] + + stats = { + "num_empty": 0, + "num_filtered": 0, + } + + def encode_line(line): + line = line.strip() + if len(line) > 0: + line = encode(line) + if valid(line): + return line + else: + stats["num_filtered"] += 1 + else: + stats["num_empty"] += 1 + return None + + for i, lines in enumerate(zip(*inputs), start=1): + enc_lines = list(map(encode_line, lines)) + if not any(enc_line is None for enc_line in enc_lines): + for enc_line, output_h in zip(enc_lines, outputs): + print(" ".join(enc_line), file=output_h) + if i % 10000 == 0: + print("processed {} lines".format(i), file=sys.stderr) + + print("skipped {} empty lines".format(stats["num_empty"]), file=sys.stderr) + print("filtered {} lines".format(stats["num_filtered"]), file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/fairseq/scripts/spm_train.py b/fairseq/scripts/spm_train.py new file mode 100644 index 0000000000000000000000000000000000000000..9db668fd4166a860198784990de68ea26157995d --- /dev/null +++ b/fairseq/scripts/spm_train.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + +from __future__ import absolute_import, division, print_function, unicode_literals + +import sys + +import sentencepiece as spm + + +if __name__ == "__main__": + spm.SentencePieceTrainer.Train(" ".join(sys.argv[1:])) diff --git a/fairseq/scripts/test_fsdp.sh b/fairseq/scripts/test_fsdp.sh new file mode 100755 index 0000000000000000000000000000000000000000..1f428a035e4474427ded991f8e8307ea59f61f69 --- /dev/null +++ b/fairseq/scripts/test_fsdp.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +rm -rf fsdp_dummy +mkdir -p fsdp_dummy +CUDA_VISIBLE_DEVICES=0,1,2,3 fairseq-train /private/home/sshleifer/data-bin/stories_mmap \ + --ddp-backend fully_sharded --fp16 --fp16-init-scale 4 \ + --cpu-offload --checkpoint-activations \ + --task language_modeling --tokens-per-sample 256 --batch-size 8 \ + --arch transformer_lm_gpt2_tiny \ + --optimizer cpu_adam --adam-betas "(0.9,0.98)" \ + --lr 0.0001 --lr-scheduler polynomial_decay --warmup-updates 5 --total-num-update 10 \ + --max-update 5 --log-format json --log-interval 1 \ + --save-interval-updates 5 --save-dir fsdp_dummy --disable-validation \ + --restore-file x.pt "$@" + +# Now we try to load the checkpoint +CUDA_VISIBLE_DEVICES=0,1 fairseq-train /private/home/sshleifer/data-bin/stories_mmap \ + --ddp-backend fully_sharded --fp16 --fp16-init-scale 4 \ + --cpu-offload --checkpoint-activations \ + --task language_modeling --tokens-per-sample 256 --batch-size 8 \ + --arch transformer_lm_gpt2_tiny \ + --optimizer cpu_adam --adam-betas "(0.9,0.98)" \ + --lr 0.0001 --lr-scheduler polynomial_decay --warmup-updates 5 --total-num-update 10 \ + --max-update 2 --log-format json --log-interval 1 \ + --save-interval-updates 2 --save-dir fsdp_dummy diff --git a/fairseq/setup.py b/fairseq/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..4379b2c31f593134fb027cf01da5fcd706a64e00 --- /dev/null +++ b/fairseq/setup.py @@ -0,0 +1,284 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import subprocess +import sys + +from setuptools import Extension, find_packages, setup + +if sys.version_info < (3, 6): + sys.exit("Sorry, Python >= 3.6 is required for fairseq.") + + +def write_version_py(): + with open(os.path.join("fairseq", "version.txt")) as f: + version = f.read().strip() + + # append latest commit hash to version string + try: + sha = ( + subprocess.check_output(["git", "rev-parse", "HEAD"]) + .decode("ascii") + .strip() + ) + version += "+" + sha[:7] + except Exception: + pass + + # write version info to fairseq/version.py + with open(os.path.join("fairseq", "version.py"), "w") as f: + f.write('__version__ = "{}"\n'.format(version)) + return version + + +version = write_version_py() + + +with open("README.md") as f: + readme = f.read() + + +if sys.platform == "darwin": + extra_compile_args = ["-stdlib=libc++", "-O3"] +else: + extra_compile_args = ["-std=c++11", "-O3"] + + +class NumpyExtension(Extension): + """Source: https://stackoverflow.com/a/54128391""" + + def __init__(self, *args, **kwargs): + self.__include_dirs = [] + super().__init__(*args, **kwargs) + + @property + def include_dirs(self): + import numpy + + return self.__include_dirs + [numpy.get_include()] + + @include_dirs.setter + def include_dirs(self, dirs): + self.__include_dirs = dirs + + +extensions = [ + Extension( + "fairseq.libbleu", + sources=[ + "fairseq/clib/libbleu/libbleu.cpp", + "fairseq/clib/libbleu/module.cpp", + ], + extra_compile_args=extra_compile_args, + ), + NumpyExtension( + "fairseq.data.data_utils_fast", + sources=["fairseq/data/data_utils_fast.pyx"], + language="c++", + extra_compile_args=extra_compile_args, + ), + NumpyExtension( + "fairseq.data.token_block_utils_fast", + sources=["fairseq/data/token_block_utils_fast.pyx"], + language="c++", + extra_compile_args=extra_compile_args, + ), +] + + +cmdclass = {} + + +try: + # torch is not available when generating docs + from torch.utils import cpp_extension + + extensions.extend( + [ + cpp_extension.CppExtension( + "fairseq.libbase", + sources=[ + "fairseq/clib/libbase/balanced_assignment.cpp", + ], + ) + ] + ) + + extensions.extend( + [ + cpp_extension.CppExtension( + "fairseq.libnat", + sources=[ + "fairseq/clib/libnat/edit_dist.cpp", + ], + ), + cpp_extension.CppExtension( + "alignment_train_cpu_binding", + sources=[ + "examples/operators/alignment_train_cpu.cpp", + ], + ), + ] + ) + if "CUDA_HOME" in os.environ: + extensions.extend( + [ + cpp_extension.CppExtension( + "fairseq.libnat_cuda", + sources=[ + "fairseq/clib/libnat_cuda/edit_dist.cu", + "fairseq/clib/libnat_cuda/binding.cpp", + ], + ), + cpp_extension.CppExtension( + "fairseq.ngram_repeat_block_cuda", + sources=[ + "fairseq/clib/cuda/ngram_repeat_block_cuda.cpp", + "fairseq/clib/cuda/ngram_repeat_block_cuda_kernel.cu", + ], + ), + cpp_extension.CppExtension( + "alignment_train_cuda_binding", + sources=[ + "examples/operators/alignment_train_kernel.cu", + "examples/operators/alignment_train_cuda.cpp", + ], + ), + ] + ) + cmdclass["build_ext"] = cpp_extension.BuildExtension + +except ImportError: + pass + + +if "READTHEDOCS" in os.environ: + # don't build extensions when generating docs + extensions = [] + if "build_ext" in cmdclass: + del cmdclass["build_ext"] + + # use CPU build of PyTorch + dependency_links = [ + "https://download.pytorch.org/whl/cpu/torch-1.7.0%2Bcpu-cp36-cp36m-linux_x86_64.whl" + ] +else: + dependency_links = [] + + +if "clean" in sys.argv[1:]: + # Source: https://bit.ly/2NLVsgE + print("deleting Cython files...") + import subprocess + + subprocess.run( + ["rm -f fairseq/*.so fairseq/**/*.so fairseq/*.pyd fairseq/**/*.pyd"], + shell=True, + ) + + +extra_packages = [] +if os.path.exists(os.path.join("fairseq", "model_parallel", "megatron", "mpu")): + extra_packages.append("fairseq.model_parallel.megatron.mpu") + + +def do_setup(package_data): + setup( + name="fairseq", + version=version, + description="Facebook AI Research Sequence-to-Sequence Toolkit", + url="https://github.com/pytorch/fairseq", + classifiers=[ + "Intended Audience :: Science/Research", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Topic :: Scientific/Engineering :: Artificial Intelligence", + ], + long_description=readme, + long_description_content_type="text/markdown", + setup_requires=[ + "cython", + 'numpy<1.20.0; python_version<"3.7"', + 'numpy; python_version>="3.7"', + "setuptools>=18.0", + ], + install_requires=[ + "cffi", + "cython", + 'dataclasses; python_version<"3.7"', + "hydra-core>=1.0.7,<1.1", + "omegaconf<2.1", + 'numpy<1.20.0; python_version<"3.7"', + 'numpy; python_version>="3.7"', + "regex", + "sacrebleu>=1.4.12", + # "torch", + "tqdm", + "bitarray", + # "torchaudio>=0.8.0", + ], + dependency_links=dependency_links, + packages=find_packages( + exclude=[ + "examples", + "examples.*", + "scripts", + "scripts.*", + "tests", + "tests.*", + ] + ) + + extra_packages, + package_data=package_data, + ext_modules=extensions, + test_suite="tests", + entry_points={ + "console_scripts": [ + "fairseq-eval-lm = fairseq_cli.eval_lm:cli_main", + "fairseq-generate = fairseq_cli.generate:cli_main", + "fairseq-hydra-train = fairseq_cli.hydra_train:cli_main", + "fairseq-interactive = fairseq_cli.interactive:cli_main", + "fairseq-preprocess = fairseq_cli.preprocess:cli_main", + "fairseq-score = fairseq_cli.score:cli_main", + "fairseq-train = fairseq_cli.train:cli_main", + "fairseq-validate = fairseq_cli.validate:cli_main", + ], + }, + cmdclass=cmdclass, + zip_safe=False, + ) + + +def get_files(path, relative_to="fairseq"): + all_files = [] + for root, _dirs, files in os.walk(path, followlinks=True): + root = os.path.relpath(root, relative_to) + for file in files: + if file.endswith(".pyc"): + continue + all_files.append(os.path.join(root, file)) + return all_files + + +if __name__ == "__main__": + try: + # symlink examples into fairseq package so package_data accepts them + fairseq_examples = os.path.join("fairseq", "examples") + if "build_ext" not in sys.argv[1:] and not os.path.exists(fairseq_examples): + os.symlink(os.path.join("..", "examples"), fairseq_examples) + + package_data = { + "fairseq": ( + get_files(fairseq_examples) + get_files(os.path.join("fairseq", "config")) + ) + } + do_setup(package_data) + finally: + if "build_ext" not in sys.argv[1:] and os.path.islink(fairseq_examples): + os.unlink(fairseq_examples) diff --git a/fairseq/tests/__init__.py b/fairseq/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/tests/distributed/__init__.py b/fairseq/tests/distributed/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/tests/distributed/test_bmuf.py b/fairseq/tests/distributed/test_bmuf.py new file mode 100644 index 0000000000000000000000000000000000000000..8b7cadb094d49587b6b82432248459fdcf42457e --- /dev/null +++ b/fairseq/tests/distributed/test_bmuf.py @@ -0,0 +1,207 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import functools +import random +import unittest +from multiprocessing import Manager + +import torch +import torch.nn as nn +from fairseq import optim +from fairseq.distributed import utils as distributed_utils +from omegaconf import OmegaConf + + +class Model(nn.Module): + def __init__(self, input_size, output_size): + super(Model, self).__init__() + self.fc = nn.Linear(input_size, output_size) + + def forward(self, input): + output = self.fc(input) + return output + + +def setup_model_loss_criterion(cfg, args, rank, is_cuda): + """ + setup model, criterion and optimizer based on input args + """ + args.distributed_rank = rank + cfg.distributed_training.distributed_rank = args.distributed_rank + if cfg.distributed_training.distributed_world_size > 1: + distributed_utils.distributed_init(cfg) + torch.manual_seed(1) + model = Model(args.input_size, args.nb_classes) + loss_fn = nn.CrossEntropyLoss() + if is_cuda: + model = model.cuda() + loss_fn = loss_fn.cuda() + + optimizer = optim.sgd.SGD(args, model.parameters()) + optimizer = optim.FairseqBMUF( + cfg=cfg.bmuf, + optimizer=optimizer + ) + + return model, loss_fn, optimizer + + +def train_step(input, target, model, loss_fn, optimizer, **unused): + """Do forward, backward and parameter update.""" + model.train() + output = model(input) + loss = loss_fn(output, target) + optimizer.backward(loss) + optimizer.step() + + +def single_gpu_training(cfg, args, rank, iterations, shared_results): + + is_cuda = torch.cuda.is_available() + if is_cuda: + torch.cuda.set_device(rank) + + model, loss_fn, optimizer = setup_model_loss_criterion(cfg, args, rank, is_cuda) + + for _ in range(iterations): + input = torch.randn(1, args.input_size) + target = torch.empty(args.batch_size, dtype=torch.long).random_(args.nb_classes) + + if is_cuda: + input = input.cuda() + target = target.cuda() + train_step(input, target, model, loss_fn, optimizer) + + results = [] + for param in model.parameters(): + if len(results) == 0: + results = param.flatten().cpu().data + else: + results = torch.cat((results, param.flatten().cpu().data), 0) + + shared_results[rank] = results + + +def setup_args(): + args = argparse.Namespace() + args.global_sync_iter = 20 + args.block_momentum = 0.875 + args.block_lr = 0.5 + args.input_size = 5 + args.nb_classes = 2 + args.batch_size = 1 + args.lr = [1e-3] + args.momentum = 0 + args.weight_decay = 0 + args.warmup_iterations = 0 + args.use_nbm = True + args.average_sync = True + args.global_sync_iter = 1 + args.model_parallel_size = 1 + args.distributed_backend = "gloo" + + args.distributed_world_size = 2 + port = random.randint(10000, 20000) + args.distributed_init_method = "tcp://localhost:{port}".format(port=port) + args.distributed_init_host = "localhost" + args.distributed_port = port + 1 + args.local_world_size = args.distributed_world_size + + cfg = OmegaConf.create() + cfg.optimization = OmegaConf.create() + cfg.common = OmegaConf.create() + cfg.distributed_training = OmegaConf.create() + cfg.dataset = OmegaConf.create() + cfg.bmuf = OmegaConf.create() + cfg.optimizer = OmegaConf.create() + + cfg.bmuf.global_sync_iter = args.global_sync_iter + cfg.bmuf.block_momentum = args.block_momentum + cfg.bmuf.block_lr = args.block_lr + cfg.dataset.batch_size = args.batch_size + cfg.optimization.lr = args.lr + cfg.optimizer.momentum = args.momentum + cfg.optimizer.weight_decay = args.weight_decay + cfg.bmuf.warmup_iterations = args.warmup_iterations + cfg.bmuf.use_nbm = args.use_nbm + cfg.bmuf.average_sync = args.average_sync + cfg.common.model_parallel_size = args.model_parallel_size + cfg.distributed_training.distributed_backend = args.distributed_backend + cfg.distributed_training.distributed_world_size = args.distributed_world_size + cfg.bmuf.distributed_world_size = args.distributed_world_size + cfg.distributed_training.distributed_init_method = args.distributed_init_method + cfg.distributed_training.distributed_port = args.distributed_port + + return cfg, args + + +@unittest.skipIf(torch.cuda.device_count() < 2, "test requires 2 GPUs") +class TestBMUF(unittest.TestCase): + def bmuf_process(self, cfg, args, iterations): + processes = [] + results = Manager().dict() + torch.multiprocessing.spawn( + fn=functools.partial(single_gpu_training, cfg, args), + args=(iterations, results), + nprocs=args.distributed_world_size, + join=True, + ) + return results + + def test_bmuf_sync(self): + # Train model for 1 iteration and do bmuf sync without doing warmup + cfg, args = setup_args() + iterations = 1 + results = self.bmuf_process(cfg, args, iterations) + # Make sure params in both machines are same + assert len(results) == 2 + self.assertAlmostEqual(results[0], results[1]) + + def test_warmup_sync(self): + # Train model for 20 iteration and do warmup sync without doing bmuf sync + cfg, args = setup_args() + args.warmup_iterations = 20 + cfg.bmuf.warmup_iterations = args.warmup_iterations + iterations = 20 + results = self.bmuf_process(cfg, args, iterations) + # Make sure params in both machines are same + assert len(results) == 2 + self.assertAlmostEqual(results[0], results[1]) + + def test_warmup_sync_bmuf_sync(self): + # Train model for 25 iteration and do warmup sync after 20 iteration + # and bmuf sync after 25 iteration + cfg, args = setup_args() + args.warmup_iterations = 20 + args.global_sync_iter = 5 + cfg.bmuf.warmup_iterations = args.warmup_iterations + cfg.bmuf.global_sync_iter = args.global_sync_iter + iterations = 25 + results = self.bmuf_process(cfg, args, iterations) + # Make sure params in both machines are same + assert len(results) == 2 + self.assertAlmostEqual(results[0], results[1]) + + def test_single_gpu_bmuf(self): + # Train model for 5 iterations and use GPU 1 + cfg, args = setup_args() + args.distributed_world_size = 1 + args.warmup_iterations = 5 + cfg.distributed_training.distributed_world_size = args.distributed_world_size + cfg.bmuf.distributed_world_size = args.distributed_world_size + cfg.bmuf.warmup_iterations = args.warmup_iterations + iterations = 20 + results = self.bmuf_process(cfg, args, iterations) + assert len(results) == 1 + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-4) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/distributed/test_distributed_timeout_wrapper.py b/fairseq/tests/distributed/test_distributed_timeout_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..27908b9d3f7d6d880351e2a12effb12f9bc27971 --- /dev/null +++ b/fairseq/tests/distributed/test_distributed_timeout_wrapper.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import signal +import time +import unittest + +import torch +from torch import nn + +from fairseq.distributed import DistributedTimeoutWrapper + + +class ModuleWithDelay(nn.Module): + + def __init__(self, delay): + super().__init__() + self.delay = delay + + def forward(self, x): + time.sleep(self.delay) + return x + + +class TestDistributedTimeoutWrapper(unittest.TestCase): + + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_no_timeout(self): + module = DistributedTimeoutWrapper(ModuleWithDelay(1), 0, signal.SIGINT) + module(torch.rand(5)) + module.stop_timeout() + + def test_timeout_safe(self): + module = DistributedTimeoutWrapper(ModuleWithDelay(1), 10, signal.SIGINT) + module(torch.rand(5)) + module.stop_timeout() + + def test_timeout_killed(self): + with self.assertRaises(KeyboardInterrupt): + module = DistributedTimeoutWrapper(ModuleWithDelay(5), 1, signal.SIGINT) + module(torch.rand(5)) + module.stop_timeout() + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/distributed/test_module_proxy_wrapper.py b/fairseq/tests/distributed/test_module_proxy_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..2803a044cdcc12e0a348f40d06ce89c571d307ed --- /dev/null +++ b/fairseq/tests/distributed/test_module_proxy_wrapper.py @@ -0,0 +1,75 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from torch import nn + +from fairseq.distributed import ModuleProxyWrapper + +from .utils import objects_are_equal + + +class MockDDPWrapper(nn.Module): + """A simple wrapper with an interface similar to DistributedDataParallel.""" + + def __init__(self, module): + super().__init__() + self.module = module + + def forward(self, x): + return self.module(x) + + +class Model(nn.Module): + def __init__(self): + super().__init__() + self.linear = nn.Linear(5, 10) + self.xyz = "hello" + + def forward(self, x): + return self.linear(x) + + def get_xyz(self): + return self.xyz + + +class TestModuleProxyWrapper(unittest.TestCase): + + def _get_module(self): + module = Model() + wrapped_module = MockDDPWrapper(module) + wrapped_module = ModuleProxyWrapper(wrapped_module) + return wrapped_module, module + + def test_getattr_forwarding(self): + wrapped_module, module = self._get_module() + assert module.xyz == "hello" + assert module.get_xyz() == "hello" + assert wrapped_module.xyz == "hello" + + wrapped_module.xyz = "world" + assert wrapped_module.xyz == "world" + assert module.get_xyz() == "hello" + + def test_state_dict(self): + wrapped_module, module = self._get_module() + assert objects_are_equal(wrapped_module.state_dict(), module.state_dict()) + + def test_load_state_dict(self): + wrapped_module, module = self._get_module() + wrapped_module.load_state_dict(module.state_dict()) + input = torch.rand(4, 5) + torch.testing.assert_allclose(wrapped_module(input), module(input)) + + def test_forward(self): + wrapped_module, module = self._get_module() + input = torch.rand(4, 5) + torch.testing.assert_allclose(wrapped_module(input), module(input)) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/distributed/test_utils.py b/fairseq/tests/distributed/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..30f995b67acd39af5816d2eb412d6b4df7f44f8c --- /dev/null +++ b/fairseq/tests/distributed/test_utils.py @@ -0,0 +1,124 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import functools +import sys +import unittest + +import torch + +from fairseq.distributed import utils as dist_utils + +from .utils import objects_are_equal, spawn_and_init + + +class DistributedTest(unittest.TestCase): + def setUp(self): + if not torch.cuda.is_available(): + raise unittest.SkipTest("CUDA not available, skipping test") + if sys.platform == "win32": + raise unittest.SkipTest("NCCL doesn't support Windows, skipping test") + if torch.cuda.device_count() < 2: + raise unittest.SkipTest("distributed tests require 2+ GPUs, skipping") + + +class TestBroadcastObject(DistributedTest): + def test_str(self): + spawn_and_init( + functools.partial( + TestBroadcastObject._test_broadcast_object, "hello world" + ), + world_size=2, + ) + + def test_tensor(self): + spawn_and_init( + functools.partial( + TestBroadcastObject._test_broadcast_object, + torch.rand(5), + ), + world_size=2, + ) + + def test_complex(self): + spawn_and_init( + functools.partial( + TestBroadcastObject._test_broadcast_object, + { + "a": "1", + "b": [2, torch.rand(2, 3), 3], + "c": (torch.rand(2, 3), 4), + "d": {5, torch.rand(5)}, + "e": torch.rand(5), + "f": torch.rand(5).int().cuda(), + }, + ), + world_size=2, + ) + + @staticmethod + def _test_broadcast_object(ref_obj, rank, group): + obj = dist_utils.broadcast_object( + ref_obj if rank == 0 else None, src_rank=0, group=group + ) + assert objects_are_equal(ref_obj, obj) + + +class TestAllGatherList(DistributedTest): + def test_str_equality(self): + spawn_and_init( + functools.partial( + TestAllGatherList._test_all_gather_list_equality, + "hello world", + ), + world_size=2, + ) + + def test_tensor_equality(self): + spawn_and_init( + functools.partial( + TestAllGatherList._test_all_gather_list_equality, + torch.rand(5), + ), + world_size=2, + ) + + def test_complex_equality(self): + spawn_and_init( + functools.partial( + TestAllGatherList._test_all_gather_list_equality, + { + "a": "1", + "b": [2, torch.rand(2, 3), 3], + "c": (torch.rand(2, 3), 4), + "d": {5, torch.rand(5)}, + "e": torch.rand(5), + "f": torch.rand(5).int(), + }, + ), + world_size=2, + ) + + @staticmethod + def _test_all_gather_list_equality(ref_obj, rank, group): + objs = dist_utils.all_gather_list(ref_obj, group) + for obj in objs: + assert objects_are_equal(ref_obj, obj) + + def test_rank_tensor(self): + spawn_and_init( + TestAllGatherList._test_all_gather_list_rank_tensor, world_size=2 + ) + + @staticmethod + def _test_all_gather_list_rank_tensor(rank, group): + obj = torch.tensor([rank]) + objs = dist_utils.all_gather_list(obj, group) + for i, obj in enumerate(objs): + assert obj.item() == i + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/distributed/utils.py b/fairseq/tests/distributed/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c8040392a8e27eb4c3a74032c702643a91d11a3e --- /dev/null +++ b/fairseq/tests/distributed/utils.py @@ -0,0 +1,62 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import functools +import tempfile + +import torch + + +def spawn_and_init(fn, world_size, args=None): + if args is None: + args = () + with tempfile.NamedTemporaryFile(delete=False) as tmp_file: + torch.multiprocessing.spawn( + fn=functools.partial(init_and_run, fn, args), + args=(world_size, tmp_file.name,), + nprocs=world_size, + join=True, + ) + + +def distributed_init(rank, world_size, tmp_file): + torch.distributed.init_process_group( + backend="nccl", + init_method="file://{}".format(tmp_file), + world_size=world_size, + rank=rank, + ) + torch.cuda.set_device(rank) + + +def init_and_run(fn, args, rank, world_size, tmp_file): + distributed_init(rank, world_size, tmp_file) + group = torch.distributed.new_group() + fn(rank, group, *args) + + +def objects_are_equal(a, b) -> bool: + if type(a) is not type(b): + return False + if isinstance(a, dict): + if set(a.keys()) != set(b.keys()): + return False + for k in a.keys(): + if not objects_are_equal(a[k], b[k]): + return False + return True + elif isinstance(a, (list, tuple, set)): + if len(a) != len(b): + return False + return all(objects_are_equal(x, y) for x, y in zip(a, b)) + elif torch.is_tensor(a): + return ( + a.size() == b.size() + and a.dtype == b.dtype + and a.device == b.device + and torch.all(a == b) + ) + else: + return a == b diff --git a/fairseq/tests/gpu/__init__.py b/fairseq/tests/gpu/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/tests/gpu/test_binaries_gpu.py b/fairseq/tests/gpu/test_binaries_gpu.py new file mode 100644 index 0000000000000000000000000000000000000000..de8c2426134089035c6e0e5da223647bab6f3dba --- /dev/null +++ b/fairseq/tests/gpu/test_binaries_gpu.py @@ -0,0 +1,449 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import logging +import json +import os +import tempfile +import unittest +from io import StringIO + +import torch +from fairseq import options +from fairseq_cli import train +from tests.utils import ( + create_dummy_data, + generate_main, + preprocess_lm_data, + preprocess_translation_data, + train_translation_model, +) + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestTranslationGPU(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_fp16_multigpu(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fp16") as data_dir: + log = os.path.join(data_dir, "train.log") + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + ["--fp16", "--log-file", log], + world_size=min(torch.cuda.device_count(), 2), + ) + generate_main(data_dir) + assert os.path.exists(log) + + @staticmethod + def parse_logs(logfile): + logs = [] + for ln in open(logfile, "r").readlines(): + try: + logs.append(json.loads(ln)) + except json.JSONDecodeError: + continue + return logs + + def test_resume_training_fsdp(self): + self._test_resume_training(["--ddp-backend", "fully_sharded"]) + + def test_resume_training_fsdp_sharded_state(self): + self._test_resume_training(["--ddp-backend", "fully_sharded", "--use-sharded-state"]) + + def test_resume_training_noc10d(self): + self._test_resume_training([]) + + def _test_resume_training(self, extra_clargs, arch="fconv_iwslt_de_en"): + flags = [ + "--fp16", + "--log-format", + "json", + "--max-update", + "10", + "--save-interval-updates", + "2", + "--log-interval", + "1", + ] + extra_clargs + world_size = min(torch.cuda.device_count(), 2) + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fp16") as data_dir: + log = os.path.join(data_dir, "train.log") + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, arch, flags + ["--log-file", log], world_size=world_size, + ) + log2 = os.path.join(data_dir, "resume.log") + restore_file = os.path.join(data_dir, "checkpoint_1_2.pt") + train_translation_model( + data_dir, + arch, + flags + ["--log-file", log2, "--restore-file", restore_file], + world_size=world_size, + ) + + l1 = self.parse_logs(log) + l2 = self.parse_logs(log2) + assert int(l2[0]["num_updates"]) == 3, f"{l1}\n\n {l2}" + for k in [ + "train_loss", + "train_num_updates", + "train_ppl", + "train_gnorm", + ]: + from_scratch, resumed = l1[-1][k], l2[-1][k] + assert ( + from_scratch == resumed + ), f"difference at {k} {from_scratch} != {resumed}" + + def test_memory_efficient_fp16(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_memory_efficient_fp16") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, "fconv_iwslt_de_en", ["--memory-efficient-fp16"] + ) + generate_main(data_dir) + + def test_transformer_fp16(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "64", + "--decoder-embed-dim", + "64", + "--fp16", + ], + run_validation=True, + ) + generate_main(data_dir) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_amp(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_amp") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model(data_dir, "fconv_iwslt_de_en", ["--amp"]) + generate_main(data_dir) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_transformer_amp(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "64", + "--decoder-embed-dim", + "64", + "--amp", + ], + run_validation=True, + ) + generate_main(data_dir) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_levenshtein_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_levenshtein_transformer" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--joined-dictionary"]) + train_translation_model( + data_dir, + "levenshtein_transformer", + [ + "--apply-bert-init", + "--early-exit", + "6,6,6", + "--criterion", + "nat_loss", + ], + task="translation_lev", + ) + gen_config = [ + "--task", + "translation_lev", + "--iter-decode-max-iter", + "9", + "--iter-decode-eos-penalty", + "0", + "--print-step", + ] + # non-ensemble generation + generate_main(data_dir, gen_config) + # ensemble generation + generate_main( + data_dir, + gen_config, + path=os.pathsep.join( + [ + os.path.join(data_dir, "checkpoint_last.pt"), + os.path.join(data_dir, "checkpoint_last.pt"), + ] + ), + ) + + def test_fsdp_checkpoint_generate(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fsdp_sharded") as data_dir: + log = os.path.join(data_dir, "train.log") + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + world_size = min(torch.cuda.device_count(), 2) + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + ["--log-file", log, "--ddp-backend", "fully_sharded"], + world_size=world_size, + ) + generate_main(data_dir) + assert os.path.exists(log) + + def test_fsdp_sharded_checkpoint_generate(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fsdp_sharded") as data_dir: + log = os.path.join(data_dir, "train.log") + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + world_size = min(torch.cuda.device_count(), 2) + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + ["--log-file", log, "--ddp-backend", "fully_sharded", "--use-sharded-state"], + world_size=world_size, + ) + generate_main(data_dir, ["--checkpoint-shard-count", str(world_size)]) + assert os.path.exists(log) + + +def _quantize_language_model(data_dir, arch, extra_flags=None, run_validation=False): + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + "language_modeling", + data_dir, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--criterion", + "adaptive_loss", + "--adaptive-softmax-cutoff", + "5,10,15", + "--max-tokens", + "500", + "--tokens-per-sample", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + train.main(train_args) + + # try scalar quantization + scalar_quant_train_parser = options.get_training_parser() + scalar_quant_train_args = options.parse_args_and_arch( + scalar_quant_train_parser, + [ + "--task", + "language_modeling", + data_dir, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--criterion", + "adaptive_loss", + "--adaptive-softmax-cutoff", + "5,10,15", + "--max-tokens", + "500", + "--tokens-per-sample", + "500", + "--save-dir", + data_dir, + "--max-update", + "3", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + "--quant-noise-scalar", + "0.5", + ] + + (extra_flags or []), + ) + train.main(scalar_quant_train_args) + + # try iterative PQ quantization + quantize_parser = options.get_training_parser() + quantize_args = options.parse_args_and_arch( + quantize_parser, + [ + "--task", + "language_modeling", + data_dir, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--criterion", + "adaptive_loss", + "--adaptive-softmax-cutoff", + "5,10,15", + "--max-tokens", + "50", + "--tokens-per-sample", + "50", + "--max-update", + "6", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + "--restore-file", + os.path.join(data_dir, "checkpoint_last.pt"), + "--reset-optimizer", + "--quantization-config-path", + os.path.join( + os.path.dirname(__file__), "transformer_quantization_config.yaml" + ), + ] + + (extra_flags or []), + ) + train.main(quantize_args) + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestQuantization(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_quantization(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_quantization") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + # tests both scalar and iterative PQ quantization + _quantize_language_model(data_dir, "transformer_lm") + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestOptimizersGPU(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_flat_grads(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_flat_grads") as data_dir: + # Use just a bit of data and tiny model to keep this test runtime reasonable + create_dummy_data(data_dir, num_examples=10, maxlen=5) + preprocess_translation_data(data_dir) + with self.assertRaises(RuntimeError): + # adafactor isn't compatible with flat grads, which + # are used by default with --fp16 + train_translation_model( + data_dir, + "lstm", + [ + "--required-batch-size-multiple", + "1", + "--encoder-layers", + "1", + "--encoder-hidden-size", + "32", + "--decoder-layers", + "1", + "--optimizer", + "adafactor", + "--fp16", + ], + ) + # but it should pass once we set --fp16-no-flatten-grads + train_translation_model( + data_dir, + "lstm", + [ + "--required-batch-size-multiple", + "1", + "--encoder-layers", + "1", + "--encoder-hidden-size", + "32", + "--decoder-layers", + "1", + "--optimizer", + "adafactor", + "--fp16", + "--fp16-no-flatten-grads", + ], + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/gpu/test_ema_gpu.py b/fairseq/tests/gpu/test_ema_gpu.py new file mode 100644 index 0000000000000000000000000000000000000000..337107d69a2626652d1f34321a555dde02b3c1a9 --- /dev/null +++ b/fairseq/tests/gpu/test_ema_gpu.py @@ -0,0 +1,200 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from copy import deepcopy +from dataclasses import dataclass +from typing import Optional + +import torch +from fairseq.models.ema import EMA + + +class DummyModule(torch.nn.Module): + def __init__(self) -> None: + """LightningModule for testing purposes + + Args: + epoch_min_loss_override (int, optional): Pass in an epoch that will be set to the minimum + validation loss for testing purposes (zero based). If None this is ignored. Defaults to None. + """ + super().__init__() + self.layer = torch.nn.Linear(in_features=32, out_features=2) + self.another_layer = torch.nn.Linear(in_features=2, out_features=2) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.layer(x) + return self.another_layer(x) + + +@dataclass +class EMAConfig(object): + ema_decay: float = 0.99 + ema_start_update: int = 0 + ema_fp32: bool = False + ema_seed_model: Optional[str] = None + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestEMAGPU(unittest.TestCase): + def assertTorchAllClose(self, x, y, atol=1e-8, rtol=1e-5, msg=None): + diff = x.float() - y.float() + diff_norm = torch.norm(diff) + other_norm = torch.norm(y.float()) + + if msg is None: + msg = "|input - other| > {} + {} * |other|".format( + atol, rtol + ) + + self.assertLessEqual( + diff_norm, + atol + rtol * other_norm, + msg=msg, + ) + + def test_ema(self): + model = DummyModule().cuda() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig() + ema = EMA(model, config) + + # set decay + ema._set_decay(config.ema_decay) + self.assertEqual(ema.get_decay(), config.ema_decay) + + # get model + self.assertEqual(ema.get_model(), ema.model) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + # EMA step + x = torch.randn(32).cuda() + y = model(x) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + ema_state_dict = ema.get_model().state_dict() + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema_state_dict[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + self.assertTorchAllClose( + ema_param, + config.ema_decay * prev_param + (1 - config.ema_decay) * param, + ) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + # Load EMA into model + model2 = DummyModule().cuda() + ema.reverse(model2) + + for key, param in model2.state_dict().items(): + ema_param = ema_state_dict[key] + self.assertTrue( + torch.allclose(ema_param, param) + ) + + def test_ema_fp32(self): + model = DummyModule().cuda().half() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig(ema_fp32=True) + ema = EMA(model, config) + + x = torch.randn(32).cuda() + y = model(x.half()) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema.get_model().state_dict()[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + self.assertIn(key, ema.fp32_params) + + # EMA update is done in fp32, and hence the EMA param must be + # closer to the EMA update done in fp32 than in fp16. + self.assertLessEqual( + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half().float() + ), + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param + (1 - config.ema_decay) * param).float() + ), + ) + self.assertTorchAllClose( + ema_param, + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half(), + ) + + def test_ema_fp16(self): + model = DummyModule().cuda().half() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig(ema_fp32=False) + ema = EMA(model, config) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + x = torch.randn(32).cuda() + y = model(x.half()) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema.get_model().state_dict()[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + + # EMA update is done in fp16, and hence the EMA param must be + # closer to the EMA update done in fp16 than in fp32. + self.assertLessEqual( + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param + (1 - config.ema_decay) * param).float() + ), + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half().float() + ), + ) + self.assertTorchAllClose( + ema_param, + config.ema_decay * prev_param + (1 - config.ema_decay) * param, + ) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/gpu/transformer_quantization_config.yaml b/fairseq/tests/gpu/transformer_quantization_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..de31d8116ced675b81eb74119642217d768e7736 --- /dev/null +++ b/fairseq/tests/gpu/transformer_quantization_config.yaml @@ -0,0 +1,28 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +# This file defines example configuration arguments for quantizing +# a transformer model with product quantization + +n_centroids: + Linear: + key: in_features + value: {"*": 8} + Embedding: + key: embedding_dim + value: {"*": 8} + +block_sizes: + Linear: + key: fuzzy_name + value: {fc: 8, attn: 4, emb: 4} + Embedding: + key: fuzzy_name + value: {emb: 8} + +layers_to_quantize: + - decoder\\.layers\\.\d+\\.fc[12] + - decoder\\.embed_tokens\\.embeddings\\.[012]\\.[01] + - decoder\\.layers\\.\d+\\.self_attn\\.(k_proj|v_proj|q_proj|out_proj) diff --git a/fairseq/tests/speech_recognition/__init__.py b/fairseq/tests/speech_recognition/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/fairseq/tests/speech_recognition/asr_test_base.py b/fairseq/tests/speech_recognition/asr_test_base.py new file mode 100644 index 0000000000000000000000000000000000000000..8c5d414e7bf17ee02f280d024fa5d07e28b79d6b --- /dev/null +++ b/fairseq/tests/speech_recognition/asr_test_base.py @@ -0,0 +1,557 @@ +#!/usr/bin/env python3 + +import argparse +import os +import unittest +from inspect import currentframe, getframeinfo + +import numpy as np +import torch +from examples.speech_recognition.data.data_utils import lengths_to_encoder_padding_mask +from fairseq.data import data_utils as fairseq_data_utils +from fairseq.data.dictionary import Dictionary +from fairseq.models import ( + BaseFairseqModel, + FairseqDecoder, + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqEncoderModel, + FairseqModel, +) +from fairseq.tasks.fairseq_task import LegacyFairseqTask + + +DEFAULT_TEST_VOCAB_SIZE = 100 + + +# /////////////////////////////////////////////////////////////////////////// +# utility function to setup dummy dict/task/input +# /////////////////////////////////////////////////////////////////////////// + + +def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE): + dummy_dict = Dictionary() + # add dummy symbol to satisfy vocab size + for id, _ in enumerate(range(vocab_size)): + dummy_dict.add_symbol("{}".format(id), 1000) + return dummy_dict + + +class DummyTask(LegacyFairseqTask): + def __init__(self, args): + super().__init__(args) + self.dictionary = get_dummy_dictionary() + if getattr(self.args, "ctc", False): + self.dictionary.add_symbol("<ctc_blank>") + self.tgt_dict = self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + +def get_dummy_task_and_parser(): + """ + to build a fariseq model, we need some dummy parse and task. This function + is used to create dummy task and parser to faciliate model/criterion test + + Note: we use FbSpeechRecognitionTask as the dummy task. You may want + to use other task by providing another function + """ + parser = argparse.ArgumentParser( + description="test_dummy_s2s_task", argument_default=argparse.SUPPRESS + ) + DummyTask.add_args(parser) + args = parser.parse_args([]) + task = DummyTask.setup_task(args) + return task, parser + + +def get_dummy_input(T=100, D=80, B=5, K=100): + forward_input = {} + # T max sequence length + # D feature vector dimension + # B batch size + # K target dimension size + feature = torch.randn(B, T, D) + # this (B, T, D) layout is just a convention, you can override it by + # write your own _prepare_forward_input function + src_lengths = torch.from_numpy( + np.random.randint(low=1, high=T, size=B, dtype=np.int64) + ) + src_lengths[0] = T # make sure the maximum length matches + prev_output_tokens = [] + for b in range(B): + token_length = np.random.randint(low=1, high=src_lengths[b].item() + 1) + tokens = np.random.randint(low=0, high=K, size=token_length, dtype=np.int64) + prev_output_tokens.append(torch.from_numpy(tokens)) + + prev_output_tokens = fairseq_data_utils.collate_tokens( + prev_output_tokens, + pad_idx=1, + eos_idx=2, + left_pad=False, + move_eos_to_beginning=False, + ) + src_lengths, sorted_order = src_lengths.sort(descending=True) + forward_input["src_tokens"] = feature.index_select(0, sorted_order) + forward_input["src_lengths"] = src_lengths + forward_input["prev_output_tokens"] = prev_output_tokens + + return forward_input + + +def get_dummy_encoder_output(encoder_out_shape=(100, 80, 5)): + """ + This only provides an example to generate dummy encoder output + """ + (T, B, D) = encoder_out_shape + encoder_out = {} + + encoder_out["encoder_out"] = torch.from_numpy( + np.random.randn(*encoder_out_shape).astype(np.float32) + ) + seq_lengths = torch.from_numpy(np.random.randint(low=1, high=T, size=B)) + # some dummy mask + encoder_out["encoder_padding_mask"] = torch.arange(T).view(1, T).expand( + B, -1 + ) >= seq_lengths.view(B, 1).expand(-1, T) + encoder_out["encoder_padding_mask"].t_() + + # encoer_padding_mask is (T, B) tensor, with (t, b)-th element indicate + # whether encoder_out[t, b] is valid (=0) or not (=1) + return encoder_out + + +def _current_postion_info(): + cf = currentframe() + frameinfo = " (at {}:{})".format( + os.path.basename(getframeinfo(cf).filename), cf.f_back.f_lineno + ) + return frameinfo + + +def check_encoder_output(encoder_output, batch_size=None): + """we expect encoder_output to be a dict with the following + key/value pairs: + - encoder_out: a Torch.Tensor + - encoder_padding_mask: a binary Torch.Tensor + """ + if not isinstance(encoder_output, dict): + msg = ( + "FairseqEncoderModel.forward(...) must be a dict" + _current_postion_info() + ) + return False, msg + + if "encoder_out" not in encoder_output: + msg = ( + "FairseqEncoderModel.forward(...) must contain encoder_out" + + _current_postion_info() + ) + return False, msg + + if "encoder_padding_mask" not in encoder_output: + msg = ( + "FairseqEncoderModel.forward(...) must contain encoder_padding_mask" + + _current_postion_info() + ) + return False, msg + + if not isinstance(encoder_output["encoder_out"], torch.Tensor): + msg = "encoder_out must be a torch.Tensor" + _current_postion_info() + return False, msg + + if encoder_output["encoder_out"].dtype != torch.float32: + msg = "encoder_out must have float32 dtype" + _current_postion_info() + return False, msg + + mask = encoder_output["encoder_padding_mask"] + if mask is not None: + if not isinstance(mask, torch.Tensor): + msg = ( + "encoder_padding_mask must be a torch.Tensor" + _current_postion_info() + ) + return False, msg + if mask.dtype != torch.uint8 and ( + not hasattr(torch, "bool") or mask.dtype != torch.bool + ): + msg = ( + "encoder_padding_mask must have dtype of uint8" + + _current_postion_info() + ) + return False, msg + + if mask.dim() != 2: + msg = ( + "we expect encoder_padding_mask to be a 2-d tensor, in shape (T, B)" + + _current_postion_info() + ) + return False, msg + + if batch_size is not None and mask.size(1) != batch_size: + msg = ( + "we expect encoder_padding_mask to be a 2-d tensor, with size(1)" + + " being the batch size" + + _current_postion_info() + ) + return False, msg + return True, None + + +def check_decoder_output(decoder_output): + """we expect output from a decoder is a tuple with the following constraint: + - the first element is a torch.Tensor + - the second element can be anything (reserved for future use) + """ + if not isinstance(decoder_output, tuple): + msg = "FariseqDecoder output must be a tuple" + _current_postion_info() + return False, msg + + if len(decoder_output) != 2: + msg = "FairseqDecoder output must be 2-elem tuple" + _current_postion_info() + return False, msg + + if not isinstance(decoder_output[0], torch.Tensor): + msg = ( + "FariseqDecoder output[0] must be a torch.Tensor" + _current_postion_info() + ) + return False, msg + + return True, None + + +# /////////////////////////////////////////////////////////////////////////// +# Base Test class +# /////////////////////////////////////////////////////////////////////////// + + +class TestBaseFairseqModelBase(unittest.TestCase): + """ + This class is used to facilitate writing unittest for any class derived from + `BaseFairseqModel`. + """ + + @classmethod + def setUpClass(cls): + if cls is TestBaseFairseqModelBase: + raise unittest.SkipTest("Skipping test case in base") + super().setUpClass() + + def setUpModel(self, model): + self.assertTrue(isinstance(model, BaseFairseqModel)) + self.model = model + + def setupInput(self): + pass + + def setUp(self): + self.model = None + self.forward_input = None + pass + + +class TestFairseqEncoderDecoderModelBase(TestBaseFairseqModelBase): + """ + base code to test FairseqEncoderDecoderModel (formally known as + `FairseqModel`) must be derived from this base class + """ + + @classmethod + def setUpClass(cls): + if cls is TestFairseqEncoderDecoderModelBase: + raise unittest.SkipTest("Skipping test case in base") + super().setUpClass() + + def setUpModel(self, model_cls, extra_args_setters=None): + self.assertTrue( + issubclass(model_cls, (FairseqEncoderDecoderModel, FairseqModel)), + msg="This class only tests for FairseqModel subclasses", + ) + + task, parser = get_dummy_task_and_parser() + model_cls.add_args(parser) + + args = parser.parse_args([]) + + if extra_args_setters is not None: + for args_setter in extra_args_setters: + args_setter(args) + model = model_cls.build_model(args, task) + self.model = model + + def setUpInput(self, input=None): + self.forward_input = get_dummy_input() if input is None else input + + def setUp(self): + super().setUp() + + def test_forward(self): + if self.model and self.forward_input: + forward_output = self.model.forward(**self.forward_input) + # for FairseqEncoderDecoderModel, forward returns a tuple of two + # elements, the first one is a Torch.Tensor + succ, msg = check_decoder_output(forward_output) + if not succ: + self.assertTrue(succ, msg=msg) + self.forward_output = forward_output + + def test_get_normalized_probs(self): + if self.model and self.forward_input: + forward_output = self.model.forward(**self.forward_input) + logprob = self.model.get_normalized_probs(forward_output, log_probs=True) + prob = self.model.get_normalized_probs(forward_output, log_probs=False) + + # in order for different models/criterion to play with each other + # we need to know whether the logprob or prob output is batch_first + # or not. We assume an additional attribute will be attached to logprob + # or prob. If you find your code failed here, simply override + # FairseqModel.get_normalized_probs, see example at + # https://fburl.com/batch_first_example + self.assertTrue(hasattr(logprob, "batch_first")) + self.assertTrue(hasattr(prob, "batch_first")) + + self.assertTrue(torch.is_tensor(logprob)) + self.assertTrue(torch.is_tensor(prob)) + + +class TestFairseqEncoderModelBase(TestBaseFairseqModelBase): + """ + base class to test FairseqEncoderModel + """ + + @classmethod + def setUpClass(cls): + if cls is TestFairseqEncoderModelBase: + raise unittest.SkipTest("Skipping test case in base") + super().setUpClass() + + def setUpModel(self, model_cls, extra_args_setters=None): + self.assertTrue( + issubclass(model_cls, FairseqEncoderModel), + msg="This class is only used for testing FairseqEncoderModel", + ) + task, parser = get_dummy_task_and_parser() + model_cls.add_args(parser) + args = parser.parse_args([]) + if extra_args_setters is not None: + for args_setter in extra_args_setters: + args_setter(args) + + model = model_cls.build_model(args, task) + self.model = model + + def setUpInput(self, input=None): + self.forward_input = get_dummy_input() if input is None else input + # get_dummy_input() is originally for s2s, here we delete extra dict + # items, so it can be used for EncoderModel / Encoder as well + self.forward_input.pop("prev_output_tokens", None) + + def setUp(self): + super().setUp() + + def test_forward(self): + if self.forward_input and self.model: + bsz = self.forward_input["src_tokens"].size(0) + forward_output = self.model.forward(**self.forward_input) + + # we expect forward_output to be a dict with the following + # key/value pairs: + # - encoder_out: a Torch.Tensor + # - encoder_padding_mask: a binary Torch.Tensor + succ, msg = check_encoder_output(forward_output, batch_size=bsz) + if not succ: + self.assertTrue(succ, msg=msg) + self.forward_output = forward_output + + def test_get_normalized_probs(self): + if self.model and self.forward_input: + forward_output = self.model.forward(**self.forward_input) + logprob = self.model.get_normalized_probs(forward_output, log_probs=True) + prob = self.model.get_normalized_probs(forward_output, log_probs=False) + + # in order for different models/criterion to play with each other + # we need to know whether the logprob or prob output is batch_first + # or not. We assume an additional attribute will be attached to logprob + # or prob. If you find your code failed here, simply override + # FairseqModel.get_normalized_probs, see example at + # https://fburl.com/batch_first_example + self.assertTrue(hasattr(logprob, "batch_first")) + self.assertTrue(hasattr(prob, "batch_first")) + + self.assertTrue(torch.is_tensor(logprob)) + self.assertTrue(torch.is_tensor(prob)) + + +class TestFairseqEncoderBase(unittest.TestCase): + """ + base class to test FairseqEncoder + """ + + @classmethod + def setUpClass(cls): + if cls is TestFairseqEncoderBase: + raise unittest.SkipTest("Skipping test case in base") + super().setUpClass() + + def setUpEncoder(self, encoder): + self.assertTrue( + isinstance(encoder, FairseqEncoder), + msg="This class is only used for test FairseqEncoder", + ) + self.encoder = encoder + + def setUpInput(self, input=None): + self.forward_input = get_dummy_input() if input is None else input + # get_dummy_input() is originally for s2s, here we delete extra dict + # items, so it can be used for EncoderModel / Encoder as well + self.forward_input.pop("prev_output_tokens", None) + + def setUp(self): + self.encoder = None + self.forward_input = None + + def test_forward(self): + if self.encoder and self.forward_input: + bsz = self.forward_input["src_tokens"].size(0) + + forward_output = self.encoder.forward(**self.forward_input) + succ, msg = check_encoder_output(forward_output, batch_size=bsz) + if not succ: + self.assertTrue(succ, msg=msg) + self.forward_output = forward_output + + +class TestFairseqDecoderBase(unittest.TestCase): + """ + base class to test FairseqDecoder + """ + + @classmethod + def setUpClass(cls): + if cls is TestFairseqDecoderBase: + raise unittest.SkipTest("Skipping test case in base") + super().setUpClass() + + def setUpDecoder(self, decoder): + self.assertTrue( + isinstance(decoder, FairseqDecoder), + msg="This class is only used for test FairseqDecoder", + ) + self.decoder = decoder + + def setUpInput(self, input=None): + self.forward_input = get_dummy_encoder_output() if input is None else input + + def setUpPrevOutputTokens(self, tokens=None): + if tokens is None: + self.encoder_input = get_dummy_input() + self.prev_output_tokens = self.encoder_input["prev_output_tokens"] + else: + self.prev_output_tokens = tokens + + def setUp(self): + self.decoder = None + self.forward_input = None + self.prev_output_tokens = None + + def test_forward(self): + if ( + self.decoder is not None + and self.forward_input is not None + and self.prev_output_tokens is not None + ): + forward_output = self.decoder.forward( + prev_output_tokens=self.prev_output_tokens, + encoder_out=self.forward_input, + ) + succ, msg = check_decoder_output(forward_output) + if not succ: + self.assertTrue(succ, msg=msg) + self.forward_input = forward_output + + +class DummyEncoderModel(FairseqEncoderModel): + def __init__(self, encoder): + super().__init__(encoder) + + @classmethod + def build_model(cls, args, task): + return cls(DummyEncoder()) + + def get_logits(self, net_output): + # Inverse of sigmoid to use with BinaryCrossEntropyWithLogitsCriterion as + # F.binary_cross_entropy_with_logits combines sigmoid and CE + return torch.log( + torch.div(net_output["encoder_out"], 1 - net_output["encoder_out"]) + ) + + def get_normalized_probs(self, net_output, log_probs, sample=None): + lprobs = super().get_normalized_probs(net_output, log_probs, sample=sample) + lprobs.batch_first = True + return lprobs + + +class DummyEncoder(FairseqEncoder): + def __init__(self): + super().__init__(None) + + def forward(self, src_tokens, src_lengths): + mask, max_len = lengths_to_encoder_padding_mask(src_lengths) + return {"encoder_out": src_tokens, "encoder_padding_mask": mask} + + +class CrossEntropyCriterionTestBase(unittest.TestCase): + @classmethod + def setUpClass(cls): + if cls is CrossEntropyCriterionTestBase: + raise unittest.SkipTest("Skipping base class test case") + super().setUpClass() + + def setUpArgs(self): + args = argparse.Namespace() + args.sentence_avg = False + args.threshold = 0.1 # to use with BinaryCrossEntropyWithLogitsCriterion + return args + + def setUp(self): + args = self.setUpArgs() + self.model = DummyEncoderModel(encoder=DummyEncoder()) + self.criterion = self.criterion_cls.build_criterion(args, task=DummyTask(args)) + + def get_src_tokens(self, correct_prediction, aggregate): + """ + correct_prediction: True if the net_output (src_tokens) should + predict the correct target + aggregate: True if the criterion expects net_output (src_tokens) + aggregated across time axis + """ + predicted_idx = 0 if correct_prediction else 1 + if aggregate: + src_tokens = torch.zeros((2, 2), dtype=torch.float) + for b in range(2): + src_tokens[b][predicted_idx] = 1.0 + else: + src_tokens = torch.zeros((2, 10, 2), dtype=torch.float) + for b in range(2): + for t in range(10): + src_tokens[b][t][predicted_idx] = 1.0 + return src_tokens + + def get_target(self, soft_target): + if soft_target: + target = torch.zeros((2, 2), dtype=torch.float) + for b in range(2): + target[b][0] = 1.0 + else: + target = torch.zeros((2, 10), dtype=torch.long) + return target + + def get_test_sample(self, correct, soft_target, aggregate): + src_tokens = self.get_src_tokens(correct, aggregate) + target = self.get_target(soft_target) + L = src_tokens.size(1) + return { + "net_input": {"src_tokens": src_tokens, "src_lengths": torch.tensor([L])}, + "target": target, + "ntokens": src_tokens.size(0) * src_tokens.size(1), + } diff --git a/fairseq/tests/speech_recognition/test_collaters.py b/fairseq/tests/speech_recognition/test_collaters.py new file mode 100644 index 0000000000000000000000000000000000000000..6a5029a48faea2426d7a0277655a2c7c08c1d16c --- /dev/null +++ b/fairseq/tests/speech_recognition/test_collaters.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import numpy as np +import torch +from examples.speech_recognition.data.collaters import Seq2SeqCollater + + +class TestSeq2SeqCollator(unittest.TestCase): + def test_collate(self): + + eos_idx = 1 + pad_idx = 0 + collater = Seq2SeqCollater( + feature_index=0, label_index=1, pad_index=pad_idx, eos_index=eos_idx + ) + + # 2 frames in the first sample and 3 frames in the second one + frames1 = np.array([[7, 8], [9, 10]]) + frames2 = np.array([[1, 2], [3, 4], [5, 6]]) + target1 = np.array([4, 2, 3, eos_idx]) + target2 = np.array([3, 2, eos_idx]) + sample1 = {"id": 0, "data": [frames1, target1]} + sample2 = {"id": 1, "data": [frames2, target2]} + batch = collater.collate([sample1, sample2]) + + # collate sort inputs by frame's length before creating the batch + self.assertTensorEqual(batch["id"], torch.tensor([1, 0])) + self.assertEqual(batch["ntokens"], 7) + self.assertTensorEqual( + batch["net_input"]["src_tokens"], + torch.tensor( + [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [pad_idx, pad_idx]]] + ), + ) + self.assertTensorEqual( + batch["net_input"]["prev_output_tokens"], + torch.tensor([[eos_idx, 3, 2, pad_idx], [eos_idx, 4, 2, 3]]), + ) + self.assertTensorEqual(batch["net_input"]["src_lengths"], torch.tensor([3, 2])) + self.assertTensorEqual( + batch["target"], + torch.tensor([[3, 2, eos_idx, pad_idx], [4, 2, 3, eos_idx]]), + ) + self.assertEqual(batch["nsentences"], 2) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/speech_recognition/test_cross_entropy.py b/fairseq/tests/speech_recognition/test_cross_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..b05400ed95e22762c3e3e5e8fd3ebfa6caf1e325 --- /dev/null +++ b/fairseq/tests/speech_recognition/test_cross_entropy.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from examples.speech_recognition.criterions.cross_entropy_acc import ( + CrossEntropyWithAccCriterion, +) + +from .asr_test_base import CrossEntropyCriterionTestBase + + +class CrossEntropyWithAccCriterionTest(CrossEntropyCriterionTestBase): + def setUp(self): + self.criterion_cls = CrossEntropyWithAccCriterion + super().setUp() + + def test_cross_entropy_all_correct(self): + sample = self.get_test_sample(correct=True, soft_target=False, aggregate=False) + loss, sample_size, logging_output = self.criterion( + self.model, sample, "sum", log_probs=True + ) + assert logging_output["correct"] == 20 + assert logging_output["total"] == 20 + assert logging_output["sample_size"] == 20 + assert logging_output["ntokens"] == 20 + + def test_cross_entropy_all_wrong(self): + sample = self.get_test_sample(correct=False, soft_target=False, aggregate=False) + loss, sample_size, logging_output = self.criterion( + self.model, sample, "sum", log_probs=True + ) + assert logging_output["correct"] == 0 + assert logging_output["total"] == 20 + assert logging_output["sample_size"] == 20 + assert logging_output["ntokens"] == 20 diff --git a/fairseq/tests/speech_recognition/test_data_utils.py b/fairseq/tests/speech_recognition/test_data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a72e0b66948da1349d87eafdef4c4004dd535c96 --- /dev/null +++ b/fairseq/tests/speech_recognition/test_data_utils.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +import unittest + +import torch +from examples.speech_recognition.data import data_utils + + +class DataUtilsTest(unittest.TestCase): + def test_normalization(self): + sample_len1 = torch.tensor( + [ + [ + -0.7661, + -1.3889, + -2.0972, + -0.9134, + -0.7071, + -0.9765, + -0.8700, + -0.8283, + 0.7512, + 1.3211, + 2.1532, + 2.1174, + 1.2800, + 1.2633, + 1.6147, + 1.6322, + 2.0723, + 3.1522, + 3.2852, + 2.2309, + 2.5569, + 2.2183, + 2.2862, + 1.5886, + 0.8773, + 0.8725, + 1.2662, + 0.9899, + 1.1069, + 1.3926, + 1.2795, + 1.1199, + 1.1477, + 1.2687, + 1.3843, + 1.1903, + 0.8355, + 1.1367, + 1.2639, + 1.4707, + ] + ] + ) + out = data_utils.apply_mv_norm(sample_len1) + assert not torch.isnan(out).any() + assert (out == sample_len1).all() diff --git a/fairseq/tests/speech_recognition/test_vggtransformer.py b/fairseq/tests/speech_recognition/test_vggtransformer.py new file mode 100644 index 0000000000000000000000000000000000000000..4dc73b8c7379970dc0bcc16fcb088a64a1bd7e3b --- /dev/null +++ b/fairseq/tests/speech_recognition/test_vggtransformer.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 + +# import models/encoder/decoder to be tested +from examples.speech_recognition.models.vggtransformer import ( + TransformerDecoder, + VGGTransformerEncoder, + VGGTransformerModel, + vggtransformer_1, + vggtransformer_2, + vggtransformer_base, +) + +# import base test class +from .asr_test_base import ( + DEFAULT_TEST_VOCAB_SIZE, + TestFairseqDecoderBase, + TestFairseqEncoderBase, + TestFairseqEncoderDecoderModelBase, + get_dummy_dictionary, + get_dummy_encoder_output, + get_dummy_input, +) + + +class VGGTransformerModelTest_mid(TestFairseqEncoderDecoderModelBase): + def setUp(self): + def override_config(args): + """ + vggtrasformer_1 use 14 layers of transformer, + for testing purpose, it is too expensive. For fast turn-around + test, reduce the number of layers to 3. + """ + args.transformer_enc_config = ( + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 3" + ) + + super().setUp() + extra_args_setter = [vggtransformer_1, override_config] + + self.setUpModel(VGGTransformerModel, extra_args_setter) + self.setUpInput(get_dummy_input(T=50, D=80, B=5, K=DEFAULT_TEST_VOCAB_SIZE)) + + +class VGGTransformerModelTest_big(TestFairseqEncoderDecoderModelBase): + def setUp(self): + def override_config(args): + """ + vggtrasformer_2 use 16 layers of transformer, + for testing purpose, it is too expensive. For fast turn-around + test, reduce the number of layers to 3. + """ + args.transformer_enc_config = ( + "((1024, 16, 4096, True, 0.15, 0.15, 0.15),) * 3" + ) + + super().setUp() + extra_args_setter = [vggtransformer_2, override_config] + + self.setUpModel(VGGTransformerModel, extra_args_setter) + self.setUpInput(get_dummy_input(T=50, D=80, B=5, K=DEFAULT_TEST_VOCAB_SIZE)) + + +class VGGTransformerModelTest_base(TestFairseqEncoderDecoderModelBase): + def setUp(self): + def override_config(args): + """ + vggtrasformer_base use 12 layers of transformer, + for testing purpose, it is too expensive. For fast turn-around + test, reduce the number of layers to 3. + """ + args.transformer_enc_config = ( + "((512, 8, 2048, True, 0.15, 0.15, 0.15),) * 3" + ) + + super().setUp() + extra_args_setter = [vggtransformer_base, override_config] + + self.setUpModel(VGGTransformerModel, extra_args_setter) + self.setUpInput(get_dummy_input(T=50, D=80, B=5, K=DEFAULT_TEST_VOCAB_SIZE)) + + +class VGGTransformerEncoderTest(TestFairseqEncoderBase): + def setUp(self): + super().setUp() + + self.setUpInput(get_dummy_input(T=50, D=80, B=5)) + + def test_forward(self): + print("1. test standard vggtransformer") + self.setUpEncoder(VGGTransformerEncoder(input_feat_per_channel=80)) + super().test_forward() + print("2. test vggtransformer with limited right context") + self.setUpEncoder( + VGGTransformerEncoder( + input_feat_per_channel=80, transformer_context=(-1, 5) + ) + ) + super().test_forward() + print("3. test vggtransformer with limited left context") + self.setUpEncoder( + VGGTransformerEncoder( + input_feat_per_channel=80, transformer_context=(5, -1) + ) + ) + super().test_forward() + print("4. test vggtransformer with limited right context and sampling") + self.setUpEncoder( + VGGTransformerEncoder( + input_feat_per_channel=80, + transformer_context=(-1, 12), + transformer_sampling=(2, 2), + ) + ) + super().test_forward() + print("5. test vggtransformer with windowed context and sampling") + self.setUpEncoder( + VGGTransformerEncoder( + input_feat_per_channel=80, + transformer_context=(12, 12), + transformer_sampling=(2, 2), + ) + ) + + +class TransformerDecoderTest(TestFairseqDecoderBase): + def setUp(self): + super().setUp() + + dict = get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE) + decoder = TransformerDecoder(dict) + dummy_encoder_output = get_dummy_encoder_output(encoder_out_shape=(50, 5, 256)) + + self.setUpDecoder(decoder) + self.setUpInput(dummy_encoder_output) + self.setUpPrevOutputTokens() diff --git a/fairseq/tests/test_activation_checkpointing.py b/fairseq/tests/test_activation_checkpointing.py new file mode 100644 index 0000000000000000000000000000000000000000..647a9572886f8aff09a4aadc0b21e1d5817ff38e --- /dev/null +++ b/fairseq/tests/test_activation_checkpointing.py @@ -0,0 +1,79 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +import torch.nn as nn +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from torch.utils.checkpoint import checkpoint + + +class Model(nn.Module): + def __init__( + self, use_pytorch_checkpoint=False, use_fairseq_checkpoint=False, **kwargs + ): + super().__init__() + torch.manual_seed(0) + self.use_pytorch_checkpoint = use_pytorch_checkpoint + self.ffn = nn.Sequential( + nn.Linear(32, 128), + # add a Dropout layer to test RNG save/restore + nn.Dropout(p=0.5), + nn.Linear(128, 32), + ) + if use_fairseq_checkpoint: + self.ffn = checkpoint_wrapper(self.ffn, **kwargs) + self.out = nn.Linear(32, 1) + + def forward(self, x): + if self.use_pytorch_checkpoint: + x = checkpoint(self.ffn, x) + else: + x = self.ffn(x) + return self.out(x) + + +class TestActivationCheckpointing(unittest.TestCase): + def _test_checkpoint_wrapper(self, device, log_memory_usage=False): + def get_loss_and_gnorm(model): + torch.manual_seed(1) + input = torch.rand(2, 16, 32).requires_grad_(True).to(device) + model.zero_grad() + loss = model(input).sum() + loss.backward() + gnorm = torch.norm( + torch.stack([torch.norm(p.grad.detach()) for p in model.parameters()]) + ) + return {"loss": loss, "gnorm": gnorm} + + model = Model().to(device) + no_cpt = get_loss_and_gnorm(model) + + model = Model(use_pytorch_checkpoint=True).to(device) + pyt_cpt = get_loss_and_gnorm(model) + torch.testing.assert_allclose(no_cpt["loss"], pyt_cpt["loss"]) + torch.testing.assert_allclose(no_cpt["gnorm"], pyt_cpt["gnorm"]) + + model = Model(use_fairseq_checkpoint=True).to(device) + fairseq_cpt = get_loss_and_gnorm(model) + torch.testing.assert_allclose(no_cpt["loss"], fairseq_cpt["loss"]) + torch.testing.assert_allclose(no_cpt["gnorm"], fairseq_cpt["gnorm"]) + + model = Model(use_fairseq_checkpoint=True, offload_to_cpu=True).to(device) + fairseq_cpt_offload = get_loss_and_gnorm(model) + torch.testing.assert_allclose(no_cpt["loss"], fairseq_cpt_offload["loss"]) + torch.testing.assert_allclose(no_cpt["gnorm"], fairseq_cpt_offload["gnorm"]) + + def test_checkpoint_wrapper_cpu(self): + self._test_checkpoint_wrapper(device=torch.device("cpu")) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_checkpoint_wrapper_cuda(self): + self._test_checkpoint_wrapper(device=torch.device("cuda")) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_amp_optimizer.py b/fairseq/tests/test_amp_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..3a785e1830e91b7e090e841d428fe4ea61f3a65c --- /dev/null +++ b/fairseq/tests/test_amp_optimizer.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import copy +import unittest + +import torch +from torch.cuda.amp import autocast, GradScaler +from fairseq.optim import build_optimizer + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestGradientScalingAMP(unittest.TestCase): + def setUp(self): + self.x = torch.tensor([2.0]).cuda().half() + weight = 3.0 + bias = 5.0 + self.error = 1.0 + self.target = torch.tensor([self.x * weight + bias + self.error]).cuda() + self.loss_fn = torch.nn.L1Loss() + + self.model = torch.nn.Linear(1, 1) + self.model.weight.data = torch.tensor([[weight]]) + self.model.bias.data = torch.tensor([bias]) + self.model.cuda() + self.params = list(self.model.parameters()) + + self.namespace_dls = argparse.Namespace( + optimizer="adam", + lr=[0.1], + adam_betas="(0.9, 0.999)", + adam_eps=1e-8, + weight_decay=0.0, + threshold_loss_scale=1, + min_loss_scale=1e-4, + ) + self.scaler = GradScaler( + init_scale=1, + growth_interval=1, + ) + + def run_iter(self, model, params, optimizer): + optimizer.zero_grad() + with autocast(): + y = model(self.x) + loss = self.loss_fn(y, self.target) + self.scaler.scale(loss).backward() + self.assertEqual(loss, torch.tensor(1.0, device="cuda:0", dtype=torch.float16)) + + self.scaler.unscale_(optimizer) + grad_norm = optimizer.clip_grad_norm(0) + self.assertAlmostEqual(grad_norm.item(), 2.2361, 4) + + self.scaler.step(optimizer) + self.scaler.update() + self.assertEqual( + model.weight, + torch.tensor( + [[3.1]], device="cuda:0", requires_grad=True + ), + ) + self.assertEqual( + model.bias, + torch.tensor( + [5.1], device="cuda:0", requires_grad=True + ), + ) + self.assertEqual(self.scaler.get_scale(), 2.0) + + def test_automatic_mixed_precision(self): + model = copy.deepcopy(self.model) + params = list(model.parameters()) + optimizer = build_optimizer(self.namespace_dls, params) + + self.run_iter(model, params, optimizer) diff --git a/fairseq/tests/test_average_checkpoints.py b/fairseq/tests/test_average_checkpoints.py new file mode 100644 index 0000000000000000000000000000000000000000..f348b56b869372d8434fe03f13324d78e9093fa2 --- /dev/null +++ b/fairseq/tests/test_average_checkpoints.py @@ -0,0 +1,134 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import collections +import os +import shutil +import tempfile +import unittest + +import numpy as np +import torch +from scripts.average_checkpoints import average_checkpoints +from torch import nn + + +class ModelWithSharedParameter(nn.Module): + def __init__(self): + super(ModelWithSharedParameter, self).__init__() + self.embedding = nn.Embedding(1000, 200) + self.FC1 = nn.Linear(200, 200) + self.FC2 = nn.Linear(200, 200) + # tie weight in FC2 to FC1 + self.FC2.weight = nn.Parameter(self.FC1.weight) + self.FC2.bias = nn.Parameter(self.FC1.bias) + + self.relu = nn.ReLU() + + def forward(self, input): + return self.FC2(self.ReLU(self.FC1(input))) + self.FC1(input) + + +class TestAverageCheckpoints(unittest.TestCase): + def test_average_checkpoints(self): + params_0 = collections.OrderedDict( + [ + ("a", torch.DoubleTensor([100.0])), + ("b", torch.FloatTensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])), + ("c", torch.IntTensor([7, 8, 9])), + ] + ) + params_1 = collections.OrderedDict( + [ + ("a", torch.DoubleTensor([1.0])), + ("b", torch.FloatTensor([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])), + ("c", torch.IntTensor([2, 2, 2])), + ] + ) + params_avg = collections.OrderedDict( + [ + ("a", torch.DoubleTensor([50.5])), + ("b", torch.FloatTensor([[1.0, 1.5, 2.0], [2.5, 3.0, 3.5]])), + # We expect truncation for integer division + ("c", torch.IntTensor([4, 5, 5])), + ] + ) + + fd_0, path_0 = tempfile.mkstemp() + fd_1, path_1 = tempfile.mkstemp() + torch.save(collections.OrderedDict([("model", params_0)]), path_0) + torch.save(collections.OrderedDict([("model", params_1)]), path_1) + + output = average_checkpoints([path_0, path_1])["model"] + + os.close(fd_0) + os.remove(path_0) + os.close(fd_1) + os.remove(path_1) + + for (k_expected, v_expected), (k_out, v_out) in zip( + params_avg.items(), output.items() + ): + self.assertEqual( + k_expected, + k_out, + "Key mismatch - expected {} but found {}. " + "(Expected list of keys: {} vs actual list of keys: {})".format( + k_expected, k_out, params_avg.keys(), output.keys() + ), + ) + np.testing.assert_allclose( + v_expected.numpy(), + v_out.numpy(), + err_msg="Tensor value mismatch for key {}".format(k_expected), + ) + + def test_average_checkpoints_with_shared_parameters(self): + def _construct_model_with_shared_parameters(path, value): + m = ModelWithSharedParameter() + nn.init.constant_(m.FC1.weight, value) + torch.save({"model": m.state_dict()}, path) + return m + + tmpdir = tempfile.mkdtemp() + paths = [] + path = os.path.join(tmpdir, "m1.pt") + m1 = _construct_model_with_shared_parameters(path, 1.0) + paths.append(path) + + path = os.path.join(tmpdir, "m2.pt") + m2 = _construct_model_with_shared_parameters(path, 2.0) + paths.append(path) + + path = os.path.join(tmpdir, "m3.pt") + m3 = _construct_model_with_shared_parameters(path, 3.0) + paths.append(path) + + new_model = average_checkpoints(paths) + self.assertTrue( + torch.equal( + new_model["model"]["embedding.weight"], + (m1.embedding.weight + m2.embedding.weight + m3.embedding.weight) / 3.0, + ) + ) + + self.assertTrue( + torch.equal( + new_model["model"]["FC1.weight"], + (m1.FC1.weight + m2.FC1.weight + m3.FC1.weight) / 3.0, + ) + ) + + self.assertTrue( + torch.equal( + new_model["model"]["FC2.weight"], + (m1.FC2.weight + m2.FC2.weight + m3.FC2.weight) / 3.0, + ) + ) + shutil.rmtree(tmpdir) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_backtranslation_dataset.py b/fairseq/tests/test_backtranslation_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..dffc3b49387dfdc046ea23d7db179377040b7cbc --- /dev/null +++ b/fairseq/tests/test_backtranslation_dataset.py @@ -0,0 +1,123 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import tests.utils as test_utils +import torch +from fairseq.data import ( + BacktranslationDataset, + LanguagePairDataset, + TransformEosDataset, +) +from fairseq.sequence_generator import SequenceGenerator + + +class TestBacktranslationDataset(unittest.TestCase): + def setUp(self): + ( + self.tgt_dict, + self.w1, + self.w2, + self.src_tokens, + self.src_lengths, + self.model, + ) = test_utils.sequence_generator_setup() + + dummy_src_samples = self.src_tokens + + self.tgt_dataset = test_utils.TestDataset(data=dummy_src_samples) + self.cuda = torch.cuda.is_available() + + def _backtranslation_dataset_helper( + self, + remove_eos_from_input_src, + remove_eos_from_output_src, + ): + tgt_dataset = LanguagePairDataset( + src=self.tgt_dataset, + src_sizes=self.tgt_dataset.sizes, + src_dict=self.tgt_dict, + tgt=None, + tgt_sizes=None, + tgt_dict=None, + ) + + generator = SequenceGenerator( + [self.model], + tgt_dict=self.tgt_dict, + max_len_a=0, + max_len_b=200, + beam_size=2, + unk_penalty=0, + ) + + backtranslation_dataset = BacktranslationDataset( + tgt_dataset=TransformEosDataset( + dataset=tgt_dataset, + eos=self.tgt_dict.eos(), + # remove eos from the input src + remove_eos_from_src=remove_eos_from_input_src, + ), + src_dict=self.tgt_dict, + backtranslation_fn=( + lambda sample: generator.generate([self.model], sample) + ), + output_collater=TransformEosDataset( + dataset=tgt_dataset, + eos=self.tgt_dict.eos(), + # if we remove eos from the input src, then we need to add it + # back to the output tgt + append_eos_to_tgt=remove_eos_from_input_src, + remove_eos_from_src=remove_eos_from_output_src, + ).collater, + cuda=self.cuda, + ) + dataloader = torch.utils.data.DataLoader( + backtranslation_dataset, + batch_size=2, + collate_fn=backtranslation_dataset.collater, + ) + backtranslation_batch_result = next(iter(dataloader)) + + eos, pad, w1, w2 = self.tgt_dict.eos(), self.tgt_dict.pad(), self.w1, self.w2 + + # Note that we sort by src_lengths and add left padding, so actually + # ids will look like: [1, 0] + expected_src = torch.LongTensor([[w1, w2, w1, eos], [pad, pad, w1, eos]]) + if remove_eos_from_output_src: + expected_src = expected_src[:, :-1] + expected_tgt = torch.LongTensor([[w1, w2, eos], [w1, w2, eos]]) + generated_src = backtranslation_batch_result["net_input"]["src_tokens"] + tgt_tokens = backtranslation_batch_result["target"] + + self.assertTensorEqual(expected_src, generated_src) + self.assertTensorEqual(expected_tgt, tgt_tokens) + + def test_backtranslation_dataset_no_eos_in_output_src(self): + self._backtranslation_dataset_helper( + remove_eos_from_input_src=False, + remove_eos_from_output_src=True, + ) + + def test_backtranslation_dataset_with_eos_in_output_src(self): + self._backtranslation_dataset_helper( + remove_eos_from_input_src=False, + remove_eos_from_output_src=False, + ) + + def test_backtranslation_dataset_no_eos_in_input_src(self): + self._backtranslation_dataset_helper( + remove_eos_from_input_src=True, + remove_eos_from_output_src=False, + ) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_binaries.py b/fairseq/tests/test_binaries.py new file mode 100644 index 0000000000000000000000000000000000000000..4e207742625427f108f78bcd24d487a081b6ccf7 --- /dev/null +++ b/fairseq/tests/test_binaries.py @@ -0,0 +1,1874 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import logging +import json +import os +import random +import sys +import tempfile +import unittest +from io import StringIO +from typing import List, Dict +import torch +from fairseq import options +from fairseq_cli import eval_lm, train +from tests.utils import ( + create_dummy_data, + generate_main, + preprocess_lm_data, + preprocess_summarization_data, + preprocess_translation_data, + create_laser_data_and_config_json, + train_translation_model, + train_language_model, +) + + +try: + import transformers # noqa + + has_hf_transformers = True +except ImportError: + has_hf_transformers = False + + +class TestTranslation(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_fconv(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fconv") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model(data_dir, "fconv_iwslt_de_en") + generate_main(data_dir) + + def test_raw(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fconv_raw") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--dataset-impl", "raw"]) + train_translation_model( + data_dir, "fconv_iwslt_de_en", ["--dataset-impl", "raw"] + ) + generate_main(data_dir, ["--dataset-impl", "raw"]) + + def test_update_freq(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_update_freq") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, "fconv_iwslt_de_en", ["--update-freq", "3"] + ) + generate_main(data_dir) + + def test_max_positions(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_max_positions") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + with self.assertRaises(Exception) as context: + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + ["--max-target-positions", "5"], + ) + self.assertTrue( + "skip this example with --skip-invalid-size-inputs-valid-test" + in str(context.exception) + ) + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + [ + "--max-target-positions", + "5", + "--skip-invalid-size-inputs-valid-test", + ], + ) + with self.assertRaises(Exception) as context: + generate_main(data_dir) + generate_main(data_dir, ["--skip-invalid-size-inputs-valid-test"]) + + def test_generation(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_sampling") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model(data_dir, "fconv_iwslt_de_en") + generate_main( + data_dir, + [ + "--sampling", + "--temperature", + "2", + "--beam", + "2", + "--nbest", + "2", + ], + ) + generate_main( + data_dir, + [ + "--sampling", + "--sampling-topk", + "3", + "--beam", + "2", + "--nbest", + "2", + ], + ) + generate_main( + data_dir, + [ + "--sampling", + "--sampling-topp", + "0.2", + "--beam", + "2", + "--nbest", + "2", + ], + ) + generate_main( + data_dir, + [ + "--diversity-rate", + "0.5", + "--beam", + "6", + ], + ) + with self.assertRaises(ValueError): + generate_main( + data_dir, + [ + "--diverse-beam-groups", + "4", + "--match-source-len", + ], + ) + generate_main(data_dir, ["--prefix-size", "2"]) + generate_main(data_dir, ["--retain-dropout"]) + + def test_eval_bleu(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_eval_bleu") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "fconv_iwslt_de_en", + [ + "--eval-bleu", + "--eval-bleu-print-samples", + "--eval-bleu-remove-bpe", + "--eval-bleu-detok", + "space", + "--eval-bleu-args", + '{"beam": 4, "min_len": 10}', + ], + ) + + def test_lstm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lstm") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "lstm_wiseman_iwslt_de_en", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--decoder-out-embed-dim", + "8", + ], + ) + generate_main(data_dir) + + def test_lstm_bidirectional(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lstm_bidirectional") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "lstm", + [ + "--encoder-layers", + "2", + "--encoder-bidirectional", + "--encoder-hidden-size", + "16", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--decoder-out-embed-dim", + "8", + "--decoder-layers", + "2", + ], + ) + generate_main(data_dir) + + def test_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + ], + run_validation=True, + ) + generate_main(data_dir) + + def test_multilingual_transformer(self): + # test with all combinations of encoder/decoder lang tokens + encoder_langtok_flags = [ + [], + ["--encoder-langtok", "src"], + ["--encoder-langtok", "tgt"], + ] + decoder_langtok_flags = [[], ["--decoder-langtok"]] + with contextlib.redirect_stdout(StringIO()): + for i in range(len(encoder_langtok_flags)): + for j in range(len(decoder_langtok_flags)): + enc_ltok_flag = encoder_langtok_flags[i] + dec_ltok_flag = decoder_langtok_flags[j] + with tempfile.TemporaryDirectory( + f"test_multilingual_transformer_{i}_{j}" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + arch="multilingual_transformer", + task="multilingual_translation", + extra_flags=[ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + ] + + enc_ltok_flag + + dec_ltok_flag, + lang_flags=["--lang-pairs", "in-out,out-in"], + run_validation=True, + extra_valid_flags=enc_ltok_flag + dec_ltok_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--task", + "multilingual_translation", + "--lang-pairs", + "in-out,out-in", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ltok_flag + + dec_ltok_flag, + ) + + @unittest.skipIf( + sys.platform.lower() == "darwin", "skip latent depth test on MacOS" + ) + def test_multilingual_translation_latent_depth(self): + # test with latent depth in encoder, decoder, or both + encoder_latent_layer = [[], ["--encoder-latent-layer"]] + decoder_latent_layer = [[], ["--decoder-latent-layer"]] + with contextlib.redirect_stdout(StringIO()): + for i in range(len(encoder_latent_layer)): + for j in range(len(decoder_latent_layer)): + if i == 0 and j == 0: + continue + enc_ll_flag = encoder_latent_layer[i] + dec_ll_flag = decoder_latent_layer[j] + with tempfile.TemporaryDirectory( + f"test_multilingual_translation_latent_depth_{i}_{j}" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data( + data_dir, extra_flags=["--joined-dictionary"] + ) + train_translation_model( + data_dir, + arch="latent_multilingual_transformer", + task="multilingual_translation_latent_depth", + extra_flags=[ + "--user-dir", + "examples/latent_depth/latent_depth_src", + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--share-encoders", + "--share-decoders", + "--sparsity-weight", + "0.1", + ] + + enc_ll_flag + + dec_ll_flag, + lang_flags=["--lang-pairs", "in-out,out-in"], + run_validation=True, + extra_valid_flags=[ + "--user-dir", + "examples/latent_depth/latent_depth_src", + ] + + enc_ll_flag + + dec_ll_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--user-dir", + "examples/latent_depth/latent_depth_src", + "--task", + "multilingual_translation_latent_depth", + "--lang-pairs", + "in-out,out-in", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ll_flag + + dec_ll_flag, + ) + + def test_translation_multi_simple_epoch(self): + # test with all combinations of encoder/decoder lang tokens + encoder_langtok_flags = [ + [], + ["--encoder-langtok", "src"], + ["--encoder-langtok", "tgt"], + ] + decoder_langtok_flags = [[], ["--decoder-langtok"]] + with contextlib.redirect_stdout(StringIO()): + for i in range(len(encoder_langtok_flags)): + for j in range(len(decoder_langtok_flags)): + enc_ltok_flag = encoder_langtok_flags[i] + dec_ltok_flag = decoder_langtok_flags[j] + with tempfile.TemporaryDirectory( + f"test_translation_multi_simple_epoch_{i}_{j}" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data( + data_dir, extra_flags=["--joined-dictionary"] + ) + train_translation_model( + data_dir, + arch="transformer", + task="translation_multi_simple_epoch", + extra_flags=[ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--sampling-method", + "temperature", + "--sampling-temperature", + "1.5", + "--virtual-epoch-size", + "1000", + ] + + enc_ltok_flag + + dec_ltok_flag, + lang_flags=["--lang-pairs", "in-out,out-in"], + run_validation=True, + extra_valid_flags=enc_ltok_flag + dec_ltok_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--task", + "translation_multi_simple_epoch", + "--lang-pairs", + "in-out,out-in", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ltok_flag + + dec_ltok_flag, + ) + + def test_translation_multi_simple_epoch_no_vepoch(self): + # test with all combinations of encoder/decoder lang tokens + with contextlib.redirect_stdout(StringIO()): + enc_ltok_flag = ["--encoder-langtok", "src"] + dec_ltok_flag = ["--decoder-langtok"] + with tempfile.TemporaryDirectory( + "test_translation_multi_simple_epoch_dict" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, extra_flags=[]) + train_translation_model( + data_dir, + arch="transformer", + task="translation_multi_simple_epoch", + extra_flags=[ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--sampling-method", + "temperature", + "--sampling-temperature", + "1.5", + ] + + enc_ltok_flag + + dec_ltok_flag, + lang_flags=["--lang-pairs", "in-out"], + run_validation=True, + extra_valid_flags=enc_ltok_flag + dec_ltok_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--task", + "translation_multi_simple_epoch", + "--lang-pairs", + "in-out", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ltok_flag + + dec_ltok_flag, + ) + + def test_translation_multi_simple_epoch_dicts(self): + # test with all combinations of encoder/decoder lang tokens + with contextlib.redirect_stdout(StringIO()): + enc_ltok_flag = ["--encoder-langtok", "src"] + dec_ltok_flag = ["--decoder-langtok"] + with tempfile.TemporaryDirectory( + "test_translation_multi_simple_epoch_dict" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, extra_flags=[]) + train_translation_model( + data_dir, + arch="transformer", + task="translation_multi_simple_epoch", + extra_flags=[ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--sampling-method", + "temperature", + "--sampling-temperature", + "1.5", + "--virtual-epoch-size", + "1000", + ] + + enc_ltok_flag + + dec_ltok_flag, + lang_flags=["--lang-pairs", "in-out"], + run_validation=True, + extra_valid_flags=enc_ltok_flag + dec_ltok_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--task", + "translation_multi_simple_epoch", + "--lang-pairs", + "in-out", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ltok_flag + + dec_ltok_flag, + ) + + def test_translation_multi_simple_epoch_src_tgt_dict_spec(self): + # test the specification of explicit --src-dict and --tgt-dict + with contextlib.redirect_stdout(StringIO()): + enc_ltok_flag = ["--encoder-langtok", "src"] + dec_ltok_flag = ["--decoder-langtok"] + with tempfile.TemporaryDirectory( + "test_translation_multi_simple_epoch_dict" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, extra_flags=[]) + train_translation_model( + data_dir, + arch="transformer", + task="translation_multi_simple_epoch", + extra_flags=[ + "--source-dict", + f"{data_dir}/dict.in.txt", + "--target-dict", + f"{data_dir}/dict.out.txt", + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--sampling-method", + "temperature", + "--sampling-temperature", + "1.5", + "--virtual-epoch-size", + "1000", + ] + + enc_ltok_flag + + dec_ltok_flag, + lang_flags=["--lang-pairs", "in-out"], + run_validation=True, + extra_valid_flags=enc_ltok_flag + dec_ltok_flag, + ) + generate_main( + data_dir, + extra_flags=[ + "--task", + "translation_multi_simple_epoch", + "--lang-pairs", + "in-out", + "--source-lang", + "in", + "--target-lang", + "out", + ] + + enc_ltok_flag + + dec_ltok_flag, + ) + + def test_transformer_cross_self_attention(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_transformer_cross_self_attention" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--no-cross-attention", + "--cross-self-attention", + ], + run_validation=True, + ) + generate_main(data_dir, extra_flags=[]) + + def test_transformer_pointer_generator(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_transformer_pointer_generator" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_summarization_data(data_dir) + train_translation_model( + data_dir, + "transformer_pointer_generator", + extra_flags=[ + "--user-dir", + "examples/pointer_generator/pointer_generator_src", + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--alignment-layer", + "-1", + "--alignment-heads", + "1", + "--source-position-markers", + "0", + ], + run_validation=True, + extra_valid_flags=[ + "--user-dir", + "examples/pointer_generator/pointer_generator_src", + ], + ) + generate_main( + data_dir, + extra_flags=[ + "--user-dir", + "examples/pointer_generator/pointer_generator_src", + ], + ) + + def test_lightconv(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lightconv") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "lightconv_iwslt_de_en", + [ + "--encoder-conv-type", + "lightweight", + "--decoder-conv-type", + "lightweight", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + ], + ) + generate_main(data_dir) + + def test_dynamicconv(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_dynamicconv") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "lightconv_iwslt_de_en", + [ + "--encoder-conv-type", + "dynamic", + "--decoder-conv-type", + "dynamic", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + ], + ) + generate_main(data_dir) + + def test_cmlm_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_cmlm_transformer") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--joined-dictionary"]) + train_translation_model( + data_dir, + "cmlm_transformer", + [ + "--apply-bert-init", + "--criterion", + "nat_loss", + "--noise", + "full_mask", + "--pred-length-offset", + "--length-loss-factor", + "0.1", + ], + task="translation_lev", + ) + generate_main( + data_dir, + [ + "--task", + "translation_lev", + "--iter-decode-max-iter", + "9", + "--iter-decode-eos-penalty", + "0", + "--print-step", + ], + ) + + def test_nonautoregressive_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_nonautoregressive_transformer" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--joined-dictionary"]) + train_translation_model( + data_dir, + "nonautoregressive_transformer", + [ + "--apply-bert-init", + "--src-embedding-copy", + "--criterion", + "nat_loss", + "--noise", + "full_mask", + "--pred-length-offset", + "--length-loss-factor", + "0.1", + ], + task="translation_lev", + ) + generate_main( + data_dir, + [ + "--task", + "translation_lev", + "--iter-decode-max-iter", + "0", + "--iter-decode-eos-penalty", + "0", + "--print-step", + ], + ) + + # def test_nat_crf_transformer(self): + # with contextlib.redirect_stdout(StringIO()): + # with tempfile.TemporaryDirectory('test_nat_crf_transformer') as data_dir: + # create_dummy_data(data_dir) + # preprocess_translation_data(data_dir, ['--joined-dictionary']) + # train_translation_model(data_dir, 'nacrf_transformer', [ + # '--apply-bert-init', '--criterion', + # 'nat_loss', '--noise', 'full_mask', '--pred-length-offset', + # '--length-loss-factor', '0.1', + # '--word-ins-loss-factor', '0.5', + # '--crf-lowrank-approx', '1', + # '--crf-beam-approx', '1' + # ], task='translation_lev') + # generate_main(data_dir, [ + # '--task', 'translation_lev', + # '--iter-decode-max-iter', '0', + # '--iter-decode-eos-penalty', '0', + # '--print-step', + # ]) + + def test_iterative_nonautoregressive_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_iterative_nonautoregressive_transformer" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--joined-dictionary"]) + train_translation_model( + data_dir, + "iterative_nonautoregressive_transformer", + [ + "--apply-bert-init", + "--src-embedding-copy", + "--criterion", + "nat_loss", + "--noise", + "full_mask", + "--stochastic-approx", + "--dae-ratio", + "0.5", + "--train-step", + "3", + ], + task="translation_lev", + ) + generate_main( + data_dir, + [ + "--task", + "translation_lev", + "--iter-decode-max-iter", + "9", + "--iter-decode-eos-penalty", + "0", + "--print-step", + ], + ) + + def test_insertion_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_insertion_transformer") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir, ["--joined-dictionary"]) + train_translation_model( + data_dir, + "insertion_transformer", + [ + "--apply-bert-init", + "--criterion", + "nat_loss", + "--noise", + "random_mask", + ], + task="translation_lev", + ) + generate_main( + data_dir, + [ + "--task", + "translation_lev", + "--iter-decode-max-iter", + "9", + "--iter-decode-eos-penalty", + "0", + "--print-step", + ], + ) + + def test_mixture_of_experts(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_moe") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--task", + "translation_moe", + "--user-dir", + "examples/translation_moe/translation_moe_src", + "--method", + "hMoElp", + "--mean-pool-gating-network", + "--num-experts", + "3", + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + ], + ) + generate_main( + data_dir, + [ + "--task", + "translation_moe", + "--user-dir", + "examples/translation_moe/translation_moe_src", + "--method", + "hMoElp", + "--mean-pool-gating-network", + "--num-experts", + "3", + "--gen-expert", + "0", + ], + ) + + def test_alignment(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_alignment") as data_dir: + create_dummy_data(data_dir, alignment=True) + preprocess_translation_data(data_dir, ["--align-suffix", "align"]) + train_translation_model( + data_dir, + "transformer_align", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--load-alignments", + "--alignment-layer", + "1", + "--criterion", + "label_smoothed_cross_entropy_with_alignment", + ], + run_validation=True, + ) + generate_main(data_dir) + + def test_laser_lstm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_laser_lstm") as data_dir: + laser_config_file = create_laser_data_and_config_json(data_dir) + train_translation_model( + laser_config_file.name, + "laser_lstm", + [ + "--user-dir", + "examples/laser/laser_src", + "--weighting-alpha", + "0.3", + "--encoder-bidirectional", + "--encoder-hidden-size", + "512", + "--encoder-layers", + "5", + "--decoder-layers", + "1", + "--encoder-embed-dim", + "320", + "--decoder-embed-dim", + "320", + "--decoder-lang-embed-dim", + "32", + "--save-dir", + data_dir, + "--disable-validation", + ], + task="laser", + lang_flags=[], + ) + + def test_laser_transformer(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_laser_transformer") as data_dir: + laser_config_file = create_laser_data_and_config_json(data_dir) + train_translation_model( + laser_config_file.name, + "laser_transformer", + [ + "--user-dir", + "examples/laser/laser_src", + "--weighting-alpha", + "0.3", + "--encoder-embed-dim", + "320", + "--decoder-embed-dim", + "320", + "--decoder-lang-embed-dim", + "32", + "--save-dir", + data_dir, + "--disable-validation", + ], + task="laser", + lang_flags=[], + ) + + def test_alignment_full_context(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_alignment") as data_dir: + create_dummy_data(data_dir, alignment=True) + preprocess_translation_data(data_dir, ["--align-suffix", "align"]) + train_translation_model( + data_dir, + "transformer_align", + [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--load-alignments", + "--alignment-layer", + "1", + "--criterion", + "label_smoothed_cross_entropy_with_alignment", + "--full-context-alignment", + ], + run_validation=True, + ) + generate_main(data_dir) + + def test_transformer_layerdrop(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer_layerdrop") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "3", + "--decoder-layers", + "3", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--encoder-layerdrop", + "0.01", + "--decoder-layerdrop", + "0.01", + ], + ) + generate_main(data_dir) + generate_main( + data_dir, + [ + "--model-overrides", + "{'encoder_layers_to_keep':'0,2','decoder_layers_to_keep':'1'}", + ], + ) + + +class TestStories(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_fconv_self_att_wp(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fconv_self_att_wp") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + config = [ + "--encoder-layers", + "[(128, 3)] * 2", + "--decoder-layers", + "[(128, 3)] * 2", + "--decoder-attention", + "True", + "--encoder-attention", + "False", + "--gated-attention", + "True", + "--self-attention", + "True", + "--project-input", + "True", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--decoder-out-embed-dim", + "8", + "--multihead-self-attention-nheads", + "2", + ] + train_translation_model(data_dir, "fconv_self_att_wp", config) + generate_main(data_dir) + + # fusion model + os.rename( + os.path.join(data_dir, "checkpoint_last.pt"), + os.path.join(data_dir, "pretrained.pt"), + ) + config.extend( + [ + "--pretrained", + "True", + "--pretrained-checkpoint", + os.path.join(data_dir, "pretrained.pt"), + "--save-dir", + os.path.join(data_dir, "fusion_model"), + ] + ) + train_translation_model(data_dir, "fconv_self_att_wp", config) + + +class TestLanguageModeling(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_fconv_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_fconv_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "fconv_lm", + [ + "--decoder-layers", + "[(850, 3)] * 2 + [(1024,4)]", + "--decoder-embed-dim", + "280", + "--optimizer", + "nag", + "--lr", + "0.1", + ], + ) + eval_lm_main(data_dir) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + def test_transformer_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "transformer_lm", + ["--add-bos-token", '--nval', '1'], + run_validation=True, + ) + eval_lm_main(data_dir) + eval_lm_main(data_dir, extra_flags=["--context-window", "25"]) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + def test_transformer_lm_with_adaptive_softmax(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_transformer_lm_with_adaptive_softmax" + ) as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "transformer_lm", + [ + "--add-bos-token", + "--criterion", + "adaptive_loss", + "--adaptive-softmax-cutoff", + "5,10,15", + ], + run_validation=True, + ) + eval_lm_main(data_dir) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + def test_lightconv_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lightconv_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "lightconv_lm", + ["--add-bos-token"], + run_validation=True, + ) + eval_lm_main(data_dir) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + def test_lstm_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lstm_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "lstm_lm", + ["--add-bos-token"], + run_validation=True, + ) + eval_lm_main(data_dir) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + def test_lstm_lm_residuals(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_lstm_lm_residuals") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "lstm_lm", + ["--add-bos-token", "--residuals"], + run_validation=True, + ) + eval_lm_main(data_dir) + generate_main( + data_dir, + [ + "--task", + "language_modeling", + "--sample-break-mode", + "eos", + "--tokens-per-sample", + "500", + ], + ) + + @unittest.skipIf(not has_hf_transformers, "skip test if transformers is missing") + def test_transformer_xl_bptt_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer_xl_bptt_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + task_flags = [ + "--user-dir", + "examples/truncated_bptt", + "--task", + "truncated_bptt_lm", + "--batch-size", + "2", + "--tokens-per-sample", + "50", + ] + train_language_model( + data_dir=data_dir, + arch="transformer_xl", + extra_flags=task_flags + + [ + "--n-layer", + "2", + ], + task="truncated_bptt_lm", + run_validation=True, + extra_valid_flags=task_flags, + ) + eval_lm_main(data_dir, extra_flags=task_flags) + # Train with activation offloading + train_language_model( + data_dir=data_dir, + arch="transformer_xl", + extra_flags=task_flags + + [ + "--n-layer", + "2", + "--offload-activations", + ], + task="truncated_bptt_lm", + run_validation=True, + extra_valid_flags=task_flags, + ) + + +class TestMaskedLanguageModel(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_legacy_masked_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_legacy_mlm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_legacy_masked_language_model(data_dir, "masked_lm") + + def test_roberta_masked_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_roberta_mlm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_masked_lm( + data_dir, "roberta_base", extra_flags=["--encoder-layers", "2"] + ) + + def test_roberta_sentence_prediction(self): + num_classes = 3 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_roberta_head") as data_dir: + create_dummy_roberta_head_data(data_dir, num_classes=num_classes) + preprocess_lm_data(os.path.join(data_dir, "input0")) + preprocess_lm_data(os.path.join(data_dir, "label")) + train_roberta_head(data_dir, "roberta_base", num_classes=num_classes) + + def test_roberta_regression_single(self): + num_classes = 1 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_roberta_regression_single" + ) as data_dir: + create_dummy_roberta_head_data( + data_dir, num_classes=num_classes, regression=True + ) + preprocess_lm_data(os.path.join(data_dir, "input0")) + train_roberta_head( + data_dir, + "roberta_base", + num_classes=num_classes, + extra_flags=["--regression-target"], + ) + + def test_roberta_regression_multiple(self): + num_classes = 3 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_roberta_regression_multiple" + ) as data_dir: + create_dummy_roberta_head_data( + data_dir, num_classes=num_classes, regression=True + ) + preprocess_lm_data(os.path.join(data_dir, "input0")) + train_roberta_head( + data_dir, + "roberta_base", + num_classes=num_classes, + extra_flags=["--regression-target"], + ) + + def test_linformer_roberta_masked_lm(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_linformer_roberta_mlm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_masked_lm( + data_dir, + "linformer_roberta_base", + extra_flags=[ + "--user-dir", + "examples/linformer/linformer_src", + "--encoder-layers", + "2", + ], + ) + + def test_linformer_roberta_sentence_prediction(self): + num_classes = 3 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_linformer_roberta_head") as data_dir: + create_dummy_roberta_head_data(data_dir, num_classes=num_classes) + preprocess_lm_data(os.path.join(data_dir, "input0")) + preprocess_lm_data(os.path.join(data_dir, "label")) + train_roberta_head( + data_dir, + "linformer_roberta_base", + num_classes=num_classes, + extra_flags=["--user-dir", "examples/linformer/linformer_src"], + ) + + def test_linformer_roberta_regression_single(self): + num_classes = 1 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_linformer_roberta_regression_single" + ) as data_dir: + create_dummy_roberta_head_data( + data_dir, num_classes=num_classes, regression=True + ) + preprocess_lm_data(os.path.join(data_dir, "input0")) + train_roberta_head( + data_dir, + "linformer_roberta_base", + num_classes=num_classes, + extra_flags=[ + "--regression-target", + "--user-dir", + "examples/linformer/linformer_src", + ], + ) + + def test_linformer_roberta_regression_multiple(self): + num_classes = 3 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory( + "test_linformer_roberta_regression_multiple" + ) as data_dir: + create_dummy_roberta_head_data( + data_dir, num_classes=num_classes, regression=True + ) + preprocess_lm_data(os.path.join(data_dir, "input0")) + train_roberta_head( + data_dir, + "linformer_roberta_base", + num_classes=num_classes, + extra_flags=[ + "--regression-target", + "--user-dir", + "examples/linformer/linformer_src", + ], + ) + + def _test_pretrained_masked_lm_for_translation(self, learned_pos_emb, encoder_only): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_mlm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_legacy_masked_language_model( + data_dir, + arch="masked_lm", + extra_args=("--encoder-learned-pos",) if learned_pos_emb else (), + ) + with tempfile.TemporaryDirectory( + "test_mlm_translation" + ) as translation_dir: + create_dummy_data(translation_dir) + preprocess_translation_data( + translation_dir, extra_flags=["--joined-dictionary"] + ) + # Train transformer with data_dir/checkpoint_last.pt + train_translation_model( + translation_dir, + arch="transformer_from_pretrained_xlm", + extra_flags=[ + "--decoder-layers", + "1", + "--decoder-embed-dim", + "32", + "--decoder-attention-heads", + "1", + "--decoder-ffn-embed-dim", + "32", + "--encoder-layers", + "1", + "--encoder-embed-dim", + "32", + "--encoder-attention-heads", + "1", + "--encoder-ffn-embed-dim", + "32", + "--pretrained-xlm-checkpoint", + "{}/checkpoint_last.pt".format(data_dir), + "--activation-fn", + "gelu", + "--max-source-positions", + "500", + "--max-target-positions", + "500", + ] + + ( + ["--encoder-learned-pos", "--decoder-learned-pos"] + if learned_pos_emb + else [] + ) + + (["--init-encoder-only"] if encoder_only else []), + task="translation_from_pretrained_xlm", + ) + + def test_pretrained_masked_lm_for_translation_learned_pos_emb(self): + self._test_pretrained_masked_lm_for_translation(True, False) + + def test_pretrained_masked_lm_for_translation_sinusoidal_pos_emb(self): + self._test_pretrained_masked_lm_for_translation(False, False) + + def test_pretrained_masked_lm_for_translation_encoder_only(self): + self._test_pretrained_masked_lm_for_translation(True, True) + + def test_r4f_roberta(self): + num_classes = 3 + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_r4f_roberta_head") as data_dir: + create_dummy_roberta_head_data(data_dir, num_classes=num_classes) + preprocess_lm_data(os.path.join(data_dir, "input0")) + preprocess_lm_data(os.path.join(data_dir, "label")) + train_roberta_head( + data_dir, + "roberta_base", + num_classes=num_classes, + extra_flags=[ + "--user-dir", + "examples/rxf/rxf_src", + "--criterion", + "sentence_prediction_r3f", + "--spectral-norm-classification-head", + ], + ) + + +def train_legacy_masked_language_model(data_dir, arch, extra_args=()): + train_parser = options.get_training_parser() + # TODO: langs should be in and out right? + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + "cross_lingual_lm", + data_dir, + "--arch", + arch, + # Optimizer args + "--optimizer", + "adam", + "--lr-scheduler", + "reduce_lr_on_plateau", + "--lr-shrink", + "0.5", + "--lr", + "0.0001", + "--stop-min-lr", + "1e-09", + # dropout, attention args + "--dropout", + "0.1", + "--attention-dropout", + "0.1", + # MLM args + "--criterion", + "legacy_masked_lm_loss", + "--masked-lm-only", + "--monolingual-langs", + "in,out", + "--num-segment", + "5", + # Transformer args: use a small transformer model for fast training + "--encoder-layers", + "1", + "--encoder-embed-dim", + "32", + "--encoder-attention-heads", + "1", + "--encoder-ffn-embed-dim", + "32", + # Other training args + "--max-tokens", + "500", + "--tokens-per-sample", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--dataset-impl", + "raw", + "--num-workers", + "0", + ] + + list(extra_args), + ) + train.main(train_args) + + +class TestOptimizers(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_optimizers(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_optimizers") as data_dir: + # Use just a bit of data and tiny model to keep this test runtime reasonable + create_dummy_data(data_dir, num_examples=10, maxlen=5) + preprocess_translation_data(data_dir) + optimizers = ["adafactor", "adam", "nag", "adagrad", "sgd", "adadelta"] + last_checkpoint = os.path.join(data_dir, "checkpoint_last.pt") + for optimizer in optimizers: + if os.path.exists(last_checkpoint): + os.remove(last_checkpoint) + train_translation_model( + data_dir, + "lstm", + [ + "--required-batch-size-multiple", + "1", + "--encoder-layers", + "1", + "--encoder-hidden-size", + "32", + "--decoder-layers", + "1", + "--optimizer", + optimizer, + ], + ) + generate_main(data_dir) + + +def read_last_log_entry( + logs: List[logging.LogRecord], logger_name: str +) -> Dict[str, float]: + for x in reversed(logs): + if x.name == logger_name: + return json.loads(x.message) + raise ValueError(f"No entries from {logger_name} found in captured logs") + + +class TestActivationCheckpointing(unittest.TestCase): + base_flags = [ + "--encoder-layers", + "2", + "--decoder-layers", + "2", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--restore-file", + "x.pt", + "--log-format", + "json", + "--log-interval", + "1", + "--max-update", + "2", + ] + + def _train(self, data_dir, extra_flags): + with self.assertLogs() as logs: + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + self.base_flags + extra_flags, + run_validation=True, + extra_valid_flags=["--log-format", "json"], + ) + return logs.records + + def test_activation_offloading_does_not_change_metrics(self): + """Neither ----checkpoint-activations nor --offload-activations should change loss""" + with tempfile.TemporaryDirectory("test_transformer_with_act_cpt") as data_dir: + + with self.assertLogs(): + create_dummy_data(data_dir, num_examples=20) + preprocess_translation_data(data_dir) + offload_logs = self._train(data_dir, ["--offload-activations"]) + baseline_logs = self._train(data_dir, []) + + assert len(baseline_logs) == len(offload_logs) + + baseline_valid_stats = read_last_log_entry(baseline_logs, "valid") + offload_valid_stats = read_last_log_entry(offload_logs, "valid") + baseline_train_stats = read_last_log_entry(baseline_logs, "train") + offload_train_stats = read_last_log_entry(offload_logs, "train") + + assert ( + baseline_train_stats["train_loss"] == offload_train_stats["train_loss"] + ) + assert ( + baseline_valid_stats["valid_loss"] == offload_valid_stats["valid_loss"] + ) + + def test_activation_checkpointing_does_not_change_metrics(self): + """--checkpoint-activations should not change loss""" + + with tempfile.TemporaryDirectory("test_transformer_with_act_cpt") as data_dir: + with self.assertLogs(): + create_dummy_data(data_dir, num_examples=20) + preprocess_translation_data(data_dir) + ckpt_logs = self._train(data_dir, ["--checkpoint-activations"]) + baseline_logs = self._train(data_dir, []) + assert len(baseline_logs) == len(ckpt_logs) + + baseline_train_stats = read_last_log_entry(baseline_logs, "train") + ckpt_train_stats = read_last_log_entry(ckpt_logs, "train") + assert baseline_train_stats["train_loss"] == ckpt_train_stats["train_loss"] + + baseline_valid_stats = read_last_log_entry(baseline_logs, "valid") + ckpt_valid_stats = read_last_log_entry(ckpt_logs, "valid") + assert baseline_valid_stats["valid_loss"] == ckpt_valid_stats["valid_loss"] + + +def create_dummy_roberta_head_data( + data_dir, num_examples=100, maxlen=10, num_classes=2, regression=False +): + input_dir = "input0" + + def _create_dummy_data(filename): + random_data = torch.rand(num_examples * maxlen) + input_data = 97 + torch.floor(26 * random_data).int() + if regression: + output_data = torch.rand((num_examples, num_classes)) + else: + output_data = 1 + torch.floor(num_classes * torch.rand(num_examples)).int() + with open(os.path.join(data_dir, input_dir, filename + ".out"), "w") as f_in: + label_filename = filename + ".label" if regression else filename + ".out" + with open(os.path.join(data_dir, "label", label_filename), "w") as f_out: + offset = 0 + for i in range(num_examples): + # write example input + ex_len = random.randint(1, maxlen) + ex_str = " ".join(map(chr, input_data[offset : offset + ex_len])) + print(ex_str, file=f_in) + # write example label + if regression: + class_str = " ".join(map(str, output_data[i].numpy())) + print(class_str, file=f_out) + else: + class_str = "class{}".format(output_data[i]) + print(class_str, file=f_out) + offset += ex_len + + os.mkdir(os.path.join(data_dir, input_dir)) + os.mkdir(os.path.join(data_dir, "label")) + _create_dummy_data("train") + _create_dummy_data("valid") + _create_dummy_data("test") + + +def train_masked_lm(data_dir, arch, extra_flags=None): + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + "masked_lm", + data_dir, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--criterion", + "masked_lm", + "--batch-size", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + train.main(train_args) + + +def train_roberta_head(data_dir, arch, num_classes=2, extra_flags=None): + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + "sentence_prediction", + data_dir, + "--arch", + arch, + "--encoder-layers", + "2", + "--num-classes", + str(num_classes), + "--optimizer", + "adam", + "--lr", + "0.0001", + "--criterion", + "sentence_prediction", + "--max-tokens", + "500", + "--max-positions", + "500", + "--batch-size", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + "1", + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + train.main(train_args) + + +def eval_lm_main(data_dir, extra_flags=None): + eval_lm_parser = options.get_eval_lm_parser() + eval_lm_args = options.parse_args_and_arch( + eval_lm_parser, + [ + data_dir, + "--path", + os.path.join(data_dir, "checkpoint_last.pt"), + "--no-progress-bar", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + eval_lm.main(eval_lm_args) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_character_token_embedder.py b/fairseq/tests/test_character_token_embedder.py new file mode 100644 index 0000000000000000000000000000000000000000..24940ebd21a0e4465ca6052409353a3179e9cf6d --- /dev/null +++ b/fairseq/tests/test_character_token_embedder.py @@ -0,0 +1,48 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq.data import Dictionary +from fairseq.modules import CharacterTokenEmbedder + + +class TestCharacterTokenEmbedder(unittest.TestCase): + def test_character_token_embedder(self): + vocab = Dictionary() + vocab.add_symbol("hello") + vocab.add_symbol("there") + + embedder = CharacterTokenEmbedder( + vocab, [(2, 16), (4, 32), (8, 64), (16, 2)], 64, 5, 2 + ) + + test_sents = [["hello", "unk", "there"], ["there"], ["hello", "there"]] + max_len = max(len(s) for s in test_sents) + input = torch.LongTensor(len(test_sents), max_len + 2).fill_(vocab.pad()) + for i in range(len(test_sents)): + input[i][0] = vocab.eos() + for j in range(len(test_sents[i])): + input[i][j + 1] = vocab.index(test_sents[i][j]) + input[i][j + 2] = vocab.eos() + embs = embedder(input) + + assert embs.size() == (len(test_sents), max_len + 2, 5) + self.assertAlmostEqual(embs[0][0], embs[1][0]) + self.assertAlmostEqual(embs[0][0], embs[0][-1]) + self.assertAlmostEqual(embs[0][1], embs[2][1]) + self.assertAlmostEqual(embs[0][3], embs[1][1]) + + embs.sum().backward() + assert embedder.char_embeddings.weight.grad is not None + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-6) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_checkpoint_utils.py b/fairseq/tests/test_checkpoint_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0f28222633a68943497616507ce412ead76864d6 --- /dev/null +++ b/fairseq/tests/test_checkpoint_utils.py @@ -0,0 +1,106 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import logging +import os +import tempfile +import unittest +from io import StringIO +from unittest.mock import patch + +from fairseq import checkpoint_utils +from omegaconf import OmegaConf + +from tests.utils import ( + create_dummy_data, + preprocess_translation_data, + train_translation_model, +) + + +class TestCheckpointUtils(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + @contextlib.contextmanager + def _train_transformer(self, seed, extra_args=None): + if extra_args is None: + extra_args = [] + with tempfile.TemporaryDirectory(f"_train_transformer_seed{seed}") as data_dir: + create_dummy_data(data_dir) + preprocess_translation_data(data_dir) + train_translation_model( + data_dir, + "transformer_iwslt_de_en", + [ + "--encoder-layers", + "3", + "--decoder-layers", + "3", + "--encoder-embed-dim", + "8", + "--decoder-embed-dim", + "8", + "--seed", + str(seed), + ] + + extra_args, + ) + yield os.path.join(data_dir, "checkpoint_last.pt") + + def test_load_model_ensemble_and_task(self): + # with contextlib.redirect_stdout(StringIO()): + with self._train_transformer(seed=123) as model1: + with self._train_transformer(seed=456) as model2: + ensemble, cfg, task = checkpoint_utils.load_model_ensemble_and_task( + filenames=[model1, model2] + ) + self.assertEqual(len(ensemble), 2) + + # after Transformer has been migrated to Hydra, this will probably + # become cfg.common.seed + self.assertEqual(ensemble[0].args.seed, 123) + self.assertEqual(ensemble[1].args.seed, 456) + + # the task from the first model should be returned + self.assertTrue("seed123" in task.cfg.data) + + # last cfg is saved + self.assertEqual(cfg.common.seed, 456) + + def test_prune_state_dict(self): + with contextlib.redirect_stdout(StringIO()): + extra_args = ["--encoder-layerdrop", "0.01", "--decoder-layerdrop", "0.01"] + with self._train_transformer(seed=1, extra_args=extra_args) as model: + ensemble, cfg, task = checkpoint_utils.load_model_ensemble_and_task( + filenames=[model], + arg_overrides={ + "encoder_layers_to_keep": "0,2", + "decoder_layers_to_keep": "1", + }, + ) + self.assertEqual(len(ensemble), 1) + self.assertEqual(len(ensemble[0].encoder.layers), 2) + self.assertEqual(len(ensemble[0].decoder.layers), 1) + + def test_torch_persistent_save_async(self): + state_dict = {} + filename = "async_checkpoint.pt" + + with patch(f"{checkpoint_utils.__name__}.PathManager.opena") as mock_opena: + with patch(f"{checkpoint_utils.__name__}._torch_persistent_save") as mock_save: + checkpoint_utils.torch_persistent_save( + state_dict, filename, async_write=True + ) + mock_opena.assert_called_with(filename, "wb") + mock_save.assert_called() + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_concat_dataset.py b/fairseq/tests/test_concat_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..d94aeffd481a2e107eb5747e41d76435b3f3dc8a --- /dev/null +++ b/fairseq/tests/test_concat_dataset.py @@ -0,0 +1,58 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq.data import LanguagePairDataset, TokenBlockDataset +from fairseq.data.concat_dataset import ConcatDataset +from tests.test_train import mock_dict + + +class TestConcatDataset(unittest.TestCase): + def setUp(self): + d = mock_dict() + tokens_1 = torch.LongTensor([1]).view(1, -1) + tokens_ds1 = TokenBlockDataset( + tokens_1, + sizes=[tokens_1.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_1 = LanguagePairDataset( + tokens_ds1, tokens_ds1.sizes, d, shuffle=False + ) + tokens_2 = torch.LongTensor([2]).view(1, -1) + tokens_ds2 = TokenBlockDataset( + tokens_2, + sizes=[tokens_2.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_2 = LanguagePairDataset( + tokens_ds2, tokens_ds2.sizes, d, shuffle=False + ) + + def test_concat_dataset_basics(self): + d = ConcatDataset([self.dataset_1, self.dataset_2]) + assert len(d) == 2 + assert d[0]["source"][0] == 1 + assert d[1]["source"][0] == 2 + + d = ConcatDataset([self.dataset_1, self.dataset_2], sample_ratios=[1, 2]) + assert len(d) == 3 + assert d[0]["source"][0] == 1 + assert d[1]["source"][0] == 2 + assert d[2]["source"][0] == 2 + + d = ConcatDataset([self.dataset_1, self.dataset_2], sample_ratios=[2, 1]) + assert len(d) == 3 + assert d[0]["source"][0] == 1 + assert d[1]["source"][0] == 1 + assert d[2]["source"][0] == 2 diff --git a/fairseq/tests/test_constraints.py b/fairseq/tests/test_constraints.py new file mode 100755 index 0000000000000000000000000000000000000000..1c37f7e1fb26d8ea5349fedd3a60f566d09cf598 --- /dev/null +++ b/fairseq/tests/test_constraints.py @@ -0,0 +1,269 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import sys +import unittest + +import torch +from fairseq.token_generation_constraints import * + + +def tensorize(constraints: List[List[int]]) -> torch.Tensor: + return [torch.tensor(x) for x in constraints] + + +class TestHelperRoutines(unittest.TestCase): + def setUp(self): + self.examples = [ + ([[]], torch.tensor([[0]])), + ([[], []], torch.tensor([[0], [0]])), + ([[torch.tensor([1, 2])], []], torch.tensor([[1, 1, 2, 0], [0, 0, 0, 0]])), + ( + [ + [ + torch.tensor([3, 1, 2]), + torch.tensor([3]), + torch.tensor([4, 5, 6, 7]), + ], + [], + [torch.tensor([1, 8, 9, 10, 1, 4, 11, 12])], + ], + torch.tensor( + [ + [3, 3, 1, 2, 0, 3, 0, 4, 5, 6, 7, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 8, 9, 10, 1, 4, 11, 12, 0, 0, 0], + ] + ), + ), + ] + + def test_packing(self): + """Ensures the list of lists of tensors gets packed correctly.""" + for batch_constraints, expected_tensor in self.examples: + packed = pack_constraints(batch_constraints) + assert torch.equal(packed, expected_tensor) + + +class TestUnorderedConstraintState(unittest.TestCase): + def setUp(self): + # Tuples of (contraint set, expected printed graph, token counts per node) + self.examples = [ + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + "([None].False#6 ([1].True#4 ([2].False#1 [3].True#1) [3].True#1 [4].True#1) ([4].False#2 ([5].True#2 ([6].False#1 [7].True#1))))", + {1: 4, 2: 1, 3: 2, 4: 3, 5: 2, 6: 1, 7: 1}, + ), + ([], "[None].False#0", {}), + (tensorize([[0]]), "([None].False#1 [0].True#1)", {0: 1}), + ( + tensorize([[100000, 1, 2, 3, 4, 5]]), + "([None].False#1 ([100000].False#1 ([1].False#1 ([2].False#1 ([3].False#1 ([4].False#1 [5].True#1))))))", + {100000: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, + ), + ( + tensorize([[1, 2], [1, 2]]), + "([None].False#2 ([1].False#2 [2].True#2))", + {1: 2, 2: 2}, + ), + ( + tensorize([[1, 2], [3, 4]]), + "([None].False#2 ([1].False#1 [2].True#1) ([3].False#1 [4].True#1))", + {1: 1, 2: 1, 3: 1, 4: 1}, + ), + ] + + self.sequences = [ + ( + self.examples[0][0], + [], + {"bank": 0, "num_completed": 0, "finished": False, "is_root": True}, + ), + ( + self.examples[0][0], + [1, 2], + {"bank": 2, "num_completed": 0, "finished": False, "is_root": False}, + ), + ( + self.examples[0][0], + [1, 2, 94], + {"bank": 1, "num_completed": 1, "finished": False, "is_root": True}, + ), + ( + self.examples[0][0], + [1, 3, 999, 1, 4], + {"bank": 4, "num_completed": 2, "finished": False, "is_root": False}, + ), + ( + self.examples[0][0], + [1, 3, 999, 1, 4, 999], + {"bank": 4, "num_completed": 2, "finished": False, "is_root": True}, + ), + ( + self.examples[0][0], + [4, 5, 6, 8], + {"bank": 2, "num_completed": 1, "finished": False, "is_root": True}, + ), + ( + self.examples[0][0], + # Tricky, because in last three, goes down [1->4] branch, could miss [1] and [4->5] + # [[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]], + [1, 2, 3, 1, 3, 1, 4, 4, 5, 6, 7, 1, 4, 5], + {"bank": 14, "num_completed": 6, "finished": True, "is_root": False}, + ), + ( + self.examples[0][0], + [1, 2, 3, 999, 1, 3, 1, 4, 4, 5, 6, 7, 1, 4, 5, 117], + {"bank": 14, "num_completed": 6, "finished": True, "is_root": True}, + ), + ( + tensorize([[1], [2, 3]]), + # Should not be able to get credit for entering 1 a second time + [1, 1], + {"bank": 1, "num_completed": 1, "finished": False, "is_root": True}, + ), + ( + self.examples[4][0], + [1, 2, 1, 2], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": False}, + ), + ( + self.examples[4][0], + [1, 2, 1, 2, 1], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": True}, + ), + ( + self.examples[5][0], + [1, 2, 3, 4, 5], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": True}, + ), + ] + + def test_graphs(self): + """ + Test whether unordered graph systems are created correctly. + """ + for example in self.examples: + constraints, expected, gold_counts = example + c = ConstraintNode.create(constraints) + assert ( + ConstraintNode.print_graph(c) == expected + ), f"got {ConstraintNode.print_graph(c)}, expected {expected}" + assert ( + c.token_counts() == gold_counts + ), f"{c} got {c.token_counts()} wanted {gold_counts}" + + def test_next_tokens(self): + """ + Tests that the set of next tokens is correct. + """ + for example in self.examples: + constraints, expected, gold_counts = example + root = ConstraintNode.create(constraints) + + root_tokens = set(root.children.keys()) + for sequence in constraints: + state = UnorderedConstraintState(root) + for token in sequence: + all_tokens = root_tokens.union(state.node.children.keys()) + assert ( + all_tokens == state.next_tokens() + ), f"ALL {all_tokens} NEXT {state.next_tokens()}" + state = state.advance(token) + + def test_sequences(self): + for constraints, tokens, expected in self.sequences: + state = UnorderedConstraintState.create(pack_constraints([constraints])[0]) + for token in tokens: + state = state.advance(token) + result = {} + for attr in expected.keys(): + result[attr] = getattr(state, attr) + + assert ( + result == expected + ), f"TEST({tokens}) GOT: {result} WANTED: {expected}" + + +class TestOrderedConstraintState(unittest.TestCase): + def setUp(self): + self.sequences = [ + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [], + {"bank": 0, "num_completed": 0, "finished": False, "is_root": True}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2], + {"bank": 2, "num_completed": 0, "finished": False, "is_root": False}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2, 94], + {"bank": 0, "num_completed": 0, "finished": False, "is_root": True}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 3, 999, 1, 4], + {"bank": 0, "num_completed": 0, "finished": False, "is_root": True}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2, 3, 999, 999], + {"bank": 3, "num_completed": 1, "finished": False, "is_root": False}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2, 3, 77, 1, 3, 1], + {"bank": 6, "num_completed": 2, "finished": False, "is_root": False}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2, 3, 1, 3, 1, 4, 4, 5, 6, 7, 1, 4, 5], + {"bank": 14, "num_completed": 6, "finished": True, "is_root": False}, + ), + ( + tensorize([[1, 2, 3], [1, 3], [1, 4], [4, 5, 6, 7], [1], [4, 5]]), + [1, 2, 999, 1, 2, 3, 999, 1, 3, 1, 4, 4, 5, 6, 7, 1, 4, 5, 117], + {"bank": 14, "num_completed": 6, "finished": True, "is_root": False}, + ), + ( + tensorize([[1], [2, 3]]), + [1, 1], + {"bank": 1, "num_completed": 1, "finished": False, "is_root": False}, + ), + ( + tensorize([[1, 2], [1, 2]]), + [1, 2, 1, 2], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": False}, + ), + ( + tensorize([[1, 2], [1, 2]]), + [1, 2, 1, 2, 1], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": False}, + ), + ( + tensorize([[1, 2], [3, 4]]), + [1, 2, 3, 4, 5], + {"bank": 4, "num_completed": 2, "finished": True, "is_root": False}, + ), + ] + + def test_sequences(self): + for i, (constraints, tokens, expected) in enumerate(self.sequences): + state = OrderedConstraintState.create(pack_constraints([constraints])[0]) + for token in tokens: + state = state.advance(token) + result = {} + for attr in expected.keys(): + result[attr] = getattr(state, attr) + assert ( + result == expected + ), f"TEST({tokens}) GOT: {result} WANTED: {expected}" + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_convtbc.py b/fairseq/tests/test_convtbc.py new file mode 100644 index 0000000000000000000000000000000000000000..3a3c9b91e70f597ab77b9b01459cc429db5d7956 --- /dev/null +++ b/fairseq/tests/test_convtbc.py @@ -0,0 +1,54 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +import torch.nn as nn +from fairseq.modules import ConvTBC + + +class TestConvTBC(unittest.TestCase): + def test_convtbc(self): + # ksz, in_channels, out_channels + conv_tbc = ConvTBC(4, 5, kernel_size=3, padding=1) + # out_channels, in_channels, ksz + conv1d = nn.Conv1d(4, 5, kernel_size=3, padding=1) + + conv_tbc.weight.data.copy_(conv1d.weight.data.transpose(0, 2)) + conv_tbc.bias.data.copy_(conv1d.bias.data) + + input_tbc = torch.randn(7, 2, 4, requires_grad=True) + input1d = input_tbc.data.transpose(0, 1).transpose(1, 2) + input1d.requires_grad = True + + output_tbc = conv_tbc(input_tbc) + output1d = conv1d(input1d) + + self.assertAlmostEqual( + output_tbc.data.transpose(0, 1).transpose(1, 2), output1d.data + ) + + grad_tbc = torch.randn(output_tbc.size()) + grad1d = grad_tbc.transpose(0, 1).transpose(1, 2).contiguous() + + output_tbc.backward(grad_tbc) + output1d.backward(grad1d) + + self.assertAlmostEqual( + conv_tbc.weight.grad.data.transpose(0, 2), conv1d.weight.grad.data + ) + self.assertAlmostEqual(conv_tbc.bias.grad.data, conv1d.bias.grad.data) + self.assertAlmostEqual( + input_tbc.grad.data.transpose(0, 1).transpose(1, 2), input1d.grad.data + ) + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-4) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_data_utils.py b/fairseq/tests/test_data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2acfc8dc184015ad762db154dd9929f4c4043093 --- /dev/null +++ b/fairseq/tests/test_data_utils.py @@ -0,0 +1,136 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import numpy as np +from fairseq.data.data_utils_fast import batch_by_size_fn +from fairseq.data.data_utils_fast import batch_by_size_vec + + +class TestBatchBySize(unittest.TestCase): + @classmethod + def batch_by_size_baseline( + cls, + indices, + num_tokens_vec, + max_tokens, + max_sentences, + bsz_mult, + ): + """Simple, reliable and slow implementation of batch by size """ + batches = [] + start = 0 + while start < len(indices): + for end in range(start + 1, len(indices) + 1): + max_val = max(num_tokens_vec[pos] for pos in range(start, end)) + sent_count = end - start + num_tokens = max_val * sent_count + overflow = num_tokens > max_tokens > 0 or sent_count > max_sentences > 0 + terminate = overflow or end == len(indices) + if overflow: + sent_count -= 1 + if terminate: + if sent_count > bsz_mult: + sent_count = sent_count - sent_count % bsz_mult + batches.append(indices[start : start + sent_count]) + start = start + sent_count + break + return batches + + @classmethod + def _get_error_message( + cls, max_sentences, max_tokens, bsz_mult, num_tokens_vec, validation, results + ): + return f"""Reference batch_by_size implementation should produce + same output as the baseline method. + Params: + max_sentences={max_sentences}, + max_tokens={max_tokens}, + bsz_mult={bsz_mult}, + num_tokens_vec={num_tokens_vec}, + expected_batches={validation}, + returned_batches={results}""" + + def _compare_results( + self, + indices_len, + batch_by_size_impl, + max_sentences, + max_tokens, + bsz_mult, + num_tokens_vec, + ): + indices = np.array(list(range(indices_len))) + validation = self.batch_by_size_baseline( + indices, + num_tokens_vec, + max_tokens=max_tokens, + max_sentences=max_sentences, + bsz_mult=bsz_mult, + ) + results = batch_by_size_impl( + indices, + num_tokens_vec, + max_tokens=max_tokens, + max_sentences=max_sentences, + bsz_mult=bsz_mult, + ) + error_msg = self._get_error_message( + max_sentences, max_tokens, bsz_mult, num_tokens_vec, validation, results + ) + self.assertEqual(len(validation), len(results), error_msg) + for first, second in zip(validation, results): + self.assertTrue(np.array_equal(first, second), error_msg) + + def _run_compare_with_baseline_sweep(self, batch_by_size_impl): + """Compare reference batch_by_size implementation with batch_by_size_baseline + across a dense grid of hyperparam values""" + MAX_MAX_TOKENS = 10 + NUM_TOKENS_VECS_COUNT = 5 + for indices_len in [10, 11]: # try odd and even len of indices + for max_sentences in range(0, indices_len + 2): + for max_tokens in range(0, MAX_MAX_TOKENS): + for bsz_mult in range(1, max(MAX_MAX_TOKENS, indices_len) + 2): + for _ in range(NUM_TOKENS_VECS_COUNT): + num_tokens_vec = np.random.randint( + 0, max_tokens + 1, size=indices_len + ) + self._compare_results( + indices_len, + batch_by_size_impl, + max_sentences, + max_tokens, + bsz_mult, + num_tokens_vec, + ) + + +class TestBatchBySizeVec(TestBatchBySize): + def test_compare_with_baseline(self): + self._run_compare_with_baseline_sweep(batch_by_size_vec) + + +class TestBatchBySizeFn(TestBatchBySize): + def test_compare_with_baseline(self): + def batch_by_size_fn_wrapper( + indices, + num_tokens_vec, + max_tokens, + max_sentences, + bsz_mult, + ): + def num_tokens_fn(idx): + return num_tokens_vec[idx] + + return batch_by_size_fn( + indices, num_tokens_fn, max_tokens, max_sentences, bsz_mult + ) + + self._run_compare_with_baseline_sweep(batch_by_size_fn_wrapper) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_dataclass_utils.py b/fairseq/tests/test_dataclass_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..45fc391a979feb198b0a4ecea69c31f1340e87d2 --- /dev/null +++ b/fairseq/tests/test_dataclass_utils.py @@ -0,0 +1,87 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from argparse import ArgumentParser +from dataclasses import dataclass, field + +from fairseq.dataclass import FairseqDataclass +from fairseq.dataclass.utils import gen_parser_from_dataclass + + +@dataclass +class A(FairseqDataclass): + data: str = field(default="test", metadata={"help": "the data input"}) + num_layers: int = field(default=200, metadata={"help": "more layers is better?"}) + + +@dataclass +class B(FairseqDataclass): + bar: A = field(default=A()) + foo: int = field(default=0, metadata={"help": "not a bar"}) + + +@dataclass +class D(FairseqDataclass): + arch: A = field(default=A()) + foo: int = field(default=0, metadata={"help": "not a bar"}) + + +@dataclass +class C(FairseqDataclass): + data: str = field(default="test", metadata={"help": "root level data input"}) + encoder: D = field(default=D()) + decoder: A = field(default=A()) + lr: int = field(default=0, metadata={"help": "learning rate"}) + + +class TestDataclassUtils(unittest.TestCase): + def test_argparse_convert_basic(self): + parser = ArgumentParser() + gen_parser_from_dataclass(parser, A(), True) + args = parser.parse_args(["--num-layers", '10', "the/data/path"]) + self.assertEqual(args.num_layers, 10) + self.assertEqual(args.data, "the/data/path") + + def test_argparse_recursive(self): + parser = ArgumentParser() + gen_parser_from_dataclass(parser, B(), True) + args = parser.parse_args(["--num-layers", "10", "--foo", "10", "the/data/path"]) + self.assertEqual(args.num_layers, 10) + self.assertEqual(args.foo, 10) + self.assertEqual(args.data, "the/data/path") + + def test_argparse_recursive_prefixing(self): + self.maxDiff = None + parser = ArgumentParser() + gen_parser_from_dataclass(parser, C(), True, "") + args = parser.parse_args( + [ + "--encoder-arch-data", + "ENCODER_ARCH_DATA", + "--encoder-arch-num-layers", + "10", + "--encoder-foo", + "10", + "--decoder-data", + "DECODER_DATA", + "--decoder-num-layers", + "10", + "--lr", + "10", + "the/data/path", + ] + ) + self.assertEqual(args.encoder_arch_data, "ENCODER_ARCH_DATA") + self.assertEqual(args.encoder_arch_num_layers, 10) + self.assertEqual(args.encoder_foo, 10) + self.assertEqual(args.decoder_data, "DECODER_DATA") + self.assertEqual(args.decoder_num_layers, 10) + self.assertEqual(args.lr, 10) + self.assertEqual(args.data, "the/data/path") + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_dataset.py b/fairseq/tests/test_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..a3e3970028bc4b0259153e403951e1735bb0cd3e --- /dev/null +++ b/fairseq/tests/test_dataset.py @@ -0,0 +1,66 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import unittest +from typing import Sequence + +from fairseq.data import LanguagePairDataset, ListDataset, RoundRobinZipDatasets +from tests.test_train import mock_dict + + +def lang_pair_dataset(lengths: Sequence[int]) -> LanguagePairDataset: + tokens = [[i] * l for i, l in enumerate(lengths)] + return LanguagePairDataset(ListDataset(tokens), lengths, mock_dict()) + + +def sample(id: int, length: int): + return {"id": id, "source": [id] * length, "target": None} + + +class TestDataset(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_round_robin_zip_datasets(self): + long_dataset = lang_pair_dataset([10, 9, 8, 11]) + short_dataset = lang_pair_dataset([11, 9]) + + dataset = RoundRobinZipDatasets({"a": long_dataset, "b": short_dataset}) + # Dataset is now sorted by sentence length + dataset.ordered_indices() + assert dataset.longest_dataset is long_dataset + self.assertEqual(dict(dataset[0]), {"a": sample(2, 8), "b": sample(1, 9)}) + # The item 2 of dataset 'a' is with item (2 % 2 = 0) of dataset 'b' + self.assertEqual(dict(dataset[2]), {"a": sample(0, 10), "b": sample(1, 9)}) + + def test_round_robin_zip_datasets_filtered(self): + long_dataset = lang_pair_dataset([10, 20, 8, 11, 1000, 7, 12]) + short_dataset = lang_pair_dataset([11, 20, 9, 1000]) + + dataset = RoundRobinZipDatasets({"a": long_dataset, "b": short_dataset}) + # Dataset is now sorted by sentence length + idx = dataset.ordered_indices() + idx, _ = dataset.filter_indices_by_size(idx, {"a": 19, "b": 900}) + self.assertEqual(list(idx), [0, 1, 2, 3, 4]) + self.assertEqual(dict(dataset[0]), {"a": sample(5, 7), "b": sample(2, 9)}) + self.assertEqual(dict(dataset[2]), {"a": sample(0, 10), "b": sample(1, 20)}) + self.assertEqual(dict(dataset[4]), {"a": sample(6, 12), "b": sample(0, 11)}) + + def test_round_robin_zip_datasets_filtered_with_tuple(self): + long_dataset = lang_pair_dataset([10, 20, 8, 11, 1000, 7, 12]) + short_dataset = lang_pair_dataset([11, 20, 9, 1000]) + + dataset = RoundRobinZipDatasets({"a": long_dataset, "b": short_dataset}) + # Dataset is now sorted by sentence length + idx = dataset.ordered_indices() + idx, _ = dataset.filter_indices_by_size(idx, 19) + self.assertEqual(list(idx), [0, 1, 2, 3, 4]) + self.assertEqual(dict(dataset[0]), {"a": sample(5, 7), "b": sample(2, 9)}) + self.assertEqual(dict(dataset[2]), {"a": sample(0, 10), "b": sample(2, 9)}) + self.assertEqual(dict(dataset[4]), {"a": sample(6, 12), "b": sample(2, 9)}) diff --git a/fairseq/tests/test_dictionary.py b/fairseq/tests/test_dictionary.py new file mode 100644 index 0000000000000000000000000000000000000000..dc9d71b3c722ce3066e182d4b237b2a72999d4d0 --- /dev/null +++ b/fairseq/tests/test_dictionary.py @@ -0,0 +1,145 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import io +import os +import string +import tempfile +import unittest + +import torch +from fairseq import tokenizer +from fairseq.data import Dictionary + + +class TestDictionary(unittest.TestCase): + def test_finalize(self): + txt = [ + "A B C D", + "B C D", + "C D", + "D", + ] + ref_ids1 = list( + map( + torch.IntTensor, + [ + [4, 5, 6, 7, 2], + [5, 6, 7, 2], + [6, 7, 2], + [7, 2], + ], + ) + ) + ref_ids2 = list( + map( + torch.IntTensor, + [ + [7, 6, 5, 4, 2], + [6, 5, 4, 2], + [5, 4, 2], + [4, 2], + ], + ) + ) + + # build dictionary + d = Dictionary() + for line in txt: + d.encode_line(line, add_if_not_exist=True) + + def get_ids(dictionary): + ids = [] + for line in txt: + ids.append(dictionary.encode_line(line, add_if_not_exist=False)) + return ids + + def assertMatch(ids, ref_ids): + for toks, ref_toks in zip(ids, ref_ids): + self.assertEqual(toks.size(), ref_toks.size()) + self.assertEqual(0, (toks != ref_toks).sum().item()) + + ids = get_ids(d) + assertMatch(ids, ref_ids1) + + # check finalized dictionary + d.finalize() + finalized_ids = get_ids(d) + assertMatch(finalized_ids, ref_ids2) + + # write to disk and reload + with tempfile.NamedTemporaryFile(mode="w") as tmp_dict: + d.save(tmp_dict.name) + d = Dictionary.load(tmp_dict.name) + reload_ids = get_ids(d) + assertMatch(reload_ids, ref_ids2) + assertMatch(finalized_ids, reload_ids) + + def test_overwrite(self): + # for example, Camembert overwrites <unk>, <s> and </s> + dict_file = io.StringIO( + "<unk> 999 #fairseq:overwrite\n" + "<s> 999 #fairseq:overwrite\n" + "</s> 999 #fairseq:overwrite\n" + ", 999\n" + "▁de 999\n" + ) + d = Dictionary() + d.add_from_file(dict_file) + self.assertEqual(d.index("<pad>"), 1) + self.assertEqual(d.index("foo"), 3) + self.assertEqual(d.index("<unk>"), 4) + self.assertEqual(d.index("<s>"), 5) + self.assertEqual(d.index("</s>"), 6) + self.assertEqual(d.index(","), 7) + self.assertEqual(d.index("▁de"), 8) + + def test_no_overwrite(self): + # for example, Camembert overwrites <unk>, <s> and </s> + dict_file = io.StringIO( + "<unk> 999\n" "<s> 999\n" "</s> 999\n" ", 999\n" "▁de 999\n" + ) + d = Dictionary() + with self.assertRaisesRegex(RuntimeError, "Duplicate"): + d.add_from_file(dict_file) + + def test_space(self): + # for example, character models treat space as a symbol + dict_file = io.StringIO(" 999\n" "a 999\n" "b 999\n") + d = Dictionary() + d.add_from_file(dict_file) + self.assertEqual(d.index(" "), 4) + self.assertEqual(d.index("a"), 5) + self.assertEqual(d.index("b"), 6) + + def test_add_file_to_dict(self): + counts = {} + num_lines = 100 + per_line = 10 + with tempfile.TemporaryDirectory("test_sampling") as data_dir: + filename = os.path.join(data_dir, "dummy.txt") + with open(filename, "w", encoding="utf-8") as data: + for c in string.ascii_letters: + line = f"{c} " * per_line + for _ in range(num_lines): + data.write(f"{line}\n") + counts[c] = per_line * num_lines + per_line += 5 + + dict = Dictionary() + Dictionary.add_file_to_dictionary( + filename, dict, tokenizer.tokenize_line, 10 + ) + dict.finalize(threshold=0, nwords=-1, padding_factor=8) + + for c in string.ascii_letters: + count = dict.get_count(dict.index(c)) + self.assertEqual( + counts[c], count, f"{c} count is {count} but should be {counts[c]}" + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_ema.py b/fairseq/tests/test_ema.py new file mode 100644 index 0000000000000000000000000000000000000000..88ea65a434e49775d40f2b08ce6df0f8d9929c18 --- /dev/null +++ b/fairseq/tests/test_ema.py @@ -0,0 +1,199 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from copy import deepcopy +from dataclasses import dataclass +from typing import Optional + +import torch +from fairseq.models.ema import EMA + + +class DummyModule(torch.nn.Module): + def __init__(self) -> None: + """LightningModule for testing purposes + + Args: + epoch_min_loss_override (int, optional): Pass in an epoch that will be set to the minimum + validation loss for testing purposes (zero based). If None this is ignored. Defaults to None. + """ + super().__init__() + self.layer = torch.nn.Linear(in_features=32, out_features=2) + self.another_layer = torch.nn.Linear(in_features=2, out_features=2) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.layer(x) + return self.another_layer(x) + + +@dataclass +class EMAConfig(object): + ema_decay: float = 0.99 + ema_start_update: int = 0 + ema_fp32: bool = False + ema_seed_model: Optional[str] = None + + +class TestEMAGPU(unittest.TestCase): + def assertTorchAllClose(self, x, y, atol=1e-8, rtol=1e-5, msg=None): + diff = x.float() - y.float() + diff_norm = torch.norm(diff) + other_norm = torch.norm(y.float()) + + if msg is None: + msg = "|input - other| > {} + {} * |other|".format( + atol, rtol + ) + + self.assertLessEqual( + diff_norm, + atol + rtol * other_norm, + msg=msg, + ) + + def test_ema(self): + model = DummyModule() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig() + ema = EMA(model, config) + + # set decay + ema._set_decay(config.ema_decay) + self.assertEqual(ema.get_decay(), config.ema_decay) + + # get model + self.assertEqual(ema.get_model(), ema.model) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + # EMA step + x = torch.randn(32) + y = model(x) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + ema_state_dict = ema.get_model().state_dict() + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema_state_dict[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + self.assertTorchAllClose( + ema_param, + config.ema_decay * prev_param + (1 - config.ema_decay) * param, + ) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + # Load EMA into model + model2 = DummyModule() + ema.reverse(model2) + + for key, param in model2.state_dict().items(): + ema_param = ema_state_dict[key] + self.assertTrue( + torch.allclose(ema_param, param) + ) + + def test_ema_fp32(self): + model = DummyModule().half() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig(ema_fp32=True) + ema = EMA(model, config) + + x = torch.randn(32) + y = model(x.half()) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema.get_model().state_dict()[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + self.assertIn(key, ema.fp32_params) + + # EMA update is done in fp32, and hence the EMA param must be + # closer to the EMA update done in fp32 than in fp16. + self.assertLessEqual( + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half().float() + ), + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param + (1 - config.ema_decay) * param).float() + ), + ) + self.assertTorchAllClose( + ema_param, + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half(), + ) + + def test_ema_fp16(self): + model = DummyModule().half() + optimizer = torch.optim.SGD(model.parameters(), lr=0.01) + state = deepcopy(model.state_dict()) + config = EMAConfig(ema_fp32=False) + ema = EMA(model, config) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + x = torch.randn(32) + y = model(x.half()) + loss = y.sum() + loss.backward() + optimizer.step() + + ema.step(model) + + for key, param in model.state_dict().items(): + prev_param = state[key] + ema_param = ema.get_model().state_dict()[key] + + if "version" in key: + # Do not decay a model.version pytorch param + continue + + # EMA update is done in fp16, and hence the EMA param must be + # closer to the EMA update done in fp16 than in fp32. + self.assertLessEqual( + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param + (1 - config.ema_decay) * param).float() + ), + torch.norm( + ema_param.float() - + (config.ema_decay * prev_param.float() + (1 - config.ema_decay) * param.float()).half().float() + ), + ) + self.assertTorchAllClose( + ema_param, + config.ema_decay * prev_param + (1 - config.ema_decay) * param, + ) + + # Since fp32 params is not used, it should be of size 0 + self.assertEqual(len(ema.fp32_params), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_export.py b/fairseq/tests/test_export.py new file mode 100644 index 0000000000000000000000000000000000000000..b380697b9aff8799f90c1e0819e408826ecf2932 --- /dev/null +++ b/fairseq/tests/test_export.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import tempfile +import unittest + +import torch +from fairseq.data.dictionary import Dictionary +from fairseq.models.transformer import TransformerModel +from fairseq.modules import multihead_attention, sinusoidal_positional_embedding +from fairseq.tasks.fairseq_task import LegacyFairseqTask + + +DEFAULT_TEST_VOCAB_SIZE = 100 + + +class DummyTask(LegacyFairseqTask): + def __init__(self, args): + super().__init__(args) + self.dictionary = get_dummy_dictionary() + if getattr(self.args, "ctc", False): + self.dictionary.add_symbol("<ctc_blank>") + self.src_dict = self.dictionary + self.tgt_dict = self.dictionary + + @property + def source_dictionary(self): + return self.src_dict + + @property + def target_dictionary(self): + return self.dictionary + + +def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE): + dummy_dict = Dictionary() + # add dummy symbol to satisfy vocab size + for id, _ in enumerate(range(vocab_size)): + dummy_dict.add_symbol("{}".format(id), 1000) + return dummy_dict + + +def get_dummy_task_and_parser(): + """ + Return a dummy task and argument parser, which can be used to + create a model/criterion. + """ + parser = argparse.ArgumentParser( + description="test_dummy_s2s_task", argument_default=argparse.SUPPRESS + ) + DummyTask.add_args(parser) + args = parser.parse_args([]) + task = DummyTask.setup_task(args) + return task, parser + + +def _test_save_and_load(scripted_module): + with tempfile.NamedTemporaryFile() as f: + scripted_module.save(f.name) + torch.jit.load(f.name) + + +class TestExportModels(unittest.TestCase): + def test_export_multihead_attention(self): + module = multihead_attention.MultiheadAttention(embed_dim=8, num_heads=2) + scripted = torch.jit.script(module) + _test_save_and_load(scripted) + + def test_incremental_state_multihead_attention(self): + module1 = multihead_attention.MultiheadAttention(embed_dim=8, num_heads=2) + module1 = torch.jit.script(module1) + module2 = multihead_attention.MultiheadAttention(embed_dim=8, num_heads=2) + module2 = torch.jit.script(module2) + + state = {} + state = module1.set_incremental_state(state, "key", {"a": torch.tensor([1])}) + state = module2.set_incremental_state(state, "key", {"a": torch.tensor([2])}) + v1 = module1.get_incremental_state(state, "key")["a"] + v2 = module2.get_incremental_state(state, "key")["a"] + + self.assertEqual(v1, 1) + self.assertEqual(v2, 2) + + def test_positional_embedding(self): + module = sinusoidal_positional_embedding.SinusoidalPositionalEmbedding( + embedding_dim=8, padding_idx=1 + ) + scripted = torch.jit.script(module) + _test_save_and_load(scripted) + + @unittest.skipIf( + torch.__version__ < "1.6.0", "Targeting OSS scriptability for the 1.6 release" + ) + def test_export_transformer(self): + task, parser = get_dummy_task_and_parser() + TransformerModel.add_args(parser) + args = parser.parse_args([]) + model = TransformerModel.build_model(args, task) + scripted = torch.jit.script(model) + _test_save_and_load(scripted) + + @unittest.skipIf( + torch.__version__ < "1.6.0", "Targeting OSS scriptability for the 1.6 release" + ) + def test_export_transformer_no_token_pos_emb(self): + task, parser = get_dummy_task_and_parser() + TransformerModel.add_args(parser) + args = parser.parse_args([]) + args.no_token_positional_embeddings = True + model = TransformerModel.build_model(args, task) + scripted = torch.jit.script(model) + _test_save_and_load(scripted) + + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_file_chunker_utils.py b/fairseq/tests/test_file_chunker_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..5cded04572f0ab68c81db9ad14de1c18951a1a10 --- /dev/null +++ b/fairseq/tests/test_file_chunker_utils.py @@ -0,0 +1,63 @@ +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import shutil +import tempfile +import unittest +from typing import Optional + + +class TestFileChunker(unittest.TestCase): + _tmpdir: Optional[str] = None + _tmpfile: Optional[str] = None + _line_content = "Hello, World\n" + _num_bytes = None + _num_lines = 200 + _num_splits = 20 + + @classmethod + def setUpClass(cls) -> None: + cls._num_bytes = len(cls._line_content.encode("utf-8")) + cls._tmpdir = tempfile.mkdtemp() + with open(os.path.join(cls._tmpdir, "test.txt"), "w") as f: + cls._tmpfile = f.name + for _i in range(cls._num_lines): + f.write(cls._line_content) + f.flush() + + @classmethod + def tearDownClass(cls) -> None: + # Cleanup temp working dir. + if cls._tmpdir is not None: + shutil.rmtree(cls._tmpdir) # type: ignore + + def test_find_offsets(self): + from fairseq.file_chunker_utils import find_offsets + + offsets = find_offsets(self._tmpfile, self._num_splits) + self.assertEqual(len(offsets), self._num_splits + 1) + (zero, *real_offsets, last) = offsets + self.assertEqual(zero, 0) + for i, o in enumerate(real_offsets): + self.assertEqual( + o, + self._num_bytes + + ((i + 1) * self._num_bytes * self._num_lines / self._num_splits), + ) + self.assertEqual(last, self._num_bytes * self._num_lines) + + def test_readchunks(self): + from fairseq.file_chunker_utils import Chunker, find_offsets + + offsets = find_offsets(self._tmpfile, self._num_splits) + for start, end in zip(offsets, offsets[1:]): + with Chunker(self._tmpfile, start, end) as lines: + all_lines = list(lines) + num_lines = self._num_lines / self._num_splits + self.assertAlmostEqual( + len(all_lines), num_lines, delta=1 + ) # because we split on the bites, we might end up with one more/less line in a chunk + self.assertListEqual( + all_lines, [self._line_content for _ in range(len(all_lines))] + ) diff --git a/fairseq/tests/test_file_io.py b/fairseq/tests/test_file_io.py new file mode 100644 index 0000000000000000000000000000000000000000..425812bf1672489093941e5fa09f9da3171559ee --- /dev/null +++ b/fairseq/tests/test_file_io.py @@ -0,0 +1,58 @@ +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import shutil +import sys +import tempfile +import unittest +from typing import Optional +from unittest.mock import MagicMock + + +class TestFileIO(unittest.TestCase): + + _tmpdir: Optional[str] = None + _tmpfile: Optional[str] = None + _tmpfile_contents = "Hello, World" + + @classmethod + def setUpClass(cls) -> None: + cls._tmpdir = tempfile.mkdtemp() + with open(os.path.join(cls._tmpdir, "test.txt"), "w") as f: + cls._tmpfile = f.name + f.write(cls._tmpfile_contents) + f.flush() + + @classmethod + def tearDownClass(cls) -> None: + # Cleanup temp working dir. + if cls._tmpdir is not None: + shutil.rmtree(cls._tmpdir) # type: ignore + + def test_file_io(self): + from fairseq.file_io import PathManager + + with PathManager.open(os.path.join(self._tmpdir, "test.txt"), "r") as f: + s = f.read() + self.assertEqual(s, self._tmpfile_contents) + + def test_file_io_oss(self): + # Mock iopath to simulate oss environment. + sys.modules["iopath"] = MagicMock() + from fairseq.file_io import PathManager + + with PathManager.open(os.path.join(self._tmpdir, "test.txt"), "r") as f: + s = f.read() + self.assertEqual(s, self._tmpfile_contents) + + def test_file_io_async(self): + # ioPath `PathManager` is initialized after the first `opena` call. + try: + from fairseq.file_io import IOPathManager, PathManager + _asyncfile = os.path.join(self._tmpdir, "async.txt") + f = PathManager.opena(_asyncfile, "wb") + f.close() + + finally: + self.assertTrue(PathManager.async_close()) diff --git a/fairseq/tests/test_fp16_optimizer.py b/fairseq/tests/test_fp16_optimizer.py new file mode 100644 index 0000000000000000000000000000000000000000..ce4f1c055ce68b8e3933636fae66cca73c5e9d18 --- /dev/null +++ b/fairseq/tests/test_fp16_optimizer.py @@ -0,0 +1,112 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import copy +import logging +import unittest + +import torch +from fairseq.optim.fp16_optimizer import FP16Optimizer, MemoryEfficientFP16Optimizer +from omegaconf import OmegaConf + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestGradientScaling(unittest.TestCase): + def setUp(self): + self.x = torch.tensor([2.0]).cuda().half() + weight = 3.0 + bias = 5.0 + self.error = 1.0 + self.target = torch.tensor([self.x * weight + bias + self.error]).cuda().half() + self.loss_fn = torch.nn.L1Loss() + + self.model = torch.nn.Linear(1, 1) + self.model.weight.data = torch.tensor([[weight]]) + self.model.bias.data = torch.tensor([bias]) + self.model.cuda().half() + self.params = list(self.model.parameters()) + + self.cfg_dls = OmegaConf.create( + { + "optimization": { + "lr": [0.1], + }, + "optimizer": { + "_name": "adam", + "lr": [0.1], + "adam_betas": "(0.9, 0.999)", + "adam_eps": 1e-8, + "weight_decay": 0.0, + }, + "common": { + "fp16_init_scale": 1, + "fp16_scale_window": 1, + "fp16_scale_tolerance": 1, + "threshold_loss_scale": 1, + "min_loss_scale": 1e-4, + "tpu": False, + }, + } + ) + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def run_iter(self, model, params, optimizer): + optimizer.zero_grad() + y = model(self.x) + loss = self.loss_fn(y, self.target) + optimizer.backward(loss) + self.assertEqual(loss, torch.tensor(1.0, device="cuda:0", dtype=torch.float16)) + + grad_norm = optimizer.clip_grad_norm(0) + self.assertAlmostEqual(grad_norm.item(), 2.2361, 4) + + optimizer.step() + self.assertEqual( + model.weight, + torch.tensor( + [[3.0996]], device="cuda:0", dtype=torch.float16, requires_grad=True + ), + ) + self.assertEqual( + model.bias, + torch.tensor( + [5.1016], device="cuda:0", dtype=torch.float16, requires_grad=True + ), + ) + self.assertEqual(optimizer.scaler.loss_scale, 2.0) + + def test_mixed_precision(self): + model = copy.deepcopy(self.model) + params = list(model.parameters()) + optimizer = FP16Optimizer.build_optimizer(self.cfg_dls, params) + + self.run_iter(model, params, optimizer) + self.assertTrue( + all( + torch.all( + fp32_params.eq( + torch.tensor( + [3.1000, 5.1000], device="cuda:0", requires_grad=True + ) + ) + ) + for fp32_params in optimizer.fp32_params.values() + ) + ) + + def test_memory_efficient(self): + model = copy.deepcopy(self.model) + params = list(model.parameters()) + optimizer = MemoryEfficientFP16Optimizer.build_optimizer(self.cfg_dls, params) + + self.run_iter(model, params, optimizer) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_huffman.py b/fairseq/tests/test_huffman.py new file mode 100644 index 0000000000000000000000000000000000000000..a8cd5222b468b2dbf22f13c9dd34c484a0c30205 --- /dev/null +++ b/fairseq/tests/test_huffman.py @@ -0,0 +1,201 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import os +import random +import string +import typing as tp +import unittest +from collections import Counter +from tempfile import NamedTemporaryFile, TemporaryDirectory + +from fairseq.data import Dictionary, indexed_dataset +from fairseq.data.huffman import ( + HuffmanCodeBuilder, + HuffmanCoder, + HuffmanMMapIndexedDataset, + HuffmanMMapIndexedDatasetBuilder, +) + +POPULATION = string.ascii_letters + string.digits + + +def make_sentence() -> tp.List[str]: + length = random.randint(10, 50) + return random.choices( + population=POPULATION, k=length, weights=range(1, len(POPULATION) + 1) + ) + + +def make_data(length=1000) -> tp.List[tp.List[str]]: + return ( + [make_sentence() for _ in range(0, length)] + # add all the symbols at least once + + [list(string.ascii_letters), list(string.digits)] + ) + + +def make_counts(data: tp.List[tp.List[str]]) -> Counter: + return Counter([symbol for sentence in data for symbol in sentence]) + + +def make_code_builder(data: tp.List[tp.List[str]]) -> HuffmanCodeBuilder: + builder = HuffmanCodeBuilder() + for sentence in data: + builder.add_symbols(*sentence) + return builder + + +class TestCodeBuilder(unittest.TestCase): + def test_code_builder_can_count(self): + data = make_data() + counts = make_counts(data) + builder = make_code_builder(data) + + self.assertEqual(builder.symbols, counts) + + def test_code_builder_can_add(self): + data = make_data() + counts = make_counts(data) + builder = make_code_builder(data) + + new_builder = builder + builder + + self.assertEqual(new_builder.symbols, counts + counts) + + def test_code_builder_can_io(self): + data = make_data() + builder = make_code_builder(data) + + with NamedTemporaryFile() as tmp_fp: + builder.to_file(tmp_fp.name) + other_builder = HuffmanCodeBuilder.from_file(tmp_fp.name) + + self.assertEqual(builder.symbols, other_builder.symbols) + + +class TestCoder(unittest.TestCase): + def test_coder_can_io(self): + data = make_data() + builder = make_code_builder(data) + coder = builder.build_code() + + with NamedTemporaryFile() as tmp_fp: + coder.to_file(tmp_fp.name) + other_coder = HuffmanCoder.from_file(tmp_fp.name) + + self.assertEqual(coder, other_coder) + + def test_coder_can_encode_decode(self): + data = make_data() + builder = make_code_builder(data) + coder = builder.build_code() + + encoded = [coder.encode(sentence) for sentence in data] + decoded = [[n.symbol for n in coder.decode(enc)] for enc in encoded] + + self.assertEqual(decoded, data) + + unseen_data = make_data() + unseen_encoded = [coder.encode(sentence) for sentence in unseen_data] + unseen_decoded = [ + [n.symbol for n in coder.decode(enc)] for enc in unseen_encoded + ] + self.assertEqual(unseen_decoded, unseen_data) + + +def build_dataset(prefix, data, coder): + with HuffmanMMapIndexedDatasetBuilder(prefix, coder) as builder: + for sentence in data: + builder.add_item(sentence) + + +def sizes(data): + return [len(sentence) for sentence in data] + + +class TestHuffmanDataset(unittest.TestCase): + def test_huffman_can_encode_decode(self): + data = make_data() + builder = make_code_builder(data) + coder = builder.build_code() + + with TemporaryDirectory() as dirname: + prefix = os.path.join(dirname, "test1") + build_dataset(prefix, data, coder) + dataset = HuffmanMMapIndexedDataset(prefix) + + self.assertEqual(len(dataset), len(data)) + decoded = [list(dataset.get_symbols(i)) for i in range(0, len(dataset))] + + self.assertEqual(decoded, data) + data_sizes = [i.item() for i in dataset.sizes] + self.assertEqual(data_sizes, sizes(data)) + + def test_huffman_compresses(self): + data = make_data() + builder = make_code_builder(data) + coder = builder.build_code() + + with TemporaryDirectory() as dirname: + prefix = os.path.join(dirname, "huffman") + build_dataset(prefix, data, coder) + + prefix_mmap = os.path.join(dirname, "mmap") + mmap_builder = indexed_dataset.make_builder( + indexed_dataset.data_file_path(prefix_mmap), + "mmap", + vocab_size=len(POPULATION), + ) + dictionary = Dictionary() + for c in POPULATION: + dictionary.add_symbol(c) + dictionary.finalize() + for sentence in data: + mmap_builder.add_item(dictionary.encode_line(" ".join(sentence))) + mmap_builder.finalize(indexed_dataset.index_file_path(prefix_mmap)) + + huff_size = os.stat(indexed_dataset.data_file_path(prefix)).st_size + mmap_size = os.stat(indexed_dataset.data_file_path(prefix_mmap)).st_size + self.assertLess(huff_size, mmap_size) + + def test_huffman_can_append(self): + data1 = make_data() + builder = make_code_builder(data1) + coder = builder.build_code() + + with TemporaryDirectory() as dirname: + prefix1 = os.path.join(dirname, "test1") + build_dataset(prefix1, data1, coder) + + data2 = make_data() + prefix2 = os.path.join(dirname, "test2") + build_dataset(prefix2, data2, coder) + + prefix3 = os.path.join(dirname, "test3") + + with HuffmanMMapIndexedDatasetBuilder(prefix3, coder) as builder: + builder.append(prefix1) + builder.append(prefix2) + + dataset = HuffmanMMapIndexedDataset(prefix3) + + self.assertEqual(len(dataset), len(data1) + len(data2)) + + decoded1 = [list(dataset.get_symbols(i)) for i in range(0, len(data1))] + self.assertEqual(decoded1, data1) + + decoded2 = [ + list(dataset.get_symbols(i)) for i in range(len(data1), len(dataset)) + ] + self.assertEqual(decoded2, data2) + + data_sizes = [i.item() for i in dataset.sizes] + self.assertEqual(data_sizes[: len(data1)], sizes(data1)) + self.assertEqual(data_sizes[len(data1) : len(dataset)], sizes(data2)) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_inference_dropout.py b/fairseq/tests/test_inference_dropout.py new file mode 100644 index 0000000000000000000000000000000000000000..353ac674780a9795492c75aa0a7bc0677b07a9c9 --- /dev/null +++ b/fairseq/tests/test_inference_dropout.py @@ -0,0 +1,70 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import logging +import unittest + +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.models.transformer import TransformerModel +from tests.test_sequence_generator import get_dummy_task_and_parser + + +class TestInferenceDropout(unittest.TestCase): + def setUp(self): + self.task, self.parser = get_dummy_task_and_parser() + TransformerModel.add_args(self.parser) + self.args = self.parser.parse_args([]) + self.args.encoder_layers = 2 + self.args.decoder_layers = 1 + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_sets_inference_dropout_to_true(self): + self.args.retain_dropout = True + self.transformer_model = TransformerModel.build_model(self.args, self.task) + cfg = convert_namespace_to_omegaconf(self.args) + self.transformer_model.prepare_for_inference_(cfg) + assert self.transformer_model.encoder.dropout_module.apply_during_inference + assert self.transformer_model.decoder.dropout_module.apply_during_inference + for layer in self.transformer_model.encoder.layers: + assert layer.dropout_module.apply_during_inference + + def test_inference_dropout_false_by_default(self): + self.transformer_model = TransformerModel.build_model(self.args, self.task) + cfg = convert_namespace_to_omegaconf(self.args) + self.transformer_model.prepare_for_inference_(cfg) + assert not self.transformer_model.encoder.dropout_module.apply_during_inference + assert not self.transformer_model.decoder.dropout_module.apply_during_inference + for layer in self.transformer_model.encoder.layers: + assert not layer.dropout_module.apply_during_inference + for layer in self.transformer_model.decoder.layers: + assert not layer.dropout_module.apply_during_inference + + def test_applies_training_mode(self): + self.transformer_model = TransformerModel.build_model(self.args, self.task) + assert self.transformer_model.encoder.dropout_module.training + for layer in self.transformer_model.encoder.layers: + assert layer.dropout_module.training + + self.transformer_model.eval() + assert not self.transformer_model.decoder.dropout_module.training + for layer in self.transformer_model.encoder.layers: + assert not layer.dropout_module.training + + def test_retain_modules(self): + self.args.retain_dropout = True + self.args.retain_dropout_modules = [ + "TransformerEncoder", + "TransformerEncoderLayer", + ] + self.transformer_model = TransformerModel.build_model(self.args, self.task) + cfg = convert_namespace_to_omegaconf(self.args) + self.transformer_model.prepare_for_inference_(cfg) + assert self.transformer_model.encoder.dropout_module.apply_during_inference + assert not self.transformer_model.decoder.dropout_module.apply_during_inference + for layer in self.transformer_model.decoder.layers: + assert not layer.dropout_module.apply_during_inference diff --git a/fairseq/tests/test_iopath.py b/fairseq/tests/test_iopath.py new file mode 100644 index 0000000000000000000000000000000000000000..908261a6619806f7ef9b5dd1beb5d6817b249a6e --- /dev/null +++ b/fairseq/tests/test_iopath.py @@ -0,0 +1,29 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from unittest import mock + + +class TestIOPath(unittest.TestCase): + + def test_no_iopath(self): + from .test_reproducibility import TestReproducibility + + with mock.patch.dict("sys.modules", {"iopath": None}): + # reuse reproducibility tests, which are e2e tests that should cover + # most checkpoint related functionality + TestReproducibility._test_reproducibility(self, "test_reproducibility") + + def test_no_supports_rename(self): + from .test_reproducibility import TestReproducibility + + with mock.patch("fairseq.file_io.PathManager.supports_rename") as mock_fn: + mock_fn.return_value = False + TestReproducibility._test_reproducibility(self, "test_reproducibility") + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_iterators.py b/fairseq/tests/test_iterators.py new file mode 100644 index 0000000000000000000000000000000000000000..7b3dd4848553357e5e8326ed3a31cf5d68ceea94 --- /dev/null +++ b/fairseq/tests/test_iterators.py @@ -0,0 +1,137 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +from fairseq.data import iterators + + +class TestIterators(unittest.TestCase): + def test_counting_iterator_index(self, ref=None, itr=None): + # Test the indexing functionality of CountingIterator + if ref is None: + assert itr is None + ref = list(range(10)) + itr = iterators.CountingIterator(ref) + else: + assert len(ref) == 10 + assert itr is not None + + self.assertTrue(itr.has_next()) + self.assertEqual(itr.n, 0) + self.assertEqual(next(itr), ref[0]) + self.assertEqual(itr.n, 1) + self.assertEqual(next(itr), ref[1]) + self.assertEqual(itr.n, 2) + itr.skip(3) + self.assertEqual(itr.n, 5) + self.assertEqual(next(itr), ref[5]) + itr.skip(2) + self.assertEqual(itr.n, 8) + self.assertEqual(list(itr), [ref[8], ref[9]]) + self.assertFalse(itr.has_next()) + + def test_counting_iterator_length_mismatch(self): + ref = list(range(10)) + # When the underlying iterable is longer than the CountingIterator, + # the remaining items in the iterable should be ignored + itr = iterators.CountingIterator(ref, total=8) + self.assertEqual(list(itr), ref[:8]) + # When the underlying iterable is shorter than the CountingIterator, + # raise an IndexError when the underlying iterable is exhausted + itr = iterators.CountingIterator(ref, total=12) + self.assertRaises(IndexError, list, itr) + + def test_counting_iterator_take(self): + # Test the "take" method of CountingIterator + ref = list(range(10)) + itr = iterators.CountingIterator(ref) + itr.take(5) + self.assertEqual(len(itr), len(list(iter(itr)))) + self.assertEqual(len(itr), 5) + + itr = iterators.CountingIterator(ref) + itr.take(5) + self.assertEqual(next(itr), ref[0]) + self.assertEqual(next(itr), ref[1]) + itr.skip(2) + self.assertEqual(next(itr), ref[4]) + self.assertFalse(itr.has_next()) + + def test_grouped_iterator(self): + # test correctness + x = list(range(10)) + itr = iterators.GroupedIterator(x, 1) + self.assertEqual(list(itr), [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]) + itr = iterators.GroupedIterator(x, 4) + self.assertEqual(list(itr), [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]]) + itr = iterators.GroupedIterator(x, 5) + self.assertEqual(list(itr), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) + + # test the GroupIterator also works correctly as a CountingIterator + x = list(range(30)) + ref = list(iterators.GroupedIterator(x, 3)) + itr = iterators.GroupedIterator(x, 3) + self.test_counting_iterator_index(ref, itr) + + def test_sharded_iterator(self): + # test correctness + x = list(range(10)) + itr = iterators.ShardedIterator(x, num_shards=1, shard_id=0) + self.assertEqual(list(itr), x) + itr = iterators.ShardedIterator(x, num_shards=2, shard_id=0) + self.assertEqual(list(itr), [0, 2, 4, 6, 8]) + itr = iterators.ShardedIterator(x, num_shards=2, shard_id=1) + self.assertEqual(list(itr), [1, 3, 5, 7, 9]) + itr = iterators.ShardedIterator(x, num_shards=3, shard_id=0) + self.assertEqual(list(itr), [0, 3, 6, 9]) + itr = iterators.ShardedIterator(x, num_shards=3, shard_id=1) + self.assertEqual(list(itr), [1, 4, 7, None]) + itr = iterators.ShardedIterator(x, num_shards=3, shard_id=2) + self.assertEqual(list(itr), [2, 5, 8, None]) + + # test CountingIterator functionality + x = list(range(30)) + ref = list(iterators.ShardedIterator(x, num_shards=3, shard_id=0)) + itr = iterators.ShardedIterator(x, num_shards=3, shard_id=0) + self.test_counting_iterator_index(ref, itr) + + def test_counting_iterator_buffered_iterator_take(self): + ref = list(range(10)) + buffered_itr = iterators.BufferedIterator(2, ref) + itr = iterators.CountingIterator(buffered_itr) + itr.take(5) + self.assertEqual(len(itr), len(list(iter(itr)))) + self.assertEqual(len(itr), 5) + + buffered_itr = iterators.BufferedIterator(2, ref) + itr = iterators.CountingIterator(buffered_itr) + itr.take(5) + self.assertEqual(len(buffered_itr), 5) + self.assertEqual(len(list(iter(buffered_itr))), 5) + + buffered_itr = iterators.BufferedIterator(2, ref) + itr = iterators.CountingIterator(buffered_itr) + itr.take(5) + self.assertEqual(next(itr), ref[0]) + self.assertEqual(next(itr), ref[1]) + itr.skip(2) + self.assertEqual(next(itr), ref[4]) + self.assertFalse(itr.has_next()) + self.assertRaises(StopIteration, next, buffered_itr) + + ref = list(range(4, 10)) + buffered_itr = iterators.BufferedIterator(2, ref) + itr = iterators.CountingIterator(buffered_itr, start=4) + itr.take(5) + self.assertEqual(len(itr), 5) + self.assertEqual(len(buffered_itr), 1) + self.assertEqual(next(itr), ref[0]) + self.assertFalse(itr.has_next()) + self.assertRaises(StopIteration, next, buffered_itr) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_label_smoothing.py b/fairseq/tests/test_label_smoothing.py new file mode 100644 index 0000000000000000000000000000000000000000..04c0f974ac80f7606327f868e948712c3c18f1d0 --- /dev/null +++ b/fairseq/tests/test_label_smoothing.py @@ -0,0 +1,123 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import copy +import unittest + +import tests.utils as test_utils +import torch +from fairseq.criterions.cross_entropy import CrossEntropyCriterion +from fairseq.criterions.label_smoothed_cross_entropy import ( + LabelSmoothedCrossEntropyCriterion, +) + + +class TestLabelSmoothing(unittest.TestCase): + def setUp(self): + # build dictionary + self.d = test_utils.dummy_dictionary(3) + vocab = len(self.d) + self.assertEqual(vocab, 4 + 3) # 4 special + 3 tokens + self.assertEqual(self.d.pad(), 1) + self.assertEqual(self.d.eos(), 2) + self.assertEqual(self.d.unk(), 3) + pad, eos, unk, w1, w2, w3 = 1, 2, 3, 4, 5, 6 # noqa: F841 + + # build dataset + self.data = [ + # the first batch item has padding + { + "source": torch.LongTensor([w1, eos]), + "target": torch.LongTensor([w1, eos]), + }, + { + "source": torch.LongTensor([w1, eos]), + "target": torch.LongTensor([w1, w1, eos]), + }, + ] + self.sample = next(test_utils.dummy_dataloader(self.data)) + + # build model + self.args = argparse.Namespace() + self.args.sentence_avg = False + self.args.report_accuracy = False + self.args.probs = ( + torch.FloatTensor( + [ + # pad eos unk w1 w2 w3 + [0.05, 0.05, 0.1, 0.05, 0.3, 0.4, 0.05], + [0.05, 0.10, 0.2, 0.05, 0.2, 0.3, 0.10], + [0.05, 0.15, 0.3, 0.05, 0.1, 0.2, 0.15], + ] + ) + .unsqueeze(0) + .expand(2, 3, 7) + ) # add batch dimension + self.task = test_utils.TestTranslationTask.setup_task(self.args, self.d, self.d) + self.model = self.task.build_model(self.args) + + def test_nll_loss(self): + self.args.label_smoothing = 0.1 + nll_crit = CrossEntropyCriterion.build_criterion(self.args, self.task) + smooth_crit = LabelSmoothedCrossEntropyCriterion.build_criterion( + self.args, self.task + ) + nll_loss, nll_sample_size, nll_logging_output = nll_crit( + self.model, self.sample + ) + smooth_loss, smooth_sample_size, smooth_logging_output = smooth_crit( + self.model, self.sample + ) + self.assertLess(abs(nll_loss - nll_logging_output["loss"]), 1e-6) + self.assertLess(abs(nll_loss - smooth_logging_output["nll_loss"]), 1e-6) + + def test_padding(self): + self.args.label_smoothing = 0.1 + crit = LabelSmoothedCrossEntropyCriterion.build_criterion(self.args, self.task) + loss, _, logging_output = crit(self.model, self.sample) + + def get_one_no_padding(idx): + # create a new sample with just a single batch item so that there's + # no padding + sample1 = next(test_utils.dummy_dataloader([self.data[idx]])) + args1 = copy.copy(self.args) + args1.probs = args1.probs[idx, :, :].unsqueeze(0) + model1 = self.task.build_model(args1) + loss1, _, _ = crit(model1, sample1) + return loss1 + + loss1 = get_one_no_padding(0) + loss2 = get_one_no_padding(1) + self.assertAlmostEqual(loss, loss1 + loss2) + + def test_reduction(self): + self.args.label_smoothing = 0.1 + crit = LabelSmoothedCrossEntropyCriterion.build_criterion(self.args, self.task) + loss, _, logging_output = crit(self.model, self.sample, reduce=True) + unreduced_loss, _, _ = crit(self.model, self.sample, reduce=False) + self.assertAlmostEqual(loss, unreduced_loss.sum()) + + def test_zero_eps(self): + self.args.label_smoothing = 0.0 + nll_crit = CrossEntropyCriterion.build_criterion(self.args, self.task) + smooth_crit = LabelSmoothedCrossEntropyCriterion.build_criterion( + self.args, self.task + ) + nll_loss, nll_sample_size, nll_logging_output = nll_crit( + self.model, self.sample + ) + smooth_loss, smooth_sample_size, smooth_logging_output = smooth_crit( + self.model, self.sample + ) + self.assertAlmostEqual(nll_loss, smooth_loss) + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-6) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_lm_context_window.py b/fairseq/tests/test_lm_context_window.py new file mode 100644 index 0000000000000000000000000000000000000000..7415e86abdf8ddc2d797092bf98f7a1331e038d6 --- /dev/null +++ b/fairseq/tests/test_lm_context_window.py @@ -0,0 +1,51 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq.data import MonolingualDataset +from fairseq.tasks.language_modeling import LanguageModelingTask, LanguageModelingConfig +from tests import utils as test_utils + + +class TestLMContextWindow(unittest.TestCase): + + def test_eval_dataloader(self): + dictionary = test_utils.dummy_dictionary(10) + assert len(dictionary) == 14 # 4 extra special symbols + assert dictionary.pad() == 1 + + dataset = test_utils.TestDataset([ + torch.tensor([4, 5, 6, 7], dtype=torch.long), + torch.tensor([8, 9, 10, 11], dtype=torch.long), + torch.tensor([12, 13], dtype=torch.long), + ]) + dataset = MonolingualDataset(dataset, sizes=[4, 4, 2], src_vocab=dictionary) + + config = LanguageModelingConfig(tokens_per_sample=4) + task = LanguageModelingTask(config, dictionary) + + eval_dataloader = task.eval_lm_dataloader( + dataset=dataset, + batch_size=1, + context_window=2, + ) + + batch = next(eval_dataloader) + assert batch["net_input"]["src_tokens"][0].tolist() == [4, 5, 6, 7, 1, 1] + assert batch["target"][0].tolist() == [4, 5, 6, 7, 1, 1] + + batch = next(eval_dataloader) + assert batch["net_input"]["src_tokens"][0].tolist() == [6, 7, 8, 9, 10, 11] + assert batch["target"][0].tolist() == [1, 1, 8, 9, 10, 11] + + batch = next(eval_dataloader) + assert batch["net_input"]["src_tokens"][0].tolist() == [10, 11, 12, 13] + assert batch["target"][0].tolist() == [1, 1, 12, 13] + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_lstm_jitable.py b/fairseq/tests/test_lstm_jitable.py new file mode 100644 index 0000000000000000000000000000000000000000..38f79d17931c32447e96c0fbae2630ac397e1804 --- /dev/null +++ b/fairseq/tests/test_lstm_jitable.py @@ -0,0 +1,115 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import tempfile +import unittest + +import torch +from fairseq.data.dictionary import Dictionary +from fairseq.models.lstm import LSTMModel +from fairseq.tasks.fairseq_task import LegacyFairseqTask + + +DEFAULT_TEST_VOCAB_SIZE = 100 + + +class DummyTask(LegacyFairseqTask): + def __init__(self, args): + super().__init__(args) + self.dictionary = get_dummy_dictionary() + if getattr(self.args, "ctc", False): + self.dictionary.add_symbol("<ctc_blank>") + self.src_dict = self.dictionary + self.tgt_dict = self.dictionary + + @property + def source_dictionary(self): + return self.src_dict + + @property + def target_dictionary(self): + return self.dictionary + + +def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE): + dummy_dict = Dictionary() + # add dummy symbol to satisfy vocab size + for id, _ in enumerate(range(vocab_size)): + dummy_dict.add_symbol("{}".format(id), 1000) + return dummy_dict + + +def get_dummy_task_and_parser(): + """ + to build a fariseq model, we need some dummy parse and task. This function + is used to create dummy task and parser to faciliate model/criterion test + + Note: we use FbSpeechRecognitionTask as the dummy task. You may want + to use other task by providing another function + """ + parser = argparse.ArgumentParser( + description="test_dummy_s2s_task", argument_default=argparse.SUPPRESS + ) + DummyTask.add_args(parser) + args = parser.parse_args([]) + task = DummyTask.setup_task(args) + return task, parser + + +class TestJitLSTMModel(unittest.TestCase): + def _test_save_and_load(self, scripted_module): + with tempfile.NamedTemporaryFile() as f: + scripted_module.save(f.name) + torch.jit.load(f.name) + + def assertTensorEqual(self, t1, t2): + t1 = t1[~torch.isnan(t1)] # can cause size mismatch errors if there are NaNs + t2 = t2[~torch.isnan(t2)] + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + def test_jit_and_export_lstm(self): + task, parser = get_dummy_task_and_parser() + LSTMModel.add_args(parser) + args = parser.parse_args([]) + args.criterion = "" + model = LSTMModel.build_model(args, task) + scripted_model = torch.jit.script(model) + self._test_save_and_load(scripted_model) + + def test_assert_jit_vs_nonjit_(self): + task, parser = get_dummy_task_and_parser() + LSTMModel.add_args(parser) + args = parser.parse_args([]) + args.criterion = "" + model = LSTMModel.build_model(args, task) + model.eval() + scripted_model = torch.jit.script(model) + scripted_model.eval() + idx = len(task.source_dictionary) + iter = 100 + # Inject random input and check output + seq_len_tensor = torch.randint(1, 10, (iter,)) + num_samples_tensor = torch.randint(1, 10, (iter,)) + for i in range(iter): + seq_len = seq_len_tensor[i] + num_samples = num_samples_tensor[i] + src_token = (torch.randint(0, idx, (num_samples, seq_len)),) + src_lengths = torch.randint(1, seq_len + 1, (num_samples,)) + src_lengths, _ = torch.sort(src_lengths, descending=True) + # Force the first sample to have seq_len + src_lengths[0] = seq_len + prev_output_token = (torch.randint(0, idx, (num_samples, 1)),) + result = model(src_token[0], src_lengths, prev_output_token[0], None) + scripted_result = scripted_model( + src_token[0], src_lengths, prev_output_token[0], None + ) + self.assertTensorEqual(result[0], scripted_result[0]) + self.assertTensorEqual(result[1], scripted_result[1]) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_memory_efficient_fp16.py b/fairseq/tests/test_memory_efficient_fp16.py new file mode 100644 index 0000000000000000000000000000000000000000..2bf2f29888d6027896128930626b1aafe7f18475 --- /dev/null +++ b/fairseq/tests/test_memory_efficient_fp16.py @@ -0,0 +1,78 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import logging +import unittest + +import torch +from fairseq.optim.adam import FairseqAdam +from fairseq.optim.fp16_optimizer import MemoryEfficientFP16Optimizer +from omegaconf import OmegaConf + + +@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") +class TestMemoryEfficientFP16(unittest.TestCase): + def setUp(self): + logging.disable(logging.CRITICAL) + + def tearDown(self): + logging.disable(logging.NOTSET) + + def test_load_state_dict(self): + # define simple FP16 model + model = torch.nn.Linear(5, 5).cuda().half() + params = list(model.parameters()) + + # initialize memory efficient FP16 optimizer + # with pseudo DictConfigs + optimizer = FairseqAdam( + cfg=OmegaConf.create( + vars( + argparse.Namespace( + adam_betas="(0.9, 0.999)", + adam_eps=1e-8, + weight_decay=0.0, + lr=[0.00001], + ) + ) + ), + params=params, + ) + me_optimizer = MemoryEfficientFP16Optimizer( + cfg=OmegaConf.create( + { + "common": vars( + argparse.Namespace( + fp16_init_scale=1, + fp16_scale_window=1, + fp16_scale_tolerance=1, + threshold_loss_scale=1, + min_loss_scale=1e-4, + ) + ) + } + ), + params=params, + optimizer=optimizer, + ) + + # optimizer state is created in the first step + loss = model(torch.rand(5).cuda().half()).sum() + me_optimizer.backward(loss) + me_optimizer.step() + + # reload state + state = me_optimizer.state_dict() + me_optimizer.load_state_dict(state) + for k, v in me_optimizer.optimizer.state.items(): + self.assertTrue(k.dtype == torch.float16) + for v_i in v.values(): + if torch.is_tensor(v_i): + self.assertTrue(v_i.dtype == torch.float32) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_metrics.py b/fairseq/tests/test_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..2de6969cf4445bc6cda44dacf6de765ea30d5f5b --- /dev/null +++ b/fairseq/tests/test_metrics.py @@ -0,0 +1,77 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +import uuid + +from fairseq import metrics + + +class TestMetrics(unittest.TestCase): + def test_nesting(self): + with metrics.aggregate() as a: + metrics.log_scalar("loss", 1) + with metrics.aggregate() as b: + metrics.log_scalar("loss", 2) + + self.assertEqual(a.get_smoothed_values()["loss"], 1.5) + self.assertEqual(b.get_smoothed_values()["loss"], 2) + + def test_new_root(self): + with metrics.aggregate() as a: + metrics.log_scalar("loss", 1) + with metrics.aggregate(new_root=True) as b: + metrics.log_scalar("loss", 2) + + self.assertEqual(a.get_smoothed_values()["loss"], 1) + self.assertEqual(b.get_smoothed_values()["loss"], 2) + + def test_nested_new_root(self): + with metrics.aggregate() as layer1: + metrics.log_scalar("loss", 1) + with metrics.aggregate(new_root=True) as layer2: + metrics.log_scalar("loss", 2) + with metrics.aggregate() as layer3: + metrics.log_scalar("loss", 3) + with metrics.aggregate(new_root=True) as layer4: + metrics.log_scalar("loss", 4) + metrics.log_scalar("loss", 1.5) + + self.assertEqual(layer4.get_smoothed_values()["loss"], 4) + self.assertEqual(layer3.get_smoothed_values()["loss"], 3) + self.assertEqual(layer2.get_smoothed_values()["loss"], 2.5) + self.assertEqual(layer1.get_smoothed_values()["loss"], 1.25) + + def test_named(self): + name = str(uuid.uuid4()) + metrics.reset_meters(name) + + with metrics.aggregate(name): + metrics.log_scalar("loss", 1) + + metrics.log_scalar("loss", 3) + + with metrics.aggregate(name): + metrics.log_scalar("loss", 2) + + self.assertEqual(metrics.get_smoothed_values(name)["loss"], 1.5) + + def test_nested_duplicate_names(self): + name = str(uuid.uuid4()) + metrics.reset_meters(name) + + with metrics.aggregate(name): + metrics.log_scalar("loss", 1) + with metrics.aggregate() as other: + with metrics.aggregate(name): + metrics.log_scalar("loss", 2) + metrics.log_scalar("loss", 6) + + self.assertEqual(metrics.get_smoothed_values(name)["loss"], 3) + self.assertEqual(other.get_smoothed_values()["loss"], 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_multi_corpus_dataset.py b/fairseq/tests/test_multi_corpus_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..5a79f4b680e5bc2c7374ec6dd8ea525c47b40985 --- /dev/null +++ b/fairseq/tests/test_multi_corpus_dataset.py @@ -0,0 +1,79 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from collections import OrderedDict + +import torch +from fairseq.data import LanguagePairDataset, TokenBlockDataset +from fairseq.data.multi_corpus_dataset import MultiCorpusDataset +from tests.test_train import mock_dict + + +class TestMultiCorpusDataset(unittest.TestCase): + def setUp(self): + d = mock_dict() + tokens_1 = torch.LongTensor([i for i in range(1, 5000, 2)]).view(1, -1) + tokens_ds1 = TokenBlockDataset( + tokens_1, + sizes=[tokens_1.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_1 = LanguagePairDataset( + tokens_ds1, tokens_ds1.sizes, d, shuffle=False + ) + tokens_2 = torch.LongTensor([i for i in range(0, 5000, 2)]).view(1, -1) + tokens_ds2 = TokenBlockDataset( + tokens_2, + sizes=[tokens_2.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_2 = LanguagePairDataset( + tokens_ds2, tokens_ds2.sizes, d, shuffle=False + ) + + def _test_sample_helper( + self, + distribution, + ): + m = MultiCorpusDataset( + OrderedDict({0: self.dataset_1, 1: self.dataset_2}), + distribution=distribution, + seed=0, + sort_indices=True, + ) + m.set_epoch(1) + indices = m.ordered_indices() + count_sample_from_first_dataset = 0 + items = set() + for i in indices: + item = m[i]["source"].item() + if item % 2 == 1: + count_sample_from_first_dataset += 1 + + items.add(item) + sample_from_first_ds_percentage = ( + 1.0 * count_sample_from_first_dataset / len(indices) + ) + self.assertLess( + abs(sample_from_first_ds_percentage - distribution[0]), + 0.01, + ) + self.assertEqual( + len(items), + int(min(len(self.dataset_1), len(indices) * distribution[0]) + + min(len(self.dataset_1), len(indices) * distribution[1])) + ) + print(distribution) + + def test_multi_corpus_dataset(self): + for distribution in [[0.5, 0.5], [0.1, 0.9], [0.9, 0.1]]: + self._test_sample_helper(distribution=distribution) diff --git a/fairseq/tests/test_multi_corpus_sampled_dataset.py b/fairseq/tests/test_multi_corpus_sampled_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..05b20328c5605178767d138cc75e070824679842 --- /dev/null +++ b/fairseq/tests/test_multi_corpus_sampled_dataset.py @@ -0,0 +1,95 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from collections import OrderedDict + +import numpy as np +import torch +from fairseq.data import LanguagePairDataset, TokenBlockDataset +from fairseq.data.multi_corpus_sampled_dataset import MultiCorpusSampledDataset +from tests.test_train import mock_dict + + +class TestMultiCorpusSampledDataset(unittest.TestCase): + def setUp(self): + d = mock_dict() + tokens_1 = torch.LongTensor([1]).view(1, -1) + tokens_ds1 = TokenBlockDataset( + tokens_1, + sizes=[tokens_1.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_1 = LanguagePairDataset( + tokens_ds1, tokens_ds1.sizes, d, shuffle=False + ) + tokens_2 = torch.LongTensor([2]).view(1, -1) + tokens_ds2 = TokenBlockDataset( + tokens_2, + sizes=[tokens_2.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + self.dataset_2 = LanguagePairDataset( + tokens_ds2, tokens_ds2.sizes, d, shuffle=False + ) + + def _test_sample_helper( + self, + expected_sample_from_first_ds_percentage, + num_samples=1000, + sampling_func=None, + ): + # To make sure test is not flaky + np.random.seed(0) + if sampling_func is None: + m = MultiCorpusSampledDataset( + OrderedDict({0: self.dataset_1, 1: self.dataset_2}), + ) + else: + m = MultiCorpusSampledDataset( + OrderedDict({0: self.dataset_1, 1: self.dataset_2}), + sampling_func=sampling_func, + ) + m.ordered_indices() + count_sample_from_first_dataset = 0 + for _ in range(num_samples): + if m.collater([m[0], m[1]])["net_input"]["src_tokens"][0] == 1: + count_sample_from_first_dataset += 1 + sample_from_first_ds_percentage = ( + 1.0 * count_sample_from_first_dataset / num_samples + ) + self.assertLess( + abs( + sample_from_first_ds_percentage + - expected_sample_from_first_ds_percentage + ), + 0.01, + ) + + def test_multi_corpus_sampled_dataset_uniform_sample(self): + self._test_sample_helper(expected_sample_from_first_ds_percentage=0.5) + + def test_multi_corpus_sampled_dataset_weighted_sample(self): + def naive_weighted_sample(weights): + def f(l): + v = np.random.random() + agg = 0 + for i, weight in enumerate(weights): + agg += weight + if agg > v: + return i + + return f + + self._test_sample_helper( + expected_sample_from_first_ds_percentage=0.9, + sampling_func=naive_weighted_sample(weights=[0.9, 0.1]), + ) diff --git a/fairseq/tests/test_multihead_attention.py b/fairseq/tests/test_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..620a2d679147bbbb8d15f3323374a39939686ec2 --- /dev/null +++ b/fairseq/tests/test_multihead_attention.py @@ -0,0 +1,73 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq.modules.multihead_attention import MultiheadAttention + + +class TestMultiheadAttention(unittest.TestCase): + def test_append_prev_key_padding_mask(self): + bsz = 1 + src_len = 4 + + cases = [ + # no padding mask + (None, None, None), + # current padding mask only + ( + torch.tensor([[1]]).bool(), + None, + torch.tensor([[0, 0, 0, 1]]).bool(), + ), + # previous padding mask only + ( + None, + torch.tensor([[0, 1, 0]]).bool(), + torch.tensor([[0, 1, 0, 0]]).bool(), + ), + # both padding masks + ( + torch.tensor([[1]]).bool(), + torch.tensor([[0, 1, 0]]).bool(), + torch.tensor([[0, 1, 0, 1]]).bool(), + ), + # prev_key_padding_mask already full + ( + torch.tensor([[0, 1, 0, 1]]).bool(), + None, + torch.tensor([[0, 1, 0, 1]]).bool(), + ), + # key_padding_mask already full + ( + None, + torch.tensor([[0, 1, 0, 1]]).bool(), + torch.tensor([[0, 1, 0, 1]]).bool(), + ), + ] + for c in cases: + key_padding_mask = MultiheadAttention._append_prev_key_padding_mask( + c[0], + c[1], + batch_size=bsz, + src_len=src_len, + static_kv=False, + ) + + if key_padding_mask is not None: + self.assertTrue( + torch.all(torch.eq(key_padding_mask, c[2])), + f"Unexpected resultant key padding mask: {key_padding_mask}" + f" given current: {c[0]} and previous: {c[1]}", + ) + self.assertEqual(key_padding_mask.size(0), bsz) + self.assertEqual(key_padding_mask.size(1), src_len) + else: + self.assertIsNone(c[2]) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_noising.py b/fairseq/tests/test_noising.py new file mode 100644 index 0000000000000000000000000000000000000000..b3d0d123c42eaca6f79371aa268049e668fcfcce --- /dev/null +++ b/fairseq/tests/test_noising.py @@ -0,0 +1,530 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest +from typing import Dict, List + +import tests.utils as test_utils +import torch +from fairseq import utils +from fairseq.data import ( + Dictionary, + LanguagePairDataset, + TransformEosDataset, + data_utils, + noising, +) + + +class TestDataNoising(unittest.TestCase): + def _get_test_data_with_bpe_cont_marker(self, append_eos=True): + """ + Args: + append_eos: if True, each input sentence in the source tokens tensor + will have an EOS appended to the end. + + Returns: + vocabs: BPE vocab with continuation markers as suffixes to denote + non-end of word tokens. This is the standard BPE format used in + fairseq's preprocessing. + x: input tensor containing numberized source tokens, with EOS at the + end if append_eos is true + src_lengths: and source lengths. + """ + vocab = Dictionary() + vocab.add_symbol("he@@") + vocab.add_symbol("llo") + vocab.add_symbol("how") + vocab.add_symbol("are") + vocab.add_symbol("y@@") + vocab.add_symbol("ou") + vocab.add_symbol("n@@") + vocab.add_symbol("ew") + vocab.add_symbol("or@@") + vocab.add_symbol("k") + + src_tokens = [ + ["he@@", "llo", "n@@", "ew", "y@@", "or@@", "k"], + ["how", "are", "y@@", "ou"], + ] + x, src_lengths = x, src_lengths = self._convert_src_tokens_to_tensor( + vocab=vocab, src_tokens=src_tokens, append_eos=append_eos + ) + return vocab, x, src_lengths + + def _get_test_data_with_bpe_end_marker(self, append_eos=True): + """ + Args: + append_eos: if True, each input sentence in the source tokens tensor + will have an EOS appended to the end. + + Returns: + vocabs: BPE vocab with end-of-word markers as suffixes to denote + tokens at the end of a word. This is an alternative to fairseq's + standard preprocessing framework and is not generally supported + within fairseq. + x: input tensor containing numberized source tokens, with EOS at the + end if append_eos is true + src_lengths: and source lengths. + """ + vocab = Dictionary() + vocab.add_symbol("he") + vocab.add_symbol("llo_EOW") + vocab.add_symbol("how_EOW") + vocab.add_symbol("are_EOW") + vocab.add_symbol("y") + vocab.add_symbol("ou_EOW") + vocab.add_symbol("n") + vocab.add_symbol("ew_EOW") + vocab.add_symbol("or") + vocab.add_symbol("k_EOW") + + src_tokens = [ + ["he", "llo_EOW", "n", "ew_EOW", "y", "or", "k_EOW"], + ["how_EOW", "are_EOW", "y", "ou_EOW"], + ] + x, src_lengths = x, src_lengths = self._convert_src_tokens_to_tensor( + vocab=vocab, src_tokens=src_tokens, append_eos=append_eos + ) + return vocab, x, src_lengths + + def _get_test_data_with_word_vocab(self, append_eos=True): + """ + Args: + append_eos: if True, each input sentence in the source tokens tensor + will have an EOS appended to the end. + + Returns: + vocabs: word vocab + x: input tensor containing numberized source tokens, with EOS at the + end if append_eos is true + src_lengths: and source lengths. + """ + vocab = Dictionary() + + vocab.add_symbol("hello") + vocab.add_symbol("how") + vocab.add_symbol("are") + vocab.add_symbol("you") + vocab.add_symbol("new") + vocab.add_symbol("york") + src_tokens = [ + ["hello", "new", "york", "you"], + ["how", "are", "you", "new", "york"], + ] + x, src_lengths = self._convert_src_tokens_to_tensor( + vocab=vocab, src_tokens=src_tokens, append_eos=append_eos + ) + return vocab, x, src_lengths + + def _convert_src_tokens_to_tensor( + self, vocab: Dictionary, src_tokens: List[List[str]], append_eos: bool + ): + src_len = [len(x) for x in src_tokens] + # If we have to append EOS, we include EOS in counting src length + if append_eos: + src_len = [length + 1 for length in src_len] + + x = torch.LongTensor(len(src_tokens), max(src_len)).fill_(vocab.pad()) + for i in range(len(src_tokens)): + for j in range(len(src_tokens[i])): + x[i][j] = vocab.index(src_tokens[i][j]) + if append_eos: + x[i][j + 1] = vocab.eos() + + x = x.transpose(1, 0) + return x, torch.LongTensor(src_len) + + def assert_eos_at_end(self, x, x_len, eos): + """Asserts last token of every sentence in x is EOS """ + for i in range(len(x_len)): + self.assertEqual( + x[x_len[i] - 1][i], + eos, + ( + "Expected eos (token id {eos}) at the end of sentence {i} " + "but got {other} instead" + ).format(i=i, eos=eos, other=x[i][-1]), + ) + + def assert_word_dropout_correct(self, x, x_noised, x_len, l_noised): + # Expect only the first word (2 bpe tokens) of the first example + # was dropped out + self.assertEqual(x_len[0] - 2, l_noised[0]) + for i in range(l_noised[0]): + self.assertEqual(x_noised[i][0], x[i + 2][0]) + + def test_word_dropout_with_eos(self): + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True) + + with data_utils.numpy_seed(1234): + noising_gen = noising.WordDropout(vocab) + x_noised, l_noised = noising_gen.noising(x, x_len, 0.2) + self.assert_word_dropout_correct( + x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised + ) + self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos()) + + def assert_word_blanking_correct(self, x, x_noised, x_len, l_noised, unk): + # Expect only the first word (2 bpe tokens) of the first example + # was blanked out + self.assertEqual(x_len[0], l_noised[0]) + for i in range(l_noised[0]): + if i < 2: + self.assertEqual(x_noised[i][0], unk) + else: + self.assertEqual(x_noised[i][0], x[i][0]) + + def test_word_blank_with_eos(self): + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True) + + with data_utils.numpy_seed(1234): + noising_gen = noising.WordDropout(vocab) + x_noised, l_noised = noising_gen.noising(x, x_len, 0.2, vocab.unk()) + self.assert_word_blanking_correct( + x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised, unk=vocab.unk() + ) + self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos()) + + def generate_unchanged_shuffle_map(self, length): + return {i: i for i in range(length)} + + def assert_word_shuffle_matches_expected( + self, + x, + x_len, + max_shuffle_distance: int, + vocab: Dictionary, + expected_shufle_maps: List[Dict[int, int]], + expect_eos_at_end: bool, + bpe_end_marker=None, + ): + """ + This verifies that with a given x, x_len, max_shuffle_distance, and + vocab, we get the expected shuffle result. + + Args: + x: Tensor of shape (T x B) = (sequence_length, batch_size) + x_len: Tensor of length B = batch_size + max_shuffle_distance: arg to pass to noising + expected_shuffle_maps: List[mapping] where mapping is a + Dict[old_index, new_index], mapping x's elements from their + old positions in x to their new positions in x. + expect_eos_at_end: if True, check the output to make sure there is + an EOS at the end. + bpe_end_marker: str denoting the BPE end token. If this is not None, we + set the BPE cont token to None in the noising classes. + """ + bpe_cont_marker = None + if bpe_end_marker is None: + bpe_cont_marker = "@@" + + with data_utils.numpy_seed(1234): + word_shuffle = noising.WordShuffle( + vocab, bpe_cont_marker=bpe_cont_marker, bpe_end_marker=bpe_end_marker + ) + x_noised, l_noised = word_shuffle.noising( + x, x_len, max_shuffle_distance=max_shuffle_distance + ) + + # For every example, we have a different expected shuffle map. We check + # that each example is shuffled as expected according to each + # corresponding shuffle map. + for i in range(len(expected_shufle_maps)): + shuffle_map = expected_shufle_maps[i] + for k, v in shuffle_map.items(): + self.assertEqual(x[k][i], x_noised[v][i]) + + # Shuffling should not affect the length of each example + for pre_shuffle_length, post_shuffle_length in zip(x_len, l_noised): + self.assertEqual(pre_shuffle_length, post_shuffle_length) + if expect_eos_at_end: + self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos()) + + def test_word_shuffle_with_eos(self): + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True) + + # Assert word shuffle with max shuffle distance 0 causes input to be + # unchanged + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + max_shuffle_distance=0, + vocab=vocab, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(example_len) + for example_len in x_len + ], + expect_eos_at_end=True, + ) + + # Assert word shuffle with max shuffle distance 3 matches our expected + # shuffle order + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + vocab=vocab, + max_shuffle_distance=3, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(x_len[0]), + {0: 0, 1: 3, 2: 1, 3: 2}, + ], + expect_eos_at_end=True, + ) + + def test_word_shuffle_with_eos_nonbpe(self): + """The purpose of this is to test shuffling logic with word vocabs""" + vocab, x, x_len = self._get_test_data_with_word_vocab(append_eos=True) + + # Assert word shuffle with max shuffle distance 0 causes input to be + # unchanged + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + max_shuffle_distance=0, + vocab=vocab, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(example_len) + for example_len in x_len + ], + expect_eos_at_end=True, + ) + + # Assert word shuffle with max shuffle distance 3 matches our expected + # shuffle order + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + vocab=vocab, + max_shuffle_distance=3, + expected_shufle_maps=[ + {0: 0, 1: 1, 2: 3, 3: 2}, + {0: 0, 1: 2, 2: 1, 3: 3, 4: 4}, + ], + expect_eos_at_end=True, + ) + + def test_word_shuffle_without_eos(self): + """Same result as word shuffle with eos except no EOS at end""" + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False) + + # Assert word shuffle with max shuffle distance 0 causes input to be + # unchanged + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + max_shuffle_distance=0, + vocab=vocab, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(example_len) + for example_len in x_len + ], + expect_eos_at_end=False, + ) + + # Assert word shuffle with max shuffle distance 3 matches our expected + # shuffle order + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + vocab=vocab, + max_shuffle_distance=3, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(x_len[0]), + {0: 0, 1: 3, 2: 1, 3: 2}, + ], + expect_eos_at_end=False, + ) + + def test_word_shuffle_without_eos_with_bpe_end_marker(self): + """Same result as word shuffle without eos except using BPE end token""" + vocab, x, x_len = self._get_test_data_with_bpe_end_marker(append_eos=False) + + # Assert word shuffle with max shuffle distance 0 causes input to be + # unchanged + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + max_shuffle_distance=0, + vocab=vocab, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(example_len) + for example_len in x_len + ], + expect_eos_at_end=False, + bpe_end_marker="_EOW", + ) + + # Assert word shuffle with max shuffle distance 3 matches our expected + # shuffle order + self.assert_word_shuffle_matches_expected( + x=x, + x_len=x_len, + vocab=vocab, + max_shuffle_distance=3, + expected_shufle_maps=[ + self.generate_unchanged_shuffle_map(x_len[0]), + {0: 0, 1: 3, 2: 1, 3: 2}, + ], + expect_eos_at_end=False, + bpe_end_marker="_EOW", + ) + + def assert_no_eos_at_end(self, x, x_len, eos): + """Asserts that the last token of each sentence in x is not EOS """ + for i in range(len(x_len)): + self.assertNotEqual( + x[x_len[i] - 1][i], + eos, + "Expected no eos (token id {eos}) at the end of sentence {i}.".format( + eos=eos, i=i + ), + ) + + def test_word_dropout_without_eos(self): + """Same result as word dropout with eos except no EOS at end""" + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False) + + with data_utils.numpy_seed(1234): + noising_gen = noising.WordDropout(vocab) + x_noised, l_noised = noising_gen.noising(x, x_len, 0.2) + self.assert_word_dropout_correct( + x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised + ) + self.assert_no_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos()) + + def test_word_blank_without_eos(self): + """Same result as word blank with eos except no EOS at end""" + vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False) + + with data_utils.numpy_seed(1234): + noising_gen = noising.WordDropout(vocab) + x_noised, l_noised = noising_gen.noising(x, x_len, 0.2, vocab.unk()) + self.assert_word_blanking_correct( + x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised, unk=vocab.unk() + ) + self.assert_no_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos()) + + def _get_noising_dataset_batch( + self, + src_tokens_no_pad, + src_dict, + append_eos_to_tgt=False, + ): + """ + Constructs a NoisingDataset and the corresponding + ``LanguagePairDataset(NoisingDataset(src), src)``. If + *append_eos_to_tgt* is True, wrap the source dataset in + :class:`TransformEosDataset` to append EOS to the clean source when + using it as the target. + """ + src_dataset = test_utils.TestDataset(data=src_tokens_no_pad) + + noising_dataset = noising.NoisingDataset( + src_dataset=src_dataset, + src_dict=src_dict, + seed=1234, + max_word_shuffle_distance=3, + word_dropout_prob=0.2, + word_blanking_prob=0.2, + noising_class=noising.UnsupervisedMTNoising, + ) + tgt = src_dataset + language_pair_dataset = LanguagePairDataset( + src=noising_dataset, tgt=tgt, src_sizes=None, src_dict=src_dict + ) + language_pair_dataset = TransformEosDataset( + language_pair_dataset, + src_dict.eos(), + append_eos_to_tgt=append_eos_to_tgt, + ) + + dataloader = torch.utils.data.DataLoader( + dataset=language_pair_dataset, + batch_size=2, + collate_fn=language_pair_dataset.collater, + ) + denoising_batch_result = next(iter(dataloader)) + return denoising_batch_result + + def test_noising_dataset_with_eos(self): + src_dict, src_tokens, _ = self._get_test_data_with_bpe_cont_marker( + append_eos=True + ) + + # Format data for src_dataset + src_tokens = torch.t(src_tokens) + src_tokens_no_pad = [] + for src_sentence in src_tokens: + src_tokens_no_pad.append( + utils.strip_pad(tensor=src_sentence, pad=src_dict.pad()) + ) + denoising_batch_result = self._get_noising_dataset_batch( + src_tokens_no_pad=src_tokens_no_pad, src_dict=src_dict + ) + + eos, pad = src_dict.eos(), src_dict.pad() + + # Generated noisy source as source + expected_src = torch.LongTensor( + [[4, 5, 10, 11, 8, 12, 13, eos], [pad, pad, pad, 6, 8, 9, 7, eos]] + ) + # Original clean source as target (right-padded) + expected_tgt = torch.LongTensor( + [[4, 5, 10, 11, 8, 12, 13, eos], [6, 7, 8, 9, eos, pad, pad, pad]] + ) + generated_src = denoising_batch_result["net_input"]["src_tokens"] + tgt_tokens = denoising_batch_result["target"] + + self.assertTensorEqual(expected_src, generated_src) + self.assertTensorEqual(expected_tgt, tgt_tokens) + + def test_noising_dataset_without_eos(self): + """ + Similar to test noising dataset with eos except that we have to set + *append_eos_to_tgt* to ``True``. + """ + + src_dict, src_tokens, _ = self._get_test_data_with_bpe_cont_marker( + append_eos=False + ) + + # Format data for src_dataset + src_tokens = torch.t(src_tokens) + src_tokens_no_pad = [] + for src_sentence in src_tokens: + src_tokens_no_pad.append( + utils.strip_pad(tensor=src_sentence, pad=src_dict.pad()) + ) + denoising_batch_result = self._get_noising_dataset_batch( + src_tokens_no_pad=src_tokens_no_pad, + src_dict=src_dict, + append_eos_to_tgt=True, + ) + + eos, pad = src_dict.eos(), src_dict.pad() + + # Generated noisy source as source + expected_src = torch.LongTensor( + [[4, 5, 10, 11, 8, 12, 13], [pad, pad, pad, 6, 8, 9, 7]] + ) + # Original clean source as target (right-padded) + expected_tgt = torch.LongTensor( + [[4, 5, 10, 11, 8, 12, 13, eos], [6, 7, 8, 9, eos, pad, pad, pad]] + ) + + generated_src = denoising_batch_result["net_input"]["src_tokens"] + tgt_tokens = denoising_batch_result["target"] + + self.assertTensorEqual(expected_src, generated_src) + self.assertTensorEqual(expected_tgt, tgt_tokens) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_online_backtranslation.py b/fairseq/tests/test_online_backtranslation.py new file mode 100644 index 0000000000000000000000000000000000000000..0ae7e773da0ff838b3c8151bc14b84a6a9238a72 --- /dev/null +++ b/fairseq/tests/test_online_backtranslation.py @@ -0,0 +1,206 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import tempfile +import unittest +from pathlib import Path +from typing import Any, Dict, Sequence + +import fairseq.data.indexed_dataset as indexed_dataset +import fairseq.options +import fairseq.tasks.online_backtranslation as obt +import torch +from tests import utils + + +def mk_sample(tokens: Sequence[int], batch_size: int = 2) -> Dict[str, Any]: + batch = torch.stack([torch.tensor(tokens, dtype=torch.long)] * batch_size) + sample = { + "net_input": { + "src_tokens": batch, + "prev_output_tokens": batch, + "src_lengths": torch.tensor([len(tokens)] * batch_size, dtype=torch.long), + }, + "target": batch[:, 1:], + } + return sample + + +def mk_dataset(num_samples: int, max_len: int, output: Path): + output.parent.mkdir(exist_ok=True) + idx = indexed_dataset.IndexedDatasetBuilder(str(output)) + data = torch.randint(5, 100, (num_samples, max_len)) + lengths = torch.randint(3, max_len, (num_samples,)) + for d, l in zip(data, lengths): + d[0] = 0 + idx.add_item(d[:l]) + idx.finalize(output.with_suffix(".idx")) + assert output.exists() + assert output.with_suffix(".idx").exists() + + +class OnlineBacktranslationTest(unittest.TestCase): + + tmp_dir = Path(tempfile.mkdtemp(suffix="OnlineBacktranslationTest")) + + @classmethod + def obt_task( + cls, languages: Sequence[str], data: Path = None, language_mapping: str = None + ): + dict_path = cls.tmp_dir / "dict.txt" + if not dict_path.exists(): + dictionary = utils.dummy_dictionary(100) + dictionary.save(str(dict_path)) + + if data is not None: + (data / "dict.txt").write_text(dict_path.read_text()) + else: + data = cls.tmp_dir + assert len(languages) >= 2 + + kwargs = { + "arch": "transformer", + # --max-sentences=1 for better predictability of batches + "max_sentences": 1, + # Use characteristics dimensions + "encoder_layers": 3, + "encoder_embed_dim": 12, + "encoder_ffn_embed_dim": 14, + "encoder_attention_heads": 4, + "decoder_layers": 3, + "decoder_embed_dim": 12, + "decoder_output_dim": 12, + "decoder_ffn_embed_dim": 14, + "decoder_attention_heads": 4, + # Disable dropout so we have comparable tests. + "dropout": 0, + "attention_dropout": 0, + "activation_dropout": 0, + "encoder_layerdrop": 0, + } + + args = fairseq.options.get_args( + data, + task="online_backtranslation", + mono_langs=",".join(languages), + valid_lang_pairs=f"{languages[0]}-{languages[1]}", + tokens_per_sample=256, + language_mapping=language_mapping, + **kwargs, + ) + task = obt.OnlineBackTranslationTask.setup_task(args) + # we need to build the model to have the correct dictionary + model = task.build_model(task.args) + return task, model + + def tmp_path(self, test_case: str) -> Path: + return Path(tempfile.mkdtemp(test_case, dir=self.tmp_dir)) + + def test_lang_tokens(self): + task, model = self.obt_task(["en", "ro", "zh"]) + assert obt._lang_token("en") in task.dictionary + assert obt._lang_token("ro") in task.dictionary + assert obt._lang_token("zh") in task.dictionary + + en_bos = obt._lang_token_index(task.common_dict, "en") + assert "en" == task.common_dict[en_bos].strip("_") + zh_bos = obt._lang_token_index(task.common_dict, "zh") + assert "zh" == task.common_dict[zh_bos].strip("_") + zh_sample = mk_sample([zh_bos, 16, 14, 12, 10]) + + # we expect to receive the bos token for translation + assert task.get_bos_token_from_sample(zh_sample) == en_bos + + def test_backtranslate_sample(self): + task, model = self.obt_task(["en", "ro", "zh"]) + + en_bos = obt._lang_token_index(task.common_dict, "en") + zh_bos = obt._lang_token_index(task.common_dict, "zh") + sample = mk_sample([zh_bos, 16, 14, 12, 10]) + + task.backtranslate_sample(sample, "zh", "en") + target_zh = list(sample["target"][0]) + assert target_zh == [16, 14, 12, 10] # original zh sentence + generated_en = sample["net_input"]["src_tokens"][0] + assert generated_en[0] == en_bos + + def test_train_dataset(self): + data = self.tmp_path("test_train_dataset") + mk_dataset(20, 10, data / "en" / "train.bin") + mk_dataset(10, 10, data / "zh" / "train.bin") + task, model = self.obt_task(["en", "zh"], data) + task.load_dataset("train") + + en_bos = obt._lang_token_index(task.common_dict, "en") + zh_bos = obt._lang_token_index(task.common_dict, "zh") + + train = task.datasets["train"] + train.ordered_indices() + train.prefetch([0, 19]) + sample_0 = train[0] + sample_19 = train[19] + self.assertEqual( + set(sample_0.keys()), {"en-BT", "en-DENOISE", "zh-BT", "zh-DENOISE"} + ) + for sample in (sample_0, sample_19): + self.assertEqual(sample["en-BT"]["source"][0], en_bos) + # bt target isn't ready to look at. + self.assertEqual(sample["en-DENOISE"]["source"][0], en_bos) + # TODO What could we check on the target side ? + + for i in range(10): + # Zh dataset is shorter, and is wrapped around En dataset. + train.prefetch([i, i + 10]) + self.assertEqual( + list(train[i]["zh-DENOISE"]["source"]), + list(train[i + 10]["zh-DENOISE"]["source"]), + ) + self.assertEqual(train[i]["zh-DENOISE"]["source"][0].item(), zh_bos) + + # Sorted by increasing len + self.assertLess( + len(sample_0["en-BT"]["source"]), len(sample_19["en-BT"]["source"]) + ) + + def test_valid_dataset(self): + data = self.tmp_path("test_valid_dataset") + mk_dataset(10, 21, data / "valid.en-zh.en.bin") + mk_dataset(10, 21, data / "valid.en-zh.zh.bin") + + task, model = self.obt_task(["en", "zh"], data) + valid = task.load_dataset("valid") + en_bos = obt._lang_token_index(task.common_dict, "en") + + assert valid is not None + valid.prefetch(range(10)) + sample_0 = valid[0] + sample_9 = valid[9] + self.assertEqual(sample_0["id"], 0) + self.assertEqual(sample_9["id"], 9) + self.assertEqual(sample_0["source"][0], en_bos) + self.assertEqual(sample_9["source"][0], en_bos) + # TODO: could we test the target side ? + + def assertFnMatch(self, fn, values): + for x, y in values.items(): + fn_x = fn(x) + self.assertEqual(fn_x, y, f"Fn has wrong value: fn({x}) = {fn_x} != {y}") + + def test_piecewise_linear_fn(self): + self.assertFnMatch( + obt.PiecewiseLinearFn.from_string("1.0"), {0: 1, 100: 1, 500: 1, 1000: 1} + ) + self.assertFnMatch( + obt.PiecewiseLinearFn.from_string("0:1,1000:0"), + {0: 1, 500: 0.5, 1000: 0, 2000: 0}, + ) + self.assertFnMatch( + obt.PiecewiseLinearFn.from_string("0:0,1000:1"), + {0: 0, 500: 0.5, 1000: 1, 2000: 1}, + ) + self.assertFnMatch( + obt.PiecewiseLinearFn.from_string("0:0,1000:1,2000:0"), + {0: 0, 500: 0.5, 1000: 1, 1500: 0.5, 2000: 0, 3000: 0}, + ) diff --git a/fairseq/tests/test_plasma_utils.py b/fairseq/tests/test_plasma_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e6344c2a5a73fcb2fb81376e7bd43470963b3674 --- /dev/null +++ b/fairseq/tests/test_plasma_utils.py @@ -0,0 +1,126 @@ +import contextlib +import unittest +import tempfile +from io import StringIO + +import numpy as np + +from tests.utils import create_dummy_data, preprocess_lm_data, train_language_model + +try: + from pyarrow import plasma + from fairseq.data.plasma_utils import PlasmaView, PlasmaStore + + PYARROW_AVAILABLE = True +except ImportError: + PYARROW_AVAILABLE = False + +dummy_path = "dummy" + + +@unittest.skipUnless(PYARROW_AVAILABLE, "") +class TestPlasmaView(unittest.TestCase): + def setUp(self) -> None: + self.tmp_file = tempfile.NamedTemporaryFile() # noqa: P201 + self.path = self.tmp_file.name + self.server = PlasmaStore.start(path=self.path, nbytes=10000) + self.client = plasma.connect(self.path, num_retries=10) + + def tearDown(self) -> None: + self.client.disconnect() + self.tmp_file.close() + self.server.kill() + + def test_two_servers_do_not_share_object_id_space(self): + data_server_1 = np.array([0, 1]) + data_server_2 = np.array([2, 3]) + server_2_path = self.path + with tempfile.NamedTemporaryFile() as server_1_path: + server = PlasmaStore.start(path=server_1_path.name, nbytes=10000) + arr1 = PlasmaView( + data_server_1, dummy_path, 1, plasma_path=server_1_path.name + ) + assert len(arr1.client.list()) == 1 + assert (arr1.array == data_server_1).all() + arr2 = PlasmaView(data_server_2, dummy_path, 1, plasma_path=server_2_path) + assert (arr2.array == data_server_2).all() + assert (arr1.array == data_server_1).all() + server.kill() + + def test_hash_collision(self): + data_server_1 = np.array([0, 1]) + data_server_2 = np.array([2, 3]) + arr1 = PlasmaView(data_server_1, dummy_path, 1, plasma_path=self.path) + assert len(arr1.client.list()) == 1 + arr2 = PlasmaView(data_server_2, dummy_path, 1, plasma_path=self.path) + assert len(arr1.client.list()) == 1 + assert len(arr2.client.list()) == 1 + assert (arr2.array == data_server_1).all() + # New hash key based on tuples + arr3 = PlasmaView( + data_server_2, dummy_path, (1, 12312312312, None), plasma_path=self.path + ) + assert ( + len(arr2.client.list()) == 2 + ), "No new object was created by using a novel hash key" + assert ( + arr3.object_id in arr2.client.list() + ), "No new object was created by using a novel hash key" + assert ( + arr3.object_id in arr3.client.list() + ), "No new object was created by using a novel hash key" + del arr3, arr2, arr1 + + @staticmethod + def _assert_view_equal(pv1, pv2): + np.testing.assert_array_equal(pv1.array, pv2.array) + + def test_putting_same_array_twice(self): + data = np.array([4, 4, 4]) + arr1 = PlasmaView(data, dummy_path, 1, plasma_path=self.path) + assert len(self.client.list()) == 1 + arr1b = PlasmaView( + data, dummy_path, 1, plasma_path=self.path + ) # should not change contents of store + arr1c = PlasmaView( + None, dummy_path, 1, plasma_path=self.path + ) # should not change contents of store + + assert len(self.client.list()) == 1 + self._assert_view_equal(arr1, arr1b) + self._assert_view_equal(arr1, arr1c) + PlasmaView( + data, dummy_path, 2, plasma_path=self.path + ) # new object id, adds new entry + assert len(self.client.list()) == 2 + + new_client = plasma.connect(self.path) + assert len(new_client.list()) == 2 # new client can access same objects + assert isinstance(arr1.object_id, plasma.ObjectID) + del arr1b + del arr1c + + def test_plasma_store_full_raises(self): + with tempfile.NamedTemporaryFile() as new_path: + server = PlasmaStore.start(path=new_path.name, nbytes=10000) + with self.assertRaises(plasma.PlasmaStoreFull): + # 2000 floats is more than 2000 bytes + PlasmaView( + np.random.rand(10000, 1), dummy_path, 1, plasma_path=new_path.name + ) + server.kill() + + def test_object_id_overflow(self): + PlasmaView.get_object_id("", 2 ** 21) + + def test_training_lm_plasma(self): + with contextlib.redirect_stdout(StringIO()): + with tempfile.TemporaryDirectory("test_transformer_lm") as data_dir: + create_dummy_data(data_dir) + preprocess_lm_data(data_dir) + train_language_model( + data_dir, + "transformer_lm", + ["--use-plasma-view", "--plasma-path", self.path], + run_validation=True, + ) diff --git a/fairseq/tests/test_reproducibility.py b/fairseq/tests/test_reproducibility.py new file mode 100644 index 0000000000000000000000000000000000000000..94931b2a0721c4adfee8899c89cac24f45973d17 --- /dev/null +++ b/fairseq/tests/test_reproducibility.py @@ -0,0 +1,150 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import json +import os +import tempfile +import unittest +from io import StringIO + +import torch + +from . import test_binaries + + +class TestReproducibility(unittest.TestCase): + def _test_reproducibility( + self, + name, + extra_flags=None, + delta=0.0001, + resume_checkpoint="checkpoint1.pt", + max_epoch=3, + ): + def get_last_log_stats_containing_string(log_records, search_string): + for log_record in logs.records[::-1]: + if isinstance(log_record.msg, str) and search_string in log_record.msg: + return json.loads(log_record.msg) + + if extra_flags is None: + extra_flags = [] + + with tempfile.TemporaryDirectory(name) as data_dir: + with self.assertLogs() as logs: + test_binaries.create_dummy_data(data_dir) + test_binaries.preprocess_translation_data(data_dir) + + # train epochs 1 and 2 together + with self.assertLogs() as logs: + test_binaries.train_translation_model( + data_dir, + "fconv_iwslt_de_en", + [ + "--dropout", + "0.0", + "--log-format", + "json", + "--log-interval", + "1", + "--max-epoch", + str(max_epoch), + ] + + extra_flags, + ) + train_log = get_last_log_stats_containing_string(logs.records, "train_loss") + valid_log = get_last_log_stats_containing_string(logs.records, "valid_loss") + + # train epoch 2, resuming from previous checkpoint 1 + os.rename( + os.path.join(data_dir, resume_checkpoint), + os.path.join(data_dir, "checkpoint_last.pt"), + ) + with self.assertLogs() as logs: + test_binaries.train_translation_model( + data_dir, + "fconv_iwslt_de_en", + [ + "--dropout", + "0.0", + "--log-format", + "json", + "--log-interval", + "1", + "--max-epoch", + str(max_epoch), + ] + + extra_flags, + ) + train_res_log = get_last_log_stats_containing_string( + logs.records, "train_loss" + ) + valid_res_log = get_last_log_stats_containing_string( + logs.records, "valid_loss" + ) + + for k in ["train_loss", "train_ppl", "train_num_updates", "train_gnorm"]: + self.assertAlmostEqual( + float(train_log[k]), float(train_res_log[k]), delta=delta + ) + for k in [ + "valid_loss", + "valid_ppl", + "valid_num_updates", + "valid_best_loss", + ]: + self.assertAlmostEqual( + float(valid_log[k]), float(valid_res_log[k]), delta=delta + ) + + def test_reproducibility(self): + self._test_reproducibility("test_reproducibility") + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_reproducibility_fp16(self): + self._test_reproducibility( + "test_reproducibility_fp16", + [ + "--fp16", + "--fp16-init-scale", + "4096", + ], + delta=0.011, + ) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_reproducibility_memory_efficient_fp16(self): + self._test_reproducibility( + "test_reproducibility_memory_efficient_fp16", + [ + "--memory-efficient-fp16", + "--fp16-init-scale", + "4096", + ], + ) + + @unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU") + def test_reproducibility_amp(self): + self._test_reproducibility( + "test_reproducibility_amp", + [ + "--amp", + "--fp16-init-scale", + "4096", + ], + delta=0.011, + ) + + def test_mid_epoch_reproducibility(self): + self._test_reproducibility( + "test_mid_epoch_reproducibility", + ["--save-interval-updates", "3"], + resume_checkpoint="checkpoint_1_3.pt", + max_epoch=1, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_resampling_dataset.py b/fairseq/tests/test_resampling_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ccb53a253ce6ca0d8e972adfa708144b4299b3cb --- /dev/null +++ b/fairseq/tests/test_resampling_dataset.py @@ -0,0 +1,103 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import collections +import unittest + +import numpy as np +from fairseq.data import ListDataset, ResamplingDataset + + +class TestResamplingDataset(unittest.TestCase): + def setUp(self): + self.strings = ["ab", "c", "def", "ghij"] + self.weights = [4.0, 2.0, 7.0, 1.5] + self.size_ratio = 2 + self.dataset = ListDataset( + self.strings, np.array([len(s) for s in self.strings]) + ) + + def _test_common(self, resampling_dataset, iters): + assert len(self.dataset) == len(self.strings) == len(self.weights) + assert len(resampling_dataset) == self.size_ratio * len(self.strings) + + results = {"ordered_by_size": True, "max_distribution_diff": 0.0} + + totalfreqs = 0 + freqs = collections.defaultdict(int) + + for epoch_num in range(iters): + resampling_dataset.set_epoch(epoch_num) + + indices = resampling_dataset.ordered_indices() + assert len(indices) == len(resampling_dataset) + + prev_size = -1 + + for i in indices: + cur_size = resampling_dataset.size(i) + # Make sure indices map to same sequences within an epoch + assert resampling_dataset[i] == resampling_dataset[i] + + # Make sure length of sequence is correct + assert cur_size == len(resampling_dataset[i]) + + freqs[resampling_dataset[i]] += 1 + totalfreqs += 1 + + if prev_size > cur_size: + results["ordered_by_size"] = False + + prev_size = cur_size + + assert set(freqs.keys()) == set(self.strings) + for s, weight in zip(self.strings, self.weights): + freq = freqs[s] / totalfreqs + expected_freq = weight / sum(self.weights) + results["max_distribution_diff"] = max( + results["max_distribution_diff"], abs(expected_freq - freq) + ) + + return results + + def test_resampling_dataset_batch_by_size_false(self): + resampling_dataset = ResamplingDataset( + self.dataset, + self.weights, + size_ratio=self.size_ratio, + batch_by_size=False, + seed=0, + ) + + results = self._test_common(resampling_dataset, iters=1000) + + # For batch_by_size = False, the batches should be returned in + # arbitrary order of size. + assert not results["ordered_by_size"] + + # Allow tolerance in distribution error of 2%. + assert results["max_distribution_diff"] < 0.02 + + def test_resampling_dataset_batch_by_size_true(self): + resampling_dataset = ResamplingDataset( + self.dataset, + self.weights, + size_ratio=self.size_ratio, + batch_by_size=True, + seed=0, + ) + + results = self._test_common(resampling_dataset, iters=1000) + + # For batch_by_size = True, the batches should be returned in + # increasing order of size. + assert results["ordered_by_size"] + + # Allow tolerance in distribution error of 2%. + assert results["max_distribution_diff"] < 0.02 + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_roberta.py b/fairseq/tests/test_roberta.py new file mode 100644 index 0000000000000000000000000000000000000000..b0b9cfd31e8cb1e03ae74403886d2fb5266e0443 --- /dev/null +++ b/fairseq/tests/test_roberta.py @@ -0,0 +1,314 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import functools +import unittest +from typing import Any, Dict, Sequence + +import fairseq +import fairseq.options +import fairseq.tasks +import torch +from tests.utils import dummy_dictionary + +VOCAB_SIZE = 100 + + +@fairseq.tasks.register_task("fake_task") +class FakeTask(fairseq.tasks.LegacyFairseqTask): + def __init__(self, args): + super().__init__(args) + self.dictionary = dummy_dictionary(VOCAB_SIZE - 4) + assert len(self.dictionary) == VOCAB_SIZE + + @property + def source_dictionary(self): + return self.dictionary + + @property + def target_dictionary(self): + return self.dictionary + + +@functools.lru_cache() +def get_toy_model( + device: str, + architecture: str = "roberta_enc_dec", + **extra_args: Any, +): + assert device in ("gpu", "cpu") + kwargs = { + "arch": architecture, + # Use characteristics dimensions + "encoder_layers": 3, + "encoder_embed_dim": 12, + "encoder_ffn_embed_dim": 14, + "encoder_attention_heads": 4, + "decoder_layers": 3, + "decoder_embed_dim": 12, + "decoder_ffn_embed_dim": 14, + "decoder_attention_heads": 4, + # Disable dropout so we have comparable tests. + "dropout": 0, + "attention_dropout": 0, + "activation_dropout": 0, + "encoder_layerdrop": 0, + # required args + "tokens_per_sample": 256, + "data": "/tmp/test_roberta", + } + kwargs.update(extra_args) + fake_task = FakeTask(kwargs) + args = fairseq.options.get_args( + task="online_backtranslation", + mono_langs="en,ro", + valid_lang_pairs="en-ro", + **kwargs, + ) + torch.manual_seed(0) + model = fake_task.build_model(args) + if device == "gpu": + model.cuda() + return fake_task, model + + +def mk_sample( + lang: str, device: str, tok: Sequence[int] = None, batch_size: int = 2 +) -> Dict[str, Any]: + assert device in ("gpu", "cpu") + if not tok: + if lang == "en": + tok = [10, 11, 12, 13, 14, 15, 2] + else: + tok = [20, 21, 22, 23, 24, 25, 26, 27, 2] + + batch = torch.stack([torch.tensor(tok, dtype=torch.long)] * batch_size) + if device == "gpu": + batch = batch.cuda() + sample = { + "net_input": { + "src_tokens": batch, + "prev_output_tokens": batch, + "src_lengths": torch.tensor( + [len(tok)] * batch_size, dtype=torch.long, device=batch.device + ), + }, + "target": batch[:, 1:], + } + return sample + + +def cpu_gpu(fn): + def helper(self): + fn(self, "cpu") + if torch.cuda.is_available(): + fn(self, "gpu") + + return helper + + +def architectures(fn): + def helper(self): + for arch in ["roberta_enc_dec", "transformer"]: + fn(self, arch) + + return helper + + +class RobertaTest(unittest.TestCase): + def assertTensorEqual(self, t1, t2, delta: float = 1e-6): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + if delta == 0.0: + self.assertEqual(t1.ne(t2).long().sum(), 0) + else: + self.assertEqual(((t2 - t1).abs() > delta).long().sum(), 0) + + def assertSharing(self, model, link_groups: Sequence[Sequence[str]]): + ids = {} + for group in link_groups: + group_ids = {name: id(params(model, name)) for name in group} + shared_id = group_ids[group[0]] + self.assertEqual(group_ids, {name: shared_id for name in group}) + self.assertNotIn(shared_id, ids) + ids[shared_id] = group + + def test_roberta_shared_params(self): + _, roberta = get_toy_model("cpu", architecture="roberta") + self.assertSharing( + roberta, + [ + [ + "encoder.sentence_encoder.embed_tokens.weight", + "encoder.lm_head.weight", + ] + ], + ) + + _, roberta = get_toy_model( + "cpu", architecture="roberta", untie_weights_roberta=True + ) + self.assertSharing( + roberta, + [ + ["encoder.sentence_encoder.embed_tokens.weight"], + ["encoder.lm_head.weight"], + ], + ) + + def test_roberta_enc_dec_shared_params(self): + # 3 distinct embeddings + _, enc_dec = get_toy_model("cpu", architecture="roberta_enc_dec") + self.assertSharing( + enc_dec, + [ + ["encoder.embed_tokens.weight"], + ["decoder.embed_tokens.weight"], + ["decoder.output_projection.weight"], + ], + ) + + # 2 distinct embeddings, one for encoder, one for decoder + _, enc_dec = get_toy_model( + "cpu", architecture="roberta_enc_dec", share_decoder_input_output_embed=True + ) + self.assertSharing( + enc_dec, + [ + ["encoder.embed_tokens.weight"], + [ + "decoder.embed_tokens.weight", + "decoder.output_projection.weight", + ], + ], + ) + + # shared embeddings + _, enc_dec = get_toy_model( + "cpu", architecture="roberta_enc_dec", share_all_embeddings=True + ) + self.assertSharing( + enc_dec, + [ + [ + "encoder.embed_tokens.weight", + "decoder.embed_tokens.weight", + "decoder.output_projection.weight", + ] + ], + ) + + def test_roberta_max_positions_is_correctly_set(self): + device = "cpu" + task, model = get_toy_model(device) + max_pos = model.max_decoder_positions() + self.assertEqual(max_pos, 256) + self.assertEqual(max_pos, model.decoder.max_positions()) + self.assertEqual(max_pos, model.encoder.max_positions()) + self.assertEqual(max_pos, model.encoder.embed_positions.max_positions) + + sentence = [31 for _ in range(max_pos)] + sample = mk_sample("en", device, sentence, batch_size=1) + self.assertEqual(list(sample["net_input"]["src_lengths"]), [max_pos]) + self.assertEqual(len(sample["net_input"]["src_tokens"][0]), max_pos) + x, _ = model.forward(**sample["net_input"]) + self.assertEqual(x.shape, (1, max_pos, VOCAB_SIZE)) + + @cpu_gpu + def test_roberta_forward_backward(self, device: str): + _, model = get_toy_model(device) + sample = mk_sample("en", device) + en_tokens = sample["net_input"]["src_tokens"] + (bs, l) = en_tokens.shape + # Forward + logits, _ = model(**sample["net_input"]) + self.assertEqual(logits.shape, (bs, l, VOCAB_SIZE)) + + # Backward + loss = logits.sum() + loss.backward() + + @cpu_gpu + def test_roberta_forward_backward_bs1(self, device: str): + _, model = get_toy_model(device) + sample = mk_sample("en", device, batch_size=1) + o, _ = model.forward(**sample["net_input"]) + loss = o.sum() + sample2 = mk_sample("ro", device, batch_size=1) + o, _ = model.forward(**sample2["net_input"]) + loss += o.sum() + loss.backward() + + @cpu_gpu + def test_roberta_batching(self, device: str): + """ + Checks that the batch of size 2 give twice the same results than the batch of size 1. + """ + _, model = get_toy_model(device) + sample = mk_sample("en", device, batch_size=1) + slen = sample["net_input"]["src_lengths"][0] + sample2 = mk_sample("en", device, batch_size=2) + with torch.no_grad(): + z = model.encoder.forward( + sample["net_input"]["src_tokens"], sample["net_input"]["src_lengths"] + ) + z = z["encoder_out"][-1] + logits, _ = model.forward(**sample["net_input"]) + + z2 = model.encoder.forward( + sample2["net_input"]["src_tokens"], sample["net_input"]["src_lengths"] + ) + z2 = z2["encoder_out"][-1] + logits2, _ = model.forward(**sample2["net_input"]) + + self.assertEqual(z.shape, (slen, 1, 12)) + self.assertEqual(z2.shape, (slen, 2, 12)) + self.assertTensorEqual(logits2[0], logits2[1]) + self.assertTensorEqual(logits[0], logits2[0]) + + @cpu_gpu + def test_roberta_incremental_decoder(self, device: str): + """ + Checks that incremental decoding yields the same result than non incremental one. + """ + task, model = get_toy_model(device) + + en_sample = mk_sample("en", device) + en_tokens = en_sample["net_input"]["src_tokens"] + ro_sample = mk_sample("ro", device) + ro_tokens = ro_sample["net_input"]["src_tokens"] + + en_enc = model.encoder.forward( + en_tokens, src_lengths=en_sample["net_input"]["src_lengths"] + ) + (bs, tgt_len) = ro_tokens.shape + + # Decode without incremental state + ro_dec, _ = model.decoder.forward(ro_tokens, encoder_out=en_enc) + self.assertEqual(ro_dec.shape, (bs, tgt_len, VOCAB_SIZE)) + self.assertTensorEqual(ro_dec[0], ro_dec[1]) + + # Decode with incremental state + inc_state = {} + ro_dec_inc = [] + for l in range(tgt_len): + ro, _ = model.decoder.forward( + ro_tokens[:, : l + 1], encoder_out=en_enc, incremental_state=inc_state + ) + self.assertEqual(ro.shape, (bs, 1, VOCAB_SIZE)) + ro_dec_inc.append(ro) + + for l in range(tgt_len): + # Intra-batch + self.assertTensorEqual(ro_dec_inc[l][0], ro_dec_inc[l][1]) + # Incremental vs non-incremental + self.assertTensorEqual(ro_dec_inc[l][:, 0], ro_dec[:, l]) + + +def params(model, name): + if "." not in name: + return getattr(model, name) + + prefix, name = name.split(".", 1) + return params(getattr(model, prefix), name) diff --git a/fairseq/tests/test_sequence_generator.py b/fairseq/tests/test_sequence_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..9273191962089816edffaa5d0c9c90cb0c3f3c1a --- /dev/null +++ b/fairseq/tests/test_sequence_generator.py @@ -0,0 +1,799 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import tempfile +import unittest +import math +import numpy as np + + +import tests.utils as test_utils +import torch +from fairseq import search +from fairseq.data.dictionary import Dictionary +from fairseq.models.transformer import TransformerModel +from fairseq.sequence_generator import EnsembleModel, SequenceGenerator +from fairseq.ngram_repeat_block import NGramRepeatBlock +from fairseq.tasks.fairseq_task import LegacyFairseqTask + + +DEFAULT_TEST_VOCAB_SIZE = 100 + + +class DummyTask(LegacyFairseqTask): + def __init__(self, args): + super().__init__(args) + self.dictionary = get_dummy_dictionary() + if getattr(self.args, "ctc", False): + self.dictionary.add_symbol("<ctc_blank>") + self.src_dict = self.dictionary + self.tgt_dict = self.dictionary + + @property + def source_dictionary(self): + return self.src_dict + + @property + def target_dictionary(self): + return self.dictionary + + +def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE): + dummy_dict = Dictionary() + # add dummy symbol to satisfy vocab size + for id, _ in enumerate(range(vocab_size)): + dummy_dict.add_symbol("{}".format(id), n=1000) + return dummy_dict + + +def get_dummy_task_and_parser(): + """ + to build a fariseq model, we need some dummy parse and task. This function + is used to create dummy task and parser to faciliate model/criterion test + + Note: we use FbSpeechRecognitionTask as the dummy task. You may want + to use other task by providing another function + """ + parser = argparse.ArgumentParser( + description="test_dummy_s2s_task", argument_default=argparse.SUPPRESS + ) + DummyTask.add_args(parser) + args = parser.parse_args([]) + task = DummyTask.setup_task(args) + return task, parser + + +class TestJitSequenceGeneratorBase(unittest.TestCase): + def setUp(self): + self.task, self.parser = get_dummy_task_and_parser() + eos = self.task.tgt_dict.eos() + src_tokens = torch.randint(3, 50, (2, 10)).long() + src_tokens = torch.cat((src_tokens, torch.LongTensor([[eos], [eos]])), -1) + src_lengths = torch.LongTensor([2, 10]) + self.sample = { + "net_input": {"src_tokens": src_tokens, "src_lengths": src_lengths} + } + TransformerModel.add_args(self.parser) + args = self.parser.parse_args([]) + args.encoder_layers = 2 + args.decoder_layers = 1 + self.transformer_model = TransformerModel.build_model(args, self.task) + + def assertOutputEqual(self, hypo, pos_probs): + pos_scores = torch.FloatTensor(pos_probs).log() + self.assertTensorSizeEqual(hypo["positional_scores"], pos_scores) + self.assertTensorSizeEqual(pos_scores.numel(), hypo["tokens"].numel()) + + def assertTensorSizeEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-4) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + def assertHypoEqual(self, h1, h2): + "Check two hypos are equal" + self.assertTensorEqual(h1["tokens"], h2["tokens"]) + self.assertAlmostEqual(h1["positional_scores"], h2["positional_scores"]) + self.assertLess(abs(h1["score"] - h2["score"]), 1e-6) + self.assertAlmostEqual(h1["attention"], h2["attention"]) + + def _test_save_and_load(self, scripted_module): + with tempfile.NamedTemporaryFile() as f: + scripted_module.save(f.name) + torch.jit.load(f.name) + + +JIT_MSG = "Targeting OSS scriptability for the 1.6 release" + + +@unittest.skipIf(torch.__version__ < "1.6.0", JIT_MSG) +class TestJitSequenceGenerator(TestJitSequenceGeneratorBase): + def test_export_transformer(self): + model = self.transformer_model + torch.jit.script(model) + + def test_ensemble_sequence_generator(self): + model = self.transformer_model + generator = SequenceGenerator( + [model], + self.task.tgt_dict, + beam_size=2, + no_repeat_ngram_size=2, + max_len_b=10, + ) + scripted_model = torch.jit.script(generator) + self._test_save_and_load(scripted_model) + + def test_export_ensemble_model(self): + model = self.transformer_model + ensemble_models = EnsembleModel([model]) + torch.jit.script(ensemble_models) + + +class TestExportSearch(unittest.TestCase): + def setUp(self): + task, _ = get_dummy_task_and_parser() + self.tgt_dict = task.tgt_dict + self.min_top1_prob = 0.4 + + def test_export_diverse_bs(self): + search_strategy = search.DiverseBeamSearch( + self.tgt_dict, num_groups=2, diversity_strength=0.0 + ) + torch.jit.script(search_strategy) + + def test_export_sampling(self): + low_sampling_topp = self.min_top1_prob / 2.0 + search_strategy = search.Sampling( + self.tgt_dict, sampling_topp=low_sampling_topp + ) + torch.jit.script(search_strategy) + + def test_export_diverse_siblings_search(self): + search_strategy = search.DiverseSiblingsSearch( + self.tgt_dict, diversity_rate=0.5 + ) + torch.jit.script(search_strategy) + + +class TestSequenceGeneratorBase(unittest.TestCase): + def assertHypoTokens(self, hypo, tokens): + self.assertTensorEqual(hypo["tokens"], torch.LongTensor(tokens)) + + def assertHypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0): + pos_scores = torch.FloatTensor(pos_probs).log() + self.assertAlmostEqual(hypo["positional_scores"], pos_scores) + self.assertEqual(pos_scores.numel(), hypo["tokens"].numel()) + score = pos_scores.sum() + if normalized: + score /= pos_scores.numel() ** lenpen + self.assertLess(abs(score - hypo["score"]), 1e-6) + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-4) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + +class TestSequenceGenerator(TestSequenceGeneratorBase): + def setUp(self): + ( + self.tgt_dict, + self.w1, + self.w2, + src_tokens, + src_lengths, + self.model, + ) = test_utils.sequence_generator_setup() + self.sample = { + "net_input": {"src_tokens": src_tokens, "src_lengths": src_lengths} + } + + def test_with_normalization(self): + generator = SequenceGenerator([self.model], self.tgt_dict, beam_size=2) + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 1.0]) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos]) + self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0]) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, w1, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.4, 1.0]) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w2, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.6]) + + def test_without_normalization(self): + # Sentence 1: unchanged from the normalized case + # Sentence 2: beams swap order + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, normalize_scores=False + ) + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 1.0], normalized=False) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos]) + self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0], normalized=False) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6], normalized=False) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w2, w1, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.4, 1.0], normalized=False) + + def test_with_lenpen_favoring_short_hypos(self): + lenpen = 0.6 + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, len_penalty=lenpen + ) + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 1.0], lenpen=lenpen) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w2, w1, w2, eos]) + self.assertHypoScore(hypos[0][1], [0.1, 0.9, 0.9, 1.0], lenpen=lenpen) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6], lenpen=lenpen) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w2, w1, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.4, 1.0], lenpen=lenpen) + + def test_with_lenpen_favoring_long_hypos(self): + lenpen = 5.0 + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, len_penalty=lenpen + ) + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w2, w1, w2, eos]) + self.assertHypoScore(hypos[0][0], [0.1, 0.9, 0.9, 1.0], lenpen=lenpen) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w1, eos]) + self.assertHypoScore(hypos[0][1], [0.9, 1.0], lenpen=lenpen) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, w1, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.4, 1.0], lenpen=lenpen) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w2, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.6], lenpen=lenpen) + + def test_maxlen(self): + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, max_len_b=2 + ) + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 1.0]) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w2, w2, eos]) + self.assertHypoScore(hypos[0][1], [0.1, 0.1, 0.6]) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.6]) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w2, w2, eos]) + self.assertHypoScore(hypos[1][1], [0.3, 0.9, 0.01]) + + def test_encoder_with_different_output_len(self): + args = self.model.encoder.args + task = test_utils.TestTranslationTask.setup_task( + args, self.tgt_dict, self.tgt_dict + ) + reshaping_model = test_utils.TestReshapingModel.build_model(args, task) + generator = SequenceGenerator( + [reshaping_model], self.tgt_dict, beam_size=2, max_len_b=2 + ) + hypos = generator.forward(self.sample) + for sent in [0, 1]: + for beam in [0, 1]: + assert hypos[sent][beam]["attention"] is not None + + def test_generation_with_additional_input(self): + args = self.model.encoder.args + task = test_utils.TestTranslationTask.setup_task( + args, self.tgt_dict, self.tgt_dict + ) + add_input_model = test_utils.TestAdditionalInputModel.build_model(args, task) + generator = SequenceGenerator([add_input_model], self.tgt_dict, beam_size=2) + sample = self.sample.copy() + sample["net_input"]["fancy_other_input"] = sample["net_input"]["src_tokens"] + hypos = generator.forward(self.sample) + eos, w1, w2 = self.tgt_dict.eos(), self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 1.0]) + + +@unittest.skipUnless(torch.cuda.is_available(), "") +class TestRepeatNgramBlocking(TestSequenceGeneratorBase): + @classmethod + def setUpClass(cls): + ( + cls.tgt_dict, + cls.w1, + cls.w2, + src_tokens, + src_lengths, + cls.model, + ) = test_utils.sequence_generator_setup() + return cls + + def test_finds_repetitive_tokens(self): + bsz, vocab_size, beam_size, step = 2, 4, 1, 3 + generated_tok = torch.tensor( + [[2, 2, 2, 2], [3, 3, 3, 3]], dtype=torch.long, device="cuda" + ) + lprobs = torch.zeros((beam_size * bsz, vocab_size), device="cuda") + desired_result = lprobs.new_tensor( + [[0.0, 0.0, -math.inf, 0.0], [0.0, 0.0, 0.0, -math.inf]] + ) + + cuda_ext_result, baseline_result = self._compare_cuda_ext_to_default_implem( + bsz, beam_size, generated_tok, lprobs, step, 2 + ) + self.assertTensorEqual(cuda_ext_result, desired_result) + self.assertTensorEqual(baseline_result, desired_result) + + @unittest.skipIf(torch.__version__ < "1.6.0", JIT_MSG) + def test_jit_no_extension(self): + bsz, vocab_size, beam_size, step = 2, 4, 1, 3 + generated_tok = torch.tensor( + [[2, 2, 2, 2], [3, 3, 3, 3]], dtype=torch.long, device="cuda" + ) + lprobs = torch.zeros((beam_size * bsz, vocab_size), device="cuda") + blocker = NGramRepeatBlock(2, use_extension=False) + base_result = blocker(generated_tok, lprobs.clone(), bsz, beam_size, step) + scripted_blocker = torch.jit.script(blocker) + jit_result = scripted_blocker( + generated_tok, lprobs.clone(), bsz, beam_size, step + ) + self.assertTensorEqual(base_result, jit_result) + + def test_ngram_blocking_same_as_default_implem(self): + """Test that cuda extension returns same things as default impl in many settings.""" + vocab_size = 4 + step = 6 + for _ in range(2): + block_param = np.random.choice([1, 2, 3, 4]) + batch_size = np.random.randint(1, 8) + beam_size = np.random.choice([1, 2, 4, 8]) + lprobs = torch.zeros((beam_size * batch_size, vocab_size), device="cuda") + + generated_tok = torch.tensor( + np.random.randint( + 0, vocab_size, size=(batch_size * beam_size, step + 1) + ), + device="cuda", + dtype=torch.long, + ) + self._compare_cuda_ext_to_default_implem( + batch_size, + beam_size, + generated_tok, + lprobs, + step, + block_param, + ) + + def _compare_cuda_ext_to_default_implem( + self, bsz, beam_size, generated_tok, lprobs, step, block_param + ): + """Assert that cuda extension and default implem return the same thing.""" + blocker = NGramRepeatBlock(block_param) + assert blocker.use_extension, "Extension not compiled" + cuda_ext_result = blocker( + generated_tok, + lprobs.clone(), + bsz, + beam_size, + step, + ) + blocker.use_extension = False + baseline_result = blocker( + generated_tok, + lprobs.clone(), + bsz, + beam_size, + step, + ) + self.assertTensorEqual(cuda_ext_result, baseline_result) + blocker.use_extension = True + return cuda_ext_result, baseline_result + + +class TestDiverseBeamSearch(TestSequenceGeneratorBase): + def setUp(self): + # construct dummy dictionary + d = test_utils.dummy_dictionary(vocab_size=2) + self.assertEqual(d.pad(), 1) + self.assertEqual(d.eos(), 2) + self.assertEqual(d.unk(), 3) + self.eos = d.eos() + self.w1 = 4 + self.w2 = 5 + + # construct source data + self.src_tokens = torch.LongTensor( + [ + [self.w1, self.w2, self.eos], + [self.w1, self.w2, self.eos], + ] + ) + self.src_lengths = torch.LongTensor([2, 2]) + + args = argparse.Namespace() + unk = 0.0 + args.beam_probs = [ + # step 0: + torch.FloatTensor( + [ + # eos w1 w2 + # sentence 1: + [0.0, unk, 0.9, 0.1], # beam 1 + [0.0, unk, 0.9, 0.1], # beam 2 + # sentence 2: + [0.0, unk, 0.7, 0.3], + [0.0, unk, 0.7, 0.3], + ] + ), + # step 1: + torch.FloatTensor( + [ + # eos w1 w2 + # sentence 1: + [0.0, unk, 0.6, 0.4], + [0.0, unk, 0.6, 0.4], + # sentence 2: + [0.25, unk, 0.35, 0.4], + [0.25, unk, 0.35, 0.4], + ] + ), + # step 2: + torch.FloatTensor( + [ + # eos w1 w2 + # sentence 1: + [1.0, unk, 0.0, 0.0], + [1.0, unk, 0.0, 0.0], + # sentence 2: + [0.9, unk, 0.1, 0.0], + [0.9, unk, 0.1, 0.0], + ] + ), + ] + + task = test_utils.TestTranslationTask.setup_task(args, d, d) + self.model = task.build_model(args) + self.tgt_dict = task.target_dictionary + + def test_diverse_beam_search(self): + search_strategy = search.DiverseBeamSearch( + self.tgt_dict, num_groups=2, diversity_strength=0.0 + ) + generator = SequenceGenerator( + [self.model], + self.tgt_dict, + beam_size=2, + search_strategy=search_strategy, + ) + sample = { + "net_input": { + "src_tokens": self.src_tokens, + "src_lengths": self.src_lengths, + } + } + hypos = generator.forward(sample) + eos, w1, w2 = self.eos, self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 0.6, 1.0]) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w1, w1, eos]) + self.assertHypoScore(hypos[0][1], [0.9, 0.6, 1.0]) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.9]) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w2, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.4, 0.9]) + + +class TestDiverseSiblingsSearch(TestDiverseBeamSearch): + def assertHypoScore( + self, hypo, pos_probs, sibling_rank, diversity_rate, normalized=True, lenpen=1.0 + ): + pos_scores = torch.FloatTensor(pos_probs).log() + pos_scores.sub_(torch.Tensor(sibling_rank) * diversity_rate) + self.assertAlmostEqual(hypo["positional_scores"], pos_scores) + self.assertEqual(pos_scores.numel(), hypo["tokens"].numel()) + score = pos_scores.sum() + if normalized: + score /= pos_scores.numel() ** lenpen + self.assertLess(abs(score - hypo["score"]), 1e-6) + + def test_diverse_beam_search(self): + search_strategy = search.DiverseSiblingsSearch( + self.tgt_dict, diversity_rate=0.5 + ) + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, search_strategy=search_strategy + ) + sample = { + "net_input": { + "src_tokens": self.src_tokens, + "src_lengths": self.src_lengths, + } + } + hypos = generator.forward(sample) + eos, w1, w2 = self.eos, self.w1, self.w2 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, w1, eos]) + self.assertHypoScore(hypos[0][0], [0.9, 0.6, 1.0], [0, 1, 1], 0.5) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w1, w2, eos]) + self.assertHypoScore(hypos[0][1], [0.9, 0.4, 1.0], [0, 2, 1], 0.5) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w2, eos]) + self.assertHypoScore(hypos[1][0], [0.7, 0.4, 0.9], [0, 1, 1], 0.5) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w1, eos]) + self.assertHypoScore(hypos[1][1], [0.7, 0.35, 0.9], [0, 2, 1], 0.5) + + +class TestPrefixBeamSearch(TestSequenceGeneratorBase): + def setUp(self): + # construct dummy dictionary + vocab_size = 10 + d = test_utils.dummy_dictionary(vocab_size=vocab_size) + self.assertEqual(d.pad(), 1) + self.assertEqual(d.eos(), 2) + self.assertEqual(d.unk(), 3) + self.eos = d.eos() + self.w1 = 4 + self.w2 = 5 + self.beam_size = 3 + + # construct prefix data + self.tokens = torch.LongTensor( + [ + [self.w1, self.w2, self.eos], + ] + ) + self.token_lengths = torch.LongTensor([2]) + + args = argparse.Namespace() + unk = 0.0 + args.beam_probs = [ + # prefix step 0: + torch.FloatTensor( + [ + # eos + [0.0, unk] + [1.0 / vocab_size] * vocab_size # beam 1 + ] * self.beam_size + ), + ] * vocab_size + + task = test_utils.TestTranslationTask.setup_task(args, d, d) + self.model = task.build_model(args) + self.tgt_dict = task.target_dictionary + + def test_prefix_beam_search(self): + search_strategy = search.BeamSearch(self.tgt_dict) + generator = SequenceGenerator( + [self.model], + self.tgt_dict, + beam_size=self.beam_size, + search_strategy=search_strategy, + ) + sample = { + "net_input": { + "src_tokens": self.tokens, + "src_lengths": self.token_lengths, + } + } + # make sure test sample doesn't break any assertion + generator.forward(sample, prefix_tokens=self.tokens[:, :-1]) + +class TestTopPSamplingSearch(TestSequenceGeneratorBase): + def setUp(self): + # construct dummy dictionary + d = test_utils.dummy_dictionary(vocab_size=2) + self.assertEqual(d.pad(), 1) + self.assertEqual(d.eos(), 2) + self.assertEqual(d.unk(), 3) + self.eos = d.eos() + self.w1 = 4 + self.w2 = 5 + + # construct source data + self.src_tokens = torch.LongTensor( + [ + [self.w1, self.w2, self.eos], + [self.w1, self.w2, self.eos], + ] + ) + self.src_lengths = torch.LongTensor([2, 2]) + + args = argparse.Namespace() + unk = 0.0 + # The minimal probability of top 2 tokens. + self.min_top2_prob = 0.75 + # The minimal probability of the top 1 token. + self.min_top1_prob = 0.4 + + w1_prob = self.min_top1_prob + w2_prob = self.min_top2_prob - self.min_top1_prob + eos_prob = 1 - self.min_top2_prob + + args.beam_probs = [ + # step 0: + torch.FloatTensor( + [ + # eos w1 w2 + [0.0, unk, 1.0, 0.0], + [0.0, unk, 1.0, 0.0], + [0.0, unk, 1.0, 0.0], + [0.0, unk, 1.0, 0.0], + ] + ), + # step 1: + torch.FloatTensor( + [ + # eos w1 w2 + [eos_prob, unk, w1_prob, w2_prob], + [eos_prob, unk, w1_prob, w2_prob], + [eos_prob, unk, w1_prob, w2_prob], + [eos_prob, unk, w1_prob, w2_prob], + ] + ), + # step 2: + torch.FloatTensor( + [ + # eos w1 w2 + [1.0, unk, 0.0, 0.0], + [1.0, unk, 0.0, 0.0], + [1.0, unk, 0.0, 0.0], + [1.0, unk, 0.0, 0.0], + ] + ), + ] + + task = test_utils.TestTranslationTask.setup_task(args, d, d) + self.model = task.build_model(args) + self.tgt_dict = task.target_dictionary + + def test_topp_sampling_search_low_prob(self): + # Given a prob low enough to top-P sampling, we expect only the top + # 1 token to be sampled, which always results in the same output. + low_sampling_topp = self.min_top1_prob / 2.0 + search_strategy = search.Sampling( + self.tgt_dict, sampling_topp=low_sampling_topp + ) + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, search_strategy=search_strategy + ) + sample = { + "net_input": { + "src_tokens": self.src_tokens, + "src_lengths": self.src_lengths, + } + } + hypos = generator.forward(sample) + eos, w1 = self.eos, self.w1 + # sentence 1, beam 1 + self.assertHypoTokens(hypos[0][0], [w1, w1, eos]) + self.assertHypoScore(hypos[0][0], [1.0, 0.4, 1.0]) + # sentence 1, beam 2 + self.assertHypoTokens(hypos[0][1], [w1, w1, eos]) + self.assertHypoScore(hypos[0][1], [1.0, 0.4, 1.0]) + # sentence 2, beam 1 + self.assertHypoTokens(hypos[1][0], [w1, w1, eos]) + self.assertHypoScore(hypos[1][0], [1.0, 0.4, 1.0]) + # sentence 2, beam 2 + self.assertHypoTokens(hypos[1][1], [w1, w1, eos]) + self.assertHypoScore(hypos[1][1], [1.0, 0.4, 1.0]) + + def test_topp_sampling_search_high_prob(self): + # Given a prob high enough to top-P sampling, any of the top 2 + # tokens could be sampled. This can cause different outputs. + high_sampling_topp = (self.min_top1_prob + self.min_top2_prob) / 2.0 + search_strategy = search.Sampling( + self.tgt_dict, sampling_topp=high_sampling_topp + ) + generator = SequenceGenerator( + [self.model], self.tgt_dict, beam_size=2, search_strategy=search_strategy + ) + sample = { + "net_input": { + "src_tokens": self.src_tokens, + "src_lengths": self.src_lengths, + } + } + hypos = generator.forward(sample) + eos, w1, w2 = self.eos, self.w1, self.w2 + # sentence 1, beam 1 + self.assertTrue( + self.hypoTokens(hypos[0][0], [w1, w1, eos]) + or self.hypoTokens(hypos[0][0], [w1, w2, eos]) + ) + self.assertTrue( + self.hypoScore(hypos[0][0], [1.0, 0.4, 1.0]) + or self.hypoScore(hypos[0][0], [1.0, 0.35, 1.0]) + ) + + # sentence 1, beam 2 + self.assertTrue( + self.hypoTokens(hypos[0][1], [w1, w1, eos]) + or self.hypoTokens(hypos[0][1], [w1, w2, eos]) + ) + self.assertTrue( + self.hypoScore(hypos[0][1], [1.0, 0.4, 1.0]) + or self.hypoScore(hypos[0][1], [1.0, 0.35, 1.0]) + ) + + # sentence 2, beam 1 + self.assertTrue( + self.hypoTokens(hypos[1][0], [w1, w1, eos]) + or self.hypoTokens(hypos[1][0], [w1, w2, eos]) + ) + self.assertTrue( + self.hypoScore(hypos[1][0], [1.0, 0.4, 1.0]) + or self.hypoScore(hypos[1][0], [1.0, 0.35, 1.0]) + ) + + # sentence 2, beam 2 + self.assertTrue( + self.hypoTokens(hypos[1][1], [w1, w1, eos]) + or self.hypoTokens(hypos[1][1], [w1, w2, eos]) + ) + self.assertTrue( + self.hypoScore(hypos[1][1], [1.0, 0.4, 1.0]) + or self.hypoScore(hypos[1][1], [1.0, 0.35, 1.0]) + ) + + def hypoTokens(self, hypo, tokens): + return self.tensorEqual(hypo["tokens"], torch.LongTensor(tokens)) + + def hypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0): + pos_scores = torch.FloatTensor(pos_probs).log() + if not self.almostEqual(hypo["positional_scores"], pos_scores): + return False + if pos_scores.numel() != hypo["tokens"].numel(): + return False + score = pos_scores.sum() + if normalized: + score /= pos_scores.numel() ** lenpen + return abs(score - hypo["score"]) < 1e-6 + + def almostEqual(self, t1, t2): + return t1.size() == t2.size() and (t1 - t2).abs().max() < 1e-4 + + def tensorEqual(self, t1, t2): + return t1.size() == t2.size() and t1.ne(t2).long().sum() == 0 + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_sequence_scorer.py b/fairseq/tests/test_sequence_scorer.py new file mode 100644 index 0000000000000000000000000000000000000000..42f9447b599bcd7a9913aec37d94ea5078ff43a3 --- /dev/null +++ b/fairseq/tests/test_sequence_scorer.py @@ -0,0 +1,120 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import unittest + +import tests.utils as test_utils +import torch +from fairseq.sequence_scorer import SequenceScorer + + +class TestSequenceScorer(unittest.TestCase): + def test_sequence_scorer(self): + # construct dummy dictionary + d = test_utils.dummy_dictionary(vocab_size=2) + self.assertEqual(d.pad(), 1) + self.assertEqual(d.eos(), 2) + self.assertEqual(d.unk(), 3) + eos = d.eos() + w1 = 4 + w2 = 5 + + # construct dataloader + data = [ + { + "source": torch.LongTensor([w1, w2, eos]), + "target": torch.LongTensor([w1, w2, w1, eos]), + }, + { + "source": torch.LongTensor([w2, eos]), + "target": torch.LongTensor([w2, w1, eos]), + }, + { + "source": torch.LongTensor([w2, eos]), + "target": torch.LongTensor([w2, eos]), + }, + ] + data_itr = test_utils.dummy_dataloader(data) + + # specify expected output probabilities + args = argparse.Namespace() + unk = 0.0 + args.beam_probs = [ + # step 0: + torch.FloatTensor( + [ + # eos w1 w2 + [0.0, unk, 0.6, 0.4], # sentence 1 + [0.0, unk, 0.4, 0.6], # sentence 2 + [0.0, unk, 0.7, 0.3], # sentence 3 + ] + ), + # step 1: + torch.FloatTensor( + [ + # eos w1 w2 + [0.0, unk, 0.2, 0.7], # sentence 1 + [0.0, unk, 0.8, 0.2], # sentence 2 + [0.7, unk, 0.1, 0.2], # sentence 3 + ] + ), + # step 2: + torch.FloatTensor( + [ + # eos w1 w2 + [0.10, unk, 0.50, 0.4], # sentence 1 + [0.15, unk, 0.15, 0.7], # sentence 2 + [0.00, unk, 0.00, 0.0], # sentence 3 + ] + ), + # step 3: + torch.FloatTensor( + [ + # eos w1 w2 + [0.9, unk, 0.05, 0.05], # sentence 1 + [0.0, unk, 0.00, 0.0], # sentence 2 + [0.0, unk, 0.00, 0.0], # sentence 3 + ] + ), + ] + expected_scores = [ + [0.6, 0.7, 0.5, 0.9], # sentence 1 + [0.6, 0.8, 0.15], # sentence 2 + [0.3, 0.7], # sentence 3 + ] + + task = test_utils.TestTranslationTask.setup_task(args, d, d) + model = task.build_model(args) + scorer = SequenceScorer(task.target_dictionary) + for sample in data_itr: + hypos = task.inference_step(scorer, [model], sample) + for id, hypos_id in zip(sample["id"].tolist(), hypos): + self.assertHypoTokens(hypos_id[0], data[id]["target"]) + self.assertHypoScore(hypos_id[0], expected_scores[id]) + + def assertHypoTokens(self, hypo, tokens): + self.assertTensorEqual(hypo["tokens"], torch.LongTensor(tokens)) + + def assertHypoScore(self, hypo, pos_probs, normalized=True, lenpen=1.0): + pos_scores = torch.FloatTensor(pos_probs).log() + self.assertAlmostEqual(hypo["positional_scores"], pos_scores) + self.assertEqual(pos_scores.numel(), hypo["tokens"].numel()) + score = pos_scores.sum() + if normalized: + score /= pos_scores.numel() ** lenpen + self.assertLess(abs(score - hypo["score"]), 1e-6) + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess((t1 - t2).abs().max(), 1e-4) + + def assertTensorEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertEqual(t1.ne(t2).long().sum(), 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_sparse_multihead_attention.py b/fairseq/tests/test_sparse_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..3e32b25a7fb1e12295b84d0c65064f8e42b7bdd3 --- /dev/null +++ b/fairseq/tests/test_sparse_multihead_attention.py @@ -0,0 +1,114 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq.modules.sparse_multihead_attention import SparseMultiheadAttention + + +class TestSparseMultiheadAttention(unittest.TestCase): + def test_sparse_multihead_attention(self): + attn_weights = torch.randn(1, 8, 8) + bidirectional_sparse_mask = torch.tensor( + [ + [0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0], + [0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0], + [0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0], + [0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0], + [float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0], + [float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0], + [float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0], + [float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0], + ] + ) + + bidirectional_attention = SparseMultiheadAttention( + 16, 1, stride=4, expressivity=1, is_bidirectional=True + ) + bidirectional_attention_sparse_mask = ( + bidirectional_attention.buffered_sparse_mask(attn_weights, 8, 8) + ) + torch.all( + torch.eq(bidirectional_attention_sparse_mask, bidirectional_sparse_mask) + ) + + sparse_mask = torch.tensor( + [ + [ + 0, + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + ], + [ + 0, + 0, + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + ], + [ + 0, + 0, + 0, + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + ], + [ + 0, + 0, + 0, + 0, + float("-inf"), + float("-inf"), + float("-inf"), + float("-inf"), + ], + [0, 0, 0, 0, 0, float("-inf"), float("-inf"), float("-inf")], + [ + float("-inf"), + float("-inf"), + float("-inf"), + 0, + 0, + 0, + float("-inf"), + float("-inf"), + ], + [ + float("-inf"), + float("-inf"), + float("-inf"), + 0, + 0, + 0, + 0, + float("-inf"), + ], + [float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0], + ] + ) + + attention = SparseMultiheadAttention( + 16, 1, stride=4, expressivity=1, is_bidirectional=False + ) + attention_sparse_mask = attention.buffered_sparse_mask(attn_weights, 8, 8) + + torch.all(torch.eq(attention_sparse_mask, sparse_mask)) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_token_block_dataset.py b/fairseq/tests/test_token_block_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..c4d7b76dcd55fe7869dbb1fa188f7b36fb639bda --- /dev/null +++ b/fairseq/tests/test_token_block_dataset.py @@ -0,0 +1,92 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import tests.utils as test_utils +import torch +from fairseq.data import TokenBlockDataset + + +class TestTokenBlockDataset(unittest.TestCase): + def _build_dataset(self, data, **kwargs): + sizes = [len(x) for x in data] + underlying_ds = test_utils.TestDataset(data) + return TokenBlockDataset(underlying_ds, sizes, **kwargs) + + def test_eos_break_mode(self): + data = [ + torch.tensor([5, 4, 3, 2, 1], dtype=torch.long), + torch.tensor([1], dtype=torch.long), + torch.tensor([8, 7, 6, 1], dtype=torch.long), + ] + ds = self._build_dataset(data, block_size=None, pad=0, eos=1, break_mode="eos") + self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1]) + self.assertEqual(ds[1].tolist(), [1]) + self.assertEqual(ds[2].tolist(), [8, 7, 6, 1]) + + data = [ + torch.tensor([5, 4, 3, 2, 1], dtype=torch.long), + torch.tensor([8, 7, 6, 1], dtype=torch.long), + torch.tensor([1], dtype=torch.long), + ] + ds = self._build_dataset(data, block_size=None, pad=0, eos=1, break_mode="eos") + self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1]) + self.assertEqual(ds[1].tolist(), [8, 7, 6, 1]) + self.assertEqual(ds[2].tolist(), [1]) + + def test_block_break_mode(self): + data = [ + torch.tensor([5, 4, 3, 2, 1], dtype=torch.long), + torch.tensor([8, 7, 6, 1], dtype=torch.long), + torch.tensor([9, 1], dtype=torch.long), + ] + ds = self._build_dataset(data, block_size=3, pad=0, eos=1, break_mode="none") + self.assertEqual(ds[0].tolist(), [5, 4, 3]) + self.assertEqual(ds[1].tolist(), [2, 1, 8]) + self.assertEqual(ds[2].tolist(), [7, 6, 1]) + self.assertEqual(ds[3].tolist(), [9, 1]) + + def test_complete_break_mode(self): + data = [ + torch.tensor([5, 4, 3, 2, 1], dtype=torch.long), + torch.tensor([8, 7, 6, 1], dtype=torch.long), + torch.tensor([9, 1], dtype=torch.long), + ] + ds = self._build_dataset( + data, block_size=6, pad=0, eos=1, break_mode="complete" + ) + self.assertEqual(ds[0].tolist(), [5, 4, 3, 2, 1]) + self.assertEqual(ds[1].tolist(), [8, 7, 6, 1, 9, 1]) + + data = [ + torch.tensor([4, 3, 2, 1], dtype=torch.long), + torch.tensor([5, 1], dtype=torch.long), + torch.tensor([1], dtype=torch.long), + torch.tensor([6, 1], dtype=torch.long), + ] + ds = self._build_dataset( + data, block_size=3, pad=0, eos=1, break_mode="complete" + ) + self.assertEqual(ds[0].tolist(), [4, 3, 2, 1]) + self.assertEqual(ds[1].tolist(), [5, 1, 1]) + self.assertEqual(ds[2].tolist(), [6, 1]) + + def test_4billion_tokens(self): + """Regression test for numpy type promotion issue https://github.com/numpy/numpy/issues/5745""" + data = [torch.tensor(list(range(10000)), dtype=torch.long)] * 430000 + ds = self._build_dataset( + data, block_size=6, pad=0, eos=1, break_mode="complete" + ) + ds[-1] # __getitem__ works + start, end = ds.slice_indices[-1] + assert end > 4294967295 # data must be sufficiently large to overflow uint32 + assert not isinstance( + end + 1, float + ) # this would also raise, since np.uint64(1) + 1 => 2.0 + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_train.py b/fairseq/tests/test_train.py new file mode 100644 index 0000000000000000000000000000000000000000..02ef94cc5b80c05485144db67501b2acedbaf291 --- /dev/null +++ b/fairseq/tests/test_train.py @@ -0,0 +1,247 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import contextlib +import logging +import unittest +from io import StringIO +from unittest.mock import MagicMock, patch + +import torch +from fairseq import checkpoint_utils, data +from omegaconf import OmegaConf + + +def mock_trainer(epoch, num_updates, iterations_in_epoch): + trainer = MagicMock() + trainer.load_checkpoint.return_value = { + "train_iterator": { + "epoch": epoch, + "iterations_in_epoch": iterations_in_epoch, + "shuffle": False, + }, + } + trainer.get_num_updates.return_value = num_updates + return trainer + + +def mock_dict(): + d = MagicMock() + d.pad.return_value = 1 + d.eos.return_value = 2 + d.unk.return_value = 3 + return d + + +def get_trainer_and_epoch_itr(epoch, epoch_size, num_updates, iterations_in_epoch): + tokens = torch.LongTensor(list(range(epoch_size))).view(1, -1) + tokens_ds = data.TokenBlockDataset( + tokens, + sizes=[tokens.size(-1)], + block_size=1, + pad=0, + eos=1, + include_targets=False, + ) + trainer = mock_trainer(epoch, num_updates, iterations_in_epoch) + dataset = data.LanguagePairDataset( + tokens_ds, tokens_ds.sizes, mock_dict(), shuffle=False + ) + epoch_itr = data.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=[[i] for i in range(epoch_size)], + ) + return trainer, epoch_itr + + +def get_mock_cfg(finetune_from_model): + cfg_mock = OmegaConf.create( + { + "checkpoint": { + "save_dir": None, + "optimizer_overrides": "{}", + "reset_dataloader": False, + "reset_meters": False, + "reset_optimizer": False, + "reset_lr_scheduler": False, + "finetune_from_model": finetune_from_model, + "model_parallel_size": 1, + "restore_file": "checkpoint_last.pt", + }, + "common": { + "model_parallel_size": 1, + }, + } + ) + return cfg_mock + + +class TestLoadCheckpoint(unittest.TestCase): + def setUp(self): + self.cfg_mock = get_mock_cfg(None) + self.patches = { + "os.makedirs": MagicMock(), + "os.path.join": MagicMock(), + "os.path.isfile": MagicMock(return_value=True), + "os.path.isabs": MagicMock(return_value=False), + "fairseq.file_io.PathManager.exists": MagicMock(return_value=False), + } + self.applied_patches = [patch(p, d) for p, d in self.patches.items()] + [p.start() for p in self.applied_patches] + logging.disable(logging.CRITICAL) + + def tearDown(self): + patch.stopall() + logging.disable(logging.NOTSET) + + def test_load_partial_checkpoint(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(2, 150, 200, 50) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + + _, epoch_itr = checkpoint_utils.load_checkpoint( + self.cfg_mock.checkpoint, trainer + ) + + self.assertEqual(epoch_itr.epoch, 2) + self.assertEqual(epoch_itr.iterations_in_epoch, 50) + + itr = epoch_itr.next_epoch_itr(shuffle=False) + self.assertEqual(epoch_itr.epoch, 2) + self.assertEqual(epoch_itr.iterations_in_epoch, 50) + + self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 50) + self.assertEqual(epoch_itr.iterations_in_epoch, 51) + + for _ in range(150 - 52): + next(itr) + self.assertEqual(epoch_itr.iterations_in_epoch, 149) + self.assertTrue(itr.has_next()) + next(itr) + self.assertFalse(itr.has_next()) + + itr = epoch_itr.next_epoch_itr(shuffle=False) + self.assertTrue(itr.has_next()) + self.assertEqual(epoch_itr.epoch, 3) + self.assertEqual(epoch_itr.iterations_in_epoch, 0) + + def test_load_full_checkpoint(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(2, 150, 300, 150) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + + _, epoch_itr = checkpoint_utils.load_checkpoint( + self.cfg_mock.checkpoint, trainer + ) + itr = epoch_itr.next_epoch_itr(shuffle=False) + + self.assertEqual(epoch_itr.epoch, 3) + self.assertEqual(epoch_itr.iterations_in_epoch, 0) + self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 0) + + def test_load_no_checkpoint(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + self.patches["os.path.isfile"].return_value = False + + _, epoch_itr = checkpoint_utils.load_checkpoint( + self.cfg_mock.checkpoint, trainer + ) + itr = epoch_itr.next_epoch_itr(shuffle=False) + + self.assertEqual(epoch_itr.epoch, 1) + self.assertEqual(epoch_itr.iterations_in_epoch, 0) + self.assertEqual(next(itr)["net_input"]["src_tokens"][0].item(), 0) + + def test_finetune_from_model_args_conflict(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + + for arg in [ + "reset_optimizer", + "reset_lr_scheduler", + "reset_meters", + "reset_dataloader", + ]: + with self.subTest(arg=arg): + cfg_mock = get_mock_cfg("/temp/checkpoint_pretrained.pt") + cfg_mock["checkpoint"][arg] = True + with self.assertRaises(Exception) as context: + _, _ = checkpoint_utils.load_checkpoint( + cfg_mock.checkpoint, trainer + ) + + self.assertTrue( + "--finetune-from-model can not be set together with either --reset-optimizer" + " or reset_lr_scheduler or reset_meters or reset_dataloader" + in str(context.exception) + ) + + def test_finetune_from_model(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + from_model_path = "/temp/checkpoint_pretrained.pt" + + def mock_finetune_exist(path): + if path == from_model_path: + return True + else: + return False + + self.patches[ + "fairseq.file_io.PathManager.exists" + ].side_effect = mock_finetune_exist + cfg_mock = get_mock_cfg(from_model_path) + cfg_mock.checkpoint.restore_file = "checkpoint_last.pt" + _, _ = checkpoint_utils.load_checkpoint(cfg_mock.checkpoint, trainer) + ( + checkpoint_path, + reset_optimizer, + reset_lr_scheduler, + optimizer_overrides, + ) = trainer.load_checkpoint.call_args[0] + reset_meters = trainer.load_checkpoint.call_args[1]["reset_meters"] + self.assertTrue(reset_optimizer) + self.assertTrue(reset_lr_scheduler) + self.assertTrue(reset_meters) + + def test_finetune_from_model_resume(self): + with contextlib.redirect_stdout(StringIO()): + trainer, epoch_itr = get_trainer_and_epoch_itr(1, 150, 0, 0) + trainer.get_train_iterator = MagicMock(return_value=epoch_itr) + from_model_path = "/temp/checkpoint_pretrained.pt" + + # launch second time + # both restore_file=checkpoint_last.pt and finetune_from_model are set + def mock_finetune_exist(path): + if path == from_model_path or path.endsWith("checkpoint_last.pt"): + return True + else: + return False + + self.patches[ + "fairseq.file_io.PathManager.exists" + ].side_effect = mock_finetune_exist + cfg_mock = get_mock_cfg(from_model_path) + cfg_mock.checkpoint.restore_file = "checkpoint_last.pt" + _, _ = checkpoint_utils.load_checkpoint(cfg_mock.checkpoint, trainer) + ( + checkpoint_path, + reset_optimizer, + reset_lr_scheduler, + optimizer_overrides, + ) = trainer.load_checkpoint.call_args[0] + reset_meters = trainer.load_checkpoint.call_args[1]["reset_meters"] + self.assertFalse(reset_optimizer) + self.assertFalse(reset_lr_scheduler) + self.assertFalse(reset_meters) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_transformer.py b/fairseq/tests/test_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..de5c5bdbd49692e63fb1cb50108a791304425dc1 --- /dev/null +++ b/fairseq/tests/test_transformer.py @@ -0,0 +1,65 @@ +import argparse +import unittest +from typing import Any, Dict, Sequence + +import torch +from fairseq.models import transformer + +from tests.test_roberta import FakeTask + + +def mk_sample(tok: Sequence[int] = None, batch_size: int = 2) -> Dict[str, Any]: + if not tok: + tok = [10, 11, 12, 13, 14, 15, 2] + + batch = torch.stack([torch.tensor(tok, dtype=torch.long)] * batch_size) + sample = { + "net_input": { + "src_tokens": batch, + "prev_output_tokens": batch, + "src_lengths": torch.tensor( + [len(tok)] * batch_size, dtype=torch.long, device=batch.device + ), + }, + "target": batch[:, 1:], + } + return sample + + +def mk_transformer(**extra_args: Any): + overrides = { + # Use characteristics dimensions + "encoder_embed_dim": 12, + "encoder_ffn_embed_dim": 14, + "decoder_embed_dim": 12, + "decoder_ffn_embed_dim": 14, + # Disable dropout so we have comparable tests. + "dropout": 0, + "attention_dropout": 0, + "activation_dropout": 0, + "encoder_layerdrop": 0, + } + overrides.update(extra_args) + # Overrides the defaults from the parser + args = argparse.Namespace(**overrides) + transformer.tiny_architecture(args) + + torch.manual_seed(0) + task = FakeTask(args) + return transformer.TransformerModel.build_model(args, task) + + +class TransformerTestCase(unittest.TestCase): + def test_forward_backward(self): + model = mk_transformer(encoder_embed_dim=12, decoder_embed_dim=12) + sample = mk_sample() + o, _ = model.forward(**sample["net_input"]) + loss = o.sum() + loss.backward() + + def test_different_encoder_decoder_embed_dim(self): + model = mk_transformer(encoder_embed_dim=12, decoder_embed_dim=16) + sample = mk_sample() + o, _ = model.forward(**sample["net_input"]) + loss = o.sum() + loss.backward() diff --git a/fairseq/tests/test_utils.py b/fairseq/tests/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..79195903e0f34372a24fa50312a6e00170c14471 --- /dev/null +++ b/fairseq/tests/test_utils.py @@ -0,0 +1,114 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import unittest + +import torch +from fairseq import utils + + +class TestUtils(unittest.TestCase): + def test_convert_padding_direction(self): + pad = 1 + left_pad = torch.LongTensor( + [ + [2, 3, 4, 5, 6], + [1, 7, 8, 9, 10], + [1, 1, 1, 11, 12], + ] + ) + right_pad = torch.LongTensor( + [ + [2, 3, 4, 5, 6], + [7, 8, 9, 10, 1], + [11, 12, 1, 1, 1], + ] + ) + + self.assertAlmostEqual( + right_pad, + utils.convert_padding_direction( + left_pad, + pad, + left_to_right=True, + ), + ) + self.assertAlmostEqual( + left_pad, + utils.convert_padding_direction( + right_pad, + pad, + right_to_left=True, + ), + ) + + def test_make_positions(self): + pad = 1 + left_pad_input = torch.LongTensor( + [ + [9, 9, 9, 9, 9], + [1, 9, 9, 9, 9], + [1, 1, 1, 9, 9], + ] + ) + left_pad_output = torch.LongTensor( + [ + [2, 3, 4, 5, 6], + [1, 2, 3, 4, 5], + [1, 1, 1, 2, 3], + ] + ) + right_pad_input = torch.LongTensor( + [ + [9, 9, 9, 9, 9], + [9, 9, 9, 9, 1], + [9, 9, 1, 1, 1], + ] + ) + right_pad_output = torch.LongTensor( + [ + [2, 3, 4, 5, 6], + [2, 3, 4, 5, 1], + [2, 3, 1, 1, 1], + ] + ) + + self.assertAlmostEqual( + left_pad_output, + utils.make_positions(left_pad_input, pad), + ) + self.assertAlmostEqual( + right_pad_output, + utils.make_positions(right_pad_input, pad), + ) + + def test_clip_grad_norm_(self): + params = torch.nn.Parameter(torch.zeros(5)).requires_grad_(False) + grad_norm = utils.clip_grad_norm_(params, 1.0) + self.assertTrue(torch.is_tensor(grad_norm)) + self.assertEqual(grad_norm, 0.0) + + params = [torch.nn.Parameter(torch.zeros(5)) for i in range(3)] + for p in params: + p.grad = torch.full((5,), fill_value=2.0) + grad_norm = utils.clip_grad_norm_(params, 1.0) + exp_grad_norm = torch.full((15,), fill_value=2.0).norm() + self.assertTrue(torch.is_tensor(grad_norm)) + self.assertEqual(grad_norm, exp_grad_norm) + + grad_norm = utils.clip_grad_norm_(params, 1.0) + self.assertAlmostEqual(grad_norm, torch.tensor(1.0)) + + def test_resolve_max_positions_with_tuple(self): + resolved = utils.resolve_max_positions(None, (2000, 100, 2000), 12000) + self.assertEqual(resolved, (2000, 100, 2000)) + + def assertAlmostEqual(self, t1, t2): + self.assertEqual(t1.size(), t2.size(), "size mismatch") + self.assertLess(utils.item((t1 - t2).abs().max()), 1e-4) + + +if __name__ == "__main__": + unittest.main() diff --git a/fairseq/tests/test_valid_subset_checks.py b/fairseq/tests/test_valid_subset_checks.py new file mode 100644 index 0000000000000000000000000000000000000000..3e9191bda66fccfebba34920f88bf7b1efea5f7e --- /dev/null +++ b/fairseq/tests/test_valid_subset_checks.py @@ -0,0 +1,138 @@ +import os +import shutil +import tempfile +import unittest + +from fairseq import options +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.data.data_utils import raise_if_valid_subsets_unintentionally_ignored +from .utils import create_dummy_data, preprocess_lm_data, train_language_model + + +def make_lm_config( + data_dir=None, + extra_flags=None, + task="language_modeling", + arch="transformer_lm_gpt2_tiny", +): + task_args = [task] + if data_dir is not None: + task_args += [data_dir] + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + *task_args, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--max-tokens", + "500", + "--tokens-per-sample", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + ] + + (extra_flags or []), + ) + cfg = convert_namespace_to_omegaconf(train_args) + return cfg + + +def write_empty_file(path): + with open(path, "w"): + pass + assert os.path.exists(path) + + +class TestValidSubsetsErrors(unittest.TestCase): + """Test various filesystem, clarg combinations and ensure that error raising happens as expected""" + + def _test_case(self, paths, extra_flags): + with tempfile.TemporaryDirectory() as data_dir: + [ + write_empty_file(os.path.join(data_dir, f"{p}.bin")) + for p in paths + ["train"] + ] + cfg = make_lm_config(data_dir, extra_flags=extra_flags) + raise_if_valid_subsets_unintentionally_ignored(cfg) + + def test_default_raises(self): + with self.assertRaises(ValueError): + self._test_case(["valid", "valid1"], []) + with self.assertRaises(ValueError): + self._test_case( + ["valid", "valid1", "valid2"], ["--valid-subset", "valid,valid1"] + ) + + def partially_specified_valid_subsets(self): + with self.assertRaises(ValueError): + self._test_case( + ["valid", "valid1", "valid2"], ["--valid-subset", "valid,valid1"] + ) + # Fix with ignore unused + self._test_case( + ["valid", "valid1", "valid2"], + ["--valid-subset", "valid,valid1", "--ignore-unused-valid-subsets"], + ) + + def test_legal_configs(self): + self._test_case(["valid"], []) + self._test_case(["valid", "valid1"], ["--ignore-unused-valid-subsets"]) + self._test_case(["valid", "valid1"], ["--combine-val"]) + self._test_case(["valid", "valid1"], ["--valid-subset", "valid,valid1"]) + self._test_case(["valid", "valid1"], ["--valid-subset", "valid1"]) + self._test_case( + ["valid", "valid1"], ["--combine-val", "--ignore-unused-valid-subsets"] + ) + self._test_case( + ["valid1"], ["--valid-subset", "valid1"] + ) # valid.bin doesn't need to be ignored. + + def test_disable_validation(self): + self._test_case([], ["--disable-validation"]) + self._test_case(["valid", "valid1"], ["--disable-validation"]) + + def test_dummy_task(self): + cfg = make_lm_config(task="dummy_lm") + raise_if_valid_subsets_unintentionally_ignored(cfg) + + def test_masked_dummy_task(self): + cfg = make_lm_config(task="dummy_masked_lm") + raise_if_valid_subsets_unintentionally_ignored(cfg) + + +class TestCombineValidSubsets(unittest.TestCase): + def _train(self, extra_flags): + with self.assertLogs() as logs: + with tempfile.TemporaryDirectory("test_transformer_lm") as data_dir: + create_dummy_data(data_dir, num_examples=20) + preprocess_lm_data(data_dir) + + shutil.copyfile(f"{data_dir}/valid.bin", f"{data_dir}/valid1.bin") + shutil.copyfile(f"{data_dir}/valid.idx", f"{data_dir}/valid1.idx") + train_language_model( + data_dir, + "transformer_lm", + ["--max-update", "0", "--log-format", "json"] + extra_flags, + run_validation=False, + ) + return [x.message for x in logs.records] + + def test_combined(self): + flags = ["--combine-valid-subsets"] + logs = self._train(flags) + assert any(["valid1" in x for x in logs]) # loaded 100 examples from valid1 + assert not any(["valid1_ppl" in x for x in logs]) # metrics are combined + + def test_subsets(self): + flags = ["--valid-subset", "valid,valid1"] + logs = self._train(flags) + assert any(["valid_ppl" in x for x in logs]) # loaded 100 examples from valid1 + assert any(["valid1_ppl" in x for x in logs]) # metrics are combined diff --git a/fairseq/tests/utils.py b/fairseq/tests/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..6e0c709517aea570acb36901dd47bc12a3025b07 --- /dev/null +++ b/fairseq/tests/utils.py @@ -0,0 +1,717 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import json +import os +import random +import sys +from io import StringIO + +import torch +import torch.nn.functional as F +from fairseq import options, utils +from fairseq.data import Dictionary +from fairseq.data.language_pair_dataset import collate +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, +) +from fairseq.models.fairseq_encoder import EncoderOut +from fairseq.tasks import LegacyFairseqTask +from fairseq_cli import generate, interactive, preprocess, train, validate +import fairseq.distributed.utils as distributed_utils +from fairseq.dataclass.utils import convert_namespace_to_omegaconf + + +def dummy_dictionary(vocab_size, prefix="token_"): + d = Dictionary() + for i in range(vocab_size): + token = prefix + str(i) + d.add_symbol(token) + d.finalize(padding_factor=1) # don't add extra padding symbols + return d + + +def dummy_dataloader( + samples, padding_idx=1, eos_idx=2, batch_size=None, +): + if batch_size is None: + batch_size = len(samples) + + # add any missing data to samples + for i, sample in enumerate(samples): + if "id" not in sample: + sample["id"] = i + + # create dataloader + dataset = TestDataset(samples) + dataloader = torch.utils.data.DataLoader( + dataset, + batch_size=batch_size, + collate_fn=(lambda samples: collate(samples, padding_idx, eos_idx)), + ) + return iter(dataloader) + + +def sequence_generator_setup(): + # construct dummy dictionary + d = dummy_dictionary(vocab_size=2) + + eos = d.eos() + w1 = 4 + w2 = 5 + + # construct source data + src_tokens = torch.LongTensor([[w1, w2, eos], [w1, w2, eos]]) + src_lengths = torch.LongTensor([2, 2]) + + args = argparse.Namespace() + unk = 0.0 + args.beam_probs = [ + # step 0: + torch.FloatTensor( + [ + # eos w1 w2 + # sentence 1: + [0.0, unk, 0.9, 0.1], # beam 1 + [0.0, unk, 0.9, 0.1], # beam 2 + # sentence 2: + [0.0, unk, 0.7, 0.3], + [0.0, unk, 0.7, 0.3], + ] + ), + # step 1: + torch.FloatTensor( + [ + # eos w1 w2 prefix + # sentence 1: + [1.0, unk, 0.0, 0.0], # w1: 0.9 (emit: w1 <eos>: 0.9*1.0) + [0.0, unk, 0.9, 0.1], # w2: 0.1 + # sentence 2: + [0.25, unk, 0.35, 0.4], # w1: 0.7 (don't emit: w1 <eos>: 0.7*0.25) + [0.00, unk, 0.10, 0.9], # w2: 0.3 + ] + ), + # step 2: + torch.FloatTensor( + [ + # eos w1 w2 prefix + # sentence 1: + [0.0, unk, 0.1, 0.9], # w2 w1: 0.1*0.9 + [ + 0.6, + unk, + 0.2, + 0.2, + ], # w2 w2: 0.1*0.1 (emit: w2 w2 <eos>: 0.1*0.1*0.6) + # sentence 2: + [ + 0.60, + unk, + 0.4, + 0.00, + ], # w1 w2: 0.7*0.4 (emit: w1 w2 <eos>: 0.7*0.4*0.6) + [0.01, unk, 0.0, 0.99], # w2 w2: 0.3*0.9 + ] + ), + # step 3: + torch.FloatTensor( + [ + # eos w1 w2 prefix + # sentence 1: + [ + 1.0, + unk, + 0.0, + 0.0, + ], # w2 w1 w2: 0.1*0.9*0.9 (emit: w2 w1 w2 <eos>: 0.1*0.9*0.9*1.0) + [ + 1.0, + unk, + 0.0, + 0.0, + ], # w2 w1 w1: 0.1*0.9*0.1 (emit: w2 w1 w1 <eos>: 0.1*0.9*0.1*1.0) + # sentence 2: + [ + 0.1, + unk, + 0.5, + 0.4, + ], # w2 w2 w2: 0.3*0.9*0.99 (emit: w2 w2 w2 <eos>: 0.3*0.9*0.99*0.1) + [ + 1.0, + unk, + 0.0, + 0.0, + ], # w1 w2 w1: 0.7*0.4*0.4 (emit: w1 w2 w1 <eos>: 0.7*0.4*0.4*1.0) + ] + ), + ] + + task = TestTranslationTask.setup_task(args, d, d) + model = task.build_model(args) + tgt_dict = task.target_dictionary + + return tgt_dict, w1, w2, src_tokens, src_lengths, model + + +def create_dummy_data(data_dir, num_examples=100, maxlen=20, alignment=False): + def _create_dummy_data(filename): + data = torch.rand(num_examples * maxlen) + data = 97 + torch.floor(26 * data).int() + with open(os.path.join(data_dir, filename), "w") as h: + offset = 0 + for _ in range(num_examples): + ex_len = random.randint(1, maxlen) + ex_str = " ".join(map(chr, data[offset : offset + ex_len])) + print(ex_str, file=h) + offset += ex_len + + def _create_dummy_alignment_data(filename_src, filename_tgt, filename): + with open(os.path.join(data_dir, filename_src), "r") as src_f, open( + os.path.join(data_dir, filename_tgt), "r" + ) as tgt_f, open(os.path.join(data_dir, filename), "w") as h: + for src, tgt in zip(src_f, tgt_f): + src_len = len(src.split()) + tgt_len = len(tgt.split()) + avg_len = (src_len + tgt_len) // 2 + num_alignments = random.randint(avg_len // 2, 2 * avg_len) + src_indices = torch.floor(torch.rand(num_alignments) * src_len).int() + tgt_indices = torch.floor(torch.rand(num_alignments) * tgt_len).int() + ex_str = " ".join( + [ + "{}-{}".format(src, tgt) + for src, tgt in zip(src_indices, tgt_indices) + ] + ) + print(ex_str, file=h) + + _create_dummy_data("train.in") + _create_dummy_data("train.out") + _create_dummy_data("valid.in") + _create_dummy_data("valid.out") + _create_dummy_data("test.in") + _create_dummy_data("test.out") + + if alignment: + _create_dummy_alignment_data("train.in", "train.out", "train.align") + _create_dummy_alignment_data("valid.in", "valid.out", "valid.align") + _create_dummy_alignment_data("test.in", "test.out", "test.align") + + +def preprocess_lm_data(data_dir): + preprocess_parser = options.get_preprocessing_parser() + preprocess_args = preprocess_parser.parse_args( + [ + "--only-source", + "--trainpref", + os.path.join(data_dir, "train.out"), + "--validpref", + os.path.join(data_dir, "valid.out"), + "--testpref", + os.path.join(data_dir, "test.out"), + "--destdir", + data_dir, + ] + ) + preprocess.main(preprocess_args) + + +def preprocess_translation_data(data_dir, extra_flags=None): + preprocess_parser = options.get_preprocessing_parser() + preprocess_args = preprocess_parser.parse_args( + [ + "--source-lang", + "in", + "--target-lang", + "out", + "--trainpref", + os.path.join(data_dir, "train"), + "--validpref", + os.path.join(data_dir, "valid"), + "--testpref", + os.path.join(data_dir, "test"), + "--thresholdtgt", + "0", + "--thresholdsrc", + "0", + "--destdir", + data_dir, + ] + + (extra_flags or []), + ) + preprocess.main(preprocess_args) + + +def preprocess_summarization_data(data_dir, extra_flags=None): + preprocess_parser = options.get_preprocessing_parser() + preprocess_args = preprocess_parser.parse_args( + [ + "--source-lang", + "in", + "--target-lang", + "out", + "--trainpref", + os.path.join(data_dir, "train"), + "--validpref", + os.path.join(data_dir, "valid"), + "--testpref", + os.path.join(data_dir, "test"), + "--thresholdtgt", + "0", + "--thresholdsrc", + "0", + "--joined-dictionary", + "--destdir", + data_dir, + ] + + (extra_flags or []), + ) + preprocess.main(preprocess_args) + + +def create_laser_data_and_config_json(data_dir): + src_langs = ["de", "fr", "ru", "tr", "zh"] + tgt_langs = ["en", "es"] + config_json = {} + config_train_json = [] + src_vocab = None + tgt_vocab = None + + for src_lang in src_langs: + for tgt_lang in tgt_langs: + langpair_folder = f"{src_lang}-{tgt_lang}" + + langpair_path = os.path.join(data_dir, langpair_folder) + os.mkdir(langpair_path) + create_dummy_data(langpair_path) + preprocess_translation_data(langpair_path, ["--dataset-impl", "cached"]) + + src_vocab = os.path.join(langpair_path, "dict.in.txt") + tgt_vocab = os.path.join(langpair_path, "dict.out.txt") + config_train_json.append( + { + "id": 0 if tgt_lang == "en" else 1, + "src": os.path.join(langpair_path, "train.in-out.in"), + "tgt": os.path.join(langpair_path, "train.in-out.out"), + } + ) + + config_json["src_vocab"] = src_vocab + config_json["tgt_vocab"] = tgt_vocab + config_json["train"] = config_train_json + + with open(os.path.join(data_dir, "laserconfig.json"), "w") as config_file: + json.dump(config_json, config_file) + + return config_file + + +def train_translation_model( + data_dir, + arch, + extra_flags=None, + task="translation", + run_validation=False, + lang_flags=None, + extra_valid_flags=None, + world_size=1, +): + if lang_flags is None: + lang_flags = [ + "--source-lang", + "in", + "--target-lang", + "out", + ] + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + task, + data_dir, + "--save-dir", + data_dir, + "--arch", + arch, + "--optimizer", + "nag", + "--lr", + "0.05", + "--max-tokens", + "500", + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + str(world_size), + "--num-workers", + "0", + ] + + lang_flags + + (extra_flags or []), + ) + + cfg = convert_namespace_to_omegaconf(train_args) + distributed_utils.call_main(cfg, train.main) + + if run_validation: + # test validation + validate_parser = options.get_validation_parser() + validate_args = options.parse_args_and_arch( + validate_parser, + [ + "--task", + task, + data_dir, + "--path", + os.path.join(data_dir, "checkpoint_last.pt"), + "--valid-subset", + "valid", + "--max-tokens", + "500", + "--no-progress-bar", + "--num-workers", + "0", + ] + + lang_flags + + (extra_valid_flags or []), + ) + validate.main(validate_args) + + +def generate_main(data_dir, extra_flags=None, path=None): + if extra_flags is None: + extra_flags = [ + "--print-alignment", + ] + if path is None: + path = os.path.join(data_dir, "checkpoint_last.pt") + generate_parser = options.get_generation_parser() + generate_args = options.parse_args_and_arch( + generate_parser, + [ + data_dir, + "--path", + path, + "--beam", + "3", + "--batch-size", + "64", + "--max-len-b", + "5", + "--gen-subset", + "valid", + "--no-progress-bar", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + + # evaluate model in batch mode + generate.main(generate_args) + + # evaluate model interactively + generate_args.buffer_size = 0 + generate_args.input = "-" + generate_args.batch_size = None + orig_stdin = sys.stdin + sys.stdin = StringIO("h e l l o\n") + interactive.main(generate_args) + sys.stdin = orig_stdin + + +class TestDataset(torch.utils.data.Dataset): + def __init__(self, data): + super().__init__() + self.data = data + self.sizes = None + + def __getitem__(self, index): + return self.data[index] + + def __len__(self): + return len(self.data) + + +class TestTranslationTask(LegacyFairseqTask): + def __init__(self, args, src_dict, tgt_dict, model): + super().__init__(args) + self.src_dict = src_dict + self.tgt_dict = tgt_dict + self.model = model + + @classmethod + def setup_task(cls, args, src_dict=None, tgt_dict=None, model=None): + return cls(args, src_dict, tgt_dict, model) + + def build_model(self, args): + return TestModel.build_model(args, self) + + @property + def source_dictionary(self): + return self.src_dict + + @property + def target_dictionary(self): + return self.tgt_dict + + +class TestModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @classmethod + def build_model(cls, args, task): + encoder = TestEncoder(args, task.source_dictionary) + decoder = TestIncrementalDecoder(args, task.target_dictionary) + return cls(encoder, decoder) + + +class TestEncoder(FairseqEncoder): + def __init__(self, args, dictionary): + super().__init__(dictionary) + self.args = args + + def forward(self, src_tokens, src_lengths=None, **kwargs): + return EncoderOut( + encoder_out=src_tokens, + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + def reorder_encoder_out(self, encoder_out, new_order): + return EncoderOut( + encoder_out=encoder_out.encoder_out.index_select(0, new_order), + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + +class TestIncrementalDecoder(FairseqIncrementalDecoder): + def __init__(self, args, dictionary): + super().__init__(dictionary) + assert hasattr(args, "beam_probs") or hasattr(args, "probs") + args.max_decoder_positions = getattr(args, "max_decoder_positions", 100) + self.args = args + + def forward(self, prev_output_tokens, encoder_out=None, incremental_state=None): + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + bbsz = prev_output_tokens.size(0) + vocab = len(self.dictionary) + src_len = encoder_out.encoder_out.size(1) + tgt_len = prev_output_tokens.size(1) + + # determine number of steps + if incremental_state is not None: + # cache step number + step = utils.get_incremental_state(self, incremental_state, "step") + if step is None: + step = 0 + utils.set_incremental_state(self, incremental_state, "step", step + 1) + steps = [step] + else: + steps = list(range(tgt_len)) + + # define output in terms of raw probs + if hasattr(self.args, "probs"): + assert ( + self.args.probs.dim() == 3 + ), "expected probs to have size bsz*steps*vocab" + probs = self.args.probs.index_select(1, torch.LongTensor(steps)) + else: + probs = torch.FloatTensor(bbsz, len(steps), vocab).zero_() + for i, step in enumerate(steps): + # args.beam_probs gives the probability for every vocab element, + # starting with eos, then unknown, and then the rest of the vocab + if step < len(self.args.beam_probs): + probs[:, i, self.dictionary.eos() :] = self.args.beam_probs[step] + else: + probs[:, i, self.dictionary.eos()] = 1.0 + + # random attention + attn = torch.rand(bbsz, tgt_len, src_len) + + dev = prev_output_tokens.device + return probs.to(dev), {"attn": [attn.to(dev)]} + + def get_normalized_probs(self, net_output, log_probs, _): + # the decoder returns probabilities directly + probs = net_output[0] + if log_probs: + return probs.log() + else: + return probs + + def max_positions(self): + return self.args.max_decoder_positions + + +class TestReshapingEncoder(FairseqEncoder): + def __init__(self, args, dictionary): + super().__init__(dictionary) + self.args = args + + def forward(self, src_tokens, src_lengths=None, **kwargs): + b_sz, t_sz = src_tokens.shape + padding_needed = t_sz % 2 + x = src_tokens + if padding_needed > 0: + padding_needed = 2 - padding_needed + x = F.pad(x, (0, padding_needed)) + + return EncoderOut( + encoder_out=x.view(b_sz, -1, 2), + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + def reorder_encoder_out(self, encoder_out, new_order): + return EncoderOut( + encoder_out=encoder_out.encoder_out.index_select(0, new_order), + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + +class TestReshapingModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @classmethod + def build_model(cls, args, task): + encoder = TestReshapingEncoder(args, task.source_dictionary) + decoder = TestIncrementalDecoder(args, task.target_dictionary) + return cls(encoder, decoder) + + +class TestAdditionalInputEncoder(FairseqEncoder): + def __init__(self, args, dictionary): + super().__init__(dictionary) + self.args = args + + def forward(self, src_tokens, src_lengths=None, **kwargs): + assert "fancy_other_input" in kwargs + assert kwargs["fancy_other_input"] is not None + return EncoderOut( + encoder_out=src_tokens, + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + def reorder_encoder_out(self, encoder_out, new_order): + return EncoderOut( + encoder_out=encoder_out.encoder_out.index_select(0, new_order), + encoder_padding_mask=None, + encoder_embedding=None, + encoder_states=None, + src_tokens=None, + src_lengths=None, + ) + + +class TestAdditionalInputModel(FairseqEncoderDecoderModel): + def __init__(self, encoder, decoder): + super().__init__(encoder, decoder) + + @classmethod + def build_model(cls, args, task): + encoder = TestAdditionalInputEncoder(args, task.source_dictionary) + decoder = TestIncrementalDecoder(args, task.target_dictionary) + return cls(encoder, decoder) + + def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): + encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) + decoder_out = self.decoder( + prev_output_tokens, encoder_out=encoder_out, **kwargs + ) + return decoder_out + + +def train_language_model( + data_dir, + arch, + extra_flags=None, + run_validation=False, + extra_valid_flags=None, + task="language_modeling", + world_size=1, +): + train_parser = options.get_training_parser() + train_args = options.parse_args_and_arch( + train_parser, + [ + "--task", + task, + data_dir, + "--arch", + arch, + "--optimizer", + "adam", + "--lr", + "0.0001", + "--max-tokens", + "500", + "--tokens-per-sample", + "500", + "--save-dir", + data_dir, + "--max-epoch", + "1", + "--no-progress-bar", + "--distributed-world-size", + str(world_size), + "--ddp-backend", + "no_c10d", + "--num-workers", + "0", + ] + + (extra_flags or []), + ) + cfg = convert_namespace_to_omegaconf(train_args) + distributed_utils.call_main(cfg, train.main) + + if run_validation: + # test validation + validate_parser = options.get_validation_parser() + validate_args = options.parse_args_and_arch( + validate_parser, + [ + "--task", + task, + data_dir, + "--path", + os.path.join(data_dir, "checkpoint_last.pt"), + "--valid-subset", + "valid", + "--max-tokens", + "500", + "--no-progress-bar", + "--num-workers", + "0", + ] + + (extra_valid_flags or []), + ) + validate.main(validate_args) diff --git a/fairseq/train.py b/fairseq/train.py new file mode 100644 index 0000000000000000000000000000000000000000..321de3d9b53f8194b58c26f5cb2c03281afc2bb1 --- /dev/null +++ b/fairseq/train.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 -u +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. +""" +Legacy entry point. Use fairseq_cli/train.py or fairseq-train instead. +""" + +from fairseq_cli.train import cli_main + + +if __name__ == "__main__": + cli_main() diff --git a/models/.ipynb_checkpoints/__init__-checkpoint.py b/models/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..97c5ec4322e2aab5906beebc8eafdf4d26b157e2 --- /dev/null +++ b/models/.ipynb_checkpoints/__init__-checkpoint.py @@ -0,0 +1,2 @@ +from .ofa import OFAModel, ofa_base_architecture, ofa_large_architecture, ofa_huge_architecture +from .t5 import OFAT5Model, T5OFAModel \ No newline at end of file diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7ea10ae1d9f9ede5e45aa0cc8856632aa7c6acc9 --- /dev/null +++ b/models/__init__.py @@ -0,0 +1 @@ +from .unival import UnIVALModel, unival_base_architecture \ No newline at end of file diff --git a/models/__pycache__/__init__.cpython-37.pyc b/models/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..95ba1e1555b507dcd3ea46531c271000d267ec82 Binary files /dev/null and b/models/__pycache__/__init__.cpython-37.pyc differ diff --git a/models/__pycache__/__init__.cpython-38.pyc b/models/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e268a49470c0bd9c1cb2e8339c4c468998e6b9cf Binary files /dev/null and b/models/__pycache__/__init__.cpython-38.pyc differ diff --git a/models/__pycache__/__init__.cpython-39.pyc b/models/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab8f7225f4cd56b49ba6bb4e3544dead804a14b9 Binary files /dev/null and b/models/__pycache__/__init__.cpython-39.pyc differ diff --git a/models/__pycache__/search.cpython-37.pyc b/models/__pycache__/search.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8f15b0428427c71ace0b7f2c0d39034fad17f47 Binary files /dev/null and b/models/__pycache__/search.cpython-37.pyc differ diff --git a/models/__pycache__/search.cpython-38.pyc b/models/__pycache__/search.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c5b5c2201fd520501e825c1a93c5baf9a69cf25 Binary files /dev/null and b/models/__pycache__/search.cpython-38.pyc differ diff --git a/models/__pycache__/search.cpython-39.pyc b/models/__pycache__/search.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c938f18d11fe9f540d90e4542cc588ba9de88769 Binary files /dev/null and b/models/__pycache__/search.cpython-39.pyc differ diff --git a/models/__pycache__/sequence_generator.cpython-37.pyc b/models/__pycache__/sequence_generator.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42756c4b5d33ba861ac71de747fe050865665d57 Binary files /dev/null and b/models/__pycache__/sequence_generator.cpython-37.pyc differ diff --git a/models/__pycache__/sequence_generator.cpython-39.pyc b/models/__pycache__/sequence_generator.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08a2b1cbfa07997927fd8566b93c2a2ce68b91e0 Binary files /dev/null and b/models/__pycache__/sequence_generator.cpython-39.pyc differ diff --git a/models/clip/__init__.py b/models/clip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dcc5619538c0f7c782508bdbd9587259d805e0d9 --- /dev/null +++ b/models/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/models/clip/__pycache__/__init__.cpython-37.pyc b/models/clip/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fed68e8cf965e7f8d209def763067c04ad0399c2 Binary files /dev/null and b/models/clip/__pycache__/__init__.cpython-37.pyc differ diff --git a/models/clip/__pycache__/__init__.cpython-38.pyc b/models/clip/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e0c3c267d360cbf3f3f64604d25edce61850e8e Binary files /dev/null and b/models/clip/__pycache__/__init__.cpython-38.pyc differ diff --git a/models/clip/__pycache__/clip.cpython-37.pyc b/models/clip/__pycache__/clip.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..263e4ce7ffc4404a8dd3dee1b34213e1e088df6e Binary files /dev/null and b/models/clip/__pycache__/clip.cpython-37.pyc differ diff --git a/models/clip/__pycache__/clip.cpython-38.pyc b/models/clip/__pycache__/clip.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d3c9236515e799b020786a5751c1d29d0fccaa3 Binary files /dev/null and b/models/clip/__pycache__/clip.cpython-38.pyc differ diff --git a/models/clip/__pycache__/model.cpython-37.pyc b/models/clip/__pycache__/model.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5379e9bcd2af269e1cab14b451c1b39584545b3 Binary files /dev/null and b/models/clip/__pycache__/model.cpython-37.pyc differ diff --git a/models/clip/__pycache__/model.cpython-38.pyc b/models/clip/__pycache__/model.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7b0cee567badd3e8c9d43071b0e51750990e851 Binary files /dev/null and b/models/clip/__pycache__/model.cpython-38.pyc differ diff --git a/models/clip/__pycache__/simple_tokenizer.cpython-37.pyc b/models/clip/__pycache__/simple_tokenizer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a6d3c18b5f24d1b3c936399cfc9be111980c8f6 Binary files /dev/null and b/models/clip/__pycache__/simple_tokenizer.cpython-37.pyc differ diff --git a/models/clip/__pycache__/simple_tokenizer.cpython-38.pyc b/models/clip/__pycache__/simple_tokenizer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c811f4e26bb677ac16c4039953e20ebaf1d07905 Binary files /dev/null and b/models/clip/__pycache__/simple_tokenizer.cpython-38.pyc differ diff --git a/models/clip/bpe_simple_vocab_16e6.txt.gz b/models/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/models/clip/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/models/clip/clip.py b/models/clip/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..f79e18bcd08ffea36041f95587aa956f5a82e052 --- /dev/null +++ b/models/clip/clip.py @@ -0,0 +1,229 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError(f"Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + try: + # loading JIT archive + model = torch.jit.load(model_path, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(model_path, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> torch.LongTensor: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length] + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/models/clip/model.py b/models/clip/model.py new file mode 100644 index 0000000000000000000000000000000000000000..cdc976bcd6247f6d1d39ad1546feb39bede20f79 --- /dev/null +++ b/models/clip/model.py @@ -0,0 +1,437 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + + self.relu = nn.ReLU(inplace=True) + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu(self.bn1(self.conv1(x))) + out = self.relu(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x, key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + + return x[0] + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.avgpool = nn.AvgPool2d(2) + self.relu = nn.ReLU(inplace=True) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + for conv, bn in [(self.conv1, self.bn1), (self.conv2, self.bn2), (self.conv3, self.bn3)]: + x = self.relu(bn(conv(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat( + [self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), + x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + self.input_resolution = image_resolution + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=-1, keepdim=True) + text_features = text_features / text_features.norm(dim=-1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len( + [k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in + [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/models/clip/simple_tokenizer.py b/models/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/models/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'</w>' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '</w>',) + pairs = get_pairs(word) + + if not pairs: + return token+'</w>' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ') + return text diff --git a/models/search.py b/models/search.py new file mode 100644 index 0000000000000000000000000000000000000000..568612212bdbbe787c7ab64017f8170ec67619f8 --- /dev/null +++ b/models/search.py @@ -0,0 +1,814 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from typing import List, Optional + +import torch +import torch.nn as nn +from fairseq.token_generation_constraints import ( + ConstraintState, + OrderedConstraintState, + UnorderedConstraintState, +) +from torch import Tensor + + +class Search(nn.Module): + def __init__(self, tgt_dict): + super().__init__() + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.eos = tgt_dict.eos() + self.vocab_size = len(tgt_dict) + self.src_lengths = torch.tensor(-1) + self.supports_constraints = False + self.stop_on_max_len = False + + def step( + self, step, lprobs, scores, prev_output_tokens=None, original_batch_idxs=None + ): + """Take a single search step. + + Args: + step: the current search step, starting at 0 + lprobs: (bsz x input_beam_size x vocab_size) + the model's log-probabilities over the vocabulary at the current step + scores: (bsz x input_beam_size x step) + the historical model scores of each hypothesis up to this point + prev_output_tokens: (bsz x step) + the previously generated oputput tokens + original_batch_idxs: (bsz) + the tensor with the batch indices, in the range [0, bsz) + this is useful in case there has been applied a re-ordering + and we need to know the orignal indices + + Return: A tuple of (scores, indices, beams) where: + scores: (bsz x output_beam_size) + the scores of the chosen elements; output_beam_size can be + larger than input_beam_size, e.g., we may return + 2*input_beam_size to account for EOS + indices: (bsz x output_beam_size) + the indices of the chosen elements + beams: (bsz x output_beam_size) + the hypothesis ids of the chosen elements, in the range [0, input_beam_size) + """ + raise NotImplementedError + + @torch.jit.export + def set_src_lengths(self, src_lengths): + self.src_lengths = src_lengths + + @torch.jit.export + def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int): + """Initialize constraint states for constrained decoding (if supported). + + Args: + batch_constraints: (torch.Tensor, optional) + the list of constraints, in packed form + beam_size: (int) + the beam size + Returns: + *encoder_out* rearranged according to *new_order* + """ + pass + + def prune_sentences(self, batch_idxs: Tensor): + """ + Removes constraint states for completed sentences (if supported). + This is called from sequence_generator._generate() when sentences are + deleted from the batch. + + Args: + batch_idxs: Indices of *sentences* whose constraint state should be *kept*. + """ + pass + + def update_constraints(self, active_hypos: Tensor): + """ + Updates the constraint states by selecting the beam items that are retained. + This is called at each time step of sequence_generator._generate() when + the set of 2 * {beam_size} candidate hypotheses are reduced to the beam size. + + Args: + active_hypos: (batch size, beam size) + list of integers denoting, for each sentence, which beam candidate items + should be kept. + """ + pass + + +class BeamSearch(Search): + def __init__(self, tgt_dict): + super().__init__(tgt_dict) + self.constraint_states = None + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores: Optional[Tensor], + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(bsz, -1), + k=min( + # Take the best 2 x beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size * 2, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ), + ) + scores_buf = top_prediction[0] + indices_buf = top_prediction[1] + # Project back into relative indices and beams + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + + # At this point, beams_buf and indices_buf are single-dim and contain relative indices + return scores_buf, indices_buf, beams_buf + + +class PrefixConstrainedBeamSearch(Search): + def __init__(self, tgt_dict, prefix_allowed_tokens_fn): + super().__init__(tgt_dict) + self.prefix_allowed_tokens_fn = prefix_allowed_tokens_fn + self.stop_on_max_len = True + + @torch.jit.export + def apply_mask(self, x, prev_output_tokens, original_batch_idxs): + beam_size = x.shape[0] // original_batch_idxs.shape[0] + original_batch_idxs = ( + original_batch_idxs.unsqueeze(-1).repeat((1, beam_size)).flatten().tolist() + ) + + mask = torch.full_like(x, -math.inf) + for sent_i, (sent, batch_i) in enumerate( + zip(prev_output_tokens, original_batch_idxs) + ): + mask[sent_i, :, self.prefix_allowed_tokens_fn(batch_i, sent)] = 0 + + return mask + + @torch.jit.export + def step( + self, + step: int, + lprobs: Tensor, + scores: Tensor, + prev_output_tokens: Tensor, + original_batch_idxs: Tensor, + ): + bsz, beam_size, vocab_size = lprobs.size() + + lprobs += self.apply_mask( + lprobs.view(bsz * beam_size, 1, vocab_size), + prev_output_tokens, + original_batch_idxs, + ).view(bsz, beam_size, vocab_size) + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(bsz, -1), + k=min( + # Take the best beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ), + ) + scores_buf = top_prediction[0] + indices_buf = top_prediction[1] + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + return scores_buf, indices_buf, beams_buf + + +class LexicallyConstrainedBeamSearch(Search): + """Implements lexically constrained beam search as described in + + Fast Lexically Constrained Decoding with Dynamic Beam + Allocation for Neural Machine Translation. Post & Vilar, + NAACL 2018. https://www.aclweb.org/anthology/N18-1119/ + + and + + Improved Lexically Constrained Decoding for Translation and + Monolingual Rewriting. Hu et al, NAACL + 2019. https://www.aclweb.org/anthology/N19-1090/ + + This is accomplished by maintaining, for each beam hypothesis, a + ConstraintState object (see constraints.py) that tracks which + constraints have been generated and using this information to + shape the beam for each input sentence. + """ + + def __init__(self, tgt_dict, representation): + super().__init__(tgt_dict) + self.representation = representation + self.vocab_size = len(tgt_dict) + self.num_cands = 0 + self.supports_constraints = True + + @torch.jit.export + def init_constraints(self, batch_constraints: Optional[Tensor], beam_size: int): + self.constraint_states = [] + for constraint_tensor in batch_constraints: + if self.representation == "ordered": + constraint_state = OrderedConstraintState.create(constraint_tensor) + elif self.representation == "unordered": + constraint_state = UnorderedConstraintState.create(constraint_tensor) + + self.constraint_states.append([constraint_state for i in range(beam_size)]) + + @torch.jit.export + def prune_sentences(self, batch_idxs: Tensor): + self.constraint_states = [ + self.constraint_states[i] for i in batch_idxs.tolist() + ] + + @torch.jit.export + def update_constraints(self, active_hypos: Tensor): + if self.constraint_states: + batch_size = active_hypos.size(0) + for sentid in range(batch_size): + self.constraint_states[sentid] = [ + self.constraint_states[sentid][i] for i in active_hypos[sentid] + ] + + @torch.jit.export + def step( + self, + step: int, + lprobs: Tensor, + scores: Optional[Tensor], + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + """ + A constrained step builds a large candidates list from the following: + - the top 2 * {beam_size} items over the whole beam + - for each item in the beam + - the top {each_k} (default 1) + - all next constraints + We then compute the constrained state of each beam item, and assign + stripe codes: 0 to the best in each bank, 1 to the 2nd-best, and so + on. We then sort by (stripe, score), and truncate the list at + 2 * beam size. + + Args: + step: the decoder step + lprobs: (batch size, beam size, target vocab) + the target-vocab distributions for each item in the beam. + Retrun: A tuple of (scores, indices, beams, constraints) where: + scores: (batch, output beam size) + the scores of the chosen elements + indices: (batch, output beam size) + the target vocab indices of the chosen elements + beams: (batch, output beam size) + the 0-indexed hypothesis ids of the chosen elements + constraints: (batch, output beam size) + the new constraint states + """ + each_k = 1 + device = lprobs.device + + batch_size, beam_size, vocab_size = lprobs.size() + + self.num_cands = min( + # Just take the k-best. We'll get another k from the 1-best from each + # row, plus more from the constraints + beam_size * 2, + lprobs.view(batch_size, -1).size(1) - 1, # -1 so we never select pad + ) + + # STEP 0: Preliminary. Prevent EOS for unfinished hyps across all batch items + constraint_states = self.constraint_states + if constraint_states and step > 0: + not_finished_indices = [] + for sentno, sent_constraints in enumerate(constraint_states): + for beamno, state in enumerate(sent_constraints): + index = sentno * beam_size + beamno + if not state.finished: + not_finished_indices.append(index) + not_finished_indices = torch.tensor(not_finished_indices) + if not_finished_indices.numel() > 0: + lprobs.view(batch_size * beam_size, -1)[ + not_finished_indices, self.eos + ] = -math.inf + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam entry for each batch item + lprobs = lprobs[:, ::beam_size, :].contiguous() + else: + # make probs contain cumulative scores for each hypothesis + assert scores is not None + lprobs = lprobs + scores[:, :, step - 1].unsqueeze(-1) + + top_prediction = torch.topk( + lprobs.view(batch_size, -1), + self.num_cands, + ) + scores_buf, indices_buf = top_prediction + # Project back into relative indices and beams + beams_buf = indices_buf // vocab_size + indices_buf = indices_buf.fmod(vocab_size) + + # Short circuit if there are no constraints in this batch + if not constraint_states: + return scores_buf, indices_buf, beams_buf + + # STEP 1: get top-1 from each hypothesis across all sentences in the batch + if step > 0: + top_scores, top_indices = torch.topk( + lprobs.view(batch_size * beam_size, -1), + k=each_k, + dim=1, + ) + top_scores = top_scores.view(batch_size, -1) + top_indices = top_indices.view(batch_size, -1) + scores_buf = torch.cat((scores_buf, top_scores), dim=1) + indices_buf = torch.cat((indices_buf, top_indices), dim=1) + new_beams = torch.arange(0, beam_size, device=device).repeat(batch_size, 1) + beams_buf = torch.cat((beams_buf, new_beams), dim=1) + + # Now, process sentences in the batch one by one. + new_scores_buf = torch.zeros((batch_size, 2 * beam_size), device=device) + new_indices_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long() + new_beams_buf = torch.zeros((batch_size, 2 * beam_size), device=device).long() + for sentno, states in enumerate(constraint_states): + scores, indices, beams, new_states = self.step_sentence( + step, + sentno, + lprobs[sentno], + constraint_states[sentno], + beams_buf[sentno].clone(), + indices_buf[sentno].clone(), + scores_buf[sentno].clone(), + ) + new_scores_buf[sentno] = scores + new_indices_buf[sentno] = indices + new_beams_buf[sentno] = beams + self.constraint_states[sentno] = new_states + + return new_scores_buf, new_indices_buf, new_beams_buf + + @torch.jit.export + def step_sentence( + self, + step: int, + sentno: int, + lprobs: Tensor, + constraint_states: List[List[ConstraintState]], + beams_buf: Tensor, + indices_buf: Tensor, + scores_buf: Tensor, + ): + """Does per-sentence processing. Adds all constraints for each + hypothesis to the list of candidates; then removes duplicates, + sorts, and dynamically stripes across the banks. All tensor inputs + are collapsed to those pertaining to a single input sentence. + """ + device = lprobs.device + + # STEP 2: Add all constraints for each beam item + for beamno, state in enumerate(constraint_states): + next_tokens = torch.tensor(list(state.next_tokens()), device=device).long() + if next_tokens.numel() != 0: + indices_buf = torch.cat((indices_buf, next_tokens)) + next_beams = ( + torch.tensor(beamno, device=device) + .repeat(next_tokens.size(0)) + .long() + ) + beams_buf = torch.cat((beams_buf, next_beams)) + next_values = lprobs[beamno].take(next_tokens.view(-1)) + scores_buf = torch.cat((scores_buf, next_values)) + + # At the 0th time step, there is just one beam item + if step == 0: + break + + # STEP 3: Compute the "bank" for each candidate. This is the + # number of constraints it's generated. We need this so that + # we can do round-robin allocation of the beam across these + # banks. If C is the number of constraints, we select the best + # item in bank C, then the best in bank C-1, etc, followed by + # the 2nd-best in bank C, the 2nd-best in bank C-1, etc, and so + # on, until the maximum beam size. We accomplish this by + # creating a sort key and striping across the banks. + + # Compute the new states for all candidates + cands_size = indices_buf.size(0) + constraint_states = [ + constraint_states[beams_buf[i]].advance(indices_buf[i]) + for i in range(cands_size) + ] + + banks = torch.tensor([state.bank for state in constraint_states], device=device) + + # STEP 4: Sort + num_constraint_tokens = len(state.tokens) + + # Sort by keys (bank, score) (i.e., sort banks together, and scores + # within banks). AFAIK pytorch doesn't support either stable sort or + # multi-key sorting, so we have to hack this. + MAX_SCORE = -100 + sort_key = (num_constraint_tokens - banks) * MAX_SCORE + scores_buf + sort_values, sort_indices = sort_key.sort(dim=0, descending=True) + scores_buf = scores_buf[sort_indices] + indices_buf = indices_buf[sort_indices] + beams_buf = beams_buf[sort_indices] + banks = banks[sort_indices] + + # Sort the constraints to follow suit + constraint_states = [constraint_states[i] for i in sort_indices] + + # STEP 5: Remove duplicates. The topk calls (overall and + # per-row) plus the per-row generation of constraints will + # produce duplicates. Here we remove them. + + def roll(t): + """Rolls a 1d tensor left by 1. + + [0, 1, 2, 3, 4] becomes [4, 0, 1, 2, 3] + """ + return torch.cat((t[-1].unsqueeze(0), t[0:-1]), dim=0) + + # We map candidates (beam, token_id) to a single dimension. + # This is then shifted by 1. We can then easily identify + # duplicates and create a mask that identifies unique + # extensions. + uniques_mask = beams_buf * (self.vocab_size + 1) + indices_buf + uniques_mask = roll(uniques_mask) != uniques_mask + + # Use the mask to pare down the data structures + scores_buf = torch.masked_select(scores_buf, uniques_mask) + indices_buf = torch.masked_select(indices_buf, uniques_mask) + beams_buf = torch.masked_select(beams_buf, uniques_mask) + banks = torch.masked_select(banks, uniques_mask) + i = 1 + for mask in uniques_mask[1:]: + if not mask: + constraint_states.pop(i) + i += mask + + # STEP 6: Assign IDs round-robin across banks, sort, and + # truncate. Now that the candidates are sorted by (bank, + # score) and uniqed, we dynamically allocate the {beam_size} + # beam by striping across the candidates. These stripes will + # be used as sort keys to do round-robin selection. This is + # accomplished in a single pass with offsets. Sorting by + # highest-banks (furthest-along hypotheses) first ensures + # progress through the constraints. + # + # e.g., BANKS: 3 3 3 2 2 2 2 1 1 1 0 0 + # OLD STRIPES: 0 1 2 0 1 2 3 0 1 2 0 1 + # NEW STRIPES: 0 1+4 2+8 0+1 1+5 2+9 3+11 0+2 1+6 2+10 0+3 1+7 + # = 0 5 10 1 6 11 13 2 7 12 3 8 + # + # Sorting by this then gives the following banks: + # + # 3 2 1 0 3 2 1 0 3 2 1 2 + # + # We'll take the top {beam_size} of these. + stripe_offsets = [offset * (len(banks) + 1) for offset in range(len(banks) + 1)] + stripes = torch.zeros_like(banks) + cur_bank_count = -1 + cur_bank = banks[0] + for i, bank in enumerate(banks): + if bank != cur_bank: + cur_bank_count = 0 + cur_bank = bank + else: + cur_bank_count += 1 + stripes[i] = num_constraint_tokens - bank + stripe_offsets[cur_bank_count] + + # STEP 7: Sort by the stripes values + sort_values, sort_indices = stripes.sort(dim=0) + scores_buf = scores_buf[sort_indices] + indices_buf = indices_buf[sort_indices] + beams_buf = beams_buf[sort_indices] + constraint_states = [constraint_states[i] for i in sort_indices] + + # STEP 8: Truncate to the candidates size! + scores_buf = scores_buf[: self.num_cands] + indices_buf = indices_buf[: self.num_cands] + beams_buf = beams_buf[: self.num_cands] + + return scores_buf, indices_buf, beams_buf, constraint_states + + +class LengthConstrainedBeamSearch(Search): + def __init__(self, tgt_dict, min_len_a, min_len_b, max_len_a, max_len_b): + super().__init__(tgt_dict) + self.min_len_a = min_len_a + self.min_len_b = min_len_b + self.max_len_a = max_len_a + self.max_len_b = max_len_b + self.beam = BeamSearch(tgt_dict) + self.needs_src_lengths = True + + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + min_lens = self.min_len_a * self.src_lengths + self.min_len_b + max_lens = self.max_len_a * self.src_lengths + self.max_len_b + lprobs[step < min_lens, :, self.eos] = -math.inf + lprobs[step >= max_lens, :, self.eos] = 0 + return self.beam.step(step, lprobs, scores) + + +class DiverseBeamSearch(Search): + """Diverse Beam Search. + + See "Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence + Models" for details. + + We only implement the Hamming Diversity penalty here, which performed best + in the original paper. + """ + + def __init__(self, tgt_dict, num_groups, diversity_strength): + super().__init__(tgt_dict) + self.num_groups = num_groups + self.diversity_strength = -diversity_strength + self.beam = BeamSearch(tgt_dict) + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + if beam_size % self.num_groups != 0: + raise ValueError( + "DiverseBeamSearch requires --beam to be divisible by the number of groups" + ) + + # initialize diversity penalty + diversity_buf = torch.zeros(lprobs[:, 0, :].size()).to(lprobs) + + scores_G, indices_G, beams_G = [], [], [] + for g in range(self.num_groups): + lprobs_g = lprobs[:, g :: self.num_groups, :] + scores_g = scores[:, g :: self.num_groups, :] if step > 0 else None + + # apply diversity penalty + if g > 0: + lprobs_g = torch.add( + lprobs_g, + other=diversity_buf.unsqueeze(1), + alpha=self.diversity_strength, + ) + else: + lprobs_g = lprobs_g.contiguous() + + scores_buf, indices_buf, beams_buf = self.beam.step( + step, lprobs_g, scores_g + ) + beams_buf.mul_(self.num_groups).add_(g) + + scores_G.append(scores_buf.clone()) + indices_G.append(indices_buf.clone()) + beams_G.append(beams_buf.clone()) + + # update diversity penalty + diversity_buf.scatter_add_( + 1, indices_buf, torch.ones(indices_buf.size()).to(diversity_buf) + ) + + # interleave results from different groups + scores_buf = torch.stack(scores_G, dim=2).view(bsz, -1) + indices_buf = torch.stack(indices_G, dim=2).view(bsz, -1) + beams_buf = torch.stack(beams_G, dim=2).view(bsz, -1) + return scores_buf, indices_buf, beams_buf + + +class Sampling(Search): + sampling_topk: int + sampling_topp: float + + def __init__(self, tgt_dict, sampling_topk=-1, sampling_topp=-1.0): + super().__init__(tgt_dict) + self.sampling_topk = sampling_topk + self.sampling_topp = sampling_topp + + def _sample_topp(self, lprobs): + """Sample among the smallest set of elements whose cumulative probability mass exceeds p. + + See `"The Curious Case of Neural Text Degeneration" + (Holtzman et al., 2019) <https://arxiv.org/abs/1904.09751>`_. + + Args: + lprobs: (bsz x input_beam_size x vocab_size) + the model's log-probabilities over the vocabulary at the current step + + Return: A tuple of (trimed_probs, truncated_indices) where: + trimed_probs: (bsz x input_beam_size x ?) + the model's probabilities over the elements selected to sample from. The + width of the third dimension is determined by top-P. + truncated_indices: (bsz x input_beam_size x ?) + the indices of the chosen elements. + """ + probs = lprobs.exp_() + + # sort the last dimension (vocab dimension) in descending order + sorted_probs, sorted_indices = probs.sort(descending=True) + + # compute a mask to indicate the words to be included in the top-P set. + cumsum_probs = sorted_probs.cumsum(dim=2) + mask = cumsum_probs.lt(self.sampling_topp) + + # note that mask was computed by 'lt'. One more word needs to be included + # so that the cumulative probability mass can exceed p. + cumsum_mask = mask.cumsum(dim=2) + last_included = cumsum_mask[:, :, -1:] + last_included.clamp_(0, mask.size()[2] - 1) + mask = mask.scatter_(2, last_included, 1) + + # truncate unnecessary dims. + max_dim = last_included.max() + truncated_mask = mask[:, :, : max_dim + 1] + truncated_probs = sorted_probs[:, :, : max_dim + 1] + truncated_indices = sorted_indices[:, :, : max_dim + 1] + + # trim the words that are not in top-P by setting their probabilities + # to 0, so that they would not be sampled later. + trim_mask = ~truncated_mask + trimed_probs = truncated_probs.masked_fill_(trim_mask, 0) + return trimed_probs, truncated_indices + + @torch.jit.export + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + + if step == 0: + # at the first step all hypotheses are equally likely, so use + # only the first beam + lprobs = lprobs[:, ::beam_size, :].contiguous() + + if self.sampling_topp > 0: + # only sample from the smallest set of words whose cumulative probability mass exceeds p + probs, top_indices = self._sample_topp(lprobs) + elif self.sampling_topk > 0: + # only sample from top-k candidates + lprobs, top_indices = lprobs.topk(self.sampling_topk) + probs = lprobs.exp_() + else: + probs = lprobs.exp_() + + # dummy data to be consistent with true branch for type check + top_indices = torch.empty(0).to(probs) + # sample + if step == 0: + indices_buf = torch.multinomial( + probs.view(bsz, -1), + beam_size, + replacement=True, + ).view(bsz, beam_size) + else: + indices_buf = torch.multinomial( + probs.view(bsz * beam_size, -1), + 1, + replacement=True, + ).view(bsz, beam_size) + + if step == 0: + # expand to beam size + probs = probs.expand(bsz, beam_size, -1) + + # gather scores + scores_buf = torch.gather(probs, dim=2, index=indices_buf.unsqueeze(-1)) + scores_buf = scores_buf.log_().view(bsz, -1) + + # remap indices if using top-k or top-P sampling + if self.sampling_topk > 0 or self.sampling_topp > 0: + indices_buf = torch.gather( + top_indices.expand(bsz, beam_size, -1), + dim=2, + index=indices_buf.unsqueeze(-1), + ).squeeze(2) + + if step == 0: + beams_buf = indices_buf.new_zeros(bsz, beam_size) + else: + beams_buf = torch.arange(0, beam_size).to(indices_buf).repeat(bsz, 1) + # make scores cumulative + scores_buf.add_( + torch.gather(scores[:, :, step - 1], dim=1, index=beams_buf) + ) + + return scores_buf, indices_buf, beams_buf + + +class DiverseSiblingsSearch(Search): + """ + Beam search with diverse siblings. + + See "A Simple, Fast Diverse Decoding Algorithm for Neural Generation" for details. + https://arxiv.org/abs/1611.08562 + + 1/ Calculate hypotheses for each beam + 2/ Intra-sibling ordering + 3/ Rewrite scores + 4/ Choose top K hypotheses + + if diversity_rate == 0 is equivalent to BeamSearch + """ + + def __init__(self, tgt_dict, diversity_rate): + super().__init__(tgt_dict) + self.diversity_rate = diversity_rate + self.beam = BeamSearch(tgt_dict) + + def step( + self, + step: int, + lprobs, + scores, + prev_output_tokens: Optional[Tensor] = None, + original_batch_idxs: Optional[Tensor] = None, + ): + bsz, beam_size, vocab_size = lprobs.size() + k = min( + # Take the best 2 x beam_size predictions. We'll choose the first + # beam_size of these which don't predict eos to continue with. + beam_size * 2, + lprobs.view(bsz, -1).size(1) - 1, # -1 so we never select pad + ) + s_list: List[Tensor] + i_list: List[Tensor] + s_list = [torch.empty(0).to(lprobs) for i in range(beam_size)] + i_list = [torch.LongTensor().to(device=lprobs.device) for i in range(beam_size)] + sibling_score = torch.arange(1, k + 1).to(lprobs) * self.diversity_rate + + if step == 0: + return self.beam.step(step, lprobs, scores) + lprobs.add_(scores[:, :, step - 1].unsqueeze(-1)) + + # 1/ Calculate hypotheses for each beam + for i in range(beam_size): + torch.topk(lprobs[:, i, :].view(bsz, -1), k, out=(s_list[i], i_list[i])) + i_list[i].fmod_(vocab_size) + + # 2/ Intra-sibling ordering by default from topk + 3/ Rewrite scores + s_list[i].sub_(sibling_score) + + # 4/ Choose top K hypotheses + indices = torch.stack(i_list, dim=1).view(bsz, -1) + + final_scores = torch.empty(0).to(lprobs) + final_indices = torch.LongTensor().to(device=lprobs.device) + final_beams = torch.LongTensor().to(device=lprobs.device) + (final_scores, final_indices) = torch.topk( + torch.stack(s_list, dim=1).view(bsz, -1), + k, + ) + + final_beams = final_indices // k + + for i in range(bsz): + final_indices[i] = indices[i][final_indices[i]] + + return final_scores, final_indices, final_beams diff --git a/models/sequence_generator.py b/models/sequence_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..77f436f86170bba3b6e083ff4e354331d648305b --- /dev/null +++ b/models/sequence_generator.py @@ -0,0 +1,1060 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from typing import Dict, List, Optional +import sys + +import torch +import torch.nn as nn +from fairseq import search, utils +from fairseq.models import FairseqIncrementalDecoder +from torch import Tensor +from fairseq.ngram_repeat_block import NGramRepeatBlock + +from data import data_utils + +class SequenceGenerator(nn.Module): + def __init__( + self, + models, + tgt_dict, + beam_size=1, + max_len_a=0, + max_len_b=200, + max_len=0, + min_len=1, + normalize_scores=True, + len_penalty=1.0, + unk_penalty=0.0, + temperature=1.0, + match_source_len=False, + no_repeat_ngram_size=0, + search_strategy=None, + eos=None, + symbols_to_strip_from_output=None, + lm_model=None, + lm_weight=1.0, + constraint_trie=None, + constraint_range=None, + gen_code=False, + gen_box=False, + ignore_eos=False, + zero_shot=False, + stop_on_max_len=True, + ): + """Generates translations of a given source sentence. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models, + currently support fairseq.models.TransformerModel for scripting + beam_size (int, optional): beam width (default: 1) + max_len_a/b (int, optional): generate sequences of maximum length + ax + b, where x is the source length + max_len (int, optional): the maximum length of the generated output + (not including end-of-sentence) + min_len (int, optional): the minimum length of the generated output + (not including end-of-sentence) + normalize_scores (bool, optional): normalize scores by the length + of the output (default: True) + len_penalty (float, optional): length penalty, where <1.0 favors + shorter, >1.0 favors longer sentences (default: 1.0) + unk_penalty (float, optional): unknown word penalty, where <0 + produces more unks, >0 produces fewer (default: 0.0) + temperature (float, optional): temperature, where values + >1.0 produce more uniform samples and values <1.0 produce + sharper samples (default: 1.0) + match_source_len (bool, optional): outputs should match the source + length (default: False) + """ + super().__init__() + if isinstance(models, EnsembleModel): + self.model = models + else: + self.model = EnsembleModel(models) + self.gen_code = gen_code + self.gen_box = gen_box + self.ignore_eos = ignore_eos + self.tgt_dict = tgt_dict + self.pad = tgt_dict.pad() + self.unk = tgt_dict.unk() + self.bos = tgt_dict.bos() + self.eos = tgt_dict.eos() if eos is None else eos + self.symbols_to_strip_from_output = ( + symbols_to_strip_from_output.union({self.eos}) + if symbols_to_strip_from_output is not None + else {self.bos, self.eos} + ) + self.vocab_size = len(tgt_dict) + self.beam_size = beam_size + # the max beam size is the dictionary size - 1, since we never select pad + self.beam_size = min(beam_size, self.vocab_size - 1) + self.max_len_a = max_len_a + self.max_len_b = max_len_b + self.min_len = min_len + self.max_len = max_len or self.model.max_decoder_positions() + + self.normalize_scores = normalize_scores + self.len_penalty = len_penalty + self.unk_penalty = unk_penalty + self.temperature = temperature + self.match_source_len = match_source_len + self.zero_shot = zero_shot + + if no_repeat_ngram_size > 0: + self.repeat_ngram_blocker = NGramRepeatBlock(no_repeat_ngram_size) + else: + self.repeat_ngram_blocker = None + + assert temperature > 0, "--temperature must be greater than 0" + + self.search = ( + search.BeamSearch(tgt_dict) if search_strategy is None else search_strategy + ) + self.search.stop_on_max_len = stop_on_max_len + # We only need to set src_lengths in LengthConstrainedBeamSearch. + # As a module attribute, setting it would break in multithread + # settings when the model is shared. + self.should_set_src_lengths = ( + hasattr(self.search, "needs_src_lengths") and self.search.needs_src_lengths + ) + + self.model.eval() + self.lm_model = lm_model + self.lm_weight = lm_weight + if self.lm_model is not None: + self.lm_model.eval() + + self.constraint_trie = constraint_trie + + self.constraint_start = None + self.constraint_end = None + if constraint_range is not None: + constraint_start, constraint_end = constraint_range.split(',') + self.constraint_start = int(constraint_start) + self.constraint_end = int(constraint_end) + + def cuda(self): + self.model.cuda() + return self + + @torch.no_grad() + def forward( + self, + sample: Dict[str, Dict[str, Tensor]], + prefix_tokens: Optional[Tensor] = None, + bos_token: Optional[int] = None, + ): + """Generate a batch of translations. + + Args: + sample (dict): batch + prefix_tokens (torch.LongTensor, optional): force decoder to begin + with these tokens + bos_token (int, optional): beginning of sentence token + (default: self.eos) + """ + return self._generate(sample, prefix_tokens, bos_token=bos_token) + + # TODO(myleott): unused, deprecate after pytorch-translate migration + def generate_batched_itr(self, data_itr, beam_size=None, cuda=False, timer=None): + """Iterate over a batched dataset and yield individual translations. + Args: + cuda (bool, optional): use GPU for generation + timer (StopwatchMeter, optional): time generations + """ + for sample in data_itr: + s = utils.move_to_cuda(sample) if cuda else sample + if "net_input" not in s: + continue + input = s["net_input"] + # model.forward normally channels prev_output_tokens into the decoder + # separately, but SequenceGenerator directly calls model.encoder + encoder_input = { + k: v for k, v in input.items() if k != "prev_output_tokens" + } + if timer is not None: + timer.start() + with torch.no_grad(): + hypos = self.generate(encoder_input) + if timer is not None: + timer.stop(sum(len(h[0]["tokens"]) for h in hypos)) + for i, id in enumerate(s["id"].data): + # remove padding + src = utils.strip_pad(input["src_tokens"].data[i, :], self.pad) + ref = ( + utils.strip_pad(s["target"].data[i, :], self.pad) + if s["target"] is not None + else None + ) + yield id, src, ref, hypos[i] + + @torch.no_grad() + def generate(self, models, sample: Dict[str, Dict[str, Tensor]], **kwargs) -> List[List[Dict[str, Tensor]]]: + """Generate translations. Match the api of other fairseq generators. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + sample (dict): batch + prefix_tokens (torch.LongTensor, optional): force decoder to begin + with these tokens + constraints (torch.LongTensor, optional): force decoder to include + the list of constraints + bos_token (int, optional): beginning of sentence token + (default: self.eos) + """ + return self._generate(models, sample, **kwargs) + + def _generate( + self, + models, + sample: Dict[str, Dict[str, Tensor]], + prefix_tokens: Optional[Tensor] = None, + constraints: Optional[Tensor] = None, + bos_token: Optional[int] = None, + ): + model = EnsembleModel(models) + incremental_states = torch.jit.annotate( + List[Dict[str, Dict[str, Optional[Tensor]]]], + [ + torch.jit.annotate(Dict[str, Dict[str, Optional[Tensor]]], {}) + for i in range(model.models_size) + ], + ) + net_input = sample["net_input"] + + if "src_tokens" in net_input: + src_tokens = net_input["src_tokens"] + # length of the source text being the character length except EndOfSentence and pad + src_lengths = ( + (src_tokens.ne(self.eos) & src_tokens.ne(self.pad)).long().sum(dim=1) + ) + elif "source" in net_input: + src_tokens = net_input["source"] + src_lengths = ( + net_input["padding_mask"].size(-1) - net_input["padding_mask"].sum(-1) + if net_input["padding_mask"] is not None + else torch.tensor(src_tokens.size(-1)).to(src_tokens) + ) + elif "features" in net_input: + src_tokens = net_input["features"] + src_lengths = ( + net_input["padding_mask"].size(-1) - net_input["padding_mask"].sum(-1) + if net_input["padding_mask"] is not None + else torch.tensor(src_tokens.size(-1)).to(src_tokens) + ) + else: + raise Exception("expected src_tokens or source in net input. input keys: " + str(net_input.keys())) + + # bsz: total number of sentences in beam + # Note that src_tokens may have more than 2 dimensions (i.e. audio features) + bsz, src_len = src_tokens.size()[:2] + beam_size = self.beam_size + + if constraints is not None and not self.search.supports_constraints: + raise NotImplementedError( + "Target-side constraints were provided, but search method doesn't support them" + ) + + # Initialize constraints, when active + self.search.init_constraints(constraints, beam_size) + + max_len: int = -1 + if self.match_source_len: + max_len = src_lengths.max().item() + else: + max_len = int(self.max_len_a * src_len + self.max_len_b) + assert ( + self.min_len <= max_len + ), "min_len cannot be larger than max_len, please adjust these!" + # compute the encoder output for each beam + + + with torch.autograd.profiler.record_function("EnsembleModel: forward_encoder"): + encoder_outs = model.forward_encoder(net_input) + + # placeholder of indices for bsz * beam_size to hold tokens and accumulative scores + new_order = torch.arange(bsz).view(-1, 1).repeat(1, beam_size).view(-1) + new_order = new_order.to(src_tokens.device).long() + encoder_outs = model.reorder_encoder_out(encoder_outs, new_order) + # ensure encoder_outs is a List. + assert encoder_outs is not None + + # initialize buffers + scores = ( + torch.zeros(bsz * beam_size, max_len + 1).to(src_tokens).float() + ) # +1 for eos; pad is never chosen for scoring + tokens = ( + torch.zeros(bsz * beam_size, max_len + 2) + .to(src_tokens) + .long() + .fill_(self.pad) + ) # +2 for eos and pad + # tokens[:, 0] = self.eos if bos_token is None else bos_token + tokens[:, 0] = self.bos + attn: Optional[Tensor] = None + + # A list that indicates candidates that should be ignored. + # For example, suppose we're sampling and have already finalized 2/5 + # samples. Then cands_to_ignore would mark 2 positions as being ignored, + # so that we only finalize the remaining 3 samples. + cands_to_ignore = ( + torch.zeros(bsz, beam_size).to(src_tokens).eq(-1) + ) # forward and backward-compatible False mask + + # list of completed sentences + finalized = torch.jit.annotate( + List[List[Dict[str, Tensor]]], + [torch.jit.annotate(List[Dict[str, Tensor]], []) for i in range(bsz)], + ) # contains lists of dictionaries of infomation about the hypothesis being finalized at each step + + # a boolean array indicating if the sentence at the index is finished or not + finished = [False for i in range(bsz)] + num_remaining_sent = bsz # number of sentences remaining + + # number of candidate hypos per step + cand_size = 2 * beam_size # 2 x beam size in case half are EOS + + # offset arrays for converting between different indexing schemes + bbsz_offsets = ( + (torch.arange(0, bsz) * beam_size) + .unsqueeze(1) + .type_as(tokens) + .to(src_tokens.device) + ) + cand_offsets = torch.arange(0, cand_size).type_as(tokens).to(src_tokens.device) + + reorder_state: Optional[Tensor] = None + batch_idxs: Optional[Tensor] = None + + original_batch_idxs: Optional[Tensor] = None + if "id" in sample and isinstance(sample["id"], Tensor): + original_batch_idxs = sample["id"] + else: + original_batch_idxs = torch.arange(0, bsz).type_as(tokens) + + for step in range(max_len + 1): # one extra step for EOS marker + # reorder decoder internal states based on the prev choice of beams + if reorder_state is not None: + if batch_idxs is not None: + # update beam indices to take into account removed sentences + corr = batch_idxs - torch.arange(batch_idxs.numel()).type_as( + batch_idxs + ) + reorder_state.view(-1, beam_size).add_( + corr.unsqueeze(-1) * beam_size + ) + original_batch_idxs = original_batch_idxs[batch_idxs] + model.reorder_incremental_state(incremental_states, reorder_state) + encoder_outs = model.reorder_encoder_out( + encoder_outs, reorder_state + ) + with torch.autograd.profiler.record_function("EnsembleModel: forward_decoder"): + lprobs, avg_attn_scores = model.forward_decoder( + tokens[:, : step + 1], + encoder_outs, + incremental_states, + self.temperature, + constraint_trie=self.constraint_trie, + constraint_start=self.constraint_start, + constraint_end=self.constraint_end, + gen_code=self.gen_code, + zero_shot=self.zero_shot, + prefix_tokens=prefix_tokens + ) + + if self.lm_model is not None: + lm_out = self.lm_model(tokens[:, : step + 1]) + probs = self.lm_model.get_normalized_probs( + lm_out, log_probs=True, sample=None + ) + probs = probs[:, -1, :] * self.lm_weight + lprobs += probs + # handle prefix tokens (possibly with different lengths) + if ( + prefix_tokens is not None + and step < prefix_tokens.size(1) + and step < max_len + ): + lprobs, tokens, scores = self._prefix_tokens( + step, lprobs, scores, tokens, prefix_tokens, beam_size + ) + elif step < self.min_len: + # minimum length constraint (does not apply if using prefix_tokens) + lprobs[:, self.eos] = -math.inf + + lprobs[lprobs != lprobs] = torch.tensor(-math.inf).to(lprobs) + lprobs[:, self.pad] = -math.inf # never select pad + lprobs[:, self.unk] -= self.unk_penalty # apply unk penalty + + if (self.gen_code or self.gen_box) and step < max_len: + lprobs[:, :4] = -math.inf + if self.gen_box: + lprobs[:, -1] = -math.inf + if (step + 1) % 5 == 0: + lprobs[:, self.constraint_start:59457] = -math.inf + else: + lprobs[:, 59457:] = -math.inf + + + # handle max length constraint + if step >= max_len: + lprobs[:, : self.eos] = -math.inf + lprobs[:, self.eos + 1 :] = -math.inf + if self.ignore_eos: + lprobs[:, self.eos] = 1 + + # Record attention scores, only support avg_attn_scores is a Tensor + + + if avg_attn_scores is not None: + if attn is None: + attn = torch.empty( + bsz * beam_size, avg_attn_scores.size(1), max_len + 2 + ).to(scores) + attn[:, :, step + 1].copy_(avg_attn_scores) + + scores = scores.type_as(lprobs) + eos_bbsz_idx = torch.empty(0).to( + tokens + ) # indices of hypothesis ending with eos (finished sentences) + eos_scores = torch.empty(0).to( + scores + ) # scores of hypothesis ending with eos (finished sentences) + + if self.should_set_src_lengths: + self.search.set_src_lengths(src_lengths) + + + if self.repeat_ngram_blocker is not None: + lprobs = self.repeat_ngram_blocker(tokens, lprobs, bsz, beam_size, step) + # Shape: (batch, cand_size) + cand_scores, cand_indices, cand_beams = self.search.step( + step, + lprobs.view(bsz, -1, self.vocab_size), + scores.view(bsz, beam_size, -1)[:, :, :step], + tokens[:, : step + 1], + original_batch_idxs, + ) + + # cand_bbsz_idx contains beam indices for the top candidate + # hypotheses, with a range of values: [0, bsz*beam_size), + # and dimensions: [bsz, cand_size] + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + + # finalize hypotheses that end in eos + # Shape of eos_mask: (batch size, beam size) + + eos_mask = cand_indices.eq(self.eos) & cand_scores.ne(-math.inf) + eos_mask[:, :beam_size][cands_to_ignore] = torch.tensor(0).to(eos_mask) + + + # only consider eos when it's among the top beam_size indices + # Now we know what beam item(s) to finish + # Shape: 1d list of absolute-numbered + eos_bbsz_idx = torch.masked_select( + cand_bbsz_idx[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + + finalized_sents: List[int] = [] + if eos_bbsz_idx.numel() > 0: + eos_scores = torch.masked_select( + cand_scores[:, :beam_size], mask=eos_mask[:, :beam_size] + ) + + finalized_sents = self.finalize_hypos( + step, + eos_bbsz_idx, + eos_scores, + tokens, + scores, + finalized, + finished, + beam_size, + attn, + src_lengths, + max_len, + ) + num_remaining_sent -= len(finalized_sents) + + assert num_remaining_sent >= 0 + if num_remaining_sent == 0: + break + if self.search.stop_on_max_len and step >= max_len: + break + assert step < max_len, f"{step} < {max_len}" + + # Remove finalized sentences (ones for which {beam_size} + # finished hypotheses have been generated) from the batch. + if len(finalized_sents) > 0: + new_bsz = bsz - len(finalized_sents) + + # construct batch_idxs which holds indices of batches to keep for the next pass + batch_mask = torch.ones( + bsz, dtype=torch.bool, device=cand_indices.device + ) + batch_mask[finalized_sents] = False + # TODO replace `nonzero(as_tuple=False)` after TorchScript supports it + batch_idxs = torch.arange( + bsz, device=cand_indices.device + ).masked_select(batch_mask) + + # Choose the subset of the hypothesized constraints that will continue + self.search.prune_sentences(batch_idxs) + + eos_mask = eos_mask[batch_idxs] + cand_beams = cand_beams[batch_idxs] + bbsz_offsets.resize_(new_bsz, 1) + cand_bbsz_idx = cand_beams.add(bbsz_offsets) + cand_scores = cand_scores[batch_idxs] + cand_indices = cand_indices[batch_idxs] + + if prefix_tokens is not None: + prefix_tokens = prefix_tokens[batch_idxs] + src_lengths = src_lengths[batch_idxs] + cands_to_ignore = cands_to_ignore[batch_idxs] + + scores = scores.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + tokens = tokens.view(bsz, -1)[batch_idxs].view(new_bsz * beam_size, -1) + if attn is not None: + attn = attn.view(bsz, -1)[batch_idxs].view( + new_bsz * beam_size, attn.size(1), -1 + ) + bsz = new_bsz + else: + batch_idxs = None + + # Set active_mask so that values > cand_size indicate eos hypos + # and values < cand_size indicate candidate active hypos. + # After, the min values per row are the top candidate active hypos + + # Rewrite the operator since the element wise or is not supported in torchscript. + + eos_mask[:, :beam_size] = ~((~cands_to_ignore) & (~eos_mask[:, :beam_size])) + active_mask = torch.add( + eos_mask.type_as(cand_offsets) * cand_size, + cand_offsets[: eos_mask.size(1)], + ) + + # get the top beam_size active hypotheses, which are just + # the hypos with the smallest values in active_mask. + # {active_hypos} indicates which {beam_size} hypotheses + # from the list of {2 * beam_size} candidates were + # selected. Shapes: (batch size, beam size) + new_cands_to_ignore, active_hypos = torch.topk( + active_mask, k=beam_size, dim=1, largest=False + ) + + # update cands_to_ignore to ignore any finalized hypos. + cands_to_ignore = new_cands_to_ignore.ge(cand_size)[:, :beam_size] + # Make sure there is at least one active item for each sentence in the batch. + assert (~cands_to_ignore).any(dim=1).all() + + # update cands_to_ignore to ignore any finalized hypos + + # {active_bbsz_idx} denotes which beam number is continued for each new hypothesis (a beam + # can be selected more than once). + active_bbsz_idx = torch.gather(cand_bbsz_idx, dim=1, index=active_hypos) + active_scores = torch.gather(cand_scores, dim=1, index=active_hypos) + + active_bbsz_idx = active_bbsz_idx.view(-1) + active_scores = active_scores.view(-1) + + # copy tokens and scores for active hypotheses + + # Set the tokens for each beam (can select the same row more than once) + tokens[:, : step + 1] = torch.index_select( + tokens[:, : step + 1], dim=0, index=active_bbsz_idx + ) + # Select the next token for each of them + tokens.view(bsz, beam_size, -1)[:, :, step + 1] = torch.gather( + cand_indices, dim=1, index=active_hypos + ) + if step > 0: + scores[:, :step] = torch.index_select( + scores[:, :step], dim=0, index=active_bbsz_idx + ) + scores.view(bsz, beam_size, -1)[:, :, step] = torch.gather( + cand_scores, dim=1, index=active_hypos + ) + + # Update constraints based on which candidates were selected for the next beam + self.search.update_constraints(active_hypos) + + # copy attention for active hypotheses + if attn is not None: + attn[:, :, : step + 2] = torch.index_select( + attn[:, :, : step + 2], dim=0, index=active_bbsz_idx + ) + + # reorder incremental state in decoder + reorder_state = active_bbsz_idx + + # sort by score descending + for sent in range(len(finalized)): + scores = torch.tensor( + [float(elem["score"].item()) for elem in finalized[sent]] + ) + _, sorted_scores_indices = torch.sort(scores, descending=True) + finalized[sent] = [finalized[sent][ssi] for ssi in sorted_scores_indices] + finalized[sent] = torch.jit.annotate( + List[Dict[str, Tensor]], finalized[sent] + ) + return finalized + + def _prefix_tokens( + self, step: int, lprobs, scores, tokens, prefix_tokens, beam_size: int + ): + """Handle prefix tokens""" + prefix_toks = prefix_tokens[:, step].unsqueeze(-1).repeat(1, beam_size).view(-1) + prefix_lprobs = lprobs.gather(-1, prefix_toks.unsqueeze(-1)) + prefix_mask = prefix_toks.ne(self.pad) + if self.constraint_trie is None: + lprobs[prefix_mask] = torch.min(prefix_lprobs) - 1 + else: + lprobs[prefix_mask] = -math.inf + lprobs[prefix_mask] = lprobs[prefix_mask].scatter( + -1, prefix_toks[prefix_mask].unsqueeze(-1), prefix_lprobs[prefix_mask] + ) + # if prefix includes eos, then we should make sure tokens and + # scores are the same across all beams + eos_mask = prefix_toks.eq(self.eos) + if eos_mask.any(): + # validate that the first beam matches the prefix + first_beam = tokens[eos_mask].view(-1, beam_size, tokens.size(-1))[ + :, 0, 1 : step + 1 + ] + eos_mask_batch_dim = eos_mask.view(-1, beam_size)[:, 0] + target_prefix = prefix_tokens[eos_mask_batch_dim][:, :step] + assert (first_beam == target_prefix).all() + + # copy tokens, scores and lprobs from the first beam to all beams + tokens = self.replicate_first_beam(tokens, eos_mask_batch_dim, beam_size) + scores = self.replicate_first_beam(scores, eos_mask_batch_dim, beam_size) + lprobs = self.replicate_first_beam(lprobs, eos_mask_batch_dim, beam_size) + return lprobs, tokens, scores + + def replicate_first_beam(self, tensor, mask, beam_size: int): + tensor = tensor.view(-1, beam_size, tensor.size(-1)) + tensor[mask] = tensor[mask][:, :1, :] + return tensor.view(-1, tensor.size(-1)) + + def finalize_hypos( + self, + step: int, + bbsz_idx, + eos_scores, + tokens, + scores, + finalized: List[List[Dict[str, Tensor]]], + finished: List[bool], + beam_size: int, + attn: Optional[Tensor], + src_lengths, + max_len: int, + ): + """Finalize hypothesis, store finalized information in `finalized`, and change `finished` accordingly. + A sentence is finalized when {beam_size} finished items have been collected for it. + + Returns number of sentences (not beam items) being finalized. + These will be removed from the batch and not processed further. + Args: + bbsz_idx (Tensor): + """ + assert bbsz_idx.numel() == eos_scores.numel() + + # clone relevant token and attention tensors. + # tokens is (batch * beam, max_len). So the index_select + # gets the newly EOS rows, then selects cols 1..{step + 2} + tokens_clone = tokens.index_select(0, bbsz_idx)[ + :, 1 : step + 2 + ] # skip the first index, which is EOS + + tokens_clone[:, step] = self.eos + attn_clone = ( + attn.index_select(0, bbsz_idx)[:, :, 1 : step + 2] + if attn is not None + else None + ) + + # compute scores per token position + pos_scores = scores.index_select(0, bbsz_idx)[:, : step + 1] + pos_scores[:, step] = eos_scores + # convert from cumulative to per-position scores + pos_scores[:, 1:] = pos_scores[:, 1:] - pos_scores[:, :-1] + + # normalize sentence-level scores + if self.normalize_scores: + eos_scores /= (step + 1) ** self.len_penalty + + # cum_unfin records which sentences in the batch are finished. + # It helps match indexing between (a) the original sentences + # in the batch and (b) the current, possibly-reduced set of + # sentences. + cum_unfin: List[int] = [] + prev = 0 + for f in finished: + if f: + prev += 1 + else: + cum_unfin.append(prev) + cum_fin_tensor = torch.tensor(cum_unfin, dtype=torch.int).to(bbsz_idx) + + unfin_idx = bbsz_idx // beam_size + sent = unfin_idx + torch.index_select(cum_fin_tensor, 0, unfin_idx) + + # Create a set of "{sent}{unfin_idx}", where + # "unfin_idx" is the index in the current (possibly reduced) + # list of sentences, and "sent" is the index in the original, + # unreduced batch + # For every finished beam item + # sentence index in the current (possibly reduced) batch + seen = (sent << 32) + unfin_idx + unique_seen: List[int] = torch.unique(seen).tolist() + + if self.match_source_len: + condition = step > torch.index_select(src_lengths, 0, unfin_idx) + eos_scores = torch.where(condition, torch.tensor(-math.inf), eos_scores) + sent_list: List[int] = sent.tolist() + for i in range(bbsz_idx.size()[0]): + # An input sentence (among those in a batch) is finished when + # beam_size hypotheses have been collected for it + if len(finalized[sent_list[i]]) < beam_size: + if attn_clone is not None: + # remove padding tokens from attn scores + hypo_attn = attn_clone[i] + else: + hypo_attn = torch.empty(0) + + finalized[sent_list[i]].append( + { + "tokens": tokens_clone[i], + "score": eos_scores[i], + "attention": hypo_attn, # src_len x tgt_len + "alignment": torch.empty(0), + "positional_scores": pos_scores[i], + } + ) + + newly_finished: List[int] = [] + for unique_s in unique_seen: + # check termination conditions for this sentence + unique_sent: int = unique_s >> 32 + unique_unfin_idx: int = unique_s - (unique_sent << 32) + + if not finished[unique_sent] and self.is_finished( + step, unique_unfin_idx, max_len, len(finalized[unique_sent]), beam_size + ): + finished[unique_sent] = True + newly_finished.append(unique_unfin_idx) + + return newly_finished + + def is_finished( + self, + step: int, + unfin_idx: int, + max_len: int, + finalized_sent_len: int, + beam_size: int, + ): + """ + Check whether decoding for a sentence is finished, which + occurs when the list of finalized sentences has reached the + beam size, or when we reach the maximum length. + """ + assert finalized_sent_len <= beam_size + if finalized_sent_len == beam_size or step == max_len: + return True + return False + + +class EnsembleModel(nn.Module): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__() + self.models_size = len(models) + # method '__len__' is not supported in ModuleList for torch script + self.single_model = models[0] + self.models = nn.ModuleList(models) + + self.has_incremental: bool = False + if all( + hasattr(m, "decoder") and isinstance(m.decoder, FairseqIncrementalDecoder) + for m in models + ): + self.has_incremental = True + + def forward(self): + pass + + def has_encoder(self): + return hasattr(self.single_model, "encoder") + + def has_incremental_states(self): + return self.has_incremental + + def max_decoder_positions(self): + return min([m.max_decoder_positions() for m in self.models if hasattr(m, "max_decoder_positions")] + [sys.maxsize]) + + @torch.jit.export + def forward_encoder(self, net_input: Dict[str, Tensor]): + if not self.has_encoder(): + return None + return [model.encoder.forward_torchscript(net_input) for model in self.models] + + @torch.jit.export + def forward_decoder( + self, + tokens, + encoder_outs: List[Dict[str, List[Tensor]]], + incremental_states: List[Dict[str, Dict[str, Optional[Tensor]]]], + temperature: float = 1.0, + constraint_trie=None, + constraint_start=None, + constraint_end=None, + gen_code=False, + zero_shot=False, + prefix_tokens=None + ): + log_probs = [] + avg_attn: Optional[Tensor] = None + encoder_out: Optional[Dict[str, List[Tensor]]] = None + code_mask = (tokens.new_ones(tokens.size(0))*gen_code).bool() + for i, model in enumerate(self.models): + if self.has_encoder(): + encoder_out = encoder_outs[i] + # decode each model + if self.has_incremental_states(): + decoder_out = model.decoder.forward( + tokens, + code_masks=code_mask, + encoder_out=encoder_out, + incremental_state=incremental_states[i], + ) + else: + if hasattr(model, "decoder"): + decoder_out = model.decoder.forward(tokens, code_masks=code_mask, encoder_out=encoder_out) + else: + decoder_out = model.forward(tokens) + + attn: Optional[Tensor] = None + decoder_len = len(decoder_out) + if decoder_len > 1 and decoder_out[1] is not None: + if isinstance(decoder_out[1], Tensor): + attn = decoder_out[1] + else: + attn_holder = decoder_out[1]["attn"] + if isinstance(attn_holder, Tensor): + attn = attn_holder + elif attn_holder is not None: + attn = attn_holder[0] + if attn is not None: + attn = attn[:, -1, :] + + decoder_out_tuple = ( + decoder_out[0][:, -1:, :].div_(temperature), + None if decoder_len <= 1 else decoder_out[1], + ) + + beam_size = decoder_out_tuple[0].size(0) // prefix_tokens.size(0) if prefix_tokens is not None else 0 + if constraint_trie is not None and not zero_shot: + assert constraint_start is None and constraint_end is None + constraint_masks = decoder_out_tuple[0].new_zeros(decoder_out_tuple[0].size()).bool() + constraint_prefix_tokens = tokens.tolist() + for token_index, constraint_prefix_token in enumerate(constraint_prefix_tokens): + prefix_len = prefix_tokens[token_index // beam_size].ne(1).sum().item() if prefix_tokens is not None else 0 + if len(constraint_prefix_token) > prefix_len: + constraint_prefix_token = [0] + constraint_prefix_token[prefix_len+1:] + constraint_nodes = constraint_trie.get_next_layer(constraint_prefix_token) + constraint_masks[token_index][:, constraint_nodes] = True + else: + constraint_masks[token_index] = True + decoder_out_tuple[0].masked_fill_(~constraint_masks, -math.inf) + if constraint_start is not None and constraint_end is not None and not zero_shot: + assert constraint_trie is None + decoder_out_tuple[0][:, :, 4:constraint_start] = -math.inf + decoder_out_tuple[0][:, :, constraint_end:] = -math.inf + + probs = model.get_normalized_probs( + decoder_out_tuple, log_probs=True, sample=None + ) + if constraint_trie is not None and zero_shot: + assert constraint_start is None and constraint_end is None + constraint_masks = decoder_out_tuple[0].new_zeros(decoder_out_tuple[0].size()).bool() + constraint_prefix_tokens = tokens.tolist() + for token_index, constraint_prefix_token in enumerate(constraint_prefix_tokens): + constraint_nodes = constraint_trie.get_next_layer(constraint_prefix_token) + constraint_masks[token_index][:, constraint_nodes] = True + probs.masked_fill_(~constraint_masks, -math.inf) + if constraint_start is not None and constraint_end is not None and zero_shot: + assert constraint_trie is None + probs[:, :, 4:constraint_start] = -math.inf + probs[:, :, constraint_end:] = -math.inf + probs = probs[:, -1, :] + if self.models_size == 1: + return probs, attn + + log_probs.append(probs) + if attn is not None: + if avg_attn is None: + avg_attn = attn + else: + avg_attn.add_(attn) + + avg_probs = torch.logsumexp(torch.stack(log_probs, dim=0), dim=0) - math.log( + self.models_size + ) + + if avg_attn is not None: + avg_attn.div_(self.models_size) + return avg_probs, avg_attn + + @torch.jit.export + def reorder_encoder_out( + self, encoder_outs: Optional[List[Dict[str, List[Tensor]]]], new_order + ): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + new_outs: List[Dict[str, List[Tensor]]] = [] + if not self.has_encoder(): + return new_outs + for i, model in enumerate(self.models): + assert encoder_outs is not None + new_outs.append( + model.encoder.reorder_encoder_out(encoder_outs[i], new_order) + ) + return new_outs + + @torch.jit.export + def reorder_incremental_state( + self, + incremental_states: List[Dict[str, Dict[str, Optional[Tensor]]]], + new_order, + ): + if not self.has_incremental_states(): + return + for i, model in enumerate(self.models): + model.decoder.reorder_incremental_state_scripting( + incremental_states[i], new_order + ) + + +class SequenceGeneratorWithAlignment(SequenceGenerator): + def __init__( + self, models, tgt_dict, left_pad_target=False, print_alignment="hard", **kwargs + ): + """Generates translations of a given source sentence. + + Produces alignments following "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + left_pad_target (bool, optional): Whether or not the + hypothesis should be left padded or not when they are + teacher forced for generating alignments. + """ + super().__init__(EnsembleModelWithAlignment(models), tgt_dict, **kwargs) + self.left_pad_target = left_pad_target + + if print_alignment == "hard": + self.extract_alignment = utils.extract_hard_alignment + elif print_alignment == "soft": + self.extract_alignment = utils.extract_soft_alignment + + @torch.no_grad() + def generate(self, models, sample, **kwargs): + finalized = super()._generate(sample, **kwargs) + + src_tokens = sample["net_input"]["src_tokens"] + bsz = src_tokens.shape[0] + beam_size = self.beam_size + ( + src_tokens, + src_lengths, + prev_output_tokens, + tgt_tokens, + ) = self._prepare_batch_for_alignment(sample, finalized) + if any(getattr(m, "full_context_alignment", False) for m in self.model.models): + attn = self.model.forward_align(src_tokens, src_lengths, prev_output_tokens) + else: + attn = [ + finalized[i // beam_size][i % beam_size]["attention"].transpose(1, 0) + for i in range(bsz * beam_size) + ] + + if src_tokens.device != "cpu": + src_tokens = src_tokens.to("cpu") + tgt_tokens = tgt_tokens.to("cpu") + attn = [i.to("cpu") for i in attn] + + # Process the attn matrix to extract hard alignments. + for i in range(bsz * beam_size): + alignment = self.extract_alignment( + attn[i], src_tokens[i], tgt_tokens[i], self.pad, self.eos + ) + finalized[i // beam_size][i % beam_size]["alignment"] = alignment + return finalized + + def _prepare_batch_for_alignment(self, sample, hypothesis): + src_tokens = sample["net_input"]["src_tokens"] + bsz = src_tokens.shape[0] + src_tokens = ( + src_tokens[:, None, :] + .expand(-1, self.beam_size, -1) + .contiguous() + .view(bsz * self.beam_size, -1) + ) + src_lengths = sample["net_input"]["src_lengths"] + src_lengths = ( + src_lengths[:, None] + .expand(-1, self.beam_size) + .contiguous() + .view(bsz * self.beam_size) + ) + prev_output_tokens = data_utils.collate_tokens( + [beam["tokens"] for example in hypothesis for beam in example], + self.pad, + self.eos, + self.left_pad_target, + move_eos_to_beginning=True, + ) + tgt_tokens = data_utils.collate_tokens( + [beam["tokens"] for example in hypothesis for beam in example], + self.pad, + self.eos, + self.left_pad_target, + move_eos_to_beginning=False, + ) + return src_tokens, src_lengths, prev_output_tokens, tgt_tokens + + +class EnsembleModelWithAlignment(EnsembleModel): + """A wrapper around an ensemble of models.""" + + def __init__(self, models): + super().__init__(models) + + def forward_align(self, src_tokens, src_lengths, prev_output_tokens): + avg_attn = None + for model in self.models: + decoder_out = model(src_tokens, src_lengths, prev_output_tokens) + attn = decoder_out[1]["attn"][0] + if avg_attn is None: + avg_attn = attn + else: + avg_attn.add_(attn) + if len(self.models) > 1: + avg_attn.div_(len(self.models)) + return avg_attn diff --git a/models/taming/.ipynb_checkpoints/util-checkpoint.py b/models/taming/.ipynb_checkpoints/util-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..7443b29e3d223a3ad396808f9717fb9a11c7507c --- /dev/null +++ b/models/taming/.ipynb_checkpoints/util-checkpoint.py @@ -0,0 +1,172 @@ +import os, hashlib +import requests +from tqdm import tqdm +import importlib + +URL_MAP = { + "vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1" +} + +CKPT_MAP = { + "vgg_lpips": "vgg.pth" +} + +MD5_MAP = { + "vgg_lpips": "d507d7349b931f0638a25a48a722f98a" +} + + +def get_obj_from_str(string, reload=False): + module, cls = string.rsplit(".", 1) + if reload: + module_imp = importlib.import_module(module) + importlib.reload(module_imp) + return getattr(importlib.import_module(module, package=None), cls) + + +def instantiate_from_config(config): + if not "target" in config: + raise KeyError("Expected key `target` to instantiate.") + return get_obj_from_str(config["target"])(**config.get("params", dict())) + + +def download(url, local_path, chunk_size=1024): + os.makedirs(os.path.split(local_path)[0], exist_ok=True) + with requests.get(url, stream=True) as r: + total_size = int(r.headers.get("content-length", 0)) + with tqdm(total=total_size, unit="B", unit_scale=True) as pbar: + with open(local_path, "wb") as f: + for data in r.iter_content(chunk_size=chunk_size): + if data: + f.write(data) + pbar.update(chunk_size) + + +def md5_hash(path): + with open(path, "rb") as f: + content = f.read() + return hashlib.md5(content).hexdigest() + + +def get_ckpt_path(name, root, check=False): + assert name in URL_MAP + path = os.path.join(root, CKPT_MAP[name]) + if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]): + print("Downloading {} model from {} to {}".format(name, URL_MAP[name], path)) + download(URL_MAP[name], path) + md5 = md5_hash(path) + assert md5 == MD5_MAP[name], md5 + return path + + +class KeyNotFoundError(Exception): + def __init__(self, cause, keys=None, visited=None): + self.cause = cause + self.keys = keys + self.visited = visited + messages = list() + if keys is not None: + messages.append("Key not found: {}".format(keys)) + if visited is not None: + messages.append("Visited: {}".format(visited)) + messages.append("Cause:\n{}".format(cause)) + message = "\n".join(messages) + super().__init__(message) + + +def retrieve( + list_or_dict, key, splitval="/", default=None, expand=True, pass_success=False +): + """Given a nested list or dict return the desired value at key expanding + callable nodes if necessary and :attr:`expand` is ``True``. The expansion + is done in-place. + + Parameters + ---------- + list_or_dict : list or dict + Possibly nested list or dictionary. + key : str + key/to/value, path like string describing all keys necessary to + consider to get to the desired value. List indices can also be + passed here. + splitval : str + String that defines the delimiter between keys of the + different depth levels in `key`. + default : obj + Value returned if :attr:`key` is not found. + expand : bool + Whether to expand callable nodes on the path or not. + + Returns + ------- + The desired value or if :attr:`default` is not ``None`` and the + :attr:`key` is not found returns ``default``. + + Raises + ------ + Exception if ``key`` not in ``list_or_dict`` and :attr:`default` is + ``None``. + """ + + keys = key.split(splitval) + + success = True + try: + visited = [] + parent = None + last_key = None + for key in keys: + if callable(list_or_dict): + if not expand: + raise KeyNotFoundError( + ValueError( + "Trying to get past callable node with expand=False." + ), + keys=keys, + visited=visited, + ) + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + + last_key = key + parent = list_or_dict + + try: + if isinstance(list_or_dict, dict): + list_or_dict = list_or_dict[key] + else: + list_or_dict = list_or_dict[int(key)] + except (KeyError, IndexError, ValueError) as e: + raise KeyNotFoundError(e, keys=keys, visited=visited) + + visited += [key] + # final expansion of retrieved value + if expand and callable(list_or_dict): + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + except KeyNotFoundError as e: + if default is None: + raise e + else: + list_or_dict = default + success = False + + if not pass_success: + return list_or_dict + else: + return list_or_dict, success + + +if __name__ == "__main__": + config = {"keya": "a", + "keyb": "b", + "keyc": + {"cc1": 1, + "cc2": 2, + } + } + from omegaconf import OmegaConf + + config = OmegaConf.create(config) + print(config) + retrieve(config, "keya") diff --git a/models/taming/__pycache__/lr_scheduler.cpython-39.pyc b/models/taming/__pycache__/lr_scheduler.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..509937ab23efb2bf99e622b0bb458a708088894f Binary files /dev/null and b/models/taming/__pycache__/lr_scheduler.cpython-39.pyc differ diff --git a/models/taming/__pycache__/util.cpython-37.pyc b/models/taming/__pycache__/util.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8b2de7620ae877c2b689054d3960253a9288a59 Binary files /dev/null and b/models/taming/__pycache__/util.cpython-37.pyc differ diff --git a/models/taming/__pycache__/util.cpython-38.pyc b/models/taming/__pycache__/util.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13e3e1e88beac9576807852850a0f357bbe9e507 Binary files /dev/null and b/models/taming/__pycache__/util.cpython-38.pyc differ diff --git a/models/taming/__pycache__/util.cpython-39.pyc b/models/taming/__pycache__/util.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5e18f23a5bcca2c96b7ee3d9faa07288817b9ac Binary files /dev/null and b/models/taming/__pycache__/util.cpython-39.pyc differ diff --git a/models/taming/lr_scheduler.py b/models/taming/lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..b77ca7009e6cb045e980ceca7576588c26bd1777 --- /dev/null +++ b/models/taming/lr_scheduler.py @@ -0,0 +1,39 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import numpy as np + + +class LambdaWarmUpCosineScheduler: + """ + note: use with a base_lr of 1.0 + """ + def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0): + self.lr_warm_up_steps = warm_up_steps + self.lr_start = lr_start + self.lr_min = lr_min + self.lr_max = lr_max + self.lr_max_decay_steps = max_decay_steps + self.last_lr = 0. + self.verbosity_interval = verbosity_interval + + def schedule(self, n): + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}") + if n < self.lr_warm_up_steps: + lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start + self.last_lr = lr + return lr + else: + t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps) + t = min(t, 1.0) + lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * ( + 1 + np.cos(t * np.pi)) + self.last_lr = lr + return lr + + def __call__(self, n): + return self.schedule(n) + diff --git a/models/taming/models/.ipynb_checkpoints/vqgan-checkpoint.py b/models/taming/models/.ipynb_checkpoints/vqgan-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..b9d7dae15ae3199ba3e5996f99d97852c3f11e48 --- /dev/null +++ b/models/taming/models/.ipynb_checkpoints/vqgan-checkpoint.py @@ -0,0 +1,262 @@ +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from models.taming.util import instantiate_from_config + +from models.taming.modules.diffusionmodules.model import Encoder, Decoder +from models.taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer +from models.taming.modules.vqvae.quantize import GumbelQuantize + +class VQModel(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__() + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25, + remap=remap, sane_index_shape=sane_index_shape) + self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.image_key = image_key + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + quant, emb_loss, info = self.quantize(h) + return quant, emb_loss, info + + def decode(self, quant): + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + def decode_code(self, code_b): + quant_b = self.quantize.embed_code(code_b) + dec = self.decode(quant_b) + return dec + + def forward(self, input): + quant, diff, _ = self.encode(input) + dec = self.decode(quant) + return dec, diff + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + return x.float() + + def training_step(self, batch, batch_idx, optimizer_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("train/aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("train/discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class GumbelVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + temperature_scheduler_config, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + kl_weight=1e-8, + remap=None, + ): + + z_channels = ddconfig["z_channels"] + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + + self.loss.n_classes = n_embed + self.vocab_size = n_embed + + self.quantize = GumbelQuantize(z_channels, embed_dim, + n_embed=n_embed, + kl_weight=kl_weight, temp_init=1.0, + remap=remap) + + self.temperature_scheduler = instantiate_from_config(temperature_scheduler_config) # annealing of temp + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def temperature_scheduling(self): + self.quantize.temperature = self.temperature_scheduler(self.global_step) + + def encode_to_prequant(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode_code(self, code_b): + quant_b = self.quantize.get_codebook_entry(code_b.view(-1), list(code_b.size())+[self.quantize.embedding_dim]) + dec = self.decode(quant_b) + return dec + + def training_step(self, batch, batch_idx, optimizer_idx): + self.temperature_scheduling() + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + self.log("temperature", self.quantize.temperature, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x, return_pred_indices=True) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + # encode + h = self.encoder(x) + h = self.quant_conv(h) + quant, _, _ = self.quantize(h) + # decode + x_rec = self.decode(quant) + log["inputs"] = x + log["reconstructions"] = x_rec + return log diff --git a/models/taming/models/__pycache__/vqgan.cpython-37.pyc b/models/taming/models/__pycache__/vqgan.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ca88637274ece748a61036d37b2739c95f8f265 Binary files /dev/null and b/models/taming/models/__pycache__/vqgan.cpython-37.pyc differ diff --git a/models/taming/models/__pycache__/vqgan.cpython-38.pyc b/models/taming/models/__pycache__/vqgan.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef878dc921d6161dca7fed8083813ced636d0670 Binary files /dev/null and b/models/taming/models/__pycache__/vqgan.cpython-38.pyc differ diff --git a/models/taming/models/__pycache__/vqgan.cpython-39.pyc b/models/taming/models/__pycache__/vqgan.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..250693d7f30c1e05b2ebeda346ec7b3b02a76728 Binary files /dev/null and b/models/taming/models/__pycache__/vqgan.cpython-39.pyc differ diff --git a/models/taming/models/vqgan.py b/models/taming/models/vqgan.py new file mode 100644 index 0000000000000000000000000000000000000000..b9d7dae15ae3199ba3e5996f99d97852c3f11e48 --- /dev/null +++ b/models/taming/models/vqgan.py @@ -0,0 +1,262 @@ +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from models.taming.util import instantiate_from_config + +from models.taming.modules.diffusionmodules.model import Encoder, Decoder +from models.taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer +from models.taming.modules.vqvae.quantize import GumbelQuantize + +class VQModel(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__() + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25, + remap=remap, sane_index_shape=sane_index_shape) + self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.image_key = image_key + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + quant, emb_loss, info = self.quantize(h) + return quant, emb_loss, info + + def decode(self, quant): + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + def decode_code(self, code_b): + quant_b = self.quantize.embed_code(code_b) + dec = self.decode(quant_b) + return dec + + def forward(self, input): + quant, diff, _ = self.encode(input) + dec = self.decode(quant) + return dec, diff + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + return x.float() + + def training_step(self, batch, batch_idx, optimizer_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("train/aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("train/discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class GumbelVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + temperature_scheduler_config, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + kl_weight=1e-8, + remap=None, + ): + + z_channels = ddconfig["z_channels"] + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + + self.loss.n_classes = n_embed + self.vocab_size = n_embed + + self.quantize = GumbelQuantize(z_channels, embed_dim, + n_embed=n_embed, + kl_weight=kl_weight, temp_init=1.0, + remap=remap) + + self.temperature_scheduler = instantiate_from_config(temperature_scheduler_config) # annealing of temp + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def temperature_scheduling(self): + self.quantize.temperature = self.temperature_scheduler(self.global_step) + + def encode_to_prequant(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode_code(self, code_b): + quant_b = self.quantize.get_codebook_entry(code_b.view(-1), list(code_b.size())+[self.quantize.embedding_dim]) + dec = self.decode(quant_b) + return dec + + def training_step(self, batch, batch_idx, optimizer_idx): + self.temperature_scheduling() + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + self.log("temperature", self.quantize.temperature, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x, return_pred_indices=True) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + # encode + h = self.encoder(x) + h = self.quant_conv(h) + quant, _, _ = self.quantize(h) + # decode + x_rec = self.decode(quant) + log["inputs"] = x + log["reconstructions"] = x_rec + return log diff --git a/models/taming/modules/.ipynb_checkpoints/util-checkpoint.py b/models/taming/modules/.ipynb_checkpoints/util-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..9ee16385d8b1342a2d60a5f1aa5cadcfbe934bd8 --- /dev/null +++ b/models/taming/modules/.ipynb_checkpoints/util-checkpoint.py @@ -0,0 +1,130 @@ +import torch +import torch.nn as nn + + +def count_params(model): + total_params = sum(p.numel() for p in model.parameters()) + return total_params + + +class ActNorm(nn.Module): + def __init__(self, num_features, logdet=False, affine=True, + allow_reverse_init=False): + assert affine + super().__init__() + self.logdet = logdet + self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1)) + self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1)) + self.allow_reverse_init = allow_reverse_init + + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def initialize(self, input): + with torch.no_grad(): + flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1) + mean = ( + flatten.mean(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + std = ( + flatten.std(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + + self.loc.data.copy_(-mean) + self.scale.data.copy_(1 / (std + 1e-6)) + + def forward(self, input, reverse=False): + if reverse: + return self.reverse(input) + if len(input.shape) == 2: + input = input[:,:,None,None] + squeeze = True + else: + squeeze = False + + _, _, height, width = input.shape + + if self.training and self.initialized.item() == 0: + self.initialize(input) + self.initialized.fill_(1) + + h = self.scale * (input + self.loc) + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + + if self.logdet: + log_abs = torch.log(torch.abs(self.scale)) + logdet = height*width*torch.sum(log_abs) + logdet = logdet * torch.ones(input.shape[0]).to(input) + return h, logdet + + return h + + def reverse(self, output): + if self.training and self.initialized.item() == 0: + if not self.allow_reverse_init: + raise RuntimeError( + "Initializing ActNorm in reverse direction is " + "disabled by default. Use allow_reverse_init=True to enable." + ) + else: + self.initialize(output) + self.initialized.fill_(1) + + if len(output.shape) == 2: + output = output[:,:,None,None] + squeeze = True + else: + squeeze = False + + h = output / self.scale - self.loc + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + return h + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + + +class Labelator(AbstractEncoder): + """Net2Net Interface for Class-Conditional Model""" + def __init__(self, n_classes, quantize_interface=True): + super().__init__() + self.n_classes = n_classes + self.quantize_interface = quantize_interface + + def encode(self, c): + c = c[:,None] + if self.quantize_interface: + return c, None, [None, None, c.long()] + return c + + +class SOSProvider(AbstractEncoder): + # for unconditional training + def __init__(self, sos_token, quantize_interface=True): + super().__init__() + self.sos_token = sos_token + self.quantize_interface = quantize_interface + + def encode(self, x): + # get batch size from data and replicate sos_token + c = torch.ones(x.shape[0], 1)*self.sos_token + c = c.long().to(x.device) + if self.quantize_interface: + return c, None, [None, None, c] + return c diff --git a/models/taming/modules/__pycache__/util.cpython-39.pyc b/models/taming/modules/__pycache__/util.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67b115407c5339b6e8b95320fcd8e11f98adbc1f Binary files /dev/null and b/models/taming/modules/__pycache__/util.cpython-39.pyc differ diff --git a/models/taming/modules/diffusionmodules/__pycache__/model.cpython-37.pyc b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc9dbc56e36a9cb231771efa87f7fe1f0c5d06ed Binary files /dev/null and b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-37.pyc differ diff --git a/models/taming/modules/diffusionmodules/__pycache__/model.cpython-38.pyc b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ae3c61bf1e5d1b397a2dd53efa4538d0e6a2cb6 Binary files /dev/null and b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-38.pyc differ diff --git a/models/taming/modules/diffusionmodules/__pycache__/model.cpython-39.pyc b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbdf642aa91d64bb140afc1a3e143a9b57ad9d9e Binary files /dev/null and b/models/taming/modules/diffusionmodules/__pycache__/model.cpython-39.pyc differ diff --git a/models/taming/modules/diffusionmodules/model.py b/models/taming/modules/diffusionmodules/model.py new file mode 100644 index 0000000000000000000000000000000000000000..d3a5db6aa2ef915e270f1ae135e4a9918fdd884c --- /dev/null +++ b/models/taming/modules/diffusionmodules/model.py @@ -0,0 +1,776 @@ +# pytorch_diffusion + derived encoder decoder +import math +import torch +import torch.nn as nn +import numpy as np + + +def get_timestep_embedding(timesteps, embedding_dim): + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: + From Fairseq. + Build sinusoidal embeddings. + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + assert len(timesteps.shape) == 1 + + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) + emb = emb.to(device=timesteps.device) + emb = timesteps.float()[:, None] * emb[None, :] + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) + if embedding_dim % 2 == 1: # zero pad + emb = torch.nn.functional.pad(emb, (0,1,0,0)) + return emb + + +def nonlinearity(x): + # swish + return x*torch.sigmoid(x) + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class Upsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + if self.with_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=2, + padding=0) + + def forward(self, x): + if self.with_conv: + pad = (0,1,0,1) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + else: + x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2) + return x + + +class ResnetBlock(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout, temb_channels=512): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = Normalize(in_channels) + self.conv1 = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if temb_channels > 0: + self.temb_proj = torch.nn.Linear(temb_channels, + out_channels) + self.norm2 = Normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d(out_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + else: + self.nin_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x, temb): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + + if temb is not None: + h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None] + + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + + return x+h + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = q.reshape(b,c,h*w) + q = q.permute(0,2,1) # b,hw,c + k = k.reshape(b,c,h*w) # b,c,hw + w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b,c,h*w) + w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b,c,h,w) + + h_ = self.proj_out(h_) + + return x+h_ + + +class Model(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, use_timestep=True): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, t=None): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Encoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, double_z=True, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + 2*z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x): + #assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution) + + # timestep embedding + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, give_pre_end=False, **ignorekwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.give_pre_end = give_pre_end + + # compute in_ch_mult, block_in and curr_res at lowest res + in_ch_mult = (1,)+tuple(ch_mult) + block_in = ch*ch_mult[self.num_resolutions-1] + curr_res = resolution // 2**(self.num_resolutions-1) + self.z_shape = (1,z_channels,curr_res,curr_res) + print("Working with z of shape {} = {} dimensions.".format( + self.z_shape, np.prod(self.z_shape))) + + # z to block_in + self.conv_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=3, + stride=1, + padding=1) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, z): + #assert z.shape[1:] == self.z_shape[1:] + self.last_z_shape = z.shape + + # timestep embedding + temb = None + + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block](h, temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + if self.give_pre_end: + return h + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class VUNet(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, + in_channels, c_channels, + resolution, z_channels, use_timestep=False, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(c_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + self.z_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=1, + stride=1, + padding=0) + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=2*block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, z): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + z = self.z_in(z) + h = torch.cat((h,z),dim=1) + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class SimpleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, *args, **kwargs): + super().__init__() + self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1), + ResnetBlock(in_channels=in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=2 * in_channels, + out_channels=4 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=4 * in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + nn.Conv2d(2*in_channels, in_channels, 1), + Upsample(in_channels, with_conv=True)]) + # end + self.norm_out = Normalize(in_channels) + self.conv_out = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + for i, layer in enumerate(self.model): + if i in [1,2,3]: + x = layer(x, None) + else: + x = layer(x) + + h = self.norm_out(x) + h = nonlinearity(h) + x = self.conv_out(h) + return x + + +class UpsampleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution, + ch_mult=(2,2), dropout=0.0): + super().__init__() + # upsampling + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + block_in = in_channels + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.res_blocks = nn.ModuleList() + self.upsample_blocks = nn.ModuleList() + for i_level in range(self.num_resolutions): + res_block = [] + block_out = ch * ch_mult[i_level] + for i_block in range(self.num_res_blocks + 1): + res_block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + self.res_blocks.append(nn.ModuleList(res_block)) + if i_level != self.num_resolutions - 1: + self.upsample_blocks.append(Upsample(block_in, True)) + curr_res = curr_res * 2 + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # upsampling + h = x + for k, i_level in enumerate(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.res_blocks[i_level][i_block](h, None) + if i_level != self.num_resolutions - 1: + h = self.upsample_blocks[k](h) + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + diff --git a/models/taming/modules/discriminator/__pycache__/model.cpython-39.pyc b/models/taming/modules/discriminator/__pycache__/model.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7d0b8d7574e5c3c4e081ae4d6e895ed064732b7 Binary files /dev/null and b/models/taming/modules/discriminator/__pycache__/model.cpython-39.pyc differ diff --git a/models/taming/modules/discriminator/model.py b/models/taming/modules/discriminator/model.py new file mode 100644 index 0000000000000000000000000000000000000000..dfe70a392608ede979303a2a8df21ffea17d89d1 --- /dev/null +++ b/models/taming/modules/discriminator/model.py @@ -0,0 +1,67 @@ +import functools +import torch.nn as nn + + +from models.taming.modules.util import ActNorm + + +def weights_init(m): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + nn.init.normal_(m.weight.data, 0.0, 0.02) + elif classname.find('BatchNorm') != -1: + nn.init.normal_(m.weight.data, 1.0, 0.02) + nn.init.constant_(m.bias.data, 0) + + +class NLayerDiscriminator(nn.Module): + """Defines a PatchGAN discriminator as in Pix2Pix + --> see https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/models/networks.py + """ + def __init__(self, input_nc=3, ndf=64, n_layers=3, use_actnorm=False): + """Construct a PatchGAN discriminator + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the last conv layer + n_layers (int) -- the number of conv layers in the discriminator + norm_layer -- normalization layer + """ + super(NLayerDiscriminator, self).__init__() + if not use_actnorm: + norm_layer = nn.BatchNorm2d + else: + norm_layer = ActNorm + if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters + use_bias = norm_layer.func != nn.BatchNorm2d + else: + use_bias = norm_layer != nn.BatchNorm2d + + kw = 4 + padw = 1 + sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)] + nf_mult = 1 + nf_mult_prev = 1 + for n in range(1, n_layers): # gradually increase the number of filters + nf_mult_prev = nf_mult + nf_mult = min(2 ** n, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + nf_mult_prev = nf_mult + nf_mult = min(2 ** n_layers, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + sequence += [ + nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map + self.main = nn.Sequential(*sequence) + + def forward(self, input): + """Standard forward.""" + return self.main(input) diff --git a/models/taming/modules/losses/__init__.py b/models/taming/modules/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ca665caea65aff21a0c3178eaf883b0a7ba171b4 --- /dev/null +++ b/models/taming/modules/losses/__init__.py @@ -0,0 +1,2 @@ +from models.taming.modules.losses.vqperceptual import DummyLoss + diff --git a/models/taming/modules/losses/__pycache__/__init__.cpython-39.pyc b/models/taming/modules/losses/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..38aa80bf4d028b6198ebfa956f842d0c5f717b65 Binary files /dev/null and b/models/taming/modules/losses/__pycache__/__init__.cpython-39.pyc differ diff --git a/models/taming/modules/losses/__pycache__/lpips.cpython-39.pyc b/models/taming/modules/losses/__pycache__/lpips.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daf63d7071f42501be66d23e71ecc35b3a0b1f58 Binary files /dev/null and b/models/taming/modules/losses/__pycache__/lpips.cpython-39.pyc differ diff --git a/models/taming/modules/losses/__pycache__/vqperceptual.cpython-39.pyc b/models/taming/modules/losses/__pycache__/vqperceptual.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b98ff0b4cbef3b19206c3d4d6eb1a46acce057b Binary files /dev/null and b/models/taming/modules/losses/__pycache__/vqperceptual.cpython-39.pyc differ diff --git a/models/taming/modules/losses/lpips.py b/models/taming/modules/losses/lpips.py new file mode 100644 index 0000000000000000000000000000000000000000..afc803b3a45a010b73e126e134b6d9562b3040fc --- /dev/null +++ b/models/taming/modules/losses/lpips.py @@ -0,0 +1,123 @@ +"""Stripped version of https://github.com/richzhang/PerceptualSimilarity/tree/master/models""" + +import torch +import torch.nn as nn +from torchvision import models +from collections import namedtuple + +from models.taming.util import get_ckpt_path + + +class LPIPS(nn.Module): + # Learned perceptual metric + def __init__(self, use_dropout=True): + super().__init__() + self.scaling_layer = ScalingLayer() + self.chns = [64, 128, 256, 512, 512] # vg16 features + self.net = vgg16(pretrained=True, requires_grad=False) + self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout) + self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout) + self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout) + self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout) + self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout) + self.load_from_pretrained() + for param in self.parameters(): + param.requires_grad = False + + def load_from_pretrained(self, name="vgg_lpips"): + ckpt = get_ckpt_path(name, "taming/modules/autoencoder/lpips") + self.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + print("loaded pretrained LPIPS loss from {}".format(ckpt)) + + @classmethod + def from_pretrained(cls, name="vgg_lpips"): + if name != "vgg_lpips": + raise NotImplementedError + model = cls() + ckpt = get_ckpt_path(name) + model.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + return model + + def forward(self, input, target): + in0_input, in1_input = (self.scaling_layer(input), self.scaling_layer(target)) + outs0, outs1 = self.net(in0_input), self.net(in1_input) + feats0, feats1, diffs = {}, {}, {} + lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4] + for kk in range(len(self.chns)): + feats0[kk], feats1[kk] = normalize_tensor(outs0[kk]), normalize_tensor(outs1[kk]) + diffs[kk] = (feats0[kk] - feats1[kk]) ** 2 + + res = [spatial_average(lins[kk].model(diffs[kk]), keepdim=True) for kk in range(len(self.chns))] + val = res[0] + for l in range(1, len(self.chns)): + val += res[l] + return val + + +class ScalingLayer(nn.Module): + def __init__(self): + super(ScalingLayer, self).__init__() + self.register_buffer('shift', torch.Tensor([-.030, -.088, -.188])[None, :, None, None]) + self.register_buffer('scale', torch.Tensor([.458, .448, .450])[None, :, None, None]) + + def forward(self, inp): + return (inp - self.shift) / self.scale + + +class NetLinLayer(nn.Module): + """ A single linear layer which does a 1x1 conv """ + def __init__(self, chn_in, chn_out=1, use_dropout=False): + super(NetLinLayer, self).__init__() + layers = [nn.Dropout(), ] if (use_dropout) else [] + layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ] + self.model = nn.Sequential(*layers) + + +class vgg16(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(vgg16, self).__init__() + vgg_pretrained_features = models.vgg16(pretrained=pretrained).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.N_slices = 5 + for x in range(4): + self.slice1.add_module(str(x), vgg_pretrained_features[x]) + for x in range(4, 9): + self.slice2.add_module(str(x), vgg_pretrained_features[x]) + for x in range(9, 16): + self.slice3.add_module(str(x), vgg_pretrained_features[x]) + for x in range(16, 23): + self.slice4.add_module(str(x), vgg_pretrained_features[x]) + for x in range(23, 30): + self.slice5.add_module(str(x), vgg_pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1_2 = h + h = self.slice2(h) + h_relu2_2 = h + h = self.slice3(h) + h_relu3_3 = h + h = self.slice4(h) + h_relu4_3 = h + h = self.slice5(h) + h_relu5_3 = h + vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3']) + out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3) + return out + + +def normalize_tensor(x,eps=1e-10): + norm_factor = torch.sqrt(torch.sum(x**2,dim=1,keepdim=True)) + return x/(norm_factor+eps) + + +def spatial_average(x, keepdim=True): + return x.mean([2,3],keepdim=keepdim) + diff --git a/models/taming/modules/losses/segmentation.py b/models/taming/modules/losses/segmentation.py new file mode 100644 index 0000000000000000000000000000000000000000..4ba77deb5159a6307ed2acba9945e4764a4ff0a5 --- /dev/null +++ b/models/taming/modules/losses/segmentation.py @@ -0,0 +1,22 @@ +import torch.nn as nn +import torch.nn.functional as F + + +class BCELoss(nn.Module): + def forward(self, prediction, target): + loss = F.binary_cross_entropy_with_logits(prediction,target) + return loss, {} + + +class BCELossWithQuant(nn.Module): + def __init__(self, codebook_weight=1.): + super().__init__() + self.codebook_weight = codebook_weight + + def forward(self, qloss, target, prediction, split): + bce_loss = F.binary_cross_entropy_with_logits(prediction,target) + loss = bce_loss + self.codebook_weight*qloss + return loss, {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/bce_loss".format(split): bce_loss.detach().mean(), + "{}/quant_loss".format(split): qloss.detach().mean() + } diff --git a/models/taming/modules/losses/vqperceptual.py b/models/taming/modules/losses/vqperceptual.py new file mode 100644 index 0000000000000000000000000000000000000000..af8eb0982d60b95751dc32c77d1d914d871a21db --- /dev/null +++ b/models/taming/modules/losses/vqperceptual.py @@ -0,0 +1,136 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from models.taming.modules.losses.lpips import LPIPS +from models.taming.modules.discriminator.model import NLayerDiscriminator, weights_init + + +class DummyLoss(nn.Module): + def __init__(self): + super().__init__() + + +def adopt_weight(weight, global_step, threshold=0, value=0.): + if global_step < threshold: + weight = value + return weight + + +def hinge_d_loss(logits_real, logits_fake): + loss_real = torch.mean(F.relu(1. - logits_real)) + loss_fake = torch.mean(F.relu(1. + logits_fake)) + d_loss = 0.5 * (loss_real + loss_fake) + return d_loss + + +def vanilla_d_loss(logits_real, logits_fake): + d_loss = 0.5 * ( + torch.mean(torch.nn.functional.softplus(-logits_real)) + + torch.mean(torch.nn.functional.softplus(logits_fake))) + return d_loss + + +class VQLPIPSWithDiscriminator(nn.Module): + def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0, + disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0, + perceptual_weight=1.0, use_actnorm=False, disc_conditional=False, + disc_ndf=64, disc_loss="hinge"): + super().__init__() + assert disc_loss in ["hinge", "vanilla"] + self.codebook_weight = codebook_weight + self.pixel_weight = pixelloss_weight + self.perceptual_loss = LPIPS().eval() + self.perceptual_weight = perceptual_weight + + self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels, + n_layers=disc_num_layers, + use_actnorm=use_actnorm, + ndf=disc_ndf + ).apply(weights_init) + self.discriminator_iter_start = disc_start + if disc_loss == "hinge": + self.disc_loss = hinge_d_loss + elif disc_loss == "vanilla": + self.disc_loss = vanilla_d_loss + else: + raise ValueError(f"Unknown GAN loss '{disc_loss}'.") + print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.") + self.disc_factor = disc_factor + self.discriminator_weight = disc_weight + self.disc_conditional = disc_conditional + + def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None): + if last_layer is not None: + nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] + else: + nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0] + + d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4) + d_weight = torch.clamp(d_weight, 0.0, 1e4).detach() + d_weight = d_weight * self.discriminator_weight + return d_weight + + def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx, + global_step, last_layer=None, cond=None, split="train"): + rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous()) + if self.perceptual_weight > 0: + p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous()) + rec_loss = rec_loss + self.perceptual_weight * p_loss + else: + p_loss = torch.tensor([0.0]) + + nll_loss = rec_loss + #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0] + nll_loss = torch.mean(nll_loss) + + # now the GAN part + if optimizer_idx == 0: + # generator update + if cond is None: + assert not self.disc_conditional + logits_fake = self.discriminator(reconstructions.contiguous()) + else: + assert self.disc_conditional + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1)) + g_loss = -torch.mean(logits_fake) + + try: + d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer) + except RuntimeError: + assert not self.training + d_weight = torch.tensor(0.0) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean() + + log = {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/quant_loss".format(split): codebook_loss.detach().mean(), + "{}/nll_loss".format(split): nll_loss.detach().mean(), + "{}/rec_loss".format(split): rec_loss.detach().mean(), + "{}/p_loss".format(split): p_loss.detach().mean(), + "{}/d_weight".format(split): d_weight.detach(), + "{}/disc_factor".format(split): torch.tensor(disc_factor), + "{}/g_loss".format(split): g_loss.detach().mean(), + } + return loss, log + + if optimizer_idx == 1: + # second pass for discriminator update + if cond is None: + logits_real = self.discriminator(inputs.contiguous().detach()) + logits_fake = self.discriminator(reconstructions.contiguous().detach()) + else: + logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1)) + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1)) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + d_loss = disc_factor * self.disc_loss(logits_real, logits_fake) + + log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(), + "{}/logits_real".format(split): logits_real.detach().mean(), + "{}/logits_fake".format(split): logits_fake.detach().mean() + } + return d_loss, log diff --git a/models/taming/modules/misc/coord.py b/models/taming/modules/misc/coord.py new file mode 100644 index 0000000000000000000000000000000000000000..ee69b0c897b6b382ae673622e420f55e494f5b09 --- /dev/null +++ b/models/taming/modules/misc/coord.py @@ -0,0 +1,31 @@ +import torch + +class CoordStage(object): + def __init__(self, n_embed, down_factor): + self.n_embed = n_embed + self.down_factor = down_factor + + def eval(self): + return self + + def encode(self, c): + """fake vqmodel interface""" + assert 0.0 <= c.min() and c.max() <= 1.0 + b,ch,h,w = c.shape + assert ch == 1 + + c = torch.nn.functional.interpolate(c, scale_factor=1/self.down_factor, + mode="area") + c = c.clamp(0.0, 1.0) + c = self.n_embed*c + c_quant = c.round() + c_ind = c_quant.to(dtype=torch.long) + + info = None, None, c_ind + return c_quant, None, info + + def decode(self, c): + c = c/self.n_embed + c = torch.nn.functional.interpolate(c, scale_factor=self.down_factor, + mode="nearest") + return c diff --git a/models/taming/modules/util.py b/models/taming/modules/util.py new file mode 100644 index 0000000000000000000000000000000000000000..9ee16385d8b1342a2d60a5f1aa5cadcfbe934bd8 --- /dev/null +++ b/models/taming/modules/util.py @@ -0,0 +1,130 @@ +import torch +import torch.nn as nn + + +def count_params(model): + total_params = sum(p.numel() for p in model.parameters()) + return total_params + + +class ActNorm(nn.Module): + def __init__(self, num_features, logdet=False, affine=True, + allow_reverse_init=False): + assert affine + super().__init__() + self.logdet = logdet + self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1)) + self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1)) + self.allow_reverse_init = allow_reverse_init + + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def initialize(self, input): + with torch.no_grad(): + flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1) + mean = ( + flatten.mean(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + std = ( + flatten.std(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + + self.loc.data.copy_(-mean) + self.scale.data.copy_(1 / (std + 1e-6)) + + def forward(self, input, reverse=False): + if reverse: + return self.reverse(input) + if len(input.shape) == 2: + input = input[:,:,None,None] + squeeze = True + else: + squeeze = False + + _, _, height, width = input.shape + + if self.training and self.initialized.item() == 0: + self.initialize(input) + self.initialized.fill_(1) + + h = self.scale * (input + self.loc) + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + + if self.logdet: + log_abs = torch.log(torch.abs(self.scale)) + logdet = height*width*torch.sum(log_abs) + logdet = logdet * torch.ones(input.shape[0]).to(input) + return h, logdet + + return h + + def reverse(self, output): + if self.training and self.initialized.item() == 0: + if not self.allow_reverse_init: + raise RuntimeError( + "Initializing ActNorm in reverse direction is " + "disabled by default. Use allow_reverse_init=True to enable." + ) + else: + self.initialize(output) + self.initialized.fill_(1) + + if len(output.shape) == 2: + output = output[:,:,None,None] + squeeze = True + else: + squeeze = False + + h = output / self.scale - self.loc + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + return h + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + + +class Labelator(AbstractEncoder): + """Net2Net Interface for Class-Conditional Model""" + def __init__(self, n_classes, quantize_interface=True): + super().__init__() + self.n_classes = n_classes + self.quantize_interface = quantize_interface + + def encode(self, c): + c = c[:,None] + if self.quantize_interface: + return c, None, [None, None, c.long()] + return c + + +class SOSProvider(AbstractEncoder): + # for unconditional training + def __init__(self, sos_token, quantize_interface=True): + super().__init__() + self.sos_token = sos_token + self.quantize_interface = quantize_interface + + def encode(self, x): + # get batch size from data and replicate sos_token + c = torch.ones(x.shape[0], 1)*self.sos_token + c = c.long().to(x.device) + if self.quantize_interface: + return c, None, [None, None, c] + return c diff --git a/models/taming/modules/vqvae/__pycache__/quantize.cpython-37.pyc b/models/taming/modules/vqvae/__pycache__/quantize.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75d3fed35126f6b7a11a0c8d0cd8ee7f7d0ba4c1 Binary files /dev/null and b/models/taming/modules/vqvae/__pycache__/quantize.cpython-37.pyc differ diff --git a/models/taming/modules/vqvae/__pycache__/quantize.cpython-38.pyc b/models/taming/modules/vqvae/__pycache__/quantize.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17394b1845ddda535b9f634a76b1008a5b3dc8f8 Binary files /dev/null and b/models/taming/modules/vqvae/__pycache__/quantize.cpython-38.pyc differ diff --git a/models/taming/modules/vqvae/__pycache__/quantize.cpython-39.pyc b/models/taming/modules/vqvae/__pycache__/quantize.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40596a4ab28f8fc094e12aa696ce4fe872cf1dbe Binary files /dev/null and b/models/taming/modules/vqvae/__pycache__/quantize.cpython-39.pyc differ diff --git a/models/taming/modules/vqvae/quantize.py b/models/taming/modules/vqvae/quantize.py new file mode 100644 index 0000000000000000000000000000000000000000..d75544e41fa01bce49dd822b1037963d62f79b51 --- /dev/null +++ b/models/taming/modules/vqvae/quantize.py @@ -0,0 +1,445 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from torch import einsum +from einops import rearrange + + +class VectorQuantizer(nn.Module): + """ + see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py + ____________________________________________ + Discretization bottleneck part of the VQ-VAE. + Inputs: + - n_e : number of embeddings + - e_dim : dimension of embedding + - beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2 + _____________________________________________ + """ + + # NOTE: this class contains a bug regarding beta; see VectorQuantizer2 for + # a fix and use legacy=False to apply that fix. VectorQuantizer2 can be + # used wherever VectorQuantizer has been used before and is additionally + # more efficient. + def __init__(self, n_e, e_dim, beta): + super(VectorQuantizer, self).__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + def forward(self, z): + """ + Inputs the output of the encoder network z and maps it to a discrete + one-hot vector that is the index of the closest embedding vector e_j + z (continuous) -> z_q (discrete) + z.shape = (batch, channel, height, width) + quantization pipeline: + 1. get encoder input (B,C,H,W) + 2. flatten input to (B*H*W,C) + """ + # reshape z -> (batch, height, width, channel) and flatten + z = z.permute(0, 2, 3, 1).contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.matmul(z_flattened, self.embedding.weight.t()) + + ## could possible replace this here + # #\start... + # find closest encodings + min_encoding_indices = torch.argmin(d, dim=1).unsqueeze(1) + + min_encodings = torch.zeros( + min_encoding_indices.shape[0], self.n_e).to(z) + min_encodings.scatter_(1, min_encoding_indices, 1) + + # dtype min encodings: torch.float32 + # min_encodings shape: torch.Size([2048, 512]) + # min_encoding_indices.shape: torch.Size([2048, 1]) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape) + #.........\end + + # with: + # .........\start + #min_encoding_indices = torch.argmin(d, dim=1) + #z_q = self.embedding(min_encoding_indices) + # ......\end......... (TODO) + + # compute loss for embedding + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # perplexity + e_mean = torch.mean(min_encodings, dim=0) + perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10))) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + # TODO: check for more easy handling with nn.Embedding + min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices) + min_encodings.scatter_(1, indices[:,None], 1) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings.float(), self.embedding.weight) + + if shape is not None: + z_q = z_q.view(shape) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + + +class GumbelQuantize(nn.Module): + """ + credit to @karpathy: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py (thanks!) + Gumbel Softmax trick quantizer + Categorical Reparameterization with Gumbel-Softmax, Jang et al. 2016 + https://arxiv.org/abs/1611.01144 + """ + def __init__(self, num_hiddens, embedding_dim, n_embed, straight_through=True, + kl_weight=5e-4, temp_init=1.0, use_vqinterface=True, + remap=None, unknown_index="random"): + super().__init__() + + self.embedding_dim = embedding_dim + self.n_embed = n_embed + + self.straight_through = straight_through + self.temperature = temp_init + self.kl_weight = kl_weight + + self.proj = nn.Conv2d(num_hiddens, n_embed, 1) + self.embed = nn.Embedding(n_embed, embedding_dim) + + self.use_vqinterface = use_vqinterface + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, return_logits=False): + # force hard = True when we are in eval mode, as we must quantize. actually, always true seems to work + hard = self.straight_through if self.training else True + temp = self.temperature if temp is None else temp + + logits = self.proj(z) + if self.remap is not None: + # continue only with used logits + full_zeros = torch.zeros_like(logits) + logits = logits[:,self.used,...] + + soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=hard) + if self.remap is not None: + # go back to all entries but unused set to zero + full_zeros[:,self.used,...] = soft_one_hot + soft_one_hot = full_zeros + z_q = einsum('b n h w, n d -> b d h w', soft_one_hot, self.embed.weight) + + # + kl divergence to the prior loss + qy = F.softmax(logits, dim=1) + diff = self.kl_weight * torch.sum(qy * torch.log(qy * self.n_embed + 1e-10), dim=1).mean() + + ind = soft_one_hot.argmax(dim=1) + if self.remap is not None: + ind = self.remap_to_used(ind) + if self.use_vqinterface: + if return_logits: + return z_q, diff, (None, None, ind), logits + return z_q, diff, (None, None, ind) + return z_q, diff, ind + + def get_codebook_entry(self, indices, shape): + b, h, w, c = shape + assert b*h*w == indices.shape[0] + indices = rearrange(indices, '(b h w) -> b h w', b=b, h=h, w=w) + if self.remap is not None: + indices = self.unmap_to_all(indices) + one_hot = F.one_hot(indices, num_classes=self.n_embed).permute(0, 3, 1, 2).float() + z_q = einsum('b n h w, n d -> b d h w', one_hot, self.embed.weight) + return z_q + + +class VectorQuantizer2(nn.Module): + """ + Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly + avoids costly matrix multiplications and allows for post-hoc remapping of indices. + """ + # NOTE: due to a bug the beta term was applied to the wrong term. for + # backwards compatibility we use the buggy version by default, but you can + # specify legacy=False to fix it. + def __init__(self, n_e, e_dim, beta, remap=None, unknown_index="random", + sane_index_shape=False, legacy=True): + super().__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + self.legacy = legacy + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_e} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_e + + self.sane_index_shape = sane_index_shape + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, rescale_logits=False, return_logits=False): + assert temp is None or temp==1.0, "Only for interface compatible with Gumbel" + assert rescale_logits==False, "Only for interface compatible with Gumbel" + assert return_logits==False, "Only for interface compatible with Gumbel" + # reshape z -> (batch, height, width, channel) and flatten + z = rearrange(z, 'b c h w -> b h w c').contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n')) + + min_encoding_indices = torch.argmin(d, dim=1) + z_q = self.embedding(min_encoding_indices).view(z.shape) + perplexity = None + min_encodings = None + + # compute loss for embedding + if not self.legacy: + loss = self.beta * torch.mean((z_q.detach()-z)**2) + \ + torch.mean((z_q - z.detach()) ** 2) + else: + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous() + + if self.remap is not None: + min_encoding_indices = min_encoding_indices.reshape(z.shape[0],-1) # add batch axis + min_encoding_indices = self.remap_to_used(min_encoding_indices) + min_encoding_indices = min_encoding_indices.reshape(-1,1) # flatten + + if self.sane_index_shape: + min_encoding_indices = min_encoding_indices.reshape( + z_q.shape[0], z_q.shape[2], z_q.shape[3]) + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + if self.remap is not None: + indices = indices.reshape(shape[0],-1) # add batch axis + indices = self.unmap_to_all(indices) + indices = indices.reshape(-1) # flatten again + + # get quantized latent vectors + z_q = self.embedding(indices) + + if shape is not None: + z_q = z_q.view(shape) + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + +class EmbeddingEMA(nn.Module): + def __init__(self, num_tokens, codebook_dim, decay=0.99, eps=1e-5): + super().__init__() + self.decay = decay + self.eps = eps + weight = torch.randn(num_tokens, codebook_dim) + self.weight = nn.Parameter(weight, requires_grad = False) + self.cluster_size = nn.Parameter(torch.zeros(num_tokens), requires_grad = False) + self.embed_avg = nn.Parameter(weight.clone(), requires_grad = False) + self.update = True + + def forward(self, embed_id): + return F.embedding(embed_id, self.weight) + + def cluster_size_ema_update(self, new_cluster_size): + self.cluster_size.data.mul_(self.decay).add_(new_cluster_size, alpha=1 - self.decay) + + def embed_avg_ema_update(self, new_embed_avg): + self.embed_avg.data.mul_(self.decay).add_(new_embed_avg, alpha=1 - self.decay) + + def weight_update(self, num_tokens): + n = self.cluster_size.sum() + smoothed_cluster_size = ( + (self.cluster_size + self.eps) / (n + num_tokens * self.eps) * n + ) + #normalize embedding average with smoothed cluster size + embed_normalized = self.embed_avg / smoothed_cluster_size.unsqueeze(1) + self.weight.data.copy_(embed_normalized) + + +class EMAVectorQuantizer(nn.Module): + def __init__(self, n_embed, embedding_dim, beta, decay=0.99, eps=1e-5, + remap=None, unknown_index="random"): + super().__init__() + self.codebook_dim = codebook_dim + self.num_tokens = num_tokens + self.beta = beta + self.embedding = EmbeddingEMA(self.num_tokens, self.codebook_dim, decay, eps) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z): + # reshape z -> (batch, height, width, channel) and flatten + #z, 'b c h w -> b h w c' + z = rearrange(z, 'b c h w -> b h w c') + z_flattened = z.reshape(-1, self.codebook_dim) + + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + d = z_flattened.pow(2).sum(dim=1, keepdim=True) + \ + self.embedding.weight.pow(2).sum(dim=1) - 2 * \ + torch.einsum('bd,nd->bn', z_flattened, self.embedding.weight) # 'n d -> d n' + + + encoding_indices = torch.argmin(d, dim=1) + + z_q = self.embedding(encoding_indices).view(z.shape) + encodings = F.one_hot(encoding_indices, self.num_tokens).type(z.dtype) + avg_probs = torch.mean(encodings, dim=0) + perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10))) + + if self.training and self.embedding.update: + #EMA cluster size + encodings_sum = encodings.sum(0) + self.embedding.cluster_size_ema_update(encodings_sum) + #EMA embedding average + embed_sum = encodings.transpose(0,1) @ z_flattened + self.embedding.embed_avg_ema_update(embed_sum) + #normalize embed_avg and update weight + self.embedding.weight_update(self.num_tokens) + + # compute loss for embedding + loss = self.beta * F.mse_loss(z_q.detach(), z) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + #z_q, 'b h w c -> b c h w' + z_q = rearrange(z_q, 'b h w c -> b c h w') + return z_q, loss, (perplexity, encodings, encoding_indices) diff --git a/models/taming/util.py b/models/taming/util.py new file mode 100644 index 0000000000000000000000000000000000000000..7443b29e3d223a3ad396808f9717fb9a11c7507c --- /dev/null +++ b/models/taming/util.py @@ -0,0 +1,172 @@ +import os, hashlib +import requests +from tqdm import tqdm +import importlib + +URL_MAP = { + "vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1" +} + +CKPT_MAP = { + "vgg_lpips": "vgg.pth" +} + +MD5_MAP = { + "vgg_lpips": "d507d7349b931f0638a25a48a722f98a" +} + + +def get_obj_from_str(string, reload=False): + module, cls = string.rsplit(".", 1) + if reload: + module_imp = importlib.import_module(module) + importlib.reload(module_imp) + return getattr(importlib.import_module(module, package=None), cls) + + +def instantiate_from_config(config): + if not "target" in config: + raise KeyError("Expected key `target` to instantiate.") + return get_obj_from_str(config["target"])(**config.get("params", dict())) + + +def download(url, local_path, chunk_size=1024): + os.makedirs(os.path.split(local_path)[0], exist_ok=True) + with requests.get(url, stream=True) as r: + total_size = int(r.headers.get("content-length", 0)) + with tqdm(total=total_size, unit="B", unit_scale=True) as pbar: + with open(local_path, "wb") as f: + for data in r.iter_content(chunk_size=chunk_size): + if data: + f.write(data) + pbar.update(chunk_size) + + +def md5_hash(path): + with open(path, "rb") as f: + content = f.read() + return hashlib.md5(content).hexdigest() + + +def get_ckpt_path(name, root, check=False): + assert name in URL_MAP + path = os.path.join(root, CKPT_MAP[name]) + if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]): + print("Downloading {} model from {} to {}".format(name, URL_MAP[name], path)) + download(URL_MAP[name], path) + md5 = md5_hash(path) + assert md5 == MD5_MAP[name], md5 + return path + + +class KeyNotFoundError(Exception): + def __init__(self, cause, keys=None, visited=None): + self.cause = cause + self.keys = keys + self.visited = visited + messages = list() + if keys is not None: + messages.append("Key not found: {}".format(keys)) + if visited is not None: + messages.append("Visited: {}".format(visited)) + messages.append("Cause:\n{}".format(cause)) + message = "\n".join(messages) + super().__init__(message) + + +def retrieve( + list_or_dict, key, splitval="/", default=None, expand=True, pass_success=False +): + """Given a nested list or dict return the desired value at key expanding + callable nodes if necessary and :attr:`expand` is ``True``. The expansion + is done in-place. + + Parameters + ---------- + list_or_dict : list or dict + Possibly nested list or dictionary. + key : str + key/to/value, path like string describing all keys necessary to + consider to get to the desired value. List indices can also be + passed here. + splitval : str + String that defines the delimiter between keys of the + different depth levels in `key`. + default : obj + Value returned if :attr:`key` is not found. + expand : bool + Whether to expand callable nodes on the path or not. + + Returns + ------- + The desired value or if :attr:`default` is not ``None`` and the + :attr:`key` is not found returns ``default``. + + Raises + ------ + Exception if ``key`` not in ``list_or_dict`` and :attr:`default` is + ``None``. + """ + + keys = key.split(splitval) + + success = True + try: + visited = [] + parent = None + last_key = None + for key in keys: + if callable(list_or_dict): + if not expand: + raise KeyNotFoundError( + ValueError( + "Trying to get past callable node with expand=False." + ), + keys=keys, + visited=visited, + ) + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + + last_key = key + parent = list_or_dict + + try: + if isinstance(list_or_dict, dict): + list_or_dict = list_or_dict[key] + else: + list_or_dict = list_or_dict[int(key)] + except (KeyError, IndexError, ValueError) as e: + raise KeyNotFoundError(e, keys=keys, visited=visited) + + visited += [key] + # final expansion of retrieved value + if expand and callable(list_or_dict): + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + except KeyNotFoundError as e: + if default is None: + raise e + else: + list_or_dict = default + success = False + + if not pass_success: + return list_or_dict + else: + return list_or_dict, success + + +if __name__ == "__main__": + config = {"keya": "a", + "keyb": "b", + "keyc": + {"cc1": 1, + "cc2": 2, + } + } + from omegaconf import OmegaConf + + config = OmegaConf.create(config) + print(config) + retrieve(config, "keya") diff --git a/models/unival/.ipynb_checkpoints/__init__-checkpoint.py b/models/unival/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..5ca74d790a95a2b14d3fbb0cf9f0a9959416d305 --- /dev/null +++ b/models/unival/.ipynb_checkpoints/__init__-checkpoint.py @@ -0,0 +1 @@ +from .ofa import OFAModel, ofa_base_architecture, ofa_large_architecture, ofa_huge_architecture \ No newline at end of file diff --git a/models/unival/.ipynb_checkpoints/ofa-checkpoint.py b/models/unival/.ipynb_checkpoints/ofa-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..f8efeb4c93ba45850c0575e7264b7396dbb1c25f --- /dev/null +++ b/models/unival/.ipynb_checkpoints/ofa-checkpoint.py @@ -0,0 +1,436 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +""" +OFA +""" +from typing import Optional + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import register_model, register_model_architecture +from fairseq.modules.transformer_sentence_encoder import init_bert_params + +from .unify_transformer import TransformerModel + +logger = logging.getLogger(__name__) + + +@register_model("ofa") +class OFAModel(TransformerModel): + __jit_unused_properties__ = ["supported_targets"] + + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + + # We follow BERT's random weight initialization + self.apply(init_bert_params) + + self.classification_heads = nn.ModuleDict() + if hasattr(self.encoder, "dictionary"): + self.eos: int = self.encoder.dictionary.eos() + + @staticmethod + def add_args(parser): + super(OFAModel, OFAModel).add_args(parser) + parser.add_argument( + "--pooler-dropout", + type=float, + metavar="D", + help="dropout probability in the masked_lm pooler layers", + ) + parser.add_argument( + "--pooler-classifier", + type=str, + choices=['mlp', 'linear'], + help="type of pooler classifier", + ) + parser.add_argument( + "--pooler-activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use for pooler layer", + ) + parser.add_argument( + "--spectral-norm-classification-head", + action="store_true", + help="Apply spectral normalization on the classification head", + ) + + @property + def supported_targets(self): + return {"self"} + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + code_masks: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None, + features_only: bool = False, + classification_head_name: Optional[str] = None, + token_embeddings: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + if classification_head_name is not None: + features_only = True + + encoder_out = self.encoder( + src_tokens, + src_lengths=src_lengths, + patch_images=patch_images, + patch_masks=patch_masks, + patch_images_2=patch_images_2, + token_embeddings=token_embeddings, + return_all_hiddens=return_all_hiddens, + sample_patch_num=sample_patch_num + ) + x, extra = self.decoder( + prev_output_tokens, + code_masks=code_masks, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + + pad = self.encoder.padding_idx + if classification_head_name is not None: + prev_lengths = prev_output_tokens.ne(pad).sum(1) + gather_index = prev_lengths[:, None, None].expand(x.size(0), 1, x.size(2)) - 1 + sentence_representation = x.gather(1, gather_index).squeeze() + if self.classification_heads[classification_head_name].use_two_images: + hidden_size = sentence_representation.size(1) + sentence_representation = sentence_representation.view(-1, hidden_size * 2) + for k, head in self.classification_heads.items(): + # for torch script only supports iteration + if k == classification_head_name: + x = head(sentence_representation) + break + + return x, extra + + def register_embedding_tokens(self, ans2label_dict, src_dict, bpe): + """Register embedding tokens""" + logger.info("Registering embedding tokens") + self.ans_tensor_list = [] + for i in range(len(ans2label_dict)): + ans = src_dict[-len(ans2label_dict)+i] + ans = ans[5:-1].replace('_', ' ') + ans_tensor = src_dict.encode_line( + line=bpe.encode(' {}'.format(ans.lower())), + add_if_not_exist=False, + append_eos=False + ).long() + self.ans_tensor_list.append(ans_tensor) + + def register_classification_head( + self, name, num_classes=None, inner_dim=None, use_two_images=False, **kwargs + ): + """Register a classification head.""" + logger.info("Registering classification head: {0}".format(name)) + if name in self.classification_heads: + prev_num_classes = self.classification_heads[name].out_proj.out_features + prev_inner_dim = self.classification_heads[name].dense.out_features + if num_classes != prev_num_classes or inner_dim != prev_inner_dim: + logger.warning( + 're-registering head "{}" with num_classes {} (prev: {}) ' + "and inner_dim {} (prev: {})".format( + name, num_classes, prev_num_classes, inner_dim, prev_inner_dim + ) + ) + self.classification_heads[name] = OFAClassificationHead( + input_dim=self.args.encoder_embed_dim, + inner_dim=inner_dim or self.args.encoder_embed_dim, + num_classes=num_classes, + activation_fn=self.args.pooler_activation_fn, + pooler_dropout=self.args.pooler_dropout, + pooler_classifier=self.args.pooler_classifier, + use_two_images=use_two_images, + do_spectral_norm=getattr( + self.args, "spectral_norm_classification_head", False + ), + ) + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + + prefix = name + "." if name != "" else "" + current_head_names = ( + [] + if not hasattr(self, "classification_heads") + else self.classification_heads.keys() + ) + + # Handle new classification heads present in the state dict. + keys_to_delete = [] + for k in state_dict.keys(): + if not k.startswith(prefix + "classification_heads."): + continue + + head_name = k[len(prefix + "classification_heads.") :].split(".")[0] + num_classes = state_dict[ + prefix + "classification_heads." + head_name + ".out_proj.weight" + ].size(0) + inner_dim = state_dict[ + prefix + "classification_heads." + head_name + ".dense.weight" + ].size(0) + + if getattr(self.args, "load_checkpoint_heads", False): + if head_name not in current_head_names: + self.register_classification_head(head_name, num_classes, inner_dim) + else: + if head_name not in current_head_names: + logger.warning( + "deleting classification head ({}) from checkpoint " + "not present in current model: {}".format(head_name, k) + ) + keys_to_delete.append(k) + elif ( + num_classes + != self.classification_heads[head_name].out_proj.out_features + or inner_dim + != self.classification_heads[head_name].dense.out_features + ): + logger.warning( + "deleting classification head ({}) from checkpoint " + "with different dimensions than current model: {}".format( + head_name, k + ) + ) + keys_to_delete.append(k) + for k in keys_to_delete: + del state_dict[k] + + def truncate_emb(key): + if key in state_dict: + state_dict[key] = state_dict[key][:-1, :] + + # When finetuning on translation task, remove last row of + # embedding matrix that corresponds to mask_idx token. + loaded_dict_size = state_dict["encoder.embed_tokens.weight"].size(0) + if ( + loaded_dict_size == len(self.encoder.dictionary) + 1 + and "<mask>" not in self.encoder.dictionary + ): + truncate_emb("encoder.embed_tokens.weight") + truncate_emb("decoder.embed_tokens.weight") + truncate_emb("encoder.output_projection.weight") + truncate_emb("decoder.output_projection.weight") + + if loaded_dict_size < len(self.encoder.dictionary): + num_langids_to_add = len(self.encoder.dictionary) - loaded_dict_size + embed_dim = state_dict["encoder.embed_tokens.weight"].size(1) + + new_lang_embed_to_add = torch.zeros(num_langids_to_add, embed_dim) + if getattr(self, "ans_tensor_list", None): + assert len(new_lang_embed_to_add) == len(self.ans_tensor_list) + for i, ans_tensor in enumerate(self.ans_tensor_list): + ans_embed = F.embedding(ans_tensor, state_dict["encoder.embed_tokens.weight"]) + ans_embed = ans_embed.sum(0) / ans_embed.size(0) + new_lang_embed_to_add[i] = ans_embed + else: + nn.init.normal_(new_lang_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_lang_embed_to_add = new_lang_embed_to_add.to( + dtype=state_dict["encoder.embed_tokens.weight"].dtype, + ) + + state_dict["encoder.embed_tokens.weight"] = torch.cat( + [state_dict["encoder.embed_tokens.weight"], new_lang_embed_to_add] + ) + state_dict["decoder.embed_tokens.weight"] = torch.cat( + [state_dict["decoder.embed_tokens.weight"], new_lang_embed_to_add] + ) + state_dict["decoder.output_projection.weight"] = torch.cat( + [state_dict["decoder.output_projection.weight"], new_lang_embed_to_add] + ) + + # Copy any newly-added classification heads into the state dict + # with their current weights. + if hasattr(self, "classification_heads"): + cur_state = self.classification_heads.state_dict() + for k, v in cur_state.items(): + if prefix + "classification_heads." + k not in state_dict: + logger.info("Overwriting " + prefix + "classification_heads." + k) + state_dict[prefix + "classification_heads." + k] = v + + +class OFAClassificationHead(nn.Module): + """Head for sentence-level classification tasks.""" + + def __init__( + self, + input_dim, + inner_dim, + num_classes, + activation_fn, + pooler_dropout, + pooler_classifier, + use_two_images=False, + do_spectral_norm=False, + ): + super().__init__() + self.pooler_classifier = pooler_classifier + self.use_two_images = use_two_images + input_dim = input_dim * 2 if use_two_images else input_dim + if pooler_classifier == "mlp": + self.dense = nn.Linear(input_dim, inner_dim) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(inner_dim, num_classes) + elif pooler_classifier == "linear": + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(input_dim, num_classes) + else: + raise NotImplementedError + + if do_spectral_norm: + self.out_proj = torch.nn.utils.spectral_norm(self.out_proj) + + def forward(self, features, **kwargs): + if self.pooler_classifier == 'mlp': + x = features + x = self.dropout(x) + x = self.dense(x) + x = self.activation_fn(x) + x = self.dropout(x) + x = self.out_proj(x) + elif self.pooler_classifier == 'linear': + x = features + x = self.dropout(x) + x = self.out_proj(x) + else: + raise NotImplementedError + return x + + +@register_model_architecture("ofa", "ofa_large") +def ofa_large_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 1024) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.relu_dropout = getattr(args, "relu_dropout", 0.0) + args.dropout = getattr(args, "dropout", 0.0) + args.max_target_positions = getattr(args, "max_target_positions", 1024) + args.max_source_positions = getattr(args, "max_source_positions", 1024) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", True + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", True) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", True) + args.layernorm_embedding = getattr(args, "layernorm_embedding", True) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.pooler_dropout = getattr(args, "pooler_dropout", 0.0) + args.pooler_classifier = getattr(args, "pooler_classifier", "mlp") + + args.resnet_drop_path_rate = getattr(args, "resnet_drop_path_rate", 0.0) + args.encoder_drop_path_rate = getattr(args, "encoder_drop_path_rate", 0.0) + args.decoder_drop_path_rate = getattr(args, "decoder_drop_path_rate", 0.0) + + args.resnet_type = getattr(args, "resnet_type", "resnet152") + args.token_bucket_size = getattr(args, "token_bucket_size", 256) + args.image_bucket_size = getattr(args, "image_bucket_size", 42) + + args.freeze_encoder_embedding = getattr(args, "freeze_encoder_embedding", False) + args.freeze_decoder_embedding = getattr(args, "freeze_decoder_embedding", False) + args.add_type_embedding = getattr(args, "add_type_embedding", True) + args.attn_scale_factor = getattr(args, "attn_scale_factor", 2) + + args.code_image_size = getattr(args, "code_image_size", 128) + args.patch_layernorm_embedding = getattr(args, "patch_layernorm_embedding", True) + args.code_layernorm_embedding = getattr(args, "code_layernorm_embedding", True) + args.entangle_position_embedding = getattr(args, "entangle_position_embedding", False) + args.disable_entangle = getattr(args, "disable_entangle", False) + args.sync_bn = getattr(args, "sync_bn", False) + + args.scale_attn = getattr(args, "scale_attn", False) + args.scale_fc = getattr(args, "scale_fc", False) + args.scale_heads = getattr(args, "scale_heads", False) + args.scale_resids = getattr(args, "scale_resids", False) + + args.orig_patch_image_size = getattr(args, "orig_patch_image_size", 256) + + +@register_model_architecture("ofa", "ofa_base") +def ofa_base_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 768) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 12) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 12) + args.resnet_type = getattr(args, "resnet_type", "resnet101") + ofa_large_architecture(args) + + +@register_model_architecture("ofa", "ofa_huge") +def ofa_huge_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1280) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 1280) + args.encoder_layers = getattr(args, "encoder_layers", 24) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.decoder_layers = getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.resnet_type = getattr(args, "resnet_type", "resnet152") + ofa_large_architecture(args) + + +@register_model_architecture("ofa", "ofa_medium") +def ofa_medium_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 512) + args.encoder_layers = getattr(args, "encoder_layers", 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.decoder_layers = getattr(args, "decoder_layers", 4) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.resnet_type = getattr(args, "resnet_type", "resnet101") + ofa_large_architecture(args) + + +@register_model_architecture("ofa", "ofa_tiny") +def ofa_tiny_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 256) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 256) + args.encoder_layers = getattr(args, "encoder_layers", 4) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 4) + args.decoder_layers = getattr(args, "decoder_layers", 4) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 4) + args.resnet_type = getattr(args, "resnet_type", "resnet50") + ofa_large_architecture(args) diff --git a/models/unival/.ipynb_checkpoints/unify_transformer-checkpoint.py b/models/unival/.ipynb_checkpoints/unify_transformer-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..dc8ab9eea0bc9809886758ad4cad694ae25b4287 --- /dev/null +++ b/models/unival/.ipynb_checkpoints/unify_transformer-checkpoint.py @@ -0,0 +1,1735 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +import random +from typing import Any, Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.distributed import fsdp_wrap +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + AdaptiveSoftmax, + BaseLayer, + FairseqDropout, + LayerDropModuleList, + LayerNorm, + SinusoidalPositionalEmbedding, + GradMultiply +) +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ +from torch import Tensor + +from .unify_transformer_layer import TransformerEncoderLayer, TransformerDecoderLayer +from .resnet import ResNet +from .frozen_bn import FrozenBatchNorm2d + + +DEFAULT_MAX_SOURCE_POSITIONS = 1024 +DEFAULT_MAX_TARGET_POSITIONS = 1024 + + +DEFAULT_MIN_PARAMS_TO_WRAP = int(1e8) + + +def BatchNorm2d(out_chan, momentum=0.1, eps=1e-3): + return nn.SyncBatchNorm.convert_sync_batchnorm( + nn.BatchNorm2d(out_chan, momentum=momentum, eps=eps) + ) + + +def make_token_bucket_position(bucket_size, max_position=DEFAULT_MAX_SOURCE_POSITIONS): + context_pos = torch.arange(max_position, dtype=torch.long)[:, None] + memory_pos = torch.arange(max_position, dtype=torch.long)[None, :] + relative_pos = context_pos - memory_pos + sign = torch.sign(relative_pos) + mid = bucket_size // 2 + abs_pos = torch.where((relative_pos<mid) & (relative_pos > -mid), mid-1, torch.abs(relative_pos)) + log_pos = torch.ceil(torch.log(abs_pos/mid)/math.log((max_position-1)/mid) * (mid-1)) + mid + log_pos = log_pos.int() + bucket_pos = torch.where(abs_pos.le(mid), relative_pos, log_pos*sign).long() + return bucket_pos + bucket_size - 1 + + +def make_image_bucket_position(bucket_size, num_relative_distance): + coords_h = torch.arange(bucket_size) + coords_w = torch.arange(bucket_size) + coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += bucket_size - 1 # shift to start from 0 + relative_coords[:, :, 1] += bucket_size - 1 + relative_coords[:, :, 0] *= 2 * bucket_size - 1 + relative_position_index = torch.zeros(size=(bucket_size * bucket_size + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = num_relative_distance - 3 + relative_position_index[0:, 0] = num_relative_distance - 2 + relative_position_index[0, 0] = num_relative_distance - 1 + return relative_position_index + + +class PromptEncoder(torch.nn.Module): + r""" + Prompt encoder to generate prompts, including prompt, prefix, instance and instruction + """ + + def __init__( + self, + type, + length, + projection, + embed_dim, + proj_dim, + layers, + vocab_size): + super().__init__() + self.prefix_projection = projection + + if type == "prefix": + layers = layers + prompt_vocab_size = length + + if self.prefix_projection: + self.embedding = torch.nn.Embedding(prompt_vocab_size, embed_dim) + self.trans = torch.nn.Sequential( + torch.nn.Linear(embed_dim, proj_dim), + torch.nn.ReLU(), + torch.nn.Linear(proj_dim, layers * 2 * embed_dim) + ) + else: + if type == "prefix": + self.embedding = torch.nn.Embedding( + prompt_vocab_size, layers * 2 * embed_dim) + + def forward(self, prefix: torch.Tensor): + if self.prefix_projection: + prefix_tokens = self.embedding(prefix) + past_key_values = self.trans(prefix_tokens) + else: + past_key_values = self.embedding(prefix) + return past_key_values + + +@register_model("unify_transformer") +class TransformerModel(FairseqEncoderDecoderModel): + """ + Transformer model from `"Attention Is All You Need" (Vaswani, et al, 2017) + <https://arxiv.org/abs/1706.03762>`_. + + Args: + encoder (TransformerEncoder): the encoder + decoder (TransformerDecoder): the decoder + + The Transformer model provides the following named architectures and + command-line arguments: + + .. argparse:: + :ref: fairseq.models.transformer_parser + :prog: + """ + + def __init__(self, args, encoder, decoder): + super().__init__(encoder, decoder) + self.args = args + self.supports_align_args = True + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--activation-fn', + choices=utils.get_available_activation_fns(), + help='activation function to use') + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--attention-dropout', type=float, metavar='D', + help='dropout probability for attention weights') + parser.add_argument('--activation-dropout', '--relu-dropout', type=float, metavar='D', + help='dropout probability after activation in FFN.') + parser.add_argument('--encoder-embed-path', type=str, metavar='STR', + help='path to pre-trained encoder embedding') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-ffn-embed-dim', type=int, metavar='N', + help='encoder embedding dimension for FFN') + parser.add_argument('--encoder-layers', type=int, metavar='N', + help='num encoder layers') + parser.add_argument('--encoder-attention-heads', type=int, metavar='N', + help='num encoder attention heads') + parser.add_argument('--encoder-normalize-before', action='store_true', + help='apply layernorm before each encoder block') + parser.add_argument('--encoder-learned-pos', action='store_true', + help='use learned positional embeddings in the encoder') + parser.add_argument('--bitfit', default=False, action='store_true', + help='use bitfit in the transformer') + parser.add_argument('--freeze-encoder', action='store_true', + help='freeze the parameters in the encoder') + + + parser.add_argument('--adapter', action='store_true', + help='use adapter in the model') + parser.add_argument('--adapter-dim', type=int, metavar='N', + help='adapter-down-dim') + + parser.add_argument('--encoder-prompt', action='store_true', + help='use prompt tuning in the encoder') + parser.add_argument('--encoder-prompt-type', type=str, metavar='STR', + choices=['prefix'], + help='the type of prompt tuning') + parser.add_argument('--encoder-prompt-projection', action='store_true', + help='use prompt projection') + parser.add_argument('--encoder-prompt-length', type=int, metavar='N', + help='use prompt tuning in the decoder') + parser.add_argument('--encoder-prompt-dim', type=int, metavar='N', + help='encoder prompt dimension if use encoder prompt projection') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-ffn-embed-dim', type=int, metavar='N', + help='decoder embedding dimension for FFN') + parser.add_argument('--decoder-layers', type=int, metavar='N', + help='num decoder layers') + parser.add_argument('--decoder-attention-heads', type=int, metavar='N', + help='num decoder attention heads') + parser.add_argument('--decoder-learned-pos', action='store_true', + help='use learned positional embeddings in the decoder') + parser.add_argument('--decoder-normalize-before', action='store_true', + help='apply layernorm before each decoder block') + parser.add_argument('--decoder-output-dim', type=int, metavar='N', + help='decoder output dimension (extra linear layer ' + 'if different from decoder embed dim') + parser.add_argument('--freeze-decoder', action='store_true', + help='freeze the parameters in the decoder') + + parser.add_argument('--decoder-prompt', action='store_true', + help='use prompt tuning in the decoder') + parser.add_argument('--decoder-prompt-type', type=str, metavar='STR', + choices=['prefix'], + help='the type of prompt tuning') + parser.add_argument('--decoder-prompt-length', type=int, metavar='N', + help='use prompt tuning in the decoder') + parser.add_argument('--decoder-prompt-projection', action='store_true', + help='use prompt projection') + parser.add_argument('--decoder-prompt-dim', type=int, metavar='N', + help='decoder prompt dimension if use decoder prompt projection') + parser.add_argument('--share-decoder-input-output-embed', action='store_true', + help='share decoder input and output embeddings') + parser.add_argument('--share-all-embeddings', action='store_true', + help='share encoder, decoder and output embeddings' + ' (requires shared dictionary and embed dim)') + parser.add_argument('--no-token-positional-embeddings', default=False, action='store_true', + help='if set, disables positional embeddings (outside self attention)') + parser.add_argument('--adaptive-softmax-cutoff', metavar='EXPR', + help='comma separated list of adaptive softmax cutoff points. ' + 'Must be used with adaptive_loss criterion'), + parser.add_argument('--adaptive-softmax-dropout', type=float, metavar='D', + help='sets adaptive softmax dropout for the tail projections') + parser.add_argument('--layernorm-embedding', action='store_true', + help='add layernorm to embedding') + parser.add_argument('--no-scale-embedding', action='store_true', + help='if True, dont scale embeddings') + parser.add_argument('--checkpoint-activations', action='store_true', + help='checkpoint activations at each layer, which saves GPU ' + 'memory usage at the cost of some additional compute') + parser.add_argument('--offload-activations', action='store_true', + help='checkpoint activations at each layer, then save to gpu. Sets --checkpoint-activations.') + # args for "Cross+Self-Attention for Transformer Models" (Peitz et al., 2019) + parser.add_argument('--no-cross-attention', default=False, action='store_true', + help='do not perform cross-attention') + parser.add_argument('--cross-self-attention', default=False, action='store_true', + help='perform cross+self-attention') + # args for "Reducing Transformer Depth on Demand with Structured Dropout" (Fan et al., 2019) + parser.add_argument('--encoder-layerdrop', type=float, metavar='D', default=0, + help='LayerDrop probability for encoder') + parser.add_argument('--decoder-layerdrop', type=float, metavar='D', default=0, + help='LayerDrop probability for decoder') + parser.add_argument('--encoder-layers-to-keep', default=None, + help='which layers to *keep* when pruning as a comma-separated list') + parser.add_argument('--decoder-layers-to-keep', default=None, + help='which layers to *keep* when pruning as a comma-separated list') + # args for Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020) + parser.add_argument('--quant-noise-pq', type=float, metavar='D', default=0, + help='iterative PQ quantization noise at training time') + parser.add_argument('--quant-noise-pq-block-size', type=int, metavar='D', default=8, + help='block size of quantization noise at training time') + parser.add_argument('--quant-noise-scalar', type=float, metavar='D', default=0, + help='scalar quantization noise and scalar quantization at training time') + # args for Fully Sharded Data Parallel (FSDP) training + parser.add_argument( + '--min-params-to-wrap', type=int, metavar='D', default=DEFAULT_MIN_PARAMS_TO_WRAP, + help=( + 'minimum number of params for a layer to be wrapped with FSDP() when ' + 'training with --ddp-backend=fully_sharded. Smaller values will ' + 'improve memory efficiency, but may make torch.distributed ' + 'communication less efficient due to smaller input sizes. This option ' + 'is set to 0 (i.e., always wrap) when --checkpoint-activations or ' + '--offload-activations are passed.' + ) + ) + + parser.add_argument('--resnet-drop-path-rate', type=float, + help='resnet drop path rate') + parser.add_argument('--encoder-drop-path-rate', type=float, + help='encoder drop path rate') + parser.add_argument('--decoder-drop-path-rate', type=float, + help='encoder drop path rate') + + parser.add_argument('--token-bucket-size', type=int, + help='token bucket size') + parser.add_argument('--image-bucket-size', type=int, + help='image bucket size') + + parser.add_argument('--attn-scale-factor', type=float, + help='attention scale factor') + parser.add_argument('--freeze-resnet', action='store_true', + help='freeze resnet') + parser.add_argument('--freeze-encoder-embedding', action='store_true', + help='freeze encoder token embedding') + parser.add_argument('--freeze-decoder-embedding', action='store_true', + help='freeze decoder token embedding') + parser.add_argument('--add-type-embedding', action='store_true', + help='add source/region/patch type embedding') + parser.add_argument('--interpolate-position', action='store_true', + help='interpolate position') + + parser.add_argument('--resnet-type', choices=['resnet50', 'resnet101', 'resnet152'], + help='resnet type') + parser.add_argument('--resnet-model-path', type=str, metavar='STR', + help='path to load resnet') + parser.add_argument('--code-image-size', type=int, + help='code image size') + parser.add_argument('--patch-layernorm-embedding', action='store_true', + help='add layernorm to patch embedding') + parser.add_argument('--code-layernorm-embedding', action='store_true', + help='add layernorm to code embedding') + parser.add_argument('--entangle-position-embedding', action='store_true', + help='entangle position embedding') + parser.add_argument('--disable-entangle', action='store_true', + help='disable entangle') + parser.add_argument('--sync-bn', action='store_true', + help='sync batchnorm') + + parser.add_argument('--scale-attn', action='store_true', + help='scale attn') + parser.add_argument('--scale-fc', action='store_true', + help='scale fc') + parser.add_argument('--scale-heads', action='store_true', + help='scale heads') + parser.add_argument('--scale-resids', action='store_true', + help='scale resids') + # fmt: on + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if args.encoder_layers_to_keep: + args.encoder_layers = len(args.encoder_layers_to_keep.split(",")) + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if getattr(args, "max_source_positions", None) is None: + args.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = DEFAULT_MAX_TARGET_POSITIONS + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + if args.share_all_embeddings: + if src_dict != tgt_dict: + raise ValueError("--share-all-embeddings requires a joined dictionary") + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = cls.build_embedding( + args, src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + encoder_embed_tokens = cls.build_embedding( + args, src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = cls.build_embedding( + args, tgt_dict, args.decoder_embed_dim, args.decoder_embed_path + ) + if getattr(args, "freeze_encoder_embedding", False) or getattr( + args, "encoder_prompt", False) or getattr(args, "decoder_prompt", False) or getattr(args, "adapter", False): + encoder_embed_tokens.weight.requires_grad = False + if getattr(args, "freeze_decoder_embedding", False) or getattr( + args, "encoder_prompt", False) or getattr(args, "decoder_prompt", False) or getattr(args, "adapter", False): + decoder_embed_tokens.weight.requires_grad = False + if getattr(args, "offload_activations", False): + args.checkpoint_activations = True # offloading implies checkpointing + encoder = cls.build_encoder(args, src_dict, encoder_embed_tokens) + decoder = cls.build_decoder(args, tgt_dict, decoder_embed_tokens) + if getattr(args, "encoder_prompt", False) or getattr( + args, "decoder_prompt", False): + encoder.requires_grad_(False) + decoder.requires_grad_(False) + if getattr(args, "encoder_prompt", False): + encoder.encoder_prompt_encoder.requires_grad_(True) + if getattr(args, "decoder_prompt", False): + decoder.decoder_prompt_encoder.requires_grad_(True) + if getattr(args, "adapter", False): + for idx, layer in enumerate(encoder.layers): + layer.adapter.requires_grad_(True) + for idx, layer in enumerate(decoder.layers): + layer.adapter.requires_grad_(True) + if not args.share_all_embeddings: + min_params_to_wrap = getattr( + args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP + ) + # fsdp_wrap is a no-op when --ddp-backend != fully_sharded + encoder = fsdp_wrap(encoder, min_num_params=min_params_to_wrap) + decoder = fsdp_wrap(decoder, min_num_params=min_params_to_wrap) + return cls(args, encoder, decoder) + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + + args.vocab_size = num_embeddings + emb = Embedding(num_embeddings, embed_dim, padding_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerDecoder( + args, + tgt_dict, + embed_tokens, + no_encoder_attn=getattr(args, "no_cross_attention", False), + ) + + # TorchScript doesn't support optional arguments with variable length (**kwargs). + # Current workaround is to add union of all arguments in child classes. + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + return_all_hiddens: bool = True, + features_only: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Run the forward pass for an encoder-decoder model. + + Copied from the base class, but without ``**kwargs``, + which are not supported by TorchScript. + """ + encoder_out = self.encoder( + src_tokens, src_lengths=src_lengths, return_all_hiddens=return_all_hiddens + ) + decoder_out = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + return decoder_out + + # Since get_normalized_probs is in the Fairseq Model which is not scriptable, + # I rewrite the get_normalized_probs from Base Class to call the + # helper function in the Base Class. + @torch.jit.export + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + return self.get_normalized_probs_scriptable(net_output, log_probs, sample) + + +class TransformerEncoder(FairseqEncoder): + """ + Transformer encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`TransformerEncoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_tokens (torch.nn.Embedding): input embedding + """ + + def __init__(self, args, dictionary, embed_tokens): + self.args = args + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + + if getattr(args, "encoder_prompt", False): + self.encoder_prompt_encoder = PromptEncoder( + type=args.encoder_prompt_type, + length=args.encoder_prompt_length, + projection=args.encoder_prompt_projection, + embed_dim=args.encoder_embed_dim, + proj_dim=args.encoder_prompt_dim, + layers=args.encoder_layers, + vocab_size=args.vocab_size) + self.encoder_dropout = nn.Dropout(p=0.2) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.encoder_layerdrop = args.encoder_layerdrop + + embed_dim = embed_tokens.embedding_dim + self.padding_idx = embed_tokens.padding_idx + self.max_source_positions = args.max_source_positions + self.num_attention_heads = args.encoder_attention_heads + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if args.no_scale_embedding else math.sqrt(embed_dim) + + if getattr(args, "layernorm_embedding", False): + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + if getattr(args, "add_type_embedding", False): + self.type_embedding = Embedding(2, embed_dim, padding_idx=None) + else: + self.type_embedding = None + + if getattr(args, "sync_bn", False): + norm_layer = BatchNorm2d + else: + if getattr(args, "freeze_resnet", False): + norm_layer = FrozenBatchNorm2d + else: + norm_layer = None + + if args.resnet_type == 'resnet101': + self.embed_images = ResNet([3, 4, 23], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet152': + self.embed_images = ResNet([3, 8, 36], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet50': + self.embed_images = ResNet([3, 4, 6], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + else: + raise NotImplementedError + self.image_proj = Linear(1024, embed_dim) + if getattr(args, "resnet_model_path", None): + print("load resnet {}".format(args.resnet_model_path)) + resnet_state_dict = torch.load(self.args.resnet_model_path) + self.embed_images.load_state_dict(resnet_state_dict) + if getattr(args, "patch_layernorm_embedding", False): + self.patch_layernorm_embedding = LayerNorm(embed_dim) + else: + self.patch_layernorm_embedding = None + + self.embed_positions = Embedding(args.max_source_positions + 2, embed_dim) + self.embed_image_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + self.pos_ln = LayerNorm(embed_dim) + self.image_pos_ln = LayerNorm(embed_dim) + self.pos_scaling = float(embed_dim / args.encoder_attention_heads * args.attn_scale_factor) ** -0.5 + self.pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.pos_k_linear = nn.Linear(embed_dim, embed_dim) + + if not args.adaptive_input and args.quant_noise_pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + args.quant_noise_pq, + args.quant_noise_pq_block_size, + ) + else: + self.quant_noise = None + + if self.encoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.encoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + + dpr = [x.item() for x in torch.linspace(0, args.encoder_drop_path_rate, args.encoder_layers)] + self.layers.extend( + [self.build_encoder_layer(args, drop_path_rate=dpr[i]) for i in range(args.encoder_layers)] + ) + self.num_layers = len(self.layers) + + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + token_bucket_size = args.token_bucket_size + token_num_rel_dis = 2 * token_bucket_size - 1 + token_rp_bucket = make_token_bucket_position(token_bucket_size) + self.token_rel_pos_table_list = nn.ModuleList( + [Embedding(token_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.encoder_layers)] + ) + + image_bucket_size = args.image_bucket_size + image_num_rel_dis = (2 * image_bucket_size - 1) * (2 * image_bucket_size - 1) + 3 + image_rp_bucket = make_image_bucket_position(image_bucket_size, image_num_rel_dis) + self.image_rel_pos_table_list = nn.ModuleList( + [Embedding(image_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.encoder_layers)] + ) + + self.patch_image_size = args.patch_image_size + self.orig_patch_image_size = args.orig_patch_image_size + + self.register_buffer("token_rp_bucket", token_rp_bucket) + self.register_buffer("image_rp_bucket", image_rp_bucket) + self.entangle_position_embedding = args.entangle_position_embedding + + def build_encoder_layer(self, args, drop_path_rate=0.0): + layer = TransformerEncoderLayer(args, drop_path_rate=drop_path_rate, \ + use_adapter=getattr(args, "adapter", False), adapter_dim=getattr(args, "adapter_dim", 200)) + checkpoint = getattr(args, "checkpoint_activations", False) + if checkpoint: + offload_to_cpu = getattr(args, "offload_activations", False) + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = ( + getattr(args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP) + if not checkpoint else 0 + ) + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def get_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + rp_bucket = self.token_rp_bucket[:seq_len, :seq_len] + values = F.embedding(rp_bucket, self.token_rel_pos_table_list[idx].weight) + values = values.unsqueeze(0).expand(x.size(0), -1, -1, -1) + values = values.permute([0, 3, 1, 2]) + return values.contiguous() + + def get_image_rel_pos_bias(self, image_position_ids, idx): + bsz, seq_len = image_position_ids.shape + rp_bucket_size = self.image_rp_bucket.size(1) + + rp_bucket = self.image_rp_bucket.unsqueeze(0).expand( + bsz, rp_bucket_size, rp_bucket_size + ).gather(1, image_position_ids[:, :, None].expand(bsz, seq_len, rp_bucket_size) + ).gather(2, image_position_ids[:, None, :].expand(bsz, seq_len, seq_len)) + values = F.embedding(rp_bucket, self.image_rel_pos_table_list[idx].weight) + values = values.permute(0, 3, 1, 2) + return values + + def get_patch_images_info(self, patch_images, sample_patch_num, device): + image_embed = self.embed_images(patch_images) + h, w = image_embed.shape[-2:] + image_num_patches = h * w + image_padding_mask = patch_images.new_zeros((patch_images.size(0), image_num_patches)).bool() + image_position_idx = torch.arange(w).unsqueeze(0).expand(h, w) + \ + torch.arange(h).unsqueeze(1) * self.args.image_bucket_size + 1 + image_position_idx = image_position_idx.view(-1).to(device) + image_position_ids = image_position_idx[None, :].expand(patch_images.size(0), image_num_patches) + + image_embed = image_embed.flatten(2).transpose(1, 2) + if sample_patch_num is not None: + patch_orders = [ + random.sample(range(image_num_patches), k=sample_patch_num) + for _ in range(patch_images.size(0)) + ] + patch_orders = torch.LongTensor(patch_orders).to(device) + image_embed = image_embed.gather( + 1, patch_orders.unsqueeze(2).expand(-1, -1, image_embed.size(2)) + ) + image_num_patches = sample_patch_num + image_padding_mask = image_padding_mask.gather(1, patch_orders) + image_position_ids = image_position_ids.gather(1, patch_orders) + orig_num_patches = (self.orig_patch_image_size // 16) ** 2 + orig_hw= self.orig_patch_image_size // 16 + if getattr(self.args, "interpolate_position", False) and image_num_patches > orig_num_patches: + old_image_position_ids = torch.arange(orig_hw).unsqueeze(0).expand(orig_hw, orig_hw) + \ + torch.arange(orig_hw).unsqueeze(1) * self.args.image_bucket_size + 1 + old_image_position_ids = old_image_position_ids.to(device) + old_image_pos_embed = self.embed_image_positions(old_image_position_ids) + old_image_pos_embed = old_image_pos_embed.reshape(1, orig_hw, orig_hw, -1).permute(0, 3, 1, 2) + image_pos_embed = F.interpolate(old_image_pos_embed, size=(h, w), mode='bilinear') + image_pos_embed = image_pos_embed.permute(0, 2, 3, 1).reshape(1, image_num_patches, -1) + image_pos_embed = image_pos_embed.expand(patch_images.size(0), -1, -1) + else: + image_pos_embed = self.embed_image_positions(image_position_ids) + + return image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed + + def get_encoder_prompt(self, prompt_tokens): + past_key_values = self.encoder_prompt_encoder(prompt_tokens) + bsz, seqlen, _ = past_key_values.shape + past_key_values = past_key_values.view( + bsz, + seqlen, + (self.args.encoder_layers) * 2, + self.args.encoder_attention_heads, + self.args.encoder_embed_dim // self.args.encoder_attention_heads, + ) + past_key_values = self.encoder_dropout(past_key_values) + past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(2) + return past_key_values + + def forward_embedding( + self, + src_tokens, + image_embed: Optional[torch.Tensor] = None, + image_embed_2: Optional[torch.Tensor] = None, + token_embedding: Optional[torch.Tensor] = None, + pos_embed: Optional[torch.Tensor] = None, + image_pos_embed: Optional[torch.Tensor] = None, + image_pos_embed_2: Optional[torch.Tensor] = None + ): + # embed tokens and positions + if token_embedding is None: + token_embedding = self.embed_tokens(src_tokens) + x = embed = self.embed_scale * token_embedding + if self.entangle_position_embedding and pos_embed is not None: + x += pos_embed + if self.type_embedding is not None: + x += self.type_embedding(src_tokens.new_zeros(x.size()[:2])) + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + x = self.dropout_module(x) + if self.quant_noise is not None: + x = self.quant_noise(x) + + # embed raw images + if image_embed is not None: + image_embed = self.image_proj(image_embed) + image_x = image_embed = self.embed_scale * image_embed + if self.entangle_position_embedding and image_pos_embed is not None: + image_x += image_pos_embed + if self.type_embedding is not None: + image_x += self.type_embedding(src_tokens.new_ones(image_x.size()[:2])) + if self.patch_layernorm_embedding is not None: + image_x = self.patch_layernorm_embedding(image_x) + image_x = self.dropout_module(image_x) + if self.quant_noise is not None: + image_x = self.quant_noise(image_x) + x = torch.cat([image_x, x], dim=1) + embed = torch.cat([image_embed, embed], dim=1) + + if image_embed_2 is not None: + assert self.type_embedding is not None + image_embed_2 = self.image_proj(image_embed_2) + image_x_2 = image_embed_2 = self.embed_scale * image_embed_2 + if self.entangle_position_embedding and image_pos_embed_2 is not None: + image_x_2 += image_pos_embed_2 + if self.type_embedding is not None: + image_x_2 += self.type_embedding(src_tokens.new_full(image_x_2.size()[:2], fill_value=2)) + if self.patch_layernorm_embedding is not None: + image_x_2 = self.patch_layernorm_embedding(image_x_2) + image_x_2 = self.dropout_module(image_x_2) + if self.quant_noise is not None: + image_x_2 = self.quant_noise(image_x_2) + x = torch.cat([image_x_2, x], dim=1) + embed = torch.cat([image_embed_2, embed], dim=1) + + return x, embed + + def forward( + self, + src_tokens, + src_lengths, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + code_masks: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + return self.forward_scriptable(src_tokens, + src_lengths, + patch_images, + patch_images_2, + patch_masks, + return_all_hiddens, + token_embeddings, + sample_patch_num) + + # TorchScript doesn't support super() method so that the scriptable Subclass + # can't access the base class model in Torchscript. + # Current workaround is to add a helper function with different name and + # call the helper function from scriptable Subclass. + def forward_scriptable( + self, + src_tokens, + src_lengths, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + prompt_tokens = None + prompt_padding_mask = None + prompt_kv_list = None + if self.args.encoder_prompt: + bsz, seq_len = src_tokens.shape[0], src_tokens.shape[1] + if self.args.encoder_prompt_type in ("prefix"): + prompt_tokens = torch.arange( + 0, self.args.encoder_prompt_length).to( + src_tokens.device) + prompt_tokens = prompt_tokens.unsqueeze(0).expand(bsz, -1) + prompt_padding_mask = torch.zeros_like(prompt_tokens).to(prompt_tokens.device) + prompt_kv_list = self.get_encoder_prompt(prompt_tokens) + image_embed = None + image_embed_2 = None + image_pos_embed = None + image_pos_embed_2 = None + if patch_images is not None: + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = \ + self.get_patch_images_info(patch_images, sample_patch_num, src_tokens.device) + image_padding_mask[~patch_masks] = True + if patch_images_2 is not None: + image_embed_2, image_num_patches_2, image_padding_mask_2, image_position_ids_2, image_pos_embed_2 = \ + self.get_patch_images_info(patch_images_2, sample_patch_num, src_tokens.device) + image_padding_mask_2[~patch_masks] = True + + encoder_padding_mask = src_tokens.eq(self.padding_idx) + if patch_images is not None: + encoder_padding_mask = torch.cat([image_padding_mask, encoder_padding_mask], dim=1) + if patch_images_2 is not None: + encoder_padding_mask = torch.cat([image_padding_mask_2, encoder_padding_mask], dim=1) + has_pads = (src_tokens.device.type == "xla" or encoder_padding_mask.any()) + + pos_embed = self.embed_positions(utils.new_arange(src_tokens)) + x, encoder_embedding = self.forward_embedding( + src_tokens, image_embed, image_embed_2, token_embeddings, + pos_embed, image_pos_embed, image_pos_embed_2 + ) + + # account for padding while computing the representation + if has_pads: + x = x * (1 - encoder_padding_mask.unsqueeze(-1).type_as(x)) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + pos_embed = self.pos_ln(pos_embed) + if patch_images is not None: + image_pos_embed = self.image_pos_ln(image_pos_embed) + pos_embed = torch.cat([image_pos_embed, pos_embed], dim=1) + if patch_images_2 is not None: + image_pos_embed_2 = self.image_pos_ln(image_pos_embed_2) + pos_embed = torch.cat([image_pos_embed_2, pos_embed], dim=1) + + pos_q = self.pos_q_linear(pos_embed).view( + pos_embed.size(0), pos_embed.size(1), self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.pos_k_linear(pos_embed).view( + pos_embed.size(0), pos_embed.size(1), self.num_attention_heads, -1 + ).transpose(1, 2) + abs_pos_bias = torch.matmul(pos_q, pos_k.transpose(2, 3)) + + encoder_states = [] + + if return_all_hiddens: + encoder_states.append(x) + + if prompt_padding_mask is not None: + encoder_padding_mask = torch.cat([prompt_padding_mask, encoder_padding_mask], dim=1) + # encoder layers + for idx, layer in enumerate(self.layers): + self_attn_bias = abs_pos_bias.clone() + self_attn_bias[:, :, -src_tokens.size(1):, -src_tokens.size(1):] += self.get_rel_pos_bias(src_tokens, idx) + if patch_images_2 is not None: + self_attn_bias[:, :, :image_num_patches_2, :image_num_patches_2] += \ + self.get_image_rel_pos_bias(image_position_ids_2, idx) + self_attn_bias[:, :, image_num_patches_2:image_num_patches_2+image_num_patches, image_num_patches_2:image_num_patches_2+image_num_patches] += \ + self.get_image_rel_pos_bias(image_position_ids, idx) + elif patch_images is not None: + self_attn_bias[:, :, :x.size(0) - src_tokens.size(1), :x.size(0) - src_tokens.size(1)] += \ + self.get_image_rel_pos_bias(image_position_ids, idx) + self_attn_bias = self_attn_bias.reshape(-1, self_attn_bias.size(2), self_attn_bias.size(2)) + if self.args.encoder_prompt: + if self.args.encoder_prompt_type != "prompt": + prompt_kv = prompt_kv_list[idx] + else: + if idx == 0: + prompt_kv = prompt_kv_list[idx] + else: + prompt_kv = None + else: + prompt_kv = None + x = layer(x, encoder_padding_mask=encoder_padding_mask if has_pads else None, \ + self_attn_bias=self_attn_bias, prompt_kv=prompt_kv) + if return_all_hiddens: + assert encoder_states is not None + encoder_states.append(x) + + if self.layer_norm is not None: + x = self.layer_norm(x) + if self.args.encoder_prompt: + encoder_padding_mask = encoder_padding_mask[:, prompt_tokens.size(1):] + # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in + # `forward` so we use a dictionary instead. + # TorchScript does not support mixed values so the values are all lists. + # The empty list is equivalent to None. + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [encoder_padding_mask], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + "position_embeddings": [pos_embed], # B x T x C + } + + @torch.jit.export + def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + if len(encoder_out["encoder_out"]) == 0: + new_encoder_out = [] + else: + new_encoder_out = [encoder_out["encoder_out"][0].index_select(1, new_order)] + if len(encoder_out["encoder_padding_mask"]) == 0: + new_encoder_padding_mask = [] + else: + new_encoder_padding_mask = [ + encoder_out["encoder_padding_mask"][0].index_select(0, new_order) + ] + if len(encoder_out["encoder_embedding"]) == 0: + new_encoder_embedding = [] + else: + new_encoder_embedding = [ + encoder_out["encoder_embedding"][0].index_select(0, new_order) + ] + + if len(encoder_out["src_tokens"]) == 0: + new_src_tokens = [] + else: + new_src_tokens = [(encoder_out["src_tokens"][0]).index_select(0, new_order)] + + if len(encoder_out["src_lengths"]) == 0: + new_src_lengths = [] + else: + new_src_lengths = [(encoder_out["src_lengths"][0]).index_select(0, new_order)] + + if len(encoder_out["position_embeddings"]) == 0: + new_position_embeddings = [] + else: + new_position_embeddings = [(encoder_out["position_embeddings"][0]).index_select(0, new_order)] + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": new_src_tokens, # B x T + "src_lengths": new_src_lengths, # B x 1 + "position_embeddings": new_position_embeddings, # B x T x C + } + + def max_positions(self): + """Maximum input length supported by the encoder.""" + if self.embed_positions is None: + return self.max_source_positions + return self.max_source_positions + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + print("deleting {0}".format(weights_key)) + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + for i in range(self.num_layers): + # update layer norms + self.layers[i].upgrade_state_dict_named( + state_dict, "{}.layers.{}".format(name, i) + ) + + # version_key = "{}.version".format(name) + # if utils.item(state_dict.get(version_key, torch.Tensor([1]))[0]) < 2: + # # earlier checkpoints did not normalize after the stack of layers + # self.layer_norm = None + # self.normalize = False + # state_dict[version_key] = torch.Tensor([1]) + + prefix = name + "." if name != "" else "" + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] + + if len(state_dict["encoder.embed_image_positions.weight"]) < len(self.state_dict()["embed_image_positions.weight"]): + num_posids_to_add = len(self.state_dict()["embed_image_positions.weight"]) - len(state_dict["encoder.embed_image_positions.weight"]) + embed_dim = state_dict["encoder.embed_image_positions.weight"].size(1) + new_pos_embed_to_add = torch.zeros(num_posids_to_add, embed_dim) + nn.init.normal_(new_pos_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_pos_embed_to_add = new_pos_embed_to_add.to( + dtype=state_dict["encoder.embed_image_positions.weight"].dtype, + ) + state_dict["encoder.embed_image_positions.weight"] = torch.cat( + [state_dict["encoder.embed_image_positions.weight"], new_pos_embed_to_add] + ) + return state_dict + + +class TransformerDecoder(FairseqIncrementalDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, + args, + dictionary, + embed_tokens, + no_encoder_attn=False, + output_projection=None, + ): + self.args = args + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + self._future_mask = torch.empty(0) + + if getattr(args, "decoder_prompt", False): + self.decoder_prompt_encoder = PromptEncoder( + type=args.decoder_prompt_type, + length=args.decoder_prompt_length, + projection=args.decoder_prompt_projection, + embed_dim=args.decoder_embed_dim, + proj_dim=args.decoder_prompt_dim, + layers=args.decoder_layers, + vocab_size=args.vocab_size) + self.decoder_dropout = nn.Dropout(p=0.2) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.decoder_layerdrop = args.decoder_layerdrop + self.share_input_output_embed = args.share_decoder_input_output_embed + self.num_attention_heads = args.decoder_attention_heads + + input_embed_dim = embed_tokens.embedding_dim + embed_dim = args.decoder_embed_dim + self.embed_dim = embed_dim + self.output_embed_dim = args.decoder_output_dim + + self.padding_idx = embed_tokens.padding_idx + self.max_target_positions = args.max_target_positions + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if args.no_scale_embedding else math.sqrt(embed_dim) + + if not args.adaptive_input and args.quant_noise_pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + args.quant_noise_pq, + args.quant_noise_pq_block_size, + ) + else: + self.quant_noise = None + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + + if getattr(args, "layernorm_embedding", False): + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + self.window_size = args.code_image_size // 8 + + self.embed_positions = Embedding(args.max_target_positions + 2, embed_dim) + self.embed_image_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + self.pos_ln = LayerNorm(embed_dim) + self.image_pos_ln = LayerNorm(embed_dim) + self.pos_scaling = float(embed_dim / self.num_attention_heads * args.attn_scale_factor) ** -0.5 + self.self_pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.self_pos_k_linear = nn.Linear(embed_dim, embed_dim) + self.cross_pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.cross_pos_k_linear = nn.Linear(embed_dim, embed_dim) + + if getattr(args, "code_layernorm_embedding", False): + self.code_layernorm_embedding = LayerNorm(embed_dim) + else: + self.code_layernorm_embedding = None + + self.cross_self_attention = getattr(args, "cross_self_attention", False) + + if self.decoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.decoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + + dpr = [x.item() for x in torch.linspace(0, args.decoder_drop_path_rate, args.decoder_layers)] + self.layers.extend( + [ + self.build_decoder_layer(args, no_encoder_attn, drop_path_rate=dpr[i]) + for i in range(args.decoder_layers) + ] + ) + self.num_layers = len(self.layers) + + if args.decoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + self.project_out_dim = ( + Linear(embed_dim, self.output_embed_dim, bias=False) + if embed_dim != self.output_embed_dim and not args.tie_adaptive_weights + else None + ) + + self.adaptive_softmax = None + self.output_projection = output_projection + if self.output_projection is None: + self.build_output_projection(args, dictionary, embed_tokens) + + token_bucket_size = args.token_bucket_size + token_num_rel_dis = 2 * token_bucket_size - 1 + token_rp_bucket = make_token_bucket_position(token_bucket_size) + self.token_rel_pos_table_list = nn.ModuleList( + [Embedding(token_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.decoder_layers)] + ) + + image_bucket_size = args.image_bucket_size + image_num_rel_dis = (2 * image_bucket_size - 1) * (2 * image_bucket_size - 1) + 3 + image_rp_bucket = make_image_bucket_position(image_bucket_size, image_num_rel_dis) + image_position_idx = torch.arange(self.window_size).unsqueeze(0).expand(self.window_size, self.window_size) + \ + torch.arange(self.window_size).unsqueeze(1) * image_bucket_size + 1 + image_position_idx = torch.cat([torch.tensor([0]), image_position_idx.view(-1)]) + image_position_idx = torch.cat([image_position_idx, torch.tensor([1024] * 769)]) + self.image_rel_pos_table_list = nn.ModuleList( + [Embedding(image_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.decoder_layers)] + ) + + self.register_buffer("token_rp_bucket", token_rp_bucket) + self.register_buffer("image_rp_bucket", image_rp_bucket) + self.register_buffer("image_position_idx", image_position_idx) + self.entangle_position_embedding = args.entangle_position_embedding + + def get_decoder_prompt(self, prompt_tokens): + past_key_values = self.decoder_prompt_encoder(prompt_tokens) + bsz, seqlen, _ = past_key_values.shape + past_key_values = past_key_values.view( + bsz, + seqlen, + self.args.decoder_layers * 2, + self.args.decoder_attention_heads, + self.args.decoder_embed_dim // self.args.decoder_attention_heads, + ) + past_key_values = self.decoder_dropout(past_key_values) + past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(2) + return past_key_values + + def build_output_projection(self, args, dictionary, embed_tokens): + if args.adaptive_softmax_cutoff is not None: + self.adaptive_softmax = AdaptiveSoftmax( + len(dictionary), + self.output_embed_dim, + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int), + dropout=args.adaptive_softmax_dropout, + adaptive_inputs=embed_tokens if args.tie_adaptive_weights else None, + factor=args.adaptive_softmax_factor, + tie_proj=args.tie_adaptive_proj, + ) + elif self.share_input_output_embed: + self.output_projection = nn.Linear( + self.embed_tokens.weight.shape[1], + self.embed_tokens.weight.shape[0], + bias=False, + ) + self.output_projection.weight = self.embed_tokens.weight + else: + self.output_projection = nn.Linear( + self.output_embed_dim, len(dictionary), bias=False + ) + nn.init.normal_( + self.output_projection.weight, mean=0, std=self.output_embed_dim ** -0.5 + ) + num_base_layers = getattr(args, "base_layers", 0) + for i in range(num_base_layers): + self.layers.insert(((i+1) * args.decoder_layers) // (num_base_layers + 1), BaseLayer(args)) + + def build_decoder_layer(self, args, no_encoder_attn=False, drop_path_rate=0.0): + layer = TransformerDecoderLayer(args, no_encoder_attn, drop_path_rate= \ + drop_path_rate, use_adapter=getattr(args, "adapter", False), adapter_dim=getattr(args, "adapter_dim", 200)) + checkpoint = getattr(args, "checkpoint_activations", False) + if checkpoint: + offload_to_cpu = getattr(args, "offload_activations", False) + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = ( + getattr(args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP) + if not checkpoint else 0 + ) + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def get_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + rp_bucket = self.token_rp_bucket[:seq_len, :seq_len] + values = F.embedding(rp_bucket, self.token_rel_pos_table_list[idx].weight) + values = values.permute([2, 0, 1]) + return values.contiguous() + + def get_image_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + image_position_idx = self.image_position_idx[:seq_len] + rp_bucket = self.image_rp_bucket[image_position_idx][:, image_position_idx] + values = F.embedding(rp_bucket, self.image_rel_pos_table_list[idx].weight) + values = values.permute(2, 0, 1) + return values + + def get_pos_info(self, tokens, tgt_pos_embed, src_pos_embed=None, use_image=False): + batch_size = tokens.size(0) + tgt_len = tokens.size(1) + tgt_pos_embed = self.image_pos_ln(tgt_pos_embed) if use_image else self.pos_ln(tgt_pos_embed) + if src_pos_embed is not None: + src_len = src_pos_embed.size(1) + pos_q = self.cross_pos_q_linear(tgt_pos_embed).view( + batch_size, tgt_len, self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.cross_pos_k_linear(src_pos_embed).view( + batch_size, src_len, self.num_attention_heads, -1 + ).transpose(1, 2) + else: + src_len = tgt_pos_embed.size(1) + pos_q = self.self_pos_q_linear(tgt_pos_embed).view( + batch_size, tgt_len, self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.self_pos_k_linear(tgt_pos_embed).view( + batch_size, src_len, self.num_attention_heads, -1 + ).transpose(1, 2) + abs_pos_bias = torch.matmul(pos_q, pos_k.transpose(2, 3)) + return abs_pos_bias + + def forward( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor] = None, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention, should be of size T x B x C + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False). + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + + x, extra = self.extract_features( + prev_output_tokens, + code_masks=code_masks, + encoder_out=encoder_out, + incremental_state=incremental_state, + full_context_alignment=full_context_alignment, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + ) + + if not features_only: + x = self.output_layer(x) + return x, extra + + def extract_features( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor], + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + return self.extract_features_scriptable( + prev_output_tokens, + code_masks, + encoder_out, + incremental_state, + full_context_alignment, + alignment_layer, + alignment_heads, + ) + + """ + A scriptable subclass of this class has an extract_features method and calls + super().extract_features, but super() is not supported in torchscript. A copy of + this function is made to be used in the subclass instead. + """ + + def extract_features_scriptable( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor], + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Similar to *forward* but only return features. + + Includes several features from "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + alignment_layer (int, optional): return mean alignment over + heads at this layer (default: last layer). + alignment_heads (int, optional): only average alignment over + this many heads (default: all heads). + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + prompt_tokens = None + prompt_padding_mask = None + prompt_kv_list = None + if self.args.decoder_prompt: + bsz, seq_len = prev_output_tokens.shape[0], prev_output_tokens.shape[1] + if self.args.decoder_prompt_type in ("prefix"): + prompt_tokens = torch.arange( + 0, self.args.decoder_prompt_length).to( + prev_output_tokens.device) + prompt_tokens = prompt_tokens.unsqueeze(0).expand(bsz, -1) + prompt_padding_mask = torch.zeros_like(prompt_tokens).to(prompt_tokens.device) + prompt_kv_list = self.get_decoder_prompt(prompt_tokens) + bs, slen = prev_output_tokens.size() + if alignment_layer is None: + alignment_layer = self.num_layers - 1 + + enc: Optional[Tensor] = None + padding_mask: Optional[Tensor] = None + if encoder_out is not None and len(encoder_out["encoder_out"]) > 0: + enc = encoder_out["encoder_out"][0] + assert ( + enc.size()[1] == bs + ), f"Expected enc.shape == (t, {bs}, c) got {enc.shape}" + if encoder_out is not None and len(encoder_out["encoder_padding_mask"]) > 0: + padding_mask = encoder_out["encoder_padding_mask"][0] + + bsz, tgt_len = prev_output_tokens.shape + token_position_idx = utils.new_arange(prev_output_tokens) + tgt_pos_embed = self.embed_positions(token_position_idx) + if code_masks is not None and torch.any(code_masks): + image_position_idx = self.image_position_idx[:prev_output_tokens.size(1)].unsqueeze(0).expand(bsz, tgt_len) + tgt_pos_embed[code_masks] = self.embed_image_positions(image_position_idx)[code_masks] + + # self attn position bias + self_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, use_image=False) + if code_masks is not None and torch.any(code_masks): + self_image_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, use_image=True) + self_abs_pos_bias[code_masks] = self_image_abs_pos_bias[code_masks] + # cross attn position bias + src_pos_embed = encoder_out['position_embeddings'][0] + cross_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, src_pos_embed=src_pos_embed) + if code_masks is not None and torch.any(code_masks): + cross_image_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, src_pos_embed=src_pos_embed, use_image=True) + cross_abs_pos_bias[code_masks] = cross_image_abs_pos_bias[code_masks] + cross_abs_pos_bias = cross_abs_pos_bias.reshape(-1, *cross_abs_pos_bias.size()[-2:]) + + all_prev_output_tokens = prev_output_tokens.clone() + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + cross_abs_pos_bias = cross_abs_pos_bias[:, -1:, :] + tgt_pos_embed = tgt_pos_embed[:, -1:, :] + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.quant_noise is not None: + x = self.quant_noise(x) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if self.entangle_position_embedding is not None and not self.args.disable_entangle: + x += tgt_pos_embed + + if self.layernorm_embedding is not None: + if code_masks is None or not code_masks.any() or not getattr(self, "code_layernorm_embedding", False): + x = self.layernorm_embedding(x) + elif code_masks is not None and code_masks.all(): + x = self.code_layernorm_embedding(x) + else: + x[~code_masks] = self.layernorm_embedding(x[~code_masks]) + x[code_masks] = self.code_layernorm_embedding(x[code_masks]) + + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + self_attn_padding_mask: Optional[Tensor] = None + if self.cross_self_attention or prev_output_tokens.eq(self.padding_idx).any(): + self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx) + if prompt_padding_mask is not None: + self_attn_padding_mask = torch.cat([prompt_padding_mask, self_attn_padding_mask], dim=1) + + # decoder layers + attn: Optional[Tensor] = None + inner_states: List[Optional[Tensor]] = [x] + for idx, layer in enumerate(self.layers): + if incremental_state is None and not full_context_alignment: + self_attn_mask = self.buffered_future_mask(x) + if self.args.decoder_prompt: + seq_len, prompt_len = x.size(0), prompt_tokens.size(1) + prompt_mask = torch.zeros([seq_len, prompt_len]).to(x.device) + self_attn_mask = torch.cat([prompt_mask, self_attn_mask], dim=1) + else: + self_attn_mask = None + + self_attn_bias = self_abs_pos_bias.clone() + if code_masks is None or not code_masks.any(): + self_attn_bias += self.get_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + elif code_masks is not None and code_masks.all(): + self_attn_bias += self.get_image_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + else: + self_attn_bias[~code_masks] += self.get_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + self_attn_bias[code_masks] += self.get_image_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + self_attn_bias = self_attn_bias.reshape(-1, *self_attn_bias.size()[-2:]) + if incremental_state is not None: + self_attn_bias = self_attn_bias[:, -1:, :] + + if self.args.decoder_prompt: + if self.args.decoder_prompt_type != "prompt": + prompt_kv = prompt_kv_list[idx] + else: + if idx == 0: + prompt_kv = prompt_kv_list[idx] + else: + prompt_kv = None + else: + prompt_kv = None + + x, layer_attn, _ = layer( + x, + enc, + padding_mask, + incremental_state, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=self_attn_padding_mask, + need_attn=bool((idx == alignment_layer)), + need_head_weights=bool((idx == alignment_layer)), + self_attn_bias=self_attn_bias, + cross_attn_bias=cross_abs_pos_bias, + prompt_kv=prompt_kv + ) + inner_states.append(x) + if layer_attn is not None and idx == alignment_layer: + attn = layer_attn.float().to(x) + + if attn is not None: + if alignment_heads is not None: + attn = attn[:alignment_heads] + + # average probabilities over heads + attn = attn.mean(dim=0) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": [attn], "inner_states": inner_states} + + def output_layer(self, features): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + # project back to size of vocabulary + return self.output_projection(features) + else: + return features + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embed_positions is None: + return self.max_target_positions + return self.max_target_positions + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + # self._future_mask.device != tensor.device is not working in TorchScript. This is a workaround. + if ( + self._future_mask.size(0) == 0 + or (not self._future_mask.device == tensor.device) + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(torch.zeros([dim, dim])), 1 + ) + self._future_mask = self._future_mask.to(tensor) + return self._future_mask[:dim, :dim] + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + + if f"{name}.output_projection.weight" not in state_dict: + if self.share_input_output_embed: + embed_out_key = f"{name}.embed_tokens.weight" + else: + embed_out_key = f"{name}.embed_out" + if embed_out_key in state_dict: + state_dict[f"{name}.output_projection.weight"] = state_dict[ + embed_out_key + ] + if not self.share_input_output_embed: + del state_dict[embed_out_key] + + for i in range(self.num_layers): + # update layer norms + self.layers[i].upgrade_state_dict_named( + state_dict, "{}.layers.{}".format(name, i) + ) + + # version_key = "{}.version".format(name) + # if utils.item(state_dict.get(version_key, torch.Tensor([1]))[0]) <= 2: + # # earlier checkpoints did not normalize after the stack of layers + # self.layer_norm = None + # self.normalize = False + # state_dict[version_key] = torch.Tensor([1]) + + prefix = name + "." if name != "" else "" + image_params = ["image_position_idx"] + for image_param in image_params: + state_dict[prefix + image_param] = self.state_dict()[image_param] + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] + + if len(state_dict["decoder.embed_image_positions.weight"]) < len(self.state_dict()["embed_image_positions.weight"]): + num_posids_to_add = len(self.state_dict()["embed_image_positions.weight"]) - len(state_dict["decoder.embed_image_positions.weight"]) + embed_dim = state_dict["decoder.embed_image_positions.weight"].size(1) + new_pos_embed_to_add = torch.zeros(num_posids_to_add, embed_dim) + nn.init.normal_(new_pos_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_pos_embed_to_add = new_pos_embed_to_add.to( + dtype=state_dict["decoder.embed_image_positions.weight"].dtype, + ) + state_dict["decoder.embed_image_positions.weight"] = torch.cat( + [state_dict["decoder.embed_image_positions.weight"], new_pos_embed_to_add] + ) + return state_dict + + +def Embedding(num_embeddings, embedding_dim, padding_idx=None, zero_init=False): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + if padding_idx is not None: + nn.init.constant_(m.weight[padding_idx], 0) + if zero_init: + nn.init.constant_(m.weight, 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m + + +@register_model_architecture("unify_transformer", "unify_transformer") +def base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.no_cross_attention = getattr(args, "no_cross_attention", False) + args.cross_self_attention = getattr(args, "cross_self_attention", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.encoder_prompt = getattr(args, "encoder_prompt", False) + args.encoder_prompt_length = getattr(args, "encoder_prompt_length", 100) + args.encoder_prompt_type = getattr(args, "encoder_prompt_type", "prefix") + args.encoder_prompt_projection = getattr(args, "encoder_prompt_projection", False) + args.encoder_prompt_dim = getattr(args, "encoder_prompt_dim", 2 * args.encoder_embed_dim) + + args.decoder_prompt = getattr(args, "decoder_prompt", False) + args.decoder_prompt_length = getattr(args, "decoder_prompt_length", 100) + args.decoder_prompt_type = getattr(args, "decoder_prompt_type", "prefix") + args.decoder_prompt_projection = getattr(args, "decoder_prompt_projection", False) + args.decoder_prompt_dim = getattr(args, "decoder_prompt_dim", 2 * args.encoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.checkpoint_activations = getattr(args, "checkpoint_activations", False) + args.offload_activations = getattr(args, "offload_activations", False) + if args.offload_activations: + args.checkpoint_activations = True + args.encoder_layers_to_keep = getattr(args, "encoder_layers_to_keep", None) + args.decoder_layers_to_keep = getattr(args, "decoder_layers_to_keep", None) + args.encoder_layerdrop = getattr(args, "encoder_layerdrop", 0) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.quant_noise_pq_block_size = getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = getattr(args, "quant_noise_scalar", 0) diff --git a/models/unival/__init__.py b/models/unival/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8f78d35df16bef627995c32f287e55c27382ec93 --- /dev/null +++ b/models/unival/__init__.py @@ -0,0 +1 @@ +from .unival import UnIVALModel, unival_base_architecture, unival_large_architecture \ No newline at end of file diff --git a/models/unival/__pycache__/__init__.cpython-37.pyc b/models/unival/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f4aa2cc5a54252edbea434354d0763c5f3d847f Binary files /dev/null and b/models/unival/__pycache__/__init__.cpython-37.pyc differ diff --git a/models/unival/__pycache__/__init__.cpython-38.pyc b/models/unival/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..70b50d6a01b18768c5e034a4f4d184557db8f0b5 Binary files /dev/null and b/models/unival/__pycache__/__init__.cpython-38.pyc differ diff --git a/models/unival/__pycache__/__init__.cpython-39.pyc b/models/unival/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfb4a38931653ebecd9ffc22be308c29875456e2 Binary files /dev/null and b/models/unival/__pycache__/__init__.cpython-39.pyc differ diff --git a/models/unival/__pycache__/frozen_bn.cpython-37.pyc b/models/unival/__pycache__/frozen_bn.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a780c7d4dba65caa875f6f367add323be10e2808 Binary files /dev/null and b/models/unival/__pycache__/frozen_bn.cpython-37.pyc differ diff --git a/models/unival/__pycache__/frozen_bn.cpython-38.pyc b/models/unival/__pycache__/frozen_bn.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2522a94416294c1136ddd81528c1449b072f1c7a Binary files /dev/null and b/models/unival/__pycache__/frozen_bn.cpython-38.pyc differ diff --git a/models/unival/__pycache__/frozen_bn.cpython-39.pyc b/models/unival/__pycache__/frozen_bn.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..665c10acaa7cf2809c51c23901796a6b48086490 Binary files /dev/null and b/models/unival/__pycache__/frozen_bn.cpython-39.pyc differ diff --git a/models/unival/__pycache__/ofa.cpython-37.pyc b/models/unival/__pycache__/ofa.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac23e7d78b84564817f9f8a184dca8aa1bce52c5 Binary files /dev/null and b/models/unival/__pycache__/ofa.cpython-37.pyc differ diff --git a/models/unival/__pycache__/ofa.cpython-38.pyc b/models/unival/__pycache__/ofa.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2df37524aaf8bb2a4b61e3eb3c75b591fec59087 Binary files /dev/null and b/models/unival/__pycache__/ofa.cpython-38.pyc differ diff --git a/models/unival/__pycache__/ofa.cpython-39.pyc b/models/unival/__pycache__/ofa.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d66167e4e2c05b96413f19b8044e45bad88ca9f Binary files /dev/null and b/models/unival/__pycache__/ofa.cpython-39.pyc differ diff --git a/models/unival/__pycache__/resnet.cpython-37.pyc b/models/unival/__pycache__/resnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f84687a03f76d860c690820135bd7f75a435900d Binary files /dev/null and b/models/unival/__pycache__/resnet.cpython-37.pyc differ diff --git a/models/unival/__pycache__/resnet.cpython-38.pyc b/models/unival/__pycache__/resnet.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3fdb31fbe28479febe190761d0e4b033f3b6a84 Binary files /dev/null and b/models/unival/__pycache__/resnet.cpython-38.pyc differ diff --git a/models/unival/__pycache__/resnet.cpython-39.pyc b/models/unival/__pycache__/resnet.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef515320cca9fbae86ce9012eac15186374d9e63 Binary files /dev/null and b/models/unival/__pycache__/resnet.cpython-39.pyc differ diff --git a/models/unival/__pycache__/resnet3d.cpython-39.pyc b/models/unival/__pycache__/resnet3d.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..822ae93d572218d297703c575bf688bfbace4272 Binary files /dev/null and b/models/unival/__pycache__/resnet3d.cpython-39.pyc differ diff --git a/models/unival/__pycache__/timesformer.cpython-39.pyc b/models/unival/__pycache__/timesformer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ccaeb26ee9ae653b1dc48fd056cff66971c96734 Binary files /dev/null and b/models/unival/__pycache__/timesformer.cpython-39.pyc differ diff --git a/models/unival/__pycache__/unify_multihead_attention.cpython-37.pyc b/models/unival/__pycache__/unify_multihead_attention.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..17a53af7cc954f87eb29fdb6857458bec31ed32e Binary files /dev/null and b/models/unival/__pycache__/unify_multihead_attention.cpython-37.pyc differ diff --git a/models/unival/__pycache__/unify_multihead_attention.cpython-38.pyc b/models/unival/__pycache__/unify_multihead_attention.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d96f5d2edaae5f5286cb2c37db7b531a8d5ea81 Binary files /dev/null and b/models/unival/__pycache__/unify_multihead_attention.cpython-38.pyc differ diff --git a/models/unival/__pycache__/unify_multihead_attention.cpython-39.pyc b/models/unival/__pycache__/unify_multihead_attention.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5410679c45b4cd4bb6872b681a62f9d72ba7e6dd Binary files /dev/null and b/models/unival/__pycache__/unify_multihead_attention.cpython-39.pyc differ diff --git a/models/unival/__pycache__/unify_transformer.cpython-37.pyc b/models/unival/__pycache__/unify_transformer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d12eb676a395fe50f04b5566201baf96ade932c Binary files /dev/null and b/models/unival/__pycache__/unify_transformer.cpython-37.pyc differ diff --git a/models/unival/__pycache__/unify_transformer.cpython-38.pyc b/models/unival/__pycache__/unify_transformer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5dedc3e3bd8beb572bea155f86784c2a12ad9059 Binary files /dev/null and b/models/unival/__pycache__/unify_transformer.cpython-38.pyc differ diff --git a/models/unival/__pycache__/unify_transformer.cpython-39.pyc b/models/unival/__pycache__/unify_transformer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..288984dddeb7f02f4304870820b5377650296624 Binary files /dev/null and b/models/unival/__pycache__/unify_transformer.cpython-39.pyc differ diff --git a/models/unival/__pycache__/unify_transformer_layer.cpython-37.pyc b/models/unival/__pycache__/unify_transformer_layer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3be7d22c8dfcd3d9394b64fdd52ae355e59c3b16 Binary files /dev/null and b/models/unival/__pycache__/unify_transformer_layer.cpython-37.pyc differ diff --git a/models/unival/__pycache__/unify_transformer_layer.cpython-38.pyc b/models/unival/__pycache__/unify_transformer_layer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d574ada4c66fabe24430b82a0d04014e5329bf06 Binary files /dev/null and b/models/unival/__pycache__/unify_transformer_layer.cpython-38.pyc differ diff --git a/models/unival/__pycache__/unify_transformer_layer.cpython-39.pyc b/models/unival/__pycache__/unify_transformer_layer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d331fef4db9a5dba0f651df55c5f4f5686be7bf5 Binary files /dev/null and b/models/unival/__pycache__/unify_transformer_layer.cpython-39.pyc differ diff --git a/models/unival/__pycache__/unival.cpython-37.pyc b/models/unival/__pycache__/unival.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..537c64c855c240c390fd9c05e575f7997b9456b6 Binary files /dev/null and b/models/unival/__pycache__/unival.cpython-37.pyc differ diff --git a/models/unival/__pycache__/vit.cpython-39.pyc b/models/unival/__pycache__/vit.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..048ac1a1264e7dea803f2738ccc0954f3f36270e Binary files /dev/null and b/models/unival/__pycache__/vit.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/ast.cpython-39.pyc b/models/unival/encoders/__pycache__/ast.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35851c63468b28f9a5177509dd2a72f4578c73e0 Binary files /dev/null and b/models/unival/encoders/__pycache__/ast.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/audio_utils.cpython-37.pyc b/models/unival/encoders/__pycache__/audio_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f99c2de645143cf611aa341751e680605bf6bf6 Binary files /dev/null and b/models/unival/encoders/__pycache__/audio_utils.cpython-37.pyc differ diff --git a/models/unival/encoders/__pycache__/audio_utils.cpython-39.pyc b/models/unival/encoders/__pycache__/audio_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eea4264dab1592cc2063d38e5783864e5c4364ab Binary files /dev/null and b/models/unival/encoders/__pycache__/audio_utils.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/clip.cpython-39.pyc b/models/unival/encoders/__pycache__/clip.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8af8d11d12e7e93b78c6ab71d8f551ecfb6ae194 Binary files /dev/null and b/models/unival/encoders/__pycache__/clip.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/feature_fusion.cpython-37.pyc b/models/unival/encoders/__pycache__/feature_fusion.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..681213d494ca7f2daffb5f2da03f79f1e033b94a Binary files /dev/null and b/models/unival/encoders/__pycache__/feature_fusion.cpython-37.pyc differ diff --git a/models/unival/encoders/__pycache__/feature_fusion.cpython-39.pyc b/models/unival/encoders/__pycache__/feature_fusion.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54b650ea8b83ddbd9b1b606372315dd50d856cc9 Binary files /dev/null and b/models/unival/encoders/__pycache__/feature_fusion.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/htsat.cpython-39.pyc b/models/unival/encoders/__pycache__/htsat.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2356a2c3ad5c3dfc158a5a6f5721339c53b6747 Binary files /dev/null and b/models/unival/encoders/__pycache__/htsat.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/pann.cpython-37.pyc b/models/unival/encoders/__pycache__/pann.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..327064affdd9ead53eb731b6bffb47b67ebfed50 Binary files /dev/null and b/models/unival/encoders/__pycache__/pann.cpython-37.pyc differ diff --git a/models/unival/encoders/__pycache__/pann.cpython-39.pyc b/models/unival/encoders/__pycache__/pann.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4a5cc076be7bc2f8e94c62fe5f2decd507f5b5b Binary files /dev/null and b/models/unival/encoders/__pycache__/pann.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/resnext3d.cpython-37.pyc b/models/unival/encoders/__pycache__/resnext3d.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9baaf0e03e712339a89a0a4c25da512b1d7d530b Binary files /dev/null and b/models/unival/encoders/__pycache__/resnext3d.cpython-37.pyc differ diff --git a/models/unival/encoders/__pycache__/resnext3d.cpython-39.pyc b/models/unival/encoders/__pycache__/resnext3d.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3afef805575b3ba7139c697dc8bbf48a9225e83 Binary files /dev/null and b/models/unival/encoders/__pycache__/resnext3d.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/s3d.cpython-39.pyc b/models/unival/encoders/__pycache__/s3d.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40ec226b64896220aa35c0304765c8cf219ea792 Binary files /dev/null and b/models/unival/encoders/__pycache__/s3d.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/simple_tokenizer.cpython-39.pyc b/models/unival/encoders/__pycache__/simple_tokenizer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bcb861ac1d6ac640fa6c751d1a75bc8dba3e9ce Binary files /dev/null and b/models/unival/encoders/__pycache__/simple_tokenizer.cpython-39.pyc differ diff --git a/models/unival/encoders/__pycache__/timm_resnet.cpython-37.pyc b/models/unival/encoders/__pycache__/timm_resnet.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec780f31c6c4a34ad7a7f9ce5d7016a8e05a36a6 Binary files /dev/null and b/models/unival/encoders/__pycache__/timm_resnet.cpython-37.pyc differ diff --git a/models/unival/encoders/__pycache__/timm_resnet.cpython-39.pyc b/models/unival/encoders/__pycache__/timm_resnet.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57e280d6c03bf4b229d3f0016a5498798658554d Binary files /dev/null and b/models/unival/encoders/__pycache__/timm_resnet.cpython-39.pyc differ diff --git a/models/unival/encoders/audio_utils.py b/models/unival/encoders/audio_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ad9801c0ac819473f738e2c1fbbdf711006ea440 --- /dev/null +++ b/models/unival/encoders/audio_utils.py @@ -0,0 +1,369 @@ +import numpy as np +import torch +from torch import nn as nn +from torchvision.ops.misc import FrozenBatchNorm2d +import logging +import h5py +from tqdm import tqdm +import random +import json +import os +import pathlib + +# TODO: (yusong) this not a good place to store those information and does not scale. Need to be fixed later. +dataset_split = { + "audiocaps": ["train", "valid", "test"], + "audioset": ["balanced_train", "unbalanced_train", "eval"], + "BBCSoundEffects": ["train", "test"], + "Clotho": ["train", "test", "valid"], + "free_to_use_sounds": ["train", "test"], + "paramount_motion": ["train", "test"], + "sonniss_game_effects": ["train", "test"], + "wesoundeffects": ["train", "test"], + "MACS": ["train", "test"], + "freesound": ["train", "test"], + "FSD50K": ["train", "test", "valid"], + "fsd50k_class_label": ["train", "test", "valid"], + "esc50": ["train", "test"], + "audiostock": ["train", "test"], + "freesound_no_overlap_noesc50": ["train", "test"], + "epidemic_sound_effects": ["train", "test"], + "VGGSound": ["train", "test"], + "urbansound8k_class_label": ["train", "test"], + "audioset_t5": ["balanced_train", "unbalanced_train", "eval"], + "epidemic_sound_effects_t5": ["train", "test"], + "WavText5K": ["train", "test"], + "esc50_no_overlap": ["train", "test"], + "usd8k_no_overlap": ["train", "test"], + "fsd50k_200_class_label": ["train", "test", "valid"] +} + + +def freeze_batch_norm_2d(module, module_match={}, name=""): + """ + Converts all `BatchNorm2d` and `SyncBatchNorm` layers of provided module into `FrozenBatchNorm2d`. If `module` is + itself an instance of either `BatchNorm2d` or `SyncBatchNorm`, it is converted into `FrozenBatchNorm2d` and + returned. Otherwise, the module is walked recursively and submodules are converted in place. + + Args: + module (torch.nn.Module): Any PyTorch module. + module_match (dict): Dictionary of full module names to freeze (all if empty) + name (str): Full module name (prefix) + + Returns: + torch.nn.Module: Resulting module + + Inspired by https://github.com/pytorch/pytorch/blob/a5895f85be0f10212791145bfedc0261d364f103/torch/nn/modules/batchnorm.py#L762 + """ + res = module + is_match = True + if module_match: + is_match = name in module_match + if is_match and isinstance( + module, (nn.modules.batchnorm.BatchNorm2d, nn.modules.batchnorm.SyncBatchNorm) + ): + res = FrozenBatchNorm2d(module.num_features) + res.num_features = module.num_features + res.affine = module.affine + if module.affine: + res.weight.data = module.weight.data.clone().detach() + res.bias.data = module.bias.data.clone().detach() + res.running_mean.data = module.running_mean.data + res.running_var.data = module.running_var.data + res.eps = module.eps + else: + for child_name, child in module.named_children(): + full_child_name = ".".join([name, child_name]) if name else child_name + new_child = freeze_batch_norm_2d(child, module_match, full_child_name) + if new_child is not child: + res.add_module(child_name, new_child) + return res + + +def exist(dataset_name, dataset_type): + """ + Check if dataset exists + """ + if dataset_type in dataset_split[dataset_name]: + return True + else: + return False + + +def get_tar_path_from_dataset_name( + dataset_names, + dataset_types, + islocal, + dataset_path, + proportion=1, + full_dataset=None +): + """ + Get tar path from dataset name and type + """ + output = [] + for n in dataset_names: + if full_dataset is not None and n in full_dataset: + current_dataset_types = dataset_split[n] + else: + current_dataset_types = dataset_types + for s in current_dataset_types: + tmp = [] + if islocal: + sizefilepath_ = f"{dataset_path}/{n}/{s}/sizes.json" + if not os.path.exists(sizefilepath_): + sizefilepath_ = f"./json_files/{n}/{s}/sizes.json" + else: + sizefilepath_ = f"./json_files/{n}/{s}/sizes.json" + if not os.path.exists(sizefilepath_): + continue + sizes = json.load(open(sizefilepath_, "r")) + for k in sizes.keys(): + if islocal: + tmp.append(f"{dataset_path}/{n}/{s}/{k}") + else: + tmp.append( + f"pipe:aws s3 --cli-connect-timeout 0 cp s3://s-laion-audio/webdataset_tar/{n}/{s}/{k} -" + ) + if proportion != 1: + tmp = random.sample(tmp, int(proportion * len(tmp))) + output.append(tmp) + return sum(output, []) + + +def get_tar_path_from_txts(txt_path, islocal, proportion=1): + """ + Get tar path from txt path + """ + if isinstance(txt_path, (list, tuple)): + return sum( + [ + get_tar_path_from_txts( + txt_path[i], islocal=islocal, proportion=proportion + ) + for i in range(len(txt_path)) + ], + [], + ) + if isinstance(txt_path, str): + with open(txt_path) as f: + lines = f.readlines() + if islocal: + lines = [ + lines[i] + .split("\n")[0] + .replace("pipe:aws s3 cp s3://s-laion-audio/", "/mnt/audio_clip/") + for i in range(len(lines)) + ] + else: + lines = [ + lines[i].split("\n")[0].replace(".tar", ".tar -") + for i in range(len(lines)) + ] + if proportion != 1: + print("Sampling tars with proportion of {}".format(proportion)) + lines = random.sample(lines, int(proportion * len(lines))) + return lines + + +def get_mix_lambda(mixup_alpha, batch_size): + mixup_lambdas = [ + np.random.beta(mixup_alpha, mixup_alpha, 1)[0] for _ in range(batch_size) + ] + return np.array(mixup_lambdas).astype(np.float32) + + +def do_mixup(x, mixup_lambda): + """ + Args: + x: (batch_size , ...) + mixup_lambda: (batch_size,) + Returns: + out: (batch_size, ...) + """ + out = ( + x.transpose(0, -1) * mixup_lambda + + torch.flip(x, dims=[0]).transpose(0, -1) * (1 - mixup_lambda) + ).transpose(0, -1) + return out + + +def interpolate(x, ratio): + """Interpolate data in time domain. This is used to compensate the + resolution reduction in downsampling of a CNN. + + Args: + x: (batch_size, time_steps, classes_num) + ratio: int, ratio to interpolate + Returns: + upsampled: (batch_size, time_steps * ratio, classes_num) + """ + (batch_size, time_steps, classes_num) = x.shape + upsampled = x[:, :, None, :].repeat(1, 1, ratio, 1) + upsampled = upsampled.reshape(batch_size, time_steps * ratio, classes_num) + return upsampled + + +def pad_framewise_output(framewise_output, frames_num): + """Pad framewise_output to the same length as input frames. The pad value + is the same as the value of the last frame. + Args: + framewise_output: (batch_size, frames_num, classes_num) + frames_num: int, number of frames to pad + Outputs: + output: (batch_size, frames_num, classes_num) + """ + pad = framewise_output[:, -1:, :].repeat( + 1, frames_num - framewise_output.shape[1], 1 + ) + """tensor for padding""" + + output = torch.cat((framewise_output, pad), dim=1) + """(batch_size, frames_num, classes_num)""" + + +def process_ipc(index_path, classes_num, filename): + # load data + logging.info("Load Data...............") + ipc = [[] for _ in range(classes_num)] + with h5py.File(index_path, "r") as f: + for i in tqdm(range(len(f["target"]))): + t_class = np.where(f["target"][i])[0] + for t in t_class: + ipc[t].append(i) + print(ipc) + np.save(filename, ipc) + logging.info("Load Data Succeed...............") + + +def save_to_dict(s, o_={}): + sp = s.split(": ") + o_.update({sp[0]: float(sp[1])}) + return o_ + + +def get_data_from_log(txt_path): + """ + Output dictionary from out.txt log file + """ + with open(txt_path) as f: + lines = f.readlines() + val_data = {} + train_data = {} + train_losses = [] + train_losses_epoch = [] + for i in range(len(lines)): + if "| INFO |" in lines[i]: + if "Eval Epoch" in lines[i]: + if "val_loss" in lines[i]: + # float(regex.sub("", lines[310].split(" ")[-1]).replace(" ", "")) + line = lines[i].split("Eval Epoch: ")[-1] + num_epoch = int(line.split(" ")[0].split(" ")[0]) + d = { + line.split(" ")[0] + .split(" ")[1] + .replace(":", ""): float(line.split(" ")[0].split(" ")[-1]) + } + for i in range(1, len(line.split(" "))): + d = save_to_dict(line.split(" ")[i], d) + val_data[num_epoch] = d + elif "Train Epoch" in lines[i]: + num_epoch = int(lines[i].split("Train Epoch: ")[1][0]) + loss = float(lines[i].split("Loss: ")[-1].split(" (")[0]) + train_losses.append(loss) + train_losses_epoch.append(num_epoch) + for i in range(len(train_losses)): + train_data[i] = { + "num_epoch": train_losses_epoch[i], + "train_loss": train_losses[i], + } + return train_data, val_data + + +def save_p(obj, filename): + import pickle + + try: + from deepdiff import DeepDiff + except: + os.system("pip install deepdiff") + from deepdiff import DeepDiff + with open(filename, "wb") as file: + pickle.dump(obj, file, protocol=pickle.HIGHEST_PROTOCOL) # highest protocol + with open(filename, "rb") as file: + z = pickle.load(file) + assert ( + DeepDiff(obj, z, ignore_string_case=True) == {} + ), "there is something wrong with the saving process" + return + + +def load_p(filename): + import pickle + + with open(filename, "rb") as file: + z = pickle.load(file) + return z + + +def save_json(data, name="data.json"): + import json + with open(name, 'w') as fp: + json.dump(data, fp) + return + + +def load_json(name): + import json + with open(name, 'r') as fp: + data = json.load(fp) + return data + + +from multiprocessing import Process, Manager +from multiprocessing import Process, Value, Array +from ctypes import c_wchar + + +def load_class_label(path): + # https://stackoverflow.com/questions/48004243/how-to-share-large-read-only-dictionary-list-across-processes-in-multiprocessing + # https://stackoverflow.com/questions/45693949/storing-strings-in-a-multiprocessing-sharedctypes-array + out = None + if path is not None: + if pathlib.Path(path).suffix in [".pkl", ".pickle"]: + out = load_p(path) + elif pathlib.Path(path).suffix in [".json", ".txt"]: + out = load_json(path) + elif pathlib.Path(path).suffix in [".npy", ".npz"]: + out = np.load(path) + elif pathlib.Path(path).suffix in [".csv"]: + import pandas as pd + out = pd.read_csv(path) + return out + # if out is None: + # return None + # else: + # key = Array(c_wchar, '\n'.join(list(out.keys())), lock=False) + # val = Array('i', out.values(), lock=False) + # return (key, val) + + +from torch import optim + + +def get_optimizer(params, lr, betas, eps, momentum, optimizer_name): + if optimizer_name.lower() == "adamw": + optimizer = optim.AdamW( + params, lr=lr, betas=betas, eps=eps + ) + elif optimizer_name.lower() == "sgd": + optimizer = optim.SGD( + params, lr=lr, momentum=momentum + ) + elif optimizer_name.lower() == "adam": + optimizer = optim.Adam( + params, lr=lr, betas=betas, eps=eps + ) + else: + raise ValueError("optimizer name is not correct") + return optimizer diff --git a/models/unival/encoders/feature_fusion.py b/models/unival/encoders/feature_fusion.py new file mode 100644 index 0000000000000000000000000000000000000000..c2419516b76931f0aa801d78e1b5f04a92a909e6 --- /dev/null +++ b/models/unival/encoders/feature_fusion.py @@ -0,0 +1,193 @@ +''' +Feature Fusion for Varible-Length Data Processing +AFF/iAFF is referred and modified from https://github.com/YimianDai/open-aff/blob/master/aff_pytorch/aff_net/fusion.py +According to the paper: Yimian Dai et al, Attentional Feature Fusion, IEEE Winter Conference on Applications of Computer Vision, WACV 2021 +''' + +import torch +import torch.nn as nn + + +class DAF(nn.Module): + ''' + 直接相加 DirectAddFuse + ''' + + def __init__(self): + super(DAF, self).__init__() + + def forward(self, x, residual): + return x + residual + + +class iAFF(nn.Module): + ''' + 多特征融合 iAFF + ''' + + def __init__(self, channels=64, r=4, type='2D'): + super(iAFF, self).__init__() + inter_channels = int(channels // r) + + if type == '1D': + # 本地注意力 + self.local_att = nn.Sequential( + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + + # 全局注意力 + self.global_att = nn.Sequential( + nn.AdaptiveAvgPool1d(1), + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + + # 第二次本地注意力 + self.local_att2 = nn.Sequential( + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + # 第二次全局注意力 + self.global_att2 = nn.Sequential( + nn.AdaptiveAvgPool1d(1), + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + elif type == '2D': + # 本地注意力 + self.local_att = nn.Sequential( + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + + # 全局注意力 + self.global_att = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + + # 第二次本地注意力 + self.local_att2 = nn.Sequential( + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + # 第二次全局注意力 + self.global_att2 = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + else: + raise f'the type is not supported' + + self.sigmoid = nn.Sigmoid() + + def forward(self, x, residual): + flag = False + xa = x + residual + if xa.size(0) == 1: + xa = torch.cat([xa,xa],dim=0) + flag = True + xl = self.local_att(xa) + xg = self.global_att(xa) + xlg = xl + xg + wei = self.sigmoid(xlg) + xi = x * wei + residual * (1 - wei) + + xl2 = self.local_att2(xi) + xg2 = self.global_att(xi) + xlg2 = xl2 + xg2 + wei2 = self.sigmoid(xlg2) + xo = x * wei2 + residual * (1 - wei2) + if flag: + xo = xo[0].unsqueeze(0) + return xo + + +class AFF(nn.Module): + ''' + 多特征融合 AFF + ''' + + def __init__(self, channels=64, r=4, type='2D'): + super(AFF, self).__init__() + inter_channels = int(channels // r) + + if type == '1D': + self.local_att = nn.Sequential( + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + self.global_att = nn.Sequential( + nn.AdaptiveAvgPool1d(1), + nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm1d(channels), + ) + elif type == '2D': + self.local_att = nn.Sequential( + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + self.global_att = nn.Sequential( + nn.AdaptiveAvgPool2d(1), + nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(inter_channels), + nn.ReLU(inplace=True), + nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0), + nn.BatchNorm2d(channels), + ) + else: + raise f'the type is not supported.' + + self.sigmoid = nn.Sigmoid() + + def forward(self, x, residual): + flag = False + xa = x + residual + if xa.size(0) == 1: + xa = torch.cat([xa,xa],dim=0) + flag = True + xl = self.local_att(xa) + xg = self.global_att(xa) + xlg = xl + xg + wei = self.sigmoid(xlg) + xo = 2 * x * wei + 2 * residual * (1 - wei) + if flag: + xo = xo[0].unsqueeze(0) + return xo + diff --git a/models/unival/encoders/pann.py b/models/unival/encoders/pann.py new file mode 100644 index 0000000000000000000000000000000000000000..02d92b18939981bd899b92dcf9574c09bd6a0772 --- /dev/null +++ b/models/unival/encoders/pann.py @@ -0,0 +1,565 @@ +# PANNs: Large-Scale Pretrained Audio Neural Networks for Audio Pattern Recognition +# Reference from https://github.com/qiuqiangkong/audioset_tagging_cnn +# Some layers are re-designed for CLAP +import os +os.environ['NUMBA_CACHE_DIR'] = '/tmp/' + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchlibrosa.stft import Spectrogram, LogmelFilterBank +from torchlibrosa.augmentation import SpecAugmentation + +from .audio_utils import do_mixup, interpolate, pad_framewise_output +from .feature_fusion import iAFF, AFF, DAF + + +def init_layer(layer): + """Initialize a Linear or Convolutional layer. """ + nn.init.xavier_uniform_(layer.weight) + + if hasattr(layer, 'bias'): + if layer.bias is not None: + layer.bias.data.fill_(0.) + + +def init_bn(bn): + """Initialize a Batchnorm layer. """ + bn.bias.data.fill_(0.) + bn.weight.data.fill_(1.) + + +class ConvBlock(nn.Module): + def __init__(self, in_channels, out_channels): + + super(ConvBlock, self).__init__() + + self.conv1 = nn.Conv2d(in_channels=in_channels, + out_channels=out_channels, + kernel_size=(3, 3), stride=(1, 1), + padding=(1, 1), bias=False) + + self.conv2 = nn.Conv2d(in_channels=out_channels, + out_channels=out_channels, + kernel_size=(3, 3), stride=(1, 1), + padding=(1, 1), bias=False) + + self.bn1 = nn.BatchNorm2d(out_channels) + self.bn2 = nn.BatchNorm2d(out_channels) + + self.init_weight() + + def init_weight(self): + init_layer(self.conv1) + init_layer(self.conv2) + init_bn(self.bn1) + init_bn(self.bn2) + + + def forward(self, input, pool_size=(2, 2), pool_type='avg'): + + x = input + x = F.relu_(self.bn1(self.conv1(x))) + x = F.relu_(self.bn2(self.conv2(x))) + if pool_type == 'max': + x = F.max_pool2d(x, kernel_size=pool_size) + elif pool_type == 'avg': + x = F.avg_pool2d(x, kernel_size=pool_size) + elif pool_type == 'avg+max': + x1 = F.avg_pool2d(x, kernel_size=pool_size) + x2 = F.max_pool2d(x, kernel_size=pool_size) + x = x1 + x2 + else: + raise Exception('Incorrect argument!') + + return x + + +class ConvBlock5x5(nn.Module): + def __init__(self, in_channels, out_channels): + + super(ConvBlock5x5, self).__init__() + + self.conv1 = nn.Conv2d(in_channels=in_channels, + out_channels=out_channels, + kernel_size=(5, 5), stride=(1, 1), + padding=(2, 2), bias=False) + + self.bn1 = nn.BatchNorm2d(out_channels) + + self.init_weight() + + def init_weight(self): + init_layer(self.conv1) + init_bn(self.bn1) + + + def forward(self, input, pool_size=(2, 2), pool_type='avg'): + + x = input + x = F.relu_(self.bn1(self.conv1(x))) + if pool_type == 'max': + x = F.max_pool2d(x, kernel_size=pool_size) + elif pool_type == 'avg': + x = F.avg_pool2d(x, kernel_size=pool_size) + elif pool_type == 'avg+max': + x1 = F.avg_pool2d(x, kernel_size=pool_size) + x2 = F.max_pool2d(x, kernel_size=pool_size) + x = x1 + x2 + else: + raise Exception('Incorrect argument!') + + return x + + +class AttBlock(nn.Module): + def __init__(self, n_in, n_out, activation='linear', temperature=1.): + super(AttBlock, self).__init__() + + self.activation = activation + self.temperature = temperature + self.att = nn.Conv1d(in_channels=n_in, out_channels=n_out, kernel_size=1, stride=1, padding=0, bias=True) + self.cla = nn.Conv1d(in_channels=n_in, out_channels=n_out, kernel_size=1, stride=1, padding=0, bias=True) + + self.bn_att = nn.BatchNorm1d(n_out) + self.init_weights() + + def init_weights(self): + init_layer(self.att) + init_layer(self.cla) + init_bn(self.bn_att) + + def forward(self, x): + # x: (n_samples, n_in, n_time) + norm_att = torch.softmax(torch.clamp(self.att(x), -10, 10), dim=-1) + cla = self.nonlinear_transform(self.cla(x)) + x = torch.sum(norm_att * cla, dim=2) + return x, norm_att, cla + + def nonlinear_transform(self, x): + if self.activation == 'linear': + return x + elif self.activation == 'sigmoid': + return torch.sigmoid(x) + + +class Cnn14(nn.Module): + def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, + fmax, classes_num, enable_fusion=False, fusion_type='None'): + + super(Cnn14, self).__init__() + + window = 'hann' + center = True + pad_mode = 'reflect' + ref = 1.0 + amin = 1e-10 + top_db = None + + self.enable_fusion = enable_fusion + self.fusion_type = fusion_type + + if mel_bins != 64: + freeze_parameters = False + else: + freeze_parameters = True + + # Spectrogram extractor + self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, + win_length=window_size, window=window, center=center, pad_mode=pad_mode, + freeze_parameters=freeze_parameters) + + # Logmel feature extractor + self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, + n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, + freeze_parameters=freeze_parameters) + + # Spec augmenter + self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, + freq_drop_width=8, freq_stripes_num=2) + + self.bn0 = nn.BatchNorm2d(mel_bins) + + if (self.enable_fusion) and (self.fusion_type == 'channel_map'): + self.conv_block1 = ConvBlock(in_channels=4, out_channels=64) + else: + self.conv_block1 = ConvBlock(in_channels=1, out_channels=64) + self.conv_block2 = ConvBlock(in_channels=64, out_channels=128) + self.conv_block3 = ConvBlock(in_channels=128, out_channels=256) + self.conv_block4 = ConvBlock(in_channels=256, out_channels=512) + self.conv_block5 = ConvBlock(in_channels=512, out_channels=1024) + self.conv_block6 = ConvBlock(in_channels=1024, out_channels=2048) + + # self.fc1 = nn.Linear(2048, 2048, bias=True) + # self.fc_audioset = nn.Linear(2048, classes_num, bias=True) + + if (self.enable_fusion) and (self.fusion_type in ['daf_1d','aff_1d','iaff_1d']): + self.mel_conv1d = nn.Sequential( + nn.Conv1d(64, 64, kernel_size=5, stride=3, padding=2), + nn.BatchNorm1d(64) # No Relu + ) + if self.fusion_type == 'daf_1d': + self.fusion_model = DAF() + elif self.fusion_type == 'aff_1d': + self.fusion_model = AFF(channels=64, type='1D') + elif self.fusion_type == 'iaff_1d': + self.fusion_model = iAFF(channels=64, type='1D') + + if (self.enable_fusion) and (self.fusion_type in ['daf_2d','aff_2d','iaff_2d']): + self.mel_conv2d = nn.Sequential( + nn.Conv2d(1, 64, kernel_size=(5,5), stride=(6, 2), padding=(2,2)), + nn.BatchNorm2d(64), + nn.ReLU(inplace=True) + ) + + if self.fusion_type == 'daf_2d': + self.fusion_model = DAF() + elif self.fusion_type == 'aff_2d': + self.fusion_model = AFF(channels=64, type='2D') + elif self.fusion_type == 'iaff_2d': + self.fusion_model = iAFF(channels=64, type='2D') + self.init_weight() + + def init_weight(self): + init_bn(self.bn0) + # init_layer(self.fc1) + # init_layer(self.fc_audioset) + + def forward(self, input, mixup_lambda=None, device=None): + """ + Input: (batch_size, data_length)""" + + if self.enable_fusion and input["longer"].sum() == 0: + # if no audio is longer than 10s, then randomly select one audio to be longer + input["longer"][torch.randint(0, input["longer"].shape[0], (1,))] = True + # input = input.float() + if not self.enable_fusion: + # self.spectrogram_extractor.float() + # self.spectrogram_extractor.stft.float() + spectype = self.spectrogram_extractor.stft.conv_real.weight.data.dtype + # print(spectype, input.dtype) + x_ = self.spectrogram_extractor(input.to(spectype).to(device=device, non_blocking=True)) # (batch_size, 1, time_steps, freq_bins) + # x = x.float() + # self.logmel_extractor.float() + # print(x_.dtype) + # print(self.logmel_extractor.melW) + # self.logmel_extractor shoulf stay in float32 + x = self.logmel_extractor(x_.to(self.logmel_extractor.melW.dtype)).to(input.dtype) # (batch_size, 1, time_steps, mel_bins) + # x = input.to(device=device, non_blocking=True) + + x = x.transpose(1, 3) + x = self.bn0(x) + x = x.transpose(1, 3) + + else: + longer_list = input["longer"].to(device=device, non_blocking=True) + x = input["mel_fusion"].to(device=device, non_blocking=True) + longer_list_idx = torch.where(longer_list)[0] + x = x.transpose(1, 3) + x = self.bn0(x) + x = x.transpose(1, 3) + if self.fusion_type in ['daf_1d','aff_1d','iaff_1d']: + new_x = x[:,0:1,:,:].clone().contiguous() + # local processing + if len(longer_list_idx) > 0: + fusion_x_local = x[longer_list_idx,1:,:,:].clone().contiguous() + FB,FC,FT,FF = fusion_x_local.size() + fusion_x_local = fusion_x_local.view(FB * FC, FT, FF) + fusion_x_local = torch.permute(fusion_x_local, (0,2,1)).contiguous() + fusion_x_local = self.mel_conv1d(fusion_x_local) + fusion_x_local = fusion_x_local.view(FB,FC,FF,fusion_x_local.size(-1)) + fusion_x_local = torch.permute(fusion_x_local, (0,2,1,3)).contiguous().flatten(2) + if fusion_x_local.size(-1) < FT: + fusion_x_local = torch.cat([fusion_x_local, torch.zeros((FB,FF,FT- fusion_x_local.size(-1)), device=device)], dim=-1) + else: + fusion_x_local = fusion_x_local[:,:,:FT] + # 1D fusion + new_x = new_x.squeeze(1).permute((0,2,1)).contiguous() + new_x[longer_list_idx] = self.fusion_model(new_x[longer_list_idx], fusion_x_local) + x = new_x.permute((0,2,1)).contiguous()[:,None,:,:] + else: + x = new_x + elif self.fusion_type in ['daf_2d','aff_2d','iaff_2d','channel_map']: + x = x # no change + + if self.training: + x = self.spec_augmenter(x) + # Mixup on spectrogram + if self.training and mixup_lambda is not None: + x = do_mixup(x, mixup_lambda) + if (self.enable_fusion) and (self.fusion_type in ['daf_2d','aff_2d','iaff_2d']): + global_x = x[:,0:1,:,:] + + # global processing + B, C, H, W = global_x.shape + global_x = self.conv_block1(global_x, pool_size=(2, 2), pool_type='avg') + if len(longer_list_idx) > 0: + local_x = x[longer_list_idx,1:,:,:].contiguous() + TH = global_x.size(-2) + # local processing + B, C, H, W = local_x.shape + local_x = local_x.view(B*C,1,H,W) + local_x = self.mel_conv2d(local_x) + local_x = local_x.view(B,C,local_x.size(1),local_x.size(2),local_x.size(3)) + local_x = local_x.permute((0,2,1,3,4)).contiguous().flatten(2,3) + TB,TC,_,TW = local_x.size() + if local_x.size(-2) < TH: + local_x = torch.cat([local_x, torch.zeros((TB,TC,TH-local_x.size(-2),TW), device=global_x.device)], dim=-2) + else: + local_x = local_x[:,:,:TH,:] + + global_x[longer_list_idx] = self.fusion_model(global_x[longer_list_idx],local_x) + x = global_x + else: + x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg') + + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block5(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block6(x, pool_size=(1, 1), pool_type='avg') + # x = F.dropout(x, p=0.2, training=self.training) + # x = torch.mean(x, dim=3) + + # latent_x1 = F.max_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x2 = F.avg_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x = latent_x1 + latent_x2 + # latent_x = latent_x.transpose(1, 2) + # latent_x = F.relu_(self.fc1(latent_x)) + # latent_output = interpolate(latent_x, 32) + + + # (x1, _) = torch.max(x, dim=2) + # x2 = torch.mean(x, dim=2) + # x = x1 + x2 + # x = F.dropout(x, p=0.5, training=self.training) + # x = F.relu_(self.fc1(x)) + # embedding = F.dropout(x, p=0.5, training=self.training) + # clipwise_output = torch.sigmoid(self.fc_audioset(x)) + + # output_dict = {'clipwise_output': clipwise_output, 'embedding': embedding, 'fine_grained_embedding': latent_output} + + return x + + +class Cnn6(nn.Module): + def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, + fmax, classes_num, enable_fusion=False, fusion_type='None'): + + super(Cnn6, self).__init__() + + window = 'hann' + center = True + pad_mode = 'reflect' + ref = 1.0 + amin = 1e-10 + top_db = None + + self.enable_fusion = enable_fusion + self.fusion_type = fusion_type + + if mel_bins != 64: + freeze_parameters = False + else: + freeze_parameters = True + # Spectrogram extractor + self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, + win_length=window_size, window=window, center=center, pad_mode=pad_mode, + freeze_parameters=freeze_parameters) + + # Logmel feature extractor + self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, + n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, + freeze_parameters=freeze_parameters) + + # Spec augmenter + self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, + freq_drop_width=8, freq_stripes_num=2) + + self.bn0 = nn.BatchNorm2d(64) + + self.conv_block1 = ConvBlock5x5(in_channels=1, out_channels=64) + self.conv_block2 = ConvBlock5x5(in_channels=64, out_channels=128) + self.conv_block3 = ConvBlock5x5(in_channels=128, out_channels=256) + self.conv_block4 = ConvBlock5x5(in_channels=256, out_channels=512) + + self.fc1 = nn.Linear(512, 512, bias=True) + self.fc_audioset = nn.Linear(512, classes_num, bias=True) + + self.init_weight() + + def init_weight(self): + init_bn(self.bn0) + init_layer(self.fc1) + init_layer(self.fc_audioset) + + def forward(self, input, mixup_lambda=None, device=None): + """ + Input: (batch_size, data_length)""" + + x = self.spectrogram_extractor(input) # (batch_size, 1, time_steps, freq_bins) + x = self.logmel_extractor(x) # (batch_size, 1, time_steps, mel_bins) + + x = x.transpose(1, 3) + x = self.bn0(x) + x = x.transpose(1, 3) + + if self.training: + x = self.spec_augmenter(x) + + # Mixup on spectrogram + if self.training and mixup_lambda is not None: + x = do_mixup(x, mixup_lambda) + + x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg') + # x = F.dropout(x, p=0.2, training=self.training) + # x = torch.mean(x, dim=3) + + # latent_x1 = F.max_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x2 = F.avg_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x = latent_x1 + latent_x2 + # latent_x = latent_x.transpose(1, 2) + # latent_x = F.relu_(self.fc1(latent_x)) + # latent_output = interpolate(latent_x, 16) + + # (x1, _) = torch.max(x, dim=2) + # x2 = torch.mean(x, dim=2) + # x = x1 + x2 + # x = F.dropout(x, p=0.5, training=self.training) + # x = F.relu_(self.fc1(x)) + # embedding = F.dropout(x, p=0.5, training=self.training) + # clipwise_output = torch.sigmoid(self.fc_audioset(x)) + + # output_dict = {'clipwise_output': clipwise_output, 'embedding': embedding, 'fine_grained_embedding': latent_output} + + return x + + +class Cnn10(nn.Module): + def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, + fmax, classes_num, enable_fusion=False, fusion_type='None'): + + super(Cnn10, self).__init__() + + window = 'hann' + center = True + pad_mode = 'reflect' + ref = 1.0 + amin = 1e-10 + top_db = None + + self.enable_fusion = enable_fusion + self.fusion_type = fusion_type + + # Spectrogram extractor + self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, + win_length=window_size, window=window, center=center, pad_mode=pad_mode, + freeze_parameters=True) + + # Logmel feature extractor + self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, + n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, + freeze_parameters=True) + + # Spec augmenter + self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, + freq_drop_width=8, freq_stripes_num=2) + + self.bn0 = nn.BatchNorm2d(mel_bins) + + self.conv_block1 = ConvBlock(in_channels=1, out_channels=64) + self.conv_block2 = ConvBlock(in_channels=64, out_channels=128) + self.conv_block3 = ConvBlock(in_channels=128, out_channels=256) + self.conv_block4 = ConvBlock(in_channels=256, out_channels=512) + self.conv_block5 = ConvBlock(in_channels=512, out_channels=1024) + + # self.fc1 = nn.Linear(1024, 1024, bias=True) + # self.fc_audioset = nn.Linear(1024, classes_num, bias=True) + + self.init_weight() + print(self.logmel_extractor) + + def init_weight(self): + init_bn(self.bn0) + # init_layer(self.fc1) + # init_layer(self.fc_audioset) + + def forward(self, input, mixup_lambda=None, device=None): + """ + Input: (batch_size, data_length)""" + + x = self.spectrogram_extractor(input) # (batch_size, 1, time_steps, freq_bins) + x = self.logmel_extractor(x) # (batch_size, 1, time_steps, mel_bins) + + x = x.transpose(1, 3) + x = self.bn0(x) + x = x.transpose(1, 3) + + if self.training: + x = self.spec_augmenter(x) + + # Mixup on spectrogram + if self.training and mixup_lambda is not None: + x = do_mixup(x, mixup_lambda) + + x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg') + x = F.dropout(x, p=0.2, training=self.training) + x = self.conv_block5(x, pool_size=(2, 2), pool_type='avg') + # x = F.dropout(x, p=0.2, training=self.training) ## cut here for ofa + # x = torch.mean(x, dim=3) + + # latent_x1 = F.max_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x2 = F.avg_pool1d(x, kernel_size=3, stride=1, padding=1) + # latent_x = latent_x1 + latent_x2 + # latent_x = latent_x.transpose(1, 2) + # latent_x = F.relu_(self.fc1(latent_x)) + # latent_output = interpolate(latent_x, 32) + + # (x1, _) = torch.max(x, dim=2) + # x2 = torch.mean(x, dim=2) + # x = x1 + x2 + # x = F.dropout(x, p=0.5, training=self.training) + # x = F.relu_(self.fc1(x)) + # embedding = F.dropout(x, p=0.5, training=self.training) + # clipwise_output = torch.sigmoid(self.fc_audioset(x)) + + # output_dict = {'clipwise_output': clipwise_output, 'embedding': embedding, 'fine_grained_embedding': latent_output} + + return x + + +def create_pann_model(audio_cfg, enable_fusion=False, fusion_type='None'): + try: + ModelProto = eval(audio_cfg.model_name) + model = ModelProto( + sample_rate = audio_cfg.sample_rate, + window_size = audio_cfg.window_size, + hop_size =audio_cfg.hop_size, + mel_bins = audio_cfg.mel_bins, + fmin = audio_cfg.fmin, + fmax = audio_cfg.fmax, + classes_num = audio_cfg.class_num, + enable_fusion = enable_fusion, + fusion_type = fusion_type + ) + return model + except: + raise RuntimeError(f'Import Model for {audio_cfg.model_name} not found, or the audio cfg parameters are not enough.') + diff --git a/models/unival/encoders/resnext3d.py b/models/unival/encoders/resnext3d.py new file mode 100644 index 0000000000000000000000000000000000000000..a4d47542626c6368a6acd1a229805ef1514601a6 --- /dev/null +++ b/models/unival/encoders/resnext3d.py @@ -0,0 +1,187 @@ +# https://github.com/kenshohara/video-classification-3d-cnn-pytorch +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.autograd import Variable +import math +from functools import partial + +__all__ = ['ResNeXt', 'resnet50', 'resnet101'] + + +def conv3x3x3(in_planes, out_planes, stride=1): + # 3x3x3 convolution with padding + return nn.Conv3d(in_planes, out_planes, kernel_size=3, + stride=stride, padding=1, bias=False) + + +def downsample_basic_block(x, planes, stride): + out = F.avg_pool3d(x, kernel_size=1, stride=stride) + zero_pads = torch.Tensor(out.size(0), planes - out.size(1), + out.size(2), out.size(3), + out.size(4)).zero_() + if isinstance(out.data, torch.cuda.FloatTensor): + zero_pads = zero_pads.cuda() + + out = Variable(torch.cat([out.data, zero_pads], dim=1)) + + return out + + +class ResNeXtBottleneck(nn.Module): + expansion = 2 + + def __init__(self, inplanes, planes, cardinality, stride=1, downsample=None, norm_layer=nn.BatchNorm3d): + super(ResNeXtBottleneck, self).__init__() + mid_planes = cardinality * int(planes / 32) + self.conv1 = nn.Conv3d(inplanes, mid_planes, kernel_size=1, bias=False) + self.bn1 = norm_layer(mid_planes) + self.conv2 = nn.Conv3d(mid_planes, mid_planes, kernel_size=3, stride=stride, + padding=1, groups=cardinality, bias=False) + self.bn2 = norm_layer(mid_planes) + self.conv3 = nn.Conv3d(mid_planes, planes * self.expansion, kernel_size=1, bias=False) + self.bn3 = norm_layer(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class ResNeXt3D(nn.Module): + + def __init__(self, block, layers, sample_size=16, sample_duration=112, shortcut_type='B', cardinality=32, num_classes=400, last_fc=True, norm_layer=None): + self.last_fc = last_fc + + self.inplanes = 64 + super(ResNeXt3D, self).__init__() + self.conv1 = nn.Conv3d(3, 64, kernel_size=7, stride=(1, 2, 2), + padding=(3, 3, 3), bias=False) + + if norm_layer is None: + norm_layer = nn.BatchNorm3d + + print("use bn:", norm_layer) + self.bn1 = norm_layer(64) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) + self.layer1 = self._make_layer(block, 128, layers[0], shortcut_type, cardinality, norm_layer=norm_layer) + self.layer2 = self._make_layer(block, 256, layers[1], shortcut_type, cardinality, stride=2, norm_layer=norm_layer) + self.layer3 = self._make_layer(block, 512, layers[2], shortcut_type, cardinality, stride=2, norm_layer=norm_layer) + if len(layers) > 3: + self.layer4 = self._make_layer(block, 1024, layers[3], shortcut_type, cardinality, stride=2, norm_layer=norm_layer) + self.all_layers = True + else: + self.all_layers = False + last_duration = math.ceil(sample_duration / 16) + last_size = math.ceil(sample_size / 32) + self.avgpool = nn.AvgPool3d((last_duration, last_size, last_size), stride=1) + # self.fc = nn.Linear(cardinality * 32 * block.expansion, num_classes) + + for m in self.modules(): + if isinstance(m, nn.Conv3d): + n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels + m.weight.data.normal_(0, math.sqrt(2. / n)) + elif isinstance(m, norm_layer): + m.weight.data.fill_(1) + m.bias.data.zero_() + + def _make_layer(self, block, planes, blocks, shortcut_type, cardinality, stride=1, norm_layer=nn.BatchNorm3d): + downsample = None + if stride != 1 or self.inplanes != planes * block.expansion: + if shortcut_type == 'A': + downsample = partial(downsample_basic_block, + planes=planes * block.expansion, + stride=stride) + else: + downsample = nn.Sequential( + nn.Conv3d(self.inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + norm_layer(planes * block.expansion) + ) + + layers = [] + layers.append(block(self.inplanes, planes, cardinality, stride, downsample, norm_layer=norm_layer)) + self.inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, cardinality, norm_layer=norm_layer)) + + return nn.Sequential(*layers) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + if self.all_layers: + x = self.layer4(x) + + # x = self.avgpool(x) + + # x = x.view(x.size(0), -1) + # if self.last_fc: + # x = self.fc(x) + + return x, x + +def get_fine_tuning_parameters(model, ft_begin_index): + if ft_begin_index == 0: + return model.parameters() + + ft_module_names = [] + for i in range(ft_begin_index, 5): + ft_module_names.append('layer{}'.format(ft_begin_index)) + ft_module_names.append('fc') + + parameters = [] + for k, v in model.named_parameters(): + for ft_module in ft_module_names: + if ft_module in k: + parameters.append({'params': v}) + break + else: + parameters.append({'params': v, 'lr': 0.0}) + + return parameters + +def resnet50(**kwargs): + """Constructs a ResNet-50 model. + """ + model = ResNeXt3D(ResNeXtBottleneck, [3, 4, 6, 3], **kwargs) + return model + +def resnet101(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNeXt3D(ResNeXtBottleneck, [3, 4, 23, 3], **kwargs) + return model + +def resnet152(**kwargs): + """Constructs a ResNet-101 model. + """ + model = ResNeXt3D(ResNeXtBottleneck, [3, 8, 36, 3], **kwargs) + return model diff --git a/models/unival/encoders/simple_tokenizer.py b/models/unival/encoders/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..c617590ed5cdfa10c375ff3ae1a619614017526d --- /dev/null +++ b/models/unival/encoders/simple_tokenizer.py @@ -0,0 +1,133 @@ +# from openai clip +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'</w>' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '</w>',) + pairs = get_pairs(word) + + if not pairs: + return token+'</w>' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ') + return text diff --git a/models/unival/encoders/timm_resnet.py b/models/unival/encoders/timm_resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..192a20e3eda5aa925e77faa20c5a395c1d91f7eb --- /dev/null +++ b/models/unival/encoders/timm_resnet.py @@ -0,0 +1,1717 @@ +"""PyTorch ResNet + +This started as a copy of https://github.com/pytorch/vision 'resnet.py' (BSD-3-Clause) with +additional dropout and dynamic global avg/max pool. + +ResNeXt, SE-ResNeXt, SENet, and MXNet Gluon stem/downsample variants, tiered stems added by Ross Wightman + +Copyright 2019, Ross Wightman +""" +import math +from functools import partial + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD +from timm.models.layers import DropBlock2d, DropPath, AvgPool2dSame, BlurPool2d, GroupNorm, create_attn, get_attn, \ + get_act_layer, get_norm_layer, create_classifier +from timm.models.helpers import build_model_with_cfg +from timm.models.helpers import checkpoint_seq +from timm.models import register_model, model_entrypoint + +__all__ = ['ResNet', 'BasicBlock', 'Bottleneck'] # model_registry will add each entrypoint fn to this + + +def _cfg(url='', **kwargs): + return { + 'url': url, + 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': (7, 7), + 'crop_pct': 0.875, 'interpolation': 'bilinear', + 'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD, + 'first_conv': 'conv1', 'classifier': 'fc', + **kwargs + } + + +default_cfgs = { + # ResNet and Wide ResNet + 'resnet10t': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet10t_176_c3-f3215ab1.pth', + input_size=(3, 176, 176), pool_size=(6, 6), + test_crop_pct=0.95, test_input_size=(3, 224, 224), + first_conv='conv1.0'), + 'resnet14t': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet14t_176_c3-c4ed2c37.pth', + input_size=(3, 176, 176), pool_size=(6, 6), + test_crop_pct=0.95, test_input_size=(3, 224, 224), + first_conv='conv1.0'), + 'resnet18': _cfg(url='https://download.pytorch.org/models/resnet18-5c106cde.pth'), + 'resnet18d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet18d_ra2-48a79e06.pth', + interpolation='bicubic', first_conv='conv1.0'), + 'resnet34': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet34-43635321.pth'), + 'resnet34d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet34d_ra2-f8dcfcaf.pth', + interpolation='bicubic', first_conv='conv1.0'), + 'resnet26': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet26-9aa10e23.pth', + interpolation='bicubic'), + 'resnet26d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet26d-69e92c46.pth', + interpolation='bicubic', first_conv='conv1.0'), + 'resnet26t': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-attn-weights/resnet26t_256_ra2-6f6fa748.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), crop_pct=0.94), + 'resnet50': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet50_a1_0-14fe96d1.pth', + interpolation='bicubic', crop_pct=0.95), + 'resnet50d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet50d_ra2-464e36ba.pth', + interpolation='bicubic', first_conv='conv1.0'), + 'resnet50t': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'resnet101': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet101_a1h-36d3f2aa.pth', + interpolation='bicubic', crop_pct=0.95), + 'resnet101d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet101d_ra2-2803ffab.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=1.0, test_input_size=(3, 320, 320)), + 'resnet152': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet152_a1h-dc400468.pth', + interpolation='bicubic', crop_pct=0.95), + 'resnet152d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet152d_ra2-5cac0439.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=1.0, test_input_size=(3, 320, 320)), + 'resnet200': _cfg(url='', interpolation='bicubic'), + 'resnet200d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet200d_ra2-bdba9bf9.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=1.0, test_input_size=(3, 320, 320)), + 'tv_resnet34': _cfg(url='https://download.pytorch.org/models/resnet34-333f7ec4.pth'), + 'tv_resnet50': _cfg(url='https://download.pytorch.org/models/resnet50-19c8e357.pth'), + 'tv_resnet101': _cfg(url='https://download.pytorch.org/models/resnet101-5d3b4d8f.pth'), + 'tv_resnet152': _cfg(url='https://download.pytorch.org/models/resnet152-b121ed2d.pth'), + 'wide_resnet50_2': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/wide_resnet50_racm-8234f177.pth', + interpolation='bicubic'), + 'wide_resnet101_2': _cfg(url='https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth'), + + # ResNets w/ alternative norm layers + 'resnet50_gn': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet50_gn_a1h2-8fe6c4d0.pth', + crop_pct=0.94, interpolation='bicubic'), + + # ResNeXt + 'resnext50_32x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnext50_32x4d_a1h-0146ab0a.pth', + interpolation='bicubic', crop_pct=0.95), + 'resnext50d_32x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnext50d_32x4d-103e99f8.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'resnext101_32x4d': _cfg(url=''), + 'resnext101_32x8d': _cfg(url='https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth'), + 'resnext101_64x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tpu-weights/resnext101_64x4d_c-0d0e0cc0.pth', + interpolation='bicubic', crop_pct=1.0, test_input_size=(3, 288, 288)), + 'tv_resnext50_32x4d': _cfg(url='https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth'), + + # ResNeXt models - Weakly Supervised Pretraining on Instagram Hashtags + # from https://github.com/facebookresearch/WSL-Images + # Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only. + 'ig_resnext101_32x8d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x8-c38310e5.pth'), + 'ig_resnext101_32x16d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x16-c6f796b0.pth'), + 'ig_resnext101_32x32d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x32-e4b90b00.pth'), + 'ig_resnext101_32x48d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x48-3e41cc8a.pth'), + + # Semi-Supervised ResNe*t models from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models + # Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only. + 'ssl_resnet18': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnet18-d92f0530.pth'), + 'ssl_resnet50': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnet50-08389792.pth'), + 'ssl_resnext50_32x4d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext50_32x4-ddb3e555.pth'), + 'ssl_resnext101_32x4d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x4-dc43570a.pth'), + 'ssl_resnext101_32x8d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x8-2cfe2f8b.pth'), + 'ssl_resnext101_32x16d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x16-15fffa57.pth'), + + # Semi-Weakly Supervised ResNe*t models from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models + # Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only. + 'swsl_resnet18': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet18-118f1556.pth'), + 'swsl_resnet50': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet50-16a12f1b.pth'), + 'swsl_resnext50_32x4d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext50_32x4-72679e44.pth'), + 'swsl_resnext101_32x4d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x4-3f87e46b.pth'), + 'swsl_resnext101_32x8d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x8-b4712904.pth'), + 'swsl_resnext101_32x16d': _cfg( + url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x16-f3559a9c.pth'), + + # Efficient Channel Attention ResNets + 'ecaresnet26t': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/ecaresnet26t_ra2-46609757.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=0.95, test_input_size=(3, 320, 320)), + 'ecaresnetlight': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tresnet/ecaresnetlight-75a9c627.pth', + interpolation='bicubic'), + 'ecaresnet50d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tresnet/ecaresnet50d-93c81e3b.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'ecaresnet50d_pruned': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tresnet/ecaresnet50d_p-e4fa23c2.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'ecaresnet50t': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/ecaresnet50t_ra2-f7ac63c4.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=0.95, test_input_size=(3, 320, 320)), + 'ecaresnet101d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tresnet/ecaresnet101d-153dad65.pth', + interpolation='bicubic', first_conv='conv1.0'), + 'ecaresnet101d_pruned': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tresnet/ecaresnet101d_p-9e74cb91.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'ecaresnet200d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), crop_pct=0.94, pool_size=(8, 8)), + 'ecaresnet269d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/ecaresnet269d_320_ra2-7baa55cb.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 320, 320), pool_size=(10, 10), + crop_pct=1.0, test_input_size=(3, 352, 352)), + + # Efficient Channel Attention ResNeXts + 'ecaresnext26t_32x4d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'ecaresnext50t_32x4d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + + # Squeeze-Excitation ResNets, to eventually replace the models in senet.py + 'seresnet18': _cfg( + url='', + interpolation='bicubic'), + 'seresnet34': _cfg( + url='', + interpolation='bicubic'), + 'seresnet50': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnet50_ra_224-8efdb4bb.pth', + interpolation='bicubic'), + 'seresnet50t': _cfg( + url='', + interpolation='bicubic', + first_conv='conv1.0'), + 'seresnet101': _cfg( + url='', + interpolation='bicubic'), + 'seresnet152': _cfg( + url='', + interpolation='bicubic'), + 'seresnet152d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnet152d_ra2-04464dd2.pth', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), pool_size=(8, 8), + crop_pct=1.0, test_input_size=(3, 320, 320) + ), + 'seresnet200d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), crop_pct=0.94, pool_size=(8, 8)), + 'seresnet269d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0', input_size=(3, 256, 256), crop_pct=0.94, pool_size=(8, 8)), + + # Squeeze-Excitation ResNeXts, to eventually replace the models in senet.py + 'seresnext26d_32x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext26d_32x4d-80fa48a3.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'seresnext26t_32x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext26tn_32x4d-569cb627.pth', + interpolation='bicubic', + first_conv='conv1.0'), + 'seresnext50_32x4d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext50_32x4d_racm-a304a460.pth', + interpolation='bicubic'), + 'seresnext101_32x4d': _cfg( + url='', + interpolation='bicubic'), + 'seresnext101_32x8d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tpu-weights/seresnext101_32x8d_ah-e6bc4c0a.pth', + interpolation='bicubic', test_input_size=(3, 288, 288), crop_pct=1.0), + 'seresnext101d_32x8d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tpu-weights/seresnext101d_32x8d_ah-191d7b94.pth', + interpolation='bicubic', first_conv='conv1.0', test_input_size=(3, 288, 288), crop_pct=1.0), + + 'senet154': _cfg( + url='', + interpolation='bicubic', + first_conv='conv1.0'), + + # ResNets with anti-aliasing / blur pool + 'resnetblur18': _cfg( + interpolation='bicubic'), + 'resnetblur50': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnetblur50-84f4748f.pth', + interpolation='bicubic'), + 'resnetblur50d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'resnetblur101d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'resnetaa50': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnetaa50_a1h-4cf422b3.pth', + test_input_size=(3, 288, 288), test_crop_pct=1.0, interpolation='bicubic'), + 'resnetaa50d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'resnetaa101d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'seresnetaa50d': _cfg( + url='', + interpolation='bicubic', first_conv='conv1.0'), + 'seresnextaa101d_32x8d': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tpu-weights/seresnextaa101d_32x8d_ah-83c8ae12.pth', + interpolation='bicubic', first_conv='conv1.0', test_input_size=(3, 288, 288), crop_pct=1.0), + + # ResNet-RS models + 'resnetrs50': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs50_ema-6b53758b.pth', + input_size=(3, 160, 160), pool_size=(5, 5), crop_pct=0.91, test_input_size=(3, 224, 224), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs101': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs101_i192_ema-1509bbf6.pth', + input_size=(3, 192, 192), pool_size=(6, 6), crop_pct=0.94, test_input_size=(3, 288, 288), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs152': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs152_i256_ema-a9aff7f9.pth', + input_size=(3, 256, 256), pool_size=(8, 8), crop_pct=1.0, test_input_size=(3, 320, 320), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs200': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-tpu-weights/resnetrs200_c-6b698b88.pth', + input_size=(3, 256, 256), pool_size=(8, 8), crop_pct=1.0, test_input_size=(3, 320, 320), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs270': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs270_ema-b40e674c.pth', + input_size=(3, 256, 256), pool_size=(8, 8), crop_pct=1.0, test_input_size=(3, 352, 352), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs350': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs350_i256_ema-5a1aa8f1.pth', + input_size=(3, 288, 288), pool_size=(9, 9), crop_pct=1.0, test_input_size=(3, 384, 384), + interpolation='bicubic', first_conv='conv1.0'), + 'resnetrs420': _cfg( + url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rs-weights/resnetrs420_ema-972dee69.pth', + input_size=(3, 320, 320), pool_size=(10, 10), crop_pct=1.0, test_input_size=(3, 416, 416), + interpolation='bicubic', first_conv='conv1.0'), +} + + +def get_padding(kernel_size, stride, dilation=1): + padding = ((stride - 1) + dilation * (kernel_size - 1)) // 2 + return padding + + +def create_aa(aa_layer, channels, stride=2, enable=True): + if not aa_layer or not enable: + return nn.Identity() + return aa_layer(stride) if issubclass(aa_layer, nn.AvgPool2d) else aa_layer(channels=channels, stride=stride) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__( + self, + inplanes, + planes, + stride=1, + downsample=None, + cardinality=1, + base_width=64, + reduce_first=1, + dilation=1, + first_dilation=None, + act_layer=nn.ReLU, + norm_layer=nn.BatchNorm2d, + attn_layer=None, + aa_layer=None, + drop_block=None, + drop_path=None, + ): + super(BasicBlock, self).__init__() + + assert cardinality == 1, 'BasicBlock only supports cardinality of 1' + assert base_width == 64, 'BasicBlock does not support changing base width' + first_planes = planes // reduce_first + outplanes = planes * self.expansion + first_dilation = first_dilation or dilation + use_aa = aa_layer is not None and (stride == 2 or first_dilation != dilation) + + self.conv1 = nn.Conv2d( + inplanes, first_planes, kernel_size=3, stride=1 if use_aa else stride, padding=first_dilation, + dilation=first_dilation, bias=False) + self.bn1 = norm_layer(first_planes) + self.drop_block = drop_block() if drop_block is not None else nn.Identity() + self.act1 = act_layer(inplace=True) + self.aa = create_aa(aa_layer, channels=first_planes, stride=stride, enable=use_aa) + + self.conv2 = nn.Conv2d( + first_planes, outplanes, kernel_size=3, padding=dilation, dilation=dilation, bias=False) + self.bn2 = norm_layer(outplanes) + + self.se = create_attn(attn_layer, outplanes) + + self.act2 = act_layer(inplace=True) + self.downsample = downsample + self.stride = stride + self.dilation = dilation + self.drop_path = drop_path + + def zero_init_last(self): + if getattr(self.bn2, 'weight', None) is not None: + nn.init.zeros_(self.bn2.weight) + + def forward(self, x): + shortcut = x + + x = self.conv1(x) + x = self.bn1(x) + x = self.drop_block(x) + x = self.act1(x) + x = self.aa(x) + + x = self.conv2(x) + x = self.bn2(x) + + if self.se is not None: + x = self.se(x) + + if self.drop_path is not None: + x = self.drop_path(x) + + if self.downsample is not None: + shortcut = self.downsample(shortcut) + x += shortcut + x = self.act2(x) + + return x + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__( + self, + inplanes, + planes, + stride=1, + downsample=None, + cardinality=1, + base_width=64, + reduce_first=1, + dilation=1, + first_dilation=None, + act_layer=nn.ReLU, + norm_layer=nn.BatchNorm2d, + attn_layer=None, + aa_layer=None, + drop_block=None, + drop_path=None, + ): + super(Bottleneck, self).__init__() + + width = int(math.floor(planes * (base_width / 64)) * cardinality) + first_planes = width // reduce_first + outplanes = planes * self.expansion + first_dilation = first_dilation or dilation + use_aa = aa_layer is not None and (stride == 2 or first_dilation != dilation) + + self.conv1 = nn.Conv2d(inplanes, first_planes, kernel_size=1, bias=False) + self.bn1 = norm_layer(first_planes) + self.act1 = act_layer(inplace=True) + + self.conv2 = nn.Conv2d( + first_planes, width, kernel_size=3, stride=1 if use_aa else stride, + padding=first_dilation, dilation=first_dilation, groups=cardinality, bias=False) + self.bn2 = norm_layer(width) + self.drop_block = drop_block() if drop_block is not None else nn.Identity() + self.act2 = act_layer(inplace=True) + self.aa = create_aa(aa_layer, channels=width, stride=stride, enable=use_aa) + + self.conv3 = nn.Conv2d(width, outplanes, kernel_size=1, bias=False) + self.bn3 = norm_layer(outplanes) + + self.se = create_attn(attn_layer, outplanes) + + self.act3 = act_layer(inplace=True) + self.downsample = downsample + self.stride = stride + self.dilation = dilation + self.drop_path = drop_path + + def zero_init_last(self): + if getattr(self.bn3, 'weight', None) is not None: + nn.init.zeros_(self.bn3.weight) + + def forward(self, x): + shortcut = x + + x = self.conv1(x) + x = self.bn1(x) + x = self.act1(x) + + x = self.conv2(x) + x = self.bn2(x) + x = self.drop_block(x) + x = self.act2(x) + x = self.aa(x) + + x = self.conv3(x) + x = self.bn3(x) + + if self.se is not None: + x = self.se(x) + + if self.drop_path is not None: + x = self.drop_path(x) + + if self.downsample is not None: + shortcut = self.downsample(shortcut) + x += shortcut + x = self.act3(x) + + return x + + +def downsample_conv( + in_channels, + out_channels, + kernel_size, + stride=1, + dilation=1, + first_dilation=None, + norm_layer=None, +): + norm_layer = norm_layer or nn.BatchNorm2d + kernel_size = 1 if stride == 1 and dilation == 1 else kernel_size + first_dilation = (first_dilation or dilation) if kernel_size > 1 else 1 + p = get_padding(kernel_size, stride, first_dilation) + + return nn.Sequential(*[ + nn.Conv2d( + in_channels, out_channels, kernel_size, stride=stride, padding=p, dilation=first_dilation, bias=False), + norm_layer(out_channels) + ]) + + +def downsample_avg( + in_channels, + out_channels, + kernel_size, + stride=1, + dilation=1, + first_dilation=None, + norm_layer=None, +): + norm_layer = norm_layer or nn.BatchNorm2d + avg_stride = stride if dilation == 1 else 1 + if stride == 1 and dilation == 1: + pool = nn.Identity() + else: + avg_pool_fn = AvgPool2dSame if avg_stride == 1 and dilation > 1 else nn.AvgPool2d + pool = avg_pool_fn(2, avg_stride, ceil_mode=True, count_include_pad=False) + + return nn.Sequential(*[ + pool, + nn.Conv2d(in_channels, out_channels, 1, stride=1, padding=0, bias=False), + norm_layer(out_channels) + ]) + + +def drop_blocks(drop_prob=0.): + return [ + None, None, + partial(DropBlock2d, drop_prob=drop_prob, block_size=5, gamma_scale=0.25) if drop_prob else None, + partial(DropBlock2d, drop_prob=drop_prob, block_size=3, gamma_scale=1.00) if drop_prob else None] + + +def make_blocks( + block_fn, + channels, + block_repeats, + inplanes, + reduce_first=1, + output_stride=32, + down_kernel_size=1, + avg_down=False, + drop_block_rate=0., + drop_path_rate=0., + **kwargs, +): + stages = [] + feature_info = [] + net_num_blocks = sum(block_repeats) + net_block_idx = 0 + net_stride = 4 + dilation = prev_dilation = 1 + for stage_idx, (planes, num_blocks, db) in enumerate(zip(channels, block_repeats, drop_blocks(drop_block_rate))): + stage_name = f'layer{stage_idx + 1}' # never liked this name, but weight compat requires it + stride = 1 if stage_idx == 0 else 2 + if net_stride >= output_stride: + dilation *= stride + stride = 1 + else: + net_stride *= stride + + downsample = None + if stride != 1 or inplanes != planes * block_fn.expansion: + down_kwargs = dict( + in_channels=inplanes, + out_channels=planes * block_fn.expansion, + kernel_size=down_kernel_size, + stride=stride, + dilation=dilation, + first_dilation=prev_dilation, + norm_layer=kwargs.get('norm_layer'), + ) + downsample = downsample_avg(**down_kwargs) if avg_down else downsample_conv(**down_kwargs) + + block_kwargs = dict(reduce_first=reduce_first, dilation=dilation, drop_block=db, **kwargs) + blocks = [] + for block_idx in range(num_blocks): + downsample = downsample if block_idx == 0 else None + stride = stride if block_idx == 0 else 1 + block_dpr = drop_path_rate * net_block_idx / (net_num_blocks - 1) # stochastic depth linear decay rule + blocks.append(block_fn( + inplanes, planes, stride, downsample, first_dilation=prev_dilation, + drop_path=DropPath(block_dpr) if block_dpr > 0. else None, **block_kwargs)) + prev_dilation = dilation + inplanes = planes * block_fn.expansion + net_block_idx += 1 + + stages.append((stage_name, nn.Sequential(*blocks))) + feature_info.append(dict(num_chs=inplanes, reduction=net_stride, module=stage_name)) + + return stages, feature_info + + +class ResNet(nn.Module): + """ResNet / ResNeXt / SE-ResNeXt / SE-Net + + This class implements all variants of ResNet, ResNeXt, SE-ResNeXt, and SENet that + * have > 1 stride in the 3x3 conv layer of bottleneck + * have conv-bn-act ordering + + This ResNet impl supports a number of stem and downsample options based on the v1c, v1d, v1e, and v1s + variants included in the MXNet Gluon ResNetV1b model. The C and D variants are also discussed in the + 'Bag of Tricks' paper: https://arxiv.org/pdf/1812.01187. The B variant is equivalent to torchvision default. + + ResNet variants (the same modifications can be used in SE/ResNeXt models as well): + * normal, b - 7x7 stem, stem_width = 64, same as torchvision ResNet, NVIDIA ResNet 'v1.5', Gluon v1b + * c - 3 layer deep 3x3 stem, stem_width = 32 (32, 32, 64) + * d - 3 layer deep 3x3 stem, stem_width = 32 (32, 32, 64), average pool in downsample + * e - 3 layer deep 3x3 stem, stem_width = 64 (64, 64, 128), average pool in downsample + * s - 3 layer deep 3x3 stem, stem_width = 64 (64, 64, 128) + * t - 3 layer deep 3x3 stem, stem width = 32 (24, 48, 64), average pool in downsample + * tn - 3 layer deep 3x3 stem, stem width = 32 (24, 32, 64), average pool in downsample + + ResNeXt + * normal - 7x7 stem, stem_width = 64, standard cardinality and base widths + * same c,d, e, s variants as ResNet can be enabled + + SE-ResNeXt + * normal - 7x7 stem, stem_width = 64 + * same c, d, e, s variants as ResNet can be enabled + + SENet-154 - 3 layer deep 3x3 stem (same as v1c-v1s), stem_width = 64, cardinality=64, + reduction by 2 on width of first bottleneck convolution, 3x3 downsample convs after first block + """ + + def __init__( + self, + block, + layers, + num_classes=1000, + in_chans=3, + output_stride=32, + global_pool='avg', + cardinality=1, + base_width=64, + stem_width=64, + stem_type='', + replace_stem_pool=False, + block_reduce_first=1, + down_kernel_size=1, + avg_down=False, + act_layer=nn.ReLU, + norm_layer=None, + aa_layer=None, + drop_rate=0.0, + drop_path_rate=0., + drop_block_rate=0., + zero_init_last=True, + block_args=None, + ): + """ + Args: + block (nn.Module): class for the residual block. Options are BasicBlock, Bottleneck. + layers (List[int]) : number of layers in each block + num_classes (int): number of classification classes (default 1000) + in_chans (int): number of input (color) channels. (default 3) + output_stride (int): output stride of the network, 32, 16, or 8. (default 32) + global_pool (str): Global pooling type. One of 'avg', 'max', 'avgmax', 'catavgmax' (default 'avg') + cardinality (int): number of convolution groups for 3x3 conv in Bottleneck. (default 1) + base_width (int): bottleneck channels factor. `planes * base_width / 64 * cardinality` (default 64) + stem_width (int): number of channels in stem convolutions (default 64) + stem_type (str): The type of stem (default ''): + * '', default - a single 7x7 conv with a width of stem_width + * 'deep' - three 3x3 convolution layers of widths stem_width, stem_width, stem_width * 2 + * 'deep_tiered' - three 3x3 conv layers of widths stem_width//4 * 3, stem_width, stem_width * 2 + replace_stem_pool (bool): replace stem max-pooling layer with a 3x3 stride-2 convolution + block_reduce_first (int): Reduction factor for first convolution output width of residual blocks, + 1 for all archs except senets, where 2 (default 1) + down_kernel_size (int): kernel size of residual block downsample path, + 1x1 for most, 3x3 for senets (default: 1) + avg_down (bool): use avg pooling for projection skip connection between stages/downsample (default False) + act_layer (str, nn.Module): activation layer + norm_layer (str, nn.Module): normalization layer + aa_layer (nn.Module): anti-aliasing layer + drop_rate (float): Dropout probability before classifier, for training (default 0.) + drop_path_rate (float): Stochastic depth drop-path rate (default 0.) + drop_block_rate (float): Drop block rate (default 0.) + zero_init_last (bool): zero-init the last weight in residual path (usually last BN affine weight) + block_args (dict): Extra kwargs to pass through to block module + """ + super(ResNet, self).__init__() + + block_args = block_args or dict() + assert output_stride in (8, 16, 32) + self.num_classes = num_classes + self.drop_rate = drop_rate + self.grad_checkpointing = False + + act_layer = get_act_layer(act_layer) + + if norm_layer is None: + norm_layer = nn.BatchNorm2d + norm_layer = get_norm_layer(norm_layer) + + # Stem + deep_stem = 'deep' in stem_type + inplanes = stem_width * 2 if deep_stem else 64 + if deep_stem: + stem_chs = (stem_width, stem_width) + if 'tiered' in stem_type: + stem_chs = (3 * (stem_width // 4), stem_width) + self.conv1 = nn.Sequential(*[ + nn.Conv2d(in_chans, stem_chs[0], 3, stride=2, padding=1, bias=False), + norm_layer(stem_chs[0]), + act_layer(inplace=True), + nn.Conv2d(stem_chs[0], stem_chs[1], 3, stride=1, padding=1, bias=False), + norm_layer(stem_chs[1]), + act_layer(inplace=True), + nn.Conv2d(stem_chs[1], inplanes, 3, stride=1, padding=1, bias=False)]) + else: + self.conv1 = nn.Conv2d(in_chans, inplanes, kernel_size=7, stride=2, padding=3, bias=False) + self.bn1 = norm_layer(inplanes) + self.act1 = act_layer(inplace=True) + self.feature_info = [dict(num_chs=inplanes, reduction=2, module='act1')] + + # Stem pooling. The name 'maxpool' remains for weight compatibility. + if replace_stem_pool: + self.maxpool = nn.Sequential(*filter(None, [ + nn.Conv2d(inplanes, inplanes, 3, stride=1 if aa_layer else 2, padding=1, bias=False), + create_aa(aa_layer, channels=inplanes, stride=2) if aa_layer is not None else None, + norm_layer(inplanes), + act_layer(inplace=True) + ])) + else: + if aa_layer is not None: + if issubclass(aa_layer, nn.AvgPool2d): + self.maxpool = aa_layer(2) + else: + self.maxpool = nn.Sequential(*[ + nn.MaxPool2d(kernel_size=3, stride=1, padding=1), + aa_layer(channels=inplanes, stride=2)]) + else: + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + # Feature Blocks + channels = [64, 128, 256, 512] + stage_modules, stage_feature_info = make_blocks( + block, + channels, + layers, + inplanes, + cardinality=cardinality, + base_width=base_width, + output_stride=output_stride, + reduce_first=block_reduce_first, + avg_down=avg_down, + down_kernel_size=down_kernel_size, + act_layer=act_layer, + norm_layer=norm_layer, + aa_layer=aa_layer, + drop_block_rate=drop_block_rate, + drop_path_rate=drop_path_rate, + **block_args, + ) + for stage in stage_modules: + self.add_module(*stage) # layer1, layer2, etc + self.feature_info.extend(stage_feature_info) + + # Head (Pooling and Classifier) + self.num_features = 512 * block.expansion + self.global_pool, self.fc = create_classifier(self.num_features, self.num_classes, pool_type=global_pool) + + self.init_weights(zero_init_last=zero_init_last) + + @staticmethod + def from_pretrained(model_name: str, load_weights=True, **kwargs) -> 'ResNet': + entry_fn = model_entrypoint(model_name, 'resnet') + return entry_fn(pretrained=not load_weights, **kwargs) + + @torch.jit.ignore + def init_weights(self, zero_init_last=True): + for n, m in self.named_modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + if zero_init_last: + for m in self.modules(): + if hasattr(m, 'zero_init_last'): + m.zero_init_last() + + @torch.jit.ignore + def group_matcher(self, coarse=False): + matcher = dict(stem=r'^conv1|bn1|maxpool', blocks=r'^layer(\d+)' if coarse else r'^layer(\d+)\.(\d+)') + return matcher + + @torch.jit.ignore + def set_grad_checkpointing(self, enable=True): + self.grad_checkpointing = enable + + @torch.jit.ignore + def get_classifier(self, name_only=False): + return 'fc' if name_only else self.fc + + def reset_classifier(self, num_classes, global_pool='avg'): + self.num_classes = num_classes + self.global_pool, self.fc = create_classifier(self.num_features, self.num_classes, pool_type=global_pool) + + def forward_features(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.act1(x) + x = self.maxpool(x) + + if self.grad_checkpointing and not torch.jit.is_scripting(): + x = checkpoint_seq([self.layer1, self.layer2, self.layer3, self.layer4], x, flatten=True) + else: + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + return x + + def forward_head(self, x, pre_logits: bool = False): + x = self.global_pool(x) + if self.drop_rate: + x = F.dropout(x, p=float(self.drop_rate), training=self.training) + return x if pre_logits else self.fc(x) + + def forward(self, x): + x = self.forward_features(x) + # x = self.forward_head(x) + return x + + +def _create_resnet(variant, pretrained=False, **kwargs): + return build_model_with_cfg(ResNet, variant, pretrained, **kwargs) + + +@register_model +def resnet10t(pretrained=False, **kwargs): + """Constructs a ResNet-10-T model. + """ + model_args = dict(block=BasicBlock, layers=[1, 1, 1, 1], stem_width=32, stem_type='deep_tiered', avg_down=True) + return _create_resnet('resnet10t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet14t(pretrained=False, **kwargs): + """Constructs a ResNet-14-T model. + """ + model_args = dict(block=Bottleneck, layers=[1, 1, 1, 1], stem_width=32, stem_type='deep_tiered', avg_down=True) + return _create_resnet('resnet14t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet18(pretrained=False, **kwargs): + """Constructs a ResNet-18 model. + """ + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2]) + return _create_resnet('resnet18', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet18d(pretrained=False, **kwargs): + """Constructs a ResNet-18-D model. + """ + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet18d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet34(pretrained=False, **kwargs): + """Constructs a ResNet-34 model. + """ + model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3]) + return _create_resnet('resnet34', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet34d(pretrained=False, **kwargs): + """Constructs a ResNet-34-D model. + """ + model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet34d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet26(pretrained=False, **kwargs): + """Constructs a ResNet-26 model. + """ + model_args = dict(block=Bottleneck, layers=[2, 2, 2, 2]) + return _create_resnet('resnet26', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet26t(pretrained=False, **kwargs): + """Constructs a ResNet-26-T model. + """ + model_args = dict(block=Bottleneck, layers=[2, 2, 2, 2], stem_width=32, stem_type='deep_tiered', avg_down=True) + return _create_resnet('resnet26t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet26d(pretrained=False, **kwargs): + """Constructs a ResNet-26-D model. + """ + model_args = dict(block=Bottleneck, layers=[2, 2, 2, 2], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet26d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs) + return _create_resnet('resnet50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet50d(pretrained=False, **kwargs) -> ResNet: + """Constructs a ResNet-50-D model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet50d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet50t(pretrained=False, **kwargs): + """Constructs a ResNet-50-T model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep_tiered', avg_down=True) + return _create_resnet('resnet50t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3]) + return _create_resnet('resnet101', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet101d(pretrained=False, **kwargs): + """Constructs a ResNet-101-D model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet101d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet152(pretrained=False, **kwargs): + """Constructs a ResNet-152 model. + """ + model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3]) + return _create_resnet('resnet152', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet152d(pretrained=False, **kwargs): + """Constructs a ResNet-152-D model. + """ + model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet152d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet200(pretrained=False, **kwargs): + """Constructs a ResNet-200 model. + """ + model_args = dict(block=Bottleneck, layers=[3, 24, 36, 3]) + return _create_resnet('resnet200', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet200d(pretrained=False, **kwargs): + """Constructs a ResNet-200-D model. + """ + model_args = dict(block=Bottleneck, layers=[3, 24, 36, 3], stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnet200d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def tv_resnet34(pretrained=False, **kwargs): + """Constructs a ResNet-34 model with original Torchvision weights. + """ + model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3]) + return _create_resnet('tv_resnet34', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def tv_resnet50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model with original Torchvision weights. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs) + return _create_resnet('tv_resnet50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def tv_resnet101(pretrained=False, **kwargs): + """Constructs a ResNet-101 model w/ Torchvision pretrained weights. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3]) + return _create_resnet('tv_resnet101', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def tv_resnet152(pretrained=False, **kwargs): + """Constructs a ResNet-152 model w/ Torchvision pretrained weights. + """ + model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3]) + return _create_resnet('tv_resnet152', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def wide_resnet50_2(pretrained=False, **kwargs): + """Constructs a Wide ResNet-50-2 model. + The model is the same as ResNet except for the bottleneck number of channels + which is twice larger in every block. The number of channels in outer 1x1 + convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048 + channels, and in Wide ResNet-50-2 has 2048-1024-2048. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], base_width=128) + return _create_resnet('wide_resnet50_2', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def wide_resnet101_2(pretrained=False, **kwargs): + """Constructs a Wide ResNet-101-2 model. + The model is the same as ResNet except for the bottleneck number of channels + which is twice larger in every block. The number of channels in outer 1x1 + convolutions is the same. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], base_width=128) + return _create_resnet('wide_resnet101_2', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnet50_gn(pretrained=False, **kwargs): + """Constructs a ResNet-50 model w/ GroupNorm + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs) + return _create_resnet('resnet50_gn', pretrained, norm_layer=GroupNorm, **model_args) + + +@register_model +def resnext50_32x4d(pretrained=False, **kwargs): + """Constructs a ResNeXt50-32x4d model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4) + return _create_resnet('resnext50_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnext50d_32x4d(pretrained=False, **kwargs): + """Constructs a ResNeXt50d-32x4d model. ResNext50 w/ deep stem & avg pool downsample + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, + stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnext50d_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnext101_32x4d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x4d model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4) + return _create_resnet('resnext101_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnext101_32x8d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x8d model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8) + return _create_resnet('resnext101_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnext101_64x4d(pretrained=False, **kwargs): + """Constructs a ResNeXt101-64x4d model. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=64, base_width=4) + return _create_resnet('resnext101_64x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def tv_resnext50_32x4d(pretrained=False, **kwargs): + """Constructs a ResNeXt50-32x4d model with original Torchvision weights. + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4) + return _create_resnet('tv_resnext50_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ig_resnext101_32x8d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x8 model pre-trained on weakly-supervised data + and finetuned on ImageNet from Figure 5 in + `"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_ + Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8) + return _create_resnet('ig_resnext101_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ig_resnext101_32x16d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x16 model pre-trained on weakly-supervised data + and finetuned on ImageNet from Figure 5 in + `"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_ + Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16) + return _create_resnet('ig_resnext101_32x16d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ig_resnext101_32x32d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x32 model pre-trained on weakly-supervised data + and finetuned on ImageNet from Figure 5 in + `"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_ + Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=32) + return _create_resnet('ig_resnext101_32x32d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ig_resnext101_32x48d(pretrained=False, **kwargs): + """Constructs a ResNeXt-101 32x48 model pre-trained on weakly-supervised data + and finetuned on ImageNet from Figure 5 in + `"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_ + Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=48) + return _create_resnet('ig_resnext101_32x48d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnet18(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNet-18 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2]) + return _create_resnet('ssl_resnet18', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnet50(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNet-50 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs) + return _create_resnet('ssl_resnet50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnext50_32x4d(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNeXt-50 32x4 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4) + return _create_resnet('ssl_resnext50_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnext101_32x4d(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNeXt-101 32x4 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4) + return _create_resnet('ssl_resnext101_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnext101_32x8d(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNeXt-101 32x8 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8) + return _create_resnet('ssl_resnext101_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ssl_resnext101_32x16d(pretrained=False, **kwargs): + """Constructs a semi-supervised ResNeXt-101 32x16 model pre-trained on YFCC100M dataset and finetuned on ImageNet + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16) + return _create_resnet('ssl_resnext101_32x16d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnet18(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised Resnet-18 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2]) + return _create_resnet('swsl_resnet18', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnet50(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised ResNet-50 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs) + return _create_resnet('swsl_resnet50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnext50_32x4d(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised ResNeXt-50 32x4 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4) + return _create_resnet('swsl_resnext50_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnext101_32x4d(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised ResNeXt-101 32x4 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4) + return _create_resnet('swsl_resnext101_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnext101_32x8d(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised ResNeXt-101 32x8 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8) + return _create_resnet('swsl_resnext101_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def swsl_resnext101_32x16d(pretrained=False, **kwargs): + """Constructs a semi-weakly supervised ResNeXt-101 32x16 model pre-trained on 1B weakly supervised + image dataset and finetuned on ImageNet. + `"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_ + Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/ + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16) + return _create_resnet('swsl_resnext101_32x16d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet26t(pretrained=False, **kwargs): + """Constructs an ECA-ResNeXt-26-T model. + This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels + in the deep stem and ECA attn. + """ + model_args = dict( + block=Bottleneck, layers=[2, 2, 2, 2], stem_width=32, + stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet26t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet50d(pretrained=False, **kwargs): + """Constructs a ResNet-50-D model with eca. + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet50d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet50d_pruned(pretrained=False, **kwargs): + """Constructs a ResNet-50-D model pruned with eca. + The pruning has been obtained using https://arxiv.org/pdf/2002.08258.pdf + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet50d_pruned', pretrained, pruned=True, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet50t(pretrained=False, **kwargs): + """Constructs an ECA-ResNet-50-T model. + Like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels in the deep stem and ECA attn. + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, + stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet50t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnetlight(pretrained=False, **kwargs): + """Constructs a ResNet-50-D light model with eca. + """ + model_args = dict( + block=Bottleneck, layers=[1, 1, 11, 3], stem_width=32, avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnetlight', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet101d(pretrained=False, **kwargs): + """Constructs a ResNet-101-D model with eca. + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet101d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet101d_pruned(pretrained=False, **kwargs): + """Constructs a ResNet-101-D model pruned with eca. + The pruning has been obtained using https://arxiv.org/pdf/2002.08258.pdf + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet101d_pruned', pretrained, pruned=True, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet200d(pretrained=False, **kwargs): + """Constructs a ResNet-200-D model with ECA. + """ + model_args = dict( + block=Bottleneck, layers=[3, 24, 36, 3], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet200d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnet269d(pretrained=False, **kwargs): + """Constructs a ResNet-269-D model with ECA. + """ + model_args = dict( + block=Bottleneck, layers=[3, 30, 48, 8], stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnet269d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnext26t_32x4d(pretrained=False, **kwargs): + """Constructs an ECA-ResNeXt-26-T model. + This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels + in the deep stem. This model replaces SE module with the ECA module + """ + model_args = dict( + block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32, + stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnext26t_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def ecaresnext50t_32x4d(pretrained=False, **kwargs): + """Constructs an ECA-ResNeXt-50-T model. + This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels + in the deep stem. This model replaces SE module with the ECA module + """ + model_args = dict( + block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32, + stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='eca')) + return _create_resnet('ecaresnext50t_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet18(pretrained=False, **kwargs): + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], block_args=dict(attn_layer='se')) + return _create_resnet('seresnet18', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet34(pretrained=False, **kwargs): + model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], block_args=dict(attn_layer='se')) + return _create_resnet('seresnet34', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet50(pretrained=False, **kwargs): + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], block_args=dict(attn_layer='se')) + return _create_resnet('seresnet50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet50t(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep_tiered', + avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnet50t', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet101(pretrained=False, **kwargs): + model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], block_args=dict(attn_layer='se')) + return _create_resnet('seresnet101', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet152(pretrained=False, **kwargs): + model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3], block_args=dict(attn_layer='se')) + return _create_resnet('seresnet152', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet152d(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 8, 36, 3], stem_width=32, stem_type='deep', + avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnet152d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet200d(pretrained=False, **kwargs): + """Constructs a ResNet-200-D model with SE attn. + """ + model_args = dict( + block=Bottleneck, layers=[3, 24, 36, 3], stem_width=32, stem_type='deep', + avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnet200d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnet269d(pretrained=False, **kwargs): + """Constructs a ResNet-269-D model with SE attn. + """ + model_args = dict( + block=Bottleneck, layers=[3, 30, 48, 8], stem_width=32, stem_type='deep', + avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnet269d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext26d_32x4d(pretrained=False, **kwargs): + """Constructs a SE-ResNeXt-26-D model.` + This is technically a 28 layer ResNet, using the 'D' modifier from Gluon / bag-of-tricks for + combination of deep stem and avg_pool in downsample. + """ + model_args = dict( + block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32, + stem_type='deep', avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnext26d_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext26t_32x4d(pretrained=False, **kwargs): + """Constructs a SE-ResNet-26-T model. + This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels + in the deep stem. + """ + model_args = dict( + block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32, + stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnext26t_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext26tn_32x4d(pretrained=False, **kwargs): + """Constructs a SE-ResNeXt-26-T model. + NOTE I deprecated previous 't' model defs and replaced 't' with 'tn', this was the only tn model of note + so keeping this def for backwards compat with any uses out there. Old 't' model is lost. + """ + return seresnext26t_32x4d(pretrained=pretrained, **kwargs) + + +@register_model +def seresnext50_32x4d(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, + block_args=dict(attn_layer='se')) + return _create_resnet('seresnext50_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext101_32x4d(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4, + block_args=dict(attn_layer='se')) + return _create_resnet('seresnext101_32x4d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext101_32x8d(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, + block_args=dict(attn_layer='se')) + return _create_resnet('seresnext101_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnext101d_32x8d(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, + stem_width=32, stem_type='deep', avg_down=True, + block_args=dict(attn_layer='se')) + return _create_resnet('seresnext101d_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def senet154(pretrained=False, **kwargs): + model_args = dict( + block=Bottleneck, layers=[3, 8, 36, 3], cardinality=64, base_width=4, stem_type='deep', + down_kernel_size=3, block_reduce_first=2, block_args=dict(attn_layer='se')) + return _create_resnet('senet154', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetblur18(pretrained=False, **kwargs): + """Constructs a ResNet-18 model with blur anti-aliasing + """ + model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], aa_layer=BlurPool2d) + return _create_resnet('resnetblur18', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetblur50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model with blur anti-aliasing + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=BlurPool2d) + return _create_resnet('resnetblur50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetblur50d(pretrained=False, **kwargs): + """Constructs a ResNet-50-D model with blur anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=BlurPool2d, + stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnetblur50d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetblur101d(pretrained=False, **kwargs): + """Constructs a ResNet-101-D model with blur anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], aa_layer=BlurPool2d, + stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnetblur101d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetaa34d(pretrained=False, **kwargs): + """Constructs a ResNet-34-D model w/ avgpool anti-aliasing + """ + model_args = dict( + block=BasicBlock, layers=[3, 4, 6, 3], aa_layer=nn.AvgPool2d, stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnetaa34d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetaa50(pretrained=False, **kwargs): + """Constructs a ResNet-50 model with avgpool anti-aliasing + """ + model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=nn.AvgPool2d) + return _create_resnet('resnetaa50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetaa50d(pretrained=False, **kwargs): + """Constructs a ResNet-50-D model with avgpool anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=nn.AvgPool2d, + stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnetaa50d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetaa101d(pretrained=False, **kwargs): + """Constructs a ResNet-101-D model with avgpool anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], aa_layer=nn.AvgPool2d, + stem_width=32, stem_type='deep', avg_down=True) + return _create_resnet('resnetaa101d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnetaa50d(pretrained=False, **kwargs): + """Constructs a SE=ResNet-50-D model with avgpool anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=nn.AvgPool2d, + stem_width=32, stem_type='deep', avg_down=True, block_args=dict(attn_layer='se')) + return _create_resnet('seresnetaa50d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def seresnextaa101d_32x8d(pretrained=False, **kwargs): + """Constructs a SE=ResNeXt-101-D 32x8d model with avgpool anti-aliasing + """ + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, + stem_width=32, stem_type='deep', avg_down=True, aa_layer=nn.AvgPool2d, + block_args=dict(attn_layer='se')) + return _create_resnet('seresnextaa101d_32x8d', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs50(pretrained=False, **kwargs): + """Constructs a ResNet-RS-50 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs50', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs101(pretrained=False, **kwargs): + """Constructs a ResNet-RS-101 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs101', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs152(pretrained=False, **kwargs): + """Constructs a ResNet-RS-152 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[3, 8, 36, 3], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs152', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs200(pretrained=False, **kwargs): + """Constructs a ResNet-RS-200 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[3, 24, 36, 3], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs200', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs270(pretrained=False, **kwargs): + """Constructs a ResNet-RS-270 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[4, 29, 53, 4], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs270', pretrained, **dict(model_args, **kwargs)) + + + +@register_model +def resnetrs350(pretrained=False, **kwargs): + """Constructs a ResNet-RS-350 model. + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[4, 36, 72, 4], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs350', pretrained, **dict(model_args, **kwargs)) + + +@register_model +def resnetrs420(pretrained=False, **kwargs): + """Constructs a ResNet-RS-420 model + Paper: Revisiting ResNets - https://arxiv.org/abs/2103.07579 + Pretrained weights from https://github.com/tensorflow/tpu/tree/bee9c4f6/models/official/resnet/resnet_rs + """ + attn_layer = partial(get_attn('se'), rd_ratio=0.25) + model_args = dict( + block=Bottleneck, layers=[4, 44, 87, 4], stem_width=32, stem_type='deep', replace_stem_pool=True, + avg_down=True, block_args=dict(attn_layer=attn_layer)) + return _create_resnet('resnetrs420', pretrained, **dict(model_args, **kwargs)) diff --git a/models/unival/frozen_bn.py b/models/unival/frozen_bn.py new file mode 100644 index 0000000000000000000000000000000000000000..081f5d079410b2cb1f2b2a4a19f18f3ca9e69dcc --- /dev/null +++ b/models/unival/frozen_bn.py @@ -0,0 +1,85 @@ +# Modified from detectron2: https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py#L13 +import torch +from torch import nn +from torch.nn import functional as F + + +class FrozenBatchNorm2d(nn.Module): + """ + BatchNorm2d where the batch statistics and the affine parameters are fixed. + + It contains non-trainable buffers called + "weight" and "bias", "running_mean", "running_var", + initialized to perform identity transformation. + + The pre-trained backbone models from Caffe2 only contain "weight" and "bias", + which are computed from the original four parameters of BN. + The affine transform `x * weight + bias` will perform the equivalent + computation of `(x - running_mean) / sqrt(running_var) * weight + bias`. + When loading a backbone model from Caffe2, "running_mean" and "running_var" + will be left unchanged as identity transformation. + + Other pre-trained backbone models may contain all 4 parameters. + + The forward is implemented by `F.batch_norm(..., training=False)`. + """ + + def __init__(self, num_features, eps=1e-5): + super().__init__() + self.num_features = num_features + self.eps = eps + self.register_buffer("weight", torch.ones(num_features)) + self.register_buffer("bias", torch.zeros(num_features)) + self.register_buffer("running_mean", torch.zeros(num_features)) + self.register_buffer("running_var", torch.ones(num_features) - eps) + + def forward(self, x): + if x.requires_grad: + # When gradients are needed, F.batch_norm will use extra memory + # because its backward op computes gradients for weight/bias as well. + scale = self.weight * (self.running_var + self.eps).rsqrt() + bias = self.bias - self.running_mean * scale + if x.dim() == 5: + scale = scale.reshape(1, -1, 1, 1, 1) + bias = bias.reshape(1, -1, 1, 1, 1) + else: + scale = scale.reshape(1, -1, 1, 1) + bias = bias.reshape(1, -1, 1, 1) + + out_dtype = x.dtype # may be half + return x * scale.to(out_dtype) + bias.to(out_dtype) + else: + # When gradients are not needed, F.batch_norm is a single fused op + # and provide more optimization opportunities. + return F.batch_norm( + x, + self.running_mean, + self.running_var, + self.weight, + self.bias, + training=False, + eps=self.eps, + ) + + def _load_from_state_dict( + self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ): + num_batches_tracked_key = prefix + 'num_batches_tracked' + if num_batches_tracked_key in state_dict: + del state_dict[num_batches_tracked_key] + version = local_metadata.get("version", None) + + if version is None or version < 2: + # No running_mean/var in early versions + # This will silent the warnings + if prefix + "running_mean" not in state_dict: + state_dict[prefix + "running_mean"] = torch.zeros_like(self.running_mean) + if prefix + "running_var" not in state_dict: + state_dict[prefix + "running_var"] = torch.ones_like(self.running_var) + + super()._load_from_state_dict( + state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs + ) + + def __repr__(self): + return "FrozenBatchNorm2d(num_features={}, eps={})".format(self.num_features, self.eps) diff --git a/models/unival/resnet.py b/models/unival/resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..9ad8ee87de4bb579d745ab8302a368ca1749a1fe --- /dev/null +++ b/models/unival/resnet.py @@ -0,0 +1,225 @@ +import torch +import torch.nn as nn + + +def drop_path(x, drop_prob: float = 0., training: bool = False): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + This is the same as the DropConnect impl I created for EfficientNet, etc networks, however, + the original name is misleading as 'Drop Connect' is a.sh different form of dropout in a.sh separate paper... + See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for + changing the layer and argument names to 'drop path' rather than mix DropConnect as a.sh layer name and use + 'survival rate' as the argument. + """ + if drop_prob == 0. or not training: + return x + keep_prob = 1 - drop_prob + shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNets + random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device) + random_tensor.floor_() # binarize + output = x.div(keep_prob) * random_tensor + return output + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + """ + def __init__(self, drop_prob=None): + super(DropPath, self).__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + +def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1): + """3x3 convolution with padding""" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=dilation, groups=groups, bias=False, dilation=dilation) + + +def conv1x1(in_planes, out_planes, stride=1): + """1x1 convolution""" + return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, + base_width=64, dilation=1, norm_layer=None): + super(BasicBlock, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + if groups != 1 or base_width != 64: + raise ValueError('BasicBlock only supports groups=1 and base_width=64') + if dilation > 1: + raise NotImplementedError("Dilation > 1 not supported in BasicBlock") + # Both self.conv1 and self.downsample layers downsample the input when stride != 1 + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = norm_layer(planes) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = norm_layer(planes) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + assert False + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2) + # while original implementation places the stride at the first 1x1 convolution(self.conv1) + # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385. + # This variant is also known as ResNet V1.5 and improves accuracy according to + # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch. + + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1, + base_width=64, dilation=1, norm_layer=None, drop_path_rate=0.0): + super(Bottleneck, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + width = int(planes * (base_width / 64.)) * groups + # Both self.conv2 and self.downsample layers downsample the input when stride != 1 + self.conv1 = conv1x1(inplanes, width) + self.bn1 = norm_layer(width) + self.conv2 = conv3x3(width, width, stride, groups, dilation) + self.bn2 = norm_layer(width) + self.conv3 = conv1x1(width, planes * self.expansion) + self.bn3 = norm_layer(planes * self.expansion) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + self.drop_path = DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity() + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out = identity + self.drop_path(out) + out = self.relu(out) + + return out + + +class ResNet(nn.Module): + + def __init__(self, layers, zero_init_residual=False, + groups=1, width_per_group=64, replace_stride_with_dilation=None, + norm_layer=None, drop_path_rate=0.0): + super(ResNet, self).__init__() + if norm_layer is None: + norm_layer = nn.BatchNorm2d + self._norm_layer = norm_layer + + self.inplanes = 64 + self.dilation = 1 + if replace_stride_with_dilation is None: + # each element in the tuple indicates if we should replace + # the 2x2 stride with a dilated convolution instead + replace_stride_with_dilation = [False, False, False] + if len(replace_stride_with_dilation) != 3: + raise ValueError("replace_stride_with_dilation should be None " + "or a 3-element tuple, got {}".format(replace_stride_with_dilation)) + self.groups = groups + self.base_width = width_per_group + self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, + bias=False) + self.bn1 = norm_layer(self.inplanes) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + self.layer1 = self._make_layer(Bottleneck, 64, layers[0], drop_path_rate=drop_path_rate) + self.layer2 = self._make_layer(Bottleneck, 128, layers[1], stride=2, + dilate=replace_stride_with_dilation[0], drop_path_rate=drop_path_rate) + self.layer3 = self._make_layer(Bottleneck, 256, layers[2], stride=2, + dilate=replace_stride_with_dilation[1], drop_path_rate=drop_path_rate) + + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, (nn.SyncBatchNorm, nn.BatchNorm2d, nn.GroupNorm)): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + + # Zero-initialize the last BN in each residual branch, + # so that the residual branch starts with zeros, and each residual block behaves like an identity. + # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677 + if zero_init_residual: + for m in self.modules(): + if isinstance(m, Bottleneck): + nn.init.constant_(m.bn3.weight, 0) + elif isinstance(m, BasicBlock): + nn.init.constant_(m.bn2.weight, 0) + + def _make_layer(self, block, planes, blocks, stride=1, dilate=False, drop_path_rate=0.0): + norm_layer = self._norm_layer + downsample = None + previous_dilation = self.dilation + if dilate: + self.dilation *= stride + stride = 1 + if stride != 1 or self.inplanes != planes * block.expansion: + downsample = nn.Sequential( + conv1x1(self.inplanes, planes * block.expansion, stride), + norm_layer(planes * block.expansion), + ) + + layers = [] + layers.append(block(self.inplanes, planes, stride, downsample, self.groups, + self.base_width, previous_dilation, norm_layer)) + self.inplanes = planes * block.expansion + + dpr = [x.item() for x in torch.linspace(0, drop_path_rate, blocks)] + for i in range(1, blocks): + layers.append(block(self.inplanes, planes, groups=self.groups, + base_width=self.base_width, dilation=self.dilation, + norm_layer=norm_layer, drop_path_rate=dpr[i])) + + return nn.Sequential(*layers) + + def _forward_impl(self, x): + # See note [TorchScript super()] + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.maxpool(x) + + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + + return x + + def forward(self, x): + return self._forward_impl(x) \ No newline at end of file diff --git a/models/unival/unify_multihead_attention.py b/models/unival/unify_multihead_attention.py new file mode 100644 index 0000000000000000000000000000000000000000..d627db69ec006ff6744b4ac30c647283e628cbac --- /dev/null +++ b/models/unival/unify_multihead_attention.py @@ -0,0 +1,534 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +from typing import Dict, Optional, Tuple + +import torch +import torch.nn.functional as F +from fairseq import utils +from fairseq.incremental_decoding_utils import with_incremental_state +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise +from torch import Tensor, nn +from torch.nn import Parameter +from fairseq.modules import LayerNorm + +@with_incremental_state +class MultiheadAttention(nn.Module): + """Multi-headed attention. + + See "Attention Is All You Need" for more details. + """ + + def __init__( + self, + embed_dim, + num_heads, + kdim=None, + vdim=None, + dropout=0.0, + bias=True, + add_bias_kv=False, + add_zero_attn=False, + self_attention=False, + encoder_decoder_attention=False, + q_noise=0.0, + qn_block_size=8, + scale_factor=2, + scale_heads=False, + qk_norm=False, + ): + super().__init__() + self.embed_dim = embed_dim + self.kdim = kdim if kdim is not None else embed_dim + self.vdim = vdim if vdim is not None else embed_dim + self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim + + self.num_heads = num_heads + self.dropout_module = FairseqDropout( + dropout, module_name=self.__class__.__name__ + ) + + self.head_dim = embed_dim // num_heads + assert ( + self.head_dim * num_heads == self.embed_dim + ), "embed_dim must be divisible by num_heads" + self.scaling = float(self.head_dim * scale_factor) ** -0.5 + + self.self_attention = self_attention + self.encoder_decoder_attention = encoder_decoder_attention + self.c_attn = nn.Parameter(torch.ones((self.num_heads,)), requires_grad=True) if scale_heads else None + + assert not self.self_attention or self.qkv_same_dim, ( + "Self-attention requires query, key and " "value to be of the same size" + ) + + self.k_proj = quant_noise( + nn.Linear(self.kdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.v_proj = quant_noise( + nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size + ) + self.q_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + self.out_proj = quant_noise( + nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size + ) + + if add_bias_kv: + self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim)) + self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim)) + else: + self.bias_k = self.bias_v = None + + self.add_zero_attn = add_zero_attn + + self.reset_parameters() + + self.onnx_trace = False + + self.qk_norm = qk_norm + if self.qk_norm: + self.q_norm = LayerNorm(embed_dim) + self.k_norm = LayerNorm(embed_dim) + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def reset_parameters(self): + if self.qkv_same_dim: + # Empirically observed the convergence to be much better with + # the scaled initialization + nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2)) + nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2)) + else: + nn.init.xavier_uniform_(self.k_proj.weight) + nn.init.xavier_uniform_(self.v_proj.weight) + nn.init.xavier_uniform_(self.q_proj.weight) + + nn.init.xavier_uniform_(self.out_proj.weight) + if self.out_proj.bias is not None: + nn.init.constant_(self.out_proj.bias, 0.0) + if self.bias_k is not None: + nn.init.xavier_normal_(self.bias_k) + if self.bias_v is not None: + nn.init.xavier_normal_(self.bias_v) + + def forward( + self, + query, + key: Optional[Tensor], + value: Optional[Tensor], + key_padding_mask: Optional[Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + need_weights: bool = True, + static_kv: bool = False, + attn_mask: Optional[Tensor] = None, + self_attn_mask: Optional[Tensor] = None, + before_softmax: bool = False, + need_head_weights: bool = False, + attn_bias: Optional[Tensor] = None, + prompt_kv: Optional[Tensor] = None + ) -> Tuple[Tensor, Optional[Tensor]]: + """Input shape: Time x Batch x Channel + + Args: + key_padding_mask (ByteTensor, optional): mask to exclude + keys that are pads, of shape `(batch, src_len)`, where + padding elements are indicated by 1s. + need_weights (bool, optional): return the attention weights, + averaged over heads (default: False). + attn_mask (ByteTensor, optional): typically used to + implement causal attention, where the mask prevents the + attention from looking forward in time (default: None). + before_softmax (bool, optional): return the raw attention + weights and values before the attention softmax. + need_head_weights (bool, optional): return the attention + weights for each head. Implies *need_weights*. Default: + return the average attention weights over all heads. + """ + if need_head_weights: + need_weights = True + + if self.qk_norm: + query = self.q_norm(query) + key = self.q_norm(key) + + is_tpu = query.device.type == "xla" + + tgt_len, bsz, embed_dim = query.size() + src_len = tgt_len + assert embed_dim == self.embed_dim, f"query dim {embed_dim} != {self.embed_dim}" + assert list(query.size()) == [tgt_len, bsz, embed_dim] + if key is not None: + src_len, key_bsz, _ = key.size() + if not torch.jit.is_scripting(): + assert key_bsz == bsz + assert value is not None + assert src_len, bsz == value.shape[:2] + + if ( + not self.onnx_trace + and not is_tpu # don't use PyTorch version on TPUs + and incremental_state is None + and not static_kv + # A workaround for quantization to work. Otherwise JIT compilation + # treats bias in linear module as method. + and not torch.jit.is_scripting() + and self_attn_mask is None + and attn_bias is None + ): + assert key is not None and value is not None + return F.multi_head_attention_forward( + query, + key, + value, + self.embed_dim, + self.num_heads, + torch.empty([0]), + torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)), + self.bias_k, + self.bias_v, + self.add_zero_attn, + self.dropout_module.p, + self.out_proj.weight, + self.out_proj.bias, + self.training or self.dropout_module.apply_during_inference, + key_padding_mask, + need_weights, + attn_mask, + use_separate_proj_weight=True, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + ) + + if incremental_state is not None: + saved_state = self._get_input_buffer(incremental_state) + if saved_state is not None and "prev_key" in saved_state: + # previous time steps are cached - no need to recompute + # key and value if they are static + if static_kv: + assert self.encoder_decoder_attention and not self.self_attention + key = value = None + else: + saved_state = None + + if self.self_attention and self_attn_mask is None: + q = self.q_proj(query) + k = self.k_proj(query) + v = self.v_proj(query) + elif self.encoder_decoder_attention: + # encoder-decoder attention + q = self.q_proj(query) + if key is None: + assert value is None + k = v = None + else: + k = self.k_proj(key) + v = self.v_proj(key) + + else: + assert key is not None and value is not None + q = self.q_proj(query) + k = self.k_proj(key) + v = self.v_proj(value) + q *= self.scaling + + if self.bias_k is not None: + assert self.bias_v is not None + k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)]) + v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)]) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + if key_padding_mask is not None: + key_padding_mask = torch.cat( + [ + key_padding_mask, + key_padding_mask.new_zeros(key_padding_mask.size(0), 1), + ], + dim=1, + ) + + q = ( + q.contiguous() + .view(tgt_len, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if k is not None: + k = ( + k.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + if v is not None: + v = ( + v.contiguous() + .view(-1, bsz * self.num_heads, self.head_dim) + .transpose(0, 1) + ) + + if saved_state is not None: + # saved states are stored with shape (bsz, num_heads, seq_len, head_dim) + if "prev_key" in saved_state: + _prev_key = saved_state["prev_key"] + assert _prev_key is not None + prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + k = prev_key + else: + assert k is not None + k = torch.cat([prev_key, k], dim=1) + src_len = k.size(1) + if "prev_value" in saved_state: + _prev_value = saved_state["prev_value"] + assert _prev_value is not None + prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim) + if static_kv: + v = prev_value + else: + assert v is not None + v = torch.cat([prev_value, v], dim=1) + prev_key_padding_mask: Optional[Tensor] = None + if "prev_key_padding_mask" in saved_state: + prev_key_padding_mask = saved_state["prev_key_padding_mask"] + assert k is not None and v is not None + key_padding_mask = MultiheadAttention._append_prev_key_padding_mask( + key_padding_mask=key_padding_mask, + prev_key_padding_mask=prev_key_padding_mask, + batch_size=bsz, + src_len=k.size(1), + static_kv=static_kv, + ) + + saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim) + saved_state["prev_key_padding_mask"] = key_padding_mask + # In this branch incremental_state is never None + assert incremental_state is not None + incremental_state = self._set_input_buffer(incremental_state, saved_state) + assert k is not None + assert k.size(1) == src_len + + # This is part of a workaround to get around fork/join parallelism + # not supporting Optional types. + if key_padding_mask is not None and key_padding_mask.dim() == 0: + key_padding_mask = None + + if key_padding_mask is not None: + assert key_padding_mask.size(0) == bsz + assert key_padding_mask.size(1) == k.size(1) + + if self.add_zero_attn: + assert v is not None + src_len += 1 + k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1) + v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1) + if attn_mask is not None: + attn_mask = torch.cat( + [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1 + ) + if key_padding_mask is not None: + key_padding_mask = torch.cat( + [ + key_padding_mask, + torch.zeros(key_padding_mask.size(0), 1).type_as( + key_padding_mask + ), + ], + dim=1, + ) + if prompt_kv is not None: + prompt_k, prompt_v = prompt_kv.split(1) + prompt_k = prompt_k.squeeze(0).reshape(k.size(0), -1, k.size(2)) + prompt_v = prompt_v.squeeze(0).reshape(v.size(0), -1, v.size(2)) + k = torch.cat([prompt_k, k], dim=1) + v = torch.cat([prompt_v, v], dim=1) + attn_weights = torch.bmm(q, k.transpose(1, 2)) + attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, k.size(1), bsz) + + assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, k.size(1)] + + if attn_bias is not None: + attn_weights[:, :, -src_len:] += attn_bias[:, :, -src_len:] + + if attn_mask is not None: + attn_mask = attn_mask.unsqueeze(0) + if self.onnx_trace: + attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1) + attn_weights += attn_mask + + if self_attn_mask is not None: + self_attn_mask = self_attn_mask.unsqueeze(1).expand(bsz, self.num_heads, tgt_len, k.size(1)) + attn_weights += self_attn_mask.contiguous().view(bsz * self.num_heads, tgt_len, k.size(1)) + + if key_padding_mask is not None: + # don't attend to padding symbols + attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, k.size(1)) + if not is_tpu: + attn_weights = attn_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool), + float("-inf"), + ) + else: + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf")) + attn_weights = attn_weights.transpose(0, 2) + attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, k.size(1)) + + if before_softmax: + return attn_weights, v + + attn_weights_float = utils.softmax( + attn_weights, dim=-1, onnx_trace=self.onnx_trace + ) + attn_weights = attn_weights_float.type_as(attn_weights) + attn_probs = self.dropout_module(attn_weights) + + assert v is not None + attn = torch.bmm(attn_probs, v) + assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim] + if self.onnx_trace and attn.size(1) == 1: + # when ONNX tracing a single decoder step (sequence length == 1) + # the transpose is a no-op copy before view, thus unnecessary + attn = attn.contiguous().view(tgt_len, bsz, embed_dim) + else: + attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim) + if self.c_attn is not None: + attn = attn.view(tgt_len, bsz, self.num_heads, self.head_dim) + attn = torch.einsum('tbhd,h->tbhd', attn, self.c_attn) + attn = attn.reshape(tgt_len, bsz, self.embed_dim) + attn = self.out_proj(attn) + attn_weights: Optional[Tensor] = None + if need_weights: + attn_weights = attn_weights_float.view( + bsz, self.num_heads, tgt_len, k.size(1) + ).transpose(1, 0) + if not need_head_weights: + # average attention weights over heads + attn_weights = attn_weights.mean(dim=0) + + return attn, attn_weights + + @staticmethod + def _append_prev_key_padding_mask( + key_padding_mask: Optional[Tensor], + prev_key_padding_mask: Optional[Tensor], + batch_size: int, + src_len: int, + static_kv: bool, + ) -> Optional[Tensor]: + # saved key padding masks have shape (bsz, seq_len) + if prev_key_padding_mask is not None and static_kv: + new_key_padding_mask = prev_key_padding_mask + elif prev_key_padding_mask is not None and key_padding_mask is not None: + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1 + ) + # During incremental decoding, as the padding token enters and + # leaves the frame, there will be a time when prev or current + # is None + elif prev_key_padding_mask is not None: + if src_len > prev_key_padding_mask.size(1): + filler = torch.zeros( + (batch_size, src_len - prev_key_padding_mask.size(1)), + device=prev_key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [prev_key_padding_mask.float(), filler.float()], dim=1 + ) + else: + new_key_padding_mask = prev_key_padding_mask.float() + elif key_padding_mask is not None: + if src_len > key_padding_mask.size(1): + filler = torch.zeros( + (batch_size, src_len - key_padding_mask.size(1)), + device=key_padding_mask.device, + ) + new_key_padding_mask = torch.cat( + [filler.float(), key_padding_mask.float()], dim=1 + ) + else: + new_key_padding_mask = key_padding_mask.float() + else: + new_key_padding_mask = prev_key_padding_mask + return new_key_padding_mask + + @torch.jit.export + def reorder_incremental_state( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + new_order: Tensor, + ): + """Reorder buffered internal state (for incremental generation).""" + input_buffer = self._get_input_buffer(incremental_state) + if input_buffer is not None: + for k in input_buffer.keys(): + input_buffer_k = input_buffer[k] + if input_buffer_k is not None: + if self.encoder_decoder_attention and input_buffer_k.size( + 0 + ) == new_order.size(0): + break + input_buffer[k] = input_buffer_k.index_select(0, new_order) + incremental_state = self._set_input_buffer(incremental_state, input_buffer) + return incremental_state + + def _get_input_buffer( + self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] + ) -> Dict[str, Optional[Tensor]]: + result = self.get_incremental_state(incremental_state, "attn_state") + if result is not None: + return result + else: + empty_result: Dict[str, Optional[Tensor]] = {} + return empty_result + + def _set_input_buffer( + self, + incremental_state: Dict[str, Dict[str, Optional[Tensor]]], + buffer: Dict[str, Optional[Tensor]], + ): + return self.set_incremental_state(incremental_state, "attn_state", buffer) + + def apply_sparse_mask(self, attn_weights, tgt_len: int, src_len: int, bsz: int): + return attn_weights + + def upgrade_state_dict_named(self, state_dict, name): + prefix = name + "." if name != "" else "" + items_to_add = {} + keys_to_remove = [] + for k in state_dict.keys(): + if k.endswith(prefix + "in_proj_weight"): + # in_proj_weight used to be q + k + v with same dimensions + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.weight"] = state_dict[k][:dim] + items_to_add[prefix + "k_proj.weight"] = state_dict[k][dim : 2 * dim] + items_to_add[prefix + "v_proj.weight"] = state_dict[k][2 * dim :] + + keys_to_remove.append(k) + + k_bias = prefix + "in_proj_bias" + if k_bias in state_dict.keys(): + dim = int(state_dict[k].shape[0] / 3) + items_to_add[prefix + "q_proj.bias"] = state_dict[k_bias][:dim] + items_to_add[prefix + "k_proj.bias"] = state_dict[k_bias][ + dim : 2 * dim + ] + items_to_add[prefix + "v_proj.bias"] = state_dict[k_bias][2 * dim :] + + keys_to_remove.append(prefix + "in_proj_bias") + + for k in keys_to_remove: + del state_dict[k] + + for key, value in items_to_add.items(): + state_dict[key] = value diff --git a/models/unival/unify_transformer.py b/models/unival/unify_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..f26c52cde9fe3cbe84b76c54d22419e40e061afc --- /dev/null +++ b/models/unival/unify_transformer.py @@ -0,0 +1,2334 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import math +import random +from typing import Any, Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.distributed import fsdp_wrap +from fairseq.models import ( + FairseqEncoder, + FairseqEncoderDecoderModel, + FairseqIncrementalDecoder, + register_model, + register_model_architecture, +) +from fairseq.modules import ( + AdaptiveSoftmax, + BaseLayer, + FairseqDropout, + LayerDropModuleList, + LayerNorm, + SinusoidalPositionalEmbedding, +) +from fairseq.modules.checkpoint_activations import checkpoint_wrapper +from fairseq.modules.quant_noise import quant_noise as apply_quant_noise_ +from torch import Tensor + +from .unify_transformer_layer import TransformerEncoderLayer, TransformerDecoderLayer +from .resnet import ResNet +from .frozen_bn import FrozenBatchNorm2d + + +# image +from .encoders.timm_resnet import resnet101, resnet152, resnet50 +# video +from .encoders.resnext3d import ResNeXt3D, ResNeXtBottleneck + +# audio +from .encoders.pann import create_pann_model +from data.audio_utils import AUDIO_CFG, dotdict + +DEFAULT_MAX_SOURCE_POSITIONS = 1024 +DEFAULT_MAX_TARGET_POSITIONS = 1024 + + +DEFAULT_MIN_PARAMS_TO_WRAP = int(1e8) +import math + +def BatchNorm2d(out_chan, momentum=0.1, eps=1e-3): + return nn.SyncBatchNorm.convert_sync_batchnorm( + nn.BatchNorm2d(out_chan, momentum=momentum, eps=eps) + ) + + +def make_token_bucket_position(bucket_size, max_position=DEFAULT_MAX_SOURCE_POSITIONS): + context_pos = torch.arange(max_position, dtype=torch.long)[:, None] + memory_pos = torch.arange(max_position, dtype=torch.long)[None, :] + relative_pos = context_pos - memory_pos + sign = torch.sign(relative_pos) + mid = bucket_size // 2 + abs_pos = torch.where((relative_pos<mid) & (relative_pos > -mid), mid-1, torch.abs(relative_pos)) + log_pos = torch.ceil(torch.log(abs_pos/mid)/math.log((max_position-1)/mid) * (mid-1)) + mid + log_pos = log_pos.int() + bucket_pos = torch.where(abs_pos.le(mid), relative_pos, log_pos*sign).long() + return bucket_pos + bucket_size - 1 + + +def make_image_bucket_position(bucket_size, num_relative_distance): + coords_h = torch.arange(bucket_size) + coords_w = torch.arange(bucket_size) + coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing='ij')) # 2, Wh, Ww + coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww + relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww + relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2 + relative_coords[:, :, 0] += bucket_size - 1 # shift to start from 0 + relative_coords[:, :, 1] += bucket_size - 1 + relative_coords[:, :, 0] *= 2 * bucket_size - 1 + relative_position_index = torch.zeros(size=(bucket_size * bucket_size + 1,) * 2, dtype=relative_coords.dtype) + relative_position_index[1:, 1:] = relative_coords.sum(-1) # Wh*Ww, Wh*Ww + relative_position_index[0, 0:] = num_relative_distance - 3 + relative_position_index[0:, 0] = num_relative_distance - 2 + relative_position_index[0, 0] = num_relative_distance - 1 + return relative_position_index + + +class PromptEncoder(torch.nn.Module): + r""" + Prompt encoder to generate prompts, including prompt, prefix, instance and instruction + """ + + def __init__( + self, + type, + length, + projection, + embed_dim, + proj_dim, + layers, + vocab_size): + super().__init__() + self.prefix_projection = projection + + if type == "prefix": + layers = layers + prompt_vocab_size = length + + if self.prefix_projection: + self.embedding = torch.nn.Embedding(prompt_vocab_size, embed_dim) + self.trans = torch.nn.Sequential( + torch.nn.Linear(embed_dim, proj_dim), + torch.nn.ReLU(), + torch.nn.Linear(proj_dim, layers * 2 * embed_dim) + ) + else: + if type == "prefix": + self.embedding = torch.nn.Embedding( + prompt_vocab_size, layers * 2 * embed_dim) + + def forward(self, prefix: torch.Tensor): + if self.prefix_projection: + prefix_tokens = self.embedding(prefix) + past_key_values = self.trans(prefix_tokens) + else: + past_key_values = self.embedding(prefix) + return past_key_values + + +@register_model("unify_transformer") +class TransformerModel(FairseqEncoderDecoderModel): + """ + Transformer model from `"Attention Is All You Need" (Vaswani, et al, 2017) + <https://arxiv.org/abs/1706.03762>`_. + + Args: + encoder (TransformerEncoder): the encoder + decoder (TransformerDecoder): the decoder + + The Transformer model provides the following named architectures and + command-line arguments: + + .. argparse:: + :ref: fairseq.models.transformer_parser + :prog: + """ + + def __init__(self, args, encoder, decoder): + super().__init__(encoder, decoder) + self.args = args + self.supports_align_args = True + + + + @staticmethod + def add_args(parser): + """Add model-specific arguments to the parser.""" + # fmt: off + parser.add_argument('--activation-fn', + choices=utils.get_available_activation_fns(), + help='activation function to use') + parser.add_argument('--dropout', type=float, metavar='D', + help='dropout probability') + parser.add_argument('--attention-dropout', type=float, metavar='D', + help='dropout probability for attention weights') + parser.add_argument('--activation-dropout', '--relu-dropout', type=float, metavar='D', + help='dropout probability after activation in FFN.') + parser.add_argument('--encoder-embed-path', type=str, metavar='STR', + help='path to pre-trained encoder embedding') + parser.add_argument('--encoder-embed-dim', type=int, metavar='N', + help='encoder embedding dimension') + parser.add_argument('--encoder-ffn-embed-dim', type=int, metavar='N', + help='encoder embedding dimension for FFN') + parser.add_argument('--encoder-layers', type=int, metavar='N', + help='num encoder layers') + parser.add_argument('--encoder-attention-heads', type=int, metavar='N', + help='num encoder attention heads') + parser.add_argument('--encoder-normalize-before', action='store_true', + help='apply layernorm before each encoder block') + parser.add_argument('--encoder-learned-pos', action='store_true', + help='use learned positional embeddings in the encoder') + parser.add_argument('--bitfit', default=False, action='store_true', + help='use bitfit in the transformer') + parser.add_argument('--freeze-encoder', action='store_true', + help='freeze the parameters in the encoder') + + + parser.add_argument('--adapter', action='store_true', + help='use adapter in the model') + parser.add_argument('--adapter-dim', type=int, metavar='N', + help='adapter-down-dim') + ### vl ADAPTER + parser.add_argument('--adapter-type', type=str, metavar='STR', + help='adapter-type') + parser.add_argument('--unfreeze', action='store_true', + help='unfreeze model when using adapters/prompts') + + parser.add_argument('--encoder-prompt', action='store_true', + help='use prompt tuning in the encoder') + parser.add_argument('--encoder-prompt-type', type=str, metavar='STR', + choices=['prefix'], + help='the type of prompt tuning') + parser.add_argument('--encoder-prompt-projection', action='store_true', + help='use prompt projection') + parser.add_argument('--encoder-prompt-length', type=int, metavar='N', + help='use prompt tuning in the decoder') + parser.add_argument('--encoder-prompt-dim', type=int, metavar='N', + help='encoder prompt dimension if use encoder prompt projection') + parser.add_argument('--decoder-embed-path', type=str, metavar='STR', + help='path to pre-trained decoder embedding') + parser.add_argument('--decoder-embed-dim', type=int, metavar='N', + help='decoder embedding dimension') + parser.add_argument('--decoder-ffn-embed-dim', type=int, metavar='N', + help='decoder embedding dimension for FFN') + parser.add_argument('--decoder-layers', type=int, metavar='N', + help='num decoder layers') + parser.add_argument('--decoder-attention-heads', type=int, metavar='N', + help='num decoder attention heads') + parser.add_argument('--decoder-learned-pos', action='store_true', + help='use learned positional embeddings in the decoder') + parser.add_argument('--decoder-normalize-before', action='store_true', + help='apply layernorm before each decoder block') + parser.add_argument('--decoder-output-dim', type=int, metavar='N', + help='decoder output dimension (extra linear layer ' + 'if different from decoder embed dim') + parser.add_argument('--freeze-decoder', action='store_true', + help='freeze the parameters in the decoder') + + parser.add_argument('--decoder-prompt', action='store_true', + help='use prompt tuning in the decoder') + parser.add_argument('--decoder-prompt-type', type=str, metavar='STR', + choices=['prefix'], + help='the type of prompt tuning') + parser.add_argument('--decoder-prompt-length', type=int, metavar='N', + help='use prompt tuning in the decoder') + parser.add_argument('--decoder-prompt-projection', action='store_true', + help='use prompt projection') + parser.add_argument('--decoder-prompt-dim', type=int, metavar='N', + help='decoder prompt dimension if use decoder prompt projection') + parser.add_argument('--share-decoder-input-output-embed', action='store_true', + help='share decoder input and output embeddings') + parser.add_argument('--share-all-embeddings', action='store_true', + help='share encoder, decoder and output embeddings' + ' (requires shared dictionary and embed dim)') + parser.add_argument('--no-token-positional-embeddings', default=False, action='store_true', + help='if set, disables positional embeddings (outside self attention)') + parser.add_argument('--adaptive-softmax-cutoff', metavar='EXPR', + help='comma separated list of adaptive softmax cutoff points. ' + 'Must be used with adaptive_loss criterion'), + parser.add_argument('--adaptive-softmax-dropout', type=float, metavar='D', + help='sets adaptive softmax dropout for the tail projections') + parser.add_argument('--layernorm-embedding', action='store_true', + help='add layernorm to embedding') + parser.add_argument('--no-scale-embedding', action='store_true', + help='if True, dont scale embeddings') + parser.add_argument('--checkpoint-activations', action='store_true', + help='checkpoint activations at each layer, which saves GPU ' + 'memory usage at the cost of some additional compute') + parser.add_argument('--offload-activations', action='store_true', + help='checkpoint activations at each layer, then save to gpu. Sets --checkpoint-activations.') + # args for "Cross+Self-Attention for Transformer Models" (Peitz et al., 2019) + parser.add_argument('--no-cross-attention', default=False, action='store_true', + help='do not perform cross-attention') + parser.add_argument('--cross-self-attention', default=False, action='store_true', + help='perform cross+self-attention') + # args for "Reducing Transformer Depth on Demand with Structured Dropout" (Fan et al., 2019) + parser.add_argument('--encoder-layerdrop', type=float, metavar='D', default=0, + help='LayerDrop probability for encoder') + parser.add_argument('--decoder-layerdrop', type=float, metavar='D', default=0, + help='LayerDrop probability for decoder') + parser.add_argument('--encoder-layers-to-keep', default=None, + help='which layers to *keep* when pruning as a comma-separated list') + parser.add_argument('--decoder-layers-to-keep', default=None, + help='which layers to *keep* when pruning as a comma-separated list') + # args for Training with Quantization Noise for Extreme Model Compression ({Fan*, Stock*} et al., 2020) + parser.add_argument('--quant-noise-pq', type=float, metavar='D', default=0, + help='iterative PQ quantization noise at training time') + parser.add_argument('--quant-noise-pq-block-size', type=int, metavar='D', default=8, + help='block size of quantization noise at training time') + parser.add_argument('--quant-noise-scalar', type=float, metavar='D', default=0, + help='scalar quantization noise and scalar quantization at training time') + # args for Fully Sharded Data Parallel (FSDP) training + parser.add_argument( + '--min-params-to-wrap', type=int, metavar='D', default=DEFAULT_MIN_PARAMS_TO_WRAP, + help=( + 'minimum number of params for a layer to be wrapped with FSDP() when ' + 'training with --ddp-backend=fully_sharded. Smaller values will ' + 'improve memory efficiency, but may make torch.distributed ' + 'communication less efficient due to smaller input sizes. This option ' + 'is set to 0 (i.e., always wrap) when --checkpoint-activations or ' + '--offload-activations are passed.' + ) + ) + + parser.add_argument('--resnet-drop-path-rate', type=float, + help='resnet drop path rate') + parser.add_argument('--encoder-drop-path-rate', type=float, + help='encoder drop path rate') + parser.add_argument('--decoder-drop-path-rate', type=float, + help='encoder drop path rate') + + parser.add_argument('--token-bucket-size', type=int, + help='token bucket size') + parser.add_argument('--image-bucket-size', type=int, + help='image bucket size') + + parser.add_argument('--attn-scale-factor', type=float, + help='attention scale factor') + parser.add_argument('--freeze-resnet', action='store_true', + help='freeze resnet') + parser.add_argument('--freeze-encoder-embedding', action='store_true', + help='freeze encoder token embedding') + parser.add_argument('--freeze-decoder-embedding', action='store_true', + help='freeze decoder token embedding') + parser.add_argument('--add-type-embedding', action='store_true', + help='add source/region/patch type embedding') + parser.add_argument('--add-mm-type-embedding', action='store_true', + help='add source/region/patch type embedding') + + parser.add_argument('--interpolate-position', action='store_true', + help='interpolate position') + + parser.add_argument('--resnet-type', choices=['resnet50', 'resnet101', 'resnet152'], + help='resnet type') + parser.add_argument('--resnet-model-path', type=str, metavar='STR', + help='path to load resnet') + parser.add_argument('--code-image-size', type=int, + help='code image size') + parser.add_argument('--patch-layernorm-embedding', action='store_true', + help='add layernorm to patch embedding') + parser.add_argument('--code-layernorm-embedding', action='store_true', + help='add layernorm to code embedding') + parser.add_argument('--entangle-position-embedding', action='store_true', + help='entangle position embedding') + parser.add_argument('--disable-entangle', action='store_true', + help='disable entangle') + parser.add_argument('--sync-bn', action='store_true', + help='sync batchnorm') + + parser.add_argument('--scale-attn', action='store_true', + help='scale attn') + parser.add_argument('--scale-fc', action='store_true', + help='scale fc') + parser.add_argument('--scale-heads', action='store_true', + help='scale heads') + parser.add_argument('--scale-resids', action='store_true', + help='scale resids') + # fmt: on + + # image encoder + parser.add_argument('--image-encoder-name', type=str, metavar='STR', default='resnet', + help='image_encoder_name') + parser.add_argument('--return-hidden-state-vision', action='store_true', + help='return_hidden_state_vision') + + parser.add_argument('--freeze-image-encoder', action='store_true', + help='freeze_image_encoder') + + parser.add_argument('--nograd', action='store_true', + help='nograd for vis encoder') + + parser.add_argument('--encoder-eval', action='store_true', + help='vision encoder.eval()') + # video + parser.add_argument('--video-encoder-name', type=str, default=None, + help='video_encoder_name') + + parser.add_argument('--video-model-path', type=str, default=None, + help='video_model_path') + parser.add_argument('--freeze-video-encoder', action='store_true', + help='freeze_video_encoder') + + parser.add_argument('--sample-patch-num', type=int, default=None, + help='num of tokens selected at random') + parser.add_argument('--with-cls', action='store_true', + help='with_cls') + + parser.add_argument('--sample-video-patch-num', type=int, default=None, + help='num of tokens selected at random') + # audio + parser.add_argument('--audio-encoder-name', type=str, default=None, + help='audio_encoder_name') + parser.add_argument('--audio-model-path', type=str, default=None, + help='audio_model_path') + parser.add_argument('--freeze-audio-encoder', action='store_true', + help='freeze_audio_encoder') + parser.add_argument('--fusion-type', type=str, default=None, + help='fusion_type') + parser.add_argument('--enable-fusion', action='store_true', + help='enable_fusion') + parser.add_argument('--mel-bins', type=int, default=64, + help='mel_bins') + parser.add_argument('--hop-size', type=int, default=480, + help='hop_size') + parser.add_argument('--sample-audio-patch-num', type=int, default=None, + help='num of tokens selected at random') + parser.add_argument('--fstride', type=int, default=10, + help='fstride') + parser.add_argument('--tstride', type=int, default=10, + help='tstride') + parser.add_argument('--input-tdim', type=int, default=1024, + help='input_tdim') + + + # progressive training + + parser.add_argument('--progressive', action='store_true', + help='progressive') + parser.add_argument('--unfreeze-epoch-encoder', type=int, default=0, + help='unfreeze_epoch_encoder') + parser.add_argument('--unfreeze-epoch-decoder', type=int, default=0, + help='unfreeze_epoch_decoder') + + parser.add_argument('--unfreeze-epoch-image', type=int, default=0, + help='unfreeze_epoch_image') + parser.add_argument('--unfreeze-epoch-video', type=int, default=0, + help='unfreeze_epoch_video') + parser.add_argument('--unfreeze-epoch-audio', type=int, default=0, + help='unfreeze_epoch_audio') + + + ## only linear + parser.add_argument('--only-linear-proj', action='store_true', + help='only_linear_proj') + parser.add_argument('--unfreeze-epoch', type=int, default=0, + help='unfreeze_epoch') + + parser.add_argument('--freeze-perception', action='store_true', + help='freeze_perception') + ## + parser.add_argument('--qk-norm', action='store_true', + help='qk_norm') + + + parser.add_argument('--layernorm-image-embedding', action='store_true', + help='layernorm_image_embedding') + + parser.add_argument('--layernorm-video-embedding', action='store_true', + help='layernorm_video_embedding') + + parser.add_argument('--layernorm-audio-embedding', action='store_true', + help='layernorm_audio_embedding') + + parser.add_argument('--freeze-batchnorm', action='store_true', + help='freeze_batchnorm') + + parser.add_argument('--freeze-resnet-video', action='store_true', + help='freeze resnet video') + + @classmethod + def build_model(cls, args, task): + """Build a new model instance.""" + + # make sure all arguments are present in older models + base_architecture(args) + + if args.encoder_layers_to_keep: + args.encoder_layers = len(args.encoder_layers_to_keep.split(",")) + if args.decoder_layers_to_keep: + args.decoder_layers = len(args.decoder_layers_to_keep.split(",")) + + if getattr(args, "max_source_positions", None) is None: + args.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS + if getattr(args, "max_target_positions", None) is None: + args.max_target_positions = DEFAULT_MAX_TARGET_POSITIONS + + src_dict, tgt_dict = task.source_dictionary, task.target_dictionary + + if args.share_all_embeddings: + if src_dict != tgt_dict: + raise ValueError("--share-all-embeddings requires a joined dictionary") + if args.encoder_embed_dim != args.decoder_embed_dim: + raise ValueError( + "--share-all-embeddings requires --encoder-embed-dim to match --decoder-embed-dim" + ) + if args.decoder_embed_path and ( + args.decoder_embed_path != args.encoder_embed_path + ): + raise ValueError( + "--share-all-embeddings not compatible with --decoder-embed-path" + ) + encoder_embed_tokens = cls.build_embedding( + args, src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = encoder_embed_tokens + args.share_decoder_input_output_embed = True + else: + encoder_embed_tokens = cls.build_embedding( + args, src_dict, args.encoder_embed_dim, args.encoder_embed_path + ) + decoder_embed_tokens = cls.build_embedding( + args, tgt_dict, args.decoder_embed_dim, args.decoder_embed_path + ) + if getattr(args, "freeze_encoder_embedding", False) or getattr( + args, "encoder_prompt", False) or getattr(args, "decoder_prompt", False) or getattr(args, "adapter", False): + encoder_embed_tokens.weight.requires_grad = False + if getattr(args, "freeze_decoder_embedding", False) or getattr( + args, "encoder_prompt", False) or getattr(args, "decoder_prompt", False) or getattr(args, "adapter", False): + decoder_embed_tokens.weight.requires_grad = False + if getattr(args, "offload_activations", False): + args.checkpoint_activations = True # offloading implies checkpointing + encoder = cls.build_encoder(args, src_dict, encoder_embed_tokens) + decoder = cls.build_decoder(args, tgt_dict, decoder_embed_tokens) + + if getattr(args, "freeze_encoder", False): + encoder.requires_grad_(False) + + + encoder.embed_images.requires_grad_(True) + encoder.image_proj.requires_grad_(True) + encoder.embed_image_positions.requires_grad_(True) + + if encoder.layernorm_image_embedding is not None: + encoder.layernorm_image_embedding.requires_grad_(True) + print("freeze image LN") + + if hasattr(encoder, 'embed_videos'): + encoder.embed_videos.requires_grad_(True) + encoder.video_proj.requires_grad_(True) + encoder.embed_video_positions.requires_grad_(True) + + if encoder.layernorm_video_embedding is not None: + encoder.layernorm_video_embedding.requires_grad_(True) + print("freeze audio LN") + + if getattr(args, "audio_encoder_name", False): + encoder.embed_audios.requires_grad_(True) + encoder.audio_proj.requires_grad_(True) + encoder.embed_audio_positions.requires_grad_(True) + if encoder.layernorm_audio_embedding is not None: + encoder.layernorm_audio_embedding.requires_grad_(True) + print("freeze audio LN") + + + + if getattr(args, "freeze_decoder", False): + decoder.requires_grad_(False) + + + if getattr(args, "encoder_prompt", False) or getattr( + args, "decoder_prompt", False) or getattr( + args, "adapter", False): + if not getattr(args, "unfreeze", False): + encoder.requires_grad_(False) + decoder.requires_grad_(False) + if getattr(args, "encoder_prompt", False): + encoder.encoder_prompt_encoder.requires_grad_(True) + if getattr(args, "decoder_prompt", False): + decoder.decoder_prompt_encoder.requires_grad_(True) + if getattr(args, "adapter", False): + for idx, layer in enumerate(encoder.layers): + layer.adapter.requires_grad_(True) + for idx, layer in enumerate(decoder.layers): + layer.adapter.requires_grad_(True) + if getattr(args, "freeze_image_encoder", False): + encoder.embed_images.requires_grad_(False) + + if getattr(args, "freeze_video_encoder", False) and hasattr(encoder, 'embed_videos'): + encoder.embed_videos.requires_grad_(False) + + if getattr(args, "freeze_audio_encoder", False) and hasattr(encoder, 'embed_audios'): + encoder.embed_audios.requires_grad_(False) + + if getattr(args, "freeze_batchnorm", False): + + for n, p in encoder.named_parameters(): + if 'bn' in n: + p.requires_grad = False + print("freeze:", n) + + if hasattr(encoder, 'embed_audios'): + if hasattr(encoder.embed_audios, 'logmel_extractor'): + for param in encoder.embed_audios.logmel_extractor.parameters(): + param.requires_grad = False + + if getattr(args, "encoder_eval", False): + print("Set encoders.eval()") + encoder.embed_images.eval() + + if getattr(args, "video_encoder_name", None): + encoder.embed_videos.eval() + + + if not args.share_all_embeddings: + min_params_to_wrap = getattr( + args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP + ) + # fsdp_wrap is a no-op when --ddp-backend != fully_sharded + encoder = fsdp_wrap(encoder, min_num_params=min_params_to_wrap) + decoder = fsdp_wrap(decoder, min_num_params=min_params_to_wrap) + return cls(args, encoder, decoder) + + @classmethod + def build_embedding(cls, args, dictionary, embed_dim, path=None): + num_embeddings = len(dictionary) + padding_idx = dictionary.pad() + + args.vocab_size = num_embeddings + emb = Embedding(num_embeddings, embed_dim, padding_idx) + # if provided, load from preloaded dictionaries + if path: + embed_dict = utils.parse_embedding(path) + utils.load_embedding(embed_dict, dictionary, emb) + return emb + + @classmethod + def build_encoder(cls, args, src_dict, embed_tokens): + return TransformerEncoder(args, src_dict, embed_tokens) + + @classmethod + def build_decoder(cls, args, tgt_dict, embed_tokens): + return TransformerDecoder( + args, + tgt_dict, + embed_tokens, + no_encoder_attn=getattr(args, "no_cross_attention", False), + ) + + # TorchScript doesn't support optional arguments with variable length (**kwargs). + # Current workaround is to add union of all arguments in child classes. + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + return_all_hiddens: bool = True, + features_only: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Run the forward pass for an encoder-decoder model. + + Copied from the base class, but without ``**kwargs``, + which are not supported by TorchScript. + """ + encoder_out = self.encoder( + src_tokens, src_lengths=src_lengths, return_all_hiddens=return_all_hiddens + ) + decoder_out = self.decoder( + prev_output_tokens, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + return decoder_out + + # Since get_normalized_probs is in the Fairseq Model which is not scriptable, + # I rewrite the get_normalized_probs from Base Class to call the + # helper function in the Base Class. + @torch.jit.export + def get_normalized_probs( + self, + net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], + log_probs: bool, + sample: Optional[Dict[str, Tensor]] = None, + ): + """Get normalized probabilities (or log probs) from a net's output.""" + return self.get_normalized_probs_scriptable(net_output, log_probs, sample) + + +class TransformerEncoder(FairseqEncoder): + """ + Transformer encoder consisting of *args.encoder_layers* layers. Each layer + is a :class:`TransformerEncoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): encoding dictionary + embed_tokens (torch.nn.Embedding): input embedding + """ + + def __init__(self, args, dictionary, embed_tokens): + self.args = args + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + + + self.freeze_image_encoder = getattr(args, "freeze_image_encoder", False) + self.freeze_video_encoder = getattr(args, "freeze_video_encoder", False) + self.nograd = getattr(args, "nograd", False) + self.num_frames = getattr(args, 'num_frames', 4) + + self.sample_patch_num = getattr(args, "sample_patch_num", 196) + + self.sample_audio_patch_num = getattr(args, "sample_audio_patch_num", self.sample_patch_num) + self.sample_video_patch_num = getattr(args, "sample_video_patch_num", self.sample_patch_num) + + self.with_cls = getattr(args, "with_cls", False) + print("self.sample_patch_num", self.sample_patch_num) + print("self.sample_audio_patch_num", self.sample_audio_patch_num) + print("self.sample_video_patch_num", self.sample_video_patch_num) + print("self.with_cls", self.with_cls) + + if getattr(args, "encoder_prompt", False): + self.encoder_prompt_encoder = PromptEncoder( + type=args.encoder_prompt_type, + length=args.encoder_prompt_length, + projection=args.encoder_prompt_projection, + embed_dim=args.encoder_embed_dim, + proj_dim=args.encoder_prompt_dim, + layers=args.encoder_layers, + vocab_size=args.vocab_size) + self.encoder_dropout = nn.Dropout(p=0.2) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.encoder_layerdrop = args.encoder_layerdrop + + embed_dim = embed_tokens.embedding_dim + self.padding_idx = embed_tokens.padding_idx + self.max_source_positions = args.max_source_positions + self.num_attention_heads = args.encoder_attention_heads + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if args.no_scale_embedding else math.sqrt(embed_dim) + + if getattr(args, "layernorm_embedding", False): + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + self.mm_type_embedding = False + if getattr(args, "add_mm_type_embedding", False): + self.type_embedding = Embedding(4, embed_dim, padding_idx=None) + self.mm_type_embedding = True + elif getattr(args, "add_type_embedding", False): + self.type_embedding = Embedding(2, embed_dim, padding_idx=None) + else: + self.type_embedding = None + + norm_layer = None + norm_layer_video = None + if getattr(args, "sync_bn", False): + norm_layer = BatchNorm2d + else: + if getattr(args, "freeze_resnet", False): # or getattr(args, "freeze_batchnorm", False) + norm_layer = FrozenBatchNorm2d + print("Frozen image bn", norm_layer) + if getattr(args, "freeze_resnet_video", False): + norm_layer_video = FrozenBatchNorm2d + print("Frozen video bn", norm_layer_video) + + + + if getattr(args, "image_encoder_name", None): + + if 'timm_resnet' in args.image_encoder_name: + if args.resnet_type == 'resnet101': + self.embed_images = resnet101(norm_layer=norm_layer) + elif args.resnet_type == 'resnet152': + self.embed_images = resnet152(norm_layer=norm_layer) + elif args.resnet_type == 'resnet50': + self.embed_images = resnet50(norm_layer=norm_layer) + else: + raise NotImplementedError + self.image_proj = Linear(2048, embed_dim) + else: + if args.resnet_type == 'resnet101': + self.embed_images = ResNet([3, 4, 23], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet152': + self.embed_images = ResNet([3, 8, 36], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet50': + self.embed_images = ResNet([3, 4, 6], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + else: + raise NotImplementedError + self.image_proj = Linear(1024, embed_dim) + else: + if args.resnet_type == 'resnet101': + self.embed_images = ResNet([3, 4, 23], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet152': + self.embed_images = ResNet([3, 8, 36], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + elif args.resnet_type == 'resnet50': + self.embed_images = ResNet([3, 4, 6], norm_layer=norm_layer, drop_path_rate=args.resnet_drop_path_rate) + else: + raise NotImplementedError + self.image_proj = Linear(1024, embed_dim) + + if getattr(args, "layernorm_image_embedding", False): + self.layernorm_image_embedding = LayerNorm(embed_dim) + else: + self.layernorm_image_embedding = None + + + ## video + if getattr(args, "video_encoder_name", None): + print("Loading: ", args.video_encoder_name) + patch_frame_size = getattr(args, 'patch_frame_size', 224) + num_frames = getattr(args, 'num_frames', 4) + pretrained_model = getattr(args, "video_model_path", None) + + if 'resnext' in args.video_encoder_name: + + if 'all' in args.video_encoder_name: + if 'resnext101' in args.video_encoder_name : + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 4, 23, 3], norm_layer=norm_layer_video) + elif 'resnext152' in args.video_encoder_name: + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 8, 36, 3], norm_layer=norm_layer_video) + elif 'resnext50' in args.video_encoder_name: + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 4, 6, 3], norm_layer=norm_layer_video) + else: + raise NotImplementedError + vis_dim = 2048 + else: + if args.video_encoder_name == 'resnext101': + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 4, 23]) + elif args.video_encoder_name == 'resnext152': + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 8, 36]) + elif args.video_encoder_name == 'resnext50': + self.embed_videos = ResNeXt3D(ResNeXtBottleneck, [3, 4, 6]) + else: + raise NotImplementedError + vis_dim = 1024 + + self.embed_video_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + + if pretrained_model: + print("load pretrained_model {}".format(pretrained_model)) + state_dict = torch.load(pretrained_model)['state_dict'] + if 'module' in list(state_dict.keys())[0]: + from collections import OrderedDict + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + name = k[7:] # remove 'module.' of dataparallel + new_state_dict[name]=v + state_dict = new_state_dict + + msg = self.embed_videos.load_state_dict(state_dict, strict=False) + print(msg) + + else: + raise NotImplemented + + + self.video_proj = Linear(vis_dim, embed_dim) + + + if getattr(args, "layernorm_video_embedding", False): + self.layernorm_video_embedding = LayerNorm(embed_dim) + else: + self.layernorm_video_embedding = None + + ## video + if getattr(args, "audio_encoder_name", None): + print("Loading: ", args.audio_encoder_name) + + + + pretrained_audio_model = getattr(args, "audio_model_path", None) + audio_cfg = getattr(args, "audio_cfg", None) + audio_cfg = audio_cfg if audio_cfg is not None else AUDIO_CFG + + audio_cfg = dotdict(audio_cfg) + enable_fusion = getattr(args, "enable_fusion", False) + fusion_type = getattr(args, "fusion_type", None) + + audio_cfg['mel_bins'] = getattr(args, "mel_bins", 64) + audio_cfg['hop_size'] = getattr(args, "hop_size", 480) + + if 'pann' in args.audio_encoder_name: + + if 'cnn6' in args.audio_encoder_name: + audio_cfg['model_name'] = 'Cnn6' + audio_dim = 512 + elif 'cnn10' in args.audio_encoder_name: + audio_cfg['model_name'] = 'Cnn10' + audio_dim = 1024 + elif 'cnn14' in args.audio_encoder_name: + audio_cfg['model_name'] = 'Cnn14' + # audio_dim = 512 + audio_dim = 2048 + else: + raise NotImplementedError + + self.embed_audios = create_pann_model(audio_cfg, enable_fusion, fusion_type) + + + self.embed_audio_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + + + + if pretrained_audio_model: + print("load pretrained_model {}".format(pretrained_audio_model)) + state_dict = torch.load(pretrained_audio_model) + if 'model' in state_dict: + state_dict = state_dict['model'] + + if 'module' in list(state_dict.keys())[0]: + from collections import OrderedDict + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + name = k.replace('module.', '') # remove 'module.' of dataparallel + new_state_dict[name]=v + state_dict = new_state_dict + + if 'sed_model.' in list(state_dict.keys())[0] or 'module.' in list(state_dict.keys())[0]: + from collections import OrderedDict + new_state_dict = OrderedDict() + for k, v in state_dict.items(): + name = k.replace('sed_model.', '').replace('module.', '').replace('audio_branch.', '') # remove 'module.' of dataparallel + new_state_dict[name]=v + state_dict = new_state_dict + + if audio_cfg['mel_bins'] != 64: + + del_keys = [] + for k, v in state_dict.items(): + if 'logmel_extractor' in k or 'bn0' in k: + del_keys.append(k) + + for k in del_keys: + del state_dict[k] + + msg = self.embed_audios.load_state_dict(state_dict, strict=False) + print(msg) + + else: + raise NotImplementedError + + self.audio_proj = Linear(audio_dim, embed_dim) + + + if getattr(args, "layernorm_audio_embedding", False): + self.layernorm_audio_embedding = LayerNorm(embed_dim) + else: + self.layernorm_audio_embedding = None + + + if getattr(args, "resnet_model_path", None): + print("load resnet {}".format(args.resnet_model_path)) + resnet_state_dict = torch.load(self.args.resnet_model_path) + msg = self.embed_images.load_state_dict(resnet_state_dict, strict=False) + print(msg) + + if getattr(args, "patch_layernorm_embedding", False): + self.patch_layernorm_embedding = LayerNorm(embed_dim) + else: + self.patch_layernorm_embedding = None + + self.embed_positions = Embedding(args.max_source_positions + 2, embed_dim) + self.embed_image_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + self.pos_ln = LayerNorm(embed_dim) + self.image_pos_ln = LayerNorm(embed_dim) + self.pos_scaling = float(embed_dim / args.encoder_attention_heads * args.attn_scale_factor) ** -0.5 + self.pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.pos_k_linear = nn.Linear(embed_dim, embed_dim) + + if not args.adaptive_input and args.quant_noise_pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + args.quant_noise_pq, + args.quant_noise_pq_block_size, + ) + else: + self.quant_noise = None + + if self.encoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.encoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + + dpr = [x.item() for x in torch.linspace(0, args.encoder_drop_path_rate, args.encoder_layers)] + self.layers.extend( + [self.build_encoder_layer(args, drop_path_rate=dpr[i]) for i in range(args.encoder_layers)] + ) + self.num_layers = len(self.layers) + + if args.encoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + token_bucket_size = args.token_bucket_size + token_num_rel_dis = 2 * token_bucket_size - 1 + token_rp_bucket = make_token_bucket_position(token_bucket_size) + self.token_rel_pos_table_list = nn.ModuleList( + [Embedding(token_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.encoder_layers)] + ) + + image_bucket_size = args.image_bucket_size + image_num_rel_dis = (2 * image_bucket_size - 1) * (2 * image_bucket_size - 1) + 3 + image_rp_bucket = make_image_bucket_position(image_bucket_size, image_num_rel_dis) + self.image_rel_pos_table_list = nn.ModuleList( + [Embedding(image_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.encoder_layers)] + ) + + self.patch_image_size = args.patch_image_size + self.orig_patch_image_size = args.orig_patch_image_size + + self.register_buffer("token_rp_bucket", token_rp_bucket) + self.register_buffer("image_rp_bucket", image_rp_bucket) + self.entangle_position_embedding = args.entangle_position_embedding + + + def build_encoder_layer(self, args, drop_path_rate=0.0): + layer = TransformerEncoderLayer(args, drop_path_rate=drop_path_rate, \ + use_adapter=getattr(args, "adapter", False), adapter_dim=getattr(args, "adapter_dim", 200), + adapter_type=getattr(args, "adapter_type", 'UN')) + checkpoint = getattr(args, "checkpoint_activations", False) + if checkpoint: + offload_to_cpu = getattr(args, "offload_activations", False) + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = ( + getattr(args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP) + if not checkpoint else 0 + ) + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def get_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + rp_bucket = self.token_rp_bucket[:seq_len, :seq_len] + values = F.embedding(rp_bucket, self.token_rel_pos_table_list[idx].weight) + values = values.unsqueeze(0).expand(x.size(0), -1, -1, -1) + values = values.permute([0, 3, 1, 2]) + return values.contiguous() + + def get_image_rel_pos_bias(self, image_position_ids, idx): + bsz, seq_len = image_position_ids.shape + rp_bucket_size = self.image_rp_bucket.size(1) + + rp_bucket = self.image_rp_bucket.unsqueeze(0).expand( + bsz, rp_bucket_size, rp_bucket_size + ).gather(1, image_position_ids[:, :, None].expand(bsz, seq_len, rp_bucket_size) + ).gather(2, image_position_ids[:, None, :].expand(bsz, seq_len, seq_len)) + values = F.embedding(rp_bucket, self.image_rel_pos_table_list[idx].weight) + values = values.permute(0, 3, 1, 2) + return values + + def get_patch_audios_info(self, patch_images, sample_patch_num, device): + + if self.nograd and self.freeze_audio_encoder: + with torch.no_grad(): + image_embed = self.embed_audios(patch_images) + else: + image_embed = self.embed_audios(patch_images) + + # in case of cnn (bs, c, h, w) + h, w = image_embed.shape[-2:] + image_num_patches = h * w + sh = int(math.ceil(math.sqrt(image_num_patches))) # to keep within image_bucket_size + sw = sh + image_embed = image_embed.flatten(2).transpose(1, 2) # (bs, c, hlw) -> (bs, hlw, c) + + image_padding_mask = patch_images.new_zeros((patch_images.size(0), image_num_patches)).bool() + + image_position_idx = torch.arange(sw).unsqueeze(0).expand(sh, sw) + \ + torch.arange(sh).unsqueeze(1) * self.args.image_bucket_size + 1 + image_position_idx = image_position_idx.reshape(-1).to(device)[:image_num_patches] + image_position_ids = image_position_idx[None, :].expand(patch_images.size(0), image_num_patches) + + if sample_patch_num is not None and sample_patch_num < image_num_patches: + patch_orders = [ + random.sample(range(image_num_patches), k=sample_patch_num) + for _ in range(patch_images.size(0)) + ] + patch_orders = torch.LongTensor(patch_orders).to(device) + image_embed = image_embed.gather( + 1, patch_orders.unsqueeze(2).expand(-1, -1, image_embed.size(2)) + ) + image_num_patches = sample_patch_num + image_padding_mask = image_padding_mask.gather(1, patch_orders) + image_position_ids = image_position_ids.gather(1, patch_orders) + + image_pos_embed = self.embed_audio_positions(image_position_ids) + + + image_embed = self.audio_proj(image_embed.type(self.audio_proj.weight.dtype)) + + if self.layernorm_audio_embedding is not None: + image_embed = self.layernorm_audio_embedding(image_embed) + + return image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed + + + def get_patch_videos_info(self, patch_images, sample_patch_num, device): + if self.nograd and self.freeze_video_encoder: + with torch.no_grad(): + _, image_embed = self.embed_videos(patch_images) + else: + _, image_embed = self.embed_videos(patch_images) + + l, h, w = image_embed.shape[-3:] + image_num_patches = h * w * l + image_embed = image_embed.flatten(2).transpose(1, 2) # (bs, c, hlw) -> (bs, hlw, c) + numframes = l + + image_padding_mask = patch_images.new_zeros((patch_images.size(0), image_num_patches)).bool() + + image_position_idx = torch.arange(w).unsqueeze(0).expand(h, w) + \ + torch.arange(h).unsqueeze(1) * self.args.image_bucket_size + 1 + image_position_idx = image_position_idx.unsqueeze(0).expand(numframes, -1, -1) + image_position_idx = image_position_idx.reshape(-1).to(device) + image_position_ids = image_position_idx[None, :].expand(patch_images.size(0), image_num_patches) + + if sample_patch_num is not None and sample_patch_num < image_num_patches: + patch_orders = [ + random.sample(range(image_num_patches), k=sample_patch_num) + for _ in range(patch_images.size(0)) + ] + patch_orders = torch.LongTensor(patch_orders).to(device) + image_embed = image_embed.gather( + 1, patch_orders.unsqueeze(2).expand(-1, -1, image_embed.size(2)) + ) + image_num_patches = sample_patch_num + image_padding_mask = image_padding_mask.gather(1, patch_orders) + image_position_ids = image_position_ids.gather(1, patch_orders) + + image_pos_embed = self.embed_video_positions(image_position_ids) + + + image_embed = self.video_proj(image_embed) + + if self.layernorm_video_embedding is not None: + image_embed = self.layernorm_video_embedding(image_embed) + + return image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed + + def get_patch_images_info(self, patch_images, sample_patch_num, device): + if self.nograd and self.freeze_image_encoder: + with torch.no_grad(): + image_embed = self.embed_images(patch_images) + else: + image_embed = self.embed_images(patch_images) + + if isinstance(image_embed, tuple): + _, image_embed = image_embed + + h, w = image_embed.shape[-2:] + image_num_patches = h * w + image_embed = image_embed.flatten(2).transpose(1, 2) + image_padding_mask = patch_images.new_zeros((patch_images.size(0), image_num_patches)).bool() + image_position_idx = torch.arange(w).unsqueeze(0).expand(h, w) + \ + torch.arange(h).unsqueeze(1) * self.args.image_bucket_size + 1 + image_position_idx = image_position_idx.view(-1).to(device) + image_position_ids = image_position_idx[None, :].expand(patch_images.size(0), image_num_patches) + + if sample_patch_num is not None and sample_patch_num < image_num_patches: + patch_orders = [ + random.sample(range(image_num_patches), k=sample_patch_num) + for _ in range(patch_images.size(0)) + ] + patch_orders = torch.LongTensor(patch_orders).to(device) + image_embed = image_embed.gather( + 1, patch_orders.unsqueeze(2).expand(-1, -1, image_embed.size(2)) + ) + image_num_patches = sample_patch_num + image_padding_mask = image_padding_mask.gather(1, patch_orders) + image_position_ids = image_position_ids.gather(1, patch_orders) + orig_num_patches = (self.orig_patch_image_size // 16) ** 2 + orig_hw= self.orig_patch_image_size // 16 + if getattr(self.args, "interpolate_position", False) and image_num_patches > orig_num_patches: + old_image_position_ids = torch.arange(orig_hw).unsqueeze(0).expand(orig_hw, orig_hw) + \ + torch.arange(orig_hw).unsqueeze(1) * self.args.image_bucket_size + 1 + old_image_position_ids = old_image_position_ids.to(device) + old_image_pos_embed = self.embed_image_positions(old_image_position_ids) + old_image_pos_embed = old_image_pos_embed.reshape(1, orig_hw, orig_hw, -1).permute(0, 3, 1, 2) + image_pos_embed = F.interpolate(old_image_pos_embed, size=(h, w), mode='bilinear') + image_pos_embed = image_pos_embed.permute(0, 2, 3, 1).reshape(1, image_num_patches, -1) + image_pos_embed = image_pos_embed.expand(patch_images.size(0), -1, -1) + else: + image_pos_embed = self.embed_image_positions(image_position_ids) + + + + image_embed = self.image_proj(image_embed) + if self.layernorm_image_embedding is not None: + image_embed = self.layernorm_image_embedding(image_embed) + + return image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed + + def get_encoder_prompt(self, prompt_tokens): + past_key_values = self.encoder_prompt_encoder(prompt_tokens) + bsz, seqlen, _ = past_key_values.shape + past_key_values = past_key_values.view( + bsz, + seqlen, + (self.args.encoder_layers) * 2, + self.args.encoder_attention_heads, + self.args.encoder_embed_dim // self.args.encoder_attention_heads, + ) + past_key_values = self.encoder_dropout(past_key_values) + past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(2) + return past_key_values + + def forward_embedding( + self, + src_tokens, + image_embed: Optional[torch.Tensor] = None, + image_embed_2: Optional[torch.Tensor] = None, + token_embedding: Optional[torch.Tensor] = None, + pos_embed: Optional[torch.Tensor] = None, + image_pos_embed: Optional[torch.Tensor] = None, + image_pos_embed_2: Optional[torch.Tensor] = None, + patch_types: Optional[torch.Tensor] = None, + ): + # embed tokens and positions + if token_embedding is None: + token_embedding = self.embed_tokens(src_tokens) + x = embed = self.embed_scale * token_embedding + if self.entangle_position_embedding and pos_embed is not None: + x += pos_embed + if self.type_embedding is not None: + x += self.type_embedding(src_tokens.new_zeros(x.size()[:2])) + if self.layernorm_embedding is not None: + x = self.layernorm_embedding(x) + x = self.dropout_module(x) + if self.quant_noise is not None: + x = self.quant_noise(x) + + # embed raw images + if image_embed is not None: + # image_embed = self.image_proj(image_embed) + image_x = image_embed = self.embed_scale * image_embed + if self.entangle_position_embedding and image_pos_embed is not None: + image_x += image_pos_embed[:, -image_x.shape[1]:, :] # account for cls token + if self.type_embedding is not None: + if self.mm_type_embedding: + mm_type = patch_types.unsqueeze(1).to(src_tokens.device) + 1 # 0 for text + image_x += self.type_embedding(mm_type) + else: + image_x += self.type_embedding(src_tokens.new_ones(image_x.size()[:2])) + if self.patch_layernorm_embedding is not None: + image_x = self.patch_layernorm_embedding(image_x) + image_x = self.dropout_module(image_x) + if self.quant_noise is not None: + image_x = self.quant_noise(image_x) + x = torch.cat([image_x, x], dim=1) + embed = torch.cat([image_embed, embed], dim=1) + + if image_embed_2 is not None: + assert self.type_embedding is not None + # image_embed_2 = self.image_proj(image_embed_2) + image_x_2 = image_embed_2 = self.embed_scale * image_embed_2 + if self.entangle_position_embedding and image_pos_embed_2 is not None: + image_x_2 += image_pos_embed_2[:, -image_x_2.shape[1]:, :] + if self.type_embedding is not None: + image_x_2 += self.type_embedding(src_tokens.new_full(image_x_2.size()[:2], fill_value=2)) + if self.patch_layernorm_embedding is not None: + image_x_2 = self.patch_layernorm_embedding(image_x_2) + image_x_2 = self.dropout_module(image_x_2) + if self.quant_noise is not None: + image_x_2 = self.quant_noise(image_x_2) + x = torch.cat([image_x_2, x], dim=1) + embed = torch.cat([image_embed_2, embed], dim=1) + + return x, embed + + def forward( + self, + src_tokens, + src_lengths, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + code_masks: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None, + patch_videos: Optional[int] = None, + patch_types: Optional[torch.Tensor] = None, + patch_audios: Optional[torch.Tensor] = None, + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + return self.forward_scriptable(src_tokens, + src_lengths, + patch_images, + patch_images_2, + patch_masks, + return_all_hiddens, + token_embeddings, + self.sample_patch_num, + patch_videos=patch_videos, + patch_types=patch_types, + patch_audios=patch_audios, + sample_audio_patch_num=self.sample_audio_patch_num, + sample_video_patch_num=self.sample_video_patch_num) + + # TorchScript doesn't support super() method so that the scriptable Subclass + # can't access the base class model in Torchscript. + # Current workaround is to add a helper function with different name and + # call the helper function from scriptable Subclass. + def forward_scriptable( + self, + src_tokens, + src_lengths, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + token_embeddings: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None, + patch_videos: Optional[int] = None, + patch_types: Optional[torch.Tensor] = None, + patch_audios: Optional[int] = None, + sample_audio_patch_num: Optional[int] = None, + sample_video_patch_num: Optional[int] = None, + ): + """ + Args: + src_tokens (LongTensor): tokens in the source language of shape + `(batch, src_len)` + src_lengths (torch.LongTensor): lengths of each source sentence of + shape `(batch)` + return_all_hiddens (bool, optional): also return all of the + intermediate hidden states (default: False). + token_embeddings (torch.Tensor, optional): precomputed embeddings + default `None` will recompute embeddings + + Returns: + dict: + - **encoder_out** (Tensor): the last encoder layer's output of + shape `(src_len, batch, embed_dim)` + - **encoder_padding_mask** (ByteTensor): the positions of + padding elements of shape `(batch, src_len)` + - **encoder_embedding** (Tensor): the (scaled) embedding lookup + of shape `(batch, src_len, embed_dim)` + - **encoder_states** (List[Tensor]): all intermediate + hidden states of shape `(src_len, batch, embed_dim)`. + Only populated if *return_all_hiddens* is True. + """ + prompt_tokens = None + prompt_padding_mask = None + prompt_kv_list = None + if self.args.encoder_prompt: + bsz, seq_len = src_tokens.shape[0], src_tokens.shape[1] + if self.args.encoder_prompt_type in ("prefix"): + prompt_tokens = torch.arange( + 0, self.args.encoder_prompt_length).to( + src_tokens.device) + prompt_tokens = prompt_tokens.unsqueeze(0).expand(bsz, -1) + prompt_padding_mask = torch.zeros_like(prompt_tokens).to(prompt_tokens.device) + prompt_kv_list = self.get_encoder_prompt(prompt_tokens) + image_embed = None + image_embed_2 = None + image_pos_embed = None + image_pos_embed_2 = None + num_image_tokens = None + + if sample_audio_patch_num is None: + sample_audio_patch_num = sample_patch_num + + if sample_video_patch_num is None: + sample_video_patch_num = sample_patch_num + + if patch_images is not None: + + if patch_types is not None: + video_idx = patch_types==1 + image_idx = patch_types==0 + audio_idx = patch_types==2 + + image_idx_ = (patch_types==0).nonzero()[:, 0] + video_idx_ = (patch_types==1).nonzero()[:, 0] + audio_idx_ = (patch_types==2).nonzero()[:, 0] + + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = None,None,None,None,None + # print(image_idx_, video_idx_, audio_idx_) + if torch.any(image_idx).item(): + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = \ + self.get_patch_images_info(patch_images, sample_patch_num, src_tokens.device) + + ids_merge = image_idx_ + + if torch.any(video_idx).item(): + video_embed, image_num_patches, video_padding_mask, video_position_ids, video_pos_embed = \ + self.get_patch_videos_info(patch_videos[video_idx], sample_video_patch_num, src_tokens.device) + + if image_embed is not None: + ids_merge = torch.cat((ids_merge, video_idx_), dim=0).long() + + image_embed = torch.cat((image_embed, video_embed), dim=0) + bs, L, D = image_embed.shape + image_padding_mask = torch.cat((image_padding_mask, video_padding_mask), dim=0) + image_position_ids = torch.cat((image_position_ids, video_position_ids), dim=0) + image_pos_embed = torch.cat((image_pos_embed, video_pos_embed), dim=0) + + image_embed = torch.gather(image_embed, dim=0, index=ids_merge[:, None, None].repeat(1, L, D)) + image_padding_mask = torch.gather(image_padding_mask, dim=0, index=ids_merge[:, None].repeat(1, image_padding_mask.shape[1])) + image_position_ids = torch.gather(image_position_ids, dim=0, index=ids_merge[:, None].repeat(1, image_position_ids.shape[1])) + image_pos_embed = torch.gather(image_pos_embed, dim=0, index=ids_merge[:, None, None].repeat(1, image_pos_embed.shape[1], D)) + + else: + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = \ + video_embed, image_num_patches, video_padding_mask, video_position_ids, video_pos_embed + ids_merge = video_idx_ + + if torch.any(audio_idx).item() : # or image_embed is None + audio_embed, image_num_patches, audio_padding_mask, audio_position_ids, audio_pos_embed = \ + self.get_patch_audios_info(patch_audios[audio_idx], sample_audio_patch_num, src_tokens.device) + + if image_embed is not None: + + ids_merge = torch.cat((ids_merge, audio_idx_), dim=0).long() + + + image_embed = torch.cat((image_embed, audio_embed), dim=0) + bs, L, D = image_embed.shape + image_padding_mask = torch.cat((image_padding_mask, audio_padding_mask), dim=0) + image_position_ids = torch.cat((image_position_ids, audio_position_ids), dim=0) + image_pos_embed = torch.cat((image_pos_embed, audio_pos_embed), dim=0) + + image_embed = torch.gather(image_embed, dim=0, index=ids_merge[:, None, None].repeat(1, L, D)) + image_padding_mask = torch.gather(image_padding_mask, dim=0, index=ids_merge[:, None].repeat(1, image_padding_mask.shape[1])) + image_position_ids = torch.gather(image_position_ids, dim=0, index=ids_merge[:, None].repeat(1, image_position_ids.shape[1])) + image_pos_embed = torch.gather(image_pos_embed, dim=0, index=ids_merge[:, None, None].repeat(1, image_pos_embed.shape[1], D)) + + else: + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = \ + audio_embed, image_num_patches, audio_padding_mask, audio_position_ids, audio_pos_embed + + else: + image_embed, image_num_patches, image_padding_mask, image_position_ids, image_pos_embed = \ + self.get_patch_images_info(patch_images, sample_patch_num, src_tokens.device) + + image_padding_mask[~patch_masks] = True + + num_image_tokens=image_num_patches + if patch_images_2 is not None: + image_embed_2, image_num_patches_2, image_padding_mask_2, image_position_ids_2, image_pos_embed_2 = \ + self.get_patch_images_info(patch_images_2, sample_patch_num, src_tokens.device) + image_padding_mask_2[~patch_masks] = True + num_image_tokens+=image_num_patches_2 + + encoder_padding_mask = src_tokens.eq(self.padding_idx) + if patch_images is not None: + encoder_padding_mask = torch.cat([image_padding_mask, encoder_padding_mask], dim=1) + if patch_images_2 is not None: + encoder_padding_mask = torch.cat([image_padding_mask_2, encoder_padding_mask], dim=1) + has_pads = (src_tokens.device.type == "xla" or encoder_padding_mask.any()) + + pos_embed = self.embed_positions(utils.new_arange(src_tokens)) + x, encoder_embedding = self.forward_embedding( + src_tokens, image_embed, image_embed_2, token_embeddings, + pos_embed, image_pos_embed, image_pos_embed_2, patch_types=patch_types + ) + + # account for padding while computing the representation + if has_pads: + x = x * (1 - encoder_padding_mask.unsqueeze(-1).type_as(x)) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + pos_embed = self.pos_ln(pos_embed) + if patch_images is not None: + image_pos_embed = self.image_pos_ln(image_pos_embed) + pos_embed = torch.cat([image_pos_embed, pos_embed], dim=1) + if patch_images_2 is not None: + image_pos_embed_2 = self.image_pos_ln(image_pos_embed_2) + pos_embed = torch.cat([image_pos_embed_2, pos_embed], dim=1) + + pos_q = self.pos_q_linear(pos_embed).view( + pos_embed.size(0), pos_embed.size(1), self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.pos_k_linear(pos_embed).view( + pos_embed.size(0), pos_embed.size(1), self.num_attention_heads, -1 + ).transpose(1, 2) + abs_pos_bias = torch.matmul(pos_q, pos_k.transpose(2, 3)) + + encoder_states = [] + + if return_all_hiddens: + encoder_states.append(x) + + if prompt_padding_mask is not None: + encoder_padding_mask = torch.cat([prompt_padding_mask, encoder_padding_mask], dim=1) + # encoder layers + if self.with_cls: + offset_rel_pos = 1 + abs_pos_bias = F.pad(abs_pos_bias, (1, 0, 1, 0), "constant", 0) + else: + offset_rel_pos = 0 + + for idx, layer in enumerate(self.layers): + self_attn_bias = abs_pos_bias.clone() + self_attn_bias[:, :, -src_tokens.size(1):, -src_tokens.size(1):] += self.get_rel_pos_bias(src_tokens, idx) + if patch_images_2 is not None: + self_attn_bias[:, :, offset_rel_pos:image_num_patches_2, offset_rel_pos:image_num_patches_2] += \ + self.get_image_rel_pos_bias(image_position_ids_2, idx) + self_attn_bias[:, :, offset_rel_pos+image_num_patches_2:image_num_patches_2+image_num_patches, offset_rel_pos+image_num_patches_2:image_num_patches_2+image_num_patches] += \ + self.get_image_rel_pos_bias(image_position_ids, idx) + elif patch_images is not None: + self_attn_bias[:, :, offset_rel_pos:x.size(0) - src_tokens.size(1), offset_rel_pos:x.size(0) - src_tokens.size(1)] += \ + self.get_image_rel_pos_bias(image_position_ids, idx) + + self_attn_bias = self_attn_bias.reshape(-1, self_attn_bias.size(2), self_attn_bias.size(2)) + + if self.args.encoder_prompt: + if self.args.encoder_prompt_type != "prompt": + prompt_kv = prompt_kv_list[idx] + else: + if idx == 0: + prompt_kv = prompt_kv_list[idx] + else: + prompt_kv = None + else: + prompt_kv = None + x = layer(x, encoder_padding_mask=encoder_padding_mask if has_pads else None, \ + self_attn_bias=self_attn_bias, prompt_kv=prompt_kv, num_image_tokens=num_image_tokens) + if return_all_hiddens: + assert encoder_states is not None + encoder_states.append(x) + + if self.layer_norm is not None: + x = self.layer_norm(x) + if self.args.encoder_prompt: + encoder_padding_mask = encoder_padding_mask[:, prompt_tokens.size(1):] + # The Pytorch Mobile lite interpreter does not supports returning NamedTuple in + # `forward` so we use a dictionary instead. + # TorchScript does not support mixed values so the values are all lists. + # The empty list is equivalent to None. + return { + "encoder_out": [x], # T x B x C + "encoder_padding_mask": [encoder_padding_mask], # B x T + "encoder_embedding": [], # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": [], + "src_lengths": [], + "position_embeddings": [pos_embed], # B x T x C + } + + @torch.jit.export + def reorder_encoder_out(self, encoder_out: Dict[str, List[Tensor]], new_order): + """ + Reorder encoder output according to *new_order*. + + Args: + encoder_out: output from the ``forward()`` method + new_order (LongTensor): desired order + + Returns: + *encoder_out* rearranged according to *new_order* + """ + if len(encoder_out["encoder_out"]) == 0: + new_encoder_out = [] + else: + new_encoder_out = [encoder_out["encoder_out"][0].index_select(1, new_order)] + if len(encoder_out["encoder_padding_mask"]) == 0: + new_encoder_padding_mask = [] + else: + new_encoder_padding_mask = [ + encoder_out["encoder_padding_mask"][0].index_select(0, new_order) + ] + if len(encoder_out["encoder_embedding"]) == 0: + new_encoder_embedding = [] + else: + new_encoder_embedding = [ + encoder_out["encoder_embedding"][0].index_select(0, new_order) + ] + + if len(encoder_out["src_tokens"]) == 0: + new_src_tokens = [] + else: + new_src_tokens = [(encoder_out["src_tokens"][0]).index_select(0, new_order)] + + if len(encoder_out["src_lengths"]) == 0: + new_src_lengths = [] + else: + new_src_lengths = [(encoder_out["src_lengths"][0]).index_select(0, new_order)] + + if len(encoder_out["position_embeddings"]) == 0: + new_position_embeddings = [] + else: + new_position_embeddings = [(encoder_out["position_embeddings"][0]).index_select(0, new_order)] + + encoder_states = encoder_out["encoder_states"] + if len(encoder_states) > 0: + for idx, state in enumerate(encoder_states): + encoder_states[idx] = state.index_select(1, new_order) + + return { + "encoder_out": new_encoder_out, # T x B x C + "encoder_padding_mask": new_encoder_padding_mask, # B x T + "encoder_embedding": new_encoder_embedding, # B x T x C + "encoder_states": encoder_states, # List[T x B x C] + "src_tokens": new_src_tokens, # B x T + "src_lengths": new_src_lengths, # B x 1 + "position_embeddings": new_position_embeddings, # B x T x C + } + + def max_positions(self): + """Maximum input length supported by the encoder.""" + if self.embed_positions is None: + return self.max_source_positions + return self.max_source_positions + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + print("deleting {0}".format(weights_key)) + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + for i in range(self.num_layers): + # update layer norms + self.layers[i].upgrade_state_dict_named( + state_dict, "{}.layers.{}".format(name, i) + ) + + prefix = name + "." if name != "" else "" + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] + + if len(state_dict["encoder.embed_image_positions.weight"]) < len(self.state_dict()["embed_image_positions.weight"]): + num_posids_to_add = len(self.state_dict()["embed_image_positions.weight"]) - len(state_dict["encoder.embed_image_positions.weight"]) + embed_dim = state_dict["encoder.embed_image_positions.weight"].size(1) + new_pos_embed_to_add = torch.zeros(num_posids_to_add, embed_dim) + nn.init.normal_(new_pos_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_pos_embed_to_add = new_pos_embed_to_add.to( + dtype=state_dict["encoder.embed_image_positions.weight"].dtype, + ) + state_dict["encoder.embed_image_positions.weight"] = torch.cat( + [state_dict["encoder.embed_image_positions.weight"], new_pos_embed_to_add] + ) + return state_dict + + +class TransformerDecoder(FairseqIncrementalDecoder): + """ + Transformer decoder consisting of *args.decoder_layers* layers. Each layer + is a :class:`TransformerDecoderLayer`. + + Args: + args (argparse.Namespace): parsed command-line arguments + dictionary (~fairseq.data.Dictionary): decoding dictionary + embed_tokens (torch.nn.Embedding): output embedding + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, + args, + dictionary, + embed_tokens, + no_encoder_attn=False, + output_projection=None, + ): + self.args = args + super().__init__(dictionary) + self.register_buffer("version", torch.Tensor([3])) + self._future_mask = torch.empty(0) + self.with_cls = getattr(args, "with_cls", False) + + if getattr(args, "decoder_prompt", False): + self.decoder_prompt_encoder = PromptEncoder( + type=args.decoder_prompt_type, + length=args.decoder_prompt_length, + projection=args.decoder_prompt_projection, + embed_dim=args.decoder_embed_dim, + proj_dim=args.decoder_prompt_dim, + layers=args.decoder_layers, + vocab_size=args.vocab_size) + self.decoder_dropout = nn.Dropout(p=0.2) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.decoder_layerdrop = args.decoder_layerdrop + self.share_input_output_embed = args.share_decoder_input_output_embed + self.num_attention_heads = args.decoder_attention_heads + + input_embed_dim = embed_tokens.embedding_dim + embed_dim = args.decoder_embed_dim + self.embed_dim = embed_dim + self.output_embed_dim = args.decoder_output_dim + + self.padding_idx = embed_tokens.padding_idx + self.max_target_positions = args.max_target_positions + + self.embed_tokens = embed_tokens + + self.embed_scale = 1.0 if args.no_scale_embedding else math.sqrt(embed_dim) + + if not args.adaptive_input and args.quant_noise_pq > 0: + self.quant_noise = apply_quant_noise_( + nn.Linear(embed_dim, embed_dim, bias=False), + args.quant_noise_pq, + args.quant_noise_pq_block_size, + ) + else: + self.quant_noise = None + + self.project_in_dim = ( + Linear(input_embed_dim, embed_dim, bias=False) + if embed_dim != input_embed_dim + else None + ) + + if getattr(args, "layernorm_embedding", False): + self.layernorm_embedding = LayerNorm(embed_dim) + else: + self.layernorm_embedding = None + + self.window_size = args.code_image_size // 8 + + self.embed_positions = Embedding(args.max_target_positions + 2, embed_dim) + self.embed_image_positions = Embedding(args.image_bucket_size ** 2 + 1, embed_dim) + self.pos_ln = LayerNorm(embed_dim) + self.image_pos_ln = LayerNorm(embed_dim) + self.pos_scaling = float(embed_dim / self.num_attention_heads * args.attn_scale_factor) ** -0.5 + self.self_pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.self_pos_k_linear = nn.Linear(embed_dim, embed_dim) + self.cross_pos_q_linear = nn.Linear(embed_dim, embed_dim) + self.cross_pos_k_linear = nn.Linear(embed_dim, embed_dim) + + if getattr(args, "code_layernorm_embedding", False): + self.code_layernorm_embedding = LayerNorm(embed_dim) + else: + self.code_layernorm_embedding = None + + self.cross_self_attention = getattr(args, "cross_self_attention", False) + + if self.decoder_layerdrop > 0.0: + self.layers = LayerDropModuleList(p=self.decoder_layerdrop) + else: + self.layers = nn.ModuleList([]) + + dpr = [x.item() for x in torch.linspace(0, args.decoder_drop_path_rate, args.decoder_layers)] + self.layers.extend( + [ + self.build_decoder_layer(args, no_encoder_attn, drop_path_rate=dpr[i]) + for i in range(args.decoder_layers) + ] + ) + self.num_layers = len(self.layers) + + if args.decoder_normalize_before: + self.layer_norm = LayerNorm(embed_dim) + else: + self.layer_norm = None + + self.project_out_dim = ( + Linear(embed_dim, self.output_embed_dim, bias=False) + if embed_dim != self.output_embed_dim and not args.tie_adaptive_weights + else None + ) + + self.adaptive_softmax = None + self.output_projection = output_projection + if self.output_projection is None: + self.build_output_projection(args, dictionary, embed_tokens) + + token_bucket_size = args.token_bucket_size + token_num_rel_dis = 2 * token_bucket_size - 1 + token_rp_bucket = make_token_bucket_position(token_bucket_size) + self.token_rel_pos_table_list = nn.ModuleList( + [Embedding(token_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.decoder_layers)] + ) + + image_bucket_size = args.image_bucket_size + image_num_rel_dis = (2 * image_bucket_size - 1) * (2 * image_bucket_size - 1) + 3 + image_rp_bucket = make_image_bucket_position(image_bucket_size, image_num_rel_dis) + image_position_idx = torch.arange(self.window_size).unsqueeze(0).expand(self.window_size, self.window_size) + \ + torch.arange(self.window_size).unsqueeze(1) * image_bucket_size + 1 + image_position_idx = torch.cat([torch.tensor([0]), image_position_idx.view(-1)]) + image_position_idx = torch.cat([image_position_idx, torch.tensor([1024] * 769)]) + self.image_rel_pos_table_list = nn.ModuleList( + [Embedding(image_num_rel_dis, self.num_attention_heads, zero_init=True) for _ in range(args.decoder_layers)] + ) + + self.register_buffer("token_rp_bucket", token_rp_bucket) + self.register_buffer("image_rp_bucket", image_rp_bucket) + self.register_buffer("image_position_idx", image_position_idx) + self.entangle_position_embedding = args.entangle_position_embedding + + def get_decoder_prompt(self, prompt_tokens): + past_key_values = self.decoder_prompt_encoder(prompt_tokens) + bsz, seqlen, _ = past_key_values.shape + past_key_values = past_key_values.view( + bsz, + seqlen, + self.args.decoder_layers * 2, + self.args.decoder_attention_heads, + self.args.decoder_embed_dim // self.args.decoder_attention_heads, + ) + past_key_values = self.decoder_dropout(past_key_values) + past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(2) + return past_key_values + + def build_output_projection(self, args, dictionary, embed_tokens): + if args.adaptive_softmax_cutoff is not None: + self.adaptive_softmax = AdaptiveSoftmax( + len(dictionary), + self.output_embed_dim, + utils.eval_str_list(args.adaptive_softmax_cutoff, type=int), + dropout=args.adaptive_softmax_dropout, + adaptive_inputs=embed_tokens if args.tie_adaptive_weights else None, + factor=args.adaptive_softmax_factor, + tie_proj=args.tie_adaptive_proj, + ) + elif self.share_input_output_embed: + self.output_projection = nn.Linear( + self.embed_tokens.weight.shape[1], + self.embed_tokens.weight.shape[0], + bias=False, + ) + self.output_projection.weight = self.embed_tokens.weight + else: + self.output_projection = nn.Linear( + self.output_embed_dim, len(dictionary), bias=False + ) + nn.init.normal_( + self.output_projection.weight, mean=0, std=self.output_embed_dim ** -0.5 + ) + num_base_layers = getattr(args, "base_layers", 0) + for i in range(num_base_layers): + self.layers.insert(((i+1) * args.decoder_layers) // (num_base_layers + 1), BaseLayer(args)) + + def build_decoder_layer(self, args, no_encoder_attn=False, drop_path_rate=0.0): + layer = TransformerDecoderLayer(args, no_encoder_attn, drop_path_rate= \ + drop_path_rate, use_adapter=getattr(args, "adapter", False), adapter_dim=getattr(args, "adapter_dim", 200)) + checkpoint = getattr(args, "checkpoint_activations", False) + if checkpoint: + offload_to_cpu = getattr(args, "offload_activations", False) + layer = checkpoint_wrapper(layer, offload_to_cpu=offload_to_cpu) + # if we are checkpointing, enforce that FSDP always wraps the + # checkpointed layer, regardless of layer size + min_params_to_wrap = ( + getattr(args, "min_params_to_wrap", DEFAULT_MIN_PARAMS_TO_WRAP) + if not checkpoint else 0 + ) + layer = fsdp_wrap(layer, min_num_params=min_params_to_wrap) + return layer + + def get_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + rp_bucket = self.token_rp_bucket[:seq_len, :seq_len] + values = F.embedding(rp_bucket, self.token_rel_pos_table_list[idx].weight) + values = values.permute([2, 0, 1]) + return values.contiguous() + + def get_image_rel_pos_bias(self, x, idx): + seq_len = x.size(1) + image_position_idx = self.image_position_idx[:seq_len] + rp_bucket = self.image_rp_bucket[image_position_idx][:, image_position_idx] + values = F.embedding(rp_bucket, self.image_rel_pos_table_list[idx].weight) + values = values.permute(2, 0, 1) + return values + + def get_pos_info(self, tokens, tgt_pos_embed, src_pos_embed=None, use_image=False): + batch_size = tokens.size(0) + tgt_len = tokens.size(1) + tgt_pos_embed = self.image_pos_ln(tgt_pos_embed) if use_image else self.pos_ln(tgt_pos_embed) + if src_pos_embed is not None: + src_len = src_pos_embed.size(1) + pos_q = self.cross_pos_q_linear(tgt_pos_embed).view( + batch_size, tgt_len, self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.cross_pos_k_linear(src_pos_embed).view( + batch_size, src_len, self.num_attention_heads, -1 + ).transpose(1, 2) + else: + src_len = tgt_pos_embed.size(1) + pos_q = self.self_pos_q_linear(tgt_pos_embed).view( + batch_size, tgt_len, self.num_attention_heads, -1 + ).transpose(1, 2) * self.pos_scaling + pos_k = self.self_pos_k_linear(tgt_pos_embed).view( + batch_size, src_len, self.num_attention_heads, -1 + ).transpose(1, 2) + abs_pos_bias = torch.matmul(pos_q, pos_k.transpose(2, 3)) + return abs_pos_bias + + def forward( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor] = None, + encoder_out: Optional[Dict[str, List[Tensor]]] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + features_only: bool = False, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + src_lengths: Optional[Any] = None, + return_all_hiddens: bool = False, + ): + """ + Args: + prev_output_tokens (LongTensor): previous decoder outputs of shape + `(batch, tgt_len)`, for teacher forcing + encoder_out (optional): output from the encoder, used for + encoder-side attention, should be of size T x B x C + incremental_state (dict): dictionary used for storing state during + :ref:`Incremental decoding` + features_only (bool, optional): only return features without + applying output layer (default: False). + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + + Returns: + tuple: + - the decoder's output of shape `(batch, tgt_len, vocab)` + - a dictionary with any model-specific outputs + """ + # print(self.training, "encoder_out", encoder_out['encoder_out'][0][0]) + x, extra = self.extract_features( + prev_output_tokens, + code_masks=code_masks, + encoder_out=encoder_out, + incremental_state=incremental_state, + full_context_alignment=full_context_alignment, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + ) + + if not features_only: + x = self.output_layer(x) + return x, extra + + def extract_features( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor], + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + return self.extract_features_scriptable( + prev_output_tokens, + code_masks, + encoder_out, + incremental_state, + full_context_alignment, + alignment_layer, + alignment_heads, + ) + + """ + A scriptable subclass of this class has an extract_features method and calls + super().extract_features, but super() is not supported in torchscript. A copy of + this function is made to be used in the subclass instead. + """ + + def extract_features_scriptable( + self, + prev_output_tokens, + code_masks: Optional[torch.Tensor], + encoder_out: Optional[Dict[str, List[Tensor]]], + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + full_context_alignment: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + ): + """ + Similar to *forward* but only return features. + + Includes several features from "Jointly Learning to Align and + Translate with Transformer Models" (Garg et al., EMNLP 2019). + + Args: + full_context_alignment (bool, optional): don't apply + auto-regressive mask to self-attention (default: False). + alignment_layer (int, optional): return mean alignment over + heads at this layer (default: last layer). + alignment_heads (int, optional): only average alignment over + this many heads (default: all heads). + + Returns: + tuple: + - the decoder's features of shape `(batch, tgt_len, embed_dim)` + - a dictionary with any model-specific outputs + """ + prompt_tokens = None + prompt_padding_mask = None + prompt_kv_list = None + if self.args.decoder_prompt: + bsz, seq_len = prev_output_tokens.shape[0], prev_output_tokens.shape[1] + if self.args.decoder_prompt_type in ("prefix"): + prompt_tokens = torch.arange( + 0, self.args.decoder_prompt_length).to( + prev_output_tokens.device) + prompt_tokens = prompt_tokens.unsqueeze(0).expand(bsz, -1) + prompt_padding_mask = torch.zeros_like(prompt_tokens).to(prompt_tokens.device) + prompt_kv_list = self.get_decoder_prompt(prompt_tokens) + bs, slen = prev_output_tokens.size() + if alignment_layer is None: + alignment_layer = self.num_layers - 1 + + enc: Optional[Tensor] = None + padding_mask: Optional[Tensor] = None + if encoder_out is not None and len(encoder_out["encoder_out"]) > 0: + enc = encoder_out["encoder_out"][0] + assert ( + enc.size()[1] == bs + ), f"Expected enc.shape == (t, {bs}, c) got {enc.shape}" + if encoder_out is not None and len(encoder_out["encoder_padding_mask"]) > 0: + padding_mask = encoder_out["encoder_padding_mask"][0] + + bsz, tgt_len = prev_output_tokens.shape + token_position_idx = utils.new_arange(prev_output_tokens) + tgt_pos_embed = self.embed_positions(token_position_idx) + if code_masks is not None and torch.any(code_masks): + image_position_idx = self.image_position_idx[:prev_output_tokens.size(1)].unsqueeze(0).expand(bsz, tgt_len) + tgt_pos_embed[code_masks] = self.embed_image_positions(image_position_idx)[code_masks] + + # self attn position bias + self_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, use_image=False) + if code_masks is not None and torch.any(code_masks): + self_image_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, use_image=True) + self_abs_pos_bias[code_masks] = self_image_abs_pos_bias[code_masks] + # cross attn position bias + src_pos_embed = encoder_out['position_embeddings'][0] + cross_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, src_pos_embed=src_pos_embed) + + + + if code_masks is not None and torch.any(code_masks): + cross_image_abs_pos_bias = self.get_pos_info(prev_output_tokens, tgt_pos_embed, src_pos_embed=src_pos_embed, use_image=True) + cross_abs_pos_bias[code_masks] = cross_image_abs_pos_bias[code_masks] + + if self.with_cls: + cross_abs_pos_bias = F.pad(cross_abs_pos_bias, (enc.shape[0] - cross_abs_pos_bias.shape[-1], 0, prev_output_tokens.shape[1] - cross_abs_pos_bias.shape[2], 0), "constant", 0) + + + cross_abs_pos_bias = cross_abs_pos_bias.reshape(-1, *cross_abs_pos_bias.size()[-2:]) + + all_prev_output_tokens = prev_output_tokens.clone() + # print(all_prev_output_tokens.shape, prev_output_tokens.shape, tgt_pos_embed.shape, self_abs_pos_bias.shape) + if incremental_state is not None: + prev_output_tokens = prev_output_tokens[:, -1:] + cross_abs_pos_bias = cross_abs_pos_bias[:, -1:, :] + tgt_pos_embed = tgt_pos_embed[:, -1:, :] + + # embed tokens and positions + x = self.embed_scale * self.embed_tokens(prev_output_tokens) + + if self.quant_noise is not None: + x = self.quant_noise(x) + + if self.project_in_dim is not None: + x = self.project_in_dim(x) + + if self.entangle_position_embedding is not None and not self.args.disable_entangle: + x += tgt_pos_embed + + if self.layernorm_embedding is not None: + if code_masks is None or not code_masks.any() or not getattr(self, "code_layernorm_embedding", False): + x = self.layernorm_embedding(x) + elif code_masks is not None and code_masks.all(): + x = self.code_layernorm_embedding(x) + else: + x[~code_masks] = self.layernorm_embedding(x[~code_masks]) + x[code_masks] = self.code_layernorm_embedding(x[code_masks]) + + x = self.dropout_module(x) + + # B x T x C -> T x B x C + x = x.transpose(0, 1) + + self_attn_padding_mask: Optional[Tensor] = None + if self.cross_self_attention or prev_output_tokens.eq(self.padding_idx).any(): + self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx) + if prompt_padding_mask is not None: + self_attn_padding_mask = torch.cat([prompt_padding_mask, self_attn_padding_mask], dim=1) + + # decoder layers + attn: Optional[Tensor] = None + inner_states: List[Optional[Tensor]] = [x] + for idx, layer in enumerate(self.layers): + if incremental_state is None and not full_context_alignment: + self_attn_mask = self.buffered_future_mask(x) + if self.args.decoder_prompt: + seq_len, prompt_len = x.size(0), prompt_tokens.size(1) + prompt_mask = torch.zeros([seq_len, prompt_len]).to(x.device) + self_attn_mask = torch.cat([prompt_mask, self_attn_mask], dim=1) + else: + self_attn_mask = None + + self_attn_bias = self_abs_pos_bias.clone() + # print(self_attn_bias.shape, 'self_attn_bias') + if code_masks is None or not code_masks.any(): + # try: + self_attn_bias += self.get_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + # except: + # print(idx, self_attn_bias.shape, all_prev_output_tokens.shape, self_abs_pos_bias.shape, incremental_state) + # self_attn_bias += self.get_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + elif code_masks is not None and code_masks.all(): + self_attn_bias += self.get_image_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + else: + self_attn_bias[~code_masks] += self.get_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + self_attn_bias[code_masks] += self.get_image_rel_pos_bias(all_prev_output_tokens, idx).unsqueeze(0) + self_attn_bias = self_attn_bias.reshape(-1, *self_attn_bias.size()[-2:]) + if incremental_state is not None: + self_attn_bias = self_attn_bias[:, -1:, :] + + if self.args.decoder_prompt: + if self.args.decoder_prompt_type != "prompt": + prompt_kv = prompt_kv_list[idx] + else: + if idx == 0: + prompt_kv = prompt_kv_list[idx] + else: + prompt_kv = None + else: + prompt_kv = None + + x, layer_attn, _ = layer( + x, + enc, + padding_mask, + incremental_state, + self_attn_mask=self_attn_mask, + self_attn_padding_mask=self_attn_padding_mask, + need_attn=bool((idx == alignment_layer)), + need_head_weights=bool((idx == alignment_layer)), + self_attn_bias=self_attn_bias, + cross_attn_bias=cross_abs_pos_bias, + prompt_kv=prompt_kv + ) + inner_states.append(x) + if layer_attn is not None and idx == alignment_layer: + attn = layer_attn.float().to(x) + + if attn is not None: + if alignment_heads is not None: + attn = attn[:alignment_heads] + + # average probabilities over heads + attn = attn.mean(dim=0) + + if self.layer_norm is not None: + x = self.layer_norm(x) + + # T x B x C -> B x T x C + x = x.transpose(0, 1) + + if self.project_out_dim is not None: + x = self.project_out_dim(x) + + return x, {"attn": [attn], "inner_states": inner_states} + + def output_layer(self, features): + """Project features to the vocabulary size.""" + if self.adaptive_softmax is None: + # project back to size of vocabulary + return self.output_projection(features) + else: + return features + + def max_positions(self): + """Maximum output length supported by the decoder.""" + if self.embed_positions is None: + return self.max_target_positions + return self.max_target_positions + + def buffered_future_mask(self, tensor): + dim = tensor.size(0) + if ( + self._future_mask.size(0) == 0 + or (not self._future_mask.device == tensor.device) + or self._future_mask.size(0) < dim + ): + self._future_mask = torch.triu( + utils.fill_with_neg_inf(torch.zeros([dim, dim])), 1 + ) + self._future_mask = self._future_mask.to(tensor) + return self._future_mask[:dim, :dim] + + def upgrade_state_dict_named(self, state_dict, name): + """Upgrade a (possibly old) state dict for new versions of fairseq.""" + if isinstance(self.embed_positions, SinusoidalPositionalEmbedding): + weights_key = "{}.embed_positions.weights".format(name) + if weights_key in state_dict: + del state_dict[weights_key] + state_dict[ + "{}.embed_positions._float_tensor".format(name) + ] = torch.FloatTensor(1) + + if f"{name}.output_projection.weight" not in state_dict: + if self.share_input_output_embed: + embed_out_key = f"{name}.embed_tokens.weight" + else: + embed_out_key = f"{name}.embed_out" + if embed_out_key in state_dict: + state_dict[f"{name}.output_projection.weight"] = state_dict[ + embed_out_key + ] + if not self.share_input_output_embed: + del state_dict[embed_out_key] + + for i in range(self.num_layers): + # update layer norms + self.layers[i].upgrade_state_dict_named( + state_dict, "{}.layers.{}".format(name, i) + ) + + + + prefix = name + "." if name != "" else "" + image_params = ["image_position_idx"] + for image_param in image_params: + state_dict[prefix + image_param] = self.state_dict()[image_param] + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] + + if len(state_dict["decoder.embed_image_positions.weight"]) < len(self.state_dict()["embed_image_positions.weight"]): + num_posids_to_add = len(self.state_dict()["embed_image_positions.weight"]) - len(state_dict["decoder.embed_image_positions.weight"]) + embed_dim = state_dict["decoder.embed_image_positions.weight"].size(1) + new_pos_embed_to_add = torch.zeros(num_posids_to_add, embed_dim) + nn.init.normal_(new_pos_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_pos_embed_to_add = new_pos_embed_to_add.to( + dtype=state_dict["decoder.embed_image_positions.weight"].dtype, + ) + state_dict["decoder.embed_image_positions.weight"] = torch.cat( + [state_dict["decoder.embed_image_positions.weight"], new_pos_embed_to_add] + ) + return state_dict + + +def Embedding(num_embeddings, embedding_dim, padding_idx=None, zero_init=False): + m = nn.Embedding(num_embeddings, embedding_dim, padding_idx=padding_idx) + nn.init.normal_(m.weight, mean=0, std=embedding_dim ** -0.5) + if padding_idx is not None: + nn.init.constant_(m.weight[padding_idx], 0) + if zero_init: + nn.init.constant_(m.weight, 0) + return m + + +def Linear(in_features, out_features, bias=True): + m = nn.Linear(in_features, out_features, bias) + nn.init.xavier_uniform_(m.weight) + if bias: + nn.init.constant_(m.bias, 0.0) + return m + + +@register_model_architecture("unify_transformer", "unify_transformer") +def base_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 512) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 2048) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 8) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", False) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", False) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 8) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", False) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", False) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.activation_dropout = getattr(args, "activation_dropout", 0.0) + args.activation_fn = getattr(args, "activation_fn", "relu") + args.dropout = getattr(args, "dropout", 0.1) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", False + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", False) + args.no_token_positional_embeddings = getattr( + args, "no_token_positional_embeddings", False + ) + args.adaptive_input = getattr(args, "adaptive_input", False) + args.no_cross_attention = getattr(args, "no_cross_attention", False) + args.cross_self_attention = getattr(args, "cross_self_attention", False) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.encoder_prompt = getattr(args, "encoder_prompt", False) + args.encoder_prompt_length = getattr(args, "encoder_prompt_length", 100) + args.encoder_prompt_type = getattr(args, "encoder_prompt_type", "prefix") + args.encoder_prompt_projection = getattr(args, "encoder_prompt_projection", False) + args.encoder_prompt_dim = getattr(args, "encoder_prompt_dim", 2 * args.encoder_embed_dim) + + args.decoder_prompt = getattr(args, "decoder_prompt", False) + args.decoder_prompt_length = getattr(args, "decoder_prompt_length", 100) + args.decoder_prompt_type = getattr(args, "decoder_prompt_type", "prefix") + args.decoder_prompt_projection = getattr(args, "decoder_prompt_projection", False) + args.decoder_prompt_dim = getattr(args, "decoder_prompt_dim", 2 * args.encoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", False) + args.layernorm_embedding = getattr(args, "layernorm_embedding", False) + args.tie_adaptive_weights = getattr(args, "tie_adaptive_weights", False) + args.checkpoint_activations = getattr(args, "checkpoint_activations", False) + args.offload_activations = getattr(args, "offload_activations", False) + if args.offload_activations: + args.checkpoint_activations = True + args.encoder_layers_to_keep = getattr(args, "encoder_layers_to_keep", None) + args.decoder_layers_to_keep = getattr(args, "decoder_layers_to_keep", None) + args.encoder_layerdrop = getattr(args, "encoder_layerdrop", 0) + args.decoder_layerdrop = getattr(args, "decoder_layerdrop", 0) + args.quant_noise_pq = getattr(args, "quant_noise_pq", 0) + args.quant_noise_pq_block_size = getattr(args, "quant_noise_pq_block_size", 8) + args.quant_noise_scalar = getattr(args, "quant_noise_scalar", 0) diff --git a/models/unival/unify_transformer_layer.py b/models/unival/unify_transformer_layer.py new file mode 100644 index 0000000000000000000000000000000000000000..ec9555f612a0ad60b93a69ecc221b7ee649169ab --- /dev/null +++ b/models/unival/unify_transformer_layer.py @@ -0,0 +1,668 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from typing import Dict, List, Optional + +import torch +import torch.nn as nn +from fairseq import utils +from fairseq.modules import LayerNorm +from fairseq.modules.fairseq_dropout import FairseqDropout +from fairseq.modules.quant_noise import quant_noise +from torch import Tensor + +from .unify_multihead_attention import MultiheadAttention + + +def drop_path(x, drop_prob: float = 0.0, training: bool = False): + """ + Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). + Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks, + however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper... + See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the + layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the + argument. + """ + if drop_prob == 0.0 or not training: + return x + keep_prob = 1 - drop_prob + shape = (1, x.shape[1], 1) + random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device) + random_tensor.floor_() # binarize + output = x.div(keep_prob) * random_tensor + return output + +def init_bert_weights(module): + """Initialize the weights.""" + if isinstance(module, (nn.Linear, nn.Embedding)): + # std defaults to 0.02, this might need to be changed + module.weight.data.normal_(mean=0.0, std=0.02) + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + +class Adapter_Layer(torch.nn.Module): + def __init__(self, + d_model=None, + down_size=None, + dropout=0.0, + init_option="bert", + adapter_scalar="1.0"): + super().__init__() + self.n_embd = d_model + self.down_size = down_size + + + if adapter_scalar == "learnable_scalar": + self.scale = nn.Parameter(torch.ones(1)) + else: + self.scale = float(adapter_scalar) + + self.down_proj = nn.Linear(self.n_embd, self.down_size) + self.non_linear_func = nn.ReLU() + self.up_proj = nn.Linear(self.down_size, self.n_embd) + + self.dropout = dropout + if init_option == "bert": + self.apply(init_bert_weights) + elif init_option == "lora": + with torch.no_grad(): + nn.init.kaiming_uniform_(self.down_proj.weight, a=math.sqrt(5)) + nn.init.zeros_(self.up_proj.weight) + nn.init.zeros_(self.down_proj.bias) + nn.init.zeros_(self.up_proj.bias) + + def forward(self, x, add_residual=True, residual=None): + residual = x if residual is None else residual + + down = self.down_proj(x) + down = self.non_linear_func(down) + down = nn.functional.dropout(down, p=self.dropout, training=self.training) + up = self.up_proj(down) + up = up * self.scale + if add_residual: + output = up + residual + else: + output = up + + return output + +class VLAdapter_Layer(torch.nn.Module): + def __init__(self, + d_model=None, + down_size=None, + dropout=0.0, + init_option="bert", + adapter_scalar="1.0"): + super().__init__() + print("load VL adapter") + self.v_adapter = Adapter_Layer(d_model=d_model, + down_size=down_size, + dropout=dropout, + init_option=init_option, + adapter_scalar=adapter_scalar) + + self.l_adapter = Adapter_Layer(d_model=d_model, + down_size=down_size, + dropout=dropout, + init_option=init_option, + adapter_scalar=adapter_scalar) + + + def forward(self, x, add_residual=True, residual=None, num_image_tokens=None): + + if num_image_tokens is not None: + v_x = x[:num_image_tokens, :, :] + l_x = x[num_image_tokens:, :, :] + else: + v_x = x + l_x = x + + v_x = self.v_adapter(v_x, add_residual=add_residual, residual=residual) + l_x = self.l_adapter(l_x, add_residual=add_residual, residual=residual) + + if num_image_tokens is not None: + x = torch.cat((v_x, l_x), dim=0) + else: + x = v_x + l_x + + return x + + +class DropPath(nn.Module): + """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).""" + + def __init__(self, drop_prob=None): + super().__init__() + self.drop_prob = drop_prob + + def forward(self, x): + return drop_path(x, self.drop_prob, self.training) + + def extra_repr(self) -> str: + return "p={}".format(self.drop_prob) + + +class TransformerEncoderLayer(nn.Module): + """Encoder layer block. + + In the original paper each operation (multi-head attention or FFN) is + postprocessed with: `dropout -> add residual -> layernorm`. In the + tensor2tensor code they suggest that learning is more robust when + preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *args.encoder_normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + """ + + def __init__(self, args, drop_path_rate=0.0, use_adapter=False, adapter_dim=200, adapter_type='UM'): + super().__init__() + self.args = args + self.use_adapter = use_adapter + self.embed_dim = args.encoder_embed_dim + self.adapter_type = adapter_type + if self.use_adapter: + if adapter_type == 'VL': + self.adapter = VLAdapter_Layer(d_model=self.embed_dim, down_size=adapter_dim) + else: + self.adapter = Adapter_Layer(d_model=self.embed_dim, down_size=adapter_dim) + self.quant_noise = getattr(args, 'quant_noise_pq', 0) + self.quant_noise_block_size = getattr(args, 'quant_noise_pq_block_size', 8) or 8 + self.self_attn = self.build_self_attention(self.embed_dim, args) + self.self_attn_layer_norm = LayerNorm(self.embed_dim) + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.activation_fn = utils.get_activation_fn( + activation=getattr(args, 'activation_fn', 'relu') or "relu" + ) + activation_dropout_p = getattr(args, "activation_dropout", 0) or 0 + if activation_dropout_p == 0: + # for backwards compatibility with models that use args.relu_dropout + activation_dropout_p = getattr(args, "relu_dropout", 0) or 0 + self.activation_dropout_module = FairseqDropout( + float(activation_dropout_p), module_name=self.__class__.__name__ + ) + self.normalize_before = args.encoder_normalize_before + self.fc1 = self.build_fc1( + self.embed_dim, + args.encoder_ffn_embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + self.fc2 = self.build_fc2( + args.encoder_ffn_embed_dim, + self.embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + + self.attn_ln = LayerNorm(self.embed_dim) if getattr(args, 'scale_attn', False) else None + self.nh = self.self_attn.num_heads + self.head_dim = self.self_attn.head_dim + + self.ffn_layernorm = LayerNorm(args.encoder_ffn_embed_dim) if getattr(args, 'scale_fc', False) else None + self.w_resid = nn.Parameter(torch.ones(self.embed_dim, ), requires_grad=True) if getattr(args, 'scale_resids', False) else None + + self.final_layer_norm = LayerNorm(self.embed_dim) + + self.drop_path = DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity() + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise( + nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size + ) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise( + nn.Linear(input_dim, output_dim), p=q_noise, block_size=qn_block_size + ) + + def build_self_attention(self, embed_dim, args): + return MultiheadAttention( + embed_dim, + args.encoder_attention_heads, + dropout=args.attention_dropout, + self_attention=True, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + scale_factor=args.attn_scale_factor, + scale_heads=getattr(args, 'scale_heads', False), + qk_norm=getattr(args, 'qk_norm', False), + ) + + def residual_connection(self, x, residual): + return residual + self.drop_path(x) + + def upgrade_state_dict_named(self, state_dict, name): + """ + Rename layer norm states from `...layer_norms.0.weight` to + `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to + `...final_layer_norm.weight` + """ + layer_norm_map = {"0": "self_attn_layer_norm", "1": "final_layer_norm"} + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layer_norms.{}.{}".format(name, old, m) + if k in state_dict: + state_dict["{}.{}.{}".format(name, new, m)] = state_dict[k] + del state_dict[k] + if "{}.{}.{}".format(name, new, m) not in state_dict and "{}.{}".format(new, m) in self.state_dict(): + state_dict[ + "{}.{}.{}".format(name, new, m) + ] = self.state_dict()["{}.{}".format(new, m)] + + prefix = name + "." if name != "" else "" + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] + + def forward( + self, + x, + encoder_padding_mask: Optional[Tensor], + attn_mask: Optional[Tensor] = None, + self_attn_bias: Optional[Tensor] = None, + prompt_kv: Optional[Tensor] = None, + num_image_tokens = None, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor): binary ByteTensor of shape + `(batch, seq_len)` where padding elements are indicated by ``1``. + attn_mask (ByteTensor): binary tensor of shape `(tgt_len, src_len)`, + where `tgt_len` is the length of output and `src_len` is the + length of input, though here both are equal to `seq_len`. + `attn_mask[tgt_i, src_j] = 1` means that when calculating the + embedding for `tgt_i`, we exclude (mask out) `src_j`. This is + useful for strided self-attention. + + Returns: + encoded output of shape `(seq_len, batch, embed_dim)` + """ + # anything in original attn_mask = 1, becomes -1e8 + # anything in original attn_mask = 0, becomes 0 + # Note that we cannot use -inf here, because at some edge cases, + # the attention weight (before softmax) for some padded element in query + # will become -inf, which results in NaN in model parameters + if attn_mask is not None: + attn_mask = attn_mask.masked_fill( + attn_mask.to(torch.bool), + -1e8 if x.dtype == torch.float32 else -1e4 + ) + + residual = x + if self.normalize_before: + x = self.self_attn_layer_norm(x) + x, _ = self.self_attn( + query=x, + key=x, + value=x, + key_padding_mask=encoder_padding_mask, + need_weights=False, + attn_mask=attn_mask, + attn_bias=self_attn_bias, + prompt_kv=prompt_kv + ) + if self.attn_ln is not None: + x = self.attn_ln(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + if self.ffn_layernorm is not None: + x = self.ffn_layernorm(x) + x = self.fc2(x) + x = self.dropout_module(x) + if self.use_adapter: + if self.adapter_type == 'VL': + x = self.adapter(x, num_image_tokens=num_image_tokens) + else: + x = self.adapter(x) + if self.w_resid is not None: + residual = torch.mul(self.w_resid, residual) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.final_layer_norm(x) + return x + + +class TransformerDecoderLayer(nn.Module): + """Decoder layer block. + + In the original paper each operation (multi-head attention, encoder + attention or FFN) is postprocessed with: `dropout -> add residual -> + layernorm`. In the tensor2tensor code they suggest that learning is more + robust when preprocessing each layer with layernorm and postprocessing with: + `dropout -> add residual`. We default to the approach in the paper, but the + tensor2tensor approach can be enabled by setting + *args.decoder_normalize_before* to ``True``. + + Args: + args (argparse.Namespace): parsed command-line arguments + no_encoder_attn (bool, optional): whether to attend to encoder outputs + (default: False). + """ + + def __init__( + self, args, no_encoder_attn=False, add_bias_kv=False, add_zero_attn=False, \ + drop_path_rate=0.0, use_adapter=False, adapter_dim=200): + super().__init__() + self.embed_dim = args.decoder_embed_dim + self.use_adapter = use_adapter + if use_adapter == True: + self.adapter = Adapter_Layer(d_model=self.embed_dim, down_size=adapter_dim) + + self.dropout_module = FairseqDropout( + args.dropout, module_name=self.__class__.__name__ + ) + self.quant_noise = getattr(args, "quant_noise_pq", 0) + self.quant_noise_block_size = getattr(args, "quant_noise_pq_block_size", 8) + + self.cross_self_attention = getattr(args, "cross_self_attention", False) + + self.self_attn = self.build_self_attention( + self.embed_dim, + args, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + ) + self.self_attn_ln = LayerNorm(self.embed_dim) if getattr(args, 'scale_attn', False) else None + self.cross_attn_ln = LayerNorm(self.embed_dim) if getattr(args, 'scale_attn', False) else None + self.nh = self.self_attn.num_heads + self.head_dim = self.self_attn.head_dim + + self.activation_fn = utils.get_activation_fn( + activation=str(args.activation_fn) + if getattr(args, "activation_fn", None) is not None + else "relu" + ) + activation_dropout_p = getattr(args, "activation_dropout", 0) or 0 + if activation_dropout_p == 0: + # for backwards compatibility with models that use args.relu_dropout + activation_dropout_p = getattr(args, "relu_dropout", 0) or 0 + self.activation_dropout_module = FairseqDropout( + float(activation_dropout_p), module_name=self.__class__.__name__ + ) + self.normalize_before = args.decoder_normalize_before + + # use layerNorm rather than FusedLayerNorm for exporting. + # char_inputs can be used to determint this. + # TODO remove this once we update apex with the fix + export = getattr(args, "char_inputs", False) + self.self_attn_layer_norm = LayerNorm(self.embed_dim, export=export) + + if no_encoder_attn: + self.encoder_attn = None + self.encoder_attn_layer_norm = None + else: + self.encoder_attn = self.build_encoder_attention(self.embed_dim, args) + self.encoder_attn_layer_norm = LayerNorm(self.embed_dim, export=export) + + self.ffn_layernorm = LayerNorm(args.decoder_ffn_embed_dim) if getattr(args, 'scale_fc', False) else None + self.w_resid = nn.Parameter(torch.ones(self.embed_dim, ), requires_grad=True) if getattr(args, 'scale_resids', False) else None + + self.fc1 = self.build_fc1( + self.embed_dim, + args.decoder_ffn_embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + self.fc2 = self.build_fc2( + args.decoder_ffn_embed_dim, + self.embed_dim, + self.quant_noise, + self.quant_noise_block_size, + ) + + self.final_layer_norm = LayerNorm(self.embed_dim, export=export) + self.need_attn = True + + self.onnx_trace = False + + self.drop_path = DropPath(drop_path_rate) if drop_path_rate > 0.0 else nn.Identity() + + def build_fc1(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_fc2(self, input_dim, output_dim, q_noise, qn_block_size): + return quant_noise(nn.Linear(input_dim, output_dim), q_noise, qn_block_size) + + def build_self_attention( + self, embed_dim, args, add_bias_kv=False, add_zero_attn=False + ): + return MultiheadAttention( + embed_dim, + args.decoder_attention_heads, + dropout=args.attention_dropout, + add_bias_kv=add_bias_kv, + add_zero_attn=add_zero_attn, + self_attention=not getattr(args, "cross_self_attention", False), + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + scale_factor=args.attn_scale_factor, + scale_heads=getattr(args, 'scale_heads', False), + qk_norm=getattr(args, 'qk_norm', False), + ) + + def build_encoder_attention(self, embed_dim, args): + return MultiheadAttention( + embed_dim, + args.decoder_attention_heads, + kdim=getattr(args, "encoder_embed_dim", None), + vdim=getattr(args, "encoder_embed_dim", None), + dropout=args.attention_dropout, + encoder_decoder_attention=True, + q_noise=self.quant_noise, + qn_block_size=self.quant_noise_block_size, + scale_factor=args.attn_scale_factor, + scale_heads=getattr(args, 'scale_heads', False), + qk_norm=getattr(args, 'qk_norm', False), + ) + + def prepare_for_onnx_export_(self): + self.onnx_trace = True + + def residual_connection(self, x, residual): + return residual + self.drop_path(x) + + def forward( + self, + x, + encoder_out: Optional[torch.Tensor] = None, + encoder_padding_mask: Optional[torch.Tensor] = None, + incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None, + prev_self_attn_state: Optional[List[torch.Tensor]] = None, + prev_attn_state: Optional[List[torch.Tensor]] = None, + self_attn_mask: Optional[torch.Tensor] = None, + self_attn_padding_mask: Optional[torch.Tensor] = None, + need_attn: bool = False, + need_head_weights: bool = False, + self_attn_bias: Optional[Tensor] = None, + cross_attn_bias: Optional[Tensor] = None, + prompt_kv: Optional[Tensor] = None, + ): + """ + Args: + x (Tensor): input to the layer of shape `(seq_len, batch, embed_dim)` + encoder_padding_mask (ByteTensor, optional): binary + ByteTensor of shape `(batch, src_len)` where padding + elements are indicated by ``1``. + need_attn (bool, optional): return attention weights + need_head_weights (bool, optional): return attention weights + for each head (default: return average over heads). + + Returns: + encoded output of shape `(seq_len, batch, embed_dim)` + """ + if need_head_weights: + need_attn = True + + residual = x + if self.normalize_before: + x = self.self_attn_layer_norm(x) + if prev_self_attn_state is not None: + prev_key, prev_value = prev_self_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_self_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_self_attn_state[2] + assert incremental_state is not None + self.self_attn._set_input_buffer(incremental_state, saved_state) + _self_attn_input_buffer = self.self_attn._get_input_buffer(incremental_state) + if self.cross_self_attention and not ( + incremental_state is not None + and _self_attn_input_buffer is not None + and "prev_key" in _self_attn_input_buffer + ): + if self_attn_mask is not None: + assert encoder_out is not None + self_attn_mask = torch.cat( + (x.new_zeros(x.size(0), encoder_out.size(0)), self_attn_mask), dim=1 + ) + if self_attn_padding_mask is not None: + if encoder_padding_mask is None: + assert encoder_out is not None + encoder_padding_mask = self_attn_padding_mask.new_zeros( + encoder_out.size(1), encoder_out.size(0) + ) + self_attn_padding_mask = torch.cat( + (encoder_padding_mask, self_attn_padding_mask), dim=1 + ) + assert encoder_out is not None + y = torch.cat((encoder_out, x), dim=0) + else: + y = x + + x, attn = self.self_attn( + query=x, + key=y, + value=y, + key_padding_mask=self_attn_padding_mask, + incremental_state=incremental_state, + need_weights=False, + attn_mask=self_attn_mask, + attn_bias=self_attn_bias, + prompt_kv=prompt_kv + ) + if self.self_attn_ln is not None: + x = self.self_attn_ln(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.self_attn_layer_norm(x) + + if self.encoder_attn is not None and encoder_out is not None: + residual = x + if self.normalize_before: + x = self.encoder_attn_layer_norm(x) + if prev_attn_state is not None: + prev_key, prev_value = prev_attn_state[:2] + saved_state: Dict[str, Optional[Tensor]] = { + "prev_key": prev_key, + "prev_value": prev_value, + } + if len(prev_attn_state) >= 3: + saved_state["prev_key_padding_mask"] = prev_attn_state[2] + assert incremental_state is not None + self.encoder_attn._set_input_buffer(incremental_state, saved_state) + + x, attn = self.encoder_attn( + query=x, + key=encoder_out, + value=encoder_out, + key_padding_mask=encoder_padding_mask, + incremental_state=incremental_state, + static_kv=True, + need_weights=need_attn or (not self.training and self.need_attn), + need_head_weights=need_head_weights, + attn_bias=cross_attn_bias + ) + if self.cross_attn_ln is not None: + x = self.cross_attn_ln(x) + x = self.dropout_module(x) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.encoder_attn_layer_norm(x) + + residual = x + if self.normalize_before: + x = self.final_layer_norm(x) + + x = self.activation_fn(self.fc1(x)) + x = self.activation_dropout_module(x) + if self.ffn_layernorm is not None: + x = self.ffn_layernorm(x) + x = self.fc2(x) + x = self.dropout_module(x) + if self.use_adapter == True: + x = self.adapter(x) + + if self.w_resid is not None: + residual = torch.mul(self.w_resid, residual) + x = self.residual_connection(x, residual) + if not self.normalize_before: + x = self.final_layer_norm(x) + if self.onnx_trace and incremental_state is not None: + saved_state = self.self_attn._get_input_buffer(incremental_state) + assert saved_state is not None + if self_attn_padding_mask is not None: + self_attn_state = [ + saved_state["prev_key"], + saved_state["prev_value"], + saved_state["prev_key_padding_mask"], + ] + else: + self_attn_state = [saved_state["prev_key"], saved_state["prev_value"]] + return x, attn, self_attn_state + return x, attn, None + + def make_generation_fast_(self, need_attn: bool = False, **kwargs): + self.need_attn = need_attn + + def upgrade_state_dict_named(self, state_dict, name): + """ + Rename layer norm states from `...layer_norms.0.weight` to + `...self_attn_layer_norm.weight` and `...layer_norms.1.weight` to + `...final_layer_norm.weight` + """ + # update layer norms + layer_norm_map = { + "0": "self_attn_layer_norm", + "1": "encoder_attn_layer_norm", + "2": "final_layer_norm", + } + for old, new in layer_norm_map.items(): + for m in ("weight", "bias"): + k = "{}.layer_norms.{}.{}".format(name, old, m) + if k in state_dict: + state_dict[ + "{}.{}.{}".format(name, new, m) + ] = state_dict[k] + del state_dict[k] + if "{}.{}.{}".format(name, new, m) not in state_dict and "{}.{}".format(new, m) in self.state_dict(): + state_dict[ + "{}.{}.{}".format(name, new, m) + ] = self.state_dict()["{}.{}".format(new, m)] + + prefix = name + "." if name != "" else "" + for param_name, param_tensor in self.state_dict().items(): + if (prefix + param_name) not in state_dict: + state_dict[prefix + param_name] = self.state_dict()[param_name] diff --git a/models/unival/unival.py b/models/unival/unival.py new file mode 100644 index 0000000000000000000000000000000000000000..a8950dc8d1d5ed0a1dfc254eb18df8ff501fb5d5 --- /dev/null +++ b/models/unival/unival.py @@ -0,0 +1,430 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +""" +UnIVAL +""" +from typing import Optional + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from fairseq import utils +from fairseq.models import register_model, register_model_architecture +from fairseq.modules.transformer_sentence_encoder import init_bert_params + +from .unify_transformer import TransformerModel + +logger = logging.getLogger(__name__) + + +@register_model("unival") +class UnIVALModel(TransformerModel): + __jit_unused_properties__ = ["supported_targets"] + + def __init__(self, args, encoder, decoder): + super().__init__(args, encoder, decoder) + + # We follow BERT's random weight initialization + self.apply(init_bert_params) + + self.classification_heads = nn.ModuleDict() + if hasattr(self.encoder, "dictionary"): + self.eos: int = self.encoder.dictionary.eos() + print('unival') + @staticmethod + def add_args(parser): + super(UnIVALModel, UnIVALModel).add_args(parser) + parser.add_argument( + "--pooler-dropout", + type=float, + metavar="D", + help="dropout probability in the masked_lm pooler layers", + ) + parser.add_argument( + "--pooler-classifier", + type=str, + choices=['mlp', 'linear'], + help="type of pooler classifier", + ) + parser.add_argument( + "--pooler-activation-fn", + choices=utils.get_available_activation_fns(), + help="activation function to use for pooler layer", + ) + parser.add_argument( + "--spectral-norm-classification-head", + action="store_true", + help="Apply spectral normalization on the classification head", + ) + + parser.add_argument( + "--strict", + action="store_false", + default=True, + help="if specified allow strict=False when loading model params", + ) + + parser.add_argument( + "--adapt_arch_for_init", + action="store_true", + default=True, + help="change UnIVAL arch to be close to init arch", + ) + + + @property + def supported_targets(self): + return {"self"} + + def forward( + self, + src_tokens, + src_lengths, + prev_output_tokens, + patch_images: Optional[torch.Tensor] = None, + patch_images_2: Optional[torch.Tensor] = None, + patch_masks: Optional[torch.Tensor] = None, + code_masks: Optional[torch.Tensor] = None, + sample_patch_num: Optional[int] = None, + features_only: bool = False, + classification_head_name: Optional[str] = None, + token_embeddings: Optional[torch.Tensor] = None, + return_all_hiddens: bool = False, + alignment_layer: Optional[int] = None, + alignment_heads: Optional[int] = None, + patch_videos: Optional[torch.Tensor] = None, + patch_types: Optional[torch.Tensor] = None, + patch_audios: Optional[torch.Tensor] = None, + ): + if classification_head_name is not None: + features_only = True + + encoder_out = self.encoder( + src_tokens, + src_lengths=src_lengths, + patch_images=patch_images, + patch_masks=patch_masks, + patch_images_2=patch_images_2, + token_embeddings=token_embeddings, + return_all_hiddens=return_all_hiddens, + sample_patch_num=sample_patch_num, + patch_videos=patch_videos, + patch_types=patch_types, + patch_audios=patch_audios, + ) + + x, extra = self.decoder( + prev_output_tokens, + code_masks=code_masks, + encoder_out=encoder_out, + features_only=features_only, + alignment_layer=alignment_layer, + alignment_heads=alignment_heads, + src_lengths=src_lengths, + return_all_hiddens=return_all_hiddens, + ) + + + pad = self.encoder.padding_idx + if classification_head_name is not None: + prev_lengths = prev_output_tokens.ne(pad).sum(1) + gather_index = prev_lengths[:, None, None].expand(x.size(0), 1, x.size(2)) - 1 + sentence_representation = x.gather(1, gather_index).squeeze() + if self.classification_heads[classification_head_name].use_two_images: + hidden_size = sentence_representation.size(1) + sentence_representation = sentence_representation.view(-1, hidden_size * 2) + for k, head in self.classification_heads.items(): + # for torch script only supports iteration + if k == classification_head_name: + x = head(sentence_representation) + break + + return x, extra + + def register_embedding_tokens(self, ans2label_dict, src_dict, bpe): + """Register embedding tokens""" + logger.info("Registering embedding tokens") + self.ans_tensor_list = [] + for i in range(len(ans2label_dict)): + ans = src_dict[-len(ans2label_dict)+i] + ans = ans[5:-1].replace('_', ' ') + ans_tensor = src_dict.encode_line( + line=bpe.encode(' {}'.format(ans.lower())), + add_if_not_exist=False, + append_eos=False + ).long() + self.ans_tensor_list.append(ans_tensor) + + def register_classification_head( + self, name, num_classes=None, inner_dim=None, use_two_images=False, **kwargs + ): + """Register a classification head.""" + logger.info("Registering classification head: {0}".format(name)) + if name in self.classification_heads: + prev_num_classes = self.classification_heads[name].out_proj.out_features + prev_inner_dim = self.classification_heads[name].dense.out_features + if num_classes != prev_num_classes or inner_dim != prev_inner_dim: + logger.warning( + 're-registering head "{}" with num_classes {} (prev: {}) ' + "and inner_dim {} (prev: {})".format( + name, num_classes, prev_num_classes, inner_dim, prev_inner_dim + ) + ) + self.classification_heads[name] = UnIVALClassificationHead( + input_dim=self.args.encoder_embed_dim, + inner_dim=inner_dim or self.args.encoder_embed_dim, + num_classes=num_classes, + activation_fn=self.args.pooler_activation_fn, + pooler_dropout=self.args.pooler_dropout, + pooler_classifier=self.args.pooler_classifier, + use_two_images=use_two_images, + do_spectral_norm=getattr( + self.args, "spectral_norm_classification_head", False + ), + ) + + def upgrade_state_dict_named(self, state_dict, name): + super().upgrade_state_dict_named(state_dict, name) + + prefix = name + "." if name != "" else "" + current_head_names = ( + [] + if not hasattr(self, "classification_heads") + else self.classification_heads.keys() + ) + + # Handle new classification heads present in the state dict. + keys_to_delete = [] + for k in state_dict.keys(): + if not k.startswith(prefix + "classification_heads."): + continue + + head_name = k[len(prefix + "classification_heads.") :].split(".")[0] + num_classes = state_dict[ + prefix + "classification_heads." + head_name + ".out_proj.weight" + ].size(0) + inner_dim = state_dict[ + prefix + "classification_heads." + head_name + ".dense.weight" + ].size(0) + + if getattr(self.args, "load_checkpoint_heads", False): + if head_name not in current_head_names: + self.register_classification_head(head_name, num_classes, inner_dim) + else: + if head_name not in current_head_names: + logger.warning( + "deleting classification head ({}) from checkpoint " + "not present in current model: {}".format(head_name, k) + ) + keys_to_delete.append(k) + elif ( + num_classes + != self.classification_heads[head_name].out_proj.out_features + or inner_dim + != self.classification_heads[head_name].dense.out_features + ): + logger.warning( + "deleting classification head ({}) from checkpoint " + "with different dimensions than current model: {}".format( + head_name, k + ) + ) + keys_to_delete.append(k) + for k in keys_to_delete: + del state_dict[k] + + def truncate_emb(key): + if key in state_dict: + state_dict[key] = state_dict[key][:-1, :] + + # When finetuning on translation task, remove last row of + # embedding matrix that corresponds to mask_idx token. + loaded_dict_size = state_dict["encoder.embed_tokens.weight"].size(0) + if ( + loaded_dict_size == len(self.encoder.dictionary) + 1 + and "<mask>" not in self.encoder.dictionary + ): + truncate_emb("encoder.embed_tokens.weight") + truncate_emb("decoder.embed_tokens.weight") + truncate_emb("encoder.output_projection.weight") + truncate_emb("decoder.output_projection.weight") + + if loaded_dict_size < len(self.encoder.dictionary): + num_langids_to_add = len(self.encoder.dictionary) - loaded_dict_size + embed_dim = state_dict["encoder.embed_tokens.weight"].size(1) + + new_lang_embed_to_add = torch.zeros(num_langids_to_add, embed_dim) + if getattr(self, "ans_tensor_list", None): + assert len(new_lang_embed_to_add) == len(self.ans_tensor_list) + for i, ans_tensor in enumerate(self.ans_tensor_list): + ans_embed = F.embedding(ans_tensor, state_dict["encoder.embed_tokens.weight"]) + ans_embed = ans_embed.sum(0) / ans_embed.size(0) + new_lang_embed_to_add[i] = ans_embed + else: + nn.init.normal_(new_lang_embed_to_add, mean=0, std=embed_dim ** -0.5) + new_lang_embed_to_add = new_lang_embed_to_add.to( + dtype=state_dict["encoder.embed_tokens.weight"].dtype, + ) + + state_dict["encoder.embed_tokens.weight"] = torch.cat( + [state_dict["encoder.embed_tokens.weight"], new_lang_embed_to_add] + ) + state_dict["decoder.embed_tokens.weight"] = torch.cat( + [state_dict["decoder.embed_tokens.weight"], new_lang_embed_to_add] + ) + state_dict["decoder.output_projection.weight"] = torch.cat( + [state_dict["decoder.output_projection.weight"], new_lang_embed_to_add] + ) + + # Copy any newly-added classification heads into the state dict + # with their current weights. + if hasattr(self, "classification_heads"): + cur_state = self.classification_heads.state_dict() + for k, v in cur_state.items(): + if prefix + "classification_heads." + k not in state_dict: + logger.info("Overwriting " + prefix + "classification_heads." + k) + state_dict[prefix + "classification_heads." + k] = v + + +class UnIVALClassificationHead(nn.Module): + """Head for sentence-level classification tasks.""" + + def __init__( + self, + input_dim, + inner_dim, + num_classes, + activation_fn, + pooler_dropout, + pooler_classifier, + use_two_images=False, + do_spectral_norm=False, + ): + super().__init__() + self.pooler_classifier = pooler_classifier + self.use_two_images = use_two_images + input_dim = input_dim * 2 if use_two_images else input_dim + if pooler_classifier == "mlp": + self.dense = nn.Linear(input_dim, inner_dim) + self.activation_fn = utils.get_activation_fn(activation_fn) + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(inner_dim, num_classes) + elif pooler_classifier == "linear": + self.dropout = nn.Dropout(p=pooler_dropout) + self.out_proj = nn.Linear(input_dim, num_classes) + else: + raise NotImplementedError + + if do_spectral_norm: + self.out_proj = torch.nn.utils.spectral_norm(self.out_proj) + + def forward(self, features, **kwargs): + if self.pooler_classifier == 'mlp': + x = features + x = self.dropout(x) + x = self.dense(x) + x = self.activation_fn(x) + x = self.dropout(x) + x = self.out_proj(x) + elif self.pooler_classifier == 'linear': + x = features + x = self.dropout(x) + x = self.out_proj(x) + else: + raise NotImplementedError + return x + + +@register_model_architecture("unival", "unival_large") +def unival_large_architecture(args): + args.encoder_embed_path = getattr(args, "encoder_embed_path", None) + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 1024) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 1024) + args.encoder_layers = getattr(args, "encoder_layers", 12) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 16) + args.encoder_normalize_before = getattr(args, "encoder_normalize_before", True) + args.encoder_learned_pos = getattr(args, "encoder_learned_pos", True) + args.decoder_embed_path = getattr(args, "decoder_embed_path", None) + args.decoder_embed_dim = getattr(args, "decoder_embed_dim", args.encoder_embed_dim) + args.decoder_ffn_embed_dim = getattr( + args, "decoder_ffn_embed_dim", args.encoder_ffn_embed_dim + ) + args.decoder_layers = getattr(args, "decoder_layers", 12) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 16) + args.decoder_normalize_before = getattr(args, "decoder_normalize_before", True) + args.decoder_learned_pos = getattr(args, "decoder_learned_pos", True) + args.attention_dropout = getattr(args, "attention_dropout", 0.0) + args.relu_dropout = getattr(args, "relu_dropout", 0.0) + args.dropout = getattr(args, "dropout", 0.0) + args.max_target_positions = getattr(args, "max_target_positions", 1024) + args.max_source_positions = getattr(args, "max_source_positions", 1024) + args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None) + args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0) + args.share_decoder_input_output_embed = getattr( + args, "share_decoder_input_output_embed", True + ) + args.share_all_embeddings = getattr(args, "share_all_embeddings", True) + + args.decoder_output_dim = getattr( + args, "decoder_output_dim", args.decoder_embed_dim + ) + args.decoder_input_dim = getattr(args, "decoder_input_dim", args.decoder_embed_dim) + + args.no_scale_embedding = getattr(args, "no_scale_embedding", True) + args.layernorm_embedding = getattr(args, "layernorm_embedding", True) + + args.activation_fn = getattr(args, "activation_fn", "gelu") + args.pooler_activation_fn = getattr(args, "pooler_activation_fn", "tanh") + args.pooler_dropout = getattr(args, "pooler_dropout", 0.0) + args.pooler_classifier = getattr(args, "pooler_classifier", "mlp") + + args.resnet_drop_path_rate = getattr(args, "resnet_drop_path_rate", 0.0) + args.encoder_drop_path_rate = getattr(args, "encoder_drop_path_rate", 0.0) + args.decoder_drop_path_rate = getattr(args, "decoder_drop_path_rate", 0.0) + + args.resnet_type = getattr(args, "resnet_type", "resnet152") + args.token_bucket_size = getattr(args, "token_bucket_size", 256) + args.image_bucket_size = getattr(args, "image_bucket_size", 42) + + args.freeze_encoder_embedding = getattr(args, "freeze_encoder_embedding", False) + args.freeze_decoder_embedding = getattr(args, "freeze_decoder_embedding", False) + args.add_type_embedding = getattr(args, "add_type_embedding", True) + args.attn_scale_factor = getattr(args, "attn_scale_factor", 2) + + args.code_image_size = getattr(args, "code_image_size", 128) + args.patch_layernorm_embedding = getattr(args, "patch_layernorm_embedding", True) + args.code_layernorm_embedding = getattr(args, "code_layernorm_embedding", True) + args.entangle_position_embedding = getattr(args, "entangle_position_embedding", False) + args.disable_entangle = getattr(args, "disable_entangle", False) + args.sync_bn = getattr(args, "sync_bn", False) + + args.scale_attn = getattr(args, "scale_attn", False) + args.scale_fc = getattr(args, "scale_fc", False) + args.scale_heads = getattr(args, "scale_heads", False) + args.scale_resids = getattr(args, "scale_resids", False) + + args.orig_patch_image_size = getattr(args, "orig_patch_image_size", 256) + + +@register_model_architecture("unival", "unival_base") +def unival_base_architecture(args): + args.encoder_embed_dim = getattr(args, "encoder_embed_dim", 768) + args.encoder_ffn_embed_dim = getattr(args, "encoder_ffn_embed_dim", 4 * 768) + args.encoder_layers = getattr(args, "encoder_layers", 6) + args.encoder_attention_heads = getattr(args, "encoder_attention_heads", 12) + args.decoder_layers = getattr(args, "decoder_layers", 6) + args.decoder_attention_heads = getattr(args, "decoder_attention_heads", 12) + args.resnet_type = getattr(args, "resnet_type", "resnet101") + unival_large_architecture(args) + + + + + + + diff --git a/modelscope.md b/modelscope.md new file mode 100644 index 0000000000000000000000000000000000000000..33b0fa43b3ecee0256e60c387671023ad84a2a7d --- /dev/null +++ b/modelscope.md @@ -0,0 +1,23 @@ +# ModelScope + +ModelScope is a new platform that provides "Model-As-A-Service", where users can use state-of-the-art models with the lowest costs of efforts as possible. We have released: +* The pretrained and finetuned **OFA** models +* **Chinese CLIP** (the CLIP pretrained Chinese data, which was previously released in our organization) + +on the platform, including the English and Chinese ones. Feel free to check these models and use them with ModelScope, and also feel free to send us feedbacks to help us improve the product. + +## Chinese +* Chinese CLIP \[[Base](https://www.modelscope.cn/#/models/damo/multi-modal_clip-vit-base-patch16_zh/summary) | [Large](https://www.modelscope.cn/#/models/damo/multi-modal_clip-vit-large-patch14_zh/summary)\] +* Finetuned OFA on Visual Grounding (RefCOCO) \[[Large](https://www.modelscope.cn/#/models/damo/ofa_visual-grounding_refcoco_large_zh/summary)\] + +## English +* Finetuned OFA on Image Captioning \[[Large](https://www.modelscope.cn/#/models/damo/ofa_image-caption_coco_large_en/summary) | [Distill](https://modelscope.cn/#/models/damo/ofa_image-caption_coco_distilled_en/summary)\] +* Finetuned OFA on Text-to-Image Generation \[[Large](https://www.modelscope.cn/#/models/damo/ofa_text-to-image-synthesis_coco_large_en/summary) | [Distill](https://modelscope.cn/#/models/damo/ofa_visual-grounding_refcoco_distilled_en/summary)\] +* Finetuned OFA on Visual Question Answering \[[Large](https://www.modelscope.cn/#/models/damo/ofa_visual-question-answering_pretrain_large_en/summary)\] +* Finetuned OFA on Visual Grounding (RefCOCO) \[[Large](https://www.modelscope.cn/#/models/damo/ofa_visual-grounding_refcoco_large_en/summary)\] +* Finetuned OFA on Visual Entailment \[[Large](https://www.modelscope.cn/#/models/damo/ofa_visual-entailment_snli-ve_large_en/summary) | [Distill](https://modelscope.cn/#/models/damo/ofa_visual-entailment_snli-ve_distilled_v2_en/summary)\] +* Finetuned OFA on Summarization (Gigaword) \[[Large](https://www.modelscope.cn/#/models/damo/ofa_summarization_gigaword_large_en/summary)\] +* Finetuned OFA on Natural Language Entailment (MNLI, can be used to finetune on the GLUE benchmark) \[[Large](https://modelscope.cn/#/models/damo/ofa_text-classification_mnli_large_en/summary)\] +* Finetuned OFA on Image Classification (ImageNet-1k) \[[Large](https://modelscope.cn/#/models/damo/ofa_image-classification_imagenet_large_en/summary)\] + + diff --git a/ofa_module/__init__.py b/ofa_module/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..30b147a95464b55f55a0dd1dc8555ca69ebec358 --- /dev/null +++ b/ofa_module/__init__.py @@ -0,0 +1,5 @@ +import data +import models +import tasks +import criterions +import utils \ No newline at end of file diff --git a/ofa_module/__pycache__/__init__.cpython-37.pyc b/ofa_module/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4a0646aa098b56cd3899f568e38176f31ac4f79 Binary files /dev/null and b/ofa_module/__pycache__/__init__.cpython-37.pyc differ diff --git a/ofa_module/__pycache__/__init__.cpython-38.pyc b/ofa_module/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10669a31036a6c7713f4d4565123f30716b5cba0 Binary files /dev/null and b/ofa_module/__pycache__/__init__.cpython-38.pyc differ diff --git a/ofa_module/__pycache__/__init__.cpython-39.pyc b/ofa_module/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16b4231d30d6185b6f59d7550c5f342b4b7fceff Binary files /dev/null and b/ofa_module/__pycache__/__init__.cpython-39.pyc differ diff --git a/ofa_test.ipynb b/ofa_test.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..7837e02afc4871569475590333fb300a545d1fbd --- /dev/null +++ b/ofa_test.ipynb @@ -0,0 +1,2499 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json \n", + "import torch\n", + "# import clip\n", + "from PIL import Image\n", + "# import sng_parser\n", + "from tqdm import tqdm \n", + "import codecs\n", + "import numpy as np\n", + "import csv\n", + "import sys\n", + "\n", + "from io import BytesIO\n", + "import base64" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100it [00:00, 14325.30it/s]\n" + ] + } + ], + "source": [ + "csv.field_size_limit(sys.maxsize)\n", + "\n", + "# path_data = '/data/mshukor/data/ofa/pretrain_example/vision_language_examples.tsv'\n", + "# selected_cols='0,1,2,3,4,5,6,7'\n", + "\n", + "# path_data = '/data/mshukor/data/ofa/pretrain_example/detection_examples.tsv'\n", + "# selected_cols='0,1,2'\n", + "\n", + "# path_data = '/data/mshukor/data/ofa/pretrain_example/image_examples.tsv'\n", + "# selected_cols='0,1,2'\n", + "\n", + "path_data = '/data/mshukor/data/ofa/pretrain_example/text_examples.tsv'\n", + "selected_cols='0,1'\n", + "\n", + "data_example = []\n", + "\n", + "selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + "\n", + "with open(path_data) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + "\n", + " d = [line[i] for i in selected_col_ids]\n", + "# print(d)\n", + " data_example.append(d)\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['100',\n", + " '...please depart this field clean unless you might be answering the question. do not ask questions you already know the answer to. thanks.retrieved from \" \" ad blocker interference detected! wikia is a single-to-usefulness web site that makes cash from promoting. we\\'ve a experience for viewers using ad blockers wikia shouldn\\'t be if youve made further modifications. take away the custom ad blocker (s) and the page leave timber as expected. categories : un-answered questionsadd class cancelsave per the reddit twine, flac files will be synced to an ios gadget via icloud impel, then accessed through thenew information utility , which will allow for local playback of the excessive-high quality audio files straight by the side of the device. if , it could stamp the first time that apple has offered help for the favored flac format an ios gadget.']" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "line" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['7',\n", + " 'perhaps the clearest indication of who won and lost came quickly on the heels of the event itself: the democratic post-debate message was that joe biden scored a clear win; the republican message was that joe biden was too mean to paul ryan. the former is a boast of success; the latter is an excuse for failure. in the larger context, it’s hard to overstate how much democrats needed a shot in the arm like this. the surface-level goals of any vice presidential debate is for the candidates to demonstrate a capacity to step up in the event of a crisis, while defending their ticket’s agenda and knocking their rivals’ agenda. but for biden, the overarching benefit was about the basic morale of his party with less than four weeks to go until election day: he wanted to give democratic voters something to feel good about, and he did. who the hell am i! i’m a liberal that is extreme in some ways and not in others. i support president obama and make no apologies for it. i think he has done a phenomenal job, especially when you consider that he inherited a huge mess and has faced unprecedented opposition from a lazy & desperate republican party. i’m a film producer/director/editor, adjunct professor, technician, media critic and photographer when i’m not reading left wing blogs and typing on this one. – on twitter @extremeliberal or email at liberalforreal (at) gmail.com own an important part of american history! cicely tyson narrates this award winning documentary that tells the story of african american migration from the old south to the prosperous north. winner of 5 awards including \"best film\" at the astoria international film festival, the \"paul robeson award\" at the newark black film festival and \"best film relating to the black experience\" at the xxv international black cinema berlin/germany!']" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_[6]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tasks = set()\n", + "datasets = set()\n", + "\n", + "for d in data:\n", + " tasks.add(d[-1])\n", + " datasets.add(d[-2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "int(data[10][0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# len(data[0][2:][0].split(' '))\n", + "# len(data[0][1])\n", + "text = data[10][1]\n", + "print(len(text.split(' ')))\n", + "print(len(text))\n", + "from nltk.tokenize import word_tokenize\n", + "len(word_tokenize(text))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "text" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from nltk.tokenize.treebank import TreebankWordDetokenizer\n", + "TreebankWordDetokenizer().detokenize(word_tokenize(text))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "key = 'refcoco_train'\n", + "index = -2\n", + "for d in data:\n", + " if d[index] == key:\n", + " print(d[2:])\n", + "# break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "d[4].split(',')\n", + "str([287.0, 127.0, 340.0, 162.0])\n", + "'{:.2f},{:.2f},{:.2f},{:.2f}'.format(287.0, 127.0, 340.0, 162.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(len(data))\n", + "data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_captions_path = '/data/mshukor/data/ofa/pretrain_example/negative_sample/all_captions.txt'\n", + "all_objects_path = '/data/mshukor/data/ofa/pretrain_example/negative_sample/object.txt'\n", + "\n", + "all_object_list = [\n", + " row.strip() for row in open(all_objects_path) if row.strip() != ''\n", + "]\n", + "all_caption_list = [\n", + " row.strip() for row in open(all_captions_path) if row.strip() != ''\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(all_object_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(all_caption_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_object_list[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_caption_list[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "json_path = '/data/mshukor/data/ofa/pretrain_example/negative_sample/type2ans.json'\n", + "type2ans = json.load(open(json_path,'r'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "type2ans.keys()\n", + "# type2ans['what color is the']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Our data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "181767it [00:02, 70482.72it/s]\n" + ] + } + ], + "source": [ + "# path_data = '/data/mshukor/data/ofa/pretrain_ours/text_mini.tsv'\n", + "# selected_cols='0,1'\n", + "\n", + "path_data = '/data/mshukor/data/ofa/pretrain_ours/detection_mini.tsv'\n", + "selected_cols='0,1,2'\n", + "\n", + "# path_data = '/data/mshukor/data/ofa/pretrain_ours/vision_language_mini.tsv'\n", + "# selected_cols='0,1,2,3,4,5,6,7'\n", + "\n", + "# path_data = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "# selected_cols='0,1,2'\n", + "\n", + "data = []\n", + "\n", + "selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + "\n", + "with open(path_data) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + "\n", + " d = [line[i] for i in selected_col_ids]\n", + "# print(d)\n", + " data.append(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# new_data = []\n", + "# for d in data:\n", + "# label_list = d[2].strip().split('&&')\n", + "# new_label_list = []\n", + "# for label in label_list:\n", + "# lab = label.strip().split(',', 5)[:4] # x0, y0, x1, y1, cat_id, cat\n", + " \n", + "# if any([\"&\" in l for l in lab]):\n", + "# lab = [remove_special(l) for l in lab]\n", + " \n", + "# print(lab)\n", + "# lab_ = lab + label.strip().split(',', 5)[4:]\n", + "# lab_ = ','.join(lab_)\n", + "# new_label_list.append(lab_)\n", + "# new_label_list = ['&&'.join(new_label_list)]\n", + "# new_data.append(d[:2]+new_label_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['&40.000', '155.000', '44.000', '164.000']\n" + ] + } + ], + "source": [ + "for d in data:\n", + " label_list = d[2].strip().split('&&')\n", + " new_label_list = []\n", + " for label in label_list:\n", + " lab = label.strip().split(',', 5)[:4] # x0, y0, x1, y1, cat_id, cat\n", + " \n", + " if any([\"&\" in l for l in lab]):\n", + " print(lab)\n", + " # lab = [remove_special(l) for l in lab]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['0',\n", + " 'coco/train2014/COCO_train2014_000000057870.jpg',\n", + " '1.020,279.960,534.110,480.000,67,dining table&&90.670,271.490,262.510,480.000,62,chair&&233.290,270.450,403.610,473.810,62,chair&&367.820,264.270,506.970,480.000,62,chair&&476.760,261.030,596.490,462.740,62,chair&&263.030,174.370,417.670,299.400,64,potted plant&&539.330,290.160,640.000,469.210,62,chair&&10.790,260.030,125.120,384.070,62,chair&&560.800,413.950,639.090,479.200,67,dining table&&20.540,376.760,103.780,431.890,62,chair&&1.080,373.210,32.360,480.000,62,chair&&298.200,235.170,381.210,269.250,86,vase&&152.170,256.670,230.580,285.780,62,chair&&364.400,256.570,417.060,283.210,62,chair&&296.780,277.790,329.260,289.780,84,book&&292.800,289.310,314.210,300.650,84,book&&285.800,257.460,299.770,273.600,62,chair']" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1.020,279.960,534.110,480.000,67,dining table',\n", + " '90.670,271.490,262.510,480.000,62,chair',\n", + " '233.290,270.450,403.610,473.810,62,chair',\n", + " '367.820,264.270,506.970,480.000,62,chair',\n", + " '476.760,261.030,596.490,462.740,62,chair',\n", + " '263.030,174.370,417.670,299.400,64,potted plant',\n", + " '539.330,290.160,640.000,469.210,62,chair',\n", + " '10.790,260.030,125.120,384.070,62,chair',\n", + " '560.800,413.950,639.090,479.200,67,dining table',\n", + " '20.540,376.760,103.780,431.890,62,chair',\n", + " '1.080,373.210,32.360,480.000,62,chair',\n", + " '298.200,235.170,381.210,269.250,86,vase',\n", + " '152.170,256.670,230.580,285.780,62,chair',\n", + " '364.400,256.570,417.060,283.210,62,chair',\n", + " '296.780,277.790,329.260,289.780,84,book',\n", + " '292.800,289.310,314.210,300.650,84,book',\n", + " '285.800,257.460,299.770,273.600,62,chair']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "label_list" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def remove_special(input_string):\n", + " final_string = \"\"\n", + " for character in input_string:\n", + " if character == \" \":\n", + " final_string = final_string + character\n", + " else:\n", + " if(character.isalnum()):\n", + " final_string = final_string + character\n", + " return final_string" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█| 5593207/5593207 [00:35<00:0\n" + ] + } + ], + "source": [ + "for d in tqdm(data):\n", + " label = d[2]\n", + " d[2] = remove_special(caption)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['0',\n", + " 'coco/train2014/COCO_train2014_000000057870.jpg',\n", + " '1.020,279.960,534.110,480.000,67,dining table&&90.670,271.490,262.510,480.000,62,chair&&233.290,270.450,403.610,473.810,62,chair&&367.820,264.270,506.970,480.000,62,chair&&476.760,261.030,596.490,462.740,62,chair&&263.030,174.370,417.670,299.400,64,potted plant&&539.330,290.160,640.000,469.210,62,chair&&10.790,260.030,125.120,384.070,62,chair&&560.800,413.950,639.090,479.200,67,dining table&&20.540,376.760,103.780,431.890,62,chair&&1.080,373.210,32.360,480.000,62,chair&&298.200,235.170,381.210,269.250,86,vase&&152.170,256.670,230.580,285.780,62,chair&&364.400,256.570,417.060,283.210,62,chair&&296.780,277.790,329.260,289.780,84,book&&292.800,289.310,314.210,300.650,84,book&&285.800,257.460,299.770,273.600,62,chair']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█| 181767/181767 [00:00<00:00,\n" + ] + } + ], + "source": [ + "for d in tqdm(data):\n", + " d[2] = d[2].replace('\\\"', '')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "data_ = []\n", + "with open(path_data) as file:\n", + " for i in tqdm(range(6458670)):\n", + " column_l = file.readline().rstrip(\"\\n\").split(\"\\t\")\n", + " data_.append(column_l)\n", + " if len(column_l) < 2:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "5593207it [00:03, 1463300.52it/s]\n" + ] + } + ], + "source": [ + "\n", + "data_example = []\n", + "fp = open('/data/mshukor/data/ofa/pretrain_ours/vision_language_mini_.tsv', \"r\")\n", + "data_example = []\n", + "for line in tqdm(fp):\n", + " data_example.append(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2796604\tcc3m/train/8/2d0d96e4ecb8e2e959a3bf10d59b9d05ac114aea.jpg\tthe residential development under construction in district\t\t\t\tcc3m\tcaption\n", + "\n" + ] + } + ], + "source": [ + "print(data_example[2796604])" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/val2014/COCO_val2014_000000329789.jpg\tA young man is eating a slice of pizza in his room\t\t\t\tcoco_karp\tcaption\n", + "\n" + ] + } + ], + "source": [ + "data_example[2796604]\n", + "fp.seek(2796604)\n", + "for l in fp:\n", + " print(l)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2317 2317\n", + "2510 2514 2510\n" + ] + } + ], + "source": [ + "len(data_[10].rstrip(\"\\n\").split(\"\\t\")[1])# len(line)\n", + "# len(data_[10].rstrip(\"\\n\").split(\"\\t\")[1].encode('utf-8'))\n", + "print(len(data_example[10]), len(data_example[10].encode('utf-8')))\n", + "print(len(data_[10]), len(data_[10].encode('utf-8')), len(data_[10].encode('utf-8').decode(\"utf-8\")))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(data_[10].encode('utf-8'))\n", + "print(data_[10])\n", + "\n", + "print(data_example[10].encode('utf-8'))\n", + "print(data_example[10])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "6458670it [01:45, 61129.36it/s] \n" + ] + } + ], + "source": [ + "output_path = '/data/mshukor/data/ofa/pretrain_ours/text_mini.tsv'\n", + "\n", + "fp = open(output_path, \"r\")\n", + "data_ = []\n", + "for line in tqdm(fp):\n", + " data_.append(line)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "6458670it [04:08, 25941.37it/s]\n" + ] + } + ], + "source": [ + "output_path = '/data/mshukor/data/ofa/pretrain_ours/text_mini.tsv'\n", + "\n", + "start_id = 0 \n", + "num_max_characters = 2500\n", + "\n", + "with open(output_path, 'w', newline='\\n') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for i, t in tqdm(enumerate(data)):\n", + " text = t[1]\n", + " item = [start_id, text]\n", + " csv_output.writerow(item)\n", + " start_id+=1" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████| 181767/181767 [00:03<00:00, 51934.09it/s]\n" + ] + } + ], + "source": [ + "output_path = '/data/mshukor/data/ofa/pretrain_ours/detection_mini.tsv'\n", + "\n", + "with open(output_path, 'w', newline='\\n') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for t in tqdm(data):\n", + " csv_output.writerow(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['5593206',\n", + " 'train2014/COCO_train2014_000000524286.jpg',\n", + " '',\n", + " 'Is that a laptop?',\n", + " '1.0|!+yes',\n", + " '',\n", + " 'vqa_train',\n", + " 'qa']" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create data tsv" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def convert_img_to_str(file_name):\n", + " img = Image.open(file_name) # path to file\n", + " img_buffer = BytesIO()\n", + " img.save(img_buffer, format=img.format)\n", + " byte_data = img_buffer.getvalue()\n", + " base64_str = base64.b64encode(byte_data) # bytes\n", + " base64_str = base64_str.decode(\"utf-8\") # str\n", + " return base64_str" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create VL tsv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Caption" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data_path = '/data/mshukor/data/our_albef_data/json_pretrain/sbu.json'\n", + "original_data = json.load(open(original_data_path,'r'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from preprocess.utils import get_tsv_data_from_jsons\n", + " \n", + "datasets = [\n", + " '/data/mshukor/data/our_albef_data/json_pretrain/coco_karp.json',\n", + " '/data/mshukor/data/our_albef_data/json_pretrain/vg_albef.json',\n", + " '/data/mshukor/data/our_albef_data/json_pretrain/sbu.json',\n", + " '/data/mshukor/data/our_albef_data/json_pretrain/cc3m.json', \n", + " \n", + " ['/data/mshukor/data/refcoco/refcoco+/refs(unc).p', '/data/mshukor/data/refcoco/refcoco+/instances.json'],\n", + " \n", + " '/data/mshukor/data/our_albef_data/data/vqa_train.json',\n", + "]\n", + "\n", + "start_id = 0\n", + "task_types = ['caption',\n", + " 'caption',\n", + " 'caption',\n", + " 'caption',\n", + " 'visual_grounding',\n", + " 'qa',]\n", + "\n", + "tsvs = get_tsv_data_from_jsons(datasets, start_id, task_types, convert_images=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(tsvs)\n", + "# tsvs[-10000]\n", + "tsvs[-1000000]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import csv\n", + "from io import StringIO\n", + "\n", + "output_path = '/data/mshukor/data/ofa/pretrain_ours/vision_language_mini.tsv'\n", + "\n", + "with open(output_path, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for t in tqdm(tsvs):\n", + " csv_output.writerow(t)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "csv.field_size_limit(sys.maxsize)\n", + "\n", + "\n", + "out_data = []\n", + "selected_cols='0,1,2,3,4,5,6,7'\n", + "\n", + "selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + "\n", + "with open(output_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in selected_col_ids]\n", + " out_data.append(d)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out_data[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### VQA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data_path = '/data/mshukor/data/our_albef_data/data/vqa_train.json'\n", + "original_data = json.load(open(original_data_path,'r'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data[100]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 1.0|!+horizontal&&0.3|!+south&&0.3|!+straight&&0.3|!+vertical\n", + "\n", + "from preprocess.utils import get_tsv_vqa_data_from_json\n", + "\n", + "\n", + "start_id = 0\n", + "dataset_name = 'vqav2'\n", + "task_type = 'qa'\n", + "\n", + "image_root = '/data/mshukor/data/coco'\n", + "tmp = get_tsv_vqa_data_from_json(original_data, start_id, dataset_name, task_type, image_root=image_root, convert_images=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tmp[10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visual Grounding " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data_path = '/data/mshukor/data/our_albef_data/data/refcoco+_train.json'\n", + "original_data = json.load(open(original_data_path,'r'))\n", + "\n", + "original_data_path = '/data/mshukor/data/our_albef_data/data/refcoco+/dets.json'\n", + "det_file = json.load(open(original_data_path,'r'))\n", + "\n", + "original_data_path = '/data/mshukor/data/our_albef_data/data/refcoco+/cocos.json'\n", + "coco_file = json.load(open(original_data_path,'r'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list(det_file.keys())[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data_path = '/data/mshukor/data/refcoco/refcoco+/instances.json'\n", + "original_data = json.load(open(original_data_path,'r'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "ref_path = '/data/mshukor/data/refcoco/refcoco+/refs(unc).p'\n", + "refs = pickle.load(open(ref_path, 'rb'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for i, ref in tqdm(enumerate(refs)):\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(refs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "refs[500]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "id_to_annot = {}\n", + "for annot in original_data['annotations']:\n", + " id_to_annot[annot['id']] = annot\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "id_to_images = {}\n", + "for annot in tqdm(original_data['images']):\n", + " id_to_images[annot['id']] = annot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "id_to_images[576457]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list(id_to_annot.keys())[:10]\n", + "id_to_annot[1640859]['bbox']\n", + "for r in tqdm(id_to_annot.values()):\n", + " if r['bbox'][0] > 0:\n", + " print(r['bbox'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list(original_data.keys())[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ref_path = '/data/mshukor/data/refcoco/refcoco+/refs(unc).p'\n", + "instances_path = '/data/mshukor/data/refcoco/refcoco+/instances.json'\n", + "start_id = 0\n", + "dataset_name='refcoco_train'\n", + "task_type='visual_grounding'\n", + "convert_images=False\n", + "split='train'\n", + "\n", + "tmp = get_tsv_from_refcoco(ref_path, instances_path, start_id, dataset_name=dataset_name, task_type=task_type, convert_images=convert_images, split=split)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tmp[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Image.open('/data/mshukor/data/coco/train2014/COCO_train2014_000000000072.jpg').convert('RGB')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "original_data['images'][:10]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ['third book starting from left', '', '29.1,11.72,66.81,343.41', '', 'refcoco_train', 'visual_grounding']\n", + "\n", + "original_data['categories']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imagenet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# image-id and image base64 string .txt file \n", + "# id, image, code in tsv final \n", + "\n", + "from preprocesss.utils import create_imagenet_txt_files\n", + "\n", + "\n", + "path_data = '/data/mshukor/data/imagenet/val'\n", + "output_path = '/data/mshukor/data/ofa/pretrain_ours/imagenet_val.txt'\n", + "\n", + "\n", + "create_imagenet_txt_files(path_data, output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "start_id\n", + "len(data)\n", + "data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "code_path = '/data/mshukor/data/ofa/pretrain_ours/imagenet_train_codes.tsv'\n", + "output_path = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "\n", + "def save_image_only_tsv_from_code_files(code_path, output_path, start_id=0):\n", + " selected_col_ids = [0,1]\n", + " out_data = []\n", + " with open(code_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in selected_col_ids]\n", + " d = [start_id]+d\n", + " out_data.append(d)\n", + "\n", + "\n", + " with open(output_path, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for t in tqdm(out_data):\n", + " csv_output.writerow(t)\n", + "\n", + "save_image_only_tsv_from_code_files(code_path, output_path, start_id=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "selected_col_ids = [0,1,2]\n", + "out_data = []\n", + "with open(output_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in selected_col_ids]\n", + " out_data.append(d)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(out_data[0][2].split(' '))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Fix image paths" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1281167it [00:16, 79250.80it/s]\n" + ] + } + ], + "source": [ + "\n", + "path_data = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "selected_cols='0,1,2'\n", + "\n", + "data = []\n", + "\n", + "selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + "\n", + "with open(path_data) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + "\n", + " d = [line[i] for i in selected_col_ids]\n", + "# print(d)\n", + " data.append(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1281167it [00:16, 76760.12it/s]\n", + "1281167it [00:01, 671149.72it/s]\n", + "100%|█████| 1281167/1281167 [00:01<00:00, 947543.73it/s]\n" + ] + } + ], + "source": [ + "# from imge-id img-path to \n", + "def replace_image_id_by_path(input_tsv, output_tsv, mapping_file):\n", + " selected_cols='0,1,2'\n", + " data = []\n", + " selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + " with open(input_tsv) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in selected_col_ids]\n", + " data.append(d)\n", + " \n", + " im_id_to_path = {}\n", + " with open(mapping_file) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in [0, 1]]\n", + " im_id_to_path[d[0]] = d[1]\n", + " \n", + " for d in tqdm(data):\n", + " im_id = d[1].split('/')[-1].split('.')[0]\n", + " im_path = im_id_to_path[im_id]\n", + " d[1] = im_path\n", + " \n", + " with open(output_tsv, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for t in tqdm(data):\n", + " csv_output.writerow(t)\n", + " \n", + " return data\n", + "\n", + "input_tsv = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "output_tsv = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "mapping_file = '/data/mshukor/data/ofa/pretrain_ours/imagenet_train.txt'\n", + "\n", + "tmp = replace_image_id_by_path(input_tsv, output_tsv, mapping_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['0',\n", + " 'RawImages/train/n03146219/n03146219_8050.JPEG',\n", + " '7442 662 7977 1652 6320 650 4376 992 1596 7734 1925 5335 3935 5604 5697 4504 5114 4050 144 215 144 6691 5321 7769 4755 3346 4691 3469 4175 1351 6907 9 6948 7749 7166 215 1026 931 970 4168 2675 6874 6248 2306 6138 8052 2970 6302 5550 2491 6931 969 6574 8014 6588 6639 389 1882 688 4691 4266 675 6248 3938 2387 4365 5999 261 2966 3499 651 5290 970 3526 5583 516 167 2103 1513 198 6657 7442 1118 7207 7307 1792 2078 388 4285 3417 5450 6959 6999 1306 1649 4556 2533 1103 6869 7681 8051 1916 7160 7743 2704 8063 2726 4860 2383 1635 8061 3497 7327 5915 7836 5697 1719 2136 96 970 7184 5167 2250 404 7007 7565 2742 33 7076 5250 7790 1838 1298 2847 3250 1204 1934 5550 4360 5688 1791 3465 634 4663 2991 5352 4066 4157 946 1596 3504 5855 5629 5411 7695 3627 3942 5631 2736 2883 5059 1423 2009 2643 1873 4960 1661 545 1396 3450 3145 211 6869 2226 6780 2724 4606 3702 3667 891 6236 6419 3531 7032 5277 3381 3031 7878 725 1652 1813 5037 949 3087 405 7884 3784 5432 633 4256 235 3182 3686 5450 2419 1593 7948 5741 6237 7233 20 7470 7071 182 1584 6780 7913 2691 7207 5094 5199 4502 5030 2360 448 5129 2713 1094 1678 1934 2458 2970 2133 867 3332 6138 294 3260 5495 4189 5732 3940 5629 4139 7335 7607 3248 4981 2109 3660 4364 7763 3964 7163 6702 691']" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████| 1281167/1281167 [00:03<00:00, 336250.44it/s]\n" + ] + } + ], + "source": [ + "# imgage_dir = 'imagenet/RawImages/train/'\n", + "# for d in tqdm(data):\n", + "# im_id = d[1]\n", + "# im_dir = im_id.split('_')[0]\n", + "# im_path = os.path.join(im_dir, im_id+'.JPEG')\n", + "# d[1] = os.path.join(imgage_dir, im_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['0',\n", + " 'imagenet/RawImages/train/n03146219/n03146219_8050.JPEG',\n", + " '7442 662 7977 1652 6320 650 4376 992 1596 7734 1925 5335 3935 5604 5697 4504 5114 4050 144 215 144 6691 5321 7769 4755 3346 4691 3469 4175 1351 6907 9 6948 7749 7166 215 1026 931 970 4168 2675 6874 6248 2306 6138 8052 2970 6302 5550 2491 6931 969 6574 8014 6588 6639 389 1882 688 4691 4266 675 6248 3938 2387 4365 5999 261 2966 3499 651 5290 970 3526 5583 516 167 2103 1513 198 6657 7442 1118 7207 7307 1792 2078 388 4285 3417 5450 6959 6999 1306 1649 4556 2533 1103 6869 7681 8051 1916 7160 7743 2704 8063 2726 4860 2383 1635 8061 3497 7327 5915 7836 5697 1719 2136 96 970 7184 5167 2250 404 7007 7565 2742 33 7076 5250 7790 1838 1298 2847 3250 1204 1934 5550 4360 5688 1791 3465 634 4663 2991 5352 4066 4157 946 1596 3504 5855 5629 5411 7695 3627 3942 5631 2736 2883 5059 1423 2009 2643 1873 4960 1661 545 1396 3450 3145 211 6869 2226 6780 2724 4606 3702 3667 891 6236 6419 3531 7032 5277 3381 3031 7878 725 1652 1813 5037 949 3087 405 7884 3784 5432 633 4256 235 3182 3686 5450 2419 1593 7948 5741 6237 7233 20 7470 7071 182 1584 6780 7913 2691 7207 5094 5199 4502 5030 2360 448 5129 2713 1094 1678 1934 2458 2970 2133 867 3332 6138 294 3260 5495 4189 5732 3940 5629 4139 7335 7607 3248 4981 2109 3660 4364 7763 3964 7163 6702 691']" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████| 1281167/1281167 [00:27<00:00, 46704.02it/s]\n" + ] + } + ], + "source": [ + "output_path = '/data/mshukor/data/ofa/pretrain_ours/image_mini.tsv'\n", + "with open(output_path, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for t in tqdm(data):\n", + " csv_output.writerow(t)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Object detection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### COCO" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# '505.856,189.994,799.744,450.016,/m/07j7r,tree&&753.664,384.00600000000003,827.392,446.572,/m/0c9ph5,flower'\n", + "\n", + "path_json = '/data/mshukor/data/coco/annotations/instances_train2014.json'\n", + "\n", + "data = json.load(open(path_json,'r'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_tsv_from_coco_detection(instances_path, start_id, convert_images=True, split='train'):\n", + "\n", + " instances = json.load(open(instances_path,'r'))\n", + " imgid_to_annot = {}\n", + " for annot in tqdm(instances['annotations']):\n", + " if annot['image_id'] not in imgid_to_annot:\n", + " imgid_to_annot[annot['image_id']] = [annot]\n", + " else:\n", + " imgid_to_annot[annot['image_id']].append(annot)\n", + "\n", + " id_to_category = {}\n", + " for annot in tqdm(instances['categories']):\n", + " id_to_category[annot['id']] = annot['name']\n", + "\n", + " tsv_data = []\n", + " missied = []\n", + " for ref in tqdm(instances['images']):\n", + " ref_split = split\n", + " image_id = ref['id']\n", + " file_name = ref['file_name']\n", + "\n", + " if ref_split == 'train':\n", + " file_name = os.path.join('coco/train2014', file_name)\n", + "\n", + " if convert_images:\n", + " img_path = os.path.join('/data/mshukor/data/', file_name)\n", + " img = convert_img_to_str(img_path)\n", + " else:\n", + " img_path = file_name.replace('/data/mshukor/data/', '')\n", + " img = img_path\n", + "\n", + " # ann_id = ref['id']\n", + " # annot = id_to_annot[ann_id]\n", + " if image_id not in imgid_to_annot:\n", + " missied.append(image_id)\n", + " continue\n", + " annots = imgid_to_annot[image_id]\n", + " detections = []\n", + " areas = []\n", + " for annot in annots:\n", + " bbox = annot['bbox'] # x,y,w,h bottom left\n", + " area = bbox[2]*bbox[3]\n", + " x1, y1, x2, y2 = bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3] # top left, bottom right \n", + " # box = '{:.3f},{:.3f},{:.3f},{:.3f}'.format(x1, y1, x2, y2)\n", + "\n", + " object_id = annot['category_id']\n", + " category = id_to_category[object_id]\n", + "\n", + " tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category)\n", + " areas.append(area)\n", + " detections.append(tmp)\n", + "\n", + " sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True)\n", + " detections = [detections[k] for k in sorted_indices]\n", + " detections = '&&'.join(detections)\n", + " t = [start_id, img, detections]\n", + "\n", + " tsv_data.append(t)\n", + " start_id+=1\n", + "\n", + " return tsv_data\n", + "\n", + "instances_path = '/data/mshukor/data/coco/annotations/instances_train2014.json'\n", + "start_id = 0\n", + "tmp = get_tsv_from_coco_detection(instances_path, start_id, convert_images=False, split='train')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list(imgid_to_annot.keys())[:10]\n", + "len(missied)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### VG" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_tsv_from_vg_detection(instances_path, path_images, start_id, convert_images=True, split='train'):\n", + " \n", + " instances = json.load(open(instances_path,'r'))\n", + " \n", + " id_to_objects = {}\n", + " for d in instances:\n", + " id_to_objects[d['id']] = d\n", + "\n", + "\n", + " \n", + " id_to_image_path = {}\n", + " for root, dirs, files, in os.walk(path_images):\n", + " for d in dirs:\n", + " dir_path = os.path.join(root, d)\n", + " for _, _, dir_files in os.walk(dir_path):\n", + " for f in dir_files:\n", + " file_path = os.path.join(dir_path, f)\n", + " file_path = '/'.join(file_path.split('/')[-4:])\n", + " image_id = f.split('.')[0]\n", + " id_to_image_path[image_id] = file_path\n", + "\n", + " \n", + "\n", + "\n", + " tsv_data = []\n", + " missied = []\n", + " negs = []\n", + " for ref in tqdm(id_to_image_path.keys()):\n", + " ref_split = split\n", + " \n", + " image_id = ref\n", + " \n", + " file_name = id_to_image_path[image_id]\n", + " if convert_images:\n", + " img_path = os.path.join('/data/mshukor/data/', file_name)\n", + " img = convert_img_to_str(img_path)\n", + " else:\n", + " img_path = file_name.replace('/data/mshukor/data/', '')\n", + " img = img_path\n", + "\n", + " \n", + " if int(image_id) in id_to_objects:\n", + " objects = id_to_objects[int(image_id)]['objects']\n", + " else:\n", + " missied.append(image_id)\n", + " continue\n", + " \n", + " if len(objects) == 0:\n", + " missied.append(image_id)\n", + " continue\n", + " \n", + " \n", + " areas = []\n", + " detections = []\n", + " for annot in objects:\n", + " x,y,w,h = annot['x'], annot['y'], annot['w'], annot['h'] # x,y,w,h bottom left\n", + " \n", + " area = w*h\n", + " \n", + " x1, y1, x2, y2 = x, y, x + w, y + h # top left, bottom right \n", + " \n", + " if x1 < 0 or x2 < 0:\n", + " negs.append(annot)\n", + " x1 = max(0, x1)\n", + " x2 = max(0, x2)\n", + " \n", + " \n", + " category = ','.join(annot['names']).replace('\\x00','')\n", + " object_id = annot['id']\n", + " \n", + " \n", + " tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category)\n", + " detections.append(tmp)\n", + " areas.append(area)\n", + "\n", + " sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True)\n", + " detections = [detections[k] for k in sorted_indices]\n", + " \n", + " detections = '&&'.join(detections)\n", + " t = [start_id, img, detections]\n", + "\n", + " tsv_data.append(t)\n", + " start_id+=1\n", + " print('missed images:', len(missied), 'negs', len(negs))\n", + " return tsv_data\n", + "\n", + "\n", + "instances_path = '/data/mshukor/data/visual_genome/annotations/objects.json'\n", + "path_images = '/data/mshukor/data/visual_genome/images'\n", + "start_id = 0\n", + "\n", + "tmp = get_tsv_from_vg_detection(instances_path, path_images, start_id, convert_images=False, split='train')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "image_root = '/data/mshukor/data/'\n", + "\n", + "Image.open(image_root+id_to_image_path['1087']).convert('RGB')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### OpenImagesV5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# data_path = '/data/mshukor/data/OpenImagesV5/train-annotations-bbox.csv'\n", + "# data_path = '/data/mshukor/data/OpenImagesV5/train-images-boxable.csv'\n", + "# data_path = '/data/mshukor/data/OpenImagesV5/train-images-boxable-with-rotation.csv'\n", + "data_path = '/data/mshukor/data/OpenImagesV5/class-descriptions-boxable.csv'\n", + "\n", + "\n", + "\n", + "\n", + "selected_col_ids = [0,1,2]\n", + "out_data = []\n", + "with open(data_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for i, line in tqdm(enumerate(tsv_file)):\n", + " # d = [line[i] for i in selected_col_ids]\n", + " out_data.append(line)\n", + "# print(line)\n", + "# if i > 2:\n", + "# break\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_tsv_from_openimages_detection(instances_path, path_images, start_id, convert_images=False, split='train')\n", + "\n", + " id_to_image_path = {}\n", + " for root, dirs, files, in os.walk(path_images):\n", + " for d in dirs:\n", + " dir_path = os.path.join(root, d)\n", + " for _, _, dir_files in os.walk(dir_path):\n", + " for f in dir_files:\n", + " file_path = os.path.join(dir_path, f)\n", + " file_path = '/'.join(file_path.split('/')[-4:])\n", + " image_id = f.split('.')[0]\n", + " id_to_image_path[image_id] = file_path\n", + "\n", + " image_root = '/gpfsdswork/dataset'\n", + "\n", + " def imagepath_to_image_size(path):\n", + " w, h = Image.open(path).size\n", + "\n", + " id_to_annot = {}\n", + " with open(instances_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for i, line in tqdm(enumerate(tsv_file)):\n", + " img_id = line[0].split(',')[0]\n", + " if img_id in id_to_annot:\n", + " id_to_annot[img_id].append(line)\n", + " else:\n", + " id_to_annot[img_id] = [line]\n", + "\n", + " classid_to_class = {}\n", + "\n", + " with open(class_path) as file:\n", + " tsv_file = csv.reader(file, delimiter=',')\n", + " for i, line in tqdm(enumerate(tsv_file)):\n", + " classid_to_class[line[0]] = line[1]\n", + "\n", + " tsv_data = []\n", + " for img_id in id_to_annot.keys():\n", + " annots = id_to_annot[img_id]\n", + " img_path = id_to_image_path[img_id]\n", + " orig_img_path = os.path.join(image_root, img_path)\n", + " w, h = imagepath_to_image_size(path)\n", + "\n", + " if convert_images:\n", + " img = convert_img_to_str(orig_img_path)\n", + " else:\n", + " img = img_path\n", + "\n", + " areas = []\n", + " detections = []\n", + " for d in annots:\n", + " d = d[0].split(',')\n", + "\n", + " x1, x2, y1, y2 = d[4:8]\n", + " x1, x2, y1, y2 = x1*w, x2*w, y1*h, y2*h\n", + " box_w, box_h = x2 - x1, y2 - y1\n", + " area = box_w*box_h\n", + " areas.append(area)\n", + "\n", + " object_id = d[2]\n", + " category = classid_to_class[object_id]\n", + "\n", + " tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category)\n", + " detections.append(tmp)\n", + "\n", + "\n", + " sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True)\n", + " detections = [detections[k] for k in sorted_indices]\n", + "\n", + " detections = '&&'.join(detections)\n", + " t = [start_id, img, detections]\n", + "\n", + " tsv_data.append(t)\n", + " start_id+=1\n", + " \n", + " return tsv_data\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "e39871fd9fd74f55" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Text" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### En Wikipedia" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%env http_proxy='http://192.168.0.100:3128' \n", + "%env https_proxy='http://192.168.0.100:3128'\n", + "\n", + "%env HF_DATASETS_CACHE=\"/data/mshukor/data/.cache\"\n", + "%env HF_DATASETS_OFFLINE=1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tmp = load_dataset(\"wikipedia\", \"20220301.en\", cache_dir=\"/data/mshukor/data/.cache\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(tmp['train'][0]['text'])\n", + "tmp['train'][0]['text'][:512]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def remove_special(input_string):\n", + " final_string = \"\"\n", + " for character in input_string:\n", + " if character == \" \":\n", + " final_string = final_string + character\n", + " else:\n", + " if(character.isalnum()):\n", + " final_string = final_string + character\n", + " return final_string\n", + "\n", + "def get_tsv_from_text_data(data_name=\"wikipedia\", data_subname=\"20220301.en\", \n", + " output_path, cache_dir=\"/data/mshukor/data/.cache\", start_id=0, num_max_characters=2500):\n", + " from datasets import load_dataset\n", + " tmp = load_dataset(data_name, data_subname, cache_dir=cache_dir)\n", + "\n", + " with open(output_path, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for i, t in tqdm(enumerate(tmp['train'])):\n", + " text = t['text'][:num_max_characters].replace('\\t', ' ').replace(\"\\n\", ' ').replace('\\\"', '')\n", + " text = remove_special(text)\n", + " item = [start_id, text]\n", + " csv_output.writerow(item)\n", + " start_id+=1\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import csv\n", + "from io import StringIO\n", + "\n", + "output_path = '/data/mshukor/data/ofa/pretrain_ours/text_mini.tsv'\n", + "\n", + "start_id = 0 \n", + "num_max_characters = 2500\n", + "\n", + "with open(output_path, 'w', newline='') as f_output:\n", + " csv_output = csv.writer(f_output, delimiter='\\t')\n", + "\n", + " for i, t in tqdm(enumerate(tmp['train'])):\n", + " text = t['text'][:num_max_characters]\n", + " item = [start_id, text]\n", + " csv_output.writerow(item)\n", + " start_id+=1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out_data = []\n", + "selected_cols='0,1'\n", + "\n", + "selected_col_ids = [int(col_id) for col_id in selected_cols.split(\",\")]\n", + "\n", + "with open(output_path) as file:\n", + " tsv_file = csv.reader(file, delimiter='\\t')\n", + " for line in tqdm(tsv_file):\n", + " d = [line[i] for i in selected_col_ids]\n", + " out_data.append(d)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "out_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create from finetuned data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "read from tsv and write to tsv directly \n", + "same for vqa v2\n", + "then create ofa_mini 4m, vqa and refcoco for pretraining " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Convert weights" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import T5Tokenizer, T5ForConditionalGeneration\n", + "from models import ofa_base_architecture, OFAModel\n", + "from transformers.tokenization_utils_base import BatchEncoding" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Explore ofa" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-11-15 08:52:08 | INFO | tasks.ofa_task | source dictionary: 59457 types\n", + "2022-11-15 08:52:08 | INFO | tasks.ofa_task | target dictionary: 59457 types\n" + ] + } + ], + "source": [ + "import torch\n", + "import numpy as np\n", + "from fairseq import utils, tasks\n", + "from fairseq import checkpoint_utils\n", + "from utils.eval_utils import eval_step\n", + "from tasks.mm_tasks.caption import CaptionTask\n", + "from models.ofa import OFAModel\n", + "from PIL import Image\n", + "\n", + "# Register refcoco task\n", + "tasks.register_task('caption', CaptionTask)\n", + "\n", + "# turn on cuda if GPU is available\n", + "use_cuda = torch.cuda.is_available()\n", + "# use fp16 only when GPU is available\n", + "use_fp16 = False\n", + "\n", + "# Load pretrained ckpt & config\n", + "overrides={\"eval_cider\":False, \"beam\":5, \"max_len_b\":16, \"no_repeat_ngram_size\":3, \"seed\":7}\n", + "models, cfg, task = checkpoint_utils.load_model_ensemble_and_task(\n", + " utils.split_paths('/data/mshukor/logs/ofa/checkpoints/caption/ofa_caption_stage_1/5_0.06_6000/checkpoint_best.pt'),\n", + " arg_overrides=overrides\n", + " )\n", + "\n", + "# Move models to GPU\n", + "for model in models:\n", + " model.eval()\n", + " if use_fp16:\n", + " model.half()\n", + " if use_cuda and not cfg.distributed_training.pipeline_model_parallel:\n", + " model.cuda()\n", + " model.prepare_for_inference_(cfg)\n", + "\n", + "# Initialize generator\n", + "generator = task.build_generator(models, cfg.generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "model_ofa = models[0]\n", + "ofa_state = model_ofa.state_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_state_given_key(state, key, excluded_keys=None):\n", + " new_state = {}\n", + " for k, v in state.items():\n", + " if key in k:\n", + " if excluded_keys is not None:\n", + " if not any([ek in k for ek in excluded_keys]):\n", + " new_state[k] = v\n", + " else:\n", + " new_state[k] = v\n", + " return new_state\n", + "\n", + "key = 'encoder.layers.0'\n", + "excluded_keys = ['embed', 'image']\n", + "ofa_tmp = get_state_given_key(ofa_state, key, excluded_keys=excluded_keys)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# def get_ofa_args_large(args):\n", + "# args['encoder_embed_path'] = getattr(args, \"encoder_embed_path\", None)\n", + "# args['encoder_embed_dim'] = getattr(args, \"encoder_embed_dim\", 1024)\n", + "# args['encoder_ffn_embed_dim'] = getattr(args, \"encoder_ffn_embed_dim\", 4 * 1024)\n", + "# args['encoder_layers'] = getattr(args, \"encoder_layers\", 12)\n", + "# args['encoder_attention_heads'] = getattr(args, \"encoder_attention_heads\", 16)\n", + "# args['encoder_normalize_before'] = getattr(args, \"encoder_normalize_before\", True)\n", + "# args['encoder_learned_pos'] = getattr(args, \"encoder_learned_pos\", True)\n", + "# args['decoder_embed_path'] = getattr(args, \"decoder_embed_path\", None)\n", + "# args['decoder_embed_dim'] = getattr(args, \"decoder_embed_dim\", args['encoder_embed_dim'])\n", + "# args['decoder_ffn_embed_dim'] = getattr(\n", + "# args, \"decoder_ffn_embed_dim\", args['encoder_ffn_embed_dim']\n", + "# )\n", + "# args['decoder_layers'] = getattr(args, \"decoder_layers\", 12)\n", + "# args['decoder_attention_heads'] = getattr(args, \"decoder_attention_heads\", 16)\n", + "# args['decoder_normalize_before'] = getattr(args, \"decoder_normalize_before\", True)\n", + "# args['decoder_learned_pos'] = getattr(args, \"decoder_learned_pos\", True)\n", + "# args['attention_dropout'] = getattr(args, \"attention_dropout\", 0.0)\n", + "# args['relu_dropout'] = getattr(args, \"relu_dropout\", 0.0)\n", + "# args['dropout'] = getattr(args, \"dropout\", 0.0)\n", + "# args['max_target_positions'] = getattr(args, \"max_target_positions\", 1024)\n", + "# args['max_source_positions'] = getattr(args, \"max_source_positions\", 1024)\n", + "# args['adaptive_softmax_cutoff'] = getattr(args, \"adaptive_softmax_cutoff\", None)\n", + "# args['adaptive_softmax_dropout'] = getattr(args, \"adaptive_softmax_dropout\", 0)\n", + "# args['share_decoder_input_output_embed'] = getattr(\n", + "# args, \"share_decoder_input_output_embed\", True\n", + "# )\n", + "# args['share_all_embeddings'] = getattr(args, \"share_all_embeddings\", True)\n", + "\n", + "# args['decoder_output_dim'] = getattr(\n", + "# args, \"decoder_output_dim\", args['decoder_embed_dim']\n", + "# )\n", + "# args['decoder_input_dim'] = getattr(args, \"decoder_input_dim\", args['decoder_embed_dim'])\n", + "\n", + "# args['no_scale_embedding'] = getattr(args, \"no_scale_embedding\", True)\n", + "# args['layernorm_embedding'] = getattr(args, \"layernorm_embedding\", True)\n", + "\n", + "# args['activation_fn'] = getattr(args, \"activation_fn\", \"gelu\")\n", + "# args['pooler_activation_fn'] = getattr(args, \"pooler_activation_fn\", \"tanh\")\n", + "# args['pooler_dropout'] = getattr(args, \"pooler_dropout\", 0.0)\n", + "# args['pooler_classifier'] = getattr(args, \"pooler_classifier\", \"mlp\")\n", + "\n", + "# args['resnet_drop_path_rate'] = getattr(args, \"resnet_drop_path_rate\", 0.0)\n", + "# args['encoder_drop_path_rate'] = getattr(args, \"encoder_drop_path_rate\", 0.0)\n", + "# args['decoder_drop_path_rate'] = getattr(args, \"decoder_drop_path_rate\", 0.0)\n", + "\n", + "# args['resnet_type'] = getattr(args, \"resnet_type\", \"resnet152\")\n", + "# args['token_bucket_size'] = getattr(args, \"token_bucket_size\", 256)\n", + "# args['image_bucket_size'] = getattr(args, \"image_bucket_size\", 42)\n", + "\n", + "# args['freeze_encoder_embedding'] = getattr(args, \"freeze_encoder_embedding\", False)\n", + "# args['freeze_decoder_embedding'] = getattr(args, \"freeze_decoder_embedding\", False)\n", + "# args['add_type_embedding'] = getattr(args, \"add_type_embedding\", True)\n", + "# args['attn_scale_factor'] = getattr(args, \"attn_scale_factor\", 2)\n", + "\n", + "# args['code_image_size'] = getattr(args, \"code_image_size\", 128)\n", + "# args['patch_layernorm_embedding'] = getattr(args, \"patch_layernorm_embedding\", True)\n", + "# args['code_layernorm_embedding'] = getattr(args, \"code_layernorm_embedding\", True)\n", + "# args['entangle_position_embedding'] = getattr(args, \"entangle_position_embedding\", False)\n", + "# args['disable_entangle'] = getattr(args, \"disable_entangle\", False)\n", + "# args['sync_bn'] = getattr(args, \"sync_bn\", False)\n", + "\n", + "# args['scale_attn'] = getattr(args, \"scale_attn\", False)\n", + "# args['scale_fc'] = getattr(args, \"scale_fc\", False)\n", + "# args['scale_heads'] = getattr(args, \"scale_heads\", False)\n", + "# args['scale_resids'] = getattr(args, \"scale_resids\", False)\n", + "\n", + "# args['orig_patch_image_size'] = getattr(args, \"orig_patch_image_size\", 256)\n", + "\n", + "# return args" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# args = {}\n", + "# args = get_ofa_args_large(args)\n", + "# args = BatchEncoding(args)\n", + "# ofa_base_architecture(args)\n", + "# data_dir = '/data/mshukor/data/ofa/pretrain_example'\n", + "\n", + "# cfg.task.neg_sample_dir = data_dir+'/negative_sample'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### convert t5 weights" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "model_t5 = T5ForConditionalGeneration.from_pretrained(\"t5-base\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_t5" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "t5_state = model_t5.state_dict()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "# line = re.sub(r\"</?\\[\\d+>\", \"\", line)\n", + "\n", + "mapping_dict = {\n", + " ## encoder\n", + " 'block': 'layers', \n", + " 'layer.[0-9]+.SelfAttention': 'self_attn', \n", + " '.q.': '.q_proj.', \n", + " '.k.weight': '.k_proj.weight', \n", + " '.v.': '.v_proj.', \n", + " # '.o.weight': '.out_proj.weight', \n", + " 'layer.0.layer_norm.': 'self_attn_layer_norm.', \n", + " 'layer.[0-9]+.DenseReluDense.': '', \n", + " '.wi.': '.fc1.', \n", + " '.wo.': '.fc2.', \n", + " \n", + " \n", + " # decoder\n", + " 'layer.[0-9]+.EncDecAttention': 'encoder_attn', \n", + " # 'layer.1.layer_norm.': 'encoder_attn_layer_norm.', \n", + " \n", + " \n", + "}\n", + "\n", + "encoder_mapping = {\n", + " 'layer.1.layer_norm.': 'final_layer_norm.', \n", + "}\n", + "\n", + "decoder_mapping = {\n", + " 'layer.1.layer_norm.': 'encoder_attn_layer_norm.', \n", + " 'layer.2.layer_norm.': 'final_layer_norm.', \n", + "}\n", + "\n", + "\n", + "simple_replace_mapping = {\n", + " \n", + " '.o.weight': '.out_proj.weight', \n", + "}\n", + "def modify_state(state, mapping_dict, encoder_mapping, decoder_mapping, simple_replace_mapping):\n", + " # orig_keys = ['block', 'layer.[0-9]+.SelfAttention', '.q.', '.k.', '.v.', '.o.', '0.layer_norm.', '.DenseReluDense.wi.', '.DenseReluDense.wo.', '.1.layer_norm.']\n", + " # new_keys = ['layers', 'layer.self_attn', '.q_proj.', '.k_proj.', '.v_proj.', '.out_proj.', '.self_attn_layer_norm.', '.fc1.', '.fc2.', '.final_layer_norm.']\n", + " \n", + " new_state = state.copy()\n", + " old_keys = []\n", + " for k, v in state.items():\n", + " \n", + " new_key = '%s' % k \n", + " for old, new in simple_replace_mapping.items():\n", + " new_key = new_key.replace(old, new)\n", + " \n", + " for old, new in mapping_dict.items():\n", + " new_key = re.sub(r\"{}\".format(old), new, new_key)\n", + " \n", + " if 'encoder' in new_key:\n", + " for old, new in encoder_mapping.items():\n", + " new_key = re.sub(r\"{}\".format(old), new, new_key)\n", + " \n", + " if 'decoder' in new_key:\n", + " for old, new in decoder_mapping.items():\n", + " new_key = re.sub(r\"{}\".format(old), new, new_key)\n", + " \n", + " new_state[new_key] = v\n", + " old_keys.append(k)\n", + " \n", + " \n", + " \n", + " \n", + " for k in old_keys:\n", + " del new_state[k]\n", + " \n", + " final_state = {}\n", + " final_state['model'] = new_state\n", + " return final_state\n", + " \n", + "new_state = modify_state(t5_state, mapping_dict, encoder_mapping, decoder_mapping, simple_replace_mapping)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_state['model'].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def compare_states(state1, state2):\n", + " different = []\n", + " for k1 in state1.keys():\n", + " if k1 not in state2:\n", + " different.append(k1)\n", + " return different\n", + " \n", + "tmp = compare_states(new_state, ofa_state)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "output_path = '/data/mshukor/logs/ofa/pretrained_models/t5_base.pt'\n", + "torch.save(new_state, output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "output_path = '/data/mshukor/logs/ofa/pretrained_models/t5_base.pt'\n", + "\n", + "tmp_state = torch.load(output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "model_ofa.load_state_dict(tmp_state['model'], strict=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "tmp_state['model'].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "tmp_state = torch.load('/data/mshukor/logs/ofa/pretrained_models/ofa_base.pt')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['args', 'cfg', 'model', 'criterion', 'optimizer_history', 'task_state', 'extra_state', 'last_optimizer_state'])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp_state.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_t5.encoder.block[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_ofa.encoder.layers[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### convert BART weights" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "weights_path = '/data/mshukor/logs/ofa/pretrained_models/bart.base/model.pt'\n", + "bart_state = torch.load(weights_path, map_location=torch.device('cpu'))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<All keys matched successfully>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_ofa.load_state_dict(bart_state['model'], strict=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "odict_keys(['encoder.version', 'encoder.embed_tokens.weight', 'encoder.embed_positions.weight', 'encoder.layers.0.self_attn.k_proj.weight', 'encoder.layers.0.self_attn.k_proj.bias', 'encoder.layers.0.self_attn.v_proj.weight', 'encoder.layers.0.self_attn.v_proj.bias', 'encoder.layers.0.self_attn.q_proj.weight', 'encoder.layers.0.self_attn.q_proj.bias', 'encoder.layers.0.self_attn.out_proj.weight', 'encoder.layers.0.self_attn.out_proj.bias', 'encoder.layers.0.self_attn_layer_norm.weight', 'encoder.layers.0.self_attn_layer_norm.bias', 'encoder.layers.0.fc1.weight', 'encoder.layers.0.fc1.bias', 'encoder.layers.0.fc2.weight', 'encoder.layers.0.fc2.bias', 'encoder.layers.0.final_layer_norm.weight', 'encoder.layers.0.final_layer_norm.bias', 'encoder.layers.1.self_attn.k_proj.weight', 'encoder.layers.1.self_attn.k_proj.bias', 'encoder.layers.1.self_attn.v_proj.weight', 'encoder.layers.1.self_attn.v_proj.bias', 'encoder.layers.1.self_attn.q_proj.weight', 'encoder.layers.1.self_attn.q_proj.bias', 'encoder.layers.1.self_attn.out_proj.weight', 'encoder.layers.1.self_attn.out_proj.bias', 'encoder.layers.1.self_attn_layer_norm.weight', 'encoder.layers.1.self_attn_layer_norm.bias', 'encoder.layers.1.fc1.weight', 'encoder.layers.1.fc1.bias', 'encoder.layers.1.fc2.weight', 'encoder.layers.1.fc2.bias', 'encoder.layers.1.final_layer_norm.weight', 'encoder.layers.1.final_layer_norm.bias', 'encoder.layers.2.self_attn.k_proj.weight', 'encoder.layers.2.self_attn.k_proj.bias', 'encoder.layers.2.self_attn.v_proj.weight', 'encoder.layers.2.self_attn.v_proj.bias', 'encoder.layers.2.self_attn.q_proj.weight', 'encoder.layers.2.self_attn.q_proj.bias', 'encoder.layers.2.self_attn.out_proj.weight', 'encoder.layers.2.self_attn.out_proj.bias', 'encoder.layers.2.self_attn_layer_norm.weight', 'encoder.layers.2.self_attn_layer_norm.bias', 'encoder.layers.2.fc1.weight', 'encoder.layers.2.fc1.bias', 'encoder.layers.2.fc2.weight', 'encoder.layers.2.fc2.bias', 'encoder.layers.2.final_layer_norm.weight', 'encoder.layers.2.final_layer_norm.bias', 'encoder.layers.3.self_attn.k_proj.weight', 'encoder.layers.3.self_attn.k_proj.bias', 'encoder.layers.3.self_attn.v_proj.weight', 'encoder.layers.3.self_attn.v_proj.bias', 'encoder.layers.3.self_attn.q_proj.weight', 'encoder.layers.3.self_attn.q_proj.bias', 'encoder.layers.3.self_attn.out_proj.weight', 'encoder.layers.3.self_attn.out_proj.bias', 'encoder.layers.3.self_attn_layer_norm.weight', 'encoder.layers.3.self_attn_layer_norm.bias', 'encoder.layers.3.fc1.weight', 'encoder.layers.3.fc1.bias', 'encoder.layers.3.fc2.weight', 'encoder.layers.3.fc2.bias', 'encoder.layers.3.final_layer_norm.weight', 'encoder.layers.3.final_layer_norm.bias', 'encoder.layers.4.self_attn.k_proj.weight', 'encoder.layers.4.self_attn.k_proj.bias', 'encoder.layers.4.self_attn.v_proj.weight', 'encoder.layers.4.self_attn.v_proj.bias', 'encoder.layers.4.self_attn.q_proj.weight', 'encoder.layers.4.self_attn.q_proj.bias', 'encoder.layers.4.self_attn.out_proj.weight', 'encoder.layers.4.self_attn.out_proj.bias', 'encoder.layers.4.self_attn_layer_norm.weight', 'encoder.layers.4.self_attn_layer_norm.bias', 'encoder.layers.4.fc1.weight', 'encoder.layers.4.fc1.bias', 'encoder.layers.4.fc2.weight', 'encoder.layers.4.fc2.bias', 'encoder.layers.4.final_layer_norm.weight', 'encoder.layers.4.final_layer_norm.bias', 'encoder.layers.5.self_attn.k_proj.weight', 'encoder.layers.5.self_attn.k_proj.bias', 'encoder.layers.5.self_attn.v_proj.weight', 'encoder.layers.5.self_attn.v_proj.bias', 'encoder.layers.5.self_attn.q_proj.weight', 'encoder.layers.5.self_attn.q_proj.bias', 'encoder.layers.5.self_attn.out_proj.weight', 'encoder.layers.5.self_attn.out_proj.bias', 'encoder.layers.5.self_attn_layer_norm.weight', 'encoder.layers.5.self_attn_layer_norm.bias', 'encoder.layers.5.fc1.weight', 'encoder.layers.5.fc1.bias', 'encoder.layers.5.fc2.weight', 'encoder.layers.5.fc2.bias', 'encoder.layers.5.final_layer_norm.weight', 'encoder.layers.5.final_layer_norm.bias', 'encoder.layernorm_embedding.weight', 'encoder.layernorm_embedding.bias', 'decoder.version', 'decoder.embed_tokens.weight', 'decoder.embed_positions.weight', 'decoder.layers.0.self_attn.k_proj.weight', 'decoder.layers.0.self_attn.k_proj.bias', 'decoder.layers.0.self_attn.v_proj.weight', 'decoder.layers.0.self_attn.v_proj.bias', 'decoder.layers.0.self_attn.q_proj.weight', 'decoder.layers.0.self_attn.q_proj.bias', 'decoder.layers.0.self_attn.out_proj.weight', 'decoder.layers.0.self_attn.out_proj.bias', 'decoder.layers.0.self_attn_layer_norm.weight', 'decoder.layers.0.self_attn_layer_norm.bias', 'decoder.layers.0.encoder_attn.k_proj.weight', 'decoder.layers.0.encoder_attn.k_proj.bias', 'decoder.layers.0.encoder_attn.v_proj.weight', 'decoder.layers.0.encoder_attn.v_proj.bias', 'decoder.layers.0.encoder_attn.q_proj.weight', 'decoder.layers.0.encoder_attn.q_proj.bias', 'decoder.layers.0.encoder_attn.out_proj.weight', 'decoder.layers.0.encoder_attn.out_proj.bias', 'decoder.layers.0.encoder_attn_layer_norm.weight', 'decoder.layers.0.encoder_attn_layer_norm.bias', 'decoder.layers.0.fc1.weight', 'decoder.layers.0.fc1.bias', 'decoder.layers.0.fc2.weight', 'decoder.layers.0.fc2.bias', 'decoder.layers.0.final_layer_norm.weight', 'decoder.layers.0.final_layer_norm.bias', 'decoder.layers.1.self_attn.k_proj.weight', 'decoder.layers.1.self_attn.k_proj.bias', 'decoder.layers.1.self_attn.v_proj.weight', 'decoder.layers.1.self_attn.v_proj.bias', 'decoder.layers.1.self_attn.q_proj.weight', 'decoder.layers.1.self_attn.q_proj.bias', 'decoder.layers.1.self_attn.out_proj.weight', 'decoder.layers.1.self_attn.out_proj.bias', 'decoder.layers.1.self_attn_layer_norm.weight', 'decoder.layers.1.self_attn_layer_norm.bias', 'decoder.layers.1.encoder_attn.k_proj.weight', 'decoder.layers.1.encoder_attn.k_proj.bias', 'decoder.layers.1.encoder_attn.v_proj.weight', 'decoder.layers.1.encoder_attn.v_proj.bias', 'decoder.layers.1.encoder_attn.q_proj.weight', 'decoder.layers.1.encoder_attn.q_proj.bias', 'decoder.layers.1.encoder_attn.out_proj.weight', 'decoder.layers.1.encoder_attn.out_proj.bias', 'decoder.layers.1.encoder_attn_layer_norm.weight', 'decoder.layers.1.encoder_attn_layer_norm.bias', 'decoder.layers.1.fc1.weight', 'decoder.layers.1.fc1.bias', 'decoder.layers.1.fc2.weight', 'decoder.layers.1.fc2.bias', 'decoder.layers.1.final_layer_norm.weight', 'decoder.layers.1.final_layer_norm.bias', 'decoder.layers.2.self_attn.k_proj.weight', 'decoder.layers.2.self_attn.k_proj.bias', 'decoder.layers.2.self_attn.v_proj.weight', 'decoder.layers.2.self_attn.v_proj.bias', 'decoder.layers.2.self_attn.q_proj.weight', 'decoder.layers.2.self_attn.q_proj.bias', 'decoder.layers.2.self_attn.out_proj.weight', 'decoder.layers.2.self_attn.out_proj.bias', 'decoder.layers.2.self_attn_layer_norm.weight', 'decoder.layers.2.self_attn_layer_norm.bias', 'decoder.layers.2.encoder_attn.k_proj.weight', 'decoder.layers.2.encoder_attn.k_proj.bias', 'decoder.layers.2.encoder_attn.v_proj.weight', 'decoder.layers.2.encoder_attn.v_proj.bias', 'decoder.layers.2.encoder_attn.q_proj.weight', 'decoder.layers.2.encoder_attn.q_proj.bias', 'decoder.layers.2.encoder_attn.out_proj.weight', 'decoder.layers.2.encoder_attn.out_proj.bias', 'decoder.layers.2.encoder_attn_layer_norm.weight', 'decoder.layers.2.encoder_attn_layer_norm.bias', 'decoder.layers.2.fc1.weight', 'decoder.layers.2.fc1.bias', 'decoder.layers.2.fc2.weight', 'decoder.layers.2.fc2.bias', 'decoder.layers.2.final_layer_norm.weight', 'decoder.layers.2.final_layer_norm.bias', 'decoder.layers.3.self_attn.k_proj.weight', 'decoder.layers.3.self_attn.k_proj.bias', 'decoder.layers.3.self_attn.v_proj.weight', 'decoder.layers.3.self_attn.v_proj.bias', 'decoder.layers.3.self_attn.q_proj.weight', 'decoder.layers.3.self_attn.q_proj.bias', 'decoder.layers.3.self_attn.out_proj.weight', 'decoder.layers.3.self_attn.out_proj.bias', 'decoder.layers.3.self_attn_layer_norm.weight', 'decoder.layers.3.self_attn_layer_norm.bias', 'decoder.layers.3.encoder_attn.k_proj.weight', 'decoder.layers.3.encoder_attn.k_proj.bias', 'decoder.layers.3.encoder_attn.v_proj.weight', 'decoder.layers.3.encoder_attn.v_proj.bias', 'decoder.layers.3.encoder_attn.q_proj.weight', 'decoder.layers.3.encoder_attn.q_proj.bias', 'decoder.layers.3.encoder_attn.out_proj.weight', 'decoder.layers.3.encoder_attn.out_proj.bias', 'decoder.layers.3.encoder_attn_layer_norm.weight', 'decoder.layers.3.encoder_attn_layer_norm.bias', 'decoder.layers.3.fc1.weight', 'decoder.layers.3.fc1.bias', 'decoder.layers.3.fc2.weight', 'decoder.layers.3.fc2.bias', 'decoder.layers.3.final_layer_norm.weight', 'decoder.layers.3.final_layer_norm.bias', 'decoder.layers.4.self_attn.k_proj.weight', 'decoder.layers.4.self_attn.k_proj.bias', 'decoder.layers.4.self_attn.v_proj.weight', 'decoder.layers.4.self_attn.v_proj.bias', 'decoder.layers.4.self_attn.q_proj.weight', 'decoder.layers.4.self_attn.q_proj.bias', 'decoder.layers.4.self_attn.out_proj.weight', 'decoder.layers.4.self_attn.out_proj.bias', 'decoder.layers.4.self_attn_layer_norm.weight', 'decoder.layers.4.self_attn_layer_norm.bias', 'decoder.layers.4.encoder_attn.k_proj.weight', 'decoder.layers.4.encoder_attn.k_proj.bias', 'decoder.layers.4.encoder_attn.v_proj.weight', 'decoder.layers.4.encoder_attn.v_proj.bias', 'decoder.layers.4.encoder_attn.q_proj.weight', 'decoder.layers.4.encoder_attn.q_proj.bias', 'decoder.layers.4.encoder_attn.out_proj.weight', 'decoder.layers.4.encoder_attn.out_proj.bias', 'decoder.layers.4.encoder_attn_layer_norm.weight', 'decoder.layers.4.encoder_attn_layer_norm.bias', 'decoder.layers.4.fc1.weight', 'decoder.layers.4.fc1.bias', 'decoder.layers.4.fc2.weight', 'decoder.layers.4.fc2.bias', 'decoder.layers.4.final_layer_norm.weight', 'decoder.layers.4.final_layer_norm.bias', 'decoder.layers.5.self_attn.k_proj.weight', 'decoder.layers.5.self_attn.k_proj.bias', 'decoder.layers.5.self_attn.v_proj.weight', 'decoder.layers.5.self_attn.v_proj.bias', 'decoder.layers.5.self_attn.q_proj.weight', 'decoder.layers.5.self_attn.q_proj.bias', 'decoder.layers.5.self_attn.out_proj.weight', 'decoder.layers.5.self_attn.out_proj.bias', 'decoder.layers.5.self_attn_layer_norm.weight', 'decoder.layers.5.self_attn_layer_norm.bias', 'decoder.layers.5.encoder_attn.k_proj.weight', 'decoder.layers.5.encoder_attn.k_proj.bias', 'decoder.layers.5.encoder_attn.v_proj.weight', 'decoder.layers.5.encoder_attn.v_proj.bias', 'decoder.layers.5.encoder_attn.q_proj.weight', 'decoder.layers.5.encoder_attn.q_proj.bias', 'decoder.layers.5.encoder_attn.out_proj.weight', 'decoder.layers.5.encoder_attn.out_proj.bias', 'decoder.layers.5.encoder_attn_layer_norm.weight', 'decoder.layers.5.encoder_attn_layer_norm.bias', 'decoder.layers.5.fc1.weight', 'decoder.layers.5.fc1.bias', 'decoder.layers.5.fc2.weight', 'decoder.layers.5.fc2.bias', 'decoder.layers.5.final_layer_norm.weight', 'decoder.layers.5.final_layer_norm.bias', 'decoder.layernorm_embedding.weight', 'decoder.layernorm_embedding.bias'])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bart_state['model'].keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0125, 0.0014, -0.0096, ..., 0.0022, 0.1057, 0.0103],\n", + " [-0.0114, -0.0169, -0.0184, ..., -0.0131, -0.0043, -0.0053],\n", + " [ 0.0842, -0.0389, 0.0096, ..., 0.0583, 0.0082, 0.0357],\n", + " ...,\n", + " [-0.0032, -0.0313, -0.1026, ..., 0.0138, 0.0056, -0.0023],\n", + " [ 0.0104, -0.0045, 0.0263, ..., 0.0158, 0.0324, -0.0111],\n", + " [-0.0038, -0.0532, -0.0147, ..., 0.0067, 0.0256, 0.0009]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ofa_state.keys()\n", + "ofa_state['encoder.embed_tokens.weight']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ofa", + "language": "python", + "name": "ofa" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/preprocess/.ipynb_checkpoints/create_tsv_files-checkpoint.py b/preprocess/.ipynb_checkpoints/create_tsv_files-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..7f3cb08ffdc59e31c8f61abde78420f16a68539a --- /dev/null +++ b/preprocess/.ipynb_checkpoints/create_tsv_files-checkpoint.py @@ -0,0 +1,133 @@ +from utils import get_tsv_data_from_jsons, create_imagenet_txt_files +import csv +from io import StringIO +from tqdm import tqdm + + +# with image conversion +# datasets = ['/data/mshukor/data/our_albef_data/json_pretrain/vg_albef.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/sbu.json', +# ] + +# output_paths = ['/data/mshukor/data/ofa/pretrain_ours/vg_albef.tsv', +# '/data/mshukor/data/ofa/pretrain_ours/sbu.tsv', +# ] + +# task_types = ['caption', +# 'caption'] + +# start_id = 566747 +# for data, task_type, output_path in zip(datasets, task_types, output_paths): + + + +# tsvs = get_tsv_data_from_jsons([data], start_id, [task_type]) + +# start_id = tsvs[-1][0] + 1 + +# print("save tsv to:", output_path) + +# with open(output_path, 'w', newline='') as f_output: +# csv_output = csv.writer(f_output, delimiter='\t') +# for t in tqdm(tsvs): +# csv_output.writerow(t) + +######################################################## +# without image conversion + +# datasets = ['/data/mshukor/data/our_albef_data/json_pretrain/coco_karp.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/vg_albef.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/sbu.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/cc3m.json'] + +# start_id = 0 +# task_types = ['caption', +# 'caption', +# 'caption', +# 'caption'] + +# tsvs = get_tsv_data_from_jsons(datasets, start_id, task_types, convert_images=False) + +# output_path = '/data/mshukor/data/ofa/pretrain_ours/vision_language_4m.tsv' + +# with open(output_path, 'w', newline='') as f_output: +# csv_output = csv.writer(f_output, delimiter='\t') + +# for t in tqdm(tsvs): +# csv_output.writerow(t) + + + +######################################################## + + +# datasets = [ +# '/data/mshukor/data/our_albef_data/json_pretrain/coco_karp.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/vg_albef.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/sbu.json', +# '/data/mshukor/data/our_albef_data/json_pretrain/cc3m.json', + +# ['/data/mshukor/data/refcoco/refcoco+/refs(unc).p', '/data/mshukor/data/refcoco/refcoco+/instances.json'], + +# '/data/mshukor/data/our_albef_data/data/vqa_train.json', +# ] + +# start_id = 0 +# task_types = ['caption', +# 'caption', +# 'caption', +# 'caption', +# 'visual_grounding', +# 'qa',] + +# tsvs = get_tsv_data_from_jsons(datasets, start_id, task_types, convert_images=False) + + +# output_path = '/data/mshukor/data/ofa/pretrain_ours/vision_language_mini.tsv' + +# with open(output_path, 'w', newline='') as f_output: +# csv_output = csv.writer(f_output, delimiter='\t') + +# for t in tqdm(tsvs): +# csv_output.writerow(t) + + + +#### imagenet + +path_data = '/data/mshukor/data/imagenet/val' +output_path = '/data/mshukor/data/ofa/pretrain_ours/imagenet_val.txt' + + +create_imagenet_txt_files(path_data, output_path) + + + +####### object detection + + + + +from preprocess.utils import get_tsv_data_from_jsons + +datasets = [ + ['coco', '/data/mshukor/data/coco/annotations/instances_train2014.json'], + ['vg', '/data/mshukor/data/visual_genome/annotations/objects.json', '/data/mshukor/data/visual_genome/images'], +] + +start_id = 0 +task_types = ['detection', + 'detection',] + + + +tsvs = get_tsv_data_from_jsons(datasets, start_id, task_types, convert_images=False) + + +output_path = '/data/mshukor/data/ofa/pretrain_ours/detection_mini.tsv' + +with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(tsvs): + csv_output.writerow(t) \ No newline at end of file diff --git a/preprocess/.ipynb_checkpoints/utils-checkpoint.py b/preprocess/.ipynb_checkpoints/utils-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..51eeff826f394ae9fb934f355a1867978e771673 --- /dev/null +++ b/preprocess/.ipynb_checkpoints/utils-checkpoint.py @@ -0,0 +1,462 @@ +import os +import json +import torch +# import clip +from PIL import Image +# import sng_parser +from tqdm import tqdm +import codecs +import numpy as np +import csv +import sys + +from io import BytesIO +import base64 +import pickle + +# uniq-id, image (base64 string), caption, question, answer, +#ground-truth objects (objects appearing in the caption or question), +#dataset name (source of the data) and task type (caption, qa or visual gronunding). + +def remove_special(input_string): + final_string = "" + for character in input_string: + if character == " ": + final_string = final_string + character + else: + if(character.isalnum()): + final_string = final_string + character + return final_string + +def convert_img_to_str(file_name): + img = Image.open(file_name) # path to file + img_buffer = BytesIO() + img.save(img_buffer, format=img.format) + byte_data = img_buffer.getvalue() + base64_str = base64.b64encode(byte_data) # bytes + base64_str = base64_str.decode("utf-8") # str + return base64_str + + +def get_tsv_caption_data_from_json(original_data, start_id, dataset_name, task_type, convert_images=True): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + caption = remove_special(d['caption']) + img_path = d['image'] + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + t = [start_id, img, caption, '','', '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + + return tsv_data + + +def get_tsv_vqa_data_from_json(original_data, start_id, dataset_name, task_type, image_root=None, convert_images=True): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + question = remove_special(d['question']) + img_path = d['image'] + if image_root is not None: + img_path = os.path.join(image_root, img_path) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + answers = set(d['answer']) + + answer_weight = {} + for ans in answers: + if ans in answer_weight.keys(): + answer_weight[ans] += 1/len(answers) + else: + answer_weight[ans] = 1/len(answers) + + ans_ = ["{:.1f}".format(conf)+'|!+'+ans for ans, conf in answer_weight.items()] + ans_ = '&&'.join(ans_) + + t = [start_id, img, '', question, ans_, '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + + return tsv_data + +def get_tsv_from_refcoco(ref_path, instances_path, start_id, dataset_name='refcoco_train', task_type='visual_grounding', convert_images=True, split='train'): + + refs = pickle.load(open(ref_path, 'rb')) + instances = json.load(open(instances_path,'r')) + + id_to_annot = {} + for annot in tqdm(instances['annotations']): + id_to_annot[annot['id']] = annot + + id_to_images = {} + for annot in tqdm(instances['images']): + id_to_images[annot['id']] = annot + + tsv_data = [] + for ref in tqdm(refs): + ref_split = ref['split'] + if ref_split == split: + image_id = ref['image_id'] + file_name = id_to_images[ref['image_id']]['file_name'] + if ref_split == 'train': + file_name = os.path.join('coco/train2014', file_name) + + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + ann_id = ref['ann_id'] + annot = id_to_annot[ann_id] + bbox = annot['bbox'] # x,y,w,h bottom left + x1, y1, x2, y2 = bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3] # top left, bottom right + box = '{:.2f},{:.2f},{:.2f},{:.2f}'.format(x1, y1, x2, y2) + for sent in ref['sentences']: + sentence = remove_special(sent['sent']) + # [id, image, 'third book starting from left', '', '29.1,11.72,66.81,343.41', '', 'refcoco_train', 'visual_grounding'] + t = [start_id, img, sentence, '', box, '', dataset_name, task_type] + + tsv_data.append(t) + start_id+=1 + + return tsv_data + +def get_tsv_data_from_jsons(datasets, start_id, task_types, image_root=None, convert_images=True): + tsvs = [] + for (original_data_path, task_type) in zip(datasets, task_types): + print(task_type) + if task_type == 'caption': + dataset_name = original_data_path.split('/')[-1].split('.')[0] + print(dataset_name,'start_id:', start_id) + original_data = json.load(open(original_data_path,'r')) + tsvs += get_tsv_caption_data_from_json(original_data=original_data, start_id=start_id, dataset_name=dataset_name, task_type=task_type, convert_images=convert_images) + elif task_type == 'qa': + dataset_name = original_data_path.split('/')[-1].split('.')[0] + print(dataset_name,'start_id:', start_id) + original_data = json.load(open(original_data_path,'r')) + tsvs += get_tsv_vqa_data_from_json(original_data=original_data, start_id=start_id, dataset_name=dataset_name, task_type=task_type, image_root=image_root, convert_images=convert_images) + + elif task_type == 'visual_grounding': + dataset_name = original_data_path[0].split('/')[-2].replace('+', '')+'_train' + print(dataset_name,'start_id:', start_id) + if dataset_name == 'refcoco_train': + tsvs += get_tsv_from_refcoco(original_data_path[0], original_data_path[1], start_id, dataset_name=dataset_name, task_type=task_type, convert_images=convert_images, split='train') + + elif task_type == 'detection': + dataset_name = original_data_path[0] + if dataset_name == 'vg': + tsvs+= get_tsv_from_vg_detection(original_data_path[1], original_data_path[2], start_id, convert_images=convert_images, split='train') + elif dataset_name == 'coco': + tsvs+= get_tsv_from_coco_detection(original_data_path[1], start_id, convert_images=convert_images, split='train') + + else: + raise + start_id = tsvs[-1][0] + 1 + + return tsvs + + + +def create_imagenet_txt_files(path_data, output_path, dataset='imagenet'): + data = [] + # start_id = 0 + for root, dirs, files, in os.walk(path_data): + for d in tqdm(dirs): + dir_path = os.path.join(root, d) + for _, _, dir_files in os.walk(dir_path): + for f in dir_files: + file_path = os.path.join(dir_path, f) + if dataset == 'imagenet21k': + file_path = '/'.join(file_path.split('/')[-3:]) + elif dataset == 'openimages': + file_path = '/'.join(file_path.split('/')[-4:]) + elif dataset == 'yfcc': + file_path = '/'.join(file_path.split('/')[-5:]) + elif dataset == 'imagenet': + file_path = '/'.join(file_path.split('/')[-5:]) + else: + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = f.split('.')[0] + tmp = [image_id, file_path] + data.append(tmp) + # start_id+=1 + + with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(data): + csv_output.writerow(t) + + + +def get_tsv_from_vg_detection(instances_path, path_images, start_id, convert_images=True, split='train'): + print('start id:', start_id) + instances = json.load(open(instances_path,'r')) + + id_to_objects = {} + for d in instances: + id_to_objects[d['id']] = d + + + + id_to_image_path = {} + for root, dirs, files, in os.walk(path_images): + for d in dirs: + dir_path = os.path.join(root, d) + for _, _, dir_files in os.walk(dir_path): + for f in dir_files: + file_path = os.path.join(dir_path, f) + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = f.split('.')[0] + id_to_image_path[image_id] = file_path + + + + + tsv_data = [] + missied = [] + for ref in tqdm(id_to_image_path.keys()): + ref_split = split + + image_id = ref + + file_name = id_to_image_path[image_id] + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + + if int(image_id) in id_to_objects: + objects = id_to_objects[int(image_id)]['objects'] + else: + missied.append(image_id) + continue + + if len(objects) == 0: + missied.append(image_id) + continue + + + areas = [] + detections = [] + for annot in objects: + x,y,w,h = annot['x'], annot['y'], annot['w'], annot['h'] # x,y,w,h bottom left + + area = w*h + + x1, y1, x2, y2 = x, y, x + w, y + h # top left, bottom right + + x1 = max(0, x1) + x2 = max(0, x2) + + + category = ','.join(remove_special(annot['names'])).replace('\x00','') + object_id = annot['id'] + + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + detections.append(tmp) + areas.append(area) + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + print('missed images:', len(missied)) + return tsv_data + + + +def get_tsv_from_coco_detection(instances_path, start_id, convert_images=True, split='train'): + print('start id:', start_id) + instances = json.load(open(instances_path,'r')) + imgid_to_annot = {} + for annot in tqdm(instances['annotations']): + if annot['image_id'] not in imgid_to_annot: + imgid_to_annot[annot['image_id']] = [annot] + else: + imgid_to_annot[annot['image_id']].append(annot) + + id_to_category = {} + for annot in tqdm(instances['categories']): + id_to_category[annot['id']] = annot['name'] + + tsv_data = [] + missied = [] + for ref in tqdm(instances['images']): + ref_split = split + image_id = ref['id'] + file_name = ref['file_name'] + + if ref_split == 'train': + file_name = os.path.join('coco/train2014', file_name) + + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + # ann_id = ref['id'] + # annot = id_to_annot[ann_id] + if image_id not in imgid_to_annot: + missied.append(image_id) + continue + annots = imgid_to_annot[image_id] + detections = [] + areas = [] + for annot in annots: + bbox = annot['bbox'] # x,y,w,h bottom left + area = bbox[2]*bbox[3] + x1, y1, x2, y2 = bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3] # top left, bottom right + # box = '{:.3f},{:.3f},{:.3f},{:.3f}'.format(x1, y1, x2, y2) + + object_id = annot['category_id'] + category = remove_special(id_to_category[object_id]) + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + areas.append(area) + detections.append(tmp) + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + + return tsv_data + + +def get_tsv_from_openimages_detection(instances_path, path_images, class_path, + start_id, convert_images=False, split='train', image_root='/gpfsdswork/dataset'): + + id_to_image_path = {} + for root, dirs, files, in os.walk(path_images): + for d in dirs: + dir_path = os.path.join(root, d) + for _, _, dir_files in os.walk(dir_path): + for f in dir_files: + file_path = os.path.join(dir_path, f) + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = f.split('.')[0] + id_to_image_path[image_id] = file_path + + + def imagepath_to_image_size(img_path): + w, h = Image.open(img_path).size + return w, h + + id_to_annot = {} + with open(instances_path) as file: + tsv_file = csv.reader(file, delimiter='\t') + for i, line in tqdm(enumerate(tsv_file)): + if i == 0: + continue # skip header + img_id = line[0].split(',')[0] + if img_id in id_to_annot: + id_to_annot[img_id].append(line) + else: + id_to_annot[img_id] = [line] + + classid_to_class = {} + + with open(class_path) as file: + tsv_file = csv.reader(file, delimiter=',') + for i, line in tqdm(enumerate(tsv_file)): + classid_to_class[line[0]] = line[1] + + tsv_data = [] + for i, img_id in tqdm(enumerate(id_to_annot.keys())): + annots = id_to_annot[img_id] + img_path = id_to_image_path[img_id] + orig_img_path = os.path.join(image_root, img_path) + + w, h = imagepath_to_image_size(orig_img_path) + + if convert_images: + img = convert_img_to_str(orig_img_path) + else: + img = img_path + + areas = [] + detections = [] + for d in annots: + d = d[0].split(',') + + x1, x2, y1, y2 = d[4:8] + x1, x2, y1, y2 = float(x1), float(x2), float(y1), float(y2) + + x1, x2, y1, y2 = x1*w, x2*w, y1*h, y2*h + box_w, box_h = x2 - x1, y2 - y1 + area = box_w*box_h + areas.append(area) + + object_id = d[2] + category = remove_special(classid_to_class[object_id]) + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + detections.append(tmp) + + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + + + return tsv_data + + +def replace_image_id_by_path(input_tsv, output_tsv, mapping_file): + selected_cols='0,1,2' + data = [] + selected_col_ids = [int(col_id) for col_id in selected_cols.split(",")] + with open(input_tsv) as file: + tsv_file = csv.reader(file, delimiter='\t') + for line in tqdm(tsv_file): + d = [line[i] for i in selected_col_ids] + data.append(d) + + im_id_to_path = {} + with open(mapping_file) as file: + tsv_file = csv.reader(file, delimiter='\t') + for line in tqdm(tsv_file): + d = [line[i] for i in [0, 1]] + im_id_to_path[d[0]] = d[1] + + for d in tqdm(data): + im_id = d[1].split('/')[-1].split('.')[0] + im_path = im_id_to_path[im_id] + d[1] = im_path + + with open(output_tsv, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(data): + csv_output.writerow(t) + + return data \ No newline at end of file diff --git a/preprocess/__init__.py b/preprocess/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/preprocess/__pycache__/__init__.cpython-37.pyc b/preprocess/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5adda1b5b0d523e744ae186a4a9ab1eb045eca93 Binary files /dev/null and b/preprocess/__pycache__/__init__.cpython-37.pyc differ diff --git a/preprocess/__pycache__/average_save_models.cpython-39.pyc b/preprocess/__pycache__/average_save_models.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1be2901428666d80bd5bc789ea601cb67e98e2e Binary files /dev/null and b/preprocess/__pycache__/average_save_models.cpython-39.pyc differ diff --git a/preprocess/__pycache__/utils.cpython-37.pyc b/preprocess/__pycache__/utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..507f8b70bff8ccb3cb1a3394a6ce015107797de9 Binary files /dev/null and b/preprocess/__pycache__/utils.cpython-37.pyc differ diff --git a/preprocess/__pycache__/utils.cpython-39.pyc b/preprocess/__pycache__/utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..428c08e56afaaffa1ce3bb16f32c5198026d239d Binary files /dev/null and b/preprocess/__pycache__/utils.cpython-39.pyc differ diff --git a/preprocess/average_save_models.py b/preprocess/average_save_models.py new file mode 100644 index 0000000000000000000000000000000000000000..c73c235e50051283eea5d6da952404d1a0749f1e --- /dev/null +++ b/preprocess/average_save_models.py @@ -0,0 +1,133 @@ +import torch +import numpy as np +import os +import re + +def average(checkpoints, lambdas=[0.5, 0.5], num_models=6, output_dir=None, filename=None, skip_keys=None, ema=False): + + ckpt = torch.load(checkpoints[0], map_location='cpu') + + if ema: + key = 'extra_state' + state = ckpt['extra_state']['ema'] + else: + key = 'model' + state = ckpt['model'] + + print(lambdas) + + + + if num_models == 1: + average_state = {k : v.clone() * lambdas[0] for k, v in state.items()} + for i in range(1, len(checkpoints)): + skip_keys_list = set() + print(checkpoints[i], lambdas[i]) + if ema: + statei = torch.load(checkpoints[i], map_location='cpu')['extra_state']['ema'] + else: + statei = torch.load(checkpoints[i], map_location='cpu')['model'] + for k, v in average_state.items(): + if k in statei and (skip_keys is None or ((not any([re.match(sk, k) for sk in skip_keys])) and (not any([sk in k for sk in skip_keys])))): + try: + average_state[k] += (lambdas[i])*statei[k].clone() + except: + print(k, average_state[k].shape, statei[k].shape) + average_state[k] += (lambdas[i])*average_state[k].clone() + else: + average_state[k] += (lambdas[i])*average_state[k].clone() + skip_keys_list.add(k) + + + state_dict = average_state + print(skip_keys_list) + if ema: + save_obj = {key:{'ema': state_dict, 'epoch': 0}} + for k, v in ckpt['extra_state'].items(): + if k != 'ema': + save_obj['extra_state']=v + print(k) + for k, v in ckpt.items(): + if k != key: + save_obj[k]=v + print(k) + else: + save_obj = {key: state_dict,} + for k, v in ckpt.items(): + if k != key: + save_obj[k]=v + print(k) + output_path = os.path.join(output_dir, '{}.pt'.format(filename)) + print('saving', output_path) + torch.save(save_obj, output_path) + + else: + if ema: + state_dict1 = ckpt['extra_state']['ema'] + state_dict2 = torch.load(checkpoints[1], map_location='cpu')['extra_state']['ema'] + else: + state_dict1 = ckpt['model'] + state_dict2 = torch.load(checkpoints[1], map_location='cpu')['model'] + for l in lambdas: + average_state = {k : v * l for k, v in state_dict1.items()} #{k : v * (1./NUM_MODELS) for k, v in state_dict1.items()} + for k, v in average_state.items(): + if k in state_dict2: + average_state[k] += (1-l)*state_dict2[k] + else: + average_state[k] += (1-l)*state_dict1[k] + + state_dict = average_state + + if ema: + save_obj = {key:{'ema': state_dict,}} + for k, v in ckpt['extra_state'].items(): + if k != 'ema': + save_obj['extra_state'][k]=v + print(k) + for k, v in ckpt.items(): + if k != key: + save_obj[k]=v + print(k) + else: + save_obj = {key: state_dict,} + for k, v in ckpt.items(): + if k != key: + save_obj[k]=v + print(k) + output_path = os.path.join(output_dir, '{}_l{:.2f}.pt'.format(filename, l)) + print('saving', output_path) + torch.save(save_obj, output_path) + + + + + + +# average of several models + +# lambdas = [1/4, 1/4, 1/4, 1/4] + +# num_models=1 +# output_dir='/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/' +# filename='avg_caprefsnlivqa' + +# checkpoints = [ +# '/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf/10_0.06_6000/checkpoint_best.pt', +# '/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf/10_5e-5_512/checkpoint_best.pt', +# '/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1/10_5e-5/checkpoint_best.pt', +# '/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1/20_0.04_1e-4_480/checkpoint_best.pt', +# ] + +# for weight interpolation +num_models=6 +output_dir='/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/' +filename='avg_capvqa' +lambdas = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0] + +checkpoints = ['/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1/20_0.04_1e-4_480/checkpoint_best.pt', + '/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf/10_0.06_6000/checkpoint_best.pt', + ] + + + +average(checkpoints, lambdas=lambdas, num_models=num_models, output_dir=output_dir, filename=filename) diff --git a/preprocess/change_model_name.py b/preprocess/change_model_name.py new file mode 100644 index 0000000000000000000000000000000000000000..71b982559594385d57522ae33144c9650906122e --- /dev/null +++ b/preprocess/change_model_name.py @@ -0,0 +1,46 @@ +import torch + +def change_name(ckpt_path, name): + print(ckpt_path, name) + state = torch.load(ckpt_path, map_location=torch.device('cpu')) + state['cfg']['model']._name = name + state['cfg']['model']._arch = name + torch.save(state, ckpt_path) + +name="unival_base" + +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_caption_stage_1/checkpoint_best.pt" +# change_name(ckpt_path, name) + + +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_refcoco/checkpoint_best.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_refcocog/checkpoint_best.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_refcocoplus/checkpoint_best.pt" +# change_name(ckpt_path, name) + +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_s1/checkpoint15.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_s2_hs/checkpoint1.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_vqa/checkpoint_best.pt" +# change_name(ckpt_path, name) + + +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_video_caption_stage_1/checkpoint_best.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_video_caption_activitynet_stage_1/checkpoint_best.pt" +# change_name(ckpt_path, name) +# ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_video_vqa/checkpoint_best.pt" +# change_name(ckpt_path, name) +ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_video_vqa_msvd/checkpoint_best.pt" +change_name(ckpt_path, name) +ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_snli_ve/checkpoint_best.pt" +change_name(ckpt_path, name) +ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_audio_caption/checkpoint_best.pt" +change_name(ckpt_path, name) +ckpt_path = "/data/mshukor/logs/ofa/best_models/unival_audio_caption_clotho/checkpoint_best.pt" +change_name(ckpt_path, name) + + diff --git a/preprocess/compress.py b/preprocess/compress.py new file mode 100644 index 0000000000000000000000000000000000000000..7994922232abafbb12cc7ecc28bdcc9bdeb193e6 --- /dev/null +++ b/preprocess/compress.py @@ -0,0 +1,234 @@ +""" +Used to compress videos (FPS and dimensions) in the Singularity project. +Modified from https://github.com/ArrowLuo/CLIP4Clip +""" +import os +from os.path import exists, join +import argparse +import subprocess +from multiprocessing import Pool +import shutil +try: + from psutil import cpu_count +except: + from multiprocessing import cpu_count +from functools import partial +from tqdm import tqdm +from PIL import Image + + +def resize_image(input_path, output_path, size=224): + with Image.open(input_path) as img: + w, h = img.width, img.height + r = 1. * w / h + if w > h: + h = size + w = r * size + else: + h = size / r + w = size + + img_resized = img.resize((int(w), int(h))) + img_resized.save(output_path) + + +def _compress_images(input_output_pair, size=224): + """ + Scale and downsample an input image to a given fps and size (shorter side size). + This also removes the audio from the image. + """ + input_image_path, output_image_path = input_output_pair + try: + resize_image(input_image_path, output_image_path, size) + except Exception as e: + print(f"Caught Exception {e}") + +def _compress_audios(input_output_pair, sample_rate=48000, replace_dir_name=None): + """ + Scale and downsample an input video to a given fps and size (shorter side size). + This also removes the audio from the video. + """ + input_file_path, output_file_path = input_output_pair + if replace_dir_name is not None: + output_file_path = input_file_path.replace(replace_dir_name, replace_dir_name+'_processed') + output_file_dir = '/'.join(output_file_path.split('/')[:-1]) + os.makedirs(output_file_dir, exist_ok=True) + try: + + command = ['ffmpeg', + '-y', # (optional) overwrite output file if it exists + '-i', input_file_path, + '-ar', str(sample_rate), + '-ac', '1', + output_file_path, # .mp3 + ] + + result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + except Exception as e: + raise e + + +def _compress_videos(input_output_pair, size=224, fps=3, replace_dir_name=None, keep_audio=False, only_audio=False): + """ + Scale and downsample an input video to a given fps and size (shorter side size). + This also removes the audio from the video. + """ + input_file_path, output_file_path = input_output_pair + if replace_dir_name is not None: + output_file_path = input_file_path.replace(replace_dir_name, replace_dir_name+'_processed') + output_file_dir = '/'.join(output_file_path.split('/')[:-1]) + os.makedirs(output_file_dir, exist_ok=True) + try: + if only_audio: + # command = ['ffmpeg', + # '-y', # (optional) overwrite output file if it exists + # '-i', input_file_path, + # '-q:a', '0', + # '-map', 'a', # only audio + # output_file_path, # .mp3 + # ] + command = ['ffmpeg', + '-y', # (optional) overwrite output file if it exists + '-i', input_file_path, + output_file_path, # .mp3 + ] + elif keep_audio: + + command = ['ffmpeg', + '-y', # (optional) overwrite output file if it exists + '-i', input_file_path, + '-filter:v', # no audio + f"scale='if(gt(a,1),trunc(oh*a/2)*2,{size})':'if(gt(a,1),{size},trunc(ow*a/2)*2)'", + # '-map', '0:v', # no audio + '-r', str(fps), # frames per second + # '-g', str(16), + output_file_path, + ] + else: + command = ['ffmpeg', + '-y', # (optional) overwrite output file if it exists + '-i', input_file_path, + '-filter:v', # no audio + f"scale='if(gt(a,1),trunc(oh*a/2)*2,{size})':'if(gt(a,1),{size},trunc(ow*a/2)*2)'", + '-map', '0:v', # no audio + '-r', str(fps), # frames per second + # '-g', str(16), + output_file_path, + ] + result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + except Exception as e: + raise e + + +def _compress(input_output_pair, fps=3, size=224, file_type="image", replace_dir_name=None, keep_audio=False, + only_audio=False, sample_rate=48000): + if file_type == "image": + _compress_images(input_output_pair, size, replace_dir_name=replace_dir_name) + elif file_type == "video": + _compress_videos(input_output_pair, size, fps, replace_dir_name=replace_dir_name, keep_audio=keep_audio, only_audio=only_audio) + elif file_type == "audio": + _compress_audios(input_output_pair, sample_rate=sample_rate, replace_dir_name=replace_dir_name) + + +def prepare_input_output_pairs(input_root, output_root, input_file_list_path=None, replace_dir_name=None, + only_audio=False, format=None): + # filename list in `input_file_list_path` can be created very fast using `ls -U . >> ../video_filenames.txt` + with open(input_file_list_path, "r") as f: + filenames = [s.strip() for s in f.readlines()] + print(f"There are {len(filenames)} video/images files loaded from list.") + input_file_path_list = [] + output_file_path_list = [] + # filenames = filenames[:100] + for e in tqdm(filenames, desc="find un-processed videos/images"): + e = e.replace('./', '') + input_file_path = join(input_root, e) + # new_e = e.split('/')[-1] + new_e = e + output_file_path = join(output_root, new_e) + file_dir = '/'.join(output_file_path.split('/')[:-1]) + os.makedirs(file_dir, exist_ok=True) + + vidformat = input_file_path.split('/')[-1].split('.')[-1] + if format is not None: + output_file_path = output_file_path.replace(vidformat, format) + elif only_audio: + output_file_path = output_file_path.replace(vidformat, 'wav') + if replace_dir_name is not None: + output_file_path = input_file_path.replace(replace_dir_name, replace_dir_name+'_processed') + # print(join(input_root, e), join(output_root, new_e), e) + if not exists(output_file_path): + input_file_path_list.append(input_file_path) + output_file_path_list.append(output_file_path) + return input_file_path_list, output_file_path_list + + +def run_compress(): + parser = argparse.ArgumentParser(description="Compress videos/images for speed-up") + parser.add_argument("--input_root", type=str, help="input root", required=True) + parser.add_argument("--input_file_list_path", type=str, required=True, default=None, + help="list of video filenames under args.input_root, it can be " + "created efficiently with `ls -U /path/to/video >> /path/to/video_filenames.txt`") + parser.add_argument("--output_root", type=str, help="output root", required=True) + parser.add_argument("--size", type=int, default=224, help="shorter side size, aspect ratio is kept") + parser.add_argument("--num_workers", type=int, default=24, help="#workers") + parser.add_argument("--fps", type=int, default=3, help="fps for output video, ignored if file_type == image") + parser.add_argument("--file_type", type=str, choices=["image", "video", "audio"], help="input file type") + parser.add_argument("--replace_dir_name", type=str, default=None, help="input file type") + parser.add_argument("--keep_audio", action='store_true', help="keep audio") + parser.add_argument("--only_audio", action='store_true', help="only audio") + + parser.add_argument("--sample_rate", type=int, default=48000, help="sample rate for audio") + parser.add_argument("--format", type=str, default=None, help="output file format") + + + + args = parser.parse_args() + + # set paths + input_root = args.input_root + output_root = args.output_root + assert input_root != output_root + if not exists(output_root): + os.makedirs(output_root, exist_ok=True) + + # prepare and find un-processed + input_file_path_list, output_file_path_list = prepare_input_output_pairs( + input_root, output_root, input_file_list_path=args.input_file_list_path,replace_dir_name=args.replace_dir_name, + only_audio=args.only_audio, format=args.format + ) + print(f"input_file_path_list[:3] {input_file_path_list[:3]}") + print(f"output_file_path_list[:3] {output_file_path_list[:3]}") + print("Total videos/images need to process: {}".format(len(input_file_path_list))) + + # start parallel jobs + num_cores = cpu_count() + num_workers = args.num_workers + print(f"Begin with {num_cores}-core logical processor, {num_workers} workers") + compress = partial(_compress, fps=args.fps, size=args.size, file_type=args.file_type, + replace_dir_name=args.replace_dir_name, keep_audio=args.keep_audio, only_audio=args.only_audio, + sample_rate=args.sample_rate) + input_pairs = list(zip(input_file_path_list, output_file_path_list)) + with Pool(num_workers) as pool, tqdm(total=len(input_file_path_list), desc="re-encoding videos/images") as pbar: + for idx, _ in enumerate(pool.imap_unordered(compress, input_pairs, chunksize=32)): + pbar.update(1) + + # copy-paste failed files + print("Compress finished, copy-paste failed files...") + copy_count = 0 + for input_file_path, output_file_path in zip(input_file_path_list, output_file_path_list): + if exists(input_file_path): + if args.replace_dir_name is not None: + output_file_path = input_file_path.replace(args.replace_dir_name, args.replace_dir_name+'_processed') + output_file_dir = '/'.join(output_file_path.split('/')[:-1]) + os.makedirs(output_file_dir, exist_ok=True) + + + if exists(output_file_path) is False or os.path.getsize(output_file_path) < 1.: + copy_count += 1 + shutil.copyfile(input_file_path, output_file_path) + print("Copy and replace file: {}".format(output_file_path)) + print(f"copy_count {copy_count}") + + +if __name__ == "__main__": + run_compress() diff --git a/preprocess/utils.py b/preprocess/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..68b4ad6ece70fe351c059c1d71b9f820dbe8bb4c --- /dev/null +++ b/preprocess/utils.py @@ -0,0 +1,819 @@ +import os +import json +# import torch +# import clip +from PIL import Image +# import sng_parser +from tqdm import tqdm +import codecs +import numpy as np +import csv +import sys + +from io import BytesIO +import base64 +import pickle + +from random import shuffle + +import ast +# uniq-id, image (base64 string), caption, question, answer, +#ground-truth objects (objects appearing in the caption or question), +#dataset name (source of the data) and task type (caption, qa or visual gronunding). + + +# import subprocess +from multiprocessing import Pool +# import shutil +try: + from psutil import cpu_count +except: + from multiprocessing import cpu_count + +from functools import partial + + +def remove_special(input_string): + final_string = "" + for character in input_string: + if character == " ": + final_string = final_string + character + else: + if(character.isalnum()): + final_string = final_string + character + return final_string + +def convert_img_to_str(file_name): + img = Image.open(file_name) # path to file + img_buffer = BytesIO() + img.save(img_buffer, format=img.format) + byte_data = img_buffer.getvalue() + base64_str = base64.b64encode(byte_data) # bytes + base64_str = base64_str.decode("utf-8") # str + return base64_str + +def add_new_tsv(original_tsv_path, new_tsv, output_path): + + + tsv = [] + with open(original_tsv_path) as file: + tsv_file = csv.reader(file, delimiter='\t') + for line in tqdm(tsv_file): + tsv.append(line) + start_id = len(tsv)+1 + + print(start_id) + for d in tqdm(new_tsv): + d[0] = d[0] + start_id + tsv.append(d) + shuffle(tsv) + + with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(tsv): + csv_output.writerow(t) + + return tsv + + +def get_tsv_caption_data_from_json(original_data, start_id, dataset_name, task_type, convert_images=True): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + caption = remove_special(d['caption']) + img_path = d['image'] + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + t = [start_id, img, caption, '','', '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + + return tsv_data + + +def get_tsv_caption_data_from_video_json(original_data, start_id, dataset_name, task_type, convert_images=True, prefix=None): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + caption = remove_special(d['caption']) + if prefix is not None: + img_path = os.path.join(prefix, d['video']) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + t = [start_id, img, caption, '','', '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + + return tsv_data + +def get_tsv_vqa_data_from_json(original_data, start_id, dataset_name, task_type, image_root=None, convert_images=True): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + question = remove_special(d['question']) + img_path = d['image'] + if 'COCO_' in img_path: + img_path = os.path.join('coco/', img_path) + + if image_root is not None: + img_path = os.path.join(image_root, img_path) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + answers = set(d['answer']) + + answer_weight = {} + for ans in answers: + ans = remove_special(ans) + if ans in answer_weight.keys(): + answer_weight[ans] += 1/len(answers) + else: + answer_weight[ans] = 1/len(answers) + + ans_ = ["{:.1f}".format(conf)+'|!+'+ans for ans, conf in answer_weight.items()] + ans_ = '&&'.join(ans_) + + t = [start_id, img, '', question, ans_, '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + + +def get_tsv_vqa_synth_data_from_json(original_data, start_id, dataset_name, task_type, image_root=None, convert_images=True, data_type='all'): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + if data_type == 'manual' and 'manual' in d['dataset']: + pass + elif data_type == 'auto' and 'manual' not in d['dataset']: + pass + elif data_type == 'all': + pass + else: + continue + + + question = remove_special(d['question']) + img_path = d['image'] + if 'COCO_' in img_path: + img_path = os.path.join('coco/', img_path) + + if image_root is not None: + img_path = os.path.join(image_root, img_path) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + answers = set(d['answer']) + + answer_weight = {} + for ans in answers: + ans = remove_special(ans) + if ans in answer_weight.keys(): + answer_weight[ans] += 1/len(answers) + else: + answer_weight[ans] = 1/len(answers) + + ans_ = ["{:.1f}".format(conf)+'|!+'+ans for ans, conf in answer_weight.items()] + ans_ = '&&'.join(ans_) + + t = [start_id, img, '', question, ans_, '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + +def get_tsv_from_vg_grounding(regions, data, start_id, dataset_name='visual_genome', task_type='visual_grounding', convert_images=True, split='train', thresh=16384): + + original_data = json.load(open(regions,'r')) + + image_data = json.load(open(data,'r')) + + + + id_2_imagepath = {} + + for d in tqdm(image_data): + id_ = int(d['image'].split('/')[-1].split('.')[0]) + id_2_imagepath[id_] = d['image'] + + tsv_data = [] + for d in tqdm(original_data): + img_path = id_2_imagepath[d['id']] + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + for reg in d['regions']: + width = reg['width'] + height = reg['height'] + x = reg['x'] + y = reg['y'] + area = width*height + if area < thresh: + x1, y1, x2, y2 = x, y, x + width, y + height # top left, bottom right + box = '{:.2f},{:.2f},{:.2f},{:.2f}'.format(x1, y1, x2, y2) + sentence = remove_special(reg['phrase']) + t = [start_id, img, sentence, '', box, '', dataset_name, task_type] + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + +def get_tsv_from_refcoco(ref_path, instances_path, start_id, dataset_name='refcoco_train', task_type='visual_grounding', convert_images=True, split='train'): + + refs = pickle.load(open(ref_path, 'rb')) + instances = json.load(open(instances_path,'r')) + + id_to_annot = {} + for annot in tqdm(instances['annotations']): + id_to_annot[annot['id']] = annot + + id_to_images = {} + for annot in tqdm(instances['images']): + id_to_images[annot['id']] = annot + + tsv_data = [] + for ref in tqdm(refs): + ref_split = ref['split'] + if ref_split == split: + image_id = ref['image_id'] + file_name = id_to_images[ref['image_id']]['file_name'] + if ref_split == 'train': + file_name = os.path.join('coco/train2014', file_name) + + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + ann_id = ref['ann_id'] + annot = id_to_annot[ann_id] + bbox = annot['bbox'] # x,y,w,h bottom left + x1, y1, x2, y2 = bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3] # top left, bottom right + box = '{:.2f},{:.2f},{:.2f},{:.2f}'.format(x1, y1, x2, y2) + for sent in ref['sentences']: + sentence = remove_special(sent['sent']) + # [id, image, 'third book starting from left', '', '29.1,11.72,66.81,343.41', '', 'refcoco_train', 'visual_grounding'] + t = [start_id, img, sentence, '', box, '', dataset_name, task_type] + + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + +def get_tsv_data_from_jsons(datasets, start_id, task_types, image_root=None, convert_images=True): + tsvs = [] + for (original_data_path, task_type) in zip(datasets, task_types): + print(task_type) + if task_type == 'caption': + dataset_name = original_data_path.split('/')[-1].split('.')[0] + print(dataset_name,'start_id:', start_id) + original_data = json.load(open(original_data_path,'r')) + tsvs += get_tsv_caption_data_from_json(original_data=original_data, start_id=start_id, dataset_name=dataset_name, task_type=task_type, convert_images=convert_images) + elif task_type == 'qa': + dataset_name = original_data_path.split('/')[-1].split('.')[0] + print(dataset_name,'start_id:', start_id) + original_data = json.load(open(original_data_path,'r')) + tsvs += get_tsv_vqa_data_from_json(original_data=original_data, start_id=start_id, dataset_name=dataset_name, task_type=task_type, image_root=image_root, convert_images=convert_images) + + elif task_type == 'visual_grounding': + dataset_name = original_data_path[0].split('/')[-2].replace('+', '')+'_train' + print(dataset_name,'start_id:', start_id) + if dataset_name == 'refcoco_train': + tsvs += get_tsv_from_refcoco(original_data_path[0], original_data_path[1], start_id, dataset_name=dataset_name, task_type=task_type, convert_images=convert_images, split='train') + + elif task_type == 'detection': + dataset_name = original_data_path[0] + if dataset_name == 'vg': + tsvs+= get_tsv_from_vg_detection(original_data_path[1], original_data_path[2], start_id, convert_images=convert_images, split='train') + elif dataset_name == 'coco': + tsvs+= get_tsv_from_coco_detection(original_data_path[1], start_id, convert_images=convert_images, split='train') + + else: + raise + start_id = tsvs[-1][0] + 1 + shuffle(tsvs) + return tsvs + + + +def create_imagenet_txt_files(path_data, output_path, dataset='imagenet'): + data = [] + # start_id = 0 + for root, dirs, files, in os.walk(path_data): + for d in tqdm(dirs): + dir_path = os.path.join(root, d) + for _, _, dir_files in os.walk(dir_path): + for f in dir_files: + file_path = os.path.join(dir_path, f) + if dataset == 'imagenet21k': + file_path = '/'.join(file_path.split('/')[-3:]) + elif dataset == 'openimages': + file_path = '/'.join(file_path.split('/')[-4:]) + elif dataset == 'yfcc': + file_path = '/'.join(file_path.split('/')[-5:]) + elif dataset == 'imagenet': + file_path = '/'.join(file_path.split('/')[-5:]) + else: + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = f.split('.')[0] + tmp = [image_id, file_path] + data.append(tmp) + # start_id+=1 + + with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(data): + csv_output.writerow(t) + + + +def get_tsv_from_vg_detection(instances_path, path_images, start_id, convert_images=True, split='train'): + print('start id:', start_id) + instances = json.load(open(instances_path,'r')) + + id_to_objects = {} + for d in instances: + id_to_objects[d['id']] = d + + + + id_to_image_path = {} + for root, dirs, files, in os.walk(path_images): + for d in dirs: + dir_path = os.path.join(root, d) + for _, _, dir_files in os.walk(dir_path): + for f in dir_files: + file_path = os.path.join(dir_path, f) + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = f.split('.')[0] + id_to_image_path[image_id] = file_path + + + + + tsv_data = [] + missied = [] + for ref in tqdm(id_to_image_path.keys()): + ref_split = split + + image_id = ref + + file_name = id_to_image_path[image_id] + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + + if int(image_id) in id_to_objects: + objects = id_to_objects[int(image_id)]['objects'] + else: + missied.append(image_id) + continue + + if len(objects) == 0: + missied.append(image_id) + continue + + + areas = [] + detections = [] + for annot in objects: + x,y,w,h = annot['x'], annot['y'], annot['w'], annot['h'] # x,y,w,h bottom left + + area = w*h + + x1, y1, x2, y2 = x, y, x + w, y + h # top left, bottom right + + x1 = max(0, x1) + x2 = max(0, x2) + + + category = ','.join(remove_special(annot['names'])).replace('\x00','') + object_id = annot['id'] + + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + detections.append(tmp) + areas.append(area) + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + print('missed images:', len(missied)) + shuffle(tsv_data) + return tsv_data + + + +def get_tsv_from_coco_detection(instances_path, start_id, convert_images=True, split='train'): + print('start id:', start_id) + instances = json.load(open(instances_path,'r')) + imgid_to_annot = {} + for annot in tqdm(instances['annotations']): + if annot['image_id'] not in imgid_to_annot: + imgid_to_annot[annot['image_id']] = [annot] + else: + imgid_to_annot[annot['image_id']].append(annot) + + id_to_category = {} + for annot in tqdm(instances['categories']): + id_to_category[annot['id']] = annot['name'] + + tsv_data = [] + missied = [] + for ref in tqdm(instances['images']): + ref_split = split + image_id = ref['id'] + file_name = ref['file_name'] + + if ref_split == 'train': + file_name = os.path.join('coco/train2014', file_name) + + if convert_images: + img_path = os.path.join('/data/mshukor/data/', file_name) + img = convert_img_to_str(img_path) + else: + img_path = file_name.replace('/data/mshukor/data/', '') + img = img_path + + # ann_id = ref['id'] + # annot = id_to_annot[ann_id] + if image_id not in imgid_to_annot: + missied.append(image_id) + continue + annots = imgid_to_annot[image_id] + detections = [] + areas = [] + for annot in annots: + bbox = annot['bbox'] # x,y,w,h bottom left + area = bbox[2]*bbox[3] + x1, y1, x2, y2 = bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3] # top left, bottom right + # box = '{:.3f},{:.3f},{:.3f},{:.3f}'.format(x1, y1, x2, y2) + + object_id = annot['category_id'] + category = remove_special(id_to_category[object_id]) + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + areas.append(area) + detections.append(tmp) + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + +def imagepath_to_image_size(img_path, dir_path): + img_path = os.path.join(dir_path, img_path) + w, h = Image.open(img_path).size + # imageid_to_meta_dict[img_path] = [w, h] + return w, h, img_path + + +def save_imageid_to_meta_dict(path_images, output_path, mp=False, num_workers=1): + + id_to_image_path = {} + for file in os.listdir(path_images): + file_path = os.path.join(path_images, file) + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = file.split('.')[0] + id_to_image_path[image_id] = file + + imageid_to_meta_dict = {} + + if mp: + iterable = list(id_to_image_path.values()) + mp_func = partial(imagepath_to_image_size, dir_path=path_images,) + + num_cores = cpu_count() + num_workers = num_workers + print(f"Begin with {num_cores}-core logical processor, {num_workers} workers") + with Pool(num_workers) as pool, tqdm(total=len(iterable), desc="running") as pbar: + for idx, res in enumerate(pool.imap_unordered(mp_func, iterable, chunksize=32)): + + w, h, img_path = res + + imageid_to_meta_dict[img_path] = [w, h] + pbar.update(1) + else: + for k, p in tqdm(id_to_image_path.items()): + + + w, h, img_path = imagepath_to_image_size(path_images, p) + + imageid_to_meta_dict[img_path] = [w, h] + + + print(len(imageid_to_meta_dict)) + with open(output_path, 'w') as f: + json.dump(imageid_to_meta_dict, f) + + return imageid_to_meta_dict + + +def get_tsv_from_openimages_detection(instances_path, path_images, class_path, + start_id, convert_images=False, split='train', image_root='/gpfsdswork/dataset', image_meta=None): + + id_to_image_path = {} + # for root, dirs, files, in os.walk(path_images): + # for d in dirs: + # dir_path = os.path.join(root, d) + # print(dir_path) + # for _, _, dir_files in os.walk(dir_path): + # for f in dir_files: + # print(f) + # file_path = os.path.join(dir_path, f) + # file_path = '/'.join(file_path.split('/')[-4:]) + # image_id = f.split('.')[0] + # id_to_image_path[image_id] = file_path + + for file in os.listdir(path_images): + file_path = os.path.join(path_images, file) + file_path = '/'.join(file_path.split('/')[-4:]) + image_id = file.split('.')[0] + id_to_image_path[image_id] = file + + def imagepath_to_image_size(img_path): + w, h = Image.open(img_path).size + return w, h + + id_to_annot = {} + with open(instances_path) as file: + tsv_file = csv.reader(file, delimiter='\t') + for i, line in tqdm(enumerate(tsv_file)): + if i == 0: + continue # skip header + img_id = line[0].split(',')[0] + if img_id in id_to_annot: + id_to_annot[img_id].append(line) + else: + id_to_annot[img_id] = [line] + + classid_to_class = {} + + with open(class_path) as file: + tsv_file = csv.reader(file, delimiter=',') + for i, line in tqdm(enumerate(tsv_file)): + classid_to_class[line[0]] = line[1] + + if image_meta is not None: + image_size = json.load(open(image_meta, 'r')) + else: + image_size = None + + tsv_data = [] + for i, img_id in tqdm(enumerate(id_to_annot.keys())): + annots = id_to_annot[img_id] + if img_id in id_to_image_path: + img_path = id_to_image_path[img_id] + orig_img_path = os.path.join(path_images, img_path) + + save_img_path = os.path.join(image_root, img_path) + + if image_size is None: + w, h = imagepath_to_image_size(orig_img_path) + else: + w, h = image_size[orig_img_path] + + if convert_images: + img = convert_img_to_str(orig_img_path) + else: + img = save_img_path + + areas = [] + detections = [] + for d in annots: + d = d[0].split(',') + + x1, x2, y1, y2 = d[4:8] + x1, x2, y1, y2 = float(x1), float(x2), float(y1), float(y2) + + x1, x2, y1, y2 = x1*w, x2*w, y1*h, y2*h + box_w, box_h = x2 - x1, y2 - y1 + area = box_w*box_h + areas.append(area) + + object_id = d[2] + category = remove_special(classid_to_class[object_id]) + + tmp = '{:.3f},{:.3f},{:.3f},{:.3f},{},{}'.format(x1, y1, x2, y2, object_id, category) + detections.append(tmp) + + + sorted_indices = sorted(range(len(areas)), key=lambda k: areas[k], reverse=True) + detections = [detections[k] for k in sorted_indices] + + detections = '&&'.join(detections) + t = [start_id, img, detections] + + tsv_data.append(t) + start_id+=1 + + shuffle(tsv_data) + return tsv_data + + + +def replace_image_id_by_path(input_tsv, output_tsv, mapping_file): + selected_cols='0,1,2' + data = [] + selected_col_ids = [int(col_id) for col_id in selected_cols.split(",")] + with open(input_tsv) as file: + tsv_file = csv.reader(file, delimiter='\t') + for line in tqdm(tsv_file): + d = [line[i] for i in selected_col_ids] + data.append(d) + + im_id_to_path = {} + with open(mapping_file) as file: + tsv_file = csv.reader(file, delimiter='\t') + for line in tqdm(tsv_file): + d = [line[i] for i in [0, 1]] + im_id_to_path[d[0]] = d[1] + + for d in tqdm(data): + im_id = d[1].split('/')[-1].split('.')[0] + im_path = im_id_to_path[im_id] + d[1] = im_path + + with open(output_tsv, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for t in tqdm(data): + csv_output.writerow(t) + + return data + + + +####3 video + +def get_tsv_msrvtt_vqa_data_from_json(original_data, start_id, image_root=None, convert_images=False): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + question = remove_special(d['question'])+'?' + img_path = d['video'] + + img_id = img_path.split('.')[0] + + + if image_root is not None: + img_path = os.path.join(image_root, img_path) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + answer = remove_special(d['answer']) + + conf = 1.0 + + ans = "{:.1f}".format(conf)+'|!+'+answer + + + t = [start_id, img_id, question, ans, '', img] + tsv_data.append(t) + start_id+=1 + shuffle(tsv_data) + return tsv_data + + + +def get_tsv_msrvtt_caption_data_from_json(original_data, start_id, image_root=None, convert_images=False): + tsv_data = [] + for i, d in tqdm(enumerate(original_data)): + caption = d['caption'] + if isinstance(caption, list): + cs = [remove_special(c) for c in caption] + caption = '&&'.join(cs) + else: + caption = remove_special(caption) + img_path = d['video'] + img_id = img_path.split('.')[0] + + if image_root is not None: + img_path = os.path.join(image_root, img_path) + + if convert_images: + img = convert_img_to_str(img_path) + else: + img_path = img_path.replace('/data/mshukor/data/', '') + img = img_path + + t = [start_id, img_id, caption, '', img] + + tsv_data.append(t) + start_id+=1 + + shuffle(tsv_data) + return tsv_data + + + +######3 Pile + + +def get_tsv_from_piletext_data(path, output_path, start_id=0, num_max_characters=2500, dataset_names=None, keepspecial=False): + print("consider only", dataset_names) + + tsv = [] + failed = 0 + with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + + with open(path, "rb") as f: + for d in tqdm(f): + d_str = d.decode("UTF-8") + d_dict = ast.literal_eval(d_str) + data_name = d_dict['meta']['pile_set_name'] + text = d_dict['text'][:num_max_characters] + + if dataset_names is not None and data_name in dataset_names: + + text = text.replace('\t', ' ').replace("\n", ' ').replace('\"', '') + if not keepspecial: + text = remove_special(text) + item = [start_id, text] + try: + csv_output.writerow(item) + except: # (UnicodeEncodeError,SyntaxError) + failed+=1 + continue + + start_id+=1 + tsv.append(item) + print("len", len(tsv), "failed", failed) + return tsv + + + + +def save_pile_tsvs(path, output_path, dataset_names, dir_names=None, keepspecial=False, num_max_characters=1500, prefix=''): + + print('prepare:', dir_names) + + for filename in os.listdir(path): + if dir_names is not None and filename in dir_names: + input_path = os.path.join(path, filename) + if 'jsonl' in filename: + output_file_name = filename.split('.')[0]+prefix+'_pile.tsv' + output_file_name = os.path.join(output_path, output_file_name) + print("creating:", output_file_name, "from", input_path) + tsv = get_tsv_from_piletext_data(input_path, output_file_name, start_id=0, num_max_characters=num_max_characters, + dataset_names=dataset_names, keepspecial=keepspecial) + + return tsv + + +def add_pile_tsvs(path, output_path='pile_all.tsv', key='pile.tsv'): + + start_id = 0 + with open(output_path, 'w', newline='') as f_output: + csv_output = csv.writer(f_output, delimiter='\t') + + for filename in os.listdir(path): + input_path = os.path.join(path, filename) + if key in filename: + + with open(input_path) as file: + tsv_file = csv.reader((line.replace('\0','') for line in file), delimiter='\t') + for line in tqdm(tsv_file): + line[0] = start_id + csv_output.writerow(line) + start_id+=1 + print('start id', line[0]) + # return tsv \ No newline at end of file diff --git a/prompt_tuning.md b/prompt_tuning.md new file mode 100644 index 0000000000000000000000000000000000000000..5c83e2f4222430598e6e15569c21d061882dfd0d --- /dev/null +++ b/prompt_tuning.md @@ -0,0 +1,66 @@ +<!--- +Copyright 2022 The OFA-Sys Team. +All rights reserved. +This source code is licensed under the Apache 2.0 license found in the LICENSE file in the root directory. +--> + +## Prompt Tuning for Generative Multimodal Pretrained Models + +### Overview +This is the code for **"Prompt Tuning for Generative Multimodal Pretrained Models"**, [Check our paper on ArXiv](https://arxiv.org/abs/2208.02532). This paper explores prompt tuning for generative multimodal pretrained models, instead of the constrastive learning models. We specifically focuses on the unified sequence-to-sequence learning framework and implement on our OFA models. +<br> + +### Requirements +* python 3.7.4 +* pytorch 1.8.1 +* torchvision 0.9.1 +* JAVA 1.8 (for COCO evaluation) +<br></br> + +### Installation +```bash +pip install -r requirements.txt +``` +<br> + +### Datasets and Checkpoints +See [datasets.md](datasets.md) and [checkpoints.md](checkpoints.md). +<br> + +### Training +We provide a demo script (`run_scripts/refcoco/train_refcoco_prefix.sh`) that has all the required parts for training. + +```sh +sh ./run_scripts/refcoco/train_refcoco_prefix.sh +``` +A few options of note: +* `--encoder-prompt` :: whether to insert prompts to the encoder +* `--decoder-prompt` :: whether to insert prompts to the decoder +* `--encoder-prompt-length` :: encoder prompt length +* `--decoder-prompt-length` :: decoder prompt length +* `--bitfit` :: whether to use bitfit +* `--adapter` :: whether to use adapter +* `--adapter-dim` :: adapter projection dim + +We recommend that your workspace directory should be organized like this: +``` +OFA/ +├── checkpoints/ +│   ├── ofa_base.pt +│   ├── ofa_large.pt +│   └── ... +├── criterions/ +├── data/ +├── dataset/ +│   ├── caption_data/ +│   ├── refcoco_data/ +│   └── ... +├── fairseq/ +├── models/ +├── run_scripts/ +├── tasks/ +├── train.py +├── trainer.py +└── utils/ +``` +<br> diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..43459aba3c92ea86641a94e48a64c3a16404a3af --- /dev/null +++ b/requirements.txt @@ -0,0 +1,87 @@ +absl_py==1.2.0 +aml==0.0.0 +apex==0.9.10dev +av==10.0.0 +azureml==0.2.7 +bitarray==2.6.0 +boto3==1.27.0 +botocore==1.30.0 +Cython==0.29.32 +decord==0.6.0 +deepdiff==6.3.0 +deepspeed==0.9.5 +editdistance==0.6.2 +einops==0.4.1 +fairscale==0.4.13 +faiss==1.5.3 +fastBPE==0.1.0 +fasttext==0.9.2 +flashlight==0.1.1 +ftfy==6.0.3 +g2p_en==2.1.0 +gossip==2.4.0 +gradio==3.35.2 +h5py==3.8.0 +indicnlp==0.0.1 +inflect==7.0.0 +iopath==0.1.10 +joblib==1.1.0 +kaldi_io==0.9.8 +kenlm==0.1 +librosa==0.9.2 +mapcalc==0.2.2 +matplotlib==3.5.3 +nltk==3.7 +npy_append_array==0.9.16 +numpy==1.21.6 +numpy==1.21.5 +ofa==0.1.0.post202203231606 +omegaconf==2.0.6 +opencv_python==4.6.0.66 +pandas==1.3.5 +phonemizer==3.2.1 +Pillow==9.2.0 +Pillow==10.0.0 +progressbar33==2.4 +psutil==5.9.0 +pyarrow==7.0.0 +pycocoevalcap==1.2 +pycocotools==2.0.4 +pythainlp==4.0.2 +pytorch_lightning==0.8.5 +pyworld==0.3.3 +PyYAML==6.0 +PyYAML==6.0 +regex==2022.9.13 +Requests==2.31.0 +rouge_score==0.1.2 +sacrebleu==2.2.1 +sacremoses==0.0.53 +scikit_learn==1.0.2 +scipy==1.7.3 +sentencepiece==0.1.99 +setuptools==68.0.0 +simuleval==1.1.0 +six==1.16.0 +soundfile==0.12.1 +spacy==3.5.4 +submitit==1.4.5 +subword_nmt==0.3.8 +t5==0.9.4 +tabulate==0.8.10 +tensorboardX==2.4.1 +tensorboardX==2.6.1 +tgt==1.4.4 +timm==0.6.12 +torch==1.13.1+cu117 +torch_xla==1.0 +torchaudio==0.13.1+cu117 +torchlibrosa==0.0.9 +torchvision==0.14.1+cu117 +torchvision==0.9.1 +tqdm==4.64.1 +transformers==4.23.1 +Unidecode==1.3.6 +wandb==0.12.21 +webrtcvad==2.0.10 +wget==3.2 diff --git a/run_scripts/averaging/fusing/scaling_best/unival_caption_stage_1_initavg_caprefsnlivqa.sh b/run_scripts/averaging/fusing/scaling_best/unival_caption_stage_1_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..d21719355d820a84c10a41b26aa32d39004ed155 --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/unival_caption_stage_1_initavg_caprefsnlivqa.sh @@ -0,0 +1,209 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_caption_stage_1_initavg_caprefsnlivqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival_ours +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +# data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_caprefsnlivqa.pt + +lr=1e-5 + + + + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=10 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"stop_on_max_len":true,"max_len_b":22,"no_repeat_ngram_size":3}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/fusing/scaling_best/unival_refcocoplus_initavg_caprefsnlivqa.sh b/run_scripts/averaging/fusing/scaling_best/unival_refcocoplus_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..576b479fdd4408342d2a96a72058e8468a508b6d --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/unival_refcocoplus_initavg_caprefsnlivqa.sh @@ -0,0 +1,159 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_initavg_caprefsnlivqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/ofa_ours +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} + + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train_1.tsv,${data_dir}/refcocoplus_train_2.tsv,${data_dir}/refcocoplus_train_3.tsv,${data_dir}/refcocoplus_train_4.tsv,${data_dir}/refcocoplus_train_5.tsv,${data_dir}/refcocoplus_train_6.tsv,${data_dir}/refcocoplus_train_7.tsv,${data_dir}/refcocoplus_train_8.tsv,${data_dir}/refcocoplus_train_9.tsv,${data_dir}/refcocoplus_train_10.tsv,${data_dir}/refcocoplus_val.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_caprefsnlivqa.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/averaging/fusing/scaling_best/unival_snli_ve_initavg_caprefsnlivqa.sh b/run_scripts/averaging/fusing/scaling_best/unival_snli_ve_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..6a0c342ef2e0194b75e5cb6122418e98c6f99069 --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/unival_snli_ve_initavg_caprefsnlivqa.sh @@ -0,0 +1,185 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_snli_ve_initavg_caprefsnlivqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + + + + +data_dir=${base_data_dir}/ofa/snli_ve_data +data=${data_dir}/snli_ve_train.tsv,${data_dir}/snli_ve_dev.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_caprefsnlivqa.pt + + +selected_cols=0,2,3,4,5 + +task=snli_ve +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=480 +prompt_type="prev_output" + + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} + +log_file=${log_dir}/${max_epoch}"_"${lr}".log" +save_path=${save_dir}/${max_epoch}"_"${lr} +mkdir -p $save_path + + + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=50000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=snli_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=${prompt_type} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --resnet-model-path=${resnet_model_path} + + # --add-caption \ diff --git a/run_scripts/averaging/fusing/scaling_best/unival_vqa_initavg_caprefsnlivqa.sh b/run_scripts/averaging/fusing/scaling_best/unival_vqa_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..897cacf44f2d30817fdfcb4ad033d6d330ec2654 --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/unival_vqa_initavg_caprefsnlivqa.sh @@ -0,0 +1,233 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_vqa_initavg_caprefsnlivqa + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +# data=${data_dir}/vqa_train.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_caprefsnlivqa.pt + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +validate_interval_updates=2000 +save_interval_updates=0 + + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --no-epoch-checkpoints \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh b/run_scripts/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..2eab82e0c3446ccf018dff293e28c88459229cc4 --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh @@ -0,0 +1,210 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + +exp_name=unival_video_caption_stage_1_initavgvideocaptionvqa + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/msrvtt_caption_train7k.tsv,${data_dir}/msrvtt_caption_test3k.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + +data=${data_dir}/msrvtt_caption_train7k_1.tsv,${data_dir}/msrvtt_caption_train7k_2.tsv,${data_dir}/msrvtt_caption_train7k_3.tsv,${data_dir}/msrvtt_caption_train7k_4.tsv,${data_dir}/msrvtt_caption_train7k_5.tsv,${data_dir}/msrvtt_caption_train7k_6.tsv,${data_dir}/msrvtt_caption_train7k_7.tsv,${data_dir}/msrvtt_caption_train7k_8.tsv,${data_dir}/msrvtt_caption_train7k_9.tsv,${data_dir}/msrvtt_caption_train7k_10.tsv,${data_dir}/msrvtt_caption_test3k.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_vid_capvqa.pt + + +lr=1e-5 + + + + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=15 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh b/run_scripts/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..786f753369538618df348d375ce16c76c60f8911 --- /dev/null +++ b/run_scripts/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh @@ -0,0 +1,239 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_video_vqa_initavgvideocaptionvqa + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# data=${data_dir}/msrvtt_qa_train.tsv,${data_dir}/msrvtt_qa_val.tsv +data=${data_dir}/msrvtt_qa_4k_train.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/msrvtt_qa_4k_train_1.tsv,${data_dir}/msrvtt_qa_4k_train_2.tsv,${data_dir}/msrvtt_qa_4k_train_3.tsv,${data_dir}/msrvtt_qa_4k_train_4.tsv,${data_dir}/msrvtt_qa_4k_train_5.tsv,${data_dir}/msrvtt_qa_4k_train_6.tsv,${data_dir}/msrvtt_qa_4k_train_7.tsv,${data_dir}/msrvtt_qa_4k_train_8.tsv,${data_dir}/msrvtt_qa_4k_train_9.tsv,${data_dir}/msrvtt_qa_4k_train_10.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + +# ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_ans2label.pkl +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_vid_capvqa.pt + +lr=1e-4 + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 +validate_interval_updates=2000 + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + + +for max_epoch in {35,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 --validate-interval-updates=${validate_interval_updates} \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/averaging/ratatouille/eval/eval_caption.sh b/run_scripts/averaging/ratatouille/eval/eval_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..5b36bbd8ed876789b73c838ea09150e3d3571029 --- /dev/null +++ b/run_scripts/averaging/ratatouille/eval/eval_caption.sh @@ -0,0 +1,96 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/caption_data +split=test +data=${data_dir}/caption_${split}.tsv # caption_val caption_test + +selected_cols=1,4,2 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + + +exp_name=eval_caption_base_best_caption_stage_1_caption_ratacapgroundsnlivqaofapt +path=${base_log_dir}/ofa/pretrained_models/average_models/caption_ratacapgroundsnlivqaofapt.pt + + + +echo ${path} +result_path=${base_log_dir}/ofa/results/caption/${exp_name}_${split} +mkdir ${result_path} + + + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=16 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" \ + --strict + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/test_predict.json ${data_dir}/test_caption_coco_format.json + diff --git a/run_scripts/averaging/ratatouille/eval/eval_refcoco.sh b/run_scripts/averaging/ratatouille/eval/eval_refcoco.sh new file mode 100644 index 0000000000000000000000000000000000000000..c5a415dc514b1795d7ad862b2213b28b2581969e --- /dev/null +++ b/run_scripts/averaging/ratatouille/eval/eval_refcoco.sh @@ -0,0 +1,147 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + + +selected_cols=0,4,2,3 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + +exp_name=eval_refcocoplus_base_best_refcocoplus_ratacapsnlivqagroundofapt +path=${base_log_dir}/ofa/pretrained_models/average_models/refcocoplus_ratacapsnlivqagroundofapt.pt + +echo ${path} +result_path=${base_log_dir}/ofa/results/refcocoplus/${exp_name} +mkdir ${result_path} + + + + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_val.tsv +split='refcocoplus_val' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_testA.tsv +split='refcocoplus_testA' +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" + + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_testB.tsv +split='refcocoplus_testB' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" diff --git a/run_scripts/averaging/ratatouille/eval/eval_vqa.sh b/run_scripts/averaging/ratatouille/eval/eval_vqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..acb6b9af3f6f91f5911b6f95da53743c3ab148cc --- /dev/null +++ b/run_scripts/averaging/ratatouille/eval/eval_vqa.sh @@ -0,0 +1,114 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/vqa_data + +# val or test or fullval +# split=fullval +# read_from_img_path='--read-from-img-path' + +split=val +read_from_img_path='' + +image_dir=${base_data_dir} + +data=${data_dir}/vqa_${split}.tsv + +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + + +selected_cols=0,5,2,3,4 +valid_batch_size=40 + + + + + + + +exp_name=eval_vqa_base_best_ratacapgroundsnlivqalr5e5 +path=${base_log_dir}/ofa/pretrained_models/average_models/vqa_ratacapgroundsnlivqalr5e5.pt + + + + +echo ${path} +result_path=${base_log_dir}/ofa/results/vqa/${exp_name}_${split} +mkdir ${result_path} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=vqa_gen \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict + + # --ema-eval \ + + + + \ No newline at end of file diff --git a/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initrefcocoplus.sh b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..aee946353fb152bf6155fd70580065caa0318249 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initrefcocoplus.sh @@ -0,0 +1,210 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_caption_stage_1_initrefcocoplus + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +# data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_5e-5_512/checkpoint_best.pt + +lr=1e-5 + + +# ${base_log_dir}/ofa/checkpoints/caption/${exp_name}/10_0.06_6000/checkpoint_last.pt + + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=10 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"stop_on_max_len":true,"max_len_b":22,"no_repeat_ngram_size":3}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initsnlive.sh b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..07bcde1c9246416586b6ff54d5475f6d7fb9cd75 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initsnlive.sh @@ -0,0 +1,208 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_caption_stage_1_initsnlive + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +# data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/snli_ve/unival_snli_ve/10_5e-5/checkpoint_best.pt + +lr=1e-5 + + +# ${base_log_dir}/ofa/checkpoints/caption/${exp_name}/10_0.06_6000/checkpoint_last.pt + + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=10 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"stop_on_max_len":true,"max_len_b":22,"no_repeat_ngram_size":3}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initvqa.sh b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4cee6f4a9fcf165d69ab56e163edbaee290288e --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/caption/unival_caption_stage_1_initvqa.sh @@ -0,0 +1,209 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_caption_stage_1_initvqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +# data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/unival_vqa/20_0.04_1e-4_480/checkpoint_best.pt + +lr=1e-5 + + +# ${base_log_dir}/ofa/checkpoints/caption/${exp_name}/10_0.06_6000/checkpoint_last.pt + + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=10 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"stop_on_max_len":true,"max_len_b":22,"no_repeat_ngram_size":3}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/ratatouille/scaling_best/caption/video/unival_video_caption_stage_1_initvideoqa.sh b/run_scripts/averaging/ratatouille/scaling_best/caption/video/unival_video_caption_stage_1_initvideoqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..595cad57f0dbdd79a6d7d8b6eec4f2dd957fb9ce --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/caption/video/unival_video_caption_stage_1_initvideoqa.sh @@ -0,0 +1,211 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + +exp_name=unival_video_caption_stage_1_initvideoqa + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/msrvtt_caption_train7k.tsv,${data_dir}/msrvtt_caption_test3k.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + +data=${data_dir}/msrvtt_caption_train7k_1.tsv,${data_dir}/msrvtt_caption_train7k_2.tsv,${data_dir}/msrvtt_caption_train7k_3.tsv,${data_dir}/msrvtt_caption_train7k_4.tsv,${data_dir}/msrvtt_caption_train7k_5.tsv,${data_dir}/msrvtt_caption_train7k_6.tsv,${data_dir}/msrvtt_caption_train7k_7.tsv,${data_dir}/msrvtt_caption_train7k_8.tsv,${data_dir}/msrvtt_caption_train7k_9.tsv,${data_dir}/msrvtt_caption_train7k_10.tsv,${data_dir}/msrvtt_caption_test3k.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/unival_video_vqa/35_0.04_1e-4_480/checkpoint_best.pt + + +lr=1e-5 + + +# ${base_log_dir}/ofa/checkpoints/caption/${exp_name}/20_0.06_6000/checkpoint_last.pt + + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=15 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict + + done + done +done \ No newline at end of file diff --git a/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initcaption.sh b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..3fb8fe46f0e73d08554a6a5ae2dc5f83ae94d0ec --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initcaption.sh @@ -0,0 +1,159 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_initcaption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} + + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train_1.tsv,${data_dir}/refcocoplus_train_2.tsv,${data_dir}/refcocoplus_train_3.tsv,${data_dir}/refcocoplus_train_4.tsv,${data_dir}/refcocoplus_train_5.tsv,${data_dir}/refcocoplus_train_6.tsv,${data_dir}/refcocoplus_train_7.tsv,${data_dir}/refcocoplus_train_8.tsv,${data_dir}/refcocoplus_train_9.tsv,${data_dir}/refcocoplus_train_10.tsv,${data_dir}/refcocoplus_val.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/unival_caption/10_0.06_6000/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initsnlive.sh b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..21336fe409c6d5deeb79d544fb0a9a2f56b92d7f --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initsnlive.sh @@ -0,0 +1,160 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_initsnlive + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} + + +# save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train_1.tsv,${data_dir}/refcocoplus_train_2.tsv,${data_dir}/refcocoplus_train_3.tsv,${data_dir}/refcocoplus_train_4.tsv,${data_dir}/refcocoplus_train_5.tsv,${data_dir}/refcocoplus_train_6.tsv,${data_dir}/refcocoplus_train_7.tsv,${data_dir}/refcocoplus_train_8.tsv,${data_dir}/refcocoplus_train_9.tsv,${data_dir}/refcocoplus_train_10.tsv,${data_dir}/refcocoplus_val.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/snli_ve/unival_snli_ve/10_5e-5/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initvqa.sh b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..a941241becccaf7e26995a69aa936d7f13d705ed --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/refcocoplus/unival_refcocoplus_initvqa.sh @@ -0,0 +1,160 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_initvqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} + + +# save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train_1.tsv,${data_dir}/refcocoplus_train_2.tsv,${data_dir}/refcocoplus_train_3.tsv,${data_dir}/refcocoplus_train_4.tsv,${data_dir}/refcocoplus_train_5.tsv,${data_dir}/refcocoplus_train_6.tsv,${data_dir}/refcocoplus_train_7.tsv,${data_dir}/refcocoplus_train_8.tsv,${data_dir}/refcocoplus_train_9.tsv,${data_dir}/refcocoplus_train_10.tsv,${data_dir}/refcocoplus_val.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/unival_vqa/20_0.04_1e-4_480/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initcaption.sh b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..8aef19a45297fa6b038322cc3bb4ac396a9f60d9 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initcaption.sh @@ -0,0 +1,187 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_snli_ve_initcaption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + + + + +data_dir=${base_data_dir}/ofa/snli_ve_data +data=${data_dir}/snli_ve_train.tsv,${data_dir}/snli_ve_dev.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/unival_caption_stage_1/10_0.06_6000/checkpoint_best.pt + + + +selected_cols=0,2,3,4,5 + +task=snli_ve +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=480 +prompt_type="prev_output" + + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} + +log_file=${log_dir}/${max_epoch}"_"${lr}".log" +save_path=${save_dir}/${max_epoch}"_"${lr} +mkdir -p $save_path + + + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=50000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=snli_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=${prompt_type} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --resnet-model-path=${resnet_model_path} + + # --add-caption \ diff --git a/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initrefcocoplus.sh b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..ebdb5452a3f48601c5b5b0155b28ed8dba268d4c --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initrefcocoplus.sh @@ -0,0 +1,186 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_snli_ve_initrefcocoplus + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + + + + +data_dir=${base_data_dir}/ofa/snli_ve_data +data=${data_dir}/snli_ve_train.tsv,${data_dir}/snli_ve_dev.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_5e-5_512/checkpoint_best.pt + + +selected_cols=0,2,3,4,5 + +task=snli_ve +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=480 +prompt_type="prev_output" + + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} + +log_file=${log_dir}/${max_epoch}"_"${lr}".log" +save_path=${save_dir}/${max_epoch}"_"${lr} +mkdir -p $save_path + + + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=50000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=snli_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=${prompt_type} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --resnet-model-path=${resnet_model_path} + + # --add-caption \ diff --git a/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initvqa.sh b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..f59a83225246d28efc99e8ba7044ef438543a714 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/snli_ve/unival_snli_ve_initvqa.sh @@ -0,0 +1,185 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_snli_ve_initvqa + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + + + + +data_dir=${base_data_dir}/ofa/snli_ve_data +data=${data_dir}/snli_ve_train.tsv,${data_dir}/snli_ve_dev.tsv + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/unival_vqa/20_0.04_1e-4_480/checkpoint_best.pt + +selected_cols=0,2,3,4,5 + +task=snli_ve +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=480 +prompt_type="prev_output" + + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} + +log_file=${log_dir}/${max_epoch}"_"${lr}".log" +save_path=${save_dir}/${max_epoch}"_"${lr} +mkdir -p $save_path + + + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=50000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=snli_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=${prompt_type} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --resnet-model-path=${resnet_model_path} + + # --add-caption \ diff --git a/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initcaption.sh b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..51beea93bd0e29b28d4238c720689b6e24829771 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initcaption.sh @@ -0,0 +1,234 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_vqa_initcaption + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +# data=${data_dir}/vqa_train.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/unival_caption/10_0.06_6000/checkpoint_best.pt + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +validate_interval_updates=2000 +save_interval_updates=0 + + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --no-epoch-checkpoints \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-dataloader --reset-meters --reset-optimizer + + + done + done + done +done diff --git a/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initsnlive.sh b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..0f7620363459f5aaa36c05555ca3c53d8837575e --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_initsnlive.sh @@ -0,0 +1,232 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_vqa_initsnlive + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +# data=${data_dir}/vqa_train.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/snli_ve/unival_snli_ve/10_5e-5/checkpoint_best.pt + +lr=1e-4 + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +validate_interval_updates=2000 +save_interval_updates=0 + + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --no-epoch-checkpoints \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_ofaplus_initrefcocoplus.sh b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_ofaplus_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..5232c9c61bfca1bb955d053bb377b08e402c35d2 --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/vqa/unival_vqa_ofaplus_initrefcocoplus.sh @@ -0,0 +1,233 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_vqa_ofaplus_initrefcocoplus + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +# data=${data_dir}/vqa_train.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_5e-5_512/checkpoint_best.pt + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +validate_interval_updates=2000 +save_interval_updates=0 + + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --no-epoch-checkpoints \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/averaging/ratatouille/scaling_best/vqa/video/unival_video_vqa_initvideocaption.sh b/run_scripts/averaging/ratatouille/scaling_best/vqa/video/unival_video_vqa_initvideocaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..4104a9ebd217b8203479f6e0bab07713d8fc8b9f --- /dev/null +++ b/run_scripts/averaging/ratatouille/scaling_best/vqa/video/unival_video_vqa_initvideocaption.sh @@ -0,0 +1,240 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival_ours +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_video_vqa_initvideocaption + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# data=${data_dir}/msrvtt_qa_train.tsv,${data_dir}/msrvtt_qa_val.tsv +data=${data_dir}/msrvtt_qa_4k_train.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/msrvtt_qa_4k_train_1.tsv,${data_dir}/msrvtt_qa_4k_train_2.tsv,${data_dir}/msrvtt_qa_4k_train_3.tsv,${data_dir}/msrvtt_qa_4k_train_4.tsv,${data_dir}/msrvtt_qa_4k_train_5.tsv,${data_dir}/msrvtt_qa_4k_train_6.tsv,${data_dir}/msrvtt_qa_4k_train_7.tsv,${data_dir}/msrvtt_qa_4k_train_8.tsv,${data_dir}/msrvtt_qa_4k_train_9.tsv,${data_dir}/msrvtt_qa_4k_train_10.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + +# ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_ans2label.pkl +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/caption/unival_video_caption/20_0.06_6000/checkpoint_best.pt + + +lr=1e-4 + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 +validate_interval_updates=2000 + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + + +for max_epoch in {35,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 --validate-interval-updates=${validate_interval_updates} \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/caption/coco_eval.py b/run_scripts/caption/coco_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..21dc995284827b15460f2444427b44d9f34e88af --- /dev/null +++ b/run_scripts/caption/coco_eval.py @@ -0,0 +1,83 @@ +import json +import sys +import os.path as op + +from pycocotools.coco import COCO +from pycocoevalcap.eval import COCOEvalCap + +sys.path.append("/lus/home/NAT/gda2204/mshukor/code/ofa_ours") +from utils.cider.pyciderevalcap.ciderD.ciderD import CiderD + +def evaluate_on_coco_caption(res_file, label_file, outfile=None, eval_cider_cached_tokens=None): + """ + res_file: txt file, each row is [image_key, json format list of captions]. + Each caption is a dict, with fields "caption", "conf". + label_file: JSON file of ground truth captions in COCO format. + """ + # ############################## + # print("eval with CidderD scorer...") + # eval_cider_cached_tokens = "/lus/scratch/NAT/gda2204/SHARED/data/ofa/video_data/caption_data/cider_cached_tokens/msrvtt-test3k-words.p" + # CiderD_scorer = CiderD(df=eval_cider_cached_tokens) + + # gts = json.load(open(label_file))['annotations'] + # res_ =json.load(open(res_file)) + # print(len(res_), len(gts)) + # # print(res_) + # gts_ = {} + # for i in range(len(gts)): + # key = gts[i]['image_id'] + # if key in gts_: + # gts_[key] += [gts[i]['caption']] + # else: + # gts_[key] = [gts[i]['caption']] + + # res_ = [{'image_id': r['image_id'], 'caption': [r['caption']]} for r in res_] + + # _, scores = CiderD_scorer.compute_score(gts_, res_) + # print(len(scores)) + # print("CIDErD: ", scores) + # print("CIDErD: ", sum(scores) / len(scores)) + + # #############################3 + coco = COCO(label_file) + cocoRes = coco.loadRes(res_file) + + ### clean result file if theres is more than one caption for each image + for i, id_ in enumerate(cocoRes.getImgIds()): + res = cocoRes.imgToAnns[id_] + if len(res) > 1: # to fix later in the code, the model should generate one caption + cocoRes.imgToAnns[id_] = [res[0]] + print("found more than one predictions: {} for img, to {}".format(res, cocoRes.imgToAnns[id_])) + + + cocoEval = COCOEvalCap(coco, cocoRes) + + # evaluate on a subset of images by setting + # cocoEval.params['image_id'] = cocoRes.getImgIds() + # please remove this line when evaluating the full validation set + cocoEval.params['image_id'] = cocoRes.getImgIds() + + + + + # evaluate results + # SPICE will take a few minutes the first time, but speeds up due to caching + cocoEval.evaluate() + result = cocoEval.eval + if not outfile: + print(result) + else: + with open(outfile, 'w') as fp: + json.dump(result, fp, indent=4) + + + return result + + +if __name__ == "__main__": + if len(sys.argv) == 3: + evaluate_on_coco_caption(sys.argv[1], sys.argv[2]) + elif len(sys.argv) == 4: + evaluate_on_coco_caption(sys.argv[1], sys.argv[2], sys.argv[3]) + else: + raise NotImplementedError \ No newline at end of file diff --git a/run_scripts/caption/eval/audio/eval_audiocaps_audio_caption.sh b/run_scripts/caption/eval/audio/eval_audiocaps_audio_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..38b38a5d389b141eecff44e8efefce349f463f10 --- /dev/null +++ b/run_scripts/caption/eval/audio/eval_audiocaps_audio_caption.sh @@ -0,0 +1,111 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_audiocaps_audio_caption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_caption +arch=unival_base +pretrained_model= + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +split=test +data=${data_dir}/audiocaps_test.tsv +image_dir=${base_data_dir} + + +eval_cider_cached=${data_dir}/cider_cached_tokens/audiocaps-test-words.p + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +model_name=unival_audio_caption +path=${new_base_log_dir}/ofa/checkpoints/caption/${model_name}/checkpoint_best.pt + + + +result_path=${new_base_log_dir}/ofa/results/caption/${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=${task} \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=16 \ + --no-repeat-ngram-size=3 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/audiocaps_test_caption_coco_format.json diff --git a/run_scripts/caption/eval/audio/eval_clotho_audio_caption.sh b/run_scripts/caption/eval/audio/eval_clotho_audio_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..a1ae5814400e1b2f6f7f81dde151ca6c555741c5 --- /dev/null +++ b/run_scripts/caption/eval/audio/eval_clotho_audio_caption.sh @@ -0,0 +1,109 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_clotho_audio_caption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_caption +arch=unival_base +pretrained_model= + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +split=test +data=${data_dir}/clotho_evaluation.tsv +image_dir=${base_data_dir} + + +eval_cider_cached=${data_dir}/cider_cached_tokens/clotho-evaluation-words.p + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +model_name=unival_audio_caption_clotho +path=${new_base_log_dir}/ofa/checkpoints/caption/${model_name}/checkpoint_best.pt + +result_path=${new_base_log_dir}/ofa/results/caption/${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=${task} \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=16 \ + --no-repeat-ngram-size=3 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/clotho_evaluation_caption_coco_format.json diff --git a/run_scripts/caption/eval/eval_caption_base_best.sh b/run_scripts/caption/eval/eval_caption_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..aa5450c987a123a2ccf25efe49a3810e53c6e1e7 --- /dev/null +++ b/run_scripts/caption/eval/eval_caption_base_best.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_caption_stage_1_ofaplus_base_pretrain_s2 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/caption_data +split=test # val test +data=${data_dir}/caption_${split}.tsv # caption_val caption_test + +zero_shot='' + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + + +# model_name=avg_postratafusevanilla +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafusevanilla.pt +# zero_shot='--zero-shot' + +model_name=unival_caption_stage_1 +path=/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/caption/unival_caption_stage_1/checkpoint_best.pt + + + +result_path=${new_base_log_dir}/ofa/results/caption/eval_${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +resnet_type=resnet101 + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --patch-image-size=480 \ + ${zero_shot} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/test_caption_coco_format.json + + diff --git a/run_scripts/caption/eval/eval_caption_base_best_avg.sh b/run_scripts/caption/eval/eval_caption_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..caf0816f3cd1bc82d5e81a9899310c5cbe4ea89a --- /dev/null +++ b/run_scripts/caption/eval/eval_caption_base_best_avg.sh @@ -0,0 +1,100 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/caption_data +split=test +data=${data_dir}/caption_${split}.tsv # caption_val caption_test + +selected_cols=1,4,2 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + + + new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + exp_name=eval_caption_base_best_avg_postfuse_capvqa${l} + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_capvqa_l${l}.pt + + + echo ${path} + result_path=${new_base_log_dir}/ofa/results/caption/${exp_name}_${split} + + mkdir ${result_path} + + + + + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/test_predict.json ${data_dir}/test_caption_coco_format.json + +done diff --git a/run_scripts/caption/eval/eval_nocaps_base.sh b/run_scripts/caption/eval/eval_nocaps_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..44b8cb9436bb52d225868c7a766b72d81a91409b --- /dev/null +++ b/run_scripts/caption/eval/eval_nocaps_base.sh @@ -0,0 +1,220 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_nocaps_stage_1_ofaplus_base_pretrain_s2 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/caption_data +split=val # val + +zero_shot='' + +read_from_img_path='--read-from-img-path' #'--read-from-img-path' # '' + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + + + +model_name=avg_postratafusevanilla +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafusevanilla.pt +zero_shot='--zero-shot' + + +result_path=${new_base_log_dir}/ofa/results/caption/eval_${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +resnet_type=resnet101 + + + +data=${data_dir}/nocaps_${split}.tsv # caption_val caption_test + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --patch-image-size=480 \ + ${zero_shot} \ + ${read_from_img_path} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/nocaps_val_caption_coco_format.json + + + + +echo "In Domain Eval" +data=${data_dir}/nocaps_indomain_${split}.tsv # caption_val caption_test + +result_path=${new_base_log_dir}/ofa/results/caption/eval_nocaps_indomain_${model_name}_${split} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --patch-image-size=480 \ + ${zero_shot} \ + ${read_from_img_path} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/nocaps_val_caption_coco_format.json + + + +echo "Near Domain Eval" +data=${data_dir}/nocaps_neardomain_${split}.tsv # caption_val caption_test + +result_path=${new_base_log_dir}/ofa/results/caption/eval_nocaps_neardomain_${model_name}_${split} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --patch-image-size=480 \ + ${zero_shot} \ + ${read_from_img_path} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/nocaps_val_caption_coco_format.json + + + +echo "Out Domain Eval" +data=${data_dir}/nocaps_outdomain_${split}.tsv # caption_val caption_test + +result_path=${new_base_log_dir}/ofa/results/caption/eval_nocaps_outdomain_${model_name}_${split} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=caption \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --unnormalized \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --patch-image-size=480 \ + ${zero_shot} \ + ${read_from_img_path} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/nocaps_val_caption_coco_format.json + diff --git a/run_scripts/caption/eval/video/eval_activitynet_video_caption.sh b/run_scripts/caption/eval/video/eval_activitynet_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..6e4d9853121b181f2896302e42b4d6059aadbb44 --- /dev/null +++ b/run_scripts/caption/eval/video/eval_activitynet_video_caption.sh @@ -0,0 +1,115 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_activitynet_video_caption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_caption +arch=unival_base +pretrained_model= + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +split=test +data=${data_dir}/activitynet_caption_val2.tsv +image_dir=${base_data_dir} + + +eval_cider_cached=${data_dir}/cider_cached_tokens/activitynet-val2-words.p + + + +model_name=unival_video_caption_activitynet +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +path=${new_base_log_dir}/ofa/checkpoints/caption/${model_name}/checkpoint_best.pt + + + + +result_path=${new_base_log_dir}/ofa/results/caption/${model_name}_${split} +# result_path=${base_log_dir}/ofa/results/caption/${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=${task} \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --max-len-b=22 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/activitynet_val2_caption_coco_format.json diff --git a/run_scripts/caption/eval/video/eval_msrvtt_video_caption.sh b/run_scripts/caption/eval/video/eval_msrvtt_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..e536083b5df7671be8fa9a03e9314aeb0675a2cc --- /dev/null +++ b/run_scripts/caption/eval/video/eval_msrvtt_video_caption.sh @@ -0,0 +1,125 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_msrvtt_video_caption + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_caption +arch=unival_base +pretrained_model= + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +split=test +data=${data_dir}/msrvtt_caption_test3k.tsv +image_dir=${base_data_dir} + + +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + + +zero_shot='' + +# model_name=unival_s2_hs +# path=/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt +# zero_shot='--zero-shot' + + + +model_name=unival_video_caption_avg_postfuse_vidcapvqa +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postfuse_vidcapvqa.pt + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + +result_path=${new_base_log_dir}/ofa/results/caption/${model_name}_${split} +mkdir ${result_path} + +selected_cols=1,4,2 + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=${task} \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam=5 \ + --max-len-b=22 \ + --no-repeat-ngram-size=3 \ + --num-workers=0 \ + --num-frames=${num_frames} \ + --patch-frame-size=${patch_frame_size} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" \ + --unnormalized \ + ${zero_shot} + + +python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/msrvtt_test3k_caption_coco_format.json diff --git a/run_scripts/caption/eval/video/eval_msrvtt_video_caption_avg.sh b/run_scripts/caption/eval/video/eval_msrvtt_video_caption_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..4b2cbc827c3471f4d153574dab2b326f55ef4d68 --- /dev/null +++ b/run_scripts/caption/eval/video/eval_msrvtt_video_caption_avg.sh @@ -0,0 +1,126 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_msrvtt_video_caption_avg + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_caption +arch=unival_base +pretrained_model= + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +split=test +data=${data_dir}/msrvtt_caption_test3k.tsv +image_dir=${base_data_dir} + + +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + + + +selected_cols=1,4,2 + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + + + model_name=avg_postfuse_vidcapvqa + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_vidcapvqa_l${l}.pt + + + + result_path=${new_base_log_dir}/ofa/results/caption/${model_name}_${split} + mkdir ${result_path} + + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=${task} \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam=5 \ + --max-len-b=22 \ + --no-repeat-ngram-size=3 \ + --num-workers=0 \ + --num-frames=${num_frames} \ + --patch-frame-size=${patch_frame_size} \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"eval_cider\":False,\"selected_cols\":\"${selected_cols}\"}" \ + --unnormalized + + + python ${ofa_dir}/run_scripts/caption/coco_eval.py ${result_path}/${split}_predict.json ${data_dir}/msrvtt_test3k_caption_coco_format.json + +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/audio/clotho/unival_audio_caption_clotho.sh b/run_scripts/caption/scaling_best/audio/clotho/unival_audio_caption_clotho.sh new file mode 100644 index 0000000000000000000000000000000000000000..8d810fc4b43346e0754653b336d1239bca8a494c --- /dev/null +++ b/run_scripts/caption/scaling_best/audio/clotho/unival_audio_caption_clotho.sh @@ -0,0 +1,217 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_audio_caption_clotho + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +# data=${data_dir}/clotho_development.tsv,${data_dir}/clotho_evaluation.tsv + +data=${data_dir}/clotho_development_1.tsv,${data_dir}/clotho_development_2.tsv,${data_dir}/clotho_development_3.tsv,${data_dir}/clotho_development_4.tsv,${data_dir}/clotho_development_5.tsv,${data_dir}/clotho_development_6.tsv,${data_dir}/clotho_development_7.tsv,${data_dir}/clotho_development_8.tsv,${data_dir}/clotho_development_9.tsv,${data_dir}/clotho_development_10.tsv,${data_dir}/clotho_evaluation.tsv + +eval_cider_cached=${data_dir}/cider_cached_tokens/clotho-evaluation-words.p + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + + +selected_cols=0,4,2 + +task=audio_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=5e-5 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 144 +patch_image_size=384 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 # 49 +patch_frame_size=224 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +# audio +audio_encoder_name=pann_cnn14 +audio_model_path=${base_log_dir}/pretrained_models/Cnn14_mAP_0.431.pth +mel_bins=64 +hop_size=200 # 155 tok + + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +validate_interval=1 + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +echo "max_epoch "${max_epoch} +for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=${validate_interval} \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16-scale-window=512 \ + --fp16 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --audio-encoder-name=${audio_encoder_name} \ + --audio-model-path=${audio_model_path} \ + --mel-bins=${mel_bins} \ + --hop-size=${hop_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --image-encoder-name=${image_encoder_name} \ + --video-encoder-name=${video_encoder_name} \ + --save-on-cuda \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --strict + + done +done diff --git a/run_scripts/caption/scaling_best/audio/unival_audio_caption.sh b/run_scripts/caption/scaling_best/audio/unival_audio_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfd8e763b9c51dd49d134ba79c871053211c36a5 --- /dev/null +++ b/run_scripts/caption/scaling_best/audio/unival_audio_caption.sh @@ -0,0 +1,216 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_audio_caption + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +data=${data_dir}/audiocaps_train.tsv,${data_dir}/audiocaps_test.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/audiocaps-test-words.p + + +data=${data_dir}/audiocaps_train_1.tsv,${data_dir}/audiocaps_train_2.tsv,${data_dir}/audiocaps_train_3.tsv,${data_dir}/audiocaps_train_4.tsv,${data_dir}/audiocaps_train_5.tsv,${data_dir}/audiocaps_train_6.tsv,${data_dir}/audiocaps_train_7.tsv,${data_dir}/audiocaps_train_8.tsv,${data_dir}/audiocaps_train_9.tsv,${data_dir}/audiocaps_train_10.tsv,${data_dir}/audiocaps_test.tsv + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + + + +selected_cols=0,4,2 + +task=audio_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=1e-4 +max_epoch=25 +warmup_ratio=0.06 +batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 144 +patch_image_size=384 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 # 49 +patch_frame_size=224 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +# audio +audio_encoder_name=pann_cnn14 +audio_model_path=${base_log_dir}/pretrained_models/Cnn14_mAP_0.431.pth +mel_bins=64 +hop_size=200 # 155 tok + + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +echo "max_epoch "${max_epoch} +for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16-scale-window=512 \ + --fp16 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --audio-encoder-name=${audio_encoder_name} \ + --audio-model-path=${audio_model_path} \ + --mel-bins=${mel_bins} \ + --hop-size=${hop_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --save-on-cuda \ + --strict \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + + done +done diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s1_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..708f53d50b078b87540d46859928940b441ac261 --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s1_onlylinear.sh @@ -0,0 +1,217 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_audio_caption_s1_onlylinear + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +data=${data_dir}/audiocaps_train_1.tsv,${data_dir}/audiocaps_train_2.tsv,${data_dir}/audiocaps_train_3.tsv,${data_dir}/audiocaps_train_4.tsv,${data_dir}/audiocaps_train_5.tsv,${data_dir}/audiocaps_train_6.tsv,${data_dir}/audiocaps_train_7.tsv,${data_dir}/audiocaps_train_8.tsv,${data_dir}/audiocaps_train_9.tsv,${data_dir}/audiocaps_train_10.tsv,${data_dir}/audiocaps_test.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/audiocaps-test-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s1/checkpoint15.pt + + + +selected_cols=0,4,2 + +task=audio_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=5e-3 +max_epoch=25 +warmup_ratio=0.06 +batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 144 +patch_image_size=384 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 # 49 +patch_frame_size=224 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +# audio +audio_encoder_name=pann_cnn14 +audio_model_path=${base_log_dir}/pretrained_models/Cnn14_mAP_0.431.pth +mel_bins=64 +hop_size=200 # 155 tok + + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +echo "max_epoch "${max_epoch} +for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16-scale-window=512 \ + --fp16 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --audio-encoder-name=${audio_encoder_name} \ + --audio-model-path=${audio_model_path} \ + --mel-bins=${mel_bins} \ + --hop-size=${hop_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --audio-sample-rate \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + + done +done diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s2_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..f7b27c72337a03f621b6f1c4a8da63275761cd90 --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_audio_caption_s2_onlylinear.sh @@ -0,0 +1,217 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_audio_caption_s2_onlylinear + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/audio_data/caption_data +data=${data_dir}/audiocaps_train_1.tsv,${data_dir}/audiocaps_train_2.tsv,${data_dir}/audiocaps_train_3.tsv,${data_dir}/audiocaps_train_4.tsv,${data_dir}/audiocaps_train_5.tsv,${data_dir}/audiocaps_train_6.tsv,${data_dir}/audiocaps_train_7.tsv,${data_dir}/audiocaps_train_8.tsv,${data_dir}/audiocaps_train_9.tsv,${data_dir}/audiocaps_train_10.tsv,${data_dir}/audiocaps_test.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/audiocaps-test-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint3.pt + + + +selected_cols=0,4,2 + +task=audio_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=5e-4 +max_epoch=25 +warmup_ratio=0.06 +batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 144 +patch_image_size=384 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 # 49 +patch_frame_size=224 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +# audio +audio_encoder_name=pann_cnn14 +audio_model_path=${base_log_dir}/pretrained_models/Cnn14_mAP_0.431.pth +mel_bins=64 +hop_size=200 # 155 tok + + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +echo "max_epoch "${max_epoch} +for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16-scale-window=512 \ + --fp16 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --audio-encoder-name=${audio_encoder_name} \ + --audio-model-path=${audio_model_path} \ + --mel-bins=${mel_bins} \ + --hop-size=${hop_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --save-on-cuda \ + --strict \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --audio-sample-rate \ + --strict \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + + done +done diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_1_s1_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_1_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..de9e8af7bf130810670e04ef3e9d1a81f4347665 --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_1_s1_onlylinear.sh @@ -0,0 +1,199 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_caption_stage_1_s1_onlylinear + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s1/checkpoint15.pt + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=5e-4 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_2_s1_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_2_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..ed2143fc0fe99b09cc1e32e913292ad70776a40f --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_caption_stage_2_s1_onlylinear.sh @@ -0,0 +1,199 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_caption_stage_2_s1_onlylinear + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint3.pt + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=5e-4 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s1_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..223f39bb43e245fc9483a76c2618136e52ff9503 --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s1_onlylinear.sh @@ -0,0 +1,206 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_video_caption_s1_onlylinear + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/msrvtt_caption_train7k_1.tsv,${data_dir}/msrvtt_caption_train7k_2.tsv,${data_dir}/msrvtt_caption_train7k_3.tsv,${data_dir}/msrvtt_caption_train7k_4.tsv,${data_dir}/msrvtt_caption_train7k_5.tsv,${data_dir}/msrvtt_caption_train7k_6.tsv,${data_dir}/msrvtt_caption_train7k_7.tsv,${data_dir}/msrvtt_caption_train7k_8.tsv,${data_dir}/msrvtt_caption_train7k_9.tsv,${data_dir}/msrvtt_caption_train7k_10.tsv,${data_dir}/msrvtt_caption_test3k.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s1/checkpoint15.pt + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=1e-3 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s2_onlylinear.sh b/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..edc0ef8be6614028a36dce60f4eaec1daacf35b7 --- /dev/null +++ b/run_scripts/caption/scaling_best/onlylinear/unival_video_caption_s2_onlylinear.sh @@ -0,0 +1,209 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_video_caption_s2_onlylinear + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/msrvtt_caption_train7k_1.tsv,${data_dir}/msrvtt_caption_train7k_2.tsv,${data_dir}/msrvtt_caption_train7k_3.tsv,${data_dir}/msrvtt_caption_train7k_4.tsv,${data_dir}/msrvtt_caption_train7k_5.tsv,${data_dir}/msrvtt_caption_train7k_6.tsv,${data_dir}/msrvtt_caption_train7k_7.tsv,${data_dir}/msrvtt_caption_train7k_8.tsv,${data_dir}/msrvtt_caption_train7k_9.tsv,${data_dir}/msrvtt_caption_train7k_10.tsv,${data_dir}/msrvtt_caption_test3k.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint3.pt + + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +# lr=5e-4 +lr=1e-3 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/unival_caption_stage_1.sh b/run_scripts/caption/scaling_best/unival_caption_stage_1.sh new file mode 100644 index 0000000000000000000000000000000000000000..beb1c2332a978f107af000ff58cef5db25e690d9 --- /dev/null +++ b/run_scripts/caption/scaling_best/unival_caption_stage_1.sh @@ -0,0 +1,205 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_caption_stage_1 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/caption_data +# data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/caption_stage1_train_1.tsv,${data_dir}/caption_stage1_train_2.tsv,${data_dir}/caption_stage1_train_3.tsv,${data_dir}/caption_stage1_train_4.tsv,${data_dir}/caption_stage1_train_5.tsv,${data_dir}/caption_stage1_train_6.tsv,${data_dir}/caption_stage1_train_7.tsv,${data_dir}/caption_stage1_train_8.tsv,${data_dir}/caption_stage1_train_9.tsv,${data_dir}/caption_stage1_train_10.tsv,${data_dir}/caption_val.tsv + + +eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + +lr=1e-5 + + +selected_cols=0,4,2 + +task=caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=10 +warmup_ratio=0.06 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"stop_on_max_len":true,"max_len_b":22,"no_repeat_ngram_size":3}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +drop_best_ratio=0.05 +drop_best_after=6000 +log_end=0.75 # for el +# log_end=1. # for el + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh b/run_scripts/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..0b1e9693f96126d7dfa5ab28f5883f6946ed2399 --- /dev/null +++ b/run_scripts/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh @@ -0,0 +1,210 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + +exp_name=unival_video_caption_activitynet_stage_1 + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/caption/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/activitynet_caption_train.tsv,${data_dir}/activitynet_caption_val2.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/activitynet-val2-words.p + +data=${data_dir}/activitynet_caption_train_1.tsv,${data_dir}/activitynet_caption_train_2.tsv,${data_dir}/activitynet_caption_train_3.tsv,${data_dir}/activitynet_caption_train_4.tsv,${data_dir}/activitynet_caption_train_5.tsv,${data_dir}/activitynet_caption_train_6.tsv,${data_dir}/activitynet_caption_train_7.tsv,${data_dir}/activitynet_caption_train_8.tsv,${data_dir}/activitynet_caption_train_9.tsv,${data_dir}/activitynet_caption_train_10.tsv,${data_dir}/activitynet_caption_val2.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + + + + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +lr=3e-5 +max_epoch=25 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + ${use_dataaug} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict + + + done + done +done \ No newline at end of file diff --git a/run_scripts/caption/scaling_best/video/unival_video_caption_stage_1.sh b/run_scripts/caption/scaling_best/video/unival_video_caption_stage_1.sh new file mode 100644 index 0000000000000000000000000000000000000000..bc6e0d818ff12cd6b255fcb3b11036aa2f41791c --- /dev/null +++ b/run_scripts/caption/scaling_best/video/unival_video_caption_stage_1.sh @@ -0,0 +1,210 @@ + + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=unival_video_caption_stage_1 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/caption/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +image_dir=${base_data_dir} + + +data_dir=${base_data_dir}/ofa/video_data/caption_data +data=${data_dir}/msrvtt_caption_train7k.tsv,${data_dir}/msrvtt_caption_test3k.tsv +eval_cider_cached=${data_dir}/cider_cached_tokens/msrvtt-test3k-words.p + +data=${data_dir}/msrvtt_caption_train7k_1.tsv,${data_dir}/msrvtt_caption_train7k_2.tsv,${data_dir}/msrvtt_caption_train7k_3.tsv,${data_dir}/msrvtt_caption_train7k_4.tsv,${data_dir}/msrvtt_caption_train7k_5.tsv,${data_dir}/msrvtt_caption_train7k_6.tsv,${data_dir}/msrvtt_caption_train7k_7.tsv,${data_dir}/msrvtt_caption_train7k_8.tsv,${data_dir}/msrvtt_caption_train7k_9.tsv,${data_dir}/msrvtt_caption_train7k_10.tsv,${data_dir}/msrvtt_caption_test3k.tsv + +restore_file=${save_base_log_dir}/ofa/checkpoints/pretrain/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs/checkpoint1.pt + +lr=1e-5 + + + + +selected_cols=0,4,2 + +task=video_caption +arch=unival_base +pretrained_model= + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 + +max_epoch=15 +warmup_ratio=0.06 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +# patch_image_size=480 +drop_worst_ratio=0.2 + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.06,}; do + echo "warmup_ratio "${warmup_ratio} + for drop_worst_after in {6000,}; do + echo "drop_worst_after "${drop_worst_after} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${drop_worst_after} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-cider \ + --eval-cider-cached-tokens=${eval_cider_cached} \ + --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \ + --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --drop-worst-ratio=${drop_worst_ratio} \ + --drop-worst-after=${drop_worst_after} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --num-frames=${num_frames} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer + + + done + done +done \ No newline at end of file diff --git a/run_scripts/image_gen/.ipynb_checkpoints/generate_code-checkpoint.py b/run_scripts/image_gen/.ipynb_checkpoints/generate_code-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..4b529019edb38f9073fccbf712509b11b65200f7 --- /dev/null +++ b/run_scripts/image_gen/.ipynb_checkpoints/generate_code-checkpoint.py @@ -0,0 +1,159 @@ +import sys + +sys.path.append('../../') +import argparse +import base64 +from io import BytesIO +from data.file_dataset import FileDataset +from PIL import Image, ImageFile +from torchvision import transforms +from omegaconf import OmegaConf +from models.taming.models.vqgan import GumbelVQ +import os + +import torch +from torch.utils.data import Dataset, DataLoader +import numpy as np + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + + +class VQGANDataset(Dataset): + def __init__(self, file, selected_cols, skip_convert_images=True, image_root=None): + self.reader = FileDataset( + file, + selected_col_ids=selected_cols, + ) + + self.skip_convert_images = skip_convert_images + self.image_root = image_root + + if self.skip_convert_images: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((args.code_image_size,args.code_image_size),interpolation=Image.BICUBIC), + transforms.ToTensor(), + preprocess_vqgan + ]) + else: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize(args.code_image_size, interpolation=Image.LANCZOS), + transforms.ToTensor(), + preprocess_vqgan + ]) + + def __len__(self): + return len(self.reader) + + def __getitem__(self, item): + column_l = self.reader[item] + if len(column_l) == 4: + pair_id, image_id, image, text = column_l + elif len(column_l) == 2: + image_id, image = column_l + else: + raise NotImplementedError + + + if not self.skip_convert_images: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))) + else: + if self.image_root is not None: + image = os.path.join(self.image_root, image) + + image = Image.open(image) + code_image = self.code_resize_transform(image) + if len(column_l) == 4: + return {"code_image": code_image, "pair_id": pair_id, "image_id": image_id, "text": text} + elif len(column_l) == 2: + return {"code_image": code_image, "image_id": image_id} + + +def custom_to_pil(x): + x = x.detach().cpu() + x = torch.clamp(x, -1., 1.) + x = (x + 1.) / 2. + x = x.permute(1, 2, 0).numpy() + x = (255 * x).astype(np.uint8) + x = Image.fromarray(x) + if not x.mode == "RGB": + x = x.convert("RGB") + return x + + +def map_pixels(x, eps=0.1): + return (1 - 2 * eps) * x + eps + + +def preprocess_vqgan(x): + x = 2. * x - 1. + return x + + +def image_to_base64(img, format): + output_buffer = BytesIO() + img.save(output_buffer, format=format) + byte_data = output_buffer.getvalue() + base64_str = base64.b64encode(byte_data) + base64_str = str(base64_str, encoding='utf-8') + return base64_str + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--file", type=str, default="") + parser.add_argument("--outputs", type=str, default="") + parser.add_argument("--selected_cols", type=str, required=True) + parser.add_argument("--code_image_size", type=int, required=True) + parser.add_argument("--vq_model", type=str, required=True) + parser.add_argument("--vqgan_model_path", type=str, default=None) + parser.add_argument("--vqgan_config_path", type=str, default=None) + parser.add_argument("--log_interval", default=100, type=int, help="log interval") + parser.add_argument("--worker_cnt", type=int, default=1) + parser.add_argument("--local_rank", type=int, default=0) + parser.add_argument("--batch_size", type=int, default=32) + parser.add_argument("--skip_convert_images", type=bool, default=False) + parser.add_argument("--image_root", type=str, default=None) + + + + args = parser.parse_args() + + vqgan_config = OmegaConf.load(args.vqgan_config_path) + vqgan = GumbelVQ(**vqgan_config.model.params) + sd = torch.load(args.vqgan_model_path, map_location="cpu")["state_dict"] + missing, unexpected = vqgan.load_state_dict(sd, strict=False) + for k, v in vqgan.named_parameters(): + v.requires_grad = False + image_tokenizer = vqgan.cuda().eval() + + writer = open(args.outputs, 'w') + + print("begin process") + + data_cnt = 0 + + dataset = VQGANDataset(args.file, args.selected_cols, skip_convert_images=args.skip_convert_images, image_root=args.image_root) + dataloader = DataLoader(dataset, batch_size=args.batch_size) + + for data in dataloader: + batch_size = data["code_image"].size()[0] + with torch.no_grad(): + z, _, [_, _, image_codes] = image_tokenizer.encode(data["code_image"].cuda()) + image_codes = image_codes.view(batch_size, -1).detach() + + for i, image_code in enumerate(image_codes): + code = ' '.join([str(num) for num in image_code.tolist()]) + + if len(data.keys()) == 4: + writer.write('\t'.join([data['pair_id'][i], data['image_id'][i], data['text'][i], code])+'\n') + elif len(data.keys()) == 2: + writer.write('\t'.join([data['image_id'][i], code])+'\n') + else: + raise NotImplementedError + writer.close() + + print("finish") diff --git a/run_scripts/image_gen/.ipynb_checkpoints/generate_for_vqgan_code-checkpoint.sh b/run_scripts/image_gen/.ipynb_checkpoints/generate_for_vqgan_code-checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..87c5af3e461f30779e6b69e931678127e5aab9cc --- /dev/null +++ b/run_scripts/image_gen/.ipynb_checkpoints/generate_for_vqgan_code-checkpoint.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env + +# for text-image paired data, each line of the given input file should contain these information (separated by tabs): +# input format +# uniq-id, image-id, image base64 string and text +# input example +# 162365 12455 /9j/4AAQSkZJ....UCP/2Q== two people in an ocean playing with a yellow frisbee. +# +# output format +# uniq-id, image-id, text and code +# output example +# 162364 12455 two people in an ocean playing with a yellow frisbee. 6288 4495 4139...4691 4844 6464 + +CUDA_VISIBLE_DEVICES=0 python generate_code.py \ + --file ./custom_data.txt \ + --outputs ./custom_data_code.txt \ + --selected_cols 0,1,2,3 \ + --code_image_size 256 \ + --vq_model vqgan \ + --vqgan_model_path ../../checkpoints/vqgan/last.ckpt \ + --vqgan_config_path ../../checkpoints/vqgan/model.yaml + +# for image-only data each line of the given input file should contain these information (separated by tabs): +# input format +# image-id and image base64 string +# input example: +# 12455 /9j/4AAQSkZJ....UCP/2Q== +# +# output format +# image-id and code +# 12455 6288 4495 4139...4691 4844 6464 + +CUDA_VISIBLE_DEVICES=0 python generate_code.py \ + --file ./custom_data.txt \ + --outputs ./custom_data_code.txt \ + --selected_cols 0,1 \ + --code_image_size 256 \ + --vq_model vqgan \ + --vqgan_model_path ../../checkpoints/vqgan/last.ckpt \ + --vqgan_config_path ../../checkpoints/vqgan/model.yaml diff --git a/run_scripts/image_gen/eval/eval_image_gen.sh b/run_scripts/image_gen/eval/eval_image_gen.sh new file mode 100644 index 0000000000000000000000000000000000000000..14882f95f06396a6a7ec92796d960fa8cfe5a3db --- /dev/null +++ b/run_scripts/image_gen/eval/eval_image_gen.sh @@ -0,0 +1,98 @@ +#!/usr/bin/env + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/image_gen_data + +data=${data_dir}/coco_vqgan_full_test.tsv + +# data=${data_dir}/coco_vqgan_dev.tsv + + +model_name=unival_image_gen_ofa_stage_2 +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/image_gen/unival_image_gen_ofa_stage_2/checkpoint_best1.pt + + +selected_cols=0,2,1 +split='test' + + +VQGAN_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/last.ckpt +VQGAN_CONFIG_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/model.yaml +CLIP_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/clip/ViT-B-16.pt +GEN_IMAGES_PATH=/lus/scratch/NAT/gda2204/SHARED/tmp/results/image_gen/${model_name} +mkdir -p $GEN_IMAGES_PATH + +echo "torch_home_path" +echo $TORCH_HOME +export TORCH_HOME=/home/mshukor/.cache/torch + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --task=image_gen \ + --batch-size=1 \ + --log-format=simple --log-interval=1 \ + --seed=42 \ + --gen-subset=${split} \ + --beam=16 \ + --min-len=1024 \ + --max-len-a=0 \ + --max-len-b=1024 \ + --sampling-topk=256 \ + --temperature=1.0 \ + --code-image-size=256 \ + --constraint-range=50265,58457 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"clip_model_path\":\"${CLIP_MODEL_PATH}\",\"vqgan_model_path\":\"${VQGAN_MODEL_PATH}\",\"vqgan_config_path\":\"${VQGAN_CONFIG_PATH}\",\"gen_images_path\":\"${GEN_IMAGES_PATH}\"}" + + +# compute IS +python image_gen/inception_score.py --gpu 4 --batch-size 128 --path1 ${GEN_IMAGES_PATH}/top1 + +# compute FID, download statistics for test dataset first. +python image_gen/fid_score.py --gpu 4 --batch-size 128 --path1 ${GEN_IMAGES_PATH}/top1 --path2 /lus/scratch/NAT/gda2204/SHARED/tmp/ofa/image_gen_data/gt_stat.npz + diff --git a/run_scripts/image_gen/eval_utils/__pycache__/dataset.cpython-39.pyc b/run_scripts/image_gen/eval_utils/__pycache__/dataset.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7dcc64c3b7f5d5d7d59da0a4ac9471377492a6f1 Binary files /dev/null and b/run_scripts/image_gen/eval_utils/__pycache__/dataset.cpython-39.pyc differ diff --git a/run_scripts/image_gen/eval_utils/__pycache__/inceptionV3.cpython-39.pyc b/run_scripts/image_gen/eval_utils/__pycache__/inceptionV3.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3464df4e7691e0f387c4d7fed441e024054e3149 Binary files /dev/null and b/run_scripts/image_gen/eval_utils/__pycache__/inceptionV3.cpython-39.pyc differ diff --git a/run_scripts/image_gen/eval_utils/dataset.py b/run_scripts/image_gen/eval_utils/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..ed7a86f13b359a79d22c89681a8af32792e47c95 --- /dev/null +++ b/run_scripts/image_gen/eval_utils/dataset.py @@ -0,0 +1,34 @@ +from torch.utils import data +from PIL import Image +import os + + +class Dataset(data.Dataset): + 'Characterizes a dataset for PyTorch' + + def __init__(self, path, transform=None): + 'Initialization' + self.file_names = self.get_filenames(path) + self.transform = transform + + def __len__(self): + 'Denotes the total number of samples' + return len(self.file_names) + + def __getitem__(self, index): + 'Generates one sample of data' + img = Image.open(self.file_names[index]).convert('RGB') + # Convert image and label to torch tensors + if self.transform is not None: + img = self.transform(img) + return img + + def get_filenames(self, data_path): + images = [] + for path, subdirs, files in os.walk(data_path): + for name in files: + if name.rfind('jpg') != -1 or name.rfind('png') != -1: + filename = os.path.join(path, name) + if os.path.isfile(filename): + images.append(filename) + return images diff --git a/run_scripts/image_gen/eval_utils/inceptionV3.py b/run_scripts/image_gen/eval_utils/inceptionV3.py new file mode 100644 index 0000000000000000000000000000000000000000..4c5932f16294db0cae9fad6c59b5c9262c801d51 --- /dev/null +++ b/run_scripts/image_gen/eval_utils/inceptionV3.py @@ -0,0 +1,150 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import models + +class InceptionV3(nn.Module): + """Pretrained InceptionV3 network returning feature maps""" + + # Index of default block of inception to return, + # corresponds to output of final average pooling + DEFAULT_BLOCK_INDEX = 3 + + # Maps feature dimensionality to their output blocks indices + BLOCK_INDEX_BY_DIM = { + 64: 0, # First max pooling features + 192: 1, # Second max pooling featurs + 768: 2, # Pre-aux classifier features + 2048: 3 # Final average pooling features + } + + def __init__(self, + output_blocks=[DEFAULT_BLOCK_INDEX], + resize_input=True, + normalize_input=True, + requires_grad=False, + pretrained_weights='/lus/home/NAT/gda2204/mshukor/.cache/torch/hub/checkpoints/inception_v3_google-0cc3c7bd.pth'): + """Build pretrained InceptionV3 + + Parameters + ---------- + output_blocks : list of int + Indices of blocks to return features of. Possible values are: + - 0: corresponds to output of first max pooling + - 1: corresponds to output of second max pooling + - 2: corresponds to output which is fed to aux classifier + - 3: corresponds to output of final average pooling + resize_input : bool + If true, bilinearly resizes input to width and height 299 before + feeding input to model. As the network without fully connected + layers is fully convolutional, it should be able to handle inputs + of arbitrary size, so resizing might not be strictly needed + normalize_input : bool + If true, normalizes the input to the statistics the pretrained + Inception network expects + requires_grad : bool + If true, parameters of the model require gradient. Possibly useful + for finetuning the network + """ + super(InceptionV3, self).__init__() + + self.resize_input = resize_input + self.normalize_input = normalize_input + self.output_blocks = sorted(output_blocks) + self.last_needed_block = max(output_blocks) + + assert self.last_needed_block <= 3, \ + 'Last possible output block index is 3' + + self.blocks = nn.ModuleList() + import os + # os.environ['TORCH_HOME'] = '.' + + inception = models.inception_v3() + + checkpoint = torch.load(pretrained_weights) + + # print(checkpoint.keys()) + msg = inception.load_state_dict(checkpoint) + print(msg) + + # Block 0: input to maxpool1 + block0 = [ + inception.Conv2d_1a_3x3, + inception.Conv2d_2a_3x3, + inception.Conv2d_2b_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block0)) + + # Block 1: maxpool1 to maxpool2 + if self.last_needed_block >= 1: + block1 = [ + inception.Conv2d_3b_1x1, + inception.Conv2d_4a_3x3, + nn.MaxPool2d(kernel_size=3, stride=2) + ] + self.blocks.append(nn.Sequential(*block1)) + + # Block 2: maxpool2 to aux classifier + if self.last_needed_block >= 2: + block2 = [ + inception.Mixed_5b, + inception.Mixed_5c, + inception.Mixed_5d, + inception.Mixed_6a, + inception.Mixed_6b, + inception.Mixed_6c, + inception.Mixed_6d, + inception.Mixed_6e, + ] + self.blocks.append(nn.Sequential(*block2)) + + # Block 3: aux classifier to final avgpool + if self.last_needed_block >= 3: + block3 = [ + inception.Mixed_7a, + inception.Mixed_7b, + inception.Mixed_7c, + nn.AdaptiveAvgPool2d(output_size=(1, 1)) + ] + self.blocks.append(nn.Sequential(*block3)) + + for param in self.parameters(): + param.requires_grad = requires_grad + + def forward(self, inp): + """Get Inception feature maps + + Parameters + ---------- + inp : torch.autograd.Variable + Input tensor of shape Bx3xHxW. Values are expected to be in + range (0, 1) + + Returns + ------- + List of torch.autograd.Variable, corresponding to the selected output + block, sorted ascending by index + """ + outp = [] + x = inp + + if self.resize_input: + x = F.upsample(x, size=(299, 299), mode='bilinear', align_corners=True) + + if self.normalize_input: + x = x.clone() + x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 + x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 + x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 + + for idx, block in enumerate(self.blocks): + x = block(x) + if idx in self.output_blocks: + outp.append(x) + + if idx == self.last_needed_block: + break + + return outp diff --git a/run_scripts/image_gen/fid_score.py b/run_scripts/image_gen/fid_score.py new file mode 100644 index 0000000000000000000000000000000000000000..7613564d6d3551f431a9a9179b8b3d95970c254c --- /dev/null +++ b/run_scripts/image_gen/fid_score.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python3 +"""Calculates the Frechet Inception Distance (FID) to evalulate GANs + +The FID metric calculates the distance between two distributions of images. +Typically, we have summary statistics (mean & covariance matrix) of one +of these distributions, while the 2nd distribution is given by a GAN. + +When run as a stand-alone program, it compares the distribution of +images that are stored as PNG/JPEG at a specified location with a +distribution given by summary statistics (in pickle format). + +The FID is calculated by assuming that X_1 and X_2 are the activations of +the pool_3 layer of the inception net for generated samples and real world +samples respectivly. + +See --help to see further details. + +Code apapted from https://github.com/bioinf-jku/TTUR to use PyTorch instead +of Tensorflow + +Copyright 2018 Institute of Bioinformatics, JKU Linz + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" +import os +from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter + +import numpy as np +import torch +import torch.utils.data +import torchvision.transforms as transforms +import tqdm +from PIL import Image +from scipy import linalg +from torch.nn.functional import adaptive_avg_pool2d +from torch.utils import data + +from eval_utils.inceptionV3 import InceptionV3 + +class Dataset(data.Dataset): + 'Characterizes a dataset for PyTorch' + + def __init__(self, path, transform=None): + 'Initialization' + self.file_names = self.get_filenames(path) + self.transform = transform + + def __len__(self): + 'Denotes the total number of samples' + return len(self.file_names) + + def __getitem__(self, index): + 'Generates one sample of data' + img = Image.open(self.file_names[index]).convert('RGB') + # Convert image and label to torch tensors + if self.transform is not None: + img = self.transform(img) + return img + + def get_filenames(self, data_path): + images = [] + for path, subdirs, files in os.walk(data_path): + for name in files: + if name.rfind('jpg') != -1 or name.rfind('png') != -1: + filename = os.path.join(path, name) + if os.path.isfile(filename): + images.append(filename) + return images + + +parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter) +parser.add_argument('--batch-size', type=int, default=64, + help='Batch size to use') +parser.add_argument('--dims', type=int, default=2048, + choices=list(InceptionV3.BLOCK_INDEX_BY_DIM), + help=('Dimensionality of Inception features to use. ' + 'By default, uses pool3 features')) +parser.add_argument('-c', '--gpu', default='', type=str, + help='GPU to use (leave blank for CPU only)') +parser.add_argument('--path1', type=str, help='path to images') +parser.add_argument('--path2', type=str, help='path to images') + + +def get_activations(images, model, batch_size=64, dims=2048, cuda=False, verbose=True): + """Calculates the activations of the pool_3 layer for all images. + + Params: + -- images : Numpy array of dimension (n_images, 3, hi, wi). The values + must lie between 0 and 1. + -- model : Instance of inception model + -- batch_size : the images numpy array is split into batches with + batch size batch_size. A reasonable batch size depends + on the hardware. + -- dims : Dimensionality of features returned by Inception + -- cuda : If set to True, use GPU + -- verbose : If set to True and parameter out_step is given, the number + of calculated batches is reported. + Returns: + -- A numpy array of dimension (num images, dims) that contains the + activations of the given tensor when feeding inception with the + query tensor. + """ + model.eval() + + # d0 = images.shape[0] + + d0 = images.__len__() * batch_size + if batch_size > d0: + print(('Warning: batch size is bigger than the data size. ' + 'Setting batch size to data size')) + batch_size = d0 + + n_batches = d0 // batch_size + n_used_imgs = n_batches * batch_size + + pred_arr = np.empty((n_used_imgs, dims)) + # for i in range(n_batches): + for i, batch in tqdm.tqdm(enumerate(images)): + # batch = batch[0] + # if verbose: + # print('\rPropagating batch %d/%d' % (i + 1, n_batches), end='', flush=True) + # import ipdb + # ipdb.set_trace() + start = i * batch_size + end = start + batch_size + + # batch = torch.from_numpy(images[start:end]).type(torch.FloatTensor) + # batch = Variable(batch, volatile=True) + + if cuda: + batch = batch.cuda() + + pred = model(batch)[0] + + # If model output is not scalar, apply global spatial average pooling. + # This happens if you choose a dimensionality not equal 2048. + if pred.shape[2] != 1 or pred.shape[3] != 1: + pred = adaptive_avg_pool2d(pred, output_size=(1, 1)) + + pred_arr[start:end] = pred.cpu().data.numpy().reshape(batch_size, -1) + + if verbose: + print(' done') + + return pred_arr + + +def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6): + """Numpy implementation of the Frechet Distance. + The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1) + and X_2 ~ N(mu_2, C_2) is + d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)). + + Stable version by Dougal J. Sutherland. + + Params: + -- mu1 : Numpy array containing the activations of a layer of the + inception net (like returned by the function 'get_predictions') + for generated samples. + -- mu2 : The sample mean over activations, precalculated on an + representive data set. + -- sigma1: The covariance matrix over activations for generated samples. + -- sigma2: The covariance matrix over activations, precalculated on an + representive data set. + + Returns: + -- : The Frechet Distance. + """ + + mu1 = np.atleast_1d(mu1) + mu2 = np.atleast_1d(mu2) + + sigma1 = np.atleast_2d(sigma1) + sigma2 = np.atleast_2d(sigma2) + + assert mu1.shape == mu2.shape, \ + 'Training and test mean vectors have different lengths' + assert sigma1.shape == sigma2.shape, \ + 'Training and test covariances have different dimensions' + + diff = mu1 - mu2 + + # Product might be almost singular + covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) + if not np.isfinite(covmean).all(): + msg = ('fid calculation produces singular product; ' + 'adding %s to diagonal of cov estimates') % eps + print(msg) + offset = np.eye(sigma1.shape[0]) * eps + covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) + + # Numerical error might give slight imaginary component + if np.iscomplexobj(covmean): + if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): + m = np.max(np.abs(covmean.imag)) + raise ValueError('Imaginary component {}'.format(m)) + covmean = covmean.real + + tr_covmean = np.trace(covmean) + + return (diff.dot(diff) + np.trace(sigma1) + + np.trace(sigma2) - 2 * tr_covmean) + + +def calculate_activation_statistics(images, model, batch_size=64, + dims=2048, cuda=False, verbose=True): + """Calculation of the statistics used by the FID. + Params: + -- images : Numpy array of dimension (n_images, 3, hi, wi). The values + must lie between 0 and 1. + -- model : Instance of inception model + -- batch_size : The images numpy array is split into batches with + batch size batch_size. A reasonable batch size + depends on the hardware. + -- dims : Dimensionality of features returned by Inception + -- cuda : If set to True, use GPU + -- verbose : If set to True and parameter out_step is given, the + number of calculated batches is reported. + Returns: + -- mu : The mean over samples of the activations of the pool_3 layer of + the inception model. + -- sigma : The covariance matrix of the activations of the pool_3 layer of + the inception model. + """ + act = get_activations(images, model, batch_size, dims, cuda, verbose) + mu = np.mean(act, axis=0) + sigma = np.cov(act, rowvar=False) + return mu, sigma + + +def _compute_statistics_of_path(path, model, batch_size, dims, cuda): + if path.endswith('.npz'): + f = np.load(path) + m, s = f['mu'][:], f['sigma'][:] + f.close() + + else: + dataset = Dataset(path, transforms.Compose([ + transforms.Resize((299, 299)), + transforms.ToTensor(), + ])) + print(dataset.__len__()) + if dataset.__len__() < batch_size: + batch_size = 1 + dataloader = torch.utils.data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=False, drop_last=True, + num_workers=0) + m, s = calculate_activation_statistics(dataloader, model, batch_size, dims, cuda) + return m, s + + +def calculate_fid_given_paths(paths, batch_size, cuda, dims): + """Calculates the FID of two paths""" + for p in paths: + if not os.path.exists(p): + raise RuntimeError('Invalid path: %s' % p) + + block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims] + + model = InceptionV3([block_idx], pretrained_weights='/lus/home/NAT/gda2204/mshukor/.cache/torch/hub/checkpoints/inception_v3_google-0cc3c7bd.pth') + + + if cuda: + model.cuda() + + m1, s1 = _compute_statistics_of_path(paths[0], model, batch_size, dims, cuda) + m2, s2 = _compute_statistics_of_path(paths[1], model, batch_size, dims, cuda) + fid_value = calculate_frechet_distance(m1, s1, m2, s2) + return fid_value + + +if __name__ == '__main__': + args = parser.parse_args() + os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu + paths = ["", ""] + paths[0] = args.path1 + paths[1] = args.path2 + print(paths) + fid_value = calculate_fid_given_paths(paths, args.batch_size, args.gpu, args.dims) + print('FID: ', fid_value) diff --git a/run_scripts/image_gen/generate_code.py b/run_scripts/image_gen/generate_code.py new file mode 100644 index 0000000000000000000000000000000000000000..020eb1160a8cb09b557eaa854b2a88e16394f2a6 --- /dev/null +++ b/run_scripts/image_gen/generate_code.py @@ -0,0 +1,197 @@ +import sys + +sys.path.append('../../') +import argparse +import base64 +from io import BytesIO +from data.file_dataset import FileDataset +from PIL import Image, ImageFile +from torchvision import transforms +from omegaconf import OmegaConf +from models.taming.models.vqgan import GumbelVQ +import os + +import torch +from torch.utils.data import Dataset, DataLoader +import numpy as np + +ImageFile.LOAD_TRUNCATED_IMAGES = True +ImageFile.MAX_IMAGE_PIXELS = None +Image.MAX_IMAGE_PIXELS = None + +from tqdm import tqdm + +class VQGANDataset(Dataset): + def __init__(self, file, selected_cols, skip_convert_images=True, image_root=None, pretraininig=True): + self.reader = FileDataset( + file, + selected_col_ids=selected_cols, + ) + + self.skip_convert_images = skip_convert_images + self.image_root = image_root + + if self.skip_convert_images: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((args.code_image_size,args.code_image_size),interpolation=Image.BICUBIC), + transforms.ToTensor(), + preprocess_vqgan + ]) + if pretraininig: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((args.code_image_size,args.code_image_size),interpolation=Image.BICUBIC), + transforms.CenterCrop(int(0.5*args.code_image_size)), + transforms.ToTensor(), + preprocess_vqgan + ]) + else: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize(args.code_image_size, interpolation=Image.LANCZOS), + transforms.ToTensor(), + preprocess_vqgan + ]) + if pretraininig: + self.code_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize(args.code_image_size, interpolation=Image.LANCZOS), + transforms.CenterCrop(int(0.5*args.code_image_size)), + transforms.ToTensor(), + preprocess_vqgan + ]) + + def __len__(self): + return len(self.reader) + + def __getitem__(self, item): + column_l = self.reader[item] + if len(column_l) == 4: + pair_id, image_id, image, text = column_l + elif len(column_l) == 2: + image_id, image = column_l + else: + raise NotImplementedError + + + if not self.skip_convert_images: + image = Image.open(BytesIO(base64.urlsafe_b64decode(image))) + else: + if self.image_root is not None: + image = os.path.join(self.image_root, image) + try: + image = Image.open(image) + except PIL.UnidentifiedImageError: + column_l = self.reader[0] + if len(column_l) == 4: + pair_id, image_id, image, text = column_l + elif len(column_l) == 2: + image_id, image = column_l + else: + raise NotImplementedError + image = Image.open(image) + + code_image = self.code_resize_transform(image) + if len(column_l) == 4: + return {"code_image": code_image, "pair_id": pair_id, "image_id": image_id, "text": text} + elif len(column_l) == 2: + return {"code_image": code_image, "image_id": image_id} + + +def custom_to_pil(x): + x = x.detach().cpu() + x = torch.clamp(x, -1., 1.) + x = (x + 1.) / 2. + x = x.permute(1, 2, 0).numpy() + x = (255 * x).astype(np.uint8) + x = Image.fromarray(x) + if not x.mode == "RGB": + x = x.convert("RGB") + return x + + +def map_pixels(x, eps=0.1): + return (1 - 2 * eps) * x + eps + + +def preprocess_vqgan(x): + x = 2. * x - 1. + return x + + +def image_to_base64(img, format): + output_buffer = BytesIO() + img.save(output_buffer, format=format) + byte_data = output_buffer.getvalue() + base64_str = base64.b64encode(byte_data) + base64_str = str(base64_str, encoding='utf-8') + return base64_str + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--file", type=str, default="") + parser.add_argument("--outputs", type=str, default="") + parser.add_argument("--selected_cols", type=str, required=True) + parser.add_argument("--code_image_size", type=int, required=True) + parser.add_argument("--vq_model", type=str, required=True) + parser.add_argument("--vqgan_model_path", type=str, default=None) + parser.add_argument("--vqgan_config_path", type=str, default=None) + parser.add_argument("--log_interval", default=100, type=int, help="log interval") + parser.add_argument("--worker_cnt", type=int, default=1) + parser.add_argument("--local_rank", type=int, default=0) + parser.add_argument("--batch_size", type=int, default=32) + parser.add_argument("--skip_convert_images", type=bool, default=False) + parser.add_argument("--image_root", type=str, default=None) + parser.add_argument("--pretraininig", type=bool, default=True) + + + + + args = parser.parse_args() + + vqgan_config = OmegaConf.load(args.vqgan_config_path) + vqgan = GumbelVQ(**vqgan_config.model.params) + sd = torch.load(args.vqgan_model_path, map_location="cpu")["state_dict"] + missing, unexpected = vqgan.load_state_dict(sd, strict=False) + for k, v in vqgan.named_parameters(): + v.requires_grad = False + image_tokenizer = vqgan.cuda().eval() + + writer = open(args.outputs, 'w') + + print("begin process") + + data_cnt = 0 + + dataset = VQGANDataset(args.file, args.selected_cols, skip_convert_images=args.skip_convert_images, + image_root=args.image_root, pretraininig=args.pretraininig) + dataloader = DataLoader(dataset, batch_size=args.batch_size) + num_corrupted = 0 + processed_ids = {} + for data in tqdm(dataloader): + batch_size = data["code_image"].size()[0] + with torch.no_grad(): + z, _, [_, _, image_codes] = image_tokenizer.encode(data["code_image"].cuda()) + image_codes = image_codes.view(batch_size, -1).detach() + + for i, image_code in enumerate(image_codes): + code = ' '.join([str(num) for num in image_code.tolist()]) + if data['image_id'][i] in processed_ids: + continue + + processed_ids[data['image_id'][i]] = 0 + + if len(data.keys()) == 4: + writer.write('\t'.join([data['pair_id'][i], data['image_id'][i], data['text'][i], code])+'\n') + elif len(data.keys()) == 2: + writer.write('\t'.join([data['image_id'][i], code])+'\n') + else: + raise NotImplementedError + + print(len(processed_ids)) + writer.close() + + print("finish") + print('num_corrupted:', num_corrupted) diff --git a/run_scripts/image_gen/image_gen_example.py b/run_scripts/image_gen/image_gen_example.py new file mode 100644 index 0000000000000000000000000000000000000000..59875079a35f04119b864f312509143d3fef29bc --- /dev/null +++ b/run_scripts/image_gen/image_gen_example.py @@ -0,0 +1,144 @@ +import sys + +sys.path.append('../../') +import torch +import numpy as np +from fairseq import utils, tasks +from fairseq import checkpoint_utils +from utils.eval_utils import eval_step +from tasks.mm_tasks import ImageGenTask +from models.ofa import OFAModel +from PIL import Image +from torchvision import transforms +import time + +# Register caption task +tasks.register_task('image_gen', ImageGenTask) +# turn on cuda if GPU is available +use_cuda = torch.cuda.is_available() +# use fp16 only when GPU is available +use_fp16 = True if use_cuda else False + +base_log_dir='/work/NAT/gda2204/mshukor/logs' + +clip_model_path=f"{base_log_dir}/ofa/pretrained_models/clip/ViT-B-16.pt" +vqgan_model_path=f"{base_log_dir}/ofa/pretrained_models/vqgan/last.ckpt" +vqgan_config_path=f"{base_log_dir}/ofa/pretrained_models/vqgan/model.yaml" + +video_model_path = f'{base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth' +resnet_model_path = f'{base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth' + + + +model_name='image_gen_ofaplus_stage_1_base_s2_long' +checkpoint_path = '/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/image_gen/image_gen_ofaplus_stage_1_base_s2_long/50000_2000_1e-3/checkpoint_best.pt' +gen_images_path=f'/lus/scratch/NAT/gda2204/SHARED/tmp/results/test_{model_name}' + + +# Load pretrained ckpt & config +overrides = {"bpe_dir": "../../utils/BPE", + "eval_cider": False, + "beam": 16, + "max_len_b": 1024, + "min_len": 1024, + "sampling_topk": 256, + "constraint_range": "50265,58457", + "clip_model_path": clip_model_path, + "vqgan_model_path": vqgan_model_path, + "vqgan_config_path": vqgan_config_path, + "seed": 7, + "video_model_path": video_model_path, + "resnet_model_path": resnet_model_path, + "gen_images_path":gen_images_path, + } + + +models, cfg, task = checkpoint_utils.load_model_ensemble_and_task( + utils.split_paths(checkpoint_path), + arg_overrides=overrides +) +task.cfg.sampling_times = 2 +# Move models to GPU +for model in models: + model.eval() + if use_fp16: + model.half() + if use_cuda and not cfg.distributed_training.pipeline_model_parallel: + model.cuda() + model.prepare_for_inference_(cfg) + +# Initialize generator +generator = task.build_generator(models, cfg.generation) + +# Text preprocess +bos_item = torch.LongTensor([task.src_dict.bos()]) +eos_item = torch.LongTensor([task.src_dict.eos()]) +pad_idx = task.src_dict.pad() + + +def encode_text(text, length=None, append_bos=False, append_eos=False): + s = task.tgt_dict.encode_line( + line=task.bpe.encode(text), + add_if_not_exist=False, + append_eos=False + ).long() + if length is not None: + s = s[:length] + if append_bos: + s = torch.cat([bos_item, s]) + if append_eos: + s = torch.cat([s, eos_item]) + return s + + +# Construct input for image generation task +def construct_sample(query: str): + code_mask = torch.tensor([True]) + src_text = encode_text(" what is the complete image? caption: {}".format(query), append_bos=True, + append_eos=True).unsqueeze(0) + src_length = torch.LongTensor([s.ne(pad_idx).long().sum() for s in src_text]) + sample = { + "id": np.array(['42']), + "net_input": { + "src_tokens": src_text, + "src_lengths": src_length, + "code_masks": code_mask + } + } + return sample + + +# Function to turn FP32 to FP16 +def apply_half(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.half) + return t + + +# Function for image generation +def image_generation(caption): + sample = construct_sample(caption) + sample = utils.move_to_cuda(sample) if use_cuda else sample + sample = utils.apply_to_sample(apply_half, sample) if use_fp16 else sample + print('|Start|', time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), caption) + with torch.no_grad(): + result, scores = eval_step(task, generator, models, sample) + + # return top-4 results (ranked by clip) + images = [result[i]['image'] for i in range(4)] + pic_size = 256 + retImage = Image.new('RGB', (pic_size * 2, pic_size * 2)) + print('|FINISHED|', time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), caption) + for i in range(4): + loc = ((i % 2) * pic_size, int(i / 2) * pic_size) + retImage.paste(images[i], loc) + return retImage + + +# Waiting for user input +print('Please input your query.') +while True: + query = input() + retImage = image_generation(query) + retImage.save(f'{query}.png') + diff --git a/run_scripts/image_gen/inception_score.py b/run_scripts/image_gen/inception_score.py new file mode 100644 index 0000000000000000000000000000000000000000..3883593c38f5531dcf5626b8a6ac69027899d4ce --- /dev/null +++ b/run_scripts/image_gen/inception_score.py @@ -0,0 +1,107 @@ +import os +from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.utils.data +import torchvision.transforms as transforms +from torchvision.models.inception import inception_v3, Inception_V3_Weights +from scipy.stats import entropy +from torch.autograd import Variable +from eval_utils.dataset import Dataset +from eval_utils.inceptionV3 import InceptionV3 + +parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter) +parser.add_argument('--batch-size', type=int, default=64, + help='Batch size to use') +parser.add_argument('--dims', type=int, default=2048, + choices=list(InceptionV3.BLOCK_INDEX_BY_DIM), + help=('Dimensionality of Inception features to use. ' + 'By default, uses pool3 features')) +parser.add_argument('-c', '--gpu', default='', type=str, + help='GPU to use (leave blank for CPU only)') +parser.add_argument('--path1', type=str, help='path to images') + + +def inception_score(imgs, cuda=True, batch_size=32, resize=False, splits=1): + """Computes the inception score of the generated images imgs + imgs -- Torch dataset of (3xHxW) numpy images normalized in the range [-1, 1] + cuda -- whether or not to run on GPU + batch_size -- batch size for feeding into Inception v3 + splits -- number of splits + """ + N = len(imgs) + + os.environ['TORCH_HOME']= '/lus/home/NAT/gda2204/mshukor/.cache/torch' + + assert batch_size > 0 + if batch_size > N: + batch_size = N + + # Set up dtype + if cuda: + dtype = torch.cuda.FloatTensor + else: + if torch.cuda.is_available(): + print("WARNING: You have a CUDA device, so you should probably set cuda=True") + dtype = torch.FloatTensor + + # Set up dataloader + dataloader = torch.utils.data.DataLoader(imgs, batch_size=batch_size) + + # Load inception model + print("Load inception model") + inception_model = inception_v3(transform_input=False).type(dtype) + checkpoint = torch.load("/lus/home/NAT/gda2204/mshukor/.cache/torch/hub/checkpoints/inception_v3_google-0cc3c7bd.pth") + + # print(checkpoint.keys()) + inception_model.load_state_dict(checkpoint) + inception_model.eval() + up = nn.Upsample(size=(299, 299), mode='bilinear').type(dtype) + + def get_pred(x): + if resize: + x = up(x) + x = inception_model(x) + return F.softmax(x).data.cpu().numpy() + + # Get predictions + preds = np.zeros((N, 1000)) + + for i, batch in enumerate(dataloader, 0): + batch = batch.type(dtype) + batchv = Variable(batch) + batch_size_i = batch.size()[0] + + preds[i * batch_size:i * batch_size + batch_size_i] = get_pred(batchv) + + # Now compute the mean kl-div + split_scores = [] + + for k in range(splits): + part = preds[k * (N // splits): (k + 1) * (N // splits), :] + py = np.mean(part, axis=0) + scores = [] + for i in range(part.shape[0]): + pyx = part[i, :] + scores.append(entropy(pyx, py)) + split_scores.append(np.exp(np.mean(scores))) + + return np.mean(split_scores), np.std(split_scores) + + +if __name__ == '__main__': + + + args = parser.parse_args() + os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu + + dataset = Dataset(args.path1, transforms.Compose([ + transforms.Resize((299, 299)), + transforms.ToTensor(), + ])) + mean, std = inception_score(dataset, cuda=True, batch_size=32, resize=False, splits=1) + print('IS mean: ', mean) + print('IS std: ', std) diff --git a/run_scripts/image_gen/scaling_best/unival_image_gen_stage_1.sh b/run_scripts/image_gen/scaling_best/unival_image_gen_stage_1.sh new file mode 100644 index 0000000000000000000000000000000000000000..0ebea86d29528b98aec099f1631a8abdee38eb51 --- /dev/null +++ b/run_scripts/image_gen/scaling_best/unival_image_gen_stage_1.sh @@ -0,0 +1,195 @@ +#!/usr/bin/env + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_image_gen_stage_1 + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/image_gen_data +# data=${data_dir}/coco_vqgan_train.tsv,${data_dir}/coco_vqgan_dev.tsv +data_dir_train=/lus/scratch/NAT/gda2204/SHARED/tmp/ofa/image_gen_data +data=${data_dir_train}/coco_vqgan_train_1.tsv,${data_dir_train}/coco_vqgan_train_2.tsv,${data_dir_train}/coco_vqgan_train_3.tsv,${data_dir_train}/coco_vqgan_train_4.tsv,${data_dir_train}/coco_vqgan_train_5.tsv,${data_dir_train}/coco_vqgan_train_6.tsv,${data_dir_train}/coco_vqgan_train_7.tsv,${data_dir_train}/coco_vqgan_train_8.tsv,${data_dir_train}/coco_vqgan_train_9.tsv,${data_dir_train}/coco_vqgan_train_10.tsv,${data_dir}/coco_vqgan_dev.tsv + + + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + +selected_cols=0,2,1 + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/image_gen/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=image_gen +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +batch_size=8 +update_freq=2 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=64 +max_tgt_length=1024 +num_bins=1000 +code_image_size=256 +constraint_range=50265,58457 + +VQGAN_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/last.ckpt +VQGAN_CONFIG_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/model.yaml +CLIP_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/clip/ViT-B-16.pt +GEN_IMAGES_PATH=/lus/scratch/NAT/gda2204/SHARED/tmp/results/${exp_name} + +mkdir -p $GEN_IMAGES_PATH + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 + + +for total_num_updates in {50000,}; do + echo "total_num_updates "${total_num_updates} + for warmup_updates in {2000,}; do + echo "warmup_updates "${warmup_updates} + for lr in {1e-3,}; do + echo "lr "${lr} + + log_file=${log_dir}/${total_num_updates}"_"${warmup_updates}"_"${lr}"_rank"${RANK}".log" + save_path=${save_dir}/${total_num_updates}"_"${warmup_updates}"_"${lr} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --batch-size-valid=1 \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --total-num-update=${total_num_updates} \ + --warmup-updates=${warmup_updates} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-last-epochs=15 \ + --save-interval=3 --validate-interval=3 \ + --max-update=${total_num_updates} \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --eval-args='{"beam":24,"min_len":1024,"max_len_a":0,"max_len_b":1024,"sampling_topk":256,"temperature":1.0}' \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --code-image-size=${code_image_size} \ + --constraint-range=${constraint_range} \ + --vqgan-model-path=${VQGAN_MODEL_PATH} \ + --vqgan-config-path=${VQGAN_CONFIG_PATH} \ + --clip-model-path=${CLIP_MODEL_PATH} \ + --gen-images-path=${GEN_IMAGES_PATH} \ + --fp16 \ + --fp16-scale-window=256 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --strict + + done + done +done diff --git a/run_scripts/image_gen/scaling_best/unival_image_gen_stage_2.sh b/run_scripts/image_gen/scaling_best/unival_image_gen_stage_2.sh new file mode 100644 index 0000000000000000000000000000000000000000..df6385b21daf76db59c249e2a15fa9ed184b1a64 --- /dev/null +++ b/run_scripts/image_gen/scaling_best/unival_image_gen_stage_2.sh @@ -0,0 +1,196 @@ +#!/usr/bin/env + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_image_gen_stage_2 + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/image_gen_data + +data_dir_train=/lus/scratch/NAT/gda2204/SHARED/tmp/ofa/image_gen_data +data=${data_dir_train}/coco_vqgan_train_1.tsv,${data_dir_train}/coco_vqgan_train_2.tsv,${data_dir_train}/coco_vqgan_train_3.tsv,${data_dir_train}/coco_vqgan_train_4.tsv,${data_dir_train}/coco_vqgan_train_5.tsv,${data_dir_train}/coco_vqgan_train_6.tsv,${data_dir_train}/coco_vqgan_train_7.tsv,${data_dir_train}/coco_vqgan_train_8.tsv,${data_dir_train}/coco_vqgan_train_9.tsv,${data_dir_train}/coco_vqgan_train_10.tsv,${data_dir}/coco_vqgan_dev.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +# data=${data_dir}/coco_vqgan_train_1.tsv,${data_dir}/coco_vqgan_train_2.tsv,${data_dir}/coco_vqgan_train_3.tsv,${data_dir}/coco_vqgan_train_4.tsv,${data_dir}/coco_vqgan_train_5.tsv,${data_dir}/coco_vqgan_train_6.tsv,${data_dir}/coco_vqgan_train_7.tsv,${data_dir}/coco_vqgan_train_8.tsv,${data_dir}/coco_vqgan_train_9.tsv,${data_dir}/coco_vqgan_train_10.tsv,${data_dir}/coco_vqgan_dev.tsv + +restore_file=/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/image_gen/unival_image_gen_stage_1/50000_2000_1e-3/checkpoint_best.pt + + +selected_cols=0,2,1 + +# save_dir=${base_log_dir}/ofa/checkpoints/image_gen/${exp_name} +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/image_gen/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +task=image_gen +arch=unival_base +criterion=clip_scst_reward_criterion +batch_size=4 +update_freq=1 +encoder_drop_path_rate=0.0 +decoder_drop_path_rate=0.0 +dropout=0.0 +attention_dropout=0.0 +max_src_length=64 +max_tgt_length=1024 +num_bins=1000 +code_image_size=256 +constraint_range=50265,58457 + +VQGAN_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/last.ckpt +VQGAN_CONFIG_PATH=${base_log_dir}/ofa/pretrained_models/vqgan/model.yaml +CLIP_MODEL_PATH=${base_log_dir}/ofa/pretrained_models/clip/ViT-B-16.pt +GEN_IMAGES_PATH=/lus/scratch/NAT/gda2204/SHARED/tmp/results/${exp_name} +mkdir -p $GEN_IMAGES_PATH + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 + + +for total_num_updates in {5000,}; do + echo "total_num_updates "${total_num_updates} + for warmup_updates in {0,}; do + echo "warmup_updates "${warmup_updates} + for lr in {1e-6,}; do + echo "lr "${lr} + + log_file=${log_dir}/${total_num_updates}"_"${warmup_updates}"_"${lr}"_rank"${RANK}".log" + save_path=${save_dir}/${total_num_updates}"_"${warmup_updates}"_"${lr} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --batch-size-valid=1 \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --total-num-update=${total_num_updates} \ + --warmup-updates=${warmup_updates} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-last-epochs=15 \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=100 --validate-interval-updates=200 \ + --freeze-resnet \ + --max-update=${total_num_updates} \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --eval-args='{"beam":24,"min_len":1024,"max_len_a":0,"max_len_b":1024,"sampling_topk":256,"temperature":1.0}' \ + --scst \ + --scst-args='{"beam":5,"min_len":1024,"max_len_a":0,"max_len_b":1024,"sampling_topk":256,"temperature":1.0}' \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --code-image-size=${code_image_size} \ + --constraint-range=${constraint_range} \ + --vqgan-model-path=${VQGAN_MODEL_PATH} \ + --vqgan-config-path=${VQGAN_CONFIG_PATH} \ + --clip-model-path=${CLIP_MODEL_PATH} \ + --gen-images-path=${GEN_IMAGES_PATH} \ + --fp16 \ + --fp16-scale-window=256 \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-optimizer --reset-dataloader --reset-meters + done + done +done diff --git a/run_scripts/pretraining/scaling/unival_s1.sh b/run_scripts/pretraining/scaling/unival_s1.sh new file mode 100644 index 0000000000000000000000000000000000000000..e21f6e13ba8fc5a905eacaa9ab505088ac13e1f0 --- /dev/null +++ b/run_scripts/pretraining/scaling/unival_s1.sh @@ -0,0 +1,175 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_s1 + +save_dir=${base_log_dir}/ofa/checkpoints/pretrain/${exp_name} + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +restore_file=${base_log_dir}/ofa/pretrained_models/bart.base/model.pt + + + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/pretrain_ours + +mkdir -p $save_dir + + +neg_sample_dir=${data_dir}/negative_sample +data=${data_dir}/vision_language_caption.tsv #vision_language_mini.tsv +text_data= #${data_dir}/text_mini.tsv +image_data= #${data_dir}/image_mini.tsv +detection_data= #${data_dir}/detection_mini.tsv + +image_text_data=${data_dir}/cc12m.tsv +image_text_cnt=8 + +image_text_vqa_data=${data_dir}/vision_language_qa.tsv +image_text_vqa_cnt=1 + +image_text_ground_data=${data_dir}/vision_language_ground.tsv +image_text_ground_cnt=1 + + +selected_cols=0,1,2,3,4,5,6,7 +text_selected_cols=0,1 +image_selected_cols=0,1,2 +detection_selected_cols=0,1,2 + + +task=unify_task +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=2e-4 +lr_scheduler=polynomial_decay +max_epoch=50 +warmup_ratio=0.01 +batch_size=2 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=30 +num_bins=1000 + +max_image_size=512 + + + +save_interval_updates=0 + +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=384 +resnet_type=resnet101 +sample_patch_num=144 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + + +python3 -m torch.distributed.launch \ +--nnodes=${NUM_NODES} \ +--nproc_per_node=${GPUS_PER_NODE} \ +--master_port=${MASTER_PORT} \ +--node_rank=${RANK} \ +--master_addr=${MASTER_ADDR} \ +--use_env ${ofa_dir}/train.py \ + $data \ + --ddp-backend=no_c10d \ + --selected-cols=${selected_cols} \ + --text-selected-cols=${text_selected_cols} \ + --image-selected-cols=${image_selected_cols} \ + --detection-selected-cols=${detection_selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --save-dir=${save_dir} \ + --neg-sample-dir=${neg_sample_dir} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=5.0 \ + --lr-scheduler=${lr_scheduler} --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-last-epochs=15 \ + --save-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --disable-validation \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --sample-patch-num=${sample_patch_num} \ + --max-image-size=${max_image_size} \ + --fp16 \ + --fp16-scale-window=128 \ + --num-workers=${num_workers} \ + --read-from-img-path \ + --image-dir=${image_dir} \ + --restore-file=${restore_file} \ + --image-encoder-name=${image_encoder_name} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --image-text-data=${image_text_data} \ + --image-text-cnt=${image_text_cnt} \ + --image-text-vqa-data=${image_text_vqa_data} \ + --image-text-vqa-cnt=${image_text_vqa_cnt} \ + --image-text-ground-data=${image_text_ground_data} \ + --image-text-ground-cnt=${image_text_ground_cnt} + diff --git a/run_scripts/pretraining/scaling/unival_s2.sh b/run_scripts/pretraining/scaling/unival_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..7839a433d37b5ee8be1b1f9bf5ff919dee2efce0 --- /dev/null +++ b/run_scripts/pretraining/scaling/unival_s2.sh @@ -0,0 +1,182 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival + +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data + +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + +exp_name=unival_s2 + +save_dir=${base_log_dir}/ofa/checkpoints/pretrain/${exp_name} + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/${exp_name}/checkpoint_last.pt + + +lr=1e-4 + + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/pretrain_ours + +mkdir -p $save_dir + + +neg_sample_dir=${data_dir}/negative_sample +data=${data_dir}/vision_language_mini_vqa_ground.tsv #vision_language_mini_webvid2m.tsv +text_data= #${data_dir}/text_mini.tsv +image_data= #${data_dir}/image_mini.tsv +detection_data= #${data_dir}/detection_mini.tsv +video_data=${data_dir}/video_mini_webvid2mccapqa.tsv #${data_dir}/video_mini_webvid2m.tsv #video data +video_cnt=1 + + + +selected_cols=0,1,2,3,4,5,6,7 +text_selected_cols=0,1 +image_selected_cols=0,1,2 +detection_selected_cols=0,1,2 +video_selected_cols=0,1,2,3,4,5,6,7 + +task=unify_task +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 + +max_epoch=50 +warmup_ratio=0.01 +batch_size=4 # will be multiplied by 2 for one .tsv, e.g. with video_data= 16 x2 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=30 +num_bins=1000 +orig_patch_image_size=224 +max_image_size=512 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=384 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=224 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +sample_patch_num=144 + +save_interval_updates=0 + + + +python3 -m torch.distributed.launch \ +--nnodes=${NUM_NODES} \ +--nproc_per_node=${GPUS_PER_NODE} \ +--master_port=${MASTER_PORT} \ +--node_rank=${RANK} \ +--master_addr=${MASTER_ADDR} \ +--use_env ${ofa_dir}/train.py \ + $data \ + --ddp-backend=no_c10d \ + --selected-cols=${selected_cols} \ + --text-selected-cols=${text_selected_cols} \ + --image-selected-cols=${image_selected_cols} \ + --detection-selected-cols=${detection_selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --save-dir=${save_dir} \ + --neg-sample-dir=${neg_sample_dir} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=5.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-last-epochs=15 \ + --save-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --disable-validation \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --sample-patch-num=${sample_patch_num} \ + --max-image-size=${max_image_size} \ + --fp16 \ + --fp16-scale-window=128 \ + --num-workers=${num_workers} \ + --read-from-img-path \ + --image-dir=${image_dir} \ + --restore-file=${restore_file} \ + --image-encoder-name=${image_encoder_name} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --save-on-cuda \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --video-selected-cols=${video_selected_cols} \ + --video-data=${video_data} \ + --video-cnt=${video_cnt} diff --git a/run_scripts/pretraining/scaling/unival_s2_hs.sh b/run_scripts/pretraining/scaling/unival_s2_hs.sh new file mode 100644 index 0000000000000000000000000000000000000000..4a6f48bfc273c49e894c760bf83978812ee5da4a --- /dev/null +++ b/run_scripts/pretraining/scaling/unival_s2_hs.sh @@ -0,0 +1,182 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival + +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data + +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + +exp_name=unival_s2_hs + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/pretrain/${exp_name} + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata/checkpoint8.pt + +lr=5e-5 + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/pretrain_ours + +mkdir -p $save_dir + + +neg_sample_dir=${data_dir}/negative_sample +data=${data_dir}/vision_language_mini_vqa_ground.tsv #vision_language_mini_webvid2m.tsv +text_data= #${data_dir}/text_mini.tsv +image_data= #${data_dir}/image_mini.tsv +detection_data= #${data_dir}/detection_mini.tsv +video_data=${data_dir}/video_mini_webvid2mccapqa.tsv #${data_dir}/video_mini_webvid2m.tsv #video data +video_cnt=1 + + +selected_cols=0,1,2,3,4,5,6,7 +text_selected_cols=0,1 +image_selected_cols=0,1,2 +detection_selected_cols=0,1,2 +video_selected_cols=0,1,2,3,4,5,6,7 + +task=unify_task +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 + +max_epoch=50 +warmup_ratio=0.01 +batch_size=4 # will be multiplied by 2 for one .tsv, e.g. with video_data= 16 x2 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=30 +num_bins=1000 +orig_patch_image_size=224 +max_image_size=512 + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101_a1h-36d3f2aa.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=16 + +sample_patch_num=225 + +save_interval_updates=0 + + + +python3 -m torch.distributed.launch \ +--nnodes=${NUM_NODES} \ +--nproc_per_node=${GPUS_PER_NODE} \ +--master_port=${MASTER_PORT} \ +--node_rank=${RANK} \ +--master_addr=${MASTER_ADDR} \ +--use_env ${ofa_dir}/train.py \ + $data \ + --ddp-backend=no_c10d \ + --selected-cols=${selected_cols} \ + --text-selected-cols=${text_selected_cols} \ + --image-selected-cols=${image_selected_cols} \ + --detection-selected-cols=${detection_selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --save-dir=${save_dir} \ + --neg-sample-dir=${neg_sample_dir} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=5.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-last-epochs=15 \ + --save-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --disable-validation \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --sample-patch-num=${sample_patch_num} \ + --max-image-size=${max_image_size} \ + --fp16 \ + --fp16-scale-window=128 \ + --num-workers=${num_workers} \ + --read-from-img-path \ + --image-dir=${image_dir} \ + --restore-file=${restore_file} \ + --image-encoder-name=${image_encoder_name} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --save-on-cuda \ + --num-frames=${num_frames} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --video-selected-cols=${video_selected_cols} \ + --video-data=${video_data} \ + --video-cnt=${video_cnt} \ + --reset-dataloader --reset-meters --reset-optimizer diff --git a/run_scripts/refcoco/eval/eval_refcoco.sh b/run_scripts/refcoco/eval/eval_refcoco.sh new file mode 100644 index 0000000000000000000000000000000000000000..32e0d7efef644e1b438c2132806413eca29d9c3e --- /dev/null +++ b/run_scripts/refcoco/eval/eval_refcoco.sh @@ -0,0 +1,170 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + + +selected_cols=0,4,2,3 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +exp_name=unival_refcoco +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcoco/unival_refcoco/checkpoint_best.pt + + + + + +acc_thresh='0.4,0.5,0.6,0.7,0.8,0.9' +metric=map +min_area_size=100000 # max 1000000 +max_area_size=30000 + +echo ${path} +result_path=${new_base_log_dir}/ofa/results/refcoco/${exp_name} +# result_path=${base_log_dir}/ofa/results/refcoco/${exp_name} +mkdir ${result_path} + + + + +data=${base_data_dir}/ofa/refcoco_data/refcoco_val.tsv +split='refcoco_val' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} + +data=${base_data_dir}/ofa/refcoco_data/refcoco_testA.tsv +split='refcoco_testA' +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} + + +data=${base_data_dir}/ofa/refcoco_data/refcoco_testB.tsv +split='refcoco_testB' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} diff --git a/run_scripts/refcoco/eval/eval_refcocog.sh b/run_scripts/refcoco/eval/eval_refcocog.sh new file mode 100644 index 0000000000000000000000000000000000000000..1051d7c94df26148778fef8a06452502d3727a89 --- /dev/null +++ b/run_scripts/refcoco/eval/eval_refcocog.sh @@ -0,0 +1,139 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + + +selected_cols=0,4,2,3 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + +exp_name=unival_refcocog +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/refcocog/unival_refcocog/checkpoint_best.pt + + + +acc_thresh='0.4,0.5,0.6,0.7,0.8,0.9' +metric=map +min_area_size=100000 # max 1000000 +max_area_size=30000 + +echo ${path} +result_path=${new_base_log_dir}/ofa/results/refcoco/${exp_name} +# result_path=${base_log_dir}/ofa/results/refcoco/${exp_name} +mkdir ${result_path} + + + + +data=${base_data_dir}/ofa/refcocog_data/refcocog_val.tsv +split='refcocog_val' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} + + + + +data=${base_data_dir}/ofa/refcocog_data/refcocog_test.tsv +split='refcocog_test' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} diff --git a/run_scripts/refcoco/eval/eval_refcocoplus.sh b/run_scripts/refcoco/eval/eval_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..64e6ed6773197de48e549b3245ee18f18f99e9b5 --- /dev/null +++ b/run_scripts/refcoco/eval/eval_refcocoplus.sh @@ -0,0 +1,191 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + + +selected_cols=0,4,2,3 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + + +zero_shot='' +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + +patch_image_size=512 +# sample_patch_num='--sample-patch-num=784' # '' +sample_patch_num='' + +# exp_name=avg_rata_l0_7refcapsnlivqa +# new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_rata_l0_7refcapsnlivqa.pt + + +model_name=avg_postratafuse +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafuse.pt +zero_shot='--zero-shot' + + + + + +acc_thresh='0.4,0.5,0.6,0.7,0.8,0.9' +metric=map +min_area_size=100000 # max 1000000 +max_area_size=30000 + +echo ${path} +result_path=${new_base_log_dir}/ofa/results/refcocoplus/${exp_name} +mkdir ${result_path} + + + + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_val.tsv +split='refcocoplus_val' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + ${zero_shot} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} \ + --patch-image-size=${patch_image_size} \ + ${sample_patch_num} + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_testA.tsv +split='refcocoplus_testA' +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + ${zero_shot} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} \ + --patch-image-size=${patch_image_size} \ + ${sample_patch_num} + + +data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_testB.tsv +split='refcocoplus_testB' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + ${zero_shot} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} \ + --patch-image-size=${patch_image_size} \ + ${sample_patch_num} diff --git a/run_scripts/refcoco/eval/eval_refcocoplus_avg.sh b/run_scripts/refcoco/eval/eval_refcocoplus_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..02863b797a1763ad09f44475f43125806c8b2f8a --- /dev/null +++ b/run_scripts/refcoco/eval/eval_refcocoplus_avg.sh @@ -0,0 +1,107 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + + +selected_cols=0,4,2,3 + + +image_encoder_name=resnet #vit_base_patch16_224 + + + + + + +acc_thresh='0.4,0.5,0.6,0.7,0.8,0.9' +metric=map +min_area_size=100000 # max 1000000 +max_area_size=30000 + + + + + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + + new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + exp_name=eval_refcocoplus_base_best_avg_postfuse_refvqa${l} + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_refvqa_l${l}.pt + + echo ${path} + result_path=${new_base_log_dir}/ofa/results/refcocoplus/${exp_name} + mkdir ${result_path} + + data=${base_data_dir}/ofa/refcocoplus_data/refcocoplus_val.tsv + split='refcocoplus_val' + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=refcoco \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --beam=5 \ + --min-len=4 \ + --max-len-a=0 \ + --max-len-b=4 \ + --no-repeat-ngram-size=3 \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} + +done \ No newline at end of file diff --git a/run_scripts/refcoco/scaling_best/unival_refcoco.sh b/run_scripts/refcoco/scaling_best/unival_refcoco.sh new file mode 100644 index 0000000000000000000000000000000000000000..311b976510e898b8a902c703bf817d722d89813f --- /dev/null +++ b/run_scripts/refcoco/scaling_best/unival_refcoco.sh @@ -0,0 +1,160 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_refcoco + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocop/${exp_name} + + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcoco_data +data=${data_dir}/refcoco_train_1.tsv,${data_dir}/refcoco_train_2.tsv,${data_dir}/refcoco_train_3.tsv,${data_dir}/refcoco_train_4.tsv,${data_dir}/refcoco_train_5.tsv,${data_dir}/refcoco_train_6.tsv,${data_dir}/refcoco_train_7.tsv,${data_dir}/refcoco_train_8.tsv,${data_dir}/refcoco_train_9.tsv,${data_dir}/refcoco_train_10.tsv,${data_dir}/refcoco_val.tsv + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/refcoco/scaling_best/unival_refcocog.sh b/run_scripts/refcoco/scaling_best/unival_refcocog.sh new file mode 100644 index 0000000000000000000000000000000000000000..5ac1a2d1ce50904ea71ae63751f496f41c2133a9 --- /dev/null +++ b/run_scripts/refcoco/scaling_best/unival_refcocog.sh @@ -0,0 +1,160 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + + +exp_name=unival_refcocog + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocog/${exp_name} + + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocog_data +data=${data_dir}/refcocog_train_1.tsv,${data_dir}/refcocog_train_2.tsv,${data_dir}/refcocog_train_3.tsv,${data_dir}/refcocog_train_4.tsv,${data_dir}/refcocog_train_5.tsv,${data_dir}/refcocog_train_6.tsv,${data_dir}/refcocog_train_7.tsv,${data_dir}/refcocog_train_8.tsv,${data_dir}/refcocog_train_9.tsv,${data_dir}/refcocog_train_10.tsv,${data_dir}/refcocog_val.tsv + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/refcoco/scaling_best/unival_refcocoplus.sh b/run_scripts/refcoco/scaling_best/unival_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..c96f0a3632528c9a2fee32b0be14af4a69e2dabb --- /dev/null +++ b/run_scripts/refcoco/scaling_best/unival_refcocoplus.sh @@ -0,0 +1,160 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} + + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train_1.tsv,${data_dir}/refcocoplus_train_2.tsv,${data_dir}/refcocoplus_train_3.tsv,${data_dir}/refcocoplus_train_4.tsv,${data_dir}/refcocoplus_train_5.tsv,${data_dir}/refcocoplus_train_6.tsv,${data_dir}/refcocoplus_train_7.tsv,${data_dir}/refcocoplus_train_8.tsv,${data_dir}/refcocoplus_train_9.tsv,${data_dir}/refcocoplus_train_10.tsv,${data_dir}/refcocoplus_val.tsv + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + +acc_thresh=0.5 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --acc-thresh=${acc_thresh} \ + --image-encoder-name=${image_encoder_name} \ + --strict diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5large_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5large_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a0e21d928ae2930a349ef7f8a552c015be7dfc59 --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5large_lreinf5.sh @@ -0,0 +1,167 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5large_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc + +min_area_size=100000 # max 1000000 +lambda_reinforce=5.0 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --lambda-reinforce=${lambda_reinforce} diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5medium_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5medium_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a85a41a0ded90aae4e6c200261f37b6170b1c58f --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5medium_lreinf5.sh @@ -0,0 +1,172 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5medium_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc + +max_area_size=30000 +min_area_size=100000 # max 1000000 + +lambda_reinforce=5.0 +medium_area='--medium-area' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} \ + --lambda-reinforce=${lambda_reinforce} \ + ${medium_area} diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumlarge_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumlarge_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a101c6b75ba360111903bd6e6fde5dbfd0294ac4 --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumlarge_lreinf5.sh @@ -0,0 +1,170 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5mediumlarge_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc + +max_area_size=30000 + +lambda_reinforce=5.0 +medium_area='--medium-area' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --max-area-size=${max_area_size} \ + --lambda-reinforce=${lambda_reinforce} \ + ${medium_area} diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumsmall_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumsmall_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..101b78ed2928efe1aa82a1a2bac523dd4773d5bf --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5mediumsmall_lreinf5.sh @@ -0,0 +1,170 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5mediumsmall_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc + +min_area_size=100000 # max 1000000 + +lambda_reinforce=5.0 +medium_area='--medium-area' + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --lambda-reinforce=${lambda_reinforce} \ + ${medium_area} diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5small_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5small_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..75cf25c3fccaed2c559674984fc4b23de16c868e --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5small_lreinf5.sh @@ -0,0 +1,168 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5small_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc +max_area_size=30000 + +lambda_reinforce=5.0 + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --max-area-size=${max_area_size} \ + --lambda-reinforce=${lambda_reinforce} diff --git a/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5smalllarge_lreinf5.sh b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5smalllarge_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..761f6dc3cb41163b1c5e4805d5c4a9488056345b --- /dev/null +++ b/run_scripts/refcoco/scst/unival_refcocoplus_acc0_5smalllarge_lreinf5.sh @@ -0,0 +1,170 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_refcocoplus_acc0_5smalllarge_lreinf5 + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +save_dir=${base_log_dir}/ofa/checkpoints/refcocoplus/${exp_name} +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + +data_dir=${base_data_dir}/ofa/refcocoplus_data +data=${data_dir}/refcocoplus_train.tsv,${data_dir}/refcocoplus_val.tsv + + +restore_file=${base_log_dir}/ofa/checkpoints/refcocoplus/unival_refcocoplus/10_3e-5_512/checkpoint_best.pt + +selected_cols=0,4,2,3 + +task=refcoco +arch=unival_base +pretrained_model= + +criterion=refcoco_scst_reward_criterion +# label_smoothing=0.1 +lr=3e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=512 + + +image_encoder_name=timm_resnet #vit_base_patch16_224 +resnet_type=resnet101 + +save_interval=1 +validate_interval_updates=2000 +save_interval_updates=0 + +sample_patch_num='--sample-patch-num=784' # '' + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} +echo "patch_image_size "${patch_image_size} + +log_file=${log_dir}/${max_epoch}"_"${lr}"_"${patch_image_size}".log" +save_path=${save_dir}/${max_epoch}"_"${lr}"_"${patch_image_size} +mkdir -p $save_path + + + +acc_thresh=0.5 +metric=acc + +max_area_size=30000 +min_area_size=100000 # max 1000000 + +lambda_reinforce=5.0 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --no-epoch-checkpoints --keep-best-checkpoints=1 \ + --save-interval=${save_interval} --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --eval-acc \ + --eval-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --best-checkpoint-metric=score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --scst \ + --scst-args='{"beam":5,"min_len":4,"max_len_a":0,"max_len_b":4}' \ + --acc-thresh=${acc_thresh} \ + --metric=${metric} \ + --min-area-size=${min_area_size} \ + --max-area-size=${max_area_size} \ + --lambda-reinforce=${lambda_reinforce} diff --git a/run_scripts/snli_ve/eval/eval_snli_ve_base_best.sh b/run_scripts/snli_ve/eval/eval_snli_ve_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..c622ca3c6d921d06409984f2430f7687409c2dd5 --- /dev/null +++ b/run_scripts/snli_ve/eval/eval_snli_ve_base_best.sh @@ -0,0 +1,158 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_snli_ve_base_best + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/snli_ve_data + +# test or dev +split=dev +read_from_img_path='' #'--read-from-img-path' # '' + +data=${data_dir}/snli_ve_${split}.tsv + +zero_shot='' + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +# model_name=avg_rata_l0_7snlirefcapvqa +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_rata_l0_7snlirefcapvqa.pt + + + +model_name=avg_postratafuse +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafuse.pt +zero_shot='--zero-shot' + + + +result_path=${new_base_log_dir}/ofa/results/snli_ve/snli_ve_${split}_${model_name} + +mkdir ${result_path} + + +selected_cols=0,2,3,4,5 +valid_batch_size=20 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=snli_ve \ + --batch-size=8 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" --image-dir=${image_dir} \ + ${read_from_img_path} \ + ${zero_shot} \ + --prompt-type='prev_output' \ + --strict \ + --noconstraints \ + --patch-image-size=480 \ + +# --ema-eval \ + + + + + +# test or dev +split=test +read_from_img_path='' #'--read-from-img-path' # '' + +data=${data_dir}/snli_ve_${split}.tsv + + + +result_path=${base_log_dir}/ofa/results/snli_ve/snli_ve_${split}_${model_name} +mkdir ${result_path} + + +selected_cols=0,2,3,4,5 +valid_batch_size=20 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=snli_ve \ + --batch-size=8 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" --image-dir=${image_dir} \ + ${read_from_img_path} \ + ${zero_shot} \ + --prompt-type='prev_output' \ + --strict \ + --noconstraints + +# --ema-eval \ \ No newline at end of file diff --git a/run_scripts/snli_ve/eval/eval_snli_ve_base_best_avg.sh b/run_scripts/snli_ve/eval/eval_snli_ve_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..52b1432956f29bb7b7bb1632a230c2bcf7b6f4be --- /dev/null +++ b/run_scripts/snli_ve/eval/eval_snli_ve_base_best_avg.sh @@ -0,0 +1,158 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_snli_ve_base_best + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/snli_ve_data + +# test or dev +split=dev +read_from_img_path='' #'--read-from-img-path' # '' + +data=${data_dir}/snli_ve_${split}.tsv + + + + + +model_name=avg_rata_snlirefcapvqa +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_rata_snlirefcapvqa.pt + + + + +result_path=${base_log_dir}/ofa/results/snli_ve/snli_ve_${split}_${model_name} +mkdir ${result_path} + + +selected_cols=0,2,3,4,5 +valid_batch_size=20 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=snli_ve \ + --batch-size=8 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict + +# --ema-eval \ + + + + + +# test or dev +split=test +read_from_img_path='' #'--read-from-img-path' # '' + +data=${data_dir}/snli_ve_${split}.tsv + + + +result_path=${base_log_dir}/ofa/results/snli_ve/snli_ve_${split}_${model_name} +mkdir ${result_path} + + +selected_cols=0,2,3,4,5 +valid_batch_size=20 + + +image_dir=${base_data_dir} + + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + + new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + exp_name=eval_snli_ve_base_best_avg_postfuse_snliref${l} + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_snliref_l${l}.pt + + + echo ${path} + result_path=${new_base_log_dir}/ofa/results/snli_ve/${exp_name} + mkdir ${result_path} + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=snli_ve \ + --batch-size=8 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}" --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict +done + +# --ema-eval \ \ No newline at end of file diff --git a/run_scripts/snli_ve/scaling_best/unival_snli_ve.sh b/run_scripts/snli_ve/scaling_best/unival_snli_ve.sh new file mode 100644 index 0000000000000000000000000000000000000000..9f2008ca448cc6b93a3730ca9fc46fcc7508cb3f --- /dev/null +++ b/run_scripts/snli_ve/scaling_best/unival_snli_ve.sh @@ -0,0 +1,183 @@ +#!/usr/bin/env + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + + +exp_name=unival_snli_ve + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/snli_ve/${exp_name} + +log_dir=${save_dir} + + +mkdir -p $log_dir $save_dir + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + +image_dir=${base_data_dir} + + + + +data_dir=${base_data_dir}/ofa/snli_ve_data +data=${data_dir}/snli_ve_train.tsv,${data_dir}/snli_ve_dev.tsv + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + +selected_cols=0,2,3,4,5 + +task=snli_ve +arch=unival_base +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.0 +lr=5e-5 +max_epoch=10 +warmup_ratio=0.06 +batch_size=8 +update_freq=4 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_tgt_length=20 +num_bins=1000 +patch_image_size=480 +prompt_type="prev_output" + + + +echo "max_epoch "${max_epoch} +echo "lr "${lr} + +log_file=${log_dir}/${max_epoch}"_"${lr}".log" +save_path=${save_dir}/${max_epoch}"_"${lr} +mkdir -p $save_path + + + + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 timm_resnet resnet +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + +save_interval=1 +validate_interval_updates=50000 +save_interval_updates=0 + + +sample_patch_num='--sample-patch-num=784' # '' + + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + $data \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --reset-optimizer --reset-dataloader --reset-meters \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay --lr=${lr} \ + --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \ + --log-format=simple --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=snli_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=${prompt_type} \ + --fp16 \ + --fp16-scale-window=512 \ + --num-workers=0 \ + --image-dir=${image_dir} \ + ${sample_patch_num} \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict \ + --resnet-model-path=${resnet_model_path} + diff --git a/run_scripts/vqa/eval/eval_okvqa_base_best.sh b/run_scripts/vqa/eval/eval_okvqa_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..006c9fa97d6bf67d88bdd46dc5677665d418f082 --- /dev/null +++ b/run_scripts/vqa/eval/eval_okvqa_base_best.sh @@ -0,0 +1,125 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_okvqa_base_best + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/vqa_data + +# val or train +split=val +read_from_img_path='--read-from-img-path' #'--read-from-img-path' # '' + +data=${data_dir}/okvqa_acc_${split}.tsv + +ans2label_file=${base_data_dir}/ofa/vqa_data/okvqa_trainval_ans2label.pkl + +zero_shot='' +eval_ema='--ema-eval' + + +# model_name=avg_rata_l0_7vqarefsnlicap +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_rata_l0_7vqarefsnlicap.pt + + + +model_name=ofa_base +path=/lus/work/NAT/gda2204/mshukor/logs/ofa/pretrained_models/ofa_base.pt +zero_shot='--zero-shot' +eval_ema='' + + +model_name=avg_postratafusevanilla +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafusevanilla.pt +zero_shot='--zero-shot' +eval_ema='' + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +result_path=${new_base_log_dir}/ofa/results/vqa/okvqa_${split}_beam_${model_name} + + +mkdir ${result_path} + + +selected_cols=0,5,2,3,4 +valid_batch_size=8 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=vqa_gen \ + --batch-size=32 \ + --valid-batch-size=${valid_batch_size} \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + ${eval_ema} \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict \ + ${zero_shot} \ + --patch-image-size=480 \ + --prompt-type='none' + # --noconstraints + +# --ema-eval \ diff --git a/run_scripts/vqa/eval/eval_vizwiz_base_best.sh b/run_scripts/vqa/eval/eval_vizwiz_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..1d15de958b678a87b9eb128fee77c3aeda2c311c --- /dev/null +++ b/run_scripts/vqa/eval/eval_vizwiz_base_best.sh @@ -0,0 +1,119 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_vizwiz_base_best + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/vqa_data + +# val or train +split=val +read_from_img_path='--read-from-img-path' #'--read-from-img-path' # '' + +data=${data_dir}/vizwiz_acc_${split}.tsv + +ans2label_file=${base_data_dir}/ofa/vqa_data/vizwiz_trainval_ans2label.pkl + +zero_shot='' +eval_ema='--ema-eval' +# model_name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf +# path=${base_log_dir}/ofa/checkpoints/vqa/${model_name}/20_0.04_1e-4_480/checkpoint_best.pt + + + + +model_name=avg_postratafuse +path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postratafuse.pt +zero_shot='--zero-shot' +eval_ema='' + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +result_path=${new_base_log_dir}/ofa/results/vqa/vizwiz_${split}_beam_${model_name} + + +mkdir ${result_path} + + +selected_cols=0,5,2,3,4 +valid_batch_size=8 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=vqa_gen \ + --batch-size=32 \ + --valid-batch-size=${valid_batch_size} \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + ${eval_ema} \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict \ + ${zero_shot} \ + --patch-image-size=480 \ + --prompt-type='none' + # --noconstraints + +# --ema-eval \ diff --git a/run_scripts/vqa/eval/eval_vqa_base_best.sh b/run_scripts/vqa/eval/eval_vqa_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..692447c2bb4f6ee6f393d6a862d89c72af3cb600 --- /dev/null +++ b/run_scripts/vqa/eval/eval_vqa_base_best.sh @@ -0,0 +1,123 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +exp_name=eval_vqa_base_best + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/vqa_data + +# val or test or fullval +split=test +read_from_img_path='' #'--read-from-img-path' # '' +# split=val +# read_from_img_path='' #'--read-from-img-path' # '' + +# split=fullval +# read_from_img_path='--read-from-img-path' + +data=${data_dir}/vqa_${split}.tsv + +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + +zero_shot='' +eval_ema='--ema-eval' + +# model_name=avg_rata_l0_7vqarefsnlicap +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_rata_l0_7vqarefsnlicap.pt + +model_name=unival_s2_hs +path=/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt +zero_shot='--zero-shot' +eval_ema='' + + + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +result_path=${new_base_log_dir}/ofa/results/vqa/vqa_${split}_beam_${model_name} + + + + +mkdir ${result_path} + + +selected_cols=0,5,2,3,4 +valid_batch_size=8 + + +image_dir=${base_data_dir} + + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=vqa_gen \ + --batch-size=32 \ + --valid-batch-size=${valid_batch_size} \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + ${eval_ema} \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + ${read_from_img_path} \ + --strict \ + ${zero_shot} \ + --patch-image-size=480 \ + --prompt-type='prev_output' + # --prompt-type='none' + # --noconstraints diff --git a/run_scripts/vqa/eval/eval_vqa_base_best_avg.sh b/run_scripts/vqa/eval/eval_vqa_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..6d256b0c3e34c5b3dec79137dcf7674b687a2e8d --- /dev/null +++ b/run_scripts/vqa/eval/eval_vqa_base_best_avg.sh @@ -0,0 +1,108 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/vqa_data + +# val or test or fullval +split=fullval +read_from_img_path=True +image_dir=${base_data_dir} + +data=${data_dir}/vqa_${split}.tsv + +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + + +selected_cols=0,5,2,3,4 +valid_batch_size=40 + + + + + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + + + new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + exp_name=eval_vqa_base_best_avg_postfuse_vqacap${l} + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_vqacap_l${l}.pt + + echo ${path} + result_path=${new_base_log_dir}/ofa/results/vqa/${exp_name}_${split} + mkdir ${result_path} + + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=vqa_gen \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + --read-from-img-path + # --ema-eval \ +done + + + \ No newline at end of file diff --git a/run_scripts/vqa/eval/video/eval_video_qa.sh b/run_scripts/vqa/eval/video/eval_video_qa.sh new file mode 100644 index 0000000000000000000000000000000000000000..d6097b1d4c9548e11068e95801aabcc67342c70a --- /dev/null +++ b/run_scripts/vqa/eval/video/eval_video_qa.sh @@ -0,0 +1,120 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# val or test or fullval +split=test +read_from_img_path=True +image_dir=${base_data_dir} + +data=${data_dir}/msrvtt_qa_4k_test.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + + +selected_cols=0,5,2,3,4 +valid_batch_size=40 + +eval_ema='--ema-eval' +zero_shot='' +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + + +# model_name=unival_s2_hs +# path=/work/NAT/gda2204/mshukor/logs/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt +# zero_shot='--zero-shot' +# eval_ema='' + + +# model_name=avg_postfuse_vidvqacap +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/pretrained_models/average_models/avg_postfuse_vidvqacap.pt +# eval_ema='' + + +echo ${path} +result_path=${new_base_log_dir}/ofa/results/vqa/${exp_name}_${split} +mkdir ${result_path} + +num_frames=8 +patch_frame_size=384 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=video_vqa_gen \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --temperature=1.0 \ + --unnormalized \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + --read-from-img-path \ + ${zero_shot} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${eval_ema} \ + --prompt-type='prev_output' + # --prompt-type='none' \ + + + # --ema-eval \ + + diff --git a/run_scripts/vqa/eval/video/eval_video_qa_avg.sh b/run_scripts/vqa/eval/video/eval_video_qa_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..eb48d7f5899cc41fcc4388510379a7a064fac49e --- /dev/null +++ b/run_scripts/vqa/eval/video/eval_video_qa_avg.sh @@ -0,0 +1,115 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# val or test or fullval +split=test +read_from_img_path=True +image_dir=${base_data_dir} + +data=${data_dir}/msrvtt_qa_4k_test.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + +selected_cols=0,5,2,3,4 +valid_batch_size=40 + +eval_ema='--ema-eval' + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + +zero_shot='' + +for l in {0.00,0.20,0.40,0.60,0.80,1.00};do + + exp_name=eval_video_vqa_base_best_avg_vid_vqacap${l} + path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_vid_vqacap_l${l}.pt + eval_ema='' + + + # exp_name=eval_video_vqa_avg_postfuse_vidvqacap${l} + # path=${new_base_log_dir}/ofa/pretrained_models/average_models/avg_postfuse_vidvqacap_l${l}.pt + # eval_ema='' + # # zero_shot='--zero-shot' + + echo ${path} + result_path=${new_base_log_dir}/ofa/results/vqa/${exp_name}_${split} + mkdir ${result_path} + + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=video_vqa_gen \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --unnormalized \ + --temperature=1.0 \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + --read-from-img-path \ + ${eval_ema} \ + ${zero_shot} \ + --prompt-type='prev_output' + # --prompt-type='none' +done + + + \ No newline at end of file diff --git a/run_scripts/vqa/eval/video/eval_video_qa_msvd.sh b/run_scripts/vqa/eval/video/eval_video_qa_msvd.sh new file mode 100644 index 0000000000000000000000000000000000000000..786cb6a46027c9690504b75b65ea8a819b63269a --- /dev/null +++ b/run_scripts/vqa/eval/video/eval_video_qa_msvd.sh @@ -0,0 +1,119 @@ +#!/usr/bin/env bash + +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# The port for communication. Note that if you want to run multiple tasks on the same machine, +# you need to specify different port numbers. +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + + + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# val or test or fullval +split=test +read_from_img_path=True +image_dir=${base_data_dir} + +data=${data_dir}/msvd_qa_1k_test.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msvd_trainval_1k_ans2label.pkl + + +selected_cols=0,5,2,3,4 +valid_batch_size=40 + +eval_ema='--ema-eval' +zero_shot='' +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs + + + + +# model_name=unival_s2_hs +# path=/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt +# eval_ema='' +# zero_shot='--zero-shot' + + +model_name=unival_video_vqa_msvd +path='/lus/scratch/NAT/gda2204/SHARED/logs/ofa/checkpoints/vqa/unival_video_vqa_msvd/checkpoint_best.pt' + + +echo ${path} +result_path=${new_base_log_dir}/ofa/results/vqa/eval_msvd_${exp_name}_${split} +mkdir ${result_path} + +num_frames=8 +patch_frame_size=384 + +python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/evaluate.py \ + ${data} \ + --path=${path} \ + --user-dir=${user_dir} \ + --task=video_vqa_gen \ + --batch-size=16 \ + --log-format=simple --log-interval=10 \ + --seed=7 \ + --gen-subset=${split} \ + --results-path=${result_path} \ + --fp16 \ + --beam-search-vqa-eval \ + --beam=5 \ + --temperature=1.0 \ + --unnormalized \ + --num-workers=0 \ + --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\",\"ans2label_file\":\"${ans2label_file}\",\"valid_batch_size\":\"${valid_batch_size}\"}" \ + --image-dir=${image_dir} \ + --read-from-img-path \ + ${zero_shot} \ + --prompt-type='none' \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${eval_ema} + + + # --ema-eval \ + + diff --git a/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s1_onlylinear.sh b/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..9fb20ee455ab31d9ff9e7c0b4f4daa240bb05745 --- /dev/null +++ b/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s1_onlylinear.sh @@ -0,0 +1,243 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_video_vqa_s1_onlylinear + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# data=${data_dir}/msrvtt_qa_train.tsv,${data_dir}/msrvtt_qa_val.tsv +data=${data_dir}/msrvtt_qa_4k_train_1.tsv,${data_dir}/msrvtt_qa_4k_train_2.tsv,${data_dir}/msrvtt_qa_4k_train_3.tsv,${data_dir}/msrvtt_qa_4k_train_4.tsv,${data_dir}/msrvtt_qa_4k_train_5.tsv,${data_dir}/msrvtt_qa_4k_train_6.tsv,${data_dir}/msrvtt_qa_4k_train_7.tsv,${data_dir}/msrvtt_qa_4k_train_8.tsv,${data_dir}/msrvtt_qa_4k_train_9.tsv,${data_dir}/msrvtt_qa_4k_train_10.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +# data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s1/checkpoint15.pt + + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +max_epoch=40 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s2_onlylinear.sh b/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..d387d4557fbf2d453c47bbf17d5d2384bde7f65f --- /dev/null +++ b/run_scripts/vqa/scaling_best/onlylinear/unival_video_vqa_s2_onlylinear.sh @@ -0,0 +1,243 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_video_vqa_s2_onlylinear + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# data=${data_dir}/msrvtt_qa_train.tsv,${data_dir}/msrvtt_qa_val.tsv +data=${data_dir}/msrvtt_qa_4k_train_1.tsv,${data_dir}/msrvtt_qa_4k_train_2.tsv,${data_dir}/msrvtt_qa_4k_train_3.tsv,${data_dir}/msrvtt_qa_4k_train_4.tsv,${data_dir}/msrvtt_qa_4k_train_5.tsv,${data_dir}/msrvtt_qa_4k_train_6.tsv,${data_dir}/msrvtt_qa_4k_train_7.tsv,${data_dir}/msrvtt_qa_4k_train_8.tsv,${data_dir}/msrvtt_qa_4k_train_9.tsv,${data_dir}/msrvtt_qa_4k_train_10.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +# data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint3.pt + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +max_epoch=40 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + +use_dataaug='--use-dataaug' + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + ${use_dataaug} \ + --reset-dataloader --reset-meters --reset-optimizer + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s1_onlylinear.sh b/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..ecee3c74f4a7b5fee97103def85e621168bcebe2 --- /dev/null +++ b/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s1_onlylinear.sh @@ -0,0 +1,227 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_vqa_ofaplus_s1_onlylinear + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +# data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + +save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s1/checkpoint15.pt +lr=5e-4 + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +max_epoch=25 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --reset-dataloader --reset-meters --reset-optimizer + + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s2_onlylinear.sh b/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..38b96e4347074f7f11ea24f3c9380f5c925a4115 --- /dev/null +++ b/run_scripts/vqa/scaling_best/onlylinear/unival_vqa_ofaplus_s2_onlylinear.sh @@ -0,0 +1,230 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + +exp_name=unival_vqa_ofaplus_s2_onlylinear + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +# data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +# save_dir=${base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint3.pt + +lr=5e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +max_epoch=25 +batch_size=16 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +for max_epoch in {$max_epoch,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --freeze-encoder \ + --freeze-decoder \ + --freeze-audio-encoder \ + --freeze-image-encoder \ + --freeze-video-encoder \ + --reset-dataloader --reset-meters --reset-optimizer + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/unival_vqa.sh b/run_scripts/vqa/scaling_best/unival_vqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..93374a9a5941fb1e5a6034f23f1ed04be4ca76d6 --- /dev/null +++ b/run_scripts/vqa/scaling_best/unival_vqa.sh @@ -0,0 +1,231 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_vqa + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/vqa_data +# data=${data_dir}/vqa_train.tsv,${data_dir}/vqa_val.tsv +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/vqa_train_1.tsv,${data_dir}/vqa_train_2.tsv,${data_dir}/vqa_train_3.tsv,${data_dir}/vqa_train_4.tsv,${data_dir}/vqa_train_5.tsv,${data_dir}/vqa_train_6.tsv,${data_dir}/vqa_train_7.tsv,${data_dir}/vqa_train_8.tsv,${data_dir}/vqa_train_9.tsv,${data_dir}/vqa_train_10.tsv,${data_dir}/vqa_val.tsv +ans2label_file=${base_data_dir}/ofa/vqa_data/trainval_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + +lr=1e-4 + + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_cross_entropy +label_smoothing=0.1 +batch_size=16 +update_freq=1 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + + + +save_interval_updates=0 + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=4 + + +sample_patch_num='--sample-patch-num=784' # '' + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + +validate_interval_updates=2000 +save_interval_updates=0 + + +for max_epoch in {20,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} --validate-interval-updates=${validate_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=20 \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + ${sample_patch_num} \ + ${eval_args} \ + --no-epoch-checkpoints \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --reset-dataloader --reset-meters --reset-optimizer + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/video/msvd/unival_video_vqa_msvd.sh b/run_scripts/vqa/scaling_best/video/msvd/unival_video_vqa_msvd.sh new file mode 100644 index 0000000000000000000000000000000000000000..0f4a4225cfb2bfd52a69ac8e41ae137d34fb72e0 --- /dev/null +++ b/run_scripts/vqa/scaling_best/video/msvd/unival_video_vqa_msvd.sh @@ -0,0 +1,240 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_video_vqa_msvd + + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +data=${data_dir}/msvd_qa_1k_train.tsv,${data_dir}/msvd_qa_1k_test.tsv +# data=${data_dir}/msvd_qa_3k_train.tsv,${data_dir}/msvd_qa_3k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/msvd_qa_1k_train_1.tsv,${data_dir}/msvd_qa_1k_train_2.tsv,${data_dir}/msvd_qa_1k_train_3.tsv,${data_dir}/msvd_qa_1k_train_4.tsv,${data_dir}/msvd_qa_1k_train_5.tsv,${data_dir}/msvd_qa_1k_train_6.tsv,${data_dir}/msvd_qa_1k_train_7.tsv,${data_dir}/msvd_qa_1k_train_8.tsv,${data_dir}/msvd_qa_1k_train_9.tsv,${data_dir}/msvd_qa_1k_train_10.tsv,${data_dir}/msvd_qa_1k_test.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msvd_trainval_1k_ans2label.pkl +# ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msvd_trainval_3k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + +new_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${new_base_log_dir}/ofa/checkpoints/vqa/${exp_name} + +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + +lr=1e-4 + + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 +# patch_image_size=480 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 + + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + + +for max_epoch in {40,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + --reset-dataloader --reset-meters --reset-optimizer \ + --strict + done + done + done +done diff --git a/run_scripts/vqa/scaling_best/video/unival_video_vqa.sh b/run_scripts/vqa/scaling_best/video/unival_video_vqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..c8a68d42e284bfe81c4bb19b757d1eff883435c8 --- /dev/null +++ b/run_scripts/vqa/scaling_best/video/unival_video_vqa.sh @@ -0,0 +1,236 @@ + +# Number of GPUs per GPU worker +export GPUS_PER_NODE=8 +# Number of GPU workers, for single-worker training, please set to 1 +export NUM_NODES=$SLURM_NNODES +# The ip address of the rank-0 worker, for single-worker training, please set to localhost +master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1) +export MASTER_ADDR=$master_addr + +# The port for communication +export MASTER_PORT=12350 +# The rank of this worker, should be in {0, ..., WORKER_CNT-1}, for single-worker training, please set to 0 +export RANK=$SLURM_NODEID + +echo "MASTER_ADDR: $MASTER_ADDR" +echo "RANK :$RANK" +echo "NUM_NODES :$NUM_NODES" +echo "GPUS_PER_NODE :$GPUS_PER_NODE" + +export MIOPEN_USER_DB_PATH=/lus/home/NAT/gda2204/mshukor/.config/miopen_${MASTER_ADDR}_${SLURM_PROCID}/ + +echo "MIOPEN_USER_DB_PATH :$MIOPEN_USER_DB_PATH" + +num_workers=0 + + +ofa_dir=/lus/home/NAT/gda2204/mshukor/code/unival +base_data_dir=/lus/scratch/NAT/gda2204/SHARED/data +base_log_dir=/work/NAT/gda2204/mshukor/logs + + +exp_name=unival_video_vqa + +image_dir=${base_data_dir} +data_dir=${base_data_dir}/ofa/video_data/vqa_data + +# data=${data_dir}/msrvtt_qa_train.tsv,${data_dir}/msrvtt_qa_val.tsv +data=${data_dir}/msrvtt_qa_4k_train.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + + +# Note: If you have shuffled the data in advance, please uncomment the line below. +data=${data_dir}/msrvtt_qa_4k_train_1.tsv,${data_dir}/msrvtt_qa_4k_train_2.tsv,${data_dir}/msrvtt_qa_4k_train_3.tsv,${data_dir}/msrvtt_qa_4k_train_4.tsv,${data_dir}/msrvtt_qa_4k_train_5.tsv,${data_dir}/msrvtt_qa_4k_train_6.tsv,${data_dir}/msrvtt_qa_4k_train_7.tsv,${data_dir}/msrvtt_qa_4k_train_8.tsv,${data_dir}/msrvtt_qa_4k_train_9.tsv,${data_dir}/msrvtt_qa_4k_train_10.tsv,${data_dir}/msrvtt_qa_4k_test.tsv + +ans2label_file=${base_data_dir}/ofa/video_data/vqa_data/msrvtt_trainval_4k_ans2label.pkl + + +selected_cols=0,5,2,3,4 + + +save_base_log_dir=/lus/scratch/NAT/gda2204/SHARED/logs +save_dir=${save_base_log_dir}/ofa/checkpoints/vqa/${exp_name} +log_dir=${save_dir} + +mkdir -p $log_dir $save_dir + +restore_file=${base_log_dir}/ofa/checkpoints/pretrain/unival_s2_hs/checkpoint1.pt + + +lr=1e-4 + +bpe_dir=${ofa_dir}/utils/BPE +user_dir=${ofa_dir}/ofa_module + + + +task=video_vqa_gen +arch=unival_base + + +criterion=adjust_label_smoothed_encouraging_loss +label_smoothing=0.1 +batch_size=8 +valid_batch_size=8 +update_freq=2 +resnet_drop_path_rate=0.0 +encoder_drop_path_rate=0.1 +decoder_drop_path_rate=0.1 +dropout=0.1 +attention_dropout=0.0 +max_src_length=80 +max_object_length=30 +max_tgt_length=30 +num_bins=1000 + +uses_ema="--uses-ema" +store_ema="--store-ema" +ema_fp32="--ema-fp32" +ema_decay=0.9999 +ema_start_update=0 + +# Specify the inference type in validation after each fine-tuning epoch +# As mentioned in the readme, you can choose from allcand or beamsearch evaluation, default to allcand +val_inference_type=beamsearch + +# Specify whether to activate unconstrained VQA finetuning, which does not use a pre-defined candidate answer set +# If --unconstrained-training is acitvated, --ans2label-file will **not be used even if it is specified** +# Meanwhile, --val-inference-type must be set to **beamsearch** +# By default, we follow the constrained finetuning as we mentioned in OFA paper, the candidate answer set shall be specified by --ans2label-file +# For more details about this option, please refer to issue #123 and PR #124 +unconstrained_training_flag="" +# unconstrained_training_flag="--unconstrained-training" + + + +### +image_encoder_name=timm_resnet #vit_base_patch16_224 +patch_image_size=480 +resnet_type=resnet101 + +resnet_model_path=${base_log_dir}/pretrained_models/resnet101-5d3b4d8f.pth + +# video +video_encoder_name=all_resnext101 +patch_frame_size=384 +video_model_path=${base_log_dir}/pretrained_models/3dcnn/resnext-101-kinetics.pth #${base_log_dir}/pretrained_models/TimeSformer_divST_8x32_224_K600.pyth +num_frames=8 + +eval_args='--eval-args={"beam":5,"unnormalized":true,"temperature":1.0,"stop_on_max_len":true}' + + +sample_patch_num='--sample-patch-num=784' # '' + +save_interval_updates=0 +validate_interval_updates=2000 + +drop_worst_ratio=0.05 # modified from 0.2 for el +log_end=0.75 # for el +drop_best_ratio=0.05 +drop_best_after=6000 +drop_worst_after=6000 + + +for max_epoch in {35,}; do + echo "max_epoch "${max_epoch} + for warmup_ratio in {0.04,}; do + echo "warmup_updates "${warmup_updates} + for lr in {$lr,}; do + echo "lr "${lr} + for patch_image_size in {$patch_image_size,}; do + echo "patch_image_size "${patch_image_size} + + log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size}"_rank"${RANK}".log" + save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_"${lr}"_"${patch_image_size} + mkdir -p $save_path + + python3 -m torch.distributed.launch \ + --nnodes=${NUM_NODES} \ + --nproc_per_node=${GPUS_PER_NODE} \ + --master_port=${MASTER_PORT} \ + --node_rank=${RANK} \ + --master_addr=${MASTER_ADDR} \ + --use_env ${ofa_dir}/train.py \ + ${data} \ + --selected-cols=${selected_cols} \ + --bpe-dir=${bpe_dir} \ + --user-dir=${user_dir} \ + --restore-file=${restore_file} \ + --save-dir=${save_path} \ + --task=${task} \ + --arch=${arch} \ + --criterion=${criterion} \ + --label-smoothing=${label_smoothing} \ + --batch-size=${batch_size} \ + --update-freq=${update_freq} \ + --encoder-normalize-before \ + --decoder-normalize-before \ + --share-decoder-input-output-embed \ + --share-all-embeddings \ + --layernorm-embedding \ + --patch-layernorm-embedding \ + --code-layernorm-embedding \ + --resnet-drop-path-rate=${resnet_drop_path_rate} \ + --encoder-drop-path-rate=${encoder_drop_path_rate} \ + --decoder-drop-path-rate=${decoder_drop_path_rate} \ + --dropout=${dropout} \ + --attention-dropout=${attention_dropout} \ + --weight-decay=0.01 \ + --optimizer=adam \ + --adam-betas="(0.9,0.999)" \ + --adam-eps=1e-08 \ + --clip-norm=1.0 \ + --lr-scheduler=polynomial_decay \ + --lr=${lr} \ + --max-epoch=${max_epoch} \ + --warmup-ratio=${warmup_ratio} \ + --log-format=simple \ + --log-interval=10 \ + --fixed-validation-seed=7 \ + --keep-best-checkpoints=1 \ + --no-epoch-checkpoints \ + --save-interval=1 --validate-interval=1 --validate-interval-updates=${validate_interval_updates} \ + --save-interval-updates=${save_interval_updates} \ + --best-checkpoint-metric=vqa_score --maximize-best-checkpoint-metric \ + --max-src-length=${max_src_length} \ + --max-object-length=${max_object_length} \ + --max-tgt-length=${max_tgt_length} \ + --find-unused-parameters \ + --freeze-encoder-embedding \ + --freeze-decoder-embedding \ + ${unconstrained_training_flag} \ + --ans2label-file=${ans2label_file} \ + --valid-batch-size=${valid_batch_size} \ + --add-type-embedding \ + --scale-attn \ + --scale-fc \ + --scale-heads \ + --disable-entangle \ + --num-bins=${num_bins} \ + --patch-image-size=${patch_image_size} \ + --prompt-type=prev_output \ + --fp16 \ + --fp16-scale-window=512 \ + ${uses_ema} \ + ${store_ema} \ + ${ema_fp32} \ + --ema-decay=${ema_decay} \ + --ema-start-update=${ema_start_update} \ + --val-inference-type=${val_inference_type} \ + --num-workers=0 \ + --image-encoder-name=${image_encoder_name} \ + --image-dir=${image_dir} \ + --video-encoder-name=${video_encoder_name} \ + --video-model-path=${video_model_path} \ + --patch-frame-size=${patch_frame_size} \ + --num-frames=${num_frames} \ + ${sample_patch_num} \ + ${eval_args} \ + --resnet-type=${resnet_type} \ + --resnet-model-path=${resnet_model_path} \ + --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \ + --drop-worst-ratio ${drop_worst_ratio} --drop-worst-after ${drop_worst_after} \ + --reset-dataloader --reset-meters --reset-optimizer + done + done + done +done diff --git a/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcap.sh b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcap.sh new file mode 100644 index 0000000000000000000000000000000000000000..97e8d6c05939dd5cf3d4faa293994e96703ed49e --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcap.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_caption_stage_1_pretrain_branchcap +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_caption_stage_1_pretrain_branchcap.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcap.sh + + diff --git a/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa.sh b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..1071e9965217b22e7a6a81865ef83c2ca43d25ae --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchcapgroundvqa.sh + + diff --git a/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchimvid.sh b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchimvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..19faad1eb174a9107286dd7587a344155885af17 --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchimvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_caption_stage_1_pretrain_branchimvid +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_caption_stage_1_pretrain_branchimvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_branchimvid.sh + + diff --git a/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore.sh b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore.sh new file mode 100644 index 0000000000000000000000000000000000000000..d06c0e0640deba9ae15bbe3862bcc602d0c0d5fe --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/ofa_mini_caption_stage_1_pretrain_qa_ground_10epmore.sh + + diff --git a/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid.sh b/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..dcbd1c71ce2491714722ad436ffd2090ec144680 --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchimvid.sh + + diff --git a/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchvid.sh b/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..733edb0766224c5940ed6844e9ee13ceb2110589 --- /dev/null +++ b/slurm_adastra/averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_pretrain_branchvid +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_pretrain_branchvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_pretrain_branchvid.sh + + diff --git a/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchcapgroundvqa.sh b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchcapgroundvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..7ef1726b505a52e8113cd3a33226f5af5d6f5bae --- /dev/null +++ b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchcapgroundvqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_branchcapgroundvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_branchcapgroundvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/refcoco/ofa_ratarefcocoplus_branchcapgroundvqa.sh + + diff --git a/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchground.sh b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchground.sh new file mode 100644 index 0000000000000000000000000000000000000000..50bd5ac66c190a4425f85f683960f879174613e1 --- /dev/null +++ b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_branchground.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_branchground +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_branchground.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/refcoco/ofa_ratarefcocoplus_branchground.sh + + diff --git a/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_pretrain_qa_ground_10epmore.sh b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_pretrain_qa_ground_10epmore.sh new file mode 100644 index 0000000000000000000000000000000000000000..ac5f6ff2108133e0517e81ecc5a5b713191786be --- /dev/null +++ b/slurm_adastra/averaging/branching/refcoco/ofa_ratarefcocoplus_pretrain_qa_ground_10epmore.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_pretrain_qa_ground_10epmore +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_pretrain_qa_ground_10epmore.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/refcoco/ofa_ratarefcocoplus_pretrain_qa_ground_10epmore.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchcapgroundvqa.sh b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchcapgroundvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..356345561435a968ccf3311f9099200f8d87f0c7 --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchcapgroundvqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_vqa_pretrain_branchcapgroundvqa +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_vqa_pretrain_branchcapgroundvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/ofa_mini_vqa_pretrain_branchcapgroundvqa.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchimvid.sh b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchimvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..dcd2c96c9442b3f816bb28658cadefb06c31dcc0 --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branchimvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_vqa_pretrain_branchimvid +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_vqa_pretrain_branchimvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/ofa_mini_vqa_pretrain_branchimvid.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branvqa.sh b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..2e4cff50c52bc5247933d877e578c4da4b568873 --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_branvqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_vqa_pretrain_branvqa +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_vqa_pretrain_branvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/ofa_mini_vqa_pretrain_branvqa.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_qa_ground_10epmore.sh b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_qa_ground_10epmore.sh new file mode 100644 index 0000000000000000000000000000000000000000..687d8126014eac913a3ed8a4e87b75bf0d24ebd8 --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/ofa_mini_vqa_pretrain_qa_ground_10epmore.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_vqa_pretrain_qa_ground_10epmore +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_vqa_pretrain_qa_ground_10epmore.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/ofa_mini_vqa_pretrain_qa_ground_10epmore.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchimvid.sh b/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchimvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..6108555fc8693dd826227964cc7c985f2f886f1b --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchimvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_pretrain_branchimvid +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_pretrain_branchimvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchimvid.sh + + diff --git a/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchvid.sh b/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchvid.sh new file mode 100644 index 0000000000000000000000000000000000000000..73430fcb9528b3ca242353113216257d909967c5 --- /dev/null +++ b/slurm_adastra/averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchvid.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_pretrain_branchvid +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_pretrain_branchvid.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/branching/vqa/video/ofa_mini_video_vqa_pretrain_branchvid.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_caption_stage_1_long1e5.sh b/slurm_adastra/averaging/caption/ofa_caption_stage_1_long1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..55048600a8431dbd76d23db8cf41fcb755a7d6a5 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_caption_stage_1_long1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_caption_stage_1_long1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_caption_stage_1_long1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_caption_stage_1_long1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup1same.sh b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup1same.sh new file mode 100644 index 0000000000000000000000000000000000000000..adfdca709d034fdf474e88dd5fa1deb271181eef --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup1same.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_caption_stage_1_soup1same +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_caption_stage_1_soup1same.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_caption_stage_1_soup1same.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup2same.sh b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup2same.sh new file mode 100644 index 0000000000000000000000000000000000000000..0596a3d4c54245985c4cbf6546dd9ebe185d38a9 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup2same.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_caption_stage_1_soup2same +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_caption_stage_1_soup2same.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_caption_stage_1_soup2same.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_bs32lr5e6.sh b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_bs32lr5e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..45dbad966e26d67aac72453a23b1308bb87f000d --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_bs32lr5e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_caption_stage_1_soup_bs32lr5e6 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_caption_stage_1_soup_bs32lr5e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_caption_stage_1_soup_bs32lr5e6.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_lr2e5dropout02.sh b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_lr2e5dropout02.sh new file mode 100644 index 0000000000000000000000000000000000000000..73c94d4a90b551c59c7665dbced972376123b01c --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_caption_stage_1_soup_lr2e5dropout02.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_caption_stage_1_soup_lr2e5dropout02 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_caption_stage_1_soup_lr2e5dropout02.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_caption_stage_1_soup_lr2e5dropout02.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_capground_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_capground_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..f2f4a34e8ea7a7eb5c27527d2b300827d5efb407 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_capground_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_capground_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_capground_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_capground_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_snlicap_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_snlicap_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..60805208da40ad3e878c37e1a814376e02d5a53f --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_snlicap_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_snlicap_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_snlicap_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_snlicap_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapground_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapground_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..974dd9a628f2414e77d8c5bfe9998fbca0eda908 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapground_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapground_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapground_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapground_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..01abf4d0ee4017270e94d4502ff2c7b2dd4e45e5 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapgroundofapt_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1.sh new file mode 100644 index 0000000000000000000000000000000000000000..c2be2f2fad529ef8350517b6a5406eab29769202 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapofa_caption_stage_1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapofa_caption_stage_1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..545b5ff6688091d6431302bc73ba70f84bb8d1eb --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapofa_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapofa_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e6.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5eeaa3382b36c4dec8293e30adb69ab170e7146 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapofa_caption_stage_1_lr1e6 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapofa_caption_stage_1_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapofa_caption_stage_1_lr1e6.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..4f0181c0d1af2675d8e0830aeefe322761e92267 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapofapt_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..422f945c31298ee4d8195c095a17160f396ba1fc --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapsnli_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..65ffed1e5189082315363609201689441cb56b38 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapsnliground_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..6c7329dcdd510887ec892147564fd51f082dcd0b --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqacapsnligroundofapt_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqasnliground_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqasnliground_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..7984c21acdc00ced3105977708ec739683fcd4ae --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqasnliground_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqasnliground_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqasnliground_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqasnliground_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/caption/ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/caption/ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a1e53acea2dff99bcb53a3e41be72bc52cc78880 --- /dev/null +++ b/slurm_adastra/averaging/caption/ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/caption/ofa_wacaption_vqasnligroundofapt_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/eval/._eval_refcocoplus.sh b/slurm_adastra/averaging/eval/._eval_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..c6c4cd6c1d7fe693ba6eb94ecd91340db03095e4 Binary files /dev/null and b/slurm_adastra/averaging/eval/._eval_refcocoplus.sh differ diff --git a/slurm_adastra/averaging/eval/eval_refcocoplus.sh b/slurm_adastra/averaging/eval/eval_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..106c2bd1ed56d49f7cd33234b680e3b4b0fca47c --- /dev/null +++ b/slurm_adastra/averaging/eval/eval_refcocoplus.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocoplus_base_best_refcocoplus_medium_small_large_supervised +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=00:30:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocoplus_base_best_refcocoplus_medium_small_large_supervised.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/eval/eval_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/eval/eval_refcocoplus_wa.sh b/slurm_adastra/averaging/eval/eval_refcocoplus_wa.sh new file mode 100644 index 0000000000000000000000000000000000000000..8e2da9d83fb61cfbc783438d47367b060a0e20c4 --- /dev/null +++ b/slurm_adastra/averaging/eval/eval_refcocoplus_wa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocoplus_supervised_large_small +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocoplus_supervised_large_small.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/eval/eval_refcocoplus_wa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa.sh b/slurm_adastra/averaging/fusing/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..21517a9b90b35a4232b5e6effe85213960113edb --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/fusing/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initavg_caprefsnlivqa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa.sh b/slurm_adastra/averaging/fusing/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..7e69711ecb92a457c7427ba87e8e772ec859f28c --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/fusing/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initavg_caprefsnlivqa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa.sh b/slurm_adastra/averaging/fusing/scaling_best/snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..32d9f42b0733bdaa6cf0eb784b5fca0279efb2f0 --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/fusing/scaling_best/snli_ve_ofaplus_base_pretrain_s2_hsep1_initavg_caprefsnlivqa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh b/slurm_adastra/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..ddc86c37135f9abeade12e3d5ffb556a21e243f7 --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/fusing/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initavgvideocaptionvqa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh b/slurm_adastra/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..eae8f512825976041e064e0a55173cd2fd91f34f --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/fusing/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initavgvideocaptionvqa.sh + + diff --git a/slurm_adastra/averaging/fusing/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa.sh b/slurm_adastra/averaging/fusing/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..b38c56497e830c426d79f1f81c85c6ed72b99030 --- /dev/null +++ b/slurm_adastra/averaging/fusing/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/fusing/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initavg_caprefsnlivqa.sh + + diff --git a/slurm_adastra/averaging/fusing/t.sh b/slurm_adastra/averaging/fusing/t.sh new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_ground_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_ground_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..7955fa0bdfa60a85d361b3332216a740194437fc --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_ground_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratacaption_ground_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratacaption_ground_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/caption/ofa_ratacaption_ground_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_snli_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_snli_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..1c0c11cd1f30c253138abc5d9d58f5a28033c5cc --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_snli_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratacaption_snli_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratacaption_snli_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/caption/ofa_ratacaption_snli_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_vqa_caption_stage_1_lr1e5.sh b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_vqa_caption_stage_1_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..d6d893a5c3283c95bae7037ac6a5f3f7b26cf9fe --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/caption/ofa_ratacaption_vqa_caption_stage_1_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratacaption_vqa_caption_stage_1_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratacaption_vqa_caption_stage_1_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/caption/ofa_ratacaption_vqa_caption_stage_1_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/caption/video/t.sh b/slurm_adastra/averaging/ratatouille/caption/video/t.sh new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/slurm_adastra/averaging/ratatouille/eval/eval_caption.sh b/slurm_adastra/averaging/ratatouille/eval/eval_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..12de25ea9d3558cfe52792ad42a93e09462f3806 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/eval/eval_caption.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_caption_base_best_caption_stage_1_caption_ratacapgroundsnlivqaofapt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_caption_base_best_caption_stage_1_caption_ratacapgroundsnlivqaofapt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/eval/eval_caption.sh + + diff --git a/slurm_adastra/averaging/ratatouille/eval/eval_refcoco.sh b/slurm_adastra/averaging/ratatouille/eval/eval_refcoco.sh new file mode 100644 index 0000000000000000000000000000000000000000..9442b5a269396d180636837bbdccdb7a89640867 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/eval/eval_refcoco.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocoplus_base_best_refcocoplus_ratacapsnlivqagroundofapt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocoplus_base_best_refcocoplus_ratacapsnlivqagroundofapt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/eval/eval_refcoco.sh + + diff --git a/slurm_adastra/averaging/ratatouille/eval/eval_vqa.sh b/slurm_adastra/averaging/ratatouille/eval/eval_vqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..ec58f451d6a062880baefa3e95d9c6b1fb0429f7 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/eval/eval_vqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_vqa_base_best_ratacapgroundsnlivqalr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_vqa_base_best_ratacapgroundsnlivqalr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/ratatouille/eval/eval_vqa.sh + + diff --git a/slurm_adastra/averaging/ratatouille/eval/eval_vqa_lambdas.sh b/slurm_adastra/averaging/ratatouille/eval/eval_vqa_lambdas.sh new file mode 100644 index 0000000000000000000000000000000000000000..7c2e5f48772bcc777962e5d3d2e4d7e6de066d05 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/eval/eval_vqa_lambdas.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_vqa_base_best_ratacapgroundsnlivqalr5e5_bestlambdas +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_vqa_base_best_ratacapgroundsnlivqalr5e5_bestlambdas.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash averaging/ratatouille/eval/eval_vqa_lambdas.sh + + diff --git a/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_cap_refcocoplus.sh b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_cap_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..8b9a24e7f7b661d5a2240b32be12e0a76a24efb3 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_cap_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_cap_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_cap_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/refcoco/ofa_ratarefcocoplus_cap_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_snli_refcocoplus.sh b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_snli_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..babe57e23c27f8decc62bafd5bc8b8a10480409d --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_snli_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_snli_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_snli_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/refcoco/ofa_ratarefcocoplus_snli_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_vqa_refcocoplus.sh b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_vqa_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..76ef45d716d446a084d92472457758a8df9cfc24 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/refcoco/ofa_ratarefcocoplus_vqa_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratarefcocoplus_vqa_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratarefcocoplus_vqa_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/refcoco/ofa_ratarefcocoplus_vqa_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus.sh b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..1f42492ba7e12735c8743756c564f25f56052592 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initrefcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive.sh b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..3b737b3ce1b21203c43e698ecf3194e6f3554227 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initsnlive.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa.sh b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..98e4a76752faa73af39383c176c4d3fb84d4cd65 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/caption/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_initvqa.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/caption/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa.sh b/slurm_adastra/averaging/ratatouille/scaling_best/caption/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..fbea8092148cb8a2d22d066a51ddf1845d089416 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/caption/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/caption/video/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_initvideoqa.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption.sh b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..61aa20d05c28621fef3750fe6ad4b5947856c16c --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initcaption.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive.sh b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..42255b4219b6cb1c6a0d0822e6282312938425eb --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initsnlive.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa.sh b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..ac23ec0ae3e38387270cf2b3f6423ab32e1d7687 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/refcocoplus/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf_initvqa.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption.sh b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..be659d856d6b262c20e69a4d00c4b1591240f536 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initcaption.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus.sh b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..4430e57b52801d431078a8a5c5784df50777b07d --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initrefcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa.sh b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa.sh new file mode 100644 index 0000000000000000000000000000000000000000..bebff31eda17d21e906d79b70c942a7552721421 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/ratatouille/scaling_best/snli_ve/snli_ve_ofaplus_base_pretrain_s2_hsep1_initvqa.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/vqa/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption.sh b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..ee244d4c83a967f922d1b3cc96106feff9c33140 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/scaling_best/vqa/video/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_initvideocaption.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption.sh b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption.sh new file mode 100644 index 0000000000000000000000000000000000000000..82c3dcb48288c3f1dbad831056f39ced140a4afa --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initcaption.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus.sh b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..22ced48f2e081e38361264b104699fba7de5c167 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initrefcocoplus.sh + + diff --git a/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive.sh b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive.sh new file mode 100644 index 0000000000000000000000000000000000000000..020e7ec007f85ca2c6bb9f2514f5a4f835f79940 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/scaling_best/vqa/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1_initsnlive.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..306b5a4058e52be72a11a8e15740e1bf4ce0dd55 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_cap_vqa_bart_noema_lr1e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_cap_vqa_bart_noema_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e6.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..b2e6032abf774ad53c3c82fd5cd7af237ba16be4 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_cap_vqa_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_cap_vqa_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr5e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..8a8d216ce0c5c0aef0ab72f70f03eeca4e091fee --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr5e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_cap_vqa_bart_noema_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_cap_vqa_bart_noema_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_cap_vqa_bart_noema_lr5e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8259355403ad7080af51de89052c8b9ecd38f93 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_ground_bart_noema_lr1e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_ground_bart_noema_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e6.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..133e0989e324478056723a1ed3a1e39b7ad82064 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_ground_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_ground_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr5e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..085f74516a8d4c5313026a973dcb9f0f9d6a7215 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr5e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_ground_bart_noema_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_ground_bart_noema_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_ground_bart_noema_lr5e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..e223694e659e884cdc72ad4df7684fec95fdc6fa --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_snli_bart_noema_lr1e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_snli_bart_noema_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e5.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e6.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..e497b6c93b235f54f3ecd7ede5186373d69a4553 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_snli_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_snli_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr5e5.sh b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..df26a9b5e9952ad81a6a300dc48a23274d702c46 --- /dev/null +++ b/slurm_adastra/averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr5e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_ratavqa_snli_bart_noema_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_ratavqa_snli_bart_noema_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/ratatouille/vqa/ofa_ratavqa_snli_bart_noema_lr5e5.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_long_refcocoplus.sh b/slurm_adastra/averaging/refcoco/ofa_long_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..34438d3714396f15692be56f043bb7ad1fd53f44 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_long_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_long_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_long_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_long_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..0e60bd9f7c4b29fed2749ada015a522dd242fd67 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_ground_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_ground_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr1e5.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..574d2e5bf277250a912958911ca91def0243cba2 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr1e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_ground_refcocoplus_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_ground_refcocoplus_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr1e5.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr5e6.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr5e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..03b152f88911943068e9ac26ba6e39a41f17d017 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr5e6.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_ground_refcocoplus_lr5e6 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_ground_refcocoplus_lr5e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_ground_refcocoplus_lr5e6.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliground_refcocoplus.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliground_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..31a8fa79596b764939904027f969f67bb48a74f5 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliground_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_vqacapsnliground_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_vqacapsnliground_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_vqacapsnliground_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..9239497539f3a2e829ca379d32e234700bbd86c6 --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_vqacapsnligroundofapt_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliofapt_refcocoplus.sh b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliofapt_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..a294679bdb4178538e495b9f6044e10aeb645a9a --- /dev/null +++ b/slurm_adastra/averaging/refcoco/ofa_warefcocoplus_vqacapsnliofapt_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_warefcocoplus_vqacapsnliofapt_refcocoplus +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_warefcocoplus_vqacapsnliofapt_refcocoplus.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/refcoco/ofa_warefcocoplus_vqacapsnliofapt_refcocoplus.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr1e6.sh b/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..94a0670f006b5758a497c40c2634a717e855b294 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_vqa_bart_noema_long_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_vqa_bart_noema_long_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_vqa_bart_noema_long_lr1e6.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr5e5.sh b/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..da53c3bce2a85a6c334954dd03da52b111121889 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_vqa_bart_noema_long_lr5e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_vqa_bart_noema_long_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_vqa_bart_noema_long_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_vqa_bart_noema_long_lr5e5.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..61cf8684b840730bbbdd8b00dde4e18e179c354e --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_capsnligroundofapt_vqa_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema.sh new file mode 100644 index 0000000000000000000000000000000000000000..d7c99ef06936cffc1fa966ef23754e0786548455 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapofa_vqa_bart_noema +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapofa_vqa_bart_noema.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..a1e4188479584e5179ba00c789c3419add27a6ca --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..fd94e6521e78e41c58235f80f1ffa5a6583b38ed --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e5.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..99e796bd9c42468b841f89b76628de13808a5cf2 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e6.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7.sh new file mode 100644 index 0000000000000000000000000000000000000000..10e850d3639b72f56975b0c46607c345027bca03 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapofa_vqa_bart_noema_lr5e7.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..6fc958883bb3e8f5638047266016e022e57029f2 --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapsnliground_vqa_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6.sh b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6.sh new file mode 100644 index 0000000000000000000000000000000000000000..2f327e39f25608f326350e517e4af9d055ca4b6f --- /dev/null +++ b/slurm_adastra/averaging/vqa/ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s1b0n0,x1004c4s1b1n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 --gpu-bind=closest bash averaging/vqa/ofa_wavqa_vqacapsnligroundofapt_vqa_bart_noema_lr1e6.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..a3f6530af162630b9a812e6a521c1154d110d7c6 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..b6162f614ce1dd4c65bd084ab1d31682f22fab46 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..674cb9e95dbba49e8a1b1b616ba4945cda1a8fd9 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..fc931d256568cc9f9c9c134a40098d0b7a48df54 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..fb1c31a5e73b7b83156f464b9ce911d7d8ad5b5e --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..c1a2dbc1f2465b5aa5598fa8b3f87c7183e16507 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..77c3c4a6632d01646e638468636ff625a3fec623 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..bcce0830dcaeffa3869a5f914753243b5b512014 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32.sh new file mode 100644 index 0000000000000000000000000000000000000000..78e5eea2a14c489d289dfd9e8674c7d13bd07dc7 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs32.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4c60408dfd0b9b3224680d955fde982de441676 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_bs8.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..65920ed7799ecb340943b4eece7add03e16cd0ee --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr1e4.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..0c2b32965544ebe0d4d3aa5559d8c6f552eb0db6 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_lr5e5.sh + + diff --git a/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..64fdccfa0bf2b64377bef89c3baea3a8b5caf766 --- /dev/null +++ b/slurm_adastra/caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/clotho/ofa_mini_clotho_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128.sh new file mode 100644 index 0000000000000000000000000000000000000000..04d7fefcc28273c07d86e957e2a621c4a452917d --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel128.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64.sh new file mode 100644 index 0000000000000000000000000000000000000000..88b2cc7d2031328db231765915fd77816c984c8e --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_bart_mel64.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch.sh new file mode 100644 index 0000000000000000000000000000000000000000..b3013b3c5c45fa3716f45234bb7f7239451cb48f --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128.sh new file mode 100644 index 0000000000000000000000000000000000000000..c8341001ad614d1656c2c51760fd106c08a217b8 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel128.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64.sh new file mode 100644 index 0000000000000000000000000000000000000000..a3e9644617ad3fc3260ed781c5e5eef88d64b78d --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_bart_allpannc14_nosample_scratch_mel64.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch_multinodes.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..68fea8d8702d0a296a53396b7d60222f476ecc86 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch_multinodes_test_pannspec_init.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14_nosample_scratch.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch_multinodes.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..eb741e06d5a9fa3208098ad8c82755b28d1b89ab --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/audio/ofa_mini_audio_caption_stage_1_bart_pannc14melb128_nosample_scratch.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10.sh new file mode 100644 index 0000000000000000000000000000000000000000..0e944e78265c5bebf44c5638bb660f1556161b52 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_ofa_cc3m_cc12m_pretrain_bart_allresnet_ep10.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_initbart.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_initbart.sh new file mode 100644 index 0000000000000000000000000000000000000000..57b9dc87566f57cca6612efda8902fc5e89ecda2 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_initbart.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_ofa_mini_initbart +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_ofa_mini_initbart.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_initbart.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10.sh new file mode 100644 index 0000000000000000000000000000000000000000..174eaaba8dd1e7d333e8cd8492a5e99f15b680e0 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_ep10.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh new file mode 100644 index 0000000000000000000000000000000000000000..aa4dd0166a3c682dc012e836c9c9f1d131ea35a8 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..417064f9e1e782b2f43aaba368e572be7ef0e063 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_ep1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..fe4e9df87101fc04eb39cfd5b14eb1c718a763e3 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..32ccaf7391b2b5efc9c21850111c4e8a08b82662 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear_nofreeze.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_onlyaudio_audiovcc_onestage_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep.sh new file mode 100644 index 0000000000000000000000000000000000000000..8bc699abdb422676602532b31ae723288e164137 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_onlyvideo_viddatacapqa_pretrain_bart_allresnxtvid_init_8f_lr4_20ep.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20.sh new file mode 100644 index 0000000000000000000000000000000000000000..33198b07c7b2ff143f68ed480dad6905a994b7d6 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8db07b23343f6b634fb3e68877c2f663ff52037 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext.sh new file mode 100644 index 0000000000000000000000000000000000000000..6c888dfaf18a046f345b93e076319231cc01a045 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..088fb7b94f4065d1fc0d7710b003635fb8b20247 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_long_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..39c282a7bfccf1297cb0daeb7b5672b2fc0632b1 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..a278a378b526cb22d141575a39ec63e0933dde09 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..4440c93990c77521b6b6851ee71c2ad77012bf9f --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..17c51a1e7d00a624557c021ef9ebea8eae5c0dce --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh new file mode 100644 index 0000000000000000000000000000000000000000..6fe30836d4058504c5e3cf4b58d273db68de26e5 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio_nofreeze_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetcls_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..5b568d7574fdebf53d9df05080937668c4296a92 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..accb650dfbc450caed31121f7d1e5623d503f0c1 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_audiosetclsdesc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..251d9706df940ab75c63f7e2b9be22a2f7197db3 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20.sh new file mode 100644 index 0000000000000000000000000000000000000000..554eeaa4dcc157390460ca543244a1e1a64e2744 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_ep20.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..4cca2f0e12dddd9a9e5ff8b8b2837ecb6ff86042 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..b92b1f2eb2f391317df9e298a6301a44590804f7 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allhtsat_init_8f_lr4_wav_audioembLN_lr1e4.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..c3f349cf8f4498c2fb25d397ab0bec652d478f86 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..4cca2f0e12dddd9a9e5ff8b8b2837ecb6ff86042 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..73cc8c4da4cdab4b599bbc9ed27c55adccf88c90 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio.sh new file mode 100644 index 0000000000000000000000000000000000000000..e5f763f47e947b3f1392e7bff662c002b77aba7b --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio_nofreeze_testep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_freezeaudio.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..a18a112070d52dcb0ac35c8ded119303eca34914 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh new file mode 100644 index 0000000000000000000000000000000000000000..3377f0a87e6ec102c663de45714e5855490ca7ec --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio_nofreezeeep10_withln.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN_lr1e4_freezeaudio.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20.sh new file mode 100644 index 0000000000000000000000000000000000000000..1750312269103578d53bbf3e6a58170a29c42fdc --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_test32k.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec.sh new file mode 100644 index 0000000000000000000000000000000000000000..de1b5010dd5f6c3971729739be8240c8d7be10c8 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_freezeencdec.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..e9cff4299ac48319534b091b70afdefcb0208e01 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear_bs256.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_bartinit_ep20_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..e6dd09709305827a1d7e7032b24f252e10fd758d --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=2:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast.sh new file mode 100644 index 0000000000000000000000000000000000000000..fd8ac9f28b071aff08f5e90262a1b1724b3b8689 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_ast.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec.sh new file mode 100644 index 0000000000000000000000000000000000000000..5b20f91c20147a6425cf03c151cd193d4f927657 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_freezeencdec.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat.sh new file mode 100644 index 0000000000000000000000000000000000000000..2d70d73eef88725e5c46904614fdde1e971c4a47 --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_htsat.sh + + diff --git a/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..c37087e2d9d628b3e36adf49ec44654b35ea86ff --- /dev/null +++ b/slurm_adastra/caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear_lr1e3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/audio/ofa_mini_audio_caption_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh + + diff --git a/slurm_adastra/caption/audio/scaling_best/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh b/slurm_adastra/caption/audio/scaling_best/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..b2d00faebf20f2172a9d8589d9925a764f4e0a28 --- /dev/null +++ b/slurm_adastra/caption/audio/scaling_best/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_bs8_4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_bs8_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh + + diff --git a/slurm_adastra/caption/eval/._eval_caption_base_best.sh b/slurm_adastra/caption/eval/._eval_caption_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..6adb6126a80f4ac5573ee096780318763cf9da70 Binary files /dev/null and b/slurm_adastra/caption/eval/._eval_caption_base_best.sh differ diff --git a/slurm_adastra/caption/eval/._eval_nocaps_base.sh b/slurm_adastra/caption/eval/._eval_nocaps_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..c00cb7c739f4b04f52a14f457caf903848ea4b72 Binary files /dev/null and b/slurm_adastra/caption/eval/._eval_nocaps_base.sh differ diff --git a/slurm_adastra/caption/eval/audio/eval_audiocaps_audio_caption.sh b/slurm_adastra/caption/eval/audio/eval_audiocaps_audio_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..e031c4858365c7569a06a0d4811567e8fdd5dd7f --- /dev/null +++ b/slurm_adastra/caption/eval/audio/eval_audiocaps_audio_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_audio_caption_ofaplus_s2_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_audio_caption_ofaplus_s2_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/audio/eval_audiocaps_audio_caption.sh + + diff --git a/slurm_adastra/caption/eval/audio/eval_clotho_audio_caption.sh b/slurm_adastra/caption/eval/audio/eval_clotho_audio_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8139c1aceb071d3080307c163f8c625ab8d73a2 --- /dev/null +++ b/slurm_adastra/caption/eval/audio/eval_clotho_audio_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_audio_caption_clotho_ofaplus_base_pretrain_s2_hs_lr5e5_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_audio_caption_clotho_ofaplus_base_pretrain_s2_hs_lr5e5_nosr_shuf_el_db_nounnorm.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/audio/eval_clotho_audio_caption.sh + + diff --git a/slurm_adastra/caption/eval/eval_caption_base_best.sh b/slurm_adastra/caption/eval/eval_caption_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5e190de89474aeff4854febddeb36146e715a1a --- /dev/null +++ b/slurm_adastra/caption/eval/eval_caption_base_best.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_caption_stage_2_ofaplus_s1_onlylinearylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_caption_stage_2_ofaplus_s1_onlylinearylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/eval_caption_base_best.sh + + diff --git a/slurm_adastra/caption/eval/eval_caption_base_best_avg.sh b/slurm_adastra/caption/eval/eval_caption_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..f3f3fe8bb8ca5fad207a6563d2b39bbbb7c8e4e9 --- /dev/null +++ b/slurm_adastra/caption/eval/eval_caption_base_best_avg.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_caption_base_best_avg_postfuse_capvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_caption_base_best_avg_postfuse_capvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/eval_caption_base_best_avg.sh + + diff --git a/slurm_adastra/caption/eval/eval_nocaps_base.sh b/slurm_adastra/caption/eval/eval_nocaps_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..6a0e6d9145500b7c5e8aa66e74db50a5c6c1b55c --- /dev/null +++ b/slurm_adastra/caption/eval/eval_nocaps_base.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_nocaps_avg_postratafusevanilla +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_nocaps_avg_postratafusevanilla.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/eval_nocaps_base.sh + + diff --git a/slurm_adastra/caption/eval/video/._eval_msrvtt_video_caption.sh b/slurm_adastra/caption/eval/video/._eval_msrvtt_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..4b870cc85280c43b84ed20f0b0e9834daa99fdbf Binary files /dev/null and b/slurm_adastra/caption/eval/video/._eval_msrvtt_video_caption.sh differ diff --git a/slurm_adastra/caption/eval/video/eval_activitynet_video_caption.sh b/slurm_adastra/caption/eval/video/eval_activitynet_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..5b199ab7c03f117f16996e6620e3763885557644 --- /dev/null +++ b/slurm_adastra/caption/eval/video/eval_activitynet_video_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_long +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_long_mxlen25_t1_5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/video/eval_activitynet_video_caption.sh + + diff --git a/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption.sh b/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..a689b6ac4f2cbc5a6a9febf550d937aab57a3cb5 --- /dev/null +++ b/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_caption_avg_postfuse_vidcapvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=00:20:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_caption_avg_postfuse_vidcapvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/video/eval_msrvtt_video_caption.sh + + diff --git a/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption_avg.sh b/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..3dbe24bfa89b7e0eec340c50bc5b70967ccb20e7 --- /dev/null +++ b/slurm_adastra/caption/eval/video/eval_msrvtt_video_caption_avg.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_msrvtt_video_caption_avg_postfuse_vidcapvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_msrvtt_video_caption_avg_postfuse_vidcapvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/video/eval_msrvtt_video_caption_avg.sh + + diff --git a/slurm_adastra/caption/eval/video/eval_msvd_video_caption.sh b/slurm_adastra/caption/eval/video/eval_msvd_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..40be5d1be7534d97c792d9e434b9be3682b6af57 --- /dev/null +++ b/slurm_adastra/caption/eval/video/eval_msvd_video_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/video/eval_msvd_video_caption.sh + + diff --git a/slurm_adastra/caption/eval/video/eval_youcookii_video_caption.sh b/slurm_adastra/caption/eval/video/eval_youcookii_video_caption.sh new file mode 100644 index 0000000000000000000000000000000000000000..b014d6509f8399370ee8897b9781b9f15f9f0867 --- /dev/null +++ b/slurm_adastra/caption/eval/video/eval_youcookii_video_caption.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_caption_base_ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_caption_base_ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/eval/video/eval_youcookii_video_caption.sh + + diff --git a/slurm_adastra/caption/scaling/._caption_stage_1_ofa_base_pretrain_s2.sh b/slurm_adastra/caption/scaling/._caption_stage_1_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..59f040682babc025f946aae651fbe307d13c4451 Binary files /dev/null and b/slurm_adastra/caption/scaling/._caption_stage_1_ofa_base_pretrain_s2.sh differ diff --git a/slurm_adastra/caption/scaling/caption_stage_1_ofa_base_pretrain_s2.sh b/slurm_adastra/caption/scaling/caption_stage_1_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..ae5af66b282411495665cd4a627f7f5fc7701885 --- /dev/null +++ b/slurm_adastra/caption/scaling/caption_stage_1_ofa_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs_frbn_testep3 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs_frbn_testep3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling/caption_stage_1_ofa_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling/caption_stage_1_ofa_huge_pretrain_s2.sh b/slurm_adastra/caption/scaling/caption_stage_1_ofa_huge_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..df8dec9329260615d694661d7f782bf92a6f174f --- /dev/null +++ b/slurm_adastra/caption/scaling/caption_stage_1_ofa_huge_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofa_huge_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofa_huge_pretrain_s2_fixedlr1e4_test_ep4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling/caption_stage_1_ofa_huge_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling/caption_stage_1_ofa_large_pretrain_s2.sh b/slurm_adastra/caption/scaling/caption_stage_1_ofa_large_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..1667d6ebf2b42d8c7ee26ccae3cd5ca60ff2449c --- /dev/null +++ b/slurm_adastra/caption/scaling/caption_stage_1_ofa_large_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofa_large_pretrain_s1_long_testep11 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofa_large_pretrain_s1_long_testep11.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling/caption_stage_1_ofa_large_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_base_pretrain_s2.sh b/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..4f3b95f7683d20705fbb7e16f47147b01ed08ca9 --- /dev/null +++ b/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs_frbn_testsep3 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs_frbn_testsep3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling/video/video_caption_stage_1_ofa_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_large_pretrain_s2.sh b/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_large_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..94c31d4d6b9110586f90b52242565278cb8ed262 --- /dev/null +++ b/slurm_adastra/caption/scaling/video/video_caption_stage_1_ofa_large_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofa_large_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofa_large_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling/video/video_caption_stage_1_ofa_large_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..a7d2354f8f0e9c3818ac209c8c6a8b3c2be886e7 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..b2d00faebf20f2172a9d8589d9925a764f4e0a28 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_bs8_4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_bs8_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_bs8_4.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e3.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e3.sh new file mode 100644 index 0000000000000000000000000000000000000000..3942b452daa7bf0e0cadea7efbb32ec86a5734b7 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e3.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_lr1e3 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_lr1e3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e3.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..104532e08ddbcddaa7c54fbda8d0a4e6790d2273 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..7a5b8cdb2e6a2483d87396597b9879f250cb4a66 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_hsep1_lr1e4_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_hsep1_lr1e4_nosr_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr5e5.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..5c052c7a1d15ead5a098f63da2c5f10003c1aa24 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_base_pretrain_s2_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_base_pretrain_s2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_base_pretrain_s2_lr5e5.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_huge_pretrain_s2_lr1e4_nosr_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_huge_pretrain_s2_lr1e4_nosr_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..7716c94170c6b4c9e21e15efdaf4bb5366b30703 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/audio_caption_ofaplus_huge_pretrain_s2_lr1e4_nosr_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_huge_inittext_lr1e4_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_huge_inittext_lr1e4_nosr_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/audio_caption_ofaplus_huge_pretrain_s2_lr1e4_nosr_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..4bbc413441c6bfa87058a82e68a20098635250e2 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e4_nosr_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..ede32387fca7a58d359598fb5516d41b02bc3fe5 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr1e5_nosr_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..c66148ca2b72e6325c90b7520af128a339030b63 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_clotho_ofaplus_base_pretrain_s2_hsep1_lr5e5_nosr_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_clotho_ofaplus_base_pretrain_s2_hsep1_lr5e5_nosr_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long.sh b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..6f272663f239d1adb45a551ce78685e080282a26 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=10:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/audio/clotho/audio_caption_clotho_ofaplus_base_pretrain_s2_lr5e5_nosr_shuf_el_db_long.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofa_base_pretrain_s2_bs16_shuf_el.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofa_base_pretrain_s2_bs16_shuf_el.sh new file mode 100644 index 0000000000000000000000000000000000000000..ad5683e7390db94879351058505bbaa3529d4054 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofa_base_pretrain_s2_bs16_shuf_el.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofainit_base_pretrain_s2_bs16_shuf_el +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofainit_base_pretrain_s2_bs16_shuf_el.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofa_base_pretrain_s2_bs16_shuf_el.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..727312c1b8e176cf2acccc83e0d26be7274e202a --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh new file mode 100644 index 0000000000000000000000000000000000000000..5743d16e5a79752005e912251b933778d3547b1c --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_bs16 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_bs16.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..b59700da4a09714905aa5a0b818cc91631af6c7f --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el.sh new file mode 100644 index 0000000000000000000000000000000000000000..81ade5d6d725cae5dac70a061bc994693a453db2 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_hsep1_bs16_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..15c709c1f0d9219d812260c9ea3e3433330b5d7d --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_bs16_shuf_el_da.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_fix.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_fix.sh new file mode 100644 index 0000000000000000000000000000000000000000..e76e27769a81124f665edd69bedd26675e7fe299 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_fix.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_fix +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_fix.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_fix.sh + + diff --git a/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..309d371f79ffe1cbe5d3deddd5f05bf905547376 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_base_pretrain_s2_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s0_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s0_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..e40b8796f0cc132bbd6716ebdd7c3dfabe886d65 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s0_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_s0_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_s0_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/audio_caption_ofaplus_s0_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s1_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..fb266a1dbc1df0ba69ab8f1bf30c9bf440c6c97d --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_s1_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_s1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/audio_caption_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s2_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..078f13abb39d8b3992b76aa1aa06b2b17de90ced --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/audio_caption_ofaplus_s2_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=audio_caption_ofaplus_s2_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/audio_caption_ofaplus_s2_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/audio_caption_ofaplus_s2_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s0_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s0_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..d58ba45721d1cb8c67741bf8f3770e3715c07d68 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s0_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_s0_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_s0_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s0_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s1_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..8234355cf5c2e59d44dfcc62bd0ea0eaa39e8613 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_s1_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_s1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s2_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..8e883fe29a8b9921e3146c36d2eba5c6decfb0bf --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s2_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_1_ofaplus_s2_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_1_ofaplus_s2_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/caption_stage_1_ofaplus_s2_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_2_ofaplus_s1_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_2_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..f0bdeffa1cabc26911fbc80429859bb8f7f9cf5c --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/caption_stage_2_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_2_ofaplus_s1_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=5:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_2_ofaplus_s1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/caption_stage_2_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s0_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s0_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..3d55b49514329f9c576a9989cfc5e29d319cb67e --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s0_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_ofaplus_s0_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_ofaplus_s0_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/video_caption_ofaplus_s0_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s1_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..589b1a9f5f45ceb4db02867ab4d9ce72983ca08d --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_ofaplus_s1_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_ofaplus_s1_onlylinear_lr1e3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/video_caption_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s2_onlylinear.sh b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..ec903902e37d06fa932af9ae1cdb62e42cbc9c4c --- /dev/null +++ b/slurm_adastra/caption/scaling_best/onlylinear/video_caption_ofaplus_s2_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_ofaplus_s2_onlylinear_lr1e3 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_ofaplus_s2_onlylinear_lr1e3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/onlylinear/video_caption_ofaplus_s2_onlylinear.sh + + diff --git a/slurm_adastra/caption/scaling_best/scst/caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf.sh b/slurm_adastra/caption/scaling_best/scst/caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..6a81fd927d6ef07b7a2a6b8ab897d33db3f4c1c6 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/scst/caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf_bs8_ep3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/scst/caption_stage_2_ofaplus_base_pretrain_s2_hsep1_bs16_shuf.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/activitynet/._video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/caption/scaling_best/video/activitynet/._video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..19a19ca4c8bf999dc9896e894956752522827d7b Binary files /dev/null and b/slurm_adastra/caption/scaling_best/video/activitynet/._video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh differ diff --git a/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh b/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..f7ee2c9519a135e1246d6c1db373bcabd815eb58 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_long +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr +####SBATCH --begin=now+3hour + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..7517c6dcc678aa895834eb3da73706c8c5b5fa93 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da_long +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr +####SBATCH --begin=now+3hour + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/activitynet/video_caption_activitynet_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2.sh b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..462746172a4e21e764db1e08380a0a646b82ffff --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_msvd_stage_1_ofaplus_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16.sh b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16.sh new file mode 100644 index 0000000000000000000000000000000000000000..22e6d1c7339f797577d804459f05098016c7235e --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_bs16.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..f28ed7c19e826ed899cc4497c11720feae8937b8 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..7c869a4f1c56d745b3eb567581b9399786459153 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/msvd/video_caption_msvd_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh b/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..70b64440b65737c73984265f8117e9b3ba5df62d --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr +####SBATCH --begin=now+3hour + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da_long.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..a08660c9c4b519045adbd1f09afda07f267ca110 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_hs_shuf_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr +####SBATCH --begin=now+3hour + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/vatex/video_caption_vatex_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2.sh b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..cc071ac1efe622abaccda84fda1a3b0e9dd96591 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh new file mode 100644 index 0000000000000000000000000000000000000000..b48a5ea3af2a1b1bd50cde96245f1fbb54891700 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_bs16 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_bs16.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_bs16.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..4dc882adc4383f0fad62524d72672aeced9c9912 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_lr5e5.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..19681a7e01e6c163a82077fb21608052660d4e59 --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..8ea299f3cb365e0c0c38ebf4bebe70f91265222f --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_stage_1_ofaplus_base_pretrain_s2_hsep1_shuf_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/video_caption_stage_1_ofaplus_base_pretrain_s2_shuf_el_db_da.sh + + diff --git a/slurm_adastra/caption/scaling_best/video/youcookii/video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db.sh b/slurm_adastra/caption/scaling_best/video/youcookii/video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..d53b4b1978e74ea268bb4a25d339325b633eb6ac --- /dev/null +++ b/slurm_adastra/caption/scaling_best/video/youcookii/video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scaling_best/video/youcookii/video_caption_youcookii_ofaplus_base_pretrain_s2_shuf_el_db.sh + + diff --git a/slurm_adastra/caption/scst/ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test.sh b/slurm_adastra/caption/scst/ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test.sh new file mode 100644 index 0000000000000000000000000000000000000000..98921cb75adfbd8479ac57a29b0b1a2d79a8350f --- /dev/null +++ b/slurm_adastra/caption/scst/ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/scst/ofa_mini_caption_stage_2_video_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_test.sh + + diff --git a/slurm_adastra/caption/video/msvd/ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/msvd/ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..d0c8a8fde0a8483d5aa772fa770c2921d877c2ea --- /dev/null +++ b/slurm_adastra/caption/video/msvd/ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/msvd/ofa_mini_msvd_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..a411c0261ee19bf5109114261b2ac9e829c055da --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_det_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..cc67768891e3af41bc0d66098f2f2b2452040d42 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_ground_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..0812fad81cdc038e602365c9074bef9e916432e0 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_itdata_cc12m7m_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..b7a8f3e820a91dd7cf604bf359f2357527a9a867 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_qa_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..78926ed9a95e542229460e1b5ee5287a67570482 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_text_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..3ae2d60db88020294cc3eb05a8084e0e36d8dc60 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..ca8bdfc14df7dc873431110a206ec600629dc52c --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_ep20_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..7bef3a9e0a2b40a5e4f1d8ebc1c3bb00e001c513 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_4f_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_4f_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..6064a4312708986eb183c711a6c9d79ba553d0e3 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_lr4_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..9bbcf3e85bbb8605d91b97d4036a15a400b3fd06 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample_multinodes_fix.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_4f_vids2_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..32a151c3072abc8051645444b95e0e7570a4ec08 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..6cbbe07cab05248f4902c056b05d861d2ce49668 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..11117d006276ae732221cdd140824a8d667f9e18 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..c450179c78abcf9fd802ee8241cdce18117e8236 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_lr4_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..16be416b59c46d25259add96499ab7da3f07259a --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_4f_vids2_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..1730f4679a0f09559226b0d4275d32d552f4307e --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..0bf1882deec32a39edc2a9dabb370610df84640d --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..969ff636701565549f157c8db675b312dbe75e2c --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_bs16.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..7069651b53417ebb36c0254fe4e818c0458cb8c2 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..ebb2a865f0458c788c7e19e06c4e3dc22d7242c9 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes_fixcider.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..3db597eb434c25ee7195a9dbacdf1ae36a75181b --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..145234f281ad7b7cd645139a964e5507c023156e --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..abb9d8fe8b34ef81e51eb15d07d6101fad2f3019 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_shared_tformer_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..fec7da149791b5ef17f33f161fa85b9837d51009 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..feb7fb4796615cb0273eb796a629aded688d32b8 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddata_allres_alls3d_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..729dbacf2ce35e5bf8ad640eb213e7d01ccedbc5 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt_ep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash averaging/branching/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_videp20_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..7ede7a8c0643d37e1945d6fdbc2245aa5d103399 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1.sh new file mode 100644 index 0000000000000000000000000000000000000000..88d0a793c61b3b6c3f52952bb53d088edc46f9c6 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_fps1.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..b4ab035096afe3c1bb6000c9288be81c6cd201e9 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..a63b817562c4db10a986b4f5854e67a966a2ba73 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_onlylinear.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..3df41a1e53760d38aa0a77fb1b8611716b80b38f --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..9b5fffa3b3f37daa9e57c23dc5d8f8d41aba3172 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..e43e6c3e4ebaab33dbb65e0b221d7c3ba279ac61 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_vit_hres_enceval_scratch.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..5c3a37a02284b282c9cddf82a3e4afb5f885b5f6 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample_multinodes_2.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..378fe167e7f952d6011642e29b59f8d7b99385bf --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_enceval_withcls_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..b1c69715e01f1acc81418e38387351e51c7930e0 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_caption_stage_1_bart_vitb16_hres_unfreeze_nosample.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_initlmscratch.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_initlmscratch.sh new file mode 100644 index 0000000000000000000000000000000000000000..9d663c141e0e37d1f0ff99d6de5cdb077abb978e --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_initlmscratch.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_initlmscratch +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_initlmscratch.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_initlmscratch.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10.sh new file mode 100644 index 0000000000000000000000000000000000000000..77c9df6d0e88b0d4f1d584f5b60ef15bea7827e2 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresne_ep10.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh new file mode 100644 index 0000000000000000000000000000000000000000..92e827178a21e579cf092fe5db478eae806d9186 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_ep1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..ff0c3f757efbd83d90f2ff6f8d17900c608d95dc --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_ep1_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_ep1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..42eae914b26c86f507fb9294457129b37b89b7c7 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_onlyvideo_viddatacapqa_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..0b819f728f3943d1cff6e2ddc5f1f82fba4d3d45 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_ep20_onlylinear.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..52a4eab0a76537e527a429f3f67cbac20391cbdd --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..80d0d73499101e72b7be166d41e1e9431366e3eb --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_onestage_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh new file mode 100644 index 0000000000000000000000000000000000000000..86d6e96703b6554f9dd6e9c5c523e24d4d8ee839 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..9c5f0704ee5fe1746a4fb34efc7f5f56acd3fa8f --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..f7dc09c1fbfcaf8c79558e72043b8e942a6ac338 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=12:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/ofa_mini_video_caption_stage_1_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh b/slurm_adastra/caption/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..562bb1396e102d7ad2efeac1e89804b0f03ebea5 --- /dev/null +++ b/slurm_adastra/caption/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes +#SBATCH --nodes=1 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash caption/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres.sh + + diff --git a/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..d54df0ea7329fad4f0841e6b39a04182e6fa2d67 --- /dev/null +++ b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/scst/ofa_mini_video_caption_stage_2BLUE_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh + + diff --git a/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a6a32d6a422426be59d78199d050b00e3e9543c1 --- /dev/null +++ b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e52.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/scst/ofa_mini_video_caption_stage_2ROUGEL_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh + + diff --git a/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..a4e82b6bff50054cf7c3752ffc7f22810c056a98 --- /dev/null +++ b/slurm_adastra/caption/video/scst/ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/scst/ofa_mini_video_caption_stage_2_4_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e5.sh + + diff --git a/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh new file mode 100644 index 0000000000000000000000000000000000000000..95c54cbf7f6c18b6ba569d39420aa49aa884e953 --- /dev/null +++ b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f.sh b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f.sh new file mode 100644 index 0000000000000000000000000000000000000000..18193f6b65d000c63d74a31b156df7a24f9a485e --- /dev/null +++ b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f.sh + + diff --git a/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res.sh b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res.sh new file mode 100644 index 0000000000000000000000000000000000000000..c1edb4dfe43dc0636b0acd3605ebf9f90a5aa202 --- /dev/null +++ b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_32f_224res.sh + + diff --git a/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res.sh b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res.sh new file mode 100644 index 0000000000000000000000000000000000000000..81d21128ec5d28adafa3e1e6dee16ed1fa9139dd --- /dev/null +++ b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_480res.sh + + diff --git a/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..fa62de19284e4c3510cd8b68d8b46f8b072dcd7b --- /dev/null +++ b/slurm_adastra/caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash caption/video/youcookii/ofa_mini_youcookii_video_caption_stage_1_bart_viddatacapqa_allres_allresnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_lr1e4.sh + + diff --git a/slurm_adastra/image_gen/eval/._eval_image_gen.sh b/slurm_adastra/image_gen/eval/._eval_image_gen.sh new file mode 100644 index 0000000000000000000000000000000000000000..1922aadc70300c4125563f8e01756bfee550e1a1 Binary files /dev/null and b/slurm_adastra/image_gen/eval/._eval_image_gen.sh differ diff --git a/slurm_adastra/image_gen/eval/eval_image_gen.sh b/slurm_adastra/image_gen/eval/eval_image_gen.sh new file mode 100644 index 0000000000000000000000000000000000000000..08fad0e14ec2abb1d804e12697157d4af7fb5969 --- /dev/null +++ b/slurm_adastra/image_gen/eval/eval_image_gen.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_image_gen_ofa_stage_2_base +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_image_gen_ofa_stage_2_base.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/eval/eval_image_gen.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_initbart.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_initbart.sh new file mode 100644 index 0000000000000000000000000000000000000000..b5edb6a5c0f74ed7410ae4d0a993883261633c1a --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_initbart.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_1_initbart +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_1_initbart.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_1_initbart.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.sh new file mode 100644 index 0000000000000000000000000000000000000000..0533bcc63101e8939c85a62402d0ff766c32a629 --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext.sh new file mode 100644 index 0000000000000000000000000000000000000000..1ff71fd696805d27bac4b3bd0d918ed70100a1d6 --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext_ep1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_1_pretrain_bart_allresnet_pretraintext.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..6420a2881fdf65d6444bb03fc31f234ac22b9608 --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..0533bcc63101e8939c85a62402d0ff766c32a629 --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_1_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=14:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_1_ofa_mini_pretrain_bart_allresnet_ep20.sh + + diff --git a/slurm_adastra/image_gen/ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh new file mode 100644 index 0000000000000000000000000000000000000000..4bb4776c1f4876bce5f0edbc92f4b720d0aa13aa --- /dev/null +++ b/slurm_adastra/image_gen/ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/ofa_mini_image_gen_stage_2_video_s2_viddatacapqa_pretrain_bart_allres_allresnxtvid_init_8f_lr4.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_1_base.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_1_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..af18c99a634af8b1b4bcec4693b26fba9d03d5f4 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_1_base.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofa_stage_1_base +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofa_stage_1_base.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofa_stage_1_base.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_2_base.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_2_base.sh new file mode 100644 index 0000000000000000000000000000000000000000..2cbc7da9d9a36d51181647196cfe2ef25d891082 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofa_stage_2_base.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofa_stage_2_base +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofa_stage_2_base.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofa_stage_2_base.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..f3a649221b1cc8ce5d8372426d8fc56e2ae0bad9 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofaplus_stage_1_base_s2 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofaplus_stage_1_base_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_bs8_4.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_bs8_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..0d3f2e29b07b7008549165fd2bff31c8e3882109 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_bs8_4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofaplus_stage_1_base_s2_bs8_4 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofaplus_stage_1_base_s2_bs8_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_bs8_4.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_hsep1_long.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_hsep1_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..64dae19a61cb5a1f0da2051729061fc5da998ac6 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_hsep1_long.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofaplus_stage_1_base_s2_hsep1_long +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofaplus_stage_1_base_s2_hsep1_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_hsep1_long.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_lr5e3.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_lr5e3.sh new file mode 100644 index 0000000000000000000000000000000000000000..8be496dd45f45227f00e57332c3c826d05f66899 --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_lr5e3.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofaplus_stage_1_base_s2_lr5e3 +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofaplus_stage_1_base_s2_lr5e3.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofaplus_stage_1_base_s2_lr5e3.sh + + diff --git a/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_2_base_s2_hsep1_long.sh b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_2_base_s2_hsep1_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..9377cae5555cd191d78d253a98f0d22294237d1a --- /dev/null +++ b/slurm_adastra/image_gen/scaling_best/image_gen_ofaplus_stage_2_base_s2_hsep1_long.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=image_gen_ofaplus_stage_2_base_s2_hsep1_long +#SBATCH --nodes=4 +#SBATCH --ntasks=4 +#SBATCH --gpus=32 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/image_gen_ofaplus_stage_2_base_s2_hsep1_long.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 4 -n 4 -c 128 --gpus=32 bash image_gen/scaling_best/image_gen_ofaplus_stage_2_base_s2_hsep1_long.sh + + diff --git a/slurm_adastra/refcoco/eval/eval_refcoco.sh b/slurm_adastra/refcoco/eval/eval_refcoco.sh new file mode 100644 index 0000000000000000000000000000000000000000..c34bb06fbe2508acddfadffee202add8bfc8de88 --- /dev/null +++ b/slurm_adastra/refcoco/eval/eval_refcoco.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcoco_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcoco_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/eval/eval_refcoco.sh + + diff --git a/slurm_adastra/refcoco/eval/eval_refcocog.sh b/slurm_adastra/refcoco/eval/eval_refcocog.sh new file mode 100644 index 0000000000000000000000000000000000000000..26ab00943bb05ef78c29fc43111af50e51865346 --- /dev/null +++ b/slurm_adastra/refcoco/eval/eval_refcocog.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocog_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocog_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/eval/eval_refcocog.sh + + diff --git a/slurm_adastra/refcoco/eval/eval_refcocoplus.sh b/slurm_adastra/refcoco/eval/eval_refcocoplus.sh new file mode 100644 index 0000000000000000000000000000000000000000..2638fb88ef795c50a5b016ebadedac7427057687 --- /dev/null +++ b/slurm_adastra/refcoco/eval/eval_refcocoplus.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocoplus_avg_postratafuse +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocoplus_avg_postratafuse.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/eval/eval_refcocoplus.sh + + diff --git a/slurm_adastra/refcoco/eval/eval_refcocoplus_avg.sh b/slurm_adastra/refcoco/eval/eval_refcocoplus_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..749b41b21f2781a07078d626e805256ce3f40395 --- /dev/null +++ b/slurm_adastra/refcoco/eval/eval_refcocoplus_avg.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_refcocoplus_base_best_avg_postfuse_refvqa +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_refcocoplus_base_best_avg_postfuse_refvqa.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/eval/eval_refcocoplus_avg.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcoco_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcoco_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..b8525dca125c1a3a0c082fb6bc7a15e4ffcf8540 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcoco_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcoco_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcoco_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcoco_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..d053d224c5211d5d2ddf54b9b9e955ff8615e926 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcoco_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocog_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcocog_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..65262231c0a4b8b5cd7dc30ffbc054fe7744c972 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocog_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocog_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocog_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocog_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..bfda450afc581c75710908b42b454c333d88e69e --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocog_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5dfa606f15d4a4617f314d05c8e1f95cd9ad9a3 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofainit_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofa_base_pretrain_s2_hs_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..43803f8bc7be3c338a4ed163747f107f217479aa --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..6819cfd954daf51ca85a20c7a90217d8ed7735f6 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_2_lr5e5.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_4.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..a40f1b030acb3094d3d557c4dc0831ac3e444c76 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_bs8_4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_bs8_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_bs8_4.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix.sh new file mode 100644 index 0000000000000000000000000000000000000000..9d552183981e07d6aaaa07dee4ba6e215cd90055 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_fix +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_fix_thresh.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..92cfe2687dbe9e0d15028448bb7a4f60d7f56d9a --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_5e5_bs8_4.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_lr5e5_bs8_4_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_lr5e5_bs8_4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..b277a0be962ed23f94d6599958f55448e829b406 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_lr5e5_bs8_4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_hsep1_fix_lr5e5_bs8_4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_fix_lr5e5_bs8_4_shuf.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..469cf3a92810e1d80e0e143f2500266b0d5208c8 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_lr5e5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..2a4f04f4c7a703386bf371b02b0d27a4e5f0574d --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_el_db.sh + + diff --git a/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf.sh b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..c3d2bf2b94d21a144ca91c5aa80ed9e82eb90f51 --- /dev/null +++ b/slurm_adastra/refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=5:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scaling_best/refcocoplus_ofaplus_base_pretrain_s2_lr5e5_shuf.sh + + diff --git a/slurm_adastra/refcoco/scst/._ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh b/slurm_adastra/refcoco/scst/._ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh new file mode 100644 index 0000000000000000000000000000000000000000..4723a900f75704fdb86b88c0156a6a072e5e5f16 Binary files /dev/null and b/slurm_adastra/refcoco/scst/._ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh differ diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..3945a1a78009d3322fb3dea8433e5f6dc53847b7 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1.sh new file mode 100644 index 0000000000000000000000000000000000000000..88b4e0d5020fda904ba952d2c50f37cec2af8154 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf1.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..2526294f3a3ec35a12cce657a32de970c9c5da2b --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5medium_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..184af2d2c3497115fa4b141966b86493fe87e90f --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumlarge_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..5a4ef4814b77e4f69b3055d81b228cca33632261 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5_test.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5mediumsmall_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..3df94d1e42c4a67c78018e410ff3462f8146fa06 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_acc0_5smalllarge_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5.sh new file mode 100644 index 0000000000000000000000000000000000000000..3d828f253098305ba14607a07da44266e4cbd56f --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf0_5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1.sh new file mode 100644 index 0000000000000000000000000000000000000000..8240b672d2b21b23a82e4ba47ac145859967d449 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf1.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..fd0ab2026ec7b816e672bc5102848ff2b690224a --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1.sh new file mode 100644 index 0000000000000000000000000000000000000000..d274b104afba11ed15bcc74a68ae8a3077027a7e --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf1.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh new file mode 100644 index 0000000000000000000000000000000000000000..2bdfc9eb24450209d2a6cb908ac67067ce1d463f --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf10.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5.sh new file mode 100644 index 0000000000000000000000000000000000000000..97e5ce8640321c1fec4dd3af6de07395aac97526 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_l1norm_lreinf5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5.sh new file mode 100644 index 0000000000000000000000000000000000000000..e42977dce983d929c5b14c4fce7cc4d15af5ce1a --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_fixedscst_mse_lreinf0_5.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_large.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_large.sh new file mode 100644 index 0000000000000000000000000000000000000000..0c64696e7cbabcacce0e707de0a8f78596f8bd40 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_large.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_large +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l10_large.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_large.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium.sh new file mode 100644 index 0000000000000000000000000000000000000000..a03d499c53f228501348bea7b53ed0d8ee7ccce3 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_medium.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small.sh new file mode 100644 index 0000000000000000000000000000000000000000..3859a4d4f0c5b714dd01ecb46571a562b772897b --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_lprob_supervised_l1_small.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large.sh new file mode 100644 index 0000000000000000000000000000000000000000..929a1a3c7d3d4a5c3a730fd9bf56815efbb6d3e3 --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_large.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium.sh new file mode 100644 index 0000000000000000000000000000000000000000..db3a4b2786b8e8e073899ed7ec250692f5d4d06e --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_medium.sh + + diff --git a/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small.sh b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small.sh new file mode 100644 index 0000000000000000000000000000000000000000..95df65ffa0227e92bb06d60f6552692ca1372fbe --- /dev/null +++ b/slurm_adastra/refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=3:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash refcoco/scst/ofa_mini_qa_ground_cc12m_balanced_refcocoplus_scst_supervised_l1_small.sh + + diff --git a/slurm_adastra/scaling/._ofa_base_pretrain_s1_ret_startonlylinear.sh b/slurm_adastra/scaling/._ofa_base_pretrain_s1_ret_startonlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..b9b7f1505bedc180bd3f8c46d17ed2e2150202d8 Binary files /dev/null and b/slurm_adastra/scaling/._ofa_base_pretrain_s1_ret_startonlylinear.sh differ diff --git a/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh new file mode 100644 index 0000000000000000000000000000000000000000..0a602283f6914ed440219bf7a0802e79d1ded320 Binary files /dev/null and b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh differ diff --git a/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh new file mode 100644 index 0000000000000000000000000000000000000000..ef8c6e80257e80d1320102005298c279c0f7f5d3 Binary files /dev/null and b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh differ diff --git a/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..fcaf4e33e914eb52a8e2580f03c8268c6b07a5a4 Binary files /dev/null and b/slurm_adastra/scaling/._ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh differ diff --git a/slurm_adastra/scaling/ofa_base_pretrain_baseline.sh b/slurm_adastra/scaling/ofa_base_pretrain_baseline.sh new file mode 100644 index 0000000000000000000000000000000000000000..ed2becd7545c6d4dc188f8cff331605cbcf62dbc --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_baseline.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_baseline +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_baseline.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+10hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_baseline.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_baseline_hs.sh b/slurm_adastra/scaling/ofa_base_pretrain_baseline_hs.sh new file mode 100644 index 0000000000000000000000000000000000000000..a22227a94e86ce14a3465b25b9df7898d3afb802 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_baseline_hs.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_baseline_hs +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_baseline_hs.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+10hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_baseline_hs.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1.sh new file mode 100644 index 0000000000000000000000000000000000000000..05fd34f22c3b9f7726c2ddc1cfbf934b204e8fd5 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1_long.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..8e77c67f12c29d7370f6c76a0a6a374bb288eb9a --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1_long.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1_long +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1_long.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1_long.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1_long_init_ofa.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1_long_init_ofa.sh new file mode 100644 index 0000000000000000000000000000000000000000..5c65d44a190a29989c5f97430499ae0edd42dec6 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1_long_init_ofa.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1_long_init_ofa +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1_long_init_ofa.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1_long_init_ofa.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1_long_initcc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1_long_initcc.sh new file mode 100644 index 0000000000000000000000000000000000000000..3923b46f37d6620a46f852ca7d9731d43d123854 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1_long_initcc.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1_long_initcc +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1_long_initcc.out +#SBATCH --exclusive +#SBATCH --time=18:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1_long_initcc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1_ret.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1_ret.sh new file mode 100644 index 0000000000000000000000000000000000000000..be287ea9ee96f961766d18837ea45572873f99d7 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1_ret.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1_ret +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1_ret.out +#SBATCH --exclusive +#SBATCH --time=18:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1_ret.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s1_ret_startonlylinear.sh b/slurm_adastra/scaling/ofa_base_pretrain_s1_ret_startonlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..e2b778dedf2e95e0acf022524f29a6aea2fa395a --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s1_ret_startonlylinear.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s1_ret_startonlylinear +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s1_ret_startonlylinear.out +#SBATCH --exclusive +#SBATCH --time=15:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s1_ret_startonlylinear.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..a825c5a5e29efb24737a9968dfebb4b26ec9678f --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +###SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..ce6dde053013282ea346c634cdf7a61caad09fd0 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +####SBATCH --gpus=256 +#SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpus=256 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..353382d8c84675c0ef18612fd6a831a74b3cc7bd --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +####SBATCH --gpus=256 +#SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpus=256 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep.sh new file mode 100644 index 0000000000000000000000000000000000000000..1d2e828e31d55e718021f2c3132f4c56629e8b3c --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep.out +#SBATCH --exclusive +#SBATCH --time=12:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa.sh new file mode 100644 index 0000000000000000000000000000000000000000..8f08a85f62293e50100a68b0c6298f1c5aeedf20 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_init_ofa.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata.sh new file mode 100644 index 0000000000000000000000000000000000000000..6af7799160741c466e2ce409b01d9cb3b9c296a9 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +###SBATCH --begin=now+5hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_nolsdata.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh new file mode 100644 index 0000000000000000000000000000000000000000..657bfeef483c26524bb5ebefdb72a5964a7aa650 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+8hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh new file mode 100644 index 0000000000000000000000000000000000000000..6138ba0633e7d80336ce97ad360fb31114d6885f --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+9hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_2.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn.sh new file mode 100644 index 0000000000000000000000000000000000000000..7612e4d8d2de1dee8a8b8fcbcfef37cdce8b430a --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+7hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..4ea31326ecbc184e134f307117f8c36806a545e3 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+7hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgbn_fvidenc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..958acb187b016fbc0855b339c676c3a800f810c0 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+7hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_initccs1_startonlylinear_nolsdata_fimgenc_fvidenc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5ce3b9fa21a5e822cd0f4754c04029f6e16ebca --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs.sh new file mode 100644 index 0000000000000000000000000000000000000000..698f0d4f94e18cd112c89fae51a47e6d5ede3cf9 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs_freezeencdec.out +#SBATCH --exclusive +#SBATCH --time=20:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+10hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..7b1e97430870c13c6aec71c11e333154bdda67e2 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+5hours + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_startonlylinear.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs.sh new file mode 100644 index 0000000000000000000000000000000000000000..aa137f48d1a21ec9e4a0a725cafdfa81ad5ff664 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +####SBATCH --begin=now+10hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_vidhs.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..b46cdc8647898d58f6afb73a7e933617e8529147 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc +#SBATCH --nodes=8 +#SBATCH --ntasks=8 +#SBATCH --gpus=64 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 8 -n 8 -c 128 --gpus=64 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_onlyenc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..9f5407440e0ae3143d633b62c2a2e16e785c9bd6 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +###SBATCH --begin=now+6hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..978d9a2638d3416bbf868edd32d6403d4edf9212 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+5hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlyenc_freezeenc.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..9ec6c614c773d72e6eb78c3c5225921a1ba31390 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+5hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5.sh b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..dca6b75a838643b0c1b0c6f266554b8eab64765f --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+4hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s2_long_lr1e4_50ep_startonlylinear_lr5e5.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_base_pretrain_s3.sh b/slurm_adastra/scaling/ofa_base_pretrain_s3.sh new file mode 100644 index 0000000000000000000000000000000000000000..fd4eba5f4729f6fdc8f39c1e54a6b47d67ccafe6 --- /dev/null +++ b/slurm_adastra/scaling/ofa_base_pretrain_s3.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_base_pretrain_s3 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +#SBATCH --gpus=256 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_base_pretrain_s3.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpus=256 --gpu-bind=closest bash pretraining/scaling/ofa_base_pretrain_s3.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s1.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s1.sh new file mode 100644 index 0000000000000000000000000000000000000000..ddad6ec7a889dab00c6fe40a9e3b3ce213b82f50 --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s1.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s1 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +###SBATCH --gpus=128 +#SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s1.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s1.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s2.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..9ab4ebdd950e662a244f1384f1d88d8d61516b36 --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s2.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s2 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s2_test.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s2.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr.sh new file mode 100644 index 0000000000000000000000000000000000000000..2bfb845b5efea5551a1f31c4e174e644cd41db2c --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s2_fixedlr +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s2_fixedlr.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s2_fixedlr.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr1e4.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..59431de43fa7bce76321099d068963c76dce6774 --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr1e4.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s2_fixedlr1e4 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s2_fixedlr1e4.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s2_fixedlr1e4.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr5e5.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..403a52091d05877c38532ce4589822687bb5b560 --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s2_fixedlr5e5.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s2_fixedlr5e5 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +####SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s2_fixedlr5e5.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s2_fixedlr5e5.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_huge_pretrain_s3.sh b/slurm_adastra/scaling/ofa_huge_pretrain_s3.sh new file mode 100644 index 0000000000000000000000000000000000000000..6c6aa646139ccc71090d761eeb9971e376dec3a5 --- /dev/null +++ b/slurm_adastra/scaling/ofa_huge_pretrain_s3.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_huge_pretrain_s3 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_huge_pretrain_s3.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_huge_pretrain_s3.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s1.sh b/slurm_adastra/scaling/ofa_large_pretrain_s1.sh new file mode 100644 index 0000000000000000000000000000000000000000..ebda97f0a136c7ae361021d2a0dd4dd1a32fe83d --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s1.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s1_test.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s1.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s1_long.sh b/slurm_adastra/scaling/ofa_large_pretrain_s1_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..66437449e3bfdc7172cdccfed17a88afd681e1d8 --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s1_long.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s1_long +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s1_long.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +#SBATCH --begin=now+1hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s1_long.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s1_long_inittext.sh b/slurm_adastra/scaling/ofa_large_pretrain_s1_long_inittext.sh new file mode 100644 index 0000000000000000000000000000000000000000..47c917a84ae91b958e0a849ab8f99b5863efc20f --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s1_long_inittext.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s1_long_inittext +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s1_long_inittext.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 +###SBATCH --begin=now+1hour + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s1_long_inittext.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s1_ret.sh b/slurm_adastra/scaling/ofa_large_pretrain_s1_ret.sh new file mode 100644 index 0000000000000000000000000000000000000000..d0f1764f7fb24c0a344d4c447707f6091408589f --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s1_ret.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s1_ret +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s1_ret.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s1_ret.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s2.sh b/slurm_adastra/scaling/ofa_large_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..cb23a34051cd120aeb3d52ae965ee407c5218587 --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s2.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s2 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +###SBATCH --gpus=128 +#SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s2.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s2_long.sh b/slurm_adastra/scaling/ofa_large_pretrain_s2_long.sh new file mode 100644 index 0000000000000000000000000000000000000000..4ad9670ddc89d5b61604eed1c1b547f77a871332 --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s2_long.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s2_long +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +###SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s2_long.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s2_long.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4.sh b/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..5be7773f6f3953a1d815faa6877c21485c030865 --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s2_long_lr1e4 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +###SBATCH --gpus=128 +#SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s2_long_lr1e4.out +#SBATCH --exclusive +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s2_long_lr1e4.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4_ep50.sh b/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4_ep50.sh new file mode 100644 index 0000000000000000000000000000000000000000..e5d1ef1ac56cf03c02cde994e418c865de5c7404 --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s2_long_lr1e4_ep50.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s2_long_lr1e4_ep50 +#SBATCH --nodes=16 +#SBATCH --ntasks=16 +#SBATCH --gpus=128 +###SBATCH --gpus-per-node=4 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s2_long_lr1e4_ep50.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 16 -n 16 -c 128 --gpus=128 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s2_long_lr1e4_ep50.sh \ No newline at end of file diff --git a/slurm_adastra/scaling/ofa_large_pretrain_s3.sh b/slurm_adastra/scaling/ofa_large_pretrain_s3.sh new file mode 100644 index 0000000000000000000000000000000000000000..0eeac74872e21f63769a4331c4428e41e807c22a --- /dev/null +++ b/slurm_adastra/scaling/ofa_large_pretrain_s3.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_large_pretrain_s3 +#SBATCH --nodes=32 +#SBATCH --ntasks=32 +#SBATCH --gpus=256 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c7s2b1n0,x1004c7s3b0n0,x1004c7s3b1n0,x1004c7s4b0n0 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_large_pretrain_s3.out +#SBATCH --exclusive +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --cpus-per-task=128 + + + +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-* + + +srun -l -N 32 -n 32 -c 128 --gpus=256 --gpu-bind=closest bash pretraining/scaling/ofa_large_pretrain_s3.sh \ No newline at end of file diff --git a/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best.sh b/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..d39b812b6fcc7e4229be1a070d7bbecb98e5d02d --- /dev/null +++ b/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_snli_ve_avg_postratafuse +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_snli_ve_avg_postratafuse.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/eval/eval_snli_ve_base_best.sh + + diff --git a/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best_avg.sh b/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..30200b3f5abb9bad718d784b3fbe11c0a58b7e5c --- /dev/null +++ b/slurm_adastra/snli_ve/eval/eval_snli_ve_base_best_avg.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=eval_snli_ve_base_best_avg_postfuse_snliref +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=1:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_snli_ve_base_best_avg_postfuse_snliref.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/eval/eval_snli_ve_base_best_avg.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofa_base_pretrain_s2.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..88ac4fcab7a7c2f961e748677062ef5e814d3ce7 --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofa_base_pretrain_s2.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofainit_base_pretrain_s2 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofainit_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofa_base_pretrain_s2.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..eadb30fa0440faafa7dd9e9edfd89a7d45605939 --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_hsep1 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_hsep1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_bs16_4.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_bs16_4.sh new file mode 100644 index 0000000000000000000000000000000000000000..2da5984a6d9787ac72b3b0983d23620dc1b902ed --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_bs16_4.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_bs16_4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_bs16_4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_bs16_4.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_el_db.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..6cf9f01b6b102a475f43d073f31b7271f17d3678 --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_el_db.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_el_db +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_el_db.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_lr1e4.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..88105e7dbef33055a1c9f279af64d8f8a1b8018c --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_lr1e4.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_lr1e4 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_lr1e4.sh + + diff --git a/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_shuf.sh b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..f65372f756ad3a38624ff82f07ecb5f63d35cdc1 --- /dev/null +++ b/slurm_adastra/snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_shuf.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +#SBATCH --job-name=snli_ve_ofaplus_base_pretrain_s2_shuf +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --gpus=8 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +####SBATCH --nodelist=x1004c4s2b0n0 +#SBATCH --time=24:00:00 +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/snli_ve_ofaplus_base_pretrain_s2_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + + +rm core-python3* + + +srun -l -N 1 -n 1 -c 128 --gpus=8 bash snli_ve/scaling_best/snli_ve_ofaplus_base_pretrain_s2_shuf.sh + + diff --git a/slurm_adastra/vqa/eval/._eval_okvqa_base_best.sh b/slurm_adastra/vqa/eval/._eval_okvqa_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..4959f11eb08af84c4474e183bd4c91b522ad75d4 Binary files /dev/null and b/slurm_adastra/vqa/eval/._eval_okvqa_base_best.sh differ diff --git a/slurm_adastra/vqa/eval/._eval_vizwiz_base_best.sh b/slurm_adastra/vqa/eval/._eval_vizwiz_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..f93babfe6642f93fd8d283d0ef73a123e5042104 Binary files /dev/null and b/slurm_adastra/vqa/eval/._eval_vizwiz_base_best.sh differ diff --git a/slurm_adastra/vqa/eval/eval_okvqa_base_best.sh b/slurm_adastra/vqa/eval/eval_okvqa_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..0d8f70c9558e5c9234671f70886304ce4bfc0724 --- /dev/null +++ b/slurm_adastra/vqa/eval/eval_okvqa_base_best.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_okvqa_zs_avg_postratafusevanilla +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_okvqa_zs_avg_postratafusevanilla.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/eval_okvqa_base_best.sh + + diff --git a/slurm_adastra/vqa/eval/eval_vizwiz_base_best.sh b/slurm_adastra/vqa/eval/eval_vizwiz_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..76e23b0e955d9429edc4640fd3c3917dad372949 --- /dev/null +++ b/slurm_adastra/vqa/eval/eval_vizwiz_base_best.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_vizwiz_zs_avg_postratafuse +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_vizwiz_zs_avg_postratafuse.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/eval_vizwiz_base_best.sh + + diff --git a/slurm_adastra/vqa/eval/eval_vqa_base_best.sh b/slurm_adastra/vqa/eval/eval_vqa_base_best.sh new file mode 100644 index 0000000000000000000000000000000000000000..20347caccc04e46025e9385b044d0e48ad247279 --- /dev/null +++ b/slurm_adastra/vqa/eval/eval_vqa_base_best.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_vqa_ofaplus_s1_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_vqa_ofaplus_s1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/eval_vqa_base_best.sh + + diff --git a/slurm_adastra/vqa/eval/eval_vqa_base_best_avg.sh b/slurm_adastra/vqa/eval/eval_vqa_base_best_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..a668bd3e4e5a87ab8513dc3285de709e148decc1 --- /dev/null +++ b/slurm_adastra/vqa/eval/eval_vqa_base_best_avg.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_vqa_base_best_avg_postfuse_vqacap +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_vqa_base_best_avg_postfuse_vqacap.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/eval_vqa_base_best_avg.sh + + diff --git a/slurm_adastra/vqa/eval/t.sh b/slurm_adastra/vqa/eval/t.sh new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/slurm_adastra/vqa/eval/video/eval_video_qa.sh b/slurm_adastra/vqa/eval/video/eval_video_qa.sh new file mode 100644 index 0000000000000000000000000000000000000000..0e257d5d6b9f62ceec0bbe85d57f8ddf04b9a711 --- /dev/null +++ b/slurm_adastra/vqa/eval/video/eval_video_qa.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_vqa_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_vqa_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_hs_prevout.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/video/eval_video_qa.sh + + diff --git a/slurm_adastra/vqa/eval/video/eval_video_qa_avg.sh b/slurm_adastra/vqa/eval/video/eval_video_qa_avg.sh new file mode 100644 index 0000000000000000000000000000000000000000..0956e3f86078e63e999d0e86df07a09ee1c88468 --- /dev/null +++ b/slurm_adastra/vqa/eval/video/eval_video_qa_avg.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_vqa_base_best_avg_vid_vqacap_prevout +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=2:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_vqa_base_best_avg_vid_vqacap_prevout.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/video/eval_video_qa_avg.sh + + diff --git a/slurm_adastra/vqa/eval/video/eval_video_qa_msvd.sh b/slurm_adastra/vqa/eval/video/eval_video_qa_msvd.sh new file mode 100644 index 0000000000000000000000000000000000000000..34dbef6bc99edaa01874d4c378f3c1abc48bf0c1 --- /dev/null +++ b/slurm_adastra/vqa/eval/video/eval_video_qa_msvd.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=eval_video_vqa_msvd_ofaplus_base_pretrain_s2_hsep1_shuf_el_db +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/eval_video_vqa_msvd_ofaplus_base_pretrain_s2_hsep1_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/eval/video/eval_video_qa_msvd.sh + + diff --git a/slurm_adastra/vqa/scaling/video/video_vqa_ofa_base_pretrain_s2.sh b/slurm_adastra/vqa/scaling/video/video_vqa_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..53d790549233444c926a7d0af3afdcef72cdffc6 --- /dev/null +++ b/slurm_adastra/vqa/scaling/video/video_vqa_ofa_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_video_vqa_ofa_base_pretrain_s2_testep8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_video_vqa_ofa_base_pretrain_s2_testep8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling/video/video_vqa_ofa_base_pretrain_s2.sh + + diff --git a/slurm_adastra/vqa/scaling/vqa_ofa_base_pretrain_s2.sh b/slurm_adastra/vqa/scaling/vqa_ofa_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..fbd88ab0f387452ef45708386e992a09c82447c5 --- /dev/null +++ b/slurm_adastra/vqa/scaling/vqa_ofa_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_testep8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=1:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofa_base_pretrain_s2_long_lr1e4_50ep_nolsdata_testep8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling/vqa_ofa_base_pretrain_s2.sh + + diff --git a/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s1_onlylinear.sh b/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..834f4ce5b5b3e6a509264a3efa2c1070b125ae31 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_s1_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_s1_onlylinear_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/onlylinear/video_vqa_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s2_onlylinear.sh b/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..6f9603630ed3461be4d53caee3b3504ace1bf283 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/onlylinear/video_vqa_ofaplus_s2_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_s2_onlylinear_lr1e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_s2_onlylinear_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/onlylinear/video_vqa_ofaplus_s2_onlylinear.sh + + diff --git a/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s1_onlylinear.sh b/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s1_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..47e614f090593eb5d0bb6a7af721da50650094a9 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s1_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_s1_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_s1_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/onlylinear/vqa_ofaplus_s1_onlylinear.sh + + diff --git a/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s2_onlylinear.sh b/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s2_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..c7943765b0576503940e1b6a91afe72e8626e38e --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/onlylinear/vqa_ofaplus_s2_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_s2_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_s2_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/onlylinear/vqa_ofaplus_s2_onlylinear.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/t.sh b/slurm_adastra/vqa/scaling_best/video/msvd/t.sh new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2.sh b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..7484ce969d099fb7fc4463f784e960b2dbd7624d --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_msvd_ofaplus_base_pretrain_s2 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_msvd_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el.sh b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el.sh new file mode 100644 index 0000000000000000000000000000000000000000..d4724bbf3870e54c055749dbaaafd4eaf1bee580 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_msvd_ofaplus_base_pretrain_s2_el +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_msvd_ofaplus_base_pretrain_s2_el.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db.sh b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..1f1ebd21dea75bca0f7454ebd6888193197e193f --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_msvd_ofaplus_base_pretrain_s2_hsep1_el_db +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_msvd_ofaplus_base_pretrain_s2_hsep1_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da.sh b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..dfb2ba41ebfafe401a61bcd7d965e3f935dc1a39 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_db_da.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb.sh b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb.sh new file mode 100644 index 0000000000000000000000000000000000000000..94327ca39ba3fbc23825467dafaace68ab335453 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/msvd/video_vqa_msvd_ofaplus_base_pretrain_s2_el_nodb.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..ba78d336d4557f987ec82287c9118ba4c42cf9e1 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_f16.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_f16.sh new file mode 100644 index 0000000000000000000000000000000000000000..d6e7325621669b0091c36f30fdbeedd7c0c5bfc8 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_f16.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_f16 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_f16.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_f16.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_lr5e5.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_lr5e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..d5ee1509fbf97c662e981cd2e525bb7abffacafc --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_lr5e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_lr5e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_lr5e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_lr5e5.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..0fcb49d8080f35b20b6b2d10ba276cc17f9fbbdc --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_hsep1_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_da.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_da.sh new file mode 100644 index 0000000000000000000000000000000000000000..ca750227b04e551f323749363692d8db8a7cdbe8 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_da.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_hs_shuf_el_db_da +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_hs_shuf_el_db_da.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_da.sh + + diff --git a/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema.sh b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema.sh new file mode 100644 index 0000000000000000000000000000000000000000..89de228da007a38e31ca5ffaa6fe3f236422f75b --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/video/video_vqa_ofaplus_base_pretrain_s2_shuf_el_db_noema.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofa_base_pretrain_s2_bs16_lr1e4_shuf.sh b/slurm_adastra/vqa/scaling_best/vqa_ofa_base_pretrain_s2_bs16_lr1e4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..abc6f222315534b98e5b28d8c0ebf263af8a4ec4 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofa_base_pretrain_s2_bs16_lr1e4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofainit_base_pretrain_s2_bs16_lr1e4_shuf +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofainit_base_pretrain_s2_bs16_lr1e4_shuf.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofa_base_pretrain_s2_bs16_lr1e4_shuf.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2.sh new file mode 100644 index 0000000000000000000000000000000000000000..c08849ed93f27d629fe024c9d4938c0bbec7aba2 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16.sh new file mode 100644 index 0000000000000000000000000000000000000000..3dfc3b4c487282e55cfa3a6aa3a5f9cd6fc4e272 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..b4e8803edffda6ccf3dd29cce492c001607b3fd8 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hsep1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db.sh new file mode 100644 index 0000000000000000000000000000000000000000..3aa6ae9cc15ab063f418ee017c61d8786f97a16a --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_hs_bs16_lr1e4_shuf_el_db +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_hs_bs16_lr1e4_shuf_el_db.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw.sh new file mode 100644 index 0000000000000000000000000000000000000000..bff00702a03881858ab34d860e4b8f6e03dfd8ea --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_el_db_nodw.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..9e072174ae3b555f854686e4c5ea4908b544cc6d --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_bs16_lr1e4_shuf_hs_lr3e4.sh + + diff --git a/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_lr1e4.sh b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..0150c0f4cf1bc511902c87a4d49af77645ec2ab4 --- /dev/null +++ b/slurm_adastra/vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=vqa_ofaplus_base_pretrain_s2_lr1e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/vqa_ofaplus_base_pretrain_s2_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/scaling_best/vqa_ofaplus_base_pretrain_s2_lr1e4.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans.sh new file mode 100644 index 0000000000000000000000000000000000000000..95eb27e543b43ff3fc9454e9e4978a76af318fb5 --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_16f_vids2_lr4_nosample_hres_longt2_bs8_1kans.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..9b637468adb91f011f1ed1ea338f24edb61fe229 --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..5d612bd0cabfcb6dd50a96cd91440b0907124a2f --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc.sh new file mode 100644 index 0000000000000000000000000000000000000000..57ec106f1f3a85f0c130a94791be1f92ec7cdfa4 --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e4_freezeenc.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5.sh new file mode 100644 index 0000000000000000000000000000000000000000..c08d9fb18c11202ac12610111725412d40486998 --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr1e5.sh + + diff --git a/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4.sh b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..3cc07554bf8c459558f70c72ff65dda2f42b3a5d --- /dev/null +++ b/slurm_adastra/vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=10:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/msvd/ofa_mini_msvd_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_1kans_lr5e4.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..286c5be50c0a57495fb37cdd77cb2bcba400ee00 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_det_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..6dc044d285efa5e43d43d5216c7028fc139f96fd --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_ground_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..af8d7334acb7ab24c726eee69d5a4e2084d8b6a0 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_itdata_cc12m7m_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..b4e893898d5e669fc2daa5b261f7cd56fdac883c --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_qa_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..aed3f597ece321e33eb2a16bf223cdc894c6ea16 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_text_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh b/slurm_adastra/vqa/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..d284603a9a6318468798dcd4f0e7f49bc890b87d --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_caption_stage_1_pretrain_bart_allresnet_pretraintext_onlylinear.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..fa62c6612b1d4c451b5e14450f459c3fa05dc5ee --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..d29e19dea5439ea1d79031e73d4f7c7c28a83449 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_4f_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_4f_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_4f_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..0be53659940f0d11fad40e0a3a90d2c6fc4d2017 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_lr4_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..93183617c3edfccbe819c85a2f859c5db58cd1f8 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_4f_vids2_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_4f_vids2_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_4f_vids2_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..3115c4f33dc16796eeaa623f7c905c113fcc701f --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_8f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..93c90f5695852daf903e16edd75ce53b93563507 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..de29b1bc45f4536e0309e471f568abfb93a5e680 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch_multinodes_nobart.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_hres_scratch.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..aafe2614b59ba782f22eaf7934a498da0141cefa --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_lr4_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..a123ce237de37f5e1ead5e8d0605498283cc99e4 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample_multinodes_4k.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_4f_vids2_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..5ea4f9fc91bc5343b5971b626c76ea75c840b958 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..5b2e8ebbfa089a5483263afd847fbe5c233aed34 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f216f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..3d3d4ca92439e3c09dab4314a154d18774913462 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_negcapvid_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..d8ea5e22356889af60dd251e99e308b1c07a2fd6 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_multinodes +#SBATCH --nodes=2 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..591ec4d8d1da970763e307e2f1bc4df33e04e120 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt2.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..2eb0237280619a0013d90777c73f701d3c8f03d3 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_longt.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..bb57fedb86fa92b0db701c32e1450a900eb749ab --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..c0ce118f21397d643e6283ef6fded31ca3c801ad --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog1_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..480ba573c606d39b8c647b921f7f3e1b2a305c37 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_res_resnxtvid_init_8f_vids2_lr4_prog2_nosample_hres.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..0396216cc20ef6c8e52c6ec4823f3e90560b54af --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_shared_tformer_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..50b21cd15515a684d76c3d2855e13a85422eb736 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddata_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..d29447aabfc68a1dd413408fb2d43814516eb585 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddata_allres_alls3d_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..c7a614b9a05d2f89f41dcb408f0af75ddc3728d4 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_videp20_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..1339a608fd0ea8b1a3379d3904f3afe0f860857f --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1.sh new file mode 100644 index 0000000000000000000000000000000000000000..db891eb5ed5e31dab45c5e745eddff9e06d4f18a --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_fps1.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..8630fcb86bcc79de3c7982db9d4540edf3d064df --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_lr1e4.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..df9311e268b0a81753a4d0a63b72f8715c2dd33b --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8_onlylinear.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..0b1aa091620bab6a13dd39eed0ebaef4f4ec1944 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_bart_viddatacapqa_allres_bs2k_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..c4aa80de4f31f5d0af901ba6c2532a0bb3bec40a --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_vitb16_hres_enceval_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_vitb16_hres_enceval_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..de4f3cb820007ec3fb4d3e48d65ef86e7c64b7bf --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample_multinodes_2.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..209f0574b0c302242eb1c100b10ebf18eaf93716 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_scratch.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..028847fae1bf96829e24189e704f6775b44f1f05 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_enceval_withcls_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample_multinodes.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample_multinodes.sh new file mode 100644 index 0000000000000000000000000000000000000000..4730b374d716718579923bd208ab9190b57b8c29 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample_multinodes.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample_multinodes +#SBATCH --nodes=4 +#SBATCH --ntasks-per-node=1 +#SBATCH --gpus-per-node=8 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample_multinodes.out +#SBATCH --exclusive +#SBATCH --time=100:00:00 +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun bash vqa/video/ofa_mini_video_vqa_bart_vitb16_hres_unfreeze_nosample.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..be03f7a8457dc24c861145f7c1b8b607886c7939 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_ep20_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_initlmscratch.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_initlmscratch.sh new file mode 100644 index 0000000000000000000000000000000000000000..d71336328ba3d136512496d70efee4df045722d1 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_initlmscratch.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_initlmscratch +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_initlmscratch.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_initlmscratch.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..1301682e6c55d00d52086d3f79eb5332551d9d75 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=18:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear_ep10.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_ep20_onlylinear.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext.sh new file mode 100644 index 0000000000000000000000000000000000000000..3ad89b4d206b104d9d0dce1c8158cbcd4b958f21 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_ep1.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4.sh new file mode 100644 index 0000000000000000000000000000000000000000..49fc88dc3b4c0ab24be25a926761b08fe8cb7739 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnet_inittext_onlylinear_lr1e4.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20.sh new file mode 100644 index 0000000000000000000000000000000000000000..b2e903bf7a02c1a27cc466702d0d0c4e65f6160c --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_ofa_mini_pretrain_bart_allresnt_ep20.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..48dbbf32420d29ee5f5c91b600df01095ef849af --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_onlyvideo_viddatacapqa_ep20_nosample_hres_longt2_bs8.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear.sh new file mode 100644 index 0000000000000000000000000000000000000000..61dc6e9f6c0e16003cb43015f3e8de869b9bff2e --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear_lr1e4.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_pretrain_bart_allresnet_pretraintext_onlylinear.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh new file mode 100644 index 0000000000000000000000000000000000000000..8681ac03a03ad070c4fe485031468d56208ba26e --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_video_audiovcc_s3_viddatacapqa_pretrain_bart_allres_allresnxtvid_allpannc14mel64h200_init_8f_lr4_wav_audioembLN.sh + + diff --git a/slurm_adastra/vqa/video/ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh b/slurm_adastra/vqa/video/ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh new file mode 100644 index 0000000000000000000000000000000000000000..7ccd735d30d9207ec391e4ec291a654bf5289309 --- /dev/null +++ b/slurm_adastra/vqa/video/ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +#SBATCH --job-name=ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8 +#SBATCH --nodes=2 +#SBATCH --ntasks=2 +#SBATCH --gpus=16 +#SBATCH --threads-per-core=2 +#SBATCH --gpu-bind=closest +#SBATCH -C MI250 +#SBATCH -A gda2204 +#SBATCH --time=24:00:00 +#SBATCH --mail-type=END,FAIL +#SBATCH --output=/lus/home/NAT/gda2204/mshukor/logs/slurm/ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.out +#SBATCH --exclusive +#SBATCH --mail-user=mustafa.shukor@isir.upmc.fr + + +cd /lus/home/NAT/gda2204/mshukor/code/ofa_ours/run_scripts +source /lus/home/NAT/gda2204/mshukor/.bashrc + +conda activate main + + +rm core-python3* + + +srun -l -N 2 -n 2 -c 128 --gpus=16 bash vqa/video/ofa_mini_video_vqa_webvid10m_bart_viddatacapqa_allres_allresnxtvid_init_8f_vids2_lr4_nosample_hres_longt2_bs8.sh + + diff --git a/spaces.md b/spaces.md new file mode 100644 index 0000000000000000000000000000000000000000..129c968e4014c6af121575b3885a4c0844e75ffc --- /dev/null +++ b/spaces.md @@ -0,0 +1,8 @@ +# Spaces +To provide better experience, we plan to build demos for our OFA models on Huggingface Spaces. Below we provide links to the demos. Have fun! + +* Generic Interface: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/OFA-Sys/OFA-Generic_Interface) +* Text-to-Image Generation: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/OFA-Sys/OFA-Text2Image_Generation) +* Image Captioning: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/OFA-Sys/OFA-Image_Caption) +* Referring Expression Comprehension: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/OFA-Sys/OFA-Visual_Grounding) +* Visual Question Answering: [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/OFA-Sys/OFA-Visual_Question_Answering) diff --git a/tasks/.ipynb_checkpoints/__init__-checkpoint.py b/tasks/.ipynb_checkpoints/__init__-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..4955475f7cf934ee5f41474ce96923b06224f38c --- /dev/null +++ b/tasks/.ipynb_checkpoints/__init__-checkpoint.py @@ -0,0 +1,6 @@ +from .cv_tasks import * +from .mm_tasks import * +from .nlg_tasks import * +from .nlu_tasks import * +from .pretrain_tasks import * +from .ofa_task import OFATask \ No newline at end of file diff --git a/tasks/.ipynb_checkpoints/ofa_task-checkpoint.py b/tasks/.ipynb_checkpoints/ofa_task-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..c40ae870e1449f80b511a2621e0f1048d924aa48 --- /dev/null +++ b/tasks/.ipynb_checkpoints/ofa_task-checkpoint.py @@ -0,0 +1,353 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import logging +import os +import math +import torch +from typing import Dict, Optional + +from fairseq import search +from fairseq.data import FairseqDataset, iterators +from fairseq.optim.amp_optimizer import AMPOptimizer +from fairseq.dataclass import FairseqDataclass +from fairseq.tasks import FairseqTask, register_task +from omegaconf import DictConfig + + +logger = logging.getLogger(__name__) + + +@dataclass +class OFAConfig(FairseqDataclass): + data: Optional[str] = field( + default=None, + metadata={ + "help": "comma separated path to data list, will be iterated upon during epochs " + "in round-robin manner; valid data are always in the last" + }, + ) + selected_cols: Optional[str] = field( + default=None, + metadata={"help": "selected cols"}, + ) + bpe: Optional[str] = field( + default='gpt2', + metadata={"help": "which bpe to use"}, + ) + bpe_dir: Optional[str] = field( + default=None, + metadata={"help": "bpe dir"}, + ) + max_source_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the source sequence"} + ) + max_target_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the target sequence"} + ) + max_src_length: int = field( + default=128, metadata={"help": "the maximum src sequence length"} + ) + max_tgt_length: int = field( + default=30, metadata={"help": "the maximum target sequence length"} + ) + + code_dict_size: int = field( + default=8192, metadata={"help": "code dict size"} + ) + patch_image_size: int = field( + default=480, metadata={"help": "patch image size"} + ) + orig_patch_image_size: int = field( + default=256, metadata={"help": "patch image size"} + ) + num_bins: int = field( + default=1000, metadata={"help": "number of quantization bins"} + ) + + imagenet_default_mean_and_std: bool = field( + default=False, + metadata={"help": "imagenet normalize"}, + ) + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + + +@register_task("ofa", dataclass=OFAConfig) +class OFATask(FairseqTask): + def __init__(self, cfg: OFAConfig, src_dict, tgt_dict): + super().__init__(cfg) + self.src_dict = src_dict + self.tgt_dict = tgt_dict + + @classmethod + def setup_task(cls, cfg: DictConfig, **kwargs): + """Setup the task.""" + + # load dictionaries + src_dict = cls.load_dictionary( + os.path.join(cfg.bpe_dir, "dict.txt") + ) + tgt_dict = cls.load_dictionary( + os.path.join(cfg.bpe_dir, "dict.txt") + ) + src_dict.add_symbol("<mask>") + tgt_dict.add_symbol("<mask>") + for i in range(cfg.code_dict_size): + src_dict.add_symbol("<code_{}>".format(i)) + tgt_dict.add_symbol("<code_{}>".format(i)) + # quantization + for i in range(cfg.num_bins): + src_dict.add_symbol("<bin_{}>".format(i)) + tgt_dict.add_symbol("<bin_{}>".format(i)) + + logger.info("source dictionary: {} types".format(len(src_dict))) + logger.info("target dictionary: {} types".format(len(tgt_dict))) + return cls(cfg, src_dict, tgt_dict) + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + assert isinstance(dataset, FairseqDataset) + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # create mini-batches with given size constraints + batch_sampler = [ + [j for j in range(i, min(i + max_sentences, len(dataset)))] + for i in range(0, len(dataset), max_sentences) + ] + total_row_count = dataset.dataset.get_total_row_count() + num_batches = math.ceil(math.ceil(total_row_count / num_shards) / max_sentences) + if len(batch_sampler) < num_batches: + batch_sampler.append([]) + + # return a reusable, sharded iterator + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=batch_sampler, + seed=seed, + num_shards=1, + shard_id=0, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size + ) + + return epoch_iter + + def build_model(self, cfg: FairseqDataclass): + model = super().build_model(cfg) + if self.cfg.bpe == 'bert': + bpe_dict = { + "_name": "bert", + "bpe_vocab_file": os.path.join(self.cfg.bpe_dir, "vocab.txt"), + "bpe_cased": False + } + bpe_dict = DictConfig(bpe_dict) + self.bpe = self.build_bpe(bpe_dict) + else: + bpe_dict = { + "_name": "gpt2", + "gpt2_encoder_json": os.path.join(self.cfg.bpe_dir, "encoder.json"), + "gpt2_vocab_bpe": os.path.join(self.cfg.bpe_dir, "vocab.bpe") + } + bpe_dict = DictConfig(bpe_dict) + self.bpe = self.build_bpe(bpe_dict) + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + """ + Build a :class:`~fairseq.SequenceGenerator` instance for this + task. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + args (fairseq.dataclass.configs.GenerationConfig): + configuration object (dataclass) for generation + extra_gen_cls_kwargs (Dict[str, Any]): extra options to pass + through to SequenceGenerator + prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]): + If provided, this function constrains the beam search to + allowed tokens only at each step. The provided function + should take 2 arguments: the batch ID (`batch_id: int`) + and a unidimensional tensor of token ids (`inputs_ids: + torch.Tensor`). It has to return a `List[int]` with the + allowed tokens for the next generation step conditioned + on the previously generated tokens (`inputs_ids`) and + the batch ID (`batch_id`). This argument is useful for + constrained generation conditioned on the prefix, as + described in "Autoregressive Entity Retrieval" + (https://arxiv.org/abs/2010.00904) and + https://github.com/facebookresearch/GENRE. + """ + if getattr(args, "score_reference", False): + from fairseq.sequence_scorer import SequenceScorer + + return SequenceScorer( + self.target_dictionary, + compute_alignment=getattr(args, "print_alignment", False), + ) + + from fairseq.sequence_generator import ( + # SequenceGenerator, + SequenceGeneratorWithAlignment, + ) + from models.sequence_generator import SequenceGenerator + + # Choose search strategy. Defaults to Beam Search. + sampling = getattr(args, "sampling", False) + sampling_topk = getattr(args, "sampling_topk", -1) + sampling_topp = getattr(args, "sampling_topp", -1.0) + diverse_beam_groups = getattr(args, "diverse_beam_groups", -1) + diverse_beam_strength = getattr(args, "diverse_beam_strength", 0.5) + match_source_len = getattr(args, "match_source_len", False) + diversity_rate = getattr(args, "diversity_rate", -1) + constrained = getattr(args, "constraints", False) + if prefix_allowed_tokens_fn is None: + prefix_allowed_tokens_fn = getattr(args, "prefix_allowed_tokens_fn", None) + if ( + sum( + int(cond) + for cond in [ + sampling, + diverse_beam_groups > 0, + match_source_len, + diversity_rate > 0, + ] + ) + > 1 + ): + raise ValueError("Provided Search parameters are mutually exclusive.") + assert sampling_topk < 0 or sampling, "--sampling-topk requires --sampling" + assert sampling_topp < 0 or sampling, "--sampling-topp requires --sampling" + + if sampling: + search_strategy = search.Sampling( + self.target_dictionary, sampling_topk, sampling_topp + ) + elif diverse_beam_groups > 0: + search_strategy = search.DiverseBeamSearch( + self.target_dictionary, diverse_beam_groups, diverse_beam_strength + ) + elif match_source_len: + # this is useful for tagging applications where the output + # length should match the input length, so we hardcode the + # length constraints for simplicity + search_strategy = search.LengthConstrainedBeamSearch( + self.target_dictionary, + min_len_a=1, + min_len_b=0, + max_len_a=1, + max_len_b=0, + ) + elif diversity_rate > -1: + search_strategy = search.DiverseSiblingsSearch( + self.target_dictionary, diversity_rate + ) + elif constrained: + search_strategy = search.LexicallyConstrainedBeamSearch( + self.target_dictionary, args.constraints + ) + elif prefix_allowed_tokens_fn: + search_strategy = search.PrefixConstrainedBeamSearch( + self.target_dictionary, prefix_allowed_tokens_fn + ) + else: + search_strategy = search.BeamSearch(self.target_dictionary) + + extra_gen_cls_kwargs = extra_gen_cls_kwargs or {} + if seq_gen_cls is None: + if getattr(args, "print_alignment", False): + seq_gen_cls = SequenceGeneratorWithAlignment + extra_gen_cls_kwargs["print_alignment"] = args.print_alignment + else: + seq_gen_cls = SequenceGenerator + + return seq_gen_cls( + models, + self.target_dictionary, + beam_size=getattr(args, "beam", 5), + max_len_a=getattr(args, "max_len_a", 0), + max_len_b=getattr(args, "max_len_b", 200), + min_len=getattr(args, "min_len", 1), + normalize_scores=(not getattr(args, "unnormalized", False)), + len_penalty=getattr(args, "lenpen", 1), + unk_penalty=getattr(args, "unkpen", 0), + temperature=getattr(args, "temperature", 1.0), + match_source_len=getattr(args, "match_source_len", False), + no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0), + search_strategy=search_strategy, + constraint_range=self.cfg.constraint_range, + **extra_gen_cls_kwargs, + ) + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False, **extra_kwargs + ): + """ + Do forward and backward, and return the loss as computed by *criterion* + for the given *model* and *sample*. + + Args: + sample (dict): the mini-batch. The format is defined by the + :class:`~fairseq.data.FairseqDataset`. + model (~fairseq.models.BaseFairseqModel): the model + criterion (~fairseq.criterions.FairseqCriterion): the criterion + optimizer (~fairseq.optim.FairseqOptimizer): the optimizer + update_num (int): the current update + ignore_grad (bool): multiply loss by 0 if this is set to True + + Returns: + tuple: + - the loss + - the sample size, which is used as the denominator for the + gradient + - logging outputs to display while training + """ + model.train() + model.set_num_updates(update_num) + with torch.autograd.profiler.record_function("forward"): + with torch.cuda.amp.autocast(enabled=(isinstance(optimizer, AMPOptimizer))): + loss, sample_size, logging_output = criterion(model, sample, update_num=update_num) + if ignore_grad: + loss *= 0 + with torch.autograd.profiler.record_function("backward"): + optimizer.backward(loss) + return loss, sample_size, logging_output + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.cfg.max_source_positions, self.cfg.max_target_positions) + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.src_dict + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary`.""" + return self.tgt_dict diff --git a/tasks/__init__.py b/tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9a5c6fd1539d5cbae069a72c9c03bb23d8c7c5f1 --- /dev/null +++ b/tasks/__init__.py @@ -0,0 +1,4 @@ +from .mm_tasks import * +from .pretrain_tasks import * +from .ofa_task import OFATask + diff --git a/tasks/__pycache__/__init__.cpython-37.pyc b/tasks/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff2b699e6b91a1087aaec4348aca707b3f272297 Binary files /dev/null and b/tasks/__pycache__/__init__.cpython-37.pyc differ diff --git a/tasks/__pycache__/__init__.cpython-38.pyc b/tasks/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a7d165c76566b43a87c19c4b76da0c55431ec65 Binary files /dev/null and b/tasks/__pycache__/__init__.cpython-38.pyc differ diff --git a/tasks/__pycache__/__init__.cpython-39.pyc b/tasks/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..506a5464a687e16af3b215efc0f5a6f3cbb0cbf9 Binary files /dev/null and b/tasks/__pycache__/__init__.cpython-39.pyc differ diff --git a/tasks/__pycache__/ofa_task.cpython-37.pyc b/tasks/__pycache__/ofa_task.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a38a41495ff9c36ccdd10a63c6e1327e6a2e618 Binary files /dev/null and b/tasks/__pycache__/ofa_task.cpython-37.pyc differ diff --git a/tasks/__pycache__/ofa_task.cpython-38.pyc b/tasks/__pycache__/ofa_task.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7f8072c65fe60d40b58485e62e635c5c7881b17 Binary files /dev/null and b/tasks/__pycache__/ofa_task.cpython-38.pyc differ diff --git a/tasks/__pycache__/ofa_task.cpython-39.pyc b/tasks/__pycache__/ofa_task.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dfa8da70481961dfbecd479d999f8495ec7f9161 Binary files /dev/null and b/tasks/__pycache__/ofa_task.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__init__.py b/tasks/mm_tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c83f075d7d878a2d27cf63ce1bda630f969c8c3b --- /dev/null +++ b/tasks/mm_tasks/__init__.py @@ -0,0 +1,8 @@ +from .caption import CaptionTask +from .image_gen import ImageGenTask +from .refcoco import RefcocoTask +from .snli_ve import SnliVeTask +from .vqa_gen import VqaGenTask +from .video_vqa_gen import VidVqaGenTask +from .video_caption import VidCaptionTask +from .audio_caption import AudCaptionTask \ No newline at end of file diff --git a/tasks/mm_tasks/__pycache__/__init__.cpython-37.pyc b/tasks/mm_tasks/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d8eda4769148c53b3ba1474253a3e794277e6a8 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/__init__.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/__init__.cpython-38.pyc b/tasks/mm_tasks/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24bd0a606e12d2c3a21cd56f0609de15530f301e Binary files /dev/null and b/tasks/mm_tasks/__pycache__/__init__.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/__init__.cpython-39.pyc b/tasks/mm_tasks/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c2bd9d3682fc0bb158780017f1cb165b5b51103 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/__init__.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/audio_caption.cpython-37.pyc b/tasks/mm_tasks/__pycache__/audio_caption.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0266f489b2638aaea30fdc51723f22d09430097f Binary files /dev/null and b/tasks/mm_tasks/__pycache__/audio_caption.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/audio_caption.cpython-39.pyc b/tasks/mm_tasks/__pycache__/audio_caption.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e65a216f9b41132b8071239a365cc0dc1be72b8d Binary files /dev/null and b/tasks/mm_tasks/__pycache__/audio_caption.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/caption.cpython-37.pyc b/tasks/mm_tasks/__pycache__/caption.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8832838ea0bf3e299e97bfbbeca2012e68778478 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/caption.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/caption.cpython-38.pyc b/tasks/mm_tasks/__pycache__/caption.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c38d708d62c7cd852019ce4d801b27d09ab5ea25 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/caption.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/caption.cpython-39.pyc b/tasks/mm_tasks/__pycache__/caption.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc67978e46718a0a46ecb5a8fb1fdf67da602798 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/caption.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/image_gen.cpython-37.pyc b/tasks/mm_tasks/__pycache__/image_gen.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff9223471ef9f5cbfeaa33c5e419bc66f4607f49 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/image_gen.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/image_gen.cpython-38.pyc b/tasks/mm_tasks/__pycache__/image_gen.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af5a3687f63acdba077f1f19d3afc5feabcfeede Binary files /dev/null and b/tasks/mm_tasks/__pycache__/image_gen.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/image_gen.cpython-39.pyc b/tasks/mm_tasks/__pycache__/image_gen.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc6fa5de88569f376e133b4b8f56b8762380b67d Binary files /dev/null and b/tasks/mm_tasks/__pycache__/image_gen.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/refcoco.cpython-37.pyc b/tasks/mm_tasks/__pycache__/refcoco.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb14c5d3838c1ff7bf62fb25ee47189809d16b57 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/refcoco.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/refcoco.cpython-38.pyc b/tasks/mm_tasks/__pycache__/refcoco.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..94b4d21464a886d689c63504cb4af76bbff7b0e7 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/refcoco.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/refcoco.cpython-39.pyc b/tasks/mm_tasks/__pycache__/refcoco.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..014f2a6dc9619e36ba00cfa0cb211b0a99e41615 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/refcoco.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/snli_ve.cpython-37.pyc b/tasks/mm_tasks/__pycache__/snli_ve.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dd0d7ca264029afd89434a6bfe7c7c14aabf3a6 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/snli_ve.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/snli_ve.cpython-38.pyc b/tasks/mm_tasks/__pycache__/snli_ve.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..706a77bb11e3f8521b6d35c3ed85df4a545ed1de Binary files /dev/null and b/tasks/mm_tasks/__pycache__/snli_ve.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/snli_ve.cpython-39.pyc b/tasks/mm_tasks/__pycache__/snli_ve.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..784f2757ffb11c7846e83e1d361fc62e90eba7a7 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/snli_ve.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/video_caption.cpython-37.pyc b/tasks/mm_tasks/__pycache__/video_caption.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..789a6c5b5479c8f2934e4ba833cc525025f74a32 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/video_caption.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/video_caption.cpython-39.pyc b/tasks/mm_tasks/__pycache__/video_caption.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79ef31a7b381b96d03ac42a9e1f9752390953683 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/video_caption.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-37.pyc b/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b6a3772a8e9b320296666661e99666d8de5ec88 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-39.pyc b/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c77ca2f4146f15d63bbea6a4d77d7746198f3b0 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/video_vqa_gen.cpython-39.pyc differ diff --git a/tasks/mm_tasks/__pycache__/vqa_gen.cpython-37.pyc b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d02df5932e073dc392c85f5cc222a3628b7be2f Binary files /dev/null and b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-37.pyc differ diff --git a/tasks/mm_tasks/__pycache__/vqa_gen.cpython-38.pyc b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..604f4d513b41708a4805261e0bfe3378f3d4f5cc Binary files /dev/null and b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-38.pyc differ diff --git a/tasks/mm_tasks/__pycache__/vqa_gen.cpython-39.pyc b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4799e46c6edb23bd685cc6959e069c9b1eaa5961 Binary files /dev/null and b/tasks/mm_tasks/__pycache__/vqa_gen.cpython-39.pyc differ diff --git a/tasks/mm_tasks/audio_caption.py b/tasks/mm_tasks/audio_caption.py new file mode 100644 index 0000000000000000000000000000000000000000..e908c9f99b0350948a17c29980ccc3dc43aa43f9 --- /dev/null +++ b/tasks/mm_tasks/audio_caption.py @@ -0,0 +1,267 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +from typing import Optional +from argparse import Namespace +from itertools import zip_longest +from collections import OrderedDict + +import numpy as np +import sacrebleu +import string +from fairseq import metrics, utils +from fairseq.tasks import register_task + +from tasks.ofa_task import OFATask, OFAConfig +from data.mm_data.audio_caption_dataset import CaptionDataset +from data.file_dataset import FileDataset +from utils.cider.pyciderevalcap.ciderD.ciderD import CiderD + +from data.audio_utils import AUDIO_CFG, dotdict, Map + + +EVAL_BLEU_ORDER = 4 + +logger = logging.getLogger(__name__) + + +@dataclass +class CaptionConfig(OFAConfig): + eval_bleu: bool = field( + default=False, metadata={"help": "evaluation with BLEU scores"} + ) + eval_cider: bool = field( + default=False, metadata={"help": "evaluation with CIDEr scores"} + ) + eval_args: Optional[str] = field( + default='{}', + metadata={ + "help": 'generation args for BLUE or CIDEr scoring, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + eval_print_samples: bool = field( + default=False, metadata={"help": "print sample generations during validation"} + ) + eval_cider_cached_tokens: Optional[str] = field( + default=None, + metadata={"help": "path to cached cPickle file used to calculate CIDEr scores"}, + ) + + scst: bool = field( + default=False, metadata={"help": "Self-critical sequence training"} + ) + scst_args: str = field( + default='{}', + metadata={ + "help": 'generation args for Self-critical sequence training, as JSON string' + }, + ) + +AUDIO_CFG +@register_task("audio_caption", dataclass=CaptionConfig) +class AudCaptionTask(OFATask): + def __init__(self, cfg: CaptionConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + audio_cfg = self.cfg.audio_cfg + audio_cfg = audio_cfg if audio_cfg is not None else AUDIO_CFG + audio_cfg = dotdict(audio_cfg) + + + self.datasets[split] = CaptionDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + scst=getattr(self.cfg, 'scst', False), + image_dir=self.cfg.image_dir, + num_frames=self.cfg.num_frames, + audio_cfg=audio_cfg, + max_audio_len = self.cfg.max_audio_len, + sample_rate=self.cfg.sample_rate, + audio_sample_rate=self.cfg.audio_sample_rate, + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + print("task") + if self.cfg.eval_bleu or self.cfg.eval_cider: + gen_args = json.loads(self.cfg.eval_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + if self.cfg.eval_cider: + self.CiderD_scorer = CiderD(df=self.cfg.eval_cider_cached_tokens) + if self.cfg.scst: + scst_args = json.loads(self.cfg.scst_args) + self.scst_generator = self.build_generator( + [model], Namespace(**scst_args) + ) + + return model + + def _calculate_cider_scores(self, gen_res, gt_res): + ''' + gen_res: generated captions, list of str + gt_idx: list of int, of the same length as gen_res + gt_res: ground truth captions, list of list of str. + gen_res[i] corresponds to gt_res[gt_idx[i]] + Each image can have multiple ground truth captions + ''' + gen_res_size = len(gen_res) + + res = OrderedDict() + for i in range(gen_res_size): + res[i] = [gen_res[i].strip()] + + gts = OrderedDict() + gt_res_ = [ + [gt_res[i][j].strip() for j in range(len(gt_res[i]))] + for i in range(len(gt_res)) + ] + for i in range(gen_res_size): + gts[i] = gt_res_[i] + + res_ = [{'image_id': i, 'caption': res[i]} for i in range(len(res))] + _, scores = self.CiderD_scorer.compute_score(gts, res_) + return scores + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = criterion(model, sample) + + model.eval() + if self.cfg.eval_bleu or self.cfg.eval_cider: + hyps, refs = self._inference(self.sequence_generator, sample, model) + if self.cfg.eval_bleu: + if self.cfg.eval_tokenized_bleu: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs)), tokenize="none") + else: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs))) + logging_output["_bleu_sys_len"] = bleu.sys_len + logging_output["_bleu_ref_len"] = bleu.ref_len + # we split counts into separate entries so that they can be + # summed efficiently across workers using fast-stat-sync + assert len(bleu.counts) == EVAL_BLEU_ORDER + for i in range(EVAL_BLEU_ORDER): + logging_output["_bleu_counts_" + str(i)] = bleu.counts[i] + logging_output["_bleu_totals_" + str(i)] = bleu.totals[i] + if self.cfg.eval_cider: + scores = self._calculate_cider_scores(hyps, refs) + logging_output["_cider_score_sum"] = scores.sum() + logging_output["_cider_cnt"] = scores.size + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + if self.cfg.eval_bleu: + counts, totals = [], [] + for i in range(EVAL_BLEU_ORDER): + counts.append(sum_logs("_bleu_counts_" + str(i))) + totals.append(sum_logs("_bleu_totals_" + str(i))) + + if max(totals) > 0: + # log counts as numpy arrays -- log_scalar will sum them correctly + metrics.log_scalar("_bleu_counts", np.array(counts)) + metrics.log_scalar("_bleu_totals", np.array(totals)) + metrics.log_scalar("_bleu_sys_len", sum_logs("_bleu_sys_len")) + metrics.log_scalar("_bleu_ref_len", sum_logs("_bleu_ref_len")) + + def compute_bleu(meters): + import inspect + import sacrebleu + + fn_sig = inspect.getfullargspec(sacrebleu.compute_bleu)[0] + if "smooth_method" in fn_sig: + smooth = {"smooth_method": "exp"} + else: + smooth = {"smooth": "exp"} + bleu = sacrebleu.compute_bleu( + correct=meters["_bleu_counts"].sum, + total=meters["_bleu_totals"].sum, + sys_len=meters["_bleu_sys_len"].sum, + ref_len=meters["_bleu_ref_len"].sum, + **smooth + ) + return round(bleu.score, 2) + + metrics.log_derived("bleu", compute_bleu) + + if self.cfg.eval_cider: + def compute_cider(meters): + cider = meters["_cider_score_sum"].sum / meters["_cider_cnt"].sum + cider = cider if isinstance(cider, float) else cider.item() + return round(cider, 3) + + if sum_logs("_cider_cnt") > 0: + metrics.log_scalar("_cider_score_sum", sum_logs("_cider_score_sum")) + metrics.log_scalar("_cider_cnt", sum_logs("_cider_cnt")) + metrics.log_derived("cider", compute_cider) + + def _inference(self, generator, sample, model): + + def decode(toks, escape_unk=False): + s = self.tgt_dict.string( + toks.int().cpu(), + # The default unknown string in fairseq is `<unk>`, but + # this is tokenized by sacrebleu as `< unk >`, inflating + # BLEU scores. Instead, we use a somewhat more verbose + # alternative that is unlikely to appear in the real + # reference, but doesn't get split into multiple tokens. + unk_string=("UNKNOWNTOKENINREF" if escape_unk else "UNKNOWNTOKENINHYP"), + ) + if self.bpe: + s = self.bpe.decode(s) + return s + + gen_out = self.inference_step(generator, [model], sample) + # print('gen_out', gen_out) + hyps, refs = [], [] + transtab = str.maketrans({key: None for key in string.punctuation}) + for i in range(len(gen_out)): + try: + decode_tokens = decode(gen_out[i][0]["tokens"]) + hyps.append(decode_tokens.translate(transtab).strip()) + refs.append( + [ + sent.translate(transtab).strip() + for sent in decode( + utils.strip_pad(sample["target"][i], self.tgt_dict.pad()), + escape_unk=True, # don't count <unk> as matches to the hypo + ).split('&&') + ] + ) + except: + print(sample) + print(gen_out) + if self.cfg.eval_print_samples: + logger.info("example hypothesis: " + hyps[0]) + logger.info("example reference: " + ' && '.join(refs[0])) + + return hyps, refs diff --git a/tasks/mm_tasks/caption.py b/tasks/mm_tasks/caption.py new file mode 100644 index 0000000000000000000000000000000000000000..9a3cf01904c6daedb366c5bda56bb2cf64656479 --- /dev/null +++ b/tasks/mm_tasks/caption.py @@ -0,0 +1,260 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +from typing import Optional +from argparse import Namespace +from itertools import zip_longest +from collections import OrderedDict + +import numpy as np +import sacrebleu +import string +from fairseq import metrics, utils +from fairseq.tasks import register_task + +from tasks.ofa_task import OFATask, OFAConfig +from data.mm_data.caption_dataset import CaptionDataset +from data.file_dataset import FileDataset +from utils.cider.pyciderevalcap.ciderD.ciderD import CiderD + +EVAL_BLEU_ORDER = 4 + +logger = logging.getLogger(__name__) + + +@dataclass +class CaptionConfig(OFAConfig): + eval_bleu: bool = field( + default=False, metadata={"help": "evaluation with BLEU scores"} + ) + eval_cider: bool = field( + default=False, metadata={"help": "evaluation with CIDEr scores"} + ) + eval_args: Optional[str] = field( + default='{}', + metadata={ + "help": 'generation args for BLUE or CIDEr scoring, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + eval_print_samples: bool = field( + default=False, metadata={"help": "print sample generations during validation"} + ) + eval_cider_cached_tokens: Optional[str] = field( + default=None, + metadata={"help": "path to cached cPickle file used to calculate CIDEr scores"}, + ) + + scst: bool = field( + default=False, metadata={"help": "Self-critical sequence training"} + ) + scst_args: str = field( + default='{}', + metadata={ + "help": 'generation args for Self-critical sequence training, as JSON string' + }, + ) + + +@register_task("caption", dataclass=CaptionConfig) +class CaptionTask(OFATask): + def __init__(self, cfg: CaptionConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = CaptionDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + scst=getattr(self.cfg, 'scst', False), + use_dataaug=self.cfg.use_dataaug, + read_from_img_path=self.cfg.read_from_img_path, + image_dir=self.cfg.image_dir, + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + if self.cfg.eval_bleu or self.cfg.eval_cider: + gen_args = json.loads(self.cfg.eval_args) + print(gen_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + if self.cfg.eval_cider: + self.CiderD_scorer = CiderD(df=self.cfg.eval_cider_cached_tokens) + if self.cfg.scst: + scst_args = json.loads(self.cfg.scst_args) + self.scst_generator = self.build_generator( + [model], Namespace(**scst_args) + ) + + return model + + def _calculate_cider_scores(self, gen_res, gt_res): + ''' + gen_res: generated captions, list of str + gt_idx: list of int, of the same length as gen_res + gt_res: ground truth captions, list of list of str. + gen_res[i] corresponds to gt_res[gt_idx[i]] + Each image can have multiple ground truth captions + ''' + gen_res_size = len(gen_res) + + res = OrderedDict() + for i in range(gen_res_size): + res[i] = [gen_res[i].strip()] + + gts = OrderedDict() + gt_res_ = [ + [gt_res[i][j].strip() for j in range(len(gt_res[i]))] + for i in range(len(gt_res)) + ] + for i in range(gen_res_size): + gts[i] = gt_res_[i] + + res_ = [{'image_id': i, 'caption': res[i]} for i in range(len(res))] + _, scores = self.CiderD_scorer.compute_score(gts, res_) + return scores + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = criterion(model, sample) + + model.eval() + if self.cfg.eval_bleu or self.cfg.eval_cider: + hyps, refs = self._inference(self.sequence_generator, sample, model) + if self.cfg.eval_bleu: + if self.cfg.eval_tokenized_bleu: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs)), tokenize="none") + else: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs))) + logging_output["_bleu_sys_len"] = bleu.sys_len + logging_output["_bleu_ref_len"] = bleu.ref_len + # we split counts into separate entries so that they can be + # summed efficiently across workers using fast-stat-sync + assert len(bleu.counts) == EVAL_BLEU_ORDER + for i in range(EVAL_BLEU_ORDER): + logging_output["_bleu_counts_" + str(i)] = bleu.counts[i] + logging_output["_bleu_totals_" + str(i)] = bleu.totals[i] + if self.cfg.eval_cider: + scores = self._calculate_cider_scores(hyps, refs) + logging_output["_cider_score_sum"] = scores.sum() + logging_output["_cider_cnt"] = scores.size + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + if self.cfg.eval_bleu: + counts, totals = [], [] + for i in range(EVAL_BLEU_ORDER): + counts.append(sum_logs("_bleu_counts_" + str(i))) + totals.append(sum_logs("_bleu_totals_" + str(i))) + + if max(totals) > 0: + # log counts as numpy arrays -- log_scalar will sum them correctly + metrics.log_scalar("_bleu_counts", np.array(counts)) + metrics.log_scalar("_bleu_totals", np.array(totals)) + metrics.log_scalar("_bleu_sys_len", sum_logs("_bleu_sys_len")) + metrics.log_scalar("_bleu_ref_len", sum_logs("_bleu_ref_len")) + + def compute_bleu(meters): + import inspect + import sacrebleu + + fn_sig = inspect.getfullargspec(sacrebleu.compute_bleu)[0] + if "smooth_method" in fn_sig: + smooth = {"smooth_method": "exp"} + else: + smooth = {"smooth": "exp"} + bleu = sacrebleu.compute_bleu( + correct=meters["_bleu_counts"].sum, + total=meters["_bleu_totals"].sum, + sys_len=meters["_bleu_sys_len"].sum, + ref_len=meters["_bleu_ref_len"].sum, + **smooth + ) + return round(bleu.score, 2) + + metrics.log_derived("bleu", compute_bleu) + + if self.cfg.eval_cider: + def compute_cider(meters): + cider = meters["_cider_score_sum"].sum / meters["_cider_cnt"].sum + cider = cider if isinstance(cider, float) else cider.item() + return round(cider, 3) + + if sum_logs("_cider_cnt") > 0: + metrics.log_scalar("_cider_score_sum", sum_logs("_cider_score_sum")) + metrics.log_scalar("_cider_cnt", sum_logs("_cider_cnt")) + metrics.log_derived("cider", compute_cider) + + def _inference(self, generator, sample, model): + + def decode(toks, escape_unk=False): + s = self.tgt_dict.string( + toks.int().cpu(), + # The default unknown string in fairseq is `<unk>`, but + # this is tokenized by sacrebleu as `< unk >`, inflating + # BLEU scores. Instead, we use a somewhat more verbose + # alternative that is unlikely to appear in the real + # reference, but doesn't get split into multiple tokens. + unk_string=("UNKNOWNTOKENINREF" if escape_unk else "UNKNOWNTOKENINHYP"), + ) + if self.bpe: + s = self.bpe.decode(s) + return s + + gen_out = self.inference_step(generator, [model], sample) + hyps, refs = [], [] + transtab = str.maketrans({key: None for key in string.punctuation}) + for i in range(len(gen_out)): + try: + decode_tokens = decode(gen_out[i][0]["tokens"]) + hyps.append(decode_tokens.translate(transtab).strip()) + refs.append( + [ + sent.translate(transtab).strip() + for sent in decode( + utils.strip_pad(sample["target"][i], self.tgt_dict.pad()), + escape_unk=True, # don't count <unk> as matches to the hypo + ).split('&&') + ] + ) + except: + print(sample['id']) + print(sample['net_input'].keys()) + print(gen_out) + # print(sample['net_input']) + + if self.cfg.eval_print_samples: + logger.info("example hypothesis: " + hyps[0]) + logger.info("example reference: " + ' && '.join(refs[0])) + + return hyps, refs diff --git a/tasks/mm_tasks/image_gen.py b/tasks/mm_tasks/image_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..e483b8db6ab1f9f03b56e1209126e59e435342f4 --- /dev/null +++ b/tasks/mm_tasks/image_gen.py @@ -0,0 +1,329 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +import os +import math +import base64 +from typing import Optional +from argparse import Namespace +from omegaconf import DictConfig, OmegaConf +from torchvision import transforms +from PIL import Image +from io import BytesIO + +import torch +import numpy as np +from fairseq import metrics +from fairseq.tasks import register_task +from fairseq.dataclass import ChoiceEnum + +from models import search, clip +from models.taming.models.vqgan import GumbelVQ +from data.mm_data.image_gen_dataset import ImageGenDataset +from data.file_dataset import FileDataset + +from tasks.ofa_task import OFATask, OFAConfig + +logger = logging.getLogger(__name__) + + +def custom_to_pil(x): + x = x.detach().cpu() + x = torch.clamp(x, -1., 1.) + x = (x + 1.) / 2. + x = x.permute(1, 2, 0).numpy() + x = (255 * x).astype(np.uint8) + x = Image.fromarray(x) + if not x.mode == "RGB": + x = x.convert("RGB") + return x + + +EVAL_CLIP_METHOD = ChoiceEnum(["ii_sim", "ti_sim"]) + +@dataclass +class ImageGenConfig(OFAConfig): + sampling_times: int = field( + default=1, metadata={"help": "sample times"} + ) + + code_image_size: int = field( + default=256, metadata={"help": "code image size"} + ) + + # options for reporting CLIP score during validation + eval_clip_method: EVAL_CLIP_METHOD = field( + default='ti_sim', + metadata={ + "help": "evaluation with CLIP scores. ii_sim means Similarity between generated Images and ref Images, ti_sim means Similarity between generated Images and input Text"} + ) + + eval_args: Optional[str] = field( + default='{}', + metadata={ + "help": 'generation args for clip scoring, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + + scst: bool = field( + default=False, metadata={"help": "Self-critical sequence training"} + ) + scst_args: str = field( + default='{}', + metadata={ + "help": 'generation args for Self-critical sequence training, as JSON string' + }, + ) + + vqgan_model_path: Optional[str] = field( + default=None, + metadata={"help": "path of vqgan model"} + ) + vqgan_config_path: Optional[str] = field( + default=None, + metadata={"help": "path of vqgan config"} + ) + clip_model_path: Optional[str] = field( + default=None, + metadata={"help": "clip model path"} + ) + gen_images_path: str = field( + default='', metadata={"help": "where to store generated images during evalution. Don't dump images if None. "} + ) + + +@register_task("image_gen", dataclass=ImageGenConfig) +class ImageGenTask(OFATask): + def __init__(self, cfg: ImageGenConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = ImageGenDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + code_dict_size=self.cfg.code_dict_size, + code_image_size=self.cfg.code_image_size + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + + device = torch.cuda.current_device() + clip_model, clip_preprocess = clip.load(self.cfg.clip_model_path, device=device) + self.clip_model = clip_model + self.clip_preprocess = clip_preprocess + self.clip_model.to(device) + self.clip_model.eval() + + vqgan_config = OmegaConf.load(self.cfg.vqgan_config_path) + vqgan = GumbelVQ(**vqgan_config.model.params) + sd = torch.load(self.cfg.vqgan_model_path, map_location="cpu")["state_dict"] + missing, unexpected = vqgan.load_state_dict(sd, strict=False) + for k, v in vqgan.named_parameters(): + v.requires_grad = False + self.image_tokenizer = vqgan + self.image_tokenizer.to(device) + self.image_tokenizer.eval() + + gen_args = json.loads(self.cfg.eval_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + if self.cfg.scst: + scst_args = json.loads(self.cfg.scst_args) + self.scst_generator = self.build_generator( + [model], Namespace(**scst_args) + ) + + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + """ + Build a :class:`~fairseq.SequenceGenerator` instance for this + task. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + args (fairseq.dataclass.configs.GenerationConfig): + configuration object (dataclass) for generation + extra_gen_cls_kwargs (Dict[str, Any]): extra options to pass + through to SequenceGenerator + prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]): + If provided, this function constrains the beam search to + allowed tokens only at each step. The provided function + should take 2 arguments: the batch ID (`batch_id: int`) + and a unidimensional tensor of token ids (`inputs_ids: + torch.Tensor`). It has to return a `List[int]` with the + allowed tokens for the next generation step conditioned + on the previously generated tokens (`inputs_ids`) and + the batch ID (`batch_id`). This argument is useful for + constrained generation conditioned on the prefix, as + described in "Autoregressive Entity Retrieval" + (https://arxiv.org/abs/2010.00904) and + https://github.com/facebookresearch/GENRE. + """ + from models.sequence_generator import SequenceGenerator + + # Choose search strategy. Defaults to Sampling. + self.sampling_times = self.cfg.sampling_times + sampling = True # we have to use sampling instead of beam search in image generation task + sampling_topk = getattr(args, "sampling_topk", -1) + sampling_topp = getattr(args, "sampling_topp", -1.0) + + assert sampling_topk < 0 or sampling, "--sampling-topk requires --sampling" + assert sampling_topp < 0 or sampling, "--sampling-topp requires --sampling" + + search_strategy = search.Sampling( + self.target_dictionary, sampling_topk, sampling_topp + ) + extra_gen_cls_kwargs = extra_gen_cls_kwargs or {} + + return SequenceGenerator( + models, + self.target_dictionary, + beam_size=getattr(args, "beam", 5), + max_len_a=getattr(args, "max_len_a", 0), + max_len_b=getattr(args, "max_len_b", 200), + min_len=getattr(args, "min_len", 1), + normalize_scores=(not getattr(args, "unnormalized", False)), + len_penalty=getattr(args, "lenpen", 1), + unk_penalty=getattr(args, "unkpen", 0), + temperature=getattr(args, "temperature", 1.0), + match_source_len=getattr(args, "match_source_len", False), + no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0), + search_strategy=search_strategy, + constraint_range=self.cfg.constraint_range, + gen_code=True, + **extra_gen_cls_kwargs, + ) + + def compute_ref_image_similarity(self, hyps, ref, device): + hyp_images = torch.stack( + [self.clip_preprocess(hyp_image) for hyp_image in hyps], dim=0 + ).to(device) + + ref_images = self.clip_preprocess(ref).unsqueeze(0).to(device) + with torch.no_grad(): + hyp_image_features = self.clip_model.encode_image(hyp_images) + ref_image_features = self.clip_model.encode_image(ref_images) + hyp_image_features /= hyp_image_features.norm(dim=-1, keepdim=True) + ref_image_features /= ref_image_features.norm(dim=-1, keepdim=True) + similarity = hyp_image_features @ ref_image_features.T + # scores.append(similarity.max().item()) + sorted_score, indices = torch.sort(similarity.view(-1), descending=True) + return sorted_score, indices + + def compute_text_similarity(self, hyps, text, device): + hyp_images = torch.stack( + [self.clip_preprocess(hyp_image) for hyp_image in hyps], dim=0 + ).to(device) + + clip_input = clip.tokenize([text]).to(device) + with torch.no_grad(): + hyp_image_features = self.clip_model.encode_image(hyp_images) + hyp_image_features /= hyp_image_features.norm(dim=-1, keepdim=True) + text_features = self.clip_model.encode_text(clip_input) + text_features /= text_features.norm(dim=-1, keepdim=True) + ti_similarity = hyp_image_features @ text_features.T + sorted_score, indices = torch.sort(ti_similarity.view(-1), descending=True) + return sorted_score, indices + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = criterion(model, sample) + + model.eval() + device = sample['target'].device + + hyps, ref = self.inference_image(self.sequence_generator, sample, [model]) + scores = [] + + tokens = sample['net_input']['src_tokens'][0].view(-1).tolist() + caption = self.bpe.decode(self.tgt_dict.string([token for token in tokens if token >= 4]))[ + 38:].replace('/', '') + if self.cfg.eval_clip_method == 'ii_sim': + similarity_score, indices = self.compute_ref_image_similarity(hyps, ref, device) + elif self.cfg.eval_clip_method == 'ti_sim': + similarity_score, indices = self.compute_text_similarity(hyps, caption, device) + else: + raise ValueError("unsupported eval method.") + + scores.append(similarity_score.max().item()) + sorted_hyps = [hyps[indice] for indice in indices] + + if self.cfg.gen_images_path: + caption_tokens = sample['net_input']['src_tokens'][0].view(-1).tolist() + caption = self.bpe.decode(self.tgt_dict.string([token for token in caption_tokens if token >= 4]))[ + 38:].replace('/', '') + self.dump_images(sorted_hyps, text=caption, path=os.path.join(self.cfg.gen_images_path, 'all_results')) + self.dump_images(sorted_hyps, text=caption, path=os.path.join(self.cfg.gen_images_path, 'top1'), topk=1) + + logging_output["_score_sum"] = sum(scores) + logging_output["_score_cnt"] = len(scores) + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + def compute_score(meters): + score = meters["_score_sum"].sum / meters["_score_cnt"].sum + score = score if isinstance(score, float) else score.item() + return round(score, 3) + + if sum_logs("_score_cnt") > 0: + metrics.log_scalar("_score_sum", sum_logs("_score_sum")) + metrics.log_scalar("_score_cnt", sum_logs("_score_cnt")) + metrics.log_derived("score", compute_score) + + def inference_image(self, generator, sample, models): + hyps, ref = [], None + for j in range(self.sampling_times): + gen_out = self.inference_step(generator, models, sample) + for i in range(len(gen_out)): + with torch.no_grad(): + tokens = torch.stack([item['tokens'][:-1] for item in gen_out[i]], dim=0) + tokens += -len(self.src_dict) + self.cfg.code_dict_size + self.cfg.num_bins + images = self.image_tokenizer.decode_code( + tokens.view(-1, self.cfg.code_image_size // 8, self.cfg.code_image_size // 8) + ) + images = [custom_to_pil(image) for image in images] + hyps += images + if 'code_images' in sample: + ref = Image.open(BytesIO(base64.urlsafe_b64decode(sample['code_images'][0]))).convert('RGB') + + return hyps, ref + + def dump_images(self, images, text, path, topk=None): + os.makedirs(path, exist_ok=True) + if topk: + images = images[:topk] + for j, image in enumerate(images): + save_path = os.path.join(path, f'{text}_{j}.png') + image.save(save_path) diff --git a/tasks/mm_tasks/refcoco.py b/tasks/mm_tasks/refcoco.py new file mode 100644 index 0000000000000000000000000000000000000000..d11a06110ab31af0418d39ea003f7d2e3251631d --- /dev/null +++ b/tasks/mm_tasks/refcoco.py @@ -0,0 +1,256 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +from typing import Optional +from argparse import Namespace + +import torch +from fairseq import metrics +from fairseq.tasks import register_task + +from tasks.ofa_task import OFATask, OFAConfig +from data.mm_data.refcoco_dataset import RefcocoDataset +from data.file_dataset import FileDataset + +logger = logging.getLogger(__name__) + + +from mapcalc import calculate_map, calculate_map_range +from functools import partial + +@dataclass +class RefcocoConfig(OFAConfig): + eval_acc: bool = field( + default=False, metadata={"help": "evaluation with accuracy"} + ) + eval_args: Optional[str] = field( + default='{}', + metadata={ + "help": 'generation args, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + eval_print_samples: bool = field( + default=False, metadata={"help": "print sample generations during validation"} + ) + + max_image_size: int = field( + default=512, metadata={"help": "max image size for normalization"} + ) + scst: bool = field( + default=False, metadata={"help": "Self-critical sequence training"} + ) + scst_args: str = field( + default='{}', + metadata={ + "help": 'generation args for Self-critical sequence training, as JSON string' + }, + ) + + + acc_thresh: Optional[str] = field( + default=None, metadata={"help": "acc thresh for refcoco"} + ) + metric: Optional[str] = field( + default='acc', + metadata={"help": "metric"} + ) + + max_area_size: Optional[float] = field( + default=None, metadata={"help": "max_area_size"} + ) + + min_area_size: Optional[float] = field( + default=None, metadata={"help": "min_area_size"} + ) + +@register_task("refcoco", dataclass=RefcocoConfig) +class RefcocoTask(OFATask): + def __init__(self, cfg: RefcocoConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + + self.metric = cfg.metric + self.min_area_size = cfg.min_area_size + self.max_area_size = cfg.max_area_size + try: + self.acc_thresh = float(cfg.acc_thresh) + except: + self.acc_thresh = cfg.acc_thresh + + print(self.acc_thresh, self.metric, self.min_area_size, self.max_area_size) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = RefcocoDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + num_bins=self.cfg.num_bins, + max_image_size=self.cfg.max_image_size + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + if self.cfg.eval_acc: + gen_args = json.loads(self.cfg.eval_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + if self.cfg.scst: + scst_args = json.loads(self.cfg.scst_args) + self.scst_generator = self.build_generator( + [model], Namespace(**scst_args) + ) + + return model + + def _calculate_ap_score(self, hyps, refs, thresh=0.5, min_area_size=None, max_area_size=None): + interacts = torch.cat( + [torch.where(hyps[:, :2] < refs[:, :2], refs[:, :2], hyps[:, :2]), + torch.where(hyps[:, 2:] < refs[:, 2:], hyps[:, 2:], refs[:, 2:])], + dim=1 + ) + area_predictions = (hyps[:, 2] - hyps[:, 0]) * (hyps[:, 3] - hyps[:, 1]) + area_targets = (refs[:, 2] - refs[:, 0]) * (refs[:, 3] - refs[:, 1]) + interacts_w = interacts[:, 2] - interacts[:, 0] + interacts_h = interacts[:, 3] - interacts[:, 1] + area_interacts = interacts_w * interacts_h + ious = area_interacts / (area_predictions + area_targets - area_interacts + 1e-6) + + if max_area_size is not None and min_area_size is not None: + ious = ious * ((area_targets < max_area_size).float() + (area_targets > min_area_size).float())/2 + elif min_area_size is not None: + ious = ious * (area_targets > min_area_size).float() + + elif max_area_size is not None: + ious = ious * (area_targets < max_area_size).float() + + if thresh is None: + return ious + else: + return ((ious >= thresh) & (interacts_w > 0) & (interacts_h > 0)).float() + + def _calculate_map_score(self, hyps, refs, thresh=0.5): + + + ground_truth = { + 'boxes': refs.cpu().numpy().tolist(), + + 'labels': [1 for i in range(refs.shape[0])] + } + + result_dict = { + 'boxes': hyps.cpu().numpy().tolist(), + + 'labels': [1 for i in range(hyps.shape[0])], + } + + score = calculate_map(ground_truth, result_dict, thresh) + + score = torch.tensor(score).unsqueeze(0).repeat(refs.shape[0]).to(hyps.device) + return score + + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = criterion(model, sample) + + model.eval() + if self.cfg.eval_acc: + hyps, refs = self._inference(self.sequence_generator, sample, model) + hyps = hyps / (self.cfg.num_bins - 1) * self.cfg.max_image_size + refs = refs / (self.cfg.num_bins - 1) * self.cfg.max_image_size + hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + refs[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + refs[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + + # scores = self._calculate_ap_score(hyps, refs) + # scores = self._calculate_ap_score(hyps, sample['region_coords'].float()) + + # scores = self._calculate_ap_score(hyps, refs) + scores = self._calculate_ap_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh) + if self.min_area_size is not None: + large_scores = self._calculate_ap_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh, + min_area_size=self.min_area_size) + logging_output["_large_score_sum"] = large_scores.sum().item() + logging_output["_large_score_cnt"] = large_scores.size(0) + + if self.max_area_size is not None: + small_scores = self._calculate_ap_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh, + max_area_size=self.max_area_size) + logging_output["_small_score_sum"] = small_scores.sum().item() + logging_output["_small_score_cnt"] = small_scores.size(0) + + if self.metric == 'map': + map_scores = self._calculate_map_score(hyps, sample['region_coords'].float(), thresh=self.acc_thresh) + logging_output["_map_score_sum"] = map_scores.sum().item() + logging_output["_map_score_cnt"] = map_scores.size(0) + + logging_output["_score_sum"] = scores.sum().item() + logging_output["_score_cnt"] = scores.size(0) + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + def compute_score(meters, prefix='_score'): + score = meters[prefix+"_sum"].sum / meters[prefix+"_cnt"].sum + score = score if isinstance(score, float) else score.item() + return round(score, 4) + + if sum_logs("_score_cnt") > 0: + metrics.log_scalar("_score_sum", sum_logs("_score_sum")) + metrics.log_scalar("_score_cnt", sum_logs("_score_cnt")) + metrics.log_derived("score", compute_score) + if self.metric == 'map': + metrics.log_scalar("_map_score_sum", sum_logs("_map_score_sum")) + metrics.log_scalar("_map_score_cnt", sum_logs("_map_score_cnt")) + metrics.log_derived("score", partial(compute_score, prefix='_map_score')) + + if self.min_area_size is not None: + metrics.log_scalar("_large_score_sum", sum_logs("_large_score_sum")) + metrics.log_scalar("_large_score_cnt", sum_logs("_large_score_cnt")) + metrics.log_derived("score", partial(compute_score, prefix='_large_score')) + if self.max_area_size is not None: + metrics.log_scalar("_small_score_sum", sum_logs("_small_score_sum")) + metrics.log_scalar("_small_score_cnt", sum_logs("_small_score_cnt")) + metrics.log_derived("score", partial(compute_score, prefix='_small_score')) + + def _inference(self, generator, sample, model): + gen_out = self.inference_step(generator, [model], sample) + hyps, refs = [], [] + for i in range(len(gen_out)): + hyps.append(gen_out[i][0]["tokens"][:-1] - len(self.src_dict) + self.cfg.num_bins) + refs.append(sample["target"][i][:-1] - len(self.src_dict) + self.cfg.num_bins) + if self.cfg.eval_print_samples: + logger.info("example hypothesis: ", hyps[0]) + logger.info("example reference: ", refs[0]) + + return torch.stack(hyps, dim=0), torch.stack(refs, dim=0) diff --git a/tasks/mm_tasks/snli_ve.py b/tasks/mm_tasks/snli_ve.py new file mode 100644 index 0000000000000000000000000000000000000000..56ef88dd64ede2c08f8e52159868d72d13439466 --- /dev/null +++ b/tasks/mm_tasks/snli_ve.py @@ -0,0 +1,197 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import json +import logging +import math +from dataclasses import dataclass, field +from typing import Optional + +import torch +from fairseq import metrics +from fairseq.tasks import register_task + +from tasks.ofa_task import OFAConfig, OFATask +from data.mm_data.snli_ve_dataset import SnliVeDataset +from data.file_dataset import FileDataset +from data import data_utils +from utils.trie import Trie + +logger = logging.getLogger(__name__) + + +@dataclass +class SnliVeConfig(OFAConfig): + ans2label_dict: Optional[str] = field( + default='{"no": 0, "yes":1, "maybe": 2}', + metadata={"help": 'answer to label dict'}, + ) + add_caption: bool = field( + default=False, + metadata={"help": "add caption to encoder"}, + ) + valid_batch_size: int = field( + default=20, + metadata={"help": "valid batch size per step"}, + ) + prompt_type: Optional[str] = field( + default=None, + metadata={"help": "prompt_type"}, + ) + + +@register_task("snli_ve", dataclass=SnliVeConfig) +class SnliVeTask(OFATask): + def __init__(self, cfg: SnliVeConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + self.ans2label_dict = json.loads(self.cfg.ans2label_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = SnliVeDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + add_caption=self.cfg.add_caption, + constraint_trie=self.constraint_trie, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + prompt_type=self.cfg.prompt_type + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + answer_item_list = [] + self.index2ans = {} + self.constraint_trie = Trie(self.tgt_dict.eos()) + for i, answer in enumerate(self.ans2label_dict.keys()): + answer_item = self.tgt_dict.encode_line( + line=self.bpe.encode(' ' + answer), + add_if_not_exist=False, + append_eos=False + ).long() + answer_item_list.append(answer_item) + self.index2ans[i] = answer + self.constraint_trie.insert([self.tgt_dict.bos()] + answer_item.tolist() + [self.tgt_dict.eos()]) + + constraint_mask_list = [] + for answer_item in answer_item_list: + constraint_mask = torch.zeros((len(answer_item)+1, len(self.tgt_dict))).bool() + for i in range(len(answer_item)+1): + constraint_prefix_token = [self.src_dict.bos()] + answer_item[:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + constraint_mask_list.append(constraint_mask) + + self.valid_answers_list = [] + self.valid_constraint_masks_list = [] + for i in range(0, len(answer_item_list), self.cfg.valid_batch_size): + self.valid_answers_list += [answer_item_list[i:i+self.cfg.valid_batch_size]] + self.valid_constraint_masks_list += [constraint_mask_list[i:i+self.cfg.valid_batch_size]] + + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + seq_generator = super().build_generator(models, args, seq_gen_cls, extra_gen_cls_kwargs, prefix_allowed_tokens_fn) + seq_generator.constraint_trie = self.constraint_trie + + return seq_generator + + def valid_step(self, sample, model, criterion, **extra_kwargs): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + + model.eval() + with torch.no_grad(): + encoder_out = model.encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"] + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([self.src_dict.eos()]) + pad = self.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(self.valid_answers_list, self.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat([torch.zeros(len(decoder_prompt)-1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], dim=0) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad, left_pad=False).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad, left_pad=False).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad, left_pad=False).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = model.decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = model.get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(self.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [self.index2ans[predict_index] for predict_index in predicts] + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + logging_output["_snli_score_sum"] = sum(scores) + logging_output["_snli_cnt"] = len(scores) + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + def compute_score(meters): + score = meters["_snli_score_sum"].sum / meters["_snli_cnt"].sum + score = score if isinstance(score, float) else score.item() + return round(score, 4) + + if sum_logs("_snli_cnt") > 0: + metrics.log_scalar("_snli_score_sum", sum_logs("_snli_score_sum")) + metrics.log_scalar("_snli_cnt", sum_logs("_snli_cnt")) + metrics.log_derived("snli_score", compute_score) diff --git a/tasks/mm_tasks/video_caption.py b/tasks/mm_tasks/video_caption.py new file mode 100644 index 0000000000000000000000000000000000000000..5b1264864789f15a40a7d43e1f0257b9e00d472b --- /dev/null +++ b/tasks/mm_tasks/video_caption.py @@ -0,0 +1,254 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +from typing import Optional +from argparse import Namespace +from itertools import zip_longest +from collections import OrderedDict + +import numpy as np +import sacrebleu +import string +from fairseq import metrics, utils +from fairseq.tasks import register_task + +from tasks.ofa_task import OFATask, OFAConfig +from data.mm_data.video_caption_dataset import CaptionDataset +from data.file_dataset import FileDataset +from utils.cider.pyciderevalcap.ciderD.ciderD import CiderD + +EVAL_BLEU_ORDER = 4 + +logger = logging.getLogger(__name__) + + +@dataclass +class CaptionConfig(OFAConfig): + eval_bleu: bool = field( + default=False, metadata={"help": "evaluation with BLEU scores"} + ) + eval_cider: bool = field( + default=False, metadata={"help": "evaluation with CIDEr scores"} + ) + eval_args: Optional[str] = field( + default='{}', + metadata={ + "help": 'generation args for BLUE or CIDEr scoring, e.g., \'{"beam": 4, "lenpen": 0.6}\', as JSON string' + }, + ) + eval_print_samples: bool = field( + default=False, metadata={"help": "print sample generations during validation"} + ) + eval_cider_cached_tokens: Optional[str] = field( + default=None, + metadata={"help": "path to cached cPickle file used to calculate CIDEr scores"}, + ) + + scst: bool = field( + default=False, metadata={"help": "Self-critical sequence training"} + ) + scst_args: str = field( + default='{}', + metadata={ + "help": 'generation args for Self-critical sequence training, as JSON string' + }, + ) + + +@register_task("video_caption", dataclass=CaptionConfig) +class VidCaptionTask(OFATask): + def __init__(self, cfg: CaptionConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + file_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + file_path = paths[-1] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = CaptionDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + scst=getattr(self.cfg, 'scst', False), + image_dir=self.cfg.image_dir, + patch_frame_size=self.cfg.patch_frame_size, + num_frames=self.cfg.num_frames, + sample_type=self.cfg.sample_type, + use_dataaug=self.cfg.use_dataaug + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + if self.cfg.eval_bleu or self.cfg.eval_cider: + gen_args = json.loads(self.cfg.eval_args) + self.sequence_generator = self.build_generator( + [model], Namespace(**gen_args) + ) + if self.cfg.eval_cider: + self.CiderD_scorer = CiderD(df=self.cfg.eval_cider_cached_tokens) + if self.cfg.scst: + scst_args = json.loads(self.cfg.scst_args) + self.scst_generator = self.build_generator( + [model], Namespace(**scst_args) + ) + + return model + + def _calculate_cider_scores(self, gen_res, gt_res): + ''' + gen_res: generated captions, list of str + gt_idx: list of int, of the same length as gen_res + gt_res: ground truth captions, list of list of str. + gen_res[i] corresponds to gt_res[gt_idx[i]] + Each image can have multiple ground truth captions + ''' + gen_res_size = len(gen_res) + + res = OrderedDict() + for i in range(gen_res_size): + res[i] = [gen_res[i].strip()] + + gts = OrderedDict() + gt_res_ = [ + [gt_res[i][j].strip() for j in range(len(gt_res[i]))] + for i in range(len(gt_res)) + ] + for i in range(gen_res_size): + gts[i] = gt_res_[i] + + res_ = [{'image_id': i, 'caption': res[i]} for i in range(len(res))] + _, scores = self.CiderD_scorer.compute_score(gts, res_) + return scores + + def valid_step(self, sample, model, criterion): + loss, sample_size, logging_output = criterion(model, sample) + + model.eval() + if self.cfg.eval_bleu or self.cfg.eval_cider: + hyps, refs = self._inference(self.sequence_generator, sample, model) + if self.cfg.eval_bleu: + if self.cfg.eval_tokenized_bleu: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs)), tokenize="none") + else: + bleu = sacrebleu.corpus_bleu(hyps, list(zip_longest(*refs))) + logging_output["_bleu_sys_len"] = bleu.sys_len + logging_output["_bleu_ref_len"] = bleu.ref_len + # we split counts into separate entries so that they can be + # summed efficiently across workers using fast-stat-sync + assert len(bleu.counts) == EVAL_BLEU_ORDER + for i in range(EVAL_BLEU_ORDER): + logging_output["_bleu_counts_" + str(i)] = bleu.counts[i] + logging_output["_bleu_totals_" + str(i)] = bleu.totals[i] + if self.cfg.eval_cider: + scores = self._calculate_cider_scores(hyps, refs) + logging_output["_cider_score_sum"] = scores.sum() + logging_output["_cider_cnt"] = scores.size + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + if self.cfg.eval_bleu: + counts, totals = [], [] + for i in range(EVAL_BLEU_ORDER): + counts.append(sum_logs("_bleu_counts_" + str(i))) + totals.append(sum_logs("_bleu_totals_" + str(i))) + + if max(totals) > 0: + # log counts as numpy arrays -- log_scalar will sum them correctly + metrics.log_scalar("_bleu_counts", np.array(counts)) + metrics.log_scalar("_bleu_totals", np.array(totals)) + metrics.log_scalar("_bleu_sys_len", sum_logs("_bleu_sys_len")) + metrics.log_scalar("_bleu_ref_len", sum_logs("_bleu_ref_len")) + + def compute_bleu(meters): + import inspect + import sacrebleu + + fn_sig = inspect.getfullargspec(sacrebleu.compute_bleu)[0] + if "smooth_method" in fn_sig: + smooth = {"smooth_method": "exp"} + else: + smooth = {"smooth": "exp"} + bleu = sacrebleu.compute_bleu( + correct=meters["_bleu_counts"].sum, + total=meters["_bleu_totals"].sum, + sys_len=meters["_bleu_sys_len"].sum, + ref_len=meters["_bleu_ref_len"].sum, + **smooth + ) + return round(bleu.score, 2) + + metrics.log_derived("bleu", compute_bleu) + + if self.cfg.eval_cider: + def compute_cider(meters): + cider = meters["_cider_score_sum"].sum / meters["_cider_cnt"].sum + cider = cider if isinstance(cider, float) else cider.item() + return round(cider, 3) + + if sum_logs("_cider_cnt") > 0: + metrics.log_scalar("_cider_score_sum", sum_logs("_cider_score_sum")) + metrics.log_scalar("_cider_cnt", sum_logs("_cider_cnt")) + metrics.log_derived("cider", compute_cider) + + def _inference(self, generator, sample, model): + + def decode(toks, escape_unk=False): + s = self.tgt_dict.string( + toks.int().cpu(), + # The default unknown string in fairseq is `<unk>`, but + # this is tokenized by sacrebleu as `< unk >`, inflating + # BLEU scores. Instead, we use a somewhat more verbose + # alternative that is unlikely to appear in the real + # reference, but doesn't get split into multiple tokens. + unk_string=("UNKNOWNTOKENINREF" if escape_unk else "UNKNOWNTOKENINHYP"), + ) + if self.bpe: + s = self.bpe.decode(s) + return s + + gen_out = self.inference_step(generator, [model], sample) + hyps, refs = [], [] + transtab = str.maketrans({key: None for key in string.punctuation}) + for i in range(len(gen_out)): + decode_tokens = decode(gen_out[i][0]["tokens"]) + hyps.append(decode_tokens.translate(transtab).strip()) + refs.append( + [ + sent.translate(transtab).strip() + for sent in decode( + utils.strip_pad(sample["target"][i], self.tgt_dict.pad()), + escape_unk=True, # don't count <unk> as matches to the hypo + ).split('&&') + ] + ) + if self.cfg.eval_print_samples: + logger.info("example hypothesis: " + hyps[0]) + logger.info("example reference: " + ' && '.join(refs[0])) + + return hyps, refs diff --git a/tasks/mm_tasks/video_vqa_gen.py b/tasks/mm_tasks/video_vqa_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..b2a5f8ccd42ce68692b141712951f7e2a71a7336 --- /dev/null +++ b/tasks/mm_tasks/video_vqa_gen.py @@ -0,0 +1,290 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +import os +import math +import pickle +from typing import Optional +from argparse import Namespace +from data.file_dataset import FileDataset + +import torch +from fairseq import metrics +from fairseq.tasks import register_task + +from models import search +from data.mm_data.video_vqa_gen_dataset import VidVqaGenDataset +from data import data_utils +from tasks.ofa_task import OFAConfig, OFATask +from utils.trie import Trie + +logger = logging.getLogger(__name__) + + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.bos, generator.eos} + + +def decode_fn(x, tgt_dict, bpe, generator, tokenizer=None): + x = tgt_dict.string(x.int().cpu(), extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator)) + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + +@dataclass +class VqaGenConfig(OFAConfig): + max_object_length: int = field( + default=30, metadata={"help": "the maximum object sequence length"} + ) + ans2label_dict: Optional[str] = field( + default='{"no": 0, "yes":1}', + metadata={"help": 'answer to label dict'}, + ) + ans2label_file: Optional[str] = field( + default=None, + metadata={"help": "path to load ans2label file"}, + ) + + add_object: bool = field( + default=False, + metadata={"help": "add object to encoder"}, + ) + valid_batch_size: int = field( + default=20, + metadata={"help": "valid batch size per step"}, + ) + prompt_type: Optional[str] = field( + default=None, + metadata={"help": "prompt_type"}, + ) + uses_ema: Optional[bool] = field( + default=False, + metadata={"help": "whether to use ema"}, + ) + val_inference_type: Optional[str] = field( + default='allcand', + metadata={"help": "inference type in validation (allcand or beamsearch), default to allcand"}, + ) + eval_args: Optional[str] = field( + default='{"beam":5,"unnormalized":true,"temperature":1.0}', + metadata={ + "help": 'generation args as JSON string for inference, only activated when --val-inference-type=beamsearch' + }, + ) + + +@register_task("video_vqa_gen", dataclass=VqaGenConfig) +class VidVqaGenTask(OFATask): + def __init__(self, cfg: VqaGenConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + self.ans2label_dict = None + if self.cfg.ans2label_file is not None: + self.ans2label_dict = pickle.load(open(self.cfg.ans2label_file, "rb")) + else: + self.ans2label_dict = json.loads(self.cfg.ans2label_dict) + + self.uses_ema = self.cfg.uses_ema + + assert self.cfg.val_inference_type in ["allcand", "beamsearch"], \ + "Unknown inference type encountered: {}, should be allcand or beamsearch.".format(self.cfg.val_inference_type) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + table_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + table_path = paths[-1] + dataset = FileDataset(table_path, self.cfg.selected_cols) + + self.datasets[split] = VidVqaGenDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_object_length=self.cfg.max_object_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + add_object=self.cfg.add_object, + constraint_trie=self.constraint_trie, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + prompt_type=self.cfg.prompt_type, + image_dir=self.cfg.image_dir, + patch_frame_size=self.cfg.patch_frame_size, + num_frames=self.cfg.num_frames, + sample_type=self.cfg.sample_type, + use_dataaug=self.cfg.use_dataaug, + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + answer_item_list = [] + self.index2ans = {} + self.constraint_trie = Trie(self.tgt_dict.eos()) + for i, answer in enumerate(self.ans2label_dict.keys()): + answer_item = self.tgt_dict.encode_line( + line=self.bpe.encode(' ' + answer), + add_if_not_exist=False, + append_eos=False + ).long() + answer_item_list.append(answer_item) + self.index2ans[i] = answer + self.constraint_trie.insert([self.tgt_dict.bos()] + answer_item.tolist() + [self.tgt_dict.eos()]) + + constraint_mask_list = [] + for answer_item in answer_item_list: + constraint_mask = torch.zeros((len(answer_item)+1, len(self.tgt_dict))).bool() + for i in range(len(answer_item)+1): + constraint_prefix_token = [self.src_dict.bos()] + answer_item[:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + constraint_mask_list.append(constraint_mask) + + if self.cfg.val_inference_type == "allcand": + self.valid_answers_list = [] + self.valid_constraint_masks_list = [] + for i in range(0, len(answer_item_list), self.cfg.valid_batch_size): + self.valid_answers_list += [answer_item_list[i:i+self.cfg.valid_batch_size]] + self.valid_constraint_masks_list += [constraint_mask_list[i:i+self.cfg.valid_batch_size]] + elif self.cfg.val_inference_type == "beamsearch": + gen_args = json.loads(self.cfg.eval_args) + self.generator = self.build_generator( + [model], Namespace(**gen_args) + ) + else: + raise NotImplementedError("Error: Unknown inference type encountered.") + + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + print("build generator:", args, seq_gen_cls, extra_gen_cls_kwargs) + seq_generator = super().build_generator(models, args, seq_gen_cls, extra_gen_cls_kwargs, prefix_allowed_tokens_fn) + seq_generator.constraint_trie = self.constraint_trie + + return seq_generator + + def valid_step(self, sample, model, criterion, **extra_kwargs): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + + if self.uses_ema: + assert 'ema_model' in extra_kwargs and extra_kwargs['ema_model'] is not None + if self.uses_ema: + eval_model = extra_kwargs['ema_model'] + else: + eval_model = model + + eval_model.eval() + with torch.no_grad(): + if self.cfg.val_inference_type == "allcand": + encoder_out = eval_model.encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"], + patch_videos=sample["net_input"]["patch_videos"], + patch_types=sample["net_input"]["patch_types"], + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([self.src_dict.eos()]) + pad = self.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(self.valid_answers_list, self.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat([torch.zeros(len(decoder_prompt)-1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], dim=0) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad, left_pad=False).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad, left_pad=False).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad, left_pad=False).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = eval_model.decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = eval_model.get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(self.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [self.index2ans[predict_index] for predict_index in predicts] + + elif self.cfg.val_inference_type == "beamsearch": + raw_hyps = self.inference_step(self.generator, [eval_model], sample, prefix_tokens=sample['prefix_tokens']) + hyps = [] + for i, sample_id in enumerate(sample["id"].tolist()): + try: + prefix_len = sample['prefix_tokens'][i].ne(1).sum().item() + detok_hypo_str = decode_fn(raw_hyps[i][0]["tokens"][prefix_len:], self.tgt_dict, self.bpe, self.generator) + hyps.append(detok_hypo_str.strip()) + except: + print(sample['id']) + print(raw_hyps) + + else: + raise NotImplementedError("Error: Unknown inference type encountered.") + + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + logging_output["_vqa_score_sum"] = sum(scores) + logging_output["_vqa_cnt"] = len(scores) + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + def compute_score(meters): + score = meters["_vqa_score_sum"].sum / meters["_vqa_cnt"].sum + score = score if isinstance(score, float) else score.item() + return round(score, 4) + + if sum_logs("_vqa_cnt") > 0: + metrics.log_scalar("_vqa_score_sum", sum_logs("_vqa_score_sum")) + metrics.log_scalar("_vqa_cnt", sum_logs("_vqa_cnt")) + metrics.log_derived("vqa_score", compute_score) diff --git a/tasks/mm_tasks/vqa_gen.py b/tasks/mm_tasks/vqa_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..dd0a9b318c5db9faae0fb7fa3e08e590b5c46efc --- /dev/null +++ b/tasks/mm_tasks/vqa_gen.py @@ -0,0 +1,290 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +import os +import math +import pickle +from typing import Optional +from argparse import Namespace +from data.file_dataset import FileDataset + +import torch +from fairseq import metrics +from fairseq.tasks import register_task + +from models import search +from data.mm_data.vqa_gen_dataset import VqaGenDataset +from data import data_utils +from tasks.ofa_task import OFAConfig, OFATask +from utils.trie import Trie + +logger = logging.getLogger(__name__) + + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.bos, generator.eos} + + +def decode_fn(x, tgt_dict, bpe, generator, tokenizer=None): + x = tgt_dict.string(x.int().cpu(), extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator)) + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + +@dataclass +class VqaGenConfig(OFAConfig): + max_object_length: int = field( + default=30, metadata={"help": "the maximum object sequence length"} + ) + ans2label_dict: Optional[str] = field( + default='{"no": 0, "yes":1}', + metadata={"help": 'answer to label dict'}, + ) + ans2label_file: Optional[str] = field( + default=None, + metadata={"help": "path to load ans2label file"}, + ) + + add_object: bool = field( + default=False, + metadata={"help": "add object to encoder"}, + ) + valid_batch_size: int = field( + default=20, + metadata={"help": "valid batch size per step"}, + ) + prompt_type: Optional[str] = field( + default=None, + metadata={"help": "prompt_type"}, + ) + uses_ema: Optional[bool] = field( + default=False, + metadata={"help": "whether to use ema"}, + ) + val_inference_type: Optional[str] = field( + default='allcand', + metadata={"help": "inference type in validation (allcand or beamsearch), default to allcand"}, + ) + eval_args: Optional[str] = field( + default='{"beam":5,"unnormalized":true,"temperature":1.0}', + metadata={ + "help": 'generation args as JSON string for inference, only activated when --val-inference-type=beamsearch' + }, + ) + + +@register_task("vqa_gen", dataclass=VqaGenConfig) +class VqaGenTask(OFATask): + def __init__(self, cfg: VqaGenConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + self.ans2label_dict = None + if self.cfg.ans2label_file is not None: + self.ans2label_dict = pickle.load(open(self.cfg.ans2label_file, "rb")) + else: + self.ans2label_dict = json.loads(self.cfg.ans2label_dict) + + self.uses_ema = self.cfg.uses_ema + + assert self.cfg.val_inference_type in ["allcand", "beamsearch"], \ + "Unknown inference type encountered: {}, should be allcand or beamsearch.".format(self.cfg.val_inference_type) + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + if split == 'train': + table_path = paths[(epoch - 1) % (len(paths) - 1)] + else: + table_path = paths[-1] + dataset = FileDataset(table_path, self.cfg.selected_cols) + + self.datasets[split] = VqaGenDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_object_length=self.cfg.max_object_length, + max_tgt_length=self.cfg.max_tgt_length, + patch_image_size=self.cfg.patch_image_size, + add_object=self.cfg.add_object, + constraint_trie=self.constraint_trie, + imagenet_default_mean_and_std=self.cfg.imagenet_default_mean_and_std, + prompt_type=self.cfg.prompt_type, + read_from_img_path=self.cfg.read_from_img_path, + image_dir=self.cfg.image_dir, + ) + + def build_model(self, cfg): + model = super().build_model(cfg) + answer_item_list = [] + self.index2ans = {} + self.constraint_trie = Trie(self.tgt_dict.eos()) + for i, answer in enumerate(self.ans2label_dict.keys()): + answer_item = self.tgt_dict.encode_line( + line=self.bpe.encode(' ' + answer), + add_if_not_exist=False, + append_eos=False + ).long() + answer_item_list.append(answer_item) + self.index2ans[i] = answer + self.constraint_trie.insert([self.tgt_dict.bos()] + answer_item.tolist() + [self.tgt_dict.eos()]) + + constraint_mask_list = [] + for answer_item in answer_item_list: + constraint_mask = torch.zeros((len(answer_item)+1, len(self.tgt_dict))).bool() + for i in range(len(answer_item)+1): + constraint_prefix_token = [self.src_dict.bos()] + answer_item[:i].tolist() + constraint_nodes = self.constraint_trie.get_next_layer(constraint_prefix_token) + constraint_mask[i][constraint_nodes] = True + constraint_mask_list.append(constraint_mask) + + if self.cfg.val_inference_type == "allcand": + self.valid_answers_list = [] + self.valid_constraint_masks_list = [] + for i in range(0, len(answer_item_list), self.cfg.valid_batch_size): + self.valid_answers_list += [answer_item_list[i:i+self.cfg.valid_batch_size]] + self.valid_constraint_masks_list += [constraint_mask_list[i:i+self.cfg.valid_batch_size]] + elif self.cfg.val_inference_type == "beamsearch": + gen_args = json.loads(self.cfg.eval_args) + self.generator = self.build_generator( + [model], Namespace(**gen_args) + ) + else: + raise NotImplementedError("Error: Unknown inference type encountered.") + + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + seq_generator = super().build_generator(models, args, seq_gen_cls, extra_gen_cls_kwargs, prefix_allowed_tokens_fn) + seq_generator.constraint_trie = self.constraint_trie + + return seq_generator + + def valid_step(self, sample, model, criterion, **extra_kwargs): + loss, sample_size, logging_output = super().valid_step(sample, model, criterion) + + if self.uses_ema: + assert 'ema_model' in extra_kwargs and extra_kwargs['ema_model'] is not None + if self.uses_ema: + eval_model = extra_kwargs['ema_model'] + else: + eval_model = model + + eval_model.eval() + with torch.no_grad(): + if self.cfg.val_inference_type == "allcand": + encoder_out = eval_model.encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"], + patch_types=sample["net_input"]["patch_types"], + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([self.src_dict.eos()]) + pad = self.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(self.valid_answers_list, self.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat([torch.zeros(len(decoder_prompt)-1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], dim=0) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad, left_pad=False).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad, left_pad=False).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad, left_pad=False).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = eval_model.decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = eval_model.get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(self.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [self.index2ans[predict_index] for predict_index in predicts] + + elif self.cfg.val_inference_type == "beamsearch": + raw_hyps = self.inference_step(self.generator, [eval_model], sample, prefix_tokens=sample['prefix_tokens']) + hyps = [] + for i, sample_id in enumerate(sample["id"].tolist()): + try: + prefix_len = sample['prefix_tokens'][i].ne(1).sum().item() + detok_hypo_str = decode_fn(raw_hyps[i][0]["tokens"][prefix_len:], self.tgt_dict, self.bpe, self.generator) + hyps.append(detok_hypo_str.strip()) + + except: + print(sample['id']) + print(raw_hyps) + # print(raw_hyps[i][0]["tokens"]) + # hyps.append(' ') + + + + else: + raise NotImplementedError("Error: Unknown inference type encountered.") + + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + logging_output["_vqa_score_sum"] = sum(scores) + logging_output["_vqa_cnt"] = len(scores) + + return loss, sample_size, logging_output + + def reduce_metrics(self, logging_outputs, criterion): + super().reduce_metrics(logging_outputs, criterion) + + def sum_logs(key): + import torch + result = sum(log.get(key, 0) for log in logging_outputs) + if torch.is_tensor(result): + result = result.cpu() + return result + + def compute_score(meters): + score = meters["_vqa_score_sum"].sum / meters["_vqa_cnt"].sum + score = score if isinstance(score, float) else score.item() + return round(score, 4) + + if sum_logs("_vqa_cnt") > 0: + metrics.log_scalar("_vqa_score_sum", sum_logs("_vqa_score_sum")) + metrics.log_scalar("_vqa_cnt", sum_logs("_vqa_cnt")) + metrics.log_derived("vqa_score", compute_score) diff --git a/tasks/ofa_task.py b/tasks/ofa_task.py new file mode 100644 index 0000000000000000000000000000000000000000..bb95ab93fd7bcaf35098c3b80d59f7466ed0af22 --- /dev/null +++ b/tasks/ofa_task.py @@ -0,0 +1,418 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import logging +import os +import math +import torch +from typing import Dict, Optional + +from fairseq import search +from fairseq.data import FairseqDataset, iterators +from fairseq.optim.amp_optimizer import AMPOptimizer +from fairseq.dataclass import FairseqDataclass +from fairseq.tasks import FairseqTask, register_task +from omegaconf import DictConfig + +from data.audio_utils import AUDIO_CFG + + +logger = logging.getLogger(__name__) + + +@dataclass +class OFAConfig(FairseqDataclass): + data: Optional[str] = field( + default=None, + metadata={ + "help": "comma separated path to data list, will be iterated upon during epochs " + "in round-robin manner; valid data are always in the last" + }, + ) + selected_cols: Optional[str] = field( + default=None, + metadata={"help": "selected cols"}, + ) + bpe: Optional[str] = field( + default='gpt2', + metadata={"help": "which bpe to use"}, + ) + bpe_dir: Optional[str] = field( + default=None, + metadata={"help": "bpe dir"}, + ) + max_source_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the source sequence"} + ) + max_target_positions: int = field( + default=1024, metadata={"help": "max number of tokens in the target sequence"} + ) + max_src_length: int = field( + default=128, metadata={"help": "the maximum src sequence length"} + ) + max_tgt_length: int = field( + default=30, metadata={"help": "the maximum target sequence length"} + ) + + code_dict_size: int = field( + default=8192, metadata={"help": "code dict size"} + ) + patch_image_size: int = field( + default=480, metadata={"help": "patch image size"} + ) + orig_patch_image_size: int = field( + default=256, metadata={"help": "patch image size"} + ) + num_bins: int = field( + default=1000, metadata={"help": "number of quantization bins"} + ) + + imagenet_default_mean_and_std: bool = field( + default=False, + metadata={"help": "imagenet normalize"}, + ) + constraint_range: Optional[str] = field( + default=None, + metadata={"help": "constraint range"} + ) + + + ## data + read_from_img_path: bool = field( + default=False, + metadata={"help": "read from image paths, don't convert images to str"}, + ) + + image_dir: str = field( + default="/lus/scratch/NAT/gda2204/SHARED/data", + metadata={"help": "path to datasets']"}, + ) + + no_image_transform: bool = field( + default=False, + metadata={"help": "read from image paths, don't convert images to str"}, + ) + patch_frame_size: int = field( + default=224, metadata={"help": "patch_frame_size"} + ) + + num_frames: int = field( + default=4, metadata={"help": "patch_frame_size"} + ) + + # audio + max_audio_len: int = field( + default=480000, metadata={"help": "patchmax_audio_len_frame_size"} + ) + audio_cfg: Optional[str] = field( + default=None, metadata={"help": '{"beam":5,"unnormalized":true,"temperature":1.0}'} + ) + + sample_type: str = field( + default="rand", + metadata={"help": "sample_type']"}, + ) + + sample_rate: int = field( + default=48000, metadata={"help": "sample rate"} + ) + + audio_sample_rate: bool = field( + default=False, + metadata={"help": "sample rate"}, + ) + + ast: bool = field( + default=False, + metadata={"help": "Use AST audio encoder"}, + ) + + mel_bins: int = field( + default=64, metadata={"help": "mel_bins"} + ) + + use_dataaug: bool = field( + default=False, + metadata={"help": "Use data augmentation"}, + ) + + +@register_task("unival", dataclass=OFAConfig) +class OFATask(FairseqTask): + def __init__(self, cfg: OFAConfig, src_dict, tgt_dict): + super().__init__(cfg) + self.src_dict = src_dict + self.tgt_dict = tgt_dict + + @classmethod + def setup_task(cls, cfg: DictConfig, **kwargs): + """Setup the task.""" + + # load dictionaries + src_dict = cls.load_dictionary( + os.path.join(cfg.bpe_dir, "dict.txt") + ) + tgt_dict = cls.load_dictionary( + os.path.join(cfg.bpe_dir, "dict.txt") + ) + src_dict.add_symbol("<mask>") + tgt_dict.add_symbol("<mask>") + for i in range(cfg.code_dict_size): + src_dict.add_symbol("<code_{}>".format(i)) + tgt_dict.add_symbol("<code_{}>".format(i)) + # quantization + for i in range(cfg.num_bins): + src_dict.add_symbol("<bin_{}>".format(i)) + tgt_dict.add_symbol("<bin_{}>".format(i)) + + logger.info("source dictionary: {} types".format(len(src_dict))) + logger.info("target dictionary: {} types".format(len(tgt_dict))) + return cls(cfg, src_dict, tgt_dict) + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + assert isinstance(dataset, FairseqDataset) + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # create mini-batches with given size constraints + batch_sampler = [ + [j for j in range(i, min(i + max_sentences, len(dataset)))] + for i in range(0, len(dataset), max_sentences) + ] + total_row_count = dataset.dataset.get_total_row_count() + num_batches = math.ceil(math.ceil(total_row_count / num_shards) / max_sentences) + if len(batch_sampler) < num_batches: + batch_sampler.append([]) + + # return a reusable, sharded iterator + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=batch_sampler, + seed=seed, + num_shards=1, + shard_id=0, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size + ) + + return epoch_iter + + def build_model(self, cfg: FairseqDataclass): + model = super().build_model(cfg) + if self.cfg.bpe == 'bert': + bpe_dict = { + "_name": "bert", + "bpe_vocab_file": os.path.join(self.cfg.bpe_dir, "vocab.txt"), + "bpe_cased": False + } + bpe_dict = DictConfig(bpe_dict) + self.bpe = self.build_bpe(bpe_dict) + else: + bpe_dict = { + "_name": "gpt2", + "gpt2_encoder_json": os.path.join(self.cfg.bpe_dir, "encoder.json"), + "gpt2_vocab_bpe": os.path.join(self.cfg.bpe_dir, "vocab.bpe") + } + bpe_dict = DictConfig(bpe_dict) + self.bpe = self.build_bpe(bpe_dict) + return model + + def build_generator( + self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None, + ): + """ + Build a :class:`~fairseq.SequenceGenerator` instance for this + task. + + Args: + models (List[~fairseq.models.FairseqModel]): ensemble of models + args (fairseq.dataclass.configs.GenerationConfig): + configuration object (dataclass) for generation + extra_gen_cls_kwargs (Dict[str, Any]): extra options to pass + through to SequenceGenerator + prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]): + If provided, this function constrains the beam search to + allowed tokens only at each step. The provided function + should take 2 arguments: the batch ID (`batch_id: int`) + and a unidimensional tensor of token ids (`inputs_ids: + torch.Tensor`). It has to return a `List[int]` with the + allowed tokens for the next generation step conditioned + on the previously generated tokens (`inputs_ids`) and + the batch ID (`batch_id`). This argument is useful for + constrained generation conditioned on the prefix, as + described in "Autoregressive Entity Retrieval" + (https://arxiv.org/abs/2010.00904) and + https://github.com/facebookresearch/GENRE. + """ + if getattr(args, "score_reference", False): + from fairseq.sequence_scorer import SequenceScorer + + return SequenceScorer( + self.target_dictionary, + compute_alignment=getattr(args, "print_alignment", False), + ) + + from fairseq.sequence_generator import ( + # SequenceGenerator, + SequenceGeneratorWithAlignment, + ) + from models.sequence_generator import SequenceGenerator + + # Choose search strategy. Defaults to Beam Search. + sampling = getattr(args, "sampling", False) + sampling_topk = getattr(args, "sampling_topk", -1) + sampling_topp = getattr(args, "sampling_topp", -1.0) + diverse_beam_groups = getattr(args, "diverse_beam_groups", -1) + diverse_beam_strength = getattr(args, "diverse_beam_strength", 0.5) + match_source_len = getattr(args, "match_source_len", False) + diversity_rate = getattr(args, "diversity_rate", -1) + constrained = getattr(args, "constraints", False) + + stop_on_max_len = getattr(args, "stop_on_max_len", False) + if prefix_allowed_tokens_fn is None: + prefix_allowed_tokens_fn = getattr(args, "prefix_allowed_tokens_fn", None) + if ( + sum( + int(cond) + for cond in [ + sampling, + diverse_beam_groups > 0, + match_source_len, + diversity_rate > 0, + ] + ) + > 1 + ): + raise ValueError("Provided Search parameters are mutually exclusive.") + assert sampling_topk < 0 or sampling, "--sampling-topk requires --sampling" + assert sampling_topp < 0 or sampling, "--sampling-topp requires --sampling" + + if sampling: + search_strategy = search.Sampling( + self.target_dictionary, sampling_topk, sampling_topp + ) + elif diverse_beam_groups > 0: + search_strategy = search.DiverseBeamSearch( + self.target_dictionary, diverse_beam_groups, diverse_beam_strength + ) + elif match_source_len: + # this is useful for tagging applications where the output + # length should match the input length, so we hardcode the + # length constraints for simplicity + search_strategy = search.LengthConstrainedBeamSearch( + self.target_dictionary, + min_len_a=1, + min_len_b=0, + max_len_a=1, + max_len_b=0, + ) + elif diversity_rate > -1: + search_strategy = search.DiverseSiblingsSearch( + self.target_dictionary, diversity_rate + ) + elif constrained: + search_strategy = search.LexicallyConstrainedBeamSearch( + self.target_dictionary, args.constraints + ) + elif prefix_allowed_tokens_fn: + search_strategy = search.PrefixConstrainedBeamSearch( + self.target_dictionary, prefix_allowed_tokens_fn + ) + else: + search_strategy = search.BeamSearch(self.target_dictionary) + + extra_gen_cls_kwargs = extra_gen_cls_kwargs or {} + if seq_gen_cls is None: + if getattr(args, "print_alignment", False): + seq_gen_cls = SequenceGeneratorWithAlignment + extra_gen_cls_kwargs["print_alignment"] = args.print_alignment + else: + seq_gen_cls = SequenceGenerator + + return seq_gen_cls( + models, + self.target_dictionary, + beam_size=getattr(args, "beam", 5), + max_len_a=getattr(args, "max_len_a", 0), + max_len_b=getattr(args, "max_len_b", 200), + min_len=getattr(args, "min_len", 1), + normalize_scores=(not getattr(args, "unnormalized", False)), + len_penalty=getattr(args, "lenpen", 1), + unk_penalty=getattr(args, "unkpen", 0), + temperature=getattr(args, "temperature", 1.0), + match_source_len=getattr(args, "match_source_len", False), + no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0), + search_strategy=search_strategy, + constraint_range=self.cfg.constraint_range, + stop_on_max_len=getattr(args, "stop_on_max_len", False), + **extra_gen_cls_kwargs, + ) + + def train_step( + self, sample, model, criterion, optimizer, update_num, ignore_grad=False, **extra_kwargs + ): + """ + Do forward and backward, and return the loss as computed by *criterion* + for the given *model* and *sample*. + + Args: + sample (dict): the mini-batch. The format is defined by the + :class:`~fairseq.data.FairseqDataset`. + model (~fairseq.models.BaseFairseqModel): the model + criterion (~fairseq.criterions.FairseqCriterion): the criterion + optimizer (~fairseq.optim.FairseqOptimizer): the optimizer + update_num (int): the current update + ignore_grad (bool): multiply loss by 0 if this is set to True + + Returns: + tuple: + - the loss + - the sample size, which is used as the denominator for the + gradient + - logging outputs to display while training + """ + model.train() + model.set_num_updates(update_num) + with torch.autograd.profiler.record_function("forward"): + with torch.cuda.amp.autocast(enabled=(isinstance(optimizer, AMPOptimizer))): + loss, sample_size, logging_output = criterion(model, sample, update_num=update_num) + if ignore_grad: + loss *= 0 + with torch.autograd.profiler.record_function("backward"): + optimizer.backward(loss) + return loss, sample_size, logging_output + + def max_positions(self): + """Return the max sentence length allowed by the task.""" + return (self.cfg.max_source_positions, self.cfg.max_target_positions) + + @property + def source_dictionary(self): + """Return the source :class:`~fairseq.data.Dictionary`.""" + return self.src_dict + + @property + def target_dictionary(self): + """Return the target :class:`~fairseq.data.Dictionary`.""" + return self.tgt_dict diff --git a/tasks/pretrain_tasks/.ipynb_checkpoints/unify_task-checkpoint.py b/tasks/pretrain_tasks/.ipynb_checkpoints/unify_task-checkpoint.py new file mode 100644 index 0000000000000000000000000000000000000000..3c59668fd0c0deae731f9503b5fa13657028ea0d --- /dev/null +++ b/tasks/pretrain_tasks/.ipynb_checkpoints/unify_task-checkpoint.py @@ -0,0 +1,210 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +import os +import math +from typing import Optional +from fairseq.tasks import register_task +from fairseq.data import FairseqDataset, iterators + +from tasks.ofa_task import OFATask, OFAConfig +from data.pretrain_data.unify_dataset import UnifyDataset +from data.file_dataset import FileDataset + +logger = logging.getLogger(__name__) + + +@dataclass +class UnifyConfig(OFAConfig): + max_image_size: int = field( + default=512, metadata={"help": ""} + ) + text_data: Optional[str] = field( + default=None, + metadata={"help": "pure text data"}, + ) + image_data: Optional[str] = field( + default=None, + metadata={"help": "pure image data"}, + ) + detection_data: Optional[str] = field( + default=None, + metadata={"help": "detection data"}, + ) + text_selected_cols: Optional[str] = field( + default=None, + metadata={"help": "pure text data selected cols"}, + ) + image_selected_cols: Optional[str] = field( + default=None, + metadata={"help": "pure image data selected cols"}, + ) + detection_selected_cols: Optional[str] = field( + default=None, + metadata={"help": "detection data selected cols"}, + ) + neg_sample_dir: Optional[str] = field( + default=None, + metadata={"help": "negative sample directory, which contains captions (taken from all image-text pairs), " + "answers (taken from VQA), " + "objects (taken form OpenImages) "}, + ) + code_image_size: int = field( + default=128, metadata={"help": "the resolution of the generated image in the image infilling task"} + ) + + pretrain_seed: int = field( + default=7, + metadata={"help": "pretrain seed"}, + ) + + mask_ratio: float = field( + default=0.3, + metadata={"help": "fraction of words/subwords that will be masked"}, + ) + random_ratio: float = field( + default=0.0, + metadata={"help": "instead of using [MASK], use random token this often"}, + ) + keep_ratio: float = field( + default=0.0, + metadata={"help": "instead of using [MASK], keep original token this often"}, + ) + mask_length: str = field( + default="span-poisson", + metadata={"help": "mask length to choose ['subword', 'word', 'span-poisson']"}, + ) + poisson_lambda: float = field( + default=3.0, + metadata={"help": "randomly shuffle sentences for this proportion of inputs"}, + ) + replace_length: int = field( + default=1, + metadata={"help": "when masking N tokens, replace with 0, 1, or N tokens (use -1 for N)"}, + ) + + ## data + read_from_img_path: bool = field( + default=False, + metadata={"help": "read from image paths, don't convert images to str"}, + ) + + +@register_task("unify_task", dataclass=UnifyConfig) +class UnifyTask(OFATask): + def __init__(self, cfg: UnifyConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + self.type2ans_dict = json.load(open(os.path.join(self.cfg.neg_sample_dir, 'type2ans.json'))) + self.ans2type_dict = {} + for type, answer_list in self.type2ans_dict.items(): + if type == 'other': + continue + for answer in answer_list: + self.ans2type_dict[answer] = type + + self.all_object_list = [ + row.strip() for row in open(os.path.join(self.cfg.neg_sample_dir, 'object.txt')) if row.strip() != '' + ] + self.all_caption_list = [ + row.strip() for row in open(os.path.join(self.cfg.neg_sample_dir, 'all_captions.txt')) if row.strip() != '' + ] + + self.pure_text_dataset = None + self.pure_image_dataset = None + self.detection_dataset = None + if self.cfg.text_data is not None: + self.pure_text_dataset = FileDataset(self.cfg.text_data, self.cfg.text_selected_cols) + if self.cfg.image_data is not None: + self.pure_image_dataset = FileDataset(self.cfg.image_data, self.cfg.image_selected_cols) + if self.cfg.detection_data is not None: + self.detection_dataset = FileDataset(self.cfg.detection_data, self.cfg.detection_selected_cols) + + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + file_path = paths[(epoch - 1) % (len(paths))] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + self.datasets[split] = UnifyDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + seed=self.cfg.pretrain_seed, + code_dict_size=self.cfg.code_dict_size, + num_bins=self.cfg.num_bins, + patch_image_size=self.cfg.patch_image_size, + code_image_size=self.cfg.code_image_size, + pure_text_dataset=self.pure_text_dataset, + pure_image_dataset=self.pure_image_dataset, + detection_dataset=self.detection_dataset, + all_object_list=self.all_object_list, + all_caption_list=self.all_caption_list, + type2ans_dict=self.type2ans_dict, + ans2type_dict=self.ans2type_dict, + max_image_size=self.cfg.max_image_size, + mask_ratio=self.cfg.mask_ratio, + random_ratio=self.cfg.random_ratio, + keep_ratio=self.cfg.keep_ratio, + mask_length=self.cfg.mask_length, + poisson_lambda=self.cfg.poisson_lambda, + replace_length=self.cfg.replace_length, + read_from_img_path=self.cfg.read_from_img_path + ) + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + assert isinstance(dataset, FairseqDataset) + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # create mini-batches with given size constraints + batch_sampler = [ + [j for j in range(i, min(i + max_sentences, len(dataset)))] + for i in range(0, len(dataset), max_sentences) + ] + total_row_count = dataset.dataset.get_total_row_count() + num_batches = math.ceil(math.ceil(total_row_count / num_shards) / max_sentences) + if len(batch_sampler) < num_batches: + batch_sampler.append([1]) + + # return a reusable, sharded iterator + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=batch_sampler, + seed=seed, + num_shards=1, + shard_id=0, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size + ) + + return epoch_iter diff --git a/tasks/pretrain_tasks/__init__.py b/tasks/pretrain_tasks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3b37e04e7e5e6ae00724710bab370ffa8b4f2195 --- /dev/null +++ b/tasks/pretrain_tasks/__init__.py @@ -0,0 +1 @@ +from .unify_task import UnifyTask \ No newline at end of file diff --git a/tasks/pretrain_tasks/__pycache__/__init__.cpython-37.pyc b/tasks/pretrain_tasks/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b734e50ef2edf98402d11e23b11ba0954096e4a7 Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/__init__.cpython-37.pyc differ diff --git a/tasks/pretrain_tasks/__pycache__/__init__.cpython-38.pyc b/tasks/pretrain_tasks/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bdfb1a0d62aded942c8ec17e694c3f60f0f58ef5 Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/__init__.cpython-38.pyc differ diff --git a/tasks/pretrain_tasks/__pycache__/__init__.cpython-39.pyc b/tasks/pretrain_tasks/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c997f2365c79a1131f6cdc0de023927f607f9542 Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/__init__.cpython-39.pyc differ diff --git a/tasks/pretrain_tasks/__pycache__/unify_task.cpython-37.pyc b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..99f076763e739247c04d3e36e8a7dd78038c885f Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-37.pyc differ diff --git a/tasks/pretrain_tasks/__pycache__/unify_task.cpython-38.pyc b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a74560a4fa8c1240c0010ef540826558e5ac71d2 Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-38.pyc differ diff --git a/tasks/pretrain_tasks/__pycache__/unify_task.cpython-39.pyc b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2685dab95b483c2baa4469936769d4f571c8d17 Binary files /dev/null and b/tasks/pretrain_tasks/__pycache__/unify_task.cpython-39.pyc differ diff --git a/tasks/pretrain_tasks/unify_task.py b/tasks/pretrain_tasks/unify_task.py new file mode 100644 index 0000000000000000000000000000000000000000..f612c0892e3f974e3f1ae2fee18b880980fd6bae --- /dev/null +++ b/tasks/pretrain_tasks/unify_task.py @@ -0,0 +1,402 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from dataclasses import dataclass, field +import json +import logging +import os +import math +from typing import Optional +from fairseq.tasks import register_task +from fairseq.data import FairseqDataset, iterators + +from tasks.ofa_task import OFATask, OFAConfig +from data.pretrain_data.unify_dataset import UnifyDataset +from data.file_dataset import FileDataset + +logger = logging.getLogger(__name__) + + +@dataclass +class UnifyConfig(OFAConfig): + max_image_size: int = field( + default=512, metadata={"help": ""} + ) + neg_sample_dir: Optional[str] = field( + default=None, + metadata={"help": "negative sample directory, which contains captions (taken from all image-text pairs), " + "answers (taken from VQA), " + "objects (taken form OpenImages) "}, + ) + code_image_size: int = field( + default=128, metadata={"help": "the resolution of the generated image in the image infilling task"} + ) + + pretrain_seed: int = field( + default=7, + metadata={"help": "pretrain seed"}, + ) + + mask_ratio: float = field( + default=0.3, + metadata={"help": "fraction of words/subwords that will be masked"}, + ) + random_ratio: float = field( + default=0.0, + metadata={"help": "instead of using [MASK], use random token this often"}, + ) + keep_ratio: float = field( + default=0.0, + metadata={"help": "instead of using [MASK], keep original token this often"}, + ) + mask_length: str = field( + default="span-poisson", + metadata={"help": "mask length to choose ['subword', 'word', 'span-poisson']"}, + ) + poisson_lambda: float = field( + default=3.0, + metadata={"help": "randomly shuffle sentences for this proportion of inputs"}, + ) + replace_length: int = field( + default=1, + metadata={"help": "when masking N tokens, replace with 0, 1, or N tokens (use -1 for N)"}, + ) + + + neg_captions_video: Optional[str] = field( + default=None, + metadata={"help": "negative sample file .txt, which contains captions (taken from all video-text pairs), "}, + ) + + neg_captions_audio: Optional[str] = field( + default=None, + metadata={"help": "negative sample file .txt, which contains captions (taken from all video-text pairs), "}, + ) + + audio_selected_cols: Optional[str] = field( + default=None, + metadata={"help": "detection data selected cols"}, + ) + + audio_data: Optional[str] = field( + default=None, + metadata={"help": "detection data"}, + ) + audio_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of video examples in the batch"}, + ) + + video_selected_cols: Optional[str] = field( + default=None, + metadata={"help": "video data selected cols"}, + ) + + video_data: Optional[str] = field( + default=None, + metadata={"help": "video data"}, + ) + + video_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of video examples in the batch"}, + ) + + image_text_data: Optional[str] = field( + default=None, + metadata={"help": "cc12m data"}, + ) + + image_text_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + other_data_cnt: int = field( + default=8, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + + init_image_text_data: Optional[str] = field( + default=None, + metadata={"help": "init data"}, + ) + + init_dataset_epoch: int = field( + default=3, + metadata={"help": "to witch from the init dataset"}, + ) + + init_text_data: Optional[str] = field( + default=None, + metadata={"help": "init data"}, + ) + + + image_text_vqa_data: Optional[str] = field( + default=None, + metadata={"help": "vqa data"}, + ) + + image_text_vqa_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + + image_text_ground_data: Optional[str] = field( + default=None, + metadata={"help": "cc12m data"}, + ) + + image_text_ground_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + only_video_data: Optional[str] = field( + default=None, + metadata={"help": "only video data"}, + ) + only_audio_data: Optional[str] = field( + default=None, + metadata={"help": "only video data"}, + ) + + video_text_data: Optional[str] = field( + default=None, + metadata={"help": "cc12m data"}, + ) + + video_text_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + audio_text_data: Optional[str] = field( + default=None, + metadata={"help": "cc12m data"}, + ) + + audio_text_cnt: int = field( + default=2, + metadata={"help": "to control the ratio of image-text examples in the batch"}, + ) + + audio_with_video: bool = field( + default=False, + metadata={"help": "audio_with_video"}, + ) + + +@register_task("unify_task", dataclass=UnifyConfig) +class UnifyTask(OFATask): + def __init__(self, cfg: UnifyConfig, src_dict, tgt_dict): + super().__init__(cfg, src_dict, tgt_dict) + + self.type2ans_dict = json.load(open(os.path.join(self.cfg.neg_sample_dir, 'type2ans.json'))) + self.ans2type_dict = {} + for type, answer_list in self.type2ans_dict.items(): + if type == 'other': + continue + for answer in answer_list: + self.ans2type_dict[answer] = type + + self.all_object_list = [ + row.strip() for row in open(os.path.join(self.cfg.neg_sample_dir, 'object.txt')) if row.strip() != '' + ] + neg_captions_path = os.path.join(self.cfg.neg_sample_dir, 'all_captions.txt') + self.all_caption_list = [ + row.strip() for row in open(os.path.join(neg_captions_path)) if row.strip() != '' + ] + + if self.cfg.neg_captions_video is not None: + neg_captions_video = self.cfg.neg_captions_video + else: + neg_captions_video = neg_captions_path + + if self.cfg.neg_captions_audio is not None: + neg_captions_audio = self.cfg.neg_captions_audio + else: + neg_captions_audio = neg_captions_path + + print("Reading negative video captions:", neg_captions_video) + self.all_caption_video_list = [ + row.strip() for row in open(os.path.join(neg_captions_video)) if row.strip() != '' + ] + print("Reading negative audio captions:", neg_captions_audio) + self.all_caption_audio_list = [ + row.strip() for row in open(os.path.join(neg_captions_audio)) if row.strip() != '' + ] + + + + # audio + self.audio_dataset = None + self.video_dataset = None + self.image_text_dataset = None + + self.video_text_dataset = None + + self.audio_text_dataset = None + + self.init_image_text_dataset = None + + self.init_text_dataset = None + + self.image_text_ground_dataset = None + self.image_text_vqa_dataset = None + + + + if self.cfg.audio_data is not None: + print("Load audio data") + self.audio_dataset = FileDataset(self.cfg.audio_data, self.cfg.audio_selected_cols) + + if self.cfg.video_data is not None: + print("Load video data") + self.video_dataset = FileDataset(self.cfg.video_data, self.cfg.video_selected_cols) + + if self.cfg.image_text_data is not None: + print("Load Image Text data") + self.image_text_dataset = FileDataset(self.cfg.image_text_data, self.cfg.selected_cols) + + if self.cfg.init_image_text_data is not None: + print("Load Init Image Text data") + self.init_image_text_dataset = FileDataset(self.cfg.init_image_text_data, self.cfg.selected_cols) + + if self.cfg.init_text_data is not None: + print("Load Init Text data") + self.init_text_dataset = FileDataset(self.cfg.init_text_data, self.cfg.text_selected_cols) + + if self.cfg.image_text_vqa_data is not None: + print("Load Image Text data") + self.image_text_vqa_dataset = FileDataset(self.cfg.image_text_vqa_data, self.cfg.selected_cols) + + if self.cfg.image_text_ground_data is not None: + print("Load Image Text data") + self.image_text_ground_dataset = FileDataset(self.cfg.image_text_ground_data, self.cfg.selected_cols) + + + if self.cfg.video_text_data is not None: + print("Load Video Text data") + self.video_text_dataset = FileDataset(self.cfg.video_text_data, self.cfg.selected_cols) + + if self.cfg.audio_text_data is not None: + print("Load Video Text data") + self.audio_text_dataset = FileDataset(self.cfg.audio_text_data, self.cfg.selected_cols) + + + def load_dataset(self, split, epoch=1, combine=False, **kwargs): + paths = self.cfg.data.split(',') + assert len(paths) > 0 + + file_path = paths[(epoch - 1) % (len(paths))] + dataset = FileDataset(file_path, self.cfg.selected_cols) + + + + self.datasets[split] = UnifyDataset( + split, + dataset, + self.bpe, + self.src_dict, + self.tgt_dict, + max_src_length=self.cfg.max_src_length, + max_tgt_length=self.cfg.max_tgt_length, + seed=self.cfg.pretrain_seed, + code_dict_size=self.cfg.code_dict_size, + num_bins=self.cfg.num_bins, + patch_image_size=self.cfg.patch_image_size, + code_image_size=self.cfg.code_image_size, + all_object_list=self.all_object_list, + all_caption_list=self.all_caption_list, + type2ans_dict=self.type2ans_dict, + ans2type_dict=self.ans2type_dict, + max_image_size=self.cfg.max_image_size, + mask_ratio=self.cfg.mask_ratio, + random_ratio=self.cfg.random_ratio, + keep_ratio=self.cfg.keep_ratio, + mask_length=self.cfg.mask_length, + poisson_lambda=self.cfg.poisson_lambda, + replace_length=self.cfg.replace_length, + read_from_img_path=self.cfg.read_from_img_path, + image_dir=self.cfg.image_dir, + no_image_transform=self.cfg.no_image_transform, + patch_frame_size=self.cfg.patch_frame_size, + num_frames=self.cfg.num_frames, + all_caption_video_list=self.all_caption_video_list, + all_caption_audio_list=self.all_caption_audio_list, + max_audio_len=self.cfg.max_audio_len, + audio_dataset=self.audio_dataset, + video_dataset=self.video_dataset, + video_cnt=self.cfg.video_cnt, + audio_cnt=self.cfg.audio_cnt, + image_text_dataset=self.image_text_dataset, + image_text_cnt=self.cfg.image_text_cnt, + other_data_cnt=self.cfg.other_data_cnt, + init_image_text_dataset=self.init_image_text_dataset, + init_dataset_epoch=self.cfg.init_dataset_epoch, + init_text_dataset=self.init_text_dataset, + image_text_vqa_dataset=self.image_text_vqa_dataset, + image_text_vqa_cnt=self.cfg.image_text_vqa_cnt, + image_text_ground_dataset=self.image_text_ground_dataset, + image_text_ground_cnt=self.cfg.image_text_ground_cnt, + only_video_data=self.cfg.only_video_data, + only_audio_data=self.cfg.only_audio_data, + video_text_dataset=self.video_text_dataset, + video_text_cnt=self.cfg.video_text_cnt, + audio_text_dataset=self.audio_text_dataset, + audio_text_cnt=self.cfg.audio_text_cnt, + audio_with_video=self.cfg.audio_with_video, + sample_rate=self.cfg.sample_rate, + ) + + def get_batch_iterator( + self, + dataset, + max_tokens=None, + max_sentences=None, + max_positions=None, + ignore_invalid_inputs=False, + required_batch_size_multiple=1, + seed=1, + num_shards=1, + shard_id=0, + num_workers=0, + epoch=1, + data_buffer_size=0, + disable_iterator_cache=False, + ): + assert isinstance(dataset, FairseqDataset) + + # initialize the dataset with the correct starting epoch + dataset.set_epoch(epoch) + + # create mini-batches with given size constraints + batch_sampler = [ + [j for j in range(i, min(i + max_sentences, len(dataset)))] + for i in range(0, len(dataset), max_sentences) + ] + total_row_count = dataset.dataset.get_total_row_count() + num_batches = math.ceil(math.ceil(total_row_count / num_shards) / max_sentences) + if len(batch_sampler) < num_batches: + batch_sampler.append([1]) + + # return a reusable, sharded iterator + epoch_iter = iterators.EpochBatchIterator( + dataset=dataset, + collate_fn=dataset.collater, + batch_sampler=batch_sampler, + seed=seed, + num_shards=1, + shard_id=0, + num_workers=num_workers, + epoch=epoch, + buffer_size=data_buffer_size + ) + + return epoch_iter diff --git a/test.py b/test.py new file mode 100644 index 0000000000000000000000000000000000000000..0acf5f4a2db26b5602d75913da6f94502cc41f6b --- /dev/null +++ b/test.py @@ -0,0 +1,101 @@ +from data.audio_utils import get_audio_features, int16_to_float32, float32_to_int16, AUDIO_CFG +import soundfile as sf +import io +import torch +import numpy as np + +AUDIO_CFG = { + "audio_length": 1024, + "clip_samples": 480000, + "mel_bins": 64, + "sample_rate": 48000, + "window_size": 1024, + "hop_size": 480, + "fmin": 50, + "fmax": 14000, + "class_num": 527, + } + + + +audio_cfg = AUDIO_CFG +max_len = 480000 +data_path = '/work/NAT/gda2204/mshukor/data/audiocaps/train/--CHY2qO5zc.wav' + +audio_data, orig_sr = sf.read(data_path) +# import librosa +# audio_data, orig_sr = librosa.load(data_path, sr=48000) + +print(orig_sr) +if audio_data.ndim>1: + audio_data = np.mean(audio_data,axis=1) + + +print(audio_data.shape, audio_data) + +audio_data = int16_to_float32(float32_to_int16(audio_data)) +audio_data = torch.tensor(audio_data).float() +print(audio_data.dtype) +print(audio_data.shape, audio_data) +# the 'fusion' truncate mode can be changed to 'rand_trunc' if run in unfusion mode +sample = {} + +sample = get_audio_features( + sample, audio_data, max_len, + data_truncating='fusion', + data_filling='repeatpad', + audio_cfg=audio_cfg, +) + +patch_audio = sample['waveform'] #.half() +print(patch_audio.shape, patch_audio.min(), patch_audio.max(), patch_audio) + +patch_audio = torch.zeros(480000) +print(patch_audio.shape) + + +from torchlibrosa.stft import Spectrogram, LogmelFilterBank + +AUDIO_CFG = { + "sample_rate": 48000, + "audio_length": 1024, + "clip_samples": 480000, + "mel_bins": 64, + "sample_rate": 48000, + "window_size": 1024, + "hop_size": 480, + "fmin": 50, + "fmax": 14000, + "class_num": 527, + } + +window = 'hann' +center = True +pad_mode = 'reflect' +ref = 1.0 +amin = 1e-10 +top_db = None + +spectrogram_extractor = Spectrogram(n_fft=AUDIO_CFG['window_size'], hop_length=AUDIO_CFG['hop_size'], + win_length=AUDIO_CFG['window_size'], window=window, center=center, pad_mode=pad_mode, + freeze_parameters=True) + + +logmel_extractor = LogmelFilterBank(sr=AUDIO_CFG['sample_rate'], n_fft=AUDIO_CFG['window_size'], + n_mels=AUDIO_CFG['mel_bins'], fmin=AUDIO_CFG['fmin'], fmax=AUDIO_CFG['fmax'], + ref=ref, amin=amin, top_db=top_db, + freeze_parameters=True)#.half() + + +patch_audio = patch_audio[None, :] +print(patch_audio.shape) +spectro = spectrogram_extractor(patch_audio) + +print(spectro.shape) +print(spectro) + + +mel = logmel_extractor(spectro) + +print(mel.shape) +print(mel) \ No newline at end of file diff --git a/train.py b/train.py new file mode 100644 index 0000000000000000000000000000000000000000..ed0a7e7482d8d8b8c8807a4f85284545a8f8fad2 --- /dev/null +++ b/train.py @@ -0,0 +1,729 @@ +#!/usr/bin/env python3 -u +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +""" +Train a new model on one or across multiple GPUs. +""" + +import argparse +import logging +import math +import os +import sys +from typing import Dict, Optional, Any, List, Tuple, Callable + +# We need to setup root logger before importing any fairseq libraries. +logging.basicConfig( + format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s', + datefmt="%Y-%m-%d %H:%M:%S", + level=os.environ.get("LOGLEVEL", "INFO").upper(), + stream=sys.stdout, +) +logger = logging.getLogger("fairseq_cli.train") + +import numpy as np +import torch +from fairseq import ( + # checkpoint_utils, + options, + quantization_utils, + tasks, + utils, +) +from fairseq.data import iterators +from fairseq.data.plasma_utils import PlasmaStore +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.distributed import fsdp_enable_wrap, fsdp_wrap, utils as distributed_utils +from fairseq.file_io import PathManager +from fairseq.logging import meters, metrics, progress_bar +from fairseq.model_parallel.megatron_trainer import MegatronTrainer +# from fairseq.trainer import Trainer +from omegaconf import DictConfig, OmegaConf + +from utils import checkpoint_utils +from trainer import Trainer + +from utils.utils import print_trainable_params_percentage, setup_for_distributed + +import psutil + +def main(cfg: FairseqConfig) -> None: + print(distributed_utils.is_master(cfg.distributed_training)) + print(cfg.distributed_training) + setup_for_distributed(distributed_utils.is_master(cfg.distributed_training)) + + if isinstance(cfg, argparse.Namespace): + cfg = convert_namespace_to_omegaconf(cfg) + + utils.import_user_module(cfg.common) + + if distributed_utils.is_master(cfg.distributed_training) and "job_logging_cfg" in cfg: + # make hydra logging work with ddp (see # see https://github.com/facebookresearch/hydra/issues/1126) + logging.config.dictConfig(OmegaConf.to_container(cfg.job_logging_cfg)) + + assert ( + cfg.dataset.max_tokens is not None or cfg.dataset.batch_size is not None + ), "Must specify batch size either with --max-tokens or --batch-size" + metrics.reset() + + if cfg.common.log_file is not None: + handler = logging.FileHandler(filename=cfg.common.log_file) + logger.addHandler(handler) + + np.random.seed(cfg.common.seed) + utils.set_torch_seed(cfg.common.seed) + + if distributed_utils.is_master(cfg.distributed_training): + print(cfg.checkpoint.save_dir) + checkpoint_utils.verify_checkpoint_directory(cfg.checkpoint.save_dir) + + + # Print args + logger.info(cfg) + + + if cfg.checkpoint.write_checkpoints_asynchronously: + try: + import iopath # noqa: F401 + except ImportError: + logging.exception( + "Asynchronous checkpoint writing is specified but iopath is " + "not installed: `pip install iopath`" + ) + return + + # Setup task, e.g., translation, language modeling, etc. + task = tasks.setup_task(cfg.task) + + assert cfg.criterion, "Please specify criterion to train a model" + + # Build model and criterion + if cfg.distributed_training.ddp_backend == "fully_sharded": + with fsdp_enable_wrap(cfg.distributed_training): + model = fsdp_wrap(task.build_model(cfg.model)) + else: + model = task.build_model(cfg.model) + + # bitfit + if cfg.model.bitfit: + for name, param in model.named_parameters(): + if ("layer_norm" in name and "bias" in name) or ("fc" in name and "bias" in name): + param.requires_grad = True + else: + param.requires_grad = False + + criterion = task.build_criterion(cfg.criterion) + + logger.info(model) + logger.info("task: {}".format(task.__class__.__name__)) + logger.info("model: {}".format(model.__class__.__name__)) + logger.info("criterion: {}".format(criterion.__class__.__name__)) + logger.info( + "num. shared model params: {:,} (num. trained: {:,})".format( + sum(p.numel() for p in model.parameters() if not getattr(p, "expert", False)), + sum(p.numel() for p in model.parameters() if not getattr(p, "expert", False) and p.requires_grad) + ) + ) + + logger.info( + "num. expert model params: {} (num. trained: {})".format( + sum(p.numel() for p in model.parameters() if getattr(p, "expert", False)), + sum(p.numel() for p in model.parameters() if getattr(p, "expert", False) and p.requires_grad), + ) + ) + + # Load valid dataset (we load training data below, based on the latest checkpoint) + # We load the valid dataset AFTER building the model + # data_utils.raise_if_valid_subsets_unintentionally_ignored(cfg) + if cfg.dataset.combine_valid_subsets: + task.load_dataset("valid", combine=True, epoch=1) + else: + for valid_sub_split in cfg.dataset.valid_subset.split(","): + task.load_dataset(valid_sub_split, combine=False, epoch=1) + + # (optionally) Configure quantization + if cfg.common.quantization_config_path is not None: + quantizer = quantization_utils.Quantizer( + config_path=cfg.common.quantization_config_path, + max_epoch=cfg.optimization.max_epoch, + max_update=cfg.optimization.max_update, + ) + else: + quantizer = None + + + + + # for n, p in model.named_parameters(): + # if not p.requires_grad: + # print(n) + + # Build trainer + if cfg.common.model_parallel_size == 1: + trainer = Trainer(cfg, task, model, criterion, quantizer) + else: + trainer = MegatronTrainer(cfg, task, model, criterion) + logger.info( + "training on {} devices (GPUs/TPUs)".format( + cfg.distributed_training.distributed_world_size + ) + ) + logger.info( + "max tokens per device = {} and max sentences per device = {}".format( + cfg.dataset.max_tokens, + cfg.dataset.batch_size, + ) + ) + + + # Load the latest checkpoint if one is available and restore the + # corresponding train iterator + strict = getattr(cfg.model, 'strict', True) + logger.info('load checkpoint, strict:{}'.format(strict)) + extra_state, epoch_itr = checkpoint_utils.load_checkpoint( + cfg.checkpoint, + trainer, + strict=strict, + # don't cache epoch iterators for sharded datasets + disable_iterator_cache=True, + load_on_cuda=cfg.checkpoint.load_on_cuda, + ) + if cfg.common.tpu: + import torch_xla.core.xla_model as xm + xm.rendezvous("load_checkpoint") # wait for all workers + + max_epoch = cfg.optimization.max_epoch or math.inf + if max_epoch > 0 and max_epoch != math.inf: + total_num_updates = sum( + math.ceil(len(epoch_itr) / cfg.optimization.update_freq[i]) + if i < len(cfg.optimization.update_freq) else + math.ceil(len(epoch_itr) / cfg.optimization.update_freq[-1]) + for i in range(max_epoch) + ) + trainer.lr_reinit(total_num_updates, trainer.get_num_updates()) + + # if getattr(cfg.model, "freeze_encoder", False): + # for idx, layer in enumerate(model.encoder.layers): + # layer.requires_grad_(False) + # if getattr(cfg.model, "freeze_decoder", False): + # for idx, layer in enumerate(model.decoder.layers): + # layer.requires_grad_(False) + + # if hasattr(cfg.model, 'progressive') or getattr(cfg.model, "freeze_perception", False): + # custom_unfreeze(trainer, epoch_itr, cfg.model) + + # if hasattr(cfg.model, 'only_linear_proj') and getattr(cfg.model, "only_linear_proj", False): + # model.requires_grad_(False) + # model.encoder.embed_tokens.weight.requires_grad = True + # model.decoder.embed_tokens.weight.requires_grad = True + + # if getattr(cfg.model, "freeze_encoder_embedding", False) or getattr( + # cfg.model, "encoder_prompt", False) or getattr(cfg.model, "decoder_prompt", False) or getattr(cfg.model, "adapter", False): + # model.encoder.embed_tokens.weight.requires_grad = False + # if getattr(cfg.model, "freeze_decoder_embedding", False) or getattr( + # cfg.model, "encoder_prompt", False) or getattr(cfg.model, "decoder_prompt", False) or getattr(cfg.model, "adapter", False): + # model.decoder.embed_tokens.weight.requires_grad = False + + + # model.encoder.image_proj.requires_grad_(True) + # if getattr(cfg.model, "video_encoder_name", None): + # model.encoder.video_proj.requires_grad_(True) + # if getattr(cfg.model, "audio_encoder_name", None): + # model.encoder.audio_proj.requires_grad_(True) + + + print_trainable_params_percentage(model) + + lr = trainer.get_lr() + + train_meter = meters.StopwatchMeter() + train_meter.start() + while epoch_itr.next_epoch_idx <= max_epoch: + if lr <= cfg.optimization.stop_min_lr: + logger.info( + f"stopping training because current learning rate ({lr}) is smaller " + "than or equal to minimum learning rate " + f"(--stop-min-lr={cfg.optimization.stop_min_lr})" + ) + break + + # train for one epoch + + valid_losses, should_stop = train(cfg, trainer, task, epoch_itr) + if should_stop: + break + + # only use first validation loss to update the learning rate + lr = trainer.lr_step(epoch_itr.epoch, valid_losses[0]) + + epoch_itr = trainer.get_train_iterator( + epoch_itr.next_epoch_idx, + # sharded data: get train iterator for next epoch + load_dataset=True, + # don't cache epoch iterators for sharded datasets + disable_iterator_cache=True, + ) + train_meter.stop() + logger.info("done training in {:.1f} seconds".format(train_meter.sum)) + + # ioPath implementation to wait for all asynchronous file writes to complete. + if cfg.checkpoint.write_checkpoints_asynchronously: + logger.info( + "ioPath PathManager waiting for all asynchronous checkpoint " + "writes to finish." + ) + PathManager.async_close() + logger.info("ioPath PathManager finished waiting.") + + +def should_stop_early(cfg: DictConfig, valid_loss: float) -> bool: + # skip check if no validation was done in the current epoch + if valid_loss is None: + return False + if cfg.checkpoint.patience <= 0: + return False + + def is_better(a, b): + return a > b if cfg.checkpoint.maximize_best_checkpoint_metric else a < b + + prev_best = getattr(should_stop_early, "best", None) + if prev_best is None or is_better(valid_loss, prev_best): + should_stop_early.best = valid_loss + should_stop_early.num_runs = 0 + return False + else: + should_stop_early.num_runs += 1 + if should_stop_early.num_runs >= cfg.checkpoint.patience: + logger.info( + "early stop since valid performance hasn't improved for last {} runs".format( + cfg.checkpoint.patience + ) + ) + return True + else: + return False + + +@metrics.aggregate("train") +def train( + cfg: DictConfig, trainer: Trainer, task: tasks.FairseqTask, epoch_itr +) -> Tuple[List[Optional[float]], bool]: + """Train the model for one epoch and return validation losses.""" + # Initialize data iterator + itr = epoch_itr.next_epoch_itr( + fix_batches_to_gpus=cfg.distributed_training.fix_batches_to_gpus, + shuffle=(epoch_itr.next_epoch_idx > cfg.dataset.curriculum), + ) + update_freq = ( + cfg.optimization.update_freq[epoch_itr.epoch - 1] + if epoch_itr.epoch <= len(cfg.optimization.update_freq) + else cfg.optimization.update_freq[-1] + ) + itr = iterators.GroupedIterator(itr, update_freq) + if cfg.common.tpu: + itr = utils.tpu_data_loader(itr) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_file=cfg.common.log_file, + log_interval=cfg.common.log_interval, + epoch=epoch_itr.epoch, + tensorboard_logdir=( + cfg.common.tensorboard_logdir + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + wandb_project=( + cfg.common.wandb_project + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + wandb_run_name=os.environ.get( + "WANDB_NAME", os.path.basename(cfg.checkpoint.save_dir) + ), + azureml_logging=( + cfg.common.azureml_logging + if distributed_utils.is_master(cfg.distributed_training) + else False + ), + ) + progress.update_config(_flatten_config(cfg)) + + trainer.begin_epoch(epoch_itr.epoch) + + valid_subsets = cfg.dataset.valid_subset.split(",") + should_stop = False + num_updates = trainer.get_num_updates() + logger.info("Start iterating over samples") + for i, samples in enumerate(progress): + with metrics.aggregate("train_inner"), torch.autograd.profiler.record_function( + "train_step-%d" % i + ): + log_output = trainer.train_step(samples) + + if log_output is not None: # not OOM, overflow, ... + # log mid-epoch stats + num_updates = trainer.get_num_updates() + if num_updates % cfg.common.log_interval == 0: + stats = get_training_stats(metrics.get_smoothed_values("train_inner")) + progress.log(stats, tag="train_inner", step=num_updates) + + # reset mid-epoch stats after each log interval + # the end-of-epoch stats will still be preserved + metrics.reset_meters("train_inner") + + end_of_epoch = not itr.has_next() + valid_losses, should_stop = validate_and_save( + cfg, trainer, task, epoch_itr, valid_subsets, end_of_epoch + ) + + # if (hasattr(cfg.model, 'progressive') or hasattr(cfg.model, 'only_linear_proj') or hasattr(cfg.model, 'freeze_perception')) and end_of_epoch: + # custom_unfreeze(trainer, epoch_itr, cfg.model) + # print_trainable_params_percentage(trainer.model) + + if should_stop: + break + + + # print(i, len(progress)) + # if i > 5: + # break + # log end-of-epoch stats + logger.info("end of epoch {} (average epoch stats below)".format(epoch_itr.epoch)) + stats = get_training_stats(metrics.get_smoothed_values("train")) + progress.print(stats, tag="train", step=num_updates) + print_trainable_params_percentage(trainer.model) + # reset epoch-level meters + metrics.reset_meters("train") + return valid_losses, should_stop + +# progressive training +def custom_unfreeze(trainer, epoch_itr, cfg): + model = trainer.model + epoch = epoch_itr.epoch + print("Epoch, ", epoch) + ## unfreeze epochs + unfreeze_epoch_encoder = cfg.unfreeze_epoch_encoder + unfreeze_epoch_decoder = cfg.unfreeze_epoch_decoder + + unfreeze_epoch_image = cfg.unfreeze_epoch_image + unfreeze_epoch_video = cfg.unfreeze_epoch_video + unfreeze_epoch_audio = cfg.unfreeze_epoch_audio + + + if getattr(cfg, "only_linear_proj", False): + unfreeze_epoch = cfg.unfreeze_epoch + if epoch >= unfreeze_epoch: + model.requires_grad_(True) + + if getattr(cfg, "freeze_encoder_embedding", False) or getattr( + cfg, "encoder_prompt", False) or getattr(cfg, "decoder_prompt", False) or getattr(cfg, "adapter", False): + model.encoder.embed_tokens.weight.requires_grad = False + if getattr(cfg, "freeze_decoder_embedding", False) or getattr( + cfg, "encoder_prompt", False) or getattr(cfg, "decoder_prompt", False) or getattr(cfg, "adapter", False): + model.decoder.embed_tokens.weight.requires_grad = False + + if trainer._ema is not None: + trainer._ema.requires_grad_(False) + print_trainable_params_percentage(model) + return + + if getattr(cfg, "freeze_perception", False): + + if hasattr(model.encoder, 'embed_images'): + if epoch >= unfreeze_epoch_image: + grad = True + else: + grad = False + model.encoder.embed_images.requires_grad_(grad) + print('model.encoder.embed_images.requires_grad', grad) + if hasattr(model.encoder, 'embed_videos'): + if epoch >= unfreeze_epoch_video: + grad = True + else: + grad = False + model.encoder.embed_videos.requires_grad_(grad) + print('model.encoder.embed_videos.requires_grad', grad) + + if hasattr(model.encoder, 'embed_audios'): + if epoch >= unfreeze_epoch_audio: + grad = True + else: + grad = False + model.encoder.embed_audios.requires_grad_(grad) + print('model.encoder.embed_audios.requires_grad', grad) + + if trainer._ema is not None: + trainer._ema.requires_grad_(False) + return + + if epoch >= unfreeze_epoch_encoder: + grad=True + else: + grad=False + for l in model.encoder.layers: + l.requires_grad_(grad) + print('model.encoder.layers.requires_grad', grad) + + if epoch >= unfreeze_epoch_decoder: + grad=True + else: + grad=False + for l in model.decoder.layers: + l.requires_grad_(grad) + print('model.decoder.layers.requires_grad', grad) + + if getattr(cfg, "freeze_encoder_embedding", False) or getattr( + cfg, "encoder_prompt", False) or getattr(cfg, "decoder_prompt", False) or getattr(cfg, "adapter", False): + model.encoder.embed_tokens.weight.requires_grad = False + if getattr(cfg, "freeze_decoder_embedding", False) or getattr( + cfg, "encoder_prompt", False) or getattr(cfg, "decoder_prompt", False) or getattr(cfg, "adapter", False): + model.decoder.embed_tokens.weight.requires_grad = False + + if getattr(cfg, "encoder_prompt", False): + model.encoder.encoder_prompt_encoder.requires_grad_(True) + if getattr(cfg, "decoder_prompt", False): + model.decoder.decoder_prompt_encoder.requires_grad_(True) + if getattr(cfg, "adapter", False): + for idx, layer in enumerate(model.encoder.layers): + layer.adapter.requires_grad_(True) + for idx, layer in enumerate(model.decoder.layers): + layer.adapter.requires_grad_(True) + + if hasattr(model.encoder, 'embed_images'): + if epoch >= unfreeze_epoch_image: + grad = True + else: + grad = False + model.encoder.embed_images.requires_grad_(grad) + print('model.encoder.embed_images.requires_grad', grad) + if hasattr(model.encoder, 'embed_videos'): + if epoch >= unfreeze_epoch_video: + grad = True + else: + grad = False + model.encoder.embed_videos.requires_grad_(grad) + print('model.encoder.embed_videos.requires_grad', grad) + + if hasattr(model.encoder, 'embed_audios'): + if epoch >= unfreeze_epoch_audio: + grad = True + else: + grad = False + model.encoder.embed_audios.requires_grad_(grad) + print('model.encoder.embed_audios.requires_grad', grad) + + if trainer._ema is not None: + trainer._ema.requires_grad_(False) + +def _flatten_config(cfg: DictConfig): + config = OmegaConf.to_container(cfg) + # remove any legacy Namespaces and replace with a single "args" + namespace = None + for k, v in list(config.items()): + if isinstance(v, argparse.Namespace): + namespace = v + del config[k] + if namespace is not None: + config["args"] = vars(namespace) + return config + + +def validate_and_save( + cfg: DictConfig, + trainer: Trainer, + task: tasks.FairseqTask, + epoch_itr, + valid_subsets: List[str], + end_of_epoch: bool, +) -> Tuple[List[Optional[float]], bool]: + num_updates = trainer.get_num_updates() + max_update = cfg.optimization.max_update or math.inf + + # Stopping conditions (and an additional one based on validation loss later + # on) + should_stop = False + if num_updates >= max_update: + should_stop = True + logger.info( + f"Stopping training due to " + f"num_updates: {num_updates} >= max_update: {max_update}" + ) + + training_time_hours = trainer.cumulative_training_time() / (60 * 60) + if ( + cfg.optimization.stop_time_hours > 0 + and training_time_hours > cfg.optimization.stop_time_hours + ): + should_stop = True + logger.info( + f"Stopping training due to " + f"cumulative_training_time: {training_time_hours} > " + f"stop_time_hours: {cfg.optimization.stop_time_hours} hour(s)" + ) + + do_save = ( + (end_of_epoch and epoch_itr.epoch % cfg.checkpoint.save_interval == 0) + or should_stop + or ( + cfg.checkpoint.save_interval_updates > 0 + and num_updates > 0 + and num_updates % cfg.checkpoint.save_interval_updates == 0 + and num_updates >= cfg.dataset.validate_after_updates + ) + ) + do_validate = ( + (not end_of_epoch and do_save) # validate during mid-epoch saves + or (end_of_epoch and epoch_itr.epoch % cfg.dataset.validate_interval == 0) + or should_stop + or ( + cfg.dataset.validate_interval_updates > 0 + and num_updates > 0 + and num_updates % cfg.dataset.validate_interval_updates == 0 + ) + ) and not cfg.dataset.disable_validation and num_updates >= cfg.dataset.validate_after_updates + + # Validate + valid_losses = [None] + if do_validate: + valid_losses = validate(cfg, trainer, task, epoch_itr, valid_subsets) + + should_stop |= should_stop_early(cfg, valid_losses[0]) + + # Save checkpoint + if do_save or should_stop: + checkpoint_utils.save_checkpoint( + cfg.checkpoint, trainer, epoch_itr, valid_losses[0], save_on_cuda=cfg.checkpoint.save_on_cuda, + ) + + return valid_losses, should_stop + + +def get_training_stats(stats: Dict[str, Any]) -> Dict[str, Any]: + stats["wall"] = round(metrics.get_meter("default", "wall").elapsed_time, 0) + return stats + + +def validate( + cfg: DictConfig, + trainer: Trainer, + task: tasks.FairseqTask, + epoch_itr, + subsets: List[str], +) -> List[Optional[float]]: + """Evaluate the model on the validation set(s) and return the losses.""" + + if cfg.dataset.fixed_validation_seed is not None: + # set fixed seed for every validation + utils.set_torch_seed(cfg.dataset.fixed_validation_seed) + + trainer.begin_valid_epoch(epoch_itr.epoch) + valid_losses = [] + for subset in subsets: + logger.info('begin validation on "{}" subset'.format(subset)) + + # Initialize data iterator + itr = trainer.get_valid_iterator(subset).next_epoch_itr( + shuffle=False, set_dataset_epoch=False # use a fixed valid set + ) + if cfg.common.tpu: + itr = utils.tpu_data_loader(itr) + progress = progress_bar.progress_bar( + itr, + log_format=cfg.common.log_format, + log_interval=cfg.common.log_interval, + epoch=epoch_itr.epoch, + prefix=f"valid on '{subset}' subset", + tensorboard_logdir=( + cfg.common.tensorboard_logdir + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"), + wandb_project=( + cfg.common.wandb_project + if distributed_utils.is_master(cfg.distributed_training) + else None + ), + wandb_run_name=os.environ.get( + "WANDB_NAME", os.path.basename(cfg.checkpoint.save_dir) + ), + ) + + # create a new root metrics aggregator so validation metrics + # don't pollute other aggregators (e.g., train meters) + with metrics.aggregate(new_root=True) as agg: + for i, sample in enumerate(progress): + if cfg.dataset.max_valid_steps is not None and i > cfg.dataset.max_valid_steps: + break + try: + # print(sample) + trainer.valid_step(sample) + except IndexError: + # print(sample) + print('didnt pass') + trainer.valid_step(sample) + continue + + # log validation stats + if hasattr(task, 'get_valid_stats'): + stats = task.get_valid_stats(cfg, trainer, agg.get_smoothed_values()) + else: + stats = agg.get_smoothed_values() + stats = get_valid_stats(cfg, trainer, stats) + + if hasattr(task, "post_validate"): + task.post_validate(trainer.get_model(), stats, agg) + + + progress.print(stats, tag=subset, step=trainer.get_num_updates()) + + valid_losses.append(stats[cfg.checkpoint.best_checkpoint_metric]) + return valid_losses + + +def get_valid_stats( + cfg: DictConfig, trainer: Trainer, stats: Dict[str, Any] +) -> Dict[str, Any]: + stats["num_updates"] = trainer.get_num_updates() + if hasattr(checkpoint_utils.save_checkpoint, "best"): + key = "best_{0}".format(cfg.checkpoint.best_checkpoint_metric) + best_function = max if cfg.checkpoint.maximize_best_checkpoint_metric else min + stats[key] = best_function( + checkpoint_utils.save_checkpoint.best, + stats[cfg.checkpoint.best_checkpoint_metric], + ) + return stats + + +def cli_main( + modify_parser: Optional[Callable[[argparse.ArgumentParser], None]] = None +) -> None: + parser = options.get_training_parser() + args = options.parse_args_and_arch(parser, modify_parser=modify_parser) + print(args) + cfg = convert_namespace_to_omegaconf(args) + + if cfg.common.use_plasma_view: + server = PlasmaStore(path=cfg.common.plasma_path) + logger.info(f"Started plasma server pid {server.server.pid} {cfg.common.plasma_path}") + + if args.profile: + with torch.cuda.profiler.profile(): + with torch.autograd.profiler.emit_nvtx(): + distributed_utils.call_main(cfg, main) + else: + distributed_utils.call_main(cfg, main) + + # if cfg.common.use_plasma_view: + # server.server.kill() + + +if __name__ == "__main__": + cli_main() + \ No newline at end of file diff --git a/trainer.py b/trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..59ee5d663b45cf3f7b0a741d6c12e3825c92a193 --- /dev/null +++ b/trainer.py @@ -0,0 +1,1569 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +""" +Train a network across multiple GPUs. +""" + +import contextlib +import logging +import sys +import time +from argparse import Namespace +from itertools import chain +from typing import Any, Dict, List + +import torch +from fairseq import models, optim, utils +from fairseq.dataclass.configs import FairseqConfig +from fairseq.dataclass.utils import convert_namespace_to_omegaconf +from fairseq.distributed import utils as distributed_utils +from fairseq.file_io import PathManager +from fairseq.logging import meters, metrics +from fairseq.models.ema import build_ema +from fairseq.nan_detector import NanDetector +from fairseq.optim import lr_scheduler +from omegaconf import OmegaConf + +from utils import checkpoint_utils +import torch.nn as nn + +logger = logging.getLogger(__name__) + + +class Trainer(object): + """Main class for data parallel training. + + This class supports synchronous distributed data parallel training, + where multiple workers each have a full model replica and gradients + are accumulated across workers before each update. We use + :class:`~torch.nn.parallel.DistributedDataParallel` to handle + communication of the gradients across workers. + """ + + def __init__(self, cfg: FairseqConfig, task, model, criterion, quantizer=None): + + if isinstance(cfg, Namespace): + logger.warning( + "argparse.Namespace configuration is deprecated! Automatically converting to OmegaConf" + ) + cfg = convert_namespace_to_omegaconf(cfg) + + self.cfg = cfg + self.task = task + + # catalog shared parameters + shared_params = _catalog_shared_params(model) + self.tpu = cfg.common.tpu + self.cuda = torch.cuda.is_available() and not cfg.common.cpu and not self.tpu + if self.cuda: + self.device = torch.device("cuda") + elif self.tpu: + self.device = utils.get_tpu_device() + else: + self.device = torch.device("cpu") + + if self.is_fsdp: + import fairscale + if self.cfg.common.bf16: + raise ValueError( + "FullyShardedDataParallel is not compatible with --bf16 or " + "--memory-efficient-bf16" + ) + if self.cfg.distributed_training.zero_sharding != "none": + raise ValueError( + "FullyShardedDataParallel is not compatible with --zero-sharding " + "option (it's already built in)" + ) + if max(self.cfg.optimization.update_freq) > 1 and fairscale.__version__ < "0.4.0": + raise RuntimeError( + "Please update to fairscale 0.4.0 or newer when combining " + "--update-freq with FullyShardedDataParallel" + ) + else: + if ( + hasattr(self.cfg.distributed_training, "cpu_offload") + and self.cfg.distributed_training.cpu_offload + ): + raise ValueError("--cpu-offload requires --ddp-backend=fully_sharded") + + # copy model and criterion to current device/dtype + self._criterion = criterion + self._model = model + if not self.is_fsdp: + if cfg.common.fp16: + assert not cfg.common.amp, "Cannot use fp16 and AMP together" + self._criterion = self._criterion.half() + self._model = self._model.half() + + if hasattr(self._model.encoder, 'embed_audios'): + from torchlibrosa.stft import Spectrogram, LogmelFilterBank + for layer in self._model.modules(): + if isinstance(layer, LogmelFilterBank) or isinstance(layer, Spectrogram): + layer.float() + print(layer) + # for layer in self._model.modules(): + # if isinstance(layer, nn.BatchNorm2d): + # layer.float() + # print(layer) + + + elif cfg.common.bf16: + self._criterion = self._criterion.to(dtype=torch.bfloat16) + self._model = self._model.to(dtype=torch.bfloat16) + elif cfg.common.amp: + self._amp_retries = 0 + if ( + not cfg.distributed_training.pipeline_model_parallel + # the DistributedFairseqModel wrapper will handle moving to device, + # so only handle cases which don't use the wrapper + and not self.use_distributed_wrapper + ): + self._criterion = self._criterion.to(device=self.device) + self._model = self._model.to(device=self.device) + self.pipeline_model_parallel = cfg.distributed_training.pipeline_model_parallel + self.last_device = None + if self.cuda and self.pipeline_model_parallel: + self.last_device = torch.device( + cfg.distributed_training.pipeline_devices[-1] + ) + + # check that shared parameters are preserved after device transfer + for shared_param in shared_params: + ref = _get_module_by_path(self._model, shared_param[0]) + for path in shared_param[1:]: + logger.info( + "detected shared parameter: {} <- {}".format(shared_param[0], path) + ) + _set_module_by_path(self._model, path, ref) + + self._dummy_batch = None # indicates we don't have a dummy batch at first + self._lr_scheduler = None + self._num_updates = 0 + self._num_xla_compiles = 0 # for TPUs + self._optim_history = None + self._optimizer = None + self._warn_once = set() + self._wrapped_criterion = None + self._wrapped_model = None + self._ema = None + + # TODO(myleott): support tpu + if self.cuda and self.data_parallel_world_size > 1: + self._grad_norm_buf = torch.cuda.DoubleTensor(self.data_parallel_world_size) + else: + self._grad_norm_buf = None + + self.quantizer = quantizer + if self.quantizer is not None: + self.quantizer.set_trainer(self) + + # get detailed cuda environment + if self.cuda: + self.cuda_env = utils.CudaEnvironment() + if self.data_parallel_world_size > 1: + self.cuda_env_arr = distributed_utils.all_gather_list( + self.cuda_env, group=distributed_utils.get_global_group() + ) + else: + self.cuda_env_arr = [self.cuda_env] + if self.data_parallel_rank == 0: + utils.CudaEnvironment.pretty_print_cuda_env_list(self.cuda_env_arr) + else: + self.cuda_env = None + self.cuda_env_arr = None + + metrics.log_start_time("wall", priority=790, round=0) + + self._start_time = time.time() + self._previous_training_time = 0 + self._cumulative_training_time = None + + def reinitialize(self): + """Reinitialize the Trainer, typically after model params change.""" + self._lr_scheduler = None + self._optimizer = None + self._wrapped_criterion = None + self._wrapped_model = None + + @property + def data_parallel_world_size(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 1 + return distributed_utils.get_data_parallel_world_size() + + @property + def data_parallel_process_group(self): + return distributed_utils.get_data_parallel_group() + + @property + def data_parallel_rank(self): + if self.cfg.distributed_training.distributed_world_size == 1: + return 0 + return distributed_utils.get_data_parallel_rank() + + @property + def is_data_parallel_master(self): + # NOTE: this returns true for all model parallel replicas with data + # parallel rank 0 + return self.data_parallel_rank == 0 + + @property + def use_distributed_wrapper(self) -> bool: + return ( + self.data_parallel_world_size > 1 and not self.cfg.optimization.use_bmuf + ) or ( + self.is_fsdp and self.cfg.distributed_training.cpu_offload + ) + + @property + def should_save_checkpoint_on_current_rank(self) -> bool: + """Indicates whether to save checkpoints on the current DDP rank.""" + if ( + self.is_fsdp and self.cfg.distributed_training.use_sharded_state + ) or getattr(self.cfg.model, "base_layers", 0) > 0: + return True + else: + return self.is_data_parallel_master + + @property + def always_call_state_dict_during_save_checkpoint(self) -> bool: + if self.is_fsdp and not self.cfg.distributed_training.use_sharded_state: + # FSDP calls communication collective when consolidating checkpoints + return True + else: + return False + + @property + def checkpoint_suffix(self) -> str: + """Suffix to add to the checkpoint file name.""" + if self.is_fsdp and self.cfg.distributed_training.use_sharded_state: + return self.cfg.checkpoint.checkpoint_suffix + "-shard{0}".format( + self.data_parallel_rank + ) + else: + return self.cfg.checkpoint.checkpoint_suffix or "" + + @property + def criterion(self): + if self._wrapped_criterion is None: + if utils.has_parameters(self._criterion) and self.use_distributed_wrapper: + self._wrapped_criterion = models.DistributedFairseqModel( + self.cfg.distributed_training, + self._criterion, + process_group=self.data_parallel_process_group, + device=self.device, + ) + else: + self._wrapped_criterion = self._criterion + return self._wrapped_criterion + + @property + def model(self): + if self._wrapped_model is None: + if self.use_distributed_wrapper: + self._wrapped_model = models.DistributedFairseqModel( + self.cfg.distributed_training, + self._model, + process_group=self.data_parallel_process_group, + device=self.device, + ) + else: + self._wrapped_model = self._model + return self._wrapped_model + + @property + def ema(self): + if self._ema is None: + self._build_ema() + return self._ema + + def _build_ema(self): + if self.cfg.ema.store_ema: + self._ema = build_ema(self._model, self.cfg.ema, self.device) + logger.info( + "Exponential Moving Average Shadow Model is initialized." + ) + + @property + def optimizer(self): + if self._optimizer is None: + self._build_optimizer() + return self._optimizer + + @property + def lr_scheduler(self): + if self._lr_scheduler is None: + self._build_optimizer() # this will initialize self._lr_scheduler + return self._lr_scheduler + + def _build_optimizer(self): + # params = list(self.model.parameters()) + # print("len of model param:", len(params)) + # params += list( + # filter( + # lambda p: p.requires_grad, + # chain(self.criterion.parameters()), + # ) + # ) + + + params = list( + filter( + lambda p: p.requires_grad, + chain(self.model.parameters(), self.criterion.parameters()), + ) + ) + print("len of optim param:", len(params)) + + if self.is_fsdp and self.cfg.common.fp16: + # FullyShardedDataParallel always uses MemoryEfficientFP16 wrapper, + # mostly for the grad scaling. But if we don't have the + # --memory-efficient-fp16 flag set, then we're effectively doing + # regular --fp16 and can allow the use of optimizers that would + # otherwise be unsupported by MemoryEfficientFP16Optimizer. + allow_unsupported = not self.cfg.common.memory_efficient_fp16 + self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer( + self.cfg, params, allow_unsupported=allow_unsupported + ) + elif self.cfg.common.fp16 or self.cfg.common.bf16 or self.cfg.common.amp: + if self.cuda and torch.cuda.get_device_capability(0)[0] < 7: + logger.info( + "NOTE: your device does NOT support faster training with --fp16 or --amp, " + "please switch to FP32 which is likely to be faster" + ) + if ( + self.cfg.common.memory_efficient_fp16 + or self.cfg.common.memory_efficient_bf16 + ): + self._optimizer = optim.MemoryEfficientFP16Optimizer.build_optimizer( + self.cfg, params + ) + elif self.cfg.common.amp: + self._optimizer = optim.AMPOptimizer.build_optimizer(self.cfg, params) + else: + self._optimizer = optim.FP16Optimizer.build_optimizer(self.cfg, params) + else: + if self.cuda and torch.cuda.get_device_capability(0)[0] >= 7: + logger.info("NOTE: your device may support faster training with --fp16 or --amp") + self._optimizer = optim.build_optimizer(self.cfg.optimizer, params) + + if self.is_fsdp: + assert ( + not self.cfg.optimization.use_bmuf + ), "--ddp-backend=fully_sharded is not compatible with BMUF" + assert self._optimizer.supports_flat_params, ( + "--ddp-backend=fully_sharded is only compatible with pointwise " + "optimizers (e.g., Adam, AdamW, Adadelta, Adamax, SGD, etc.). " + "However, the sharding will result in slightly different results when " + "using non-pointwise optimizers (e.g., Adagrad, Adafactor, LAMB)" + ) + + if self.cfg.optimization.use_bmuf: + self._optimizer = optim.FairseqBMUF( + self.cfg.bmuf, + self._optimizer, + ) + + if self.cfg.distributed_training.zero_sharding == "os": + if ( + self.cfg.common.fp16 + and not self.cfg.common.memory_efficient_fp16 + and not self.cfg.common.memory_efficient_bf16 + ) and not self.cfg.common.fp16_no_flatten_grads: + raise ValueError( + "ZeRO is incomptabile with fp16 and flattened grads. " + "Please use --fp16-no-flatten-grads" + ) + else: + optim.shard_(self._optimizer, self.data_parallel_process_group) + + # We should initialize the learning rate scheduler immediately after + # building the optimizer, so that the initial learning rate is set. + self._lr_scheduler = lr_scheduler.build_lr_scheduler( + self.cfg.lr_scheduler, + self.optimizer, + ) + self._lr_scheduler.step_update(0) + + @property + def is_fsdp(self): + return self.cfg.distributed_training.ddp_backend == "fully_sharded" + + def consolidate_optimizer(self): + """For OSS, we need to consolidate the state dict.""" + if self.cfg.checkpoint.no_save_optimizer_state: + return + self._gathered_optim_state = None + if hasattr(self.optimizer.optimizer, "consolidate_state_dict"): + self.optimizer.optimizer.consolidate_state_dict() + elif self.is_fsdp and not self.model.use_sharded_state: + st = self.model.gather_full_optim_state_dict( + self.optimizer + ) # only returns on rank 0 + self._gathered_optim_state = st + + def state_dict(self): + state_dict = { + "args": None, # legacy + "cfg": ( + OmegaConf.to_container(self.cfg, resolve=True, enum_to_str=True) + if OmegaConf.is_config(self.cfg) + else self.cfg + ), + "model": self.model.state_dict(), + "criterion": ( + self.criterion.state_dict() + if utils.has_parameters(self.criterion) + else None + ), + "optimizer_history": (self._optim_history or []) + + [ + { + "criterion_name": self.get_criterion().__class__.__name__, + "optimizer_name": self.optimizer.__class__.__name__, + "lr_scheduler_state": self.lr_scheduler.state_dict(), + "num_updates": self.get_num_updates(), + } + ], + "task_state": self.task.state_dict() if self.task is not None else {}, + "extra_state": { + "metrics": metrics.state_dict(), + "previous_training_time": self.cumulative_training_time(), + }, + } + if self.cfg.ema.store_ema: + # Save EMA model state as extra state + state_dict["extra_state"]["ema"] = self.ema.get_model().state_dict() + if self.cfg.ema.ema_fp32: + # Save EMA params in fp32 + state_dict["extra_state"]["ema_fp32_params"] = self.ema.fp32_params + if not self.cfg.checkpoint.no_save_optimizer_state: + if self._gathered_optim_state is not None: + state_dict["last_optimizer_state"] = self._gathered_optim_state + self._gathered_optim_state = None + else: + state_dict["last_optimizer_state"] = self.optimizer.state_dict() + if self.is_fsdp: + # save meta data for recombining checkpoint upon loading + state_dict["fsdp_metadata"] = self.model.local_metadata_dict() + return state_dict + + def save_checkpoint(self, filename, extra_state, save_on_cuda=False): + """Save all training state in a checkpoint file.""" + logger.info(f"Saving checkpoint to {filename}") + # call state_dict on all ranks in case it needs internal communication + if not save_on_cuda: + state_dict = utils.move_to_cpu(self.state_dict()) + else: + print("Save on cuda") + state_dict = self.state_dict() + state_dict["extra_state"].update(extra_state) + if self.should_save_checkpoint_on_current_rank: + checkpoint_utils.torch_persistent_save( + state_dict, + filename, + async_write=self.cfg.checkpoint.write_checkpoints_asynchronously, + ) + logger.info(f"Finished saving checkpoint to {filename}") + + def load_checkpoint( + self, + filename, + reset_optimizer=False, + reset_lr_scheduler=False, + optimizer_overrides=None, + reset_meters=False, + strict=True, + load_on_cuda=False, + ): + """ + Load all training state from a checkpoint file. + rank = 0 will load the checkpoint, and then broadcast it to all + other ranks. + """ + extra_state, self._optim_history, last_optim_state = None, [], None + + logger.info(f"Preparing to load checkpoint {filename}") + is_distributed = self.data_parallel_world_size > 1 + bexists = PathManager.isfile(filename) + if bexists: + load_on_all_ranks = ( + self.cfg.checkpoint.load_checkpoint_on_all_dp_ranks + # TPUs don't support broadcast yet, so load checkpoints + # on every worker for now + or self.tpu + # FSDP requires loading checkpoint shards on all ranks + or (self.is_fsdp and self.cfg.distributed_training.use_sharded_state) + or getattr(self.cfg.model, "base_layers", 0) > 0 + ) + + if load_on_all_ranks or self.data_parallel_rank == 0: + state = checkpoint_utils.load_checkpoint_to_cpu( + filename, load_on_all_ranks=load_on_all_ranks, strict=strict,load_on_cuda=load_on_cuda, + ) + last_optim_state = state.get("last_optimizer_state", None) + + # If doing zero_sharding, do not broadcast global optimizer + # state. Later we will broadcast sharded states to each rank + # to avoid memory from exploding. + if ( + not load_on_all_ranks + and self.cfg.distributed_training.zero_sharding == "os" + and "last_optimizer_state" in state + and is_distributed + ): + state["last_optimizer_state"] = "SHARDED" + else: + last_optim_state = None + state = None + + if is_distributed and not load_on_all_ranks: # .contiguous() + state = distributed_utils.broadcast_object( + state, + src_rank=0, + group=self.data_parallel_process_group, + dist_device=self.device, + ) + if self.data_parallel_rank > 0: + last_optim_state = state.get("last_optimizer_state", None) + + # load model parameters + try: + if self.cfg.checkpoint.use_ema_weights_to_init_param and "extra_state" in state and "ema" in state["extra_state"]: + logger.info("use_ema_weights_to_init_param = True, will use EMA weights in the ckpt to init the model param...") + ema_state_dict = state["extra_state"]["ema_fp32_params"] if "ema_fp32_params" in state["extra_state"] else state["extra_state"]["ema"] + msg = self.model.load_state_dict( + ema_state_dict, strict=strict, model_cfg=self.cfg.model + ) + else: + msg = self.model.load_state_dict( + state["model"], strict=strict, model_cfg=self.cfg.model + ) + logger.info(msg) + + # save memory for later steps + if not (self.cfg.ema.store_ema and (self.cfg.checkpoint.use_latest_weights_to_init_ema or not ("extra_state" in state and "ema" in state["extra_state"]))): + del state["model"] + if utils.has_parameters(self.get_criterion()) and 'criterion' in state: + self.get_criterion().load_state_dict( + state["criterion"], strict=strict + ) + del state["criterion"] + + except Exception: + raise Exception( + "Cannot load model parameters from checkpoint {}; " + "please ensure that the architectures match.".format(filename) + ) + extra_state = state.get("extra_state", None) + self._optim_history = state.get("optimizer_history", None) + + if last_optim_state is not None and not reset_optimizer: + # rebuild optimizer after loading model, since params may have changed + self._build_optimizer() + + # only reload optimizer and lr_scheduler if they match + last_optim = self._optim_history[-1] + assert ( + last_optim["criterion_name"] == self.get_criterion().__class__.__name__ + ), f"Criterion does not match; please reset the optimizer (--reset-optimizer). {last_optim['criterion_name']} vs {self.get_criterion().__class__.__name__}" + assert ( + last_optim["optimizer_name"] == self.optimizer.__class__.__name__ + ), f"Optimizer does not match; please reset the optimizer (--reset-optimizer). {last_optim['optimizer_name']} vs {self.optimizer.__class__.__name__}" + + if not reset_lr_scheduler: + self.lr_scheduler.load_state_dict(last_optim["lr_scheduler_state"]) + + if self.is_fsdp and not self.model.use_sharded_state: + # if use_sharded_state, the last_optim_state is already sharded, skip this + last_optim_state = self.model.get_shard_from_optim_state_dict( + last_optim_state + ) + elif not load_on_all_ranks and is_distributed: + last_optim_state = self.optimizer.broadcast_global_state_dict( + last_optim_state + ) + + self.optimizer.load_state_dict(last_optim_state, optimizer_overrides) + + self.set_num_updates(last_optim["num_updates"]) + + if extra_state is not None: + itr_state = extra_state["train_iterator"] + epoch = itr_state["epoch"] + + if "previous_training_time" in extra_state: + self._previous_training_time = extra_state["previous_training_time"] + self._start_time = time.time() + + self.lr_step(epoch) + + if ( + itr_state.get("version", 1) >= 2 + and itr_state["iterations_in_epoch"] == 0 + ): + # reset meters at start of epoch + reset_meters = True + + if "metrics" in extra_state and not reset_meters: + metrics.load_state_dict(extra_state["metrics"]) + + # reset TimeMeters, since their start times don't make sense anymore + for meter in metrics.get_meters("default"): + if isinstance(meter, meters.TimeMeter): + meter.reset() + + if self.cfg.ema.store_ema: + if self.cfg.checkpoint.use_latest_weights_to_init_ema or "ema" not in extra_state: + if "ema" not in extra_state: + logger.warn( + "EMA not found in checkpoint. But store_ema is True. " + "EMA is re-initialized from checkpoint." + ) + elif self.cfg.checkpoint.use_latest_weights_to_init_ema: + logger.info( + "use_latest_weights_to_init_ema = True. EMA is re-initialized from checkpoint." + ) + self.ema.restore(state["model"], build_fp32_params=self.cfg.ema.ema_fp32) + del state["model"] + else: + logger.info( + "Loading EMA from checkpoint" + ) + self.ema.restore(extra_state["ema"], build_fp32_params=False) + + if self.cfg.ema.ema_fp32: + if "ema_fp32_params" in extra_state: + logger.info( + "Loading EMA fp32 params from checkpoint" + ) + self.ema.build_fp32_params(extra_state["ema_fp32_params"]) + else: + logger.info( + "Building EMA fp32 params from EMA model in checkpoint" + ) + self.ema.build_fp32_params() + + logger.info( + "Loaded checkpoint {} (epoch {} @ {} updates)".format( + filename, epoch, self.get_num_updates() + ) + ) + + else: + logger.info("No existing checkpoint found {}".format(filename)) + + # print("delete state ...") + # del state # dereference seems crucial + # torch.cuda.empty_cache() + + return extra_state + + def get_train_iterator( + self, + epoch, + combine=True, + load_dataset=True, + data_selector=None, + shard_batch_itr=True, + disable_iterator_cache=False, + ): + """Return an EpochBatchIterator over the training set for a given epoch.""" + if load_dataset: + logger.info("loading train data for epoch {}".format(epoch)) + self.task.load_dataset( + self.cfg.dataset.train_subset, + epoch=epoch, + combine=combine, + data_selector=data_selector, + tpu=self.tpu, + ) + batch_iterator = self.task.get_batch_iterator( + dataset=self.task.dataset(self.cfg.dataset.train_subset), + max_tokens=self.cfg.dataset.max_tokens, + max_sentences=self.cfg.dataset.batch_size, + max_positions=utils.resolve_max_positions( + self.task.max_positions(), + self.model.max_positions(), + self.cfg.dataset.max_tokens, + ), + ignore_invalid_inputs=True, + required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple, + seed=self.cfg.common.seed, + num_shards=self.data_parallel_world_size if shard_batch_itr else 1, + shard_id=self.data_parallel_rank if shard_batch_itr else 0, + num_workers=self.cfg.dataset.num_workers, + epoch=epoch, + data_buffer_size=self.cfg.dataset.data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ) + self.reset_dummy_batch(batch_iterator.first_batch) + batch_iterator.dataset.dataset._seek() + return batch_iterator + + def get_valid_iterator( + self, + subset, + disable_iterator_cache=False, + ): + """Return an EpochBatchIterator over given validation subset for a given epoch.""" + self.task.dataset(subset).dataset._seek() + batch_iterator = self.task.get_batch_iterator( + dataset=self.task.dataset(subset), + max_tokens=self.cfg.dataset.max_tokens_valid, + max_sentences=self.cfg.dataset.batch_size_valid, + max_positions=utils.resolve_max_positions( + self.task.max_positions(), + self.model.max_positions(), + ), + ignore_invalid_inputs=self.cfg.dataset.skip_invalid_size_inputs_valid_test, + required_batch_size_multiple=self.cfg.dataset.required_batch_size_multiple, + seed=self.cfg.common.seed, + num_shards=self.data_parallel_world_size, + shard_id=self.data_parallel_rank, + num_workers=self.cfg.dataset.num_workers, + # always pass a fixed "epoch" to keep validation data consistent + # across training epochs + epoch=1, + data_buffer_size=self.cfg.dataset.data_buffer_size, + disable_iterator_cache=disable_iterator_cache, + ) + self.reset_dummy_batch(batch_iterator.first_batch) + batch_iterator.dataset.dataset._seek() + return batch_iterator + + def begin_epoch(self, epoch): + """Called at the beginning of each epoch.""" + logger.info("begin training epoch {}".format(epoch)) + + self.lr_step_begin_epoch(epoch) + + if self.quantizer is not None: + self.quantizer.begin_epoch(epoch) + + # task specific setup per epoch + self.task.begin_epoch(epoch, self.get_model()) + + if self.tpu: + import torch_xla.core.xla_model as xm + + xm.rendezvous("begin_epoch") # wait for all workers + xm.mark_step() + + def begin_valid_epoch(self, epoch): + """Called at the beginning of each validation epoch.""" + + # task specific setup per validation epoch + self.task.begin_valid_epoch(epoch, self.get_model()) + + def reset_dummy_batch(self, batch): + self._dummy_batch = batch + + @metrics.aggregate("train") + def train_step(self, samples, raise_oom=False): + """Do forward, backward and parameter update.""" + self._set_seed() + self.model.train() + self.criterion.train() + self.zero_grad() + + metrics.log_start_time("train_wall", priority=800, round=0) + + # If EMA is enabled through store_ema=True + # and task.uses_ema is True, pass the EMA model as a keyword + # argument to the task. + extra_kwargs = {} + if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False): + extra_kwargs["ema_model"] = self.ema.get_model() + + # forward and backward pass + logging_outputs, sample_size, ooms = [], 0, 0 + for i, sample in enumerate(samples): # delayed update loop + sample, is_dummy_batch = self._prepare_sample(sample) + + def maybe_no_sync(): + """ + Whenever *samples* contains more than one mini-batch, we + want to accumulate gradients locally and only call + all-reduce in the last backwards pass. + """ + if ( + self.data_parallel_world_size > 1 + and hasattr(self.model, "no_sync") + and i < len(samples) - 1 + # The no_sync context manager results in increased memory + # usage with FSDP, since full-size gradients will be + # accumulated on each GPU. It's typically a better tradeoff + # to do the extra communication with FSDP. + and not self.is_fsdp + ): + return self.model.no_sync() + else: + return contextlib.ExitStack() # dummy contextmanager + + try: + with maybe_no_sync(): + # forward and backward + loss, sample_size_i, logging_output = self.task.train_step( + sample=sample, + model=self.model, + criterion=self.criterion, + optimizer=self.optimizer, + update_num=self.get_num_updates(), + ignore_grad=is_dummy_batch, + **extra_kwargs, + ) + del loss + + logging_outputs.append(logging_output) + sample_size += sample_size_i + + # emptying the CUDA cache after the first step can + # reduce the chance of OOM + if self.cuda and self.get_num_updates() == 0: + torch.cuda.empty_cache() + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + if raise_oom: + raise e + logger.warning( + "attempting to recover from OOM in forward/backward pass" + ) + ooms += 1 + self.zero_grad() + if self.cuda: + torch.cuda.empty_cache() + if self.cfg.distributed_training.distributed_world_size == 1: + return None + else: + raise e + + if self.tpu and i < len(samples) - 1: + # tpu-comment: every XLA operation before marking step is + # appended to the IR graph, and processing too many batches + # before marking step can lead to OOM errors. + # To handle gradient accumulation use case, we explicitly + # mark step here for every forward pass without a backward pass + self._xla_markstep_and_send_to_cpu() + + if is_dummy_batch: + if torch.is_tensor(sample_size): + sample_size.zero_() + else: + sample_size *= 0.0 + + if torch.is_tensor(sample_size): + sample_size = sample_size.float() + else: + sample_size = float(sample_size) + + # gather logging outputs from all replicas + if self._sync_stats(): + train_time = self._local_cumulative_training_time() + logging_outputs, ( + sample_size, + ooms, + total_train_time, + ) = self._aggregate_logging_outputs( + logging_outputs, sample_size, ooms, train_time, ignore=is_dummy_batch + ) + self._cumulative_training_time = ( + total_train_time / self.data_parallel_world_size + ) + + overflow = False + try: + with torch.autograd.profiler.record_function("reduce-grads"): + # reduce gradients across workers + self.optimizer.all_reduce_grads(self.model) + if utils.has_parameters(self.criterion): + self.optimizer.all_reduce_grads(self.criterion) + + with torch.autograd.profiler.record_function("multiply-grads"): + # multiply gradients by (data_parallel_size / sample_size) since + # DDP normalizes by the number of data parallel workers for + # improved fp16 precision. + # Thus we get (sum_of_gradients / sample_size) at the end. + # In case of fp16, this step also undoes loss scaling. + # (Debugging note: Some optimizers perform this scaling on the + # fly, so inspecting model.parameters() or optimizer.params may + # still show the original, unscaled gradients.) + numer = ( + self.data_parallel_world_size + if not self.cfg.optimization.use_bmuf or self._sync_stats() + else 1 + ) + self.optimizer.multiply_grads(numer / (sample_size or 1.0)) + # Note: (sample_size or 1.0) handles the case of a zero gradient, in a + # way that avoids CPU/device transfers in case sample_size is a GPU or + # TPU object. The assumption is that the gradient itself is also 0. + + with torch.autograd.profiler.record_function("clip-grads"): + # clip grads + grad_norm = self.clip_grad_norm(self.cfg.optimization.clip_norm) + + # check that grad norms are consistent across workers + # on tpu check tensor is slow + if not self.tpu: + if ( + not self.cfg.optimization.use_bmuf + and self.cfg.distributed_training.ddp_backend != "slow_mo" + ): + self._check_grad_norms(grad_norm) + if not torch.isfinite(grad_norm).all(): + # in case of AMP, if gradients are Nan/Inf then + # optimizer step is still required + if self.cfg.common.amp: + overflow = True + else: + # check local gradnorm single GPU case, trigger NanDetector + raise FloatingPointError("gradients are Nan/Inf") + + with torch.autograd.profiler.record_function("optimizer"): + # take an optimization step + self.task.optimizer_step( + self.optimizer, model=self.model, update_num=self.get_num_updates() + ) + if self.cfg.common.amp and overflow: + if self._amp_retries == self.cfg.common.amp_batch_retries: + logger.info("AMP: skipping this batch.") + self._amp_retries = 0 + else: + self._amp_retries += 1 + return self.train_step(samples, raise_oom) # recursion to feed in same batch + + except FloatingPointError: + # re-run the forward and backward pass with hooks attached to print + # out where it fails + self.zero_grad() + with NanDetector(self.get_model()): + for _, sample in enumerate(samples): + sample, _ = self._prepare_sample(sample) + self.task.train_step( + sample, + self.model, + self.criterion, + self.optimizer, + self.get_num_updates(), + ignore_grad=False, + **extra_kwargs, + ) + raise + except OverflowError as e: + overflow = True + logger.info( + f"NOTE: gradient overflow detected, ignoring gradient, {str(e)}" + ) + grad_norm = torch.tensor(0.0).cuda() + self.zero_grad() + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + logger.error("OOM during optimization, irrecoverable") + raise e + + # Some distributed wrappers (e.g., SlowMo) need access to the optimizer + # after the step + if hasattr(self.model, "perform_additional_optimizer_actions"): + if hasattr(self.optimizer, "fp32_params"): + self.model.perform_additional_optimizer_actions( + self.optimizer.optimizer, self.optimizer.fp32_params + ) + else: + self.model.perform_additional_optimizer_actions( + self.optimizer.optimizer + ) + + logging_output = None + if not overflow or self.cfg.distributed_training.ddp_backend == "slow_mo": + self.set_num_updates(self.get_num_updates() + 1) + + if self.cfg.ema.store_ema: + # Step EMA forward with new model. + self.ema.step( + self.get_model(), + self.get_num_updates(), + ) + metrics.log_scalar( + "ema_decay", + self.ema.get_decay(), + priority=10000, + round=5, + weight=0, + ) + + if self.tpu: + import torch_xla.core.xla_model as xm + + # mark step on TPUs + self._xla_markstep_and_send_to_cpu() + + # only log stats every log_interval steps + # this causes wps to be misreported when log_interval > 1 + logging_output = {} + if self.get_num_updates() % self.cfg.common.log_interval == 0: + # log memory usage + mem_info = xm.get_memory_info(self.device) + gb_free = mem_info["kb_free"] / 1024 / 1024 + gb_total = mem_info["kb_total"] / 1024 / 1024 + metrics.log_scalar( + "gb_free", gb_free, priority=1500, round=1, weight=0 + ) + metrics.log_scalar( + "gb_total", gb_total, priority=1600, round=1, weight=0 + ) + logging_outputs = self._xla_markstep_and_send_to_cpu( + logging_outputs + ) + logging_output = self._reduce_and_log_stats( + logging_outputs, sample_size, grad_norm + ) + + # log whenever there's an XLA compilation, since these + # slow down training and may indicate opportunities for + # optimization + self._check_xla_compilation() + else: + if self.cuda and self.cuda_env is not None: + # log minimum free memory over the iteration + gb_used = torch.cuda.max_memory_allocated() / 1024 / 1024 / 1024 + torch.cuda.reset_peak_memory_stats() + gb_free = self.cuda_env.total_memory_in_GB - gb_used + metrics.log_scalar( + "gb_free", gb_free, priority=1500, round=1, weight=0 + ) + + # log stats + logging_output = self._reduce_and_log_stats( + logging_outputs, sample_size, grad_norm + ) + + # clear CUDA cache to reduce memory fragmentation + if ( + self.cuda + and self.cfg.common.empty_cache_freq > 0 + and ( + (self.get_num_updates() + self.cfg.common.empty_cache_freq - 1) + % self.cfg.common.empty_cache_freq + ) + == 0 + ): + torch.cuda.empty_cache() + + if self.cfg.common.fp16 or self.cfg.common.amp: + metrics.log_scalar( + "loss_scale", + ( + self.optimizer.scaler.loss_scale + if self.cfg.common.fp16 + else self.optimizer.scaler.get_scale() + ), + priority=700, + round=4, + weight=0, + ) + + metrics.log_stop_time("train_wall") + return logging_output + + @metrics.aggregate("valid") + def valid_step(self, sample, raise_oom=False): + """Do forward pass in evaluation mode.""" + if self.tpu: + import torch_xla.core.xla_model as xm + + xm.rendezvous("valid_step") # wait for all workers + + # If EMA is enabled through store_ema=True + # and task.uses_ema is True, pass the EMA model as a keyword + # argument to the task. + extra_kwargs = {} + if self.cfg.ema.store_ema and getattr(self.task, "uses_ema", False): + extra_kwargs["ema_model"] = self.ema.get_model() + + with torch.no_grad(): + self.model.eval() + self.criterion.eval() + + sample, is_dummy_batch = self._prepare_sample(sample) + + try: + _loss, sample_size, logging_output = self.task.valid_step( + sample, self.model, self.criterion, **extra_kwargs + ) + except RuntimeError as e: + if "out of memory" in str(e): + self._log_oom(e) + if not raise_oom: + logger.warning( + "ran out of memory in validation step, retrying batch" + ) + for p in self.model.parameters(): + if p.grad is not None: + p.grad = None # free some memory + if self.cuda: + torch.cuda.empty_cache() + return self.valid_step(sample, raise_oom=True) + raise e + + + logging_outputs = [logging_output] + if is_dummy_batch: + if torch.is_tensor(sample_size): + sample_size.zero_() + else: + sample_size *= 0.0 + + # gather logging outputs from all replicas + if self.data_parallel_world_size > 1: + logging_outputs, (sample_size,) = self._aggregate_logging_outputs( + logging_outputs, + sample_size, + ignore=is_dummy_batch, + ) + + # log validation stats + if self.tpu: + logging_outputs = self._xla_markstep_and_send_to_cpu(logging_outputs) + logging_output = self._reduce_and_log_stats(logging_outputs, sample_size) + + return logging_output + + def zero_grad(self): + self.optimizer.zero_grad() + + def lr_step_begin_epoch(self, epoch): + """Adjust the learning rate at the beginning of the epoch.""" + self.lr_scheduler.step_begin_epoch(epoch) + # prefer updating the LR based on the number of steps + return self.lr_step_update() + + def lr_reinit(self, total_updates, num_updates): + self.lr_scheduler.reinit(total_updates, num_updates) + + def lr_step(self, epoch, val_loss=None): + """Adjust the learning rate at the end of the epoch.""" + self.lr_scheduler.step(epoch, val_loss) + # prefer updating the LR based on the number of steps + return self.lr_step_update() + + def lr_step_update(self): + """Update the learning rate after each update.""" + new_lr = self.lr_scheduler.step_update(self.get_num_updates()) + if isinstance(new_lr, dict): + for k, v in new_lr.items(): + metrics.log_scalar(f"lr_{k}", v, weight=0, priority=300) + new_lr = new_lr.get("default", next(iter(new_lr.values()))) + else: + metrics.log_scalar("lr", new_lr, weight=0, priority=300) + return new_lr + + def get_lr(self): + """Get the current learning rate.""" + return self.optimizer.get_lr() + + def get_model(self): + """Get the (non-wrapped) model instance.""" + return self._model + + def get_criterion(self): + """Get the (non-wrapped) criterion instance.""" + return self._criterion + + def get_meter(self, name): + """[deprecated] Get a specific meter by name.""" + from fairseq import meters + + if "get_meter" not in self._warn_once: + self._warn_once.add("get_meter") + utils.deprecation_warning( + "Trainer.get_meter is deprecated. Please use fairseq.metrics instead." + ) + + train_meters = metrics.get_meters("train") + if train_meters is None: + train_meters = {} + + if name == "train_loss" and "loss" in train_meters: + return train_meters["loss"] + elif name == "train_nll_loss": + # support for legacy train.py, which assumed this meter is + # always initialized + m = train_meters.get("nll_loss", None) + return m or meters.AverageMeter() + elif name == "wall": + # support for legacy train.py, which assumed this meter is + # always initialized + m = metrics.get_meter("default", "wall") + return m or meters.TimeMeter() + elif name == "wps": + m = metrics.get_meter("train", "wps") + return m or meters.TimeMeter() + elif name in {"valid_loss", "valid_nll_loss"}: + # support for legacy train.py, which assumed these meters + # are always initialized + k = name[len("valid_") :] + m = metrics.get_meter("valid", k) + return m or meters.AverageMeter() + elif name == "oom": + return meters.AverageMeter() + elif name in train_meters: + return train_meters[name] + return None + + def get_num_updates(self): + """Get the number of parameters updates.""" + return self._num_updates + + def set_num_updates(self, num_updates): + """Set the number of parameters updates.""" + self._num_updates = num_updates + self.lr_step_update() + if self.quantizer: + self.quantizer.step_update(self._num_updates) + metrics.log_scalar("num_updates", self._num_updates, weight=0, priority=200) + + def clip_grad_norm(self, clip_norm): + def agg_norm_fn(total_norm): + total_norm = total_norm.cuda().float() ** 2 + total_norm = distributed_utils.all_reduce( + total_norm, group=self.data_parallel_process_group + ) + return total_norm ** 0.5 + + should_agg_norm = ( + self.is_fsdp + and ( + self.data_parallel_process_group is not None + or torch.distributed.is_initialized() + ) + ) + return self.optimizer.clip_grad_norm( + clip_norm, aggregate_norm_fn=agg_norm_fn if should_agg_norm else None + ) + + def cumulative_training_time(self): + if self._cumulative_training_time is None: + # single GPU + return self._local_cumulative_training_time() + else: + return self._cumulative_training_time + + def _local_cumulative_training_time(self): + """Aggregate training time in seconds.""" + return time.time() - self._start_time + self._previous_training_time + + def _fp_convert_sample(self, sample): + def apply_half(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.half) + return t + + def apply_bfloat16(t): + if t.dtype is torch.float32: + return t.to(dtype=torch.bfloat16) + return t + + if self.cfg.common.fp16: + sample = utils.apply_to_sample(apply_half, sample) + + if self.cfg.common.bf16: + sample = utils.apply_to_sample(apply_bfloat16, sample) + + return sample + + def _prepare_sample(self, sample, is_dummy=False): + if sample == "DUMMY": + raise Exception( + "Trying to use an uninitialized 'dummy' batch. This usually indicates " + "that the total number of batches is smaller than the number of " + "participating GPUs. Try reducing the batch size or using fewer GPUs." + ) + + if sample is None or len(sample) == 0: + assert ( + self._dummy_batch is not None and len(self._dummy_batch) > 0 + ), "Invalid dummy batch: {}".format(self._dummy_batch) + sample, _ = self._prepare_sample(self._dummy_batch, is_dummy=True) + return sample, True + + # Given that PCIe/NVLink bandwidth is significantly smaller than DRAM bandwidth + # it makes sense to do the format conversion on the CPU and then transfer + # a smaller buffer to the device. This also saves GPU memory capacity. + + if self.cfg.common.on_cpu_convert_precision: + sample = self._fp_convert_sample(sample) + + if self.cuda: + if self.pipeline_model_parallel: + if 'target' in sample: + sample['target'] = utils.move_to_cuda(sample['target'], device=self.last_device) + else: + sample = utils.move_to_cuda(sample) + elif self.tpu and is_dummy: + # the dummy batch may not be on the appropriate device + sample = utils.move_to_cuda(sample, device=self.device) + + if not self.cfg.common.on_cpu_convert_precision: + sample = self._fp_convert_sample(sample) + + if self._dummy_batch == "DUMMY": + self._dummy_batch = sample + + return sample, False + + def _set_seed(self): + # Set seed based on args.seed and the update number so that we get + # reproducible results when resuming from checkpoints + seed = self.cfg.common.seed + self.get_num_updates() + utils.set_torch_seed(seed) + + def _sync_stats(self): + # Return True if it's using multiple GPUs and DDP or multiple GPUs with + # BMUF and it's a bmuf sync with warmup iterations completed before. + if self.data_parallel_world_size == 1: + return False + elif self.cfg.optimization.use_bmuf: + return ( + self.get_num_updates() + 1 + ) % self.cfg.bmuf.global_sync_iter == 0 and ( + self.get_num_updates() + 1 + ) > self.cfg.bmuf.warmup_iterations + else: + return True + + def _log_oom(self, exc): + msg = "OOM: Ran out of memory with exception: {}".format(exc) + logger.warning(msg) + if torch.cuda.is_available() and hasattr(torch.cuda, "memory_summary"): + for device_idx in range(torch.cuda.device_count()): + logger.warning(torch.cuda.memory_summary(device=device_idx)) + sys.stderr.flush() + + def _aggregate_logging_outputs( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + if self.task.__class__.logging_outputs_can_be_summed(self.get_criterion()): + return self._fast_stat_sync_sum( + logging_outputs, *extra_stats_to_sum, ignore=ignore + ) + else: + return self._all_gather_list_sync( + logging_outputs, *extra_stats_to_sum, ignore=ignore + ) + + def _all_gather_list_sync( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + """ + Sync logging outputs across workers. all_gather_list_sync is + suitable when logging outputs are complex types. + """ + if self.tpu: + raise NotImplementedError + if ignore: + logging_outputs = [] + results = list( + zip( + *distributed_utils.all_gather_list( + [logging_outputs] + list(extra_stats_to_sum), + max_size=getattr(self.cfg.common, "all_gather_list_size", 16384), + group=self.data_parallel_process_group, + ) + ) + ) + logging_outputs, extra_stats_to_sum = results[0], results[1:] + logging_outputs = list(chain.from_iterable(logging_outputs)) + extra_stats_to_sum = [sum(s) for s in extra_stats_to_sum] + return logging_outputs, extra_stats_to_sum + + def _fast_stat_sync_sum( + self, + logging_outputs: List[Dict[str, Any]], + *extra_stats_to_sum, + ignore=False, + ): + """ + Sync logging outputs across workers. fast_stat_sync_sum is + faster than all_gather_list_sync, but is only suitable when + logging outputs are scalars and can be summed. Note that + *logging_outputs* cannot contain any nested dicts/lists. + """ + data = {} + for i, stat in enumerate(extra_stats_to_sum): + data["extra_stats_" + str(i)] = stat + if len(logging_outputs) > 0: + log_keys = list(logging_outputs[0].keys()) + for k in log_keys: + if not ignore: + v = sum(log[k] for log in logging_outputs if k in log) + else: + v = logging_outputs[0][k] + v = torch.zeros_like(v) if torch.is_tensor(v) else 0 + data["logging_outputs_" + k] = v + else: + log_keys = None + + data = distributed_utils.all_reduce_dict( + data, device=self.device, group=self.data_parallel_process_group + ) + + extra_stats_to_sum = [ + data["extra_stats_" + str(i)] for i in range(len(extra_stats_to_sum)) + ] + if log_keys is not None: + logging_outputs = [{k: data["logging_outputs_" + k] for k in log_keys}] + else: + logging_outputs = [] + return logging_outputs, extra_stats_to_sum + + def _check_grad_norms(self, grad_norm): + """Check that grad norms are consistent across workers.""" + if self._grad_norm_buf is not None: + self._grad_norm_buf.zero_() + self._grad_norm_buf[self.data_parallel_rank] = grad_norm + distributed_utils.all_reduce( + self._grad_norm_buf, group=self.data_parallel_process_group + ) + + def is_consistent(tensor): + max_abs_diff = torch.max(torch.abs(tensor - tensor[0])) + return ( + (torch.isfinite(tensor).all() + and (max_abs_diff / (tensor[0] + 1e-6) < 1e-6).all()) + or + (self.cfg.common.amp and not torch.isfinite(tensor).all()) + # in case of amp non-finite grads are fine + ) + + if not is_consistent(self._grad_norm_buf): + pretty_detail = "\n".join( + "rank {:3d} = {:.8f}".format(r, n) + for r, n in enumerate(self._grad_norm_buf.tolist()) + ) + error_detail = "grad_norm across the workers:\n{}\n".format( + pretty_detail + ) + # use FloatingPointError to trigger NanDetector + raise FloatingPointError( + "Fatal error: gradients are inconsistent between workers. " + "Try --ddp-backend=legacy_ddp. " + "Or are you mixing up different generation of GPUs in training?" + + "\n" + + "-" * 80 + + "\n{}\n".format(error_detail) + + "-" * 80 + ) + + def _reduce_and_log_stats(self, logging_outputs, sample_size, grad_norm=None): + if grad_norm is not None and ( + not torch.is_tensor(grad_norm) or torch.isfinite(grad_norm) + ): + metrics.log_speed("ups", 1.0, priority=100, round=2) + metrics.log_scalar("gnorm", grad_norm, priority=400, round=3) + if self.cfg.optimization.clip_norm > 0: + metrics.log_scalar( + "clip", + torch.where( + grad_norm > self.cfg.optimization.clip_norm, + grad_norm.new_tensor(100), + grad_norm.new_tensor(0), + ), + priority=500, + round=1, + ) + + with metrics.aggregate() as agg: + if logging_outputs is not None: + self.task.reduce_metrics(logging_outputs, self.get_criterion()) + del logging_outputs + + # extra warning for criterions that don't properly log a loss value + if "loss" not in agg: + if "loss" not in self._warn_once: + self._warn_once.add("loss") + logger.warning( + "Criterion.reduce_metrics did not log a 'loss' value, " + "which may break some functionality" + ) + metrics.log_scalar("loss", -1) + + # support legacy interface + if self.tpu: + logging_output = {} + else: + logging_output = agg.get_smoothed_values() + logging_output["sample_size"] = sample_size + for key_to_delete in ["ppl", "wps", "wpb", "bsz"]: + if key_to_delete in logging_output: + del logging_output[key_to_delete] + return logging_output + + def _check_xla_compilation(self): + import torch_xla.debug.metrics as met + + compile_stats = met.metric_data("CompileTime") + if compile_stats is None: + return + num_xla_compiles = compile_stats[0] + if num_xla_compiles > self._num_xla_compiles: + logger.warning( + "XLA compilation detected on device #{}; too many of these can lead " + "to slow training, but we expect a few in the beginning".format( + self.cfg.distributed_training.distributed_rank + ) + ) + self._num_xla_compiles = num_xla_compiles + + def _xla_markstep_and_send_to_cpu(self, data=None): + import torch_xla.core.xla_model as xm + + xm.mark_step() + if data is not None: + from fairseq.utils import xla_device_to_cpu + + return xla_device_to_cpu(data) + + +def _catalog_shared_params(module, memo=None, prefix=""): + if memo is None: + first_call = True + memo = {} + else: + first_call = False + for name, param in module._parameters.items(): + param_prefix = prefix + ("." if prefix else "") + name + if param not in memo: + memo[param] = [] + memo[param].append(param_prefix) + for name, m in module._modules.items(): + if m is None: + continue + submodule_prefix = prefix + ("." if prefix else "") + name + _catalog_shared_params(m, memo, submodule_prefix) + if first_call: + return [x for x in memo.values() if len(x) > 1] + + +def _get_module_by_path(module, path): + path = path.split(".") + for name in path: + module = getattr(module, name) + return module + + +def _set_module_by_path(module, path, value): + path = path.split(".") + for name in path[:-1]: + module = getattr(module, name) + setattr(module, path[-1], value) diff --git a/transformers.md b/transformers.md new file mode 100644 index 0000000000000000000000000000000000000000..d7e3d789259baff0606ae1d5156ce33f79ee141b --- /dev/null +++ b/transformers.md @@ -0,0 +1,69 @@ +# Use in huggingface transformers (Beta) + +[**Colab Notebook**](https://colab.research.google.com/drive/1Ho81RBV8jysZ7e0FhsSCk_v938QeDuy3?usp=sharing) +![image](https://user-images.githubusercontent.com/27664428/190052470-56679999-571b-4d46-a9a8-e567b78e20d1.png) + + +We now support inference of OFA on the huggingface transformers. In the near future, we will provide the codes for training. + +Model checkpoints are stored in our [huggingface models](https://huggingface.co/OFA-Sys). Specifically, 5 versions of the pretrained OFA models, namely OFA-tiny, OFA-medium, OFA-base, OFA-large, and OFA-huge have been already uploaded. For more information about the models, please refer to the Model Card on our [README](https://github.com/OFA-Sys/OFA). +Note that each directory includes 4 files, namely `config.json` which consists of model configuration, `vocab.json` and `merge.txt` for our OFA tokenizer, and lastly `pytorch_model.bin` which consists of model weights. There is no need to worry about the mismatch between Fairseq and transformers, since we have addressed the issue yet. + +To use it in transformers, you can first refer to this notebook ([link](https://colab.research.google.com/drive/1Ho81RBV8jysZ7e0FhsSCk_v938QeDuy3?usp=sharing)). For more information, you can find codes in this branch https://github.com/OFA-Sys/OFA/tree/feature/add_transformers. + +In the following, we introduce the details in our provided notebook and illustrate how to use OFA in Transformers. + +First, install the transformers and download the models (take OFA-tiny as an example) as shown below. + +``` +git clone --single-branch --branch feature/add_transformers https://github.com/OFA-Sys/OFA.git +pip install OFA/transformers/ +git clone https://huggingface.co/OFA-Sys/OFA-tiny +``` + +Next, refer the path to OFA-tiny to `ckpt_dir`, and prepare an image for the testing example below. Also, ensure that you have pillow and torchvision in your environment. Check if there is the directory `generate` in your model directory `transformers/src/transformers/models/ofa` to ensure that you can use the sequence generator that we provide. + +``` +>>> from PIL import Image +>>> from torchvision import transforms +>>> from transformers import OFATokenizer, OFAModel +>>> from transformers.models.ofa.generate import sequence_generator + +>>> mean, std = [0.5, 0.5, 0.5], [0.5, 0.5, 0.5] +>>> resolution = 256 +>>> patch_resize_transform = transforms.Compose([ + lambda image: image.convert("RGB"), + transforms.Resize((resolution, resolution), interpolation=Image.BICUBIC), + transforms.ToTensor(), + transforms.Normalize(mean=mean, std=std) + ]) + + +>>> tokenizer = OFATokenizer.from_pretrained(ckpt_dir) + +>>> txt = " what does the image describe?" +>>> inputs = tokenizer([txt], return_tensors="pt").input_ids +>>> img = Image.open(path_to_image) +>>> patch_img = patch_resize_transform(img).unsqueeze(0) + + +>>> # using the generator of fairseq version +>>> model = OFAModel.from_pretrained(ckpt_dir, use_cache=True) +>>> generator = sequence_generator.SequenceGenerator( + tokenizer=tokenizer, + beam_size=5, + max_len_b=16, + min_len=0, + no_repeat_ngram_size=3, + ) +>>> data = {} +>>> data["net_input"] = {"input_ids": inputs, 'patch_images': patch_img, 'patch_masks':torch.tensor([True])} +>>> gen_output = generator.generate([model], data) +>>> gen = [gen_output[i][0]["tokens"] for i in range(len(gen_output))] + +>>> # using the generator of huggingface version +>>> model = OFAModel.from_pretrained(ckpt_dir, use_cache=False) +>>> gen = model.generate(inputs, patch_images=patch_img, num_beams=5, no_repeat_ngram_size=3) + +>>> print(tokenizer.batch_decode(gen, skip_special_tokens=True)) +``` diff --git a/utils/BERT_CN_dict/dict.txt b/utils/BERT_CN_dict/dict.txt new file mode 100644 index 0000000000000000000000000000000000000000..dde0c80e432c69680cd7aae1b3baf980e8574733 --- /dev/null +++ b/utils/BERT_CN_dict/dict.txt @@ -0,0 +1,21128 @@ +[PAD] 1 +[unused1] 1 +[unused2] 1 +[unused3] 1 +[unused4] 1 +[unused5] 1 +[unused6] 1 +[unused7] 1 +[unused8] 1 +[unused9] 1 +[unused10] 1 +[unused11] 1 +[unused12] 1 +[unused13] 1 +[unused14] 1 +[unused15] 1 +[unused16] 1 +[unused17] 1 +[unused18] 1 +[unused19] 1 +[unused20] 1 +[unused21] 1 +[unused22] 1 +[unused23] 1 +[unused24] 1 +[unused25] 1 +[unused26] 1 +[unused27] 1 +[unused28] 1 +[unused29] 1 +[unused30] 1 +[unused31] 1 +[unused32] 1 +[unused33] 1 +[unused34] 1 +[unused35] 1 +[unused36] 1 +[unused37] 1 +[unused38] 1 +[unused39] 1 +[unused40] 1 +[unused41] 1 +[unused42] 1 +[unused43] 1 +[unused44] 1 +[unused45] 1 +[unused46] 1 +[unused47] 1 +[unused48] 1 +[unused49] 1 +[unused50] 1 +[unused51] 1 +[unused52] 1 +[unused53] 1 +[unused54] 1 +[unused55] 1 +[unused56] 1 +[unused57] 1 +[unused58] 1 +[unused59] 1 +[unused60] 1 +[unused61] 1 +[unused62] 1 +[unused63] 1 +[unused64] 1 +[unused65] 1 +[unused66] 1 +[unused67] 1 +[unused68] 1 +[unused69] 1 +[unused70] 1 +[unused71] 1 +[unused72] 1 +[unused73] 1 +[unused74] 1 +[unused75] 1 +[unused76] 1 +[unused77] 1 +[unused78] 1 +[unused79] 1 +[unused80] 1 +[unused81] 1 +[unused82] 1 +[unused83] 1 +[unused84] 1 +[unused85] 1 +[unused86] 1 +[unused87] 1 +[unused88] 1 +[unused89] 1 +[unused90] 1 +[unused91] 1 +[unused92] 1 +[unused93] 1 +[unused94] 1 +[unused95] 1 +[unused96] 1 +[unused97] 1 +[unused98] 1 +[unused99] 1 +[UNK] 1 +[CLS] 1 +[SEP] 1 +[MASK] 1 +<S> 1 +<T> 1 +! 1 +" 1 +# 1 +$ 1 +% 1 +& 1 +' 1 +( 1 +) 1 +* 1 ++ 1 +, 1 +- 1 +. 1 +/ 1 +0 1 +1 1 +2 1 +3 1 +4 1 +5 1 +6 1 +7 1 +8 1 +9 1 +: 1 +; 1 +< 1 += 1 +> 1 +? 1 +@ 1 +[ 1 +\ 1 +] 1 +^ 1 +_ 1 +a 1 +b 1 +c 1 +d 1 +e 1 +f 1 +g 1 +h 1 +i 1 +j 1 +k 1 +l 1 +m 1 +n 1 +o 1 +p 1 +q 1 +r 1 +s 1 +t 1 +u 1 +v 1 +w 1 +x 1 +y 1 +z 1 +{ 1 +| 1 +} 1 +~ 1 +£ 1 +¤ 1 +¥ 1 +§ 1 +© 1 +« 1 +® 1 +° 1 +± 1 +² 1 +³ 1 +µ 1 +· 1 +¹ 1 +º 1 +» 1 +¼ 1 +× 1 +ß 1 +æ 1 +÷ 1 +ø 1 +đ 1 +ŋ 1 +ɔ 1 +ə 1 +ɡ 1 +ʰ 1 +ˇ 1 +ˈ 1 +ˊ 1 +ˋ 1 +ˍ 1 +ː 1 +˙ 1 +˚ 1 +ˢ 1 +α 1 +β 1 +γ 1 +δ 1 +ε 1 +η 1 +θ 1 +ι 1 +κ 1 +λ 1 +μ 1 +ν 1 +ο 1 +π 1 +ρ 1 +ς 1 +σ 1 +τ 1 +υ 1 +φ 1 +χ 1 +ψ 1 +ω 1 +а 1 +б 1 +в 1 +г 1 +д 1 +е 1 +ж 1 +з 1 +и 1 +к 1 +л 1 +м 1 +н 1 +о 1 +п 1 +р 1 +с 1 +т 1 +у 1 +ф 1 +х 1 +ц 1 +ч 1 +ш 1 +ы 1 +ь 1 +я 1 +і 1 +ا 1 +ب 1 +ة 1 +ت 1 +د 1 +ر 1 +س 1 +ع 1 +ل 1 +م 1 +ن 1 +ه 1 +و 1 +ي 1 +۩ 1 +ก 1 +ง 1 +น 1 +ม 1 +ย 1 +ร 1 +อ 1 +า 1 +เ 1 +๑ 1 +་ 1 +ღ 1 +ᄀ 1 +ᄁ 1 +ᄂ 1 +ᄃ 1 +ᄅ 1 +ᄆ 1 +ᄇ 1 +ᄈ 1 +ᄉ 1 +ᄋ 1 +ᄌ 1 +ᄎ 1 +ᄏ 1 +ᄐ 1 +ᄑ 1 +ᄒ 1 +ᅡ 1 +ᅢ 1 +ᅣ 1 +ᅥ 1 +ᅦ 1 +ᅧ 1 +ᅨ 1 +ᅩ 1 +ᅪ 1 +ᅬ 1 +ᅭ 1 +ᅮ 1 +ᅯ 1 +ᅲ 1 +ᅳ 1 +ᅴ 1 +ᅵ 1 +ᆨ 1 +ᆫ 1 +ᆯ 1 +ᆷ 1 +ᆸ 1 +ᆺ 1 +ᆻ 1 +ᆼ 1 +ᗜ 1 +ᵃ 1 +ᵉ 1 +ᵍ 1 +ᵏ 1 +ᵐ 1 +ᵒ 1 +ᵘ 1 +‖ 1 +„ 1 +† 1 +• 1 +‥ 1 +‧ 1 + 1 +‰ 1 +′ 1 +″ 1 +‹ 1 +› 1 +※ 1 +‿ 1 +⁄ 1 +ⁱ 1 +⁺ 1 +ⁿ 1 +₁ 1 +₂ 1 +₃ 1 +₄ 1 +€ 1 +℃ 1 +№ 1 +™ 1 +ⅰ 1 +ⅱ 1 +ⅲ 1 +ⅳ 1 +ⅴ 1 +← 1 +↑ 1 +→ 1 +↓ 1 +↔ 1 +↗ 1 +↘ 1 +⇒ 1 +∀ 1 +− 1 +∕ 1 +∙ 1 +√ 1 +∞ 1 +∟ 1 +∠ 1 +∣ 1 +∥ 1 +∩ 1 +∮ 1 +∶ 1 +∼ 1 +∽ 1 +≈ 1 +≒ 1 +≡ 1 +≤ 1 +≥ 1 +≦ 1 +≧ 1 +≪ 1 +≫ 1 +⊙ 1 +⋅ 1 +⋈ 1 +⋯ 1 +⌒ 1 +① 1 +② 1 +③ 1 +④ 1 +⑤ 1 +⑥ 1 +⑦ 1 +⑧ 1 +⑨ 1 +⑩ 1 +⑴ 1 +⑵ 1 +⑶ 1 +⑷ 1 +⑸ 1 +⒈ 1 +⒉ 1 +⒊ 1 +⒋ 1 +ⓒ 1 +ⓔ 1 +ⓘ 1 +─ 1 +━ 1 +│ 1 +┃ 1 +┅ 1 +┆ 1 +┊ 1 +┌ 1 +└ 1 +├ 1 +┣ 1 +═ 1 +║ 1 +╚ 1 +╞ 1 +╠ 1 +╭ 1 +╮ 1 +╯ 1 +╰ 1 +╱ 1 +╳ 1 +▂ 1 +▃ 1 +▅ 1 +▇ 1 +█ 1 +▉ 1 +▋ 1 +▌ 1 +▍ 1 +▎ 1 +■ 1 +□ 1 +▪ 1 +▫ 1 +▬ 1 +▲ 1 +△ 1 +▶ 1 +► 1 +▼ 1 +▽ 1 +◆ 1 +◇ 1 +○ 1 +◎ 1 +● 1 +◕ 1 +◠ 1 +◢ 1 +◤ 1 +☀ 1 +★ 1 +☆ 1 +☕ 1 +☞ 1 +☺ 1 +☼ 1 +♀ 1 +♂ 1 +♠ 1 +♡ 1 +♣ 1 +♥ 1 +♦ 1 +♪ 1 +♫ 1 +♬ 1 +✈ 1 +✔ 1 +✕ 1 +✖ 1 +✦ 1 +✨ 1 +✪ 1 +✰ 1 +✿ 1 +❀ 1 +❤ 1 +➜ 1 +➤ 1 +⦿ 1 +、 1 +。 1 +〃 1 +々 1 +〇 1 +〈 1 +〉 1 +《 1 +》 1 +「 1 +」 1 +『 1 +』 1 +【 1 +】 1 +〓 1 +〔 1 +〕 1 +〖 1 +〗 1 +〜 1 +〝 1 +〞 1 +ぁ 1 +あ 1 +ぃ 1 +い 1 +う 1 +ぇ 1 +え 1 +お 1 +か 1 +き 1 +く 1 +け 1 +こ 1 +さ 1 +し 1 +す 1 +せ 1 +そ 1 +た 1 +ち 1 +っ 1 +つ 1 +て 1 +と 1 +な 1 +に 1 +ぬ 1 +ね 1 +の 1 +は 1 +ひ 1 +ふ 1 +へ 1 +ほ 1 +ま 1 +み 1 +む 1 +め 1 +も 1 +ゃ 1 +や 1 +ゅ 1 +ゆ 1 +ょ 1 +よ 1 +ら 1 +り 1 +る 1 +れ 1 +ろ 1 +わ 1 +を 1 +ん 1 +゜ 1 +ゝ 1 +ァ 1 +ア 1 +ィ 1 +イ 1 +ゥ 1 +ウ 1 +ェ 1 +エ 1 +ォ 1 +オ 1 +カ 1 +キ 1 +ク 1 +ケ 1 +コ 1 +サ 1 +シ 1 +ス 1 +セ 1 +ソ 1 +タ 1 +チ 1 +ッ 1 +ツ 1 +テ 1 +ト 1 +ナ 1 +ニ 1 +ヌ 1 +ネ 1 +ノ 1 +ハ 1 +ヒ 1 +フ 1 +ヘ 1 +ホ 1 +マ 1 +ミ 1 +ム 1 +メ 1 +モ 1 +ャ 1 +ヤ 1 +ュ 1 +ユ 1 +ョ 1 +ヨ 1 +ラ 1 +リ 1 +ル 1 +レ 1 +ロ 1 +ワ 1 +ヲ 1 +ン 1 +ヶ 1 +・ 1 +ー 1 +ヽ 1 +ㄅ 1 +ㄆ 1 +ㄇ 1 +ㄉ 1 +ㄋ 1 +ㄌ 1 +ㄍ 1 +ㄎ 1 +ㄏ 1 +ㄒ 1 +ㄚ 1 +ㄛ 1 +ㄞ 1 +ㄟ 1 +ㄢ 1 +ㄤ 1 +ㄥ 1 +ㄧ 1 +ㄨ 1 +ㆍ 1 +㈦ 1 +㊣ 1 +㎡ 1 +㗎 1 +一 1 +丁 1 +七 1 +万 1 +丈 1 +三 1 +上 1 +下 1 +不 1 +与 1 +丐 1 +丑 1 +专 1 +且 1 +丕 1 +世 1 +丘 1 +丙 1 +业 1 +丛 1 +东 1 +丝 1 +丞 1 +丟 1 +両 1 +丢 1 +两 1 +严 1 +並 1 +丧 1 +丨 1 +个 1 +丫 1 +中 1 +丰 1 +串 1 +临 1 +丶 1 +丸 1 +丹 1 +为 1 +主 1 +丼 1 +丽 1 +举 1 +丿 1 +乂 1 +乃 1 +久 1 +么 1 +义 1 +之 1 +乌 1 +乍 1 +乎 1 +乏 1 +乐 1 +乒 1 +乓 1 +乔 1 +乖 1 +乗 1 +乘 1 +乙 1 +乜 1 +九 1 +乞 1 +也 1 +习 1 +乡 1 +书 1 +乩 1 +买 1 +乱 1 +乳 1 +乾 1 +亀 1 +亂 1 +了 1 +予 1 +争 1 +事 1 +二 1 +于 1 +亏 1 +云 1 +互 1 +五 1 +井 1 +亘 1 +亙 1 +亚 1 +些 1 +亜 1 +亞 1 +亟 1 +亡 1 +亢 1 +交 1 +亥 1 +亦 1 +产 1 +亨 1 +亩 1 +享 1 +京 1 +亭 1 +亮 1 +亲 1 +亳 1 +亵 1 +人 1 +亿 1 +什 1 +仁 1 +仃 1 +仄 1 +仅 1 +仆 1 +仇 1 +今 1 +介 1 +仍 1 +从 1 +仏 1 +仑 1 +仓 1 +仔 1 +仕 1 +他 1 +仗 1 +付 1 +仙 1 +仝 1 +仞 1 +仟 1 +代 1 +令 1 +以 1 +仨 1 +仪 1 +们 1 +仮 1 +仰 1 +仲 1 +件 1 +价 1 +任 1 +份 1 +仿 1 +企 1 +伉 1 +伊 1 +伍 1 +伎 1 +伏 1 +伐 1 +休 1 +伕 1 +众 1 +优 1 +伙 1 +会 1 +伝 1 +伞 1 +伟 1 +传 1 +伢 1 +伤 1 +伦 1 +伪 1 +伫 1 +伯 1 +估 1 +伴 1 +伶 1 +伸 1 +伺 1 +似 1 +伽 1 +佃 1 +但 1 +佇 1 +佈 1 +位 1 +低 1 +住 1 +佐 1 +佑 1 +体 1 +佔 1 +何 1 +佗 1 +佘 1 +余 1 +佚 1 +佛 1 +作 1 +佝 1 +佞 1 +佟 1 +你 1 +佢 1 +佣 1 +佤 1 +佥 1 +佩 1 +佬 1 +佯 1 +佰 1 +佳 1 +併 1 +佶 1 +佻 1 +佼 1 +使 1 +侃 1 +侄 1 +來 1 +侈 1 +例 1 +侍 1 +侏 1 +侑 1 +侖 1 +侗 1 +供 1 +依 1 +侠 1 +価 1 +侣 1 +侥 1 +侦 1 +侧 1 +侨 1 +侬 1 +侮 1 +侯 1 +侵 1 +侶 1 +侷 1 +便 1 +係 1 +促 1 +俄 1 +俊 1 +俎 1 +俏 1 +俐 1 +俑 1 +俗 1 +俘 1 +俚 1 +保 1 +俞 1 +俟 1 +俠 1 +信 1 +俨 1 +俩 1 +俪 1 +俬 1 +俭 1 +修 1 +俯 1 +俱 1 +俳 1 +俸 1 +俺 1 +俾 1 +倆 1 +倉 1 +個 1 +倌 1 +倍 1 +倏 1 +們 1 +倒 1 +倔 1 +倖 1 +倘 1 +候 1 +倚 1 +倜 1 +借 1 +倡 1 +値 1 +倦 1 +倩 1 +倪 1 +倫 1 +倬 1 +倭 1 +倶 1 +债 1 +值 1 +倾 1 +偃 1 +假 1 +偈 1 +偉 1 +偌 1 +偎 1 +偏 1 +偕 1 +做 1 +停 1 +健 1 +側 1 +偵 1 +偶 1 +偷 1 +偻 1 +偽 1 +偿 1 +傀 1 +傅 1 +傍 1 +傑 1 +傘 1 +備 1 +傚 1 +傢 1 +傣 1 +傥 1 +储 1 +傩 1 +催 1 +傭 1 +傲 1 +傳 1 +債 1 +傷 1 +傻 1 +傾 1 +僅 1 +働 1 +像 1 +僑 1 +僕 1 +僖 1 +僚 1 +僥 1 +僧 1 +僭 1 +僮 1 +僱 1 +僵 1 +價 1 +僻 1 +儀 1 +儂 1 +億 1 +儆 1 +儉 1 +儋 1 +儒 1 +儕 1 +儘 1 +償 1 +儡 1 +優 1 +儲 1 +儷 1 +儼 1 +儿 1 +兀 1 +允 1 +元 1 +兄 1 +充 1 +兆 1 +兇 1 +先 1 +光 1 +克 1 +兌 1 +免 1 +児 1 +兑 1 +兒 1 +兔 1 +兖 1 +党 1 +兜 1 +兢 1 +入 1 +內 1 +全 1 +兩 1 +八 1 +公 1 +六 1 +兮 1 +兰 1 +共 1 +兲 1 +关 1 +兴 1 +兵 1 +其 1 +具 1 +典 1 +兹 1 +养 1 +兼 1 +兽 1 +冀 1 +内 1 +円 1 +冇 1 +冈 1 +冉 1 +冊 1 +册 1 +再 1 +冏 1 +冒 1 +冕 1 +冗 1 +写 1 +军 1 +农 1 +冠 1 +冢 1 +冤 1 +冥 1 +冨 1 +冪 1 +冬 1 +冯 1 +冰 1 +冲 1 +决 1 +况 1 +冶 1 +冷 1 +冻 1 +冼 1 +冽 1 +冾 1 +净 1 +凄 1 +准 1 +凇 1 +凈 1 +凉 1 +凋 1 +凌 1 +凍 1 +减 1 +凑 1 +凛 1 +凜 1 +凝 1 +几 1 +凡 1 +凤 1 +処 1 +凪 1 +凭 1 +凯 1 +凰 1 +凱 1 +凳 1 +凶 1 +凸 1 +凹 1 +出 1 +击 1 +函 1 +凿 1 +刀 1 +刁 1 +刃 1 +分 1 +切 1 +刈 1 +刊 1 +刍 1 +刎 1 +刑 1 +划 1 +列 1 +刘 1 +则 1 +刚 1 +创 1 +初 1 +删 1 +判 1 +別 1 +刨 1 +利 1 +刪 1 +别 1 +刮 1 +到 1 +制 1 +刷 1 +券 1 +刹 1 +刺 1 +刻 1 +刽 1 +剁 1 +剂 1 +剃 1 +則 1 +剉 1 +削 1 +剋 1 +剌 1 +前 1 +剎 1 +剐 1 +剑 1 +剔 1 +剖 1 +剛 1 +剜 1 +剝 1 +剣 1 +剤 1 +剥 1 +剧 1 +剩 1 +剪 1 +副 1 +割 1 +創 1 +剷 1 +剽 1 +剿 1 +劃 1 +劇 1 +劈 1 +劉 1 +劊 1 +劍 1 +劏 1 +劑 1 +力 1 +劝 1 +办 1 +功 1 +加 1 +务 1 +劣 1 +动 1 +助 1 +努 1 +劫 1 +劭 1 +励 1 +劲 1 +劳 1 +労 1 +劵 1 +効 1 +劾 1 +势 1 +勁 1 +勃 1 +勇 1 +勉 1 +勋 1 +勐 1 +勒 1 +動 1 +勖 1 +勘 1 +務 1 +勛 1 +勝 1 +勞 1 +募 1 +勢 1 +勤 1 +勧 1 +勳 1 +勵 1 +勸 1 +勺 1 +勻 1 +勾 1 +勿 1 +匀 1 +包 1 +匆 1 +匈 1 +匍 1 +匐 1 +匕 1 +化 1 +北 1 +匙 1 +匝 1 +匠 1 +匡 1 +匣 1 +匪 1 +匮 1 +匯 1 +匱 1 +匹 1 +区 1 +医 1 +匾 1 +匿 1 +區 1 +十 1 +千 1 +卅 1 +升 1 +午 1 +卉 1 +半 1 +卍 1 +华 1 +协 1 +卑 1 +卒 1 +卓 1 +協 1 +单 1 +卖 1 +南 1 +単 1 +博 1 +卜 1 +卞 1 +卟 1 +占 1 +卡 1 +卢 1 +卤 1 +卦 1 +卧 1 +卫 1 +卮 1 +卯 1 +印 1 +危 1 +即 1 +却 1 +卵 1 +卷 1 +卸 1 +卻 1 +卿 1 +厂 1 +厄 1 +厅 1 +历 1 +厉 1 +压 1 +厌 1 +厕 1 +厘 1 +厚 1 +厝 1 +原 1 +厢 1 +厥 1 +厦 1 +厨 1 +厩 1 +厭 1 +厮 1 +厲 1 +厳 1 +去 1 +县 1 +叁 1 +参 1 +參 1 +又 1 +叉 1 +及 1 +友 1 +双 1 +反 1 +収 1 +发 1 +叔 1 +取 1 +受 1 +变 1 +叙 1 +叛 1 +叟 1 +叠 1 +叡 1 +叢 1 +口 1 +古 1 +句 1 +另 1 +叨 1 +叩 1 +只 1 +叫 1 +召 1 +叭 1 +叮 1 +可 1 +台 1 +叱 1 +史 1 +右 1 +叵 1 +叶 1 +号 1 +司 1 +叹 1 +叻 1 +叼 1 +叽 1 +吁 1 +吃 1 +各 1 +吆 1 +合 1 +吉 1 +吊 1 +吋 1 +同 1 +名 1 +后 1 +吏 1 +吐 1 +向 1 +吒 1 +吓 1 +吕 1 +吖 1 +吗 1 +君 1 +吝 1 +吞 1 +吟 1 +吠 1 +吡 1 +否 1 +吧 1 +吨 1 +吩 1 +含 1 +听 1 +吭 1 +吮 1 +启 1 +吱 1 +吳 1 +吴 1 +吵 1 +吶 1 +吸 1 +吹 1 +吻 1 +吼 1 +吽 1 +吾 1 +呀 1 +呂 1 +呃 1 +呆 1 +呈 1 +告 1 +呋 1 +呎 1 +呐 1 +呓 1 +呕 1 +呗 1 +员 1 +呛 1 +呜 1 +呢 1 +呤 1 +呦 1 +周 1 +呱 1 +呲 1 +味 1 +呵 1 +呷 1 +呸 1 +呻 1 +呼 1 +命 1 +咀 1 +咁 1 +咂 1 +咄 1 +咆 1 +咋 1 +和 1 +咎 1 +咏 1 +咐 1 +咒 1 +咔 1 +咕 1 +咖 1 +咗 1 +咘 1 +咙 1 +咚 1 +咛 1 +咣 1 +咤 1 +咦 1 +咧 1 +咨 1 +咩 1 +咪 1 +咫 1 +咬 1 +咭 1 +咯 1 +咱 1 +咲 1 +咳 1 +咸 1 +咻 1 +咽 1 +咿 1 +哀 1 +品 1 +哂 1 +哄 1 +哆 1 +哇 1 +哈 1 +哉 1 +哋 1 +哌 1 +响 1 +哎 1 +哏 1 +哐 1 +哑 1 +哒 1 +哔 1 +哗 1 +哟 1 +員 1 +哥 1 +哦 1 +哧 1 +哨 1 +哩 1 +哪 1 +哭 1 +哮 1 +哲 1 +哺 1 +哼 1 +哽 1 +唁 1 +唄 1 +唆 1 +唇 1 +唉 1 +唏 1 +唐 1 +唑 1 +唔 1 +唠 1 +唤 1 +唧 1 +唬 1 +售 1 +唯 1 +唰 1 +唱 1 +唳 1 +唷 1 +唸 1 +唾 1 +啃 1 +啄 1 +商 1 +啉 1 +啊 1 +問 1 +啓 1 +啕 1 +啖 1 +啜 1 +啞 1 +啟 1 +啡 1 +啤 1 +啥 1 +啦 1 +啧 1 +啪 1 +啫 1 +啬 1 +啮 1 +啰 1 +啱 1 +啲 1 +啵 1 +啶 1 +啷 1 +啸 1 +啻 1 +啼 1 +啾 1 +喀 1 +喂 1 +喃 1 +善 1 +喆 1 +喇 1 +喉 1 +喊 1 +喋 1 +喎 1 +喏 1 +喔 1 +喘 1 +喙 1 +喚 1 +喜 1 +喝 1 +喟 1 +喧 1 +喪 1 +喫 1 +喬 1 +單 1 +喰 1 +喱 1 +喲 1 +喳 1 +喵 1 +営 1 +喷 1 +喹 1 +喺 1 +喻 1 +喽 1 +嗅 1 +嗆 1 +嗇 1 +嗎 1 +嗑 1 +嗒 1 +嗓 1 +嗔 1 +嗖 1 +嗚 1 +嗜 1 +嗝 1 +嗟 1 +嗡 1 +嗣 1 +嗤 1 +嗦 1 +嗨 1 +嗪 1 +嗬 1 +嗯 1 +嗰 1 +嗲 1 +嗳 1 +嗶 1 +嗷 1 +嗽 1 +嘀 1 +嘅 1 +嘆 1 +嘈 1 +嘉 1 +嘌 1 +嘍 1 +嘎 1 +嘔 1 +嘖 1 +嘗 1 +嘘 1 +嘚 1 +嘛 1 +嘜 1 +嘞 1 +嘟 1 +嘢 1 +嘣 1 +嘤 1 +嘧 1 +嘩 1 +嘭 1 +嘮 1 +嘯 1 +嘰 1 +嘱 1 +嘲 1 +嘴 1 +嘶 1 +嘸 1 +嘹 1 +嘻 1 +嘿 1 +噁 1 +噌 1 +噎 1 +噓 1 +噔 1 +噗 1 +噙 1 +噜 1 +噠 1 +噢 1 +噤 1 +器 1 +噩 1 +噪 1 +噬 1 +噱 1 +噴 1 +噶 1 +噸 1 +噹 1 +噻 1 +噼 1 +嚀 1 +嚇 1 +嚎 1 +嚏 1 +嚐 1 +嚓 1 +嚕 1 +嚟 1 +嚣 1 +嚥 1 +嚨 1 +嚮 1 +嚴 1 +嚷 1 +嚼 1 +囂 1 +囉 1 +囊 1 +囍 1 +囑 1 +囔 1 +囗 1 +囚 1 +四 1 +囝 1 +回 1 +囟 1 +因 1 +囡 1 +团 1 +団 1 +囤 1 +囧 1 +囪 1 +囫 1 +园 1 +困 1 +囱 1 +囲 1 +図 1 +围 1 +囹 1 +固 1 +国 1 +图 1 +囿 1 +圃 1 +圄 1 +圆 1 +圈 1 +國 1 +圍 1 +圏 1 +園 1 +圓 1 +圖 1 +團 1 +圜 1 +土 1 +圣 1 +圧 1 +在 1 +圩 1 +圭 1 +地 1 +圳 1 +场 1 +圻 1 +圾 1 +址 1 +坂 1 +均 1 +坊 1 +坍 1 +坎 1 +坏 1 +坐 1 +坑 1 +块 1 +坚 1 +坛 1 +坝 1 +坞 1 +坟 1 +坠 1 +坡 1 +坤 1 +坦 1 +坨 1 +坪 1 +坯 1 +坳 1 +坵 1 +坷 1 +垂 1 +垃 1 +垄 1 +型 1 +垒 1 +垚 1 +垛 1 +垠 1 +垢 1 +垣 1 +垦 1 +垩 1 +垫 1 +垭 1 +垮 1 +垵 1 +埂 1 +埃 1 +埋 1 +城 1 +埔 1 +埕 1 +埗 1 +域 1 +埠 1 +埤 1 +埵 1 +執 1 +埸 1 +培 1 +基 1 +埼 1 +堀 1 +堂 1 +堃 1 +堅 1 +堆 1 +堇 1 +堑 1 +堕 1 +堙 1 +堡 1 +堤 1 +堪 1 +堯 1 +堰 1 +報 1 +場 1 +堵 1 +堺 1 +堿 1 +塊 1 +塌 1 +塑 1 +塔 1 +塗 1 +塘 1 +塚 1 +塞 1 +塢 1 +塩 1 +填 1 +塬 1 +塭 1 +塵 1 +塾 1 +墀 1 +境 1 +墅 1 +墉 1 +墊 1 +墒 1 +墓 1 +増 1 +墘 1 +墙 1 +墜 1 +增 1 +墟 1 +墨 1 +墩 1 +墮 1 +墳 1 +墻 1 +墾 1 +壁 1 +壅 1 +壆 1 +壇 1 +壊 1 +壑 1 +壓 1 +壕 1 +壘 1 +壞 1 +壟 1 +壢 1 +壤 1 +壩 1 +士 1 +壬 1 +壮 1 +壯 1 +声 1 +売 1 +壳 1 +壶 1 +壹 1 +壺 1 +壽 1 +处 1 +备 1 +変 1 +复 1 +夏 1 +夔 1 +夕 1 +外 1 +夙 1 +多 1 +夜 1 +够 1 +夠 1 +夢 1 +夥 1 +大 1 +天 1 +太 1 +夫 1 +夭 1 +央 1 +夯 1 +失 1 +头 1 +夷 1 +夸 1 +夹 1 +夺 1 +夾 1 +奂 1 +奄 1 +奇 1 +奈 1 +奉 1 +奋 1 +奎 1 +奏 1 +奐 1 +契 1 +奔 1 +奕 1 +奖 1 +套 1 +奘 1 +奚 1 +奠 1 +奢 1 +奥 1 +奧 1 +奪 1 +奬 1 +奮 1 +女 1 +奴 1 +奶 1 +奸 1 +她 1 +好 1 +如 1 +妃 1 +妄 1 +妆 1 +妇 1 +妈 1 +妊 1 +妍 1 +妒 1 +妓 1 +妖 1 +妘 1 +妙 1 +妝 1 +妞 1 +妣 1 +妤 1 +妥 1 +妨 1 +妩 1 +妪 1 +妮 1 +妲 1 +妳 1 +妹 1 +妻 1 +妾 1 +姆 1 +姉 1 +姊 1 +始 1 +姍 1 +姐 1 +姑 1 +姒 1 +姓 1 +委 1 +姗 1 +姚 1 +姜 1 +姝 1 +姣 1 +姥 1 +姦 1 +姨 1 +姪 1 +姫 1 +姬 1 +姹 1 +姻 1 +姿 1 +威 1 +娃 1 +娄 1 +娅 1 +娆 1 +娇 1 +娉 1 +娑 1 +娓 1 +娘 1 +娛 1 +娜 1 +娟 1 +娠 1 +娣 1 +娥 1 +娩 1 +娱 1 +娲 1 +娴 1 +娶 1 +娼 1 +婀 1 +婁 1 +婆 1 +婉 1 +婊 1 +婕 1 +婚 1 +婢 1 +婦 1 +婧 1 +婪 1 +婭 1 +婴 1 +婵 1 +婶 1 +婷 1 +婺 1 +婿 1 +媒 1 +媚 1 +媛 1 +媞 1 +媧 1 +媲 1 +媳 1 +媽 1 +媾 1 +嫁 1 +嫂 1 +嫉 1 +嫌 1 +嫑 1 +嫔 1 +嫖 1 +嫘 1 +嫚 1 +嫡 1 +嫣 1 +嫦 1 +嫩 1 +嫲 1 +嫵 1 +嫻 1 +嬅 1 +嬉 1 +嬌 1 +嬗 1 +嬛 1 +嬢 1 +嬤 1 +嬪 1 +嬰 1 +嬴 1 +嬷 1 +嬸 1 +嬿 1 +孀 1 +孃 1 +子 1 +孑 1 +孔 1 +孕 1 +孖 1 +字 1 +存 1 +孙 1 +孚 1 +孛 1 +孜 1 +孝 1 +孟 1 +孢 1 +季 1 +孤 1 +学 1 +孩 1 +孪 1 +孫 1 +孬 1 +孰 1 +孱 1 +孳 1 +孵 1 +學 1 +孺 1 +孽 1 +孿 1 +宁 1 +它 1 +宅 1 +宇 1 +守 1 +安 1 +宋 1 +完 1 +宏 1 +宓 1 +宕 1 +宗 1 +官 1 +宙 1 +定 1 +宛 1 +宜 1 +宝 1 +实 1 +実 1 +宠 1 +审 1 +客 1 +宣 1 +室 1 +宥 1 +宦 1 +宪 1 +宫 1 +宮 1 +宰 1 +害 1 +宴 1 +宵 1 +家 1 +宸 1 +容 1 +宽 1 +宾 1 +宿 1 +寂 1 +寄 1 +寅 1 +密 1 +寇 1 +富 1 +寐 1 +寒 1 +寓 1 +寛 1 +寝 1 +寞 1 +察 1 +寡 1 +寢 1 +寥 1 +實 1 +寧 1 +寨 1 +審 1 +寫 1 +寬 1 +寮 1 +寰 1 +寵 1 +寶 1 +寸 1 +对 1 +寺 1 +寻 1 +导 1 +対 1 +寿 1 +封 1 +専 1 +射 1 +将 1 +將 1 +專 1 +尉 1 +尊 1 +尋 1 +對 1 +導 1 +小 1 +少 1 +尔 1 +尕 1 +尖 1 +尘 1 +尚 1 +尝 1 +尤 1 +尧 1 +尬 1 +就 1 +尴 1 +尷 1 +尸 1 +尹 1 +尺 1 +尻 1 +尼 1 +尽 1 +尾 1 +尿 1 +局 1 +屁 1 +层 1 +屄 1 +居 1 +屆 1 +屈 1 +屉 1 +届 1 +屋 1 +屌 1 +屍 1 +屎 1 +屏 1 +屐 1 +屑 1 +展 1 +屜 1 +属 1 +屠 1 +屡 1 +屢 1 +層 1 +履 1 +屬 1 +屯 1 +山 1 +屹 1 +屿 1 +岀 1 +岁 1 +岂 1 +岌 1 +岐 1 +岑 1 +岔 1 +岖 1 +岗 1 +岘 1 +岙 1 +岚 1 +岛 1 +岡 1 +岩 1 +岫 1 +岬 1 +岭 1 +岱 1 +岳 1 +岷 1 +岸 1 +峇 1 +峋 1 +峒 1 +峙 1 +峡 1 +峤 1 +峥 1 +峦 1 +峨 1 +峪 1 +峭 1 +峯 1 +峰 1 +峴 1 +島 1 +峻 1 +峽 1 +崁 1 +崂 1 +崆 1 +崇 1 +崎 1 +崑 1 +崔 1 +崖 1 +崗 1 +崙 1 +崛 1 +崧 1 +崩 1 +崭 1 +崴 1 +崽 1 +嵇 1 +嵊 1 +嵋 1 +嵌 1 +嵐 1 +嵘 1 +嵩 1 +嵬 1 +嵯 1 +嶂 1 +嶄 1 +嶇 1 +嶋 1 +嶙 1 +嶺 1 +嶼 1 +嶽 1 +巅 1 +巍 1 +巒 1 +巔 1 +巖 1 +川 1 +州 1 +巡 1 +巢 1 +工 1 +左 1 +巧 1 +巨 1 +巩 1 +巫 1 +差 1 +己 1 +已 1 +巳 1 +巴 1 +巷 1 +巻 1 +巽 1 +巾 1 +巿 1 +币 1 +市 1 +布 1 +帅 1 +帆 1 +师 1 +希 1 +帐 1 +帑 1 +帕 1 +帖 1 +帘 1 +帚 1 +帛 1 +帜 1 +帝 1 +帥 1 +带 1 +帧 1 +師 1 +席 1 +帮 1 +帯 1 +帰 1 +帳 1 +帶 1 +帷 1 +常 1 +帼 1 +帽 1 +幀 1 +幂 1 +幄 1 +幅 1 +幌 1 +幔 1 +幕 1 +幟 1 +幡 1 +幢 1 +幣 1 +幫 1 +干 1 +平 1 +年 1 +并 1 +幸 1 +幹 1 +幺 1 +幻 1 +幼 1 +幽 1 +幾 1 +广 1 +庁 1 +広 1 +庄 1 +庆 1 +庇 1 +床 1 +序 1 +庐 1 +库 1 +应 1 +底 1 +庖 1 +店 1 +庙 1 +庚 1 +府 1 +庞 1 +废 1 +庠 1 +度 1 +座 1 +庫 1 +庭 1 +庵 1 +庶 1 +康 1 +庸 1 +庹 1 +庾 1 +廁 1 +廂 1 +廃 1 +廈 1 +廉 1 +廊 1 +廓 1 +廖 1 +廚 1 +廝 1 +廟 1 +廠 1 +廢 1 +廣 1 +廬 1 +廳 1 +延 1 +廷 1 +建 1 +廿 1 +开 1 +弁 1 +异 1 +弃 1 +弄 1 +弈 1 +弊 1 +弋 1 +式 1 +弑 1 +弒 1 +弓 1 +弔 1 +引 1 +弗 1 +弘 1 +弛 1 +弟 1 +张 1 +弥 1 +弦 1 +弧 1 +弩 1 +弭 1 +弯 1 +弱 1 +張 1 +強 1 +弹 1 +强 1 +弼 1 +弾 1 +彅 1 +彆 1 +彈 1 +彌 1 +彎 1 +归 1 +当 1 +录 1 +彗 1 +彙 1 +彝 1 +形 1 +彤 1 +彥 1 +彦 1 +彧 1 +彩 1 +彪 1 +彫 1 +彬 1 +彭 1 +彰 1 +影 1 +彷 1 +役 1 +彻 1 +彼 1 +彿 1 +往 1 +征 1 +径 1 +待 1 +徇 1 +很 1 +徉 1 +徊 1 +律 1 +後 1 +徐 1 +徑 1 +徒 1 +従 1 +徕 1 +得 1 +徘 1 +徙 1 +徜 1 +從 1 +徠 1 +御 1 +徨 1 +復 1 +循 1 +徬 1 +微 1 +徳 1 +徴 1 +徵 1 +德 1 +徹 1 +徼 1 +徽 1 +心 1 +必 1 +忆 1 +忌 1 +忍 1 +忏 1 +忐 1 +忑 1 +忒 1 +忖 1 +志 1 +忘 1 +忙 1 +応 1 +忠 1 +忡 1 +忤 1 +忧 1 +忪 1 +快 1 +忱 1 +念 1 +忻 1 +忽 1 +忿 1 +怀 1 +态 1 +怂 1 +怅 1 +怆 1 +怎 1 +怏 1 +怒 1 +怔 1 +怕 1 +怖 1 +怙 1 +怜 1 +思 1 +怠 1 +怡 1 +急 1 +怦 1 +性 1 +怨 1 +怪 1 +怯 1 +怵 1 +总 1 +怼 1 +恁 1 +恃 1 +恆 1 +恋 1 +恍 1 +恐 1 +恒 1 +恕 1 +恙 1 +恚 1 +恢 1 +恣 1 +恤 1 +恥 1 +恨 1 +恩 1 +恪 1 +恫 1 +恬 1 +恭 1 +息 1 +恰 1 +恳 1 +恵 1 +恶 1 +恸 1 +恺 1 +恻 1 +恼 1 +恿 1 +悄 1 +悅 1 +悉 1 +悌 1 +悍 1 +悔 1 +悖 1 +悚 1 +悟 1 +悠 1 +患 1 +悦 1 +您 1 +悩 1 +悪 1 +悬 1 +悯 1 +悱 1 +悲 1 +悴 1 +悵 1 +悶 1 +悸 1 +悻 1 +悼 1 +悽 1 +情 1 +惆 1 +惇 1 +惊 1 +惋 1 +惑 1 +惕 1 +惘 1 +惚 1 +惜 1 +惟 1 +惠 1 +惡 1 +惦 1 +惧 1 +惨 1 +惩 1 +惫 1 +惬 1 +惭 1 +惮 1 +惯 1 +惰 1 +惱 1 +想 1 +惴 1 +惶 1 +惹 1 +惺 1 +愁 1 +愆 1 +愈 1 +愉 1 +愍 1 +意 1 +愕 1 +愚 1 +愛 1 +愜 1 +感 1 +愣 1 +愤 1 +愧 1 +愫 1 +愷 1 +愿 1 +慄 1 +慈 1 +態 1 +慌 1 +慎 1 +慑 1 +慕 1 +慘 1 +慚 1 +慟 1 +慢 1 +慣 1 +慧 1 +慨 1 +慫 1 +慮 1 +慰 1 +慳 1 +慵 1 +慶 1 +慷 1 +慾 1 +憂 1 +憊 1 +憋 1 +憎 1 +憐 1 +憑 1 +憔 1 +憚 1 +憤 1 +憧 1 +憨 1 +憩 1 +憫 1 +憬 1 +憲 1 +憶 1 +憾 1 +懂 1 +懇 1 +懈 1 +應 1 +懊 1 +懋 1 +懑 1 +懒 1 +懦 1 +懲 1 +懵 1 +懶 1 +懷 1 +懸 1 +懺 1 +懼 1 +懾 1 +懿 1 +戀 1 +戈 1 +戊 1 +戌 1 +戍 1 +戎 1 +戏 1 +成 1 +我 1 +戒 1 +戕 1 +或 1 +战 1 +戚 1 +戛 1 +戟 1 +戡 1 +戦 1 +截 1 +戬 1 +戮 1 +戰 1 +戲 1 +戳 1 +戴 1 +戶 1 +户 1 +戸 1 +戻 1 +戾 1 +房 1 +所 1 +扁 1 +扇 1 +扈 1 +扉 1 +手 1 +才 1 +扎 1 +扑 1 +扒 1 +打 1 +扔 1 +払 1 +托 1 +扛 1 +扣 1 +扦 1 +执 1 +扩 1 +扪 1 +扫 1 +扬 1 +扭 1 +扮 1 +扯 1 +扰 1 +扱 1 +扳 1 +扶 1 +批 1 +扼 1 +找 1 +承 1 +技 1 +抄 1 +抉 1 +把 1 +抑 1 +抒 1 +抓 1 +投 1 +抖 1 +抗 1 +折 1 +抚 1 +抛 1 +抜 1 +択 1 +抟 1 +抠 1 +抡 1 +抢 1 +护 1 +报 1 +抨 1 +披 1 +抬 1 +抱 1 +抵 1 +抹 1 +押 1 +抽 1 +抿 1 +拂 1 +拄 1 +担 1 +拆 1 +拇 1 +拈 1 +拉 1 +拋 1 +拌 1 +拍 1 +拎 1 +拐 1 +拒 1 +拓 1 +拔 1 +拖 1 +拗 1 +拘 1 +拙 1 +拚 1 +招 1 +拜 1 +拟 1 +拡 1 +拢 1 +拣 1 +拥 1 +拦 1 +拧 1 +拨 1 +择 1 +括 1 +拭 1 +拮 1 +拯 1 +拱 1 +拳 1 +拴 1 +拷 1 +拼 1 +拽 1 +拾 1 +拿 1 +持 1 +挂 1 +指 1 +挈 1 +按 1 +挎 1 +挑 1 +挖 1 +挙 1 +挚 1 +挛 1 +挝 1 +挞 1 +挟 1 +挠 1 +挡 1 +挣 1 +挤 1 +挥 1 +挨 1 +挪 1 +挫 1 +振 1 +挲 1 +挹 1 +挺 1 +挽 1 +挾 1 +捂 1 +捅 1 +捆 1 +捉 1 +捋 1 +捌 1 +捍 1 +捎 1 +捏 1 +捐 1 +捕 1 +捞 1 +损 1 +捡 1 +换 1 +捣 1 +捧 1 +捨 1 +捩 1 +据 1 +捱 1 +捲 1 +捶 1 +捷 1 +捺 1 +捻 1 +掀 1 +掂 1 +掃 1 +掇 1 +授 1 +掉 1 +掌 1 +掏 1 +掐 1 +排 1 +掖 1 +掘 1 +掙 1 +掛 1 +掠 1 +採 1 +探 1 +掣 1 +接 1 +控 1 +推 1 +掩 1 +措 1 +掬 1 +掰 1 +掲 1 +掳 1 +掴 1 +掷 1 +掸 1 +掺 1 +揀 1 +揃 1 +揄 1 +揆 1 +揉 1 +揍 1 +描 1 +提 1 +插 1 +揖 1 +揚 1 +換 1 +握 1 +揣 1 +揩 1 +揪 1 +揭 1 +揮 1 +援 1 +揶 1 +揸 1 +揹 1 +揽 1 +搀 1 +搁 1 +搂 1 +搅 1 +損 1 +搏 1 +搐 1 +搓 1 +搔 1 +搖 1 +搗 1 +搜 1 +搞 1 +搡 1 +搪 1 +搬 1 +搭 1 +搵 1 +搶 1 +携 1 +搽 1 +摀 1 +摁 1 +摄 1 +摆 1 +摇 1 +摈 1 +摊 1 +摒 1 +摔 1 +摘 1 +摞 1 +摟 1 +摧 1 +摩 1 +摯 1 +摳 1 +摸 1 +摹 1 +摺 1 +摻 1 +撂 1 +撃 1 +撅 1 +撇 1 +撈 1 +撐 1 +撑 1 +撒 1 +撓 1 +撕 1 +撚 1 +撞 1 +撤 1 +撥 1 +撩 1 +撫 1 +撬 1 +播 1 +撮 1 +撰 1 +撲 1 +撵 1 +撷 1 +撸 1 +撻 1 +撼 1 +撿 1 +擀 1 +擁 1 +擂 1 +擄 1 +擅 1 +擇 1 +擊 1 +擋 1 +操 1 +擎 1 +擒 1 +擔 1 +擘 1 +據 1 +擞 1 +擠 1 +擡 1 +擢 1 +擦 1 +擬 1 +擰 1 +擱 1 +擲 1 +擴 1 +擷 1 +擺 1 +擼 1 +擾 1 +攀 1 +攏 1 +攒 1 +攔 1 +攘 1 +攙 1 +攜 1 +攝 1 +攞 1 +攢 1 +攣 1 +攤 1 +攥 1 +攪 1 +攫 1 +攬 1 +支 1 +收 1 +攸 1 +改 1 +攻 1 +放 1 +政 1 +故 1 +效 1 +敌 1 +敍 1 +敎 1 +敏 1 +救 1 +敕 1 +敖 1 +敗 1 +敘 1 +教 1 +敛 1 +敝 1 +敞 1 +敢 1 +散 1 +敦 1 +敬 1 +数 1 +敲 1 +整 1 +敵 1 +敷 1 +數 1 +斂 1 +斃 1 +文 1 +斋 1 +斌 1 +斎 1 +斐 1 +斑 1 +斓 1 +斗 1 +料 1 +斛 1 +斜 1 +斟 1 +斡 1 +斤 1 +斥 1 +斧 1 +斩 1 +斫 1 +斬 1 +断 1 +斯 1 +新 1 +斷 1 +方 1 +於 1 +施 1 +旁 1 +旃 1 +旅 1 +旋 1 +旌 1 +旎 1 +族 1 +旖 1 +旗 1 +无 1 +既 1 +日 1 +旦 1 +旧 1 +旨 1 +早 1 +旬 1 +旭 1 +旮 1 +旱 1 +时 1 +旷 1 +旺 1 +旻 1 +昀 1 +昂 1 +昆 1 +昇 1 +昉 1 +昊 1 +昌 1 +明 1 +昏 1 +易 1 +昔 1 +昕 1 +昙 1 +星 1 +映 1 +春 1 +昧 1 +昨 1 +昭 1 +是 1 +昱 1 +昴 1 +昵 1 +昶 1 +昼 1 +显 1 +晁 1 +時 1 +晃 1 +晉 1 +晋 1 +晌 1 +晏 1 +晒 1 +晓 1 +晔 1 +晕 1 +晖 1 +晗 1 +晚 1 +晝 1 +晞 1 +晟 1 +晤 1 +晦 1 +晨 1 +晩 1 +普 1 +景 1 +晰 1 +晴 1 +晶 1 +晷 1 +智 1 +晾 1 +暂 1 +暄 1 +暇 1 +暈 1 +暉 1 +暌 1 +暐 1 +暑 1 +暖 1 +暗 1 +暝 1 +暢 1 +暧 1 +暨 1 +暫 1 +暮 1 +暱 1 +暴 1 +暸 1 +暹 1 +曄 1 +曆 1 +曇 1 +曉 1 +曖 1 +曙 1 +曜 1 +曝 1 +曠 1 +曦 1 +曬 1 +曰 1 +曲 1 +曳 1 +更 1 +書 1 +曹 1 +曼 1 +曾 1 +替 1 +最 1 +會 1 +月 1 +有 1 +朋 1 +服 1 +朐 1 +朔 1 +朕 1 +朗 1 +望 1 +朝 1 +期 1 +朦 1 +朧 1 +木 1 +未 1 +末 1 +本 1 +札 1 +朮 1 +术 1 +朱 1 +朴 1 +朵 1 +机 1 +朽 1 +杀 1 +杂 1 +权 1 +杆 1 +杈 1 +杉 1 +李 1 +杏 1 +材 1 +村 1 +杓 1 +杖 1 +杜 1 +杞 1 +束 1 +杠 1 +条 1 +来 1 +杨 1 +杭 1 +杯 1 +杰 1 +東 1 +杳 1 +杵 1 +杷 1 +杼 1 +松 1 +板 1 +极 1 +构 1 +枇 1 +枉 1 +枋 1 +析 1 +枕 1 +林 1 +枚 1 +果 1 +枝 1 +枢 1 +枣 1 +枪 1 +枫 1 +枭 1 +枯 1 +枰 1 +枱 1 +枳 1 +架 1 +枷 1 +枸 1 +柄 1 +柏 1 +某 1 +柑 1 +柒 1 +染 1 +柔 1 +柘 1 +柚 1 +柜 1 +柞 1 +柠 1 +柢 1 +查 1 +柩 1 +柬 1 +柯 1 +柱 1 +柳 1 +柴 1 +柵 1 +査 1 +柿 1 +栀 1 +栃 1 +栄 1 +栅 1 +标 1 +栈 1 +栉 1 +栋 1 +栎 1 +栏 1 +树 1 +栓 1 +栖 1 +栗 1 +校 1 +栩 1 +株 1 +样 1 +核 1 +根 1 +格 1 +栽 1 +栾 1 +桀 1 +桁 1 +桂 1 +桃 1 +桅 1 +框 1 +案 1 +桉 1 +桌 1 +桎 1 +桐 1 +桑 1 +桓 1 +桔 1 +桜 1 +桠 1 +桡 1 +桢 1 +档 1 +桥 1 +桦 1 +桧 1 +桨 1 +桩 1 +桶 1 +桿 1 +梁 1 +梅 1 +梆 1 +梏 1 +梓 1 +梗 1 +條 1 +梟 1 +梢 1 +梦 1 +梧 1 +梨 1 +梭 1 +梯 1 +械 1 +梳 1 +梵 1 +梶 1 +检 1 +棂 1 +棄 1 +棉 1 +棋 1 +棍 1 +棒 1 +棕 1 +棗 1 +棘 1 +棚 1 +棟 1 +棠 1 +棣 1 +棧 1 +森 1 +棱 1 +棲 1 +棵 1 +棹 1 +棺 1 +椁 1 +椅 1 +椋 1 +植 1 +椎 1 +椒 1 +検 1 +椪 1 +椭 1 +椰 1 +椹 1 +椽 1 +椿 1 +楂 1 +楊 1 +楓 1 +楔 1 +楚 1 +楝 1 +楞 1 +楠 1 +楣 1 +楨 1 +楫 1 +業 1 +楮 1 +極 1 +楷 1 +楸 1 +楹 1 +楼 1 +楽 1 +概 1 +榄 1 +榆 1 +榈 1 +榉 1 +榔 1 +榕 1 +榖 1 +榛 1 +榜 1 +榨 1 +榫 1 +榭 1 +榮 1 +榱 1 +榴 1 +榷 1 +榻 1 +槁 1 +槃 1 +構 1 +槌 1 +槍 1 +槎 1 +槐 1 +槓 1 +様 1 +槛 1 +槟 1 +槤 1 +槭 1 +槲 1 +槳 1 +槻 1 +槽 1 +槿 1 +樁 1 +樂 1 +樊 1 +樑 1 +樓 1 +標 1 +樞 1 +樟 1 +模 1 +樣 1 +権 1 +横 1 +樫 1 +樯 1 +樱 1 +樵 1 +樸 1 +樹 1 +樺 1 +樽 1 +樾 1 +橄 1 +橇 1 +橋 1 +橐 1 +橘 1 +橙 1 +機 1 +橡 1 +橢 1 +橫 1 +橱 1 +橹 1 +橼 1 +檀 1 +檄 1 +檎 1 +檐 1 +檔 1 +檗 1 +檜 1 +檢 1 +檬 1 +檯 1 +檳 1 +檸 1 +檻 1 +櫃 1 +櫚 1 +櫛 1 +櫥 1 +櫸 1 +櫻 1 +欄 1 +權 1 +欒 1 +欖 1 +欠 1 +次 1 +欢 1 +欣 1 +欧 1 +欲 1 +欸 1 +欺 1 +欽 1 +款 1 +歆 1 +歇 1 +歉 1 +歌 1 +歎 1 +歐 1 +歓 1 +歙 1 +歛 1 +歡 1 +止 1 +正 1 +此 1 +步 1 +武 1 +歧 1 +歩 1 +歪 1 +歯 1 +歲 1 +歳 1 +歴 1 +歷 1 +歸 1 +歹 1 +死 1 +歼 1 +殁 1 +殃 1 +殆 1 +殇 1 +殉 1 +殊 1 +残 1 +殒 1 +殓 1 +殖 1 +殘 1 +殞 1 +殡 1 +殤 1 +殭 1 +殯 1 +殲 1 +殴 1 +段 1 +殷 1 +殺 1 +殼 1 +殿 1 +毀 1 +毁 1 +毂 1 +毅 1 +毆 1 +毋 1 +母 1 +毎 1 +每 1 +毒 1 +毓 1 +比 1 +毕 1 +毗 1 +毘 1 +毙 1 +毛 1 +毡 1 +毫 1 +毯 1 +毽 1 +氈 1 +氏 1 +氐 1 +民 1 +氓 1 +气 1 +氖 1 +気 1 +氙 1 +氛 1 +氟 1 +氡 1 +氢 1 +氣 1 +氤 1 +氦 1 +氧 1 +氨 1 +氪 1 +氫 1 +氮 1 +氯 1 +氰 1 +氲 1 +水 1 +氷 1 +永 1 +氹 1 +氾 1 +汀 1 +汁 1 +求 1 +汆 1 +汇 1 +汉 1 +汎 1 +汐 1 +汕 1 +汗 1 +汙 1 +汛 1 +汝 1 +汞 1 +江 1 +池 1 +污 1 +汤 1 +汨 1 +汩 1 +汪 1 +汰 1 +汲 1 +汴 1 +汶 1 +汹 1 +決 1 +汽 1 +汾 1 +沁 1 +沂 1 +沃 1 +沅 1 +沈 1 +沉 1 +沌 1 +沏 1 +沐 1 +沒 1 +沓 1 +沖 1 +沙 1 +沛 1 +沟 1 +没 1 +沢 1 +沣 1 +沥 1 +沦 1 +沧 1 +沪 1 +沫 1 +沭 1 +沮 1 +沱 1 +河 1 +沸 1 +油 1 +治 1 +沼 1 +沽 1 +沾 1 +沿 1 +況 1 +泄 1 +泉 1 +泊 1 +泌 1 +泓 1 +法 1 +泗 1 +泛 1 +泞 1 +泠 1 +泡 1 +波 1 +泣 1 +泥 1 +注 1 +泪 1 +泫 1 +泮 1 +泯 1 +泰 1 +泱 1 +泳 1 +泵 1 +泷 1 +泸 1 +泻 1 +泼 1 +泽 1 +泾 1 +洁 1 +洄 1 +洋 1 +洒 1 +洗 1 +洙 1 +洛 1 +洞 1 +津 1 +洩 1 +洪 1 +洮 1 +洱 1 +洲 1 +洵 1 +洶 1 +洸 1 +洹 1 +活 1 +洼 1 +洽 1 +派 1 +流 1 +浃 1 +浄 1 +浅 1 +浆 1 +浇 1 +浊 1 +测 1 +济 1 +浏 1 +浑 1 +浒 1 +浓 1 +浔 1 +浙 1 +浚 1 +浜 1 +浣 1 +浦 1 +浩 1 +浪 1 +浬 1 +浮 1 +浯 1 +浴 1 +海 1 +浸 1 +涂 1 +涅 1 +涇 1 +消 1 +涉 1 +涌 1 +涎 1 +涓 1 +涔 1 +涕 1 +涙 1 +涛 1 +涝 1 +涞 1 +涟 1 +涠 1 +涡 1 +涣 1 +涤 1 +润 1 +涧 1 +涨 1 +涩 1 +涪 1 +涮 1 +涯 1 +液 1 +涵 1 +涸 1 +涼 1 +涿 1 +淀 1 +淄 1 +淅 1 +淆 1 +淇 1 +淋 1 +淌 1 +淑 1 +淒 1 +淖 1 +淘 1 +淙 1 +淚 1 +淞 1 +淡 1 +淤 1 +淦 1 +淨 1 +淩 1 +淪 1 +淫 1 +淬 1 +淮 1 +深 1 +淳 1 +淵 1 +混 1 +淹 1 +淺 1 +添 1 +淼 1 +清 1 +済 1 +渉 1 +渊 1 +渋 1 +渍 1 +渎 1 +渐 1 +渔 1 +渗 1 +渙 1 +渚 1 +減 1 +渝 1 +渠 1 +渡 1 +渣 1 +渤 1 +渥 1 +渦 1 +温 1 +測 1 +渭 1 +港 1 +渲 1 +渴 1 +游 1 +渺 1 +渾 1 +湃 1 +湄 1 +湊 1 +湍 1 +湖 1 +湘 1 +湛 1 +湟 1 +湧 1 +湫 1 +湮 1 +湯 1 +湳 1 +湾 1 +湿 1 +満 1 +溃 1 +溅 1 +溉 1 +溏 1 +源 1 +準 1 +溜 1 +溝 1 +溟 1 +溢 1 +溥 1 +溧 1 +溪 1 +溫 1 +溯 1 +溱 1 +溴 1 +溶 1 +溺 1 +溼 1 +滁 1 +滂 1 +滄 1 +滅 1 +滇 1 +滋 1 +滌 1 +滑 1 +滓 1 +滔 1 +滕 1 +滙 1 +滚 1 +滝 1 +滞 1 +滟 1 +满 1 +滢 1 +滤 1 +滥 1 +滦 1 +滨 1 +滩 1 +滬 1 +滯 1 +滲 1 +滴 1 +滷 1 +滸 1 +滾 1 +滿 1 +漁 1 +漂 1 +漆 1 +漉 1 +漏 1 +漓 1 +演 1 +漕 1 +漠 1 +漢 1 +漣 1 +漩 1 +漪 1 +漫 1 +漬 1 +漯 1 +漱 1 +漲 1 +漳 1 +漸 1 +漾 1 +漿 1 +潆 1 +潇 1 +潋 1 +潍 1 +潑 1 +潔 1 +潘 1 +潛 1 +潜 1 +潞 1 +潟 1 +潢 1 +潤 1 +潦 1 +潧 1 +潭 1 +潮 1 +潰 1 +潴 1 +潸 1 +潺 1 +潼 1 +澀 1 +澄 1 +澆 1 +澈 1 +澍 1 +澎 1 +澗 1 +澜 1 +澡 1 +澤 1 +澧 1 +澱 1 +澳 1 +澹 1 +激 1 +濁 1 +濂 1 +濃 1 +濑 1 +濒 1 +濕 1 +濘 1 +濛 1 +濟 1 +濠 1 +濡 1 +濤 1 +濫 1 +濬 1 +濮 1 +濯 1 +濱 1 +濺 1 +濾 1 +瀅 1 +瀆 1 +瀉 1 +瀋 1 +瀏 1 +瀑 1 +瀕 1 +瀘 1 +瀚 1 +瀛 1 +瀝 1 +瀞 1 +瀟 1 +瀧 1 +瀨 1 +瀬 1 +瀰 1 +瀾 1 +灌 1 +灏 1 +灑 1 +灘 1 +灝 1 +灞 1 +灣 1 +火 1 +灬 1 +灭 1 +灯 1 +灰 1 +灵 1 +灶 1 +灸 1 +灼 1 +災 1 +灾 1 +灿 1 +炀 1 +炁 1 +炅 1 +炉 1 +炊 1 +炎 1 +炒 1 +炔 1 +炕 1 +炖 1 +炙 1 +炜 1 +炫 1 +炬 1 +炭 1 +炮 1 +炯 1 +炳 1 +炷 1 +炸 1 +点 1 +為 1 +炼 1 +炽 1 +烁 1 +烂 1 +烃 1 +烈 1 +烊 1 +烏 1 +烘 1 +烙 1 +烛 1 +烟 1 +烤 1 +烦 1 +烧 1 +烨 1 +烩 1 +烫 1 +烬 1 +热 1 +烯 1 +烷 1 +烹 1 +烽 1 +焉 1 +焊 1 +焕 1 +焖 1 +焗 1 +焘 1 +焙 1 +焚 1 +焜 1 +無 1 +焦 1 +焯 1 +焰 1 +焱 1 +然 1 +焼 1 +煅 1 +煉 1 +煊 1 +煌 1 +煎 1 +煒 1 +煖 1 +煙 1 +煜 1 +煞 1 +煤 1 +煥 1 +煦 1 +照 1 +煨 1 +煩 1 +煮 1 +煲 1 +煸 1 +煽 1 +熄 1 +熊 1 +熏 1 +熒 1 +熔 1 +熙 1 +熟 1 +熠 1 +熨 1 +熬 1 +熱 1 +熵 1 +熹 1 +熾 1 +燁 1 +燃 1 +燄 1 +燈 1 +燉 1 +燊 1 +燎 1 +燒 1 +燔 1 +燕 1 +燙 1 +燜 1 +營 1 +燥 1 +燦 1 +燧 1 +燭 1 +燮 1 +燴 1 +燻 1 +燼 1 +燿 1 +爆 1 +爍 1 +爐 1 +爛 1 +爪 1 +爬 1 +爭 1 +爰 1 +爱 1 +爲 1 +爵 1 +父 1 +爷 1 +爸 1 +爹 1 +爺 1 +爻 1 +爽 1 +爾 1 +牆 1 +片 1 +版 1 +牌 1 +牍 1 +牒 1 +牙 1 +牛 1 +牝 1 +牟 1 +牠 1 +牡 1 +牢 1 +牦 1 +牧 1 +物 1 +牯 1 +牲 1 +牴 1 +牵 1 +特 1 +牺 1 +牽 1 +犀 1 +犁 1 +犄 1 +犊 1 +犍 1 +犒 1 +犢 1 +犧 1 +犬 1 +犯 1 +状 1 +犷 1 +犸 1 +犹 1 +狀 1 +狂 1 +狄 1 +狈 1 +狎 1 +狐 1 +狒 1 +狗 1 +狙 1 +狞 1 +狠 1 +狡 1 +狩 1 +独 1 +狭 1 +狮 1 +狰 1 +狱 1 +狸 1 +狹 1 +狼 1 +狽 1 +猎 1 +猕 1 +猖 1 +猗 1 +猙 1 +猛 1 +猜 1 +猝 1 +猥 1 +猩 1 +猪 1 +猫 1 +猬 1 +献 1 +猴 1 +猶 1 +猷 1 +猾 1 +猿 1 +獄 1 +獅 1 +獎 1 +獐 1 +獒 1 +獗 1 +獠 1 +獣 1 +獨 1 +獭 1 +獰 1 +獲 1 +獵 1 +獷 1 +獸 1 +獺 1 +獻 1 +獼 1 +獾 1 +玄 1 +率 1 +玉 1 +王 1 +玑 1 +玖 1 +玛 1 +玟 1 +玠 1 +玥 1 +玩 1 +玫 1 +玮 1 +环 1 +现 1 +玲 1 +玳 1 +玷 1 +玺 1 +玻 1 +珀 1 +珂 1 +珅 1 +珈 1 +珉 1 +珊 1 +珍 1 +珏 1 +珐 1 +珑 1 +珙 1 +珞 1 +珠 1 +珣 1 +珥 1 +珩 1 +珪 1 +班 1 +珮 1 +珲 1 +珺 1 +現 1 +球 1 +琅 1 +理 1 +琇 1 +琉 1 +琊 1 +琍 1 +琏 1 +琐 1 +琛 1 +琢 1 +琥 1 +琦 1 +琨 1 +琪 1 +琬 1 +琮 1 +琰 1 +琲 1 +琳 1 +琴 1 +琵 1 +琶 1 +琺 1 +琼 1 +瑀 1 +瑁 1 +瑄 1 +瑋 1 +瑕 1 +瑗 1 +瑙 1 +瑚 1 +瑛 1 +瑜 1 +瑞 1 +瑟 1 +瑠 1 +瑣 1 +瑤 1 +瑩 1 +瑪 1 +瑯 1 +瑰 1 +瑶 1 +瑾 1 +璀 1 +璁 1 +璃 1 +璇 1 +璉 1 +璋 1 +璎 1 +璐 1 +璜 1 +璞 1 +璟 1 +璧 1 +璨 1 +環 1 +璽 1 +璿 1 +瓊 1 +瓏 1 +瓒 1 +瓜 1 +瓢 1 +瓣 1 +瓤 1 +瓦 1 +瓮 1 +瓯 1 +瓴 1 +瓶 1 +瓷 1 +甄 1 +甌 1 +甕 1 +甘 1 +甙 1 +甚 1 +甜 1 +生 1 +產 1 +産 1 +甥 1 +甦 1 +用 1 +甩 1 +甫 1 +甬 1 +甭 1 +甯 1 +田 1 +由 1 +甲 1 +申 1 +电 1 +男 1 +甸 1 +町 1 +画 1 +甾 1 +畀 1 +畅 1 +界 1 +畏 1 +畑 1 +畔 1 +留 1 +畜 1 +畝 1 +畢 1 +略 1 +畦 1 +番 1 +畫 1 +異 1 +畲 1 +畳 1 +畴 1 +當 1 +畸 1 +畹 1 +畿 1 +疆 1 +疇 1 +疊 1 +疏 1 +疑 1 +疔 1 +疖 1 +疗 1 +疙 1 +疚 1 +疝 1 +疟 1 +疡 1 +疣 1 +疤 1 +疥 1 +疫 1 +疮 1 +疯 1 +疱 1 +疲 1 +疳 1 +疵 1 +疸 1 +疹 1 +疼 1 +疽 1 +疾 1 +痂 1 +病 1 +症 1 +痈 1 +痉 1 +痊 1 +痍 1 +痒 1 +痔 1 +痕 1 +痘 1 +痙 1 +痛 1 +痞 1 +痠 1 +痢 1 +痣 1 +痤 1 +痧 1 +痨 1 +痪 1 +痫 1 +痰 1 +痱 1 +痴 1 +痹 1 +痺 1 +痼 1 +痿 1 +瘀 1 +瘁 1 +瘋 1 +瘍 1 +瘓 1 +瘘 1 +瘙 1 +瘟 1 +瘠 1 +瘡 1 +瘢 1 +瘤 1 +瘦 1 +瘧 1 +瘩 1 +瘪 1 +瘫 1 +瘴 1 +瘸 1 +瘾 1 +療 1 +癇 1 +癌 1 +癒 1 +癖 1 +癜 1 +癞 1 +癡 1 +癢 1 +癣 1 +癥 1 +癫 1 +癬 1 +癮 1 +癱 1 +癲 1 +癸 1 +発 1 +登 1 +發 1 +白 1 +百 1 +皂 1 +的 1 +皆 1 +皇 1 +皈 1 +皋 1 +皎 1 +皑 1 +皓 1 +皖 1 +皙 1 +皚 1 +皮 1 +皰 1 +皱 1 +皴 1 +皺 1 +皿 1 +盂 1 +盃 1 +盅 1 +盆 1 +盈 1 +益 1 +盎 1 +盏 1 +盐 1 +监 1 +盒 1 +盔 1 +盖 1 +盗 1 +盘 1 +盛 1 +盜 1 +盞 1 +盟 1 +盡 1 +監 1 +盤 1 +盥 1 +盧 1 +盪 1 +目 1 +盯 1 +盱 1 +盲 1 +直 1 +相 1 +盹 1 +盼 1 +盾 1 +省 1 +眈 1 +眉 1 +看 1 +県 1 +眙 1 +眞 1 +真 1 +眠 1 +眦 1 +眨 1 +眩 1 +眯 1 +眶 1 +眷 1 +眸 1 +眺 1 +眼 1 +眾 1 +着 1 +睁 1 +睇 1 +睏 1 +睐 1 +睑 1 +睛 1 +睜 1 +睞 1 +睡 1 +睢 1 +督 1 +睥 1 +睦 1 +睨 1 +睪 1 +睫 1 +睬 1 +睹 1 +睽 1 +睾 1 +睿 1 +瞄 1 +瞅 1 +瞇 1 +瞋 1 +瞌 1 +瞎 1 +瞑 1 +瞒 1 +瞓 1 +瞞 1 +瞟 1 +瞠 1 +瞥 1 +瞧 1 +瞩 1 +瞪 1 +瞬 1 +瞭 1 +瞰 1 +瞳 1 +瞻 1 +瞼 1 +瞿 1 +矇 1 +矍 1 +矗 1 +矚 1 +矛 1 +矜 1 +矢 1 +矣 1 +知 1 +矩 1 +矫 1 +短 1 +矮 1 +矯 1 +石 1 +矶 1 +矽 1 +矾 1 +矿 1 +码 1 +砂 1 +砌 1 +砍 1 +砒 1 +研 1 +砖 1 +砗 1 +砚 1 +砝 1 +砣 1 +砥 1 +砧 1 +砭 1 +砰 1 +砲 1 +破 1 +砷 1 +砸 1 +砺 1 +砼 1 +砾 1 +础 1 +硅 1 +硐 1 +硒 1 +硕 1 +硝 1 +硫 1 +硬 1 +确 1 +硯 1 +硼 1 +碁 1 +碇 1 +碉 1 +碌 1 +碍 1 +碎 1 +碑 1 +碓 1 +碗 1 +碘 1 +碚 1 +碛 1 +碟 1 +碣 1 +碧 1 +碩 1 +碰 1 +碱 1 +碳 1 +碴 1 +確 1 +碼 1 +碾 1 +磁 1 +磅 1 +磊 1 +磋 1 +磐 1 +磕 1 +磚 1 +磡 1 +磨 1 +磬 1 +磯 1 +磲 1 +磷 1 +磺 1 +礁 1 +礎 1 +礙 1 +礡 1 +礦 1 +礪 1 +礫 1 +礴 1 +示 1 +礼 1 +社 1 +祀 1 +祁 1 +祂 1 +祇 1 +祈 1 +祉 1 +祎 1 +祐 1 +祕 1 +祖 1 +祗 1 +祚 1 +祛 1 +祜 1 +祝 1 +神 1 +祟 1 +祠 1 +祢 1 +祥 1 +票 1 +祭 1 +祯 1 +祷 1 +祸 1 +祺 1 +祿 1 +禀 1 +禁 1 +禄 1 +禅 1 +禍 1 +禎 1 +福 1 +禛 1 +禦 1 +禧 1 +禪 1 +禮 1 +禱 1 +禹 1 +禺 1 +离 1 +禽 1 +禾 1 +禿 1 +秀 1 +私 1 +秃 1 +秆 1 +秉 1 +秋 1 +种 1 +科 1 +秒 1 +秘 1 +租 1 +秣 1 +秤 1 +秦 1 +秧 1 +秩 1 +秭 1 +积 1 +称 1 +秸 1 +移 1 +秽 1 +稀 1 +稅 1 +程 1 +稍 1 +税 1 +稔 1 +稗 1 +稚 1 +稜 1 +稞 1 +稟 1 +稠 1 +稣 1 +種 1 +稱 1 +稲 1 +稳 1 +稷 1 +稹 1 +稻 1 +稼 1 +稽 1 +稿 1 +穀 1 +穂 1 +穆 1 +穌 1 +積 1 +穎 1 +穗 1 +穢 1 +穩 1 +穫 1 +穴 1 +究 1 +穷 1 +穹 1 +空 1 +穿 1 +突 1 +窃 1 +窄 1 +窈 1 +窍 1 +窑 1 +窒 1 +窓 1 +窕 1 +窖 1 +窗 1 +窘 1 +窜 1 +窝 1 +窟 1 +窠 1 +窥 1 +窦 1 +窨 1 +窩 1 +窪 1 +窮 1 +窯 1 +窺 1 +窿 1 +竄 1 +竅 1 +竇 1 +竊 1 +立 1 +竖 1 +站 1 +竜 1 +竞 1 +竟 1 +章 1 +竣 1 +童 1 +竭 1 +端 1 +競 1 +竹 1 +竺 1 +竽 1 +竿 1 +笃 1 +笆 1 +笈 1 +笋 1 +笏 1 +笑 1 +笔 1 +笙 1 +笛 1 +笞 1 +笠 1 +符 1 +笨 1 +第 1 +笹 1 +笺 1 +笼 1 +筆 1 +等 1 +筊 1 +筋 1 +筍 1 +筏 1 +筐 1 +筑 1 +筒 1 +答 1 +策 1 +筛 1 +筝 1 +筠 1 +筱 1 +筲 1 +筵 1 +筷 1 +筹 1 +签 1 +简 1 +箇 1 +箋 1 +箍 1 +箏 1 +箐 1 +箔 1 +箕 1 +算 1 +箝 1 +管 1 +箩 1 +箫 1 +箭 1 +箱 1 +箴 1 +箸 1 +節 1 +篁 1 +範 1 +篆 1 +篇 1 +築 1 +篑 1 +篓 1 +篙 1 +篝 1 +篠 1 +篡 1 +篤 1 +篩 1 +篪 1 +篮 1 +篱 1 +篷 1 +簇 1 +簌 1 +簍 1 +簡 1 +簦 1 +簧 1 +簪 1 +簫 1 +簷 1 +簸 1 +簽 1 +簾 1 +簿 1 +籁 1 +籃 1 +籌 1 +籍 1 +籐 1 +籟 1 +籠 1 +籤 1 +籬 1 +籮 1 +籲 1 +米 1 +类 1 +籼 1 +籽 1 +粄 1 +粉 1 +粑 1 +粒 1 +粕 1 +粗 1 +粘 1 +粟 1 +粤 1 +粥 1 +粧 1 +粪 1 +粮 1 +粱 1 +粲 1 +粳 1 +粵 1 +粹 1 +粼 1 +粽 1 +精 1 +粿 1 +糅 1 +糊 1 +糍 1 +糕 1 +糖 1 +糗 1 +糙 1 +糜 1 +糞 1 +糟 1 +糠 1 +糧 1 +糬 1 +糯 1 +糰 1 +糸 1 +系 1 +糾 1 +紀 1 +紂 1 +約 1 +紅 1 +紉 1 +紊 1 +紋 1 +納 1 +紐 1 +紓 1 +純 1 +紗 1 +紘 1 +紙 1 +級 1 +紛 1 +紜 1 +素 1 +紡 1 +索 1 +紧 1 +紫 1 +紮 1 +累 1 +細 1 +紳 1 +紹 1 +紺 1 +終 1 +絃 1 +組 1 +絆 1 +経 1 +結 1 +絕 1 +絞 1 +絡 1 +絢 1 +給 1 +絨 1 +絮 1 +統 1 +絲 1 +絳 1 +絵 1 +絶 1 +絹 1 +綁 1 +綏 1 +綑 1 +經 1 +継 1 +続 1 +綜 1 +綠 1 +綢 1 +綦 1 +綫 1 +綬 1 +維 1 +綱 1 +網 1 +綴 1 +綵 1 +綸 1 +綺 1 +綻 1 +綽 1 +綾 1 +綿 1 +緊 1 +緋 1 +総 1 +緑 1 +緒 1 +緘 1 +線 1 +緝 1 +緞 1 +締 1 +緣 1 +編 1 +緩 1 +緬 1 +緯 1 +練 1 +緹 1 +緻 1 +縁 1 +縄 1 +縈 1 +縛 1 +縝 1 +縣 1 +縫 1 +縮 1 +縱 1 +縴 1 +縷 1 +總 1 +績 1 +繁 1 +繃 1 +繆 1 +繇 1 +繋 1 +織 1 +繕 1 +繚 1 +繞 1 +繡 1 +繩 1 +繪 1 +繫 1 +繭 1 +繳 1 +繹 1 +繼 1 +繽 1 +纂 1 +續 1 +纍 1 +纏 1 +纓 1 +纔 1 +纖 1 +纜 1 +纠 1 +红 1 +纣 1 +纤 1 +约 1 +级 1 +纨 1 +纪 1 +纫 1 +纬 1 +纭 1 +纯 1 +纰 1 +纱 1 +纲 1 +纳 1 +纵 1 +纶 1 +纷 1 +纸 1 +纹 1 +纺 1 +纽 1 +纾 1 +线 1 +绀 1 +练 1 +组 1 +绅 1 +细 1 +织 1 +终 1 +绊 1 +绍 1 +绎 1 +经 1 +绑 1 +绒 1 +结 1 +绔 1 +绕 1 +绘 1 +给 1 +绚 1 +绛 1 +络 1 +绝 1 +绞 1 +统 1 +绡 1 +绢 1 +绣 1 +绥 1 +绦 1 +继 1 +绩 1 +绪 1 +绫 1 +续 1 +绮 1 +绯 1 +绰 1 +绳 1 +维 1 +绵 1 +绶 1 +绷 1 +绸 1 +绻 1 +综 1 +绽 1 +绾 1 +绿 1 +缀 1 +缄 1 +缅 1 +缆 1 +缇 1 +缈 1 +缉 1 +缎 1 +缓 1 +缔 1 +缕 1 +编 1 +缘 1 +缙 1 +缚 1 +缜 1 +缝 1 +缠 1 +缢 1 +缤 1 +缥 1 +缨 1 +缩 1 +缪 1 +缭 1 +缮 1 +缰 1 +缱 1 +缴 1 +缸 1 +缺 1 +缽 1 +罂 1 +罄 1 +罌 1 +罐 1 +网 1 +罔 1 +罕 1 +罗 1 +罚 1 +罡 1 +罢 1 +罩 1 +罪 1 +置 1 +罰 1 +署 1 +罵 1 +罷 1 +罹 1 +羁 1 +羅 1 +羈 1 +羊 1 +羌 1 +美 1 +羔 1 +羚 1 +羞 1 +羟 1 +羡 1 +羣 1 +群 1 +羥 1 +羧 1 +羨 1 +義 1 +羯 1 +羲 1 +羸 1 +羹 1 +羽 1 +羿 1 +翁 1 +翅 1 +翊 1 +翌 1 +翎 1 +習 1 +翔 1 +翘 1 +翟 1 +翠 1 +翡 1 +翦 1 +翩 1 +翰 1 +翱 1 +翳 1 +翹 1 +翻 1 +翼 1 +耀 1 +老 1 +考 1 +耄 1 +者 1 +耆 1 +耋 1 +而 1 +耍 1 +耐 1 +耒 1 +耕 1 +耗 1 +耘 1 +耙 1 +耦 1 +耨 1 +耳 1 +耶 1 +耷 1 +耸 1 +耻 1 +耽 1 +耿 1 +聂 1 +聆 1 +聊 1 +聋 1 +职 1 +聒 1 +联 1 +聖 1 +聘 1 +聚 1 +聞 1 +聪 1 +聯 1 +聰 1 +聲 1 +聳 1 +聴 1 +聶 1 +職 1 +聽 1 +聾 1 +聿 1 +肃 1 +肄 1 +肅 1 +肆 1 +肇 1 +肉 1 +肋 1 +肌 1 +肏 1 +肓 1 +肖 1 +肘 1 +肚 1 +肛 1 +肝 1 +肠 1 +股 1 +肢 1 +肤 1 +肥 1 +肩 1 +肪 1 +肮 1 +肯 1 +肱 1 +育 1 +肴 1 +肺 1 +肽 1 +肾 1 +肿 1 +胀 1 +胁 1 +胃 1 +胄 1 +胆 1 +背 1 +胍 1 +胎 1 +胖 1 +胚 1 +胛 1 +胜 1 +胝 1 +胞 1 +胡 1 +胤 1 +胥 1 +胧 1 +胫 1 +胭 1 +胯 1 +胰 1 +胱 1 +胳 1 +胴 1 +胶 1 +胸 1 +胺 1 +能 1 +脂 1 +脅 1 +脆 1 +脇 1 +脈 1 +脉 1 +脊 1 +脍 1 +脏 1 +脐 1 +脑 1 +脓 1 +脖 1 +脘 1 +脚 1 +脛 1 +脣 1 +脩 1 +脫 1 +脯 1 +脱 1 +脲 1 +脳 1 +脸 1 +脹 1 +脾 1 +腆 1 +腈 1 +腊 1 +腋 1 +腌 1 +腎 1 +腐 1 +腑 1 +腓 1 +腔 1 +腕 1 +腥 1 +腦 1 +腩 1 +腫 1 +腭 1 +腮 1 +腰 1 +腱 1 +腳 1 +腴 1 +腸 1 +腹 1 +腺 1 +腻 1 +腼 1 +腾 1 +腿 1 +膀 1 +膈 1 +膊 1 +膏 1 +膑 1 +膘 1 +膚 1 +膛 1 +膜 1 +膝 1 +膠 1 +膦 1 +膨 1 +膩 1 +膳 1 +膺 1 +膻 1 +膽 1 +膾 1 +膿 1 +臀 1 +臂 1 +臃 1 +臆 1 +臉 1 +臊 1 +臍 1 +臓 1 +臘 1 +臟 1 +臣 1 +臥 1 +臧 1 +臨 1 +自 1 +臬 1 +臭 1 +至 1 +致 1 +臺 1 +臻 1 +臼 1 +臾 1 +舀 1 +舂 1 +舅 1 +舆 1 +與 1 +興 1 +舉 1 +舊 1 +舌 1 +舍 1 +舎 1 +舐 1 +舒 1 +舔 1 +舖 1 +舗 1 +舛 1 +舜 1 +舞 1 +舟 1 +航 1 +舫 1 +般 1 +舰 1 +舱 1 +舵 1 +舶 1 +舷 1 +舸 1 +船 1 +舺 1 +舾 1 +艇 1 +艋 1 +艘 1 +艙 1 +艦 1 +艮 1 +良 1 +艰 1 +艱 1 +色 1 +艳 1 +艷 1 +艹 1 +艺 1 +艾 1 +节 1 +芃 1 +芈 1 +芊 1 +芋 1 +芍 1 +芎 1 +芒 1 +芙 1 +芜 1 +芝 1 +芡 1 +芥 1 +芦 1 +芩 1 +芪 1 +芫 1 +芬 1 +芭 1 +芮 1 +芯 1 +花 1 +芳 1 +芷 1 +芸 1 +芹 1 +芻 1 +芽 1 +芾 1 +苁 1 +苄 1 +苇 1 +苋 1 +苍 1 +苏 1 +苑 1 +苒 1 +苓 1 +苔 1 +苕 1 +苗 1 +苛 1 +苜 1 +苞 1 +苟 1 +苡 1 +苣 1 +若 1 +苦 1 +苫 1 +苯 1 +英 1 +苷 1 +苹 1 +苻 1 +茁 1 +茂 1 +范 1 +茄 1 +茅 1 +茉 1 +茎 1 +茏 1 +茗 1 +茜 1 +茧 1 +茨 1 +茫 1 +茬 1 +茭 1 +茯 1 +茱 1 +茲 1 +茴 1 +茵 1 +茶 1 +茸 1 +茹 1 +茼 1 +荀 1 +荃 1 +荆 1 +草 1 +荊 1 +荏 1 +荐 1 +荒 1 +荔 1 +荖 1 +荘 1 +荚 1 +荞 1 +荟 1 +荠 1 +荡 1 +荣 1 +荤 1 +荥 1 +荧 1 +荨 1 +荪 1 +荫 1 +药 1 +荳 1 +荷 1 +荸 1 +荻 1 +荼 1 +荽 1 +莅 1 +莆 1 +莉 1 +莊 1 +莎 1 +莒 1 +莓 1 +莖 1 +莘 1 +莞 1 +莠 1 +莢 1 +莧 1 +莪 1 +莫 1 +莱 1 +莲 1 +莴 1 +获 1 +莹 1 +莺 1 +莽 1 +莿 1 +菀 1 +菁 1 +菅 1 +菇 1 +菈 1 +菊 1 +菌 1 +菏 1 +菓 1 +菖 1 +菘 1 +菜 1 +菟 1 +菠 1 +菡 1 +菩 1 +華 1 +菱 1 +菲 1 +菸 1 +菽 1 +萁 1 +萃 1 +萄 1 +萊 1 +萋 1 +萌 1 +萍 1 +萎 1 +萘 1 +萝 1 +萤 1 +营 1 +萦 1 +萧 1 +萨 1 +萩 1 +萬 1 +萱 1 +萵 1 +萸 1 +萼 1 +落 1 +葆 1 +葉 1 +著 1 +葚 1 +葛 1 +葡 1 +董 1 +葦 1 +葩 1 +葫 1 +葬 1 +葭 1 +葯 1 +葱 1 +葳 1 +葵 1 +葷 1 +葺 1 +蒂 1 +蒋 1 +蒐 1 +蒔 1 +蒙 1 +蒜 1 +蒞 1 +蒟 1 +蒡 1 +蒨 1 +蒲 1 +蒸 1 +蒹 1 +蒻 1 +蒼 1 +蒿 1 +蓁 1 +蓄 1 +蓆 1 +蓉 1 +蓋 1 +蓑 1 +蓓 1 +蓖 1 +蓝 1 +蓟 1 +蓦 1 +蓬 1 +蓮 1 +蓼 1 +蓿 1 +蔑 1 +蔓 1 +蔔 1 +蔗 1 +蔘 1 +蔚 1 +蔡 1 +蔣 1 +蔥 1 +蔫 1 +蔬 1 +蔭 1 +蔵 1 +蔷 1 +蔺 1 +蔻 1 +蔼 1 +蔽 1 +蕁 1 +蕃 1 +蕈 1 +蕉 1 +蕊 1 +蕎 1 +蕙 1 +蕤 1 +蕨 1 +蕩 1 +蕪 1 +蕭 1 +蕲 1 +蕴 1 +蕻 1 +蕾 1 +薄 1 +薅 1 +薇 1 +薈 1 +薊 1 +薏 1 +薑 1 +薔 1 +薙 1 +薛 1 +薦 1 +薨 1 +薩 1 +薪 1 +薬 1 +薯 1 +薰 1 +薹 1 +藉 1 +藍 1 +藏 1 +藐 1 +藓 1 +藕 1 +藜 1 +藝 1 +藤 1 +藥 1 +藩 1 +藹 1 +藻 1 +藿 1 +蘆 1 +蘇 1 +蘊 1 +蘋 1 +蘑 1 +蘚 1 +蘭 1 +蘸 1 +蘼 1 +蘿 1 +虎 1 +虏 1 +虐 1 +虑 1 +虔 1 +處 1 +虚 1 +虛 1 +虜 1 +虞 1 +號 1 +虢 1 +虧 1 +虫 1 +虬 1 +虱 1 +虹 1 +虻 1 +虽 1 +虾 1 +蚀 1 +蚁 1 +蚂 1 +蚊 1 +蚌 1 +蚓 1 +蚕 1 +蚜 1 +蚝 1 +蚣 1 +蚤 1 +蚩 1 +蚪 1 +蚯 1 +蚱 1 +蚵 1 +蛀 1 +蛆 1 +蛇 1 +蛊 1 +蛋 1 +蛎 1 +蛐 1 +蛔 1 +蛙 1 +蛛 1 +蛟 1 +蛤 1 +蛭 1 +蛮 1 +蛰 1 +蛳 1 +蛹 1 +蛻 1 +蛾 1 +蜀 1 +蜂 1 +蜃 1 +蜆 1 +蜇 1 +蜈 1 +蜊 1 +蜍 1 +蜒 1 +蜓 1 +蜕 1 +蜗 1 +蜘 1 +蜚 1 +蜜 1 +蜡 1 +蜢 1 +蜥 1 +蜱 1 +蜴 1 +蜷 1 +蜻 1 +蜿 1 +蝇 1 +蝈 1 +蝉 1 +蝌 1 +蝎 1 +蝕 1 +蝗 1 +蝙 1 +蝟 1 +蝠 1 +蝦 1 +蝨 1 +蝴 1 +蝶 1 +蝸 1 +蝼 1 +螂 1 +螃 1 +融 1 +螞 1 +螢 1 +螨 1 +螯 1 +螳 1 +螺 1 +蟀 1 +蟄 1 +蟆 1 +蟋 1 +蟎 1 +蟑 1 +蟒 1 +蟠 1 +蟬 1 +蟲 1 +蟹 1 +蟻 1 +蟾 1 +蠅 1 +蠍 1 +蠔 1 +蠕 1 +蠛 1 +蠟 1 +蠡 1 +蠢 1 +蠣 1 +蠱 1 +蠶 1 +蠹 1 +蠻 1 +血 1 +衄 1 +衅 1 +衆 1 +行 1 +衍 1 +術 1 +衔 1 +街 1 +衙 1 +衛 1 +衝 1 +衞 1 +衡 1 +衢 1 +衣 1 +补 1 +表 1 +衩 1 +衫 1 +衬 1 +衮 1 +衰 1 +衲 1 +衷 1 +衹 1 +衾 1 +衿 1 +袁 1 +袂 1 +袄 1 +袅 1 +袈 1 +袋 1 +袍 1 +袒 1 +袖 1 +袜 1 +袞 1 +袤 1 +袪 1 +被 1 +袭 1 +袱 1 +裁 1 +裂 1 +装 1 +裆 1 +裊 1 +裏 1 +裔 1 +裕 1 +裘 1 +裙 1 +補 1 +裝 1 +裟 1 +裡 1 +裤 1 +裨 1 +裱 1 +裳 1 +裴 1 +裸 1 +裹 1 +製 1 +裾 1 +褂 1 +複 1 +褐 1 +褒 1 +褓 1 +褔 1 +褚 1 +褥 1 +褪 1 +褫 1 +褲 1 +褶 1 +褻 1 +襁 1 +襄 1 +襟 1 +襠 1 +襪 1 +襬 1 +襯 1 +襲 1 +西 1 +要 1 +覃 1 +覆 1 +覇 1 +見 1 +規 1 +覓 1 +視 1 +覚 1 +覦 1 +覧 1 +親 1 +覬 1 +観 1 +覷 1 +覺 1 +覽 1 +觀 1 +见 1 +观 1 +规 1 +觅 1 +视 1 +览 1 +觉 1 +觊 1 +觎 1 +觐 1 +觑 1 +角 1 +觞 1 +解 1 +觥 1 +触 1 +觸 1 +言 1 +訂 1 +計 1 +訊 1 +討 1 +訓 1 +訕 1 +訖 1 +託 1 +記 1 +訛 1 +訝 1 +訟 1 +訣 1 +訥 1 +訪 1 +設 1 +許 1 +訳 1 +訴 1 +訶 1 +診 1 +註 1 +証 1 +詆 1 +詐 1 +詔 1 +評 1 +詛 1 +詞 1 +詠 1 +詡 1 +詢 1 +詣 1 +試 1 +詩 1 +詫 1 +詬 1 +詭 1 +詮 1 +詰 1 +話 1 +該 1 +詳 1 +詹 1 +詼 1 +誅 1 +誇 1 +誉 1 +誌 1 +認 1 +誓 1 +誕 1 +誘 1 +語 1 +誠 1 +誡 1 +誣 1 +誤 1 +誥 1 +誦 1 +誨 1 +說 1 +説 1 +読 1 +誰 1 +課 1 +誹 1 +誼 1 +調 1 +諄 1 +談 1 +請 1 +諏 1 +諒 1 +論 1 +諗 1 +諜 1 +諡 1 +諦 1 +諧 1 +諫 1 +諭 1 +諮 1 +諱 1 +諳 1 +諷 1 +諸 1 +諺 1 +諾 1 +謀 1 +謁 1 +謂 1 +謄 1 +謊 1 +謎 1 +謐 1 +謔 1 +謗 1 +謙 1 +講 1 +謝 1 +謠 1 +謨 1 +謬 1 +謹 1 +謾 1 +譁 1 +證 1 +譎 1 +譏 1 +識 1 +譙 1 +譚 1 +譜 1 +警 1 +譬 1 +譯 1 +議 1 +譲 1 +譴 1 +護 1 +譽 1 +讀 1 +變 1 +讓 1 +讚 1 +讞 1 +计 1 +订 1 +认 1 +讥 1 +讧 1 +讨 1 +让 1 +讪 1 +讫 1 +训 1 +议 1 +讯 1 +记 1 +讲 1 +讳 1 +讴 1 +讶 1 +讷 1 +许 1 +讹 1 +论 1 +讼 1 +讽 1 +设 1 +访 1 +诀 1 +证 1 +诃 1 +评 1 +诅 1 +识 1 +诈 1 +诉 1 +诊 1 +诋 1 +词 1 +诏 1 +译 1 +试 1 +诗 1 +诘 1 +诙 1 +诚 1 +诛 1 +话 1 +诞 1 +诟 1 +诠 1 +诡 1 +询 1 +诣 1 +诤 1 +该 1 +详 1 +诧 1 +诩 1 +诫 1 +诬 1 +语 1 +误 1 +诰 1 +诱 1 +诲 1 +说 1 +诵 1 +诶 1 +请 1 +诸 1 +诺 1 +读 1 +诽 1 +课 1 +诿 1 +谀 1 +谁 1 +调 1 +谄 1 +谅 1 +谆 1 +谈 1 +谊 1 +谋 1 +谌 1 +谍 1 +谎 1 +谏 1 +谐 1 +谑 1 +谒 1 +谓 1 +谔 1 +谕 1 +谗 1 +谘 1 +谙 1 +谚 1 +谛 1 +谜 1 +谟 1 +谢 1 +谣 1 +谤 1 +谥 1 +谦 1 +谧 1 +谨 1 +谩 1 +谪 1 +谬 1 +谭 1 +谯 1 +谱 1 +谲 1 +谴 1 +谶 1 +谷 1 +豁 1 +豆 1 +豇 1 +豈 1 +豉 1 +豊 1 +豌 1 +豎 1 +豐 1 +豔 1 +豚 1 +象 1 +豢 1 +豪 1 +豫 1 +豬 1 +豹 1 +豺 1 +貂 1 +貅 1 +貌 1 +貓 1 +貔 1 +貘 1 +貝 1 +貞 1 +負 1 +財 1 +貢 1 +貧 1 +貨 1 +販 1 +貪 1 +貫 1 +責 1 +貯 1 +貰 1 +貳 1 +貴 1 +貶 1 +買 1 +貸 1 +費 1 +貼 1 +貽 1 +貿 1 +賀 1 +賁 1 +賂 1 +賃 1 +賄 1 +資 1 +賈 1 +賊 1 +賑 1 +賓 1 +賜 1 +賞 1 +賠 1 +賡 1 +賢 1 +賣 1 +賤 1 +賦 1 +質 1 +賬 1 +賭 1 +賴 1 +賺 1 +購 1 +賽 1 +贅 1 +贈 1 +贊 1 +贍 1 +贏 1 +贓 1 +贖 1 +贛 1 +贝 1 +贞 1 +负 1 +贡 1 +财 1 +责 1 +贤 1 +败 1 +账 1 +货 1 +质 1 +贩 1 +贪 1 +贫 1 +贬 1 +购 1 +贮 1 +贯 1 +贰 1 +贱 1 +贲 1 +贴 1 +贵 1 +贷 1 +贸 1 +费 1 +贺 1 +贻 1 +贼 1 +贾 1 +贿 1 +赁 1 +赂 1 +赃 1 +资 1 +赅 1 +赈 1 +赊 1 +赋 1 +赌 1 +赎 1 +赏 1 +赐 1 +赓 1 +赔 1 +赖 1 +赘 1 +赚 1 +赛 1 +赝 1 +赞 1 +赠 1 +赡 1 +赢 1 +赣 1 +赤 1 +赦 1 +赧 1 +赫 1 +赭 1 +走 1 +赳 1 +赴 1 +赵 1 +赶 1 +起 1 +趁 1 +超 1 +越 1 +趋 1 +趕 1 +趙 1 +趟 1 +趣 1 +趨 1 +足 1 +趴 1 +趵 1 +趸 1 +趺 1 +趾 1 +跃 1 +跄 1 +跆 1 +跋 1 +跌 1 +跎 1 +跑 1 +跖 1 +跚 1 +跛 1 +距 1 +跟 1 +跡 1 +跤 1 +跨 1 +跩 1 +跪 1 +路 1 +跳 1 +践 1 +跷 1 +跹 1 +跺 1 +跻 1 +踉 1 +踊 1 +踌 1 +踏 1 +踐 1 +踝 1 +踞 1 +踟 1 +踢 1 +踩 1 +踪 1 +踮 1 +踱 1 +踴 1 +踵 1 +踹 1 +蹂 1 +蹄 1 +蹇 1 +蹈 1 +蹉 1 +蹊 1 +蹋 1 +蹑 1 +蹒 1 +蹙 1 +蹟 1 +蹣 1 +蹤 1 +蹦 1 +蹩 1 +蹬 1 +蹭 1 +蹲 1 +蹴 1 +蹶 1 +蹺 1 +蹼 1 +蹿 1 +躁 1 +躇 1 +躉 1 +躊 1 +躋 1 +躍 1 +躏 1 +躪 1 +身 1 +躬 1 +躯 1 +躲 1 +躺 1 +軀 1 +車 1 +軋 1 +軌 1 +軍 1 +軒 1 +軟 1 +転 1 +軸 1 +軼 1 +軽 1 +軾 1 +較 1 +載 1 +輒 1 +輓 1 +輔 1 +輕 1 +輛 1 +輝 1 +輟 1 +輩 1 +輪 1 +輯 1 +輸 1 +輻 1 +輾 1 +輿 1 +轄 1 +轅 1 +轆 1 +轉 1 +轍 1 +轎 1 +轟 1 +车 1 +轧 1 +轨 1 +轩 1 +转 1 +轭 1 +轮 1 +软 1 +轰 1 +轲 1 +轴 1 +轶 1 +轻 1 +轼 1 +载 1 +轿 1 +较 1 +辄 1 +辅 1 +辆 1 +辇 1 +辈 1 +辉 1 +辊 1 +辍 1 +辐 1 +辑 1 +输 1 +辕 1 +辖 1 +辗 1 +辘 1 +辙 1 +辛 1 +辜 1 +辞 1 +辟 1 +辣 1 +辦 1 +辨 1 +辩 1 +辫 1 +辭 1 +辮 1 +辯 1 +辰 1 +辱 1 +農 1 +边 1 +辺 1 +辻 1 +込 1 +辽 1 +达 1 +迁 1 +迂 1 +迄 1 +迅 1 +过 1 +迈 1 +迎 1 +运 1 +近 1 +返 1 +还 1 +这 1 +进 1 +远 1 +违 1 +连 1 +迟 1 +迢 1 +迤 1 +迥 1 +迦 1 +迩 1 +迪 1 +迫 1 +迭 1 +述 1 +迴 1 +迷 1 +迸 1 +迹 1 +迺 1 +追 1 +退 1 +送 1 +适 1 +逃 1 +逅 1 +逆 1 +选 1 +逊 1 +逍 1 +透 1 +逐 1 +递 1 +途 1 +逕 1 +逗 1 +這 1 +通 1 +逛 1 +逝 1 +逞 1 +速 1 +造 1 +逢 1 +連 1 +逮 1 +週 1 +進 1 +逵 1 +逶 1 +逸 1 +逻 1 +逼 1 +逾 1 +遁 1 +遂 1 +遅 1 +遇 1 +遊 1 +運 1 +遍 1 +過 1 +遏 1 +遐 1 +遑 1 +遒 1 +道 1 +達 1 +違 1 +遗 1 +遙 1 +遛 1 +遜 1 +遞 1 +遠 1 +遢 1 +遣 1 +遥 1 +遨 1 +適 1 +遭 1 +遮 1 +遲 1 +遴 1 +遵 1 +遶 1 +遷 1 +選 1 +遺 1 +遼 1 +遽 1 +避 1 +邀 1 +邁 1 +邂 1 +邃 1 +還 1 +邇 1 +邈 1 +邊 1 +邋 1 +邏 1 +邑 1 +邓 1 +邕 1 +邛 1 +邝 1 +邢 1 +那 1 +邦 1 +邨 1 +邪 1 +邬 1 +邮 1 +邯 1 +邰 1 +邱 1 +邳 1 +邵 1 +邸 1 +邹 1 +邺 1 +邻 1 +郁 1 +郅 1 +郊 1 +郎 1 +郑 1 +郜 1 +郝 1 +郡 1 +郢 1 +郤 1 +郦 1 +郧 1 +部 1 +郫 1 +郭 1 +郴 1 +郵 1 +郷 1 +郸 1 +都 1 +鄂 1 +鄉 1 +鄒 1 +鄔 1 +鄙 1 +鄞 1 +鄢 1 +鄧 1 +鄭 1 +鄰 1 +鄱 1 +鄲 1 +鄺 1 +酉 1 +酊 1 +酋 1 +酌 1 +配 1 +酐 1 +酒 1 +酗 1 +酚 1 +酝 1 +酢 1 +酣 1 +酥 1 +酩 1 +酪 1 +酬 1 +酮 1 +酯 1 +酰 1 +酱 1 +酵 1 +酶 1 +酷 1 +酸 1 +酿 1 +醃 1 +醇 1 +醉 1 +醋 1 +醍 1 +醐 1 +醒 1 +醚 1 +醛 1 +醜 1 +醞 1 +醣 1 +醪 1 +醫 1 +醬 1 +醮 1 +醯 1 +醴 1 +醺 1 +釀 1 +釁 1 +采 1 +釉 1 +释 1 +釋 1 +里 1 +重 1 +野 1 +量 1 +釐 1 +金 1 +釗 1 +釘 1 +釜 1 +針 1 +釣 1 +釦 1 +釧 1 +釵 1 +鈀 1 +鈉 1 +鈍 1 +鈎 1 +鈔 1 +鈕 1 +鈞 1 +鈣 1 +鈦 1 +鈪 1 +鈴 1 +鈺 1 +鈾 1 +鉀 1 +鉄 1 +鉅 1 +鉉 1 +鉑 1 +鉗 1 +鉚 1 +鉛 1 +鉤 1 +鉴 1 +鉻 1 +銀 1 +銃 1 +銅 1 +銑 1 +銓 1 +銖 1 +銘 1 +銜 1 +銬 1 +銭 1 +銮 1 +銳 1 +銷 1 +銹 1 +鋁 1 +鋅 1 +鋒 1 +鋤 1 +鋪 1 +鋰 1 +鋸 1 +鋼 1 +錄 1 +錐 1 +錘 1 +錚 1 +錠 1 +錢 1 +錦 1 +錨 1 +錫 1 +錮 1 +錯 1 +録 1 +錳 1 +錶 1 +鍊 1 +鍋 1 +鍍 1 +鍛 1 +鍥 1 +鍰 1 +鍵 1 +鍺 1 +鍾 1 +鎂 1 +鎊 1 +鎌 1 +鎏 1 +鎔 1 +鎖 1 +鎗 1 +鎚 1 +鎧 1 +鎬 1 +鎮 1 +鎳 1 +鏈 1 +鏖 1 +鏗 1 +鏘 1 +鏞 1 +鏟 1 +鏡 1 +鏢 1 +鏤 1 +鏽 1 +鐘 1 +鐮 1 +鐲 1 +鐳 1 +鐵 1 +鐸 1 +鐺 1 +鑄 1 +鑊 1 +鑑 1 +鑒 1 +鑣 1 +鑫 1 +鑰 1 +鑲 1 +鑼 1 +鑽 1 +鑾 1 +鑿 1 +针 1 +钉 1 +钊 1 +钎 1 +钏 1 +钒 1 +钓 1 +钗 1 +钙 1 +钛 1 +钜 1 +钝 1 +钞 1 +钟 1 +钠 1 +钡 1 +钢 1 +钣 1 +钤 1 +钥 1 +钦 1 +钧 1 +钨 1 +钩 1 +钮 1 +钯 1 +钰 1 +钱 1 +钳 1 +钴 1 +钵 1 +钺 1 +钻 1 +钼 1 +钾 1 +钿 1 +铀 1 +铁 1 +铂 1 +铃 1 +铄 1 +铅 1 +铆 1 +铉 1 +铎 1 +铐 1 +铛 1 +铜 1 +铝 1 +铠 1 +铡 1 +铢 1 +铣 1 +铤 1 +铨 1 +铩 1 +铬 1 +铭 1 +铮 1 +铰 1 +铲 1 +铵 1 +银 1 +铸 1 +铺 1 +链 1 +铿 1 +销 1 +锁 1 +锂 1 +锄 1 +锅 1 +锆 1 +锈 1 +锉 1 +锋 1 +锌 1 +锏 1 +锐 1 +锑 1 +错 1 +锚 1 +锟 1 +锡 1 +锢 1 +锣 1 +锤 1 +锥 1 +锦 1 +锭 1 +键 1 +锯 1 +锰 1 +锲 1 +锵 1 +锹 1 +锺 1 +锻 1 +镀 1 +镁 1 +镂 1 +镇 1 +镉 1 +镌 1 +镍 1 +镐 1 +镑 1 +镕 1 +镖 1 +镗 1 +镛 1 +镜 1 +镣 1 +镭 1 +镯 1 +镰 1 +镳 1 +镶 1 +長 1 +长 1 +門 1 +閃 1 +閉 1 +開 1 +閎 1 +閏 1 +閑 1 +閒 1 +間 1 +閔 1 +閘 1 +閡 1 +関 1 +閣 1 +閥 1 +閨 1 +閩 1 +閱 1 +閲 1 +閹 1 +閻 1 +閾 1 +闆 1 +闇 1 +闊 1 +闌 1 +闍 1 +闔 1 +闕 1 +闖 1 +闘 1 +關 1 +闡 1 +闢 1 +门 1 +闪 1 +闫 1 +闭 1 +问 1 +闯 1 +闰 1 +闲 1 +间 1 +闵 1 +闷 1 +闸 1 +闹 1 +闺 1 +闻 1 +闽 1 +闾 1 +阀 1 +阁 1 +阂 1 +阅 1 +阆 1 +阇 1 +阈 1 +阉 1 +阎 1 +阐 1 +阑 1 +阔 1 +阕 1 +阖 1 +阙 1 +阚 1 +阜 1 +队 1 +阡 1 +阪 1 +阮 1 +阱 1 +防 1 +阳 1 +阴 1 +阵 1 +阶 1 +阻 1 +阿 1 +陀 1 +陂 1 +附 1 +际 1 +陆 1 +陇 1 +陈 1 +陋 1 +陌 1 +降 1 +限 1 +陕 1 +陛 1 +陝 1 +陞 1 +陟 1 +陡 1 +院 1 +陣 1 +除 1 +陨 1 +险 1 +陪 1 +陰 1 +陲 1 +陳 1 +陵 1 +陶 1 +陷 1 +陸 1 +険 1 +陽 1 +隅 1 +隆 1 +隈 1 +隊 1 +隋 1 +隍 1 +階 1 +随 1 +隐 1 +隔 1 +隕 1 +隘 1 +隙 1 +際 1 +障 1 +隠 1 +隣 1 +隧 1 +隨 1 +險 1 +隱 1 +隴 1 +隶 1 +隸 1 +隻 1 +隼 1 +隽 1 +难 1 +雀 1 +雁 1 +雄 1 +雅 1 +集 1 +雇 1 +雉 1 +雋 1 +雌 1 +雍 1 +雎 1 +雏 1 +雑 1 +雒 1 +雕 1 +雖 1 +雙 1 +雛 1 +雜 1 +雞 1 +離 1 +難 1 +雨 1 +雪 1 +雯 1 +雰 1 +雲 1 +雳 1 +零 1 +雷 1 +雹 1 +電 1 +雾 1 +需 1 +霁 1 +霄 1 +霆 1 +震 1 +霈 1 +霉 1 +霊 1 +霍 1 +霎 1 +霏 1 +霑 1 +霓 1 +霖 1 +霜 1 +霞 1 +霧 1 +霭 1 +霰 1 +露 1 +霸 1 +霹 1 +霽 1 +霾 1 +靂 1 +靄 1 +靈 1 +青 1 +靓 1 +靖 1 +静 1 +靚 1 +靛 1 +靜 1 +非 1 +靠 1 +靡 1 +面 1 +靥 1 +靦 1 +革 1 +靳 1 +靴 1 +靶 1 +靼 1 +鞅 1 +鞋 1 +鞍 1 +鞏 1 +鞑 1 +鞘 1 +鞠 1 +鞣 1 +鞦 1 +鞭 1 +韆 1 +韋 1 +韌 1 +韓 1 +韜 1 +韦 1 +韧 1 +韩 1 +韬 1 +韭 1 +音 1 +韵 1 +韶 1 +韻 1 +響 1 +頁 1 +頂 1 +頃 1 +項 1 +順 1 +須 1 +頌 1 +預 1 +頑 1 +頒 1 +頓 1 +頗 1 +領 1 +頜 1 +頡 1 +頤 1 +頫 1 +頭 1 +頰 1 +頷 1 +頸 1 +頹 1 +頻 1 +頼 1 +顆 1 +題 1 +額 1 +顎 1 +顏 1 +顔 1 +願 1 +顛 1 +類 1 +顧 1 +顫 1 +顯 1 +顱 1 +顴 1 +页 1 +顶 1 +顷 1 +项 1 +顺 1 +须 1 +顼 1 +顽 1 +顾 1 +顿 1 +颁 1 +颂 1 +预 1 +颅 1 +领 1 +颇 1 +颈 1 +颉 1 +颊 1 +颌 1 +颍 1 +颐 1 +频 1 +颓 1 +颔 1 +颖 1 +颗 1 +题 1 +颚 1 +颛 1 +颜 1 +额 1 +颞 1 +颠 1 +颡 1 +颢 1 +颤 1 +颦 1 +颧 1 +風 1 +颯 1 +颱 1 +颳 1 +颶 1 +颼 1 +飄 1 +飆 1 +风 1 +飒 1 +飓 1 +飕 1 +飘 1 +飙 1 +飚 1 +飛 1 +飞 1 +食 1 +飢 1 +飨 1 +飩 1 +飪 1 +飯 1 +飲 1 +飼 1 +飽 1 +飾 1 +餃 1 +餅 1 +餉 1 +養 1 +餌 1 +餐 1 +餒 1 +餓 1 +餘 1 +餚 1 +餛 1 +餞 1 +餡 1 +館 1 +餮 1 +餵 1 +餾 1 +饅 1 +饈 1 +饋 1 +饌 1 +饍 1 +饑 1 +饒 1 +饕 1 +饗 1 +饞 1 +饥 1 +饨 1 +饪 1 +饬 1 +饭 1 +饮 1 +饯 1 +饰 1 +饱 1 +饲 1 +饴 1 +饵 1 +饶 1 +饷 1 +饺 1 +饼 1 +饽 1 +饿 1 +馀 1 +馁 1 +馄 1 +馅 1 +馆 1 +馈 1 +馋 1 +馍 1 +馏 1 +馒 1 +馔 1 +首 1 +馗 1 +香 1 +馥 1 +馨 1 +馬 1 +馭 1 +馮 1 +馳 1 +馴 1 +駁 1 +駄 1 +駅 1 +駆 1 +駐 1 +駒 1 +駕 1 +駛 1 +駝 1 +駭 1 +駱 1 +駿 1 +騁 1 +騎 1 +騏 1 +験 1 +騙 1 +騨 1 +騰 1 +騷 1 +驀 1 +驅 1 +驊 1 +驍 1 +驒 1 +驕 1 +驗 1 +驚 1 +驛 1 +驟 1 +驢 1 +驥 1 +马 1 +驭 1 +驮 1 +驯 1 +驰 1 +驱 1 +驳 1 +驴 1 +驶 1 +驷 1 +驸 1 +驹 1 +驻 1 +驼 1 +驾 1 +驿 1 +骁 1 +骂 1 +骄 1 +骅 1 +骆 1 +骇 1 +骈 1 +骊 1 +骋 1 +验 1 +骏 1 +骐 1 +骑 1 +骗 1 +骚 1 +骛 1 +骜 1 +骞 1 +骠 1 +骡 1 +骤 1 +骥 1 +骧 1 +骨 1 +骯 1 +骰 1 +骶 1 +骷 1 +骸 1 +骼 1 +髂 1 +髅 1 +髋 1 +髏 1 +髒 1 +髓 1 +體 1 +髖 1 +高 1 +髦 1 +髪 1 +髮 1 +髯 1 +髻 1 +鬃 1 +鬆 1 +鬍 1 +鬓 1 +鬚 1 +鬟 1 +鬢 1 +鬣 1 +鬥 1 +鬧 1 +鬱 1 +鬼 1 +魁 1 +魂 1 +魄 1 +魅 1 +魇 1 +魍 1 +魏 1 +魔 1 +魘 1 +魚 1 +魯 1 +魷 1 +鮑 1 +鮨 1 +鮪 1 +鮭 1 +鮮 1 +鯉 1 +鯊 1 +鯖 1 +鯛 1 +鯨 1 +鯰 1 +鯽 1 +鰍 1 +鰓 1 +鰭 1 +鰲 1 +鰻 1 +鰾 1 +鱈 1 +鱉 1 +鱔 1 +鱗 1 +鱷 1 +鱸 1 +鱼 1 +鱿 1 +鲁 1 +鲈 1 +鲍 1 +鲑 1 +鲛 1 +鲜 1 +鲟 1 +鲢 1 +鲤 1 +鲨 1 +鲫 1 +鲱 1 +鲲 1 +鲶 1 +鲷 1 +鲸 1 +鳃 1 +鳄 1 +鳅 1 +鳌 1 +鳍 1 +鳕 1 +鳖 1 +鳗 1 +鳝 1 +鳞 1 +鳥 1 +鳩 1 +鳳 1 +鳴 1 +鳶 1 +鴉 1 +鴕 1 +鴛 1 +鴦 1 +鴨 1 +鴻 1 +鴿 1 +鵑 1 +鵜 1 +鵝 1 +鵡 1 +鵬 1 +鵰 1 +鵲 1 +鶘 1 +鶩 1 +鶯 1 +鶴 1 +鷗 1 +鷲 1 +鷹 1 +鷺 1 +鸚 1 +鸞 1 +鸟 1 +鸠 1 +鸡 1 +鸢 1 +鸣 1 +鸥 1 +鸦 1 +鸨 1 +鸪 1 +鸭 1 +鸯 1 +鸳 1 +鸵 1 +鸽 1 +鸾 1 +鸿 1 +鹂 1 +鹃 1 +鹄 1 +鹅 1 +鹈 1 +鹉 1 +鹊 1 +鹌 1 +鹏 1 +鹑 1 +鹕 1 +鹘 1 +鹜 1 +鹞 1 +鹤 1 +鹦 1 +鹧 1 +鹫 1 +鹭 1 +鹰 1 +鹳 1 +鹵 1 +鹹 1 +鹼 1 +鹽 1 +鹿 1 +麂 1 +麋 1 +麒 1 +麓 1 +麗 1 +麝 1 +麟 1 +麥 1 +麦 1 +麩 1 +麴 1 +麵 1 +麸 1 +麺 1 +麻 1 +麼 1 +麽 1 +麾 1 +黃 1 +黄 1 +黍 1 +黎 1 +黏 1 +黑 1 +黒 1 +黔 1 +默 1 +黛 1 +黜 1 +黝 1 +點 1 +黠 1 +黨 1 +黯 1 +黴 1 +鼋 1 +鼎 1 +鼐 1 +鼓 1 +鼠 1 +鼬 1 +鼹 1 +鼻 1 +鼾 1 +齁 1 +齊 1 +齋 1 +齐 1 +齒 1 +齡 1 +齢 1 +齣 1 +齦 1 +齿 1 +龄 1 +龅 1 +龈 1 +龊 1 +龋 1 +龌 1 +龍 1 +龐 1 +龔 1 +龕 1 +龙 1 +龚 1 +龛 1 +龜 1 +龟 1 +︰ 1 +︱ 1 +︶ 1 +︿ 1 +﹁ 1 +﹂ 1 +﹍ 1 +﹏ 1 +﹐ 1 +﹑ 1 +﹒ 1 +﹔ 1 +﹕ 1 +﹖ 1 +﹗ 1 +﹙ 1 +﹚ 1 +﹝ 1 +﹞ 1 +﹡ 1 +﹣ 1 +！ 1 +＂ 1 +＃ 1 +＄ 1 +％ 1 +＆ 1 +＇ 1 +（ 1 +） 1 +＊ 1 +＋ 1 +， 1 +－ 1 +． 1 +／ 1 +０ 1 +１ 1 +２ 1 +３ 1 +４ 1 +５ 1 +６ 1 +７ 1 +８ 1 +９ 1 +： 1 +； 1 +＜ 1 +＝ 1 +＞ 1 +？ 1 +＠ 1 +［ 1 +＼ 1 +］ 1 +＾ 1 +＿ 1 +｀ 1 +ａ 1 +ｂ 1 +ｃ 1 +ｄ 1 +ｅ 1 +ｆ 1 +ｇ 1 +ｈ 1 +ｉ 1 +ｊ 1 +ｋ 1 +ｌ 1 +ｍ 1 +ｎ 1 +ｏ 1 +ｐ 1 +ｑ 1 +ｒ 1 +ｓ 1 +ｔ 1 +ｕ 1 +ｖ 1 +ｗ 1 +ｘ 1 +ｙ 1 +ｚ 1 +｛ 1 +｜ 1 +｝ 1 +～ 1 +｡ 1 +｢ 1 +｣ 1 +､ 1 +･ 1 +ｯ 1 +ｰ 1 +ｲ 1 +ｸ 1 +ｼ 1 +ｽ 1 +ﾄ 1 +ﾉ 1 +ﾌ 1 +ﾗ 1 +ﾙ 1 +ﾝ 1 +ﾞ 1 +ﾟ 1 +￣ 1 +￥ 1 +👍 1 +🔥 1 +😂 1 +😎 1 +... 1 +yam 1 +10 1 +2017 1 +12 1 +11 1 +2016 1 +20 1 +30 1 +15 1 +06 1 +lofter 1 +##s 1 +2015 1 +by 1 +16 1 +14 1 +18 1 +13 1 +24 1 +17 1 +2014 1 +21 1 +##0 1 +22 1 +19 1 +25 1 +23 1 +com 1 +100 1 +00 1 +05 1 +2013 1 +##a 1 +03 1 +09 1 +08 1 +28 1 +##2 1 +50 1 +01 1 +04 1 +##1 1 +27 1 +02 1 +2012 1 +##3 1 +26 1 +##e 1 +07 1 +##8 1 +##5 1 +##6 1 +##4 1 +##9 1 +##7 1 +29 1 +2011 1 +40 1 +##t 1 +2010 1 +##o 1 +##d 1 +##i 1 +2009 1 +##n 1 +app 1 +www 1 +the 1 +##m 1 +31 1 +##c 1 +##l 1 +##y 1 +##r 1 +##g 1 +2008 1 +60 1 +http 1 +200 1 +qq 1 +##p 1 +80 1 +##f 1 +google 1 +pixnet 1 +90 1 +cookies 1 +tripadvisor 1 +500 1 +##er 1 +##k 1 +35 1 +##h 1 +facebook 1 +2007 1 +2000 1 +70 1 +##b 1 +of 1 +##x 1 +##u 1 +45 1 +300 1 +iphone 1 +32 1 +1000 1 +2006 1 +48 1 +ip 1 +36 1 +in 1 +38 1 +3d 1 +##w 1 +##ing 1 +55 1 +ctrip 1 +##on 1 +##v 1 +33 1 +##の 1 +to 1 +34 1 +400 1 +id 1 +2005 1 +it 1 +37 1 +windows 1 +llc 1 +top 1 +99 1 +42 1 +39 1 +000 1 +led 1 +at 1 +##an 1 +41 1 +51 1 +52 1 +46 1 +49 1 +43 1 +53 1 +44 1 +##z 1 +android 1 +58 1 +and 1 +59 1 +2004 1 +56 1 +vr 1 +##か 1 +5000 1 +2003 1 +47 1 +blogthis 1 +twitter 1 +54 1 +##le 1 +150 1 +ok 1 +2018 1 +57 1 +75 1 +cn 1 +no 1 +ios 1 +##in 1 +##mm 1 +##00 1 +800 1 +on 1 +te 1 +3000 1 +65 1 +2001 1 +360 1 +95 1 +ig 1 +lv 1 +120 1 +##ng 1 +##を 1 +##us 1 +##に 1 +pc 1 +てす 1 +── 1 +600 1 +##te 1 +85 1 +2002 1 +88 1 +##ed 1 +html 1 +ncc 1 +wifi 1 +email 1 +64 1 +blog 1 +is 1 +##10 1 +##て 1 +mail 1 +online 1 +##al 1 +dvd 1 +##ic 1 +studio 1 +##は 1 +##℃ 1 +##ia 1 +##と 1 +line 1 +vip 1 +72 1 +##q 1 +98 1 +##ce 1 +##en 1 +for 1 +##is 1 +##ra 1 +##es 1 +##j 1 +usb 1 +net 1 +cp 1 +1999 1 +asia 1 +4g 1 +##cm 1 +diy 1 +new 1 +3c 1 +##お 1 +ta 1 +66 1 +language 1 +vs 1 +apple 1 +tw 1 +86 1 +web 1 +##ne 1 +ipad 1 +62 1 +you 1 +##re 1 +101 1 +68 1 +##tion 1 +ps 1 +de 1 +bt 1 +pony 1 +atm 1 +##2017 1 +1998 1 +67 1 +##ch 1 +ceo 1 +##or 1 +go 1 +##na 1 +av 1 +pro 1 +cafe 1 +96 1 +pinterest 1 +97 1 +63 1 +pixstyleme3c 1 +##ta 1 +more 1 +said 1 +##2016 1 +1997 1 +mp3 1 +700 1 +##ll 1 +nba 1 +jun 1 +##20 1 +92 1 +tv 1 +1995 1 +pm 1 +61 1 +76 1 +nbsp 1 +250 1 +##ie 1 +linux 1 +##ma 1 +cd 1 +110 1 +hd 1 +##17 1 +78 1 +##ion 1 +77 1 +6000 1 +am 1 +##th 1 +##st 1 +94 1 +##se 1 +##et 1 +69 1 +180 1 +gdp 1 +my 1 +105 1 +81 1 +abc 1 +89 1 +flash 1 +79 1 +one 1 +93 1 +1990 1 +1996 1 +##ck 1 +gps 1 +##も 1 +##ly 1 +web885 1 +106 1 +2020 1 +91 1 +##ge 1 +4000 1 +1500 1 +xd 1 +boss 1 +isbn 1 +1994 1 +org 1 +##ry 1 +me 1 +love 1 +##11 1 +0fork 1 +73 1 +##12 1 +3g 1 +##ter 1 +##ar 1 +71 1 +82 1 +##la 1 +hotel 1 +130 1 +1970 1 +pk 1 +83 1 +87 1 +140 1 +ie 1 +##os 1 +##30 1 +##el 1 +74 1 +##50 1 +seo 1 +cpu 1 +##ml 1 +p2p 1 +84 1 +may 1 +##る 1 +sun 1 +tue 1 +internet 1 +cc 1 +posted 1 +youtube 1 +##at 1 +##ン 1 +##man 1 +ii 1 +##ル 1 +##15 1 +abs 1 +nt 1 +pdf 1 +yahoo 1 +ago 1 +1980 1 +##it 1 +news 1 +mac 1 +104 1 +##てす 1 +##me 1 +##り 1 +java 1 +1992 1 +spa 1 +##de 1 +##nt 1 +hk 1 +all 1 +plus 1 +la 1 +1993 1 +##mb 1 +##16 1 +##ve 1 +west 1 +##da 1 +160 1 +air 1 +##い 1 +##ps 1 +から 1 +##to 1 +1989 1 +logo 1 +htc 1 +php 1 +https 1 +fi 1 +momo 1 +##son 1 +sat 1 +##ke 1 +##80 1 +ebd 1 +suv 1 +wi 1 +day 1 +apk 1 +##88 1 +##um 1 +mv 1 +galaxy 1 +wiki 1 +or 1 +brake 1 +##ス 1 +1200 1 +する 1 +this 1 +1991 1 +mon 1 +##こ 1 +❤2017 1 +po 1 +##ない 1 +javascript 1 +life 1 +home 1 +june 1 +##ss 1 +system 1 +900 1 +##ー 1 +##０ 1 +pp 1 +1988 1 +world 1 +fb 1 +4k 1 +br 1 +##as 1 +ic 1 +ai 1 +leonardo 1 +safari 1 +##60 1 +live 1 +free 1 +xx 1 +wed 1 +win7 1 +kiehl 1 +##co 1 +lg 1 +o2o 1 +##go 1 +us 1 +235 1 +1949 1 +mm 1 +しい 1 +vfm 1 +kanye 1 +##90 1 +##2015 1 +##id 1 +jr 1 +##ey 1 +123 1 +rss 1 +##sa 1 +##ro 1 +##am 1 +##no 1 +thu 1 +fri 1 +350 1 +##sh 1 +##ki 1 +103 1 +comments 1 +name 1 +##のて 1 +##pe 1 +##ine 1 +max 1 +1987 1 +8000 1 +uber 1 +##mi 1 +##ton 1 +wordpress 1 +office 1 +1986 1 +1985 1 +##ment 1 +107 1 +bd 1 +win10 1 +##ld 1 +##li 1 +gmail 1 +bb 1 +dior 1 +##rs 1 +##ri 1 +##rd 1 +##ます 1 +up 1 +cad 1 +##® 1 +dr 1 +して 1 +read 1 +##21 1 +をお 1 +##io 1 +##99 1 +url 1 +1984 1 +pvc 1 +paypal 1 +show 1 +policy 1 +##40 1 +##ty 1 +##18 1 +with 1 +##★ 1 +##01 1 +txt 1 +102 1 +##ba 1 +dna 1 +from 1 +post 1 +mini 1 +ar 1 +taiwan 1 +john 1 +##ga 1 +privacy 1 +agoda 1 +##13 1 +##ny 1 +word 1 +##24 1 +##22 1 +##by 1 +##ur 1 +##hz 1 +1982 1 +##ang 1 +265 1 +cookie 1 +netscape 1 +108 1 +##ka 1 +##～ 1 +##ad 1 +house 1 +share 1 +note 1 +ibm 1 +code 1 +hello 1 +nike 1 +sim 1 +survey 1 +##016 1 +1979 1 +1950 1 +wikia 1 +##32 1 +##017 1 +5g 1 +cbc 1 +##tor 1 +##kg 1 +1983 1 +##rt 1 +##14 1 +campaign 1 +store 1 +2500 1 +os 1 +##ct 1 +##ts 1 +##° 1 +170 1 +api 1 +##ns 1 +365 1 +excel 1 +##な 1 +##ao 1 +##ら 1 +##し 1 +～～ 1 +##nd 1 +university 1 +163 1 +には 1 +518 1 +##70 1 +##ya 1 +##il 1 +##25 1 +pierre 1 +ipo 1 +0020 1 +897 1 +##23 1 +hotels 1 +##ian 1 +のお 1 +125 1 +years 1 +6606 1 +##ers 1 +##26 1 +high 1 +##day 1 +time 1 +##ay 1 +bug 1 +##line 1 +##く 1 +##す 1 +##be 1 +xp 1 +talk2yam 1 +yamservice 1 +10000 1 +coco 1 +##dy 1 +sony 1 +##ies 1 +1978 1 +microsoft 1 +david 1 +people 1 +##ha 1 +1960 1 +instagram 1 +intel 1 +その 1 +##ot 1 +iso 1 +1981 1 +##va 1 +115 1 +##mo 1 +##land 1 +xxx 1 +man 1 +co 1 +ltxsw 1 +##ation 1 +baby 1 +220 1 +##pa 1 +##ol 1 +1945 1 +7000 1 +tag 1 +450 1 +##ue 1 +msn 1 +##31 1 +oppo 1 +##ト 1 +##ca 1 +control 1 +##om 1 +st 1 +chrome 1 +##ure 1 +##ん 1 +be 1 +##き 1 +lol 1 +##19 1 +した 1 +##bo 1 +240 1 +lady 1 +##100 1 +##way 1 +##から 1 +4600 1 +##ko 1 +##do 1 +##un 1 +4s 1 +corporation 1 +168 1 +##ni 1 +herme 1 +##28 1 +ｃｐ 1 +978 1 +##up 1 +##06 1 +ui 1 +##ds 1 +ppt 1 +admin 1 +three 1 +します 1 +bbc 1 +re 1 +128 1 +##48 1 +ca 1 +##015 1 +##35 1 +hp 1 +##ee 1 +tpp 1 +##た 1 +##ive 1 +×× 1 +root 1 +##cc 1 +##ました 1 +##ble 1 +##ity 1 +adobe 1 +park 1 +114 1 +et 1 +oled 1 +city 1 +##ex 1 +##ler 1 +##ap 1 +china 1 +##book 1 +20000 1 +view 1 +##ice 1 +global 1 +##km 1 +your 1 +hong 1 +##mg 1 +out 1 +##ms 1 +ng 1 +ebay 1 +##29 1 +menu 1 +ubuntu 1 +##cy 1 +rom 1 +##view 1 +open 1 +ktv 1 +do 1 +server 1 +##lo 1 +if 1 +english 1 +##ね 1 +##５ 1 +##oo 1 +1600 1 +##02 1 +step1 1 +kong 1 +club 1 +135 1 +july 1 +inc 1 +1976 1 +mr 1 +hi 1 +##net 1 +touch 1 +##ls 1 +##ii 1 +michael 1 +lcd 1 +##05 1 +##33 1 +phone 1 +james 1 +step2 1 +1300 1 +ios9 1 +##box 1 +dc 1 +##２ 1 +##ley 1 +samsung 1 +111 1 +280 1 +pokemon 1 +css 1 +##ent 1 +##les 1 +いいえ 1 +##１ 1 +s8 1 +atom 1 +play 1 +bmw 1 +##said 1 +sa 1 +etf 1 +ctrl 1 +♥yoyo♥ 1 +##55 1 +2025 1 +##2014 1 +##66 1 +adidas 1 +amazon 1 +1958 1 +##ber 1 +##ner 1 +visa 1 +##77 1 +##der 1 +1800 1 +connectivity 1 +##hi 1 +firefox 1 +109 1 +118 1 +hr 1 +so 1 +style 1 +mark 1 +pop 1 +ol 1 +skip 1 +1975 1 +as 1 +##27 1 +##ir 1 +##61 1 +190 1 +mba 1 +##う 1 +##ai 1 +le 1 +##ver 1 +1900 1 +cafe2017 1 +lte 1 +super 1 +113 1 +129 1 +##ron 1 +amd 1 +like 1 +##☆ 1 +are 1 +##ster 1 +we 1 +##sk 1 +paul 1 +data 1 +international 1 +##ft 1 +longchamp 1 +ssd 1 +good 1 +##ート 1 +##ti 1 +reply 1 +##my 1 +↓↓↓ 1 +apr 1 +star 1 +##ker 1 +source 1 +136 1 +js 1 +112 1 +get 1 +force 1 +photo 1 +##one 1 +126 1 +##2013 1 +##ow 1 +link 1 +bbs 1 +1972 1 +goods 1 +##lin 1 +python 1 +119 1 +##ip 1 +game 1 +##ics 1 +##ません 1 +blue 1 +##● 1 +520 1 +##45 1 +page 1 +itunes 1 +##03 1 +1955 1 +260 1 +1968 1 +gt 1 +gif 1 +618 1 +##ff 1 +##47 1 +group 1 +くたさい 1 +about 1 +bar 1 +ganji 1 +##nce 1 +music 1 +lee 1 +not 1 +1977 1 +1971 1 +1973 1 +##per 1 +an 1 +faq 1 +comment 1 +##って 1 +days 1 +##ock 1 +116 1 +##bs 1 +1974 1 +1969 1 +v1 1 +player 1 +1956 1 +xbox 1 +sql 1 +fm 1 +f1 1 +139 1 +##ah 1 +210 1 +##lv 1 +##mp 1 +##000 1 +melody 1 +1957 1 +##３ 1 +550 1 +17life 1 +199 1 +1966 1 +xml 1 +market 1 +##au 1 +##71 1 +999 1 +##04 1 +what 1 +gl 1 +##95 1 +##age 1 +tips 1 +##68 1 +book 1 +##ting 1 +mysql 1 +can 1 +1959 1 +230 1 +##ung 1 +wonderland 1 +watch 1 +10℃ 1 +##ction 1 +9000 1 +mar 1 +mobile 1 +1946 1 +1962 1 +article 1 +##db 1 +part 1 +▲top 1 +party 1 +って 1 +1967 1 +1964 1 +1948 1 +##07 1 +##ore 1 +##op 1 +この 1 +dj 1 +##78 1 +##38 1 +010 1 +main 1 +225 1 +1965 1 +##ong 1 +art 1 +320 1 +ad 1 +134 1 +020 1 +##73 1 +117 1 +pm2 1 +japan 1 +228 1 +##08 1 +ts 1 +1963 1 +##ica 1 +der 1 +sm 1 +##36 1 +2019 1 +##wa 1 +ct 1 +##７ 1 +##や 1 +##64 1 +1937 1 +homemesh 1 +search 1 +##85 1 +##れは 1 +##tv 1 +##di 1 +macbook 1 +##９ 1 +##くたさい 1 +service 1 +##♥ 1 +type 1 +った 1 +750 1 +##ier 1 +##si 1 +##75 1 +##います 1 +##ok 1 +best 1 +##ット 1 +goris 1 +lock 1 +##った 1 +cf 1 +3m 1 +big 1 +##ut 1 +ftp 1 +carol 1 +##vi 1 +１０ 1 +1961 1 +happy 1 +sd 1 +##ac 1 +122 1 +anti 1 +pe 1 +cnn 1 +iii 1 +1920 1 +138 1 +##ラ 1 +1940 1 +esp 1 +jan 1 +tags 1 +##98 1 +##51 1 +august 1 +vol 1 +##86 1 +154 1 +##™ 1 +##fs 1 +##れ 1 +##sion 1 +design 1 +ac 1 +##ム 1 +press 1 +jordan 1 +ppp 1 +that 1 +key 1 +check 1 +##６ 1 +##tt 1 +##㎡ 1 +1080p 1 +##lt 1 +power 1 +##42 1 +1952 1 +##bc 1 +vivi 1 +##ック 1 +he 1 +133 1 +121 1 +jpg 1 +##rry 1 +201 1 +175 1 +3500 1 +1947 1 +nb 1 +##ted 1 +##rn 1 +しています 1 +1954 1 +usd 1 +##t00 1 +master 1 +##ンク 1 +001 1 +model 1 +##58 1 +al 1 +##09 1 +1953 1 +##34 1 +ram 1 +goo 1 +ても 1 +##ui 1 +127 1 +1930 1 +red 1 +##ary 1 +rpg 1 +item 1 +##pm 1 +##41 1 +270 1 +##za 1 +project 1 +##2012 1 +hot 1 +td 1 +blogabstract 1 +##ger 1 +##62 1 +650 1 +##44 1 +gr2 1 +##します 1 +##ｍ 1 +black 1 +electronic 1 +nfc 1 +year 1 +asus 1 +また 1 +html5 1 +cindy 1 +##hd 1 +m3 1 +132 1 +esc 1 +##od 1 +booking 1 +##53 1 +fed 1 +tvb 1 +##81 1 +##ina 1 +mit 1 +165 1 +##いる 1 +chan 1 +192 1 +distribution 1 +next 1 +になる 1 +peter 1 +bios 1 +steam 1 +cm 1 +1941 1 +にも 1 +pk10 1 +##ix 1 +##65 1 +##91 1 +dec 1 +nasa 1 +##ana 1 +icecat 1 +00z 1 +b1 1 +will 1 +##46 1 +li 1 +se 1 +##ji 1 +##み 1 +##ard 1 +oct 1 +##ain 1 +jp 1 +##ze 1 +##bi 1 +cio 1 +##56 1 +smart 1 +h5 1 +##39 1 +##port 1 +curve 1 +vpn 1 +##nm 1 +##dia 1 +utc 1 +##あり 1 +12345678910 1 +##52 1 +rmvb 1 +chanel 1 +a4 1 +miss 1 +##and 1 +##im 1 +media 1 +who 1 +##63 1 +she 1 +girl 1 +5s 1 +124 1 +vera 1 +##して 1 +class 1 +vivo 1 +king 1 +##フ 1 +##ei 1 +national 1 +ab 1 +1951 1 +5cm 1 +888 1 +145 1 +ipod 1 +ap 1 +1100 1 +5mm 1 +211 1 +ms 1 +2756 1 +##69 1 +mp4 1 +msci 1 +##po 1 +##89 1 +131 1 +mg 1 +index 1 +380 1 +##bit 1 +##out 1 +##zz 1 +##97 1 +##67 1 +158 1 +apec 1 +##８ 1 +photoshop 1 +opec 1 +￥799 1 +ては 1 +##96 1 +##tes 1 +##ast 1 +2g 1 +○○ 1 +##ール 1 +￥2899 1 +##ling 1 +##よ 1 +##ory 1 +1938 1 +##ical 1 +kitty 1 +content 1 +##43 1 +step3 1 +##cn 1 +win8 1 +155 1 +vc 1 +1400 1 +iphone7 1 +robert 1 +##した 1 +tcl 1 +137 1 +beauty 1 +##87 1 +en 1 +dollars 1 +##ys 1 +##oc 1 +step 1 +pay 1 +yy 1 +a1 1 +##2011 1 +##lly 1 +##ks 1 +##♪ 1 +1939 1 +188 1 +download 1 +1944 1 +sep 1 +exe 1 +ph 1 +います 1 +school 1 +gb 1 +center 1 +pr 1 +street 1 +##board 1 +uv 1 +##37 1 +##lan 1 +winrar 1 +##que 1 +##ua 1 +##com 1 +1942 1 +1936 1 +480 1 +gpu 1 +##４ 1 +ettoday 1 +fu 1 +tom 1 +##54 1 +##ren 1 +##via 1 +149 1 +##72 1 +b2b 1 +144 1 +##79 1 +##tch 1 +rose 1 +arm 1 +mb 1 +##49 1 +##ial 1 +##nn 1 +nvidia 1 +step4 1 +mvp 1 +00㎡ 1 +york 1 +156 1 +##イ 1 +how 1 +cpi 1 +591 1 +2765 1 +gov 1 +kg 1 +joe 1 +##xx 1 +mandy 1 +pa 1 +##ser 1 +copyright 1 +fashion 1 +1935 1 +don 1 +##け 1 +ecu 1 +##ist 1 +##art 1 +erp 1 +wap 1 +have 1 +##lm 1 +talk 1 +##ek 1 +##ning 1 +##if 1 +ch 1 +##ite 1 +video 1 +1943 1 +cs 1 +san 1 +iot 1 +look 1 +##84 1 +##2010 1 +##ku 1 +october 1 +##ux 1 +trump 1 +##hs 1 +##ide 1 +box 1 +141 1 +first 1 +##ins 1 +april 1 +##ight 1 +##83 1 +185 1 +angel 1 +protected 1 +aa 1 +151 1 +162 1 +x1 1 +m2 1 +##fe 1 +##× 1 +##ho 1 +size 1 +143 1 +min 1 +ofo 1 +fun 1 +gomaji 1 +ex 1 +hdmi 1 +food 1 +dns 1 +march 1 +chris 1 +kevin 1 +##のか 1 +##lla 1 +##pp 1 +##ec 1 +ag 1 +ems 1 +6s 1 +720p 1 +##rm 1 +##ham 1 +off 1 +##92 1 +asp 1 +team 1 +fandom 1 +ed 1 +299 1 +▌♥ 1 +##ell 1 +info 1 +されています 1 +##82 1 +sina 1 +4066 1 +161 1 +##able 1 +##ctor 1 +330 1 +399 1 +315 1 +dll 1 +rights 1 +ltd 1 +idc 1 +jul 1 +3kg 1 +1927 1 +142 1 +ma 1 +surface 1 +##76 1 +##ク 1 +～～～ 1 +304 1 +mall 1 +eps 1 +146 1 +green 1 +##59 1 +map 1 +space 1 +donald 1 +v2 1 +sodu 1 +##light 1 +1931 1 +148 1 +1700 1 +まて 1 +310 1 +reserved 1 +htm 1 +##han 1 +##57 1 +2d 1 +178 1 +mod 1 +##ise 1 +##tions 1 +152 1 +ti 1 +##shi 1 +doc 1 +1933 1 +icp 1 +055 1 +wang 1 +##ram 1 +shopping 1 +aug 1 +##pi 1 +##well 1 +now 1 +wam 1 +b2 1 +からお 1 +##hu 1 +236 1 +1928 1 +##gb 1 +266 1 +f2 1 +##93 1 +153 1 +mix 1 +##ef 1 +##uan 1 +bwl 1 +##plus 1 +##res 1 +core 1 +##ess 1 +tea 1 +5℃ 1 +hktvmall 1 +nhk 1 +##ate 1 +list 1 +##ese 1 +301 1 +feb 1 +4m 1 +inn 1 +ての 1 +nov 1 +159 1 +12345 1 +daniel 1 +##ci 1 +pass 1 +##bet 1 +##nk 1 +coffee 1 +202 1 +ssl 1 +airbnb 1 +##ute 1 +fbi 1 +woshipm 1 +skype 1 +ea 1 +cg 1 +sp 1 +##fc 1 +##www 1 +yes 1 +edge 1 +alt 1 +007 1 +##94 1 +fpga 1 +##ght 1 +##gs 1 +iso9001 1 +さい 1 +##ile 1 +##wood 1 +##uo 1 +image 1 +lin 1 +icon 1 +american 1 +##em 1 +1932 1 +set 1 +says 1 +##king 1 +##tive 1 +blogger 1 +##74 1 +なと 1 +256 1 +147 1 +##ox 1 +##zy 1 +##red 1 +##ium 1 +##lf 1 +nokia 1 +claire 1 +##リ 1 +##ding 1 +november 1 +lohas 1 +##500 1 +##tic 1 +##マ 1 +##cs 1 +##ある 1 +##che 1 +##ire 1 +##gy 1 +##ult 1 +db 1 +january 1 +win 1 +##カ 1 +166 1 +road 1 +ptt 1 +##ま 1 +##つ 1 +198 1 +##fa 1 +##mer 1 +anna 1 +pchome 1 +はい 1 +udn 1 +ef 1 +420 1 +##time 1 +##tte 1 +2030 1 +##ア 1 +g20 1 +white 1 +かかります 1 +1929 1 +308 1 +garden 1 +eleven 1 +di 1 +##おります 1 +chen 1 +309b 1 +777 1 +172 1 +young 1 +cosplay 1 +ちてない 1 +4500 1 +bat 1 +##123 1 +##tra 1 +##ては 1 +kindle 1 +npc 1 +steve 1 +etc 1 +##ern 1 +##｜ 1 +call 1 +xperia 1 +ces 1 +travel 1 +sk 1 +s7 1 +##ous 1 +1934 1 +##int 1 +みいたたけます 1 +183 1 +edu 1 +file 1 +cho 1 +qr 1 +##car 1 +##our 1 +186 1 +##ant 1 +##ｄ 1 +eric 1 +1914 1 +rends 1 +##jo 1 +##する 1 +mastercard 1 +##2000 1 +kb 1 +##min 1 +290 1 +##ino 1 +vista 1 +##ris 1 +##ud 1 +jack 1 +2400 1 +##set 1 +169 1 +pos 1 +1912 1 +##her 1 +##ou 1 +taipei 1 +しく 1 +205 1 +beta 1 +##ませんか 1 +232 1 +##fi 1 +express 1 +255 1 +body 1 +##ill 1 +aphojoy 1 +user 1 +december 1 +meiki 1 +##ick 1 +tweet 1 +richard 1 +##av 1 +##ᆫ 1 +iphone6 1 +##dd 1 +ちてすか 1 +views 1 +##mark 1 +321 1 +pd 1 +##００ 1 +times 1 +##▲ 1 +level 1 +##ash 1 +10g 1 +point 1 +5l 1 +##ome 1 +208 1 +koreanmall 1 +##ak 1 +george 1 +q2 1 +206 1 +wma 1 +tcp 1 +##200 1 +スタッフ 1 +full 1 +mlb 1 +##lle 1 +##watch 1 +tm 1 +run 1 +179 1 +911 1 +smith 1 +business 1 +##und 1 +1919 1 +color 1 +##tal 1 +222 1 +171 1 +##less 1 +moon 1 +4399 1 +##rl 1 +update 1 +pcb 1 +shop 1 +499 1 +157 1 +little 1 +なし 1 +end 1 +##mhz 1 +van 1 +dsp 1 +easy 1 +660 1 +##house 1 +##key 1 +history 1 +##ｏ 1 +oh 1 +##001 1 +##hy 1 +##web 1 +oem 1 +let 1 +was 1 +##2009 1 +##gg 1 +review 1 +##wan 1 +182 1 +##°c 1 +203 1 +uc 1 +title 1 +##val 1 +united 1 +233 1 +2021 1 +##ons 1 +doi 1 +trivago 1 +overdope 1 +sbs 1 +##ance 1 +##ち 1 +grand 1 +special 1 +573032185 1 +imf 1 +216 1 +wx17house 1 +##so 1 +##ーム 1 +audi 1 +##he 1 +london 1 +william 1 +##rp 1 +##ake 1 +science 1 +beach 1 +cfa 1 +amp 1 +ps4 1 +880 1 +##800 1 +##link 1 +##hp 1 +crm 1 +ferragamo 1 +bell 1 +make 1 +##eng 1 +195 1 +under 1 +zh 1 +photos 1 +2300 1 +##style 1 +##ント 1 +via 1 +176 1 +da 1 +##gi 1 +company 1 +i7 1 +##ray 1 +thomas 1 +370 1 +ufo 1 +i5 1 +##max 1 +plc 1 +ben 1 +back 1 +research 1 +8g 1 +173 1 +mike 1 +##pc 1 +##ッフ 1 +september 1 +189 1 +##ace 1 +vps 1 +february 1 +167 1 +pantos 1 +wp 1 +lisa 1 +1921 1 +★★ 1 +jquery 1 +night 1 +long 1 +offer 1 +##berg 1 +##news 1 +1911 1 +##いて 1 +ray 1 +fks 1 +wto 1 +せます 1 +over 1 +164 1 +340 1 +##all 1 +##rus 1 +1924 1 +##888 1 +##works 1 +blogtitle 1 +loftpermalink 1 +##→ 1 +187 1 +martin 1 +test 1 +ling 1 +km 1 +##め 1 +15000 1 +fda 1 +v3 1 +##ja 1 +##ロ 1 +ｗedding 1 +かある 1 +outlet 1 +family 1 +##ea 1 +をこ 1 +##top 1 +story 1 +##ness 1 +salvatore 1 +##lu 1 +204 1 +swift 1 +215 1 +room 1 +している 1 +oracle 1 +##ul 1 +1925 1 +sam 1 +b2c 1 +week 1 +pi 1 +rock 1 +##のは 1 +##ａ 1 +##けと 1 +##ean 1 +##300 1 +##gle 1 +cctv 1 +after 1 +chinese 1 +##back 1 +powered 1 +x2 1 +##tan 1 +1918 1 +##nes 1 +##イン 1 +canon 1 +only 1 +181 1 +##zi 1 +##las 1 +say 1 +##oe 1 +184 1 +##sd 1 +221 1 +##bot 1 +##world 1 +##zo 1 +sky 1 +made 1 +top100 1 +just 1 +1926 1 +pmi 1 +802 1 +234 1 +gap 1 +##vr 1 +177 1 +les 1 +174 1 +▲topoct 1 +ball 1 +vogue 1 +vi 1 +ing 1 +ofweek 1 +cos 1 +##list 1 +##ort 1 +▲topmay 1 +##なら 1 +##lon 1 +として 1 +last 1 +##tc 1 +##of 1 +##bus 1 +##gen 1 +real 1 +eva 1 +##コ 1 +a3 1 +nas 1 +##lie 1 +##ria 1 +##coin 1 +##bt 1 +▲topapr 1 +his 1 +212 1 +cat 1 +nata 1 +vive 1 +health 1 +⋯⋯ 1 +drive 1 +sir 1 +▲topmar 1 +du 1 +cup 1 +##カー 1 +##ook 1 +##よう 1 +##sy 1 +alex 1 +msg 1 +tour 1 +しました 1 +3ce 1 +##word 1 +193 1 +ebooks 1 +r8 1 +block 1 +318 1 +##より 1 +2200 1 +nice 1 +pvp 1 +207 1 +months 1 +1905 1 +rewards 1 +##ther 1 +1917 1 +0800 1 +##xi 1 +##チ 1 +##sc 1 +micro 1 +850 1 +gg 1 +blogfp 1 +op 1 +1922 1 +daily 1 +m1 1 +264 1 +true 1 +##bb 1 +ml 1 +##tar 1 +##のお 1 +##ky 1 +anthony 1 +196 1 +253 1 +##yo 1 +state 1 +218 1 +##ara 1 +##aa 1 +##rc 1 +##tz 1 +##ston 1 +より 1 +gear 1 +##eo 1 +##ade 1 +ge 1 +see 1 +1923 1 +##win 1 +##ura 1 +ss 1 +heart 1 +##den 1 +##ita 1 +down 1 +##sm 1 +el 1 +png 1 +2100 1 +610 1 +rakuten 1 +whatsapp 1 +bay 1 +dream 1 +add 1 +##use 1 +680 1 +311 1 +pad 1 +gucci 1 +mpv 1 +##ode 1 +##fo 1 +island 1 +▲topjun 1 +##▼ 1 +223 1 +jason 1 +214 1 +chicago 1 +##❤ 1 +しの 1 +##hone 1 +io 1 +##れる 1 +##ことか 1 +sogo 1 +be2 1 +##ology 1 +990 1 +cloud 1 +vcd 1 +##con 1 +2～3 1 +##ford 1 +##joy 1 +##kb 1 +##こさいます 1 +##rade 1 +but 1 +##ach 1 +docker 1 +##ful 1 +rfid 1 +ul 1 +##ase 1 +hit 1 +ford 1 +##star 1 +580 1 +##○ 1 +１１ 1 +a2 1 +sdk 1 +reading 1 +edited 1 +##are 1 +cmos 1 +##mc 1 +238 1 +siri 1 +light 1 +##ella 1 +##ため 1 +bloomberg 1 +##read 1 +pizza 1 +##ison 1 +jimmy 1 +##vm 1 +college 1 +node 1 +journal 1 +ba 1 +18k 1 +##play 1 +245 1 +##cer 1 +２０ 1 +magic 1 +##yu 1 +191 1 +jump 1 +288 1 +tt 1 +##ings 1 +asr 1 +##lia 1 +3200 1 +step5 1 +network 1 +##cd 1 +mc 1 +いします 1 +1234 1 +pixstyleme 1 +273 1 +##600 1 +2800 1 +money 1 +★★★★★ 1 +1280 1 +１２ 1 +430 1 +bl 1 +みの 1 +act 1 +##tus 1 +tokyo 1 +##rial 1 +##life 1 +emba 1 +##ae 1 +saas 1 +tcs 1 +##rk 1 +##wang 1 +summer 1 +##sp 1 +ko 1 +##ving 1 +390 1 +premium 1 +##その 1 +netflix 1 +##ヒ 1 +uk 1 +mt 1 +##lton 1 +right 1 +frank 1 +two 1 +209 1 +える 1 +##ple 1 +##cal 1 +021 1 +##んな 1 +##sen 1 +##ville 1 +hold 1 +nexus 1 +dd 1 +##ius 1 +てお 1 +##mah 1 +##なく 1 +tila 1 +zero 1 +820 1 +ce 1 +##tin 1 +resort 1 +##ws 1 +charles 1 +old 1 +p10 1 +5d 1 +report 1 +##360 1 +##ru 1 +##には 1 +bus 1 +vans 1 +lt 1 +##est 1 +pv 1 +##レ 1 +links 1 +rebecca 1 +##ツ 1 +##dm 1 +azure 1 +##365 1 +きな 1 +limited 1 +bit 1 +4gb 1 +##mon 1 +1910 1 +moto 1 +##eam 1 +213 1 +1913 1 +var 1 +eos 1 +なとの 1 +226 1 +blogspot 1 +された 1 +699 1 +e3 1 +dos 1 +dm 1 +fc 1 +##ments 1 +##ik 1 +##kw 1 +boy 1 +##bin 1 +##ata 1 +960 1 +er 1 +##せ 1 +219 1 +##vin 1 +##tu 1 +##ula 1 +194 1 +##∥ 1 +station 1 +##ろ 1 +##ature 1 +835 1 +files 1 +zara 1 +hdr 1 +top10 1 +nature 1 +950 1 +magazine 1 +s6 1 +marriott 1 +##シ 1 +avira 1 +case 1 +##っと 1 +tab 1 +##ran 1 +tony 1 +##home 1 +oculus 1 +im 1 +##ral 1 +jean 1 +saint 1 +cry 1 +307 1 +rosie 1 +##force 1 +##ini 1 +ice 1 +##bert 1 +のある 1 +##nder 1 +##mber 1 +pet 1 +2600 1 +##◆ 1 +plurk 1 +▲topdec 1 +##sis 1 +00kg 1 +▲topnov 1 +720 1 +##ence 1 +tim 1 +##ω 1 +##nc 1 +##ても 1 +##name 1 +log 1 +ips 1 +great 1 +ikea 1 +malaysia 1 +unix 1 +##イト 1 +3600 1 +##ncy 1 +##nie 1 +12000 1 +akb48 1 +##ye 1 +##oid 1 +404 1 +##chi 1 +##いた 1 +oa 1 +xuehai 1 +##1000 1 +##orm 1 +##rf 1 +275 1 +さん 1 +##ware 1 +##リー 1 +980 1 +ho 1 +##pro 1 +text 1 +##era 1 +560 1 +bob 1 +227 1 +##ub 1 +##2008 1 +8891 1 +scp 1 +avi 1 +##zen 1 +2022 1 +mi 1 +wu 1 +museum 1 +qvod 1 +apache 1 +lake 1 +jcb 1 +▲topaug 1 +★★★ 1 +ni 1 +##hr 1 +hill 1 +302 1 +ne 1 +weibo 1 +490 1 +ruby 1 +##ーシ 1 +##ヶ 1 +##row 1 +4d 1 +▲topjul 1 +iv 1 +##ish 1 +github 1 +306 1 +mate 1 +312 1 +##スト 1 +##lot 1 +##ane 1 +andrew 1 +のハイト 1 +##tina 1 +t1 1 +rf 1 +ed2k 1 +##vel 1 +##900 1 +way 1 +final 1 +りの 1 +ns 1 +5a 1 +705 1 +197 1 +##メ 1 +sweet 1 +bytes 1 +##ene 1 +▲topjan 1 +231 1 +##cker 1 +##2007 1 +##px 1 +100g 1 +topapp 1 +229 1 +helpapp 1 +rs 1 +low 1 +14k 1 +g4g 1 +care 1 +630 1 +ldquo 1 +あり 1 +##fork 1 +leave 1 +rm 1 +edition 1 +##gan 1 +##zon 1 +##qq 1 +▲topsep 1 +##google 1 +##ism 1 +gold 1 +224 1 +explorer 1 +##zer 1 +toyota 1 +category 1 +select 1 +visual 1 +##labels 1 +restaurant 1 +##md 1 +posts 1 +s1 1 +##ico 1 +もっと 1 +angelababy 1 +123456 1 +217 1 +sports 1 +s3 1 +mbc 1 +1915 1 +してくたさい 1 +shell 1 +x86 1 +candy 1 +##new 1 +kbs 1 +face 1 +xl 1 +470 1 +##here 1 +4a 1 +swissinfo 1 +v8 1 +▲topfeb 1 +dram 1 +##ual 1 +##vice 1 +3a 1 +##wer 1 +sport 1 +q1 1 +ios10 1 +public 1 +int 1 +card 1 +##ｃ 1 +ep 1 +au 1 +rt 1 +##れた 1 +1080 1 +bill 1 +##mll 1 +kim 1 +３０ 1 +460 1 +wan 1 +##uk 1 +##ミ 1 +x3 1 +298 1 +0t 1 +scott 1 +##ming 1 +239 1 +e5 1 +##3d 1 +h7n9 1 +worldcat 1 +brown 1 +##あります 1 +##vo 1 +##led 1 +##580 1 +##ax 1 +249 1 +410 1 +##ert 1 +paris 1 +##～6 1 +polo 1 +925 1 +##lr 1 +599 1 +##ナ 1 +capital 1 +##hing 1 +bank 1 +cv 1 +1g 1 +##chat 1 +##ｓ 1 +##たい 1 +adc 1 +##ule 1 +2m 1 +##ｅ 1 +digital 1 +hotmail 1 +268 1 +##pad 1 +870 1 +bbq 1 +quot 1 +##ring 1 +before 1 +wali 1 +##まて 1 +mcu 1 +2k 1 +2b 1 +という 1 +costco 1 +316 1 +north 1 +333 1 +switch 1 +##city 1 +##ｐ 1 +philips 1 +##mann 1 +management 1 +panasonic 1 +##cl 1 +##vd 1 +##ping 1 +##rge 1 +alice 1 +##lk 1 +##ましょう 1 +css3 1 +##ney 1 +vision 1 +alpha 1 +##ular 1 +##400 1 +##tter 1 +lz 1 +にお 1 +##ありません 1 +mode 1 +gre 1 +1916 1 +pci 1 +##tm 1 +237 1 +1～2 1 +##yan 1 +##そ 1 +について 1 +##let 1 +##キ 1 +work 1 +war 1 +coach 1 +ah 1 +mary 1 +##ᅵ 1 +huang 1 +##pt 1 +a8 1 +pt 1 +follow 1 +##berry 1 +1895 1 +##ew 1 +a5 1 +ghost 1 +##ション 1 +##wn 1 +##og 1 +south 1 +##code 1 +girls 1 +##rid 1 +action 1 +villa 1 +git 1 +r11 1 +table 1 +games 1 +##cket 1 +error 1 +##anonymoussaid 1 +##ag 1 +here 1 +##ame 1 +##gc 1 +qa 1 +##■ 1 +##lis 1 +gmp 1 +##gin 1 +vmalife 1 +##cher 1 +yu 1 +wedding 1 +##tis 1 +demo 1 +dragon 1 +530 1 +soho 1 +social 1 +bye 1 +##rant 1 +river 1 +orz 1 +acer 1 +325 1 +##↑ 1 +##ース 1 +##ats 1 +261 1 +del 1 +##ven 1 +440 1 +ups 1 +##ように 1 +##ター 1 +305 1 +value 1 +macd 1 +yougou 1 +##dn 1 +661 1 +##ano 1 +ll 1 +##urt 1 +##rent 1 +continue 1 +script 1 +##wen 1 +##ect 1 +paper 1 +263 1 +319 1 +shift 1 +##chel 1 +##フト 1 +##cat 1 +258 1 +x5 1 +fox 1 +243 1 +##さん 1 +car 1 +aaa 1 +##blog 1 +loading 1 +##yn 1 +##tp 1 +kuso 1 +799 1 +si 1 +sns 1 +イカせるテンマ 1 +ヒンクテンマ3 1 +rmb 1 +vdc 1 +forest 1 +central 1 +prime 1 +help 1 +ultra 1 +##rmb 1 +##ような 1 +241 1 +square 1 +688 1 +##しい 1 +のないフロクに 1 +##field 1 +##reen 1 +##ors 1 +##ju 1 +c1 1 +start 1 +510 1 +##air 1 +##map 1 +cdn 1 +##wo 1 +cba 1 +stephen 1 +m8 1 +100km 1 +##get 1 +opera 1 +##base 1 +##ood 1 +vsa 1 +com™ 1 +##aw 1 +##ail 1 +251 1 +なのて 1 +count 1 +t2 1 +##ᅡ 1 +##een 1 +2700 1 +hop 1 +##gp 1 +vsc 1 +tree 1 +##eg 1 +##ose 1 +816 1 +285 1 +##ories 1 +##shop 1 +alphago 1 +v4 1 +1909 1 +simon 1 +##ᆼ 1 +fluke62max 1 +zip 1 +スホンサー 1 +##sta 1 +louis 1 +cr 1 +bas 1 +##～10 1 +bc 1 +##yer 1 +hadoop 1 +##ube 1 +##wi 1 +1906 1 +0755 1 +hola 1 +##low 1 +place 1 +centre 1 +5v 1 +d3 1 +##fer 1 +252 1 +##750 1 +##media 1 +281 1 +540 1 +0l 1 +exchange 1 +262 1 +series 1 +##ハー 1 +##san 1 +eb 1 +##bank 1 +##ｋ 1 +q3 1 +##nge 1 +##mail 1 +take 1 +##lp 1 +259 1 +1888 1 +client 1 +east 1 +cache 1 +event 1 +vincent 1 +##ールを 1 +きを 1 +##nse 1 +sui 1 +855 1 +adchoice 1 +##и 1 +##stry 1 +##なたの 1 +246 1 +##zone 1 +ga 1 +apps 1 +sea 1 +##ab 1 +248 1 +cisco 1 +##タ 1 +##rner 1 +kymco 1 +##care 1 +dha 1 +##pu 1 +##yi 1 +minkoff 1 +royal 1 +p1 1 +への 1 +annie 1 +269 1 +collection 1 +kpi 1 +playstation 1 +257 1 +になります 1 +866 1 +bh 1 +##bar 1 +queen 1 +505 1 +radio 1 +1904 1 +andy 1 +armani 1 +##xy 1 +manager 1 +iherb 1 +##ery 1 +##share 1 +spring 1 +raid 1 +johnson 1 +1908 1 +##ob 1 +volvo 1 +hall 1 +##ball 1 +v6 1 +our 1 +taylor 1 +##hk 1 +bi 1 +242 1 +##cp 1 +kate 1 +bo 1 +water 1 +technology 1 +##rie 1 +サイトは 1 +277 1 +##ona 1 +##sl 1 +hpv 1 +303 1 +gtx 1 +hip 1 +rdquo 1 +jayz 1 +stone 1 +##lex 1 +##rum 1 +namespace 1 +##やり 1 +620 1 +##ale 1 +##atic 1 +des 1 +##erson 1 +##ql 1 +##ves 1 +##type 1 +enter 1 +##この 1 +##てきます 1 +d2 1 +##168 1 +##mix 1 +##bian 1 +との 1 +a9 1 +jj 1 +ky 1 +##lc 1 +access 1 +movie 1 +##hc 1 +リストに 1 +tower 1 +##ration 1 +##mit 1 +ます 1 +##nch 1 +ua 1 +tel 1 +prefix 1 +##o2 1 +1907 1 +##point 1 +1901 1 +ott 1 +～10 1 +##http 1 +##ury 1 +baidu 1 +##ink 1 +member 1 +##logy 1 +bigbang 1 +nownews 1 +##js 1 +##shot 1 +##tb 1 +##こと 1 +247 1 +eba 1 +##tics 1 +##lus 1 +ける 1 +v5 1 +spark 1 +##ama 1 +there 1 +##ions 1 +god 1 +##lls 1 +##down 1 +hiv 1 +##ress 1 +burberry 1 +day2 1 +##kv 1 +◆◆ 1 +jeff 1 +related 1 +film 1 +edit 1 +joseph 1 +283 1 +##ark 1 +cx 1 +32gb 1 +order 1 +g9 1 +30000 1 +##ans 1 +##tty 1 +s5 1 +##bee 1 +かあります 1 +thread 1 +xr 1 +buy 1 +sh 1 +005 1 +land 1 +spotify 1 +mx 1 +##ari 1 +276 1 +##verse 1 +×email 1 +sf 1 +why 1 +##ことて 1 +244 1 +7headlines 1 +nego 1 +sunny 1 +dom 1 +exo 1 +401 1 +666 1 +positioning 1 +fit 1 +rgb 1 +##tton 1 +278 1 +kiss 1 +alexa 1 +adam 1 +lp 1 +みリストを 1 +##ｇ 1 +mp 1 +##ties 1 +##llow 1 +amy 1 +##du 1 +np 1 +002 1 +institute 1 +271 1 +##rth 1 +##lar 1 +2345 1 +590 1 +##des 1 +sidebar 1 +１５ 1 +imax 1 +site 1 +##cky 1 +##kit 1 +##ime 1 +##009 1 +season 1 +323 1 +##fun 1 +##ンター 1 +##ひ 1 +gogoro 1 +a7 1 +pu 1 +lily 1 +fire 1 +twd600 1 +##ッセーシを 1 +いて 1 +##vis 1 +30ml 1 +##cture 1 +##をお 1 +information 1 +##オ 1 +close 1 +friday 1 +##くれる 1 +yi 1 +nick 1 +てすか 1 +##tta 1 +##tel 1 +6500 1 +##lock 1 +cbd 1 +economy 1 +254 1 +かお 1 +267 1 +tinker 1 +double 1 +375 1 +8gb 1 +voice 1 +##app 1 +oops 1 +channel 1 +today 1 +985 1 +##right 1 +raw 1 +xyz 1 +##＋ 1 +jim 1 +edm 1 +##cent 1 +7500 1 +supreme 1 +814 1 +ds 1 +##its 1 +##asia 1 +dropbox 1 +##てすか 1 +##tti 1 +books 1 +272 1 +100ml 1 +##tle 1 +##ller 1 +##ken 1 +##more 1 +##boy 1 +sex 1 +309 1 +##dom 1 +t3 1 +##ider 1 +##なります 1 +##unch 1 +1903 1 +810 1 +feel 1 +5500 1 +##かった 1 +##put 1 +により 1 +s2 1 +mo 1 +##gh 1 +men 1 +ka 1 +amoled 1 +div 1 +##tr 1 +##n1 1 +port 1 +howard 1 +##tags 1 +ken 1 +dnf 1 +##nus 1 +adsense 1 +##а 1 +ide 1 +##へ 1 +buff 1 +thunder 1 +##town 1 +##ique 1 +has 1 +##body 1 +auto 1 +pin 1 +##erry 1 +tee 1 +てした 1 +295 1 +number 1 +##the 1 +##013 1 +object 1 +psp 1 +cool 1 +udnbkk 1 +16gb 1 +##mic 1 +miui 1 +##tro 1 +most 1 +r2 1 +##alk 1 +##nity 1 +1880 1 +±0 1 +##いました 1 +428 1 +s4 1 +law 1 +version 1 +##oa 1 +n1 1 +sgs 1 +docomo 1 +##tf 1 +##ack 1 +henry 1 +fc2 1 +##ded 1 +##sco 1 +##014 1 +##rite 1 +286 1 +0mm 1 +linkedin 1 +##ada 1 +##now 1 +wii 1 +##ndy 1 +ucbug 1 +##◎ 1 +sputniknews 1 +legalminer 1 +##ika 1 +##xp 1 +2gb 1 +##bu 1 +q10 1 +oo 1 +b6 1 +come 1 +##rman 1 +cheese 1 +ming 1 +maker 1 +##gm 1 +nikon 1 +##fig 1 +ppi 1 +kelly 1 +##ります 1 +jchere 1 +てきます 1 +ted 1 +md 1 +003 1 +fgo 1 +tech 1 +##tto 1 +dan 1 +soc 1 +##gl 1 +##len 1 +hair 1 +earth 1 +640 1 +521 1 +img 1 +##pper 1 +##a1 1 +##てきる 1 +##ロク 1 +acca 1 +##ition 1 +##ference 1 +suite 1 +##ig 1 +outlook 1 +##mond 1 +##cation 1 +398 1 +##pr 1 +279 1 +101vip 1 +358 1 +##999 1 +282 1 +64gb 1 +3800 1 +345 1 +airport 1 +##over 1 +284 1 +##おり 1 +jones 1 +##ith 1 +lab 1 +##su 1 +##いるのて 1 +co2 1 +town 1 +piece 1 +##llo 1 +no1 1 +vmware 1 +24h 1 +##qi 1 +focus 1 +reader 1 +##admin 1 +##ora 1 +tb 1 +false 1 +##log 1 +1898 1 +know 1 +lan 1 +838 1 +##ces 1 +f4 1 +##ume 1 +motel 1 +stop 1 +##oper 1 +na 1 +flickr 1 +netcomponents 1 +##af 1 +##─ 1 +pose 1 +williams 1 +local 1 +##ound 1 +##cg 1 +##site 1 +##iko 1 +いお 1 +274 1 +5m 1 +gsm 1 +con 1 +##ath 1 +1902 1 +friends 1 +##hip 1 +cell 1 +317 1 +##rey 1 +780 1 +cream 1 +##cks 1 +012 1 +##dp 1 +facebooktwitterpinterestgoogle 1 +sso 1 +324 1 +shtml 1 +song 1 +swiss 1 +##mw 1 +##キンク 1 +lumia 1 +xdd 1 +string 1 +tiffany 1 +522 1 +marc 1 +られた 1 +insee 1 +russell 1 +sc 1 +dell 1 +##ations 1 +ｏｋ 1 +camera 1 +289 1 +##vs 1 +##flow 1 +##late 1 +classic 1 +287 1 +##nter 1 +stay 1 +g1 1 +mtv 1 +512 1 +##ever 1 +##lab 1 +##nger 1 +qe 1 +sata 1 +ryan 1 +d1 1 +50ml 1 +cms 1 +##cing 1 +su 1 +292 1 +3300 1 +editor 1 +296 1 +##nap 1 +security 1 +sunday 1 +association 1 +##ens 1 +##700 1 +##bra 1 +acg 1 +##かり 1 +sofascore 1 +とは 1 +mkv 1 +##ign 1 +jonathan 1 +gary 1 +build 1 +labels 1 +##oto 1 +tesla 1 +moba 1 +qi 1 +gohappy 1 +general 1 +ajax 1 +1024 1 +##かる 1 +サイト 1 +society 1 +##test 1 +##urs 1 +wps 1 +fedora 1 +##ich 1 +mozilla 1 +328 1 +##480 1 +##dr 1 +usa 1 +urn 1 +##lina 1 +##ｒ 1 +grace 1 +##die 1 +##try 1 +##ader 1 +1250 1 +##なり 1 +elle 1 +570 1 +##chen 1 +##ᆯ 1 +price 1 +##ten 1 +uhz 1 +##ough 1 +eq 1 +##hen 1 +states 1 +push 1 +session 1 +balance 1 +wow 1 +506 1 +##cus 1 +##py 1 +when 1 +##ward 1 +##ep 1 +34e 1 +wong 1 +library 1 +prada 1 +##サイト 1 +##cle 1 +running 1 +##ree 1 +313 1 +ck 1 +date 1 +q4 1 +##ctive 1 +##ool 1 +##＞ 1 +mk 1 +##ira 1 +##163 1 +388 1 +die 1 +secret 1 +rq 1 +dota 1 +buffet 1 +は１ヶ 1 +e6 1 +##ez 1 +pan 1 +368 1 +ha 1 +##card 1 +##cha 1 +2a 1 +##さ 1 +alan 1 +day3 1 +eye 1 +f3 1 +##end 1 +france 1 +keep 1 +adi 1 +rna 1 +tvbs 1 +##ala 1 +solo 1 +nova 1 +##え 1 +##tail 1 +##ょう 1 +support 1 +##ries 1 +##なる 1 +##ved 1 +base 1 +copy 1 +iis 1 +fps 1 +##ways 1 +hero 1 +hgih 1 +profile 1 +fish 1 +mu 1 +ssh 1 +entertainment 1 +chang 1 +##wd 1 +click 1 +cake 1 +##ond 1 +pre 1 +##tom 1 +kic 1 +pixel 1 +##ov 1 +##fl 1 +product 1 +6a 1 +##pd 1 +dear 1 +##gate 1 +es 1 +yumi 1 +audio 1 +##² 1 +##sky 1 +echo 1 +bin 1 +where 1 +##ture 1 +329 1 +##ape 1 +find 1 +sap 1 +isis 1 +##なと 1 +nand 1 +##101 1 +##load 1 +##ream 1 +band 1 +a6 1 +525 1 +never 1 +##post 1 +festival 1 +50cm 1 +##we 1 +555 1 +guide 1 +314 1 +zenfone 1 +##ike 1 +335 1 +gd 1 +forum 1 +jessica 1 +strong 1 +alexander 1 +##ould 1 +software 1 +allen 1 +##ious 1 +program 1 +360° 1 +else 1 +lohasthree 1 +##gar 1 +することかてきます 1 +please 1 +##れます 1 +rc 1 +##ggle 1 +##ric 1 +bim 1 +50000 1 +##own 1 +eclipse 1 +355 1 +brian 1 +3ds 1 +##side 1 +061 1 +361 1 +##other 1 +##ける 1 +##tech 1 +##ator 1 +485 1 +engine 1 +##ged 1 +##ｔ 1 +plaza 1 +##fit 1 +cia 1 +ngo 1 +westbrook 1 +shi 1 +tbs 1 +50mm 1 +##みませんか 1 +sci 1 +291 1 +reuters 1 +##ily 1 +contextlink 1 +##hn 1 +af 1 +##cil 1 +bridge 1 +very 1 +##cel 1 +1890 1 +cambridge 1 +##ize 1 +15g 1 +##aid 1 +##data 1 +790 1 +frm 1 +##head 1 +award 1 +butler 1 +##sun 1 +meta 1 +##mar 1 +america 1 +ps3 1 +puma 1 +pmid 1 +##すか 1 +lc 1 +670 1 +kitchen 1 +##lic 1 +オーフン5 1 +きなしソフトサーヒス 1 +そして 1 +day1 1 +future 1 +★★★★ 1 +##text 1 +##page 1 +##rris 1 +pm1 1 +##ket 1 +fans 1 +##っています 1 +1001 1 +christian 1 +bot 1 +kids 1 +trackback 1 +##hai 1 +c3 1 +display 1 +##hl 1 +n2 1 +1896 1 +idea 1 +さんも 1 +##sent 1 +airmail 1 +##ug 1 +##men 1 +pwm 1 +けます 1 +028 1 +##lution 1 +369 1 +852 1 +awards 1 +schemas 1 +354 1 +asics 1 +wikipedia 1 +font 1 +##tional 1 +##vy 1 +c2 1 +293 1 +##れている 1 +##dget 1 +##ein 1 +っている 1 +contact 1 +pepper 1 +スキル 1 +339 1 +##～5 1 +294 1 +##uel 1 +##ument 1 +730 1 +##hang 1 +みてす 1 +q5 1 +##sue 1 +rain 1 +##ndi 1 +wei 1 +swatch 1 +##cept 1 +わせ 1 +331 1 +popular 1 +##ste 1 +##tag 1 +p2 1 +501 1 +trc 1 +1899 1 +##west 1 +##live 1 +justin 1 +honda 1 +ping 1 +messenger 1 +##rap 1 +v9 1 +543 1 +##とは 1 +unity 1 +appqq 1 +はすへて 1 +025 1 +leo 1 +##tone 1 +##テ 1 +##ass 1 +uniqlo 1 +##010 1 +502 1 +her 1 +jane 1 +memory 1 +moneydj 1 +##tical 1 +human 1 +12306 1 +していると 1 +##m2 1 +coc 1 +miacare 1 +##mn 1 +tmt 1 +##core 1 +vim 1 +kk 1 +##may 1 +fan 1 +target 1 +use 1 +too 1 +338 1 +435 1 +2050 1 +867 1 +737 1 +fast 1 +##2c 1 +services 1 +##ope 1 +omega 1 +energy 1 +##わ 1 +pinkoi 1 +1a 1 +##なから 1 +##rain 1 +jackson 1 +##ement 1 +##シャンルの 1 +374 1 +366 1 +そんな 1 +p9 1 +rd 1 +##ᆨ 1 +1111 1 +##tier 1 +##vic 1 +zone 1 +##│ 1 +385 1 +690 1 +dl 1 +isofix 1 +cpa 1 +m4 1 +322 1 +kimi 1 +めて 1 +davis 1 +##lay 1 +lulu 1 +##uck 1 +050 1 +weeks 1 +qs 1 +##hop 1 +920 1 +##ｎ 1 +ae 1 +##ear 1 +～5 1 +eia 1 +405 1 +##fly 1 +korea 1 +jpeg 1 +boost 1 +##ship 1 +small 1 +##リア 1 +1860 1 +eur 1 +297 1 +425 1 +valley 1 +##iel 1 +simple 1 +##ude 1 +rn 1 +k2 1 +##ena 1 +されます 1 +non 1 +patrick 1 +しているから 1 +##ナー 1 +feed 1 +5757 1 +30g 1 +process 1 +well 1 +qqmei 1 +##thing 1 +they 1 +aws 1 +lu 1 +pink 1 +##ters 1 +##kin 1 +または 1 +board 1 +##vertisement 1 +wine 1 +##ien 1 +unicode 1 +##dge 1 +r1 1 +359 1 +##tant 1 +いを 1 +##twitter 1 +##3c 1 +cool1 1 +される 1 +##れて 1 +##ｌ 1 +isp 1 +##012 1 +standard 1 +45㎡2 1 +402 1 +##150 1 +matt 1 +##fu 1 +326 1 +##iner 1 +googlemsn 1 +pixnetfacebookyahoo 1 +##ラン 1 +x7 1 +886 1 +##uce 1 +メーカー 1 +sao 1 +##ev 1 +##きました 1 +##file 1 +9678 1 +403 1 +xddd 1 +shirt 1 +6l 1 +##rio 1 +##hat 1 +3mm 1 +givenchy 1 +ya 1 +bang 1 +##lio 1 +monday 1 +crystal 1 +ロクイン 1 +##abc 1 +336 1 +head 1 +890 1 +ubuntuforumwikilinuxpastechat 1 +##vc 1 +##～20 1 +##rity 1 +cnc 1 +7866 1 +ipv6 1 +null 1 +1897 1 +##ost 1 +yang 1 +imsean 1 +tiger 1 +##fet 1 +##ンス 1 +352 1 +##＝ 1 +dji 1 +327 1 +ji 1 +maria 1 +##come 1 +##んて 1 +foundation 1 +3100 1 +##beth 1 +##なった 1 +1m 1 +601 1 +active 1 +##aft 1 +##don 1 +3p 1 +sr 1 +349 1 +emma 1 +##khz 1 +living 1 +415 1 +353 1 +1889 1 +341 1 +709 1 +457 1 +sas 1 +x6 1 +##face 1 +pptv 1 +x4 1 +##mate 1 +han 1 +sophie 1 +##jing 1 +337 1 +fifa 1 +##mand 1 +other 1 +sale 1 +inwedding 1 +##gn 1 +てきちゃいます 1 +##mmy 1 +##pmlast 1 +bad 1 +nana 1 +nbc 1 +してみてくたさいね 1 +なとはお 1 +##wu 1 +##かあります 1 +##あ 1 +note7 1 +single 1 +##340 1 +せからこ 1 +してくたさい♪この 1 +しにはとんとんワークケートを 1 +するとあなたにもっとマッチした 1 +ならワークケートへ 1 +もみつかっちゃうかも 1 +ワークケートの 1 +##bel 1 +window 1 +##dio 1 +##ht 1 +union 1 +age 1 +382 1 +１４ 1 +##ivity 1 +##ｙ 1 +コメント 1 +domain 1 +neo 1 +##isa 1 +##lter 1 +5k 1 +f5 1 +steven 1 +##cts 1 +powerpoint 1 +tft 1 +self 1 +g2 1 +ft 1 +##テル 1 +zol 1 +##act 1 +mwc 1 +381 1 +343 1 +もう 1 +nbapop 1 +408 1 +てある 1 +eds 1 +ace 1 +##room 1 +previous 1 +author 1 +tomtom 1 +il 1 +##ets 1 +hu 1 +financial 1 +☆☆☆ 1 +っています 1 +bp 1 +5t 1 +chi 1 +1gb 1 +##hg 1 +fairmont 1 +cross 1 +008 1 +gay 1 +h2 1 +function 1 +##けて 1 +356 1 +also 1 +1b 1 +625 1 +##ータ 1 +##raph 1 +1894 1 +3～5 1 +##ils 1 +i3 1 +334 1 +avenue 1 +##host 1 +による 1 +##bon 1 +##tsu 1 +message 1 +navigation 1 +50g 1 +fintech 1 +h6 1 +##ことを 1 +8cm 1 +##ject 1 +##vas 1 +##firm 1 +credit 1 +##wf 1 +xxxx 1 +form 1 +##nor 1 +##space 1 +huawei 1 +plan 1 +json 1 +sbl 1 +##dc 1 +machine 1 +921 1 +392 1 +wish 1 +##120 1 +##sol 1 +windows7 1 +edward 1 +##ために 1 +development 1 +washington 1 +##nsis 1 +lo 1 +818 1 +##sio 1 +##ym 1 +##bor 1 +planet 1 +##～8 1 +##wt 1 +ieee 1 +gpa 1 +##めて 1 +camp 1 +ann 1 +gm 1 +##tw 1 +##oka 1 +connect 1 +##rss 1 +##work 1 +##atus 1 +wall 1 +chicken 1 +soul 1 +2mm 1 +##times 1 +fa 1 +##ather 1 +##cord 1 +009 1 +##eep 1 +hitachi 1 +gui 1 +harry 1 +##pan 1 +e1 1 +disney 1 +##press 1 +##ーション 1 +wind 1 +386 1 +frigidaire 1 +##tl 1 +liu 1 +hsu 1 +332 1 +basic 1 +von 1 +ev 1 +いた 1 +てきる 1 +スホンサーサイト 1 +learning 1 +##ull 1 +expedia 1 +archives 1 +change 1 +##wei 1 +santa 1 +cut 1 +ins 1 +6gb 1 +turbo 1 +brand 1 +cf1 1 +508 1 +004 1 +return 1 +747 1 +##rip 1 +h1 1 +##nis 1 +##をこ 1 +128gb 1 +##にお 1 +3t 1 +application 1 +しており 1 +emc 1 +rx 1 +##oon 1 +384 1 +quick 1 +412 1 +15058 1 +wilson 1 +wing 1 +chapter 1 +##bug 1 +beyond 1 +##cms 1 +##dar 1 +##oh 1 +zoom 1 +e2 1 +trip 1 +sb 1 +##nba 1 +rcep 1 +342 1 +aspx 1 +ci 1 +080 1 +gc 1 +gnu 1 +める 1 +##count 1 +advanced 1 +dance 1 +dv 1 +##url 1 +##ging 1 +367 1 +8591 1 +am09 1 +shadow 1 +battle 1 +346 1 +##ｉ 1 +##cia 1 +##という 1 +emily 1 +##のてす 1 +##tation 1 +host 1 +ff 1 +techorz 1 +sars 1 +##mini 1 +##mporary 1 +##ering 1 +nc 1 +4200 1 +798 1 +##next 1 +cma 1 +##mbps 1 +##gas 1 +##ift 1 +##dot 1 +##ィ 1 +455 1 +##～17 1 +amana 1 +##りの 1 +426 1 +##ros 1 +ir 1 +00㎡1 1 +##eet 1 +##ible 1 +##↓ 1 +710 1 +ˋ▽ˊ 1 +##aka 1 +dcs 1 +iq 1 +##ｖ 1 +l1 1 +##lor 1 +maggie 1 +##011 1 +##iu 1 +588 1 +##～1 1 +830 1 +##gt 1 +1tb 1 +articles 1 +create 1 +##burg 1 +##iki 1 +database 1 +fantasy 1 +##rex 1 +##cam 1 +dlc 1 +dean 1 +##you 1 +hard 1 +path 1 +gaming 1 +victoria 1 +maps 1 +cb 1 +##lee 1 +##itor 1 +overchicstoretvhome 1 +systems 1 +##xt 1 +416 1 +p3 1 +sarah 1 +760 1 +##nan 1 +407 1 +486 1 +x9 1 +install 1 +second 1 +626 1 +##ann 1 +##ph 1 +##rcle 1 +##nic 1 +860 1 +##nar 1 +ec 1 +##とう 1 +768 1 +metro 1 +chocolate 1 +##rian 1 +～4 1 +##table 1 +##しています 1 +skin 1 +##sn 1 +395 1 +mountain 1 +##0mm 1 +inparadise 1 +6m 1 +7x24 1 +ib 1 +4800 1 +##jia 1 +eeworld 1 +creative 1 +g5 1 +g3 1 +357 1 +parker 1 +ecfa 1 +village 1 +からの 1 +18000 1 +sylvia 1 +サーヒス 1 +hbl 1 +##ques 1 +##onsored 1 +##x2 1 +##きます 1 +##v4 1 +##tein 1 +ie6 1 +383 1 +##stack 1 +389 1 +ver 1 +##ads 1 +##baby 1 +sound 1 +bbe 1 +##110 1 +##lone 1 +##uid 1 +ads 1 +022 1 +gundam 1 +351 1 +thinkpad 1 +006 1 +scrum 1 +match 1 +##ave 1 +mems 1 +##470 1 +##oy 1 +##なりました 1 +##talk 1 +glass 1 +lamigo 1 +span 1 +##eme 1 +job 1 +##a5 1 +jay 1 +wade 1 +kde 1 +498 1 +##lace 1 +ocean 1 +tvg 1 +##covery 1 +##r3 1 +##ners 1 +##rea 1 +junior 1 +think 1 +##aine 1 +cover 1 +##ision 1 +##sia 1 +↓↓ 1 +##bow 1 +msi 1 +413 1 +458 1 +406 1 +##love 1 +711 1 +801 1 +soft 1 +z2 1 +##pl 1 +456 1 +1840 1 +mobil 1 +mind 1 +##uy 1 +427 1 +nginx 1 +##oi 1 +めた 1 +##rr 1 +6221 1 +##mple 1 +##sson 1 +##ーシてす 1 +371 1 +##nts 1 +91tv 1 +comhd 1 +crv3000 1 +##uard 1 +1868 1 +397 1 +deep 1 +lost 1 +field 1 +gallery 1 +##bia 1 +rate 1 +spf 1 +redis 1 +traction 1 +930 1 +icloud 1 +011 1 +なら 1 +fe 1 +jose 1 +372 1 +##tory 1 +into 1 +sohu 1 +fx 1 +899 1 +379 1 +kicstart2 1 +##hia 1 +すく 1 +##～3 1 +##sit 1 +ra 1 +２４ 1 +##walk 1 +##xure 1 +500g 1 +##pact 1 +pacific 1 +xa 1 +natural 1 +carlo 1 +##250 1 +##walker 1 +1850 1 +##can 1 +cto 1 +gigi 1 +516 1 +##サー 1 +pen 1 +##hoo 1 +ob 1 +matlab 1 +##ｂ 1 +##yy 1 +13913459 1 +##iti 1 +mango 1 +##bbs 1 +sense 1 +c5 1 +oxford 1 +##ニア 1 +walker 1 +jennifer 1 +##ola 1 +course 1 +##bre 1 +701 1 +##pus 1 +##rder 1 +lucky 1 +075 1 +##ぁ 1 +ivy 1 +なお 1 +##nia 1 +sotheby 1 +side 1 +##ugh 1 +joy 1 +##orage 1 +##ush 1 +##bat 1 +##dt 1 +364 1 +r9 1 +##2d 1 +##gio 1 +511 1 +country 1 +wear 1 +##lax 1 +##～7 1 +##moon 1 +393 1 +seven 1 +study 1 +411 1 +348 1 +lonzo 1 +8k 1 +##ェ 1 +evolution 1 +##イフ 1 +##kk 1 +gs 1 +kd 1 +##レス 1 +arduino 1 +344 1 +b12 1 +##lux 1 +arpg 1 +##rdon 1 +cook 1 +##x5 1 +dark 1 +five 1 +##als 1 +##ida 1 +とても 1 +sign 1 +362 1 +##ちの 1 +something 1 +20mm 1 +##nda 1 +387 1 +##posted 1 +fresh 1 +tf 1 +1870 1 +422 1 +cam 1 +##mine 1 +##skip 1 +##form 1 +##ssion 1 +education 1 +394 1 +##tee 1 +dyson 1 +stage 1 +##jie 1 +want 1 +##night 1 +epson 1 +pack 1 +あります 1 +##ppy 1 +テリヘル 1 +##█ 1 +wd 1 +##eh 1 +##rence 1 +left 1 +##lvin 1 +golden 1 +mhz 1 +discovery 1 +##trix 1 +##n2 1 +loft 1 +##uch 1 +##dra 1 +##sse 1 +speed 1 +～1 1 +1mdb 1 +sorry 1 +welcome 1 +##urn 1 +wave 1 +gaga 1 +##lmer 1 +teddy 1 +##160 1 +トラックハック 1 +せよ 1 +611 1 +##f2016 1 +378 1 +rp 1 +##sha 1 +rar 1 +##あなたに 1 +##きた 1 +840 1 +holiday 1 +##ュー 1 +373 1 +074 1 +##vg 1 +##nos 1 +##rail 1 +gartner 1 +gi 1 +6p 1 +##dium 1 +kit 1 +488 1 +b3 1 +eco 1 +##ろう 1 +20g 1 +sean 1 +##stone 1 +autocad 1 +nu 1 +##np 1 +f16 1 +write 1 +029 1 +m5 1 +##ias 1 +images 1 +atp 1 +##dk 1 +fsm 1 +504 1 +1350 1 +ve 1 +52kb 1 +##xxx 1 +##のに 1 +##cake 1 +414 1 +unit 1 +lim 1 +ru 1 +1v 1 +##ification 1 +published 1 +angela 1 +16g 1 +analytics 1 +ak 1 +##ｑ 1 +##nel 1 +gmt 1 +##icon 1 +again 1 +##₂ 1 +##bby 1 +ios11 1 +445 1 +かこさいます 1 +waze 1 +いてす 1 +##ハ 1 +9985 1 +##ust 1 +##ティー 1 +framework 1 +##007 1 +iptv 1 +delete 1 +52sykb 1 +cl 1 +wwdc 1 +027 1 +30cm 1 +##fw 1 +##ての 1 +1389 1 +##xon 1 +brandt 1 +##ses 1 +##dragon 1 +tc 1 +vetements 1 +anne 1 +monte 1 +modern 1 +official 1 +##へて 1 +##ere 1 +##nne 1 +##oud 1 +もちろん 1 +５０ 1 +etnews 1 +##a2 1 +##graphy 1 +421 1 +863 1 +##ちゃん 1 +444 1 +##rtex 1 +##てお 1 +l2 1 +##gma 1 +mount 1 +ccd 1 +たと 1 +archive 1 +morning 1 +tan 1 +ddos 1 +e7 1 +##ホ 1 +day4 1 +##ウ 1 +gis 1 +453 1 +its 1 +495 1 +factory 1 +bruce 1 +pg 1 +##ito 1 +ってくたさい 1 +guest 1 +cdma 1 +##lling 1 +536 1 +n3 1 +しかし 1 +3～4 1 +mega 1 +eyes 1 +ro 1 +１３ 1 +women 1 +dac 1 +church 1 +##jun 1 +singapore 1 +##facebook 1 +6991 1 +starbucks 1 +##tos 1 +##stin 1 +##shine 1 +zen 1 +##mu 1 +tina 1 +20℃ 1 +1893 1 +##たけて 1 +503 1 +465 1 +request 1 +##gence 1 +qt 1 +##っ 1 +1886 1 +347 1 +363 1 +q7 1 +##zzi 1 +diary 1 +##tore 1 +409 1 +##ead 1 +468 1 +cst 1 +##osa 1 +canada 1 +agent 1 +va 1 +##jiang 1 +##ちは 1 +##ーク 1 +##lam 1 +sg 1 +##nix 1 +##sday 1 +##よって 1 +g6 1 +##master 1 +bing 1 +##zl 1 +charlie 1 +１６ 1 +8mm 1 +nb40 1 +##ーン 1 +thai 1 +##ルフ 1 +ln284ct 1 +##itz 1 +##2f 1 +bonnie 1 +##food 1 +##lent 1 +originals 1 +##stro 1 +##lts 1 +418 1 +∟∣ 1 +##bscribe 1 +children 1 +ntd 1 +yesstyle 1 +##かも 1 +hmv 1 +##tment 1 +d5 1 +2cm 1 +arts 1 +sms 1 +##pn 1 +##я 1 +##いい 1 +topios9 1 +539 1 +lifestyle 1 +virtual 1 +##ague 1 +xz 1 +##deo 1 +muji 1 +024 1 +unt 1 +##nnis 1 +##ᅩ 1 +faq1 1 +1884 1 +396 1 +##ette 1 +fly 1 +64㎡ 1 +はしめまして 1 +441 1 +curry 1 +##pop 1 +のこ 1 +release 1 +##← 1 +##◆◆ 1 +##cast 1 +073 1 +ありな 1 +500ml 1 +##ews 1 +5c 1 +##stle 1 +ios7 1 +##ima 1 +787 1 +dog 1 +lenovo 1 +##r4 1 +roger 1 +013 1 +cbs 1 +vornado 1 +100m 1 +417 1 +##desk 1 +##クok 1 +##ald 1 +1867 1 +9595 1 +2900 1 +##van 1 +oil 1 +##ｘ 1 +some 1 +break 1 +common 1 +##jy 1 +##lines 1 +g7 1 +twice 1 +419 1 +ella 1 +nano 1 +belle 1 +にこ 1 +##mes 1 +##self 1 +##note 1 +jb 1 +##ことかてきます 1 +benz 1 +##との 1 +##ova 1 +451 1 +save 1 +##wing 1 +##ますのて 1 +kai 1 +りは 1 +##hua 1 +##rect 1 +rainer 1 +##unge 1 +448 1 +##0m 1 +adsl 1 +##かな 1 +guestname 1 +##uma 1 +##kins 1 +##zu 1 +tokichoi 1 +##price 1 +county 1 +##med 1 +##mus 1 +rmk 1 +391 1 +address 1 +vm 1 +えて 1 +openload 1 +##group 1 +##hin 1 +##iginal 1 +amg 1 +urban 1 +##oz 1 +jobs 1 +emi 1 +##public 1 +beautiful 1 +##sch 1 +album 1 +##dden 1 +##bell 1 +jerry 1 +works 1 +hostel 1 +miller 1 +##drive 1 +##rmin 1 +##１０ 1 +376 1 +boot 1 +828 1 +##370 1 +##fx 1 +##cm～ 1 +1885 1 +##nome 1 +##ctionary 1 +##oman 1 +##lish 1 +##cr 1 +##hm 1 +433 1 +##how 1 +432 1 +francis 1 +xi 1 +c919 1 +b5 1 +evernote 1 +##uc 1 +vga 1 +##3000 1 +coupe 1 +##urg 1 +##cca 1 +##uality 1 +019 1 +6g 1 +れる 1 +multi 1 +##また 1 +##ett 1 +em 1 +hey 1 +##ani 1 +##tax 1 +##rma 1 +inside 1 +than 1 +740 1 +leonnhurt 1 +##jin 1 +ict 1 +れた 1 +bird 1 +notes 1 +200mm 1 +くの 1 +##dical 1 +##lli 1 +result 1 +442 1 +iu 1 +ee 1 +438 1 +smap 1 +gopro 1 +##last 1 +yin 1 +pure 1 +998 1 +32g 1 +けた 1 +5kg 1 +##dan 1 +##rame 1 +mama 1 +##oot 1 +bean 1 +marketing 1 +##hur 1 +2l 1 +bella 1 +sync 1 +xuite 1 +##ground 1 +515 1 +discuz 1 +##getrelax 1 +##ince 1 +##bay 1 +##5s 1 +cj 1 +##イス 1 +gmat 1 +apt 1 +##pass 1 +jing 1 +##rix 1 +c4 1 +rich 1 +##とても 1 +niusnews 1 +##ello 1 +bag 1 +770 1 +##eting 1 +##mobile 1 +１８ 1 +culture 1 +015 1 +##のてすか 1 +377 1 +1020 1 +area 1 +##ience 1 +616 1 +details 1 +gp 1 +universal 1 +silver 1 +dit 1 +はお 1 +private 1 +ddd 1 +u11 1 +kanshu 1 +##ified 1 +fung 1 +##nny 1 +dx 1 +##520 1 +tai 1 +475 1 +023 1 +##fr 1 +##lean 1 +3s 1 +##pin 1 +429 1 +##rin 1 +25000 1 +ly 1 +rick 1 +##bility 1 +usb3 1 +banner 1 +##baru 1 +##gion 1 +metal 1 +dt 1 +vdf 1 +1871 1 +karl 1 +qualcomm 1 +bear 1 +1010 1 +oldid 1 +ian 1 +jo 1 +##tors 1 +population 1 +##ernel 1 +1882 1 +mmorpg 1 +##mv 1 +##bike 1 +603 1 +##© 1 +ww 1 +friend 1 +##ager 1 +exhibition 1 +##del 1 +##pods 1 +fpx 1 +structure 1 +##free 1 +##tings 1 +kl 1 +##rley 1 +##copyright 1 +##mma 1 +california 1 +3400 1 +orange 1 +yoga 1 +4l 1 +canmake 1 +honey 1 +##anda 1 +##コメント 1 +595 1 +nikkie 1 +##ルハイト 1 +dhl 1 +publishing 1 +##mall 1 +##gnet 1 +20cm 1 +513 1 +##クセス 1 +##┅ 1 +e88 1 +970 1 +##dog 1 +fishbase 1 +##! 1 +##" 1 +### 1 +##$ 1 +##% 1 +##& 1 +##' 1 +##( 1 +##) 1 +##* 1 +##+ 1 +##, 1 +##- 1 +##. 1 +##/ 1 +##: 1 +##; 1 +##< 1 +##= 1 +##> 1 +##? 1 +##@ 1 +##[ 1 +##\ 1 +##] 1 +##^ 1 +##_ 1 +##{ 1 +##| 1 +##} 1 +##~ 1 +##£ 1 +##¤ 1 +##¥ 1 +##§ 1 +##« 1 +##± 1 +##³ 1 +##µ 1 +##· 1 +##¹ 1 +##º 1 +##» 1 +##¼ 1 +##ß 1 +##æ 1 +##÷ 1 +##ø 1 +##đ 1 +##ŋ 1 +##ɔ 1 +##ə 1 +##ɡ 1 +##ʰ 1 +##ˇ 1 +##ˈ 1 +##ˊ 1 +##ˋ 1 +##ˍ 1 +##ː 1 +##˙ 1 +##˚ 1 +##ˢ 1 +##α 1 +##β 1 +##γ 1 +##δ 1 +##ε 1 +##η 1 +##θ 1 +##ι 1 +##κ 1 +##λ 1 +##μ 1 +##ν 1 +##ο 1 +##π 1 +##ρ 1 +##ς 1 +##σ 1 +##τ 1 +##υ 1 +##φ 1 +##χ 1 +##ψ 1 +##б 1 +##в 1 +##г 1 +##д 1 +##е 1 +##ж 1 +##з 1 +##к 1 +##л 1 +##м 1 +##н 1 +##о 1 +##п 1 +##р 1 +##с 1 +##т 1 +##у 1 +##ф 1 +##х 1 +##ц 1 +##ч 1 +##ш 1 +##ы 1 +##ь 1 +##і 1 +##ا 1 +##ب 1 +##ة 1 +##ت 1 +##د 1 +##ر 1 +##س 1 +##ع 1 +##ل 1 +##م 1 +##ن 1 +##ه 1 +##و 1 +##ي 1 +##۩ 1 +##ก 1 +##ง 1 +##น 1 +##ม 1 +##ย 1 +##ร 1 +##อ 1 +##า 1 +##เ 1 +##๑ 1 +##་ 1 +##ღ 1 +##ᄀ 1 +##ᄁ 1 +##ᄂ 1 +##ᄃ 1 +##ᄅ 1 +##ᄆ 1 +##ᄇ 1 +##ᄈ 1 +##ᄉ 1 +##ᄋ 1 +##ᄌ 1 +##ᄎ 1 +##ᄏ 1 +##ᄐ 1 +##ᄑ 1 +##ᄒ 1 +##ᅢ 1 +##ᅣ 1 +##ᅥ 1 +##ᅦ 1 +##ᅧ 1 +##ᅨ 1 +##ᅪ 1 +##ᅬ 1 +##ᅭ 1 +##ᅮ 1 +##ᅯ 1 +##ᅲ 1 +##ᅳ 1 +##ᅴ 1 +##ᆷ 1 +##ᆸ 1 +##ᆺ 1 +##ᆻ 1 +##ᗜ 1 +##ᵃ 1 +##ᵉ 1 +##ᵍ 1 +##ᵏ 1 +##ᵐ 1 +##ᵒ 1 +##ᵘ 1 +##‖ 1 +##„ 1 +##† 1 +##• 1 +##‥ 1 +##‧ 1 +## 1 +##‰ 1 +##′ 1 +##″ 1 +##‹ 1 +##› 1 +##※ 1 +##‿ 1 +##⁄ 1 +##ⁱ 1 +##⁺ 1 +##ⁿ 1 +##₁ 1 +##₃ 1 +##₄ 1 +##€ 1 +##№ 1 +##ⅰ 1 +##ⅱ 1 +##ⅲ 1 +##ⅳ 1 +##ⅴ 1 +##↔ 1 +##↗ 1 +##↘ 1 +##⇒ 1 +##∀ 1 +##− 1 +##∕ 1 +##∙ 1 +##√ 1 +##∞ 1 +##∟ 1 +##∠ 1 +##∣ 1 +##∩ 1 +##∮ 1 +##∶ 1 +##∼ 1 +##∽ 1 +##≈ 1 +##≒ 1 +##≡ 1 +##≤ 1 +##≥ 1 +##≦ 1 +##≧ 1 +##≪ 1 +##≫ 1 +##⊙ 1 +##⋅ 1 +##⋈ 1 +##⋯ 1 +##⌒ 1 +##① 1 +##② 1 +##③ 1 +##④ 1 +##⑤ 1 +##⑥ 1 +##⑦ 1 +##⑧ 1 +##⑨ 1 +##⑩ 1 +##⑴ 1 +##⑵ 1 +##⑶ 1 +##⑷ 1 +##⑸ 1 +##⒈ 1 +##⒉ 1 +##⒊ 1 +##⒋ 1 +##ⓒ 1 +##ⓔ 1 +##ⓘ 1 +##━ 1 +##┃ 1 +##┆ 1 +##┊ 1 +##┌ 1 +##└ 1 +##├ 1 +##┣ 1 +##═ 1 +##║ 1 +##╚ 1 +##╞ 1 +##╠ 1 +##╭ 1 +##╮ 1 +##╯ 1 +##╰ 1 +##╱ 1 +##╳ 1 +##▂ 1 +##▃ 1 +##▅ 1 +##▇ 1 +##▉ 1 +##▋ 1 +##▌ 1 +##▍ 1 +##▎ 1 +##□ 1 +##▪ 1 +##▫ 1 +##▬ 1 +##△ 1 +##▶ 1 +##► 1 +##▽ 1 +##◇ 1 +##◕ 1 +##◠ 1 +##◢ 1 +##◤ 1 +##☀ 1 +##☕ 1 +##☞ 1 +##☺ 1 +##☼ 1 +##♀ 1 +##♂ 1 +##♠ 1 +##♡ 1 +##♣ 1 +##♦ 1 +##♫ 1 +##♬ 1 +##✈ 1 +##✔ 1 +##✕ 1 +##✖ 1 +##✦ 1 +##✨ 1 +##✪ 1 +##✰ 1 +##✿ 1 +##❀ 1 +##➜ 1 +##➤ 1 +##⦿ 1 +##、 1 +##。 1 +##〃 1 +##々 1 +##〇 1 +##〈 1 +##〉 1 +##《 1 +##》 1 +##「 1 +##」 1 +##『 1 +##』 1 +##【 1 +##】 1 +##〓 1 +##〔 1 +##〕 1 +##〖 1 +##〗 1 +##〜 1 +##〝 1 +##〞 1 +##ぃ 1 +##ぇ 1 +##ぬ 1 +##ふ 1 +##ほ 1 +##む 1 +##ゃ 1 +##ゅ 1 +##ゆ 1 +##ょ 1 +##゜ 1 +##ゝ 1 +##ァ 1 +##ゥ 1 +##エ 1 +##ォ 1 +##ケ 1 +##サ 1 +##セ 1 +##ソ 1 +##ッ 1 +##ニ 1 +##ヌ 1 +##ネ 1 +##ノ 1 +##ヘ 1 +##モ 1 +##ャ 1 +##ヤ 1 +##ュ 1 +##ユ 1 +##ョ 1 +##ヨ 1 +##ワ 1 +##ヲ 1 +##・ 1 +##ヽ 1 +##ㄅ 1 +##ㄆ 1 +##ㄇ 1 +##ㄉ 1 +##ㄋ 1 +##ㄌ 1 +##ㄍ 1 +##ㄎ 1 +##ㄏ 1 +##ㄒ 1 +##ㄚ 1 +##ㄛ 1 +##ㄞ 1 +##ㄟ 1 +##ㄢ 1 +##ㄤ 1 +##ㄥ 1 +##ㄧ 1 +##ㄨ 1 +##ㆍ 1 +##㈦ 1 +##㊣ 1 +##㗎 1 +##一 1 +##丁 1 +##七 1 +##万 1 +##丈 1 +##三 1 +##上 1 +##下 1 +##不 1 +##与 1 +##丐 1 +##丑 1 +##专 1 +##且 1 +##丕 1 +##世 1 +##丘 1 +##丙 1 +##业 1 +##丛 1 +##东 1 +##丝 1 +##丞 1 +##丟 1 +##両 1 +##丢 1 +##两 1 +##严 1 +##並 1 +##丧 1 +##丨 1 +##个 1 +##丫 1 +##中 1 +##丰 1 +##串 1 +##临 1 +##丶 1 +##丸 1 +##丹 1 +##为 1 +##主 1 +##丼 1 +##丽 1 +##举 1 +##丿 1 +##乂 1 +##乃 1 +##久 1 +##么 1 +##义 1 +##之 1 +##乌 1 +##乍 1 +##乎 1 +##乏 1 +##乐 1 +##乒 1 +##乓 1 +##乔 1 +##乖 1 +##乗 1 +##乘 1 +##乙 1 +##乜 1 +##九 1 +##乞 1 +##也 1 +##习 1 +##乡 1 +##书 1 +##乩 1 +##买 1 +##乱 1 +##乳 1 +##乾 1 +##亀 1 +##亂 1 +##了 1 +##予 1 +##争 1 +##事 1 +##二 1 +##于 1 +##亏 1 +##云 1 +##互 1 +##五 1 +##井 1 +##亘 1 +##亙 1 +##亚 1 +##些 1 +##亜 1 +##亞 1 +##亟 1 +##亡 1 +##亢 1 +##交 1 +##亥 1 +##亦 1 +##产 1 +##亨 1 +##亩 1 +##享 1 +##京 1 +##亭 1 +##亮 1 +##亲 1 +##亳 1 +##亵 1 +##人 1 +##亿 1 +##什 1 +##仁 1 +##仃 1 +##仄 1 +##仅 1 +##仆 1 +##仇 1 +##今 1 +##介 1 +##仍 1 +##从 1 +##仏 1 +##仑 1 +##仓 1 +##仔 1 +##仕 1 +##他 1 +##仗 1 +##付 1 +##仙 1 +##仝 1 +##仞 1 +##仟 1 +##代 1 +##令 1 +##以 1 +##仨 1 +##仪 1 +##们 1 +##仮 1 +##仰 1 +##仲 1 +##件 1 +##价 1 +##任 1 +##份 1 +##仿 1 +##企 1 +##伉 1 +##伊 1 +##伍 1 +##伎 1 +##伏 1 +##伐 1 +##休 1 +##伕 1 +##众 1 +##优 1 +##伙 1 +##会 1 +##伝 1 +##伞 1 +##伟 1 +##传 1 +##伢 1 +##伤 1 +##伦 1 +##伪 1 +##伫 1 +##伯 1 +##估 1 +##伴 1 +##伶 1 +##伸 1 +##伺 1 +##似 1 +##伽 1 +##佃 1 +##但 1 +##佇 1 +##佈 1 +##位 1 +##低 1 +##住 1 +##佐 1 +##佑 1 +##体 1 +##佔 1 +##何 1 +##佗 1 +##佘 1 +##余 1 +##佚 1 +##佛 1 +##作 1 +##佝 1 +##佞 1 +##佟 1 +##你 1 +##佢 1 +##佣 1 +##佤 1 +##佥 1 +##佩 1 +##佬 1 +##佯 1 +##佰 1 +##佳 1 +##併 1 +##佶 1 +##佻 1 +##佼 1 +##使 1 +##侃 1 +##侄 1 +##來 1 +##侈 1 +##例 1 +##侍 1 +##侏 1 +##侑 1 +##侖 1 +##侗 1 +##供 1 +##依 1 +##侠 1 +##価 1 +##侣 1 +##侥 1 +##侦 1 +##侧 1 +##侨 1 +##侬 1 +##侮 1 +##侯 1 +##侵 1 +##侶 1 +##侷 1 +##便 1 +##係 1 +##促 1 +##俄 1 +##俊 1 +##俎 1 +##俏 1 +##俐 1 +##俑 1 +##俗 1 +##俘 1 +##俚 1 +##保 1 +##俞 1 +##俟 1 +##俠 1 +##信 1 +##俨 1 +##俩 1 +##俪 1 +##俬 1 +##俭 1 +##修 1 +##俯 1 +##俱 1 +##俳 1 +##俸 1 +##俺 1 +##俾 1 +##倆 1 +##倉 1 +##個 1 +##倌 1 +##倍 1 +##倏 1 +##們 1 +##倒 1 +##倔 1 +##倖 1 +##倘 1 +##候 1 +##倚 1 +##倜 1 +##借 1 +##倡 1 +##値 1 +##倦 1 +##倩 1 +##倪 1 +##倫 1 +##倬 1 +##倭 1 +##倶 1 +##债 1 +##值 1 +##倾 1 +##偃 1 +##假 1 +##偈 1 +##偉 1 +##偌 1 +##偎 1 +##偏 1 +##偕 1 +##做 1 +##停 1 +##健 1 +##側 1 +##偵 1 +##偶 1 +##偷 1 +##偻 1 +##偽 1 +##偿 1 +##傀 1 +##傅 1 +##傍 1 +##傑 1 +##傘 1 +##備 1 +##傚 1 +##傢 1 +##傣 1 +##傥 1 +##储 1 +##傩 1 +##催 1 +##傭 1 +##傲 1 +##傳 1 +##債 1 +##傷 1 +##傻 1 +##傾 1 +##僅 1 +##働 1 +##像 1 +##僑 1 +##僕 1 +##僖 1 +##僚 1 +##僥 1 +##僧 1 +##僭 1 +##僮 1 +##僱 1 +##僵 1 +##價 1 +##僻 1 +##儀 1 +##儂 1 +##億 1 +##儆 1 +##儉 1 +##儋 1 +##儒 1 +##儕 1 +##儘 1 +##償 1 +##儡 1 +##優 1 +##儲 1 +##儷 1 +##儼 1 +##儿 1 +##兀 1 +##允 1 +##元 1 +##兄 1 +##充 1 +##兆 1 +##兇 1 +##先 1 +##光 1 +##克 1 +##兌 1 +##免 1 +##児 1 +##兑 1 +##兒 1 +##兔 1 +##兖 1 +##党 1 +##兜 1 +##兢 1 +##入 1 +##內 1 +##全 1 +##兩 1 +##八 1 +##公 1 +##六 1 +##兮 1 +##兰 1 +##共 1 +##兲 1 +##关 1 +##兴 1 +##兵 1 +##其 1 +##具 1 +##典 1 +##兹 1 +##养 1 +##兼 1 +##兽 1 +##冀 1 +##内 1 +##円 1 +##冇 1 +##冈 1 +##冉 1 +##冊 1 +##册 1 +##再 1 +##冏 1 +##冒 1 +##冕 1 +##冗 1 +##写 1 +##军 1 +##农 1 +##冠 1 +##冢 1 +##冤 1 +##冥 1 +##冨 1 +##冪 1 +##冬 1 +##冯 1 +##冰 1 +##冲 1 +##决 1 +##况 1 +##冶 1 +##冷 1 +##冻 1 +##冼 1 +##冽 1 +##冾 1 +##净 1 +##凄 1 +##准 1 +##凇 1 +##凈 1 +##凉 1 +##凋 1 +##凌 1 +##凍 1 +##减 1 +##凑 1 +##凛 1 +##凜 1 +##凝 1 +##几 1 +##凡 1 +##凤 1 +##処 1 +##凪 1 +##凭 1 +##凯 1 +##凰 1 +##凱 1 +##凳 1 +##凶 1 +##凸 1 +##凹 1 +##出 1 +##击 1 +##函 1 +##凿 1 +##刀 1 +##刁 1 +##刃 1 +##分 1 +##切 1 +##刈 1 +##刊 1 +##刍 1 +##刎 1 +##刑 1 +##划 1 +##列 1 +##刘 1 +##则 1 +##刚 1 +##创 1 +##初 1 +##删 1 +##判 1 +##別 1 +##刨 1 +##利 1 +##刪 1 +##别 1 +##刮 1 +##到 1 +##制 1 +##刷 1 +##券 1 +##刹 1 +##刺 1 +##刻 1 +##刽 1 +##剁 1 +##剂 1 +##剃 1 +##則 1 +##剉 1 +##削 1 +##剋 1 +##剌 1 +##前 1 +##剎 1 +##剐 1 +##剑 1 +##剔 1 +##剖 1 +##剛 1 +##剜 1 +##剝 1 +##剣 1 +##剤 1 +##剥 1 +##剧 1 +##剩 1 +##剪 1 +##副 1 +##割 1 +##創 1 +##剷 1 +##剽 1 +##剿 1 +##劃 1 +##劇 1 +##劈 1 +##劉 1 +##劊 1 +##劍 1 +##劏 1 +##劑 1 +##力 1 +##劝 1 +##办 1 +##功 1 +##加 1 +##务 1 +##劣 1 +##动 1 +##助 1 +##努 1 +##劫 1 +##劭 1 +##励 1 +##劲 1 +##劳 1 +##労 1 +##劵 1 +##効 1 +##劾 1 +##势 1 +##勁 1 +##勃 1 +##勇 1 +##勉 1 +##勋 1 +##勐 1 +##勒 1 +##動 1 +##勖 1 +##勘 1 +##務 1 +##勛 1 +##勝 1 +##勞 1 +##募 1 +##勢 1 +##勤 1 +##勧 1 +##勳 1 +##勵 1 +##勸 1 +##勺 1 +##勻 1 +##勾 1 +##勿 1 +##匀 1 +##包 1 +##匆 1 +##匈 1 +##匍 1 +##匐 1 +##匕 1 +##化 1 +##北 1 +##匙 1 +##匝 1 +##匠 1 +##匡 1 +##匣 1 +##匪 1 +##匮 1 +##匯 1 +##匱 1 +##匹 1 +##区 1 +##医 1 +##匾 1 +##匿 1 +##區 1 +##十 1 +##千 1 +##卅 1 +##升 1 +##午 1 +##卉 1 +##半 1 +##卍 1 +##华 1 +##协 1 +##卑 1 +##卒 1 +##卓 1 +##協 1 +##单 1 +##卖 1 +##南 1 +##単 1 +##博 1 +##卜 1 +##卞 1 +##卟 1 +##占 1 +##卡 1 +##卢 1 +##卤 1 +##卦 1 +##卧 1 +##卫 1 +##卮 1 +##卯 1 +##印 1 +##危 1 +##即 1 +##却 1 +##卵 1 +##卷 1 +##卸 1 +##卻 1 +##卿 1 +##厂 1 +##厄 1 +##厅 1 +##历 1 +##厉 1 +##压 1 +##厌 1 +##厕 1 +##厘 1 +##厚 1 +##厝 1 +##原 1 +##厢 1 +##厥 1 +##厦 1 +##厨 1 +##厩 1 +##厭 1 +##厮 1 +##厲 1 +##厳 1 +##去 1 +##县 1 +##叁 1 +##参 1 +##參 1 +##又 1 +##叉 1 +##及 1 +##友 1 +##双 1 +##反 1 +##収 1 +##发 1 +##叔 1 +##取 1 +##受 1 +##变 1 +##叙 1 +##叛 1 +##叟 1 +##叠 1 +##叡 1 +##叢 1 +##口 1 +##古 1 +##句 1 +##另 1 +##叨 1 +##叩 1 +##只 1 +##叫 1 +##召 1 +##叭 1 +##叮 1 +##可 1 +##台 1 +##叱 1 +##史 1 +##右 1 +##叵 1 +##叶 1 +##号 1 +##司 1 +##叹 1 +##叻 1 +##叼 1 +##叽 1 +##吁 1 +##吃 1 +##各 1 +##吆 1 +##合 1 +##吉 1 +##吊 1 +##吋 1 +##同 1 +##名 1 +##后 1 +##吏 1 +##吐 1 +##向 1 +##吒 1 +##吓 1 +##吕 1 +##吖 1 +##吗 1 +##君 1 +##吝 1 +##吞 1 +##吟 1 +##吠 1 +##吡 1 +##否 1 +##吧 1 +##吨 1 +##吩 1 +##含 1 +##听 1 +##吭 1 +##吮 1 +##启 1 +##吱 1 +##吳 1 +##吴 1 +##吵 1 +##吶 1 +##吸 1 +##吹 1 +##吻 1 +##吼 1 +##吽 1 +##吾 1 +##呀 1 +##呂 1 +##呃 1 +##呆 1 +##呈 1 +##告 1 +##呋 1 +##呎 1 +##呐 1 +##呓 1 +##呕 1 +##呗 1 +##员 1 +##呛 1 +##呜 1 +##呢 1 +##呤 1 +##呦 1 +##周 1 +##呱 1 +##呲 1 +##味 1 +##呵 1 +##呷 1 +##呸 1 +##呻 1 +##呼 1 +##命 1 +##咀 1 +##咁 1 +##咂 1 +##咄 1 +##咆 1 +##咋 1 +##和 1 +##咎 1 +##咏 1 +##咐 1 +##咒 1 +##咔 1 +##咕 1 +##咖 1 +##咗 1 +##咘 1 +##咙 1 +##咚 1 +##咛 1 +##咣 1 +##咤 1 +##咦 1 +##咧 1 +##咨 1 +##咩 1 +##咪 1 +##咫 1 +##咬 1 +##咭 1 +##咯 1 +##咱 1 +##咲 1 +##咳 1 +##咸 1 +##咻 1 +##咽 1 +##咿 1 +##哀 1 +##品 1 +##哂 1 +##哄 1 +##哆 1 +##哇 1 +##哈 1 +##哉 1 +##哋 1 +##哌 1 +##响 1 +##哎 1 +##哏 1 +##哐 1 +##哑 1 +##哒 1 +##哔 1 +##哗 1 +##哟 1 +##員 1 +##哥 1 +##哦 1 +##哧 1 +##哨 1 +##哩 1 +##哪 1 +##哭 1 +##哮 1 +##哲 1 +##哺 1 +##哼 1 +##哽 1 +##唁 1 +##唄 1 +##唆 1 +##唇 1 +##唉 1 +##唏 1 +##唐 1 +##唑 1 +##唔 1 +##唠 1 +##唤 1 +##唧 1 +##唬 1 +##售 1 +##唯 1 +##唰 1 +##唱 1 +##唳 1 +##唷 1 +##唸 1 +##唾 1 +##啃 1 +##啄 1 +##商 1 +##啉 1 +##啊 1 +##問 1 +##啓 1 +##啕 1 +##啖 1 +##啜 1 +##啞 1 +##啟 1 +##啡 1 +##啤 1 +##啥 1 +##啦 1 +##啧 1 +##啪 1 +##啫 1 +##啬 1 +##啮 1 +##啰 1 +##啱 1 +##啲 1 +##啵 1 +##啶 1 +##啷 1 +##啸 1 +##啻 1 +##啼 1 +##啾 1 +##喀 1 +##喂 1 +##喃 1 +##善 1 +##喆 1 +##喇 1 +##喉 1 +##喊 1 +##喋 1 +##喎 1 +##喏 1 +##喔 1 +##喘 1 +##喙 1 +##喚 1 +##喜 1 +##喝 1 +##喟 1 +##喧 1 +##喪 1 +##喫 1 +##喬 1 +##單 1 +##喰 1 +##喱 1 +##喲 1 +##喳 1 +##喵 1 +##営 1 +##喷 1 +##喹 1 +##喺 1 +##喻 1 +##喽 1 +##嗅 1 +##嗆 1 +##嗇 1 +##嗎 1 +##嗑 1 +##嗒 1 +##嗓 1 +##嗔 1 +##嗖 1 +##嗚 1 +##嗜 1 +##嗝 1 +##嗟 1 +##嗡 1 +##嗣 1 +##嗤 1 +##嗦 1 +##嗨 1 +##嗪 1 +##嗬 1 +##嗯 1 +##嗰 1 +##嗲 1 +##嗳 1 +##嗶 1 +##嗷 1 +##嗽 1 +##嘀 1 +##嘅 1 +##嘆 1 +##嘈 1 +##嘉 1 +##嘌 1 +##嘍 1 +##嘎 1 +##嘔 1 +##嘖 1 +##嘗 1 +##嘘 1 +##嘚 1 +##嘛 1 +##嘜 1 +##嘞 1 +##嘟 1 +##嘢 1 +##嘣 1 +##嘤 1 +##嘧 1 +##嘩 1 +##嘭 1 +##嘮 1 +##嘯 1 +##嘰 1 +##嘱 1 +##嘲 1 +##嘴 1 +##嘶 1 +##嘸 1 +##嘹 1 +##嘻 1 +##嘿 1 +##噁 1 +##噌 1 +##噎 1 +##噓 1 +##噔 1 +##噗 1 +##噙 1 +##噜 1 +##噠 1 +##噢 1 +##噤 1 +##器 1 +##噩 1 +##噪 1 +##噬 1 +##噱 1 +##噴 1 +##噶 1 +##噸 1 +##噹 1 +##噻 1 +##噼 1 +##嚀 1 +##嚇 1 +##嚎 1 +##嚏 1 +##嚐 1 +##嚓 1 +##嚕 1 +##嚟 1 +##嚣 1 +##嚥 1 +##嚨 1 +##嚮 1 +##嚴 1 +##嚷 1 +##嚼 1 +##囂 1 +##囉 1 +##囊 1 +##囍 1 +##囑 1 +##囔 1 +##囗 1 +##囚 1 +##四 1 +##囝 1 +##回 1 +##囟 1 +##因 1 +##囡 1 +##团 1 +##団 1 +##囤 1 +##囧 1 +##囪 1 +##囫 1 +##园 1 +##困 1 +##囱 1 +##囲 1 +##図 1 +##围 1 +##囹 1 +##固 1 +##国 1 +##图 1 +##囿 1 +##圃 1 +##圄 1 +##圆 1 +##圈 1 +##國 1 +##圍 1 +##圏 1 +##園 1 +##圓 1 +##圖 1 +##團 1 +##圜 1 +##土 1 +##圣 1 +##圧 1 +##在 1 +##圩 1 +##圭 1 +##地 1 +##圳 1 +##场 1 +##圻 1 +##圾 1 +##址 1 +##坂 1 +##均 1 +##坊 1 +##坍 1 +##坎 1 +##坏 1 +##坐 1 +##坑 1 +##块 1 +##坚 1 +##坛 1 +##坝 1 +##坞 1 +##坟 1 +##坠 1 +##坡 1 +##坤 1 +##坦 1 +##坨 1 +##坪 1 +##坯 1 +##坳 1 +##坵 1 +##坷 1 +##垂 1 +##垃 1 +##垄 1 +##型 1 +##垒 1 +##垚 1 +##垛 1 +##垠 1 +##垢 1 +##垣 1 +##垦 1 +##垩 1 +##垫 1 +##垭 1 +##垮 1 +##垵 1 +##埂 1 +##埃 1 +##埋 1 +##城 1 +##埔 1 +##埕 1 +##埗 1 +##域 1 +##埠 1 +##埤 1 +##埵 1 +##執 1 +##埸 1 +##培 1 +##基 1 +##埼 1 +##堀 1 +##堂 1 +##堃 1 +##堅 1 +##堆 1 +##堇 1 +##堑 1 +##堕 1 +##堙 1 +##堡 1 +##堤 1 +##堪 1 +##堯 1 +##堰 1 +##報 1 +##場 1 +##堵 1 +##堺 1 +##堿 1 +##塊 1 +##塌 1 +##塑 1 +##塔 1 +##塗 1 +##塘 1 +##塚 1 +##塞 1 +##塢 1 +##塩 1 +##填 1 +##塬 1 +##塭 1 +##塵 1 +##塾 1 +##墀 1 +##境 1 +##墅 1 +##墉 1 +##墊 1 +##墒 1 +##墓 1 +##増 1 +##墘 1 +##墙 1 +##墜 1 +##增 1 +##墟 1 +##墨 1 +##墩 1 +##墮 1 +##墳 1 +##墻 1 +##墾 1 +##壁 1 +##壅 1 +##壆 1 +##壇 1 +##壊 1 +##壑 1 +##壓 1 +##壕 1 +##壘 1 +##壞 1 +##壟 1 +##壢 1 +##壤 1 +##壩 1 +##士 1 +##壬 1 +##壮 1 +##壯 1 +##声 1 +##売 1 +##壳 1 +##壶 1 +##壹 1 +##壺 1 +##壽 1 +##处 1 +##备 1 +##変 1 +##复 1 +##夏 1 +##夔 1 +##夕 1 +##外 1 +##夙 1 +##多 1 +##夜 1 +##够 1 +##夠 1 +##夢 1 +##夥 1 +##大 1 +##天 1 +##太 1 +##夫 1 +##夭 1 +##央 1 +##夯 1 +##失 1 +##头 1 +##夷 1 +##夸 1 +##夹 1 +##夺 1 +##夾 1 +##奂 1 +##奄 1 +##奇 1 +##奈 1 +##奉 1 +##奋 1 +##奎 1 +##奏 1 +##奐 1 +##契 1 +##奔 1 +##奕 1 +##奖 1 +##套 1 +##奘 1 +##奚 1 +##奠 1 +##奢 1 +##奥 1 +##奧 1 +##奪 1 +##奬 1 +##奮 1 +##女 1 +##奴 1 +##奶 1 +##奸 1 +##她 1 +##好 1 +##如 1 +##妃 1 +##妄 1 +##妆 1 +##妇 1 +##妈 1 +##妊 1 +##妍 1 +##妒 1 +##妓 1 +##妖 1 +##妘 1 +##妙 1 +##妝 1 +##妞 1 +##妣 1 +##妤 1 +##妥 1 +##妨 1 +##妩 1 +##妪 1 +##妮 1 +##妲 1 +##妳 1 +##妹 1 +##妻 1 +##妾 1 +##姆 1 +##姉 1 +##姊 1 +##始 1 +##姍 1 +##姐 1 +##姑 1 +##姒 1 +##姓 1 +##委 1 +##姗 1 +##姚 1 +##姜 1 +##姝 1 +##姣 1 +##姥 1 +##姦 1 +##姨 1 +##姪 1 +##姫 1 +##姬 1 +##姹 1 +##姻 1 +##姿 1 +##威 1 +##娃 1 +##娄 1 +##娅 1 +##娆 1 +##娇 1 +##娉 1 +##娑 1 +##娓 1 +##娘 1 +##娛 1 +##娜 1 +##娟 1 +##娠 1 +##娣 1 +##娥 1 +##娩 1 +##娱 1 +##娲 1 +##娴 1 +##娶 1 +##娼 1 +##婀 1 +##婁 1 +##婆 1 +##婉 1 +##婊 1 +##婕 1 +##婚 1 +##婢 1 +##婦 1 +##婧 1 +##婪 1 +##婭 1 +##婴 1 +##婵 1 +##婶 1 +##婷 1 +##婺 1 +##婿 1 +##媒 1 +##媚 1 +##媛 1 +##媞 1 +##媧 1 +##媲 1 +##媳 1 +##媽 1 +##媾 1 +##嫁 1 +##嫂 1 +##嫉 1 +##嫌 1 +##嫑 1 +##嫔 1 +##嫖 1 +##嫘 1 +##嫚 1 +##嫡 1 +##嫣 1 +##嫦 1 +##嫩 1 +##嫲 1 +##嫵 1 +##嫻 1 +##嬅 1 +##嬉 1 +##嬌 1 +##嬗 1 +##嬛 1 +##嬢 1 +##嬤 1 +##嬪 1 +##嬰 1 +##嬴 1 +##嬷 1 +##嬸 1 +##嬿 1 +##孀 1 +##孃 1 +##子 1 +##孑 1 +##孔 1 +##孕 1 +##孖 1 +##字 1 +##存 1 +##孙 1 +##孚 1 +##孛 1 +##孜 1 +##孝 1 +##孟 1 +##孢 1 +##季 1 +##孤 1 +##学 1 +##孩 1 +##孪 1 +##孫 1 +##孬 1 +##孰 1 +##孱 1 +##孳 1 +##孵 1 +##學 1 +##孺 1 +##孽 1 +##孿 1 +##宁 1 +##它 1 +##宅 1 +##宇 1 +##守 1 +##安 1 +##宋 1 +##完 1 +##宏 1 +##宓 1 +##宕 1 +##宗 1 +##官 1 +##宙 1 +##定 1 +##宛 1 +##宜 1 +##宝 1 +##实 1 +##実 1 +##宠 1 +##审 1 +##客 1 +##宣 1 +##室 1 +##宥 1 +##宦 1 +##宪 1 +##宫 1 +##宮 1 +##宰 1 +##害 1 +##宴 1 +##宵 1 +##家 1 +##宸 1 +##容 1 +##宽 1 +##宾 1 +##宿 1 +##寂 1 +##寄 1 +##寅 1 +##密 1 +##寇 1 +##富 1 +##寐 1 +##寒 1 +##寓 1 +##寛 1 +##寝 1 +##寞 1 +##察 1 +##寡 1 +##寢 1 +##寥 1 +##實 1 +##寧 1 +##寨 1 +##審 1 +##寫 1 +##寬 1 +##寮 1 +##寰 1 +##寵 1 +##寶 1 +##寸 1 +##对 1 +##寺 1 +##寻 1 +##导 1 +##対 1 +##寿 1 +##封 1 +##専 1 +##射 1 +##将 1 +##將 1 +##專 1 +##尉 1 +##尊 1 +##尋 1 +##對 1 +##導 1 +##小 1 +##少 1 +##尔 1 +##尕 1 +##尖 1 +##尘 1 +##尚 1 +##尝 1 +##尤 1 +##尧 1 +##尬 1 +##就 1 +##尴 1 +##尷 1 +##尸 1 +##尹 1 +##尺 1 +##尻 1 +##尼 1 +##尽 1 +##尾 1 +##尿 1 +##局 1 +##屁 1 +##层 1 +##屄 1 +##居 1 +##屆 1 +##屈 1 +##屉 1 +##届 1 +##屋 1 +##屌 1 +##屍 1 +##屎 1 +##屏 1 +##屐 1 +##屑 1 +##展 1 +##屜 1 +##属 1 +##屠 1 +##屡 1 +##屢 1 +##層 1 +##履 1 +##屬 1 +##屯 1 +##山 1 +##屹 1 +##屿 1 +##岀 1 +##岁 1 +##岂 1 +##岌 1 +##岐 1 +##岑 1 +##岔 1 +##岖 1 +##岗 1 +##岘 1 +##岙 1 +##岚 1 +##岛 1 +##岡 1 +##岩 1 +##岫 1 +##岬 1 +##岭 1 +##岱 1 +##岳 1 +##岷 1 +##岸 1 +##峇 1 +##峋 1 +##峒 1 +##峙 1 +##峡 1 +##峤 1 +##峥 1 +##峦 1 +##峨 1 +##峪 1 +##峭 1 +##峯 1 +##峰 1 +##峴 1 +##島 1 +##峻 1 +##峽 1 +##崁 1 +##崂 1 +##崆 1 +##崇 1 +##崎 1 +##崑 1 +##崔 1 +##崖 1 +##崗 1 +##崙 1 +##崛 1 +##崧 1 +##崩 1 +##崭 1 +##崴 1 +##崽 1 +##嵇 1 +##嵊 1 +##嵋 1 +##嵌 1 +##嵐 1 +##嵘 1 +##嵩 1 +##嵬 1 +##嵯 1 +##嶂 1 +##嶄 1 +##嶇 1 +##嶋 1 +##嶙 1 +##嶺 1 +##嶼 1 +##嶽 1 +##巅 1 +##巍 1 +##巒 1 +##巔 1 +##巖 1 +##川 1 +##州 1 +##巡 1 +##巢 1 +##工 1 +##左 1 +##巧 1 +##巨 1 +##巩 1 +##巫 1 +##差 1 +##己 1 +##已 1 +##巳 1 +##巴 1 +##巷 1 +##巻 1 +##巽 1 +##巾 1 +##巿 1 +##币 1 +##市 1 +##布 1 +##帅 1 +##帆 1 +##师 1 +##希 1 +##帐 1 +##帑 1 +##帕 1 +##帖 1 +##帘 1 +##帚 1 +##帛 1 +##帜 1 +##帝 1 +##帥 1 +##带 1 +##帧 1 +##師 1 +##席 1 +##帮 1 +##帯 1 +##帰 1 +##帳 1 +##帶 1 +##帷 1 +##常 1 +##帼 1 +##帽 1 +##幀 1 +##幂 1 +##幄 1 +##幅 1 +##幌 1 +##幔 1 +##幕 1 +##幟 1 +##幡 1 +##幢 1 +##幣 1 +##幫 1 +##干 1 +##平 1 +##年 1 +##并 1 +##幸 1 +##幹 1 +##幺 1 +##幻 1 +##幼 1 +##幽 1 +##幾 1 +##广 1 +##庁 1 +##広 1 +##庄 1 +##庆 1 +##庇 1 +##床 1 +##序 1 +##庐 1 +##库 1 +##应 1 +##底 1 +##庖 1 +##店 1 +##庙 1 +##庚 1 +##府 1 +##庞 1 +##废 1 +##庠 1 +##度 1 +##座 1 +##庫 1 +##庭 1 +##庵 1 +##庶 1 +##康 1 +##庸 1 +##庹 1 +##庾 1 +##廁 1 +##廂 1 +##廃 1 +##廈 1 +##廉 1 +##廊 1 +##廓 1 +##廖 1 +##廚 1 +##廝 1 +##廟 1 +##廠 1 +##廢 1 +##廣 1 +##廬 1 +##廳 1 +##延 1 +##廷 1 +##建 1 +##廿 1 +##开 1 +##弁 1 +##异 1 +##弃 1 +##弄 1 +##弈 1 +##弊 1 +##弋 1 +##式 1 +##弑 1 +##弒 1 +##弓 1 +##弔 1 +##引 1 +##弗 1 +##弘 1 +##弛 1 +##弟 1 +##张 1 +##弥 1 +##弦 1 +##弧 1 +##弩 1 +##弭 1 +##弯 1 +##弱 1 +##張 1 +##強 1 +##弹 1 +##强 1 +##弼 1 +##弾 1 +##彅 1 +##彆 1 +##彈 1 +##彌 1 +##彎 1 +##归 1 +##当 1 +##录 1 +##彗 1 +##彙 1 +##彝 1 +##形 1 +##彤 1 +##彥 1 +##彦 1 +##彧 1 +##彩 1 +##彪 1 +##彫 1 +##彬 1 +##彭 1 +##彰 1 +##影 1 +##彷 1 +##役 1 +##彻 1 +##彼 1 +##彿 1 +##往 1 +##征 1 +##径 1 +##待 1 +##徇 1 +##很 1 +##徉 1 +##徊 1 +##律 1 +##後 1 +##徐 1 +##徑 1 +##徒 1 +##従 1 +##徕 1 +##得 1 +##徘 1 +##徙 1 +##徜 1 +##從 1 +##徠 1 +##御 1 +##徨 1 +##復 1 +##循 1 +##徬 1 +##微 1 +##徳 1 +##徴 1 +##徵 1 +##德 1 +##徹 1 +##徼 1 +##徽 1 +##心 1 +##必 1 +##忆 1 +##忌 1 +##忍 1 +##忏 1 +##忐 1 +##忑 1 +##忒 1 +##忖 1 +##志 1 +##忘 1 +##忙 1 +##応 1 +##忠 1 +##忡 1 +##忤 1 +##忧 1 +##忪 1 +##快 1 +##忱 1 +##念 1 +##忻 1 +##忽 1 +##忿 1 +##怀 1 +##态 1 +##怂 1 +##怅 1 +##怆 1 +##怎 1 +##怏 1 +##怒 1 +##怔 1 +##怕 1 +##怖 1 +##怙 1 +##怜 1 +##思 1 +##怠 1 +##怡 1 +##急 1 +##怦 1 +##性 1 +##怨 1 +##怪 1 +##怯 1 +##怵 1 +##总 1 +##怼 1 +##恁 1 +##恃 1 +##恆 1 +##恋 1 +##恍 1 +##恐 1 +##恒 1 +##恕 1 +##恙 1 +##恚 1 +##恢 1 +##恣 1 +##恤 1 +##恥 1 +##恨 1 +##恩 1 +##恪 1 +##恫 1 +##恬 1 +##恭 1 +##息 1 +##恰 1 +##恳 1 +##恵 1 +##恶 1 +##恸 1 +##恺 1 +##恻 1 +##恼 1 +##恿 1 +##悄 1 +##悅 1 +##悉 1 +##悌 1 +##悍 1 +##悔 1 +##悖 1 +##悚 1 +##悟 1 +##悠 1 +##患 1 +##悦 1 +##您 1 +##悩 1 +##悪 1 +##悬 1 +##悯 1 +##悱 1 +##悲 1 +##悴 1 +##悵 1 +##悶 1 +##悸 1 +##悻 1 +##悼 1 +##悽 1 +##情 1 +##惆 1 +##惇 1 +##惊 1 +##惋 1 +##惑 1 +##惕 1 +##惘 1 +##惚 1 +##惜 1 +##惟 1 +##惠 1 +##惡 1 +##惦 1 +##惧 1 +##惨 1 +##惩 1 +##惫 1 +##惬 1 +##惭 1 +##惮 1 +##惯 1 +##惰 1 +##惱 1 +##想 1 +##惴 1 +##惶 1 +##惹 1 +##惺 1 +##愁 1 +##愆 1 +##愈 1 +##愉 1 +##愍 1 +##意 1 +##愕 1 +##愚 1 +##愛 1 +##愜 1 +##感 1 +##愣 1 +##愤 1 +##愧 1 +##愫 1 +##愷 1 +##愿 1 +##慄 1 +##慈 1 +##態 1 +##慌 1 +##慎 1 +##慑 1 +##慕 1 +##慘 1 +##慚 1 +##慟 1 +##慢 1 +##慣 1 +##慧 1 +##慨 1 +##慫 1 +##慮 1 +##慰 1 +##慳 1 +##慵 1 +##慶 1 +##慷 1 +##慾 1 +##憂 1 +##憊 1 +##憋 1 +##憎 1 +##憐 1 +##憑 1 +##憔 1 +##憚 1 +##憤 1 +##憧 1 +##憨 1 +##憩 1 +##憫 1 +##憬 1 +##憲 1 +##憶 1 +##憾 1 +##懂 1 +##懇 1 +##懈 1 +##應 1 +##懊 1 +##懋 1 +##懑 1 +##懒 1 +##懦 1 +##懲 1 +##懵 1 +##懶 1 +##懷 1 +##懸 1 +##懺 1 +##懼 1 +##懾 1 +##懿 1 +##戀 1 +##戈 1 +##戊 1 +##戌 1 +##戍 1 +##戎 1 +##戏 1 +##成 1 +##我 1 +##戒 1 +##戕 1 +##或 1 +##战 1 +##戚 1 +##戛 1 +##戟 1 +##戡 1 +##戦 1 +##截 1 +##戬 1 +##戮 1 +##戰 1 +##戲 1 +##戳 1 +##戴 1 +##戶 1 +##户 1 +##戸 1 +##戻 1 +##戾 1 +##房 1 +##所 1 +##扁 1 +##扇 1 +##扈 1 +##扉 1 +##手 1 +##才 1 +##扎 1 +##扑 1 +##扒 1 +##打 1 +##扔 1 +##払 1 +##托 1 +##扛 1 +##扣 1 +##扦 1 +##执 1 +##扩 1 +##扪 1 +##扫 1 +##扬 1 +##扭 1 +##扮 1 +##扯 1 +##扰 1 +##扱 1 +##扳 1 +##扶 1 +##批 1 +##扼 1 +##找 1 +##承 1 +##技 1 +##抄 1 +##抉 1 +##把 1 +##抑 1 +##抒 1 +##抓 1 +##投 1 +##抖 1 +##抗 1 +##折 1 +##抚 1 +##抛 1 +##抜 1 +##択 1 +##抟 1 +##抠 1 +##抡 1 +##抢 1 +##护 1 +##报 1 +##抨 1 +##披 1 +##抬 1 +##抱 1 +##抵 1 +##抹 1 +##押 1 +##抽 1 +##抿 1 +##拂 1 +##拄 1 +##担 1 +##拆 1 +##拇 1 +##拈 1 +##拉 1 +##拋 1 +##拌 1 +##拍 1 +##拎 1 +##拐 1 +##拒 1 +##拓 1 +##拔 1 +##拖 1 +##拗 1 +##拘 1 +##拙 1 +##拚 1 +##招 1 +##拜 1 +##拟 1 +##拡 1 +##拢 1 +##拣 1 +##拥 1 +##拦 1 +##拧 1 +##拨 1 +##择 1 +##括 1 +##拭 1 +##拮 1 +##拯 1 +##拱 1 +##拳 1 +##拴 1 +##拷 1 +##拼 1 +##拽 1 +##拾 1 +##拿 1 +##持 1 +##挂 1 +##指 1 +##挈 1 +##按 1 +##挎 1 +##挑 1 +##挖 1 +##挙 1 +##挚 1 +##挛 1 +##挝 1 +##挞 1 +##挟 1 +##挠 1 +##挡 1 +##挣 1 +##挤 1 +##挥 1 +##挨 1 +##挪 1 +##挫 1 +##振 1 +##挲 1 +##挹 1 +##挺 1 +##挽 1 +##挾 1 +##捂 1 +##捅 1 +##捆 1 +##捉 1 +##捋 1 +##捌 1 +##捍 1 +##捎 1 +##捏 1 +##捐 1 +##捕 1 +##捞 1 +##损 1 +##捡 1 +##换 1 +##捣 1 +##捧 1 +##捨 1 +##捩 1 +##据 1 +##捱 1 +##捲 1 +##捶 1 +##捷 1 +##捺 1 +##捻 1 +##掀 1 +##掂 1 +##掃 1 +##掇 1 +##授 1 +##掉 1 +##掌 1 +##掏 1 +##掐 1 +##排 1 +##掖 1 +##掘 1 +##掙 1 +##掛 1 +##掠 1 +##採 1 +##探 1 +##掣 1 +##接 1 +##控 1 +##推 1 +##掩 1 +##措 1 +##掬 1 +##掰 1 +##掲 1 +##掳 1 +##掴 1 +##掷 1 +##掸 1 +##掺 1 +##揀 1 +##揃 1 +##揄 1 +##揆 1 +##揉 1 +##揍 1 +##描 1 +##提 1 +##插 1 +##揖 1 +##揚 1 +##換 1 +##握 1 +##揣 1 +##揩 1 +##揪 1 +##揭 1 +##揮 1 +##援 1 +##揶 1 +##揸 1 +##揹 1 +##揽 1 +##搀 1 +##搁 1 +##搂 1 +##搅 1 +##損 1 +##搏 1 +##搐 1 +##搓 1 +##搔 1 +##搖 1 +##搗 1 +##搜 1 +##搞 1 +##搡 1 +##搪 1 +##搬 1 +##搭 1 +##搵 1 +##搶 1 +##携 1 +##搽 1 +##摀 1 +##摁 1 +##摄 1 +##摆 1 +##摇 1 +##摈 1 +##摊 1 +##摒 1 +##摔 1 +##摘 1 +##摞 1 +##摟 1 +##摧 1 +##摩 1 +##摯 1 +##摳 1 +##摸 1 +##摹 1 +##摺 1 +##摻 1 +##撂 1 +##撃 1 +##撅 1 +##撇 1 +##撈 1 +##撐 1 +##撑 1 +##撒 1 +##撓 1 +##撕 1 +##撚 1 +##撞 1 +##撤 1 +##撥 1 +##撩 1 +##撫 1 +##撬 1 +##播 1 +##撮 1 +##撰 1 +##撲 1 +##撵 1 +##撷 1 +##撸 1 +##撻 1 +##撼 1 +##撿 1 +##擀 1 +##擁 1 +##擂 1 +##擄 1 +##擅 1 +##擇 1 +##擊 1 +##擋 1 +##操 1 +##擎 1 +##擒 1 +##擔 1 +##擘 1 +##據 1 +##擞 1 +##擠 1 +##擡 1 +##擢 1 +##擦 1 +##擬 1 +##擰 1 +##擱 1 +##擲 1 +##擴 1 +##擷 1 +##擺 1 +##擼 1 +##擾 1 +##攀 1 +##攏 1 +##攒 1 +##攔 1 +##攘 1 +##攙 1 +##攜 1 +##攝 1 +##攞 1 +##攢 1 +##攣 1 +##攤 1 +##攥 1 +##攪 1 +##攫 1 +##攬 1 +##支 1 +##收 1 +##攸 1 +##改 1 +##攻 1 +##放 1 +##政 1 +##故 1 +##效 1 +##敌 1 +##敍 1 +##敎 1 +##敏 1 +##救 1 +##敕 1 +##敖 1 +##敗 1 +##敘 1 +##教 1 +##敛 1 +##敝 1 +##敞 1 +##敢 1 +##散 1 +##敦 1 +##敬 1 +##数 1 +##敲 1 +##整 1 +##敵 1 +##敷 1 +##數 1 +##斂 1 +##斃 1 +##文 1 +##斋 1 +##斌 1 +##斎 1 +##斐 1 +##斑 1 +##斓 1 +##斗 1 +##料 1 +##斛 1 +##斜 1 +##斟 1 +##斡 1 +##斤 1 +##斥 1 +##斧 1 +##斩 1 +##斫 1 +##斬 1 +##断 1 +##斯 1 +##新 1 +##斷 1 +##方 1 +##於 1 +##施 1 +##旁 1 +##旃 1 +##旅 1 +##旋 1 +##旌 1 +##旎 1 +##族 1 +##旖 1 +##旗 1 +##无 1 +##既 1 +##日 1 +##旦 1 +##旧 1 +##旨 1 +##早 1 +##旬 1 +##旭 1 +##旮 1 +##旱 1 +##时 1 +##旷 1 +##旺 1 +##旻 1 +##昀 1 +##昂 1 +##昆 1 +##昇 1 +##昉 1 +##昊 1 +##昌 1 +##明 1 +##昏 1 +##易 1 +##昔 1 +##昕 1 +##昙 1 +##星 1 +##映 1 +##春 1 +##昧 1 +##昨 1 +##昭 1 +##是 1 +##昱 1 +##昴 1 +##昵 1 +##昶 1 +##昼 1 +##显 1 +##晁 1 +##時 1 +##晃 1 +##晉 1 +##晋 1 +##晌 1 +##晏 1 +##晒 1 +##晓 1 +##晔 1 +##晕 1 +##晖 1 +##晗 1 +##晚 1 +##晝 1 +##晞 1 +##晟 1 +##晤 1 +##晦 1 +##晨 1 +##晩 1 +##普 1 +##景 1 +##晰 1 +##晴 1 +##晶 1 +##晷 1 +##智 1 +##晾 1 +##暂 1 +##暄 1 +##暇 1 +##暈 1 +##暉 1 +##暌 1 +##暐 1 +##暑 1 +##暖 1 +##暗 1 +##暝 1 +##暢 1 +##暧 1 +##暨 1 +##暫 1 +##暮 1 +##暱 1 +##暴 1 +##暸 1 +##暹 1 +##曄 1 +##曆 1 +##曇 1 +##曉 1 +##曖 1 +##曙 1 +##曜 1 +##曝 1 +##曠 1 +##曦 1 +##曬 1 +##曰 1 +##曲 1 +##曳 1 +##更 1 +##書 1 +##曹 1 +##曼 1 +##曾 1 +##替 1 +##最 1 +##會 1 +##月 1 +##有 1 +##朋 1 +##服 1 +##朐 1 +##朔 1 +##朕 1 +##朗 1 +##望 1 +##朝 1 +##期 1 +##朦 1 +##朧 1 +##木 1 +##未 1 +##末 1 +##本 1 +##札 1 +##朮 1 +##术 1 +##朱 1 +##朴 1 +##朵 1 +##机 1 +##朽 1 +##杀 1 +##杂 1 +##权 1 +##杆 1 +##杈 1 +##杉 1 +##李 1 +##杏 1 +##材 1 +##村 1 +##杓 1 +##杖 1 +##杜 1 +##杞 1 +##束 1 +##杠 1 +##条 1 +##来 1 +##杨 1 +##杭 1 +##杯 1 +##杰 1 +##東 1 +##杳 1 +##杵 1 +##杷 1 +##杼 1 +##松 1 +##板 1 +##极 1 +##构 1 +##枇 1 +##枉 1 +##枋 1 +##析 1 +##枕 1 +##林 1 +##枚 1 +##果 1 +##枝 1 +##枢 1 +##枣 1 +##枪 1 +##枫 1 +##枭 1 +##枯 1 +##枰 1 +##枱 1 +##枳 1 +##架 1 +##枷 1 +##枸 1 +##柄 1 +##柏 1 +##某 1 +##柑 1 +##柒 1 +##染 1 +##柔 1 +##柘 1 +##柚 1 +##柜 1 +##柞 1 +##柠 1 +##柢 1 +##查 1 +##柩 1 +##柬 1 +##柯 1 +##柱 1 +##柳 1 +##柴 1 +##柵 1 +##査 1 +##柿 1 +##栀 1 +##栃 1 +##栄 1 +##栅 1 +##标 1 +##栈 1 +##栉 1 +##栋 1 +##栎 1 +##栏 1 +##树 1 +##栓 1 +##栖 1 +##栗 1 +##校 1 +##栩 1 +##株 1 +##样 1 +##核 1 +##根 1 +##格 1 +##栽 1 +##栾 1 +##桀 1 +##桁 1 +##桂 1 +##桃 1 +##桅 1 +##框 1 +##案 1 +##桉 1 +##桌 1 +##桎 1 +##桐 1 +##桑 1 +##桓 1 +##桔 1 +##桜 1 +##桠 1 +##桡 1 +##桢 1 +##档 1 +##桥 1 +##桦 1 +##桧 1 +##桨 1 +##桩 1 +##桶 1 +##桿 1 +##梁 1 +##梅 1 +##梆 1 +##梏 1 +##梓 1 +##梗 1 +##條 1 +##梟 1 +##梢 1 +##梦 1 +##梧 1 +##梨 1 +##梭 1 +##梯 1 +##械 1 +##梳 1 +##梵 1 +##梶 1 +##检 1 +##棂 1 +##棄 1 +##棉 1 +##棋 1 +##棍 1 +##棒 1 +##棕 1 +##棗 1 +##棘 1 +##棚 1 +##棟 1 +##棠 1 +##棣 1 +##棧 1 +##森 1 +##棱 1 +##棲 1 +##棵 1 +##棹 1 +##棺 1 +##椁 1 +##椅 1 +##椋 1 +##植 1 +##椎 1 +##椒 1 +##検 1 +##椪 1 +##椭 1 +##椰 1 +##椹 1 +##椽 1 +##椿 1 +##楂 1 +##楊 1 +##楓 1 +##楔 1 +##楚 1 +##楝 1 +##楞 1 +##楠 1 +##楣 1 +##楨 1 +##楫 1 +##業 1 +##楮 1 +##極 1 +##楷 1 +##楸 1 +##楹 1 +##楼 1 +##楽 1 +##概 1 +##榄 1 +##榆 1 +##榈 1 +##榉 1 +##榔 1 +##榕 1 +##榖 1 +##榛 1 +##榜 1 +##榨 1 +##榫 1 +##榭 1 +##榮 1 +##榱 1 +##榴 1 +##榷 1 +##榻 1 +##槁 1 +##槃 1 +##構 1 +##槌 1 +##槍 1 +##槎 1 +##槐 1 +##槓 1 +##様 1 +##槛 1 +##槟 1 +##槤 1 +##槭 1 +##槲 1 +##槳 1 +##槻 1 +##槽 1 +##槿 1 +##樁 1 +##樂 1 +##樊 1 +##樑 1 +##樓 1 +##標 1 +##樞 1 +##樟 1 +##模 1 +##樣 1 +##権 1 +##横 1 +##樫 1 +##樯 1 +##樱 1 +##樵 1 +##樸 1 +##樹 1 +##樺 1 +##樽 1 +##樾 1 +##橄 1 +##橇 1 +##橋 1 +##橐 1 +##橘 1 +##橙 1 +##機 1 +##橡 1 +##橢 1 +##橫 1 +##橱 1 +##橹 1 +##橼 1 +##檀 1 +##檄 1 +##檎 1 +##檐 1 +##檔 1 +##檗 1 +##檜 1 +##檢 1 +##檬 1 +##檯 1 +##檳 1 +##檸 1 +##檻 1 +##櫃 1 +##櫚 1 +##櫛 1 +##櫥 1 +##櫸 1 +##櫻 1 +##欄 1 +##權 1 +##欒 1 +##欖 1 +##欠 1 +##次 1 +##欢 1 +##欣 1 +##欧 1 +##欲 1 +##欸 1 +##欺 1 +##欽 1 +##款 1 +##歆 1 +##歇 1 +##歉 1 +##歌 1 +##歎 1 +##歐 1 +##歓 1 +##歙 1 +##歛 1 +##歡 1 +##止 1 +##正 1 +##此 1 +##步 1 +##武 1 +##歧 1 +##歩 1 +##歪 1 +##歯 1 +##歲 1 +##歳 1 +##歴 1 +##歷 1 +##歸 1 +##歹 1 +##死 1 +##歼 1 +##殁 1 +##殃 1 +##殆 1 +##殇 1 +##殉 1 +##殊 1 +##残 1 +##殒 1 +##殓 1 +##殖 1 +##殘 1 +##殞 1 +##殡 1 +##殤 1 +##殭 1 +##殯 1 +##殲 1 +##殴 1 +##段 1 +##殷 1 +##殺 1 +##殼 1 +##殿 1 +##毀 1 +##毁 1 +##毂 1 +##毅 1 +##毆 1 +##毋 1 +##母 1 +##毎 1 +##每 1 +##毒 1 +##毓 1 +##比 1 +##毕 1 +##毗 1 +##毘 1 +##毙 1 +##毛 1 +##毡 1 +##毫 1 +##毯 1 +##毽 1 +##氈 1 +##氏 1 +##氐 1 +##民 1 +##氓 1 +##气 1 +##氖 1 +##気 1 +##氙 1 +##氛 1 +##氟 1 +##氡 1 +##氢 1 +##氣 1 +##氤 1 +##氦 1 +##氧 1 +##氨 1 +##氪 1 +##氫 1 +##氮 1 +##氯 1 +##氰 1 +##氲 1 +##水 1 +##氷 1 +##永 1 +##氹 1 +##氾 1 +##汀 1 +##汁 1 +##求 1 +##汆 1 +##汇 1 +##汉 1 +##汎 1 +##汐 1 +##汕 1 +##汗 1 +##汙 1 +##汛 1 +##汝 1 +##汞 1 +##江 1 +##池 1 +##污 1 +##汤 1 +##汨 1 +##汩 1 +##汪 1 +##汰 1 +##汲 1 +##汴 1 +##汶 1 +##汹 1 +##決 1 +##汽 1 +##汾 1 +##沁 1 +##沂 1 +##沃 1 +##沅 1 +##沈 1 +##沉 1 +##沌 1 +##沏 1 +##沐 1 +##沒 1 +##沓 1 +##沖 1 +##沙 1 +##沛 1 +##沟 1 +##没 1 +##沢 1 +##沣 1 +##沥 1 +##沦 1 +##沧 1 +##沪 1 +##沫 1 +##沭 1 +##沮 1 +##沱 1 +##河 1 +##沸 1 +##油 1 +##治 1 +##沼 1 +##沽 1 +##沾 1 +##沿 1 +##況 1 +##泄 1 +##泉 1 +##泊 1 +##泌 1 +##泓 1 +##法 1 +##泗 1 +##泛 1 +##泞 1 +##泠 1 +##泡 1 +##波 1 +##泣 1 +##泥 1 +##注 1 +##泪 1 +##泫 1 +##泮 1 +##泯 1 +##泰 1 +##泱 1 +##泳 1 +##泵 1 +##泷 1 +##泸 1 +##泻 1 +##泼 1 +##泽 1 +##泾 1 +##洁 1 +##洄 1 +##洋 1 +##洒 1 +##洗 1 +##洙 1 +##洛 1 +##洞 1 +##津 1 +##洩 1 +##洪 1 +##洮 1 +##洱 1 +##洲 1 +##洵 1 +##洶 1 +##洸 1 +##洹 1 +##活 1 +##洼 1 +##洽 1 +##派 1 +##流 1 +##浃 1 +##浄 1 +##浅 1 +##浆 1 +##浇 1 +##浊 1 +##测 1 +##济 1 +##浏 1 +##浑 1 +##浒 1 +##浓 1 +##浔 1 +##浙 1 +##浚 1 +##浜 1 +##浣 1 +##浦 1 +##浩 1 +##浪 1 +##浬 1 +##浮 1 +##浯 1 +##浴 1 +##海 1 +##浸 1 +##涂 1 +##涅 1 +##涇 1 +##消 1 +##涉 1 +##涌 1 +##涎 1 +##涓 1 +##涔 1 +##涕 1 +##涙 1 +##涛 1 +##涝 1 +##涞 1 +##涟 1 +##涠 1 +##涡 1 +##涣 1 +##涤 1 +##润 1 +##涧 1 +##涨 1 +##涩 1 +##涪 1 +##涮 1 +##涯 1 +##液 1 +##涵 1 +##涸 1 +##涼 1 +##涿 1 +##淀 1 +##淄 1 +##淅 1 +##淆 1 +##淇 1 +##淋 1 +##淌 1 +##淑 1 +##淒 1 +##淖 1 +##淘 1 +##淙 1 +##淚 1 +##淞 1 +##淡 1 +##淤 1 +##淦 1 +##淨 1 +##淩 1 +##淪 1 +##淫 1 +##淬 1 +##淮 1 +##深 1 +##淳 1 +##淵 1 +##混 1 +##淹 1 +##淺 1 +##添 1 +##淼 1 +##清 1 +##済 1 +##渉 1 +##渊 1 +##渋 1 +##渍 1 +##渎 1 +##渐 1 +##渔 1 +##渗 1 +##渙 1 +##渚 1 +##減 1 +##渝 1 +##渠 1 +##渡 1 +##渣 1 +##渤 1 +##渥 1 +##渦 1 +##温 1 +##測 1 +##渭 1 +##港 1 +##渲 1 +##渴 1 +##游 1 +##渺 1 +##渾 1 +##湃 1 +##湄 1 +##湊 1 +##湍 1 +##湖 1 +##湘 1 +##湛 1 +##湟 1 +##湧 1 +##湫 1 +##湮 1 +##湯 1 +##湳 1 +##湾 1 +##湿 1 +##満 1 +##溃 1 +##溅 1 +##溉 1 +##溏 1 +##源 1 +##準 1 +##溜 1 +##溝 1 +##溟 1 +##溢 1 +##溥 1 +##溧 1 +##溪 1 +##溫 1 +##溯 1 +##溱 1 +##溴 1 +##溶 1 +##溺 1 +##溼 1 +##滁 1 +##滂 1 +##滄 1 +##滅 1 +##滇 1 +##滋 1 +##滌 1 +##滑 1 +##滓 1 +##滔 1 +##滕 1 +##滙 1 +##滚 1 +##滝 1 +##滞 1 +##滟 1 +##满 1 +##滢 1 +##滤 1 +##滥 1 +##滦 1 +##滨 1 +##滩 1 +##滬 1 +##滯 1 +##滲 1 +##滴 1 +##滷 1 +##滸 1 +##滾 1 +##滿 1 +##漁 1 +##漂 1 +##漆 1 +##漉 1 +##漏 1 +##漓 1 +##演 1 +##漕 1 +##漠 1 +##漢 1 +##漣 1 +##漩 1 +##漪 1 +##漫 1 +##漬 1 +##漯 1 +##漱 1 +##漲 1 +##漳 1 +##漸 1 +##漾 1 +##漿 1 +##潆 1 +##潇 1 +##潋 1 +##潍 1 +##潑 1 +##潔 1 +##潘 1 +##潛 1 +##潜 1 +##潞 1 +##潟 1 +##潢 1 +##潤 1 +##潦 1 +##潧 1 +##潭 1 +##潮 1 +##潰 1 +##潴 1 +##潸 1 +##潺 1 +##潼 1 +##澀 1 +##澄 1 +##澆 1 +##澈 1 +##澍 1 +##澎 1 +##澗 1 +##澜 1 +##澡 1 +##澤 1 +##澧 1 +##澱 1 +##澳 1 +##澹 1 +##激 1 +##濁 1 +##濂 1 +##濃 1 +##濑 1 +##濒 1 +##濕 1 +##濘 1 +##濛 1 +##濟 1 +##濠 1 +##濡 1 +##濤 1 +##濫 1 +##濬 1 +##濮 1 +##濯 1 +##濱 1 +##濺 1 +##濾 1 +##瀅 1 +##瀆 1 +##瀉 1 +##瀋 1 +##瀏 1 +##瀑 1 +##瀕 1 +##瀘 1 +##瀚 1 +##瀛 1 +##瀝 1 +##瀞 1 +##瀟 1 +##瀧 1 +##瀨 1 +##瀬 1 +##瀰 1 +##瀾 1 +##灌 1 +##灏 1 +##灑 1 +##灘 1 +##灝 1 +##灞 1 +##灣 1 +##火 1 +##灬 1 +##灭 1 +##灯 1 +##灰 1 +##灵 1 +##灶 1 +##灸 1 +##灼 1 +##災 1 +##灾 1 +##灿 1 +##炀 1 +##炁 1 +##炅 1 +##炉 1 +##炊 1 +##炎 1 +##炒 1 +##炔 1 +##炕 1 +##炖 1 +##炙 1 +##炜 1 +##炫 1 +##炬 1 +##炭 1 +##炮 1 +##炯 1 +##炳 1 +##炷 1 +##炸 1 +##点 1 +##為 1 +##炼 1 +##炽 1 +##烁 1 +##烂 1 +##烃 1 +##烈 1 +##烊 1 +##烏 1 +##烘 1 +##烙 1 +##烛 1 +##烟 1 +##烤 1 +##烦 1 +##烧 1 +##烨 1 +##烩 1 +##烫 1 +##烬 1 +##热 1 +##烯 1 +##烷 1 +##烹 1 +##烽 1 +##焉 1 +##焊 1 +##焕 1 +##焖 1 +##焗 1 +##焘 1 +##焙 1 +##焚 1 +##焜 1 +##無 1 +##焦 1 +##焯 1 +##焰 1 +##焱 1 +##然 1 +##焼 1 +##煅 1 +##煉 1 +##煊 1 +##煌 1 +##煎 1 +##煒 1 +##煖 1 +##煙 1 +##煜 1 +##煞 1 +##煤 1 +##煥 1 +##煦 1 +##照 1 +##煨 1 +##煩 1 +##煮 1 +##煲 1 +##煸 1 +##煽 1 +##熄 1 +##熊 1 +##熏 1 +##熒 1 +##熔 1 +##熙 1 +##熟 1 +##熠 1 +##熨 1 +##熬 1 +##熱 1 +##熵 1 +##熹 1 +##熾 1 +##燁 1 +##燃 1 +##燄 1 +##燈 1 +##燉 1 +##燊 1 +##燎 1 +##燒 1 +##燔 1 +##燕 1 +##燙 1 +##燜 1 +##營 1 +##燥 1 +##燦 1 +##燧 1 +##燭 1 +##燮 1 +##燴 1 +##燻 1 +##燼 1 +##燿 1 +##爆 1 +##爍 1 +##爐 1 +##爛 1 +##爪 1 +##爬 1 +##爭 1 +##爰 1 +##爱 1 +##爲 1 +##爵 1 +##父 1 +##爷 1 +##爸 1 +##爹 1 +##爺 1 +##爻 1 +##爽 1 +##爾 1 +##牆 1 +##片 1 +##版 1 +##牌 1 +##牍 1 +##牒 1 +##牙 1 +##牛 1 +##牝 1 +##牟 1 +##牠 1 +##牡 1 +##牢 1 +##牦 1 +##牧 1 +##物 1 +##牯 1 +##牲 1 +##牴 1 +##牵 1 +##特 1 +##牺 1 +##牽 1 +##犀 1 +##犁 1 +##犄 1 +##犊 1 +##犍 1 +##犒 1 +##犢 1 +##犧 1 +##犬 1 +##犯 1 +##状 1 +##犷 1 +##犸 1 +##犹 1 +##狀 1 +##狂 1 +##狄 1 +##狈 1 +##狎 1 +##狐 1 +##狒 1 +##狗 1 +##狙 1 +##狞 1 +##狠 1 +##狡 1 +##狩 1 +##独 1 +##狭 1 +##狮 1 +##狰 1 +##狱 1 +##狸 1 +##狹 1 +##狼 1 +##狽 1 +##猎 1 +##猕 1 +##猖 1 +##猗 1 +##猙 1 +##猛 1 +##猜 1 +##猝 1 +##猥 1 +##猩 1 +##猪 1 +##猫 1 +##猬 1 +##献 1 +##猴 1 +##猶 1 +##猷 1 +##猾 1 +##猿 1 +##獄 1 +##獅 1 +##獎 1 +##獐 1 +##獒 1 +##獗 1 +##獠 1 +##獣 1 +##獨 1 +##獭 1 +##獰 1 +##獲 1 +##獵 1 +##獷 1 +##獸 1 +##獺 1 +##獻 1 +##獼 1 +##獾 1 +##玄 1 +##率 1 +##玉 1 +##王 1 +##玑 1 +##玖 1 +##玛 1 +##玟 1 +##玠 1 +##玥 1 +##玩 1 +##玫 1 +##玮 1 +##环 1 +##现 1 +##玲 1 +##玳 1 +##玷 1 +##玺 1 +##玻 1 +##珀 1 +##珂 1 +##珅 1 +##珈 1 +##珉 1 +##珊 1 +##珍 1 +##珏 1 +##珐 1 +##珑 1 +##珙 1 +##珞 1 +##珠 1 +##珣 1 +##珥 1 +##珩 1 +##珪 1 +##班 1 +##珮 1 +##珲 1 +##珺 1 +##現 1 +##球 1 +##琅 1 +##理 1 +##琇 1 +##琉 1 +##琊 1 +##琍 1 +##琏 1 +##琐 1 +##琛 1 +##琢 1 +##琥 1 +##琦 1 +##琨 1 +##琪 1 +##琬 1 +##琮 1 +##琰 1 +##琲 1 +##琳 1 +##琴 1 +##琵 1 +##琶 1 +##琺 1 +##琼 1 +##瑀 1 +##瑁 1 +##瑄 1 +##瑋 1 +##瑕 1 +##瑗 1 +##瑙 1 +##瑚 1 +##瑛 1 +##瑜 1 +##瑞 1 +##瑟 1 +##瑠 1 +##瑣 1 +##瑤 1 +##瑩 1 +##瑪 1 +##瑯 1 +##瑰 1 +##瑶 1 +##瑾 1 +##璀 1 +##璁 1 +##璃 1 +##璇 1 +##璉 1 +##璋 1 +##璎 1 +##璐 1 +##璜 1 +##璞 1 +##璟 1 +##璧 1 +##璨 1 +##環 1 +##璽 1 +##璿 1 +##瓊 1 +##瓏 1 +##瓒 1 +##瓜 1 +##瓢 1 +##瓣 1 +##瓤 1 +##瓦 1 +##瓮 1 +##瓯 1 +##瓴 1 +##瓶 1 +##瓷 1 +##甄 1 +##甌 1 +##甕 1 +##甘 1 +##甙 1 +##甚 1 +##甜 1 +##生 1 +##產 1 +##産 1 +##甥 1 +##甦 1 +##用 1 +##甩 1 +##甫 1 +##甬 1 +##甭 1 +##甯 1 +##田 1 +##由 1 +##甲 1 +##申 1 +##电 1 +##男 1 +##甸 1 +##町 1 +##画 1 +##甾 1 +##畀 1 +##畅 1 +##界 1 +##畏 1 +##畑 1 +##畔 1 +##留 1 +##畜 1 +##畝 1 +##畢 1 +##略 1 +##畦 1 +##番 1 +##畫 1 +##異 1 +##畲 1 +##畳 1 +##畴 1 +##當 1 +##畸 1 +##畹 1 +##畿 1 +##疆 1 +##疇 1 +##疊 1 +##疏 1 +##疑 1 +##疔 1 +##疖 1 +##疗 1 +##疙 1 +##疚 1 +##疝 1 +##疟 1 +##疡 1 +##疣 1 +##疤 1 +##疥 1 +##疫 1 +##疮 1 +##疯 1 +##疱 1 +##疲 1 +##疳 1 +##疵 1 +##疸 1 +##疹 1 +##疼 1 +##疽 1 +##疾 1 +##痂 1 +##病 1 +##症 1 +##痈 1 +##痉 1 +##痊 1 +##痍 1 +##痒 1 +##痔 1 +##痕 1 +##痘 1 +##痙 1 +##痛 1 +##痞 1 +##痠 1 +##痢 1 +##痣 1 +##痤 1 +##痧 1 +##痨 1 +##痪 1 +##痫 1 +##痰 1 +##痱 1 +##痴 1 +##痹 1 +##痺 1 +##痼 1 +##痿 1 +##瘀 1 +##瘁 1 +##瘋 1 +##瘍 1 +##瘓 1 +##瘘 1 +##瘙 1 +##瘟 1 +##瘠 1 +##瘡 1 +##瘢 1 +##瘤 1 +##瘦 1 +##瘧 1 +##瘩 1 +##瘪 1 +##瘫 1 +##瘴 1 +##瘸 1 +##瘾 1 +##療 1 +##癇 1 +##癌 1 +##癒 1 +##癖 1 +##癜 1 +##癞 1 +##癡 1 +##癢 1 +##癣 1 +##癥 1 +##癫 1 +##癬 1 +##癮 1 +##癱 1 +##癲 1 +##癸 1 +##発 1 +##登 1 +##發 1 +##白 1 +##百 1 +##皂 1 +##的 1 +##皆 1 +##皇 1 +##皈 1 +##皋 1 +##皎 1 +##皑 1 +##皓 1 +##皖 1 +##皙 1 +##皚 1 +##皮 1 +##皰 1 +##皱 1 +##皴 1 +##皺 1 +##皿 1 +##盂 1 +##盃 1 +##盅 1 +##盆 1 +##盈 1 +##益 1 +##盎 1 +##盏 1 +##盐 1 +##监 1 +##盒 1 +##盔 1 +##盖 1 +##盗 1 +##盘 1 +##盛 1 +##盜 1 +##盞 1 +##盟 1 +##盡 1 +##監 1 +##盤 1 +##盥 1 +##盧 1 +##盪 1 +##目 1 +##盯 1 +##盱 1 +##盲 1 +##直 1 +##相 1 +##盹 1 +##盼 1 +##盾 1 +##省 1 +##眈 1 +##眉 1 +##看 1 +##県 1 +##眙 1 +##眞 1 +##真 1 +##眠 1 +##眦 1 +##眨 1 +##眩 1 +##眯 1 +##眶 1 +##眷 1 +##眸 1 +##眺 1 +##眼 1 +##眾 1 +##着 1 +##睁 1 +##睇 1 +##睏 1 +##睐 1 +##睑 1 +##睛 1 +##睜 1 +##睞 1 +##睡 1 +##睢 1 +##督 1 +##睥 1 +##睦 1 +##睨 1 +##睪 1 +##睫 1 +##睬 1 +##睹 1 +##睽 1 +##睾 1 +##睿 1 +##瞄 1 +##瞅 1 +##瞇 1 +##瞋 1 +##瞌 1 +##瞎 1 +##瞑 1 +##瞒 1 +##瞓 1 +##瞞 1 +##瞟 1 +##瞠 1 +##瞥 1 +##瞧 1 +##瞩 1 +##瞪 1 +##瞬 1 +##瞭 1 +##瞰 1 +##瞳 1 +##瞻 1 +##瞼 1 +##瞿 1 +##矇 1 +##矍 1 +##矗 1 +##矚 1 +##矛 1 +##矜 1 +##矢 1 +##矣 1 +##知 1 +##矩 1 +##矫 1 +##短 1 +##矮 1 +##矯 1 +##石 1 +##矶 1 +##矽 1 +##矾 1 +##矿 1 +##码 1 +##砂 1 +##砌 1 +##砍 1 +##砒 1 +##研 1 +##砖 1 +##砗 1 +##砚 1 +##砝 1 +##砣 1 +##砥 1 +##砧 1 +##砭 1 +##砰 1 +##砲 1 +##破 1 +##砷 1 +##砸 1 +##砺 1 +##砼 1 +##砾 1 +##础 1 +##硅 1 +##硐 1 +##硒 1 +##硕 1 +##硝 1 +##硫 1 +##硬 1 +##确 1 +##硯 1 +##硼 1 +##碁 1 +##碇 1 +##碉 1 +##碌 1 +##碍 1 +##碎 1 +##碑 1 +##碓 1 +##碗 1 +##碘 1 +##碚 1 +##碛 1 +##碟 1 +##碣 1 +##碧 1 +##碩 1 +##碰 1 +##碱 1 +##碳 1 +##碴 1 +##確 1 +##碼 1 +##碾 1 +##磁 1 +##磅 1 +##磊 1 +##磋 1 +##磐 1 +##磕 1 +##磚 1 +##磡 1 +##磨 1 +##磬 1 +##磯 1 +##磲 1 +##磷 1 +##磺 1 +##礁 1 +##礎 1 +##礙 1 +##礡 1 +##礦 1 +##礪 1 +##礫 1 +##礴 1 +##示 1 +##礼 1 +##社 1 +##祀 1 +##祁 1 +##祂 1 +##祇 1 +##祈 1 +##祉 1 +##祎 1 +##祐 1 +##祕 1 +##祖 1 +##祗 1 +##祚 1 +##祛 1 +##祜 1 +##祝 1 +##神 1 +##祟 1 +##祠 1 +##祢 1 +##祥 1 +##票 1 +##祭 1 +##祯 1 +##祷 1 +##祸 1 +##祺 1 +##祿 1 +##禀 1 +##禁 1 +##禄 1 +##禅 1 +##禍 1 +##禎 1 +##福 1 +##禛 1 +##禦 1 +##禧 1 +##禪 1 +##禮 1 +##禱 1 +##禹 1 +##禺 1 +##离 1 +##禽 1 +##禾 1 +##禿 1 +##秀 1 +##私 1 +##秃 1 +##秆 1 +##秉 1 +##秋 1 +##种 1 +##科 1 +##秒 1 +##秘 1 +##租 1 +##秣 1 +##秤 1 +##秦 1 +##秧 1 +##秩 1 +##秭 1 +##积 1 +##称 1 +##秸 1 +##移 1 +##秽 1 +##稀 1 +##稅 1 +##程 1 +##稍 1 +##税 1 +##稔 1 +##稗 1 +##稚 1 +##稜 1 +##稞 1 +##稟 1 +##稠 1 +##稣 1 +##種 1 +##稱 1 +##稲 1 +##稳 1 +##稷 1 +##稹 1 +##稻 1 +##稼 1 +##稽 1 +##稿 1 +##穀 1 +##穂 1 +##穆 1 +##穌 1 +##積 1 +##穎 1 +##穗 1 +##穢 1 +##穩 1 +##穫 1 +##穴 1 +##究 1 +##穷 1 +##穹 1 +##空 1 +##穿 1 +##突 1 +##窃 1 +##窄 1 +##窈 1 +##窍 1 +##窑 1 +##窒 1 +##窓 1 +##窕 1 +##窖 1 +##窗 1 +##窘 1 +##窜 1 +##窝 1 +##窟 1 +##窠 1 +##窥 1 +##窦 1 +##窨 1 +##窩 1 +##窪 1 +##窮 1 +##窯 1 +##窺 1 +##窿 1 +##竄 1 +##竅 1 +##竇 1 +##竊 1 +##立 1 +##竖 1 +##站 1 +##竜 1 +##竞 1 +##竟 1 +##章 1 +##竣 1 +##童 1 +##竭 1 +##端 1 +##競 1 +##竹 1 +##竺 1 +##竽 1 +##竿 1 +##笃 1 +##笆 1 +##笈 1 +##笋 1 +##笏 1 +##笑 1 +##笔 1 +##笙 1 +##笛 1 +##笞 1 +##笠 1 +##符 1 +##笨 1 +##第 1 +##笹 1 +##笺 1 +##笼 1 +##筆 1 +##等 1 +##筊 1 +##筋 1 +##筍 1 +##筏 1 +##筐 1 +##筑 1 +##筒 1 +##答 1 +##策 1 +##筛 1 +##筝 1 +##筠 1 +##筱 1 +##筲 1 +##筵 1 +##筷 1 +##筹 1 +##签 1 +##简 1 +##箇 1 +##箋 1 +##箍 1 +##箏 1 +##箐 1 +##箔 1 +##箕 1 +##算 1 +##箝 1 +##管 1 +##箩 1 +##箫 1 +##箭 1 +##箱 1 +##箴 1 +##箸 1 +##節 1 +##篁 1 +##範 1 +##篆 1 +##篇 1 +##築 1 +##篑 1 +##篓 1 +##篙 1 +##篝 1 +##篠 1 +##篡 1 +##篤 1 +##篩 1 +##篪 1 +##篮 1 +##篱 1 +##篷 1 +##簇 1 +##簌 1 +##簍 1 +##簡 1 +##簦 1 +##簧 1 +##簪 1 +##簫 1 +##簷 1 +##簸 1 +##簽 1 +##簾 1 +##簿 1 +##籁 1 +##籃 1 +##籌 1 +##籍 1 +##籐 1 +##籟 1 +##籠 1 +##籤 1 +##籬 1 +##籮 1 +##籲 1 +##米 1 +##类 1 +##籼 1 +##籽 1 +##粄 1 +##粉 1 +##粑 1 +##粒 1 +##粕 1 +##粗 1 +##粘 1 +##粟 1 +##粤 1 +##粥 1 +##粧 1 +##粪 1 +##粮 1 +##粱 1 +##粲 1 +##粳 1 +##粵 1 +##粹 1 +##粼 1 +##粽 1 +##精 1 +##粿 1 +##糅 1 +##糊 1 +##糍 1 +##糕 1 +##糖 1 +##糗 1 +##糙 1 +##糜 1 +##糞 1 +##糟 1 +##糠 1 +##糧 1 +##糬 1 +##糯 1 +##糰 1 +##糸 1 +##系 1 +##糾 1 +##紀 1 +##紂 1 +##約 1 +##紅 1 +##紉 1 +##紊 1 +##紋 1 +##納 1 +##紐 1 +##紓 1 +##純 1 +##紗 1 +##紘 1 +##紙 1 +##級 1 +##紛 1 +##紜 1 +##素 1 +##紡 1 +##索 1 +##紧 1 +##紫 1 +##紮 1 +##累 1 +##細 1 +##紳 1 +##紹 1 +##紺 1 +##終 1 +##絃 1 +##組 1 +##絆 1 +##経 1 +##結 1 +##絕 1 +##絞 1 +##絡 1 +##絢 1 +##給 1 +##絨 1 +##絮 1 +##統 1 +##絲 1 +##絳 1 +##絵 1 +##絶 1 +##絹 1 +##綁 1 +##綏 1 +##綑 1 +##經 1 +##継 1 +##続 1 +##綜 1 +##綠 1 +##綢 1 +##綦 1 +##綫 1 +##綬 1 +##維 1 +##綱 1 +##網 1 +##綴 1 +##綵 1 +##綸 1 +##綺 1 +##綻 1 +##綽 1 +##綾 1 +##綿 1 +##緊 1 +##緋 1 +##総 1 +##緑 1 +##緒 1 +##緘 1 +##線 1 +##緝 1 +##緞 1 +##締 1 +##緣 1 +##編 1 +##緩 1 +##緬 1 +##緯 1 +##練 1 +##緹 1 +##緻 1 +##縁 1 +##縄 1 +##縈 1 +##縛 1 +##縝 1 +##縣 1 +##縫 1 +##縮 1 +##縱 1 +##縴 1 +##縷 1 +##總 1 +##績 1 +##繁 1 +##繃 1 +##繆 1 +##繇 1 +##繋 1 +##織 1 +##繕 1 +##繚 1 +##繞 1 +##繡 1 +##繩 1 +##繪 1 +##繫 1 +##繭 1 +##繳 1 +##繹 1 +##繼 1 +##繽 1 +##纂 1 +##續 1 +##纍 1 +##纏 1 +##纓 1 +##纔 1 +##纖 1 +##纜 1 +##纠 1 +##红 1 +##纣 1 +##纤 1 +##约 1 +##级 1 +##纨 1 +##纪 1 +##纫 1 +##纬 1 +##纭 1 +##纯 1 +##纰 1 +##纱 1 +##纲 1 +##纳 1 +##纵 1 +##纶 1 +##纷 1 +##纸 1 +##纹 1 +##纺 1 +##纽 1 +##纾 1 +##线 1 +##绀 1 +##练 1 +##组 1 +##绅 1 +##细 1 +##织 1 +##终 1 +##绊 1 +##绍 1 +##绎 1 +##经 1 +##绑 1 +##绒 1 +##结 1 +##绔 1 +##绕 1 +##绘 1 +##给 1 +##绚 1 +##绛 1 +##络 1 +##绝 1 +##绞 1 +##统 1 +##绡 1 +##绢 1 +##绣 1 +##绥 1 +##绦 1 +##继 1 +##绩 1 +##绪 1 +##绫 1 +##续 1 +##绮 1 +##绯 1 +##绰 1 +##绳 1 +##维 1 +##绵 1 +##绶 1 +##绷 1 +##绸 1 +##绻 1 +##综 1 +##绽 1 +##绾 1 +##绿 1 +##缀 1 +##缄 1 +##缅 1 +##缆 1 +##缇 1 +##缈 1 +##缉 1 +##缎 1 +##缓 1 +##缔 1 +##缕 1 +##编 1 +##缘 1 +##缙 1 +##缚 1 +##缜 1 +##缝 1 +##缠 1 +##缢 1 +##缤 1 +##缥 1 +##缨 1 +##缩 1 +##缪 1 +##缭 1 +##缮 1 +##缰 1 +##缱 1 +##缴 1 +##缸 1 +##缺 1 +##缽 1 +##罂 1 +##罄 1 +##罌 1 +##罐 1 +##网 1 +##罔 1 +##罕 1 +##罗 1 +##罚 1 +##罡 1 +##罢 1 +##罩 1 +##罪 1 +##置 1 +##罰 1 +##署 1 +##罵 1 +##罷 1 +##罹 1 +##羁 1 +##羅 1 +##羈 1 +##羊 1 +##羌 1 +##美 1 +##羔 1 +##羚 1 +##羞 1 +##羟 1 +##羡 1 +##羣 1 +##群 1 +##羥 1 +##羧 1 +##羨 1 +##義 1 +##羯 1 +##羲 1 +##羸 1 +##羹 1 +##羽 1 +##羿 1 +##翁 1 +##翅 1 +##翊 1 +##翌 1 +##翎 1 +##習 1 +##翔 1 +##翘 1 +##翟 1 +##翠 1 +##翡 1 +##翦 1 +##翩 1 +##翰 1 +##翱 1 +##翳 1 +##翹 1 +##翻 1 +##翼 1 +##耀 1 +##老 1 +##考 1 +##耄 1 +##者 1 +##耆 1 +##耋 1 +##而 1 +##耍 1 +##耐 1 +##耒 1 +##耕 1 +##耗 1 +##耘 1 +##耙 1 +##耦 1 +##耨 1 +##耳 1 +##耶 1 +##耷 1 +##耸 1 +##耻 1 +##耽 1 +##耿 1 +##聂 1 +##聆 1 +##聊 1 +##聋 1 +##职 1 +##聒 1 +##联 1 +##聖 1 +##聘 1 +##聚 1 +##聞 1 +##聪 1 +##聯 1 +##聰 1 +##聲 1 +##聳 1 +##聴 1 +##聶 1 +##職 1 +##聽 1 +##聾 1 +##聿 1 +##肃 1 +##肄 1 +##肅 1 +##肆 1 +##肇 1 +##肉 1 +##肋 1 +##肌 1 +##肏 1 +##肓 1 +##肖 1 +##肘 1 +##肚 1 +##肛 1 +##肝 1 +##肠 1 +##股 1 +##肢 1 +##肤 1 +##肥 1 +##肩 1 +##肪 1 +##肮 1 +##肯 1 +##肱 1 +##育 1 +##肴 1 +##肺 1 +##肽 1 +##肾 1 +##肿 1 +##胀 1 +##胁 1 +##胃 1 +##胄 1 +##胆 1 +##背 1 +##胍 1 +##胎 1 +##胖 1 +##胚 1 +##胛 1 +##胜 1 +##胝 1 +##胞 1 +##胡 1 +##胤 1 +##胥 1 +##胧 1 +##胫 1 +##胭 1 +##胯 1 +##胰 1 +##胱 1 +##胳 1 +##胴 1 +##胶 1 +##胸 1 +##胺 1 +##能 1 +##脂 1 +##脅 1 +##脆 1 +##脇 1 +##脈 1 +##脉 1 +##脊 1 +##脍 1 +##脏 1 +##脐 1 +##脑 1 +##脓 1 +##脖 1 +##脘 1 +##脚 1 +##脛 1 +##脣 1 +##脩 1 +##脫 1 +##脯 1 +##脱 1 +##脲 1 +##脳 1 +##脸 1 +##脹 1 +##脾 1 +##腆 1 +##腈 1 +##腊 1 +##腋 1 +##腌 1 +##腎 1 +##腐 1 +##腑 1 +##腓 1 +##腔 1 +##腕 1 +##腥 1 +##腦 1 +##腩 1 +##腫 1 +##腭 1 +##腮 1 +##腰 1 +##腱 1 +##腳 1 +##腴 1 +##腸 1 +##腹 1 +##腺 1 +##腻 1 +##腼 1 +##腾 1 +##腿 1 +##膀 1 +##膈 1 +##膊 1 +##膏 1 +##膑 1 +##膘 1 +##膚 1 +##膛 1 +##膜 1 +##膝 1 +##膠 1 +##膦 1 +##膨 1 +##膩 1 +##膳 1 +##膺 1 +##膻 1 +##膽 1 +##膾 1 +##膿 1 +##臀 1 +##臂 1 +##臃 1 +##臆 1 +##臉 1 +##臊 1 +##臍 1 +##臓 1 +##臘 1 +##臟 1 +##臣 1 +##臥 1 +##臧 1 +##臨 1 +##自 1 +##臬 1 +##臭 1 +##至 1 +##致 1 +##臺 1 +##臻 1 +##臼 1 +##臾 1 +##舀 1 +##舂 1 +##舅 1 +##舆 1 +##與 1 +##興 1 +##舉 1 +##舊 1 +##舌 1 +##舍 1 +##舎 1 +##舐 1 +##舒 1 +##舔 1 +##舖 1 +##舗 1 +##舛 1 +##舜 1 +##舞 1 +##舟 1 +##航 1 +##舫 1 +##般 1 +##舰 1 +##舱 1 +##舵 1 +##舶 1 +##舷 1 +##舸 1 +##船 1 +##舺 1 +##舾 1 +##艇 1 +##艋 1 +##艘 1 +##艙 1 +##艦 1 +##艮 1 +##良 1 +##艰 1 +##艱 1 +##色 1 +##艳 1 +##艷 1 +##艹 1 +##艺 1 +##艾 1 +##节 1 +##芃 1 +##芈 1 +##芊 1 +##芋 1 +##芍 1 +##芎 1 +##芒 1 +##芙 1 +##芜 1 +##芝 1 +##芡 1 +##芥 1 +##芦 1 +##芩 1 +##芪 1 +##芫 1 +##芬 1 +##芭 1 +##芮 1 +##芯 1 +##花 1 +##芳 1 +##芷 1 +##芸 1 +##芹 1 +##芻 1 +##芽 1 +##芾 1 +##苁 1 +##苄 1 +##苇 1 +##苋 1 +##苍 1 +##苏 1 +##苑 1 +##苒 1 +##苓 1 +##苔 1 +##苕 1 +##苗 1 +##苛 1 +##苜 1 +##苞 1 +##苟 1 +##苡 1 +##苣 1 +##若 1 +##苦 1 +##苫 1 +##苯 1 +##英 1 +##苷 1 +##苹 1 +##苻 1 +##茁 1 +##茂 1 +##范 1 +##茄 1 +##茅 1 +##茉 1 +##茎 1 +##茏 1 +##茗 1 +##茜 1 +##茧 1 +##茨 1 +##茫 1 +##茬 1 +##茭 1 +##茯 1 +##茱 1 +##茲 1 +##茴 1 +##茵 1 +##茶 1 +##茸 1 +##茹 1 +##茼 1 +##荀 1 +##荃 1 +##荆 1 +##草 1 +##荊 1 +##荏 1 +##荐 1 +##荒 1 +##荔 1 +##荖 1 +##荘 1 +##荚 1 +##荞 1 +##荟 1 +##荠 1 +##荡 1 +##荣 1 +##荤 1 +##荥 1 +##荧 1 +##荨 1 +##荪 1 +##荫 1 +##药 1 +##荳 1 +##荷 1 +##荸 1 +##荻 1 +##荼 1 +##荽 1 +##莅 1 +##莆 1 +##莉 1 +##莊 1 +##莎 1 +##莒 1 +##莓 1 +##莖 1 +##莘 1 +##莞 1 +##莠 1 +##莢 1 +##莧 1 +##莪 1 +##莫 1 +##莱 1 +##莲 1 +##莴 1 +##获 1 +##莹 1 +##莺 1 +##莽 1 +##莿 1 +##菀 1 +##菁 1 +##菅 1 +##菇 1 +##菈 1 +##菊 1 +##菌 1 +##菏 1 +##菓 1 +##菖 1 +##菘 1 +##菜 1 +##菟 1 +##菠 1 +##菡 1 +##菩 1 +##華 1 +##菱 1 +##菲 1 +##菸 1 +##菽 1 +##萁 1 +##萃 1 +##萄 1 +##萊 1 +##萋 1 +##萌 1 +##萍 1 +##萎 1 +##萘 1 +##萝 1 +##萤 1 +##营 1 +##萦 1 +##萧 1 +##萨 1 +##萩 1 +##萬 1 +##萱 1 +##萵 1 +##萸 1 +##萼 1 +##落 1 +##葆 1 +##葉 1 +##著 1 +##葚 1 +##葛 1 +##葡 1 +##董 1 +##葦 1 +##葩 1 +##葫 1 +##葬 1 +##葭 1 +##葯 1 +##葱 1 +##葳 1 +##葵 1 +##葷 1 +##葺 1 +##蒂 1 +##蒋 1 +##蒐 1 +##蒔 1 +##蒙 1 +##蒜 1 +##蒞 1 +##蒟 1 +##蒡 1 +##蒨 1 +##蒲 1 +##蒸 1 +##蒹 1 +##蒻 1 +##蒼 1 +##蒿 1 +##蓁 1 +##蓄 1 +##蓆 1 +##蓉 1 +##蓋 1 +##蓑 1 +##蓓 1 +##蓖 1 +##蓝 1 +##蓟 1 +##蓦 1 +##蓬 1 +##蓮 1 +##蓼 1 +##蓿 1 +##蔑 1 +##蔓 1 +##蔔 1 +##蔗 1 +##蔘 1 +##蔚 1 +##蔡 1 +##蔣 1 +##蔥 1 +##蔫 1 +##蔬 1 +##蔭 1 +##蔵 1 +##蔷 1 +##蔺 1 +##蔻 1 +##蔼 1 +##蔽 1 +##蕁 1 +##蕃 1 +##蕈 1 +##蕉 1 +##蕊 1 +##蕎 1 +##蕙 1 +##蕤 1 +##蕨 1 +##蕩 1 +##蕪 1 +##蕭 1 +##蕲 1 +##蕴 1 +##蕻 1 +##蕾 1 +##薄 1 +##薅 1 +##薇 1 +##薈 1 +##薊 1 +##薏 1 +##薑 1 +##薔 1 +##薙 1 +##薛 1 +##薦 1 +##薨 1 +##薩 1 +##薪 1 +##薬 1 +##薯 1 +##薰 1 +##薹 1 +##藉 1 +##藍 1 +##藏 1 +##藐 1 +##藓 1 +##藕 1 +##藜 1 +##藝 1 +##藤 1 +##藥 1 +##藩 1 +##藹 1 +##藻 1 +##藿 1 +##蘆 1 +##蘇 1 +##蘊 1 +##蘋 1 +##蘑 1 +##蘚 1 +##蘭 1 +##蘸 1 +##蘼 1 +##蘿 1 +##虎 1 +##虏 1 +##虐 1 +##虑 1 +##虔 1 +##處 1 +##虚 1 +##虛 1 +##虜 1 +##虞 1 +##號 1 +##虢 1 +##虧 1 +##虫 1 +##虬 1 +##虱 1 +##虹 1 +##虻 1 +##虽 1 +##虾 1 +##蚀 1 +##蚁 1 +##蚂 1 +##蚊 1 +##蚌 1 +##蚓 1 +##蚕 1 +##蚜 1 +##蚝 1 +##蚣 1 +##蚤 1 +##蚩 1 +##蚪 1 +##蚯 1 +##蚱 1 +##蚵 1 +##蛀 1 +##蛆 1 +##蛇 1 +##蛊 1 +##蛋 1 +##蛎 1 +##蛐 1 +##蛔 1 +##蛙 1 +##蛛 1 +##蛟 1 +##蛤 1 +##蛭 1 +##蛮 1 +##蛰 1 +##蛳 1 +##蛹 1 +##蛻 1 +##蛾 1 +##蜀 1 +##蜂 1 +##蜃 1 +##蜆 1 +##蜇 1 +##蜈 1 +##蜊 1 +##蜍 1 +##蜒 1 +##蜓 1 +##蜕 1 +##蜗 1 +##蜘 1 +##蜚 1 +##蜜 1 +##蜡 1 +##蜢 1 +##蜥 1 +##蜱 1 +##蜴 1 +##蜷 1 +##蜻 1 +##蜿 1 +##蝇 1 +##蝈 1 +##蝉 1 +##蝌 1 +##蝎 1 +##蝕 1 +##蝗 1 +##蝙 1 +##蝟 1 +##蝠 1 +##蝦 1 +##蝨 1 +##蝴 1 +##蝶 1 +##蝸 1 +##蝼 1 +##螂 1 +##螃 1 +##融 1 +##螞 1 +##螢 1 +##螨 1 +##螯 1 +##螳 1 +##螺 1 +##蟀 1 +##蟄 1 +##蟆 1 +##蟋 1 +##蟎 1 +##蟑 1 +##蟒 1 +##蟠 1 +##蟬 1 +##蟲 1 +##蟹 1 +##蟻 1 +##蟾 1 +##蠅 1 +##蠍 1 +##蠔 1 +##蠕 1 +##蠛 1 +##蠟 1 +##蠡 1 +##蠢 1 +##蠣 1 +##蠱 1 +##蠶 1 +##蠹 1 +##蠻 1 +##血 1 +##衄 1 +##衅 1 +##衆 1 +##行 1 +##衍 1 +##術 1 +##衔 1 +##街 1 +##衙 1 +##衛 1 +##衝 1 +##衞 1 +##衡 1 +##衢 1 +##衣 1 +##补 1 +##表 1 +##衩 1 +##衫 1 +##衬 1 +##衮 1 +##衰 1 +##衲 1 +##衷 1 +##衹 1 +##衾 1 +##衿 1 +##袁 1 +##袂 1 +##袄 1 +##袅 1 +##袈 1 +##袋 1 +##袍 1 +##袒 1 +##袖 1 +##袜 1 +##袞 1 +##袤 1 +##袪 1 +##被 1 +##袭 1 +##袱 1 +##裁 1 +##裂 1 +##装 1 +##裆 1 +##裊 1 +##裏 1 +##裔 1 +##裕 1 +##裘 1 +##裙 1 +##補 1 +##裝 1 +##裟 1 +##裡 1 +##裤 1 +##裨 1 +##裱 1 +##裳 1 +##裴 1 +##裸 1 +##裹 1 +##製 1 +##裾 1 +##褂 1 +##複 1 +##褐 1 +##褒 1 +##褓 1 +##褔 1 +##褚 1 +##褥 1 +##褪 1 +##褫 1 +##褲 1 +##褶 1 +##褻 1 +##襁 1 +##襄 1 +##襟 1 +##襠 1 +##襪 1 +##襬 1 +##襯 1 +##襲 1 +##西 1 +##要 1 +##覃 1 +##覆 1 +##覇 1 +##見 1 +##規 1 +##覓 1 +##視 1 +##覚 1 +##覦 1 +##覧 1 +##親 1 +##覬 1 +##観 1 +##覷 1 +##覺 1 +##覽 1 +##觀 1 +##见 1 +##观 1 +##规 1 +##觅 1 +##视 1 +##览 1 +##觉 1 +##觊 1 +##觎 1 +##觐 1 +##觑 1 +##角 1 +##觞 1 +##解 1 +##觥 1 +##触 1 +##觸 1 +##言 1 +##訂 1 +##計 1 +##訊 1 +##討 1 +##訓 1 +##訕 1 +##訖 1 +##託 1 +##記 1 +##訛 1 +##訝 1 +##訟 1 +##訣 1 +##訥 1 +##訪 1 +##設 1 +##許 1 +##訳 1 +##訴 1 +##訶 1 +##診 1 +##註 1 +##証 1 +##詆 1 +##詐 1 +##詔 1 +##評 1 +##詛 1 +##詞 1 +##詠 1 +##詡 1 +##詢 1 +##詣 1 +##試 1 +##詩 1 +##詫 1 +##詬 1 +##詭 1 +##詮 1 +##詰 1 +##話 1 +##該 1 +##詳 1 +##詹 1 +##詼 1 +##誅 1 +##誇 1 +##誉 1 +##誌 1 +##認 1 +##誓 1 +##誕 1 +##誘 1 +##語 1 +##誠 1 +##誡 1 +##誣 1 +##誤 1 +##誥 1 +##誦 1 +##誨 1 +##說 1 +##説 1 +##読 1 +##誰 1 +##課 1 +##誹 1 +##誼 1 +##調 1 +##諄 1 +##談 1 +##請 1 +##諏 1 +##諒 1 +##論 1 +##諗 1 +##諜 1 +##諡 1 +##諦 1 +##諧 1 +##諫 1 +##諭 1 +##諮 1 +##諱 1 +##諳 1 +##諷 1 +##諸 1 +##諺 1 +##諾 1 +##謀 1 +##謁 1 +##謂 1 +##謄 1 +##謊 1 +##謎 1 +##謐 1 +##謔 1 +##謗 1 +##謙 1 +##講 1 +##謝 1 +##謠 1 +##謨 1 +##謬 1 +##謹 1 +##謾 1 +##譁 1 +##證 1 +##譎 1 +##譏 1 +##識 1 +##譙 1 +##譚 1 +##譜 1 +##警 1 +##譬 1 +##譯 1 +##議 1 +##譲 1 +##譴 1 +##護 1 +##譽 1 +##讀 1 +##變 1 +##讓 1 +##讚 1 +##讞 1 +##计 1 +##订 1 +##认 1 +##讥 1 +##讧 1 +##讨 1 +##让 1 +##讪 1 +##讫 1 +##训 1 +##议 1 +##讯 1 +##记 1 +##讲 1 +##讳 1 +##讴 1 +##讶 1 +##讷 1 +##许 1 +##讹 1 +##论 1 +##讼 1 +##讽 1 +##设 1 +##访 1 +##诀 1 +##证 1 +##诃 1 +##评 1 +##诅 1 +##识 1 +##诈 1 +##诉 1 +##诊 1 +##诋 1 +##词 1 +##诏 1 +##译 1 +##试 1 +##诗 1 +##诘 1 +##诙 1 +##诚 1 +##诛 1 +##话 1 +##诞 1 +##诟 1 +##诠 1 +##诡 1 +##询 1 +##诣 1 +##诤 1 +##该 1 +##详 1 +##诧 1 +##诩 1 +##诫 1 +##诬 1 +##语 1 +##误 1 +##诰 1 +##诱 1 +##诲 1 +##说 1 +##诵 1 +##诶 1 +##请 1 +##诸 1 +##诺 1 +##读 1 +##诽 1 +##课 1 +##诿 1 +##谀 1 +##谁 1 +##调 1 +##谄 1 +##谅 1 +##谆 1 +##谈 1 +##谊 1 +##谋 1 +##谌 1 +##谍 1 +##谎 1 +##谏 1 +##谐 1 +##谑 1 +##谒 1 +##谓 1 +##谔 1 +##谕 1 +##谗 1 +##谘 1 +##谙 1 +##谚 1 +##谛 1 +##谜 1 +##谟 1 +##谢 1 +##谣 1 +##谤 1 +##谥 1 +##谦 1 +##谧 1 +##谨 1 +##谩 1 +##谪 1 +##谬 1 +##谭 1 +##谯 1 +##谱 1 +##谲 1 +##谴 1 +##谶 1 +##谷 1 +##豁 1 +##豆 1 +##豇 1 +##豈 1 +##豉 1 +##豊 1 +##豌 1 +##豎 1 +##豐 1 +##豔 1 +##豚 1 +##象 1 +##豢 1 +##豪 1 +##豫 1 +##豬 1 +##豹 1 +##豺 1 +##貂 1 +##貅 1 +##貌 1 +##貓 1 +##貔 1 +##貘 1 +##貝 1 +##貞 1 +##負 1 +##財 1 +##貢 1 +##貧 1 +##貨 1 +##販 1 +##貪 1 +##貫 1 +##責 1 +##貯 1 +##貰 1 +##貳 1 +##貴 1 +##貶 1 +##買 1 +##貸 1 +##費 1 +##貼 1 +##貽 1 +##貿 1 +##賀 1 +##賁 1 +##賂 1 +##賃 1 +##賄 1 +##資 1 +##賈 1 +##賊 1 +##賑 1 +##賓 1 +##賜 1 +##賞 1 +##賠 1 +##賡 1 +##賢 1 +##賣 1 +##賤 1 +##賦 1 +##質 1 +##賬 1 +##賭 1 +##賴 1 +##賺 1 +##購 1 +##賽 1 +##贅 1 +##贈 1 +##贊 1 +##贍 1 +##贏 1 +##贓 1 +##贖 1 +##贛 1 +##贝 1 +##贞 1 +##负 1 +##贡 1 +##财 1 +##责 1 +##贤 1 +##败 1 +##账 1 +##货 1 +##质 1 +##贩 1 +##贪 1 +##贫 1 +##贬 1 +##购 1 +##贮 1 +##贯 1 +##贰 1 +##贱 1 +##贲 1 +##贴 1 +##贵 1 +##贷 1 +##贸 1 +##费 1 +##贺 1 +##贻 1 +##贼 1 +##贾 1 +##贿 1 +##赁 1 +##赂 1 +##赃 1 +##资 1 +##赅 1 +##赈 1 +##赊 1 +##赋 1 +##赌 1 +##赎 1 +##赏 1 +##赐 1 +##赓 1 +##赔 1 +##赖 1 +##赘 1 +##赚 1 +##赛 1 +##赝 1 +##赞 1 +##赠 1 +##赡 1 +##赢 1 +##赣 1 +##赤 1 +##赦 1 +##赧 1 +##赫 1 +##赭 1 +##走 1 +##赳 1 +##赴 1 +##赵 1 +##赶 1 +##起 1 +##趁 1 +##超 1 +##越 1 +##趋 1 +##趕 1 +##趙 1 +##趟 1 +##趣 1 +##趨 1 +##足 1 +##趴 1 +##趵 1 +##趸 1 +##趺 1 +##趾 1 +##跃 1 +##跄 1 +##跆 1 +##跋 1 +##跌 1 +##跎 1 +##跑 1 +##跖 1 +##跚 1 +##跛 1 +##距 1 +##跟 1 +##跡 1 +##跤 1 +##跨 1 +##跩 1 +##跪 1 +##路 1 +##跳 1 +##践 1 +##跷 1 +##跹 1 +##跺 1 +##跻 1 +##踉 1 +##踊 1 +##踌 1 +##踏 1 +##踐 1 +##踝 1 +##踞 1 +##踟 1 +##踢 1 +##踩 1 +##踪 1 +##踮 1 +##踱 1 +##踴 1 +##踵 1 +##踹 1 +##蹂 1 +##蹄 1 +##蹇 1 +##蹈 1 +##蹉 1 +##蹊 1 +##蹋 1 +##蹑 1 +##蹒 1 +##蹙 1 +##蹟 1 +##蹣 1 +##蹤 1 +##蹦 1 +##蹩 1 +##蹬 1 +##蹭 1 +##蹲 1 +##蹴 1 +##蹶 1 +##蹺 1 +##蹼 1 +##蹿 1 +##躁 1 +##躇 1 +##躉 1 +##躊 1 +##躋 1 +##躍 1 +##躏 1 +##躪 1 +##身 1 +##躬 1 +##躯 1 +##躲 1 +##躺 1 +##軀 1 +##車 1 +##軋 1 +##軌 1 +##軍 1 +##軒 1 +##軟 1 +##転 1 +##軸 1 +##軼 1 +##軽 1 +##軾 1 +##較 1 +##載 1 +##輒 1 +##輓 1 +##輔 1 +##輕 1 +##輛 1 +##輝 1 +##輟 1 +##輩 1 +##輪 1 +##輯 1 +##輸 1 +##輻 1 +##輾 1 +##輿 1 +##轄 1 +##轅 1 +##轆 1 +##轉 1 +##轍 1 +##轎 1 +##轟 1 +##车 1 +##轧 1 +##轨 1 +##轩 1 +##转 1 +##轭 1 +##轮 1 +##软 1 +##轰 1 +##轲 1 +##轴 1 +##轶 1 +##轻 1 +##轼 1 +##载 1 +##轿 1 +##较 1 +##辄 1 +##辅 1 +##辆 1 +##辇 1 +##辈 1 +##辉 1 +##辊 1 +##辍 1 +##辐 1 +##辑 1 +##输 1 +##辕 1 +##辖 1 +##辗 1 +##辘 1 +##辙 1 +##辛 1 +##辜 1 +##辞 1 +##辟 1 +##辣 1 +##辦 1 +##辨 1 +##辩 1 +##辫 1 +##辭 1 +##辮 1 +##辯 1 +##辰 1 +##辱 1 +##農 1 +##边 1 +##辺 1 +##辻 1 +##込 1 +##辽 1 +##达 1 +##迁 1 +##迂 1 +##迄 1 +##迅 1 +##过 1 +##迈 1 +##迎 1 +##运 1 +##近 1 +##返 1 +##还 1 +##这 1 +##进 1 +##远 1 +##违 1 +##连 1 +##迟 1 +##迢 1 +##迤 1 +##迥 1 +##迦 1 +##迩 1 +##迪 1 +##迫 1 +##迭 1 +##述 1 +##迴 1 +##迷 1 +##迸 1 +##迹 1 +##迺 1 +##追 1 +##退 1 +##送 1 +##适 1 +##逃 1 +##逅 1 +##逆 1 +##选 1 +##逊 1 +##逍 1 +##透 1 +##逐 1 +##递 1 +##途 1 +##逕 1 +##逗 1 +##這 1 +##通 1 +##逛 1 +##逝 1 +##逞 1 +##速 1 +##造 1 +##逢 1 +##連 1 +##逮 1 +##週 1 +##進 1 +##逵 1 +##逶 1 +##逸 1 +##逻 1 +##逼 1 +##逾 1 +##遁 1 +##遂 1 +##遅 1 +##遇 1 +##遊 1 +##運 1 +##遍 1 +##過 1 +##遏 1 +##遐 1 +##遑 1 +##遒 1 +##道 1 +##達 1 +##違 1 +##遗 1 +##遙 1 +##遛 1 +##遜 1 +##遞 1 +##遠 1 +##遢 1 +##遣 1 +##遥 1 +##遨 1 +##適 1 +##遭 1 +##遮 1 +##遲 1 +##遴 1 +##遵 1 +##遶 1 +##遷 1 +##選 1 +##遺 1 +##遼 1 +##遽 1 +##避 1 +##邀 1 +##邁 1 +##邂 1 +##邃 1 +##還 1 +##邇 1 +##邈 1 +##邊 1 +##邋 1 +##邏 1 +##邑 1 +##邓 1 +##邕 1 +##邛 1 +##邝 1 +##邢 1 +##那 1 +##邦 1 +##邨 1 +##邪 1 +##邬 1 +##邮 1 +##邯 1 +##邰 1 +##邱 1 +##邳 1 +##邵 1 +##邸 1 +##邹 1 +##邺 1 +##邻 1 +##郁 1 +##郅 1 +##郊 1 +##郎 1 +##郑 1 +##郜 1 +##郝 1 +##郡 1 +##郢 1 +##郤 1 +##郦 1 +##郧 1 +##部 1 +##郫 1 +##郭 1 +##郴 1 +##郵 1 +##郷 1 +##郸 1 +##都 1 +##鄂 1 +##鄉 1 +##鄒 1 +##鄔 1 +##鄙 1 +##鄞 1 +##鄢 1 +##鄧 1 +##鄭 1 +##鄰 1 +##鄱 1 +##鄲 1 +##鄺 1 +##酉 1 +##酊 1 +##酋 1 +##酌 1 +##配 1 +##酐 1 +##酒 1 +##酗 1 +##酚 1 +##酝 1 +##酢 1 +##酣 1 +##酥 1 +##酩 1 +##酪 1 +##酬 1 +##酮 1 +##酯 1 +##酰 1 +##酱 1 +##酵 1 +##酶 1 +##酷 1 +##酸 1 +##酿 1 +##醃 1 +##醇 1 +##醉 1 +##醋 1 +##醍 1 +##醐 1 +##醒 1 +##醚 1 +##醛 1 +##醜 1 +##醞 1 +##醣 1 +##醪 1 +##醫 1 +##醬 1 +##醮 1 +##醯 1 +##醴 1 +##醺 1 +##釀 1 +##釁 1 +##采 1 +##釉 1 +##释 1 +##釋 1 +##里 1 +##重 1 +##野 1 +##量 1 +##釐 1 +##金 1 +##釗 1 +##釘 1 +##釜 1 +##針 1 +##釣 1 +##釦 1 +##釧 1 +##釵 1 +##鈀 1 +##鈉 1 +##鈍 1 +##鈎 1 +##鈔 1 +##鈕 1 +##鈞 1 +##鈣 1 +##鈦 1 +##鈪 1 +##鈴 1 +##鈺 1 +##鈾 1 +##鉀 1 +##鉄 1 +##鉅 1 +##鉉 1 +##鉑 1 +##鉗 1 +##鉚 1 +##鉛 1 +##鉤 1 +##鉴 1 +##鉻 1 +##銀 1 +##銃 1 +##銅 1 +##銑 1 +##銓 1 +##銖 1 +##銘 1 +##銜 1 +##銬 1 +##銭 1 +##銮 1 +##銳 1 +##銷 1 +##銹 1 +##鋁 1 +##鋅 1 +##鋒 1 +##鋤 1 +##鋪 1 +##鋰 1 +##鋸 1 +##鋼 1 +##錄 1 +##錐 1 +##錘 1 +##錚 1 +##錠 1 +##錢 1 +##錦 1 +##錨 1 +##錫 1 +##錮 1 +##錯 1 +##録 1 +##錳 1 +##錶 1 +##鍊 1 +##鍋 1 +##鍍 1 +##鍛 1 +##鍥 1 +##鍰 1 +##鍵 1 +##鍺 1 +##鍾 1 +##鎂 1 +##鎊 1 +##鎌 1 +##鎏 1 +##鎔 1 +##鎖 1 +##鎗 1 +##鎚 1 +##鎧 1 +##鎬 1 +##鎮 1 +##鎳 1 +##鏈 1 +##鏖 1 +##鏗 1 +##鏘 1 +##鏞 1 +##鏟 1 +##鏡 1 +##鏢 1 +##鏤 1 +##鏽 1 +##鐘 1 +##鐮 1 +##鐲 1 +##鐳 1 +##鐵 1 +##鐸 1 +##鐺 1 +##鑄 1 +##鑊 1 +##鑑 1 +##鑒 1 +##鑣 1 +##鑫 1 +##鑰 1 +##鑲 1 +##鑼 1 +##鑽 1 +##鑾 1 +##鑿 1 +##针 1 +##钉 1 +##钊 1 +##钎 1 +##钏 1 +##钒 1 +##钓 1 +##钗 1 +##钙 1 +##钛 1 +##钜 1 +##钝 1 +##钞 1 +##钟 1 +##钠 1 +##钡 1 +##钢 1 +##钣 1 +##钤 1 +##钥 1 +##钦 1 +##钧 1 +##钨 1 +##钩 1 +##钮 1 +##钯 1 +##钰 1 +##钱 1 +##钳 1 +##钴 1 +##钵 1 +##钺 1 +##钻 1 +##钼 1 +##钾 1 +##钿 1 +##铀 1 +##铁 1 +##铂 1 +##铃 1 +##铄 1 +##铅 1 +##铆 1 +##铉 1 +##铎 1 +##铐 1 +##铛 1 +##铜 1 +##铝 1 +##铠 1 +##铡 1 +##铢 1 +##铣 1 +##铤 1 +##铨 1 +##铩 1 +##铬 1 +##铭 1 +##铮 1 +##铰 1 +##铲 1 +##铵 1 +##银 1 +##铸 1 +##铺 1 +##链 1 +##铿 1 +##销 1 +##锁 1 +##锂 1 +##锄 1 +##锅 1 +##锆 1 +##锈 1 +##锉 1 +##锋 1 +##锌 1 +##锏 1 +##锐 1 +##锑 1 +##错 1 +##锚 1 +##锟 1 +##锡 1 +##锢 1 +##锣 1 +##锤 1 +##锥 1 +##锦 1 +##锭 1 +##键 1 +##锯 1 +##锰 1 +##锲 1 +##锵 1 +##锹 1 +##锺 1 +##锻 1 +##镀 1 +##镁 1 +##镂 1 +##镇 1 +##镉 1 +##镌 1 +##镍 1 +##镐 1 +##镑 1 +##镕 1 +##镖 1 +##镗 1 +##镛 1 +##镜 1 +##镣 1 +##镭 1 +##镯 1 +##镰 1 +##镳 1 +##镶 1 +##長 1 +##长 1 +##門 1 +##閃 1 +##閉 1 +##開 1 +##閎 1 +##閏 1 +##閑 1 +##閒 1 +##間 1 +##閔 1 +##閘 1 +##閡 1 +##関 1 +##閣 1 +##閥 1 +##閨 1 +##閩 1 +##閱 1 +##閲 1 +##閹 1 +##閻 1 +##閾 1 +##闆 1 +##闇 1 +##闊 1 +##闌 1 +##闍 1 +##闔 1 +##闕 1 +##闖 1 +##闘 1 +##關 1 +##闡 1 +##闢 1 +##门 1 +##闪 1 +##闫 1 +##闭 1 +##问 1 +##闯 1 +##闰 1 +##闲 1 +##间 1 +##闵 1 +##闷 1 +##闸 1 +##闹 1 +##闺 1 +##闻 1 +##闽 1 +##闾 1 +##阀 1 +##阁 1 +##阂 1 +##阅 1 +##阆 1 +##阇 1 +##阈 1 +##阉 1 +##阎 1 +##阐 1 +##阑 1 +##阔 1 +##阕 1 +##阖 1 +##阙 1 +##阚 1 +##阜 1 +##队 1 +##阡 1 +##阪 1 +##阮 1 +##阱 1 +##防 1 +##阳 1 +##阴 1 +##阵 1 +##阶 1 +##阻 1 +##阿 1 +##陀 1 +##陂 1 +##附 1 +##际 1 +##陆 1 +##陇 1 +##陈 1 +##陋 1 +##陌 1 +##降 1 +##限 1 +##陕 1 +##陛 1 +##陝 1 +##陞 1 +##陟 1 +##陡 1 +##院 1 +##陣 1 +##除 1 +##陨 1 +##险 1 +##陪 1 +##陰 1 +##陲 1 +##陳 1 +##陵 1 +##陶 1 +##陷 1 +##陸 1 +##険 1 +##陽 1 +##隅 1 +##隆 1 +##隈 1 +##隊 1 +##隋 1 +##隍 1 +##階 1 +##随 1 +##隐 1 +##隔 1 +##隕 1 +##隘 1 +##隙 1 +##際 1 +##障 1 +##隠 1 +##隣 1 +##隧 1 +##隨 1 +##險 1 +##隱 1 +##隴 1 +##隶 1 +##隸 1 +##隻 1 +##隼 1 +##隽 1 +##难 1 +##雀 1 +##雁 1 +##雄 1 +##雅 1 +##集 1 +##雇 1 +##雉 1 +##雋 1 +##雌 1 +##雍 1 +##雎 1 +##雏 1 +##雑 1 +##雒 1 +##雕 1 +##雖 1 +##雙 1 +##雛 1 +##雜 1 +##雞 1 +##離 1 +##難 1 +##雨 1 +##雪 1 +##雯 1 +##雰 1 +##雲 1 +##雳 1 +##零 1 +##雷 1 +##雹 1 +##電 1 +##雾 1 +##需 1 +##霁 1 +##霄 1 +##霆 1 +##震 1 +##霈 1 +##霉 1 +##霊 1 +##霍 1 +##霎 1 +##霏 1 +##霑 1 +##霓 1 +##霖 1 +##霜 1 +##霞 1 +##霧 1 +##霭 1 +##霰 1 +##露 1 +##霸 1 +##霹 1 +##霽 1 +##霾 1 +##靂 1 +##靄 1 +##靈 1 +##青 1 +##靓 1 +##靖 1 +##静 1 +##靚 1 +##靛 1 +##靜 1 +##非 1 +##靠 1 +##靡 1 +##面 1 +##靥 1 +##靦 1 +##革 1 +##靳 1 +##靴 1 +##靶 1 +##靼 1 +##鞅 1 +##鞋 1 +##鞍 1 +##鞏 1 +##鞑 1 +##鞘 1 +##鞠 1 +##鞣 1 +##鞦 1 +##鞭 1 +##韆 1 +##韋 1 +##韌 1 +##韓 1 +##韜 1 +##韦 1 +##韧 1 +##韩 1 +##韬 1 +##韭 1 +##音 1 +##韵 1 +##韶 1 +##韻 1 +##響 1 +##頁 1 +##頂 1 +##頃 1 +##項 1 +##順 1 +##須 1 +##頌 1 +##預 1 +##頑 1 +##頒 1 +##頓 1 +##頗 1 +##領 1 +##頜 1 +##頡 1 +##頤 1 +##頫 1 +##頭 1 +##頰 1 +##頷 1 +##頸 1 +##頹 1 +##頻 1 +##頼 1 +##顆 1 +##題 1 +##額 1 +##顎 1 +##顏 1 +##顔 1 +##願 1 +##顛 1 +##類 1 +##顧 1 +##顫 1 +##顯 1 +##顱 1 +##顴 1 +##页 1 +##顶 1 +##顷 1 +##项 1 +##顺 1 +##须 1 +##顼 1 +##顽 1 +##顾 1 +##顿 1 +##颁 1 +##颂 1 +##预 1 +##颅 1 +##领 1 +##颇 1 +##颈 1 +##颉 1 +##颊 1 +##颌 1 +##颍 1 +##颐 1 +##频 1 +##颓 1 +##颔 1 +##颖 1 +##颗 1 +##题 1 +##颚 1 +##颛 1 +##颜 1 +##额 1 +##颞 1 +##颠 1 +##颡 1 +##颢 1 +##颤 1 +##颦 1 +##颧 1 +##風 1 +##颯 1 +##颱 1 +##颳 1 +##颶 1 +##颼 1 +##飄 1 +##飆 1 +##风 1 +##飒 1 +##飓 1 +##飕 1 +##飘 1 +##飙 1 +##飚 1 +##飛 1 +##飞 1 +##食 1 +##飢 1 +##飨 1 +##飩 1 +##飪 1 +##飯 1 +##飲 1 +##飼 1 +##飽 1 +##飾 1 +##餃 1 +##餅 1 +##餉 1 +##養 1 +##餌 1 +##餐 1 +##餒 1 +##餓 1 +##餘 1 +##餚 1 +##餛 1 +##餞 1 +##餡 1 +##館 1 +##餮 1 +##餵 1 +##餾 1 +##饅 1 +##饈 1 +##饋 1 +##饌 1 +##饍 1 +##饑 1 +##饒 1 +##饕 1 +##饗 1 +##饞 1 +##饥 1 +##饨 1 +##饪 1 +##饬 1 +##饭 1 +##饮 1 +##饯 1 +##饰 1 +##饱 1 +##饲 1 +##饴 1 +##饵 1 +##饶 1 +##饷 1 +##饺 1 +##饼 1 +##饽 1 +##饿 1 +##馀 1 +##馁 1 +##馄 1 +##馅 1 +##馆 1 +##馈 1 +##馋 1 +##馍 1 +##馏 1 +##馒 1 +##馔 1 +##首 1 +##馗 1 +##香 1 +##馥 1 +##馨 1 +##馬 1 +##馭 1 +##馮 1 +##馳 1 +##馴 1 +##駁 1 +##駄 1 +##駅 1 +##駆 1 +##駐 1 +##駒 1 +##駕 1 +##駛 1 +##駝 1 +##駭 1 +##駱 1 +##駿 1 +##騁 1 +##騎 1 +##騏 1 +##験 1 +##騙 1 +##騨 1 +##騰 1 +##騷 1 +##驀 1 +##驅 1 +##驊 1 +##驍 1 +##驒 1 +##驕 1 +##驗 1 +##驚 1 +##驛 1 +##驟 1 +##驢 1 +##驥 1 +##马 1 +##驭 1 +##驮 1 +##驯 1 +##驰 1 +##驱 1 +##驳 1 +##驴 1 +##驶 1 +##驷 1 +##驸 1 +##驹 1 +##驻 1 +##驼 1 +##驾 1 +##驿 1 +##骁 1 +##骂 1 +##骄 1 +##骅 1 +##骆 1 +##骇 1 +##骈 1 +##骊 1 +##骋 1 +##验 1 +##骏 1 +##骐 1 +##骑 1 +##骗 1 +##骚 1 +##骛 1 +##骜 1 +##骞 1 +##骠 1 +##骡 1 +##骤 1 +##骥 1 +##骧 1 +##骨 1 +##骯 1 +##骰 1 +##骶 1 +##骷 1 +##骸 1 +##骼 1 +##髂 1 +##髅 1 +##髋 1 +##髏 1 +##髒 1 +##髓 1 +##體 1 +##髖 1 +##高 1 +##髦 1 +##髪 1 +##髮 1 +##髯 1 +##髻 1 +##鬃 1 +##鬆 1 +##鬍 1 +##鬓 1 +##鬚 1 +##鬟 1 +##鬢 1 +##鬣 1 +##鬥 1 +##鬧 1 +##鬱 1 +##鬼 1 +##魁 1 +##魂 1 +##魄 1 +##魅 1 +##魇 1 +##魍 1 +##魏 1 +##魔 1 +##魘 1 +##魚 1 +##魯 1 +##魷 1 +##鮑 1 +##鮨 1 +##鮪 1 +##鮭 1 +##鮮 1 +##鯉 1 +##鯊 1 +##鯖 1 +##鯛 1 +##鯨 1 +##鯰 1 +##鯽 1 +##鰍 1 +##鰓 1 +##鰭 1 +##鰲 1 +##鰻 1 +##鰾 1 +##鱈 1 +##鱉 1 +##鱔 1 +##鱗 1 +##鱷 1 +##鱸 1 +##鱼 1 +##鱿 1 +##鲁 1 +##鲈 1 +##鲍 1 +##鲑 1 +##鲛 1 +##鲜 1 +##鲟 1 +##鲢 1 +##鲤 1 +##鲨 1 +##鲫 1 +##鲱 1 +##鲲 1 +##鲶 1 +##鲷 1 +##鲸 1 +##鳃 1 +##鳄 1 +##鳅 1 +##鳌 1 +##鳍 1 +##鳕 1 +##鳖 1 +##鳗 1 +##鳝 1 +##鳞 1 +##鳥 1 +##鳩 1 +##鳳 1 +##鳴 1 +##鳶 1 +##鴉 1 +##鴕 1 +##鴛 1 +##鴦 1 +##鴨 1 +##鴻 1 +##鴿 1 +##鵑 1 +##鵜 1 +##鵝 1 +##鵡 1 +##鵬 1 +##鵰 1 +##鵲 1 +##鶘 1 +##鶩 1 +##鶯 1 +##鶴 1 +##鷗 1 +##鷲 1 +##鷹 1 +##鷺 1 +##鸚 1 +##鸞 1 +##鸟 1 +##鸠 1 +##鸡 1 +##鸢 1 +##鸣 1 +##鸥 1 +##鸦 1 +##鸨 1 +##鸪 1 +##鸭 1 +##鸯 1 +##鸳 1 +##鸵 1 +##鸽 1 +##鸾 1 +##鸿 1 +##鹂 1 +##鹃 1 +##鹄 1 +##鹅 1 +##鹈 1 +##鹉 1 +##鹊 1 +##鹌 1 +##鹏 1 +##鹑 1 +##鹕 1 +##鹘 1 +##鹜 1 +##鹞 1 +##鹤 1 +##鹦 1 +##鹧 1 +##鹫 1 +##鹭 1 +##鹰 1 +##鹳 1 +##鹵 1 +##鹹 1 +##鹼 1 +##鹽 1 +##鹿 1 +##麂 1 +##麋 1 +##麒 1 +##麓 1 +##麗 1 +##麝 1 +##麟 1 +##麥 1 +##麦 1 +##麩 1 +##麴 1 +##麵 1 +##麸 1 +##麺 1 +##麻 1 +##麼 1 +##麽 1 +##麾 1 +##黃 1 +##黄 1 +##黍 1 +##黎 1 +##黏 1 +##黑 1 +##黒 1 +##黔 1 +##默 1 +##黛 1 +##黜 1 +##黝 1 +##點 1 +##黠 1 +##黨 1 +##黯 1 +##黴 1 +##鼋 1 +##鼎 1 +##鼐 1 +##鼓 1 +##鼠 1 +##鼬 1 +##鼹 1 +##鼻 1 +##鼾 1 +##齁 1 +##齊 1 +##齋 1 +##齐 1 +##齒 1 +##齡 1 +##齢 1 +##齣 1 +##齦 1 +##齿 1 +##龄 1 +##龅 1 +##龈 1 +##龊 1 +##龋 1 +##龌 1 +##龍 1 +##龐 1 +##龔 1 +##龕 1 +##龙 1 +##龚 1 +##龛 1 +##龜 1 +##龟 1 +##︰ 1 +##︱ 1 +##︶ 1 +##︿ 1 +##﹁ 1 +##﹂ 1 +##﹍ 1 +##﹏ 1 +##﹐ 1 +##﹑ 1 +##﹒ 1 +##﹔ 1 +##﹕ 1 +##﹖ 1 +##﹗ 1 +##﹙ 1 +##﹚ 1 +##﹝ 1 +##﹞ 1 +##﹡ 1 +##﹣ 1 +##！ 1 +##＂ 1 +##＃ 1 +##＄ 1 +##％ 1 +##＆ 1 +##＇ 1 +##（ 1 +##） 1 +##＊ 1 +##， 1 +##－ 1 +##． 1 +##／ 1 +##： 1 +##； 1 +##＜ 1 +##？ 1 +##＠ 1 +##［ 1 +##＼ 1 +##］ 1 +##＾ 1 +##＿ 1 +##｀ 1 +##ｆ 1 +##ｈ 1 +##ｊ 1 +##ｕ 1 +##ｗ 1 +##ｚ 1 +##｛ 1 +##｝ 1 +##｡ 1 +##｢ 1 +##｣ 1 +##､ 1 +##･ 1 +##ｯ 1 +##ｰ 1 +##ｲ 1 +##ｸ 1 +##ｼ 1 +##ｽ 1 +##ﾄ 1 +##ﾉ 1 +##ﾌ 1 +##ﾗ 1 +##ﾙ 1 +##ﾝ 1 +##ﾞ 1 +##ﾟ 1 +##￣ 1 +##￥ 1 +##👍 1 +##🔥 1 +##😂 1 +##😎 1 diff --git a/utils/BERT_CN_dict/vocab.txt b/utils/BERT_CN_dict/vocab.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca4f9781030019ab9b253c6dcb8c7878b6dc87a5 --- /dev/null +++ b/utils/BERT_CN_dict/vocab.txt @@ -0,0 +1,21128 @@ +[PAD] +[unused1] +[unused2] +[unused3] +[unused4] +[unused5] +[unused6] +[unused7] +[unused8] +[unused9] +[unused10] +[unused11] +[unused12] +[unused13] +[unused14] +[unused15] +[unused16] +[unused17] +[unused18] +[unused19] +[unused20] +[unused21] +[unused22] +[unused23] +[unused24] +[unused25] +[unused26] +[unused27] +[unused28] +[unused29] +[unused30] +[unused31] +[unused32] +[unused33] +[unused34] +[unused35] +[unused36] +[unused37] +[unused38] +[unused39] +[unused40] +[unused41] +[unused42] +[unused43] +[unused44] +[unused45] +[unused46] +[unused47] +[unused48] +[unused49] +[unused50] +[unused51] +[unused52] +[unused53] +[unused54] +[unused55] +[unused56] +[unused57] +[unused58] +[unused59] +[unused60] +[unused61] +[unused62] +[unused63] +[unused64] +[unused65] +[unused66] +[unused67] +[unused68] +[unused69] +[unused70] +[unused71] +[unused72] +[unused73] +[unused74] +[unused75] +[unused76] +[unused77] +[unused78] +[unused79] +[unused80] +[unused81] +[unused82] +[unused83] +[unused84] +[unused85] +[unused86] +[unused87] +[unused88] +[unused89] +[unused90] +[unused91] +[unused92] +[unused93] +[unused94] +[unused95] +[unused96] +[unused97] +[unused98] +[unused99] +[UNK] +[CLS] +[SEP] +[MASK] +<S> +<T> +! +" +# +$ +% +& +' +( +) +* ++ +, +- +. +/ +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +: +; +< += +> +? +@ +[ +\ +] +^ +_ +a +b +c +d +e +f +g +h +i +j +k +l +m +n +o +p +q +r +s +t +u +v +w +x +y +z +{ +| +} +~ +£ +¤ +¥ +§ +© +« +® +° +± +² +³ +µ +· +¹ +º +» +¼ +× +ß +æ +÷ +ø +đ +ŋ +ɔ +ə +ɡ +ʰ +ˇ +ˈ +ˊ +ˋ +ˍ +ː +˙ +˚ +ˢ +α +β +γ +δ +ε +η +θ +ι +κ +λ +μ +ν +ο +π +ρ +ς +σ +τ +υ +φ +χ +ψ +ω +а +б +в +г +д +е +ж +з +и +к +л +м +н +о +п +р +с +т +у +ф +х +ц +ч +ш +ы +ь +я +і +ا +ب +ة +ت +د +ر +س +ع +ل +م +ن +ه +و +ي +۩ +ก +ง +น +ม +ย +ร +อ +า +เ +๑ +་ +ღ +ᄀ +ᄁ +ᄂ +ᄃ +ᄅ +ᄆ +ᄇ +ᄈ +ᄉ +ᄋ +ᄌ +ᄎ +ᄏ +ᄐ +ᄑ +ᄒ +ᅡ +ᅢ +ᅣ +ᅥ +ᅦ +ᅧ +ᅨ +ᅩ +ᅪ +ᅬ +ᅭ +ᅮ +ᅯ +ᅲ +ᅳ +ᅴ +ᅵ +ᆨ +ᆫ +ᆯ +ᆷ +ᆸ +ᆺ +ᆻ +ᆼ +ᗜ +ᵃ +ᵉ +ᵍ +ᵏ +ᵐ +ᵒ +ᵘ +‖ +„ +† +• +‥ +‧ +
 +‰ +′ +″ +‹ +› +※ +‿ +⁄ +ⁱ +⁺ +ⁿ +₁ +₂ +₃ +₄ +€ +℃ +№ +™ +ⅰ +ⅱ +ⅲ +ⅳ +ⅴ +← +↑ +→ +↓ +↔ +↗ +↘ +⇒ +∀ +− +∕ +∙ +√ +∞ +∟ +∠ +∣ +∥ +∩ +∮ +∶ +∼ +∽ +≈ +≒ +≡ +≤ +≥ +≦ +≧ +≪ +≫ +⊙ +⋅ +⋈ +⋯ +⌒ +① +② +③ +④ +⑤ +⑥ +⑦ +⑧ +⑨ +⑩ +⑴ +⑵ +⑶ +⑷ +⑸ +⒈ +⒉ +⒊ +⒋ +ⓒ +ⓔ +ⓘ +─ +━ +│ +┃ +┅ +┆ +┊ +┌ +└ +├ +┣ +═ +║ +╚ +╞ +╠ +╭ +╮ +╯ +╰ +╱ +╳ +▂ +▃ +▅ +▇ +█ +▉ +▋ +▌ +▍ +▎ +■ +□ +▪ +▫ +▬ +▲ +△ +▶ +► +▼ +▽ +◆ +◇ +○ +◎ +● +◕ +◠ +◢ +◤ +☀ +★ +☆ +☕ +☞ +☺ +☼ +♀ +♂ +♠ +♡ +♣ +♥ +♦ +♪ +♫ +♬ +✈ +✔ +✕ +✖ +✦ +✨ +✪ +✰ +✿ +❀ +❤ +➜ +➤ +⦿ +、 +。 +〃 +々 +〇 +〈 +〉 +《 +》 +「 +」 +『 +』 +【 +】 +〓 +〔 +〕 +〖 +〗 +〜 +〝 +〞 +ぁ +あ +ぃ +い +う +ぇ +え +お +か +き +く +け +こ +さ +し +す +せ +そ +た +ち +っ +つ +て +と +な +に +ぬ +ね +の +は +ひ +ふ +へ +ほ +ま +み +む +め +も +ゃ +や +ゅ +ゆ +ょ +よ +ら +り +る +れ +ろ +わ +を +ん +゜ +ゝ +ァ +ア +ィ +イ +ゥ +ウ +ェ +エ +ォ +オ +カ +キ +ク +ケ +コ +サ +シ +ス +セ +ソ +タ +チ +ッ +ツ +テ +ト +ナ +ニ +ヌ +ネ +ノ +ハ +ヒ +フ +ヘ +ホ +マ +ミ +ム +メ +モ +ャ +ヤ +ュ +ユ +ョ +ヨ +ラ +リ +ル +レ +ロ +ワ +ヲ +ン +ヶ +・ +ー +ヽ +ㄅ +ㄆ +ㄇ +ㄉ +ㄋ +ㄌ +ㄍ +ㄎ +ㄏ +ㄒ +ㄚ +ㄛ +ㄞ +ㄟ +ㄢ +ㄤ +ㄥ +ㄧ +ㄨ +ㆍ +㈦ +㊣ +㎡ +㗎 +一 +丁 +七 +万 +丈 +三 +上 +下 +不 +与 +丐 +丑 +专 +且 +丕 +世 +丘 +丙 +业 +丛 +东 +丝 +丞 +丟 +両 +丢 +两 +严 +並 +丧 +丨 +个 +丫 +中 +丰 +串 +临 +丶 +丸 +丹 +为 +主 +丼 +丽 +举 +丿 +乂 +乃 +久 +么 +义 +之 +乌 +乍 +乎 +乏 +乐 +乒 +乓 +乔 +乖 +乗 +乘 +乙 +乜 +九 +乞 +也 +习 +乡 +书 +乩 +买 +乱 +乳 +乾 +亀 +亂 +了 +予 +争 +事 +二 +于 +亏 +云 +互 +五 +井 +亘 +亙 +亚 +些 +亜 +亞 +亟 +亡 +亢 +交 +亥 +亦 +产 +亨 +亩 +享 +京 +亭 +亮 +亲 +亳 +亵 +人 +亿 +什 +仁 +仃 +仄 +仅 +仆 +仇 +今 +介 +仍 +从 +仏 +仑 +仓 +仔 +仕 +他 +仗 +付 +仙 +仝 +仞 +仟 +代 +令 +以 +仨 +仪 +们 +仮 +仰 +仲 +件 +价 +任 +份 +仿 +企 +伉 +伊 +伍 +伎 +伏 +伐 +休 +伕 +众 +优 +伙 +会 +伝 +伞 +伟 +传 +伢 +伤 +伦 +伪 +伫 +伯 +估 +伴 +伶 +伸 +伺 +似 +伽 +佃 +但 +佇 +佈 +位 +低 +住 +佐 +佑 +体 +佔 +何 +佗 +佘 +余 +佚 +佛 +作 +佝 +佞 +佟 +你 +佢 +佣 +佤 +佥 +佩 +佬 +佯 +佰 +佳 +併 +佶 +佻 +佼 +使 +侃 +侄 +來 +侈 +例 +侍 +侏 +侑 +侖 +侗 +供 +依 +侠 +価 +侣 +侥 +侦 +侧 +侨 +侬 +侮 +侯 +侵 +侶 +侷 +便 +係 +促 +俄 +俊 +俎 +俏 +俐 +俑 +俗 +俘 +俚 +保 +俞 +俟 +俠 +信 +俨 +俩 +俪 +俬 +俭 +修 +俯 +俱 +俳 +俸 +俺 +俾 +倆 +倉 +個 +倌 +倍 +倏 +們 +倒 +倔 +倖 +倘 +候 +倚 +倜 +借 +倡 +値 +倦 +倩 +倪 +倫 +倬 +倭 +倶 +债 +值 +倾 +偃 +假 +偈 +偉 +偌 +偎 +偏 +偕 +做 +停 +健 +側 +偵 +偶 +偷 +偻 +偽 +偿 +傀 +傅 +傍 +傑 +傘 +備 +傚 +傢 +傣 +傥 +储 +傩 +催 +傭 +傲 +傳 +債 +傷 +傻 +傾 +僅 +働 +像 +僑 +僕 +僖 +僚 +僥 +僧 +僭 +僮 +僱 +僵 +價 +僻 +儀 +儂 +億 +儆 +儉 +儋 +儒 +儕 +儘 +償 +儡 +優 +儲 +儷 +儼 +儿 +兀 +允 +元 +兄 +充 +兆 +兇 +先 +光 +克 +兌 +免 +児 +兑 +兒 +兔 +兖 +党 +兜 +兢 +入 +內 +全 +兩 +八 +公 +六 +兮 +兰 +共 +兲 +关 +兴 +兵 +其 +具 +典 +兹 +养 +兼 +兽 +冀 +内 +円 +冇 +冈 +冉 +冊 +册 +再 +冏 +冒 +冕 +冗 +写 +军 +农 +冠 +冢 +冤 +冥 +冨 +冪 +冬 +冯 +冰 +冲 +决 +况 +冶 +冷 +冻 +冼 +冽 +冾 +净 +凄 +准 +凇 +凈 +凉 +凋 +凌 +凍 +减 +凑 +凛 +凜 +凝 +几 +凡 +凤 +処 +凪 +凭 +凯 +凰 +凱 +凳 +凶 +凸 +凹 +出 +击 +函 +凿 +刀 +刁 +刃 +分 +切 +刈 +刊 +刍 +刎 +刑 +划 +列 +刘 +则 +刚 +创 +初 +删 +判 +別 +刨 +利 +刪 +别 +刮 +到 +制 +刷 +券 +刹 +刺 +刻 +刽 +剁 +剂 +剃 +則 +剉 +削 +剋 +剌 +前 +剎 +剐 +剑 +剔 +剖 +剛 +剜 +剝 +剣 +剤 +剥 +剧 +剩 +剪 +副 +割 +創 +剷 +剽 +剿 +劃 +劇 +劈 +劉 +劊 +劍 +劏 +劑 +力 +劝 +办 +功 +加 +务 +劣 +动 +助 +努 +劫 +劭 +励 +劲 +劳 +労 +劵 +効 +劾 +势 +勁 +勃 +勇 +勉 +勋 +勐 +勒 +動 +勖 +勘 +務 +勛 +勝 +勞 +募 +勢 +勤 +勧 +勳 +勵 +勸 +勺 +勻 +勾 +勿 +匀 +包 +匆 +匈 +匍 +匐 +匕 +化 +北 +匙 +匝 +匠 +匡 +匣 +匪 +匮 +匯 +匱 +匹 +区 +医 +匾 +匿 +區 +十 +千 +卅 +升 +午 +卉 +半 +卍 +华 +协 +卑 +卒 +卓 +協 +单 +卖 +南 +単 +博 +卜 +卞 +卟 +占 +卡 +卢 +卤 +卦 +卧 +卫 +卮 +卯 +印 +危 +即 +却 +卵 +卷 +卸 +卻 +卿 +厂 +厄 +厅 +历 +厉 +压 +厌 +厕 +厘 +厚 +厝 +原 +厢 +厥 +厦 +厨 +厩 +厭 +厮 +厲 +厳 +去 +县 +叁 +参 +參 +又 +叉 +及 +友 +双 +反 +収 +发 +叔 +取 +受 +变 +叙 +叛 +叟 +叠 +叡 +叢 +口 +古 +句 +另 +叨 +叩 +只 +叫 +召 +叭 +叮 +可 +台 +叱 +史 +右 +叵 +叶 +号 +司 +叹 +叻 +叼 +叽 +吁 +吃 +各 +吆 +合 +吉 +吊 +吋 +同 +名 +后 +吏 +吐 +向 +吒 +吓 +吕 +吖 +吗 +君 +吝 +吞 +吟 +吠 +吡 +否 +吧 +吨 +吩 +含 +听 +吭 +吮 +启 +吱 +吳 +吴 +吵 +吶 +吸 +吹 +吻 +吼 +吽 +吾 +呀 +呂 +呃 +呆 +呈 +告 +呋 +呎 +呐 +呓 +呕 +呗 +员 +呛 +呜 +呢 +呤 +呦 +周 +呱 +呲 +味 +呵 +呷 +呸 +呻 +呼 +命 +咀 +咁 +咂 +咄 +咆 +咋 +和 +咎 +咏 +咐 +咒 +咔 +咕 +咖 +咗 +咘 +咙 +咚 +咛 +咣 +咤 +咦 +咧 +咨 +咩 +咪 +咫 +咬 +咭 +咯 +咱 +咲 +咳 +咸 +咻 +咽 +咿 +哀 +品 +哂 +哄 +哆 +哇 +哈 +哉 +哋 +哌 +响 +哎 +哏 +哐 +哑 +哒 +哔 +哗 +哟 +員 +哥 +哦 +哧 +哨 +哩 +哪 +哭 +哮 +哲 +哺 +哼 +哽 +唁 +唄 +唆 +唇 +唉 +唏 +唐 +唑 +唔 +唠 +唤 +唧 +唬 +售 +唯 +唰 +唱 +唳 +唷 +唸 +唾 +啃 +啄 +商 +啉 +啊 +問 +啓 +啕 +啖 +啜 +啞 +啟 +啡 +啤 +啥 +啦 +啧 +啪 +啫 +啬 +啮 +啰 +啱 +啲 +啵 +啶 +啷 +啸 +啻 +啼 +啾 +喀 +喂 +喃 +善 +喆 +喇 +喉 +喊 +喋 +喎 +喏 +喔 +喘 +喙 +喚 +喜 +喝 +喟 +喧 +喪 +喫 +喬 +單 +喰 +喱 +喲 +喳 +喵 +営 +喷 +喹 +喺 +喻 +喽 +嗅 +嗆 +嗇 +嗎 +嗑 +嗒 +嗓 +嗔 +嗖 +嗚 +嗜 +嗝 +嗟 +嗡 +嗣 +嗤 +嗦 +嗨 +嗪 +嗬 +嗯 +嗰 +嗲 +嗳 +嗶 +嗷 +嗽 +嘀 +嘅 +嘆 +嘈 +嘉 +嘌 +嘍 +嘎 +嘔 +嘖 +嘗 +嘘 +嘚 +嘛 +嘜 +嘞 +嘟 +嘢 +嘣 +嘤 +嘧 +嘩 +嘭 +嘮 +嘯 +嘰 +嘱 +嘲 +嘴 +嘶 +嘸 +嘹 +嘻 +嘿 +噁 +噌 +噎 +噓 +噔 +噗 +噙 +噜 +噠 +噢 +噤 +器 +噩 +噪 +噬 +噱 +噴 +噶 +噸 +噹 +噻 +噼 +嚀 +嚇 +嚎 +嚏 +嚐 +嚓 +嚕 +嚟 +嚣 +嚥 +嚨 +嚮 +嚴 +嚷 +嚼 +囂 +囉 +囊 +囍 +囑 +囔 +囗 +囚 +四 +囝 +回 +囟 +因 +囡 +团 +団 +囤 +囧 +囪 +囫 +园 +困 +囱 +囲 +図 +围 +囹 +固 +国 +图 +囿 +圃 +圄 +圆 +圈 +國 +圍 +圏 +園 +圓 +圖 +團 +圜 +土 +圣 +圧 +在 +圩 +圭 +地 +圳 +场 +圻 +圾 +址 +坂 +均 +坊 +坍 +坎 +坏 +坐 +坑 +块 +坚 +坛 +坝 +坞 +坟 +坠 +坡 +坤 +坦 +坨 +坪 +坯 +坳 +坵 +坷 +垂 +垃 +垄 +型 +垒 +垚 +垛 +垠 +垢 +垣 +垦 +垩 +垫 +垭 +垮 +垵 +埂 +埃 +埋 +城 +埔 +埕 +埗 +域 +埠 +埤 +埵 +執 +埸 +培 +基 +埼 +堀 +堂 +堃 +堅 +堆 +堇 +堑 +堕 +堙 +堡 +堤 +堪 +堯 +堰 +報 +場 +堵 +堺 +堿 +塊 +塌 +塑 +塔 +塗 +塘 +塚 +塞 +塢 +塩 +填 +塬 +塭 +塵 +塾 +墀 +境 +墅 +墉 +墊 +墒 +墓 +増 +墘 +墙 +墜 +增 +墟 +墨 +墩 +墮 +墳 +墻 +墾 +壁 +壅 +壆 +壇 +壊 +壑 +壓 +壕 +壘 +壞 +壟 +壢 +壤 +壩 +士 +壬 +壮 +壯 +声 +売 +壳 +壶 +壹 +壺 +壽 +处 +备 +変 +复 +夏 +夔 +夕 +外 +夙 +多 +夜 +够 +夠 +夢 +夥 +大 +天 +太 +夫 +夭 +央 +夯 +失 +头 +夷 +夸 +夹 +夺 +夾 +奂 +奄 +奇 +奈 +奉 +奋 +奎 +奏 +奐 +契 +奔 +奕 +奖 +套 +奘 +奚 +奠 +奢 +奥 +奧 +奪 +奬 +奮 +女 +奴 +奶 +奸 +她 +好 +如 +妃 +妄 +妆 +妇 +妈 +妊 +妍 +妒 +妓 +妖 +妘 +妙 +妝 +妞 +妣 +妤 +妥 +妨 +妩 +妪 +妮 +妲 +妳 +妹 +妻 +妾 +姆 +姉 +姊 +始 +姍 +姐 +姑 +姒 +姓 +委 +姗 +姚 +姜 +姝 +姣 +姥 +姦 +姨 +姪 +姫 +姬 +姹 +姻 +姿 +威 +娃 +娄 +娅 +娆 +娇 +娉 +娑 +娓 +娘 +娛 +娜 +娟 +娠 +娣 +娥 +娩 +娱 +娲 +娴 +娶 +娼 +婀 +婁 +婆 +婉 +婊 +婕 +婚 +婢 +婦 +婧 +婪 +婭 +婴 +婵 +婶 +婷 +婺 +婿 +媒 +媚 +媛 +媞 +媧 +媲 +媳 +媽 +媾 +嫁 +嫂 +嫉 +嫌 +嫑 +嫔 +嫖 +嫘 +嫚 +嫡 +嫣 +嫦 +嫩 +嫲 +嫵 +嫻 +嬅 +嬉 +嬌 +嬗 +嬛 +嬢 +嬤 +嬪 +嬰 +嬴 +嬷 +嬸 +嬿 +孀 +孃 +子 +孑 +孔 +孕 +孖 +字 +存 +孙 +孚 +孛 +孜 +孝 +孟 +孢 +季 +孤 +学 +孩 +孪 +孫 +孬 +孰 +孱 +孳 +孵 +學 +孺 +孽 +孿 +宁 +它 +宅 +宇 +守 +安 +宋 +完 +宏 +宓 +宕 +宗 +官 +宙 +定 +宛 +宜 +宝 +实 +実 +宠 +审 +客 +宣 +室 +宥 +宦 +宪 +宫 +宮 +宰 +害 +宴 +宵 +家 +宸 +容 +宽 +宾 +宿 +寂 +寄 +寅 +密 +寇 +富 +寐 +寒 +寓 +寛 +寝 +寞 +察 +寡 +寢 +寥 +實 +寧 +寨 +審 +寫 +寬 +寮 +寰 +寵 +寶 +寸 +对 +寺 +寻 +导 +対 +寿 +封 +専 +射 +将 +將 +專 +尉 +尊 +尋 +對 +導 +小 +少 +尔 +尕 +尖 +尘 +尚 +尝 +尤 +尧 +尬 +就 +尴 +尷 +尸 +尹 +尺 +尻 +尼 +尽 +尾 +尿 +局 +屁 +层 +屄 +居 +屆 +屈 +屉 +届 +屋 +屌 +屍 +屎 +屏 +屐 +屑 +展 +屜 +属 +屠 +屡 +屢 +層 +履 +屬 +屯 +山 +屹 +屿 +岀 +岁 +岂 +岌 +岐 +岑 +岔 +岖 +岗 +岘 +岙 +岚 +岛 +岡 +岩 +岫 +岬 +岭 +岱 +岳 +岷 +岸 +峇 +峋 +峒 +峙 +峡 +峤 +峥 +峦 +峨 +峪 +峭 +峯 +峰 +峴 +島 +峻 +峽 +崁 +崂 +崆 +崇 +崎 +崑 +崔 +崖 +崗 +崙 +崛 +崧 +崩 +崭 +崴 +崽 +嵇 +嵊 +嵋 +嵌 +嵐 +嵘 +嵩 +嵬 +嵯 +嶂 +嶄 +嶇 +嶋 +嶙 +嶺 +嶼 +嶽 +巅 +巍 +巒 +巔 +巖 +川 +州 +巡 +巢 +工 +左 +巧 +巨 +巩 +巫 +差 +己 +已 +巳 +巴 +巷 +巻 +巽 +巾 +巿 +币 +市 +布 +帅 +帆 +师 +希 +帐 +帑 +帕 +帖 +帘 +帚 +帛 +帜 +帝 +帥 +带 +帧 +師 +席 +帮 +帯 +帰 +帳 +帶 +帷 +常 +帼 +帽 +幀 +幂 +幄 +幅 +幌 +幔 +幕 +幟 +幡 +幢 +幣 +幫 +干 +平 +年 +并 +幸 +幹 +幺 +幻 +幼 +幽 +幾 +广 +庁 +広 +庄 +庆 +庇 +床 +序 +庐 +库 +应 +底 +庖 +店 +庙 +庚 +府 +庞 +废 +庠 +度 +座 +庫 +庭 +庵 +庶 +康 +庸 +庹 +庾 +廁 +廂 +廃 +廈 +廉 +廊 +廓 +廖 +廚 +廝 +廟 +廠 +廢 +廣 +廬 +廳 +延 +廷 +建 +廿 +开 +弁 +异 +弃 +弄 +弈 +弊 +弋 +式 +弑 +弒 +弓 +弔 +引 +弗 +弘 +弛 +弟 +张 +弥 +弦 +弧 +弩 +弭 +弯 +弱 +張 +強 +弹 +强 +弼 +弾 +彅 +彆 +彈 +彌 +彎 +归 +当 +录 +彗 +彙 +彝 +形 +彤 +彥 +彦 +彧 +彩 +彪 +彫 +彬 +彭 +彰 +影 +彷 +役 +彻 +彼 +彿 +往 +征 +径 +待 +徇 +很 +徉 +徊 +律 +後 +徐 +徑 +徒 +従 +徕 +得 +徘 +徙 +徜 +從 +徠 +御 +徨 +復 +循 +徬 +微 +徳 +徴 +徵 +德 +徹 +徼 +徽 +心 +必 +忆 +忌 +忍 +忏 +忐 +忑 +忒 +忖 +志 +忘 +忙 +応 +忠 +忡 +忤 +忧 +忪 +快 +忱 +念 +忻 +忽 +忿 +怀 +态 +怂 +怅 +怆 +怎 +怏 +怒 +怔 +怕 +怖 +怙 +怜 +思 +怠 +怡 +急 +怦 +性 +怨 +怪 +怯 +怵 +总 +怼 +恁 +恃 +恆 +恋 +恍 +恐 +恒 +恕 +恙 +恚 +恢 +恣 +恤 +恥 +恨 +恩 +恪 +恫 +恬 +恭 +息 +恰 +恳 +恵 +恶 +恸 +恺 +恻 +恼 +恿 +悄 +悅 +悉 +悌 +悍 +悔 +悖 +悚 +悟 +悠 +患 +悦 +您 +悩 +悪 +悬 +悯 +悱 +悲 +悴 +悵 +悶 +悸 +悻 +悼 +悽 +情 +惆 +惇 +惊 +惋 +惑 +惕 +惘 +惚 +惜 +惟 +惠 +惡 +惦 +惧 +惨 +惩 +惫 +惬 +惭 +惮 +惯 +惰 +惱 +想 +惴 +惶 +惹 +惺 +愁 +愆 +愈 +愉 +愍 +意 +愕 +愚 +愛 +愜 +感 +愣 +愤 +愧 +愫 +愷 +愿 +慄 +慈 +態 +慌 +慎 +慑 +慕 +慘 +慚 +慟 +慢 +慣 +慧 +慨 +慫 +慮 +慰 +慳 +慵 +慶 +慷 +慾 +憂 +憊 +憋 +憎 +憐 +憑 +憔 +憚 +憤 +憧 +憨 +憩 +憫 +憬 +憲 +憶 +憾 +懂 +懇 +懈 +應 +懊 +懋 +懑 +懒 +懦 +懲 +懵 +懶 +懷 +懸 +懺 +懼 +懾 +懿 +戀 +戈 +戊 +戌 +戍 +戎 +戏 +成 +我 +戒 +戕 +或 +战 +戚 +戛 +戟 +戡 +戦 +截 +戬 +戮 +戰 +戲 +戳 +戴 +戶 +户 +戸 +戻 +戾 +房 +所 +扁 +扇 +扈 +扉 +手 +才 +扎 +扑 +扒 +打 +扔 +払 +托 +扛 +扣 +扦 +执 +扩 +扪 +扫 +扬 +扭 +扮 +扯 +扰 +扱 +扳 +扶 +批 +扼 +找 +承 +技 +抄 +抉 +把 +抑 +抒 +抓 +投 +抖 +抗 +折 +抚 +抛 +抜 +択 +抟 +抠 +抡 +抢 +护 +报 +抨 +披 +抬 +抱 +抵 +抹 +押 +抽 +抿 +拂 +拄 +担 +拆 +拇 +拈 +拉 +拋 +拌 +拍 +拎 +拐 +拒 +拓 +拔 +拖 +拗 +拘 +拙 +拚 +招 +拜 +拟 +拡 +拢 +拣 +拥 +拦 +拧 +拨 +择 +括 +拭 +拮 +拯 +拱 +拳 +拴 +拷 +拼 +拽 +拾 +拿 +持 +挂 +指 +挈 +按 +挎 +挑 +挖 +挙 +挚 +挛 +挝 +挞 +挟 +挠 +挡 +挣 +挤 +挥 +挨 +挪 +挫 +振 +挲 +挹 +挺 +挽 +挾 +捂 +捅 +捆 +捉 +捋 +捌 +捍 +捎 +捏 +捐 +捕 +捞 +损 +捡 +换 +捣 +捧 +捨 +捩 +据 +捱 +捲 +捶 +捷 +捺 +捻 +掀 +掂 +掃 +掇 +授 +掉 +掌 +掏 +掐 +排 +掖 +掘 +掙 +掛 +掠 +採 +探 +掣 +接 +控 +推 +掩 +措 +掬 +掰 +掲 +掳 +掴 +掷 +掸 +掺 +揀 +揃 +揄 +揆 +揉 +揍 +描 +提 +插 +揖 +揚 +換 +握 +揣 +揩 +揪 +揭 +揮 +援 +揶 +揸 +揹 +揽 +搀 +搁 +搂 +搅 +損 +搏 +搐 +搓 +搔 +搖 +搗 +搜 +搞 +搡 +搪 +搬 +搭 +搵 +搶 +携 +搽 +摀 +摁 +摄 +摆 +摇 +摈 +摊 +摒 +摔 +摘 +摞 +摟 +摧 +摩 +摯 +摳 +摸 +摹 +摺 +摻 +撂 +撃 +撅 +撇 +撈 +撐 +撑 +撒 +撓 +撕 +撚 +撞 +撤 +撥 +撩 +撫 +撬 +播 +撮 +撰 +撲 +撵 +撷 +撸 +撻 +撼 +撿 +擀 +擁 +擂 +擄 +擅 +擇 +擊 +擋 +操 +擎 +擒 +擔 +擘 +據 +擞 +擠 +擡 +擢 +擦 +擬 +擰 +擱 +擲 +擴 +擷 +擺 +擼 +擾 +攀 +攏 +攒 +攔 +攘 +攙 +攜 +攝 +攞 +攢 +攣 +攤 +攥 +攪 +攫 +攬 +支 +收 +攸 +改 +攻 +放 +政 +故 +效 +敌 +敍 +敎 +敏 +救 +敕 +敖 +敗 +敘 +教 +敛 +敝 +敞 +敢 +散 +敦 +敬 +数 +敲 +整 +敵 +敷 +數 +斂 +斃 +文 +斋 +斌 +斎 +斐 +斑 +斓 +斗 +料 +斛 +斜 +斟 +斡 +斤 +斥 +斧 +斩 +斫 +斬 +断 +斯 +新 +斷 +方 +於 +施 +旁 +旃 +旅 +旋 +旌 +旎 +族 +旖 +旗 +无 +既 +日 +旦 +旧 +旨 +早 +旬 +旭 +旮 +旱 +时 +旷 +旺 +旻 +昀 +昂 +昆 +昇 +昉 +昊 +昌 +明 +昏 +易 +昔 +昕 +昙 +星 +映 +春 +昧 +昨 +昭 +是 +昱 +昴 +昵 +昶 +昼 +显 +晁 +時 +晃 +晉 +晋 +晌 +晏 +晒 +晓 +晔 +晕 +晖 +晗 +晚 +晝 +晞 +晟 +晤 +晦 +晨 +晩 +普 +景 +晰 +晴 +晶 +晷 +智 +晾 +暂 +暄 +暇 +暈 +暉 +暌 +暐 +暑 +暖 +暗 +暝 +暢 +暧 +暨 +暫 +暮 +暱 +暴 +暸 +暹 +曄 +曆 +曇 +曉 +曖 +曙 +曜 +曝 +曠 +曦 +曬 +曰 +曲 +曳 +更 +書 +曹 +曼 +曾 +替 +最 +會 +月 +有 +朋 +服 +朐 +朔 +朕 +朗 +望 +朝 +期 +朦 +朧 +木 +未 +末 +本 +札 +朮 +术 +朱 +朴 +朵 +机 +朽 +杀 +杂 +权 +杆 +杈 +杉 +李 +杏 +材 +村 +杓 +杖 +杜 +杞 +束 +杠 +条 +来 +杨 +杭 +杯 +杰 +東 +杳 +杵 +杷 +杼 +松 +板 +极 +构 +枇 +枉 +枋 +析 +枕 +林 +枚 +果 +枝 +枢 +枣 +枪 +枫 +枭 +枯 +枰 +枱 +枳 +架 +枷 +枸 +柄 +柏 +某 +柑 +柒 +染 +柔 +柘 +柚 +柜 +柞 +柠 +柢 +查 +柩 +柬 +柯 +柱 +柳 +柴 +柵 +査 +柿 +栀 +栃 +栄 +栅 +标 +栈 +栉 +栋 +栎 +栏 +树 +栓 +栖 +栗 +校 +栩 +株 +样 +核 +根 +格 +栽 +栾 +桀 +桁 +桂 +桃 +桅 +框 +案 +桉 +桌 +桎 +桐 +桑 +桓 +桔 +桜 +桠 +桡 +桢 +档 +桥 +桦 +桧 +桨 +桩 +桶 +桿 +梁 +梅 +梆 +梏 +梓 +梗 +條 +梟 +梢 +梦 +梧 +梨 +梭 +梯 +械 +梳 +梵 +梶 +检 +棂 +棄 +棉 +棋 +棍 +棒 +棕 +棗 +棘 +棚 +棟 +棠 +棣 +棧 +森 +棱 +棲 +棵 +棹 +棺 +椁 +椅 +椋 +植 +椎 +椒 +検 +椪 +椭 +椰 +椹 +椽 +椿 +楂 +楊 +楓 +楔 +楚 +楝 +楞 +楠 +楣 +楨 +楫 +業 +楮 +極 +楷 +楸 +楹 +楼 +楽 +概 +榄 +榆 +榈 +榉 +榔 +榕 +榖 +榛 +榜 +榨 +榫 +榭 +榮 +榱 +榴 +榷 +榻 +槁 +槃 +構 +槌 +槍 +槎 +槐 +槓 +様 +槛 +槟 +槤 +槭 +槲 +槳 +槻 +槽 +槿 +樁 +樂 +樊 +樑 +樓 +標 +樞 +樟 +模 +樣 +権 +横 +樫 +樯 +樱 +樵 +樸 +樹 +樺 +樽 +樾 +橄 +橇 +橋 +橐 +橘 +橙 +機 +橡 +橢 +橫 +橱 +橹 +橼 +檀 +檄 +檎 +檐 +檔 +檗 +檜 +檢 +檬 +檯 +檳 +檸 +檻 +櫃 +櫚 +櫛 +櫥 +櫸 +櫻 +欄 +權 +欒 +欖 +欠 +次 +欢 +欣 +欧 +欲 +欸 +欺 +欽 +款 +歆 +歇 +歉 +歌 +歎 +歐 +歓 +歙 +歛 +歡 +止 +正 +此 +步 +武 +歧 +歩 +歪 +歯 +歲 +歳 +歴 +歷 +歸 +歹 +死 +歼 +殁 +殃 +殆 +殇 +殉 +殊 +残 +殒 +殓 +殖 +殘 +殞 +殡 +殤 +殭 +殯 +殲 +殴 +段 +殷 +殺 +殼 +殿 +毀 +毁 +毂 +毅 +毆 +毋 +母 +毎 +每 +毒 +毓 +比 +毕 +毗 +毘 +毙 +毛 +毡 +毫 +毯 +毽 +氈 +氏 +氐 +民 +氓 +气 +氖 +気 +氙 +氛 +氟 +氡 +氢 +氣 +氤 +氦 +氧 +氨 +氪 +氫 +氮 +氯 +氰 +氲 +水 +氷 +永 +氹 +氾 +汀 +汁 +求 +汆 +汇 +汉 +汎 +汐 +汕 +汗 +汙 +汛 +汝 +汞 +江 +池 +污 +汤 +汨 +汩 +汪 +汰 +汲 +汴 +汶 +汹 +決 +汽 +汾 +沁 +沂 +沃 +沅 +沈 +沉 +沌 +沏 +沐 +沒 +沓 +沖 +沙 +沛 +沟 +没 +沢 +沣 +沥 +沦 +沧 +沪 +沫 +沭 +沮 +沱 +河 +沸 +油 +治 +沼 +沽 +沾 +沿 +況 +泄 +泉 +泊 +泌 +泓 +法 +泗 +泛 +泞 +泠 +泡 +波 +泣 +泥 +注 +泪 +泫 +泮 +泯 +泰 +泱 +泳 +泵 +泷 +泸 +泻 +泼 +泽 +泾 +洁 +洄 +洋 +洒 +洗 +洙 +洛 +洞 +津 +洩 +洪 +洮 +洱 +洲 +洵 +洶 +洸 +洹 +活 +洼 +洽 +派 +流 +浃 +浄 +浅 +浆 +浇 +浊 +测 +济 +浏 +浑 +浒 +浓 +浔 +浙 +浚 +浜 +浣 +浦 +浩 +浪 +浬 +浮 +浯 +浴 +海 +浸 +涂 +涅 +涇 +消 +涉 +涌 +涎 +涓 +涔 +涕 +涙 +涛 +涝 +涞 +涟 +涠 +涡 +涣 +涤 +润 +涧 +涨 +涩 +涪 +涮 +涯 +液 +涵 +涸 +涼 +涿 +淀 +淄 +淅 +淆 +淇 +淋 +淌 +淑 +淒 +淖 +淘 +淙 +淚 +淞 +淡 +淤 +淦 +淨 +淩 +淪 +淫 +淬 +淮 +深 +淳 +淵 +混 +淹 +淺 +添 +淼 +清 +済 +渉 +渊 +渋 +渍 +渎 +渐 +渔 +渗 +渙 +渚 +減 +渝 +渠 +渡 +渣 +渤 +渥 +渦 +温 +測 +渭 +港 +渲 +渴 +游 +渺 +渾 +湃 +湄 +湊 +湍 +湖 +湘 +湛 +湟 +湧 +湫 +湮 +湯 +湳 +湾 +湿 +満 +溃 +溅 +溉 +溏 +源 +準 +溜 +溝 +溟 +溢 +溥 +溧 +溪 +溫 +溯 +溱 +溴 +溶 +溺 +溼 +滁 +滂 +滄 +滅 +滇 +滋 +滌 +滑 +滓 +滔 +滕 +滙 +滚 +滝 +滞 +滟 +满 +滢 +滤 +滥 +滦 +滨 +滩 +滬 +滯 +滲 +滴 +滷 +滸 +滾 +滿 +漁 +漂 +漆 +漉 +漏 +漓 +演 +漕 +漠 +漢 +漣 +漩 +漪 +漫 +漬 +漯 +漱 +漲 +漳 +漸 +漾 +漿 +潆 +潇 +潋 +潍 +潑 +潔 +潘 +潛 +潜 +潞 +潟 +潢 +潤 +潦 +潧 +潭 +潮 +潰 +潴 +潸 +潺 +潼 +澀 +澄 +澆 +澈 +澍 +澎 +澗 +澜 +澡 +澤 +澧 +澱 +澳 +澹 +激 +濁 +濂 +濃 +濑 +濒 +濕 +濘 +濛 +濟 +濠 +濡 +濤 +濫 +濬 +濮 +濯 +濱 +濺 +濾 +瀅 +瀆 +瀉 +瀋 +瀏 +瀑 +瀕 +瀘 +瀚 +瀛 +瀝 +瀞 +瀟 +瀧 +瀨 +瀬 +瀰 +瀾 +灌 +灏 +灑 +灘 +灝 +灞 +灣 +火 +灬 +灭 +灯 +灰 +灵 +灶 +灸 +灼 +災 +灾 +灿 +炀 +炁 +炅 +炉 +炊 +炎 +炒 +炔 +炕 +炖 +炙 +炜 +炫 +炬 +炭 +炮 +炯 +炳 +炷 +炸 +点 +為 +炼 +炽 +烁 +烂 +烃 +烈 +烊 +烏 +烘 +烙 +烛 +烟 +烤 +烦 +烧 +烨 +烩 +烫 +烬 +热 +烯 +烷 +烹 +烽 +焉 +焊 +焕 +焖 +焗 +焘 +焙 +焚 +焜 +無 +焦 +焯 +焰 +焱 +然 +焼 +煅 +煉 +煊 +煌 +煎 +煒 +煖 +煙 +煜 +煞 +煤 +煥 +煦 +照 +煨 +煩 +煮 +煲 +煸 +煽 +熄 +熊 +熏 +熒 +熔 +熙 +熟 +熠 +熨 +熬 +熱 +熵 +熹 +熾 +燁 +燃 +燄 +燈 +燉 +燊 +燎 +燒 +燔 +燕 +燙 +燜 +營 +燥 +燦 +燧 +燭 +燮 +燴 +燻 +燼 +燿 +爆 +爍 +爐 +爛 +爪 +爬 +爭 +爰 +爱 +爲 +爵 +父 +爷 +爸 +爹 +爺 +爻 +爽 +爾 +牆 +片 +版 +牌 +牍 +牒 +牙 +牛 +牝 +牟 +牠 +牡 +牢 +牦 +牧 +物 +牯 +牲 +牴 +牵 +特 +牺 +牽 +犀 +犁 +犄 +犊 +犍 +犒 +犢 +犧 +犬 +犯 +状 +犷 +犸 +犹 +狀 +狂 +狄 +狈 +狎 +狐 +狒 +狗 +狙 +狞 +狠 +狡 +狩 +独 +狭 +狮 +狰 +狱 +狸 +狹 +狼 +狽 +猎 +猕 +猖 +猗 +猙 +猛 +猜 +猝 +猥 +猩 +猪 +猫 +猬 +献 +猴 +猶 +猷 +猾 +猿 +獄 +獅 +獎 +獐 +獒 +獗 +獠 +獣 +獨 +獭 +獰 +獲 +獵 +獷 +獸 +獺 +獻 +獼 +獾 +玄 +率 +玉 +王 +玑 +玖 +玛 +玟 +玠 +玥 +玩 +玫 +玮 +环 +现 +玲 +玳 +玷 +玺 +玻 +珀 +珂 +珅 +珈 +珉 +珊 +珍 +珏 +珐 +珑 +珙 +珞 +珠 +珣 +珥 +珩 +珪 +班 +珮 +珲 +珺 +現 +球 +琅 +理 +琇 +琉 +琊 +琍 +琏 +琐 +琛 +琢 +琥 +琦 +琨 +琪 +琬 +琮 +琰 +琲 +琳 +琴 +琵 +琶 +琺 +琼 +瑀 +瑁 +瑄 +瑋 +瑕 +瑗 +瑙 +瑚 +瑛 +瑜 +瑞 +瑟 +瑠 +瑣 +瑤 +瑩 +瑪 +瑯 +瑰 +瑶 +瑾 +璀 +璁 +璃 +璇 +璉 +璋 +璎 +璐 +璜 +璞 +璟 +璧 +璨 +環 +璽 +璿 +瓊 +瓏 +瓒 +瓜 +瓢 +瓣 +瓤 +瓦 +瓮 +瓯 +瓴 +瓶 +瓷 +甄 +甌 +甕 +甘 +甙 +甚 +甜 +生 +產 +産 +甥 +甦 +用 +甩 +甫 +甬 +甭 +甯 +田 +由 +甲 +申 +电 +男 +甸 +町 +画 +甾 +畀 +畅 +界 +畏 +畑 +畔 +留 +畜 +畝 +畢 +略 +畦 +番 +畫 +異 +畲 +畳 +畴 +當 +畸 +畹 +畿 +疆 +疇 +疊 +疏 +疑 +疔 +疖 +疗 +疙 +疚 +疝 +疟 +疡 +疣 +疤 +疥 +疫 +疮 +疯 +疱 +疲 +疳 +疵 +疸 +疹 +疼 +疽 +疾 +痂 +病 +症 +痈 +痉 +痊 +痍 +痒 +痔 +痕 +痘 +痙 +痛 +痞 +痠 +痢 +痣 +痤 +痧 +痨 +痪 +痫 +痰 +痱 +痴 +痹 +痺 +痼 +痿 +瘀 +瘁 +瘋 +瘍 +瘓 +瘘 +瘙 +瘟 +瘠 +瘡 +瘢 +瘤 +瘦 +瘧 +瘩 +瘪 +瘫 +瘴 +瘸 +瘾 +療 +癇 +癌 +癒 +癖 +癜 +癞 +癡 +癢 +癣 +癥 +癫 +癬 +癮 +癱 +癲 +癸 +発 +登 +發 +白 +百 +皂 +的 +皆 +皇 +皈 +皋 +皎 +皑 +皓 +皖 +皙 +皚 +皮 +皰 +皱 +皴 +皺 +皿 +盂 +盃 +盅 +盆 +盈 +益 +盎 +盏 +盐 +监 +盒 +盔 +盖 +盗 +盘 +盛 +盜 +盞 +盟 +盡 +監 +盤 +盥 +盧 +盪 +目 +盯 +盱 +盲 +直 +相 +盹 +盼 +盾 +省 +眈 +眉 +看 +県 +眙 +眞 +真 +眠 +眦 +眨 +眩 +眯 +眶 +眷 +眸 +眺 +眼 +眾 +着 +睁 +睇 +睏 +睐 +睑 +睛 +睜 +睞 +睡 +睢 +督 +睥 +睦 +睨 +睪 +睫 +睬 +睹 +睽 +睾 +睿 +瞄 +瞅 +瞇 +瞋 +瞌 +瞎 +瞑 +瞒 +瞓 +瞞 +瞟 +瞠 +瞥 +瞧 +瞩 +瞪 +瞬 +瞭 +瞰 +瞳 +瞻 +瞼 +瞿 +矇 +矍 +矗 +矚 +矛 +矜 +矢 +矣 +知 +矩 +矫 +短 +矮 +矯 +石 +矶 +矽 +矾 +矿 +码 +砂 +砌 +砍 +砒 +研 +砖 +砗 +砚 +砝 +砣 +砥 +砧 +砭 +砰 +砲 +破 +砷 +砸 +砺 +砼 +砾 +础 +硅 +硐 +硒 +硕 +硝 +硫 +硬 +确 +硯 +硼 +碁 +碇 +碉 +碌 +碍 +碎 +碑 +碓 +碗 +碘 +碚 +碛 +碟 +碣 +碧 +碩 +碰 +碱 +碳 +碴 +確 +碼 +碾 +磁 +磅 +磊 +磋 +磐 +磕 +磚 +磡 +磨 +磬 +磯 +磲 +磷 +磺 +礁 +礎 +礙 +礡 +礦 +礪 +礫 +礴 +示 +礼 +社 +祀 +祁 +祂 +祇 +祈 +祉 +祎 +祐 +祕 +祖 +祗 +祚 +祛 +祜 +祝 +神 +祟 +祠 +祢 +祥 +票 +祭 +祯 +祷 +祸 +祺 +祿 +禀 +禁 +禄 +禅 +禍 +禎 +福 +禛 +禦 +禧 +禪 +禮 +禱 +禹 +禺 +离 +禽 +禾 +禿 +秀 +私 +秃 +秆 +秉 +秋 +种 +科 +秒 +秘 +租 +秣 +秤 +秦 +秧 +秩 +秭 +积 +称 +秸 +移 +秽 +稀 +稅 +程 +稍 +税 +稔 +稗 +稚 +稜 +稞 +稟 +稠 +稣 +種 +稱 +稲 +稳 +稷 +稹 +稻 +稼 +稽 +稿 +穀 +穂 +穆 +穌 +積 +穎 +穗 +穢 +穩 +穫 +穴 +究 +穷 +穹 +空 +穿 +突 +窃 +窄 +窈 +窍 +窑 +窒 +窓 +窕 +窖 +窗 +窘 +窜 +窝 +窟 +窠 +窥 +窦 +窨 +窩 +窪 +窮 +窯 +窺 +窿 +竄 +竅 +竇 +竊 +立 +竖 +站 +竜 +竞 +竟 +章 +竣 +童 +竭 +端 +競 +竹 +竺 +竽 +竿 +笃 +笆 +笈 +笋 +笏 +笑 +笔 +笙 +笛 +笞 +笠 +符 +笨 +第 +笹 +笺 +笼 +筆 +等 +筊 +筋 +筍 +筏 +筐 +筑 +筒 +答 +策 +筛 +筝 +筠 +筱 +筲 +筵 +筷 +筹 +签 +简 +箇 +箋 +箍 +箏 +箐 +箔 +箕 +算 +箝 +管 +箩 +箫 +箭 +箱 +箴 +箸 +節 +篁 +範 +篆 +篇 +築 +篑 +篓 +篙 +篝 +篠 +篡 +篤 +篩 +篪 +篮 +篱 +篷 +簇 +簌 +簍 +簡 +簦 +簧 +簪 +簫 +簷 +簸 +簽 +簾 +簿 +籁 +籃 +籌 +籍 +籐 +籟 +籠 +籤 +籬 +籮 +籲 +米 +类 +籼 +籽 +粄 +粉 +粑 +粒 +粕 +粗 +粘 +粟 +粤 +粥 +粧 +粪 +粮 +粱 +粲 +粳 +粵 +粹 +粼 +粽 +精 +粿 +糅 +糊 +糍 +糕 +糖 +糗 +糙 +糜 +糞 +糟 +糠 +糧 +糬 +糯 +糰 +糸 +系 +糾 +紀 +紂 +約 +紅 +紉 +紊 +紋 +納 +紐 +紓 +純 +紗 +紘 +紙 +級 +紛 +紜 +素 +紡 +索 +紧 +紫 +紮 +累 +細 +紳 +紹 +紺 +終 +絃 +組 +絆 +経 +結 +絕 +絞 +絡 +絢 +給 +絨 +絮 +統 +絲 +絳 +絵 +絶 +絹 +綁 +綏 +綑 +經 +継 +続 +綜 +綠 +綢 +綦 +綫 +綬 +維 +綱 +網 +綴 +綵 +綸 +綺 +綻 +綽 +綾 +綿 +緊 +緋 +総 +緑 +緒 +緘 +線 +緝 +緞 +締 +緣 +編 +緩 +緬 +緯 +練 +緹 +緻 +縁 +縄 +縈 +縛 +縝 +縣 +縫 +縮 +縱 +縴 +縷 +總 +績 +繁 +繃 +繆 +繇 +繋 +織 +繕 +繚 +繞 +繡 +繩 +繪 +繫 +繭 +繳 +繹 +繼 +繽 +纂 +續 +纍 +纏 +纓 +纔 +纖 +纜 +纠 +红 +纣 +纤 +约 +级 +纨 +纪 +纫 +纬 +纭 +纯 +纰 +纱 +纲 +纳 +纵 +纶 +纷 +纸 +纹 +纺 +纽 +纾 +线 +绀 +练 +组 +绅 +细 +织 +终 +绊 +绍 +绎 +经 +绑 +绒 +结 +绔 +绕 +绘 +给 +绚 +绛 +络 +绝 +绞 +统 +绡 +绢 +绣 +绥 +绦 +继 +绩 +绪 +绫 +续 +绮 +绯 +绰 +绳 +维 +绵 +绶 +绷 +绸 +绻 +综 +绽 +绾 +绿 +缀 +缄 +缅 +缆 +缇 +缈 +缉 +缎 +缓 +缔 +缕 +编 +缘 +缙 +缚 +缜 +缝 +缠 +缢 +缤 +缥 +缨 +缩 +缪 +缭 +缮 +缰 +缱 +缴 +缸 +缺 +缽 +罂 +罄 +罌 +罐 +网 +罔 +罕 +罗 +罚 +罡 +罢 +罩 +罪 +置 +罰 +署 +罵 +罷 +罹 +羁 +羅 +羈 +羊 +羌 +美 +羔 +羚 +羞 +羟 +羡 +羣 +群 +羥 +羧 +羨 +義 +羯 +羲 +羸 +羹 +羽 +羿 +翁 +翅 +翊 +翌 +翎 +習 +翔 +翘 +翟 +翠 +翡 +翦 +翩 +翰 +翱 +翳 +翹 +翻 +翼 +耀 +老 +考 +耄 +者 +耆 +耋 +而 +耍 +耐 +耒 +耕 +耗 +耘 +耙 +耦 +耨 +耳 +耶 +耷 +耸 +耻 +耽 +耿 +聂 +聆 +聊 +聋 +职 +聒 +联 +聖 +聘 +聚 +聞 +聪 +聯 +聰 +聲 +聳 +聴 +聶 +職 +聽 +聾 +聿 +肃 +肄 +肅 +肆 +肇 +肉 +肋 +肌 +肏 +肓 +肖 +肘 +肚 +肛 +肝 +肠 +股 +肢 +肤 +肥 +肩 +肪 +肮 +肯 +肱 +育 +肴 +肺 +肽 +肾 +肿 +胀 +胁 +胃 +胄 +胆 +背 +胍 +胎 +胖 +胚 +胛 +胜 +胝 +胞 +胡 +胤 +胥 +胧 +胫 +胭 +胯 +胰 +胱 +胳 +胴 +胶 +胸 +胺 +能 +脂 +脅 +脆 +脇 +脈 +脉 +脊 +脍 +脏 +脐 +脑 +脓 +脖 +脘 +脚 +脛 +脣 +脩 +脫 +脯 +脱 +脲 +脳 +脸 +脹 +脾 +腆 +腈 +腊 +腋 +腌 +腎 +腐 +腑 +腓 +腔 +腕 +腥 +腦 +腩 +腫 +腭 +腮 +腰 +腱 +腳 +腴 +腸 +腹 +腺 +腻 +腼 +腾 +腿 +膀 +膈 +膊 +膏 +膑 +膘 +膚 +膛 +膜 +膝 +膠 +膦 +膨 +膩 +膳 +膺 +膻 +膽 +膾 +膿 +臀 +臂 +臃 +臆 +臉 +臊 +臍 +臓 +臘 +臟 +臣 +臥 +臧 +臨 +自 +臬 +臭 +至 +致 +臺 +臻 +臼 +臾 +舀 +舂 +舅 +舆 +與 +興 +舉 +舊 +舌 +舍 +舎 +舐 +舒 +舔 +舖 +舗 +舛 +舜 +舞 +舟 +航 +舫 +般 +舰 +舱 +舵 +舶 +舷 +舸 +船 +舺 +舾 +艇 +艋 +艘 +艙 +艦 +艮 +良 +艰 +艱 +色 +艳 +艷 +艹 +艺 +艾 +节 +芃 +芈 +芊 +芋 +芍 +芎 +芒 +芙 +芜 +芝 +芡 +芥 +芦 +芩 +芪 +芫 +芬 +芭 +芮 +芯 +花 +芳 +芷 +芸 +芹 +芻 +芽 +芾 +苁 +苄 +苇 +苋 +苍 +苏 +苑 +苒 +苓 +苔 +苕 +苗 +苛 +苜 +苞 +苟 +苡 +苣 +若 +苦 +苫 +苯 +英 +苷 +苹 +苻 +茁 +茂 +范 +茄 +茅 +茉 +茎 +茏 +茗 +茜 +茧 +茨 +茫 +茬 +茭 +茯 +茱 +茲 +茴 +茵 +茶 +茸 +茹 +茼 +荀 +荃 +荆 +草 +荊 +荏 +荐 +荒 +荔 +荖 +荘 +荚 +荞 +荟 +荠 +荡 +荣 +荤 +荥 +荧 +荨 +荪 +荫 +药 +荳 +荷 +荸 +荻 +荼 +荽 +莅 +莆 +莉 +莊 +莎 +莒 +莓 +莖 +莘 +莞 +莠 +莢 +莧 +莪 +莫 +莱 +莲 +莴 +获 +莹 +莺 +莽 +莿 +菀 +菁 +菅 +菇 +菈 +菊 +菌 +菏 +菓 +菖 +菘 +菜 +菟 +菠 +菡 +菩 +華 +菱 +菲 +菸 +菽 +萁 +萃 +萄 +萊 +萋 +萌 +萍 +萎 +萘 +萝 +萤 +营 +萦 +萧 +萨 +萩 +萬 +萱 +萵 +萸 +萼 +落 +葆 +葉 +著 +葚 +葛 +葡 +董 +葦 +葩 +葫 +葬 +葭 +葯 +葱 +葳 +葵 +葷 +葺 +蒂 +蒋 +蒐 +蒔 +蒙 +蒜 +蒞 +蒟 +蒡 +蒨 +蒲 +蒸 +蒹 +蒻 +蒼 +蒿 +蓁 +蓄 +蓆 +蓉 +蓋 +蓑 +蓓 +蓖 +蓝 +蓟 +蓦 +蓬 +蓮 +蓼 +蓿 +蔑 +蔓 +蔔 +蔗 +蔘 +蔚 +蔡 +蔣 +蔥 +蔫 +蔬 +蔭 +蔵 +蔷 +蔺 +蔻 +蔼 +蔽 +蕁 +蕃 +蕈 +蕉 +蕊 +蕎 +蕙 +蕤 +蕨 +蕩 +蕪 +蕭 +蕲 +蕴 +蕻 +蕾 +薄 +薅 +薇 +薈 +薊 +薏 +薑 +薔 +薙 +薛 +薦 +薨 +薩 +薪 +薬 +薯 +薰 +薹 +藉 +藍 +藏 +藐 +藓 +藕 +藜 +藝 +藤 +藥 +藩 +藹 +藻 +藿 +蘆 +蘇 +蘊 +蘋 +蘑 +蘚 +蘭 +蘸 +蘼 +蘿 +虎 +虏 +虐 +虑 +虔 +處 +虚 +虛 +虜 +虞 +號 +虢 +虧 +虫 +虬 +虱 +虹 +虻 +虽 +虾 +蚀 +蚁 +蚂 +蚊 +蚌 +蚓 +蚕 +蚜 +蚝 +蚣 +蚤 +蚩 +蚪 +蚯 +蚱 +蚵 +蛀 +蛆 +蛇 +蛊 +蛋 +蛎 +蛐 +蛔 +蛙 +蛛 +蛟 +蛤 +蛭 +蛮 +蛰 +蛳 +蛹 +蛻 +蛾 +蜀 +蜂 +蜃 +蜆 +蜇 +蜈 +蜊 +蜍 +蜒 +蜓 +蜕 +蜗 +蜘 +蜚 +蜜 +蜡 +蜢 +蜥 +蜱 +蜴 +蜷 +蜻 +蜿 +蝇 +蝈 +蝉 +蝌 +蝎 +蝕 +蝗 +蝙 +蝟 +蝠 +蝦 +蝨 +蝴 +蝶 +蝸 +蝼 +螂 +螃 +融 +螞 +螢 +螨 +螯 +螳 +螺 +蟀 +蟄 +蟆 +蟋 +蟎 +蟑 +蟒 +蟠 +蟬 +蟲 +蟹 +蟻 +蟾 +蠅 +蠍 +蠔 +蠕 +蠛 +蠟 +蠡 +蠢 +蠣 +蠱 +蠶 +蠹 +蠻 +血 +衄 +衅 +衆 +行 +衍 +術 +衔 +街 +衙 +衛 +衝 +衞 +衡 +衢 +衣 +补 +表 +衩 +衫 +衬 +衮 +衰 +衲 +衷 +衹 +衾 +衿 +袁 +袂 +袄 +袅 +袈 +袋 +袍 +袒 +袖 +袜 +袞 +袤 +袪 +被 +袭 +袱 +裁 +裂 +装 +裆 +裊 +裏 +裔 +裕 +裘 +裙 +補 +裝 +裟 +裡 +裤 +裨 +裱 +裳 +裴 +裸 +裹 +製 +裾 +褂 +複 +褐 +褒 +褓 +褔 +褚 +褥 +褪 +褫 +褲 +褶 +褻 +襁 +襄 +襟 +襠 +襪 +襬 +襯 +襲 +西 +要 +覃 +覆 +覇 +見 +規 +覓 +視 +覚 +覦 +覧 +親 +覬 +観 +覷 +覺 +覽 +觀 +见 +观 +规 +觅 +视 +览 +觉 +觊 +觎 +觐 +觑 +角 +觞 +解 +觥 +触 +觸 +言 +訂 +計 +訊 +討 +訓 +訕 +訖 +託 +記 +訛 +訝 +訟 +訣 +訥 +訪 +設 +許 +訳 +訴 +訶 +診 +註 +証 +詆 +詐 +詔 +評 +詛 +詞 +詠 +詡 +詢 +詣 +試 +詩 +詫 +詬 +詭 +詮 +詰 +話 +該 +詳 +詹 +詼 +誅 +誇 +誉 +誌 +認 +誓 +誕 +誘 +語 +誠 +誡 +誣 +誤 +誥 +誦 +誨 +說 +説 +読 +誰 +課 +誹 +誼 +調 +諄 +談 +請 +諏 +諒 +論 +諗 +諜 +諡 +諦 +諧 +諫 +諭 +諮 +諱 +諳 +諷 +諸 +諺 +諾 +謀 +謁 +謂 +謄 +謊 +謎 +謐 +謔 +謗 +謙 +講 +謝 +謠 +謨 +謬 +謹 +謾 +譁 +證 +譎 +譏 +識 +譙 +譚 +譜 +警 +譬 +譯 +議 +譲 +譴 +護 +譽 +讀 +變 +讓 +讚 +讞 +计 +订 +认 +讥 +讧 +讨 +让 +讪 +讫 +训 +议 +讯 +记 +讲 +讳 +讴 +讶 +讷 +许 +讹 +论 +讼 +讽 +设 +访 +诀 +证 +诃 +评 +诅 +识 +诈 +诉 +诊 +诋 +词 +诏 +译 +试 +诗 +诘 +诙 +诚 +诛 +话 +诞 +诟 +诠 +诡 +询 +诣 +诤 +该 +详 +诧 +诩 +诫 +诬 +语 +误 +诰 +诱 +诲 +说 +诵 +诶 +请 +诸 +诺 +读 +诽 +课 +诿 +谀 +谁 +调 +谄 +谅 +谆 +谈 +谊 +谋 +谌 +谍 +谎 +谏 +谐 +谑 +谒 +谓 +谔 +谕 +谗 +谘 +谙 +谚 +谛 +谜 +谟 +谢 +谣 +谤 +谥 +谦 +谧 +谨 +谩 +谪 +谬 +谭 +谯 +谱 +谲 +谴 +谶 +谷 +豁 +豆 +豇 +豈 +豉 +豊 +豌 +豎 +豐 +豔 +豚 +象 +豢 +豪 +豫 +豬 +豹 +豺 +貂 +貅 +貌 +貓 +貔 +貘 +貝 +貞 +負 +財 +貢 +貧 +貨 +販 +貪 +貫 +責 +貯 +貰 +貳 +貴 +貶 +買 +貸 +費 +貼 +貽 +貿 +賀 +賁 +賂 +賃 +賄 +資 +賈 +賊 +賑 +賓 +賜 +賞 +賠 +賡 +賢 +賣 +賤 +賦 +質 +賬 +賭 +賴 +賺 +購 +賽 +贅 +贈 +贊 +贍 +贏 +贓 +贖 +贛 +贝 +贞 +负 +贡 +财 +责 +贤 +败 +账 +货 +质 +贩 +贪 +贫 +贬 +购 +贮 +贯 +贰 +贱 +贲 +贴 +贵 +贷 +贸 +费 +贺 +贻 +贼 +贾 +贿 +赁 +赂 +赃 +资 +赅 +赈 +赊 +赋 +赌 +赎 +赏 +赐 +赓 +赔 +赖 +赘 +赚 +赛 +赝 +赞 +赠 +赡 +赢 +赣 +赤 +赦 +赧 +赫 +赭 +走 +赳 +赴 +赵 +赶 +起 +趁 +超 +越 +趋 +趕 +趙 +趟 +趣 +趨 +足 +趴 +趵 +趸 +趺 +趾 +跃 +跄 +跆 +跋 +跌 +跎 +跑 +跖 +跚 +跛 +距 +跟 +跡 +跤 +跨 +跩 +跪 +路 +跳 +践 +跷 +跹 +跺 +跻 +踉 +踊 +踌 +踏 +踐 +踝 +踞 +踟 +踢 +踩 +踪 +踮 +踱 +踴 +踵 +踹 +蹂 +蹄 +蹇 +蹈 +蹉 +蹊 +蹋 +蹑 +蹒 +蹙 +蹟 +蹣 +蹤 +蹦 +蹩 +蹬 +蹭 +蹲 +蹴 +蹶 +蹺 +蹼 +蹿 +躁 +躇 +躉 +躊 +躋 +躍 +躏 +躪 +身 +躬 +躯 +躲 +躺 +軀 +車 +軋 +軌 +軍 +軒 +軟 +転 +軸 +軼 +軽 +軾 +較 +載 +輒 +輓 +輔 +輕 +輛 +輝 +輟 +輩 +輪 +輯 +輸 +輻 +輾 +輿 +轄 +轅 +轆 +轉 +轍 +轎 +轟 +车 +轧 +轨 +轩 +转 +轭 +轮 +软 +轰 +轲 +轴 +轶 +轻 +轼 +载 +轿 +较 +辄 +辅 +辆 +辇 +辈 +辉 +辊 +辍 +辐 +辑 +输 +辕 +辖 +辗 +辘 +辙 +辛 +辜 +辞 +辟 +辣 +辦 +辨 +辩 +辫 +辭 +辮 +辯 +辰 +辱 +農 +边 +辺 +辻 +込 +辽 +达 +迁 +迂 +迄 +迅 +过 +迈 +迎 +运 +近 +返 +还 +这 +进 +远 +违 +连 +迟 +迢 +迤 +迥 +迦 +迩 +迪 +迫 +迭 +述 +迴 +迷 +迸 +迹 +迺 +追 +退 +送 +适 +逃 +逅 +逆 +选 +逊 +逍 +透 +逐 +递 +途 +逕 +逗 +這 +通 +逛 +逝 +逞 +速 +造 +逢 +連 +逮 +週 +進 +逵 +逶 +逸 +逻 +逼 +逾 +遁 +遂 +遅 +遇 +遊 +運 +遍 +過 +遏 +遐 +遑 +遒 +道 +達 +違 +遗 +遙 +遛 +遜 +遞 +遠 +遢 +遣 +遥 +遨 +適 +遭 +遮 +遲 +遴 +遵 +遶 +遷 +選 +遺 +遼 +遽 +避 +邀 +邁 +邂 +邃 +還 +邇 +邈 +邊 +邋 +邏 +邑 +邓 +邕 +邛 +邝 +邢 +那 +邦 +邨 +邪 +邬 +邮 +邯 +邰 +邱 +邳 +邵 +邸 +邹 +邺 +邻 +郁 +郅 +郊 +郎 +郑 +郜 +郝 +郡 +郢 +郤 +郦 +郧 +部 +郫 +郭 +郴 +郵 +郷 +郸 +都 +鄂 +鄉 +鄒 +鄔 +鄙 +鄞 +鄢 +鄧 +鄭 +鄰 +鄱 +鄲 +鄺 +酉 +酊 +酋 +酌 +配 +酐 +酒 +酗 +酚 +酝 +酢 +酣 +酥 +酩 +酪 +酬 +酮 +酯 +酰 +酱 +酵 +酶 +酷 +酸 +酿 +醃 +醇 +醉 +醋 +醍 +醐 +醒 +醚 +醛 +醜 +醞 +醣 +醪 +醫 +醬 +醮 +醯 +醴 +醺 +釀 +釁 +采 +釉 +释 +釋 +里 +重 +野 +量 +釐 +金 +釗 +釘 +釜 +針 +釣 +釦 +釧 +釵 +鈀 +鈉 +鈍 +鈎 +鈔 +鈕 +鈞 +鈣 +鈦 +鈪 +鈴 +鈺 +鈾 +鉀 +鉄 +鉅 +鉉 +鉑 +鉗 +鉚 +鉛 +鉤 +鉴 +鉻 +銀 +銃 +銅 +銑 +銓 +銖 +銘 +銜 +銬 +銭 +銮 +銳 +銷 +銹 +鋁 +鋅 +鋒 +鋤 +鋪 +鋰 +鋸 +鋼 +錄 +錐 +錘 +錚 +錠 +錢 +錦 +錨 +錫 +錮 +錯 +録 +錳 +錶 +鍊 +鍋 +鍍 +鍛 +鍥 +鍰 +鍵 +鍺 +鍾 +鎂 +鎊 +鎌 +鎏 +鎔 +鎖 +鎗 +鎚 +鎧 +鎬 +鎮 +鎳 +鏈 +鏖 +鏗 +鏘 +鏞 +鏟 +鏡 +鏢 +鏤 +鏽 +鐘 +鐮 +鐲 +鐳 +鐵 +鐸 +鐺 +鑄 +鑊 +鑑 +鑒 +鑣 +鑫 +鑰 +鑲 +鑼 +鑽 +鑾 +鑿 +针 +钉 +钊 +钎 +钏 +钒 +钓 +钗 +钙 +钛 +钜 +钝 +钞 +钟 +钠 +钡 +钢 +钣 +钤 +钥 +钦 +钧 +钨 +钩 +钮 +钯 +钰 +钱 +钳 +钴 +钵 +钺 +钻 +钼 +钾 +钿 +铀 +铁 +铂 +铃 +铄 +铅 +铆 +铉 +铎 +铐 +铛 +铜 +铝 +铠 +铡 +铢 +铣 +铤 +铨 +铩 +铬 +铭 +铮 +铰 +铲 +铵 +银 +铸 +铺 +链 +铿 +销 +锁 +锂 +锄 +锅 +锆 +锈 +锉 +锋 +锌 +锏 +锐 +锑 +错 +锚 +锟 +锡 +锢 +锣 +锤 +锥 +锦 +锭 +键 +锯 +锰 +锲 +锵 +锹 +锺 +锻 +镀 +镁 +镂 +镇 +镉 +镌 +镍 +镐 +镑 +镕 +镖 +镗 +镛 +镜 +镣 +镭 +镯 +镰 +镳 +镶 +長 +长 +門 +閃 +閉 +開 +閎 +閏 +閑 +閒 +間 +閔 +閘 +閡 +関 +閣 +閥 +閨 +閩 +閱 +閲 +閹 +閻 +閾 +闆 +闇 +闊 +闌 +闍 +闔 +闕 +闖 +闘 +關 +闡 +闢 +门 +闪 +闫 +闭 +问 +闯 +闰 +闲 +间 +闵 +闷 +闸 +闹 +闺 +闻 +闽 +闾 +阀 +阁 +阂 +阅 +阆 +阇 +阈 +阉 +阎 +阐 +阑 +阔 +阕 +阖 +阙 +阚 +阜 +队 +阡 +阪 +阮 +阱 +防 +阳 +阴 +阵 +阶 +阻 +阿 +陀 +陂 +附 +际 +陆 +陇 +陈 +陋 +陌 +降 +限 +陕 +陛 +陝 +陞 +陟 +陡 +院 +陣 +除 +陨 +险 +陪 +陰 +陲 +陳 +陵 +陶 +陷 +陸 +険 +陽 +隅 +隆 +隈 +隊 +隋 +隍 +階 +随 +隐 +隔 +隕 +隘 +隙 +際 +障 +隠 +隣 +隧 +隨 +險 +隱 +隴 +隶 +隸 +隻 +隼 +隽 +难 +雀 +雁 +雄 +雅 +集 +雇 +雉 +雋 +雌 +雍 +雎 +雏 +雑 +雒 +雕 +雖 +雙 +雛 +雜 +雞 +離 +難 +雨 +雪 +雯 +雰 +雲 +雳 +零 +雷 +雹 +電 +雾 +需 +霁 +霄 +霆 +震 +霈 +霉 +霊 +霍 +霎 +霏 +霑 +霓 +霖 +霜 +霞 +霧 +霭 +霰 +露 +霸 +霹 +霽 +霾 +靂 +靄 +靈 +青 +靓 +靖 +静 +靚 +靛 +靜 +非 +靠 +靡 +面 +靥 +靦 +革 +靳 +靴 +靶 +靼 +鞅 +鞋 +鞍 +鞏 +鞑 +鞘 +鞠 +鞣 +鞦 +鞭 +韆 +韋 +韌 +韓 +韜 +韦 +韧 +韩 +韬 +韭 +音 +韵 +韶 +韻 +響 +頁 +頂 +頃 +項 +順 +須 +頌 +預 +頑 +頒 +頓 +頗 +領 +頜 +頡 +頤 +頫 +頭 +頰 +頷 +頸 +頹 +頻 +頼 +顆 +題 +額 +顎 +顏 +顔 +願 +顛 +類 +顧 +顫 +顯 +顱 +顴 +页 +顶 +顷 +项 +顺 +须 +顼 +顽 +顾 +顿 +颁 +颂 +预 +颅 +领 +颇 +颈 +颉 +颊 +颌 +颍 +颐 +频 +颓 +颔 +颖 +颗 +题 +颚 +颛 +颜 +额 +颞 +颠 +颡 +颢 +颤 +颦 +颧 +風 +颯 +颱 +颳 +颶 +颼 +飄 +飆 +风 +飒 +飓 +飕 +飘 +飙 +飚 +飛 +飞 +食 +飢 +飨 +飩 +飪 +飯 +飲 +飼 +飽 +飾 +餃 +餅 +餉 +養 +餌 +餐 +餒 +餓 +餘 +餚 +餛 +餞 +餡 +館 +餮 +餵 +餾 +饅 +饈 +饋 +饌 +饍 +饑 +饒 +饕 +饗 +饞 +饥 +饨 +饪 +饬 +饭 +饮 +饯 +饰 +饱 +饲 +饴 +饵 +饶 +饷 +饺 +饼 +饽 +饿 +馀 +馁 +馄 +馅 +馆 +馈 +馋 +馍 +馏 +馒 +馔 +首 +馗 +香 +馥 +馨 +馬 +馭 +馮 +馳 +馴 +駁 +駄 +駅 +駆 +駐 +駒 +駕 +駛 +駝 +駭 +駱 +駿 +騁 +騎 +騏 +験 +騙 +騨 +騰 +騷 +驀 +驅 +驊 +驍 +驒 +驕 +驗 +驚 +驛 +驟 +驢 +驥 +马 +驭 +驮 +驯 +驰 +驱 +驳 +驴 +驶 +驷 +驸 +驹 +驻 +驼 +驾 +驿 +骁 +骂 +骄 +骅 +骆 +骇 +骈 +骊 +骋 +验 +骏 +骐 +骑 +骗 +骚 +骛 +骜 +骞 +骠 +骡 +骤 +骥 +骧 +骨 +骯 +骰 +骶 +骷 +骸 +骼 +髂 +髅 +髋 +髏 +髒 +髓 +體 +髖 +高 +髦 +髪 +髮 +髯 +髻 +鬃 +鬆 +鬍 +鬓 +鬚 +鬟 +鬢 +鬣 +鬥 +鬧 +鬱 +鬼 +魁 +魂 +魄 +魅 +魇 +魍 +魏 +魔 +魘 +魚 +魯 +魷 +鮑 +鮨 +鮪 +鮭 +鮮 +鯉 +鯊 +鯖 +鯛 +鯨 +鯰 +鯽 +鰍 +鰓 +鰭 +鰲 +鰻 +鰾 +鱈 +鱉 +鱔 +鱗 +鱷 +鱸 +鱼 +鱿 +鲁 +鲈 +鲍 +鲑 +鲛 +鲜 +鲟 +鲢 +鲤 +鲨 +鲫 +鲱 +鲲 +鲶 +鲷 +鲸 +鳃 +鳄 +鳅 +鳌 +鳍 +鳕 +鳖 +鳗 +鳝 +鳞 +鳥 +鳩 +鳳 +鳴 +鳶 +鴉 +鴕 +鴛 +鴦 +鴨 +鴻 +鴿 +鵑 +鵜 +鵝 +鵡 +鵬 +鵰 +鵲 +鶘 +鶩 +鶯 +鶴 +鷗 +鷲 +鷹 +鷺 +鸚 +鸞 +鸟 +鸠 +鸡 +鸢 +鸣 +鸥 +鸦 +鸨 +鸪 +鸭 +鸯 +鸳 +鸵 +鸽 +鸾 +鸿 +鹂 +鹃 +鹄 +鹅 +鹈 +鹉 +鹊 +鹌 +鹏 +鹑 +鹕 +鹘 +鹜 +鹞 +鹤 +鹦 +鹧 +鹫 +鹭 +鹰 +鹳 +鹵 +鹹 +鹼 +鹽 +鹿 +麂 +麋 +麒 +麓 +麗 +麝 +麟 +麥 +麦 +麩 +麴 +麵 +麸 +麺 +麻 +麼 +麽 +麾 +黃 +黄 +黍 +黎 +黏 +黑 +黒 +黔 +默 +黛 +黜 +黝 +點 +黠 +黨 +黯 +黴 +鼋 +鼎 +鼐 +鼓 +鼠 +鼬 +鼹 +鼻 +鼾 +齁 +齊 +齋 +齐 +齒 +齡 +齢 +齣 +齦 +齿 +龄 +龅 +龈 +龊 +龋 +龌 +龍 +龐 +龔 +龕 +龙 +龚 +龛 +龜 +龟 +︰ +︱ +︶ +︿ +﹁ +﹂ +﹍ +﹏ +﹐ +﹑ +﹒ +﹔ +﹕ +﹖ +﹗ +﹙ +﹚ +﹝ +﹞ +﹡ +﹣ +！ +＂ +＃ +＄ +％ +＆ +＇ +（ +） +＊ +＋ +， +－ +． +／ +０ +１ +２ +３ +４ +５ +６ +７ +８ +９ +： +； +＜ +＝ +＞ +？ +＠ +［ +＼ +］ +＾ +＿ +｀ +ａ +ｂ +ｃ +ｄ +ｅ +ｆ +ｇ +ｈ +ｉ +ｊ +ｋ +ｌ +ｍ +ｎ +ｏ +ｐ +ｑ +ｒ +ｓ +ｔ +ｕ +ｖ +ｗ +ｘ +ｙ +ｚ +｛ +｜ +｝ +～ +｡ +｢ +｣ +､ +･ +ｯ +ｰ +ｲ +ｸ +ｼ +ｽ +ﾄ +ﾉ +ﾌ +ﾗ +ﾙ +ﾝ +ﾞ +ﾟ +￣ +￥ +👍 +🔥 +😂 +😎 +... +yam +10 +2017 +12 +11 +2016 +20 +30 +15 +06 +lofter +##s +2015 +by +16 +14 +18 +13 +24 +17 +2014 +21 +##0 +22 +19 +25 +23 +com +100 +00 +05 +2013 +##a +03 +09 +08 +28 +##2 +50 +01 +04 +##1 +27 +02 +2012 +##3 +26 +##e +07 +##8 +##5 +##6 +##4 +##9 +##7 +29 +2011 +40 +##t +2010 +##o +##d +##i +2009 +##n +app +www +the +##m +31 +##c +##l +##y +##r +##g +2008 +60 +http +200 +qq +##p +80 +##f +google +pixnet +90 +cookies +tripadvisor +500 +##er +##k +35 +##h +facebook +2007 +2000 +70 +##b +of +##x +##u +45 +300 +iphone +32 +1000 +2006 +48 +ip +36 +in +38 +3d +##w +##ing +55 +ctrip +##on +##v +33 +##の +to +34 +400 +id +2005 +it +37 +windows +llc +top +99 +42 +39 +000 +led +at +##an +41 +51 +52 +46 +49 +43 +53 +44 +##z +android +58 +and +59 +2004 +56 +vr +##か +5000 +2003 +47 +blogthis +twitter +54 +##le +150 +ok +2018 +57 +75 +cn +no +ios +##in +##mm +##00 +800 +on +te +3000 +65 +2001 +360 +95 +ig +lv +120 +##ng +##を +##us +##に +pc +てす +── +600 +##te +85 +2002 +88 +##ed +html +ncc +wifi +email +64 +blog +is +##10 +##て +mail +online +##al +dvd +##ic +studio +##は +##℃ +##ia +##と +line +vip +72 +##q +98 +##ce +##en +for +##is +##ra +##es +##j +usb +net +cp +1999 +asia +4g +##cm +diy +new +3c +##お +ta +66 +language +vs +apple +tw +86 +web +##ne +ipad +62 +you +##re +101 +68 +##tion +ps +de +bt +pony +atm +##2017 +1998 +67 +##ch +ceo +##or +go +##na +av +pro +cafe +96 +pinterest +97 +63 +pixstyleme3c +##ta +more +said +##2016 +1997 +mp3 +700 +##ll +nba +jun +##20 +92 +tv +1995 +pm +61 +76 +nbsp +250 +##ie +linux +##ma +cd +110 +hd +##17 +78 +##ion +77 +6000 +am +##th +##st +94 +##se +##et +69 +180 +gdp +my +105 +81 +abc +89 +flash +79 +one +93 +1990 +1996 +##ck +gps +##も +##ly +web885 +106 +2020 +91 +##ge +4000 +1500 +xd +boss +isbn +1994 +org +##ry +me +love +##11 +0fork +73 +##12 +3g +##ter +##ar +71 +82 +##la +hotel +130 +1970 +pk +83 +87 +140 +ie +##os +##30 +##el +74 +##50 +seo +cpu +##ml +p2p +84 +may +##る +sun +tue +internet +cc +posted +youtube +##at +##ン +##man +ii +##ル +##15 +abs +nt +pdf +yahoo +ago +1980 +##it +news +mac +104 +##てす +##me +##り +java +1992 +spa +##de +##nt +hk +all +plus +la +1993 +##mb +##16 +##ve +west +##da +160 +air +##い +##ps +から +##to +1989 +logo +htc +php +https +fi +momo +##son +sat +##ke +##80 +ebd +suv +wi +day +apk +##88 +##um +mv +galaxy +wiki +or +brake +##ス +1200 +する +this +1991 +mon +##こ +❤2017 +po +##ない +javascript +life +home +june +##ss +system +900 +##ー +##０ +pp +1988 +world +fb +4k +br +##as +ic +ai +leonardo +safari +##60 +live +free +xx +wed +win7 +kiehl +##co +lg +o2o +##go +us +235 +1949 +mm +しい +vfm +kanye +##90 +##2015 +##id +jr +##ey +123 +rss +##sa +##ro +##am +##no +thu +fri +350 +##sh +##ki +103 +comments +name +##のて +##pe +##ine +max +1987 +8000 +uber +##mi +##ton +wordpress +office +1986 +1985 +##ment +107 +bd +win10 +##ld +##li +gmail +bb +dior +##rs +##ri +##rd +##ます +up +cad +##® +dr +して +read +##21 +をお +##io +##99 +url +1984 +pvc +paypal +show +policy +##40 +##ty +##18 +with +##★ +##01 +txt +102 +##ba +dna +from +post +mini +ar +taiwan +john +##ga +privacy +agoda +##13 +##ny +word +##24 +##22 +##by +##ur +##hz +1982 +##ang +265 +cookie +netscape +108 +##ka +##～ +##ad +house +share +note +ibm +code +hello +nike +sim +survey +##016 +1979 +1950 +wikia +##32 +##017 +5g +cbc +##tor +##kg +1983 +##rt +##14 +campaign +store +2500 +os +##ct +##ts +##° +170 +api +##ns +365 +excel +##な +##ao +##ら +##し +～～ +##nd +university +163 +には +518 +##70 +##ya +##il +##25 +pierre +ipo +0020 +897 +##23 +hotels +##ian +のお +125 +years +6606 +##ers +##26 +high +##day +time +##ay +bug +##line +##く +##す +##be +xp +talk2yam +yamservice +10000 +coco +##dy +sony +##ies +1978 +microsoft +david +people +##ha +1960 +instagram +intel +その +##ot +iso +1981 +##va +115 +##mo +##land +xxx +man +co +ltxsw +##ation +baby +220 +##pa +##ol +1945 +7000 +tag +450 +##ue +msn +##31 +oppo +##ト +##ca +control +##om +st +chrome +##ure +##ん +be +##き +lol +##19 +した +##bo +240 +lady +##100 +##way +##から +4600 +##ko +##do +##un +4s +corporation +168 +##ni +herme +##28 +ｃｐ +978 +##up +##06 +ui +##ds +ppt +admin +three +します +bbc +re +128 +##48 +ca +##015 +##35 +hp +##ee +tpp +##た +##ive +×× +root +##cc +##ました +##ble +##ity +adobe +park +114 +et +oled +city +##ex +##ler +##ap +china +##book +20000 +view +##ice +global +##km +your +hong +##mg +out +##ms +ng +ebay +##29 +menu +ubuntu +##cy +rom +##view +open +ktv +do +server +##lo +if +english +##ね +##５ +##oo +1600 +##02 +step1 +kong +club +135 +july +inc +1976 +mr +hi +##net +touch +##ls +##ii +michael +lcd +##05 +##33 +phone +james +step2 +1300 +ios9 +##box +dc +##２ +##ley +samsung +111 +280 +pokemon +css +##ent +##les +いいえ +##１ +s8 +atom +play +bmw +##said +sa +etf +ctrl +♥yoyo♥ +##55 +2025 +##2014 +##66 +adidas +amazon +1958 +##ber +##ner +visa +##77 +##der +1800 +connectivity +##hi +firefox +109 +118 +hr +so +style +mark +pop +ol +skip +1975 +as +##27 +##ir +##61 +190 +mba +##う +##ai +le +##ver +1900 +cafe2017 +lte +super +113 +129 +##ron +amd +like +##☆ +are +##ster +we +##sk +paul +data +international +##ft +longchamp +ssd +good +##ート +##ti +reply +##my +↓↓↓ +apr +star +##ker +source +136 +js +112 +get +force +photo +##one +126 +##2013 +##ow +link +bbs +1972 +goods +##lin +python +119 +##ip +game +##ics +##ません +blue +##● +520 +##45 +page +itunes +##03 +1955 +260 +1968 +gt +gif +618 +##ff +##47 +group +くたさい +about +bar +ganji +##nce +music +lee +not +1977 +1971 +1973 +##per +an +faq +comment +##って +days +##ock +116 +##bs +1974 +1969 +v1 +player +1956 +xbox +sql +fm +f1 +139 +##ah +210 +##lv +##mp +##000 +melody +1957 +##３ +550 +17life +199 +1966 +xml +market +##au +##71 +999 +##04 +what +gl +##95 +##age +tips +##68 +book +##ting +mysql +can +1959 +230 +##ung +wonderland +watch +10℃ +##ction +9000 +mar +mobile +1946 +1962 +article +##db +part +▲top +party +って +1967 +1964 +1948 +##07 +##ore +##op +この +dj +##78 +##38 +010 +main +225 +1965 +##ong +art +320 +ad +134 +020 +##73 +117 +pm2 +japan +228 +##08 +ts +1963 +##ica +der +sm +##36 +2019 +##wa +ct +##７ +##や +##64 +1937 +homemesh +search +##85 +##れは +##tv +##di +macbook +##９ +##くたさい +service +##♥ +type +った +750 +##ier +##si +##75 +##います +##ok +best +##ット +goris +lock +##った +cf +3m +big +##ut +ftp +carol +##vi +１０ +1961 +happy +sd +##ac +122 +anti +pe +cnn +iii +1920 +138 +##ラ +1940 +esp +jan +tags +##98 +##51 +august +vol +##86 +154 +##™ +##fs +##れ +##sion +design +ac +##ム +press +jordan +ppp +that +key +check +##６ +##tt +##㎡ +1080p +##lt +power +##42 +1952 +##bc +vivi +##ック +he +133 +121 +jpg +##rry +201 +175 +3500 +1947 +nb +##ted +##rn +しています +1954 +usd +##t00 +master +##ンク +001 +model +##58 +al +##09 +1953 +##34 +ram +goo +ても +##ui +127 +1930 +red +##ary +rpg +item +##pm +##41 +270 +##za +project +##2012 +hot +td +blogabstract +##ger +##62 +650 +##44 +gr2 +##します +##ｍ +black +electronic +nfc +year +asus +また +html5 +cindy +##hd +m3 +132 +esc +##od +booking +##53 +fed +tvb +##81 +##ina +mit +165 +##いる +chan +192 +distribution +next +になる +peter +bios +steam +cm +1941 +にも +pk10 +##ix +##65 +##91 +dec +nasa +##ana +icecat +00z +b1 +will +##46 +li +se +##ji +##み +##ard +oct +##ain +jp +##ze +##bi +cio +##56 +smart +h5 +##39 +##port +curve +vpn +##nm +##dia +utc +##あり +12345678910 +##52 +rmvb +chanel +a4 +miss +##and +##im +media +who +##63 +she +girl +5s +124 +vera +##して +class +vivo +king +##フ +##ei +national +ab +1951 +5cm +888 +145 +ipod +ap +1100 +5mm +211 +ms +2756 +##69 +mp4 +msci +##po +##89 +131 +mg +index +380 +##bit +##out +##zz +##97 +##67 +158 +apec +##８ +photoshop +opec +￥799 +ては +##96 +##tes +##ast +2g +○○ +##ール +￥2899 +##ling +##よ +##ory +1938 +##ical +kitty +content +##43 +step3 +##cn +win8 +155 +vc +1400 +iphone7 +robert +##した +tcl +137 +beauty +##87 +en +dollars +##ys +##oc +step +pay +yy +a1 +##2011 +##lly +##ks +##♪ +1939 +188 +download +1944 +sep +exe +ph +います +school +gb +center +pr +street +##board +uv +##37 +##lan +winrar +##que +##ua +##com +1942 +1936 +480 +gpu +##４ +ettoday +fu +tom +##54 +##ren +##via +149 +##72 +b2b +144 +##79 +##tch +rose +arm +mb +##49 +##ial +##nn +nvidia +step4 +mvp +00㎡ +york +156 +##イ +how +cpi +591 +2765 +gov +kg +joe +##xx +mandy +pa +##ser +copyright +fashion +1935 +don +##け +ecu +##ist +##art +erp +wap +have +##lm +talk +##ek +##ning +##if +ch +##ite +video +1943 +cs +san +iot +look +##84 +##2010 +##ku +october +##ux +trump +##hs +##ide +box +141 +first +##ins +april +##ight +##83 +185 +angel +protected +aa +151 +162 +x1 +m2 +##fe +##× +##ho +size +143 +min +ofo +fun +gomaji +ex +hdmi +food +dns +march +chris +kevin +##のか +##lla +##pp +##ec +ag +ems +6s +720p +##rm +##ham +off +##92 +asp +team +fandom +ed +299 +▌♥ +##ell +info +されています +##82 +sina +4066 +161 +##able +##ctor +330 +399 +315 +dll +rights +ltd +idc +jul +3kg +1927 +142 +ma +surface +##76 +##ク +～～～ +304 +mall +eps +146 +green +##59 +map +space +donald +v2 +sodu +##light +1931 +148 +1700 +まて +310 +reserved +htm +##han +##57 +2d +178 +mod +##ise +##tions +152 +ti +##shi +doc +1933 +icp +055 +wang +##ram +shopping +aug +##pi +##well +now +wam +b2 +からお +##hu +236 +1928 +##gb +266 +f2 +##93 +153 +mix +##ef +##uan +bwl +##plus +##res +core +##ess +tea +5℃ +hktvmall +nhk +##ate +list +##ese +301 +feb +4m +inn +ての +nov +159 +12345 +daniel +##ci +pass +##bet +##nk +coffee +202 +ssl +airbnb +##ute +fbi +woshipm +skype +ea +cg +sp +##fc +##www +yes +edge +alt +007 +##94 +fpga +##ght +##gs +iso9001 +さい +##ile +##wood +##uo +image +lin +icon +american +##em +1932 +set +says +##king +##tive +blogger +##74 +なと +256 +147 +##ox +##zy +##red +##ium +##lf +nokia +claire +##リ +##ding +november +lohas +##500 +##tic +##マ +##cs +##ある +##che +##ire +##gy +##ult +db +january +win +##カ +166 +road +ptt +##ま +##つ +198 +##fa +##mer +anna +pchome +はい +udn +ef +420 +##time +##tte +2030 +##ア +g20 +white +かかります +1929 +308 +garden +eleven +di +##おります +chen +309b +777 +172 +young +cosplay +ちてない +4500 +bat +##123 +##tra +##ては +kindle +npc +steve +etc +##ern +##｜ +call +xperia +ces +travel +sk +s7 +##ous +1934 +##int +みいたたけます +183 +edu +file +cho +qr +##car +##our +186 +##ant +##ｄ +eric +1914 +rends +##jo +##する +mastercard +##2000 +kb +##min +290 +##ino +vista +##ris +##ud +jack +2400 +##set +169 +pos +1912 +##her +##ou +taipei +しく +205 +beta +##ませんか +232 +##fi +express +255 +body +##ill +aphojoy +user +december +meiki +##ick +tweet +richard +##av +##ᆫ +iphone6 +##dd +ちてすか +views +##mark +321 +pd +##００ +times +##▲ +level +##ash +10g +point +5l +##ome +208 +koreanmall +##ak +george +q2 +206 +wma +tcp +##200 +スタッフ +full +mlb +##lle +##watch +tm +run +179 +911 +smith +business +##und +1919 +color +##tal +222 +171 +##less +moon +4399 +##rl +update +pcb +shop +499 +157 +little +なし +end +##mhz +van +dsp +easy +660 +##house +##key +history +##ｏ +oh +##001 +##hy +##web +oem +let +was +##2009 +##gg +review +##wan +182 +##°c +203 +uc +title +##val +united +233 +2021 +##ons +doi +trivago +overdope +sbs +##ance +##ち +grand +special +573032185 +imf +216 +wx17house +##so +##ーム +audi +##he +london +william +##rp +##ake +science +beach +cfa +amp +ps4 +880 +##800 +##link +##hp +crm +ferragamo +bell +make +##eng +195 +under +zh +photos +2300 +##style +##ント +via +176 +da +##gi +company +i7 +##ray +thomas +370 +ufo +i5 +##max +plc +ben +back +research +8g +173 +mike +##pc +##ッフ +september +189 +##ace +vps +february +167 +pantos +wp +lisa +1921 +★★ +jquery +night +long +offer +##berg +##news +1911 +##いて +ray +fks +wto +せます +over +164 +340 +##all +##rus +1924 +##888 +##works +blogtitle +loftpermalink +##→ +187 +martin +test +ling +km +##め +15000 +fda +v3 +##ja +##ロ +ｗedding +かある +outlet +family +##ea +をこ +##top +story +##ness +salvatore +##lu +204 +swift +215 +room +している +oracle +##ul +1925 +sam +b2c +week +pi +rock +##のは +##ａ +##けと +##ean +##300 +##gle +cctv +after +chinese +##back +powered +x2 +##tan +1918 +##nes +##イン +canon +only +181 +##zi +##las +say +##oe +184 +##sd +221 +##bot +##world +##zo +sky +made +top100 +just +1926 +pmi +802 +234 +gap +##vr +177 +les +174 +▲topoct +ball +vogue +vi +ing +ofweek +cos +##list +##ort +▲topmay +##なら +##lon +として +last +##tc +##of +##bus +##gen +real +eva +##コ +a3 +nas +##lie +##ria +##coin +##bt +▲topapr +his +212 +cat +nata +vive +health +⋯⋯ +drive +sir +▲topmar +du +cup +##カー +##ook +##よう +##sy +alex +msg +tour +しました +3ce +##word +193 +ebooks +r8 +block +318 +##より +2200 +nice +pvp +207 +months +1905 +rewards +##ther +1917 +0800 +##xi +##チ +##sc +micro +850 +gg +blogfp +op +1922 +daily +m1 +264 +true +##bb +ml +##tar +##のお +##ky +anthony +196 +253 +##yo +state +218 +##ara +##aa +##rc +##tz +##ston +より +gear +##eo +##ade +ge +see +1923 +##win +##ura +ss +heart +##den +##ita +down +##sm +el +png +2100 +610 +rakuten +whatsapp +bay +dream +add +##use +680 +311 +pad +gucci +mpv +##ode +##fo +island +▲topjun +##▼ +223 +jason +214 +chicago +##❤ +しの +##hone +io +##れる +##ことか +sogo +be2 +##ology +990 +cloud +vcd +##con +2～3 +##ford +##joy +##kb +##こさいます +##rade +but +##ach +docker +##ful +rfid +ul +##ase +hit +ford +##star +580 +##○ +１１ +a2 +sdk +reading +edited +##are +cmos +##mc +238 +siri +light +##ella +##ため +bloomberg +##read +pizza +##ison +jimmy +##vm +college +node +journal +ba +18k +##play +245 +##cer +２０ +magic +##yu +191 +jump +288 +tt +##ings +asr +##lia +3200 +step5 +network +##cd +mc +いします +1234 +pixstyleme +273 +##600 +2800 +money +★★★★★ +1280 +１２ +430 +bl +みの +act +##tus +tokyo +##rial +##life +emba +##ae +saas +tcs +##rk +##wang +summer +##sp +ko +##ving +390 +premium +##その +netflix +##ヒ +uk +mt +##lton +right +frank +two +209 +える +##ple +##cal +021 +##んな +##sen +##ville +hold +nexus +dd +##ius +てお +##mah +##なく +tila +zero +820 +ce +##tin +resort +##ws +charles +old +p10 +5d +report +##360 +##ru +##には +bus +vans +lt +##est +pv +##レ +links +rebecca +##ツ +##dm +azure +##365 +きな +limited +bit +4gb +##mon +1910 +moto +##eam +213 +1913 +var +eos +なとの +226 +blogspot +された +699 +e3 +dos +dm +fc +##ments +##ik +##kw +boy +##bin +##ata +960 +er +##せ +219 +##vin +##tu +##ula +194 +##∥ +station +##ろ +##ature +835 +files +zara +hdr +top10 +nature +950 +magazine +s6 +marriott +##シ +avira +case +##っと +tab +##ran +tony +##home +oculus +im +##ral +jean +saint +cry +307 +rosie +##force +##ini +ice +##bert +のある +##nder +##mber +pet +2600 +##◆ +plurk +▲topdec +##sis +00kg +▲topnov +720 +##ence +tim +##ω +##nc +##ても +##name +log +ips +great +ikea +malaysia +unix +##イト +3600 +##ncy +##nie +12000 +akb48 +##ye +##oid +404 +##chi +##いた +oa +xuehai +##1000 +##orm +##rf +275 +さん +##ware +##リー +980 +ho +##pro +text +##era +560 +bob +227 +##ub +##2008 +8891 +scp +avi +##zen +2022 +mi +wu +museum +qvod +apache +lake +jcb +▲topaug +★★★ +ni +##hr +hill +302 +ne +weibo +490 +ruby +##ーシ +##ヶ +##row +4d +▲topjul +iv +##ish +github +306 +mate +312 +##スト +##lot +##ane +andrew +のハイト +##tina +t1 +rf +ed2k +##vel +##900 +way +final +りの +ns +5a +705 +197 +##メ +sweet +bytes +##ene +▲topjan +231 +##cker +##2007 +##px +100g +topapp +229 +helpapp +rs +low +14k +g4g +care +630 +ldquo +あり +##fork +leave +rm +edition +##gan +##zon +##qq +▲topsep +##google +##ism +gold +224 +explorer +##zer +toyota +category +select +visual +##labels +restaurant +##md +posts +s1 +##ico +もっと +angelababy +123456 +217 +sports +s3 +mbc +1915 +してくたさい +shell +x86 +candy +##new +kbs +face +xl +470 +##here +4a +swissinfo +v8 +▲topfeb +dram +##ual +##vice +3a +##wer +sport +q1 +ios10 +public +int +card +##ｃ +ep +au +rt +##れた +1080 +bill +##mll +kim +３０ +460 +wan +##uk +##ミ +x3 +298 +0t +scott +##ming +239 +e5 +##3d +h7n9 +worldcat +brown +##あります +##vo +##led +##580 +##ax +249 +410 +##ert +paris +##～6 +polo +925 +##lr +599 +##ナ +capital +##hing +bank +cv +1g +##chat +##ｓ +##たい +adc +##ule +2m +##ｅ +digital +hotmail +268 +##pad +870 +bbq +quot +##ring +before +wali +##まて +mcu +2k +2b +という +costco +316 +north +333 +switch +##city +##ｐ +philips +##mann +management +panasonic +##cl +##vd +##ping +##rge +alice +##lk +##ましょう +css3 +##ney +vision +alpha +##ular +##400 +##tter +lz +にお +##ありません +mode +gre +1916 +pci +##tm +237 +1～2 +##yan +##そ +について +##let +##キ +work +war +coach +ah +mary +##ᅵ +huang +##pt +a8 +pt +follow +##berry +1895 +##ew +a5 +ghost +##ション +##wn +##og +south +##code +girls +##rid +action +villa +git +r11 +table +games +##cket +error +##anonymoussaid +##ag +here +##ame +##gc +qa +##■ +##lis +gmp +##gin +vmalife +##cher +yu +wedding +##tis +demo +dragon +530 +soho +social +bye +##rant +river +orz +acer +325 +##↑ +##ース +##ats +261 +del +##ven +440 +ups +##ように +##ター +305 +value +macd +yougou +##dn +661 +##ano +ll +##urt +##rent +continue +script +##wen +##ect +paper +263 +319 +shift +##chel +##フト +##cat +258 +x5 +fox +243 +##さん +car +aaa +##blog +loading +##yn +##tp +kuso +799 +si +sns +イカせるテンマ +ヒンクテンマ3 +rmb +vdc +forest +central +prime +help +ultra +##rmb +##ような +241 +square +688 +##しい +のないフロクに +##field +##reen +##ors +##ju +c1 +start +510 +##air +##map +cdn +##wo +cba +stephen +m8 +100km +##get +opera +##base +##ood +vsa +com™ +##aw +##ail +251 +なのて +count +t2 +##ᅡ +##een +2700 +hop +##gp +vsc +tree +##eg +##ose +816 +285 +##ories +##shop +alphago +v4 +1909 +simon +##ᆼ +fluke62max +zip +スホンサー +##sta +louis +cr +bas +##～10 +bc +##yer +hadoop +##ube +##wi +1906 +0755 +hola +##low +place +centre +5v +d3 +##fer +252 +##750 +##media +281 +540 +0l +exchange +262 +series +##ハー +##san +eb +##bank +##ｋ +q3 +##nge +##mail +take +##lp +259 +1888 +client +east +cache +event +vincent +##ールを +きを +##nse +sui +855 +adchoice +##и +##stry +##なたの +246 +##zone +ga +apps +sea +##ab +248 +cisco +##タ +##rner +kymco +##care +dha +##pu +##yi +minkoff +royal +p1 +への +annie +269 +collection +kpi +playstation +257 +になります +866 +bh +##bar +queen +505 +radio +1904 +andy +armani +##xy +manager +iherb +##ery +##share +spring +raid +johnson +1908 +##ob +volvo +hall +##ball +v6 +our +taylor +##hk +bi +242 +##cp +kate +bo +water +technology +##rie +サイトは +277 +##ona +##sl +hpv +303 +gtx +hip +rdquo +jayz +stone +##lex +##rum +namespace +##やり +620 +##ale +##atic +des +##erson +##ql +##ves +##type +enter +##この +##てきます +d2 +##168 +##mix +##bian +との +a9 +jj +ky +##lc +access +movie +##hc +リストに +tower +##ration +##mit +ます +##nch +ua +tel +prefix +##o2 +1907 +##point +1901 +ott +～10 +##http +##ury +baidu +##ink +member +##logy +bigbang +nownews +##js +##shot +##tb +##こと +247 +eba +##tics +##lus +ける +v5 +spark +##ama +there +##ions +god +##lls +##down +hiv +##ress +burberry +day2 +##kv +◆◆ +jeff +related +film +edit +joseph +283 +##ark +cx +32gb +order +g9 +30000 +##ans +##tty +s5 +##bee +かあります +thread +xr +buy +sh +005 +land +spotify +mx +##ari +276 +##verse +×email +sf +why +##ことて +244 +7headlines +nego +sunny +dom +exo +401 +666 +positioning +fit +rgb +##tton +278 +kiss +alexa +adam +lp +みリストを +##ｇ +mp +##ties +##llow +amy +##du +np +002 +institute +271 +##rth +##lar +2345 +590 +##des +sidebar +１５ +imax +site +##cky +##kit +##ime +##009 +season +323 +##fun +##ンター +##ひ +gogoro +a7 +pu +lily +fire +twd600 +##ッセーシを +いて +##vis +30ml +##cture +##をお +information +##オ +close +friday +##くれる +yi +nick +てすか +##tta +##tel +6500 +##lock +cbd +economy +254 +かお +267 +tinker +double +375 +8gb +voice +##app +oops +channel +today +985 +##right +raw +xyz +##＋ +jim +edm +##cent +7500 +supreme +814 +ds +##its +##asia +dropbox +##てすか +##tti +books +272 +100ml +##tle +##ller +##ken +##more +##boy +sex +309 +##dom +t3 +##ider +##なります +##unch +1903 +810 +feel +5500 +##かった +##put +により +s2 +mo +##gh +men +ka +amoled +div +##tr +##n1 +port +howard +##tags +ken +dnf +##nus +adsense +##а +ide +##へ +buff +thunder +##town +##ique +has +##body +auto +pin +##erry +tee +てした +295 +number +##the +##013 +object +psp +cool +udnbkk +16gb +##mic +miui +##tro +most +r2 +##alk +##nity +1880 +±0 +##いました +428 +s4 +law +version +##oa +n1 +sgs +docomo +##tf +##ack +henry +fc2 +##ded +##sco +##014 +##rite +286 +0mm +linkedin +##ada +##now +wii +##ndy +ucbug +##◎ +sputniknews +legalminer +##ika +##xp +2gb +##bu +q10 +oo +b6 +come +##rman +cheese +ming +maker +##gm +nikon +##fig +ppi +kelly +##ります +jchere +てきます +ted +md +003 +fgo +tech +##tto +dan +soc +##gl +##len +hair +earth +640 +521 +img +##pper +##a1 +##てきる +##ロク +acca +##ition +##ference +suite +##ig +outlook +##mond +##cation +398 +##pr +279 +101vip +358 +##999 +282 +64gb +3800 +345 +airport +##over +284 +##おり +jones +##ith +lab +##su +##いるのて +co2 +town +piece +##llo +no1 +vmware +24h +##qi +focus +reader +##admin +##ora +tb +false +##log +1898 +know +lan +838 +##ces +f4 +##ume +motel +stop +##oper +na +flickr +netcomponents +##af +##─ +pose +williams +local +##ound +##cg +##site +##iko +いお +274 +5m +gsm +con +##ath +1902 +friends +##hip +cell +317 +##rey +780 +cream +##cks +012 +##dp +facebooktwitterpinterestgoogle +sso +324 +shtml +song +swiss +##mw +##キンク +lumia +xdd +string +tiffany +522 +marc +られた +insee +russell +sc +dell +##ations +ｏｋ +camera +289 +##vs +##flow +##late +classic +287 +##nter +stay +g1 +mtv +512 +##ever +##lab +##nger +qe +sata +ryan +d1 +50ml +cms +##cing +su +292 +3300 +editor +296 +##nap +security +sunday +association +##ens +##700 +##bra +acg +##かり +sofascore +とは +mkv +##ign +jonathan +gary +build +labels +##oto +tesla +moba +qi +gohappy +general +ajax +1024 +##かる +サイト +society +##test +##urs +wps +fedora +##ich +mozilla +328 +##480 +##dr +usa +urn +##lina +##ｒ +grace +##die +##try +##ader +1250 +##なり +elle +570 +##chen +##ᆯ +price +##ten +uhz +##ough +eq +##hen +states +push +session +balance +wow +506 +##cus +##py +when +##ward +##ep +34e +wong +library +prada +##サイト +##cle +running +##ree +313 +ck +date +q4 +##ctive +##ool +##＞ +mk +##ira +##163 +388 +die +secret +rq +dota +buffet +は１ヶ +e6 +##ez +pan +368 +ha +##card +##cha +2a +##さ +alan +day3 +eye +f3 +##end +france +keep +adi +rna +tvbs +##ala +solo +nova +##え +##tail +##ょう +support +##ries +##なる +##ved +base +copy +iis +fps +##ways +hero +hgih +profile +fish +mu +ssh +entertainment +chang +##wd +click +cake +##ond +pre +##tom +kic +pixel +##ov +##fl +product +6a +##pd +dear +##gate +es +yumi +audio +##² +##sky +echo +bin +where +##ture +329 +##ape +find +sap +isis +##なと +nand +##101 +##load +##ream +band +a6 +525 +never +##post +festival +50cm +##we +555 +guide +314 +zenfone +##ike +335 +gd +forum +jessica +strong +alexander +##ould +software +allen +##ious +program +360° +else +lohasthree +##gar +することかてきます +please +##れます +rc +##ggle +##ric +bim +50000 +##own +eclipse +355 +brian +3ds +##side +061 +361 +##other +##ける +##tech +##ator +485 +engine +##ged +##ｔ +plaza +##fit +cia +ngo +westbrook +shi +tbs +50mm +##みませんか +sci +291 +reuters +##ily +contextlink +##hn +af +##cil +bridge +very +##cel +1890 +cambridge +##ize +15g +##aid +##data +790 +frm +##head +award +butler +##sun +meta +##mar +america +ps3 +puma +pmid +##すか +lc +670 +kitchen +##lic +オーフン5 +きなしソフトサーヒス +そして +day1 +future +★★★★ +##text +##page +##rris +pm1 +##ket +fans +##っています +1001 +christian +bot +kids +trackback +##hai +c3 +display +##hl +n2 +1896 +idea +さんも +##sent +airmail +##ug +##men +pwm +けます +028 +##lution +369 +852 +awards +schemas +354 +asics +wikipedia +font +##tional +##vy +c2 +293 +##れている +##dget +##ein +っている +contact +pepper +スキル +339 +##～5 +294 +##uel +##ument +730 +##hang +みてす +q5 +##sue +rain +##ndi +wei +swatch +##cept +わせ +331 +popular +##ste +##tag +p2 +501 +trc +1899 +##west +##live +justin +honda +ping +messenger +##rap +v9 +543 +##とは +unity +appqq +はすへて +025 +leo +##tone +##テ +##ass +uniqlo +##010 +502 +her +jane +memory +moneydj +##tical +human +12306 +していると +##m2 +coc +miacare +##mn +tmt +##core +vim +kk +##may +fan +target +use +too +338 +435 +2050 +867 +737 +fast +##2c +services +##ope +omega +energy +##わ +pinkoi +1a +##なから +##rain +jackson +##ement +##シャンルの +374 +366 +そんな +p9 +rd +##ᆨ +1111 +##tier +##vic +zone +##│ +385 +690 +dl +isofix +cpa +m4 +322 +kimi +めて +davis +##lay +lulu +##uck +050 +weeks +qs +##hop +920 +##ｎ +ae +##ear +～5 +eia +405 +##fly +korea +jpeg +boost +##ship +small +##リア +1860 +eur +297 +425 +valley +##iel +simple +##ude +rn +k2 +##ena +されます +non +patrick +しているから +##ナー +feed +5757 +30g +process +well +qqmei +##thing +they +aws +lu +pink +##ters +##kin +または +board +##vertisement +wine +##ien +unicode +##dge +r1 +359 +##tant +いを +##twitter +##3c +cool1 +される +##れて +##ｌ +isp +##012 +standard +45㎡2 +402 +##150 +matt +##fu +326 +##iner +googlemsn +pixnetfacebookyahoo +##ラン +x7 +886 +##uce +メーカー +sao +##ev +##きました +##file +9678 +403 +xddd +shirt +6l +##rio +##hat +3mm +givenchy +ya +bang +##lio +monday +crystal +ロクイン +##abc +336 +head +890 +ubuntuforumwikilinuxpastechat +##vc +##～20 +##rity +cnc +7866 +ipv6 +null +1897 +##ost +yang +imsean +tiger +##fet +##ンス +352 +##＝ +dji +327 +ji +maria +##come +##んて +foundation +3100 +##beth +##なった +1m +601 +active +##aft +##don +3p +sr +349 +emma +##khz +living +415 +353 +1889 +341 +709 +457 +sas +x6 +##face +pptv +x4 +##mate +han +sophie +##jing +337 +fifa +##mand +other +sale +inwedding +##gn +てきちゃいます +##mmy +##pmlast +bad +nana +nbc +してみてくたさいね +なとはお +##wu +##かあります +##あ +note7 +single +##340 +せからこ +してくたさい♪この +しにはとんとんワークケートを +するとあなたにもっとマッチした +ならワークケートへ +もみつかっちゃうかも +ワークケートの +##bel +window +##dio +##ht +union +age +382 +１４ +##ivity +##ｙ +コメント +domain +neo +##isa +##lter +5k +f5 +steven +##cts +powerpoint +tft +self +g2 +ft +##テル +zol +##act +mwc +381 +343 +もう +nbapop +408 +てある +eds +ace +##room +previous +author +tomtom +il +##ets +hu +financial +☆☆☆ +っています +bp +5t +chi +1gb +##hg +fairmont +cross +008 +gay +h2 +function +##けて +356 +also +1b +625 +##ータ +##raph +1894 +3～5 +##ils +i3 +334 +avenue +##host +による +##bon +##tsu +message +navigation +50g +fintech +h6 +##ことを +8cm +##ject +##vas +##firm +credit +##wf +xxxx +form +##nor +##space +huawei +plan +json +sbl +##dc +machine +921 +392 +wish +##120 +##sol +windows7 +edward +##ために +development +washington +##nsis +lo +818 +##sio +##ym +##bor +planet +##～8 +##wt +ieee +gpa +##めて +camp +ann +gm +##tw +##oka +connect +##rss +##work +##atus +wall +chicken +soul +2mm +##times +fa +##ather +##cord +009 +##eep +hitachi +gui +harry +##pan +e1 +disney +##press +##ーション +wind +386 +frigidaire +##tl +liu +hsu +332 +basic +von +ev +いた +てきる +スホンサーサイト +learning +##ull +expedia +archives +change +##wei +santa +cut +ins +6gb +turbo +brand +cf1 +508 +004 +return +747 +##rip +h1 +##nis +##をこ +128gb +##にお +3t +application +しており +emc +rx +##oon +384 +quick +412 +15058 +wilson +wing +chapter +##bug +beyond +##cms +##dar +##oh +zoom +e2 +trip +sb +##nba +rcep +342 +aspx +ci +080 +gc +gnu +める +##count +advanced +dance +dv +##url +##ging +367 +8591 +am09 +shadow +battle +346 +##ｉ +##cia +##という +emily +##のてす +##tation +host +ff +techorz +sars +##mini +##mporary +##ering +nc +4200 +798 +##next +cma +##mbps +##gas +##ift +##dot +##ィ +455 +##～17 +amana +##りの +426 +##ros +ir +00㎡1 +##eet +##ible +##↓ +710 +ˋ▽ˊ +##aka +dcs +iq +##ｖ +l1 +##lor +maggie +##011 +##iu +588 +##～1 +830 +##gt +1tb +articles +create +##burg +##iki +database +fantasy +##rex +##cam +dlc +dean +##you +hard +path +gaming +victoria +maps +cb +##lee +##itor +overchicstoretvhome +systems +##xt +416 +p3 +sarah +760 +##nan +407 +486 +x9 +install +second +626 +##ann +##ph +##rcle +##nic +860 +##nar +ec +##とう +768 +metro +chocolate +##rian +～4 +##table +##しています +skin +##sn +395 +mountain +##0mm +inparadise +6m +7x24 +ib +4800 +##jia +eeworld +creative +g5 +g3 +357 +parker +ecfa +village +からの +18000 +sylvia +サーヒス +hbl +##ques +##onsored +##x2 +##きます +##v4 +##tein +ie6 +383 +##stack +389 +ver +##ads +##baby +sound +bbe +##110 +##lone +##uid +ads +022 +gundam +351 +thinkpad +006 +scrum +match +##ave +mems +##470 +##oy +##なりました +##talk +glass +lamigo +span +##eme +job +##a5 +jay +wade +kde +498 +##lace +ocean +tvg +##covery +##r3 +##ners +##rea +junior +think +##aine +cover +##ision +##sia +↓↓ +##bow +msi +413 +458 +406 +##love +711 +801 +soft +z2 +##pl +456 +1840 +mobil +mind +##uy +427 +nginx +##oi +めた +##rr +6221 +##mple +##sson +##ーシてす +371 +##nts +91tv +comhd +crv3000 +##uard +1868 +397 +deep +lost +field +gallery +##bia +rate +spf +redis +traction +930 +icloud +011 +なら +fe +jose +372 +##tory +into +sohu +fx +899 +379 +kicstart2 +##hia +すく +##～3 +##sit +ra +２４ +##walk +##xure +500g +##pact +pacific +xa +natural +carlo +##250 +##walker +1850 +##can +cto +gigi +516 +##サー +pen +##hoo +ob +matlab +##ｂ +##yy +13913459 +##iti +mango +##bbs +sense +c5 +oxford +##ニア +walker +jennifer +##ola +course +##bre +701 +##pus +##rder +lucky +075 +##ぁ +ivy +なお +##nia +sotheby +side +##ugh +joy +##orage +##ush +##bat +##dt +364 +r9 +##2d +##gio +511 +country +wear +##lax +##～7 +##moon +393 +seven +study +411 +348 +lonzo +8k +##ェ +evolution +##イフ +##kk +gs +kd +##レス +arduino +344 +b12 +##lux +arpg +##rdon +cook +##x5 +dark +five +##als +##ida +とても +sign +362 +##ちの +something +20mm +##nda +387 +##posted +fresh +tf +1870 +422 +cam +##mine +##skip +##form +##ssion +education +394 +##tee +dyson +stage +##jie +want +##night +epson +pack +あります +##ppy +テリヘル +##█ +wd +##eh +##rence +left +##lvin +golden +mhz +discovery +##trix +##n2 +loft +##uch +##dra +##sse +speed +～1 +1mdb +sorry +welcome +##urn +wave +gaga +##lmer +teddy +##160 +トラックハック +せよ +611 +##f2016 +378 +rp +##sha +rar +##あなたに +##きた +840 +holiday +##ュー +373 +074 +##vg +##nos +##rail +gartner +gi +6p +##dium +kit +488 +b3 +eco +##ろう +20g +sean +##stone +autocad +nu +##np +f16 +write +029 +m5 +##ias +images +atp +##dk +fsm +504 +1350 +ve +52kb +##xxx +##のに +##cake +414 +unit +lim +ru +1v +##ification +published +angela +16g +analytics +ak +##ｑ +##nel +gmt +##icon +again +##₂ +##bby +ios11 +445 +かこさいます +waze +いてす +##ハ +9985 +##ust +##ティー +framework +##007 +iptv +delete +52sykb +cl +wwdc +027 +30cm +##fw +##ての +1389 +##xon +brandt +##ses +##dragon +tc +vetements +anne +monte +modern +official +##へて +##ere +##nne +##oud +もちろん +５０ +etnews +##a2 +##graphy +421 +863 +##ちゃん +444 +##rtex +##てお +l2 +##gma +mount +ccd +たと +archive +morning +tan +ddos +e7 +##ホ +day4 +##ウ +gis +453 +its +495 +factory +bruce +pg +##ito +ってくたさい +guest +cdma +##lling +536 +n3 +しかし +3～4 +mega +eyes +ro +１３ +women +dac +church +##jun +singapore +##facebook +6991 +starbucks +##tos +##stin +##shine +zen +##mu +tina +20℃ +1893 +##たけて +503 +465 +request +##gence +qt +##っ +1886 +347 +363 +q7 +##zzi +diary +##tore +409 +##ead +468 +cst +##osa +canada +agent +va +##jiang +##ちは +##ーク +##lam +sg +##nix +##sday +##よって +g6 +##master +bing +##zl +charlie +１６ +8mm +nb40 +##ーン +thai +##ルフ +ln284ct +##itz +##2f +bonnie +##food +##lent +originals +##stro +##lts +418 +∟∣ +##bscribe +children +ntd +yesstyle +##かも +hmv +##tment +d5 +2cm +arts +sms +##pn +##я +##いい +topios9 +539 +lifestyle +virtual +##ague +xz +##deo +muji +024 +unt +##nnis +##ᅩ +faq1 +1884 +396 +##ette +fly +64㎡ +はしめまして +441 +curry +##pop +のこ +release +##← +##◆◆ +##cast +073 +ありな +500ml +##ews +5c +##stle +ios7 +##ima +787 +dog +lenovo +##r4 +roger +013 +cbs +vornado +100m +417 +##desk +##クok +##ald +1867 +9595 +2900 +##van +oil +##ｘ +some +break +common +##jy +##lines +g7 +twice +419 +ella +nano +belle +にこ +##mes +##self +##note +jb +##ことかてきます +benz +##との +##ova +451 +save +##wing +##ますのて +kai +りは +##hua +##rect +rainer +##unge +448 +##0m +adsl +##かな +guestname +##uma +##kins +##zu +tokichoi +##price +county +##med +##mus +rmk +391 +address +vm +えて +openload +##group +##hin +##iginal +amg +urban +##oz +jobs +emi +##public +beautiful +##sch +album +##dden +##bell +jerry +works +hostel +miller +##drive +##rmin +##１０ +376 +boot +828 +##370 +##fx +##cm～ +1885 +##nome +##ctionary +##oman +##lish +##cr +##hm +433 +##how +432 +francis +xi +c919 +b5 +evernote +##uc +vga +##3000 +coupe +##urg +##cca +##uality +019 +6g +れる +multi +##また +##ett +em +hey +##ani +##tax +##rma +inside +than +740 +leonnhurt +##jin +ict +れた +bird +notes +200mm +くの +##dical +##lli +result +442 +iu +ee +438 +smap +gopro +##last +yin +pure +998 +32g +けた +5kg +##dan +##rame +mama +##oot +bean +marketing +##hur +2l +bella +sync +xuite +##ground +515 +discuz +##getrelax +##ince +##bay +##5s +cj +##イス +gmat +apt +##pass +jing +##rix +c4 +rich +##とても +niusnews +##ello +bag +770 +##eting +##mobile +１８ +culture +015 +##のてすか +377 +1020 +area +##ience +616 +details +gp +universal +silver +dit +はお +private +ddd +u11 +kanshu +##ified +fung +##nny +dx +##520 +tai +475 +023 +##fr +##lean +3s +##pin +429 +##rin +25000 +ly +rick +##bility +usb3 +banner +##baru +##gion +metal +dt +vdf +1871 +karl +qualcomm +bear +1010 +oldid +ian +jo +##tors +population +##ernel +1882 +mmorpg +##mv +##bike +603 +##© +ww +friend +##ager +exhibition +##del +##pods +fpx +structure +##free +##tings +kl +##rley +##copyright +##mma +california +3400 +orange +yoga +4l +canmake +honey +##anda +##コメント +595 +nikkie +##ルハイト +dhl +publishing +##mall +##gnet +20cm +513 +##クセス +##┅ +e88 +970 +##dog +fishbase +##! +##" +### +##$ +##% +##& +##' +##( +##) +##* +##+ +##, +##- +##. +##/ +##: +##; +##< +##= +##> +##? +##@ +##[ +##\ +##] +##^ +##_ +##{ +##| +##} +##~ +##£ +##¤ +##¥ +##§ +##« +##± +##³ +##µ +##· +##¹ +##º +##» +##¼ +##ß +##æ +##÷ +##ø +##đ +##ŋ +##ɔ +##ə +##ɡ +##ʰ +##ˇ +##ˈ +##ˊ +##ˋ +##ˍ +##ː +##˙ +##˚ +##ˢ +##α +##β +##γ +##δ +##ε +##η +##θ +##ι +##κ +##λ +##μ +##ν +##ο +##π +##ρ +##ς +##σ +##τ +##υ +##φ +##χ +##ψ +##б +##в +##г +##д +##е +##ж +##з +##к +##л +##м +##н +##о +##п +##р +##с +##т +##у +##ф +##х +##ц +##ч +##ш +##ы +##ь +##і +##ا +##ب +##ة +##ت +##د +##ر +##س +##ع +##ل +##م +##ن +##ه +##و +##ي +##۩ +##ก +##ง +##น +##ม +##ย +##ร +##อ +##า +##เ +##๑ +##་ +##ღ +##ᄀ +##ᄁ +##ᄂ +##ᄃ +##ᄅ +##ᄆ +##ᄇ +##ᄈ +##ᄉ +##ᄋ +##ᄌ +##ᄎ +##ᄏ +##ᄐ +##ᄑ +##ᄒ +##ᅢ +##ᅣ +##ᅥ +##ᅦ +##ᅧ +##ᅨ +##ᅪ +##ᅬ +##ᅭ +##ᅮ +##ᅯ +##ᅲ +##ᅳ +##ᅴ +##ᆷ +##ᆸ +##ᆺ +##ᆻ +##ᗜ +##ᵃ +##ᵉ +##ᵍ +##ᵏ +##ᵐ +##ᵒ +##ᵘ +##‖ +##„ +##† +##• +##‥ +##‧ +##
 +##‰ +##′ +##″ +##‹ +##› +##※ +##‿ +##⁄ +##ⁱ +##⁺ +##ⁿ +##₁ +##₃ +##₄ +##€ +##№ +##ⅰ +##ⅱ +##ⅲ +##ⅳ +##ⅴ +##↔ +##↗ +##↘ +##⇒ +##∀ +##− +##∕ +##∙ +##√ +##∞ +##∟ +##∠ +##∣ +##∩ +##∮ +##∶ +##∼ +##∽ +##≈ +##≒ +##≡ +##≤ +##≥ +##≦ +##≧ +##≪ +##≫ +##⊙ +##⋅ +##⋈ +##⋯ +##⌒ +##① +##② +##③ +##④ +##⑤ +##⑥ +##⑦ +##⑧ +##⑨ +##⑩ +##⑴ +##⑵ +##⑶ +##⑷ +##⑸ +##⒈ +##⒉ +##⒊ +##⒋ +##ⓒ +##ⓔ +##ⓘ +##━ +##┃ +##┆ +##┊ +##┌ +##└ +##├ +##┣ +##═ +##║ +##╚ +##╞ +##╠ +##╭ +##╮ +##╯ +##╰ +##╱ +##╳ +##▂ +##▃ +##▅ +##▇ +##▉ +##▋ +##▌ +##▍ +##▎ +##□ +##▪ +##▫ +##▬ +##△ +##▶ +##► +##▽ +##◇ +##◕ +##◠ +##◢ +##◤ +##☀ +##☕ +##☞ +##☺ +##☼ +##♀ +##♂ +##♠ +##♡ +##♣ +##♦ +##♫ +##♬ +##✈ +##✔ +##✕ +##✖ +##✦ +##✨ +##✪ +##✰ +##✿ +##❀ +##➜ +##➤ +##⦿ +##、 +##。 +##〃 +##々 +##〇 +##〈 +##〉 +##《 +##》 +##「 +##」 +##『 +##』 +##【 +##】 +##〓 +##〔 +##〕 +##〖 +##〗 +##〜 +##〝 +##〞 +##ぃ +##ぇ +##ぬ +##ふ +##ほ +##む +##ゃ +##ゅ +##ゆ +##ょ +##゜ +##ゝ +##ァ +##ゥ +##エ +##ォ +##ケ +##サ +##セ +##ソ +##ッ +##ニ +##ヌ +##ネ +##ノ +##ヘ +##モ +##ャ +##ヤ +##ュ +##ユ +##ョ +##ヨ +##ワ +##ヲ +##・ +##ヽ +##ㄅ +##ㄆ +##ㄇ +##ㄉ +##ㄋ +##ㄌ +##ㄍ +##ㄎ +##ㄏ +##ㄒ +##ㄚ +##ㄛ +##ㄞ +##ㄟ +##ㄢ +##ㄤ +##ㄥ +##ㄧ +##ㄨ +##ㆍ +##㈦ +##㊣ +##㗎 +##一 +##丁 +##七 +##万 +##丈 +##三 +##上 +##下 +##不 +##与 +##丐 +##丑 +##专 +##且 +##丕 +##世 +##丘 +##丙 +##业 +##丛 +##东 +##丝 +##丞 +##丟 +##両 +##丢 +##两 +##严 +##並 +##丧 +##丨 +##个 +##丫 +##中 +##丰 +##串 +##临 +##丶 +##丸 +##丹 +##为 +##主 +##丼 +##丽 +##举 +##丿 +##乂 +##乃 +##久 +##么 +##义 +##之 +##乌 +##乍 +##乎 +##乏 +##乐 +##乒 +##乓 +##乔 +##乖 +##乗 +##乘 +##乙 +##乜 +##九 +##乞 +##也 +##习 +##乡 +##书 +##乩 +##买 +##乱 +##乳 +##乾 +##亀 +##亂 +##了 +##予 +##争 +##事 +##二 +##于 +##亏 +##云 +##互 +##五 +##井 +##亘 +##亙 +##亚 +##些 +##亜 +##亞 +##亟 +##亡 +##亢 +##交 +##亥 +##亦 +##产 +##亨 +##亩 +##享 +##京 +##亭 +##亮 +##亲 +##亳 +##亵 +##人 +##亿 +##什 +##仁 +##仃 +##仄 +##仅 +##仆 +##仇 +##今 +##介 +##仍 +##从 +##仏 +##仑 +##仓 +##仔 +##仕 +##他 +##仗 +##付 +##仙 +##仝 +##仞 +##仟 +##代 +##令 +##以 +##仨 +##仪 +##们 +##仮 +##仰 +##仲 +##件 +##价 +##任 +##份 +##仿 +##企 +##伉 +##伊 +##伍 +##伎 +##伏 +##伐 +##休 +##伕 +##众 +##优 +##伙 +##会 +##伝 +##伞 +##伟 +##传 +##伢 +##伤 +##伦 +##伪 +##伫 +##伯 +##估 +##伴 +##伶 +##伸 +##伺 +##似 +##伽 +##佃 +##但 +##佇 +##佈 +##位 +##低 +##住 +##佐 +##佑 +##体 +##佔 +##何 +##佗 +##佘 +##余 +##佚 +##佛 +##作 +##佝 +##佞 +##佟 +##你 +##佢 +##佣 +##佤 +##佥 +##佩 +##佬 +##佯 +##佰 +##佳 +##併 +##佶 +##佻 +##佼 +##使 +##侃 +##侄 +##來 +##侈 +##例 +##侍 +##侏 +##侑 +##侖 +##侗 +##供 +##依 +##侠 +##価 +##侣 +##侥 +##侦 +##侧 +##侨 +##侬 +##侮 +##侯 +##侵 +##侶 +##侷 +##便 +##係 +##促 +##俄 +##俊 +##俎 +##俏 +##俐 +##俑 +##俗 +##俘 +##俚 +##保 +##俞 +##俟 +##俠 +##信 +##俨 +##俩 +##俪 +##俬 +##俭 +##修 +##俯 +##俱 +##俳 +##俸 +##俺 +##俾 +##倆 +##倉 +##個 +##倌 +##倍 +##倏 +##們 +##倒 +##倔 +##倖 +##倘 +##候 +##倚 +##倜 +##借 +##倡 +##値 +##倦 +##倩 +##倪 +##倫 +##倬 +##倭 +##倶 +##债 +##值 +##倾 +##偃 +##假 +##偈 +##偉 +##偌 +##偎 +##偏 +##偕 +##做 +##停 +##健 +##側 +##偵 +##偶 +##偷 +##偻 +##偽 +##偿 +##傀 +##傅 +##傍 +##傑 +##傘 +##備 +##傚 +##傢 +##傣 +##傥 +##储 +##傩 +##催 +##傭 +##傲 +##傳 +##債 +##傷 +##傻 +##傾 +##僅 +##働 +##像 +##僑 +##僕 +##僖 +##僚 +##僥 +##僧 +##僭 +##僮 +##僱 +##僵 +##價 +##僻 +##儀 +##儂 +##億 +##儆 +##儉 +##儋 +##儒 +##儕 +##儘 +##償 +##儡 +##優 +##儲 +##儷 +##儼 +##儿 +##兀 +##允 +##元 +##兄 +##充 +##兆 +##兇 +##先 +##光 +##克 +##兌 +##免 +##児 +##兑 +##兒 +##兔 +##兖 +##党 +##兜 +##兢 +##入 +##內 +##全 +##兩 +##八 +##公 +##六 +##兮 +##兰 +##共 +##兲 +##关 +##兴 +##兵 +##其 +##具 +##典 +##兹 +##养 +##兼 +##兽 +##冀 +##内 +##円 +##冇 +##冈 +##冉 +##冊 +##册 +##再 +##冏 +##冒 +##冕 +##冗 +##写 +##军 +##农 +##冠 +##冢 +##冤 +##冥 +##冨 +##冪 +##冬 +##冯 +##冰 +##冲 +##决 +##况 +##冶 +##冷 +##冻 +##冼 +##冽 +##冾 +##净 +##凄 +##准 +##凇 +##凈 +##凉 +##凋 +##凌 +##凍 +##减 +##凑 +##凛 +##凜 +##凝 +##几 +##凡 +##凤 +##処 +##凪 +##凭 +##凯 +##凰 +##凱 +##凳 +##凶 +##凸 +##凹 +##出 +##击 +##函 +##凿 +##刀 +##刁 +##刃 +##分 +##切 +##刈 +##刊 +##刍 +##刎 +##刑 +##划 +##列 +##刘 +##则 +##刚 +##创 +##初 +##删 +##判 +##別 +##刨 +##利 +##刪 +##别 +##刮 +##到 +##制 +##刷 +##券 +##刹 +##刺 +##刻 +##刽 +##剁 +##剂 +##剃 +##則 +##剉 +##削 +##剋 +##剌 +##前 +##剎 +##剐 +##剑 +##剔 +##剖 +##剛 +##剜 +##剝 +##剣 +##剤 +##剥 +##剧 +##剩 +##剪 +##副 +##割 +##創 +##剷 +##剽 +##剿 +##劃 +##劇 +##劈 +##劉 +##劊 +##劍 +##劏 +##劑 +##力 +##劝 +##办 +##功 +##加 +##务 +##劣 +##动 +##助 +##努 +##劫 +##劭 +##励 +##劲 +##劳 +##労 +##劵 +##効 +##劾 +##势 +##勁 +##勃 +##勇 +##勉 +##勋 +##勐 +##勒 +##動 +##勖 +##勘 +##務 +##勛 +##勝 +##勞 +##募 +##勢 +##勤 +##勧 +##勳 +##勵 +##勸 +##勺 +##勻 +##勾 +##勿 +##匀 +##包 +##匆 +##匈 +##匍 +##匐 +##匕 +##化 +##北 +##匙 +##匝 +##匠 +##匡 +##匣 +##匪 +##匮 +##匯 +##匱 +##匹 +##区 +##医 +##匾 +##匿 +##區 +##十 +##千 +##卅 +##升 +##午 +##卉 +##半 +##卍 +##华 +##协 +##卑 +##卒 +##卓 +##協 +##单 +##卖 +##南 +##単 +##博 +##卜 +##卞 +##卟 +##占 +##卡 +##卢 +##卤 +##卦 +##卧 +##卫 +##卮 +##卯 +##印 +##危 +##即 +##却 +##卵 +##卷 +##卸 +##卻 +##卿 +##厂 +##厄 +##厅 +##历 +##厉 +##压 +##厌 +##厕 +##厘 +##厚 +##厝 +##原 +##厢 +##厥 +##厦 +##厨 +##厩 +##厭 +##厮 +##厲 +##厳 +##去 +##县 +##叁 +##参 +##參 +##又 +##叉 +##及 +##友 +##双 +##反 +##収 +##发 +##叔 +##取 +##受 +##变 +##叙 +##叛 +##叟 +##叠 +##叡 +##叢 +##口 +##古 +##句 +##另 +##叨 +##叩 +##只 +##叫 +##召 +##叭 +##叮 +##可 +##台 +##叱 +##史 +##右 +##叵 +##叶 +##号 +##司 +##叹 +##叻 +##叼 +##叽 +##吁 +##吃 +##各 +##吆 +##合 +##吉 +##吊 +##吋 +##同 +##名 +##后 +##吏 +##吐 +##向 +##吒 +##吓 +##吕 +##吖 +##吗 +##君 +##吝 +##吞 +##吟 +##吠 +##吡 +##否 +##吧 +##吨 +##吩 +##含 +##听 +##吭 +##吮 +##启 +##吱 +##吳 +##吴 +##吵 +##吶 +##吸 +##吹 +##吻 +##吼 +##吽 +##吾 +##呀 +##呂 +##呃 +##呆 +##呈 +##告 +##呋 +##呎 +##呐 +##呓 +##呕 +##呗 +##员 +##呛 +##呜 +##呢 +##呤 +##呦 +##周 +##呱 +##呲 +##味 +##呵 +##呷 +##呸 +##呻 +##呼 +##命 +##咀 +##咁 +##咂 +##咄 +##咆 +##咋 +##和 +##咎 +##咏 +##咐 +##咒 +##咔 +##咕 +##咖 +##咗 +##咘 +##咙 +##咚 +##咛 +##咣 +##咤 +##咦 +##咧 +##咨 +##咩 +##咪 +##咫 +##咬 +##咭 +##咯 +##咱 +##咲 +##咳 +##咸 +##咻 +##咽 +##咿 +##哀 +##品 +##哂 +##哄 +##哆 +##哇 +##哈 +##哉 +##哋 +##哌 +##响 +##哎 +##哏 +##哐 +##哑 +##哒 +##哔 +##哗 +##哟 +##員 +##哥 +##哦 +##哧 +##哨 +##哩 +##哪 +##哭 +##哮 +##哲 +##哺 +##哼 +##哽 +##唁 +##唄 +##唆 +##唇 +##唉 +##唏 +##唐 +##唑 +##唔 +##唠 +##唤 +##唧 +##唬 +##售 +##唯 +##唰 +##唱 +##唳 +##唷 +##唸 +##唾 +##啃 +##啄 +##商 +##啉 +##啊 +##問 +##啓 +##啕 +##啖 +##啜 +##啞 +##啟 +##啡 +##啤 +##啥 +##啦 +##啧 +##啪 +##啫 +##啬 +##啮 +##啰 +##啱 +##啲 +##啵 +##啶 +##啷 +##啸 +##啻 +##啼 +##啾 +##喀 +##喂 +##喃 +##善 +##喆 +##喇 +##喉 +##喊 +##喋 +##喎 +##喏 +##喔 +##喘 +##喙 +##喚 +##喜 +##喝 +##喟 +##喧 +##喪 +##喫 +##喬 +##單 +##喰 +##喱 +##喲 +##喳 +##喵 +##営 +##喷 +##喹 +##喺 +##喻 +##喽 +##嗅 +##嗆 +##嗇 +##嗎 +##嗑 +##嗒 +##嗓 +##嗔 +##嗖 +##嗚 +##嗜 +##嗝 +##嗟 +##嗡 +##嗣 +##嗤 +##嗦 +##嗨 +##嗪 +##嗬 +##嗯 +##嗰 +##嗲 +##嗳 +##嗶 +##嗷 +##嗽 +##嘀 +##嘅 +##嘆 +##嘈 +##嘉 +##嘌 +##嘍 +##嘎 +##嘔 +##嘖 +##嘗 +##嘘 +##嘚 +##嘛 +##嘜 +##嘞 +##嘟 +##嘢 +##嘣 +##嘤 +##嘧 +##嘩 +##嘭 +##嘮 +##嘯 +##嘰 +##嘱 +##嘲 +##嘴 +##嘶 +##嘸 +##嘹 +##嘻 +##嘿 +##噁 +##噌 +##噎 +##噓 +##噔 +##噗 +##噙 +##噜 +##噠 +##噢 +##噤 +##器 +##噩 +##噪 +##噬 +##噱 +##噴 +##噶 +##噸 +##噹 +##噻 +##噼 +##嚀 +##嚇 +##嚎 +##嚏 +##嚐 +##嚓 +##嚕 +##嚟 +##嚣 +##嚥 +##嚨 +##嚮 +##嚴 +##嚷 +##嚼 +##囂 +##囉 +##囊 +##囍 +##囑 +##囔 +##囗 +##囚 +##四 +##囝 +##回 +##囟 +##因 +##囡 +##团 +##団 +##囤 +##囧 +##囪 +##囫 +##园 +##困 +##囱 +##囲 +##図 +##围 +##囹 +##固 +##国 +##图 +##囿 +##圃 +##圄 +##圆 +##圈 +##國 +##圍 +##圏 +##園 +##圓 +##圖 +##團 +##圜 +##土 +##圣 +##圧 +##在 +##圩 +##圭 +##地 +##圳 +##场 +##圻 +##圾 +##址 +##坂 +##均 +##坊 +##坍 +##坎 +##坏 +##坐 +##坑 +##块 +##坚 +##坛 +##坝 +##坞 +##坟 +##坠 +##坡 +##坤 +##坦 +##坨 +##坪 +##坯 +##坳 +##坵 +##坷 +##垂 +##垃 +##垄 +##型 +##垒 +##垚 +##垛 +##垠 +##垢 +##垣 +##垦 +##垩 +##垫 +##垭 +##垮 +##垵 +##埂 +##埃 +##埋 +##城 +##埔 +##埕 +##埗 +##域 +##埠 +##埤 +##埵 +##執 +##埸 +##培 +##基 +##埼 +##堀 +##堂 +##堃 +##堅 +##堆 +##堇 +##堑 +##堕 +##堙 +##堡 +##堤 +##堪 +##堯 +##堰 +##報 +##場 +##堵 +##堺 +##堿 +##塊 +##塌 +##塑 +##塔 +##塗 +##塘 +##塚 +##塞 +##塢 +##塩 +##填 +##塬 +##塭 +##塵 +##塾 +##墀 +##境 +##墅 +##墉 +##墊 +##墒 +##墓 +##増 +##墘 +##墙 +##墜 +##增 +##墟 +##墨 +##墩 +##墮 +##墳 +##墻 +##墾 +##壁 +##壅 +##壆 +##壇 +##壊 +##壑 +##壓 +##壕 +##壘 +##壞 +##壟 +##壢 +##壤 +##壩 +##士 +##壬 +##壮 +##壯 +##声 +##売 +##壳 +##壶 +##壹 +##壺 +##壽 +##处 +##备 +##変 +##复 +##夏 +##夔 +##夕 +##外 +##夙 +##多 +##夜 +##够 +##夠 +##夢 +##夥 +##大 +##天 +##太 +##夫 +##夭 +##央 +##夯 +##失 +##头 +##夷 +##夸 +##夹 +##夺 +##夾 +##奂 +##奄 +##奇 +##奈 +##奉 +##奋 +##奎 +##奏 +##奐 +##契 +##奔 +##奕 +##奖 +##套 +##奘 +##奚 +##奠 +##奢 +##奥 +##奧 +##奪 +##奬 +##奮 +##女 +##奴 +##奶 +##奸 +##她 +##好 +##如 +##妃 +##妄 +##妆 +##妇 +##妈 +##妊 +##妍 +##妒 +##妓 +##妖 +##妘 +##妙 +##妝 +##妞 +##妣 +##妤 +##妥 +##妨 +##妩 +##妪 +##妮 +##妲 +##妳 +##妹 +##妻 +##妾 +##姆 +##姉 +##姊 +##始 +##姍 +##姐 +##姑 +##姒 +##姓 +##委 +##姗 +##姚 +##姜 +##姝 +##姣 +##姥 +##姦 +##姨 +##姪 +##姫 +##姬 +##姹 +##姻 +##姿 +##威 +##娃 +##娄 +##娅 +##娆 +##娇 +##娉 +##娑 +##娓 +##娘 +##娛 +##娜 +##娟 +##娠 +##娣 +##娥 +##娩 +##娱 +##娲 +##娴 +##娶 +##娼 +##婀 +##婁 +##婆 +##婉 +##婊 +##婕 +##婚 +##婢 +##婦 +##婧 +##婪 +##婭 +##婴 +##婵 +##婶 +##婷 +##婺 +##婿 +##媒 +##媚 +##媛 +##媞 +##媧 +##媲 +##媳 +##媽 +##媾 +##嫁 +##嫂 +##嫉 +##嫌 +##嫑 +##嫔 +##嫖 +##嫘 +##嫚 +##嫡 +##嫣 +##嫦 +##嫩 +##嫲 +##嫵 +##嫻 +##嬅 +##嬉 +##嬌 +##嬗 +##嬛 +##嬢 +##嬤 +##嬪 +##嬰 +##嬴 +##嬷 +##嬸 +##嬿 +##孀 +##孃 +##子 +##孑 +##孔 +##孕 +##孖 +##字 +##存 +##孙 +##孚 +##孛 +##孜 +##孝 +##孟 +##孢 +##季 +##孤 +##学 +##孩 +##孪 +##孫 +##孬 +##孰 +##孱 +##孳 +##孵 +##學 +##孺 +##孽 +##孿 +##宁 +##它 +##宅 +##宇 +##守 +##安 +##宋 +##完 +##宏 +##宓 +##宕 +##宗 +##官 +##宙 +##定 +##宛 +##宜 +##宝 +##实 +##実 +##宠 +##审 +##客 +##宣 +##室 +##宥 +##宦 +##宪 +##宫 +##宮 +##宰 +##害 +##宴 +##宵 +##家 +##宸 +##容 +##宽 +##宾 +##宿 +##寂 +##寄 +##寅 +##密 +##寇 +##富 +##寐 +##寒 +##寓 +##寛 +##寝 +##寞 +##察 +##寡 +##寢 +##寥 +##實 +##寧 +##寨 +##審 +##寫 +##寬 +##寮 +##寰 +##寵 +##寶 +##寸 +##对 +##寺 +##寻 +##导 +##対 +##寿 +##封 +##専 +##射 +##将 +##將 +##專 +##尉 +##尊 +##尋 +##對 +##導 +##小 +##少 +##尔 +##尕 +##尖 +##尘 +##尚 +##尝 +##尤 +##尧 +##尬 +##就 +##尴 +##尷 +##尸 +##尹 +##尺 +##尻 +##尼 +##尽 +##尾 +##尿 +##局 +##屁 +##层 +##屄 +##居 +##屆 +##屈 +##屉 +##届 +##屋 +##屌 +##屍 +##屎 +##屏 +##屐 +##屑 +##展 +##屜 +##属 +##屠 +##屡 +##屢 +##層 +##履 +##屬 +##屯 +##山 +##屹 +##屿 +##岀 +##岁 +##岂 +##岌 +##岐 +##岑 +##岔 +##岖 +##岗 +##岘 +##岙 +##岚 +##岛 +##岡 +##岩 +##岫 +##岬 +##岭 +##岱 +##岳 +##岷 +##岸 +##峇 +##峋 +##峒 +##峙 +##峡 +##峤 +##峥 +##峦 +##峨 +##峪 +##峭 +##峯 +##峰 +##峴 +##島 +##峻 +##峽 +##崁 +##崂 +##崆 +##崇 +##崎 +##崑 +##崔 +##崖 +##崗 +##崙 +##崛 +##崧 +##崩 +##崭 +##崴 +##崽 +##嵇 +##嵊 +##嵋 +##嵌 +##嵐 +##嵘 +##嵩 +##嵬 +##嵯 +##嶂 +##嶄 +##嶇 +##嶋 +##嶙 +##嶺 +##嶼 +##嶽 +##巅 +##巍 +##巒 +##巔 +##巖 +##川 +##州 +##巡 +##巢 +##工 +##左 +##巧 +##巨 +##巩 +##巫 +##差 +##己 +##已 +##巳 +##巴 +##巷 +##巻 +##巽 +##巾 +##巿 +##币 +##市 +##布 +##帅 +##帆 +##师 +##希 +##帐 +##帑 +##帕 +##帖 +##帘 +##帚 +##帛 +##帜 +##帝 +##帥 +##带 +##帧 +##師 +##席 +##帮 +##帯 +##帰 +##帳 +##帶 +##帷 +##常 +##帼 +##帽 +##幀 +##幂 +##幄 +##幅 +##幌 +##幔 +##幕 +##幟 +##幡 +##幢 +##幣 +##幫 +##干 +##平 +##年 +##并 +##幸 +##幹 +##幺 +##幻 +##幼 +##幽 +##幾 +##广 +##庁 +##広 +##庄 +##庆 +##庇 +##床 +##序 +##庐 +##库 +##应 +##底 +##庖 +##店 +##庙 +##庚 +##府 +##庞 +##废 +##庠 +##度 +##座 +##庫 +##庭 +##庵 +##庶 +##康 +##庸 +##庹 +##庾 +##廁 +##廂 +##廃 +##廈 +##廉 +##廊 +##廓 +##廖 +##廚 +##廝 +##廟 +##廠 +##廢 +##廣 +##廬 +##廳 +##延 +##廷 +##建 +##廿 +##开 +##弁 +##异 +##弃 +##弄 +##弈 +##弊 +##弋 +##式 +##弑 +##弒 +##弓 +##弔 +##引 +##弗 +##弘 +##弛 +##弟 +##张 +##弥 +##弦 +##弧 +##弩 +##弭 +##弯 +##弱 +##張 +##強 +##弹 +##强 +##弼 +##弾 +##彅 +##彆 +##彈 +##彌 +##彎 +##归 +##当 +##录 +##彗 +##彙 +##彝 +##形 +##彤 +##彥 +##彦 +##彧 +##彩 +##彪 +##彫 +##彬 +##彭 +##彰 +##影 +##彷 +##役 +##彻 +##彼 +##彿 +##往 +##征 +##径 +##待 +##徇 +##很 +##徉 +##徊 +##律 +##後 +##徐 +##徑 +##徒 +##従 +##徕 +##得 +##徘 +##徙 +##徜 +##從 +##徠 +##御 +##徨 +##復 +##循 +##徬 +##微 +##徳 +##徴 +##徵 +##德 +##徹 +##徼 +##徽 +##心 +##必 +##忆 +##忌 +##忍 +##忏 +##忐 +##忑 +##忒 +##忖 +##志 +##忘 +##忙 +##応 +##忠 +##忡 +##忤 +##忧 +##忪 +##快 +##忱 +##念 +##忻 +##忽 +##忿 +##怀 +##态 +##怂 +##怅 +##怆 +##怎 +##怏 +##怒 +##怔 +##怕 +##怖 +##怙 +##怜 +##思 +##怠 +##怡 +##急 +##怦 +##性 +##怨 +##怪 +##怯 +##怵 +##总 +##怼 +##恁 +##恃 +##恆 +##恋 +##恍 +##恐 +##恒 +##恕 +##恙 +##恚 +##恢 +##恣 +##恤 +##恥 +##恨 +##恩 +##恪 +##恫 +##恬 +##恭 +##息 +##恰 +##恳 +##恵 +##恶 +##恸 +##恺 +##恻 +##恼 +##恿 +##悄 +##悅 +##悉 +##悌 +##悍 +##悔 +##悖 +##悚 +##悟 +##悠 +##患 +##悦 +##您 +##悩 +##悪 +##悬 +##悯 +##悱 +##悲 +##悴 +##悵 +##悶 +##悸 +##悻 +##悼 +##悽 +##情 +##惆 +##惇 +##惊 +##惋 +##惑 +##惕 +##惘 +##惚 +##惜 +##惟 +##惠 +##惡 +##惦 +##惧 +##惨 +##惩 +##惫 +##惬 +##惭 +##惮 +##惯 +##惰 +##惱 +##想 +##惴 +##惶 +##惹 +##惺 +##愁 +##愆 +##愈 +##愉 +##愍 +##意 +##愕 +##愚 +##愛 +##愜 +##感 +##愣 +##愤 +##愧 +##愫 +##愷 +##愿 +##慄 +##慈 +##態 +##慌 +##慎 +##慑 +##慕 +##慘 +##慚 +##慟 +##慢 +##慣 +##慧 +##慨 +##慫 +##慮 +##慰 +##慳 +##慵 +##慶 +##慷 +##慾 +##憂 +##憊 +##憋 +##憎 +##憐 +##憑 +##憔 +##憚 +##憤 +##憧 +##憨 +##憩 +##憫 +##憬 +##憲 +##憶 +##憾 +##懂 +##懇 +##懈 +##應 +##懊 +##懋 +##懑 +##懒 +##懦 +##懲 +##懵 +##懶 +##懷 +##懸 +##懺 +##懼 +##懾 +##懿 +##戀 +##戈 +##戊 +##戌 +##戍 +##戎 +##戏 +##成 +##我 +##戒 +##戕 +##或 +##战 +##戚 +##戛 +##戟 +##戡 +##戦 +##截 +##戬 +##戮 +##戰 +##戲 +##戳 +##戴 +##戶 +##户 +##戸 +##戻 +##戾 +##房 +##所 +##扁 +##扇 +##扈 +##扉 +##手 +##才 +##扎 +##扑 +##扒 +##打 +##扔 +##払 +##托 +##扛 +##扣 +##扦 +##执 +##扩 +##扪 +##扫 +##扬 +##扭 +##扮 +##扯 +##扰 +##扱 +##扳 +##扶 +##批 +##扼 +##找 +##承 +##技 +##抄 +##抉 +##把 +##抑 +##抒 +##抓 +##投 +##抖 +##抗 +##折 +##抚 +##抛 +##抜 +##択 +##抟 +##抠 +##抡 +##抢 +##护 +##报 +##抨 +##披 +##抬 +##抱 +##抵 +##抹 +##押 +##抽 +##抿 +##拂 +##拄 +##担 +##拆 +##拇 +##拈 +##拉 +##拋 +##拌 +##拍 +##拎 +##拐 +##拒 +##拓 +##拔 +##拖 +##拗 +##拘 +##拙 +##拚 +##招 +##拜 +##拟 +##拡 +##拢 +##拣 +##拥 +##拦 +##拧 +##拨 +##择 +##括 +##拭 +##拮 +##拯 +##拱 +##拳 +##拴 +##拷 +##拼 +##拽 +##拾 +##拿 +##持 +##挂 +##指 +##挈 +##按 +##挎 +##挑 +##挖 +##挙 +##挚 +##挛 +##挝 +##挞 +##挟 +##挠 +##挡 +##挣 +##挤 +##挥 +##挨 +##挪 +##挫 +##振 +##挲 +##挹 +##挺 +##挽 +##挾 +##捂 +##捅 +##捆 +##捉 +##捋 +##捌 +##捍 +##捎 +##捏 +##捐 +##捕 +##捞 +##损 +##捡 +##换 +##捣 +##捧 +##捨 +##捩 +##据 +##捱 +##捲 +##捶 +##捷 +##捺 +##捻 +##掀 +##掂 +##掃 +##掇 +##授 +##掉 +##掌 +##掏 +##掐 +##排 +##掖 +##掘 +##掙 +##掛 +##掠 +##採 +##探 +##掣 +##接 +##控 +##推 +##掩 +##措 +##掬 +##掰 +##掲 +##掳 +##掴 +##掷 +##掸 +##掺 +##揀 +##揃 +##揄 +##揆 +##揉 +##揍 +##描 +##提 +##插 +##揖 +##揚 +##換 +##握 +##揣 +##揩 +##揪 +##揭 +##揮 +##援 +##揶 +##揸 +##揹 +##揽 +##搀 +##搁 +##搂 +##搅 +##損 +##搏 +##搐 +##搓 +##搔 +##搖 +##搗 +##搜 +##搞 +##搡 +##搪 +##搬 +##搭 +##搵 +##搶 +##携 +##搽 +##摀 +##摁 +##摄 +##摆 +##摇 +##摈 +##摊 +##摒 +##摔 +##摘 +##摞 +##摟 +##摧 +##摩 +##摯 +##摳 +##摸 +##摹 +##摺 +##摻 +##撂 +##撃 +##撅 +##撇 +##撈 +##撐 +##撑 +##撒 +##撓 +##撕 +##撚 +##撞 +##撤 +##撥 +##撩 +##撫 +##撬 +##播 +##撮 +##撰 +##撲 +##撵 +##撷 +##撸 +##撻 +##撼 +##撿 +##擀 +##擁 +##擂 +##擄 +##擅 +##擇 +##擊 +##擋 +##操 +##擎 +##擒 +##擔 +##擘 +##據 +##擞 +##擠 +##擡 +##擢 +##擦 +##擬 +##擰 +##擱 +##擲 +##擴 +##擷 +##擺 +##擼 +##擾 +##攀 +##攏 +##攒 +##攔 +##攘 +##攙 +##攜 +##攝 +##攞 +##攢 +##攣 +##攤 +##攥 +##攪 +##攫 +##攬 +##支 +##收 +##攸 +##改 +##攻 +##放 +##政 +##故 +##效 +##敌 +##敍 +##敎 +##敏 +##救 +##敕 +##敖 +##敗 +##敘 +##教 +##敛 +##敝 +##敞 +##敢 +##散 +##敦 +##敬 +##数 +##敲 +##整 +##敵 +##敷 +##數 +##斂 +##斃 +##文 +##斋 +##斌 +##斎 +##斐 +##斑 +##斓 +##斗 +##料 +##斛 +##斜 +##斟 +##斡 +##斤 +##斥 +##斧 +##斩 +##斫 +##斬 +##断 +##斯 +##新 +##斷 +##方 +##於 +##施 +##旁 +##旃 +##旅 +##旋 +##旌 +##旎 +##族 +##旖 +##旗 +##无 +##既 +##日 +##旦 +##旧 +##旨 +##早 +##旬 +##旭 +##旮 +##旱 +##时 +##旷 +##旺 +##旻 +##昀 +##昂 +##昆 +##昇 +##昉 +##昊 +##昌 +##明 +##昏 +##易 +##昔 +##昕 +##昙 +##星 +##映 +##春 +##昧 +##昨 +##昭 +##是 +##昱 +##昴 +##昵 +##昶 +##昼 +##显 +##晁 +##時 +##晃 +##晉 +##晋 +##晌 +##晏 +##晒 +##晓 +##晔 +##晕 +##晖 +##晗 +##晚 +##晝 +##晞 +##晟 +##晤 +##晦 +##晨 +##晩 +##普 +##景 +##晰 +##晴 +##晶 +##晷 +##智 +##晾 +##暂 +##暄 +##暇 +##暈 +##暉 +##暌 +##暐 +##暑 +##暖 +##暗 +##暝 +##暢 +##暧 +##暨 +##暫 +##暮 +##暱 +##暴 +##暸 +##暹 +##曄 +##曆 +##曇 +##曉 +##曖 +##曙 +##曜 +##曝 +##曠 +##曦 +##曬 +##曰 +##曲 +##曳 +##更 +##書 +##曹 +##曼 +##曾 +##替 +##最 +##會 +##月 +##有 +##朋 +##服 +##朐 +##朔 +##朕 +##朗 +##望 +##朝 +##期 +##朦 +##朧 +##木 +##未 +##末 +##本 +##札 +##朮 +##术 +##朱 +##朴 +##朵 +##机 +##朽 +##杀 +##杂 +##权 +##杆 +##杈 +##杉 +##李 +##杏 +##材 +##村 +##杓 +##杖 +##杜 +##杞 +##束 +##杠 +##条 +##来 +##杨 +##杭 +##杯 +##杰 +##東 +##杳 +##杵 +##杷 +##杼 +##松 +##板 +##极 +##构 +##枇 +##枉 +##枋 +##析 +##枕 +##林 +##枚 +##果 +##枝 +##枢 +##枣 +##枪 +##枫 +##枭 +##枯 +##枰 +##枱 +##枳 +##架 +##枷 +##枸 +##柄 +##柏 +##某 +##柑 +##柒 +##染 +##柔 +##柘 +##柚 +##柜 +##柞 +##柠 +##柢 +##查 +##柩 +##柬 +##柯 +##柱 +##柳 +##柴 +##柵 +##査 +##柿 +##栀 +##栃 +##栄 +##栅 +##标 +##栈 +##栉 +##栋 +##栎 +##栏 +##树 +##栓 +##栖 +##栗 +##校 +##栩 +##株 +##样 +##核 +##根 +##格 +##栽 +##栾 +##桀 +##桁 +##桂 +##桃 +##桅 +##框 +##案 +##桉 +##桌 +##桎 +##桐 +##桑 +##桓 +##桔 +##桜 +##桠 +##桡 +##桢 +##档 +##桥 +##桦 +##桧 +##桨 +##桩 +##桶 +##桿 +##梁 +##梅 +##梆 +##梏 +##梓 +##梗 +##條 +##梟 +##梢 +##梦 +##梧 +##梨 +##梭 +##梯 +##械 +##梳 +##梵 +##梶 +##检 +##棂 +##棄 +##棉 +##棋 +##棍 +##棒 +##棕 +##棗 +##棘 +##棚 +##棟 +##棠 +##棣 +##棧 +##森 +##棱 +##棲 +##棵 +##棹 +##棺 +##椁 +##椅 +##椋 +##植 +##椎 +##椒 +##検 +##椪 +##椭 +##椰 +##椹 +##椽 +##椿 +##楂 +##楊 +##楓 +##楔 +##楚 +##楝 +##楞 +##楠 +##楣 +##楨 +##楫 +##業 +##楮 +##極 +##楷 +##楸 +##楹 +##楼 +##楽 +##概 +##榄 +##榆 +##榈 +##榉 +##榔 +##榕 +##榖 +##榛 +##榜 +##榨 +##榫 +##榭 +##榮 +##榱 +##榴 +##榷 +##榻 +##槁 +##槃 +##構 +##槌 +##槍 +##槎 +##槐 +##槓 +##様 +##槛 +##槟 +##槤 +##槭 +##槲 +##槳 +##槻 +##槽 +##槿 +##樁 +##樂 +##樊 +##樑 +##樓 +##標 +##樞 +##樟 +##模 +##樣 +##権 +##横 +##樫 +##樯 +##樱 +##樵 +##樸 +##樹 +##樺 +##樽 +##樾 +##橄 +##橇 +##橋 +##橐 +##橘 +##橙 +##機 +##橡 +##橢 +##橫 +##橱 +##橹 +##橼 +##檀 +##檄 +##檎 +##檐 +##檔 +##檗 +##檜 +##檢 +##檬 +##檯 +##檳 +##檸 +##檻 +##櫃 +##櫚 +##櫛 +##櫥 +##櫸 +##櫻 +##欄 +##權 +##欒 +##欖 +##欠 +##次 +##欢 +##欣 +##欧 +##欲 +##欸 +##欺 +##欽 +##款 +##歆 +##歇 +##歉 +##歌 +##歎 +##歐 +##歓 +##歙 +##歛 +##歡 +##止 +##正 +##此 +##步 +##武 +##歧 +##歩 +##歪 +##歯 +##歲 +##歳 +##歴 +##歷 +##歸 +##歹 +##死 +##歼 +##殁 +##殃 +##殆 +##殇 +##殉 +##殊 +##残 +##殒 +##殓 +##殖 +##殘 +##殞 +##殡 +##殤 +##殭 +##殯 +##殲 +##殴 +##段 +##殷 +##殺 +##殼 +##殿 +##毀 +##毁 +##毂 +##毅 +##毆 +##毋 +##母 +##毎 +##每 +##毒 +##毓 +##比 +##毕 +##毗 +##毘 +##毙 +##毛 +##毡 +##毫 +##毯 +##毽 +##氈 +##氏 +##氐 +##民 +##氓 +##气 +##氖 +##気 +##氙 +##氛 +##氟 +##氡 +##氢 +##氣 +##氤 +##氦 +##氧 +##氨 +##氪 +##氫 +##氮 +##氯 +##氰 +##氲 +##水 +##氷 +##永 +##氹 +##氾 +##汀 +##汁 +##求 +##汆 +##汇 +##汉 +##汎 +##汐 +##汕 +##汗 +##汙 +##汛 +##汝 +##汞 +##江 +##池 +##污 +##汤 +##汨 +##汩 +##汪 +##汰 +##汲 +##汴 +##汶 +##汹 +##決 +##汽 +##汾 +##沁 +##沂 +##沃 +##沅 +##沈 +##沉 +##沌 +##沏 +##沐 +##沒 +##沓 +##沖 +##沙 +##沛 +##沟 +##没 +##沢 +##沣 +##沥 +##沦 +##沧 +##沪 +##沫 +##沭 +##沮 +##沱 +##河 +##沸 +##油 +##治 +##沼 +##沽 +##沾 +##沿 +##況 +##泄 +##泉 +##泊 +##泌 +##泓 +##法 +##泗 +##泛 +##泞 +##泠 +##泡 +##波 +##泣 +##泥 +##注 +##泪 +##泫 +##泮 +##泯 +##泰 +##泱 +##泳 +##泵 +##泷 +##泸 +##泻 +##泼 +##泽 +##泾 +##洁 +##洄 +##洋 +##洒 +##洗 +##洙 +##洛 +##洞 +##津 +##洩 +##洪 +##洮 +##洱 +##洲 +##洵 +##洶 +##洸 +##洹 +##活 +##洼 +##洽 +##派 +##流 +##浃 +##浄 +##浅 +##浆 +##浇 +##浊 +##测 +##济 +##浏 +##浑 +##浒 +##浓 +##浔 +##浙 +##浚 +##浜 +##浣 +##浦 +##浩 +##浪 +##浬 +##浮 +##浯 +##浴 +##海 +##浸 +##涂 +##涅 +##涇 +##消 +##涉 +##涌 +##涎 +##涓 +##涔 +##涕 +##涙 +##涛 +##涝 +##涞 +##涟 +##涠 +##涡 +##涣 +##涤 +##润 +##涧 +##涨 +##涩 +##涪 +##涮 +##涯 +##液 +##涵 +##涸 +##涼 +##涿 +##淀 +##淄 +##淅 +##淆 +##淇 +##淋 +##淌 +##淑 +##淒 +##淖 +##淘 +##淙 +##淚 +##淞 +##淡 +##淤 +##淦 +##淨 +##淩 +##淪 +##淫 +##淬 +##淮 +##深 +##淳 +##淵 +##混 +##淹 +##淺 +##添 +##淼 +##清 +##済 +##渉 +##渊 +##渋 +##渍 +##渎 +##渐 +##渔 +##渗 +##渙 +##渚 +##減 +##渝 +##渠 +##渡 +##渣 +##渤 +##渥 +##渦 +##温 +##測 +##渭 +##港 +##渲 +##渴 +##游 +##渺 +##渾 +##湃 +##湄 +##湊 +##湍 +##湖 +##湘 +##湛 +##湟 +##湧 +##湫 +##湮 +##湯 +##湳 +##湾 +##湿 +##満 +##溃 +##溅 +##溉 +##溏 +##源 +##準 +##溜 +##溝 +##溟 +##溢 +##溥 +##溧 +##溪 +##溫 +##溯 +##溱 +##溴 +##溶 +##溺 +##溼 +##滁 +##滂 +##滄 +##滅 +##滇 +##滋 +##滌 +##滑 +##滓 +##滔 +##滕 +##滙 +##滚 +##滝 +##滞 +##滟 +##满 +##滢 +##滤 +##滥 +##滦 +##滨 +##滩 +##滬 +##滯 +##滲 +##滴 +##滷 +##滸 +##滾 +##滿 +##漁 +##漂 +##漆 +##漉 +##漏 +##漓 +##演 +##漕 +##漠 +##漢 +##漣 +##漩 +##漪 +##漫 +##漬 +##漯 +##漱 +##漲 +##漳 +##漸 +##漾 +##漿 +##潆 +##潇 +##潋 +##潍 +##潑 +##潔 +##潘 +##潛 +##潜 +##潞 +##潟 +##潢 +##潤 +##潦 +##潧 +##潭 +##潮 +##潰 +##潴 +##潸 +##潺 +##潼 +##澀 +##澄 +##澆 +##澈 +##澍 +##澎 +##澗 +##澜 +##澡 +##澤 +##澧 +##澱 +##澳 +##澹 +##激 +##濁 +##濂 +##濃 +##濑 +##濒 +##濕 +##濘 +##濛 +##濟 +##濠 +##濡 +##濤 +##濫 +##濬 +##濮 +##濯 +##濱 +##濺 +##濾 +##瀅 +##瀆 +##瀉 +##瀋 +##瀏 +##瀑 +##瀕 +##瀘 +##瀚 +##瀛 +##瀝 +##瀞 +##瀟 +##瀧 +##瀨 +##瀬 +##瀰 +##瀾 +##灌 +##灏 +##灑 +##灘 +##灝 +##灞 +##灣 +##火 +##灬 +##灭 +##灯 +##灰 +##灵 +##灶 +##灸 +##灼 +##災 +##灾 +##灿 +##炀 +##炁 +##炅 +##炉 +##炊 +##炎 +##炒 +##炔 +##炕 +##炖 +##炙 +##炜 +##炫 +##炬 +##炭 +##炮 +##炯 +##炳 +##炷 +##炸 +##点 +##為 +##炼 +##炽 +##烁 +##烂 +##烃 +##烈 +##烊 +##烏 +##烘 +##烙 +##烛 +##烟 +##烤 +##烦 +##烧 +##烨 +##烩 +##烫 +##烬 +##热 +##烯 +##烷 +##烹 +##烽 +##焉 +##焊 +##焕 +##焖 +##焗 +##焘 +##焙 +##焚 +##焜 +##無 +##焦 +##焯 +##焰 +##焱 +##然 +##焼 +##煅 +##煉 +##煊 +##煌 +##煎 +##煒 +##煖 +##煙 +##煜 +##煞 +##煤 +##煥 +##煦 +##照 +##煨 +##煩 +##煮 +##煲 +##煸 +##煽 +##熄 +##熊 +##熏 +##熒 +##熔 +##熙 +##熟 +##熠 +##熨 +##熬 +##熱 +##熵 +##熹 +##熾 +##燁 +##燃 +##燄 +##燈 +##燉 +##燊 +##燎 +##燒 +##燔 +##燕 +##燙 +##燜 +##營 +##燥 +##燦 +##燧 +##燭 +##燮 +##燴 +##燻 +##燼 +##燿 +##爆 +##爍 +##爐 +##爛 +##爪 +##爬 +##爭 +##爰 +##爱 +##爲 +##爵 +##父 +##爷 +##爸 +##爹 +##爺 +##爻 +##爽 +##爾 +##牆 +##片 +##版 +##牌 +##牍 +##牒 +##牙 +##牛 +##牝 +##牟 +##牠 +##牡 +##牢 +##牦 +##牧 +##物 +##牯 +##牲 +##牴 +##牵 +##特 +##牺 +##牽 +##犀 +##犁 +##犄 +##犊 +##犍 +##犒 +##犢 +##犧 +##犬 +##犯 +##状 +##犷 +##犸 +##犹 +##狀 +##狂 +##狄 +##狈 +##狎 +##狐 +##狒 +##狗 +##狙 +##狞 +##狠 +##狡 +##狩 +##独 +##狭 +##狮 +##狰 +##狱 +##狸 +##狹 +##狼 +##狽 +##猎 +##猕 +##猖 +##猗 +##猙 +##猛 +##猜 +##猝 +##猥 +##猩 +##猪 +##猫 +##猬 +##献 +##猴 +##猶 +##猷 +##猾 +##猿 +##獄 +##獅 +##獎 +##獐 +##獒 +##獗 +##獠 +##獣 +##獨 +##獭 +##獰 +##獲 +##獵 +##獷 +##獸 +##獺 +##獻 +##獼 +##獾 +##玄 +##率 +##玉 +##王 +##玑 +##玖 +##玛 +##玟 +##玠 +##玥 +##玩 +##玫 +##玮 +##环 +##现 +##玲 +##玳 +##玷 +##玺 +##玻 +##珀 +##珂 +##珅 +##珈 +##珉 +##珊 +##珍 +##珏 +##珐 +##珑 +##珙 +##珞 +##珠 +##珣 +##珥 +##珩 +##珪 +##班 +##珮 +##珲 +##珺 +##現 +##球 +##琅 +##理 +##琇 +##琉 +##琊 +##琍 +##琏 +##琐 +##琛 +##琢 +##琥 +##琦 +##琨 +##琪 +##琬 +##琮 +##琰 +##琲 +##琳 +##琴 +##琵 +##琶 +##琺 +##琼 +##瑀 +##瑁 +##瑄 +##瑋 +##瑕 +##瑗 +##瑙 +##瑚 +##瑛 +##瑜 +##瑞 +##瑟 +##瑠 +##瑣 +##瑤 +##瑩 +##瑪 +##瑯 +##瑰 +##瑶 +##瑾 +##璀 +##璁 +##璃 +##璇 +##璉 +##璋 +##璎 +##璐 +##璜 +##璞 +##璟 +##璧 +##璨 +##環 +##璽 +##璿 +##瓊 +##瓏 +##瓒 +##瓜 +##瓢 +##瓣 +##瓤 +##瓦 +##瓮 +##瓯 +##瓴 +##瓶 +##瓷 +##甄 +##甌 +##甕 +##甘 +##甙 +##甚 +##甜 +##生 +##產 +##産 +##甥 +##甦 +##用 +##甩 +##甫 +##甬 +##甭 +##甯 +##田 +##由 +##甲 +##申 +##电 +##男 +##甸 +##町 +##画 +##甾 +##畀 +##畅 +##界 +##畏 +##畑 +##畔 +##留 +##畜 +##畝 +##畢 +##略 +##畦 +##番 +##畫 +##異 +##畲 +##畳 +##畴 +##當 +##畸 +##畹 +##畿 +##疆 +##疇 +##疊 +##疏 +##疑 +##疔 +##疖 +##疗 +##疙 +##疚 +##疝 +##疟 +##疡 +##疣 +##疤 +##疥 +##疫 +##疮 +##疯 +##疱 +##疲 +##疳 +##疵 +##疸 +##疹 +##疼 +##疽 +##疾 +##痂 +##病 +##症 +##痈 +##痉 +##痊 +##痍 +##痒 +##痔 +##痕 +##痘 +##痙 +##痛 +##痞 +##痠 +##痢 +##痣 +##痤 +##痧 +##痨 +##痪 +##痫 +##痰 +##痱 +##痴 +##痹 +##痺 +##痼 +##痿 +##瘀 +##瘁 +##瘋 +##瘍 +##瘓 +##瘘 +##瘙 +##瘟 +##瘠 +##瘡 +##瘢 +##瘤 +##瘦 +##瘧 +##瘩 +##瘪 +##瘫 +##瘴 +##瘸 +##瘾 +##療 +##癇 +##癌 +##癒 +##癖 +##癜 +##癞 +##癡 +##癢 +##癣 +##癥 +##癫 +##癬 +##癮 +##癱 +##癲 +##癸 +##発 +##登 +##發 +##白 +##百 +##皂 +##的 +##皆 +##皇 +##皈 +##皋 +##皎 +##皑 +##皓 +##皖 +##皙 +##皚 +##皮 +##皰 +##皱 +##皴 +##皺 +##皿 +##盂 +##盃 +##盅 +##盆 +##盈 +##益 +##盎 +##盏 +##盐 +##监 +##盒 +##盔 +##盖 +##盗 +##盘 +##盛 +##盜 +##盞 +##盟 +##盡 +##監 +##盤 +##盥 +##盧 +##盪 +##目 +##盯 +##盱 +##盲 +##直 +##相 +##盹 +##盼 +##盾 +##省 +##眈 +##眉 +##看 +##県 +##眙 +##眞 +##真 +##眠 +##眦 +##眨 +##眩 +##眯 +##眶 +##眷 +##眸 +##眺 +##眼 +##眾 +##着 +##睁 +##睇 +##睏 +##睐 +##睑 +##睛 +##睜 +##睞 +##睡 +##睢 +##督 +##睥 +##睦 +##睨 +##睪 +##睫 +##睬 +##睹 +##睽 +##睾 +##睿 +##瞄 +##瞅 +##瞇 +##瞋 +##瞌 +##瞎 +##瞑 +##瞒 +##瞓 +##瞞 +##瞟 +##瞠 +##瞥 +##瞧 +##瞩 +##瞪 +##瞬 +##瞭 +##瞰 +##瞳 +##瞻 +##瞼 +##瞿 +##矇 +##矍 +##矗 +##矚 +##矛 +##矜 +##矢 +##矣 +##知 +##矩 +##矫 +##短 +##矮 +##矯 +##石 +##矶 +##矽 +##矾 +##矿 +##码 +##砂 +##砌 +##砍 +##砒 +##研 +##砖 +##砗 +##砚 +##砝 +##砣 +##砥 +##砧 +##砭 +##砰 +##砲 +##破 +##砷 +##砸 +##砺 +##砼 +##砾 +##础 +##硅 +##硐 +##硒 +##硕 +##硝 +##硫 +##硬 +##确 +##硯 +##硼 +##碁 +##碇 +##碉 +##碌 +##碍 +##碎 +##碑 +##碓 +##碗 +##碘 +##碚 +##碛 +##碟 +##碣 +##碧 +##碩 +##碰 +##碱 +##碳 +##碴 +##確 +##碼 +##碾 +##磁 +##磅 +##磊 +##磋 +##磐 +##磕 +##磚 +##磡 +##磨 +##磬 +##磯 +##磲 +##磷 +##磺 +##礁 +##礎 +##礙 +##礡 +##礦 +##礪 +##礫 +##礴 +##示 +##礼 +##社 +##祀 +##祁 +##祂 +##祇 +##祈 +##祉 +##祎 +##祐 +##祕 +##祖 +##祗 +##祚 +##祛 +##祜 +##祝 +##神 +##祟 +##祠 +##祢 +##祥 +##票 +##祭 +##祯 +##祷 +##祸 +##祺 +##祿 +##禀 +##禁 +##禄 +##禅 +##禍 +##禎 +##福 +##禛 +##禦 +##禧 +##禪 +##禮 +##禱 +##禹 +##禺 +##离 +##禽 +##禾 +##禿 +##秀 +##私 +##秃 +##秆 +##秉 +##秋 +##种 +##科 +##秒 +##秘 +##租 +##秣 +##秤 +##秦 +##秧 +##秩 +##秭 +##积 +##称 +##秸 +##移 +##秽 +##稀 +##稅 +##程 +##稍 +##税 +##稔 +##稗 +##稚 +##稜 +##稞 +##稟 +##稠 +##稣 +##種 +##稱 +##稲 +##稳 +##稷 +##稹 +##稻 +##稼 +##稽 +##稿 +##穀 +##穂 +##穆 +##穌 +##積 +##穎 +##穗 +##穢 +##穩 +##穫 +##穴 +##究 +##穷 +##穹 +##空 +##穿 +##突 +##窃 +##窄 +##窈 +##窍 +##窑 +##窒 +##窓 +##窕 +##窖 +##窗 +##窘 +##窜 +##窝 +##窟 +##窠 +##窥 +##窦 +##窨 +##窩 +##窪 +##窮 +##窯 +##窺 +##窿 +##竄 +##竅 +##竇 +##竊 +##立 +##竖 +##站 +##竜 +##竞 +##竟 +##章 +##竣 +##童 +##竭 +##端 +##競 +##竹 +##竺 +##竽 +##竿 +##笃 +##笆 +##笈 +##笋 +##笏 +##笑 +##笔 +##笙 +##笛 +##笞 +##笠 +##符 +##笨 +##第 +##笹 +##笺 +##笼 +##筆 +##等 +##筊 +##筋 +##筍 +##筏 +##筐 +##筑 +##筒 +##答 +##策 +##筛 +##筝 +##筠 +##筱 +##筲 +##筵 +##筷 +##筹 +##签 +##简 +##箇 +##箋 +##箍 +##箏 +##箐 +##箔 +##箕 +##算 +##箝 +##管 +##箩 +##箫 +##箭 +##箱 +##箴 +##箸 +##節 +##篁 +##範 +##篆 +##篇 +##築 +##篑 +##篓 +##篙 +##篝 +##篠 +##篡 +##篤 +##篩 +##篪 +##篮 +##篱 +##篷 +##簇 +##簌 +##簍 +##簡 +##簦 +##簧 +##簪 +##簫 +##簷 +##簸 +##簽 +##簾 +##簿 +##籁 +##籃 +##籌 +##籍 +##籐 +##籟 +##籠 +##籤 +##籬 +##籮 +##籲 +##米 +##类 +##籼 +##籽 +##粄 +##粉 +##粑 +##粒 +##粕 +##粗 +##粘 +##粟 +##粤 +##粥 +##粧 +##粪 +##粮 +##粱 +##粲 +##粳 +##粵 +##粹 +##粼 +##粽 +##精 +##粿 +##糅 +##糊 +##糍 +##糕 +##糖 +##糗 +##糙 +##糜 +##糞 +##糟 +##糠 +##糧 +##糬 +##糯 +##糰 +##糸 +##系 +##糾 +##紀 +##紂 +##約 +##紅 +##紉 +##紊 +##紋 +##納 +##紐 +##紓 +##純 +##紗 +##紘 +##紙 +##級 +##紛 +##紜 +##素 +##紡 +##索 +##紧 +##紫 +##紮 +##累 +##細 +##紳 +##紹 +##紺 +##終 +##絃 +##組 +##絆 +##経 +##結 +##絕 +##絞 +##絡 +##絢 +##給 +##絨 +##絮 +##統 +##絲 +##絳 +##絵 +##絶 +##絹 +##綁 +##綏 +##綑 +##經 +##継 +##続 +##綜 +##綠 +##綢 +##綦 +##綫 +##綬 +##維 +##綱 +##網 +##綴 +##綵 +##綸 +##綺 +##綻 +##綽 +##綾 +##綿 +##緊 +##緋 +##総 +##緑 +##緒 +##緘 +##線 +##緝 +##緞 +##締 +##緣 +##編 +##緩 +##緬 +##緯 +##練 +##緹 +##緻 +##縁 +##縄 +##縈 +##縛 +##縝 +##縣 +##縫 +##縮 +##縱 +##縴 +##縷 +##總 +##績 +##繁 +##繃 +##繆 +##繇 +##繋 +##織 +##繕 +##繚 +##繞 +##繡 +##繩 +##繪 +##繫 +##繭 +##繳 +##繹 +##繼 +##繽 +##纂 +##續 +##纍 +##纏 +##纓 +##纔 +##纖 +##纜 +##纠 +##红 +##纣 +##纤 +##约 +##级 +##纨 +##纪 +##纫 +##纬 +##纭 +##纯 +##纰 +##纱 +##纲 +##纳 +##纵 +##纶 +##纷 +##纸 +##纹 +##纺 +##纽 +##纾 +##线 +##绀 +##练 +##组 +##绅 +##细 +##织 +##终 +##绊 +##绍 +##绎 +##经 +##绑 +##绒 +##结 +##绔 +##绕 +##绘 +##给 +##绚 +##绛 +##络 +##绝 +##绞 +##统 +##绡 +##绢 +##绣 +##绥 +##绦 +##继 +##绩 +##绪 +##绫 +##续 +##绮 +##绯 +##绰 +##绳 +##维 +##绵 +##绶 +##绷 +##绸 +##绻 +##综 +##绽 +##绾 +##绿 +##缀 +##缄 +##缅 +##缆 +##缇 +##缈 +##缉 +##缎 +##缓 +##缔 +##缕 +##编 +##缘 +##缙 +##缚 +##缜 +##缝 +##缠 +##缢 +##缤 +##缥 +##缨 +##缩 +##缪 +##缭 +##缮 +##缰 +##缱 +##缴 +##缸 +##缺 +##缽 +##罂 +##罄 +##罌 +##罐 +##网 +##罔 +##罕 +##罗 +##罚 +##罡 +##罢 +##罩 +##罪 +##置 +##罰 +##署 +##罵 +##罷 +##罹 +##羁 +##羅 +##羈 +##羊 +##羌 +##美 +##羔 +##羚 +##羞 +##羟 +##羡 +##羣 +##群 +##羥 +##羧 +##羨 +##義 +##羯 +##羲 +##羸 +##羹 +##羽 +##羿 +##翁 +##翅 +##翊 +##翌 +##翎 +##習 +##翔 +##翘 +##翟 +##翠 +##翡 +##翦 +##翩 +##翰 +##翱 +##翳 +##翹 +##翻 +##翼 +##耀 +##老 +##考 +##耄 +##者 +##耆 +##耋 +##而 +##耍 +##耐 +##耒 +##耕 +##耗 +##耘 +##耙 +##耦 +##耨 +##耳 +##耶 +##耷 +##耸 +##耻 +##耽 +##耿 +##聂 +##聆 +##聊 +##聋 +##职 +##聒 +##联 +##聖 +##聘 +##聚 +##聞 +##聪 +##聯 +##聰 +##聲 +##聳 +##聴 +##聶 +##職 +##聽 +##聾 +##聿 +##肃 +##肄 +##肅 +##肆 +##肇 +##肉 +##肋 +##肌 +##肏 +##肓 +##肖 +##肘 +##肚 +##肛 +##肝 +##肠 +##股 +##肢 +##肤 +##肥 +##肩 +##肪 +##肮 +##肯 +##肱 +##育 +##肴 +##肺 +##肽 +##肾 +##肿 +##胀 +##胁 +##胃 +##胄 +##胆 +##背 +##胍 +##胎 +##胖 +##胚 +##胛 +##胜 +##胝 +##胞 +##胡 +##胤 +##胥 +##胧 +##胫 +##胭 +##胯 +##胰 +##胱 +##胳 +##胴 +##胶 +##胸 +##胺 +##能 +##脂 +##脅 +##脆 +##脇 +##脈 +##脉 +##脊 +##脍 +##脏 +##脐 +##脑 +##脓 +##脖 +##脘 +##脚 +##脛 +##脣 +##脩 +##脫 +##脯 +##脱 +##脲 +##脳 +##脸 +##脹 +##脾 +##腆 +##腈 +##腊 +##腋 +##腌 +##腎 +##腐 +##腑 +##腓 +##腔 +##腕 +##腥 +##腦 +##腩 +##腫 +##腭 +##腮 +##腰 +##腱 +##腳 +##腴 +##腸 +##腹 +##腺 +##腻 +##腼 +##腾 +##腿 +##膀 +##膈 +##膊 +##膏 +##膑 +##膘 +##膚 +##膛 +##膜 +##膝 +##膠 +##膦 +##膨 +##膩 +##膳 +##膺 +##膻 +##膽 +##膾 +##膿 +##臀 +##臂 +##臃 +##臆 +##臉 +##臊 +##臍 +##臓 +##臘 +##臟 +##臣 +##臥 +##臧 +##臨 +##自 +##臬 +##臭 +##至 +##致 +##臺 +##臻 +##臼 +##臾 +##舀 +##舂 +##舅 +##舆 +##與 +##興 +##舉 +##舊 +##舌 +##舍 +##舎 +##舐 +##舒 +##舔 +##舖 +##舗 +##舛 +##舜 +##舞 +##舟 +##航 +##舫 +##般 +##舰 +##舱 +##舵 +##舶 +##舷 +##舸 +##船 +##舺 +##舾 +##艇 +##艋 +##艘 +##艙 +##艦 +##艮 +##良 +##艰 +##艱 +##色 +##艳 +##艷 +##艹 +##艺 +##艾 +##节 +##芃 +##芈 +##芊 +##芋 +##芍 +##芎 +##芒 +##芙 +##芜 +##芝 +##芡 +##芥 +##芦 +##芩 +##芪 +##芫 +##芬 +##芭 +##芮 +##芯 +##花 +##芳 +##芷 +##芸 +##芹 +##芻 +##芽 +##芾 +##苁 +##苄 +##苇 +##苋 +##苍 +##苏 +##苑 +##苒 +##苓 +##苔 +##苕 +##苗 +##苛 +##苜 +##苞 +##苟 +##苡 +##苣 +##若 +##苦 +##苫 +##苯 +##英 +##苷 +##苹 +##苻 +##茁 +##茂 +##范 +##茄 +##茅 +##茉 +##茎 +##茏 +##茗 +##茜 +##茧 +##茨 +##茫 +##茬 +##茭 +##茯 +##茱 +##茲 +##茴 +##茵 +##茶 +##茸 +##茹 +##茼 +##荀 +##荃 +##荆 +##草 +##荊 +##荏 +##荐 +##荒 +##荔 +##荖 +##荘 +##荚 +##荞 +##荟 +##荠 +##荡 +##荣 +##荤 +##荥 +##荧 +##荨 +##荪 +##荫 +##药 +##荳 +##荷 +##荸 +##荻 +##荼 +##荽 +##莅 +##莆 +##莉 +##莊 +##莎 +##莒 +##莓 +##莖 +##莘 +##莞 +##莠 +##莢 +##莧 +##莪 +##莫 +##莱 +##莲 +##莴 +##获 +##莹 +##莺 +##莽 +##莿 +##菀 +##菁 +##菅 +##菇 +##菈 +##菊 +##菌 +##菏 +##菓 +##菖 +##菘 +##菜 +##菟 +##菠 +##菡 +##菩 +##華 +##菱 +##菲 +##菸 +##菽 +##萁 +##萃 +##萄 +##萊 +##萋 +##萌 +##萍 +##萎 +##萘 +##萝 +##萤 +##营 +##萦 +##萧 +##萨 +##萩 +##萬 +##萱 +##萵 +##萸 +##萼 +##落 +##葆 +##葉 +##著 +##葚 +##葛 +##葡 +##董 +##葦 +##葩 +##葫 +##葬 +##葭 +##葯 +##葱 +##葳 +##葵 +##葷 +##葺 +##蒂 +##蒋 +##蒐 +##蒔 +##蒙 +##蒜 +##蒞 +##蒟 +##蒡 +##蒨 +##蒲 +##蒸 +##蒹 +##蒻 +##蒼 +##蒿 +##蓁 +##蓄 +##蓆 +##蓉 +##蓋 +##蓑 +##蓓 +##蓖 +##蓝 +##蓟 +##蓦 +##蓬 +##蓮 +##蓼 +##蓿 +##蔑 +##蔓 +##蔔 +##蔗 +##蔘 +##蔚 +##蔡 +##蔣 +##蔥 +##蔫 +##蔬 +##蔭 +##蔵 +##蔷 +##蔺 +##蔻 +##蔼 +##蔽 +##蕁 +##蕃 +##蕈 +##蕉 +##蕊 +##蕎 +##蕙 +##蕤 +##蕨 +##蕩 +##蕪 +##蕭 +##蕲 +##蕴 +##蕻 +##蕾 +##薄 +##薅 +##薇 +##薈 +##薊 +##薏 +##薑 +##薔 +##薙 +##薛 +##薦 +##薨 +##薩 +##薪 +##薬 +##薯 +##薰 +##薹 +##藉 +##藍 +##藏 +##藐 +##藓 +##藕 +##藜 +##藝 +##藤 +##藥 +##藩 +##藹 +##藻 +##藿 +##蘆 +##蘇 +##蘊 +##蘋 +##蘑 +##蘚 +##蘭 +##蘸 +##蘼 +##蘿 +##虎 +##虏 +##虐 +##虑 +##虔 +##處 +##虚 +##虛 +##虜 +##虞 +##號 +##虢 +##虧 +##虫 +##虬 +##虱 +##虹 +##虻 +##虽 +##虾 +##蚀 +##蚁 +##蚂 +##蚊 +##蚌 +##蚓 +##蚕 +##蚜 +##蚝 +##蚣 +##蚤 +##蚩 +##蚪 +##蚯 +##蚱 +##蚵 +##蛀 +##蛆 +##蛇 +##蛊 +##蛋 +##蛎 +##蛐 +##蛔 +##蛙 +##蛛 +##蛟 +##蛤 +##蛭 +##蛮 +##蛰 +##蛳 +##蛹 +##蛻 +##蛾 +##蜀 +##蜂 +##蜃 +##蜆 +##蜇 +##蜈 +##蜊 +##蜍 +##蜒 +##蜓 +##蜕 +##蜗 +##蜘 +##蜚 +##蜜 +##蜡 +##蜢 +##蜥 +##蜱 +##蜴 +##蜷 +##蜻 +##蜿 +##蝇 +##蝈 +##蝉 +##蝌 +##蝎 +##蝕 +##蝗 +##蝙 +##蝟 +##蝠 +##蝦 +##蝨 +##蝴 +##蝶 +##蝸 +##蝼 +##螂 +##螃 +##融 +##螞 +##螢 +##螨 +##螯 +##螳 +##螺 +##蟀 +##蟄 +##蟆 +##蟋 +##蟎 +##蟑 +##蟒 +##蟠 +##蟬 +##蟲 +##蟹 +##蟻 +##蟾 +##蠅 +##蠍 +##蠔 +##蠕 +##蠛 +##蠟 +##蠡 +##蠢 +##蠣 +##蠱 +##蠶 +##蠹 +##蠻 +##血 +##衄 +##衅 +##衆 +##行 +##衍 +##術 +##衔 +##街 +##衙 +##衛 +##衝 +##衞 +##衡 +##衢 +##衣 +##补 +##表 +##衩 +##衫 +##衬 +##衮 +##衰 +##衲 +##衷 +##衹 +##衾 +##衿 +##袁 +##袂 +##袄 +##袅 +##袈 +##袋 +##袍 +##袒 +##袖 +##袜 +##袞 +##袤 +##袪 +##被 +##袭 +##袱 +##裁 +##裂 +##装 +##裆 +##裊 +##裏 +##裔 +##裕 +##裘 +##裙 +##補 +##裝 +##裟 +##裡 +##裤 +##裨 +##裱 +##裳 +##裴 +##裸 +##裹 +##製 +##裾 +##褂 +##複 +##褐 +##褒 +##褓 +##褔 +##褚 +##褥 +##褪 +##褫 +##褲 +##褶 +##褻 +##襁 +##襄 +##襟 +##襠 +##襪 +##襬 +##襯 +##襲 +##西 +##要 +##覃 +##覆 +##覇 +##見 +##規 +##覓 +##視 +##覚 +##覦 +##覧 +##親 +##覬 +##観 +##覷 +##覺 +##覽 +##觀 +##见 +##观 +##规 +##觅 +##视 +##览 +##觉 +##觊 +##觎 +##觐 +##觑 +##角 +##觞 +##解 +##觥 +##触 +##觸 +##言 +##訂 +##計 +##訊 +##討 +##訓 +##訕 +##訖 +##託 +##記 +##訛 +##訝 +##訟 +##訣 +##訥 +##訪 +##設 +##許 +##訳 +##訴 +##訶 +##診 +##註 +##証 +##詆 +##詐 +##詔 +##評 +##詛 +##詞 +##詠 +##詡 +##詢 +##詣 +##試 +##詩 +##詫 +##詬 +##詭 +##詮 +##詰 +##話 +##該 +##詳 +##詹 +##詼 +##誅 +##誇 +##誉 +##誌 +##認 +##誓 +##誕 +##誘 +##語 +##誠 +##誡 +##誣 +##誤 +##誥 +##誦 +##誨 +##說 +##説 +##読 +##誰 +##課 +##誹 +##誼 +##調 +##諄 +##談 +##請 +##諏 +##諒 +##論 +##諗 +##諜 +##諡 +##諦 +##諧 +##諫 +##諭 +##諮 +##諱 +##諳 +##諷 +##諸 +##諺 +##諾 +##謀 +##謁 +##謂 +##謄 +##謊 +##謎 +##謐 +##謔 +##謗 +##謙 +##講 +##謝 +##謠 +##謨 +##謬 +##謹 +##謾 +##譁 +##證 +##譎 +##譏 +##識 +##譙 +##譚 +##譜 +##警 +##譬 +##譯 +##議 +##譲 +##譴 +##護 +##譽 +##讀 +##變 +##讓 +##讚 +##讞 +##计 +##订 +##认 +##讥 +##讧 +##讨 +##让 +##讪 +##讫 +##训 +##议 +##讯 +##记 +##讲 +##讳 +##讴 +##讶 +##讷 +##许 +##讹 +##论 +##讼 +##讽 +##设 +##访 +##诀 +##证 +##诃 +##评 +##诅 +##识 +##诈 +##诉 +##诊 +##诋 +##词 +##诏 +##译 +##试 +##诗 +##诘 +##诙 +##诚 +##诛 +##话 +##诞 +##诟 +##诠 +##诡 +##询 +##诣 +##诤 +##该 +##详 +##诧 +##诩 +##诫 +##诬 +##语 +##误 +##诰 +##诱 +##诲 +##说 +##诵 +##诶 +##请 +##诸 +##诺 +##读 +##诽 +##课 +##诿 +##谀 +##谁 +##调 +##谄 +##谅 +##谆 +##谈 +##谊 +##谋 +##谌 +##谍 +##谎 +##谏 +##谐 +##谑 +##谒 +##谓 +##谔 +##谕 +##谗 +##谘 +##谙 +##谚 +##谛 +##谜 +##谟 +##谢 +##谣 +##谤 +##谥 +##谦 +##谧 +##谨 +##谩 +##谪 +##谬 +##谭 +##谯 +##谱 +##谲 +##谴 +##谶 +##谷 +##豁 +##豆 +##豇 +##豈 +##豉 +##豊 +##豌 +##豎 +##豐 +##豔 +##豚 +##象 +##豢 +##豪 +##豫 +##豬 +##豹 +##豺 +##貂 +##貅 +##貌 +##貓 +##貔 +##貘 +##貝 +##貞 +##負 +##財 +##貢 +##貧 +##貨 +##販 +##貪 +##貫 +##責 +##貯 +##貰 +##貳 +##貴 +##貶 +##買 +##貸 +##費 +##貼 +##貽 +##貿 +##賀 +##賁 +##賂 +##賃 +##賄 +##資 +##賈 +##賊 +##賑 +##賓 +##賜 +##賞 +##賠 +##賡 +##賢 +##賣 +##賤 +##賦 +##質 +##賬 +##賭 +##賴 +##賺 +##購 +##賽 +##贅 +##贈 +##贊 +##贍 +##贏 +##贓 +##贖 +##贛 +##贝 +##贞 +##负 +##贡 +##财 +##责 +##贤 +##败 +##账 +##货 +##质 +##贩 +##贪 +##贫 +##贬 +##购 +##贮 +##贯 +##贰 +##贱 +##贲 +##贴 +##贵 +##贷 +##贸 +##费 +##贺 +##贻 +##贼 +##贾 +##贿 +##赁 +##赂 +##赃 +##资 +##赅 +##赈 +##赊 +##赋 +##赌 +##赎 +##赏 +##赐 +##赓 +##赔 +##赖 +##赘 +##赚 +##赛 +##赝 +##赞 +##赠 +##赡 +##赢 +##赣 +##赤 +##赦 +##赧 +##赫 +##赭 +##走 +##赳 +##赴 +##赵 +##赶 +##起 +##趁 +##超 +##越 +##趋 +##趕 +##趙 +##趟 +##趣 +##趨 +##足 +##趴 +##趵 +##趸 +##趺 +##趾 +##跃 +##跄 +##跆 +##跋 +##跌 +##跎 +##跑 +##跖 +##跚 +##跛 +##距 +##跟 +##跡 +##跤 +##跨 +##跩 +##跪 +##路 +##跳 +##践 +##跷 +##跹 +##跺 +##跻 +##踉 +##踊 +##踌 +##踏 +##踐 +##踝 +##踞 +##踟 +##踢 +##踩 +##踪 +##踮 +##踱 +##踴 +##踵 +##踹 +##蹂 +##蹄 +##蹇 +##蹈 +##蹉 +##蹊 +##蹋 +##蹑 +##蹒 +##蹙 +##蹟 +##蹣 +##蹤 +##蹦 +##蹩 +##蹬 +##蹭 +##蹲 +##蹴 +##蹶 +##蹺 +##蹼 +##蹿 +##躁 +##躇 +##躉 +##躊 +##躋 +##躍 +##躏 +##躪 +##身 +##躬 +##躯 +##躲 +##躺 +##軀 +##車 +##軋 +##軌 +##軍 +##軒 +##軟 +##転 +##軸 +##軼 +##軽 +##軾 +##較 +##載 +##輒 +##輓 +##輔 +##輕 +##輛 +##輝 +##輟 +##輩 +##輪 +##輯 +##輸 +##輻 +##輾 +##輿 +##轄 +##轅 +##轆 +##轉 +##轍 +##轎 +##轟 +##车 +##轧 +##轨 +##轩 +##转 +##轭 +##轮 +##软 +##轰 +##轲 +##轴 +##轶 +##轻 +##轼 +##载 +##轿 +##较 +##辄 +##辅 +##辆 +##辇 +##辈 +##辉 +##辊 +##辍 +##辐 +##辑 +##输 +##辕 +##辖 +##辗 +##辘 +##辙 +##辛 +##辜 +##辞 +##辟 +##辣 +##辦 +##辨 +##辩 +##辫 +##辭 +##辮 +##辯 +##辰 +##辱 +##農 +##边 +##辺 +##辻 +##込 +##辽 +##达 +##迁 +##迂 +##迄 +##迅 +##过 +##迈 +##迎 +##运 +##近 +##返 +##还 +##这 +##进 +##远 +##违 +##连 +##迟 +##迢 +##迤 +##迥 +##迦 +##迩 +##迪 +##迫 +##迭 +##述 +##迴 +##迷 +##迸 +##迹 +##迺 +##追 +##退 +##送 +##适 +##逃 +##逅 +##逆 +##选 +##逊 +##逍 +##透 +##逐 +##递 +##途 +##逕 +##逗 +##這 +##通 +##逛 +##逝 +##逞 +##速 +##造 +##逢 +##連 +##逮 +##週 +##進 +##逵 +##逶 +##逸 +##逻 +##逼 +##逾 +##遁 +##遂 +##遅 +##遇 +##遊 +##運 +##遍 +##過 +##遏 +##遐 +##遑 +##遒 +##道 +##達 +##違 +##遗 +##遙 +##遛 +##遜 +##遞 +##遠 +##遢 +##遣 +##遥 +##遨 +##適 +##遭 +##遮 +##遲 +##遴 +##遵 +##遶 +##遷 +##選 +##遺 +##遼 +##遽 +##避 +##邀 +##邁 +##邂 +##邃 +##還 +##邇 +##邈 +##邊 +##邋 +##邏 +##邑 +##邓 +##邕 +##邛 +##邝 +##邢 +##那 +##邦 +##邨 +##邪 +##邬 +##邮 +##邯 +##邰 +##邱 +##邳 +##邵 +##邸 +##邹 +##邺 +##邻 +##郁 +##郅 +##郊 +##郎 +##郑 +##郜 +##郝 +##郡 +##郢 +##郤 +##郦 +##郧 +##部 +##郫 +##郭 +##郴 +##郵 +##郷 +##郸 +##都 +##鄂 +##鄉 +##鄒 +##鄔 +##鄙 +##鄞 +##鄢 +##鄧 +##鄭 +##鄰 +##鄱 +##鄲 +##鄺 +##酉 +##酊 +##酋 +##酌 +##配 +##酐 +##酒 +##酗 +##酚 +##酝 +##酢 +##酣 +##酥 +##酩 +##酪 +##酬 +##酮 +##酯 +##酰 +##酱 +##酵 +##酶 +##酷 +##酸 +##酿 +##醃 +##醇 +##醉 +##醋 +##醍 +##醐 +##醒 +##醚 +##醛 +##醜 +##醞 +##醣 +##醪 +##醫 +##醬 +##醮 +##醯 +##醴 +##醺 +##釀 +##釁 +##采 +##釉 +##释 +##釋 +##里 +##重 +##野 +##量 +##釐 +##金 +##釗 +##釘 +##釜 +##針 +##釣 +##釦 +##釧 +##釵 +##鈀 +##鈉 +##鈍 +##鈎 +##鈔 +##鈕 +##鈞 +##鈣 +##鈦 +##鈪 +##鈴 +##鈺 +##鈾 +##鉀 +##鉄 +##鉅 +##鉉 +##鉑 +##鉗 +##鉚 +##鉛 +##鉤 +##鉴 +##鉻 +##銀 +##銃 +##銅 +##銑 +##銓 +##銖 +##銘 +##銜 +##銬 +##銭 +##銮 +##銳 +##銷 +##銹 +##鋁 +##鋅 +##鋒 +##鋤 +##鋪 +##鋰 +##鋸 +##鋼 +##錄 +##錐 +##錘 +##錚 +##錠 +##錢 +##錦 +##錨 +##錫 +##錮 +##錯 +##録 +##錳 +##錶 +##鍊 +##鍋 +##鍍 +##鍛 +##鍥 +##鍰 +##鍵 +##鍺 +##鍾 +##鎂 +##鎊 +##鎌 +##鎏 +##鎔 +##鎖 +##鎗 +##鎚 +##鎧 +##鎬 +##鎮 +##鎳 +##鏈 +##鏖 +##鏗 +##鏘 +##鏞 +##鏟 +##鏡 +##鏢 +##鏤 +##鏽 +##鐘 +##鐮 +##鐲 +##鐳 +##鐵 +##鐸 +##鐺 +##鑄 +##鑊 +##鑑 +##鑒 +##鑣 +##鑫 +##鑰 +##鑲 +##鑼 +##鑽 +##鑾 +##鑿 +##针 +##钉 +##钊 +##钎 +##钏 +##钒 +##钓 +##钗 +##钙 +##钛 +##钜 +##钝 +##钞 +##钟 +##钠 +##钡 +##钢 +##钣 +##钤 +##钥 +##钦 +##钧 +##钨 +##钩 +##钮 +##钯 +##钰 +##钱 +##钳 +##钴 +##钵 +##钺 +##钻 +##钼 +##钾 +##钿 +##铀 +##铁 +##铂 +##铃 +##铄 +##铅 +##铆 +##铉 +##铎 +##铐 +##铛 +##铜 +##铝 +##铠 +##铡 +##铢 +##铣 +##铤 +##铨 +##铩 +##铬 +##铭 +##铮 +##铰 +##铲 +##铵 +##银 +##铸 +##铺 +##链 +##铿 +##销 +##锁 +##锂 +##锄 +##锅 +##锆 +##锈 +##锉 +##锋 +##锌 +##锏 +##锐 +##锑 +##错 +##锚 +##锟 +##锡 +##锢 +##锣 +##锤 +##锥 +##锦 +##锭 +##键 +##锯 +##锰 +##锲 +##锵 +##锹 +##锺 +##锻 +##镀 +##镁 +##镂 +##镇 +##镉 +##镌 +##镍 +##镐 +##镑 +##镕 +##镖 +##镗 +##镛 +##镜 +##镣 +##镭 +##镯 +##镰 +##镳 +##镶 +##長 +##长 +##門 +##閃 +##閉 +##開 +##閎 +##閏 +##閑 +##閒 +##間 +##閔 +##閘 +##閡 +##関 +##閣 +##閥 +##閨 +##閩 +##閱 +##閲 +##閹 +##閻 +##閾 +##闆 +##闇 +##闊 +##闌 +##闍 +##闔 +##闕 +##闖 +##闘 +##關 +##闡 +##闢 +##门 +##闪 +##闫 +##闭 +##问 +##闯 +##闰 +##闲 +##间 +##闵 +##闷 +##闸 +##闹 +##闺 +##闻 +##闽 +##闾 +##阀 +##阁 +##阂 +##阅 +##阆 +##阇 +##阈 +##阉 +##阎 +##阐 +##阑 +##阔 +##阕 +##阖 +##阙 +##阚 +##阜 +##队 +##阡 +##阪 +##阮 +##阱 +##防 +##阳 +##阴 +##阵 +##阶 +##阻 +##阿 +##陀 +##陂 +##附 +##际 +##陆 +##陇 +##陈 +##陋 +##陌 +##降 +##限 +##陕 +##陛 +##陝 +##陞 +##陟 +##陡 +##院 +##陣 +##除 +##陨 +##险 +##陪 +##陰 +##陲 +##陳 +##陵 +##陶 +##陷 +##陸 +##険 +##陽 +##隅 +##隆 +##隈 +##隊 +##隋 +##隍 +##階 +##随 +##隐 +##隔 +##隕 +##隘 +##隙 +##際 +##障 +##隠 +##隣 +##隧 +##隨 +##險 +##隱 +##隴 +##隶 +##隸 +##隻 +##隼 +##隽 +##难 +##雀 +##雁 +##雄 +##雅 +##集 +##雇 +##雉 +##雋 +##雌 +##雍 +##雎 +##雏 +##雑 +##雒 +##雕 +##雖 +##雙 +##雛 +##雜 +##雞 +##離 +##難 +##雨 +##雪 +##雯 +##雰 +##雲 +##雳 +##零 +##雷 +##雹 +##電 +##雾 +##需 +##霁 +##霄 +##霆 +##震 +##霈 +##霉 +##霊 +##霍 +##霎 +##霏 +##霑 +##霓 +##霖 +##霜 +##霞 +##霧 +##霭 +##霰 +##露 +##霸 +##霹 +##霽 +##霾 +##靂 +##靄 +##靈 +##青 +##靓 +##靖 +##静 +##靚 +##靛 +##靜 +##非 +##靠 +##靡 +##面 +##靥 +##靦 +##革 +##靳 +##靴 +##靶 +##靼 +##鞅 +##鞋 +##鞍 +##鞏 +##鞑 +##鞘 +##鞠 +##鞣 +##鞦 +##鞭 +##韆 +##韋 +##韌 +##韓 +##韜 +##韦 +##韧 +##韩 +##韬 +##韭 +##音 +##韵 +##韶 +##韻 +##響 +##頁 +##頂 +##頃 +##項 +##順 +##須 +##頌 +##預 +##頑 +##頒 +##頓 +##頗 +##領 +##頜 +##頡 +##頤 +##頫 +##頭 +##頰 +##頷 +##頸 +##頹 +##頻 +##頼 +##顆 +##題 +##額 +##顎 +##顏 +##顔 +##願 +##顛 +##類 +##顧 +##顫 +##顯 +##顱 +##顴 +##页 +##顶 +##顷 +##项 +##顺 +##须 +##顼 +##顽 +##顾 +##顿 +##颁 +##颂 +##预 +##颅 +##领 +##颇 +##颈 +##颉 +##颊 +##颌 +##颍 +##颐 +##频 +##颓 +##颔 +##颖 +##颗 +##题 +##颚 +##颛 +##颜 +##额 +##颞 +##颠 +##颡 +##颢 +##颤 +##颦 +##颧 +##風 +##颯 +##颱 +##颳 +##颶 +##颼 +##飄 +##飆 +##风 +##飒 +##飓 +##飕 +##飘 +##飙 +##飚 +##飛 +##飞 +##食 +##飢 +##飨 +##飩 +##飪 +##飯 +##飲 +##飼 +##飽 +##飾 +##餃 +##餅 +##餉 +##養 +##餌 +##餐 +##餒 +##餓 +##餘 +##餚 +##餛 +##餞 +##餡 +##館 +##餮 +##餵 +##餾 +##饅 +##饈 +##饋 +##饌 +##饍 +##饑 +##饒 +##饕 +##饗 +##饞 +##饥 +##饨 +##饪 +##饬 +##饭 +##饮 +##饯 +##饰 +##饱 +##饲 +##饴 +##饵 +##饶 +##饷 +##饺 +##饼 +##饽 +##饿 +##馀 +##馁 +##馄 +##馅 +##馆 +##馈 +##馋 +##馍 +##馏 +##馒 +##馔 +##首 +##馗 +##香 +##馥 +##馨 +##馬 +##馭 +##馮 +##馳 +##馴 +##駁 +##駄 +##駅 +##駆 +##駐 +##駒 +##駕 +##駛 +##駝 +##駭 +##駱 +##駿 +##騁 +##騎 +##騏 +##験 +##騙 +##騨 +##騰 +##騷 +##驀 +##驅 +##驊 +##驍 +##驒 +##驕 +##驗 +##驚 +##驛 +##驟 +##驢 +##驥 +##马 +##驭 +##驮 +##驯 +##驰 +##驱 +##驳 +##驴 +##驶 +##驷 +##驸 +##驹 +##驻 +##驼 +##驾 +##驿 +##骁 +##骂 +##骄 +##骅 +##骆 +##骇 +##骈 +##骊 +##骋 +##验 +##骏 +##骐 +##骑 +##骗 +##骚 +##骛 +##骜 +##骞 +##骠 +##骡 +##骤 +##骥 +##骧 +##骨 +##骯 +##骰 +##骶 +##骷 +##骸 +##骼 +##髂 +##髅 +##髋 +##髏 +##髒 +##髓 +##體 +##髖 +##高 +##髦 +##髪 +##髮 +##髯 +##髻 +##鬃 +##鬆 +##鬍 +##鬓 +##鬚 +##鬟 +##鬢 +##鬣 +##鬥 +##鬧 +##鬱 +##鬼 +##魁 +##魂 +##魄 +##魅 +##魇 +##魍 +##魏 +##魔 +##魘 +##魚 +##魯 +##魷 +##鮑 +##鮨 +##鮪 +##鮭 +##鮮 +##鯉 +##鯊 +##鯖 +##鯛 +##鯨 +##鯰 +##鯽 +##鰍 +##鰓 +##鰭 +##鰲 +##鰻 +##鰾 +##鱈 +##鱉 +##鱔 +##鱗 +##鱷 +##鱸 +##鱼 +##鱿 +##鲁 +##鲈 +##鲍 +##鲑 +##鲛 +##鲜 +##鲟 +##鲢 +##鲤 +##鲨 +##鲫 +##鲱 +##鲲 +##鲶 +##鲷 +##鲸 +##鳃 +##鳄 +##鳅 +##鳌 +##鳍 +##鳕 +##鳖 +##鳗 +##鳝 +##鳞 +##鳥 +##鳩 +##鳳 +##鳴 +##鳶 +##鴉 +##鴕 +##鴛 +##鴦 +##鴨 +##鴻 +##鴿 +##鵑 +##鵜 +##鵝 +##鵡 +##鵬 +##鵰 +##鵲 +##鶘 +##鶩 +##鶯 +##鶴 +##鷗 +##鷲 +##鷹 +##鷺 +##鸚 +##鸞 +##鸟 +##鸠 +##鸡 +##鸢 +##鸣 +##鸥 +##鸦 +##鸨 +##鸪 +##鸭 +##鸯 +##鸳 +##鸵 +##鸽 +##鸾 +##鸿 +##鹂 +##鹃 +##鹄 +##鹅 +##鹈 +##鹉 +##鹊 +##鹌 +##鹏 +##鹑 +##鹕 +##鹘 +##鹜 +##鹞 +##鹤 +##鹦 +##鹧 +##鹫 +##鹭 +##鹰 +##鹳 +##鹵 +##鹹 +##鹼 +##鹽 +##鹿 +##麂 +##麋 +##麒 +##麓 +##麗 +##麝 +##麟 +##麥 +##麦 +##麩 +##麴 +##麵 +##麸 +##麺 +##麻 +##麼 +##麽 +##麾 +##黃 +##黄 +##黍 +##黎 +##黏 +##黑 +##黒 +##黔 +##默 +##黛 +##黜 +##黝 +##點 +##黠 +##黨 +##黯 +##黴 +##鼋 +##鼎 +##鼐 +##鼓 +##鼠 +##鼬 +##鼹 +##鼻 +##鼾 +##齁 +##齊 +##齋 +##齐 +##齒 +##齡 +##齢 +##齣 +##齦 +##齿 +##龄 +##龅 +##龈 +##龊 +##龋 +##龌 +##龍 +##龐 +##龔 +##龕 +##龙 +##龚 +##龛 +##龜 +##龟 +##︰ +##︱ +##︶ +##︿ +##﹁ +##﹂ +##﹍ +##﹏ +##﹐ +##﹑ +##﹒ +##﹔ +##﹕ +##﹖ +##﹗ +##﹙ +##﹚ +##﹝ +##﹞ +##﹡ +##﹣ +##！ +##＂ +##＃ +##＄ +##％ +##＆ +##＇ +##（ +##） +##＊ +##， +##－ +##． +##／ +##： +##； +##＜ +##？ +##＠ +##［ +##＼ +##］ +##＾ +##＿ +##｀ +##ｆ +##ｈ +##ｊ +##ｕ +##ｗ +##ｚ +##｛ +##｝ +##｡ +##｢ +##｣ +##､ +##･ +##ｯ +##ｰ +##ｲ +##ｸ +##ｼ +##ｽ +##ﾄ +##ﾉ +##ﾌ +##ﾗ +##ﾙ +##ﾝ +##ﾞ +##ﾟ +##￣ +##￥ +##👍 +##🔥 +##😂 +##😎 diff --git a/utils/BPE/__init__.py b/utils/BPE/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/utils/BPE/dict.txt b/utils/BPE/dict.txt new file mode 100644 index 0000000000000000000000000000000000000000..9b4d2de40fa2cbeb2c6128cfd031b9872ef4d054 --- /dev/null +++ b/utils/BPE/dict.txt @@ -0,0 +1,50260 @@ +13 850314647 +262 800385005 +11 800251374 +284 432911125 +290 394899794 +286 386139013 +257 357878752 +287 311196488 +12 215156821 +329 155236946 +326 154060431 +319 147178919 +318 142591644 +447 130810923 +338 116498242 +351 114784681 +383 108664122 +373 100357189 +366 93880741 +379 93284459 +340 88803471 +355 85749070 +531 85009762 +247 82642284 +307 77095226 +82 76381845 +416 73380803 +422 71911149 +389 68628918 +423 67243391 +468 64317701 +25 63508661 +357 63001640 +339 61994245 +314 60989470 +465 56381137 +481 55817121 +281 55370942 +428 52404829 +8 49955136 +564 49278190 +407 49022194 +251 48828693 +345 46413707 +250 46095324 +511 42623671 +393 41629710 +484 41252315 +356 40985272 +475 40041980 +508 39889004 +517 36480426 +550 35941594 +587 34803895 +547 34523820 +546 33398226 +553 33091056 +543 32654778 +510 32035371 +663 32028126 +460 31691389 +530 31181535 +503 30862486 +635 30813519 +720 30660454 +607 30374808 +477 29369504 +706 29183313 +526 29041171 +14 28893906 +561 27738361 +470 26738514 +614 25458253 +618 24232023 +717 23994060 +673 23817299 +734 23792701 +625 23376942 +661 23220442 +317 22862326 +674 22516011 +632 22500762 +640 22453472 +621 22170426 +656 21469936 +612 21420897 +83 21318775 +679 21314775 +649 21268970 +851 21092011 +938 20404401 +655 20375026 +554 20334200 +584 20320611 +523 20315428 +644 20012607 +40 19422652 +588 19096246 +64 18759122 +617 18693984 +50 18238046 +26689 18079440 +606 17992787 +812 17864313 +6 17843244 +466 17817361 +534 17796224 +532 17532111 +352 17384084 +1 17279082 +611 17091775 +714 17025679 +30 16939428 +645 16677856 +72 16553037 +76 16327061 +651 15971344 +471 15879338 +783 15823492 +683 15819244 +736 15197650 +887 15053172 +784 14786686 +616 14556795 +705 14539133 +691 14309272 +1115 14176045 +26 14145184 +362 14098304 +464 14083981 +16 14033199 +1411 13989417 +1028 13787695 +878 13752356 +1664 13470232 +78 13378307 +1301 13160863 +703 13034870 +780 12998354 +597 12928745 +749 12878804 +852 12866041 +787 12811365 +810 12810008 +1141 12785466 +832 12685151 +981 12676060 +830 12643489 +770 12491952 +1510 12485834 +278 12398432 +513 12345382 +925 12242439 +880 12187173 +838 12095675 +866 12088892 +572 12004582 +1139 11932599 +502 11810743 +347 11778080 +1016 11554835 +1074 11537640 +775 11416721 +883 11147387 +1230 11002697 +835 10997448 +1135 10975044 +867 10945123 +788 10941163 +670 10932097 +1297 10878979 +785 10826031 +17 10797378 +983 10787263 +843 10673666 +259 10657207 +1941 10592731 +279 10574822 +845 10526221 +1110 10523541 +1363 10476406 +1011 10465302 +1285 10446380 +1201 10423577 +968 10348378 +743 10336013 +772 10297739 +1622 10289758 +766 10280263 +2177 10243413 +1181 10234334 +642 10188179 +276 10110644 +815 10077564 +1088 10066642 +2864 10065012 +1218 10051426 +514 10027697 +991 9981059 +881 9920784 +604 9911573 +922 9903273 +892 9899715 +4 9886396 +311 9824882 +777 9788574 +1910 9785844 +360 9705921 +400 9632736 +467 9594120 +821 9549150 +884 9547397 +760 9515151 +1390 9514008 +836 9399858 +88 9399371 +1306 9350994 +350 9326094 +750 9317800 +739 9296956 +910 9295771 +268 9233925 +406 9191046 +1022 9185932 +583 9178621 +509 9120375 +327 9057596 +718 8963492 +995 8936939 +636 8882717 +399 8811370 +826 8792653 +765 8755010 +1440 8704406 +828 8681852 +1029 8668925 +761 8595175 +260 8550153 +68 8521820 +1026 8495454 +1037 8482028 +20 8478672 +18 8372937 +1499 8372574 +371 8359700 +1644 8353078 +32 8336893 +890 8325716 +1119 8309982 +886 8287585 +263 8275838 +309 8275603 +337 8268937 +84 8260458 +1111 8203580 +994 8202575 +272 8193169 +261 8189103 +767 8122128 +390 8069108 +1375 7988935 +1597 7984150 +989 7938818 +73 7922334 +364 7880395 +1107 7805773 +1992 7800278 +283 7777203 +402 7732480 +3217 7712997 +376 7593883 +1266 7589093 +976 7577523 +1194 7566250 +900 7556294 +727 7550625 +1320 7507098 +292 7495866 +77 7470439 +1282 7450955 +1641 7411391 +1171 7409099 +1114 7363929 +1081 7347040 +15 7312426 +367 7306406 +807 7279240 +1160 7272825 +1936 7262915 +274 7253218 +3431 7220578 +299 7218583 +3635 7152871 +3860 7135265 +71 7117156 +1353 7113713 +1392 7090351 +1204 7074121 +3321 7040732 +1043 7037776 +779 7012062 +370 6995545 +19 6983878 +3583 6974965 +898 6966637 +1864 6959506 +711 6952288 +905 6939061 +520 6938890 +582 6920647 +1364 6908579 +1578 6875577 +1105 6855797 +1295 6829761 +1002 6812464 +1256 6769157 +1966 6727321 +657 6641494 +737 6624794 +1104 6593949 +494 6588847 +2997 6571290 +256 6561739 +7303 6545519 +0 6525880 +89 6511169 +74 6481093 +1812 6451687 +2173 6415053 +1448 6412987 +1524 6397024 +1321 6394244 +1584 6392878 +282 6358319 +81 6351445 +1592 6336754 +1705 6331987 +973 6315804 +1234 6313784 +1748 6306370 +449 6287674 +1318 6264091 +1271 6240689 +34 6237906 +1053 6231567 +1123 6220759 +1165 6216478 +1839 6189790 +306 6174365 +1227 6170682 +271 6158328 +2087 6143528 +804 6141406 +1365 6119704 +790 6119691 +1222 6097096 +1528 6093784 +860 6086478 +1718 6080393 +1755 6062347 +304 6058377 +1367 6044404 +418 6021291 +1178 5961986 +273 5944078 +2258 5884266 +921 5875428 +2368 5843037 +1049 5834912 +1444 5825616 +1550 5810506 +1613 5807417 +1625 5806489 +1933 5804564 +3909 5804009 +1315 5793456 +1263 5781210 +412 5780871 +1294 5756002 +1243 5755617 +440 5703257 +288 5696335 +923 5686348 +33 5683530 +4283 5662615 +1542 5657499 +1466 5655969 +2520 5626252 +1737 5617548 +1239 5613802 +1893 5604800 +3502 5592880 +1231 5592559 +805 5586720 +23 5579916 +1422 5562000 +1957 5554673 +21 5545853 +1223 5537815 +1339 5525740 +1439 5518540 +270 5516122 +22 5511292 +1406 5508724 +1751 5500821 +1497 5473031 +1310 5460960 +2237 5456445 +2254 5424602 +3418 5378471 +1366 5362221 +265 5361225 +1541 5359232 +67 5328572 +1637 5322515 +1903 5319711 +1973 5285283 +2938 5283708 +1057 5281356 +1568 5274805 +321 5273108 +2756 5236169 +1830 5223345 +1770 5222102 +65 5208299 +1244 5204410 +1180 5203669 +2098 5169445 +1730 5168645 +2056 5168496 +3349 5156053 +2055 5138614 +2807 5130949 +1101 5123031 +66 5103752 +1816 5093006 +1400 5076411 +1498 5071579 +1642 5055917 +1989 5044992 +1290 5034040 +2643 5023350 +2097 5022728 +1762 5015331 +44 5015012 +479 5008250 +1775 5005597 +2706 5005225 +1909 4997835 +1866 4990678 +1566 4981122 +1336 4950527 +757 4941775 +2063 4937397 +2648 4929257 +293 4925771 +1464 4911409 +2184 4905422 +75 4894914 +392 4889056 +1487 4877439 +1064 4865397 +24 4854296 +1080 4852641 +569 4850805 +1971 4849650 +1605 4847284 +1182 4846260 +1938 4828745 +857 4805157 +1535 4772487 +285 4766512 +1176 4764682 +966 4760238 +2277 4743915 +764 4731348 +1377 4728044 +1479 4720640 +1539 4714734 +1085 4700915 +1811 4696785 +2274 4657189 +869 4652756 +45 4649060 +1099 4644445 +1394 4638480 +1280 4637662 +3000 4618471 +1577 4618338 +544 4614094 +2805 4608260 +35 4606393 +2351 4602990 +1629 4586377 +1661 4584310 +2003 4567755 +49 4546496 +1478 4546419 +2795 4542206 +2828 4536638 +1248 4526225 +1593 4511113 +69 4502347 +2457 4489997 +1511 4484539 +1881 4472447 +47 4460868 +1708 4455874 +1097 4450969 +1551 4445924 +1660 4433465 +1785 4424736 +1627 4412038 +1445 4401529 +2594 4393865 +1719 4389889 +1649 4380458 +2444 4375390 +4287 4371881 +417 4370421 +716 4365322 +1168 4364296 +1735 4360877 +1621 4331683 +2233 4330036 +3249 4325097 +42 4320291 +1276 4314178 +1829 4314165 +1884 4312560 +38 4306679 +2555 4304404 +2084 4296432 +2151 4287967 +1688 4285173 +2831 4280062 +1342 4276707 +1270 4239023 +555 4236623 +1327 4234882 +2139 4227635 +1467 4219535 +2045 4208129 +2714 4198810 +303 4195216 +1771 4185532 +2901 4181081 +2077 4179380 +1863 4178336 +1965 4175165 +2067 4175032 +1716 4169486 +2651 4155215 +2267 4147302 +2607 4145837 +1964 4133545 +1462 4126396 +1978 4126179 +1972 4121510 +1410 4119035 +1679 4106021 +51 4105433 +1871 4105196 +2406 4102924 +2551 4097217 +2008 4097102 +1853 4093083 +70 4092580 +2293 4087207 +2324 4083845 +43 4083418 +1337 4082770 +1813 4079395 +1695 4077362 +960 4077221 +264 4076617 +2688 4072140 +1183 4070745 +1414 4064159 +1474 4057078 +2282 4053024 +3414 4042308 +1430 4037596 +3035 4031658 +1103 4018655 +2059 4015508 +2080 4011218 +2969 4005397 +1919 4000144 +1969 3997080 +316 3993493 +1459 3984707 +1521 3978369 +37 3969953 +1675 3968119 +3009 3965772 +996 3965252 +1596 3943972 +2263 3941497 +3457 3938197 +1450 3937663 +86 3925608 +2058 3919358 +1636 3917053 +1804 3911665 +1429 3909332 +1757 3906464 +354 3891128 +405 3889614 +3176 3888837 +1877 3882885 +1576 3878715 +2893 3873729 +2252 3872753 +1281 3863057 +1254 3862011 +301 3858937 +1048 3852378 +3203 3851712 +2159 3847206 +1626 3842112 +324 3832573 +1760 3832298 +1169 3818301 +2739 3816048 +1687 3814765 +1595 3811813 +1517 3803324 +2260 3791037 +1693 3787455 +1262 3785788 +2102 3779927 +291 3777762 +1923 3777288 +1700 3776768 +2157 3771717 +1378 3757930 +2732 3755186 +79 3754633 +1854 3745778 +3269 3737875 +1502 3737616 +685 3723444 +4200 3719859 +1865 3719356 +128 3715003 +1402 3710786 +2168 3703789 +1986 3699485 +1867 3696280 +2026 3695382 +1683 3694355 +2961 3691575 +1842 3680139 +929 3678416 +2489 3665779 +1052 3661007 +396 3659796 +3329 3643884 +2669 3638778 +1862 3622381 +3452 3605249 +3794 3602291 +2111 3590156 +2046 3587528 +2957 3581398 +1913 3580361 +1441 3577048 +1241 3568130 +46 3565250 +2811 3562952 +2278 3561460 +1998 3550042 +461 3548528 +1744 3532659 +1975 3526648 +2291 3521569 +3056 3518738 +2904 3518633 +1752 3511388 +1900 3510560 +2626 3506312 +1654 3504513 +385 3502364 +2745 3487380 +2057 3487072 +3136 3485766 +7955 3485171 +4139 3481632 +2415 3480433 +2148 3480049 +1628 3467067 +2071 3466219 +2107 3463315 +940 3460357 +1598 3457691 +258 3455533 +1575 3454361 +2826 3452135 +2716 3449165 +3985 3445703 +85 3445461 +1987 3443747 +3598 3439871 +3352 3431656 +2478 3424520 +333 3421332 +246 3418219 +2620 3415717 +1212 3412196 +2450 3409727 +1247 3405540 +1912 3399689 +36 3395391 +346 3391001 +3426 3380470 +3298 3379545 +3292 3377200 +2250 3371380 +2440 3369691 +3061 3367419 +39 3363104 +978 3353736 +1802 3350527 +2431 3348906 +3071 3340128 +2253 3337972 +2494 3334848 +609 3333865 +2310 3329148 +986 3328812 +2635 3325356 +3437 3320853 +2292 3319741 +2823 3308131 +1588 3303360 +269 3302371 +275 3284415 +60 3282646 +2428 3276582 +1918 3276387 +2615 3273427 +2472 3272517 +1690 3267675 +410 3265844 +2678 3262749 +2106 3260749 +2354 3251238 +2717 3247356 +678 3244526 +1109 3242666 +3334 3241700 +3451 3238451 +320 3236458 +3230 3233294 +3389 3229315 +2166 3227294 +1611 3224985 +1994 3213613 +430 3209260 +2986 3199943 +1790 3194716 +1438 3193856 +4784 3192749 +1781 3170903 +302 3166428 +2227 3162561 +54 3145229 +2693 3138924 +1393 3138049 +2597 3137970 +2482 3137124 +3034 3122439 +1946 3121857 +2863 3119047 +3267 3115876 +2041 3113770 +1743 3107914 +2476 3105231 +388 3102434 +300 3100235 +3186 3098789 +1729 3098376 +2488 3094662 +5018 3092842 +4058 3079283 +2156 3078111 +52 3074167 +3096 3072323 +1468 3071877 +2497 3070835 +2793 3050336 +3427 3047066 +1630 3040837 +3284 3037800 +3624 3034708 +2650 3033943 +2785 3033180 +1807 3027961 +3645 3026379 +2691 3025436 +3106 3024747 +3037 3023165 +3759 3023164 +312 3020879 +1767 3018684 +2526 3018183 +666 3015679 +3139 3012306 +3085 3009667 +2223 3002610 +4041 3002353 +2712 3001744 +1838 2997522 +2048 2983869 +2854 2981556 +2534 2972131 +308 2969299 +2646 2967019 +3016 2965071 +3337 2960427 +3187 2957831 +4912 2956818 +3331 2956176 +1643 2956098 +2722 2953729 +2932 2951114 +2422 2950537 +2399 2948398 +500 2946582 +4039 2945677 +3961 2944538 +2222 2943764 +3078 2943739 +4275 2942029 +1724 2934719 +911 2931322 +3296 2930626 +384 2925764 +2319 2924706 +1238 2912540 +1911 2911206 +53 2910401 +2005 2910213 +2923 2909079 +1303 2908146 +4536 2904452 +2921 2898494 +3530 2896507 +343 2894182 +575 2892577 +3058 2891202 +277 2889780 +323 2886056 +710 2881312 +660 2874230 +1949 2873478 +3250 2868743 +225 2861798 +41 2858852 +1808 2848588 +1021 2846040 +3773 2842914 +7713 2841920 +540 2838877 +2137 2837279 +2750 2836122 +3271 2833311 +2994 2832696 +397 2832081 +2174 2831245 +2630 2825882 +1073 2823768 +378 2822150 +2491 2819311 +403 2817676 +2540 2811122 +2060 2808168 +2214 2807667 +2242 2804699 +3554 2801970 +266 2800975 +3442 2799863 +5544 2795504 +1682 2795443 +1351 2777650 +297 2776601 +3155 2770111 +2050 2768526 +3466 2759754 +1544 2759525 +993 2754965 +3340 2752396 +8591 2751808 +1255 2750444 +1895 2750214 +3015 2746600 +3125 2744902 +3945 2744846 +6426 2744124 +2897 2740354 +1309 2739832 +959 2737933 +2822 2737646 +1368 2733555 +2042 2730078 +374 2728295 +3006 2714274 +2245 2700521 +2928 2694744 +2872 2687504 +4896 2686827 +4297 2685685 +2766 2685288 +444 2682283 +2888 2681984 +1200 2679658 +2975 2678829 +377 2675721 +1988 2675064 +2523 2673705 +1583 2671163 +1024 2667070 +415 2666262 +3576 2658993 +2119 2657291 +2647 2648808 +3227 2648233 +1997 2646862 +4081 2645756 +4094 2645293 +1633 2637801 +1917 2637232 +2276 2635825 +2492 2634522 +1312 2634263 +2839 2633915 +2592 2632902 +3662 2624861 +3224 2624698 +1766 2624083 +3663 2624035 +1745 2621047 +5 2620736 +2300 2619855 +4664 2619338 +3430 2619137 +2130 2618208 +6184 2618030 +3687 2611608 +13130 2607739 +2637 2602497 +2622 2597101 +3700 2596588 +2435 2591941 +2158 2587673 +2279 2584888 +2506 2577787 +3724 2574566 +2950 2573209 +2460 2568568 +2125 2566267 +2861 2562749 +1134 2549917 +5454 2544616 +3751 2536696 +1858 2535706 +2579 2530192 +1826 2529534 +2608 2528860 +2681 2527523 +56 2526960 +3814 2525489 +4332 2524158 +2735 2523828 +3367 2523419 +2272 2516165 +3756 2511014 +2585 2509794 +5041 2503584 +4248 2503218 +2802 2502456 +2180 2500659 +3482 2499158 +3899 2496197 +2666 2495174 +395 2490074 +368 2486179 +1976 2484836 +2773 2481413 +669 2475721 +448 2470404 +1314 2468787 +1175 2466968 +3052 2465830 +3491 2465693 +55 2458697 +305 2457793 +2496 2455621 +2241 2454504 +1210 2453199 +2031 2450641 +3111 2447239 +2568 2446982 +7781 2446876 +1635 2445064 +2582 2444049 +2613 2443100 +3195 2441989 +5079 2432713 +2211 2428055 +3234 2426818 +4037 2426428 +1549 2425595 +5991 2421705 +4495 2417713 +952 2416570 +267 2415840 +2458 2414786 +328 2414598 +3790 2413453 +2641 2411736 +1296 2408790 +3199 2407660 +3072 2407258 +763 2402573 +2742 2402326 +4640 2400825 +1907 2399123 +654 2395466 +2911 2394784 +3931 2392276 +3818 2385503 +4346 2385039 +3119 2384203 +31 2383468 +1492 2381026 +3397 2380456 +3484 2379083 +330 2378895 +4706 2377588 +2251 2376885 +2479 2374155 +3053 2371784 +5939 2368766 +1388 2368606 +1692 2366880 +1908 2363611 +4542 2356967 +3596 2356312 +1122 2352389 +5003 2349430 +2962 2349359 +1607 2349127 +3047 2347321 +2627 2346853 +3025 2342305 +2995 2337450 +2835 2335936 +1004 2333657 +3214 2332768 +2029 2332229 +13440 2330317 +1561 2324920 +3074 2315814 +380 2312070 +515 2311421 +365 2310632 +3382 2306041 +363 2305310 +3160 2304973 +296 2303562 +435 2300111 +3512 2297054 +3747 2295650 +1334 2294588 +4281 2294310 +2614 2292185 +2524 2284943 +3394 2281882 +3095 2281714 +2147 2281124 +2187 2279131 +2855 2275319 +2702 2272741 +3517 2271280 +325 2268773 +3520 2268531 +1065 2264589 +3215 2261296 +4395 2260201 +2652 2259754 +1120 2259547 +648 2258982 +4436 2257188 +2089 2255914 +2209 2255859 +4969 2249342 +3022 2248989 +4530 2248944 +2330 2247322 +3261 2246707 +1532 2245244 +12042 2243318 +2270 2243237 +1657 2239438 +2846 2238923 +3999 2237519 +3845 2237334 +2271 2233955 +2126 2233086 +499 2231417 +1659 2229762 +5193 2228394 +3688 2226618 +1382 2226353 +446 2225805 +818 2224123 +2092 2222423 +3623 2220823 +5373 2220082 +2321 2219693 +5057 2219662 +1526 2219349 +5169 2218821 +2912 2217212 +3220 2216122 +3315 2215806 +2808 2214953 +2365 2214929 +2628 2212471 +3805 2211616 +2121 2211232 +1560 2204752 +3259 2204036 +3240 2203146 +2634 2202115 +3656 2200682 +2683 2199255 +3767 2197871 +2612 2193603 +1138 2190750 +3181 2189669 +4193 2189626 +3162 2186721 +2239 2185546 +2988 2185413 +2589 2185214 +1720 2185135 +2192 2184857 +4387 2184827 +4038 2180149 +4492 2178553 +1249 2178508 +3599 2177234 +3988 2176292 +4519 2175412 +2010 2173733 +3965 2173661 +4149 2170484 +3833 2170048 +3017 2169734 +1100 2168903 +4884 2168582 +349 2167597 +2035 2164690 +4040 2163330 +3407 2162686 +3415 2161099 +680 2159475 +1399 2158929 +4661 2157800 +1228 2155490 +551 2154941 +87 2154822 +4376 2154446 +559 2153394 +2392 2153055 +315 2150386 +2342 2150379 +3936 2150034 +1639 2148662 +2837 2143071 +358 2142250 +5153 2141503 +3793 2139387 +2940 2139279 +3126 2139153 +8358 2138790 +1477 2137623 +2720 2137372 +2138 2135247 +5085 2134103 +3957 2132520 +662 2131237 +3432 2125446 +2663 2125055 +8428 2121327 +2408 2121234 +1051 2121150 +3012 2120925 +3740 2120211 +3362 2118913 +2877 2111347 +820 2109304 +1195 2108223 +528 2107435 +2297 2104723 +1956 2104400 +2990 2101876 +5567 2098776 +62 2098771 +2312 2098237 +1570 2097507 +4086 2094834 +1738 2094385 +3142 2094215 +4505 2092752 +1031 2081290 +797 2079864 +2900 2079818 +1157 2079615 +3277 2079046 +3492 2078225 +1803 2078060 +4466 2077826 +4445 2076000 +5953 2074891 +4172 2072344 +2383 2070424 +3274 2062552 +2405 2061430 +474 2059389 +4539 2058329 +5371 2054600 +2753 2053126 +3377 2051234 +2884 2050465 +313 2048274 +1437 2048095 +1495 2047894 +1044 2047797 +1672 2046882 +4773 2046230 +3128 2045207 +4444 2043458 +439 2043235 +12637 2038256 +5692 2037358 +504 2035309 +3307 2032332 +2323 2031475 +2495 2028884 +4196 2027995 +341 2026813 +4176 2023899 +5834 2020359 +4744 2020302 +2563 2016917 +2882 2013222 +505 2010517 +3707 2009054 +1612 2007764 +4652 2006805 +2687 2006766 +5342 1994135 +3670 1992183 +4375 1990482 +2761 1988748 +4756 1987768 +3403 1986706 +2266 1985660 +3066 1985309 +129 1983048 +4481 1981282 +4354 1979172 +2033 1978125 +4576 1977385 +1943 1973375 +2370 1972674 +2486 1971043 +3090 1969680 +2810 1969527 +5401 1967900 +4381 1967895 +3800 1966998 +641 1966963 +2776 1966928 +3611 1965109 +6567 1965030 +3710 1963705 +803 1963552 +1332 1963452 +1600 1962893 +5442 1959629 +2936 1959617 +2723 1956891 +57 1956274 +2331 1955550 +2728 1955126 +4266 1954189 +3708 1952903 +4155 1951761 +3236 1951553 +2011 1949390 +3893 1944470 +3715 1943834 +3501 1942268 +3641 1942249 +3967 1941157 +5695 1939245 +3946 1939135 +1848 1938862 +2982 1935927 +3081 1935780 +2842 1935540 +3393 1929631 +4409 1927034 +533 1926581 +1208 1925558 +6123 1924601 +3328 1919903 +3073 1919157 +5478 1915260 +3690 1915130 +992 1914387 +3519 1914014 +3677 1913098 +4479 1909848 +5555 1908826 +353 1908475 +2952 1907503 +1374 1906721 +2972 1906704 +3151 1906344 +2298 1905945 +5047 1905773 +2407 1905690 +298 1904852 +80 1903294 +1040 1903278 +4590 1902254 +1833 1899229 +5595 1897899 +4251 1897347 +2610 1895735 +2724 1894339 +3626 1892750 +4244 1890732 +4318 1889199 +4957 1886758 +2775 1885004 +5095 1881967 +4721 1880372 +7198 1879205 +3892 1878736 +1558 1875025 +3884 1874312 +3942 1869131 +3206 1868585 +2499 1868244 +2562 1867987 +1507 1866658 +4838 1862252 +289 1862164 +1645 1859225 +2700 1855499 +1754 1855200 +3772 1851086 +4888 1850666 +4045 1848988 +3867 1847435 +157 1843867 +4493 1842927 +2619 1838354 +4786 1836011 +1398 1834121 +3088 1832988 +4120 1831679 +2695 1831610 +5665 1829988 +3381 1828595 +2427 1828369 +4452 1825877 +4477 1823113 +2974 1821399 +6672 1821145 +1814 1821079 +5466 1821016 +4639 1820572 +1265 1819995 +2314 1818041 +1008 1816897 +437 1815421 +3423 1814262 +3245 1812767 +3650 1811355 +2503 1810984 +1728 1810732 +2116 1810704 +8872 1806001 +2332 1805620 +2968 1804542 +1061 1803718 +4581 1802885 +1525 1802513 +3888 1799212 +2925 1794822 +2727 1794109 +1302 1794082 +4560 1793094 +3114 1791585 +3513 1791504 +709 1790178 +4783 1789889 +4488 1789224 +2832 1789080 +2746 1788885 +5652 1787699 +331 1785106 +4865 1784176 +3739 1782930 +4586 1782099 +3877 1780375 +5059 1780266 +2869 1779960 +4485 1778625 +6130 1774579 +3940 1772616 +4271 1768597 +2985 1768596 +4918 1768371 +5030 1768004 +220 1767607 +280 1766245 +1872 1766073 +3706 1765293 +1545 1759778 +5267 1758636 +3761 1757768 +5491 1757560 +2104 1756508 +7313 1756194 +4054 1755775 +2574 1753800 +3667 1753746 +3651 1753739 +4405 1752238 +571 1751391 +4308 1751021 +5437 1750489 +1944 1749114 +1355 1748662 +4274 1746718 +8278 1743712 +578 1742168 +2694 1741205 +2656 1738365 +2636 1738002 +4513 1737002 +2185 1736027 +5449 1728990 +2813 1728933 +2993 1728096 +2587 1728026 +615 1727522 +4881 1726170 +4776 1724711 +2565 1724643 +2726 1722884 +4999 1718878 +3098 1718690 +3685 1717832 +2987 1717445 +1559 1716265 +10205 1715772 +3486 1713237 +427 1712990 +2583 1712089 +4995 1711510 +3871 1710985 +5134 1710681 +4902 1710660 +4602 1710486 +620 1710125 +5537 1709921 +3170 1709734 +1892 1706520 +3173 1705945 +2073 1704583 +5011 1703887 +2346 1703108 +786 1702332 +4059 1699595 +1844 1697348 +295 1696098 +4473 1694758 +4696 1694438 +4280 1692697 +3241 1692185 +3067 1691819 +5694 1688571 +563 1687198 +4987 1687182 +2000 1686158 +1982 1680689 +4317 1679080 +2800 1678829 +2743 1676341 +3782 1676203 +4136 1675550 +4141 1675316 +3011 1674431 +404 1671943 +4508 1671300 +3848 1671224 +6341 1671141 +1486 1670636 +3338 1670469 +4394 1670223 +3357 1669888 +3226 1669751 +6557 1668766 +1359 1668112 +2081 1664853 +2364 1664159 +3146 1663984 +1257 1663233 +2193 1661698 +3294 1659449 +1148 1658760 +411 1658023 +874 1655097 +2219 1654452 +1143 1654129 +4427 1653889 +5583 1651423 +3954 1651313 +2779 1651054 +3216 1650840 +5396 1650681 +2150 1649743 +3127 1647955 +4373 1645141 +3164 1644786 +1433 1644622 +5201 1644557 +2423 1643559 +2672 1641242 +598 1640066 +1869 1639116 +3926 1637219 +6956 1635903 +4390 1635697 +1485 1635611 +6180 1633463 +4186 1632566 +11033 1632005 +10575 1631124 +5398 1630774 +4152 1630130 +6523 1629814 +2708 1628267 +3371 1627540 +4842 1624633 +3807 1624226 +1415 1621531 +414 1620770 +3386 1620487 +5180 1618946 +4956 1618827 +3033 1618817 +4854 1618654 +1395 1617375 +4418 1616971 +3275 1614077 +496 1613939 +4367 1612988 +3115 1611458 +4138 1611246 +707 1609966 +3941 1609655 +943 1608211 +4689 1605650 +541 1602489 +1220 1600656 +5856 1600558 +3465 1599819 +2014 1599485 +2642 1597905 +361 1597790 +3804 1596713 +4930 1595012 +4656 1594232 +4032 1591856 +2094 1591768 +4486 1590377 +3850 1589189 +3417 1587932 +4068 1587210 +6484 1587158 +3573 1586303 +751 1584930 +5273 1584119 +1001 1582810 +4511 1582438 +1350 1582111 +5682 1581323 +5701 1579275 +3750 1578369 +1215 1578106 +1288 1575560 +6443 1574356 +2456 1574032 +4305 1572178 +6786 1570930 +1722 1567616 +5070 1564834 +2391 1563465 +5229 1561859 +4992 1560941 +5828 1560570 +689 1560524 +1000 1560250 +3469 1559413 +3 1558890 +375 1558286 +4789 1557386 +3288 1557204 +5361 1556430 +829 1555089 +602 1553100 +6502 1552435 +3869 1550400 +482 1550363 +3769 1550026 +7 1548704 +695 1548541 +2221 1548436 +3615 1544415 +1891 1544125 +6186 1543528 +1129 1542997 +3741 1540855 +3412 1539970 +2198 1539205 +6193 1536595 +4009 1535736 +3923 1530812 +1879 1530386 +4137 1528607 +4502 1527678 +2513 1527637 +506 1527207 +5717 1527072 +4796 1526999 +5611 1525342 +4438 1524952 +7324 1524876 +5103 1524376 +3932 1523931 +4983 1523249 +2644 1522609 +3354 1522133 +4890 1521795 +3730 1521634 +42159 1521590 +1077 1521212 +1203 1518704 +5531 1515641 +4606 1515536 +3218 1515150 +6745 1513200 +5006 1513115 +5890 1512226 +5052 1511945 +4970 1510725 +6714 1508429 +4030 1506853 +1245 1505561 +3675 1504974 +4426 1504340 +3375 1503790 +3177 1503516 +382 1502511 +39711 1501599 +336 1500357 +1961 1499155 +3504 1498266 +5298 1496420 +732 1496386 +4752 1496009 +2879 1495099 +4260 1494843 +1041 1494107 +4746 1494014 +2556 1493772 +2074 1493385 +8734 1492850 +4979 1492643 +5510 1489374 +3521 1488249 +3812 1487987 +2989 1487864 +1537 1487614 +4219 1485195 +6686 1483477 +2504 1482854 +3584 1481993 +4568 1481365 +3421 1481356 +4237 1481211 +4814 1480648 +334 1479315 +3439 1479269 +3002 1477903 +1417 1477126 +930 1475368 +322 1474128 +1546 1473723 +4647 1473119 +488 1473092 +4073 1473078 +7024 1472792 +1531 1472346 +1797 1471634 +3625 1471454 +2409 1470321 +2196 1468500 +1663 1466759 +5672 1466160 +3689 1465868 +1981 1465495 +2858 1464549 +5199 1464208 +6916 1463903 +3574 1462903 +525 1461357 +3301 1459805 +3341 1459758 +1805 1458557 +2677 1458359 +6821 1458176 +3443 1458132 +4523 1457686 +1821 1456407 +8064 1455853 +2485 1453972 +7648 1453898 +8549 1453728 +3701 1452597 +344 1452384 +5471 1451483 +434 1451045 +624 1450197 +386 1449819 +719 1449119 +3859 1448585 +3092 1447520 +5166 1447492 +5323 1447286 +4585 1446385 +560 1444813 +4056 1444800 +7530 1442047 +3049 1440630 +5399 1440467 +1810 1439368 +39883 1438860 +4619 1438062 +6047 1437307 +4100 1435643 +4403 1435094 +6233 1434841 +4875 1431868 +2215 1430928 +518 1430530 +6798 1430070 +4379 1429963 +2191 1429101 +5212 1428466 +5926 1426982 +3726 1426439 +5127 1425739 +4608 1425400 +3770 1423320 +684 1423301 +3399 1423143 +549 1422979 +1471 1422620 +1326 1422545 +4034 1422191 +4414 1421600 +5260 1421418 +3285 1421044 +4671 1419983 +4388 1419806 +2329 1419508 +3117 1418665 +2512 1418078 +3614 1417918 +5296 1417278 +4380 1416914 +4691 1415979 +1242 1415603 +1042 1415013 +3094 1413700 +3059 1413465 +4019 1411855 +5658 1410605 +4101 1410072 +14420 1409152 +2576 1408914 +7229 1406591 +6095 1406131 +3729 1402106 +6168 1401550 +5535 1401292 +5348 1399444 +3131 1399224 +3050 1399104 +1108 1399004 +4769 1398370 +516 1395487 +5802 1392661 +671 1392187 +5175 1391611 +12216 1390973 +2141 1390969 +3764 1390483 +5158 1389181 +4504 1386980 +2546 1384925 +4301 1384339 +10767 1383934 +6011 1383767 +1793 1383582 +4809 1380537 +2443 1380319 +372 1379345 +2769 1378891 +3822 1378669 +4065 1378474 +7092 1378135 +576 1377793 +8060 1377625 +5150 1375001 +391 1374575 +6246 1374163 +5618 1372598 +4392 1372508 +442 1371294 +2372 1370549 +7636 1368619 +4734 1367530 +2679 1367016 +4811 1365243 +5068 1363461 +2751 1362395 +4986 1361444 +48 1361374 +7638 1360237 +3064 1359735 +9747 1358672 +5747 1358332 +2947 1357419 +2692 1356699 +3613 1356588 +912 1355680 +359 1353287 +4268 1353229 +10395 1351988 +4650 1350702 +3368 1350513 +939 1350079 +452 1349984 +2465 1349409 +4006 1347932 +5710 1347611 +3420 1346666 +5410 1346311 +557 1346053 +2657 1345538 +3562 1344045 +4646 1343369 +1565 1343288 +791 1342812 +3841 1342808 +3244 1342552 +8301 1340601 +15069 1340247 +6290 1339930 +5780 1339030 +5928 1338936 +2231 1338201 +469 1338045 +5123 1337766 +4046 1337492 +1370 1337438 +5742 1336548 +6027 1336530 +3895 1335611 +463 1334739 +2099 1333298 +2763 1332891 +5094 1332269 +6592 1330873 +5096 1330694 +3434 1330495 +11421 1330487 +11092 1330119 +4133 1329427 +2611 1328981 +1701 1328763 +1703 1326543 +2362 1326290 +4574 1325119 +6136 1323601 +1954 1320496 +6334 1318454 +8464 1316365 +2910 1316215 +5093 1315678 +3158 1315478 +5156 1314587 +4314 1314066 +4341 1314003 +409 1313875 +5054 1312722 +4326 1312569 +3327 1311762 +4587 1310546 +7994 1310530 +3436 1310399 +1634 1309798 +4787 1308208 +3842 1307129 +3336 1303877 +1453 1303867 +527 1303388 +3819 1302492 +4870 1302035 +1711 1301722 +4736 1301545 +3280 1301512 +485 1300709 +3938 1300533 +988 1299815 +1023 1299461 +5197 1298056 +3691 1298022 +3785 1297957 +3265 1296350 +2398 1296348 +6729 1296290 +5033 1295463 +3409 1294973 +5913 1291479 +4654 1290537 +7630 1288623 +3709 1286675 +6376 1286193 +3781 1285807 +7756 1285579 +10171 1285322 +2818 1284996 +1014 1282901 +4097 1282603 +4813 1282045 +3038 1281458 +5341 1281418 +420 1281046 +4955 1280803 +8836 1279703 +1731 1278908 +3636 1278857 +3392 1278431 +7392 1277991 +3194 1276594 +4446 1276547 +4540 1275393 +4099 1274105 +4788 1273253 +4167 1272413 +459 1272249 +1948 1271480 +1640 1270835 +7176 1270571 +4429 1269217 +4042 1269107 +2740 1268901 +5866 1268234 +4737 1267826 +6299 1267725 +8150 1266632 +3099 1265853 +19398 1265684 +1878 1265115 +4893 1265091 +2318 1263652 +5627 1263447 +8909 1263276 +5174 1263166 +2829 1261919 +4688 1261278 +6289 1261136 +4765 1258870 +4525 1258646 +4940 1258077 +433 1257886 +4675 1257299 +3950 1257106 +4334 1255854 +4371 1255469 +4478 1255023 +6459 1254251 +3958 1253900 +5364 1253811 +2327 1253249 +119 1252957 +3264 1252530 +3588 1252368 +1624 1252185 +4885 1251484 +521 1251476 +3607 1251163 +7420 1251114 +3572 1250281 +536 1250114 +6325 1249281 +5140 1249176 +5284 1248712 +1828 1247137 +4978 1245733 +4708 1244437 +6825 1243796 +3968 1241799 +6280 1240647 +6835 1240422 +12052 1240210 +6023 1236586 +1283 1236065 +5804 1235634 +4762 1234227 +2095 1233277 +2447 1232432 +445 1231550 +3734 1231293 +3161 1231023 +3612 1230155 +2638 1229977 +1343 1228431 +6516 1227971 +5137 1227542 +7014 1227326 +6638 1226525 +2275 1225586 +5670 1225366 +15862 1224702 +5426 1222773 +1338 1222222 +4569 1222157 +12499 1221455 +4043 1221352 +2043 1221192 +2581 1221146 +622 1220070 +1547 1219481 +1096 1219401 +5461 1219355 +3657 1219079 +4966 1218169 +1137 1218103 +5366 1217930 +2866 1216988 +3356 1216655 +4641 1215786 +5163 1214894 +1656 1214167 +3825 1213380 +443 1212646 +3863 1212582 +6078 1212500 +2426 1212420 +425 1212037 +647 1211602 +7320 1211287 +1086 1211104 +3568 1210892 +4621 1210058 +5741 1209984 +4763 1209467 +4698 1209089 +2948 1208943 +2461 1208205 +1714 1207871 +7372 1205825 +5689 1205245 +4533 1205189 +3084 1205002 +5112 1204702 +3148 1204416 +4205 1203481 +3933 1202908 +11302 1202825 +7968 1201690 +4410 1200581 +6491 1199580 +6884 1199477 +9027 1199088 +6476 1197258 +2402 1196830 +3272 1196577 +4946 1196366 +1847 1195644 +2068 1195640 +2230 1194751 +5668 1194054 +6841 1193691 +6628 1192538 +5617 1192353 +3704 1192118 +454 1190907 +4113 1190819 +3360 1188180 +3595 1188055 +6388 1186942 +3024 1186481 +5676 1186075 +2616 1185977 +5076 1185573 +6997 1185148 +1573 1184210 +2502 1184197 +3956 1183015 +3306 1182352 +4191 1182121 +2907 1181996 +3758 1181687 +2933 1181593 +12820 1181273 +3505 1181150 +2481 1181067 +4258 1180761 +5339 1179754 +4497 1178907 +4705 1178786 +8424 1178672 +6989 1178672 +7225 1178011 +519 1177463 +5613 1177032 +837 1176942 +4203 1176560 +2736 1176366 +7067 1176283 +726 1175669 +2926 1175583 +5839 1175102 +4028 1175019 +6898 1174845 +46444 1173449 +3518 1172575 +2176 1172215 +3344 1171044 +6682 1170042 +4286 1170039 +4075 1168934 +3925 1168605 +3516 1168434 +7915 1167772 +6314 1167088 +1666 1166890 +6586 1165644 +3896 1164453 +1205 1163886 +4315 1163570 +6717 1163432 +4048 1163167 +6301 1162084 +7281 1161824 +3589 1161761 +1045 1161449 +3335 1160825 +3840 1160664 +4406 1160456 +4330 1160159 +1340 1159444 +871 1158633 +5995 1158628 +3722 1158586 +4618 1158428 +5010 1157604 +4564 1157265 +3190 1156679 +4369 1156412 +4047 1154902 +6342 1154157 +5707 1154075 +4393 1153892 +3355 1153701 +1413 1152770 +6542 1152768 +6447 1152716 +7366 1152389 +5382 1152114 +4683 1151509 +2311 1150108 +2328 1149589 +5179 1149446 +3496 1149070 +4206 1148604 +3748 1146891 +4425 1146252 +5311 1145728 +6702 1145147 +4398 1144278 +3952 1144184 +4795 1143514 +4900 1141559 +6858 1140893 +3348 1140558 +4166 1140194 +7396 1138944 +1277 1138668 +5001 1137748 +3446 1137430 +10662 1136646 +4858 1136361 +3091 1136277 +8783 1135186 +2605 1135155 +3809 1134429 +3251 1134183 +6983 1133029 +4673 1132793 +6025 1131898 +473 1131860 +1582 1131777 +8900 1131533 +5942 1131397 +5448 1131115 +5845 1131004 +3665 1130444 +4153 1129425 +3580 1129156 +6612 1129095 +5394 1129005 +30494 1128381 +421 1128217 +2883 1128149 +6922 1128102 +7044 1128058 +3788 1126787 +591 1126267 +4067 1123860 +4632 1123334 +5871 1122772 +3653 1121714 +6265 1121635 +2061 1121351 +1709 1121162 +3648 1120782 +7172 1120292 +2112 1120153 +2566 1119761 +4165 1119543 +2039 1118103 +4077 1117991 +5213 1117193 +2939 1116899 +9952 1116227 +11214 1115457 +6294 1115417 +6182 1114988 +1236 1114768 +4676 1113847 +14018 1113731 +5818 1113054 +6568 1112793 +3649 1112551 +7945 1111652 +4290 1111506 +11063 1111148 +7478 1110529 +5664 1110127 +2561 1108755 +11419 1108318 +599 1108264 +7055 1107776 +5025 1107245 +4151 1106800 +6699 1106003 +3660 1105998 +5007 1105989 +4753 1105892 +4122 1103755 +3951 1103085 +4819 1103013 +7541 1102865 +6308 1101995 +5081 1101551 +3827 1101551 +6348 1101534 +7025 1101049 +5520 1100898 +4713 1100782 +8406 1099966 +5257 1099287 +3592 1099115 +9689 1098471 +3497 1097861 +4430 1097362 +9912 1097102 +8153 1097019 +6108 1096435 +6154 1096150 +5502 1094500 +7425 1094293 +7127 1093101 +3283 1093034 +4624 1092815 +7000 1092519 +6241 1091967 +17560 1091497 +512 1090181 +5403 1090022 +6081 1088193 +3359 1088146 +3221 1087980 +7082 1087741 +3290 1087438 +1921 1086770 +10169 1085547 +3717 1084848 +4963 1084155 +3487 1083889 +4512 1083842 +781 1083714 +3402 1082905 +1717 1082724 +3297 1082684 +7910 1082114 +6934 1081913 +4914 1080997 +5504 1080481 +7415 1079818 +4441 1079514 +4928 1079417 +1323 1078936 +5764 1078723 +13598 1078487 +5205 1078470 +4747 1078344 +9068 1077920 +18015 1077721 +7008 1077624 +9502 1077051 +3919 1076785 +7939 1076621 +4461 1076561 +6355 1076297 +3026 1074645 +6046 1074406 +453 1073993 +2128 1073157 +3594 1073046 +2149 1072456 +13520 1072257 +5290 1071604 +5675 1070845 +4050 1070287 +5451 1069447 +6643 1069445 +4336 1069141 +431 1068235 +5389 1067211 +1514 1066254 +3424 1065502 +1906 1065274 +5581 1064940 +7504 1064485 +3578 1064180 +3666 1063907 +3744 1063473 +590 1063051 +5370 1062933 +7072 1062318 +9256 1062317 +833 1062017 +5236 1061829 +16462 1060612 +5291 1059433 +4201 1059425 +3777 1059131 +861 1058768 +2356 1058460 +562 1058081 +4831 1056793 +1362 1056283 +11435 1056101 +5637 1055964 +6079 1055924 +495 1055621 +3463 1055372 +1870 1055004 +3597 1054912 +6191 1054492 +4302 1054350 +672 1054156 +6332 1054152 +5538 1054038 +3774 1053925 +4678 1053559 +5852 1052549 +6698 1052045 +694 1052010 +4642 1051966 +2208 1051338 +5252 1050757 +1619 1050376 +4001 1050365 +3970 1050229 +5316 1049898 +6076 1049745 +5170 1049627 +4633 1049406 +6219 1048935 +3318 1048824 +5087 1048697 +5895 1048672 +4499 1048514 +3776 1048447 +5386 1048337 +5203 1047480 +5293 1047160 +4171 1047152 +3159 1047020 +6150 1046461 +8009 1045545 +1268 1044664 +4953 1044482 +5176 1044260 +6272 1043933 +5349 1043837 +7728 1043680 +3953 1043554 +3197 1042977 +6116 1041224 +8886 1040488 +6343 1040295 +5086 1039785 +958 1039594 +831 1039207 +1317 1038938 +893 1037936 +5597 1037832 +9621 1037628 +538 1037073 +501 1036988 +7908 1036807 +6110 1036682 +1899 1036322 +8511 1035818 +5954 1035279 +96 1035250 +6853 1034370 +3350 1033703 +4610 1033561 +2951 1033423 +7124 1033278 +5693 1032803 +7476 1032681 +6288 1031061 +4496 1030906 +4538 1030856 +4771 1029333 +2075 1028886 +2113 1028695 +10390 1028255 +7779 1027567 +507 1027336 +3406 1027246 +7517 1026986 +5395 1026926 +387 1025854 +3252 1025192 +4570 1024225 +4261 1024017 +8092 1023604 +4964 1023023 +2013 1022989 +3918 1022342 +4599 1021950 +5762 1021750 +6995 1021687 +4291 1020561 +5750 1020427 +3586 1020053 +6035 1019853 +4104 1019777 +7802 1018633 +5587 1018578 +1424 1018565 +2344 1017560 +4609 1017207 +4860 1016525 +4365 1016357 +3511 1016197 +4905 1015998 +4025 1015981 +3347 1015669 +7028 1015628 +2078 1015524 +1983 1015352 +3031 1015337 +979 1015312 +9072 1014743 +5122 1014687 +3891 1014111 +5474 1014058 +7880 1013953 +3210 1013783 +568 1013436 +5220 1013406 +4434 1012403 +4697 1011550 +5362 1011498 +3737 1011380 +756 1011159 +5136 1010585 +5242 1010457 +5110 1010415 +5523 1010390 +4908 1010100 +7534 1010030 +3387 1008087 +8063 1007595 +3910 1007470 +701 1007115 +600 1005923 +2425 1005712 +2713 1005668 +4792 1005214 +3806 1004967 +4190 1004836 +798 1004024 +3947 1003824 +1734 1003335 +774 1002962 +49430 1002589 +5859 1001740 +5704 1001278 +4238 1001170 +918 1001111 +4553 1000558 +5031 1000426 +8437 999699 +2246 999417 +4084 998042 +4197 998026 +8545 997343 +9611 996559 +4887 996285 +7865 995676 +4692 995619 +6961 995585 +1404 995563 +4423 995201 +8108 995057 +3450 994841 +4849 994834 +4220 994662 +889 994403 +6914 993625 +3621 993134 +1039 992744 +5938 992199 +715 992013 +1689 991685 +5281 991483 +1482 990745 +4372 990263 +7964 989765 +10123 989614 +3854 989508 +782 988371 +4800 988139 +4439 988074 +7395 987559 +4325 987452 +2448 986794 +1681 986285 +5882 986221 +5891 984558 +6630 984477 +3555 984317 +5733 983370 +6613 982970 +455 982830 +4725 982772 +7943 981571 +2885 981392 +5419 980765 +7374 979270 +4917 978913 +3561 978800 +1078 978520 +4162 978296 +9669 978242 +2815 978236 +1680 978235 +8693 978157 +498 977781 +4422 977129 +2167 976132 +2390 975986 +4931 975803 +4635 975620 +5922 973722 +5115 973595 +4384 973528 +7927 973338 +8031 973073 +424 972909 +896 972209 +1352 972098 +4974 971531 +3716 971410 +5545 971211 +4837 970688 +3105 970602 +3972 969545 +9388 969002 +6151 968990 +5380 968941 +5798 968828 +6848 968442 +5062 968256 +8136 968147 +7291 967583 +3087 967418 +1962 966850 +3894 966452 +10191 966175 +2051 965356 +913 964915 +8047 964868 +4458 964367 +5300 964311 +6994 964187 +3725 962770 +7529 962681 +8121 962545 +5526 961651 +6033 961565 +6466 961557 +4150 961454 +1650 961250 +486 961032 +491 960800 +5745 960709 +8878 959982 +5334 959692 +5045 959526 +7903 959023 +6057 958754 +5749 958063 +8087 958003 +6264 957693 +4004 957171 +9413 956628 +8611 956473 +627 955912 +1219 955395 +3499 954203 +10610 954183 +776 954130 +3404 953636 +7593 952789 +3713 951708 +4694 951700 +5486 951539 +9089 950646 +2389 950463 +10499 950298 +5788 950061 +6926 948694 +4518 948669 +7864 948572 +748 948224 +7606 947933 +1010 947597 +8059 945880 +4571 944428 +16267 944143 +6705 944128 +8674 943230 +4923 942533 +2421 942380 +5556 941699 +4735 941386 +5270 940960 +4202 940146 +5335 937988 +1890 937973 +6088 937822 +4816 937750 +4588 937427 +7452 937286 +1658 937147 +5533 936928 +1616 936623 +7712 935685 +3108 935633 +6205 935469 +7901 935057 +4950 934554 +3619 934220 +419 933976 +3478 933536 +5262 932866 +945 932541 +18840 931723 +5009 930935 +21138 930513 +1772 929479 +4755 929010 +5941 928630 +7133 927505 +6977 927246 +4833 926967 +7018 926786 +6403 926666 +6497 926492 +10247 926122 +6149 925968 +1446 925939 +25370 925871 +5688 925496 +10 925332 +8123 923747 +5989 923482 +1503 922356 +4637 922330 +4634 921904 +12385 921506 +4631 921152 +7628 921120 +413 920921 +7351 919431 +5975 919370 +5091 919110 +7297 918894 +5149 918737 +10330 918368 +12131 918249 +6621 918125 +7403 918086 +7052 917508 +369 917495 +3886 916915 +5125 916460 +2366 916128 +9116 915995 +7137 915749 +4998 915052 +5929 914971 +5585 914915 +3538 914319 +26442 913487 +4710 913429 +7253 913428 +3303 913013 +4457 912882 +40026 912761 +3914 910594 +6793 910482 +6596 910007 +4947 909361 +3122 908576 +7746 908460 +6510 908043 +2890 908025 +2420 907987 +5699 907839 +5402 907697 +8473 907013 +6128 906605 +4451 906397 +2934 906049 +12874 905857 +1677 905839 +5228 904072 +6103 904029 +3835 903727 +4855 903439 +4750 902769 +332 902136 +9475 902096 +9005 901510 +4916 900786 +6464 899911 +3853 899655 +3268 899638 +8602 899334 +2665 899101 +6402 898959 +2744 898743 +4601 898430 +7062 898339 +8785 897821 +567 897616 +10391 897375 +7725 896852 +15320 896741 +5423 896175 +4490 895533 +6416 895290 +5713 895254 +10501 895030 +1432 894640 +9077 894615 +6483 894614 +5586 894579 +4622 894347 +20877 893427 +2079 893154 +623 893020 +4991 892646 +5690 892425 +10618 890849 +12184 890553 +8244 890099 +1780 889484 +1313 889246 +106 888842 +795 888161 +3638 887959 +4353 887887 +10542 887847 +5409 887321 +7546 887173 +2396 886955 +4347 886599 +850 886537 +629 886491 +1128 886222 +6119 886169 +6727 886128 +4236 886028 +3281 885374 +7466 885097 +873 884923 +10830 884441 +4894 884043 +3878 884013 +7389 883818 +2347 883556 +7848 883275 +5223 883182 +3900 883053 +3783 883041 +5982 882775 +5198 882436 +1736 881949 +2393 881816 +2395 881208 +6358 881038 +7683 880486 +8342 880373 +8078 879936 +10371 879935 +8761 879473 +7356 879394 +9604 879106 +6960 878827 +2624 878148 +4684 877919 +3189 877629 +2547 877507 +4920 876005 +5860 875894 +6133 875719 +5230 875515 +3539 875493 +1959 875161 +8292 875055 +6509 874958 +1012 874561 +7611 874327 +6943 874065 +7557 872959 +3977 872862 +4960 872487 +11529 870460 +3632 869034 +2474 868380 +3278 868202 +7261 868159 +5182 867690 +6196 867596 +5322 867298 +5438 867126 +5214 866142 +5836 865387 +7595 864999 +489 864993 +2199 864291 +5017 864182 +3802 864008 +6849 863857 +4929 863148 +5898 862499 +6441 862493 +7118 861461 +12551 861355 +8488 861121 +9141 861100 +1381 860833 +7533 860823 +7458 860382 +10827 860061 +1451 859861 +4615 859080 +4764 859011 +8111 858777 +4324 858591 +7647 858536 +3223 858325 +5055 857740 +4296 857441 +5797 857174 +4351 856996 +5407 856847 +3544 856775 +1795 856495 +1665 856106 +5495 855994 +4257 855834 +8050 855330 +10109 854644 +7022 854557 +7920 854365 +7799 854340 +5608 854336 +5385 854118 +3046 854067 +7194 852548 +16964 852383 +7651 852355 +12379 852095 +4213 851873 +7456 851550 +11695 851095 +7401 851086 +7412 850942 +1586 850652 +5143 850210 +902 849624 +5952 849584 +6200 849045 +11643 848152 +5071 847489 +458 847417 +4547 847319 +6907 847057 +7705 846873 +1341 846615 +10021 846038 +1902 845644 +5479 845479 +14897 844971 +2188 844313 +5455 844072 +4459 843875 +4719 843858 +2959 843654 +595 843545 +3132 843221 +5924 843160 +1232 842710 +10306 842643 +574 842221 +5287 841971 +10728 841811 +441 841635 +7794 841423 +5609 841175 +5867 841140 +9366 840353 +8403 840105 +7585 840023 +6405 840017 +6875 839897 +2834 839591 +4179 839528 +12011 839205 +7433 839201 +4292 839187 +7492 839060 +3851 838918 +747 838741 +4785 838458 +1620 837460 +1710 837330 +4343 836110 +4216 836033 +8185 835422 +4577 835155 +5529 834254 +1475 834211 +8165 834201 +7627 834128 +2836 834105 +5708 834100 +11383 834017 +9138 833943 +9008 832798 +2124 832447 +4168 832285 +6802 831767 +4952 831698 +6716 831649 +7806 831440 +4333 830985 +5295 830546 +4036 830203 +5716 830154 +5615 830060 +3644 829493 +3608 829215 +2238 829204 +1345 828544 +3048 828260 +6142 827480 +10805 827295 +5202 826828 +4620 826416 +7459 825942 +4856 825116 +5811 824590 +4232 824275 +4362 824215 +2937 823809 +8502 823728 +5358 823668 +6155 823643 +8974 823355 +9266 821977 +6215 821613 +573 821459 +4053 820973 +7017 820798 +5911 819328 +3917 819177 +4643 819129 +7868 819089 +9003 818965 +4146 818654 +7463 818425 +6175 818176 +6669 818066 +8366 817761 +6594 817656 +2853 817307 +118 817287 +5264 817284 +7421 817216 +8211 817116 +9692 817105 +6305 816562 +7973 816504 +8810 815781 +7269 815760 +2682 815662 +12516 815187 +7524 814872 +2873 814870 +2154 814832 +2949 814350 +6318 813767 +7244 813673 +497 813572 +10413 813503 +698 813483 +7859 813085 +5043 812590 +4981 812572 +4922 812555 +5004 812273 +8127 812230 +8414 811932 +6240 811897 +12147 811787 +3616 811551 +5776 811486 +9870 811062 +7740 810523 +2091 810014 +2792 809891 +3205 809207 +6622 808813 +5849 808800 +8200 808021 +585 807549 +9470 807304 +9818 807238 +7083 806891 +4082 806605 +4975 806503 +2316 806460 +3551 805935 +6493 805854 +2816 805436 +5350 804945 +4003 804496 +1706 804386 +4695 804360 +8221 804223 +3211 803968 +8708 803949 +5155 803913 +4988 803565 +4874 803237 +10106 802720 +3232 802701 +7732 802397 +5326 802066 +6427 801361 +5631 801279 +6740 800879 +6100 800742 +401 800726 +4803 800624 +6363 800619 +5727 800412 +1127 800086 +9298 800083 +4996 800014 +4106 799519 +487 799506 +4131 799341 +5610 799162 +7121 798834 +6115 798667 +6481 798460 +4829 798303 +3881 797726 +962 797583 +6642 796913 +7139 796371 +4263 795916 +3872 794949 +11957 794566 +4071 794495 +8533 794334 +8919 793766 +8639 793455 +7516 792793 +5873 792586 +6276 792041 +2034 791816 +8796 791720 +5353 791490 +7103 791434 +2548 791227 +8329 791148 +9605 791129 +9953 790868 +8372 790696 +589 790467 +8144 789428 +5221 789411 +7012 789054 +6520 788825 +7831 788498 +844 788331 +1623 788130 +5696 787166 +4645 787122 +7986 787107 +5827 787081 +5445 787003 +5243 786478 +5046 786472 +6330 786159 +5014 786066 +6379 786013 +10636 785808 +917 785162 +3124 784947 +2640 784189 +9725 783553 +9253 783425 +8049 783310 +6538 782938 +5638 782700 +8632 782584 +6807 782551 +721 782040 +16059 781941 +6333 781716 +6074 781638 +5565 781181 +1765 780911 +5810 780630 +3714 780526 +954 780449 +5778 780376 +5789 779996 +1068 779555 +3363 779048 +5593 778906 +3640 778657 +10240 778494 +4289 778292 +5114 778205 +987 778126 +46640 777912 +7413 777318 +7317 776881 +9 776842 +11115 776693 +5021 776583 +5381 776513 +6563 776178 +3753 776103 +2264 776075 +6905 775817 +6936 775626 +6050 775178 +5752 775047 +7064 774442 +4471 774370 +2007 774332 +7099 774232 +10876 773951 +7078 773426 +3963 773066 +6619 772959 +6888 772667 +8536 772525 +6670 772421 +3829 772119 +6198 771881 +14015 770622 +7002 770508 +1018 770301 +4174 770174 +4701 770100 +8395 769730 +2599 769416 +7040 769323 +5612 769037 +7970 769031 +2438 768787 +10749 768289 +8982 768073 +5161 768005 +2453 767894 +7171 767851 +3815 766903 +3996 766842 +5850 766046 +6228 765987 +4899 765434 +7271 765147 +2718 765137 +6235 765125 +8407 765069 +862 765005 +5906 764849 +1187 764634 +8636 764295 +5814 764221 +4096 764076 +1142 764058 +8620 764028 +19809 763246 +6165 763231 +7840 762640 +6614 762319 +11079 761718 +13308 761408 +10799 761174 +1192 761045 +6774 760963 +3683 760869 +2394 760818 +6482 760799 +7823 760780 +1778 760726 +4462 760542 +6131 760457 +6253 760190 +6070 760142 +9436 760093 +5885 759875 +2449 759865 +1556 759355 +2598 759301 +9648 759298 +6692 759148 +8587 759113 +9180 758708 +4889 758705 +6296 758275 +10614 758002 +6623 757773 +1516 757483 +5983 757289 +5963 757079 +9371 756527 +9839 756521 +6190 756459 +457 756319 +7423 756132 +20635 756084 +2451 756028 +8936 755576 +5517 755366 +3001 754873 +2689 754598 +7797 754588 +7411 754253 +5433 753725 +6260 753428 +11618 752903 +7519 752784 +6189 752766 +1931 752571 +11514 752163 +5441 751927 +11356 751848 +6401 751735 +1324 751409 +2339 751243 +5417 750911 +735 750739 +5022 750547 +3908 750126 +3765 750060 +9461 749906 +8282 749744 +778 748051 +3873 747968 +7212 747911 +13423 747877 +6712 746778 +5940 746619 +593 745833 +12787 745585 +8024 744764 +7874 744587 +6204 744070 +5761 743492 +408 743484 +6490 743166 +7800 742528 +5879 742339 +6266 742335 +4320 741518 +2623 741505 +5363 740788 +1017 740736 +7288 740643 +9019 740546 +6870 740253 +6693 740189 +4329 739395 +7404 739189 +4093 738959 +9825 738518 +8857 737741 +10648 737228 +5318 737201 +16175 736827 +6823 736756 +10807 735530 +3535 735395 +2892 735274 +12180 735097 +3023 734685 +5188 734061 +10006 733791 +14549 733714 +33721 733497 +5875 733377 +9087 733374 +5338 732693 +5863 732401 +12785 732355 +4845 732267 +5857 732242 +18293 731947 +4595 731814 +4222 731703 +9500 731638 +9283 731189 +8877 731155 +8470 731144 +6872 730530 +4188 730422 +6225 730269 +5108 730199 +7148 729814 +1581 729749 +10500 729418 +6832 729243 +2920 729192 +6656 728880 +2670 728538 +7312 728480 +4295 728371 +5462 728288 +6339 728140 +3862 727744 +9975 727410 +7188 727311 +5861 727283 +5387 726788 +11761 726787 +634 726665 +5118 726571 +8976 726201 +8838 725568 +744 725461 +342 725294 +7163 725203 +6709 725026 +1146 724457 +9920 724076 +5896 723335 +4781 722493 +4537 722266 +11171 722136 +4433 722080 +8415 722004 +1095 721984 +8036 721541 +8685 720983 +4934 720956 +8879 720855 +8998 719936 +10654 719841 +4760 719610 +6134 719284 +9918 719163 +7897 718765 +11754 718515 +7432 718161 +9951 718152 +5254 717916 +4158 717914 +5186 717844 +20832 717534 +10039 717274 +6626 717236 +1069 716980 +6593 716881 +6085 716690 +9671 716454 +9070 716415 +8663 716353 +10804 715896 +5706 715743 +5359 715340 +27868 715294 +6792 715292 +6741 715229 +9153 715036 +13129 715014 +5044 714833 +6647 714813 +6511 714437 +8100 714414 +13648 714321 +9735 714169 +10964 714150 +22971 713833 +6829 713647 +4249 713298 +5365 712933 +5732 712932 +4143 712823 +5996 712740 +8618 712707 +6073 712606 +5986 712473 +1030 712471 +1461 712265 +5992 712229 +2066 711631 +18841 711614 +9925 711387 +8259 711334 +7205 710271 +11117 710047 +4793 709820 +6478 709698 +3858 709005 +2996 708450 +6430 708208 +4007 707891 +768 707799 +6067 707724 +9320 707652 +1894 707449 +7431 707015 +1509 706866 +14207 706655 +5511 706560 +6553 706382 +4385 706268 +4925 706167 +8096 706036 +6143 705550 +6188 705375 +9764 705084 +13126 704724 +6554 704581 +7394 704389 +5288 704007 +7912 703955 +4483 703878 +8929 703551 +14466 702956 +9071 702931 +8518 702631 +12517 702625 +32290 702438 +8581 702251 +7962 702211 +5719 702082 +5916 701971 +2577 701821 +7328 701292 +3248 700210 +5743 699668 +5457 699547 +6126 699148 +2931 698934 +6323 698857 +7639 698407 +1494 698189 +5846 697622 +2685 697571 +7791 697392 +294 697012 +13100 696907 +5726 696441 +3200 696066 +5946 696036 +7464 695756 +6304 695647 +10504 695601 +7547 695511 +9880 695470 +4572 695347 +14237 695318 +7373 695309 +9477 695162 +6980 695128 +5806 694770 +605 694642 +2998 694435 +7895 694205 +4528 693789 +2749 693766 +5483 693676 +9566 693519 +2580 693316 +10174 693096 +8704 693080 +9909 692938 +21393 692900 +3993 692679 +12262 692396 +10464 692058 +8155 692022 +6817 691879 +2943 691761 +5645 691684 +6576 691662 +8540 691355 +8742 691341 +4116 691092 +5303 690849 +9570 690723 +2380 690285 +11394 690269 +14017 689530 +6809 689244 +6129 688667 +5369 688418 +4345 688195 +5274 688173 +239 687921 +4090 687761 +8072 687681 +5876 687636 +7195 687577 +5667 687373 +1950 686507 +2484 686452 +8179 686263 +6608 686261 +8688 686110 +6279 685683 +10729 685582 +7173 685513 +6687 685094 +6409 684986 +4469 684945 +10604 684560 +6135 684453 +8832 684446 +14708 684416 +1990 684197 +1082 684138 +5566 683609 +5559 683395 +4074 683378 +2256 683376 +2024 683346 +8073 683283 +897 683245 +6173 683136 +7734 682901 +8882 682762 +1855 682313 +5034 682278 +9852 681791 +7624 681768 +6673 681693 +6411 681081 +7364 681064 +4913 681060 +6031 680976 +7344 680890 +6827 680734 +12168 680648 +9591 680619 +7246 680607 +5644 679833 +4069 679756 +7387 679646 +7318 679542 +5456 679522 +1662 679367 +7886 679365 +7977 679346 +14403 679217 +7311 679157 +11947 679007 +7924 678757 +9755 678632 +2436 678453 +947 678119 +7884 678117 +5884 678031 +6662 677968 +7323 677870 +5543 677819 +2919 677816 +10405 677754 +9101 677581 +6093 677515 +7051 677389 +8224 677269 +7337 677160 +2295 677074 +1158 676751 +6844 676610 +5412 676453 +4306 676409 +7224 676369 +7846 676354 +11289 676149 +3237 676053 +4876 675868 +7259 675866 +9754 675784 +7256 675714 +7771 675679 +11534 675527 +8972 675521 +9761 675505 +876 675302 +4159 675287 +22940 674880 +10131 674860 +690 674447 +1904 674392 +1083 673897 +6032 673886 +5101 673784 +3738 672730 +3180 672440 +4391 672381 +10673 672248 +2857 672245 +2001 672175 +9651 671458 +5413 671453 +11133 671373 +8556 671203 +7522 671159 +4270 671110 +3682 670879 +21648 670847 +5933 670801 +11409 670739 +8362 670409 +11287 670223 +7719 670222 +3698 670219 +7016 670090 +613 669934 +5766 669916 +10093 669908 +249 669379 +5157 669251 +4935 668785 +18912 668708 +1589 668686 +6218 668678 +4221 668611 +1533 668559 +6461 668440 +6666 668008 +9679 667710 +5301 667687 +5920 667645 +6041 667255 +10026 667109 +537 666906 +4455 666658 +5787 666453 +6157 666445 +5207 666201 +17846 665807 +8305 665802 +3992 665716 +8592 665686 +2953 665632 +7482 664859 +7485 664609 +3904 664497 +1325 664191 +3955 663800 +3582 663747 +6232 663677 +5858 663380 +6675 663306 +603 663284 +3510 662971 +3198 662873 +6868 661915 +3398 661810 +2662 661713 +5548 661134 +3254 660739 +3435 660236 +3208 660141 +7602 660107 +2944 660028 +6140 660004 +9084 659896 +22346 659867 +8213 659526 +8359 659308 +8987 659019 +4252 658938 +7283 658854 +3188 658518 +11807 658016 +9906 657789 +4088 657734 +7796 657606 +1092 657505 +1431 657491 +9119 657490 +4751 657349 +5539 656930 +8672 656751 +7486 656405 +746 656119 +2705 656036 +6056 655720 +1995 655638 +8589 655599 +10397 655550 +6725 655530 +10242 655020 +7276 654911 +9074 654748 +38913 654696 +7898 654624 +1740 654207 +4327 654145 +7652 653660 +381 653525 +4061 653521 +1671 653489 +1530 653176 +7189 653134 +13430 652994 +4339 652906 +6049 652838 +37707 652638 +825 652479 +7346 652418 +2780 652110 +3113 651930 +5901 651795 +14024 651686 +6555 651683 +9659 651412 +11154 651044 +4836 650886 +10016 650673 +5887 650661 +9118 650642 +7832 650470 +5564 650455 +7334 650225 +10737 650100 +5292 649726 +2984 649605 +5428 649179 +9280 648905 +6952 648709 +920 648620 +19360 648453 +31215 648415 +5894 648264 +5390 648185 +8607 648182 +7030 647962 +5443 647898 +13785 647830 +5603 647672 +5278 647399 +127 647382 +2538 647133 +5330 646394 +7204 645847 +5488 645597 +6082 645495 +9025 645143 +13119 645117 +12673 645054 +5870 644976 +9439 644729 +6531 644334 +5524 643753 +8308 643717 +2049 643595 +3169 643406 +1102 643192 +1416 643014 +4556 642555 +6801 642064 +1452 641982 +4225 641671 +4961 641591 +664 641444 +9899 641281 +7765 641155 +3668 640797 +577 640764 +8345 640747 +5795 640537 +8411 640494 +5621 640471 +6370 640152 +9486 639933 +13089 639843 +5187 639596 +6665 639411 +8335 639410 +8475 639341 +3705 639284 +5302 638828 +9716 638798 +4361 638678 +2047 638657 +10219 638643 +310 638361 +6891 637744 +7011 637600 +3559 637533 +6559 637504 +687 637481 +10071 637167 +5035 637079 +3811 637040 +6292 636820 +7325 636136 +5679 635912 +9992 635639 +5509 635306 +3152 635231 +12074 635104 +9957 634959 +6655 634887 +9016 634863 +7410 634829 +696 634729 +7960 634441 +3876 634388 +2596 633768 +10013 633760 +6163 633090 +7849 632916 +5506 632595 +4727 632496 +2667 632345 +6768 632173 +6616 632141 +11257 632026 +10068 631604 +7123 631579 +7542 631579 +7023 631466 +7720 631250 +6796 631244 +3070 630513 +3256 630499 +2767 630481 +9974 630365 +692 630358 +5549 630267 +6896 630202 +9002 630065 +6923 629920 +15811 629850 +9738 629838 +2891 629691 +4231 629583 +8606 629251 +11823 629198 +9853 628987 +7027 628837 +3991 628805 +2190 628682 +6862 628532 +4939 627964 +14914 627859 +2902 627520 +11615 627385 +4904 627359 +10650 627124 +5279 626755 +7777 626600 +799 626519 +6183 626487 +15113 626346 +1229 626246 +12224 625949 +36826 625284 +2501 625099 +6000 624750 +9326 624573 +8978 624449 +10101 624337 +2514 624302 +11660 624213 +8318 624036 +4562 623978 +1939 623886 +1067 623705 +7981 623554 +8590 623553 +7150 623194 +7216 623063 +6640 623002 +2127 622758 +8237 622309 +4951 622270 +9885 621960 +7830 621930 +6877 621661 +5485 621547 +854 621467 +3342 621167 +5503 621125 +3745 620985 +668 620572 +1850 620506 +7342 620486 +8082 620245 +565 620179 +429 620017 +9739 619828 +4449 619512 +8737 619500 +3182 619289 +10714 618874 +3332 618818 +3901 618659 +3154 618496 +7272 618484 +7953 618134 +5734 617900 +6065 617790 +9847 617491 +5075 617361 +2257 617024 +3865 616847 +4321 616792 +7029 616539 +11897 616236 +7835 616232 +10433 615972 +9617 615869 +5490 615816 +848 615766 +10357 615359 +7810 614764 +8666 614423 +2414 614200 +5501 614089 +6838 613977 +3791 613640 +1505 613292 +11821 612953 +9024 612648 +6298 612576 +8037 612282 +9392 612232 +7444 612155 +11162 612106 +8667 611893 +859 611851 +5514 611662 +7184 611457 +6633 611425 +7625 611246 +6029 611220 +7703 611085 +1167 610976 +1112 610958 +5405 610796 +6097 610555 +5655 610530 +3834 610027 +7077 610008 +8141 609961 +11070 609752 +126 609368 +7697 608871 +3661 608867 +6337 608742 +1653 608691 +8270 608543 +3563 608510 +1173 608225 +8277 608152 +1602 608008 +5527 607857 +8148 607798 +9307 607780 +6087 607464 +3506 607304 +19195 606852 +4962 606712 +5160 606653 +6885 606329 +1522 606222 +4144 606105 +9375 605871 +23997 605838 +7215 605645 +7136 605240 +7696 605204 +5439 604950 +7867 604769 +4417 604529 +6979 604164 +594 603974 +9389 603879 +9730 603658 +11826 603599 +15007 603523 +450 603404 +7784 603393 +12858 603312 +9763 603136 +2560 602954 +8780 602780 +1015 602661 +7219 602594 +11344 602587 +5729 602572 +6550 602536 +5475 602409 +2493 602094 +2305 602075 +10481 601222 +6467 601095 +15855 601040 +11226 600883 +9406 600845 +12104 600838 +3134 600815 +11223 600279 +592 600247 +10273 600115 +10955 599932 +11523 599822 +10329 599458 +6591 599380 +2631 599358 +6536 598751 +9498 597864 +2584 597750 +942 597599 +3312 597138 +6932 596982 +10663 596904 +11582 596881 +1056 596523 +1380 596400 +7406 596161 +10856 595892 +4178 595769 +6918 595606 +7637 595338 +3262 595268 +7309 595160 +8378 595058 +5235 594694 +6373 594645 +7539 594423 +10318 594361 +8720 594360 +10490 594265 +6782 594145 +4627 594120 +4844 594063 +456 594019 +2202 593801 +10512 593750 +1610 593244 +9232 592972 +13837 592565 +6590 592522 +4944 592362 +7174 592237 +3270 591789 +5465 591294 +6958 591198 +7520 590915 +5966 590914 +6004 590867 +6230 590717 +7380 590682 +9273 590639 +7179 590581 +10252 590079 +11232 590075 +10018 589454 +4397 589171 +10553 588862 +11654 588414 +5265 588100 +10307 588072 +7049 587817 +7971 587507 +7370 587415 +2269 587239 +4827 587061 +2178 587040 +28154 586814 +7681 586670 +2777 586647 +704 586590 +2032 586160 +29240 586009 +4303 585944 +6833 585900 +13304 585788 +658 585509 +4259 584968 +11783 584697 +10010 584641 +436 584638 +4044 584624 +5072 584498 +11149 584320 +2999 583791 +6991 583506 +9359 583285 +10319 583073 +8218 583031 +745 582797 +13210 582777 +6147 582612 +8420 582572 +6275 582333 +9784 582289 +2946 582278 +6928 582062 +5016 581857 +5519 581711 +7525 581516 +4638 581509 +28749 581004 +5917 580810 +2367 580376 +9416 580198 +3110 579900 +3837 579873 +10731 579847 +9443 579795 +9279 579534 +12090 579424 +9533 579369 +9046 579350 +3101 579267 +4079 578683 +11763 578236 +15434 577988 +6356 577910 +3944 577882 +10711 577459 +8514 577435 +7441 577388 +524 577286 +34754 577196 +8694 577150 +6518 577063 +8248 577045 +4839 576905 +11343 576880 +8107 576869 +5584 576838 +1211 576832 +5116 576522 +9593 576137 +9512 575883 +5357 575872 +5981 575845 +4091 575497 +14591 575465 +9955 575415 +8090 575406 +6822 575321 +2306 575187 +6755 575130 +7691 575061 +8055 574976 +8215 574691 +7341 574574 +8083 574574 +11687 574439 +6650 574049 +9358 573897 +6834 573740 +3461 573724 +12508 573413 +7192 573384 +15110 573316 +1924 573275 +6496 573211 +794 573111 +5481 573030 +17674 572959 +8547 572682 +6632 572577 +882 572533 +8990 572530 +7043 571991 +2791 571520 +7668 571498 +8732 571494 +4051 571420 +7674 571339 +936 570961 +3721 570900 +3060 570854 +6731 570838 +6317 570838 +11852 570745 +676 570627 +6414 570552 +8848 570361 +3823 570118 +9264 569921 +6840 569894 +4360 569706 +6268 569701 +6776 569555 +7383 569475 +6551 569359 +15319 569196 +8076 569167 +7142 568628 +11416 568580 +5374 568324 +8740 568107 +1455 568100 +6044 567784 +7437 567697 +1443 567507 +6066 567414 +5865 567337 +13104 567326 +4506 567190 +8819 566704 +8528 566670 +6164 566437 +12988 566156 +7093 565967 +3549 565654 +4877 565544 +4312 565286 +6413 565089 +1140 565068 +8774 564935 +4554 564912 +2213 564896 +10808 564748 +5799 564629 +10556 564192 +2430 564111 +253 563468 +8465 563415 +17768 563337 +8962 563249 +3887 563038 +9640 562781 +907 562010 +6886 561513 +7502 561321 +3326 561303 +10607 561199 +480 561037 +1571 560925 +14987 560911 +3755 560808 +522 560722 +8326 560191 +8261 560155 +10043 560098 +451 559924 +8361 559912 +8028 559794 +9594 559778 +545 559407 +31681 559385 +6946 559306 +7108 559275 +2645 559165 +5635 558799 +8302 558731 +6588 558119 +7263 558055 +14935 557913 +9272 557817 +9589 557707 +11745 557593 +3395 557506 +16004 557248 +6861 557017 +8062 557002 +9349 556662 +4031 556646 +8245 556554 +1460 556326 +4579 556319 +5000 556167 +10105 556070 +5215 556063 +10061 556034 +8744 555748 +1435 555400 +8272 555325 +5964 555146 +12767 555106 +9073 554642 +10530 554555 +11663 554385 +3553 554378 +8198 554300 +7034 554151 +2978 553814 +120 553526 +6584 553151 +3861 553102 +1776 553022 +7748 552759 +462 552707 +2123 552637 +1667 552623 +2661 552550 +16009 552434 +9984 552378 +652 552358 +7786 552200 +16407 551865 +11849 551642 +24385 551605 +1357 551592 +9051 551540 +8384 551212 +16974 551193 +12690 551066 +6372 551013 +14100 550991 +22767 550854 +9181 550845 +3980 550594 +3763 550539 +10383 550504 +1501 550432 +9663 550249 +3454 550052 +10764 549946 +11408 549714 +13417 549671 +5238 549218 +4309 549159 +5598 549109 +7175 548618 +3365 548511 +11264 548307 +8759 548096 +1036 547793 +5575 547523 +6099 547457 +1726 547406 +9095 547200 +11016 546805 +6600 546767 +9117 546746 +4724 546694 +4535 546644 +19859 546641 +10085 546192 +11990 545927 +5616 545745 +11867 545469 +558 545369 +12750 545195 +11453 545040 +6007 545014 +4805 544806 +11536 544790 +8381 544636 +12007 544575 +1678 544421 +9354 544408 +5969 544383 +10120 544328 +2004 544322 +9336 544293 +11047 544173 +10656 544121 +9601 543949 +1133 543728 +2771 543554 +948 543517 +7264 543327 +5436 543269 +5253 543261 +2304 543194 +5464 543083 +9935 542754 +13289 542612 +3830 542534 +8826 542457 +12164 542022 +10432 541880 +9691 541784 +5472 541671 +5715 541589 +1799 541522 +8295 541394 +8390 541248 +7384 541184 +4450 541159 +4739 541155 +2945 541039 +9292 541013 +8985 540742 +14039 540629 +4224 540466 +10207 540401 +9687 540209 +14051 540174 +8015 540103 +6393 539847 +6208 539816 +8665 539668 +9176 539559 +2417 539392 +6529 539382 +6678 539231 +1806 538825 +10158 538815 +9308 538759 +9769 538636 +11798 538499 +2686 538256 +30756 538096 +12774 537997 +10202 537811 +20948 537713 +5984 537666 +6034 537532 +5269 537514 +12024 537300 +6016 537023 +3068 536803 +10653 536746 +4544 536720 +47383 536644 +6303 536574 +1670 536539 +9368 536507 +4711 536324 +6688 536289 +11374 536287 +5332 536164 +5415 535772 +686 535624 +12302 535597 +8034 535259 +7298 535243 +5027 534858 +4404 534801 +4993 534397 +4310 534235 +11474 534227 +9179 534109 +3013 533926 +4267 533674 +5947 533656 +6242 533613 +9657 533598 +6971 533518 +8683 533415 +891 533390 +9894 533388 +10278 533319 +1033 533218 +9432 533117 +10935 533048 +955 533045 +6930 532804 +6609 532747 +6216 532571 +863 532480 +10200 532443 +4973 532320 +3388 532276 +8512 532164 +8747 532078 +6754 531928 +1150 531903 +10629 531822 +9634 531776 +6851 531720 +4503 531705 +11520 531460 +2671 530938 +14536 530797 +2040 530459 +4522 530342 +3376 530119 +11366 530088 +8560 529987 +10183 529970 +3913 529729 +27572 529657 +9231 529501 +6006 529484 +12353 529322 +5582 529169 +10936 529025 +11596 528842 +13270 528815 +4778 528726 +1958 528689 +9965 528383 +7996 528093 +5256 527765 +7987 527727 +8724 527617 +12761 527594 +14205 527540 +30101 527445 +2376 527425 +11113 527174 +12108 526987 +7523 526948 +14861 526831 +6769 526760 +10251 526687 +5141 526686 +12056 526659 +11911 526627 +808 526618 +8829 526430 +15142 526406 +7932 526264 +21842 525942 +4269 525894 +11288 525883 +3703 525813 +11661 525338 +1423 525254 +5107 525204 +9038 525200 +7760 525179 +2675 525099 +7214 525047 +7997 524960 +3202 524802 +6611 524696 +1886 524345 +2200 524290 +11565 524211 +9505 524148 +10177 524099 +8391 523969 +4145 523792 +9309 523601 +1098 523601 +28589 523309 +16404 523284 +13663 523201 +11465 523027 +14943 522826 +8227 522727 +728 522579 +10315 522535 +11182 522489 +5711 522363 +9592 522137 +12901 522119 +6842 521979 +7584 521897 +3605 521789 +3459 521714 +7844 521599 +32790 521575 +9489 521286 +6270 521053 +2142 521051 +8203 521013 +5453 521007 +9836 520903 +38387 520845 +5800 520632 +2442 520625 +10763 520466 +5498 520396 +7588 520298 +8584 520208 +1834 520004 +8830 519633 +6440 519510 +3104 519421 +8519 519326 +12980 518862 +10266 518833 +8705 518717 +7507 518708 +3175 518680 +3489 518674 +10290 518362 +5268 518131 +4498 518124 +2845 518039 +7604 518016 +4871 517787 +5640 517709 +2018 517645 +9552 517437 +2025 517381 +7690 517300 +10674 517255 +1084 517164 +1774 516848 +9481 516274 +9558 516120 +11044 516115 +7543 516105 +8054 516100 +14637 516058 +5049 515800 +12989 515724 +6866 515494 +10665 515424 +5340 515194 +5698 515174 +7907 515166 +17329 515143 +4693 515073 +4349 514677 +610 514618 +4958 514534 +9658 514511 +7058 514162 +11279 514146 +5909 513815 +2403 513591 +4273 513532 +5948 513355 +3324 513090 +7622 512788 +4543 512710 +47013 512667 +15994 512605 +16020 512591 +6227 512519 +14167 512493 +122 512466 +6439 512393 +1787 512303 +4810 512061 +6970 511802 +7348 511766 +13419 511721 +3183 511719 +1697 511536 +1346 511242 +6639 511134 +5642 511062 +11372 511039 +7827 511016 +1360 510851 +7841 510829 +1694 510698 +9638 510663 +5967 510625 +6903 510571 +5425 510480 +5931 510406 +856 510365 +16213 510309 +9840 509866 +9114 509800 +6153 509717 +3503 509652 +7663 509651 +2915 509566 +6492 509531 +4859 509528 +3797 508985 +9869 508778 +7498 508579 +7090 508348 +2935 508256 +8061 508150 +5129 508134 +2850 507942 +10346 507712 +8171 507083 +11126 506565 +12313 506541 +8114 506538 +1925 506318 +7265 506203 +10308 506177 +2788 506150 +18355 506070 +6789 505868 +7428 505805 +7739 505672 +335 505540 +4437 505375 +1046 505338 +7505 505231 +1820 505189 +6646 505079 +4847 505035 +7723 504840 +1874 504583 +10769 504401 +6062 504379 +9393 504300 +3609 504287 +8022 504015 +8163 503963 +5662 503954 +4578 503944 +28808 503835 +9733 503821 +4419 503723 +12152 503716 +9584 503534 +7724 503491 +12139 503393 +1225 503219 +12451 503123 +2404 503095 +7161 503020 +38325 502957 +13064 502866 +13959 502619 +16685 502602 +8489 502599 +2801 502372 +8948 502353 +7744 502332 +11301 502329 +18317 502311 +6380 502208 +9554 502166 +10638 502156 +6350 502075 +14395 502028 +733 501896 +11255 501750 +8793 501681 +2704 501584 +7941 501562 +9142 501326 +8766 501173 +7042 501158 +9161 501143 +14316 501138 +1058 501137 +7567 500930 +17215 500926 +7722 500875 +7686 500769 +10009 500732 +8834 500182 +1267 500098 +5194 500074 +12433 499839 +10094 499728 +1153 499598 +10826 499365 +1951 499236 +6378 499083 +10309 498859 +14771 498759 +11563 498613 +7327 498161 +7069 498100 +12274 498050 +9188 497940 +3514 497889 +9859 497683 +4294 497668 +6634 497660 +8616 497651 +14456 497583 +12420 497494 +9262 497418 +1050 497098 +8849 497057 +9337 496804 +8698 496736 +5680 496519 +8714 496340 +6599 496156 +13922 496122 +12783 496080 +13956 496070 +9904 496047 +9469 495805 +9204 495517 +6856 495493 +4282 495458 +8331 495218 +7741 495080 +7876 495033 +13101 494968 +8868 494871 +10102 494813 +6537 494662 +6174 494574 +1006 494209 +11292 493769 +8138 493741 +7417 493306 +7819 493293 +4021 493280 +5069 493031 +1676 492861 +7618 492809 +619 492743 +7111 492488 +13098 492423 +5219 492395 +9549 492153 +1674 492046 +12644 491967 +5657 491932 +9238 491889 +1186 491713 +9247 491667 +6419 491609 +14080 491582 +12506 491546 +7850 491532 +8276 491506 +8319 491476 +7745 491425 +14389 491164 +11725 491143 +6948 491116 +8852 491069 +12557 491017 +2860 490863 +12438 490713 +11938 490511 +17154 490479 +12352 490449 +9209 490055 +6465 489970 +7362 489941 +9456 489939 +3808 489894 +10691 489840 +6118 489617 +3526 489349 +11717 488745 +13553 488681 +570 488430 +8846 488377 +10579 488145 +7667 488138 +9398 488058 +6252 488041 +10816 487804 +9902 487778 +6635 487683 +10986 487574 +12255 487515 +6772 487362 +10409 487277 +4035 487133 +6508 487039 +7578 486957 +38898 486923 +8209 486827 +2301 486497 +8350 486454 +8649 486382 +10226 486188 +7477 486080 +46195 486017 +4761 485991 +6572 485950 +104 485842 +10589 485787 +5368 485706 +11057 485511 +14379 485358 +22306 485315 +10064 485172 +9040 485169 +2439 484771 +1305 484754 +9301 484652 +6295 484648 +2093 484477 +7095 484430 +9465 484269 +8867 484258 +7164 484152 +30772 483866 +8104 483650 +2516 483348 +9559 483026 +4526 482958 +11345 482881 +7632 482880 +6086 482805 +13479 482529 +8018 482355 +4217 482302 +7147 482262 +10277 482204 +12534 482102 +9613 481874 +8922 481792 +7766 481713 +5908 481572 +3260 481497 +2806 481392 +3242 481272 +9103 481197 +6412 481109 +6374 480706 +5816 480672 +2649 480629 +18325 480570 +28244 480558 +4448 480540 +3257 480335 +6947 480290 +12217 480181 +7699 480013 +3433 479977 +9694 479829 +9014 479704 +14200 479703 +6282 479693 +6541 479643 +32009 479575 +8383 479249 +4598 479147 +10209 479146 +9403 479045 +6448 478902 +17692 478863 +7457 478667 +2433 478511 +724 478152 +13045 478149 +7634 478062 +12031 477941 +8565 477889 +6365 477835 +6122 477730 +1569 477700 +8239 477668 +581 477633 +864 477246 +7007 477223 +8971 477114 +10937 477035 +7487 476747 +10596 476592 +11840 476530 +8916 476449 +9276 476256 +8676 476237 +2163 476190 +875 476049 +12996 475823 +4531 475813 +11467 475808 +3771 475740 +5625 475421 +16987 475263 +10704 475232 +36430 474914 +4377 474829 +10503 474740 +10810 474711 +9759 474548 +13189 474527 +17944 474409 +4130 474295 +25650 474213 +2606 474053 +11448 473925 +6159 473703 +7552 473678 +956 473675 +2019 473515 +4304 473492 +13347 473405 +1299 473258 +8507 473017 +10930 472996 +6209 472990 +1590 472948 +6507 472885 +12155 472759 +10401 472745 +12087 472716 +6026 472567 +8847 472500 +5184 472211 +8286 472197 +9544 472194 +6105 472192 +11231 471976 +12696 471900 +9317 471819 +4625 471755 +9327 471505 +7473 470986 +2840 470738 +8197 470623 +14780 470281 +12946 470152 +3813 469939 +12382 469887 +5308 469869 +10382 469852 +17662 469530 +13509 469357 +5650 469084 +7274 468913 +3537 468876 +6512 468810 +8466 468776 +16693 468472 +4767 468256 +8461 468202 +13285 468151 +729 468066 +2737 467943 +6654 467872 +2543 467645 +539 467455 +7169 467379 +21003 467300 +7675 467213 +12815 467106 +14138 466738 +3166 466697 +5739 466627 +6177 466578 +1898 466078 +30251 465915 +7881 465902 +9772 465804 +13312 465503 +19646 465313 +5897 465263 +7560 465238 +8119 465232 +7151 465210 +15752 464964 +4476 464929 +3077 464826 +4941 464756 +10152 464493 +3255 464477 +7930 464418 +8561 464331 +8057 464290 +5073 464075 +13191 463887 +6498 463863 +7357 463530 +9815 463411 +13489 463148 +12369 463029 +6762 462915 +4482 462736 +2350 462731 +6506 462634 +2152 462592 +11622 462312 +8668 462185 +5878 462019 +2852 462006 +16145 461943 +6064 461812 +11772 461652 +3529 461506 +11617 461437 +13662 461340 +2922 461227 +21195 461196 +8733 461097 +8546 461014 +19299 460751 +9131 460711 +7863 460685 +4240 460580 +8889 460543 +25151 460407 +41615 460212 +6322 460155 +7914 460099 +15572 459295 +4580 459246 +12682 459131 +6899 458997 +9722 458947 +5951 458826 +2701 458808 +1512 458735 +10655 458723 +9674 458635 +7285 458614 +13864 458453 +7706 458443 +14463 458408 +11969 458352 +12022 458342 +8030 458206 +5718 458203 +9499 458191 +18091 457686 +10820 457682 +11153 457653 +17189 457496 +7397 457166 +15435 457165 +10404 457133 +1079 457130 +7186 456764 +11831 456653 +10633 456482 +870 456379 +10719 456339 +4089 456215 +10470 456203 +11729 456195 +13178 456192 +3768 456183 +14691 455976 +28 455976 +10976 455911 +4663 455897 +5249 455773 +8442 455449 +5282 455325 +3720 455145 +13356 455082 +11581 454949 +2381 454810 +601 454802 +903 454655 +10099 454543 +16483 454518 +10399 454507 +1252 454428 +11305 454423 +3246 454342 +12605 454177 +15247 453973 +3866 453730 +46481 453702 +4548 453681 +10325 453562 +11566 453362 +6287 453357 +9240 453334 +6244 453271 +4474 453245 +4524 453216 +16519 453141 +1897 453137 +3732 453109 +3885 453072 +15244 452997 +11434 452891 +11100 452784 +949 452773 +10747 452756 +8223 452719 +6125 452444 +8207 452351 +12053 452321 +2870 452256 +10303 452236 +8112 452129 +2044 452086 +11749 451878 +7009 451838 +8098 451813 +11233 451812 +8853 451678 +15302 451647 +7257 451557 +4851 451508 +24247 451387 +14651 451369 +5671 451350 +29690 451218 +5673 450985 +7429 450645 +14526 450579 +1489 450407 +18381 450182 +895 450118 +18279 450047 +7511 449889 +7564 449873 +2539 449697 +10423 449668 +10222 449447 +12427 449438 +8233 449184 +15446 449140 +13659 449125 +7852 449025 +4487 449014 +14486 449007 +9750 448958 +6889 448930 +11189 448906 +11769 448691 +9528 448621 +8339 448582 +7460 448524 +7480 448475 +6645 448428 +16167 448391 +5961 448383 +11468 448323 +10947 448316 +7448 448262 +10831 448231 +7743 448200 +11790 448123 +3864 448020 +9699 447968 +17741 447947 +8551 447942 +10997 447848 +631 447787 +8956 447706 +5831 447623 +741 447620 +10428 447512 +13310 447352 +1273 447226 +8084 447095 +5508 446729 +6951 446617 +6810 446454 +9252 446194 +1304 446147 +11628 446139 +12408 446021 +5600 445908 +3620 445780 +11102 445687 +1817 445635 +15260 445631 +4521 445604 +7891 445507 +9644 445478 +10540 445477 +7623 445150 +4869 445065 +15846 445057 +13965 444997 +6547 444996 +10497 444967 +7698 444957 +7262 444924 +21996 444912 +3565 444847 +7361 444827 +8601 444817 +1090 444803 +9519 444736 +4790 444625 +6867 444594 +17420 444560 +7491 444513 +8190 444458 +1513 444222 +10522 444039 +6674 444008 +7183 443956 +2088 443644 +9207 443623 +11320 443607 +10088 443581 +11136 443530 +4460 443497 +6042 443486 +7716 443421 +13854 443389 +5674 443287 +16581 443281 +9167 443098 +7165 442919 +4687 442895 +4866 442855 +10784 442654 +4732 442633 +865 442626 +5237 442517 +12652 442432 +10075 442326 +3525 442279 +3483 442207 +853 442188 +10834 442053 +10092 442033 +6544 442002 +9212 441858 +8776 441583 +12857 441523 +9588 441423 +13445 441268 +7301 441201 +9670 441165 +9208 441056 +9397 440989 +7393 440970 +30830 440747 +14959 440610 +6286 440540 +9157 440442 +10033 440162 +8313 440089 +7407 440088 +5078 439983 +10297 439973 +3585 439845 +11632 439807 +11088 439726 +8873 439603 +11905 439537 +7050 439349 +12771 439335 +10578 439236 +14006 439225 +9189 439199 +13943 439161 +8242 438925 +27737 438892 +14685 438862 +2841 438853 +8188 438775 +6060 438757 +10657 438692 +8468 438514 +6939 438377 +5224 438336 +3602 438299 +10029 437970 +7475 437917 +21675 437790 +11328 437753 +5258 437656 +793 437502 +2105 437344 +11461 437203 +18335 437071 +6366 437018 +7995 437015 +7506 436901 +10062 436677 +6846 436653 +10159 436578 +10848 436530 +10660 436510 +7369 436436 +7032 436299 +2446 436290 +5066 436196 +7974 435903 +8568 435896 +18936 435627 +10991 435619 +8386 435599 +5628 435553 +3975 435372 +796 435152 +7445 435125 +11307 434750 +4364 434663 +9667 434529 +9629 434332 +6706 434291 +8486 434203 +3981 434045 +8137 433968 +8526 433856 +11780 433721 +12803 433690 +9817 433586 +3020 433537 +10115 433505 +4903 433496 +16077 433356 +10275 433334 +11243 433238 +12088 433209 +9144 433171 +3695 433088 +7472 433029 +9319 432997 +8026 432869 +6697 432716 +9036 432689 +6505 432658 +4911 432291 +28227 432239 +4758 432224 +1845 432086 +10836 431880 +7021 431848 +8296 431812 +12328 431752 +1005 431721 +5923 431708 +13162 431573 +13097 431521 +32825 431122 +10913 431081 +9623 430972 +13682 430905 +25440 430798 +15016 430612 +2696 430394 +1587 430367 +10463 430242 +12612 430177 +10448 430165 +9196 430158 +20241 429817 +3263 429681 +12533 429646 +12577 429472 +3907 429457 +14717 429425 +9041 429321 +10140 429303 +5440 429164 +8225 429150 +7979 429111 +5162 429109 +34979 428999 +8263 428967 +9643 428904 +548 428758 +1698 428731 +2441 428648 +11058 428630 +6575 428307 +8686 428274 +14719 428107 +9980 428077 +9299 428002 +3966 427967 +11431 427858 +626 427844 +7170 427618 +8945 427570 +21703 427336 +12199 427179 +15818 427119 +9524 427061 +94 427057 +10084 427023 +8275 426906 +9803 426806 +4848 426803 +12507 426752 +8093 426716 +5400 426665 +10822 426582 +10544 426474 +8684 426470 +3474 426393 +2824 426292 +1124 426099 +5767 425935 +7763 425894 +2052 425887 +5888 425825 +17894 425817 +6910 425796 +25792 425781 +723 425679 +11668 425517 +8860 425445 +1027 425439 +6454 425414 +6787 425354 +15958 425316 +4712 425219 +23731 425071 +39990 425025 +7822 424954 +7237 424883 +7750 424792 +5469 424745 +13030 424621 +438 424384 +2569 424271 +6795 424188 +10012 424179 +16348 424166 +14359 423890 +3994 423764 +11330 423708 +9889 423613 +7767 423523 +6761 423314 +11237 423255 +9194 423211 +8025 423111 +2787 423038 +10053 423032 +8257 422993 +3838 422979 +8999 422972 +8013 422938 +14886 422812 +3974 422673 +11803 422479 +6277 422372 +10054 422115 +8006 422012 +8482 421985 +5333 421820 +4846 421787 +11123 421771 +13795 421760 +14597 421541 +12268 421468 +9539 421435 +11646 421416 +12848 421415 +10828 421149 +4465 421005 +8312 420878 +1940 420842 +9384 420774 +10343 420682 +38563 420682 +2171 420647 +10907 420307 +14847 420294 +8888 420198 +5496 420132 +4898 419944 +10821 419846 +8754 419807 +18836 419789 +7306 419436 +4480 419357 +13107 419242 +4662 419029 +13301 418988 +7620 418900 +6387 418663 +398 418591 +13316 418591 +5404 418532 +3212 418520 +14683 418447 +14372 418412 +13683 418208 +9753 418195 +4164 418183 +11476 418137 +6869 418119 +8463 418118 +10759 417587 +12478 417567 +14813 417528 +11753 417140 +7772 417075 +15152 417032 +6973 416961 +26840 416803 +2236 416706 +8454 416300 +11228 416181 +18802 416171 +12112 416118 +7600 416058 +14345 416018 +8883 416008 +13620 415903 +3550 415841 +10282 415776 +16127 415765 +9599 415745 +11376 415739 +10074 415692 +731 415656 +7243 415472 +14057 415445 +8157 415366 +5774 415223 +6117 415193 +1117 415145 +13077 415133 +17448 415079 +14424 415006 +5868 414948 +7228 414712 +8564 414687 +1496 414653 +11939 414600 +9137 414451 +18042 414426 +8871 414367 +7527 414259 +9210 414225 +6942 414161 +9284 414093 +11864 413979 +4729 413800 +15336 413797 +29749 413689 +9808 413450 +6986 413448 +6397 413294 +15598 413245 +14819 413174 +13547 413105 +6777 413085 +13804 413005 +13257 412980 +7446 412953 +6273 412946 +12620 412923 +7178 412896 +8953 412856 +10893 412416 +9031 412276 +702 412269 +15338 412154 +7747 412118 +7872 412058 +12769 412014 +11722 411923 +9983 411914 +16256 411890 +10732 411859 +19277 411821 +5883 411797 +11942 411756 +7255 411620 +10568 411592 +22917 411489 +3425 411402 +3494 411372 +18707 411253 +3185 411125 +15733 411004 +10460 410993 +4453 410817 +4401 410718 +7363 410707 +20954 410678 +10270 410579 +8404 410530 +16570 410515 +16863 410211 +11702 410131 +4235 409832 +9001 409794 +12806 409633 +12223 409518 +9396 409503 +13797 409366 +12402 409239 +7526 409230 +12600 409139 +15100 409091 +10681 409050 +10246 408972 +11872 408925 +7579 408648 +9172 408405 +17796 408380 +9115 408352 +21793 408261 +12691 408216 +6364 408060 +6859 408027 +13038 407988 +1632 407958 +12477 407924 +15378 407851 +9352 407688 +3633 407655 +5803 407653 +8646 407621 +7587 407575 +15331 407451 +1758 407253 +877 407147 +11998 407145 +11679 407103 +3601 407096 +4669 407086 +227 407081 +11334 407006 +8131 406946 +1759 406891 +8452 406865 +8997 406822 +9574 406812 +6797 406810 +11336 406762 +8501 406738 +11114 406687 +10311 406649 +10150 406623 +17689 406578 +11300 406421 +9814 406384 +8389 406349 +8271 406333 +7954 406313 +10576 406312 +6565 406306 +7545 406240 +9102 406164 +14328 406013 +2144 405990 +13673 405932 +5337 405901 +8865 405864 +1155 405852 +3719 405528 +9258 405495 +13093 405422 +9011 405319 +6257 405240 +1835 405060 +12871 405052 +5588 404835 +16629 404629 +9799 404597 +15295 404559 +11066 404496 +8716 404329 +12928 404150 +12206 404017 +9635 404014 +7635 403984 +7561 403954 +12388 403633 +13630 403434 +13592 403053 +15896 402919 +20197 402829 +9645 402757 +13393 402755 +12165 402698 +14074 402666 +9332 402472 +12406 402273 +6938 402132 +8471 402079 +15615 401716 +14410 401641 +8020 401607 +9573 401541 +813 401316 +13709 401296 +7267 401278 +4049 401218 +7817 401160 +1125 400938 +6695 400924 +753 400632 +13117 400629 +7467 400617 +7405 400469 +8741 400432 +1347 400368 +10095 400320 +10692 400261 +7558 400226 +9133 400206 +4467 400136 +8814 399952 +1648 399945 +5172 399767 +1723 399704 +5384 399677 +32425 399666 +8130 399658 +26094 399611 +6602 399400 +7501 399051 +21356 399047 +13960 399015 +26119 399002 +1177 399001 +15076 398977 +7965 398937 +14072 398855 +2545 398812 +15033 398769 +10156 398733 +9015 398630 +5550 398523 +3735 398483 +15694 398450 +12318 398428 +9709 398412 +4156 398372 +6937 398056 +13447 397970 +11083 397902 +7612 397887 +677 397838 +4709 397653 +8539 397640 +3405 397576 +15184 397562 +10880 397473 +7718 397294 +1846 397197 +13919 397195 +17199 397161 +12963 397157 +2357 397072 +8168 396992 +13067 396930 +7360 396710 +6625 396663 +12670 396660 +11363 396611 +8644 396544 +1071 396138 +9569 396044 +11103 396035 +16278 396022 +12356 395953 +20790 395715 +12160 395513 +1278 395447 +9985 395426 +6589 395388 +1322 395383 +14327 395356 +10727 395331 +6824 395153 +15301 394895 +9233 394857 +8970 394826 +8147 394812 +11406 394778 +4129 394771 +29657 394731 +13339 394630 +3141 394547 +26220 394385 +9029 394178 +14133 393701 +4313 393607 +10741 393597 +12000 393560 +11038 393455 +7708 393396 +6981 393382 +48539 393366 +12965 393321 +3051 393202 +9697 392989 +2629 392849 +556 392807 +11481 392800 +6595 392750 +1371 392745 +19099 392599 +5602 392531 +7039 392512 +14905 392497 +11118 392472 +18390 392419 +2848 392286 +7982 392117 +1034 392071 +7825 392001 +12930 391952 +8262 391872 +926 391870 +13904 391618 +3528 391502 +6259 391442 +432 391392 +4897 391238 +2797 391028 +21852 390801 +3844 390776 +7075 390638 +11972 390586 +18286 390550 +10914 390522 +12181 390457 +10274 390401 +2411 390339 +11704 390287 +9856 390187 +9268 390171 +12150 390103 +9879 389997 +7471 389987 +9185 389986 +12879 389967 +7455 389884 +1747 389879 +13340 389812 +10127 389663 +10402 389568 +19613 389434 +4285 389340 +2038 389257 +5847 389229 +8097 389217 +10014 389052 +7695 389038 +6964 388887 +11915 388736 +17305 388721 +3069 388564 +6779 388434 +7866 388384 +1789 388251 +12684 388146 +5521 388118 +10595 388088 +6873 387763 +1818 387683 +7054 387518 +10754 387382 +6451 387287 +9655 387128 +8355 387116 +8129 387080 +16393 387050 +13999 386969 +7787 386929 +11276 386759 +5562 386693 +13741 386688 +12285 386638 +6641 386580 +6737 386535 +7187 386445 +2536 386412 +14122 386389 +15682 386380 +6234 386377 +10302 386248 +14115 386219 +16666 386042 +10332 385907 +3964 385839 +6620 385645 +10361 385548 +8902 385496 +10966 385484 +14187 385467 +13633 385375 +17063 385313 +18621 385065 +10617 385042 +12539 384984 +14997 384883 +11983 384868 +5468 384814 +7238 384796 +10721 384572 +15555 384479 +1275 384392 +11432 384301 +2977 384284 +10569 384253 +13359 384110 +11560 384076 +10342 384009 +6569 383954 +19122 383938 +22611 383811 +6036 383687 +8474 383644 +5740 383429 +7692 383359 +586 383295 +1419 383273 +4066 383194 +1538 383149 +3191 382945 +12284 382931 +14620 382918 +9110 382879 +4825 382730 +21199 382531 +8126 382516 +11652 382509 +3889 382433 +4352 382237 +8478 382053 +5422 381988 +6597 381839 +8246 381825 +16052 381819 +2748 381810 +9530 381684 +16119 381666 +6445 381644 +18292 381607 +23370 381562 +10089 381523 +11077 381365 +7226 381330 +13329 381179 +14021 381124 +9758 381123 +11809 381086 +13772 381080 +3036 381064 +15223 381038 +6486 381025 +6814 380938 +13241 380861 +8027 380855 +8884 380820 +2054 380811 +19709 380793 +6504 380605 +9626 380566 +11515 380412 +8628 380336 +13367 380121 +13861 380071 +31362 380053 +1647 380010 +17820 379781 +9166 379560 +6906 379374 +14469 379282 +14227 379210 +3754 379002 +11001 378926 +11526 378867 +8347 378753 +7862 378733 +9281 378662 +17718 378652 +4293 378636 +13302 378542 +6982 378491 +14217 378485 +8494 378459 +4932 378435 +10408 378283 +15796 378222 +10588 378132 +23357 377965 +17462 377860 +8904 377819 +11000 377789 +16738 377598 +17499 377581 +11677 377538 +4936 377530 +1130 377448 +9007 377376 +9900 377348 +7382 377267 +5760 377258 +937 376979 +12252 376780 +20311 376769 +849 376755 +1389 376721 +17715 376614 +10135 376600 +14066 376597 +7026 376387 +132 376386 +6957 376353 +11734 376300 +3258 376225 +6452 376005 +909 375926 +11332 375842 +10386 375819 +10710 375699 +14825 375691 +8088 375684 +12148 375681 +9936 375544 +7270 375490 +11781 375370 +6226 375337 +2437 375301 +9846 375164 +9296 375038 +17027 374977 +2337 374938 +3912 374885 +15162 374882 +8252 374852 +10484 374831 +20251 374829 +2165 374799 +6901 374710 +10243 374664 +13671 374469 +7358 374221 +16120 374131 +3149 374119 +9021 374053 +7110 374044 +11078 373834 +1484 373662 +8069 373610 +10868 373588 +3184 373585 +2754 373555 +1292 373520 +10146 373513 +6912 373432 +7754 373402 +4013 373341 +3792 373296 +9149 373012 +11259 372932 +12159 372917 +4700 372912 +1007 372888 +21538 372840 +4959 372816 +6479 372812 +13226 372725 +7586 372712 +14105 372647 +16720 372515 +5653 372464 +13336 372347 +13612 372275 +4589 372141 +13914 372001 +14433 371923 +1631 371838 +7166 371618 +12906 371602 +8234 371586 +5705 371556 +7875 371528 +3929 371451 +13354 371418 +9677 371286 +9619 371233 +7247 371188 +9511 370981 +8794 370937 +21506 370897 +10058 370891 +10305 370833 +10192 370769 +12665 370754 +16752 370681 +7375 370584 +100 370551 +10145 370550 +12396 370469 +2930 370325 +16440 370303 +6579 370297 +8523 370210 +6450 369913 +2471 369759 +3039 369622 +823 369518 +8673 369498 +28689 369444 +14728 369442 +13019 369391 +14537 369330 +9177 369323 +11846 369307 +9564 369236 +15286 369223 +15725 369135 +8258 369120 +16094 369079 +8217 368989 +12897 368893 +14162 368880 +10918 368753 +7820 368688 +4563 368543 +9807 368432 +9561 368424 +18609 368234 +9075 368089 +9085 368050 +10231 368001 +11138 367959 +12246 367928 +972 367806 +10255 367786 +7906 367661 +8680 367603 +15115 367522 +13048 367461 +11087 367387 +9494 367342 +18071 367262 +964 367230 +12373 367196 +4175 367107 +8659 367082 +2070 367075 +7045 367061 +14510 367048 +10571 367012 +15070 366988 +12654 366942 +3310 366871 +7548 366733 +5977 366666 +12259 366570 +4909 366534 +16640 366491 +3167 366477 +4558 366360 +19610 366257 +11099 366173 +12232 366119 +7509 366023 +9374 365891 +3470 365884 +17127 365533 +8192 365498 +7114 365476 +10380 365341 +16137 365300 +4366 365277 +7946 365216 +7365 365191 +7088 364886 +9480 364726 +8216 364713 +7685 364626 +12932 364617 +2195 364581 +9931 364506 +13844 364477 +11390 364405 +8220 364387 +8253 364234 +14408 364112 +7882 364093 +12263 364016 +7152 363829 +3998 363827 +1087 363800 +2507 363606 +7427 363566 +7521 363514 +10708 363450 +7714 363438 +2248 363431 +15930 363224 +6651 363153 +7733 362858 +6457 362836 +8566 362822 +8498 362813 +1063 362682 +2353 362622 +10040 362443 +14931 361977 +23512 361973 +6766 361959 +5999 361585 +9348 361559 +9376 361481 +7603 361432 +7422 361379 +10184 361347 +5648 361297 +3320 361123 +10017 361097 +14909 361015 +9910 360987 +3824 360918 +6515 360811 +7496 360806 +19303 360766 +8791 360691 +12523 360595 +8993 360575 +5801 360431 +4529 360398 +10965 360256 +229 360226 +9457 360164 +11252 360152 +16346 360033 +14449 359968 +11686 359944 +18334 359855 +14812 359787 +10468 359667 +7998 359571 +9964 359523 +7451 359379 +9241 359237 +6711 359234 +4545 359213 +8287 359148 +816 358897 +10147 358736 +12380 358729 +9949 358648 +1196 358550 +9107 358437 +15795 358413 +5824 358312 +5372 358295 +5124 358289 +9086 358245 +6748 358216 +9168 358064 +6805 357931 +15498 357866 +14679 357853 +14300 357819 +15528 357737 +6069 357670 +40138 357664 +12763 357550 +16051 357498 +12389 357475 +4002 357463 +12069 357303 +6371 357290 +13572 357238 +15342 357172 +9860 357116 +7664 356998 +7950 356936 +10846 356850 +17547 356634 +18475 356600 +13125 356555 +9328 356554 +6543 356451 +2954 356267 +15055 356232 +10833 356213 +26878 356180 +5013 356178 +6953 356175 +5654 356154 +6101 356107 +14641 356073 +9151 356027 +4421 355987 +16535 355894 +5639 355847 +5050 355821 +9938 355713 +11325 355685 +7531 355646 +12981 355592 +7666 355538 +9399 355432 +13415 355422 +7538 355305 +1258 355163 +18545 355158 +2759 355119 +1136 355109 +6617 355081 +13571 355038 +14069 355019 +12437 354981 +17960 354969 +9325 354939 +13708 354915 +6420 354705 +14757 354591 +14919 354480 +9199 354451 +4108 354398 +12949 354382 +6578 354376 +9361 354353 +10718 354244 +13593 354199 +6052 354007 +8436 353994 +9105 353886 +12275 353856 +9121 353405 +11106 353379 +10800 353350 +8598 353325 +2100 353199 +2290 353173 +15080 353027 +11642 353004 +16542 352734 +16111 352650 +15602 352627 +10608 352611 +5313 352603 +17782 352590 +7838 352517 +16445 352493 +6909 352475 +14791 352413 +9857 352193 +17842 352066 +1638 352040 +16712 351998 +2164 351959 +14364 351891 +3287 351887 +8706 351810 +12873 351660 +13075 351610 +22484 351603 +16707 351599 +7381 351585 +4463 351585 +699 351567 +11856 351470 +25851 351312 +10364 351096 +8266 350892 +12492 350873 +14493 350708 +8854 350697 +13346 350683 +10469 350675 +10216 350657 +5147 350609 +4169 350591 +10872 350527 +10366 350409 +12801 350394 +9572 350320 +8149 350232 +6375 350198 +5447 350173 +28141 350103 +18733 350035 +13642 350000 +1144 349908 +10421 349802 +10427 349683 +14377 349622 +17826 349557 +6528 349442 +9877 349409 +4198 349335 +11550 349300 +14840 349249 +16952 349120 +7776 349119 +8914 349098 +15164 349012 +6469 348997 +6206 348967 +7731 348954 +6890 348922 +1348 348722 +10086 348564 +15037 348531 +9345 348509 +10474 348482 +8949 348330 +35327 348207 +13458 348166 +4901 348016 +13853 348002 +10925 347889 +9835 347859 +5414 347837 +3369 347791 +8582 347636 +11682 347617 +31433 347583 +9136 347427 +4702 347410 +9482 347376 +11271 347359 +566 347358 +17334 347227 +13850 347132 +11023 347130 +18263 347068 +10400 347041 +27133 346684 +6462 346645 +11272 346626 +9963 346622 +15198 346518 +7818 346505 +646 346495 +6778 346466 +9775 346459 +13485 346404 +9013 346329 +11946 346288 +10668 346248 +1330 346195 +8517 346056 +6239 345826 +9557 345703 +16978 345593 +8348 345532 +1272 345478 +11238 345461 +18555 345457 +20872 345277 +10359 345271 +17036 345196 +2120 344930 +2280 344773 +8573 344722 +10515 344702 +12020 344681 +10597 344592 +9260 344591 +12047 344581 +10429 344566 +11185 344446 +5892 344360 +5250 344253 +9160 343902 +8458 343880 +7252 343790 +31173 343777 +4022 343555 +10003 343480 +11193 343472 +6562 343348 +13925 343228 +17406 343189 +4730 343165 +11155 343055 +12231 343030 +17014 343022 +16618 342966 +7278 342897 +9211 342896 +5100 342826 +15066 342723 +11594 342721 +12527 342717 +8288 342688 +3664 342668 +9490 342586 +3839 342537 +14429 342519 +1075 342420 +2232 342183 +10980 342178 +2022 342057 +11472 342053 +3979 342036 +15346 341959 +15863 341944 +1691 341900 +15294 341872 +11112 341843 +14569 341817 +8915 341671 +10304 341465 +4843 341417 +6494 341415 +7926 341332 +8515 341225 +12046 341172 +1216 341117 +9473 341068 +9274 341050 +11570 341048 +6659 340992 +22473 340911 +8075 340763 +15393 340693 +14883 340689 +2522 340630 +9960 340607 +8212 340582 +7208 340577 +10594 340450 +21909 340415 +10765 340343 +4583 340262 +8603 340144 +13637 339972 +7138 339832 +9581 339824 +13188 339727 +15689 339721 +8749 339613 +18576 339525 +8425 339432 +10241 339308 +3902 339257 +11937 339211 +8222 339181 +7621 339139 +2518 339112 +11758 339065 +5855 338929 +12173 338908 +12615 338903 +8801 338853 +842 338791 +13142 338723 +5516 338721 +12329 338602 +7388 338534 +26105 338531 +5032 338437 +7795 338417 +8957 338345 +2483 338332 +10038 338262 +3743 338006 +8181 337997 +14952 337748 +5492 337746 +12882 337707 +11648 337676 +8806 337599 +5833 337517 +9780 337469 +4623 337392 +17880 337247 +4745 337244 +12538 337238 +6369 337188 +6758 337119 +15706 337069 +15870 336993 +9400 336894 +5721 336815 +7097 336767 +7869 336739 +20092 336483 +13229 336427 +20486 336410 +12970 336280 +8786 336264 +8440 336084 +12746 336078 +8268 335957 +19034 335955 +20082 335940 +5601 335924 +5210 335873 +17907 335805 +6075 335758 +4835 335634 +2129 335490 +10931 335423 +5607 335409 +11333 335370 +7653 335365 +12400 335354 +11602 335344 +4731 335188 +12575 335173 +1618 335125 +13606 335118 +21285 335017 +12107 334923 +1387 334914 +34033 334900 +14495 334864 +7331 334829 +18740 334712 +3987 334670 +16134 334569 +14860 334478 +1062 334442 +17185 334381 +12497 334367 +19616 334301 +3696 334292 +12772 334266 +11403 334201 +10172 334185 +2183 334078 +17409 334077 +9646 333987 +10941 333957 +4424 333731 +13109 333719 +32214 333692 +9408 333646 +5703 333577 +9901 333570 +7135 333416 +11495 333379 +13953 333300 +10182 333300 +8541 333269 +13833 333263 +9471 333259 +16527 333092 +16533 333048 +1739 333033 +2160 332999 +24520 332927 +17541 332914 +245 332905 +1601 332894 +8989 332859 +16512 332747 +4265 332705 +14576 332575 +3150 332510 +12565 332496 +10439 332445 +31112 332411 +14926 332365 +11450 332296 +1984 332256 +9871 332254 +4277 332226 +11684 332109 +6882 331909 +6733 331893 +11521 331862 +22488 331824 +10839 331793 +1055 331762 +10969 331754 +11177 331679 +18154 331626 +5737 331561 +7801 331482 +14409 331482 +11597 331282 +12023 331207 +9170 331045 +2799 331010 +8124 331002 +11553 330990 +9022 330926 +12827 330921 +10801 330902 +1699 330871 +12880 330544 +12465 330534 +14286 330531 +14783 330519 +7902 330467 +20000 330396 +10750 330328 +8887 330300 +14317 330224 +9620 330208 +13280 330181 +8712 330141 +11584 330100 +5053 329959 +5907 329943 +4415 329942 +10454 329927 +11132 329916 +14858 329894 +15670 329864 +8125 329754 +15422 329750 +12831 329749 +37666 329684 +16433 329663 +3192 329598 +11636 329464 +10193 329407 +11375 329359 +10695 329328 +14388 329322 +8180 329251 +9874 329097 +8920 329091 +4534 328825 +8903 328698 +23964 328655 +17122 328606 +7048 328597 +6211 328591 +8925 328576 +11955 328523 +2378 328502 +14896 328482 +9751 328231 +12578 328224 +1773 328185 +6338 328096 +8839 327999 +10923 327937 +7778 327911 +12617 327835 +9018 327783 +11732 327780 +7563 327739 +6803 327707 +8969 327692 +5552 327602 +3905 327557 +9911 327480 +7119 327458 +36285 327444 +7684 327424 +9616 327313 +11129 327297 +12032 327230 +11490 327080 +7792 327061 +13574 327032 +11398 327007 +8066 326906 +1952 326868 +2710 326703 +13362 326668 +14457 326642 +17339 326625 +12580 326624 +21861 326488 +21157 326473 +34119 326457 +14235 326388 +11819 326384 +4102 326329 +7209 326168 +6195 326143 +10291 326111 +8894 326110 +7330 325951 +5869 325935 +14525 325893 +13120 325862 +6167 325828 +9509 325807 +24382 325742 +7855 325721 +10078 325656 +7112 325654 +5599 325576 +8122 325525 +15105 325514 +15740 325468 +16753 325462 +9517 325427 +10953 325424 +13936 325332 +8862 325273 +3464 325244 +5452 325232 +20983 325102 +17582 325099 +1483 324860 +8035 324825 +8824 324800 +14119 324704 +12766 324689 +9412 324668 +12780 324579 +12521 324471 +9752 324452 +13923 324383 +6001 324264 +13145 324264 +9464 324208 +7336 324205 +15626 324177 +19773 324148 +8701 324135 +8504 324114 +9422 324110 +10457 324084 +5832 324083 +14654 324004 +13777 323947 +5142 323924 +3843 323885 +14264 323868 +8621 323792 +6176 323751 +10538 323625 +38836 323556 +9958 323458 +493 323456 +15406 323421 +10098 323257 +13272 323251 +14882 323077 +18369 323073 +18525 323037 +11278 322890 +24754 322889 +3536 322832 +12542 322786 +7893 322728 +2971 322724 +6949 322711 +12699 322709 +11920 322700 +9813 322679 +17078 322609 +5446 322605 +2778 322596 +13694 322559 +14567 322526 +12049 322315 +23576 322120 +4316 322022 +8699 322006 +9743 321964 +4331 321936 +10843 321863 +19310 321849 +8469 321771 +4121 321673 +12513 321647 +4470 321634 +9431 321433 +5793 321318 +7773 321315 +21279 321289 +8713 321248 +1233 321228 +3731 321181 +17381 321180 +9628 321107 +4386 321100 +9845 321023 +19250 320960 +5064 320841 +5540 320721 +4185 320694 +15469 320670 +7735 320664 +21313 320604 +965 320601 +10529 320574 +12545 320556 +725 320395 +15593 320377 +12641 320315 +3364 320117 +9429 320034 +11009 319918 +11293 319719 +17357 319656 +4105 319633 +2224 319519 +15287 319462 +15929 319083 +5500 319073 +5848 318999 +3826 318962 +7353 318844 +7721 318797 +6495 318768 +16093 318732 +12309 318723 +18672 318712 +20171 318609 +16852 318532 +11169 318478 +9314 318476 +2229 318472 +7329 318393 +7416 318319 +20384 318047 +11004 317965 +17524 317883 +8678 317800 +11540 317774 +659 317752 +5036 317723 +13106 317669 +8787 317543 +13029 317496 +20716 317472 +2821 317076 +13748 317005 +9391 316991 +19332 316987 +19483 316986 +9727 316962 +11658 316942 +12607 316917 +13883 316914 +9155 316768 +2348 316745 +17955 316743 +1373 316719 +7873 316717 +2069 316670 +21105 316623 +8771 316595 +10452 316592 +11756 316513 +17915 316507 +6455 316406 +11824 316389 +22815 316388 +13784 316374 +7424 316364 +6386 316312 +20617 316271 +5557 316215 +20357 316185 +14794 316066 +17352 316046 +28630 315957 +5968 315855 +16428 315835 +6920 315834 +11130 315824 +11545 315711 +2118 315680 +3727 315673 +16182 315559 +15229 315523 +16387 315368 +21933 315289 +11359 315283 +10649 315261 +4659 315233 +14240 315221 +17356 315168 +17192 315122 +8689 315037 +11765 315023 +6251 314974 +12141 314897 +9055 314803 +11845 314792 +13566 314771 +9934 314711 +2741 314681 +27344 314655 +8281 314654 +5874 314594 +9891 314528 +12634 314519 +8782 314510 +21865 314451 +9520 314369 +11768 314347 +10206 314338 +12759 314296 +4255 314282 +35185 314258 +10271 314254 +11926 314202 +1385 314190 +9323 314182 +25841 313849 +13644 313842 +3686 313681 +18726 313573 +10059 313482 +1328 313246 +8365 313222 +7096 313182 +12811 313118 +21877 313081 +16679 313028 +9811 313018 +11882 313016 +5416 312970 +7275 312919 +7613 312904 +4177 312865 +9460 312773 +18848 312722 +14544 312645 +16915 312621 +13901 312583 +7156 312558 +12735 312557 +14850 312525 +9373 312429 +7888 312382 +13449 312351 +29378 312294 +13307 312290 +22026 312233 +17521 312201 +9892 312174 +16476 312147 +1333 312144 +13342 312097 +14598 312036 +18859 312015 +8765 311951 +12228 311876 +5355 311833 +13933 311638 +20741 311606 +9824 311582 +9104 311540 +26138 311538 +13768 311520 +23481 311505 +14600 311385 +18309 311349 +931 311338 +3673 311267 +10651 311194 +6685 311113 +11473 311083 +13276 311034 +8880 310999 +6489 310946 +12695 310937 +4802 310930 +9355 310849 +10938 310762 +4743 310727 +15300 310686 +10768 310656 +9575 310603 +12519 310526 +10215 310423 +13124 310339 +10170 310325 +13902 310286 +13944 310233 +12540 310206 +13317 310177 +12151 310173 +1286 310125 +7125 309987 +11172 309933 +14669 309886 +12926 309859 +7661 309685 +9794 309629 +9585 309568 +14135 309560 +2194 309554 +11294 309522 +2544 309428 +13692 309380 +16248 309370 +17196 309335 +9175 309081 +15261 309005 +1473 308985 +1960 308936 +13456 308907 +10546 308821 +14762 308772 +10591 308714 +11721 308591 +3086 308558 +9363 308490 +13176 308475 +11989 308474 +10543 308427 +23781 308348 +13403 308323 +9099 308280 +11784 308078 +32089 307995 +529 307911 +95 307756 +3939 307654 +16435 307639 +20182 307587 +34847 307510 +10509 307452 +6071 307446 +11500 307410 +10384 307357 +15343 307354 +1963 307209 +9541 307199 +14939 306944 +20014 306924 +11903 306893 +5921 306873 +12723 306865 +3178 306813 +17389 306782 +12705 306774 +12068 306684 +3460 306676 +10070 306651 +11192 306520 +21841 306506 +9017 306491 +20755 306438 +6843 306369 +8670 306349 +17281 306327 +19391 306285 +9450 306242 +16574 305876 +12812 305859 +5067 305834 +7295 305811 +15604 305795 +15454 305645 +9757 305637 +7709 305617 +7443 305616 +2558 305584 +11013 305563 +11161 305551 +8661 305334 +13146 305327 +9294 305325 +6248 305317 +16457 305285 +24505 305278 +9550 305260 +535 305241 +18677 305121 +13832 305112 +5325 305045 +10630 304946 +12983 304915 +20119 304903 +8161 304873 +13840 304833 +12528 304832 +2085 304744 +15664 304720 +885 304692 +22593 304679 +9563 304674 +15392 304568 +9776 304540 +7815 304496 +5331 304477 +5023 304443 +17661 304421 +12344 304409 +14082 304392 +14737 304191 +10134 304135 +19952 304119 +12955 303828 +18505 303801 +7812 303777 +21574 303696 +5209 303694 +11234 303620 +9867 303608 +12751 303483 +12091 303455 +12606 303441 +11142 303322 +9447 303166 +11533 303122 +16168 303103 +7207 303092 +11666 302797 +9842 302745 +11322 302716 +11410 302571 +9567 302570 +18256 302546 +9706 302540 +10494 302536 +14899 302514 +8537 302402 +14101 302392 +5430 302339 +16307 302301 +3325 302118 +13766 302110 +6431 302098 +11626 302087 +1434 301879 +10518 301863 +12669 301838 +10869 301811 +7702 301726 +7258 301624 +7605 301599 +4891 301498 +1504 301484 +11665 301409 +11426 301408 +18220 301381 +13512 301342 +17068 301234 +1942 301225 +3311 301188 +9415 301179 +3820 301175 +11512 301087 +8719 300995 +8182 300908 +17235 300901 +5777 300818 +5794 300789 +7223 300767 +18864 300667 +10443 300646 +24589 300646 +17132 300620 +4340 300534 +7104 300478 +1188 300402 +3019 300388 +6992 300317 +8354 300316 +13609 300300 +4245 300252 +9079 300197 +15199 300105 +7157 300038 +762 299991 +17450 299943 +17044 299810 +16349 299699 +8975 299568 +4806 299541 +2895 299520 +15573 299493 +13116 299369 +10625 299261 +13037 299171 +2419 299150 +7610 299146 +13201 298875 +7599 298787 +3831 298725 +15984 298640 +5171 298514 +2604 298497 +13594 298417 +10287 298407 +10032 298356 +14538 298240 +31061 298197 +17630 298135 +14503 298117 +7808 298087 +4000 298047 +5660 298010 +6213 297993 +14417 297966 +8495 297957 +6245 297936 +29115 297877 +10069 297860 +5932 297831 +847 297818 +15459 297746 +7197 297706 +7937 297624 +6407 297566 +8477 297541 +17490 297510 +7957 297419 +19847 297359 +16298 297176 +16328 297109 +5097 297095 +18708 297085 +2817 297026 +10758 296992 +6941 296987 +17930 296964 +9322 296934 +10299 296918 +7644 296748 +13320 296692 +10927 296691 +11812 296683 +18151 296588 +8650 296576 +11952 296532 +653 296525 +10467 296457 +222 296347 +18985 296336 +17646 296312 +3361 296291 +15508 296281 +10908 296275 +12299 296124 +11589 296065 +4357 296044 +4649 296014 +19912 295919 +10238 295896 +7598 295800 +10902 295794 +824 295763 +2434 295738 +108 295681 +14396 295673 +19566 295671 +16313 295653 +4509 295636 +14616 295610 +17619 295541 +10999 295494 +5755 295491 +8697 295465 +13830 295385 +19045 295195 +21162 295171 +5489 295157 +11191 295115 +15153 295040 +3449 294958 +11150 294898 +18133 294799 +10989 294694 +14770 294585 +11554 294580 +10476 294501 +5002 294469 +3440 294422 +21765 294385 +11791 294325 +15840 294296 +17719 294251 +5812 294223 +25236 294167 +16721 294070 +16888 293941 +868 293915 +12118 293877 +6458 293767 +14533 293678 +10000 293634 +24664 293626 +12019 293496 +1686 293475 +8309 293429 +3055 293333 +13230 293232 +12536 293224 +15369 293223 +8941 293204 +14778 293112 +22535 293108 +11015 293042 +18825 292878 +17159 292877 +8895 292682 +1035 292678 +15372 292655 +14248 292637 +10898 292633 +13973 292544 +11801 292523 +20261 292508 +10609 292453 +11311 292434 +17671 292434 +7768 292322 +26318 292282 +16031 292266 +10948 292244 +10899 292189 +2345 292185 +12671 291955 +11889 291889 +20899 291879 +13183 291782 +5286 291580 +11909 291559 +11637 291497 +6965 291479 +12525 291428 +6170 291277 +4103 291236 +12937 291227 +15523 291170 +16156 291108 +24272 291089 +9507 291083 +11899 291014 +17857 290869 +6521 290825 +4092 290814 +7159 290777 +24320 290770 +12435 290704 +8492 290694 +11932 290634 +11206 290586 +14447 290535 +18961 290530 +48099 290522 +8640 290518 +492 290477 +1418 290394 +19982 290348 +9225 290286 +2261 290270 +11168 290218 +18479 290213 +20499 290165 +11810 290067 +11210 289892 +9329 289865 +15471 289784 +14518 289756 +18020 289680 +14488 289576 +7035 289565 +8662 289554 +11681 289503 +21562 289256 +4863 289185 +4064 289173 +19247 289165 +5195 289164 +16582 289117 +6908 289054 +21866 289013 +12266 288914 +3697 288830 +10233 288812 +12377 288775 +14734 288753 +33683 288737 +771 288733 +2030 288732 +11026 288731 +15317 288722 +6902 288708 +48796 288704 +22386 288678 +21614 288662 +2134 288587 +5765 288576 +13584 288406 +7378 288289 +819 288274 +10129 288254 +11075 288220 +2680 288189 +13831 288175 +18393 288077 +11676 288063 +15383 287991 +4359 287991 +36030 287903 +20852 287857 +5181 287657 +10726 287650 +21323 287633 +10559 287568 +14332 287540 +9555 287519 +9595 287510 +6194 287503 +6539 287493 +11818 287374 +1202 287364 +4319 287305 +18110 287296 +6573 287280 +15891 287257 +9293 287226 +12432 287194 +10030 287189 +18086 287141 +14086 287073 +10762 287047 +13465 287036 +19744 287018 +9387 287010 +14867 286974 +11464 286951 +24003 286921 +8617 286874 +10471 286857 +3112 286748 +12725 286626 +21165 286488 +7319 286337 +12036 286305 +4229 286285 +12537 286255 +11005 286249 +697 286174 +10700 286147 +12548 286127 +7515 286098 +6109 286082 +16015 286066 +8046 286061 +11544 285977 +13855 285908 +11735 285898 +15192 285893 +9653 285800 +10792 285796 +7616 285649 +15556 285556 +17799 285509 +9773 285508 +25287 285465 +14416 285439 +18572 285395 +10358 285292 +9183 285207 +12073 285159 +16754 285095 +8721 285047 +17081 285026 +12593 285023 +9568 284957 +8101 284931 +12002 284929 +8472 284908 +7770 284900 +5077 284807 +28852 284805 +19523 284761 +14219 284693 +15177 284685 +13722 284615 +12734 284575 +13404 284454 +4982 284434 +6751 284376 +10008 284360 +6096 284343 +14999 284301 +10087 284270 +11918 284068 +11699 284065 +10701 283996 +9583 283931 +6291 283902 +15196 283850 +15416 283835 +14521 283648 +13723 283591 +7993 283539 +8559 283442 +7650 283209 +11552 283208 +7929 283037 +18106 283014 +11065 283009 +9793 282858 +10860 282804 +2189 282772 +8717 282753 +2849 282749 +4014 282718 +7900 282712 +7335 282598 +14225 282574 +20228 282555 +12633 282528 +10824 282517 +11455 282474 +552 282383 +11954 282283 +3911 282276 +6757 282252 +8840 282235 +8805 282201 +19375 282196 +8580 282166 +6738 282152 +10906 282124 +13325 282069 +12111 282057 +7193 282053 +13004 281987 +904 281961 +15579 281954 +11003 281952 +17608 281805 +8135 281776 +12308 281762 +5994 281742 +12689 281646 +13678 281637 +3400 281600 +17151 281552 +20176 281468 +6381 281450 +10420 281445 +16105 281417 +6283 281376 +16774 281323 +12865 281321 +9675 281161 +21439 281160 +10073 281140 +15012 281072 +14820 281032 +4420 281012 +13389 280931 +15278 280924 +14707 280864 +11693 280834 +20989 280800 +9061 280631 +7811 280622 +17702 280585 +19712 280517 +18085 280506 +15792 280423 +19747 280412 +8315 280313 +39683 280210 +4679 280163 +14674 280064 +23039 280029 +20707 280003 +21014 279940 +10250 279930 +11936 279904 +15062 279814 +13588 279790 +11975 279759 +16528 279751 +24687 279670 +15616 279652 +11119 279609 +20355 279492 +9458 279484 +2603 279343 +6335 279249 +2340 279229 +17423 279191 +23623 279109 +17325 279054 +3570 278931 +13551 278846 +12995 278839 +18168 278838 +5781 278820 +9986 278790 +4112 278768 +13184 278726 +15890 278588 +18678 278548 +14213 278519 +1979 278509 +16420 278503 +13111 278460 +3846 278452 +5643 278436 +872 278359 +11868 278353 +12688 278278 +14273 278220 +40466 278181 +20700 278103 +14888 277999 +10218 277984 +16940 277960 +2072 277862 +12348 277847 +35946 277842 +16029 277774 +1013 277769 +28840 277738 +2896 277683 +15505 277680 +6446 277613 +8691 277549 +1298 277514 +14752 277419 +5714 277364 +8058 277325 +20894 277293 +16434 277271 +32115 277243 +10667 277221 +5889 277187 +16210 277086 +19788 277074 +3533 277064 +23555 277023 +8177 276841 +10045 276692 +1712 276688 +1335 276680 +20139 276667 +19245 276644 +10652 276628 +12798 276600 +16332 276591 +1702 276565 +13466 276542 +7894 276539 +13750 276477 +28070 276466 +4801 276375 +8758 276319 +6121 276242 +15599 276225 +9216 276173 +18913 276162 +15257 276075 +15397 276033 +12079 275990 +9154 275941 +9066 275923 +10041 275851 +18685 275759 +19362 275648 +5748 275520 +4134 275490 +10968 275417 +8116 275403 +20337 275390 +9676 275296 +14523 275249 +10280 275230 +11829 275119 +9864 275070 +2313 275056 +11010 275033 +1967 274991 +11611 274774 +17836 274745 +7967 274431 +9080 274379 +13891 274378 +11069 274377 +9197 274377 +6487 274363 +48198 274323 +11164 274304 +14725 274301 +12868 274287 +977 274251 +18358 274249 +11072 274222 +8405 273995 +13110 273961 +1436 273939 +9812 273852 +38251 273850 +4976 273834 +37175 273792 +4279 273790 +5756 273779 +10637 273707 +10130 273685 +6080 273601 +12182 273585 +7202 273453 +8850 273393 +1763 273379 +10498 273327 +2387 273318 +14058 273304 +15360 273269 +5572 273260 +6300 273225 +9193 273201 +4873 273182 +18034 273131 +10643 273103 +18966 273048 +13338 273037 +17468 273016 +8942 272969 +10706 272949 +12553 272893 +18353 272878 +15623 272786 +13573 272782 +15901 272749 +9441 272650 +10813 272641 +8735 272558 +6721 272540 +8338 272518 +22905 272496 +9639 272495 +8500 272427 +8099 272380 +9148 272311 +5854 272243 +10204 272231 +20222 272164 +10616 272112 +7036 272099 +12203 272005 +9927 271973 +2528 271969 +14672 271956 +20710 271955 +14481 271954 +13938 271929 +10776 271845 +17588 271844 +36309 271778 +6546 271746 +15296 271737 +9508 271628 +20522 271611 +2172 271603 +8202 271578 +12829 271575 +19800 271532 +26763 271446 +6752 271369 +43577 271245 +11256 271209 +19717 271164 +8095 271162 +11095 271143 +3849 271032 +8235 271029 +738 270906 +11559 270890 +20059 270852 +13408 270845 +3028 270826 +5700 270819 +2382 270815 +8033 270752 +9796 270711 +9707 270670 +15586 270602 +11263 270508 +13032 270474 +3982 270469 +18066 270444 +13059 270444 +14064 270365 +14085 270332 +28145 270328 +12911 270252 +11558 270112 +16239 270107 +15188 270048 +23761 270032 +5826 269980 +11032 269966 +20782 269958 +17838 269931 +13546 269902 +13041 269892 +16831 269852 +14779 269849 +5222 269801 +24711 269796 +36763 269737 +28125 269727 +11462 269718 +17913 269702 +5499 269615 +25335 269614 +14663 269604 +21730 269511 +14912 269493 +8711 269479 +12014 269429 +10436 269409 +14142 269313 +9888 269307 +18513 269211 +12651 269198 +13413 269143 +10261 269129 +1875 269121 +19101 269115 +20259 269074 +6581 268988 +11832 268914 +6224 268884 +11557 268878 +14667 268836 +9713 268811 +4943 268781 +16383 268725 +17704 268673 +20581 268654 +17642 268565 +15348 268558 +8798 268409 +9826 268357 +18772 268355 +13977 268336 +12436 268316 +11357 268262 +9305 268185 +11949 268141 +8509 268137 +10176 268091 +20529 268080 +14260 268054 +16246 268025 +7577 268019 +22635 267980 +12411 267878 +15220 267832 +16902 267772 +15726 267705 +17475 267693 +11997 267649 +9719 267643 +9966 267593 +11706 267584 +27993 267517 +9698 267510 +16769 267493 +12520 267425 +18939 267423 +6998 267352 +13714 267345 +7988 267328 +5432 267300 +9159 267270 +970 267247 +1883 267156 +12597 267130 +969 267116 +7851 267079 +11396 267044 +6319 267022 +7572 267019 +13487 267000 +13586 266983 +25945 266865 +11135 266858 +20426 266817 +22183 266781 +16334 266772 +20325 266757 +21494 266718 +5626 266678 +14033 266677 +2731 266637 +18212 266575 +12601 266521 +8396 266504 +10584 266501 +9829 266467 +5128 266439 +4718 266285 +8283 266232 +3163 266200 +18665 266165 +14043 266065 +2140 266017 +19553 265926 +12724 265897 +12908 265737 +22933 265703 +13990 265584 +15463 265520 +9162 265465 +14517 265285 +12336 265242 +5408 265206 +17167 265200 +15971 265164 +25651 265080 +8727 265079 +19017 265072 +33160 265025 +21147 264980 +16893 264915 +16797 264903 +13684 264899 +9849 264890 +16559 264831 +14718 264765 +12655 264748 +4023 264639 +9947 264581 +16155 264574 +31594 264544 +6104 264519 +15806 264392 +21221 264345 +1397 264227 +4083 264178 +23394 264177 +10083 264160 +33328 264146 +6156 264080 +12939 264080 +9950 264074 +8166 264059 +15030 264027 +32324 263999 +12346 263955 +13474 263950 +11874 263884 +19995 263882 +130 263839 +14634 263819 +5646 263795 +5421 263702 +7294 263697 +17165 263670 +6764 263622 +12503 263616 +6428 263585 +12225 263506 +4853 263495 +24161 263476 +7268 263464 +10829 263388 +8399 263381 +11694 263379 +8341 263349 +10689 263278 +17788 263200 +15832 263001 +10485 262951 +17053 262897 +98 262873 +15503 262806 +10393 262799 +21026 262785 +16089 262736 +7145 262696 +14329 262691 +10988 262667 +4938 262617 +6631 262431 +13094 262414 +4759 262370 +10713 262359 +722 262358 +6607 262294 +10338 262229 +27459 262199 +1985 262192 +8005 262074 +11160 262045 +20065 262043 +2530 262029 +9917 262001 +11107 261971 +5245 261877 +8842 261858 +13244 261844 +1756 261828 +18624 261697 +18496 261651 +13640 261637 +13234 261637 +12460 261630 +13688 261554 +934 261540 +13998 261539 +3949 261532 +15591 261500 +10766 261405 +13463 261377 +3498 261340 +7853 261336 +13657 261333 +16565 261324 +11266 261295 +10050 261267 +17187 261200 +7468 261148 +6570 261101 +9112 261095 +12841 261041 +15465 260960 +19868 260941 +14742 260914 +12080 260898 +12008 260822 +9514 260792 +8968 260774 +18240 260745 +10453 260671 +20614 260614 +12162 260544 +13534 260539 +1207 260515 +19675 260494 +5211 260493 +7532 260462 +27116 260264 +18014 260241 +4272 260231 +12101 260002 +20055 260002 +18184 259947 +21742 259850 +8187 259823 +789 259784 +7073 259779 +11338 259732 +14710 259554 +13820 259548 +16918 259503 +18327 259488 +5354 259482 +1154 259371 +13112 259364 +5411 259218 +17413 259156 +7570 259098 +17028 259065 +3775 259024 +7576 258971 +10495 258913 +6127 258860 +3742 258785 +3524 258778 +29002 258748 +15438 258703 +4948 258702 +19804 258665 +5899 258622 +2197 258614 +6453 258581 +13293 258579 +24880 258460 +9850 258441 +6974 258388 +6488 258313 +13475 258303 +9637 258255 +20633 258235 +20920 258220 +12910 258106 +11326 258084 +15443 258081 +6577 258043 +11323 258035 +8300 258029 +5735 257973 +15415 257934 +16449 257901 +2531 257843 +6894 257785 +6968 257729 +11418 257714 +8449 257532 +7688 257450 +22257 257392 +13134 257380 +8807 257349 +11281 257236 +16076 257119 +14110 257102 +27061 257101 +20430 257077 +6098 257021 +12890 257009 +5779 257002 +6473 256775 +11236 256721 +10403 256692 +3943 256662 +20052 256644 +8441 256628 +18899 256570 +14067 256490 +11576 256482 +10884 256474 +12616 256472 +4111 256447 +16905 256399 +14903 256344 +11195 256341 +7780 256319 +1164 256273 +8967 256253 +3493 256114 +8752 256058 +2541 256032 +10392 256030 +10581 255868 +3378 255861 +1798 255786 +5629 255752 +15191 255708 +11204 255626 +5536 255621 +18473 255525 +28209 255401 +8797 255344 +28086 255308 +5935 255300 +9369 255253 +8781 255237 +14601 255157 +235 255145 +755 255125 +6715 255118 +12457 255082 +3779 255039 +21525 255029 +18193 254999 +4447 254987 +24577 254972 +13069 254847 +12598 254776 +2564 254772 +11274 254713 +9765 254691 +16849 254651 +23425 254644 +22016 254589 +348 254584 +8977 254497 +10190 254449 +20442 254376 +10627 254325 +10417 254323 +13982 254312 +11353 254285 +24538 254246 +13478 254180 +7660 254144 +11131 254100 +14285 254067 +7646 254033 +12201 253999 +11029 253849 +11513 253830 +17218 253821 +1291 253782 +22159 253746 +11847 253742 +11422 253730 +4980 253724 +19817 253712 +9526 253590 +8324 253576 +7439 253554 +3575 253498 +6915 253302 +18406 253209 +14559 253205 +11853 253138 +10724 253101 +15976 253017 +4335 252999 +18489 252895 +19323 252807 +11746 252702 +4117 252677 +16443 252637 +14954 252628 +16028 252566 +15224 252495 +9961 252455 +9300 252455 +840 252429 +5513 252399 +6485 252340 +13016 252335 +10647 252236 +12556 252163 +36103 252155 +5822 252148 +10574 252130 +14159 252092 +14103 251995 +3007 251941 +4868 251923 +11608 251871 +15543 251818 +12627 251743 +2632 251725 +17369 251625 +21605 251579 +23201 251546 +11614 251528 +14636 251438 +14113 251425 +10996 251405 +1059 251391 +17277 251368 +12325 251362 +17676 251307 +15760 251285 +1358 251238 +11925 251213 +35851 251159 +16179 251087 +9506 251020 +9405 251012 +14581 250999 +21714 250981 +15866 250957 +19292 250939 +13778 250936 +2721 250909 +16805 250843 +9609 250738 +2894 250728 +1481 250694 +14984 250681 +12187 250629 +16209 250606 +6667 250598 +12039 250592 +26351 250590 +19464 250589 +3847 250521 +10096 250519 +28143 250431 +11561 250430 +18755 250425 +6831 250402 +5345 250399 +18303 250342 +12744 250205 +17645 250183 +472 250178 +13258 250161 +7889 250156 +13985 250150 +3100 250117 +12399 250031 +11842 250024 +6770 250012 +6028 249984 +19422 249883 +6185 249881 +16095 249875 +14442 249839 +18277 249820 +14008 249716 +4780 249716 +10564 249657 +7935 249650 +6524 249633 +14261 249603 +10942 249535 +8201 249530 +21872 249484 +12387 249481 +5159 249453 +11963 249430 +10852 249408 +20572 249303 +37985 249161 +26225 249133 +1428 249004 +23267 248991 +22347 248928 +542 248860 +28162 248806 +4226 248801 +11675 248800 +8947 248788 +1534 248786 +41224 248756 +9768 248730 +13677 248668 +10844 248660 +15123 248616 +37379 248570 +25672 248531 +9324 248483 +14196 248438 +12097 248435 +19687 248328 +8861 248293 +13279 248278 +13835 248278 +10975 248165 +25682 248143 +8532 248039 +11751 247945 +18524 247934 +19886 247924 +11483 247918 +29393 247899 +3003 247868 +21532 247858 +11886 247855 +9919 247809 +8579 247739 +7508 247717 +5178 247696 +10958 247675 +11760 247663 +8788 247636 +14000 247605 +17104 247525 +11574 247443 +16824 247389 +17551 247323 +2363 247278 +8117 247274 +15970 247271 +15401 247260 +19339 247215 +21336 247052 +5277 246999 +9905 246986 +15461 246929 +1426 246892 +12010 246866 +14665 246863 +7700 246845 +10825 246814 +1384 246762 +26360 246755 +14166 246713 +19786 246710 +1447 246566 +17871 246562 +4170 246466 +12802 246446 +17735 246443 +13863 246416 +9987 246399 +6771 246369 +12037 246276 +9922 246272 +11298 246270 +14071 246245 +12818 246200 +2002 246197 +2899 246184 +12034 246175 +14111 246152 +12287 246149 +18080 246097 +13892 246079 +6102 246042 +18158 246018 +14644 245998 +6158 245996 +12242 245993 +12058 245991 +1837 245897 +700 245844 +8554 245716 +3372 245711 +1287 245705 +1126 245700 +13237 245676 +2906 245653 +4472 245609 +14148 245596 +9715 245545 +11740 245521 +2320 245503 +24782 245428 +9721 245401 +822 245388 +23063 245383 +2416 245248 +44155 245172 +49443 245152 +19522 245137 +712 245074 +22297 245043 +10744 245042 +15395 244980 +9837 244959 +16674 244923 +9220 244912 +5532 244856 +10077 244828 +9686 244823 +14236 244822 +2676 244770 +12132 244758 +9050 244729 +14226 244674 +13157 244611 +17699 244469 +17038 244387 +6893 244356 +13504 244340 +10047 244337 +22867 244314 +13091 244305 +10435 244293 +33672 244254 +15600 244222 +21796 244154 +14971 244148 +20531 244110 +12170 244096 +24721 244062 +37129 244008 +18183 243979 +17559 243908 +15238 243887 +19436 243839 +811 243838 +15006 243778 +15097 243778 +18329 243649 +20536 243618 +4665 243601 +13969 243595 +11342 243536 +579 243534 +15013 243522 +6700 243506 +13524 243505 +7402 243497 +8280 243462 +10301 243456 +21291 243454 +19167 243434 +13472 243353 +20472 243313 +13011 243279 +16238 243267 +17996 243223 +16534 243174 +11811 243163 +1614 243152 +18704 243103 +9217 243076 +5949 243011 +19090 242932 +9923 242910 +12086 242909 +7461 242849 +12700 242795 +18373 242776 +17371 242768 +5563 242766 +47201 242738 +21070 242727 +17634 242709 +10425 242709 +8434 242578 +5305 242536 +13252 242499 +14348 242487 +9246 242471 +15150 242436 +12500 242426 +17528 242424 +18887 242414 +24116 242389 +23488 242387 +7101 242331 +12973 242273 +2617 242131 +7222 242040 +20330 241995 +15713 241800 +16787 241745 +19307 241718 +18884 241713 +14960 241706 +957 241671 +14748 241658 +7102 241557 +7006 241500 +6340 241483 +8946 241477 +17832 241462 +17905 241448 +26244 241403 +15812 241375 +11770 241368 +9661 241361 +17591 241249 +12729 241190 +26058 241190 +6663 241181 +14923 241131 +20131 241093 +21668 241073 +18470 241045 +4852 241036 +24568 241000 +8835 240978 +31259 240907 +13214 240824 +1746 240812 +4597 240806 +11006 240802 +394 240783 +14713 240716 +13535 240664 +14702 240509 +10323 240409 +19025 240405 +15403 240391 +15470 240322 +10682 240296 +10111 240284 +18518 240277 +7160 240260 +15707 240246 +16452 240209 +14178 240201 +16032 240154 +19116 240139 +8113 240113 +13852 240086 +14022 240037 +12591 239957 +14649 239945 +14339 239916 +21474 239915 +17709 239869 +21952 239817 +8264 239800 +17285 239799 +15737 239731 +17205 239671 +12622 239654 +15444 239648 +16316 239634 +2096 239603 +22948 239581 +9988 239554 +15462 239547 +13167 239539 +3989 239496 +14347 239410 +7911 239385 +18950 239341 +16012 239331 +15779 239300 +13245 239217 +10939 239205 +43208 239145 +8044 239110 +32537 239109 +9109 239055 +16468 239053 +9831 239022 +12289 239015 +12473 239008 +18956 238967 +14034 238965 +32390 238949 +1603 238943 +14759 238899 +19568 238873 +11312 238863 +33448 238862 +12602 238848 +10863 238822 +11508 238722 +1721 238695 +15347 238681 +13473 238680 +14443 238591 +32482 238579 +21305 238555 +2412 238509 +24964 238499 +9433 238479 +12778 238475 +5183 238472 +9749 238441 +6707 238429 +13232 238307 +18410 238305 +9977 238236 +8167 238147 +6089 238087 +2262 238000 +23058 237971 +14009 237931 +14218 237929 +8856 237914 +21938 237904 +9865 237862 +23698 237825 +22261 237799 +12066 237794 +19614 237663 +21550 237644 +6503 237632 +21421 237611 +4407 237500 +18728 237407 +12585 237404 +18190 237370 +13913 237323 +6327 237314 +7091 237275 +7484 237239 +14807 237233 +19919 237104 +2240 237027 +12883 237006 +12672 236984 +17245 236981 +18613 236789 +16135 236789 +44510 236747 +35409 236737 +15031 236551 +12013 236527 +15386 236516 +17176 236497 +10815 236496 +10492 236470 +10911 236469 +13537 236392 +4243 236333 +6400 236316 +29007 236291 +7631 236276 +8314 236264 +20765 236214 +23559 236191 +39859 236188 +14123 236160 +113 236154 +5580 236071 +9257 236046 +10670 236036 +15773 236026 +20395 235988 +18889 235975 +3681 235975 +19136 235965 +14552 235898 +8768 235870 +17075 235844 +7031 235821 +18073 235812 +18311 235801 +4822 235768 +25158 235758 +17906 235743 +17016 235723 +17355 235718 +11170 235613 +7129 235589 +23128 235587 +10746 235529 +3960 235490 +19819 235460 +7177 235452 +8996 235421 +16659 235413 +1070 235407 +4157 235389 +8304 235384 +20604 235267 +7834 235243 +10048 235231 +11270 235182 +13701 235151 +16689 235144 +8718 235065 +39999 235029 +15530 235010 +10598 235006 +19477 234921 +22923 234913 +19834 234897 +19603 234886 +8604 234842 +22230 234835 +10312 234832 +13885 234797 +15280 234727 +13754 234708 +15841 234647 +13622 234596 +12412 234580 +7122 234532 +22874 234512 +11546 234510 +12123 234453 +31995 234438 +18623 234425 +10090 234380 +11506 234346 +16295 234317 +28282 234313 +9907 234307 +17030 234286 +15364 234266 +2781 234214 +15273 234174 +9425 234152 +8599 234104 +10912 234073 +19887 234033 +12278 234000 +8779 233995 +928 233978 +22410 233978 +37186 233977 +10552 233962 +17785 233866 +3137 233815 +2286 233801 +12588 233798 +11446 233668 +20209 233640 +11541 233540 +13118 233501 +20994 233463 +7299 233456 +20495 233430 +14615 233395 +12028 233375 +13771 233371 +19940 233078 +10715 233075 +11940 233049 +15744 233012 +14023 233010 +21298 232991 +10755 232962 +12445 232844 +15849 232811 +12161 232793 +13488 232737 +19627 232725 +14303 232713 +9970 232693 +17155 232615 +16293 232590 +18423 232583 +12917 232573 +13225 232560 +16816 232513 +22137 232462 +2550 232439 +39970 232428 +1749 232423 +26053 232383 +7231 232347 +24540 232344 +12452 232280 +20890 232235 +5304 232190 +10861 232125 +5026 232123 +25763 232111 +15375 232100 +20882 232062 +29224 232056 +17051 232023 +6068 231967 +20377 231908 +15868 231882 +21588 231866 +478 231844 +9004 231835 +10025 231767 +3916 231764 +28058 231697 +6324 231683 +18039 231677 +14891 231669 +9009 231622 +9215 231608 +3515 231529 +12316 231500 +10225 231487 +13895 231467 +14790 231452 +1831 231443 +10537 231322 +7571 231276 +19790 231269 +16115 231247 +12990 231210 +7590 231116 +3699 231084 +3041 231078 +12566 231025 +12191 231001 +13613 230993 +8447 230991 +5770 230906 +45811 230849 +1557 230840 +12059 230775 +5120 230749 +6124 230744 +8595 230721 +9718 230711 +12872 230700 +10066 230682 +26280 230666 +14053 230646 +16126 230641 +20815 230603 +20903 230557 +916 230552 +241 230545 +17654 230421 +20202 230418 +5542 230400 +3109 230337 +17364 230305 +3174 230284 +17797 230253 +31561 230216 +13105 230200 +9656 230199 +16639 230184 +11835 230183 +6139 230117 +9082 230099 +14287 230049 +18280 230024 +25670 229987 +7430 229958 +18481 229950 +22671 229936 +11084 229910 +12174 229895 +11073 229858 +13756 229837 +17600 229795 +11447 229737 +8845 229737 +15534 229685 +21576 229658 +3522 229633 +19405 229593 +14381 229582 +18866 229566 +4033 229525 +12075 229520 +22536 229517 +19947 229507 +16280 229473 +6203 229472 +15491 229435 +8563 229365 +11680 229308 +20799 229304 +13705 229298 +18933 229208 +17266 229208 +14462 229158 +12742 229153 +23669 229130 +20382 229080 +10889 229078 +20565 229060 +12439 229004 +5686 228929 +16467 228914 +17542 228834 +11764 228816 +13693 228765 +10823 228749 +15892 228474 +30452 228448 +10472 228390 +16610 228364 +9236 228343 +24174 228330 +17476 228315 +15800 228213 +15981 228148 +7236 228132 +26199 228108 +2684 228107 +3103 228045 +12133 228039 +9672 228007 +4532 228006 +10900 227989 +8924 227958 +8799 227886 +10224 227883 +28986 227838 +10797 227833 +2782 227758 +33007 227718 +12463 227636 +29367 227597 +7221 227558 +12739 227509 +26597 227410 +12914 227402 +20656 227371 +22372 227348 +12954 227344 +4919 227333 +1996 227306 +14516 227304 +19584 227302 +33467 227285 +15549 227265 +14451 227254 +25176 227163 +8513 227110 +9265 227079 +5825 227077 +16916 227064 +8837 227058 +11304 227013 +16525 226927 +13881 226803 +10817 226749 +21513 226745 +48716 226692 +7218 226646 +5019 226635 +38526 226632 +15436 226625 +10175 226595 +8529 226551 +22167 226539 +1520 226496 +8173 226474 +8959 226444 +29411 226444 +10195 226443 +1465 226389 +1025 226359 +2265 226346 +2243 226311 +10592 226276 +12912 226248 +13819 226212 +10972 226199 +13043 226171 +21088 226141 +11620 226139 +22221 226136 +21233 226136 +2575 226078 +7729 226071 +11314 226060 +14845 225997 +5661 225991 +13273 225979 +2385 225975 +21512 225910 +5937 225907 +16330 225870 +4299 225870 +15662 225857 +22750 225820 +11478 225806 +22925 225769 +24033 225758 +13643 225757 +21097 225757 +1162 225739 +17058 225730 +17487 225677 +15077 225668 +6759 225659 +29293 225603 +17807 225584 +6181 225569 +8893 225560 +23547 225538 +17507 225495 +15928 225483 +5164 225472 +117 225463 +17195 225402 +15852 225393 +14431 225373 +19478 225368 +20695 225363 +15318 225341 +17494 225257 +12062 225251 +22908 225210 +15771 225198 +224 225168 +30958 225155 +12686 225055 +13638 225016 +19388 225000 +14703 224981 +16970 224976 +2454 224974 +17690 224952 +20409 224908 +20111 224898 +19765 224893 +11759 224893 +22081 224874 +9316 224841 +16517 224830 +6306 224819 +1540 224790 +13156 224756 +14212 224670 +14554 224670 +9978 224653 +23889 224643 +9701 224604 +10451 224582 +8534 224555 +14900 224517 +6045 224382 +8476 224300 +17691 224299 +4768 224263 +21995 224248 +8901 224228 +15313 224200 +15567 224200 +26040 224190 +36753 224177 +30289 224128 +13053 224119 +8045 224114 +12581 224098 +10532 224031 +14471 224019 +10422 224014 +14129 223973 +10619 223972 +14643 223911 +17217 223859 +18169 223852 +13355 223803 +6742 223772 +4262 223693 +2809 223686 +14430 223638 +10001 223524 +20516 223522 +12974 223505 +16566 223488 +7989 223485 +11445 223472 +13044 223433 +3856 223428 +10349 223409 +14855 223408 +17113 223375 +13388 223352 +14738 223342 +5126 223298 +6684 223218 +13675 223215 +12092 223199 +11380 223127 +14608 223060 +8011 223015 +13453 223013 +3898 222961 +20492 222958 +12300 222874 +16400 222852 +22281 222839 +12218 222818 +15608 222811 +35253 222785 +5074 222748 +13641 222731 +49280 222731 +20769 222727 +6955 222709 +7481 222695 +19502 222671 +1386 222670 +8695 222613 +9344 222608 +237 222484 +21408 222483 +5972 222470 +7196 222462 +17967 222444 +26702 222349 +20940 222340 +16403 222307 +15425 222295 +14256 222285 +17374 222212 +10580 222212 +21776 222204 +13013 222189 +24573 222178 +14109 222164 +3300 222160 +4017 222053 +12330 222052 +13679 222039 +11384 222000 +13477 221999 +8169 221984 +8068 221968 +23647 221922 +9944 221915 +906 221889 +5934 221882 +26603 221847 +10276 221841 +11382 221793 +12971 221790 +3021 221779 +10945 221752 +9221 221735 +23720 221725 +10770 221698 +14305 221674 +23990 221645 +3225 221614 +13720 221600 +13334 221578 +1151 221567 +16378 221516 +1072 221490 +48160 221489 +31033 221484 +1412 221480 +12560 221416 +13670 221410 +14096 221391 +16002 221375 +16732 221374 +3383 221339 +13514 221325 +3481 221313 +8800 221265 +17668 221262 +10690 221256 +12247 221236 +2135 221229 +17716 221203 +3080 221187 +21205 221165 +15895 221164 +9618 221164 +40196 221132 +20541 221101 +9976 221070 +5796 221049 +11436 221034 +7972 221000 +21679 220976 +5060 220952 +18653 220948 +13823 220936 +10745 220919 +18103 220907 +9521 220896 +11492 220856 +10959 220757 +16825 220751 +7080 220723 +17025 220694 +15519 220606 +11873 220606 +15698 220593 +16117 220569 +18921 220522 +2490 220511 +15449 220499 +32777 220459 +12856 220431 +14042 220401 +2535 220336 +999 220320 +8748 220319 +22966 220306 +16615 220206 +30303 220200 +21724 220193 +15679 220149 +35912 220141 +16568 220080 +13995 220065 +23075 220052 +16413 220030 +13351 220009 +5534 220005 +14044 219957 +18675 219945 +6881 219871 +18751 219864 +123 219758 +21791 219714 +15210 219709 +773 219683 +10547 219682 +5757 219678 +15018 219671 +10524 219668 +10933 219637 +18828 219624 +16013 219618 +13133 219536 +10426 219525 +16757 219524 +3903 219524 +15893 219477 +3488 219405 +13528 219373 +3014 219331 +24287 219327 +16798 219323 +19994 219277 +14958 219254 +6865 219234 +24434 219228 +42623 219200 +5231 219155 +9039 219130 +18727 219118 +16937 219109 +27943 219103 +22724 219087 +11085 219087 +23794 219086 +9607 219056 +19660 219029 +4411 218968 +14090 218928 +17337 218915 +22693 218906 +9190 218872 +12297 218858 +5263 218728 +8655 218726 +49258 218675 +3684 218645 +27620 218613 +24712 218557 +9914 218554 +11110 218532 +20893 218523 +17830 218518 +4389 218498 +23400 218425 +11583 218403 +2768 218401 +24537 218396 +7343 218395 +17370 218395 +21406 218351 +15032 218351 +10181 218300 +8231 218226 +12030 218226 +20097 218153 +13428 218146 +18532 218134 +8823 218128 +12846 218114 +9455 218081 +13209 218080 +16310 218054 +20464 218046 +11843 218044 +15203 218041 +10577 218034 +20955 217996 +8548 217983 +10849 217980 +12333 217976 +8630 217966 +18284 217888 +9740 217809 +1221 217776 +7899 217760 +10011 217740 +7626 217665 +13558 217631 +18914 217578 +15937 217549 +29611 217546 +15894 217527 +9030 217526 +18241 217517 +26315 217499 +11511 217481 +23696 217456 +11391 217437 +11067 217404 +1213 217394 +22861 217392 +12834 217369 +10283 217326 +40912 217323 +12716 217304 +14545 217260 +16381 217225 +15207 217189 +4703 217182 +13261 217111 +16050 217102 +17100 217085 +15171 217048 +12639 217029 +10960 217025 +22957 216931 +12950 216859 +18456 216850 +15757 216841 +12704 216839 +12702 216778 +17945 216772 +14342 216745 +23724 216736 +9028 216726 +18901 216711 +3543 216674 +21376 216672 +15734 216671 +3934 216663 +8722 216500 +27987 216482 +20138 216439 +14037 216414 +14491 216413 +2843 216352 +22421 216341 +13578 216333 +16862 216275 +12554 216271 +28537 216255 +5173 216251 +12549 216248 +21623 216176 +17456 216144 +16484 216142 +17659 216113 +17736 216061 +7079 216055 +21913 215938 +14764 215893 +11443 215865 +11776 215842 +31873 215831 +4738 215782 +18501 215701 +12694 215684 +19625 215672 +19003 215654 +6460 215618 +12127 215615 +16160 215607 +12094 215525 +10249 215518 +15045 215504 +10424 215428 +5605 215404 +12082 215401 +17092 215391 +13054 215323 +14288 215244 +9472 215228 +18711 215207 +16538 215140 +15074 215093 +19975 215087 +11816 215077 +28288 215071 +17884 215042 +3937 215038 +12797 214963 +22600 214939 +23475 214902 +5393 214860 +5979 214807 +10802 214804 +1801 214787 +967 214768 +10488 214663 +14263 214634 +10857 214609 +31157 214596 +8905 214546 +4714 214537 +17029 214532 +23368 214500 +15570 214476 +33496 214457 +17445 214346 +13206 214340 +24416 214331 +2487 214279 +18494 214232 +8577 214231 +22028 214210 +3617 214151 +12372 214126 +41805 214121 +13792 214118 +14869 214110 +12713 214089 +11219 214037 +9527 214012 +688 214000 +8627 213979 +3118 213865 +11022 213825 +18136 213766 +16749 213678 +2207 213676 +5167 213671 +12125 213643 +27227 213623 +6857 213550 +12864 213535 +1308 213529 +17397 213499 +23593 213362 +16035 213342 +11917 213329 +9124 213275 +13774 213224 +14183 213191 +22161 213177 +15427 213148 +15233 213144 +12055 213128 +971 213066 +3723 213027 +10640 213027 +13941 213025 +36128 213014 +11091 213006 +17034 212967 +23166 212933 +9370 212901 +10686 212857 +23751 212844 +31777 212803 +19138 212754 +24579 212728 +8858 212692 +5930 212671 +12476 212652 +6580 212651 +6972 212647 +13669 212629 +6383 212600 +18419 212599 +8284 212585 +23015 212571 +19582 212553 +8070 212508 +8855 212503 +9056 212502 +15727 212495 +5276 212469 +14833 212421 +9535 212418 +18152 212403 +9577 212394 +15240 212379 +15607 212375 +24323 212369 +11444 212362 +14973 212361 +17853 212358 +13937 212356 +17313 212347 +6808 212331 +24663 212323 +19033 212285 +11317 212254 +12296 212141 +20365 212058 +14284 212016 +15808 211962 +15955 211952 +16392 211948 +6297 211881 +1856 211881 +14186 211830 +2288 211802 +5837 211713 +2664 211706 +14604 211705 +14901 211645 +28190 211626 +22101 211577 +18330 211516 +19896 211500 +21523 211488 +11392 211463 +2618 211419 +14450 211415 +11904 211401 +11859 211384 +17444 211351 +9343 211266 +2770 211247 +20243 211246 +14659 211228 +9430 211228 +12077 211197 +14732 211181 +15704 211147 +21946 211139 +12269 211069 +11731 211062 +11672 211055 +17872 210994 +15668 210988 +14548 210950 +12969 210928 +1235 210923 +15215 210892 +10909 210879 +48798 210872 +3428 210853 +1523 210844 +12916 210814 +13027 210809 +11728 210779 +29073 210714 +13888 210709 +16846 210705 +9612 210673 +10162 210657 +16085 210643 +14320 210584 +13619 210579 +23194 210418 +19077 210354 +8159 210295 +20118 210278 +24821 210256 +16651 210150 +22637 210124 +2709 210072 +19163 210068 +15254 210067 +44600 210015 +9419 210007 +13988 209990 +15550 209888 +13204 209858 +22280 209856 +17422 209842 +11697 209839 +12936 209801 +11186 209777 +35621 209746 +10164 209721 +18918 209712 +633 209613 +20776 209595 +13737 209449 +31506 209446 +17424 209442 +8226 209393 +24868 209374 +12624 209351 +12511 209343 +2927 209279 +8080 209270 +14740 209255 +5838 209214 +5959 209211 +22548 209176 +13536 209058 +19174 209012 +24144 209012 +18845 208893 +26402 208846 +1156 208837 +12594 208796 +2533 208779 +14358 208763 +36485 208754 +11888 208739 +7232 208733 +23526 208652 +3610 208564 +20178 208484 +43998 208460 +10926 208352 +3458 208345 +13816 208330 +38742 208301 +14081 208278 +11399 208260 +20085 208192 +13961 208187 +12805 208183 +14614 208174 +3883 208152 +1885 208139 +3008 208126 +23639 208079 +17070 208016 +5283 207990 +9341 207938 +5476 207931 +9684 207911 +19661 207893 +11564 207862 +19105 207862 +22847 207837 +16007 207836 +11524 207827 +15144 207818 +21468 207755 +16914 207689 +18404 207670 +12390 207654 +17840 207497 +16008 207494 +45871 207470 +2586 207461 +14628 207455 +18265 207430 +18614 207428 +7081 207359 +8770 207356 +5297 207336 +18798 207306 +15525 207287 +19808 207251 +14506 207241 +20400 207080 +12788 207060 +14741 207043 +41153 207022 +32922 207010 +8160 206987 +1529 206971 +9379 206951 +13721 206944 +10347 206925 +3247 206897 +13387 206828 +19043 206818 +1815 206782 +23894 206771 +16053 206753 +3852 206737 +18075 206716 +9941 206709 +24576 206705 +23174 206693 +12471 206688 +2153 206680 +3304 206669 +18476 206649 +43318 206638 +14293 206636 +4494 206621 +12319 206566 +29533 206556 +12120 206522 +7931 206512 +19284 206500 +1851 206486 +5594 206411 +4990 206402 +3618 206396 +3201 206381 +14401 206362 +19902 206336 +14321 206300 +17322 206286 +11941 206270 +20110 206225 +18222 206211 +17780 206209 +17536 206137 +1118 206127 +11496 206117 +23430 206105 +10932 206102 +17390 206059 +13646 206043 +6653 206006 +16494 205987 +23358 205935 +10438 205877 +8979 205865 +15281 205825 +6302 205821 +11678 205815 +3353 205776 +20819 205742 +13224 205690 +14499 205675 +23554 205671 +28113 205647 +9495 205646 +5576 205637 +16048 205569 +12459 205499 +33597 205435 +7645 205422 +13790 205322 +15542 205315 +46245 205291 +18895 205274 +12244 205269 +20081 205229 +7284 205225 +25869 205181 +24392 205170 +10565 205124 +13611 205121 +6500 205103 +16261 205096 +14147 205064 +6649 205025 +6819 205001 +17272 204957 +8822 204956 +39726 204889 +4400 204876 +9306 204876 +9229 204814 +6747 204801 +12842 204800 +9704 204776 +35747 204774 +9830 204741 +15500 204721 +9930 204720 +14502 204642 +11315 204596 +19732 204574 +9312 204415 +21146 204408 +14496 204374 +11875 204360 +15859 204334 +30917 204299 +8763 204243 +17023 204218 +1779 204140 +13407 204123 +21462 204106 +14802 204105 +18352 204097 +14556 204094 +11378 204029 +17252 203976 +14660 203975 +30102 203960 +18730 203909 +15107 203853 +6091 203824 +6911 203759 +17432 203643 +14393 203587 +19530 203585 +9578 203567 +25890 203504 +13872 203480 +25415 203476 +20533 203450 +19911 203416 +13879 203386 +12579 203381 +3545 203356 +19210 203348 +20163 203348 +14942 203332 +21371 203316 +20091 203230 +10362 203162 +15516 203101 +24836 203043 +14877 203030 +18515 203027 +12985 203014 +11971 202922 +16490 202920 +14241 202830 +9113 202823 +17931 202801 +10862 202692 +21835 202678 +24175 202629 +8906 202566 +22799 202531 +24389 202517 +10620 202510 +23638 202485 +14946 202399 +29602 202361 +6021 202316 +15736 202310 +16078 202283 +1131 202258 +15869 202240 +13181 202236 +1311 202227 +3082 202222 +10920 202218 +24153 202190 +11173 202148 +21997 202148 +17304 202107 +18210 202094 +13803 202072 +7206 202055 +15953 202037 +13549 201990 +3558 201987 +22984 201969 +20953 201925 +13870 201922 +34630 201878 +11152 201875 +20821 201871 +18087 201855 +11815 201831 +17396 201827 +17112 201822 +26283 201750 +7565 201738 +8128 201738 +40055 201718 +22636 201689 +27883 201686 +28047 201679 +22643 201678 +15805 201639 +22207 201629 +15673 201585 +10717 201583 +16637 201556 +15089 201546 +14768 201433 +19304 201430 +25079 201428 +8940 201385 +15499 201358 +13055 201337 +23434 201293 +15035 201291 +22559 201281 +14232 201276 +5840 201267 +13467 201221 +6201 201203 +18319 201201 +18199 201115 +18078 201095 +36458 201045 +13179 201043 +34969 201035 +12555 201016 +24357 201015 +22489 200993 +19635 200941 +12294 200933 +22276 200926 +13205 200911 +31684 200896 +16055 200851 +10664 200848 +1673 200815 +5098 200813 +18322 200775 +5119 200771 +16636 200749 +29394 200726 +13627 200720 +10239 200697 +10716 200671 +8937 200664 +13215 200643 +26914 200631 +18617 200624 +4685 200606 +12822 200605 +5636 200549 +40319 200524 +16783 200520 +21335 200482 +21022 200464 +11299 200458 +27801 200441 +8254 200419 +7676 200363 +8178 200318 +26015 200274 +223 200265 +24527 200249 +2752 200218 +21819 200209 +7958 200165 +15843 200150 +11105 200111 +23524 200102 +10678 200093 +10866 200087 +21284 200061 +13471 200057 +6055 199960 +16736 199936 +18721 199855 +16518 199836 +11635 199796 +1915 199773 +13650 199720 +3828 199718 +13810 199695 +15193 199677 +9916 199675 +10081 199628 +12526 199625 +12647 199611 +25807 199610 +9664 199591 +15314 199455 +16842 199444 +11175 199437 +15531 199413 +34309 199402 +16508 199393 +11104 199386 +7730 199379 +18641 199320 +4173 199281 +8696 199241 +27928 199240 +6603 199220 +10232 199206 +28057 199161 +22553 199146 +26851 199116 +11424 199111 +18757 199088 +5289 199070 +25254 199069 +25125 199065 +14343 198992 +10365 198991 +17936 198991 +27469 198988 +17366 198972 +15154 198972 +4382 198876 +12198 198871 +16759 198834 +14337 198784 +7109 198771 +19740 198641 +17581 198607 +24379 198563 +3816 198537 +9693 198535 +15241 198532 +23817 198507 +18804 198432 +24255 198411 +6107 198349 +17362 198316 +10809 198310 +21116 198310 +5039 198291 +2308 198291 +26088 198236 +18260 198222 +14458 198213 +25389 198156 +21008 198155 +11470 198084 +21859 198070 +11283 198029 +16230 198019 +47809 197994 +13997 197990 +8267 197972 +27011 197967 +12197 197954 +12362 197946 +24131 197924 +10940 197885 +37628 197882 +8811 197822 +14509 197774 +15373 197762 +15515 197717 +16865 197711 +13815 197675 +7813 197661 +12381 197657 +3401 197647 +12273 197626 +21516 197617 +14384 197598 +103 197579 +19135 197563 +18409 197561 +39760 197544 +11634 197538 +20019 197411 +12887 197393 +5956 197370 +24668 197359 +15251 197327 +9342 197322 +27003 197303 +21050 197272 +25759 197268 +25640 197266 +9510 197262 +18204 197255 +9098 197246 +16868 197227 +21507 197214 +15882 197137 +14324 197103 +23827 197101 +9823 197072 +31340 197067 +7326 197066 +10385 196985 +18739 196964 +809 196944 +22319 196940 +19920 196910 +19688 196860 +10478 196853 +11571 196838 +12214 196815 +34058 196793 +16655 196733 +17296 196724 +14611 196714 +14412 196691 +11667 196663 +19413 196620 +8875 196593 +13165 196540 +16734 196518 +24104 196511 +8364 196502 +2326 196500 +5985 196441 +12706 196438 +8208 196390 +5329 196290 +681 196210 +31389 196208 +17135 196207 +25186 196204 +10622 196197 +19843 196177 +9932 196088 +2875 196086 +3798 196083 +9032 196057 +21782 196019 +16083 196002 +8966 195986 +18134 195959 +740 195949 +16118 195920 +17455 195892 +17958 195875 +10326 195842 +40110 195837 +3123 195811 +13035 195796 +12158 195765 +27526 195763 +16551 195691 +24590 195680 +13238 195546 +9340 195533 +19376 195525 +17270 195514 +9048 195472 +13062 195464 +17098 195441 +4968 195439 +13767 195439 +23307 195310 +15221 195299 +5121 195294 +17496 195292 +9513 195226 +9858 195219 +1742 195203 +13910 195163 +10317 195147 +15441 195142 +27606 195130 +28797 195114 +14075 195031 +15819 194979 +17161 194971 +32190 194967 +48063 194956 +2228 194853 +11148 194826 +20569 194815 +10528 194814 +18544 194813 +16384 194776 +11262 194776 +36553 194753 +12838 194747 +12167 194707 +19089 194655 +9442 194643 +15804 194612 +7408 194589 +9714 194544 +13502 194485 +30094 194423 +20758 194418 +7130 194411 +14803 194409 +30683 194325 +3495 194295 +9723 194235 +10375 194199 +19198 194180 +34016 194170 +42897 194156 +16503 194153 +15135 194135 +19964 194121 +24304 194073 +5573 194073 +14307 194006 +12280 194000 +7742 193988 +7617 193977 +10971 193959 +16546 193948 +17628 193922 +22195 193916 +18062 193910 +22516 193894 +34761 193893 +16556 193874 +13212 193838 +13728 193837 +16054 193822 +20494 193814 +8397 193791 +2 193789 +14246 193784 +15872 193776 +11137 193773 +20117 193750 +9096 193748 +12660 193694 +14441 193657 +11607 193643 +26436 193642 +21750 193638 +12547 193620 +22540 193620 +9445 193578 +23941 193545 +30382 193517 +10949 193503 +19665 193474 +12239 193456 +22687 193447 +13975 193440 +22013 193425 +17812 193409 +19639 193409 +10257 193402 +27083 193366 +4378 193331 +25375 193276 +3702 193272 +25014 193255 +1809 193231 +4864 193160 +6561 193114 +15253 193107 +23888 193103 +12564 193103 +12407 193070 +11111 193052 +12847 193023 +97 193021 +8932 193008 +19223 193008 +13324 193005 +9479 192988 +29536 192979 +33888 192911 +11913 192848 +8450 192848 +18006 192801 +4128 192796 +9404 192771 +23502 192733 +9476 192630 +22233 192603 +19984 192576 +4867 192557 +16033 192554 +19579 192541 +22418 192522 +7679 192514 +14161 192475 +12446 192437 +17652 192394 +15039 192387 +13114 192384 +23995 192370 +15283 192312 +16287 192264 +18201 192232 +22099 192198 +22596 192180 +13427 192167 +21299 192163 +5819 192093 +6058 192084 +23445 192073 +23605 192046 +16180 191892 +25715 191891 +19889 191824 +17492 191797 +1458 191777 +12922 191773 +14693 191767 +17375 191734 +13446 191698 +14801 191695 +11202 191687 +16514 191672 +15487 191656 +13791 191645 +15242 191615 +14245 191581 +3801 191536 +12226 191534 +24238 191508 +20103 191476 +2371 191454 +13151 191441 +22578 191429 +23249 191414 +8965 191396 +17578 191380 +12384 191374 +13591 191368 +13395 191318 +5805 191296 +18010 191271 +23078 191243 +7013 191207 +11923 191207 +12934 191173 +11068 191129 +20282 191124 +27290 191101 +20534 191056 +10112 191047 +18024 191030 +6220 191015 +14422 190963 +20154 190925 +24743 190912 +27905 190886 +18153 190854 +12888 190844 +12653 190841 +14765 190815 +13980 190798 +14004 190783 +18652 190783 +8876 190748 +13666 190685 +14052 190683 +16172 190678 +15699 190672 +7536 190620 +7554 190609 +12755 190599 +15426 190597 +4005 190592 +18976 190577 +13454 190558 +20501 190550 +14890 190507 +26355 190499 +14895 190386 +5012 190382 +10143 190362 +23382 190336 +13135 190315 +14143 190311 +8408 190282 +20200 190266 +15010 190236 +18732 190207 +16847 190178 +16109 190116 +24253 190092 +15264 190053 +17392 190030 +30774 190011 +13565 189985 +16499 189968 +20993 189957 +1604 189929 +9779 189922 +10795 189864 +35942 189857 +9386 189853 +25040 189836 +9174 189786 +19690 189778 +12245 189734 +20071 189723 +19574 189707 +18389 189707 +11779 189627 +26691 189621 +18198 189589 +12666 189586 +12509 189521 +10116 189504 +43967 189435 +11795 189420 +13275 189387 +15986 189374 +7057 189357 +11616 189356 +14528 189342 +14852 189333 +7037 189303 +20792 189288 +6660 189274 +13061 189255 +18786 189228 +23344 189217 +21612 189165 +13952 189163 +18394 189160 +14446 189141 +11254 189124 +10733 189118 +20669 189093 +16493 189039 +1408 189035 +17998 188970 +16861 188962 +10688 188950 +9518 188895 +16826 188888 +23040 188881 +17695 188866 +5189 188861 +7707 188860 +19550 188833 +13931 188821 +16929 188812 +11673 188801 +7788 188737 +16431 188706 +17428 188625 +12680 188619 +2964 188531 +8251 188521 +12649 188513 +19126 188486 +13614 188464 +12498 188434 +240 188366 +23960 188355 +16027 188339 +14736 188328 +8557 188257 +14504 188242 +12317 188216 +18928 188187 +13647 188177 +730 188141 +8499 188040 +25752 188019 +25799 188009 +4475 187984 +19705 187920 +242 187919 +9321 187901 +13971 187893 +17949 187866 +26546 187806 +4337 187792 +1574 187732 +16070 187679 +13314 187655 +16290 187605 +6390 187575 +32991 187551 +11080 187546 +6945 187488 +23139 187471 +23788 187464 +9365 187434 +11040 187433 +22381 187427 +18313 187380 +26085 187341 +14982 187323 +8574 187276 +19958 187261 +11414 187206 +1166 187206 +17537 187191 +15381 187178 +13385 187171 +21736 187169 +6530 187142 +7084 187139 +5528 187138 +26856 187128 +10757 187127 +13401 187114 +9991 187065 +12293 187060 +16477 187032 +4484 186968 +8790 186965 +3083 186903 +18033 186884 +17308 186848 +21609 186846 +4527 186814 +17997 186785 +17243 186783 +15114 186781 +15797 186778 +13927 186730 +10373 186727 +10874 186712 +7805 186676 +12698 186634 +14313 186602 +20320 186582 +19271 186577 +7715 186575 +16090 186565 +6236 186562 +13596 186556 +10119 186540 +27792 186538 +14668 186502 +12264 186476 +27837 186457 +32584 186446 +15897 186417 +2814 186411 +1191 186396 +12472 186389 +9173 186320 +20194 186304 +7749 186228 +7239 186223 +12044 186214 +12298 186188 +30851 186186 +10213 186182 +9427 186147 +31547 186096 +26056 186096 +5154 186083 +6548 186073 +1500 186064 +13153 186036 +21740 186013 +12450 186009 +17535 186007 +13187 185997 +15665 185967 +14772 185946 +22445 185931 +39073 185927 +28247 185912 +10671 185884 +13373 185871 +10335 185854 +9969 185840 +14892 185836 +8576 185825 +5614 185778 +5886 185753 +17332 185753 +10566 185745 +20515 185743 +12393 185692 +16300 185686 +26107 185651 +25872 185641 +7582 185618 +11050 185594 +7085 185589 +13266 185586 +10785 185573 +22931 185543 +13052 185522 +16355 185505 +17321 185499 +18563 185409 +6954 185351 +16532 185333 +9034 185322 +8631 185317 +7857 185290 +3642 185273 +13497 185252 +9353 185245 +38926 185244 +21505 185243 +32903 185225 +7785 185218 +12925 185211 +23489 185206 +121 185160 +17914 185159 +20252 185137 +6756 185118 +14333 185097 +15660 185070 +12227 185042 +8210 185040 +14727 185014 +21012 185010 +16968 185009 +30664 184980 +44144 184965 +23088 184951 +7038 184948 +22770 184841 +15980 184824 +18791 184788 +20829 184782 +46011 184765 +13457 184748 +17264 184706 +8363 184673 +5579 184646 +33864 184641 +12134 184598 +28490 184582 +6090 184556 +18088 184536 +30693 184523 +2475 184522 +17901 184511 +12568 184491 +11012 184482 +18530 184461 +21029 184451 +2673 184416 +15453 184413 +23837 184409 +19121 184397 +14995 184396 +14247 184351 +26391 184333 +6648 184215 +17083 184126 +15398 184122 +24154 184099 +17466 184079 +23566 184073 +17057 184041 +1456 184024 +36107 184020 +11441 183972 +12892 183957 +29424 183938 +17728 183935 +17096 183913 +19358 183880 +19592 183868 +12135 183847 +15617 183769 +7947 183698 +22132 183693 +17921 183642 +14930 183631 +16373 183628 +14139 183577 +15339 183563 +20208 183553 +9434 183516 +17948 183511 +15282 183476 +22558 183422 +16245 183386 +20879 183384 +20760 183322 +15112 183317 +19037 183298 +2790 183225 +9334 183222 +12586 183218 +18655 183207 +19823 183187 +21361 183163 +17471 183140 +16633 183140 +35348 183095 +28422 183085 +15329 183035 +21681 183027 +23393 183018 +14365 183016 +26661 182986 +22103 182984 +17188 182968 +6582 182948 +6247 182823 +11128 182782 +14281 182774 +9683 182761 +16821 182757 +18687 182664 +11739 182625 +31996 182584 +11109 182582 +4605 182563 +9033 182516 +9091 182502 +6148 182479 +12365 182357 +16205 182328 +28102 182310 +10703 182278 +2206 182267 +19431 182240 +13020 182239 +19316 182231 +4933 182220 +16828 182198 +3500 182192 +23288 182185 +10491 182150 +15789 182145 +8505 182107 +4886 182055 +11613 181967 +19651 181962 +7266 181950 +12421 181938 +27463 181932 +5092 181911 +26159 181884 +12238 181842 +20754 181817 +13017 181767 +15321 181759 +31415 181722 +17777 181718 +10590 181707 +3557 181705 +22182 181685 +2283 181681 +26182 181679 +15382 181678 +20915 181642 +10281 181615 +11286 181602 +25450 181598 +13081 181592 +24692 181592 +15335 181586 +10245 181585 +35240 181555 +12419 181544 +7379 181476 +12625 181426 +107 181418 +46568 181398 +29911 181382 +11996 181319 +18842 181296 +13197 181295 +26683 181289 +10983 181248 +20143 181240 +9251 181201 +58 181192 +25013 181189 +24269 181184 +8016 181180 +15138 181178 +5246 181147 +10753 181123 +25279 181114 +49188 181107 +22235 181106 +10416 181102 +15962 181083 +858 181077 +10603 181041 +28345 181027 +17517 181012 +13685 181010 +13796 180966 +5962 180927 +10560 180906 +12720 180895 +23443 180844 +14179 180758 +5936 180697 +14774 180686 +13396 180683 +13963 180683 +11806 180666 +21990 180646 +18195 180618 +9111 180605 +3032 180476 +6931 180457 +19029 180423 +26291 180419 +4674 180417 +30096 180414 +12737 180368 +10437 180314 +22937 180290 +21569 180184 +39173 180170 +6477 180162 +8340 180155 +12186 180123 +19784 180123 +12172 180100 +8067 180079 +27686 180044 +22112 180031 +20351 180027 +12386 180017 +24533 180009 +18983 179914 +26013 179907 +2169 179890 +14505 179883 +12057 179881 +19196 179873 +12703 179836 +15692 179684 +10787 179678 +20788 179665 +22382 179642 +14800 179640 +20079 179626 +25496 179602 +23957 179584 +17262 179561 +13076 179553 +7963 179552 +14792 179535 +10431 179516 +19558 179512 +19624 179503 +14444 179480 +1379 179445 +3313 179441 +9385 179437 +9546 179322 +17869 179308 +7308 179274 +21274 179269 +5775 179268 +17675 179252 +7689 179189 +13343 179180 +24797 179178 +29040 179165 +2734 179158 +15638 179153 +13203 179151 +23943 179129 +13718 179096 +24078 179090 +8692 179077 +12051 179067 +42326 179058 +14157 179052 +20884 179044 +16223 179043 +23976 178992 +12200 178959 +16748 178947 +14083 178946 +19055 178945 +24459 178906 +16988 178836 +16219 178833 +48984 178785 +7500 178772 +14297 178751 +9993 178748 +8643 178746 +3010 178732 +22586 178718 +36427 178703 +20158 178700 +18580 178676 +5574 178583 +16110 178569 +14013 178558 +30994 178554 +12157 178553 +28078 178528 +30739 178473 +17349 178470 +16427 178409 +29928 178401 +16522 178396 +16263 178391 +13734 178348 +15914 178347 +12114 178274 +8913 178254 +17774 178239 +17612 178210 +29560 178195 +14283 178152 +20169 178090 +42357 178076 +43461 178071 +22681 178031 +10398 177993 +24004 177926 +7759 177925 +15232 177918 +7440 177896 +18625 177828 +14201 177827 +12714 177772 +13246 177752 +12501 177747 +26809 177746 +1527 177730 +14720 177703 +15271 177600 +15820 177574 +17291 177547 +953 177535 +7980 177516 +16044 177494 +27639 177455 +18012 177379 +7300 177367 +16389 177354 +5783 177341 +15775 177334 +10442 177311 +21248 177251 +15945 177248 +11400 177211 +22490 177209 +16212 177168 +20432 177124 +16625 177111 +12122 177089 +12948 177075 +20312 177066 +26767 177058 +11762 177052 +6679 177034 +36061 177015 +27941 177013 +10388 177008 +8634 177003 +26685 176994 +2259 176811 +21504 176802 +21941 176770 +19051 176713 +15052 176707 +18365 176701 +22311 176694 +23629 176647 +7386 176630 +14645 176620 +19671 176614 +7442 176566 +908 176554 +963 176538 +6708 176535 +13092 176534 +21041 176525 +16584 176498 +2798 176462 +11578 176420 +11303 176408 +7273 176391 +22893 176380 +4614 176339 +6765 176307 +14590 176286 +16176 176282 +12260 176279 +13568 176271 +17986 176270 +13533 176231 +28040 176226 +3978 176223 +9627 176157 +20210 176137 +18996 176125 +21891 176057 +15678 176047 +12532 175994 +15925 175983 +12449 175949 +19925 175941 +16933 175937 +9786 175935 +16699 175919 +9390 175908 +21809 175905 +37108 175883 +12800 175860 +22962 175858 +14841 175811 +13378 175806 +14594 175747 +20353 175712 +11841 175708 +3196 175676 +8260 175670 +9424 175656 +20685 175654 +2473 175652 +12383 175641 +18141 175636 +12070 175606 +17214 175605 +23668 175599 +12878 175578 +6996 175575 +14434 175564 +5117 175538 +19137 175531 +13836 175530 +27748 175492 +24756 175452 +2876 175441 +12006 175423 +18633 175421 +11625 175394 +28111 175300 +17131 175299 +26101 175296 +4757 175293 +16190 175283 +4660 175281 +24499 175281 +13957 175252 +23592 175226 +14532 175208 +6422 175206 +9795 175192 +6320 175173 +21650 175161 +23676 175135 +7764 175042 +9290 174995 +14112 174966 +10904 174950 +10928 174887 +14735 174859 +5728 174841 +14543 174810 +22175 174807 +14530 174738 +1741 174726 +12113 174647 +27616 174644 +13028 174622 +18054 174599 +638 174583 +13182 174582 +15359 174563 +17431 174553 +43850 174526 +16319 174525 +24252 174506 +21198 174471 +20023 174399 +7063 174367 +19562 174366 +22779 174346 +4307 174344 +1769 174327 +14239 174325 +5375 174305 +24454 174256 +8023 174253 +3541 174227 +9088 174178 +12301 174161 +14655 174111 +12462 174104 +25157 174068 +27546 174066 +25995 174064 +19087 174060 +23955 174041 +22102 174021 +13703 174011 +12175 174004 +21204 173982 +17935 173962 +20412 173922 +12083 173901 +14953 173892 +13439 173877 +30175 173873 +11796 173872 +21884 173811 +27911 173805 +29311 173801 +951 173797 +7923 173778 +18526 173761 +12733 173710 +28891 173706 +13121 173684 +1548 173674 +26293 173655 +18632 173633 +29141 173580 +6385 173558 +3694 173557 +15518 173539 +12213 173531 +25225 173478 +10782 173464 +20550 173462 +7227 173435 +817 173425 +8343 173419 +16730 173409 +25147 173394 +33339 173376 +27541 173306 +26203 173301 +31167 173285 +11901 173265 +11623 173194 +14376 173160 +27042 173159 +16079 173133 +7858 173078 +12952 172985 +17110 172967 +9828 172956 +16611 172909 +14788 172908 +21455 172893 +9666 172882 +10725 172849 +14087 172813 +11061 172779 +13139 172764 +12701 172753 +13400 172750 +10645 172749 +26456 172713 +22653 172706 +12824 172703 +7883 172684 +15637 172673 +8508 172668 +3671 172656 +16197 172651 +6359 172639 +25434 172563 +5191 172562 +9915 172552 +1761 172546 +20990 172531 +18520 172530 +7305 172488 +8558 172486 +15345 172477 +19378 172448 +23681 172412 +23936 172403 +14026 172399 +26373 172356 +10194 172322 +11459 172305 +12085 172285 +16336 172271 +13405 172236 +12361 172235 +6061 172209 +3757 172202 +8550 172200 +17222 172176 +6735 172162 +7235 172062 +23975 172027 +16473 172025 +11987 172020 +22098 171992 +17461 171991 +12656 171991 +6763 171989 +46179 171979 +12347 171925 +12470 171923 +8891 171915 +21071 171901 +18870 171890 +1655 171870 +21166 171857 +6444 171853 +1840 171774 +8869 171773 +12784 171753 +28472 171729 +21571 171719 +24763 171628 +12320 171619 +21840 171608 +1927 171529 +18382 171521 +5753 171500 +17290 171498 +44892 171491 +9801 171488 +12584 171458 +101 171438 +7514 171434 +46990 171428 +29913 171428 +20771 171416 +2601 171410 +17460 171395 +21220 171384 +16895 171380 +9127 171376 +15619 171357 +19094 171350 +20455 171331 +33323 171302 +28975 171299 +4774 171292 +20319 171273 +15844 171257 +16686 171115 +27025 171095 +30646 171073 +27607 171054 +9335 171010 +18367 171000 +22569 170994 +33564 170982 +22634 170958 +22300 170944 +18729 170910 +33653 170901 +16657 170899 +7670 170892 +14480 170888 +21862 170874 +17095 170838 +22383 170834 +8991 170821 +22394 170769 +13676 170754 +35659 170660 +38858 170592 +11638 170560 +1240 170543 +26353 170531 +11609 170454 +14690 170433 +12004 170432 +9269 170423 +16146 170371 +27599 170360 +14928 170326 +1930 170295 +7454 170289 +23328 170274 +31546 170245 +5247 170202 +17803 170200 +19258 170198 +5980 170197 +24980 170151 +742 170143 +19057 170127 +4910 170077 +22953 170045 +25585 170029 +21927 170019 +29090 170017 +31159 169975 +7128 169965 +8065 169957 +8833 169947 +27582 169932 +13386 169901 +31346 169899 +11766 169880 +16047 169880 +5978 169862 +16608 169852 +10031 169833 +31078 169816 +32636 169802 +10370 169746 +10675 169728 +47979 169720 +33231 169712 +24684 169670 +16621 169667 +19764 169656 +19988 169648 +29747 169644 +44009 169639 +7074 169638 +9800 169628 +1585 169536 +24073 169523 +21087 169487 +22720 169463 +22434 169431 +25074 169400 +12659 169366 +11733 169362 +35093 169320 +15873 169309 +16602 169292 +14485 169259 +17449 169228 +14234 169204 +30245 169196 +18064 169190 +18735 169178 +12569 169172 +12493 169135 +14648 169118 +25935 169114 +26116 169108 +675 169099 +8306 169097 +2956 169065 +12229 169035 +23076 169019 +11387 168999 +18130 168991 +16930 168979 +12790 168977 +15767 168976 +21110 168952 +31703 168924 +12779 168902 +24485 168902 +29674 168898 +17120 168891 +16359 168887 +19169 168876 +1076 168872 +16894 168838 +10322 168830 +20552 168816 +16324 168804 +26078 168785 +34786 168725 +2006 168691 +11542 168666 +16932 168631 +11968 168561 +18647 168543 +11556 168522 +30384 168493 +899 168471 +13374 168460 +22225 168459 +15881 168449 +11341 168440 +6644 168425 +10712 168414 +21266 168360 +17876 168314 +8610 168313 +22541 168302 +12121 168276 +105 168274 +18053 168229 +11031 168215 +17441 168157 +11640 168079 +1788 168065 +12697 168063 +18079 168041 +14789 168034 +23577 168015 +25686 168011 +14325 168010 +14826 167973 +8808 167968 +7385 167959 +15656 167943 +26406 167933 +3477 167926 +25167 167922 +20441 167896 +9254 167895 +14102 167884 +13580 167830 +22041 167798 +27611 167791 +19711 167781 +29890 167771 +34943 167757 +32149 167722 +24207 167666 +14551 167664 +1929 167661 +5851 167643 +9792 167642 +13207 167637 +17711 167633 +23438 167558 +4095 167545 +18656 167543 +10761 167496 +9310 167481 +31509 167455 +13084 167453 +12823 167449 +12484 167418 +29272 167411 +23780 167399 +19725 167368 +20271 167359 +20386 167350 +8071 167327 +23982 167266 +26451 167221 +16675 167217 +23415 167158 +2508 167108 +17938 167087 +18519 167077 +13717 167065 +9053 167045 +11575 167045 +6723 167044 +5830 167038 +11451 167009 +20237 166982 +13656 166930 +33118 166913 +2929 166913 +34589 166887 +12886 166877 +21011 166858 +20886 166856 +11053 166854 +5225 166852 +13747 166832 +9351 166806 +14676 166779 +16171 166777 +31526 166766 +24031 166749 +26606 166743 +13889 166741 +18679 166738 +11757 166711 +30035 166709 +2114 166669 +22695 166667 +11054 166649 +11442 166649 +15413 166635 +9579 166605 +13239 166595 +13752 166594 +1567 166549 +13699 166525 +17962 166524 +13510 166490 +18387 166475 +1934 166420 +26400 166403 +36759 166372 +15172 166364 +21666 166333 +25733 166308 +24799 166303 +14386 166271 +11463 166237 +8290 166233 +25914 166221 +4207 166202 +11562 166199 +7310 166186 +12576 166158 +12236 166143 +17372 166140 +23270 166122 +10605 166100 +11349 166100 +9726 166095 +24164 166090 +6950 166083 +13267 166071 +19636 166055 +12422 166053 +10217 166036 +14340 166030 +15163 166028 +14048 166027 +14154 165992 +22309 165928 +14266 165928 +34217 165921 +11052 165919 +33399 165910 +3832 165889 +16237 165889 +7287 165873 +22351 165865 +15291 165860 +1928 165844 +17673 165838 +6615 165779 +12844 165748 +47875 165744 +713 165695 +28392 165691 +14678 165625 +16545 165608 +14492 165582 +21402 165530 +22361 165529 +19219 165467 +4596 165457 +12923 165451 +5702 165438 +11820 165426 +1089 165423 +13516 165419 +26190 165371 +25701 165371 +13827 165370 +4328 165308 +34366 165287 +19140 165262 +10320 165222 +11863 165214 +12033 165196 +28523 165172 +31791 165153 +15489 165126 +17274 165125 +15477 165115 +23829 165086 +19290 165064 +21531 165051 +13070 165041 +7710 165021 +11516 165009 +21006 165000 +23832 164975 +9948 164892 +24850 164885 +11101 164882 +27117 164844 +32564 164833 +22771 164818 +8142 164818 +34506 164763 +16192 164663 +13452 164658 +10368 164642 +4342 164624 +23325 164571 +14153 164564 +32136 164562 +19500 164555 +1777 164538 +26216 164529 +21518 164502 +17863 164502 +11662 164492 +14851 164477 +28059 164405 +27035 164382 +12144 164302 +12903 164283 +17564 164257 +13006 164252 +13753 164245 +1768 164242 +9848 164233 +23247 164218 +16788 164197 +12979 164190 +41179 164177 +2217 164136 +9255 164136 +41588 164100 +23413 164093 +14955 164090 +11664 164075 +23429 164074 +2889 164070 +20002 164057 +4630 164034 +13318 164034 +9058 164026 +11543 163998 +13608 163983 +23643 163952 +18067 163942 +4501 163926 +22158 163921 +20404 163910 +21418 163874 +17344 163864 +12444 163801 +901 163789 +29037 163767 +16500 163753 +14093 163735 +29306 163647 +7837 163646 +22223 163631 +13122 163620 +14776 163601 +5589 163591 +9989 163571 +23624 163502 +8274 163471 +16325 163463 +30031 163460 +9330 163450 +839 163430 +24397 163382 +8605 163360 +5988 163329 +11860 163296 +16765 163287 +20527 163284 +3316 163277 +915 163267 +18434 163258 +10165 163223 +14185 163180 +15464 163159 +27274 163156 +20165 163120 +11011 163101 +20390 163090 +15276 163078 +21133 163077 +32694 163019 +19745 163009 +18246 163004 +2181 162993 +8074 162946 +20304 162946 +42057 162941 +11089 162921 +17109 162920 +13799 162841 +18021 162828 +21817 162821 +21270 162821 +11870 162809 +7056 162800 +21167 162709 +19657 162699 +17887 162692 +21023 162683 +12793 162679 +22958 162650 +18862 162610 +18753 162565 +16585 162550 +30843 162549 +19432 162535 +22680 162525 +6895 162511 +18488 162509 +8435 162506 +26301 162478 +46129 162457 +17346 162449 +11094 162410 +23068 162393 +23617 162378 +24232 162378 +17742 162375 +20291 162364 +22260 162360 +22639 162344 +30872 162339 +8431 162339 +15371 162317 +15305 162307 +21896 162293 +26615 162268 +665 162268 +20714 162265 +17368 162256 +20093 162231 +21183 162191 +23200 162167 +19855 162160 +33922 162151 +1615 162141 +33724 162135 +4062 162117 +18570 162085 +7149 162079 +16853 162064 +20742 162037 +25050 162013 +7591 161991 +8369 161974 +28643 161972 +17454 161968 +15472 161941 +31005 161940 +18416 161919 +33911 161884 +10220 161861 +9942 161846 +14089 161843 +12524 161833 +18852 161808 +2218 161795 +21119 161783 +10351 161736 +27847 161736 +11624 161735 +14639 161728 +226 161620 +11736 161616 +20739 161604 +11329 161601 +20352 161563 +17054 161549 +4180 161537 +33385 161528 +25889 161523 +16320 161497 +33193 161491 +31767 161467 +11247 161429 +28759 161424 +14378 161422 +23590 161420 +20393 161410 +15654 161390 +12098 161372 +27986 161357 +18397 161348 +11649 161326 +23070 161293 +25634 161289 +19475 161286 +15916 161274 +13779 161164 +16299 161163 +3984 161154 +19517 161142 +16860 161140 +12546 161125 +8229 161124 +25793 161099 +15332 161092 +14104 161088 +27357 161081 +15099 161076 +16034 161064 +15722 161054 +18618 161004 +21158 160987 +9491 160981 +12096 160973 +18362 160959 +31230 160951 +22171 160939 +15749 160938 +23280 160928 +27180 160917 +19350 160903 +13917 160863 +28686 160840 +22387 160829 +14150 160787 +8950 160765 +7711 160757 +11433 160753 +20447 160753 +21743 160744 +17589 160726 +22830 160718 +15564 160701 +15935 160665 +17086 160655 +11025 160649 +1020 160616 +3915 160590 +21445 160576 +12860 160543 +20653 160539 +22627 160534 +28355 160530 +13727 160517 +13331 160513 +14657 160501 +15293 160493 +12345 160491 +25469 160481 +8859 160468 +21249 160462 +26538 160449 +25684 160447 +5691 160438 +14846 160434 +30427 160423 +5844 160391 +18323 160386 +14318 160373 +25535 160370 +20840 160352 +10526 160335 +16247 160329 +18666 160320 +15850 160286 +15326 160278 +23259 160245 +17260 160245 +24091 160196 +13769 160191 +27540 160149 +12898 160107 +12661 160094 +11657 160079 +5912 160074 +11738 160067 +2913 159992 +8204 159989 +26804 159960 +14595 159957 +14730 159947 +32760 159941 +32078 159907 +13460 159893 +21425 159882 +26618 159858 +32879 159838 +12592 159836 +24832 159811 +15536 159796 +16537 159787 +27828 159774 +18857 159772 +14483 159740 +25054 159712 +9586 159707 +20096 159707 +17079 159702 +14370 159698 +19207 159671 +26824 159630 +33139 159614 +25172 159602 +13686 159592 +40289 159583 +21838 159580 +18128 159571 +14733 159563 +31292 159553 +18139 159513 +44066 159510 +25165 159492 +14371 159474 +17255 159432 +5379 159426 +4119 159418 +15250 159397 +12041 159368 +39463 159338 +14862 159315 +22140 159290 +7769 159278 +8629 159228 +29714 159198 +28855 159198 +14484 159181 +16255 159158 +22945 159156 +9875 159043 +12188 159039 +12877 158992 +33605 158976 +41449 158974 +11212 158974 +32688 158957 +13455 158950 +17638 158947 +8531 158908 +21193 158855 +7220 158842 +3875 158831 +6017 158800 +9724 158796 +13808 158790 +21798 158768 +16569 158740 +8487 158725 +12891 158721 +16169 158668 +50079 158664 +14662 158663 +9565 158660 +26070 158632 +16715 158620 +25982 158612 +14921 158609 +24190 158591 +16304 158587 +16561 158553 +17052 158522 +17590 158510 +2012 158490 +40635 158487 +14193 158454 +16597 158446 +29200 158411 +25768 158388 +16599 158346 +22283 158342 +14190 158305 +17984 158291 +11368 158289 +894 158285 +8726 158253 +13271 158252 +38818 158242 +15909 158213 +15279 158211 +19987 158186 +14029 158156 +2967 158148 +7597 158145 +11282 158119 +30334 158112 +1819 158040 +7211 158026 +8804 158002 +24152 157998 +9863 157974 +15124 157954 +12189 157895 +31507 157885 +10381 157862 +20551 157853 +35293 157847 +8664 157839 +15828 157836 +17114 157813 +15585 157797 +32317 157785 +21141 157733 +29444 157718 +13570 157718 +11352 157674 +933 157613 +13222 157602 +14310 157588 +12929 157586 +18017 157577 +15647 157572 +28278 157566 +14540 157562 +9576 157531 +10599 157529 +11140 157502 +25936 157484 +39637 157468 +5684 157467 +20997 157452 +23115 157437 +18108 157436 +20705 157426 +21457 157387 +16511 157373 +28564 157373 +23420 157353 +13786 157351 +10284 157333 +11723 157333 +24005 157315 +10919 157293 +27874 157280 +16548 157274 +9995 157264 +13141 157253 +15907 157235 +12571 157218 +2247 157218 +28182 157209 +14121 157200 +1552 157195 +7400 157179 +15747 157150 +10188 157144 +13079 157126 +29443 157105 +22605 157085 +14638 157043 +22722 157041 +38061 157031 +19702 156983 +24713 156960 +29600 156910 +27622 156908 +23811 156882 +18612 156867 +29330 156804 +31071 156786 +18340 156752 +26962 156752 +16460 156724 +20126 156706 +5275 156655 +20342 156637 +18259 156614 +888 156611 +15816 156610 +30405 156596 +10742 156594 +26068 156592 +12572 156545 +23980 156530 +18468 156522 +6256 156514 +18504 156499 +4020 156492 +22323 156483 +10685 156482 +18752 156458 +17268 156414 +13788 156414 +5083 156407 +31472 156400 +2908 156375 +26807 156369 +24142 156367 +22571 156353 +11060 156348 +17093 156298 +20642 156289 +19551 156285 +3780 156274 +19495 156268 +800 156267 +20603 156263 +18147 156244 +35151 156227 +18385 156178 +18684 156168 +20601 156162 +8553 156147 +14028 156145 +46279 156133 +16456 156127 +7913 156073 +17066 156071 +12692 156046 +25978 156013 +14173 156010 +25299 156002 +23519 155994 +28335 155959 +20157 155953 +5677 155929 +3971 155902 +12267 155878 +3309 155863 +20933 155816 +24296 155768 +5821 155741 +18236 155729 +17893 155698 +17012 155685 +15902 155658 +20051 155639 +16395 155631 +25688 155605 +11711 155597 +22455 155571 +22095 155561 +18590 155536 +28052 155527 +43856 155456 +25109 155429 +19414 155419 +23546 155417 +25296 155396 +15021 155380 +8624 155360 +34338 155326 +48543 155324 +18264 155290 +2285 155264 +34139 155261 +17920 155238 +25201 155154 +12279 155145 +16075 155111 +14818 155107 +16318 155106 +16397 155078 +37244 155044 +23472 155043 +29220 155029 +11501 155027 +18446 154973 +3319 154963 +18180 154948 +15101 154935 +18105 154933 +16740 154932 +8960 154919 +17616 154899 +28280 154889 +13521 154875 +10583 154855 +7071 154845 +12326 154824 +16024 154804 +21292 154782 +1047 154750 +11188 154727 +18223 154723 +12768 154698 +13391 154683 +11948 154679 +28354 154643 +12105 154624 +24833 154599 +12179 154573 +15399 154535 +17089 154509 +14687 154465 +2374 154450 +10248 154438 +15723 154435 +15621 154410 +630 154398 +14809 154370 +17722 154361 +23424 154352 +14088 154336 +2429 154321 +14275 154316 +19026 154282 +7493 154278 +32948 154265 +3733 154263 +20270 154229 +15830 154223 +19602 154195 +6517 154179 +17989 154171 +46668 154162 +19068 154157 +10285 154148 +30223 154138 +17981 154123 +24545 154116 +8241 154084 +6404 154027 +1185 154019 +4227 154018 +14208 153999 +16811 153998 +18867 153997 +16755 153996 +36431 153984 +25613 153954 +19481 153934 +13435 153913 +34112 153902 +22676 153889 +11096 153830 +18920 153800 +40113 153775 +19447 153772 +32440 153762 +23632 153760 +27052 153749 +11945 153742 +26091 153725 +15718 153715 +31736 153713 +21821 153700 +20153 153693 +1553 153661 +24300 153645 +12395 153620 +11800 153610 +24859 153584 +31318 153521 +17254 153482 +7573 153476 +255 153473 +25230 153472 +24625 153458 +9878 153450 +10114 153435 +21400 153433 +14884 153380 +26918 153347 +12370 153341 +18432 153335 +16459 153330 +26023 153308 +8118 153298 +49355 153294 +25846 153268 +6005 153259 +34910 153259 +6392 153251 +44828 153232 +17530 153226 +20462 153208 +15867 153204 +10548 153174 +18342 153154 +24135 153137 +11335 153129 +15571 153117 +22970 153096 +16507 153049 +14440 153036 +2764 153035 +23533 153022 +8681 153019 +16195 152986 +4507 152962 +8613 152961 +14045 152955 +26326 152952 +4250 152929 +12958 152900 +29825 152864 +19830 152848 +23265 152843 +36863 152777 +31110 152776 +20670 152773 +14580 152733 +13707 152713 +28397 152701 +21820 152700 +14640 152687 +9380 152661 +10635 152624 +14814 152596 +16356 152522 +11246 152502 +40001 152483 +23013 152432 +25316 152418 +27724 152407 +25018 152406 +15628 152383 +35637 152371 +20424 152336 +18269 152305 +13172 152300 +2143 152274 +47633 152263 +3411 152256 +1190 152228 +21827 152218 +16642 152203 +22205 152196 +13148 152180 +4230 152159 +15551 152108 +8002 152108 +15226 152070 +11261 152055 +11705 152032 +20240 152015 +23918 151954 +31625 151951 +21028 151947 +43566 151927 +2341 151908 +19935 151900 +12863 151899 +32958 151881 +15691 151875 +16887 151864 +16963 151863 +14338 151859 +27194 151857 +26909 151855 +19999 151840 +6871 151824 +14593 151815 +26716 151771 +13899 151760 +20753 151700 +36095 151697 +15298 151683 +32496 151606 +2865 151590 +17809 151567 +29797 151566 +36744 151544 +22368 151535 +12271 151498 +19632 151465 +9356 151455 +20583 151415 +17061 151403 +17781 151390 +24968 151389 +41461 151377 +22877 151362 +4906 151313 +13667 151309 +27283 151288 +31764 151280 +18648 151258 +47286 151250 +31918 151179 +16277 151130 +19519 151110 +19931 151099 +21434 151094 +35385 151073 +21808 151068 +4127 151053 +30112 151050 +29402 151046 +17383 151039 +3279 151028 +41727 151001 +34549 150992 +7141 150988 +16001 150978 +12740 150977 +19013 150919 +2317 150903 +13616 150870 +19829 150866 +26544 150859 +23494 150829 +11793 150822 +5678 150789 +21346 150787 +6839 150781 +16612 150779 +2859 150761 +16133 150748 +25462 150743 +25175 150735 +29222 150706 +18266 150702 +15557 150701 +24413 150649 +17378 150591 +14714 150581 +1868 150571 +4189 150541 +2747 150526 +14470 150516 +26960 150510 +12209 150502 +1685 150501 +6880 150485 +18165 150479 +14383 150433 +4561 150430 +12804 150411 +48298 150408 +24766 150396 +22964 150364 +17837 150349 +28792 150347 +4160 150339 +3874 150327 +13113 150326 +9654 150323 +13858 150312 +13476 150291 +13000 150289 +19443 150285 +7856 150248 +20631 150223 +23663 150219 +36878 150211 +4356 150206 +12005 150181 +5061 150174 +17292 150167 +37929 150165 +1174 150149 +7100 150145 +12119 150121 +19934 150114 +25911 150114 +26985 150114 +18551 150112 +10979 150111 +6475 150106 +31063 150073 +23008 150064 +11198 150059 +19131 150055 +20156 150033 +14073 150025 +18140 150022 +14394 150016 +3438 150003 +12027 149972 +20774 149888 +21126 149879 +19097 149868 +10345 149816 +41012 149812 +14438 149801 +18553 149773 +16954 149767 +21423 149719 +32519 149709 +29074 149707 +8784 149698 +2963 149683 +13026 149678 +23052 149660 +28242 149649 +16677 149632 +13599 149629 +36692 149596 +18550 149593 +3351 149580 +3711 149539 +26454 149533 +18916 149510 +23531 149481 +17467 149475 +11207 149458 +11710 149431 +10720 149413 +3629 149411 +18315 149407 +28649 149298 +7490 149297 +43484 149267 +19315 149251 +20561 149234 +12681 149204 +31460 149200 +11707 149196 +19278 149166 +13951 149157 +25452 149155 +2898 149145 +16472 149134 +20276 149129 +16889 149126 +23786 149104 +14799 149093 +13326 149084 +37361 149083 +18499 149066 +29418 149057 +2668 149055 +23902 149051 +12839 149015 +29806 148976 +24380 148923 +28108 148871 +32939 148870 +14497 148862 +5623 148850 +17730 148845 +15635 148837 +44508 148835 +20077 148829 +11499 148813 +14271 148813 +22191 148798 +9737 148798 +16960 148777 +32682 148773 +31630 148764 +35231 148749 +21039 148721 +43841 148710 +31248 148693 +25313 148685 +25043 148683 +21112 148627 +20289 148622 +18811 148620 +16265 148608 +7655 148578 +9045 148574 +15712 148554 +26039 148540 +22264 148525 +13869 148513 +14031 148505 +8392 148502 +34783 148499 +24536 148490 +33110 148480 +21380 148469 +26686 148438 +9695 148399 +15765 148398 +10586 148396 +9834 148374 +14363 148368 +42189 148367 +8297 148330 +42235 148326 +24163 148323 +21511 148301 +13539 148287 +16259 148284 +22841 148280 +34655 148279 +13639 148270 +1873 148220 +236 148220 +28791 148173 +16981 148158 +31002 148157 +19666 148135 +17609 148080 +11527 148078 +16938 148071 +19649 148013 +961 147986 +7673 147977 +15143 147964 +14583 147917 +13645 147910 +12590 147909 +18724 147905 +27502 147901 +23942 147874 +11428 147867 +4740 147865 +27609 147860 +16425 147859 +20731 147848 +29640 147844 +3143 147820 +23852 147767 +10348 147753 +4777 147752 +11930 147739 +16904 147704 +2307 147703 +17498 147652 +12791 147635 +10107 147624 +29751 147606 +16406 147605 +12017 147592 +17625 147562 +9382 147562 +14351 147554 +22244 147533 +5725 147520 +2655 147490 +23655 147473 +21530 147408 +12657 147405 +4879 147395 +22075 147383 +21685 147355 +22786 147242 +21420 147225 +15794 147218 +3577 147175 +9536 147160 +35193 147093 +27348 147076 +17198 147049 +8615 147031 +24037 147017 +6532 147016 +25289 146998 +10897 146965 +156 146955 +39920 146925 +22647 146921 +10148 146909 +10891 146887 +14041 146872 +18143 146867 +15460 146865 +5518 146864 +2917 146864 +17123 146801 +23600 146765 +10582 146703 +23240 146699 +17502 146680 +26943 146669 +7488 146654 +14282 146636 +21161 146625 +22879 146622 +14176 146611 +28250 146596 +18654 146583 +20715 146561 +11056 146533 +16645 146525 +40160 146513 +608 146508 +13770 146488 +16830 146483 +21987 146426 +34162 146377 +14136 146323 +20505 146305 +12741 146284 +13530 146275 +27250 146260 +32489 146242 +9929 146232 +34183 146216 +27775 146212 +21644 146198 +11530 146177 +6309 146169 +19496 146142 +20047 146103 +16521 146087 +22926 146036 +3228 146019 +15108 145976 +27879 145951 +15921 145950 +18818 145948 +11379 145936 +28259 145928 +6051 145927 +27886 145925 +21919 145900 +27771 145884 +19002 145869 +28565 145863 +10229 145861 +19480 145857 +7120 145846 +1901 145839 +16470 145810 +10456 145793 +25464 145789 +11895 145789 +19597 145785 +8769 145767 +24787 145747 +35764 145738 +34116 145734 +36040 145708 +13884 145698 +29285 145693 +29484 145690 +11916 145681 +20244 145661 +26899 145652 +8739 145638 +16231 145626 +11767 145621 +27334 145619 +39823 145614 +24193 145602 +26249 145596 +31774 145592 +12889 145583 +15933 145566 +26739 145565 +48974 145558 +5146 145504 +19383 145482 +22772 145462 +18379 145458 +18695 145447 +20874 145411 +10593 145401 +37720 145373 +19783 145319 +15085 145314 +9297 145310 +17316 145293 +18522 145290 +18785 145276 +63 145276 +6229 145255 +21733 145255 +12479 145254 +23186 145227 +14489 145197 +10752 145179 +39375 145173 +31636 145170 +35597 145170 +39632 145167 +18295 145138 +41924 145119 +14448 145118 +28458 145088 +20671 145086 +10602 145079 +18595 145063 +15190 145062 +19346 145051 +11179 145035 +16216 145026 +15941 144995 +11741 144989 +9261 144984 +18094 144969 +25479 144862 +26136 144855 +27229 144848 +7761 144848 +2973 144807 +17160 144798 +24248 144764 +7200 144739 +22375 144732 +23356 144732 +14361 144729 +21057 144721 +18508 144691 +4817 144670 +9598 144624 +12709 144620 +11108 144598 +6423 144592 +14097 144587 +15822 144585 +14653 144550 +20813 144539 +21541 144521 +26242 144514 +37440 144509 +4114 144509 +13375 144474 +18575 144446 +3222 144446 +10783 144443 +24105 144434 +18283 144432 +10197 144427 +14349 144424 +38813 144413 +39249 144396 +6724 144389 +490 144388 +32452 144361 +7068 144353 +19171 144331 +26154 144327 +22336 144323 +9866 144305 +22108 144292 +6468 144287 +15825 144282 +23702 144255 +6988 144243 +10730 144241 +28414 144241 +17276 144230 +14983 144229 +14864 144214 +26348 144200 +1843 144196 +25357 144180 +14180 144170 +18662 144158 +24067 144156 +14699 144154 +10924 144126 +20162 144107 +22038 144094 +14724 144049 +27633 144028 +8310 143966 +19050 143962 +17411 143945 +2299 143915 +1617 143906 +26372 143898 +17416 143870 +37072 143867 +879 143850 +21624 143840 +6790 143798 +18750 143787 +20672 143775 +3157 143711 +2386 143672 +13143 143671 +21641 143653 +4559 143641 +26134 143618 +15807 143611 +40990 143519 +17206 143512 +12481 143506 +8510 143503 +12495 143490 +10227 143482 +20576 143478 +28379 143414 +15904 143411 +14871 143409 +12153 143373 +24194 143336 +21272 143326 +11700 143323 +19000 143288 +17004 143282 +12683 143277 +6499 143264 +20250 143258 +22543 143237 +17835 143236 +21337 143227 +36888 143176 +8524 143165 +20600 143162 +13186 143159 +5420 143155 +38488 143155 +35295 143153 +26935 143119 +29737 143113 +12290 143106 +6072 143102 +35399 143098 +15050 143097 +19544 143080 +21813 143026 +22371 143025 +13024 143020 +13529 143006 +12719 143001 +8756 142996 +26390 142984 +39099 142967 +13063 142945 +21024 142943 +15455 142914 +6574 142910 +8299 142910 +35136 142909 +22736 142908 +25647 142902 +16352 142896 +18573 142873 +2593 142862 +23312 142838 +36861 142830 +14169 142814 +7409 142806 +9756 142803 +28238 142793 +15949 142780 +24779 142717 +11894 142698 +37911 142687 +5450 142670 +8322 142664 +15133 142663 +22004 142624 +14252 142623 +16291 142622 +19996 142485 +21542 142483 +12237 142454 +22814 142400 +14323 142388 +6048 142372 +24946 142362 +16567 142345 +26046 142335 +12817 142314 +20805 142310 +7251 142296 +33338 142294 +24086 142293 +20461 142280 +2322 142269 +43812 142263 +12312 142254 +9582 142243 +38134 142234 +26907 142226 +16218 142210 +38671 142196 +13002 142196 +4826 142194 +14947 142188 +30836 142187 +10288 142181 +15175 142177 +15743 142174 +8228 142163 +17162 142134 +13005 142118 +31721 142116 +36139 142113 +10128 142107 +9688 142074 +43941 142063 +23773 142057 +14498 142033 +24740 141961 +15644 141960 +30633 141944 +15875 141934 +21114 141929 +13127 141927 +15504 141914 +8373 141897 +18969 141895 +20345 141876 +15234 141835 +8344 141831 +15043 141803 +19877 141769 +13690 141755 +17648 141754 +9285 141750 +12777 141739 +20493 141725 +33876 141723 +20175 141717 +22151 141698 +48828 141689 +25665 141686 +1259 141670 +20698 141670 +14010 141664 +28330 141659 +15349 141650 +5945 141623 +30801 141606 +26414 141595 +17800 141591 +998 141574 +16832 141552 +16492 141540 +27153 141534 +16399 141504 +13444 141490 +19848 141477 +28291 141476 +40253 141467 +21735 141446 +11685 141439 +39304 141433 +17687 141365 +11503 141351 +19534 141326 +18244 141322 +19487 141311 +15985 141281 +31612 141266 +13368 141262 +11290 141261 +10230 141260 +7657 141247 +18213 141238 +14996 141232 +23627 141202 +20075 141173 +5843 141143 +25333 141137 +22862 141121 +10477 141085 +22432 141070 +19425 141064 +20392 141053 +16361 141043 +23407 141014 +40624 141014 +27267 140988 +12258 140965 +18605 140949 +33020 140940 +28553 140933 +20974 140924 +14296 140899 +46935 140878 +2511 140811 +19437 140786 +21107 140783 +18591 140782 +6811 140766 +12243 140763 +1349 140737 +10974 140709 +5151 140698 +12748 140677 +25621 140661 +19263 140656 +16061 140651 +4432 140640 +31658 140637 +40060 140636 +19384 140632 +20814 140631 +25142 140619 +19301 140587 +23198 140585 +14131 140572 +7435 140568 +27515 140552 +15248 140540 +24581 140504 +25657 140498 +8402 140492 +15421 140465 +5720 140454 +17977 140454 +11471 140450 +24851 140420 +25308 140397 +13370 140392 +19479 140354 +22462 140350 +46000 140325 +29759 140315 +12964 140307 +11211 140304 +1197 140274 +20172 140272 +11510 140237 +17087 140207 +17897 140176 +17315 140174 +22064 140170 +37758 140169 +8608 140168 +8105 140165 +27247 140162 +12899 140156 +14436 140154 +20013 140149 +32134 140148 +10998 140138 +23354 140134 +26971 140127 +20327 140124 +26773 140115 +34982 140110 +20286 140083 +19313 140048 +23608 140032 +12505 140012 +27593 139969 +32025 139966 +19347 139957 +13365 139945 +13970 139935 +22452 139930 +8133 139915 +26445 139911 +12967 139876 +15134 139872 +9597 139860 +17107 139855 +19253 139841 +36895 139840 +2703 139835 +12029 139834 +40713 139815 +29269 139809 +17810 139778 +13517 139757 +16543 139737 +16502 139714 +14773 139695 +5351 139685 +12623 139663 +35363 139642 +27501 139623 +4715 139600 +3129 139597 +9245 139595 +9463 139588 +27885 139587 +17965 139583 +19132 139552 +13996 139549 +17282 139532 +15658 139528 +13319 139474 +5958 139469 +22218 139457 +25332 139452 +36779 139435 +22211 139423 +3379 139419 +6921 139416 +9234 139404 +17902 139396 +13288 139395 +23486 139371 +26479 139365 +37135 139360 +18371 139338 +7870 139292 +22597 139285 +26812 139273 +38704 139262 +14170 139260 +41708 139256 +19192 139241 +25003 139237 +2082 139236 +33330 139203 +39818 139192 +34105 139171 +25951 139164 +40020 139161 +21493 139131 +14128 139128 +9303 139119 +8103 139094 +14555 139070 +14156 139032 +22078 139012 +3266 138995 +14680 138963 +41941 138960 +18929 138948 +7938 138938 +17144 138922 +5724 138921 +18764 138920 +18915 138877 +10970 138844 +6255 138824 +19092 138812 +23233 138772 +16526 138749 +18657 138723 +9012 138692 +11580 138689 +16723 138684 +3144 138649 +754 138649 +5005 138632 +13012 138619 +944 138584 +10814 138583 +18560 138535 +17858 138511 +5751 138507 +29467 138495 +10354 138474 +10735 138452 +23019 138452 +29374 138452 +39946 138446 +22954 138429 +20127 138406 +15068 138388 +32644 138345 +31518 138313 +25912 138299 +24349 138293 +19989 138283 +12261 138276 +19494 138260 +28220 138234 +14546 138229 +26508 138228 +13706 138227 +21432 138224 +30093 138195 +18997 138186 +18935 138185 +19009 138150 +9596 138085 +21980 138078 +22301 138067 +21150 138016 +30311 138013 +28395 138002 +1145 137982 +17415 137982 +11892 137980 +48216 137923 +25448 137913 +14482 137889 +18965 137887 +17825 137879 +18523 137867 +11196 137844 +6850 137838 +19036 137832 +8516 137831 +10736 137823 +15686 137814 +8352 137792 +17324 137789 +25204 137788 +30315 137776 +25320 137772 +26874 137734 +13159 137723 +32369 137717 +13817 137699 +34673 137683 +9478 137680 +32646 137661 +21904 137649 +19789 137636 +25091 137583 +16700 137566 +21768 137552 +13066 137528 +23266 137523 +13893 137487 +12016 137481 +12323 137456 +25583 137455 +23300 137453 +15696 137327 +12855 137310 +49219 137299 +8151 137294 +16908 137290 +8439 137277 +6037 137276 +15285 137271 +27265 137223 +14769 137218 +15532 137198 +13763 137185 +30479 137177 +20524 137161 +28356 137159 +8575 137140 +12850 137138 +16045 137125 +27678 137117 +23226 137112 +10696 137107 +16391 137106 +20463 137105 +14743 137089 +15963 137075 +18138 137041 +31335 137033 +33709 137028 +8753 137024 +18310 136991 +8249 136987 +18116 136975 +19228 136973 +24009 136969 +21348 136945 +9997 136892 +35521 136858 +30260 136849 +20902 136836 +22641 136817 +5327 136805 +17073 136787 +13390 136757 +15934 136751 +35109 136719 +25974 136715 +24050 136706 +18903 136670 +37173 136634 +1652 136609 +23940 136579 +4223 136573 +26347 136572 +16162 136554 +16380 136548 +11851 136525 +14937 136515 +19161 136465 +22043 136462 +20849 136448 +31745 136448 +13818 136435 +23956 136431 +47144 136428 +34974 136423 +13801 136409 +22053 136378 +2525 136377 +6210 136367 +31540 136361 +1293 136354 +13993 136347 +14494 136319 +5259 136294 +4818 136274 +17864 136261 +24828 136253 +19674 136251 +25143 136242 +26913 136241 +11412 136220 +3810 136187 +24463 136173 +47962 136161 +18838 136132 +15657 136132 +34891 136078 +18302 136078 +29377 136051 +21349 136043 +28650 136013 +5088 136008 +18250 135991 +21691 135968 +15430 135949 +2654 135947 +44830 135945 +8520 135934 +12429 135919 +19888 135915 +17813 135910 +15827 135906 +22844 135900 +20434 135895 +20201 135887 +15554 135886 +12884 135878 +13859 135821 +827 135794 +27022 135785 +5973 135784 +26721 135779 +20170 135770 +19670 135770 +10892 135733 +15028 135730 +30928 135729 +9537 135713 +16771 135662 +4686 135657 +17899 135653 +7338 135653 +9742 135638 +8874 135624 +25067 135612 +2401 135602 +18644 135580 +4915 135574 +23727 135562 +15201 135534 +5746 135506 +21829 135459 +21040 135442 +17173 135442 +15768 135440 +27139 135425 +23790 135421 +16808 135408 +32722 135364 +31941 135358 +17991 135358 +9996 135356 +9360 135346 +14754 135332 +23049 135312 +18449 135257 +17153 135236 +2470 135234 +12956 135230 +1725 135221 +41107 135218 +16461 135211 +18860 135206 +15651 135184 +19110 135179 +15643 135177 +14149 135109 +16337 135106 +39897 135092 +12693 135089 +26649 135084 +11389 135075 +9145 135074 +26346 135068 +27443 135067 +22798 135063 +8377 135055 +34698 135017 +32250 135009 +24002 135005 +22663 135003 +19696 135001 +27698 134997 +21803 134967 +32108 134952 +18582 134939 +17101 134938 +32641 134906 +16038 134906 +9712 134898 +32462 134885 +15899 134884 +15468 134883 +15374 134876 +12642 134866 +22304 134858 +44133 134834 +15222 134777 +22001 134772 +29760 134753 +24553 134748 +35706 134738 +18715 134725 +9525 134724 +14716 134703 +22089 134687 +46754 134683 +9423 134677 +37118 134677 +25041 134658 +29995 134646 +24585 134646 +7340 134641 +10984 134634 +17387 134623 +32076 134607 +31178 134594 +26542 134575 +3672 134564 +5773 134545 +23006 134542 +24959 134532 +10154 134529 +22534 134525 +14979 134521 +21246 134516 +26376 134513 +12364 134511 +20725 134496 +18412 134495 +22080 134493 +7066 134484 +19412 134469 +7821 134443 +25518 134438 +24023 134427 +13540 134402 +45826 134397 +13843 134350 +17849 134341 +41992 134319 +5434 134314 +16226 134302 +24301 134299 +13742 134277 +17843 134272 +15915 134271 +33693 134260 +31958 134254 +26601 134245 +21500 134191 +33545 134161 +13213 134121 +48922 134117 +17979 134103 +11346 134093 +14723 134054 +18705 134045 +18008 134043 +19416 134036 +33167 134027 +33666 134023 +23043 133985 +8772 133973 +12440 133968 +39419 133931 +19403 133911 +25426 133910 +4454 133866 +22707 133862 +20865 133845 +26778 133839 +36538 133814 +19716 133802 +6362 133794 +32944 133782 +24017 133778 +10659 133777 +20824 133736 +37539 133714 +29771 133710 +6449 133687 +3044 133682 +19497 133674 +18081 133662 +16660 133646 +3448 133633 +18700 133633 +38735 133626 +7594 133617 +14335 133600 +12015 133581 +5460 133580 +20818 133557 +14198 133555 +20001 133546 +10396 133540 +21350 133521 +22864 133484 +33953 133448 +17534 133432 +29638 133397 +18383 133386 +7241 133382 +43630 133346 +25160 133310 +5356 133302 +24534 133271 +21660 133251 +23140 133242 +19600 133234 +17239 133213 +13559 133210 +34944 133196 +17819 133125 +24722 133121 +34509 133118 +7737 133116 +23225 133089 +12957 133079 +19158 133031 +11215 133028 +35004 133010 +8491 132998 +30461 132990 +38599 132981 +17762 132978 +21277 132978 +9587 132973 +4828 132970 +16572 132957 +27803 132945 +20155 132912 +20333 132911 +18805 132907 +1732 132894 +18258 132883 +13601 132867 +17330 132854 +806 132852 +25463 132829 +15475 132816 +24803 132814 +32074 132808 +12078 132797 +16178 132792 +18552 132780 +33362 132778 +23178 132778 +21811 132771 +20030 132746 +34747 132706 +31827 132697 +11881 132687 +7518 132678 +14985 132669 +46800 132651 +22662 132640 +31307 132614 +28231 132609 +14664 132607 +19978 132601 +10794 132574 +32897 132545 +12115 132544 +30758 132541 +27388 132532 +28894 132530 +29066 132508 +18031 132440 +5321 132440 +31156 132418 +25130 132405 +34241 132380 +22255 132338 +18252 132308 +23548 132307 +35300 132300 +26264 132293 +22403 132289 +21358 132287 +27324 132257 +35331 132241 +19623 132232 +3444 132224 +39608 132215 +34995 132211 +7245 132211 +13332 132205 +26383 132203 +19869 132142 +34802 132112 +21419 132108 +12945 132088 +23033 132074 +14352 132073 +20545 132063 +37698 132057 +18132 132029 +13364 132018 +24199 132011 +12249 132005 +21788 132003 +26459 131986 +18585 131981 +14145 131961 +15025 131951 +8094 131944 +5056 131936 +8496 131930 +7951 131926 +32464 131913 +21572 131899 +23890 131893 +31187 131878 +27094 131874 +14775 131870 +16164 131870 +44070 131862 +935 131858 +22892 131842 +33127 131841 +18535 131830 +18045 131822 +17985 131820 +27028 131794 +10990 131793 +233 131755 +1032 131748 +12810 131670 +20295 131661 +7003 131644 +13531 131639 +19283 131633 +19521 131629 +10883 131607 +3102 131603 +23310 131602 +28972 131585 +5165 131579 +17885 131576 +12185 131569 +22688 131533 +23630 131530 +6472 131510 +20857 131502 +10840 131472 +13357 131449 +16131 131445 +19305 131438 +16157 131430 +32188 131412 +19406 131393 +18030 131387 +4016 131369 +16617 131368 +18514 131367 +25953 131334 +13333 131318 +23023 131299 +24315 131296 +15195 131293 +26735 131288 +13793 131276 +26608 131252 +19280 131233 +32737 131230 +5976 131228 +28132 131197 +25623 131179 +27663 131158 +18661 131145 +20152 131143 +15687 131126 +19850 131110 +6783 131085 +13140 131080 +32382 131072 +12809 131070 +1454 131069 +13496 131061 +23342 131057 +28223 131024 +19141 131022 +16924 131003 +15799 130966 +15943 130965 +19069 130964 +38768 130960 +30680 130916 +20230 130906 +22447 130893 +20220 130885 +23641 130885 +18257 130869 +20061 130868 +29755 130867 +13798 130850 +11340 130838 +8379 130835 +9164 130831 +23254 130822 +31592 130815 +31036 130808 +23411 130797 +16746 130783 +19533 130778 +18600 130768 +18192 130748 +5669 130742 +19189 130734 +17419 130704 +18056 130682 +24424 130681 +12854 130680 +19410 130662 +5872 130645 +16784 130638 +13108 130617 +23885 130606 +27779 130603 +14811 130593 +18579 130591 +15495 130558 +20607 130555 +10076 130554 +23366 130553 +18832 130552 +11982 130540 +22126 130538 +30717 130536 +14181 130527 +15064 130516 +31585 130506 +25564 130505 +29872 130490 +26167 130479 +19066 130476 +21922 130471 +8483 130441 +10389 130430 +26338 130402 +8881 130361 +9662 130356 +11817 130350 +16139 130336 +23659 130331 +3291 130328 +10203 130318 +2833 130283 +24310 130243 +29717 130191 +11028 130165 +14760 130155 +10992 130152 +10449 130128 +40518 130127 +13981 130093 +22573 130086 +6197 130086 +37478 130063 +19086 130054 +31311 130029 +49368 130024 +14795 129994 +19386 129991 +16217 129979 +24737 129960 +9543 129951 +45091 129944 +25476 129943 +10978 129933 +5910 129924 +30858 129910 +16043 129863 +21568 129860 +23782 129837 +13256 129807 +8410 129804 +24479 129787 +28236 129781 +34540 129770 +21332 129767 +37415 129704 +12530 129690 +29045 129676 +9052 129673 +19255 129652 +15917 129642 +17261 129624 +24083 129604 +17706 129598 +13597 129594 +30629 129587 +16523 129579 +17767 129570 +34285 129568 +39873 129554 +20623 129536 +17940 129530 +13519 129530 +27583 129529 +15762 129522 +3803 129499 +36401 129483 +30825 129482 +26106 129455 +2960 129446 +28559 129444 +19993 129436 +27209 129405 +6187 129401 +29364 129394 +18577 129378 +22310 129377 +18029 129363 +25556 129363 +32802 129362 +11364 129341 +16958 129340 +17677 129312 +24554 129301 +28150 129243 +37376 129209 +34564 129195 +13825 129189 +4239 129188 +28793 129168 +28319 129154 +10153 129150 +22086 129150 +17317 129150 +14806 129144 +6799 129137 +15577 129112 +23319 129096 +20833 129088 +9410 129056 +13242 129047 +11674 129039 +23704 129017 +11992 129017 +13829 129014 +11216 129009 +29029 128983 +19308 128976 +32408 128968 +11319 128936 +16379 128905 +2871 128865 +16711 128854 +19695 128852 +10214 128837 +10411 128813 +3299 128802 +7087 128781 +15502 128780 +21509 128778 +12469 128777 +14211 128776 +13160 128763 +21076 128759 +30321 128753 +12414 128727 +27918 128698 +30258 128698 +27179 128690 +18873 128688 +16026 128688 +20622 128666 +6429 128658 +15666 128641 +20775 128611 +14722 128607 +20749 128607 +26690 128554 +44723 128548 +18482 128544 +22176 128537 +13794 128537 +34497 128533 +28080 128527 +21320 128520 +14027 128499 +13235 128496 +15275 128492 +21454 128488 +19173 128447 +16976 128441 +15923 128440 +10350 128420 +21543 128354 +17919 128353 +28992 128338 +26617 128329 +14828 128323 +20239 128323 +16257 128293 +14745 128239 +17577 128234 +33487 128231 +6605 128229 +2086 128196 +17795 128182 +11960 128158 +5763 128145 +20691 128128 +9417 128124 +24535 128114 +11848 128102 +29470 128090 +2349 128089 +19832 128082 +14130 128060 +18306 128059 +28931 128054 +14991 128049 +16464 128042 +13906 128036 +13964 128032 +24999 128027 +21608 128023 +22836 128019 +34778 128017 +1224 128012 +8156 127986 +41530 127975 +8255 127963 +30511 127955 +16463 127953 +31802 127951 +20897 127935 +20027 127933 +18447 127917 +15847 127899 +24671 127878 +4161 127872 +20726 127850 +13698 127830 +20159 127826 +7354 127810 +36399 127809 +21120 127800 +11423 127791 +24093 127773 +35482 127769 +13424 127768 +29056 127739 +16967 127728 +3855 127719 +31329 127712 +13123 127695 +31970 127686 +22198 127638 +9449 127632 +20883 127616 +26626 127615 +9437 127588 +24660 127570 +25619 127569 +16481 127568 +16479 127562 +9367 127550 +25615 127547 +14963 127542 +24126 127539 +10838 127539 +20069 127526 +2388 127526 +22821 127519 +19546 127503 +25187 127487 +6437 127487 +29328 127462 +3817 127422 +24841 127416 +11959 127411 +21381 127405 +12685 127401 +29276 127377 +12265 127352 +17435 127348 +15061 127330 +1669 127328 +14292 127320 +17713 127315 +19063 127307 +19157 127281 +8351 127277 +19264 127255 +17757 127245 +11752 127207 +14553 127192 +20188 127170 +30088 127157 +15569 127152 +22424 127141 +7191 127137 +4551 127129 +21257 127127 +31100 127127 +9267 127119 +28181 127109 +14658 127089 +17603 127087 +8851 127082 +11976 127069 +26089 127068 +14976 127059 +3868 127049 +1226 127040 +20116 127039 +16697 127037 +32426 127029 +18282 127021 +8158 127004 +26044 127003 +12176 126996 +17361 126991 +23465 126976 +34283 126916 +24110 126892 +26482 126883 +14798 126866 +36011 126836 +11698 126823 +7736 126779 +28199 126777 +18359 126777 +33157 126772 +18057 126766 +5344 126749 +29852 126727 +8426 126721 +27466 126715 +14460 126712 +3930 126684 +14582 126678 +17865 126674 +8176 126622 +31325 126613 +12128 126609 +39998 126599 +17039 126588 +15325 126572 +15700 126538 +17789 126511 +20229 126490 +27082 126490 +24173 126455 +47417 126452 +21049 126376 +12416 126374 +234 126350 +9608 126318 +10723 126314 +6344 126314 +25693 126308 +27994 126292 +23527 126266 +110 126256 +25438 126255 +20018 126243 +26401 126222 +17009 126214 +35398 126200 +27181 126178 +15394 126166 +22895 126160 +13399 126152 +6152 126070 +33051 126068 +30918 126061 +32300 126058 +9090 126034 +11147 126006 +20573 126005 +22162 125978 +1727 125971 +36872 125968 +31455 125964 +13459 125960 +12431 125944 +23369 125940 +20738 125923 +8992 125913 +31806 125894 +29864 125890 +12959 125889 +17867 125857 +20212 125844 +9126 125812 +21151 125803 +29822 125802 +17769 125762 +14032 125746 +12587 125739 +24872 125735 +27051 125733 +22145 125721 +21329 125709 +2343 125702 +21880 125672 +25026 125659 +15900 125632 +5241 125627 +6434 125614 +23003 125594 +13897 125543 +18051 125534 +13468 125528 +15265 125521 +27165 125510 +28024 125506 +22052 125501 +29111 125497 +26321 125484 +13755 125474 +15778 125466 +11240 125464 +30498 125461 +23754 125450 +23856 125414 +33379 125367 +14165 125365 +12749 125345 +25028 125333 +28313 125331 +16386 125299 +16282 125293 +16949 125290 +36983 125273 +16829 125258 +21631 125254 +4199 125233 +38579 125213 +18794 125199 +7940 125190 +26431 125158 +40396 125151 +18978 125148 +30126 125144 +28830 125126 +17275 125125 +20469 125107 +4666 125106 +16342 125106 +30644 125051 +21555 125045 +10480 125034 +10536 125025 +10756 125025 +12035 125019 +8056 125013 +15972 124988 +18131 124971 +13948 124971 +26728 124956 +14249 124947 +15927 124937 +44130 124928 +46880 124912 +11891 124899 +27120 124857 +17760 124849 +15756 124847 +15458 124842 +15218 124822 +44418 124816 +21899 124814 +16276 124788 +11799 124788 +28274 124781 +15423 124764 +15588 124733 +17626 124723 +35921 124719 +15613 124712 +20062 124697 +29388 124694 +24878 124664 +9150 124653 +5314 124647 +19170 124645 +25005 124640 +13527 124636 +13604 124619 +17604 124610 +4626 124572 +28085 124567 +21801 124559 +42506 124556 +17404 124554 +4716 124547 +11879 124527 +38943 124485 +15524 124457 +14035 124441 +49963 124398 +18502 124394 +34072 124393 +20249 124389 +5299 124386 +15669 124369 +27890 124349 +28293 124329 +18839 124308 +19273 124302 +43204 124276 +21027 124269 +27309 124267 +23692 124252 +18082 124252 +2659 124243 +22727 124243 +1199 124239 +19525 124239 +29897 124224 +22325 124221 +30681 124190 +11782 124180 +22376 124105 +20612 124096 +2373 124096 +27512 124091 +27320 124071 +23953 124058 +16851 124048 +21547 124045 +16408 124037 +19719 123989 +20440 123988 +24185 123978 +16402 123943 +23446 123940 +31832 123926 +25821 123920 +6535 123915 +37236 123894 +26624 123888 +32788 123883 +25408 123870 +36707 123865 +38477 123845 +17021 123842 +3760 123831 +7662 123825 +14962 123814 +30569 123795 +32251 123776 +14787 123775 +21517 123753 +8205 123745 +19874 123734 +14160 123724 +19642 123705 +15408 123694 +14357 123690 +11621 123689 +25522 123687 +26673 123684 +17639 123681 +26849 123656 +5429 123621 +27999 123612 +12852 123612 +27350 123608 +23842 123602 +1214 123579 +30895 123559 +45376 123535 +33461 123520 +21845 123504 +29072 123497 +19183 123465 +10374 123419 +25866 123418 +24405 123406 +31154 123400 +23397 123390 +16003 123386 +19444 123382 +14267 123353 +15259 123346 +19374 123341 +6999 123340 +19330 123337 +11701 123317 +18281 123284 +14476 123278 +30857 123273 +35571 123272 +19451 123265 +16030 123263 +10870 123261 +18403 123215 +17170 123207 +10921 123203 +15837 123185 +29049 123176 +17141 123172 +15368 123168 +16609 123161 +18822 123148 +16524 123143 +38396 123091 +28842 123082 +19249 123080 +34803 123075 +13300 123073 +19595 123057 +15751 123055 +23679 123044 +50196 123042 +27938 123041 +18658 122934 +5391 122903 +23121 122853 +18990 122850 +14816 122833 +12816 122817 +25016 122807 +20268 122806 +33743 122793 +28549 122781 +26640 122767 +34649 122757 +25123 122740 +27557 122730 +13532 122717 +24172 122715 +8199 122667 +18178 122650 +21683 122604 +16690 122592 +35773 122588 +25575 122564 +14276 122559 +17990 122553 +27820 122549 +32907 122517 +22901 122505 +19611 122498 +18044 122478 +15629 122450 +18774 122446 +9156 122434 +27702 122421 +17755 122419 +17064 122398 +23352 122397 +39489 122393 +33099 122372 +3345 122359 +15277 122337 +15821 122332 +28608 122328 +32664 122320 +31045 122298 +24800 122293 +30724 122286 +33391 122275 +16555 122274 +11487 122269 +27922 122268 +29866 122267 +20105 122265 +13589 122260 +11181 122223 +14520 122206 +23933 122204 +21067 122194 +17233 122177 +17333 122168 +28760 122160 +15483 122157 +18207 122151 +19178 122151 +12835 122146 +26896 122141 +14461 122113 +19111 122104 +29431 122093 +25577 122083 +22355 122083 +17105 122065 +12819 122057 +24224 122023 +15772 122005 +21331 121999 +35292 121948 +15000 121946 +16880 121939 +46289 121924 +38718 121920 +18650 121917 +2146 121912 +31574 121909 +23143 121899 +4594 121896 +11844 121885 +24789 121882 +18767 121867 +40418 121845 +29834 121842 +27975 121824 +11914 121808 +26577 121791 +26004 121781 +27862 121776 +18957 121771 +21089 121764 +19015 121750 +14114 121748 +22118 121746 +35825 121727 +22803 121723 +16062 121692 +20963 121687 +27027 121665 +15833 121661 +12840 121654 +43736 121641 +13218 121636 +19188 121623 +14084 121622 +30552 121613 +20841 121595 +7925 121592 +28331 121583 +16289 121565 +28948 121558 +30422 121546 +19518 121542 +16785 121516 +22777 121507 +27604 121474 +22436 121467 +10005 121465 +3079 121458 +25218 121457 +17814 121418 +14144 121412 +10178 121411 +12994 121402 +5813 121392 +17026 121374 +34271 121366 +7210 121366 +22499 121344 +15448 121313 +26380 121311 +16412 121301 +24072 121295 +10133 121291 +14944 121282 +29975 121282 +31770 121280 +24138 121264 +7839 121247 +16997 121228 +4821 121222 +26966 121221 +41770 121215 +4653 121195 +15814 121179 +17442 121169 +7575 121133 +14268 121123 +38779 121115 +15178 121110 +37506 121108 +31107 121078 +10835 121074 +14404 121073 +19684 121048 +12550 121038 +3622 121019 +34273 121016 +15488 121016 +16936 121013 +32054 121011 +24054 121010 +34361 120997 +37822 120990 +3147 120971 +23276 120969 +18157 120957 +10254 120946 +5377 120932 +8702 120927 +20875 120921 +14907 120915 +31004 120888 +2588 120876 +23431 120875 +28212 120873 +41624 120868 +2505 120854 +37213 120848 +15728 120840 +12136 120838 +4830 120827 +23455 120816 +15213 120805 +28323 120804 +20324 120794 +22700 120786 +11230 120775 +31446 120774 +4775 120761 +15957 120760 +24076 120758 +18696 120758 +12518 120749 +28470 120716 +28449 120707 +11244 120691 +15781 120676 +27174 120676 +14425 120666 +15187 120654 +17142 120653 +27655 120646 +16662 120643 +15674 120638 +20952 120631 +15389 120630 +22105 120580 +20606 120580 +9223 120553 +34855 120551 +28275 120508 +22835 120507 +9791 120495 +13503 120475 +3976 120460 +33925 120449 +15709 120440 +20371 120439 +21187 120396 +27470 120386 +14682 120381 +18988 120379 +30197 120370 +11985 120353 +16014 120342 +21900 120323 +16309 120301 +44568 120291 +29583 120286 +10995 120285 +20518 120284 +22249 120281 +17210 120279 +30145 120243 +21404 120234 +5591 120233 +28314 120227 +2537 120221 +19236 120189 +31388 120186 +23732 120184 +14277 120172 +27504 120153 +10337 120141 +18639 120121 +35410 120108 +16224 120100 +45284 120055 +20525 120041 +28382 120031 +16510 120026 +5730 120006 +32612 119981 +49746 119974 +22111 119950 +14712 119947 +43321 119941 +20889 119936 +22250 119924 +14711 119913 +16871 119905 +35686 119871 +19827 119866 +24816 119820 +14199 119818 +10812 119815 +32801 119798 +29875 119795 +24746 119781 +18663 119772 +25876 119743 +33845 119741 +19134 119731 +20246 119692 +15216 119688 +7465 119681 +2758 119676 +10946 119674 +12807 119659 +44083 119659 +28755 119659 +22202 119642 +16220 119634 +29713 119630 +15758 119592 +11397 119582 +31066 119571 +27008 119551 +18101 119524 +21676 119521 +9206 119499 +28822 119497 +38780 119495 +39597 119480 +24215 119476 +18422 119472 +17228 119434 +9484 119428 +12116 119426 +19205 119424 +24462 119423 +35837 119407 +25604 119399 +20444 119399 +15922 119371 +24482 119369 +17698 119363 +31769 119358 +16235 119356 +6249 119355 +19505 119342 +15334 119337 +19059 119312 +19224 119292 +6637 119277 +21638 119272 +40666 119252 +47563 119245 +36677 119243 +15231 119229 +17341 119228 +18413 119221 +19287 119197 +10314 119173 +19992 119162 +28818 119150 +13674 119110 +17318 119107 +42095 119104 +27154 119096 +37518 119076 +20195 119074 +19885 119066 +2462 119063 +14932 119055 +19254 119041 +36552 119014 +11358 118995 +33534 118974 +12163 118957 +27434 118926 +19644 118916 +27511 118900 +17231 118891 +48349 118867 +44337 118827 +3674 118802 +22976 118787 +1319 118776 +15641 118775 +18963 118772 +19047 118771 +31593 118770 +24268 118770 +24120 118766 +24410 118765 +7854 118753 +17658 118737 +12558 118726 +7669 118722 +23634 118718 +12250 118710 +31039 118696 +12711 118695 +24791 118694 +27136 118687 +33445 118674 +17137 118670 +22116 118652 +21372 118651 +24759 118644 +19637 118643 +12314 118624 +4024 118619 +19572 118616 +8106 118612 +21190 118608 +29329 118591 +6749 118583 +5522 118573 +21189 118538 +20727 118524 +35083 118523 +22591 118520 +8336 118518 +18421 118510 +8120 118508 +27478 118507 +27667 118497 +18531 118493 +7975 118489 +18455 118481 +24967 118452 +16622 118441 +16560 118434 +17856 118417 +25048 118416 +17247 118409 +13008 118399 +30169 118392 +27023 118392 +16415 118387 +28237 118383 +25884 118378 +14561 118377 +28623 118376 +1974 118374 +34468 118353 +30997 118352 +17479 118309 +15063 118308 +40188 118300 +12183 118289 +28487 118265 +39692 118254 +10850 118242 +596 118239 +24024 118178 +29010 118175 +26549 118175 +7544 118174 +14622 118141 +21030 118135 +32130 118109 +15964 118100 +10321 118085 +5406 118074 +12799 118067 +9248 118049 +19450 118047 +13353 118038 +20340 118037 +20945 118033 +26562 118027 +24817 118026 +23141 118026 +35232 118004 +20747 118003 +17988 117996 +7001 117976 +26363 117967 +32210 117957 +31842 117951 +29216 117939 +15376 117938 +16727 117927 +22475 117899 +35560 117898 +16101 117871 +14917 117868 +9782 117864 +19837 117850 +16385 117848 +9130 117810 +26768 117788 +997 117779 +6864 117774 +21837 117760 +32055 117755 +36316 117750 +18592 117740 +36606 117732 +6285 117725 +13281 117721 +36345 117709 +4704 117694 +21229 117692 +34174 117672 +3366 117657 +45695 117655 +15129 117648 +46441 117643 +41863 117632 +1555 117625 +16039 117620 +14729 117604 +6161 117600 +32224 117592 +24058 117564 +17326 117563 +15745 117548 +8952 117546 +19235 117537 +17286 117529 +38167 117528 +10601 117522 +10136 117507 +49583 117488 +18821 117476 +46154 117472 +19272 117463 +21343 117461 +27707 117457 +3669 117453 +15766 117428 +34488 117427 +21846 117412 +37851 117408 +26516 117401 +21143 117391 +18725 117376 +34438 117368 +18702 117362 +8162 117343 +25259 117340 +22868 117336 +27818 117332 +18344 117327 +924 117316 +21472 117310 +40439 117306 +16971 117294 +32666 117293 +19125 117285 +31006 117275 +4861 117256 +14968 117255 +18692 117226 +8609 117209 +11854 117197 +30833 117194 +14941 117190 +12924 117181 +16450 117174 +48088 117173 +3305 117171 +15998 117171 +33017 117167 +40858 117164 +32579 117161 +17446 117132 +17636 117129 +21921 117124 +45567 117124 +41445 117094 +17631 117091 +23962 117024 +28367 117022 +14380 117015 +19417 117010 +38029 116996 +708 116994 +28990 116979 +17197 116973 +12368 116961 +23538 116953 +30418 116952 +49611 116944 +20913 116940 +30241 116931 +32451 116924 +31750 116924 +6837 116916 +15228 116889 +21830 116886 +14966 116854 +11377 116852 +24854 116839 +36269 116837 +248 116834 +13939 116827 +39290 116766 +3778 116752 +9771 116747 +22846 116733 +21347 116731 +33457 116727 +18451 116724 +19681 116718 +45790 116681 +13508 116680 +22493 116676 +22598 116671 +4720 116667 +30024 116661 +20928 116656 +21096 116654 +27581 116650 +5758 116642 +12902 116633 +22778 116623 +25894 116617 +15719 116606 +39398 116603 +16807 116602 +27231 116596 +7816 116582 +34108 116573 +30567 116559 +10056 116543 +14715 116519 +14475 116497 +23910 116456 +14834 116456 +30364 116454 +25706 116453 +15753 116444 +28442 116434 +35469 116433 +12310 116425 +15910 116416 +21957 116405 +39808 116388 +16903 116385 +18989 116376 +39487 116376 +14782 116372 +44744 116356 +17180 116354 +18556 116349 +26876 116324 +27436 116313 +25482 116308 +13735 116304 +25394 116294 +26450 116277 +37616 116277 +7643 116276 +10550 116245 +19693 116243 +25852 116220 +1009 116180 +12861 116176 +11043 116174 +17124 116170 +24933 116165 +12921 116149 +18642 116146 +15402 116135 +2469 116096 +28578 116075 +23682 116074 +17939 116040 +17918 116033 +4491 116022 +4399 116019 +22232 116015 +30837 116010 +2296 116003 +19356 115997 +30738 115978 +10934 115971 +15836 115952 +19266 115932 +28571 115926 +23558 115922 +22761 115911 +30217 115908 +28083 115882 +19750 115877 +15418 115869 +7438 115863 +37918 115860 +42442 115851 +22568 115848 +4670 115832 +20537 115831 +26212 115829 +10626 115826 +25722 115824 +24952 115801 +38739 115794 +28172 115756 +22942 115738 +32246 115724 +22698 115711 +26724 115689 +16394 115688 +19860 115671 +22045 115657 +19771 115654 +7286 115652 +31393 115649 +24719 115594 +10606 115590 +11742 115574 +20417 115560 +39641 115541 +30157 115539 +18979 115489 +29784 115471 +22871 115456 +16656 115454 +17412 115448 +20185 115441 +10340 115438 +22152 115437 +22753 115424 +47970 115422 +8332 115410 +20388 115407 +40238 115385 +17136 115384 +19215 115375 +5497 115369 +24630 115363 +36026 115356 +6217 115346 +38307 115331 +12931 115321 +44985 115318 +19240 115308 +8588 115305 +17343 115297 +16965 115297 +21108 115274 +31668 115272 +23423 115269 +44021 115255 +18316 115242 +111 115218 +30017 115213 +19152 115197 +34668 115186 +43449 115178 +14746 115152 +32559 115151 +39199 115140 +19014 115138 +8325 115132 +13348 115122 +28137 115112 +17351 115074 +10961 115046 +24448 115041 +30625 115012 +32473 114997 +27243 114972 +25737 114952 +38988 114930 +33629 114917 +1198 114880 +23041 114878 +33197 114860 +32763 114850 +25732 114849 +24617 114837 +4657 114831 +24237 114822 +18492 114820 +48609 114805 +17726 114802 +19575 114794 +10324 114779 +15009 114778 +10943 114778 +46485 114767 +34609 114761 +24011 114759 +24626 114742 +11393 114718 +14262 114713 +13432 114709 +20517 114709 +18813 114701 +23897 114697 +13813 114693 +24456 114672 +17870 114659 +4820 114652 +15363 114638 +18137 114627 +27239 114619 +37520 114611 +1791 114610 +34022 114584 +15693 114577 +16314 114563 +6696 114550 +22425 114545 +14934 114533 +13068 114533 +37936 114533 +46520 114532 +7510 114530 +19692 114528 +28001 114519 +20858 114465 +15959 114460 +34410 114446 +18429 114436 +21383 114434 +29476 114425 +20830 114419 +36019 114417 +15440 114410 +31140 114376 +13886 114375 +17451 114350 +16728 114339 +19516 114329 +19218 114295 +6347 114288 +6013 114285 +25347 114282 +28960 114280 +44286 114263 +20736 114226 +7758 114219 +25837 114215 +11994 114203 +17293 114196 +9435 114179 +2244 114175 +15186 114155 +18341 114147 +29147 114139 +26803 114113 +12342 114113 +33061 114104 +24829 114104 +18135 114084 +31047 114082 +40560 114068 +21307 114058 +21416 114031 +27046 114011 +24261 114008 +47168 113996 +10344 113973 +9222 113955 +102 113953 +3564 113949 +27026 113948 +26172 113940 +3130 113924 +3063 113907 +24627 113901 +27296 113856 +10157 113854 +11950 113851 +33617 113842 +15589 113838 +31799 113808 +19340 113805 +109 113805 +2573 113794 +47180 113776 +6878 113771 +18077 113739 +17714 113729 +40159 113721 +40344 113718 +38580 113716 +35007 113711 +35053 113685 +10896 113670 +19353 113666 +11339 113666 +47652 113661 +17099 113658 +28785 113653 +25338 113646 +22076 113639 +8085 113636 +9235 113629 +11386 113612 +19344 113612 +17877 113612 +20496 113594 +24682 113590 +32127 113557 +23915 113556 +10462 113553 +2621 113550 +30554 113540 +5133 113528 +13954 113525 +47296 113443 +16726 113424 +10173 113419 +20999 113413 +17584 113387 +35440 113386 +2352 113376 +26619 113372 +14177 113343 +7234 113325 +19289 113294 +25446 113249 +31984 113228 +18682 113217 +22435 113192 +22044 113175 +36952 113170 +20285 113152 +24060 113141 +25736 113139 +30697 113084 +18984 113082 +14568 113068 +24473 113039 +17924 113037 +32376 113032 +33708 113030 +28941 113014 +17298 113013 +13878 113012 +14956 113000 +14542 112997 +29189 112980 +17166 112979 +22199 112966 +23130 112943 +34724 112929 +15683 112912 +17523 112887 +16084 112886 +17655 112871 +17558 112871 +20421 112866 +36477 112850 +17805 112849 +18450 112847 +35401 112845 +20929 112836 +14397 112833 +15181 112827 +12169 112804 +25374 112802 +20970 112801 +5482 112794 +16370 112782 +16550 112781 +21010 112776 +42071 112773 +13196 112755 +16576 112754 +15467 112752 +91 112729 +21966 112720 +29018 112719 +27788 112718 +23107 112696 +6691 112695 +38256 112694 +24610 112693 +10256 112691 +26202 112678 +23950 112673 +1563 112672 +20828 112642 +28587 112640 +16159 112637 +22518 112637 +9467 112608 +23529 112607 +10360 112607 +23948 112603 +9230 112592 +21961 112588 +26630 112585 +12961 112577 +16835 112565 +33726 112551 +28550 112537 +16042 112531 +9732 112521 +24948 112520 +10917 112519 +17238 112508 +15482 112506 +14419 112484 +16573 112478 +20756 112465 +17549 112426 +16294 112420 +18881 112418 +2851 112409 +29758 112392 +16489 112375 +14209 112371 +26585 112361 +40928 112354 +9665 112346 +17033 112337 +43225 112332 +23541 112321 +22694 112320 +25436 112317 +23825 112315 +21998 112298 +8642 112295 +24313 112284 +16840 112281 +29980 112271 +10693 112258 +30426 112255 +21702 112236 +17970 112199 +3027 112194 +24891 112183 +14572 112169 +4722 112149 +3219 112147 +1449 112130 +27496 112098 +22848 112089 +18162 112084 +28375 112054 +20294 112053 +29019 112048 +26736 112047 +5139 112032 +15618 112031 +36067 112030 +26066 112024 +9998 112023 +36518 112019 +29260 112017 +46536 112016 +22268 112007 +12618 111987 +17623 111987 +25750 111980 +30287 111957 +18384 111956 +16057 111956 +33311 111930 +33371 111930 +6606 111906 +21590 111904 +41806 111904 +23718 111903 +29553 111853 +24025 111849 +34687 111840 +27497 111833 +18120 111829 +18098 111817 +13505 111816 +2413 111776 +27906 111774 +18744 111765 +20835 111746 +1800 111745 +18622 111736 +16999 111726 +14047 111710 +26278 111708 +7885 111680 +18981 111679 +37909 111671 +14259 111665 +40098 111653 +22292 111646 +11466 111607 +27473 111603 +15975 111601 +3018 111598 +19612 111585 +18820 111566 +31946 111560 +36178 111544 +14233 111526 +12093 111521 +5336 111514 +13841 111480 +39992 111478 +25694 111476 +49487 111476 +19426 111473 +20449 111469 +1536 111462 +22843 111459 +22807 111449 +21411 111447 +22097 111387 +12510 111385 +20629 111383 +21832 111360 +15185 111321 +9973 111320 +29926 111313 +17888 111306 +25570 111298 +34521 111292 +13762 111274 +38529 111270 +32534 111267 +27119 111259 +18877 111243 +792 111231 +21570 111201 +7738 111178 +31620 111174 +31622 111172 +22581 111154 +2179 111152 +11144 111141 +5040 111121 +16747 111073 +13025 111060 +6010 111050 +17568 111050 +20433 111010 +20577 110983 +19217 110974 +29012 110948 +20562 110917 +18197 110910 +14547 110908 +33098 110894 +35783 110881 +22096 110879 +12821 110869 +16760 110864 +15131 110864 +34560 110857 +27418 110855 +974 110850 +26891 110849 +36986 110848 +36683 110815 +13433 110810 +25813 110795 +24634 110781 +5328 110780 +28604 110768 +19894 110754 +28628 110720 +17508 110714 +24884 110708 +22723 110705 +21001 110697 +4628 110669 +18233 110660 +31617 110625 +23994 110620 +14872 110618 +22537 110592 +16347 110563 +11880 110559 +33847 110559 +20471 110555 +18583 110553 +9678 110546 +13787 110530 +37081 110528 +38805 110507 +15094 110504 +33625 110502 +12397 110501 +34814 110499 +29 110485 +9377 110471 +25814 110470 +37790 110464 +17076 110419 +36199 110412 +32206 110411 +12076 110407 +23687 110402 +8729 110399 +22533 110393 +17565 110375 +25691 110364 +16416 110357 +16292 110346 +28773 110346 +16106 110343 +27147 110342 +13015 110331 +16343 110317 +30744 110312 +15968 110303 +35903 110267 +7934 110261 +243 110257 +30007 110254 +13482 110252 +12256 110244 +23017 110238 +4241 110232 +30379 110211 +20173 110198 +28276 110176 +24065 110172 +19951 110168 +45818 110162 +26420 110158 +18493 110158 +19379 110154 +36852 110123 +17229 110106 +17453 110105 +23707 110102 +12064 110092 +12707 110082 +31244 110069 +28014 110046 +2980 110045 +17556 110043 +1401 110024 +27872 110021 +12648 110011 +10796 110009 +18500 110006 +22414 109992 +30628 109992 +12178 109989 +8423 109985 +15284 109974 +23448 109945 +27206 109927 +22575 109926 +21025 109915 +24264 109903 +23384 109898 +2284 109898 +14479 109885 +29921 109881 +8757 109867 +34753 109867 +27216 109862 +19561 109854 +15731 109841 +31108 109834 +5285 109830 +14206 109802 +20406 109789 +21625 109782 +6162 109780 +27589 109766 +40162 109754 +26853 109753 +33006 109733 +13868 109724 +30215 109723 +17644 109720 +31942 109711 +20794 109705 +8870 109685 +38613 109647 +43105 109641 +21951 109636 +3508 109629 +15610 109610 +29597 109607 +37070 109563 +21823 109545 +14766 109542 +9383 109541 +9708 109539 +16925 109531 +18321 109531 +16251 109514 +22560 109502 +25340 109489 +13071 109479 +32669 109479 +18461 109462 +40532 109458 +34186 109449 +28513 109446 +37921 109420 +8652 109399 +27517 109399 +12430 109375 +14290 109374 +50240 109356 +27058 109344 +25892 109323 +18626 109313 +9178 109304 +36363 109265 +24034 109262 +27333 109250 +35553 109243 +9440 109239 +34699 109239 +49403 109230 +7020 109226 +16073 109215 +17074 109191 +16695 109190 +48583 109183 +47177 109166 +26496 109164 +8567 109162 +16158 109157 +17700 109114 +16058 109112 +27974 109089 +28879 109087 +17163 109079 +25957 109071 +24622 109053 +26049 109044 +17345 109038 +23622 109028 +25949 109027 +27833 109020 +26389 109002 +15169 109002 +25065 108979 +21651 108957 +23804 108946 +14698 108943 +23062 108941 +20387 108930 +15993 108930 +32868 108923 +27835 108908 +20101 108907 +37126 108899 +24649 108881 +23911 108878 +21200 108876 +941 108873 +13050 108861 +21099 108851 +24522 108847 +4984 108838 +15337 108834 +32992 108832 +34553 108827 +5731 108822 +20338 108811 +35345 108795 +37270 108794 +36758 108791 +8459 108790 +17656 108782 +42556 108782 +21707 108777 +41816 108764 +29842 108758 +41759 108758 +15938 108753 +29139 108746 +21068 108743 +16944 108734 +13746 108721 +2136 108712 +21566 108691 +15510 108679 +15533 108678 +26361 108677 +15939 108671 +25826 108655 +43416 108650 +11460 108646 +29761 108646 +18235 108626 +17289 108618 +17342 108612 +20031 108607 +30067 108607 +28245 108589 +29578 108583 +32444 108580 +24141 108576 +23783 108551 +21203 108544 +25203 108539 +45980 108539 +19458 108529 +10957 108528 +29588 108507 +24701 108498 +13695 108489 +8109 108486 +25141 108469 +36451 108460 +13411 108459 +12635 108442 +5558 108421 +15344 108417 +17548 108401 +25539 108399 +17775 108360 +28926 108341 +23103 108333 +45624 108330 +38602 108318 +26905 108304 +31275 108289 +39717 108286 +21673 108284 +10905 108265 +23185 108247 +34479 108242 +12251 108242 +20425 108242 +12177 108231 +21799 108218 +22673 108189 +31988 108187 +23993 108184 +28503 108175 +18427 108171 +32810 108130 +21848 108123 +33624 108112 +11598 108082 +24471 108049 +47604 108032 +18357 108026 +10707 108011 +9122 107999 +17696 107994 +22527 107990 +19647 107989 +15874 107977 +6258 107969 +16019 107967 +23973 107959 +26635 107954 +23887 107919 +13822 107917 +25965 107902 +18693 107889 +35089 107873 +28289 107850 +30770 107844 +10356 107804 +22561 107803 +42735 107795 +13745 107775 +35759 107766 +14992 107755 +28619 107755 +35206 107752 +7614 107745 +9446 107705 +36675 107690 +10327 107670 +41427 107666 +12876 107664 +23086 107651 +19901 107616 +21031 107579 +44321 107574 +33059 107560 +41253 107537 +33673 107536 +30597 107535 +14294 107534 +7250 107531 +27505 107531 +24341 107525 +36700 107516 +28485 107514 +34272 107514 +29336 107476 +20881 107471 +11653 107461 +29575 107452 +6243 107451 +23256 107447 +15529 107429 +21954 107420 +16605 107413 +2375 107413 +18436 107396 +14893 107391 +25523 107378 +7922 107373 +18179 107368 +13493 107366 +35691 107365 +17607 107348 +30401 107338 +1356 107332 +16882 107330 +25247 107317 +29521 107310 +11354 107308 +17942 107301 +23621 107297 +17439 107288 +11659 107272 +28346 107263 +17365 107258 +19658 107251 +44198 107247 +21596 107243 +25427 107235 +15017 107215 +18987 107199 +11401 107183 +10781 107179 +12375 107176 +15561 107168 +39062 107167 +4834 107159 +19038 107153 +21655 107138 +16125 107128 +23404 107127 +7952 107119 +29838 107098 +23514 107074 +22566 107038 +31876 107035 +25477 107014 +17186 107001 +25910 106995 +25824 106991 +25146 106974 +22894 106968 +29058 106953 +3718 106938 +36486 106932 +19113 106932 +24963 106930 +21046 106917 +20349 106912 +8625 106905 +25395 106878 +35188 106861 +34002 106860 +29656 106849 +932 106830 +18787 106830 +28672 106817 +39700 106798 +15058 106798 +31845 106798 +35892 106792 +30081 106760 +18399 106755 +39560 106753 +43262 106752 +13602 106745 +3384 106743 +19748 106725 +20528 106718 +29463 106712 +15645 106680 +17624 106678 +36719 106671 +19439 106659 +42668 106650 +21658 106623 +20236 106603 +12986 106599 +12870 106581 +8079 106576 +39137 106568 +18854 106552 +13664 106543 +12253 106495 +14063 106481 +25136 106471 +16762 106462 +16668 106453 +37578 106452 +29803 106432 +19168 106428 +26005 106408 +21362 106404 +21276 106400 +24271 106381 +26349 106371 +22900 106361 +20657 106360 +17753 106358 +46726 106344 +6113 106338 +24226 106337 +31074 106336 +17927 106333 +28044 106330 +4517 106327 +27687 106320 +19761 106313 +13575 106310 +18174 106282 +29820 106265 +18350 106262 +21723 106250 +37425 106240 +19654 106224 +5261 106223 +33035 106219 +36236 106203 +31333 106199 +43804 106198 +1860 106194 +11813 106179 +5685 106177 +13950 106177 +18418 106170 +16739 106164 +15936 106134 +18778 106127 +35902 106125 +32211 106122 +26815 106121 +27909 106119 +38001 106102 +48245 106097 +10339 106094 +30947 106078 +7842 106055 +24929 106038 +6391 105988 +21430 105973 +16426 105960 +15121 105958 +24128 105950 +17501 105930 +26336 105916 +25422 105910 +44844 105856 +5905 105843 +25485 105839 +2377 105825 +17586 105823 +14175 105822 +25614 105818 +22168 105808 +48560 105805 +42192 105798 +4135 105767 +12918 105742 +31117 105726 +17522 105716 +20732 105712 +16222 105709 +18035 105690 +15290 105633 +32470 105630 +22549 105607 +43013 105596 +18734 105595 +32034 105590 +13860 105581 +31232 105578 +39507 105571 +33787 105569 +5185 105569 +34992 105557 +20487 105544 +18894 105536 +14870 105520 +12941 105491 +29599 105482 +23543 105464 +16836 105460 +28229 105455 +7414 105449 +21615 105449 +36962 105418 +18028 105409 +35468 105406 +39032 105406 +24351 105397 +2220 105387 +39329 105383 +13661 105375 +985 105373 +31610 105352 +16430 105349 +20401 105348 +26038 105347 +21368 105326 +3646 105323 +26474 105320 +6767 105317 +44487 105294 +18782 105285 +17279 105275 +15497 105268 +40707 105266 +30385 105261 +29799 105256 +2557 105241 +1149 105226 +23080 105189 +17554 105179 +20160 105164 +27723 105162 +32586 105160 +10676 105154 +14107 105139 +10982 105131 +27316 105111 +10644 105109 +23365 105106 +1882 105085 +19193 105060 +24057 105059 +35507 105055 +11427 105024 +16065 105020 +18395 105017 +47975 105001 +12583 104995 +1861 104991 +38581 104975 +19589 104971 +19942 104959 +34807 104949 +14739 104948 +30446 104922 +37958 104912 +10510 104907 +6966 104889 +31376 104889 +18474 104873 +22650 104867 +28917 104843 +15857 104825 +12171 104825 +12038 104822 +42555 104819 +36547 104790 +15991 104789 +23030 104785 +19726 104780 +39911 104761 +26779 104752 +27565 104752 +22928 104741 +17184 104739 +16627 104734 +3571 104687 +15494 104677 +27337 104671 +10091 104669 +15989 104665 +26036 104660 +33500 104650 +24690 104606 +20674 104597 +27311 104596 +17783 104590 +23231 104588 +40556 104586 +28163 104581 +13397 104574 +27709 104566 +17621 104565 +30773 104562 +41582 104562 +17592 104532 +28723 104530 +36442 104526 +1264 104523 +16069 104515 +49743 104496 +32743 104485 +27585 104484 +33943 104479 +23229 104478 +30469 104472 +8337 104465 +18247 104461 +25363 104461 +22649 104458 +3969 104437 +23923 104424 +31019 104413 +4967 104390 +17778 104379 +27399 104375 +29209 104367 +13865 104354 +35079 104350 +17544 104349 +8863 104347 +21942 104345 +9703 104340 +12853 104326 +26319 104318 +30190 104315 +23184 104285 +26147 104273 +2903 104262 +20354 104253 +18671 104253 +16800 104229 +14242 104219 +8445 104217 +24824 104211 +33874 104198 +15632 104192 +15122 104183 +22804 104182 +33831 104177 +17587 104144 +31118 104114 +17686 104108 +17348 104103 +19957 104091 +24377 104085 +33828 104081 +16382 104077 +41916 104045 +17172 104043 +1376 104042 +18002 104038 +11978 104035 +20372 104024 +18898 104014 +30884 103943 +18780 103938 +19938 103936 +23151 103928 +15990 103904 +38684 103894 +18645 103870 +30596 103865 +9092 103852 +30105 103835 +47280 103829 +12040 103816 +27428 103816 +27875 103813 +9414 103804 +33442 103802 +18339 103797 +11777 103788 +42263 103767 +43602 103760 +25880 103756 +7793 103754 +19905 103747 +6083 103746 +16049 103738 +22397 103731 +26248 103720 +21553 103708 +16577 103703 +26725 103662 +13629 103660 +23610 103655 +41158 103638 +24263 103636 +24348 103590 +40370 103580 +9729 103568 +9861 103567 +29313 103564 +25756 103550 +24169 103541 +29234 103528 +47827 103506 +13345 103491 +19470 103488 +24411 103488 +17263 103478 +27658 103467 +12089 103457 +28634 103444 +1493 103440 +21160 103432 +24157 103415 +29941 103391 +26476 103389 +23147 103388 +30359 103378 +26540 103363 +11789 103361 +11437 103354 +20346 103346 +14589 103346 +19276 103339 +3339 103311 +37142 103300 +11517 103293 +20070 103275 +5842 103264 +13431 103260 +27811 103244 +45196 103236 +11908 103232 +12728 103220 +26399 103206 +20024 103200 +16194 103196 +31105 103148 +19022 103137 +2175 103129 +17784 103128 +41976 103126 +18507 103123 +9972 103123 +2302 103102 +22307 103102 +12219 103095 +39943 103079 +33089 103052 +36577 103024 +17146 103018 +30341 103009 +42896 103003 +19870 102997 +32681 102991 +29634 102984 +44081 102977 +9529 102948 +32013 102947 +35627 102934 +37568 102931 +27401 102921 +15741 102914 +4015 102903 +8653 102895 +27157 102878 +47214 102866 +13322 102862 +41124 102858 +30679 102858 +39295 102856 +24788 102840 +17175 102840 +27426 102836 +47837 102813 +8583 102810 +21104 102782 +37112 102767 +12281 102746 +33251 102743 +45015 102705 +24267 102704 +29756 102671 +6368 102668 +10151 102659 +25488 102649 +39874 102634 +39393 102632 +30938 102631 +24056 102621 +19471 102619 +9551 102609 +6345 102608 +22063 102603 +42631 102602 +17399 102593 +3870 102589 +33577 102587 +39723 102543 +12270 102529 +15136 102525 +21122 102522 +38938 102520 +2881 102514 +3370 102507 +48286 102505 +2117 102500 +37178 102500 +15268 102482 +33185 102482 +20976 102474 +30789 102472 +34325 102467 +18781 102456 +21007 102453 +10185 102450 +14197 102440 +19560 102427 +36595 102375 +31214 102367 +4591 102346 +31790 102342 +25720 102333 +33998 102322 +25758 102308 +34955 102296 +22783 102275 +33644 102260 +46614 102258 +30537 102232 +23096 102226 +12109 102226 +23264 102218 +38465 102200 +40911 102195 +21310 102194 +44634 102193 +15476 102191 +23458 102181 +29156 102179 +16225 102168 +28648 102167 +33556 102156 +18177 102139 +7332 102129 +25401 102126 +16737 102106 +22197 102104 +20880 102095 +26395 102091 +27612 102084 +26965 102082 +30966 102073 +14666 102066 +27240 102061 +3920 102059 +34612 102023 +29497 102013 +18947 102013 +34492 102003 +32835 101996 +34806 101986 +23602 101982 +20242 101975 +5473 101972 +17169 101970 +8132 101968 +33208 101965 +17754 101957 +16600 101953 +16857 101939 +24532 101910 +49927 101896 +42177 101891 +34308 101891 +22737 101889 +22729 101888 +26890 101883 +24654 101875 +22359 101875 +1163 101864 +11081 101853 +22943 101845 +20431 101843 +32748 101835 +23967 101825 +15777 101819 +23787 101814 +23189 101797 +21545 101792 +39220 101773 +25582 101761 +8562 101754 +17311 101740 +22982 101738 +29188 101725 +18565 101715 +21435 101714 +40897 101711 +19010 101700 +33670 101699 +14366 101688 +34985 101687 +9734 101682 +14289 101662 +17779 101650 +25854 101637 +13929 101621 +28187 101620 +22187 101605 +14243 101605 +7292 101591 +17557 101589 +25927 101575 +17091 101562 +18593 101542 +30164 101540 +30008 101533 +23508 101508 +19166 101497 +18326 101451 +30979 101436 +24365 101436 +33817 101433 +29618 101426 +23708 101424 +16181 101413 +43025 101391 +3042 101389 +31463 101385 +7367 101375 +35321 101374 +35532 101370 +29468 101349 +14108 101344 +25819 101342 +26850 101315 +6883 101315 +24171 101305 +46198 101304 +37686 101297 +11670 101289 +1920 101275 +10296 101271 +25656 101262 +40730 101257 +12311 101237 +31523 101234 +20720 101219 +25217 101212 +18697 101203 +40186 101194 +14563 101183 +16322 101180 +25712 101177 +11651 101167 +22412 101167 +20825 101160 +46055 101145 +14704 101139 +21567 101129 +14835 101127 +20538 101116 +14330 101095 +20078 101079 +47677 101066 +43480 101065 +19095 101037 +11773 101021 +25162 101015 +22551 101012 +19048 101010 +23204 101006 +30933 100994 +22238 100974 +29504 100967 +21664 100965 +20699 100965 +9331 100964 +16896 100963 +24150 100958 +45726 100946 +16092 100944 +22392 100928 +27545 100921 +25510 100913 +24972 100898 +38880 100887 +26166 100877 +49251 100856 +22706 100856 +24658 100850 +23014 100847 +38507 100845 +5768 100834 +29585 100820 +22978 100773 +18902 100769 +8195 100745 +14839 100734 +3116 100728 +17032 100702 +26122 100699 +41673 100697 +15481 100667 +23034 100663 +20793 100660 +17898 100658 +13542 100658 +22669 100657 +31134 100637 +14230 100636 +16953 100622 +40419 100616 +2838 100609 +10447 100600 +18737 100583 +23018 100572 +32017 100554 +13166 100545 +17485 100536 +28893 100535 +12442 100532 +18608 100530 +14924 100523 +27555 100523 +31183 100517 +27196 100509 +35852 100507 +20192 100505 +4726 100505 +3746 100502 +15702 100496 +22498 100492 +19683 100492 +16006 100456 +39929 100453 +29764 100451 +6223 100439 +21501 100433 +43724 100430 +40458 100410 +19369 100402 +28772 100394 +8303 100394 +29545 100385 +45526 100360 +39781 100356 +17085 100353 +30115 100343 +46965 100335 +9785 100334 +9766 100314 +33324 100280 +16046 100274 +5807 100274 +28528 100268 +21098 100265 +38762 100258 +10161 100256 +39268 100256 +36194 100251 +24607 100247 +29170 100235 +28800 100226 +2991 100180 +28515 100159 +26862 100146 +1316 100144 +23796 100138 +11046 100136 +19337 100127 +12608 100126 +7376 100114 +29732 100107 +17567 100098 +20991 100094 +12636 100093 +24130 100092 +45130 100092 +984 100092 +13851 100071 +33452 100071 +39410 100054 +22259 100046 +9967 100038 +30593 100023 +27548 100018 +10680 100008 +39030 100008 +29384 99993 +17724 99992 +25358 99984 +21080 99981 +3857 99981 +32719 99971 +7649 99960 +32787 99958 +36388 99950 +43708 99940 +28635 99937 +32705 99930 +13254 99925 +30776 99923 +35481 99922 +17234 99912 +15119 99899 +34908 99861 +13805 99861 +33609 99851 +22677 99843 +18276 99837 +26183 99827 +15309 99810 +20263 99799 +41405 99793 +18512 99793 +16839 99779 +13545 99766 +19239 99755 +41800 99754 +17862 99754 +1794 99749 +21647 99737 +39964 99736 +23383 99723 +31908 99720 +25999 99720 +11308 99720 +35956 99695 +5105 99693 +26207 99660 +30783 99655 +24450 99653 +27343 99648 +24842 99644 +24347 99634 +18954 99625 +20820 99621 +23461 99614 +29798 99593 +10279 99589 +25605 99582 +19910 99562 +26775 99561 +8597 99558 +14574 99545 +6269 99520 +22321 99518 +14195 99510 +48148 99507 +32098 99474 +23316 99455 +12340 99450 +26786 99446 +17572 99423 +19401 99415 +45395 99405 +2733 99392 +26670 99378 +31826 99377 +18630 99373 +22505 99372 +37388 99371 +17978 99364 +12366 99357 +18297 99352 +5315 99352 +23618 99350 +21235 99343 +13898 99335 +26345 99331 +16236 99327 +39140 99323 +38772 99314 +28038 99308 +16121 99306 +18975 99302 +23309 99263 +12434 99260 +19096 99255 +29297 99240 +31370 99229 +19318 99226 +12403 99216 +29721 99214 +14251 99213 +19268 99200 +34705 99187 +11999 99183 +13526 99183 +16717 99175 +26103 99152 +21883 99148 +19288 99131 +18953 99126 +20039 99125 +31833 99122 +23245 99121 +22692 99118 +29532 99112 +39810 99072 +21810 99069 +17640 99069 +34707 99067 +30489 99055 +33478 99054 +18229 99034 +28651 99027 +34930 99027 +26530 99022 +26555 99020 +43305 99001 +28444 99001 +38204 98999 +24638 98996 +22526 98983 +14796 98983 +19229 98967 +30399 98959 +18460 98956 +23099 98954 +17543 98953 +14627 98946 +27539 98941 +48023 98930 +27725 98918 +10508 98910 +24166 98907 +30654 98895 +27382 98894 +19321 98893 +16123 98889 +22644 98882 +17430 98881 +19605 98878 +27806 98875 +19123 98875 +23207 98824 +25987 98811 +26048 98805 +35801 98804 +11348 98796 +10944 98793 +10117 98787 +15104 98780 +25724 98770 +47804 98760 +37903 98756 +14299 98745 +22896 98739 +26211 98735 +9649 98716 +19604 98712 +14056 98710 +18370 98651 +35434 98644 +238 98630 +47317 98624 +20843 98621 +32987 98612 +34880 98609 +15387 98604 +7190 98579 +32370 98579 +22977 98578 +20611 98567 +33905 98561 +2036 98556 +31057 98553 +43265 98550 +45870 98549 +7217 98549 +16113 98546 +33997 98528 +11251 98527 +42484 98525 +18336 98522 +26409 98518 +19035 98512 +47251 98487 +15548 98478 +3630 98467 +21258 98454 +23730 98450 +16613 98449 +10793 98428 +26443 98414 +14570 98405 +4402 98405 +32364 98397 +30091 98392 +40944 98386 +12277 98362 +20947 98360 +23148 98355 +21135 98351 +42745 98344 +25185 98339 +7991 98331 +10265 98313 +28901 98292 +4593 98291 +33261 98290 +24644 98283 +13626 98282 +18587 98281 +11502 98276 +31437 98267 +26622 98265 +21764 98242 +45408 98214 +32330 98212 +15639 98198 +16777 98196 +27440 98189 +38278 98169 +24395 98167 +25051 98164 +39588 98158 +31596 98157 +32536 98133 +24558 98122 +12765 98117 +28194 98102 +28437 98098 +24955 98087 +44211 98086 +41196 98079 +37536 98069 +21635 98058 +3628 98053 +48931 98053 +15377 98041 +10771 98034 +28118 98030 +32443 98013 +21923 98008 +23916 98006 +25718 98005 +16687 98002 +16215 98001 +46819 97997 +11404 97997 +3445 97990 +15750 97970 +8623 97967 +28892 97960 +19508 97960 +13231 97943 +42883 97942 +10705 97939 +28061 97919 +29014 97915 +14887 97908 +31974 97903 +6855 97903 +17765 97903 +14155 97900 +16614 97893 +26117 97891 +37154 97883 +30890 97880 +26746 97874 +23335 97858 +10022 97838 +32020 97828 +12678 97827 +45810 97821 +28752 97795 +30996 97783 +31949 97779 +12544 97767 +39143 97757 +25967 97745 +16418 97741 +19064 97735 +30612 97693 +31357 97686 +29529 97682 +11927 97679 +17031 97679 +32597 97675 +29357 97674 +10414 97665 +45051 97663 +34827 97662 +40197 97660 +25017 97655 +13555 97649 +18288 97648 +7619 97621 +14612 97621 +12456 97621 +24723 97618 +31661 97616 +5900 97605 +32183 97601 +18026 97599 +42693 97599 +16531 97596 +26520 97586 +29667 97584 +29596 97581 +19723 97575 +27439 97575 +30757 97553 +31473 97552 +26082 97544 +26328 97542 +20908 97540 +37085 97527 +18121 97515 +33140 97514 +15633 97513 +27396 97512 +19556 97510 +22030 97498 +22888 97492 +11014 97487 +20321 97485 +33685 97481 +28744 97463 +34068 97455 +18539 97452 +15663 97451 +16731 97434 +22147 97423 +23949 97421 +28514 97417 +49173 97414 +28193 97385 +22329 97366 +25659 97354 +41035 97343 +26860 97342 +44369 97324 +39452 97317 +12371 97315 +17300 97313 +40449 97290 +20410 97288 +17145 97282 +22710 97279 +40195 97271 +19552 97265 +4246 97248 +21815 97245 +33515 97229 +31558 97228 +22060 97228 +39802 97223 +16885 97204 +43004 97203 +6701 97196 +28076 97186 +25734 97186 +35807 97182 +20571 97179 +19187 97172 +11986 97157 +11822 97156 +22295 97144 +30236 97137 +30140 97126 +14301 97108 +21085 97100 +22870 97092 +28949 97089 +23327 97080 +14927 97073 +24892 97071 +9078 97070 +25779 97053 +17080 97048 +22181 97048 +24805 97047 +48206 97042 +14014 97036 +17694 97032 +28853 97030 +25223 97019 +21092 97015 +8042 97008 +14898 97007 +34681 97005 +18594 97001 +18834 96999 +46499 96989 +18176 96985 +45212 96983 +19922 96982 +44726 96970 +4126 96968 +34755 96962 +24784 96957 +25428 96943 +48460 96934 +40388 96923 +2825 96911 +21686 96907 +32265 96898 +23301 96894 +11862 96892 +23299 96891 +21124 96879 +5106 96872 +38276 96871 +19144 96865 +26197 96858 +17511 96854 +17531 96848 +16312 96845 +15053 96835 +16716 96830 +8421 96817 +18543 96812 +18118 96805 +32615 96803 +18411 96789 +3076 96780 +20888 96775 +19459 96769 +6018 96764 +24495 96759 +22051 96753 +26299 96752 +4604 96742 +23071 96741 +1106 96729 +34327 96727 +38619 96710 +38740 96708 +43237 96702 +46097 96692 +35234 96689 +19468 96678 +8923 96678 +30785 96671 +33750 96670 +24514 96666 +17207 96649 +20420 96646 +19433 96645 +19884 96635 +24350 96635 +6661 96624 +23165 96608 +20254 96601 +33094 96592 +22979 96591 +22623 96590 +23160 96579 +13522 96578 +9203 96556 +24048 96555 +9971 96528 +10780 96521 +34701 96520 +25863 96507 +36231 96504 +24942 96501 +34060 96479 +20040 96463 +14392 96453 +29015 96451 +9696 96441 +30257 96436 +31784 96430 +13543 96429 +19267 96422 +47967 96420 +13826 96420 +36889 96417 +4798 96406 +34440 96405 +25483 96376 +19133 96356 +34780 96356 +41348 96344 +33718 96343 +10378 96333 +17486 96328 +13309 96326 +9192 96311 +21754 96301 +29136 96290 +27278 96290 +26605 96273 +31269 96262 +26843 96260 +29815 96243 +4862 96231 +21219 96219 +20787 96213 +2856 96205 +33130 96196 +28445 96191 +22604 96180 +27340 96178 +15544 96168 +25115 96151 +19165 96145 +10007 96142 +28036 96135 +20408 96116 +2725 96115 +22989 96083 +19143 96079 +27264 96072 +26077 96072 +9632 96053 +4063 96036 +24089 96036 +29239 96032 +23273 96026 +14661 96021 +35415 96012 +3043 96011 +27567 96010 +39447 96010 +9069 95993 +31171 95988 +27353 95985 +32137 95980 +40695 95952 +20750 95941 +40222 95937 +21100 95922 +21558 95913 +32410 95910 +27177 95908 +20056 95890 +31220 95888 +13905 95883 +35274 95871 +22668 95857 +18275 95855 +26594 95835 +25786 95822 +14564 95821 +27308 95810 +24281 95805 +19897 95803 +32490 95796 +14948 95762 +2017 95741 +19713 95740 +24387 95733 +25075 95724 +22474 95724 +18831 95719 +34886 95717 +27425 95714 +13315 95698 +28492 95692 +48395 95686 +30652 95683 +30651 95671 +39361 95668 +41114 95663 +35121 95658 +23867 95651 +31981 95650 +2021 95649 +21662 95645 +16632 95638 +25377 95637 +21461 95633 +28120 95633 +25646 95620 +16588 95617 +36799 95615 +9883 95607 +20925 95592 +18511 95588 +44168 95587 +39672 95576 +21164 95565 +18027 95562 +33972 95558 +31637 95548 +22365 95536 +35336 95531 +8825 95523 +22339 95522 +7608 95521 +24947 95515 +14411 95506 +1307 95505 +16989 95486 +18616 95482 +33902 95473 +25409 95465 +29488 95452 +21552 95448 +7474 95436 +32605 95425 +33147 95421 +15304 95409 +39124 95402 +30970 95402 +33859 95401 +21851 95396 +12589 95395 +25507 95358 +24262 95358 +24014 95356 +46366 95351 +4107 95324 +11491 95315 +17747 95299 +22582 95286 +33405 95282 +37066 95272 +38131 95270 +16264 95267 +16649 95265 +25729 95254 +15174 95230 +16509 95221 +23879 95218 +41688 95215 +29658 95204 +8356 95193 +17917 95190 +33352 95171 +31735 95167 +35983 95166 +8812 95147 +12196 95147 +10837 95146 +9873 95136 +20935 95134 +7469 95114 +14751 95109 +21984 95097 +19018 95075 +32714 95065 +29809 95057 +33777 95057 +25376 95057 +32678 95048 +17182 95037 +46281 95032 +39245 95014 +25303 95012 +37487 94994 +42748 94986 +31341 94966 +19923 94954 +33356 94942 +16917 94935 +1704 94933 +20299 94931 +29782 94925 +24066 94922 +20664 94915 +17973 94910 +10516 94908 +19701 94899 +9395 94892 +9346 94887 +36715 94880 +22912 94880 +21318 94874 +10788 94873 +31656 94867 +21223 94849 +34962 94832 +34462 94830 +12233 94826 +13548 94793 +36636 94775 +12202 94762 +26784 94758 +6421 94752 +27731 94750 +34710 94739 +32540 94736 +3057 94727 +11024 94710 +31565 94694 +49281 94689 +19001 94683 +31678 94677 +6545 94676 +35687 94673 +26316 94633 +21134 94630 +34050 94630 +18023 94626 +44572 94623 +44781 94623 +8743 94596 +7807 94590 +5633 94589 +13587 94580 +36978 94574 +23122 94574 +12341 94564 +36002 94562 +18142 94560 +47678 94555 +13018 94537 +27356 94533 +9937 94525 +682 94499 +21640 94495 +16243 94465 +36503 94462 +47660 94450 +33503 94441 +28303 94435 +4749 94429 +32831 94420 +8530 94420 +26487 94418 +18469 94417 +36251 94414 +29125 94408 +14091 94399 +25494 94399 +25455 94377 +14331 94376 +12248 94351 +6750 94335 +18808 94333 +21490 94320 +22733 94314 +11696 94312 +23149 94305 +17241 94299 +22185 94288 +28814 94273 +26502 94273 +14272 94272 +14700 94259 +24768 94253 +13481 94244 +6014 94234 +30279 94231 +29686 94225 +6703 94216 +17306 94216 +3323 94178 +14515 94178 +46820 94167 +3005 94160 +18364 94150 +29662 94130 +29208 94129 +10036 94128 +26253 94128 +28294 94121 +39728 94102 +18480 94091 +27821 94088 +18420 94085 +9855 94077 +41260 94067 +6897 94063 +32951 94062 +10444 94043 +13180 94043 +16619 94037 +26113 94031 +2064 94029 +16308 94028 +37401 94028 +28094 94019 +39125 94017 +27373 94015 +11775 94014 +22378 94008 +16741 94001 +16630 93994 +33984 93982 +22609 93963 +18948 93957 +13282 93949 +44323 93934 +13464 93932 +12354 93930 +14362 93923 +20328 93920 +25234 93919 +33527 93918 +15889 93906 +21021 93906 +43870 93903 +26310 93900 +12488 93900 +11855 93898 +39039 93895 +16374 93866 +26002 93859 +16744 93856 +14856 93839 +14613 93838 +17500 93826 +15323 93817 +21366 93803 +22626 93795 +15887 93795 +31704 93784 +22529 93784 +44317 93779 +40057 93769 +19985 93767 +801 93764 +27839 93746 +25263 93723 +32253 93722 +23905 93721 +13443 93719 +25281 93709 +24623 93701 +36421 93695 +22007 93687 +46306 93686 +32853 93681 +25170 93666 +15209 93656 +24677 93641 +17575 93638 +11331 93636 +1172 93625 +38188 93622 +31099 93611 +40445 93606 +27321 93601 +24230 93597 +13199 93586 +18320 93570 +18025 93568 +28996 93564 +37033 93563 +15784 93561 +21639 93553 +30828 93548 +30618 93537 +43245 93534 +31201 93532 +19024 93527 +30456 93527 +2905 93518 +8007 93500 +20265 93497 +22125 93482 +1733 93482 +39508 93474 +19844 93473 +21127 93472 +43513 93459 +35689 93452 +37907 93450 +1562 93429 +5152 93413 +33519 93375 +12026 93372 +22085 93372 +19493 93369 +6713 93365 +19504 93352 +24683 93347 +27297 93340 +34906 93338 +33458 93338 +24006 93338 +20066 93336 +23689 93335 +30286 93335 +28499 93334 +13716 93325 +17873 93324 +44502 93309 +4370 93305 +31136 93289 +10981 93284 +38881 93278 +18548 93272 +10295 93266 +50048 93265 +24391 93248 +4489 93237 +11248 93237 +17852 93233 +11902 93222 +6919 93198 +42100 93192 +26102 93178 +20680 93163 +46719 93161 +26581 93156 +20054 93155 +26906 93147 +22385 93113 +8525 93108 +23746 93103 +10212 93102 +30839 93100 +23205 93097 +19294 93086 +24918 93085 +32938 93085 +20640 93076 +667 93075 +3004 93074 +36384 93063 +15255 93058 +30600 93056 +18272 93046 +20588 93041 +29483 93036 +2309 93024 +5132 93015 +40318 92991 +8931 92991 +25620 92989 +44075 92987 +8764 92985 +25305 92983 +25277 92980 +14879 92973 +29986 92951 +16876 92946 +44041 92944 +27571 92918 +10740 92916 +7918 92914 +36516 92907 +26548 92906 +27060 92905 +9532 92905 +23095 92897 +37490 92887 +35493 92884 +14686 92881 +34593 92863 +23057 92846 +46917 92840 +20042 92840 +29070 92838 +7633 92830 +12849 92825 +1490 92822 +45303 92813 +25860 92800 +36832 92793 +26916 92791 +22019 92786 +35591 92785 +31065 92776 +3927 92775 +41164 92760 +10459 92752 +23477 92737 +26057 92730 +29210 92720 +10973 92712 +5232 92711 +24359 92705 +16766 92705 +36812 92702 +17347 92685 +32413 92675 +19201 92674 +11887 92664 +35017 92664 +28646 92661 +10418 92641 +49762 92640 +27197 92636 +19882 92616 +23453 92613 +48607 92600 +19175 92599 +26727 92597 +5102 92590 +25629 92577 +252 92571 +5028 92570 +19845 92565 +6436 92559 +36611 92554 +40021 92550 +23968 92549 +13909 92544 +25339 92539 +11980 92536 +13227 92534 +28170 92528 +26645 92527 +42499 92522 +18043 92508 +16729 92503 +12106 92502 +22299 92483 +25937 92475 +31233 92465 +15568 92444 +17090 92443 +21051 92440 +28591 92440 +6171 92411 +26655 92397 +24584 92386 +14314 92384 +19297 92377 +12896 92376 +24433 92374 +36771 92372 +12862 92368 +21452 92367 +46459 92358 +30870 92352 +7352 92337 +7061 92328 +24325 92322 +22188 92321 +38838 92316 +16446 92309 +23557 92299 +18643 92298 +10916 92283 +35078 92260 +7322 92256 +27822 92251 +24656 92247 +18463 92237 +39661 92227 +9064 92217 +20278 92214 +9496 92212 +34881 92210 +23074 92204 +25449 92191 +19883 92186 +24219 92184 +12394 92182 +3652 92170 +6683 92164 +42630 92161 +22574 92161 +26610 92156 +22106 92156 +18059 92142 +29654 92139 +22206 92133 +30325 92133 +25317 92121 +39309 92115 +10527 92106 +28393 92100 +23056 92099 +42150 92097 +21216 92095 +26800 92087 +17150 92081 +38478 92078 +20399 92072 +8048 92063 +27138 92063 +33892 92057 +7642 92046 +43326 92046 +14573 92043 +29786 92038 +11280 92028 +27662 92026 +35646 92025 +19102 92023 +7928 92018 +41345 92013 +19440 91973 +1093 91965 +7836 91956 +34405 91939 +23239 91929 +35497 91928 +6424 91916 +23217 91909 +19838 91909 +42350 91901 +26334 91895 +35816 91894 +20269 91892 +30718 91879 +37969 91869 +27397 91860 +34077 91858 +14151 91858 +9501 91855 +22423 91839 +11519 91834 +30462 91831 +14068 91822 +24402 91813 +10865 91811 +40132 91800 +48858 91799 +18221 91797 +12417 91795 +19862 91786 +46381 91781 +46260 91774 +6456 91765 +33318 91757 +25116 91754 +5200 91737 +21294 91735 +36904 91733 +20067 91721 +16288 91712 +16170 91709 +36574 91700 +30678 91699 +30437 91688 +20326 91683 +21814 91672 +45963 91662 +32659 91636 +41845 91629 +26938 91628 +20383 91621 +27957 91620 +28662 91619 +32979 91615 +30570 91607 +32002 91591 +26565 91588 +9827 91567 +34915 91566 +30012 91562 +34686 91552 +23084 91543 +17555 91541 +45229 91527 +34696 91525 +21256 91522 +4682 91516 +39303 91511 +34422 91500 +13958 91496 +22219 91493 +46422 91471 +32526 91470 +47775 91463 +6040 91460 +17909 91457 +13216 91449 +12796 91444 +27907 91443 +25173 91430 +42286 91423 +20693 91419 +16866 91415 +22765 91411 +11498 91403 +8677 91396 +8394 91383 +22730 91375 +18783 91374 +40474 91368 +29753 91348 +22889 91344 +24337 91343 +41525 91340 +22949 91334 +31890 91331 +23699 91322 +25971 91308 +26777 91308 +11291 91307 +7368 91305 +10798 91299 +18478 91272 +16641 91269 +12609 91244 +28983 91230 +15824 91227 +12562 91224 +12060 91223 +16369 91222 +23353 91220 +28411 91218 +21661 91211 +24569 91210 +20009 91210 +45371 91202 +25861 91202 +34474 91200 +25984 91189 +21879 91170 +10910 91168 +13834 91159 +19343 91156 +36588 91150 +20037 91146 +33749 91143 +22625 91131 +2509 91128 +34732 91098 +30880 91097 +25725 91070 +14821 91063 +19547 91062 +21674 91042 +31158 91034 +10028 91033 +30043 91027 +14426 91025 +17219 91024 +30046 91023 +25403 91020 +32342 91016 +39265 91015 +43664 91003 +27840 91001 +29359 90985 +19387 90978 +10505 90960 +21621 90959 +33242 90945 +13946 90944 +21915 90942 +24635 90941 +16132 90938 +9702 90936 +29489 90927 +3468 90926 +21649 90913 +20958 90900 +25923 90899 +15992 90897 +35633 90887 +6726 90881 +21971 90869 +29628 90833 +14731 90827 +44025 90826 +26695 90806 +20460 90802 +42185 90800 +35165 90794 +46561 90793 +20744 90788 +29475 90778 +8375 90769 +20905 90760 +11224 90757 +14805 90754 +20445 90749 +23401 90746 +25355 90745 +25154 90744 +11163 90741 +27523 90734 +37387 90731 +40412 90730 +3534 90717 +41346 90716 +25349 90716 +23348 90716 +20060 90705 +6571 90703 +31367 90700 +30926 90696 +24950 90694 +24346 90689 +24489 90677 +36029 90667 +12025 90667 +13058 90666 +9191 90664 +34051 90653 +16809 90649 +19322 90646 +21392 90646 +14701 90631 +17851 90631 +40644 90629 +11146 90629 +32632 90625 +12001 90620 +14874 90605 +47966 90604 +26593 90566 +24484 90565 +40288 90564 +21682 90555 +35671 90544 +39927 90542 +13569 90541 +32832 90540 +28661 90540 +6818 90494 +14843 90492 +28157 90474 +46832 90471 +22776 90466 +11814 90459 +34676 90459 +27325 90455 +35564 90433 +36985 90432 +19446 90431 +17246 90424 +14005 90400 +22332 90391 +12867 90389 +15919 90389 +28534 90385 +3054 90384 +27123 90380 +6179 90369 +15027 90348 +37874 90337 +17512 90325 +19221 90317 +26187 90309 +42284 90307 +12050 90272 +29741 90260 +13992 90260 +44340 90258 +9123 90249 +31429 90243 +9094 90233 +6351 90232 +23167 90231 +31355 90228 +21486 90212 +7659 90210 +21438 90195 +38428 90192 +30231 90185 +35874 90179 +42873 90167 +23403 90166 +19704 90164 +29570 90155 +4808 90144 +28464 90134 +30307 90129 +16603 90115 +29060 90084 +38774 90082 +7230 90081 +27075 90071 +36467 90067 +21429 90066 +20128 90058 +29459 90052 +12782 90047 +30153 90043 +25930 90039 +17738 90032 +27449 90015 +22054 90013 +21611 90009 +30305 90007 +28088 90001 +24497 89973 +18485 89969 +10080 89960 +20618 89956 +15197 89950 +33286 89941 +13083 89940 +15492 89935 +6237 89910 +99 89908 +25331 89905 +27521 89900 +30700 89889 +21094 89876 +30706 89862 +32486 89832 +34584 89809 +24903 89790 +19528 89789 +11912 89787 +24375 89784 +17102 89776 +44452 89773 +19503 89772 +41900 89768 +35896 89762 +16900 89760 +18972 89751 +42052 89745 +1887 89743 +26924 89735 +19185 89734 +20795 89727 +6024 89723 +18952 89721 +43791 89710 +34766 89704 +34138 89697 +38018 89666 +37619 89649 +10235 89647 +33072 89646 +27529 89644 +4464 89642 +28558 89637 +34017 89631 +16405 89630 +17672 89628 +37123 89621 +35047 89619 +29362 89618 +34895 89610 +32982 89591 +14562 89589 +28488 89587 +22756 89582 +37584 89569 +18959 89566 +24599 89549 +29118 89544 +42208 89537 +11567 89483 +28984 89465 +31231 89449 +22129 89445 +39739 89445 +26740 89444 +24303 89429 +36025 89413 +6442 89413 +20038 89409 +42682 89400 +25794 89392 +25056 89364 +19813 89364 +10316 89363 +22020 89356 +26762 89352 +19893 89352 +23503 89344 +11489 89341 +26296 89337 +1217 89335 +19762 89326 +18596 89322 +26387 89322 +26871 89320 +4500 89317 +10977 89305 +40378 89302 +14507 89298 +27259 89297 +9347 89282 +37690 89276 +37090 89264 +27602 89254 +20435 89238 +9744 89232 +33190 89219 +18814 89214 +33886 89204 +18529 89202 +17047 89198 +15176 89195 +15354 89191 +20050 89188 +22554 89182 +20767 89175 +36633 89171 +25107 89167 +28823 89141 +19555 89120 +12599 89115 +37217 89112 +22331 89107 +20687 89097 +36069 89093 +34601 89090 +15735 89076 +20950 89069 +43174 89068 +12130 89067 +31402 89064 +20982 89060 +34281 89046 +44467 89038 +16772 89035 +35141 89033 +14062 89029 +28176 89026 +16186 89018 +13269 89016 +41826 89014 +30883 89010 +23987 89009 +36429 88992 +16439 88987 +10211 88981 +27508 88970 +37940 88969 +28999 88958 +26772 88951 +29816 88945 +38617 88939 +26311 88925 +20923 88924 +39113 88915 +41782 88906 +17669 88900 +24632 88869 +23221 88864 +32414 88862 +27015 88857 +9760 88848 +17000 88841 +28224 88835 +26527 88835 +31920 88827 +8051 88783 +37519 88779 +15180 88745 +26930 88742 +12543 88731 +29383 88705 +26553 88695 +33014 88691 +48812 88689 +19962 88667 +41904 88658 +40974 88658 +27980 88656 +41703 88655 +1179 88655 +48822 88632 +23027 88622 +41005 88616 +10137 88611 +36971 88610 +39045 88607 +43126 88606 +20625 88601 +35692 88599 +13248 88586 +49003 88585 +30848 88577 +38317 88556 +20339 88552 +17682 88545 +31683 88530 +18586 88516 +25407 88513 +36590 88511 +20673 88510 +13217 88506 +24374 88506 +23749 88504 +15212 88500 +17284 88500 +20313 88499 +32241 88490 +17221 88486 +13809 88465 +19434 88465 +38522 88456 +32438 88443 +21431 88423 +31213 88420 +32174 88415 +24685 88383 +15355 88376 +18581 88355 +13380 88347 +12391 88343 +23934 88340 +23714 88328 +16221 88324 +10521 88319 +27624 88319 +28803 88308 +41905 88301 +12204 88288 +25588 88280 +15056 88278 +30722 88274 +21787 88272 +29043 88266 +22987 88259 +49183 88255 +13617 88253 +26816 88252 +7070 88251 +21334 88247 +18628 88212 +3133 88198 +24949 88197 +21082 88190 +4582 88188 +38758 88184 +19585 88179 +44535 88175 +35982 88163 +17480 88160 +20145 88159 +36245 88154 +15165 88151 +115 88146 +2016 88119 +34317 88106 +19186 88084 +7755 88080 +16859 88067 +18631 88056 +15420 88053 +2369 88051 +32601 88050 +27095 88048 +22837 88047 +17707 88046 +26149 88041 +30920 88040 +16064 88036 +9459 88029 +37332 88028 +18992 88026 +10379 88024 +17509 88021 +11203 88021 +16957 88014 +18285 88002 +27146 87994 +32176 87987 +23050 87981 +15801 87967 +39540 87967 +13652 87966 +25208 87947 +42605 87943 +33613 87937 +48955 87926 +11933 87924 +33375 87916 +29505 87903 +31893 87902 +27341 87889 +13848 87889 +16513 87886 +21546 87885 +22486 87883 +26898 87878 +34380 87877 +42065 87875 +28336 87874 +34136 87870 +36718 87867 +22875 87867 +23083 87850 +40766 87848 +23332 87846 +28180 87823 +19020 87823 +37685 87821 +21387 87810 +41137 87797 +20088 87795 +28431 87790 +46287 87790 +19710 87785 +4125 87779 +14356 87778 +3600 87767 +48125 87766 +17650 87762 +28775 87741 +33945 87736 +26973 87730 +30441 87726 +41578 87725 +12461 87723 +25359 87712 +45961 87709 +31618 87691 +44303 87688 +23456 87686 +9538 87672 +40782 87672 +9630 87667 +16790 87642 +14309 87637 +25290 87637 +4072 87629 +26944 87622 +18063 87615 +17299 87603 +21131 87601 +25891 87597 +49657 87597 +34916 87591 +14642 87588 +25845 87571 +38330 87569 +40833 87560 +20137 87551 +15906 87546 +22459 87541 +44824 87541 +45034 87527 +22513 87527 +6676 87523 +35917 87515 +29727 87509 +32099 87508 +5352 87502 +20439 87483 +17059 87474 +22350 87468 +39727 87467 +33742 87456 +29832 87455 +25168 87454 +24160 87451 +32919 87428 +20391 87422 +4029 87420 +23386 87417 +35062 87416 +27699 87413 +15601 87411 +11922 87411 +20466 87406 +14025 87405 +19072 87404 +30784 87397 +1113 87395 +19686 87389 +26671 87386 +8455 87381 +38442 87381 +36443 87363 +20667 87362 +19407 87355 +13483 87353 +41742 87350 +116 87319 +30174 87314 +29195 87309 +40214 87303 +7065 87302 +37756 87299 +27144 87283 +13251 87280 +32733 87276 +20080 87269 +12915 87263 +19979 87254 +25571 87253 +40735 87247 +5216 87243 +30925 87241 +23972 87238 +11979 87218 +24092 87199 +22570 87199 +32552 87193 +42644 87190 +29775 87186 +21929 87183 +33218 87179 +24749 87172 +19098 87166 +21156 87163 +21784 87162 +13277 87156 +23996 87153 +19766 87145 +21226 87139 +28160 87137 +31926 87128 +19907 87119 +30512 87116 +45446 87114 +4629 87109 +23427 87108 +18637 87107 +19878 87105 +8736 87087 +46552 87080 +16345 87068 +25351 87060 +4355 87050 +23505 87043 +41182 87032 +4124 87020 +22338 87016 +19812 87009 +21115 87005 +48855 87005 +31273 87005 +23422 87003 +19390 86988 +27768 86982 +21698 86976 +23116 86962 +20007 86959 +25566 86954 +21385 86952 +19536 86949 +8792 86943 +17968 86920 +8174 86919 +38536 86905 +6063 86901 +20703 86898 +36810 86894 +28126 86890 +16789 86885 +21853 86881 +30188 86871 +39651 86864 +33521 86862 +18182 86794 +10486 86793 +14454 86792 +44311 86779 +22363 86773 +21367 86765 +6944 86763 +6352 86755 +7155 86746 +40902 86745 +22000 86734 +33659 86734 +26157 86731 +17216 86730 +39734 86729 +18620 86726 +25273 86720 +5596 86708 +11743 86698 +29023 86698 +7059 86696 +41078 86692 +47249 86684 +21732 86675 +34899 86673 +28020 86666 +14319 86663 +38403 86650 +40208 86648 +34767 86648 +15974 86641 +16250 86637 +34662 86634 +47089 86629 +38928 86617 +30941 86595 +3374 86590 +21178 86585 +17546 86574 +11074 86569 +22287 86567 +35979 86561 +5681 86552 +9200 86549 +34914 86544 +20256 86537 +20149 86534 +20064 86533 +19506 86528 +38433 86524 +18437 86523 +31239 86522 +17710 86521 +6587 86521 +22034 86519 +35105 86513 +20411 86510 +29025 86498 +10517 86485 +20479 86485 +46950 86480 +14453 86465 +24381 86458 +12913 86443 +16285 86440 +43248 86430 +16810 86427 +31863 86426 +27307 86426 +37956 86416 +19863 86405 +31742 86403 +24211 86401 +19733 86398 +33164 86396 +21854 86393 +11267 86390 +18102 86389 +29413 86385 +24621 86382 +42700 86378 +14848 86378 +2287 86373 +12466 86365 +22999 86360 +23665 86352 +22254 86342 +6039 86338 +50158 86337 +35805 86333 +35593 86330 +21882 86328 +42168 86324 +24406 86311 +15688 86305 +16227 86302 +40669 86301 +9700 86300 +29317 86295 +40233 86280 +31865 86275 +10466 86256 +17200 86255 +19607 86252 +14513 86248 +24659 86243 +19861 86240 +6658 86221 +48297 86217 +3532 86216 +14981 86192 +18710 86180 +24775 86178 +32456 86177 +15111 86175 +35680 86154 +39995 86152 +4565 86145 +30006 86119 +19342 86114 +22010 86111 +47594 86102 +18634 86096 +46187 86094 +33337 86078 +41145 86076 +23171 86067 +23992 86054 +32405 86043 +23978 86038 +23152 86035 +42602 86035 +13991 86026 +13360 86023 +44481 86020 +43586 85995 +30985 85990 +21779 85988 +36647 85984 +32145 85984 +19091 85979 +20723 85970 +10819 85966 +23173 85955 +25124 85952 +12423 85949 +18851 85940 +33664 85931 +16583 85923 +20063 85918 +15029 85918 +41839 85915 +41960 85914 +24998 85901 +17697 85901 +27355 85892 +6313 85891 +44749 85880 +17232 85876 +33514 85867 +16453 85860 +10407 85858 +14350 85856 +22849 85835 +38665 85818 +27973 85810 +28077 85807 +19341 85804 +34682 85799 +44170 85798 +20592 85797 +21079 85791 +47538 85790 +48848 85782 +24404 85771 +37003 85769 +12363 85756 +49315 85752 +32619 85743 +11201 85714 +37006 85709 +6794 85702 +19698 85702 +21391 85696 +39282 85682 +32175 85666 +21375 85666 +13152 85656 +24435 85645 +27618 85634 +17065 85633 +18659 85631 +26374 85628 +20514 85605 +20823 85599 +23077 85598 +27213 85593 +22289 85585 +44359 85571 +25909 85565 +24187 85554 +16638 85537 +1713 85534 +19409 85527 +30496 85519 +24352 85508 +26428 85501 +13259 85501 +17157 85501 +33814 85500 +40777 85492 +21214 85486 +17520 85481 +32716 85466 +22139 85463 +47574 85451 +1300 85447 +22072 85440 +12753 85438 +20584 85429 +43784 85427 +31225 85421 +13920 85414 +26312 85404 +17242 85403 +11438 85403 +14936 85397 +23202 85390 +46185 85375 +33590 85372 +15711 85369 +34041 85365 +33579 85355 +16102 85354 +17545 85354 +42766 85336 +29679 85326 +10223 85325 +38552 85319 +20558 85307 +17395 85297 +39086 85295 +44298 85291 +2360 85279 +42086 85229 +38343 85228 +29949 85222 +32961 85219 +29445 85218 +15587 85208 +19208 85208 +28213 85206 +28099 85203 +41505 85202 +24205 85202 +43596 85194 +15780 85194 +17438 85184 +20416 85168 +13631 85165 +27437 85162 +35663 85144 +39017 85136 +22714 85100 +36976 85098 +18013 85096 +36591 85091 +28438 85079 +24097 85067 +35386 85055 +7877 85048 +31483 85027 +24451 85024 +43002 85016 +23701 85016 +33347 84993 +41200 84983 +18927 84979 +20734 84970 +22959 84955 +18689 84945 +18723 84939 +21822 84921 +31840 84912 +26262 84907 +34233 84900 +38118 84899 +34118 84893 +4954 84883 +30845 84882 +28049 84881 +25044 84875 +36646 84852 +28943 84843 +42502 84843 +15410 84842 +31088 84829 +10475 84828 +26472 84822 +22546 84798 +25243 84792 +20428 84780 +41438 84769 +20089 84735 +20708 84727 +36229 84724 +47430 84724 +28595 84720 +32280 84715 +49220 84709 +10885 84706 +23757 84702 +6169 84700 +41406 84691 +19078 84686 +24694 84679 +26378 84668 +24636 84664 +45265 84637 +2517 84635 +32314 84617 +16635 84612 +41695 84611 +22562 84610 +19856 84609 +18440 84601 +11222 84597 +14529 84591 +20770 84589 +32260 84583 +20132 84581 +42037 84578 +16189 84555 +27876 84552 +20122 84548 +35181 84541 +44113 84540 +19921 84539 +24751 84537 +13144 84535 +23373 84533 +27304 84530 +19565 84526 +8040 84520 +29324 84519 +48880 84511 +35397 84505 +34545 84501 +15611 84497 +38701 84493 +20396 84487 +5029 84481 +14866 84476 +35766 84462 +38623 84462 +16086 84456 +25569 84448 +42649 84440 +33195 84424 +10104 84420 +13713 84404 +24795 84401 +35034 84400 +39503 84396 +32022 84377 +14705 84368 +40993 84365 +19361 84360 +23436 84357 +14584 84352 +25027 84340 +49722 84326 +31067 84323 +40679 84318 +24592 84293 +30263 84286 +33881 84282 +29612 84277 +31812 84264 +26643 84257 +2600 84257 +759 84240 +36418 84236 +13949 84232 +26889 84227 +22712 84221 +15982 84216 +23399 84215 +114 84202 +10734 84196 +43575 84156 +24273 84156 +16812 84155 +31853 84150 +19908 84144 +23799 84141 +19419 84118 +31252 84118 +17598 84115 +35727 84094 +45577 84092 +29144 84089 +40626 84080 +16564 84076 +2204 84075 +32116 84069 +8444 84067 +20559 84066 +5651 84061 +23860 84058 +28064 84049 +28584 84041 +27647 84029 +14557 84024 +16104 84020 +39617 84009 +24167 83997 +3193 83990 +47995 83975 +18606 83975 +11718 83972 +37919 83962 +23218 83959 +42823 83952 +29395 83950 +21128 83946 +17892 83945 +12335 83944 +35329 83941 +45093 83930 +25711 83925 +34113 83915 +16498 83910 +9278 83906 +3093 83901 +24276 83874 +25430 83867 +32924 83857 +17519 83857 +31133 83847 +16082 83843 +34235 83842 +22430 83805 +26403 83802 +17513 83793 +22451 83789 +35464 83787 +37492 83774 +35242 83765 +46335 83757 +27645 83757 +13681 83746 +29314 83746 +28890 83724 +27810 83719 +28486 83717 +35673 83715 +4078 83714 +29777 83710 +41721 83708 +27322 83705 +35338 83703 +36694 83698 +30029 83690 +30090 83688 +39830 83687 +44145 83684 +38115 83678 +7158 83677 +23985 83676 +5634 83673 +7282 83661 +27940 83657 +35670 83649 +40599 83648 +8298 83623 +34005 83610 +20130 83610 +42525 83606 +28454 83553 +43192 83552 +44603 83550 +28910 83539 +20648 83524 +18876 83523 +26356 83521 +12146 83507 +27671 83493 +49484 83488 +8089 83484 +14514 83480 +26720 83479 +30750 83476 +45814 83473 +47989 83463 +21043 83449 +42178 83443 +18388 83431 +4741 83420 +29502 83417 +26925 83403 +18964 83394 +26140 83383 +13158 83378 +39278 83375 +47534 83374 +21415 83366 +18261 83361 +26131 83360 +17048 83359 +24655 83357 +27335 83356 +23851 83353 +13585 83348 +28136 83345 +26083 83343 +21601 83343 +19621 83339 +44024 83333 +1572 83327 +7814 83325 +27251 83321 +34852 83305 +22904 83303 +21715 83295 +18669 83293 +30927 83293 +3441 83288 +24401 83274 +25635 83268 +12349 83254 +17583 83254 +21804 83252 +21726 83251 +23734 83237 +10854 83231 +39751 83228 +19541 83222 +18290 83213 +29104 83211 +43761 83209 +25406 83202 +32189 83184 +23271 83184 +43772 83146 +19499 83145 +4147 83143 +32557 83142 +7140 83136 +8291 83130 +45646 83127 +21182 83112 +25246 83099 +27069 83097 +27170 83096 +21752 83090 +8656 83090 +32620 83075 +8827 83071 +9636 83067 +18227 83050 +23000 83046 +46508 83043 +37242 83042 +16794 83011 +36385 83008 +12881 83001 +32889 82994 +37529 82991 +13014 82987 +17211 82985 +18018 82981 +4677 82980 +9650 82977 +5683 82975 +34927 82961 +25300 82960 +27141 82953 +10019 82944 +49001 82942 +8843 82933 +7371 82932 +8321 82922 +15802 82912 +28300 82907 +18506 82899 +11630 82889 +23648 82887 +37427 82882 +20610 82882 +32365 82876 +9624 82853 +46518 82849 +15473 82831 +11351 82821 +35819 82808 +13469 82804 +42379 82793 +30595 82792 +27347 82787 +16628 82779 +39542 82771 +23485 82756 +28405 82747 +39634 82742 +39151 82740 +3509 82734 +25727 82733 +22665 82730 +15950 82729 +6214 82724 +41835 82718 +8896 82715 +37866 82710 +9999 82701 +25329 82696 +11316 82687 +6192 82680 +25567 82674 +11241 82673 +19601 82670 +18346 82669 +2186 82665 +13740 82653 +20951 82649 +1469 82635 +32267 82625 +27103 82610 +35806 82602 +25023 82588 +30198 82585 +3906 82560 +17202 82555 +13719 82553 +40209 82550 +19408 82538 +20385 82535 +21514 82521 +12254 82513 +44291 82500 +28536 82492 +17082 82488 +9275 82469 +17421 82467 +3075 82450 +45518 82444 +29669 82442 +34968 82425 +33909 82424 +23690 82423 +20227 82418 +21036 82416 +7574 82416 +3253 82415 +15237 82415 +11034 82411 +25764 82394 +15034 82390 +24282 82387 +36546 82373 +35160 82370 +23710 82362 +18598 82356 +47297 82355 +48685 82349 +15353 82346 +20862 82346 +13219 82345 +22426 82344 +27067 82335 +11166 82333 +10585 82314 +27884 82313 +19162 82312 +28804 82309 +29256 82305 +12972 82300 +8802 82297 +33306 82287 +33404 82285 +23390 82282 +24619 82276 +24302 82269 +15539 82264 +29661 82247 +30701 82247 +47618 82247 +21078 82241 +24408 82240 +23677 82232 +20850 82229 +15447 82226 +19472 82220 +14413 82219 +20309 82196 +46879 82190 +41463 82189 +16143 82184 +16196 82183 +30972 82180 +1993 82173 +31440 82162 +41668 82157 +34238 82149 +10561 82128 +43412 82123 +15636 82117 +28146 82117 +11125 82115 +34015 82104 +15831 82104 +23432 82102 +42730 82088 +30047 82085 +23929 82079 +16586 82073 +18660 82067 +18759 82066 +41459 82064 +15292 82051 +18830 82046 +25046 82045 +7233 82042 +38990 82038 +13582 82032 +9226 81980 +21247 81977 +27376 81961 +25227 81957 +42342 81947 +24902 81940 +32887 81940 +36143 81930 +15219 81922 +919 81920 +24566 81914 +20870 81910 +20140 81909 +29586 81901 +22216 81900 +45103 81893 +19486 81878 +21983 81874 +32289 81870 +30809 81868 +37053 81866 +19399 81850 +15983 81845 +22563 81842 +23572 81842 +8139 81836 +9128 81835 +46397 81830 +20293 81801 +19586 81783 +23007 81782 +29961 81764 +43287 81756 +27929 81752 +29543 81746 +23575 81736 +13022 81724 +21761 81723 +13655 81719 +11045 81715 +12142 81710 +42429 81706 +23616 81703 +29103 81702 +7789 81700 +14146 81693 +32660 81672 +30037 81671 +29742 81662 +20121 81661 +19370 81638 +26706 81626 +14588 81618 +30319 81618 +50041 81613 +29707 81611 +19190 81607 +40751 81605 +47189 81603 +28318 81591 +23715 81585 +27638 81584 +33837 81583 +17201 81577 +23038 81572 +31787 81556 +16122 81552 +50083 81547 +29337 81542 +40365 81531 +35271 81528 +45202 81525 +20232 81502 +47630 81502 +18810 81484 +19643 81480 +23091 81478 +5444 81477 +20697 81477 +25126 81475 +22144 81474 +769 81474 +28269 81463 +39043 81461 +20887 81459 +23161 81458 +23026 81451 +39926 81451 +15049 81444 +23501 81440 +40650 81435 +25524 81408 +1646 81400 +15918 81400 +38455 81393 +8367 81384 +10993 81384 +32899 81381 +50133 81375 +3473 81360 +24345 81358 +27893 81353 +12760 81344 +15646 81342 +23670 81337 +14511 81326 +15940 81319 +19755 81319 +10887 81318 +28175 81314 +14439 81312 +30572 81306 +42576 81303 +39534 81290 +12770 81290 +14326 81277 +25087 81271 +13552 81268 +16060 81259 +22092 81247 +35002 81244 +24423 81243 +38180 81235 +29594 81225 +20992 81224 +26320 81221 +21140 81215 +44786 81212 +36882 81212 +26162 81179 +32675 81171 +1515 81170 +30527 81169 +28310 81165 +19397 81164 +33143 81161 +22760 81159 +21773 81149 +22517 81149 +35893 81147 +24103 81137 +34590 81135 +27070 81133 +20582 81129 +28577 81123 +24956 81121 +25314 81114 +36746 81114 +20721 81106 +24930 81104 +18537 81102 +5063 81101 +26022 81100 +49396 81097 +30404 81074 +33728 81070 +3654 81068 +24115 81059 +41434 81057 +34520 81057 +17002 81054 +30666 81041 +31569 81037 +40130 81037 +21586 81032 +43682 81030 +29479 81029 +35603 81026 +25767 81025 +8984 80993 +4754 80989 +19594 80983 +20332 80979 +29702 80975 +23841 80974 +20003 80974 +20033 80972 +25692 80968 +35839 80965 +21289 80960 +7656 80949 +15060 80949 +6094 80930 +37544 80927 +37709 80924 +31451 80915 +25133 80906 +41401 80905 +16129 80903 +7999 80886 +41281 80883 +34086 80870 +39342 80864 +42257 80859 +40263 80859 +44365 80857 +23597 80856 +32720 80854 +21125 80848 +15269 80847 +24862 80845 +26174 80844 +37386 80843 +13175 80826 +21670 80822 +21137 80808 +17926 80808 +36867 80796 +16616 80794 +29379 80791 +30882 80789 +22408 80788 +16329 80788 +22998 80773 +20842 80757 +35877 80753 +22952 80752 +21073 80739 +30400 80735 +40775 80731 +40167 80729 +18405 80727 +17194 80723 +22296 80716 +28016 80706 +25708 80704 +9862 80691 +24523 80691 +9913 80690 +36085 80687 +23333 80685 +29843 80679 +45406 80664 +25664 80645 +18714 80643 +22612 80629 +20973 80628 +18181 80627 +46434 80609 +32153 80608 +30340 80606 +26681 80604 +14415 80598 +25011 80590 +19392 80588 +21293 80583 +24985 80568 +6360 80567 +16022 80562 +24162 80548 +32474 80544 +25073 80536 +34595 80528 +13605 80518 +17660 80516 +25495 80514 +31394 80512 +38572 80512 +29989 80509 +1999 80508 +31723 80501 +25680 80491 +12061 80482 +36831 80480 +21032 80478 +13421 80478 +22393 80463 +23371 80452 +31488 80447 +31164 80442 +26541 80433 +38717 80417 +48823 80416 +44008 80409 +7126 80385 +19981 80378 +24969 80373 +35270 80368 +31530 80362 +48114 80360 +20864 80352 +31867 80351 +30525 80350 +28856 80349 +40592 80346 +33990 80345 +31839 80344 +7833 80334 +47299 80329 +22120 80328 +31241 80322 +45788 80321 +6985 80318 +39261 80308 +21510 80308 +15770 80292 +18788 80285 +30370 80275 +48514 80274 +25827 80268 +24594 80258 +17376 80257 +20224 80253 +10888 80252 +23238 80248 +10163 80244 +17526 80238 +20374 80237 +27386 80229 +24801 80218 +2053 80217 +13915 80213 +26989 80212 +34133 80200 +20586 80200 +38672 80194 +25451 80193 +15671 80185 +23999 80169 +40886 80166 +15565 80166 +5082 80162 +30900 80156 +19769 80150 +19139 80150 +11951 80147 +21885 80143 +23844 80137 +6238 80121 +43083 80114 +30759 80114 +34443 80100 +21268 80099 +38847 80098 +21857 80073 +29900 80068 +10057 80068 +13632 80050 +19799 80048 +2132 80045 +37503 80041 +21824 80040 +25939 80038 +13987 80032 +8484 80023 +45208 80014 +21986 80012 +20678 80012 +11165 79976 +41774 79971 +44126 79970 +38388 79969 +4794 79968 +22726 79963 +8738 79960 +31868 79955 +26734 79954 +20284 79940 +19333 79939 +35618 79934 +28847 79927 +22014 79925 +21622 79923 +29423 79921 +36502 79919 +23974 79918 +29860 79915 +33173 79909 +27220 79907 +29399 79906 +35248 79906 +31314 79894 +10551 79889 +48471 79877 +16652 79863 +48053 79863 +40013 79862 +14625 79857 +21977 79829 +19581 79823 +19061 79817 +21994 79817 +32548 79813 +14003 79811 +38289 79810 +43109 79805 +41147 79756 +14508 79749 +38427 79744 +24703 79729 +19824 79727 +37321 79714 +36975 79713 +26900 79689 +33011 79682 +2527 79680 +32711 79679 +28921 79671 +35457 79666 +26441 79656 +20892 79652 +42124 79649 +47463 79637 +22782 79635 +14842 79622 +33978 79614 +32354 79610 +15883 79607 +16898 79604 +8041 79602 +17106 79601 +20484 79600 +20376 79597 +38562 79592 +21443 79587 +11260 79577 +22652 79575 +32862 79568 +41828 79563 +33126 79558 +25766 79548 +34861 79544 +14432 79544 +25420 79542 +22258 79540 +31796 79537 +22956 79516 +21534 79497 +17987 79492 +34101 79489 +17129 79481 +26020 79469 +18129 79463 +20956 79450 +30794 79439 +1463 79429 +21843 79428 +45868 79418 +2794 79412 +23965 79408 +43323 79407 +13416 79407 +35695 79396 +24270 79394 +5736 79389 +23510 79380 +23744 79372 +29169 79356 +21982 79353 +38245 79352 +45411 79323 +15715 79321 +25893 79316 +11691 79313 +27366 79309 +37259 79303 +24340 79295 +45753 79292 +29396 79292 +28121 79292 +5722 79290 +20717 79278 +39847 79265 +31537 79264 +8152 79251 +22525 79235 +32363 79232 +29827 79230 +2958 79227 +29948 79223 +21148 79222 +30254 79214 +18333 79210 +17335 79206 +38957 79204 +18495 79200 +24563 79199 +23738 79198 +28615 79192 +35530 79192 +43463 79184 +35568 79179 +18360 79168 +31701 79156 +43017 79141 +43676 79130 +34760 79122 +26602 79116 +21834 79101 +18516 79095 +42148 79070 +14354 79062 +14969 79059 +26532 79054 +38911 79053 +21751 79048 +26680 79048 +20006 79046 +50040 79033 +31462 79033 +18564 79029 +43443 79028 +23137 79022 +9908 79020 +20508 79019 +39314 79019 +30356 79017 +27690 79010 +18465 78997 +27902 78989 +27716 78971 +11059 78971 +13871 78948 +48067 78943 +28320 78927 +11518 78916 +26672 78914 +49652 78904 +15738 78895 +20187 78894 +20811 78893 +13448 78892 +43531 78889 +35506 78886 +25072 78882 +6415 78879 +25687 78877 +28716 78870 +5864 78861 +43050 78855 +7976 78850 +23797 78837 +38732 78837 +44047 78835 +5309 78835 +45178 78834 +4510 78827 +44765 78811 +12193 78808 +43512 78806 +22992 78806 +45932 78801 +33860 78799 +15954 78779 +31251 78772 +20555 78770 +47661 78770 +4214 78769 +15774 78769 +12490 78767 +29520 78767 +35289 78758 +48976 78756 +26297 78753 +30885 78744 +21603 78739 +15834 78738 +20114 78736 +10262 78730 +24738 78719 +16376 78717 +34334 78706 +19514 78701 +23540 78695 +10557 78689 +21339 78686 +31143 78680 +3413 78673 +28201 78672 +20585 78672 +2830 78670 +15088 78661 +12993 78660 +16173 78652 +22839 78637 +10473 78636 +36562 78634 +35304 78618 +41999 78610 +26579 78595 +11225 78591 +21939 78585 +38660 78578 +34265 78575 +19070 78573 +30861 78564 +43090 78563 +24496 78562 +19115 78561 +1329 78558 +27538 78547 +8543 78546 +44185 78543 +31896 78543 +10049 78542 +40434 78536 +23302 78532 +20900 78532 +23528 78532 +34481 78531 +36239 78519 +32791 78518 +32687 78515 +9897 78500 +36634 78497 +42103 78487 +33436 78484 +45667 78482 +18561 78480 +26719 78479 +43450 78473 +31258 78462 +20690 78450 +17067 78447 +27930 78444 +29102 78442 +34798 78441 +10562 78431 +20302 78424 +24486 78417 +35829 78416 +47819 78411 +12900 78406 +31176 78396 +16758 78394 +18775 78388 +24353 78386 +35390 78385 +29685 78385 +22661 78381 +38338 78375 +37704 78362 +36520 78332 +9485 78326 +28215 78324 +20681 78323 +16563 78316 +21502 78314 +43991 78311 +17463 78301 +24699 78298 +18931 78293 +11744 78286 +31028 78286 +20394 78279 +27055 78278 +21629 78275 +37932 78270 +17359 78259 +29780 78254 +19257 78246 +15871 78245 +42225 78242 +29354 78232 +17798 78232 +25343 78231 +7809 78230 +30976 78228 +41363 78228 +31145 78217 +24020 78217 +16590 78196 +12138 78196 +37575 78195 +27185 78177 +19127 78171 +28706 78158 +31038 78127 +19262 78125 +7117 78118 +46620 78116 +40176 78116 +19916 78108 +20901 78106 +24101 78101 +23518 78086 +47857 78085 +12595 78083 +31293 78076 +37979 78074 +30658 78056 +27235 78055 +9516 78038 +29547 78031 +30284 78013 +112 78012 +41271 78007 +24059 77989 +18930 77971 +4965 77967 +27848 77965 +12758 77962 +29309 77958 +29946 77948 +27269 77932 +18797 77932 +17743 77928 +31535 77926 +28612 77911 +21678 77906 +40014 77902 +9059 77897 +17908 77890 +12081 77885 +34989 77860 +17503 77857 +10511 77851 +46551 77849 +17929 77844 +11174 77839 +36395 77827 +20196 77820 +32036 77818 +43692 77817 +35221 77806 +22128 77799 +34305 77796 +23285 77795 +6144 77792 +28967 77783 +19634 77777 +17615 77773 +36374 77764 +25000 77762 +17314 77759 +36300 77753 +23703 77749 +28519 77743 +43405 77742 +7959 77740 +11048 77740 +13523 77734 +46216 77727 +19490 77726 +49490 77724 +48971 77721 +23612 77716 +44599 77715 +30036 77715 +12825 77712 +43162 77712 +30227 77693 +23762 77688 +32994 77681 +16388 77676 +23492 77674 +22461 77663 +9452 77659 +6178 77627 +27963 77625 +36805 77620 +21818 77615 +32319 77614 +40154 77613 +28970 77608 +9060 77599 +39592 77597 +13195 77580 +20594 77580 +12894 77579 +30044 77568 +21757 77563 +45056 77562 +44419 77558 +27628 77551 +15558 77546 +6788 77541 +23261 77538 +41272 77538 +34928 77528 +19782 77522 +12350 77518 +18391 77506 +44842 77504 +7905 77503 +31139 77501 +35652 77500 +35999 77499 +25875 77480 +25802 77478 +24519 77476 +8635 77474 +19441 77471 +30350 77468 +43455 77467 +17168 77462 +19997 77459 +8250 77458 +38434 77457 +20873 77449 +27668 77447 +16152 77446 +35169 77421 +36814 77420 +44544 77418 +21218 77409 +24822 77400 +13294 77395 +32450 77387 +25092 77387 +21487 77383 +40460 77380 +39211 77377 +13800 77367 +43932 77358 +18517 77355 +23866 77347 +22286 77340 +16867 77334 +25152 77324 +20553 77320 +22514 77320 +17793 77307 +33783 77303 +14586 77286 +10377 77281 +8918 77270 +25931 77259 +36419 77256 +15592 77256 +29682 77249 +15146 77246 +22444 77239 +4383 77225 +36988 77224 +33444 77218 +48983 77214 +31997 77212 +16644 77206 +11205 77205 +5998 77202 +25210 77200 +20996 77196 +48157 77195 +26415 77194 +11778 77192 +18149 77189 +34003 77187 +23474 77173 +8777 77171 +29518 77166 +17916 77163 +1152 77149 +21790 77145 +16901 77142 +20927 77138 +13541 77116 +15920 77113 +2774 77105 +20367 77099 +22265 77096 +38680 77094 +31121 77094 +39012 77089 +27677 77088 +41373 77083 +48729 77074 +21479 77073 +14998 77069 +24210 77061 +24081 77044 +35129 77042 +21102 77035 +22863 77031 +25352 77021 +43915 77018 +39869 77017 +44202 77010 +4942 77002 +41503 77001 +23470 77000 +27232 76985 +41388 76981 +29901 76961 +38044 76955 +16241 76950 +42868 76948 +19699 76941 +4592 76939 +23085 76930 +24596 76929 +26324 76928 +44289 76912 +17703 76910 +40780 76909 +24927 76889 +44748 76882 +22242 76860 +19372 76851 +19787 76843 +47457 76840 +47435 76836 +15246 76835 +24324 76834 +22420 76830 +12933 76830 +4514 76822 +33940 76814 +17745 76813 +24234 76808 +38203 76807 +23631 76806 +33363 76796 +1750 76791 +37602 76789 +39414 76789 +15173 76788 +28603 76788 +38759 76784 +32539 76783 +10234 76772 +38157 76762 +21322 76762 +28617 76760 +29525 76744 +33654 76743 +17732 76734 +41462 76728 +17923 76722 +22237 76718 +26196 76716 +27805 76710 +26839 76709 +19775 76705 +19509 76704 +37916 76704 +3789 76703 +50199 76702 +41064 76688 +29218 76679 +31368 76651 +32840 76651 +25709 76646 +41324 76644 +21692 76643 +43733 76642 +15490 76622 +20932 76622 +29808 76614 +16803 76606 +38464 76586 +23105 76585 +23255 76574 +48323 76572 +27615 76568 +33668 76568 +18304 76552 +27519 76532 +29350 76528 +47765 76527 +19435 76523 +32400 76522 +35535 76514 +18646 76508 +24384 76508 +33495 76507 +28569 76503 +42008 76499 +8393 76496 +48773 76493 +22471 76488 +25828 76481 +25232 76471 +41239 76469 +26464 76457 +34461 76455 +9728 76448 +31525 76447 +37335 76439 +40520 76426 +38500 76423 +23125 76416 +23306 76411 +21806 76410 +33358 76405 +32228 76401 +34141 76393 +47412 76393 +31797 76392 +13422 76385 +10871 76382 +7762 76380 +16919 76375 +40742 76375 +29039 76370 +25238 76367 +27074 76359 +33254 76355 +15230 76351 +11633 76342 +29523 76337 +24666 76334 +35315 76331 +40811 76328 +23102 76326 +28838 76321 +26010 76317 +11220 76316 +29496 76311 +31369 76308 +44424 76306 +14478 76304 +7116 76304 +38154 76303 +22021 76298 +27484 76298 +16480 76292 +34240 76292 +29116 76292 +26669 76281 +6250 76280 +25315 76280 +12338 76268 +19214 76260 +39855 76257 +28370 76256 +33419 76250 +17484 76243 +22608 76243 +34001 76234 +15788 76229 +29876 76229 +50170 76224 +30269 76220 +34004 76218 +23675 76213 +23913 76210 +23439 76203 +39325 76184 +32878 76174 +25159 76166 +25301 76164 +25098 76160 +12531 76153 +48841 76142 +17637 76140 +31748 76139 +22384 76131 +31049 76122 +17179 76121 +34074 76121 +8432 76118 +33642 76114 +29351 76113 +29137 76111 +35925 76102 +22333 76098 +36411 76068 +20359 76060 +30451 76057 +38294 76054 +30509 76051 +35512 76026 +29902 76024 +8398 76021 +13429 76019 +21171 76018 +29781 76017 +7185 76015 +30278 75999 +3235 75996 +34092 75987 +9631 75975 +45933 75965 +21873 75954 +23500 75953 +49182 75947 +24240 75940 +1786 75938 +28928 75933 +45197 75926 +16855 75925 +2784 75921 +25119 75920 +7307 75919 +8189 75911 +12512 75903 +12727 75899 +35559 75894 +11347 75888 +36468 75879 +18843 75876 +46050 75875 +37392 75874 +48496 75857 +19232 75856 +26758 75854 +35823 75840 +44963 75831 +24007 75816 +33572 75812 +35276 75811 +46065 75804 +30939 75794 +21867 75794 +9302 75791 +46078 75784 +5272 75778 +35833 75769 +16691 75755 +13306 75748 +37298 75744 +11708 75730 +22983 75728 +29340 75721 +8353 75717 +30914 75715 +42954 75712 +22379 75707 +19460 75701 +19906 75698 +28084 75689 +21771 75686 +37480 75684 +13873 75684 +23944 75680 +24960 75675 +27465 75674 +41637 75669 +18694 75658 +30428 75655 +26757 75645 +18205 75638 +20363 75635 +34936 75633 +22485 75627 +15102 75617 +6357 75615 +29960 75600 +49209 75584 +8679 75577 +3546 75576 +30977 75569 +25632 75557 +25833 75549 +19977 75545 +33956 75544 +24444 75531 +24106 75524 +28862 75524 +25847 75505 +25542 75499 +33128 75495 +26982 75493 +32671 75485 +41838 75484 +32819 75476 +48438 75472 +32834 75463 +18926 75459 +23658 75455 +27455 75449 +20919 75449 +22565 75446 +31928 75443 +37641 75432 +30316 75432 +29437 75427 +37788 75419 +39457 75419 +33354 75418 +35425 75415 +26711 75396 +31411 75387 +39900 75380 +43544 75378 +20358 75374 +24419 75373 +28232 75372 +9940 75371 +24557 75366 +25771 75352 +14607 75344 +32027 75329 +5903 75304 +45951 75299 +27225 75295 +22353 75291 +14040 75284 +31726 75270 +38079 75262 +39762 75258 +25662 75255 +28576 75247 +38851 75237 +5168 75233 +21778 75228 +3540 75220 +35213 75213 +27098 75211 +12978 75206 +40768 75203 +30237 75202 +48503 75183 +37036 75164 +19338 75158 +20422 75157 +21694 75142 +36697 75138 +28579 75128 +27513 75113 +46708 75106 +28582 75102 +34254 75099 +34790 75099 +45674 75095 +22193 75095 +33214 75092 +39791 75091 +34064 75074 +32313 75073 +44492 75071 +20995 75066 +17895 75063 +26587 75046 +14857 75043 +13491 75040 +17013 75037 +8612 75035 +34856 75029 +38630 75028 +20090 75026 +32684 75022 +32890 75022 +38146 75021 +13299 75006 +11167 74991 +25950 74981 +22642 74971 +32119 74969 +25012 74955 +40089 74954 +30089 74943 +3995 74942 +18533 74941 +41788 74940 +49224 74936 +1564 74935 +9106 74934 +44692 74924 +18307 74920 +37191 74908 +34550 74892 +32623 74878 +3165 74870 +18599 74862 +16396 74848 +45276 74848 +5048 74839 +24971 74824 +28679 74812 +4132 74812 +43269 74808 +27794 74802 +9893 74773 +32856 74770 +34132 74759 +24601 74750 +29963 74744 +18112 74741 +44585 74739 +35344 74730 +36047 74721 +37445 74712 +17859 74711 +38287 74711 +25555 74710 +25697 74705 +23290 74697 +44745 74696 +33179 74689 +20136 74683 +19274 74679 +23931 74675 +23359 74667 +6199 74664 +25849 74661 +21442 74654 +21491 74645 +26237 74637 +40526 74624 +18452 74624 +38632 74621 +34602 74616 +30529 74615 +26126 74614 +19656 74610 +40667 74599 +17504 74594 +25800 74593 +22377 74589 +29166 74588 +17794 74580 +26430 74573 +39898 74555 +31348 74553 +21196 74551 +5620 74551 +18917 74547 +28510 74546 +5427 74545 +18886 74536 +36200 74534 +40095 74533 +5823 74531 +15648 74530 +13434 74528 +46347 74527 +30921 74525 +16540 74524 +18607 74521 +30371 74515 +29004 74508 +29651 74506 +14134 74479 +19204 74475 +24165 74472 +19084 74468 +1170 74468 +34643 74465 +19866 74452 +15072 74450 +3879 74444 +18812 74444 +48312 74440 +21414 74438 +19234 74436 +21802 74415 +18807 74406 +25379 74399 +34638 74398 +11017 74394 +42247 74389 +48834 74384 +23880 74379 +36602 74360 +38367 74356 +2334 74356 +27669 74355 +14216 74348 +40243 74345 +21428 74345 +50203 74338 +41377 74335 +38083 74332 +42993 74331 +30320 74326 +8265 74316 +21210 74310 +21355 74300 +5606 74291 +40765 74288 +31486 74287 +31605 74283 +20008 74282 +19802 74277 +16562 74277 +26325 74277 +19100 74270 +42799 74267 +41662 74243 +38485 74229 +25810 74228 +40004 74225 +34603 74220 +21345 74218 +13621 74209 +39547 74207 +13480 74192 +24688 74191 +29339 74191 +29295 74172 +35380 74171 +30244 74161 +39836 74161 +11601 74158 +23805 74150 +13876 74150 +3799 74145 +15677 74116 +6053 74114 +32010 74112 +36359 74108 +20011 74103 +41010 74095 +35668 74092 +22056 74087 +6212 74082 +17734 74076 +42471 74073 +47793 74072 +43103 74069 +14836 74066 +23532 74065 +41398 74061 +4883 74055 +31901 74055 +32355 74046 +23822 74039 +37277 74031 +16269 74022 +46391 74015 +41059 74013 +28697 74010 +39979 74008 +8429 74002 +26170 74000 +37755 73997 +30605 73995 +21403 73992 +18816 73991 +21409 73984 +19147 73976 +29044 73968 +38109 73960 +37937 73956 +35985 73955 +46019 73951 +42266 73949 +35049 73945 +37762 73936 +23748 73913 +29692 73907 +45373 73899 +4550 73875 +32416 73858 +42445 73845 +33359 73842 +18858 73839 +2633 73835 +45377 73829 +16108 73829 +30497 73826 +30421 73826 +27096 73821 +24176 73820 +36945 73810 +48043 73804 +30915 73799 +31245 73798 +30288 73795 +11002 73795 +18466 73787 +33425 73777 +29804 73772 +43647 73770 +21020 73763 +42228 73761 +33263 73752 +11475 73752 +19396 73752 +21978 73750 +43159 73723 +32730 73711 +22946 73708 +46583 73704 +20962 73702 +13590 73700 +35373 73684 +27525 73684 +48009 73669 +27700 73666 +48371 73665 +30699 73664 +46210 73664 +17552 73662 +46530 73659 +26148 73653 +33798 73638 +23598 73632 +42603 73623 +35056 73612 +32883 73610 +33125 73606 +19075 73603 +29632 73594 +26145 73592 +29432 73590 +12968 73589 +17506 73586 +27464 73585 +19949 73585 +29831 73584 +35834 73580 +5990 73578 +26127 73576 +18194 73568 +20762 73559 +22816 73552 +42509 73551 +27184 73542 +26188 73540 +30107 73539 +38030 73536 +3233 73532 +34911 73528 +39660 73527 +9979 73519 +27059 73514 +32670 73514 +14291 73511 +8330 73508 +38282 73505 +44271 73500 +19606 73491 +42365 73489 +47882 73487 +2983 73484 +18578 73482 +34679 73479 +42884 73476 +34794 73474 +30302 73469 +39598 73466 +9890 73465 +30492 73458 +13802 73455 +40325 73443 +19269 73441 +29430 73437 +29539 73429 +24994 73416 +15262 73404 +23584 73401 +39644 73400 +44035 73400 +24390 73398 +25531 73394 +16249 73377 +21234 73365 +24924 73362 +41204 73347 +38830 73342 +29131 73339 +5038 73335 +4018 73328 +15606 73321 +44919 73320 +37948 73316 +43280 73312 +26369 73309 +36556 73307 +5791 73306 +46353 73306 +15442 73304 +11650 73293 +24500 73292 +48314 73279 +27953 73272 +8091 73272 +28691 73269 +6326 73264 +17267 73262 +38555 73256 +29264 73251 +38620 73250 +25865 73248 +27390 73238 +21245 73235 +31044 73228 +26269 73226 +4516 73220 +18300 73218 +29696 73214 +19320 73212 +17947 73206 +48863 73205 +20190 73203 +14295 73198 +41595 73180 +25111 73175 +24030 73166 +27857 73160 +45673 73154 +28997 73150 +21278 73150 +28824 73147 +37723 73144 +27637 73139 +27752 73135 +29681 73135 +18435 73121 +3634 73106 +44684 73099 +30859 73096 +26223 73095 +32930 73092 +20665 73091 +27223 73089 +22884 73084 +43931 73077 +15001 73067 +19751 73061 +26570 73061 +29148 73056 +29811 73037 +15563 73029 +12643 73025 +40422 73024 +35134 73022 +36554 73021 +17770 73018 +23361 73007 +30901 73003 +17748 72999 +12529 72998 +36176 72980 +41783 72979 +26256 72979 +2674 72964 +38075 72946 +38253 72945 +8841 72943 +31712 72943 +37791 72938 +15996 72937 +1953 72932 +3542 72927 +15680 72922 +16975 72912 +29768 72912 +47040 72905 +36815 72904 +25924 72903 +22173 72899 +36548 72896 +40997 72886 +33895 72866 +35657 72865 +25311 72845 +9067 72839 +3213 72835 +37664 72832 +49425 72831 +26564 72831 +32256 72817 +38662 72814 +32166 72810 +31623 72802 +37651 72787 +43720 72786 +16147 72777 +10082 72773 +27485 72765 +40744 72757 +28908 72743 +8000 72730 +9717 72718 +18922 72709 +40351 72708 +6281 72696 +20510 72692 +45844 72690 +4823 72684 +14873 72678 +39193 72672 +4396 72658 +29916 72628 +11715 72627 +23476 72620 +20273 72616 +22538 72609 +14617 72601 +46458 72599 +22751 72578 +28753 72578 +21539 72572 +25508 72570 +35480 72570 +49063 72568 +19328 72567 +33989 72558 +8710 72553 +42722 72551 +7824 72542 +36955 72530 +28195 72523 +8400 72507 +26834 72505 +31864 72501 +30984 72480 +32411 72480 +16834 72479 +23389 72458 +34331 72455 +24177 72455 +24430 72447 +15793 72444 +39404 72440 +12603 72437 +41489 72434 +25888 72429 +12322 72428 +9135 72421 +25244 72417 +25070 72415 +22878 72408 +44398 72404 +26017 72400 +32839 72390 +20005 72387 +25625 72364 +29092 72356 +19349 72342 +31606 72321 +11644 72320 +5051 72318 +4098 72313 +22990 72310 +43640 72310 +12786 72308 +8493 72308 +28695 72300 +32359 72299 +21794 72290 +38977 72287 +36884 72287 +12991 72284 +30881 72260 +30711 72255 +37383 72251 +33073 72250 +12947 72241 +19430 72240 +20233 72232 +26014 72231 +44878 72217 +3579 72212 +18454 72211 +25573 72210 +23246 72203 +21033 72202 +40649 72186 +24730 72182 +45011 72178 +29186 72178 +21989 72176 +38681 72168 +6836 72156 +32758 72156 +46373 72155 +48007 72154 +26041 72153 +26958 72151 +17729 72145 +28918 72142 +24139 72140 +20712 72140 +16815 72138 +28307 72086 +20347 72078 +23840 72069 +33587 72055 +17790 72052 +27900 72051 +24107 72049 +22354 72048 +23374 72038 +18562 72036 +17062 72034 +21925 72026 +31285 72024 +17951 72016 +28819 72016 +4374 72011 +4573 72010 +36980 72007 +17514 71996 +46643 71986 +1922 71979 +6690 71978 +43703 71974 +23101 71974 +40498 71967 +11265 71961 +10642 71957 +32955 71942 +26285 71937 +9047 71934 +19104 71933 +13414 71929 +9100 71928 +39072 71921 +31138 71921 +15761 71915 +29292 71915 +27491 71913 +41736 71911 +40892 71907 +26021 71902 +38789 71898 +10051 71896 +19960 71888 +37260 71870 +27315 71863 +23060 71860 +40394 71857 +25082 71849 +17283 71841 +23195 71835 +34286 71835 +49521 71822 +18366 71820 +39016 71820 +46625 71816 +49618 71805 +34269 71799 +39576 71799 +17382 71795 +24901 71787 +47489 71781 +15631 71777 +37717 71774 +28110 71766 +14880 71764 +12195 71755 +24887 71753 +43731 71748 +16921 71740 +49117 71738 +45856 71731 +11258 71724 +22326 71717 +47813 71700 +1980 71685 +30323 71681 +36041 71670 +6106 71670 +31256 71669 +24790 71665 +16305 71650 +40899 71647 +36671 71646 +8821 71639 +48018 71638 +33948 71636 +38809 71632 +26665 71631 +8571 71628 +42920 71621 +15024 71618 +17084 71609 +40846 71601 +27873 71601 +4057 71593 +17972 71585 +30022 71585 +45301 71581 +35018 71576 +24883 71549 +25717 71546 +26073 71546 +37968 71542 +49528 71504 +43816 71495 +11719 71494 +11277 71488 +34659 71487 +46936 71484 +21690 71480 +22441 71474 +46321 71472 +40065 71470 +38297 71469 +32655 71468 +27580 71466 +33807 71442 +21159 71439 +21453 71437 +19826 71429 +25520 71426 +7277 71426 +19062 71420 +39958 71414 +27574 71403 +22349 71388 +13932 71386 +39236 71384 +22721 71365 +23324 71362 +28594 71358 +24429 71354 +42389 71352 +29779 71351 +23693 71343 +23766 71342 +42990 71339 +46502 71337 +27113 71334 +41763 71319 +42620 71318 +32691 71317 +34009 71310 +13085 71295 +7596 71293 +20248 71292 +45749 71290 +24098 71289 +28461 71286 +36679 71281 +38817 71277 +35383 71271 +10890 71269 +21325 71253 +9921 71251 +34214 71246 +11071 71244 +23281 71240 +20542 71240 +48807 71238 +29263 71236 +27942 71233 +28284 71225 +24114 71218 +21636 71218 +38981 71216 +38687 71215 +21042 71211 +49808 71207 +21528 71201 +29365 71200 +18973 71191 +39109 71190 +11973 71187 +19810 71186 +30055 71185 +29499 71183 +28148 71183 +23213 71174 +21213 71149 +4985 71145 +21522 71134 +30886 71129 +39116 71127 +21710 71121 +43792 71116 +33376 71113 +20936 71108 +3373 71094 +27476 71092 +21083 71068 +28763 71062 +36192 71061 +17319 71038 +37399 71036 +17208 71034 +22972 71024 +16036 71024 +37257 71012 +43152 71009 +47712 70998 +37443 70993 +29745 70981 +12885 70978 +33557 70969 +45913 70959 +26657 70959 +33996 70951 +26051 70948 +27457 70943 +10334 70943 +23642 70932 +48912 70930 +37938 70918 +11439 70912 +20102 70906 +12718 70905 +25638 70900 +18348 70896 +2521 70892 +17571 70886 +41584 70886 +44436 70880 +22267 70872 +38286 70867 +12129 70857 +15367 70854 +30879 70846 +27336 70843 +16504 70842 +42373 70836 +24241 70830 +20567 70830 +30054 70825 +24329 70824 +40680 70823 +41227 70820 +35703 70819 +22576 70814 +42281 70809 +23530 70803 +34860 70795 +45606 70782 +40250 70782 +41749 70770 +49194 70768 +37742 70766 +23798 70763 +17601 70762 +10450 70755 +29178 70752 +8368 70747 +26275 70735 +24808 70734 +15065 70731 +35840 70723 +20838 70716 +25747 70709 +2062 70701 +41803 70700 +26251 70693 +25815 70675 +48467 70673 +28517 70672 +22318 70667 +40942 70666 +23158 70655 +40875 70652 +29535 70652 +22855 70635 +9774 70630 +45026 70622 +12674 70621 +29996 70619 +25413 70596 +39953 70596 +34660 70595 +32829 70593 +36126 70588 +39365 70580 +16817 70579 +9868 70578 +22660 70577 +28507 70577 +23388 70576 +26931 70576 +17427 70574 +24600 70568 +37595 70567 +22100 70565 +23791 70561 +14697 70556 +19155 70555 +16506 70537 +36525 70535 +13610 70529 +1206 70521 +27648 70515 +27328 70514 +15649 70511 +25416 70502 +20616 70494 +23809 70485 +2553 70479 +32164 70470 +11420 70470 +19300 70468 +23776 70465 +16315 70464 +19898 70464 +41082 70455 +41396 70443 +32767 70430 +254 70422 +18742 70420 +40764 70418 +19821 70413 +26790 70412 +11493 70412 +24447 70406 +19774 70400 +35301 70391 +990 70390 +37634 70379 +28372 70378 +25740 70374 +21363 70373 +21473 70372 +43235 70368 +39607 70364 +26228 70359 +24216 70351 +27767 70349 +4123 70346 +16252 70339 +48633 70332 +46608 70328 +7447 70321 +17834 70313 +8462 70308 +32121 70306 +25972 70300 +26234 70298 +38201 70296 +38971 70292 +14619 70278 +40814 70275 +21503 70267 +25137 70263 +3581 70263 +24306 70260 +21540 70244 +21000 70244 +12833 70237 +27105 70234 +44406 70234 +22036 70232 +32466 70231 +49404 70224 +22169 70222 +30160 70214 +19225 70193 +21613 70192 +21805 70190 +18763 70186 +4520 70181 +42355 70181 +8939 70179 +1836 70177 +580 70171 +18868 70166 +36233 70163 +12468 70157 +29591 70156 +22364 70156 +7609 70155 +41390 70148 +6513 70148 +28538 70146 +22107 70144 +28546 70143 +27063 70143 +22084 70142 +40011 70134 +26027 70132 +29278 70131 +45181 70127 +24317 70124 +28533 70122 +36782 70115 +22520 70109 +28583 70109 +42746 70097 +26081 70085 +29885 70083 +14675 70079 +35281 70074 +36348 70072 +30840 70067 +29699 70066 +24853 70057 +21296 70056 +4782 70038 +24068 70032 +12482 70030 +31353 70017 +17226 70016 +6556 70011 +1825 70008 +28412 69996 +18070 69988 +24628 69971 +39209 69959 +13856 69952 +34904 69950 +40840 69948 +15932 69944 +30242 69937 +19032 69933 +20234 69924 +20262 69918 +33188 69907 +39136 69891 +21048 69889 +31976 69883 +31481 69881 +18127 69880 +34203 69878 +752 69878 +6610 69871 +3455 69861 +18904 69854 +32461 69854 +40269 69845 +16781 69841 +18892 69828 +18878 69827 +4541 69827 +9487 69827 +6806 69819 +43346 69816 +14353 69798 +25030 69794 +49626 69792 +26838 69791 +45549 69787 +21869 69774 +23683 69763 +30183 69759 +33174 69758 +41979 69756 +12762 69751 +21354 69736 +43047 69736 +16270 69734 +50026 69732 +22632 69732 +14747 69731 +17338 69723 +38643 69717 +32902 69712 +23110 69705 +27549 69700 +9277 69694 +3507 69686 +44805 69681 +30534 69678 +24865 69678 +6784 69672 +36900 69668 +34250 69664 +32205 69664 +28717 69662 +26954 69656 +28509 69654 +42038 69649 +23932 69648 +21719 69646 +12515 69640 +24681 69637 +44416 69624 +28831 69615 +37042 69608 +38982 69601 +28726 69584 +33329 69576 +29454 69562 +1888 69560 +31990 69558 +49798 69544 +32629 69541 +24208 69540 +23845 69536 +36267 69535 +21934 69530 +16823 69514 +6307 69514 +17952 69508 +22898 69507 +38921 69502 +45341 69498 +46579 69491 +26426 69491 +38057 69486 +148 69485 +19571 69469 +35189 69467 +37377 69461 +30822 69455 +17657 69455 +16920 69447 +19238 69442 +43428 69439 +48588 69438 +14258 69432 +20318 69428 +44373 69421 +17384 69421 +22343 69416 +42273 69407 +36073 69393 +44099 69386 +34558 69382 +2182 69372 +44122 69362 +8958 69360 +15987 69355 +36721 69351 +14001 69349 +15236 69341 +32168 69336 +44799 69329 +30259 69321 +45754 69314 +23082 69307 +34344 69301 +43561 69281 +11425 69264 +38700 69258 +37729 69256 +27384 69253 +41071 69239 +29931 69229 +21573 69226 +18907 69225 +25274 69223 +27859 69222 +36389 69219 +31470 69218 +41325 69218 +10573 69208 +38152 69199 +25572 69189 +31291 69186 +11688 69169 +15708 69166 +47847 69162 +39068 69161 +47431 69152 +41555 69145 +47711 69141 +45044 69135 +13099 69132 +33413 69129 +21059 69125 +29650 69123 +17596 69119 +38872 69117 +13223 69117 +32308 69116 +34939 69107 +24657 69092 +31212 69088 +27518 69087 +36425 69083 +45293 69073 +43537 69071 +27361 69066 +42764 69047 +13311 69045 +16544 69045 +37448 69037 +48876 69037 +31288 69035 +35359 69023 +8585 69014 +11898 69008 +10236 69006 +38952 69005 +26861 68998 +30154 68997 +15596 68994 +17149 68989 +38839 68989 +8401 68987 +27330 68980 +8043 68980 +50090 68980 +37013 68972 +16592 68972 +28969 68964 +45294 68963 +5347 68961 +27817 68960 +23563 68958 +28098 68954 +31515 68953 +29849 68952 +30282 68946 +20186 68945 +19828 68944 +4892 68940 +25690 68935 +32268 68934 +16436 68934 +5769 68933 +20912 68927 +17265 68920 +40056 68920 +29055 68908 +19760 68907 +7753 68904 +1935 68903 +7076 68901 +20167 68891 +27432 68890 +46828 68889 +24910 68885 +20547 68875 +3567 68863 +24425 68852 +8654 68852 +23223 68835 +11197 68830 +35421 68824 +8910 68812 +33217 68811 +28493 68809 +45863 68800 +18052 68798 +46535 68794 +47925 68792 +26722 68790 +3089 68790 +28325 68788 +31316 68779 +28206 68778 +40946 68772 +18225 68769 +22328 68767 +41769 68761 +17670 68748 +15595 68747 +33005 68742 +19181 68738 +22091 68727 +33632 68725 +2567 68720 +9641 68707 +9195 68698 +23367 68695 +26963 68694 +42953 68682 +17437 68678 +48757 68677 +48847 68674 +28021 68673 +23873 68672 +42629 68663 +45347 68658 +32448 68654 +43154 68647 +26902 68647 +19792 68633 +34748 68631 +27409 68630 +33533 68623 +36508 68621 +42999 68618 +22094 68611 +42113 68606 +16879 68604 +33423 68602 +26831 68566 +29534 68559 +36498 68554 +14098 68548 +49495 68547 +22200 68542 +32331 68535 +28991 68534 +37558 68531 +44349 68530 +28652 68526 +11020 68522 +18215 68522 +39036 68522 +40770 68514 +44911 68509 +6514 68491 +31123 68490 +32980 68488 +2234 68488 +20866 68486 +38261 68481 +35798 68480 +42574 68479 +46388 68479 +7933 68469 +23498 68452 +40072 68449 +26510 68442 +43623 68440 +17388 68438 +6389 68436 +24257 68423 +38059 68421 +42736 68418 +45936 68413 +26128 68413 +39313 68412 +35323 68403 +35594 68392 +39025 68389 +42094 68389 +17847 68386 +16631 68385 +15328 68375 +32043 68370 +19849 68366 +26490 68365 +22066 68357 +18046 68351 +2303 68337 +9876 68336 +13137 68333 +23823 68332 +15652 68332 +35080 68330 +23323 68327 +43890 68326 +46732 68320 +19103 68319 +27939 68311 +27234 68306 +27391 68301 +29140 68300 +26137 68300 +36333 68299 +8183 68290 +31189 68284 +36576 68283 +16187 68280 +27568 68277 +15538 68276 +44018 68273 +47717 68253 +39905 68252 +24436 68249 +27407 68240 +21591 68238 +40015 68237 +19345 68231 +20226 68230 +21894 68221 +38372 68212 +30151 68212 +31568 68190 +16858 68186 +18664 68180 +35249 68168 +46578 68143 +33915 68142 +34093 68118 +20437 68114 +37946 68102 +40317 68102 +40543 68098 +18741 68094 +21709 68085 +36662 68083 +42705 68059 +8789 68055 +16703 68053 +40696 68051 +49293 68048 +12291 68045 +41971 68045 +47349 68038 +18815 68034 +38511 68033 +49894 68021 +26547 68021 +34536 68018 +28207 68017 +41086 68006 +47822 68005 +1970 67984 +24028 67974 +20934 67971 +36987 67966 +10113 67960 +22951 67949 +22142 67944 +21035 67942 +36353 67938 +20780 67936 +47074 67928 +25705 67927 +21916 67919 +8230 67917 +44050 67910 +21365 67885 +19371 67884 +25240 67878 +26835 67875 +22601 67874 +35432 67872 +16056 67863 +27298 67860 +48711 67849 +23865 67829 +22827 67823 +30974 67809 +27989 67792 +21344 67777 +38992 67776 +36472 67776 +14786 67766 +39026 67764 +31861 67757 +43814 67744 +21792 67733 +18510 67733 +41540 67732 +23490 67731 +40528 67730 +13087 67730 +9580 67729 +26240 67727 +1472 67727 +33601 67721 +47265 67721 +38919 67714 +20986 67710 +13384 67707 +49338 67694 +12828 67690 +30957 67687 +19454 67685 +18278 67654 +33513 67647 +14398 67646 +22594 67641 +11786 67639 +11876 67631 +2965 67624 +21427 67616 +20959 67612 +18376 67612 +26566 67609 +7201 67606 +27878 67604 +35933 67590 +13174 67587 +13839 67580 +4210 67579 +25112 67570 +46533 67567 +15967 67567 +9288 67558 +39154 67553 +39091 67544 +19917 67544 +20474 67543 +23774 67539 +38058 67537 +15299 67536 +19082 67534 +3795 67530 +26329 67512 +30455 67511 +41422 67509 +37016 67505 +32741 67502 +30062 67498 +24362 67497 +19206 67497 +36755 67486 +8457 67486 +26071 67485 +38495 67483 +21769 67476 +40983 67460 +41618 67451 +19325 67443 +14904 67441 +27088 67432 +32952 67427 +36507 67406 +29180 67403 +27947 67402 +30438 67398 +19930 67392 +20307 67391 +34187 67386 +45899 67384 +13033 67380 +26821 67373 +36933 67370 +7199 67368 +36592 67367 +34430 67365 +38080 67336 +3153 67334 +17688 67334 +32404 67333 +49369 67330 +20718 67327 +25327 67321 +43487 67314 +43229 67311 +10044 67310 +31277 67305 +29684 67302 +19903 67297 +22590 67291 +27183 67288 +15754 67287 +19222 67287 +22744 67282 +39046 67281 +38798 67277 +10613 67264 +39690 67260 +29711 67255 +21407 67245 +6207 67241 +19074 67237 +27029 67230 +28889 67226 +28267 67224 +12483 67216 +35335 67215 +49118 67214 +47097 67210 +16796 67207 +4233 67207 +16011 67191 +12458 67184 +22115 67183 +48831 67181 +19040 67180 +5570 67179 +4140 67176 +17983 67174 +35060 67167 +40688 67167 +26573 67160 +16365 67158 +24332 67149 +17756 67147 +35022 67146 +13042 67146 +2205 67137 +35127 67135 +40399 67133 +31147 67131 +24769 67131 +31931 67100 +27252 67100 +19909 67095 +19954 67094 +29630 67093 +141 67090 +19118 67089 +28332 67086 +45269 67082 +13824 67082 +36709 67080 +23594 67072 +27498 67061 +34922 67056 +44421 67043 +43765 67042 +27681 67037 +3314 67021 +31096 67016 +25250 67005 +17759 67001 +18571 66993 +9553 66992 +20179 66988 +29426 66977 +39944 66971 +19939 66965 +13624 66964 +9690 66958 +25772 66950 +5943 66948 +914 66937 +27208 66937 +38707 66931 +17010 66916 +8196 66915 +20868 66914 +42849 66913 +33021 66909 +23959 66906 +16354 66884 +26191 66878 +29595 66874 +9426 66872 +32800 66871 +25192 66866 +20100 66864 +21770 66862 +22050 66851 +24715 66851 +31422 66848 +46574 66843 +28105 66838 +14925 66831 +49858 66830 +15137 66829 +36131 66822 +11825 66818 +24530 66807 +13924 66806 +24716 66805 +26590 66799 +29451 66789 +16326 66788 +20836 66786 +30065 66785 +24796 66784 +7060 66782 +30060 66781 +30849 66779 +17585 66776 +24905 66776 +7680 66766 +6271 66765 +41037 66764 +46355 66764 +44272 66760 +29793 66742 +26500 66741 +8480 66739 +20917 66730 +23311 66727 +43861 66724 +20124 66724 +40563 66706 +41665 66705 +40524 66696 +21777 66695 +21536 66694 +23717 66689 +19609 66688 +46039 66687 +31879 66686 +24507 66676 +26888 66675 +34037 66674 +26810 66672 +40752 66671 +29290 66670 +25721 66667 +10363 66663 +40376 66660 +10419 66658 +34143 66645 +15274 66641 +21549 66633 +22427 66614 +37878 66586 +50236 66581 +42540 66581 +40645 66581 +22231 66577 +42847 66574 +45277 66567 +26432 66561 +24561 66549 +19485 66549 +34245 66545 +23834 66544 +40030 66540 +28459 66539 +7916 66538 +19507 66528 +20975 66527 +16552 66525 +36290 66524 +36254 66523 +45109 66517 +35696 66517 +20796 66516 +23771 66513 +26636 66502 +34639 66497 +4680 66491 +41913 66486 +28233 66484 +45327 66484 +37521 66479 +20048 66470 +25878 66469 +4804 66460 +5792 66455 +49398 66448 +21240 66426 +43757 66408 +27861 66400 +47515 66397 +15417 66396 +29105 66386 +37131 66383 +35459 66374 +4600 66368 +27415 66365 +22256 66364 +12012 66358 +28962 66357 +28225 66354 +15997 66351 +24386 66347 +21225 66346 +24012 66345 +26596 66344 +35449 66338 +47447 66338 +25858 66334 +41514 66330 +42542 66326 +29287 66319 +36398 66313 +32019 66307 +26206 66303 +26928 66297 +44294 66297 +21697 66296 +49767 66295 +33078 66293 +27718 66291 +30466 66290 +23134 66287 +39370 66268 +25433 66267 +25988 66261 +24506 66244 +30555 66234 +20578 66233 +37339 66227 +21718 66226 +24922 66224 +1937 66223 +17402 66221 +20615 66220 +21433 66216 +35032 66210 +23586 66204 +17824 66200 +33171 66198 +37556 66196 +30888 66190 +37499 66186 +21712 66183 +45177 66183 +31846 66165 +13381 66156 +25809 66154 +19088 66145 +19180 66144 +39288 66144 +33769 66140 +24578 66140 +26936 66139 +32826 66138 +41946 66127 +28123 66126 +49783 66126 +24049 66125 +42439 66123 +36524 66121 +37951 66112 +19645 66109 +36031 66104 +23275 66104 +17393 66104 +35466 66102 +18104 66083 +3527 66079 +20729 66079 +15155 66078 +21377 66075 +23570 66072 +33628 66058 +23938 66048 +47699 66043 +14990 66037 +34937 66035 +31453 66030 +19445 66030 +19348 66026 +45346 66016 +15079 66007 +35715 66005 +38548 66000 +38153 65991 +37517 65991 +30166 65984 +45603 65971 +9562 65967 +24777 65964 +25424 65959 +23667 65959 +25103 65957 +40935 65951 +35754 65946 +40701 65945 +27561 65943 +40274 65937 +44107 65934 +20675 65933 +38826 65927 +25318 65925 +26043 65925 +34268 65910 +48041 65908 +48117 65899 +28079 65896 +40633 65893 +31302 65891 +33280 65891 +36696 65891 +39745 65887 +35043 65887 +24291 65887 +36963 65885 +38262 65885 +40691 65883 +29050 65883 +34299 65881 +38111 65877 +23654 65875 +20834 65872 +18159 65871 +17400 65869 +27697 65862 +41611 65849 +46669 65845 +18558 65830 +35724 65825 +27851 65810 +29107 65807 +27262 65806 +13040 65802 +35845 65801 +23263 65798 +38459 65796 +30171 65791 +43774 65789 +20511 65786 +31320 65784 +41223 65776 +16996 65766 +22947 65764 +48309 65762 +40863 65761 +6785 65758 +38222 65757 +6804 65742 +33071 65740 +37276 65739 +33122 65739 +18629 65736 +23818 65735 +27475 65734 +32860 65727 +8622 65724 +23442 65717 +32358 65707 +27474 65707 +23824 65698 +36386 65698 +5577 65688 +10496 65681 +41943 65678 +11454 65675 +35966 65675 +19672 65672 +4807 65671 +13513 65669 +32969 65668 +28756 65657 +33568 65656 +35953 65653 +19244 65645 +29569 65643 +25425 65639 +31757 65634 +18273 65628 +6015 65625 +23009 65625 +22670 65621 +19972 65621 +15424 65619 +14192 65616 +35954 65615 +32445 65608 +29202 65608 +48164 65606 +16980 65604 +42475 65604 +32596 65603 +17118 65600 +44801 65600 +46406 65590 +32735 65589 +28011 65586 +27284 65582 +7583 65578 +43207 65573 +16931 65572 +11991 65561 +19233 65546 +29155 65542 +18298 65537 +33262 65533 +21154 65530 +43741 65528 +15456 65524 +39718 65508 +32569 65507 +15705 65504 +20350 65502 +24587 65498 +38164 65495 +29398 65495 +43393 65493 +24562 65489 +19114 65489 +20668 65477 +30538 65466 +34700 65463 +22049 65448 +34548 65447 +34014 65440 +27182 65432 +41702 65430 +21669 65427 +23372 65425 +35446 65425 +38178 65413 +21144 65412 +17749 65408 +34892 65405 +29232 65404 +43742 65401 +42151 65399 +25834 65394 +34315 65393 +14837 65392 +40685 65390 +16654 65389 +21607 65389 +35297 65378 +21816 65366 +19023 65364 +26852 65347 +27807 65347 +19736 65337 +21850 65336 +18574 65335 +21172 65322 +16833 65304 +31532 65302 +30973 65298 +29168 65274 +32762 65273 +9057 65269 +29450 65265 +8164 65261 +2760 65256 +35485 65254 +19865 65248 +46051 65245 +12984 65244 +43226 65242 +30172 65239 +18955 65239 +6084 65232 +31381 65230 +29614 65225 +31747 65202 +13369 65200 +38863 65198 +46653 65189 +37796 65188 +41140 65183 +12295 65181 +22547 65180 +39479 65177 +1506 65172 +25212 65167 +41902 65161 +39148 65157 +30793 65151 +29235 65150 +1361 65149 +6874 65148 +31001 65148 +2552 65138 +48484 65133 +13202 65132 +29242 65132 +37030 65130 +47154 65121 +21374 65119 +28526 65113 +44119 65112 +37180 65104 +28491 65102 +33368 65100 +44143 65096 +44381 65091 +17890 65088 +31956 65082 +18668 65067 +31781 65053 +18345 65041 +40992 65037 +9647 65032 +42125 65030 +35351 65029 +42498 65016 +9357 65005 +33522 64997 +30510 64996 +29065 64992 +30889 64992 +16966 64975 +26614 64971 +33936 64956 +40807 64948 +27819 64940 +27995 64930 +17301 64924 +31647 64923 +41310 64920 +30713 64919 +1491 64917 +11837 64914 +39360 64913 +24755 64910 +12552 64907 +25547 64904 +9822 64903 +34369 64900 +23981 64897 +34623 64895 +5493 64885 +49042 64883 +32914 64880 +26647 64878 +25241 64876 +19281 64872 +32753 64865 +26139 64864 +44386 64859 +27281 64851 +24739 64846 +44918 64838 +37566 64837 +22406 64833 +29844 64824 +42824 64805 +38063 64802 +14189 64796 +19664 64796 +5226 64782 +45463 64775 +47735 64766 +24780 64765 +22033 64742 +27048 64735 +28010 64734 +20083 64723 +27044 64718 +5458 64715 +37097 64709 +35971 64708 +3308 64701 +46811 64664 +34295 64662 +41896 64661 +27200 64652 +9062 64637 +26016 64631 +21890 64630 +26886 64628 +25980 64626 +33663 64621 +38719 64620 +3948 64618 +22780 64614 +22739 64601 +45556 64598 +44626 64582 +45125 64580 +40308 64579 +27899 64569 +24311 64568 +30375 64567 +32232 64565 +23591 64564 +49872 64553 +4323 64552 +6978 64549 +29382 64548 +19727 64540 +3231 64538 +30449 64533 +48906 64531 +21016 64531 +22248 64528 +16184 64525 +27276 64518 +21643 64514 +48769 64514 +39203 64511 +28530 64511 +23176 64508 +31332 64504 +31290 64502 +28654 64500 +7919 64500 +25397 64494 +28527 64492 +47595 64484 +33052 64481 +26215 64471 +18396 64466 +32607 64461 +21825 64459 +5360 64453 +16669 64450 +44179 64446 +28197 64443 +10286 64436 +19836 64433 +33806 64431 +25293 64419 +48361 64416 +43419 64408 +20108 64400 +38355 64398 +39358 64397 +15202 64381 +30256 64355 +36740 64355 +34998 64354 +36304 64343 +38320 64341 +18971 64336 +33081 64334 +34518 64329 +32083 64325 +30000 64322 +22701 64318 +19818 64306 +37313 64295 +40978 64294 +26730 64290 +24846 64271 +36121 64270 +27558 64261 +36009 64260 +18977 64259 +41926 64244 +26609 64238 +46779 64238 +28387 64238 +21826 64235 +40907 64224 +29671 64224 +24989 64214 +22656 64210 +25592 64206 +20743 64200 +25784 64193 +42392 64193 +24939 64189 +13398 64180 +45399 64171 +14635 64156 +26001 64155 +32029 64152 +48677 64145 +29927 64140 +42288 64135 +48302 64135 +4515 64131 +2101 64129 +38230 64125 +25655 64125 +14076 64121 +28779 64117 +5647 64115 +15217 64114 +36092 64113 +41967 64112 +16161 64107 +16487 64103 +22494 64102 +25063 64100 +33041 64096 +27759 64090 +24488 64083 +28973 64075 +46889 64075 +17515 64063 +31725 64060 +23769 64050 +35675 64047 +20161 64046 +26688 64040 +26112 64036 +28153 64031 +26470 64024 +44210 64015 +34571 64013 +42754 64007 +3921 64003 +21230 63999 +24356 63996 +46949 63996 +49860 63995 +43442 63995 +35128 63992 +2384 63991 +32033 63990 +9182 63984 +16274 63982 +15225 63979 +4070 63978 +31639 63975 +22465 63974 +41651 63973 +9448 63964 +35198 63962 +32504 63961 +45187 63958 +13103 63957 +12960 63950 +38360 63945 +13880 63937 +9804 63930 +11313 63921 +19772 63918 +47592 63915 +29333 63914 +20546 63914 +41073 63912 +37924 63907 +34821 63904 +24916 63903 +35444 63900 +44352 63891 +25076 63890 +4648 63889 +43985 63881 +6719 63881 +7803 63878 +35377 63878 +38523 63877 +38285 63866 +33899 63865 +6929 63864 +40352 63860 +46539 63858 +22303 63842 +36437 63837 +30061 63837 +35756 63836 +18041 63835 +41533 63833 +30987 63821 +22967 63820 +18722 63818 +34744 63812 +22745 63805 +25997 63798 +49577 63798 +17510 63796 +25519 63785 +41892 63784 +41965 63770 +19538 63757 +33702 63754 +25368 63752 +16096 63747 +45732 63743 +11362 63741 +38174 63739 +25776 63730 +36302 63728 +31101 63726 +24643 63725 +25699 63722 +46994 63713 +4636 63712 +47693 63712 +14838 63705 +10300 63703 +20646 63699 +28784 63696 +20634 63694 +22358 63685 +20144 63683 +28477 63682 +11184 63680 +24000 63673 +21261 63668 +32885 63667 +9819 63666 +16773 63664 +29020 63660 +37134 63652 +31477 63638 +46729 63633 +45555 63632 +11866 63631 +15903 63631 +14646 63631 +19130 63628 +18542 63623 +33753 63623 +25963 63620 +17385 63616 +29207 63608 +37461 63607 +19265 63594 +21508 63593 +22160 63584 +26536 63580 +42628 63580 +14254 63575 +43376 63574 +36762 63562 +34796 63561 +38315 63559 +31104 63552 +33861 63550 +18951 63549 +34351 63535 +25268 63532 +45064 63530 +29353 63529 +5659 63528 +35201 63526 +20853 63522 +19811 63520 +37043 63510 +12535 63506 +25976 63503 +30705 63500 +43868 63497 +11176 63484 +31352 63473 +39387 63471 +25493 63470 +45067 63470 +18768 63469 +30186 63465 +32249 63463 +31480 63457 +39011 63446 +22335 63443 +7861 63443 +24793 63441 +14602 63437 +17641 63429 +31498 63427 +25134 63426 +17297 63425 +29494 63420 +16486 63417 +21060 63409 +30663 63408 +35296 63401 +32967 63395 +33228 63392 +21729 63392 +17140 63374 +5317 63374 +30292 63371 +38234 63366 +37286 63360 +10141 63355 +19734 63350 +11804 63348 +19474 63340 +22247 63340 +12944 63322 +24018 63317 +38558 63316 +44936 63315 +33675 63309 +26224 63307 +26732 63300 +18058 63298 +27965 63296 +26684 63290 +27887 63277 +27221 63276 +1193 63271 +33453 63265 +21585 63258 +33578 63258 +40959 63243 +18720 63239 +24995 63234 +27004 63227 +27127 63224 +30647 63222 +20334 63219 +12997 63206 +24231 63200 +35554 63196 +25557 63194 +46989 63192 +48316 63191 +40074 63184 +38606 63184 +10994 63179 +47894 63176 +19442 63173 +15714 63170 +11284 63168 +46411 63167 +38129 63165 +24478 63158 +21255 63158 +49482 63158 +1407 63144 +21388 63141 +24069 63136 +34990 63135 +38646 63131 +25678 63125 +34596 63123 +45189 63122 +34040 63116 +34231 63112 +18905 63097 +11857 63093 +38358 63092 +36806 63091 +28776 63083 +37931 63081 +31892 63075 +29439 63072 +33290 63072 +47005 63070 +26424 63069 +25560 63058 +40430 63056 +48158 63054 +17464 63051 +22113 63047 +35065 63031 +50075 63023 +21667 63021 +20034 63019 +29943 63018 +28092 63017 +2108 63016 +41640 63013 +1132 63012 +20624 63009 +36876 63005 +27305 63002 +20381 63002 +39523 62996 +20478 62995 +49250 62994 +14797 62994 +13060 62992 +44310 62991 +23574 62990 +45476 62967 +26830 62965 +11296 62964 +9362 62963 +32507 62960 +31379 62955 +45033 62949 +23284 62947 +35938 62944 +22131 62944 +29135 62942 +25077 62938 +21578 62927 +25773 62927 +39372 62925 +3990 62921 +43341 62916 +23816 62916 +31091 62911 +33075 62909 +32442 62896 +18248 62881 +38014 62879 +26304 62872 +22352 62867 +8081 62866 +12976 62864 +50231 62857 +24921 62842 +18636 62837 +19846 62837 +41155 62821 +26574 62810 +42923 62806 +20844 62801 +31198 62794 +19650 62783 +17240 62778 +16856 62777 +11555 62777 +18049 62755 +25381 62751 +20043 62746 +36903 62744 +15624 62742 +23853 62741 +43678 62733 +6435 62733 +42952 62723 +14967 62723 +13049 62721 +19052 62720 +31351 62705 +23145 62704 +40596 62682 +27065 62678 +32805 62667 +33745 62661 +23417 62652 +27408 62651 +25071 62648 +35037 62647 +49067 62645 +38534 62633 +30712 62631 +42838 62626 +37629 62624 +25654 62620 +4142 62620 +44760 62618 +15845 62603 +3447 62602 +34809 62595 +7004 62593 +46137 62589 +45329 62587 +42862 62584 +26421 62583 +13696 62574 +15835 62573 +34529 62558 +25544 62533 +42345 62518 +23183 62516 +29987 62514 +25789 62501 +38162 62501 +39854 62496 +26397 62485 +20822 62484 +36839 62474 +31682 62473 +31443 62465 +32135 62459 +47955 62453 +37095 62453 +43097 62450 +34061 62442 +33633 62434 +28340 62429 +24786 62427 +17103 62419 +27327 62417 +40359 62413 +28234 62412 +36997 62408 +7254 62406 +8593 62406 +25580 62406 +31086 62406 +6652 62405 +21965 62398 +2445 62396 +28246 62395 +37075 62394 +31720 62392 +28767 62388 +11458 62385 +18534 62382 +36391 62380 +24648 62377 +31163 62375 +32385 62372 +22679 62367 +42328 62360 +24475 62355 +23741 62350 +36354 62339 +24672 62336 +29817 62332 +33782 62331 +19531 62331 +26218 62328 +17470 62306 +30050 62304 +43415 62300 +16985 62293 +38487 62277 +28364 62268 +47304 62257 +23421 62252 +10458 62249 +20260 62247 +25543 62245 +18869 62239 +36735 62235 +43256 62231 +28574 62228 +25562 62227 +42521 62222 +36768 62221 +230 62217 +30040 62215 +33880 62212 +35104 62207 +21489 62201 +13001 62195 +35256 62193 +24986 62193 +49018 62190 +9338 62183 +27855 62171 +31603 62153 +12721 62149 +34685 62149 +46977 62149 +41969 62142 +37732 62140 +20316 62132 +21888 62131 +43611 62127 +28671 62123 +23180 62123 +38137 62122 +12480 62120 +32628 62118 +35024 62117 +27495 62108 +49145 62102 +30250 62091 +24734 62064 +30913 62064 +34429 62054 +46327 62051 +11531 62033 +13154 62028 +19418 62024 +34475 62022 +38087 62021 +231 62021 +15396 62008 +34199 62003 +1715 61999 +48674 61998 +46409 61995 +30339 61994 +36897 61990 +42261 61989 +42621 61987 +29573 61985 +13377 61984 +31513 61978 +29042 61962 +15605 61953 +48734 61946 +24203 61944 +38725 61937 +10901 61934 +30868 61934 +29772 61921 +18175 61918 +31689 61915 +41804 61914 +25943 61906 +26519 61903 +29837 61901 +15810 61896 +15813 61893 +23117 61892 +17776 61889 +46227 61866 +35357 61862 +35685 61857 +43431 61855 +40129 61852 +40808 61849 +44014 61847 +13096 61846 +42554 61846 +39292 61842 +49002 61837 +22121 61814 +47891 61810 +32925 61807 +26394 61798 +40587 61798 +30721 61796 +15630 61788 +26951 61786 +23336 61766 +32302 61755 +22531 61745 +25781 61738 +23755 61736 +22236 61733 +12043 61731 +36743 61729 +18188 61723 +46072 61722 +39123 61718 +30755 61718 +7829 61705 +41718 61704 +43296 61704 +20010 61702 +34677 61701 +14046 61698 +16991 61697 +37553 61697 +3560 61695 +20676 61692 +42198 61685 +31934 61682 +26879 61678 +15785 61673 +24308 61668 +42356 61666 +22859 61660 +36858 61655 +45402 61650 +31810 61638 +47688 61619 +22703 61619 +17481 61615 +35517 61613 +44410 61596 +35228 61593 +12003 61583 +40349 61581 +29026 61576 +48273 61569 +28218 61562 +38920 61559 +25731 61552 +22655 61546 +32945 61545 +28161 61541 +46611 61534 +45022 61528 +13193 61514 +21056 61506 +47554 61503 +15357 61502 +32757 61495 +31238 61489 +30391 61486 +42518 61482 +24407 61479 +32046 61475 +39244 61451 +24246 61448 +10533 61447 +28082 61441 +35733 61435 +44252 61429 +21868 61424 +31517 61419 +17758 61418 +23236 61418 +12283 61412 +29301 61405 +24925 61402 +45996 61401 +8001 61395 +47727 61390 +36605 61372 +19177 61372 +39094 61368 +26386 61359 +10531 61355 +34166 61355 +32533 61342 +29259 61333 +33917 61333 +33652 61327 +44838 61322 +11977 61317 +41930 61315 +30349 61314 +28357 61311 +34081 61307 +17886 61305 +20266 61299 +6990 61299 +28344 61296 +34264 61290 +29036 61289 +34282 61284 +32202 61283 +14756 61281 +35003 61281 +36246 61280 +19915 61265 +37307 61264 +24312 61257 +32985 61253 +18289 61249 +12332 61245 +17766 61244 +34845 61239 +45369 61233 +30082 61222 +21652 61216 +23695 61211 +33585 61199 +15405 61190 +16081 61188 +15015 61185 +41476 61183 +19590 61181 +23859 61170 +18863 61167 +18490 61161 +11187 61159 +42786 61148 +44843 61148 +27346 61147 +35406 61139 +33867 61134 +44840 61129 +36773 61125 +36432 61123 +50070 61122 +32028 61117 +45562 61116 +12938 61113 +14831 61105 +20942 61104 +13335 61100 +48405 61090 +34226 61088 +8481 61085 +15478 61083 +49748 61083 +21207 61079 +25144 61077 +46286 61073 +31469 61072 +43130 61062 +39822 61061 +25907 61048 +36045 61046 +47561 61037 +22769 61036 +34838 61036 +5424 61034 +38633 61033 +11007 61028 +31083 61025 +20759 61025 +30224 61022 +44914 61021 +22483 61020 +16869 61019 +31788 61019 +19798 61014 +50198 61001 +7355 60988 +21580 60971 +23855 60969 +27135 60966 +48654 60963 +38931 60960 +29194 60955 +40390 60945 +30877 60939 +36405 60929 +42073 60929 +40542 60924 +39772 60914 +30084 60911 +18392 60902 +38822 60895 +46277 60890 +4298 60888 +14049 60881 +32972 60873 +27962 60865 +29716 60851 +11249 60842 +15537 60840 +45005 60835 +26124 60831 +42291 60828 +29461 60826 +26717 60826 +28607 60825 +39161 60824 +36964 60824 +34207 60824 +26457 60816 +5592 60812 +15194 60805 +9158 60805 +21581 60802 +26370 60800 +48937 60796 +18032 60795 +31604 60791 +26340 60789 +1405 60786 +37525 60786 +22320 60783 +38502 60765 +39952 60762 +25738 60756 +32064 60753 +33677 60751 +30873 60749 +22828 60744 +46744 60739 +24217 60738 +29370 60732 +41645 60726 +39656 60717 +48535 60715 +26194 60715 +44288 60714 +23098 60713 +45155 60711 +42226 60701 +46898 60673 +23625 60672 +29862 60671 +48857 60666 +25276 60654 +33681 60648 +28836 60647 +15266 60643 +41852 60638 +13966 60622 +25219 60620 +31600 60617 +31549 60616 +48639 60615 +23089 60611 +47319 60606 +25121 60605 +38554 60603 +29199 60601 +30544 60598 +25221 60595 +17436 60594 +19659 60593 +20022 60593 +28641 60590 +17115 60590 +43599 60589 +15584 60589 +27692 60585 +42183 60566 +15947 60565 +42196 60562 +32392 60560 +25704 60558 +22448 60555 +21932 60549 +24458 60547 +39330 60543 +29537 60537 +32528 60527 +29635 60520 +44997 60518 +45073 60514 +28837 60511 +47802 60499 +46766 60497 +45475 60497 +17020 60484 +14977 60483 +42619 60480 +25906 60478 +30771 60467 +2658 60460 +19814 60460 +47552 60455 +41886 60448 +36106 60444 +47956 60433 +15634 60428 +11577 60425 +20343 60420 +18680 60417 +49984 60413 +28142 60403 +4681 60401 +44790 60400 +40636 60397 +23895 60390 +32745 60388 +46151 60384 +9372 60384 +32874 60383 +32964 60374 +26844 60369 +46193 60365 +18823 60359 +26653 60359 +30942 60355 +37816 60352 +22705 60342 +45194 60327 +44111 60323 +23440 60322 +44358 60319 +27211 60315 +33024 60303 +40917 60302 +35771 60302 +39092 60300 +40769 60294 +19554 60291 +29738 60290 +47403 60284 +30909 60271 +46191 60271 +25546 60261 +32484 60261 +27452 60257 +38965 60250 +13704 60250 +31022 60249 +30063 60249 +46134 60246 +35855 60243 +39829 60238 +4668 60237 +18218 60237 +29542 60233 +37684 60224 +48403 60210 +37470 60207 +12645 60205 +21926 60196 +13764 60195 +16558 60195 +4348 60194 +31939 60194 +27492 60183 +34608 60180 +37159 60179 +48423 60162 +47485 60161 +29556 60161 +39097 60161 +34664 60152 +49200 60151 +37914 60142 +25500 60137 +18549 60126 +28443 60112 +20713 60101 +13894 60095 +25094 60095 +22740 60094 +42441 60086 +43898 60085 +28816 60073 +44949 60068 +45585 60067 +23556 60066 +16983 60058 +28415 60056 +19974 60049 +33511 60047 +44443 60044 +39480 60041 +24250 60038 +30874 60037 +21630 60035 +21831 60035 +18777 60032 +29787 60031 +30393 60023 +38426 60015 +40588 60009 +37240 60004 +2755 59997 +28188 59996 +25996 59996 +29255 59994 +20895 59989 +34146 59983 +41953 59981 +32625 59979 +17248 59979 +5104 59972 +48283 59969 +37391 59969 +37119 59967 +15429 59965 +35020 59965 +30954 59962 +31309 59954 +27782 59938 +6138 59937 +37897 59935 +35122 59932 +26781 59931 +21208 59929 +25639 59924 +39671 59923 +23133 59922 +15120 59920 +33760 59907 +31782 59900 +5080 59899 +44391 59896 +20757 59894 +47148 59891 +35142 59889 +46684 59885 +17792 59884 +32727 59878 +20802 59870 +19679 59863 +36800 59857 +33636 59854 +15716 59853 +2090 59853 +24758 59852 +17806 59850 +32715 59848 +27173 59847 +8490 59846 +27951 59844 +41407 59843 +47919 59843 +20785 59838 +31432 59834 +28214 59832 +30855 59825 +4278 59824 +35647 59823 +32609 59822 +35984 59820 +27312 59812 +11532 59807 +35734 59805 +3752 59802 +22909 59794 +33421 59791 +43923 59788 +22253 59785 +30503 59777 +44525 59772 +34164 59772 +19548 59770 +26258 59768 +16667 59767 +25062 59765 +41161 59755 +17007 59751 +43728 59748 +48269 59743 +7890 59742 +22186 59740 +15627 59733 +20867 59729 +44437 59723 +22017 59722 +31195 59722 +25457 59721 +33775 59719 +44192 59717 +22415 59711 +22631 59708 +42614 59705 +8146 59693 +6564 59688 +22366 59684 +25181 59682 +3692 59681 +11469 59681 +37216 59677 +20403 59676 +36788 59673 +13051 59672 +9777 59668 +39777 59660 +38979 59657 +35101 59653 +31829 59642 +30490 59641 +34311 59634 +33588 59631 +39042 59629 +15086 59629 +42351 59619 +22127 59613 +20446 59613 +32193 59611 +22487 59610 +24696 59607 +23691 59598 +2355 59598 +22470 59594 +30632 59593 +16066 59586 +22994 59578 +18611 59575 +16206 59575 +30720 59574 +19524 59571 +42997 59570 +13759 59568 +44871 59566 +23759 59565 +39909 59558 +21967 59549 +30814 59546 +28416 59542 +15409 59539 +25453 59537 +21444 59536 +41282 59530 +23662 59528 +30447 59521 +42386 59519 +36506 59517 +43084 59516 +31889 59513 +6310 59502 +30860 59487 +43771 59483 +45023 59478 +7019 59472 +44354 59465 +33983 59464 +41790 59457 +6263 59445 +25530 59441 +31321 59441 +32468 59441 +24233 59440 +48130 59438 +19685 59431 +5919 59426 +25904 59423 +29912 59421 +9214 59415 +26412 59413 +31392 59409 +15308 59408 +30030 59404 +24938 59402 +25177 59394 +30113 59390 +39421 59380 +29895 59379 +637 59379 +29731 59377 +25024 59376 +23760 59371 +4924 59370 +47312 59370 +19107 59368 +7978 59362 +26219 59359 +38351 59358 +10015 59354 +49737 59352 +2122 59351 +32814 59351 +9242 59350 +21958 59347 +11086 59347 +35831 59334 +8307 59333 +1425 59327 +36219 59316 +15046 59308 +23752 59307 +18640 59302 +16696 59300 +29491 59298 +21228 59290 +17533 59289 +15625 59288 +42692 59287 +48421 59280 +31831 59278 +23387 59264 +4284 59263 +7896 59262 +24707 59254 +16962 59245 +17963 59238 +34102 59236 +22370 59236 +34365 59235 +44677 59233 +34967 59231 +20476 59229 +21047 59228 +24221 59226 +37604 59224 +10110 59224 +35311 59223 +16331 59221 +24080 59216 +12140 59213 +18287 59204 +28087 59203 +36745 59201 +19933 59201 +46527 59199 +1579 59198 +24873 59187 +11327 59179 +8453 59171 +17280 59162 +38462 59156 +27430 59155 +26029 59149 +32480 59149 +26289 59148 +39720 59144 +25525 59137 +39337 59135 +43675 59128 +37484 59115 +44691 59114 +19943 59106 +32295 59101 +39733 59099 +24544 59095 +43855 59091 +50024 59086 +4288 59084 +4699 59083 +33198 59083 +42541 59070 +46488 59067 +30473 59066 +31922 59065 +28347 59052 +39566 59035 +14255 59033 +42167 59029 +26221 59028 +24314 59027 +34123 59026 +20057 59025 +36866 59020 +14915 59014 +33163 59014 +30519 59013 +13806 59001 +31365 59000 +27091 58999 +29417 58999 +43775 58997 +42290 58994 +27869 58990 +26648 58982 +22025 58979 +37438 58979 +42845 58975 +18756 58971 +46997 58969 +10611 58969 +12494 58967 +40425 58967 +50251 58964 +47686 58963 +20323 58958 +33976 58945 +49486 58945 +37899 58943 +24848 58943 +44660 58932 +15451 58930 +42207 58925 +46089 58925 +30829 58919 +30130 58917 +26855 58915 +33779 58912 +28476 58907 +33009 58904 +34161 58898 +23405 58896 +21185 58889 +41524 58885 +35774 58884 +50089 58880 +43945 58873 +23482 58867 +26241 58853 +24090 58852 +4055 58849 +25751 58830 +21617 58829 +36761 58820 +24889 58820 +42599 58819 +38028 58818 +9809 58816 +47220 58809 +35577 58807 +41556 58807 +27410 58805 +27870 58805 +36608 58803 +24501 58798 +28902 58792 +45083 58791 +38879 58785 +18792 58785 +22579 58780 +22618 58773 +19577 58770 +38223 58764 +41870 58746 +17731 58745 +34818 58744 +25616 58740 +42436 58738 +29237 58738 +35110 58734 +20918 58733 +39459 58725 +28738 58715 +37463 58713 +39812 58709 +46767 58707 +14306 58705 +28783 58701 +20733 58699 +9962 58697 +44236 58696 +23278 58694 +29898 58694 +35209 58689 +34854 58685 +36438 58681 +25804 58680 +46007 58680 +26698 58677 +26875 58672 +22503 58672 +3140 58670 +40894 58669 +16793 58662 +44970 58661 +28844 58652 +34988 58638 +40442 58638 +33269 58635 +15147 58634 +29327 58633 +21695 58622 +20368 58617 +30485 58613 +40934 58611 +40389 58609 +21935 58608 +32141 58606 +31155 58593 +46463 58590 +35374 58589 +41701 58588 +30588 58588 +7556 58582 +35651 58581 +48014 58574 +10951 58573 +22775 58569 +20839 58564 +42994 58559 +41643 58555 +21887 58552 +22217 58545 +39291 58543 +26031 58542 +2455 58537 +25966 58536 +33596 58532 +46123 58530 +45633 58527 +35719 58524 +36830 58521 +41480 58517 +20058 58513 +23303 58513 +31095 58511 +40950 58509 +28317 58508 +18050 58492 +44108 58487 +36642 58468 +19655 58465 +41457 58463 +27562 58462 +33085 58453 +39871 58444 +19296 58443 +30937 58443 +7162 58440 +26877 58436 +23182 58431 +44848 58423 +9228 58421 +21529 58418 +44493 58418 +24040 58414 +36457 58410 +40929 58405 +3639 58404 +26880 58403 +3490 58403 +12282 58393 +30726 58389 +36514 58387 +42293 58387 +42928 58378 +26658 58374 +32215 58370 +10199 58369 +31698 58368 +37824 58366 +25432 58364 +35717 58359 +24490 58347 +20644 58343 +29493 58341 +47328 58335 +26061 58334 +49457 58333 +3796 58323 +14164 58318 +30002 58318 +36586 58317 +26986 58314 +28606 58312 +22040 58310 +43989 58306 +14019 58297 +24421 58293 +7483 58288 +18850 58283 +17627 58279 +35014 58255 +32881 58255 +12137 58253 +39708 58249 +20632 58244 +27010 58234 +49318 58218 +9896 58209 +19924 58190 +33315 58190 +40665 58189 +49537 58186 +28305 58184 +6020 58183 +23694 58181 +50135 58179 +41213 58174 +30275 58170 +44559 58165 +36944 58162 +40264 58158 +30853 58143 +41034 58141 +30051 58128 +25108 58126 +21326 58123 +40424 58118 +47665 58118 +26100 58118 +26186 58117 +33824 58116 +21002 58116 +19567 58105 +19420 58099 +31818 58099 +47928 58097 +31403 58095 +34851 58094 +17259 58085 +23649 58080 +4612 58079 +49622 58074 +27306 58073 +23961 58067 +17213 58060 +23112 58048 +41326 58037 +26668 58033 +32872 58029 +38302 58027 +32333 58025 +27931 58021 +37915 58020 +47689 58020 +45239 58013 +21290 58011 +28429 58011 +16841 58007 +26582 58002 +46451 58002 +32483 58001 +24178 57999 +30607 57998 +38493 57996 +40915 57983 +38099 57982 +48453 57976 +43474 57970 +37051 57967 +24260 57964 +25798 57964 +32095 57962 +34056 57956 +29861 57953 +21554 57950 +23179 57940 +8448 57938 +23810 57932 +36162 57927 +10483 57927 +40977 57926 +44150 57920 +28502 57918 +45587 57910 +21422 57909 +30592 57908 +32613 57895 +13623 57890 +37599 57890 +42127 57890 +26969 57887 +18368 57885 +21265 57877 +27268 57871 +29345 57862 +20709 57862 +45775 57858 +46278 57852 +16969 57849 +16799 57847 +37718 57845 +1859 57835 +39257 57835 +32677 57812 +23258 57812 +36896 57812 +15710 57809 +34177 57809 +14721 57805 +41429 57804 +19591 57799 +30239 57797 +37976 57793 +33871 57788 +35654 57781 +33555 57780 +24725 57779 +20477 57769 +29652 57766 +2966 57764 +37562 57760 +15898 57751 +24228 57750 +13010 57750 +11159 57746 +9851 57740 +48591 57739 +40228 57735 +16475 57733 +34552 57731 +46691 57726 +35589 57719 +37538 57717 +3333 57717 +46905 57712 +24521 57712 +32453 57712 +29361 57708 +36292 57703 +23706 57697 +48500 57690 +24560 57689 +24082 57684 +37356 57680 +34010 57679 +5507 57677 +31449 57675 +36583 57673 +21239 57664 +25260 57662 +5656 57660 +43310 57659 +45031 57659 +39828 57655 +39619 57654 +26192 57654 +7540 57648 +27163 57642 +39722 57639 +8675 57634 +30176 57634 +28451 57630 +42417 57625 +20730 57612 +38175 57608 +31522 57604 +29405 57604 +31421 57592 +38242 57585 +49165 57573 +46507 57569 +30415 57568 +33611 57531 +9493 57527 +30300 57527 +41648 57526 +21606 57519 +30775 57514 +29254 57513 +33285 57511 +29955 57497 +47458 57491 +17701 57484 +28882 57476 +25913 57473 +28885 57472 +26798 57469 +10641 57466 +46368 57462 +49325 57455 +34356 57454 +39616 57454 +28539 57452 +14322 57451 +21169 57445 +25631 57441 +34029 57439 +20450 57438 +41045 57437 +30524 57435 +7956 57430 +43701 57424 +36644 57420 +31265 57420 +40718 57412 +5663 57408 +34034 57406 +17855 57404 +32521 57402 +29151 57392 +45108 57388 +36541 57386 +28506 57372 +37751 57368 +19200 57366 +6540 57363 +13102 57358 +23244 57352 +9956 57349 +20752 57346 +2796 57338 +21960 57327 +21593 57325 +27684 57319 +34954 57316 +28602 57313 +30255 57309 +9503 57289 +92 57268 +35622 57267 +34763 57264 +23603 57258 +39654 57255 +20151 57254 +33265 57249 +47879 57242 +10841 57235 +45496 57232 +24070 57230 +33658 57225 +34262 57220 +28521 57218 +35113 57216 +33835 57211 +32906 57205 +7213 57201 +11417 57197 +14270 57194 +31977 57187 +17950 57178 +38045 57170 +42368 57164 +4799 57161 +26042 57158 +40837 57146 +29265 57144 +14455 57141 +48714 57140 +21976 57126 +23601 57117 +25541 57116 +24494 57115 +15327 57113 +43999 57107 +7640 57103 +35437 57099 +36327 57091 +37352 57086 +10055 57082 +14269 57078 +44978 57077 +44333 57074 +44042 57065 +34735 57059 +31734 57056 +32679 57052 +32132 57050 +38814 57042 +5233 57039 +2131 57037 +23349 57036 +23713 57034 +38935 57024 +7549 57023 +39255 57022 +36205 57015 +23181 57007 +12392 57000 +4611 56997 +47697 56991 +10445 56985 +46884 56981 +30132 56975 +15412 56974 +16899 56965 +7757 56961 +30042 56960 +43349 56955 +35006 56948 +45966 56948 +25004 56945 +14274 56929 +29267 56926 +31027 56918 +23164 56918 +24182 56915 +25292 56902 +24928 56902 +29360 56900 +44343 56899 +42476 56895 +32701 56892 +36995 56889 +34428 56886 +25509 56886 +41430 56885 +2571 56885 +45774 56882 +18911 56874 +14603 56874 +43748 56867 +45247 56860 +29229 56854 +29466 56847 +30761 56839 +44128 56834 +35786 56825 +43379 56824 +24338 56822 +23666 56814 +28980 56814 +24760 56811 +45658 56806 +42627 56806 +20779 56803 +30777 56791 +37610 56790 +38244 56789 +21688 56787 +8467 56787 +47609 56787 +47518 56786 +17539 56785 +23292 56784 +25677 56778 +6331 56778 +12410 56776 +4182 56760 +22580 56753 +23153 56752 +46429 56749 +37439 56748 +2715 56743 +23848 56742 +25565 56740 +27605 56739 +39490 56731 +22156 56730 +18459 56725 +26497 56719 +41898 56715 +25325 56711 +41252 56710 +18967 56709 +44483 56703 +35658 56701 +44019 56697 +35362 56684 +38435 56682 +43479 56681 +47186 56681 +45644 56679 +27762 56677 +37884 56675 +30935 56659 +25309 56658 +6959 56658 +29456 56655 +28639 56646 +31731 56635 +49627 56635 +32774 56628 +10855 56627 +21450 56620 +25266 56612 +30508 56607 +37990 56606 +30179 56602 +14920 56602 +29653 56601 +26718 56596 +48988 56590 +26744 56589 +41778 56586 +37373 56586 +11944 56581 +21584 56570 +37761 56569 +13978 56568 +22395 56567 +21795 56564 +14565 56563 +9610 56556 +45795 56554 +16465 56554 +40421 56554 +38423 56551 +28625 56551 +22595 56550 +45209 56538 +28903 56537 +20938 56528 +6003 56526 +49197 56525 +20467 56516 +26980 56515 +44718 56514 +37318 56513 +26274 56511 +25398 56509 +18111 56505 +26771 56503 +44500 56502 +36791 56501 +15078 56500 +39845 56496 +8443 56486 +45400 56483 +16571 56481 +31395 56477 +36096 56475 +15157 56474 +36656 56459 +20694 56450 +25421 56435 +15170 56430 +24913 56430 +27479 56430 +27592 56429 +9444 56424 +39406 56421 +23097 56418 +11970 56414 +38608 56412 +33340 56409 +43425 56406 +15729 56403 +19197 56400 +15721 56391 +1783 56378 +27719 56373 +43995 56372 +37954 56368 +28109 56358 +35803 56358 +33482 56352 +35337 56350 +32882 56344 +4815 56338 +39034 56337 +47608 56334 +33181 56327 +20806 56323 +21295 56321 +28593 56319 +44067 56314 +16909 56311 +49037 56310 +22986 56305 +29452 56304 +24662 56297 +9682 56294 +47015 56286 +24831 56285 +7349 56285 +36074 56282 +33973 56279 +32736 56278 +22638 56278 +11645 56278 +26379 56277 +12663 56274 +18846 56271 +38398 56269 +42158 56265 +42395 56261 +41120 56258 +49842 56258 +48781 56253 +32254 56248 +47012 56247 +22196 56247 +5944 56245 +21755 56232 +30033 56219 +47164 56219 +20798 56212 +28633 56207 +19363 56204 +39451 56202 +40559 56195 +20807 56192 +20831 56189 +37198 56188 +21783 56184 +33736 56183 +32472 56179 +38583 56177 +28916 56177 +38820 56176 +40088 56171 +30668 56136 +20281 56136 +47586 56130 +18271 56125 +9685 56124 +25769 56120 +11190 56116 +33946 56112 +39630 56109 +32578 56106 +27079 56102 +12632 56092 +11402 56091 +29957 56084 +16199 56073 +29406 56069 +36448 56063 +45942 56060 +26271 56059 +19932 56054 +40870 56054 +27217 56052 +7015 56046 +33600 56044 +33255 56038 +11865 56033 +25280 56033 +26444 56031 +25696 56031 +2065 56019 +45897 56008 +17459 56005 +6008 56004 +11671 56003 +44366 56001 +24041 55998 +1488 55996 +32530 55992 +35923 55988 +11218 55985 +31599 55983 +30080 55976 +21693 55973 +43811 55970 +40745 55968 +33247 55956 +33907 55953 +30069 55944 +11194 55942 +14036 55942 +25466 55940 +36610 55939 +37121 55938 +3391 55932 +21074 55932 +28286 55931 +39965 55927 +26384 55926 +12752 55921 +16814 55920 +22613 55915 +15096 55898 +16670 55896 +25190 55889 +29871 55885 +18603 55880 +27134 55878 +15051 55871 +17878 55869 +43859 55861 +7315 55860 +35326 55852 +11522 55852 +5378 55849 +27364 55837 +27107 55833 +35210 55831 +19311 55830 +18879 55824 +5955 55818 +23523 55816 +26009 55814 +32848 55813 +5015 55811 +26509 55809 +23159 55806 +44250 55802 +3346 55802 +29802 55802 +24369 55802 +40855 55798 +28090 55795 +39205 55793 +26974 55791 +28359 55790 +13984 55790 +37714 55786 +29663 55782 +24993 55780 +20768 55775 +19334 55762 +49112 55756 +37084 55748 +42408 55740 +10570 55739 +27845 55732 +37329 55724 +16927 55723 +23729 55720 +4311 55715 +17622 55707 +42760 55700 +37325 55691 +7293 55688 +20981 55688 +16340 55686 +34632 55682 +36070 55679 +14500 55678 +50066 55675 +25148 55670 +14652 55668 +20436 55668 +25390 55658 +29385 55652 +39670 55647 +24718 55646 +23243 55641 +23208 55638 +26012 55637 +18993 55632 +37514 55622 +46049 55621 +29527 55618 +30038 55617 +21054 55616 +19770 55610 +24984 55608 +11572 55606 +32710 55597 +36512 55593 +23604 55588 +39343 55587 +39150 55583 +41069 55580 +28829 55578 +28034 55573 +28046 55565 +41950 55564 +41328 55563 +24420 55562 +32151 55558 +43653 55551 +25068 55547 +29093 55545 +32560 55544 +38808 55541 +45851 55541 +45982 55540 +43308 55535 +21579 55532 +25036 55520 +34110 55510 +47261 55508 +41764 55506 +10482 55505 +33627 55504 +20937 55497 +6720 55495 +48968 55483 +22228 55479 +20073 55476 +24651 55475 +41046 55474 +43858 55473 +2023 55471 +42221 55463 +19630 55459 +40776 55457 +23678 55455 +25411 55446 +28713 55443 +43042 55438 +22853 55436 +38400 55433 +33025 55431 +49108 55431 +18676 55426 +24588 55426 +35106 55418 +44923 55414 +24720 55411 +30276 55404 +43688 55403 +27675 55399 +12668 55398 +40801 55396 +37708 55386 +33839 55382 +19008 55378 +5547 55375 +25749 55373 +24706 55368 +10333 55361 +18239 55361 +26917 55359 +26452 55350 +33710 55348 +26494 55342 +38927 55341 +26521 55341 +36132 55339 +30423 55339 +30912 55336 +42573 55334 +36989 55319 +1159 55317 +26785 55317 +25179 55316 +6254 55315 +9886 55315 +37322 55315 +41360 55313 +32084 55306 +4215 55303 +21093 55295 +41817 55292 +42431 55288 +35924 55287 +36440 55283 +37254 55279 +36778 55270 +41683 55269 +28203 55268 +21836 55268 +28580 55267 +19569 55260 +33848 55259 +28563 55259 +36358 55240 +39350 55237 +38102 55229 +29981 55228 +34840 55222 +37728 55218 +49375 55217 +12582 55217 +28385 55203 +44385 55201 +9606 55200 +27903 55194 +42334 55191 +34395 55188 +13349 55188 +29089 55184 +24773 55181 +34629 55179 +30020 55178 +38651 55178 +3380 55177 +24051 55176 +35935 55175 +38191 55172 +27224 55154 +17866 55153 +46107 55151 +37206 55147 +37314 55142 +28295 55130 +27414 55129 +39206 55129 +46362 55127 +12613 55119 +24013 55119 +37465 55110 +46849 55105 +46132 55100 +43911 55096 +30204 55092 +44470 55088 +33388 55088 +14854 55084 +43881 55084 +15227 55080 +28450 55073 +44922 55068 +24815 55067 +21478 55067 +49696 55063 +19402 55060 +28273 55059 +24119 55057 +31375 55056 +26646 55054 +30013 55048 +29009 55044 +50106 55032 +22153 55030 +35130 55022 +47545 55019 +49006 55019 +39019 55013 +31878 54992 +37745 54990 +9731 54987 +2786 54984 +1237 54980 +15084 54978 +18908 54970 +37808 54965 +38283 54963 +32327 54961 +36066 54961 +37752 54960 +35860 54960 +40931 54957 +33517 54955 +37768 54955 +21748 54952 +22584 54951 +27362 54948 +49570 54941 +23507 54936 +21192 54934 +34012 54933 +3604 54928 +49407 54927 +39834 54919 +32111 54909 +46921 54896 +35546 54890 +38730 54887 +33291 54885 +14578 54872 +30623 54867 +34905 54864 +13402 54851 +25365 54845 +45747 54842 +41352 54842 +24053 54840 +43997 54836 +33466 54832 +36274 54831 +28423 54820 +27704 54818 +24071 54814 +28616 54814 +5554 54807 +1945 54798 +29914 54797 +41493 54795 +19851 54794 +32502 54786 +31087 54777 +24673 54771 +49247 54770 +27043 54766 +24039 54762 +19980 54751 +30902 54750 +40513 54747 +49195 54742 +44282 54741 +6962 54740 +33446 54738 +42397 54735 +49185 54735 +31501 54730 +35368 54728 +34573 54726 +41454 54719 +16417 54718 +16422 54702 +42239 54701 +38337 54695 +18681 54683 +1442 54682 +45813 54682 +6329 54675 +11965 54674 +41875 54669 +42803 54656 +47692 54656 +14906 54654 +18349 54651 +29579 54648 +7046 54648 +30696 54642 +30229 54641 +37113 54638 +28568 54637 +47470 54636 +29689 54632 +23917 54627 +38031 54626 +44117 54623 +17848 54622 +49873 54615 +15655 54615 +43052 54614 +158 54613 +7106 54607 +6395 54603 +22995 54602 +30522 54599 +30827 54589 +35233 54585 +35573 54579 +32281 54578 +31174 54577 +3787 54571 +34782 54569 +33201 54556 +44864 54556 +31413 54556 +6474 54555 +50219 54539 +22699 54535 +2210 54524 +4163 54521 +30357 54521 +27142 54520 +24646 54519 +28572 54516 +29673 54514 +23135 54512 +32387 54512 +16279 54498 +43251 54489 +6775 54488 +24571 54483 +33799 54482 +22963 54472 +16661 54472 +46116 54471 +38796 54465 +15851 54456 +37305 54454 +27101 54452 +33630 54448 +42857 54446 +43593 54445 +18148 54437 +29128 54422 +27721 54421 +17046 54415 +26210 54413 +20483 54411 +48994 54409 +31884 54408 +16945 54405 +23452 54403 +36232 54402 +19839 54401 +30413 54400 +11227 54394 +37551 54379 +13875 54376 +26637 54372 +13691 54362 +17458 54359 +21626 54349 +26808 54348 +19880 54341 +25806 54340 +10687 54336 +27695 54334 +34958 54334 +42971 54330 +42718 54327 +29850 54320 +20279 54312 +28682 54304 +38964 54284 +42358 54281 +31998 54278 +31531 54265 +29983 54262 +19179 54261 +40153 54257 +33124 54257 +3145 54254 +10845 54253 +25229 54249 +2418 54241 +25288 54238 +13649 54236 +29243 54236 +1684 54235 +27864 54231 +30386 54227 +41758 54226 +17008 54222 +46194 54218 +26819 54216 +17693 54216 +9633 54216 +40457 54213 +12830 54211 +49862 54210 +29704 54209 +13268 54209 +22405 54207 +40514 54205 +6780 54204 +25695 54200 +8600 54185 +42626 54183 +17380 54181 +25360 54178 +15581 54176 +35082 54174 +39585 54163 +30953 54160 +16371 54148 +28849 54147 +16653 54143 +10867 54143 +16491 54137 +38716 54134 +27888 54133 +49637 54129 +19780 54129 +13409 54124 +6718 54118 +8570 54118 +23048 54115 +25501 54100 +37408 54097 +31075 54093 +13436 54090 +39095 54089 +30064 54085 +33584 54078 +20931 54076 +16272 54070 +36188 54070 +42658 54069 +31003 54068 +39543 54067 +47404 54064 +16360 54062 +23375 54058 +25478 54054 +38886 54052 +6800 54049 +28729 54035 +7537 54035 +43968 54033 +45488 54033 +41262 54032 +22819 54032 +25006 54032 +49179 54032 +45159 54028 +42813 54028 +14951 54027 +15385 54026 +20609 54023 +24888 54021 +46346 54011 +25473 54010 +32595 54009 +35605 54006 +22792 54005 +46924 53997 +15003 53994 +49980 53992 +19004 53991 +9037 53986 +40727 53986 +18861 53980 +41314 53971 +22965 53970 +44953 53968 +32807 53966 +30740 53952 +47137 53950 +26903 53934 +27996 53933 +42157 53933 +40595 53933 +30690 53932 +22220 53931 +12496 53928 +5560 53928 +41440 53923 +36847 53922 +24046 53919 +19216 53915 +37264 53915 +38510 53911 +24810 53909 +24124 53906 +16283 53900 +37476 53899 +26143 53896 +45524 53883 +29889 53882 +35606 53878 +14599 53877 +22373 53874 +31465 53866 +31670 53855 +27395 53855 +44348 53848 +23011 53847 +14618 53847 +46081 53846 +34208 53839 +2916 53837 +24785 53828 +47358 53827 +45861 53821 +28285 53818 +40570 53809 +12907 53808 +37079 53803 +42569 53792 +18882 53788 +29729 53785 +18444 53782 +34047 53777 +28746 53774 +35159 53772 +23989 53771 +16702 53767 +34470 53762 +9767 53761 +21875 53758 +36909 53757 +42077 53751 +19641 53747 +40497 53744 +30767 53737 +15106 53732 +30220 53732 +37009 53730 +29154 53726 +13039 53723 +693 53718 +23069 53718 +29959 53714 +42211 53714 +26359 53711 +3655 53710 +30048 53694 +28790 53688 +28701 53687 +42427 53682 +33773 53681 +35196 53676 +42916 53673 +8544 53661 +37063 53660 +26893 53655 +44633 53654 +19156 53654 +35019 53645 +40355 53644 +23408 53643 +21378 53639 +29109 53638 +21252 53638 +16984 53632 +27078 53629 +39712 53628 +24896 53624 +17017 53619 +26788 53616 +38870 53615 +12072 53614 +35730 53613 +34216 53613 +43459 53609 +20247 53600 +19145 53600 +5738 53598 +28023 53598 +11505 53582 +30545 53572 +21949 53572 +22974 53571 +11802 53566 +26600 53561 +28932 53556 +23419 53553 +43022 53552 +26300 53550 +22711 53549 +1932 53546 +32650 53542 +36892 53536 +33846 53534 +34527 53531 +9453 53529 +24343 53528 +2133 53526 +26408 53521 +19482 53516 +40598 53513 +34858 53513 +29944 53509 +23499 53509 +40332 53509 +13653 53506 +30135 53503 +29724 53501 +19648 53498 +49383 53497 +45483 53495 +4344 53489 +26837 53478 +35413 53477 +30630 53469 +25025 53464 +40924 53457 +30686 53455 +34292 53453 +29932 53445 +32693 53445 +40447 53439 +44886 53438 +25607 53437 +47461 53435 +46233 53432 +45680 53429 +45777 53428 +20225 53424 +25805 53422 +42568 53421 +34491 53420 +19708 53419 +39028 53418 +33506 53415 +23304 53414 +27804 53410 +36747 53397 +29219 53395 +28678 53393 +26910 53391 +35583 53388 +38264 53387 +45517 53387 +27926 53385 +7181 53382 +45088 53382 +48854 53378 +28805 53378 +31390 53376 +41027 53375 +22890 53369 +28898 53368 +29576 53368 +44178 53364 +21654 53362 +24764 53356 +49019 53352 +24977 53350 +49134 53349 +14120 53348 +48886 53346 +45263 53346 +29117 53341 +24502 53339 +20107 53335 +37105 53333 +33565 53329 +24691 53326 +21870 53320 +47756 53316 +40377 53314 +37896 53313 +42645 53308 +22910 53306 +38934 53284 +26770 53282 +38039 53278 +12398 53275 +37406 53273 +29481 53269 +10244 53259 +35138 53258 +25596 53250 +22464 53242 +48209 53237 +14344 53233 +46269 53231 +45676 53229 +16149 53216 +15200 53214 +6689 53213 +27433 53210 +26074 53207 +47216 53205 +29762 53200 +15952 53198 +7249 53195 +26306 53194 +26827 53185 +28554 53185 +22495 53185 +2226 53182 +35023 53182 +31645 53181 +23199 53180 +27482 53178 +34599 53178 +20191 53177 +33067 53174 +44404 53171 +34666 53171 +30792 53170 +47974 53170 +16886 53170 +32150 53168 +50151 53164 +34070 53163 +39133 53148 +22577 53145 +43588 53145 +25503 53145 +24556 53143 +26270 53130 +37890 53124 +12514 53120 +17379 53106 +13200 53101 +25610 53099 +34671 53093 +140 53091 +45078 53087 +27654 53083 +21910 53078 +42404 53064 +18232 53057 +28669 53054 +46929 53051 +19329 53049 +25336 53042 +41746 53036 +34304 53034 +43092 53028 +22478 53022 +20465 53014 +32420 53012 +22042 53003 +12067 53001 +41535 53000 +27601 52999 +36364 52989 +39127 52985 +5569 52983 +28436 52975 +13450 52973 +35287 52972 +36601 52968 +28947 52967 +29028 52961 +47714 52961 +21467 52957 +244 52954 +29624 52945 +20845 52944 +34502 52941 +35980 52941 +30392 52936 +28005 52935 +26926 52930 +23536 52926 +48320 52918 +40471 52914 +29030 52908 +44870 52900 +45183 52897 +47499 52897 +2009 52895 +26133 52884 +29883 52883 +31445 52877 +25754 52873 +34579 52856 +43809 52853 +40583 52852 +41074 52852 +36444 52850 +31405 52844 +15087 52843 +43657 52840 +21905 52838 +31363 52837 +48498 52832 +42453 52829 +21129 52825 +39730 52824 +16843 52823 +32104 52822 +16072 52816 +44588 52815 +31541 52815 +12154 52809 +20219 52802 +34383 52800 +16021 52799 +5343 52799 +14355 52789 +39083 52788 +24109 52785 +39569 52775 +20029 52769 +46133 52765 +41731 52761 +12628 52748 +40753 52744 +10489 52743 +24235 52736 +34234 52736 +28518 52736 +22659 52725 +43738 52724 +27360 52720 +33667 52719 +35918 52717 +6826 52717 +30301 52717 +22817 52715 +426 52710 +34260 52700 +35782 52699 +43524 52693 +7289 52692 +26708 52692 +32325 52690 +39465 52687 +44610 52686 +1391 52686 +22624 52685 +32162 52667 +46034 52666 +40847 52662 +42805 52661 +18896 52661 +14400 52660 +37928 52659 +18673 52648 +23146 52640 +27429 52639 +22416 52632 +40212 52625 +33719 52625 +33305 52619 +21616 52619 +27544 52595 +21940 52589 +28251 52588 +9076 52588 +40789 52577 +28007 52574 +42058 52572 +33906 52563 +25138 52560 +33050 52558 +25879 52557 +47535 52556 +39983 52546 +22629 52543 +25304 52537 +40302 52527 +31609 52523 +21937 52520 +14849 52518 +18754 52518 +39435 52515 +48378 52513 +21874 52510 +21696 52510 +32673 52504 +45215 52500 +35510 52499 +45910 52497 +27834 52496 +33731 52489 +35118 52483 +28308 52479 +33757 52476 +30500 52475 +28610 52464 +41559 52463 +24680 52451 +44663 52449 +32932 52449 +17472 52447 +31177 52443 +43934 52431 +16442 52430 +48115 52429 +20348 52427 +40851 52424 +28131 52421 +33364 52420 +21103 52419 +43348 52417 +19184 52416 +27152 52410 +22672 52409 +45059 52406 +40151 52402 +4443 52397 +49270 52393 +36000 52391 +29541 52391 +23444 52390 +13147 52384 +46837 52383 +29622 52383 +23609 52379 +35239 52370 +36317 52362 +2255 52360 +2162 52359 +11275 52357 +49362 52356 +30791 52352 +27406 52346 +31825 52344 +42152 52339 +24982 52336 +22124 52336 +28739 52334 +19545 52332 +32783 52327 +41772 52322 +24813 52321 +31638 52319 +35146 52312 +10624 52311 +20032 52310 +50050 52305 +45867 52302 +48249 52302 +32631 52298 +8506 52297 +33158 52291 +32063 52290 +20370 52286 +19948 52285 +3172 52285 +19473 52284 +49661 52284 +23656 52278 +32262 52270 +23908 52268 +9943 52263 +33093 52257 +21311 52257 +32784 52257 +32554 52256 +37358 52253 +32911 52252 +41077 52248 +31969 52246 +26749 52244 +33348 52244 +37370 52235 +42724 52234 +23127 52234 +41546 52229 +9741 52228 +24869 52222 +29574 52220 +45594 52219 +47905 52217 +41594 52214 +22234 52206 +34180 52205 +24297 52203 +40476 52201 +23871 52200 +14885 52199 +15245 52190 +7086 52188 +24727 52183 +28581 52180 +6845 52180 +21379 52176 +24354 52173 +11042 52171 +30645 52170 +11712 52166 +14656 52159 +40879 52156 +22209 52156 +47318 52152 +46212 52149 +42433 52143 +21600 52139 +11883 52139 +21657 52137 +25928 52133 +36912 52131 +38252 52126 +35025 52123 +22450 52118 +36846 52117 +29617 52111 +42710 52110 +30993 52108 +26339 52103 +48334 52095 +20135 52089 +19058 52087 +47058 52085 +21671 52085 +21972 52077 +41085 52076 +43276 52074 +42236 52065 +36455 52063 +38479 52063 +34762 52062 +31967 52061 +26760 52058 +24653 52055 +24551 52052 +31420 52051 +32598 52048 +13034 52046 +20549 52045 +10743 52042 +16455 52038 +1905 52035 +8172 52034 +21717 52032 +42888 52026 +34172 52023 +13240 52016 +17164 52015 +27124 52015 +9083 52013 +32857 52002 +39732 52001 +25090 52000 +32837 51993 +17310 51987 +27089 51983 +28939 51981 +21095 51980 +35107 51967 +28139 51965 +35865 51963 +43423 51955 +23462 51949 +46584 51949 +26179 51944 +28030 51942 +40084 51942 +5240 51939 +20764 51937 +46595 51936 +31328 51936 +35849 51934 +45415 51932 +35031 51930 +37089 51917 +43867 51914 +25441 51904 +19918 51896 +13660 51895 +27394 51894 +42640 51893 +48576 51891 +24652 51885 +47647 51872 +34537 51870 +20123 51868 +19973 51868 +25049 51866 +38458 51864 +32931 51863 +33332 51860 +30821 51858 +38309 51853 +29853 51842 +44194 51831 +25237 51830 +21440 51828 +40676 51823 +44703 51823 +25209 51822 +19617 51821 +28504 51820 +22440 51819 +11858 51811 +38207 51809 +35690 51803 +22583 51802 +31665 51800 +23395 51795 +38695 51794 +36134 51789 +47983 51788 +30170 51788 +41675 51786 +17550 51784 +40500 51782 +9994 51782 +22521 51779 +34477 51778 +21963 51777 +47972 51777 +37237 51767 +25917 51765 +33473 51765 +22850 51763 +31933 51763 +19835 51763 +37789 51761 +31874 51757 +36780 51755 +1599 51750 +37468 51740 +29366 51740 +36289 51731 +34392 51731 +47290 51722 +33259 51719 +16658 51714 +32384 51713 +17941 51713 +14390 51703 +23904 51703 +19955 51700 +38736 51694 +42609 51694 +33865 51693 +40426 51673 +7005 51663 +11590 51655 +38597 51652 +20418 51644 +14020 51643 +33401 51643 +44956 51638 +32543 51626 +48722 51623 +36426 51621 +31888 51616 +4728 51615 +48946 51612 +19971 51611 +5809 51604 +34426 51599 +19619 51599 +43976 51593 +15288 51591 +31378 51588 +33841 51587 +27073 51583 +45552 51582 +28719 51582 +33275 51581 +23169 51580 +33134 51573 +27978 51572 +18942 51572 +49068 51570 +28178 51569 +33575 51569 +20389 51560 +8140 51560 +39246 51558 +26942 51555 +1991 51554 +12405 51541 +33002 51539 +34358 51531 +46795 51531 +4555 51518 +36283 51518 +31236 51518 +11600 51509 +42729 51506 +9171 51503 +25579 51502 +814 51501 +49408 51493 +13341 51489 +41575 51489 +41698 51484 +23469 51467 +47680 51463 +15612 51463 +27979 51458 +50054 51457 +44459 51457 +37557 51452 +18738 51450 +27795 51448 +8010 51447 +30580 51441 +21174 51434 +45978 51434 +30878 51425 +32283 51425 +44537 51420 +42179 51416 +30059 51408 +29567 51407 +25643 51404 +24976 51403 +26507 51402 +45316 51399 +36775 51395 +47706 51393 +27635 51393 +45744 51392 +17831 51391 +39561 51387 +17993 51384 +13358 51383 +49474 51382 +32379 51378 +40124 51370 +26466 51368 +21386 51368 +13563 51360 +49470 51355 +26666 51353 +31935 51352 +30594 51351 +10455 51345 +31663 51333 +46413 51331 +27001 51329 +45047 51329 +24826 51328 +36224 51313 +27062 51308 +47451 51304 +44882 51300 +36168 51297 +38290 51296 +46184 51291 +36129 51291 +22818 51284 +46892 51280 +18347 51273 +20106 51271 +3983 51270 +25326 51268 +38916 51261 +16724 51260 +46685 51260 +14059 51259 +31822 51256 +25337 51255 +13776 51255 +36464 51245 +45962 51245 +47474 51241 +16961 51238 +10293 51234 +25829 51227 +32959 51227 +44413 51224 +47437 51223 +16240 51217 +21786 51209 +9844 51209 +29754 51205 +45651 51197 +19970 51179 +22134 51177 +9339 51165 +34996 51164 +37319 51155 +24431 51155 +17489 51153 +47225 51146 +20809 51141 +28942 51141 +33733 51140 +30274 51139 +30346 51138 +36856 51134 +19365 51129 +26405 51124 +28053 51104 +29227 51103 +13247 51102 +24555 51100 +25080 51088 +18486 51085 +23983 51085 +24900 51081 +39386 51079 +21526 51079 +25761 51078 +35294 51075 +28621 51071 +30137 51062 +34557 51061 +34501 51061 +41715 51057 +15370 51052 +30436 51050 +31582 51049 +41088 51049 +39774 51047 +50214 51040 +25916 51040 +44322 51029 +38656 51025 +40794 51024 +37194 51021 +27627 51020 +16939 51015 +24931 51014 +29440 51010 +32306 51008 +37803 51007 +34246 51006 +41135 51002 +35949 50997 +29296 50997 +1066 50992 +2738 50991 +36250 50981 +38026 50975 +48133 50974 +40603 50972 +22308 50965 +36433 50954 +17328 50953 +9843 50953 +32090 50951 +5251 50944 +44851 50934 +23044 50932 +28750 50925 +34130 50924 +11141 50919 +28241 50917 +20706 50916 +3590 50913 +24953 50912 +24417 50908 +38000 50905 +44044 50905 +35864 50898 +7146 50894 +27826 50894 +8021 50891 +48694 50888 +48756 50887 +35595 50885 +36312 50870 +25291 50855 +15547 50852 +31459 50850 +44998 50845 +41191 50841 +9219 50826 +16437 50813 +32792 50812 +14878 50805 +7512 50797 +25037 50796 +30158 50787 +23534 50784 +46760 50782 +12215 50775 +40304 50772 +45926 50771 +14535 50770 +48470 50762 +33586 50761 +8715 50761 +34678 50761 +34531 50760 +39636 50758 +149 50753 +14587 50750 +24570 50749 +15701 50748 +48684 50747 +38494 50732 +34933 50731 +45221 50726 +28471 50726 +29097 50723 +41329 50723 +39554 50718 +48664 50712 +32766 50697 +28210 50694 +6519 50692 +7053 50688 +17966 50686 +28895 50684 +39517 50683 +33836 50671 +14753 50663 +35280 50660 +8422 50654 +18424 50653 +7489 50648 +21766 50645 +49554 50637 +34890 50631 +14677 50628 +41598 50626 +24550 50623 +40975 50623 +14250 50622 +22334 50622 +18407 50613 +7860 50598 +26298 50597 +38336 50596 +17139 50591 +34723 50591 +19260 50591 +32244 50586 +19950 50581 +32740 50577 +48506 50573 +37843 50572 +23568 50571 +15513 50571 +27351 50564 +30778 50556 +37671 50554 +21081 50550 +21973 50548 +8927 50545 +23016 50544 +26633 50537 +2519 50537 +2452 50533 +46985 50530 +29176 50521 +11217 50514 +24140 50505 +45683 50504 +26434 50502 +42908 50502 +22881 50500 +37005 50484 +49411 50476 +25762 50476 +27318 50473 +28866 50470 +38236 50468 +23053 50467 +7528 50466 +30862 50464 +45808 50462 +12832 50455 +43943 50448 +44833 50448 +47930 50444 +7983 50440 +46117 50435 +37069 50427 +27150 50422 +12935 50421 +31132 50418 +37315 50417 +29387 50414 +28548 50413 +33091 50413 +36816 50412 +36497 50409 +16142 50409 +28754 50402 +27014 50395 +36494 50392 +46234 50389 +21044 50387 +29480 50380 +43183 50377 +27338 50373 +18833 50371 +31679 50370 +31109 50367 +27168 50366 +22654 50362 +33474 50355 +25047 50354 +30865 50354 +34291 50353 +33343 50348 +26250 50345 +36994 50342 +41379 50341 +26929 50336 +24464 50328 +35515 50322 +26477 50320 +33955 50315 +14633 50314 +47908 50314 +24218 50313 +36628 50313 +37953 50310 +22924 50309 +41494 50309 +28655 50296 +26881 50289 +28135 50289 +43081 50275 +30810 50272 +30959 50261 +20566 50259 +21592 50255 +22008 50255 +27164 50249 +44127 50245 +49939 50241 +44216 50237 +40996 50230 +19291 50228 +22463 50225 +31295 50220 +47528 50218 +14007 50214 +46106 50210 +31354 50208 +26413 50206 +36569 50204 +28993 50199 +21072 50194 +36701 50191 +22969 50191 +32697 50186 +10915 50183 +28806 50178 +1796 50175 +22150 50168 +28560 50164 +16601 50150 +6975 50149 +6315 50149 +17651 50140 +43268 50139 +37930 50136 +20458 50134 +34154 50133 +27460 50129 +43029 50127 +6728 50123 +18217 50117 +28368 50114 +29835 50107 +44209 50105 +29642 50098 +40947 50092 +38625 50091 +48195 50079 +35259 50077 +29000 50077 +22524 50075 +20402 50071 +43070 50067 +10228 50059 +25474 50054 +22960 50054 +26934 50051 +39538 50048 +14298 50043 +23560 50040 +45773 50032 +29358 50031 +3678 50028 +22029 50028 +25505 50024 +36195 50015 +24757 50015 +28498 50006 +9492 50005 +20812 50005 +49523 49984 +39604 49984 +25985 49971 +14414 49966 +27367 49965 +4850 49956 +50224 49950 +29098 49944 +44038 49938 +46008 49937 +32909 49937 +11871 49933 +29997 49933 +7497 49929 +20647 49911 +15520 49911 +34252 49911 +30408 49909 +49653 49906 +34321 49904 +23313 49903 +37197 49902 +34929 49901 +29974 49898 +16704 49893 +27793 49884 +41777 49884 +9132 49873 +34342 49867 +20473 49864 +15951 49864 +18294 49863 +28009 49861 +19149 49861 +19833 49859 +36272 49857 +17003 49853 +17961 49851 +33307 49843 +2145 49840 +27114 49840 +12303 49838 +19730 49834 +35372 49831 +24641 49823 +24987 49820 +24298 49815 +33331 49815 +28002 49811 +19142 49808 +24650 49805 +43581 49805 +26783 49800 +28685 49797 +43543 49791 +30980 49791 +27499 49784 +46864 49783 +29076 49783 +25885 49779 +33941 49777 +22980 49777 +36665 49775 +21139 49763 +29380 49762 +27735 49761 +46562 49759 +30747 49759 +31555 49758 +45711 49758 +28545 49747 +21738 49746 +44654 49734 +36071 49732 +21632 49723 +39916 49723 +45132 49721 +18527 49720 +47479 49718 +39533 49714 +47246 49714 +18231 49708 +13560 49705 +10684 49703 +28389 49700 +5709 49699 +20916 49692 +43178 49690 +36714 49689 +11365 49683 +48064 49679 +44379 49675 +26332 49674 +27736 49672 +2037 49665 +30261 49665 +47725 49661 +30353 49656 +39567 49653 +33019 49650 +12418 49640 +27623 49639 +32984 49638 +23378 49635 +26279 49634 +20781 49629 +32724 49624 +49266 49623 +22603 49622 +25386 49617 +46988 49608 +41471 49598 +15140 49597 +31994 49596 +44579 49595 +45264 49589 +20728 49587 +47681 49584 +35223 49584 +28796 49577 +35454 49574 +36540 49572 +34069 49565 +31247 49565 +30367 49565 +21956 49560 +20596 49555 +25330 49548 +39620 49547 +33381 49545 +27625 49542 +24604 49522 +41987 49519 +7279 49518 +8170 49515 +31186 49508 +49769 49496 +28733 49492 +37648 49490 +43590 49484 +34355 49484 +28774 49483 +14435 49476 +4264 49476 +5786 49473 +27317 49473 +36240 49472 +42687 49470 +25783 49463 +42251 49460 +40973 49454 +44466 49448 +25110 49444 +29765 49442 +34613 49442 +30310 49441 +27997 49432 +36054 49431 +20909 49427 +43244 49427 +32520 49414 +30967 49413 +21212 49412 +38748 49408 +34597 49406 +38085 49403 +25856 49402 +46305 49400 +25439 49400 +10122 49386 +46834 49384 +29894 49383 +10341 49374 +13190 49373 +25743 49369 +45614 49367 +31331 49365 +46882 49365 +16994 49363 +48487 49361 +28887 49360 +23674 49356 +43039 49352 +31250 49350 +44135 49348 +36483 49342 +26467 49341 +12324 49341 +23385 49336 +5494 49330 +43974 49327 +24183 49324 +23059 49319 +22808 49316 +3385 49311 +39159 49311 +36197 49310 +24147 49304 +6924 49302 +8930 49301 +33045 49292 +19429 49288 +38591 49285 +25739 49285 +39476 49283 +29723 49269 +25069 49269 +36270 49268 +38376 49265 +42478 49265 +46855 49263 +42070 49262 +13208 49255 +30834 49251 +1784 49245 +33427 49243 +31719 49240 +14346 49240 +15885 49235 +46903 49229 +12428 49225 +35866 49223 +4872 49218 +13363 49213 +35135 49211 +12604 49209 +41391 49206 +34485 49198 +39735 49197 +24063 49190 +3097 49186 +36682 49185 +43144 49184 +19065 49181 +32344 49177 +25744 49174 +22557 49169 +33168 49166 +17482 49164 +32510 49162 +42815 49158 +25986 49154 +36686 49154 +43106 49152 +21045 49150 +36293 49150 +44188 49148 +17946 49128 +44636 49125 +28324 49121 +15783 49119 +32195 49119 +22716 49115 +18351 49113 +37726 49108 +29778 49103 +31070 49101 +16441 49100 +37731 49095 +45094 49089 +21152 49085 +28381 49076 +28068 49076 +41334 49076 +9044 49068 +16200 49064 +36110 49063 +5089 49060 +26006 49059 +24483 49044 +43400 49042 +24582 49038 +47755 49036 +28596 49032 +27843 49027 +48253 49023 +34205 49021 +50209 49013 +19742 49006 +42734 49005 +32600 49004 +39614 49000 +29373 48996 +29604 48993 +19694 48991 +47170 48989 +45759 48988 +28027 48981 +46930 48975 +23660 48974 +19796 48973 +30574 48968 +41716 48956 +42737 48956 +45588 48956 +26580 48950 +38408 48948 +47978 48944 +21201 48944 +36717 48942 +37632 48938 +14709 48933 +36294 48933 +28704 48933 +12212 48926 +29016 48916 +36212 48912 +46854 48910 +35495 48905 +25702 48904 +2867 48903 +36114 48901 +40343 48900 +34715 48895 +35183 48886 +31015 48884 +21123 48884 +16596 48880 +19112 48876 +30587 48871 +25859 48867 +27631 48852 +25791 48847 +29887 48846 +12920 48846 +16620 48844 +44043 48839 +24470 48838 +49132 48837 +38674 48837 +27441 48831 +23094 48828 +17721 48826 +10903 48825 +31274 48824 +22511 48824 +19620 48819 +21892 48813 +47817 48808 +18651 48808 +27045 48804 +19427 48799 +23334 48799 +31261 48798 +17336 48796 +48199 48791 +9787 48786 +37221 48772 +43579 48768 +36351 48764 +36242 48761 +43127 48760 +14253 48757 +35199 48750 +32772 48748 +25922 48745 +28854 48743 +30930 48743 +32219 48728 +28144 48724 +20198 48721 +19753 48720 +32793 48715 +48039 48715 +26664 48713 +25644 48711 +29708 48709 +26110 48708 +13972 48703 +39397 48694 +38914 48689 +19794 48689 +21680 48676 +37116 48673 +39005 48672 +22073 48657 +31608 48655 +29403 48647 +25242 48646 +33154 48641 +28202 48637 +26535 48633 +35094 48632 +37184 48631 +28952 48630 +35862 48624 +46516 48622 +29091 48620 +33764 48618 +33226 48617 +41220 48613 +4428 48613 +19542 48612 +33541 48610 +38034 48608 +31983 48606 +22057 48597 +22746 48593 +27241 48574 +25533 48572 +4300 48571 +40611 48569 +46395 48566 +18949 48559 +29332 48557 +27630 48555 +37813 48554 +31597 48550 +43274 48548 +25602 48546 +34541 48540 +28025 48538 +24611 48538 +12415 48533 +13262 48531 +25459 48527 +49553 48527 +34874 48527 +46057 48527 +49372 48523 +38866 48509 +24778 48508 +34224 48505 +22437 48495 +45468 48490 +17975 48490 +24256 48482 +29031 48476 +37882 48475 +39163 48473 +40255 48472 +26811 48466 +36450 48465 +1852 48465 +27121 48464 +19367 48463 +19961 48459 +44518 48455 +44655 48454 +40793 48454 +12464 48453 +34384 48452 +34902 48450 +36172 48441 +16339 48441 +29079 48437 +10760 48437 +33469 48435 +27587 48432 +36776 48426 +35208 48425 +19054 48425 +25516 48424 +34078 48422 +41973 48414 +11122 48412 +38173 48400 +4584 48399 +34882 48397 +26277 48391 +34434 48390 +29683 48382 +7752 48377 +45983 48376 +40910 48374 +31848 48373 +39769 48366 +12222 48364 +49752 48364 +23726 48363 +17019 48362 +26366 48359 +37091 48357 +36991 48356 +49851 48341 +22374 48341 +47572 48339 +21309 48338 +23337 48332 +28262 48329 +29246 48326 +49598 48325 +26130 48321 +18690 48315 +38594 48314 +23487 48314 +12573 48312 +31017 48310 +45736 48307 +21273 48305 +8648 48300 +29355 48295 +41089 48293 +7672 48292 +28714 48291 +20661 48276 +34912 48270 +45568 48263 +8671 48262 +44485 48260 +2690 48257 +27912 48256 +45494 48256 +21645 48246 +36559 48242 +46567 48239 +30622 48235 +26557 48229 +44523 48227 +36960 48227 +19867 48223 +10461 48221 +17723 48219 +29549 48218 +44862 48218 +24904 48218 +45142 48216 +23100 48213 +37279 48209 +9887 48209 +46470 48205 +18230 48202 +45511 48202 +48850 48202 +39037 48199 +33119 48197 +24814 48195 +42792 48194 +9042 48189 +39685 48187 +23253 48186 +34276 48182 +43373 48177 +43120 48174 +36193 48173 +5090 48171 +49902 48167 +24894 48161 +36833 48160 +43663 48159 +37248 48150 +28799 48150 +42898 48146 +32656 48145 +39339 48140 +47199 48135 +31068 48133 +35455 48131 +21725 48119 +47916 48119 +41336 48115 +33271 48114 +33977 48108 +35008 48107 +49432 48106 +30383 48106 +24975 48102 +47773 48099 +23506 48097 +33133 48091 +36612 48090 +5306 48090 +36998 48065 +37073 48064 +20206 48062 +11934 48060 +32728 48056 +45425 48054 +16341 48052 +36281 48044 +17363 48035 +35465 48033 +15880 48030 +16357 48025 +21527 48023 +22275 48023 +33502 48015 +13672 48014 +41679 48012 +31986 48012 +28867 48011 +33755 48009 +24776 48006 +8357 48004 +37292 47998 +34746 47994 +37027 47992 +40519 47990 +36279 47980 +6417 47979 +36083 47978 +28456 47977 +31114 47970 +38527 47969 +34567 47968 +39302 47965 +45504 47964 +25600 47960 +32377 47960 +27712 47958 +33424 47957 +10811 47948 +28771 47935 +35262 47924 +26539 47917 +29282 47917 +3643 47915 +39412 47915 +18255 47913 +14750 47910 +38088 47905 +6398 47904 +40470 47903 +45246 47901 +40662 47899 +24504 47899 +41229 47898 +49292 47898 +46160 47896 +35309 47896 +47329 47892 +40453 47890 +26352 47889 +22682 47885 +21262 47885 +39441 47884 +27238 47884 +28378 47879 +14132 47878 +21969 47877 +31533 47876 +33851 47875 +30582 47875 +22342 47874 +15075 47874 +40955 47871 +35332 47870 +27244 47864 +26181 47863 +22832 47858 +43956 47853 +29846 47852 +2697 47844 +20666 47844 +26281 47843 +18268 47843 +9928 47836 +2083 47836 +32350 47834 +37342 47831 +21315 47829 +27132 47825 +15809 47819 +38987 47819 +34375 47811 +47668 47809 +41836 47806 +25284 47803 +17273 47802 +39862 47800 +16311 47791 +1476 47789 +47853 47786 +39027 47783 +48213 47783 +8012 47782 +33063 47765 +27445 47759 +34849 47745 +41970 47743 +42170 47742 +42876 47742 +1161 47739 +36742 47733 +47151 47729 +13115 47725 +18301 47725 +35272 47723 +27219 47708 +3416 47707 +28177 47699 +38738 47699 +29770 47687 +26465 47686 +38383 47685 +22069 47680 +21456 47679 +14174 47674 +23539 47667 +46247 47665 +34459 47663 +22179 47659 +22449 47658 +42791 47654 +39603 47653 +50169 47652 +26667 47651 +44498 47645 +44868 47642 +28876 47640 +26701 47638 +5109 47637 +19327 47637 +31064 47634 +30573 47633 +35905 47625 +45232 47624 +43616 47621 +28217 47618 +48642 47617 +27086 47617 +42992 47611 +42327 47611 +23688 47609 +26282 47598 +36099 47596 +40852 47596 +43766 47594 +33297 47593 +49466 47591 +17209 47585 +43670 47582 +24748 47581 +32353 47571 +48342 47569 +38757 47561 +32905 47561 +32085 47556 +9250 47542 +35729 47542 +37663 47540 +16112 47538 +33694 47537 +31556 47535 +28277 47531 +25104 47526 +38429 47525 +39074 47524 +40404 47523 +46739 47521 +28940 47519 +27329 47518 +23753 47514 +29041 47510 +31267 47506 +35163 47506 +18150 47505 +33159 47503 +24811 47492 +22148 47488 +25342 47487 +38812 47487 +39283 47486 +25808 47483 +15486 47483 +12808 47482 +30103 47481 +19159 47481 +32572 47477 +30430 47475 +25881 47464 +37486 47459 +27506 47446 +28334 47432 +21561 47418 +18801 47417 +30180 47414 +39383 47411 +25587 47410 +28091 47408 +41626 47405 +47228 47403 +29419 47402 +1480 47400 +30363 47399 +33319 47394 +43558 47393 +27946 47391 +16623 47391 +37749 47390 +31271 47390 +18619 47388 +44003 47374 +21458 47373 +29181 47371 +38119 47362 +31807 47362 +10963 47356 +28060 47355 +46922 47354 +37331 47351 +27577 47345 +32884 47333 +22515 47327 +19853 47322 +19354 47319 +40431 47314 +16275 47311 +5915 47310 +44339 47303 +35489 47299 +43398 47294 +35096 47293 +18799 47293 +46577 47288 +29005 47287 +25534 47286 +27657 47281 +20298 47279 +42299 47272 +27613 47271 +29341 47270 +45723 47268 +38908 47263 +37164 47253 +38260 47252 +1251 47243 +47848 47234 +35817 47231 +28453 47230 +28878 47227 +5065 47223 +20214 47217 +13220 47216 +25649 47214 +38186 47210 +46822 47209 +34693 47207 +17827 47207 +19520 47204 +19756 47202 +24249 47201 +32514 47200 +2844 47198 +49416 47195 +36874 47186 +39962 47184 +37800 47183 +30669 47181 +43100 47180 +25671 47175 +15450 47174 +28888 47160 +34079 47156 +19484 47156 +42274 47154 +6278 47154 +37793 47153 +33816 47153 +31693 47149 +47218 47148 +33858 47146 +40689 47137 +21287 47137 +40105 47133 +30571 47133 +32402 47132 +38009 47131 +24294 47129 +22930 47120 +19707 47115 +34941 47114 +42425 47112 +19498 47111 +28609 47109 +34134 47104 +44056 47100 +19976 47094 +17678 47084 +47562 47083 +15310 47073 +16458 47068 +37228 47064 +23756 47063 +15590 47060 +19355 47056 +42906 47056 +45512 47056 +32529 47052 +11593 47052 +31528 47052 +21713 47051 +28880 47045 +20800 47043 +22291 47033 +40511 47032 +48569 47016 +48060 47011 +43799 47003 +20113 47001 +36579 46998 +36748 46996 +34263 46996 +49520 46994 +38686 46986 +35177 46971 +42967 46970 +14336 46967 +45184 46965 +47413 46965 +34789 46965 +45139 46964 +3065 46962 +23921 46961 +28687 46955 +32654 46950 +44738 46946 +35153 46942 +32761 46937 +17647 46935 +46150 46934 +38761 46931 +35355 46921 +12454 46913 +30876 46903 +3552 46902 +27458 46902 +23277 46901 +10465 46898 +35662 46897 +16643 46895 +41794 46895 +39524 46892 +42899 46892 +39164 46887 +36101 46879 +11370 46878 +12221 46873 +32293 46870 +29641 46869 +28424 46863 +28309 46861 +13775 46860 +39767 46856 +29343 46855 +34155 46853 +35932 46852 +46875 46850 +50173 46846 +35426 46843 +7615 46840 +42004 46840 +46447 46837 +28786 46834 +37048 46829 +32122 46829 +29280 46827 +1091 46827 +10709 46824 +42571 46820 +30468 46812 +35526 46807 +28807 46786 +6059 46785 +9313 46784 +43652 46779 +39640 46776 +48568 46764 +5957 46763 +25194 46763 +15432 46761 +50186 46760 +26135 46759 +36360 46755 +11019 46751 +30097 46749 +27952 46749 +32808 46748 +3935 46742 +25584 46738 +47377 46725 +26996 46725 +24134 46725 +24709 46720 +23585 46717 +36865 46715 +31910 46710 +16854 46708 +36093 46703 +48853 46698 +19900 46698 +43104 46694 +31349 46692 +41238 46686 +21521 46678 +49412 46678 +44026 46677 +45332 46677 +14406 46675 +25371 46664 +43257 46655 +33656 46655 +46861 46652 +27201 46649 +24944 46646 +29101 46642 +32343 46636 +17999 46634 +21306 46629 +32294 46629 +49104 46628 +23581 46624 +30875 46614 +48794 46612 +45645 46611 +45516 46610 +32396 46608 +20922 46608 +38406 46606 +11321 46605 +49612 46603 +35441 46600 +49190 46592 +9805 46592 +48701 46584 +30968 46582 +30066 46577 +46340 46575 +31377 46575 +35901 46567 +22208 46565 +21232 46562 +19108 46557 +45542 46557 +21194 46551 +35631 46546 +42580 46546 +29619 46542 +40943 46540 +44614 46537 +26957 46535 +32393 46532 +27377 46527 +47219 46524 +26975 46524 +24415 46523 +19680 46517 +40530 46513 +30811 46500 +30264 46491 +37054 46491 +18011 46489 +23250 46486 +21499 46482 +37818 46472 +22032 46469 +19831 46467 +34498 46463 +38833 46459 +12732 46458 +25710 46456 +29433 46452 +31207 46449 +47272 46447 +34569 46444 +33018 46438 +5530 46432 +18040 46428 +39891 46423 +28033 46423 +47353 46423 +33471 46415 +16678 46414 +35941 46414 +34191 46402 +18970 46402 +15183 46398 +17220 46397 +35180 46394 +13665 46383 +23126 46383 +32556 46382 +23087 46378 +47295 46377 +47196 46366 +31043 46364 +8110 46360 +13494 46358 +40698 46356 +40363 46355 +31168 46353 +35182 46351 +11143 46351 +34935 46346 +34122 46340 +27791 46338 +31172 46333 +40702 46330 +6172 46330 +16682 46322 +49597 46319 +23564 46319 +28590 46318 +31894 46316 +32542 46310 +24299 46303 +23214 46302 +6202 46299 +25598 46299 +13350 46299 +30548 46293 +49825 46288 +40062 46287 +34862 46283 +21163 46283 +20637 46283 +47560 46276 +30381 46274 +11599 46272 +27717 46270 +6120 46269 +21242 46269 +20025 46268 +33431 46263 +23447 46262 +36319 46260 +46980 46258 +32806 46258 +15008 46253 +29950 46251 +33570 46249 +14894 46239 +26761 46237 +19270 46234 +32921 46233 +42818 46228 +7671 46225 +37644 46222 +27254 46222 +47984 46221 +32729 46216 +2909 46212 +40657 46210 +29621 46209 +33713 46208 +14106 46206 +26034 46200 +22204 46196 +14265 46195 +11035 46193 +42437 46189 +44302 46189 +49967 46178 +44301 46177 +22633 46176 +40490 46165 +36930 46164 +8320 46159 +18093 46152 +11528 46151 +37026 46151 +35045 46149 +35370 46147 +30168 46146 +4772 46145 +43747 46137 +41130 46132 +34076 46130 +35088 46124 +16505 46123 +37428 46120 +20638 46115 +43007 46112 +43944 46109 +16258 46106 +22567 46098 +36214 46098 +23807 46093 +46972 46091 +9939 46091 +25384 46088 +29283 46087 +37293 46082 +7296 46079 +26707 46079 +36513 46072 +26173 46070 +32794 46069 +37891 46068 +42886 46058 +28328 46053 +44131 46048 +29397 46040 +42232 46039 +40741 46034 +26000 46034 +12205 46032 +37457 46032 +20964 46031 +19252 46030 +26753 46030 +32479 46029 +39078 46024 +25419 46023 +27642 46023 +45827 46017 +42097 46016 +32773 46015 +24227 46013 +35842 46009 +49300 46004 +32204 46002 +37554 46000 +23589 45991 +45046 45989 +48742 45987 +30355 45987 +34038 45986 +15307 45982 +39784 45980 +39987 45978 +39956 45976 +28388 45976 +22823 45976 +26473 45974 +22024 45969 +48437 45964 +38960 45958 +39716 45952 +31545 45952 +18458 45949 +45344 45949 +33561 45942 +34875 45941 +15861 45939 +32120 45939 +35639 45935 +32769 45930 +26990 45927 +43953 45925 +28954 45923 +38540 45916 +50172 45916 +40033 45912 +31448 45909 +39067 45905 +44769 45904 +29094 45900 +44768 45900 +18638 45900 +47244 45896 +29722 45892 +39960 45887 +46330 45887 +24372 45887 +16761 45865 +28107 45865 +8154 45864 +28031 45863 +36111 45861 +47950 45860 +32894 45859 +13908 45858 +47513 45857 +34151 45856 +27404 45855 +20453 45853 +14214 45848 +20751 45847 +43066 45844 +48901 45838 +20454 45834 +28271 45830 +35988 45827 +17134 45825 +11669 45820 +34243 45820 +47722 45818 +26471 45818 +39131 45806 +28448 45805 +46033 45802 +34316 45800 +20300 45799 +37676 45798 +34195 45795 +7550 45791 +26063 45787 +39420 45776 +30232 45771 +28183 45769 +26641 45765 +44818 45764 +40192 45764 +43176 45763 +36145 45762 +12942 45758 +26463 45756 +45878 45751 +26153 45749 +12192 45748 +37347 45747 +20979 45745 +44846 45740 +24843 45739 +42324 45735 +44220 45734 +28858 45732 +28351 45729 +27151 45728 +35011 45726 +26592 45726 +39235 45724 +27198 45724 +21721 45721 +37975 45715 +29442 45714 +17860 45699 +36383 45699 +23268 45698 +38754 45697 +37900 45696 +48709 45695 +37261 45695 +9926 45687 +45238 45687 +34152 45684 +2397 45683 +26333 45682 +37550 45681 +40966 45675 +31151 45673 +27769 45670 +8687 45664 +30185 45662 +27412 45661 +15787 45653 +44820 45649 +33536 45648 +33900 45647 +38705 45646 +25417 45642 +21767 45642 +22362 45640 +39678 45636 +50220 45628 +35073 45627 +41523 45625 +14065 45624 +24344 45624 +43153 45623 +31749 45622 +44652 45618 +36058 45615 +45413 45615 +39453 45611 +40641 45609 +27126 45601 +40136 45601 +36910 45601 +49628 45598 +32920 45597 +43492 45595 +49323 45589 +18005 45585 +29211 45582 +21762 45581 +49796 45577 +23831 45574 +36308 45571 +27758 45570 +40835 45569 +34486 45557 +37234 45553 +11720 45552 +34885 45548 +31629 45546 +46644 45537 +27253 45531 +26919 45525 +22136 45522 +29924 45521 +31489 45520 +49987 45520 +22564 45510 +29546 45510 +11537 45509 +10415 45508 +19259 45507 +24572 45499 +12304 45497 +40606 45494 +47748 45493 +42329 45492 +33790 45490 +15854 45490 +24170 45487 +45958 45477 +18076 45476 +41740 45473 +23550 45470 +38854 45468 +16183 45461 +41113 45458 +11055 45456 +35940 45455 +36394 45452 +21064 45451 +46544 45449 +9673 45449 +31059 45449 +9548 45448 +36769 45446 +28737 45442 +40307 45440 +23672 45439 +34663 45437 +23162 45434 +38689 45431 +42139 45426 +45200 45424 +40900 45424 +17620 45423 +38878 45422 +47657 45421 +39493 45401 +33182 45401 +19467 45398 +30795 45397 +16260 45391 +32367 45390 +35550 45386 +49341 45385 +40461 45380 +18219 45374 +8638 45371 +26484 45361 +21447 45360 +19941 45353 +10554 45352 +1823 45347 +29369 45345 +24702 45344 +13255 45341 +15098 45339 +29462 45334 +39373 45334 +41529 45333 +36941 45332 +23945 45328 +16010 45325 +50028 45324 +41928 45319 +21396 45318 +27162 45318 +49655 45310 +37222 45308 +26526 45303 +19852 45300 +27742 45296 +33105 45293 +4247 45291 +47410 45289 +37327 45285 +22717 45285 +46958 45282 +41053 45278 +20109 45272 +25514 45268 +6425 45263 +23272 45241 +21856 45239 +27036 45239 +24168 45230 +43939 45229 +15379 45223 +21352 45223 +25903 45223 +26949 45221 +30019 45218 +31130 45216 +41484 45215 +15125 45210 +32993 45207 +25685 45203 +38048 45200 +16911 45199 +45049 45195 +38932 45191 +9143 45188 +35794 45186 +37743 45183 +42186 45178 +33464 45174 +19172 45170 +17594 45164 +30551 45164 +36288 45164 +17133 45162 +27371 45162 +26093 45154 +48335 45154 +24309 45147 +28747 45147 +31991 45146 +38862 45145 +28978 45145 +29062 45144 +26887 45143 +25591 45143 +8145 45141 +29735 45139 +35906 45138 +23426 45132 +42850 45127 +36098 45122 +22035 45122 +35822 45120 +47573 45116 +26692 45113 +2361 45108 +15878 45107 +48687 45101 +24513 45096 +33270 45094 +22458 45092 +5145 45089 +26704 45087 +38378 45077 +26822 45071 +21515 45070 +43533 45069 +25830 45065 +42753 45063 +6940 45049 +28192 45048 +34683 45045 +32123 45042 +10035 45039 +44486 45035 +5042 45034 +29051 45032 +40859 45030 +7580 45025 +40687 45024 +30506 45013 +28959 45012 +42802 45012 +32816 45007 +22826 44996 +9474 44990 +31955 44989 +33187 44989 +49232 44988 +31202 44986 +9781 44978 +39076 44977 +39308 44974 +34965 44971 +24094 44964 +228 44960 +30549 44958 +23175 44953 +35613 44952 +17727 44938 +29985 44937 +11369 44930 +48604 44924 +22210 44923 +47877 44920 +10698 44909 +25797 44905 +20414 44904 +34030 44904 +27666 44903 +40904 44898 +39652 44897 +42828 44896 +27573 44894 +24288 44891 +49498 44886 +20485 44883 +24158 44882 +14558 44881 +17237 44879 +6293 44877 +22245 44876 +39679 44873 +13921 44870 +42490 44862 +38041 44860 +22911 44854 +46690 44854 +39128 44852 +39826 44851 +27109 44840 +23055 44839 +18875 44838 +19678 44838 +41520 44837 +5135 44836 +35584 44835 +30246 44828 +45222 44827 +24143 44827 +39411 44818 +49901 44817 +30559 44817 +48592 44815 +33963 44813 +23191 44808 +45892 44797 +30621 44795 +32154 44793 +25964 44793 +7949 44790 +34019 44787 +9243 44787 +1420 44786 +36703 44785 +42587 44782 +13131 44771 +46825 44767 +26820 44766 +9745 44766 +2498 44761 +42606 44758 +17817 44754 +18487 44752 +29524 44752 +32160 44750 +38189 44750 +39085 44745 +36587 44742 +10858 44739 +42378 44730 +31142 44728 +42495 44724 +19461 44719 +16806 44718 +15452 44716 +35873 44714 +39778 44711 +28801 44710 +26782 44709 +34480 44705 +33224 44703 +1269 44703 +32435 44702 +16364 44699 +36712 44699 +44913 44696 +11318 44691 +23537 44690 +11787 44689 +34903 44688 +21599 44683 +33896 44682 +27746 44679 +30568 44673 +30627 44670 +26576 44668 +43273 44658 +18107 44654 +29805 44652 +35429 44650 +49668 44648 +15411 44640 +47169 44633 +32581 44631 +37324 44631 +33344 44627 +25245 44625 +20084 44614 +33612 44606 +32167 44606 +19251 44605 +23684 44597 +7316 44597 +33732 44594 +23234 44593 +29086 44588 +12998 44588 +37378 44584 +31428 44584 +35212 44582 +47747 44581 +41630 44577 +26524 44575 +30086 44574 +16578 44571 +26978 44571 +47162 44567 +30844 44566 +4717 44565 +46662 44563 +14002 44556 +21259 44556 +9295 44554 +21441 44549 +33097 44546 +25498 44544 +30982 44543 +7921 44543 +27393 44541 +20914 44540 +27829 44539 +48073 44537 +22981 44534 +41909 44533 +232 44532 +34966 44528 +48028 44524 +31103 44522 +31450 44521 +22154 44521 +3924 44512 +17045 44511 +47830 44509 +43171 44509 +29697 44507 +46505 44502 +32049 44502 +21395 44500 +25307 44497 +45760 44496 +26774 44494 +22763 44486 +38094 44484 +34336 44481 +33852 44479 +46598 44478 +35278 44478 +36915 44475 +23454 44472 +6549 44471 +31648 44466 +22047 44464 +47533 44455 +48127 44454 +36582 44453 +38728 44453 +1184 44453 +23051 44443 +33189 44442 +38590 44435 +48965 44433 +32225 44432 +33418 44428 +41545 44427 +47399 44426 +25129 44425 +22194 44423 +9139 44423 +25929 44422 +32954 44421 +21062 44419 +48368 44416 +18206 44413 +15650 44407 +37829 44404 +27326 44404 +10441 44401 +26818 44398 +30416 44397 +1955 44397 +42917 44396 +37748 44394 +27688 44394 +38777 44394 +10487 44393 +41007 44390 +42610 44378 +35889 44373 +4607 44372 +15815 44371 +41218 44363 +28815 44362 +41980 44359 +38760 44357 +26243 44355 +20177 44355 +30004 44351 +24088 44348 +10121 44346 +45998 44341 +21282 44341 +48279 44340 +22651 44339 +45817 44335 +12754 44332 +23341 44328 +29262 44327 +26217 44324 +36619 44321 +18944 44321 +40459 44320 +50232 44317 +32235 44315 +28875 44314 +22790 44313 +46547 44313 +38176 44310 +8086 44307 +38962 44305 +40891 44299 +30796 44295 +25882 44295 +28826 44294 +35075 44292 +29183 44291 +33935 44290 +38868 44289 +16429 44288 +14418 44287 +43285 44280 +2249 44278 +24705 44274 +41985 44271 +25760 44270 +32630 44269 +14280 44268 +7390 44265 +41819 44261 +26422 44260 +22229 44256 +43150 44253 +28417 44252 +37437 44249 +46474 44245 +39835 44244 +42546 44238 +35471 44234 +10832 44232 +29643 44231 +25921 44227 +17042 44226 +48184 44221 +21497 44212 +25393 44210 +38883 44207 +27166 44207 +23109 44206 +14650 44198 +46673 44197 +40199 44184 +8866 44184 +22481 44183 +28994 44182 +20221 44181 +20305 44181 +27892 44179 +35173 44176 +23891 44174 +34290 44173 +28265 44166 +24487 44164 +32662 44164 +19822 44164 +43493 44160 +14922 44159 +18415 44158 +31137 44154 +29244 44153 +31706 44152 +28629 44152 +22068 44145 +35158 44145 +20766 44142 +36880 44140 +22413 44135 +23801 44135 +10539 44131 +13782 44130 +23671 44125 +23467 44124 +43842 44112 +35879 44109 +20969 44104 +40581 44101 +37692 44100 +31487 44096 +42575 44095 +35238 44095 +35245 44093 +36710 44091 +30530 44088 +41954 44085 +44795 44078 +13420 44076 +39167 44074 +36183 44073 +24857 44067 +9218 44066 +41719 44065 +12194 44063 +45830 44062 +38316 44057 +40772 44057 +26826 44049 +32481 44036 +37371 44030 +39857 44029 +33964 44028 +38794 44027 +46339 44023 +38951 44019 +37278 44017 +18938 44012 +40790 44012 +14902 44011 +33879 44009 +32114 44002 +19854 44002 +29962 44001 +41566 43997 +27405 43980 +33082 43978 +48695 43976 +19501 43972 +45024 43971 +19129 43971 +33260 43971 +43644 43970 +46218 43963 +29791 43962 +47041 43962 +32270 43961 +11285 43960 +44490 43956 +4276 43950 +39675 43948 +39438 43943 +39041 43943 +37029 43941 +26364 43936 +44752 43934 +29830 43928 +48918 43924 +21254 43920 +38291 43916 +46593 43910 +12009 43909 +30471 43901 +47600 43900 +18372 43897 +35424 43887 +37316 43881 +47096 43881 +38368 43877 +39917 43875 +25735 43874 +31283 43872 +28944 43871 +2338 43871 +25334 43867 +18761 43862 +22401 43856 +22507 43853 +32913 43850 +22172 43849 +46221 43847 +19700 43846 +27191 43844 +42458 43838 +28433 43838 +36263 43835 +24818 43828 +35501 43825 +19394 43824 +38775 43821 +35968 43820 +40568 43802 +38003 43798 +30247 43788 +24414 43787 +21533 43786 +29623 43783 +45129 43777 +37973 43774 +34624 43773 +38181 43771 +18016 43766 +31906 43758 +15546 43750 +31012 43748 +32240 43744 +49565 43741 +37660 43741 +46496 43736 +7944 43735 +36151 43734 +40045 43730 +49676 43728 +39824 43726 +42998 43725 +23163 43724 +16972 43722 +30365 43718 +16302 43716 +35534 43711 +36184 43711 +8102 43710 +33589 43709 +32776 43708 +48271 43698 +35473 43696 +16912 43694 +27064 43694 +32237 43692 +31210 43686 +27937 43684 +49906 43684 +38299 43677 +13583 43672 +15312 43671 +44180 43669 +41249 43662 +34099 43659 +37965 43652 +32222 43650 +48292 43647 +32813 43645 +28097 43641 +16185 43641 +28748 43636 +28541 43636 +25183 43632 +36324 43631 +36051 43631 +5280 43627 +31229 43626 +46982 43625 +36708 43624 +34221 43622 +33184 43621 +14868 43619 +20784 43609 +36334 43608 +45527 43607 +44200 43601 +15526 43601 +47766 43599 +24027 43598 +33593 43589 +34759 43587 +32018 43585 +19842 43584 +24605 43582 +36622 43577 +32309 43575 +13926 43563 +14421 43561 +12776 43559 +29563 43556 +31804 43553 +32469 43546 +16018 43542 +15559 43541 +36811 43540 +33729 43534 +48660 43533 +30502 43527 +25703 43522 +23457 43519 +5960 43519 +26956 43499 +36266 43496 +26578 43485 +29637 43484 +34740 43484 +24498 43483 +43457 43482 +35222 43480 +45354 43479 +28179 43476 +28765 43469 +40621 43464 +32067 43462 +18701 43462 +39770 43457 +20296 43457 +17841 43455 +18824 43455 +40677 43453 +16698 43452 +37416 43446 +42657 43444 +15092 43443 +41711 43441 +31856 43438 +25088 43436 +33875 43434 +42409 43433 +45789 43431 +16242 43428 +27936 43426 +45262 43425 +16706 43425 +24747 43423 +46301 43422 +48417 43418 +29899 43417 +43350 43416 +22619 43414 +27895 43410 +46427 43408 +17879 43406 +30477 43403 +29956 43397 +50146 43390 +47443 43389 +45235 43385 +34188 43384 +34127 43381 +42438 43381 +38553 43380 +7314 43380 +43715 43380 +30786 43377 +34884 43376 +49235 43376 +44792 43372 +33680 43370 +40856 43364 +41878 43363 +34170 43363 +31165 43361 +17323 43360 +18328 43358 +48257 43358 +27693 43351 +41893 43349 +34020 43343 +33884 43341 +28032 43339 +28403 43335 +29935 43334 +37317 43333 +32956 43329 +39552 43326 +28965 43322 +27773 43320 +34419 43317 +21333 43317 +22388 43311 +29217 43310 +8433 43307 +15597 43302 +18871 43296 +43833 43295 +38132 43288 +27472 43285 +44441 43285 +31182 43282 +44699 43282 +34837 43276 +35254 43274 +12789 43274 +20589 43271 +22141 43268 +26096 43267 +37247 43262 +26263 43259 +22922 43259 +29338 43255 +31669 43255 +44866 43252 +12305 43251 +37871 43250 +28006 43244 +42504 43242 +29482 43235 +48303 43232 +44972 43232 +47977 43222 +25527 43220 +6361 43218 +48614 43217 +18443 43212 +18228 43212 +26067 43212 +45391 43209 +27400 43206 +50058 43205 +26723 43204 +30184 43202 +33805 43197 +38096 43188 +41225 43184 +16890 43181 +31860 43173 +33516 43172 +36062 43170 +17011 43165 +34994 43163 +39673 43155 +39381 43152 +41756 43151 +32311 43150 +34454 43149 +35405 43148 +42841 43147 +45707 43144 +32995 43137 +22411 43133 +27257 43129 +44429 43129 +8333 43128 +31772 43127 +33292 43123 +42749 43121 +47143 43120 +41175 43119 +28003 43117 +38065 43116 +49462 43116 +45691 43112 +22555 43110 +44595 43110 +32721 43109 +45375 43107 +27780 43106 +26481 43105 +45715 43102 +31780 43099 +21684 43096 +43383 43096 +37432 43093 +34397 43093 +47129 43092 +25948 43087 +20791 43084 +48705 43082 +24322 43079 +33177 43076 +40586 43074 +24823 43067 +25674 43063 +7089 43061 +33763 43060 +43175 43053 +42048 43049 +31779 43046 +24339 43044 +17685 43044 +37451 43044 +40221 43043 +11429 43041 +47770 43039 +28680 43034 +18536 43032 +42116 43026 +7248 43023 +23005 43016 +33877 43012 +13789 43012 +38561 43010 +49756 43006 +40958 43006 +23777 43005 +25900 43004 +44268 43004 +28699 43001 +25135 43001 +27827 42996 +31505 42994 +4546 42994 +23875 42990 +50081 42989 +44941 42985 +27921 42970 +17937 42964 +35947 42961 +33619 42959 +44255 42956 +32423 42955 +31588 42954 +33655 42954 +43075 42953 +28168 42952 +37291 42950 +41269 42950 +21701 42949 +24698 42944 +25550 42944 +9401 42937 +37727 42928 +17119 42924 +37493 42919 +42689 42916 +25470 42915 +28384 42914 +46664 42912 +29368 42904 +44243 42900 +29464 42893 +44874 42892 +34087 42891 +26937 42890 +42410 42886 +33802 42883 +9660 42879 +27000 42870 +42694 42869 +13544 42864 +20636 42857 +22391 42854 +34147 42853 +23588 42852 +26731 42848 +40898 42848 +48256 42844 +18809 42842 +28846 42840 +42142 42835 +38091 42834 +26765 42828 +36641 42826 +29225 42825 +44316 42824 +29138 42819 +44717 42816 +36175 42816 +10155 42813 +26084 42813 +17072 42812 +24111 42810 +31866 42808 +40171 42806 +37625 42804 +16262 42804 +48784 42803 +15054 42801 +29877 42801 +50217 42796 +26460 42794 +49241 42794 +40502 42791 +39511 42791 +6583 42786 +24827 42784 +35456 42783 +29063 42783 +30445 42783 +38225 42779 +19248 42776 +31372 42769 +27798 42769 +38504 42768 +48666 42768 +28963 42766 +42020 42764 +24893 42754 +30079 42754 +27617 42753 +31534 42740 +22389 42738 +35581 42737 +35463 42737 +37367 42734 +36557 42731 +24409 42729 +33720 42727 +36589 42724 +21173 42721 +26832 42714 +47971 42712 +7115 42708 +23120 42706 +20977 42702 +29867 42701 +25713 42697 +40913 42690 +7878 42688 +43770 42687 +25669 42686 +21260 42680 +44630 42677 +37343 42676 +43259 42670 +48516 42669 +37040 42668 +34031 42666 +33068 42665 +23065 42665 +16756 42663 +48222 42657 +23355 42657 +23963 42656 +13441 42655 +49076 42653 +3566 42647 +28909 42644 +32024 42642 +23045 42629 +46699 42624 +42890 42623 +36004 42623 +36566 42622 +23297 42621 +22607 42621 +49852 42618 +29407 42618 +19213 42617 +26607 42616 +13169 42606 +47018 42602 +25993 42602 +44756 42599 +16676 42594 +32692 42591 +37245 42590 +27188 42589 +19071 42588 +37784 42586 +39408 42585 +44554 42585 +25156 42581 +29874 42578 +39536 42578 +44932 42570 +40936 42567 +42774 42565 +36630 42564 +40854 42561 +28055 42556 +31464 42554 +44147 42548 +30011 42548 +32415 42547 +10210 42541 +36355 42541 +44524 42539 +34259 42538 +3922 42538 +30253 42534 +1279 42534 +34940 42533 +27877 42532 +1926 42531 +8633 42531 +36808 42529 +22645 42528 +32234 42528 +38900 42525 +29739 42520 +27462 42509 +29718 42504 +42511 42503 +25402 42497 +36706 42493 +22269 42489 +14452 42483 +33833 42482 +29514 42479 +40982 42469 +10369 42469 +47364 42468 +44731 42466 +22732 42465 +37000 42461 +34202 42455 +28731 42452 +5759 42450 +39676 42448 +44945 42448 +3453 42445 +17193 42445 +24195 42441 +38698 42441 +26115 42436 +15956 42435 +8898 42432 +29789 42431 +18084 42430 +27420 42429 +37565 42429 +45510 42425 +48113 42424 +39631 42424 +29404 42421 +45807 42420 +47741 42418 +42852 42417 +18338 42416 +50073 42414 +28158 42411 +28848 42409 +37100 42409 +3548 42407 +20570 42407 +14423 42403 +35505 42402 +39473 42401 +26571 42398 +30481 42395 +37626 42391 +27591 42389 +33992 42388 +37753 42387 +29605 42385 +24278 42380 +28668 42376 +11440 42372 +29648 42371 +44299 42366 +25578 42360 +23064 42358 +40648 42357 +2803 42357 +39935 42351 +30149 42343 +39080 42343 +22337 42333 +44574 42328 +43074 42324 +26814 42317 +27041 42314 +13323 42314 +29615 42308 +22087 42302 +45928 42297 +48233 42296 +48750 42291 +1427 42285 +28874 42278 +33264 42276 +22886 42272 +36167 42261 +39795 42260 +31581 42246 +29376 42245 +31016 42244 +38682 42241 +16708 42237 +37560 42236 +31474 42234 +47507 42227 +23298 42222 +23188 42222 +30852 42221 +34483 42220 +33233 42214 +17708 42214 +46941 42212 +11984 42209 +30507 42207 +27756 42201 +32553 42198 +37589 42197 +23922 42195 +29608 42194 +33863 42191 +22587 42188 +46714 42184 +23262 42183 +27621 42182 +18940 42179 +48120 42178 +16694 42175 +36160 42173 +33599 42168 +49314 42168 +49157 42166 +26511 42160 +37301 42151 +48138 42149 +22852 42147 +10679 42144 +48066 42143 +32947 42139 +48111 42138 +43573 42133 +26118 42132 +28127 42131 +24137 42130 +7418 42123 +49030 42123 +16091 42120 +36189 42119 +33752 42116 +43542 42116 +34702 42114 +34225 42112 +38769 42110 +43014 42105 +41439 42099 +21405 42099 +25862 42091 +44615 42090 +15126 42090 +30850 42086 +37862 42079 +31025 42078 +26050 42078 +44312 42074 +24286 42070 +35765 42067 +47508 42067 +41151 42067 +26554 42066 +37935 42065 +14477 42065 +20848 42065 +37299 42064 +43086 42063 +26195 42063 +31296 42061 +41354 42054 +38999 42049 +35268 42048 +20356 42039 +1344 42033 +13847 42032 +26114 42031 +35969 42026 +50062 42024 +36684 42023 +40544 42022 +14220 42021 +24804 42016 +35927 42015 +22023 42012 +17875 42006 +12491 42002 +14382 42000 +22327 41999 +41957 41998 +28827 41988 +40795 41986 +26741 41982 +39725 41979 +29172 41978 +35576 41976 +33417 41974 +36415 41973 +47438 41973 +7167 41970 +8430 41967 +34731 41967 +28742 41967 +49377 41966 +41437 41961 +42843 41960 +13500 41957 +35250 41957 +37099 41956 +33970 41954 +31987 41953 +35154 41952 +42450 41948 +44341 41944 +44564 41944 +47122 41943 +41773 41936 +24761 41935 +41126 41935 +25460 41934 +46009 41933 +43190 41933 +28870 41916 +28964 41912 +30023 41911 +32433 41910 +33546 41906 +41318 41902 +48268 41899 +24549 41899 +46587 41893 +4658 41878 +28946 41877 +38068 41876 +46742 41876 +36939 41875 +30648 41873 +32726 41869 +28637 41867 +31085 41866 +49829 41861 +30124 41849 +4194 41845 +27118 41844 +43261 41842 +44158 41841 +21155 41839 +23362 41833 +29592 41827 +44775 41825 +643 41823 +46703 41822 +30161 41821 +49431 41819 +42085 41812 +35197 41807 +29503 41805 +29300 41804 +43965 41801 +36783 41797 +31692 41794 +38616 41791 +49774 41791 +47181 41788 +45450 41784 +42209 41781 +44992 41780 +16350 41778 +37876 41773 +49101 41773 +26795 41767 +33914 41764 +25803 41764 +34372 41762 +43520 41759 +42140 41752 +37620 41742 +40815 41737 +30990 41734 +28467 41730 +37872 41728 +22190 41728 +49589 41727 +18155 41725 +29933 41722 +46412 41720 +40181 41719 +21269 41714 +37993 41709 +22697 41707 +23237 41706 +37764 41706 +24368 41701 +37267 41700 +43381 41699 +24907 41699 +47547 41699 +44160 41698 +20443 41697 +28511 41696 +49595 41696 +49088 41693 +31430 41690 +27256 41689 +35981 41683 +47444 41682 +33662 41680 +31060 41678 +14204 41678 +35650 41677 +47095 41675 +30550 41673 +36550 41670 +49744 41667 +6736 41667 +10187 41666 +40448 41665 +5239 41661 +35547 41660 +38421 41659 +5234 41658 +46609 41649 +16163 41647 +29691 41646 +29038 41645 +22883 41645 +25096 41640 +44284 41637 +14579 41628 +24574 41625 +11993 41622 +47952 41619 +41189 41618 +40280 41617 +40690 41615 +23220 41606 +35701 41605 +35205 41604 +45058 41604 +14304 41602 +18683 41602 +31468 41601 +26247 41600 +49839 41596 +17353 41592 +38631 41591 +37429 41590 +42047 41590 +38801 41590 +26204 41589 +11268 41586 +28658 41584 +42123 41579 +16074 41575 +27487 41572 +46175 41572 +25445 41564 +36953 41562 +41273 41559 +43851 41558 +29633 41556 +15763 41554 +30517 41553 +5324 41552 +36034 41551 +12110 41544 +31113 41543 +27368 41542 +23685 41538 +48590 41530 +35698 41527 +1403 41526 +25010 41525 +28279 41521 +33687 41517 +35308 41516 +47500 41515 +49634 41515 +24181 41513 +47100 41508 +35672 41507 +31598 41504 +29145 41504 +21699 41491 +35616 41490 +46361 41489 +49297 41482 +14522 41481 +33878 41481 +20016 41478 +38005 41473 +29473 41473 +34228 41470 +29952 41470 +28778 41469 +29655 41467 +7569 41467 +45800 41462 +43499 41461 +27176 41460 +6816 41454 +37128 41454 +30041 41453 +17223 41449 +46157 41449 +40185 41446 +34824 41446 +32927 41445 +31999 41437 +43157 41437 +46515 41434 +15315 41431 +28703 41425 +31056 41421 +40372 41419 +45318 41414 +32747 41414 +45615 41414 +13290 41400 +25521 41397 +40066 41394 +30144 41393 +48501 41391 +50210 41390 +23619 41390 +18146 41386 +36256 41384 +32910 41382 +40252 41381 +26427 41381 +43902 41378 +28386 41377 +29906 41375 +34592 41371 +19176 41367 +41353 41365 +49739 41364 +26591 41362 +34781 41361 +18897 41349 +41565 41346 +50017 41345 +49994 41342 +32421 41342 +27596 41340 +29187 41337 +36015 41337 +46907 41336 +38019 41334 +32960 41334 +20597 41333 +32946 41318 +31235 41318 +28705 41316 +46073 41308 +41779 41307 +27263 41305 +46264 41303 +32576 41299 +35785 41299 +30674 41299 +24767 41292 +37462 41292 +35784 41287 +27761 41285 +48155 41283 +29517 41282 +47380 41282 +41738 41273 +47579 41271 +37984 41270 +31289 41268 +36213 41268 +27199 41266 +43018 41265 +40960 41262 +49468 41260 +33238 41252 +44763 41246 +13730 41245 +48015 41244 +23800 41239 +36049 41238 +39053 41236 +14945 41236 +43554 41236 +28408 41234 +23815 41220 +15739 41219 +22709 41217 +31685 41217 +27228 41209 +24909 41205 +41860 41197 +31843 41193 +41188 41192 +35525 41189 +15350 41187 +29915 41178 +46946 41176 +24399 41174 +49759 41170 +2992 41169 +14125 41168 +14437 41163 +15365 41162 +31641 41162 +37303 41159 +28069 41159 +37886 41159 +43255 41153 +46013 41152 +17253 41151 +18100 41150 +22749 41149 +28845 41148 +35683 41146 +34797 41137 +35341 41137 +28711 41131 +17561 41129 +29013 41124 +6732 41122 +22985 41112 +37812 41100 +20072 41098 +33826 41097 +7942 41096 +21911 41096 +30963 41094 +40323 41091 +41483 41088 +29206 41086 +41404 41078 +20595 41077 +20827 41075 +35261 41075 +5248 41073 +20509 41072 +5630 41067 +20797 41065 +21437 41060 +24403 41046 +49683 41046 +30649 41046 +42474 41043 +26337 41041 +35951 41041 +37114 41040 +28226 41036 +25675 41034 +34963 41032 +23628 41032 +45261 41025 +38560 41010 +49690 41008 +14988 41003 +37668 41003 +34819 41002 +15995 40999 +47031 40998 +28494 40998 +34173 40992 +34528 40991 +19404 40990 +37489 40987 +26863 40987 +48741 40985 +27205 40985 +44447 40979 +2424 40976 +27481 40973 +12272 40969 +31360 40968 +1594 40962 +34815 40960 +22572 40956 +42549 40955 +30252 40955 +22189 40954 +40018 40952 +24825 40952 +48119 40948 +7144 40943 +40551 40943 +46773 40942 +30125 40941 +25321 40937 +16941 40932 +38413 40932 +46131 40924 +47061 40923 +35097 40917 +25429 40915 +49059 40913 +20724 40912 +31875 40906 +43671 40898 +39271 40887 +23209 40882 +21338 40881 +49536 40878 +42040 40877 +31586 40876 +42618 40876 +39915 40874 +27230 40871 +16232 40868 +9409 40868 +39178 40866 +23700 40866 +39001 40860 +36090 40859 +34150 40858 +28933 40856 +30943 40848 +46896 40845 +24277 40842 +48258 40841 +33631 40835 +3456 40830 +23716 40825 +46450 40824 +31824 40821 +3606 40820 +34006 40819 +27710 40817 +18995 40808 +32752 40805 +40338 40804 +32696 40798 +41597 40785 +40827 40784 +18784 40782 +41837 40780 +29420 40779 +34551 40766 +47342 40762 +48171 40761 +24602 40749 +31193 40749 +40661 40747 +21731 40736 +32213 40734 +18568 40733 +33230 40732 +39047 40730 +18308 40724 +34614 40723 +4440 40723 +43414 40722 +37357 40710 +20133 40708 +43754 40706 +40224 40701 +39262 40700 +34863 40698 +30299 40695 +27969 40689 +10520 40689 +30412 40688 +44146 40684 +46426 40681 +20215 40679 +17477 40678 +38411 40673 +29979 40673 +33657 40671 +44516 40671 +22791 40668 +43188 40661 +17815 40659 +16647 40658 +19752 40656 +23673 40655 +27649 40651 +44473 40650 +28211 40648 +46919 40647 +4949 40647 +23315 40645 +34654 40644 +43726 40642 +28186 40638 +37172 40636 +35629 40634 +22523 40633 +32181 40631 +27017 40630 +33107 40629 +33822 40626 +20816 40625 +29252 40622 +45687 40622 +38193 40618 +33904 40617 +44096 40612 +22117 40611 +45566 40610 +27143 40603 +33595 40601 +36138 40600 +38645 40597 +41246 40593 +27416 40592 +15433 40592 +26350 40591 +31149 40590 +20199 40586 +8039 40584 +37880 40575 +32170 40570 +21286 40569 +19891 40568 +48967 40564 +28239 40556 +33598 40555 +40183 40555 +43933 40547 +37459 40545 +21426 40544 +26506 40544 +39240 40541 +14137 40540 +43288 40534 +29165 40532 +28304 40532 +24136 40527 +16432 40526 +47997 40522 +37001 40522 +24265 40515 +43972 40513 +24096 40506 +28982 40504 +23347 40500 +26897 40497 +18145 40494 +44076 40493 +35797 40490 +12919 40490 +44285 40488 +44620 40484 +29580 40482 +40771 40479 +25270 40479 +28552 40479 +35303 40477 +23142 40459 +43988 40456 +37546 40454 +36190 40452 +27644 40451 +39088 40450 +40773 40447 +35055 40446 +33294 40441 +12306 40439 +40144 40437 +36820 40431 +13989 40429 +9806 40429 +26754 40428 +27776 40428 +39864 40426 +41994 40425 +29130 40418 +17006 40414 +33229 40413 +40617 40411 +20068 40407 +18377 40403 +30745 40401 +24197 40394 +8954 40393 +21898 40391 +17340 40391 +36660 40386 +45443 40386 +35520 40381 +45678 40381 +37885 40381 +1822 40380 +41720 40379 +20924 40378 +16529 40371 +39281 40369 +40906 40345 +50180 40342 +33256 40339 +38308 40329 +12487 40328 +44715 40323 +40986 40323 +19079 40320 +47014 40317 +36691 40309 +39221 40308 +39160 40308 +43003 40307 +22829 40300 +19230 40298 +19564 40292 +35492 40288 +26208 40285 +36489 40283 +17579 40282 +28263 40279 +45378 40274 +48390 40274 +38639 40273 +46902 40273 +28446 40272 +39273 40268 +31564 40268 +31343 40268 +40000 40266 +25319 40265 +30407 40265 +35934 40258 +40048 40255 +42545 40254 +34297 40253 +1396 40249 +44456 40245 +31089 40245 +12234 40236 +13758 40229 +12747 40228 +27774 40228 +22932 40226 +33550 40225 +31975 40223 +40634 40214 +49882 40211 +49952 40208 +32647 40206 +32566 40194 +26995 40192 +31580 40191 +42837 40182 +40614 40181 +35275 40180 +15206 40172 +29972 40168 +48226 40167 +39002 40165 +25447 40165 +28598 40164 +1094 40157 +31031 40157 +16191 40155 +48434 40151 +32094 40150 +13376 40144 +26411 40140 +48759 40139 +29303 40137 +29909 40137 +36672 40136 +25728 40136 +46629 40132 +37341 40125 +23516 40122 +31278 40122 +34725 40120 +41415 40119 +44771 40116 +13260 40112 +23721 40110 +28551 40108 +34644 40108 +37271 40105 +39796 40101 +27192 40099 +20851 40097 +45030 40097 +28715 40097 +27778 40096 +42613 40096 +31454 40091 +40909 40090 +42892 40089 +47149 40089 +31434 40088 +39663 40082 +35939 40080 +30748 40076 +42119 40074 +41903 40074 +13550 40071 +32497 40070 +9545 40066 +21390 40065 +35856 40063 +15786 40060 +34839 40060 +28930 40058 +29776 40056 +17465 40056 +32699 40055 +19706 40054 +22243 40050 +46190 40050 +17288 40042 +32798 40040 +12149 40040 +33950 40033 +46295 40031 +37140 40026 +47624 40026 +41522 40025 +25960 40024 +48367 40022 +36529 40021 +37986 40020 +26977 40020 +35878 40019 +29947 40013 +28103 40013 +45548 40010 +47492 40003 +42858 40002 +41448 40002 +47042 40001 +47140 39987 +49870 39984 +37607 39979 +31792 39970 +28700 39963 +48218 39958 +33039 39958 +29119 39956 +13564 39956 +43200 39953 +21992 39948 +43314 39941 +19638 39941 +29559 39931 +17823 39928 +49290 39927 +12795 39925 +50045 39923 +49866 39916 +24492 39909 +32933 39906 +42371 39904 +13164 39903 +29268 39899 +6746 39896 +32476 39893 +19936 39893 +48456 39893 +38537 39889 +33237 39888 +40678 39885 +25035 39883 +27948 39877 +8890 39877 +36158 39876 +25059 39864 +19815 39864 +48153 39863 +47004 39863 +30238 39861 +45099 39856 +41378 39841 +30820 39839 +36849 39836 +26884 39834 +21037 39832 +21749 39829 +35090 39814 +45419 39812 +29414 39809 +39564 39808 +36326 39801 +42826 39801 +25356 39800 +46379 39796 +14822 39795 +48296 39795 +41532 39791 +43896 39791 +32492 39791 +27753 39790 +48128 39789 +17613 39787 +48904 39786 +49420 39782 +15208 39781 +19231 39779 +17580 39775 +19720 39775 +22865 39773 +29939 39772 +42514 39766 +37215 39765 +40320 39762 +31219 39761 +35582 39761 +35016 39760 +35769 39759 +43424 39758 +9239 39754 +38787 39752 +31869 39746 +25788 39746 +31323 39745 +26533 39740 +39369 39736 +24616 39733 +37987 39731 +45036 39731 +31819 39730 +6382 39727 +37524 39727 +48580 39725 +30495 39725 +36661 39724 +46851 39721 +37464 39717 +34244 39717 +23906 39713 +29767 39711 +21991 39707 +17128 39706 +34025 39705 +20292 39696 +31146 39690 +44221 39679 +28900 39673 +44628 39673 +24676 39672 +14465 39667 +48881 39665 +37738 39664 +20423 39663 +48424 39661 +43278 39661 +34857 39660 +30052 39658 +36906 39657 +33512 39651 +7350 39646 +24274 39645 +37722 39645 +41534 39644 +25944 39644 +42880 39641 +27790 39641 +30304 39640 +31650 39637 +29184 39637 +34417 39636 +13849 39634 +25920 39634 +43113 39625 +36573 39617 +45513 39616 +3736 39616 +26923 39613 +39138 39613 +45763 39610 +36161 39604 +21304 39604 +32110 39602 +37606 39597 +34970 39597 +37683 39585 +3476 39583 +38228 39582 +26019 39581 +30095 39580 +18117 39577 +46041 39577 +12156 39574 +46004 39574 +39510 39573 +35382 39572 +31651 39571 +45121 39568 +32592 39566 +6813 39566 +48022 39565 +35057 39561 +19462 39560 +7153 39559 +36511 39559 +47788 39558 +23021 39555 +36756 39547 +45220 39546 +41824 39545 +13916 39544 +31543 39542 +28567 39541 +24509 39539 +47331 39535 +36637 39534 +22457 39531 +15999 39530 +44803 39530 +33530 39529 +14202 39528 +43359 39528 +41696 39528 +26478 39524 +6892 39524 +26322 39515 +46738 39513 +37623 39512 +28369 39509 +30614 39502 +32683 39495 +30354 39494 +48914 39487 +39798 39485 +13986 39485 +47769 39481 +16097 39479 +38496 39479 +49286 39476 +31794 39471 +44618 39471 +45829 39466 +39593 39461 +15675 39459 +36264 39458 +41891 39449 +8328 39446 +21758 39446 +24936 39437 +42625 39430 +16673 39421 +41410 39418 +27799 39418 +30280 39417 +37952 39416 +34453 39413 +39502 39412 +33919 39409 +41865 39409 +27998 39408 +42402 39406 +25032 39399 +30219 39397 +20104 39395 +15977 39394 +30147 39393 +37149 39393 +10751 39388 +31356 39387 +36012 39380 +3627 39377 +16144 39374 +23392 39364 +33183 39360 +36050 39357 +27172 39351 +28257 39349 +38550 39345 +29253 39338 +28138 39320 +43170 39318 +36068 39318 +42966 39318 +35445 39317 +37810 39316 +22348 39315 +45459 39315 +46035 39312 +26792 39303 +24118 39300 +14473 39299 +45602 39298 +49807 39295 +29132 39292 +20968 39290 +25256 39286 +18060 39283 +30940 39281 +38443 39276 +30948 39268 +32133 39267 +25770 39263 +22950 39256 +30032 39256 +27673 39254 +47405 39250 +40684 39249 +35216 39245 +28447 39240 +12425 39240 +24906 39237 +31209 39234 +35091 39233 +44226 39232 +46637 39219 +27112 39216 +41871 39213 +25061 39213 +46414 39210 +27588 39209 +27218 39207 +30272 39205 +27715 39202 +27289 39202 +41040 39201 +29687 39200 +29449 39200 +43264 39198 +37246 39198 +22800 39197 +24254 39197 +7240 39196 +48026 39193 +43949 39193 +2878 39191 +27171 39188 +20245 39186 +33411 39183 +30501 39183 +26260 39182 +21917 39180 +32117 39172 +47099 39171 +24876 39170 +44708 39169 +25345 39169 +35711 39168 +36519 39165 +27970 39161 +35077 39159 +34328 39158 +47745 39156 +34451 39155 +39832 39152 +24940 39151 +25959 39150 +38648 39141 +17763 39141 +17525 39133 +36332 39131 +11485 39129 +16874 39128 +45546 39126 +27777 39119 +13974 39112 +29965 39111 +18047 39111 +25667 39111 +36339 39109 +31270 39109 +42578 39108 +46878 39108 +48343 39107 +28396 39104 +39865 39104 +37019 39102 +30904 39100 +2336 39100 +39399 39090 +25191 39089 +31111 39080 +26090 39076 +33334 39075 +44058 39073 +44940 39073 +8388 39070 +31427 39063 +29558 39061 +37294 39060 +37949 39057 +21009 39053 +42021 39050 +16409 39045 +40468 39043 +37721 39041 +24870 39039 +36280 39037 +28130 39034 +34741 39033 +40693 39027 +32926 39026 +50191 39025 +44880 39023 +35995 39022 +47750 39021 +32618 39017 +17764 39014 +13278 39009 +44175 39000 +21077 38999 +42201 38998 +34691 38996 +32789 38989 +41209 38985 +36146 38975 +14916 38973 +6311 38970 +50008 38970 +39263 38969 +21492 38968 +42340 38967 +24591 38965 +28520 38962 +28597 38951 +40440 38951 +27345 38949 +23326 38943 +11587 38943 +35184 38933 +28174 38926 +19631 38924 +44697 38924 +45447 38923 +31930 38921 +31557 38918 +34326 38914 +33866 38914 +20044 38912 +27680 38912 +43112 38908 +48049 38907 +25286 38897 +23451 38895 +40273 38893 +22278 38891 +39694 38890 +47959 38890 +49335 38889 +24772 38887 +41884 38886 +44091 38881 +23350 38878 +15720 38876 +33770 38876 +41264 38875 +16414 38873 +24726 38871 +8479 38865 +34611 38862 +40123 38862 +27203 38861 +25707 38859 +46337 38856 +43064 38856 +28936 38855 +36534 38852 +40817 38852 +39110 38851 +21895 38839 +45396 38839 +41342 38837 +44512 38829 +29512 38827 +27917 38827 +21858 38825 +49590 38822 +39477 38821 +20803 38816 +29213 38814 +43942 38807 +17771 38807 +20861 38805 +40905 38799 +11961 38798 +38379 38790 +27564 38790 +48563 38788 +24693 38787 +21153 38784 +28420 38783 +34894 38773 +23092 38771 +49524 38769 +34738 38767 +16099 38767 +37285 38766 +17469 38764 +24279 38760 +48622 38756 +22429 38755 +27009 38754 +47347 38749 +45699 38746 +30110 38740 +17250 38737 +46702 38733 +41370 38730 +48572 38727 +44770 38724 +43929 38714 +35038 38714 +17278 38711 +48274 38710 +6860 38704 +41414 38703 +28825 38699 +42375 38699 +14407 38698 +45429 38693 +41149 38689 +49847 38686 +23036 38685 +10067 38683 +22466 38683 +25785 38674 +34737 38671 +41063 38670 +33849 38667 +41883 38659 +36453 38657 +43032 38653 +35919 38652 +6773 38647 +2466 38644 +15366 38642 +20777 38640 +40268 38636 +40291 38635 +41516 38633 +19044 38633 +35524 38629 +32144 38628 +31805 38627 +38086 38626 +40270 38621 +36336 38621 +33387 38620 +17818 38619 +35800 38617 +34360 38615 +20772 38614 +9821 38611 +46288 38609 +22691 38600 +48422 38597 +25272 38591 +29645 38590 +41018 38589 +20711 38588 +24962 38587 +49510 38587 +47828 38586 +33520 38585 +14368 38577 +32261 38575 +20211 38575 +39198 38573 +46895 38569 +38889 38566 +32391 38562 +44666 38561 +47257 38554 +35710 38554 +47098 38553 +39013 38552 +37274 38544 +23483 38536 +28585 38532 +32109 38530 +46791 38526 +22813 38524 +35870 38516 +25782 38513 +46357 38512 +9271 38512 +45211 38510 +27033 38510 +28976 38498 +45248 38498 +33047 38498 +36380 38494 +47713 38493 +37086 38490 +30624 38490 +38745 38488 +30514 38487 +26611 38487 +2886 38486 +10873 38485 +43351 38484 +41562 38483 +42191 38481 +34841 38481 +45994 38474 +45712 38474 +22921 38473 +41567 38467 +28925 38464 +21577 38461 +21084 38459 +12331 38458 +4187 38456 +29133 38455 +26529 38455 +41013 38451 +48998 38450 +31475 38448 +22657 38445 +29551 38444 +47313 38442 +45769 38424 +38192 38424 +34688 38420 +42240 38414 +18483 38412 +34135 38410 +33488 38403 +31759 38398 +23571 38396 +36946 38395 +41929 38393 +40003 38393 +40878 38387 +34898 38380 +13155 38379 +18160 38378 +2711 38376 +27640 38374 +26485 38370 +41737 38366 +21759 38355 +27486 38353 +38612 38348 +11350 38348 +33591 38347 +28159 38346 +48486 38344 +25823 38344 +46657 38340 +21186 38338 +46312 38332 +29951 38331 +33065 38329 +43504 38328 +22302 38327 +11726 38323 +22622 38322 +35325 38320 +28204 38319 +32680 38318 +23460 38317 +35112 38316 +14964 38314 +34176 38313 +11878 38313 +48406 38312 +40037 38311 +12794 38311 +33048 38310 +30601 38310 +49844 38305 +40964 38304 +31081 38297 +16979 38294 +23402 38292 +17108 38291 +26284 38289 +46852 38285 +39153 38284 +12574 38284 +39180 38282 +27960 38281 +1753 38281 +28627 38280 +40798 38279 +37256 38278 +47982 38274 +45074 38274 +20643 38274 +28588 38272 +2529 38269 +24920 38267 +37624 38267 +9198 38265 +7391 38263 +49187 38262 +23463 38259 +44488 38253 +21797 38246 +26950 38245 +35174 38243 +12940 38229 +34920 38224 +28802 38217 +34641 38216 +44234 38214 +34464 38206 +21985 38199 +24845 38188 +37681 38185 +44767 38185 +38182 38184 +48106 38182 +16913 38182 +17610 38180 +24745 38174 +21610 38172 +30533 38169 +26423 38168 +9289 38166 +34425 38161 +29214 38160 +45342 38154 +14215 38152 +20876 38146 +38425 38145 +31342 38143 +32221 38140 +48566 38137 +32674 38136 +9249 38132 +46730 38132 +32357 38131 +3897 38129 +47022 38124 +20658 38124 +34332 38120 +35427 38120 +26660 38119 +13733 38118 +39580 38113 +32744 38109 +39574 38109 +49400 38108 +37995 38104 +26392 38101 +36919 38101 +37104 38097 +43955 38091 +31572 38090 +14974 38085 +20957 38085 +37630 38085 +2289 38083 +39146 38079 +28140 38078 +39589 38076 +33162 38065 +12409 38065 +29057 38064 +31773 38062 +34869 38059 +10179 38054 +21847 38048 +36539 38044 +24528 38043 +34089 38041 +40496 38041 +47130 38038 +47993 38036 +36817 38036 +38585 38035 +41119 38032 +30376 38031 +46942 38031 +41031 38028 +31359 38025 +48531 38025 +32877 38023 +28306 38023 +3029 38020 +29033 38017 +34948 38016 +44376 38015 +33592 38013 +23580 38012 +38520 38011 +35894 38006 +8014 38001 +39853 37999 +48843 37998 +28302 37993 +16718 37987 +32052 37986 +20911 37986 +47028 37978 +48731 37970 +21382 37967 +44495 37962 +17974 37958 +34298 37958 +6601 37958 +32201 37957 +39015 37956 +29649 37954 +13501 37951 +23437 37948 +32611 37938 +25840 37935 +39348 37935 +29068 37935 +25499 37933 +41861 37932 +27734 37931 +42761 37930 +8637 37929 +30989 37927 +37868 37926 +32547 37921 +18703 37920 +25778 37917 +37333 37911 +37646 37910 +36824 37907 +4435 37901 +39525 37900 +33155 37899 +44151 37890 +45156 37889 +34774 37885 +18069 37882 +35529 37877 +45916 37870 +32337 37866 +36459 37864 +27560 37862 +29538 37862 +30453 37860 +15511 37857 +20413 37857 +21241 37855 +21953 37854 +42320 37853 +26697 37852 +48102 37850 +46783 37847 +49252 37846 +12987 37840 +26983 37839 +16398 37839 +21537 37839 +36016 37837 +17680 37837 +13983 37836 +34441 37836 +37537 37835 +25171 37835 +44390 37829 +37643 37829 +41714 37826 +25870 37822 +24783 37819 +29526 37818 +14191 37818 +34987 37817 +24184 37817 +41320 37813 +18890 37808 +32900 37805 +39556 37800 +43793 37798 +28116 37795 +33508 37787 +32754 37787 +14487 37785 +38209 37779 +45223 37779 +45162 37778 +31018 37777 +20605 37775 +24245 37773 +20497 37773 +24612 37771 +44888 37767 +43503 37766 +49255 37765 +41680 37762 +25404 37762 +42110 37756 +47796 37754 +9652 37754 +22497 37740 +6743 37737 +33178 37735 +44904 37733 +29082 37732 +38853 37730 +23740 37724 +34505 37724 +24180 37715 +20856 37715 +22312 37711 +31227 37707 +20506 37704 +25322 37700 +28727 37699 +40585 37697 +35548 37696 +37611 37694 +45498 37692 +43307 37690 +40714 37688 +35557 37687 +14539 37686 +40249 37684 +17828 37684 +41664 37684 +49874 37684 +37980 37679 +14184 37678 +42101 37673 +26308 37671 +13603 37668 +34872 37666 +45846 37666 +48928 37665 +36575 37664 +28481 37662 +42743 37662 +38272 37662 +22119 37659 +50060 37658 +15803 37651 +18019 37650 +43783 37649 +42241 37647 +21728 37646 +39082 37626 +36234 37622 +40755 37614 +23653 37610 +44766 37607 +43744 37604 +8578 37601 +45054 37601 +31510 37600 +32338 37599 +834 37595 +30194 37591 +40593 37584 +24213 37583 +25149 37579 +48681 37575 +46016 37572 +27140 37567 +33509 37567 +44635 37562 +47825 37562 +38359 37561 +13689 37551 +32298 37549 +45237 37543 +24468 37539 +43709 37534 +9451 37532 +26872 37526 +22913 37525 +18601 37524 +19570 37521 +22163 37517 +34771 37517 +49727 37511 +40919 37510 +38306 37505 +22226 37503 +44507 37500 +33004 37499 +41236 37491 +47416 37490 +35168 37489 +15884 37488 +32156 37485 +21780 37484 +32161 37482 +15552 37479 +32493 37479 +39501 37479 +46313 37477 +13437 37473 +36689 37468 +32209 37464 +32299 37460 +29024 37458 +39114 37454 +26168 37454 +20264 37453 +36237 37450 +35598 37448 +40547 37444 +12905 37430 +38060 37421 +20943 37420 +47739 37419 +5020 37415 +24991 37414 +26987 37412 +34039 37411 +25083 37408 +29270 37408 +22648 37399 +39484 37399 +22991 37397 +36238 37392 +40868 37391 +16284 37386 +5841 37383 +40327 37382 +38127 37380 +35688 37374 +35996 37373 +15042 37371 +22324 37369 +24222 37366 +41268 37365 +24275 37365 +33036 37362 +30692 37362 +32012 37362 +48306 37361 +44827 37356 +26705 37354 +44331 37353 +36322 37351 +29555 37350 +16598 37342 +47055 37339 +33735 37339 +18937 37337 +35761 37335 +26045 37333 +13732 37328 +25648 37325 +38876 37325 +36097 37322 +15445 37321 +47062 37318 +27277 37318 +30788 37316 +11413 37316 +27522 37314 +14577 37310 +34594 37309 +42346 37304 +36478 37303 +42264 37302 +29157 37302 +31300 37302 +36340 37299 +35723 37296 +49789 37293 +7434 37292 +20855 37288 +40410 37287 +44368 37286 +45075 37283 +44049 37282 +28740 37279 +31287 37278 +17529 37277 +17138 37271 +40170 37271 +26448 37263 +30685 37263 +22419 37258 +41846 37255 +33966 37253 +42951 37251 +46675 37251 +26979 37249 +50071 37249 +24839 37248 +34378 37244 +25399 37238 +37088 37238 +27255 37237 +47584 37236 +30499 37235 +10572 37235 +18173 37231 +28647 37231 +3289 37225 +4110 37224 +39813 37220 +16802 37217 +26912 37216 +36349 37214 +43227 37212 +47039 37210 +37306 37209 +10877 37205 +29318 37205 +37901 37204 +5111 37204 +16087 37202 +40953 37199 +29807 37198 +45143 37198 +49417 37193 +36412 37190 +43369 37190 +40152 37176 +21839 37167 +41917 37166 +17618 37151 +19385 37151 +44388 37148 +34401 37143 +49558 37140 +18209 37140 +47704 37139 +32593 37136 +35148 37132 +38439 37126 +43386 37115 +38884 37115 +25095 37111 +28164 37104 +22059 37103 +3276 37102 +36035 37102 +20482 37101 +46043 37100 +47203 37089 +8316 37089 +32817 37087 +35826 37081 +26787 37078 +48629 37077 +27656 37075 +46466 37075 +15876 37064 +38975 37064 +39973 37064 +33492 37060 +43222 37058 +37220 37058 +47566 37049 +42418 37046 +42515 37043 +20599 37042 +34289 37042 +37526 37041 +43497 37041 +36179 37039 +47248 37034 +47767 37032 +19944 37027 +33438 37026 +33840 37025 +12726 37025 +39931 37024 +21633 37020 +40991 37016 +28522 37014 +40796 37012 +25796 37008 +35737 37003 +34494 37001 +22728 36999 +29992 36997 +47494 36996 +34387 36992 +45782 36990 +31897 36990 +31485 36981 +13284 36981 +39207 36980 +12143 36980 +44232 36977 +37873 36975 +46105 36973 +25161 36970 +23211 36968 +39851 36967 +18747 36964 +41315 36964 +32455 36960 +21013 36959 +30638 36957 +13857 36955 +29587 36954 +35052 36953 +43751 36953 +28017 36952 +24678 36948 +18426 36944 +45927 36942 +20053 36940 +21303 36938 +24624 36937 +31243 36936 +15746 36935 +34063 36935 +45161 36932 +14055 36932 +28200 36929 +37064 36926 +25369 36924 +42851 36921 +45043 36915 +46696 36908 +26108 36908 +24603 36907 +8214 36907 +27149 36904 +42252 36900 +19737 36893 +24974 36890 +41039 36886 +42664 36885 +17943 36885 +30332 36885 +5925 36880 +27207 36880 +17024 36878 +26972 36871 +6730 36869 +32008 36867 +20961 36862 +21217 36860 +47631 36849 +43186 36848 +42017 36846 +15826 36843 +5723 36842 +31169 36838 +27057 36838 +37192 36829 +29968 36829 +20427 36826 +18910 36823 +33811 36822 +48179 36822 +27402 36822 +36599 36817 +43203 36811 +32231 36808 +32532 36804 +29349 36804 +16725 36803 +47496 36802 +36860 36795 +38669 36791 +45497 36785 +4234 36784 +23464 36776 +41400 36770 +28071 36761 +16286 36760 +47460 36759 +26086 36753 +36838 36750 +38221 36748 +44257 36741 +16198 36730 +10632 36727 +29598 36725 +32107 36725 +31766 36720 +38051 36719 +39454 36717 +45995 36715 +19689 36713 +45948 36711 +28788 36710 +36844 36708 +2757 36708 +21981 36706 +49230 36704 +22988 36703 +18457 36701 +37409 36700 +22279 36698 +41521 36691 +38722 36691 +36973 36682 +35867 36678 +32626 36677 +44584 36674 +32651 36674 +20459 36673 +47888 36672 +35458 36671 +34716 36669 +19146 36665 +45609 36664 +29763 36659 +43206 36655 +44725 36655 +31503 36650 +40381 36649 +16234 36647 +42926 36646 +41693 36645 +19803 36640 +33862 36639 +21902 36630 +33603 36629 +35356 36625 +49606 36620 +48373 36619 +10410 36617 +49890 36612 +39635 36611 +9710 36610 +38323 36610 +33109 36610 +25285 36609 +11407 36606 +38386 36599 +48261 36598 +47387 36594 +33928 36591 +25622 36591 +17822 36591 +21281 36589 +46525 36588 +25946 36587 +49581 36580 +34834 36579 +10180 36579 +33560 36576 +43562 36576 +20141 36569 +45386 36569 +44275 36564 +44098 36563 +16485 36560 +36901 36559 +7783 36557 +25418 36556 +33266 36551 +35139 36546 +24452 36542 +37087 36538 +24875 36538 +27800 36537 +34711 36537 +28857 36534 +26407 36533 +23020 36533 +29286 36531 +5113 36529 +30734 36525 +24770 36523 +41554 36520 +10879 36518 +28728 36517 +16928 36514 +21202 36503 +32172 36503 +34538 36501 +38961 36499 +36344 36496 +41539 36494 +49414 36493 +27982 36491 +34266 36483 +35218 36480 +32708 36474 +30425 36468 +34503 36467 +30463 36464 +45535 36457 +31029 36450 +37543 36449 +22620 36449 +24970 36448 +37454 36447 +46407 36444 +34109 36442 +27372 36441 +7182 36439 +35353 36438 +39287 36436 +28868 36435 +39338 36433 +29134 36428 +18941 36425 +44094 36418 +25653 36415 +33781 36413 +42639 36412 +11269 36410 +46711 36403 +27563 36401 +9394 36398 +37062 36397 +33138 36395 +29561 36386 +31925 36377 +47339 36364 +25278 36362 +31521 36360 +16770 36356 +38265 36356 +35137 36352 +35714 36346 +22530 36342 +31858 36341 +13862 36341 +47108 36340 +10775 36334 +24943 36333 +41579 36330 +42910 36328 +946 36325 +40007 36319 +45764 36316 +35161 36316 +40140 36308 +40737 36289 +39190 36287 +43115 36287 +13712 36286 +45503 36280 +26829 36280 +48786 36269 +47223 36267 +30991 36264 +9407 36260 +13928 36258 +28907 36255 +37355 36254 +27785 36251 +32698 36248 +32037 36243 +47640 36241 +36958 36238 +19967 36234 +38078 36231 +33015 36231 +16071 36226 +27653 36222 +23565 36222 +46467 36222 +42362 36221 +29429 36220 +47260 36217 +33408 36216 +29801 36215 +23318 36214 +29728 36213 +31738 36212 +22396 36208 +35015 36203 +8003 36198 +47805 36195 +16266 36193 +35899 36184 +46619 36182 +27967 36177 +19795 36173 +45062 36165 +28979 36163 +46548 36163 +16751 36161 +24149 36159 +35028 36155 +27896 36154 +41710 36150 +40857 36147 +38036 36146 +32950 36142 +34581 36135 +28817 36130 +48215 36128 +44967 36127 +41247 36127 +36082 36123 +42447 36116 +46208 36113 +13080 36113 +49777 36112 +11656 36112 +28301 36109 +9534 36108 +35863 36104 +43627 36102 +25382 36102 +37814 36095 +49547 36094 +31188 36089 +31753 36089 +20702 36087 +26915 36082 +46062 36080 +18776 36079 +26492 36077 +31093 36075 +42046 36069 +36666 36067 +38046 36066 +47453 36065 +35519 36064 +40757 36064 +44001 36063 +19583 36062 +41754 36061 +15047 36061 +37115 36061 +6744 36058 +46769 36055 +25998 36053 +48803 36049 +39239 36047 +14078 36047 +16942 36045 +28974 36044 +49162 36042 +40071 36039 +46656 36039 +1608 36037 +28896 36036 +44875 36035 +15640 36035 +24911 36031 +42028 36031 +48776 36031 +38200 36029 +42941 36022 +18055 36021 +42882 36014 +37185 36014 +20930 36012 +33027 36010 +8745 36003 +29008 36002 +47478 36002 +48667 36002 +44611 36000 +34993 35998 +27889 35998 +44823 35994 +42391 35988 +32855 35987 +16233 35985 +43840 35983 +35484 35982 +27760 35976 +33289 35970 +9590 35970 +38304 35969 +19963 35962 +50142 35961 +48357 35955 +40697 35955 +48450 35952 +28953 35946 +48574 35944 +42231 35942 +49879 35942 +38185 35931 +25022 35930 +15127 35929 +22713 35923 +49445 35922 +21360 35921 +29099 35917 +36527 35910 +43960 35909 +49363 35905 +20205 35904 +37223 35903 +32755 35900 +8413 35899 +49772 35896 +45484 35895 +37125 35895 +13313 35894 +47268 35893 +42292 35892 +46292 35887 +35531 35880 +42870 35880 +17230 35878 +27081 35878 +26682 35876 +42972 35876 +2699 35875 +27533 35875 +33499 35873 +24856 35867 +24305 35866 +21227 35865 +41214 35864 +15681 35860 +34232 35858 +42900 35856 +30005 35850 +34080 35849 +42594 35847 +28592 35843 +39226 35843 +44571 35842 +41528 35833 +26993 35830 +35431 35828 +23835 35828 +26598 35820 +31412 35805 +41840 35803 +46658 35802 +14231 35801 +33982 35794 +23881 35794 +15048 35791 +8926 35791 +27040 35789 +31170 35786 +44581 35779 +45457 35779 +39674 35779 +32227 35778 +25153 35774 +2880 35769 +7704 35767 +23468 35762 +23971 35758 +47083 35754 +42517 35751 +17303 35748 +36102 35744 +30741 35743 +47401 35734 +43185 35725 +30727 35722 +32568 35720 +44907 35720 +9982 35713 +40761 35712 +28096 35711 +29976 35704 +39129 35700 +10886 35696 +34923 35692 +42462 35690 +32274 35688 +19085 35678 +19926 35674 +28430 35673 +17287 35666 +49684 35665 +35021 35663 +28297 35658 +43388 35658 +27659 35654 +37571 35653 +26968 35653 +40120 35653 +43131 35653 +49909 35652 +16990 35649 +15484 35647 +49334 35646 +41108 35642 +37413 35642 +41685 35640 +38598 35635 +30615 35635 +27249 35635 +31730 35634 +15204 35633 +12646 35631 +40126 35629 +42927 35628 +46635 35627 +41254 35626 +30528 35620 +39539 35620 +27019 35616 +11794 35615 +41226 35610 +41125 35610 +31814 35609 +34756 35609 +18567 35607 +49009 35603 +47664 35603 +31211 35600 +41854 35597 +28843 35595 +3693 35594 +31716 35591 +21288 35591 +24877 35586 +46242 35583 +44989 35583 +41123 35582 +50176 35577 +44355 35575 +43342 35575 +35545 35574 +23836 35571 +39863 35570 +13911 35570 +18943 35558 +34689 35558 +26268 35552 +45240 35547 +38991 35547 +5148 35544 +46814 35535 +3396 35534 +42370 35530 +28676 35528 +29954 35523 +22240 35522 +30483 35522 +48525 35509 +39081 35508 +29818 35499 +46829 35499 +48202 35493 +42088 35491 +32112 35488 +36079 35487 +48383 35487 +37111 35486 +10612 35485 +9614 35485 +36668 35481 +32549 35481 +37210 35480 +14016 35477 +42423 35477 +22860 35475 +48986 35473 +7094 35473 +27158 35471 +28922 35468 +34253 35460 +38791 35458 +33689 35457 +47868 35448 +40054 35446 +30835 35446 +35960 35441 +31010 35438 +11869 35437 +16017 35432 +46715 35430 +23833 35430 +21495 35430 +22606 35428 +40608 35427 +25086 35427 +25341 35425 +9213 35424 +38227 35424 +40450 35418 +28640 35418 +26273 35416 +20735 35411 +29500 35409 +46631 35407 +24575 35399 +40070 35397 +39384 35396 +31192 35395 +42106 35393 +25540 35390 +16451 35387 +49935 35380 +10722 35379 +46626 35371 +7717 35370 +13383 35370 +33148 35364 +47476 35363 +21170 35360 +38912 35356 +42508 35356 +46909 35350 +38190 35349 +40300 35348 +35704 35345 +43978 35343 +20405 35335 +25437 35334 +24724 35332 +26246 35330 +11488 35329 +18893 35328 +27392 35326 +14312 35325 +46534 35325 +20315 35325 +45735 35322 +24242 35319 +45405 35317 +33083 35316 +28850 35315 +48748 35314 +6704 35312 +47163 35312 +33016 35310 +18795 35307 +39741 35305 +33960 35302 +48221 35300 +32779 35299 +35005 35295 +27189 35294 +11371 35292 +34035 35284 +20987 35280 +43511 35277 +14647 35269 +34690 35268 +48358 35267 +35643 35266 +26313 35264 +34036 35264 +45350 35263 +48420 35263 +46348 35261 +34785 35258 +43958 35257 +30248 35252 +39885 35252 +25089 35251 +15496 35245 +27797 35240 +26276 35239 +6145 35233 +38848 35230 +31102 35227 +32171 35225 +40078 35223 +42825 35219 +49654 35218 +48656 35218 +15148 35216 +29087 35211 +49679 35210 +6812 35205 +40831 35205 +36972 35201 +42741 35189 +40515 35184 +31649 35174 +6760 35169 +40395 35168 +24820 35166 +25511 35165 +10355 35164 +48636 35163 +13295 35163 +34670 35161 +40589 35155 +23042 35154 +30267 35154 +7154 35154 +36446 35144 +40446 35139 +44565 35137 +21019 35128 +33211 35128 +49530 35126 +27339 35122 +32786 35117 +38238 35113 +28048 35113 +42002 35109 +36738 35109 +23144 35107 +38267 35105 +42339 35105 +33416 35105 +32575 35104 +44219 35104 +8928 35102 +25269 35097 +6433 35096 +49575 35089 +40326 35089 +36014 35087 +2762 35080 +29069 35075 +48347 35074 +37733 35074 +25898 35071 +34341 35070 +32653 35065 +43837 35062 +39155 35059 +23912 35058 +17018 35051 +11385 35051 +29204 35045 +29174 35043 +44981 35040 +39496 35037 +42836 35032 +31009 35026 +31566 35026 +32142 35020 +32996 35020 +34658 35017 +20203 35016 +45098 35010 +12315 35005 +12611 35003 +21018 34996 +4733 34995 +36057 34994 +3168 34984 +42607 34983 +25991 34979 +42422 34979 +31947 34976 +46652 34975 +44590 34974 +39797 34972 +40871 34969 +44810 34969 +19203 34962 +26551 34961 +41795 34952 +30802 34949 +44306 34948 +41586 34939 +29096 34936 +36564 34935 +33341 34931 +38006 34931 +41918 34931 +43716 34931 +45315 34930 +38135 34929 +42988 34929 +37041 34928 +29322 34914 +38373 34914 +20810 34913 +40115 34913 +32886 34910 +41699 34908 +45652 34907 +34859 34905 +39389 34901 +21881 34898 +14385 34898 +32143 34897 +45085 34897 +13265 34896 +45017 34895 +39233 34893 +45172 34892 +38966 34888 +27910 34888 +29122 34887 +39740 34880 +30505 34877 +37212 34877 +32185 34869 +16520 34868 +41231 34865 +33121 34865 +34721 34860 +17190 34857 +34730 34856 +41747 34856 +28684 34850 +40294 34847 +26525 34838 +32129 34834 +47421 34829 +38842 34825 +4655 34821 +45407 34816 +24100 34815 +30971 34811 +31166 34808 +46964 34803 +39439 34801 +33475 34799 +42022 34799 +43853 34797 +44806 34796 +26895 34794 +17309 34794 +21928 34793 +28872 34793 +30707 34790 +34278 34788 +47450 34785 +32621 34780 +31476 34778 +29298 34770 +46881 34770 +45502 34767 +38008 34766 +45525 34763 +12792 34761 +46622 34759 +44643 34757 +23123 34753 +26381 34752 +36209 34744 +24750 34742 +23644 34740 +30373 34739 +41855 34738 +6471 34737 +31397 34737 +41478 34736 +26146 34736 +24736 34733 +43189 34733 +21524 34731 +38621 34728 +36932 34727 +29448 34726 +12679 34717 +47193 34711 +49278 34711 +20641 34710 +17171 34709 +46891 34701 +23219 34700 +31135 34696 +39229 34694 +31607 34694 +47027 34690 +19559 34686 +24917 34683 +33607 34679 +35556 34679 +29552 34676 +47495 34674 +46017 34673 +24043 34668 +27676 34664 +31778 34656 +6604 34655 +5459 34649 +43507 34645 +49791 34645 +30805 34643 +29903 34641 +33301 34640 +6406 34638 +35131 34630 +42793 34628 +41186 34627 +38731 34627 +23924 34626 +41157 34625 +49304 34622 +27531 34622 +40760 34620 +8232 34617 +50136 34615 +18072 34615 +39793 34608 +22356 34606 +32051 34603 +9668 34602 +23998 34602 +40716 34601 +36177 34597 +40137 34595 +25536 34594 +44182 34592 +37661 34591 +41431 34590 +25400 34588 +46230 34584 +30199 34583 +39322 34583 +30584 34582 +36135 34580 +49827 34580 +31786 34580 +27159 34579 +12893 34579 +28439 34573 +41654 34564 +49600 34559 +26675 34558 +32016 34558 +32686 34557 +48598 34556 +22409 34556 +38206 34551 +23552 34550 +12621 34549 +29275 34547 +24155 34545 +25822 34541 +30361 34540 +47428 34538 +47610 34538 +46709 34535 +44845 34534 +42767 34533 +45334 34533 +32545 34530 +39460 34529 +42727 34528 +32375 34528 +34484 34522 +40131 34521 +43051 34519 +27920 34516 +35569 34513 +34382 34513 +30780 34506 +26303 34504 +28881 34499 +32378 34493 +36033 34486 +24895 34484 +32759 34479 +21090 34473 +30155 34472 +46549 34472 +45226 34469 +36043 34468 +49817 34468 +37782 34466 +35483 34466 +22754 34465 +42205 34464 +19543 34460 +20341 34457 +48537 34457 +29129 34456 +28782 34455 +5376 34452 +13425 34451 +17684 34448 +13907 34447 +49119 34445 +47434 34442 +50128 34441 +31514 34440 +28362 34428 +47229 34422 +34532 34419 +23496 34419 +48596 34418 +28692 34416 +45918 34414 +30435 34413 +39326 34409 +36006 34402 +14940 34402 +36105 34400 +18667 34398 +33040 34395 +32386 34395 +23338 34392 +40487 34390 +30148 34389 +30616 34385 +34057 34381 +41250 34380 +30338 34373 +36367 34371 +29923 34370 +18007 34369 +21901 34368 +19336 34366 +41321 34366 +23079 34364 +16819 34362 +21897 34362 +39981 34360 +8731 34357 +40309 34352 +24732 34352 +13484 34350 +48985 34350 +21132 34348 +33149 34348 +44474 34347 +34452 34347 +42879 34346 +32591 34345 +21466 34343 +45698 34338 +41393 34335 +29528 34332 +23222 34331 +24665 34329 +24792 34324 +34418 34321 +27988 34317 +17516 34305 +39191 34289 +46848 34288 +39838 34287 +48180 34286 +23573 34286 +34568 34280 +29215 34276 +18554 34275 +33620 34274 +47620 34273 +30749 34271 +30804 34270 +47662 34268 +42566 34261 +41549 34253 +16488 34252 +30121 34251 +32561 34247 +25663 34246 +43527 34243 +36819 34242 +43067 34237 +21328 34233 +33451 34231 +26309 34230 +44995 34227 +27359 34226 +31924 34225 +31667 34223 +30806 34220 +39152 34220 +32781 34219 +48586 34217 +12021 34216 +30560 34214 +9043 34211 +21557 34203 +32820 34198 +45972 34193 +31082 34192 +19453 34188 +27860 34185 +8619 34185 +49243 34184 +49840 34181 +12745 34180 +27641 34180 +15132 34173 +43079 34172 +26864 34170 +32861 34170 +48118 34167 +14127 34166 +45436 34164 +44674 34159 +46913 34159 +36968 34157 +30458 34152 +8134 34149 +35162 34147 +19366 34144 +23874 34139 +33443 34136 +24525 34136 +40830 34124 +26854 34124 +34864 34124 +20146 34122 +17744 34115 +45138 34114 +49708 34113 +28736 34104 +45655 34101 +25312 34099 +25344 34097 +40565 34092 +45241 34086 +32191 34086 +5590 34083 +28065 34079 +40834 34073 +49248 34072 +22544 34071 +15856 34066 +45275 34064 +43802 34061 +30639 34056 +48833 34053 +44244 34050 +40930 34048 +33456 34044 +38347 34041 +33282 34041 +11785 34041 +49792 34034 +45997 34030 +33776 34029 +21482 34029 +48521 34026 +46517 34026 +37407 34020 +34887 34017 +11361 34017 +32292 34016 +49911 34012 +33688 34010 +32192 34010 +38923 34007 +34826 34006 +16884 33999 +25378 33998 +44645 33991 +26235 33991 +19588 33983 +37052 33979 +35408 33978 +47146 33976 +16768 33975 +5131 33974 +47367 33968 +47165 33965 +34011 33964 +40473 33963 +33535 33962 +34194 33959 +43865 33958 +34493 33957 +46196 33952 +38130 33952 +24552 33950 +34449 33949 +41237 33949 +49868 33942 +15479 33940 +10851 33939 +15004 33939 +32118 33936 +19452 33930 +39680 33926 +49699 33922 +36021 33922 +29167 33914 +10661 33914 +49000 33912 +5784 33912 +36531 33902 +37375 33900 +14681 33900 +25899 33899 +46317 33899 +45168 33898 +6501 33898 +14755 33897 +25239 33890 +28484 33889 +48696 33888 +31279 33888 +40121 33887 +45179 33883 +45954 33880 +13867 33879 +24367 33879 +24202 33877 +41160 33873 +15717 33868 +49099 33867 +4212 33865 +47742 33861 +35820 33858 +7774 33856 +27012 33854 +47761 33854 +44505 33853 +39565 33850 +27030 33848 +44580 33848 +40813 33848 +44283 33847 +46390 33844 +33930 33842 +18417 33842 +41475 33835 +45061 33834 +27018 33833 +35176 33832 +42959 33824 +37252 33824 +37970 33822 +30673 33822 +22088 33821 +44240 33821 +34230 33821 +40210 33817 +40494 33812 +49831 33809 +39388 33804 +46524 33795 +47550 33795 +18674 33790 +45365 33786 +8555 33783 +26160 33780 +44428 33780 +41016 33779 +30403 33778 +36449 33772 +21111 33770 +26569 33767 +40949 33765 +37183 33759 +29626 33758 +43332 33758 +42893 33757 +4882 33755 +22996 33752 +41956 33751 +46706 33751 +10034 33748 +39579 33748 +46307 33745 +27696 33744 +47887 33741 +48878 33738 +34192 33731 +30936 33717 +29197 33716 +45939 33712 +20504 33710 +42874 33710 +39993 33709 +43818 33706 +34423 33705 +43553 33703 +38156 33702 +31760 33701 +47866 33689 +32258 33685 +30558 33682 +39642 33680 +32838 33679 +36202 33679 +44005 33677 +37594 33673 +5431 33673 +34396 33664 +31834 33662 +19535 33660 +36535 33654 +30222 33647 +37933 33646 +41350 33645 +19512 33643 +37397 33640 +47810 33639 +9483 33638 +31677 33631 +25839 33628 +27729 33626 +42807 33620 +40237 33620 +36585 33615 +36923 33615 +46646 33605 +16037 33592 +25700 33590 +22239 33583 +21034 33580 +30318 33577 +35086 33577 +38341 33571 +25383 33570 +38050 33570 +27757 33567 +42265 33566 +40722 33565 +38584 33564 +42099 33561 +45306 33560 +4468 33552 +29794 33550 +32551 33549 +39425 33548 +36466 33543 +35640 33540 +41259 33537 +28681 33535 +25353 33533 +30368 33531 +34125 33526 +34925 33525 +45642 33525 +49032 33524 +48977 33518 +19067 33516 +33397 33514 +34846 33514 +34322 33512 +45313 33511 +27503 33509 +42688 33502 +21863 33502 +33046 33498 +40150 33484 +34511 33479 +28460 33476 +33057 33475 +24765 33473 +31914 33473 +37080 33472 +38869 33472 +21944 33470 +34065 33468 +24733 33466 +32709 33465 +23291 33464 +37881 33463 +36223 33462 +34412 33459 +11484 33459 +42444 33458 +33671 33457 +49384 33454 +26028 33453 +41421 33448 +34918 33447 +10772 33446 +32565 33443 +15877 33442 +16973 33442 +42129 33441 +36218 33440 +49142 33438 +28543 33437 +17911 33437 +41751 33436 +47105 33435 +43210 33433 +10646 33432 +45832 33414 +46737 33408 +37353 33405 +36845 33405 +17717 33405 +41001 33405 +33287 33403 +40174 33399 +38090 33398 +9895 33397 +44371 33395 +35883 33391 +38397 33390 +16539 33381 +23379 33372 +45950 33372 +48595 33371 +28115 33369 +36794 33368 +36736 33364 +27385 33364 +35516 33361 +29477 33360 +28977 33358 +32329 33357 +38327 33357 +14596 33356 +40102 33353 +44364 33346 +34514 33345 +33055 33343 +28440 33341 +48519 33338 +24674 33335 +27450 33332 +22262 33330 +48240 33325 +7693 33325 +38123 33324 +27665 33323 +30070 33322 +35872 33322 +28149 33321 +42262 33319 +46961 33315 +47433 33314 +23035 33311 +10881 33308 +43880 33307 +47591 33307 +19393 33307 +15672 33301 +14152 33298 +12327 33297 +46174 33296 +33327 33296 +43165 33292 +33537 33292 +40229 33290 +44735 33287 +41109 33280 +40534 33277 +49364 33277 +42913 33274 +47002 33273 +18254 33270 +10440 33263 +43672 33260 +29606 33260 +19807 33258 +33166 33256 +14970 33253 +49859 33251 +25590 33251 +20218 33250 +42968 33250 +7033 33249 +39976 33248 +37024 33248 +24285 33242 +35225 33241 +35527 33241 +46225 33240 +40508 33237 +49291 33237 +39486 33235 +26677 33233 +30798 33229 +41623 33228 +36825 33225 +29201 33223 +34318 33223 +41117 33219 +43344 33219 +23863 33217 +33304 33216 +28208 33214 +38751 33212 +36893 33209 +44277 33207 +34157 33207 +18934 33204 +42361 33204 +21209 33201 +44619 33195 +29077 33193 +45324 33193 +24133 33191 +20548 33189 +40625 33187 +43852 33186 +32057 33186 +47729 33178 +38677 33177 +16000 33176 +37754 33176 +49838 33175 +31553 33170 +22735 33165 +13438 33163 +19428 33162 +32841 33161 +46382 33161 +23340 33158 +21449 33156 +33626 33155 +35358 33152 +39300 33151 +46401 33149 +13828 33147 +41921 33147 +26097 33146 +40896 33144 +18430 33141 +21484 33141 +37502 33139 +20451 33139 +26531 33138 +28290 33137 +47691 33135 +46226 33131 +13935 33126 +27303 33124 +26230 33124 +32297 33121 +35491 33118 +49910 33115 +29001 33112 +34277 33110 +50100 33109 +41907 33108 +3997 33107 +42255 33104 +8820 33102 +41975 33101 +20087 33096 +26069 33092 +25873 33088 +36032 33087 +47917 33086 +45010 33082 +19596 33082 +33774 33080 +22794 33077 +49178 33077 +24863 33075 +42598 33072 +7843 33070 +41558 33064 +39989 33064 +49349 33063 +39966 33061 +30100 33059 +38348 33054 +43044 33049 +35461 33044 +30799 33043 +41802 33041 +27626 33039 +41879 33038 +26552 33038 +26200 33036 +47645 33036 +27961 33036 +28072 33034 +30290 33032 +29607 33023 +32563 33022 +27706 33021 +30703 33019 +30742 33010 +42647 33006 +14094 33006 +26845 33001 +38486 33000 +39351 32999 +43360 32998 +46243 32998 +44716 32993 +47222 32991 +33679 32989 +44937 32986 +35725 32982 +36638 32982 +2707 32979 +44462 32977 +40995 32977 +31675 32976 +26970 32967 +22340 32967 +40883 32966 +42491 32964 +21222 32960 +30689 32952 +43494 32950 +31722 32945 +45550 32944 +37844 32942 +45779 32939 +38749 32938 +43088 32936 +20028 32934 +32349 32933 +7775 32931 +34115 32929 +43635 32926 +44304 32923 +4192 32923 +42617 32923 +24613 32919 +42146 32919 +30181 32919 +17605 32915 +44712 32915 +31511 32908 +48145 32906 +34394 32906 +34942 32904 +37255 32902 +33754 32897 +33106 32895 +44720 32895 +38042 32895 +29061 32894 +17037 32890 +44861 32887 +28734 32885 +6984 32878 +44377 32872 +45451 32865 +43567 32865 +17204 32865 +43133 32864 +19220 32864 +13896 32862 +38573 32861 +44656 32853 +29584 32853 +33690 32852 +33712 32852 +27913 32852 +43598 32849 +28287 32848 +30896 32845 +42659 32844 +22011 32844 +28562 32843 +36115 32843 +49573 32838 +13451 32833 +18484 32833 +49559 32825 +37792 32824 +28877 32823 +37807 32821 +44142 32820 +47782 32817 +25009 32812 +8017 32810 +42633 32809 +31921 32808 +49331 32807 +17980 32805 +23830 32799 +34868 32796 +19998 32793 +25042 32792 +35858 32792 +37107 32791 +27783 32789 +24595 32784 +40968 32782 +45360 32780 +46392 32776 +43279 32773 +28468 32772 +40416 32770 +15214 32769 +31900 32765 +47958 32764 +17954 32763 +49237 32758 +42200 32751 +24192 32751 +22357 32750 +32409 32750 +36222 32749 +20904 32745 +5893 32745 +31899 32744 +6913 32742 +33390 32740 +41038 32739 +43560 32737 +41122 32732 +35333 32730 +20429 32730 +45041 32729 +9838 32729 +46806 32726 +22284 32724 +37398 32723 +31707 32723 +37202 32722 +41210 32717 +14334 32716 +48743 32715 +42755 32714 +27714 32713 +35108 32712 +31640 32712 +31550 32711 +48829 32711 +5993 32703 +46843 32701 +43107 32698 +13710 32698 +39959 32696 +35634 32692 +26150 32690 +42377 32690 +21560 32689 +39395 32686 +34833 32684 +40597 32683 +32525 32681 +11595 32680 +40017 32679 +6146 32677 +27424 32677 +30429 32677 +26948 32675 +32764 32674 +28327 32670 +36001 32669 +41674 32668 +49725 32666 +8380 32665 +29251 32661 +30766 32660 +11750 32656 +8521 32652 +48329 32647 +42128 32647 +34598 32643 +33504 32642 +32303 32640 +10196 32640 +34465 32636 +28557 32635 +18528 32634 +3293 32630 +45558 32630 +36765 32629 +36187 32629 +4080 32627 +32220 32625 +27781 32620 +36465 32613 +40191 32612 +28221 32602 +46188 32598 +41154 32598 +49245 32597 +29441 32597 +2467 32596 +1696 32595 +46419 32587 +3171 32585 +42859 32579 +35290 32577 +27652 32573 +39430 32573 +33169 32569 +37785 32565 +31084 32565 +36396 32562 +47019 32559 +24700 32558 +10847 32555 +23196 32551 +40501 32548 +39541 32545 +34563 32542 +48715 32541 +36318 32540 +33298 32539 +47320 32539 +34409 32539 +30127 32538 +30995 32537 +38691 32535 +48704 32533 +802 32530 +41418 32529 +16177 32526 +25855 32526 +26231 32525 +35857 32522 +19457 32522 +30123 32521 +35599 32521 +45802 32521 +35084 32519 +30434 32518 +43136 32515 +47948 32514 +47115 32513 +26342 32510 +18746 32509 +50102 32504 +39474 32502 +44193 32497 +27222 32497 +9311 32497 +8899 32494 +2027 32494 +38985 32491 +23364 32486 +8317 32483 +47119 32482 +4416 32477 +37312 32475 +3243 32475 +21181 32468 +42513 32468 +27342 32468 +36155 32468 +36731 32467 +40527 32467 +47820 32464 +46624 32460 +37433 32459 +46959 32451 +32389 32450 +13636 32449 +35669 32446 +15156 32445 +12773 32444 +36841 32444 +35563 32441 +39577 32433 +28062 32427 +49038 32426 +29854 32418 +47008 32417 +34751 32413 +48621 32412 +40525 32411 +27212 32409 +47054 32406 +45120 32403 +21551 32403 +49198 32398 +47619 32397 +14781 32397 +43082 32396 +50185 32395 +26265 32395 +33440 32391 +34275 32385 +47386 32379 +41428 32378 +35959 32377 +45889 32375 +34323 32372 +39599 32370 +41750 32368 +46991 32365 +40536 32363 +41527 32361 +39937 32361 +32282 32356 +35931 32353 +8569 32352 +11714 32346 +39804 32337 +5463 32336 +31496 32333 +33389 32333 +34757 32330 +21184 32330 +32637 32325 +40836 32323 +6863 32321 +46400 32320 +35322 32315 +43091 32309 +27287 32302 +42844 32297 +38515 32293 +24885 32293 +30832 32291 +40535 32290 +35352 32289 +38010 32288 +31883 32285 +32446 32283 +30824 32275 +36947 32275 +48363 32273 +38441 32273 +25818 32259 +36331 32253 +27728 32250 +41961 32248 +30869 32246 +40180 32244 +36855 32239 +37609 32238 +40529 32237 +30733 32237 +29930 32235 +42278 32235 +42414 32235 +24438 32233 +40409 32227 +34357 32224 +18731 32224 +41996 32224 +46345 32221 +40028 32219 +37110 32217 +33604 32217 +38945 32214 +11906 32214 +44262 32213 +42798 32212 +17801 32211 +32850 32211 +48910 32206 +28230 32205 +35880 32205 +35389 32203 +50099 32200 +35054 32196 +47749 32193 +47968 32193 +46945 32191 +28981 32190 +33267 32187 +34791 32176 +34071 32169 +33785 32167 +27453 32167 +11036 32166 +38424 32164 +22696 32164 +38436 32164 +47543 32163 +40699 32158 +46908 32158 +33064 32156 +12307 32156 +8988 32154 +29564 32152 +37700 32146 +36711 32145 +29855 32133 +13330 32132 +30291 32132 +12211 32132 +29813 32130 +20910 32121 +35897 32120 +19825 32119 +18998 32116 +29509 32113 +9381 32113 +45665 32108 +26286 32105 +30819 32104 +34114 32103 +14428 32102 +48455 32099 +12288 32098 +19540 32095 +39713 32092 +37417 32091 +43638 32090 +44553 32089 +46420 32089 +37109 32088 +37679 32087 +23775 32080 +34977 32079 +13625 32077 +19728 32075 +26583 32074 +29236 32073 +32522 32069 +18211 32065 +32638 32063 +36651 32062 +31717 32062 +43508 32058 +32045 32049 +36078 32048 +14070 32047 +42454 32043 +49127 32040 +35314 32038 +41951 32031 +43893 32031 +46967 32031 +36784 32029 +12826 32024 +47029 32022 +38049 32020 +13418 32019 +33326 32017 +36053 32013 +34616 32011 +37479 32010 +17130 32010 +43043 32009 +20535 32009 +36943 32008 +32066 32007 +12048 32006 +48837 31988 +47239 31984 +18627 31978 +42304 31974 +47267 31974 +9615 31967 +44794 31966 +30336 31965 +21175 31960 +13934 31957 +41106 31953 +14832 31953 +31980 31952 +47893 31950 +35164 31948 +44414 31947 +34587 31946 +35026 31943 +32732 31939 +2812 31939 +50160 31938 +42932 31938 +35371 31934 +43684 31933 +16338 31933 +45931 31930 +40296 31927 +21267 31926 +27049 31923 +26226 31921 +31570 31920 +34052 31918 +27977 31911 +20267 31909 +36182 31907 +44446 31906 +50034 31903 +29907 31900 +38444 31898 +6739 31897 +32544 31889 +41894 31888 +31180 31882 +27128 31882 +29695 31881 +34646 31880 +41244 31878 +31850 31878 +29620 31878 +32718 31876 +49285 31871 +19914 31870 +37861 31868 +47653 31867 +40087 31866 +36005 31858 +35033 31857 +22146 31853 +13634 31853 +49458 31850 +16664 31849 +44273 31846 +46173 31844 +50195 31840 +40313 31839 +25838 31838 +40330 31837 +30981 31836 +46461 31836 +32652 31836 +43545 31833 +13760 31832 +27679 31828 +42949 31828 +33435 31827 +48093 31827 +29348 31820 +18061 31817 +28660 31817 +27832 31811 +49264 31807 +22602 31805 +18770 31803 +17953 31802 +22431 31797 +32702 31794 +39248 31792 +44849 31792 +13057 31791 +15574 31788 +50013 31787 +35365 31787 +30440 31784 +27842 31784 +32159 31780 +14315 31779 +30387 31775 +29920 31769 +38074 31768 +44476 31766 +18113 31766 +31190 31764 +36329 31760 +39638 31757 +41809 31756 +38811 31756 +29856 31753 +48475 31748 +34444 31748 +47926 31746 +40068 31745 +46108 31742 +40774 31742 +8746 31729 +18216 31729 +35081 31728 +47107 31728 +23808 31727 +33191 31726 +25765 31724 +38331 31721 +34082 31721 +25553 31720 +34446 31720 +40112 31717 +24642 31717 +2730 31717 +29548 31716 +20540 31710 +28466 31703 +1668 31703 +38781 31703 +18906 31698 +50215 31698 +43068 31697 +23583 31695 +40980 31694 +44773 31693 +41286 31692 +45848 31686 +26742 31685 +11295 31679 +13842 31678 +22787 31678 +21168 31677 +30723 31676 +44776 31676 +40334 31674 +37552 31673 +36369 31673 +23892 31671 +27137 31669 +17249 31669 +31690 31667 +35808 31664 +23061 31661 +12413 31661 +41856 31657 +47259 31653 +47841 31652 +7010 31651 +40032 31644 +1409 31644 +43712 31644 +30092 31643 +38724 31640 +41177 31636 +50225 31632 +48509 31629 +26239 31621 +29075 31619 +30114 31610 +5902 31608 +48723 31599 +39809 31598 +41413 31596 +13658 31595 +49753 31595 +31911 31594 +14541 31593 +33144 31591 +22858 31588 +23876 31587 +35661 31581 +47865 31579 +29474 31578 +47254 31573 +24645 31573 +36544 31572 +26883 31572 +15541 31562 +37719 31562 +41655 31561 +47316 31560 +29516 31560 +26429 31555 +25994 31552 +28483 31550 +42204 31548 +28469 31541 +40869 31539 +28937 31538 +36402 31538 +11509 31537 +15622 31532 +30577 31530 +36959 31529 +30362 31528 +15839 31525 +44889 31523 +30057 31523 +45112 31522 +20587 31518 +25489 31513 +39254 31510 +47734 31507 +47204 31506 +45445 31506 +46070 31504 +35436 31503 +34750 31501 +23410 31499 +42248 31497 +36404 31493 +13595 31490 +35361 31490 +38240 31488 +43195 31486 +36654 31484 +44181 31481 +42193 31480 +33115 31479 +38850 31477 +29540 31475 +26065 31475 +24838 31474 +41631 31470 +27867 31466 +10289 31466 +6734 31465 +31713 31463 +27990 31459 +15829 31457 +43693 31455 +31240 31452 +44346 31447 +24988 31446 +49013 31446 +48973 31445 +23409 31445 +38024 31443 +39844 31442 +29288 31433 +37820 31431 +25480 31428 +34810 31426 +27854 31424 +33544 31422 +38475 31421 +23849 31420 +15560 31419 +40094 31417 +41517 31407 +43609 31402 +27578 31389 +36362 31387 +34144 31387 +30911 31386 +43556 31382 +26290 31375 +38531 31374 +42403 31371 +39955 31371 +37989 31370 +41399 31368 +18856 31366 +13470 31366 +45309 31360 +44205 31360 +35587 31359 +34665 31357 +39514 31354 +42596 31345 +47158 31341 +31345 31340 +44577 31340 +24932 31340 +22788 31338 +37582 31335 +48354 31333 +41062 31333 +48214 31332 +31602 31329 +23491 31328 +32847 31326 +36186 31326 +44722 31325 +36920 31325 +42461 31323 +46377 31322 +42497 31319 +39532 31317 +8004 31316 +19777 31316 +40873 31315 +35592 31314 +44834 31312 +40579 31311 +25405 31307 +32339 31304 +32749 31301 +38361 31299 +6967 31297 +27720 31295 +44678 31293 +27597 31289 +22067 31288 +35853 31288 +41118 31279 +13506 31277 +16454 31268 +22674 31267 +31601 31261 +38890 31261 +40818 31257 +17251 31256 +37137 31255 +48491 31254 +29191 31250 +45852 31248 +43371 31246 +46113 31242 +6231 31241 +48917 31234 +30182 31233 +17111 31233 +2591 31232 +6558 31229 +18758 31229 +11655 31228 +15093 31228 +27689 31226 +43578 31225 +28516 31223 +42153 31222 +39362 31220 +29750 31220 +38940 31214 +32424 31213 +32974 31213 +6820 31213 +10372 31208 +34190 31201 +40064 31193 +483 31186 +19191 31185 +44534 31184 +29498 31172 +35376 31168 +31672 31164 +48172 31156 +7985 31154 +30195 31153 +15407 31153 +48824 31152 +22664 31147 +34209 31146 +40562 31145 +1383 31144 +24774 31143 +38468 31141 +31632 31140 +23930 31135 +47961 31132 +44811 31131 +32624 31130 +40142 31124 +25989 31123 +40939 31122 +9093 31122 +16875 31120 +35552 31117 +12559 31116 +38405 31115 +35462 31112 +24686 31111 +5505 31109 +41536 31109 +35963 31106 +37382 31103 +41116 31102 +30847 31100 +46128 31099 +40750 31098 +50043 31096 +38545 31095 +42394 31095 +33026 31094 +29190 31093 +49309 31080 +40623 31079 +10631 31078 +18126 31074 +39975 31073 +21460 31073 +11569 31072 +37208 31072 +48308 31071 +32035 31068 +44527 31068 +17632 31066 +29571 31066 +26823 31058 +22556 31057 +32471 31056 +10987 31055 +29833 31054 +43325 31054 +31816 31053 +35132 31049 +47587 31048 +11525 31047 +28292 31045 +14585 31043 +5255 31040 +36454 31039 +42285 31037 +45583 31037 +33850 31036 +32075 31035 +31575 31024 +24453 31021 +47667 31020 +33145 31016 +23418 31016 +36441 31015 +47779 31013 +22589 31013 +46124 31011 +46638 31004 +47395 31001 +31306 31001 +42045 30999 +42958 30995 +5568 30994 +27881 30994 +30842 30992 +29171 30989 +46398 30983 +18171 30981 +34952 30976 +44085 30975 +46494 30974 +25594 30973 +27763 30971 +37658 30971 +49982 30968 +38410 30964 +38098 30960 +26375 30959 +23819 30952 +48692 30947 +34726 30944 +47448 30940 +38007 30939 +49556 30938 +45466 30937 +47751 30927 +49344 30926 +31756 30925 +10507 30922 +48044 30920 +38246 30917 +19019 30916 +35665 30914 +33037 30912 +33649 30912 +15419 30905 +36730 30904 +31055 30899 +39877 30898 +37687 30897 +39130 30895 +37959 30889 +21224 30883 +30714 30880 +23553 30876 +42308 30876 +47414 30873 +7562 30873 +37840 30872 +44300 30867 +36869 30866 +47519 30860 +21589 30860 +49591 30858 +41199 30856 +25790 30854 +46627 30853 +48097 30851 +48939 30849 +44245 30847 +32395 30844 +34499 30841 +35522 30841 +8527 30840 +48805 30839 +37967 30839 +43829 30837 +32827 30834 +24280 30833 +8725 30829 +37783 30828 +34107 30827 +43613 30825 +35152 30822 +37302 30822 +25150 30821 +11551 30816 +48669 30814 +33901 30812 +22070 30812 +7694 30810 +20314 30801 +22822 30799 +31916 30798 +21211 30797 +5388 30794 +34800 30789 +46531 30789 +49083 30789 +48454 30785 +46265 30781 +18546 30778 +42768 30777 +39939 30776 +31297 30769 +48020 30767 +45230 30765 +32859 30765 +23680 30765 +46564 30763 +34672 30762 +14744 30760 +37533 30760 +5266 30755 +41653 30754 +43035 30752 +23235 30748 +33058 30748 +50076 30741 +29048 30739 +34406 30739 +17403 30730 +6664 30726 +46394 30726 +22009 30724 +38668 30722 +16955 30721 +38939 30721 +46168 30712 +17786 30706 +44313 30704 +31380 30701 +20283 30701 +44809 30701 +23322 30698 +33686 30691 +40712 30691 +20189 30690 +30797 30688 +45455 30688 +23914 30686 +21988 30679 +45540 30677 +38609 30674 +37501 30673 +45794 30670 +25487 30669 +50153 30663 +26561 30659 +47136 30658 +27944 30657 +40826 30654 +46867 30652 +16775 30650 +35859 30649 +40145 30648 +37421 30647 +36798 30645 +29159 30644 +22796 30640 +29925 30640 +29455 30635 +25323 30634 +38647 30629 +47607 30626 +23210 30621 +21753 30616 +42835 30616 +48241 30613 +29879 30611 +25777 30608 +42732 30599 +40590 30597 +49529 30596 +41184 30594 +26518 30591 +1246 30591 +17891 30590 +14278 30590 +45092 30588 +41442 30587 +39132 30584 +41843 30583 +31504 30582 +42337 30580 +11367 30578 +35776 30578 +41110 30577 +15948 30575 +37482 30575 +29958 30572 +31237 30570 +13761 30569 +36417 30567 +10167 30565 +35601 30562 +13507 30559 +42025 30558 +41332 30557 +30949 30555 +44353 30551 +37300 30550 +44432 30542 +22074 30542 +22477 30541 +45260 30541 +37850 30540 +32989 30539 +16587 30539 +38198 30536 +42833 30535 +9810 30534 +27102 30530 +31591 30530 +48001 30530 +38708 30530 +35175 30526 +11457 30525 +25857 30524 +10535 30524 +44693 30517 +37530 30515 +29331 30514 +27047 30513 +41997 30513 +36140 30505 +45593 30502 +48446 30497 +18462 30496 +37795 30492 +15912 30480 +12489 30479 +41574 30476 +26156 30469 +30111 30462 +45581 30462 +3107 30460 +43983 30460 +35607 30459 +42708 30449 +45370 30448 +31284 30446 +31344 30444 +46981 30442 +39875 30440 +49567 30438 +18119 30435 +37179 30433 +31414 30433 +27233 30432 +11830 30431 +39775 30427 +46125 30424 +39977 30423 +46206 30423 +45292 30422 +45432 30422 +5687 30418 +37144 30416 +30098 30416 +42016 30410 +42160 30401 +30119 30400 +33890 30398 +26613 30397 +29083 30394 +23970 30394 +46418 30387 +18837 30385 +22271 30385 +47131 30383 +8908 30383 +44607 30379 +32642 30379 +48336 30378 +39867 30376 +28683 30376 +42041 30376 +32973 30375 +41395 30374 +40101 30372 +16923 30371 +4791 30369 +43409 30368 +25310 30367 +6935 30364 +18242 30356 +42912 30355 +32039 30354 +30864 30353 +44657 30352 +44714 30351 +50020 30350 +44472 30349 +2170 30349 +40168 30347 +11245 30346 +32077 30341 +38942 30337 +27661 30336 +25253 30335 +32690 30334 +46937 30332 +48644 30329 +42806 30327 +29053 30324 +16591 30324 +41091 30320 +43374 30319 +41968 30316 +44497 30312 +35788 30306 +33393 30306 +13136 30303 +36877 30300 +24099 30300 +50086 30295 +22734 30295 +49023 30290 +39498 30288 +13192 30285 +48575 30281 +45919 30273 +39311 30272 +1470 30270 +44297 30270 +27285 30267 +45204 30266 +30983 30263 +20965 30263 +21236 30261 +20598 30260 +23739 30256 +45374 30248 +38097 30247 +40594 30245 +27431 30239 +17121 30238 +26992 30230 +17478 30230 +18291 30229 +46944 30225 +20985 30225 +10875 30222 +14308 30220 +39659 30219 +43746 30217 +31700 30217 +16390 30217 +38101 30217 +42018 30205 +46694 30202 +46853 30200 +34566 30199 +39293 30192 +27332 30192 +11890 30188 +30955 30188 +47207 30187 +24123 30184 +30285 30183 +48778 30177 +37854 30175 +41187 30172 +49066 30170 +19691 30169 +44016 30168 +39331 30164 +38319 30163 +47791 30158 +39145 30157 +21520 30157 +9421 30157 +42779 30156 +41197 30154 +39469 30153 +37211 30151 +8995 30150 +23232 30147 +34466 30143 +36159 30142 +42715 30138 +6267 30135 +48830 30135 +9006 30133 +37263 30129 +21342 30117 +18343 30113 +26343 30112 +16992 30107 +48045 30106 +41834 30105 +46818 30103 +18597 30102 +26514 30102 +47188 30101 +42551 30101 +8334 30099 +37583 30096 +26024 30095 +46215 30094 +45479 30092 +48870 30091 +40810 30086 +20216 30085 +46454 30082 +36522 30081 +36154 30081 +45709 30080 +13056 30080 +46590 30078 +3120 30076 +49181 30074 +25085 30073 +27085 30071 +38895 30070 +41728 30070 +49259 30070 +49804 30069 +45397 30069 +38268 30066 +34313 30060 +30962 30058 +38596 30057 +34120 30054 +17925 30052 +41056 30051 +47052 30047 +31408 30035 +31338 30033 +40428 30031 +6160 30028 +43452 30025 +40800 30020 +50233 30016 +45404 30011 +28051 30005 +33034 30003 +46801 30002 +43080 29999 +43338 29992 +50156 29991 +35844 29989 +30450 29987 +27210 29987 +39980 29986 +48966 29986 +30737 29986 +41869 29981 +44670 29979 +28821 29976 +19840 29972 +35340 29971 +21747 29970 +30099 29969 +14918 29968 +15352 29965 +28171 29964 +45389 29956 +39052 29954 +48920 29946 +31887 29944 +41881 29944 +33551 29938 +49522 29936 +43662 29932 +25491 29930 +15979 29930 +38771 29929 +26674 29928 +28659 29926 +12018 29921 +49180 29917 +25372 29916 +42242 29914 +37617 29912 +30523 29909 +29284 29906 +48483 29903 +40723 29901 +33394 29898 +38578 29897 +44852 29895 +46336 29894 +45612 29893 +8751 29892 +46776 29892 +49389 29891 +42134 29890 +33706 29890 +33001 29887 +20217 29882 +45598 29876 +41402 29875 +41690 29875 +24983 29870 +33927 29869 +37759 29867 +48733 29866 +30665 29866 +19759 29866 +44222 29859 +45308 29857 +49207 29857 +49350 29857 +35674 29856 +41067 29856 +36890 29851 +38384 29849 +46790 29848 +10023 29848 +43123 29846 +44740 29843 +47973 29840 +35682 29839 +38273 29829 +32081 29828 +16202 29827 +36036 29824 +47091 29807 +33303 29806 +28479 29806 +44522 29804 +19106 29803 +10666 29799 +43466 29799 +38303 29799 +47334 29792 +41044 29783 +47523 29783 +10434 29783 +44924 29775 +33273 29772 +40999 29770 +5987 29769 +43779 29766 +14949 29763 +27660 29762 +42671 29756 +45164 29755 +33868 29755 +27375 29753 +35195 29750 +22741 29748 +13724 29747 +42275 29739 +21627 29737 +45151 29736 +38849 29732 +44109 29731 +42738 29730 +17443 29730 +47980 29729 +28342 29728 +41266 29728 +16801 29727 +36741 29726 +14994 29725 +48105 29710 +35186 29709 +20373 29708 +45967 29708 +44345 29704 +28042 29702 +38723 29694 +33370 29691 +15942 29690 +33820 29688 +29315 29688 +39071 29687 +45045 29686 +44173 29685 +9035 29685 +14464 29679 +34106 29676 +34692 29663 +26631 29661 +39475 29658 +31046 29656 +44637 29655 +43981 29651 +28315 29650 +34404 29650 +41432 29649 +34547 29648 +37205 29647 +19892 29645 +44141 29644 +42023 29642 +33618 29642 +27066 29638 +32871 29637 +30442 29634 +33300 29634 +25164 29629 +48266 29629 +31940 29628 +41070 29625 +47643 29624 +40315 29617 +40077 29614 +38255 29613 +5037 29608 +28540 29607 +36313 29606 +21772 29605 +39189 29598 +50103 29597 +31282 29597 +26842 29597 +39537 29593 +47001 29592 +15388 29592 +36296 29589 +36065 29587 +30457 29581 +44247 29581 +48492 29579 +43309 29579 +44039 29578 +41608 29578 +43247 29576 +23212 29574 +34956 29573 +49471 29573 +28166 29570 +45171 29565 +39894 29565 +46784 29564 +23154 29563 +32272 29561 +36262 29556 +33562 29552 +27468 29551 +33350 29551 +36089 29549 +41621 29549 +37627 29549 +33013 29546 +40293 29543 +23073 29536 +24010 29533 +4254 29529 +20490 29528 +20489 29528 +14222 29527 +10985 29515 +44064 29511 +30808 29510 +25412 29508 +23947 29503 +9945 29501 +43700 29498 +45894 29495 +26847 29494 +41933 29489 +41098 29489 +41004 29489 +18425 29489 +46833 29486 +34709 29484 +45153 29483 +28035 29482 +27984 29480 +14830 29475 +38756 29475 +22456 29473 +41288 29473 +19513 29472 +39423 29472 +31785 29470 +48061 29469 +30335 29468 +31224 29464 +25414 29462 +28311 29461 +15703 29461 +21844 29456 +34986 29456 +48325 29456 +46066 29455 +25871 29453 +42656 29452 +28219 29447 +49996 29447 +8503 29445 +48663 29445 +31125 29440 +39612 29434 +19640 29433 +35000 29433 +42256 29431 +34576 29428 +40469 29426 +34091 29425 +13132 29423 +15527 29421 +34772 29420 +45274 29418 +42176 29416 +26161 29412 +25214 29412 +2820 29409 +33531 29408 +49402 29407 +33043 29407 +48116 29406 +12321 29406 +42706 29405 +40096 29404 +49549 29403 +14550 29402 +9788 29402 +19491 29400 +47135 29399 +3659 29397 +24742 29396 +32148 29390 +36673 29390 +49186 29386 +49305 29384 +17408 29382 +47778 29379 +46166 29378 +16713 29377 +35972 29365 +32858 29364 +36100 29364 +26455 29359 +36724 29358 +28828 29355 +48963 29354 +38126 29353 +24284 29349 +37999 29346 +45255 29340 +36377 29339 +49663 29336 +39846 29336 +36993 29333 +39521 29329 +23657 29328 +33974 29326 +40557 29324 +5817 29322 +45888 29321 +36593 29320 +45622 29318 +22919 29317 +1857 29317 +49419 29314 +1554 29308 +47895 29307 +35752 29306 +44115 29304 +46504 29303 +31444 29302 +29392 29298 +42079 29290 +39858 29289 +41602 29284 +36221 29284 +35518 29281 +22061 29277 +13243 29273 +33407 29272 +41128 29272 +48411 29271 +30923 29270 +49758 29269 +38930 29265 +3762 29262 +22704 29261 +33432 29259 +18428 29253 +42677 29252 +45906 29252 +32770 29251 +20481 29250 +27260 29243 +45981 29243 +27494 29242 +17666 29241 +11395 29240 +39267 29239 +47844 29234 +25127 29233 +35435 29231 +33576 29229 +40297 29228 +32823 29228 +23868 29224 +20407 29224 +44475 29223 +35588 29218 +14172 29218 +37035 29214 +47737 29214 +26354 29213 +26433 29212 +36215 29204 +35229 29204 +37018 29201 +29175 29199 +16067 29198 +35227 29197 +36060 29197 +36153 29193 +20564 29191 +42665 29189 +26726 29188 +47874 29187 +47628 29182 +37590 29182 +42772 29180 +45039 29180 +47327 29178 +37170 29175 +38765 29173 +2028 29172 +28810 29169 +46058 29169 +37290 29168 +30826 29168 +43272 29166 +27108 29163 +31763 29161 +26868 29157 +47565 29154 +22502 29154 +47325 29154 +36042 29147 +44499 29141 +18467 29138 +25532 29138 +9798 29136 +31552 29129 +41307 29128 +42933 29125 +44460 29123 +38614 29120 +47501 29119 +27824 29118 +35821 29118 +33038 29117 +18208 29111 +46563 29109 +41768 29103 +43713 29098 +26079 29098 +38133 29096 +13812 29094 +41550 29090 +42560 29088 +23927 29087 +45105 29084 +41978 29083 +45843 29083 +37207 29082 +47541 29081 +18986 29075 +43365 29074 +35778 29074 +34522 29070 +35354 29069 +42674 29064 +20978 29063 +39471 29063 +25897 29059 +15653 29058 +45174 29057 +38492 29057 +35367 29056 +30460 29052 +33949 29050 +34975 29048 +34843 29047 +31697 29046 +26946 29045 +38349 29044 +24615 29044 +37904 29042 +38888 29040 +48388 29038 +21519 29037 +45087 29035 +45586 29035 +35451 29029 +40582 29028 +31203 29026 +26567 29025 +43033 29020 +39879 29018 +25933 29016 +30557 29016 +44407 29013 +43906 29013 +23067 29008 +45690 29006 +17152 29002 +30704 29001 +40867 29000 +36435 29000 +15695 28998 +36617 28996 +34770 28995 +48095 28994 +31963 28991 +48217 28988 +36022 28988 +45190 28980 +44434 28978 +49452 28977 +30015 28976 +8658 28973 +21734 28973 +41606 28973 +28529 28973 +25681 28968 +1827 28967 +28129 28963 +41301 28961 +8175 28959 +30480 28958 +37281 28957 +37106 28957 +46167 28955 +18191 28955 +39024 28955 +30760 28954 +37585 28954 +8374 28950 +30131 28949 +22277 28949 +44533 28948 +26748 28947 +17667 28945 +45040 28945 +10952 28938 +26793 28936 +31423 28927 +39055 28924 +38763 28924 +44073 28924 +49726 28915 +30083 28910 +20125 28910 +43139 28907 +34267 28904 +2609 28901 +18698 28899 +45312 28899 +44105 28898 +35214 28895 +43798 28894 +33543 28893 +45985 28891 +40284 28890 +36789 28889 +22390 28886 +24283 28886 +47166 28886 +34274 28880 +25848 28879 +35257 28879 +13372 28876 +9854 28871 +37011 28871 +43317 28866 +40227 28864 +14881 28864 +32513 28864 +47289 28863 +30271 28860 +49040 28856 +25350 28852 +29896 28847 +28043 28846 +44885 28844 +26882 28842 +3676 28842 +42464 28841 +36669 28838 +20984 28836 +28184 28836 +42957 28831 +44594 28829 +10336 28829 +34279 28826 +37830 28825 +43286 28823 +27598 28823 +38258 28823 +47422 28821 +11612 28816 +48397 28814 +9010 28810 +33957 28809 +41217 28806 +47940 28805 +25019 28805 +39951 28805 +37402 28802 +39033 28801 +47301 28797 +17426 28796 +38530 28794 +28720 28794 +36667 28793 +48259 28792 +31985 28789 +44624 28788 +37385 28787 +23886 28787 +48707 28784 +39705 28784 +47034 28782 +25002 28781 +41739 28780 +28884 28779 +40738 28779 +32328 28778 +36311 28775 +29973 28764 +43646 28761 +29436 28761 +37061 28760 +38369 28759 +10100 28759 +28912 28755 +35768 28753 +11836 28753 +45501 28752 +31710 28749 +30372 28747 +43141 28747 +25298 28746 +44964 28744 +46283 28743 +29308 28741 +27766 28740 +40658 28739 +23345 28738 +36403 28736 +16114 28735 +34324 28734 +41234 28733 +37209 28731 +23742 28727 +40675 28727 +17540 28724 +43124 28720 +26189 28719 +33818 28718 +30803 28718 +28256 28717 +33472 28715 +15166 28715 +9600 28713 +32990 28705 +48134 28705 +18398 28705 +16438 28703 +13394 28699 +42078 28698 +41042 28689 +8387 28688 +48384 28685 +28371 28684 +15730 28684 +36795 28681 +48993 28681 +31398 28678 +18509 28678 +33645 28675 +33316 28673 +43295 28673 +32266 28671 +49734 28671 +11090 28670 +45805 28670 +36286 28668 +15791 28668 +47183 28668 +45004 28665 +34433 28665 +33903 28663 +33053 28662 +22018 28660 +44732 28658 +21066 28657 +48464 28654 +14696 28653 +29726 28652 +34385 28645 +39269 28642 +35219 28639 +34628 28637 +15059 28636 +22215 28636 +46142 28634 +29416 28633 +30807 28631 +45456 28630 +3986 28622 +49775 28622 +36871 28621 +33639 28620 +35288 28618 +40200 28617 +37657 28615 +19928 28615 +31416 28610 +25388 28607 +42222 28600 +29088 28600 +34561 28598 +29814 28598 +11479 28597 +34831 28596 +49779 28596 +49301 28595 +43181 28589 +7495 28589 +45084 28589 +40075 28587 +37136 28585 +36273 28579 +36720 28578 +12292 28570 +32531 28569 +33355 28569 +49236 28569 +48698 28569 +10272 28568 +39947 28567 +37760 28566 +27971 28562 +43028 28556 +47094 28554 +40479 28552 +16244 28552 +49320 28552 +12455 28548 +22789 28546 +18296 28542 +37243 28541 +29305 28540 +28426 28537 +27610 28531 +7966 28529 +26976 28521 +49465 28521 +27145 28519 +50162 28517 +38901 28516 +49978 28510 +49212 28508 +39519 28508 +29766 28507 +40316 28506 +26075 28506 +35641 28506 +32459 28505 +45858 28504 +34391 28504 +29892 28501 +45055 28501 +50134 28500 +34512 28500 +27310 28499 +39418 28498 +25517 28497 +14054 28496 +29893 28492 +1354 28492 +34415 28491 +42374 28491 +47093 28490 +33741 28490 +29381 28488 +40838 28486 +32658 28482 +26920 28481 +28950 28479 +39185 28478 +39063 28477 +15978 28475 +32199 28475 +45703 28470 +33748 28467 +21544 28466 +42161 28464 +29390 28461 +38121 28459 +25812 28457 +39440 28455 +30343 28454 +31128 28453 +27841 28451 +35095 28445 +45096 28444 +47606 28444 +34515 28443 +2772 28442 +50072 28439 +14972 28438 +35447 28435 +18214 28433 +40802 28432 +30591 28426 +31828 28424 +24394 28423 +39144 28423 +45283 28420 +39843 28415 +47568 28414 +37283 28414 +39924 28408 +44034 28404 +30743 28400 +49435 28396 +28441 28392 +42388 28389 +39202 28388 +49227 28388 +48415 28386 +32187 28384 +49507 28382 +48377 28382 +36821 28371 +30419 28371 +40329 28367 +39238 28367 +46060 28365 +40463 28362 +38702 28362 +34722 28361 +38840 28361 +1121 28361 +45231 28359 +48969 28357 +44264 28356 +93 28353 +49401 28353 +16351 28347 +21979 28345 +43347 28342 +40023 28342 +20045 28341 +42699 28338 +35046 28338 +28927 28334 +11041 28333 +45663 28328 +28674 28326 +35868 28326 +33479 28324 +49871 28323 +25730 28322 +38867 28318 +49164 28316 +29937 28315 +42816 28313 +45414 28313 +4350 28312 +45393 28308 +20544 28302 +28709 28302 +47629 28302 +50042 28301 +38968 28297 +50190 28292 +38081 28291 +39982 28288 +37360 28283 +47266 28282 +45730 28282 +27966 28280 +15545 28276 +49242 28275 +45146 28274 +31729 28271 +39988 28270 +42102 28268 +42212 28267 +31524 28265 +25220 28264 +30465 28263 +35537 28261 +48355 28255 +36371 28253 +18909 28247 +37473 28246 +48352 28235 +22048 28231 +40271 28229 +2970 28219 +14427 28216 +42331 28214 +28270 28214 +34296 28212 +41704 28212 +48929 28206 +20235 28206 +23664 28204 +49957 28204 +31194 28198 +32042 28191 +38570 28190 +37750 28189 +39856 28184 +13021 28184 +49206 28183 +46240 28180 +38158 28179 +41487 28177 +28413 28177 +12619 28177 +49729 28176 +40721 28176 +13406 28172 +49786 28172 +35757 28168 +24633 28163 +33821 28162 +42831 28157 +46559 28156 +36013 28155 +45600 28150 +38404 28150 +34212 28146 +22840 28141 +27451 28140 +27713 28140 +30045 28139 +21741 28137 +44541 28137 +27087 28135 +36123 28134 +33253 28128 +34458 28124 +27934 28123 +49078 28121 +21716 28120 +30120 28119 +49698 28118 +33830 28118 +47890 28118 +16977 28116 +27417 28115 +14986 28114 +26997 28113 +23820 28108 +22907 28108 +43764 28107 +11747 28105 +30191 28102 +39048 28101 +45694 28100 +26165 28100 +24830 28099 +43622 28092 +28531 28091 +26120 28087 +25139 28084 +38773 28084 +49080 28077 +27507 28076 +35117 28072 +39247 28072 +47341 28072 +49308 28071 +37507 28065 +45296 28065 +18779 28065 +46845 28061 +30586 28060 +38589 28059 +33212 28056 +43472 28049 +12738 28046 +37964 28043 +5190 28035 +31048 28035 +48982 28034 +23723 28033 +14785 28031 +48927 28031 +40038 28030 +48706 28024 +20095 28022 +46553 28022 +39645 28019 +23578 28019 +43882 28019 +37419 28011 +24752 28009 +49448 28007 +39349 28006 +34307 28003 +17712 28002 +40272 28002 +42341 28000 +22479 28000 +49399 27997 +20539 27997 +43905 27996 +50065 27996 +14402 27994 +14118 27992 +32030 27992 +41537 27990 +44335 27989 +37734 27989 +18982 27988 +48100 27986 +22768 27984 +26651 27983 +47943 27981 +38622 27979 +32182 27979 +34432 27974 +50077 27971 +48074 27970 +46873 27969 +19027 27968 +40504 27966 +39594 27964 +24472 27964 +40788 27963 +34476 27962 +32695 27958 +18262 27958 +29999 27957 +22795 27956 +47992 27954 +48281 27952 +38476 27951 +35891 27949 +31014 27944 +42723 27943 +39171 27940 +20663 27938 +14534 27937 +26780 27936 +46473 27934 +42935 27934 +34066 27934 +36957 27930 +25021 27929 +41194 27925 +38792 27920 +18712 27919 +24997 27919 +34526 27915 +19549 27913 +47695 27913 +9428 27913 +22532 27909 +48101 27905 +41366 27900 +47884 27898 +31655 27897 +2379 27897 +15182 27896 +25264 27895 +34182 27894 +39606 27894 +29471 27891 +40093 27891 +29998 27890 +49587 27889 +10950 27885 +24961 27883 +22109 27877 +49354 27877 +42775 27876 +50011 27875 +25515 27872 +43845 27871 +48293 27866 +34353 27864 +31903 27864 +36908 27861 +41669 27858 +24965 27858 +45671 27856 +29769 27855 +40444 27851 +37381 27848 +23170 27848 +33378 27842 +25868 27837 +28056 27836 +46927 27836 +47332 27836 +49295 27835 +43534 27834 +36257 27828 +49620 27828 +21264 27827 +28240 27827 +31228 27825 +41851 27823 +37879 27822 +40369 27820 +48238 27819 +23561 27817 +9224 27808 +47832 27805 +22491 27803 +20094 27802 +1916 27800 +48051 27797 +46163 27791 +22476 27787 +48360 27780 +31907 27776 +21634 27775 +21602 27774 +47338 27774 +32407 27774 +17049 27773 +28945 27765 +13495 27764 +26833 27761 +22715 27759 +45743 27758 +18164 27754 +44772 27754 +45381 27753 +29409 27746 +23542 27745 +27349 27742 +32242 27741 +32935 27737 +47382 27734 +19966 27734 +39842 27734 +42218 27734 +8961 27731 +36165 27728 +31862 27725 +32100 27725 +32880 27725 +46647 27725 +27272 27718 +40845 27717 +49887 27713 +27178 27708 +32312 27705 +36495 27702 +42154 27702 +8019 27699 +49428 27697 +43843 27694 +9720 27693 +46778 27692 +36220 27691 +44129 27691 +34642 27689 +27552 27687 +40610 27681 +44477 27680 +31548 27679 +39336 27679 +27242 27678 +19456 27677 +30141 27673 +32417 27671 +42811 27669 +30536 27661 +37927 27659 +39704 27653 +40941 27651 +43914 27651 +15614 27649 +41605 27648 +34669 27646 +31578 27645 +40903 27643 +45437 27642 +21005 27642 +45273 27642 +45291 27638 +46213 27636 +29228 27630 +41717 27630 +49120 27628 +42510 27626 +41368 27626 +31702 27625 +40049 27625 +28532 27624 +38120 27624 +15316 27623 +44071 27623 +36185 27621 +40067 27619 +48797 27619 +43916 27619 +45756 27618 +27527 27616 +42773 27615 +34413 27615 +40933 27607 +33660 27605 +46605 27604 +44653 27604 +46054 27602 +44583 27602 +36277 27596 +20651 27594 +24992 27589 +36063 27588 +31877 27588 +20148 27586 +43071 27581 +38937 27580 +48815 27575 +41889 27575 +24639 27574 +33277 27564 +45541 27563 +27461 27555 +35190 27551 +41991 27546 +38877 27545 +39379 27544 +22212 27542 +46351 27542 +43417 27541 +15073 27540 +47632 27539 +42907 27538 +42260 27536 +41927 27534 +41278 27534 +39613 27533 +21642 27529 +32957 27528 +17896 27527 +26764 27524 +36491 27520 +41337 27517 +37034 27512 +25251 27512 +28781 27511 +47351 27511 +39669 27508 +38690 27508 +23743 27501 +36086 27498 +26213 27492 +45828 27489 +16203 27478 +29095 27478 +23551 27476 +48788 27475 +43552 27475 +39805 27472 +37147 27471 +46229 27470 +28063 27468 +9054 27466 +30406 27466 +39214 27465 +36999 27463 +49976 27463 +37962 27462 +45733 27461 +43110 27461 +8963 27460 +7513 27459 +8376 27458 +11449 27458 +31691 27457 +41015 27456 +48611 27450 +35830 27450 +28478 27449 +33834 27447 +24038 27447 +49824 27439 +47077 27437 +20419 27436 +25366 27436 +27099 27435 +37494 27435 +43886 27429 +40643 27428 +32523 27424 +39390 27424 +46030 27421 +36378 27415 +30695 27412 +49340 27412 +32388 27408 +31733 27407 +41663 27406 +33396 27405 +33771 27405 +34523 27405 +23535 27404 +30730 27399 +48637 27395 +44668 27389 +37532 27388 +28462 27386 +48029 27384 +48690 27383 +47602 27379 +46236 27378 +31841 27377 +48016 27376 +30702 27367 +34059 27365 +44463 27361 +47366 27361 +24481 27354 +40724 27352 +33032 27351 +42878 27347 +47256 27346 +12475 27343 +25741 27342 +38905 27342 +25942 27342 +38056 27342 +26030 27341 +25481 27340 +31196 27339 +6470 27338 +45955 27336 +47483 27335 +26512 27334 +21397 27333 +30919 27326 +32804 27324 +32799 27321 +50139 27315 +28067 27305 +39868 27304 +47024 27301 +30122 27297 +38332 27295 +27516 27293 +46718 27292 +36157 27291 +19226 27291 +44999 27289 +43919 27289 +39783 27287 +36688 27287 +40604 27285 +50202 27284 +6221 27279 +47270 27279 +41760 27278 +38305 27275 +34247 27275 +44011 27273 +29100 27271 +47092 27267 +30225 27267 +1372 27265 +44854 27263 +34044 27262 +20626 27261 +43489 27260 +35660 27260 +44246 27259 +39602 27258 +45831 27239 +44350 27237 +41241 27235 +42701 27235 +15724 27226 +42653 27220 +39699 27217 +30932 27215 +45716 27212 +40027 27211 +8647 27211 +19041 27210 +36653 27204 +46753 27203 +48186 27202 +11082 27199 +48094 27196 +13729 27193 +43356 27191 +23024 27190 +32700 27188 +43299 27188 +37846 27187 +33372 27184 +40706 27184 +35402 27182 +32585 27182 +11486 27178 +44517 27175 +26543 27168 +40134 27167 +21739 27162 +14853 27161 +43501 27159 +42777 27158 +37621 27157 +40187 27157 +48058 27155 +1369 27154 +15823 27153 +22482 27152 +49642 27150 +28638 27149 +38747 27147 +30944 27147 +37238 27146 +33507 27146 +39135 27145 +9820 27144 +32508 27140 +39059 27137 +7592 27136 +38170 27135 +37701 27132 +29032 27130 +33069 27129 +23747 27127 +33844 27124 +41138 27122 +47441 27118 +43621 27117 +31912 27113 +40844 27113 +22213 27111 +34374 27109 +25836 27106 +46688 27103 +42420 27099 +36116 27096 +42162 27096 +13579 27096 +42984 27093 +37847 27090 +38634 27087 +39840 27087 +34249 27085 +40306 27082 +17225 27081 +12570 27078 +46280 27078 +34489 27075 +37268 27072 +42087 27072 +42642 27067 +14965 27066 +36615 27065 +32040 27061 +34482 27061 +11373 27057 +35882 27055 +33882 27055 +47816 27051 +25431 27049 +41820 27045 +47867 27045 +34377 27041 +48673 27039 +40462 27035 +40303 27033 +4997 27033 +36936 27032 +29198 27031 +40922 27028 +16767 27025 +26461 27021 +11619 27015 +37645 27014 +40888 27014 +42467 27013 +47721 27012 +30146 27012 +22689 27010 +18090 27008 +29858 27006 +41479 27006 +34873 27006 +44389 27005 +47856 27004 +49880 27002 +17882 27001 +44658 26999 +42564 26995 +25114 26995 +16986 26995 +33400 26992 +38125 26991 +33008 26976 +21646 26969 +18760 26967 +35502 26965 +39204 26963 +38893 26962 +31662 26960 +21548 26956 +48166 26955 +31499 26949 +39899 26947 +35328 26941 +43650 26941 +27853 26940 +46630 26939 +44536 26939 +10628 26936 +33638 26934 +36517 26933 +44138 26933 +29371 26930 +43587 26929 +49202 26927 +21459 26924 +45560 26922 +46901 26922 +47509 26920 +45768 26920 +4008 26920 +11588 26919 +45613 26919 +36887 26918 +32998 26917 +42238 26913 +44102 26912 +42347 26911 +49924 26909 +47564 26906 +24914 26905 +25627 26903 +25140 26903 +32050 26901 +10694 26899 +38340 26899 +32460 26898 +19150 26898 +24295 26894 +37127 26893 +29326 26887 +20288 26883 +41385 26883 +35722 26880 +39903 26879 +45834 26877 +37673 26877 +43056 26874 +34471 26871 +22824 26871 +43483 26864 +16088 26863 +39277 26860 +36626 26859 +39392 26859 +36072 26855 +6396 26852 +47277 26852 +31339 26851 +42673 26844 +30768 26843 +39750 26843 +8844 26843 +38810 26838 +29744 26834 +23615 26833 +33117 26830 +47655 26830 +39402 26828 +43236 26828 +32373 26822 +45879 26815 +35499 26813 +44545 26813 +29627 26811 +15684 26810 +36243 26810 +19164 26808 +7936 26807 +50166 26805 +44053 26804 +37563 26803 +44068 26800 +6887 26799 +24398 26796 +32152 26794 +48140 26794 +42270 26791 +27916 26789 +35375 26789 +32399 26789 +20457 26784 +47187 26784 +48350 26783 +49680 26782 +29153 26781 +27838 26780 +43548 26776 +35677 26775 +32731 26775 +46090 26773 +48234 26773 +37241 26770 +44947 26768 +27115 26767 +9797 26766 +31020 26765 +7347 26764 +5829 26761 +37547 26761 +31837 26760 +15603 26760 +44426 26758 +45363 26757 +41284 26753 +33558 26752 +7398 26751 +49382 26745 +39954 26733 +21672 26733 +41112 26728 +23515 26727 +34314 26725 +33916 26725 +25726 26724 +61 26723 +24055 26720 +38823 26720 +32712 26717 +37320 26717 +40429 26716 +24229 26714 +46721 26713 +11538 26713 +42894 26709 +9642 26708 +34436 26705 +36375 26703 +49571 26700 +48730 26700 +31160 26698 +41306 26698 +11027 26697 +45922 26694 +40024 26693 +39279 26692 +37004 26685 +15509 26674 +37694 26673 +30504 26673 +34256 26671 +34159 26671 +24855 26671 +31654 26671 +45253 26669 +43232 26669 +48511 26668 +38013 26668 +28152 26668 +36625 26667 +24026 26665 +46139 26665 +38753 26663 +14050 26662 +24798 26660 +50131 26659 +17367 26656 +40215 26653 +38635 26653 +43333 26648 +43606 26648 +46119 26646 +22166 26646 +34424 26638 +47157 26636 +46252 26631 +34801 26631 +35059 26630 +9990 26629 +45233 26628 +43396 26626 +42335 26625 +30992 26623 +46027 26617 +34835 26617 +41243 26616 +38364 26613 +48211 26612 +25113 26612 +43674 26609 +42143 26605 +7892 26603 +15297 26601 +22785 26600 +47510 26595 +10352 26592 +44480 26592 +23722 26588 +35916 26588 +43435 26587 +29081 26587 +34951 26586 +46266 26585 +35124 26584 +39764 26581 +34606 26581 +6680 26580 +29120 26580 +31855 26579 +33552 26579 +12230 26579 +32811 26574 +33988 26573 +29819 26570 +38750 26570 +44782 26567 +36217 26563 +34184 26561 +26756 26558 +36879 26557 +49950 26557 +45643 26557 +22842 26556 +40432 26555 +50206 26551 +31280 26549 +18849 26548 +23113 26543 +49672 26538 +36649 26538 +33812 26536 +38726 26535 +44672 26534 +43891 26534 +46813 26534 +34825 26533 +50212 26532 +45968 26530 +35273 26521 +43973 26521 +35243 26515 +35617 26515 +16705 26513 +43470 26508 +27927 26507 +49296 26507 +36565 26507 +43439 26506 +42934 26504 +20854 26502 +49263 26494 +33542 26492 +22854 26491 +41129 26488 +24209 26487 +34743 26487 +32097 26478 +45625 26469 +32180 26468 +46272 26468 +32073 26468 +19956 26464 +15161 26462 +47224 26461 +44118 26461 +16421 26461 +26885 26458 +18855 26457 +45481 26450 +46705 26449 +48012 26445 +35824 26444 +36328 26444 +22298 26444 +47590 26441 +35246 26441 +48626 26439 +49410 26431 +35871 26427 +35360 26420 +15391 26418 +39600 26415 +49981 26411 +44062 26411 +36039 26402 +35998 26402 +42434 26401 +39035 26398 +36141 26398 +49353 26395 +8775 26393 +36210 26387 +44017 26386 +35419 26385 +24129 26384 +42961 26384 +39978 26380 +44976 26379 +24669 26378 +5950 26373 +30787 26369 +24897 26367 +27155 26366 +35076 26361 +42922 26361 +44853 26359 +26007 26358 +32643 26358 +27258 26356 +45060 26351 +35989 26346 +49376 26343 +31714 26339 +28556 26339 +21327 26337 +40295 26337 +25940 26337 +26988 26337 +42132 26336 +41207 26336 +32128 26335 +133 26334 +27411 26333 +38887 26332 +44832 26329 +46557 26328 +41024 26327 +38568 26323 +49889 26319 +12401 26319 +34450 26317 +33538 26316 +35068 26314 +8818 26313 +26869 26313 +33569 26313 +24446 26312 +7751 26310 +46101 26309 +36905 26308 +48122 26307 +48242 26306 +32746 26305 +41084 26304 +25905 26302 +21781 26301 +49861 26301 +7826 26301 +47696 26295 +20591 26292 +49588 26291 +35804 26291 +45553 26290 +49159 26289 +38151 26288 +44092 26282 +45188 26281 +28915 26280 +15905 26279 +47442 26276 +37151 26274 +43607 26273 +28841 26273 +31026 26272 +44983 26271 +3238 26268 +13635 26268 +22005 26265 +17457 26264 +34339 26264 +23339 26264 +44680 26256 +38714 26255 +45812 26255 +46750 26253 +37580 26252 +41672 26251 +22508 26244 +30390 26238 +46275 26236 +47263 26235 +40715 26233 +12722 26231 +18251 26230 +26550 26227 +42352 26223 +26769 26223 +37513 26223 +26556 26222 +44314 26221 +36373 26219 +45418 26218 +42970 26214 +15151 26211 +13882 26205 +21931 26203 +49631 26202 +41885 26200 +29203 26197 +38784 26196 +31076 26192 +5820 26191 +15838 26190 +15457 26187 +45905 26186 +47436 26186 +47391 26185 +29108 26179 +34140 26178 +34229 26175 +36149 26174 +20415 26166 +31216 26165 +22968 26164 +25396 26162 +24327 26161 +42149 26157 +39340 26154 +39548 26153 +40080 26147 +37939 26146 +35404 26146 +1782 26145 +45499 26144 +33961 26141 +46782 26136 +43936 26135 +11755 26133 +8730 26129 +42679 26127 +46952 26126 +35264 26124 +39761 26118 +15594 26112 +16296 26110 +35126 26109 +40571 26109 +32285 26107 +22246 26107 +30657 26106 +48755 26105 +28399 26103 +40427 26098 +44986 26096 +11178 26096 +40670 26095 +40622 26093 +43330 26092 +49913 26092 +37193 26091 +48152 26089 +11713 26089 +42683 26087 +20375 26087 +31952 26086 +32494 26085 +1580 26085 +47589 26084 +48299 26082 +30410 26078 +20017 26074 +27111 26068 +22138 26067 +45014 26066 +33985 26066 +40016 26066 +40194 26063 +29386 26063 +24125 26062 +8497 26061 +37171 26061 +25328 26060 +42049 26059 +38333 26057 +40086 26057 +1038 26050 +45102 26050 +41021 26048 +43500 26047 +23398 26046 +48916 26044 +42465 26044 +15258 26044 +27814 26043 +49208 26039 +14824 26035 +32361 26032 +46698 26031 +28173 26031 +30162 26030 +48247 26029 +35679 26027 +23768 26023 +48517 26021 +39535 26020 +17969 26019 +33137 26014 +48151 26013 +35586 26012 +28573 26007 +31491 26007 +25055 25998 +40467 25997 +14140 25997 +38603 25994 +42713 25994 +28341 25992 +3637 25991 +19527 25991 +38210 25988 +41193 25988 +41212 25987 +27749 25986 +13940 25984 +46423 25982 +46938 25981 +40567 25980 +49192 25977 +28555 25977 +36460 25977 +37853 25977 +42067 25972 +49596 25963 +18844 25960 +21417 25959 +47964 25959 +39527 25959 +29703 25959 +49455 25959 +49272 25957 +29143 25954 +31471 25952 +19242 25951 +29675 25949 +48077 25949 +19652 25946 +39625 25945 +28155 25945 +45584 25944 +37639 25943 +32997 25940 +27646 25938 +19663 25934 +27898 25933 +9402 25932 +42914 25932 +35074 25930 +34179 25924 +25801 25923 +32056 25923 +49085 25919 +46232 25919 +41283 25916 +25324 25915 +39928 25913 +46069 25909 +35536 25908 +47300 25908 +22743 25907 +30960 25903 +17611 25903 +15431 25903 +27796 25893 +35667 25892 +49673 25891 +48356 25891 +36618 25888 +22224 25886 +32622 25882 +9515 25880 +17071 25878 +20366 25877 +26620 25875 +18540 25874 +40580 25873 +32093 25872 +9165 25870 +22122 25869 +20944 25863 +25132 25863 +44757 25851 +44186 25851 +42801 25850 +43395 25848 +46308 25848 +45471 25846 +41139 25845 +38248 25843 +24958 25841 +22801 25840 +40085 25839 +40335 25834 +38683 25834 +24670 25833 +15659 25831 +40492 25829 +44511 25827 +27446 25823 +9187 25820 +40398 25819 +36410 25809 +11158 25807 +49393 25805 +34626 25803 +1519 25803 +36392 25802 +15361 25800 +45785 25800 +50243 25799 +49761 25796 +34347 25792 +42415 25792 +17995 25791 +43426 25789 +27202 25787 +33933 25783 +38766 25779 +3890 25779 +34830 25779 +21907 25775 +25603 25774 +25816 25774 +23864 25773 +35904 25770 +44100 25765 +22588 25761 +25548 25754 +34752 25752 +49014 25750 +31334 25749 +11724 25739 +30129 25733 +44006 25733 +36597 25726 +39212 25726 +41498 25723 +34565 25722 +39506 25722 +15159 25722 +34938 25718 +29936 25718 +16204 25718 +9304 25716 +22891 25715 +15946 25714 +11120 25711 +26710 25709 +42810 25708 +39624 25707 +49311 25706 +35150 25705 +39901 25703 +27770 25703 +49385 25702 +45957 25702 +36966 25699 +46322 25691 +35987 25689 +21283 25689 +38652 25683 +41687 25680 +27190 25679 +34201 25677 +44938 25676 +39195 25672 +28283 25670 +31011 25669 +20871 25666 +24062 25666 +26733 25662 +34510 25658 +49609 25654 +41465 25653 +42224 25652 +38077 25652 +40615 25649 +30790 25648 +25883 25647 +38944 25647 +48341 25647 +40694 25646 +38393 25646 +40090 25646 +47284 25644 +29757 25641 +43888 25638 +34896 25638 +28702 25636 +38324 25633 +31222 25632 +39646 25619 +36766 25618 +45469 25614 +42716 25613 +43478 25611 +33156 25608 +47406 25605 +10853 25603 +44813 25597 +35412 25595 +26634 25590 +37196 25584 +20521 25578 +40932 25575 +49636 25572 +40358 25570 +37887 25568 +19781 25568 +37982 25565 +47388 25565 +43574 25560 +31406 25559 +44570 25553 +30200 25551 +30433 25549 +23104 25538 +43871 25537 +49310 25535 +7658 25534 +40336 25532 +41041 25532 +40509 25531 +39054 25527 +35042 25526 +32457 25526 +41617 25523 +48961 25519 +37809 25519 +14684 25518 +33540 25518 +43340 25516 +6566 25516 +47059 25514 +42969 25513 +33965 25513 +39272 25512 +45934 25510 +4012 25505 +41168 25502 +30389 25499 +32842 25498 +35342 25497 +49639 25497 +30841 25496 +29478 25496 +39038 25496 +37710 25490 +41799 25487 +42354 25485 +39376 25483 +50112 25482 +38409 25480 +20303 25479 +22616 25477 +27863 25477 +21999 25476 +41613 25474 +4087 25473 +38239 25473 +48071 25471 +48581 25468 +45048 25467 +42325 25466 +28626 25465 +44548 25463 +8194 25463 +50150 25463 +46439 25462 +37161 25461 +11703 25459 +46591 25458 +19715 25458 +35551 25457 +38311 25453 +47455 25452 +22975 25452 +42457 25450 +49175 25448 +30682 25447 +43555 25445 +34784 25433 +24075 25430 +13327 25429 +8803 25428 +46969 25426 +25864 25421 +12966 25417 +28374 25413 +31527 25411 +17060 25404 +29192 25403 +26659 25401 +18003 25400 +44730 25399 +42083 25395 +32102 25394 +35120 25392 +48962 25392 +42865 25391 +37330 25391 +42387 25389 +41083 25388 +38366 25388 +31298 25387 +46465 25384 +33437 25377 +27739 25376 +48243 25374 +47043 25373 +30999 25373 +49265 25369 +22509 25369 +43924 25365 +14221 25364 +47774 25362 +24597 25358 +31054 25358 +46365 25357 +37230 25355 +47872 25353 +44662 25353 +46586 25352 +36023 25351 +36244 25347 +47912 25345 +32912 25345 +42733 25339 +47902 25337 +45480 25335 +47075 25333 +32334 25330 +49441 25326 +14375 25325 +28971 25324 +33022 25318 +40829 25315 +3030 25314 +24316 25314 +24812 25314 +49723 25312 +36087 25306 +45042 25304 +38450 25303 +41014 25300 +37593 25299 +6321 25297 +15071 25296 +27266 25296 +11808 25295 +43737 25295 +41724 25293 +41639 25291 +31260 25290 +24289 25289 +49830 25289 +41593 25283 +39930 25282 +25197 25279 +18402 25279 +37287 25278 +34126 25274 +41087 25273 +32218 25273 +7904 25271 +37572 25270 +40472 25267 +43528 25265 +41131 25265 +13009 25264 +40362 25260 +30563 25260 +48579 25252 +42982 25247 +43928 25246 +34637 25245 +49025 25244 +38328 25243 +7470 25240 +37309 25240 +38229 25232 +28998 25232 +50087 25230 +44993 25229 +25886 25225 +46859 25223 +46603 25218 +38922 25218 +41028 25212 +44777 25211 +43694 25211 +29334 25210 +15014 25209 +20682 25209 +7321 25209 +35965 25206 +40923 25203 +11834 25202 +11591 25200 +23066 25199 +8981 25196 +22876 25195 +36681 25194 +26961 25194 +20049 25192 +46797 25192 +21302 25190 +45837 25188 +48280 25187 +39264 25179 +39710 25175 +31953 25174 +48550 25173 +35310 25171 +22083 25171 +36676 25171 +46172 25170 +43773 25170 +3959 25168 +42203 25167 +49069 25166 +33459 25166 +40169 25165 +39591 25161 +32173 25161 +30566 25156 +47869 25156 +21855 25153 +36509 25152 +47842 25150 +36793 25148 +45714 25147 +46469 25140 +23308 25139 +38541 25138 +38322 25135 +12522 25129 +44737 25124 +36094 25124 +36207 25123 +23466 25121 +36705 25118 +42426 25118 +39006 25115 +49391 25114 +22178 25114 +32000 25113 +28380 25112 +25364 25110 +21720 25108 +38611 25107 +46122 25105 +35305 25103 +43114 25097 +12992 25096 +37635 25096 +8143 25089 +45921 25083 +38915 25083 +23351 25083 +35155 25083 +38150 25079 +41786 25078 +30283 25072 +31037 25071 +43354 25069 +42156 25069 +11121 25063 +47855 25062 +47309 25060 +35907 25057 +30752 25056 +42076 25056 +10072 25055 +25100 25054 +24016 25053 +35267 25053 +48418 25052 +46951 25051 +13814 25050 +46487 25048 +12502 25048 +46040 25048 +25975 25047 +42421 25046 +38446 25045 +8327 25044 +26595 25043 +25045 25040 +24074 25040 +19731 25037 +48606 25031 +38163 25029 +31418 25028 +37145 25027 +36536 25027 +10394 25023 +20679 25023 +24580 25021 +25252 25017 +33206 25017 +32079 25017 +42765 25016 +34980 25016 +39056 25015 +8323 25014 +49897 25012 +44103 25009 +48315 25006 +48149 25005 +49564 25003 +38259 25000 +49805 24999 +47716 24998 +41638 24998 +46029 24994 +33573 24994 +32140 24991 +42925 24990 +33646 24989 +36108 24989 +19128 24988 +18089 24988 +38212 24986 +29991 24984 +14767 24984 +38997 24980 +40540 24979 +38712 24976 +49483 24975 +33580 24974 +49593 24974 +33123 24968 +24151 24966 +47142 24966 +41864 24966 +35709 24963 +47362 24962 +11683 24961 +33342 24959 +48981 24957 +38076 24955 +13095 24953 +33548 24952 +39677 24951 +19608 24949 +38329 24949 +37008 24949 +26222 24948 +47487 24945 +29647 24944 +18096 24940 +23549 24939 +28690 24939 +36080 24938 +17094 24937 +33958 24937 +27186 24932 +41290 24929 +45186 24928 +27106 24925 +46943 24924 +25774 24919 +48990 24918 +33525 24917 +45110 24914 +32436 24913 +21038 24911 +33869 24911 +46594 24910 +40314 24910 +38506 24908 +17593 24908 +14519 24908 +39497 24906 +27034 24906 +33827 24904 +15501 24904 +23129 24903 +20966 24903 +28191 24902 +45741 24901 +49629 24901 +47481 24901 +21912 24900 +41121 24899 +38171 24898 +18123 24893 +36898 24893 +44491 24892 +46592 24891 +27037 24891 +45245 24888 +44496 24887 +35993 24885 +32908 24885 +14374 24884 +43576 24878 +28693 24876 +49619 24875 +47291 24874 +34620 24870 +37098 24867 +43281 24866 +42294 24864 +16549 24861 +46734 24855 +49154 24854 +18318 24854 +45420 24854 +40488 24850 +25755 24846 +38859 24845 +46087 24832 +23567 24829 +39318 24829 +4363 24828 +40862 24826 +39595 24825 +49380 24816 +48921 24812 +38089 24809 +32158 24808 +31384 24804 +41890 24801 +45780 24801 +47007 24794 +22433 24793 +13046 24793 +38524 24792 +38054 24792 +10259 24789 +10149 24784 +39416 24783 +45320 24783 +17570 24777 +28281 24775 +18829 24774 +46291 24773 +34403 24771 +36366 24768 +20012 24767 +43250 24766 +14829 24765 +21370 24762 +31115 24759 +5470 24758 +36864 24755 +38483 24753 +36306 24751 +27314 24750 +33788 24749 +42662 24749 +48348 24748 +47843 24745 +15158 24743 +44689 24743 +10534 24734 +48766 24734 +26959 24732 +41285 24732 +20563 24732 +34559 24728 +47851 24722 +47221 24722 +43161 24720 +18186 24713 +44201 24711 +29438 24701 +2273 24701 +5790 24699 +30443 24696 +49440 24695 +35324 24690 +39468 24689 +49105 24689 +30021 24687 +44951 24685 +10818 24684 +15067 24682 +48651 24682 +42526 24680 +31407 24680 +28045 24679 +48135 24678 +38721 24677 +12276 24677 +47462 24676 +37833 24672 +35247 24666 +42505 24666 +43370 24663 +44841 24660 +35708 24660 +48025 24659 +42446 24656 +24508 24656 +46529 24655 +11235 24655 +39064 24649 +37229 24648 +44089 24648 +15480 24643 +36627 24642 +45731 24641 +24148 24641 +24044 24636 +30671 24634 +38657 24632 +45141 24630 +45629 24628 +39744 24626 +34817 24623 +43603 24623 +41180 24621 +45423 24620 +48430 24619 +30398 24619 +47243 24617 +27808 24616 +19151 24614 +42108 24610 +42137 24604 +43963 24603 +6274 24601 +46273 24600 +33215 24599 +29774 24597 +44088 24597 +30964 24597 +45002 24595 +34625 24595 +29977 24591 +36480 24589 +47390 24588 +35699 24585 +39837 24583 +24467 24583 +47780 24581 +38084 24577 +43486 24576 +14311 24574 +47337 24573 +47352 24572 +29969 24571 +41544 24567 +50147 24554 +37102 24551 +27093 24549 +32321 24549 +37570 24548 +41755 24548 +20719 24546 +35740 24545 +4085 24542 +49599 24541 +20639 24537 +24204 24535 +9205 24529 +34490 24525 +11928 24520 +32226 24517 +42707 24513 +33669 24512 +45578 24509 +27569 24507 +40383 24506 +29810 24506 +42315 24505 +31150 24503 +46042 24503 +37251 24500 +46674 24494 +43658 24494 +41061 24491 +35649 24490 +43151 24490 +24432 24488 +34370 24487 +40791 24486 +39686 24485 +23802 24482 +11964 24482 +29603 24481 +36144 24481 +28770 24478 +39009 24474 +32627 24472 +44514 24469 +47153 24469 +24629 24468 +33088 24468 +33192 24466 +44526 24463 +19879 24462 +29185 24461 +49246 24457 +32062 24452 +30539 24448 +36657 24447 +39158 24445 +40286 24444 +47833 24444 +40812 24444 +33938 24442 +43166 24441 +12626 24441 +48024 24439 +29408 24438 +28151 24430 +28124 24427 +49848 24426 +47208 24421 +7654 24421 +48957 24419 +46282 24419 +33317 24416 +7499 24416 +9291 24410 +37614 24408 +41472 24408 +26714 24408 +1968 24407 +29839 24407 +8921 24406 +46462 24405 +49932 24404 +26797 24403 +33227 24402 +29346 24402 +37466 24402 +27750 24397 +36777 24390 +38172 24388 +36551 24385 +27825 24382 +46580 24379 +45874 24379 +40464 24377 +2602 24376 +38675 24373 +32427 24373 +45185 24371 +30214 24369 +16935 24368 +21321 24365 +49447 24363 +43122 24359 +44022 24359 +49975 24358 +22155 24357 +44958 24353 +36629 24352 +16877 24351 +28390 24350 +45956 24348 +38875 24348 +44631 24340 +43935 24339 +26151 24338 +37542 24335 +41258 24333 +29501 24333 +49919 24328 +36397 24324 +10186 24323 +42744 24318 +22812 24314 +19677 24313 +24631 24313 +19466 24312 +48474 24311 +1284 24310 +31882 24310 +37076 24309 +44966 24306 +29400 24302 +49968 24301 +37068 24301 +38974 24299 +44695 24298 +28343 24294 +35615 24287 +164 24283 +27380 24283 +20507 24282 +49956 24281 +46098 24279 +45607 24279 +34310 24278 +34287 24277 +45343 24277 +34535 24276 +32277 24273 +49895 24271 +43224 24268 +30643 24267 +39682 24266 +40206 24263 +6525 24261 +29506 24260 +40787 24258 +40305 24256 +44979 24255 +38232 24253 +45000 24250 +21597 24249 +30152 24242 +46899 24242 +48244 24241 +30028 24240 +33971 24240 +35970 24239 +48225 24239 +16733 24235 +42651 24235 +32217 24235 +44789 24230 +23640 24229 +29173 24228 +36680 24228 +28722 24218 +18900 24215 +38746 24215 +45478 24215 +27784 24214 +40609 24213 +44681 24205 +43677 24201 +36979 24194 +37992 24194 +39100 24193 +29616 24193 +5880 24189 +44065 24187 +42364 24186 +35403 24184 +27514 24183 +41959 24181 +43138 24177 +6463 24174 +27871 24174 +24899 24174 +45976 24172 +43885 24167 +46074 24167 +47709 24165 +36393 24160 +37169 24156 +31964 24155 +35846 24155 +32562 24153 +21436 24148 +41515 24147 +3593 24147 +31304 24146 +36749 24140 +22845 24138 +33698 24136 +26586 24134 +38909 24134 +49191 24132 +37002 24132 +9531 24128 +45969 24121 +34407 24119 +30546 24118 +47378 24117 +46164 24115 +41132 24109 +45355 24108 +39721 24108 +23779 24104 +42227 24104 +36247 24102 +33220 24101 +39380 24100 +43957 24098 +50127 24097 +19946 24096 +16804 24096 +24809 24096 +8053 24096 +30578 24095 +21179 24095 +37528 24095 +48412 24091 +45016 24089 +22702 24087 +15580 24086 +45477 24086 +25666 24084 +38595 24083 +47840 24080 +48996 24075 +41797 24073 +12757 24070 +48083 24066 +23279 24057 +36760 24056 +4616 24056 +38873 24054 +33981 24050 +40076 24049 +46628 24047 +44822 24047 +46641 24043 +35602 24042 +20980 24041 +42363 24038 +38380 24037 +5561 24037 +39706 24035 +17839 24031 +48787 24029 +5918 24029 +23317 24027 +23495 24027 +1289 24026 +37469 24026 +34583 24023 +23449 24020 +47753 24016 +36570 24013 +36323 24012 +43329 24012 +33102 24009 +44530 24009 +41526 24007 +46323 24007 +22293 24006 +30484 24002 +22214 24002 +34467 24000 +32139 23999 +36434 23999 +31035 23998 +46794 23995 +25492 23994 +22764 23993 +46436 23988 +48036 23982 +27550 23977 +43220 23970 +29457 23965 +12337 23961 +35638 23960 +18068 23958 +29601 23957 +26750 23957 +41367 23955 +37396 23955 +35010 23955 +40739 23954 +48793 23954 +47923 23954 +19400 23946 +23582 23946 +40569 23945 +47953 23945 +37282 23945 +42937 23943 +36298 23942 +49048 23942 +33832 23940 +11604 23939 +45460 23938 +24667 23933 +41656 23931 +45660 23929 +49745 23929 +48196 23928 +49163 23928 +28605 23923 +25189 23919 +21924 23918 +18124 23917 +38339 23917 +43836 23913 +28029 23913 +44093 23913 +30377 23912 +19913 23911 +14527 23905 +13581 23903 +49741 23903 +48643 23902 +38431 23902 +43495 23899 +26679 23897 +49854 23893 +49941 23893 +38989 23892 +47906 23888 +42570 23886 +37682 23885 +25265 23883 +33302 23880 +48055 23878 +5244 23876 +31072 23872 +38976 23871 +42319 23870 +4118 23869 +16795 23867 +47740 23867 +18736 23864 +49904 23862 +21727 23862 +26468 23855 +38547 23854 +47673 23853 +34822 23852 +163 23851 +45176 23849 +39882 23848 +44664 23848 +26255 23847 +18305 23840 +37730 23836 +38525 23832 +48710 23831 +31162 23827 +37998 23821 +31835 23819 +48255 23817 +47944 23817 +26141 23811 +42648 23811 +37431 23810 +35286 23807 +33872 23807 +40125 23807 +45564 23806 +33921 23803 +26650 23802 +46601 23801 +40103 23801 +33665 23800 +43759 23799 +16469 23797 +36907 23796 +41029 23793 +29458 23791 +38107 23791 +21659 23791 +21238 23786 +47873 23785 +40758 23777 +46138 23775 +45326 23775 +31497 23774 +44206 23773 +46396 23771 +49378 23769 +39472 23766 +12124 23764 +8349 23761 +33079 23761 +50117 23759 +26713 23756 +15189 23755 +43788 23752 +41174 23751 +22177 23749 +35978 23748 +29422 23745 +39215 23745 +25962 23744 +29258 23744 +49566 23743 +13866 23740 +23450 23738 +45543 23731 +42305 23730 +44865 23729 +16735 23729 +41564 23728 +38737 23727 +45679 23726 +43469 23721 +42584 23719 +33610 23717 +26404 23712 +40437 23711 +22820 23711 +36462 23710 +48459 23709 +32953 23709 +15576 23705 +16140 23704 +39256 23701 +49225 23699 +33819 23698 +49716 23695 +14163 23694 +5546 23694 +40600 23693 +46324 23686 +29922 23685 +50229 23684 +42795 23682 +38147 23681 +49992 23678 +40887 23673 +4972 23666 +7568 23664 +39058 23663 +41882 23662 +49077 23661 +35092 23661 +31466 23660 +38871 23658 +32583 23658 +23899 23658 +20649 23656 +32672 23655 +49695 23653 +45727 23652 +22090 23650 +43743 23649 +39305 23649 +32703 23646 +40022 23644 +39549 23643 +48675 23643 +39609 23642 +33969 23640 +43149 23638 +39623 23638 +44263 23637 +10292 23633 +14117 23632 +44002 23629 +34085 23624 +44290 23622 +34728 23620 +22802 23616 +27603 23615 +43538 23614 +42206 23610 +42051 23610 +46731 23606 +42537 23605 +45289 23604 +20207 23604 +40198 23599 +39139 23595 +43831 23593 +48112 23591 +40732 23590 +44027 23590 +12448 23589 +38539 23589 +24113 23587 +11097 23583 +50082 23581 +26175 23580 +26295 23579 +36330 23575 +23925 23573 +47132 23570 +47674 23570 +48898 23570 +42155 23570 +3882 23569 +43147 23569 +35066 23568 +49148 23568 +36052 23567 +40660 23567 +10956 23566 +48862 23564 +28688 23564 +37923 23564 +49124 23563 +43711 23562 +16554 23561 +36357 23557 +20530 23551 +47687 23551 +35716 23545 +43964 23545 +39773 23538 +42489 23534 +35910 23533 +42582 23532 +46983 23531 +43980 23530 +34645 23529 +38249 23529 +40354 23524 +32904 23520 +37132 23519 +41081 23517 +20470 23515 +37622 23514 +37071 23510 +44471 23509 +26417 23508 +19080 23508 +47398 23507 +47836 23505 +40321 23495 +48275 23493 +38440 23489 +9186 23489 +44915 23489 +44682 23483 +37225 23476 +33042 23474 +31191 23474 +28081 23472 +41859 23466 +30746 23465 +12866 23465 +32535 23465 +13128 23464 +30106 23462 +19881 23458 +39003 23457 +34131 23448 +27500 23447 +38706 23447 +16595 23444 +35848 23442 +32663 23439 +13283 23437 +43984 23436 +43951 23434 +12610 23433 +48903 23430 +41983 23428 +16837 23423 +20896 23423 +20926 23420 +6830 23419 +38275 23415 +40882 23413 +28435 23413 +30764 23413 +34376 23412 +44551 23412 +39119 23412 +36024 23411 +43011 23410 +43218 23400 +17821 23400 +12814 23397 +43918 23394 +9184 23392 +39252 23389 +38224 23385 +30193 23384 +8038 23383 +46789 23377 +50035 23376 +35085 23374 +39382 23373 +46099 23372 +32477 23365 +15022 23362 +18923 23361 +31823 23360 +38159 23360 +45158 23356 +41634 23356 +28708 23353 +34717 23351 +36891 23350 +24102 23350 +49951 23349 +35366 23344 +43482 23342 +22938 23341 +3928 23337 +42590 23337 +24518 23337 +36914 23334 +10567 23333 +41412 23333 +37308 23332 +11360 23331 +17320 23331 +42608 23330 +43334 23326 +23986 23320 +12975 23320 +49623 23319 +31847 23318 +43234 23314 +39108 23313 +42272 23313 +15540 23312 +26087 23306 +34917 23306 +40893 23301 +41303 23297 +38205 23293 +37364 23287 +30488 23287 +49392 23286 +5058 23282 +38473 23280 +2572 23280 +40455 23280 +24383 23279 +19056 23273 +17015 23272 +37474 23272 +28812 23271 +37249 23269 +45428 23269 +32320 23268 +26789 23265 +8247 23264 +45514 23263 +41447 23262 +46443 23260 +44465 23260 +11953 23259 +47230 23255 +41632 23255 +28260 23253 +41619 23252 +47829 23249 +48389 23249 +37703 23247 +47446 23246 +45244 23246 +47234 23245 +37020 23243 +29629 23243 +26121 23238 +12207 23230 +42297 23228 +26499 23226 +24206 23224 +46844 23224 +36488 23222 +19492 23222 +40740 23220 +45806 23219 +47669 23219 +39997 23213 +29022 23211 +42762 23210 +17116 23206 +11929 23204 +49433 23201 +35697 23199 +18960 23198 +47452 23196 +37021 23193 +42661 23193 +26288 23193 +37515 23185 +38733 23185 +48827 23185 +37825 23182 +10208 23181 +17802 23178 +24393 23178 +48943 23174 +38346 23164 +35990 23163 +45095 23153 +6328 23153 +45317 23152 +34420 23152 +37603 23149 +42936 23147 +38569 23145 +44816 23143 +38575 23142 +42611 23141 +28989 23141 +5130 23141 +13382 23136 +45822 23135 +38402 23134 +45799 23133 +21705 23133 +27595 23130 +27959 23128 +40047 23121 +49317 23118 +47626 23117 +36931 23116 +43921 23115 +33241 23115 +41677 23115 +39409 23114 +42013 23114 +47938 23113 +37153 23113 +46416 23112 +42989 23110 +27280 23109 +38741 23106 +33759 23100 +37823 23100 +39328 23098 +11051 23096 +24637 23091 +36809 23090 +36913 23089 +34578 23089 +46318 23087 +39352 23084 +29688 23080 +47134 23076 +22037 23074 +22914 23073 +26523 23072 +43096 23072 +41775 23072 +26955 23065 +28391 23064 +36859 23064 +40821 23063 +46755 23062 +46565 23060 +43407 23059 +27850 23053 +48520 23051 +162 23050 +32863 23047 +30273 23046 +32126 23044 +5418 23043 +19005 23042 +38022 23041 +41167 23040 +48197 23034 +49846 23033 +30677 23029 +47049 23029 +30816 23029 +36996 23028 +31234 23025 +47910 23022 +41322 23022 +43187 23022 +43132 23018 +35394 23017 +45207 23014 +25456 23013 +13781 23011 +36974 23008 +28675 23008 +27740 23008 +6815 23007 +49473 23006 +22628 23005 +36505 23002 +35549 22999 +48154 22998 +30085 22997 +34776 22996 +47803 22995 +38313 22985 +35467 22983 +47627 22977 +24095 22973 +45657 22971 +40965 22969 +19873 22965 +46408 22962 +37869 22960 +48934 22957 +23433 22957 +45604 22956 +36951 22949 +27413 22948 +29693 22948 +46338 22945 +43366 22944 +23441 22935 +47057 22933 +45631 22931 +39667 22930 +38254 22929 +38472 22927 +35623 22926 +32962 22925 +48577 22922 +26699 22919 +24547 22919 +45191 22917 +39466 22916 +48461 22916 +47047 22916 +45621 22913 +38533 22910 +25066 22910 +47104 22909 +42279 22907 +34427 22906 +29978 22903 +27226 22902 +34251 22894 +11456 22893 +43072 22887 +32725 22882 +35962 22879 +39320 22879 +9282 22875 +8186 22873 +49867 22871 +45534 22868 +35391 22868 +37895 22866 +3209 22864 +46493 22861 +39448 22861 +18745 22858 +41785 22856 +25528 22854 +31705 22853 +33616 22852 +39518 22852 +43156 22849 +43705 22847 +32488 22847 +42449 22841 +38959 22839 +27294 22838 +31218 22837 +47045 22835 +34765 22825 +48542 22824 +43539 22822 +22941 22821 +47112 22819 +40881 22816 +44457 22816 +31452 22815 +31516 22812 +33962 22812 +49820 22811 +34343 22810 +41923 22806 +38831 22806 +36678 22805 +40328 22805 +34416 22805 +45001 22805 +10563 22804 +34574 22804 +39799 22803 +41338 22803 +39545 22802 +37060 22801 +40681 22801 +39495 22801 +25262 22800 +15620 22799 +45974 22799 +22398 22796 +49721 22795 +21464 22789 +46671 22789 +40141 22788 +24717 22781 +48913 22781 +38666 22780 +41649 22776 +48883 22773 +12334 22773 +36729 22773 +33887 22772 +48426 22767 +33697 22767 +48811 22767 +28407 22765 +25257 22764 +44455 22762 +35876 22761 +25184 22761 +46831 22759 +47194 22755 +23569 22753 +40408 22751 +49914 22746 +37737 22740 +29152 22739 +37618 22739 +33808 22737 +30296 22735 +20021 22735 +29910 22733 +30610 22733 +36734 22733 +31751 22731 +45331 22731 +4779 22722 +37711 22720 +41569 22719 +42872 22716 +32082 22709 +41589 22708 +50007 22705 +41093 22702 +37864 22701 +32322 22697 +48817 22697 +6346 22692 +46735 22690 +36723 22684 +41612 22684 +50193 22684 +33104 22684 +15358 22683 +37831 22679 +39563 22679 +46642 22678 +35171 22677 +44361 22670 +33791 22666 +31024 22665 +49326 22665 +39610 22664 +50078 22661 +38967 22653 +40554 22652 +30631 22644 +35369 22640 +48868 22633 +45650 22633 +35885 22632 +39101 22631 +47883 22630 +39709 22629 +34153 22627 +46186 22625 +20120 22623 +30731 22622 +50208 22621 +43485 22621 +41491 22621 +44582 22620 +27427 22617 +37857 22615 +34439 22613 +32060 22610 +40819 22606 +12339 22601 +36699 22599 +33700 22599 +46376 22599 +43570 22598 +37576 22594 +8586 22594 +36785 22577 +2981 22577 +24061 22576 +37893 22571 +42725 22571 +27543 22568 +50105 22568 +49453 22567 +42794 22566 +42050 22561 +19697 22561 +46241 22560 +39985 22558 +11716 22558 +47449 22553 +46199 22552 +46094 22552 +43565 22552 +43337 22551 +22806 22551 +42081 22550 +35291 22549 +40231 22547 +37972 22545 +16344 22543 +24675 22541 +40652 22541 +39512 22538 +45068 22535 +47102 22534 +40149 22534 +27964 22534 +35562 22533 +49177 22527 +41190 22526 +32263 22526 +46446 22525 +30342 22524 +50023 22522 +48345 22522 +49079 22522 +35700 22518 +48559 22518 +33924 22517 +39925 22517 +34185 22516 +37856 22516 +47372 22515 +48324 22514 +48513 22512 +17077 22512 +13654 22511 +47314 22510 +47480 22509 +48872 22507 +31242 22507 +46350 22506 +36260 22502 +36088 22501 +40861 22499 +36561 22496 +41453 22496 +48950 22492 +36118 22485 +33246 22484 +36048 22483 +48683 22483 +35475 22481 +21263 22479 +43101 22477 +21760 22474 +23286 22473 +24244 22471 +39093 22470 +45070 22469 +35544 22467 +25261 22466 +46309 22464 +38422 22462 +16541 22457 +39779 22457 +21595 22455 +45019 22449 +34961 22447 +46001 22445 +49920 22443 +47302 22441 +42069 22434 +37028 22434 +15428 22434 +47356 22433 +18946 22432 +15390 22429 +2976 22426 +50046 22426 +44784 22425 +47684 22423 +48079 22421 +41172 22419 +46141 22419 +8885 22417 +16023 22416 +59 22415 +48419 22413 +48792 22412 +42122 22410 +46682 22409 +16515 22408 +21480 22407 +18332 22405 +9542 22404 +28764 22404 +46389 22395 +42516 22395 +36368 22395 +4413 22392 +5712 22390 +33932 22388 +14673 22384 +46082 22384 +44550 22383 +42398 22380 +22443 22379 +30374 22378 +44641 22377 +38298 22373 +39174 22371 +23607 22368 +35739 22367 +40956 22365 +22539 22364 +30908 22356 +47599 22355 +48370 22354 +42846 22354 +42043 22351 +27489 22348 +32146 22348 +47355 22348 +42163 22347 +48359 22347 +43355 22346 +18588 22345 +26625 22344 +47159 22340 +25954 22339 +32617 22339 +42666 22338 +7143 22338 +13900 22334 +46804 22334 +50021 22333 +34346 22331 +23637 22330 +47067 22330 +30117 22327 +16367 22326 +31144 22321 +40619 22320 +49624 22318 +7917 22316 +32676 22315 +42330 22313 +20498 22308 +36801 22305 +21582 22305 +29680 22300 +44074 22300 +44228 22300 +30206 22297 +16297 22296 +30077 22296 +21706 22292 +40749 22291 +20686 22288 +2914 22286 +41425 22284 +35012 22282 +20737 22281 +41734 22279 +5138 22278 +28860 22265 +44382 22261 +44665 22261 +31992 22259 +50197 22259 +40985 22258 +22104 22256 +47679 22255 +15095 22253 +42061 22252 +26644 22249 +45029 22249 +19797 22247 +49799 22240 +47475 22240 +49801 22239 +39299 22233 +34812 22232 +32867 22230 +38986 22225 +30243 22224 +46836 22224 +42487 22220 +32538 22219 +42111 22218 +47459 22213 +39018 22210 +37334 22209 +10525 22208 +22438 22203 +22006 22202 +30314 22200 +20041 22199 +47324 22198 +48427 22198 +29162 22192 +34907 22189 +3045 22187 +20099 22186 +38371 22183 +40190 22177 +29783 22177 +42695 22174 +41144 22173 +39483 22172 +24358 22171 +47354 22169 +42399 22166 +49647 22160 +32005 22156 +49456 22154 +34053 22153 +33076 22150 +40438 22143 +31206 22140 +14957 22140 +22610 22138 +38549 22134 +48005 22133 +36203 22132 +47557 22131 +27816 22130 +34463 22128 +32751 22127 +49093 22127 +45279 22124 +38374 22123 +33602 22122 +42714 22121 +40499 22119 +50012 22114 +21914 22114 +39949 22114 +47363 22113 +39743 22113 +40163 22112 +40333 22107 +37272 22106 +40762 22104 +34330 22102 +33310 22101 +38356 22100 +45984 22100 +27483 22097 +12756 22095 +35282 22093 +30277 22092 +18238 22092 +13185 22090 +34158 22090 +29581 22090 +1609 22088 +30924 22087 +18793 22086 +49754 22085 +28645 22083 +22899 22080 +37615 22077 +44230 22075 +37636 22073 +31754 22072 +9063 22070 +24867 22067 +22939 22061 +29865 22061 +30846 22057 +46255 22057 +48624 22053 +19011 22052 +48284 22051 +48480 22046 +36530 22044 +48248 22043 +41165 22040 +30694 22039 +42366 22037 +45382 22034 +22404 22032 +11690 22031 +45787 22030 +27021 22021 +45737 22017 +32516 22017 +24326 22016 +42144 22012 +24132 22007 +25174 22007 +35642 22004 +29059 22003 +42947 22003 +13518 22003 +39243 22002 +25392 22000 +49172 21998 +34950 21998 +44106 21997 +42107 21997 +45757 21997 +30863 21997 +36956 21995 +41289 21995 +26178 21994 +47850 21991 +12715 21991 +35973 21987 +15879 21985 +37794 21984 +31800 21980 +3040 21979 +41211 21979 +25545 21979 +45173 21979 +25835 21978 +28911 21977 +24449 21977 +48201 21972 +45314 21970 +6781 21969 +32165 21968 +38903 21961 +48332 21959 +37567 21958 +33794 21957 +17377 21954 +37414 21954 +49990 21950 +45792 21945 +34096 21942 +48632 21941 +29266 21939 +47241 21936 +37735 21934 +31982 21933 +49306 21933 +16557 21932 +37338 21930 +39544 21928 +49329 21926 +19154 21925 +2510 21924 +31891 21922 +32648 21922 +29249 21921 +45971 21918 +49508 21917 +39653 21917 +49514 21916 +21401 21916 +29054 21916 +9556 21915 +47929 21912 +48721 21901 +48512 21899 +19117 21897 +30464 21895 +45572 21892 +35071 21891 +37776 21888 +35735 21887 +41075 21887 +43704 21887 +45012 21886 +40841 21881 +34530 21877 +16138 21875 +43231 21871 +39122 21871 +36620 21871 +38310 21870 +38629 21862 +42380 21860 +36249 21856 +43434 21852 +38352 21852 +41304 21850 +29299 21850 +42712 21849 +49231 21849 +6925 21848 +44569 21847 +17833 21843 +35681 21843 +45213 21842 +17417 21841 +49586 21840 +32430 21836 +47124 21836 +21619 21833 +49706 21833 +47814 21833 +34959 21832 +42534 21829 +46431 21827 +45259 21821 +37747 21820 +26846 21819 +39553 21816 +39004 21816 +33374 21814 +48004 21811 +34546 21811 +2765 21810 +28718 21809 +16353 21808 +29792 21808 +27279 21807 +27379 21802 +43315 21801 +47128 21801 +21280 21800 +5604 21798 +34828 21797 +23206 21795 +40876 21790 +16501 21788 +47909 21786 +38092 21786 +43184 21785 +21243 21785 +35133 21784 +18166 21781 +38703 21780 +49986 21780 +45654 21779 +26302 21777 +47885 21777 +37434 21773 +39918 21773 +47023 21772 +41308 21771 +10878 21768 +44539 21768 +35678 21765 +27629 21765 +34137 21764 +41423 21761 +23203 21760 +39558 21759 +27672 21758 +14933 21757 +48008 21755 +40885 21752 +36314 21752 +39586 21751 +40081 21751 +41580 21748 +49888 21748 +37613 21745 +33398 21744 +7399 21743 +26776 21740 +48949 21739 +27836 21736 +33345 21736 +27398 21735 +35815 21733 +24198 21733 +42905 21733 +17069 21731 +8917 21731 +42704 21731 +38995 21729 +37094 21729 +43134 21729 +44815 21728 +50064 21727 +38456 21726 +44860 21725 +36299 21723 +10198 21722 +41789 21722 +39689 21722 +19895 21722 +18790 21719 +34302 21717 +40275 21717 +36201 21716 +41813 21715 +48070 21714 +4994 21713 +30732 21711 +17746 21706 +43862 21704 +36496 21701 +44903 21700 +29700 21698 +46472 21697 +31383 21694 +35664 21692 +44461 21688 +41287 21687 +35809 21686 +44430 21685 +37777 21682 +6753 21678 +32869 21678 +12909 21678 +28037 21676 +41291 21674 +24047 21673 +36271 21671 +46492 21670 +17148 21669 +48783 21667 +33608 21663 +40234 21662 +45661 21659 +35721 21654 +44593 21653 +40184 21651 +47076 21651 +37804 21651 +27291 21650 +49714 21649 +49010 21643 +36643 21638 +28694 21638 +25155 21637 +41548 21636 +1707 21636 +45409 21634 +24156 21630 +49983 21621 +44251 21621 +35890 21614 +45722 21614 +41660 21613 +24225 21612 +40877 21608 +43509 21605 +47411 21604 +27904 21604 +10139 21598 +19539 21595 +45090 21592 +42780 21589 +41275 21589 +49386 21586 +48091 21583 +16153 21583 +38466 21581 +39771 21580 +32567 21577 +41822 21577 +29052 21576 +26008 21575 +34820 21574 +13036 21573 +46962 21571 +47326 21570 +46960 21563 +40618 21562 +32970 21562 +43536 21559 +16907 21557 +48311 21550 +38783 21550 +39526 21548 +46526 21547 +45551 21546 +49719 21544 +35472 21541 +16005 21540 +47336 21537 +25118 21536 +26330 21536 +46197 21533 +13047 21533 +42529 21532 +26738 21532 +22742 21529 +43666 21523 +20523 21522 +26305 21520 +40823 21513 +32439 21511 +27537 21511 +44149 21509 +39117 21504 +39942 21500 +40405 21498 +43289 21497 +41477 21497 +27891 21497 +41542 21496 +39880 21494 +28957 21493 +46663 21491 +40385 21489 +13874 21486 +30521 21485 +22667 21480 +4442 21479 +40058 21475 +46290 21475 +46762 21473 +18835 21472 +17354 21469 +46724 21465 +46606 21464 +44439 21464 +41577 21462 +48924 21461 +10954 21455 +7041 21454 +37505 21449 +40495 21448 +46661 21444 +47205 21442 +24318 21442 +49555 21442 +32058 21436 +41810 21432 +45649 21431 +33987 21430 +27743 21423 +29840 21423 +37055 21421 +14863 21420 +46298 21418 +39530 21417 +40276 21416 +44857 21415 +7494 21413 +26092 21413 +39801 21406 +33979 21401 +36664 21396 +42194 21395 +43624 21391 +42309 21390 +28073 21388 +40860 21388 +49747 21382 +48649 21381 +38856 21381 +38605 21377 +43780 21376 +29796 21374 +32824 21374 +2281 21373 +43860 21373 +49688 21371 +28402 21368 +46044 21362 +46885 21356 +40128 21355 +16820 21355 +20847 21354 +48176 21352 +26922 21351 +48250 21351 +45025 21350 +37483 21348 +49809 21346 +29733 21345 +45521 21338 +42921 21335 +42055 21334 +18635 21332 +21389 21329 +44994 21328 +20378 21327 +10138 21324 +49184 21322 +46916 21322 +48425 21321 +36376 21319 +40671 21317 +41557 21315 +16692 21312 +48661 21310 +42634 21306 +28041 21301 +46509 21301 +30986 21300 +49276 21299 +44048 21299 +33462 21296 +26261 21293 +49640 21293 +49102 21292 +6618 21288 +45193 21287 +40954 21287 +44137 21286 +43125 21285 +47101 21282 +5771 21281 +33484 21277 +14889 21276 +38576 21275 +41101 21271 +42533 21269 +46293 21266 +31938 21266 +37475 21266 +49692 21264 +18038 21260 +48200 21260 +29067 21259 +40785 21258 +44987 21258 +40889 21256 +39357 21251 +43523 21248 +45993 21247 +19006 21245 +30931 21241 +1116 21237 +30606 21237 +43803 21227 +45505 21225 +13967 21223 +43168 21223 +46254 21223 +36208 21222 +12065 21221 +28677 21221 +49478 21220 +46585 21219 +41292 21216 +39578 21216 +39344 21216 +43293 21212 +42280 21207 +21301 21206 +33621 21206 +41666 21201 +30662 21201 +35875 21201 +31199 21201 +30650 21201 +31120 21200 +17483 21196 +32243 21191 +35418 21188 +43403 21182 +39201 21176 +42960 21173 +22805 21171 +39736 21171 +37304 21171 +32200 21168 +42472 21168 +44281 21168 +13903 21167 +39312 21167 +40051 21166 +4184 21164 +10683 21163 +39251 21157 +32371 21154 +39166 21154 +33883 21153 +32968 21152 +49973 21151 +21101 21148 +41066 21146 +26155 21146 +23709 21141 +41590 21140 +39111 21138 +31495 21137 +41460 21137 +48987 21127 +13821 21127 +38073 21123 +46005 21123 +23155 21122 +47988 21116 +2868 21115 +38906 21115 +48564 21112 +40245 21112 +40173 21103 +31880 21103 +44162 21100 +27403 21100 +134 21099 +34865 21094 +11156 21093 +36981 21089 +43016 21089 +21871 21086 +27559 21086 +45682 21085 +31350 21083 +43874 21082 +39023 21078 +46847 21076 +38505 21074 +46067 21071 +48182 21066 +21687 21066 +28730 21057 +50189 21056 +42875 21054 +34335 21052 +11229 21050 +10922 21050 +37348 21049 +36927 21046 +42726 21046 +46550 21045 +26588 21044 +13065 21040 +13090 21037 +22834 21036 +13082 21035 +42268 21030 +45630 21029 +8451 21029 +47792 21024 +28757 21022 +34312 21022 +49461 21022 +49233 21019 +38407 21018 +16742 21017 +39186 21016 +35140 21014 +20949 21013 +45458 21008 +49979 21004 +37323 21001 +43626 21001 +30420 21001 +32915 20999 +43253 20992 +45136 20991 +40700 20990 +1889 20989 +26123 20988 +33553 20987 +38546 20983 +46271 20981 +5853 20980 +42015 20974 +25283 20974 +39216 20973 +30565 20972 +43820 20971 +44957 20971 +35145 20971 +37472 20971 +43610 20970 +36445 20969 +49381 20968 +47283 20968 +14975 20966 +34178 20966 +32704 20965 +35720 20963 +36902 20961 +34647 20959 +35030 20959 +46612 20958 +5877 20957 +35378 20956 +32975 20954 +35755 20947 +14238 20947 +41166 20946 +46378 20944 +27556 20942 +38846 20941 +18521 20938 +35388 20935 +40116 20935 +36549 20933 +48399 20928 +37531 20927 +39449 20923 +47303 20919 +12999 20917 +25235 20916 +27701 20916 +42005 20914 +46146 20913 +33483 20912 +37117 20907 +39327 20907 +30234 20907 +43633 20902 +18122 20898 +45493 20895 +6933 20893 +7845 20884 +33723 20877 +24418 20874 +39904 20872 +48736 20870 +8660 20868 +26307 20867 +49122 20866 +33449 20863 +30270 20862 +30893 20861 +48726 20861 +45072 20860 +38636 20860 +49282 20859 +42010 20859 +49418 20858 +34359 20856 +37716 20855 +24543 20853 +33284 20852 +40157 20851 +17156 20851 +48809 20847 +49697 20843 +40957 20842 +34742 20840 +42747 20839 +41858 20836 +37769 20835 +22058 20835 +43363 20833 +48680 20831 +5927 20830 +13228 20826 +33856 20826 +37780 20825 +48230 20824 +40375 20819 +48212 20819 +3712 20814 +45719 20809 +26267 20809 +23072 20809 +41043 20808 +33647 20804 +49940 20803 +47287 20798 +3138 20795 +27129 20794 +32599 20788 +22012 20787 +30018 20780 +49024 20775 +39118 20775 +30317 20775 +36337 20773 +28004 20773 +47551 20773 +47904 20770 +43690 20770 +39513 20765 +18448 20763 +9790 20762 +28022 20761 +45325 20759 +33056 20758 +31409 20757 +39940 20757 +25983 20755 +40979 20754 +45485 20753 +45704 20752 +36059 20752 +4552 20746 +34288 20745 +40285 20744 +29878 20744 +35156 20742 +37902 20741 +48263 20741 +29593 20740 +43510 20740 +41195 20739 +49542 20738 +40523 20738 +43221 20737 +2400 20736 +39895 20734 +40182 20732 +49625 20732 +8778 20731 +50032 20729 +32276 20725 +40564 20723 +24441 20722 +28352 20717 +6261 20716 +33797 20715 +34618 20715 +49707 20715 +45929 20713 +4878 20713 +43116 20713 +47009 20712 +28833 20712 +38066 20708 +16946 20707 +16575 20707 +45693 20706 +48052 20704 +34435 20703 +46460 20703 +26817 20700 +22266 20699 +39738 20697 +27068 20694 +13561 20693 +35997 20692 +37806 20691 +45128 20690 +39831 20689 +24661 20687 +47861 20686 +20098 20686 +44004 20680 +44261 20678 +39242 20675 +41148 20674 +11586 20671 +45118 20671 +4832 20671 +40043 20667 +44184 20659 +22797 20659 +25033 20657 +43322 20654 +22454 20653 +33258 20653 +34793 20649 +38220 20648 +40248 20648 +36722 20646 +43996 20645 +48189 20643 +10079 20642 +43540 20641 +47913 20635 +16709 20626 +43193 20622 +37765 20614 +39768 20612 +45028 20607 +47484 20606 +12743 20606 +45632 20606 +13962 20604 +21250 20597 +38082 20597 +28667 20596 +42740 20595 +49561 20587 +15535 20587 +43367 20585 +41364 20585 +43410 20584 +40987 20584 +10672 20583 +49109 20581 +38055 20580 +40179 20578 +42583 20574 +25642 20573 +24753 20570 +34124 20569 +49944 20568 +49351 20563 +49288 20562 +31041 20560 +34456 20556 +41019 20556 +32918 20553 +50000 20552 +37845 20550 +33239 20549 +41344 20546 +19738 20545 +35926 20544 +43391 20542 +36265 20542 +47799 20541 +37349 20539 +45900 20534 +47408 20528 +35474 20526 +42105 20524 +49853 20523 +42885 20521 +41473 20519 +40005 20515 +39179 20514 +46984 20512 +2201 20512 +36424 20512 +12843 20509 +29508 20507 +23909 20504 +39378 20503 +46415 20502 +30691 20502 +47276 20501 +45668 20495 +42175 20493 +41017 20493 +17982 20491 +50213 20491 +48062 20490 +37860 20490 +40175 20489 +23661 20489 +1508 20487 +37224 20484 +14761 20479 +48159 20478 +10294 20477 +44817 20476 +47426 20473 +37258 20473 +41847 20473 +34046 20471 +18009 20470 +38586 20470 +29715 20470 +47702 20469 +43169 20466 +33993 20462 +44218 20460 +41745 20459 +34400 20459 +44925 20458 +32059 20458 +5965 20458 +20456 20448 +39731 20446 +45758 20446 +48866 20445 +39188 20445 +43912 20444 +11062 20440 +34813 20437 +42117 20437 +45421 20436 +33758 20435 +46827 20433 +34739 20431 +34524 20429 +15578 20427 +6019 20426 +40638 20426 +25228 20426 +24008 20424 +37289 20423 +11415 20422 +42778 20422 +47666 20421 +4456 20417 +37680 20416 +29984 20416 +35736 20416 +38053 20415 +45538 20413 +45940 20413 +47897 20412 +37827 20412 +5084 20411 +17665 20411 +24461 20410 +34300 20409 +41495 20409 +23346 20408 +42918 20407 +28613 20406 +31674 20405 +43420 20404 +45590 20403 +46387 20402 +27288 20401 +44927 20400 +47969 20400 +45840 20399 +42215 20396 +21470 20396 +41136 20392 +16366 20388 +43685 20387 +39403 20386 +41302 20384 +46759 20383 +45850 20380 +40147 20379 +24882 20376 +35396 20376 +41232 20373 +30139 20372 +33272 20369 +48429 20369 +43707 20367 +45366 20365 +35200 20365 +37802 20363 +18688 20363 +41143 20362 +19633 20361 +24019 20356 +40486 20356 +47818 20354 +21197 20353 +9832 20347 +35908 20344 +42650 20342 +45089 20342 +28664 20341 +33854 20341 +22274 20340 +38907 20338 +35810 20337 +45720 20336 +26939 20333 +25271 20332 +24334 20332 +19317 20331 +34169 20330 +33367 20329 +48229 20326 +4977 20324 +42819 20321 +31589 20317 +46352 20316 +44576 20312 +50181 20307 +43631 20301 +41486 20301 +48466 20298 +36603 20298 +41295 20298 +40820 20297 +29988 20295 +49125 20294 +46023 20294 +41706 20293 +35964 20293 +45280 20292 +46435 20287 +32238 20286 +37453 20284 +32069 20276 +42199 20275 +45842 20274 +46169 20268 +48294 20266 +31080 20265 +40940 20264 +32739 20262 +37424 20257 +32923 20256 +35828 20256 +20655 20255 +26794 20254 +39315 20254 +36928 20254 +40433 20252 +33967 20246 +5217 20240 +45131 20238 +42213 20237 +21319 20237 +33402 20235 +24531 20235 +45339 20232 +39368 20222 +30813 20221 +21618 20219 +40797 20219 +38885 20215 +16634 20204 +33186 20201 +31634 20199 +50140 20197 +29734 20196 +38628 20195 +48544 20192 +20397 20187 +33112 20184 +13749 20183 +3962 20183 +39096 20181 +45009 20180 +37852 20180 +46147 20178 +46341 20176 +32475 20171 +4575 20170 +42353 20170 +36076 20170 +33549 20167 +24981 20167 +46235 20166 +47106 20165 +49898 20165 +30641 20163 +48909 20161 +17488 20159 +25746 20155 +47623 20154 +36600 20154 +48136 20151 +30192 20145 +18541 20142 +31148 20142 +31633 20136 +29884 20131 +48782 20129 +30518 20125 +15289 20115 +32795 20114 +32738 20113 +38312 20109 +44793 20108 +47957 20103 +23012 20098 +33463 20089 +49089 20089 +49921 20088 +41065 20086 +48380 20083 +49674 20079 +47985 20078 +16714 20077 +42871 20077 +30189 20077 +49644 20075 +43875 20074 +14141 20073 +25990 20073 +39697 20073 +25099 20071 +30969 20069 +26266 20064 +18765 20063 +28358 20063 +49934 20062 +45385 20060 +18156 20060 +37988 20059 +17992 20059 +40035 20051 +44736 20050 +44260 20047 +13515 20045 +40423 20044 +45797 20043 +36870 20042 +49012 20035 +44400 20032 +48386 20028 +33939 20026 +25506 20025 +23928 20024 +42411 20022 +13651 20022 +39120 20021 +45427 20021 +41198 20018 +22528 20017 +48463 20014 +47642 20012 +8416 20009 +21918 20007 +40311 20005 +22809 20002 +25979 20002 +39664 19999 +30087 19998 +36961 19997 +37826 19996 +43697 19995 +3229 19992 +39210 19990 +43057 19984 +15609 19981 +35490 19980 +48295 19977 +27787 19976 +38697 19972 +21860 19971 +40393 19970 +46180 19968 +49244 19964 +36226 19964 +45106 19961 +30396 19959 +49995 19957 +47675 19953 +32362 19947 +18314 19946 +25679 19945 +37601 19944 +47578 19944 +32318 19943 +13628 19943 +42276 19941 +48291 19940 +45401 19938 +13887 19933 +36725 19932 +41600 19930 +44136 19929 +41948 19928 +47069 19926 +33366 19923 +45252 19920 +46636 19911 +37015 19908 +13073 19906 +42428 19904 +38918 19903 +43901 19901 +30322 19900 +39878 19899 +47330 19892 +33199 19890 +46617 19889 +27968 19889 +41938 19887 +41752 19886 +42091 19885 +44123 19885 +39628 19882 +40465 19881 +48057 19881 +44639 19880 +18380 19879 +1060 19878 +45472 19877 +11988 19875 +4971 19874 +17910 19872 +22690 19867 +42939 19864 +47468 19863 +23651 19858 +20112 19858 +42430 19856 +34487 19851 +46201 19845 +34437 19840 +41257 19837 +37775 19833 +50085 19831 +38438 19831 +42074 19827 +38237 19826 +45107 19822 +46314 19820 +49503 19820 +29401 19820 +22157 19819 +25117 19815 +42413 19815 +34792 19812 +20448 19811 +46758 19806 +43600 19805 +33101 19805 +32852 19803 +44908 19800 +37203 19799 +45111 19798 +12658 19791 +25661 19788 +32941 19784 +40573 19783 +39107 19777 +44705 19772 +42250 19772 +49488 19770 +9622 19769 +45721 19762 +40256 19761 +34964 19761 +42601 19761 +43876 19761 +32001 19760 +46792 19757 +38802 19755 +48376 19752 +41722 19750 +27894 19748 +48177 19747 +45113 19746 +40848 19745 +11877 19744 +12235 19744 +36276 19743 +18048 19742 +42790 19741 +48408 19736 +34631 19736 +47601 19734 +15514 19733 +36104 19727 +42769 19726 +44881 19726 +39872 19725 +44617 19724 +36693 19721 +48745 19720 +32316 19720 +38654 19717 +9872 19716 +23172 19712 +43808 19710 +48882 19709 +43580 19707 +44578 19705 +39696 19701 +42962 19698 +30235 19698 +27992 19698 +44928 19697 +43673 19697 +49650 19696 +40654 19695 +45531 19695 +17751 19694 +19007 19692 +41647 19691 +41261 19690 +3121 19689 +16998 19689 +38970 19688 +45288 19686 +32616 19685 +42789 19684 +38070 19683 +46356 19683 +48584 19681 +46438 19679 +23812 19678 +48108 19678 +10803 19678 +47824 19675 +30620 19674 +12359 19674 +41604 19669 +41895 19668 +31184 19667 +27880 19665 +45124 19664 +47070 19661 +46883 19660 +46302 19656 +44667 19652 +23093 19650 +16684 19649 +43432 19646 +44969 19644 +16530 19643 +49097 19643 +6854 19643 +17573 19642 +7992 19637 +31000 19634 +44977 19633 +40682 19631 +28631 19629 +38457 19628 +15507 19626 +49196 19625 +35438 19624 +47576 19619 +26694 19617 +46020 19615 +47308 19615 +41458 19612 +43571 19610 +28761 19608 +40572 19606 +41914 19605 +48739 19605 +20280 19603 +47491 19602 +32928 19601 +25346 19599 +46258 19598 +43451 19592 +47493 19590 +46028 19584 +32454 19583 +10600 19583 +43813 19580 +47482 19574 +31094 19573 +37167 19571 +42690 19569 +42343 19568 +42463 19564 +44363 19556 +28869 19555 +42776 19547 +40417 19545 +33505 19545 +44893 19544 +43026 19544 +49216 19542 +20335 19541 +28254 19539 +40747 19538 +30409 19536 +31551 19536 +6694 19534 +38445 19534 +42115 19533 +30903 19532 +24292 19531 +48030 19530 +42214 19526 +50168 19524 +48638 19523 +20193 19521 +20502 19520 +48110 19519 +15911 19517 +48194 19515 +40659 19515 +43284 19514 +26729 19513 +40620 19511 +35795 19510 +49446 19508 +38843 19508 +18442 19507 +23396 19504 +34694 19504 +26766 19500 +38142 19497 +38828 19495 +33070 19495 +21968 19493 +46061 19493 +44549 19492 +50080 19491 +28106 19487 +13344 19486 +18099 19484 +41381 19483 +26025 19482 +33751 19479 +44399 19479 +22165 19479 +48392 19474 +38793 19474 +42321 19471 +21889 19465 +38117 19459 +43778 19457 +46894 19455 +34431 19454 +46572 19452 +37586 19449 +46632 19449 +29891 19447 +40279 19447 +46417 19447 +48264 19446 +26233 19445 +36580 19444 +38015 19444 +49837 19443 +37522 19443 +28455 19442 +18885 19441 +46333 19437 +43908 19436 +10201 19435 +27300 19433 +31286 19429 +48488 19428 +30765 19426 +49115 19425 +31563 19422 +38314 19420 +35609 19415 +43948 19414 +22135 19412 +31613 19407 +40639 19405 +31972 19404 +47521 19401 +34615 19394 +40972 19394 +38139 19392 +30482 19390 +39912 19389 +37832 19389 +39332 19388 +18584 19388 +42548 19386 +47899 19386 +47498 19385 +38071 19384 +44879 19381 +32340 19380 +1261 19379 +45960 19378 +39147 19373 +22504 19372 +45864 19371 +49123 19371 +46442 19370 +39089 19370 +50161 19369 +38350 19369 +38202 19362 +41599 19361 +38600 19361 +23190 19359 +22550 19359 +38954 19358 +23952 19358 +46871 19356 +47990 19356 +39112 19355 +21722 19355 +42956 19354 +44649 19354 +40756 19352 +34808 19349 +30424 19349 +42032 19348 +11021 19348 +40207 19347 +49064 19346 +35143 19345 +49953 19344 +36275 19344 +38852 19344 +49147 19343 +34026 19341 +39800 19341 +25512 19341 +43006 19341 +4989 19336 +24480 19335 +41456 19335 +21463 19335 +9411 19330 +23645 19328 +23435 19326 +46239 19325 +7462 19324 +47760 19323 +35854 19323 +9378 19322 +18713 19321 +35167 19320 +43719 19319 +45006 19319 +42130 19315 +48856 19313 +48634 19313 +46886 19311 +38177 19310 +47369 19309 +42759 19308 +24945 19307 +31577 19306 +44215 19304 +28864 19303 +41642 19302 +43182 19298 +46925 19296 +38509 19295 +44468 19295 +49319 19292 +48764 19292 +37839 19291 +42336 19291 +31050 19287 +44338 19283 +28114 19281 +46096 19278 +16606 19277 +45734 19276 +25052 19274 +34023 19272 +44031 19269 +37050 19268 +41833 19267 +38116 19266 +36555 19264 +29289 19263 +48092 19261 +18363 19260 +41541 19258 +23522 19258 +47931 19257 +45989 19254 +47683 19253 +49701 19250 +46052 19249 +34621 19246 +33203 19245 +40711 19243 +47900 19243 +47233 19242 +2874 19237 +46501 19232 +49111 19231 +18386 19230 +38062 19230 +46056 19227 +15676 19227 +38375 19226 +45838 19225 +47200 19223 +48724 19223 +39102 19222 +49439 19218 +42075 19216 +18144 19214 +45881 19211 +46872 19211 +29344 19210 +47949 19209 +39573 19207 +41925 19206 +45349 19206 +44896 19203 +38685 19202 +44397 19198 +41169 19197 +21177 19196 +8460 19196 +35123 19194 +48573 19184 +18095 19182 +16956 19180 +1914 19179 +24990 19179 +16786 19176 +23562 19176 +10042 19175 +25029 19175 +34619 19175 +37652 19174 +36813 19172 +36948 19170 +20773 19161 +24412 19159 +20763 19158 +29304 19157 +27319 19156 +38412 19156 +22918 19155 +46109 19154 +40441 19147 +37798 19144 +39405 19140 +48150 19139 +39785 19137 +29114 19137 +38604 19131 +43462 19129 +44408 19124 +45122 19121 +17434 19121 +34200 19120 +46749 19118 +27130 19114 +35509 19113 +49509 19113 +50010 19112 +42407 19112 +45452 19112 +44960 19110 +46868 19108 +45696 19107 +48096 19106 +46270 19105 +27270 19098 +22902 19089 +34393 19089 +10519 19088 +33074 19085 +43864 19082 +42174 19080 +25633 19080 +44560 19078 +48630 19075 +11850 19073 +48524 19071 +36305 19069 +22869 19066 +18719 19064 +43048 19060 +44891 19058 +28871 19058 +47670 19057 +47880 19057 +44513 19053 +14688 19052 +31643 19047 +48260 19047 +33651 19047 +39413 19045 +46263 19044 +33571 19039 +17191 19036 +43009 19036 +44176 19033 +41792 19032 +34779 19031 +28886 19030 +46158 19027 +46993 19026 +48825 19023 +45944 19022 +19741 19019 +41583 19018 +21936 19016 +49845 19013 +48398 19012 +25058 19011 +5467 19008 +36282 19007 +41492 19006 +24512 19005 +48187 19004 +42763 19002 +29274 19001 +16982 19001 +47237 19001 +33325 19001 +50027 18997 +42435 18992 +35230 18989 +46589 18989 +40631 18985 +18749 18983 +26368 18982 +36228 18982 +21663 18979 +4027 18979 +13807 18978 +36499 18978 +36109 18977 +46176 18972 +26491 18968 +39443 18965 +49974 18963 +31457 18963 +46103 18954 +47785 18952 +47016 18951 +27175 18951 +43986 18950 +41072 18949 +34408 18947 +48813 18946 +7290 18945 +47396 18945 +41280 18945 +48645 18944 +30187 18936 +50167 18933 +43339 18933 +38650 18932 +29163 18931 +12650 18931 +40736 18930 +47915 18929 +17181 18928 +39584 18927 +20619 18925 +47305 18924 +44063 18924 +30142 18919 +44214 18918 +10027 18917 +26967 18914 +41279 18912 +48170 18912 +45225 18910 +50222 18905 +22192 18898 +46285 18894 +39324 18893 +37446 18892 +20297 18891 +43119 18888 +13163 18888 +43465 18885 +13297 18883 +41627 18882 +49397 18881 +43445 18881 +37458 18881 +47941 18881 +48246 18878 +8289 18877 +37889 18876 +42562 18875 +33995 18875 +49964 18873 +49052 18862 +49857 18861 +32606 18860 +41874 18856 +44598 18854 +29277 18853 +46623 18852 +41765 18852 +42011 18850 +38169 18849 +27991 18847 +34349 18846 +5312 18842 +46250 18839 +21704 18836 +40251 18831 +26901 18830 +23770 18828 +47350 18821 +27214 18820 +48930 18819 +19735 18817 +35387 18813 +39509 18810 +29410 18809 +47807 18803 +49489 18800 +17040 18794 +48462 18794 +34850 18790 +34411 18788 +34610 18787 +47694 18786 +2203 18785 +40401 18782 +43427 18779 +13264 18779 +25775 18778 +43819 18776 +27636 18773 +46476 18770 +37941 18768 +33086 18768 +41955 18764 +45705 18762 +45441 18758 +43300 18751 +8535 18747 +43854 18745 +44265 18740 +38318 18739 +35087 18736 +18991 18735 +8522 18729 +45857 18727 +37691 18725 +44685 18725 +49499 18724 +27215 18723 +34718 18721 +35950 18719 +43564 18718 +23168 18717 +24085 18717 +19489 18716 +16448 18715 +43822 18715 +48665 18711 +49550 18711 +42145 18708 +10639 18702 +26836 18702 +48697 18696 +39568 18695 +27844 18695 +48772 18694 +47397 18693 +48037 18692 +25367 18692 +39615 18686 +44504 18685 +48442 18683 +43385 18683 +5666 18682 +42675 18680 +43883 18680 +24647 18678 +42271 18676 +41403 18674 +5914 18674 +26892 18674 +48864 18672 +48647 18667 +17566 18666 +14391 18664 +42283 18664 +32031 18662 +21113 18661 +24212 18661 +48381 18658 +37400 18656 +46649 18649 +24360 18645 +34919 18645 +47613 18644 +39550 18641 +33934 18639 +41998 18636 +16424 18628 +32942 18626 +24112 18626 +36241 18625 +26098 18622 +40414 18621 +36818 18620 +48648 18618 +47812 18613 +49130 18607 +9333 18606 +21930 18604 +41050 18602 +26991 18599 +47901 18598 +42443 18596 +30380 18595 +42938 18592 +45791 18592 +34829 18591 +43722 18590 +44372 18589 +36255 18584 +28919 18584 +17271 18581 +23862 18578 +25955 18577 +24121 18576 +42482 18574 +36056 18572 +44675 18570 +40804 18569 +24355 18569 +49816 18569 +42702 18568 +37905 18568 +46743 18567 +36949 18567 +10430 18566 +41060 18561 +8456 18559 +25612 18558 +31728 18557 +44269 18555 +29919 18555 +42405 18554 +16579 18546 +24084 18544 +20150 18544 +34888 18543 +46692 18542 +30297 18541 +31737 18540 +18497 18538 +22062 18535 +48489 18534 +44622 18532 +49720 18532 +23736 18528 +47085 18527 +34712 18524 +35443 18524 +44087 18524 +32501 18516 +19537 18515 +26341 18513 +28547 18510 +32527 18508 +35712 18505 +45639 18502 +41330 18501 +47838 18500 +48719 18500 +25593 18499 +38752 18498 +44955 18496 +27547 18490 +39866 18490 +6900 18490 +22285 18490 +17350 18490 +43930 18489 +32179 18487 +44586 18486 +48808 18482 +9802 18478 +35064 18476 +19424 18473 +50205 18471 +29982 18470 +48861 18470 +49330 18470 +42307 18469 +47037 18465 +44055 18465 +33096 18465 +42412 18464 +35035 18463 +48006 18463 +43389 18462 +34333 18462 +39334 18459 +15026 18458 +46752 18457 +10859 18456 +44753 18455 +43950 18454 +41183 18453 +8032 18452 +24145 18449 +47646 18445 +47275 18444 +13031 18444 +44327 18442 +41815 18441 +46678 18441 +44573 18439 +38226 18434 +42604 18433 +26994 18431 +46296 18430 +29929 18429 +39921 18429 +13607 18421 +42493 18421 +39168 18419 +38902 18416 +46026 18412 +44396 18410 +38187 18410 +37452 18410 +19465 18406 +49150 18402 +43557 18402 +49424 18399 +48578 18393 +33838 18392 +41531 18390 +41962 18390 +16845 18385 +35775 18380 +48305 18380 +46900 18379 +11605 18378 +31439 18378 +27949 18377 +48337 18369 +23789 18368 +46681 18368 +21086 18368 +43191 18367 +31257 18366 +23733 18366 +39492 18364 +43680 18361 +45839 18358 +47963 18356 +34652 18353 +8206 18352 +42739 18347 +41610 18346 +43559 18346 +44295 18341 +41228 18336 +23156 18336 +43446 18336 +26857 18335 +40908 18335 +45943 18335 +6969 18330 +44719 18329 +43521 18329 +38565 18327 +49666 18324 +46093 18323 +45702 18321 +44659 18315 +40350 18313 +45628 18312 +17418 18309 +46860 18307 +30352 18307 +47512 18307 +48618 18306 +43277 18303 +17881 18301 +38588 18300 +34897 18298 +35350 18293 +31989 18291 +36823 18290 +33131 18289 +39776 18289 +50074 18289 +48602 18286 +40348 18281 +45486 18277 +48414 18276 +47488 18275 +21118 18274 +35513 18271 +45214 18270 +16536 18267 +43468 18267 +27789 18267 +43847 18264 +17425 18262 +41850 18261 +12357 18261 +36954 18258 +50029 18255 +40052 18254 +34773 18253 +14124 18252 +43283 18248 +46478 18248 +48603 18244 +45319 18244 +31255 18241 +48740 18240 +43059 18238 +31671 18236 +38451 18236 +11931 18232 +32216 18224 +47389 18218 +44172 18216 +49033 18214 +32007 18214 +22055 18214 +22592 18212 +44847 18211 +40451 18211 +48892 18209 +41051 18207 +28524 18205 +24511 18205 +30613 18203 +40505 18201 +33142 18200 +45515 18198 +48653 18198 +44375 18197 +13337 18196 +44612 18192 +32203 18188 +17407 18187 +38642 18187 +45256 18185 +48767 18185 +4667 18183 +43665 18182 +48156 18180 +30026 18180 +13161 18180 +37699 18179 +42001 18179 +50052 18177 +28089 18176 +20627 18176 +38508 18171 +9680 18171 +29080 18170 +42635 18169 +42955 18169 +35635 18164 +45157 18162 +33923 18160 +38219 18160 +40287 18158 +42996 18155 +36523 18155 +35251 18152 +8417 18152 +19872 18151 +24704 18150 +23108 18145 +43312 18144 +41963 18142 +23428 18135 +46079 18130 +31793 18124 +45891 18123 +31664 18119 +25723 18118 +17791 18117 +44494 18117 +44305 18116 +29670 18116 +31904 18115 +22851 18114 +38161 18108 +19945 18106 +31305 18105 +31715 18103 +45007 18101 +19743 18100 +17725 18095 +49051 18091 +47582 18090 +43172 18088 +34390 18085 +29550 18084 +48075 18084 +44542 18083 +15493 18083 +47570 18081 +44826 18078 +29746 18077 +32106 18074 +19241 18074 +47274 18070 +37363 18070 +38692 18067 +6012 18067 +47859 18061 +29149 18060 +34097 18059 +27935 18054 +24437 18054 +39961 18049 +48441 18044 +23611 18037 +43243 18037 +41263 18034 +38627 18032 +13072 18031 +43563 18028 +48945 18028 +32315 18026 +26486 18023 +28575 18019 +43239 18018 +35914 18016 +48165 18016 +28095 18011 +42187 18007 +16306 18006 +21015 18005 +41596 18004 +42622 18003 +42312 18003 +43668 17999 +44307 17998 +36804 17997 +47240 17993 +49348 17993 +26388 17987 +5307 17986 +38471 17985 +34167 17985 +34706 17982 +48465 17981 +44694 17977 +30867 17976 +36659 17975 +32208 17975 +32512 17973 +43887 17967 +41235 17966 +44114 17966 +45728 17963 +22467 17962 +49641 17960 +20308 17957 +42237 17956 +39134 17954 +39633 17952 +44743 17949 +38179 17947 +41841 17945 +47896 17934 +49900 17929 +49366 17926 +45523 17919 +39601 17918 +12360 17917 +49803 17910 +32449 17909 +19357 17908 +48054 17902 +31007 17899 +37045 17899 +9097 17898 +47612 17893 +14445 17893 +43098 17891 +40143 17891 +39450 17890 +33429 17888 +41601 17886 +35051 17881 +32649 17881 +49915 17880 +40663 17875 +44887 17874 +47111 17871 +31554 17869 +49875 17868 +19319 17868 +17391 17866 +37994 17865 +37836 17863 +20846 17860 +16870 17859 +27524 17858 +4742 17855 +22469 17855 +47726 17851 +41095 17849 +41732 17849 +46618 17848 +49313 17847 +46914 17846 +24802 17846 +27664 17844 +44543 17843 +39417 17837 +38213 17836 +48556 17831 +22272 17831 +34575 17827 +31761 17827 +21176 17827 +49579 17827 +37152 17825 +30541 17822 +24510 17821 +19816 17821 +22993 17820 +37074 17818 +49234 17818 +43656 17817 +41990 17817 +46440 17815 +49254 17815 +48623 17812 +44253 17811 +48090 17810 +48086 17810 +15311 17810 +37057 17809 +30675 17808 +11827 17808 +44203 17802 +22512 17799 +46888 17798 +44943 17789 +44552 17787 +26446 17786 +47965 17783 +13221 17780 +45938 17780 +11535 17780 +10702 17777 +29519 17777 +35298 17773 +17850 17772 +28906 17768 +44661 17766 +37637 17764 +29917 17764 +1764 17764 +34337 17762 +24290 17761 +22407 17760 +49437 17759 +18243 17757 +28905 17756 +45462 17756 +44532 17754 +49436 17753 +20164 17753 +29857 17748 +18819 17747 +10260 17747 +47152 17738 +46046 17738 +48444 17734 +17177 17733 +37828 17730 +24609 17724 +8760 17719 +39647 17715 +41351 17714 +37288 17714 +48947 17714 +20683 17709 +26055 17708 +45114 17707 +11049 17705 +42676 17704 +43739 17702 +31960 17702 +30233 17702 +42188 17698 +50223 17698 +35838 17697 +44897 17695 +23792 17695 +47758 17692 +12875 17691 +44259 17690 +25683 17688 +43805 17686 +37394 17686 +43046 17681 +49782 17681 +44069 17680 +48047 17675 +43490 17672 +24559 17671 +44020 17670 +23977 17670 +27454 17664 +45616 17663 +28863 17661 +41369 17661 +2463 17659 +29126 17658 +45216 17653 +12443 17647 +20630 17643 +29247 17642 +47731 17641 +43732 17638 +41705 17636 +45825 17635 +47044 17635 +40104 17635 +44169 17634 +25652 17634 +23521 17634 +41793 17633 +35379 17633 +32661 17631 +33108 17629 +44060 17628 +8645 17628 +42322 17623 +39121 17621 +33481 17619 +46371 17616 +43336 17615 +47191 17615 +39090 17610 +34128 17603 +47056 17595 +42084 17595 +40392 17594 +41141 17594 +30226 17592 +27369 17588 +43209 17587 +30329 17585 +2216 17584 +31950 17583 +40839 17583 +32870 17580 +37346 17579 +14911 17577 +35731 17576 +11030 17576 +42782 17576 +11018 17576 +40324 17575 +31336 17575 +37779 17575 +43946 17573 +49856 17572 +45738 17571 +43787 17570 +40260 17567 +34684 17566 +44934 17566 +20971 17565 +50183 17563 +46159 17563 +44673 17562 +24035 17561 +28329 17561 +38744 17560 +40201 17558 +45465 17557 +46267 17556 +39887 17553 +26331 17551 +48236 17546 +42258 17546 +10328 17546 +43605 17545 +39572 17541 +44965 17539 +45670 17534 +43027 17534 +46841 17533 +35909 17532 +30074 17531 +50238 17530 +36252 17522 +49075 17517 +45636 17515 +31310 17514 +46665 17514 +44000 17514 +46519 17510 +39570 17507 +38497 17506 +39437 17505 +38896 17504 +35911 17502 +18538 17502 +39816 17499 +46248 17497 +27020 17497 +47184 17490 +20238 17490 +17614 17490 +40301 17490 +35744 17489 +11981 17488 +43589 17485 +19899 17484 +41094 17483 +46887 17483 +35961 17481 +43625 17479 +46432 17476 +48884 17475 +27480 17474 +44121 17474 +6030 17473 +28321 17469 +43529 17469 +35211 17468 +29123 17468 +2862 17463 +26940 17461 +48555 17460 +43063 17460 +38624 17458 +42488 17457 +42964 17452 +33913 17451 +13303 17450 +18999 17447 +2847 17442 +44973 17441 +29882 17440 +25020 17436 +42131 17434 +45080 17434 +38385 17433 +37592 17423 +43240 17423 +44442 17421 +14913 17419 +37696 17416 +29511 17416 +6671 17416 +49602 17416 +26458 17415 +49703 17414 +21594 17414 +45182 17409 +48818 17406 +14606 17403 +37296 17403 +39491 17397 +41761 17396 +45964 17396 +15082 17393 +33441 17391 +45935 17391 +41376 17388 +42581 17388 +46468 17386 +27374 17386 +40647 17385 +41409 17385 +31098 17383 +41047 17382 +36479 17381 +45648 17380 +841 17379 +20745 17379 +44078 17378 +42965 17378 +17005 17376 +13462 17375 +3591 17374 +42980 17373 +49257 17370 +29078 17370 +23037 17369 +13249 17368 +32895 17367 +50165 17366 +45761 17363 +37174 17360 +25213 17357 +49303 17354 +24866 17353 +36227 17352 +39183 17351 +44153 17345 +39923 17344 +4148 17343 +48926 17343 +18431 17343 +46815 17343 +29150 17341 +43292 17341 +47370 17341 +19295 17335 +19211 17334 +46717 17331 +49211 17330 +48327 17329 +5772 17327 +43994 17322 +19285 17321 +34997 17317 +44764 17317 +24064 17316 +49356 17316 +18471 17316 +33554 17316 +43223 17314 +28780 17314 +19676 17314 +49394 17313 +36191 17312 +4566 17311 +43683 17310 +35881 17310 +42494 17306 +26908 17306 +48552 17305 +43146 17300 +41159 17291 +41700 17290 +48228 17290 +42643 17288 +16750 17287 +13287 17286 +11134 17284 +44329 17284 +41561 17283 +45949 17282 +36352 17281 +38513 17277 +24189 17277 +19768 17271 +37078 17271 +42301 17265 +34667 17256 +35945 17254 +33975 17251 +35157 17251 +47776 17251 +49114 17249 +44077 17245 +42141 17242 +9108 17242 +27187 17240 +14993 17240 +46781 17239 +35625 17238 +48959 17237 +48188 17236 +15522 17235 +24729 17232 +48964 17230 +40733 17229 +33635 17226 +47946 17224 +28425 17218 +31042 17216 +22658 17215 +49525 17213 +32178 17211 +36728 17204 +46807 17203 +28599 17201 +20020 17201 +38679 17198 +2570 17197 +40545 17194 +41455 17194 +47127 17192 +40384 17191 +42703 17191 +42563 17187 +30583 17187 +9244 17187 +26245 17184 +48952 17183 +31686 17181 +34211 17174 +44900 17174 +14817 17166 +32186 17166 +37201 17164 +45659 17161 +25435 17159 +39196 17158 +44980 17157 +38208 17155 +44417 17152 +31993 17147 +47544 17145 +48894 17144 +12220 17144 +37496 17141 +38864 17139 +44489 17133 +30010 17132 +26755 17131 +40202 17130 +27919 17130 +47555 17125 +49730 17120 +46091 17120 +20306 17116 +42978 17116 +47871 17116 +39422 17115 +24196 17109 +2110 17108 +37007 17107 +43514 17105 +44249 17104 +43228 17104 +10221 17104 +26632 17102 +38418 17102 +31401 17102 +46095 17102 +43515 17101 +44528 17101 +46953 17101 +32717 17101 +43687 17097 +50006 17096 +23509 17095 +33528 17092 +45765 17089 +11962 17088 +29544 17087 +30009 17085 +3475 17079 +18547 17077 +30516 17077 +49289 17076 +34090 17073 +31951 17072 +45559 17072 +41644 17071 +44877 17069 +31126 17069 +38972 17069 +50055 17061 +35149 17061 +37883 17060 +37460 17060 +17147 17058 +49189 17057 +44729 17055 +44171 17054 +16593 17053 +49053 17046 +31021 17044 +25551 17044 +37354 17043 +33691 17042 +43619 17041 +46112 17039 +30344 17037 +44183 17037 +33980 17033 +36170 17031 +47603 17028 +43413 17026 +46798 17025 +39061 17021 +41827 17020 +7909 17019 +47672 17015 +40108 17011 +49253 17010 +26439 17004 +48528 17003 +49645 16995 +26419 16995 +49532 16993 +44589 16990 +35745 16989 +44950 16988 +13321 16985 +21237 16981 +40262 16980 +26358 16978 +41867 16977 +42520 16972 +36038 16970 +46114 16970 +50019 16969 +47210 16968 +47036 16967 +46571 16967 +16327 16966 +46542 16965 +3471 16963 +21993 16961 +35743 16958 +48840 16956 +32803 16956 +33704 16956 +31741 16956 +36390 16952 +46877 16947 +24079 16945 +34472 16941 +29273 16940 +15252 16940 +46809 16938 +26560 16938 +5744 16937 +45886 16934 +28322 16933 +41267 16931 +20650 16928 +24428 16927 +22545 16923 +33336 16919 +32381 16917 +39106 16914 +42385 16912 +42820 16907 +44701 16906 +31740 16906 +30910 16906 +30173 16905 +38484 16904 +49459 16904 +22123 16903 +24978 16902 +32428 16902 +21628 16901 +17227 16900 +34600 16896 +20704 16895 +14474 16895 +10774 16892 +44509 16891 +45100 16888 +20204 16886 +42856 16886 +42054 16885 +47641 16884 +40277 16884 +44116 16883 +25606 16883 +38947 16878 +49700 16877 +47539 16877 +48431 16876 +41300 16875 +33202 16874 +14038 16873 +40849 16872 +48262 16871 +46803 16870 +45557 16870 +24443 16869 +47156 16868 +50119 16868 +35330 16862 +37649 16862 +48518 16859 +45467 16851 +33430 16851 +38467 16850 +43807 16849 +39528 16846 +45053 16841 +42946 16841 +47898 16838 +49735 16836 +20181 16836 +15128 16833 +27579 16833 +49768 16833 +32707 16831 +45952 16827 +45666 16824 +4797 16819 +16948 16817 +47360 16816 +40193 16815 +44383 16814 +32264 16805 +22251 16800 +50226 16799 +11076 16795 +34478 16795 +35915 16793 +40602 16791 +41784 16790 +33701 16790 +30817 16790 +46503 16789 +40926 16788 +26584 16786 +40673 16785 +45206 16784 +31644 16776 +43723 16775 +46928 16774 +46303 16773 +40575 16773 +40984 16768 +23251 16767 +45862 16766 +37165 16765 +31830 16762 +44384 16758 +46704 16757 +15356 16757 +36594 16753 +43824 16753 +42253 16751 +27365 16750 +45987 16747 +47907 16745 +38353 16742 +21275 16739 +49669 16738 +49787 16736 +20526 16736 +50242 16733 +25574 16732 +20960 16730 +39765 16728 +17117 16725 +48747 16725 +17932 16724 +47424 16723 +46862 16723 +23750 16723 +40366 16722 +46012 16720 +2212 16720 +43140 16720 +42483 16717 +19423 16717 +43952 16714 +31438 16709 +29828 16708 +41134 16708 +47994 16705 +44647 16704 +29248 16703 +50174 16697 +42600 16696 +37512 16693 +43275 16691 +42672 16689 +49500 16688 +39557 16687 +49087 16686 +31615 16682 +17041 16681 +44030 16677 +46405 16676 +37336 16676 +41563 16676 +36924 16673 +17854 16669 +42313 16668 +49822 16663 +45601 16662 +41872 16660 +18769 16659 +49541 16659 +45902 16657 +49685 16656 +46325 16653 +37797 16651 +43021 16650 +40380 16650 +44207 16647 +37689 16645 +31595 16644 +26984 16641 +32196 16637 +23545 16636 +33135 16631 +40435 16631 +23197 16627 +41103 16626 +34823 16625 +49750 16621 +41723 16620 +45372 16619 +39217 16618 +16466 16613 +42024 16607 +38567 16606 +25932 16605 +41934 16605 +44395 16602 +44741 16599 +10264 16599 +47886 16597 +21785 16597 +49481 16589 +39702 16589 +48820 16588 +39984 16586 +33730 16585 +43937 16580 +25660 16579 +47921 16574 +49784 16574 +49512 16569 +29106 16567 +15960 16565 +25595 16560 +47787 16560 +49733 16560 +45126 16558 +20921 16556 +34008 16551 +28566 16549 +27080 16549 +42053 16546 +41922 16541 +45770 16541 +43615 16539 +11603 16536 +22752 16534 +39852 16533 +45310 16533 +31185 16532 +49718 16531 +44931 16527 +2625 16525 +22288 16524 +45692 16524 +48979 16522 +45508 16522 +31624 16518 +48428 16516 +17617 16514 +30378 16509 +48109 16507 +1876 16507 +46410 16506 +20277 16505 +11180 16502 +33947 16498 +34921 16496 +38734 16494 +46761 16494 +43835 16491 +47846 16487 +975 16486 +24474 16485 +27747 16483 +36452 16482 +48409 16482 +38138 16479 +44780 16475 +44869 16474 +49682 16474 +28958 16469 +49878 16465 +30602 16464 +2819 16462 +47616 16457 +46256 16457 +48365 16455 +32478 16453 +48612 16452 +38140 16451 +44134 16448 +39933 16448 +47849 16446 +28601 16443 +43645 16442 +17883 16436 +34129 16434 +45290 16434 +42557 16432 +11337 16432 +34570 16427 +49294 16424 +950 16420 +49592 16418 +49922 16417 +27053 16415 +42691 16410 +50088 16410 +45766 16409 +48679 16409 +26026 16404 +47548 16403 +44671 16402 +19368 16398 +38827 16394 +42480 16391 +23331 16389 +31836 16388 +38257 16388 +23878 16386 +14194 16385 +46918 16382 +40503 16382 +32044 16381 +24695 16378 +46957 16375 +48098 16375 +42853 16369 +6316 16368 +41511 16367 +49287 16367 +20223 16366 +16780 16365 +37841 16364 +34007 16361 +48839 16360 +5904 16360 +44856 16358 +35648 16358 +49949 16356 +42486 16354 +24117 16354 +34675 16351 +47597 16351 +45500 16350 +37688 16350 +38556 16348 +48530 16348 +27786 16348 +40282 16344 +8382 16343 +40218 16342 +20580 16340 +47503 16338 +24366 16336 +19673 16333 +47580 16330 +29319 16327 +41466 16324 +44152 16322 +44921 16322 +9903 16321 +30617 16319 +32796 16318 +27858 16316 +31387 16316 +49936 16316 +14609 16306 +49055 16305 +33204 16305 +26537 16298 +26382 16296 +47728 16296 +27727 16293 +6137 16291 +49971 16288 +43608 16288 +43686 16287 +33320 16286 +17295 16286 +44422 16285 +16650 16284 +48173 16280 +35758 16279 +47247 16275 +45605 16271 +17976 16266 +45571 16262 +46736 16261 +49943 16260 +50123 16251 +44761 16251 +29487 16250 +42459 16249 +47346 16248 +22380 16246 +8703 16245 +48338 16243 +38806 16242 +15130 16240 +49638 16240 +38195 16237 +45925 16231 +5487 16231 +40962 16226 +19381 16225 +42787 16223 +46511 16221 +29788 16220 +46660 16219 +42416 16219 +35504 16218 +46500 16216 +44778 16214 +46192 16214 +49617 16212 +28505 16210 +49327 16209 +31752 16206 +25122 16206 +50234 16205 +8907 16205 +45506 16201 +36150 16200 +37739 16199 +50014 16198 +45877 16197 +41450 16195 +17307 16193 +22082 16192 +27383 16188 +37491 16187 +29193 16187 +12764 16186 +49307 16186 +44698 16185 +36925 16185 +21312 16184 +28751 16183 +11145 16181 +11956 16179 +41984 16178 +6629 16174 +32657 16174 +33908 16172 +35772 16172 +42060 16170 +24526 16167 +44750 16166 +47155 16165 +42572 16165 +48771 16162 +2294 16161 +38017 16157 +31371 16156 +23858 16156 +46839 16147 +35258 16144 +39077 16143 +30636 16138 +49193 16138 +27722 16138 +6534 16137 +43977 16127 +31404 16126 +37166 16126 +3410 16123 +45439 16122 +19335 16121 +32335 16118 +47192 16116 +29665 16115 +37849 16113 +49614 16108 +37577 16108 +927 16104 +30402 16100 +34661 16100 +26398 16099 +42080 16098 +45362 16097 +8236 16096 +21369 16096 +21145 16095 +36885 16092 +48960 16090 +46393 16090 +1274 16089 +44324 16087 +45701 16086 +45224 16086 +30472 16085 +25282 16084 +49717 16083 +47385 16083 +7871 16081 +45050 16080 +44229 16078 +15117 16076 +33894 16076 +11627 16073 +40019 16073 +2542 16072 +38710 16071 +49218 16071 +37059 16068 +9438 16067 +43252 16067 +46556 16067 +48372 16067 +50068 16065 +40299 16065 +48628 16062 +37540 16062 +41650 16059 +15748 16057 +17889 16055 +19806 16054 +37678 16050 +40353 16050 +6377 16043 +43795 16040 +44132 16040 +41299 16040 +41496 16034 +14203 16034 +32587 16032 +48167 16031 +48655 16030 +40521 16028 +45304 16026 +15044 16021 +35869 16015 +45127 16015 +47467 16015 +40225 16014 +41201 16012 +43199 16011 +33422 16009 +45653 16008 +43128 16008 +28361 16006 +31276 16004 +10446 16003 +21300 16000 +45116 15998 +45909 15997 +41936 15995 +45618 15995 +13461 15995 +27456 15994 +49959 15992 +46342 15991 +44125 15988 +49533 15987 +41932 15984 +32038 15983 +48223 15979 +36568 15973 +46756 15971 +49517 15971 +37925 15969 +29873 15967 +40538 15965 +28795 15963 +33175 15960 +37163 15960 +39701 15957 +20579 15954 +31852 15952 +21498 15952 +9134 15945 +46992 15941 +35684 15941 +44427 15940 +44609 15936 +47860 15935 +47374 15929 +17752 15927 +12474 15923 +35976 15921 +26252 15919 +30143 15918 +2161 15916 +43324 15914 +26314 15912 +22149 15909 +31062 15908 +43438 15908 +40382 15907 +32271 15906 +10412 15906 +47202 15895 +48548 15895 +20817 15892 +50192 15891 +6132 15888 +6791 15886 +34893 15885 +49760 15883 +48717 15882 +46018 15882 +29142 15882 +37774 15881 +25673 15877 +49199 15877 +39285 15876 +31124 15874 +26254 15871 +37640 15870 +20183 15869 +20941 15868 +38819 15868 +43758 15866 +37204 15863 +41513 15859 +17538 15856 +36303 15856 +9736 15854 +44796 15851 +48640 15849 +47567 15849 +14808 15849 +26035 15848 +28951 15836 +7302 15836 +43335 15834 +38659 15834 +27323 15830 +34414 15829 +28475 15828 +43568 15827 +49985 15827 +49659 15825 +45570 15820 +39766 15815 +8750 15815 +30576 15810 +43230 15809 +50187 15806 +25842 15806 +12596 15804 +32351 15804 +26676 15801 +44561 15798 +31152 15798 +31821 15797 +32876 15796 +40970 15796 +34320 15793 +42612 15792 +45804 15787 +46484 15785 +44254 15782 +43776 15780 +13538 15774 +31153 15772 +39182 15771 +44040 15770 +38069 15770 +32610 15769 +45573 15769 +39306 15768 +48896 15766 +36148 15764 +41416 15764 +47634 15763 +32434 15759 +26505 15758 +48691 15756 +42834 15753 +38025 15751 +38498 15750 +35217 15750 +15965 15748 +9147 15747 +32412 15747 +22685 15747 +43421 15746 +14405 15744 +47976 15741 +23192 15740 +42911 15739 +10189 15739 +45453 15739 +23857 15738 +24548 15736 +16362 15736 +40340 15735 +23847 15733 +10506 15733 +48081 15727 +30262 15727 +38770 15726 +30397 15726 +38699 15725 +37838 15725 +48554 15724 +28421 15720 +43643 15720 +15562 15720 +35191 15720 +35486 15719 +2554 15718 +37677 15718 +24476 15718 +42796 15718 +44367 15714 +11539 15713 +48129 15712 +39649 15712 +48980 15712 +16482 15710 +44084 15705 +33715 15702 +20967 15700 +46064 15699 +49373 15699 +37667 15699 +48089 15699 +37182 15698 +41327 15698 +23260 15694 +23937 15693 +29522 15690 +43550 15690 +26171 15685 +27381 15683 +43846 15676 +43585 15675 +31492 15675 +20076 15672 +37926 15672 +39848 15671 +42864 15670 +21637 15665 +9954 15663 +24979 15662 +43502 15662 +37488 15661 +24330 15661 +34572 15659 +43148 15658 +29179 15658 +37744 15657 +43498 15656 +44650 15656 +40298 15655 +31973 15655 +48540 15654 +14623 15654 +50182 15652 +41178 15651 +23029 15650 +43959 15648 +31635 15648 +30324 15646 +44095 15646 +49766 15645 +22825 15642 +49961 15639 +21565 15638 +41009 15637 +8831 15636 +35334 15632 +34083 15628 +47876 15628 +13912 15625 +37564 15623 +42027 15622 +32177 15616 +39515 15612 +41003 15609 +32163 15604 +36739 15604 +49156 15600 +34871 15600 +39346 15595 +6917 15594 +40146 15592 +49141 15591 +32614 15590 +34799 15588 +43390 15587 +48891 15587 +19326 15585 +28028 15584 +31583 15581 +49039 15579 +44774 15578 +39208 15578 +37058 15575 +8596 15570 +13274 15569 +5383 15568 +43155 15566 +38795 15566 +30454 15565 +48161 15564 +33523 15562 +40531 15560 +34736 15559 +42991 15558 +4723 15556 +48587 15555 +45801 15553 +39790 15551 +22071 15546 +40784 15543 +44235 15543 +34117 15542 +45217 15541 +28419 15541 +12358 15538 +32304 15537 +40584 15534 +45305 15532 +49423 15529 +47420 15525 +44124 15519 +41607 15518 +43639 15514 +35814 15512 +43863 15510 +13023 15510 +43884 15508 +49469 15505 +47211 15504 +43938 15504 +11943 15503 +26558 15501 +28897 15501 +36645 15495 +45752 15494 +32257 15492 +50069 15486 +4338 15486 +28000 15481 +45257 15476 +50132 15476 +40100 15476 +39817 15472 +43584 15470 +28777 15468 +20488 15468 +41636 15468 +44370 15466 +45097 15465 +2789 15465 +50095 15463 +38194 15463 +26873 15461 +28418 15460 +34931 15457 +32812 15457 +32633 15456 +19718 15456 +46486 15455 +34160 15445 +28261 15444 +49262 15440 +22856 15432 +26703 15428 +47273 15426 +27435 15426 +16063 15416 +3647 15414 +42401 15414 +47038 15413 +46856 15413 +9884 15412 +13286 15409 +48712 15407 +15667 15406 +38956 15402 +48718 15401 +48290 15400 +38279 15398 +44905 15395 +25853 15395 +37966 15389 +46874 15387 +43045 15386 +46693 15386 +46088 15385 +6114 15383 +23883 15383 +43060 15382 +45295 15382 +41949 15381 +50141 15379 +29748 15376 +28249 15372 +48019 15372 +46926 15368 +43927 15364 +18187 15363 +45219 15363 +35958 15361 +27590 15360 +35948 15359 +40400 15356 +38782 15355 +15019 15348 +45575 15345 +44629 15340 +19983 15339 +34972 15329 +15908 15329 +48970 15323 +6054 15323 +21908 15320 +42528 15318 +39807 15316 +43526 15311 +47359 15311 +22480 15309 +39444 15306 +41829 15304 +39957 15303 +41712 15299 +24045 15299 +33412 15298 +31058 15296 +37600 15294 +41572 15292 +12664 15291 +27532 15290 +32934 15287 +35578 15280 +42987 15279 +46209 15274 +45930 15273 +43637 15271 +41830 15270 +39896 15266 +46970 15263 +49594 15262 +45860 15261 +42891 15260 +45781 15259 +35241 15259 +46048 15257 +23412 15253 +26799 15251 +30068 15248 +43547 15246 +41171 15242 +38743 15241 +24422 15241 +33415 15240 +138 15238 +40373 15237 +46725 15235 +47553 15233 +46319 15233 +39748 15230 +46152 15230 +28985 15230 +30058 15226 +43926 15225 +38973 15224 +16778 15218 +28299 15217 +49823 15215 +29469 15215 +19279 15215 +25475 15210 +8311 15210 +33695 15205 +38711 15205 +38503 15202 +40743 15202 +41426 15201 +32487 15201 +42854 15199 +21341 15199 +29421 15198 +38845 15197 +42318 15194 +16688 15191 +43142 15190 +48800 15188 +6092 15186 +31927 15185 +44884 15185 +21556 15183 +48935 15182 +46162 15181 +36757 15180 +44688 15180 +32347 15178 +48307 15177 +19703 15169 +35614 15169 +44638 15162 +46940 15160 +13711 15159 +49713 15159 +49557 15156 +49757 15156 +21394 15154 +44739 15153 +34210 15152 +39950 15149 +21774 15142 +42121 15141 +18773 15141 +43872 15139 +11629 15138 +47922 15136 +10513 15128 +47789 15124 +23136 15123 +40118 15119 +30133 15118 +22599 15118 +49841 15117 +48627 15115 +47141 15109 +19532 15107 +44328 15104 +46560 15101 +27110 15097 +44890 15096 +45438 15096 +8657 15095 +50239 15094 +27751 15089 +42333 15088 +4617 15087 +44045 15086 +39505 15086 +18234 15086 +45134 15084 +30118 15081 +31776 15081 +42863 15077 +31097 15076 +42456 15075 +48597 15072 +48326 15071 +30988 15070 +48143 15070 +49764 15067 +47927 15065 +32775 15064 +46359 15063 +28248 15062 +5177 15060 +38786 15059 +35718 15059 +47920 15057 +24926 15056 +18958 15054 +39341 15052 +47529 15051 +42007 15051 +43030 15050 +24439 15048 +38607 15046 +43760 15043 +43290 15041 +9748 15039 +23737 15036 +49552 15033 +50049 15032 +23587 15032 +30653 15031 +46838 15029 +41443 15028 +44821 15028 +27363 15024 +33897 15022 +44721 15020 +29664 15020 +40616 15016 +35115 15011 +50254 15011 +21061 15011 +18375 15010 +35187 15010 +42632 15009 +49170 15009 +33594 15008 +22500 15008 +42220 15006 +49005 15002 +41587 15000 +7607 14995 +43440 14988 +43592 14986 +47752 14985 +47588 14983 +8412 14982 +41676 14980 +33033 14980 +15011 14980 +18037 14978 +21812 14975 +26589 14975 +49352 14975 +28920 14969 +37801 14967 +42003 14960 +26236 14957 +45338 14953 +33498 14952 +43817 14948 +39289 14943 +27100 14939 +43454 14939 +46607 14933 +41553 14931 +38419 14930 +42589 14928 +49954 14927 +46498 14926 +39870 14925 +24837 14924 +37449 14924 +49544 14921 +25969 14920 +46528 14919 +39780 14914 +39974 14914 +26209 14911 +27976 14910 +45210 14905 +43826 14905 +45580 14903 +17562 14894 +37977 14893 +36640 14888 +45345 14886 +42092 14885 +18826 14885 +43725 14878 +33944 14877 +30348 14877 +42349 14875 +22666 14874 +34218 14874 +5346 14873 +44237 14871 +40046 14868 +48439 14864 +22003 14861 +44802 14860 +37943 14860 +41919 14860 +45924 14859 +15002 14859 +47464 14858 +33842 14855 +38342 14853 +36235 14851 +35284 14851 +22442 14851 +45820 14851 +33136 14849 +33335 14848 +45718 14847 +38216 14843 +40726 14841 +49988 14840 +47736 14840 +49113 14839 +27 14839 +44734 14839 +25641 14833 +10669 14833 +45489 14830 +42068 14828 +47379 14826 +37162 14818 +44929 14818 +45071 14813 +40475 14806 +16683 14805 +16993 14802 +49336 14801 +29112 14796 +25222 14791 +18891 14789 +48732 14788 +47439 14783 +44037 14783 +44521 14782 +34294 14779 +15888 14778 +15091 14777 +19805 14777 +40646 14773 +37218 14772 +48328 14772 +48635 14771 +34984 14768 +49131 14766 +49800 14766 +41812 14765 +42012 14764 +34900 14764 +41255 14759 +22002 14758 +17212 14745 +25558 14743 +14158 14742 +16214 14739 +4937 14737 +32965 14736 +26323 14735 +46300 14734 +21191 14734 +26859 14727 +39162 14724 +43040 14724 +45079 14722 +11828 14719 +48232 14717 +32588 14713 +5024 14710 +45424 14708 +13947 14707 +18361 14705 +12378 14701 +40655 14698 +28205 14698 +27248 14697 +25443 14697 +16363 14697 +15642 14696 +27039 14695 +40008 14695 +36984 14693 +40576 14692 +38196 14686 +42544 14682 +29161 14680 +30709 14675 +41294 14675 +34909 14673 +48192 14664 +49021 14663 +36921 14662 +46857 14661 +48449 14660 +40411 14658 +50148 14656 +40938 14654 +39276 14653 +41543 14653 +50067 14652 +38661 14651 +34733 14647 +45596 14647 +37702 14640 +26752 14639 +34213 14638 +50228 14637 +46910 14637 +19030 14637 +46770 14636 +37284 14635 +45165 14635 +32198 14635 +19042 14631 +50091 14627 +44469 14619 +35423 14617 +47236 14612 +24465 14611 +46821 14611 +25608 14611 +18874 14608 +7701 14606 +43411 14599 +49463 14595 +42812 14590 +49649 14589 +42909 14585 +48768 14585 +47003 14585 +35384 14583 +29677 14580 +48252 14579 +43617 14579 +30128 14575 +48322 14574 +29644 14570 +17740 14568 +35626 14567 +47733 14567 +38168 14566 +10514 14564 +45574 14561 +16016 14559 +47440 14558 +40884 14555 +48775 14552 +30907 14552 +30619 14550 +4651 14549 +33532 14548 +44690 14546 +2942 14544 +31642 14542 +49092 14535 +41058 14534 +43069 14528 +16926 14527 +41347 14526 +49442 14525 +35400 14524 +49395 14523 +14810 14522 +46480 14519 +32286 14519 +27682 14518 +48810 14514 +49047 14511 +20906 14506 +17126 14505 +47176 14504 +31308 14501 +47121 14499 +42770 14497 +45576 14497 +24744 14497 +47053 14491 +48777 14488 +41508 14488 +49656 14487 +46633 14484 +48888 14483 +29823 14479 +30945 14478 +49049 14476 +47517 14474 +26745 14473 +13738 14470 +30056 14470 +32380 14469 +45426 14465 +27650 14464 +50031 14463 +38112 14461 +11221 14460 +16423 14458 +39662 14456 +33809 14454 +8008 14454 +17956 14453 +33322 14452 +44959 14449 +37898 14447 +33060 14445 +49299 14444 +48615 14441 +48751 14440 +21653 14437 +49497 14436 +8542 14430 +41811 14430 +27651 14428 +34329 14428 +44440 14426 +31746 14426 +39259 14426 +39968 14418 +36624 14417 +49421 14416 +48925 14415 +20317 14415 +46385 14414 +43001 14411 +20142 14409 +15439 14404 +25231 14402 +46876 14399 +46869 14399 +47744 14397 +41823 14393 +30975 14393 +32929 14390 +47719 14389 +41981 14389 +42406 14388 +37888 14387 +49477 14385 +49491 14385 +31849 14381 +3973 14380 +29709 14379 +26927 14379 +37535 14378 +33622 14377 +48132 14377 +48000 14375 +47032 14374 +46489 14373 +26904 14370 +45448 14366 +43448 14362 +31385 14362 +39562 14356 +19194 14355 +42298 14355 +26981 14354 +45431 14353 +44344 14353 +37912 14352 +38933 14349 +9778 14348 +46816 14346 +38532 14345 +33281 14344 +37670 14343 +48168 14340 +48072 14339 +9420 14338 +49540 14334 +27831 14331 +36614 14330 +31885 14329 +42681 14329 +45272 14327 +43496 14326 +41670 14326 +49917 14325 +40312 14322 +41467 14322 +20808 14321 +19199 14319 +24460 14317 +43781 14314 +32431 14312 +45620 14307 +46823 14305 +45473 14302 +48479 14301 +34165 14301 +40728 14300 +29562 14297 +38658 14296 +24886 14293 +32041 14286 +41339 14286 +32279 14283 +44438 14282 +34319 14282 +48942 14280 +10962 14277 +50005 14272 +9488 14271 +46457 14269 +48571 14267 +49815 14265 +39029 14264 +48546 14263 +47323 14263 +36152 14262 +24236 14261 +46558 14259 +27125 14256 +22114 14255 +35666 14253 +31870 14252 +22313 14249 +21964 14248 +31709 14248 +28339 14247 +37044 14245 +45895 14241 +21745 14239 +49359 14239 +19757 14237 +41507 14228 +12166 14226 +27271 14226 +43201 14225 +41988 14224 +28363 14223 +30781 14222 +2464 14222 +25820 14220 +30598 14218 +37056 14215 +13680 14215 +46712 14215 +26335 14214 +30561 14214 +21475 14214 +35009 14214 +30637 14205 +47381 14204 +44762 14203 +40967 14199 +37067 14199 +30708 14197 +46751 14196 +45619 14195 +44640 14194 +38512 14191 +32780 14191 +49072 14188 +41276 14184 +35728 14183 +48254 14179 +36774 14177 +21446 14175 +24331 14175 +21308 14174 +40029 14173 +46645 14173 +18789 14170 +40566 14169 +38199 14167 +42259 14165 +35166 14162 +34084 14159 +39941 14154 +45610 14150 +165 14149 +36934 14148 +29725 14146 +43679 14146 +8427 14140 +50221 14133 +38709 14131 +43464 14130 +41844 14127 +39363 14127 +12210 14126 +36439 14123 +42096 14121 +26616 14119 +11324 14118 +49274 14117 +39066 14116 +44676 14116 +12367 14114 +49538 14106 +49298 14105 +46370 14104 +20939 14099 +17957 14099 +45020 14097 +36422 14094 +24220 14093 +17429 14091 +14689 14090 +16607 14088 +6657 14080 +49605 14078 +47525 14076 +27846 14072 +38538 14071 +38917 14070 +4672 14066 +33676 14066 +45491 14065 +45937 14061 +45688 14060 +37569 14056 +27056 14054 +49892 14052 +46456 14052 +8279 14045 +34636 14045 +9560 14044 +32571 14044 +15249 14037 +39687 14037 +42190 14035 +33804 14031 +39963 14027 +39367 14026 +19986 14025 +45388 14023 +43745 14021 +26032 14019 +38033 14015 +18274 14015 +38414 14014 +46223 14014 +46670 14013 +20258 14008 +24996 14006 +44996 14004 +49937 14000 +11748 13999 +47033 13998 +46588 13997 +25832 13996 +47583 13994 +40189 13994 +25468 13993 +28934 13992 +43058 13989 +31119 13986 +39270 13984 +44540 13982 +49810 13981 +50124 13978 +42977 13977 +48887 13976 +44787 13976 +47743 13976 +38489 13972 +16827 13971 +41181 13966 +45412 13965 +32372 13964 +38474 13962 +11547 13961 +37917 13960 +36532 13959 +8933 13955 +34622 13954 +48785 13953 +25202 13953 +45579 13952 +41725 13952 +41011 13948 +23032 13947 +48270 13943 +47577 13941 +49938 13939 +31322 13937 +39141 13936 +31978 13935 +33210 13924 +13088 13919 +16624 13917 +32269 13912 +33640 13908 +36474 13906 +44007 13905 +5551 13905 +37158 13899 +37280 13898 +45323 13898 +48276 13898 +39546 13896 +25968 13896 +30076 13892 +48905 13890 +50107 13890 +45917 13890 +48208 13889 +31268 13880 +35452 13876 +43447 13876 +48013 13873 +9946 13873 +40216 13869 +43163 13869 +26052 13866 +46200 13866 +17055 13865 +45882 13854 +43954 13852 +36091 13851 +47593 13850 +46380 13849 +35192 13849 +30575 13849 +40443 13849 +28988 13843 +31200 13843 +35099 13841 +29971 13831 +50063 13830 +49923 13830 +29182 13829 +10331 13827 +31319 13827 +17244 13819 +22617 13818 +24923 13814 +49271 13814 +39629 13814 +19721 13809 +39319 13809 +10634 13808 +23459 13803 +36829 13802 +34981 13800 +45920 13800 +49916 13798 +34062 13794 +8409 13787 +24860 13787 +37160 13786 +47011 13785 +28296 13780 +10037 13778 +49903 13775 +46863 13772 +32844 13768 +27685 13767 +35920 13766 +35511 13765 +145 13758 +11797 13757 +26628 13754 +46974 13754 +8817 13753 +42817 13752 +37944 13750 +43402 13746 +24608 13743 +37894 13742 +36007 13741 +29160 13733 +43019 13728 +46224 13728 +23901 13726 +10406 13725 +42056 13723 +45328 13722 +40042 13720 +44279 13716 +26435 13715 +34045 13715 +43591 13715 +9711 13714 +32006 13714 +23633 13713 +3408 13712 +32401 13712 +38610 13709 +45945 13709 +23697 13708 +15235 13707 +16779 13706 +50004 13705 +19937 13704 +50115 13704 +11297 13701 +33361 13699 +33414 13695 +40628 13694 +45086 13692 +47197 13687 +42029 13687 +41568 13686 +16872 13686 +15404 13684 +26184 13682 +33150 13681 +38713 13674 +46003 13672 +31399 13672 +47343 13670 +35957 13666 +40036 13664 +31621 13662 +45884 13657 +45821 13657 +48351 13655 +19046 13655 +39079 13652 +32346 13651 +25188 13650 +48802 13645 +38655 13644 +23504 13643 +9026 13640 +41417 13640 +36848 13639 +26515 13635 +44984 13635 +25844 13634 +49223 13632 +43062 13632 +48340 13632 +23215 13629 +45287 13627 +19599 13624 +50018 13623 +33740 13621 +18185 13617 +35789 13616 +27378 13613 +46181 13611 +49090 13610 +8897 13610 +6585 13602 +17928 13602 +43873 13600 +25467 13600 +22748 13599 +45487 13598 +27576 13596 +18817 13596 +28075 13595 +37675 13593 +47079 13592 +37295 13591 +6526 13591 +45152 13590 +43202 13588 +26612 13584 +39529 13584 +8690 13584 +34352 13583 +8219 13581 +48440 13580 +39366 13578 +42369 13573 +41221 13572 +37369 13571 +43832 13568 +4841 13565 +22747 13562 +34844 13561 +43179 13561 +22031 13560 +45359 13560 +39754 13555 +43364 13555 +49240 13554 +49480 13552 +46716 13548 +30922 13548 +24697 13544 +49931 13543 +4408 13542 +39385 13541 +42295 13541 +22143 13540 +46299 13540 +45669 13540 +47549 13539 +2719 13538 +25716 13537 +16864 13536 +32383 13536 +43785 13534 +23636 13531 +11381 13530 +46597 13529 +41547 13527 +16881 13519 +34680 13519 +19243 13516 +26099 13515 +41452 13512 +33696 13512 +48846 13507 +41277 13501 +42093 13498 +32287 13498 +33216 13492 +39481 13491 +36797 13489 +34469 13489 +18968 13488 +44097 13482 +37441 13477 +48078 13476 +46810 13475 +8973 13475 +48207 13474 +21598 13472 +45361 13470 +38535 13470 +14171 13469 +19153 13469 +40754 13467 +36842 13463 +39494 13460 +27237 13457 +48210 13456 +23988 13456 +49818 13455 +41435 13452 +44394 13451 +27054 13450 +46963 13448 +48435 13448 +26064 13447 +22290 13446 +36537 13443 +40379 13443 +30556 13437 +28570 13437 +42244 13437 +41684 13435 +4208 13434 +4195 13431 +38824 13431 +16665 13427 +40040 13427 +28724 13425 +31106 13416 +34533 13415 +30526 13414 +16701 13413 +34088 13413 +26205 13411 +6002 13408 +45180 13408 +45855 13408 +41887 13405 +23579 13402 +20272 13400 +38729 13396 +46171 13385 +47373 13381 +46328 13377 +49928 13375 +49613 13373 +48317 13373 +28272 13371 +40226 13370 +31584 13369 +48374 13360 +49711 13358 +28093 13356 +25057 13356 +10502 13351 +6627 13351 +49020 13351 +47575 13350 +46713 13349 +25742 13349 +19965 13349 +9227 13348 +45330 13341 +36572 13341 +23784 13339 +43378 13334 +30590 13332 +20783 13329 +40601 13329 +23293 13327 +21063 13325 +18706 13324 +39819 13323 +1003 13321 +46038 13318 +49965 13312 +49203 13308 +43473 13307 +47821 13304 +43541 13303 +43129 13301 +48010 13300 +48770 13297 +27705 13295 +18649 13293 +47269 13291 +47138 13290 +42709 13287 +48445 13286 +31961 13285 +30491 13282 +44855 13281 +22282 13278 +47996 13278 +50098 13277 +31479 13275 +16719 13274 +23132 13270 +28665 13268 +48339 13266 +47811 13266 +5310 13264 +42561 13263 +48042 13262 +49345 13262 +147 13262 +30729 13259 +42460 13251 +17493 13245 +48735 13245 +47637 13240 +10004 13239 +33066 13238 +38389 13238 +45440 13236 +37934 13236 +33235 13234 +36635 13232 +43005 13231 +38064 13230 +33146 13229 +36751 13227 +25934 13226 +46826 13224 +18691 13221 +29391 13218 +12441 13215 +25628 13213 +24191 13212 +19767 13209 +7629 13208 +38144 13198 +36802 13198 +11200 13191 +43121 13190 +11497 13188 +31902 13188 +20344 13188 +45991 13185 +16228 13184 +161 13183 +12837 13182 +24951 13179 +42269 13178 +37654 13177 +40050 13177 +41265 13177 +48282 13175 +19298 13174 +40642 13170 +12638 13168 +47870 13167 +26371 13166 +36484 13163 +39684 13160 +25563 13159 +32937 13155 +35655 13154 +8986 13152 +33942 13148 +46053 13147 +15141 13147 +23898 13146 +34973 13145 +45589 13143 +41419 13141 +15553 13136 +2480 13134 +22916 13132 +48050 13132 +4076 13128 +33703 13125 +32374 13122 +32245 13120 +28835 13119 +44835 13119 +41625 13115 +45149 13114 +41464 13113 +48532 13111 +38861 13107 +43699 13103 +37328 13103 +34215 13102 +8944 13101 +23951 13101 +40177 13101 +17705 13100 +22184 13099 +48104 13096 +38437 13096 +48849 13095 +47161 13092 +47777 13092 +31544 13089 +40989 13088 +46689 13088 +33351 13087 +12541 13087 +38416 13085 +39260 13083 +46522 13080 +14360 13077 +43311 13075 +45322 13074 +29730 13067 +45387 13064 +35428 13063 +15303 13061 +24258 13060 +49998 13057 +36335 13056 +50036 13051 +29678 13051 +3631 13048 +30034 13047 +37638 13042 +48646 13042 +38233 13041 +31562 13040 +45470 13039 +48331 13036 +49569 13036 +41944 13035 +23283 13030 +24529 13028 +38280 13028 +38301 13027 +49881 13026 +49989 13024 +46772 13021 +15168 13021 +50137 13020 +36578 13020 +37471 13019 +35072 13018 +41730 13017 +45915 13017 +40779 13017 +19286 13013 +41616 13009 +47757 13007 +47238 13005 +45923 13005 +30395 13005 +42332 13004 +31315 13004 +17178 12995 +19511 12995 +28710 12993 +42512 12993 +32463 12990 +48502 12989 +10065 12986 +43211 12985 +39972 12981 +15160 12980 +23763 12973 +32822 12969 +50096 12969 +50154 12965 +2109 12963 +42531 12963 +17934 12960 +28216 12955 +44621 12954 +36456 12953 +47264 12952 +33382 12948 +19669 12944 +24223 12944 +9504 12942 +42136 12941 +47321 12941 +16680 12935 +26393 12934 +37368 12931 +24819 12928 +34193 12926 +40522 12925 +49635 12925 +44883 12922 +31249 12921 +38788 12921 +42072 12917 +43756 12917 +40039 12916 +36492 12916 +47622 12914 +34605 12909 +17804 12902 +47231 12899 +49966 12899 +38994 12898 +49812 12897 +38996 12897 +46316 12896 +35542 12894 +24159 12892 +7553 12892 +44445 12891 +31872 12888 +13615 12885 +36420 12882 +9571 12880 +41362 12879 +15384 12878 +38559 12871 +40763 12869 +38395 12867 +32845 12865 +48065 12865 +37559 12857 +29310 12856 +30754 12849 +35111 12849 +36206 12846 +40683 12842 +45946 12842 +36315 12840 +23343 12839 +36416 12839 +39371 12837 +5204 12836 +35596 12834 +31567 12830 +25867 12826 +46802 12825 +49776 12825 +44733 12822 +41022 12817 +48689 12815 +45883 12815 +13739 12808 +43306 12806 +35936 12805 +13410 12799 +45013 12792 +47839 12792 +23725 12789 +17569 12788 +43362 12779 +18771 12775 +32307 12774 +49671 12773 +32768 12769 +32397 12768 +41935 12765 +20907 12764 +35285 12764 +11064 12761 +9816 12761 +49479 12759 +20575 12757 +35487 12754 +36413 12753 +18602 12753 +49814 12752 +45203 12752 +16850 12751 +45885 12748 +34883 12743 +37971 12742 +41689 12741 +47407 12741 +33029 12725 +40951 12722 +47048 12722 +39913 12719 +31461 12717 +39485 12711 +14784 12708 +45815 12705 +37138 12704 +19246 12700 +36010 12698 +48385 12692 +27076 12691 +40533 12687 +43970 12686 +23850 12686 +45849 12683 +42538 12682 +45816 12678 +32505 12678 +49681 12677 +46482 12676 +35832 12676 +46475 12670 +11692 12669 +24477 12669 +47536 12668 +5974 12668 +42585 12660 +20654 12658 +22857 12658 +15776 12658 +33200 12658 +2410 12658 +48021 12656 +12708 12652 +13702 12652 +46817 12650 +50114 12649 +30779 12645 +32999 12644 +40731 12641 +48940 12637 +21065 12636 +23606 12633 +38394 12630 +33737 12624 +28787 12623 +22510 12620 +42147 12620 +48076 12619 +45333 12607 +35619 12606 +48619 12602 +50129 12600 +48752 12597 +6993 12596 +36967 12595 +13490 12594 +44241 12591 +23778 12588 +12102 12587 +13918 12583 +47081 12582 +28353 12581 +19758 12573 +28512 12572 +34236 12569 +42904 12568 +38950 12567 +33222 12564 +34054 12561 +35644 12559 +37122 12559 +44605 12555 +27131 12555 +34197 12550 +39049 12548 +34848 12546 +33244 12542 +25297 12541 +34719 12541 +33090 12541 +16995 12540 +19093 12538 +21886 12538 +46596 12537 +11124 12537 +36543 12536 +49268 12534 +44072 12528 +39571 12527 +15521 12526 +16838 12524 +38829 12522 +23216 12521 +34513 12520 +41270 12518 +46774 12516 +49275 12512 +20860 12511 +15690 12509 +41912 12506 +41509 12505 +8052 12505 +50194 12503 +44814 12502 +32898 12501 +13744 12501 +50056 12499 +38047 12496 +48978 12488 +37715 12487 +16722 12487 +32940 12482 +46740 12481 +20519 12481 +25206 12480 +9746 12476 +41173 12475 +40114 12474 +11213 12463 +37997 12461 +43969 12457 +41659 12454 +21488 12454 +49260 12453 +48033 12452 +47914 12452 +22872 12451 +30670 12449 +25484 12446 +38557 12444 +49343 12443 +32278 12443 +33403 12442 +17737 12442 +5397 12441 +31294 12439 +33268 12437 +43629 12434 +48508 12434 +34507 12433 +26999 12431 +23939 12430 +39758 12429 +50230 12427 +40127 12424 +48353 12423 +43794 12421 +39060 12421 +41500 12418 +29110 12418 +28050 12418 +39442 12415 +46723 12412 +31435 12411 +41030 12404 +13138 12403 +26033 12403 +45859 12400 +13838 12398 +30330 12394 +40371 12393 +19904 12392 +32828 12390 +34517 12390 +32765 12388 +37805 12382 +49360 12382 +25630 12377 +40346 12374 +47125 12368 +49732 12367 +22472 12366 +36836 12365 +21535 12365 +29257 12363 +42390 12362 +9023 12361 +41371 12359 +48919 12359 +27594 12358 +37892 12356 +47858 12354 +43669 12354 +28377 12346 +39719 12342 +49169 12341 +12667 12340 +43696 12338 +47425 12337 +44266 12337 +26462 12336 +49886 12336 +49367 12336 +11310 12334 +48059 12334 +9081 12333 +22614 12333 +42800 12325 +38011 12323 +40002 12323 +30688 12323 +39020 12322 +26144 12322 +41857 12321 +27897 12320 +35448 12317 +39889 12313 +46765 12310 +45063 12310 +12447 12310 +32500 12309 +13846 12306 +22762 12303 +12687 12301 +45383 12300 +40357 12298 +48178 12296 +31959 12296 +15969 12294 +37983 12291 +26125 12288 +44895 12287 +41571 12286 +48533 12279 +39176 12279 +44961 12276 +47087 12275 +21604 12275 +48842 12273 +24606 12268 +48401 12266 +33165 12263 +26709 12263 +35777 12263 +45394 12261 +18226 12257 +28743 12255 +36407 12252 +18299 12251 +43849 12248 +39237 12245 +36372 12244 +44029 12240 +11098 12239 +5835 12238 +38345 12236 +45880 12235 +29465 12235 +49449 12234 +41240 12233 +34024 12232 +42616 12232 +45076 12227 +45947 12227 +49153 12227 +36163 12220 +45482 12220 +17599 12218 +25458 12218 +39969 12211 +4253 12210 +49460 12208 +43205 12208 +39250 12206 +43196 12205 +43659 12204 +33100 12204 +43294 12204 +3569 12202 +41469 12202 +31373 12201 +47315 12199 +41105 12199 +38797 12193 +30547 12192 +28913 12191 +49755 12189 +44804 12188 +46433 12187 +28768 12187 +43519 12186 +6394 12186 +34653 12185 +43752 12183 +33857 12180 +29035 12180 +38857 12179 +40165 12179 +49106 12178 +48859 12177 +19968 12176 +47759 12174 +50218 12172 +48287 12169 +32004 12167 +17001 12167 +47392 12165 +45903 12153 +48224 12153 +39794 12149 +49016 12148 +28904 12147 +42019 12144 +44433 12143 +25568 12143 +38980 12141 +49152 12139 +45959 12135 +22936 12132 +44080 12124 +10020 12124 +48819 12122 +46262 12121 +5971 12113 +39294 12112 +20074 12110 +10739 12110 +4549 12107 +50053 12105 +25973 12105 +38832 12102 +28496 12102 +45904 12101 +45965 12097 +40553 12095 +31313 12095 +49526 12095 +48387 12093 +20556 12092 +47051 12092 +46986 12090 +33559 12086 +34055 12083 +32668 12073 +26018 12072 +8538 12072 +39436 12069 +43992 12068 +33793 12067 +42931 12066 +36261 12064 +24890 12063 +25097 12061 +4880 12061 +39356 12057 +48085 12057 +30431 12053 +35364 12051 +27299 12050 +32558 12050 +4567 12048 +32366 12048 +47617 12047 +32893 12046 +17360 12044 +37265 12042 +42217 12040 +48482 12035 +46771 12034 +31616 12032 +49387 12032 +49724 12031 +47110 12027 +48478 12025 +23705 12022 +33674 12021 +34049 12020 +23047 12017 +13379 12016 +28366 12014 +37516 12011 +27882 12010 +25504 12009 +49977 12008 +42500 12005 +17497 12004 +46971 12001 +26806 12000 +27815 12000 +40337 11998 +42756 11996 +31520 11995 +35751 11995 +49662 11994 +41958 11991 +35100 11991 +50057 11987 +49907 11987 +8240 11987 +47556 11985 +31789 11979 +43634 11977 +43345 11976 +48871 11975 +46920 11972 +47311 11970 +22897 11970 +7828 11969 +39715 11967 +30946 11967 +41048 11967 +15267 11964 +48481 11958 +41691 11956 +14670 11955 +34223 11955 +48251 11953 +45970 11953 +49972 11948 +48048 11948 +46987 11945 +45713 11943 +49664 11940 +25526 11938 +43249 11936 +36493 11934 +30887 11934 +43516 11927 +28169 11926 +34627 11926 +41451 11925 +31040 11924 +18438 11911 +37819 11908 +12084 11907 +30735 11903 +37310 11899 +3419 11898 +34591 11897 +48139 11896 +46024 11895 +3317 11895 +21485 11894 +35928 11894 +42277 11892 +26418 11892 +39746 11891 +27331 11890 +49054 11889 +33641 11889 +49667 11886 +50241 11882 +46205 11882 +40122 11880 +49100 11877 +48779 11876 +31943 11873 +16188 11873 +29124 11866 +44962 11862 +48391 11859 +42945 11853 +27535 11852 +44212 11851 +48758 11849 +39626 11849 +49098 11842 +41389 11836 +47771 11836 +41906 11827 +49826 11824 +44224 11821 +43947 11819 +40824 11817 +7132 11815 +41787 11814 +27738 11813 +23471 11813 +26493 11810 +39991 11808 +5206 11806 +48693 11800 +40866 11799 +43920 11797 +49321 11795 +42839 11794 +47615 11793 +48300 11792 +20568 11791 +47878 11790 +35713 11789 +21353 11788 +17597 11788 +28349 11785 +45656 11784 +33279 11783 +28409 11781 +49238 11781 +38217 11780 +43838 11780 +38673 11778 +37963 11777 +34399 11774 +17331 11774 +49740 11767 +33739 11766 +41697 11763 +6904 11758 +48203 11756 +20253 11755 +22201 11750 +44411 11749 +27490 11747 +38664 11744 +48068 11741 +32068 11740 +48668 11739 +33308 11736 +48616 11735 +47465 11732 +41842 11730 +46768 11729 +21244 11725 +41316 11724 +36137 11724 +47854 11722 +44479 11721 +46686 11721 +46575 11719 +47335 11719 +31312 11718 +46246 11714 +31030 11712 +44899 11712 +41796 11709 +42832 11709 +36687 11706 +15517 11703 +23765 11702 +24919 11700 +47998 11700 +48040 11697 +47088 11694 +48989 11690 +20274 11687 +28185 11687 +42919 11682 +41733 11682 +30203 11676 +21559 11675 +29158 11675 +47080 11675 +11250 11672 +6522 11671 +28400 11671 +22615 11668 +34656 11667 +46276 11656 +28117 11653 +11242 11646 +30025 11645 +47801 11644 +41397 11644 +35392 11644 +50122 11643 +50164 11643 +50244 11642 +35044 11642 +42686 11641 +49947 11640 +46793 11631 +27554 11630 +32580 11629 +36136 11628 +40656 11625 +45599 11624 +39806 11623 +12710 11620 +45380 11619 +11355 11619 +42393 11617 +46569 11614 +14228 11612 +44139 11604 +41502 11602 +40578 11601 +30655 11601 +20310 11595 +42552 11593 +35884 11592 +13877 11591 +49835 11590 +36807 11590 +40512 11589 +37549 11589 +46978 11587 +25034 11585 +40843 11584 +47532 11581 +11116 11577 +47103 11570 +29003 11566 +45065 11564 +44325 11564 +23187 11560 +47278 11560 +37598 11559 +45845 11558 +36631 11557 +41497 11557 +36230 11557 +42230 11556 +47520 11555 +27423 11554 +48507 11553 +47073 11553 +43429 11553 +29666 11552 +45873 11552 +27471 11549 +49205 11549 +41801 11548 +33926 11544 +12286 11544 +43821 11542 +3135 11538 +26377 11537 +37038 11535 +36716 11534 +48851 11533 +42827 11532 +45167 11531 +43750 11531 +17574 11525 +25373 11524 +27708 11524 +50211 11524 +37103 11520 +49210 11517 +44700 11517 +171 11513 +42112 11511 +31217 11511 +46404 11510 +44351 11510 +48394 11510 +25952 11510 +16211 11509 +40945 11507 +24127 11506 +32873 11506 +34398 11504 +35237 11499 +46032 11494 +26559 11490 +48032 11489 +47456 11482 +49502 11480 +25038 11480 +27923 11479 +35763 11479 +33428 11478 +17808 11477 +25896 11476 +34028 11473 +31299 11472 +25166 11471 +35204 11466 +46573 11465 +36409 11463 +49633 11460 +40805 11460 +24491 11459 +32589 11459 +36325 11451 +45793 11448 +26528 11448 +14630 11447 +45611 11443 +37947 11441 +42118 11440 +855 11436 +49405 11434 +36113 11432 +43800 11429 +47514 11425 +49103 11425 +37705 11425 +31948 11425 +18196 11424 +40976 11422 +44558 11421 +26894 11417 +40244 11416 +20789 11414 +35027 11411 +42267 11410 +49027 11408 +25877 11407 +49062 11406 +32866 11404 +32723 11401 +40969 11400 +39359 11398 +35417 11397 +44602 11396 +44933 11396 +45847 11395 +50038 11390 +27683 11389 +23525 11389 +46006 11388 +19729 11386 +24370 11386 +22460 11381 +42323 11379 +46244 11374 +16377 11373 +31013 11369 +40510 11363 +8641 11363 +29590 11360 +25908 11355 +40539 11350 +44342 11347 +25093 11346 +14244 11346 +43797 11346 +30891 11345 +46523 11342 +7345 11339 +25981 11337 +33780 11337 +31034 11337 +49962 11336 +30687 11335 +46483 11334 +32604 11329 +47754 11329 +36501 11328 +48932 11325 +17874 11324 +27754 11322 +17829 11319 +44454 11319 +41821 11317 +34388 11317 +33103 11317 +49534 11316 +18092 11315 +28406 11315 +45710 11311 +50120 11311 +8294 11309 +44982 11306 +49689 11305 +45569 11300 +43506 11298 +19331 11297 +20361 11297 +23900 11294 +45069 11292 +47700 11288 +29245 11284 +29625 11282 +25956 11280 +25196 11279 +10313 11275 +34788 11275 +48907 11271 +42039 11268 +47942 11267 +49773 11266 +47933 11265 +43143 11264 +33257 11259 +23517 11258 +42848 11256 +45686 11254 +47710 11252 +42469 11252 +26921 11250 +45057 11250 +44059 11249 +43917 11247 +44990 11247 +46063 11243 +25552 11240 +32236 11239 +47621 11238 +37405 11237 +50253 11233 +45637 11233 +13170 11233 +15988 11232 +31374 11231 +32503 11230 +38263 11228 +27865 11228 +39504 11224 +42044 11223 +31560 11221 +9129 11216 +34163 11214 +41311 11213 +35539 11213 +38295 11213 +41036 11211 +17903 11208 +50138 11202 +37039 11197 +39461 11196 +14011 11191 +46747 11190 +49585 11189 +22422 11187 +10738 11186 +36216 11185 +35543 11183 +17257 11182 +36287 11182 +21069 11181 +41142 11181 +39396 11177 +46375 11176 +24542 11173 +40204 11173 +35694 11173 +30308 11171 +41603 11170 +37837 11166 +11199 11165 +34978 11165 +45623 11165 +45641 11164 +49371 11164 +18827 11160 +8385 11159 +18001 11159 +44315 11158 +43399 11157 +47954 11157 +41877 11154 +38100 11143 +6410 11140 +45536 11139 +27530 11137 +34368 11131 +19739 11128 +33801 11122 +43535 11121 +36639 11118 +11958 11117 +40605 11110 +40916 11108 +49332 11107 +31317 11100 +31366 11092 +12836 11089 +23872 11088 +39522 11086 +12504 11085 +32157 11084 +49166 11080 +46667 11077 +8184 11072 +14467 11066 +8938 11063 +28054 11063 +16375 11061 +18312 11060 +39010 11060 +30411 11053 +39936 11052 +38470 11052 +34714 11051 +40865 11050 +46830 11048 +34878 11047 +49948 11047 +21359 11047 +30366 11044 +31808 11044 +32854 11044 +32124 11043 +29177 11043 +34971 11042 +42523 11032 +37232 11025 +41899 11024 +29425 11023 +46403 11016 +28015 11014 +47235 11013 +32296 11010 +11309 11010 +33999 11007 +35263 11004 +41163 11003 +42400 11002 +35836 10999 +19714 10998 +30196 10996 +38592 10994 +44248 10994 +2268 10990 +30417 10990 +2359 10988 +45052 10986 +47114 10985 +34729 10982 +46540 10982 +24879 10980 +46576 10979 +20364 10979 +16910 10975 +33288 10966 +27122 10966 +2325 10965 +46015 10963 +20475 10960 +39084 10959 +49365 10958 +41692 10948 +40734 10947 +4748 10946 +35753 10942 +36528 10941 +27744 10941 +13618 10939 +38778 10934 +26932 10934 +47123 10933 +46354 10931 +42751 10929 +33219 10928 +29231 10926 +44023 10925 +46161 10918 +29427 10917 +45117 10917 +13554 10912 +36350 10910 +48889 10910 +36225 10909 +5782 10909 +50121 10907 +31079 10906 +31587 10904 +45307 10903 +29490 10901 +37275 10899 +10237 10892 +42944 10889 +7242 10887 +43595 10886 +41102 10886 +48804 10885 +45771 10885 +31657 10884 +36164 10882 +33225 10882 +23177 10875 +42641 10874 +47371 10873 +36075 10870 +28427 10867 +45104 10863 +46687 10862 +19377 10860 +14229 10860 +23635 10860 +32422 10858 +38104 10858 +34768 10857 +16401 10857 +27301 10856 +46259 10855 +43460 10854 +31529 10853 +15270 10850 +23295 10849 +46931 10847 +29084 10844 +46399 10842 +44401 10840 +25559 10837 +21398 10836 +43649 10835 +48017 10833 +13845 10832 +42126 10830 +41646 10824 +36020 10824 +36055 10822 +4154 10819 +25958 10814 +49017 10813 +29375 10812 +24849 10811 +12117 10811 +27204 10810 +25609 10810 +45021 10809 +44101 10803 +42963 10800 +17035 10799 +32499 10798 +32087 10798 +34189 10797 +135 10793 +41384 10793 +15057 10789 +39426 10789 +22164 10787 +33738 10784 +46490 10778 +41920 10776 +30075 10775 +47368 10775 +47126 10774 +45591 10766 +31458 10763 +18464 10763 +28189 10761 +44713 10761 +36873 10759 +46425 10758 +45745 10755 +38432 10754 +23861 10752 +25233 10750 +39428 10749 +39932 10749 +47831 10748 +22774 10743 +26438 10742 +46153 10741 +27741 10736 +14758 10733 +6677 10731 +16474 10728 +43041 10728 +38517 10727 +43632 10726 +23296 10724 +37297 10724 +47707 10719 +9259 10715 +36835 10714 +17959 10708 +7377 10708 +27295 10707 +25825 10707 +46666 10704 +29812 10702 +48239 10698 +46145 10697 +47293 10695 +35422 10695 +18569 10689 +4644 10688 +20380 10687 +12563 10684 +28463 10683 +32896 10680 +41408 10679 +39892 10679 +34745 10678 +41825 10676 +50002 10672 +44412 10668 +31500 10666 +32053 10665 +24188 10665 +41766 10664 +46453 10663 +37032 10661 +46045 10660 +32977 10660 +28434 10658 +38023 10655 +43076 10652 +23882 10650 +41245 10650 +34145 10649 +42536 10642 +23479 10641 +20761 10641 +24266 10640 +17868 10640 +38993 10639 +27354 10638 +48432 10636 +41713 10636 +13687 10635 +36342 10634 +35317 10626 +34421 10625 +16710 10624 +41331 10623 +21469 10619 +34021 10619 +44484 10617 +45416 10616 +43137 10615 +33205 10613 +48594 10612 +49143 10610 +20362 10610 +49610 10602 +30207 10601 +41355 10599 +18962 10598 +36423 10596 +33095 10596 +26176 10593 +38363 10592 +34811 10591 +33455 10584 +1250 10583 +49958 10580 +45357 10579 +28535 10574 +38969 10572 +39353 10569 +29990 10568 +30163 10565 +46835 10564 +25258 10563 +36381 10562 +19148 10558 +32936 10557 +42104 10546 +48821 10544 +13492 10543 +49107 10541 +40292 10537 +15769 10536 +43327 10535 +46720 10532 +41361 10531 +43522 10530 +42303 10528 +42559 10527 +21136 10526 +49519 10523 +42306 10517 +33727 10515 +40178 10513 +46648 10506 +39948 10506 +11631 10506 +42808 10505 +38910 10502 +40961 10502 +30116 10501 +33581 10497 +40686 10497 +28834 10496 +49993 10495 +38678 10493 +48235 10488 +25617 10486 +30823 10477 +27932 10477 +42233 10470 +13725 10469 +42829 10468 +47504 10466 +13168 10459 +29434 10458 +29824 10457 +31519 10457 +34239 10453 +46812 10449 +45776 10441 +5632 10440 +18331 10439 +16025 10436 +47394 10436 +41831 10435 +43382 10435 +47784 10432 +39499 10431 +16317 10427 +11507 10417 +34957 10416 +28586 10412 +47659 10411 +22684 10404 +38670 10404 +49821 10394 +40937 10392 +48992 10391 +20620 10389 +25561 10382 +6636 10380 +27071 10377 +21399 10377 +32026 10375 +13811 10374 +25599 10374 +11008 10373 +11209 10373 +32574 10369 +47281 10368 +40872 10366 +41986 10363 +17602 10360 +34853 10358 +35653 10357 +47310 10356 +34734 10344 +18980 10343 +31226 10340 +43215 10339 +44944 10339 +41133 10337 +12355 10336 +42902 10336 +23920 10334 +35796 10329 +37311 10325 +44876 10325 +31771 10323 +18766 10320 +17398 10320 +4613 10320 +30815 10319 +26480 10317 +3302 10313 +44356 10312 +9120 10312 +25008 10312 +47800 10311 +46865 10310 +35478 10306 +48169 10298 +25198 10293 +8813 10291 +24541 10286 +25015 10286 +30228 10285 +37908 10284 +48601 10284 +15858 10282 +20452 10281 +7984 10281 +14793 10280 +33767 10277 +41910 10276 +41635 10276 +47179 10274 +16672 10271 +34542 10270 +20166 10266 +38449 10265 +46437 10262 +29836 10260 +29127 10258 +29011 10257 +50094 10255 +41319 10254 +44403 10253 +18888 10250 +36827 10245 +27438 10243 +35811 10240 +20692 10240 +32577 10239 +43358 10235 +38357 10234 +29967 10234 +30532 10233 +48915 10232 +29279 10232 +12099 10231 +38490 10230 +47790 10230 +23650 10228 +40148 10227 +32506 10225 +9125 10219 +43372 10215 +25361 10214 +45268 10210 +32011 10207 +26568 10207 +21297 10203 +42697 10201 +23896 10201 +23813 10198 +39284 10196 +29389 10196 +2729 10196 +43173 10195 +44988 10193 +34651 10188 +9140 10186 +43823 10185 +37867 10182 +43031 10181 +35762 10180 +38785 10177 +42302 10177 +41735 10176 +21708 10173 +19653 10169 +30078 10168 +46543 10167 +46364 10164 +26059 10163 +31262 10163 +44420 10163 +31653 10161 +26489 10159 +48676 10158 +43401 10154 +5578 10151 +37555 10150 +32750 10146 +20696 10142 +37442 10139 +16663 10139 +39884 10139 +40630 10139 +17183 10139 +40119 10138 +28673 10137 +32864 10135 +46445 10134 +49765 10131 +48436 10130 +18557 10129 +22903 10129 +42577 10128 +22708 10127 +33450 10126 +2335 10124 +46334 10122 +36120 10118 +44710 10112 +42219 10112 +39040 10108 +47635 10107 +40783 10103 +35048 10101 +47167 10099 +38955 10099 +19448 10098 +44894 10092 +27488 10091 +33243 10090 +42981 10089 +16848 10088 +39648 10087 +43012 10086 +47262 10086 +21130 10086 +46204 10085 +2639 10084 +45725 10082 +38037 10081 +23712 10080 +34555 10080 +49004 10077 +34175 10075 +23406 10074 +26453 10072 +13567 10072 +49710 10071 +16321 10071 +46934 10067 +36400 10065 +14938 10057 +37786 10056 +33747 10056 +35541 10054 +41510 10052 +47375 10051 +26164 10051 +26259 10049 +27160 10047 +49678 10047 +35203 10045 +45638 10045 +168 10045 +40880 10044 +32986 10034 +32498 10029 +32273 10026 +24052 10025 +50130 10022 +36081 10022 +41880 10020 +48002 10017 +34946 10016 +21970 10012 +8626 10011 +31795 10010 +44187 10010 +48816 10008 +18374 10008 +23828 10007 +48174 10007 +32305 10000 +46178 9992 +49738 9991 +22294 9986 +34362 9978 +31494 9968 +45278 9968 +43530 9966 +136 9966 +38166 9965 +45778 9963 +22227 9962 +50022 9958 +38284 9955 +36652 9953 +39698 9952 +50039 9948 +17904 9947 +46654 9946 +19309 9946 +26952 9939 +38803 9938 +49229 9935 +46148 9934 +8951 9934 +29964 9931 +45018 9929 +35114 9929 +45348 9928 +33526 9925 +44280 9924 +48146 9923 +27467 9915 +44362 9915 +26449 9913 +30579 9913 +24937 9906 +37023 9905 +49450 9900 +46372 9899 +31694 9898 +19081 9895 +40006 9891 +36268 9888 +40082 9885 +42109 9881 +18503 9880 +47636 9878 +48220 9877 +34657 9876 +18491 9874 +18354 9871 +44696 9869 +18324 9868 +31628 9867 +50152 9865 +44347 9865 +38266 9864 +39169 9863 +42985 9861 +22920 9861 +48672 9857 +20778 9853 +28995 9853 +11253 9847 +11208 9846 +48708 9838 +41312 9835 +9522 9833 +24614 9830 +38247 9829 +45740 9829 +31281 9826 +40994 9823 +11893 9823 +38924 9822 +45444 9821 +22399 9821 +43061 9821 +16419 9821 +48510 9820 +25586 9817 +38420 9816 +35416 9816 +46805 9815 +41192 9814 +17447 9808 +48832 9807 +14989 9802 +19628 9802 +32447 9801 +40555 9797 +48605 9795 +14876 9794 +41474 9793 +34588 9791 +49429 9791 +49091 9790 +23124 9790 +4557 9789 +23478 9788 +23274 9785 +28008 9784 +44616 9782 +30358 9779 +49675 9776 +48038 9775 +31646 9775 +33369 9773 +5484 9770 +44287 9768 +3467 9765 +35812 9764 +41952 9761 +38516 9756 +40491 9753 +30763 9751 +25843 9751 +49677 9748 +50044 9746 +42698 9745 +4115 9745 +43601 9743 +32836 9739 +42282 9739 +39213 9738 +34960 9737 +26132 9735 +19598 9734 +30470 9732 +31482 9730 +151 9730 +41897 9727 +42593 9722 +35787 9716 +48551 9715 +50111 9708 +35312 9708 +16496 9705 +35226 9705 +48035 9703 +27092 9702 +28026 9701 +49060 9700 +24108 9700 +26488 9694 +32336 9693 +37741 9690 +37534 9687 +42860 9683 +48899 9682 +39729 9680 +7436 9676 +24874 9675 +49576 9675 +24794 9670 +44519 9670 +49204 9669 +11838 9669 +25105 9669 +42595 9665 +38514 9665 +20134 9664 +47644 9661 +27236 9660 +27016 9659 +33113 9659 +49415 9656 +49705 9654 +25689 9654 +23954 9652 +43467 9650 +47698 9647 +19124 9647 +31197 9645 +24762 9645 +27104 9637 +43263 9635 +44906 9635 +49284 9634 +16174 9628 +34348 9628 +46973 9627 +31324 9625 +20628 9622 +24251 9621 +47376 9619 +10132 9619 +35850 9611 +3531 9609 +32976 9606 +24593 9606 +49283 9604 +41866 9604 +32301 9603 +34100 9603 +37450 9596 +49548 9592 +33392 9591 +22738 9590 +26813 9590 +41682 9588 +38004 9587 +49136 9585 +34067 9585 +19352 9584 +18224 9584 +21180 9583 +31303 9583 +4211 9581 +28798 9580 +45066 9580 +37608 9578 +33460 9578 +32582 9577 +43698 9577 +41485 9572 +1651 9569 +11388 9569 +42448 9559 +39432 9557 +13731 9557 +44378 9555 +35827 9555 +20035 9546 +50061 9542 +5553 9541 +33823 9536 +27954 9533 +45973 9533 +34544 9532 +49616 9532 +46449 9531 +5862 9528 +24445 9526 +31337 9524 +42742 9524 +33959 9520 +46906 9519 +45697 9518 +39876 9515 +43352 9515 +650 9513 +24735 9513 +48662 9510 +43304 9507 +31361 9507 +42138 9505 +46149 9504 +21483 9504 +24858 9499 +43620 9494 +22439 9493 +42579 9492 +19389 9491 +43830 9490 +30073 9489 +43909 9489 +44242 9481 +8238 9481 +27812 9480 +34073 9465 +33049 9460 +46170 9458 +41942 9457 +32983 9456 +24427 9454 +28987 9453 +3295 9452 +48141 9451 +10258 9450 +20878 9448 +16154 9438 +31673 9431 +43767 9430 +42667 9429 +24371 9429 +27691 9426 +49584 9425 +14929 9419 +43111 9417 +30515 9417 +47526 9415 +32248 9411 +7687 9407 +8256 9407 +32778 9406 +47986 9395 +15764 9391 +13976 9391 +37447 9383 +32071 9378 +44393 9376 +18880 9371 +19626 9370 +38072 9364 +13955 9361 +47017 9359 +29845 9358 +2653 9355 +49328 9353 +8446 9351 +36969 9349 +41576 9346 +39639 9345 +18762 9343 +49651 9339 +33614 9336 +9789 9327 +42034 9326 +27981 9326 +40454 9321 +26185 9321 +39433 9321 +28600 9321 +44902 9321 +48703 9319 +49269 9316 +18000 9316 +43505 9316 +18378 9308 +43254 9307 +48011 9307 +30177 9306 +48490 9301 +49215 9301 +42591 9299 +42830 9297 +37541 9296 +35732 9295 +9270 9295 +49022 9292 +22344 9289 +34870 9286 +48175 9285 +35567 9284 +31923 9284 +2015 9283 +36650 9282 +49043 9281 +45708 9279 +17294 9278 +12775 9278 +39587 9278 +24781 9277 +36482 9276 +38501 9276 +44858 9274 +38382 9272 +27387 9267 +33312 9267 +50059 9265 +25007 9265 +37974 9264 +50184 9261 +41176 9260 +48795 9258 +34713 9258 +44746 9256 +45836 9255 +50104 9246 +39581 9245 +11579 9243 +46031 9240 +49793 9240 +30611 9232 +36992 9230 +47060 9225 +25031 9224 +34508 9222 +45595 9218 +48237 9216 +33003 9215 +49160 9213 +45896 9211 +48137 9209 +50037 9208 +43476 9207 +35624 9206 +37497 9204 +39297 9202 +9540 9201 +33873 9198 +49171 9197 +39424 9196 +41156 9191 +20520 9190 +23484 9187 +47502 9187 +29071 9181 +41501 9180 +14079 9179 +45742 9177 +39022 9177 +4926 9172 +31699 9171 +10842 9170 +42821 9169 +40803 9169 +46998 9167 +8669 9167 +27493 9166 +38720 9165 +44079 9164 +16745 9161 +47650 9156 +37781 9153 +27302 9150 +46130 9149 +15167 9143 +49955 9141 +43755 9140 +47605 9138 +47786 9138 +28104 9138 +34257 9136 +37037 9134 +16128 9134 +48780 9133 +48865 9130 +38136 9124 +32988 9120 +45461 9110 +44839 9108 +43594 9107 +48936 9105 +43681 9102 +41937 9096 +47845 9094 +48565 9092 +26513 9086 +9163 9084 +46363 9083 +38694 9081 +47415 9080 +29859 9080 +28432 9080 +14626 9077 +31539 9076 +49361 9072 +37219 9071 +48382 9069 +48713 9067 +24620 9065 +22811 9061 +42930 9061 +43135 9060 +38755 9060 +44975 9058 +44357 9057 +45597 9057 +19302 9057 +39104 9055 +47808 9053 +44788 9050 +29196 9049 +41054 9043 +39445 9042 +37950 9039 +32255 9038 +33954 9036 +44164 9034 +30961 9031 +49333 9031 +45266 9031 +44597 9030 +42532 9027 +23150 9026 +48407 9026 +26805 9026 +32809 9023 +1260 9023 +43301 9022 +48671 9020 +34043 9019 +40998 9017 +30104 9015 +28489 9011 +48163 9005 +49084 9003 +24864 8996 +47250 8993 +40918 8992 +40213 8991 +40342 8989 +31962 8988 +50246 8988 +49539 8986 +33510 8984 +28832 8983 +37591 8983 +50201 8982 +26483 8975 +30951 8972 +31571 8972 +34879 8967 +2020 8966 +10002 8964 +35299 8963 +23031 8960 +10124 8957 +12982 8952 +40061 8951 +32021 8949 +40220 8948 +46261 8948 +44909 8946 +49863 8943 +36702 8942 +32233 8940 +14632 8939 +40921 8939 +33395 8934 +7339 8929 +49545 8927 +39627 8926 +29233 8924 +40729 8923 +31131 8919 +30294 8918 +40436 8917 +28741 8916 +38804 8915 +24567 8913 +30978 8907 +35477 8903 +14694 8902 +30369 8900 +45390 8897 +32515 8895 +21975 8892 +27755 8892 +44687 8891 +41170 8887 +41757 8884 +33278 8883 +37130 8881 +27084 8880 +42567 8877 +50255 8875 +18414 8874 +37875 8874 +38825 8873 +35748 8871 +47035 8868 +26080 8862 +14571 8856 +39031 8848 +30053 8847 +48515 8846 +50171 8845 +37561 8841 +46870 8841 +45267 8841 +37326 8839 +24915 8836 +19929 8832 +21410 8831 +50003 8825 +39050 8825 +31223 8824 +44702 8824 +41374 8822 +37587 8821 +22317 8820 +35411 8817 +24565 8816 +21587 8815 +36965 8813 +49034 8811 +42678 8807 +36609 8804 +48826 8802 +35194 8802 +42033 8801 +33563 8796 +23230 8795 +27090 8794 +47999 8793 +47724 8792 +31484 8791 +49161 8787 +44623 8786 +48599 8783 +30309 8782 +33889 8780 +27077 8778 +43343 8775 +30459 8775 +39583 8773 +4109 8772 +35349 8767 +45410 8766 +29530 8765 +29706 8762 +29568 8760 +44751 8759 +43604 8759 +49065 8759 +30333 8758 +17772 8757 +39657 8756 +35224 8754 +31426 8752 +35450 8752 +22731 8750 +23919 8746 +42597 8744 +38693 8742 +48725 8740 +45893 8737 +32971 8735 +25780 8733 +38949 8732 +46071 8727 +29970 8725 +6418 8719 +7887 8719 +48190 8719 +17312 8717 +10806 8715 +49891 8715 +48951 8715 +17994 8714 +7566 8712 +30178 8712 +49693 8710 +39596 8710 +20652 8707 +47344 8701 +1019 8701 +35636 8699 +15860 8698 +25145 8694 +10555 8692 +2924 8692 +19864 8690 +33491 8690 +48879 8690 +26662 8685 +41152 8683 +16335 8681 +48410 8681 +14373 8679 +48126 8675 +43093 8673 +50110 8672 +33493 8666 +49797 8665 +43940 8665 +8651 8657 +48476 8655 +29238 8652 +28348 8649 +44556 8645 +7682 8639 +40254 8638 +38844 8634 +29609 8634 +37092 8629 +39665 8625 +42781 8624 +26743 8621 +31744 8620 +49715 8619 +29363 8618 +46655 8612 +19120 8612 +6262 8611 +45634 8611 +18974 8611 +16763 8611 +32348 8610 +34171 8608 +16130 8607 +48400 8605 +39401 8603 +28809 8601 +49658 8599 +13525 8596 +10376 8593 +26385 8592 +39075 8592 +41686 8591 +47185 8590 +50252 8589 +40963 8587 +40725 8585 +34381 8584 +46068 8584 +17088 8582 +49133 8582 +13366 8580 +35749 8579 +38582 8578 +40552 8578 +46211 8577 +28128 8577 +21700 8576 +21448 8575 +30866 8574 +40217 8573 +40607 8571 +21746 8568 +17394 8563 +35316 8559 +44529 8557 +6022 8553 +6963 8553 +26169 8553 +32943 8551 +38480 8549 +41652 8548 +37746 8547 +41876 8547 +49543 8543 +41023 8542 +40205 8540 +28495 8537 +35116 8537 +30513 8536 +47806 8536 +35898 8534 +12257 8533 +48877 8532 +43877 8529 +36663 8528 +47497 8527 +37366 8526 +33360 8524 +25215 8520 +37877 8520 +30635 8517 +35986 8511 +29790 8510 +38984 8508 +33346 8506 +31803 8505 +39307 8505 +30039 8502 +17971 8501 +16447 8500 +34363 8499 +30634 8498 +14210 8496 +40166 8494 +20543 8492 +37049 8490 +22222 8489 +1331 8483 +36414 8483 +47511 8483 +48897 8481 +37724 8477 +26177 8476 +47862 8475 +20500 8474 +26627 8472 +47072 8467 +44157 8467 +46059 8466 +50097 8464 +4218 8463 +40746 8463 +29321 8463 +27161 8461 +25387 8458 +47178 8457 +46650 8454 +49785 8448 +43180 8447 +41814 8444 +39274 8443 +39464 8440 +36790 8439 +40172 8438 +38093 8438 +46707 8437 +46555 8435 +29908 8430 +44901 8427 +34500 8423 +44939 8421 +14875 8419 +17452 8413 +35994 8412 +19991 8409 +49221 8409 +49261 8409 +23248 8408 +49876 8407 +42246 8405 +48495 8398 +24146 8397 +28636 8396 +50245 8395 +42372 8393 +31092 8393 +28929 8391 +38958 8386 +28501 8386 +48333 8386 +48923 8385 +41762 8384 +12561 8380 +39051 8380 +34094 8379 +39234 8378 +25676 8376 +44863 8376 +39605 8373 +35566 8372 +18800 8370 +21373 8370 +44873 8370 +29694 8366 +46304 8366 +28642 8363 +38108 8362 +35179 8360 +38401 8359 +39782 8357 +32352 8356 +35886 8354 +18924 8354 +32491 8353 +45979 8351 +43164 8349 +43430 8348 +46915 8346 +39014 8342 +32194 8337 +45258 8333 +35125 8331 +38983 8331 +33194 8330 +37372 8329 +13511 8328 +23377 8325 +31330 8324 +29034 8323 +19793 8321 +34836 8321 +44482 8319 +39218 8310 +38334 8305 +40341 8304 +40239 8300 +27005 8298 +32061 8297 +35313 8296 +27442 8293 +38800 8291 +21564 8291 +35610 8290 +47345 8290 +35252 8287 +47245 8283 +23227 8279 +45464 8278 +34075 8275 +34306 8273 +9237 8272 +40828 8268 +41518 8267 +12190 8261 +33141 8259 +30414 8259 +43219 8259 +46537 8256 +41771 8253 +34777 8249 +39400 8247 +39335 8247 +44669 8246 +45561 8242 +31652 8239 +35900 8238 +40482 8234 +46214 8229 +37181 8227 +34648 8227 +41743 8226 +3358 8225 +33240 8223 +37231 8222 +40952 8221 +17050 8221 +44308 8220 +33722 8217 +13250 8216 +42731 8216 +37253 8215 +34220 8213 +25442 8212 +39228 8208 +3485 8202 +35580 8202 +26469 8202 +19261 8201 +35215 8201 +45236 8200 +41694 8198 +42663 8193 +28196 8190 +19668 8187 +27726 8186 +33313 8184 +13743 8183 +40484 8183 +25817 8179 +42344 8170 +26751 8167 +46104 8163 +21893 8163 +28316 8162 +10621 8158 +46513 8156 +16553 8156 +28859 8156 +44258 8155 +45796 8150 +34367 8149 +14706 8145 +7581 8140 +34913 8140 +46207 8139 +30725 8139 +47217 8136 +32821 8135 +6111 8134 +23119 8133 +639 8131 +39914 8128 +23893 8127 +31979 8123 +2076 8121 +39057 8118 +44837 8116 +47685 8111 +42861 8111 +46135 8109 +40407 8107 +36156 8102 +49031 8099 +49044 8095 +4824 8092 +49316 8091 +43710 8088 +38897 8087 +42383 8085 +2459 8082 +16271 8082 +32125 8082 +22838 8078 +33891 8076 +39227 8075 +21188 8075 +42229 8075 +37659 8075 +41420 8074 +42181 8072 +41873 8070 +19749 8070 +44783 8068 +33497 8068 +30476 8068 +3766 8068 +45270 8067 +42950 8065 +48504 8061 +20722 8060 +41798 8059 +25078 8058 +49648 8058 +26841 8051 +45192 8051 +44606 8051 +40708 8051 +17327 8049 +6722 8048 +47477 8045 +44449 8044 +48087 8042 +29631 8041 +29701 8040 +43546 8039 +37596 8035 +42842 8035 +48121 8035 +28398 8034 +28473 8034 +22519 8033 +35498 8032 +39296 8031 +25811 8029 +40612 8027 +43982 8027 +35479 8027 +29938 8026 +35565 8024 +24021 8022 +44380 8021 +15400 8011 +12977 8010 +23946 8007 +45875 8007 +38544 8003 +35943 8003 +39241 8002 +23620 7999 +38447 7998 +11494 7998 +33615 7996 +36950 7990 +22882 7987 +25601 7986 +34983 7986 +30313 7984 +26362 7983 +19053 7982 +20988 7974 +47723 7974 +47306 7973 +25120 7970 +25668 7969 +46284 7968 +16207 7963 +36211 7959 +27866 7957 +18267 7950 +40550 7947 +35612 7946 +24966 7941 +46084 7939 +35888 7938 +36018 7936 +43436 7935 +16411 7932 +8614 7928 +41620 7925 +38676 7923 +13352 7919 +40374 7915 +19119 7915 +33711 7911 +49413 7910 +25938 7910 +35013 7909 +32594 7909 +42338 7905 +24708 7904 +30108 7902 +31141 7893 +44601 7891 +35937 7886 +48589 7880 +18036 7877 +40079 7877 +46014 7875 +48620 7874 +43689 7874 +46680 7867 +43618 7866 +40483 7866 +31762 7864 +35070 7855 +46203 7850 +44800 7846 +18445 7844 +16124 7841 +47298 7840 +34389 7839 +41032 7838 +20147 7836 +39170 7830 +26437 7828 +48699 7828 +36837 7824 +25513 7823 +38882 7821 +20287 7816 +28480 7814 +15512 7813 +45772 7811 +49864 7811 +47409 7805 +43730 7804 +49578 7802 +47889 7792 +38587 7792 +14763 7790 +49158 7789 +32640 7788 +48890 7773 +38978 7769 +37410 7766 +1606 7765 +38638 7763 +8934 7763 +45532 7762 +32901 7760 +49833 7760 +32981 7759 +24598 7755 +33567 7753 +43655 7745 +39301 7743 +45154 7740 +14575 7736 +26654 7736 +34867 7735 +45081 7734 +44791 7734 +29566 7734 +49467 7732 +29261 7727 +29531 7725 +44567 7725 +34447 7725 +29271 7724 +27732 7723 +46842 7720 +35991 7718 +26072 7715 +32155 7713 +21833 7710 +30027 7709 +29821 7702 +38453 7702 +25537 7701 +38293 7700 +17633 7699 +44196 7698 +43397 7698 +90 7697 +42452 7694 +18718 7694 +476 7692 +50250 7690 +32458 7690 +27245 7689 +49302 7685 +36990 7675 +33377 7672 +35929 7670 +49493 7667 +48844 7664 +38454 7661 +33765 7661 +21121 7659 +33952 7659 +48288 7654 +32888 7654 +44061 7653 +42942 7644 +48762 7640 +44503 7640 +41490 7640 +27261 7638 +24200 7636 +37025 7629 +30608 7627 +46616 7625 +31851 7622 +36899 7622 +25211 7621 +35319 7621 +24640 7619 +27273 7616 +37767 7616 +26201 7613 +36077 7613 +43642 7610 +45681 7608 +29888 7604 +40767 7603 +35574 7602 +34695 7601 +15263 7601 +49930 7600 +17373 7599 +41127 7594 +32875 7594 +37957 7593 +48027 7589 +33574 7585 +41628 7583 +19959 7582 +19256 7580 +25039 7576 +11730 7576 +167 7576 +48494 7574 +30394 7567 +2532 7564 +33249 7562 +37548 7561 +37189 7558 +36868 7554 +38288 7553 +34866 7551 +48836 7547 +37362 7542 +50047 7542 +25831 7540 +49632 7540 +47663 7537 +25354 7537 +15023 7535 +34270 7535 +49279 7534 +38767 7533 +48570 7527 +39103 7526 +29676 7523 +42940 7522 +45746 7519 +41274 7517 +49454 7513 +49942 7509 +46075 7509 +41025 7508 +27419 7507 +24328 7507 +32602 7506 +48549 7505 +11157 7501 +14566 7497 +16813 7496 +37384 7492 +26425 7491 +41681 7490 +38002 7487 +39087 7485 +36008 7484 +8767 7479 +10268 7479 +6879 7477 +50207 7476 +39427 7473 +48561 7472 +44644 7470 +26652 7468 +27421 7467 +20998 7466 +12851 7465 +38391 7464 +49121 7464 +37047 7459 +35244 7454 +36840 7450 +38231 7449 +4857 7443 +25977 7441 +31129 7436 +42455 7436 +40548 7434 +39225 7433 +30328 7432 +12951 7431 +21004 7429 +50126 7425 +30659 7424 +49580 7424 +38415 7423 +36295 7422 +31508 7421 +29668 7414 +11935 7407 +15205 7407 +37065 7406 +26003 7404 +39230 7403 +30281 7401 +41356 7400 +38837 7396 +36500 7394 +16229 7389 +34204 7389 +41206 7388 +38141 7386 +10479 7385 +44920 7382 +34554 7381 +46126 7375 +49970 7373 +30306 7373 +42670 7373 +40842 7370 +26696 7370 +2595 7366 +41341 7365 +44742 7362 +47213 7359 +38143 7359 +45509 7354 +13773 7354 +18806 7352 +6976 7352 +41570 7349 +35255 7348 +32441 7347 +30240 7344 +44374 7340 +39197 7334 +46604 7333 +33161 7330 +12631 7327 +35590 7321 +45282 7319 +34586 7313 +21620 7313 +18408 7311 +21357 7310 +34953 7306 +18161 7306 +49686 7300 +14624 7297 +33383 7296 +15330 7295 +38482 7291 +31272 7290 +34926 7287 +35570 7287 +23958 7286 +44563 7284 +26953 7280 +37365 7279 +49869 7277 +31493 7275 +49492 7273 +24042 7273 +48799 7273 +43892 7267 +48451 7265 +37834 7261 +42296 7260 +28732 7259 +17563 7259 +32771 7256 +7641 7254 +48272 7254 +24259 7253 +7426 7252 +15582 7250 +28923 7247 +37404 7246 +29294 7245 +47133 7244 +40506 7242 +32949 7236 +45898 7234 +41079 7233 +20086 7230 +47516 7229 +36284 7228 +45627 7225 +34048 7224 +13498 7223 +40368 7219 +5881 7218 +37504 7216 +44724 7216 +29006 7215 +46728 7213 +42006 7213 +49572 7209 +49712 7206 +23843 7202 +49008 7201 +26747 7199 +42771 7198 +21215 7195 +41931 7194 +19573 7193 +32105 7192 +49379 7189 +20468 7188 +44679 7182 +37821 7176 +40097 7176 +34947 7176 +28039 7175 +44292 7173 +11861 7172 +25294 7171 +7790 7168 +20740 7167 +25106 7161 +35119 7159 +39156 7156 +39478 7155 +38020 7154 +44812 7152 +42466 7148 +37697 7147 +36648 7145 +46251 7145 +24396 7145 +39861 7142 +27447 7141 +18065 7136 +1054 7134 +25306 7131 +44360 7130 +9833 7126 +48593 7125 +31400 7124 +47937 7123 +48582 7122 +25919 7121 +37139 7120 +37740 7119 +20438 7118 +3680 7114 +41208 7112 +33433 7105 +43894 7104 +28721 7102 +30542 7101 +44387 7094 +16950 7091 +46933 7089 +47585 7088 +43404 7087 +36772 7086 +27477 7084 +33010 7083 +32645 7079 +8243 7078 +41488 7077 +24583 7074 +8700 7067 +47294 7066 +42317 7064 +43827 7063 +30769 7063 +50025 7059 +36822 7058 +48631 7054 +17664 7051 +39881 7050 +49144 7049 +48485 7040 +15742 7040 +19746 7039 +29205 7039 +36883 7037 +45853 7034 +17679 7032 +31755 7030 +36881 7027 +32797 7025 +43878 7022 +42550 7022 +37945 7021 +27958 7021 +26629 7018 +41499 7015 +45166 7003 +45336 7001 +39839 6998 +9770 6994 +44054 6993 +41298 6992 +23493 6991 +31968 6990 +44227 6987 +19312 6987 +8191 6983 +43320 6982 +34379 6981 +49516 6981 +36803 6976 +32550 6976 +44759 6975 +27536 6973 +40139 6971 +36526 6970 +31919 6969 +23228 6968 +49095 6968 +40988 6967 +33357 6966 +22621 6966 +43387 6964 +29492 6964 +18994 6963 +46546 6963 +17733 6963 +43441 6960 +49828 6955 +10773 6955 +2315 6955 +46975 6953 +11477 6951 +46683 6950 +42979 6950 +34455 6948 +36834 6946 +7559 6944 +43456 6943 +49138 6942 +24834 6941 +31590 6941 +19615 6939 +31122 6939 +39902 6938 +46102 6937 +44276 6937 +17043 6937 +26964 6935 +36754 6932 +40331 6931 +39200 6930 +46002 6930 +26062 6926 +41744 6924 +14472 6918 +15380 6916 +41633 6916 +37269 6916 +44991 6916 +18202 6912 +44159 6911 +20026 6910 +31419 6910 +49370 6910 +48124 6909 +29307 6908 +24342 6901 +29223 6893 +29221 6891 +33786 6883 +39458 6882 +50188 6882 +38241 6880 +22585 6876 +3836 6870 +29017 6868 +49562 6865 +28018 6862 +41748 6859 +33349 6859 +49802 6859 +33028 6853 +5970 6851 +40853 6847 +48791 6844 +49709 6842 +14629 6836 +13078 6836 +36607 6834 +38027 6832 +50178 6831 +49176 6830 +43437 6830 +42696 6829 +37674 6827 +31053 6814 +42171 6814 +34242 6813 +49670 6812 +30603 6812 +40478 6812 +36843 6811 +22927 6810 +49422 6806 +43740 6805 +12962 6805 +16776 6802 +18453 6795 +40107 6791 +40397 6791 +22955 6788 +47172 6788 +28745 6781 +38035 6781 +13576 6781 +41862 6779 +12629 6779 +46120 6776 +33684 6775 +10387 6773 +19593 6769 +31815 6763 +46025 6760 +33077 6759 +18615 6759 +17505 6756 +46022 6753 +48567 6753 +14950 6753 +36122 6748 +17922 6745 +18743 6744 +28298 6743 +40091 6743 +32916 6740 +43828 6736 +20684 6732 +16444 6731 +26257 6731 +28100 6730 +8077 6728 +48895 6728 +10166 6727 +13263 6726 +41008 6725 +25947 6725 +35608 6724 +46477 6723 +32184 6722 +36894 6719 +46421 6719 +44591 6717 +25385 6715 +40981 6714 +31442 6712 +48084 6712 +43517 6709 +38899 6709 +43572 6709 +24361 6708 +14126 6708 +30642 6708 +31798 6706 +43614 6705 +21206 6705 +26447 6703 +16951 6700 +47781 6700 +24835 6696 +47117 6693 +40360 6691 +43612 6691 +49790 6689 +20613 6683 +50016 6681 +35645 6676 +41901 6675 +32665 6675 +35750 6670 +32851 6669 +46369 6669 +33485 6669 +38998 6666 +40901 6666 +37436 6663 +38688 6663 +23935 6660 +46077 6658 +19576 6654 +33650 6652 +12904 6652 +15732 6646 +2333 6644 +42310 6644 +45038 6643 +28019 6642 +26152 6638 +35802 6636 +44501 6635 +19209 6633 +16764 6632 +40044 6631 +27619 6630 +41242 6629 +19578 6629 +45685 6627 +15145 6622 +23767 6617 +10623 6615 +37870 6614 +10677 6613 +12095 6612 +31116 6611 +39462 6610 +36733 6608 +43777 6608 +10699 6607 +44819 6602 +4812 6600 +13556 6600 +28101 6595 +42503 6595 +139 6594 +37150 6591 +40920 6590 +35835 6585 +47537 6584 +46610 6583 +31945 6582 +29942 6579 +26599 6578 +23806 6578 +16594 6576 +35630 6574 +45271 6573 +49884 6573 +2358 6572 +18400 6571 +44798 6568 +42481 6559 +42685 6557 +50015 6552 +7113 6550 +31857 6550 +32138 6548 +29347 6548 +48765 6547 +46076 6544 +32429 6542 +49728 6540 +33080 6540 +45869 6534 +17649 6533 +42948 6532 +26663 6526 +48529 6526 +35220 6525 +24388 6525 +16873 6521 +47206 6518 +15973 6517 +47918 6517 +25200 6516 +42135 6516 +46613 6516 +10118 6513 +20602 6509 +10126 6508 +49811 6508 +15341 6508 +25423 6507 +41202 6507 +38095 6500 +28465 6498 +48103 6497 +25163 6496 +46374 6496 +42485 6493 +31358 6492 +45119 6492 +29918 6491 +27856 6489 +40322 6489 +13942 6488 +40914 6488 +25636 6486 +19314 6486 +20689 6485 +13194 6482 +33373 6480 +27024 6480 +35742 6478 +7419 6477 +48852 6477 +49918 6473 +23520 6471 +31436 6468 +6668 6467 +27195 6464 +31809 6462 +16943 6454 +5515 6450 +39841 6448 +47050 6448 +36533 6446 +40059 6446 +37835 6443 +33314 6440 +48954 6439 +41251 6438 +47705 6437 +45337 6437 +14302 6436 +7107 6434 +28820 6430 +40481 6427 +2979 6425 +20863 6424 +44478 6423 +26272 6423 +43975 6421 +10786 6421 +49028 6420 +43331 6419 +44910 6418 +16947 6418 +32113 6417 +24469 6417 +17302 6413 +39788 6411 +47524 6410 +8419 6406 +15583 6402 +48413 6401 +44935 6400 +14279 6399 +46311 6398 +40864 6397 +27956 6396 +41767 6396 +46228 6394 +14823 6393 +25941 6390 +30520 6390 +47116 6389 +44213 6384 +35726 6382 +33333 6381 +31627 6369 +25486 6369 +46850 6354 +37340 6353 +23903 6350 +41591 6349 +40387 6347 +42440 6347 +12453 6343 +36604 6342 +15256 6342 +8892 6339 +40230 6339 +49110 6338 +38835 6337 +8371 6334 +4927 6331 +15103 6329 +49096 6327 +46780 6326 +27634 6324 +49126 6322 +3480 6319 +18853 6318 +46315 6318 +20168 6316 +48493 6316 +38452 6310 +7798 6309 +34000 6309 +35746 6309 +38936 6309 +43020 6308 +33283 6308 +36515 6306 +34674 6305 +49770 6304 +45234 6299 +32485 6298 +6432 6296 +47150 6296 +29027 6295 +28663 6293 +40705 6293 +17203 6292 +48379 6289 +15864 6281 +33410 6279 +47065 6274 +42887 6273 +46253 6271 +29880 6270 +6077 6269 +36133 6259 +41614 6254 +26129 6253 +42797 6249 +40339 6249 +48545 6248 +14061 6247 +30014 6246 +33716 6245 +27745 6244 +42243 6239 +42501 6236 +17739 6232 +13968 6232 +33353 6229 +35283 6229 +27608 6228 +42721 6225 +21053 6213 +32223 6211 +48790 6210 +31915 6208 +45565 6206 +46634 6204 +28698 6204 +21117 6201 +7727 6200 +29356 6199 +13499 6197 +34617 6194 +20557 6192 +45783 6188 +48613 6187 +21496 6186 +28066 6185 +44758 6183 +43749 6182 +39431 6181 +45582 6180 +47852 6177 +33276 6175 +33480 6172 +47242 6165 +29291 6161 +35790 6160 +22961 6160 +8273 6155 +46521 6153 +39707 6151 +43099 6145 +21878 6143 +17224 6141 +31688 6139 +43714 6139 +32555 6131 +47285 6129 +28410 6128 +45977 6128 +25302 6127 +34556 6125 +21106 6123 +1457 6123 +15324 6122 +43641 6122 +8269 6119 +17258 6118 +44336 6117 +45841 6114 +14399 6112 +49045 6108 +40825 6106 +7551 6106 +21330 6102 +24881 6101 +45353 6100 +36046 6096 +34104 6094 +29610 6093 +48468 6092 +22079 6089 +26687 6089 +20301 6086 +16136 6084 +31932 6083 +15118 6079 +48659 6078 +31614 6075 +28497 6075 +49999 6072 +17663 6069 +49563 6068 +48814 6067 +45352 6066 +49780 6065 +28735 6065 +45677 6065 +35381 6065 +34539 6062 +46127 6060 +35460 6054 +50237 6048 +31801 6048 +28813 6047 +28873 6047 +20257 6044 +43036 6041 +26504 6040 +32394 6037 +26522 6033 +49621 6033 +41470 6033 +6624 6031 +23966 6030 +17606 6030 +33365 6029 +45751 6029 +16681 6027 +45833 6026 +13253 6026 +3547 6022 +22360 6015 +46428 6015 +30676 6014 +38727 6014 +26563 6013 +46700 6012 +42784 6011 +25961 6010 +13007 6009 +16906 6008 +33170 6005 +6828 6003 +10310 6002 +37235 6001 +41076 6001 +33299 6000 +32072 5999 +42788 5998 +47625 5993 +32103 5993 +48749 5992 +35955 5991 +36787 5990 +43904 5986 +46840 5981 +16604 5979 +49515 5978 +146 5978 +45529 5976 +6384 5973 +42814 5970 +40640 5969 +32323 5968 +48433 5967 +36346 5966 +46786 5965 +47190 5965 +45901 5963 +35503 5960 +30710 5957 +34280 5952 +46231 5952 +39787 5949 +37656 5946 +38344 5945 +31559 5942 +41394 5941 +25199 5941 +12614 5941 +27520 5937 +16547 5936 +43844 5935 +35302 5932 +43108 5932 +43392 5932 +49277 5931 +31695 5931 +50175 5930 +39792 5926 +38618 5921 +28452 5921 +29800 5921 +46080 5919 +47658 5919 +35843 5919 +39456 5917 +46785 5913 +43368 5913 +46297 5911 +30337 5911 +30894 5908 +47427 5908 +28851 5907 +40890 5903 +15437 5903 +47288 5901 +38103 5900 +43990 5893 +30956 5892 +8864 5892 +18716 5891 +15333 5885 +39286 5884 +14182 5883 +50051 5879 +39919 5878 +42881 5874 +46294 5871 +50144 5870 +37393 5864 +38114 5860 +46144 5857 +33494 5854 +40692 5852 +33476 5849 +44278 5846 +37736 5844 +37573 5835 +23028 5835 +24546 5834 +45430 5834 +33380 5833 +27038 5832 +34350 5825 +41581 5823 +48867 5822 +5477 5818 +14490 5815 +45592 5815 +31502 5814 +44968 5811 +38183 5808 +32706 5808 +42254 5807 +49946 5806 +36732 5806 +28482 5805 +23054 5803 +20331 5799 +26517 5795 +45854 5793 +36343 5792 +20659 5791 +29146 5788 +42133 5781 +39429 5778 +30486 5776 +47255 5775 +44199 5773 +46538 5773 +39938 5772 +26801 5771 +49485 5768 +43198 5766 +48789 5765 +37725 5763 +18114 5762 +24954 5762 +39888 5760 +27097 5756 +26604 5753 +8911 5748 +48034 5745 +14369 5744 +13173 5744 +31859 5743 +47173 5739 +30543 5737 +24321 5735 +24840 5735 +23869 5735 +8552 5733 +33245 5732 +10541 5730 +46599 5729 +47471 5729 +36727 5726 +35628 5723 +5218 5721 +28644 5720 +45608 5714 +150 5711 +46219 5710 +47522 5708 +40632 5705 +30854 5700 +46383 5698 +41358 5696 +29515 5693 +48941 5693 +27553 5692 +27072 5684 +42098 5683 +30003 5682 +27915 5682 +12730 5675 +41057 5675 +32345 5672 +26495 5672 +42419 5669 +44566 5669 +48902 5665 +37672 5658 +37942 5658 +24243 5657 +48536 5654 +33853 5652 +27148 5649 +34227 5647 +32978 5645 +17844 5643 +40874 5642 +37865 5642 +37960 5637 +23252 5636 +12895 5636 +22027 5635 +31391 5631 +44270 5628 +18709 5628 +36341 5624 +49687 5624 +39908 5623 +49691 5619 +44596 5615 +9933 5614 +21665 5613 +41667 5613 +37770 5612 +29121 5608 +40653 5605 +20946 5602 +24912 5601 +42014 5596 +18439 5596 +21789 5592 +49494 5588 +49406 5588 +35977 5585 +36064 5580 +8572 5578 +45912 5578 +36147 5575 +30474 5573 +43532 5573 +49081 5572 +45198 5572 +41915 5568 +35320 5566 +4026 5566 +26848 5565 +22915 5564 +46748 5562 +47834 5560 +37418 5560 +42975 5559 +34198 5558 +40925 5558 +47730 5555 +48838 5555 +31205 5555 +9898 5552 +44319 5551 +26621 5550 +31396 5550 +28561 5544 +35738 5539 +29513 5538 +32833 5537 +41317 5536 +47454 5530 +18203 5530 +26416 5529 +13236 5527 +27389 5527 +47772 5527 +25753 5523 +19380 5521 +13074 5520 +39575 5519 +36027 5517 +33815 5516 +26109 5515 +36198 5513 +46710 5511 +16743 5510 +31626 5508 +50177 5508 +25554 5506 +24524 5502 +43925 5500 +46727 5499 +30698 5492 +31971 5491 +13305 5490 +1824 5490 +28861 5489 +42182 5483 +15239 5483 +36347 5483 +17576 5482 +44709 5479 +13930 5478 +34042 5475 +28914 5475 +10789 5474 +47419 5471 +42809 5470 +31441 5469 +34634 5461 +4945 5454 +50248 5452 +8360 5450 +38113 5446 +24333 5446 +47357 5445 +50092 5443 +23010 5440 +47402 5436 +27694 5433 +27193 5433 +29320 5432 +30892 5424 +32635 5424 +33582 5421 +27313 5420 +40164 5418 +47960 5415 +2515 5412 +46639 5411 +46510 5406 +23599 5406 +26287 5405 +35676 5403 +26858 5403 +25901 5403 +46183 5402 +41622 5396 +21149 5391 +13890 5388 +38270 5386 +10894 5385 +35575 5382 +46566 5379 +28956 5379 +3204 5377 +42031 5374 +27031 5374 +20180 5371 +46085 5368 +35393 5368 +8293 5368 +49357 5367 +49239 5367 +43406 5361 +38615 5361 +13149 5359 +40710 5358 +45201 5355 +46452 5353 +30934 5353 +43085 5352 +23416 5351 +30493 5347 +33634 5345 +42036 5343 +22468 5341 +31253 5340 +36204 5339 +14387 5339 +24426 5328 +45530 5326 +44831 5324 +42114 5324 +44225 5322 +48562 5320 +30156 5320 +40759 5319 +49057 5318 +42895 5316 +11921 5308 +29672 5307 +48652 5306 +44531 5306 +34924 5306 +9602 5304 +44604 5303 +9924 5301 +16478 5301 +9350 5300 +40546 5298 +45417 5293 +33092 5292 +50125 5292 +46360 5289 +4358 5288 +25624 5288 +49574 5285 +30230 5282 +28614 5280 +40627 5277 +28122 5274 +28268 5272 +7131 5270 +46897 5270 +38032 5269 +29302 5268 +44515 5267 +23391 5265 +35780 5263 +47783 5263 +44156 5262 +14168 5262 +43651 5260 +36428 5260 +2578 5254 +29945 5251 +27830 5246 +24378 5244 +33855 5244 +25454 5237 +39007 5235 +42547 5232 +45133 5230 +41995 5230 +10615 5229 +45647 5227 +23969 5223 +13233 5221 +46455 5221 +15036 5220 +26357 5219 +34769 5215 +44859 5214 +39407 5210 +36632 5210 +47911 5209 +30345 5209 +32465 5207 +26870 5203 +26828 5198 +35895 5196 +31711 5189 +37855 5187 +47892 5187 +46177 5186 +34442 5182 +43866 5179 +33898 5173 +45300 5166 +50157 5165 +20837 5165 +38948 5164 +3239 5161 +29934 5159 +17495 5158 +48657 5151 +40232 5150 +21656 5150 +23793 5148 +24015 5148 +18925 5145 +30581 5144 +45941 5139 +45285 5137 +33762 5136 +31898 5135 +34877 5134 +49742 5134 +44727 5131 +35781 5131 +24516 5130 +38518 5127 +46911 5120 +24364 5117 +42507 5115 +44296 5114 +29660 5112 +11924 5111 +12485 5111 +11788 5107 +49702 5105 +44562 5104 +45140 5102 +27925 5098 +31659 5097 +7203 5095 +30218 5094 +19016 5093 +39934 5090 +2500 5088 +19763 5086 +17056 5084 +42588 5081 +16107 5081 +40577 5080 +5320 5080 +22077 5078 +33172 5073 +21413 5071 +34371 5071 +44683 5064 +48473 5061 +20231 5059 +9881 5059 +46367 5058 +23314 5057 +23758 5057 +25444 5055 +36487 5054 +39668 5053 +49140 5051 +43054 5049 +15924 5048 +14978 5048 +46384 5048 +12859 5046 +46037 5045 +35913 5044 +49451 5039 +40009 5037 +42042 5035 +36125 5033 +15782 5032 +45547 5031 +27586 5030 +44451 5029 +28653 5024 +46329 5022 +48278 5022 +44086 5022 +27448 5020 +9315 5020 +26802 5019 +18559 5018 +27282 5017 +1880 5016 +39219 5012 +6349 5012 +32091 5011 +44330 5011 +38799 5007 +19160 5006 +15966 5006 +16372 5005 +8029 5002 +16358 5002 +21351 5000 +24515 5000 +46808 4995 +18097 4995 +42901 4993 +31127 4993 +16671 4992 +28839 4990 +26365 4989 +17964 4980 +21800 4977 +49444 4977 +41908 4974 +26737 4973 +43869 4973 +47763 4972 +6560 4971 +15848 4971 +40809 4967 +35346 4966 +19722 4963 +20701 4963 +43260 4962 +19563 4961 +48267 4957 +33825 4956 +45368 4952 +23838 4947 +44032 4945 +37124 4945 +13371 4943 +41296 4941 +39551 4941 +32096 4940 +43661 4939 +26294 4937 +49912 4936 +40480 4935 +26163 4935 +14605 4934 +38715 4933 +14749 4932 +38197 4930 +33054 4929 +48477 4928 +40083 4926 +21906 4926 +31611 4925 +47639 4924 +22880 4923 +22369 4920 +41848 4919 +47020 4919 +33129 4918 +11239 4916 +28935 4914 +25757 4914 +38566 4909 +17595 4908 +48738 4908 +33132 4906 +48948 4904 +43810 4899 +39455 4896 +30589 4895 +10791 4891 +41387 4891 +28258 4888 +28508 4885 +16580 4884 +20891 4884 +22646 4883 +22400 4882 +33734 4881 +35170 4880 +14910 4878 +30016 4876 +17097 4874 +17861 4871 +47466 4869 +29352 4869 +11995 4868 +37120 4866 +3784 4861 +21465 4860 +43418 4857 +46514 4855 +24455 4849 +45101 4845 +23686 4845 +25391 4844 +45403 4843 +21231 4842 +39650 4840 +43762 4835 +39559 4834 +45175 4834 +45243 4832 +31811 4832 +48191 4832 +38821 4827 +6222 4824 +47333 4817 +19109 4816 +46047 4814 +46615 4810 +40281 4810 +13442 4805 +27772 4801 +43660 4798 +30150 4796 +31382 4792 +33248 4790 +41411 4789 +32966 4772 +47025 4769 +17491 4769 +36982 4766 +44231 4764 +35236 4764 +46111 4757 +27566 4749 +15865 4747 +20369 4746 +33744 4743 +29639 4741 +31425 4739 +30001 4736 +38521 4736 +25101 4734 +42995 4733 +46602 4733 +49094 4730 +25169 4730 +33196 4728 +43167 4726 +44120 4725 +42384 4723 +21962 4717 +17143 4715 +8285 4712 +41424 4712 +44239 4711 +41233 4710 +10267 4710 +41446 4706 +24201 4703 +40133 4701 +16040 4699 +14631 4699 +42553 4698 +5192 4698 +1189 4696 +32608 4696 +6009 4695 +4368 4694 +45299 4694 +39555 4694 +18932 4693 +36476 4690 +40347 4690 +19031 4690 +33234 4689 +42223 4687 +41097 4682 +43118 4679 +40850 4679 +9169 4676 +40651 4676 +33518 4672 +46995 4665 +39622 4665 +49475 4665 +30071 4664 +48301 4663 +43377 4661 +43628 4659 +13361 4659 +40258 4652 +43258 4650 +6354 4648 +37712 4643 +39833 4643 +4183 4642 +28228 4637 +36504 4625 +19801 4622 +43471 4621 +20885 4619 +46659 4617 +42711 4616 +43194 4615 +48056 4613 +49438 4612 +45729 4612 +32101 4609 +33766 4608 +22552 4600 +26572 4600 +40402 4599 +20593 4596 +45914 4596 +37214 4596 +34749 4596 +24908 4594 +40799 4591 +23646 4587 +10353 4587 +20574 4587 +35779 4584 +23814 4582 +16254 4577 +36471 4576 +49604 4576 +41205 4576 +22015 4569 +44190 4568 +23821 4562 +32356 4561 +21109 4559 +20898 4559 +48538 4557 +42477 4556 +46155 4554 +29868 4552 +35442 4551 +48131 4549 +34562 4549 +41359 4548 +49788 4545 +33152 4545 +47109 4545 +16497 4544 +50200 4541 +10895 4538 +34149 4537 +19778 4535 +38365 4533 +48860 4532 +41966 4527 +24179 4525 +29507 4523 +33789 4522 +30736 4518 +33951 4515 +26865 4514 +25249 4512 +34293 4511 +19212 4511 +46021 4511 +31718 4510 +20688 4508 +27286 4506 +10103 4504 +40668 4500 +21575 4496 +44425 4496 +30388 4495 +15944 4494 +46824 4493 +33772 4488 +48682 4488 +19871 4486 +48885 4485 +38941 4483 +14116 4480 +22866 4478 +15414 4474 +9523 4473 +36942 4473 +45035 4467 +38110 4466 +35952 4462 +14224 4460 +46722 4459 +44850 4457 +3479 4456 +37273 4454 +19724 4453 +27955 4452 +35414 4450 +37155 4448 +43815 4447 +25461 4442 +46955 4442 +19359 4441 +33406 4439 +39347 4438 +32023 4436 +44538 4432 +7453 4430 +24517 4429 +31871 4427 +33661 4427 +34577 4425 +6038 4424 +48142 4424 +49646 4420 +30535 4418 +7098 4416 +34496 4414 +11306 4414 +46343 4413 +36571 4413 +36320 4410 +49511 4405 +3462 4404 +28266 4402 +29428 4401 +35632 4399 +17440 4399 +18847 4398 +42822 4397 +44642 4394 +33717 4392 +20360 4391 +43008 4391 +24214 4390 +36084 4386 +9625 4383 +50118 4383 +43597 4375 +49217 4375 +29323 4373 +38644 4373 +37773 4373 +47598 4368 +37012 4366 +44191 4366 +38148 4365 +36387 4363 +3749 4362 +17474 4358 +41185 4356 +47473 4347 +35741 4345 +36510 4334 +44166 4331 +17236 4329 +44409 4328 +15038 4327 +23795 4324 +38215 4320 +166 4320 +48003 4312 +36613 4307 +28961 4305 +16368 4304 +40247 4303 +38399 4300 +28712 4296 +50204 4290 +31680 4288 +37188 4287 +26545 4287 +33274 4285 +42432 4285 +45675 4282 +33678 4281 +32086 4278 +20015 4278 +23002 4278 +46217 4273 +39945 4272 +38564 4271 +13994 4270 +35813 4268 +37815 4268 +14459 4267 +38274 4267 +20129 4266 +44613 4262 +28376 4261 +11093 4255 +29720 4253 +48875 4252 +42359 4250 +28074 4242 +49347 4241 +37500 4240 +50109 4233 +18919 4232 +47935 4230 +30540 4229 +8193 4226 +24586 4223 +37766 4218 +23735 4218 +42903 4217 +46775 4217 +36117 4216 +29736 4214 +46733 4213 +39582 4209 +38043 4209 +7969 4208 +33968 4204 +18074 4203 +31895 4202 +32603 4199 +46320 4199 +14621 4196 +33062 4195 +14844 4194 +36911 4191 +3821 4190 +7678 4187 +27358 4187 +27050 4184 +3880 4183 +34795 4181 +38891 4180 +49751 4180 +38499 4172 +5435 4165 +4770 4165 +20826 4164 +8809 4163 +43316 4158 +49749 4155 +49531 4153 +9462 4149 +36781 4149 +32419 4147 +45077 4143 +43790 4135 +10168 4132 +34303 4132 +37351 4130 +28119 4129 +37148 4129 +11709 4128 +9152 4127 +42059 4126 +4256 4126 +43721 4126 +43270 4125 +38038 4124 +26639 4122 +32065 4121 +32495 4121 +49222 4120 +5754 4120 +30221 4120 +37920 4117 +28252 4117 +28474 4117 +45988 4115 +33321 4108 +41020 4108 +28333 4101 +25538 4097 +29453 4092 +44808 4089 +48608 4083 +42197 4083 +22773 4079 +10558 4077 +43654 4076 +29064 4075 +39223 4067 +41982 4067 +48082 4063 +34457 4061 +43094 4059 +38641 4059 +37344 4059 +30998 4058 +31069 4054 +9547 4052 +39275 4051 +25267 4049 +43987 4048 +48625 4045 +21945 4042 +26111 4042 +9783 4039 +10777 4037 +36259 4031 +28147 4031 +40203 4026 +41940 4026 +8594 4023 +50149 4023 +30564 4020 +45367 4020 +30950 4020 +22885 4018 +37655 4017 +38790 4017 +49041 4011 +28769 4011 +46672 4010 +44707 4010 +43525 4003 +44898 4001 +25576 4000 +36558 3996 +1832 3995 +47252 3991 +31775 3988 +49836 3987 +15005 3984 +24036 3984 +43384 3983 +3658 3983 +28428 3981 +15575 3978 +34635 3974 +45242 3974 +131 3972 +41781 3971 +36291 3969 +43233 3968 +33606 3968 +32032 3962 +11183 3962 +47924 3961 +28373 3959 +34703 3956 +40637 3956 +38815 3955 +37250 3953 +32252 3953 +42166 3952 +26317 3951 +19083 3950 +33236 3947 +49061 3946 +48558 3946 +32782 3945 +38640 3944 +19076 3943 +47823 3942 +34764 3938 +36598 3936 +24564 3934 +19275 3934 +22719 3934 +4412 3932 +32634 3931 +36770 3930 +46430 3929 +23772 3927 +34168 3927 +15179 3925 +49899 3924 +26396 3922 +46697 3922 +28789 3919 +1253 3918 +35767 3913 +45205 3912 +35967 3911 +41560 3910 +11452 3910 +44592 3909 +39266 3908 +24941 3907 +22522 3905 +16844 3905 +49128 3904 +48447 3902 +33501 3899 +30952 3899 +43895 3892 +26214 3890 +29230 3888 +7304 3887 +30326 3881 +12103 3881 +45027 3878 +37022 3877 +41671 3877 +39069 3875 +25255 3869 +46100 3868 +38807 3866 +30672 3863 +42592 3858 +47113 3856 +10263 3855 +22683 3855 +42009 3854 +49501 3854 +18401 3853 +41609 3850 +47638 3849 +26180 3847 +6353 3846 +39126 3846 +47365 3842 +44946 3839 +23803 3837 +8816 3836 +38491 3834 +41741 3824 +38855 3824 +18498 3824 +44028 3823 +27933 3819 +15322 3818 +40211 3816 +36616 3816 +45835 3815 +40034 3815 +32147 3814 +33800 3813 +28766 3808 +32169 3808 +25637 3808 +34148 3808 +2783 3804 +47798 3803 +42539 3801 +28338 3801 +31909 3799 +41482 3798 +19622 3798 +2827 3797 +18270 3793 +38874 3793 +45254 3792 +3273 3789 +41026 3789 +28404 3788 +37713 3787 +28611 3787 +38417 3783 +19776 3780 +10024 3778 +36463 3777 +5619 3776 +48754 3775 +32846 3774 +33486 3769 +26344 3769 +8912 3768 +33176 3767 +36850 3766 +45700 3762 +46220 3762 +48330 3758 +41989 3758 +44458 3757 +22170 3755 +41219 3754 +49926 3754 +29486 3749 +49151 3746 +17518 3746 +31929 3746 +44223 3744 +45684 3742 +30871 3741 +49908 3741 +29870 3740 +33796 3739 +26367 3736 +12208 3731 +36258 3730 +47279 3726 +19449 3720 +49933 3718 +23241 3713 +28622 3712 +10367 3711 +35395 3711 +35178 3708 +46799 3708 +10929 3708 +38637 3705 +31696 3702 +21849 3701 +30609 3698 +47071 3697 +48181 3696 +42473 3696 +41104 3694 +17256 3692 +18610 3691 +13757 3690 +49256 3687 +41552 3684 +15466 3678 +12351 3676 +46182 3675 +49560 3674 +37403 3673 +22929 3670 +43087 3664 +35791 3664 +37146 3661 +8935 3660 +34999 3660 +16301 3659 +43782 3657 +39967 3657 +18167 3656 +30265 3655 +18172 3655 +46676 3655 +31954 3651 +39345 3650 +37647 3650 +38663 3646 +32685 3642 +41162 3640 +46358 3633 +41000 3632 +23877 3631 +36674 3631 +42195 3624 +44747 3622 +48547 3622 +49849 3620 +39825 3619 +26037 3618 +26440 3616 +22810 3615 +37510 3614 +28883 3613 +43582 3611 +19754 3611 +23114 3607 +38601 3607 +45037 3602 +37017 3602 +33547 3600 +44435 3597 +47718 3593 +29046 3591 +47815 3591 +45798 3591 +32830 3590 +12145 3589 +28222 3589 +31410 3589 +39849 3587 +38296 3587 +37477 3587 +13751 3586 +40517 3586 +36977 3585 +10046 3583 +26060 3578 +48310 3574 +47348 3574 +42180 3574 +26198 3568 +27614 3567 +44318 3566 +33439 3564 +42840 3563 +41392 3562 +33539 3561 +33714 3560 +19488 3560 +50145 3558 +18717 3557 +24335 3556 +43907 3554 +17386 3554 +35279 3553 +40106 3546 +24741 3545 +36124 3545 +45890 3545 +35620 3544 +23826 3544 +44706 3541 +29085 3541 +47531 3538 +49388 3537 +34445 3530 +19618 3527 +28312 3525 +38481 3523 +42652 3522 +5649 3522 +2660 3518 +41512 3514 +36623 3510 +31417 3510 +17125 3510 +36436 3505 +26656 3504 +25205 3500 +33087 3498 +41055 3498 +46701 3497 +19557 3497 +14815 3495 +32070 3495 +27908 3490 +18337 3490 +4707 3490 +20336 3487 +26638 3487 +44464 3485 +36542 3482 +7555 3476 +43271 3474 +15109 3473 +48319 3470 +37996 3469 +39815 3468 +40025 3467 +39590 3466 +46326 3461 +39531 3459 +23513 3459 +37187 3458 +49139 3457 +39470 3456 +11430 3455 +3390 3454 +49794 3453 +45809 3452 +49026 3452 +5196 3451 +33637 3450 +48686 3449 +40832 3449 +10493 3448 +21677 3448 +26193 3448 +33931 3447 +43319 3447 +35770 3442 +46912 3442 +30331 3437 +20275 3437 +36851 3436 +35347 3436 +47026 3435 +46893 3435 +44267 3433 +29435 3432 +34248 3430 +46143 3430 +37077 3427 +33293 3425 +47322 3422 +47361 3419 +43158 3416 +43160 3413 +37481 3410 +36037 3409 +41090 3409 +41506 3408 +43477 3407 +40709 3406 +38841 3404 +35974 3403 +22492 3403 +18249 3400 +30448 3400 +10587 3398 +47209 3397 +7333 3396 +36028 3396 +26238 3396 +27002 3393 +49155 3393 +49601 3393 +31743 3392 +15340 3391 +5480 3388 +18589 3387 +33784 3384 +42165 3384 +35792 3383 +43212 3383 +32815 3381 +23380 3379 +37010 3377 +44942 3377 +24844 3376 +19364 3373 +11151 3370 +22630 3369 +47227 3368 +33707 3366 +26693 3366 +35202 3366 +10545 3365 +1518 3363 +44754 3361 +26158 3359 +34364 3357 +23480 3357 +19293 3355 +14257 3354 +38321 3347 +21251 3344 +44807 3341 +25064 3340 +50093 3339 +41707 3336 +48289 3329 +30818 3329 +7990 3323 +4228 3322 +27849 3320 +21744 3319 +43806 3316 +11127 3315 +22252 3313 +32341 3312 +42082 3309 +14012 3308 +44954 3304 +34258 3301 +18872 3299 +43216 3296 +44154 3295 +40778 3295 +26501 3294 +28012 3294 +44334 3294 +49945 3293 +44238 3293 +38460 3293 +21075 3291 +20621 3289 +44836 3288 +33409 3285 +49036 3284 +34805 3282 +39658 3281 +48522 3281 +35760 3275 +18604 3274 +33420 3274 +35265 3273 +45755 3267 +33447 3263 +35102 3258 +38040 3253 +33792 3252 +27983 3251 +31073 3250 +46257 3247 +18245 3245 +15759 3243 +40806 3237 +35500 3235 +3322 3234 +31254 3229 +20480 3229 +40781 3228 +41808 3227 +20255 3224 +35420 3223 +35147 3223 +8370 3220 +49893 3212 +41709 3209 +17643 3208 +39070 3207 +48402 3207 +33120 3207 +39232 3207 +20184 3206 +22873 3206 +13600 3203 +40063 3201 +45872 3200 +47118 3200 +48933 3196 +23111 3194 +35058 3190 +35488 3184 +28938 3184 +42976 3183 +19237 3182 +36356 3178 +49608 3177 +26104 3175 +46932 3174 +43303 3174 +49850 3174 +18865 3173 +43979 3173 +44090 3171 +32368 3167 +22935 3167 +49506 3166 +44217 3164 +28525 3162 +44177 3162 +35538 3160 +40310 3157 +30444 3156 +44450 3153 +35433 3152 +18441 3151 +32229 3147 +45160 3144 +47120 3143 +23652 3141 +29485 3140 +30467 3138 +6552 3135 +31008 3134 +46331 3131 +45866 3131 +6876 3130 +41436 3130 +22314 3125 +38542 3125 +32247 3121 +15485 3121 +16891 3119 +48641 3118 +38764 3117 +7047 3113 +35172 3110 +42289 3109 +42184 3108 +23321 3107 +34032 3103 +32963 3102 +36196 3102 +37046 3101 +3062 3100 +49496 3095 +37653 3093 +48650 3091 +13577 3080 +9681 3079 +40135 3078 +16818 3065 +28326 3064 +49116 3064 +48346 3060 +29565 3060 +36567 3058 +3179 3056 +44825 3056 +25850 3055 +31467 3050 +43214 3047 +24400 3047 +44632 3047 +10697 3047 +24852 3044 +19012 3043 +11639 3039 +24728 3038 +37778 3037 +12063 3034 +27914 3034 +29335 3032 +20329 3030 +4921 3030 +36248 3028 +46512 3025 +38128 3024 +45528 3022 +2225 3022 +41080 3022 +39184 3021 +32818 3020 +48975 3013 +12343 3012 +5697 3011 +45169 3010 +7449 3010 +37359 3010 +38012 3010 +42646 3009 +22428 3008 +33209 3007 +37395 3006 +13003 3000 +20859 2999 +35277 2996 +28811 2996 +13668 2995 +46010 2993 +42660 2993 +47445 2991 +41780 2991 +35001 2990 +17527 2986 +35528 2984 +26715 2983 +22305 2981 +16151 2980 +46679 2978 +39986 2978 +36767 2975 +2103 2974 +22417 2974 +36857 2973 +5144 2969 +41911 2968 +35533 2967 +33643 2967 +32275 2964 +41382 2964 +9981 2963 +13086 2962 +19306 2959 +46115 2958 +45311 2952 +23839 2948 +17174 2947 +38052 2942 +28865 2940 +44195 2940 +40792 2934 +47046 2933 +27950 2933 +38106 2932 +31579 2930 +25102 2921 +169 2921 +22678 2920 +39688 2920 +37799 2919 +26941 2918 +36970 2915 +19351 2912 +19857 2908 +30715 2907 +39355 2904 +35494 2902 +23360 2902 +45195 2899 +32467 2898 +41357 2895 +32197 2895 +11549 2894 +37693 2894 +14501 2891 +41111 2890 +22506 2887 +47064 2886 +43834 2884 +31619 2882 +27575 2881 +12467 2879 +39789 2876 +45147 2875 +14095 2875 +5319 2874 +20660 2872 +44779 2872 +48845 2872 +35041 2871 +10864 2871 +25490 2870 +22453 2869 +32418 2866 +38277 2862 +38577 2858 +46332 2857 +16166 2856 +23414 2849 +26327 2845 +40927 2843 +23289 2842 +32570 2841 +49883 2841 +38865 2839 +37597 2838 +11573 2837 +46757 2836 +33746 2834 +38816 2833 +45490 2833 +49885 2833 +29863 2832 +21828 2831 +44012 2829 +36112 2827 +49806 2821 +37422 2819 +48728 2817 +42120 2816 +39354 2815 +27945 2814 +47384 2810 +24503 2810 +19282 2807 +26232 2807 +49046 2805 +16589 2804 +38392 2803 +38354 2801 +3330 2800 +48700 2799 +45522 2798 +30205 2792 +37262 2790 +48107 2788 +9762 2784 +34582 2782 +19580 2780 +24087 2778 +30661 2776 +33870 2776 +38292 2774 +39516 2773 +47558 2772 +34889 2764 +38067 2759 +26623 2758 +43753 2758 +25925 2753 +27169 2749 +25714 2746 +50235 2745 +43217 2744 +37978 2742 +28457 2742 +27292 2742 +43695 2741 +29719 2737 +44608 2730 +37157 2729 +21384 2727 +35029 2727 +35558 2726 +48938 2726 +22367 2725 +40010 2725 +23025 2722 +42173 2719 +41068 2715 +23745 2715 +47145 2712 +44952 2711 +46954 2708 +23269 2708 +38281 2705 +32689 2705 +30487 2705 +14980 2703 +16141 2698 +38904 2694 +31966 2693 +37031 2693 +41203 2690 +49615 2690 +27510 2686 +30753 2684 +18566 2683 +19324 2677 +35470 2677 +1792 2677 +33114 2676 +42522 2674 +39323 2668 +47084 2666 +49763 2665 +17414 2664 +38448 2664 +49513 2664 +20869 2663 +4181 2663 +4209 2662 +47006 2662 +8709 2661 +37177 2655 +17022 2654 +21974 2651 +26142 2650 +21340 2647 +22203 2644 +34111 2640 +40099 2638 +34787 2636 +31077 2635 +28167 2633 +47030 2629 +37612 2628 +47174 2628 +15817 2626 +18699 2626 +48443 2626 +40257 2625 +35841 2625 +37156 2623 +6367 2622 +34727 2622 +40613 2621 +42216 2621 +49427 2617 +30293 2616 +44110 2614 +38269 2614 +16897 2613 +45537 2613 +37200 2612 +38235 2611 +40895 2610 +5541 2609 +49071 2608 +35693 2608 +45824 2606 +45135 2606 +39759 2604 +41807 2603 +11610 2603 +48162 2601 +8723 2595 +33910 2594 +4052 2584 +22887 2584 +49832 2584 +44711 2580 +34095 2577 +31301 2576 +16273 2575 +48147 2570 +37511 2568 +980 2568 +41776 2566 +35476 2563 +21471 2561 +46554 2560 +47469 2555 +19526 2555 +37411 2553 +19875 2549 +41972 2548 +32713 2547 +41256 2547 +1591 2545 +18748 2544 +25180 2543 +43706 2542 +30249 2541 +34876 2540 +23081 2540 +44163 2539 +47506 2539 +46471 2538 +9146 2537 +18796 2532 +16516 2529 +49337 2528 +22755 2528 +43583 2524 +30585 2519 +26759 2514 +4840 2510 +42974 2509 +42064 2508 +4766 2507 +44453 2506 +48658 2505 +31266 2505 +31447 2504 +39994 2501 +50030 2499 +28620 2499 +36379 2495 +38571 2493 +18022 2493 +43691 2492 +33986 2490 +44189 2487 +5525 2485 +34181 2480 +19411 2479 +36321 2474 +49505 2474 +758 2471 +36361 2470 +27528 2468 +32785 2467 +38925 2467 +49228 2467 +19382 2464 +44930 2463 +26011 2462 +31181 2462 +41375 2460 +49342 2458 +45492 2457 +30728 2455 +41033 2454 +42451 2453 +22180 2453 +18109 2452 +46495 2452 +31542 2445 +30599 2444 +47951 2441 +36670 2437 +41993 2437 +36621 2434 +34142 2433 +23157 2430 +36017 2425 +40117 2425 +35887 2424 +50163 2424 +47651 2424 +30216 2421 +48744 2419 +31512 2418 +35040 2416 +35847 2416 +23118 2414 +44046 2409 +48469 2408 +47764 2406 +21317 2405 +7168 2404 +41729 2404 +29510 2402 +49137 2400 +21055 2399 +30553 2396 +39194 2393 +22501 2390 +11792 2390 +38946 2385 +33768 2384 +29904 2383 +42558 2380 +25472 2376 +30312 2376 +48900 2375 +25380 2374 +39175 2373 +49795 2372 +34495 2371 +45454 2369 +20004 2369 +49174 2369 +17410 2368 +45672 2366 +39814 2364 +8707 2363 +30782 2363 +11884 2362 +21689 2362 +23870 2359 +21920 2356 +34804 2352 +22093 2347 +5208 2346 +9065 2345 +43145 2344 +14671 2342 +19515 2340 +13783 2337 +14961 2335 +45689 2335 +31631 2334 +46156 2333 +31838 2332 +29905 2331 +45724 2328 +41372 2325 +34720 2320 +47472 2317 +34932 2316 +36690 2316 +40452 2316 +33583 2314 +45519 2314 +24871 2310 +48505 2309 +43786 2309 +47708 2306 +46479 2306 +46121 2303 +40574 2302 +47010 2299 +37199 2298 +22022 2298 +24319 2296 +40246 2294 +44974 2290 +30347 2288 +45803 2286 +47086 2283 +39724 2283 +28618 2280 +39065 2278 +5641 2276 +30604 2275 +10142 2272 +21476 2272 +23257 2270 +40155 2269 +40259 2268 +28968 2265 +24771 2263 +46136 2261 +41947 2260 +36658 2257 +13557 2252 +27985 2250 +34354 2250 +48499 2249 +27600 2246 +27167 2246 +44448 2245 +8964 2243 +17750 2242 +16495 2239 +22542 2239 +47701 2239 +46947 2237 +49358 2237 +42624 2235 +49226 2234 +28198 2231 +48321 2230 +40485 2230 +41100 2230 +10778 2229 +23979 2228 +34196 2227 +21864 2226 +35705 2226 +43702 2225 +31844 2223 +39890 2221 +33725 2221 +40971 2220 +19858 2218 +36370 2217 +33912 2214 +10967 2210 +159 2209 +25178 2208 +8682 2204 +12731 2204 +31179 2204 +48760 2201 +47720 2200 +45876 2196 +42855 2195 +36127 2195 +34340 2193 +39910 2190 +28365 2187 +22330 2183 +6527 2182 +846 2179 +50249 2178 +17635 2177 +38155 2173 +32212 2170 +37859 2169 +28656 2165 +37633 2163 +45662 2163 +39971 2161 +40541 2161 +28762 2160 +48956 2160 +30856 2159 +49896 2157 +48806 2157 +21412 2155 +48869 2155 +49630 2154 +27703 2151 +32230 2150 +42986 2148 +49214 2145 +49665 2142 +43000 2141 +24861 2141 +31660 2141 +44405 2140 +42719 2140 +48369 2139 +39021 2136 +7879 2135 +49905 2132 +44208 2132 +37195 2131 +3679 2129 +47068 2128 +27275 2127 +42758 2124 +37665 2123 +47835 2120 +20290 2116 +42169 2115 +43049 2111 +45286 2111 +41052 2109 +11774 2107 +48523 2100 +32667 2100 +46237 2100 +45351 2098 +49504 2097 +17269 2092 +48720 2091 +36253 2089 +21017 2089 +42867 2089 +23004 2088 +26047 2088 +32734 2081 +46890 2080 +28624 2079 +36408 2078 +40413 2074 +42530 2074 +33044 2069 +32573 2068 +29250 2066 +45008 2065 +49374 2064 +15931 2062 +45908 2062 +47649 2061 +37910 2058 +19890 2057 +44971 2052 +49050 2050 +48362 2047 +10882 2047 +47063 2045 +49925 2036 +12126 2035 +5785 2034 +41444 2034 +46165 2034 +46582 2029 +40591 2028 +11771 2024 +40053 2022 +47732 2022 +9454 2020 +38667 2019 +36044 2019 +48285 2019 +34460 2019 +33920 2018 +46787 2017 +13715 2016 +25529 2015 +4322 2014 +25224 2013 +9201 2012 +39500 2012 +11139 2008 +14188 2005 +33111 2005 +26575 2000 +41753 1998 +19469 1998 +9959 1996 +48452 1995 +30640 1995 +39377 1994 +23595 1993 +24376 1992 +14092 1991 +43717 1990 +28337 1989 +48183 1987 +30167 1986 +25348 1985 +11405 1984 +41099 1983 +48375 1982 +16791 1982 +22046 1980 +23320 1978 +44010 1977 +28794 1974 +36916 1974 +22759 1974 +21876 1974 +28758 1973 +48046 1972 +16883 1967 +20560 1965 +30626 1965 +16878 1964 +45356 1960 +15798 1960 +31364 1959 +15566 1959 +30475 1958 +19182 1956 +20748 1953 +12376 1952 +13291 1952 +22793 1951 +18883 1950 +40356 1949 +50247 1947 +35523 1945 +46621 1944 +18237 1943 +29881 1941 +37430 1940 +41519 1938 +49434 1936 +39044 1936 +47656 1934 +31327 1933 +21583 1933 +28134 1933 +26947 1933 +39000 1931 +38860 1929 +44015 1923 +45507 1923 +26945 1922 +44797 1921 +28707 1920 +13726 1916 +9418 1914 +29829 1913 +40158 1912 +137 1911 +33000 1910 +4907 1909 +38649 1909 +42381 1908 +49834 1907 +35039 1904 +21058 1902 +32014 1901 +45364 1899 +45163 1899 +36918 1896 +36406 1895 +48617 1894 +5512 1894 +23907 1893 +43037 1890 +19667 1890 +32892 1889 +2559 1886 +38696 1882 +32080 1880 +22833 1877 +21756 1876 +11805 1875 +32259 1872 +35975 1872 +30201 1871 +45249 1867 +13328 1867 +22402 1864 +13292 1864 +36545 1863 +49322 1862 +1147 1857 +34013 1857 +44140 1856 +27809 1856 +35307 1855 +26410 1852 +43857 1849 +42973 1848 +34098 1848 +44867 1847 +19990 1845 +11967 1843 +46386 1843 +23381 1836 +31264 1832 +47292 1829 +42866 1827 +33030 1826 +35540 1819 +20608 1818 +39149 1818 +44625 1817 +46238 1814 +48763 1812 +26292 1811 +35453 1810 +43034 1807 +29886 1806 +24957 1806 +47768 1804 +10063 1804 +35611 1802 +46846 1800 +22130 1799 +37093 1797 +28899 1796 +43789 1795 +12676 1795 +38528 1790 +47160 1788 +33566 1787 +37498 1785 +40558 1785 +45554 1776 +1421 1775 +5294 1775 +17358 1774 +18253 1773 +27444 1772 +44728 1769 +19028 1768 +48344 1763 +12567 1762 +27670 1758 +2235 1757 +42915 1753 +35861 1752 +43475 1751 +25895 1750 +7479 1750 +22973 1742 +43267 1739 +38776 1738 +45170 1737 +50227 1736 +46651 1736 +42929 1734 +16892 1733 +49346 1731 +37133 1729 +37350 1729 +21943 1728 +22766 1726 +4011 1725 +49865 1725 +39621 1725 +35656 1721 +7450 1720 +49213 1719 +49877 1715 +25748 1715 +41115 1713 +29743 1711 +23193 1707 +43422 1705 +31347 1705 +33810 1704 +25275 1703 +27674 1702 +15090 1701 +39157 1697 +33648 1695 +42636 1694 +42063 1694 +20746 1694 +31913 1693 +24807 1691 +14859 1690 +44402 1689 +14908 1689 +40261 1688 +13736 1685 +49168 1683 +40267 1683 +11907 1683 +36655 1681 +39643 1681 +16410 1679 +39316 1677 +49819 1674 +19463 1673 +40507 1673 +31246 1673 +46448 1673 +42316 1671 +31687 1671 +9466 1671 +49603 1670 +7726 1667 +34156 1665 +25471 1663 +15020 1663 +34301 1661 +1947 1661 +36181 1660 +31326 1657 +30266 1656 +43458 1656 +41964 1650 +38469 1650 +44293 1649 +33692 1647 +43380 1643 +26678 1643 +43433 1642 +31758 1641 +47400 1639 +2477 1638 +36307 1638 +48991 1637 +10549 1636 +32332 1634 +16268 1633 +28966 1632 +30656 1632 +47226 1629 +46979 1629 +19373 1628 +35036 1626 +38929 1624 +6312 1624 +42615 1622 +45819 1621 +47863 1620 +47195 1619 +26933 1617 +46695 1615 +27711 1614 +18686 1613 +28394 1613 +33386 1612 +42524 1612 +48205 1608 +32360 1605 +9318 1604 +45626 1603 +48526 1601 +29710 1601 +25874 1601 +14610 1599 +3472 1597 +44309 1594 +39922 1594 +19510 1590 +38381 1590 +34121 1588 +28253 1587 +49660 1586 +29773 1585 +32048 1582 +34219 1582 +45664 1581 +46464 1579 +5271 1578 +48911 1578 +22110 1573 +42720 1572 +34018 1569 +38335 1569 +44704 1569 +15149 1568 +45137 1567 +42172 1566 +35339 1563 +43910 1562 +45250 1560 +13392 1560 +23022 1559 +33012 1559 +48277 1557 +16333 1553 +23764 1553 +19202 1553 +19060 1551 +30049 1550 +43993 1546 +32432 1541 +41657 1541 +12374 1540 +31905 1536 +45032 1536 +43408 1534 +39224 1531 +42717 1531 +44423 1528 +19876 1528 +12054 1524 +13412 1523 +34816 1522 +28383 1518 +30295 1516 +39298 1514 +21142 1513 +30327 1513 +19953 1512 +39850 1511 +21563 1505 +17653 1504 +5099 1502 +48123 1499 +30268 1498 +39181 1497 +45297 1495 +36854 1494 +21947 1494 +32639 1494 +21271 1493 +18200 1493 +45748 1491 +43961 1488 +7847 1488 +48534 1487 +43073 1486 +29826 1485 +49991 1483 +42492 1482 +3603 1481 +40704 1480 +43024 1476 +45739 1475 +35585 1471 +41222 1470 +3728 1468 +30360 1465 +40489 1465 +37455 1464 +29712 1463 +30136 1462 +28112 1462 +21052 1459 +33699 1459 +31676 1457 +44036 1454 +43729 1454 +39310 1453 +43078 1453 +33250 1451 +15926 1446 +44506 1442 +29869 1440 +28156 1440 +44520 1438 +47690 1435 +142 1433 +33223 1432 +48761 1432 +34775 1431 +11900 1431 +39187 1430 +47746 1429 +29316 1428 +42468 1428 +36365 1427 +27823 1424 +30562 1424 +31263 1423 +40031 1422 +3429 1421 +30159 1420 +44415 1418 +11039 1418 +47066 1415 +47090 1415 +47212 1412 +20491 1409 +34402 1408 +5008 1408 +28924 1406 +37706 1404 +26227 1404 +45384 1401 +47991 1401 +11411 1399 +20972 1399 +41049 1399 +19662 1399 +38211 1399 +46858 1397 +21314 1391 +13780 1391 +42360 1391 +33705 1387 +49736 1386 +36563 1386 +44013 1384 +37337 1383 +46923 1379 +49312 1379 +23242 1377 +46763 1375 +31490 1375 +49929 1373 +35944 1370 +11482 1370 +38300 1369 +50155 1366 +32590 1363 +43825 1362 +47881 1360 +46349 1360 +48585 1360 +40156 1359 +47797 1359 +37141 1358 +32326 1355 +41305 1355 +12630 1351 +45767 1350 +34945 1350 +29698 1349 +19438 1348 +25182 1344 +24457 1341 +43444 1340 +23473 1339 +24935 1339 +27422 1338 +49035 1338 +40403 1336 +41818 1334 +35600 1334 +6284 1331 +7665 1331 +36171 1328 +3343 1326 +45887 1325 +40092 1324 +23511 1321 +47215 1320 +23626 1319 +11833 1317 +16080 1317 +49267 1316 +46581 1313 +33756 1308 +45251 1308 +25787 1307 +16041 1304 +27901 1302 +36382 1300 +33885 1300 +37906 1296 +19529 1295 +45907 1294 +37239 1293 +3282 1290 +38834 1290 +29613 1290 +18170 1289 +45533 1288 +31221 1285 +6852 1285 +36698 1285 +19395 1285 +40406 1285 +42519 1285 +23106 1283 +47947 1282 +33180 1281 +46570 1281 +37508 1278 +42300 1277 +27813 1275 +8485 1274 +39391 1274 +45750 1272 +27730 1271 +42680 1270 +45999 1270 +23305 1269 +36695 1267 +47546 1266 +11641 1263 +28401 1263 +50084 1263 +26825 1258 +45302 1254 +14524 1254 +33295 1253 +12100 1253 +38953 1253 +34697 1252 +39222 1252 +38021 1252 +36560 1250 +36180 1249 +3422 1248 +40456 1246 +16100 1245 +38543 1242 +37390 1240 +11037 1238 +25216 1235 +42479 1234 +26866 1234 +48835 1233 +34708 1232 +47393 1231 +43727 1229 +39827 1228 +29557 1227 +40069 1227 +26796 1226 +19455 1226 +44197 1225 +34640 1225 +10748 1224 +2155 1224 +27765 1216 +29241 1215 +43117 1215 +47795 1212 +47738 1211 +49694 1211 +20046 1211 +47864 1209 +46344 1208 +33623 1206 +43763 1204 +14060 1200 +40161 1199 +24539 1196 +16648 1195 +29281 1193 +17912 1193 +22065 1188 +43971 1188 +37863 1186 +35061 1186 +25618 1184 +12927 1183 +18125 1181 +37523 1179 +37101 1179 +41333 1177 +160 1176 +12241 1175 +14804 1175 +17720 1174 +27370 1173 +41248 1170 +17816 1169 +46746 1167 +39520 1165 +38271 1163 +34255 1163 +11727 1162 +33232 1162 +43879 1162 +21950 1162 +39098 1161 +22944 1161 +36750 1161 +10779 1160 +34519 1160 +25918 1158 +45281 1157 +36461 1154 +7503 1153 +36297 1152 +29572 1152 +37650 1150 +7180 1149 +30351 1149 +36764 1147 +23046 1145 +32756 1144 +48472 1143 +29472 1143 +5227 1142 +14865 1140 +12813 1140 +28243 1137 +8943 1137 +37848 1136 +19969 1136 +47527 1135 +34261 1132 +21903 1129 +35260 1127 +14560 1126 +42030 1126 +41592 1124 +47171 1124 +12426 1122 +46956 1122 +12071 1121 +20662 1119 +21711 1117 +36713 1117 +48227 1116 +22781 1115 +30660 1115 +43551 1113 +43328 1111 +41504 1109 +18163 1108 +31431 1106 +48873 1103 +31051 1102 +38184 1102 +40816 1097 +37345 1096 +35103 1095 +34704 1094 +27764 1092 +41096 1088 +47429 1088 +35561 1087 +41468 1086 +49551 1085 +43089 1083 +27570 1082 +47945 1078 +18477 1077 +49146 1077 +6847 1076 +16208 1073 +16934 1072 +16281 1067 +37420 1067 +24239 1065 +50143 1065 +2698 1064 +39786 1063 +37168 1061 +47082 1060 +45340 1059 +38124 1058 +16922 1056 +46310 1054 +11568 1053 +42527 1053 +32131 1053 +29460 1053 +44082 1052 +32849 1052 +18083 1052 +46796 1049 +49056 1049 +13486 1045 +30719 1041 +46966 1039 +28255 1036 +23138 1035 +22273 1035 +12486 1030 +45145 1028 +49070 1027 +37380 1027 +39695 1025 +41661 1024 +47611 1019 +48144 1019 +22345 1018 +44204 1017 +45640 1017 +45115 1017 +42752 1016 +31944 1016 +40674 1015 +41343 1014 +8762 1014 +45148 1013 +44575 1011 +33843 1011 +30667 1010 +43266 1008 +44948 1006 +33252 1005 +26911 1005 +35930 1004 +42654 1003 +42245 1002 +21424 999 +33151 998 +45865 997 +44052 996 +40822 996 +23294 993 +31386 993 +12640 989 +9705 989 +20786 986 +16471 985 +29495 984 +49535 984 +12953 982 +25915 982 +9020 978 +11647 976 +1209 976 +13211 972 +47139 966 +43966 966 +22174 961 +41002 960 +46976 959 +39258 959 +46086 958 +39611 958 +43922 956 +48080 956 +39231 955 +35407 955 +19820 951 +21324 950 +19421 950 +47826 949 +45442 949 +33031 946 +48997 943 +24714 941 +33221 940 +23001 940 +6043 939 +41585 939 +26076 938 +27156 935 +47715 934 +40561 931 +29325 931 +48313 931 +48364 929 +47340 928 +12045 927 +37605 925 +36853 922 +30751 920 +12675 919 +47671 915 +40041 914 +38165 911 +9497 911 +36752 911 +10790 908 +7948 906 +15697 905 +44165 904 +33213 903 +28544 903 +35707 902 +44917 901 +29848 900 +12736 898 +26475 896 +31965 892 +37096 892 +25195 892 +48958 891 +45992 889 +38963 888 +38218 887 +27632 887 +42655 880 +36119 879 +32403 878 +25001 873 +37771 873 +17845 872 +18670 872 +29312 869 +41726 862 +15139 862 +25597 862 +43488 859 +21481 858 +25081 858 +40223 857 +45474 856 +22718 853 +27972 853 +46497 850 +32003 849 +21737 847 +24029 847 +47676 846 +31023 846 +37695 843 +21477 843 +37955 842 +42669 840 +32092 840 +43549 838 +39666 836 +39482 833 +19682 833 +46764 832 +7535 832 +6927 832 +14367 831 +28165 830 +25745 830 +34222 828 +31724 827 +143 824 +42000 823 +48670 823 +17158 821 +11839 820 +33524 817 +39105 816 +25902 815 +29554 815 +41791 815 +22316 814 +44646 813 +32291 809 +49426 805 +37456 803 +41309 803 +43015 803 +38551 800 +42565 799 +2549 797 +44829 796 +9263 796 +38461 795 +43889 795 +35269 794 +29994 794 +36003 794 +31917 793 +22270 791 +12424 791 +46274 791 +33470 790 +33778 789 +46092 788 +46036 785 +41335 784 +31456 784 +21775 783 +15211 783 +15081 782 +3786 781 +29841 781 +16116 780 +43297 777 +43903 776 +34976 772 +19587 772 +4431 772 +40391 771 +49201 771 +21763 769 +21091 768 +45298 767 +45990 766 +48265 763 +37374 760 +29847 760 +42924 759 +39763 756 +7961 755 +41150 753 +37014 753 +30298 751 +30838 750 +144 748 +175 748 +40664 746 +9202 745 +15362 745 +38626 745 +39415 744 +36875 741 +15886 741 +5392 741 +15306 741 +23497 739 +25410 738 +45398 736 +14030 735 +38430 734 +28133 734 +22758 733 +18189 733 +34284 730 +30138 729 +46741 728 +23991 728 +29940 727 +36584 727 +37423 727 +49568 726 +20379 725 +47903 722 +8795 721 +6141 719 +31813 719 +48678 717 +22341 716 +46202 715 +27802 714 +41293 713 +27352 711 +44148 709 +37961 708 +29785 706 +40477 705 +29412 705 +21948 704 +43900 701 +40367 699 +22446 699 +43718 697 +42684 692 +37772 690 +45911 688 +46866 686 +30831 685 +8728 685 +36685 685 +10108 684 +33918 684 +39618 682 +48746 681 +39317 681 +34585 680 +3556 679 +21955 678 +15790 674 +6336 673 +9603 673 +47505 672 +46189 668 +25226 668 +23719 667 +49518 665 +37083 664 +39691 661 +43238 658 +25295 656 +6480 653 +23884 653 +48688 652 +20645 650 +36310 650 +48972 650 +31424 647 +48702 646 +34534 642 +41216 642 +30916 640 +33084 639 +37588 639 +45358 638 +40265 637 +49007 636 +30929 636 +8815 635 +44274 634 +8955 633 +38145 630 +43357 628 +37581 627 +29705 626 +43962 626 +33116 626 +22934 624 +46506 623 +42376 622 +36142 622 +11966 622 +32284 620 +36278 619 +9841 617 +29966 616 +38105 616 +17433 615 +19779 614 +170 613 +25060 613 +7280 612 +36737 612 +29415 612 +24679 611 +22784 611 +47762 610 +982 608 +48416 606 +9468 604 +46083 603 +42348 602 +43023 599 +29047 599 +46532 598 +29582 598 +34237 597 +24442 597 +22263 596 +41146 595 +12712 594 +45617 593 +27643 593 +47078 593 +39893 591 +49704 589 +49339 589 +32288 588 +49969 587 +37176 586 +43913 586 +24032 585 +15474 583 +44557 583 +2468 581 +43055 580 +34580 580 +37190 576 +8773 576 +19841 575 +46118 573 +35266 573 +43291 571 +43491 569 +22906 568 +13700 567 +37266 567 +28657 566 +10523 566 +38593 566 +6710 565 +31175 565 +13562 562 +40717 561 +23854 555 +38574 555 +48553 554 +34758 554 +29740 553 +28235 552 +9882 552 +50101 549 +39747 547 +37527 547 +29953 545 +45228 545 +43095 543 +44627 542 +40748 540 +40948 539 +14077 535 +41092 535 +42314 535 +43636 531 +37763 530 +29212 529 +42757 527 +46777 526 +42249 524 +28350 524 +23224 523 +27032 522 +41215 521 +15083 519 +14726 519 +28360 518 +44051 518 +16148 517 +16792 515 +13298 515 +36338 514 +48393 513 +16150 512 +31854 512 +15661 511 +43648 511 +31817 511 +36470 510 +21316 507 +47581 506 +35430 506 +38463 505 +48774 505 +49135 504 +48801 503 +27246 502 +32015 502 +21364 501 +19785 498 +45520 498 +24122 497 +35067 497 +5622 497 +15961 496 +48557 493 +23287 492 +10144 491 +10097 491 +26867 487 +41888 487 +49409 484 +24336 484 +39488 483 +25248 482 +20398 481 +38892 479 +20322 479 +16626 477 +35508 476 +26791 476 +40290 475 +49546 475 +16253 474 +43768 473 +43197 473 +14099 470 +47418 469 +9287 468 +14692 468 +25053 467 +45227 466 +42164 466 +14512 466 +28632 465 +45986 464 +30134 462 +38519 462 +28955 460 +29636 458 +33489 457 +44057 457 +20036 457 +23376 456 +15272 455 +36166 452 +29577 450 +32541 449 +24373 448 +24689 448 +39737 447 +5571 447 +10160 446 +49582 446 +49015 446 +44755 444 +23711 442 +42804 441 +28013 441 +40672 440 +37143 440 +35439 439 +8346 439 +35050 437 +15116 436 +36447 436 +44926 435 +16323 434 +31768 434 +44174 431 +14777 430 +15853 430 +21451 428 +41340 428 +47232 428 +46999 427 +35799 425 +35555 425 +25131 424 +19927 423 +41349 423 +8983 421 +34991 417 +20213 416 +34949 415 +33682 415 +44332 414 +29589 413 +49771 413 +49129 412 +24186 412 +33803 411 +48893 410 +25645 408 +19415 407 +44547 407 +35235 405 +39321 404 +40786 403 +37389 401 +34650 401 +45717 399 +20590 397 +8994 396 +26054 393 +48031 393 +13697 391 +2955 390 +40266 386 +1977 385 +17405 384 +2115 382 +3207 382 +45082 381 +3156 381 +32517 381 +43102 381 +40537 380 +43375 378 +47932 378 +30109 377 +48737 376 +16165 373 +19629 371 +30072 370 +37485 368 +3286 368 +48995 367 +24493 367 +25465 366 +43848 366 +21253 365 +24440 364 +49607 359 +37227 359 +48541 358 +41573 358 +40386 353 +7601 352 +29851 352 +22133 352 +29659 352 +49011 351 +45218 351 +18004 350 +40720 349 +37467 346 +42783 345 +32398 343 +49960 342 +35306 342 +34345 341 +27007 341 +12404 340 +42543 339 +42638 338 +49167 335 +31208 334 +45784 333 +33296 333 +20512 332 +32742 332 +18356 331 +44587 331 +30165 329 +41433 327 +40364 327 +9049 326 +2918 326 +17683 325 +17681 325 +24077 324 +25611 324 +6166 323 +39681 323 +49855 323 +44256 322 +39333 322 +49073 320 +31937 320 +37509 317 +43077 316 +15842 316 +33384 315 +25497 315 +30965 315 +48497 315 +16193 315 +47987 313 +22725 313 +46140 313 +2804 312 +32524 311 +20532 310 +47939 310 +28542 310 +39192 309 +10125 308 +17773 305 +47423 305 +46268 301 +24363 301 +20513 300 +26498 300 +50179 299 +36469 298 +34543 297 +20115 297 +28696 297 +36786 296 +26712 294 +31090 293 +42062 290 +23131 287 +38326 287 +34373 287 +26095 286 +25626 286 +46424 285 +15506 285 +9000 285 +31936 283 +30800 282 +49058 281 +27551 280 +44648 276 +12240 276 +18803 275 +7589 274 +41641 274 +40109 274 +1896 273 +47000 273 +32518 272 +45379 272 +45635 272 +33529 272 +13765 270 +40420 270 +12845 269 +16201 268 +33465 268 +24001 267 +49249 267 +41853 267 +4010 266 +8418 265 +49813 265 +25581 264 +43481 263 +46788 262 +41629 262 +24710 261 +35144 261 +39907 260 +47021 260 +20801 260 +25128 259 +30812 259 +48304 258 +18115 257 +48404 256 +33829 256 +23846 255 +6112 254 +5997 254 +6987 253 +7677 253 +26503 253 +44161 253 +46491 252 +48231 251 +11910 251 +37669 250 +35702 249 +49464 248 +41323 248 +37233 247 +26998 246 +36828 246 +24806 244 +32207 243 +30762 242 +42637 242 +16103 242 +172 242 +49472 242 +25084 241 +7105 239 +19791 238 +41974 237 +45335 237 +31052 236 +37426 236 +13177 235 +38894 235 +37495 234 +25549 234 +25795 234 +43801 234 +43282 233 +13296 231 +38149 231 +24466 230 +28264 230 +34525 230 +48448 228 +36581 227 +36521 227 +49082 225 +48318 225 +8755 225 +36792 223 +43353 223 +19039 223 +43302 222 +20677 220 +47307 220 +32310 220 +31732 220 +19021 219 +17401 219 +36922 219 +12717 218 +33426 217 +46904 217 +33309 216 +33795 215 +29993 214 +4242 214 +32546 212 +35818 208 +47175 208 +11896 208 +34934 208 +48908 208 +42367 208 +43769 207 +50159 207 +35514 205 +45495 204 +43213 203 +2590 203 +4895 203 +27542 202 +39996 201 +35063 201 +47569 200 +40283 198 +37817 198 +1543 197 +37757 197 +14592 196 +27733 195 +39394 195 +13979 194 +12662 193 +2887 193 +42287 191 +22241 191 +32891 189 +11548 189 +26642 188 +11480 187 +15755 186 +10060 186 +15913 186 +45144 185 +42026 185 +19227 184 +33761 184 +25207 182 +38122 182 +44916 181 +29113 181 +22831 179 +13945 179 +6681 178 +34901 178 +22322 178 +50108 177 +29164 176 +23544 174 +46545 174 +15351 173 +22496 173 +39742 173 +11606 173 +36796 173 +26229 171 +39115 171 +35572 170 +16959 169 +30716 168 +37642 167 +44651 167 +27852 167 +40073 167 +37913 167 +45975 166 +46968 166 +38362 165 +29446 165 +7359 164 +17473 163 +40012 163 +47258 163 +46677 162 +49390 162 +45150 162 +24022 161 +24898 160 +32239 160 +45434 159 +27509 159 +39703 159 +3587 157 +11974 157 +36726 156 +15685 155 +38653 154 +24618 154 +17532 153 +24973 151 +41386 151 +48944 151 +41678 151 +7804 149 +33991 148 +21959 146 +14531 145 +41441 144 +37412 144 +41658 143 +6399 142 +2941 142 +33893 141 +41849 140 +11919 140 +44912 139 +46541 138 +32088 137 +35604 137 +48610 137 +50033 137 +19476 137 +25926 136 +23330 136 +49843 136 +50001 135 +48999 134 +48458 134 +36301 133 +16646 132 +47271 132 +40111 132 +23329 132 +41313 131 +23728 130 +33207 128 +47542 127 +37082 127 +10269 126 +39434 126 +48204 125 +43667 124 +6533 122 +49273 122 +40361 122 +49324 121 +25589 121 +8438 120 +2432 120 +17761 120 +10052 120 +37435 119 +47981 118 +12869 116 +34607 115 +41006 113 +47596 113 +45123 112 +43246 110 +40719 110 +26700 110 +41945 109 +152 109 +16098 109 +6598 109 +47253 107 +46249 107 +29021 106 +45563 106 +47147 105 +45539 105 +35343 105 +43241 105 +50216 105 +43734 105 +35922 104 +29226 104 +44431 104 +221 104 +25970 104 +27293 103 +1841 103 +14468 103 +42311 103 +47559 102 +49643 102 +35069 101 +8115 101 +44233 100 +16303 100 +47282 99 +40629 99 +39008 99 +32509 98 +32917 98 +42396 98 +176 97 +36169 96 +48753 96 +10253 94 +40516 94 +3523 93 +48185 93 +49086 93 +44104 92 +31204 92 +43839 91 +27924 90 +17933 90 +49476 89 +36596 89 +46745 89 +44167 87 +30531 87 +47486 87 +40549 86 +35992 85 +34832 85 +33468 85 +46996 84 +40493 84 +43242 84 +7134 83 +11585 80 +22640 80 +37811 80 +42869 80 +39860 79 +25719 78 +23984 77 +11273 76 +41481 76 +20554 75 +13198 75 +28725 74 +42210 74 +155 73 +48727 73 +35318 72 +41365 71 +32511 70 +40345 70 +31708 69 +44872 69 +41832 69 +9968 69 +28670 69 +30478 67 +10298 67 +11885 66 +11737 66 +17787 66 +41939 65 +41868 65 +39467 65 +41538 64 +44546 63 +20503 62 +47682 61 +4060 61 +16068 60 +48457 59 +36473 59 +45449 59 +50113 58 +15040 58 +46110 58 +47614 58 +50116 57 +43313 57 +18945 57 +29795 57 +37858 56 +26534 55 +18433 55 +39886 55 +33490 54 +40415 54 +36704 53 +44785 53 +43899 51 +32865 51 +47530 51 +39364 50 +42535 49 +25887 49 +37981 49 +49527 49 +33937 48 +36940 48 +22315 47 +48874 47 +4204 47 +23596 47 +31478 47 +42035 46 +9286 46 +38016 46 +11689 46 +42785 45 +46222 45 +33994 45 +47794 45 +43897 45 +42877 45 +48953 44 +44686 44 +37545 44 +45435 43 +34386 42 +7260 42 +13171 42 +23926 41 +24307 40 +31820 40 +44392 39 +48600 38 +41230 38 +38390 38 +13150 37 +154 37 +38243 36 +29447 36 +44326 36 +29646 35 +19073 35 +15041 35 +45433 34 +42382 32 +38377 32 +47540 32 +47936 32 +47432 31 +49149 31 +30432 31 +39280 30 +48366 30 +12943 29 +37922 29 +14695 29 +13426 29 +16782 28 +49997 28 +36926 28 +23613 28 +22675 28 +35098 28 +6408 28 +33153 28 +31739 28 +43518 27 +7782 27 +29752 27 +23363 26 +45823 26 +43053 26 +40236 24 +37787 24 +49029 24 +33023 24 +20804 24 +34103 24 +27013 23 +37991 23 +42943 23 +44033 23 +41380 22 +25698 22 +42750 22 +25362 22 +44555 22 +22039 20 +42983 20 +45762 20 +27006 20 +12677 19 +48219 19 +43394 19 +37662 19 +17553 18 +45422 18 +30439 18 +14341 18 +11592 17 +33929 17 +17629 17 +42889 17 +153 17 +14223 17 +43010 17 +32843 16 +48193 16 +35793 16 +36475 16 +31161 15 +16822 15 +47182 15 +44112 14 +34604 14 +31881 14 +46402 13 +36937 12 +28500 12 +24731 12 +27584 12 +43796 11 +36481 11 +40703 11 +19049 10 +44444 10 +4690 10 +42470 9 +41977 9 +36917 9 +46948 9 +10658 9 +38250 9 +43298 8 +45953 8 +36929 8 +42234 7 +38160 7 +47490 7 +40235 7 +5808 7 +45786 7 +36490 6 +5367 6 +27534 6 +21807 5 +36886 5 +39693 5 +30684 5 +37226 5 +15243 5 +34633 5 +22997 5 +25658 4 +45321 4 +8980 4 +47648 4 +34206 4 +43569 4 +36862 3 +49778 3 +45392 3 +42066 3 +36130 3 +46939 3 +6438 3 +34842 2 +48527 2 +38370 2 +34473 2 +40278 2 +20174 2 +5815 1 +9364 1 +39142 1 +47703 1 +49074 1 +31536 1 +14827 1 +23090 1 +43735 1 +24847 1 +40219 1 +32437 1 +31727 1 +124 0 +125 0 +173 0 +174 0 +177 0 +178 0 +179 0 +180 0 +181 0 +182 0 +183 0 +184 0 +185 0 +186 0 +187 0 +188 0 +189 0 +190 0 +191 0 +192 0 +193 0 +194 0 +195 0 +196 0 +197 0 +198 0 +199 0 +200 0 +201 0 +202 0 +203 0 +204 0 +205 0 +206 0 +207 0 +208 0 +209 0 +210 0 +211 0 +212 0 +213 0 +214 0 +215 0 +216 0 +217 0 +218 0 +219 0 +628 0 +1849 0 +4603 0 +5624 0 +8828 0 +11504 0 +12781 0 +17811 0 +17900 0 +18472 0 +22686 0 +22757 0 +23282 0 +23614 0 +23785 0 +24293 0 +24934 0 +25193 0 +25502 0 +25992 0 +28666 0 +29342 0 +29372 0 +30202 0 +30208 0 +30209 0 +30210 0 +30211 0 +30212 0 +30213 0 +30897 0 +30898 0 +30899 0 +30905 0 +30906 0 +31032 0 +31538 0 +31573 0 +31576 0 +31666 0 +31765 0 +31783 0 +31886 0 +31957 0 +32047 0 +32406 0 +33434 0 +33454 0 +33477 0 +33813 0 +34027 0 +34448 0 +34504 0 +34516 0 +35207 0 +35496 0 +35579 0 +36173 0 +36174 0 +36935 0 +36938 0 +37444 0 +37574 0 +37579 0 +37631 0 +37842 0 +38214 0 +39165 0 +39172 0 +39177 0 +39253 0 +39374 0 +39446 0 +39655 0 +39714 0 +39749 0 +39752 0 +39753 0 +39755 0 +39756 0 +39757 0 +39803 0 +39811 0 +39820 0 +39821 0 +39906 0 +40240 0 +40241 0 +40242 0 +41297 0 +41383 0 +41551 0 +42089 0 +42090 0 +42202 0 +42424 0 +42496 0 +42586 0 +42728 0 +43038 0 +43065 0 +43177 0 +43361 0 +43453 0 +44320 0 +45003 0 +45199 0 +45544 0 +45545 0 +45706 0 +46600 0 +47198 0 +47571 0 +47654 0 +47934 0 +48069 0 +48396 0 +49731 0 +49781 0 +50009 0 +50256 0 +madeupword0000 0 +madeupword0001 0 +madeupword0002 0 diff --git a/utils/BPE/encoder.json b/utils/BPE/encoder.json new file mode 100644 index 0000000000000000000000000000000000000000..1f1d9aaca301414e7f6c9396df506798ff4eb9a6 --- /dev/null +++ b/utils/BPE/encoder.json @@ -0,0 +1 @@ +{"!": 0, "\"": 1, "#": 2, "$": 3, "%": 4, "&": 5, "'": 6, "(": 7, ")": 8, "*": 9, "+": 10, ",": 11, "-": 12, ".": 13, "/": 14, "0": 15, "1": 16, "2": 17, "3": 18, "4": 19, "5": 20, "6": 21, "7": 22, "8": 23, "9": 24, ":": 25, ";": 26, "<": 27, "=": 28, ">": 29, "?": 30, "@": 31, "A": 32, "B": 33, "C": 34, "D": 35, "E": 36, "F": 37, "G": 38, "H": 39, "I": 40, "J": 41, "K": 42, "L": 43, "M": 44, "N": 45, "O": 46, "P": 47, "Q": 48, "R": 49, "S": 50, "T": 51, "U": 52, "V": 53, "W": 54, "X": 55, "Y": 56, "Z": 57, "[": 58, "\\": 59, "]": 60, "^": 61, "_": 62, "`": 63, "a": 64, "b": 65, "c": 66, "d": 67, "e": 68, "f": 69, "g": 70, "h": 71, "i": 72, "j": 73, "k": 74, "l": 75, "m": 76, "n": 77, "o": 78, "p": 79, "q": 80, "r": 81, "s": 82, "t": 83, "u": 84, "v": 85, "w": 86, "x": 87, "y": 88, "z": 89, "{": 90, "|": 91, "}": 92, "~": 93, "\u00a1": 94, "\u00a2": 95, "\u00a3": 96, "\u00a4": 97, "\u00a5": 98, "\u00a6": 99, "\u00a7": 100, "\u00a8": 101, "\u00a9": 102, "\u00aa": 103, "\u00ab": 104, "\u00ac": 105, "\u00ae": 106, "\u00af": 107, "\u00b0": 108, "\u00b1": 109, "\u00b2": 110, "\u00b3": 111, "\u00b4": 112, "\u00b5": 113, "\u00b6": 114, "\u00b7": 115, "\u00b8": 116, "\u00b9": 117, "\u00ba": 118, "\u00bb": 119, "\u00bc": 120, "\u00bd": 121, "\u00be": 122, "\u00bf": 123, "\u00c0": 124, "\u00c1": 125, "\u00c2": 126, "\u00c3": 127, "\u00c4": 128, "\u00c5": 129, "\u00c6": 130, "\u00c7": 131, "\u00c8": 132, "\u00c9": 133, "\u00ca": 134, "\u00cb": 135, "\u00cc": 136, "\u00cd": 137, "\u00ce": 138, "\u00cf": 139, "\u00d0": 140, "\u00d1": 141, "\u00d2": 142, "\u00d3": 143, "\u00d4": 144, "\u00d5": 145, "\u00d6": 146, "\u00d7": 147, "\u00d8": 148, "\u00d9": 149, "\u00da": 150, "\u00db": 151, "\u00dc": 152, "\u00dd": 153, "\u00de": 154, "\u00df": 155, "\u00e0": 156, "\u00e1": 157, "\u00e2": 158, "\u00e3": 159, "\u00e4": 160, "\u00e5": 161, "\u00e6": 162, "\u00e7": 163, "\u00e8": 164, "\u00e9": 165, "\u00ea": 166, "\u00eb": 167, "\u00ec": 168, "\u00ed": 169, "\u00ee": 170, "\u00ef": 171, "\u00f0": 172, "\u00f1": 173, "\u00f2": 174, "\u00f3": 175, "\u00f4": 176, "\u00f5": 177, "\u00f6": 178, "\u00f7": 179, "\u00f8": 180, "\u00f9": 181, "\u00fa": 182, "\u00fb": 183, "\u00fc": 184, "\u00fd": 185, "\u00fe": 186, "\u00ff": 187, "\u0100": 188, "\u0101": 189, "\u0102": 190, "\u0103": 191, "\u0104": 192, "\u0105": 193, "\u0106": 194, "\u0107": 195, "\u0108": 196, "\u0109": 197, "\u010a": 198, "\u010b": 199, "\u010c": 200, "\u010d": 201, "\u010e": 202, "\u010f": 203, "\u0110": 204, "\u0111": 205, "\u0112": 206, "\u0113": 207, "\u0114": 208, "\u0115": 209, "\u0116": 210, "\u0117": 211, "\u0118": 212, "\u0119": 213, "\u011a": 214, "\u011b": 215, "\u011c": 216, "\u011d": 217, "\u011e": 218, "\u011f": 219, "\u0120": 220, "\u0121": 221, "\u0122": 222, "\u0123": 223, "\u0124": 224, "\u0125": 225, "\u0126": 226, "\u0127": 227, "\u0128": 228, "\u0129": 229, "\u012a": 230, "\u012b": 231, "\u012c": 232, "\u012d": 233, "\u012e": 234, "\u012f": 235, "\u0130": 236, "\u0131": 237, "\u0132": 238, "\u0133": 239, "\u0134": 240, "\u0135": 241, "\u0136": 242, "\u0137": 243, "\u0138": 244, "\u0139": 245, "\u013a": 246, "\u013b": 247, "\u013c": 248, "\u013d": 249, "\u013e": 250, "\u013f": 251, "\u0140": 252, "\u0141": 253, "\u0142": 254, "\u0143": 255, "\u0120t": 256, "\u0120a": 257, "he": 258, "in": 259, "re": 260, "on": 261, "\u0120the": 262, "er": 263, "\u0120s": 264, "at": 265, "\u0120w": 266, "\u0120o": 267, "en": 268, "\u0120c": 269, "it": 270, "is": 271, "an": 272, "or": 273, "es": 274, "\u0120b": 275, "ed": 276, "\u0120f": 277, "ing": 278, "\u0120p": 279, "ou": 280, "\u0120an": 281, "al": 282, "ar": 283, "\u0120to": 284, "\u0120m": 285, "\u0120of": 286, "\u0120in": 287, "\u0120d": 288, "\u0120h": 289, "\u0120and": 290, "ic": 291, "as": 292, "le": 293, "\u0120th": 294, "ion": 295, "om": 296, "ll": 297, "ent": 298, "\u0120n": 299, "\u0120l": 300, "st": 301, "\u0120re": 302, "ve": 303, "\u0120e": 304, "ro": 305, "ly": 306, "\u0120be": 307, "\u0120g": 308, "\u0120T": 309, "ct": 310, "\u0120S": 311, "id": 312, "ot": 313, "\u0120I": 314, "ut": 315, "et": 316, "\u0120A": 317, "\u0120is": 318, "\u0120on": 319, "im": 320, "am": 321, "ow": 322, "ay": 323, "ad": 324, "se": 325, "\u0120that": 326, "\u0120C": 327, "ig": 328, "\u0120for": 329, "ac": 330, "\u0120y": 331, "ver": 332, "ur": 333, "\u0120u": 334, "ld": 335, "\u0120st": 336, "\u0120M": 337, "'s": 338, "\u0120he": 339, "\u0120it": 340, "ation": 341, "ith": 342, "ir": 343, "ce": 344, "\u0120you": 345, "il": 346, "\u0120B": 347, "\u0120wh": 348, "ol": 349, "\u0120P": 350, "\u0120with": 351, "\u01201": 352, "ter": 353, "ch": 354, "\u0120as": 355, "\u0120we": 356, "\u0120(": 357, "nd": 358, "ill": 359, "\u0120D": 360, "if": 361, "\u01202": 362, "ag": 363, "ers": 364, "ke": 365, "\u0120\"": 366, "\u0120H": 367, "em": 368, "\u0120con": 369, "\u0120W": 370, "\u0120R": 371, "her": 372, "\u0120was": 373, "\u0120r": 374, "od": 375, "\u0120F": 376, "ul": 377, "ate": 378, "\u0120at": 379, "ri": 380, "pp": 381, "ore": 382, "\u0120The": 383, "\u0120se": 384, "us": 385, "\u0120pro": 386, "\u0120ha": 387, "um": 388, "\u0120are": 389, "\u0120de": 390, "ain": 391, "and": 392, "\u0120or": 393, "igh": 394, "est": 395, "ist": 396, "ab": 397, "rom": 398, "\u0120N": 399, "th": 400, "\u0120com": 401, "\u0120G": 402, "un": 403, "op": 404, "00": 405, "\u0120L": 406, "\u0120not": 407, "ess": 408, "\u0120ex": 409, "\u0120v": 410, "res": 411, "\u0120E": 412, "ew": 413, "ity": 414, "ant": 415, "\u0120by": 416, "el": 417, "os": 418, "ort": 419, "oc": 420, "qu": 421, "\u0120from": 422, "\u0120have": 423, "\u0120su": 424, "ive": 425, "ould": 426, "\u0120sh": 427, "\u0120this": 428, "nt": 429, "ra": 430, "pe": 431, "ight": 432, "art": 433, "ment": 434, "\u0120al": 435, "ust": 436, "end": 437, "--": 438, "all": 439, "\u0120O": 440, "ack": 441, "\u0120ch": 442, "\u0120le": 443, "ies": 444, "red": 445, "ard": 446, "\u00e2\u0122": 447, "out": 448, "\u0120J": 449, "\u0120ab": 450, "ear": 451, "iv": 452, "ally": 453, "our": 454, "ost": 455, "gh": 456, "pt": 457, "\u0120pl": 458, "ast": 459, "\u0120can": 460, "ak": 461, "ome": 462, "ud": 463, "The": 464, "\u0120his": 465, "\u0120do": 466, "\u0120go": 467, "\u0120has": 468, "ge": 469, "'t": 470, "\u0120U": 471, "rou": 472, "\u0120sa": 473, "\u0120j": 474, "\u0120but": 475, "\u0120wor": 476, "\u0120all": 477, "ect": 478, "\u0120k": 479, "ame": 480, "\u0120will": 481, "ok": 482, "\u0120whe": 483, "\u0120they": 484, "ide": 485, "01": 486, "ff": 487, "ich": 488, "pl": 489, "ther": 490, "\u0120tr": 491, "..": 492, "\u0120int": 493, "ie": 494, "ure": 495, "age": 496, "\u0120ne": 497, "ial": 498, "ap": 499, "ine": 500, "ice": 501, "\u0120me": 502, "\u0120out": 503, "ans": 504, "one": 505, "ong": 506, "ions": 507, "\u0120who": 508, "\u0120K": 509, "\u0120up": 510, "\u0120their": 511, "\u0120ad": 512, "\u01203": 513, "\u0120us": 514, "ated": 515, "ous": 516, "\u0120more": 517, "ue": 518, "og": 519, "\u0120St": 520, "ind": 521, "ike": 522, "\u0120so": 523, "ime": 524, "per": 525, ".\"": 526, "ber": 527, "iz": 528, "act": 529, "\u0120one": 530, "\u0120said": 531, "\u0120-": 532, "are": 533, "\u0120your": 534, "cc": 535, "\u0120Th": 536, "\u0120cl": 537, "ep": 538, "ake": 539, "able": 540, "ip": 541, "\u0120cont": 542, "\u0120which": 543, "ia": 544, "\u0120im": 545, "\u0120about": 546, "\u0120were": 547, "very": 548, "ub": 549, "\u0120had": 550, "\u0120en": 551, "\u0120comp": 552, ",\"": 553, "\u0120In": 554, "\u0120un": 555, "\u0120ag": 556, "ire": 557, "ace": 558, "au": 559, "ary": 560, "\u0120would": 561, "ass": 562, "ry": 563, "\u0120\u00e2\u0122": 564, "cl": 565, "ook": 566, "ere": 567, "so": 568, "\u0120V": 569, "ign": 570, "ib": 571, "\u0120off": 572, "\u0120te": 573, "ven": 574, "\u0120Y": 575, "ile": 576, "ose": 577, "ite": 578, "orm": 579, "\u0120201": 580, "\u0120res": 581, "\u0120man": 582, "\u0120per": 583, "\u0120other": 584, "ord": 585, "ult": 586, "\u0120been": 587, "\u0120like": 588, "ase": 589, "ance": 590, "ks": 591, "ays": 592, "own": 593, "ence": 594, "\u0120dis": 595, "ction": 596, "\u0120any": 597, "\u0120app": 598, "\u0120sp": 599, "int": 600, "ress": 601, "ations": 602, "ail": 603, "\u01204": 604, "ical": 605, "\u0120them": 606, "\u0120her": 607, "ount": 608, "\u0120Ch": 609, "\u0120ar": 610, "\u0120if": 611, "\u0120there": 612, "\u0120pe": 613, "\u0120year": 614, "av": 615, "\u0120my": 616, "\u0120some": 617, "\u0120when": 618, "ough": 619, "ach": 620, "\u0120than": 621, "ru": 622, "ond": 623, "ick": 624, "\u0120over": 625, "vel": 626, "\u0120qu": 627, "\u010a\u010a": 628, "\u0120sc": 629, "reat": 630, "ree": 631, "\u0120It": 632, "ound": 633, "port": 634, "\u0120also": 635, "\u0120part": 636, "fter": 637, "\u0120kn": 638, "\u0120bec": 639, "\u0120time": 640, "ens": 641, "\u01205": 642, "ople": 643, "\u0120what": 644, "\u0120no": 645, "du": 646, "mer": 647, "ang": 648, "\u0120new": 649, "----": 650, "\u0120get": 651, "ory": 652, "ition": 653, "ings": 654, "\u0120just": 655, "\u0120into": 656, "\u01200": 657, "ents": 658, "ove": 659, "te": 660, "\u0120people": 661, "\u0120pre": 662, "\u0120its": 663, "\u0120rec": 664, "\u0120tw": 665, "ian": 666, "irst": 667, "ark": 668, "ors": 669, "\u0120work": 670, "ade": 671, "ob": 672, "\u0120she": 673, "\u0120our": 674, "wn": 675, "ink": 676, "lic": 677, "\u012019": 678, "\u0120He": 679, "ish": 680, "nder": 681, "ause": 682, "\u0120him": 683, "ons": 684, "\u0120[": 685, "\u0120ro": 686, "form": 687, "ild": 688, "ates": 689, "vers": 690, "\u0120only": 691, "oll": 692, "\u0120spe": 693, "ck": 694, "ell": 695, "amp": 696, "\u0120acc": 697, "\u0120bl": 698, "ious": 699, "urn": 700, "ft": 701, "ood": 702, "\u0120how": 703, "hed": 704, "\u0120'": 705, "\u0120after": 706, "aw": 707, "\u0120att": 708, "ov": 709, "ne": 710, "\u0120play": 711, "erv": 712, "ict": 713, "\u0120could": 714, "itt": 715, "\u0120am": 716, "\u0120first": 717, "\u01206": 718, "\u0120act": 719, "\u0120$": 720, "ec": 721, "hing": 722, "ual": 723, "ull": 724, "\u0120comm": 725, "oy": 726, "old": 727, "ces": 728, "ater": 729, "\u0120fe": 730, "\u0120bet": 731, "we": 732, "iff": 733, "\u0120two": 734, "ock": 735, "\u0120back": 736, ").": 737, "ident": 738, "\u0120under": 739, "rough": 740, "sel": 741, "xt": 742, "\u0120may": 743, "round": 744, "\u0120po": 745, "ph": 746, "iss": 747, "\u0120des": 748, "\u0120most": 749, "\u0120did": 750, "\u0120add": 751, "ject": 752, "\u0120inc": 753, "fore": 754, "\u0120pol": 755, "ont": 756, "\u0120again": 757, "clud": 758, "tern": 759, "\u0120know": 760, "\u0120need": 761, "\u0120cons": 762, "\u0120co": 763, "\u0120.": 764, "\u0120want": 765, "\u0120see": 766, "\u01207": 767, "ning": 768, "iew": 769, "\u0120This": 770, "ced": 771, "\u0120even": 772, "\u0120ind": 773, "ty": 774, "\u0120We": 775, "ath": 776, "\u0120these": 777, "\u0120pr": 778, "\u0120use": 779, "\u0120because": 780, "\u0120fl": 781, "ng": 782, "\u0120now": 783, "\u0120\u00e2\u0122\u0135": 784, "com": 785, "ise": 786, "\u0120make": 787, "\u0120then": 788, "ower": 789, "\u0120every": 790, "\u0120Un": 791, "\u0120sec": 792, "oss": 793, "uch": 794, "\u0120em": 795, "\u0120=": 796, "\u0120Re": 797, "ied": 798, "rit": 799, "\u0120inv": 800, "lect": 801, "\u0120supp": 802, "ating": 803, "\u0120look": 804, "man": 805, "pect": 806, "\u01208": 807, "row": 808, "\u0120bu": 809, "\u0120where": 810, "ific": 811, "\u0120years": 812, "ily": 813, "\u0120diff": 814, "\u0120should": 815, "\u0120rem": 816, "Th": 817, "In": 818, "\u0120ev": 819, "day": 820, "'re": 821, "rib": 822, "\u0120rel": 823, "ss": 824, "\u0120def": 825, "\u0120right": 826, "\u0120sy": 827, "),": 828, "les": 829, "000": 830, "hen": 831, "\u0120through": 832, "\u0120Tr": 833, "__": 834, "\u0120way": 835, "\u0120don": 836, "\u0120,": 837, "\u012010": 838, "ased": 839, "\u0120ass": 840, "ublic": 841, "\u0120reg": 842, "\u0120And": 843, "ix": 844, "\u0120very": 845, "\u0120includ": 846, "other": 847, "\u0120imp": 848, "oth": 849, "\u0120sub": 850, "\u0120\u00e2\u0122\u0136": 851, "\u0120being": 852, "arg": 853, "\u0120Wh": 854, "==": 855, "ible": 856, "\u0120does": 857, "ange": 858, "ram": 859, "\u01209": 860, "ert": 861, "ps": 862, "ited": 863, "ational": 864, "\u0120br": 865, "\u0120down": 866, "\u0120many": 867, "aking": 868, "\u0120call": 869, "uring": 870, "ities": 871, "\u0120ph": 872, "ics": 873, "als": 874, "\u0120dec": 875, "ative": 876, "ener": 877, "\u0120before": 878, "ility": 879, "\u0120well": 880, "\u0120much": 881, "erson": 882, "\u0120those": 883, "\u0120such": 884, "\u0120ke": 885, "\u0120end": 886, "\u0120But": 887, "ason": 888, "ting": 889, "\u0120long": 890, "ef": 891, "\u0120think": 892, "ys": 893, "\u0120bel": 894, "\u0120sm": 895, "its": 896, "ax": 897, "\u0120own": 898, "\u0120prov": 899, "\u0120set": 900, "ife": 901, "ments": 902, "ble": 903, "ward": 904, "\u0120show": 905, "\u0120pres": 906, "ms": 907, "omet": 908, "\u0120ob": 909, "\u0120say": 910, "\u0120Sh": 911, "ts": 912, "ful": 913, "\u0120eff": 914, "\u0120gu": 915, "\u0120inst": 916, "und": 917, "ren": 918, "cess": 919, "\u0120ent": 920, "\u0120You": 921, "\u0120good": 922, "\u0120start": 923, "ince": 924, "\u0120made": 925, "tt": 926, "stem": 927, "olog": 928, "up": 929, "\u0120|": 930, "ump": 931, "\u0120hel": 932, "vern": 933, "ular": 934, "ually": 935, "\u0120ac": 936, "\u0120mon": 937, "\u0120last": 938, "\u0120200": 939, "10": 940, "\u0120stud": 941, "ures": 942, "\u0120Ar": 943, "self": 944, "ars": 945, "meric": 946, "ues": 947, "cy": 948, "\u0120min": 949, "ollow": 950, "\u0120col": 951, "io": 952, "\u0120mod": 953, "\u0120count": 954, "\u0120Com": 955, "hes": 956, "\u0120fin": 957, "air": 958, "ier": 959, "\u00e2\u0122\u0136": 960, "read": 961, "ank": 962, "atch": 963, "ever": 964, "\u0120str": 965, "\u0120point": 966, "ork": 967, "\u0120New": 968, "\u0120sur": 969, "ool": 970, "alk": 971, "ement": 972, "\u0120used": 973, "ract": 974, "ween": 975, "\u0120same": 976, "oun": 977, "\u0120Al": 978, "ci": 979, "\u0120differe": 980, "\u0120while": 981, "--------": 982, "\u0120game": 983, "cept": 984, "\u0120sim": 985, "...": 986, "\u0120inter": 987, "ek": 988, "\u0120report": 989, "\u0120produ": 990, "\u0120still": 991, "led": 992, "ah": 993, "\u0120here": 994, "\u0120world": 995, "\u0120though": 996, "\u0120num": 997, "arch": 998, "imes": 999, "ale": 1000, "\u0120Se": 1001, "\u0120If": 1002, "//": 1003, "\u0120Le": 1004, "\u0120ret": 1005, "\u0120ref": 1006, "\u0120trans": 1007, "ner": 1008, "ution": 1009, "ters": 1010, "\u0120take": 1011, "\u0120Cl": 1012, "\u0120conf": 1013, "way": 1014, "ave": 1015, "\u0120going": 1016, "\u0120sl": 1017, "ug": 1018, "\u0120Americ": 1019, "\u0120spec": 1020, "\u0120hand": 1021, "\u0120between": 1022, "ists": 1023, "\u0120De": 1024, "oot": 1025, "It": 1026, "\u0120ear": 1027, "\u0120against": 1028, "\u0120high": 1029, "gan": 1030, "az": 1031, "ather": 1032, "\u0120exp": 1033, "\u0120op": 1034, "\u0120ins": 1035, "\u0120gr": 1036, "\u0120help": 1037, "\u0120requ": 1038, "ets": 1039, "ins": 1040, "\u0120Pro": 1041, "ism": 1042, "\u0120found": 1043, "land": 1044, "ata": 1045, "uss": 1046, "ames": 1047, "\u0120person": 1048, "\u0120great": 1049, "pr": 1050, "\u0120sign": 1051, "\u0120An": 1052, "'ve": 1053, "\u0120somet": 1054, "\u0120ser": 1055, "hip": 1056, "\u0120run": 1057, "\u0120:": 1058, "\u0120ter": 1059, "irect": 1060, "\u0120follow": 1061, "\u0120det": 1062, "ices": 1063, "\u0120find": 1064, "12": 1065, "\u0120mem": 1066, "\u0120cr": 1067, "ered": 1068, "ex": 1069, "\u0120ext": 1070, "uth": 1071, "ense": 1072, "co": 1073, "\u0120team": 1074, "ving": 1075, "ouse": 1076, "ash": 1077, "att": 1078, "ved": 1079, "\u0120system": 1080, "\u0120As": 1081, "der": 1082, "ives": 1083, "min": 1084, "\u0120lead": 1085, "\u0120Bl": 1086, "cent": 1087, "\u0120around": 1088, "\u0120govern": 1089, "\u0120cur": 1090, "velop": 1091, "any": 1092, "\u0120cour": 1093, "alth": 1094, "ages": 1095, "ize": 1096, "\u0120car": 1097, "ode": 1098, "\u0120law": 1099, "\u0120read": 1100, "'m": 1101, "con": 1102, "\u0120real": 1103, "\u0120support": 1104, "\u012012": 1105, "....": 1106, "\u0120really": 1107, "ness": 1108, "\u0120fact": 1109, "\u0120day": 1110, "\u0120both": 1111, "ying": 1112, "\u0120serv": 1113, "\u0120For": 1114, "\u0120three": 1115, "\u0120wom": 1116, "\u0120med": 1117, "ody": 1118, "\u0120They": 1119, "50": 1120, "\u0120exper": 1121, "ton": 1122, "\u0120each": 1123, "akes": 1124, "\u0120che": 1125, "\u0120cre": 1126, "ines": 1127, "\u0120rep": 1128, "19": 1129, "gg": 1130, "illion": 1131, "\u0120grou": 1132, "ute": 1133, "ik": 1134, "We": 1135, "get": 1136, "ER": 1137, "\u0120met": 1138, "\u0120says": 1139, "ox": 1140, "\u0120during": 1141, "ern": 1142, "ized": 1143, "ared": 1144, "\u0120fam": 1145, "ically": 1146, "\u0120happ": 1147, "\u0120Is": 1148, "\u0120char": 1149, "med": 1150, "vent": 1151, "\u0120gener": 1152, "ient": 1153, "ple": 1154, "iet": 1155, "rent": 1156, "11": 1157, "ves": 1158, "ption": 1159, "\u012020": 1160, "formation": 1161, "\u0120cor": 1162, "\u0120offic": 1163, "ield": 1164, "\u0120too": 1165, "ision": 1166, "\u0120inf": 1167, "\u0120Z": 1168, "the": 1169, "oad": 1170, "\u0120public": 1171, "\u0120prog": 1172, "ric": 1173, "**": 1174, "\u0120war": 1175, "\u0120power": 1176, "view": 1177, "\u0120few": 1178, "\u0120loc": 1179, "\u0120different": 1180, "\u0120state": 1181, "\u0120head": 1182, "'ll": 1183, "\u0120poss": 1184, "\u0120stat": 1185, "ret": 1186, "ants": 1187, "\u0120val": 1188, "\u0120iss": 1189, "\u0120cle": 1190, "ivers": 1191, "anc": 1192, "\u0120expl": 1193, "\u0120another": 1194, "\u0120Q": 1195, "\u0120av": 1196, "thing": 1197, "nce": 1198, "Wh": 1199, "\u0120child": 1200, "\u0120since": 1201, "ired": 1202, "less": 1203, "\u0120life": 1204, "\u0120develop": 1205, "ittle": 1206, "\u0120dep": 1207, "\u0120pass": 1208, "\u00e3\u0125": 1209, "\u0120turn": 1210, "orn": 1211, "This": 1212, "bers": 1213, "ross": 1214, "\u0120Ad": 1215, "\u0120fr": 1216, "\u0120resp": 1217, "\u0120second": 1218, "oh": 1219, "\u0120/": 1220, "\u0120disc": 1221, "\u0120&": 1222, "\u0120something": 1223, "\u0120comple": 1224, "\u0120ed": 1225, "\u0120fil": 1226, "\u0120month": 1227, "aj": 1228, "uc": 1229, "\u0120government": 1230, "\u0120without": 1231, "\u0120leg": 1232, "\u0120dist": 1233, "\u0120put": 1234, "\u0120quest": 1235, "ann": 1236, "\u0120prot": 1237, "20": 1238, "\u0120never": 1239, "ience": 1240, "\u0120level": 1241, "\u0120art": 1242, "\u0120things": 1243, "\u0120might": 1244, "\u0120effect": 1245, "\u0120contro": 1246, "\u0120cent": 1247, "\u012018": 1248, "\u0120allow": 1249, "\u0120belie": 1250, "chool": 1251, "ott": 1252, "\u0120incre": 1253, "\u0120feel": 1254, "\u0120result": 1255, "\u0120lot": 1256, "\u0120fun": 1257, "ote": 1258, "\u0120ty": 1259, "erest": 1260, "\u0120contin": 1261, "\u0120using": 1262, "\u0120big": 1263, "201": 1264, "\u0120ask": 1265, "\u0120best": 1266, "\u0120)": 1267, "IN": 1268, "\u0120opp": 1269, "30": 1270, "\u0120number": 1271, "iness": 1272, "St": 1273, "lease": 1274, "\u0120ca": 1275, "\u0120must": 1276, "\u0120direct": 1277, "\u0120gl": 1278, "\u0120<": 1279, "\u0120open": 1280, "\u0120post": 1281, "\u0120come": 1282, "\u0120seem": 1283, "ording": 1284, "\u0120week": 1285, "ately": 1286, "ital": 1287, "\u0120el": 1288, "riend": 1289, "\u0120far": 1290, "\u0120tra": 1291, "inal": 1292, "\u0120pri": 1293, "\u0120US": 1294, "\u0120place": 1295, "\u0120form": 1296, "\u0120told": 1297, "\":": 1298, "ains": 1299, "ature": 1300, "\u0120Trump": 1301, "\u0120stand": 1302, "\u0120#": 1303, "ider": 1304, "\u0120Fr": 1305, "\u0120next": 1306, "\u0120soc": 1307, "\u0120pur": 1308, "\u0120let": 1309, "\u0120little": 1310, "\u0120hum": 1311, "\u0120i": 1312, "ron": 1313, "15": 1314, "\u012015": 1315, "\u0120commun": 1316, "\u0120mark": 1317, "\u0120There": 1318, "\u0120wr": 1319, "\u0120That": 1320, "\u0120information": 1321, "ways": 1322, "\u0120bus": 1323, "app": 1324, "\u0120invest": 1325, "me": 1326, "\u0120hard": 1327, "ained": 1328, "ead": 1329, "\u0120import": 1330, "\u0120appro": 1331, "\u0120test": 1332, "\u0120tri": 1333, "\u0120rest": 1334, "osed": 1335, "\u0120full": 1336, "\u0120care": 1337, "\u0120Sp": 1338, "\u0120case": 1339, "ON": 1340, "\u0120sk": 1341, "\u0120less": 1342, "\u0120+": 1343, "\u0120partic": 1344, "\u0120Pl": 1345, "ably": 1346, "uck": 1347, "ished": 1348, "chn": 1349, "be": 1350, "\u0120list": 1351, "ator": 1352, "\u0120top": 1353, "\u0120adv": 1354, "\u0120Be": 1355, "ruct": 1356, "\u0120dem": 1357, "ration": 1358, "ling": 1359, "gy": 1360, "reen": 1361, "ger": 1362, "\u0120home": 1363, "\u0120left": 1364, "\u0120better": 1365, "\u0120data": 1366, "\u012011": 1367, "\u0120attack": 1368, "\u0120proble": 1369, "line": 1370, "ards": 1371, "\u0120beh": 1372, "ral": 1373, "\u0120How": 1374, "\u0120She": 1375, "arge": 1376, "\u0120--": 1377, "://": 1378, "\u0120bro": 1379, "\u0120Ph": 1380, "ats": 1381, "\u0120build": 1382, "ww": 1383, "ided": 1384, "aim": 1385, "ases": 1386, "ency": 1387, "\u0120main": 1388, "ined": 1389, "\u0120including": 1390, "\u0120{": 1391, "\u0120got": 1392, "\u0120interest": 1393, "\u0120keep": 1394, "\u0120X": 1395, "\u0120eas": 1396, "aining": 1397, "\u0120class": 1398, "\u00e2\u0122\u00a6": 1399, "\u0120No": 1400, "\u0120var": 1401, "\u0120small": 1402, "ample": 1403, "AT": 1404, "\u0120ide": 1405, "\u0120So": 1406, "\u0120rece": 1407, "\u0120polit": 1408, "\u0120mov": 1409, "\u0120plan": 1410, "\u0120percent": 1411, "iving": 1412, "\u0120camp": 1413, "\u0120pay": 1414, "14": 1415, "sc": 1416, "ised": 1417, "\u0120unt": 1418, "oney": 1419, "ploy": 1420, "====": 1421, "\u0120didn": 1422, "\u0120Ind": 1423, "els": 1424, "ertain": 1425, "\u0120pos": 1426, "____": 1427, "iver": 1428, "\u0120process": 1429, "\u0120program": 1430, "ified": 1431, "\u0120Rep": 1432, "16": 1433, "uro": 1434, "ology": 1435, "atter": 1436, "ina": 1437, "\u0120name": 1438, "\u0120All": 1439, "\u0120four": 1440, "\u0120return": 1441, "vious": 1442, "bs": 1443, "\u0120called": 1444, "\u0120move": 1445, "\u0120Sc": 1446, "ird": 1447, "\u0120group": 1448, "\u0120bre": 1449, "\u0120men": 1450, "\u0120cap": 1451, "ten": 1452, "ee": 1453, "\u0120dri": 1454, "leg": 1455, "here": 1456, "uthor": 1457, "\u0120pat": 1458, "\u0120current": 1459, "ides": 1460, "\u0120pop": 1461, "to": 1462, "ention": 1463, "\u0120always": 1464, "\u0120mil": 1465, "\u0120women": 1466, "\u012016": 1467, "\u0120old": 1468, "iven": 1469, "raph": 1470, "\u0120Or": 1471, "ror": 1472, "ently": 1473, "\u0120near": 1474, "\u0120Ex": 1475, "ream": 1476, "sh": 1477, "\u012014": 1478, "\u0120free": 1479, "ission": 1480, "stand": 1481, "\u0120Con": 1482, "ality": 1483, "used": 1484, "13": 1485, "\u0120design": 1486, "\u0120change": 1487, "\u0120chang": 1488, "\u0120bo": 1489, "\u0120vis": 1490, "ember": 1491, "\u0120book": 1492, "ready": 1493, "\u0120kill": 1494, "25": 1495, "pped": 1496, "\u0120away": 1497, "\u0120able": 1498, "\u0120country": 1499, "\u0120const": 1500, "arn": 1501, "\u0120order": 1502, "AR": 1503, "ior": 1504, "ium": 1505, "orth": 1506, "18": 1507, "ailable": 1508, "\u0120sw": 1509, "\u0120million": 1510, "\u012013": 1511, "atic": 1512, "ted": 1513, "\u0120Go": 1514, "\u0120oper": 1515, "eng": 1516, "\u0120thing": 1517, "ajor": 1518, "conom": 1519, "\u0120Comm": 1520, "\u0120why": 1521, "ured": 1522, "ural": 1523, "\u0120school": 1524, "by": 1525, "\u0120Mar": 1526, "\u0120aff": 1527, "\u0120days": 1528, "\u0120ann": 1529, "ush": 1530, "ane": 1531, "If": 1532, "eg": 1533, "\u0120prof": 1534, "\u0120health": 1535, "outh": 1536, "But": 1537, "ional": 1538, ".,": 1539, "\u0120sol": 1540, "\u0120already": 1541, "\u012030": 1542, "\u0120charact": 1543, "He": 1544, "\u0120friend": 1545, "ES": 1546, "ians": 1547, "icle": 1548, "'d": 1549, "\u0120On": 1550, "\u0120least": 1551, "\u0120prom": 1552, "\u0120dr": 1553, "\u0120hist": 1554, "ither": 1555, "\u0120est": 1556, "iqu": 1557, "17": 1558, "son": 1559, "\u0120tell": 1560, "\u0120talk": 1561, "ohn": 1562, "oint": 1563, "lection": 1564, "AN": 1565, "\u0120until": 1566, "augh": 1567, "\u0120later": 1568, "\u0120ve": 1569, "\u0120view": 1570, "ending": 1571, "ived": 1572, "\u0120word": 1573, "ware": 1574, "\u0120cost": 1575, "\u0120enough": 1576, "\u0120give": 1577, "\u0120United": 1578, "\u0120techn": 1579, "arent": 1580, "OR": 1581, "\u0120par": 1582, "\u0120Dr": 1583, "\u01202016": 1584, "rist": 1585, "ering": 1586, "\u0120\u00c2": 1587, "\u0120large": 1588, "side": 1589, "acy": 1590, "ccess": 1591, "\u0120win": 1592, "\u0120important": 1593, "\u0120199": 1594, "\u0120doesn": 1595, "\u012017": 1596, "\u0120business": 1597, "\u0120clear": 1598, "\u0120rese": 1599, "\",": 1600, "ury": 1601, "\u0120equ": 1602, "aster": 1603, "alf": 1604, "\u0120American": 1605, "nect": 1606, "\u0120expect": 1607, "iversity": 1608, "\u0120occ": 1609, "\u0120Fl": 1610, "\u0120kind": 1611, "\u0120mean": 1612, "\u0120past": 1613, "\u0120dev": 1614, "\u0120bas": 1615, "let": 1616, "raft": 1617, "\u0120organ": 1618, "\u0120del": 1619, "\u0120perform": 1620, "\u0120story": 1621, "\u0120season": 1622, "\u0120Col": 1623, "\u0120claim": 1624, "\u0120came": 1625, "\u0120within": 1626, "\u0120line": 1627, "\u0120project": 1628, "\u0120At": 1629, "\u0120control": 1630, "ended": 1631, "\u0120Sy": 1632, "\u0120air": 1633, "ization": 1634, "\u0120*": 1635, "ley": 1636, "\u0120money": 1637, "idd": 1638, "You": 1639, "for": 1640, "\u0120family": 1641, "\u0120making": 1642, "\u0120bit": 1643, "\u0120police": 1644, "\u0120happen": 1645, "\u0120vers": 1646, "ony": 1647, "uff": 1648, "\u0120When": 1649, "\u0120sit": 1650, "ideo": 1651, "lf": 1652, "ison": 1653, "\u0120sure": 1654, "gin": 1655, "\u0120appear": 1656, "\u0120light": 1657, "\u0120es": 1658, "of": 1659, "\u0120water": 1660, "\u0120times": 1661, "not": 1662, "\u0120grow": 1663, "\u0120company": 1664, "\u0120Te": 1665, "ows": 1666, "\u0120mar": 1667, "ource": 1668, "iol": 1669, "arm": 1670, "br": 1671, "\u0120example": 1672, "\u0120conc": 1673, "\u0120fore": 1674, "\u0120To": 1675, "pro": 1676, "EN": 1677, "ries": 1678, "\u012025": 1679, "\u0120Can": 1680, "ney": 1681, "\u0120actually": 1682, "\u0120ever": 1683, "urity": 1684, "aken": 1685, "aps": 1686, "\u0120tax": 1687, "\u0120major": 1688, "ama": 1689, "\u0120often": 1690, "eral": 1691, "\u0120human": 1692, "\u0120job": 1693, "ister": 1694, "\u0120available": 1695, "ocr": 1696, "enn": 1697, "aid": 1698, "ivid": 1699, "\u0120record": 1700, "?\"": 1701, "\u0120sing": 1702, "\u0120Am": 1703, "idence": 1704, "\u0120news": 1705, "ster": 1706, "\u0120econom": 1707, "\u0120following": 1708, "\u0120Br": 1709, "ising": 1710, "\u0120hour": 1711, "most": 1712, "ument": 1713, "\u0120sex": 1714, "\u0120desc": 1715, "\u0120become": 1716, "\u0120Ed": 1717, "\u0120took": 1718, "\u0120having": 1719, "\u0120product": 1720, "ault": 1721, "As": 1722, "aring": 1723, "\u0120means": 1724, "\u0120hop": 1725, "une": 1726, "\u0120cho": 1727, "\u0120certain": 1728, "\u0120non": 1729, "\u0120deal": 1730, "24": 1731, "lement": 1732, "oci": 1733, "ene": 1734, "\u0120side": 1735, "\u0120Pr": 1736, "\u0120May": 1737, "\u0120reason": 1738, "ued": 1739, "ched": 1740, "ulation": 1741, "\u0120elect": 1742, "\u0120official": 1743, "\u0120possible": 1744, "\u0120hold": 1745, "ands": 1746, "ots": 1747, "\u0120city": 1748, "ories": 1749, "\u0120sever": 1750, "\u0120children": 1751, "\u0120once": 1752, "\u0120activ": 1753, "ler": 1754, "\u0120night": 1755, "itions": 1756, "\u0120John": 1757, "ape": 1758, "play": 1759, "\u0120done": 1760, "\u0120lim": 1761, "\u0120working": 1762, "\u0120Pres": 1763, "orld": 1764, "eb": 1765, "\u0120Co": 1766, "\u0120body": 1767, "ails": 1768, "utes": 1769, "\u0120Mr": 1770, "\u0120whether": 1771, "\u0120author": 1772, "rop": 1773, "\u0120proper": 1774, "\u0120seen": 1775, ");": 1776, "\u0120fac": 1777, "\u0120Su": 1778, "\u0120cond": 1779, "iting": 1780, "\u0120course": 1781, "\u0120}": 1782, "----------------": 1783, "aign": 1784, "\u0120event": 1785, "\u0120eng": 1786, "\u0120pot": 1787, "\u0120intern": 1788, "iam": 1789, "\u0120short": 1790, "empt": 1791, "\u00e3\u0124": 1792, "\u0120God": 1793, "ilar": 1794, "80": 1795, "\u0120orig": 1796, "IS": 1797, "ourn": 1798, "ability": 1799, "itive": 1800, "\u0120dam": 1801, "\u0120100": 1802, "\u0120press": 1803, "\u0120doing": 1804, "\u0120protect": 1805, "ring": 1806, "\u0120thought": 1807, "\u0120question": 1808, "rew": 1809, "\u0120War": 1810, "\u0120several": 1811, "\u0120State": 1812, "\u0120given": 1813, "\u0120fund": 1814, "\u0120Tw": 1815, "\u0120went": 1816, "ances": 1817, "work": 1818, "por": 1819, "my": 1820, "40": 1821, "\u0120arg": 1822, "artment": 1823, "ustom": 1824, "\u0120polic": 1825, "\u0120meet": 1826, "\u0120creat": 1827, "22": 1828, "\u0120States": 1829, "\u0120games": 1830, "raw": 1831, "uture": 1832, "\u0120understand": 1833, "urs": 1834, "\u0120Ob": 1835, "lish": 1836, "sy": 1837, "\u0120makes": 1838, "\u0120won": 1839, "agon": 1840, "\u0120htt": 1841, "\u0120love": 1842, "ential": 1843, "\u0120complete": 1844, "par": 1845, "\u0120Im": 1846, "AL": 1847, "\u0120account": 1848, "\u00c2\u0142": 1849, "ored": 1850, "vert": 1851, "\u0120ident": 1852, "\u01202015": 1853, "\u0120others": 1854, "\u0120Min": 1855, "iber": 1856, "verage": 1857, "There": 1858, "itional": 1859, "dd": 1860, "\u0120prob": 1861, "\u0120young": 1862, "\u0120along": 1863, "\u0120according": 1864, "\u0120yet": 1865, "\u0120members": 1866, "\u0120What": 1867, "oid": 1868, "\u0120Man": 1869, "And": 1870, "\u0120among": 1871, "ai": 1872, "\u0120employ": 1873, "\u0120Res": 1874, "\u0120>": 1875, "\u0120invol": 1876, "\u0120low": 1877, "af": 1878, "\u0120Car": 1879, "\u0120hig": 1880, "\u0120One": 1881, "\u0120Sec": 1882, "ination": 1883, "\u0120likely": 1884, "\u0120ant": 1885, "aged": 1886, "\u0120Russ": 1887, "\u0120ben": 1888, "\u0120rele": 1889, "For": 1890, "back": 1891, "\u0120Not": 1892, "\u0120president": 1893, "ball": 1894, "\u0120access": 1895, "ividual": 1896, "\u0120Dem": 1897, "\u0120Euro": 1898, "60": 1899, "\u0120known": 1900, "irl": 1901, "\u0120Gr": 1902, "\u0120early": 1903, "use": 1904, "iety": 1905, "\u00e2\u0122\u0135": 1906, "\u0120fight": 1907, "\u0120sent": 1908, "\u0120today": 1909, "\u0120market": 1910, "\".": 1911, "\u0120based": 1912, "\u0120strong": 1913, "urther": 1914, "\u0120deb": 1915, "mber": 1916, "\u0120problem": 1917, "\u0120death": 1918, "\u0120social": 1919, "imate": 1920, "AS": 1921, "ortun": 1922, "\u0120campaign": 1923, "ery": 1924, "Ch": 1925, "\u0120ey": 1926, "ially": 1927, "\u0120mus": 1928, "wh": 1929, "pos": 1930, "\u0120er": 1931, "\u0120saf": 1932, "\u0120months": 1933, "iron": 1934, "\u0120viol": 1935, "\u0120five": 1936, "\u0120stre": 1937, "\u0120players": 1938, "inc": 1939, "ald": 1940, "year": 1941, "aun": 1942, "\u0120success": 1943, "\u0120present": 1944, "erence": 1945, "\u01202014": 1946, "\u0120sugg": 1947, "\u0120particular": 1948, "\u0120try": 1949, "\u0120suggest": 1950, "\u0120Christ": 1951, "ones": 1952, "\u0120priv": 1953, "23": 1954, "\u0120crit": 1955, "\u0120land": 1956, "\u0120local": 1957, "ify": 1958, "29": 1959, "\u0120aut": 1960, "ED": 1961, "\u0120Gu": 1962, "\u0120mult": 1963, "\u0120political": 1964, "\u0120asked": 1965, "\u0120former": 1966, "itter": 1967, "ript": 1968, "\u0120close": 1969, "\u0120pract": 1970, "\u0120York": 1971, "\u0120getting": 1972, "\u0120across": 1973, "\u0120comb": 1974, "\u0120believe": 1975, "\u0120z": 1976, "\u0120toget": 1977, "\u0120together": 1978, "\u0120Cent": 1979, "irc": 1980, "\u0120individual": 1981, "\u0120Mc": 1982, "27": 1983, "isk": 1984, "\u0120Eng": 1985, "\u0120face": 1986, "\u012024": 1987, "\u0120value": 1988, "\u0120area": 1989, "ev": 1990, "\u0120writ": 1991, "\u0120President": 1992, "\u0120vot": 1993, "\u0120key": 1994, "\u0120mom": 1995, "put": 1996, "\u0120anything": 1997, "\u0120experience": 1998, "attle": 1999, "\u0120mind": 2000, "aff": 2001, "omm": 2002, "\u0120future": 2003, "ged": 2004, "\u0120cut": 2005, "\u0120tot": 2006, "itch": 2007, "\u0120video": 2008, "\u0120investig": 2009, "\u0120net": 2010, "\u0120My": 2011, "rict": 2012, "ien": 2013, ".)": 2014, "\u0120impro": 2015, "though": 2016, "wards": 2017, "\u0120connect": 2018, "\u0120Med": 2019, "selves": 2020, "ensive": 2021, "mb": 2022, "ober": 2023, "ators": 2024, "An": 2025, "\u012050": 2026, "\u0120redu": 2027, "resent": 2028, "\u0120above": 2029, "\u0120fre": 2030, "\u0120Europe": 2031, "sw": 2032, "\u0120amount": 2033, "\u0120App": 2034, "\u0120either": 2035, "\u0120milit": 2036, "\u0120anal": 2037, "\u0120fail": 2038, "\u0120En": 2039, "ales": 2040, "\u0120special": 2041, "\u0120black": 2042, "IT": 2043, "cher": 2044, "\u0120looking": 2045, "\u0120fire": 2046, "yn": 2047, "\u0120almost": 2048, "oon": 2049, "\u0120study": 2050, "\u0120miss": 2051, "ches": 2052, "rown": 2053, "\u0120tre": 2054, "\u0120community": 2055, "\u0120media": 2056, "\u0120food": 2057, "\u0120comes": 2058, "\u0120University": 2059, "\u0120single": 2060, "What": 2061, "uly": 2062, "\u0120half": 2063, "ague": 2064, "hod": 2065, "\u0120Republic": 2066, "\u0120started": 2067, "\u0120quick": 2068, "oto": 2069, "book": 2070, "\u0120issue": 2071, "itor": 2072, "\u0120else": 2073, "\u0120consider": 2074, "26": 2075, "rodu": 2076, "\u0120taken": 2077, "28": 2078, "99": 2079, "\u0120With": 2080, "\u0120true": 2081, "\u0120wa": 2082, "\u0120trad": 2083, "\u0120ago": 2084, "\u0120mess": 2085, "ief": 2086, "\u0120added": 2087, "oke": 2088, "\u0120bad": 2089, "\u0120fav": 2090, "33": 2091, "\u0120similar": 2092, "ask": 2093, "\u0120Don": 2094, "\u0120character": 2095, "orts": 2096, "\u0120House": 2097, "\u0120reported": 2098, "\u0120type": 2099, "val": 2100, "iod": 2101, "\u0120However": 2102, "\u0120targ": 2103, "\u0120entire": 2104, "pping": 2105, "\u0120history": 2106, "\u0120live": 2107, "ffic": 2108, "........": 2109, "ederal": 2110, "\u0120trying": 2111, "\u0120discuss": 2112, "\u0120Har": 2113, "aces": 2114, "lished": 2115, "\u0120self": 2116, "osp": 2117, "rest": 2118, "\u0120room": 2119, "elt": 2120, "\u0120fall": 2121, "olution": 2122, "\u0120et": 2123, "\u0120x": 2124, "\u0120isn": 2125, "\u0120idea": 2126, "bo": 2127, "\u0120sound": 2128, "\u0120Dep": 2129, "\u0120someone": 2130, "cially": 2131, "ully": 2132, "\u0120foc": 2133, "\u0120object": 2134, "ift": 2135, "aper": 2136, "\u0120player": 2137, "\u0120rather": 2138, "\u0120service": 2139, "ashing": 2140, "\u0120Do": 2141, "\u0120Part": 2142, "rug": 2143, "mon": 2144, "ply": 2145, "\u0120mor": 2146, "\u0120nothing": 2147, "\u0120provide": 2148, "IC": 2149, "ung": 2150, "\u0120party": 2151, "\u0120exist": 2152, "\u0120mag": 2153, "70": 2154, "\u0120rul": 2155, "\u0120house": 2156, "\u0120behind": 2157, "\u0120however": 2158, "\u0120World": 2159, "\u0120sum": 2160, "\u0120applic": 2161, "\u0120;": 2162, "\u0120function": 2163, "gr": 2164, "\u0120Pol": 2165, "\u0120front": 2166, "200": 2167, "\u0120series": 2168, "\u0120tem": 2169, "\u0120typ": 2170, "ills": 2171, "\u0120opt": 2172, "\u0120points": 2173, "\u0120below": 2174, "itted": 2175, "\u0120specific": 2176, "\u01202017": 2177, "umb": 2178, "\u0120ra": 2179, "\u0120previous": 2180, "\u0120pret": 2181, "reme": 2182, "\u0120custom": 2183, "\u0120court": 2184, "\u0120Me": 2185, "\u0120repl": 2186, "\u0120whole": 2187, "go": 2188, "cer": 2189, "\u0120treat": 2190, "\u0120Act": 2191, "\u0120probably": 2192, "\u0120learn": 2193, "ender": 2194, "\u0120Ass": 2195, "\u0120version": 2196, "now": 2197, "\u0120check": 2198, "\u0120Cal": 2199, "RE": 2200, "minist": 2201, "On": 2202, "ources": 2203, "\u0120benef": 2204, "\u0120doc": 2205, "\u0120deter": 2206, "\u0120enc": 2207, "\u0120super": 2208, "\u0120address": 2209, "\u0120vict": 2210, "\u01202013": 2211, "\u0120meas": 2212, "tr": 2213, "\u0120field": 2214, "When": 2215, "\u0120signific": 2216, "uge": 2217, "\u0120feat": 2218, "\u0120common": 2219, "load": 2220, "\u0120begin": 2221, "\u0120bring": 2222, "\u0120action": 2223, "erman": 2224, "\u0120describ": 2225, "\u0120indust": 2226, "\u0120wanted": 2227, "ried": 2228, "ming": 2229, "\u0120attempt": 2230, "45": 2231, "fer": 2232, "\u0120due": 2233, "ression": 2234, "##": 2235, "\u0120shall": 2236, "\u0120six": 2237, "oo": 2238, "\u0120step": 2239, "\u0120pub": 2240, "\u0120himself": 2241, "\u012023": 2242, "\u0120cop": 2243, "\u0120dest": 2244, "\u0120stop": 2245, "AC": 2246, "ibility": 2247, "\u0120lab": 2248, "icult": 2249, "\u0120hours": 2250, "\u0120create": 2251, "\u0120further": 2252, "\u0120America": 2253, "\u0120City": 2254, "\u0120dou": 2255, "head": 2256, "ST": 2257, "\u0120North": 2258, "cing": 2259, "\u0120national": 2260, "ule": 2261, "\u0120Inst": 2262, "\u0120taking": 2263, "\u0120Qu": 2264, "irt": 2265, "\u0120red": 2266, "\u0120research": 2267, "viron": 2268, "\u0120Ge": 2269, "\u0120break": 2270, "ana": 2271, "\u0120space": 2272, "aterial": 2273, "\u0120recent": 2274, "\u0120Ab": 2275, "\u0120general": 2276, "\u0120hit": 2277, "\u0120period": 2278, "\u0120everything": 2279, "ively": 2280, "\u0120phys": 2281, "\u0120saying": 2282, "anks": 2283, "\u0120cou": 2284, "\u0120cult": 2285, "aced": 2286, "eal": 2287, "uation": 2288, "\u0120coun": 2289, "lu": 2290, "\u0120include": 2291, "\u0120position": 2292, "\u0120After": 2293, "\u0120Canad": 2294, "\u0120Em": 2295, "\u0120imm": 2296, "\u0120Red": 2297, "\u0120pick": 2298, "\u0120compl": 2299, "\u0120matter": 2300, "reg": 2301, "ext": 2302, "angu": 2303, "isc": 2304, "ole": 2305, "aut": 2306, "\u0120compet": 2307, "eed": 2308, "fect": 2309, "\u012021": 2310, "\u0120Sen": 2311, "\u0120These": 2312, "asing": 2313, "\u0120cannot": 2314, "\u0120init": 2315, "\u0120relations": 2316, "ached": 2317, "\u0120bar": 2318, "\u012040": 2319, "\u0120TH": 2320, "\u01202012": 2321, "\u0120vol": 2322, "\u0120ground": 2323, "\u0120security": 2324, "\u0120upd": 2325, "ilt": 2326, "35": 2327, "\u0120concern": 2328, "\u0120Just": 2329, "\u0120white": 2330, "\u0120seems": 2331, "\u0120Her": 2332, "pecially": 2333, "ients": 2334, "\u0120announ": 2335, "\u0120fig": 2336, "ights": 2337, "\u0120stri": 2338, "like": 2339, "ids": 2340, "\u0120sus": 2341, "\u0120watch": 2342, "\u0120\u00e2": 2343, "\u0120wind": 2344, "\u0120Cont": 2345, "\u0120itself": 2346, "\u0120mass": 2347, "Al": 2348, "yle": 2349, "ique": 2350, "\u0120National": 2351, "\u0120abs": 2352, "\u0120pack": 2353, "\u0120outside": 2354, "\u0120anim": 2355, "\u0120pain": 2356, "eter": 2357, "\u0120manag": 2358, "duct": 2359, "ogn": 2360, "\u0120]": 2361, "\u0120Sept": 2362, "sec": 2363, "off": 2364, "\u0120Jan": 2365, "\u0120foot": 2366, "ades": 2367, "\u0120third": 2368, "\u0120mot": 2369, "\u0120evidence": 2370, "inton": 2371, "\u0120threat": 2372, "apt": 2373, "ples": 2374, "cle": 2375, "\u0120lo": 2376, "\u0120decl": 2377, "\u0120item": 2378, "medi": 2379, "\u0120represent": 2380, "omb": 2381, "amer": 2382, "\u0120significant": 2383, "ograph": 2384, "su": 2385, "\u0120cal": 2386, "ires": 2387, "0000": 2388, "ID": 2389, "AM": 2390, "\u0120simply": 2391, "\u0120longer": 2392, "\u0120file": 2393, "OT": 2394, "che": 2395, "So": 2396, "ateg": 2397, "org": 2398, "\u0120His": 2399, "\u0120ener": 2400, "\u0120dom": 2401, "\u0120upon": 2402, "ili": 2403, "\":\"": 2404, "\u0120themselves": 2405, "\u0120coming": 2406, "\u0120quite": 2407, "\u0120difficult": 2408, "\u0120Bar": 2409, "ilities": 2410, "rel": 2411, "ends": 2412, "cial": 2413, "64": 2414, "\u0120woman": 2415, "rap": 2416, "yr": 2417, "\u0120necess": 2418, "ips": 2419, "\u0120text": 2420, "\u0120require": 2421, "\u0120military": 2422, "\u0120review": 2423, "\u0120respons": 2424, "75": 2425, "\u0120subject": 2426, "\u0120instead": 2427, "\u0120issues": 2428, "\u0120gen": 2429, "\",\"": 2430, "\u0120minutes": 2431, "\u0120weap": 2432, "ray": 2433, "amed": 2434, "time": 2435, "bl": 2436, "How": 2437, "\u0120code": 2438, "\u0120Sm": 2439, "\u0120higher": 2440, "\u0120Ste": 2441, "ris": 2442, "\u0120page": 2443, "\u0120students": 2444, "\u0120Intern": 2445, "\u0120method": 2446, "\u0120Aug": 2447, "\u0120Per": 2448, "\u0120Ag": 2449, "\u0120policy": 2450, "\u0120Sw": 2451, "\u0120exec": 2452, "\u0120accept": 2453, "ume": 2454, "ribut": 2455, "\u0120words": 2456, "\u0120final": 2457, "\u0120changes": 2458, "\u0120Democr": 2459, "\u0120friends": 2460, "\u0120respect": 2461, "\u0120ep": 2462, "\u0120compan": 2463, "ivil": 2464, "\u0120damage": 2465, "****": 2466, "ogle": 2467, "vironment": 2468, "\u0120neg": 2469, "ental": 2470, "\u0120ap": 2471, "\u0120total": 2472, "ival": 2473, "!\"": 2474, "lim": 2475, "\u0120needs": 2476, "\u0120agre": 2477, "\u0120development": 2478, "\u0120age": 2479, "iple": 2480, "21": 2481, "\u0120results": 2482, "\u0120Af": 2483, "Sh": 2484, "\u0120gun": 2485, "\u0120Obama": 2486, "roll": 2487, "\u0120@": 2488, "\u0120rights": 2489, "\u0120Brit": 2490, "\u0120running": 2491, "\u0120wasn": 2492, "\u0120port": 2493, "\u0120rate": 2494, "\u0120pretty": 2495, "\u0120target": 2496, "\u0120saw": 2497, "\u0120circ": 2498, "\u0120works": 2499, "icro": 2500, "alt": 2501, "over": 2502, "www": 2503, "That": 2504, "lier": 2505, "\u0120everyone": 2506, "ude": 2507, "\u0120pie": 2508, "iddle": 2509, "rael": 2510, "\u0120rad": 2511, "\u0120block": 2512, "\u0120walk": 2513, "To": 2514, "\u00e3\u0123": 2515, "nes": 2516, "\u0120Aust": 2517, "aul": 2518, "rote": 2519, "\u0120South": 2520, "ession": 2521, "oph": 2522, "\u0120shows": 2523, "\u0120site": 2524, "\u0120jo": 2525, "\u0120risk": 2526, "clus": 2527, "lt": 2528, "\u0120inj": 2529, "iding": 2530, "\u0120Spe": 2531, "\u0120chall": 2532, "irm": 2533, "\u012022": 2534, "itting": 2535, "str": 2536, "\u0120hy": 2537, "LE": 2538, "key": 2539, "\u0120began": 2540, "atur": 2541, "ashington": 2542, "lam": 2543, "\u0120Dav": 2544, "bit": 2545, "\u0120size": 2546, "\u0120Par": 2547, "38": 2548, "ournal": 2549, "face": 2550, "\u0120decision": 2551, "\u0120larg": 2552, "\u0120jud": 2553, "rect": 2554, "\u0120continue": 2555, "\u0120Oct": 2556, "overed": 2557, "\u0120Int": 2558, "========": 2559, "\u0120parent": 2560, "\u0120Will": 2561, "\u0120easy": 2562, "\u0120drug": 2563, "anger": 2564, "\u0120sense": 2565, "\u0120di": 2566, "iday": 2567, "\u0120energy": 2568, "istic": 2569, "\u0120associ": 2570, "arter": 2571, "obal": 2572, "eks": 2573, "\u0120El": 2574, "urch": 2575, "\u0120girl": 2576, "oe": 2577, "itle": 2578, "\u012028": 2579, "\u0120Che": 2580, "\u0120request": 2581, "\u0120soon": 2582, "\u0120host": 2583, "ky": 2584, "\u0120states": 2585, "omes": 2586, "\u0120material": 2587, "lex": 2588, "\u0120moment": 2589, "\u0120answ": 2590, "onse": 2591, "\u0120especially": 2592, "\u0120norm": 2593, "\u0120services": 2594, "pite": 2595, "ran": 2596, "\u0120role": 2597, "44": 2598, "):": 2599, "\u0120cred": 2600, "Cl": 2601, "________": 2602, "\u0120mat": 2603, "\u0120log": 2604, "\u0120Clinton": 2605, "OU": 2606, "\u0120office": 2607, "\u012026": 2608, "\u0120charg": 2609, "\u0120track": 2610, "ma": 2611, "\u0120heart": 2612, "\u0120ball": 2613, "\u0120personal": 2614, "\u0120building": 2615, "na": 2616, "set": 2617, "body": 2618, "\u0120Black": 2619, "\u0120increase": 2620, "itten": 2621, "\u0120needed": 2622, "36": 2623, "32": 2624, "=\"": 2625, "\u0120lost": 2626, "\u0120became": 2627, "\u0120groups": 2628, "\u0120Mus": 2629, "\u0120wrote": 2630, "\u0120Pe": 2631, "\u0120prop": 2632, "joy": 2633, "\u00c3\u00a9": 2634, "\u0120White": 2635, "\u0120dead": 2636, ".'": 2637, "\u0120http": 2638, "\u0120webs": 2639, "OS": 2640, "\u0120inside": 2641, "\u0120wrong": 2642, "\u0120statement": 2643, "\u0120...": 2644, "yl": 2645, "\u0120film": 2646, "\u0120music": 2647, "\u0120share": 2648, "ification": 2649, "\u0120release": 2650, "\u0120forward": 2651, "\u0120stay": 2652, "\u0120comput": 2653, "itte": 2654, "ser": 2655, "\u0120original": 2656, "\u0120card": 2657, "\u0120cand": 2658, "\u0120div": 2659, "atural": 2660, "\u0120favor": 2661, "OM": 2662, "\u0120cases": 2663, "uses": 2664, "\u0120section": 2665, "\u0120leave": 2666, "ging": 2667, "oved": 2668, "\u0120Washington": 2669, "39": 2670, "\u0120Gl": 2671, "\u0120required": 2672, "action": 2673, "apan": 2674, "oor": 2675, "iter": 2676, "\u0120King": 2677, "\u0120countries": 2678, "\u0120German": 2679, "lling": 2680, "\u012027": 2681, "34": 2682, "\u0120questions": 2683, "\u0120prim": 2684, "\u0120cell": 2685, "\u0120shoot": 2686, "\u0120anyone": 2687, "\u0120West": 2688, "\u0120affect": 2689, "epend": 2690, "\u0120online": 2691, "\u0120Israel": 2692, "\u0120September": 2693, "\u0120ability": 2694, "\u0120content": 2695, "ises": 2696, "\u0120reve": 2697, "\u0120laun": 2698, "\u0120indic": 2699, "\u0120force": 2700, "cast": 2701, "\u0120sold": 2702, "aving": 2703, "fl": 2704, "\u0120soft": 2705, "\u0120companies": 2706, "ceed": 2707, "\u0120article": 2708, "\u0120aud": 2709, "\u0120rev": 2710, "\u0120educ": 2711, "\u0120playing": 2712, "05": 2713, "\u0120held": 2714, "ctor": 2715, "\u0120released": 2716, "\u0120federal": 2717, "37": 2718, "\u0120administ": 2719, "\u0120interview": 2720, "\u0120install": 2721, "\u0120received": 2722, "\u0120source": 2723, "uk": 2724, "Ph": 2725, "\u0120serious": 2726, "\u0120created": 2727, "\u0120cause": 2728, "\u0120immedi": 2729, "\u0120defin": 2730, "uel": 2731, "\u0120Department": 2732, "ctions": 2733, "\u0120Cour": 2734, "\u0120Now": 2735, "ze": 2736, "ites": 2737, "itution": 2738, "\u0120late": 2739, "\u0120speak": 2740, "ners": 2741, "\u0120legal": 2742, "ari": 2743, "\u0120Cor": 2744, "\u0120weeks": 2745, "\u0120model": 2746, "\u0120pred": 2747, "\u0120exact": 2748, "BC": 2749, "\u0120By": 2750, "ING": 2751, "osing": 2752, "\u0120takes": 2753, "\u0120regard": 2754, "\u0120opportun": 2755, "\u0120price": 2756, "\u0120198": 2757, "\u0120Apr": 2758, "fully": 2759, "\u0120ord": 2760, "\u0120problems": 2761, "ruction": 2762, "ham": 2763, "\u0120Count": 2764, "lege": 2765, "\u0120leaders": 2766, "ET": 2767, "lev": 2768, "\u0120deep": 2769, "ological": 2770, "ese": 2771, "haps": 2772, "\u0120Some": 2773, "\u0120pers": 2774, "\u0120contract": 2775, "\u0120relationship": 2776, "sp": 2777, "oud": 2778, "\u0120base": 2779, "48": 2780, "mit": 2781, "Ad": 2782, "ancial": 2783, "\u0120consum": 2784, "\u0120potential": 2785, "\u0120langu": 2786, "rem": 2787, "eth": 2788, "\u0120relig": 2789, "ressed": 2790, "66": 2791, "\u0120link": 2792, "\u0120lower": 2793, "ayer": 2794, "\u0120June": 2795, "\u0120fem": 2796, "unt": 2797, "erc": 2798, "urd": 2799, "\u0120contact": 2800, "\u0120ill": 2801, "\u0120mother": 2802, "\u0120estab": 2803, "htt": 2804, "\u0120March": 2805, "\u0120Bro": 2806, "\u0120China": 2807, "\u012029": 2808, "\u0120squ": 2809, "\u0120provided": 2810, "\u0120average": 2811, "asons": 2812, "\u01202011": 2813, "\u0120exam": 2814, "lin": 2815, "55": 2816, "ned": 2817, "\u0120perfect": 2818, "\u0120tou": 2819, "alse": 2820, "ux": 2821, "\u0120buy": 2822, "\u0120shot": 2823, "\u0120collect": 2824, "\u0120phot": 2825, "\u0120played": 2826, "\u0120surpr": 2827, "\u0120officials": 2828, "\u0120simple": 2829, "avy": 2830, "\u0120industry": 2831, "\u0120hands": 2832, "ground": 2833, "\u0120pull": 2834, "\u0120round": 2835, "\u0120user": 2836, "\u0120range": 2837, "uary": 2838, "\u0120private": 2839, "ops": 2840, "ees": 2841, "\u0120ways": 2842, "\u0120Mich": 2843, "\u0120veh": 2844, "\u0120except": 2845, "\u0120terms": 2846, "imum": 2847, "pper": 2848, "ION": 2849, "ores": 2850, "\u0120Dragon": 2851, "oul": 2852, "\u0120den": 2853, "\u0120performance": 2854, "\u0120bill": 2855, "cil": 2856, "47": 2857, "\u0120environment": 2858, "\u0120exc": 2859, "add": 2860, "\u0120worth": 2861, "\u0120pict": 2862, "\u0120chance": 2863, "\u01202018": 2864, "bor": 2865, "\u0120speed": 2866, "iction": 2867, "\u0120alleg": 2868, "\u0120Japan": 2869, "atory": 2870, "reet": 2871, "\u0120match": 2872, "\u0120II": 2873, "\u0120stru": 2874, "order": 2875, "\u0120ste": 2876, "\u0120living": 2877, "\u0120struct": 2878, "ino": 2879, "\u0120separ": 2880, "hern": 2881, "\u0120response": 2882, "\u0120enjoy": 2883, "\u0120via": 2884, "AD": 2885, "uments": 2886, "acebook": 2887, "\u0120member": 2888, "ibr": 2889, "izing": 2890, "\u0120tool": 2891, "\u0120Mon": 2892, "\u0120While": 2893, "hood": 2894, "\u0120Ang": 2895, "\u0120Def": 2896, "\u0120offer": 2897, "Tr": 2898, "aur": 2899, "\u0120turned": 2900, "\u0120July": 2901, "down": 2902, "anced": 2903, "\u0120recently": 2904, "\u0120Ear": 2905, "\u0120ce": 2906, "\u0120Star": 2907, "\u0120Cong": 2908, "rought": 2909, "\u0120blood": 2910, "\u0120hope": 2911, "\u0120comment": 2912, "aint": 2913, "\u0120arri": 2914, "iles": 2915, "\u0120particip": 2916, "ought": 2917, "ription": 2918, "08": 2919, "49": 2920, "\u0120gave": 2921, "\u0120select": 2922, "\u0120killed": 2923, "sych": 2924, "\u0120goes": 2925, "ij": 2926, "\u0120coll": 2927, "\u0120impact": 2928, "atives": 2929, "\u0120Ser": 2930, "09": 2931, "\u0120August": 2932, "\u0120boy": 2933, "de": 2934, "\u0120Des": 2935, "\u0120felt": 2936, "US": 2937, "\u0120expected": 2938, "\u0120image": 2939, "\u0120Mark": 2940, "ccording": 2941, "oice": 2942, "EC": 2943, "\u0120Mag": 2944, "ened": 2945, "hold": 2946, "\u0120Post": 2947, "\u0120prevent": 2948, "No": 2949, "\u0120involved": 2950, "\u0120eyes": 2951, "\u0120quickly": 2952, "At": 2953, "unk": 2954, "\u0120behav": 2955, "\u0120ur": 2956, "\u0120led": 2957, "come": 2958, "ey": 2959, "\u0120candid": 2960, "\u0120earlier": 2961, "\u0120focus": 2962, "ety": 2963, "Pro": 2964, "ledge": 2965, "ixed": 2966, "illed": 2967, "\u0120popular": 2968, "AP": 2969, "\u0120sett": 2970, "light": 2971, "\u0120various": 2972, "inks": 2973, "\u0120levels": 2974, "\u0120road": 2975, "ellig": 2976, "ables": 2977, "hel": 2978, "ittee": 2979, "\u0120Gener": 2980, "ype": 2981, "\u0120heard": 2982, "icles": 2983, "\u0120mis": 2984, "\u0120users": 2985, "\u0120San": 2986, "\u0120improve": 2987, "\u0120father": 2988, "\u0120search": 2989, "They": 2990, "vil": 2991, "\u0120profess": 2992, "\u0120knew": 2993, "\u0120loss": 2994, "\u0120events": 2995, "65": 2996, "\u0120billion": 2997, "07": 2998, "02": 2999, "\u0120News": 3000, "\u0120AM": 3001, "\u0120cover": 3002, "where": 3003, "ension": 3004, "\u0120bott": 3005, "\u0120areas": 3006, "ences": 3007, "ope": 3008, "\u0120Twitter": 3009, "ael": 3010, "\u0120gets": 3011, "\u0120Google": 3012, "\u0120sn": 3013, "iant": 3014, "\u0120vote": 3015, "\u0120nearly": 3016, "\u0120included": 3017, "\u0120recogn": 3018, "zz": 3019, "mm": 3020, "aled": 3021, "\u0120happened": 3022, "04": 3023, "\u0120hot": 3024, "\u0120whose": 3025, "\u0120civil": 3026, "\u0120suff": 3027, "oes": 3028, "itiz": 3029, "\u0120Syri": 3030, "\u0120respond": 3031, "\u0120hon": 3032, "\u0120features": 3033, "\u0120economic": 3034, "\u0120April": 3035, "rim": 3036, "\u0120technology": 3037, "\u0120option": 3038, "aging": 3039, "\u0120purch": 3040, "Re": 3041, "\u0120lat": 3042, "chie": 3043, "isl": 3044, "\u0120recomm": 3045, "uf": 3046, "\u0120training": 3047, "\u0120effects": 3048, "\u0120fast": 3049, "\u01202010": 3050, "\u0120occur": 3051, "\u0120website": 3052, "\u0120email": 3053, "\u0120sens": 3054, "ech": 3055, "\u0120oil": 3056, "\u0120influ": 3057, "\u0120currently": 3058, "\u0120Sch": 3059, "\u0120Add": 3060, "\u0120goal": 3061, "\u0120scient": 3062, "\u0120conv": 3063, "100": 3064, "emy": 3065, "\u0120decided": 3066, "\u0120travel": 3067, "\u0120mention": 3068, "LL": 3069, "03": 3070, "\u0120election": 3071, "\u0120phone": 3072, "\u0120looks": 3073, "\u0120situation": 3074, "\u0120cy": 3075, "\u0120hor": 3076, "bed": 3077, "\u0120Court": 3078, "aily": 3079, "aves": 3080, "\u0120quality": 3081, "\u0120Comp": 3082, "wise": 3083, "\u0120table": 3084, "\u0120staff": 3085, "\u0120Wind": 3086, "ett": 3087, "\u0120tried": 3088, "idered": 3089, "\u0120addition": 3090, "\u0120box": 3091, "\u0120lack": 3092, "arily": 3093, "\u0120wide": 3094, "\u0120mid": 3095, "\u0120board": 3096, "ysis": 3097, "\u0120anti": 3098, "ha": 3099, "\u0120dig": 3100, "ening": 3101, "\u0120dro": 3102, "Con": 3103, "68": 3104, "\u0120slow": 3105, "based": 3106, "sequ": 3107, "\u0120path": 3108, "Ex": 3109, "aker": 3110, "\u0120worked": 3111, "\u0120pen": 3112, "\u0120engine": 3113, "\u0120looked": 3114, "\u0120Super": 3115, "\u0120Serv": 3116, "\u0120victim": 3117, "Un": 3118, "\u0120property": 3119, "\u0120introdu": 3120, "\u0120execut": 3121, "\u0120PM": 3122, "Le": 3123, "\u0120color": 3124, "\u0120More": 3125, "\u012060": 3126, "\u0120network": 3127, "\u0120date": 3128, "cul": 3129, "idge": 3130, "\u0120extra": 3131, "31": 3132, "\u0120sle": 3133, "67": 3134, "\u0120wond": 3135, "\u0120reports": 3136, "just": 3137, "\u0120Austral": 3138, "\u0120capital": 3139, "\u0120ens": 3140, "\u0120command": 3141, "\u0120allowed": 3142, "\u0120prep": 3143, "\u0120capt": 3144, "hib": 3145, "\u0120numbers": 3146, "chan": 3147, "\u0120fair": 3148, "mp": 3149, "oms": 3150, "\u0120reach": 3151, "With": 3152, "tain": 3153, "\u0120broad": 3154, "\u0120couple": 3155, "ecause": 3156, "lying": 3157, "\u0120Feb": 3158, "\u0120screen": 3159, "\u0120lives": 3160, "\u0120prior": 3161, "\u0120Congress": 3162, "Ar": 3163, "\u0120approach": 3164, "\u0120emer": 3165, "aries": 3166, "\u0120Dis": 3167, "serv": 3168, "\u0120Ne": 3169, "\u0120built": 3170, "cies": 3171, "\u0120repe": 3172, "\u0120rules": 3173, "force": 3174, "\u0120Pal": 3175, "\u0120financial": 3176, "\u0120considered": 3177, "\u0120Char": 3178, "nces": 3179, "\u0120IS": 3180, "\u0120brought": 3181, "\u0120bi": 3182, "iers": 3183, "\u0120Sim": 3184, "OP": 3185, "\u0120products": 3186, "\u0120visit": 3187, "\u0120document": 3188, "\u0120conduct": 3189, "\u0120completely": 3190, "ining": 3191, "\u0120Calif": 3192, "ibly": 3193, "\u0120written": 3194, "\u0120TV": 3195, "ements": 3196, "\u0120draw": 3197, "One": 3198, "\u0120published": 3199, "\u0120secret": 3200, "rain": 3201, "het": 3202, "\u0120Facebook": 3203, "onday": 3204, "\u0120Up": 3205, "\u0120sexual": 3206, "\u0120thous": 3207, "\u0120Pat": 3208, "\u0120ess": 3209, "\u0120standard": 3210, "\u0120arm": 3211, "ges": 3212, "ection": 3213, "\u0120fell": 3214, "\u0120foreign": 3215, "ani": 3216, "\u0120Friday": 3217, "\u0120regular": 3218, "inary": 3219, "\u0120increased": 3220, "\u0120usually": 3221, "\u0120demon": 3222, "\u0120dark": 3223, "\u0120additional": 3224, "rol": 3225, "\u0120Of": 3226, "\u0120production": 3227, "!!": 3228, "undred": 3229, "\u0120international": 3230, "idents": 3231, "\u0120Free": 3232, "roup": 3233, "\u0120race": 3234, "\u0120mach": 3235, "\u0120huge": 3236, "All": 3237, "lear": 3238, "ovember": 3239, "\u0120town": 3240, "\u0120attention": 3241, "\u0120Off": 3242, "yond": 3243, "\u0120Then": 3244, "field": 3245, "\u0120terror": 3246, "raz": 3247, "\u0120Bo": 3248, "\u0120meeting": 3249, "\u0120Park": 3250, "\u0120arrest": 3251, "\u0120fear": 3252, "\u0120aw": 3253, "\u0120Val": 3254, "oring": 3255, "',": 3256, "\u0120extreme": 3257, "arr": 3258, "\u0120workers": 3259, "After": 3260, "\u012031": 3261, "net": 3262, "ament": 3263, "\u0120directly": 3264, "\u0120population": 3265, "ube": 3266, "\u0120October": 3267, "\u0120IN": 3268, "\u0120January": 3269, "59": 3270, "\u0120David": 3271, "\u0120cross": 3272, "cember": 3273, "\u0120First": 3274, "\u0120message": 3275, "irit": 3276, "\u0120nation": 3277, "\u0120poll": 3278, "isions": 3279, "\u0120answer": 3280, "ny": 3281, "isode": 3282, "\u0120carry": 3283, "\u0120Russia": 3284, "\u0120hear": 3285, "ength": 3286, "roy": 3287, "\u0120natural": 3288, "inally": 3289, "\u0120dog": 3290, "mitted": 3291, "\u0120trade": 3292, "\u0120subst": 3293, "\u0120multiple": 3294, "\u0120Afric": 3295, "\u0120fans": 3296, "\u0120sort": 3297, "\u0120global": 3298, "ication": 3299, "\u0120Wed": 3300, "ara": 3301, "\u0120achie": 3302, "\u0120language": 3303, "vey": 3304, "\u0120tal": 3305, "\u0120necessary": 3306, "\u0120details": 3307, "\u0120sen": 3308, "\u0120Sund": 3309, "\u0120Reg": 3310, "\u0120Rec": 3311, "06": 3312, "\u0120sil": 3313, "ressive": 3314, "\u0120medical": 3315, "unch": 3316, "ornia": 3317, "\u0120und": 3318, "fort": 3319, "ocks": 3320, "\u0120Monday": 3321, "uesday": 3322, "craft": 3323, "77": 3324, "urt": 3325, "\u0120ver": 3326, "\u0120Hill": 3327, "\u0120receive": 3328, "\u0120morning": 3329, "estern": 3330, "\u0120bank": 3331, "\u0120sat": 3332, "irth": 3333, "\u0120High": 3334, "\u0120device": 3335, "\u0120THE": 3336, "\u0120Center": 3337, "\u0120safe": 3338, "\u0120ple": 3339, "\u0120Canada": 3340, "\u0120systems": 3341, "\u0120assist": 3342, "\u0120surv": 3343, "\u0120battle": 3344, "\u0120Soc": 3345, "vertis": 3346, "She": 3347, "\u0120paper": 3348, "\u0120growth": 3349, "\u0120cast": 3350, "Sc": 3351, "\u0120plans": 3352, "lled": 3353, "\u0120parts": 3354, "\u0120wall": 3355, "\u0120movement": 3356, "\u0120practice": 3357, "imately": 3358, "\u0120display": 3359, "\u0120sometimes": 3360, "omp": 3361, "\u0120Paul": 3362, "\u0120Yes": 3363, "king": 3364, "58": 3365, "oly": 3366, "\u0120son": 3367, "\u0120avoid": 3368, "okes": 3369, "\u0120Jew": 3370, "\u0120towards": 3371, "asc": 3372, "\u0120//": 3373, "\u0120Kore": 3374, "\u0120talking": 3375, "\u0120correct": 3376, "\u0120spent": 3377, "icks": 3378, "iable": 3379, "eared": 3380, "\u0120term": 3381, "\u0120wants": 3382, "oming": 3383, "\u0120ut": 3384, "\u0120doub": 3385, "\u0120forces": 3386, "\u0120please": 3387, "69": 3388, "\u0120November": 3389, "atform": 3390, "ondon": 3391, "\u0120ones": 3392, "\u0120immediately": 3393, "\u0120Russian": 3394, "\u0120Met": 3395, "\u0120deg": 3396, "\u0120parents": 3397, "CH": 3398, "\u0120Americans": 3399, "aly": 3400, "\u0120Mod": 3401, "\u0120shown": 3402, "\u0120conditions": 3403, "\u0120stuff": 3404, "\u0120reb": 3405, "\u0120Your": 3406, "\u0120includes": 3407, "nown": 3408, "\u0120Sam": 3409, "\u0120experien": 3410, "mission": 3411, "\u0120Even": 3412, "aught": 3413, "\u0120announced": 3414, "\u0120Republican": 3415, "\u0120determin": 3416, "\u0120described": 3417, "\u0120County": 3418, "()": 3419, "\u0120door": 3420, "\u0120changed": 3421, "\u0120neigh": 3422, "\u0120Here": 3423, "\u0120clean": 3424, "\u0120pan": 3425, "\u0120December": 3426, "\u0120European": 3427, "iring": 3428, "apter": 3429, "\u0120club": 3430, "\u0120Tuesday": 3431, "\u0120paid": 3432, "\u0120Net": 3433, "\u0120attacks": 3434, "\u0120characters": 3435, "\u0120alone": 3436, "\u0120director": 3437, "dom": 3438, "\u012035": 3439, "\u0120load": 3440, "\u0120rout": 3441, "\u0120California": 3442, "\u0120finally": 3443, "\u0120rac": 3444, "\u0120contr": 3445, "\u0120exactly": 3446, "resh": 3447, "pri": 3448, "\u0120Islam": 3449, "\u0120nature": 3450, "\u0120career": 3451, "\u0120latest": 3452, "\u0120convers": 3453, "\u0120Sl": 3454, "pose": 3455, "cient": 3456, "\u0120Inc": 3457, "ivity": 3458, "88": 3459, "\u0120Att": 3460, "\u0120Mor": 3461, "nesday": 3462, "\u0120weight": 3463, "ken": 3464, "\u0120note": 3465, "\u0120teams": 3466, "\u0120\\": 3467, "airs": 3468, "\u0120Green": 3469, "\u0120hundred": 3470, "onent": 3471, "\u0120streng": 3472, "\u0120consist": 3473, "icated": 3474, "\u0120regul": 3475, "\u0120lic": 3476, "astic": 3477, "\u0120ten": 3478, "ursday": 3479, "elligence": 3480, "ously": 3481, "\u0120UK": 3482, "BI": 3483, "\u0120costs": 3484, "\u0120independ": 3485, "\u0120AP": 3486, "\u0120normal": 3487, "\u0120hom": 3488, "\u0120obvious": 3489, "\u0120swe": 3490, "\u0120star": 3491, "\u0120ready": 3492, "acher": 3493, "\u0120implement": 3494, "gest": 3495, "\u0120song": 3496, "\u0120Get": 3497, "\u0120Lab": 3498, "\u0120interesting": 3499, "using": 3500, "\u0120giving": 3501, "\u0120Sunday": 3502, "\u0120etc": 3503, "\u0120middle": 3504, "\u0120remember": 3505, "right": 3506, "osition": 3507, "utions": 3508, "\u0120max": 3509, "46": 3510, "\u0120yourself": 3511, "\u0120demand": 3512, "\u0120treatment": 3513, "\u0120danger": 3514, "\u0120Cons": 3515, "\u0120guy": 3516, "\u0120British": 3517, "\u0120physical": 3518, "\u0120related": 3519, "\u0120remain": 3520, "\u0120couldn": 3521, "\u0120refer": 3522, "\u0120citiz": 3523, "box": 3524, "ENT": 3525, "board": 3526, "\u0120inn": 3527, "IG": 3528, "ero": 3529, "\u0120Street": 3530, "ospital": 3531, "rench": 3532, "chers": 3533, "\u0120stra": 3534, "OL": 3535, "ager": 3536, "\u0120AN": 3537, "\u0120easily": 3538, "IA": 3539, "enge": 3540, "iny": 3541, "\u0120clos": 3542, "ocked": 3543, "\u0120uses": 3544, "\u0120Coun": 3545, "Im": 3546, "uild": 3547, "??": 3548, "more": 3549, "\u0120ang": 3550, "\u0120write": 3551, "olute": 3552, "57": 3553, "\u0120leader": 3554, "\u0120reading": 3555, "</": 3556, "\u0120autom": 3557, "ests": 3558, "43": 3559, "\u0120legisl": 3560, "\u0120Gold": 3561, "\u0120designed": 3562, "\u0120ST": 3563, "\u0120Leg": 3564, "ares": 3565, "\u0120beaut": 3566, "\u0120Tex": 3567, "\u0120appears": 3568, "\u0120strugg": 3569, "\u0120Rom": 3570, "\u012000": 3571, "\u0120choice": 3572, "\u0120particularly": 3573, "\u0120From": 3574, "oper": 3575, "\u0120London": 3576, "anned": 3577, "\u0120allows": 3578, "obile": 3579, "\u0120difference": 3580, "\u00e2\u0122\u00a2": 3581, "\u0120View": 3582, "\u0120Wednesday": 3583, "\u0120although": 3584, "\u0120relative": 3585, "\u0120application": 3586, "atever": 3587, "\u0120aren": 3588, "\u0120myself": 3589, "\u0120imag": 3590, "\u0120dise": 3591, "\u0120society": 3592, "\u0120frequ": 3593, "\u0120English": 3594, "\u0120poor": 3595, "\u0120Day": 3596, "\u0120writing": 3597, "\u0120seven": 3598, "\u0120starting": 3599, "\u0120bud": 3600, "\u0120print": 3601, "\u0120Trans": 3602, "ufact": 3603, "\u0120Stud": 3604, "new": 3605, "\u0120crim": 3606, "\u0120gives": 3607, "\u0120cool": 3608, "ae": 3609, "iance": 3610, "\u0120General": 3611, "\u0120thinking": 3612, "\u0120save": 3613, "\u0120limited": 3614, "\u0120Party": 3615, "\u0120meaning": 3616, "pen": 3617, "owers": 3618, "\u0120Jack": 3619, "EM": 3620, "\u0120nice": 3621, "rupt": 3622, "\u0120gas": 3623, "\u0120eight": 3624, "\u0120feet": 3625, "\u0120effort": 3626, "\u0120ign": 3627, "icit": 3628, "Bl": 3629, "coin": 3630, "\u0120opin": 3631, "\u0120brain": 3632, "While": 3633, "hest": 3634, "\u0120Thursday": 3635, "\u0120wouldn": 3636, "aughter": 3637, "\u0120touch": 3638, "lements": 3639, "\u0120studies": 3640, "\u0120center": 3641, "cont": 3642, "orge": 3643, "\u0120computer": 3644, "\u0120investigation": 3645, "Pl": 3646, "orks": 3647, "\u01202008": 3648, "\u0120increasing": 3649, "\u0120store": 3650, "\u0120comments": 3651, "\u0120bal": 3652, "men": 3653, "\u0120doll": 3654, "\u0120liber": 3655, "\u0120wife": 3656, "\u0120laws": 3657, "aturday": 3658, "itness": 3659, "\u0120modern": 3660, "\u0120Sk": 3661, "\u0120administration": 3662, "\u0120opportunity": 3663, "\u0120sal": 3664, "\u0120powerful": 3665, "My": 3666, "\u0120claims": 3667, "\u0120Earth": 3668, "ords": 3669, "\u0120title": 3670, "\u0120esc": 3671, "name": 3672, "Not": 3673, "omen": 3674, "\u0120beyond": 3675, "\u0120camer": 3676, "\u0120sell": 3677, "itute": 3678, "earch": 3679, "\u0120appl": 3680, "iment": 3681, "42": 3682, "\u0120Art": 3683, "\u0120unf": 3684, "\u0120violence": 3685, "urg": 3686, "\u0120East": 3687, "\u0120compared": 3688, "\u0120options": 3689, "\u0120throughout": 3690, "\u0120vs": 3691, "igr": 3692, ".[": 3693, "aches": 3694, "78": 3695, "\u0120files": 3696, "FL": 3697, "EL": 3698, "arian": 3699, "\u0120James": 3700, "\u0120Air": 3701, "anch": 3702, "\u0120detail": 3703, "\u0120piece": 3704, "PS": 3705, "\u0120named": 3706, "\u0120education": 3707, "\u0120drive": 3708, "\u0120items": 3709, "\u0120student": 3710, "iced": 3711, "::": 3712, "ico": 3713, "\u0120throw": 3714, "\u0120scene": 3715, "\u0120complex": 3716, "\u01202009": 3717, "\u0120prec": 3718, "\u0120Bre": 3719, "79": 3720, "\u0120concept": 3721, "\u0120status": 3722, "aming": 3723, "\u0120died": 3724, "\u0120knowledge": 3725, "\u0120beginning": 3726, "OD": 3727, "ruary": 3728, "\u0120certainly": 3729, "\u0120guys": 3730, "\u0120slight": 3731, "inn": 3732, "ounds": 3733, "\u0120fine": 3734, "\u0120fat": 3735, "ications": 3736, "\u0120perhaps": 3737, "\u0120Ant": 3738, "\u0120income": 3739, "\u0120https": 3740, "\u0120majority": 3741, "ports": 3742, "ston": 3743, "\u0120greater": 3744, "\u0120feed": 3745, "entially": 3746, "\u0120safety": 3747, "\u0120unique": 3748, "andom": 3749, "\u0120gone": 3750, "\u0120showed": 3751, "\u0120histor": 3752, "\u0120counter": 3753, "ius": 3754, "ida": 3755, "\u0120leading": 3756, "ipe": 3757, "\u0120send": 3758, "\u0120Donald": 3759, "erve": 3760, "\u0120defense": 3761, "inese": 3762, "\u0120yes": 3763, "\u0120Fire": 3764, "\u0120Muslim": 3765, "raq": 3766, "\u0120continued": 3767, "osh": 3768, "\u0120provides": 3769, "\u0120prison": 3770, "\u0120Pre": 3771, "\u0120happy": 3772, "\u0120economy": 3773, "\u0120trust": 3774, "ags": 3775, "\u0120Game": 3776, "\u0120weapons": 3777, "uman": 3778, "\u0120Cle": 3779, "itation": 3780, "\u0120analysis": 3781, "\u0120Times": 3782, "\u0120science": 3783, "->": 3784, "\u0120figure": 3785, "\u0120disapp": 3786, "enty": 3787, "\u0120software": 3788, "\u0120ult": 3789, "\u0120officers": 3790, "New": 3791, "Is": 3792, "\u0120remains": 3793, "\u0120India": 3794, "\u0120psych": 3795, "rief": 3796, "\u0120cat": 3797, "esc": 3798, "\u0120observ": 3799, "\u0120stage": 3800, "\u0120Dark": 3801, "\u0120enter": 3802, "change": 3803, "\u0120passed": 3804, "\u0120despite": 3805, "\u0120Out": 3806, "\u0120movie": 3807, "rs": 3808, "\u0120voice": 3809, "mine": 3810, "\u0120Play": 3811, "\u0120toward": 3812, "\u0120Ter": 3813, "\u0120region": 3814, "\u0120values": 3815, "orters": 3816, "\u0120mount": 3817, "\u0120officer": 3818, "\u0120Other": 3819, "ban": 3820, "\u0120hous": 3821, "wood": 3822, "room": 3823, "IV": 3824, "\u0120Sun": 3825, "see": 3826, "\u0120Over": 3827, "rog": 3828, "90": 3829, "\u0120lay": 3830, "\u0120Tur": 3831, "awn": 3832, "\u0120pressure": 3833, "\u0120Sub": 3834, "\u0120books": 3835, "edom": 3836, "\u0120Sand": 3837, "AA": 3838, "ago": 3839, "\u0120reasons": 3840, "ford": 3841, "\u0120activity": 3842, "UT": 3843, "Now": 3844, "\u0120Senate": 3845, "cell": 3846, "night": 3847, "\u0120calls": 3848, "inter": 3849, "\u0120letter": 3850, "\u0120Rob": 3851, "\u0120Je": 3852, "\u0120choose": 3853, "\u0120Law": 3854, "Get": 3855, "Be": 3856, "\u0120rob": 3857, "\u0120types": 3858, "\u0120platform": 3859, "\u0120quarter": 3860, "RA": 3861, "\u0120Time": 3862, "\u0120maybe": 3863, "\u0120Cr": 3864, "95": 3865, "pre": 3866, "\u0120moving": 3867, "\u0120lif": 3868, "\u0120gold": 3869, "\u0120som": 3870, "\u0120patients": 3871, "\u0120truth": 3872, "\u0120Ke": 3873, "urance": 3874, "antly": 3875, "mar": 3876, "\u0120charge": 3877, "\u0120Great": 3878, "\u0120cele": 3879, "--------------------------------": 3880, "\u0120rock": 3881, "roid": 3882, "ancy": 3883, "\u0120credit": 3884, "aud": 3885, "By": 3886, "\u0120Every": 3887, "\u0120moved": 3888, "inger": 3889, "ribution": 3890, "\u0120names": 3891, "\u0120straight": 3892, "\u0120Health": 3893, "\u0120Well": 3894, "\u0120feature": 3895, "\u0120rule": 3896, "\u0120sche": 3897, "inated": 3898, "\u0120Michael": 3899, "berg": 3900, "41": 3901, "iled": 3902, "band": 3903, "\u0120click": 3904, "\u0120Angel": 3905, "onents": 3906, "\u00c2\u0143": 3907, "\u0120Iraq": 3908, "\u0120Saturday": 3909, "\u0120aware": 3910, "part": 3911, "\u0120pattern": 3912, "OW": 3913, "\u0120Let": 3914, "\u0120grad": 3915, "igned": 3916, "\u0120associated": 3917, "\u0120style": 3918, "no": 3919, "iation": 3920, "aith": 3921, "ilies": 3922, "\u0120stories": 3923, "uration": 3924, "\u0120individuals": 3925, "\u0120\u00e2\u0122\u00a6": 3926, "miss": 3927, "\u0120Associ": 3928, "ishing": 3929, "aby": 3930, "\u0120summer": 3931, "\u0120Ben": 3932, "\u012032": 3933, "\u0120arch": 3934, "uty": 3935, "\u0120Texas": 3936, "hol": 3937, "\u0120fully": 3938, "\u0120mill": 3939, "\u0120followed": 3940, "\u0120Bill": 3941, "\u0120Indian": 3942, "\u0120Secret": 3943, "\u0120Bel": 3944, "\u0120February": 3945, "\u0120jobs": 3946, "\u0120seemed": 3947, "\u0120Govern": 3948, "ipped": 3949, "\u0120reality": 3950, "\u0120lines": 3951, "\u0120park": 3952, "\u0120measure": 3953, "\u0120Our": 3954, "IM": 3955, "\u0120brother": 3956, "\u0120growing": 3957, "\u0120ban": 3958, "\u0120estim": 3959, "\u0120cry": 3960, "\u0120School": 3961, "\u0120mechan": 3962, "\u0120OF": 3963, "\u0120Windows": 3964, "\u0120rates": 3965, "\u0120Oh": 3966, "\u0120positive": 3967, "\u0120culture": 3968, "istics": 3969, "ica": 3970, "\u0120har": 3971, "ya": 3972, "itely": 3973, "ipp": 3974, "\u0120map": 3975, "encies": 3976, "\u0120William": 3977, "II": 3978, "akers": 3979, "56": 3980, "\u0120Mart": 3981, "\u0120Rem": 3982, "\u0120altern": 3983, "itude": 3984, "\u0120coach": 3985, "rowd": 3986, "Don": 3987, "\u0120kids": 3988, "\u0120journal": 3989, "\u0120corpor": 3990, "\u0120false": 3991, "\u0120web": 3992, "\u0120sleep": 3993, "\u0120contain": 3994, "\u0120sto": 3995, "\u0120bed": 3996, "iverse": 3997, "\u0120Rich": 3998, "\u0120Chinese": 3999, "\u0120pun": 4000, "\u0120meant": 4001, "known": 4002, "\u0120notice": 4003, "\u0120favorite": 4004, "aven": 4005, "\u0120condition": 4006, "\u0120purpose": 4007, "))": 4008, "\u0120organization": 4009, "\u0120challeng": 4010, "\u0120manufact": 4011, "\u0120susp": 4012, "\u0120Ac": 4013, "\u0120critic": 4014, "unes": 4015, "uclear": 4016, "\u0120mer": 4017, "vention": 4018, "\u012080": 4019, "\u0120mist": 4020, "\u0120Us": 4021, "\u0120Tor": 4022, "http": 4023, "olf": 4024, "\u0120larger": 4025, "\u0120advant": 4026, "\u0120resear": 4027, "\u0120actions": 4028, "ml": 4029, "\u0120kept": 4030, "\u0120aim": 4031, ",'": 4032, "col": 4033, "\u0120benefits": 4034, "ifying": 4035, "\u0120actual": 4036, "\u0120International": 4037, "\u0120vehicle": 4038, "\u0120chief": 4039, "\u0120efforts": 4040, "\u0120League": 4041, "\u0120Most": 4042, "\u0120wait": 4043, "\u0120adult": 4044, "\u0120overall": 4045, "\u0120speech": 4046, "\u0120highly": 4047, "\u0120female": 4048, "\u0120error": 4049, "\u0120effective": 4050, "54": 4051, "\u0120encour": 4052, "well": 4053, "\u0120failed": 4054, "\u0120conserv": 4055, "\u0120programs": 4056, "\u0120trou": 4057, "\u0120ahead": 4058, "500": 4059, "vertisement": 4060, "IP": 4061, "\u0120Found": 4062, "pir": 4063, "\u0120%": 4064, "\u0120crime": 4065, "ander": 4066, "\u0120location": 4067, "\u0120Iran": 4068, "\u0120behavior": 4069, "azing": 4070, "\u0120rare": 4071, "\u0120emb": 4072, "\u0120caused": 4073, "\u0120ship": 4074, "\u0120active": 4075, "\u0120contribut": 4076, "\u0120green": 4077, "\u0120acqu": 4078, "\u0120reflect": 4079, "venue": 4080, "\u0120firm": 4081, "\u0120birth": 4082, "].": 4083, "\u0120clearly": 4084, "\u0120emot": 4085, "\u0120agency": 4086, "riage": 4087, "\u0120memory": 4088, "98": 4089, "SA": 4090, "\u0120See": 4091, "acing": 4092, "CC": 4093, "\u0120biggest": 4094, "\u0120rap": 4095, "\u0120basic": 4096, "\u0120band": 4097, "eat": 4098, "\u0120suspect": 4099, "\u0120Mac": 4100, "\u012090": 4101, "mark": 4102, "istan": 4103, "\u0120spread": 4104, "ams": 4105, "ki": 4106, "asy": 4107, "rav": 4108, "\u0120Rober": 4109, "\u0120demonstr": 4110, "rated": 4111, "\u0120absolute": 4112, "\u0120places": 4113, "\u0120impl": 4114, "ibrary": 4115, "\u0120cards": 4116, "\u0120destroy": 4117, "\u0120virt": 4118, "vere": 4119, "\u0120appeared": 4120, "yan": 4121, "point": 4122, "\u0120beg": 4123, "\u0120temper": 4124, "spe": 4125, "anted": 4126, "ears": 4127, "\u0120Direct": 4128, "\u0120length": 4129, "\u0120blog": 4130, "amb": 4131, "\u0120integ": 4132, "\u0120resources": 4133, "acc": 4134, "iful": 4135, "\u0120spot": 4136, "\u0120forced": 4137, "\u0120thousands": 4138, "\u0120Minister": 4139, "\u0120qual": 4140, "\u0120French": 4141, "atically": 4142, "\u0120generally": 4143, "\u0120drink": 4144, "\u0120thus": 4145, "IL": 4146, "odes": 4147, "\u0120appropri": 4148, "\u0120Read": 4149, "\u0120whom": 4150, "\u0120eye": 4151, "\u0120college": 4152, "\u012045": 4153, "irection": 4154, "\u0120ensure": 4155, "\u0120apparent": 4156, "iders": 4157, "\u0120religious": 4158, "\u0120minor": 4159, "olic": 4160, "\u0120tro": 4161, "\u0120Why": 4162, "ribute": 4163, "met": 4164, "\u0120primary": 4165, "\u0120developed": 4166, "\u0120peace": 4167, "\u0120skin": 4168, "ste": 4169, "ava": 4170, "\u0120blue": 4171, "\u0120families": 4172, "\u0120ir": 4173, "\u0120apply": 4174, "\u0120inform": 4175, "\u0120Smith": 4176, "CT": 4177, "ii": 4178, "\u0120limit": 4179, "\u0120resist": 4180, "................": 4181, "umn": 4182, "\u0120conflic": 4183, "\u0120twe": 4184, "udd": 4185, "\u0120Tom": 4186, "\u0120liter": 4187, "que": 4188, "bon": 4189, "\u0120hair": 4190, "\u0120eventually": 4191, "\u0120pus": 4192, "\u0120helped": 4193, "\u0120agg": 4194, "orney": 4195, "\u0120Apple": 4196, "\u0120fit": 4197, "\u0120Sur": 4198, "\u0120prem": 4199, "\u0120sales": 4200, "\u0120seconds": 4201, "\u0120strength": 4202, "\u0120feeling": 4203, "\u00bf\u00bd": 4204, "\u0120tour": 4205, "\u0120knows": 4206, "oom": 4207, "\u0120exerc": 4208, "\u0120somew": 4209, "\u00ef\u00bf\u00bd": 4210, ">>": 4211, "\u0120spokes": 4212, "\u0120ideas": 4213, "\u0120regist": 4214, "soft": 4215, "\u0120Del": 4216, "\u0120PC": 4217, "\u0120propos": 4218, "\u0120launch": 4219, "\u0120bottom": 4220, "TH": 4221, "\u0120Please": 4222, "vest": 4223, "itz": 4224, "\u0120Inter": 4225, "\u0120script": 4226, "\u0120rat": 4227, "arning": 4228, "\u0120il": 4229, "\u0120Jer": 4230, "\u0120Are": 4231, "\u0120whatever": 4232, "oken": 4233, "cience": 4234, "\u0120mode": 4235, "\u0120agree": 4236, "\u0120sources": 4237, "\u0120initial": 4238, "\u0120restrict": 4239, "\u0120wonder": 4240, "usion": 4241, "####": 4242, "\u0120Sil": 4243, "ville": 4244, "\u0120burn": 4245, "tw": 4246, "asion": 4247, "\u0120\u00c2\u00a3": 4248, "\u0120nor": 4249, "uing": 4250, "\u0120reached": 4251, "\u0120sun": 4252, "\u0120categ": 4253, "igration": 4254, "\u0120cook": 4255, "\u0120promot": 4256, "\u0120male": 4257, "\u0120climate": 4258, "\u0120fix": 4259, "\u0120alleged": 4260, "UR": 4261, "alled": 4262, "\u0120images": 4263, "Cont": 4264, "ota": 4265, "\u0120schools": 4266, "ios": 4267, "\u0120drop": 4268, "\u0120stream": 4269, "\u0120Mo": 4270, "\u0120previously": 4271, "aling": 4272, "\u0120pet": 4273, "\u0120double": 4274, "\u0120(@": 4275, "annel": 4276, "\u0120default": 4277, "ties": 4278, "\u0120rank": 4279, "\u0120Dec": 4280, "\u0120Council": 4281, "\u0120weapon": 4282, "\u0120stock": 4283, "\u0120analy": 4284, "\u0120Str": 4285, "\u0120picture": 4286, "\u0120Police": 4287, "ference": 4288, "\u0120century": 4289, "\u0120citizens": 4290, "\u0120onto": 4291, "\u0120expand": 4292, "\u0120hero": 4293, "\u0120Sol": 4294, "\u0120wild": 4295, "\u0120update": 4296, "\u0120customers": 4297, "ront": 4298, "def": 4299, "\u0120lik": 4300, "\u0120criminal": 4301, "\u0120Christian": 4302, "SP": 4303, "76": 4304, "\u0120leaving": 4305, "\u0120otherwise": 4306, "\u0120Dist": 4307, "\u0120basis": 4308, "52": 4309, "53": 4310, "icip": 4311, "\u0120Ber": 4312, "\u0120recommend": 4313, "\u0120floor": 4314, "\u0120crowd": 4315, "oles": 4316, "\u012070": 4317, "\u0120central": 4318, "\u0120Ev": 4319, "\u0120dream": 4320, "\u0120download": 4321, "\u0120confir": 4322, "\u0120Thom": 4323, "\u0120window": 4324, "\u0120happens": 4325, "\u0120unit": 4326, "\u0120tend": 4327, "\u0120spl": 4328, "\u0120becomes": 4329, "\u0120fighting": 4330, "\u0120predict": 4331, "\u0120Press": 4332, "\u0120Power": 4333, "\u0120heavy": 4334, "aked": 4335, "\u0120fan": 4336, "orter": 4337, "ategy": 4338, "BA": 4339, "izes": 4340, "\u0120spend": 4341, "Here": 4342, "\u01202007": 4343, "\u0120adop": 4344, "\u0120Ham": 4345, "\u0120football": 4346, "\u0120Port": 4347, "oday": 4348, "51": 4349, "ampions": 4350, "\u0120transfer": 4351, "ht": 4352, "\u012038": 4353, "term": 4354, "acity": 4355, "\u0120bur": 4356, "],": 4357, "ternal": 4358, "rig": 4359, "but": 4360, "\u0120therefore": 4361, "\u0120Because": 4362, "resp": 4363, "rey": 4364, "\u0120mission": 4365, "Some": 4366, "\u0120noted": 4367, "\u0120assum": 4368, "\u0120disease": 4369, "\u0120edit": 4370, "\u0120progress": 4371, "rd": 4372, "\u0120Brown": 4373, "ocal": 4374, "\u0120adding": 4375, "\u0120raised": 4376, "\u0120Any": 4377, "\u0120tick": 4378, "\u0120seeing": 4379, "\u0120People": 4380, "\u0120agreement": 4381, "\u0120server": 4382, "\u0120wat": 4383, "\u0120debate": 4384, "\u0120supposed": 4385, "iling": 4386, "\u0120largest": 4387, "\u0120successful": 4388, "\u0120Pri": 4389, "\u0120Democratic": 4390, "\u0120jump": 4391, "\u0120Syria": 4392, "\u0120owners": 4393, "\u0120offers": 4394, "\u0120shooting": 4395, "\u0120effic": 4396, "sey": 4397, "\u0120haven": 4398, "verse": 4399, "tered": 4400, "\u0120Light": 4401, "imal": 4402, "\u0120Big": 4403, "\u0120defend": 4404, "\u0120beat": 4405, "\u0120records": 4406, "%)": 4407, "\u0120scen": 4408, "\u0120employees": 4409, "\u0120devices": 4410, "hem": 4411, "\u0120commer": 4412, "\u0120Mex": 4413, "\u0120benefit": 4414, "\u0120Prof": 4415, "\u0120illeg": 4416, "\u0120surface": 4417, "\u0120Also": 4418, "\u0120harm": 4419, "ingly": 4420, "wide": 4421, "\u0120Alex": 4422, "\u0120shut": 4423, "\u0120Cur": 4424, "\u0120lose": 4425, "pm": 4426, "\u0120challenge": 4427, "semb": 4428, "\u0120station": 4429, "\u0120intelligence": 4430, "\u0120accur": 4431, "\u0120Flor": 4432, "\u0120requires": 4433, "\u0120Mal": 4434, "bum": 4435, "\u0120hospital": 4436, "\u0120spirit": 4437, "\u0120offered": 4438, "\u0120produce": 4439, "\u0120Commun": 4440, "\u0120creating": 4441, "\u0120cris": 4442, "spect": 4443, "\u0120ended": 4444, "\u0120daily": 4445, "\u0120voters": 4446, "lands": 4447, "ias": 4448, "ih": 4449, "ona": 4450, "\u0120smart": 4451, "\u0120Office": 4452, "\u0120Lord": 4453, "rial": 4454, "\u0120Internet": 4455, "\u0120circum": 4456, "\u0120extremely": 4457, "'.": 4458, "\u0120opinion": 4459, "\u0120Mil": 4460, "\u0120gain": 4461, "BS": 4462, "\u0120Fin": 4463, "yp": 4464, "\u0120useful": 4465, "\u0120budget": 4466, "\u0120comfort": 4467, "isf": 4468, "\u0120background": 4469, "eline": 4470, "\u0120episode": 4471, "\u0120enemy": 4472, "\u0120trial": 4473, "\u0120establish": 4474, "date": 4475, "\u0120Cap": 4476, "\u0120continues": 4477, "\u0120showing": 4478, "\u0120Union": 4479, "with": 4480, "\u0120posted": 4481, "\u0120System": 4482, "\u0120eat": 4483, "rian": 4484, "\u0120rise": 4485, "\u0120Germany": 4486, "ils": 4487, "\u0120signed": 4488, "\u0120vill": 4489, "\u0120grand": 4490, "mor": 4491, "\u0120England": 4492, "\u0120projects": 4493, "umber": 4494, "\u0120conference": 4495, "za": 4496, "\u0120responsible": 4497, "\u0120Arab": 4498, "\u0120learned": 4499, "\u00e2\u0122\u0136\u00e2\u0122\u0136": 4500, "ipping": 4501, "\u0120George": 4502, "OC": 4503, "\u0120returned": 4504, "\u0120Australia": 4505, "\u0120brief": 4506, "Qu": 4507, "\u0120brand": 4508, "illing": 4509, "abled": 4510, "\u0120highest": 4511, "\u0120train": 4512, "\u0120Commission": 4513, "while": 4514, "\u0120nom": 4515, "ception": 4516, "\u0120mut": 4517, "\u0120Blue": 4518, "\u0120incident": 4519, "vant": 4520, "86": 4521, "\u0120ID": 4522, "\u0120nuclear": 4523, "74": 4524, "\u0120Like": 4525, "\u0120RE": 4526, "\u0120Micro": 4527, "li": 4528, "mail": 4529, "\u0120charges": 4530, "89": 4531, "\u0120adjust": 4532, "ado": 4533, "\u0120earth": 4534, "NA": 4535, "\u0120prices": 4536, "PA": 4537, "\u0120draft": 4538, "\u0120runs": 4539, "\u0120candidate": 4540, "enses": 4541, "\u0120management": 4542, "\u0120Phil": 4543, "\u0120Miss": 4544, "\u0120teach": 4545, "gram": 4546, "\u0120understanding": 4547, "ait": 4548, "icago": 4549, "Add": 4550, "\u0120Ep": 4551, "secut": 4552, "\u0120separate": 4553, "\u0120instance": 4554, "\u0120eth": 4555, "\u0120unless": 4556, "********": 4557, "\u0120Fore": 4558, "inate": 4559, "\u0120operations": 4560, "Sp": 4561, "\u0120faith": 4562, "gar": 4563, "\u0120Church": 4564, "ronic": 4565, "\u0120config": 4566, "osure": 4567, "\u0120activities": 4568, "\u0120traditional": 4569, "\u012036": 4570, "\u0120direction": 4571, "\u0120machine": 4572, "\u0120surround": 4573, "\u0120push": 4574, "unction": 4575, "\u0120EU": 4576, "\u0120easier": 4577, "\u0120argument": 4578, "GB": 4579, "\u0120micro": 4580, "\u0120spending": 4581, "izations": 4582, "\u0120theory": 4583, "adow": 4584, "\u0120calling": 4585, "\u0120Last": 4586, "\u0120der": 4587, "\u0120influence": 4588, "\u0120commit": 4589, "\u0120photo": 4590, "\u0120unc": 4591, "istry": 4592, "gn": 4593, "aste": 4594, "acks": 4595, "\u0120disp": 4596, "ady": 4597, "do": 4598, "\u0120Good": 4599, "\u0120`": 4600, "\u0120wish": 4601, "\u0120revealed": 4602, "\u00c2\u0142\u00c2\u0142": 4603, "lig": 4604, "\u0120enforce": 4605, "\u0120Committee": 4606, "\u0120chem": 4607, "\u0120miles": 4608, "\u0120interested": 4609, "\u0120solution": 4610, "icy": 4611, "inct": 4612, "\u0120->": 4613, "\u0120Det": 4614, "\u0120removed": 4615, "\u0120compar": 4616, "eah": 4617, "\u0120plant": 4618, "\u0120Since": 4619, "\u0120achieve": 4620, "\u0120advantage": 4621, "\u0120slightly": 4622, "bing": 4623, "\u0120placed": 4624, "under": 4625, "2015": 4626, "\u0120Mad": 4627, "\u0120tim": 4628, "oses": 4629, "\u0120cru": 4630, "\u0120Rock": 4631, "\u0120mostly": 4632, "\u0120negative": 4633, "\u0120setting": 4634, "\u0120produced": 4635, "\u0120mur": 4636, "\u0120connection": 4637, "\u0120Mer": 4638, "\u0120driver": 4639, "\u0120executive": 4640, "\u0120assault": 4641, "\u0120born": 4642, "\u0120Ver": 4643, "tained": 4644, "\u0120structure": 4645, "\u0120reduce": 4646, "\u0120decades": 4647, "\u0120ded": 4648, "uke": 4649, "\u0120Many": 4650, "idden": 4651, "\u0120league": 4652, "Se": 4653, "\u0120join": 4654, "\u0120disco": 4655, "\u0120die": 4656, "cks": 4657, "actions": 4658, "\u0120assess": 4659, "agn": 4660, "\u0120goals": 4661, "ours": 4662, "IR": 4663, "\u0120senior": 4664, "iller": 4665, "mod": 4666, "ipment": 4667, "ocol": 4668, "uy": 4669, "\u0120Que": 4670, "\u0120parties": 4671, "irgin": 4672, "\u0120learning": 4673, "itable": 4674, "\u0120street": 4675, "\u0120camera": 4676, "App": 4677, "\u0120skills": 4678, "bre": 4679, "cious": 4680, "\u0120celebr": 4681, "\u0120Franc": 4682, "\u0120existing": 4683, "\u0120willing": 4684, "lor": 4685, "\u0120id": 4686, "\u0120Space": 4687, "\u0120critical": 4688, "\u0120La": 4689, "ortunately": 4690, "\u0120serve": 4691, "\u0120cold": 4692, "\u0120species": 4693, "TS": 4694, "\u0120animals": 4695, "\u0120Bay": 4696, "\u0120older": 4697, "\u0120Under": 4698, "estic": 4699, "\u0120Tre": 4700, "\u0120teacher": 4701, "\u0120prefer": 4702, "vis": 4703, "\u0120thread": 4704, "\u0120Matt": 4705, "\u0120manager": 4706, "\u00e3\u0125\u00bb": 4707, "\u0120professional": 4708, "\u0120Vol": 4709, "\u0120notes": 4710, "These": 4711, "ula": 4712, "\u0120fresh": 4713, "ented": 4714, "uzz": 4715, "edy": 4716, "clusion": 4717, "\u0120Rel": 4718, "\u0120doubt": 4719, "EO": 4720, "\u0120opened": 4721, "\u0120Bit": 4722, "Advertisement": 4723, "\u0120guess": 4724, "\u0120UN": 4725, "\u0120sequ": 4726, "\u0120explain": 4727, "otten": 4728, "\u0120attract": 4729, "aks": 4730, "\u0120string": 4731, "\u0120context": 4732, "ossible": 4733, "\u0120Republicans": 4734, "\u0120solid": 4735, "\u0120cities": 4736, "\u0120asking": 4737, "\u0120random": 4738, "ups": 4739, "uries": 4740, "arant": 4741, "dden": 4742, "gl": 4743, "\u0120Florida": 4744, "\u0120depend": 4745, "\u0120Scott": 4746, "\u012033": 4747, "\u0120iT": 4748, "icon": 4749, "\u0120mentioned": 4750, "\u01202000": 4751, "\u0120claimed": 4752, "\u0120definitely": 4753, "ulf": 4754, "\u0120core": 4755, "\u0120opening": 4756, "\u0120Const": 4757, "which": 4758, "\u0120Tra": 4759, "AG": 4760, "72": 4761, "\u0120believed": 4762, "ada": 4763, "\u012048": 4764, "\u0120Security": 4765, "yright": 4766, "\u0120Pet": 4767, "\u0120Lou": 4768, "\u0120holding": 4769, "================": 4770, "\u0120ice": 4771, "\u0120brow": 4772, "\u0120authorities": 4773, "host": 4774, "word": 4775, "\u0120score": 4776, "\u0120Div": 4777, "\u0120cells": 4778, "\u0120transl": 4779, "\u0120neighbor": 4780, "\u0120remove": 4781, "uct": 4782, "\u0120district": 4783, "\u0120According": 4784, "\u0120worse": 4785, "\u0120concerns": 4786, "\u0120presidential": 4787, "\u0120policies": 4788, "\u0120Hall": 4789, "73": 4790, "\u0120hus": 4791, "AY": 4792, "\u01202006": 4793, "\u0120Jud": 4794, "\u0120independent": 4795, "\u0120Justice": 4796, "iliar": 4797, "print": 4798, "ighter": 4799, "\u0120protection": 4800, "zen": 4801, "\u0120sudden": 4802, "house": 4803, "\u0120Jes": 4804, "PR": 4805, "\u0120Inf": 4806, "\u0120bul": 4807, "\u0120_": 4808, "\u0120Service": 4809, "\u0120PR": 4810, "\u0120strategy": 4811, "ffect": 4812, "\u0120girls": 4813, "\u0120missing": 4814, "oyal": 4815, "\u0120Team": 4816, "ulated": 4817, "\u0120dat": 4818, "\u0120politics": 4819, "abor": 4820, "According": 4821, "\u0120spell": 4822, "\u0120graph": 4823, "orthern": 4824, "TC": 4825, "Ab": 4826, "\u0120labor": 4827, "isher": 4828, "\u0120kick": 4829, "\u0120iTunes": 4830, "\u0120steps": 4831, "poses": 4832, "\u0120smaller": 4833, "En": 4834, "bert": 4835, "\u0120roll": 4836, "\u0120researchers": 4837, "\u0120closed": 4838, "\u0120transport": 4839, "\u0120lawy": 4840, "________________": 4841, "\u0120Chicago": 4842, "\u0120aspect": 4843, "\u0120none": 4844, "\u0120marriage": 4845, "96": 4846, "\u0120elements": 4847, "\u0120Fre": 4848, "\u0120Sal": 4849, "\u0120dram": 4850, "FC": 4851, "top": 4852, "equ": 4853, "\u0120hearing": 4854, "\u0120supported": 4855, "\u0120testing": 4856, "cohol": 4857, "\u0120massive": 4858, "\u0120stick": 4859, "\u0120guard": 4860, "isco": 4861, "phone": 4862, "From": 4863, "However": 4864, "\u0120border": 4865, "\u0120copy": 4866, "ography": 4867, "list": 4868, "71": 4869, "\u0120owner": 4870, "class": 4871, "ruit": 4872, "rate": 4873, "\u0120Once": 4874, "\u0120digital": 4875, "\u0120task": 4876, "ERS": 4877, "\u0120incred": 4878, "tes": 4879, "++": 4880, "\u0120France": 4881, "\u0120breat": 4882, "owl": 4883, "\u0120issued": 4884, "\u0120Western": 4885, "\u0120detect": 4886, "\u0120partners": 4887, "\u0120shared": 4888, "\u0120Call": 4889, "\u0120cancer": 4890, "ache": 4891, "ribe": 4892, "\u0120explained": 4893, "\u0120heat": 4894, "{\"": 4895, "\u0120investment": 4896, "\u0120Book": 4897, "\u0120wood": 4898, "\u0120tools": 4899, "\u0120Although": 4900, "\u0120belief": 4901, "\u0120crisis": 4902, "\u0120ge": 4903, "\u0120MP": 4904, "\u0120operation": 4905, "type": 4906, "~~": 4907, "ga": 4908, "\u0120contains": 4909, "anta": 4910, "\u0120express": 4911, "\u0120Group": 4912, "\u0120Journal": 4913, "ka": 4914, "\u0120amb": 4915, "\u0120USA": 4916, "\u0120finding": 4917, "\u0120funding": 4918, "how": 4919, "\u0120established": 4920, "ideos": 4921, "\u0120degree": 4922, "\u0120dangerous": 4923, "anging": 4924, "\u0120freedom": 4925, "pport": 4926, "outhern": 4927, "\u0120church": 4928, "\u0120catch": 4929, "\u0120Two": 4930, "\u0120presence": 4931, "\u0120Guard": 4932, "Up": 4933, "\u0120authority": 4934, "\u0120Project": 4935, "\u0120button": 4936, "\u0120consequ": 4937, "\u0120valid": 4938, "\u0120weak": 4939, "\u0120starts": 4940, "\u0120reference": 4941, "\u0120Mem": 4942, "\")": 4943, "UN": 4944, "orage": 4945, "\u0120Open": 4946, "\u0120collection": 4947, "ym": 4948, "gency": 4949, "\u0120beautiful": 4950, "ros": 4951, "\u0120tells": 4952, "\u0120waiting": 4953, "nel": 4954, "\u0120providing": 4955, "\u0120Democrats": 4956, "\u0120daughter": 4957, "\u0120master": 4958, "\u0120purposes": 4959, "\u0120Japanese": 4960, "\u0120equal": 4961, "\u0120turns": 4962, "\u0120documents": 4963, "\u0120watching": 4964, "Res": 4965, "\u0120ran": 4966, "2014": 4967, "\u0120reject": 4968, "\u0120Korea": 4969, "\u0120victims": 4970, "Level": 4971, "erences": 4972, "\u0120witness": 4973, "\u012034": 4974, "\u0120reform": 4975, "coming": 4976, "\u0120occup": 4977, "\u0120caught": 4978, "\u0120traffic": 4979, "ading": 4980, "\u0120models": 4981, "ario": 4982, "\u0120served": 4983, "\u0120batter": 4984, "uate": 4985, "\u0120Secretary": 4986, "\u0120agreed": 4987, "\u0120truly": 4988, "ynam": 4989, "\u0120Ret": 4990, "\u0120units": 4991, "\u0120Research": 4992, "hand": 4993, "azine": 4994, "\u0120Mike": 4995, "\u0120variety": 4996, "otal": 4997, "\u0120amazing": 4998, "\u0120confirmed": 4999, "\u0120entirely": 5000, "\u0120purchase": 5001, "\u0120element": 5002, "\u0120cash": 5003, "\u0120determine": 5004, "De": 5005, "\u0120cars": 5006, "\u0120Wall": 5007, "\u00e2\u0138": 5008, "\u0120views": 5009, "\u0120drugs": 5010, "\u0120department": 5011, "\u0120Step": 5012, "uit": 5013, "\u012039": 5014, "asure": 5015, "\u0120Class": 5016, "\u0120covered": 5017, "\u0120Bank": 5018, "\u0120mere": 5019, "uana": 5020, "\u0120multi": 5021, "\u0120mix": 5022, "\u0120unlike": 5023, "levision": 5024, "\u0120stopped": 5025, "\u0120sem": 5026, "\u0120Gal": 5027, "ules": 5028, "\u0120wel": 5029, "\u0120Johnson": 5030, "la": 5031, "\u0120skill": 5032, "\u0120becoming": 5033, "rie": 5034, "\u0120appropriate": 5035, "fe": 5036, "ellow": 5037, "\u0120Prot": 5038, "ulate": 5039, "ocation": 5040, "\u0120weekend": 5041, "odies": 5042, "\u0120sites": 5043, "\u0120animal": 5044, "\u0120Tim": 5045, "\u0120scale": 5046, "\u0120charged": 5047, "\u0120instruct": 5048, "illa": 5049, "\u0120methods": 5050, "\u0120cert": 5051, "\u0120judge": 5052, "\u0120Hel": 5053, "\u0120dollars": 5054, "\u0120standing": 5055, "\u0120Squ": 5056, "\u0120debt": 5057, "liam": 5058, "\u0120driving": 5059, "\u0120Sum": 5060, "\u0120Edition": 5061, "\u0120album": 5062, "andon": 5063, "IF": 5064, "\u0120Uk": 5065, "63": 5066, "ader": 5067, "\u0120commercial": 5068, "esh": 5069, "\u0120Government": 5070, "\u0120discovered": 5071, "\u0120output": 5072, "\u0120Hillary": 5073, "\u0120Carol": 5074, "\u01202005": 5075, "\u0120abuse": 5076, "ancing": 5077, "\u0120switch": 5078, "\u0120annual": 5079, "Tw": 5080, "\u0120stated": 5081, "agement": 5082, "inner": 5083, "\u0120democr": 5084, "\u0120residents": 5085, "\u0120allowing": 5086, "\u0120factors": 5087, "odd": 5088, "\u0120fuck": 5089, "emies": 5090, "\u0120occurred": 5091, "oti": 5092, "\u0120north": 5093, "\u0120Public": 5094, "\u0120injury": 5095, "\u0120insurance": 5096, "CL": 5097, "olly": 5098, "\u00e3\u0122": 5099, "\u0120repeated": 5100, "\u0120arms": 5101, "anged": 5102, "\u0120construction": 5103, "\u0120fle": 5104, "PU": 5105, "icians": 5106, "\u0120forms": 5107, "\u0120McC": 5108, "antic": 5109, "\u0120mental": 5110, "pire": 5111, "\u0120equipment": 5112, "\u0120fant": 5113, "\u0120discussion": 5114, "\u0120regarding": 5115, "kin": 5116, "arp": 5117, "\u0120chair": 5118, "ogue": 5119, "\u0120proceed": 5120, "\u0120Id": 5121, "Our": 5122, "\u0120murder": 5123, "Man": 5124, "\u012049": 5125, "asp": 5126, "\u0120supply": 5127, "\u0120input": 5128, "\u0120wealth": 5129, "liament": 5130, "\u0120proced": 5131, "orial": 5132, "\u0120Stat": 5133, "\u0120NFL": 5134, "hens": 5135, "\u0120Institute": 5136, "\u0120putting": 5137, "ournament": 5138, "etic": 5139, "\u0120located": 5140, "\u0120kid": 5141, "eria": 5142, "run": 5143, "\u0120princ": 5144, "\u0120!": 5145, "going": 5146, "\u0120Bet": 5147, "\u0120clot": 5148, "\u0120telling": 5149, "\u0120proposed": 5150, "iot": 5151, "orry": 5152, "\u0120funds": 5153, "gment": 5154, "\u0120Life": 5155, "\u0120baby": 5156, "\u0120Back": 5157, "\u0120spoke": 5158, "Image": 5159, "\u0120earn": 5160, "\u0120AT": 5161, "gu": 5162, "\u0120exchange": 5163, "\u0120Lin": 5164, "oving": 5165, "\u0120pair": 5166, "More": 5167, "azon": 5168, "\u0120arrested": 5169, "\u0120killing": 5170, "can": 5171, "\u0120Card": 5172, "yd": 5173, "\u0120identified": 5174, "\u0120mobile": 5175, "\u0120thanks": 5176, "onym": 5177, "\u0120Form": 5178, "\u0120hundreds": 5179, "\u0120Chris": 5180, "\u0120Cat": 5181, "\u0120trend": 5182, "hat": 5183, "\u0120Av": 5184, "oman": 5185, "\u0120electric": 5186, "\u0120Wil": 5187, "SE": 5188, "Of": 5189, "\u0120restaur": 5190, "oted": 5191, "\u0120trig": 5192, "\u0120nine": 5193, "\u0120bomb": 5194, "Why": 5195, "\u00c2\u00af": 5196, "\u0120coverage": 5197, "\u0120appeal": 5198, "\u0120Robert": 5199, "\u0120Sup": 5200, "\u0120finished": 5201, "\u0120flow": 5202, "\u0120deliver": 5203, "\u0120calcul": 5204, "\u0120photos": 5205, "\u0120phil": 5206, "\u0120pieces": 5207, "\u0120appre": 5208, "kes": 5209, "\u0120rough": 5210, "Do": 5211, "\u0120partner": 5212, "\u0120concerned": 5213, "\u012037": 5214, "\u0120Gen": 5215, "Col": 5216, "ctors": 5217, "\u0120=>": 5218, "state": 5219, "\u0120suggested": 5220, "\u0120Force": 5221, "CE": 5222, "\u0120herself": 5223, "\u0120Plan": 5224, "works": 5225, "ooth": 5226, "rency": 5227, "\u0120corner": 5228, "\u0120husband": 5229, "\u0120internet": 5230, "\u0120Aut": 5231, "ems": 5232, "osen": 5233, "\u0120Atl": 5234, "gen": 5235, "\u0120balance": 5236, "62": 5237, "\u0120sounds": 5238, "text": 5239, "\u0120arr": 5240, "oves": 5241, "\u0120millions": 5242, "\u0120radio": 5243, "\u0120satisf": 5244, "\u0120Dam": 5245, "Mr": 5246, "Go": 5247, "Spe": 5248, "\u0120combat": 5249, "rant": 5250, "\u0120Gree": 5251, "\u0120fuel": 5252, "\u0120distance": 5253, "\u0120tests": 5254, "\u0120decre": 5255, "\u0120Er": 5256, "\u0120managed": 5257, "DS": 5258, "\u0120tit": 5259, "\u0120measures": 5260, "\u0120Liber": 5261, "\u0120attend": 5262, "ashed": 5263, "\u0120Jose": 5264, "\u0120Night": 5265, "dit": 5266, "\u0120Nov": 5267, "\u0120End": 5268, "outs": 5269, "\u0120generation": 5270, "\u0120advoc": 5271, "yth": 5272, "\u0120conversation": 5273, "\u0120Sky": 5274, "active": 5275, "cel": 5276, "rier": 5277, "\u0120Frank": 5278, "\u0120gender": 5279, "\u0120concent": 5280, "\u0120carried": 5281, "anda": 5282, "\u0120Virgin": 5283, "\u0120arrived": 5284, "icide": 5285, "aded": 5286, "\u0120failure": 5287, "\u0120minimum": 5288, "lets": 5289, "\u0120worst": 5290, "\u0120keeping": 5291, "\u0120intended": 5292, "\u0120illegal": 5293, "\u0120subsc": 5294, "\u0120determined": 5295, "\u0120trip": 5296, "Yes": 5297, "\u0120raise": 5298, "\u0120~": 5299, "\u0120feels": 5300, "\u0120package": 5301, "\u0120Jo": 5302, "hi": 5303, "2016": 5304, "real": 5305, "\u0120fra": 5306, "\u0120symb": 5307, "Me": 5308, "ucky": 5309, "pret": 5310, "\u0120Kh": 5311, "\u0120Edit": 5312, "\u0120Web": 5313, "emic": 5314, "\u0120Color": 5315, "\u0120justice": 5316, "Int": 5317, "\u0120farm": 5318, "cknow": 5319, "\">": 5320, "eless": 5321, "\u0120reduced": 5322, "\u0120500": 5323, "xx": 5324, "\u0120Rad": 5325, "\u0120Wood": 5326, "\u0120clin": 5327, "\u0120hyp": 5328, "iler": 5329, "ura": 5330, "kins": 5331, "85": 5332, "61": 5333, "\u0120Their": 5334, "\u0120Mary": 5335, "\u0120san": 5336, "\u0120novel": 5337, "\u0120Who": 5338, "\u0120capacity": 5339, "\u0120impossible": 5340, "\u0120plays": 5341, "\u0120minister": 5342, "ijuana": 5343, "icate": 5344, "\u0120Set": 5345, "\u0120fram": 5346, "\u0120ing": 5347, "\u0120communities": 5348, "\u0120FBI": 5349, "ita": 5350, "\u0120bon": 5351, "\u0120strateg": 5352, "\u0120interests": 5353, "lock": 5354, "gers": 5355, "mas": 5356, "\u0120AND": 5357, "\u0120conflict": 5358, "\u0120requirements": 5359, "\u0120sac": 5360, "\u0120operating": 5361, "ini": 5362, "related": 5363, "\u0120committed": 5364, "\u0120relatively": 5365, "\u0120south": 5366, "\u00c2\u00af\u00c2\u00af": 5367, "\u0120afford": 5368, "\u0120identity": 5369, "\u0120decisions": 5370, "\u0120accused": 5371, "place": 5372, "\u0120victory": 5373, "och": 5374, "iat": 5375, "Name": 5376, "Com": 5377, "tion": 5378, "eds": 5379, "\u0120seek": 5380, "\u0120tight": 5381, "\u0120Images": 5382, "\u0120initi": 5383, "\u0120humans": 5384, "\u0120familiar": 5385, "\u0120audience": 5386, "\u0120internal": 5387, "venture": 5388, "\u0120sides": 5389, "\u0120TO": 5390, "\u0120dim": 5391, "\u0120conclud": 5392, "\u0120appoint": 5393, "\u0120enforcement": 5394, "\u0120Jim": 5395, "\u0120Association": 5396, "\u0120circumst": 5397, "\u0120Canadian": 5398, "\u0120joined": 5399, "\u0120differences": 5400, "\u0120Los": 5401, "\u0120protest": 5402, "\u0120twice": 5403, "win": 5404, "\u0120glass": 5405, "arsh": 5406, "\u0120Army": 5407, "\u0120expression": 5408, "\u0120decide": 5409, "\u0120planning": 5410, "ania": 5411, "\u0120handle": 5412, "\u0120Microsoft": 5413, "\u0120Nor": 5414, "\u0120maximum": 5415, "\u0120Rev": 5416, "\u0120sea": 5417, "\u0120eval": 5418, "\u0120helps": 5419, "ref": 5420, "\u0120bound": 5421, "\u0120mouth": 5422, "\u0120standards": 5423, "\u0120clim": 5424, "\u0120Camp": 5425, "\u0120Fox": 5426, "cles": 5427, "\u0120army": 5428, "\u0120Techn": 5429, "acking": 5430, "xy": 5431, "SS": 5432, "\u012042": 5433, "\u0120bug": 5434, "\u0120Ukrain": 5435, "\u0120Max": 5436, "\u0120Jones": 5437, "\u0120Show": 5438, "lo": 5439, "\u0120planet": 5440, "\u012075": 5441, "\u0120winning": 5442, "\u0120faster": 5443, "\u0120spect": 5444, "\u0120broken": 5445, "TR": 5446, "\u0120defined": 5447, "\u0120healthy": 5448, "\u0120competition": 5449, "https": 5450, "\u0120Island": 5451, "\u0120Fe": 5452, "\u0120announce": 5453, "\u0120Cup": 5454, "\u0120Instead": 5455, "\u0120client": 5456, "\u0120possibly": 5457, "section": 5458, "ocket": 5459, "look": 5460, "\u0120finish": 5461, "\u0120crew": 5462, "\u0120reserv": 5463, "\u0120editor": 5464, "\u0120hate": 5465, "\u0120sale": 5466, "\u0120controvers": 5467, "\u0120pages": 5468, "wing": 5469, "\u0120numer": 5470, "\u0120opposition": 5471, "\u01202004": 5472, "\u0120refuge": 5473, "\u0120flight": 5474, "\u0120apart": 5475, "\u0120Lat": 5476, "Americ": 5477, "\u0120Africa": 5478, "\u0120applications": 5479, "\u0120Palest": 5480, "\u0120Bur": 5481, "\u0120gar": 5482, "\u0120Social": 5483, "\u0120upgr": 5484, "\u0120shape": 5485, "\u0120speaking": 5486, "ansion": 5487, "ao": 5488, "\u0120Sn": 5489, "\u0120worry": 5490, "\u0120Britain": 5491, "Please": 5492, "roud": 5493, "\u0120hun": 5494, "\u0120introduced": 5495, "\u0120diet": 5496, "Ind": 5497, "\u0120Second": 5498, "\u0120functions": 5499, "uts": 5500, "\u0120Each": 5501, "\u0120Jeff": 5502, "\u0120stress": 5503, "\u0120accounts": 5504, "\u0120guarant": 5505, "\u0120Ann": 5506, "edia": 5507, "\u0120honest": 5508, "\u0120tree": 5509, "\u0120African": 5510, "\u0120Bush": 5511, "},": 5512, "\u0120sch": 5513, "\u0120Only": 5514, "\u0120fif": 5515, "igan": 5516, "\u0120exercise": 5517, "\u0120Exp": 5518, "\u0120scientists": 5519, "\u0120legislation": 5520, "\u0120Work": 5521, "\u0120Spr": 5522, "\u00c3\u0124": 5523, "\u0120Human": 5524, "\u0120\u00e8": 5525, "\u0120survey": 5526, "\u0120rich": 5527, "rip": 5528, "\u0120maintain": 5529, "\u0120flo": 5530, "\u0120leadership": 5531, "stream": 5532, "\u0120Islamic": 5533, "\u012001": 5534, "\u0120College": 5535, "\u0120magic": 5536, "\u0120Prime": 5537, "\u0120figures": 5538, "2017": 5539, "inder": 5540, "xual": 5541, "\u0120Dead": 5542, "\u0120absolutely": 5543, "\u0120fourth": 5544, "\u0120presented": 5545, "respond": 5546, "rible": 5547, "\u0120alcohol": 5548, "ato": 5549, "\u0120DE": 5550, "porary": 5551, "\u0120grab": 5552, "\u0120vari": 5553, "\u0120quant": 5554, "\u0120Photo": 5555, "\u0120plus": 5556, "rick": 5557, "arks": 5558, "\u0120alternative": 5559, "\u0120pil": 5560, "\u0120approx": 5561, "that": 5562, "\u0120objects": 5563, "\u0120Ro": 5564, "\u0120Android": 5565, "\u0120significantly": 5566, "\u0120Road": 5567, "kay": 5568, "Read": 5569, "avor": 5570, "\u0120acknow": 5571, "\u0120HD": 5572, "\u0120Sing": 5573, "Or": 5574, "\u0120Mont": 5575, "\u0120uns": 5576, "prof": 5577, "\u0120negoti": 5578, "\u0120Arch": 5579, "iki": 5580, "\u0120television": 5581, "\u0120Jewish": 5582, "\u0120committee": 5583, "\u0120motor": 5584, "\u0120appearance": 5585, "\u0120sitting": 5586, "\u0120strike": 5587, "\u0120Down": 5588, "comp": 5589, "\u0120Hist": 5590, "\u0120fold": 5591, "acement": 5592, "\u0120Louis": 5593, "\u0120belong": 5594, "\u0120\u00e2\u0122\u00a2": 5595, "\u0120mort": 5596, "\u0120prepared": 5597, "\u012064": 5598, "\u0120Master": 5599, "\u0120indeed": 5600, "\u0120Den": 5601, "\u0120rent": 5602, "TA": 5603, "ourney": 5604, "arc": 5605, "Su": 5606, "97": 5607, "\u0120advice": 5608, "\u0120changing": 5609, "\u0120listed": 5610, "\u0120launched": 5611, "isation": 5612, "\u0120Peter": 5613, "ishes": 5614, "\u0120lived": 5615, "\u0120Mel": 5616, "\u0120Supreme": 5617, "\u0120Federal": 5618, "\u0120);": 5619, "ructure": 5620, "\u0120sets": 5621, "\u0120philos": 5622, "uous": 5623, "\u0120\u00c2\u0142": 5624, "\u0120applied": 5625, "\u0120NOT": 5626, "\u0120housing": 5627, "\u0120Mount": 5628, "\u0120odd": 5629, "\u0120sust": 5630, "DA": 5631, "fficient": 5632, "\u0120?": 5633, "olved": 5634, "\u0120powers": 5635, "\u0120thr": 5636, "\u0120remaining": 5637, "\u0120Water": 5638, "LC": 5639, "\u0120causes": 5640, "\u00e3\u0123\u00ae": 5641, "\u0120manner": 5642, "ads": 5643, "\u0120suggests": 5644, "\u0120ends": 5645, "standing": 5646, "fig": 5647, "\u0120Dun": 5648, "idth": 5649, "\u0120gay": 5650, "\u0120termin": 5651, "\u0120Angeles": 5652, "MS": 5653, "\u0120scientific": 5654, "\u0120coal": 5655, "apers": 5656, "bar": 5657, "\u0120Thomas": 5658, "\u0120sym": 5659, "\u0120Run": 5660, "this": 5661, "PC": 5662, "igrants": 5663, "\u0120minute": 5664, "\u0120District": 5665, "cellent": 5666, "\u0120leaves": 5667, "\u0120completed": 5668, "amin": 5669, "\u0120focused": 5670, "\u0120monitor": 5671, "\u0120vehicles": 5672, "MA": 5673, "\u0120Mass": 5674, "\u0120Grand": 5675, "\u0120affected": 5676, "itutional": 5677, "\u0120construct": 5678, "\u0120follows": 5679, "\u0120ton": 5680, "reens": 5681, "\u0120homes": 5682, "\u0120Ext": 5683, "\u0120Level": 5684, "rast": 5685, "\u0120Ir": 5686, "\u0120elim": 5687, "\u0120largely": 5688, "\u0120Joe": 5689, "\u0120votes": 5690, "alls": 5691, "\u0120businesses": 5692, "\u0120Foundation": 5693, "\u0120Central": 5694, "\u0120yards": 5695, "\u0120materials": 5696, "ulner": 5697, "\u0120guide": 5698, "\u0120closer": 5699, "ums": 5700, "\u0120sports": 5701, "eder": 5702, "Just": 5703, "\u0120taxes": 5704, "84": 5705, "\u0120Old": 5706, "\u0120decade": 5707, "ola": 5708, "\u0120vir": 5709, "\u0120dropped": 5710, "\u0120delay": 5711, "itect": 5712, "\u0120secure": 5713, "stein": 5714, "level": 5715, "\u0120treated": 5716, "\u0120filed": 5717, "aine": 5718, "\u0120van": 5719, "\u0120mir": 5720, "\u0120column": 5721, "icted": 5722, "eper": 5723, "\u0120rot": 5724, "\u0120consult": 5725, "\u0120entry": 5726, "\u0120marijuana": 5727, "\u0120Dou": 5728, "\u0120apparently": 5729, "oking": 5730, "clusive": 5731, "\u0120increases": 5732, "ano": 5733, "\u0120specifically": 5734, "\u0120tele": 5735, "ensions": 5736, "\u0120religion": 5737, "abilities": 5738, "\u0120frame": 5739, "\u0120Note": 5740, "\u0120Lee": 5741, "\u0120helping": 5742, "\u0120edge": 5743, "oston": 5744, "\u0120organizations": 5745, "\u00c3\u0125": 5746, "\u0120Both": 5747, "hips": 5748, "\u0120bigger": 5749, "\u0120boost": 5750, "\u0120Stand": 5751, "\u0120row": 5752, "uls": 5753, "abase": 5754, "\u0120rid": 5755, "Let": 5756, "aren": 5757, "rave": 5758, "\u0120stret": 5759, "PD": 5760, "\u0120vision": 5761, "\u0120wearing": 5762, "\u0120appreci": 5763, "\u0120award": 5764, "\u0120Use": 5765, "\u0120factor": 5766, "war": 5767, "ulations": 5768, ")(": 5769, "\u0120god": 5770, "\u0120territ": 5771, "\u0120param": 5772, "asts": 5773, "87": 5774, "\u0120enemies": 5775, "\u0120Games": 5776, "FF": 5777, "\u0120accident": 5778, "Well": 5779, "\u0120Martin": 5780, "TER": 5781, "\u0120ath": 5782, "\u0120Hell": 5783, "\u0120forg": 5784, "\u0120veter": 5785, "\u0120Medic": 5786, "free": 5787, "\u0120stars": 5788, "\u0120expensive": 5789, "\u0120acad": 5790, "rawn": 5791, "\u0120Whe": 5792, "\u0120lock": 5793, "\u0120format": 5794, "\u0120soldiers": 5795, "sm": 5796, "\u0120agent": 5797, "\u0120responsibility": 5798, "ora": 5799, "\u0120Science": 5800, "\u0120rapid": 5801, "\u0120tough": 5802, "\u0120Jesus": 5803, "\u0120believes": 5804, "ML": 5805, "\u0120wear": 5806, "lete": 5807, "\u00c3\u0125\u00c3\u0124": 5808, "\u0120Dri": 5809, "\u0120commission": 5810, "\u0120Bob": 5811, "Oh": 5812, "aped": 5813, "\u0120warm": 5814, "\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124": 5815, "\u01202003": 5816, "ortion": 5817, "\u0120hasn": 5818, "uster": 5819, "\u0120univers": 5820, "\u0120Ill": 5821, "\u0120king": 5822, "ologies": 5823, "94": 5824, "\u0120Tem": 5825, "\u0120Mos": 5826, "\u0120patient": 5827, "\u0120Mexico": 5828, "cean": 5829, "\u0120Death": 5830, "\u0120Sanders": 5831, "you": 5832, "\u0120Cast": 5833, "\u0120Company": 5834, "pty": 5835, "\u0120happening": 5836, "FP": 5837, "\u0120Battle": 5838, "\u0120bought": 5839, "Am": 5840, "Mod": 5841, "Us": 5842, "uters": 5843, "\u0120Cre": 5844, "\u0120Those": 5845, "\u012044": 5846, "iser": 5847, "\u0120soul": 5848, "\u0120Top": 5849, "\u0120Harry": 5850, "\u0120Aw": 5851, "\u0120seat": 5852, "ffee": 5853, "\u0120revolution": 5854, "\u0120(\"": 5855, "\u0120During": 5856, "ette": 5857, "\u0120ring": 5858, "\u0120offensive": 5859, "\u0120returns": 5860, "\u0120videos": 5861, "\u0120discl": 5862, "\u0120famous": 5863, "enced": 5864, "\u0120Sign": 5865, "\u0120River": 5866, "\u0120300": 5867, "PM": 5868, "\u0120Bus": 5869, "\u0120CH": 5870, "\u0120candidates": 5871, "arden": 5872, "\u0120percentage": 5873, "\u0120visual": 5874, "\u0120thank": 5875, "\u0120trouble": 5876, "nergy": 5877, "\u01202001": 5878, "\u0120prove": 5879, "ashion": 5880, "\u0120enh": 5881, "\u0120Long": 5882, "UM": 5883, "\u0120connected": 5884, "\u0120possibility": 5885, "Over": 5886, "\u0120expert": 5887, "\u0120library": 5888, "arts": 5889, "\u0120Director": 5890, "\u0120fellow": 5891, "92": 5892, "irty": 5893, "\u0120dry": 5894, "\u0120signs": 5895, "\u0120Love": 5896, "\u0120quiet": 5897, "foot": 5898, "\u0120pure": 5899, "\u0120Hun": 5900, "\u0120filled": 5901, "phas": 5902, "\u0120Elect": 5903, "endment": 5904, "\u0120Expl": 5905, "\u0120unable": 5906, "ns": 5907, "mo": 5908, "\u0120vast": 5909, "obe": 5910, "\u0120identify": 5911, "apping": 5912, "\u0120Carolina": 5913, "gress": 5914, "\u0120prote": 5915, "\u0120fish": 5916, "\u0120circumstances": 5917, "razy": 5918, "\u0120Phot": 5919, "\u0120bodies": 5920, "\u0120Mur": 5921, "\u0120developing": 5922, "\u0120AR": 5923, "\u0120experienced": 5924, "\u0120substant": 5925, "\u0120Board": 5926, "esome": 5927, "\u0120domestic": 5928, "\u0120combined": 5929, "\u0120Put": 5930, "\u0120chemical": 5931, "\u0120Child": 5932, "\u0120pool": 5933, "\u0120Cy": 5934, "\u0120egg": 5935, "cons": 5936, "sters": 5937, "\u0120hurt": 5938, "\u0120markets": 5939, "\u0120conservative": 5940, "\u0120supporters": 5941, "\u0120agencies": 5942, "idel": 5943, "Ob": 5944, "urb": 5945, "\u012043": 5946, "\u0120Defense": 5947, "ye": 5948, "\u0120Ap": 5949, "dule": 5950, "\u0120temperature": 5951, "\u0120conducted": 5952, "\u0120Chief": 5953, "\u0120pulled": 5954, "\u0120fol": 5955, "Last": 5956, "onto": 5957, "osis": 5958, "VER": 5959, "Des": 5960, "\u0120Pan": 5961, "First": 5962, "\u0120advance": 5963, "\u0120license": 5964, "rors": 5965, "\u0120Jon": 5966, "\u0120imagine": 5967, "\u0120hell": 5968, "\u0120fixed": 5969, "\u0120incor": 5970, "osite": 5971, "\u0120Log": 5972, "icken": 5973, "]:": 5974, "\u0120surprise": 5975, "hab": 5976, "\u0120craft": 5977, "olt": 5978, "\u0120Jul": 5979, "\u0120dial": 5980, "\u0120relevant": 5981, "\u0120entered": 5982, "\u0120leads": 5983, "\u0120AD": 5984, "\u0120Clean": 5985, "\u0120pictures": 5986, "essor": 5987, "\u0120alt": 5988, "\u0120paying": 5989, "Per": 5990, "\u0120Market": 5991, "\u0120updates": 5992, "amily": 5993, "\u0120Type": 5994, "\u0120Home": 5995, "\u012055": 5996, "sembly": 5997, "rome": 5998, "83": 5999, "\u0120greatest": 6000, "\u0120height": 6001, "\u0120heav": 6002, "aints": 6003, "\u0120listen": 6004, "aser": 6005, "\u0120SH": 6006, "\u0120capable": 6007, "acle": 6008, "\u0120perspect": 6009, "inating": 6010, "\u0120offering": 6011, "rypt": 6012, "\u0120Develop": 6013, "abin": 6014, "rc": 6015, "\u0120bright": 6016, "alty": 6017, "arrow": 6018, "\u0120suppl": 6019, "inding": 6020, "acked": 6021, "gypt": 6022, "\u0120Another": 6023, "pg": 6024, "\u0120Virginia": 6025, "\u0120Lu": 6026, "\u0120planned": 6027, "\u0120pit": 6028, "\u0120sweet": 6029, "Type": 6030, "\u0120Di": 6031, "\u0120typically": 6032, "\u0120Francisco": 6033, "\u0120prospect": 6034, "\u0120Dan": 6035, "\u0120teen": 6036, "rees": 6037, "\u0120sched": 6038, "\u0120hol": 6039, "\u0120scr": 6040, "\u0120lots": 6041, "life": 6042, "\u0120newsp": 6043, "\u0120forget": 6044, "\u0120None": 6045, "\u0120Middle": 6046, "\u0120Ryan": 6047, "edd": 6048, "\u0120severe": 6049, "\u0120suit": 6050, "ller": 6051, "93": 6052, "\u0120correspond": 6053, "\u0120explos": 6054, "uations": 6055, "\u0120flag": 6056, "game": 6057, "rid": 6058, "\u0120prin": 6059, "\u0120Data": 6060, "\u0120deploy": 6061, "\u0120Enter": 6062, "suit": 6063, "ghan": 6064, "\u0120Men": 6065, "\u0120thoughts": 6066, "\u0120matters": 6067, "\u0120adapt": 6068, "\u0120Ari": 6069, "\u0120fill": 6070, "\u0120forth": 6071, "\u0120sam": 6072, "\u012041": 6073, "\u0120payment": 6074, "\u0120Hor": 6075, "\u0120spring": 6076, "duc": 6077, "\u0120losing": 6078, "\u0120bringing": 6079, "FO": 6080, "ala": 6081, "\u0120distribution": 6082, "hered": 6083, "bour": 6084, "\u0120Israeli": 6085, "oma": 6086, "\u0120combination": 6087, "\u0120plenty": 6088, "VE": 6089, "Can": 6090, "\u0120Haw": 6091, "\u0120perman": 6092, "\u0120Special": 6093, "\u0120tow": 6094, "\u0120seeking": 6095, "\u0120examples": 6096, "\u0120classes": 6097, "cr": 6098, "\u0120beer": 6099, "\u0120moves": 6100, "\u0120IP": 6101, "\u0120Kn": 6102, "\u0120panel": 6103, "Even": 6104, "\u0120properly": 6105, "\u0120ris": 6106, "\u0120plug": 6107, "\u0120estimated": 6108, "Every": 6109, "\u0120defensive": 6110, "agraph": 6111, "\u0120pregn": 6112, "\u0120instit": 6113, "\u0120Vict": 6114, "\u0120volume": 6115, "\u0120positions": 6116, "\u0120links": 6117, "\u0120Program": 6118, "\u0120Week": 6119, "agues": 6120, "\u0120transform": 6121, "ker": 6122, "\u0120CEO": 6123, "\u0120cas": 6124, "\u0120opponent": 6125, "\u0120tweet": 6126, "\u0120Code": 6127, "\u0120shop": 6128, "\u0120fly": 6129, "\u0120talks": 6130, "\u0120bag": 6131, "Phone": 6132, "\u0120aid": 6133, "\u0120plants": 6134, "\u012065": 6135, "\u0120attorney": 6136, "arters": 6137, "quest": 6138, "\u0120Magic": 6139, "\u0120begins": 6140, "\u0120myster": 6141, "\u0120environmental": 6142, "\u0120storage": 6143, "NN": 6144, "\u0120marg": 6145, "\u0120ske": 6146, "\u0120metal": 6147, "elly": 6148, "\u0120ordered": 6149, "\u0120remained": 6150, "\u0120loved": 6151, "\u0120prompt": 6152, "\u0120updated": 6153, "\u0120experts": 6154, "\u0120walking": 6155, "\u0120ancient": 6156, "\u0120performed": 6157, "ATE": 6158, "\u0120neither": 6159, "iency": 6160, "\u0120manufacture": 6161, "\u0120Pak": 6162, "\u0120selected": 6163, "\u0120mine": 6164, "\u0120ultimately": 6165, "\u0120explan": 6166, "\u0120label": 6167, "\u0120Services": 6168, "ributed": 6169, "Trump": 6170, "\u0120syn": 6171, "\u0120Ult": 6172, "SC": 6173, "\u0120meat": 6174, "\u0120giant": 6175, "\u0120Wars": 6176, "\u0120ON": 6177, "\u0120adm": 6178, "\u0120interpret": 6179, "\u0120evening": 6180, "\u0120evil": 6181, "\u0120Boston": 6182, "\u0120Wild": 6183, "\u0120\u00c3": 6184, "\u0120Bitcoin": 6185, "\u0120Amazon": 6186, "Dr": 6187, "\u0120Information": 6188, "\u0120obviously": 6189, "\u0120advanced": 6190, "Photo": 6191, "olar": 6192, "\u0120weather": 6193, "\u0120symbol": 6194, "\u0120sole": 6195, "\u0120potentially": 6196, "oster": 6197, "\u0120originally": 6198, "mun": 6199, "300": 6200, "aze": 6201, "essions": 6202, "\u0120deck": 6203, "\u0120stood": 6204, "\u0120youth": 6205, "\u0120Bern": 6206, "Rep": 6207, "\u0120Test": 6208, "\u0120basically": 6209, "otic": 6210, "\u0120involve": 6211, "olit": 6212, "lyn": 6213, "See": 6214, "\u0120aircraft": 6215, "\u0120confirm": 6216, "EW": 6217, "\u0120messages": 6218, "\u0120Richard": 6219, "\u0120kit": 6220, "\u0120prohib": 6221, "\u0120vulner": 6222, "isters": 6223, "\u0120existence": 6224, "\u0120turning": 6225, "\u0120SP": 6226, "\u0120desire": 6227, "\u0120flat": 6228, "\u0120ment": 6229, "season": 6230, "anges": 6231, "\u0120neighborhood": 6232, "\u0120Lake": 6233, "ATION": 6234, "\u0120pointed": 6235, "bur": 6236, "\u0120innov": 6237, "ucks": 6238, "UL": 6239, "\u0120professor": 6240, "\u0120expressed": 6241, "AB": 6242, "icious": 6243, "\u01202002": 6244, "\u0120Dev": 6245, "\u0120session": 6246, "\u0120bare": 6247, "sen": 6248, "\u0120diss": 6249, "\u0120Cath": 6250, "\u0120Pass": 6251, "\u0120Point": 6252, "\u0120doctor": 6253, "orrow": 6254, "ailed": 6255, "\u0120Rub": 6256, "\u0120DC": 6257, "\u0120Charl": 6258, "person": 6259, "\u0120writer": 6260, "ighters": 6261, "ureau": 6262, "\u0120oblig": 6263, "\u0120recorded": 6264, "\u0120broke": 6265, "\u0120orders": 6266, "ilty": 6267, "\u0120motion": 6268, "inity": 6269, "law": 6270, "adium": 6271, "\u0120immigration": 6272, "\u0120contrast": 6273, "\u0120batt": 6274, "\u0120excellent": 6275, "\u0120technical": 6276, "ami": 6277, "\u0120tun": 6278, "\u0120cloud": 6279, "\u0120Year": 6280, "geon": 6281, "\u0120creation": 6282, "\u0120strange": 6283, "\u0120auth": 6284, "\u0120fort": 6285, "born": 6286, "\u0120extent": 6287, "\u0120Today": 6288, "\u0120Club": 6289, "\u0120rain": 6290, "\u0120sample": 6291, "\u0120accepted": 6292, "\u0120tact": 6293, "\u0120fired": 6294, "\u0120Son": 6295, "\u0120stands": 6296, "\u0120boot": 6297, "\u012047": 6298, "\u0120statements": 6299, "\u0120versions": 6300, "\u0120selling": 6301, "ounded": 6302, "\u01201990": 6303, "\u0120weren": 6304, "\u0120Watch": 6305, "\u0120experiment": 6306, "Post": 6307, "\u0120retail": 6308, "uled": 6309, "Inst": 6310, "unte": 6311, "\u00e3\u0125\u00bc": 6312, "\u0120depart": 6313, "\u0120bond": 6314, "ivery": 6315, "ompl": 6316, "\u0120reaction": 6317, "\u0120Syrian": 6318, "\u0120Pac": 6319, "apped": 6320, "aniel": 6321, "DP": 6322, "\u0120resolution": 6323, "\u0120react": 6324, "\u0120approved": 6325, "onom": 6326, "mond": 6327, "\u0120Offic": 6328, "---": 6329, "\u0120replace": 6330, "\u0120tack": 6331, "\u0120sport": 6332, "\u0120chain": 6333, "\u0120emergency": 6334, "rad": 6335, "\u0120Palestin": 6336, "\u012046": 6337, "\u0120automatically": 6338, "\u0120route": 6339, "\u0120pal": 6340, "\u0120banks": 6341, "\u0120Paris": 6342, "\u0120Media": 6343, "road": 6344, "icing": 6345, "ixt": 6346, "isted": 6347, "\u0120grew": 6348, "\u0120coord": 6349, "\u0120Where": 6350, "omin": 6351, "\u0120subs": 6352, "\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd": 6353, "\u0120\u00c2\u00b1": 6354, "\u0120corporate": 6355, "\u0120selection": 6356, "noon": 6357, "\u0120Report": 6358, "cs": 6359, "cluding": 6360, "orders": 6361, "anche": 6362, "\u0120Its": 6363, "\u0120slowly": 6364, "\u0120Egypt": 6365, "\u0120Acc": 6366, "\u0120colle": 6367, "iques": 6368, "EX": 6369, "\u0120attempts": 6370, "url": 6371, "\u0120Cross": 6372, "\u0120findings": 6373, "\u0120SC": 6374, "\u0120OR": 6375, "\u0120index": 6376, "ensity": 6377, "\u0120Way": 6378, "\u0120Land": 6379, "\u0120shock": 6380, "dis": 6381, "\u0120dynam": 6382, "\u0120cart": 6383, "mosp": 6384, "Since": 6385, "iest": 6386, "\u0120Boy": 6387, "\u0120storm": 6388, "\u0120Contin": 6389, "2013": 6390, "hew": 6391, "ilit": 6392, "\u0120essential": 6393, "iquid": 6394, "Other": 6395, "ivered": 6396, "\u0120reasonable": 6397, "Act": 6398, "\u0120subsequ": 6399, "\u0120Pack": 6400, "\u0120Fort": 6401, "\u0120considering": 6402, "\u0120university": 6403, "log": 6404, "\u0120married": 6405, "\u0120illust": 6406, "\u0120True": 6407, "\u00a3\u0131": 6408, "\u0120numerous": 6409, "rastructure": 6410, "\u0120seriously": 6411, "\u0120referred": 6412, "ua": 6413, "\u0120consistent": 6414, "onna": 6415, "\u0120Real": 6416, "ruption": 6417, "ciples": 6418, "\u0120facts": 6419, "91": 6420, "otes": 6421, "erg": 6422, "Then": 6423, "\u0120accompl": 6424, "Note": 6425, "\u0120revenue": 6426, "\u0120passing": 6427, "\u0120mal": 6428, "een": 6429, "\u0120Yet": 6430, "\u0120gather": 6431, "terday": 6432, "ework": 6433, "\u0120Author": 6434, "Pe": 6435, "\u0120optim": 6436, "\u0120rub": 6437, "\u0120\u00e8\u00a3\u0131": 6438, "\u0120unknown": 6439, "stone": 6440, "\u0120union": 6441, "olve": 6442, "\u0120opportunities": 6443, "\u0120browser": 6444, "\u0120Wal": 6445, "\u0120Cost": 6446, "\u0120reporting": 6447, "sts": 6448, "pet": 6449, "\u0120sand": 6450, "\u0120suddenly": 6451, "\u0120surprising": 6452, "\u0120VR": 6453, "\u0120somewhat": 6454, "\u0120Bas": 6455, "ulture": 6456, "izz": 6457, "\u0120CD": 6458, "\u0120challenges": 6459, "\u0120settings": 6460, "\u0120experiences": 6461, "\u0120Full": 6462, "\u0120cann": 6463, "\u0120receiving": 6464, "EST": 6465, "\u0120joint": 6466, "\u0120cultural": 6467, "\u0120ast": 6468, "82": 6469, "astern": 6470, "ceived": 6471, "\u0120Cru": 6472, "\u0120bull": 6473, "pired": 6474, "amm": 6475, "\u0120facing": 6476, "power": 6477, "\u0120boss": 6478, "\u0120Hol": 6479, "\u0120instr": 6480, "\u0120increasingly": 6481, "\u0120shift": 6482, "\u0120streets": 6483, "\u0120Williams": 6484, "abb": 6485, "\u0120lie": 6486, "\u0120laugh": 6487, "\u0120Ca": 6488, "PL": 6489, "\u0120adults": 6490, "\u0120customer": 6491, "\u0120obtained": 6492, "\u0120supporting": 6493, "html": 6494, "fire": 6495, "\u0120detailed": 6496, "\u0120picked": 6497, "\u0120Right": 6498, "lder": 6499, "EE": 6500, "stood": 6501, "\u0120Kim": 6502, "\u0120wire": 6503, "\u0120sight": 6504, "\u0120developers": 6505, "\u0120persons": 6506, "\u0120sad": 6507, "\u0120cup": 6508, "\u0120warning": 6509, "\u0120boys": 6510, "long": 6511, "\u0120bird": 6512, "fo": 6513, "\u0120wal": 6514, "\u0120observed": 6515, "\u0120zone": 6516, "iveness": 6517, "\u0120channel": 6518, "cript": 6519, "\u0120refused": 6520, "\u0120Again": 6521, "\u0120suc": 6522, "\u0120spokesman": 6523, "\u0120Ref": 6524, "rite": 6525, "ouston": 6526, "\u00e3\u0125\u00b3": 6527, "\u0120Sher": 6528, "\u0120acts": 6529, "\u0120Name": 6530, "\u0120struggle": 6531, "arry": 6532, "ometimes": 6533, "\u0120discrim": 6534, "HT": 6535, "\u0120category": 6536, "\u0120realize": 6537, "\u0120employee": 6538, "\u0120Afghan": 6539, "enger": 6540, "\u0120guns": 6541, "\u0120Steve": 6542, "\u0120Mot": 6543, "\u0120Ol": 6544, "oked": 6545, "\u0120thick": 6546, "\u0120fairly": 6547, "illy": 6548, "\u0120surve": 6549, "\u0120Mat": 6550, "weight": 6551, "\u00e2\u0136": 6552, "\u0120troops": 6553, "\u0120agents": 6554, "\u0120battery": 6555, "\u0120motiv": 6556, "\u00c3\u00a1": 6557, "Sec": 6558, "den": 6559, "overy": 6560, "LS": 6561, "\u0120flu": 6562, "\u0120confident": 6563, "\u0120Oper": 6564, "\u0120empty": 6565, "\u0120phen": 6566, "\u0120sector": 6567, "\u0120excited": 6568, "\u0120remote": 6569, "aph": 6570, "oen": 6571, "\u0120destroyed": 6572, "\u0120moral": 6573, "\u0120HP": 6574, "\u0120Ron": 6575, "\u0120dress": 6576, "\u0120Bat": 6577, "\u0120lit": 6578, "\u0120MS": 6579, "\u0120af": 6580, "HL": 6581, "rum": 6582, "isms": 6583, "\u0120shouldn": 6584, "\u0120sympt": 6585, "\u0120Toronto": 6586, "hetic": 6587, "\u0120carbon": 6588, "\u0120installed": 6589, "\u0120violent": 6590, "\u0120solar": 6591, "ja": 6592, "\u0120practices": 6593, "\u0120ride": 6594, "\u0120Penn": 6595, "\u0120improved": 6596, "\u0120audio": 6597, "\u0120behavi": 6598, "\u0120PS": 6599, "\u0120eating": 6600, "Data": 6601, "\u0120Review": 6602, "pass": 6603, "claim": 6604, "uated": 6605, "angers": 6606, "chen": 6607, "\u0120properties": 6608, "\u0120anywhere": 6609, "Another": 6610, "\u0120blow": 6611, "\u0120Jackson": 6612, "\u0120proud": 6613, "\u0120plane": 6614, "lines": 6615, "\u0120square": 6616, "\u0120proof": 6617, "ansas": 6618, "\u0120talked": 6619, "makers": 6620, "\u0120sister": 6621, "\u0120holds": 6622, "\u0120resident": 6623, "\u0120==": 6624, "\u0120resistance": 6625, "\u0120split": 6626, "\u0120prosecut": 6627, "\u0120confidence": 6628, "resents": 6629, "\u0120cuts": 6630, "\u0120exception": 6631, "\u0120zero": 6632, "Getty": 6633, "\u0120copyright": 6634, "\u0120totally": 6635, "ormal": 6636, "ifications": 6637, "\u0120Australian": 6638, "\u0120sick": 6639, "\u0120150": 6640, "\u0120household": 6641, "\u0120fees": 6642, "\u0120drivers": 6643, "ogen": 6644, "\u0120NY": 6645, "\u0120necessarily": 6646, "\u0120regulations": 6647, "earing": 6648, "sl": 6649, "\u0120perspective": 6650, "care": 6651, "icial": 6652, "His": 6653, "\u0120escape": 6654, "\u0120surprised": 6655, "\u0120Van": 6656, "urrent": 6657, "\u0120vac": 6658, "81": 6659, "\u0120Thus": 6660, "\u0120emphas": 6661, "\u0120Champions": 6662, "\u0120Ice": 6663, "\u0120narr": 6664, "\u0120heads": 6665, "\u0120causing": 6666, "bel": 6667, "fortunately": 6668, "\u0120Ma": 6669, "\u0120targets": 6670, "cipl": 6671, "\u0120afternoon": 6672, "\u0120adds": 6673, "\u0120Maybe": 6674, "\u0120Four": 6675, "essed": 6676, "plete": 6677, "\u0120usual": 6678, "cho": 6679, "ingu": 6680, "\u0120withd": 6681, "\u0120Energy": 6682, "\u0120Econom": 6683, "OO": 6684, "\u0120articles": 6685, "\u0120injured": 6686, "\u0120manage": 6687, "\u0120explains": 6688, "\u0120diagn": 6689, "Rec": 6690, "atures": 6691, "\u0120linked": 6692, "\u0120discussed": 6693, "\u0120explo": 6694, "\u0120occasion": 6695, "athan": 6696, "\u0120opposite": 6697, "\u0120faces": 6698, "\u0120denied": 6699, "\u0120Knight": 6700, "\u0120nut": 6701, "\u0120approximately": 6702, "\u0120disappoint": 6703, "onymous": 6704, "\u0120Best": 6705, "\u0120Lo": 6706, "\u0120Hy": 6707, "\u0120Aff": 6708, "\u0120voting": 6709, "anwhile": 6710, "\u0120III": 6711, "\u0120institutions": 6712, "agram": 6713, "\u0120Daily": 6714, "\u0120drag": 6715, "\u0120nearby": 6716, "\u0120guilty": 6717, "\u0120conver": 6718, "Pre": 6719, "ship": 6720, "\u0120reward": 6721, "\u0120philosoph": 6722, "\u0120SS": 6723, "ugh": 6724, "\u0120apps": 6725, "friend": 6726, "\u0120upper": 6727, "\u0120advert": 6728, "\u0120snow": 6729, "\u0120frust": 6730, "\u0120ourselves": 6731, "Fr": 6732, "\u0120Die": 6733, "ampion": 6734, "\u0120dismiss": 6735, "\u0120cere": 6736, "\u0120signal": 6737, "from": 6738, "\u0120).": 6739, "\u012052": 6740, "\u0120crimes": 6741, "itors": 6742, "estival": 6743, "useum": 6744, "\u0120council": 6745, "\u0120Saud": 6746, "May": 6747, "\u0120Gun": 6748, "ician": 6749, "ether": 6750, "\u0120sufficient": 6751, "\u0120Hen": 6752, "sole": 6753, "\u0120historical": 6754, "\u0120Far": 6755, "\u0120Turn": 6756, "\u0120pin": 6757, "\u0120succeed": 6758, "mat": 6759, "lymp": 6760, "\u0120tradition": 6761, "\u0120Ok": 6762, "\u0120cro": 6763, "\u0120description": 6764, "alle": 6765, "\u0120sky": 6766, "Te": 6767, "\u0120widely": 6768, "\u0120wave": 6769, "\u0120definition": 6770, "\u0120Jews": 6771, "\u0120cycle": 6772, "\u0120refere": 6773, "\u0120brings": 6774, "usal": 6775, "\u0120alive": 6776, "\u0120frequently": 6777, "\u0120intention": 6778, "\u0120Control": 6779, "lv": 6780, "ystem": 6781, "\u0120privacy": 6782, "gent": 6783, "rence": 6784, "\u0120Quest": 6785, "\u0120Christmas": 6786, "\u0120rail": 6787, "\u0120cooper": 6788, "\u0120tested": 6789, "\u0120Capt": 6790, "asks": 6791, "\u0120comfortable": 6792, "\u0120delivered": 6793, "scape": 6794, "\u0120depth": 6795, "\u0120GOP": 6796, "\u0120writes": 6797, "\u0120assets": 6798, "\u0120sav": 6799, "iments": 6800, "\u0120transition": 6801, "\u0120artist": 6802, "\u0120Look": 6803, "\u0120lob": 6804, "\u0120components": 6805, "arity": 6806, "\u0120walked": 6807, "\u0120root": 6808, "\u0120participants": 6809, "\u0120noticed": 6810, "\u0120resc": 6811, "\u0120nav": 6812, "\u0120Administ": 6813, "da": 6814, "utral": 6815, "plate": 6816, "\u0120importance": 6817, "\u0120assert": 6818, "iously": 6819, "cription": 6820, "\u0120injuries": 6821, "\u0120Check": 6822, "\u0120registered": 6823, "\u0120intent": 6824, "\u0120missed": 6825, "ographic": 6826, "\u0120sentence": 6827, "ounter": 6828, "\u0120assistance": 6829, "evin": 6830, "\u0120database": 6831, "\u0120buildings": 6832, "\u0120classic": 6833, "\u0120thinks": 6834, "\u0120Ohio": 6835, "Pr": 6836, "ugg": 6837, "\u0120fee": 6838, "pan": 6839, "\u0120effectively": 6840, "\u0120facility": 6841, "\u0120bear": 6842, "\u0120chapter": 6843, "\u0120dogs": 6844, "\u0120Columb": 6845, "\u0120latter": 6846, "itial": 6847, "\u0120admitted": 6848, "TV": 6849, "\u0120Georg": 6850, "\u0120posts": 6851, "\\\\": 6852, "\u0120lawyer": 6853, "\u0120equival": 6854, "\u0120mand": 6855, "\u0120controlled": 6856, "\u0120Walk": 6857, "\u0120Andrew": 6858, "\u0120menu": 6859, "amental": 6860, "\u0120protected": 6861, "va": 6862, "\u0120administr": 6863, "oral": 6864, "\u0120rein": 6865, "\u0120Sar": 6866, "\u0120amounts": 6867, "\u0120native": 6868, "\u0120Moon": 6869, "\u0120represents": 6870, "\u0120abandon": 6871, "\u0120carrying": 6872, "\u0120tank": 6873, "mary": 6874, "\u0120declared": 6875, "Tube": 6876, "\u0120hat": 6877, "\u0120punish": 6878, "ellect": 6879, "mes": 6880, "\u0120universe": 6881, "\u0120Rod": 6882, "phy": 6883, "\u0120infrastructure": 6884, "\u012051": 6885, "\u0120opposed": 6886, "ownt": 6887, "ca": 6888, "\u0120Make": 6889, "\u0120hardware": 6890, "\u0120coffee": 6891, "Rel": 6892, "bal": 6893, "world": 6894, "\u0120Saf": 6895, "\u0120Sea": 6896, "inals": 6897, "\u0120owned": 6898, "\u0120hall": 6899, "ersion": 6900, "\u0120describe": 6901, "\u0120Pot": 6902, "\u0120portion": 6903, "\u0120atmosp": 6904, "\u0120governments": 6905, "\u0120depending": 6906, "\u0120offense": 6907, "\u0120trick": 6908, "awa": 6909, "\u0120Line": 6910, "\u0120Vis": 6911, "\u0120Hard": 6912, "\u0120Orig": 6913, "\u0120Click": 6914, "\u0120desk": 6915, "\u0120Valley": 6916, "\u0120Sov": 6917, "\u0120movies": 6918, "\u0120remark": 6919, "\u0120mail": 6920, "\u0120conscious": 6921, "\u0120ruling": 6922, "\u0120Rights": 6923, "\u0120medic": 6924, "hent": 6925, "\u0120Women": 6926, "><": 6927, "\u0120replaced": 6928, "\u0120Prem": 6929, "\u0120Thanks": 6930, "\u0120renew": 6931, "\u0120Ball": 6932, "iform": 6933, "\u0120shots": 6934, "Comm": 6935, "\u0120armed": 6936, "\u0120constant": 6937, "\u0120taste": 6938, "\u0120realized": 6939, "\u0120buff": 6940, "\u0120mo": 6941, "\u0120efficient": 6942, "Most": 6943, "oration": 6944, "ifies": 6945, "\u0120communication": 6946, "\u0120flood": 6947, "\u0120consequences": 6948, "\u0120anyway": 6949, "igg": 6950, "\u0120GM": 6951, "\u0120Thank": 6952, "\u0120iron": 6953, "\u0120evolution": 6954, "\u0120Cop": 6955, "twitter": 6956, "\u012095": 6957, "\u0120relationships": 6958, "adel": 6959, "\u0120Young": 6960, "\u0120proposal": 6961, "ayers": 6962, "uilding": 6963, "\u0120Hot": 6964, "ORE": 6965, "cos": 6966, "\u0120collabor": 6967, "PG": 6968, "axy": 6969, "\u0120knowing": 6970, "\u0120supports": 6971, "owed": 6972, "\u0120controls": 6973, "\u0120merely": 6974, "umer": 6975, "\u0120athlet": 6976, "\u0120fashion": 6977, "path": 6978, "\u0120gift": 6979, "\u0120era": 6980, "AND": 6981, "\u0120kinds": 6982, "\u0120Korean": 6983, "\u0120legit": 6984, "ulous": 6985, "\u0120essentially": 6986, "\u0120therap": 6987, "nic": 6988, "\u0120suffered": 6989, "\u0120hur": 6990, "\u0120promise": 6991, "\u0120excess": 6992, "\u0120overw": 6993, "\u0120prime": 6994, "\u0120Houston": 6995, "erry": 6996, "\u0120Ms": 6997, "RS": 6998, "2012": 6999, "\u0120stores": 7000, "\u0120Olymp": 7001, "\u0120journey": 7002, "Although": 7003, "Sub": 7004, "\u0120Educ": 7005, "\u0120Chapter": 7006, "\u0120requests": 7007, "\u0120consumers": 7008, "\u0120tiny": 7009, "\u0120isol": 7010, "\u0120Fair": 7011, "ba": 7012, "\u0120YOU": 7013, "\u0120crash": 7014, "celer": 7015, "\u0120emotional": 7016, "\u0120goods": 7017, "\u0120elected": 7018, "\u0120moder": 7019, "\u0120Linux": 7020, "\u0120blocks": 7021, "\u0120island": 7022, "\u0120Society": 7023, "\u0120elections": 7024, "\u0120broadcast": 7025, "\u0120cheap": 7026, "\u0120nations": 7027, "\u0120seasons": 7028, "400": 7029, "\u0120waste": 7030, "\u0120Sat": 7031, "\u0120fields": 7032, "employ": 7033, "\u0120profile": 7034, "\u0120authors": 7035, "ALL": 7036, "\u0120Gra": 7037, "west": 7038, "\u0120Ty": 7039, "\u0120deaths": 7040, "\u0120vacc": 7041, "\u0120formed": 7042, "\u0120du": 7043, "\u0120ongoing": 7044, "\u0120Muslims": 7045, "elf": 7046, "igure": 7047, "\u0120assume": 7048, "\u0120Ukraine": 7049, "water": 7050, "\u0120coast": 7051, "\u0120voted": 7052, "gor": 7053, "\u0120AS": 7054, "\u0120Michigan": 7055, "aza": 7056, "\u0120Arm": 7057, "iro": 7058, "\u0120flex": 7059, "asters": 7060, "''": 7061, "\u0120welcome": 7062, "arl": 7063, "\u0120locations": 7064, "igation": 7065, "\u0120Fil": 7066, "\u0120buying": 7067, "\u0120architect": 7068, "\u0120harder": 7069, "\u0120Cub": 7070, "\u0120interface": 7071, "\u0120restaurant": 7072, "\u0120discover": 7073, "\u0120exceed": 7074, "\u0120favour": 7075, "gery": 7076, "\u0120duty": 7077, "\u0120pitch": 7078, "ador": 7079, "\u0120Mach": 7080, "boy": 7081, "\u0120responded": 7082, "\u0120extended": 7083, "hers": 7084, "Many": 7085, "raid": 7086, "ifer": 7087, "\u0120Ins": 7088, "Ser": 7089, "\u0120medium": 7090, "she": 7091, "\u0120Sports": 7092, "\u0120magazine": 7093, "utation": 7094, "\u0120limits": 7095, "\u0120Gall": 7096, "\u0120external": 7097, "razil": 7098, "\u0120younger": 7099, "tle": 7100, "\u0120remind": 7101, "\u0120CON": 7102, "\u0120immediate": 7103, "\u0120hidden": 7104, "\u0120volunte": 7105, "\u0120simpl": 7106, "odcast": 7107, "\u0120phase": 7108, "dr": 7109, "\u0120plot": 7110, "\u0120exposure": 7111, "RI": 7112, "ograp": 7113, "vin": 7114, "anish": 7115, "\u0120Acad": 7116, "\u0120Engine": 7117, "\u0120expansion": 7118, "\u0120Pay": 7119, "Your": 7120, "\u0120pushed": 7121, "\u0120Ell": 7122, "\u0120Head": 7123, "\u0120marketing": 7124, "\u0120AC": 7125, "ket": 7126, "\u0120hits": 7127, "\u0120gro": 7128, "\u0120Age": 7129, "\u0120Scot": 7130, "][": 7131, "\u0120stim": 7132, "\u0120iPhone": 7133, "\u012a\u0134": 7134, "\u0120narrow": 7135, "\u0120Getty": 7136, "\u0120Turkey": 7137, "\u0120perfectly": 7138, "\u0120enable": 7139, "utch": 7140, "\u0120precise": 7141, "\u0120regime": 7142, "\u0120shif": 7143, "\u0120compens": 7144, "gun": 7145, "div": 7146, "\u0120chosen": 7147, "\u0120Ken": 7148, "Any": 7149, "\u0120trees": 7150, "\u0120recommended": 7151, "\u0120Ren": 7152, "uable": 7153, "\u0120HT": 7154, "Follow": 7155, "EG": 7156, "\u0120Hand": 7157, "\u0120Kenn": 7158, "\u0120arguments": 7159, "\u0120exists": 7160, "\u0120bike": 7161, "\u0120Conserv": 7162, "\u0120breaking": 7163, "\u0120Gar": 7164, "\u0120crazy": 7165, "\u0120virtual": 7166, "aylor": 7167, "ixel": 7168, "\u01201980": 7169, "\u0120permission": 7170, "\u0120Series": 7171, "\u0120consumer": 7172, "\u0120closely": 7173, "called": 7174, "\u012054": 7175, "\u0120hopes": 7176, "\u0120array": 7177, "\u0120Win": 7178, "\u0120Labour": 7179, "\u0120spons": 7180, "\u0120Ire": 7181, "\u0120pow": 7182, "\u0120readers": 7183, "\u0120employment": 7184, "\u0120creature": 7185, "\u0120resulting": 7186, "\u0120accurate": 7187, "\u0120moments": 7188, "\u0120argued": 7189, "\u0120ped": 7190, "During": 7191, "\u012053": 7192, "\u0120Tal": 7193, "\u0120sought": 7194, "\u0120suffering": 7195, "\u0120icon": 7196, "lee": 7197, "\u0120($": 7198, "alian": 7199, "\u00c2\u00b0": 7200, "\u0120pra": 7201, "\u0120bonus": 7202, "(\"": 7203, "ko": 7204, "\u0120acting": 7205, "DE": 7206, "fall": 7207, "\u0120comparison": 7208, "\u0120smooth": 7209, "\u0120NAS": 7210, "upp": 7211, "\u0120Joseph": 7212, "eping": 7213, "\u0120Take": 7214, "\u0120Mid": 7215, "\u0120sending": 7216, "fast": 7217, "\u0120Fall": 7218, "\u0120dealing": 7219, "user": 7220, "\u0120Organ": 7221, "Co": 7222, "\u0120attached": 7223, "\u0120sees": 7224, "%.": 7225, "\u0120typical": 7226, "ART": 7227, "\u0120finds": 7228, "\u0120Asia": 7229, "umin": 7230, "\u0120Core": 7231, "\u0120Ent": 7232, "inent": 7233, "uce": 7234, "\u0120Blood": 7235, "\u0120Never": 7236, "\u0120emails": 7237, "\u0120highlight": 7238, "\u0120confront": 7239, "atus": 7240, "uted": 7241, "\u0120unus": 7242, "\u0120topic": 7243, "\u0120Adam": 7244, "\u0120ble": 7245, "ati": 7246, "\u0120understood": 7247, "Set": 7248, "struct": 7249, "TP": 7250, "\u0120mob": 7251, "aa": 7252, "\u0120Start": 7253, "pected": 7254, "sell": 7255, "\u0120dedicated": 7256, "\u0120CA": 7257, "uan": 7258, "\u0120songs": 7259, "escription": 7260, "\u0120tech": 7261, "\u0120rape": 7262, "\u0120aside": 7263, "\u0120grant": 7264, "\u012056": 7265, "sub": 7266, "\u0120argue": 7267, "\u0120containing": 7268, "\u0120schedule": 7269, "\u0120liberal": 7270, "\u0120publicly": 7271, "\u0120heavily": 7272, "\u0120Ut": 7273, "iner": 7274, "\u0120Section": 7275, "\u0120Care": 7276, "weet": 7277, "ls": 7278, "Dis": 7279, "\u00e2\u0136\u0122": 7280, "\u0120Follow": 7281, "Back": 7282, "\u0120IT": 7283, "\u0120bes": 7284, "ji": 7285, "\u0120Hit": 7286, "ested": 7287, "\u0120everybody": 7288, "\u0120Swed": 7289, "\u0120femin": 7290, "\u0120facilities": 7291, "\u0120conven": 7292, "Comp": 7293, "\u0120OS": 7294, "core": 7295, "\u0120anx": 7296, "\u0120division": 7297, "\u0120Cam": 7298, "\u0120Stan": 7299, "mates": 7300, "\u0120explore": 7301, "plom": 7302, "\u0120shares": 7303, "pload": 7304, "anes": 7305, "\u0120ideal": 7306, "eters": 7307, "\u0120Base": 7308, "\u0120plastic": 7309, "\u0120distinct": 7310, "\u0120Network": 7311, "\u0120Seattle": 7312, "\u0120trading": 7313, "ensus": 7314, "intend": 7315, "\u0120exhib": 7316, "\u0120initially": 7317, "\u0120Food": 7318, "\u0120thousand": 7319, "\u0120Business": 7320, "acter": 7321, "\u0120paragraph": 7322, "\u0120roughly": 7323, "\u0120www": 7324, "\u0120creative": 7325, "\u0120Conf": 7326, "\u0120consumption": 7327, "\u0120films": 7328, "agan": 7329, "\u0120obtain": 7330, "\u0120tall": 7331, "\u0120tor": 7332, "\u0120acknowled": 7333, "\u0120grown": 7334, "alo": 7335, "KE": 7336, "\u0120400": 7337, "enders": 7338, "taining": 7339, "UG": 7340, "\u0120suicide": 7341, "\u0120watched": 7342, "\u0120List": 7343, "ali": 7344, "rehens": 7345, "\u0120surrounding": 7346, "\u0120pip": 7347, "\u0120flying": 7348, "\u0120Java": 7349, "ordan": 7350, "\u0120serving": 7351, "inations": 7352, "post": 7353, "\u0120sho": 7354, "Av": 7355, "\u0120jail": 7356, "zy": 7357, "\u01201999": 7358, "\u0120</": 7359, "\u0120literally": 7360, "\u0120Sir": 7361, "\u0120exposed": 7362, "\u0120lies": 7363, "star": 7364, "\u0120bat": 7365, "\u0120earned": 7366, "\u0120Dig": 7367, "\u0120specified": 7368, "\u0120Season": 7369, "\u0120degrees": 7370, "Donald": 7371, "\u0120centre": 7372, "\u0120sharing": 7373, "\u0120winter": 7374, "\u0120CO": 7375, "Che": 7376, "\u0120\u00ce": 7377, "MP": 7378, "\u0120unw": 7379, "\u0120fewer": 7380, "\u0120Mir": 7381, "\u0120somewhere": 7382, "\u0120Key": 7383, "\u0120attacked": 7384, "\u0120Kir": 7385, "\u0120domain": 7386, "\u0120stronger": 7387, "\u012099": 7388, "\u0120penalty": 7389, "Id": 7390, "Script": 7391, "\u0120declined": 7392, "\u0120neck": 7393, "\u0120fraud": 7394, "\u0120currency": 7395, "\u0120rising": 7396, "RC": 7397, "\u00e2\u0122\u00a6\u00e2\u0122\u00a6": 7398, "Hz": 7399, "\u0120tab": 7400, "\u0120talent": 7401, "nam": 7402, "\u0120NBA": 7403, "\u0120village": 7404, "\u0120legs": 7405, "\u0120Next": 7406, "Ed": 7407, "\u0120acid": 7408, "\u0120hyd": 7409, "800": 7410, "\u0120involving": 7411, "\u0120Image": 7412, "\u0120Before": 7413, "Fl": 7414, "\u0120yesterday": 7415, "Source": 7416, "\u0120terrorist": 7417, "\u0120sup": 7418, "\u0120synt": 7419, "\u0120Saudi": 7420, "\u0120west": 7421, "\u0120ru": 7422, "burg": 7423, "\u0120visible": 7424, "\u0120struck": 7425, "rison": 7426, "\u0120awesome": 7427, "\u0120drawn": 7428, "\u0120answers": 7429, "\u0120Girl": 7430, "\u0120Ram": 7431, "\u0120threats": 7432, "\u0120defeat": 7433, "osit": 7434, "\u0120vent": 7435, "aturally": 7436, "American": 7437, "enda": 7438, "\u0120Holy": 7439, "\u0120rum": 7440, "%,": 7441, "case": 7442, "\u0120History": 7443, "\u0120YouTube": 7444, "\u0120situations": 7445, "\u0120DNA": 7446, "Ste": 7447, "\u0120saved": 7448, "Item": 7449, "\u0120recip": 7450, "ologist": 7451, "\u0120faced": 7452, "\u0120elig": 7453, "Once": 7454, "\u0120Li": 7455, "uh": 7456, "\u0120mistake": 7457, "\u0120Division": 7458, "\u0120Bell": 7459, "\u0120symptoms": 7460, "\u00c2\u00ae": 7461, "\u0120domin": 7462, "\u0120falling": 7463, "\u0120ending": 7464, "ashes": 7465, "\u0120matches": 7466, "\u0120Online": 7467, "\u0120explanation": 7468, "Def": 7469, "redit": 7470, "\u0120anymore": 7471, "\u0120Total": 7472, "\u0120FOR": 7473, "ushed": 7474, "\u0120letters": 7475, "\u0120risks": 7476, "\u0120OK": 7477, "\u0120reportedly": 7478, ":\\": 7479, "\u0120plate": 7480, "\u0120subjects": 7481, "\u0120attempted": 7482, "ifier": 7483, "iana": 7484, "\u0120unlikely": 7485, "\u0120Though": 7486, "uma": 7487, "\u0120Invest": 7488, "\u0120Prin": 7489, "ican": 7490, "\u0120Dar": 7491, "\u0120Colorado": 7492, "aug": 7493, "\u0120veget": 7494, "aos": 7495, "ria": 7496, "\u0120shel": 7497, "\u0120marked": 7498, "\u0120()": 7499, "\u0120spr": 7500, "po": 7501, "\u0120Link": 7502, "\u0120defe": 7503, "\u0120Jr": 7504, "\u0120theme": 7505, "\u0120passion": 7506, "\u0120Pen": 7507, "\u0120info": 7508, "izer": 7509, "\u0120shit": 7510, "\u0120Civil": 7511, "apse": 7512, "cre": 7513, "\u0120poly": 7514, "\u0120component": 7515, "\u0120Charles": 7516, "\u0120Ireland": 7517, "\u0120Prov": 7518, "\u0120doctors": 7519, "\u0120granted": 7520, "\u0120paint": 7521, "\u0120honor": 7522, "\u0120smoke": 7523, "\u0120payments": 7524, "\u0120primarily": 7525, "\u0120Kingdom": 7526, "rich": 7527, "atell": 7528, "\u0120deals": 7529, "\u0120scheduled": 7530, "\u0120fundamental": 7531, "\u0120protein": 7532, "\u0120newspaper": 7533, "\u0120clients": 7534, "ython": 7535, "\u0120Date": 7536, "hus": 7537, "\u0120feedback": 7538, "\u0120stretch": 7539, "\u0120cock": 7540, "\u0120hotel": 7541, "\u0120Queen": 7542, "\u0120sugar": 7543, "\u0120ju": 7544, "\u0120milk": 7545, "\u0120approval": 7546, "\u0120Live": 7547, "\u0120equivalent": 7548, "efully": 7549, "\u0120insert": 7550, "zona": 7551, "\u0120extension": 7552, "dri": 7553, "John": 7554, "\u0120accomp": 7555, "Sm": 7556, "\u0120Fund": 7557, "\u0120constantly": 7558, "\u0120``": 7559, "\u0120generated": 7560, "\u0120Action": 7561, "\u0120Psych": 7562, "\u0120Tri": 7563, "\u0120recognize": 7564, "\u0120vary": 7565, "pha": 7566, "\u0120Ra": 7567, "df": 7568, "etch": 7569, "\u0120Soviet": 7570, "Two": 7571, "\u0120patterns": 7572, "\u0120profession": 7573, "aning": 7574, "Time": 7575, "\u0120Lim": 7576, "\u0120colors": 7577, "\u0120Az": 7578, "\u0120TR": 7579, "\u0120infect": 7580, "\u0120phenomen": 7581, "\u0120shell": 7582, "Also": 7583, "\u0120puts": 7584, "\u0120delivery": 7585, "\u0120brown": 7586, "\u0120processing": 7587, "\u0120lights": 7588, "essage": 7589, "\u0120Brook": 7590, "\u0120Aud": 7591, "lation": 7592, "\u0120industrial": 7593, "Like": 7594, "\u0120Brazil": 7595, "rous": 7596, "ESS": 7597, "\u0120Luc": 7598, "\u0120somehow": 7599, "\u012085": 7600, "\u0120proport": 7601, "\u0120politicians": 7602, "\u0120indicate": 7603, "\u0120hole": 7604, "\u0120techniques": 7605, "\u0120competitive": 7606, "\u0120phr": 7607, "\u0120vo": 7608, "istent": 7609, "\u0120Dream": 7610, "\u0120campus": 7611, "\u0120aspects": 7612, "\u0120helpful": 7613, "\u0120shield": 7614, "orse": 7615, "\u0120trigger": 7616, "mal": 7617, "\u012058": 7618, "\u0120tort": 7619, "\u0120personally": 7620, "\u0120tag": 7621, "\u0120keeps": 7622, "\u0120Video": 7623, "\u0120bench": 7624, "\u0120gap": 7625, "aire": 7626, "\u0120east": 7627, "\u0120recovery": 7628, "perial": 7629, "\u0120profit": 7630, "\u0120Mic": 7631, "\u012057": 7632, "\u0120colon": 7633, "\u0120strongly": 7634, "style": 7635, "\u0120allegations": 7636, "han": 7637, "\u0120reporters": 7638, "jo": 7639, "rine": 7640, "arget": 7641, "andal": 7642, "\u012003": 7643, "\u0120flash": 7644, "trans": 7645, "\u0120strict": 7646, "\u0120parking": 7647, "\u0120Pakistan": 7648, "\u0120li": 7649, "\u0120weird": 7650, "\u0120Eric": 7651, "\u0120regions": 7652, "\u0120Jun": 7653, "\u0120intellect": 7654, "\u0120WH": 7655, "oding": 7656, "ributes": 7657, "upid": 7658, "\u0120Tit": 7659, "\u0120finger": 7660, "oria": 7661, "\u0120elev": 7662, "\u0120Field": 7663, "\u0120conclusion": 7664, ";;": 7665, "\u0120feelings": 7666, "\u0120extensive": 7667, "\u0120mixed": 7668, "\u0120neuro": 7669, "vy": 7670, "\u0120harass": 7671, "\u0120Circ": 7672, "ouch": 7673, "\u0120territory": 7674, "\u0120successfully": 7675, "Mar": 7676, "\u0120ingred": 7677, "\u0120overwhel": 7678, "\u0120layer": 7679, "View": 7680, "\u0120allies": 7681, "illance": 7682, "\u0120Three": 7683, "\u0120bunch": 7684, "\u0120normally": 7685, "\u0120networks": 7686, "\u0120sacr": 7687, "\u0120CIA": 7688, "bles": 7689, "\u0120chose": 7690, "\u0120opponents": 7691, "\u0120regardless": 7692, "\u0120franch": 7693, "\u0120pref": 7694, "\u0120Po": 7695, "\u0120bridge": 7696, "anna": 7697, "\u0120Silver": 7698, "\u0120wage": 7699, "page": 7700, "rior": 7701, "\u0120radical": 7702, "\u0120Little": 7703, "\u0120manip": 7704, "\u0120secretary": 7705, "\u0120gang": 7706, "DR": 7707, "FA": 7708, "\u0120decent": 7709, "\u0120Spirit": 7710, "\u0120uncle": 7711, "\u0120Development": 7712, "\u0120investors": 7713, "\u0120walls": 7714, "\u0120publish": 7715, "\u0120generate": 7716, "issions": 7717, "car": 7718, "\u0120promote": 7719, "\u0120cutting": 7720, "\u0120chest": 7721, "\u0120drinking": 7722, "\u0120collected": 7723, "\u012072": 7724, "\u0120hoping": 7725, "\u0120embr": 7726, "gorith": 7727, "\u0120warned": 7728, "\u0120instructions": 7729, "OG": 7730, "\u0120Did": 7731, "\u0120Agency": 7732, "\u0120gear": 7733, "\u0120criticism": 7734, "\u0120Further": 7735, "\u0120util": 7736, "anny": 7737, "Red": 7738, "\u0120counsel": 7739, "\u0120Asian": 7740, "\u0120reduction": 7741, "pool": 7742, "\u0120teaching": 7743, "\u0120deeply": 7744, "iy": 7745, "\u0120estimates": 7746, "\u0120choices": 7747, "\u0120permanent": 7748, "inem": 7749, "kel": 7750, "\u0120fasc": 7751, "pse": 7752, "file": 7753, "\u0120Low": 7754, "\u0120Person": 7755, "\u0120tournament": 7756, "stal": 7757, "\u0120mel": 7758, "UST": 7759, "\u0120Ray": 7760, "azi": 7761, "Val": 7762, "\u0120contained": 7763, "\u0120Holly": 7764, "\u0120wake": 7765, "\u0120reveal": 7766, "\u0120processes": 7767, "\u0120ISIS": 7768, "\u012009": 7769, "\u0120blind": 7770, "\u0120steel": 7771, "\u0120Bad": 7772, "\u0120carefully": 7773, "appy": 7774, "roit": 7775, "\u0120gaming": 7776, "\u0120houses": 7777, "\u0120Coll": 7778, "\u0120truck": 7779, "erm": 7780, "\u0120scored": 7781, "\u0120occas": 7782, "return": 7783, "bound": 7784, "var": 7785, "\u0120sharp": 7786, "\u0120afraid": 7787, "\u0120EX": 7788, "amber": 7789, "cific": 7790, "\u0120scheme": 7791, "NC": 7792, "\u0120Polit": 7793, "\u0120decline": 7794, "\u01201998": 7795, "\u0120pushing": 7796, "\u0120possession": 7797, "\u0120privile": 7798, "\u0120teachers": 7799, "\u0120yield": 7800, "HA": 7801, "\u0120Davis": 7802, "itled": 7803, "########": 7804, "\u0120rig": 7805, "\u0120Daniel": 7806, "acon": 7807, "\u0120hide": 7808, "uten": 7809, "\u0120colleagues": 7810, "\u0120principles": 7811, "\u0120loud": 7812, "\u0120sin": 7813, "\u0120Demon": 7814, "\u0120stone": 7815, "\u012002": 7816, "\u0120taught": 7817, "\u0120terrible": 7818, "\u0120stuck": 7819, "\u0120Policy": 7820, "teen": 7821, "\u0120implementation": 7822, "\u0120BBC": 7823, "\u0120API": 7824, "\u0120wheel": 7825, "allas": 7826, "\u0120champions": 7827, "olars": 7828, "player": 7829, "\u0120repeatedly": 7830, "\u0120Still": 7831, "\u0120likes": 7832, "asty": 7833, "ester": 7834, "\u0120Catholic": 7835, "RL": 7836, "\u0120bath": 7837, "\u0120noise": 7838, "title": 7839, "\u0120northern": 7840, "Part": 7841, "\u0120magn": 7842, "\u0120fab": 7843, "\u0120Ash": 7844, "\u0120displ": 7845, "\u0120ticket": 7846, "\u0120murd": 7847, "\u0120alongside": 7848, "\u0120Music": 7849, "\u0120river": 7850, "\u0120Steel": 7851, "\u0120CL": 7852, "\u0120Player": 7853, "\u0120Mult": 7854, "owing": 7855, "rep": 7856, "size": 7857, "\u0120tur": 7858, "\u0120Georgia": 7859, "iscal": 7860, "raction": 7861, "\u0120cable": 7862, "\u012059": 7863, "\u0120wins": 7864, "\u0120upcoming": 7865, "\u0120survive": 7866, "\u0120inspired": 7867, "\u0120Education": 7868, "\u0120statistics": 7869, "\u0120Foot": 7870, "iami": 7871, "\u0120yellow": 7872, "\u0120Page": 7873, ".-": 7874, "\u0120Has": 7875, "\u0120urban": 7876, "\u0120ax": 7877, "essel": 7878, "\\\"": 7879, "\u0120quarterback": 7880, "\u0120register": 7881, "\u0120Labor": 7882, "\u0120abilities": 7883, "\u0120Family": 7884, "\u0120variable": 7885, "\u0120Price": 7886, "\u0120contem": 7887, "\u0120thin": 7888, "\u0120Equ": 7889, "data": 7890, "\u0120gotten": 7891, "\u0120constit": 7892, "\u0120asks": 7893, "\u0120tail": 7894, "\u0120exciting": 7895, "\u0120Effect": 7896, "\u0120Spanish": 7897, "\u0120encourage": 7898, "inson": 7899, "\u0120Ah": 7900, "\u0120commitment": 7901, "CS": 7902, "\u0120rally": 7903, "\u0120::": 7904, "\u0120subsid": 7905, "\u0120spin": 7906, "\u0120captured": 7907, "2018": 7908, "\u0120innoc": 7909, "\u0120allegedly": 7910, "\u0120Come": 7911, "\u0120artists": 7912, "\u0120Number": 7913, "\u0120electronic": 7914, "\u0120regional": 7915, "apes": 7916, "\u0120wra": 7917, "\u0120myth": 7918, "prise": 7919, "\u0120Miller": 7920, "\u0120Creat": 7921, "\u0120Episode": 7922, "bell": 7923, "\u0120directed": 7924, "\u0120extract": 7925, "\u0120sorry": 7926, "\u0120vice": 7927, "agger": 7928, "\u0120Support": 7929, "\u012066": 7930, "\u0120Iron": 7931, "\u0120wonderful": 7932, "\u0120gra": 7933, "Net": 7934, "ione": 7935, "Eng": 7936, "\u0120ships": 7937, "ikes": 7938, "\u0120Kevin": 7939, "itar": 7940, "\u0120activists": 7941, "true": 7942, "\u0120Arizona": 7943, "enth": 7944, "\u0120Despite": 7945, "\u0120SE": 7946, "\u0120habit": 7947, "ernel": 7948, "\u0120inqu": 7949, "\u0120abortion": 7950, "\u0120void": 7951, "\u0120explicit": 7952, "\u0120engaged": 7953, "\u0120angry": 7954, "\u0120rating": 7955, "\u0120frag": 7956, "bro": 7957, "icking": 7958, "dev": 7959, "\u0120worried": 7960, "\u0120obser": 7961, "\u0120apartment": 7962, "\u0120GT": 7963, "\u0120estate": 7964, "\u0120Constitution": 7965, "emon": 7966, "\u0120Snow": 7967, "\u0120county": 7968, "\u0120disag": 7969, "\u0120Stephen": 7970, "\u0120immigrants": 7971, "wind": 7972, "\u0120Nations": 7973, "\u0120folks": 7974, "Out": 7975, "\u0120gall": 7976, "\u0120targeted": 7977, "\u0120stead": 7978, "\u0120Bon": 7979, "\u0120Lib": 7980, "\u0120informed": 7981, "\u0120120": 7982, "chain": 7983, "idelines": 7984, "orough": 7985, "\u0120driven": 7986, "\u0120regularly": 7987, "\u0120basket": 7988, "\u0120principle": 7989, "ocument": 7990, "\u0120stun": 7991, "ibilities": 7992, "\u0120Roman": 7993, "\u0120About": 7994, "\u0120alert": 7995, "\u0120democracy": 7996, "\u0120represented": 7997, "HS": 7998, "cers": 7999, "parent": 8000, "Art": 8001, "pack": 8002, "\u0120diplom": 8003, "rets": 8004, "\u0120NO": 8005, "\u0120capture": 8006, "\u0120Adv": 8007, "\u0126\u00a2": 8008, "\u0120announcement": 8009, "\u0120Lear": 8010, "\u0120hook": 8011, "\u0120purs": 8012, "\u0120Such": 8013, "\u0120Camer": 8014, "\u0120refugees": 8015, "\u0120Ve": 8016, "Pol": 8017, "\u0120recognized": 8018, "lib": 8019, "\u0120hadn": 8020, "Ass": 8021, "\u0120pilot": 8022, "ushing": 8023, "\u0120returning": 8024, "\u0120trail": 8025, "\u0120Stone": 8026, "\u0120routine": 8027, "\u0120courts": 8028, "\u0120desper": 8029, "\u0120friendly": 8030, "\u0120Italy": 8031, "\u0120pled": 8032, "\u0120breath": 8033, "\u0120studio": 8034, "NS": 8035, "\u0120impressive": 8036, "\u0120Afghanistan": 8037, "\u0120fing": 8038, "\u0120downt": 8039, "inking": 8040, "\u0120Rog": 8041, "iary": 8042, "color": 8043, "sex": 8044, "aron": 8045, "\u0120fault": 8046, "\u0120Nick": 8047, "Down": 8048, "\u0120Rose": 8049, "\u0120Southern": 8050, "XX": 8051, "isodes": 8052, "List": 8053, "600": 8054, "\u0120outcome": 8055, "err": 8056, "\u0120elsewhere": 8057, "\u0120retire": 8058, "\u0120pounds": 8059, "\u0120Global": 8060, "People": 8061, "\u0120communications": 8062, "\u0120loan": 8063, "\u0120ratio": 8064, "\u0120Empire": 8065, "\u0120gonna": 8066, "\u0120invent": 8067, "DF": 8068, "\u01201970": 8069, "\u0120Common": 8070, "pat": 8071, "\u0120promised": 8072, "\u0120dinner": 8073, "\u0120Hom": 8074, "\u0120creates": 8075, "\u0120operate": 8076, "verty": 8077, "\u0120Jordan": 8078, "etime": 8079, "\u0120sustain": 8080, "Reg": 8081, "\u0120incredible": 8082, "ima": 8083, "\u0120warrant": 8084, "\u0120mm": 8085, "Att": 8086, "\u0120lawsuit": 8087, "\u0120reviews": 8088, "iture": 8089, "\u0120Source": 8090, "lights": 8091, "\u0120Ford": 8092, "\u012063": 8093, "group": 8094, "store": 8095, "\u0120featured": 8096, "\u0120forever": 8097, "\u0120poverty": 8098, "\u0120Pop": 8099, "\u0120CNN": 8100, "azz": 8101, "abis": 8102, "aching": 8103, "\u0120laid": 8104, "\u0120Supp": 8105, "\u0120filter": 8106, "ena": 8107, "\u0120Community": 8108, "\u0120creatures": 8109, "uction": 8110, "\u0120Royal": 8111, "\u0120association": 8112, "\u0120Connect": 8113, "\u0120Brad": 8114, "\u00e2\u0138\u012a": 8115, "lers": 8116, "there": 8117, "\u0120Gi": 8118, "\u0120valuable": 8119, "ACK": 8120, "\u0120Taylor": 8121, "\u0120liquid": 8122, "\u0120Attorney": 8123, "\u0120Carl": 8124, "\u0120Final": 8125, "aga": 8126, "\u0120Wilson": 8127, "Because": 8128, "\u0120Professor": 8129, "aka": 8130, "\u0120incredibly": 8131, "rance": 8132, "!)": 8133, "Ref": 8134, "sk": 8135, "\u0120solutions": 8136, "\u0120atmosphere": 8137, "\u0120blame": 8138, "umes": 8139, "\u0120Nob": 8140, "CA": 8141, "umps": 8142, "rical": 8143, "\u0120Putin": 8144, "\u0120Dest": 8145, "oric": 8146, "\u0120PA": 8147, "\u0120respectively": 8148, "wan": 8149, "\u0120fifth": 8150, "\u00e2\u0126\u00a2": 8151, "\u0120Cry": 8152, "\u0120governor": 8153, "resident": 8154, "\u0120purchased": 8155, "\u0120hack": 8156, "\u0120intense": 8157, "obs": 8158, "\u0120origin": 8159, "\u0120define": 8160, "\u0120careful": 8161, "***": 8162, "\u0120shoulder": 8163, "Click": 8164, "\u0120tied": 8165, "\u0120destruction": 8166, "oured": 8167, "\u0120nobody": 8168, "\u0120ho": 8169, "\u0120Exper": 8170, "\u0120tip": 8171, "\";": 8172, "\u0120technique": 8173, "\u0120jur": 8174, "\u0120Pok": 8175, "bow": 8176, "\u0120legend": 8177, "\u0120accord": 8178, "\u0120busy": 8179, "\u0120Intel": 8180, "\u0120hang": 8181, "aki": 8182, ".]": 8183, "\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136": 8184, "\u0120surgery": 8185, "\u0120reprodu": 8186, "\u0120uniform": 8187, "\u0120scenes": 8188, "code": 8189, "\u012062": 8190, "lisher": 8191, "\u0120Have": 8192, "phia": 8193, "\u0120crypt": 8194, "\u0120recon": 8195, "\u0120scream": 8196, "\u0120adopted": 8197, "\u0120scores": 8198, "Ne": 8199, "\u0120Italian": 8200, "including": 8201, "BO": 8202, "\u0120indicated": 8203, "\u0120entertain": 8204, "Gu": 8205, "Text": 8206, "iel": 8207, "\u0120twenty": 8208, "\u0120engage": 8209, "offs": 8210, "\u0120Pacific": 8211, "\u0120smile": 8212, "\u0120personnel": 8213, "\u0120toler": 8214, "\u0120doors": 8215, "\u0120tone": 8216, "\u0120machines": 8217, "\u0120entering": 8218, "tenance": 8219, "CO": 8220, "\u0120Jersey": 8221, "\u0120forest": 8222, "\u0120horse": 8223, "\u0120complaint": 8224, "\u0120Spring": 8225, "yo": 8226, "\u0120Plus": 8227, "eding": 8228, "\u0120Return": 8229, "quarters": 8230, "ials": 8231, "cow": 8232, "\u0120academic": 8233, "\u0120fruit": 8234, "\u01201996": 8235, "ogether": 8236, "\u0120wine": 8237, "\u0120pursu": 8238, "\u0120Steven": 8239, "\u0120licens": 8240, "Who": 8241, "\u0120clothes": 8242, "rection": 8243, "\u0120squad": 8244, "\u0120stable": 8245, "\u0120raw": 8246, "zens": 8247, "Star": 8248, "uties": 8249, "ancer": 8250, "\u0120keys": 8251, "\u0120Mu": 8252, "\u0120complicated": 8253, "iger": 8254, "\u0120Text": 8255, "\u0120absor": 8256, "\u012068": 8257, "\u0120funny": 8258, "\u0120relief": 8259, "\u0120Lew": 8260, "\u0120Cook": 8261, "\u0120chart": 8262, "\u0120drawing": 8263, "GE": 8264, "\u0120module": 8265, "\u0120Bull": 8266, "ILL": 8267, "\u0120salt": 8268, "00000000": 8269, "ille": 8270, "\u0120resource": 8271, "away": 8272, "adelphia": 8273, "\u0120Bru": 8274, "\u012067": 8275, "\u0120somebody": 8276, "\u0120participate": 8277, "\u0120rose": 8278, "wered": 8279, "\u0120muscle": 8280, "\u0120consent": 8281, "\u0120continuing": 8282, "\u0120Guardian": 8283, "\u0120Order": 8284, "regon": 8285, "\u0120rear": 8286, "\u0120provision": 8287, "\u0120liked": 8288, "rient": 8289, "\u0120bra": 8290, "Trans": 8291, "\u0120meetings": 8292, "\u0120tox": 8293, "\u0120convent": 8294, "\u0120auto": 8295, "\u0120recording": 8296, "\u0120Soft": 8297, "001": 8298, "\u0120Roll": 8299, "\u0120programming": 8300, "\u0120pic": 8301, "\u0120proved": 8302, "\u0120stab": 8303, "\u0120Ast": 8304, "\u0120caption": 8305, "ulating": 8306, "\u0120Attack": 8307, "\u0120newly": 8308, "\u01201997": 8309, "fr": 8310, "\u0120discipl": 8311, "\u0120Greek": 8312, "\u0120edition": 8313, "\u0120Does": 8314, "\u0120Box": 8315, "ifle": 8316, "acket": 8317, "\u0120passes": 8318, "\u0120guest": 8319, "\u0120acceler": 8320, "itals": 8321, "UD": 8322, "\u0120authent": 8323, "\u0120Rest": 8324, "oval": 8325, "ta": 8326, "uine": 8327, "\u0120armor": 8328, "\u0120Town": 8329, "\u0120compat": 8330, "\u0120inches": 8331, "Despite": 8332, "\u0120assign": 8333, "herent": 8334, "\u0120prepare": 8335, "\u0120Meg": 8336, "ockey": 8337, "\u0120depends": 8338, "\u0120tracks": 8339, "watch": 8340, "\u0120lists": 8341, "\u0120Northern": 8342, "\u0120alter": 8343, "rec": 8344, "\u0120Eastern": 8345, "\u0120condem": 8346, "\u0120everywhere": 8347, "?'": 8348, "\u0120affili": 8349, "\u0120fought": 8350, "\":{\"": 8351, "\u0120mac": 8352, "itarian": 8353, "\u0120scope": 8354, "\u0120AL": 8355, "aws": 8356, "arms": 8357, "\u0120que": 8358, "\u0120enjoyed": 8359, "nesota": 8360, "\u0120aggressive": 8361, "\u0120Story": 8362, "\u0120IV": 8363, "\u0120recipe": 8364, "\u0120rarely": 8365, "\u0120Medical": 8366, "value": 8367, "angel": 8368, "aying": 8369, "omething": 8370, "\u0120subsection": 8371, "\u0120southern": 8372, "\u0120frequency": 8373, "rete": 8374, "rolled": 8375, "ults": 8376, "\u0120Nic": 8377, "\u0120behalf": 8378, "\u0120sequence": 8379, "abet": 8380, "\u0120controversial": 8381, "\u0120comprom": 8382, "\u0120worker": 8383, "\u0120mainly": 8384, "\u0120algorith": 8385, "\u0120Major": 8386, "orce": 8387, "gender": 8388, "\u0120organized": 8389, "\u0120fake": 8390, "\u0120concluded": 8391, "\u0120ED": 8392, "\u0120Exec": 8393, "rage": 8394, "\u0120chances": 8395, "berry": 8396, "\u0120Trad": 8397, "\u0120configuration": 8398, "\u0120withdraw": 8399, "\u0120fro": 8400, "udes": 8401, "\u0120Brother": 8402, "\u0120Brian": 8403, "\u0120tries": 8404, "\u0120samples": 8405, "\u0120bid": 8406, "\u0120Golden": 8407, "\u0120photograph": 8408, "ifest": 8409, "\u0120DO": 8410, "\u0120Parliament": 8411, "****************": 8412, "Rem": 8413, "\u0120contest": 8414, "\u0120signing": 8415, "px": 8416, "\u0120Zeal": 8417, "\u00e2\u0136\u0122\u00e2\u0136\u0122": 8418, "Ear": 8419, "\u0120exit": 8420, "Before": 8421, "\u0120Corpor": 8422, "null": 8423, "month": 8424, "\u0120racial": 8425, "otted": 8426, "\u0120Veg": 8427, "\u0120Reuters": 8428, "\u0120sword": 8429, "pson": 8430, "\u0120Romney": 8431, "aed": 8432, "\u0120trib": 8433, "\u0120inner": 8434, "\u0120protocol": 8435, "\u0120Bi": 8436, "\u0120Miami": 8437, "everal": 8438, "press": 8439, "\u0120shipping": 8440, "\u0120Amendment": 8441, "\u0120Howard": 8442, "connect": 8443, "\u0120Disc": 8444, "\u0120Jac": 8445, "iamond": 8446, "\u0120Therefore": 8447, "ses": 8448, "\u0120Princess": 8449, "\u0120USB": 8450, "\u0120Anth": 8451, "\u0120surveillance": 8452, "\u0120apolog": 8453, "\u012061": 8454, "owa": 8455, "\u0120fulf": 8456, "js": 8457, "\u0120luck": 8458, "usted": 8459, "\u0120\u00c2\u00a7": 8460, "ni": 8461, "\u0120anticip": 8462, "eman": 8463, "\u0120winner": 8464, "\u0120silver": 8465, "lla": 8466, "icity": 8467, "\u0120unusual": 8468, "\u0120crack": 8469, "\u0120ties": 8470, "ez": 8471, "\u0120practical": 8472, "\u0120province": 8473, "\u0120Place": 8474, "\u0120priority": 8475, "ICE": 8476, "\u0120describes": 8477, "\u0120branch": 8478, "Form": 8479, "aska": 8480, "missions": 8481, "bi": 8482, "\u0120porn": 8483, "\u0120Turk": 8484, "\u0120enthus": 8485, "\u0120fighters": 8486, "\u012008": 8487, "\u0120Detroit": 8488, "\u0120foundation": 8489, "avid": 8490, "Are": 8491, "\u0120judgment": 8492, "cling": 8493, "\u0120solve": 8494, "\u0120Design": 8495, "Where": 8496, "hesis": 8497, "\u0120Tro": 8498, "after": 8499, "\u0120neutral": 8500, "\u0120Palestinian": 8501, "\u0120Hollywood": 8502, "\u0120advis": 8503, "\u0120Non": 8504, "yes": 8505, "olis": 8506, "\u0120reputation": 8507, "\u0120smell": 8508, "\u0120bread": 8509, "\u0120Bul": 8510, "\u0120Beach": 8511, "\u0120claiming": 8512, "\u0120genetic": 8513, "\u0120technologies": 8514, "\u0120upgrade": 8515, "rows": 8516, "\u0120developer": 8517, "\u0120Josh": 8518, "\u0120Disney": 8519, "erved": 8520, "ipal": 8521, "\u0120unex": 8522, "\u0120barely": 8523, "then": 8524, "\u0120Pub": 8525, "\u0120illness": 8526, "etary": 8527, "\u0120Bal": 8528, "\u0120patch": 8529, "\u0120butt": 8530, "\u0120stupid": 8531, "\u0120Dog": 8532, "\u0120Dallas": 8533, "front": 8534, "iece": 8535, "\u0120protests": 8536, "\u0120chat": 8537, "oenix": 8538, "\u0120wing": 8539, "\u0120parliament": 8540, "\u012077": 8541, "osexual": 8542, "\u0120render": 8543, "ptions": 8544, "\u0120Coast": 8545, "osa": 8546, "\u0120Greg": 8547, "hop": 8548, "\u0120Management": 8549, "\u0120bitcoin": 8550, "\u0120recover": 8551, "\u0120incorpor": 8552, "orne": 8553, "\u0120Using": 8554, "\u0120preced": 8555, "\u0120threatened": 8556, "\u0120spiritual": 8557, "\u0120Event": 8558, "\u0120Fred": 8559, "\u0120advertising": 8560, "\u0120improvements": 8561, "\u0120Custom": 8562, "\u0120errors": 8563, "\u0120sensitive": 8564, "\u0120Navy": 8565, "\u0120cream": 8566, "Look": 8567, "\u0120exclusive": 8568, "\u0120comprehens": 8569, "\u0120deleg": 8570, "\u0120conce": 8571, "\u0120remem": 8572, "\u0120structures": 8573, "\u0120stored": 8574, "ND": 8575, "\u01201000": 8576, "UP": 8577, "\u0120Budd": 8578, "AF": 8579, "woman": 8580, "\u0120Academy": 8581, "\u00f0\u0141": 8582, "sea": 8583, "\u0120temporary": 8584, "About": 8585, "esters": 8586, "\u0120tickets": 8587, "\u0120possess": 8588, "inch": 8589, "oz": 8590, "\u0120la": 8591, "\u0120contracts": 8592, "\u0120unp": 8593, "\u0120cig": 8594, "\u0120Kat": 8595, "ultural": 8596, "asm": 8597, "\u0120mountain": 8598, "\u0120Captain": 8599, "Step": 8600, "making": 8601, "\u0120Spain": 8602, "\u0120equally": 8603, "\u0120lands": 8604, "aters": 8605, "\u0120rejected": 8606, "era": 8607, "imm": 8608, "rix": 8609, "CD": 8610, "\u0120transaction": 8611, "gener": 8612, "lessly": 8613, "\u0120||": 8614, "\u0120cos": 8615, "\u0120Henry": 8616, "\u0120provisions": 8617, "\u0120gained": 8618, "\u0120directory": 8619, "\u0120raising": 8620, "\u0120Sep": 8621, "olen": 8622, "onder": 8623, "\u0120console": 8624, "inst": 8625, "\u0120bom": 8626, "\u0120uncertain": 8627, "150": 8628, "ocking": 8629, "\u0120measured": 8630, "\u0120plain": 8631, "\u0120seats": 8632, "\u0120dict": 8633, "SL": 8634, "afe": 8635, "\u0120estimate": 8636, "izon": 8637, "athered": 8638, "\u0120contributed": 8639, "\u0120episodes": 8640, "ommod": 8641, "Gr": 8642, "ANT": 8643, "\u012069": 8644, "Gener": 8645, "\u0120250": 8646, "viously": 8647, "rogen": 8648, "\u0120terrorism": 8649, "\u0120movements": 8650, "entle": 8651, "ounce": 8652, "\u0120Soul": 8653, "\u0120prev": 8654, "\u0120Table": 8655, "acts": 8656, "riors": 8657, "tab": 8658, "\u0120suffer": 8659, "\u0120nerv": 8660, "\u0120mainstream": 8661, "\u0120Wolf": 8662, "\u0120franchise": 8663, "bat": 8664, "\u0120demands": 8665, "\u0120agenda": 8666, "\u0120dozen": 8667, "\u0120clinical": 8668, "izard": 8669, "\u0120Op": 8670, "td": 8671, "\u0120visited": 8672, "\u0120Perhaps": 8673, "\u0120actor": 8674, "\u0120delic": 8675, "\u0120contribute": 8676, "\u0120inject": 8677, "\u0120Es": 8678, "acco": 8679, "\u0120listening": 8680, "\u0120congress": 8681, "ependent": 8682, "\u0120premium": 8683, "\u012076": 8684, "\u0120Irish": 8685, "\u0120assigned": 8686, "\u0120Phys": 8687, "\u0120worldwide": 8688, "\u0120narrative": 8689, "otype": 8690, "mont": 8691, "base": 8692, "\u0120Bowl": 8693, "\u0120Administration": 8694, "\u0120relation": 8695, "\u0120EV": 8696, "CP": 8697, "\u0120covers": 8698, "\u012078": 8699, "\u0120certific": 8700, "\u0120grass": 8701, "\u012004": 8702, "piracy": 8703, "ira": 8704, "\u0120engineering": 8705, "\u0120Mars": 8706, "\u0120unemploy": 8707, "\u0120Foreign": 8708, "stract": 8709, "\u0120ven": 8710, "\u0120steal": 8711, "\u0120replied": 8712, "\u0120ultimate": 8713, "\u0120titles": 8714, "dated": 8715, "\u0120joy": 8716, "aus": 8717, "\u0120hyper": 8718, "aku": 8719, "\u0120officially": 8720, "\u0120Product": 8721, "\u0120difficulty": 8722, "peror": 8723, "\u0120resulted": 8724, "ribed": 8725, "link": 8726, "who": 8727, "~~~~": 8728, "\u0120Speed": 8729, "\u0120Viet": 8730, "Wind": 8731, "\u0120Barack": 8732, "\u0120restrictions": 8733, "\u0120Share": 8734, "\u01201995": 8735, "itionally": 8736, "\u0120beauty": 8737, "opt": 8738, "\u0120maps": 8739, "\u0120CR": 8740, "\u0120Nation": 8741, "\u0120Cruz": 8742, "Will": 8743, "\u0120electricity": 8744, "\u0120org": 8745, "\u0120burd": 8746, "\u0120violation": 8747, "\u0120usage": 8748, "\u0120permit": 8749, "\u0120Chron": 8750, "\u0120Fant": 8751, "\u0120naturally": 8752, "\u012007": 8753, "\u0120thrown": 8754, "\u0120Awoken": 8755, "\u0120alien": 8756, "\u0120Hero": 8757, "\u0120Kent": 8758, "\u0120Rick": 8759, "rike": 8760, "\u0120pace": 8761, "},{\"": 8762, "GL": 8763, "\u0120poison": 8764, "\u0120Tower": 8765, "\u0120formal": 8766, "alysis": 8767, "\u0120genuine": 8768, "\u0120kil": 8769, "aver": 8770, "\u0120procedure": 8771, "\u0120Prop": 8772, "intendo": 8773, "\u0120Main": 8774, "asant": 8775, "\u0120trained": 8776, "Game": 8777, "\u0120Load": 8778, "\u0120MA": 8779, "\u0120crucial": 8780, "\u0120lets": 8781, "\u0120FR": 8782, "\u0120champion": 8783, "101": 8784, "\u0120Conference": 8785, "\u0120writers": 8786, "\u0120connections": 8787, "\u0120okay": 8788, "irms": 8789, "\u0120Rand": 8790, "\u0120encounter": 8791, "\u0120Buff": 8792, "\u0120achieved": 8793, "\u0120checks": 8794, "iscons": 8795, "\u0120assistant": 8796, "\u0120whenever": 8797, "\u0120Access": 8798, "\u0120Ur": 8799, "bin": 8800, "\u0120clock": 8801, "isp": 8802, "opher": 8803, "\u0120borrow": 8804, "\u0120mad": 8805, "\u0120personality": 8806, "only": 8807, "IST": 8808, "abama": 8809, "\u0120gains": 8810, "\u0120commonly": 8811, "\u0120terr": 8812, "\u0120hypot": 8813, "\u0120rely": 8814, "\u0120tiss": 8815, "isconsin": 8816, "\u0120ridic": 8817, "function": 8818, "\u0120Oregon": 8819, "\u0120uncom": 8820, "rating": 8821, "eland": 8822, "\u0120NC": 8823, "\u0120moon": 8824, "annon": 8825, "\u0120vulnerable": 8826, "utive": 8827, "\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142": 8828, "\u0120Radio": 8829, "\u0120western": 8830, "sect": 8831, "\u0120Tony": 8832, "\u0120occurs": 8833, "\u0120Os": 8834, "\u0120Hon": 8835, "\u00c3\u0143": 8836, "\u0120vessel": 8837, "\u0120Scotland": 8838, "\u0120discrimination": 8839, "\u0120subsequent": 8840, "string": 8841, "\u0120fantasy": 8842, "\u0120Shadow": 8843, "\u0120testim": 8844, "WE": 8845, "iti": 8846, "ras": 8847, "\u0120boat": 8848, "\u0120marks": 8849, "\u0120ordinary": 8850, "\u0120ren": 8851, "\u0120representative": 8852, "\u0120petition": 8853, "\u012073": 8854, "\u0120adventure": 8855, "\u0120ignore": 8856, "\u0120Philadelphia": 8857, "\u0120Sav": 8858, "VP": 8859, "\u0120factory": 8860, "\u0120tasks": 8861, "\u0120depression": 8862, "zed": 8863, "................................": 8864, "\u0120Storm": 8865, "\u0120cogn": 8866, "\u0120eligible": 8867, "\u0120reducing": 8868, "via": 8869, "\u012005": 8870, "\u0120striking": 8871, "\u0120dollar": 8872, "ho": 8873, "OV": 8874, "\u0120instrument": 8875, "\u0120philosophy": 8876, "\u0120Moore": 8877, "\u0120Avenue": 8878, "\u0120ruled": 8879, "\u0120Front": 8880, "INE": 8881, "\u0120Mah": 8882, "\u0120scenario": 8883, "\u0120NASA": 8884, "\u0120enorm": 8885, "\u0120debut": 8886, "\u0120tea": 8887, "Today": 8888, "\u0120absence": 8889, "Sim": 8890, "\u0120ham": 8891, "leep": 8892, "\u0120tables": 8893, "\u0120Heart": 8894, "MI": 8895, "Ke": 8896, "requ": 8897, "VD": 8898, "map": 8899, "\u0120chairman": 8900, "\u0120pump": 8901, "\u0120rapidly": 8902, "vi": 8903, "\u0120substantial": 8904, "EP": 8905, "des": 8906, "chant": 8907, "ilipp": 8908, "\u0120Santa": 8909, "riers": 8910, "anchester": 8911, "Load": 8912, "\u0120Case": 8913, "\u0120saving": 8914, "\u012074": 8915, "\u0120AFP": 8916, "erning": 8917, "ounced": 8918, "\u0120Minnesota": 8919, "\u0120Was": 8920, "\u0120recru": 8921, "\u0120assessment": 8922, "\u0120Bron": 8923, "UE": 8924, "\u0120dynamic": 8925, "\u0120furn": 8926, "ulator": 8927, "\u0120propag": 8928, "high": 8929, "\u0120accommod": 8930, "\u0120stack": 8931, "\u0120Sus": 8932, "writ": 8933, "\u0120reven": 8934, "\u0120Godd": 8935, "\u0120Zealand": 8936, "abs": 8937, "\u0120brut": 8938, "\u0120perpet": 8939, "hot": 8940, "\u0120hardly": 8941, "\u0120Burn": 8942, "\u00e3\u0124\u00b9": 8943, "\u0120sty": 8944, "\u0120transactions": 8945, "\u0120gate": 8946, "\u0120screens": 8947, "\u0120submitted": 8948, "\u0120101": 8949, "\u0120languages": 8950, "ught": 8951, "emen": 8952, "\u0120falls": 8953, "\u0120coc": 8954, "\u0124\u00ac": 8955, "\u0120strikes": 8956, "pa": 8957, "\u0120deliber": 8958, "\u0120IM": 8959, "\u0120relax": 8960, "annels": 8961, "\u0120Senator": 8962, "\u0120extrem": 8963, "\u0120},": 8964, "\u0120Deb": 8965, "\u0120bell": 8966, "\u0120disorder": 8967, "cut": 8968, "\u0120iOS": 8969, "\u0120locked": 8970, "\u0120emissions": 8971, "\u0120shortly": 8972, "\"]": 8973, "\u0120Judge": 8974, "\u0120Sometimes": 8975, "\u0120rival": 8976, "\u0120dust": 8977, "\u0120reaching": 8978, "File": 8979, "\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af": 8980, "inois": 8981, "\u0120Jason": 8982, "\u0120satell": 8983, "aret": 8984, "\u0120stations": 8985, "\u0120agric": 8986, "\u0120Technology": 8987, "comes": 8988, "\u0120Unfortunately": 8989, "\u0120Children": 8990, "\u0120applies": 8991, "asted": 8992, "\u0120anger": 8993, "ailability": 8994, "\u0120Damage": 8995, "\u0120compare": 8996, "\u0120Standard": 8997, "\u0120aimed": 8998, "\u0120Ba": 8999, "anguage": 9000, "\u0120regulation": 9001, "\u0120jury": 9002, "\u0120airport": 9003, "\u0120sections": 9004, "\u0120Prince": 9005, "emed": 9006, "\u0120medicine": 9007, "\u0120hitting": 9008, "\u0120spark": 9009, "olves": 9010, "\u0120ads": 9011, "State": 9012, "\u0120foods": 9013, "\u0120replacement": 9014, "\u0120chicken": 9015, "\u0120lowest": 9016, "\u0120minds": 9017, "\u0120involves": 9018, "ui": 9019, "\u0120arrang": 9020, "\u0120procedures": 9021, "\u0120Which": 9022, "iversary": 9023, "\u0120bills": 9024, "\u0120improvement": 9025, "\u0120inev": 9026, "\u0120expectations": 9027, "\u0120intellectual": 9028, "\u0120spaces": 9029, "\u0120mechanism": 9030, "250": 9031, "break": 9032, "\u0120Ze": 9033, "\u0120Tenn": 9034, "\u0120Balt": 9035, "\u0120barrel": 9036, "\u0120static": 9037, "mann": 9038, "Police": 9039, "\u0120tips": 9040, "\u0120handling": 9041, "cus": 9042, "oded": 9043, "ilton": 9044, "iry": 9045, "\u0120journalists": 9046, "ourse": 9047, "\u0120comic": 9048, "\u0120nomine": 9049, "ITY": 9050, "\u0120versus": 9051, "\u0120loop": 9052, "\u0120surf": 9053, "\u0120Indust": 9054, "\u0120Hunter": 9055, "\u0120beliefs": 9056, "isan": 9057, "\u0120setup": 9058, "\u0120brew": 9059, "image": 9060, "\u0120computers": 9061, "fol": 9062, "},\"": 9063, "\u0120Medal": 9064, "\u0120taxp": 9065, "\u0120displayed": 9066, "\u0120grav": 9067, "\u0120fiscal": 9068, "Mon": 9069, "\u0120Moscow": 9070, "\u0120Kong": 9071, "\u0120Centre": 9072, "\u0120cameras": 9073, "\u0120Mrs": 9074, "\u0120Hay": 9075, "\u0120aver": 9076, "\u0120Kelly": 9077, "py": 9078, "\u0120requirement": 9079, "\u0120entitled": 9080, "ombie": 9081, "\u0120shadow": 9082, "agic": 9083, "\u0120Ak": 9084, "\u0120elite": 9085, "\u0120divided": 9086, "\u0120heading": 9087, "\u0120copies": 9088, "\u0120losses": 9089, "\u0120vit": 9090, "ked": 9091, "\u0120Bry": 9092, "\u0120ans": 9093, "\u0120Steam": 9094, "\u0120reporter": 9095, "heim": 9096, "\u0120Item": 9097, "\u0120superior": 9098, "don": 9099, "erent": 9100, "\u00c3\u00b6": 9101, "\u0120therapy": 9102, "\u0120peak": 9103, "\u0120Model": 9104, "\u0120lying": 9105, "\u0120gam": 9106, "zer": 9107, "ritten": 9108, "\u0120responses": 9109, "\u0120consideration": 9110, "\u0120Bible": 9111, "\u0120loyal": 9112, "\u0120instant": 9113, "\u0120pm": 9114, "\u0120Forest": 9115, "\u00c3\u00bc": 9116, "\u0120extend": 9117, "\u0120convicted": 9118, "\u0120founder": 9119, "\u0120convin": 9120, "\u0120Oak": 9121, "check": 9122, "\u0120scholars": 9123, "ped": 9124, "\u0120overse": 9125, "Top": 9126, "count": 9127, "\u0120Ark": 9128, "\u00c2\u00b7": 9129, "\u012006": 9130, "\u0120LA": 9131, "md": 9132, "\u0120Latin": 9133, "imental": 9134, "\u0120CPU": 9135, "\u0120substance": 9136, "\u0120minority": 9137, "\u0120manufacturing": 9138, "Er": 9139, "ocolate": 9140, "\u0120attended": 9141, "\u0120Manager": 9142, "rations": 9143, "\u0120appreciate": 9144, "omy": 9145, "GBT": 9146, "idency": 9147, "BL": 9148, "\u0120guarantee": 9149, "position": 9150, "\u0120ocean": 9151, "clude": 9152, "\u0120headed": 9153, "\u0120tape": 9154, "\u0120loose": 9155, "\u0120logic": 9156, "\u0120proven": 9157, "\u0120spir": 9158, "\u0120admit": 9159, "isa": 9160, "\u0120investigate": 9161, "\u01201994": 9162, "sylv": 9163, "\u0120Lost": 9164, "cest": 9165, "\u012071": 9166, "\u0120requested": 9167, "\u0120windows": 9168, "\u0120Pok\u00c3\u00a9": 9169, "\u0120Without": 9170, "Met": 9171, "\u0120behaviour": 9172, "\u0120reader": 9173, "\u0120hung": 9174, "\u0120Keep": 9175, "\u0120roles": 9176, "\u0120implemented": 9177, "\u0120blank": 9178, "\u0120serves": 9179, "\u0120Jay": 9180, "\u0120cited": 9181, "\u0120Friend": 9182, "profit": 9183, "apon": 9184, "\u0120repair": 9185, "item": 9186, "arrass": 9187, "\u0120critics": 9188, "adi": 9189, "\u0120Father": 9190, "\u0120shout": 9191, "\u0120fool": 9192, "\u012088": 9193, "\u0120producing": 9194, "\u0120lib": 9195, "\u0120rounds": 9196, "\u0120circle": 9197, "\u0120prepar": 9198, "\u0120submit": 9199, "\u0120nic": 9200, "morrow": 9201, "\u00e3\u0125\u00ab": 9202, "Under": 9203, "\u0120vital": 9204, "atern": 9205, "\u0120password": 9206, "\u0120publication": 9207, "\u0120prominent": 9208, "\u0120speaks": 9209, "\u0120bars": 9210, "\u0120deeper": 9211, "\u0120Mill": 9212, "ported": 9213, "\u0120wid": 9214, "\u0120butter": 9215, "\u0120smoking": 9216, "\u0120indicates": 9217, "Key": 9218, "ropri": 9219, "\u0120File": 9220, "alling": 9221, "asting": 9222, "\u0120Rus": 9223, "\u0120adj": 9224, "\u012079": 9225, "aval": 9226, "\u0120presum": 9227, "burgh": 9228, "onic": 9229, "\u0120fur": 9230, "\u0120polls": 9231, "ika": 9232, "\u0120secondary": 9233, "\u0120monster": 9234, "igs": 9235, "\u0120Current": 9236, "Event": 9237, "\u0120ownership": 9238, "endar": 9239, "\u0120arrive": 9240, "\u0120Tax": 9241, "\u0120null": 9242, "\u0120Priv": 9243, "\u0120thro": 9244, "\u0120kiss": 9245, "cat": 9246, "\u0120upset": 9247, "angle": 9248, "itches": 9249, "ector": 9250, "ologists": 9251, "\u0120Galaxy": 9252, "\u0120corruption": 9253, "\u0120hint": 9254, "enter": 9255, "\u0120Hospital": 9256, "\u0120greatly": 9257, "\u0120begun": 9258, "esy": 9259, "\u0120soil": 9260, "\u0120Anton": 9261, "\u0120maintenance": 9262, "\u00e3\u0125\u00a9": 9263, "\u0120dozens": 9264, "\u0120humanity": 9265, "\u0120Alabama": 9266, "\u0120rom": 9267, "worth": 9268, "aping": 9269, "sylvania": 9270, "lah": 9271, "\u0120gathered": 9272, "GA": 9273, "\u0120attacking": 9274, "found": 9275, "\u0120Square": 9276, "\u0120arbit": 9277, "ictions": 9278, "\u0120Wisconsin": 9279, "\u0120dance": 9280, "\u0120Saint": 9281, "archy": 9282, "\u0120baseball": 9283, "\u0120contributions": 9284, "\u0120literature": 9285, "\u0120exha": 9286, "perty": 9287, "test": 9288, "\u0120bab": 9289, "\u0120container": 9290, "letter": 9291, "\u0120fallen": 9292, "\u0120websites": 9293, "\u0120bottle": 9294, "\u0120Sac": 9295, "\u0120breast": 9296, "\u0120PL": 9297, "\u0120veteran": 9298, "\u0120interviews": 9299, "\u0120Ale": 9300, "\u0120banned": 9301, "engers": 9302, "\u0120Revolution": 9303, "inth": 9304, "\u0120concerning": 9305, "IVE": 9306, "\u0120expenses": 9307, "\u0120Matthew": 9308, "\u0120Columbia": 9309, "ds": 9310, "istance": 9311, "\u0120entity": 9312, "...\"": 9313, "\u0120reliable": 9314, "\u0120paralle": 9315, "\u0120Christians": 9316, "\u0120opinions": 9317, "\u0120indu": 9318, "low": 9319, "\u0120compete": 9320, "\u0120thorough": 9321, "\u0120employed": 9322, "\u0120establishment": 9323, "igen": 9324, "\u0120Cro": 9325, "\u0120lawyers": 9326, "\u0120Station": 9327, "TE": 9328, "\u0120Lind": 9329, "\u0120Pur": 9330, "itary": 9331, "\u0120efficiency": 9332, "\u00e2\u0122\u0132": 9333, "\u0120Ly": 9334, "\u0120mask": 9335, "\u0120disaster": 9336, "\u0120ages": 9337, "ERE": 9338, "esis": 9339, "\u0120Hold": 9340, "\u0120casual": 9341, "bled": 9342, "\u0120enabled": 9343, "\u0120Environment": 9344, "\u0120Intelligence": 9345, "iper": 9346, "\u0120Map": 9347, "\u0120BE": 9348, "\u0120emerged": 9349, "isdom": 9350, "\u0120cabin": 9351, "\u0120registration": 9352, "\u0120fingers": 9353, "\u0120roster": 9354, "\u0120framework": 9355, "\u0120Doctor": 9356, "etts": 9357, "\u0120transportation": 9358, "\u0120awareness": 9359, "Her": 9360, "\u0120attempting": 9361, "Off": 9362, "\u0120Store": 9363, "\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124": 9364, "\u0120Know": 9365, "\u0120defence": 9366, "\u0120scan": 9367, "\u0120Ten": 9368, "\u0120Chair": 9369, "\u0120PH": 9370, "\u0120Atlanta": 9371, "\u0120fucking": 9372, "\u0120answered": 9373, "bn": 9374, "\u0120Kar": 9375, "\u0120categories": 9376, "\u0120rational": 9377, "\u0120cust": 9378, "\u0120robot": 9379, "\u0120correctly": 9380, "\u0120gif": 9381, "\u0120graphics": 9382, "mic": 9383, "\u0120grounds": 9384, "\u0120Opp": 9385, "iate": 9386, "\u0120distributed": 9387, "\u0120sanctions": 9388, "\u0120challenging": 9389, "uto": 9390, "\u0120ingredients": 9391, "\u0120invited": 9392, "\u0120founded": 9393, "\u0120Requ": 9394, "ded": 9395, "\u0120bowl": 9396, "\u0120brothers": 9397, "\u0120Ha": 9398, "IO": 9399, "\u0120wages": 9400, "imore": 9401, "ocial": 9402, "\u0120seed": 9403, "atively": 9404, "\u0120addresses": 9405, "\u0120Iowa": 9406, "abeth": 9407, "\u0120attitude": 9408, "isd": 9409, "child": 9410, "\u0120mole": 9411, "\u0120discovery": 9412, "yard": 9413, "Br": 9414, "\u012082": 9415, "\u0120supplies": 9416, "elling": 9417, "\u0120distingu": 9418, "CR": 9419, "\u0120recept": 9420, "\u0120vert": 9421, "\u0120swim": 9422, "bec": 9423, "door": 9424, "\u0120Yeah": 9425, "\u0120gal": 9426, "\u0120interact": 9427, "\u0120ESP": 9428, "\u0120CS": 9429, "amps": 9430, "\u0120convinced": 9431, "\u0120objective": 9432, "\u0120dish": 9433, "\u0120Photos": 9434, "lad": 9435, "\u0120downtown": 9436, "oil": 9437, "inction": 9438, "\u0120tomorrow": 9439, "\u0120COM": 9440, "\u0120survival": 9441, "shot": 9442, "\u0120settlement": 9443, "Cons": 9444, "\u0120Xbox": 9445, "interest": 9446, "\u0120SM": 9447, "argo": 9448, "eness": 9449, "\u0120ethnic": 9450, "bered": 9451, "Min": 9452, "\u0120Tok": 9453, "\u0120incent": 9454, "\u0120Command": 9455, "\u0120maintained": 9456, "\u0120breaks": 9457, "bridge": 9458, "atar": 9459, "agg": 9460, "\u0120Finally": 9461, "unicip": 9462, "\u0120Ont": 9463, "left": 9464, "\u0120recognition": 9465, "\u0120*/": 9466, "\u0120Pers": 9467, "\u0120welf": 9468, "\u0120addressed": 9469, "\u0120Kansas": 9470, "\u0120virus": 9471, "\u0120whereas": 9472, "\u0120papers": 9473, "rams": 9474, "\u0120Ministry": 9475, "\u0120pleasure": 9476, "\u0120acquired": 9477, "\u0120duration": 9478, "jpg": 9479, "\u0120calm": 9480, "\u0120NHL": 9481, "\u0120burning": 9482, "\u0120folder": 9483, "icked": 9484, "\u0120Py": 9485, "\u0120Illinois": 9486, "Class": 9487, "\u0120Goddess": 9488, "\u0120performing": 9489, "\u0120welfare": 9490, "jar": 9491, "Inter": 9492, "\u0120lin": 9493, "\u0120enhance": 9494, "\u0120notion": 9495, "fare": 9496, "ypes": 9497, "\u0120Area": 9498, "\u0120cannabis": 9499, "\u0120Diego": 9500, "fs": 9501, "\u0120Manchester": 9502, "comm": 9503, "inite": 9504, "\u0120covering": 9505, "\u0120Sound": 9506, "\u01201960": 9507, "\u012084": 9508, "elect": 9509, "zing": 9510, "\u0120citizen": 9511, "\u0120phones": 9512, "\u0120raid": 9513, "\u0120ignored": 9514, "\u0120Object": 9515, "\u0120upload": 9516, "card": 9517, "\u0120modified": 9518, "\u0120rooms": 9519, "iah": 9520, "range": 9521, "heast": 9522, "achus": 9523, "\u0120suggesting": 9524, "\u00e2\u0122\u012d": 9525, "grade": 9526, "El": 9527, "\u0120clothing": 9528, "\u0120rh": 9529, "\u0120Han": 9530, "unity": 9531, "encing": 9532, "\u0120Austin": 9533, "secution": 9534, "tra": 9535, "dem": 9536, "\u0120Qual": 9537, "\u0120heaven": 9538, "\u0120stages": 9539, "\u0120wedd": 9540, "plus": 9541, "ificial": 9542, "\u0120Imm": 9543, "\u0120Ho": 9544, "ieties": 9545, "\u0120phrase": 9546, "\u0120brill": 9547, "actory": 9548, "\u0120providers": 9549, "\u0120silence": 9550, "\u0120aer": 9551, "\u0120AI": 9552, "\u0120Adventure": 9553, "\u0120platforms": 9554, "\u0120demonstrated": 9555, "\u0120interf": 9556, "ington": 9557, "\u0120races": 9558, "\u0120grade": 9559, "ultane": 9560, "\u0120Through": 9561, "false": 9562, "\u0120bow": 9563, "\u0120AB": 9564, "\u0120flavor": 9565, "\u0120historic": 9566, "gov": 9567, "\u0120colour": 9568, "\u0120viewed": 9569, "\u0120Email": 9570, "elcome": 9571, "\u0120intervention": 9572, "\u0120diversity": 9573, "\u0120periods": 9574, "\u0120reverse": 9575, "\u0120Very": 9576, "\u0120quote": 9577, "\u0120Left": 9578, "through": 9579, "\u0120screw": 9580, "\u0120landing": 9581, "\u0120pill": 9582, "\u0120wet": 9583, "\u0120protesters": 9584, "\u0120repeat": 9585, "aved": 9586, "erk": 9587, "\u0120salary": 9588, "\u0120Pennsylvania": 9589, "Still": 9590, "\u0120mayor": 9591, "\u0120kitchen": 9592, "\u0120featuring": 9593, "\u0120Museum": 9594, "\u0120Tournament": 9595, "\u0120Fal": 9596, "\u0120servers": 9597, "UC": 9598, "\u0120anybody": 9599, "img": 9600, "\u0120Trade": 9601, "ixture": 9602, "theless": 9603, "\u0120finance": 9604, "\u0120closing": 9605, "\u0120Patri": 9606, "iac": 9607, "abel": 9608, "\u0120>>": 9609, "orous": 9610, "\u0120firms": 9611, "screen": 9612, "una": 9613, "\u0120embarrass": 9614, "ulse": 9615, "\u0120letting": 9616, "\u0120threw": 9617, "iley": 9618, "\u0120channels": 9619, "lan": 9620, "\u0120Vegas": 9621, "\u0120sear": 9622, "\u0120fantastic": 9623, "arre": 9624, "uzzle": 9625, "\u0120Der": 9626, "Those": 9627, "\u0120swing": 9628, "\u0120sheet": 9629, "index": 9630, "cover": 9631, "ogan": 9632, "\u0120variables": 9633, "\u0120Tech": 9634, "\u0120spoken": 9635, "achel": 9636, "\u0120Da": 9637, "\u0120Mountain": 9638, "\u0120loaded": 9639, "\u0120footage": 9640, "version": 9641, "\u0120unl": 9642, "\u0120Phoenix": 9643, "\u0120throwing": 9644, "\u0120firing": 9645, "\u0120tracking": 9646, "\u0120width": 9647, "\u0120struggling": 9648, "rooms": 9649, "otion": 9650, "\u0120monthly": 9651, "\u0120Server": 9652, "\u0120eggs": 9653, "open": 9654, "MC": 9655, "\u01201993": 9656, "\u0120hired": 9657, "\u0120stayed": 9658, "\u0120Allen": 9659, "\u0120stro": 9660, "\u012098": 9661, "step": 9662, "\u0120Turkish": 9663, "\u0120fabric": 9664, "isting": 9665, "\u0120Dom": 9666, "\u0120dates": 9667, "\u0120pron": 9668, "\u0120basketball": 9669, "\u0120lucky": 9670, "\u0120Arabia": 9671, "\u0120assumed": 9672, "esty": 9673, "\u0120affairs": 9674, "\u0120glad": 9675, "\u0120Indeed": 9676, "\u0120FA": 9677, "\u0120Word": 9678, "\u0120joining": 9679, "ifice": 9680, "pread": 9681, "irts": 9682, "\u0120Select": 9683, "\u0120populations": 9684, "aware": 9685, "\u0120nose": 9686, "\u0120complaints": 9687, "start": 9688, "\u0120scoring": 9689, "Thanks": 9690, "\u0120mining": 9691, "\u0120visitors": 9692, "SH": 9693, "\u0120damaged": 9694, "\u0120characteristics": 9695, "\u0120Pent": 9696, "DC": 9697, "\u012083": 9698, "\u0120Six": 9699, "rates": 9700, "\u0120flags": 9701, "\u0120Brew": 9702, "dog": 9703, "Mark": 9704, "////": 9705, "\u0120execution": 9706, "\u0120joke": 9707, "phones": 9708, "\u0120testimony": 9709, "\u0120obst": 9710, "QL": 9711, "\u0120Cut": 9712, "\u0120studied": 9713, "\u0120Nintendo": 9714, "icket": 9715, "\u0120NBC": 9716, "\u0120lad": 9717, "\u0120Bra": 9718, "\u0120Moh": 9719, "\u0120kernel": 9720, "\u0120overwhelming": 9721, "\u0120aged": 9722, "\u0120applicable": 9723, "\u0120Cond": 9724, "\u0120roads": 9725, "\u0120Block": 9726, "made": 9727, "odge": 9728, "\u0120commands": 9729, "\u0120offices": 9730, "veland": 9731, "\u0120tut": 9732, "\u0120receiver": 9733, "\u0120Fro": 9734, "\u0120shopping": 9735, "\u0120iP": 9736, "\u0120Stre": 9737, "\u0120ABC": 9738, "\u0120entertainment": 9739, "\u0120Bow": 9740, "orted": 9741, "Mc": 9742, "\u0120reads": 9743, "grad": 9744, "\u0120Collect": 9745, "\u0120\u00e2\u012a\u0134": 9746, "\u0120Capital": 9747, "ederation": 9748, "\u0120employer": 9749, "\u0120involvement": 9750, "\u0120anxiety": 9751, "alia": 9752, "\u0120roof": 9753, "\u0120Among": 9754, "\u0120Democrat": 9755, "\u0120stats": 9756, "\u0120Vill": 9757, "\u0120constitutional": 9758, "\u0120referring": 9759, "itty": 9760, "\u0120tackle": 9761, "outube": 9762, "\u0120backed": 9763, "\u0120Hong": 9764, "\u0120Broad": 9765, "\u0120ele": 9766, "\u0120Ott": 9767, "\u01201992": 9768, "hour": 9769, "achusetts": 9770, "Cal": 9771, "\u0120defeated": 9772, "\u012081": 9773, "esp": 9774, "\u0120seemingly": 9775, "was": 9776, "\u0120Jenn": 9777, "\u0120Kurd": 9778, "\u0120gene": 9779, "\u0120discount": 9780, "Ret": 9781, "ECT": 9782, "();": 9783, "\u0120clubs": 9784, "\u0120sid": 9785, "\u0120Marsh": 9786, "Check": 9787, "\u0120pp": 9788, "\u0120Eag": 9789, "idespread": 9790, "\u0120beings": 9791, "FT": 9792, "\u0120introduction": 9793, "\u0120Change": 9794, "ARD": 9795, "\u0120110": 9796, "adows": 9797, "ierce": 9798, "\u0120meal": 9799, "author": 9800, "\u0120Bang": 9801, "lahoma": 9802, "\u0120ranks": 9803, "2011": 9804, "????": 9805, "max": 9806, "\u0120collapse": 9807, "\u0120opens": 9808, "\u0120echo": 9809, "\u0120soph": 9810, "\u0120racist": 9811, "\u0120enormous": 9812, "\u0120waves": 9813, "\u0120tap": 9814, "\u0120comprehensive": 9815, ".--": 9816, "\u0120Roy": 9817, "\u0120farmers": 9818, "Related": 9819, "aired": 9820, "rones": 9821, "\u0120Crim": 9822, "\u0120proportion": 9823, "\u0120designs": 9824, "\u0120negotiations": 9825, "\u0120virtually": 9826, "\u0120Batman": 9827, "\u0120warn": 9828, "\u0120legitimate": 9829, "mate": 9830, "\u0120convention": 9831, ",,": 9832, "netic": 9833, "\u0120SD": 9834, "\u0120consistently": 9835, "\u0120compensation": 9836, "\u0120punishment": 9837, "\u0120ye": 9838, "\u0120tie": 9839, "\u0120Bureau": 9840, "irlf": 9841, "\u0120Bu": 9842, "\u0120Aren": 9843, "\u0120Philipp": 9844, "\u0120knife": 9845, "\u0120memories": 9846, "\u0120Ross": 9847, "\u0120angle": 9848, "\u012086": 9849, "\u0120Thunder": 9850, "\u0120rend": 9851, "\u0120Tour": 9852, "\u0120counts": 9853, "sung": 9854, "\u0120Imp": 9855, "\u0120educational": 9856, "\u0120accessible": 9857, "COM": 9858, "\u0120drew": 9859, "yer": 9860, "Gl": 9861, "amine": 9862, "ORT": 9863, "OB": 9864, "IB": 9865, "master": 9866, "\u0120trials": 9867, "ogy": 9868, "har": 9869, "\u0120Trust": 9870, "\u0120preferred": 9871, "irlfriend": 9872, "\u0120Nev": 9873, "\u0120bin": 9874, "\u0120cow": 9875, "Page": 9876, "\u0120signature": 9877, "\u0120BL": 9878, "700": 9879, "\u0120retired": 9880, "\u0120bytes": 9881, "\u0120neighb": 9882, "\u0120Legend": 9883, "\u0120devast": 9884, "\u0120suspected": 9885, "isons": 9886, "\u0120Pok\u00c3\u00a9mon": 9887, "scale": 9888, "\u0120capabilities": 9889, "\u0120revel": 9890, "\u0120cheese": 9891, "dy": 9892, "igrant": 9893, "\u0120failing": 9894, "bits": 9895, "\u0120Heroes": 9896, "\u0120Ghost": 9897, "\u0120Scient": 9898, "\u0120appointed": 9899, "uri": 9900, "\u0120institution": 9901, "\u0120expanded": 9902, "greg": 9903, "\u0120monitoring": 9904, "\u0120podcast": 9905, "\u0120coalition": 9906, "\u012096": 9907, "Jo": 9908, "\u0120stolen": 9909, "\u0120Sab": 9910, "\u0120stops": 9911, "\u0120holiday": 9912, "\u0120intr": 9913, "Car": 9914, "Black": 9915, "\u0120LGBT": 9916, "\u0120warming": 9917, "\u0120Anderson": 9918, "\u012089": 9919, "\u0120producer": 9920, "Med": 9921, "\u0120accuracy": 9922, "\u0120Marvel": 9923, "izabeth": 9924, "\u0120Patrick": 9925, "mony": 9926, "\u0120mini": 9927, "acles": 9928, "\u0120overt": 9929, "they": 9930, "\u0120membership": 9931, "\u0120Ven": 9932, "\u0120exch": 9933, "\u0120removal": 9934, "\u0120Dave": 9935, "TY": 9936, "mad": 9937, "\u0120Find": 9938, "\u0120adequ": 9939, "\u0120ec": 9940, "\u0120teeth": 9941, "\u0120emotion": 9942, "\u0120perm": 9943, "\u0120solely": 9944, "db": 9945, "\u0120extraord": 9946, "IGHT": 9947, "cal": 9948, "\u0120guidelines": 9949, "\u0120dying": 9950, "\u0120suspended": 9951, "\u0120Premier": 9952, "\u0120Anthony": 9953, "elve": 9954, "\u0120dad": 9955, "\u0120Eth": 9956, "\u0120Football": 9957, "\u0120abandoned": 9958, "\u0120<<": 9959, "\u0120march": 9960, "\u0120horror": 9961, "\u00e2\u0122\u00a6\"": 9962, "\u0120childhood": 9963, "\u0120campaigns": 9964, "\u0120lunch": 9965, "\u0120Albert": 9966, "block": 9967, "\u00e2\u0138\u012a\u00e2\u0138\u012a": 9968, "ounding": 9969, "\u0120bone": 9970, "organ": 9971, "aders": 9972, "\u0120Flash": 9973, "\u0120Drive": 9974, "\u0120tonight": 9975, "\u0120wars": 9976, "\u0120FL": 9977, "\u0120formation": 9978, "const": 9979, "News": 9980, "\u0120compe": 9981, "orious": 9982, "\u0120Staff": 9983, "\u0120discussions": 9984, "\u0120Protection": 9985, "\u0120Jam": 9986, "\u0120criteria": 9987, "\u0120installation": 9988, "\u0120accomplish": 9989, "izza": 9990, "\u0120publisher": 9991, "\u0120rescue": 9992, "\u0120Try": 9993, "ULL": 9994, "\u0120Som": 9995, "\u0120Hop": 9996, "oret": 9997, "ths": 9998, "ordon": 9999, "\u0120pocket": 10000, "\u0120Inv": 10001, "Download": 10002, "\u0120Crime": 10003, "\u0120bene": 10004, "\u0120Guide": 10005, "\u0120Assembly": 10006, "\u0120parameters": 10007, "IE": 10008, "\u0120Alexander": 10009, "\u0120concert": 10010, "\u0120Sche": 10011, "\u0120shoes": 10012, "\u0120visiting": 10013, "\u0120recall": 10014, "\u0120bub": 10015, "\u0120rural": 10016, "\u0120concrete": 10017, "\u0120Ros": 10018, "Next": 10019, "Russ": 10020, "\u0120loans": 10021, "\u0120Shield": 10022, "\u0120trem": 10023, "hemat": 10024, "kg": 10025, "\u0120Harris": 10026, "isition": 10027, "\u0120Move": 10028, "\u0120FC": 10029, "\u0120fate": 10030, "\u0120Cho": 10031, "\u0120tired": 10032, "\u0120principal": 10033, "hist": 10034, "iences": 10035, "athy": 10036, "\u0120sevent": 10037, "\u0120mood": 10038, "\u0120strategic": 10039, "\u0120diseases": 10040, "\u0120forum": 10041, "\u0120tempor": 10042, "\u0120headquarters": 10043, "Par": 10044, "ige": 10045, "flix": 10046, "\u0120guitar": 10047, "\u012094": 10048, "Only": 10049, "\u0120releases": 10050, "roph": 10051, "================================": 10052, "\u0120600": 10053, "\u0120Continue": 10054, "igate": 10055, "\u0120Crit": 10056, "system": 10057, "\u0120disabled": 10058, "\u0120unexpected": 10059, "ithub": 10060, "\u0120unclear": 10061, "\u0120Est": 10062, "\u0120contrad": 10063, "\u0120strategies": 10064, "ventures": 10065, "\u0120passage": 10066, "AME": 10067, "\u0120improving": 10068, "\u0120reveals": 10069, "\u0120decrease": 10070, "ova": 10071, "\u0120annoy": 10072, "\u0120Short": 10073, "\u0120Library": 10074, "\u0120cyber": 10075, "nell": 10076, "\u0120Hur": 10077, "\u0120CB": 10078, "\u0120photograp": 10079, "UI": 10080, "\u0120sed": 10081, "Ge": 10082, "\u012087": 10083, "\u0120diverse": 10084, "\u0120encouraged": 10085, "\u0120conspiracy": 10086, "\u0120birds": 10087, "\u0120operator": 10088, "\u0120handful": 10089, "\u0120classified": 10090, "?)": 10091, "\u0120dramatic": 10092, "\u0120investigators": 10093, "ito": 10094, "\u0120widespread": 10095, "\u0120Room": 10096, "----------------------------------------------------------------": 10097, "\u0120collective": 10098, "\u0120journalist": 10099, "String": 10100, "\u0120temperatures": 10101, "ila": 10102, "\u0120guid": 10103, "\u0120inspect": 10104, "\u0120missile": 10105, "\u0120Mayor": 10106, "\u0120manual": 10107, "\u0120simultane": 10108, "\u0120ratings": 10109, "\u0120suck": 10110, "\u012097": 10111, "\u0120universal": 10112, "\u0120pharm": 10113, "\u0120disrupt": 10114, "iano": 10115, "AV": 10116, "\u0120ft": 10117, "\u0120statist": 10118, "olds": 10119, "\u0120Walker": 10120, "php": 10121, "\u0120undert": 10122, "\u0120Las": 10123, "ishop": 10124, "ntil": 10125, "reshold": 10126, "\u0120Whether": 10127, "Ms": 10128, "\u0120deny": 10129, "\u0120Cloud": 10130, "\u0120provider": 10131, "\u0120surviv": 10132, "\u0120Update": 10133, "has": 10134, "\u0120mistakes": 10135, "charge": 10136, "pled": 10137, "rity": 10138, "\u0120node": 10139, "\u0120Massachusetts": 10140, "ools": 10141, "lication": 10142, "\u0120fails": 10143, "emale": 10144, "ori": 10145, "backs": 10146, "\u0120shirt": 10147, "\u0120''": 10148, "\u0120NAT": 10149, "\u0120waters": 10150, "elson": 10151, "\u0120ease": 10152, "\u0120scar": 10153, "\u0120contents": 10154, "mind": 10155, "\u0120contribution": 10156, "\u0120shr": 10157, "\u0120handed": 10158, "\u0120stability": 10159, "\u0120trave": 10160, "Em": 10161, "\u0120mirror": 10162, "123": 10163, "\u0120weigh": 10164, "\u0120fiction": 10165, "ouver": 10166, "istant": 10167, "rition": 10168, "\u0120Fed": 10169, "\u0120physically": 10170, "\u0120stake": 10171, "\u0120Article": 10172, "\u0120Arc": 10173, "\u0120Lewis": 10174, "\u0120Mind": 10175, "\u0120demonstrate": 10176, "\u0120profits": 10177, "vision": 10178, "omic": 10179, "olid": 10180, "\u0120battles": 10181, "\u0120drives": 10182, "\u0120eastern": 10183, "\u0120Sony": 10184, "!!!": 10185, "aration": 10186, "vard": 10187, "\u0120GL": 10188, "portation": 10189, "\u012092": 10190, "\u0120lawmakers": 10191, "\u0120protecting": 10192, "\u0120EPA": 10193, "\u0120yeah": 10194, "\u0120shame": 10195, "olph": 10196, "even": 10197, "xit": 10198, "\u0120attach": 10199, "\u0120representing": 10200, "\u0120obs": 10201, "\u0120Utah": 10202, "iffs": 10203, "\u0120Freedom": 10204, "\u00c3\u00b3": 10205, "AK": 10206, "\u0120incidents": 10207, "itage": 10208, "\u0120viewers": 10209, "cd": 10210, "\u0120mouse": 10211, "\u0120clar": 10212, "\u0120accordance": 10213, "\u0120bot": 10214, "cor": 10215, "\u0120Summer": 10216, "held": 10217, "\u0120innocent": 10218, "\u0120initiative": 10219, "ols": 10220, "________________________________": 10221, "\u0120spots": 10222, "pace": 10223, "\u0120conventional": 10224, "\u0120corporations": 10225, "\u0120blocked": 10226, "HD": 10227, "attered": 10228, "\u0120refers": 10229, "\u0120buck": 10230, "\u0120Digital": 10231, "120": 10232, "\u0120topics": 10233, "TF": 10234, "\u00c4\u0123": 10235, "brid": 10236, "reement": 10237, "\u0120underlying": 10238, "\u0120Member": 10239, "\u0120investigating": 10240, "\u0120pregnancy": 10241, "\u0120touchdown": 10242, "\u0120Band": 10243, "\u0120Caller": 10244, "\u0120instances": 10245, "PP": 10246, "wa": 10247, "Good": 10248, "\u01201991": 10249, "\u0120Cold": 10250, "\u0120fears": 10251, "\u0120remarks": 10252, "\u0128\u0134": 10253, "atal": 10254, "\u0120mit": 10255, "\u0120experiments": 10256, "ipt": 10257, "Color": 10258, "indu": 10259, "Update": 10260, "\u012093": 10261, "Ag": 10262, "\u0120\u00e5": 10263, "ancouver": 10264, "Both": 10265, "\u0120judges": 10266, "Object": 10267, "\u0120stere": 10268, "umbn": 10269, "\u0120participation": 10270, "\u0120Stars": 10271, "\u0120Jere": 10272, "\u0120weekly": 10273, "\u0120Ban": 10274, "\u0120conversations": 10275, "\u0120Pitt": 10276, "uz": 10277, "\u0120Indiana": 10278, "\u0120Kick": 10279, "\u0120infection": 10280, "\u0120heroes": 10281, "\u0120settled": 10282, "\u0120strip": 10283, "\u0120hal": 10284, "\u0120dump": 10285, "\u0120Sci": 10286, "\u0120les": 10287, "\u0120references": 10288, "\u0120URL": 10289, "\u0120Bridge": 10290, "\u0120wanting": 10291, "Force": 10292, "\u0120exclus": 10293, "Meanwhile": 10294, "mn": 10295, "\u0120gentle": 10296, "maker": 10297, "senal": 10298, "\u0120Gro": 10299, "ouri": 10300, "\u0120Rain": 10301, "\u0120Alliance": 10302, "\u0120lift": 10303, "ela": 10304, "SD": 10305, "\u0120Cleveland": 10306, "\u0120ranked": 10307, "\u0120stadium": 10308, "\u0120deadly": 10309, "\u00e4\u00b8": 10310, "\u0120riding": 10311, "aria": 10312, "\u0120Armor": 10313, "\u0120documentation": 10314, "\u0120Greece": 10315, "reek": 10316, "\u0120lens": 10317, "\u0120Sa": 10318, "\u0120gross": 10319, "\u0120Emer": 10320, "agers": 10321, "\u0120Dub": 10322, "\u0120Rh": 10323, "\u0120AMD": 10324, "\u0120arrival": 10325, "\u0120desert": 10326, "\u0120supplement": 10327, "\u0120Resp": 10328, "\u0120knee": 10329, "\u0120margin": 10330, "font": 10331, "ogg": 10332, "2010": 10333, "\u0120Pir": 10334, "\u0120Prom": 10335, "ivals": 10336, "\u0120intake": 10337, "\u0120differently": 10338, "ugs": 10339, "\u0120bits": 10340, "cluded": 10341, "\u0120searching": 10342, "\u0120Du": 10343, "umble": 10344, "\u0120functional": 10345, "\u0120Baltimore": 10346, "\u0120Could": 10347, "\u0120desired": 10348, "\u0120circuit": 10349, "\u0120Lyn": 10350, "\u0120GO": 10351, "\u0120False": 10352, "repre": 10353, "':": 10354, "alties": 10355, "\u0120minim": 10356, "\u0120drove": 10357, "\u0120Should": 10358, "\u0120hip": 10359, "\u0120pros": 10360, "\u0120utility": 10361, "\u0120Nature": 10362, "\u0120Mode": 10363, "President": 10364, "opp": 10365, "rat": 10366, "formance": 10367, "\u0120concentration": 10368, "\u0120font": 10369, "\u0120Bud": 10370, "\u0120amid": 10371, "\u0120revers": 10372, "\u0120ML": 10373, "Bar": 10374, "\u0120interaction": 10375, "\u0120jurisd": 10376, "\u0120spells": 10377, "dep": 10378, "fil": 10379, "\u0120civilians": 10380, "utter": 10381, "\u0120Cooper": 10382, "\u0120Below": 10383, "\u0120entrance": 10384, "\u0120convert": 10385, "\u0120controversy": 10386, "owered": 10387, "\u0120contrary": 10388, "\u0120arc": 10389, "\u0120Executive": 10390, "\u0120Officer": 10391, "\u0120packages": 10392, "\u0120progressive": 10393, "width": 10394, "\u0120reserved": 10395, "vol": 10396, "\u0120Samsung": 10397, "\u0120printed": 10398, "\u0120centers": 10399, "\u0120introduce": 10400, "\u0120Kennedy": 10401, "\u0120odds": 10402, "\u0120surely": 10403, "\u0120independence": 10404, "\u0120passengers": 10405, "reprene": 10406, "\u0120Beh": 10407, "\u0120loves": 10408, "\u0120ESPN": 10409, "\u0120facilit": 10410, "\u0120identical": 10411, "\u0120doct": 10412, "\u0120partnership": 10413, "conf": 10414, "\u0120Hide": 10415, "\u0120confused": 10416, "\u0120Cow": 10417, "Men": 10418, "\u0120wrest": 10419, "\u0120Iraqi": 10420, "\u0120holes": 10421, "\u0120Studies": 10422, "\u0120pregnant": 10423, "hard": 10424, "\u0120signals": 10425, "IX": 10426, "\u0120pulling": 10427, "\u0120graduate": 10428, "\u0120nominee": 10429, "Date": 10430, "\u0120permitted": 10431, "\u0120\u00e2\u0124\u00ac": 10432, "\u0120Oklahoma": 10433, "Start": 10434, "\u0120authorized": 10435, "\u0120alarm": 10436, "\u0120Cos": 10437, "van": 10438, "\u0120generations": 10439, "cular": 10440, "\u0120dragon": 10441, "\u0120Software": 10442, "\u0120Edward": 10443, "\u0120controller": 10444, "Sen": 10445, "gered": 10446, "\u0120Vik": 10447, "\u0120approached": 10448, "Thank": 10449, "\u0120cance": 10450, "\u0120formula": 10451, "\u0120Small": 10452, "\u0120weakness": 10453, "\u0120ramp": 10454, "itudes": 10455, "jud": 10456, "\u0120brilliant": 10457, "\u0120accus": 10458, "source": 10459, "\u0120800": 10460, "\u0120Evil": 10461, "Sw": 10462, "\u0120homeless": 10463, "week": 10464, "iens": 10465, "rics": 10466, "\u0120Third": 10467, "TO": 10468, "\u0120organic": 10469, "\u0120presentation": 10470, "agh": 10471, "\u0120Download": 10472, "vation": 10473, "\u0120assembly": 10474, "orable": 10475, "holders": 10476, "\u0120Bernie": 10477, "\u0120Help": 10478, "\u0120tong": 10479, "\u0120Fight": 10480, "\u0120beach": 10481, "Book": 10482, "\u0120Lic": 10483, "\u0120rush": 10484, "\u0120Round": 10485, "oup": 10486, "\u0120Marx": 10487, "\u0120calculated": 10488, "\u0120Devil": 10489, "\u0120Sarah": 10490, "\u0120occasionally": 10491, "\u0120bullet": 10492, "Available": 10493, "gate": 10494, "\u012091": 10495, "\u0120hosp": 10496, "\u0120promises": 10497, "\u0120HIV": 10498, "\u0120Stadium": 10499, "\u0120Stock": 10500, "\u0120Corporation": 10501, "gage": 10502, "NG": 10503, "\u0120Credit": 10504, "\u0120sne": 10505, "ibl": 10506, "\u0120accum": 10507, "such": 10508, "\u0120terrorists": 10509, "\u0120consciousness": 10510, "\u0120Zh": 10511, "\u0120drama": 10512, "oola": 10513, "piration": 10514, "\u0120labour": 10515, "\u0120Nin": 10516, "\u0120utter": 10517, "\u0120democratic": 10518, "\u0120assass": 10519, "ilation": 10520, "\u0120gest": 10521, "\u0120abroad": 10522, "\u0120metab": 10523, "\u0120sorts": 10524, "\u0120flav": 10525, "UB": 10526, "\u0120mg": 10527, "\u0120Nothing": 10528, "\u0120Od": 10529, "\u0120musical": 10530, "2009": 10531, "\u0120drops": 10532, "ocated": 10533, "ateral": 10534, "000000": 10535, "\u0120gre": 10536, "\u0120equality": 10537, "\u0120burden": 10538, "\u0120vig": 10539, "\u0120Leader": 10540, "------------": 10541, "\u0120ceremony": 10542, "\u0120fighter": 10543, "\u0120actors": 10544, "\u0120\u00e6": 10545, "aman": 10546, "Fi": 10547, "\u0120align": 10548, "puter": 10549, "\u0120elder": 10550, "\u0120NSA": 10551, "\u0120representation": 10552, "\u0120Ontario": 10553, "ITH": 10554, "usalem": 10555, "\u0120harassment": 10556, "itzer": 10557, "\u0120symp": 10558, "\u0120boxes": 10559, "\u0120DR": 10560, "\u0120manifest": 10561, "atre": 10562, "\u0120^": 10563, "\u0120dies": 10564, "leton": 10565, "\u0120missions": 10566, "ethe": 10567, "\u0120resolve": 10568, "\u0120followers": 10569, "\u0120asc": 10570, "\u0120km": 10571, "lord": 10572, "ammed": 10573, "\u0120silent": 10574, "\u0120Associated": 10575, "\u0120timing": 10576, "\u0120prisoners": 10577, "\u0120Kings": 10578, "\u0120Five": 10579, "\u0120tower": 10580, "\u0120approaches": 10581, "\u0120precisely": 10582, "\u0120bureau": 10583, "\u0120Mother": 10584, "\u0120Iss": 10585, "\u0120keyboard": 10586, "itual": 10587, "\u0120funded": 10588, "\u0120staying": 10589, "\u0120psychological": 10590, "\u0120mile": 10591, "\u0120Leon": 10592, "\u0120Barb": 10593, "will": 10594, "\u0120wider": 10595, "\u0120Atlantic": 10596, "\u0120till": 10597, "\u0120Rome": 10598, "rot": 10599, "\u0120accompan": 10600, "\u0120flour": 10601, "aco": 10602, "World": 10603, "\u0120Express": 10604, "\u0120Yu": 10605, "Cor": 10606, "\u0120pleased": 10607, "party": 10608, "\u0120pointing": 10609, "\u0120inflation": 10610, "\u0120roy": 10611, "\u0120),": 10612, "ainer": 10613, "\u0120wedding": 10614, "ormon": 10615, "\u0120requiring": 10616, "\u0120qualified": 10617, "\u0120segment": 10618, "END": 10619, "\u0120sizes": 10620, "eals": 10621, "\u0120corrupt": 10622, "assador": 10623, "\u0120celeb": 10624, "\u0120dreams": 10625, "\u0120Mess": 10626, "\u0120checking": 10627, "\u0120Version": 10628, "\u0120preparing": 10629, "\u0120actively": 10630, "\u0120Diff": 10631, "\u0120lux": 10632, "\u0120Winter": 10633, "acteria": 10634, "\u0120NE": 10635, "\u0120deputy": 10636, "\u0120transgender": 10637, "\u0120summary": 10638, "\u0120inher": 10639, "eries": 10640, "char": 10641, "\u0120Yan": 10642, "\u0120knock": 10643, "\u0120Path": 10644, "\u0120lip": 10645, "roller": 10646, "\u0120impression": 10647, "\u0120celebrate": 10648, "\u0120slide": 10649, "\u0120guests": 10650, "\u0120clip": 10651, "FS": 10652, "\u0120savings": 10653, "\u0120captain": 10654, "\u0120legacy": 10655, "\u0120Denver": 10656, "\u0120wounded": 10657, "taboola": 10658, "ACT": 10659, "\u0120pursue": 10660, "\u0120oxy": 10661, "\u0120q": 10662, "\u0120semi": 10663, "\u0120Need": 10664, "\u0120Affairs": 10665, "\u0120obsc": 10666, "\u0120checked": 10667, "\u0120dual": 10668, "Code": 10669, "\u0120MD": 10670, "lem": 10671, "ulty": 10672, "\u0120\u00c2\u00a9": 10673, "\u0120Elizabeth": 10674, "\u0120centuries": 10675, "arded": 10676, "src": 10677, "\u0120evident": 10678, "ennis": 10679, "atin": 10680, "\u0120unemployment": 10681, "\u0120Mario": 10682, "\u0120intim": 10683, "Christ": 10684, "\u0120biological": 10685, "\u0120soldier": 10686, "\u0120Added": 10687, "\u0120math": 10688, "\u0120Gil": 10689, "\u0120bias": 10690, "\u0120dating": 10691, "\u0120Ocean": 10692, "\u0120mice": 10693, "Mus": 10694, "hire": 10695, "\u0120Tes": 10696, "Server": 10697, "limited": 10698, "Size": 10699, "\u0120meters": 10700, "\u0120rocket": 10701, "essee": 10702, "\u0120certificate": 10703, "\u0120Iranian": 10704, "ASS": 10705, "\u0120grid": 10706, "Dec": 10707, "\u0120rolling": 10708, "commun": 10709, "\u0120Sweden": 10710, "bury": 10711, "\u0120tissue": 10712, "\u0120racism": 10713, "\u0120Local": 10714, "\u0120mystery": 10715, "\u0120examine": 10716, "\u0120stem": 10717, "\u0120sits": 10718, "\u0120hoped": 10719, "oting": 10720, "\u0120dialogue": 10721, "\u0120persu": 10722, "Watch": 10723, "lay": 10724, "MAN": 10725, "\u0120chronic": 10726, "\u0120Portland": 10727, "market": 10728, "\u0120SEC": 10729, "\u0120parallel": 10730, "\u0120scandal": 10731, "\u0120carries": 10732, "\u0120phenomenon": 10733, "human": 10734, "acker": 10735, "\u0120Ox": 10736, "\u0120retirement": 10737, "tainment": 10738, "ovie": 10739, "\u0120Gear": 10740, "\u0120duties": 10741, "\u0120dose": 10742, "\u0120scroll": 10743, "MB": 10744, "inf": 10745, "\u0120sauce": 10746, "\u0120landscape": 10747, "reddit": 10748, "\u0120Championship": 10749, "\u0120Reddit": 10750, "alid": 10751, "\u0120coin": 10752, "\u0120overs": 10753, "\u0120posting": 10754, "about": 10755, "\u0120fel": 10756, "andy": 10757, "\u0120bold": 10758, "\u0120focusing": 10759, "effect": 10760, "GR": 10761, "\u0120deemed": 10762, "\u0120recommendations": 10763, "\u0120stepped": 10764, "\u0120voter": 10765, "\u0120Deep": 10766, "\u0120Instagram": 10767, "\u0120moderate": 10768, "\u0120Maryland": 10769, "\u0120restricted": 10770, "\u0120MB": 10771, "\u0120Chall": 10772, "\u0120tob": 10773, "\u0120cir": 10774, "\u0120Occ": 10775, "\u0120Ever": 10776, "\u0120collaps": 10777, "INFO": 10778, "=-": 10779, "\u0120Pict": 10780, "\u0120Account": 10781, "nc": 10782, "\u0120ought": 10783, "\u0120export": 10784, "\u0120drunk": 10785, "('": 10786, "\u0120wise": 10787, "\u0120Mort": 10788, "necess": 10789, "\u0120ancest": 10790, "\u0120Incre": 10791, "\u0120frequent": 10792, "mir": 10793, "\u0120interpretation": 10794, "\u0120dependent": 10795, "\u0120coins": 10796, "\u0120Bol": 10797, "Video": 10798, "\u0120Justin": 10799, "\u0120fatal": 10800, "\u0120cooking": 10801, "\u0120confusion": 10802, "ipher": 10803, "\u0120custody": 10804, "\u0120Morgan": 10805, "omach": 10806, "\u0120Governor": 10807, "\u0120restaurants": 10808, "eling": 10809, "\u0120acknowledged": 10810, "\u0120ther": 10811, "\u0120genes": 10812, "ching": 10813, "Hey": 10814, "\u0120tactics": 10815, "\u0120Mexican": 10816, "\u0120vend": 10817, "\u0120hes": 10818, "quer": 10819, "\u0120noting": 10820, "\u0120Cameron": 10821, "\u0120targeting": 10822, "rock": 10823, "\u0120credits": 10824, "\u0120emotions": 10825, "\u0120representatives": 10826, "news": 10827, "\u0120legislative": 10828, "\u0120removing": 10829, "\u0120tweeted": 10830, "\u0120Carter": 10831, "\u0120Fixed": 10832, "\u0120forcing": 10833, "\u0120speaker": 10834, "\u0120males": 10835, "\u0120Vietnam": 10836, "lined": 10837, "\u0120concepts": 10838, "\u0120voices": 10839, "oir": 10840, "\u0120Trib": 10841, "Whe": 10842, "\u0120Jerusalem": 10843, "\u0120Sant": 10844, "\u0120cul": 10845, "\u0120lady": 10846, "\u0120Hawai": 10847, "\u0120arts": 10848, "\u0120Inn": 10849, "\u0120Machine": 10850, "\u0120Emperor": 10851, "\u0120slot": 10852, "gly": 10853, "\u0120Process": 10854, "III": 10855, "\u0120athletes": 10856, "\u0120Temple": 10857, "\u0120Represent": 10858, "\u0120presc": 10859, "\u0120tons": 10860, "\u0120golden": 10861, "\u0120punch": 10862, "\u0120GR": 10863, "iverpool": 10864, "\u0120enact": 10865, "\u0120lobby": 10866, "\u0120mos": 10867, "\u0120picking": 10868, "\u0120lifetime": 10869, "\u0120cognitive": 10870, "Each": 10871, "zo": 10872, "\u0120dub": 10873, "\u0120consists": 10874, "oln": 10875, "\u0120festival": 10876, "amous": 10877, "\u0120intellig": 10878, "words": 10879, "\u0120Smart": 10880, "\u0120dele": 10881, "\u0120lapt": 10882, "\u0120magical": 10883, "\u0120Sin": 10884, "bus": 10885, "urities": 10886, "ighth": 10887, "\u0120Ruby": 10888, "\u0120Sure": 10889, "olving": 10890, "\u0120jun": 10891, "OST": 10892, "\u0120imposed": 10893, "\u0120astron": 10894, "\u0120correl": 10895, "\u0120NS": 10896, "\u0120Kit": 10897, "\u0120Future": 10898, "burn": 10899, "\u0120immune": 10900, "ocus": 10901, "\u0120courses": 10902, "\u0120String": 10903, "\u0120lean": 10904, "\u0120ghost": 10905, "\u0120outcomes": 10906, "\u0120expense": 10907, "\u0120everyday": 10908, "\u0120acceptable": 10909, "Ah": 10910, "\u0120equipped": 10911, "\u0120orange": 10912, "FR": 10913, "\u0120Dutch": 10914, "Though": 10915, "\u0120Rank": 10916, "QU": 10917, "\u0120Roberts": 10918, "what": 10919, "rend": 10920, "\u0120disappear": 10921, "\u0120spawn": 10922, "\u0120Lam": 10923, "ois": 10924, "\u0120deserve": 10925, "\u0120minimal": 10926, "\u0120nervous": 10927, "\u0120Would": 10928, "\u0120rook": 10929, "\u0120Vancouver": 10930, "\u0120resign": 10931, "shire": 10932, "\u0120Works": 10933, "\u0120Build": 10934, "\u0120affordable": 10935, "\u0120Gary": 10936, "\u0120Arena": 10937, "\u0120hanging": 10938, "\u0120implications": 10939, "\u0120Song": 10940, "\u0120maintaining": 10941, "\u0120guards": 10942, "CON": 10943, "\u0120derived": 10944, "\u0120executed": 10945, "\u0120theories": 10946, "\u0120quoted": 10947, "\u0120Andre": 10948, "oga": 10949, "seless": 10950, "info": 10951, "\u0120Belg": 10952, "\u0120tears": 10953, "\u0120Surv": 10954, "\u0120birthday": 10955, "igious": 10956, "immer": 10957, "\u0120spectrum": 10958, "\u0120architecture": 10959, "\u0120recruit": 10960, "arma": 10961, "Table": 10962, "\u0120monsters": 10963, "\u0120Gov": 10964, "\u0120destination": 10965, "\u0120attractive": 10966, "\u0120foss": 10967, "\u0120Moreover": 10968, "\u0120presents": 10969, "THE": 10970, "\u0120reply": 10971, "pton": 10972, "\u0120cum": 10973, "\u0120delight": 10974, "\u0120affects": 10975, "\u0120donations": 10976, "\u0120Toy": 10977, "\u0120Him": 10978, "MENT": 10979, "\u0120overcome": 10980, "itched": 10981, "\u0120Fantasy": 10982, "\u0120Hat": 10983, "\u0120Beast": 10984, "bott": 10985, "\u0120investigations": 10986, "Run": 10987, "\u0120hunting": 10988, "di": 10989, "fund": 10990, "\u0120sessions": 10991, "estyle": 10992, "\u0120portray": 10993, "oids": 10994, "Yeah": 10995, "\u0120communicate": 10996, "\u0120comedy": 10997, "\u0120Yang": 10998, "\u0120belt": 10999, "\u0120Marine": 11000, "\u0120predicted": 11001, "Play": 11002, "\u0120importantly": 11003, "\u0120remarkable": 11004, "\u0120eliminate": 11005, "David": 11006, "\u0120bind": 11007, "VID": 11008, "\u0120advocates": 11009, "\u0120Gaza": 11010, "imp": 11011, "DB": 11012, "\u0120Na": 11013, "\u0120Similar": 11014, "IES": 11015, "\u0120charity": 11016, "vas": 11017, "math": 11018, "\u0120\u00e2\u0138": 11019, "oker": 11020, "ndum": 11021, "\u0120caps": 11022, "\u0120Hal": 11023, "2000": 11024, "ean": 11025, "\u0120fleet": 11026, "\u0120recre": 11027, "Right": 11028, "\u0120sleeping": 11029, "ijing": 11030, "kind": 11031, "\u0120designated": 11032, "\u00c3\u00a4": 11033, "\u0120animation": 11034, "kee": 11035, "\u0120Introdu": 11036, "\u0120/>": 11037, "\u0120delayed": 11038, "\u0120tremend": 11039, "\u0120curious": 11040, "Use": 11041, "\u0120lect": 11042, "dam": 11043, "\u0120innovation": 11044, "\u0120Points": 11045, "\u0120loading": 11046, "\u0120dispute": 11047, "ctic": 11048, "irds": 11049, "\u0120BY": 11050, "\u0120nurs": 11051, "\u0120Value": 11052, "IONS": 11053, "\u0120Hum": 11054, "\u0120template": 11055, "mers": 11056, "\u0120appearances": 11057, "\u0120Entertainment": 11058, "\u0120translation": 11059, "\u0120sake": 11060, "\u0120beneath": 11061, "\u0120inhib": 11062, "\u0120euro": 11063, "abetes": 11064, "\u0120studying": 11065, "\u0120Mas": 11066, "\u0120perceived": 11067, "\u0120examined": 11068, "\u0120eager": 11069, "\u0120coaches": 11070, "\u0120imper": 11071, "chi": 11072, "\u0120produces": 11073, "\").": 11074, "\u0120Everyone": 11075, "\u0120municip": 11076, "\u0120girlfriend": 11077, "\u0120hire": 11078, "\u0120Vice": 11079, "\u0120suitable": 11080, "opy": 11081, "\u0120inequ": 11082, "\u0120Duke": 11083, "fish": 11084, "first": 11085, "\u0120Obs": 11086, "\u0120interior": 11087, "\u0120Bruce": 11088, "\u0120Ry": 11089, "\u0120analys": 11090, "\u0120considerable": 11091, "\u0120forecast": 11092, "\u0120fert": 11093, "orship": 11094, "\u0120Drug": 11095, "\u0120ALL": 11096, ":\"": 11097, "thur": 11098, "\u0120Mail": 11099, "\u0120ballot": 11100, "\u0120instantly": 11101, "\u0120Channel": 11102, "\u0120picks": 11103, "\u01201989": 11104, "\u0120tent": 11105, "oli": 11106, "\u0120civilian": 11107, "bling": 11108, "ello": 11109, "bu": 11110, "\u0120inch": 11111, "\u0120logo": 11112, "\u0120cooperation": 11113, "\u0120walks": 11114, "\u0120investments": 11115, "\u0120imprison": 11116, "\u0120Festival": 11117, "\u0120Ky": 11118, "\u0120legally": 11119, "\u0120gri": 11120, "charg": 11121, "Sl": 11122, "\u0120threatening": 11123, "duction": 11124, "flow": 11125, "\u0120dismissed": 11126, "ibraries": 11127, "cap": 11128, "ele": 11129, "\u0120McG": 11130, "\u0120Harvard": 11131, "\u0120Conservative": 11132, "\u0120CBS": 11133, "png": 11134, "\u0120roots": 11135, "\u0120Having": 11136, "umbled": 11137, "\u0120Fun": 11138, "\\/": 11139, "\u0120Search": 11140, "plex": 11141, "\u0120discussing": 11142, "\u0120continu": 11143, "\u0120Tai": 11144, "\u0120Wik": 11145, "Free": 11146, "fit": 11147, "\u0120refuse": 11148, "\u0120managing": 11149, "\u0120synd": 11150, "ipedia": 11151, "walk": 11152, "\u0120professionals": 11153, "\u0120guidance": 11154, "\u0120universities": 11155, "\u0120assemb": 11156, "untu": 11157, "Finally": 11158, "ASE": 11159, "\u0120Auto": 11160, "\u0120Had": 11161, "\u0120anniversary": 11162, "LD": 11163, "\u0120Dur": 11164, "\u0120Ultimate": 11165, "ihad": 11166, "product": 11167, "\u0120transit": 11168, "\u0120restore": 11169, "\u0120explaining": 11170, "\u0120asset": 11171, "\u0120transferred": 11172, "\u0120burst": 11173, "apolis": 11174, "\u0120Magazine": 11175, "\u0120Cra": 11176, "\u0120BR": 11177, "gged": 11178, "\u0120HE": 11179, "Mich": 11180, "bet": 11181, "\u0120Lady": 11182, "ylum": 11183, "erves": 11184, "\u0120meets": 11185, "white": 11186, "Log": 11187, "\u0120corresponding": 11188, "\u0120insisted": 11189, "GG": 11190, "\u0120surrounded": 11191, "\u0120tens": 11192, "\u0120lane": 11193, "\u0120coinc": 11194, "home": 11195, "\u0120existed": 11196, "ected": 11197, "\u0120Double": 11198, "lamm": 11199, "\u0120skept": 11200, "exp": 11201, "\u0120perception": 11202, "iev": 11203, "\u0120Being": 11204, "oft": 11205, "\u0120adopt": 11206, ".:": 11207, "];": 11208, "Windows": 11209, "\u0120satellite": 11210, "ASH": 11211, "\u0120infant": 11212, "description": 11213, "\u0120Meanwhile": 11214, "cm": 11215, "oca": 11216, "\u0120Treat": 11217, "actor": 11218, "\u0120tobacco": 11219, "\u0120Norm": 11220, "emption": 11221, "\u0120flesh": 11222, "\u0120je": 11223, "oop": 11224, "\u0120Heaven": 11225, "\u0120beating": 11226, "anim": 11227, "\u0120gathering": 11228, "\u0120cultiv": 11229, "GO": 11230, "abe": 11231, "\u0120Jonathan": 11232, "\u0120Safety": 11233, "\u0120badly": 11234, "prot": 11235, "\u0120choosing": 11236, "\u0120contacted": 11237, "\u0120quit": 11238, "\u0120distur": 11239, "\u0120stir": 11240, "\u0120token": 11241, "Det": 11242, "\u0120Pa": 11243, "\u0120functionality": 11244, "003": 11245, "some": 11246, "\u0120limitations": 11247, "\u0120meth": 11248, "build": 11249, "config": 11250, "NT": 11251, "rell": 11252, "blem": 11253, "\u0120Mom": 11254, "\u0120veterans": 11255, "\u0120Hu": 11256, "\u0120trends": 11257, "arer": 11258, "\u0120Given": 11259, "\u0120Caption": 11260, "may": 11261, "AST": 11262, "\u0120wondering": 11263, "\u0120Clark": 11264, "normal": 11265, "\u0120separated": 11266, "\u0120desp": 11267, "stic": 11268, "brew": 11269, "\u0120relating": 11270, "\u0120Nik": 11271, "\u0120Farm": 11272, "\u0120enthusi": 11273, "good": 11274, "deb": 11275, "\u0120activist": 11276, "\u0120mart": 11277, "\u0120explosion": 11278, "\u0120Economic": 11279, "Link": 11280, "\u0120insight": 11281, "\u0120convenient": 11282, "\u0120counterpart": 11283, "support": 11284, "\u0120Virt": 11285, "agen": 11286, "\u0120Tennessee": 11287, "\u0120Simon": 11288, "\u0120Award": 11289, "OCK": 11290, "\u0120Figure": 11291, "\u0120overseas": 11292, "\u0120pride": 11293, "\u0120Cas": 11294, "note": 11295, "mg": 11296, "Current": 11297, "\u0120displays": 11298, "content": 11299, "\u0120traveling": 11300, "\u0120hospitals": 11301, "\u0120Financial": 11302, "\u0120Past": 11303, "\u0120defendant": 11304, "\u0120streaming": 11305, "mble": 11306, "\u0120Berlin": 11307, "uki": 11308, "\u0120distribut": 11309, "\u0120antib": 11310, "\u0120chocolate": 11311, "\u0120Castle": 11312, "\u0120interrupt": 11313, "\u0120Row": 11314, "\u0120conversion": 11315, "\u0120bugs": 11316, "\u0120Rather": 11317, "liest": 11318, "LY": 11319, "\u0120Jean": 11320, "common": 11321, "akh": 11322, "\u0120130": 11323, "otton": 11324, "\u0120Dean": 11325, "\u0120amendment": 11326, "\u0120gameplay": 11327, "\u0120Warren": 11328, "oda": 11329, "\u0120highlights": 11330, "\u0120irre": 11331, "\u0120NATO": 11332, "\u0120balls": 11333, "\u0120demanding": 11334, "URE": 11335, "\u0120Luke": 11336, "Figure": 11337, "stop": 11338, "onia": 11339, "zone": 11340, "izers": 11341, "\u0120WR": 11342, "\u0120awarded": 11343, "\u0120regulatory": 11344, "\u0120Hart": 11345, "\u0120SN": 11346, "pling": 11347, "\u0120sour": 11348, "\u0120Pixel": 11349, "usive": 11350, "\u0120fet": 11351, "\u0120Sent": 11352, "\u0120automatic": 11353, "\u0120fer": 11354, "vernment": 11355, "\u0120Khan": 11356, "TON": 11357, "father": 11358, "\u0120extraordinary": 11359, "throp": 11360, "\u0120Python": 11361, "\u0120GPU": 11362, "\u0120sexually": 11363, "\u0120desktop": 11364, "itivity": 11365, "\u0120Antonio": 11366, "\u0120orient": 11367, "\u0120ears": 11368, "obby": 11369, "ouses": 11370, "vertisements": 11371, "\u0120manufacturers": 11372, "icient": 11373, "minute": 11374, "\u0120conviction": 11375, "\u0120garden": 11376, "public": 11377, "\u0120satisfied": 11378, "fold": 11379, "OK": 11380, "\u0120inhab": 11381, "\u0120Think": 11382, "\u0120programme": 11383, "\u0120stomach": 11384, "\u0120coordin": 11385, "\u0120holy": 11386, "\u0120threshold": 11387, "\u0120rhet": 11388, "\u0120serial": 11389, "\u0120employers": 11390, "\u0120Everything": 11391, "rah": 11392, "\u0120bother": 11393, "\u0120brands": 11394, "Value": 11395, "\u0120Ted": 11396, "\u0120Planet": 11397, "\u0120pink": 11398, "\u0120Furthermore": 11399, "sa": 11400, "PE": 11401, "reck": 11402, "\u0120USD": 11403, "otte": 11404, "\u0120&&": 11405, "\u0120landed": 11406, "gets": 11407, "\u0120producers": 11408, "\u0120healthcare": 11409, "\u0120dominant": 11410, "\u0120destro": 11411, "\u0120amended": 11412, "chron": 11413, "\u0120fits": 11414, "\u0120Syd": 11415, "\u0120Authority": 11416, "ATCH": 11417, "\u0120fights": 11418, "\u0120LLC": 11419, "\u0120---": 11420, "\u0120Corp": 11421, "\u0120toxic": 11422, "specific": 11423, "\u0120Corn": 11424, "\u0120Chel": 11425, "\u0120telephone": 11426, "\u0120Pant": 11427, "\u0120mysterious": 11428, "aunch": 11429, "odox": 11430, "media": 11431, "\u0120witnesses": 11432, "agu": 11433, "\u0120questioned": 11434, "\u0120Brexit": 11435, "\u0120Remember": 11436, "enez": 11437, "\u0120endorse": 11438, "iatric": 11439, "\u0120Ident": 11440, "\u0120ridiculous": 11441, "110": 11442, "\u0120prayer": 11443, "\u0120scientist": 11444, "\u01201950": 11445, "\u0120Aqu": 11446, "\u0120underground": 11447, "\u0120UFC": 11448, "mare": 11449, "\u0120Later": 11450, "wich": 11451, "\u0120subscrib": 11452, "\u0120hosts": 11453, "\u0120err": 11454, "\u0120grants": 11455, "antom": 11456, "\u0120summon": 11457, "early": 11458, "\u0120Clear": 11459, "\u0120Prim": 11460, "\u0120suspension": 11461, "\u0120guaranteed": 11462, "apper": 11463, "\u0120rice": 11464, "\u0120Sean": 11465, "\u0120Shin": 11466, "\u0120referendum": 11467, "\u0120fled": 11468, "rust": 11469, "\u0120360": 11470, "tery": 11471, "\u0120shocked": 11472, "BR": 11473, "\u0120Oil": 11474, "\u0120Allah": 11475, "\u0120partly": 11476, "\u0120ignor": 11477, "\u0120transmission": 11478, "\u0120homosexual": 11479, "iversal": 11480, "\u0120hopefully": 11481, "\u00e3\u0124\u00a4": 11482, "\u0120lesson": 11483, "Leg": 11484, "\u0120..": 11485, "Yet": 11486, "table": 11487, "appropri": 11488, "rett": 11489, "\u0120boards": 11490, "\u0120incorrect": 11491, "\u0120bacteria": 11492, "aru": 11493, "amac": 11494, "\u0120snap": 11495, ".'\"": 11496, "\u0120parad": 11497, "tem": 11498, "heart": 11499, "\u0120availability": 11500, "\u0120wisdom": 11501, "\u0120(+": 11502, "\u0120priest": 11503, "\u0120\u00c2\u0142\u0120\u00c2\u0142": 11504, "Open": 11505, "\u0120span": 11506, "\u0120parameter": 11507, "\u0120convince": 11508, "\u0120(%)": 11509, "rac": 11510, "\u0120fo": 11511, "\u0120safely": 11512, "\u0120converted": 11513, "\u0120Olympic": 11514, "\u0120reserve": 11515, "\u0120healing": 11516, "\u0120Mine": 11517, "Max": 11518, "\u0120inherent": 11519, "\u0120Graham": 11520, "\u0120integrated": 11521, "Dem": 11522, "\u0120pipeline": 11523, "\u0120applying": 11524, "\u0120embed": 11525, "\u0120Charlie": 11526, "\u0120cave": 11527, "2008": 11528, "\u0120consensus": 11529, "\u0120rewards": 11530, "Pal": 11531, "\u0120HTML": 11532, "\u0120popularity": 11533, "looking": 11534, "\u0120Sword": 11535, "\u0120Arts": 11536, "')": 11537, "\u0120electron": 11538, "clusions": 11539, "\u0120integrity": 11540, "\u0120exclusively": 11541, "\u0120grace": 11542, "\u0120torture": 11543, "\u0120burned": 11544, "two": 11545, "\u0120180": 11546, "Produ": 11547, "\u0120entreprene": 11548, "raphics": 11549, "\u0120gym": 11550, "ricane": 11551, "\u0120Tam": 11552, "\u0120administrative": 11553, "\u0120manufacturer": 11554, "\u0120vel": 11555, "\u0120Ni": 11556, "\u0120isolated": 11557, "\u0120Medicine": 11558, "\u0120backup": 11559, "\u0120promoting": 11560, "\u0120commander": 11561, "\u0120flee": 11562, "\u0120Russell": 11563, "\u0120forgotten": 11564, "\u0120Missouri": 11565, "\u0120residence": 11566, "mons": 11567, "\u0120resemb": 11568, "\u0120wand": 11569, "\u0120meaningful": 11570, "PT": 11571, "\u0120bol": 11572, "\u0120helic": 11573, "\u0120wealthy": 11574, "\u0120rifle": 11575, "strong": 11576, "rowing": 11577, "plan": 11578, "asury": 11579, "\u00e2\u0122\u00a6.": 11580, "\u0120expanding": 11581, "\u0120Hamilton": 11582, "\u0120receives": 11583, "SI": 11584, "eatures": 11585, "\u0120Anim": 11586, "REE": 11587, "Put": 11588, "\u0120briefly": 11589, "rive": 11590, "\u0120stimul": 11591, "\u0120``(": 11592, "\u0120__": 11593, "\u0120chip": 11594, "\u0120haz": 11595, "\u0120prize": 11596, "\u0120Things": 11597, "ACE": 11598, "ulin": 11599, "dict": 11600, "oku": 11601, "\u0120associate": 11602, "ockets": 11603, "youtube": 11604, "Story": 11605, "ategory": 11606, "\u0120mild": 11607, "ailing": 11608, "\u0120Ye": 11609, "Orig": 11610, "\u0120Ka": 11611, "orig": 11612, "\u0120propaganda": 11613, "\u0120anonymous": 11614, "\u0120struggled": 11615, "\u0120outrage": 11616, "ATED": 11617, "\u0120Beijing": 11618, "rary": 11619, "\u0120leather": 11620, "\u0120worlds": 11621, "\u0120broader": 11622, "125": 11623, "idal": 11624, "\u0120Better": 11625, "\u0120tear": 11626, "Ext": 11627, "\u0120proposals": 11628, "\u0120iter": 11629, "\u0120Squad": 11630, "\u0120volunt": 11631, "mi": 11632, "Did": 11633, "\u0120Pu": 11634, "pin": 11635, "\u0120speakers": 11636, "\u0120borders": 11637, "\u0120figured": 11638, "='": 11639, "\u0120simultaneously": 11640, "aeda": 11641, "\u0120charging": 11642, "\u0120urged": 11643, "\u0120conj": 11644, "256": 11645, "\u0120Gordon": 11646, "merce": 11647, "\u0120documentary": 11648, "Share": 11649, "itol": 11650, "ONE": 11651, "\u0120Garden": 11652, "hatt": 11653, "\u0120Thompson": 11654, "aneous": 11655, "apore": 11656, "\u0120tanks": 11657, "\u0120lessons": 11658, "track": 11659, "\u0120outstanding": 11660, "\u0120volunteers": 11661, "\u0120spray": 11662, "\u0120managers": 11663, "large": 11664, "\u0120camps": 11665, "\u0120artificial": 11666, "\u0120Ru": 11667, "\u0120bags": 11668, "thal": 11669, "\u0120compatible": 11670, "\u0120Blade": 11671, "\u0120fed": 11672, "\u0120argues": 11673, "FI": 11674, "\u0120unfair": 11675, "\u0120corn": 11676, "\u0120offset": 11677, "\u0120directions": 11678, "\u0120disappointed": 11679, "\u0120Convention": 11680, "\u0120viewing": 11681, "ME": 11682, "ocity": 11683, "\u0120towns": 11684, "\u0120layers": 11685, "\u0120rolled": 11686, "\u0120jumped": 11687, "\u0120attribute": 11688, "\u0120unnecess": 11689, "incoln": 11690, "\u0120suppose": 11691, "\u0120Nether": 11692, "cha": 11693, "\u0120buried": 11694, "\u0120sixth": 11695, "Ben": 11696, "ressing": 11697, "OUR": 11698, "\u0120wound": 11699, "\u0120cycl": 11700, "\u0120mechanisms": 11701, "\u0120congressional": 11702, "\u0120Element": 11703, "\u0120agreements": 11704, "\u0120decor": 11705, "\u0120closest": 11706, "\u0120Mit": 11707, "Google": 11708, "}}": 11709, "\u0120mixture": 11710, "\u0120fluid": 11711, "Sign": 11712, "\u0120Scholar": 11713, "\u0120pist": 11714, "asket": 11715, "abling": 11716, "\u0120racing": 11717, "hero": 11718, "riel": 11719, "assy": 11720, "\u0120cheaper": 11721, "ben": 11722, "\u0120vertical": 11723, "amacare": 11724, "\u0120Reading": 11725, "gments": 11726, "\u0120helicop": 11727, "\u0120sacrifice": 11728, "aya": 11729, "paren": 11730, "VA": 11731, "\u0120Les": 11732, "\u0120Studio": 11733, "\u0120violations": 11734, "\u0120Anna": 11735, "acer": 11736, "\u00e9\u00be": 11737, "\u0120Rat": 11738, "\u0120Beck": 11739, "\u0120Dick": 11740, "\u0120ACT": 11741, "\u0120composition": 11742, "\u0120texture": 11743, "\u0120Own": 11744, "\u0120smartphone": 11745, "\u0120NA": 11746, "\u0120forb": 11747, "import": 11748, "\u0120defending": 11749, "ilst": 11750, "rer": 11751, "\u0120oh": 11752, "\u0120Jeremy": 11753, "\u0120banking": 11754, "ceptions": 11755, "\u0120respective": 11756, "/.": 11757, "\u0120drinks": 11758, "\u0120Wi": 11759, "\u0120bands": 11760, "\u0120Liverpool": 11761, "\u0120grip": 11762, "\u0120Buy": 11763, "\u0120openly": 11764, "\u0120reviewed": 11765, "pert": 11766, "\u0120verify": 11767, "\u0120Cole": 11768, "\u0120Wales": 11769, "MO": 11770, "\u0120unpre": 11771, "\u0120shelter": 11772, "\u0120Imperial": 11773, "\u0120gui": 11774, "\u0120Dak": 11775, "\u0120suggestions": 11776, "\u0120explicitly": 11777, "\u0120slave": 11778, "\u0120blockchain": 11779, "\u0120competing": 11780, "\u0120promising": 11781, "SON": 11782, "\u0120soccer": 11783, "\u0120constitution": 11784, "429": 11785, "\u0120distract": 11786, "\u0120User": 11787, "esides": 11788, "\u0120Method": 11789, "\u0120Tokyo": 11790, "\u0120accompanied": 11791, "Client": 11792, "sur": 11793, "alog": 11794, "\u0120identification": 11795, "\u0120invasion": 11796, "asma": 11797, "\u0120industries": 11798, "ppers": 11799, "\u0120subtle": 11800, "\u0120Unit": 11801, "natural": 11802, "\u0120survived": 11803, "\u0120flaw": 11804, "\u013a\u0127": 11805, "\u0120Holl": 11806, "\u0120deficit": 11807, "\u0120tutorial": 11808, "\u0120Chance": 11809, "\u0120arguing": 11810, "\u0120contemporary": 11811, "\u0120integration": 11812, "forward": 11813, "\u0120tum": 11814, "itis": 11815, "\u0120hiding": 11816, "\u0120Domin": 11817, "\u0120Tan": 11818, "\u0120Building": 11819, "\u0120Vin": 11820, "\u0120spokesperson": 11821, "\u0120Notes": 11822, "\u0120emerging": 11823, "\u0120preparation": 11824, "\u0120prost": 11825, "\u0120suspects": 11826, "\u0120autonom": 11827, "Description": 11828, "\u0120dealt": 11829, "\u0120Pear": 11830, "\u0120steady": 11831, "\u0120decreased": 11832, "\u0120sovere": 11833, "\u0120Clin": 11834, "\u0120gradually": 11835, "orses": 11836, "\u0120WAR": 11837, "Serv": 11838, "\u00e3\u0124\u00a2": 11839, "hr": 11840, "\u0120dirty": 11841, "\u0120Barn": 11842, "\u0120BC": 11843, "\u0120dil": 11844, "\u0120calendar": 11845, "\u0120compliance": 11846, "\u0120chamber": 11847, "bb": 11848, "\u0120passenger": 11849, "ateful": 11850, "\u0120Title": 11851, "\u0120Sydney": 11852, "\u0120Got": 11853, "\u0120darkness": 11854, "\u0120defect": 11855, "\u0120packed": 11856, "assion": 11857, "\u0120gods": 11858, "\u0120harsh": 11859, "ICK": 11860, "leans": 11861, "\u0120algorithm": 11862, "\u0120oxygen": 11863, "\u0120visits": 11864, "\u0120blade": 11865, "\u0120kilomet": 11866, "\u0120Kentucky": 11867, "\u0120killer": 11868, "Pack": 11869, "enny": 11870, "\u0120divine": 11871, "\u0120nomination": 11872, "being": 11873, "\u0120engines": 11874, "\u0120cats": 11875, "\u0120buffer": 11876, "\u0120Phill": 11877, "\u0120traff": 11878, "AGE": 11879, "\u0120tongue": 11880, "\u0120radiation": 11881, "erer": 11882, "mem": 11883, "\u0120Explicit": 11884, "\u00e9\u00be\u012f": 11885, "\u0120couples": 11886, "\u0120physics": 11887, "\u0120McK": 11888, "\u0120politically": 11889, "awks": 11890, "\u0120Bloom": 11891, "\u0120worship": 11892, "eger": 11893, "uter": 11894, "\u0120FO": 11895, "\u0120mathemat": 11896, "\u0120sentenced": 11897, "\u0120disk": 11898, "\u0120Marg": 11899, "\u0120/*": 11900, "PI": 11901, "\u0120optional": 11902, "\u0120babies": 11903, "\u0120seeds": 11904, "\u0120Scottish": 11905, "\u0120thy": 11906, "]]": 11907, "\u0120Hitler": 11908, "PH": 11909, "ngth": 11910, "\u0120recovered": 11911, "inge": 11912, "\u0120powder": 11913, "\u0120lips": 11914, "\u0120designer": 11915, "\u0120disorders": 11916, "\u0120courage": 11917, "\u0120chaos": 11918, "\"},{\"": 11919, "\u0120carrier": 11920, "bably": 11921, "High": 11922, "\u0120RT": 11923, "esity": 11924, "len": 11925, "\u0120routes": 11926, "uating": 11927, "Fil": 11928, "NOT": 11929, "wall": 11930, "sburgh": 11931, "\u0120engaging": 11932, "\u0120JavaScript": 11933, "orer": 11934, "lihood": 11935, "\u0120unions": 11936, "\u0120Federation": 11937, "\u0120Tesla": 11938, "\u0120completion": 11939, "\u0120Ta": 11940, "\u0120privilege": 11941, "\u0120Orange": 11942, "\u0120neur": 11943, "parency": 11944, "\u0120bones": 11945, "\u0120titled": 11946, "\u0120prosecutors": 11947, "\u0120ME": 11948, "\u0120engineer": 11949, "\u0120Universe": 11950, "\u0120Hig": 11951, "nie": 11952, "oard": 11953, "\u0120hearts": 11954, "\u0120Gre": 11955, "ussion": 11956, "\u0120ministry": 11957, "\u0120penet": 11958, "\u0120Nut": 11959, "\u0120Ow": 11960, "\u0120XP": 11961, "instein": 11962, "\u0120bulk": 11963, "System": 11964, "icism": 11965, "\u0120Marketable": 11966, "\u0120preval": 11967, "\u0120poster": 11968, "\u0120attending": 11969, "urable": 11970, "\u0120licensed": 11971, "\u0120Gh": 11972, "etry": 11973, "\u0120Tradable": 11974, "\u0120blast": 11975, "\u00e0\u00a4": 11976, "\u0120Titan": 11977, "elled": 11978, "die": 11979, "Have": 11980, "\u0120Flame": 11981, "\u0120profound": 11982, "\u0120participating": 11983, "\u0120anime": 11984, "\u0120Ess": 11985, "\u0120specify": 11986, "\u0120regarded": 11987, "\u0120Spell": 11988, "\u0120sons": 11989, "owned": 11990, "\u0120merc": 11991, "\u0120experimental": 11992, "lando": 11993, "hs": 11994, "\u0120Dungeon": 11995, "inos": 11996, "\u0120comply": 11997, "\u0120Systems": 11998, "arth": 11999, "\u0120seized": 12000, "local": 12001, "\u0120Girls": 12002, "udo": 12003, "oned": 12004, "\u0120Fle": 12005, "\u0120constructed": 12006, "\u0120hosted": 12007, "\u0120scared": 12008, "actic": 12009, "\u0120Islands": 12010, "\u0120MORE": 12011, "\u0120bless": 12012, "\u0120blocking": 12013, "\u0120chips": 12014, "\u0120evac": 12015, "Ps": 12016, "\u0120corporation": 12017, "\u0120ox": 12018, "\u0120lighting": 12019, "\u0120neighbors": 12020, "\u0120Ub": 12021, "aro": 12022, "\u0120beef": 12023, "\u0120Uber": 12024, "Facebook": 12025, "armed": 12026, "itate": 12027, "\u0120Rating": 12028, "\u0120Quick": 12029, "\u0120occupied": 12030, "\u0120aims": 12031, "\u0120Additionally": 12032, "\u0120Interest": 12033, "\u0120dramatically": 12034, "\u0120heal": 12035, "\u0120painting": 12036, "\u0120engineers": 12037, "MM": 12038, "\u0120Must": 12039, "\u0120quantity": 12040, "Paul": 12041, "\u0120earnings": 12042, "\u0120Posts": 12043, "stra": 12044, "\u00e3\u0125\u00bc\u00e3\u0125": 12045, "\u0120stance": 12046, "\u0120dropping": 12047, "script": 12048, "\u0120dressed": 12049, "Make": 12050, "\u0120justify": 12051, "\u0120Ltd": 12052, "\u0120prompted": 12053, "\u0120scrut": 12054, "\u0120speeds": 12055, "\u0120Giants": 12056, "omer": 12057, "\u0120Editor": 12058, "\u0120describing": 12059, "\u0120Lie": 12060, "mented": 12061, "\u0120nowhere": 12062, "ocaly": 12063, "\u0120instruction": 12064, "fortable": 12065, "\u0120entities": 12066, "\u0120cm": 12067, "\u0120Natural": 12068, "\u0120inquiry": 12069, "\u0120pressed": 12070, "izont": 12071, "forced": 12072, "\u0120raises": 12073, "\u0120Netflix": 12074, "\u0120Side": 12075, "\u0120outer": 12076, "\u0120amongst": 12077, "ims": 12078, "owski": 12079, "\u0120climb": 12080, "never": 12081, "\u0120combine": 12082, "ding": 12083, "\u0120compr": 12084, "\u0120significance": 12085, "\u0120remembered": 12086, "\u0120Nevada": 12087, "\u0120Tel": 12088, "\u0120Scar": 12089, "\u0120Warriors": 12090, "\u0120Jane": 12091, "\u0120coup": 12092, "bas": 12093, "\u0120terminal": 12094, ",-": 12095, "OH": 12096, "\u0120tension": 12097, "\u0120wings": 12098, "\u0120Myster": 12099, "\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd": 12100, "\u0120Unlike": 12101, "valid": 12102, "vironments": 12103, "\u0120Ali": 12104, "\u0120naked": 12105, "books": 12106, "\u0120Mun": 12107, "\u0120Gulf": 12108, "\u0120density": 12109, "\u0120dimin": 12110, "\u0120desperate": 12111, "\u0120presidency": 12112, "\u01201986": 12113, "hy": 12114, "IND": 12115, "\u0120unlock": 12116, "imens": 12117, "\u0120handled": 12118, "\u0120Eb": 12119, "\u0120disappeared": 12120, "\u0120genre": 12121, "\u01201988": 12122, "\u0120determination": 12123, "Stream": 12124, "iko": 12125, "apters": 12126, "\u0120acknowledge": 12127, "Jan": 12128, "\u0120capitalism": 12129, "Pat": 12130, "\u01202020": 12131, "\u0120painful": 12132, "\u0120curve": 12133, "\u0120bombs": 12134, "storm": 12135, "\u0120Metal": 12136, "encer": 12137, "\u0120Fig": 12138, "\u0120Aaron": 12139, "anches": 12140, "\u0120inspiration": 12141, "\u0120exhaust": 12142, "tains": 12143, "ashi": 12144, "\u0120descript": 12145, "\u0120ritual": 12146, "\u0120Chelsea": 12147, "\u0120promotion": 12148, "\u0120Hung": 12149, "\u0120Ward": 12150, "iva": 12151, "\u0120ET": 12152, "\u0120toss": 12153, "allow": 12154, "\u0120Francis": 12155, "Dep": 12156, "\u0120happiness": 12157, "\u0120Glass": 12158, "\u0120beta": 12159, "\u0120strengthen": 12160, "NE": 12161, "oa": 12162, "\u0120buttons": 12163, "\u0120Murray": 12164, "\u0120kicked": 12165, "Quest": 12166, "\u0120Talk": 12167, "\u0120Several": 12168, "\u0120Zero": 12169, "\u0120drone": 12170, "ulk": 12171, "\u0120cam": 12172, "\u0120Mobile": 12173, "\u0120preventing": 12174, "\u0120retro": 12175, "\u0120Ax": 12176, "\u0120cruel": 12177, "\u0120float": 12178, ".),": 12179, "\u0120filing": 12180, "\u0120Grant": 12181, "\u0120Bor": 12182, "\u0120rib": 12183, "\u0120championship": 12184, "\u0120Merc": 12185, "\u0120styles": 12186, "\u0120cake": 12187, "\u0120builds": 12188, "\u0120Self": 12189, "iox": 12190, "\u0120epic": 12191, "oyd": 12192, "Bel": 12193, "\u0120Stew": 12194, ".(": 12195, "ahu": 12196, "\u0120Beyond": 12197, "\u0120outs": 12198, "\u0120solo": 12199, "\u0120Tree": 12200, "\u0120preserve": 12201, "\u0120tub": 12202, "ARE": 12203, "roc": 12204, "\u0120Impro": 12205, "\u0120Wright": 12206, "\u0120bund": 12207, "\u0120traged": 12208, "\u0120occasional": 12209, "bian": 12210, "Second": 12211, "rons": 12212, "\u0120interactions": 12213, "formed": 12214, "sing": 12215, "\u0120owns": 12216, "\u0120hockey": 12217, "General": 12218, "\u0120logical": 12219, "\u0120expend": 12220, "\u0120escal": 12221, "\u0120Griff": 12222, "\u0120Crown": 12223, "\u0120Reserve": 12224, "\u0120stopping": 12225, "\u0120excuse": 12226, "second": 12227, "\u0120operated": 12228, "\u0120reaches": 12229, "\u0120Malays": 12230, "\u0120pollution": 12231, "\u0120Brooklyn": 12232, "\u0120delete": 12233, "\u0120hash": 12234, "Block": 12235, "aha": 12236, "\u00e2\u0122\u00b3": 12237, "\u0120shorter": 12238, "piece": 12239, "></": 12240, "\u0120horm": 12241, "\u0120Wat": 12242, "\u0120Break": 12243, "\u0120prohibited": 12244, "\u0120intensity": 12245, "\u0120Alan": 12246, "\u0120liability": 12247, "?!": 12248, "anded": 12249, "\u0120neighbour": 12250, "\u0120Collection": 12251, "\u0120fires": 12252, "\u0120revolutionary": 12253, "fly": 12254, "\u0120Orleans": 12255, "White": 12256, "\u0120Writ": 12257, "\u0120Dawn": 12258, "\u0120settle": 12259, "\u0120execute": 12260, "BM": 12261, "\u0120spokeswoman": 12262, "\u0120lifestyle": 12263, "\u0120clicking": 12264, "\u0120Kill": 12265, "\u0120Liberal": 12266, "\u0120Nazi": 12267, "\u0120trailer": 12268, "\u0120mountains": 12269, "\u0120damn": 12270, "zes": 12271, "pes": 12272, "\u0120pressing": 12273, "\u0120bail": 12274, "\u0120Organization": 12275, "\u0120pir": 12276, "\u0120thirty": 12277, "\u0120electrical": 12278, "\u0120115": 12279, "\u0120Poly": 12280, "\u0120Rap": 12281, "\u0120Strike": 12282, "\u0120Cann": 12283, "\u0120demanded": 12284, "\u0120backing": 12285, "default": 12286, "speed": 12287, "\u0120Legisl": 12288, "\u0120mothers": 12289, "\u0120Body": 12290, "\u0120variation": 12291, "cedented": 12292, "powered": 12293, "leading": 12294, "Never": 12295, "\u0120grave": 12296, "\u0120Anti": 12297, "AW": 12298, "\u0120interviewed": 12299, "\u0120Gab": 12300, "\u0120Fat": 12301, "\u0120rookie": 12302, "uu": 12303, "\u0120depos": 12304, "ixon": 12305, "\u0120ampl": 12306, "retion": 12307, "\u0120Heat": 12308, "\u0120peaceful": 12309, "SM": 12310, "ieve": 12311, "\u0120diver": 12312, "\u0120Victoria": 12313, "\u0120mic": 12314, "pdf": 12315, "\u0120stating": 12316, "\u0120lung": 12317, "\u0120criticized": 12318, "\u0120vaccine": 12319, "\u0120Loading": 12320, "urse": 12321, "Take": 12322, "\u0120Fran": 12323, "\u0120Sold": 12324, "\u0120Robin": 12325, "\u0120detected": 12326, "\u0120Script": 12327, "\u0120adjusted": 12328, "\u0120senator": 12329, "\u0120opposing": 12330, "Error": 12331, "Count": 12332, "\u0120conflicts": 12333, "\u0120ow": 12334, "\u0120Argent": 12335, "\u0120matching": 12336, "hh": 12337, "\u0120Trek": 12338, "starter": 12339, "\"),": 12340, "\u0120AF": 12341, "oder": 12342, "xxxx": 12343, "\u0120Alt": 12344, "acre": 12345, "\u0120Pick": 12346, "\u0120Solar": 12347, "\u0120Dal": 12348, "Oct": 12349, "\u0120Batt": 12350, "\u0120src": 12351, "\u0120engagement": 12352, "\u0120executives": 12353, "\u0120liberty": 12354, "java": 12355, "\u0120talented": 12356, "igenous": 12357, "\u0120consecut": 12358, ".....": 12359, "Info": 12360, "\u0120horrible": 12361, "\u0120surprisingly": 12362, "feed": 12363, "icating": 12364, "\u0120LED": 12365, "\u0120females": 12366, "Station": 12367, "eller": 12368, "\u0120Oakland": 12369, "\u0120mechanical": 12370, "iology": 12371, "\u0120Var": 12372, "\u0120robust": 12373, "ettings": 12374, "otta": 12375, "\u0120theoret": 12376, "\u0120retain": 12377, "kward": 12378, "\u0120da": 12379, "\u0120deployed": 12380, "del": 12381, "\u0120Andy": 12382, "\u0120subscribe": 12383, "web": 12384, "\u0120na": 12385, "\u0120Michel": 12386, "\u0120partially": 12387, "\u0120Comey": 12388, "\u0120crown": 12389, "\u0120Maj": 12390, "\u0120Blu": 12391, "rator": 12392, "Day": 12393, "INT": 12394, "\u0120documented": 12395, "\u0120GDP": 12396, "gi": 12397, "chell": 12398, "\u0120brutal": 12399, "\u0120Bab": 12400, "stration": 12401, "\u0120theft": 12402, "\u0120tube": 12403, "@@": 12404, "\u0120query": 12405, "\u0120Lincoln": 12406, "\u0120publishing": 12407, "\u0120wore": 12408, "orical": 12409, "\u0120ric": 12410, "\u0120notable": 12411, "\u0120subsequently": 12412, "nex": 12413, "\u0120observe": 12414, "\u0120Boe": 12415, "\u0120codes": 12416, "main": 12417, "WH": 12418, "\u0120SL": 12419, "\u0120residential": 12420, "avan": 12421, "\u0120mas": 12422, "arest": 12423, "adeon": 12424, "OUT": 12425, "\u0120sophistic": 12426, "ante": 12427, "\u0120cens": 12428, "\u0120**": 12429, "\u0120mortality": 12430, "\u0120yours": 12431, "\u0120occasions": 12432, "\u0120recalled": 12433, "\u0120Driver": 12434, "\u0120vocal": 12435, "\u0120bathroom": 12436, "\u0120shops": 12437, "\u0120collaboration": 12438, "\u0120Obamacare": 12439, "\u0120Cell": 12440, "Char": 12441, "Super": 12442, "Cre": 12443, "\u0120tends": 12444, "\u0120torn": 12445, "\u0120economics": 12446, "avery": 12447, "\u0120Raid": 12448, "\u0120Sem": 12449, "\u0120shoulders": 12450, "\u0120expecting": 12451, "\u0120examination": 12452, "ename": 12453, "\u0120UI": 12454, "iability": 12455, "olas": 12456, "\u0120Amb": 12457, "\u0120Dra": 12458, "\u0120midfield": 12459, "\u0120IC": 12460, "\u0120layout": 12461, "\u0120floating": 12462, "fi": 12463, "itative": 12464, "\u0120tremendous": 12465, "\u0120\u00d0": 12466, "\u0120abund": 12467, "Work": 12468, "\u0120Lightning": 12469, "\u0120similarly": 12470, "\u0120conservatives": 12471, "\u0120pray": 12472, "BE": 12473, "izarre": 12474, "\u0120tempt": 12475, "\u0120emphasis": 12476, "\u0120Metro": 12477, "\u0120fishing": 12478, "\u0120marry": 12479, "neg": 12480, "\u0120Study": 12481, "\u0120reck": 12482, "\u0120dispos": 12483, "oning": 12484, "bsite": 12485, "\u0120suspic": 12486, "\u0120merch": 12487, "\u0120Gib": 12488, "\u0120Description": 12489, "\u0120DVD": 12490, "whe": 12491, "\u0120Yemen": 12492, "\u0120environments": 12493, "ooting": 12494, "\u0120Modern": 12495, "eu": 12496, "\u0120reflects": 12497, "\u0120honey": 12498, "\u0120analyst": 12499, "\u0120gut": 12500, "dec": 12501, "Action": 12502, "\u0120households": 12503, "\u0120ster": 12504, "\u0120temple": 12505, "\u0120reforms": 12506, "\u0120favourite": 12507, "\u0120deadline": 12508, "\u0120LE": 12509, "Three": 12510, "\u0120Within": 12511, "Aug": 12512, "\u0120nights": 12513, "elta": 12514, "\u0120invalid": 12515, "\u0120Exchange": 12516, "\u0120Delhi": 12517, "when": 12518, "income": 12519, "\u0120\u00f0\u0141": 12520, "\u0120wireless": 12521, "scribe": 12522, "ista": 12523, "\u0120hostile": 12524, "\u0120ally": 12525, "\u0120gig": 12526, "\u0120outlets": 12527, "\u0120Dor": 12528, "EMENT": 12529, "\u0120ash": 12530, "\u0120abstract": 12531, "ORD": 12532, "\u0120Motor": 12533, "\u0120adviser": 12534, "istle": 12535, "\u0120bases": 12536, "\u0120courtesy": 12537, "\u0120crossing": 12538, "\u0120cleared": 12539, "\u0120refugee": 12540, "cosystem": 12541, "\u0120throws": 12542, "fun": 12543, "bourne": 12544, "days": 12545, "\u0120disagree": 12546, "\u0120Native": 12547, "\u0120reflected": 12548, "\u0120Fast": 12549, "\u0120Yellow": 12550, "\u0120Singapore": 12551, "\u0120Raven": 12552, "\u0120embrace": 12553, "\u0120Ku": 12554, "\u0120Chen": 12555, "\u0120Early": 12556, "\u0120appointment": 12557, "\u0120Mini": 12558, "itement": 12559, "\u0120placing": 12560, "\u0120bicy": 12561, "SR": 12562, "\u0120whis": 12563, "SU": 12564, "\u0120investigated": 12565, "\u0120photographs": 12566, "github": 12567, "\u0120Beat": 12568, "\u0120Ring": 12569, "ighed": 12570, "iar": 12571, "\u0120evolved": 12572, "erald": 12573, "\u0120dun": 12574, "\u0120hub": 12575, "IAL": 12576, "\u0120encouraging": 12577, "\u0120Print": 12578, "\u0120Days": 12579, "\u0120prosecution": 12580, "\u0120pants": 12581, "azy": 12582, "live": 12583, "\u0120fossil": 12584, "\u0120Ju": 12585, "\u0120rocks": 12586, "udge": 12587, "\u0120Race": 12588, "\u0120greet": 12589, "bie": 12590, "\u0120filling": 12591, "\u0120Len": 12592, "\u0120diabetes": 12593, "\u0120firearms": 12594, "uming": 12595, "enezuel": 12596, "\u0120BB": 12597, "\u0120accepting": 12598, "ATH": 12599, "\u0120resort": 12600, "\u0120hunt": 12601, "rik": 12602, "ucker": 12603, "aments": 12604, "\u0120sustained": 12605, "\u0120crossed": 12606, "\u0120breakfast": 12607, "\u0120attributes": 12608, "lected": 12609, "atile": 12610, "\u0120vibr": 12611, "\u0120Kal": 12612, "arson": 12613, "oples": 12614, "\u0120touched": 12615, "\u0120damages": 12616, "\u0120impressed": 12617, "rup": 12618, "\u0120anch": 12619, "\u0120Adams": 12620, "Hel": 12621, "\u0120Victor": 12622, "\u0120mounted": 12623, "\u0120CC": 12624, "\u0120delicious": 12625, "span": 12626, "ella": 12627, "\u0120elabor": 12628, "amples": 12629, "\u0120defic": 12630, "\u0120constitu": 12631, "uates": 12632, "\u0120Mission": 12633, "\u0120Ther": 12634, "\u0120Monster": 12635, "bes": 12636, "Reuters": 12637, "\u0120Indones": 12638, "hill": 12639, "munition": 12640, "\u0120confirmation": 12641, "\u0120Consider": 12642, "acent": 12643, "\u0120jet": 12644, "\u0120Employ": 12645, "\u0120GTX": 12646, "nan": 12647, "\u0120Spider": 12648, "\u0120processor": 12649, "\u0120patri": 12650, "\u0120Pentagon": 12651, "\u0120Robinson": 12652, "\u0120realistic": 12653, "\u00c3\u00b1": 12654, "\u0120appearing": 12655, "\u0120pipe": 12656, "omed": 12657, "\u0120fru": 12658, "\u0120awful": 12659, "\u0120evaluation": 12660, "\u0120intelligent": 12661, "\u0120Citiz": 12662, "\u0120fundra": 12663, "odium": 12664, "\u0120tweets": 12665, "\u0120worn": 12666, "pring": 12667, "\u0120kidn": 12668, "\u0120rebels": 12669, "\u0120Kam": 12670, "\u0120Netherlands": 12671, "\u0120SW": 12672, "\u0120acquisition": 12673, "\u0120Male": 12674, "\u00e3\u0125\u00aa": 12675, "ombies": 12676, "\u0120tradem": 12677, "\u0120Status": 12678, "Bre": 12679, "\u0120THIS": 12680, "\u0120adverse": 12681, "\u0120NEW": 12682, "sign": 12683, "\u0120organisation": 12684, "enc": 12685, "\u0120Harper": 12686, "apor": 12687, "\u0120Members": 12688, "\u0120Peace": 12689, "\u0120Airport": 12690, "\u0120Others": 12691, "\u0120scratch": 12692, "\u0120Pil": 12693, "\u0120sensor": 12694, "\u0120adoption": 12695, "\u0120Hotel": 12696, "\u0120Drag": 12697, "\u0120honestly": 12698, "\u0120yard": 12699, "\u0120Forces": 12700, "\u0120patent": 12701, "\u0120bass": 12702, "\u0120quietly": 12703, "\u0120breathing": 12704, "\u0120pose": 12705, "iors": 12706, "\u0120Jess": 12707, "static": 12708, "ITE": 12709, "Offic": 12710, "\u0120jew": 12711, "wcs": 12712, "\u0120140": 12713, "\u0120preview": 12714, "ippi": 12715, "\u0120unfortunately": 12716, "okemon": 12717, "\u0120horn": 12718, "\u0120reass": 12719, "\u0120peer": 12720, "ocker": 12721, "\u0120unto": 12722, "\u0120Gray": 12723, "\u0120cleaning": 12724, "\u0120attracted": 12725, "2007": 12726, "Point": 12727, "kill": 12728, "\u0120Agreement": 12729, "urches": 12730, "\u0120horr": 12731, "\u0120Mississ": 12732, "\u0120worthy": 12733, "\u0120flowers": 12734, "town": 12735, "dll": 12736, "\u0120reactions": 12737, "\u0120dece": 12738, "\u0120indicating": 12739, "MD": 12740, "\u0120preference": 12741, "\u0120MVP": 12742, "essional": 12743, "\u0120Target": 12744, "gence": 12745, "\u0120Indians": 12746, "\u0120misc": 12747, "\u0120freely": 12748, "\u0120muscles": 12749, "\u0120lineup": 12750, "\u0120impacts": 12751, "ousing": 12752, "omi": 12753, "acular": 12754, "\u0120controlling": 12755, "agine": 12756, "cery": 12757, "hell": 12758, "\u0120ranking": 12759, "\u0120Nich": 12760, "\u0120Ave": 12761, "128": 12762, "\u0120highway": 12763, "\u0120incons": 12764, "\u0120binding": 12765, "\u0120struggles": 12766, "\u0120Pittsburgh": 12767, "\u0120gray": 12768, "rin": 12769, "\u0120comics": 12770, "\u0120Sport": 12771, "\u0120relatives": 12772, "\u0120fright": 12773, "\u0120probe": 12774, "\u0120Portug": 12775, "\u0120voc": 12776, "\u0120tu": 12777, "\u0120Corps": 12778, "\u0120possibilities": 12779, "\u0120qualify": 12780, "wcsstore": 12781, "\u0120libraries": 12782, "\u0120migrants": 12783, "\u0120entries": 12784, "\u0120consecutive": 12785, "vals": 12786, "\u0120Chairman": 12787, "\u0120hill": 12788, "IME": 12789, "\u0120Gard": 12790, "\u0120inequality": 12791, "fox": 12792, "\u0120Save": 12793, "\u0120cort": 12794, "claimed": 12795, "\u0120traits": 12796, "\u0120pour": 12797, "\u0120missiles": 12798, "\u0120essence": 12799, "\u0120sends": 12800, "\u0120alliance": 12801, "\u0120wishes": 12802, "\u0120Christopher": 12803, "Big": 12804, "NY": 12805, "\u0120Jacob": 12806, "san": 12807, "urred": 12808, "\u0120SO": 12809, "lly": 12810, "\u0120advocate": 12811, "\u0120Bond": 12812, "\u0120\"/": 12813, "Using": 12814, "\u0120districts": 12815, "\u0120Gate": 12816, "\u0120Bir": 12817, "ridge": 12818, "\u0120Naz": 12819, "\u0120Rs": 12820, "boards": 12821, "\u0120Ga": 12822, "\u0120Reagan": 12823, "\u0120influenced": 12824, "1000": 12825, "apy": 12826, "\u0120challenged": 12827, "\u0120barg": 12828, "\u0120faculty": 12829, "\u0120Fif": 12830, "\u0120acquire": 12831, "Ac": 12832, "\u0120insect": 12833, "\u0120instruments": 12834, "\u0120leaf": 12835, "thodox": 12836, "Message": 12837, "\u0120tale": 12838, "\u0120thereby": 12839, "\u0120trap": 12840, "\u0120strongest": 12841, "\u0120Military": 12842, "isible": 12843, "\u01201984": 12844, "etheless": 12845, "\u0120flexible": 12846, "\u0120kills": 12847, "\u0120finishing": 12848, "\u0120Size": 12849, "\u0120reduces": 12850, "\u0120epid": 12851, "\u0120orientation": 12852, "full": 12853, "\u0120trace": 12854, "\u0120laser": 12855, "\u0120oppose": 12856, "\u0120editing": 12857, "\u0120momentum": 12858, "\u00e4\u00ba": 12859, "show": 12860, "VI": 12861, "\u0120Lad": 12862, "\u01201985": 12863, "\u0120murdered": 12864, "900": 12865, "uther": 12866, "\u0120probability": 12867, "\u0120Poll": 12868, "\u0120reluct": 12869, "\u0120Chem": 12870, "\u0120Montreal": 12871, "\u0120adequate": 12872, "\u0120Poland": 12873, "\u0120Sheriff": 12874, "umph": 12875, "\u0120ok": 12876, "\u0120000": 12877, "\u0120\"[": 12878, "\u0120operators": 12879, "\u0120Fer": 12880, "\u0120modes": 12881, "\u0120Eve": 12882, "\u0120discipline": 12883, "NET": 12884, "Hand": 12885, "\u0120oral": 12886, "\u0120WE": 12887, "email": 12888, "JP": 12889, "\u0120Palestinians": 12890, "\u0120hence": 12891, "\u0120Less": 12892, "\u0120overl": 12893, "dig": 12894, "\u0120intimid": 12895, "\u0120Coal": 12896, "\u0120ranging": 12897, "tha": 12898, "\u0120distant": 12899, "\u0120fib": 12900, "\u0120Index": 12901, "\u0120Wonder": 12902, "\u0120Pel": 12903, "hattan": 12904, "\u0120Hug": 12905, "\u00c3\u0139": 12906, "rait": 12907, "\u0120wrapped": 12908, "\u0120RPG": 12909, "\u0120chemicals": 12910, "\u0120Money": 12911, "\u0120frozen": 12912, "\u0120indirect": 12913, "\u0120Against": 12914, "End": 12915, "\u0120uncomfortable": 12916, "\u0120Gallery": 12917, "\u0120Posted": 12918, "\u00d8\u00a7": 12919, "onduct": 12920, "\u0120consequence": 12921, "\u0120bitter": 12922, "\u01201987": 12923, "pop": 12924, "\u0120countless": 12925, "\u0120Alaska": 12926, "ffff": 12927, "\u0120departure": 12928, "\u0120refund": 12929, "\u0120Ian": 12930, "iated": 12931, "\u0120seeks": 12932, "\u0120mechanics": 12933, "\u0120jurisdiction": 12934, "lynn": 12935, "\u0120alike": 12936, "\u0120Hunt": 12937, "athon": 12938, "\u0120resolved": 12939, "\u0120cache": 12940, "\u0120distinction": 12941, "direct": 12942, "\u0120encount": 12943, "oub": 12944, "beat": 12945, "\u0120Country": 12946, "search": 12947, "\u0120continuous": 12948, "\u0120modest": 12949, "\u0120Rail": 12950, "thood": 12951, "130": 12952, "BUG": 12953, "\u0120criminals": 12954, "\u0120indication": 12955, "\u0120encountered": 12956, "last": 12957, "\u0120Wy": 12958, "\u0120ideology": 12959, "\u0120PDF": 12960, "security": 12961, "])": 12962, "\u0120Jimmy": 12963, "\u0120EN": 12964, "\u0120hiring": 12965, "Tem": 12966, "\u0120pig": 12967, "aunt": 12968, "\u0120Crystal": 12969, "\u0120penalties": 12970, "\u0120capability": 12971, "\u0120py": 12972, "\u0120productive": 12973, "\u0120balanced": 12974, "\u0120GeForce": 12975, "click": 12976, "olitan": 12977, "ods": 12978, "\u0120afterwards": 12979, "\u0120playoffs": 12980, "\u0120Gill": 12981, "User": 12982, "\u0120backs": 12983, "pub": 12984, "tag": 12985, "\u0120absurd": 12986, "piring": 12987, "\u0120citing": 12988, "\u0120trillion": 12989, "\u0120obligation": 12990, "\u0120maxim": 12991, "ahoo": 12992, "cf": 12993, "umi": 12994, "\u0120Alpha": 12995, "\u0120Nelson": 12996, "\u0120pursuant": 12997, "initely": 12998, "\u0120fract": 12999, "entry": 13000, "bery": 13001, "\u0120Thor": 13002, "Added": 13003, "\u0120DJ": 13004, "\u0120Gene": 13005, "\u0120awkward": 13006, "Stud": 13007, "\u0120wallet": 13008, "\u0120Divine": 13009, "arios": 13010, "\u0120releasing": 13011, "\u0120edited": 13012, "\u0120accomplished": 13013, "Best": 13014, "\u0120edges": 13015, "\u0120planes": 13016, "\u0120feeding": 13017, "\"},\"": 13018, "\u0120disclosure": 13019, "\u0120grain": 13020, "airy": 13021, "oons": 13022, "ernand": 13023, "VR": 13024, "\u0120reasonably": 13025, "\u0120drum": 13026, "\u0120partial": 13027, "\u0120graphic": 13028, "\u0120unprecedented": 13029, "\u0120advised": 13030, "Micro": 13031, "\u0120Assad": 13032, "points": 13033, "scar": 13034, "\u0120Zone": 13035, "ttes": 13036, "\u0120700": 13037, "vo": 13038, "\u0120Hamp": 13039, "\u0120fixes": 13040, "\u0120caution": 13041, "\u0120strings": 13042, "\u0120panels": 13043, "\u0120leak": 13044, "\u0120pricing": 13045, "rowth": 13046, "\u0120Error": 13047, "\u0120Saints": 13048, "fix": 13049, "\u0120observations": 13050, "\u0120Abs": 13051, "\u0120suggestion": 13052, "\u0120Ukrainian": 13053, "\u0120barrier": 13054, "\u0120painted": 13055, "Bet": 13056, "imir": 13057, "\u0120Spect": 13058, "pot": 13059, "orneys": 13060, "\u0120compound": 13061, "\u0120bears": 13062, "\u0120Rush": 13063, "\u0120luxury": 13064, "Sum": 13065, "\u0120orbit": 13066, "\u0120Marc": 13067, "\u0120exempt": 13068, "\u0120Trail": 13069, "\u0120MO": 13070, "\u0120Hans": 13071, "\u0120Weapon": 13072, "ocused": 13073, "uminum": 13074, "\u0120Jerry": 13075, "\u0120bust": 13076, "\u0120AG": 13077, "\u0120Wiki": 13078, "\u0120endless": 13079, "\u0120Vlad": 13080, "\u0120Bah": 13081, "\u0120Radeon": 13082, "keys": 13083, "\u0120Survey": 13084, "\u0120Viol": 13085, "define": 13086, "lean": 13087, "\u0120commod": 13088, "\u0120revenues": 13089, "\u00c5\u012f": 13090, "\u0120furniture": 13091, "\u0120casting": 13092, "\u0120diplomatic": 13093, "\u0120Players": 13094, "\u0120Killed": 13095, "\u0120modify": 13096, "\u0120innovative": 13097, "\u0120Abu": 13098, "nor": 13099, "\u0120bonds": 13100, "\u0120coaching": 13101, "Mer": 13102, "\u0120modules": 13103, "\u0120Patriots": 13104, "\u0120enhanced": 13105, "\u0120proceedings": 13106, "\u0120teammates": 13107, "\u0120128": 13108, "ardo": 13109, "\u0120compromise": 13110, "\u0120Much": 13111, "\u0120flew": 13112, "\u0120Edge": 13113, "\u0120unnecessary": 13114, "\u0120doctrine": 13115, "report": 13116, "\u0120Orlando": 13117, "\u0120Profile": 13118, "\u0120playoff": 13119, "friendly": 13120, "\u0120complain": 13121, "\u0120MC": 13122, "\u0120Opt": 13123, "\u0120GB": 13124, "\u0120beaten": 13125, "\u0120golf": 13126, "\u0120placement": 13127, "Bit": 13128, "\u0120newsletter": 13129, "\u01202019": 13130, "visor": 13131, "rawl": 13132, "\u0120iPad": 13133, "\u0120acted": 13134, "\u0120juice": 13135, "\u0120decks": 13136, "PN": 13137, "success": 13138, "\u0120Half": 13139, "\u0120deleted": 13140, "\u0120secrets": 13141, "\u0120asylum": 13142, "Mart": 13143, "\u0120Activ": 13144, "\u0120Guy": 13145, "\u0120Ts": 13146, "\u0120dys": 13147, "\u0120assuming": 13148, "\u0120mana": 13149, "\u0120subur": 13150, "\u0120125": 13151, "Media": 13152, "ARY": 13153, "ride": 13154, "cp": 13155, "\u0120difficulties": 13156, "\u0120collecting": 13157, "\u0120bankrupt": 13158, "non": 13159, "\u0120composed": 13160, "\u0120volt": 13161, "\u0120militants": 13162, "\u0120>>>": 13163, "\u0120Mormon": 13164, "tor": 13165, "\u0120particles": 13166, "\u0120Bart": 13167, "ryption": 13168, "\u0120admin": 13169, "\u0120squee": 13170, "VIDIA": 13171, "\u0120creator": 13172, "iameter": 13173, "icular": 13174, "NBC": 13175, "\u0120grabbed": 13176, "\u0120nodd": 13177, "\u0120rated": 13178, "\u0120rotation": 13179, "\u0120grasp": 13180, "\u0120excessive": 13181, "\u0120EC": 13182, "\u0120Whit": 13183, "\u0120inventory": 13184, "aults": 13185, "\u0120FB": 13186, "\u0120ecosystem": 13187, "\u0120billions": 13188, "\u0120venture": 13189, "named": 13190, "\u0120defender": 13191, "oute": 13192, "Instead": 13193, "irable": 13194, "War": 13195, "\u0120assumption": 13196, "\u0120bite": 13197, "\u0120earthqu": 13198, "tail": 13199, "space": 13200, "\u0120gifts": 13201, "boys": 13202, "\u0120inevitable": 13203, "\u0120structural": 13204, "\u0120beneficial": 13205, "\u0120compelling": 13206, "hole": 13207, "ervation": 13208, "\u0120coat": 13209, "oj": 13210, "incarn": 13211, "\u0120Years": 13212, "\u0120determining": 13213, "\u0120rhetoric": 13214, "\u0120boundaries": 13215, "\u0120whites": 13216, "Ant": 13217, "addy": 13218, ")-": 13219, "raham": 13220, "etermin": 13221, "\u0120harvest": 13222, "\u0120Conc": 13223, "\u0120laptop": 13224, "\u0120Match": 13225, "\u0120enjoying": 13226, "cca": 13227, "ollar": 13228, "\u0120trips": 13229, "\u0120addiction": 13230, "\u0120Sak": 13231, "\u0120powered": 13232, "\u0120cous": 13233, "\u0120Russians": 13234, "iere": 13235, "\u0120retrie": 13236, "quality": 13237, "\u0120differ": 13238, "\u0120kingdom": 13239, "\u0120Laur": 13240, "\u0120Capitol": 13241, "\u0120conclusions": 13242, "\u0120Altern": 13243, "\u0120Nav": 13244, "\u0120transparent": 13245, "BER": 13246, "Group": 13247, "\u0120Complete": 13248, "\u0120infer": 13249, "\u0120intrig": 13250, "\u0120insane": 13251, "RO": 13252, "ophob": 13253, "isen": 13254, "qual": 13255, "Michael": 13256, "\u0120museum": 13257, "\u0120Pope": 13258, "\u0120reset": 13259, "rative": 13260, "five": 13261, "\u0120aggreg": 13262, "ittees": 13263, "ository": 13264, "\u0120carb": 13265, "\u0120Record": 13266, "\u0120decides": 13267, "\u0120Fix": 13268, "\u0120exceptions": 13269, "\u0120Commissioner": 13270, "uns": 13271, "\u0120Environmental": 13272, "\u0120legendary": 13273, "istence": 13274, "\u0120tunnel": 13275, "km": 13276, "\u0120insult": 13277, "\u0120troll": 13278, "\u0120shake": 13279, "\u0120detention": 13280, "ques": 13281, "\u0120Chrome": 13282, "\u0120Files": 13283, "\u0120subt": 13284, "\u0120prospects": 13285, "\u0120prol": 13286, "render": 13287, "proof": 13288, "\u0120performances": 13289, "Str": 13290, "\u0120href": 13291, "ername": 13292, "\u0120achievement": 13293, "\u0120fut": 13294, "Full": 13295, "\u0120Leban": 13296, "google": 13297, "\u00e3\u0125\u012a": 13298, "ampa": 13299, "Maybe": 13300, "\u0120projected": 13301, "\u0120Emb": 13302, "\u0120colleg": 13303, "\u0120awards": 13304, "\u0120\u00e2\u0136": 13305, "Gold": 13306, "\u0120Blake": 13307, "\u0120Raj": 13308, "ifting": 13309, "\u0120pending": 13310, "\u0120instinct": 13311, "\u0120developments": 13312, "Connect": 13313, "\u0120Mand": 13314, "\u0120WITH": 13315, "\u0120Philippines": 13316, "profile": 13317, "\u0120altogether": 13318, "\u0120Bund": 13319, "\u0120TD": 13320, "oooo": 13321, "amped": 13322, "iph": 13323, "\u0120steam": 13324, "\u0120oldest": 13325, "\u0120detection": 13326, "ulpt": 13327, "\u0120\u00e7": 13328, "\u0120Wayne": 13329, "2006": 13330, "fa": 13331, "\u0120circles": 13332, "\u0120Fu": 13333, "\u0120donors": 13334, "appropriate": 13335, "\u0120Dakota": 13336, "jamin": 13337, "\u0120motivated": 13338, "\u0120purchases": 13339, "\u0120Louisiana": 13340, "\u0120Spl": 13341, "\u0120globe": 13342, "\u0120105": 13343, "zip": 13344, "call": 13345, "\u0120departments": 13346, "\u0120sustainable": 13347, "105": 13348, "\u0120OP": 13349, "ifiers": 13350, "\u0120prevented": 13351, "\u0120incomp": 13352, "\u0120Commander": 13353, "\u0120dominated": 13354, "\u0120\u00c2\u00bb": 13355, "\u0120invested": 13356, "\u0120complexity": 13357, "\u0120incl": 13358, "\u0120ensuring": 13359, "\u0120realm": 13360, "ync": 13361, "\u0120Independent": 13362, "rained": 13363, "\u0120Jen": 13364, "\u0120Flight": 13365, "\u0120athe": 13366, "\u0120speculation": 13367, "\u0120TE": 13368, "ocate": 13369, "tic": 13370, "\u0120plaint": 13371, "herry": 13372, "\u0120toy": 13373, "\u0120111": 13374, "\u0120plates": 13375, "status": 13376, "\u0120Isa": 13377, "\u0120devoted": 13378, "Cop": 13379, "\u0120ES": 13380, "255": 13381, "urrency": 13382, "Main": 13383, "\u0120slaves": 13384, "\u0120pepper": 13385, "\u0120quotes": 13386, "\u0120ceiling": 13387, "\u0120Fish": 13388, "\u0120transformation": 13389, "\u0120fraction": 13390, "\u0120advantages": 13391, "\u0120toile": 13392, "\u0120stunning": 13393, "\u0120moist": 13394, "breaking": 13395, "si": 13396, "\u0120Location": 13397, "\u0120Medium": 13398, "\u0120texts": 13399, "\u0120ugly": 13400, "\u0120bio": 13401, ".\u00e2\u0122\u0136": 13402, "\u0120Based": 13403, "\u0120trains": 13404, "\u0120Wing": 13405, "\u0120Ancient": 13406, "\u0120Records": 13407, "\u0120Hope": 13408, "Special": 13409, "adesh": 13410, "obi": 13411, "[/": 13412, "\u0120temporarily": 13413, "Ver": 13414, "hu": 13415, "oser": 13416, "\u0120overnight": 13417, "\u0120mamm": 13418, "\u0120Treasury": 13419, "\u0120Venezuel": 13420, "\u0120Mega": 13421, "\u0120tar": 13422, "\u0120expects": 13423, "black": 13424, "orph": 13425, "\\\\\\\\": 13426, "\u0120acceptance": 13427, "\u0120radar": 13428, "sis": 13429, "\u0120junior": 13430, "\u0120frames": 13431, "\u0120observation": 13432, "acies": 13433, "Power": 13434, "\u0120Advanced": 13435, "Mag": 13436, "ologically": 13437, "\u0120Mechan": 13438, "\u0120sentences": 13439, "\u0120analysts": 13440, "aughters": 13441, "forcement": 13442, "\u0120vague": 13443, "\u0120clause": 13444, "\u0120directors": 13445, "\u0120evaluate": 13446, "\u0120cabinet": 13447, "Matt": 13448, "\u0120Classic": 13449, "Ang": 13450, "\u0120cler": 13451, "\u0120Buck": 13452, "\u0120researcher": 13453, "\u0120160": 13454, "\u0120poorly": 13455, "\u0120experiencing": 13456, "\u0120Ped": 13457, "\u0120Manhattan": 13458, "\u0120freed": 13459, "\u0120themes": 13460, "advant": 13461, "\u0120nin": 13462, "\u0120praise": 13463, "104": 13464, "\u0120Libya": 13465, "best": 13466, "\u0120trusted": 13467, "\u0120cease": 13468, "\u0120dign": 13469, "Direct": 13470, "\u0120bombing": 13471, "\u0120migration": 13472, "\u0120Sciences": 13473, "\u0120municipal": 13474, "\u0120Average": 13475, "\u0120glory": 13476, "\u0120revealing": 13477, "\u0120arena": 13478, "\u0120uncertainty": 13479, "\u0120battlefield": 13480, "iao": 13481, "God": 13482, "\u0120cinem": 13483, "rape": 13484, "elle": 13485, "apons": 13486, "\u0120listing": 13487, "\u0120waited": 13488, "\u0120spotted": 13489, "keley": 13490, "\u0120Audio": 13491, "eor": 13492, "arding": 13493, "idding": 13494, "igma": 13495, "\u0120Neg": 13496, "\u0120lone": 13497, "\u0120----": 13498, "exe": 13499, "deg": 13500, "\u0120transf": 13501, "\u0120wash": 13502, "\u0120slavery": 13503, "\u0120exploring": 13504, "\u0120WW": 13505, "atson": 13506, "\u0120encl": 13507, "lies": 13508, "\u0120Creek": 13509, "\u0120wooden": 13510, "Manager": 13511, "\u0120Brand": 13512, "ummy": 13513, "\u0120Arthur": 13514, "\u0120bureaucr": 13515, "\u0120blend": 13516, "arians": 13517, "Further": 13518, "\u0120supposedly": 13519, "\u0120winds": 13520, "\u01201979": 13521, "\u0120gravity": 13522, "\u0120analyses": 13523, "\u0120Travel": 13524, "\u0120Veter": 13525, "\u0120dumb": 13526, "\u0120alternate": 13527, "gal": 13528, "\u0120consumed": 13529, "\u0120effectiveness": 13530, ".''": 13531, "\u0120paths": 13532, "onda": 13533, "LA": 13534, "\u0120Strong": 13535, "\u0120enables": 13536, "\u0120escaped": 13537, "\u0120\"\"": 13538, "\u0120112": 13539, "\u01201983": 13540, "\u0120smiled": 13541, "\u0120tendency": 13542, "Fire": 13543, "\u0120pars": 13544, "\u0120Roc": 13545, "\u0120lake": 13546, "\u0120fitness": 13547, "\u0120Ath": 13548, "\u0120Horn": 13549, "\u0120hier": 13550, "\u0120impose": 13551, "mother": 13552, "\u0120pension": 13553, "icut": 13554, "borne": 13555, "iciary": 13556, "._": 13557, "\u0120SU": 13558, "\u0120polar": 13559, "isy": 13560, "engu": 13561, "itialized": 13562, "ATA": 13563, "write": 13564, "\u0120exercises": 13565, "\u0120Diamond": 13566, "otypes": 13567, "\u0120harmful": 13568, "onz": 13569, "\u0120printing": 13570, "story": 13571, "\u0120expertise": 13572, "\u0120Ger": 13573, "\u0120tragedy": 13574, "\u0120Fly": 13575, "\u0120divid": 13576, "ampire": 13577, "stock": 13578, "Mem": 13579, "\u0120reign": 13580, "\u0120unve": 13581, "\u0120amend": 13582, "\u0120Prophet": 13583, "\u0120mutual": 13584, "\u0120Fac": 13585, "\u0120replacing": 13586, "Har": 13587, "\u0120Circuit": 13588, "\u0120throat": 13589, "\u0120Shot": 13590, "\u0120batteries": 13591, "\u0120toll": 13592, "\u0120addressing": 13593, "\u0120Medicaid": 13594, "\u0120pupp": 13595, "\u0120Nar": 13596, "olk": 13597, "\u0120equity": 13598, "MR": 13599, "\u0120Hispan": 13600, "\u0120Large": 13601, "mid": 13602, "Dev": 13603, "\u0120exped": 13604, "\u0120demo": 13605, "\u0120Marshall": 13606, "ergus": 13607, "\u0120fiber": 13608, "\u0120divorce": 13609, "\u0120Create": 13610, "\u0120slower": 13611, "\u0120Parker": 13612, "\u0120Student": 13613, "\u0120Training": 13614, "Return": 13615, "\u0120Tru": 13616, "\u0120cub": 13617, "\u0120Reached": 13618, "\u0120panic": 13619, "\u0120quarters": 13620, "\u0120rect": 13621, "\u0120treating": 13622, "\u0120rats": 13623, "\u0120Christianity": 13624, "oler": 13625, "\u0120sacred": 13626, "\u0120declare": 13627, "ulative": 13628, "eting": 13629, "\u0120delivering": 13630, "estone": 13631, "\u0120tel": 13632, "\u0120Larry": 13633, "\u0120meta": 13634, "accept": 13635, "artz": 13636, "\u0120Roger": 13637, "handed": 13638, "\u0120header": 13639, "\u0120trapped": 13640, "\u0120Century": 13641, "\u0120knocked": 13642, "\u0120Oxford": 13643, "\u0120survivors": 13644, "bot": 13645, "\u0120demonstration": 13646, "\u0120dirt": 13647, "\u0120assists": 13648, "OME": 13649, "\u0120Draft": 13650, "ortunate": 13651, "folio": 13652, "pered": 13653, "usters": 13654, "gt": 13655, "\u0120Lock": 13656, "\u0120judicial": 13657, "verted": 13658, "\u0120secured": 13659, "outing": 13660, "\u0120Books": 13661, "\u0120hosting": 13662, "\u0120lifted": 13663, "length": 13664, "\u0120jer": 13665, "\u0120wheels": 13666, "\u0120Range": 13667, "umbnails": 13668, "\u0120diagnosis": 13669, "tech": 13670, "\u0120Stewart": 13671, "\u0120Pract": 13672, "\u0120nationwide": 13673, "\u0120dear": 13674, "\u0120obligations": 13675, "\u0120grows": 13676, "\u0120mandatory": 13677, "\u0120suspicious": 13678, "!'": 13679, "Apr": 13680, "Great": 13681, "\u0120mortgage": 13682, "\u0120prosecutor": 13683, "\u0120editorial": 13684, "\u0120Kr": 13685, "\u0120processed": 13686, "ungle": 13687, "\u0120flexibility": 13688, "Earlier": 13689, "\u0120Cart": 13690, "\u0120Sug": 13691, "\u0120focuses": 13692, "\u0120startup": 13693, "\u0120breach": 13694, "\u0120Tob": 13695, "cycle": 13696, "\u00e3\u0122\u012e": 13697, "rose": 13698, "\u0120bizarre": 13699, "\u00e3\u0122\u012f": 13700, "\u0120vegetables": 13701, "$$": 13702, "\u0120retreat": 13703, "oshi": 13704, "\u0120Shop": 13705, "\u0120Ground": 13706, "\u0120Stop": 13707, "\u0120Hawaii": 13708, "\u0120Ay": 13709, "Perhaps": 13710, "\u0120Beaut": 13711, "uffer": 13712, "enna": 13713, "\u0120productivity": 13714, "Fixed": 13715, "control": 13716, "\u0120absent": 13717, "\u0120Campaign": 13718, "Green": 13719, "\u0120identifying": 13720, "\u0120regret": 13721, "\u0120promoted": 13722, "\u0120Seven": 13723, "\u0120eru": 13724, "neath": 13725, "aughed": 13726, "\u0120Pin": 13727, "\u0120Living": 13728, "Cost": 13729, "omatic": 13730, "mega": 13731, "\u0120Nig": 13732, "ocy": 13733, "\u0120inbox": 13734, "\u0120empire": 13735, "\u0120horizont": 13736, "\u0120branches": 13737, "\u0120metaph": 13738, "Active": 13739, "edi": 13740, "\u0120Film": 13741, "\u0120Something": 13742, "\u0120mods": 13743, "incial": 13744, "\u0120Original": 13745, "Gen": 13746, "\u0120spirits": 13747, "\u0120earning": 13748, "Hist": 13749, "\u0120riders": 13750, "\u0120sacrific": 13751, "MT": 13752, "\u0120VA": 13753, "\u0120Salt": 13754, "\u0120occupation": 13755, "\u0120Mi": 13756, "\u0120disg": 13757, "lict": 13758, "\u0120nit": 13759, "\u0120nodes": 13760, "eem": 13761, "\u0120Pier": 13762, "\u0120hatred": 13763, "psy": 13764, "\u00e3\u0125\u012b": 13765, "\u0120theater": 13766, "\u0120sophisticated": 13767, "\u0120defended": 13768, "\u0120besides": 13769, "\u0120thoroughly": 13770, "\u0120Medicare": 13771, "\u0120blamed": 13772, "arently": 13773, "\u0120crying": 13774, "FOR": 13775, "priv": 13776, "\u0120singing": 13777, "\u0120Il": 13778, "\u0120cute": 13779, "oided": 13780, "olitical": 13781, "\u0120Neuro": 13782, "\u00e5\u00a4": 13783, "\u0120donation": 13784, "\u0120Eagles": 13785, "\u0120Give": 13786, "Tom": 13787, "\u0120substantially": 13788, "\u0120License": 13789, "\u0120Ja": 13790, "\u0120grey": 13791, "\u0120Animal": 13792, "\u0120ER": 13793, "\u0120Und": 13794, "\u0120keen": 13795, "\u0120conclude": 13796, "\u0120Mississippi": 13797, "Engine": 13798, "\u0120Studios": 13799, "Press": 13800, "overs": 13801, "llers": 13802, "\u0120350": 13803, "\u0120Rangers": 13804, "\u0120rou": 13805, "erto": 13806, "Ep": 13807, "issa": 13808, "ivan": 13809, "\u0120seal": 13810, "\u0120Regist": 13811, "display": 13812, "\u0120weaken": 13813, "uum": 13814, "\u0120Commons": 13815, "\u0120Say": 13816, "\u0120cultures": 13817, "\u0120laughed": 13818, "\u0120slip": 13819, "\u0120treatments": 13820, "izable": 13821, "mart": 13822, "\u0120Rice": 13823, "\u0120beast": 13824, "\u0120obesity": 13825, "\u0120Laure": 13826, "iga": 13827, "Which": 13828, "holder": 13829, "\u0120elderly": 13830, "\u0120pays": 13831, "\u0120complained": 13832, "\u0120crop": 13833, "\u0120proc": 13834, "\u0120explosive": 13835, "\u0120Fan": 13836, "\u0120Arsenal": 13837, "Author": 13838, "eful": 13839, "\u0120meals": 13840, "\u0120(-": 13841, "idays": 13842, "\u0120imagination": 13843, "\u0120annually": 13844, "\u0120ms": 13845, "asures": 13846, "Head": 13847, "ikh": 13848, "matic": 13849, "\u0120boyfriend": 13850, "\u0120Computer": 13851, "\u0120bump": 13852, "\u0120surge": 13853, "\u0120Craig": 13854, "\u0120Kirk": 13855, "Del": 13856, "mediate": 13857, "\u0120scenarios": 13858, "\u0120Mut": 13859, "\u0120Stream": 13860, "\u0120competitors": 13861, "\u00d9\u0126": 13862, "\u0120Stanford": 13863, "\u0120Resources": 13864, "azed": 13865, "bage": 13866, "\u0120organis": 13867, "\u0120Release": 13868, "\u0120separately": 13869, "\u0120habits": 13870, "\u0120measurements": 13871, "\u0120Close": 13872, "\u0120accompany": 13873, "\u0120gly": 13874, "\u0120tang": 13875, "\u0120Rou": 13876, "\u0120plugin": 13877, "\u0120convey": 13878, "\u0120Challenge": 13879, "oots": 13880, "jan": 13881, "\u0120curs": 13882, "\u0120Relations": 13883, "keeper": 13884, "\u0120approaching": 13885, "ping": 13886, "Speaking": 13887, "\u0120arrangement": 13888, "\u0120VI": 13889, "arettes": 13890, "\u0120affecting": 13891, "\u0120permits": 13892, "because": 13893, "\u0120useless": 13894, "\u0120Hus": 13895, "!!!!": 13896, "\u0120destroying": 13897, "Unfortunately": 13898, "\u0120fascinating": 13899, "Sem": 13900, "\u0120electoral": 13901, "\u0120transparency": 13902, "\u0120Chaos": 13903, "\u0120volunteer": 13904, "\u0120statistical": 13905, "\u0120activated": 13906, "rox": 13907, "Web": 13908, "HE": 13909, "\u0120Hampshire": 13910, "isive": 13911, "Map": 13912, "\u0120trash": 13913, "\u0120Lawrence": 13914, "stick": 13915, "Cr": 13916, "\u0120rings": 13917, "EXT": 13918, "\u0120operational": 13919, "opes": 13920, "Does": 13921, "\u0120Evans": 13922, "\u0120witnessed": 13923, "Port": 13924, "\u0120launching": 13925, "econom": 13926, "wear": 13927, "\u0120Particip": 13928, "umm": 13929, "cules": 13930, "\u0120RAM": 13931, "\u0120Tun": 13932, "\u0120assured": 13933, "\u0120binary": 13934, "\u0120betray": 13935, "\u0120exploration": 13936, "\u0120Fel": 13937, "\u0120admission": 13938, "itated": 13939, "Sy": 13940, "\u0120avoided": 13941, "\u0120Simulator": 13942, "\u0120celebrated": 13943, "\u0120Electric": 13944, "\u00a5\u0140": 13945, "\u0120cluster": 13946, "itzerland": 13947, "health": 13948, "Line": 13949, "\u0120Nash": 13950, "aton": 13951, "\u0120spare": 13952, "\u0120enterprise": 13953, "\u0120DIS": 13954, "cludes": 13955, "\u0120flights": 13956, "\u0120regards": 13957, "\u0120\u00c3\u0139": 13958, "half": 13959, "\u0120trucks": 13960, "\u0120contacts": 13961, "\u0120uncons": 13962, "\u0120Climate": 13963, "\u0120immense": 13964, "NEW": 13965, "occ": 13966, "ective": 13967, "\u0120embod": 13968, "\u0120patrol": 13969, "\u0120beside": 13970, "\u0120viable": 13971, "\u0120creep": 13972, "\u0120triggered": 13973, "verning": 13974, "\u0120comparable": 13975, "ql": 13976, "\u0120gaining": 13977, "asses": 13978, "\u0120();": 13979, "\u0120Grey": 13980, "\u0120MLS": 13981, "sized": 13982, "\u0120prosper": 13983, "\"?": 13984, "\u0120polling": 13985, "\u0120shar": 13986, "\u0120RC": 13987, "\u0120firearm": 13988, "orient": 13989, "\u0120fence": 13990, "\u0120variations": 13991, "giving": 13992, "\u0120Pi": 13993, "ospel": 13994, "\u0120pledge": 13995, "\u0120cure": 13996, "\u0120spy": 13997, "\u0120violated": 13998, "\u0120rushed": 13999, "\u0120stroke": 14000, "\u0120Blog": 14001, "sels": 14002, "\u0120Ec": 14003, ",''": 14004, "\u0120pale": 14005, "\u0120Collins": 14006, "terror": 14007, "\u0120Canadians": 14008, "\u0120tune": 14009, "\u0120laboratory": 14010, "\u0120nons": 14011, "tarian": 14012, "\u0120disability": 14013, "\u0120Gam": 14014, "\u0120singer": 14015, "alg": 14016, "\u0120Senior": 14017, "\u0120traded": 14018, "\u0120Warrior": 14019, "\u0120infring": 14020, "\u0120Franklin": 14021, "\u0120strain": 14022, "\u0120Swedish": 14023, "\u0120seventh": 14024, "\u0120Benn": 14025, "\u0120Tell": 14026, "\u0120syndrome": 14027, "\u0120wondered": 14028, "iden": 14029, "++++": 14030, "igo": 14031, "\u0120purple": 14032, "\u0120journalism": 14033, "\u0120rebel": 14034, "\u0120fu": 14035, "blog": 14036, "\u0120invite": 14037, "rencies": 14038, "\u0120Contact": 14039, "Israel": 14040, "\u0120Content": 14041, "\u0120cheer": 14042, "\u0120bedroom": 14043, "\u0120Engineering": 14044, "\u0120Queens": 14045, "\u0120dwell": 14046, "\u0120PlayStation": 14047, "\u0120Dim": 14048, "\u0120Colon": 14049, "lr": 14050, "\u0120operates": 14051, "\u0120motivation": 14052, "USA": 14053, "astered": 14054, "Core": 14055, "\u0120Truth": 14056, "olo": 14057, "OSE": 14058, "\u0120Memory": 14059, "\u0120predec": 14060, "\u0120anarch": 14061, "\u01201920": 14062, "\u0120Yam": 14063, "\u00c3\u00a8": 14064, "bid": 14065, "\u0120grateful": 14066, "\u0120excitement": 14067, "\u0120treasure": 14068, "\u0120longest": 14069, "ctive": 14070, "\u0120deserves": 14071, "\u0120reserves": 14072, "\u0120cops": 14073, "\u0120Ottawa": 14074, "\u0120Egyptian": 14075, "anked": 14076, "\u0120artif": 14077, "\u0120hypothesis": 14078, ":/": 14079, "\u0120purchasing": 14080, "\u0120lovely": 14081, "HP": 14082, "\u0120divide": 14083, "\u0120strictly": 14084, "\u0120questioning": 14085, "\u0120taxpayers": 14086, "\u0120Joy": 14087, "\u0120rolls": 14088, "\u0120Heavy": 14089, "\u0120ports": 14090, "\u0120magnetic": 14091, "\u0120inflamm": 14092, "\u0120brush": 14093, "tics": 14094, "\u00e2\u012a\u0134": 14095, "\u0120bottles": 14096, "ppy": 14097, "\u0120padd": 14098, "\u00e3\u0124\u00af": 14099, "million": 14100, "\u0120devastating": 14101, "\u0120compiled": 14102, "\u0120medication": 14103, "\u0120twelve": 14104, "\u0120Perry": 14105, "Space": 14106, "imb": 14107, "your": 14108, "\u0120leaked": 14109, "\u0120Tar": 14110, "\u0120unity": 14111, "\u0120infected": 14112, "\u0120traveled": 14113, "IDE": 14114, "\u0120McDonald": 14115, "txt": 14116, "\u0120Princ": 14117, "\u0120interven": 14118, "\u0120Taiwan": 14119, "\u0120Pow": 14120, "\u0120bearing": 14121, "\u0120Thread": 14122, "\u0120zones": 14123, "izards": 14124, "unks": 14125, "Chapter": 14126, "llor": 14127, "\u0120\u00c2\u00b7": 14128, "\u0120wounds": 14129, "\u0120discretion": 14130, "\u0120succeeded": 14131, "iking": 14132, "\u0120iconic": 14133, "Call": 14134, "\u0120screening": 14135, "\u0120Mis": 14136, "icts": 14137, "\u0120ministers": 14138, "\u0120separation": 14139, "Player": 14140, "\u0120bip": 14141, "\u0120beloved": 14142, "\u0120counting": 14143, "\u0120Eye": 14144, "around": 14145, "inging": 14146, "\u0120tablet": 14147, "\u0120offence": 14148, "inance": 14149, "have": 14150, "\u0120Info": 14151, "\u0120Ninja": 14152, "\u0120protective": 14153, "\u0120Cass": 14154, "Mac": 14155, "\u0120Quality": 14156, "North": 14157, "\u0120ic": 14158, "\u0120Cuba": 14159, "\u0120Chronicle": 14160, "\u0120Property": 14161, "\u0120fastest": 14162, "otos": 14163, "\u0120Germ": 14164, "OWN": 14165, "\u0120boom": 14166, "\u0120Stanley": 14167, "erguson": 14168, "\u0120clever": 14169, "\u0120enters": 14170, "mode": 14171, "terior": 14172, "\u0120Sens": 14173, "\u0120linear": 14174, "ARK": 14175, "\u0120comparing": 14176, "\u0120purely": 14177, "\u0120safer": 14178, "\u0120Potter": 14179, "\u0120cups": 14180, "RT": 14181, "\u0120gluc": 14182, "\u0120attributed": 14183, "\u0120dupl": 14184, "\u0120Pap": 14185, "\u0120precious": 14186, "\u0120pa": 14187, "ictionary": 14188, "\u0120Tig": 14189, "\u0120Too": 14190, "olutions": 14191, "stan": 14192, "\u0120robots": 14193, "\u0120lobb": 14194, "\u0120statute": 14195, "\u0120prevention": 14196, "western": 14197, "160": 14198, "\u0120Active": 14199, "\u0120Maria": 14200, "hal": 14201, "None": 14202, "ellar": 14203, "\u0120KB": 14204, "\u0120Partners": 14205, "\u0120Single": 14206, "\u0120Following": 14207, "ango": 14208, "acious": 14209, "\u0120thou": 14210, "\u0120kg": 14211, "\u0120influential": 14212, "\u0120Friends": 14213, "Sur": 14214, "ainted": 14215, "\u0120forums": 14216, "\u0120starter": 14217, "\u0120citizenship": 14218, "\u0120Election": 14219, "onge": 14220, "otation": 14221, "osph": 14222, ";;;;": 14223, "utical": 14224, "pur": 14225, "eren": 14226, "\u0120accusations": 14227, "bitious": 14228, "abbit": 14229, "\u0120Ord": 14230, "Posted": 14231, "irk": 14232, "\u0120sensitivity": 14233, "iche": 14234, "\u0120Amy": 14235, "\u0120Fab": 14236, "\u0120summit": 14237, "\u0120pedest": 14238, "\u0120rubber": 14239, "\u0120agricultural": 14240, "\u0120cancel": 14241, "AE": 14242, "\u0120inaug": 14243, "\u0120contam": 14244, "\u0120firmly": 14245, "iw": 14246, "stage": 14247, "\u0120Kan": 14248, "\u0120tier": 14249, "\u0120invention": 14250, "\u0120translated": 14251, "\u0120Rules": 14252, "Box": 14253, "Twitter": 14254, "IDS": 14255, "\u0120pizza": 14256, "\u0120debug": 14257, "\u0120Drop": 14258, "vs": 14259, "\u0120horses": 14260, "big": 14261, "\u0120boring": 14262, "\u0120hood": 14263, "\u0120McCain": 14264, "atched": 14265, "\u0120Bros": 14266, "\u0120skip": 14267, "\u0120essay": 14268, "stat": 14269, "\u0120Legends": 14270, "\u0120ammunition": 14271, "auc": 14272, "\u0120shooter": 14273, "\u0120unh": 14274, "\u0120supplied": 14275, "\u0120generic": 14276, "\u0120SK": 14277, "iban": 14278, "yrics": 14279, "\u0120255": 14280, "\u0120climbing": 14281, "Former": 14282, "\u0120flip": 14283, "\u0120jumping": 14284, "\u0120frustration": 14285, "\u0120Terry": 14286, "\u0120neighborhoods": 14287, "\u0120median": 14288, "bean": 14289, "\u0120brains": 14290, "Following": 14291, "\u0120shaped": 14292, "\u0120draws": 14293, "\u0120altered": 14294, "Jack": 14295, "\u0120recipes": 14296, "\u0120skilled": 14297, "wealth": 14298, "achi": 14299, "election": 14300, "\u0120behaviors": 14301, "deals": 14302, "\u0120Until": 14303, "Fe": 14304, "\u0120declaration": 14305, "marks": 14306, "\u0120Between": 14307, "celona": 14308, "\u0120reson": 14309, "\u0120bubble": 14310, "Among": 14311, "\u0120imperial": 14312, "GS": 14313, "\u0120feminist": 14314, "2005": 14315, "\u0120Kyle": 14316, "\u0120accounting": 14317, "\u0120Tele": 14318, "\u0120Tyr": 14319, "\u0120connecting": 14320, "\u0120rehab": 14321, "\u0120Pred": 14322, "sim": 14323, "\u0120meantime": 14324, "\u0120physician": 14325, "MW": 14326, "\u0120Campbell": 14327, "\u0120Brandon": 14328, "\u0120contributing": 14329, "\u0120Rule": 14330, "\u0120Weight": 14331, "\u0120Nap": 14332, "\u0120interactive": 14333, "\u0120vag": 14334, "\u0120helmet": 14335, "\u0120Comb": 14336, "four": 14337, "\u0120shipped": 14338, "\u0120completing": 14339, "\u0120PD": 14340, "PDATE": 14341, "\u0120spreading": 14342, "\u0120scary": 14343, "erving": 14344, "\u0120Gas": 14345, "\u0120frank": 14346, "school": 14347, "\u0120romantic": 14348, "\u0120stabil": 14349, "Rob": 14350, "\u0120accurately": 14351, "\u0120acute": 14352, "\u0120Hann": 14353, "\u0120symbols": 14354, "\u0120civilization": 14355, "\u0120AW": 14356, "\u0120lightning": 14357, "\u0120considers": 14358, "\u0120venue": 14359, "\u0120\u00d7": 14360, "\u0120oven": 14361, "\u0120SF": 14362, "his": 14363, "\u0120nu": 14364, "\u0120Learn": 14365, "\u0120peoples": 14366, "\u0120std": 14367, "\u0120slee": 14368, "\u0120slic": 14369, "\u0120Statistics": 14370, "\u0120corners": 14371, "\u0120Baker": 14372, "\u0120:)": 14373, "mentation": 14374, "olver": 14375, "\u0120laughing": 14376, "\u0120Todd": 14377, "onde": 14378, "\u0120Hills": 14379, "\u0120nuts": 14380, "\u0120Woman": 14381, "plane": 14382, "\u0120liver": 14383, "\u0120Inside": 14384, "Sorry": 14385, "\u0120agrees": 14386, "\u0120fundament": 14387, "\u0120Fisher": 14388, "\u0120auction": 14389, "\u0120threads": 14390, "glas": 14391, "\u0120Basic": 14392, "\u0120Nat": 14393, "\u0120lacking": 14394, "\u0120celebration": 14395, "ju": 14396, "\u0120silly": 14397, "Euro": 14398, "\u0120tatt": 14399, "ighty": 14400, "controlled": 14401, "Test": 14402, "\u0120Singh": 14403, "\u0120rage": 14404, "\u0120rhyth": 14405, "offic": 14406, "\u0120Phantom": 14407, "\u0120headlines": 14408, "\u0120responding": 14409, "\u0120Morning": 14410, "\u0120vitamin": 14411, "\u0120boots": 14412, "\u0120Site": 14413, "alin": 14414, "pi": 14415, "\u0120viral": 14416, "\u0120UC": 14417, "DER": 14418, "\u0120Sex": 14419, "\u0120stocks": 14420, "current": 14421, "\u0120churches": 14422, "\u0120Rare": 14423, "\u0120Murphy": 14424, "\u0120denial": 14425, "\u0120Gaming": 14426, "\u0120toug": 14427, "\u0120nick": 14428, "\u0120makers": 14429, "\u0120Ronald": 14430, "\u0120generous": 14431, "\u0120Doc": 14432, "\u0120Morris": 14433, "\u0120transformed": 14434, "\u0120Normal": 14435, "\u0120104": 14436, "\u0120Kickstarter": 14437, "\u0120Upon": 14438, "Online": 14439, "\u0120IRS": 14440, "\u0120wrap": 14441, "\u0120loving": 14442, "\u0120arrives": 14443, "\u0120Due": 14444, "\u0120heter": 14445, "\u0120Made": 14446, "\u0120rental": 14447, "\u0120belongs": 14448, "\u0120attorneys": 14449, "\u0120crops": 14450, "\u0120matched": 14451, "ulum": 14452, "oline": 14453, "109": 14454, "\u0120dispar": 14455, "\u0120buyers": 14456, "\u0120Cambridge": 14457, "\u0120ethics": 14458, "roups": 14459, "\u0120justified": 14460, "\u0120marginal": 14461, "\u0120respected": 14462, "winning": 14463, "\u0120nodded": 14464, "\u0120Serge": 14465, "\u0120Former": 14466, "Craft": 14467, "################": 14468, "\u0120Warner": 14469, "\u0120dash": 14470, "ete": 14471, "\u0120entert": 14472, "\u0120Escape": 14473, "outheast": 14474, "\u0120knees": 14475, "\u0120Bomb": 14476, "\u0120rug": 14477, "Pass": 14478, "\u0120attitudes": 14479, "government": 14480, "\u0120Prior": 14481, "\u0120qualities": 14482, "\u0120notification": 14483, "\u0120Phone": 14484, "lie": 14485, "\u0120anticipated": 14486, "\u0120Combat": 14487, "\u0120Barry": 14488, "\u01201982": 14489, "Users": 14490, "oner": 14491, "\u0120computing": 14492, "\u0120Connecticut": 14493, "\u0120lesser": 14494, "\u0120peers": 14495, "\u0120Cu": 14496, "\u0120technically": 14497, "\u0120submission": 14498, "\u0120Universal": 14499, "\u0120manually": 14500, "ourge": 14501, "\u0120respondents": 14502, "\u0120BTC": 14503, "\u0120Host": 14504, "\u0120fare": 14505, "\u0120Bird": 14506, "\u0120receipt": 14507, "also": 14508, "\u0120jack": 14509, "\u0120agriculture": 14510, "\u0120skull": 14511, "\u0120!=": 14512, "\u0120passive": 14513, "\u0120CI": 14514, "\u0120societies": 14515, "\u0120reminded": 14516, "\u0120interference": 14517, "Buy": 14518, "\u0120\u00e2\u013e": 14519, "gon": 14520, "\u0120scrutiny": 14521, "\u0120Witch": 14522, "\u0120conducting": 14523, "\u0120\u00e3\u0125": 14524, "\u0120exchanges": 14525, "\u0120Mitchell": 14526, "\u0120inhabit": 14527, "\u0120twist": 14528, "BD": 14529, "\u0120wherever": 14530, "groupon": 14531, "\u0120jokes": 14532, "\u0120Benjamin": 14533, "\u0120Random": 14534, "frame": 14535, "\u0120Lions": 14536, "\u0120highlighted": 14537, "\u0120Arkansas": 14538, "Ent": 14539, "\u0120pile": 14540, "\u0120prelim": 14541, "gs": 14542, "minded": 14543, "\u0120felony": 14544, "\u0120GA": 14545, "\u0120Luck": 14546, "\u0120practically": 14547, "\u0120Bos": 14548, "\u0120actress": 14549, "Dam": 14550, "\u0120Bou": 14551, "\u0120visa": 14552, "\u0120embedded": 14553, "\u0120hybrid": 14554, "\u0120earliest": 14555, "\u0120sooner": 14556, "social": 14557, "\u0120HA": 14558, "\u0120steep": 14559, "\u0120disadvant": 14560, "\u0120exploit": 14561, "\u0120Egg": 14562, "\u0120Ultra": 14563, "\u0120necessity": 14564, "Local": 14565, "iege": 14566, "\u0120dated": 14567, "\u0120masses": 14568, "\u0120subscription": 14569, "pless": 14570, "\u0120anonym": 14571, "\u0120presumably": 14572, "Blue": 14573, "Their": 14574, "asketball": 14575, "\u0120Philip": 14576, "\u0120comed": 14577, "loaded": 14578, "rane": 14579, "\u0120reflection": 14580, "China": 14581, "\u0120extends": 14582, "\u0120forming": 14583, "\u0120unders": 14584, "2001": 14585, "\u0120grat": 14586, "\u0120concentrations": 14587, "\u0120insulin": 14588, "\u0120secular": 14589, "\u0120whilst": 14590, "\u0120winners": 14591, "Advertisements": 14592, "\u0120deliberately": 14593, "\u0120Working": 14594, "\u0120sink": 14595, "etics": 14596, "dale": 14597, "\u0120mandate": 14598, "\u0120gram": 14599, "\u0120vacation": 14600, "\u0120warnings": 14601, "ripp": 14602, "\u0120THAT": 14603, "\u0120commentary": 14604, "\u0120intu": 14605, "\u0120aest": 14606, "\u0120reasoning": 14607, "\u0120breakdown": 14608, "\u0120Zombie": 14609, "\u0120-->": 14610, "\u0120Political": 14611, "cott": 14612, "\u0120thrust": 14613, "\u0120technological": 14614, "\u0120deciding": 14615, "\u0120trafficking": 14616, "Long": 14617, "Welcome": 14618, "prising": 14619, "\u0120Communications": 14620, "\u0120endors": 14621, "\u0120swift": 14622, "\u0120metabol": 14623, "coins": 14624, "resa": 14625, "\u0120HTTP": 14626, "\u0120enroll": 14627, "\u0120Happy": 14628, "usr": 14629, "intage": 14630, "\u0120[\"": 14631, "uably": 14632, "\u0120Material": 14633, "\u0120repeal": 14634, "Sept": 14635, "kh": 14636, "\u0120Modi": 14637, "\u0120underneath": 14638, "\u0120IL": 14639, "shore": 14640, "\u0120diagnosed": 14641, "aceutical": 14642, "\u0120shower": 14643, "aux": 14644, "\u0120Switch": 14645, "\u0120Strength": 14646, "\u0120jihad": 14647, "national": 14648, "\u0120trauma": 14649, "ussy": 14650, "oni": 14651, "\u0120consolid": 14652, "\u0120calories": 14653, "\u0120Flynn": 14654, "agged": 14655, "168": 14656, "\u0120Pink": 14657, "\u0120fulfill": 14658, "\u0120chains": 14659, "\u0120notably": 14660, "\u0120AV": 14661, "Life": 14662, "\u0120Chuck": 14663, "mus": 14664, "\u0120Urban": 14665, "\u0120Hend": 14666, "\u0120deposit": 14667, "\u0120Sad": 14668, "\u0120affair": 14669, "ORK": 14670, "ieval": 14671, "\u0120FDA": 14672, "\u0120trop": 14673, "\u0120Overall": 14674, "\u0120virtue": 14675, "\u0120satisfaction": 14676, "aund": 14677, "\u0120lun": 14678, "\u0120Switzerland": 14679, "\u0120Operation": 14680, "process": 14681, "\u0120shook": 14682, "\u0120counties": 14683, "leased": 14684, "\u0120Charlotte": 14685, "112": 14686, "\u0120transcript": 14687, "\u0120redd": 14688, "push": 14689, "\u0120Hey": 14690, "\u0120Analysis": 14691, "[\"": 14692, "\u0120alternatives": 14693, "ardless": 14694, "\u0120eleph": 14695, "\u0120prejud": 14696, "\u0120Leaf": 14697, "Having": 14698, "\u0120Hub": 14699, "\u0120expressions": 14700, "\u0120Volume": 14701, "\u0120shocking": 14702, "\u0120Reds": 14703, "\u0120readily": 14704, "\u0120planets": 14705, "adata": 14706, "\u0120collapsed": 14707, "\u0120Madrid": 14708, "\u0120irrit": 14709, "ipper": 14710, "\u0120Enc": 14711, "\u0120Wire": 14712, "\u0120buzz": 14713, "\u0120GP": 14714, "asha": 14715, "\u0120accidentally": 14716, "uru": 14717, "\u0120frustrated": 14718, "\u0120SA": 14719, "\u0120hungry": 14720, "\u0120Huff": 14721, "\u0120labels": 14722, "anto": 14723, "\u0120EP": 14724, "\u0120barriers": 14725, ")|": 14726, "\u0120Berkeley": 14727, "\u0120Jets": 14728, "\u0120pairs": 14729, "\u0120Lan": 14730, "James": 14731, "\u0120Bear": 14732, "\u0120humor": 14733, "\u0120Liberty": 14734, "\u0120magnitude": 14735, "\u0120aging": 14736, "\u0120Mason": 14737, "\u0120friendship": 14738, "umbling": 14739, "\u0120emerge": 14740, "\u0120newspapers": 14741, "\u0120ambitious": 14742, "\u0120Richards": 14743, "aternal": 14744, "\u01201981": 14745, "\u0120cookies": 14746, "\u0120sculpt": 14747, "\u0120pursuit": 14748, "Location": 14749, "\u0120scripts": 14750, "pc": 14751, "\u0120arrangements": 14752, "\u0120diameter": 14753, "\u0120loses": 14754, "amation": 14755, "\u0120liqu": 14756, "\u0120Jake": 14757, "arette": 14758, "\u0120understands": 14759, "\u0120Zen": 14760, "vm": 14761, "\u0120approve": 14762, "\u0120wip": 14763, "\u0120ultra": 14764, "\u0120intend": 14765, "\u0120DI": 14766, "ascular": 14767, "\u0120stays": 14768, "\u0120Kor": 14769, "\u0120Kl": 14770, "\u0120investing": 14771, "La": 14772, "\u0120believing": 14773, "bad": 14774, "mouth": 14775, "\u0120taxpayer": 14776, "\u00e3\u0125\u0125": 14777, "\u0120Quebec": 14778, "\u0120lap": 14779, "\u0120Swiss": 14780, "drop": 14781, "\u0120drain": 14782, "iri": 14783, "etc": 14784, "ften": 14785, "\u0120Nex": 14786, "\u0120straw": 14787, "\u0120screaming": 14788, "\u0120counted": 14789, "\u0120damaging": 14790, "\u0120ambassador": 14791, "century": 14792, "\u0120prox": 14793, "\u0120arrests": 14794, "uv": 14795, "ilateral": 14796, "\u0120Charg": 14797, "\u0120prescribed": 14798, "\u0120independently": 14799, "\u0120fierce": 14800, "\u0120Baby": 14801, "\u0120brave": 14802, "\u0120suits": 14803, "=>": 14804, "\u0120baseline": 14805, "\u0120Rate": 14806, "\u0120islands": 14807, "\u0120((": 14808, "green": 14809, "ixels": 14810, "\u0120namely": 14811, "\u0120Village": 14812, "than": 14813, "amy": 14814, "Version": 14815, "gmail": 14816, "entials": 14817, "\u0120Sud": 14818, "\u0120Melbourne": 14819, "\u0120arriving": 14820, "\u0120quantum": 14821, "eff": 14822, "ropolitan": 14823, "Tri": 14824, "\u0120funeral": 14825, "\u0120IR": 14826, "\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124": 14827, "\u0120Cob": 14828, "itably": 14829, "\u0120turb": 14830, "\u0120combo": 14831, "Review": 14832, "\u0120deployment": 14833, "uity": 14834, "\u0120Bott": 14835, "\u0120invisible": 14836, "\u0120rendering": 14837, "\u0120unlocked": 14838, "\u0120aqu": 14839, "\u0120Vladimir": 14840, "\u0120pad": 14841, "\u0120Brain": 14842, "\u0120Legacy": 14843, "dragon": 14844, "\u0120Kurdish": 14845, "\u0120sounded": 14846, "\u0120detained": 14847, "\u0120DM": 14848, "gary": 14849, "\u0120daughters": 14850, "\u0120disturbing": 14851, "uka": 14852, "\u0120Parad": 14853, "\u0120tast": 14854, "\u0120unfortunate": 14855, "\u0120ul": 14856, "emin": 14857, "\u0120attendance": 14858, "trl": 14859, "\u0120parks": 14860, "\u0120Memorial": 14861, "\u0120Alice": 14862, "othy": 14863, "guard": 14864, "\u0120Dise": 14865, "\u0120Shan": 14866, "\u0120Forum": 14867, "Rich": 14868, "\u0120shifted": 14869, "uez": 14870, "\u0120lighter": 14871, "\u0120Magn": 14872, "\u0120cod": 14873, "Sch": 14874, "hammad": 14875, "Pub": 14876, "350": 14877, "\u0120Pokemon": 14878, "\u0120prototype": 14879, "\u0120unre": 14880, "Base": 14881, "\u0120Students": 14882, "\u0120Reply": 14883, "\u0120Communist": 14884, "\u0120gau": 14885, "\u0120Tyler": 14886, "IZ": 14887, "\u0120participated": 14888, "\u0120suprem": 14889, "\u0120Details": 14890, "\u0120vessels": 14891, "rod": 14892, "\u0120tribe": 14893, "keep": 14894, "\u0120assumptions": 14895, "\u0120pound": 14896, "\u0120crude": 14897, "\u0120Available": 14898, "\u0120swimming": 14899, "\u0120inclusion": 14900, "\u0120advances": 14901, "culation": 14902, "\u0120conservation": 14903, "\u0120overd": 14904, "\u0120Buffalo": 14905, "Article": 14906, "edge": 14907, "\u0120awa": 14908, "\u0120Madison": 14909, "\u0120sidew": 14910, "\u0120catast": 14911, "\u0120Krist": 14912, "ucle": 14913, "\u0120Highway": 14914, "\u0120Terror": 14915, "\u0120activation": 14916, "\u0120unconscious": 14917, "\u0120Satan": 14918, "\u0120Susan": 14919, "illery": 14920, "\u0120arranged": 14921, "iop": 14922, "\u0120rumors": 14923, "urring": 14924, "think": 14925, "\u0120Keith": 14926, "\u0120Kind": 14927, "\u0120avoiding": 14928, "byn": 14929, "nut": 14930, "\u0120Speaker": 14931, "rus": 14932, "names": 14933, "\u0120guilt": 14934, "\u0120Olympics": 14935, "\u0120sail": 14936, "\u0120Mes": 14937, "levant": 14938, "\u0120Columbus": 14939, "aft": 14940, "City": 14941, "South": 14942, "\u0120Harvey": 14943, "\u0120Pun": 14944, "Several": 14945, "\u0120mentally": 14946, "\u0120impress": 14947, "mount": 14948, "\u0120Ubuntu": 14949, "\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136": 14950, "\u0120Superman": 14951, "\u0120MPs": 14952, "\u0120intentions": 14953, "\u0120Racing": 14954, "\u0120likelihood": 14955, "\u0120240": 14956, "Total": 14957, "\u0120toys": 14958, "\u0120Watson": 14959, "\u0120urge": 14960, "Lear": 14961, "\u0120Paper": 14962, "\u0120occurring": 14963, "\u0120Beng": 14964, "\u0120Cert": 14965, "\u0120stones": 14966, "Tim": 14967, "\u0120Twin": 14968, "zb": 14969, "\u0120Dynam": 14970, "\u0120politician": 14971, "kens": 14972, "\u0120Enterprise": 14973, "UTERS": 14974, "\u0120abol": 14975, "\u0120refresh": 14976, "\u0120arbitrary": 14977, "pection": 14978, "\u0120troubles": 14979, "\u0120});": 14980, "tv": 14981, "\u0120pilots": 14982, "\u0120distribute": 14983, "\u0120audit": 14984, "\u0120pause": 14985, "original": 14986, "\u0120rivals": 14987, "\u00c2\u00a3": 14988, "Fig": 14989, "TL": 14990, "abil": 14991, "rying": 14992, "Lin": 14993, "ioned": 14994, "lon": 14995, "\u0120fancy": 14996, "\u0120crashed": 14997, "\u0120tract": 14998, "\u0120shed": 14999, "\u0120consume": 15000, "Based": 15001, "download": 15002, "init": 15003, "\u0120voltage": 15004, "Introdu": 15005, "\u0120condemned": 15006, "\u0120Finance": 15007, "respect": 15008, "\u0120excluded": 15009, "\u0120establishing": 15010, "heric": 15011, "\u0120heritage": 15012, "\u0120spectacular": 15013, "\u0120unst": 15014, "\u0120Snowden": 15015, "\u0120Lane": 15016, "San": 15017, "\u0120protections": 15018, "struction": 15019, "incinn": 15020, "\u0120macro": 15021, "Custom": 15022, "iosity": 15023, "\u0120esp": 15024, "\u0120functioning": 15025, "\u0120mush": 15026, "\u0120puzzle": 15027, "\u0120ethical": 15028, "Mal": 15029, "\u0120governing": 15030, "\u0120Ferguson": 15031, "\u0120restored": 15032, "\u0120stressed": 15033, "\u0120Counter": 15034, "\u0120Kas": 15035, "clip": 15036, "ANS": 15037, "\u0120seiz": 15038, "UK": 15039, "byss": 15040, "oldown": 15041, "api": 15042, "\u0120permanently": 15043, "ounters": 15044, "West": 15045, "Through": 15046, "Light": 15047, "atoes": 15048, "\u0120neat": 15049, "\u0120cord": 15050, "urer": 15051, "\u0120severely": 15052, "\u0120Aven": 15053, "\u0120interrog": 15054, "\u0120triple": 15055, "Given": 15056, "Number": 15057, "\u0120arise": 15058, "\u0120sher": 15059, "plant": 15060, "\u0120flower": 15061, "\u0120Cou": 15062, "\u0120ate": 15063, "\u0120newer": 15064, "bul": 15065, "\u0120meanwhile": 15066, "\u0120Lair": 15067, "\u0120adjustment": 15068, "\u0120Copyright": 15069, "\u0120divers": 15070, "iological": 15071, "\u0120gamers": 15072, "oat": 15073, "\u0120historically": 15074, "\u0120analog": 15075, "\u0120longtime": 15076, "\u0120prescription": 15077, "\u0120Mist": 15078, "\u0120Hyper": 15079, "\u0120Maine": 15080, "\u0120Deity": 15081, "\u0120multipl": 15082, "\u0120Reincarn": 15083, "\u0120Hyd": 15084, "\u0120Pic": 15085, "Sil": 15086, "rants": 15087, "\u0120Cris": 15088, ".;": 15089, "({": 15090, "ependence": 15091, "\u0120recy": 15092, "ateur": 15093, "\u0120quad": 15094, "\u0120glob": 15095, "\u0120conced": 15096, "team": 15097, "\u0120capitalist": 15098, "\u0120Lot": 15099, "\u0120royal": 15100, "\u0120Cyber": 15101, "\u0120blacks": 15102, "metic": 15103, "riv": 15104, "\u0120Danny": 15105, "\u0120spo": 15106, "\u0120RO": 15107, "\u0120animated": 15108, "rypted": 15109, "\u0120Deputy": 15110, "\u0120rendered": 15111, "FE": 15112, "\u0120streak": 15113, "\u0120clouds": 15114, "\u0120Doug": 15115, "~~~~~~~~": 15116, "\u0120discour": 15117, "\u0120Veh": 15118, "\u0120psychology": 15119, "\u0120Journey": 15120, "\u0120crystal": 15121, "\u0120Frost": 15122, "\u0120suspicion": 15123, "\u0120relate": 15124, "orus": 15125, "\u0120Crypt": 15126, "\u0120NVIDIA": 15127, "comed": 15128, "uting": 15129, "incinnati": 15130, "\u0120vulnerability": 15131, "ostic": 15132, "\u0120isolation": 15133, "\u0120cooling": 15134, "\u0120Coalition": 15135, "\u0120119": 15136, "Four": 15137, "\u0120Deal": 15138, "\u0120\u00e2\u012b": 15139, "semble": 15140, "rament": 15141, "\u0120Barcelona": 15142, "\u0120102": 15143, "\u0120cocaine": 15144, "ocalypse": 15145, "Feb": 15146, "ogenic": 15147, "\u0120mutation": 15148, "\u0120cryptoc": 15149, "\u0120Kel": 15150, "\u0120Git": 15151, "ais": 15152, "\u0120sisters": 15153, "ANK": 15154, "\u0120activate": 15155, "Ter": 15156, "\u0120dread": 15157, "ylon": 15158, "\u0120propri": 15159, "Aust": 15160, "\u0120Default": 15161, "\u0120outdoor": 15162, "\u0120sheer": 15163, "ceive": 15164, "\u0120gently": 15165, "\u00d0\u00be": 15166, "Program": 15167, "\u0120\u00e2\u0128\u0134": 15168, "\u0120vegan": 15169, "\u0120Crus": 15170, "\u0120responsibilities": 15171, "\u0120HR": 15172, "OLD": 15173, "\u0120prevents": 15174, "\u0120stiff": 15175, "\u0120Were": 15176, "\u0120athletic": 15177, "\u0120Score": 15178, "\u0120):": 15179, "\u0120columns": 15180, "\u0120Loc": 15181, "available": 15182, "\u0120Fram": 15183, "\u0120Sessions": 15184, "\u0120companion": 15185, "\u0120packs": 15186, "140": 15187, "\u0120Knights": 15188, "\u0120fart": 15189, "\u0120streams": 15190, "\u0120shore": 15191, "\u0120appeals": 15192, "\u0120Performance": 15193, "haul": 15194, "\u0120Stra": 15195, "\u0120Nag": 15196, "103": 15197, "\u0120Transportation": 15198, "BB": 15199, "Ev": 15200, "zan": 15201, "Public": 15202, "\u0120twin": 15203, "ulsion": 15204, "Mult": 15205, "\u0120electro": 15206, "\u0120statue": 15207, "ationally": 15208, "\u0120Nort": 15209, "\u0120inspection": 15210, "/*": 15211, "igue": 15212, "\u0120compassion": 15213, "\u0120Tales": 15214, "\u0120Stein": 15215, "\u0120Screen": 15216, "\u0120Bug": 15217, "\u0120Lion": 15218, "girl": 15219, "\u0120withdrawal": 15220, "\u0120objectives": 15221, "\u0120bloody": 15222, "\u0120preliminary": 15223, "\u0120jacket": 15224, "\u0120dimensions": 15225, "\u0120Cool": 15226, "\u0120Occup": 15227, "\u0120wreck": 15228, "\u0120doubled": 15229, "anking": 15230, "\u01201975": 15231, "\u0120glasses": 15232, "\u0120Wang": 15233, "prov": 15234, "Path": 15235, "connected": 15236, "\u0120Multi": 15237, "\u0120Norway": 15238, "agonist": 15239, "\u0120feared": 15240, "\u0120touching": 15241, "\u0120arguably": 15242, "\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af": 15243, "\u0120NCAA": 15244, "chem": 15245, "\u0120spat": 15246, "\u0120WWE": 15247, "\u0120Cel": 15248, "igger": 15249, "\u0120attacker": 15250, "\u0120Join": 15251, "object": 15252, "etta": 15253, "\u0120eliminated": 15254, "det": 15255, "\u0120destruct": 15256, "\u0120Lucas": 15257, "ctuary": 15258, "180": 15259, "\u0120Brady": 15260, "\u0120Blues": 15261, "Bay": 15262, "aukee": 15263, "\u0120timeline": 15264, "\u0120delegates": 15265, "written": 15266, "ufficient": 15267, "\u0120shapes": 15268, "Copyright": 15269, "ouble": 15270, "service": 15271, "\u0120pione": 15272, "\u0120colleges": 15273, "\u0120rows": 15274, "\u0120spite": 15275, "\u0120assessed": 15276, "360": 15277, "\u0120lease": 15278, "\u0120confidential": 15279, "cker": 15280, "\u0120Manning": 15281, "\u0120Voice": 15282, "\u0120sealed": 15283, "\u0120calculate": 15284, "NO": 15285, "\u0120Assistant": 15286, "\u0120teenager": 15287, "ulent": 15288, "atherine": 15289, "\u0120mock": 15290, "\u0120diamond": 15291, "\u0120fest": 15292, "\u0120switched": 15293, "\u0120resume": 15294, "\u0120Puerto": 15295, "\u0120lanes": 15296, "iration": 15297, "\u0120Similarly": 15298, "\u0120rod": 15299, "\u0120Sel": 15300, "\u0120Palace": 15301, "\u0120Limited": 15302, "eous": 15303, "\u0120variant": 15304, "\u0120ward": 15305, "\u0120))": 15306, "Show": 15307, "OOK": 15308, "Alex": 15309, "\u0120Nep": 15310, "bris": 15311, "\u0120Wikipedia": 15312, "\u0120exceptional": 15313, "\u0120manages": 15314, "\u0120Draw": 15315, "Again": 15316, "\u0120copper": 15317, "utt": 15318, "\u0120exports": 15319, "\u0120portfolio": 15320, "\u0120elevated": 15321, "Rated": 15322, "\u0120Otherwise": 15323, "\u0120Tact": 15324, "\u0120Shel": 15325, "\u0120TX": 15326, "\"\u00e2\u0122\u0136": 15327, "\u0120resur": 15328, "\u0120Wa": 15329, "venant": 15330, "\u0120monetary": 15331, "people": 15332, "Email": 15333, "\u0120fifty": 15334, "\u0120Sweet": 15335, "\u0120Malaysia": 15336, "\u0120confusing": 15337, "\u0120Rio": 15338, "uda": 15339, "utenant": 15340, "\");": 15341, "\u0120praised": 15342, "\u0120volumes": 15343, "turn": 15344, "\u0120mature": 15345, "\u0120nonprofit": 15346, "\u0120passionate": 15347, "\u0120Private": 15348, "\u0120103": 15349, "\u0120descend": 15350, "\u00e7\u00a5\u0140": 15351, "uffy": 15352, "headed": 15353, "Whether": 15354, "rien": 15355, "zech": 15356, "beit": 15357, "\u0120chrom": 15358, "\u0120McM": 15359, "\u0120dancing": 15360, "\u0120eleg": 15361, "\u0120Noticed": 15362, "115": 15363, "\u0120advocacy": 15364, "ENTS": 15365, "ambling": 15366, "\u0120Minor": 15367, "\u0120Finn": 15368, "\u0120priorities": 15369, "\u0120thereof": 15370, "\u0120Stage": 15371, "\u0120Rogers": 15372, "\u0120substitute": 15373, "\u0120Jar": 15374, "\u0120Jefferson": 15375, "\u0120lightly": 15376, "102": 15377, "\u0120Lisa": 15378, "uits": 15379, "ysical": 15380, "\u0120shifts": 15381, "\u0120drones": 15382, "\u0120workplace": 15383, "\u0120resid": 15384, "ensed": 15385, "ahn": 15386, "\u0120preferences": 15387, "server": 15388, "\u0120debates": 15389, "doc": 15390, "\u0120Gods": 15391, "\u0120helicopter": 15392, "\u0120honour": 15393, "\u0120considerably": 15394, "eded": 15395, "\u0120Female": 15396, "\u0120Anne": 15397, "\u0120reun": 15398, "\u0120Face": 15399, "\u0120Hallow": 15400, "\u0120Budget": 15401, "\u0120condemn": 15402, "\u0120tender": 15403, "Prof": 15404, "ocratic": 15405, "\u0120Turner": 15406, "\u0120Agric": 15407, "\u01201976": 15408, "\u0120apt": 15409, "disc": 15410, "\u0120Fighter": 15411, "\u0120Aur": 15412, "\u0120garbage": 15413, "input": 15414, "\u0120Karl": 15415, "\u0120Oliver": 15416, "\u0120Language": 15417, "kn": 15418, "Non": 15419, "\u0120Clar": 15420, "\u0120traditions": 15421, "\u0120advertisement": 15422, "\u0120Sor": 15423, "\u0120archive": 15424, "\u0120villages": 15425, "750": 15426, "\u0120implementing": 15427, "waukee": 15428, "\u0120dietary": 15429, "\u0120switching": 15430, "Republic": 15431, "\u0120velocity": 15432, "\u0120cit": 15433, "\u0120Awards": 15434, "\u0120financing": 15435, "\u0120lasted": 15436, ")]": 15437, "\u0120reminder": 15438, "Person": 15439, "\u0120precision": 15440, "\u0120designers": 15441, "\u0120Fried": 15442, "\u0120Border": 15443, "\u0120tragic": 15444, "\u0120wield": 15445, "\u0120initiatives": 15446, "\u0120Tank": 15447, "wer": 15448, "\u0120joins": 15449, "Ro": 15450, "inery": 15451, "\u0120arrow": 15452, "\u0120generating": 15453, "founder": 15454, "\u0120searches": 15455, "\u0120randomly": 15456, "Access": 15457, "\u0120batch": 15458, "\u0120posed": 15459, "lat": 15460, "\u0120pursuing": 15461, "asa": 15462, "\u0120testified": 15463, "forming": 15464, "\u0120Shar": 15465, "wiki": 15466, "\u0120Either": 15467, "Sometimes": 15468, "\u0120senators": 15469, "\u0120Johnny": 15470, "\u0120Taliban": 15471, "\u0120GPS": 15472, "\":\"/": 15473, "\u00e3\u0123\u00ae\u00e5": 15474, "\u0120analyzed": 15475, "\u0120Rubio": 15476, "\u0120Movement": 15477, "opard": 15478, "iii": 15479, "Stand": 15480, "fight": 15481, "\u0120ignoring": 15482, "iang": 15483, "\u0120GN": 15484, "soever": 15485, "\u0120STAT": 15486, "\u0120refusing": 15487, "\u0120sweat": 15488, "\u0120bay": 15489, "PORT": 15490, "irmed": 15491, "aky": 15492, "\u0120dispro": 15493, "\u0120labeled": 15494, "\u0120108": 15495, "Hello": 15496, "\u0120pleasant": 15497, "aba": 15498, "\u0120triumph": 15499, "\u0120aboard": 15500, "\u0120incom": 15501, "\u0120Crow": 15502, "lett": 15503, "\u0120folk": 15504, "\u0120chase": 15505, "``": 15506, "\u0120Brus": 15507, "\u0120teens": 15508, "cue": 15509, "\u0120terrain": 15510, "hyd": 15511, "ilight": 15512, "ORY": 15513, "Support": 15514, "ews": 15515, "lli": 15516, "raints": 15517, "\u0120Cand": 15518, "\u0120abused": 15519, "achment": 15520, "larg": 15521, "Bas": 15522, "\u0120Cancer": 15523, "\u01201978": 15524, "\u0120supporter": 15525, "access": 15526, "\u0120Termin": 15527, "\u0120Tampa": 15528, "\u0120ANY": 15529, "\u0120newest": 15530, "\u0120Criminal": 15531, "edu": 15532, "\u01201930": 15533, "\u0120admits": 15534, "\u0120ende": 15535, "\u0120failures": 15536, "urate": 15537, "fulness": 15538, "cycl": 15539, "\u0120Subject": 15540, "\u0120infinite": 15541, "three": 15542, "WA": 15543, "pit": 15544, "\u0120Install": 15545, "Rad": 15546, "iliation": 15547, "GM": 15548, "\u0120continent": 15549, "\u0120accommodate": 15550, "\u0120Clay": 15551, "\u0120pup": 15552, "\u0120Function": 15553, "\u0120hammer": 15554, "\u0120Alberta": 15555, "\u0120revised": 15556, "\u0120minorities": 15557, "\u0120measurement": 15558, "Connell": 15559, "\u0120disable": 15560, "\u0120Mix": 15561, "Incre": 15562, "\u0120fork": 15563, "\u0120Rosen": 15564, "\u0120implies": 15565, "umblr": 15566, "ANG": 15567, "\u0120proteins": 15568, "\u0120aggression": 15569, "\u0120facilitate": 15570, "SN": 15571, "\u0120illegally": 15572, "uer": 15573, "\u0120academ": 15574, "\u0120puzz": 15575, "\u0120Shift": 15576, "pay": 15577, "ollo": 15578, "\u0120audiences": 15579, "Build": 15580, "\u0120noble": 15581, "\u0120syntax": 15582, "\u00e2\u013a\u0127": 15583, "\u0120beam": 15584, "\u0120Bed": 15585, "\u0120Ald": 15586, "\u0120origins": 15587, "video": 15588, "\u01201977": 15589, "\u0120Assault": 15590, "\u0120garage": 15591, "Team": 15592, "\u0120verdict": 15593, "\u0120dwar": 15594, "\u0120Virtual": 15595, "event": 15596, "Keep": 15597, "\u0120sentiment": 15598, "\u0120wildlife": 15599, "shirt": 15600, "\u0120burg": 15601, "\u0120recommendation": 15602, "represent": 15603, "\u0120gallery": 15604, "owners": 15605, "\u0120scholar": 15606, "\u0120convenience": 15607, "\u0120Swift": 15608, "\u0120convinc": 15609, "Cap": 15610, "\u0120warfare": 15611, "\u0120Visual": 15612, "\u0120constitute": 15613, "\u0120abort": 15614, "\u0120Weather": 15615, "\u0120Looking": 15616, "\u0120Hem": 15617, "\u0120martial": 15618, "\u0120incoming": 15619, "etition": 15620, "\u0120tolerance": 15621, "\u0120Created": 15622, "\u0120flows": 15623, "\u0120Elder": 15624, "\u0120souls": 15625, "\u0120foul": 15626, "\u0120Pain": 15627, "\u0120CAN": 15628, "\u0120220": 15629, "bc": 15630, "hend": 15631, "\u0120genius": 15632, "Real": 15633, "\u0120Wr": 15634, "ometer": 15635, "pad": 15636, "\u0120limiting": 15637, "\u0120Si": 15638, "\u0120Lore": 15639, "\u0120Adventures": 15640, "\u0120varied": 15641, "Disc": 15642, "fin": 15643, "\u0120Personal": 15644, "Chris": 15645, "\u0120invented": 15646, "\u0120dive": 15647, "\u0120Rise": 15648, "\u0120oz": 15649, "\u0120Comics": 15650, "\u0120expose": 15651, "\u0120Reb": 15652, "letters": 15653, "site": 15654, "imated": 15655, "\u0120hacking": 15656, "\u0120educated": 15657, "\u0120Nobody": 15658, "\u0120depri": 15659, "\u0120incentive": 15660, "\u00e3\u0124\u00b7": 15661, "\u0120oversight": 15662, "\u0120tribes": 15663, "\u0120Belgium": 15664, "\u0120licensing": 15665, "ourt": 15666, "Product": 15667, "ahl": 15668, "\u0120Gem": 15669, "\u0120specialist": 15670, "\u0120cra": 15671, "anners": 15672, "\u0120Corbyn": 15673, "\u01201973": 15674, "READ": 15675, "\u0120summar": 15676, "\u0120overlook": 15677, "\u0120Application": 15678, "\u0120inappropriate": 15679, "\u0120downloaded": 15680, "Que": 15681, "\u0120Bears": 15682, "\u0120thumb": 15683, "\u0120Character": 15684, "\u0120Reincarnated": 15685, "\u0120Sid": 15686, "\u0120demonstrates": 15687, "sky": 15688, "\u0120Bloomberg": 15689, "\u0120Array": 15690, "\u0120Results": 15691, "\u0120Fourth": 15692, "\u0120EDT": 15693, "\u0120Oscar": 15694, "cend": 15695, "\u0120106": 15696, "\u0120NULL": 15697, "\u0120HERE": 15698, "match": 15699, "\u0120Brun": 15700, "\u0120glucose": 15701, "ieg": 15702, "egu": 15703, "\u0120certified": 15704, "\u0120relie": 15705, "\u0120humanitarian": 15706, "\u0120prayers": 15707, "King": 15708, "\u0120nan": 15709, "hou": 15710, "108": 15711, "ulu": 15712, "\u0120renewable": 15713, "\u0120distinguish": 15714, "\u0120dense": 15715, "\u0120Vent": 15716, "\u0120Package": 15717, "\u0120Boss": 15718, "\u0120editors": 15719, "\u0120migr": 15720, "Tra": 15721, "\u0120Peters": 15722, "\u0120Arctic": 15723, "2004": 15724, "\u0120Cape": 15725, "\u0120locally": 15726, "\u0120lasting": 15727, "\u0120handy": 15728, ".).": 15729, "Pan": 15730, "\u0120RES": 15731, "Index": 15732, "\u0120tensions": 15733, "\u0120formerly": 15734, "\u0120ideological": 15735, "\u0120sensors": 15736, "\u0120dealers": 15737, "\u0120defines": 15738, "Sk": 15739, "\u0120proceeds": 15740, "\u0120proxy": 15741, "azines": 15742, "\u0120Bash": 15743, "\u0120Pad": 15744, "\u0120Craft": 15745, "ealous": 15746, "\u0120sheets": 15747, "ometry": 15748, "June": 15749, "clock": 15750, "TT": 15751, "\u0120Theatre": 15752, "\u0120Buzz": 15753, "\u0120chapters": 15754, "\u0120millenn": 15755, "\u0120dough": 15756, "\u0120Congressional": 15757, "\u0120imagined": 15758, "avior": 15759, "\u0120clinic": 15760, "\u01201945": 15761, "\u0120holder": 15762, "root": 15763, "olester": 15764, "\u0120restart": 15765, "BN": 15766, "\u0120Hamas": 15767, "\u0120Job": 15768, "\u0120orb": 15769, "\u0120ram": 15770, "\u0120disclose": 15771, "\u0120translate": 15772, "\u0120immigrant": 15773, "\u0120annoying": 15774, "\u0120treaty": 15775, "anium": 15776, "\u0120Tea": 15777, "\u0120Legion": 15778, "\u0120crowds": 15779, "\u0120Bec": 15780, "\u0120Aer": 15781, "ohyd": 15782, "Bro": 15783, "Looking": 15784, "\u0120lbs": 15785, "\u0120aggress": 15786, "\u0120seam": 15787, "\u0120intercept": 15788, "\u0120MI": 15789, "mercial": 15790, "activ": 15791, "\u0120Cit": 15792, "\u0120dimension": 15793, "\u0120consistency": 15794, "\u0120rushing": 15795, "\u0120Douglas": 15796, "\u0120trim": 15797, "Install": 15798, "icker": 15799, "\u0120shy": 15800, "106": 15801, "\u0120mentions": 15802, "pelled": 15803, "\u0120Tak": 15804, "cost": 15805, "\u0120classroom": 15806, "\u0120fortune": 15807, "driven": 15808, "\u0120unle": 15809, "\u0120Wheel": 15810, "\u0120investor": 15811, "\u0120Masters": 15812, "kit": 15813, "\u0120associations": 15814, "\u0120Evolution": 15815, "oping": 15816, "uscript": 15817, "\u0120provincial": 15818, "\u0120Walter": 15819, "avi": 15820, "SO": 15821, "\u0120unlimited": 15822, "English": 15823, "\u0120Cards": 15824, "\u0120Ebola": 15825, "nered": 15826, "\u0120revenge": 15827, "\u0120outright": 15828, "umper": 15829, "\u0120fitting": 15830, "\u0120Solid": 15831, "\u0120formally": 15832, "\u0120problematic": 15833, "\u0120hazard": 15834, "\u0120encryption": 15835, "\u0120straightforward": 15836, "\u0120AK": 15837, "\u0120pse": 15838, "\u0120Orb": 15839, "\u0120Chamber": 15840, "\u0120Mak": 15841, "Contents": 15842, "\u0120loyalty": 15843, "\u0120lyrics": 15844, "\u0120Sym": 15845, "\u0120welcomed": 15846, "\u0120cooked": 15847, "\u0120monop": 15848, "\u0120nurse": 15849, "\u0120misleading": 15850, "\u0120eternal": 15851, "\u0120shifting": 15852, "\u0120+=": 15853, "Vis": 15854, "\u0120institutional": 15855, "illary": 15856, "\u0120pant": 15857, "VERT": 15858, "\u0120ACC": 15859, "\u0120Enh": 15860, "\u0120incon": 15861, "\u0120REUTERS": 15862, "\u0120donated": 15863, "\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6": 15864, "Intern": 15865, "\u0120exhibit": 15866, "\u0120tire": 15867, "\u0120Ric": 15868, "\u0120Champion": 15869, "\u0120Muhammad": 15870, "NING": 15871, "\u0120Soccer": 15872, "\u0120mobility": 15873, "\u0120varying": 15874, "\u0120Movie": 15875, "\u0120lord": 15876, "oak": 15877, "Field": 15878, "\u0120vector": 15879, "usions": 15880, "\u0120scrap": 15881, "\u0120enabling": 15882, "make": 15883, "Tor": 15884, ".*": 15885, "||": 15886, "\u0120Website": 15887, "\u0120NPC": 15888, "\u0120socialist": 15889, "\u0120Billy": 15890, "\u0120Additional": 15891, "\u0120cargo": 15892, "\u0120farms": 15893, "\u0120Soon": 15894, "\u0120Prize": 15895, "\u0120midnight": 15896, "\u0120900": 15897, "seen": 15898, "\u0120Spot": 15899, "\u0120sheep": 15900, "\u0120sponsored": 15901, "\u0120Hi": 15902, "\u0120Jump": 15903, "\u01201967": 15904, "Microsoft": 15905, "\u0120Agent": 15906, "\u0120charts": 15907, "dir": 15908, "\u0120adjacent": 15909, "\u0120tricks": 15910, "\u0120manga": 15911, "\u0120exagger": 15912, "/>": 15913, "football": 15914, "\u0120FCC": 15915, "GC": 15916, "\u0120Tier": 15917, "andra": 15918, "OUND": 15919, "%),": 15920, "\u0120fruits": 15921, "VC": 15922, "\u0120AA": 15923, "Rober": 15924, "\u0120midst": 15925, "\u00e2\u0139": 15926, "anka": 15927, "\u0120legislature": 15928, "\u0120Neil": 15929, "\u0120tourists": 15930, "\"\"": 15931, "\u0120Warning": 15932, "\u0120Nevertheless": 15933, "\u0120Official": 15934, "\u0120Whatever": 15935, "\u0120mold": 15936, "\u0120drafted": 15937, "\u0120substances": 15938, "\u0120breed": 15939, "\u0120tags": 15940, "\u0120Task": 15941, "\u0120verb": 15942, "\u0120manufactured": 15943, "comments": 15944, "\u0120Polish": 15945, "Prov": 15946, "\u0120determines": 15947, "Obama": 15948, "kers": 15949, "\u0120utterly": 15950, "\u0120sect": 15951, "sche": 15952, "\u0120Gates": 15953, "\u0120Chap": 15954, "\u0120aluminum": 15955, "\u0120zombie": 15956, "\u0120Touch": 15957, "\u0120UP": 15958, "\u0120satisfy": 15959, "\u0120predomin": 15960, "ascript": 15961, "\u0120elaborate": 15962, "\u01201968": 15963, "\u0120measuring": 15964, "\u0120Vari": 15965, "anyahu": 15966, "\u0120sir": 15967, "ulates": 15968, "idges": 15969, "ickets": 15970, "\u0120Spencer": 15971, "TM": 15972, "oubted": 15973, "\u0120prey": 15974, "\u0120installing": 15975, "\u0120Cab": 15976, "reed": 15977, "reated": 15978, "Supp": 15979, "\u0120wrist": 15980, "\u0120Kerry": 15981, "107": 15982, "\u0120Kle": 15983, "\u0120Rachel": 15984, "\u0120cotton": 15985, "\u0120ARE": 15986, "\u0120Ele": 15987, "Control": 15988, "\u0120loads": 15989, "\u0120Dod": 15990, "anas": 15991, "bone": 15992, "\u0120classical": 15993, "\u0120Regional": 15994, "\u0120Integ": 15995, "VM": 15996, "\u0120desires": 15997, "\u0120autism": 15998, "supported": 15999, "\u0120Message": 16000, "\u0120compact": 16001, "writer": 16002, "\u0120109": 16003, "\u0120Hurricane": 16004, "cision": 16005, "\u0120cycles": 16006, "\u0120drill": 16007, "\u0120colleague": 16008, "\u0120maker": 16009, "German": 16010, "\u0120mistaken": 16011, "Sun": 16012, "\u0120Gay": 16013, "\u0120whatsoever": 16014, "\u0120sells": 16015, "\u0120Airl": 16016, "liv": 16017, "\u0120Option": 16018, "\u0120solved": 16019, "\u0120sectors": 16020, "\u0120horizontal": 16021, "\u0120equation": 16022, "\u0120Skill": 16023, "\u0120Bio": 16024, "gement": 16025, "\u0120Snap": 16026, "\u0120Legal": 16027, "\u0120trademark": 16028, "\u0120makeup": 16029, "\u0120assembled": 16030, "\u0120saves": 16031, "\u0120Halloween": 16032, "\u0120Vermont": 16033, "\u0120FROM": 16034, "\u0120farming": 16035, "\u0120Podcast": 16036, "acceptable": 16037, "\u0120Higher": 16038, "\u0120asleep": 16039, "ullivan": 16040, "\u0120referen": 16041, "\u0120Lev": 16042, "\u0120bullets": 16043, "oko": 16044, "HC": 16045, "\u0120stairs": 16046, "\u0120maintains": 16047, "\u0120Lower": 16048, "\u0120Vi": 16049, "\u0120marine": 16050, "\u0120acres": 16051, "\u0120coordinator": 16052, "\u0120Joh": 16053, "\u0120counterparts": 16054, "\u0120Brothers": 16055, "\u0120indict": 16056, "bra": 16057, "\u0120chunk": 16058, "\u0120cents": 16059, "Home": 16060, "\u0120Month": 16061, "\u0120accordingly": 16062, "ifles": 16063, "\u0120Germans": 16064, "\u0120Syn": 16065, "Hub": 16066, "\u0120eyeb": 16067, "\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122": 16068, "\u0120ranges": 16069, "\u0120Holland": 16070, "\u0120Robot": 16071, "fc": 16072, "Mike": 16073, "\u0120plasma": 16074, "\u0120swap": 16075, "\u0120athlete": 16076, "\u0120Rams": 16077, ",'\"": 16078, "\u0120infections": 16079, "\u0120corrid": 16080, "\u0120vib": 16081, "\u0120patches": 16082, "\u0120traditionally": 16083, "\u0120revelation": 16084, "\u0120sweep": 16085, "\u0120glance": 16086, "\u0120inex": 16087, "2003": 16088, "\u0120Raw": 16089, "working": 16090, "osures": 16091, "\u0120Dat": 16092, "\u0120Lynch": 16093, "\u0120leverage": 16094, "\u0120Reid": 16095, "\u0120correlation": 16096, "iances": 16097, "avascript": 16098, "\u0120repository": 16099, "retty": 16100, "\u01201972": 16101, "240": 16102, "\u0120oun": 16103, "pol": 16104, "\u0120Reed": 16105, "\u0120tactical": 16106, "isite": 16107, "Apple": 16108, "\u0120Quinn": 16109, "\u0120raped": 16110, "illo": 16111, "Europe": 16112, "\u0120algorithms": 16113, "\u0120Rodrig": 16114, "iu": 16115, "\u0120illum": 16116, "\u0120fame": 16117, "\u0120introducing": 16118, "\u0120delays": 16119, "\u0120Raiders": 16120, "\u0120whistle": 16121, "\u0120novels": 16122, "\u0120Really": 16123, "\u0120deriv": 16124, "\u0120publications": 16125, "\u0120Neither": 16126, "\u0120Commerce": 16127, "\u0120aston": 16128, "language": 16129, "Notes": 16130, "\u0120Roth": 16131, "\u0120Fear": 16132, "\u0120mate": 16133, "\u0120parade": 16134, "\u0120QB": 16135, "\u0120maneu": 16136, "\u0120Cincinnati": 16137, "mitting": 16138, "\u0120waist": 16139, "\u0120Rew": 16140, "\u0120discont": 16141, "\u00d0\u00b0": 16142, "\u0120staring": 16143, "\u0120alias": 16144, "\u0120securities": 16145, "\u0120toilet": 16146, "\u0120Jedi": 16147, "\u0120unlaw": 16148, "vised": 16149, "////////": 16150, "](": 16151, "\u0120Weiss": 16152, "\u0120prest": 16153, "\u0120Compan": 16154, "\u0120memo": 16155, "\u0120Grace": 16156, "July": 16157, "\u0120Elite": 16158, "center": 16159, "\u0120Stay": 16160, "\u0120galaxy": 16161, "\u0120tooth": 16162, "\u0120Settings": 16163, "\u0120subjected": 16164, "\u00e3\u0124\u00a6": 16165, "\u0120lineback": 16166, "\u0120retailers": 16167, "\u0120Want": 16168, "\u0120dangers": 16169, "Air": 16170, "\u0120voluntary": 16171, "eway": 16172, "\u0120interpreted": 16173, "otine": 16174, "\u00c3\u00a7": 16175, "\u0120pel": 16176, "Service": 16177, "\u0120Eventually": 16178, "\u0120careers": 16179, "\u0120threaten": 16180, "\u0120memor": 16181, "\u0120Bradley": 16182, "ancies": 16183, "sn": 16184, "\u0120Unknown": 16185, "National": 16186, "\u0120shadows": 16187, "ailand": 16188, "\u0120Dash": 16189, "Everyone": 16190, "izzard": 16191, "March": 16192, "=(": 16193, "\u0120pulls": 16194, "\u0120stranger": 16195, "\u0120backwards": 16196, "\u0120Bernard": 16197, "imensional": 16198, "\u0120chron": 16199, "\u0120theoretical": 16200, "ktop": 16201, "\u0120ware": 16202, "\u0120Investig": 16203, "\u0120Initi": 16204, "\u0120Operations": 16205, "oven": 16206, "ocide": 16207, "*/": 16208, "\u0120flames": 16209, "\u0120Cash": 16210, "shit": 16211, "\u0120cab": 16212, "\u0120Analy": 16213, "\u0120Seah": 16214, "\u0120defining": 16215, "\u0120ordering": 16216, "\u0120immun": 16217, "\u0120persistent": 16218, "ACH": 16219, "Russian": 16220, "mans": 16221, "\u0120hind": 16222, "\u0120photography": 16223, "\u00c2\u00a9": 16224, "\u0120hug": 16225, "\u0120107": 16226, "\u0120Hence": 16227, "iots": 16228, "udeau": 16229, "\u0120subsidies": 16230, "\u0120routinely": 16231, "\u0120Device": 16232, "itic": 16233, "\u0120disgust": 16234, "lander": 16235, "\u01201940": 16236, "\u0120assignment": 16237, "\u0120Besides": 16238, "wick": 16239, "\u0120Dust": 16240, "usc": 16241, "structed": 16242, "111": 16243, "develop": 16244, "\u0120fond": 16245, "\u0120intersection": 16246, "\u0120dignity": 16247, "\u0120commissioner": 16248, "Without": 16249, "reach": 16250, "\u0120cartoon": 16251, "\u0120scales": 16252, "\u00e3\u0125\u0143": 16253, "FIG": 16254, "\u0120surveys": 16255, "\u0120Indonesia": 16256, "\u0120artwork": 16257, "\u0120unch": 16258, "\u0120cycling": 16259, "unct": 16260, "auer": 16261, "orate": 16262, "\u0120Obviously": 16263, "\u0120characterized": 16264, "feld": 16265, "\u0120affirm": 16266, "\u0120innings": 16267, "\u0120\u00e9": 16268, "\u0120aliens": 16269, "\u0120cloth": 16270, "etooth": 16271, "\u0120Certain": 16272, "\u00c2\u00a7": 16273, "\u0120digest": 16274, "know": 16275, "\u0120XL": 16276, "\u0120predictions": 16277, "\u0120din": 16278, "WAR": 16279, "\u0120aftermath": 16280, "Example": 16281, "\u0120Success": 16282, "\u0120Thr": 16283, "IGN": 16284, "\u0120miner": 16285, "Bus": 16286, "\u0120clarity": 16287, "heimer": 16288, "\u0120OUT": 16289, "\u0120Send": 16290, "\u0120Circle": 16291, "\u0120Diet": 16292, "\u0120pronounced": 16293, "\u0120creators": 16294, "\u0120earthquake": 16295, "attery": 16296, "geons": 16297, "\u0120od": 16298, "\u0120laying": 16299, "orp": 16300, "Ult": 16301, "project": 16302, "\u0120undermin": 16303, "\u0120sequel": 16304, "Sam": 16305, "\u0120Darkness": 16306, "\u0120reception": 16307, "bull": 16308, "YS": 16309, "\u0120Vir": 16310, "\u0120sequences": 16311, "\u0120Coin": 16312, "\u0120outfit": 16313, "\u0120Wait": 16314, "119": 16315, "\u0120delivers": 16316, "......": 16317, "\u0120blown": 16318, "\u0120Esc": 16319, "\u0120Math": 16320, "perm": 16321, "\u0120Ul": 16322, "\u0120glim": 16323, "\u0120facial": 16324, "\u0120greenhouse": 16325, "\u0120tokens": 16326, "/-": 16327, "\u0120Annual": 16328, "\u0120ONE": 16329, "\u0120teenage": 16330, "\u0120Physical": 16331, "\u0120Lang": 16332, "\u0120Celt": 16333, "\u0120sued": 16334, "ividually": 16335, "\u0120patience": 16336, "chair": 16337, "regular": 16338, "\u0120aug": 16339, "inv": 16340, "except": 16341, "\u0120Lil": 16342, "\u0120nest": 16343, "fd": 16344, "sum": 16345, "\u0120Chase": 16346, "Russia": 16347, "\u0120Jennifer": 16348, "\u0120offseason": 16349, "Overall": 16350, "Fore": 16351, "\u0120riot": 16352, "Aud": 16353, "former": 16354, "\u0120defenders": 16355, "\u0120CT": 16356, "iotic": 16357, "ribly": 16358, "\u0120automated": 16359, "\u0120penis": 16360, "\u0120insist": 16361, "\u0120diagram": 16362, "\u0120SQL": 16363, "\u0120Garc": 16364, "\u0120witch": 16365, "client": 16366, "ierra": 16367, "ambers": 16368, "\u0120recount": 16369, "far": 16370, "Very": 16371, "osterone": 16372, "\u0120appreciated": 16373, "\u0120Perfect": 16374, "Section": 16375, "\u0120doses": 16376, "ocaust": 16377, "\u0120costly": 16378, "\u0120grams": 16379, "\u0120Shi": 16380, "\u0120wrestling": 16381, "\u01201971": 16382, "\u0120trophy": 16383, "\u0120nerve": 16384, "\u0120Kaz": 16385, "\u0120Experience": 16386, "\u0120pledged": 16387, "\u0120playback": 16388, "\u0120creativity": 16389, "bye": 16390, "\u0120attackers": 16391, "\u0120holders": 16392, "\u0120Coach": 16393, "\u0120PhD": 16394, "\u0120transfers": 16395, "\u0120colored": 16396, "\u0120Hindu": 16397, "\u0120drown": 16398, "\u0120listened": 16399, "\u0120WA": 16400, "iasm": 16401, "PO": 16402, "\u0120appealing": 16403, "\u0120disclosed": 16404, "\u0120Chicken": 16405, "agging": 16406, "\u0120pleaded": 16407, "\u0120navigation": 16408, "\u0120Returns": 16409, "\u0120[[": 16410, "ROR": 16411, "EA": 16412, "\u0120photographer": 16413, "\u0120Rider": 16414, "ippers": 16415, "\u0120slice": 16416, "\u0120erect": 16417, "\u0120hed": 16418, "issance": 16419, "\u0120Vikings": 16420, "urious": 16421, "\u0120appet": 16422, "oubtedly": 16423, "Child": 16424, "\u0120authentic": 16425, "oos": 16426, "\u0120Making": 16427, "\u0120announcing": 16428, "\u0120bod": 16429, "\u0120meter": 16430, "\u0120Nine": 16431, "\u0120Rogue": 16432, "\u0120workforce": 16433, "\u0120renewed": 16434, "\u0120organisations": 16435, "acs": 16436, "PLE": 16437, "Short": 16438, "\u0120compounds": 16439, "\u0120Visit": 16440, "\u0120envelop": 16441, "earth": 16442, "\u0120supportive": 16443, "ggle": 16444, "\u0120Brussels": 16445, "\u0120Guild": 16446, "Create": 16447, "REL": 16448, "\u0120averaged": 16449, "\u01201969": 16450, "riages": 16451, "\u0120lengthy": 16452, "\u0120forgot": 16453, "Okay": 16454, "\u0120Erd": 16455, "\u0120dealer": 16456, "\u0120recession": 16457, "DD": 16458, "\u0120desperately": 16459, "\u0120hunger": 16460, "\u0120sticks": 16461, "\u0120mph": 16462, "\u0120Faith": 16463, "\u0120intentionally": 16464, "\u0120demol": 16465, "ueller": 16466, "\u0120Sale": 16467, "\u0120debris": 16468, "spring": 16469, "\u0120leap": 16470, ">>>>": 16471, "\u0120containers": 16472, "selling": 16473, "ranean": 16474, "attering": 16475, "\u0120commented": 16476, "\u0120CM": 16477, "onut": 16478, "\u0120woods": 16479, "especially": 16480, "\u0120organize": 16481, "ivic": 16482, "\u0120Woods": 16483, "anga": 16484, "squ": 16485, "\u0120maj": 16486, "amon": 16487, "\u0120axis": 16488, "\u01201974": 16489, "\u0120Denmark": 16490, "\u0120warrior": 16491, "\u0120Pand": 16492, "\u0120outlined": 16493, "\u0120BO": 16494, "insula": 16495, "zilla": 16496, "ebook": 16497, "\u0120dare": 16498, "\u0120searched": 16499, "\u0120navigate": 16500, "Sn": 16501, "writing": 16502, "\u0120united": 16503, "Japan": 16504, "\u0120Hebrew": 16505, "\u0120flame": 16506, "\u0120relies": 16507, "\u0120catching": 16508, "\u0120Sho": 16509, "\u0120imprisonment": 16510, "\u0120pockets": 16511, "\u0120closure": 16512, "\u0120Fam": 16513, "tim": 16514, "adequ": 16515, "Activity": 16516, "\u0120recruiting": 16517, "\u0120WATCH": 16518, "\u0120Argentina": 16519, "dest": 16520, "\u0120apologize": 16521, "oro": 16522, "\u0120lacks": 16523, "\u0120tuned": 16524, "\u0120Griffin": 16525, "\u0120infamous": 16526, "\u0120celebrity": 16527, "sson": 16528, "\u0120----------------------------------------------------------------": 16529, "\u0120Isis": 16530, "\u0120Display": 16531, "\u0120credibility": 16532, "\u0120economies": 16533, "\u0120headline": 16534, "\u0120Cowboys": 16535, "\u0120indef": 16536, "\u0120lately": 16537, "\u0120incentives": 16538, "button": 16539, "\u0120Mob": 16540, "Aut": 16541, "\u0120resigned": 16542, "\u0120Om": 16543, "camp": 16544, "\u0120profiles": 16545, "\u0120schemes": 16546, "olphins": 16547, "ayed": 16548, "Clinton": 16549, "enh": 16550, "\u0120Yahoo": 16551, "\u0120abst": 16552, "\u0120ank": 16553, "suits": 16554, "\u0120wished": 16555, "\u0120Marco": 16556, "udden": 16557, "\u0120sphere": 16558, "\u0120Bishop": 16559, "\u0120incorporated": 16560, "\u0120Plant": 16561, "114": 16562, "\u0120hated": 16563, "pic": 16564, "\u0120donate": 16565, "\u0120lined": 16566, "\u0120beans": 16567, "\u0120stealing": 16568, "\u0120costume": 16569, "\u0120sheriff": 16570, "\u0120forty": 16571, "\u0120intact": 16572, "\u0120adapted": 16573, "\u0120travelling": 16574, "bart": 16575, "\u0120nicely": 16576, "\u0120dried": 16577, "\u0120scal": 16578, "osity": 16579, "NOTE": 16580, "\u0120Bh": 16581, "\u0120Broncos": 16582, "\u0120Ign": 16583, "\u0120intimate": 16584, "\u0120chemistry": 16585, "\u0120optimal": 16586, "Deb": 16587, "\u0120Generation": 16588, "\u0120],": 16589, "ichi": 16590, "\u0120Wii": 16591, "\u0120YOUR": 16592, "ventions": 16593, "Write": 16594, "\u0120popul": 16595, "unning": 16596, "\u0120Wor": 16597, "Vol": 16598, "\u0120queen": 16599, "heads": 16600, "KK": 16601, "\u0120analyze": 16602, "opic": 16603, "earchers": 16604, "\u0120dot": 16605, "legraph": 16606, "astically": 16607, "\u0120upgrades": 16608, "\u0120cares": 16609, "\u0120extending": 16610, "\u0120freeze": 16611, "\u0120inability": 16612, "\u0120organs": 16613, "\u0120pretend": 16614, "\u0120outlet": 16615, "113": 16616, "olan": 16617, "\u0120Mall": 16618, "uling": 16619, "talk": 16620, "\u0120expressing": 16621, "\u0120Always": 16622, "\u0120Begin": 16623, "files": 16624, "\u0120licenses": 16625, "%%": 16626, "\u0120Mitt": 16627, "\u0120filters": 16628, "\u0120Milwaukee": 16629, "GN": 16630, "\u0120unfold": 16631, "Mo": 16632, "\u0120nutrition": 16633, "ppo": 16634, "Bo": 16635, "\u0120founding": 16636, "\u0120undermine": 16637, "\u0120easiest": 16638, "\u0120Czech": 16639, "\u0120Mack": 16640, "\u0120sexuality": 16641, "\u0120Nixon": 16642, "Win": 16643, "\u0120Arn": 16644, "\u0120Kin": 16645, "\u00e3\u0124\u00a3": 16646, "icer": 16647, "\u0120fortun": 16648, "\u0120surfaces": 16649, "aghd": 16650, "\u0120carriers": 16651, "\u0120PART": 16652, "\u0120Tib": 16653, "\u0120interval": 16654, "\u0120frustrating": 16655, "\u0120Ship": 16656, "\u0120Armed": 16657, "ffe": 16658, "\u0120boats": 16659, "\u0120Abraham": 16660, "inis": 16661, "\u0120suited": 16662, "thread": 16663, "iov": 16664, "abul": 16665, "\u0120Venezuela": 16666, "\u0120tom": 16667, "super": 16668, "\u0120castle": 16669, "although": 16670, "ioxide": 16671, "eches": 16672, "\u0120evolutionary": 16673, "\u0120negotiate": 16674, "\u0120confronted": 16675, "Remember": 16676, "\u0120170": 16677, "Such": 16678, "\u0120911": 16679, "mult": 16680, "\u0120Abyss": 16681, "urry": 16682, "kees": 16683, "spec": 16684, "\u0120Barbara": 16685, "\u0120belonging": 16686, "\u0120villain": 16687, "istani": 16688, "\u0120accountable": 16689, "\u0120portions": 16690, "\u0120Decl": 16691, "Ur": 16692, "\u0120Kate": 16693, "gre": 16694, "\u0120magazines": 16695, "UCK": 16696, "\u0120regulate": 16697, "omon": 16698, "\u0120Almost": 16699, "\u0120overview": 16700, "\u0120scram": 16701, "\u0120loot": 16702, "\u0120Fitz": 16703, "\u0120characteristic": 16704, "\u0120Snake": 16705, "say": 16706, "\u0120Rico": 16707, "\u0120trait": 16708, "\u0120Joined": 16709, "aucus": 16710, "\u0120adaptation": 16711, "\u0120Airlines": 16712, "\u0120archae": 16713, "\u0120Ide": 16714, "\u0120bikes": 16715, "\u0120literary": 16716, "\u0120influences": 16717, "\u0120Used": 16718, "Creat": 16719, "\u0120plea": 16720, "\u0120Defence": 16721, "\u0120Assass": 16722, "\u0120pond": 16723, "ULT": 16724, ")\"": 16725, "\u0120evaluated": 16726, "\u0120obtaining": 16727, "\u0120demographic": 16728, "\u0120vigil": 16729, "aley": 16730, "\u0120spouse": 16731, "\u0120Seahawks": 16732, "respons": 16733, "\u0120Belt": 16734, "umatic": 16735, "\u0120rises": 16736, "runner": 16737, "\u0120Michelle": 16738, "\u0120potent": 16739, "race": 16740, "\u0120PAC": 16741, "Find": 16742, "olesterol": 16743, "ISS": 16744, "\u0120Introduced": 16745, "resses": 16746, "ignment": 16747, "Os": 16748, "\u0120Tu": 16749, "\u0120Dex": 16750, "icides": 16751, "\u0120sparked": 16752, "\u0120Laura": 16753, "\u0120Bryant": 16754, "\u0120smiling": 16755, "\u0120Nexus": 16756, "\u0120defendants": 16757, "\u0120Catal": 16758, "\u0120dishes": 16759, "shaped": 16760, "\u0120prolong": 16761, "mt": 16762, "($": 16763, "\u00e3\u0122\u0124": 16764, "\u0120calculations": 16765, "\u0120Same": 16766, "\u0120piv": 16767, "HH": 16768, "\u0120cancelled": 16769, "\u0120grin": 16770, "\u0120territories": 16771, "istically": 16772, "Come": 16773, "\u0120Parent": 16774, "Project": 16775, "\u0120neglig": 16776, "\u0120Privacy": 16777, "\u0120ammo": 16778, "LECT": 16779, "olutely": 16780, "\u0120Epic": 16781, "\u0120misunder": 16782, "wal": 16783, "April": 16784, "mos": 16785, "pathy": 16786, "\u0120Carson": 16787, "\u0120albums": 16788, "\u0120Easy": 16789, "\u0120pistol": 16790, "<<": 16791, "\u0120\\(": 16792, "target": 16793, "help": 16794, "\u0120interpre": 16795, "conscious": 16796, "\u0120Housing": 16797, "\u0120Joint": 16798, "127": 16799, "\u0120beers": 16800, "science": 16801, "\u0120Firefox": 16802, "effective": 16803, "\u0120Cabin": 16804, "\u0120Okay": 16805, "\u0120Applic": 16806, "\u0120spacecraft": 16807, "\u0120SR": 16808, "vet": 16809, "\u0120Strange": 16810, "SB": 16811, "\u0120corps": 16812, "iberal": 16813, "efficient": 16814, "\u0120prevalence": 16815, "\u0120economists": 16816, "118": 16817, "Thread": 16818, "ordable": 16819, "ODE": 16820, "\u0120Cant": 16821, "=-=-": 16822, "ifiable": 16823, "\u0120Around": 16824, "\u0120pole": 16825, "\u0120willingness": 16826, "CLA": 16827, "\u0120Kid": 16828, "\u0120complement": 16829, "\u0120scattered": 16830, "\u0120inmates": 16831, "\u0120bleeding": 16832, "every": 16833, "\u0120queue": 16834, "\u0120Train": 16835, "\u0120hij": 16836, "\u0120melee": 16837, "pleted": 16838, "\u0120digit": 16839, "\u0120gem": 16840, "official": 16841, "\u0120lifting": 16842, "\u00d0\u00b5": 16843, "Requ": 16844, "itutes": 16845, "\u0120packaging": 16846, "\u0120Workers": 16847, "hran": 16848, "\u0120Lebanon": 16849, "olesc": 16850, "\u0120punished": 16851, "\u0120Juan": 16852, "\u0120jam": 16853, "\u0120Document": 16854, "\u0120mapping": 16855, "icates": 16856, "\u0120inevitably": 16857, "\u0120vanilla": 16858, "\u0120Ton": 16859, "\u0120watches": 16860, "\u0120leagues": 16861, "\u0120initiated": 16862, "degree": 16863, "portion": 16864, "\u0120recalls": 16865, "\u0120ruin": 16866, "\u0120melt": 16867, "IAN": 16868, "\u0120hem": 16869, "Exp": 16870, "\u0120baking": 16871, "\u0120Colomb": 16872, "atible": 16873, "\u0120radius": 16874, "plug": 16875, "\u0120IF": 16876, "etically": 16877, "\u0120fict": 16878, "HER": 16879, "\u0120Tap": 16880, "atinum": 16881, "\u0120ink": 16882, "\u0120coh": 16883, "\u0120Wizard": 16884, "both": 16885, "tex": 16886, "\u0120spends": 16887, "\u0120Currently": 16888, "\u0120Pit": 16889, "\u0120neurons": 16890, "ignt": 16891, "\u0120rall": 16892, "\u0120buses": 16893, "building": 16894, "\u0120adjustments": 16895, "\u0120cried": 16896, "iblical": 16897, "atted": 16898, "\u0120Zion": 16899, "\u0120Matter": 16900, "\u0120meditation": 16901, "\u0120Dennis": 16902, "\u0120ours": 16903, "\u0120Tab": 16904, "\u0120rankings": 16905, "ortal": 16906, "\u0120advers": 16907, "\u0120surrender": 16908, "\u0120Gob": 16909, "cium": 16910, "omas": 16911, "imeter": 16912, "\u0120multiplayer": 16913, "\u0120heroin": 16914, "\u0120optimistic": 16915, "\u0120indicator": 16916, "\u0120Brig": 16917, "\u0120grocery": 16918, "\u0120applicant": 16919, "\u0120Rocket": 16920, "vid": 16921, "Exception": 16922, "pent": 16923, "\u0120organizing": 16924, "\u0120encounters": 16925, "\u0120TOD": 16926, "\u0120jewel": 16927, "Save": 16928, "\u0120Christie": 16929, "\u0120heating": 16930, "\u0120lazy": 16931, "\u0120CP": 16932, "\u0120cousin": 16933, "Config": 16934, "\u0120regener": 16935, "\u0120nearest": 16936, "\u0120achieving": 16937, "ENS": 16938, "throw": 16939, "\u0120Richmond": 16940, "antle": 16941, "2002": 16942, "\u0120anten": 16943, "bird": 16944, "133": 16945, "\u0120narc": 16946, "raint": 16947, "unny": 16948, "\u0120Hispanic": 16949, "ournaments": 16950, "\u0120prophe": 16951, "\u0120Thailand": 16952, "\u0120Ti": 16953, "\u0120injection": 16954, "\u0120inherit": 16955, "ravis": 16956, "\u0120medi": 16957, "\u0120whoever": 16958, "\u0120DEBUG": 16959, "GP": 16960, "\u0120Hud": 16961, "Card": 16962, "prom": 16963, "\u0120por": 16964, "\u0120overhead": 16965, "Law": 16966, "\u0120violate": 16967, "\u0120heated": 16968, "\u0120descriptions": 16969, "\u0120achievements": 16970, "\u0120Beer": 16971, "\u0120Quant": 16972, "Was": 16973, "\u0120eighth": 16974, "\u0120Iv": 16975, "\u0120specialized": 16976, "UPDATE": 16977, "\u0120Delta": 16978, "Pop": 16979, "Jul": 16980, "\u0120Ask": 16981, "ophy": 16982, "\u0120newsletters": 16983, "\u0120Tool": 16984, "\u0120gard": 16985, "\u0120Confeder": 16986, "\u0120GMT": 16987, "\u0120Abbott": 16988, "\u0120immunity": 16989, "\u0120VM": 16990, "Islam": 16991, "\u0120implicit": 16992, "wd": 16993, "\u01201944": 16994, "ravity": 16995, "ometric": 16996, "\u0120surviving": 16997, "urai": 16998, "\u0120Prison": 16999, "\u0120rust": 17000, "\u0120Sketch": 17001, "\u0120bees": 17002, "\u0120Theory": 17003, "\u0120merit": 17004, "Tex": 17005, "chat": 17006, "\u0120mim": 17007, "\u0120paste": 17008, "\u0120Koch": 17009, "\u0120ignorance": 17010, "\u0120Shoot": 17011, "\u0120basement": 17012, "United": 17013, "\u0120Advis": 17014, "height": 17015, "\u0120foster": 17016, "\u0120detain": 17017, "information": 17018, "\u0120neural": 17019, "';": 17020, "\u0120proves": 17021, "allery": 17022, "\u0120invitation": 17023, "umbers": 17024, "\u0120cattle": 17025, "\u0120bicycle": 17026, "zi": 17027, "\u0120consultant": 17028, "\u0120apology": 17029, "\u0120Tiger": 17030, "\u0120123": 17031, "999": 17032, "\u0120individually": 17033, "rt": 17034, "igion": 17035, "\u0120Brazilian": 17036, "\u0120disturb": 17037, "\u0120entrepreneurs": 17038, "\u0120forests": 17039, "cerpt": 17040, "plates": 17041, "pher": 17042, "clipse": 17043, "\u0120twitter": 17044, "\u0120acids": 17045, "ographical": 17046, "hum": 17047, "\u0120Bald": 17048, "ifully": 17049, "\u0120compiler": 17050, "\u0120DA": 17051, "\u0120donor": 17052, "asi": 17053, "\u0120tribal": 17054, "lash": 17055, "\u0120Config": 17056, "\u0120applicants": 17057, "\u0120salaries": 17058, "135": 17059, "Putin": 17060, "\u0120Focus": 17061, "irs": 17062, "\u0120misconduct": 17063, "\u0120Haz": 17064, "\u0120eaten": 17065, "Mobile": 17066, "Muslim": 17067, "\u0120Marcus": 17068, "viol": 17069, "\u0120favorable": 17070, "\u0120stub": 17071, "adin": 17072, "\u0120Hob": 17073, "\u0120faithful": 17074, "\u0120electronics": 17075, "\u0120vacuum": 17076, "wait": 17077, "backed": 17078, "economic": 17079, "dist": 17080, "\u0120tenure": 17081, "\u0120sincere": 17082, "\u0120Together": 17083, "\u0120Wave": 17084, "\u0120progression": 17085, "\u0120denying": 17086, "\u0120distress": 17087, "braska": 17088, "third": 17089, "\u0120mixing": 17090, "\u0120colonial": 17091, "\u0120privately": 17092, "\u0120unrest": 17093, "aternity": 17094, "\u0120premises": 17095, "anti": 17096, "gregation": 17097, "\u0120licence": 17098, "\u0120Hind": 17099, "\u0120Samuel": 17100, "\u0120convincing": 17101, "\u0120Ace": 17102, "\u0120Rust": 17103, "\u0120Netanyahu": 17104, "\u0120handles": 17105, "\u0120Patch": 17106, "oriented": 17107, "aho": 17108, "\u0120Gonz": 17109, "\u0120hackers": 17110, "claimer": 17111, "\u0120customs": 17112, "\u0120Gran": 17113, "fighters": 17114, "\u0120luc": 17115, "\u0120manuscript": 17116, "arenthood": 17117, "\u0120devil": 17118, "\u0120warriors": 17119, "\u0120offenders": 17120, "William": 17121, "\u0120holidays": 17122, "\u0120nightmare": 17123, "\u0120lever": 17124, "ifferent": 17125, "Stat": 17126, "\u0120exhibition": 17127, "puted": 17128, "\u0120Pure": 17129, "\u0120alpha": 17130, "\u0120enthusiasm": 17131, "\u0120Representatives": 17132, "EAR": 17133, "\u0120Typ": 17134, "\u0120wheat": 17135, "\u0120Alf": 17136, "\u0120correction": 17137, "\u0120evangel": 17138, "ATT": 17139, "Miss": 17140, "\u0120soup": 17141, "\u0120implied": 17142, "param": 17143, "\u0120sexy": 17144, "\u0120Lux": 17145, "\u0120republic": 17146, "patch": 17147, "ablish": 17148, "\u0120icons": 17149, "\u0120fathers": 17150, "\u0120GET": 17151, "\u0120Carib": 17152, "\u0120regulated": 17153, "\u0120Cohen": 17154, "\u0120Bobby": 17155, "\u0120ner": 17156, "\u0120bent": 17157, "ventory": 17158, "\u0120Along": 17159, "\u0120EST": 17160, "\u0120Wallace": 17161, "\u0120murders": 17162, "rise": 17163, "kell": 17164, "\u0120Commonwealth": 17165, "\u0120nasty": 17166, "eta": 17167, "\u0120MIT": 17168, "\u0120administered": 17169, "\u0120genuinely": 17170, "Editor": 17171, "nick": 17172, "\u0120hydro": 17173, "********************************": 17174, "\u0120Ble": 17175, "\u0120fines": 17176, "\u0120gorge": 17177, "ausible": 17178, "rh": 17179, "\u0120apple": 17180, "mentioned": 17181, "\u0120rope": 17182, "otyp": 17183, "HR": 17184, "\u0120disappointing": 17185, "\u0120cage": 17186, "nik": 17187, "\u0120doubts": 17188, "\u0120FREE": 17189, "prints": 17190, "\u0120MUST": 17191, "\u0120vendors": 17192, "\u0120Inqu": 17193, "\u0120liberals": 17194, "\u0120contractor": 17195, "\u0120upside": 17196, "children": 17197, "\u0120tricky": 17198, "\u0120regulators": 17199, "charged": 17200, "liter": 17201, "\u0120***": 17202, "\u0120rebell": 17203, "lang": 17204, "\u0120locals": 17205, "\u0120physicians": 17206, "\u0120hey": 17207, "arse": 17208, "tm": 17209, "\u0120Lex": 17210, "\u0120behavioral": 17211, "successful": 17212, "FX": 17213, "\u0120brick": 17214, "ovic": 17215, "\u0120conform": 17216, "\u0120reviewing": 17217, "\u0120insights": 17218, "\u0120biology": 17219, "\u0120Remove": 17220, "\u0120Extra": 17221, "\u0120committing": 17222, "induced": 17223, "ignty": 17224, "igm": 17225, "\u0120atomic": 17226, "Common": 17227, "\u0120EM": 17228, "\u0120Pere": 17229, "\u0120Items": 17230, "eh": 17231, "\u0120preserved": 17232, "\u0120Hood": 17233, "\u0120prisoner": 17234, "\u0120bankruptcy": 17235, "\u0120gren": 17236, "ushes": 17237, "\u0120exploitation": 17238, "\u0120signatures": 17239, "\u0120finan": 17240, "],\"": 17241, "\u0120MR": 17242, "\u0120meg": 17243, "remlin": 17244, "\u0120musicians": 17245, "\u0120selecting": 17246, "\u0120examining": 17247, "INK": 17248, "lated": 17249, "Hi": 17250, "\u0120artic": 17251, "\u0120pets": 17252, "\u0120impair": 17253, "\u0120MAN": 17254, "\u0120tablets": 17255, "include": 17256, "Range": 17257, "\u0120caut": 17258, "\u0120logs": 17259, "\u0120mounting": 17260, "\u0120unaware": 17261, "\u0120dynamics": 17262, "\u0120Palestine": 17263, "\u0120Quarter": 17264, "\u0120Purple": 17265, "\u0120ma": 17266, "\u0120Import": 17267, "\u0120collections": 17268, "ciation": 17269, "\u0120successor": 17270, "\u0120clone": 17271, "\u0120aiming": 17272, "\u0120possessed": 17273, "\u0120sticking": 17274, "\u0120shaking": 17275, "\u0120locate": 17276, "\u0120Hockey": 17277, "Turn": 17278, "170": 17279, "\u0120fifteen": 17280, "\u0120Harrison": 17281, "\u0120continuously": 17282, "\u0120TC": 17283, "\u0120Valent": 17284, "\u0120Rescue": 17285, "\u0120bypass": 17286, "amount": 17287, "\u0120mast": 17288, "\u0120protects": 17289, "\u0120artistic": 17290, "\u0120sometime": 17291, "\u0120shoe": 17292, "\u0120shouted": 17293, "ificant": 17294, "etitive": 17295, "\u0120Register": 17296, "\u0120Jin": 17297, "\u0120concentrated": 17298, "lington": 17299, "onies": 17300, "\u0120generator": 17301, "yrim": 17302, "\u0120Armen": 17303, "\u0120clearing": 17304, "ido": 17305, "\u0120TW": 17306, "alph": 17307, "\u0120ladies": 17308, "Hard": 17309, "\u0120dialog": 17310, "\u0120inputs": 17311, "\u00e6\u013e": 17312, "\u0120poses": 17313, "\u0120slots": 17314, "\u0120Premium": 17315, "\u0120leaks": 17316, "\u0120bosses": 17317, "\u0120113": 17318, "course": 17319, "Acc": 17320, "\u0120Newton": 17321, "\u0120Austria": 17322, "\u0120Mage": 17323, "\u0120teaches": 17324, "abad": 17325, "\u0120wears": 17326, "\u0120cyl": 17327, "\u0120curse": 17328, "\u0120Sales": 17329, "\u0120Wings": 17330, "\u0120psy": 17331, "\u0120gaps": 17332, "\u0120Iceland": 17333, "\u0120Pinterest": 17334, "\u0120landlord": 17335, "\u0120definitions": 17336, "\u0120Ker": 17337, "\u0120sufficiently": 17338, "\u0120Pence": 17339, "\u0120Architect": 17340, "\u0120surpass": 17341, "\u0120114": 17342, "\u0120superhero": 17343, "\u0120Disease": 17344, "\u0120priests": 17345, "\u0120Culture": 17346, "\u0120definitive": 17347, "\u0120secretly": 17348, "\u0120Dance": 17349, "install": 17350, "chief": 17351, "\u0120Jessica": 17352, "Would": 17353, "Updated": 17354, "\u0120locker": 17355, "\u0120Kay": 17356, "\u0120memorial": 17357, "\u00e8\u00a6": 17358, "fat": 17359, "\u0120disgu": 17360, "\u0120flavors": 17361, "\u0120Baseball": 17362, "\u0120Resistance": 17363, "\u0120kicks": 17364, "\u0120env": 17365, "\u0120teenagers": 17366, "Dark": 17367, "\u0120CAR": 17368, "\u0120halt": 17369, "\u0120LG": 17370, "\u0120Gabriel": 17371, "\u0120fever": 17372, "\u0120satur": 17373, "\u0120mall": 17374, "\u0120affiliate": 17375, "\u0120Sleep": 17376, "\u0120Specific": 17377, "\u0120Vel": 17378, "\u0120jar": 17379, "\u0120Sacred": 17380, "\u0120Edwards": 17381, "\u0120ACL": 17382, "\u0120retained": 17383, "\u0120Giant": 17384, "\u0120limitation": 17385, "inces": 17386, "\u0120refusal": 17387, "\u0120Tale": 17388, "\u0120Butler": 17389, "\u0120accidents": 17390, "\u0120CSS": 17391, "\u0120imported": 17392, "\u0120Copy": 17393, "\u00ce\u00b1": 17394, "ERT": 17395, "zel": 17396, "\u0120divisions": 17397, "hots": 17398, "\u0120Alb": 17399, "\u0120DS": 17400, "Loader": 17401, "Washington": 17402, "atisf": 17403, "\u0120Creative": 17404, "\\.": 17405, "\u0120Autom": 17406, "redict": 17407, "\u0120receptor": 17408, "\u0120Carlos": 17409, "Method": 17410, "oka": 17411, "\u0120malicious": 17412, "\u0120stepping": 17413, ",[": 17414, "\u0120Dad": 17415, "\u0120attraction": 17416, "\u0120Effects": 17417, "\u0120Pirate": 17418, "\u0120Cer": 17419, "\u0120Industry": 17420, "\u0120Rud": 17421, "\u0120charter": 17422, "\u0120dining": 17423, "\u0120insists": 17424, "\u0120configure": 17425, "\u0120(#": 17426, "\u0120Simple": 17427, "\u0120Scroll": 17428, "UTC": 17429, "175": 17430, "\u0120Kon": 17431, "\u0120marketplace": 17432, "\u0120\u00e3\u0124": 17433, "\u0120refres": 17434, "\u0120gates": 17435, "erred": 17436, "\u0120Pod": 17437, "\u0120behave": 17438, "Frank": 17439, "node": 17440, "\u0120endorsed": 17441, "hett": 17442, "asive": 17443, "\u0120Homeland": 17444, "\u0120rides": 17445, "\u0120Leave": 17446, "erness": 17447, "\u0120flooding": 17448, "AFP": 17449, "\u0120risen": 17450, "\u0120continually": 17451, "\u0120unanim": 17452, "\u0120Contract": 17453, "\u0120Pas": 17454, "\u0120guided": 17455, "\u0120Chile": 17456, "bd": 17457, "\u0120succ": 17458, "ptic": 17459, "\u0120committees": 17460, "\u0120Luther": 17461, "\u0120Anyone": 17462, "\u0120sab": 17463, "124": 17464, "\u0120pixel": 17465, "\u0120Bak": 17466, "\u0120Tag": 17467, "\u0120Bennett": 17468, "Enter": 17469, "small": 17470, "\u0120Presidential": 17471, "\u0120pul": 17472, "\u0120contrace": 17473, "archive": 17474, "\u0120coastal": 17475, "\u0120Kids": 17476, "192": 17477, "\u00e2\u0122\u00b2": 17478, "icky": 17479, "INGTON": 17480, "\u0120wolf": 17481, "\u0120Stalin": 17482, "Tur": 17483, "idget": 17484, "amas": 17485, "\u0120Unless": 17486, "\u0120sponsor": 17487, "\u0120morph": 17488, "\u0120Choose": 17489, "\u0120runner": 17490, "\u0120unbel": 17491, "\u0120mud": 17492, "\u0120Mana": 17493, "\u0120dubbed": 17494, "\u0120godd": 17495, "urers": 17496, "window": 17497, "\u0120relied": 17498, "\u0120celebrating": 17499, "osc": 17500, "\u0120135": 17501, "\u0120lobbying": 17502, "\u0120incomplete": 17503, "\u0120restriction": 17504, "\u0120incap": 17505, "itus": 17506, "\u0120expectation": 17507, "\u0120Apollo": 17508, "\u0120intens": 17509, "\u0120sync": 17510, "GH": 17511, "\u0120manipulation": 17512, "BY": 17513, "\u0120spear": 17514, "\u0120breasts": 17515, "\u0120volcan": 17516, "ilia": 17517, "Material": 17518, "\u0120formats": 17519, "\u0120Bast": 17520, "\u0120parliamentary": 17521, "\u0120snake": 17522, "\u0120servants": 17523, "\u0120Trudeau": 17524, "\u0120Grim": 17525, "\u0120Arabic": 17526, "\u0120SCP": 17527, "\u0120Boys": 17528, "station": 17529, "\u0120prospective": 17530, "orde": 17531, "initialized": 17532, "\u0120bored": 17533, "ABLE": 17534, "\u0120accessed": 17535, "\u0120taxi": 17536, "\u0120Shell": 17537, "aiden": 17538, "ursed": 17539, "inates": 17540, "\u0120Insurance": 17541, "\u0120Pete": 17542, "September": 17543, "650": 17544, "\u0120adventures": 17545, "\u0120Cover": 17546, "\u0120tribute": 17547, "\u0120sketch": 17548, "\u0120empower": 17549, "\u0120\u00d8": 17550, "\u0120Glenn": 17551, "\u0120Daw": 17552, "=\\\"": 17553, "\u0120Politics": 17554, "\u0120guides": 17555, "\u0120dioxide": 17556, "\u0120Gore": 17557, "\u0120Bright": 17558, "\u0120Sierra": 17559, "\u0120valued": 17560, "cond": 17561, "\u0120pointer": 17562, "Select": 17563, "\u0120risky": 17564, "\u0120absorb": 17565, "images": 17566, "\u0120refuses": 17567, "\u0120bonuses": 17568, "___": 17569, "\u0120hilar": 17570, "\u0120Features": 17571, "220": 17572, "\u0120Collector": 17573, "Foot": 17574, "\u01201964": 17575, "culus": 17576, "\u0120dawn": 17577, "\u0120workout": 17578, "\u0120LO": 17579, "\u0120philosophical": 17580, "\u0120Sandy": 17581, "\u0120Youth": 17582, "\u0120liable": 17583, "Af": 17584, "blue": 17585, "\u0120overturn": 17586, "lessness": 17587, "\u0120Tribune": 17588, "\u0120Ing": 17589, "\u0120factories": 17590, "\u0120catches": 17591, "\u0120prone": 17592, "\u0120matrix": 17593, "\u0120login": 17594, "\u0120inacc": 17595, "\u0120exert": 17596, "sys": 17597, "\u0120needle": 17598, "\u0120Qur": 17599, "\u0120notified": 17600, "oulder": 17601, "tx": 17602, "\u0120reminds": 17603, "\u0120publishers": 17604, "\u0120nort": 17605, "\u0120git": 17606, "\u0120flies": 17607, "\u0120Emily": 17608, "\u0120flowing": 17609, "\u0120Alien": 17610, "\u0120Strateg": 17611, "\u0120hardest": 17612, "\u0120modification": 17613, "API": 17614, "\u0120MY": 17615, "\u0120crashes": 17616, "stairs": 17617, "number": 17618, "\u0120urging": 17619, "channel": 17620, "\u0120Falcon": 17621, "\u0120inhabitants": 17622, "\u0120terrifying": 17623, "\u0120utilize": 17624, "\u0120banner": 17625, "\u0120cigarettes": 17626, "\u0120senses": 17627, "\u0120Holmes": 17628, "\u0120practition": 17629, "\u0120Phillips": 17630, "otto": 17631, "\u0120compile": 17632, "Model": 17633, "\u0120Ko": 17634, "\u0120[]": 17635, "Americans": 17636, "\u0120Terms": 17637, "\u0120medications": 17638, "\u0120Ana": 17639, "\u0120fundamentally": 17640, "\u0120Notice": 17641, "\u0120weaker": 17642, "\u01200000": 17643, "\u0120garlic": 17644, "\u0120outbreak": 17645, "\u0120economist": 17646, "\u0120Birth": 17647, "\u0120obstacles": 17648, "arcer": 17649, "\u0120Orthodox": 17650, "\u0120placebo": 17651, "\u0120Crew": 17652, "aspberry": 17653, "\u0120Angels": 17654, "\u0120discharge": 17655, "\u0120destructive": 17656, "117": 17657, "\u0120Rising": 17658, "\u0120dairy": 17659, "late": 17660, "\u0120collision": 17661, "\u0120Tigers": 17662, "eanor": 17663, "ocumented": 17664, "\u0120Invalid": 17665, "\u0120dont": 17666, "\u0120Liter": 17667, "\u0120Va": 17668, "\u0120hydrogen": 17669, "\u0120variants": 17670, "\u0120Browns": 17671, "\u01201965": 17672, "\u0120indigenous": 17673, "\u0120trades": 17674, "\u0120remainder": 17675, "\u0120swept": 17676, "\u0120Impact": 17677, "\u0120redist": 17678, "\u0120unint": 17679, "graduate": 17680, "\u00e3\u0125\u0137": 17681, "\u0120WILL": 17682, "\u00e3\u0123\u00ae\u00e7": 17683, "\u0120Critical": 17684, "\u0120fisher": 17685, "\u0120vicious": 17686, "\u0120reversed": 17687, "Year": 17688, "\u0120Sox": 17689, "\u0120shootings": 17690, "\u0120filming": 17691, "\u0120touchdowns": 17692, "aires": 17693, "mel": 17694, "\u0120grandfather": 17695, "\u0120affection": 17696, "ingle": 17697, "\u0120overly": 17698, "Additional": 17699, "\u0120supreme": 17700, "\u0120Grad": 17701, "\u0120sporting": 17702, "\u0120mercy": 17703, "\u0120Brooks": 17704, "ounty": 17705, "\u0120performs": 17706, "\u0120tightly": 17707, "\u0120demons": 17708, "\u0120killings": 17709, "\u0120faction": 17710, "\u0120Nova": 17711, "auts": 17712, "\u0120undoubtedly": 17713, "arin": 17714, "\u0120underway": 17715, "rak": 17716, "\u0120liv": 17717, "\u0120Region": 17718, "\u0120briefing": 17719, "sers": 17720, "cloud": 17721, "\u0120Mik": 17722, "usp": 17723, "\u0120prediction": 17724, "azor": 17725, "\u0120portable": 17726, "\u0120Gand": 17727, "\u0120presenting": 17728, "\u01201080": 17729, "\u00c2\u00bb": 17730, "ushi": 17731, "\u0120Spark": 17732, "thereum": 17733, "\u0120justification": 17734, "\u0120Ny": 17735, "\u0120contractors": 17736, "mingham": 17737, "\u0120Style": 17738, "\u00e5\u0127": 17739, "\u0120Chronicles": 17740, "\u0120Picture": 17741, "\u0120proving": 17742, "\u0120wives": 17743, "sett": 17744, "\u0120molecules": 17745, "\u0120Fairy": 17746, "\u0120consisting": 17747, "\u0120pier": 17748, "alone": 17749, "inition": 17750, "\u0120nucle": 17751, "json": 17752, "\u0120gotta": 17753, "\u0120mobil": 17754, "\u0120verbal": 17755, "arium": 17756, "\u0120monument": 17757, "ucked": 17758, "\u0120256": 17759, "Tech": 17760, "minecraft": 17761, "\u0120Track": 17762, "\u0120tile": 17763, "\u0120compatibility": 17764, "asis": 17765, "\u0120sadd": 17766, "\u0120instructed": 17767, "\u0120Mueller": 17768, "\u0120lethal": 17769, "\u0120hormone": 17770, "\u0120orche": 17771, "else": 17772, "\u0120skelet": 17773, "\u0120entertaining": 17774, "\u0120minimize": 17775, "again": 17776, "\u0120undergo": 17777, "\u0120constraints": 17778, "\u0120cigarette": 17779, "\u0120Islamist": 17780, "\u0120travels": 17781, "\u0120Panthers": 17782, "lings": 17783, "Care": 17784, "\u0120lawsuits": 17785, "uras": 17786, "\u0120cryst": 17787, "\u0120lowered": 17788, "\u0120aerial": 17789, "\u0120combinations": 17790, "\u0120haun": 17791, "\u0120cha": 17792, "\u0120vine": 17793, "\u0120quantities": 17794, "\u0120linking": 17795, "bank": 17796, "\u0120soy": 17797, "Bill": 17798, "\u0120Angela": 17799, "\u0120recipient": 17800, "\u0120Protest": 17801, "\u0120socket": 17802, "\u0120solidarity": 17803, "\u0120\u00e2\u0128": 17804, "mill": 17805, "\u0120varies": 17806, "\u0120Pakistani": 17807, "Dragon": 17808, "\u0120une": 17809, "\u0120horizon": 17810, "\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142": 17811, "\u0120provinces": 17812, "\u0120frankly": 17813, "\u0120enacted": 17814, "notes": 17815, "['": 17816, "\u0120192": 17817, "ocracy": 17818, "\u0120endorsement": 17819, "\u0120overtime": 17820, "True": 17821, "Lab": 17822, "licted": 17823, "\u0120DNC": 17824, "\u0120beats": 17825, "\u0120Jamie": 17826, "152": 17827, "\u0120INT": 17828, "Contact": 17829, "\u0120accounted": 17830, "hash": 17831, "\u0120Packers": 17832, "pires": 17833, "\u0120lesbian": 17834, "\u0120amendments": 17835, "\u0120hopeful": 17836, "\u0120Finland": 17837, "\u0120spotlight": 17838, "\u0120configured": 17839, "\u0120troubled": 17840, "\u0120gaze": 17841, "\u0120Calgary": 17842, "\u0120reliability": 17843, "\u0120insurg": 17844, "swer": 17845, "buy": 17846, "\u0120Skin": 17847, "\u0120pixels": 17848, "\u0120handgun": 17849, "\u0120paras": 17850, "\u0120categor": 17851, "\u0120EL": 17852, "\u0120Rex": 17853, "Indeed": 17854, "\u0120kinda": 17855, "\u0120conjunction": 17856, "\u0120Bryan": 17857, "\u0120Manufact": 17858, "yang": 17859, "Plus": 17860, "SQL": 17861, "ishment": 17862, "\u0120dominate": 17863, "\u0120nail": 17864, "\u0120oath": 17865, "\u0120erupt": 17866, "\u0120Fine": 17867, "itbart": 17868, "\u0120Chip": 17869, "\u0120Abd": 17870, "\u0120Nam": 17871, "\u0120buyer": 17872, "\u0120dissent": 17873, "Leaks": 17874, "Contin": 17875, "\u0120rider": 17876, "\u0120Someone": 17877, "\u0120illusion": 17878, "cin": 17879, "\u0120Boeing": 17880, "\u0120inadequ": 17881, "ovation": 17882, "iants": 17883, "\u0120rebuild": 17884, "450": 17885, "\u0120Destiny": 17886, "SW": 17887, "\u0120Till": 17888, "Hit": 17889, "iaz": 17890, "\u0120Bangl": 17891, "achers": 17892, "\u0120Reform": 17893, "\u0120segments": 17894, "\u0120systematic": 17895, "dc": 17896, "\u0120Conservatives": 17897, "\u0120portal": 17898, "hor": 17899, "\u0120Dragonbound": 17900, "\u0120dragged": 17901, "omo": 17902, "\u0120thee": 17903, "advert": 17904, "\u0120Reports": 17905, "\u0120Et": 17906, "\u0120barrels": 17907, "August": 17908, "\u0120comparisons": 17909, "\u0120hex": 17910, "\u0120anthrop": 17911, "\"[": 17912, "borough": 17913, "abi": 17914, "\u0120pictured": 17915, "playing": 17916, "\u0120Address": 17917, "\u0120Mirror": 17918, "Smith": 17919, "\u0120tires": 17920, "\u0120NPR": 17921, "AAAA": 17922, "\u0120classification": 17923, "\u0120Than": 17924, "\u0120Harm": 17925, "\u0120RA": 17926, "\u0120rejection": 17927, "mination": 17928, "\u0120ranged": 17929, "\u0120Falls": 17930, "DI": 17931, "Host": 17932, "\u00e3\u0124\u00b4": 17933, "\u0120Example": 17934, "listed": 17935, "thirds": 17936, "\u0120safegu": 17937, "brand": 17938, "\u0120probable": 17939, "Canada": 17940, "ITION": 17941, "\u0120Qaeda": 17942, "\u0120chick": 17943, "\u0120imports": 17944, "hit": 17945, "loc": 17946, "WW": 17947, "\u0120blew": 17948, "\u0120anytime": 17949, "\u0120wholes": 17950, "iked": 17951, "\u0120calculation": 17952, "create": 17953, "\u0120Ori": 17954, "\u0120upgraded": 17955, "\u0120appar": 17956, "utory": 17957, "\u0120Mol": 17958, "Brit": 17959, "\u0120Jong": 17960, "INAL": 17961, "\u0120Starting": 17962, "\u0120dice": 17963, "urtle": 17964, "\u0120relying": 17965, "closure": 17966, "\u0120profitable": 17967, "\u0120slaughter": 17968, "\u0120Manual": 17969, "caster": 17970, "\u0120\"$": 17971, "\u0120feather": 17972, "\u0120Simply": 17973, "ieves": 17974, "\u0120deterior": 17975, "\u0120PCI": 17976, "\u0120stamp": 17977, "\u0120flaws": 17978, "\u0120shade": 17979, "hammer": 17980, "\u0120passport": 17981, "\u0120conting": 17982, "amel": 17983, "\u0120observers": 17984, "\u0120neglect": 17985, "\u0120RB": 17986, "\u0120Brotherhood": 17987, "\u0120skeptical": 17988, "family": 17989, "usk": 17990, "\u0120emotionally": 17991, "\u00e2\u013b": 17992, "\u0120Beta": 17993, "asonable": 17994, "idity": 17995, "\u0120Mul": 17996, "\u0120kicking": 17997, "\u0120Carm": 17998, "ollah": 17999, "VERTIS": 18000, "\u0120Athen": 18001, "\u0120ladder": 18002, "\u0120Bullet": 18003, "\u00e5\u00a3": 18004, "0001": 18005, "\u0120Wildlife": 18006, "\u0120Mask": 18007, "\u0120Nan": 18008, "Rev": 18009, "\u0120unacceptable": 18010, "legal": 18011, "\u0120crowded": 18012, "agi": 18013, "\u0120Cox": 18014, "je": 18015, "\u0120morality": 18016, "\u0120fuels": 18017, "\u0120cables": 18018, "\u0120mankind": 18019, "\u0120Caribbean": 18020, "\u0120anchor": 18021, "\u0120byte": 18022, "\u0120Often": 18023, "\u0120Oz": 18024, "\u0120crafted": 18025, "\u0120historian": 18026, "\u0120Wu": 18027, "\u0120towers": 18028, "\u0120Citizens": 18029, "\u0120helm": 18030, "\u0120credentials": 18031, "\u0120singular": 18032, "\u0120Jesse": 18033, "\u0120tackles": 18034, "\u0120contempt": 18035, "\u0120afore": 18036, "\u0120Shadows": 18037, "\u0120nil": 18038, "\u0120urgent": 18039, "apple": 18040, "blood": 18041, "\u0120von": 18042, "\u0120offline": 18043, "\u0120breathe": 18044, "\u0120jumps": 18045, "\u0120irrelevant": 18046, "oxic": 18047, "omal": 18048, "important": 18049, "Jim": 18050, "\u0120gloves": 18051, "arming": 18052, "depth": 18053, "\u0120talents": 18054, "ookie": 18055, "\u0120SB": 18056, "\u0120palm": 18057, "uffs": 18058, "esta": 18059, "IGH": 18060, "\u0120canon": 18061, "\u0120Verizon": 18062, "\u0120Ple": 18063, "\u0120coupled": 18064, "velt": 18065, "\u0120fundraising": 18066, "\u0120Getting": 18067, "\u0120DLC": 18068, "\u0120mathematical": 18069, "\u0120HS": 18070, "\u0120Cardinals": 18071, "telling": 18072, "\u0120sponsors": 18073, "\u0120\u00cf": 18074, "\u0120Bulls": 18075, "option": 18076, "\u0120propose": 18077, "\u0120memorable": 18078, "\u0120embraced": 18079, "\u0120declining": 18080, "Health": 18081, "eda": 18082, "\u0120};": 18083, "\u0120spam": 18084, "mile": 18085, "\u0120pitcher": 18086, "\u0120Eight": 18087, "\u0120caring": 18088, "utic": 18089, "role": 18090, "\u0120airline": 18091, "ernandez": 18092, "\u0120Athlet": 18093, "\u0120certification": 18094, "uxe": 18095, "riger": 18096, "\u0120empir": 18097, "\u0120sensation": 18098, "\u0120dism": 18099, "\u0120bolt": 18100, "\u0120evolve": 18101, "House": 18102, "\u0120consultation": 18103, "\u0120Duty": 18104, "\u0120touches": 18105, "\u0120Nathan": 18106, "\u0120faint": 18107, "had": 18108, "\"(": 18109, "\u0120Consumer": 18110, "\u0120Extreme": 18111, "\u0120127": 18112, "\u0120Herm": 18113, "\u0120Sacrament": 18114, "izoph": 18115, "\u0120anxious": 18116, "ulously": 18117, "\u0120socially": 18118, "\u0120UTC": 18119, "\u0120solving": 18120, "\u0120Letter": 18121, "History": 18122, "educ": 18123, "Price": 18124, "));": 18125, "\u0120reload": 18126, "amic": 18127, "\u0120pork": 18128, "\u0120discourse": 18129, "\u0120tournaments": 18130, "airo": 18131, "\u0120Kur": 18132, "\u0120Costa": 18133, "\u0120violating": 18134, "\u0120interfere": 18135, "\u0120recreational": 18136, "uffle": 18137, "\u0120speeches": 18138, "\u0120needing": 18139, "\u0120remembers": 18140, "\u0120credited": 18141, "nia": 18142, "focused": 18143, "amera": 18144, "\u0120bru": 18145, "umbs": 18146, "\u0120Cuban": 18147, "\u0120preceding": 18148, "\u0120nonsense": 18149, "acial": 18150, "\u0120smartphones": 18151, "\u0120Stories": 18152, "Sports": 18153, "\u0120Emergency": 18154, "ouncing": 18155, "efined": 18156, "\u0120ber": 18157, "\u0120consulting": 18158, "\u0120masters": 18159, "heastern": 18160, ".\"[": 18161, "\u0120Running": 18162, "\u0120suscept": 18163, "\u0120Feng": 18164, "America": 18165, "prises": 18166, "stitial": 18167, "\u0120Weekly": 18168, "\u0120Greater": 18169, "modules": 18170, "ifter": 18171, "Graphics": 18172, "uler": 18173, "\u0120wholly": 18174, "\u0120suppress": 18175, "\u0120concealed": 18176, "\u0120happily": 18177, "\u0120accepts": 18178, "\u0120Enjoy": 18179, "\u0120rivers": 18180, "\u0120Except": 18181, "225": 18182, "\u0120NHS": 18183, "\u0120McConnell": 18184, "\u0120pussy": 18185, "ferred": 18186, "utable": 18187, "\u0120attain": 18188, "\u0120>=": 18189, "\u0120deposits": 18190, "rophic": 18191, "\u0120notorious": 18192, "\u0120Shaw": 18193, "ilitation": 18194, "\u0120epidemic": 18195, "allic": 18196, "\u0120smallest": 18197, "ovich": 18198, "\u0120accessories": 18199, "perties": 18200, "\u0120surplus": 18201, "\u0120Mech": 18202, "\u0120ambig": 18203, "\u0120Immigration": 18204, "\u0120chim": 18205, "eval": 18206, "\u0120practicing": 18207, "\u0120Mystery": 18208, "\u0120domains": 18209, "\u0120Silicon": 18210, "apps": 18211, "\u0120kilometers": 18212, "ea": 18213, "\u0120Smash": 18214, "\u0120warranty": 18215, "\u0120nost": 18216, "sil": 18217, "rev": 18218, "Jon": 18219, "\u0120Dublin": 18220, "\u0120tastes": 18221, "\u0120bout": 18222, "great": 18223, "error": 18224, "\u0120switches": 18225, "\u0120Bapt": 18226, "DO": 18227, "oki": 18228, "\u0120sourced": 18229, "produ": 18230, "\u0120attachment": 18231, "\u0120Issue": 18232, "\u0120Question": 18233, "Join": 18234, "\u0120fitted": 18235, "\u0120unlawful": 18236, "^^": 18237, "erek": 18238, "\u0120authentication": 18239, "\u0120stole": 18240, "\u0120accountability": 18241, "label": 18242, "Search": 18243, "\u0120albeit": 18244, "atican": 18245, "funded": 18246, "\u0120Adding": 18247, "\u0120IQ": 18248, "\u0120submar": 18249, "lit": 18250, "aque": 18251, "\u0120Learning": 18252, "\u0120integer": 18253, "Master": 18254, "\u0120Chrom": 18255, "\u0120premier": 18256, "Op": 18257, "\u0120Liu": 18258, "\u0120blessed": 18259, "\u0120Globe": 18260, "\u0120Response": 18261, "\u0120legitim": 18262, "\u0120Merkel": 18263, "\u0120disposal": 18264, "\u00c2\u00b4": 18265, "\u0120gauge": 18266, "peat": 18267, "\u0120induced": 18268, "\u0120questionable": 18269, "arthy": 18270, "\u0120Vit": 18271, "\u0120Feed": 18272, "Until": 18273, "Ut": 18274, "worthy": 18275, "RY": 18276, "\u0120Herald": 18277, "\u0120Hammer": 18278, "\u0120medal": 18279, "\u0120Rivers": 18280, "\u0120Hack": 18281, "\u0120clarify": 18282, "\u0120tracked": 18283, "\u0120autonomous": 18284, "\u0120tenant": 18285, "\u0120Qatar": 18286, "erie": 18287, "\u0120grim": 18288, "\u0120Monitor": 18289, "\u0120resistant": 18290, "\u0120Spec": 18291, "\u0120Wells": 18292, "NAS": 18293, "148": 18294, "\u0120miners": 18295, "iotics": 18296, "\u0120misses": 18297, "116": 18298, "gian": 18299, "git": 18300, "\u0120Eyes": 18301, "pres": 18302, "\u0120graduated": 18303, "\u0120angel": 18304, "\u0120synchron": 18305, "\u0120efficiently": 18306, "\u0120transmitted": 18307, "Harry": 18308, "\u0120globally": 18309, "ENCE": 18310, "\u0120Montana": 18311, "raged": 18312, "\u0120Prevention": 18313, "\u0120piss": 18314, "\u0120Ll": 18315, "\u0120shelf": 18316, "\u0120BJP": 18317, "\u0120Testament": 18318, "\u0120Late": 18319, "iker": 18320, "\u0120Happ": 18321, "\u0120Julian": 18322, "hall": 18323, "\u0120spont": 18324, "\u0120shutdown": 18325, "\u0120inconsistent": 18326, "\u0120subscribers": 18327, "\u0120skeleton": 18328, "\u0120Nebraska": 18329, "\u0120inspire": 18330, "\u0120Void": 18331, "Feed": 18332, "\u0120angles": 18333, "\u0120Springs": 18334, "\u0120benchmark": 18335, "\u0120vaccines": 18336, "izophren": 18337, "sexual": 18338, "uffed": 18339, "\u0120shine": 18340, "\u0120Kath": 18341, "\u0120gesture": 18342, "inea": 18343, "\u0120rip": 18344, "\u0120oppression": 18345, "\u0120conscience": 18346, "bt": 18347, "\u0120Lum": 18348, "\u0120incidence": 18349, "\u0120Fa": 18350, "wr": 18351, "\u0120mineral": 18352, "\u0120Spurs": 18353, "alky": 18354, "\u0120thunder": 18355, "\u0120opio": 18356, "Being": 18357, "\u0120Palm": 18358, "\u0120wasted": 18359, "\u0120lb": 18360, "iaries": 18361, "\u0120Initiative": 18362, "\u0120curric": 18363, "\u0120marker": 18364, "\u0120McL": 18365, "\u0120extensions": 18366, "\u0120Pv": 18367, "\u0120Arms": 18368, "\u0120offerings": 18369, "\u0120defenses": 18370, "\u0120vendor": 18371, "\u0120contradict": 18372, "\u0120Colin": 18373, "\u0120reddit": 18374, "\u0120peripher": 18375, "122": 18376, "\u0120sins": 18377, "Edit": 18378, "ICT": 18379, "Soft": 18380, "\u0120Shah": 18381, "\u0120administrator": 18382, "\u0120Trip": 18383, "\u0120pornography": 18384, "\u0120tuition": 18385, "inence": 18386, "\u0120Progress": 18387, "\u0120catalog": 18388, "\u0120suite": 18389, "\u0120hike": 18390, "\u0120reproductive": 18391, "engine": 18392, "\u0120drought": 18393, "\u0120Noah": 18394, "\u0120230": 18395, "\u0120dude": 18396, "\u0120relaxed": 18397, "\u0120partition": 18398, "\u0120participant": 18399, "\u0120telesc": 18400, "\u0120feas": 18401, "\u0120FF": 18402, "owner": 18403, "\u0120sweeping": 18404, "\u0120lenses": 18405, "\u0120matchup": 18406, "\u0120Repl": 18407, "ournals": 18408, "\u0120credible": 18409, "\u0120grandmother": 18410, "\u0120thermal": 18411, "\u0120subscribing": 18412, "\u0120identities": 18413, "colm": 18414, "UCT": 18415, "\u0120reluctant": 18416, "users": 18417, "\u0120Cort": 18418, "\u0120assisted": 18419, "OSS": 18420, "ATIONS": 18421, "ISH": 18422, "\u0120pharmaceutical": 18423, "icable": 18424, "adian": 18425, "\u0120Sonic": 18426, "\u0120Fury": 18427, "\u0120Mong": 18428, "AH": 18429, "\u0120Psychology": 18430, "\u0120phosph": 18431, "\u0120treats": 18432, "\u0143\u0136": 18433, "\u0120steadily": 18434, "\u0120Hello": 18435, "\u0120relates": 18436, "\u0120clue": 18437, "Expl": 18438, "auth": 18439, "\u0120revision": 18440, "\u0120eld": 18441, "osion": 18442, "\u0120bron": 18443, "144": 18444, "rikes": 18445, "\u0120mines": 18446, "\u0120blanket": 18447, "\u0120Fail": 18448, "eled": 18449, "\u0120Imagine": 18450, "\u0120Planned": 18451, "aic": 18452, "Request": 18453, "Mad": 18454, "\u0120Horse": 18455, "\u0120Eagle": 18456, "\u0120capac": 18457, "157": 18458, "\u0120ling": 18459, "\u0120Nice": 18460, "\u0120Parenthood": 18461, "minster": 18462, "ogs": 18463, "ensitive": 18464, "Nothing": 18465, "\u0120carn": 18466, "Fin": 18467, "\u0120PE": 18468, "\u0120rifles": 18469, "\u0120LP": 18470, "Sand": 18471, "\u0120guiActive": 18472, "\u0120tourist": 18473, "CNN": 18474, "\u0120unveiled": 18475, "\u0120predecessor": 18476, "}{": 18477, "uber": 18478, "\u0120offshore": 18479, "\u0120optical": 18480, "\u0120Rot": 18481, "\u0120Pearl": 18482, "eton": 18483, "\u0120stared": 18484, "\u0120farther": 18485, "atility": 18486, "contin": 18487, "\u0120Gy": 18488, "\u0120Foster": 18489, "\u0120Coc": 18490, "rients": 18491, "\u0120designing": 18492, "\u0120Economy": 18493, "ONG": 18494, "Women": 18495, "\u0120Nancy": 18496, "erver": 18497, "\u0120mascul": 18498, "\u0120casualties": 18499, "\u0120225": 18500, "\u0120Sullivan": 18501, "\u0120Choice": 18502, "\u0120aster": 18503, "ws": 18504, "\u0120hotels": 18505, "\u0120considerations": 18506, "\u0120couch": 18507, "\u0120Strip": 18508, "\u0120Gn": 18509, "\u0120manipulate": 18510, "lied": 18511, "\u0120synthetic": 18512, "\u0120assaulted": 18513, "\u0120offenses": 18514, "\u0120Drake": 18515, "\u0120impe": 18516, "October": 18517, "\u0120Heritage": 18518, "hl": 18519, "\u0120Blair": 18520, "Unlike": 18521, "\u0120grief": 18522, "\u0120450": 18523, "\u0120opted": 18524, "\u0120resignation": 18525, "ilo": 18526, "\u0120verse": 18527, "\u0120Tomb": 18528, "\u0120upt": 18529, "\u0120aired": 18530, "\u0120Hook": 18531, "\u0120MLB": 18532, "\u0120assumes": 18533, "outed": 18534, "\u0120Vers": 18535, "\u0120inferior": 18536, "\u0120bundle": 18537, "\u0120DNS": 18538, "ographer": 18539, "\u0120multip": 18540, "\u0120Souls": 18541, "\u0120illustrated": 18542, "\u0120tactic": 18543, "\u0120dressing": 18544, "\u0120duo": 18545, "Conf": 18546, "\u0120relent": 18547, "\u0120cant": 18548, "\u0120scarce": 18549, "\u0120candy": 18550, "\u0120CF": 18551, "\u0120affiliated": 18552, "\u0120sprint": 18553, "ylan": 18554, "\u0120Garcia": 18555, "\u0120junk": 18556, "Print": 18557, "exec": 18558, "Crit": 18559, "\u0120portrait": 18560, "iries": 18561, "\u0120OFF": 18562, "\u0120disputes": 18563, "WR": 18564, "Love": 18565, "\u00e3\u0123\u0126": 18566, "\u0120Reyn": 18567, "\u0120hipp": 18568, "opath": 18569, "\u0120floors": 18570, "\u0120Feel": 18571, "\u0120worries": 18572, "\u0120settlements": 18573, "\u0120Pos": 18574, "\u0120mosque": 18575, "\u0120finals": 18576, "\u0120crushed": 18577, "\u0120Probably": 18578, "\u0120Bot": 18579, "\u0120Mans": 18580, "\u0120Period": 18581, "\u0120sovereignty": 18582, "\u0120seller": 18583, "\u0120apost": 18584, "\u0120amateur": 18585, "\u0120dorm": 18586, "\u0120consuming": 18587, "\u0120armour": 18588, "\u0120Roose": 18589, "\u0120intensive": 18590, "\u0120eliminating": 18591, "\u0120Sunni": 18592, "\u0120Aleppo": 18593, "jin": 18594, "\u0120advise": 18595, "pal": 18596, "\u0120Halo": 18597, "\u0120descent": 18598, "\u0120simpler": 18599, "\u0120booth": 18600, "STR": 18601, "Later": 18602, "\u0120Cave": 18603, "===": 18604, "\u0120mol": 18605, "\u0120fist": 18606, "\u0120shotgun": 18607, "supp": 18608, "\u0120robbery": 18609, "Effect": 18610, "\u0120obscure": 18611, "\u0120Professional": 18612, "\u0120embassy": 18613, "\u0120militant": 18614, "\u0120incarcer": 18615, "\u0120generates": 18616, "\u0120launches": 18617, "\u0120administrators": 18618, "\u0120shaft": 18619, "\u0120circular": 18620, "\u0120freshman": 18621, "\u0120Wes": 18622, "\u0120Joel": 18623, "\u0120Drew": 18624, "\u0120Duncan": 18625, "\u0120Apparently": 18626, "sight": 18627, "\u0120Internal": 18628, "\u0120Individual": 18629, "\u0120FE": 18630, "\u0120bore": 18631, "\u0120Mt": 18632, "\u0120broadly": 18633, "\u0120Options": 18634, "ountain": 18635, "ipes": 18636, "\u0120Videos": 18637, "204": 18638, "\u0120hills": 18639, "\u0120simulation": 18640, "\u0120disappointment": 18641, "itan": 18642, "\u0120Laboratory": 18643, "\u0120upward": 18644, "\u0120boundary": 18645, "\u0120darker": 18646, "hart": 18647, "\u0120dominance": 18648, "Cong": 18649, "\u0120Oracle": 18650, "\u0120Lords": 18651, "\u0120scholarship": 18652, "\u0120Vincent": 18653, "ede": 18654, "\u0120Rah": 18655, "\u0120encourages": 18656, "rov": 18657, "\u0120quo": 18658, "\u0120premise": 18659, "\u0120Crisis": 18660, "\u0120Holocaust": 18661, "\u0120rhythm": 18662, "\u0120metric": 18663, "club": 18664, "\u0120transported": 18665, "\u0120nod": 18666, "\u0120Pist": 18667, "\u0120ancestors": 18668, "\u0120Freder": 18669, "thumbnails": 18670, "\u0120CE": 18671, "OND": 18672, "Phil": 18673, "venge": 18674, "\u0120Products": 18675, "castle": 18676, "\u0120qualifying": 18677, "\u0120Karen": 18678, "VERTISEMENT": 18679, "\u0120mighty": 18680, "\u0120explanations": 18681, "\u0120fixing": 18682, "Di": 18683, "\u0120declaring": 18684, "\u0120anonymity": 18685, "\u0120juven": 18686, "\u0120Nord": 18687, "\u0120Doom": 18688, "\u0120Actually": 18689, "Ok": 18690, "phis": 18691, "\u0120Desert": 18692, "\u0120116": 18693, "IK": 18694, "\u0120FM": 18695, "\u0120incomes": 18696, "VEL": 18697, "okers": 18698, "\u0120pecul": 18699, "\u0120lightweight": 18700, "gue": 18701, "\u0120accent": 18702, "\u0120increment": 18703, "\u0120Chan": 18704, "\u0120complaining": 18705, "\u0120Baghd": 18706, "\u0120midfielder": 18707, "\u0120overhaul": 18708, "Process": 18709, "\u0120Hollow": 18710, "\u0120Titans": 18711, "Small": 18712, "manuel": 18713, "\u0120Unity": 18714, "\u0120Events": 18715, "Sty": 18716, "\u0120disproportion": 18717, "nesty": 18718, "enes": 18719, "\u0120Cod": 18720, "\u0120demonstrations": 18721, "\u0120Crimson": 18722, "\u0120OH": 18723, "\u0120enrolled": 18724, "\u0120cel": 18725, "\u0120Brett": 18726, "\u0120aide": 18727, "\u0120heels": 18728, "\u0120broadband": 18729, "\u0120marking": 18730, "\u0120wizard": 18731, "\u0120NJ": 18732, "\u0120Chiefs": 18733, "\u0120ingredient": 18734, "\u0120dug": 18735, "\u0120Shut": 18736, "urchase": 18737, "endor": 18738, "\u0120farmer": 18739, "\u0120Goldman": 18740, "129": 18741, "155": 18742, "Order": 18743, "\u0120lion": 18744, "iably": 18745, "\u0120stain": 18746, "array": 18747, "ilitary": 18748, "\u0120FAQ": 18749, "\u0120exploded": 18750, "\u0120McCarthy": 18751, "\u0120Tweet": 18752, "\u0120Greens": 18753, "eking": 18754, "ln": 18755, "ensen": 18756, "\u0120motorcycle": 18757, "\u0120particle": 18758, "\u0120cholesterol": 18759, "Bron": 18760, "\u0120stair": 18761, "\u0120oxid": 18762, "\u0120desirable": 18763, "ibles": 18764, "\u0120theor": 18765, "forcing": 18766, "\u0120promotional": 18767, "ovo": 18768, "boot": 18769, "\u0120Bonus": 18770, "rawling": 18771, "\u0120shortage": 18772, "\u0120Psy": 18773, "\u0120recruited": 18774, "\u0120infants": 18775, "\u0120testosterone": 18776, "\u0120deduct": 18777, "\u0120distinctive": 18778, "\u0120firmware": 18779, "built": 18780, "145": 18781, "\u0120explored": 18782, "\u0120factions": 18783, "\u0120vide": 18784, "\u0120tattoo": 18785, "\u0120financially": 18786, "\u0120fatigue": 18787, "\u0120proceeding": 18788, "constitutional": 18789, "\u0120miser": 18790, "\u0120chairs": 18791, "gging": 18792, "ipple": 18793, "\u0120dent": 18794, "\u0120disreg": 18795, "\u00e7\u0136": 18796, "stant": 18797, "llo": 18798, "bps": 18799, "akening": 18800, "\u0120abnormal": 18801, "\u0120ERA": 18802, "\u00e5\u00a3\u00ab": 18803, "\u0120HBO": 18804, "\u0120MAR": 18805, "\u0120concess": 18806, "\u0120servant": 18807, "\u0120aspir": 18808, "lav": 18809, "\u0120Panel": 18810, "amo": 18811, "\u0120precip": 18812, "\u0120recordings": 18813, "\u0120proceeded": 18814, "\u0120colony": 18815, "\u0120Tang": 18816, "ablo": 18817, "\u0120stripped": 18818, "Left": 18819, "too": 18820, "\u0120potatoes": 18821, "\u0120finest": 18822, "%).": 18823, "\u0120crap": 18824, "\u0120Zach": 18825, "abases": 18826, "\u0120Goth": 18827, "\u0120billionaire": 18828, "wolf": 18829, "\u0120sanction": 18830, "SK": 18831, "\u0120logged": 18832, "Po": 18833, "eyed": 18834, "unal": 18835, "\u0120cricket": 18836, "\u0120armies": 18837, "\u0120uncovered": 18838, "Cloud": 18839, "\u00c3\u00b3n": 18840, "\u0120rebounds": 18841, "\u0120mes": 18842, "Oper": 18843, "Pac": 18844, "\u0120nationally": 18845, "\u0120inserted": 18846, "pict": 18847, "\u0120governance": 18848, "\u00d0\u00b8": 18849, "\u0120privileges": 18850, "GET": 18851, "\u0120favorites": 18852, "imity": 18853, "\u0120lover": 18854, "them": 18855, "empl": 18856, "\u0120gorgeous": 18857, "Ann": 18858, "\u0120slipped": 18859, "\u0120veto": 18860, "Bob": 18861, "\u0120slim": 18862, "ucc": 18863, "\u0120Fame": 18864, "uddenly": 18865, "\u0120denies": 18866, "\u0120Maur": 18867, "\u0120distances": 18868, "\u0120wanna": 18869, "tar": 18870, "\u0120SER": 18871, "\u0120\u00e2\u012a": 18872, "\u0120lemon": 18873, "athetic": 18874, "\u0120literal": 18875, "\u0120distinguished": 18876, "\u0120answering": 18877, "GI": 18878, "\u0120religions": 18879, "\u0120Philos": 18880, "\u0120Lay": 18881, "\u0120compos": 18882, "irements": 18883, "\u0120Kos": 18884, "inez": 18885, "rolling": 18886, "\u0120youngest": 18887, "andise": 18888, "\u0120Born": 18889, "\u0120altar": 18890, "amina": 18891, "\u0120Boot": 18892, "voc": 18893, "\u0120digging": 18894, "\u0120pressures": 18895, "\u0120len": 18896, "264": 18897, "\u0120assassination": 18898, "\u0120Birmingham": 18899, "\u0120Myth": 18900, "\u0120sovereign": 18901, "\u0120Artist": 18902, "\u0120Photograph": 18903, "\u0120depicted": 18904, "\u0120dispens": 18905, "orthy": 18906, "\u0120ambul": 18907, "integ": 18908, "\u0120Cele": 18909, "\u0120Tibet": 18910, "\u0120hierarchy": 18911, "\u0120cu": 18912, "\u0120preseason": 18913, "\u0120Peterson": 18914, "\u0120colours": 18915, "\u0120worrying": 18916, "\u0120backers": 18917, "\u0120Palmer": 18918, "\u0120\u00ce\u00bc": 18919, "\u0120contributor": 18920, "\u0120hearings": 18921, "\u0120urine": 18922, "\u0120\u00d9": 18923, "ourgeois": 18924, "Similar": 18925, "\u0120Zimmer": 18926, "something": 18927, "\u0120USC": 18928, "\u0120strengths": 18929, "\u0120FI": 18930, "\u0120logging": 18931, "Asked": 18932, "\u0120Thai": 18933, "inqu": 18934, "\u0120Walt": 18935, "\u0120crews": 18936, "itism": 18937, "301": 18938, "\u0120sharply": 18939, "umed": 18940, "\u0120redirect": 18941, "rators": 18942, "Inf": 18943, "\u0120Weapons": 18944, "\u0120teasp": 18945, "1999": 18946, "Live": 18947, "\u0120Especially": 18948, "\u0120Ster": 18949, "\u0120Veterans": 18950, "\u0120intro": 18951, "otherapy": 18952, "\u0120malware": 18953, "\u0120breeding": 18954, "\u0120molecular": 18955, "\u0120Route": 18956, "\u0120Comment": 18957, "ochem": 18958, "\u0120ain": 18959, "Season": 18960, "\u0120linebacker": 18961, "\u00c4\u00ab": 18962, "\u0120Economics": 18963, "esar": 18964, "\u0120Lives": 18965, "\u0120Emma": 18966, "\u0120kin": 18967, "\u0120Territ": 18968, "\u0120planted": 18969, "oton": 18970, "\u0120Butter": 18971, "\u0120Spons": 18972, "PER": 18973, "\u0120dungeon": 18974, "\u0120symbolic": 18975, "\u0120filmed": 18976, "\u0120diets": 18977, "\u0120concludes": 18978, "\u0120certainty": 18979, "\u0120Format": 18980, "\u0120strangers": 18981, "format": 18982, "\u0120Phase": 18983, "\u0120copied": 18984, "\u0120metres": 18985, "lda": 18986, "\u0120Users": 18987, "\u0120deliberate": 18988, "\u0120washed": 18989, "\u0120Lance": 18990, "imation": 18991, "\u0120improper": 18992, "\u0120Genesis": 18993, "ickr": 18994, "\u0120Kush": 18995, "\u0120realise": 18996, "\u0120embarrassing": 18997, "alking": 18998, "bucks": 18999, "\u0120verified": 19000, "\u0120outline": 19001, "years": 19002, "\u0120Income": 19003, "202": 19004, "\u0120zombies": 19005, "Final": 19006, "\u0120Millenn": 19007, "\u0120modifications": 19008, "\u0120Vision": 19009, "\u0120Moses": 19010, "verb": 19011, "iterranean": 19012, "\u0120Jet": 19013, "\u0120naval": 19014, "\u0120Agg": 19015, "\u0120url": 19016, "\u0120victories": 19017, "\u0120nonetheless": 19018, "\u0120injust": 19019, "\u0120Fact": 19020, "\u00e7\u013c": 19021, "\u0120insufficient": 19022, "review": 19023, "facebook": 19024, "\u0120negotiating": 19025, "\u0120guarantees": 19026, "imen": 19027, "utenberg": 19028, "\u0120gambling": 19029, "\u0120congr": 19030, "Loading": 19031, "\u0120nevertheless": 19032, "\u0120presidents": 19033, "\u0120Industrial": 19034, "\u0120118": 19035, "\u0120poured": 19036, "\u0120Tory": 19037, "\u0120175": 19038, "\u0120:=": 19039, "Scott": 19040, "angered": 19041, "Tok": 19042, "\u0120organizers": 19043, "Mat": 19044, "\u0120Growth": 19045, "\u0120adul": 19046, "\u0120ensures": 19047, "\u0120117": 19048, "\u00e9\u00be\u012f\u00e5": 19049, "\u0120massacre": 19050, "\u0120grades": 19051, "before": 19052, "ADVERTISEMENT": 19053, "\u0120Slow": 19054, "\u0120MMA": 19055, "\u00e2\u0122\u0136\"": 19056, "\u0120Vatican": 19057, "Qaeda": 19058, "\u0120owe": 19059, "6666": 19060, "\u0120Sorry": 19061, "\u0120Grass": 19062, "\u0120backgrounds": 19063, "\u0120exhausted": 19064, "\u0120clan": 19065, "\u0120compromised": 19066, "\u0120Elf": 19067, "\u0120Isaac": 19068, "enson": 19069, "Invest": 19070, "IFA": 19071, "\u0120interrupted": 19072, "\u00e3\u0125\u012b\u00e3\u0125\u00a9": 19073, "\u0120twisted": 19074, "\u0120Dragons": 19075, "Mode": 19076, "\u0120Kremlin": 19077, "\u0120fertil": 19078, "heres": 19079, "phan": 19080, "\u0120Node": 19081, "fed": 19082, "\u0120Orc": 19083, "\u0120unwilling": 19084, "Cent": 19085, "\u0120priorit": 19086, "\u0120graduates": 19087, "\u0120subjective": 19088, "\u0120issuing": 19089, "\u0120Lt": 19090, "\u0120viewer": 19091, "\u0120woke": 19092, "Thus": 19093, "brook": 19094, "\u0120depressed": 19095, "\u0120bracket": 19096, "\u0120Gor": 19097, "\u0120Fighting": 19098, "\u0120striker": 19099, "Report": 19100, "\u0120Portugal": 19101, "\u0120neo": 19102, "wed": 19103, "199": 19104, "\u0120fleeing": 19105, "shadow": 19106, "identified": 19107, "USE": 19108, "Steam": 19109, "\u0120stretched": 19110, "\u0120revelations": 19111, "arted": 19112, "\u0120Dw": 19113, "\u0120alignment": 19114, "eston": 19115, "\u0120Jared": 19116, "Sep": 19117, "\u0120blogs": 19118, "update": 19119, "gom": 19120, "risk": 19121, "\u0120clash": 19122, "\u0120Hour": 19123, "\u0120runtime": 19124, "\u0120unwanted": 19125, "\u0120scam": 19126, "\u0120rack": 19127, "\u0120enlight": 19128, "onest": 19129, "\u0120Ferr": 19130, "\u0120convictions": 19131, "\u0120piano": 19132, "\u0120circulation": 19133, "\u0120Welcome": 19134, "\u0120backlash": 19135, "\u0120Wade": 19136, "\u0120receivers": 19137, "otive": 19138, "Jeff": 19139, "\u0120networking": 19140, "\u0120Prep": 19141, "\u0120Explorer": 19142, "\u0120lecture": 19143, "\u0120uploaded": 19144, "\u0120Meat": 19145, "BLE": 19146, "\u0120Nazis": 19147, "\u0120Synd": 19148, "stud": 19149, "roots": 19150, "rians": 19151, "\u0120portrayed": 19152, "\u0120??": 19153, "\u0120Buddha": 19154, "sun": 19155, "Robert": 19156, "\u0120Complex": 19157, "\u0120oversee": 19158, "\u0120stealth": 19159, "Title": 19160, "\u0120Jobs": 19161, "\u0120Kum": 19162, "\u0120appreciation": 19163, "\u0120MOD": 19164, "\u0120basics": 19165, "\u0120clips": 19166, "\u0120nursing": 19167, "\u0120proposition": 19168, "\u0120realised": 19169, "\u0120NYC": 19170, "\u0120allocated": 19171, "rium": 19172, "aran": 19173, "\u0120Production": 19174, "\u0120Vote": 19175, "\u0120smugg": 19176, "\u0120hunter": 19177, "azer": 19178, "\u0120Changes": 19179, "\u0120fluct": 19180, "yon": 19181, "Array": 19182, "\u0120kits": 19183, "Water": 19184, "\u0120uncommon": 19185, "\u0120resting": 19186, "ells": 19187, "would": 19188, "\u0120pursued": 19189, "\u0120assertion": 19190, "ometown": 19191, "\u0120Mosul": 19192, "\u0120Platform": 19193, "iolet": 19194, "\u0120shareholders": 19195, "\u0120trails": 19196, "Pay": 19197, "\u0120Enforcement": 19198, "types": 19199, "\u0120Anonymous": 19200, "\u0120satisfying": 19201, "ilogy": 19202, "\u0120('": 19203, "wave": 19204, "city": 19205, "Steve": 19206, "\u0120confrontation": 19207, "\u0120Eld": 19208, "Capt": 19209, "ahan": 19210, "htm": 19211, "\u0120Ctrl": 19212, "ONS": 19213, "230": 19214, "ifa": 19215, "holding": 19216, "\u0120delicate": 19217, "\u0120jaw": 19218, "\u0120Going": 19219, "orum": 19220, "Sal": 19221, "\u0120dull": 19222, "\u0120Beth": 19223, "\u0120prisons": 19224, "\u0120ego": 19225, "\u0120Elsa": 19226, "avorite": 19227, "\u0120Gang": 19228, "\u0120Nuclear": 19229, "\u0120spider": 19230, "atsu": 19231, "\u0120sampling": 19232, "\u0120absorbed": 19233, "\u0120Pharm": 19234, "ieth": 19235, "\u0120bucket": 19236, "\u0120Recomm": 19237, "OF": 19238, "\u0120Factory": 19239, "ANCE": 19240, "\u0120bacter": 19241, "Has": 19242, "\u0120Observ": 19243, "121": 19244, "\u0120premiere": 19245, "Develop": 19246, "\u0120currencies": 19247, "Cast": 19248, "\u0120accompanying": 19249, "\u0120Nashville": 19250, "\u0120fatty": 19251, "\u0120Brend": 19252, "\u0120locks": 19253, "\u0120centered": 19254, "\u0120UT": 19255, "aughs": 19256, "orie": 19257, "\u0120Affordable": 19258, "vance": 19259, "DL": 19260, "emet": 19261, "\u0120throne": 19262, "\u0120Bluetooth": 19263, "\u0120naming": 19264, "ifts": 19265, "ADE": 19266, "\u0120corrected": 19267, "\u0120promptly": 19268, "\u0120STR": 19269, "\u0120genome": 19270, "\u0120cope": 19271, "\u0120valley": 19272, "\u0120rounded": 19273, "\u0120Kend": 19274, "alion": 19275, "pers": 19276, "\u0120tourism": 19277, "\u0120stark": 19278, "vl": 19279, "\u0120blowing": 19280, "\u0120Schedule": 19281, "std": 19282, "\u0120unhappy": 19283, "\u0120litigation": 19284, "cedes": 19285, "\u0120android": 19286, "\u0120integral": 19287, "erers": 19288, "uded": 19289, "tax": 19290, "\u0120reiter": 19291, "\u0120Motors": 19292, "ociated": 19293, "\u0120wonders": 19294, "\u0120Apost": 19295, "ucking": 19296, "\u0120Roosevelt": 19297, "fram": 19298, "\u0120yields": 19299, "\u0120constitutes": 19300, "awk": 19301, "Interest": 19302, "\u0120interim": 19303, "\u0120breakthrough": 19304, "\u0120Cher": 19305, "\u0120prosec": 19306, "\u0120Dj": 19307, "\u0120MT": 19308, "Resp": 19309, "\u0120PT": 19310, "\u0120sperm": 19311, "edit": 19312, "BT": 19313, "Linux": 19314, "country": 19315, "league": 19316, "\u0120dick": 19317, "\u0120oct": 19318, "\u0120inserting": 19319, "\u0120scra": 19320, "\u0120Brewing": 19321, "\u01201966": 19322, "\u0120runners": 19323, "\u0120plun": 19324, "idy": 19325, "\u0120Dian": 19326, "\u0120dysfunction": 19327, "\u0120exclusion": 19328, "\u0120disgr": 19329, "\u0120incorporate": 19330, "\u0120reconc": 19331, "\u0120nominated": 19332, "\u0120Archer": 19333, "draw": 19334, "achelor": 19335, "\u0120writings": 19336, "\u0120shallow": 19337, "\u0120hast": 19338, "\u0120BMW": 19339, "\u0120RS": 19340, "\u0120thigh": 19341, "\u01201963": 19342, "\u0120lamb": 19343, "\u0120favored": 19344, "agle": 19345, "\u0120cooler": 19346, "\u0120Hours": 19347, "\u0120GU": 19348, "\u0120Origin": 19349, "\u0120glimpse": 19350, "--------------------": 19351, "Lim": 19352, "\u0120cheek": 19353, "\u0120jealous": 19354, "-'": 19355, "\u0120harness": 19356, "\u0120Poison": 19357, "\u0120disabilities": 19358, "neapolis": 19359, "\u0120outlook": 19360, "\u0120notify": 19361, "\u0120Indianapolis": 19362, "\u0120abrupt": 19363, "nsic": 19364, "\u0120encrypted": 19365, "\u0120forfe": 19366, "reath": 19367, "\u0120rabb": 19368, "\u0120foundations": 19369, "\u0120compliment": 19370, "\u0120Interview": 19371, "\u0120Swe": 19372, "\u0120adolesc": 19373, "\u0120monitors": 19374, "\u0120Sacramento": 19375, "\u0120timely": 19376, "\u0120contempl": 19377, "\u0120positioned": 19378, "\u0120posters": 19379, "phies": 19380, "iovascular": 19381, "void": 19382, "\u0120Fifth": 19383, "\u0120investigative": 19384, "OUN": 19385, "\u0120integrate": 19386, "\u0120INC": 19387, "isha": 19388, "iblings": 19389, "\u0120Request": 19390, "\u0120Rodriguez": 19391, "\u0120slides": 19392, "\u0120DX": 19393, "\u0120feminism": 19394, "\u0120datas": 19395, "\u0120bend": 19396, "irus": 19397, "\u0120Nigeria": 19398, "Fox": 19399, "Change": 19400, "\u0120airplane": 19401, "\u0120Laden": 19402, "\u0120publicity": 19403, "ixty": 19404, "\u0120commitments": 19405, "\u0120aggregate": 19406, "\u0120displaying": 19407, "\u0120Arrow": 19408, "\u0120122": 19409, "\u0120respects": 19410, "android": 19411, "six": 19412, "\u0120Sha": 19413, "\u0120restoration": 19414, ")\\": 19415, "WS": 19416, "oys": 19417, "\u0120illustrate": 19418, "without": 19419, "126": 19420, "\u0120\u00e2\u0136\u0124": 19421, "\u0120pickup": 19422, "nels": 19423, "\u0120....": 19424, "food": 19425, "\u0120Fen": 19426, ")?": 19427, "\u0120phenomena": 19428, "\u0120companions": 19429, "\u0120Write": 19430, "\u0120spill": 19431, "\u0120bridges": 19432, "\u0120Updated": 19433, "\u0120Fo": 19434, "\u0120insects": 19435, "ASHINGTON": 19436, "\u0120scare": 19437, "iltr": 19438, "\u0120Zhang": 19439, "\u0120severity": 19440, "\u0120indul": 19441, "149": 19442, "\u0120Coffee": 19443, "\u0120norms": 19444, "\u0120pulse": 19445, "\u0120FT": 19446, "\u0120horrific": 19447, "\u0120Destroy": 19448, "\u0120JSON": 19449, "\u0120olive": 19450, "\u0120discusses": 19451, "Rest": 19452, "Elect": 19453, "\u0120Winn": 19454, "\u0120Surviv": 19455, "\u0120Hait": 19456, "Sure": 19457, "oped": 19458, "\u0120rooted": 19459, "\u0120Ske": 19460, "\u0120Bronze": 19461, "\u0120lol": 19462, "Default": 19463, "\u0120commodity": 19464, "redited": 19465, "\u0120libertarian": 19466, "\u0120forbidden": 19467, "\u0120gran": 19468, "\u00e0\u00a8": 19469, "\u0120lag": 19470, "enz": 19471, "drive": 19472, "\u0120mathematics": 19473, "\u0120wires": 19474, "\u0120critically": 19475, "\u0120carbohyd": 19476, "\u0120Chancellor": 19477, "\u0120Eddie": 19478, "\u0120banning": 19479, "\u0120Fri": 19480, "\u0120complications": 19481, "etric": 19482, "\u0120Bangladesh": 19483, "\u0120bandwidth": 19484, "Stop": 19485, "\u0120Originally": 19486, "\u0120halfway": 19487, "ynasty": 19488, "shine": 19489, "\u0120tales": 19490, "rities": 19491, "avier": 19492, "\u0120spinning": 19493, "\u0120WHO": 19494, "\u0120neighbourhood": 19495, "bach": 19496, "\u0120commerce": 19497, "\u0120Sle": 19498, "BU": 19499, "\u0120entrepreneur": 19500, "\u0120peculiar": 19501, "\u0120Comments": 19502, "fre": 19503, "320": 19504, "ICS": 19505, "\u0120imagery": 19506, "\u0120Canon": 19507, "\u0120Electronic": 19508, "short": 19509, "((": 19510, "Dig": 19511, "\u0120commem": 19512, "uced": 19513, "\u0120inclined": 19514, "\u0120Summon": 19515, "\u0120cliff": 19516, "\u0120Mediterranean": 19517, "\u0120poetry": 19518, "\u0120prosperity": 19519, "\u0120Rece": 19520, "\u0120pills": 19521, "member": 19522, "\u0120finale": 19523, "unc": 19524, "\u0120Gig": 19525, "\u00e4\u00bd": 19526, "\u0120lod": 19527, "\u0120backward": 19528, "-+": 19529, "\u0120Forward": 19530, "\u0120thri": 19531, "sure": 19532, "\u0120soap": 19533, "\u0120FX": 19534, "RES": 19535, "\u0120Sexual": 19536, "oulos": 19537, "\u0120foolish": 19538, "\u0120righteous": 19539, "\u0120coff": 19540, "terrorism": 19541, "ustain": 19542, "oter": 19543, "\u0120abuses": 19544, "next": 19545, "\u0120abusive": 19546, "\u0120thereafter": 19547, "\u0120prohibition": 19548, "\u0120SUP": 19549, "\u0120dip": 19550, "\u0120ripped": 19551, "\u0120inherited": 19552, "\u0120bats": 19553, "stru": 19554, "GT": 19555, "\u0120flawed": 19556, "phabet": 19557, "\u0120fog": 19558, "doors": 19559, "\u0120imaging": 19560, "\u0120digits": 19561, "\u0120Hungary": 19562, "\u0120arrog": 19563, "\u0120teachings": 19564, "\u0120protocols": 19565, "\u0120Banks": 19566, "\u00e0\u00b8": 19567, "pound": 19568, "\u0120Curt": 19569, ".\")": 19570, "./": 19571, "\u0120exemption": 19572, "endix": 19573, "\u0120Mull": 19574, "\u0120improves": 19575, "\u0120Gamer": 19576, "dimensional": 19577, "Icon": 19578, "\u0120Margaret": 19579, "Status": 19580, "dates": 19581, "\u0120intends": 19582, "\u0120depict": 19583, "\u0120parked": 19584, "Joe": 19585, "\u0120Marines": 19586, "chnology": 19587, "!).": 19588, "\u0120judged": 19589, "\u0120weights": 19590, "Ray": 19591, "\u0120apartments": 19592, "hester": 19593, "\u0120reinforce": 19594, "\u0120offender": 19595, "occup": 19596, "\u0120sore": 19597, "ept": 19598, "\u0120PHP": 19599, "\u0120Brow": 19600, "\u0120authorization": 19601, "\u0120Risk": 19602, "\u0120Delaware": 19603, "\u0120QU": 19604, "\u0120notifications": 19605, "\u0120sunlight": 19606, "\u0120exclude": 19607, "dat": 19608, "\u0120mesh": 19609, "\u0120Sudan": 19610, "\u0120belonged": 19611, "\u0120subway": 19612, "\u0120noon": 19613, "\u0120Interior": 19614, "olics": 19615, "\u0120Lakers": 19616, "\u0120coding": 19617, "Disclaimer": 19618, "Calif": 19619, "Old": 19620, "\u0120disl": 19621, "?????": 19622, "\u0120confirms": 19623, "\u0120recruitment": 19624, "\u0120homicide": 19625, "Consider": 19626, "\u0120Jeffrey": 19627, "fty": 19628, "};": 19629, "\u0120objection": 19630, "doing": 19631, "\u0120Leo": 19632, "Want": 19633, "\u0120glow": 19634, "\u0120Clarke": 19635, "\u0120Norman": 19636, "\u0120verification": 19637, "\u0120packet": 19638, "\u0120Formula": 19639, "\u0120plag": 19640, "esville": 19641, "\u0120shouting": 19642, "\u0120ov": 19643, "\u0120REC": 19644, "\u0120Bub": 19645, "\u0120ninth": 19646, "\u0120energ": 19647, "\u0120validity": 19648, "\u0120ups": 19649, "jack": 19650, "\u0120neighboring": 19651, "\u0120Nec": 19652, "eworks": 19653, "\u0120Hab": 19654, "arez": 19655, "\u0120spine": 19656, "\u0120eventual": 19657, "\u0120Leaders": 19658, "\u0120Carn": 19659, "\u0120probation": 19660, "\u0120romance": 19661, "msg": 19662, "\u0120Mechanical": 19663, "ERY": 19664, "Rock": 19665, "\u0120partisan": 19666, "Node": 19667, "assets": 19668, "minent": 19669, "\u0120foreigners": 19670, "\u0120testify": 19671, "\u0120Usually": 19672, "lords": 19673, "\u0120Gren": 19674, "\u0120Powell": 19675, "BIL": 19676, "\u0120sr": 19677, "\u0120addict": 19678, "\u0120shells": 19679, "\u0120sigh": 19680, "\u0120Yale": 19681, "ternity": 19682, "\u0120750": 19683, "EU": 19684, "\u0120Rifle": 19685, "\u0120patron": 19686, "ema": 19687, "\u0120Bannon": 19688, "anity": 19689, "\u0120tropical": 19690, "\u0120VII": 19691, "cross": 19692, "Everything": 19693, "\u0120ISO": 19694, "\u0120humble": 19695, "assing": 19696, "\u0120FIG": 19697, "\u0120updating": 19698, "yson": 19699, "\u0120calcium": 19700, "\u0120competent": 19701, "\u0120steering": 19702, "Prot": 19703, "\u0120SY": 19704, "\u0120Finals": 19705, "\u0120Rug": 19706, "159": 19707, "137": 19708, "\u0120Golf": 19709, "\u0120126": 19710, "\u0120accommodation": 19711, "\u0120Hughes": 19712, "\u0120aesthetic": 19713, "artisan": 19714, "\u0120Twilight": 19715, "\u0120prince": 19716, "\u0120Agriculture": 19717, "\u0120Disco": 19718, "\u0120precedent": 19719, "\u0120typing": 19720, "authorized": 19721, "Option": 19722, "\u0120Aub": 19723, "lishes": 19724, "acht": 19725, "mag": 19726, "Peter": 19727, "\u0120UFO": 19728, "monton": 19729, "\u0120Lith": 19730, "\u0120arom": 19731, "\u0120securing": 19732, "\u0120confined": 19733, "private": 19734, "\u0120swords": 19735, "\u0120markers": 19736, "\u0120metabolic": 19737, "select": 19738, "\u0120Curse": 19739, "\u0120Ot": 19740, "gressive": 19741, "\u0120incumb": 19742, "\u0120Saga": 19743, "\u0120priced": 19744, "\u0120clearance": 19745, "Content": 19746, "\u0120drilling": 19747, "\u0120notices": 19748, "\u0120bourgeois": 19749, "\u0120vest": 19750, "\u0120cookie": 19751, "\u0120Guardians": 19752, "rys": 19753, "inyl": 19754, "\u0120124": 19755, "\u0120plausible": 19756, "ongh": 19757, "\u0120Odin": 19758, "\u0120conception": 19759, "\u0120Yuk": 19760, "\u0120Baghdad": 19761, "\u0120Flag": 19762, "Austral": 19763, "\u0120IBM": 19764, "\u0120internationally": 19765, "\u0120WikiLeaks": 19766, "IED": 19767, "\u0120cyn": 19768, "\u0120chooses": 19769, "\u0120Pill": 19770, "\u0120combining": 19771, "\u0120radi": 19772, "\u0120Mohammed": 19773, "defense": 19774, "atching": 19775, "Subject": 19776, "iciency": 19777, "Frame": 19778, "\u0120{\"": 19779, "\u0120chess": 19780, "\u0120timer": 19781, "190": 19782, "\u0120tin": 19783, "\u0120ordinance": 19784, "emetery": 19785, "\u0120accusing": 19786, "\u0120noticeable": 19787, "\u0120centres": 19788, "\u0120lid": 19789, "\u0120Mills": 19790, "imgur": 19791, "\u0120zoom": 19792, "ergic": 19793, "\u0120compression": 19794, "prim": 19795, "find": 19796, "\u0120surg": 19797, "\u0120pand": 19798, "\u0120Kee": 19799, "\u0120Chad": 19800, "cellence": 19801, "oyle": 19802, "\u0120socialism": 19803, "\u0120Travis": 19804, "\u0120MHz": 19805, "\u0120guild": 19806, "ALLY": 19807, "\u0120Subscribe": 19808, "\u0120Related": 19809, "\u0120occurrence": 19810, "itching": 19811, "\u0120fictional": 19812, "\u0120crush": 19813, "\u0120EA": 19814, "cod": 19815, "mix": 19816, "\u0120Triple": 19817, "\u0120retrieve": 19818, "\u0120stimulus": 19819, "\u0120psychiat": 19820, "\u0120Door": 19821, "\u0120homosexuality": 19822, "\u0120elementary": 19823, "\u0120cellular": 19824, "idian": 19825, "\u0120Laun": 19826, "\u0120intriguing": 19827, "\u0120foam": 19828, "\u0120Bass": 19829, "idi": 19830, "itsu": 19831, "\u0120assure": 19832, "\u0120congrat": 19833, "\u0120businessman": 19834, "\u0120Boost": 19835, "close": 19836, "\u0120lied": 19837, "\u0120sciences": 19838, "\u0120Omega": 19839, "\u0120Graphics": 19840, "\u0120<=": 19841, "spoken": 19842, "\u0120connectivity": 19843, "Saturday": 19844, "\u0120Avengers": 19845, "\u0120toggle": 19846, "\u0120ankle": 19847, "\u0120nationalist": 19848, "model": 19849, "\u0120Pool": 19850, "ophobia": 19851, "Var": 19852, "\u0120Mons": 19853, "atories": 19854, "\u0120aggressively": 19855, "Clear": 19856, "Forge": 19857, "acters": 19858, "\u0120hedge": 19859, "\u0120pipes": 19860, "\u0120blunt": 19861, "\u0120sq": 19862, "\u0120remotely": 19863, "Wed": 19864, "asers": 19865, "\u0120refriger": 19866, "\u0120tiles": 19867, "\u0120rescued": 19868, "\u0120comprised": 19869, "insky": 19870, "\u0120manif": 19871, "avanaugh": 19872, "\u0120prolifer": 19873, "\u0120aligned": 19874, "xml": 19875, "\u0120triv": 19876, "\u0120coordination": 19877, "\u0120PER": 19878, "\u0120Quote": 19879, "134": 19880, "bf": 19881, "\u0120Saw": 19882, "\u0120termination": 19883, "\u0120190": 19884, "\u0120additions": 19885, "\u0120trio": 19886, "\u0120projections": 19887, "\u0120positively": 19888, "\u0120inclusive": 19889, "\u0120membr": 19890, "1990": 19891, "older": 19892, "\u0120practiced": 19893, "inkle": 19894, "Arch": 19895, "\u0120starters": 19896, "arius": 19897, "\u0120intermediate": 19898, "\u0120Benef": 19899, "\u0120Killer": 19900, "\u0120interventions": 19901, "\u0120Kil": 19902, "\u0120Flying": 19903, "Inv": 19904, "\u0120premature": 19905, "\u0120psychiatric": 19906, "\u0120indie": 19907, "\u0120collar": 19908, "\u0120Rainbow": 19909, "afi": 19910, "\u0120disruption": 19911, "\u0120FOX": 19912, "casting": 19913, "\u0120misdem": 19914, "cro": 19915, "\u0120wipe": 19916, "ardon": 19917, "\u0120bast": 19918, "\u0120Tommy": 19919, "\u0120Representative": 19920, "\u0120belly": 19921, "\u0120PO": 19922, "\u0120Breitbart": 19923, "132": 19924, "\u0120messaging": 19925, "Should": 19926, "References": 19927, "\u0120GRE": 19928, "istical": 19929, "LP": 19930, "\u0120Cav": 19931, "\u0120Crazy": 19932, "\u0120intuitive": 19933, "keeping": 19934, "\u0120Moss": 19935, "\u0120discontin": 19936, "\u0120Module": 19937, "\u0120unrelated": 19938, "\u0120Practice": 19939, "\u0120Transport": 19940, "\u0120statistically": 19941, "orns": 19942, "\u0120sized": 19943, "pu": 19944, "\u0120caf": 19945, "\u0120Worlds": 19946, "\u0120Rodgers": 19947, "\u0120Lun": 19948, "\u0120Comic": 19949, "living": 19950, "\u0120cared": 19951, "\u0120climbed": 19952, "){": 19953, "\u0120consisted": 19954, "\u0120medieval": 19955, "folk": 19956, "\u0120hacked": 19957, "\u0120dire": 19958, "\u0120Hermione": 19959, "\u0120tended": 19960, "ceans": 19961, "Daniel": 19962, "went": 19963, "\u0120legislators": 19964, "\u0120redes": 19965, "games": 19966, "\u0120gn": 19967, "amiliar": 19968, "\u0120++": 19969, "ggy": 19970, "threat": 19971, "\u0120magnet": 19972, "\u0120perceive": 19973, "\u0120zip": 19974, "\u0120indictment": 19975, "\u0120critique": 19976, "gard": 19977, "\u0120Safe": 19978, "\u0120Cream": 19979, "\u0120advent": 19980, "oba": 19981, "\u0120vowed": 19982, "ousands": 19983, "\u0120ski": 19984, "\u0120abortions": 19985, "uart": 19986, "\u0120stunned": 19987, "\u0120advancing": 19988, "\u0120lacked": 19989, "\u0120\\\"": 19990, "\u0120schizophren": 19991, "\u0120elegant": 19992, "\u0120conferences": 19993, "\u0120canceled": 19994, "\u0120Hudson": 19995, "\u0120Hopefully": 19996, "\u0120trump": 19997, "\u0120frequencies": 19998, "\u0120meteor": 19999, "\u0120Junior": 20000, "\u0120Fleet": 20001, "\u0120Malcolm": 20002, "\u0120Tools": 20003, "\u0120........": 20004, "\u0120hobby": 20005, "\u0120Europeans": 20006, "\u01201500": 20007, "\u0120Into": 20008, "\u0120sway": 20009, "\u0120Appro": 20010, "\u0120Compl": 20011, "Community": 20012, "\u0120tide": 20013, "\u0120Summit": 20014, "\u00e4\u00bb": 20015, "\u0120intervals": 20016, "\u0120Ether": 20017, "\u0120habitat": 20018, "\u0120Stevens": 20019, "lishing": 20020, "\u0120Domain": 20021, "\u0120triggers": 20022, "\u0120chasing": 20023, "\u0120charm": 20024, "\u0120Flower": 20025, "itored": 20026, "\u0120blessing": 20027, "\u0120textures": 20028, "Five": 20029, "\u0120liquor": 20030, "RP": 20031, "FIN": 20032, "\u01201962": 20033, "CAR": 20034, "Unknown": 20035, "\u0120resil": 20036, "\u0120Lily": 20037, "\u0120abundance": 20038, "\u0120predictable": 20039, "rar": 20040, "\u0120bullshit": 20041, "leen": 20042, "chet": 20043, "Mor": 20044, "Much": 20045, "\u00e4\u00b9": 20046, "\u0120emphasized": 20047, "\u0120crust": 20048, "\u0120primitive": 20049, "\u0120enjoyable": 20050, "\u0120Pictures": 20051, "\u0120teammate": 20052, "pler": 20053, "\u0120Tol": 20054, "\u0120Kane": 20055, "\u0120summoned": 20056, "thy": 20057, "rama": 20058, "\u0120Honda": 20059, "\u0120realizing": 20060, "\u0120quicker": 20061, "\u0120concentrate": 20062, "clear": 20063, "\u0120210": 20064, "\u0120Erdogan": 20065, "aris": 20066, "\u0120responds": 20067, "\u0120BI": 20068, "\u0120eligibility": 20069, "\u0120pushes": 20070, "\u0120Idaho": 20071, "\u0120aggrav": 20072, "\u0120ruins": 20073, "urations": 20074, "\u0120bans": 20075, "\u0120anat": 20076, "share": 20077, "\u0120grind": 20078, "hin": 20079, "umen": 20080, "\u0120utilities": 20081, "\u0120Yankees": 20082, "\u0120databases": 20083, "\u0120DD": 20084, "\u0120displaced": 20085, "\u0120dependencies": 20086, "\u0120stimulation": 20087, "hun": 20088, "houses": 20089, "\u0120Pretty": 20090, "\u0120Ravens": 20091, "\u0120TODAY": 20092, "\u0120associates": 20093, "\u0120therape": 20094, "cled": 20095, "\u0120deer": 20096, "\u0120repairs": 20097, "rentice": 20098, "\u0120receptors": 20099, "\u0120remed": 20100, "\u0120Ce": 20101, "\u0120marriages": 20102, "\u0120ballots": 20103, "\u0120Soldier": 20104, "\u0120hilarious": 20105, "opl": 20106, "138": 20107, "\u0120inherently": 20108, "\u0120ignorant": 20109, "\u0120bounce": 20110, "\u0120Easter": 20111, "RELATED": 20112, "\u0120Currency": 20113, "EV": 20114, "\u00e3\u0125\u0140": 20115, "\u0120Lead": 20116, "\u0120deceased": 20117, "Brien": 20118, "\u0120Musk": 20119, "JS": 20120, "\u0120merge": 20121, "hearted": 20122, "creat": 20123, "mitt": 20124, "mund": 20125, "\u0120\u00e2\u0122\u012d": 20126, "\u0120Bag": 20127, "\u0120projection": 20128, "\u0120java": 20129, "\u0120Standards": 20130, "\u0120Leonard": 20131, "\u0120coconut": 20132, "\u0120Population": 20133, "\u0120traject": 20134, "\u0120imply": 20135, "\u0120curiosity": 20136, "\u0120DB": 20137, "\u0120Fresh": 20138, "\u0120Por": 20139, "\u0120heavier": 20140, "neys": 20141, "gomery": 20142, "\u0120deserved": 20143, "\u0120phrases": 20144, "\u0120GC": 20145, "\u0120yeast": 20146, "desc": 20147, "Death": 20148, "\u0120reboot": 20149, "\u0120metadata": 20150, "ICAL": 20151, "\u0120repay": 20152, "\u0120Independence": 20153, "\u0120suburban": 20154, "icals": 20155, "\u0120atop": 20156, "\u0120allocation": 20157, "generation": 20158, "\u0120Gram": 20159, "\u0120moisture": 20160, "\u0120pine": 20161, "\u0120Liberals": 20162, "\u0120aides": 20163, "\u0120underest": 20164, "\u0120Berry": 20165, "\u0120ceremon": 20166, "370": 20167, "astrous": 20168, "\u0120Pirates": 20169, "\u0120tense": 20170, "\u0120Industries": 20171, "\u0120Appeals": 20172, "\u0120Near": 20173, "\u0120\u00e8\u00a3\u0131\u00e7": 20174, "\u0120lovers": 20175, "\u0120CAP": 20176, "\u0120Craw": 20177, "\u0120giants": 20178, "\u0120efficacy": 20179, "Element": 20180, "\u0120Behavior": 20181, "\u0120Toyota": 20182, "\u0120intest": 20183, "Priv": 20184, "AI": 20185, "\u0120maneuver": 20186, "\u0120perfection": 20187, "\u0120bang": 20188, "paper": 20189, "rill": 20190, "George": 20191, "border": 20192, "inters": 20193, "\u0120Seth": 20194, "\u0120clues": 20195, "\u0120Levi": 20196, "\u0120Revenue": 20197, "147": 20198, "\u0120vapor": 20199, "\u0120fortunate": 20200, "\u0120threatens": 20201, "\u0120vet": 20202, "\u0120dependency": 20203, "ersed": 20204, "article": 20205, "\u0120Blizzard": 20206, "\u0120chlor": 20207, "\u0120minus": 20208, "\u0120Bills": 20209, "\u0120cryptocurrency": 20210, "\u0120metabolism": 20211, "tering": 20212, "\u0120pestic": 20213, "steps": 20214, "\u0120Treasure": 20215, "racted": 20216, "\u0120Constant": 20217, "\u0120temp": 20218, "139": 20219, "\u0120Detective": 20220, "urally": 20221, "\u0120recovering": 20222, "\u0120cortex": 20223, "\u0120144": 20224, "closed": 20225, "\u0120prejudice": 20226, "aunted": 20227, "\u0120storms": 20228, "\u0120NOW": 20229, "\u0120machinery": 20230, "Address": 20231, "\u0120compelled": 20232, "270": 20233, "\u0120despair": 20234, "bane": 20235, "\u0120vegetable": 20236, "\u0120beds": 20237, "Learn": 20238, "\u0120colorful": 20239, "\u0120spike": 20240, "\u0120margins": 20241, "\u0120sympathy": 20242, "\u0120workshop": 20243, "\u0120CBC": 20244, "Sat": 20245, "\u0120burns": 20246, "\u0120Gender": 20247, "\u0120129": 20248, "\u0120Cable": 20249, "\u0120debts": 20250, "\u0120Theresa": 20251, "\u0120reflecting": 20252, "\u0120airst": 20253, "\u0120rim": 20254, "ramid": 20255, "\u0120weaknesses": 20256, "Writ": 20257, "oggle": 20258, "ti": 20259, "\u0120Charge": 20260, "\u0120weighed": 20261, "\u0120(.": 20262, "\u0120laughter": 20263, "\u0120router": 20264, "\u0120Democracy": 20265, "Dear": 20266, "\u0120hasht": 20267, "\u0120dy": 20268, "\u0120hints": 20269, "running": 20270, "\u0120finishes": 20271, "arus": 20272, "Mass": 20273, "result": 20274, "ascus": 20275, "\u0120vintage": 20276, "\u0120conqu": 20277, "\u0120wildly": 20278, "acist": 20279, "\u0120lingu": 20280, "\u0120protagonist": 20281, "strom": 20282, "teenth": 20283, "\u0120Solo": 20284, "mac": 20285, "filled": 20286, "\u0120renown": 20287, "itives": 20288, "\u0120motive": 20289, "\u0120Antar": 20290, "\u0120Mann": 20291, "\u0120Adjust": 20292, "\u0120rockets": 20293, "\u0120troubling": 20294, "ei": 20295, "\u0120organisms": 20296, "assis": 20297, "Christian": 20298, "\u0120145": 20299, "\u0120Hass": 20300, "\u0120swall": 20301, "\u0120wax": 20302, "\u0120Survival": 20303, "VS": 20304, "\u0120Murd": 20305, "vd": 20306, "standard": 20307, "\u0120dragons": 20308, "\u0120acceleration": 20309, "rational": 20310, "final": 20311, "\u0120paired": 20312, "\u0120Ethereum": 20313, "\u0120interfaces": 20314, "\u0120resent": 20315, "\u0120artifacts": 20316, "\u00c5\u00ab": 20317, "arel": 20318, "\u0120competitor": 20319, "\u0120Nicholas": 20320, "\u0120Surface": 20321, "cpp": 20322, "\u0120Tot": 20323, "\u0120economically": 20324, "\u0120organised": 20325, "\u0120enforced": 20326, "inho": 20327, "\u0120varieties": 20328, "\u0120abdom": 20329, "\u0120Bailey": 20330, "idav": 20331, "\u0120Salv": 20332, "paid": 20333, "\u0120altitude": 20334, "essert": 20335, "\u0120Gutenberg": 20336, "area": 20337, "opoulos": 20338, "\u0120professors": 20339, "iggs": 20340, "\u0120Fate": 20341, "hey": 20342, "\u01203000": 20343, "Dist": 20344, "\u0120twins": 20345, "cill": 20346, "\u0120Maps": 20347, "\u0120traps": 20348, "\u0120weed": 20349, "\u0120Kiss": 20350, "\u0120yoga": 20351, "\u0120recipients": 20352, "\u0120Westminster": 20353, "\u0120pools": 20354, "\u0120Walmart": 20355, "188": 20356, "\u0120Schools": 20357, "attack": 20358, "\u0120ARM": 20359, "paragraph": 20360, "Warning": 20361, "jl": 20362, "\u0120selfish": 20363, "anchez": 20364, "\u0120Heights": 20365, "Fre": 20366, "\u0120Soph": 20367, "\u0120--------------------------------": 20368, "tml": 20369, "333": 20370, "\u0120raids": 20371, "\u0120satellites": 20372, "KEY": 20373, "\u0120lasts": 20374, "\u00d1\u0124": 20375, "Ins": 20376, "\u0120Dame": 20377, "\u0120unpredict": 20378, "///": 20379, "ghai": 20380, "\u0120artillery": 20381, "\u0120cruise": 20382, "\u0120gel": 20383, "\u0120Cabinet": 20384, "\u0120blows": 20385, "\u0120Esp": 20386, "\u0120proximity": 20387, "othe": 20388, "\u0120Skills": 20389, "\u0120Upper": 20390, "obo": 20391, "\u0120NDP": 20392, "\u0120enjoys": 20393, "\u0120repeating": 20394, "\u0120Construction": 20395, "\u0120Questions": 20396, "Hillary": 20397, "\u0120uint": 20398, "\u0120processors": 20399, "\u0120Gibson": 20400, "\u0120Multiple": 20401, "qa": 20402, "\u0120Bom": 20403, "\u0120Miles": 20404, "ventional": 20405, "\u0120hurts": 20406, "skin": 20407, "\u0120AIDS": 20408, "\u0120advisers": 20409, "\u0120Root": 20410, "\u0120methodology": 20411, "\u0120Dale": 20412, "\u0120deton": 20413, "\u0120Knowledge": 20414, "sequently": 20415, "\u0120121": 20416, "\u0120connects": 20417, "Cy": 20418, "\u0120Danger": 20419, "\u0120contributors": 20420, "\u0120Bent": 20421, "\u0120brass": 20422, "\u0120Guns": 20423, "into": 20424, "\u0120Fortune": 20425, "\u0120broker": 20426, "balance": 20427, "\u0120lengths": 20428, "\u0120vic": 20429, "\u0120averaging": 20430, "\u0120appropriately": 20431, "\u0120Camera": 20432, "\u0120sandwich": 20433, "\u0120CDC": 20434, "\u0120coordinate": 20435, "\u0120navig": 20436, "\u0120goodness": 20437, "laim": 20438, "\u0120brake": 20439, "\u0120extremist": 20440, "\u0120Wake": 20441, "\u0120Mend": 20442, "\u0120Tiny": 20443, "\u0120COL": 20444, "\u0120RF": 20445, "\u0120Dual": 20446, "\u0120Wine": 20447, "Case": 20448, "\u0120refined": 20449, "\u0120lamp": 20450, "Lead": 20451, "\u0120bapt": 20452, "\u0120Carb": 20453, "\u0120Sadd": 20454, "\u0120Minneapolis": 20455, "PDF": 20456, "Early": 20457, "\u0120Hidden": 20458, "Its": 20459, "\u0120TIME": 20460, "\u0120pap": 20461, "\u0120commissioned": 20462, "\u0120Few": 20463, "\u0120Colts": 20464, "\u0120Bren": 20465, "\u0120bothered": 20466, "\u0120likewise": 20467, "Exper": 20468, "\u0120Schw": 20469, "cry": 20470, "nn": 20471, "\u0120Mitch": 20472, "imon": 20473, "MG": 20474, "bm": 20475, "UMP": 20476, "rays": 20477, "\u0120registry": 20478, "\u0120270": 20479, "achine": 20480, "rella": 20481, "anting": 20482, "00000": 20483, "\u0120ruined": 20484, "spot": 20485, "\u0120ta": 20486, "\u0120maximize": 20487, "\u0120inconven": 20488, "Dead": 20489, "Human": 20490, "Enabled": 20491, "\u0120Marie": 20492, "\u0120chill": 20493, "\u0120Paradise": 20494, "\u0120starring": 20495, "\u0120Latino": 20496, "\u0120Protocol": 20497, "\u0120EVER": 20498, "\u0120suppliers": 20499, "message": 20500, "\u0120Brock": 20501, "\u0120serum": 20502, "\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a": 20503, "\u0120encomp": 20504, "\u0120ambition": 20505, "uese": 20506, "\u0120arrows": 20507, "Andrew": 20508, "\u0120antenna": 20509, "\u01201961": 20510, "\u0120Bark": 20511, "\u0120bool": 20512, "\u00e3\u0124\u00aa": 20513, "\u0120Storage": 20514, "\u0120railway": 20515, "\u0120tougher": 20516, "\u0120Cad": 20517, "\u0120washing": 20518, "Py": 20519, "']": 20520, "embed": 20521, "\u0120Memphis": 20522, "ackle": 20523, "\u0120famously": 20524, "\u0120Fortunately": 20525, "ovies": 20526, "\u0120mindset": 20527, "\u0120sneak": 20528, "\u0120Dh": 20529, "RAW": 20530, "\u0120Simpson": 20531, "\u0120livest": 20532, "\u0120landmark": 20533, "\u0120cement": 20534, "Low": 20535, "\u0120thrilled": 20536, "\u0120Course": 20537, "inel": 20538, "\u0120chuck": 20539, "idate": 20540, "global": 20541, "\u0120whit": 20542, "\u0120\u00ef\u00bf\u00bd": 20543, "adays": 20544, "ski": 20545, "\u0120SV": 20546, "\u0120viruses": 20547, "306": 20548, "\u0120Respons": 20549, "\u0120theaters": 20550, "\u0120Branch": 20551, "\u0120Geneva": 20552, "\u0120MK": 20553, "\u0120unbeliev": 20554, "\u0120communist": 20555, "Original": 20556, "\u0120Received": 20557, "\u0120Transfer": 20558, "\u0120Arg": 20559, "Input": 20560, "\u0120Strategy": 20561, "\u0120palace": 20562, "thening": 20563, "Dri": 20564, "\u0120sentencing": 20565, "umbnail": 20566, "\u0120pins": 20567, "recy": 20568, "\u0120siblings": 20569, "Getting": 20570, "\u0120BU": 20571, "\u0120Northwest": 20572, "\u0120prolonged": 20573, "\u0120Sakura": 20574, "Comb": 20575, "\u0120Bour": 20576, "\u0120inadequate": 20577, "\u0120Kash": 20578, "\u0120username": 20579, "\u0120Improve": 20580, "\u0120battling": 20581, "\u0120MAC": 20582, "\u0120curriculum": 20583, "\u0120soda": 20584, "\u0120Cannon": 20585, "\u0120sensible": 20586, "spons": 20587, "December": 20588, "\u0120wicked": 20589, "\u0120Pengu": 20590, "\u0120dictators": 20591, "\u0120Hearts": 20592, "ogyn": 20593, "\u0120similarities": 20594, "\u0120Stats": 20595, "\u0120hollow": 20596, "itations": 20597, "\":[": 20598, "\u0120hover": 20599, "\u0120Listen": 20600, "sch": 20601, "Sund": 20602, "\u0120cad": 20603, "\u0120Parks": 20604, "\u0120lur": 20605, "\u0120hype": 20606, "\u0120Lem": 20607, "NAME": 20608, "isure": 20609, "Friday": 20610, "\u0120shoots": 20611, "\u0120closes": 20612, "\u0120db": 20613, "\u0120Ridge": 20614, "\u0120Different": 20615, "\u0120replies": 20616, "\u0120Broadway": 20617, "opers": 20618, "\u0120intoler": 20619, "\u0120Zeus": 20620, "akespe": 20621, "\u0120proprietary": 20622, "\u0120requesting": 20623, "\u0120controllers": 20624, "\u0120MIN": 20625, "imedia": 20626, "becca": 20627, "\u0120expans": 20628, "\u0120oils": 20629, "Bot": 20630, "\u0120Chand": 20631, "\u0120printer": 20632, "\u0120topped": 20633, "\u0120POL": 20634, "\u0120Earlier": 20635, "Social": 20636, "avin": 20637, "\u0120decreases": 20638, "\u0120Seb": 20639, "\u0120specifications": 20640, "\u0120Blast": 20641, "\u0120Kurt": 20642, "\u0120freel": 20643, "Brown": 20644, "\u0120dilig": 20645, "roe": 20646, "\u0120Problem": 20647, "\u0120Quad": 20648, "\u0120decentral": 20649, "\u0120Vector": 20650, "anut": 20651, "\u0120plugins": 20652, "\u0120Gregory": 20653, "\u0120fucked": 20654, "elines": 20655, "\u0120Ambassador": 20656, "take": 20657, "\u0120cleans": 20658, "ongyang": 20659, "Anonymous": 20660, "stro": 20661, "\"}": 20662, "aline": 20663, "\u0120Odd": 20664, "\u0120Eug": 20665, "216": 20666, "\u0120boil": 20667, "\u0120Powers": 20668, "\u0120nurses": 20669, "Obviously": 20670, "\u0120Technical": 20671, "\u0120exceeded": 20672, "ORS": 20673, "\u0120extremists": 20674, "\u0120traces": 20675, "expl": 20676, "\u0120comr": 20677, "\u0120Sach": 20678, ")/": 20679, "\u0120masks": 20680, "\u0120sci": 20681, "Bon": 20682, "\u0120regression": 20683, "wegian": 20684, "\u0120advisor": 20685, "itures": 20686, "\u0120Vo": 20687, "example": 20688, "\u0120Instruct": 20689, "\u0120siege": 20690, "\u0120reductions": 20691, "ptr": 20692, "\u0120statutory": 20693, "\u0120removes": 20694, "\u0120puck": 20695, "redits": 20696, "\u0120bee": 20697, "\u0120salad": 20698, "\u0120promotions": 20699, "\u0120Joshua": 20700, "withstanding": 20701, "ETH": 20702, "\u0120Cha": 20703, "imus": 20704, "\u0120expenditure": 20705, "aunting": 20706, "\u0120delighted": 20707, "\u0120155": 20708, "beh": 20709, "\u0120carpet": 20710, "\u0120Spart": 20711, "\u0120jungle": 20712, "lists": 20713, "\u0120bullying": 20714, "\u0120Nobel": 20715, "\u0120Glen": 20716, "\u0120referenced": 20717, "\u0120introduces": 20718, "sein": 20719, "\u0120chopped": 20720, "glass": 20721, "\u0120Wrest": 20722, "\u0120neutrality": 20723, "\u0120\u00e2\u013b": 20724, "\u0120investigator": 20725, "\u0120shelves": 20726, "\u0120unconstitutional": 20727, "\u0120reproduction": 20728, "\u0120merchant": 20729, "mia": 20730, "\u0120metrics": 20731, "\u0120explosives": 20732, "\u0120Sonia": 20733, "\u0120bodily": 20734, "\u0120thickness": 20735, "\u0120predominantly": 20736, "\u0120Ability": 20737, "\u0120monitored": 20738, "ICH": 20739, "\u0120].": 20740, "\u0120Martinez": 20741, "\u0120visibility": 20742, "\u0120queries": 20743, "\u0120genocide": 20744, "\u0120Warfare": 20745, "Query": 20746, "\u0120studios": 20747, "\u0120embry": 20748, "\u0120corridor": 20749, "\u0120cleaned": 20750, "complete": 20751, "\u0120MH": 20752, "\u0120enrollment": 20753, "INGS": 20754, "\u0120impacted": 20755, "\u0120disastrous": 20756, "\u0120Yun": 20757, "\u0120Claire": 20758, "\u0120Basically": 20759, "yt": 20760, "usterity": 20761, "\u0120indirectly": 20762, "wik": 20763, "\u0120dod": 20764, "\u0120Carr": 20765, "\u0120amp": 20766, "\u0120prohibit": 20767, "\u0120Initial": 20768, "\u0120Rd": 20769, "iji": 20770, "\u0120educate": 20771, "corn": 20772, "iott": 20773, "\u0120Beauty": 20774, "\u0120detective": 20775, "\u0120Conn": 20776, "since": 20777, "\u0120stagger": 20778, "\u0120obese": 20779, "\u0120bree": 20780, "ologic": 20781, "isse": 20782, "walker": 20783, "\u0120blades": 20784, "\u0120lawful": 20785, "func": 20786, "\u0120Behind": 20787, "\u0120appetite": 20788, "\u0120(*": 20789, "\u0120tennis": 20790, "\u0120offspring": 20791, "\u0120jets": 20792, "\u0120structured": 20793, "\u0120aforementioned": 20794, "Nov": 20795, "\u0120scaling": 20796, "fill": 20797, "\u0120stew": 20798, "\u0120curb": 20799, "\u0120Stephan": 20800, "edIn": 20801, "SF": 20802, "obic": 20803, "\u00e9\u0143\u0136": 20804, "oug": 20805, "\u0120MM": 20806, "\u0120genetically": 20807, "opez": 20808, "136": 20809, "\u0120umb": 20810, "ancers": 20811, "\u0120cohort": 20812, "\u0120merchandise": 20813, "\u0120imposing": 20814, "\u0120Legislature": 20815, "\u0120Archive": 20816, "ivia": 20817, "\u0120Naval": 20818, "\u0120offences": 20819, "\u0120miracle": 20820, "\u0120snapped": 20821, "\u0120foes": 20822, "\u0120extensively": 20823, "\u0120Raf": 20824, "\u0120cater": 20825, "edience": 20826, "Kit": 20827, "\u0120Bin": 20828, "\u0120recommends": 20829, "\u0120Cities": 20830, "\u0120rigid": 20831, "\u0120READ": 20832, "\u0120Noble": 20833, "\u0120Tian": 20834, "\u0120certificates": 20835, "antis": 20836, "oiler": 20837, "\u0120Buddhist": 20838, "did": 20839, "\u0120surveyed": 20840, "\u0120downward": 20841, "\u0120prints": 20842, "\u0120Motion": 20843, "ronics": 20844, "\u0120Sans": 20845, "ossibly": 20846, "uctions": 20847, "\u0120colonies": 20848, "\u0120Danish": 20849, "unit": 20850, "\u0120spoil": 20851, "\u0120advisory": 20852, "berries": 20853, "Plan": 20854, "\u0120specification": 20855, "ophers": 20856, "\u0120Resource": 20857, "\u0120shirts": 20858, "prisingly": 20859, "communications": 20860, "\u0120trivial": 20861, "\u0120mentioning": 20862, "isexual": 20863, "\u0120supplements": 20864, "\u0120supervision": 20865, "BP": 20866, "vor": 20867, "\u0120wit": 20868, "\u0120cooldown": 20869, "\u0120plaintiff": 20870, "\u0120Reviews": 20871, "\u0120Sri": 20872, "\u0120Mint": 20873, "\u0120Sugar": 20874, "\u0120afterward": 20875, "\u0120Priest": 20876, "\u0120Investment": 20877, "ogene": 20878, "\u0120Taking": 20879, "\u0120stretching": 20880, "\u0120inflammation": 20881, "\u0120Tehran": 20882, "\u0120lining": 20883, "\u0120freezing": 20884, "\u0120Entity": 20885, "\u0120inspiring": 20886, "special": 20887, "price": 20888, "\u0120sue": 20889, "\u0120Porter": 20890, "ounge": 20891, "ETA": 20892, "\u0120Derek": 20893, "\u0120Luis": 20894, "uo": 20895, "ymph": 20896, "\u0120exterior": 20897, "ihil": 20898, "\u0120Ashley": 20899, "inator": 20900, "\u0120nutrients": 20901, "\u0120Thrones": 20902, "\u0120finances": 20903, "\u0120Inspect": 20904, "\u0120specially": 20905, "\u0120Required": 20906, "\u0120PTS": 20907, "\u0120Violence": 20908, "ointed": 20909, "shots": 20910, "\u0120excerpt": 20911, "coon": 20912, "INS": 20913, "\u0120Gri": 20914, "\u0120recognised": 20915, "Week": 20916, "Young": 20917, "\u0120vom": 20918, "isle": 20919, "\u0120Curry": 20920, "\u0120Buddh": 20921, "\u0120notebook": 20922, "\u0120durable": 20923, "/?": 20924, "\u0120Gad": 20925, "\u0120Pupp": 20926, "\u0120forgive": 20927, "park": 20928, "\u0120personalities": 20929, "analysis": 20930, "clamation": 20931, "\u0120elevator": 20932, "\u0120warehouse": 20933, "\u0120Role": 20934, "unn": 20935, "\u0120illustration": 20936, "\u0120Scan": 20937, "\u0120atmospheric": 20938, "Import": 20939, "ANC": 20940, "ricted": 20941, "fu": 20942, "010": 20943, "\u0120arche": 20944, "\u0120rewarded": 20945, "akespeare": 20946, "\u0120internally": 20947, "\u0120RBI": 20948, "alker": 20949, "\u0120elephant": 20950, "owitz": 20951, "\u0120Pizza": 20952, "\u0120bipartisan": 20953, "\u00c3\u00a9s": 20954, "\u0120slowed": 20955, "\u0120Stark": 20956, "\u0120override": 20957, "OUS": 20958, "\u0120320": 20959, "undreds": 20960, "\u0120Deck": 20961, "\u0120Census": 20962, "bee": 20963, "146": 20964, "otor": 20965, "\u0120ip": 20966, "\u0120ub": 20967, "ocations": 20968, "\u0120Button": 20969, "rice": 20970, "\u0120cripp": 20971, "fff": 20972, "\u0120originated": 20973, "\u0120overwhelmed": 20974, "appa": 20975, "\u0120foremost": 20976, "\u00e2\u0122\u0133": 20977, "\u0120LEG": 20978, "release": 20979, "eatured": 20980, "atches": 20981, "\u0120reps": 20982, "\u0120lending": 20983, "\u0120Reference": 20984, "\u0120Client": 20985, "165": 20986, "venth": 20987, "Complete": 20988, "\u0120Patrol": 20989, "\u0120sworn": 20990, "cam": 20991, "\u0120shuttle": 20992, "\u0120Ralph": 20993, "\u0120hometown": 20994, "-,": 20995, "onal": 20996, "\u0120BP": 20997, "\u00e5\u0131": 20998, "\u0120persuade": 20999, "\u0120Alexand": 21000, "\u0120combines": 21001, "\u0120vivid": 21002, "\u0120Lag": 21003, "\u0120encoding": 21004, "\u0120salvation": 21005, "wen": 21006, "\u0120Recovery": 21007, "iya": 21008, "University": 21009, "\u0120Biden": 21010, "\u0120budgets": 21011, "\u0120Texans": 21012, "fits": 21013, "\u0120honored": 21014, "\u0120python": 21015, "TD": 21016, "###": 21017, "clone": 21018, "\u0120blink": 21019, "\u0120Liquid": 21020, "\u0120unemployed": 21021, "\u0120clashes": 21022, "\u0120Counsel": 21023, "\u0120directing": 21024, "\u0120punct": 21025, "\u0120Falcons": 21026, "\u0120shark": 21027, "\u0120Damascus": 21028, "\u0120jeans": 21029, "\u0120embark": 21030, "\u0120seize": 21031, "\u0120upwards": 21032, "280": 21033, "\u0120Ez": 21034, "\u0120Anything": 21035, "\u0120exotic": 21036, "lower": 21037, "\u0120Creator": 21038, "\u0120Um": 21039, "\u0120suburbs": 21040, "berger": 21041, "\u0120Wend": 21042, "\u0120mint": 21043, "\u0120XX": 21044, "\u0120Dro": 21045, "\u0120suffers": 21046, "\u0120herb": 21047, "tree": 21048, "\u0120fragile": 21049, "\u0120flooded": 21050, "\u0120Alcohol": 21051, "olean": 21052, "nyder": 21053, "\u0120KO": 21054, "Fram": 21055, "\u0120136": 21056, "\u0120owed": 21057, "\u0120Melee": 21058, "\u0120Hash": 21059, "\u0120whisk": 21060, "\u0120sudo": 21061, "rr": 21062, "Quick": 21063, "appro": 21064, "\u0120ii": 21065, "\u0120Examples": 21066, "hee": 21067, "\u0120promotes": 21068, "perature": 21069, "kar": 21070, "\u0120Honor": 21071, "\u0120sodium": 21072, "\u0120Lif": 21073, "rosso": 21074, "intendent": 21075, "\u0120correspondent": 21076, "Found": 21077, "secret": 21078, "\u0120identifies": 21079, "agne": 21080, "\u0120lou": 21081, "\u0120PP": 21082, "\u0120coincidence": 21083, "move": 21084, "\u0120militia": 21085, "\u0120infiltr": 21086, "\u0120Primary": 21087, "\u0120pitching": 21088, "\u0120Ib": 21089, "\u0120GOOD": 21090, "\u00e3\u0124\u00b8": 21091, "\u0120Wizards": 21092, "iral": 21093, "\u0120Venus": 21094, "RR": 21095, "\u0120\u00e2\u0122\u0137": 21096, "\u0120Casey": 21097, "\u0120sadly": 21098, "\u0120admire": 21099, "\u0120embarrassed": 21100, "cb": 21101, "Mel": 21102, "\u0120tubes": 21103, "\u0120beautifully": 21104, "\u0120Queensland": 21105, "Below": 21106, "rez": 21107, "quet": 21108, "pleasant": 21109, "\u0120\u00c2\u00ab": 21110, "Camp": 21111, "\u0120decisive": 21112, "1998": 21113, "\u0120Lamb": 21114, "utton": 21115, "hn": 21116, "\u0120Jagu": 21117, "aunder": 21118, "\u0120Cord": 21119, "\u0120clerk": 21120, "\u0120caffe": 21121, "\u0120wiped": 21122, "\u0120reim": 21123, "\u0120Mountains": 21124, "\u0120imprisoned": 21125, "\u0120develops": 21126, "\u0120Pra": 21127, "\u0120modeling": 21128, "Anyone": 21129, "ancel": 21130, "\u0120Sit": 21131, "\u0120shields": 21132, "\u0120lawn": 21133, "\u0120cardiovascular": 21134, "\u0120demonstrating": 21135, "\u0120parse": 21136, "\u0120Israelis": 21137, "\u0120euros": 21138, "143": 21139, "\u0120glorious": 21140, "inski": 21141, "ecd": 21142, "\u0120conditioning": 21143, "\u0120helpless": 21144, "\u0120microsc": 21145, "\u0120Harbor": 21146, "\u0120stakes": 21147, "\u0120260": 21148, "\u0120unequ": 21149, "\u0120Floyd": 21150, "\u0120damp": 21151, "\u0120apparatus": 21152, "\u0120Laws": 21153, "\u0120counters": 21154, "\u0120induce": 21155, "atable": 21156, "\u0120Ahmed": 21157, "\u0120slam": 21158, "November": 21159, "\u0120persist": 21160, "\u0120imminent": 21161, "\u00c3\u00a1n": 21162, "\u0120shred": 21163, "\u0120phases": 21164, "\u0120Edmonton": 21165, "\u0120Armstrong": 21166, "\u0120Meet": 21167, "\u0120Kitty": 21168, "\u00d1\u0122": 21169, "circ": 21170, "\u0120Adult": 21171, "\u0120arose": 21172, "\u0120Xen": 21173, "Dan": 21174, "gow": 21175, "\u0120superf": 21176, "\u0120Admir": 21177, "\u0120endure": 21178, "\u0120keyword": 21179, "yrus": 21180, "\u0120yarn": 21181, "\u0120pathway": 21182, "\u0120Hopkins": 21183, "midt": 21184, "\u0120censorship": 21185, "dependent": 21186, "\u0120instructor": 21187, "Sources": 21188, "\u0120toe": 21189, "\u0120balloon": 21190, "Nob": 21191, "\u0120swear": 21192, "\u0120Castro": 21193, "\u0120gloss": 21194, "\u0120Kavanaugh": 21195, "\u0120remarkably": 21196, "Photos": 21197, "\u0120Nom": 21198, "\u0120Southeast": 21199, "yers": 21200, "\u0120validation": 21201, "\u0120cannon": 21202, "\u0120Victory": 21203, "\u0120Pierre": 21204, "\u0120cautious": 21205, "Audio": 21206, "\u0120fetch": 21207, "\u0120Gift": 21208, "\u0120Hyp": 21209, "\u0120remedy": 21210, "ZE": 21211, "\u0120scent": 21212, "\u0120beard": 21213, "\u0120Rut": 21214, "-\"": 21215, "\u0120patents": 21216, "Hy": 21217, "\u0120unjust": 21218, "\u0120potato": 21219, "\u0120forthcoming": 21220, "\u0120chef": 21221, "\u0120Rift": 21222, "affe": 21223, "\u0120ROM": 21224, "\u0120Launch": 21225, "\u0120pads": 21226, "\u0120Neo": 21227, "\u0120onset": 21228, "\u0120squeeze": 21229, "safe": 21230, "\u0120prefix": 21231, "\u0120TM": 21232, "\u0120Nearly": 21233, "\u0120Clinical": 21234, "\u0120Mental": 21235, "otiation": 21236, "\u0120Unic": 21237, "antry": 21238, "\u0120Cir": 21239, "\u0120epit": 21240, "\u00c3\u00a6": 21241, "\u0120extracted": 21242, "versely": 21243, "riad": 21244, "\u0120strains": 21245, "\u0120tops": 21246, "\u0120poem": 21247, "\u0120Randy": 21248, "\u0120Maple": 21249, "THER": 21250, "upiter": 21251, "\u0120SSD": 21252, "\u013c\u00e9": 21253, "\u0120uncon": 21254, "pering": 21255, "\u0120slept": 21256, "iners": 21257, "\u0120underwater": 21258, "\u0120Evidence": 21259, "gone": 21260, "205": 21261, "\u0120historians": 21262, "\u0120synthesis": 21263, "\u0120frog": 21264, "basketball": 21265, "\u0120vibrant": 21266, "\u0120subord": 21267, "\u0120365": 21268, "\u0120Dial": 21269, "\u0120cooperate": 21270, "HAHA": 21271, "\u0120greeted": 21272, "158": 21273, "\u0120jazz": 21274, "\u0120intox": 21275, "\u0120Walking": 21276, "\u0120supervisor": 21277, "\u0120Fusion": 21278, "\u0120Mercedes": 21279, "send": 21280, "Ham": 21281, "sd": 21282, "nl": 21283, "\u0120tours": 21284, "\u0120FIFA": 21285, "\u0120culp": 21286, "gd": 21287, "304": 21288, "\u0120pleas": 21289, "\u0120illustrates": 21290, "\u0120Colombia": 21291, "\u0120highlighting": 21292, "\u0120Summary": 21293, "\u0120exposing": 21294, "\u0120Dru": 21295, "\u0120irony": 21296, "ritional": 21297, "\u0120Carroll": 21298, "\u0120Ellis": 21299, "Pict": 21300, "\u0120Rapt": 21301, "\u0120adapter": 21302, "\u0120unm": 21303, "\u0120corpse": 21304, "\u0120celebrities": 21305, "Den": 21306, "atum": 21307, "\u0120Apocalypse": 21308, "\u0120Wag": 21309, "lining": 21310, "\u0120hormones": 21311, "Rub": 21312, "\u0120Xi": 21313, "\u0120Vaults": 21314, "208": 21315, "alkyrie": 21316, "inosaur": 21317, "\u0120feeds": 21318, "vity": 21319, "\u0120defeating": 21320, "Wait": 21321, "\u0120emphasize": 21322, "\u0120Steelers": 21323, "yrinth": 21324, "leys": 21325, "\u0120Whenever": 21326, "Currently": 21327, "\u0120Clock": 21328, "\u0120collectively": 21329, "anyon": 21330, "\u0120JP": 21331, "\u0120mentality": 21332, "\u0120downloads": 21333, "\u0120surroundings": 21334, "\u0120Barnes": 21335, "\u0120flagship": 21336, "\u0120indicators": 21337, "\u0120grapp": 21338, "January": 21339, "\u0120Elemental": 21340, "\u0120Athena": 21341, "ibal": 21342, "\u0120sights": 21343, "\u0120capita": 21344, "\u0120Treaty": 21345, "\u0120voiced": 21346, "\u0120Gaz": 21347, "lette": 21348, "\u0120ya": 21349, "\u0120expired": 21350, "Legend": 21351, "Hot": 21352, "nature": 21353, "\u0120unstable": 21354, "\u0120280": 21355, "\u00c3\u00ba": 21356, "Comment": 21357, "ALE": 21358, "\u0120quests": 21359, "\u0120handler": 21360, "nis": 21361, "\u0120versatile": 21362, "\u0120conceal": 21363, "engeance": 21364, "\u0120Interactive": 21365, "\u0120obsessed": 21366, "\u0120Dogs": 21367, "\u0120cracked": 21368, "Sound": 21369, "sv": 21370, "\u0120Dylan": 21371, "roads": 21372, "fx": 21373, "\u0120Catholics": 21374, "\u0120Hag": 21375, "\u0120slammed": 21376, "\u0120glowing": 21377, "sale": 21378, "\u0120tissues": 21379, "\u0120Chi": 21380, "nee": 21381, "\u0120cher": 21382, "sic": 21383, "urrection": 21384, "\u0120bacon": 21385, "ulatory": 21386, ").\"": 21387, "\u0120irregular": 21388, "FORM": 21389, "assed": 21390, "\u0120intentional": 21391, "\u0120compensate": 21392, "\u0120Speaking": 21393, "\u0120Sets": 21394, "153": 21395, "\u0120conventions": 21396, "bands": 21397, "emade": 21398, "\u0120ecc": 21399, "\u0120Winston": 21400, "\u0120Assassin": 21401, "\u0120Belgian": 21402, "\u0120dependence": 21403, "\u0120niche": 21404, "\u0120bark": 21405, "\u0120Jazz": 21406, "\u0120disadvantage": 21407, "\u0120gasoline": 21408, "\u0120165": 21409, "\u00e7\u013c\u0126": 21410, "essa": 21411, "module": 21412, "angular": 21413, "OY": 21414, "\u0120Treatment": 21415, "itas": 21416, "olation": 21417, "\u0120Arnold": 21418, "\u0120feud": 21419, "\u0120Nest": 21420, "\u0120theatre": 21421, "ewater": 21422, "\u0120minors": 21423, "olicy": 21424, "\u0120Haven": 21425, "division": 21426, "\u0120trunk": 21427, "Far": 21428, "\u0120Pull": 21429, "\u0120capturing": 21430, "\u01201800": 21431, "\u0120Teen": 21432, "\u0120exempl": 21433, "\u0120clinics": 21434, "\u0120Burg": 21435, "\u0120substit": 21436, "\u0120payload": 21437, "\u0120Lav": 21438, "\u0120Troy": 21439, "\u0120Witness": 21440, "\u0120fragments": 21441, "\u0120passwords": 21442, "\u0120gospel": 21443, "\u0120Gin": 21444, "\u0120tenants": 21445, "olith": 21446, "Six": 21447, "Previous": 21448, "\u0120Ages": 21449, "\u0120Darwin": 21450, "\u0120blat": 21451, "\u0120empathy": 21452, "smith": 21453, "bag": 21454, "\u0120Echo": 21455, "\u0120Camb": 21456, "\u0120Madd": 21457, "\u0120Boo": 21458, "\u0120rede": 21459, "\u0120Burning": 21460, "\u0120smoothly": 21461, "\u0120Adrian": 21462, "\u0120Vampire": 21463, "\u0120Monsters": 21464, "steam": 21465, "Style": 21466, "Ma": 21467, "rea": 21468, "\u0120Dwar": 21469, "alyst": 21470, "ursor": 21471, "\u0120elimination": 21472, "\u0120crypto": 21473, "cht": 21474, "\u0120Eternal": 21475, "\u00e2\u0122\u00a6]": 21476, "\u0120Sorce": 21477, "Ill": 21478, "NER": 21479, "\u0120uh": 21480, "Conclusion": 21481, "wage": 21482, "\u0120respir": 21483, "\u0120reminis": 21484, "hetical": 21485, "\u0120gy": 21486, "\u0120utilized": 21487, "icidal": 21488, "\u01201900": 21489, "\u0120hunters": 21490, "\u0120Swan": 21491, "\u0120React": 21492, "\u0120visitor": 21493, "\u0120Thanksgiving": 21494, "308": 21495, "Posts": 21496, "\u0120hips": 21497, "1997": 21498, "omers": 21499, "\u0120knocking": 21500, "\u0120Vehicle": 21501, "\u0120til": 21502, "\u0120138": 21503, "\u0120mi": 21504, "\u0120Investigation": 21505, "\u0120Kenya": 21506, "\u0120casino": 21507, "\u0120motives": 21508, "\u0120regain": 21509, "rex": 21510, "\u0120weekends": 21511, "\u0120stabbed": 21512, "boro": 21513, "\u0120exploited": 21514, "\u0120HAVE": 21515, "\u0120Television": 21516, "cock": 21517, "\u0120preparations": 21518, "\u0120endeav": 21519, "\u0120Remote": 21520, "\u0120Maker": 21521, "\u0120Produ": 21522, "\u0120Evan": 21523, "\u0120informational": 21524, "\u0120Louisville": 21525, "154": 21526, "\u0120Dreams": 21527, "\u0120plots": 21528, "\u0120Runner": 21529, "\u0120hurting": 21530, "\u0120academy": 21531, "\u0120Montgomery": 21532, "nm": 21533, "\u0120Lanc": 21534, "\u0120Alz": 21535, "210": 21536, "elong": 21537, "\u0120retailer": 21538, "\u0120arising": 21539, "\u0120rebellion": 21540, "\u0120blonde": 21541, "played": 21542, "\u0120instrumental": 21543, "Cross": 21544, "\u0120retention": 21545, "\u0120therapeutic": 21546, "\u0120seas": 21547, "\u0120infantry": 21548, "\u0120Clint": 21549, "\u0120prompting": 21550, "\u0120bitch": 21551, "\u0120stems": 21552, "\u0120Kra": 21553, "\u0120thesis": 21554, "\u0120Bog": 21555, "rued": 21556, "\u0120kings": 21557, "\u0120clay": 21558, "ificent": 21559, "\u0120YES": 21560, "\u0120Thing": 21561, "\u0120Cubs": 21562, "veyard": 21563, "elsh": 21564, "inarily": 21565, "\u0120Ey": 21566, "\u0120Rolling": 21567, "\u0120evolving": 21568, "India": 21569, "\u0120recognizes": 21570, "\u0120graduation": 21571, "isers": 21572, "\u0120fertility": 21573, "\u0120Milan": 21574, "Command": 21575, "\u0120boxing": 21576, "\u01201943": 21577, "\u0120gluten": 21578, "\u0120Emir": 21579, "\u0120idol": 21580, "\u0120conceived": 21581, "\u0120Creation": 21582, "Merit": 21583, "uddy": 21584, "ussions": 21585, "\u0120Lieutenant": 21586, "ietal": 21587, "\u0120unchanged": 21588, "\u0120Scale": 21589, "\u0120Crimea": 21590, "balls": 21591, "atorial": 21592, "\u0120depths": 21593, "\u0120empirical": 21594, "\u0120transm": 21595, "\u0120unsafe": 21596, "missible": 21597, "comfort": 21598, "156": 21599, "\u0120mechanic": 21600, "002": 21601, "lins": 21602, "\u0120smoked": 21603, "Pos": 21604, "\u0120slowing": 21605, "\u0120lav": 21606, "Texas": 21607, "\u0120cheating": 21608, "\u0120Metropolitan": 21609, "ethyl": 21610, "\u0120discovering": 21611, "asse": 21612, "\u0120pencil": 21613, "\u0120Pyongyang": 21614, "\u0120closet": 21615, "\u0120Sheet": 21616, "\u0120Entry": 21617, "oustic": 21618, "\u0120myst": 21619, "erate": 21620, "ariat": 21621, "\u0120minerals": 21622, "\u0120musician": 21623, "\u0120Pul": 21624, "\u0120Maz": 21625, "249": 21626, "\u0120permissions": 21627, "\u0120iv": 21628, "enary": 21629, "ickers": 21630, "\u0120Bing": 21631, "hea": 21632, "enable": 21633, "\u0120griev": 21634, "\u0120asserted": 21635, "\u0120Colonel": 21636, "\u0120affidav": 21637, "wo": 21638, "\u0120seated": 21639, "\u0120Ride": 21640, "\u0120paintings": 21641, "\u0120Pix": 21642, "\u0120137": 21643, "ishi": 21644, "umbai": 21645, "gotten": 21646, "\u0120Earl": 21647, "\u0120inning": 21648, "\u0120census": 21649, "\u0120travelled": 21650, "\u0120Consult": 21651, "185": 21652, "bind": 21653, "\u0120simplicity": 21654, "\u0120overlooked": 21655, "\u0120Helpful": 21656, "\u0120monkey": 21657, "\u0120overwhelmingly": 21658, "Blood": 21659, "\u0120Flint": 21660, "\u0120Jama": 21661, "\u0120Present": 21662, "\u0120Rage": 21663, "\u0120TA": 21664, "ptive": 21665, "\u0120turnout": 21666, "wald": 21667, "\u0120Dolphins": 21668, "\u0120VPN": 21669, "\u0120onion": 21670, "\u0120crafting": 21671, "mma": 21672, "\u0120Mercury": 21673, "\u0120arrange": 21674, "\u0120alerts": 21675, "\u0120OT": 21676, "zbollah": 21677, "\u0120gases": 21678, "\u0120Richardson": 21679, "sal": 21680, "lar": 21681, "\u0120frost": 21682, "\u0120lowering": 21683, "\u0120acclaim": 21684, "\u0120startups": 21685, "\u0120Gain": 21686, "essment": 21687, "\u0120guardian": 21688, "\u00e4\u00ba\u00ba": 21689, "\u0120Pie": 21690, "\u0120Links": 21691, "\u0120merits": 21692, "\u0120awake": 21693, "\u0120parental": 21694, "\u0120exceeds": 21695, "\u0120idle": 21696, "\u0120Pilot": 21697, "\u0120eBay": 21698, "\u0120Accept": 21699, "ipeg": 21700, "Cam": 21701, "\u0120Kot": 21702, "\u0120traders": 21703, "olitics": 21704, "unker": 21705, "\u0120Pale": 21706, "osi": 21707, "anmar": 21708, "\u01201947": 21709, "\u0120Fell": 21710, "estial": 21711, "itating": 21712, "GF": 21713, "\u0120Sr": 21714, "ifted": 21715, "\u0120connector": 21716, "\u0120Bone": 21717, "illes": 21718, "260": 21719, "hma": 21720, "\u0120overlap": 21721, "\u0120GitHub": 21722, "\u0120cleaner": 21723, "\u0120Baptist": 21724, "\u0120WAS": 21725, "\u0120lungs": 21726, "\u00d1\u0123": 21727, "\u0120BUT": 21728, "\u0120cite": 21729, "\u0120pitched": 21730, "reatment": 21731, "\u0120trophies": 21732, "\u0120Nu": 21733, "386": 21734, "\u0120Pride": 21735, "\u0120attendees": 21736, "[]": 21737, "179": 21738, "\u0120spatial": 21739, "\u0120prizes": 21740, "\u0120Religion": 21741, "\u0120showcase": 21742, "\u0120Category": 21743, "vidia": 21744, "Target": 21745, "Property": 21746, "?,": 21747, "\u0120fusion": 21748, "pie": 21749, "\u0120UCLA": 21750, "\u0120soundtrack": 21751, "\u0120princess": 21752, "\u0120Caval": 21753, "should": 21754, "\u0120limbs": 21755, "Background": 21756, "\u0120lonely": 21757, "\u0120cores": 21758, "\u0120Tail": 21759, "sheet": 21760, "\u0120132": 21761, "Ra": 21762, "\u00e3\u0124\u00ab": 21763, "\u0120Bolt": 21764, "\u0120booked": 21765, "\u0120administer": 21766, "\u0120equals": 21767, "wy": 21768, "\u0120observing": 21769, "\u0120Baron": 21770, "\u0120Adobe": 21771, "\u0120virgin": 21772, "\u0120Socialist": 21773, "Move": 21774, "ghazi": 21775, "\u0120Linda": 21776, "212": 21777, "\u0120brewing": 21778, "\u0120merchants": 21779, "burse": 21780, "\u0120divor": 21781, "\u0120metals": 21782, "\u0120Ner": 21783, "\u0120sums": 21784, "\u0120Enemy": 21785, "\u0120envision": 21786, "\u0120granting": 21787, "\u0120Honey": 21788, "\u0120Skyrim": 21789, "\u0120socio": 21790, "graded": 21791, "\u0120selective": 21792, "WASHINGTON": 21793, "\u01201948": 21794, "\u0120Sirius": 21795, "\u0120Gross": 21796, "activity": 21797, "\u0120Ivan": 21798, "\u0120furious": 21799, "BSD": 21800, "\u0120Previous": 21801, "\u0120responsive": 21802, "\u0120charitable": 21803, "\u0120leaning": 21804, "\u0120Pew": 21805, "\u0120violates": 21806, "\\\\\\\\\\\\\\\\": 21807, "\u0120Coming": 21808, "wire": 21809, "\u0120poet": 21810, "\u0120resolutions": 21811, "command": 21812, "\u0120Portuguese": 21813, "\u0120nickname": 21814, "\u0120deaf": 21815, "February": 21816, "\u0120recognise": 21817, "\u0120entirety": 21818, "\u0120seasonal": 21819, "placed": 21820, "\u0120Telegraph": 21821, "\u0120microphone": 21822, "ouring": 21823, "\u0120grains": 21824, "\u0120governed": 21825, "\u0120postp": 21826, "\u0120Waters": 21827, "inement": 21828, "\u0120undocumented": 21829, "\u0120Comcast": 21830, "\u0120fox": 21831, "\u0120assaults": 21832, "reon": 21833, "many": 21834, "\u0120Jenkins": 21835, "\u0120Anyway": 21836, "\u0120assessments": 21837, "\u0120downs": 21838, "\u0120Mouse": 21839, "\u0120superb": 21840, "kt": 21841, "\u0120Dow": 21842, "\u0120taxation": 21843, "401": 21844, "\u0120smiles": 21845, "\u0120undertaken": 21846, "\u0120exh": 21847, "\u0120enthusiastic": 21848, "\u0120twent": 21849, "\u0120governmental": 21850, "\u0120autonomy": 21851, "\u0120Technologies": 21852, "\u0120Chain": 21853, "\u0120prevalent": 21854, "fb": 21855, "\u0120nicotine": 21856, "ogram": 21857, "job": 21858, "\u0120awaiting": 21859, "\u0120Menu": 21860, "\u0120deputies": 21861, "kov": 21862, "ishops": 21863, "Button": 21864, "\u0120Shanghai": 21865, "\u0120diesel": 21866, "\u0120Duck": 21867, "Ryan": 21868, "\u0120PCs": 21869, "NF": 21870, "jury": 21871, "ente": 21872, "\u0120inaccurate": 21873, "eddy": 21874, "Whatever": 21875, "\u0120showc": 21876, "\u0120Nad": 21877, "odus": 21878, "etr": 21879, "\u0120plaintiffs": 21880, "\u0120WOR": 21881, "\u0120Assange": 21882, "\u0120privat": 21883, "\u0120premiums": 21884, "\u0120tam": 21885, "URL": 21886, "\u0120elites": 21887, "\u0120Ranger": 21888, "ottenham": 21889, "\u0120Hoff": 21890, "\u0120Athens": 21891, "\u0120definite": 21892, "\u0120sighed": 21893, "\u0120evenly": 21894, "211": 21895, "\u0120Amber": 21896, "akia": 21897, "\u0120mailing": 21898, "\u0120crashing": 21899, "\u0120Confederate": 21900, "rugged": 21901, "Wal": 21902, "\u0120Depths": 21903, "\u0120juvenile": 21904, "\u0120reactor": 21905, "Introduction": 21906, "\u0120Deluxe": 21907, "1995": 21908, "\u0120Sanchez": 21909, "\u0120Mead": 21910, "ivable": 21911, ":-": 21912, "\u0120Planning": 21913, "\u0120Trap": 21914, "quin": 21915, "\u0120Protect": 21916, "vered": 21917, "Information": 21918, "\u0120kidney": 21919, "innamon": 21920, "las": 21921, "\u0120policing": 21922, "\u0120tolerate": 21923, "\u0120Qi": 21924, "\u0120biased": 21925, "Fort": 21926, "\u0120Ki": 21927, "save": 21928, "\u0120privileged": 21929, "\u0120beasts": 21930, "\u0120Glas": 21931, "\u0120Cinem": 21932, "\u0120comeback": 21933, "Sunday": 21934, "\u0120extinction": 21935, "hops": 21936, "\u0120transmit": 21937, "\u0120doubles": 21938, "\u0120Flat": 21939, "167": 21940, "\u0120disputed": 21941, "\u0120injustice": 21942, "foo": 21943, "Vict": 21944, "roleum": 21945, "\u0120Julie": 21946, "Context": 21947, "\u0120Rarity": 21948, "issue": 21949, "Component": 21950, "\u0120counseling": 21951, "anne": 21952, "dark": 21953, "\u0120objections": 21954, "uilt": 21955, "\u0120gast": 21956, "\u0120plac": 21957, "\u0120unused": 21958, "\u00e3\u0125\u0129": 21959, "\u0120Trial": 21960, "\u0120Jas": 21961, "hedral": 21962, "obb": 21963, "\u0120temporal": 21964, "\u0120PRO": 21965, "\u0120NW": 21966, "\u0120Anniversary": 21967, "Large": 21968, "\u0120therm": 21969, "\u0120david": 21970, "\u0120systemic": 21971, "\u0120Shir": 21972, "mut": 21973, "\u0120Nept": 21974, "address": 21975, "\u0120scanning": 21976, "\u0120understandable": 21977, "\u0120canvas": 21978, "Cat": 21979, "\u0120Zoo": 21980, "\u0120angels": 21981, "LO": 21982, "\u0120Statement": 21983, "\u0120Sig": 21984, "ovable": 21985, "\u0120Away": 21986, "sharing": 21987, "ocrats": 21988, "stated": 21989, "\u0120weighing": 21990, "Nor": 21991, "wild": 21992, "Bey": 21993, "\u0120astonishing": 21994, "\u0120Reynolds": 21995, "\u0120opener": 21996, "\u0120trainer": 21997, "\u0120surgical": 21998, "pn": 21999, "\u0120adjusting": 22000, "wheel": 22001, "\u0120frown": 22002, "ervative": 22003, "\u0120suspend": 22004, "Within": 22005, "tein": 22006, "\u0120obstacle": 22007, "\u0120liberties": 22008, "ymes": 22009, "\u0120uranium": 22010, "ansom": 22011, "anol": 22012, "uba": 22013, "\u0120Loss": 22014, "\u0120arous": 22015, "\u0120Henderson": 22016, "Wow": 22017, "spl": 22018, "cur": 22019, "\u0120\u00c2\u0143": 22020, "\u0120theirs": 22021, "Damage": 22022, "\u0120downloading": 22023, "\u0120discern": 22024, "\u0120Sto": 22025, "\u0120Fla": 22026, "\u0120hath": 22027, "\u0120Aj": 22028, "\u0120unpleasant": 22029, "European": 22030, "expensive": 22031, "\u0120screenshot": 22032, "\u0120UV": 22033, "\u0120allied": 22034, "\u0120Persian": 22035, "\u0120monopoly": 22036, "\u0120atom": 22037, "\u0120Redskins": 22038, "\"><": 22039, "\u0120cancell": 22040, "\u0120cinema": 22041, "131": 22042, "fair": 22043, "\u0120Alfred": 22044, "\u0120duck": 22045, "args": 22046, "223": 22047, "\u0120ISI": 22048, "\u0120signaling": 22049, "inar": 22050, "\u0120laughs": 22051, "\u0120forwards": 22052, "\u0120reckless": 22053, "\u0120listeners": 22054, "ativity": 22055, "\u0120vastly": 22056, "nant": 22057, "Less": 22058, "\u0120Hunting": 22059, "\u0120Scientific": 22060, "ITED": 22061, "\u0120knight": 22062, "\u0120HTC": 22063, "usa": 22064, "tmp": 22065, "\u0120rude": 22066, "\u0120Legendary": 22067, "\u0120arises": 22068, "Bad": 22069, "\u0120Claim": 22070, "peg": 22071, "\u0120realities": 22072, "Think": 22073, "\u0120\u00c2\u00b0": 22074, "\u0120rode": 22075, "\u0120strive": 22076, "\u0120anecd": 22077, "\u0120shorts": 22078, "\u0120hypothes": 22079, "\u0120coordinated": 22080, "\u0120Gandhi": 22081, "\u0120FPS": 22082, "RED": 22083, "\u0120susceptible": 22084, "\u0120shrink": 22085, "\u0120Chart": 22086, "Help": 22087, "\u0120ion": 22088, "deep": 22089, "ribes": 22090, "\u0120Kai": 22091, "\u0120Customer": 22092, "Summary": 22093, "\u0120cough": 22094, "wife": 22095, "\u0120lend": 22096, "\u0120positioning": 22097, "\u0120lottery": 22098, "\u0120Canyon": 22099, "\u0120fade": 22100, "\u0120bronze": 22101, "\u0120Kenny": 22102, "\u0120boasts": 22103, "\u0120Enhanced": 22104, "record": 22105, "\u0120emergence": 22106, "\u0120akin": 22107, "\u0120Bert": 22108, "itous": 22109, "\u00e2\u0138\u0133": 22110, "\u0120stip": 22111, "\u0120exchanged": 22112, "omore": 22113, "alsh": 22114, "\u0120reservoir": 22115, "\u0120standpoint": 22116, "WM": 22117, "\u0120initiate": 22118, "\u0120decay": 22119, "\u0120brewery": 22120, "\u0120terribly": 22121, "\u0120mortal": 22122, "levard": 22123, "\u0120revis": 22124, "NI": 22125, "elo": 22126, "\u0120confess": 22127, "\u0120MSNBC": 22128, "\u0120submissions": 22129, "Controller": 22130, "\u0120202": 22131, "\u0120Ruth": 22132, "});": 22133, "\u0120Azure": 22134, "\u0120.\"": 22135, "206": 22136, "\u0120Marketing": 22137, "\u0120laund": 22138, "iencies": 22139, "\u0120renowned": 22140, "\u0120Trou": 22141, "\u0120NGO": 22142, "blems": 22143, "\u0120terrified": 22144, "\u0120warns": 22145, "\u0120pert": 22146, "\u0120unsure": 22147, "480": 22148, "alez": 22149, "ultz": 22150, "\u0120Outside": 22151, "\u0120styl": 22152, "\u0120Underground": 22153, "\u0120panc": 22154, "\u0120dictionary": 22155, "\u0120foe": 22156, "riminal": 22157, "\u0120Norwegian": 22158, "\u0120jailed": 22159, "\u0120maternal": 22160, "\u00c3\u00a9e": 22161, "\u0120Lucy": 22162, "cop": 22163, "Cho": 22164, "\u0120unsigned": 22165, "\u0120Zelda": 22166, "\u0120Insider": 22167, "\u0120Continued": 22168, "\u0120133": 22169, "\u0120Naruto": 22170, "\u0120Majority": 22171, "169": 22172, "\u0120Wo": 22173, "\u00e3\u0124\u0135": 22174, "\u0120pastor": 22175, "\u0120informal": 22176, "\u00d0\u00bd": 22177, "anthrop": 22178, "join": 22179, "\u00e3\u0123\u0139": 22180, "itational": 22181, "NP": 22182, "\u0120Writing": 22183, "fn": 22184, "\u0120Bever": 22185, "195": 22186, "\u0120yelling": 22187, "\u0120drastically": 22188, "\u0120eject": 22189, "\u0120neut": 22190, "\u0120thrive": 22191, "\u0120Frequ": 22192, "oux": 22193, "\u0120possesses": 22194, "\u0120Senators": 22195, "\u0120DES": 22196, "\u0120Shakespeare": 22197, "\u0120Franco": 22198, "\u0120LB": 22199, "uchi": 22200, "\u0120incarn": 22201, "\u0120founders": 22202, "Function": 22203, "\u0120brightness": 22204, "\u0120BT": 22205, "\u0120whale": 22206, "\u0120Theater": 22207, "mass": 22208, "\u0120Doll": 22209, "Something": 22210, "\u0120echoed": 22211, "\u0120Hex": 22212, "crit": 22213, "afia": 22214, "\u0120goddess": 22215, "\u0120eleven": 22216, "\u0120Preview": 22217, "\u0120Aurora": 22218, "\u0120401": 22219, "ulsive": 22220, "\u0120Logan": 22221, "inburgh": 22222, "\u0120Centers": 22223, "\u0120ONLY": 22224, "\u0120Aid": 22225, "\u0120paradox": 22226, "\u0120hurd": 22227, "\u0120LC": 22228, "Due": 22229, "court": 22230, "\u0120offended": 22231, "\u0120evaluating": 22232, "\u0120Matthews": 22233, "\u0120tomb": 22234, "\u0120payroll": 22235, "\u0120extraction": 22236, "\u0120Hands": 22237, "ifi": 22238, "\u0120supernatural": 22239, "\u0120COMM": 22240, "]=": 22241, "dogs": 22242, "\u0120512": 22243, "\u0120Meeting": 22244, "Richard": 22245, "\u0120Maximum": 22246, "\u0120ideals": 22247, "Things": 22248, "mand": 22249, "\u0120Regardless": 22250, "\u0120humili": 22251, "buffer": 22252, "Little": 22253, "\u0120Dani": 22254, "\u0120Nak": 22255, "\u0120liberation": 22256, "\u0120Abe": 22257, "\u0120OL": 22258, "\u0120stuffed": 22259, "aca": 22260, "inda": 22261, "raphic": 22262, "\u0120mosqu": 22263, "\u0120campaigning": 22264, "\u0120occupy": 22265, "Squ": 22266, "rina": 22267, "\u0120Wel": 22268, "\u0120VS": 22269, "\u0120physic": 22270, "\u0120puls": 22271, "rint": 22272, "oaded": 22273, "ETF": 22274, "\u0120Archives": 22275, "\u0120venues": 22276, "hner": 22277, "\u0120Turbo": 22278, "\u0120lust": 22279, "\u0120appealed": 22280, "quez": 22281, "ilib": 22282, "\u0120Timothy": 22283, "\u0120omn": 22284, "dro": 22285, "\u0120obsession": 22286, "\u0120Savage": 22287, "1996": 22288, "Global": 22289, "Jes": 22290, "214": 22291, "\u0120sliding": 22292, "\u0120disappro": 22293, "\u0120Magical": 22294, "\u0120voluntarily": 22295, "gb": 22296, "aney": 22297, "\u0120prophet": 22298, "\u0120Rein": 22299, "\u0120Julia": 22300, "\u0120Worth": 22301, "aurus": 22302, "\u0120bounds": 22303, "ieu": 22304, ")))": 22305, "\u0120crore": 22306, "\u0120Citizen": 22307, "Sky": 22308, "\u0120columnist": 22309, "\u0120seekers": 22310, "ondo": 22311, "ISA": 22312, "\u0120Length": 22313, "\u0120nostalg": 22314, "\u0120newcom": 22315, "\u0120detrim": 22316, "entric": 22317, "375": 22318, "\u0120GE": 22319, "\u0120autop": 22320, "\u0120academics": 22321, "AppData": 22322, "\u0120Shen": 22323, "\u0120idiot": 22324, "\u0120Transit": 22325, "\u0120teaspoon": 22326, "Wil": 22327, "KO": 22328, "\u0120Comedy": 22329, ">,": 22330, "\u0120populated": 22331, "WD": 22332, "\u0120pigs": 22333, "\u0120Oculus": 22334, "\u0120sympathetic": 22335, "\u0120marathon": 22336, "198": 22337, "\u0120seizure": 22338, "sided": 22339, "\u0120dop": 22340, "irtual": 22341, "Land": 22342, "\u0120Floor": 22343, "osaurs": 22344, "...]": 22345, "\u0120los": 22346, "\u0120subsidiary": 22347, "EY": 22348, "\u0120Parts": 22349, "\u0120Stef": 22350, "\u0120Judiciary": 22351, "\u0120134": 22352, "\u0120mirrors": 22353, "\u0120ket": 22354, "times": 22355, "\u0120neurolog": 22356, "\u0120cav": 22357, "\u0120Guest": 22358, "\u0120tumor": 22359, "scill": 22360, "\u0120Lloyd": 22361, "Est": 22362, "\u0120clearer": 22363, "\u0120stereotypes": 22364, "\u0120dur": 22365, "nothing": 22366, "Reddit": 22367, "\u0120negotiated": 22368, "------------------------": 22369, "235": 22370, "\u0120flown": 22371, "\u0120Seoul": 22372, "\u0120Resident": 22373, "\u0120SCH": 22374, "\u0120disappearance": 22375, "\u0120Vince": 22376, "grown": 22377, "\u0120grabs": 22378, "ril": 22379, "\u0120Infinite": 22380, "\u0120Twenty": 22381, "\u0120pedestrian": 22382, "\u0120jersey": 22383, "\u0120Fur": 22384, "\u0120Infinity": 22385, "\u0120Elliott": 22386, "\u0120mentor": 22387, "\u0120morally": 22388, "\u0120obey": 22389, "secure": 22390, "iffe": 22391, "\u0120antibiotics": 22392, "angled": 22393, "\u0120Freeman": 22394, "\u0120Introduction": 22395, "Jun": 22396, "\u0120marsh": 22397, "icans": 22398, "\u0120EVENTS": 22399, "ochond": 22400, "Wall": 22401, "iculty": 22402, "\u0120misdemeanor": 22403, "\u0120ly": 22404, "Thomas": 22405, "\u0120Resolution": 22406, "\u0120animations": 22407, "\u0120Dry": 22408, "\u0120intercourse": 22409, "\u0120Newcastle": 22410, "\u0120Hog": 22411, "\u0120Equipment": 22412, "177": 22413, "\u0120territorial": 22414, "\u0120archives": 22415, "203": 22416, "Filter": 22417, "\u0120Munich": 22418, "\u0120commanded": 22419, "\u0120Wand": 22420, "\u0120pitches": 22421, "\u0120Croat": 22422, "\u0120ratios": 22423, "\u0120Mits": 22424, "\u0120accumulated": 22425, "\u0120Specifically": 22426, "\u0120gentleman": 22427, "acerb": 22428, "\u0120penn": 22429, "\u0120aka": 22430, "\u0120Fuk": 22431, "\u0120intervene": 22432, "\u0120Refuge": 22433, "\u0120Alzheimer": 22434, "\u0120succession": 22435, "ohan": 22436, "does": 22437, "Lord": 22438, "\u0120separat": 22439, "\u0120correspondence": 22440, "\u0120shiny": 22441, "Prior": 22442, "\u0120sulf": 22443, "\u0120miserable": 22444, "\u0120dedication": 22445, "().": 22446, "\u0120specialists": 22447, "\u0120defects": 22448, "\u0120Cult": 22449, "\u0120Xia": 22450, "\u0120jeopard": 22451, "\u0120Ore": 22452, "Ability": 22453, "\u0120lear": 22454, "\u0120ambitions": 22455, "\u0120BMI": 22456, "\u0120Arabs": 22457, "\u01201942": 22458, "\u0120preservation": 22459, "ificate": 22460, "\u0120ashamed": 22461, "loss": 22462, "\u0120Restaur": 22463, "\u0120resemble": 22464, "\u0120enrich": 22465, "\u0120KN": 22466, "\u0120Clan": 22467, "float": 22468, "\u0120playable": 22469, "ITT": 22470, "\u0120harmony": 22471, "arrison": 22472, "\u0120Weinstein": 22473, "were": 22474, "\u0120poisoning": 22475, "\u0120Comput": 22476, "\u0120WordPress": 22477, "major": 22478, "\u0120Valve": 22479, "Fan": 22480, "\u0120Throw": 22481, "\u0120Romans": 22482, "\u0120Depression": 22483, "ados": 22484, "\u0120tortured": 22485, "\u0120balancing": 22486, "bottom": 22487, "\u0120acquiring": 22488, "\u0120Monte": 22489, "ardi": 22490, "\u0120aura": 22491, "\u0120##": 22492, "\u0120Standing": 22493, "\u0120Atlas": 22494, "CF": 22495, "\u0120intrins": 22496, "\u0120Benghazi": 22497, "\u0120camping": 22498, "\u0120tapped": 22499, "blade": 22500, "strous": 22501, "\u0120Rabb": 22502, "\u0120Written": 22503, "tip": 22504, "\u0120Neigh": 22505, "sterdam": 22506, "\u0120Allow": 22507, "\u0120Healing": 22508, "\u0120Rhod": 22509, "num": 22510, "\u0120caffeine": 22511, "\u0120Percent": 22512, "\u0120boo": 22513, "\u0120apples": 22514, "305": 22515, "\u0120welcoming": 22516, "\u0120applaud": 22517, "\u0120austerity": 22518, "\u00c2\u00b1": 22519, "\u0120Reality": 22520, "efe": 22521, "\u00e5\u00ae": 22522, "\u0120sucks": 22523, "\u0120tabs": 22524, "\u0120PayPal": 22525, "\u0120backpack": 22526, "\u0120gifted": 22527, "abulary": 22528, "\u0120Scout": 22529, "irteen": 22530, "\u0120chin": 22531, "\u0120omitted": 22532, "\u0120negatively": 22533, "\u0120accessing": 22534, "\u0120Earn": 22535, "\u0120ambulance": 22536, "\u0120headphones": 22537, "\u0120205": 22538, "\u0120Refresh": 22539, "president": 22540, "\u0120Kitchen": 22541, "\u0120Entered": 22542, "\u0120Snyder": 22543, "005": 22544, "omical": 22545, "\u0120borrowed": 22546, "\u0120Nem": 22547, "\u0120aviation": 22548, "\u0120stall": 22549, "rimination": 22550, "\u0120uniforms": 22551, "itime": 22552, "\u0120Simmons": 22553, "energy": 22554, "ablished": 22555, "yy": 22556, "qualified": 22557, "\u0120rallies": 22558, "\u0120Stuart": 22559, "flight": 22560, "\u0120gangs": 22561, "rag": 22562, "\u0120vault": 22563, "lux": 22564, "\u0120Compar": 22565, "\u0120designation": 22566, "209": 22567, "\u0120Jos": 22568, "dollar": 22569, "zero": 22570, "\u0120wells": 22571, "303": 22572, "\u0120constituents": 22573, "\u0120heck": 22574, "\u0120cows": 22575, "\u0120commanders": 22576, "\u0120differential": 22577, "\u0120Catherine": 22578, "299": 22579, "\u0120valve": 22580, "\u0120brace": 22581, "\u0120perspectives": 22582, "cert": 22583, "fact": 22584, "icularly": 22585, "\u0120McN": 22586, "planes": 22587, "\u0120intric": 22588, "\u0120peas": 22589, "ovan": 22590, "\u0120tossed": 22591, "retch": 22592, "\u0120Lopez": 22593, "\u0120unfamiliar": 22594, "death": 22595, "\u0120Apart": 22596, "\u0120Chang": 22597, "\u0120relieved": 22598, "rophe": 22599, "\u0120airports": 22600, "\u0120freak": 22601, "util": 22602, "Mill": 22603, "\u0120Chin": 22604, "\u0120Owen": 22605, "male": 22606, "\u0120Broken": 22607, "\u0120Winds": 22608, "rob": 22609, "rising": 22610, "\u0120firefighters": 22611, "\u0120authoritarian": 22612, "\u0120148": 22613, "Bitcoin": 22614, "external": 22615, "\u0120browsers": 22616, "ichever": 22617, "orian": 22618, "\u0120unb": 22619, "\u0120poke": 22620, "\u0120Zot": 22621, "Mid": 22622, "\u0120Popular": 22623, "\u0120covert": 22624, "\u0120contributes": 22625, "\u0120650": 22626, "\u0120contention": 22627, "Gate": 22628, "\u0120consoles": 22629, "\u0120chromos": 22630, "\u0120IX": 22631, "\u0120visually": 22632, "\u0120Eisen": 22633, "\u0120jewelry": 22634, "\u0120delegation": 22635, "\u0120accelerate": 22636, "\u0120Riley": 22637, "\u0120slope": 22638, "\u0120indoor": 22639, "itially": 22640, "\u0120hugely": 22641, "\u0120tunnels": 22642, "\u0120fined": 22643, "\u0120directive": 22644, "\u0120forehead": 22645, "ustomed": 22646, "\u0120skate": 22647, "Music": 22648, "gas": 22649, "\u0120recognizing": 22650, "ambo": 22651, "\u0120overweight": 22652, "\u0120Grade": 22653, "\u00d9\u012c": 22654, "\u0120sounding": 22655, "\u0120locking": 22656, "\u0120REM": 22657, "Store": 22658, "\u0120excav": 22659, "\u0120Likewise": 22660, "\u0120Lights": 22661, "\u0120elbow": 22662, "\u0120Supply": 22663, "wic": 22664, "\u0120handsome": 22665, "1994": 22666, "Coll": 22667, "\u0120adequately": 22668, "\u0120Associate": 22669, "\u0120strips": 22670, "\u0120crackdown": 22671, "\u0120marvel": 22672, "\u0120Kun": 22673, "\u0120passages": 22674, "@@@@": 22675, "\u0120Tall": 22676, "\u0120thoughtful": 22677, "namese": 22678, "\u0120prostitution": 22679, "business": 22680, "\u0120ballistic": 22681, "personal": 22682, "cig": 22683, "izational": 22684, "Round": 22685, "\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142": 22686, "\u0120Coleman": 22687, "\u0120admitting": 22688, "\u0120Plug": 22689, "\u0120bitcoins": 22690, "\u0120Suz": 22691, "\u0120fairness": 22692, "\u0120supplier": 22693, "\u0120catastrophic": 22694, "\u0120Helen": 22695, "oqu": 22696, "Marc": 22697, "\u0120Articles": 22698, "gie": 22699, "\u0120endangered": 22700, "\u0120destiny": 22701, "\u0120Volt": 22702, "olia": 22703, "axis": 22704, "\u0120cheat": 22705, "\u0120unified": 22706, "ICO": 22707, "quote": 22708, "302": 22709, "\u0120Sed": 22710, "\u0120suppression": 22711, "\u0120analyzing": 22712, "\u0120squat": 22713, "\u0120figuring": 22714, "\u0120coordinates": 22715, "\u0120chunks": 22716, "\u01201946": 22717, "\u0120subp": 22718, "\u0120wiki": 22719, "\u0120Forbes": 22720, "\u0120Jupiter": 22721, "\u0120Erik": 22722, "imer": 22723, "\u0120Commercial": 22724, "\\)": 22725, "\u0120legitimacy": 22726, "\u0120dental": 22727, "\u0120Mean": 22728, "\u0120deficits": 22729, "550": 22730, "Originally": 22731, "\u0120Horror": 22732, "\u0120contamination": 22733, "llah": 22734, "\u0120confisc": 22735, "\u0120Clare": 22736, "TB": 22737, "\u0120Failed": 22738, "aned": 22739, "\u0120ruler": 22740, "\u0120Controller": 22741, "\u0120feminists": 22742, "Fix": 22743, "gay": 22744, "207": 22745, "\u0120rabbit": 22746, "Third": 22747, "owntown": 22748, "\u0120glue": 22749, "\u0120volatile": 22750, "\u0120shining": 22751, "\u0120foll": 22752, "\u0120impaired": 22753, "\u0120supers": 22754, "\u00e6\u012a": 22755, "\u0120clutch": 22756, "\u013c\u00e9\u0128\u0134": 22757, "\u0120prolet": 22758, "\u0120(!": 22759, "\u0120yelled": 22760, "\u0120Kiev": 22761, "\u0120Ern": 22762, "\u0120Shock": 22763, "KB": 22764, "\u0120situated": 22765, "query": 22766, "\u0120Nas": 22767, "\u0120annex": 22768, "character": 22769, "\u0120Holiday": 22770, "\u0120automation": 22771, "\u0120Jill": 22772, "\u0120Remastered": 22773, "\u0120linem": 22774, "\u0120wilderness": 22775, "\u0120Horizon": 22776, "\u0120Guinea": 22777, "AZ": 22778, "\u0120mainland": 22779, "\u0120secrecy": 22780, "LEASE": 22781, "\u0120punk": 22782, "\u0120Province": 22783, "(),": 22784, "Speed": 22785, "\u0120handing": 22786, "\u0120Sebast": 22787, "Sir": 22788, "rase": 22789, "\u0120journals": 22790, "\u0120congest": 22791, "\u0120Tut": 22792, "irrel": 22793, "\u0120schizophrenia": 22794, "\u0120misogyn": 22795, "healthy": 22796, "Iron": 22797, "\u0120reacted": 22798, "-$": 22799, "252": 22800, "\u0120plural": 22801, "\u0120plum": 22802, "\u0120bargain": 22803, "\u0120grounded": 22804, "finder": 22805, "\u0120disse": 22806, "\u0120Laz": 22807, "OOD": 22808, "\u0120atroc": 22809, "Factory": 22810, "\u0120minions": 22811, "\u0120ori": 22812, "\u0120Brave": 22813, "\u0120PRE": 22814, "\u0120Myanmar": 22815, "\u0120Hod": 22816, "\u0120expedition": 22817, "\u0120explode": 22818, "\u0120Coord": 22819, "\u0120extr": 22820, "\u0120Brief": 22821, "\u0120ADHD": 22822, "\u0120hardcore": 22823, "feeding": 22824, "\u0120dile": 22825, "\u0120Fruit": 22826, "\u0120vaccination": 22827, "\u0120Mao": 22828, "osphere": 22829, "\u0120contests": 22830, "-|": 22831, "\u0120fren": 22832, "isphere": 22833, "Rom": 22834, "\u0120Sharp": 22835, "\u0120Trend": 22836, "\u0120disconnect": 22837, "\u00e2\u0122\u00a2\u00e2\u0122\u00a2": 22838, "\u0120persecution": 22839, "Earth": 22840, "\u0120healthier": 22841, "384": 22842, "\u0120cob": 22843, "\u0120Trinity": 22844, "OWS": 22845, "ANN": 22846, "\u0120specialty": 22847, "\u0120gru": 22848, "\u0120cooperative": 22849, "why": 22850, "Starting": 22851, "\u0120Issues": 22852, "stre": 22853, "ensor": 22854, "\u0120185": 22855, "Adv": 22856, "!?": 22857, "\u0120Revel": 22858, "emia": 22859, "\u0120Hulk": 22860, "\u0120celebrations": 22861, "\u0120Sou": 22862, "raud": 22863, "\u0120Klein": 22864, "\u0120unreal": 22865, "context": 22866, "\u0120partnerships": 22867, "\u0120adopting": 22868, "tical": 22869, "\u0120splash": 22870, "\u0120Hezbollah": 22871, "category": 22872, "cyclop": 22873, "xton": 22874, "\u0120Dot": 22875, "urdy": 22876, "tz": 22877, "\u0120envelope": 22878, "\u0120NL": 22879, "\u00e2\u0137": 22880, "\u0120wherein": 22881, "Spec": 22882, "184": 22883, "\u0120telev": 22884, "aliation": 22885, "\u0120myths": 22886, "\u00e5\u00b0": 22887, "\u0120rigorous": 22888, "\u0120communicating": 22889, "\u0120observer": 22890, "\u0120rehe": 22891, "\u0120Wash": 22892, "\u0120apologized": 22893, "\u0120Tin": 22894, "\u0120expenditures": 22895, "workers": 22896, "document": 22897, "\u0120hesitate": 22898, "\u0120Lenin": 22899, "\u0120unpredictable": 22900, "\u0120renewal": 22901, "cler": 22902, "okia": 22903, "\u0120CONT": 22904, "\u0120postseason": 22905, "Tokens": 22906, "\u0120exacerb": 22907, "\u0120betting": 22908, "\u0120147": 22909, "\u0120elevation": 22910, "Wood": 22911, "\u0120Solomon": 22912, "194": 22913, "004": 22914, "output": 22915, "\u0120redund": 22916, "\u0120Mumbai": 22917, "\u0120pH": 22918, "\u0120reproduce": 22919, "\u0120Duration": 22920, "MAX": 22921, "\u0120bog": 22922, "CBS": 22923, "\u0120Balance": 22924, "\u0120Sgt": 22925, "\u0120Recent": 22926, "\u0120cd": 22927, "\u0120popped": 22928, "\u0120incompet": 22929, "prop": 22930, "ayan": 22931, "guy": 22932, "Pacific": 22933, "\u0120tyr": 22934, "\u0120{{": 22935, "\u0120Mystic": 22936, "\u0120Dana": 22937, "\u0120masturb": 22938, "\u0120geometry": 22939, "\u00c3\u00a2": 22940, "\u0120Correct": 22941, "\u0120trajectory": 22942, "\u0120distracted": 22943, "\u0120foo": 22944, "\u0120Welsh": 22945, "Luc": 22946, "mith": 22947, "\u0120rugby": 22948, "\u0120respiratory": 22949, "\u0120triangle": 22950, "\u0120215": 22951, "\u0120undergraduate": 22952, "\u0120Superior": 22953, "changing": 22954, "_-": 22955, "\u0120rightly": 22956, "\u0120referee": 22957, "\u0120lucrative": 22958, "\u0120unauthorized": 22959, "\u0120resembles": 22960, "\u0120GNU": 22961, "\u0120Derby": 22962, "\u0120pathways": 22963, "\u0120Led": 22964, "\u0120endurance": 22965, "\u0120stint": 22966, "\u0120collector": 22967, "Fast": 22968, "\u0120dots": 22969, "\u0120nationals": 22970, "\u0120Securities": 22971, "\u0120whip": 22972, "Param": 22973, "\u0120learns": 22974, "Magic": 22975, "\u0120detailing": 22976, "moon": 22977, "\u0120broadcasting": 22978, "\u0120baked": 22979, "265": 22980, "holm": 22981, "\u0120Sah": 22982, "\u0120Hussein": 22983, "\u0120Courtesy": 22984, "174": 22985, "\u0120146": 22986, "\u0120geographic": 22987, "peace": 22988, "\u0120judging": 22989, "\u0120Stern": 22990, "Bur": 22991, "\u0120storyline": 22992, "Gun": 22993, "\u0120Stick": 22994, "245": 22995, "307": 22996, "\u00e3\u0124\u00b4\u00e3\u0125\u00b3": 22997, "\u0120Administrator": 22998, "\u0120burnt": 22999, "\u0120pave": 23000, "choes": 23001, "Exec": 23002, "\u0120campuses": 23003, "Result": 23004, "\u0120mutations": 23005, "\u0120Charter": 23006, "\u0120captures": 23007, "\u0120compares": 23008, "\u0120badge": 23009, "Scient": 23010, "\u0120erad": 23011, "iery": 23012, "oi": 23013, "ettes": 23014, "\u0120Estate": 23015, "\u0120strap": 23016, "\u0120proudly": 23017, "\u0120fried": 23018, "\u0120withdrawn": 23019, "\u0120Voy": 23020, "phony": 23021, "Items": 23022, "\u0120Pierce": 23023, "bard": 23024, "\u0120annotation": 23025, "anton": 23026, "illon": 23027, "Impro": 23028, "...)": 23029, "\u0120happier": 23030, "------": 23031, "adjust": 23032, "\u0120staffers": 23033, "\u0120activism": 23034, "\u0120perf": 23035, "\u0120alright": 23036, "Need": 23037, "\u0120commence": 23038, "\u0120opioid": 23039, "\u0120Amanda": 23040, "Es": 23041, "\u0120Pars": 23042, "\u0120Kaw": 23043, "Works": 23044, "248": 23045, "\u0120indo": 23046, "tc": 23047, "endant": 23048, "\u0120Moto": 23049, "\u0120legalization": 23050, "OTE": 23051, "\u0120tasked": 23052, "\u0120tsp": 23053, "\u0120ACTIONS": 23054, "166": 23055, "\u0120refreshing": 23056, "\u0120NR": 23057, "\u0120Perez": 23058, "\u0120infringement": 23059, "SY": 23060, "Listen": 23061, "inning": 23062, "ku": 23063, "\u0120rotate": 23064, "program": 23065, "arah": 23066, "Design": 23067, "\u0120(\u00c2\u00a3": 23068, "\u0120storing": 23069, "\u0120warrants": 23070, "\u0120judgement": 23071, "\u0120Brist": 23072, "usually": 23073, "photo": 23074, "\u0120Ran": 23075, "\u0120Pine": 23076, "\u0120outrageous": 23077, "\u0120Valentine": 23078, "luence": 23079, "\u0120Everybody": 23080, "Altern": 23081, "\u0120relevance": 23082, "\u0120terminated": 23083, "\u0120dessert": 23084, "\u0120fulfilled": 23085, "\u0120prosecuted": 23086, "\u0120Words": 23087, "\u0120migrant": 23088, "\u0120cultivation": 23089, "\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124": 23090, "idelity": 23091, "\u0120Vern": 23092, "\u0120Login": 23093, "\u0120metaphor": 23094, "\u0120Tip": 23095, "\u0120recruits": 23096, "\u0120Pig": 23097, "ribing": 23098, "\u0120enthusiasts": 23099, "exper": 23100, "\u0120frightening": 23101, "\u0120Hair": 23102, "anson": 23103, "strate": 23104, "\u0120hi": 23105, "Height": 23106, "\u0120owning": 23107, "none": 23108, "\u0120dislike": 23109, "\u0120knives": 23110, "pherd": 23111, "\u0120loudly": 23112, "\u0120APIs": 23113, "Display": 23114, "\u0120Lac": 23115, "\u0120USS": 23116, "abl": 23117, "verages": 23118, "Jew": 23119, "\u0120172": 23120, "\u0120Historical": 23121, "atoon": 23122, "\u0120Physics": 23123, "intern": 23124, "\u0120warmth": 23125, "\u0120topp": 23126, "DM": 23127, "\u0120gunman": 23128, "\u0120emperor": 23129, "odi": 23130, "\u00e3\u0125\u00a3": 23131, "inatory": 23132, "\u0120Rib": 23133, "\u0120131": 23134, "\u0120Saturn": 23135, "\u0120Shining": 23136, "\u0120waking": 23137, "Quotes": 23138, "\u0120comedian": 23139, "enberg": 23140, "\u00c2\u00bd": 23141, "\u0120believers": 23142, "\u0120paperwork": 23143, "custom": 23144, "\u0120lev": 23145, "\u0120lament": 23146, "\u0120pouring": 23147, "222": 23148, "political": 23149, "\u0120Supplement": 23150, "maid": 23151, "\u0120cruelty": 23152, "\u0120tread": 23153, "ysics": 23154, "Aw": 23155, "rites": 23156, "\u0120modifier": 23157, "\u0120Position": 23158, "Adam": 23159, "lb": 23160, "ubs": 23161, "\u0120imperfect": 23162, "\u0120clusters": 23163, "\u0120Engineer": 23164, "\u0120Cherry": 23165, "\u0120inauguration": 23166, "\u0120Sau": 23167, "\u0120embodiment": 23168, "\u0120Uncle": 23169, "\u0120overr": 23170, "\u0120explosions": 23171, "cule": 23172, "\u0120Princeton": 23173, "\u0120Andrea": 23174, "\u0120incorrectly": 23175, "\u0120earnest": 23176, "\u0120pilgr": 23177, "\u0120Sprint": 23178, "\u0120sleeve": 23179, "\u0120hears": 23180, "\u0120Amazing": 23181, "\u0120browsing": 23182, "agin": 23183, "\u0120homeland": 23184, "\u0120haw": 23185, "\u0120diving": 23186, "istered": 23187, "178": 23188, "\u0120bargaining": 23189, "\u0120Arcade": 23190, "\u0120delegate": 23191, "terson": 23192, "................................................................": 23193, "\u0120Jacksonville": 23194, "275": 23195, "\u0120stagn": 23196, "\u0120adam": 23197, "\u0120Sherman": 23198, "CB": 23199, "\u0120suburb": 23200, "\u0120Foods": 23201, "\u0120converting": 23202, "\u0120Arist": 23203, "\u0120chambers": 23204, "love": 23205, "\u0120amino": 23206, "\u0120Gan": 23207, "\u0120madness": 23208, "mc": 23209, "\u0120USE": 23210, "defined": 23211, "\u0120ultr": 23212, "indust": 23213, "\u0120wolves": 23214, "lance": 23215, "Additionally": 23216, "\u0120cracks": 23217, "asia": 23218, "\u0120Reason": 23219, "\u0120Pump": 23220, "\u0120accidental": 23221, "\u0120Laser": 23222, "\u0120Rid": 23223, "\u0120initialized": 23224, "elli": 23225, "\u0120unnamed": 23226, "\u0120noun": 23227, "\u0120Passed": 23228, "\u0120hostage": 23229, "\u0120Ethiop": 23230, "shirts": 23231, "\u0120unrel": 23232, "\u0120Embassy": 23233, "\u01201941": 23234, "\u0120atoms": 23235, "\u0120purported": 23236, "164": 23237, "\u0120Fi": 23238, "\u0120gallons": 23239, "\u0120Monica": 23240, "\u0120pg": 23241, "enment": 23242, "\u0120sorted": 23243, "\u0120Gospel": 23244, "\u0120heights": 23245, "\u0120traced": 23246, "\u0120undergoing": 23247, "Shell": 23248, "\u0120sacks": 23249, "\u0120proportions": 23250, "\u0120halluc": 23251, "Font": 23252, "acet": 23253, "\u0120warmer": 23254, "\u0120INTER": 23255, "\u0120grabbing": 23256, "Plug": 23257, "\u0120realization": 23258, "\u0120Burke": 23259, "\u0120enchant": 23260, "ATER": 23261, "\u0120Seed": 23262, "\u0120abundant": 23263, "FM": 23264, "\u0120civic": 23265, "Vs": 23266, "isi": 23267, "\u0120vow": 23268, "\u0120reper": 23269, "\u0120Partnership": 23270, "\u0120penetration": 23271, "\u0120axe": 23272, "\u0120shattered": 23273, "\u0120Zombies": 23274, "\u0120vinyl": 23275, "\u0120Alert": 23276, "eon": 23277, "\u0120obliged": 23278, "\u0120Illust": 23279, "\u0120Plaza": 23280, "\u0120Frontier": 23281, "\u0120davidjl": 23282, "\u0120Serial": 23283, "\u0120Hav": 23284, "\u0120Nutrition": 23285, "Bi": 23286, "\u0120\u00e2\u0138\u012a": 23287, "\u0120Jays": 23288, "linux": 23289, "\u0120hurry": 23290, "\u0120voy": 23291, "\u0120hopeless": 23292, "\u0120Stealth": 23293, "\u0120\u00e3\u0123": 23294, "essors": 23295, "ttle": 23296, "borg": 23297, "\u0120Safari": 23298, "fell": 23299, "\u0120wary": 23300, "due": 23301, "\u0120Above": 23302, "Ha": 23303, "ELL": 23304, "\u0120notor": 23305, "\u0120Won": 23306, "Too": 23307, "\u0120occupations": 23308, "\u0120possessions": 23309, "\u0120inviting": 23310, "\u0120predators": 23311, "\u0120accelerated": 23312, "\u0120157": 23313, "uterte": 23314, "\u0120Cube": 23315, "east": 23316, "account": 23317, "Give": 23318, "\u0120transplant": 23319, "redients": 23320, "idable": 23321, "\u0120screenshots": 23322, "\u0120Gund": 23323, "\u0120FS": 23324, "\u0120travelers": 23325, "\u0120sensory": 23326, "\u0120Fiat": 23327, "\u0120Rockets": 23328, "\u0130\u012d": 23329, "_{": 23330, "Friend": 23331, "\u0120charming": 23332, "ALS": 23333, "\u0120enjoyment": 23334, "mph": 23335, "\u01205000": 23336, "\u0120REG": 23337, "\u00d9\u0128": 23338, "bia": 23339, "\u0120compilation": 23340, "rost": 23341, "\u0120VP": 23342, "\u0120Schne": 23343, "2019": 23344, "\u0120copying": 23345, "MORE": 23346, "\u0120Flore": 23347, "falls": 23348, "215": 23349, "total": 23350, "\u0120disciples": 23351, "double": 23352, "\u0120exceeding": 23353, "\u0120smashed": 23354, "\u0120conceptual": 23355, "\u0120Romania": 23356, "\u0120Brent": 23357, "\u0120ICE": 23358, "\u0120Tou": 23359, "\u0120grap": 23360, "\u0120nails": 23361, "189": 23362, "\u00e3\u0125\u013a": 23363, "\u0120procure": 23364, "eur": 23365, "\u0120confirming": 23366, "\u0120Cec": 23367, "awi": 23368, "\u0120Eden": 23369, "\u0120ng": 23370, "\u0120engineered": 23371, "atics": 23372, "\u0120hooked": 23373, "\u0120disgusting": 23374, "\u0120Murder": 23375, "\u00e3\u0124\u00bf": 23376, "Library": 23377, "\u0120168": 23378, "Almost": 23379, "hematic": 23380, "Menu": 23381, "\u0120Notre": 23382, "\u0120Jur": 23383, "\u0120kidnapped": 23384, "\u0120hacker": 23385, "\u0120Jade": 23386, "\u0120creepy": 23387, "\u0120drawings": 23388, "\u0120Sponsor": 23389, "\u0120cyclists": 23390, "\u0120Goblin": 23391, "\u0120optimized": 23392, "\u0120staged": 23393, "\u0120McD": 23394, "between": 23395, "Age": 23396, "eno": 23397, "Sex": 23398, "\u0120Wide": 23399, "nings": 23400, "avis": 23401, "\u0120incapable": 23402, "\u0120Kob": 23403, "\u0120rewarding": 23404, "\u0120Lone": 23405, "olescent": 23406, "\u0120contracted": 23407, "\u0120sticky": 23408, "Jose": 23409, "Ball": 23410, "fest": 23411, "\u0120Input": 23412, "\u0120Recently": 23413, "\u0120tomat": 23414, "square": 23415, "Application": 23416, "\u0120nitrogen": 23417, "\u0120duplicate": 23418, "\u0120Recon": 23419, "\u0120Dear": 23420, "London": 23421, "\u0120intra": 23422, "\u0120dock": 23423, "\u0120outreach": 23424, "\u0120Million": 23425, "\u0120mammals": 23426, "ampton": 23427, "VAL": 23428, "\u0120snaps": 23429, "\u0120dos": 23430, "\u0120Whole": 23431, "\u0120Ready": 23432, "Try": 23433, "\u0120Winnipeg": 23434, "earance": 23435, "\u0120incurred": 23436, "renched": 23437, "\u0120NSW": 23438, "ilot": 23439, "raine": 23440, "\u0120cube": 23441, "got": 23442, "\u0120runway": 23443, "etermined": 23444, "\u0120Hawks": 23445, "\u0120survivor": 23446, "\u0120Wish": 23447, "\u0120Din": 23448, "\u0120DEF": 23449, "\u0120Vault": 23450, "187": 23451, "\u0120mushrooms": 23452, "\u0120crisp": 23453, "bey": 23454, "\u0120Discovery": 23455, "\u0120developmental": 23456, "\u0120paradigm": 23457, "\u0120chaotic": 23458, "\u0120Tsu": 23459, "\u0120333": 23460, "bons": 23461, "\u0120bacterial": 23462, "\u0120commits": 23463, "\u0120cosmic": 23464, "\u0120mega": 23465, "ocative": 23466, "\u0120Paint": 23467, "ophobic": 23468, "\u0120vain": 23469, "\u0120carved": 23470, "\u0120Thief": 23471, "\u0120Gul": 23472, "owship": 23473, "\u0120cites": 23474, "\u0120Edinburgh": 23475, "\u0120diminished": 23476, "\u0120acknowledges": 23477, "\u0120Kills": 23478, "\u0120microw": 23479, "\u0120Hera": 23480, "\u0120seniors": 23481, "\u0120whereby": 23482, "Hop": 23483, "atron": 23484, "\u0120unavailable": 23485, "\u0120Nate": 23486, "\u0120480": 23487, "\u0120slated": 23488, "\u0120Rebecca": 23489, "\u0120Battery": 23490, "\u0120grammar": 23491, "\u0120headset": 23492, "\u0120cursor": 23493, "\u0120excluding": 23494, "anye": 23495, "aundering": 23496, "ebin": 23497, "\u0120feasible": 23498, "\u0120Publishing": 23499, "\u0120Labs": 23500, "\u0120Cliff": 23501, "\u0120Ferrari": 23502, "\u0120pac": 23503, "visible": 23504, "marked": 23505, "pell": 23506, "\u0120polite": 23507, "\u0120staggering": 23508, "\u0120Galactic": 23509, "\u0120superst": 23510, "\u0120paran": 23511, "\u0120Officers": 23512, "\u00e3\u0122\u0123": 23513, "\u0120specifics": 23514, "ulus": 23515, "239": 23516, "\u0120Paste": 23517, "AMP": 23518, "\u0120Panama": 23519, "\u0120Delete": 23520, "anguard": 23521, "restrial": 23522, "\u0120heroic": 23523, "\u0120Dy": 23524, "\u00d8\u00a7\u00d9\u0126": 23525, "\u0120incumbent": 23526, "\u0120crunch": 23527, "tro": 23528, "\u0120scoop": 23529, "\u0120blogger": 23530, "\u0120sellers": 23531, "uren": 23532, "\u0120medicines": 23533, "\u0120Caps": 23534, "\u0120Animation": 23535, "oxy": 23536, "\u0120outward": 23537, "\u0120inquiries": 23538, "229": 23539, "\u0120psychologist": 23540, "\u0120Sask": 23541, "evil": 23542, "\u0120contaminated": 23543, "\u00e3\u0124\u00a8": 23544, "herence": 23545, "\u0120branded": 23546, "\u0120Abdul": 23547, "zh": 23548, "\u0120paragraphs": 23549, "\u0120mins": 23550, "\u0120correlated": 23551, "erb": 23552, "\u0120impart": 23553, "\u0120milestone": 23554, "\u0120Solutions": 23555, "otle": 23556, "\u0120undercover": 23557, "\u0120marched": 23558, "\u0120Chargers": 23559, "fax": 23560, "\u0120Secrets": 23561, "\u0120ruth": 23562, "weather": 23563, "\u0120feminine": 23564, "\u0120sham": 23565, "\u0120prestigious": 23566, "iggins": 23567, "\u0120sung": 23568, "history": 23569, "ettle": 23570, "ggie": 23571, "\u0120outdated": 23572, "oland": 23573, "\u0120perceptions": 23574, "\u0120Session": 23575, "\u0120Dodgers": 23576, "uj": 23577, "\u0120END": 23578, "Doc": 23579, "\u0120deficiency": 23580, "Grand": 23581, "\u0120Joker": 23582, "\u0120retrospect": 23583, "\u0120diagnostic": 23584, "\u0120harmless": 23585, "\u0120rogue": 23586, "\u0120Aval": 23587, "Equ": 23588, "\u0120transc": 23589, "\u0120Robertson": 23590, "\u0120Depending": 23591, "\u0120Burns": 23592, "ivo": 23593, "\u0120hostility": 23594, "Features": 23595, "\u0135\u013a": 23596, "\u0120discomfort": 23597, "\u0120LCD": 23598, "specified": 23599, "\u0120Expect": 23600, "340": 23601, "\u0120imperative": 23602, "\u0120Regular": 23603, "Chinese": 23604, "\u0120statewide": 23605, "\u0120symm": 23606, "\u0120loops": 23607, "\u0120autumn": 23608, "Nick": 23609, "\u0120shaping": 23610, "\u0120quot": 23611, "\u0120cherry": 23612, "\u0120Crossref": 23613, "\u00e8\u00a6\u013c\u00e9\u0128\u0134": 23614, "Standard": 23615, "heed": 23616, "\u0120Dell": 23617, "\u0120Vietnamese": 23618, "\u0120ost": 23619, "\u0120Valkyrie": 23620, "OA": 23621, "Assad": 23622, "\u0120rebound": 23623, "\u0120Traffic": 23624, "places": 23625, "\u00e6\u013a": 23626, "\u0120Buc": 23627, "172": 23628, "\u0120shelters": 23629, "\u0120insisting": 23630, "\u0120Certainly": 23631, "\u0120Kenneth": 23632, "\u0120TCP": 23633, "\u0120penal": 23634, "\u0120Replay": 23635, "heard": 23636, "\u0120dialect": 23637, "iza": 23638, "\u0120FY": 23639, "itcher": 23640, "\u0120DL": 23641, "\u0120spiral": 23642, "\u0120quarterbacks": 23643, "\u0120hull": 23644, "\u0120google": 23645, "\u0120todd": 23646, "\u0120Sterling": 23647, "\u0120Plate": 23648, "\u0120spying": 23649, "mbol": 23650, "\u0120Realm": 23651, "\u0120Proced": 23652, "\u0120Crash": 23653, "\u0120terminate": 23654, "\u0120protesting": 23655, "Center": 23656, "guided": 23657, "\u0120uncover": 23658, "\u0120boycott": 23659, "\u0120realizes": 23660, "sound": 23661, "\u0120pretending": 23662, "\u0120Vas": 23663, "1980": 23664, "\u0120framed": 23665, "\u0120139": 23666, "\u0120descended": 23667, "\u0120rehabilitation": 23668, "\u0120borrowing": 23669, "\u0120Buch": 23670, "\u0120blur": 23671, "Ron": 23672, "\u0120Frozen": 23673, "enza": 23674, "Chief": 23675, "\u0120Poor": 23676, "\u0120translates": 23677, "MIN": 23678, "\u0120212": 23679, "JECT": 23680, "\u0120erupted": 23681, "\u0120successes": 23682, "SEC": 23683, "\u0120plague": 23684, "\u0120gems": 23685, "doms": 23686, "\u0120stretches": 23687, "\u0120Spy": 23688, "\u0120storytelling": 23689, "Credit": 23690, "\u0120Push": 23691, "\u0120traction": 23692, "\u0120ineffective": 23693, "\u0120Luna": 23694, "\u0120tapes": 23695, "\u0120analytics": 23696, "ercise": 23697, "\u0120programmes": 23698, "\u0120Carbon": 23699, "\u0120behold": 23700, "heavy": 23701, "\u0120Conservation": 23702, "\u0120FIR": 23703, "\u0120sack": 23704, "termin": 23705, "ricks": 23706, "\u0120housed": 23707, "\u0120unusually": 23708, "Ice": 23709, "\u0120executing": 23710, "\u0120Moroc": 23711, "eday": 23712, "\u0120editions": 23713, "\u0120smarter": 23714, "\u0120BA": 23715, "\u0120outlaw": 23716, "\u0120vanished": 23717, "iba": 23718, "ALSE": 23719, "\u0120Silva": 23720, "238": 23721, "Could": 23722, "\u0120philosopher": 23723, "\u0120evacuated": 23724, "Secret": 23725, "142": 23726, "\u0120visas": 23727, "\u00e3\u0124\u00ac": 23728, "\u0120Malt": 23729, "\u0120Clearly": 23730, "\u0120Niger": 23731, "\u0120Cairo": 23732, "\u0120Fist": 23733, "380": 23734, "\u0120XML": 23735, "auto": 23736, "itant": 23737, "\u0120reinforced": 23738, "Record": 23739, "\u0120Survivor": 23740, "GHz": 23741, "\u0120screws": 23742, "parents": 23743, "\u0120oceans": 23744, "mares": 23745, "\u0120brakes": 23746, "vasive": 23747, "\u0120hello": 23748, "\u0120SIM": 23749, "rimp": 23750, "\u0120ore": 23751, "\u0120Armour": 23752, "247": 23753, "\u0120terrific": 23754, "\u0120tones": 23755, "141": 23756, "\u0120Minutes": 23757, "Episode": 23758, "\u0120curves": 23759, "\u0120inflammatory": 23760, "\u0120batting": 23761, "\u0120Beautiful": 23762, "Lay": 23763, "\u0120unpop": 23764, "vable": 23765, "\u0120riots": 23766, "\u0120Tactics": 23767, "baugh": 23768, "\u0120Cock": 23769, "\u0120orgasm": 23770, "\u0120Sas": 23771, "\u0120constructor": 23772, "etz": 23773, "Gov": 23774, "\u0120antagon": 23775, "\u0120theat": 23776, "\u0120deeds": 23777, "hao": 23778, "cuts": 23779, "\u0120McCl": 23780, "\u0120um": 23781, "\u0120Scientists": 23782, "\u0120grassroots": 23783, "yssey": 23784, "\"]=>": 23785, "\u0120surfaced": 23786, "\u0120shades": 23787, "\u0120neighbours": 23788, "\u0120advertis": 23789, "oya": 23790, "\u0120merged": 23791, "Upon": 23792, "\u0120gad": 23793, "\u0120anticipate": 23794, "Anyway": 23795, "\u0120slogan": 23796, "\u0120disrespect": 23797, "Iran": 23798, "\u0120TB": 23799, "acted": 23800, "\u0120subpoen": 23801, "mediately": 23802, "OOOO": 23803, "\u0120waiver": 23804, "\u0120vulnerabilities": 23805, "ottesville": 23806, "\u0120Huffington": 23807, "Josh": 23808, "\u0120DH": 23809, "Monday": 23810, "\u0120Ellen": 23811, "Know": 23812, "xon": 23813, "items": 23814, "228": 23815, "\u0120fills": 23816, "\u0120Nike": 23817, "\u0120cumulative": 23818, "andals": 23819, "Ir": 23820, "\u0120\u00ec": 23821, "\u0120friction": 23822, "igator": 23823, "\u0120scans": 23824, "\u0120Vienna": 23825, "ldom": 23826, "\u0120performers": 23827, "Prim": 23828, "\u0120bidding": 23829, "Mur": 23830, "\u0120leaned": 23831, "\u0120Prix": 23832, "alks": 23833, "\u0120[\u00e2\u0122\u00a6]": 23834, "\u0120Twitch": 23835, "\u0120Developer": 23836, "\u0120Gir": 23837, "\u0120callback": 23838, "Abstract": 23839, "\u0120accustomed": 23840, "\u0120freedoms": 23841, "\u0120PG": 23842, "uracy": 23843, "\u0120lump": 23844, "isman": 23845, ",,,,": 23846, "1992": 23847, "\u0120RED": 23848, "\u0120worm": 23849, "Match": 23850, "\u0120Platinum": 23851, "IJ": 23852, "\u0120Owner": 23853, "Trivia": 23854, "compl": 23855, "\u0120newborn": 23856, "\u0120fantas": 23857, "Own": 23858, "\u01201959": 23859, "\u0120sympath": 23860, "\u0120ubiqu": 23861, "\u0120outputs": 23862, "\u0120allev": 23863, "\u0120prag": 23864, "Kevin": 23865, "\u0120favors": 23866, "\u0120burial": 23867, "\u0120nurt": 23868, "solete": 23869, "cache": 23870, "\u0120156": 23871, "\u0120unlocks": 23872, "techn": 23873, "Making": 23874, "\u0120conquer": 23875, "adic": 23876, "\u00e6\u0138": 23877, "\u0120elf": 23878, "\u0120electorate": 23879, "\u0120Kurds": 23880, "\u0120Stack": 23881, "\u0120Samurai": 23882, "\u0120\u00e2\u013a\u0127": 23883, "\u0120{}": 23884, "\u0120Said": 23885, "\u0120Fallout": 23886, "\u0120kindness": 23887, "\u0120Customs": 23888, "\u0120Boulevard": 23889, "\u0120helicopters": 23890, "otics": 23891, "\u0120Veget": 23892, "comment": 23893, "\u0120criticised": 23894, "\u0120polished": 23895, "\u0120Remix": 23896, "\u0120Cultural": 23897, "\u0120recons": 23898, "\u0120doi": 23899, "atem": 23900, "Screen": 23901, "\u0120barred": 23902, "Comments": 23903, "\u0120Generally": 23904, "\u0120slap": 23905, "720": 23906, "Vari": 23907, "pine": 23908, "\u0120empt": 23909, "\u0120hats": 23910, "\u0120Playing": 23911, "lab": 23912, "average": 23913, "forms": 23914, "\u0120Cotton": 23915, "\u0120cans": 23916, "\u0120DON": 23917, "\u0120Somalia": 23918, "Crypt": 23919, "\u0120Increases": 23920, "Ever": 23921, "modern": 23922, "\u0120surgeon": 23923, "3000": 23924, "\u0120randomized": 23925, "================================================================": 23926, "Bern": 23927, "impl": 23928, "\u0120COR": 23929, "\u0120proclaim": 23930, "thouse": 23931, "\u0120toes": 23932, "\u0120ample": 23933, "\u0120preserving": 23934, "\u0120disbel": 23935, "grand": 23936, "Besides": 23937, "\u0120silk": 23938, "\u0120Pattern": 23939, "hm": 23940, "\u0120enterprises": 23941, "\u0120affidavit": 23942, "\u0120Advisory": 23943, "\u0120advertised": 23944, "\u0120Religious": 23945, "sections": 23946, "psych": 23947, "\u0120Fields": 23948, "aways": 23949, "\u0120hashtag": 23950, "\u0120Nightmare": 23951, "\u0120vampire": 23952, "\u0120forensic": 23953, "rossover": 23954, "nar": 23955, "\u0120navy": 23956, "\u0120vacant": 23957, "\u0120Duel": 23958, "\u0120hallway": 23959, "\u0120facebook": 23960, "identally": 23961, "\u0120NRA": 23962, "\u0120matt": 23963, "\u0120hurricane": 23964, "\u0120Kirby": 23965, "\u0120Puzzle": 23966, "\u0120skirt": 23967, "oust": 23968, "dullah": 23969, "\u0120analogy": 23970, "inion": 23971, "\u0120tomatoes": 23972, "\u0120NV": 23973, "\u0120Peak": 23974, "\u0120Meyer": 23975, "\u0120appointments": 23976, "\u0120masc": 23977, "\u0120alley": 23978, "rehend": 23979, "\u0120charities": 23980, "\u0120undo": 23981, "\u0120destinations": 23982, "\u0120Testing": 23983, "\"></": 23984, "\u0120destined": 23985, "\u0120implements": 23986, "\u0120Harold": 23987, "RECT": 23988, "\u0120optimization": 23989, "\u0120kilometres": 23990, "\u0120cmd": 23991, "\u0120impairment": 23992, "\u0120unsuccessful": 23993, "\u0120swiftly": 23994, "\u0120Glasgow": 23995, "arten": 23996, "\u0120Shares": 23997, "\u0120Answer": 23998, "\u0120Album": 23999, "\u0120nutritional": 24000, "\u00e3\u0125\u0138": 24001, "\u0120Fut": 24002, "\u0120bloc": 24003, "\u0120NFC": 24004, "\u0120wholesale": 24005, "\u0120CW": 24006, "\u0120neglected": 24007, "\u0120launcher": 24008, "\u0120announcements": 24009, "OULD": 24010, "comb": 24011, "\u0120rotating": 24012, "\u0120rests": 24013, "\u0120Ticket": 24014, "chedel": 24015, "Lou": 24016, "\u0120Vic": 24017, "\u0120\"'": 24018, "\u0120templates": 24019, "\u0120replaces": 24020, "Arc": 24021, "::::": 24022, "\u0120Gilbert": 24023, "\u0120illnesses": 24024, "\u0120schedules": 24025, "\u0120heterosexual": 24026, "LINE": 24027, "\u0120herein": 24028, "\u0120coerc": 24029, "\u0120decreasing": 24030, "\u0120deportation": 24031, "sudo": 24032, "\u0120Indigenous": 24033, "\u0120weighs": 24034, "Along": 24035, "');": 24036, "\u0120Bengals": 24037, "707": 24038, "\u0120joints": 24039, "verts": 24040, "\u0120149": 24041, "naire": 24042, "\u0120simplest": 24043, "\u0120lore": 24044, "1080": 24045, "fiction": 24046, "\u0120Database": 24047, "\u0120reservation": 24048, "\u0120sou": 24049, "\u0120sanctuary": 24050, "audio": 24051, "aple": 24052, "\u0120vegetarian": 24053, "\u0120anticipation": 24054, "micro": 24055, "\u0120enduring": 24056, "\u0120departed": 24057, "\u0120sidewalk": 24058, "\u0120prohibits": 24059, "\u0120Font": 24060, "\u0120compute": 24061, "\u0120Sect": 24062, "\u0120158": 24063, "Battle": 24064, "\u0120bomber": 24065, "\u0120distraction": 24066, "\u0120endured": 24067, "\u0120practitioners": 24068, "\u0120disturbed": 24069, "\u0120drank": 24070, "ordered": 24071, "\u0120surprises": 24072, "seat": 24073, "Security": 24074, "\u0120Wisdom": 24075, "ogo": 24076, "\u0120subparagraph": 24077, "\u0120Peninsula": 24078, "\u0120Origins": 24079, "iren": 24080, "\u0120Pav": 24081, "iggle": 24082, "\u0120gratitude": 24083, "\u0120Gravity": 24084, "overty": 24085, "iman": 24086, "ctr": 24087, "\u0120Caesar": 24088, "could": 24089, "gem": 24090, "\u0120skies": 24091, "\u0120champ": 24092, "\u0120agreeing": 24093, "Family": 24094, "Div": 24095, "176": 24096, "\u0120messy": 24097, "umption": 24098, "Federal": 24099, "erno": 24100, "\u0120Chat": 24101, "Beyond": 24102, "\u0120devote": 24103, "\u0120Walsh": 24104, "\u0120dumped": 24105, "\u0120accumulation": 24106, "stad": 24107, "hibition": 24108, "\u0120smokers": 24109, "\u0120inspector": 24110, "French": 24111, "issan": 24112, "\u0120Vita": 24113, "\u0120researching": 24114, "RAM": 24115, "\u0120Celtics": 24116, "\u0120cloak": 24117, "\u0120Terra": 24118, "Mary": 24119, "sold": 24120, "\u0120DOM": 24121, "mods": 24122, "Intel": 24123, "\u0120multitude": 24124, "\u0120Improved": 24125, "\u0120reliance": 24126, "\u0120artifact": 24127, "\u0120alarming": 24128, "Prom": 24129, "hon": 24130, "TION": 24131, "medium": 24132, "\u0120reflex": 24133, "\u0120Excel": 24134, "\u0120weakened": 24135, "163": 24136, "224": 24137, "\u0120costumes": 24138, "\u0120uniquely": 24139, "\u0120sorrow": 24140, "\u0120mansion": 24141, "wp": 24142, "\u0120salv": 24143, "\u0120Grove": 24144, "bsp": 24145, "\u0120Sniper": 24146, "\u0120Shipping": 24147, "\u0120POW": 24148, "\u0120undis": 24149, "\u0120branding": 24150, "Girl": 24151, "\u0120Ahmad": 24152, "\u0120Lakes": 24153, "\u0120Corey": 24154, "\u0120inheritance": 24155, "enery": 24156, "\u0120packing": 24157, "\u0120Prest": 24158, "Dest": 24159, "FW": 24160, "\u0120regulator": 24161, "locked": 24162, "\u0120contested": 24163, "\u0120Melissa": 24164, "\u0120Duc": 24165, "\u0120unpopular": 24166, "\u0120stacked": 24167, "\u01201917": 24168, "\u0120yearly": 24169, "\u0120stare": 24170, "\u0120assessing": 24171, "\u00c3\u00b8": 24172, "\u0120beverages": 24173, "\u0120competitions": 24174, "\u0120strengthening": 24175, "along": 24176, "\u0120Lud": 24177, "\u0120melted": 24178, "stanbul": 24179, "\u0120bounty": 24180, "ENC": 24181, "\u0120Lands": 24182, "\u0120declares": 24183, "\u0120customize": 24184, "\u0120composite": 24185, "\u00e3\u0125\u00ac": 24186, "CM": 24187, "ographics": 24188, "\u0120Temp": 24189, "\u0120contender": 24190, "\u0120insign": 24191, "\u0120LAN": 24192, "\u0120disasters": 24193, "inspired": 24194, "\u0120judgments": 24195, "ustainable": 24196, "ursion": 24197, "\u0120variance": 24198, "\u0120Ultimately": 24199, "\u0120--------": 24200, "uador": 24201, "\u0120RX": 24202, "\u0120melting": 24203, "\u0120Extended": 24204, "\u0120Twe": 24205, "Major": 24206, "\u0120Bil": 24207, "\u0120syrup": 24208, "quick": 24209, "\u0120Holder": 24210, "\u0120innocence": 24211, "ULE": 24212, "\u0120Might": 24213, "9999": 24214, "\u0120fal": 24215, "\u0120continuity": 24216, "\u01201953": 24217, "\u0120BS": 24218, "still": 24219, "Lat": 24220, "\u0120Abuse": 24221, "\u0120unsupported": 24222, "xxxxxxxx": 24223, "\u0120institute": 24224, "\u0120fragment": 24225, "\u0120Pep": 24226, "Western": 24227, "\u0120Cause": 24228, "\u0120Frag": 24229, "\u0120Ars": 24230, "\u00e0\u00a5": 24231, "astics": 24232, "\u0120bishop": 24233, "\u0120crosses": 24234, "\u0120154": 24235, "\u0120Upgrade": 24236, "\u0120mitigate": 24237, "\u0120Raymond": 24238, "Mods": 24239, "\u0120tomato": 24240, "\u0120stumbled": 24241, "\u0120differs": 24242, "Initial": 24243, "\u0120Raspberry": 24244, "\u0120ignores": 24245, "\u0120tant": 24246, "\u00c3\u0142": 24247, "\u0120relay": 24248, "\u0120bisexual": 24249, "\u0120confession": 24250, "\u0120dement": 24251, "inas": 24252, "\u0120Heather": 24253, "platform": 24254, "driving": 24255, "bourg": 24256, "\u0120Mush": 24257, "\u0120hyster": 24258, "Details": 24259, "\u0120drift": 24260, "\u0120Wald": 24261, "\u0120Luckily": 24262, "orf": 24263, "\u0120expire": 24264, "\u0120Punch": 24265, "zyme": 24266, "gold": 24267, "\u0120unpaid": 24268, "\u0120Trent": 24269, "\u0120unarmed": 24270, "\u0120illicit": 24271, "\u0120Tottenham": 24272, "\u0120smash": 24273, "International": 24274, "inker": 24275, "\u0120sting": 24276, "\u0120Saddam": 24277, "\u0120ART": 24278, "\u0120truths": 24279, "birth": 24280, "\u0120sober": 24281, "\u0120Nit": 24282, "\u0120ib": 24283, "\u0120usable": 24284, "\u0120stacks": 24285, "\u0120Sylv": 24286, "\u0120northeast": 24287, "\u0120domination": 24288, "\u0120Mour": 24289, "ENSE": 24290, "\u0120Measure": 24291, "\u0120programmer": 24292, "\u0120<-": 24293, "182": 24294, "\u0120Condition": 24295, "\u0120backyard": 24296, "irling": 24297, "\u0120Jeb": 24298, "\u0120Creed": 24299, "\u0120Hang": 24300, "\u0120COMP": 24301, "FER": 24302, "\u0120Ish": 24303, "\u0120detectives": 24304, "---------------": 24305, "\u0120Messenger": 24306, "\u0120looph": 24307, "\u0120gateway": 24308, "151": 24309, "\u0120Materials": 24310, "\u0120DT": 24311, "\u0120doomed": 24312, "odo": 24313, "\u0120slices": 24314, "\u0120emailed": 24315, "\u0120Perl": 24316, "\u0120renov": 24317, "UTH": 24318, "odynam": 24319, "\u0120Southwest": 24320, "getic": 24321, "\u0120TPP": 24322, "\u0120optimism": 24323, "\u0120Tow": 24324, "ulators": 24325, "protected": 24326, "yles": 24327, "\u00c2\u00ab": 24328, "\u0120exile": 24329, "env": 24330, "Prop": 24331, "\u0120Zimmerman": 24332, "\u00d9\u0130": 24333, "Ca": 24334, "omaly": 24335, "\u00e3\u0125\u0128": 24336, "\u0120railroad": 24337, "Lee": 24338, "232": 24339, "\u0120replicate": 24340, "\u0120comfortably": 24341, "actly": 24342, "\u0120rav": 24343, "\u0120telescope": 24344, "\u0120honesty": 24345, "\u0120Pepper": 24346, "\u0120Bring": 24347, "\u0120richest": 24348, "\u0120outdoors": 24349, "\u0120halls": 24350, "\u0120contend": 24351, "ISE": 24352, "\u0120submitting": 24353, "\u0120naive": 24354, "arations": 24355, "\u0120143": 24356, "\u0120poised": 24357, "responsible": 24358, "\u0120socks": 24359, "\u0120Skull": 24360, "Question": 24361, "\u0120discoveries": 24362, "Joined": 24363, "\u0120Enemies": 24364, "\u0120Wireless": 24365, "\u0120Revenge": 24366, "\u0120puzzles": 24367, "\u0120ceased": 24368, "290": 24369, "criptions": 24370, "\u0120Console": 24371, "\u0120boiling": 24372, "\u0120discrep": 24373, "\u0120deduction": 24374, "\u0120arsenal": 24375, "XXXX": 24376, "\u0120Amsterdam": 24377, "roximately": 24378, "\u0120Shane": 24379, "\u0120posing": 24380, "\u0120ACLU": 24381, "\u0120Companies": 24382, "\u0120theology": 24383, "\u0120Ug": 24384, "quarter": 24385, "\u0120Hank": 24386, "Coin": 24387, "\u0120Lv": 24388, "\u0120allegation": 24389, "\u0120Avoid": 24390, "\u0120indefinitely": 24391, "\u0120commodities": 24392, "\u0120brig": 24393, "\u0120Manit": 24394, "\u0120tenth": 24395, "method": 24396, "\u0120Knicks": 24397, "\u0120\u00e2\u0122\u0130": 24398, "\u0120invoked": 24399, "Dial": 24400, "ARA": 24401, "\u0120caucus": 24402, "227": 24403, "\u0120Jab": 24404, "\u0120ounces": 24405, "bay": 24406, "\u0120buddy": 24407, "fan": 24408, "234": 24409, "\u0120Hil": 24410, "adh": 24411, "\u0120TY": 24412, "\u0120IND": 24413, "\u01201939": 24414, "\u0120iteration": 24415, "\u0120Gonzalez": 24416, "\u0120Vert": 24417, "\u0120IO": 24418, "emb": 24419, "rera": 24420, "ench": 24421, "\u0120Requirements": 24422, "\u0120Wins": 24423, "\u0120livestock": 24424, "hours": 24425, "\"\u00e2\u0122\u00a6": 24426, "bral": 24427, "Marg": 24428, "\u0120Done": 24429, "\u0120wasting": 24430, "inged": 24431, "groups": 24432, "\u0120wishing": 24433, "\u0120Tumblr": 24434, "\u0120tapping": 24435, "\u0120nationalism": 24436, "\u0120Byr": 24437, "\u0120squares": 24438, "\u0120Actions": 24439, "\u00e3\u0125\u00a5": 24440, "Inside": 24441, "debug": 24442, "\u0120append": 24443, "\u0120stubborn": 24444, "\u0120Cind": 24445, "Tell": 24446, "\u0120tearing": 24447, "\u0120Rey": 24448, "orc": 24449, "\u0120Dayton": 24450, "\u0120NH": 24451, "\u0120Madness": 24452, "Charl": 24453, "\u0120Morrison": 24454, "filter": 24455, "\u0120accuse": 24456, "\u0120./": 24457, "\u0120torrent": 24458, "\u0120declines": 24459, "gallery": 24460, "Mine": 24461, "\u0120negotiation": 24462, "\u0120Bashar": 24463, "opia": 24464, "1993": 24465, "emort": 24466, "\u0120Novel": 24467, "\u0120Fang": 24468, "ersive": 24469, "\u0120Instant": 24470, "\u0120roller": 24471, "Around": 24472, "\u0120Elections": 24473, "Games": 24474, "\u0120inexpensive": 24475, "\u0120wors": 24476, "\u0120vul": 24477, "\u0120Hole": 24478, "\u0120unbelievable": 24479, "\u0120nause": 24480, "\u0120entr": 24481, "boat": 24482, "\u0120STE": 24483, "\u0120bush": 24484, "\u0120Hassan": 24485, "\u0120wo": 24486, "\u0120paused": 24487, "\u0120Mig": 24488, "lived": 24489, "\u0120scout": 24490, "\u0120lith": 24491, "Published": 24492, "duino": 24493, "cool": 24494, "\u0120circulating": 24495, "idas": 24496, "\u0120Pam": 24497, "violent": 24498, "\u0120Crawford": 24499, "uddle": 24500, "\u0120Letters": 24501, "Guard": 24502, "morph": 24503, "\u0120wandering": 24504, "\u0120sophomore": 24505, "\u0120queer": 24506, "\u0120Blind": 24507, "rue": 24508, "\u0120Marriage": 24509, "Dom": 24510, "\u0120padding": 24511, "\u0120folders": 24512, "\u0120meaningless": 24513, "\u0120candidacy": 24514, "afort": 24515, "\u0120whistlebl": 24516, "\u0120Identified": 24517, "\u0120cigar": 24518, "\u0120hid": 24519, "\u0120Dubai": 24520, "\u0120posture": 24521, "\u0120hiking": 24522, "\u0120Terminal": 24523, "Legendary": 24524, "\u0120TP": 24525, "\u0120ATK": 24526, "\u0120Starbucks": 24527, "\u0120Riot": 24528, "1991": 24529, "\u0120Bottom": 24530, "effic": 24531, "\u0120Eugene": 24532, "\u0120Wyoming": 24533, "\u0120Rocky": 24534, "\u0120salmon": 24535, "\u0120metro": 24536, "\u0120bilateral": 24537, "\u0120celebrates": 24538, "Length": 24539, "billion": 24540, "Bat": 24541, "\u0120releg": 24542, "\u0120pseudo": 24543, "DT": 24544, "\u0120Rhode": 24545, "Parent": 24546, "pletion": 24547, "\u0120attribut": 24548, "\u0120tuning": 24549, "\u0120NOTE": 24550, "\u0120Rebel": 24551, "icus": 24552, "Fund": 24553, "\u0120cocktail": 24554, "\u0120501": 24555, "\u0120spoon": 24556, "\u0120brutality": 24557, "\u0120unite": 24558, "\u0120microbi": 24559, "\u0120Reich": 24560, "positive": 24561, "\u0120amazed": 24562, "\u0120NT": 24563, "Desc": 24564, "ECTION": 24565, "\u0120falsely": 24566, "\u0120Highlander": 24567, "\u0120Crist": 24568, "\u0120Victorian": 24569, "\u0120distributions": 24570, "their": 24571, "\u0120Einstein": 24572, "\u0120pod": 24573, "\u0120epidem": 24574, "\u0120heap": 24575, "\u0120Ranch": 24576, "\u0120anthem": 24577, "\u0120reapp": 24578, "\u0120Auburn": 24579, "\u0120concurrent": 24580, "\u0120Throughout": 24581, "\u0120POST": 24582, "\u00e2\u013a": 24583, "\u0120homemade": 24584, "kick": 24585, "Beg": 24586, "\u0120chassis": 24587, "counter": 24588, "\u0120merger": 24589, "\u0120laps": 24590, "217": 24591, "union": 24592, "\u0120Trigger": 24593, "\u0120debated": 24594, "\u0120silently": 24595, "\u0120restraint": 24596, "Bal": 24597, "0000000": 24598, "\u0120formidable": 24599, "\u0120Filip": 24600, "\u0120sacrifices": 24601, "Food": 24602, "\u0120dwarf": 24603, "\u0120Sequ": 24604, "inian": 24605, "Moreover": 24606, "\u0120tangible": 24607, "opsis": 24608, "\u0120Minecraft": 24609, "\u0120Registration": 24610, "oan": 24611, "\u0120representations": 24612, "\u0120thirst": 24613, "\u0120corp": 24614, "irement": 24615, "Made": 24616, "loe": 24617, ">\"": 24618, "cats": 24619, "*.": 24620, "\u0120gestures": 24621, "general": 24622, "League": 24623, "\u0120packets": 24624, "\u0120Inspector": 24625, "\u0120Berg": 24626, "\u0120fraudulent": 24627, "\u0120criticize": 24628, "Fun": 24629, "\u0120blaming": 24630, "ndra": 24631, "\u0120slash": 24632, "\u0120Eston": 24633, "\u0120proposing": 24634, "\u0120whales": 24635, "\u0120therapist": 24636, "\u0120subset": 24637, "\u0120leisure": 24638, "ELD": 24639, "\u0120CVE": 24640, "\u0120Activity": 24641, "\u0120culmin": 24642, "shop": 24643, "\u0120DAY": 24644, "ischer": 24645, "\u0120Admiral": 24646, "\u0120Attacks": 24647, "\u01201958": 24648, "\u0120memoir": 24649, "\u0120folded": 24650, "\u0120sexist": 24651, "\u0120153": 24652, "\u0120LI": 24653, "\u0120readings": 24654, "\u0120embarrassment": 24655, "\u0120Employment": 24656, "wart": 24657, "chin": 24658, "\u0120continuation": 24659, "lia": 24660, "Recently": 24661, "\u0120duel": 24662, "\u0120evacuation": 24663, "\u0120Kashmir": 24664, "\u0120disposition": 24665, "\u0120Rig": 24666, "\u0120bolts": 24667, "\u0120insurers": 24668, "467": 24669, "Mex": 24670, "\u0120retaliation": 24671, "\u0120misery": 24672, "\u0120unreasonable": 24673, "raining": 24674, "Imm": 24675, "\u0120PU": 24676, "emer": 24677, "\u0120genital": 24678, "\u00e3\u0124\u00b3": 24679, "\u0120Candy": 24680, "\u0120onions": 24681, "\u0120Patt": 24682, "liner": 24683, "\u0120conceded": 24684, "\u0120fa": 24685, "\u0120forc": 24686, "\u0120Hernandez": 24687, "\u0120Geoff": 24688, "debian": 24689, "\u0120Teams": 24690, "\u0120cries": 24691, "\u0120homeowners": 24692, "237": 24693, "ABC": 24694, "\u0120stitch": 24695, "\u0120statistic": 24696, "\u0120headers": 24697, "\u0120Biology": 24698, "\u0120motors": 24699, "\u0120GEN": 24700, "\u0120Lip": 24701, "\u0120hates": 24702, "\u0120heel": 24703, "Self": 24704, "ipl": 24705, "EDIT": 24706, "orting": 24707, "\u0120annot": 24708, "\u0120Speech": 24709, "oldemort": 24710, "\u0120Javascript": 24711, "\u0120LeBron": 24712, "\u0120footprint": 24713, "\u0120fn": 24714, "\u0120seizures": 24715, "nas": 24716, "hide": 24717, "\u01201954": 24718, "\u0120Bee": 24719, "\u0120Declaration": 24720, "\u0120Katie": 24721, "\u0120reservations": 24722, "NR": 24723, "female": 24724, "\u0120saturated": 24725, "\u0120biblical": 24726, "\u0120trolls": 24727, "Device": 24728, "photos": 24729, "\u0120drums": 24730, "\u00e3\u0125\u012b\u00e3\u0125\u00a9\u00e3\u0124\u00b4\u00e3\u0125\u00b3": 24731, "Night": 24732, "fighter": 24733, "\u0120Hak": 24734, "riber": 24735, "\u0120cush": 24736, "\u0120disciplinary": 24737, "baum": 24738, "\u0120GH": 24739, "\u0120Schmidt": 24740, "ilibrium": 24741, "\u0120sixty": 24742, "\u0120Kushner": 24743, "rots": 24744, "\u0120pund": 24745, "\u0120Rac": 24746, "\u0120springs": 24747, "\u0120conve": 24748, "Business": 24749, "Fall": 24750, "\u0120qualifications": 24751, "\u0120verses": 24752, "\u0120narciss": 24753, "\u0120Koh": 24754, "\u0120Wow": 24755, "\u0120Charlottesville": 24756, "edo": 24757, "\u0120interrogation": 24758, "\u0120Wool": 24759, "365": 24760, "Brian": 24761, "\u0120\u00e2\u013e\u0135": 24762, "\u0120alleges": 24763, "onds": 24764, "idation": 24765, "\u0120Jackie": 24766, "yu": 24767, "\u0120lakes": 24768, "\u0120worthwhile": 24769, "\u0120crystals": 24770, "\u0120Juda": 24771, "\u0120comprehend": 24772, "\u0120flush": 24773, "\u0120absorption": 24774, "\u0120OC": 24775, "\u0120frightened": 24776, "\u0120Chocolate": 24777, "Martin": 24778, "\u0120buys": 24779, "\u0120bucks": 24780, "\u0120appell": 24781, "\u0120Championships": 24782, "\u0120listener": 24783, "\u0120Defensive": 24784, "\u0120cz": 24785, "uds": 24786, "\u0120Mate": 24787, "\u0120replay": 24788, "\u0120decorated": 24789, "\u0120sunk": 24790, "\u0120VIP": 24791, "\u0120Ank": 24792, "\u0120195": 24793, "aaaa": 24794, "Nobody": 24795, "\u0120Milk": 24796, "\u0120Gur": 24797, "\u0120Mk": 24798, "\u0120Sara": 24799, "\u0120seating": 24800, "\u0120Wid": 24801, "Track": 24802, "\u0120employs": 24803, "\u0120gigantic": 24804, "APP": 24805, "\u00e3\u0124\u00a7": 24806, "inventory": 24807, "\u0120towel": 24808, "atche": 24809, "lasting": 24810, "\u0120TL": 24811, "\u0120latency": 24812, "\u0120kne": 24813, "Ber": 24814, "meaning": 24815, "\u0120upheld": 24816, "\u0120playground": 24817, "\u0120mant": 24818, "Side": 24819, "\u0120stereo": 24820, "\u0120northwest": 24821, "\u0120exceptionally": 24822, "\u0120rays": 24823, "\u0120recurring": 24824, "Drive": 24825, "\u0120upright": 24826, "\u0120abduct": 24827, "\u0120Marathon": 24828, "\u0120goodbye": 24829, "\u0120alphabet": 24830, "hp": 24831, "\u0120courtroom": 24832, "rington": 24833, "othing": 24834, "Tag": 24835, "\u0120diplomats": 24836, "\u0120barbar": 24837, "\u0120Aqua": 24838, "183": 24839, "3333": 24840, "\u0120maturity": 24841, "\u0120instability": 24842, "\u0120Apache": 24843, "\u0120===": 24844, "\u0120fasting": 24845, "\u0120Grid": 24846, "ModLoader": 24847, "\u0120152": 24848, "Abs": 24849, "\u0120Operating": 24850, "etti": 24851, "\u0120acquaint": 24852, "Donnell": 24853, "\u0120Kem": 24854, "\u0120Forge": 24855, "\u0120armored": 24856, "Mil": 24857, "\u0120philosophers": 24858, "invest": 24859, "Players": 24860, "\u00e2\u012a": 24861, "\u0120myriad": 24862, "\u0120comrades": 24863, "Rot": 24864, "\u0120remembering": 24865, "\u0120corresponds": 24866, "\u0120programmers": 24867, "\u0120Lynn": 24868, "\u0120olig": 24869, "\u0120coherent": 24870, "ynchron": 24871, "\u0120Chemical": 24872, "\u0120jugg": 24873, "pair": 24874, "posts": 24875, "Eye": 24876, "\u0120Inner": 24877, "\u0120semester": 24878, "ottest": 24879, "\u0120Emirates": 24880, "ricanes": 24881, "orously": 24882, "mits": 24883, "\u0120Wis": 24884, "\u0120dodge": 24885, "location": 24886, "\u0120faded": 24887, "Amazon": 24888, "\u0120Proceed": 24889, "\u0120INFO": 24890, "journal": 24891, "\u0120Truck": 24892, "Ten": 24893, "\u0120217": 24894, "\u0120statutes": 24895, "mobile": 24896, "\u0120Types": 24897, "Recomm": 24898, "buster": 24899, "pex": 24900, "\u0120legends": 24901, "\u0120headache": 24902, "faced": 24903, "\u0120WiFi": 24904, "ifty": 24905, "\u0120HER": 24906, "\u0120circuits": 24907, "ERROR": 24908, "226": 24909, "olin": 24910, "\u0120cylinder": 24911, "ospace": 24912, "ikers": 24913, "Prem": 24914, "Quant": 24915, "\u0120conflicting": 24916, "\u0120slightest": 24917, "\u0120forged": 24918, "ionage": 24919, "Stephen": 24920, "\u0120Kub": 24921, "\u0120Opportun": 24922, "\u0120Heal": 24923, "\u0120blo": 24924, "\u0120rulers": 24925, "\u0120huh": 24926, "\u0120submarine": 24927, "fy": 24928, "asser": 24929, "\u0120allowance": 24930, "\u0120Kasich": 24931, "\u0120Tas": 24932, "\u0120Australians": 24933, "ForgeModLoader": 24934, "\u0120\u00e2\u0128\u0133": 24935, "\u0120Matrix": 24936, "amins": 24937, "\u01201200": 24938, "\u0120Acqu": 24939, "236": 24940, "Document": 24941, "\u0120Breaking": 24942, "193": 24943, "\u0120Subst": 24944, "\u0120Roller": 24945, "\u0120Properties": 24946, "\u0120NI": 24947, "tier": 24948, "\u0120crushing": 24949, "\u0120advocating": 24950, "Furthermore": 24951, "keepers": 24952, "\u0120sexism": 24953, "xd": 24954, "\u0120caller": 24955, "\u0120Sense": 24956, "chieve": 24957, "\u0120TF": 24958, "\u0120fueled": 24959, "\u0120reminiscent": 24960, "\u0120obsess": 24961, "urst": 24962, "\u0120uphold": 24963, "\u0120Fans": 24964, "hetics": 24965, "\u0120\u00e2\u0139": 24966, "\u0120Bath": 24967, "\u0120beverage": 24968, "\u0120oscill": 24969, "254": 24970, "\u0120poles": 24971, "\u0120gradual": 24972, "\u0120exting": 24973, "\u0120Suff": 24974, "\u0120Suddenly": 24975, "\u0120liking": 24976, "\u01201949": 24977, "unciation": 24978, "amination": 24979, "\u0120Omar": 24980, "\u0120LV": 24981, "\u0120Consequently": 24982, "\u0120synthes": 24983, "\u0120GIF": 24984, "\u0120pains": 24985, "\u0120interacting": 24986, "uously": 24987, "incre": 24988, "\u0120rumor": 24989, "\u0120Scientology": 24990, "197": 24991, "\u0120Zig": 24992, "\u0120spelling": 24993, "\u0120ASS": 24994, "\u0120extingu": 24995, "mson": 24996, "\u0120gh": 24997, "\u0120remarked": 24998, "\u0120Strategic": 24999, "\u0120MON": 25000, "\u00e5\u00a5": 25001, "gae": 25002, "\u0120WHAT": 25003, "Eric": 25004, "\u0120Campus": 25005, "\u0120methane": 25006, "\u0120imagin": 25007, "JUST": 25008, "\u0120Alm": 25009, "XT": 25010, "iq": 25011, "\u0120RSS": 25012, "\u0120wrongdoing": 25013, "atta": 25014, "\u0120bigot": 25015, "\u0120demonstrators": 25016, "\u0120Calvin": 25017, "\u0120Villa": 25018, "\u0120membrane": 25019, "\u0120Awesome": 25020, "\u0120benefic": 25021, "268": 25022, "\u0120magnificent": 25023, "\u0120Lots": 25024, "Greg": 25025, "\u0120Boris": 25026, "\u0120detainees": 25027, "\u0120Herman": 25028, "\u0120whispered": 25029, "\u0120awe": 25030, "Professor": 25031, "funding": 25032, "\u0120physiological": 25033, "\u0120Destruction": 25034, "\u0120limb": 25035, "\u0120manipulated": 25036, "\u0120bubbles": 25037, "\u0120pseud": 25038, "\u0120hydra": 25039, "\u0120Bristol": 25040, "\u0120stellar": 25041, "\u0120Expansion": 25042, "\u0120Kell": 25043, "\u0120Interestingly": 25044, "\u0120mans": 25045, "\u0120dragging": 25046, "\u0120ecological": 25047, "\u0120Fit": 25048, "\u0120gent": 25049, "\u0120benefited": 25050, "\u0120Haiti": 25051, "\u0120polyg": 25052, "\u00e3\u0125\u0130": 25053, "\u01202030": 25054, "\u0120prow": 25055, "\u0120reconstruction": 25056, "\u0120wast": 25057, "\u0120psychic": 25058, "\u0120Greeks": 25059, "Handler": 25060, "162": 25061, "\u0120Pulse": 25062, "\u0120solicit": 25063, "\u0120sys": 25064, "\u0120influx": 25065, "\u0120Gentle": 25066, "percent": 25067, "\u0120proliferation": 25068, "\u0120taxable": 25069, "\u0120disregard": 25070, "\u0120escaping": 25071, "\u0120ginger": 25072, "\u0120withstand": 25073, "\u0120devastated": 25074, "\u0120Dew": 25075, "series": 25076, "\u0120injected": 25077, "elaide": 25078, "\u0120turnover": 25079, "heat": 25080, "\u013b\u0124": 25081, "Happy": 25082, "\u0120Silent": 25083, "\u00e3\u0124\u0143": 25084, "ivism": 25085, "\u0120irrational": 25086, "AMA": 25087, "\u0120reef": 25088, "rub": 25089, "\u0120162": 25090, "\u0120bankers": 25091, "\u0120Ethics": 25092, "vv": 25093, "\u0120criticisms": 25094, "Kn": 25095, "186": 25096, "Movie": 25097, "\u0120Tories": 25098, "\u0120nood": 25099, "\u0120distortion": 25100, "False": 25101, "odore": 25102, "\u0120tasty": 25103, "Research": 25104, "\u0120UID": 25105, "-)": 25106, "\u0120divorced": 25107, "\u0120MU": 25108, "\u0120Hayes": 25109, "\u0120Isn": 25110, "iani": 25111, "\u0120HQ": 25112, "\u0120\"#": 25113, "ignant": 25114, "\u0120traumatic": 25115, "\u0120Ling": 25116, "Hun": 25117, "\u0120sabot": 25118, "online": 25119, "random": 25120, "\u0120renamed": 25121, "rared": 25122, "KA": 25123, "dead": 25124, "\u00c3\u00a9t": 25125, "\u0120Assistance": 25126, "\u0120seaf": 25127, "++++++++": 25128, "\u0120seldom": 25129, "\u0120Webb": 25130, "\u0120boolean": 25131, "ulet": 25132, "\u0120refrain": 25133, "\u0120DIY": 25134, "rule": 25135, "\u0120shutting": 25136, "\u0120utilizing": 25137, "loading": 25138, "\u0120Param": 25139, "coal": 25140, "ooter": 25141, "\u0120attracting": 25142, "\u0120Dol": 25143, "\u0120hers": 25144, "agnetic": 25145, "\u0120Reach": 25146, "imo": 25147, "\u0120discarded": 25148, "\u0120Pip": 25149, "015": 25150, "\u00c3\u00bcr": 25151, "\u0120mug": 25152, "Imagine": 25153, "COL": 25154, "\u0120cursed": 25155, "\u0120Shows": 25156, "\u0120Curtis": 25157, "\u0120Sachs": 25158, "speaking": 25159, "\u0120Vista": 25160, "\u0120Framework": 25161, "ongo": 25162, "\u0120subreddit": 25163, "\u0120crus": 25164, "\u0120Oval": 25165, "Row": 25166, "growing": 25167, "\u0120installment": 25168, "\u0120glac": 25169, "\u0120Advance": 25170, "ECK": 25171, "\u0120LGBTQ": 25172, "LEY": 25173, "\u0120acet": 25174, "\u0120successive": 25175, "\u0120Nicole": 25176, "\u01201957": 25177, "Quote": 25178, "\u0120circumstance": 25179, "ackets": 25180, "\u0120142": 25181, "ortium": 25182, "\u0120guessed": 25183, "\u0120Frame": 25184, "\u0120perpetrators": 25185, "\u0120Aviation": 25186, "\u0120Bench": 25187, "\u0120handc": 25188, "Ap": 25189, "\u01201956": 25190, "259": 25191, "rand": 25192, "NetMessage": 25193, "din": 25194, "urtles": 25195, "hig": 25196, "\u0120VIII": 25197, "ffiti": 25198, "\u0120Swords": 25199, "bial": 25200, "\u0120kidnapping": 25201, "device": 25202, "\u0120barn": 25203, "\u0120Eli": 25204, "aucas": 25205, "Send": 25206, "Constructed": 25207, "\u0120\u00c2\u00bd": 25208, "\u0120needles": 25209, "\u0120advertisements": 25210, "\u0120vou": 25211, "\u0120exhibited": 25212, "\u0120Fortress": 25213, "Ask": 25214, "Berry": 25215, "TYPE": 25216, "\u0120cancers": 25217, "umping": 25218, "\u0120Territory": 25219, "\u0120prud": 25220, "\u0120nas": 25221, "\u0120atheist": 25222, "\u0120balances": 25223, "\u00e3\u0123\u0141": 25224, "\u0120Shawn": 25225, "&&": 25226, "\u0120landsc": 25227, "\u0120RGB": 25228, "\u0120petty": 25229, "\u0120excellence": 25230, "\u0120translations": 25231, "\u0120parcel": 25232, "\u0120Chev": 25233, "East": 25234, "\u0120Output": 25235, "imi": 25236, "\u0120ambient": 25237, "\u0120Threat": 25238, "\u0120villains": 25239, "\u0120550": 25240, "ICA": 25241, "\u0120taller": 25242, "\u0120leaking": 25243, "cup": 25244, "\u0120polish": 25245, "\u0120infectious": 25246, "\u0120KC": 25247, "\u0120@@": 25248, "background": 25249, "\u0120bureaucracy": 25250, "\u0120Sai": 25251, "unless": 25252, "itious": 25253, "\u0120Skype": 25254, "Atl": 25255, "IDENT": 25256, "008": 25257, "\u0120hypocr": 25258, "\u0120pitchers": 25259, "\u0120guessing": 25260, "\u0120FINAL": 25261, "Between": 25262, "\u0120villagers": 25263, "\u0120252": 25264, "fashion": 25265, "\u0120Tunis": 25266, "Beh": 25267, "\u0120Exc": 25268, "\u0120MID": 25269, "288": 25270, "\u0120Haskell": 25271, "196": 25272, "\u0120NOR": 25273, "\u0120specs": 25274, "\u0120invari": 25275, "\u0120glut": 25276, "\u0120Cars": 25277, "\u0120impulse": 25278, "\u0120honors": 25279, "gel": 25280, "\u0120jurisdictions": 25281, "\u0120Bundle": 25282, "ulas": 25283, "California": 25284, "\u0120Increase": 25285, "\u0120pear": 25286, "\u0120singles": 25287, "\u0120cues": 25288, "\u0120underwent": 25289, "\u0120WS": 25290, "\u0120exaggerated": 25291, "\u0120dubious": 25292, "\u0120flashing": 25293, "LOG": 25294, ")].": 25295, "Journal": 25296, "tg": 25297, "Van": 25298, "\u0120Istanbul": 25299, "\u0120Insp": 25300, "\u0120Franken": 25301, "Draw": 25302, "\u0120sadness": 25303, "\u0120ironic": 25304, "\u0120Fry": 25305, "xc": 25306, "\u0120164": 25307, "isch": 25308, "Way": 25309, "\u0120Protestant": 25310, "horn": 25311, "\u0120unaff": 25312, "\u0120Viv": 25313, "illas": 25314, "\u0120Productions": 25315, "\u0120Hogan": 25316, "\u0120perimeter": 25317, "\u0120Sisters": 25318, "\u0120spontaneous": 25319, "\u0120downside": 25320, "\u0120descendants": 25321, "\u0120orn": 25322, "worm": 25323, "Japanese": 25324, "\u01201955": 25325, "\u0120151": 25326, "\u0120Doing": 25327, "elsen": 25328, "umbles": 25329, "\u0120radically": 25330, "\u0120Drum": 25331, "\u0120Bach": 25332, "\u0120liabilities": 25333, "\u0120OB": 25334, "\u0120Elementary": 25335, "\u0120meme": 25336, "ynes": 25337, "\u0120fingerprint": 25338, "\u0120Grab": 25339, "\u0120undertake": 25340, "Members": 25341, "\u0120Reader": 25342, "\u0120Sims": 25343, "god": 25344, "\u0120hypothetical": 25345, "scient": 25346, "\u0120AJ": 25347, "\u0120charism": 25348, "\u0120admissions": 25349, "\u0120Missile": 25350, "trade": 25351, "\u0120exercising": 25352, "\u0120Background": 25353, "Written": 25354, "\u0120vocals": 25355, "whether": 25356, "\u0120vi": 25357, "\u0120Winner": 25358, "\u0120litter": 25359, "\u0120Shooting": 25360, "STEM": 25361, "\u00e3\u0124\u00a1": 25362, "\u0120AFL": 25363, "\u0120variability": 25364, "\u0120eats": 25365, "\u0120DPS": 25366, "brow": 25367, "\u0120elephants": 25368, "\u0120strat": 25369, "\u0120\u00c5": 25370, "\u0120settlers": 25371, "Matthew": 25372, "\u0120inadvert": 25373, "HI": 25374, "\u0120IMF": 25375, "\u0120Goal": 25376, "\u0120nerves": 25377, "Johnson": 25378, "eye": 25379, "ablishment": 25380, "Thursday": 25381, "BILITY": 25382, "Had": 25383, "amoto": 25384, "hetamine": 25385, "eps": 25386, "\u0120mitochond": 25387, "\u0120compressed": 25388, "\u0120Trevor": 25389, "\u0120Animals": 25390, "Tool": 25391, "Lock": 25392, "\u0120tweak": 25393, "\u0120pinch": 25394, "\u0120cancellation": 25395, "Pot": 25396, "\u0120focal": 25397, "\u0120Astron": 25398, "173": 25399, "\u0120ASC": 25400, "\u0120OTHER": 25401, "umni": 25402, "\u0120demise": 25403, "dl": 25404, "\u00d9\u0127": 25405, "Semitism": 25406, "\u0120cracking": 25407, "\u0120collaborative": 25408, "\u0120explores": 25409, "sql": 25410, "\u0120herbs": 25411, "\u0120configurations": 25412, "mis": 25413, "\u0120Result": 25414, "acey": 25415, "\u0120Smoke": 25416, "\u0120sanct": 25417, "elia": 25418, "\u0120degener": 25419, "\u0120deepest": 25420, "\u0120screamed": 25421, "\u0120nap": 25422, "Software": 25423, "\u0120STAR": 25424, "EF": 25425, "\u0120Xin": 25426, "sponsored": 25427, "manship": 25428, "233": 25429, "\u0120primaries": 25430, "\u0120filtering": 25431, "\u0120assemble": 25432, "mil": 25433, "\u0120Myers": 25434, "bows": 25435, "\u0120punched": 25436, "Mic": 25437, "\u0120innovations": 25438, "\u0120func": 25439, "ando": 25440, "\u0120fracking": 25441, "\u0120Vul": 25442, "\u00d0\u00be\u00d0": 25443, "oshop": 25444, "\u0120Immun": 25445, "\u0120settling": 25446, "\u0120adolescents": 25447, "\u0120rebuilding": 25448, "\u0120transforming": 25449, "\u0120parole": 25450, "\u0120harbor": 25451, "\u0120booking": 25452, "otional": 25453, "ongevity": 25454, "\u0120Yo": 25455, "bug": 25456, "\u0120emerges": 25457, "\u0120Methods": 25458, "\u0120Chu": 25459, "Pres": 25460, "\u0120Dungeons": 25461, "\u0120trailing": 25462, "\u0120Rum": 25463, "\u0120Hugh": 25464, "\u00e5\u00a4\u00a9": 25465, "\u0120Era": 25466, "\u0120Battles": 25467, "Results": 25468, "\u0120Trading": 25469, "\u0120versa": 25470, "css": 25471, "axies": 25472, "heet": 25473, "\u0120greed": 25474, "1989": 25475, "\u0120gardens": 25476, "\u0120contingent": 25477, "Park": 25478, "\u0120Leafs": 25479, "hook": 25480, "robe": 25481, "\u0120diplomacy": 25482, "\u0120Fuel": 25483, "\u0120Invasion": 25484, "\u0120upgrading": 25485, "Male": 25486, "\u0120elic": 25487, "\u0120relentless": 25488, "\u0120Covenant": 25489, "apesh": 25490, "\u0120Trop": 25491, "Ty": 25492, "production": 25493, "arty": 25494, "\u0120punches": 25495, "ako": 25496, "cyclopedia": 25497, "\u0120Rabbit": 25498, "\u0120HDMI": 25499, "\u0120141": 25500, "\u0120foil": 25501, "ItemImage": 25502, "\u0120FG": 25503, "\u0120implementations": 25504, "\u0120Pom": 25505, "ixtures": 25506, "\u0120await": 25507, "\u0120330": 25508, "amus": 25509, "\u0120umbrella": 25510, "\u0120foresee": 25511, "separ": 25512, "\u0120circumcision": 25513, "\u0120peripheral": 25514, "Say": 25515, "\u0120Expert": 25516, "Inc": 25517, "\u0120withdrew": 25518, "\u0120Anders": 25519, "fried": 25520, "\u0120radioactive": 25521, "\u0120Opening": 25522, "\u0120boarding": 25523, "\u0120ND": 25524, "\u0120overthrow": 25525, "Activ": 25526, "WP": 25527, "\u0120Acts": 25528, "\u00d7\u013b": 25529, "\u0120motions": 25530, "vic": 25531, "\u0120Mighty": 25532, "\u0120Defender": 25533, "aer": 25534, "\u0120thankful": 25535, "\u0120Killing": 25536, "\u0120Bris": 25537, "moil": 25538, "\u0120predicting": 25539, "266": 25540, "choice": 25541, "\u0120killers": 25542, "\u0120incub": 25543, "\u0120Chest": 25544, "athering": 25545, "\u0120proclaimed": 25546, "flower": 25547, "ossom": 25548, "umbledore": 25549, "\u0120Cycling": 25550, "\u0120Occupy": 25551, "AGES": 25552, "Pen": 25553, "\u0120Yug": 25554, "\u0120packaged": 25555, "\u0120heightened": 25556, "cot": 25557, "stack": 25558, "Cond": 25559, "\u0120stamps": 25560, "mage": 25561, "\u0120persuaded": 25562, "\u0120ensl": 25563, "\u0120Cardinal": 25564, "\u0120solitary": 25565, "\u0120possessing": 25566, "\u0120Cork": 25567, "\u0120evid": 25568, "\u0120Tay": 25569, "\u0120blues": 25570, "\u0120extremism": 25571, "\u0120lunar": 25572, "\u0120clown": 25573, "Techn": 25574, "\u0120festivals": 25575, "\u0120PvP": 25576, "\u0120Lar": 25577, "\u0120consequently": 25578, "present": 25579, "\u0120someday": 25580, "\u00e7\u0130\u012d": 25581, "\u0120Meteor": 25582, "\u0120touring": 25583, "culture": 25584, "\u0120beaches": 25585, "Ship": 25586, "cause": 25587, "\u0120Flood": 25588, "\u00e3\u0125\u00af": 25589, "\u0120purity": 25590, "those": 25591, "\u0120emission": 25592, "bolt": 25593, "\u0120chord": 25594, "\u0120Scripture": 25595, "Lu": 25596, "\u0120${": 25597, "created": 25598, "Others": 25599, "258": 25600, "\u0120elemental": 25601, "\u0120annoyed": 25602, "\u0120AE": 25603, "dan": 25604, "\u0120Sag": 25605, "Researchers": 25606, "\u0120fairy": 25607, "\u00e2\u0122\u0135\u00e2\u0122\u0135": 25608, "============": 25609, "Smart": 25610, "GGGG": 25611, "\u0120skeletons": 25612, "\u0120pupils": 25613, "linked": 25614, "\u0120urgency": 25615, "enabled": 25616, "\u0120Fuck": 25617, "\u0120councill": 25618, "rab": 25619, "UAL": 25620, "TI": 25621, "\u0120lifes": 25622, "\u0120confessed": 25623, "Bug": 25624, "\u0120harmon": 25625, "\u0120CONFIG": 25626, "\u0120Neutral": 25627, "Double": 25628, "\u0120staple": 25629, "\u0120SHA": 25630, "British": 25631, "\u0120SNP": 25632, "ATOR": 25633, "oco": 25634, "\u0120swinging": 25635, "gex": 25636, "oleon": 25637, "plain": 25638, "\u0120Missing": 25639, "\u0120Trophy": 25640, "vari": 25641, "ranch": 25642, "\u0120301": 25643, "440": 25644, "0000000000000000": 25645, "\u0120restoring": 25646, "\u0120haul": 25647, "ucing": 25648, "nerg": 25649, "\u0120futures": 25650, "\u0120strategist": 25651, "question": 25652, "\u0120lateral": 25653, "\u0120Bard": 25654, "\u0120sor": 25655, "\u0120Rhodes": 25656, "\u0120Downtown": 25657, "?????-": 25658, "\u0120Lit": 25659, "\u0120Bened": 25660, "\u0120coil": 25661, "street": 25662, "\u0120Portal": 25663, "FILE": 25664, "\u0120Gru": 25665, "*,": 25666, "231": 25667, "neum": 25668, "\u0120sucked": 25669, "\u0120rapper": 25670, "\u0120tendencies": 25671, "\u0120Lauren": 25672, "cellaneous": 25673, "267": 25674, "\u0120browse": 25675, "\u0120overc": 25676, "header": 25677, "oise": 25678, "\u0120beet": 25679, "\u0120Gle": 25680, "Stay": 25681, "\u0120mum": 25682, "\u0120typed": 25683, "\u0120discounts": 25684, "Talk": 25685, "\u0120Og": 25686, "existing": 25687, "\u0120Sell": 25688, "uph": 25689, "CI": 25690, "\u0120Austrian": 25691, "\u0120Warm": 25692, "\u0120dismissal": 25693, "\u0120averages": 25694, "camera": 25695, "\u0120allegiance": 25696, "LAN": 25697, "=\"#": 25698, "\u0120commentators": 25699, "\u0120Setting": 25700, "\u0120Midwest": 25701, "\u0120pharmac": 25702, "\u0120EXP": 25703, "\u0120stainless": 25704, "Chicago": 25705, "\u0120tan": 25706, "244": 25707, "\u0120countryside": 25708, "\u0120Vac": 25709, "295": 25710, "\u0120pinned": 25711, "\u0120crises": 25712, "\u0120standardized": 25713, "Task": 25714, "\u0120Jail": 25715, "\u0120Docker": 25716, "colored": 25717, "forth": 25718, "\"},": 25719, "\u0120patrons": 25720, "\u0120spice": 25721, "\u0120mourn": 25722, "\u0120Mood": 25723, "\u0120laundry": 25724, "\u0120equip": 25725, "\u0120Mole": 25726, "yll": 25727, "\u0120THC": 25728, "nation": 25729, "\u0120Sherlock": 25730, "\u0120issu": 25731, "\u0120Kre": 25732, "\u0120Americas": 25733, "\u0120AAA": 25734, "\u0120systematically": 25735, "\u0120contra": 25736, "\u0120Sally": 25737, "\u0120rationale": 25738, "\u0120carriage": 25739, "\u0120peaks": 25740, "\u0120contradiction": 25741, "ensation": 25742, "\u0120Failure": 25743, "\u0120props": 25744, "\u0120namespace": 25745, "\u0120cove": 25746, "fields": 25747, "\u00e3\u0124\u012d": 25748, "\u0120wool": 25749, "\u0120Catch": 25750, "\u0120presumed": 25751, "\u0120Diana": 25752, "ragon": 25753, "igi": 25754, "\u0120hamm": 25755, "\u0120stunt": 25756, "\u0120GUI": 25757, "\u0120Observatory": 25758, "\u0120Shore": 25759, "\u0120smells": 25760, "annah": 25761, "\u0120cockpit": 25762, "\u0120Duterte": 25763, "850": 25764, "\u0120oppressed": 25765, "breaker": 25766, "\u0120Contribut": 25767, "\u0120Peru": 25768, "\u0120Monsanto": 25769, "\u0120Attempt": 25770, "\u0120commanding": 25771, "\u0120fridge": 25772, "\u0120Rin": 25773, "\u0120Chess": 25774, "uality": 25775, "\u0120ol": 25776, "Republican": 25777, "\u0120Glory": 25778, "\u0120WIN": 25779, ".......": 25780, "agent": 25781, "reading": 25782, "\u0120inh": 25783, "Jones": 25784, "\u0120clicks": 25785, "alan": 25786, "\u0120[];": 25787, "\u0120Majesty": 25788, "\u0120Ced": 25789, "opus": 25790, "atel": 25791, "\u00c3\u00aa": 25792, "ARC": 25793, "\u0120Ecuador": 25794, "\u00e3\u0125\u0142": 25795, "\u0120Kuro": 25796, "\u0120rituals": 25797, "\u0120captive": 25798, "\u0120ounce": 25799, "\u0120disagreement": 25800, "\u0120slog": 25801, "fuel": 25802, "Pet": 25803, "Mail": 25804, "\u0120exercised": 25805, "\u0120solic": 25806, "\u0120rainfall": 25807, "\u0120devotion": 25808, "\u0120Assessment": 25809, "\u0120robotic": 25810, "options": 25811, "\u0120RP": 25812, "\u0120Families": 25813, "\u0120Flames": 25814, "\u0120assignments": 25815, "007": 25816, "akedown": 25817, "\u0120vocabulary": 25818, "Reilly": 25819, "\u0120caval": 25820, "gars": 25821, "\u0120suppressed": 25822, "\u0120SET": 25823, "\u0120Johns": 25824, "\u0120warp": 25825, "broken": 25826, "\u0120statues": 25827, "\u0120advocated": 25828, "\u0120275": 25829, "\u0120peril": 25830, "omorph": 25831, "\u0120Femin": 25832, "perfect": 25833, "\u0120hatch": 25834, "Lib": 25835, "512": 25836, "\u0120lifelong": 25837, "313": 25838, "\u0120cheeks": 25839, "\u0120numbered": 25840, "\u0120Mug": 25841, "Body": 25842, "ravel": 25843, "Weight": 25844, "\u0120Jak": 25845, "\u0120Heath": 25846, "\u0120kissing": 25847, "\u0120JUST": 25848, "\u0120waving": 25849, "upload": 25850, "\u0120insider": 25851, "\u0120Progressive": 25852, "\u0120Filter": 25853, "tta": 25854, "\u0120Beam": 25855, "\u0120violently": 25856, "ipation": 25857, "\u0120skepticism": 25858, "\u01201918": 25859, "\u0120Annie": 25860, "\u0120SI": 25861, "\u0120genetics": 25862, "\u0120onboard": 25863, "atl": 25864, "\u0120Friedman": 25865, "\u0120Bri": 25866, "ceptive": 25867, "\u0120pirate": 25868, "\u0120Reporter": 25869, "278": 25870, "\u0120mythology": 25871, "\u0120eclipse": 25872, "\u0120skins": 25873, "\u0120glyph": 25874, "ingham": 25875, "Files": 25876, "Cour": 25877, "women": 25878, "\u0120regimes": 25879, "\u0120photographed": 25880, "Kat": 25881, "\u0120MAX": 25882, "Officials": 25883, "\u0120unexpectedly": 25884, "\u0120impressions": 25885, "Front": 25886, ";;;;;;;;": 25887, "\u0120supremacy": 25888, "\u0120sang": 25889, "\u0120aggravated": 25890, "\u0120abruptly": 25891, "\u0120Sector": 25892, "\u0120excuses": 25893, "\u0120costing": 25894, "idepress": 25895, "Stack": 25896, "\u0120RNA": 25897, "obil": 25898, "\u0120ghosts": 25899, "ldon": 25900, "atibility": 25901, "Topics": 25902, "\u0120reimburse": 25903, "\u0120HM": 25904, "\u0120Deg": 25905, "\u0120thief": 25906, "yet": 25907, "ogenesis": 25908, "leaning": 25909, "\u0120Kol": 25910, "\u0120Basketball": 25911, "\u0120fi": 25912, "\u0120Seeing": 25913, "\u0120recycling": 25914, "\u0120[-": 25915, "Congress": 25916, "\u0120lectures": 25917, "Psy": 25918, "\u0120nep": 25919, "\u0120maid": 25920, "\u0120oriented": 25921, "AX": 25922, "\u0120respectful": 25923, "rene": 25924, "flush": 25925, "\u0120Unloaded": 25926, "request": 25927, "grid": 25928, "\u0120Alternatively": 25929, "\u0120Hugo": 25930, "\u0120decree": 25931, "\u0120Buddhism": 25932, "andum": 25933, "Android": 25934, "\u0120Congo": 25935, "\u0120Joyce": 25936, "\u0120acknowledging": 25937, "hesive": 25938, "\u0120Tomorrow": 25939, "\u0120Hiro": 25940, "thren": 25941, "\u0120Maced": 25942, "\u0120hoax": 25943, "\u0120Increased": 25944, "\u0120Pradesh": 25945, "Wild": 25946, "______": 25947, "161": 25948, "\u0120aunt": 25949, "\u0120distributing": 25950, "\u0120Tucker": 25951, "\u0120SSL": 25952, "\u0120Wolves": 25953, "Building": 25954, "oult": 25955, "\u0120Luo": 25956, "\u0120Yas": 25957, "\u0120Spir": 25958, "\u0120Shape": 25959, "\u0120Cambod": 25960, "\u0120IPv": 25961, "\u0120ml": 25962, "\u0120extrad": 25963, "390": 25964, "\u0120Penny": 25965, "dream": 25966, "\u0120stationed": 25967, "optional": 25968, "eworthy": 25969, ".</": 25970, "\u0120undertaking": 25971, "\u0120chickens": 25972, "\u0120stimuli": 25973, "\u0120Else": 25974, "igators": 25975, "\u0120Beginning": 25976, "ctory": 25977, "\u0120prepares": 25978, "\u0120delta": 25979, "\u0120vicinity": 25980, "tool": 25981, "\u0120workshops": 25982, "MHz": 25983, "\u0120accusation": 25984, "\u0120histories": 25985, "ropolis": 25986, "\u0120Churchill": 25987, "\u0120neon": 25988, "\u0120baff": 25989, "dies": 25990, "maybe": 25991, "\u0120\u00e8\u00a3\u0131\u00e8\u00a6\u013c\u00e9\u0128\u0134": 25992, "\u0120symptom": 25993, "ECH": 25994, "\u0120Manuel": 25995, "\u0120banana": 25996, "\u0120HB": 25997, "\u0120****": 25998, "\u0120Koreans": 25999, "coll": 26000, "FB": 26001, "\u0120praying": 26002, "\u0120Cannot": 26003, "\u0120Mile": 26004, "\u0120embracing": 26005, "\u0120Silk": 26006, "393": 26007, "oters": 26008, "FD": 26009, "\u0120daylight": 26010, "alias": 26011, "\u0120Brigade": 26012, "\u0120Hannah": 26013, "\u0120clergy": 26014, "\u0120southeast": 26015, "\u0120alcoholic": 26016, "\u0120proposes": 26017, "livion": 26018, "\u0120calculating": 26019, "\u0120stimulate": 26020, "\u0120splitting": 26021, "eight": 26022, "\u0120Indy": 26023, "plays": 26024, "\u0120Pik": 26025, "\u0120domest": 26026, "\u0120forgiveness": 26027, "\u0120Rings": 26028, "patient": 26029, "kinson": 26030, "Mont": 26031, "igible": 26032, ";\"": 26033, "\u0120periodically": 26034, "ammad": 26035, "\u0120Britt": 26036, "pard": 26037, "\u0120arbitration": 26038, "\u0120Schneider": 26039, "\u0120Corporate": 26040, "\u0120Maya": 26041, "\u0120snakes": 26042, "aum": 26043, "\u0120blasted": 26044, "\u0120mysteries": 26045, "\u0120revive": 26046, "ocamp": 26047, "\u0120Dodge": 26048, "\u0120Opera": 26049, "279": 26050, "\u0120orphan": 26051, "\u0120specifies": 26052, "\u0120Mets": 26053, "Duration": 26054, "Hen": 26055, "\u0120fireworks": 26056, "\u0120prosecute": 26057, "\u0120Tillerson": 26058, "dp": 26059, "usage": 26060, "liness": 26061, "\u0120Debian": 26062, "\u0120224": 26063, "rises": 26064, "\u0120Infect": 26065, "atra": 26066, "\u0120RR": 26067, "\u0120Lor": 26068, "diff": 26069, "\u0120Charleston": 26070, "\u0120acoustic": 26071, "\u0120amuse": 26072, "330": 26073, "\u0120cer": 26074, "\u0120Tac": 26075, "\u0120[+": 26076, "\u0120cardiac": 26077, "\u0120Restaurant": 26078, "ergy": 26079, "\u0120fuzz": 26080, "\u0120bites": 26081, "\u0120hazardous": 26082, "\u0120brighter": 26083, "rans": 26084, "\u0120Stephanie": 26085, "extra": 26086, "RET": 26087, "\u0120Christine": 26088, "\u0120Sue": 26089, "statement": 26090, "\u0120bolster": 26091, "\u0120antit": 26092, "Radio": 26093, "BIT": 26094, "\u00e3\u0124\u00b0": 26095, "\u0120visions": 26096, "\u0120Concept": 26097, "\u0120inline": 26098, "\u0120Philosophy": 26099, "isans": 26100, "\u0120Irving": 26101, "\u00c3\u00a3": 26102, "taking": 26103, "\u0120inconsist": 26104, "\u0120Kumar": 26105, "\u0120lig": 26106, "\u0120Schumer": 26107, "\u0120Regulations": 26108, "\u0120Hz": 26109, "thro": 26110, "\u0120Voldemort": 26111, "\u0120MED": 26112, "\u0120Frederick": 26113, "Pad": 26114, "221": 26115, "\u0120alleging": 26116, "\u0120Communication": 26117, "\u0120167": 26118, "\u0120forecasts": 26119, "\u0120spiders": 26120, "Organ": 26121, "\u0120Participants": 26122, "\u0120Ops": 26123, "design": 26124, "Close": 26125, "\u0120facto": 26126, "\u0120bombers": 26127, "resistant": 26128, "ategories": 26129, "School": 26130, "\u0120homework": 26131, "\u0120corro": 26132, "Tuesday": 26133, "\u0120Brendan": 26134, "\u0120MX": 26135, "\u0120TS": 26136, "\u0120Stri": 26137, "\u0120stakeholders": 26138, "\u0120Millennium": 26139, "\u0120transferring": 26140, "Jud": 26141, "\u0120tac": 26142, "\u01201600": 26143, "\u0120SDK": 26144, "rb": 26145, "\u0120interpretations": 26146, "\u0120SG": 26147, "\u0120upstairs": 26148, "\u0120Harvest": 26149, "\u0120vagina": 26150, "\u0120ingest": 26151, "xf": 26152, "\u0120Orion": 26153, "\u0120Joey": 26154, "\u0120sandwic": 26155, "\u0120immortal": 26156, "\u0120flipped": 26157, "ortex": 26158, "threatening": 26159, "\u0120sniper": 26160, "\u0120converts": 26161, "\u0120installations": 26162, "\u0120Bulgar": 26163, "orsche": 26164, "mails": 26165, "\u0120lure": 26166, "\u0120narrowly": 26167, "\u0120grenade": 26168, "\u0120Ging": 26169, "\u0120underwear": 26170, "--------------": 26171, "\u0120chased": 26172, "\u0120VAL": 26173, "\u0120parenting": 26174, "\u0120Hamb": 26175, "\u0120Blaz": 26176, "\u0120anarchist": 26177, "\u0120Median": 26178, "\u0120Programs": 26179, "\u00ce\u00bd": 26180, "\u0120obj": 26181, "\u0120Nokia": 26182, "orman": 26183, "anqu": 26184, "atism": 26185, "opa": 26186, "\u0120fulfilling": 26187, "\u0120puppy": 26188, "\u0120entit": 26189, "\u0120Sebastian": 26190, "\u0120shooters": 26191, "\u0120richer": 26192, "\u00e8\u00a1": 26193, "\u0120tempted": 26194, "\u0120ATT": 26195, "\u0120CV": 26196, "\u0120tore": 26197, "Resource": 26198, "\u0120Devils": 26199, "408": 26200, "inational": 26201, "\u0120assurance": 26202, "\u0120Darren": 26203, "\u0120whichever": 26204, "posure": 26205, "\u0120fury": 26206, "Stock": 26207, "\u0120universally": 26208, "response": 26209, "\u0120oak": 26210, "\u0120workload": 26211, "\u0120Corner": 26212, "eele": 26213, "\"...": 26214, "\u0120deprived": 26215, "kowski": 26216, "\u0120casts": 26217, "\u0120affiliation": 26218, "\u0120Ach": 26219, "\u0120Asked": 26220, "athe": 26221, "\u0120lact": 26222, "\u0120Thu": 26223, "rm": 26224, "\u0120airlines": 26225, "\u0120notions": 26226, "Format": 26227, "\u0120FAA": 26228, "\u00e3\u0125\u012c": 26229, "driver": 26230, "\u0120transcend": 26231, "Settings": 26232, "\u0120Prosecut": 26233, "\u0120spinal": 26234, "\u0120defaults": 26235, "FK": 26236, "\u0120prefers": 26237, "rendered": 26238, "thus": 26239, "film": 26240, "\u0120tiger": 26241, "\u0120Spicer": 26242, "recogn": 26243, "\u0120Rugby": 26244, "Network": 26245, "\u0120pity": 26246, "\u0120compartment": 26247, "casters": 26248, "\u0120Monroe": 26249, "\u0120720": 26250, "\u0120corrections": 26251, "\u0120dopamine": 26252, "\u0120AZ": 26253, "Cut": 26254, "\u0120roomm": 26255, "\u0120speculate": 26256, "Hash": 26257, "\u0120restrictive": 26258, "1111": 26259, "redible": 26260, "onel": 26261, "\u0120rampant": 26262, "reported": 26263, "\u0120Suite": 26264, "\u0120Minimum": 26265, "alys": 26266, "azard": 26267, "loop": 26268, "\u0120lent": 26269, "sha": 26270, "\u0120vandal": 26271, "menu": 26272, "\u0120Boehner": 26273, "\u0120narratives": 26274, "\u0120authenticity": 26275, "269": 26276, "anic": 26277, "duty": 26278, "285": 26279, "\u0120thanked": 26280, "\u0120betrayed": 26281, "lift": 26282, "\u0120southwest": 26283, "\u0120Dexter": 26284, "\u0120Bod": 26285, "\u0120keywords": 26286, "Average": 26287, "DIS": 26288, "\u0120ethnicity": 26289, "!),": 26290, "\u0120Nationals": 26291, "\u00e1\u00b9": 26292, "\u0120Tah": 26293, "ioxid": 26294, "\u0120widget": 26295, "\u0120pasta": 26296, "\u0120billing": 26297, "\u0120trilogy": 26298, "\u0120Lines": 26299, "\u0120sniff": 26300, "\u0120nephew": 26301, "Late": 26302, "\u0120princip": 26303, "\u0120Loop": 26304, "\u0120Marxist": 26305, "\u0120dissolved": 26306, "\u0120contexts": 26307, "\u0120Amount": 26308, "\u0120Spike": 26309, "\u0120totals": 26310, "\u0120organizer": 26311, "\u0120uprising": 26312, "ships": 26313, "YY": 26314, "\u0120Northeast": 26315, "money": 26316, "gradation": 26317, "\u0120goalkeeper": 26318, "\u0120Hear": 26319, "\u0120steak": 26320, "\u0120BuzzFeed": 26321, "\u0120solemn": 26322, "\u0120Scand": 26323, "\u0120popping": 26324, "\u0120adhere": 26325, "\u0120Alleg": 26326, "byte": 26327, "\u0120Wolver": 26328, "\u0120unin": 26329, "\u0120recol": 26330, "itud": 26331, "\u0120mimic": 26332, "ibus": 26333, "\u0120predicts": 26334, "\u0120Keeper": 26335, "iating": 26336, "\u0120deception": 26337, "\u0120learnt": 26338, "\u0120diary": 26339, "\u0120conditional": 26340, "\u0120relic": 26341, "\u0120invoke": 26342, "ienced": 26343, "\u00e5\u012a": 26344, "\u0120Pont": 26345, "\u0120cellphone": 26346, "\u0120speeding": 26347, "\u0120tackling": 26348, "\u0120nude": 26349, "opened": 26350, "\u0120Manafort": 26351, "\u01201952": 26352, "\u0120majors": 26353, "\u0120Silence": 26354, "\u0120logistics": 26355, "\u0120weighted": 26356, "\u0120Psychiat": 26357, "\":[\"": 26358, "\u0120sickness": 26359, "\u0120dividends": 26360, "zon": 26361, "Release": 26362, "\u0120Keys": 26363, "\u0120Ich": 26364, "\u0120enz": 26365, "\u0120Fernand": 26366, "\u0120\u00ce\u00b1": 26367, "\u0120meanings": 26368, "\u0120penny": 26369, "\u0120stern": 26370, "\u0120lar": 26371, "\u0120Published": 26372, "\u0120backdrop": 26373, "Kim": 26374, "\u0120Synt": 26375, "\u0120debuted": 26376, "wm": 26377, "\u0120Isle": 26378, "\u0120regulating": 26379, "otti": 26380, "\u0120Scholars": 26381, "icester": 26382, "\u0120Chef": 26383, "\u0120pops": 26384, "\u0120Launcher": 26385, "\u0120Various": 26386, "\u0120commenting": 26387, "oslav": 26388, "enzie": 26389, "\u0120rivalry": 26390, "\u00e2\u0124\u00ac": 26391, "Really": 26392, "\u0120orc": 26393, "\u0120bean": 26394, "\u0120Judy": 26395, "Notice": 26396, "\u0120Bike": 26397, "?]": 26398, "\u0120rented": 26399, "sten": 26400, "\u0120forefront": 26401, "\u0120Baldwin": 26402, "\u0120yielded": 26403, "tails": 26404, "Prime": 26405, "\u0120Sources": 26406, "icator": 26407, "Sean": 26408, "\u0120marching": 26409, "Output": 26410, "\u0120Jungle": 26411, "\u0120reside": 26412, "zzle": 26413, "\u0120Andrews": 26414, "\u0120torque": 26415, "Basic": 26416, "Actually": 26417, "strap": 26418, "penter": 26419, "\u0120exams": 26420, "\u0120Ya": 26421, "\u0120159": 26422, "\u0120Decision": 26423, "\u0120ransom": 26424, "eteenth": 26425, "ensing": 26426, "213": 26427, "\u0120sunset": 26428, "404": 26429, "\u0120Rapid": 26430, "\u0120Hein": 26431, "\u0120Aboriginal": 26432, "\u0120organism": 26433, "\u0120Sever": 26434, "\u0120cla": 26435, "aji": 26436, "Simple": 26437, "\u0120Flavor": 26438, "\u0120Eval": 26439, "prus": 26440, "\u0120chorus": 26441, "DAY": 26442, "\u0120denounced": 26443, "\u0120biography": 26444, "\u0120Turnbull": 26445, "Recent": 26446, "Normal": 26447, "lections": 26448, "Word": 26449, "\u0120ferry": 26450, "\u0120Wagner": 26451, "hom": 26452, "Unit": 26453, "\u0120supermarket": 26454, "\u0120Sith": 26455, "\u0120nominees": 26456, "\u0120dictatorship": 26457, "iddler": 26458, "\u0120announces": 26459, "\u0120Them": 26460, "\u0120Neptune": 26461, "\u0120deity": 26462, "\u0120Yi": 26463, "\u0120monarch": 26464, "ARR": 26465, "\u0120invaded": 26466, "\u0120Hok": 26467, "untary": 26468, "Certain": 26469, "ega": 26470, "\u0120kidding": 26471, "\u0120Regulation": 26472, "\u0120tray": 26473, "\u0120photographers": 26474, "\u0120Arcane": 26475, "\u0120discharged": 26476, "\u0120evangelical": 26477, "\u0120interchange": 26478, "\u0120filmmaker": 26479, "\u0120Endless": 26480, "\u0120290": 26481, "\u0120Salvador": 26482, "ASY": 26483, "\u0120Signal": 26484, "\u0120wrath": 26485, "\u00e2\u013e": 26486, "lot": 26487, "'/": 26488, "\u0120projectile": 26489, "\u0120employing": 26490, "\u0120Interface": 26491, "191": 26492, "atellite": 26493, "\u0120Rath": 26494, "package": 26495, "\u0120indications": 26496, "Jason": 26497, "\u0120args": 26498, "\u0120GHz": 26499, "\u0120tilt": 26500, "nants": 26501, "won": 26502, "\u00e3\u0124\u00b5": 26503, "redd": 26504, "rescent": 26505, "\u0120Calendar": 26506, "\u0120modular": 26507, "\u0120assisting": 26508, "\u0120redeem": 26509, "\u0120Bean": 26510, "\u0120worsh": 26511, "\u0120decentralized": 26512, ")...": 26513, "377": 26514, "\u0120arrays": 26515, "\u0120accomplishments": 26516, "\u00ce\u00bf": 26517, "dot": 26518, "\u0120mutually": 26519, "\u0120obstruct": 26520, "\u0120misrepresent": 26521, "orest": 26522, "ionic": 26523, "ruce": 26524, "%;": 26525, "\u0120knowingly": 26526, "porting": 26527, "inently": 26528, "Ari": 26529, "\u0120Schultz": 26530, "Da": 26531, "\u0120Cere": 26532, "\u0120obsolete": 26533, "\u0127\u012d": 26534, "give": 26535, "\u0120bait": 26536, "\u0120enlarg": 26537, "Neill": 26538, "\u01201933": 26539, "\u0120reconsider": 26540, "\u0120Sergeant": 26541, "\u0120Diane": 26542, "\u0120Cogn": 26543, "\u0120Icon": 26544, "Position": 26545, "\u0120fost": 26546, "\u0120stirring": 26547, "seven": 26548, "\u0120SpaceX": 26549, "uggets": 26550, "\u0120medd": 26551, "Gal": 26552, "\u0120Sister": 26553, "Boy": 26554, "\u0120triggering": 26555, "Taking": 26556, "\u0120screams": 26557, "\u0120causal": 26558, "\u0120awaken": 26559, "Arm": 26560, "297": 26561, "\u0120dispatched": 26562, "\u0120FALSE": 26563, "\u0120organizational": 26564, "\u0120Tong": 26565, "\u0120dilemma": 26566, "demon": 26567, "Spl": 26568, "\u0120hooks": 26569, "uding": 26570, "\u0120validate": 26571, "\u0120potion": 26572, "\u0120claw": 26573, "\u0120burgl": 26574, "\u0120quir": 26575, "ACA": 26576, "\u0120Brennan": 26577, "\u0120durability": 26578, "\u0120bombings": 26579, "\u0120Window": 26580, "\u0120culprit": 26581, "325": 26582, "Therefore": 26583, "umbered": 26584, "performance": 26585, "warts": 26586, "\u0120enforcing": 26587, "\u0120Blow": 26588, "\u0120reprint": 26589, "ifax": 26590, "alpha": 26591, "\u0120sinister": 26592, "\u0120burger": 26593, "fighting": 26594, "Score": 26595, "\u0120Stones": 26596, "iem": 26597, "405": 26598, "chemy": 26599, "\u0120vinegar": 26600, "nom": 26601, "\u0120prevailing": 26602, "\u0120Latest": 26603, "\u00c2\u00b6": 26604, "\u0120ba": 26605, "\u0120Writer": 26606, "\u0120177": 26607, "\u0120Conway": 26608, "\u0120collects": 26609, "\u0120quantitative": 26610, "\u0120horrors": 26611, "ogens": 26612, "\u0120Slov": 26613, "\u0120lays": 26614, "haw": 26615, "\u0120Slash": 26616, "\u0120nightclub": 26617, "\u0120Davies": 26618, "\u0120bride": 26619, "\u0120Scarlet": 26620, "ymm": 26621, "\u0120Applications": 26622, "velength": 26623, "\u0120revival": 26624, "\u0120softly": 26625, "\u0120zoo": 26626, "itaire": 26627, "Cur": 26628, "\u0120electrom": 26629, "\u0120planting": 26630, "OTO": 26631, "\u0120Elements": 26632, "\u0120swallow": 26633, "porter": 26634, "\u0120laptops": 26635, "\u0120peanut": 26636, "\u0120lobbyists": 26637, "\u00ce\u00b2": 26638, "Panel": 26639, "\u0120Joan": 26640, "imil": 26641, "tnc": 26642, "\u0120resisted": 26643, "\u0120outwe": 26644, "\u0120retaining": 26645, "atri": 26646, "\u0120poorer": 26647, "\u0120Syrians": 26648, "\u0120Hammond": 26649, "\u0120weld": 26650, "uder": 26651, "topic": 26652, "\u0120TT": 26653, "ricia": 26654, "\u0120thieves": 26655, "Lic": 26656, "\u0120Gust": 26657, "\u0120Ways": 26658, "areth": 26659, "243": 26660, "\u0120broadcaster": 26661, "shield": 26662, "assium": 26663, "uble": 26664, "\u0120airstrikes": 26665, "onso": 26666, "\u0120pedal": 26667, "\u0120collectors": 26668, "\u0120Vander": 26669, "\u0120Mesa": 26670, "\u0120dictator": 26671, "\u0120dir": 26672, "enton": 26673, "cart": 26674, "score": 26675, "adder": 26676, "Cry": 26677, "\u0120ssh": 26678, "gger": 26679, "\u0120drunken": 26680, "\u0120GS": 26681, "\u0120Seat": 26682, "\u0120cornerback": 26683, "\u0120skipped": 26684, "\u0120Researchers": 26685, "\u0120Audi": 26686, "Reference": 26687, "\u0120haunted": 26688, "\u00c3\u00ab": 26689, "\u0120Clinic": 26690, "cz": 26691, "\u0120ps": 26692, "\u0120Paladin": 26693, "\u0120Recipe": 26694, "\u0120stigma": 26695, "oppy": 26696, "\u0120monkeys": 26697, "\u0120Hawk": 26698, "Sad": 26699, "\"/>": 26700, "\u0120Workshop": 26701, "\u0120Retail": 26702, "\u0120Avatar": 26703, "625": 26704, "Na": 26705, "\u0120VC": 26706, "\u0120Secure": 26707, "MY": 26708, "1988": 26709, "ossip": 26710, "\u0120prostate": 26711, "\u0120unden": 26712, "\u0120gamer": 26713, "\u0120Contents": 26714, "\u0120Warhammer": 26715, "\u0120Sentinel": 26716, "310": 26717, "\u0120segregation": 26718, "\u0120Flex": 26719, "\u0120MAY": 26720, "\u0120drills": 26721, "\u0120Drugs": 26722, "Islamic": 26723, "\u0120spur": 26724, "\u0120cafe": 26725, "\u0120imaginary": 26726, "\u0120guiding": 26727, "\u0120swings": 26728, "\u0120Theme": 26729, "oby": 26730, "\u0120nud": 26731, "\u0120begging": 26732, "\u0120strongh": 26733, "\u0120rejecting": 26734, "\u0120pedestrians": 26735, "\u0120Prospect": 26736, "Rare": 26737, "sle": 26738, "\u0120concessions": 26739, "\u0120Constitutional": 26740, "\u0120beams": 26741, "\u0120fibers": 26742, "poon": 26743, "\u0120instincts": 26744, "property": 26745, "\u0120BIG": 26746, "Sanders": 26747, "imates": 26748, "\u0120coating": 26749, "\u0120corpses": 26750, "\u0120TRUE": 26751, "checked": 26752, "\u0120166": 26753, "Ash": 26754, "\u0120JS": 26755, "\u0120Fiction": 26756, "\u0120communal": 26757, "\u0120energetic": 26758, "oooooooo": 26759, "\u0120nowadays": 26760, "ILD": 26761, "ibo": 26762, "\u0120SUV": 26763, "Ren": 26764, "\u0120dwelling": 26765, "Silver": 26766, "\u0120tally": 26767, "\u0120Moving": 26768, "\u0120coward": 26769, "\u0120generals": 26770, "\u0120horns": 26771, "\u0120circulated": 26772, "\u0120robbed": 26773, "\u0120Unlimited": 26774, "\u0120harassed": 26775, "\u0120inhibit": 26776, "\u0120composer": 26777, "\u0120Spotify": 26778, "\u0120spreads": 26779, "364": 26780, "\u0120suicidal": 26781, "\u0120noises": 26782, "\u0120Stur": 26783, "\u0120saga": 26784, "\u0120Kag": 26785, "iso": 26786, "\u0120theoretically": 26787, "Money": 26788, "\u0120similarity": 26789, "\u0120sliced": 26790, "utils": 26791, "inges": 26792, "\"-": 26793, "\u0120anth": 26794, "\u0120imped": 26795, "Module": 26796, "Throughout": 26797, "\u0120menus": 26798, "committee": 26799, "andi": 26800, "obj": 26801, "inav": 26802, "fired": 26803, "\u0120Abdullah": 26804, "\u0120undead": 26805, "\u0120fonts": 26806, "Hold": 26807, "ENG": 26808, "\u0120sustainability": 26809, "\u0120flick": 26810, "\u0120razor": 26811, "\u0120Fest": 26812, "\u0120Characters": 26813, "\u0120wording": 26814, "\u0120populist": 26815, "\u0120criticizing": 26816, "\u0120muse": 26817, "vine": 26818, "\u0120cardboard": 26819, "\u0120kindly": 26820, "\u0120fringe": 26821, "\u0120Theft": 26822, "icultural": 26823, "\u0120governors": 26824, "\u0120\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd": 26825, "\u0120163": 26826, "\u0120timeout": 26827, "\u0120Auth": 26828, "Children": 26829, "AU": 26830, "\u0120redemption": 26831, "\u0120Alger": 26832, "\u01201914": 26833, "\u0120waved": 26834, "\u0120astronauts": 26835, "ograms": 26836, "\u0120swamp": 26837, "\u0120Finnish": 26838, "\u0120candle": 26839, "\u0120tonnes": 26840, "utm": 26841, "\u0120ray": 26842, "\u0120spun": 26843, "\u0120fearful": 26844, "articles": 26845, "\u0120caus": 26846, "orically": 26847, "\u0120Requires": 26848, "\u0120Gol": 26849, "\u0120pope": 26850, "\u0120inaugural": 26851, "\u0120gle": 26852, "ADA": 26853, "\u0120ISIL": 26854, "\u0120Offensive": 26855, "\u0120watchdog": 26856, "\u0120balcon": 26857, "entity": 26858, "\u0120Hoo": 26859, "\u0120gallon": 26860, "ACC": 26861, "\u0120doubling": 26862, "\u0120implication": 26863, "\u0120Sight": 26864, "\u0120doctr": 26865, "-------": 26866, "\u0120\\\\": 26867, "\u0120malt": 26868, "Roll": 26869, "\u0120\u00e2\u012b\u00a5": 26870, "\u0120recap": 26871, "adding": 26872, "uces": 26873, "\u0120Bend": 26874, "figure": 26875, "\u0120turkey": 26876, "\u0120societal": 26877, "\u0120Tickets": 26878, "\u0120commercially": 26879, "\u0120spicy": 26880, "\u0120216": 26881, "\u0120Ramp": 26882, "\u0120superiority": 26883, "\u00c3\u00af": 26884, "\u0120Tracker": 26885, "Carl": 26886, "\u0120Coy": 26887, "\u0120Patriot": 26888, "\u0120consulted": 26889, "\u0120listings": 26890, "\u0120slew": 26891, "reenshot": 26892, "\u0120Gone": 26893, "\u0120[...]": 26894, "309": 26895, "\u0120hottest": 26896, "\u00d8\u00b1": 26897, "\u0120rocky": 26898, "\u0120Diaz": 26899, "\u0120massage": 26900, "\u0120paraly": 26901, "\u0120pony": 26902, "Az": 26903, "\u0120cartridge": 26904, "\u0120NZ": 26905, "\u0120snack": 26906, "\u0120Lamar": 26907, "plement": 26908, "\u0120Leslie": 26909, "\u0120mater": 26910, "\u0120snipp": 26911, "246": 26912, "\u0120jointly": 26913, "\u0120Brisbane": 26914, "\u0120iPod": 26915, "\u0120pumping": 26916, "\u0120goat": 26917, "\u0120Sharon": 26918, "ealing": 26919, "\u0120coron": 26920, "\u0120anomal": 26921, "rahim": 26922, "\u0120Connection": 26923, "\u0120sculpture": 26924, "\u0120scheduling": 26925, "\u0120Daddy": 26926, "athing": 26927, "\u0120eyebrows": 26928, "\u0120curved": 26929, "\u0120sentiments": 26930, "\u0120drafting": 26931, "Drop": 26932, "([": 26933, "\u0120nominal": 26934, "\u0120Leadership": 26935, "\u0120Grow": 26936, "\u0120176": 26937, "\u0120constructive": 26938, "ivation": 26939, "\u0120corrupted": 26940, "gerald": 26941, "\u0120Cros": 26942, "\u0120Chester": 26943, "\u0120Lap": 26944, "\u00e3\u0123\u00aa": 26945, "OTH": 26946, "DATA": 26947, "\u0120almond": 26948, "probably": 26949, "Imp": 26950, "\u0120feast": 26951, "\u0120Warcraft": 26952, "Flor": 26953, "\u0120checkpoint": 26954, "\u0120transcription": 26955, "\u0120204": 26956, "\u0120tweaks": 26957, "\u0120relieve": 26958, "Science": 26959, "\u0120performer": 26960, "Zone": 26961, "\u0120turmoil": 26962, "igated": 26963, "hibit": 26964, "\u0120Cafe": 26965, "themed": 26966, "\u0120fluor": 26967, "bench": 26968, "\u0120decom": 26969, "\u0120Unt": 26970, "\u0120Barrett": 26971, "\u0120Facts": 26972, "\u0120tasting": 26973, "\u0120PTSD": 26974, "\u0120Seal": 26975, "\u0120Judaism": 26976, "\u0120Dynamic": 26977, "\u0120Cors": 26978, "Ve": 26979, "\u0120Ming": 26980, "\u0120Transform": 26981, "von": 26982, "\u0120Defenders": 26983, "\u0120Tactical": 26984, "\u0120Von": 26985, "\u0120Univers": 26986, "\u0120distorted": 26987, "\u0120Breath": 26988, "?'\"": 26989, "\u0120agon": 26990, "\u0120Deadly": 26991, "\u0120lan": 26992, "\u0120Cycle": 26993, "orned": 26994, "\u0120reliably": 26995, "\u0120glor": 26996, "\u0120Monkey": 26997, "\u00e3\u0125\u00a1": 26998, "\u0120adren": 26999, "\u0120microwave": 27000, "\u0120Alban": 27001, "ircraft": 27002, "digit": 27003, "smart": 27004, "\u0120Dread": 27005, "\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af\u00c2\u00af": 27006, "{{": 27007, "\u0120Rochester": 27008, "\u0120simplified": 27009, "\u0120inflicted": 27010, "\u0120takeover": 27011, "\u0120yourselves": 27012, "aditional": 27013, "\u0120muscular": 27014, "KS": 27015, "\u0120ingen": 27016, "Tax": 27017, "\u0120Feature": 27018, "277": 27019, "\u0120cruc": 27020, "\u0120crate": 27021, "\u0120unidentified": 27022, "\u0120acclaimed": 27023, "\u0120Manga": 27024, "\u0120Frances": 27025, "\u0120Nepal": 27026, "\u0120Gerald": 27027, "\u0120Kuwait": 27028, "\u0120slain": 27029, "\u0120Heb": 27030, "\u0120Goku": 27031, "\u00e3\u0123\u00ae\u00e6": 27032, "286": 27033, "Mrs": 27034, "\u0120Cody": 27035, "\u0120Sanctuary": 27036, "016": 27037, "\u0120dismant": 27038, "\u0120dataset": 27039, "\u0120Hond": 27040, "buck": 27041, "\u0120Patterson": 27042, "\u0120palette": 27043, "\u0120GD": 27044, "icol": 27045, "\u0120Lodge": 27046, "\u0120planetary": 27047, "akin": 27048, "\u0120Registered": 27049, "abwe": 27050, "\u0120Petersburg": 27051, "\u0120hailed": 27052, "\u0120Piece": 27053, "Sche": 27054, "\u0120DOJ": 27055, "\u0120enumer": 27056, "181": 27057, "\u0120Observer": 27058, "\u0120Bold": 27059, "founded": 27060, "commerce": 27061, "\u0120exploits": 27062, "\u0120Finding": 27063, "URN": 27064, "\u0120Sne": 27065, "\u0120Acid": 27066, "ayette": 27067, "\u0120Values": 27068, "\u0120drastic": 27069, "\u0120architectural": 27070, "\u0120\".": 27071, "\u00d7\u0137": 27072, "umped": 27073, "\u0120wrapping": 27074, "\u0120widow": 27075, "\u0120Slayer": 27076, "lace": 27077, "once": 27078, "Germany": 27079, "avoid": 27080, "\u0120temples": 27081, "PAR": 27082, "\u00c3\u00b4": 27083, "\u0120Lucifer": 27084, "\u0120Flickr": 27085, "lov": 27086, "forces": 27087, "\u0120scouting": 27088, "\u0120louder": 27089, "tesy": 27090, "\u0120beforehand": 27091, "\u00c4\u0135": 27092, "\u0120Neon": 27093, "\u0120Wol": 27094, "\u0120Typically": 27095, "\u0120Politico": 27096, "-+-+": 27097, "\u0120builder": 27098, "\u0120derive": 27099, "Kill": 27100, "\u0120poker": 27101, "\u0120ambiguous": 27102, "\u0120lifts": 27103, "\u0120cyt": 27104, "\u0120ribs": 27105, "oodle": 27106, "\u0120Sounds": 27107, "hair": 27108, "\u0120Syndrome": 27109, "tf": 27110, "\u0120proportional": 27111, "uid": 27112, "\u0120pertaining": 27113, "\u0120Kindle": 27114, "\u0120Negro": 27115, "\u0120reiterated": 27116, "\u0120Tonight": 27117, "oths": 27118, "\u0120Cornell": 27119, "\u0120owing": 27120, "\u0120208": 27121, "elfare": 27122, "ocating": 27123, "\u0120Birds": 27124, "Subscribe": 27125, "\u0120essays": 27126, "\u0120burdens": 27127, "\u0120illustrations": 27128, "arious": 27129, "ERAL": 27130, "\u0120Calcul": 27131, "\u0120xen": 27132, "\u0120LinkedIn": 27133, "\u0120Jung": 27134, "\u0120redesign": 27135, "Connor": 27136, "296": 27137, "\u0120reversal": 27138, "\u0120Adelaide": 27139, "\u0120LL": 27140, "\u0120sinking": 27141, "\u0120gum": 27142, "USH": 27143, "capt": 27144, "\u0120Grimm": 27145, "\u0120footsteps": 27146, "\u0120CBD": 27147, "ispers": 27148, "\u0120prose": 27149, "Wednesday": 27150, "\u0120Movies": 27151, "edin": 27152, "\u0120overturned": 27153, "\u0120contentious": 27154, "USB": 27155, "~~~~~~~~~~~~~~~~": 27156, "\u0120Copper": 27157, "\u0120pointless": 27158, "NV": 27159, "values": 27160, "olphin": 27161, "dain": 27162, "\u0120deposited": 27163, "\u0120GW": 27164, "\u0120preceded": 27165, "\u0120Cla": 27166, "\u0120Golem": 27167, "\u0120Nim": 27168, "\u0120\u00ce\u00b2": 27169, "\u0120Engineers": 27170, "middle": 27171, "\u0120flatt": 27172, "operative": 27173, "\u0120councils": 27174, "imbabwe": 27175, "elin": 27176, "\u0120stressful": 27177, "\u0120LD": 27178, "\u0120resh": 27179, "lake": 27180, "\u0120wheelchair": 27181, "\u0120Alternative": 27182, "\u0120optimize": 27183, "operation": 27184, "\u0120peek": 27185, "\u0120oneself": 27186, "igil": 27187, "\u0120transitions": 27188, "opathy": 27189, "blank": 27190, "\u0120169": 27191, "171": 27192, "________________________________________________________________": 27193, "\u0120laundering": 27194, "Enc": 27195, "\u0120DEC": 27196, "\u0120workouts": 27197, "\u0120spikes": 27198, "\u0120dinosaurs": 27199, "\u0120discriminatory": 27200, "Pool": 27201, "Rather": 27202, "385": 27203, "RNA": 27204, "testers": 27205, "eto": 27206, "\u0120Identity": 27207, "\u0120vein": 27208, "\u0120Burton": 27209, "\u0120arcade": 27210, "420": 27211, "Ultimately": 27212, "\u0120Sadly": 27213, "\u00c3\u00b0": 27214, "pill": 27215, "\u0120cubic": 27216, "\u0120Spectrum": 27217, "these": 27218, "states": 27219, "\u0120unofficial": 27220, "hawks": 27221, "\u0120EVERY": 27222, "\u0120rainbow": 27223, "\u0120incarceration": 27224, "anding": 27225, "\u0120syll": 27226, "\u0120Everton": 27227, "\u0120179": 27228, "\u0120Serbia": 27229, "\u0120189": 27230, "meter": 27231, "\u0120Mickey": 27232, "\u0120antiqu": 27233, "\u0120factual": 27234, "neck": 27235, "\u0120Nare": 27236, "norm": 27237, "must": 27238, "\u0120highways": 27239, "\u0120glam": 27240, "\u0120dividing": 27241, "\u0120Squadron": 27242, "\u0120Martha": 27243, "\u0120births": 27244, "Cover": 27245, "////////////////": 27246, "\u0120Wong": 27247, "Phot": 27248, "\u0120ALS": 27249, "rio": 27250, "\u0120Nonetheless": 27251, "\u0120Lemon": 27252, "\u0120206": 27253, "\u0120EE": 27254, "\u0120derivative": 27255, "\u0120WWII": 27256, "vote": 27257, "\u0120therein": 27258, "\u0120separating": 27259, "446": 27260, "sync": 27261, "\u0120Streets": 27262, "\u0120ratt": 27263, "\u0120municipality": 27264, "\u0120Shortly": 27265, "\u0120monk": 27266, "),\"": 27267, "\u0120scrub": 27268, "\u0120operatives": 27269, "Neither": 27270, "Place": 27271, "\u0120Limit": 27272, "Female": 27273, "\u0120Actor": 27274, "Character": 27275, "\u0120constituted": 27276, "357": 27277, "\u0120protested": 27278, "\u0120Straw": 27279, "\u0120Height": 27280, "ilda": 27281, "\u0120Typh": 27282, "\u0120floods": 27283, "\u0120cosmetic": 27284, "WAY": 27285, "perture": 27286, "upon": 27287, "tons": 27288, "essing": 27289, "\u0120Pocket": 27290, "\u0120rooft": 27291, "\u0120Caucas": 27292, "\u0120antidepress": 27293, "\u0120incompatible": 27294, "ECD": 27295, "\u0120opera": 27296, "\u0120Contest": 27297, "\u0120generators": 27298, "lime": 27299, "Defense": 27300, "1987": 27301, "forum": 27302, "\u0120savage": 27303, "\u0120Hungarian": 27304, "nz": 27305, "\u0120metallic": 27306, "\u0120expelled": 27307, "\u0120residency": 27308, "\u0120dresses": 27309, "666": 27310, "\u0120Clement": 27311, "fires": 27312, "Category": 27313, "\u0120geek": 27314, "alis": 27315, "\u0120cemetery": 27316, "educated": 27317, "\u0120crawl": 27318, "\u0120Unable": 27319, "\u0120Tyson": 27320, "akis": 27321, "\u0120pardon": 27322, "\u0120Wra": 27323, "\u0120strengthened": 27324, "\u0120Fors": 27325, "335": 27326, "\u0120HC": 27327, "\u0120Mond": 27328, "\u0120visuals": 27329, "\u0120Beatles": 27330, "ettlement": 27331, "\u0120\u00ef": 27332, "gro": 27333, "\u0120bash": 27334, "\u0120poorest": 27335, "\u0120excel": 27336, "\u0120aspirations": 27337, "\u0120Municip": 27338, "ensible": 27339, "\u0120ceremonies": 27340, "\u0120intimidation": 27341, "\u0120CONTR": 27342, "beck": 27343, "\u0120Kap": 27344, "asu": 27345, "\u0120trademarks": 27346, "\u0120Sew": 27347, "\u0120Competition": 27348, "network": 27349, "\u0120Arri": 27350, "\u0120Tet": 27351, "Roaming": 27352, "WC": 27353, "Dat": 27354, "\u0120sob": 27355, "\u0120pairing": 27356, "\u0120overdose": 27357, "SAY": 27358, "aber": 27359, "\u0120revolt": 27360, "\u0120Fah": 27361, "acting": 27362, "eq": 27363, "estation": 27364, "Fight": 27365, "\u0120Marks": 27366, "273": 27367, "\u0120178": 27368, "Raw": 27369, "\u00e3\u0123\u012d": 27370, "349": 27371, "blocks": 27372, "\u0120verge": 27373, "estine": 27374, "\u0120Podesta": 27375, "\u0120invasive": 27376, "\u0120profoundly": 27377, "\u0120Ao": 27378, "each": 27379, "\u0120lest": 27380, "interpret": 27381, "\u0120shrinking": 27382, "\u0120errone": 27383, "\u0120chees": 27384, "lys": 27385, "\u0120Ivy": 27386, "\u0120Directory": 27387, "\u0120hinted": 27388, "VICE": 27389, "\u0120contacting": 27390, "\u0120Gent": 27391, "hei": 27392, "\u0120labeling": 27393, "\u0120mercury": 27394, "\u0120Lite": 27395, "\u0120expires": 27396, "\u0120destabil": 27397, "ritis": 27398, "cu": 27399, "\u0120feathers": 27400, "\u0120steer": 27401, "\u0120programmed": 27402, "\u0120Vader": 27403, "Going": 27404, "\u0120Elim": 27405, "\u0120yo": 27406, "\u0120Miche": 27407, "\u0120203": 27408, "\u0120sleeves": 27409, "\u0120bully": 27410, "\u0120Humans": 27411, "368": 27412, "\u0120compress": 27413, "\u0120Banner": 27414, "ARS": 27415, "\u0120awhile": 27416, "\u0120calib": 27417, "\u0120sponsorship": 27418, "\u0120Difficulty": 27419, "\u0120Papers": 27420, "\u0120identifier": 27421, "}.": 27422, "\u0120yog": 27423, "\u0120Shia": 27424, "\u0120cleanup": 27425, "\u0120vibe": 27426, "introdu": 27427, "imming": 27428, "Australia": 27429, "\u0120outlines": 27430, "\u0120Youtube": 27431, "train": 27432, "\u0120Makes": 27433, "\u0120deported": 27434, "\u0120centr": 27435, "\u0120Dug": 27436, "\u0120Boulder": 27437, "\u0120Buffy": 27438, "\u0120injunction": 27439, "\u0120Harley": 27440, "\u0120Groups": 27441, "\u0120Dumbledore": 27442, "\u0120Clara": 27443, "\u0120\"-": 27444, "\u0120sacrificed": 27445, "eph": 27446, "Shadow": 27447, "ibling": 27448, "\u0120freelance": 27449, "\u0120evidently": 27450, "phal": 27451, "\u0120retains": 27452, "Mir": 27453, "\u0120finite": 27454, "dar": 27455, "\u0120Cous": 27456, "\u0120repaired": 27457, "\u0120periodic": 27458, "\u0120championships": 27459, "\u0120asteroid": 27460, "blind": 27461, "\u0120expressly": 27462, "\u0120Astros": 27463, "\u0120scaled": 27464, "\u0120geographical": 27465, "\u0120Rapids": 27466, "Enjoy": 27467, "\u0120elastic": 27468, "\u0120Mohamed": 27469, "Market": 27470, "begin": 27471, "\u0120discovers": 27472, "\u0120telecommunications": 27473, "\u0120scanner": 27474, "\u0120enlarge": 27475, "\u0120sharks": 27476, "\u0120psychedel": 27477, "\u0120Rouge": 27478, "\u0120snapshot": 27479, "isine": 27480, "XP": 27481, "\u0120pesticides": 27482, "\u0120LSD": 27483, "\u0120Distribution": 27484, "really": 27485, "\u0120degradation": 27486, "\u0120disguise": 27487, "\u0120biom": 27488, "\u0120EXT": 27489, "\u0120equations": 27490, "\u0120hazards": 27491, "\u0120Compared": 27492, ")*": 27493, "\u0120virtues": 27494, "\u0120elders": 27495, "\u0120enhancing": 27496, "\u0120Across": 27497, "eros": 27498, "angling": 27499, "\u0120combust": 27500, "ucci": 27501, "\u0120concussion": 27502, "\u0120contraception": 27503, "\u0120Kang": 27504, "\u0120expresses": 27505, "\u0120aux": 27506, "\u0120Pione": 27507, "\u0120exhibits": 27508, "Debug": 27509, "OTAL": 27510, "\u0120Already": 27511, "\u0120Wheeler": 27512, "\u0120expands": 27513, "?:": 27514, "\u0120reconciliation": 27515, "\u0120pirates": 27516, "\u0120purse": 27517, "\u0120discourage": 27518, "\u0120spectacle": 27519, "Rank": 27520, "\u0120wraps": 27521, "\u0120Thought": 27522, "\u0120impending": 27523, "Opp": 27524, "\u0120Anglo": 27525, "\u0120EUR": 27526, "\u0120screwed": 27527, "retched": 27528, "\u0120encouragement": 27529, "models": 27530, "\u0120confuse": 27531, "mmm": 27532, "\u0120Vitamin": 27533, "\u00e2\u0138\u0133\u00e2\u0138\u0133": 27534, "Cru": 27535, "\u0120knights": 27536, "\u0120discard": 27537, "\u0120bishops": 27538, "\u0120Wear": 27539, "\u0120Garrett": 27540, "kan": 27541, "\u00e3\u0125\u0141": 27542, "\u0120masculine": 27543, "capital": 27544, "\u0120Aus": 27545, "\u0120fatally": 27546, "thanks": 27547, "\u0120AU": 27548, "\u0120Gut": 27549, "1200": 27550, "\u012000000000": 27551, "\u0120surrog": 27552, "\u0120BIOS": 27553, "raits": 27554, "\u0120Watts": 27555, "\u0120resurrection": 27556, "\u0120Electoral": 27557, "\u0120Tips": 27558, "4000": 27559, "\u0120nutrient": 27560, "\u0120depicting": 27561, "\u0120sprink": 27562, "\u0120muff": 27563, "\u0120LIM": 27564, "\u0120Sample": 27565, "psc": 27566, "ibi": 27567, "generated": 27568, "\u0120specimens": 27569, "\u0120dissatisf": 27570, "\u0120tailored": 27571, "\u0120holdings": 27572, "\u0120Monthly": 27573, "\u0120Eat": 27574, "poons": 27575, "\u0120nec": 27576, "\u0120Cage": 27577, "\u0120Lotus": 27578, "\u0120Lantern": 27579, "\u0120frontier": 27580, "\u0120pensions": 27581, "\u0120joked": 27582, "\u0120Hardy": 27583, "=-=-=-=-": 27584, "rade": 27585, "UID": 27586, "\u0120rails": 27587, "\u0120emit": 27588, "\u0120slate": 27589, "\u0120smug": 27590, "\u0120spit": 27591, "\u0120Calls": 27592, "\u0120Jacobs": 27593, "feat": 27594, "\u0120UE": 27595, "\u0120restruct": 27596, "\u0120regeneration": 27597, "\u0120energies": 27598, "\u0120Connor": 27599, "OHN": 27600, "\u0120Cheese": 27601, "\u0120ger": 27602, "\u0120resurrect": 27603, "management": 27604, "NW": 27605, "\u0120presently": 27606, "\u0120Bruins": 27607, "Member": 27608, "\u0120Mang": 27609, "idan": 27610, "\u0120boosting": 27611, "wyn": 27612, "+.": 27613, "requisite": 27614, "\u0120NYPD": 27615, "\u0120Megan": 27616, "\u0120Conditions": 27617, "\u0120pics": 27618, "nesium": 27619, "\u0120Rash": 27620, "\u0120174": 27621, "\u0120Ducks": 27622, "\u0120embro": 27623, "zu": 27624, "onian": 27625, "religious": 27626, "\u0120craz": 27627, "\u0120ACA": 27628, "\u0120Zucker": 27629, "EMA": 27630, "\u0120Pros": 27631, "Weapon": 27632, "\u0120Knox": 27633, "\u0120Arduino": 27634, "\u0120stove": 27635, "\u0120heavens": 27636, "\u0120Purchase": 27637, "\u0120herd": 27638, "\u0120fundraiser": 27639, "Digital": 27640, "5000": 27641, "\u0120proponents": 27642, "/\u00e2\u0122\u012d": 27643, "\u0120jelly": 27644, "\u0120Visa": 27645, "\u0120monks": 27646, "\u0120advancement": 27647, "\u0120Wer": 27648, "\u0120187": 27649, "eus": 27650, "ertility": 27651, "\u0120fetal": 27652, "\u01201936": 27653, "Lo": 27654, "\u0120outfits": 27655, "\u0120staircase": 27656, "bomb": 27657, "\u0120customized": 27658, "clair": 27659, "Tree": 27660, "\u0120mapped": 27661, "\u0120Considering": 27662, "\u0120Torres": 27663, "\u0120methyl": 27664, "\u0120approximate": 27665, "\u0120doom": 27666, "\u0120Hansen": 27667, "\u0120crossover": 27668, "\u0120standalone": 27669, "\u00e4\u00bc": 27670, "\u0120invites": 27671, "\u0120graveyard": 27672, "\u0120hp": 27673, "DonaldTrump": 27674, "\u0120escort": 27675, "Gar": 27676, "\u0120predecessors": 27677, "\u0120hay": 27678, "\u0120enzyme": 27679, "\u0120Straight": 27680, "visors": 27681, "Ing": 27682, "aneously": 27683, "\u0120Applied": 27684, "\u0120fec": 27685, "\u0120Durant": 27686, "\u0120outspoken": 27687, "orb": 27688, "\u0120zeal": 27689, "\u0120disgrace": 27690, "').": 27691, "\u0120Cheng": 27692, "289": 27693, "\u0120Rena": 27694, "\u0120Suicide": 27695, "294": 27696, "\u0120outraged": 27697, "\u0120Newman": 27698, "\u0120Nvidia": 27699, "\u0120Aber": 27700, "\u0120Bers": 27701, "\u0120recreation": 27702, "Window": 27703, "\u0120DP": 27704, "xe": 27705, "\u0120pedoph": 27706, "\u0120fallout": 27707, "amboo": 27708, "\u0120presentations": 27709, "\u0120Apps": 27710, "\u0120html": 27711, "345": 27712, "\u0120XXX": 27713, "\u0120rubbing": 27714, "\u0120Leather": 27715, "\u0120humidity": 27716, "seys": 27717, "established": 27718, "\u0120Units": 27719, "646": 27720, "\u0120respectable": 27721, "Auto": 27722, "\u0120thriving": 27723, "\u0120Innovation": 27724, "angs": 27725, "Extra": 27726, "regulation": 27727, "298": 27728, "pick": 27729, "Examples": 27730, "\u0120CJ": 27731, "Attack": 27732, "\u0120dracon": 27733, "LT": 27734, "\u0120sticker": 27735, "rers": 27736, "\u0120sunny": 27737, "Iss": 27738, "regulated": 27739, "dim": 27740, "\u0120Abstract": 27741, "\u0120husbands": 27742, "Office": 27743, "omination": 27744, "itars": 27745, "ANGE": 27746, "ascal": 27747, "\u0120Kris": 27748, "\u0120Infantry": 27749, "\u0120malf": 27750, "\u0120Athe": 27751, "\u0120Rally": 27752, "balanced": 27753, "........................": 27754, "OUP": 27755, "\u0120molecule": 27756, "metics": 27757, "\u0120Split": 27758, "\u0120Instructions": 27759, "\u0120Nights": 27760, "cards": 27761, "\u0120tug": 27762, "\u0120cone": 27763, "\u00e5\u0143": 27764, "\u0120tx": 27765, "\u0120Discussion": 27766, "\u0120catastrophe": 27767, "ppe": 27768, "gio": 27769, "\u0120communism": 27770, "\u0120halted": 27771, "\u0120Guant": 27772, "clean": 27773, "\u0120Sched": 27774, "\u0120Kanye": 27775, "\u0120wander": 27776, "\u0120Seriously": 27777, "\u0120188": 27778, "ennial": 27779, "follow": 27780, "productive": 27781, "\u0120Flow": 27782, "\u0120Sail": 27783, "\u0120craw": 27784, "\u0120simulations": 27785, "oru": 27786, "angles": 27787, "\u0120Nolan": 27788, "\u0120menstru": 27789, "470": 27790, "\u0120207": 27791, "aja": 27792, "\u0120casually": 27793, "boarding": 27794, "\u0120222": 27795, "ovy": 27796, "\u0120Numbers": 27797, "umat": 27798, "OE": 27799, "287": 27800, "\u0120Clemson": 27801, "\u0120certs": 27802, "\u0120slid": 27803, "\u0120Tribe": 27804, "\u0120toast": 27805, "\u0120fortunes": 27806, "\u0120fals": 27807, "\u0120Committees": 27808, "\u0120gp": 27809, "\u0120fiery": 27810, "\u0120Nets": 27811, "\u0120Anime": 27812, "Package": 27813, "\u0120Compare": 27814, "laughter": 27815, "infect": 27816, "\u0120atrocities": 27817, "\u0120justices": 27818, "\u0120insults": 27819, "\u0120Vernon": 27820, "\u0120shaken": 27821, "\u0120persona": 27822, "estamp": 27823, "367": 27824, "brain": 27825, "\u0120experimenting": 27826, "Ken": 27827, "\u0120Electronics": 27828, "\u0120161": 27829, "domain": 27830, "\u0120graphical": 27831, "bishop": 27832, "\u0120whopping": 27833, "\u0120Evangel": 27834, "\u0120advertisers": 27835, "\u0120Spear": 27836, "\u0120bids": 27837, "\u0120destroys": 27838, "utz": 27839, "\u0120undersc": 27840, "\u0120ADD": 27841, "\u0120ants": 27842, "\u0120Cum": 27843, "ipples": 27844, "\u0120Fill": 27845, "\u0120glanced": 27846, "\u0120indicted": 27847, "\u0120Eff": 27848, "\u0120miscon": 27849, "\u0120Desktop": 27850, "\u0120abide": 27851, "\u00e3\u0125\u0122": 27852, "\u0120Io": 27853, "\u0120Coul": 27854, "\u0120capsule": 27855, "\u0120Chrys": 27856, "MON": 27857, "\u0120undes": 27858, "\u0120IRA": 27859, "\u0120citation": 27860, "\u0120dictate": 27861, "\u0120Networks": 27862, "\u0120Conflict": 27863, "\u0120Stuff": 27864, "xa": 27865, "isec": 27866, "\u0120Chemistry": 27867, "\u0120quarterly": 27868, "Williams": 27869, "anan": 27870, "Opt": 27871, "\u0120Alexandria": 27872, "outheastern": 27873, "\u0120Springfield": 27874, "\u0120Blacks": 27875, "\u0120geography": 27876, "242": 27877, "\u0120utmost": 27878, "\u0120Exxon": 27879, "abouts": 27880, "EVA": 27881, "\u0120Enable": 27882, "\u0120Barr": 27883, "\u0120disagreed": 27884, "\u0120Cyprus": 27885, "\u0120dementia": 27886, "\u0120labs": 27887, "\u0120ubiquitous": 27888, "\u0120LOVE": 27889, "\u0120consolidated": 27890, "sr": 27891, "\u0120creamy": 27892, "\u0120Timber": 27893, "Regardless": 27894, "\u0120Certificate": 27895, "\u0120\"...": 27896, "ogenous": 27897, "Captain": 27898, "\u0120insulting": 27899, "\u0120Soros": 27900, "\u0120Instr": 27901, "\u0120Bulgaria": 27902, "better": 27903, "\u0120sucking": 27904, "\u0120Davidson": 27905, "atz": 27906, "\u0120collateral": 27907, "gif": 27908, "\u0120plagued": 27909, "\u0120Cancel": 27910, "\u0120Gardner": 27911, "RB": 27912, "\u0120sixteen": 27913, "Remove": 27914, "uristic": 27915, "cook": 27916, "Rod": 27917, "\u0120comprising": 27918, "fle": 27919, ")\u00e2\u0122\u0136": 27920, "\u0120Viking": 27921, "growth": 27922, "agonal": 27923, "\u0120srf": 27924, "afety": 27925, "mot": 27926, "Nearly": 27927, "stown": 27928, "\u0120Factor": 27929, "\u0120automobile": 27930, "\u0120procedural": 27931, "mask": 27932, "ampires": 27933, "\u0120disappears": 27934, "jab": 27935, "315": 27936, "\u01201951": 27937, "needed": 27938, "\u0120daring": 27939, "leader": 27940, "\u0120podium": 27941, "\u0120unhealthy": 27942, "\u0120mund": 27943, "\u0120pyramid": 27944, "ocre": 27945, "\u0120kissed": 27946, "\u0120dreamed": 27947, "\u0120Fantastic": 27948, "\u0120Gly": 27949, "\u00e5\u012c": 27950, "\u0120greatness": 27951, "\u0120spices": 27952, "\u0120metropolitan": 27953, "\u0120compuls": 27954, "iets": 27955, "1016": 27956, "\u0120Sham": 27957, "\u0120Pyr": 27958, "flies": 27959, "\u0120Midnight": 27960, "\u0120swallowed": 27961, "\u0120genres": 27962, "\u0120Lucky": 27963, "\u0120Rewards": 27964, "\u0120dispatch": 27965, "\u0120IPA": 27966, "\u0120Apply": 27967, "\u0120aven": 27968, "alities": 27969, "312": 27970, "things": 27971, "\u0120().": 27972, "\u0120mates": 27973, "\u0120Sz": 27974, "\u0120COP": 27975, "olate": 27976, "OFF": 27977, "\u0120recharge": 27978, "caps": 27979, "\u0120Yorker": 27980, "icone": 27981, "\u0120galaxies": 27982, "ileaks": 27983, "Dave": 27984, "\u0120Puzz": 27985, "\u0120Celtic": 27986, "\u0120AFC": 27987, "276": 27988, "\u0120Sons": 27989, "\u0120affirmative": 27990, "Hor": 27991, "\u0120tutorials": 27992, "\u0120CITY": 27993, "\u0120Rosa": 27994, "\u0120Extension": 27995, "Series": 27996, "\u0120fats": 27997, "\u0120rab": 27998, "lis": 27999, "\u0120unic": 28000, "\u0120eve": 28001, "\u0120Spin": 28002, "\u0120adulthood": 28003, "typ": 28004, "\u0120sectarian": 28005, "\u0120checkout": 28006, "\u0120Cycl": 28007, "Single": 28008, "\u0120martyr": 28009, "\u0120chilling": 28010, "888": 28011, "oufl": 28012, "\u0120];": 28013, "\u0120congestion": 28014, "mk": 28015, "\u0120Whereas": 28016, "\u01201938": 28017, "urrencies": 28018, "erion": 28019, "\u0120boast": 28020, "\u0120Patients": 28021, "\u0120chap": 28022, "\u0120BD": 28023, "realDonaldTrump": 28024, "\u0120examines": 28025, "hov": 28026, "\u0120startling": 28027, "\u0120Babylon": 28028, "wid": 28029, "omew": 28030, "brance": 28031, "\u0120Odyssey": 28032, "wig": 28033, "\u0120torch": 28034, "\u0120Vox": 28035, "\u0120Moz": 28036, "\u0120Troll": 28037, "\u0120Ans": 28038, "Similarly": 28039, "\u0120Ful": 28040, "006": 28041, "Unless": 28042, "\u0120Alone": 28043, "stead": 28044, "\u0120Publisher": 28045, "rights": 28046, "tu": 28047, "\u0120Doesn": 28048, "\u0120professionally": 28049, "\u0120clo": 28050, "icz": 28051, "\u0120steals": 28052, "\u0120\u00e1": 28053, "1986": 28054, "\u0120sturdy": 28055, "\u0120Johann": 28056, "\u0120medals": 28057, "\u0120filings": 28058, "\u0120Fraser": 28059, "done": 28060, "\u0120multinational": 28061, "\u0120feder": 28062, "\u0120worthless": 28063, "\u0120pest": 28064, "Yesterday": 28065, "ankind": 28066, "\u0120gays": 28067, "\u0120borne": 28068, "\u0120POS": 28069, "Picture": 28070, "\u0120percentages": 28071, "251": 28072, "rame": 28073, "\u0120potions": 28074, "AMD": 28075, "\u0120Lebanese": 28076, "\u0120rang": 28077, "\u0120LSU": 28078, "ongs": 28079, "\u0120peninsula": 28080, "\u0120Clause": 28081, "ALK": 28082, "oha": 28083, "\u0120MacBook": 28084, "\u0120unanimous": 28085, "\u0120lenders": 28086, "\u0120hangs": 28087, "\u0120franchises": 28088, "orers": 28089, "\u0120Updates": 28090, "\u0120isolate": 28091, "andro": 28092, "Soon": 28093, "\u0120disruptive": 28094, "\u0120Surve": 28095, "\u0120stitches": 28096, "\u0120Scorp": 28097, "\u0120Dominion": 28098, "\u0120supplying": 28099, "Arg": 28100, "\u0120turret": 28101, "\u0120Luk": 28102, "\u0120brackets": 28103, "*)": 28104, "\u0120Revolutionary": 28105, "\u0120Honest": 28106, "\u0120noticing": 28107, "\u0120Shannon": 28108, "\u0120afforded": 28109, "\u0120tha": 28110, "\u0120Janet": 28111, "!--": 28112, "\u0120Narendra": 28113, "\u0120Plot": 28114, "Hol": 28115, "sever": 28116, "eenth": 28117, "\u0120obstruction": 28118, "\u01201024": 28119, "staff": 28120, "jas": 28121, "orget": 28122, "scenes": 28123, "laughs": 28124, "\u0120Fargo": 28125, "crime": 28126, "\u0120orchestr": 28127, "\u0120delet": 28128, "iliary": 28129, "rieved": 28130, "\u0120militar": 28131, "\u0120Greene": 28132, "\u00e2\u0139\u0131": 28133, "\u00e3\u0123\u00a6": 28134, "\u0120Guards": 28135, "\u0120unleashed": 28136, "\u0120Weber": 28137, "\u0120adjustable": 28138, "\u0120caliber": 28139, "\u0120motivations": 28140, "\u0120\u00c3\u0142": 28141, "mAh": 28142, "\u0120Lanka": 28143, "handle": 28144, "\u0120pent": 28145, "\u0120Rav": 28146, "\u0120Angular": 28147, "\u0120Kau": 28148, "umbing": 28149, "\u0120philanthrop": 28150, "\u0120dehyd": 28151, "\u0120toxicity": 28152, "eer": 28153, "\u0120YORK": 28154, "witz": 28155, "\u00e5\u00bc": 28156, "\u0120IE": 28157, "community": 28158, "\u0120AH": 28159, "\u0120retali": 28160, "\u0120massively": 28161, "\u0120Daniels": 28162, "\u0120DEL": 28163, "\u0120carcin": 28164, "Url": 28165, "\u0120routing": 28166, "\u0120NPCs": 28167, "\u0120RAF": 28168, "ryce": 28169, "\u0120waived": 28170, "\u0120Guatem": 28171, "Everybody": 28172, "\u0120covenant": 28173, "\u0120173": 28174, "\u0120relaxing": 28175, "\u0120quart": 28176, "almost": 28177, "\u0120guarded": 28178, "\u0120Soldiers": 28179, "\u0120PLAY": 28180, "\u0120outgoing": 28181, "LAND": 28182, "\u0120rewrite": 28183, "\u0120MOV": 28184, "\u0120Imper": 28185, "\u0120Solution": 28186, "\u0120phenomenal": 28187, "\u0120longevity": 28188, "\u0120impat": 28189, "\u0120Nissan": 28190, "irie": 28191, "\u0120odor": 28192, "\u0120Zar": 28193, "oks": 28194, "\u0120militias": 28195, "\u0120SPEC": 28196, "\u0120tolerated": 28197, "arser": 28198, "\u0120Bradford": 28199, "+,": 28200, "\u0120surreal": 28201, "sf": 28202, "Canadian": 28203, "\u0120resemblance": 28204, "\u0120carbohydrate": 28205, "VIEW": 28206, "\u0120accessory": 28207, "meal": 28208, "largest": 28209, "iegel": 28210, "Someone": 28211, "\u0120toughest": 28212, "oso": 28213, "\u0120funnel": 28214, "\u0120condemnation": 28215, "luent": 28216, "\u0120wired": 28217, "\u0120Sunset": 28218, "Jesus": 28219, "\u0120PST": 28220, "\u0120Pages": 28221, "\u0120Tycoon": 28222, "\u0120PF": 28223, "\u0120selections": 28224, "\u0120\u00e0\u00a4": 28225, "partisan": 28226, "\u0120highs": 28227, "\u0120Rune": 28228, "\u0120crafts": 28229, "lead": 28230, "\u0120Parents": 28231, "\u0120reclaim": 28232, "eker": 28233, "\u0120Allied": 28234, "aeper": 28235, "\u0120looming": 28236, "\u0120beneficiaries": 28237, "\u0120Hull": 28238, "Students": 28239, "Jewish": 28240, "dj": 28241, "\u0120pact": 28242, "template": 28243, "\u0120Officials": 28244, "\u0120Baylor": 28245, "\u0120hemp": 28246, "\u0120youths": 28247, "\u0120Levels": 28248, "\u0120Xiao": 28249, "\u0120Ches": 28250, "\u0120endeavor": 28251, "\u0120Removed": 28252, "\u0120hippocamp": 28253, "Hell": 28254, "\u00e3\u0124\u012c": 28255, "805": 28256, "\u0120dinosaur": 28257, "\u0120Wrath": 28258, "\u0120Indonesian": 28259, "\u0120calculator": 28260, "\u0120Dictionary": 28261, "\u0120420": 28262, "\u0120MAG": 28263, "(_": 28264, "!,": 28265, "tarians": 28266, "\u0120restricting": 28267, "racuse": 28268, "\u0120weekday": 28269, "OUNT": 28270, "\u0120shrugged": 28271, "leground": 28272, "\u0120bald": 28273, "\u0120Doctors": 28274, "\u0120touted": 28275, "\u0120Maxwell": 28276, "\u0120214": 28277, "\u0120diplomat": 28278, "\u0120repression": 28279, "\u0120constituency": 28280, "vice": 28281, "ranked": 28282, "\u0120Napoleon": 28283, "gang": 28284, "\u0120Forever": 28285, "tun": 28286, "\u0120bulb": 28287, "\u0120PDT": 28288, "\u0120Cisco": 28289, "VEN": 28290, "\u0120resumed": 28291, "Steven": 28292, "\u0120Manitoba": 28293, "\u0120fabulous": 28294, "\u0120Agents": 28295, "1984": 28296, "\u0120amusing": 28297, "\u0120Mysteries": 28298, "\u0120orthodox": 28299, "floor": 28300, "\u0120questionnaire": 28301, "\u0120penetrate": 28302, "\u0120filmmakers": 28303, "\u0120Unc": 28304, "\u0120stamped": 28305, "\u0120thirteen": 28306, "\u0120outfield": 28307, "\u0120forwarded": 28308, "\u0120appra": 28309, "\u0120aided": 28310, "try": 28311, "\u0120unfocused": 28312, "\u0120Liz": 28313, "\u0120Wendy": 28314, "\u0120Scene": 28315, "Charg": 28316, "\u0120rejects": 28317, "\u0120leftist": 28318, "\u0120Providence": 28319, "\u0120Brid": 28320, "regn": 28321, "\u0120prophecy": 28322, "\u0120LIVE": 28323, "499": 28324, "\u0120forge": 28325, "\u0120FML": 28326, "\u0120intrinsic": 28327, "\u0120Frog": 28328, "\u0120wont": 28329, "\u0120Holt": 28330, "\u0120famed": 28331, "CLUS": 28332, "aepernick": 28333, "\u0120Hate": 28334, "\u0120Cay": 28335, "\u0120registering": 28336, "ortality": 28337, "ropy": 28338, "ocalyptic": 28339, "aan": 28340, "nav": 28341, "\u0120fascist": 28342, "IFIED": 28343, "\u0120implicated": 28344, "\u0120Resort": 28345, "\u0120Chandler": 28346, "\u0120Brick": 28347, "Pin": 28348, "ysc": 28349, "Usage": 28350, "\u0120Helm": 28351, "usra": 28352, "\u00e2\u013a\u0127\u00e2\u013a\u0127": 28353, "\u0120Abbas": 28354, "\u0120unanimously": 28355, "\u0120keeper": 28356, "\u0120addicted": 28357, "???": 28358, "\u0120helmets": 28359, "\u0120antioxid": 28360, "apsed": 28361, "808": 28362, "giene": 28363, "\u0120waits": 28364, "\u0120minion": 28365, "raved": 28366, "\u0120Porsche": 28367, "\u0120dreaming": 28368, "\u0120171": 28369, "\u0120Cain": 28370, "\u0120unfor": 28371, "asso": 28372, "\u0120Configuration": 28373, "kun": 28374, "hardt": 28375, "\u0120nested": 28376, "\u0120LDS": 28377, "LES": 28378, "\u0120tying": 28379, "enos": 28380, "\u0120cue": 28381, "\u0120Marqu": 28382, "skirts": 28383, "\u0120clicked": 28384, "\u0120expiration": 28385, "\u0120Accordingly": 28386, "\u0120WC": 28387, "\u0120blessings": 28388, "\u0120addictive": 28389, "\u0120Narr": 28390, "yx": 28391, "\u0120Jaguars": 28392, "\u0120rents": 28393, "\u0120Siber": 28394, "\u0120tipped": 28395, "ousse": 28396, "\u0120Fitzgerald": 28397, "\u0120hierarch": 28398, "outine": 28399, "\u0120wavelength": 28400, ">.": 28401, "chid": 28402, "\u0120Processing": 28403, "/+": 28404, "ranking": 28405, "Easy": 28406, "\u0120Construct": 28407, "\u0120tet": 28408, "insured": 28409, "HUD": 28410, "\u0120quoting": 28411, "\u0120communicated": 28412, "inx": 28413, "\u0120inmate": 28414, "\u0120erected": 28415, "\u0120Absolutely": 28416, "\u0120Surely": 28417, "\u0120unim": 28418, "\u0120Throne": 28419, "heid": 28420, "\u0120claws": 28421, "\u0120superstar": 28422, "\u0120Lenn": 28423, "\u0120Whis": 28424, "Uk": 28425, "abol": 28426, "\u0120sket": 28427, "\u0120Niet": 28428, "\u0120perks": 28429, "\u0120affinity": 28430, "\u0120openings": 28431, "phasis": 28432, "\u0120discriminate": 28433, "Tip": 28434, "vc": 28435, "\u0120grinding": 28436, "\u0120Jenny": 28437, "\u0120asthma": 28438, "holes": 28439, "\u0120Homer": 28440, "\u0120registers": 28441, "\u0120Glad": 28442, "\u0120creations": 28443, "\u0120lithium": 28444, "\u0120applause": 28445, "until": 28446, "Justice": 28447, "\u0120Turks": 28448, "\u0120scandals": 28449, "\u0120bake": 28450, "tank": 28451, "Mech": 28452, "\u0120Means": 28453, "\u0120Maid": 28454, "Republicans": 28455, "isal": 28456, "windows": 28457, "\u0120Santos": 28458, "\u0120vegetation": 28459, "338": 28460, "tri": 28461, "\u0120flux": 28462, "insert": 28463, "\u0120clarified": 28464, "\u0120mortg": 28465, "\u0120Chim": 28466, "\u0120Tort": 28467, "\u0120disclaim": 28468, "metal": 28469, "\u0120Aside": 28470, "\u0120induction": 28471, "\u0120infl": 28472, "\u0120atheists": 28473, "amph": 28474, "\u0120ether": 28475, "\u0120Vital": 28476, "\u0120Built": 28477, "Mind": 28478, "\u0120weaponry": 28479, "SET": 28480, "\u0120186": 28481, "admin": 28482, "gam": 28483, "contract": 28484, "afa": 28485, "\u0120derivatives": 28486, "\u0120snacks": 28487, "\u0120churn": 28488, "Econom": 28489, "\u0120capped": 28490, "\u0120Understanding": 28491, "\u0120Hers": 28492, "\u0120Iz": 28493, "\u0120duct": 28494, "IENT": 28495, "aughty": 28496, "\u0120\u00e2\u013e\u0136": 28497, "\u0120NP": 28498, "\u0120sailing": 28499, "Initialized": 28500, "\u0120ted": 28501, "\u0120reactors": 28502, "\u0120Lomb": 28503, "\u0120choke": 28504, "\u0120Worm": 28505, "\u0120admiration": 28506, "\u0120swung": 28507, "ensibly": 28508, "\u0120rash": 28509, "\u0120Goals": 28510, "\u0120Important": 28511, "Shot": 28512, "\u0120Ras": 28513, "\u0120trainers": 28514, "\u0120Bun": 28515, "Working": 28516, "\u0120harmed": 28517, "\u0120Pandora": 28518, "\u0120LTE": 28519, "\u0120mushroom": 28520, "\u0120CHAR": 28521, "\u0120Fee": 28522, "\u0120Moy": 28523, "Born": 28524, "oliberal": 28525, "\u0120Martial": 28526, "\u0120gentlemen": 28527, "\u0120lingering": 28528, "Official": 28529, "\u0120graffiti": 28530, "\u0120Names": 28531, "Der": 28532, "\u0120quint": 28533, "istrate": 28534, "azeera": 28535, "\u0120NOTICE": 28536, "\u0120Florence": 28537, "\u0120payable": 28538, "\u0120depicts": 28539, "\u0120Species": 28540, "Heart": 28541, "\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122\u00e2\u0136\u0122": 28542, "\u0120enclosed": 28543, "Increases": 28544, "Daily": 28545, "\u0120Lis": 28546, "\u0120enactment": 28547, "\u0120Bacon": 28548, "\u0120Steele": 28549, "demand": 28550, "\u0120183": 28551, "\u0120mouths": 28552, "\u0120stranded": 28553, "\u0120enhancement": 28554, "011": 28555, "\u0120Whats": 28556, "\u0120healed": 28557, "eny": 28558, "\u0120Rab": 28559, "\u0120340": 28560, "\u0120Labyrinth": 28561, "roach": 28562, "\u0120Yosh": 28563, "\u0120Clippers": 28564, "\u0120concerts": 28565, "Internet": 28566, "355": 28567, "\u0120stickers": 28568, "\u0120termed": 28569, "\u0120Axe": 28570, "\u0120grandparents": 28571, "France": 28572, "\u0120Clim": 28573, "\u0120Uh": 28574, "ulic": 28575, "\u0120thrill": 28576, "centric": 28577, "\u0120Overview": 28578, "\u0120Conduct": 28579, "\u0120substantive": 28580, "\u0120182": 28581, "mur": 28582, "\u0120stray": 28583, "\u0120Coff": 28584, "\u0120repetitive": 28585, "\u0120Forgotten": 28586, "\u0120qualification": 28587, "ewitness": 28588, "\u0120Zimbabwe": 28589, "\u0120simulated": 28590, "\u0120JD": 28591, "253": 28592, "\u0120Ware": 28593, "\u0120unsc": 28594, "Times": 28595, "\u0120summons": 28596, "\u0120disconnected": 28597, "\u0120184": 28598, "cius": 28599, "\u0120Gujar": 28600, "odka": 28601, "\u0120erase": 28602, "\u0120Tobacco": 28603, "elected": 28604, "\u0120uncont": 28605, "\u0120Shepard": 28606, "\u0120Lamp": 28607, "\u0120alerted": 28608, "\u0120operative": 28609, "arna": 28610, "uint": 28611, "\u0120negligence": 28612, "acements": 28613, "\u0120supra": 28614, "\u0120prevail": 28615, "\u0120Shark": 28616, "\u0120belts": 28617, "\u00e3\u0123\u00ab": 28618, "\u0120tighter": 28619, "Engineers": 28620, "\u0120inactive": 28621, "\u0120exponent": 28622, "\u0120Willie": 28623, "aples": 28624, "\u0120heir": 28625, "\u0120Hits": 28626, "iann": 28627, "\u0120Says": 28628, "\u0120currents": 28629, "\u0120Bengal": 28630, "\u0120arist": 28631, "Buffer": 28632, "\u0120breeze": 28633, "\u0120Wesley": 28634, "Cola": 28635, "\u0120pronoun": 28636, "\u0120deed": 28637, "\u0120Kling": 28638, "\u0120oft": 28639, "\u0120inflict": 28640, "\u0120punishing": 28641, "\u0120nm": 28642, "iku": 28643, "ODUCT": 28644, "014": 28645, "\u0120subsidy": 28646, "\u0120DEA": 28647, "\u0120Herbert": 28648, "\u0120Jal": 28649, "Bank": 28650, "\u0120deferred": 28651, "\u0120shipment": 28652, "Bott": 28653, "\u0120alle": 28654, "bearing": 28655, "HTML": 28656, "Offline": 28657, "\u0120213": 28658, "\u0120scrolling": 28659, "\u0120scanned": 28660, "\u0120Libyan": 28661, "\u0120TOP": 28662, "chrom": 28663, "dt": 28664, "column": 28665, "PsyNetMessage": 28666, "Zero": 28667, "\u0120torso": 28668, "050": 28669, "\u00e2\u0137\u0132": 28670, "\u0120imperson": 28671, "\u0120Schwartz": 28672, "udic": 28673, "\u0120pissed": 28674, "\u0120Sapp": 28675, "257": 28676, "\u0120ISPs": 28677, "ogl": 28678, "\u0120supervised": 28679, "\u0120adolescent": 28680, "\u0120attained": 28681, "\u0120Delivery": 28682, "\u0120Bunny": 28683, "\u01201937": 28684, "\u0120miniature": 28685, "\u0120os": 28686, "\u0120370": 28687, "608": 28688, "\u0120Mourinho": 28689, "\u0120innate": 28690, "\u0120tempo": 28691, "\u0120NM": 28692, "\u0120Fallen": 28693, "009": 28694, "\u0120provocative": 28695, "Streamer": 28696, "\u0120Benedict": 28697, "\u0120Bolshe": 28698, "\u0120turtle": 28699, "\u0120PCB": 28700, "\u0120Equal": 28701, "Director": 28702, "\u0120Rend": 28703, "\u0120fluids": 28704, "Authorities": 28705, "\u0120cousins": 28706, "requency": 28707, "\u0120Neighbor": 28708, "sets": 28709, "shared": 28710, "Charles": 28711, "password": 28712, "\u0120gears": 28713, "\u0120211": 28714, "\u0120Hardware": 28715, "rika": 28716, "\u0120upstream": 28717, "Hom": 28718, "\u0120disproportionately": 28719, "ivities": 28720, "\u0120undefined": 28721, "\u0120electrons": 28722, "\u0120commemor": 28723, "Eventually": 28724, "\u0120><": 28725, "\u0120irresponsible": 28726, "218": 28727, "\u0120Released": 28728, "\u0120OVER": 28729, "\u0120IGN": 28730, "\u0120Bread": 28731, "stellar": 28732, "\u0120Sage": 28733, "tted": 28734, "damage": 28735, "edition": 28736, "\u0120Prec": 28737, "\u0120lime": 28738, "\u0120confinement": 28739, "\u0120calorie": 28740, "weapon": 28741, "\u0120differing": 28742, "\u0120Sina": 28743, "mys": 28744, "amd": 28745, "\u0120intricate": 28746, "kk": 28747, "\u0120PAT": 28748, "\u00c3\u00a3o": 28749, "stones": 28750, "links": 28751, "\u0120ranch": 28752, "Semitic": 28753, "\u0120differentiate": 28754, "\u0120Singer": 28755, "occupied": 28756, "\u0120fortress": 28757, "cmd": 28758, "\u0120interception": 28759, "\u0120Ankara": 28760, "\u0120rept": 28761, "\u0120Solitaire": 28762, "\u0120remake": 28763, "pred": 28764, "\u0120dared": 28765, "autions": 28766, "\u0120BACK": 28767, "Running": 28768, "\u0120debugging": 28769, "\u0120graphs": 28770, "399": 28771, "\u0120Nigel": 28772, "\u0120bun": 28773, "\u0120pillow": 28774, "\u0120progressed": 28775, "fashioned": 28776, "\u0120obedience": 28777, "ERN": 28778, "\u0120rehears": 28779, "Cell": 28780, "tl": 28781, "Sher": 28782, "\u0120herald": 28783, "\u0120Payment": 28784, "\u0120Cory": 28785, "\u0120Dept": 28786, "\u0120repent": 28787, "\u0120Weak": 28788, "uckland": 28789, "\u0120pleasing": 28790, "\u0120shortages": 28791, "\u0120jurors": 28792, "\u0120Kab": 28793, "qqa": 28794, "Anti": 28795, "\u0120wow": 28796, "\u0120RCMP": 28797, "\u0120tsun": 28798, "\u0120Sic": 28799, "\u0120comprises": 28800, "\u0120spies": 28801, "\u0120precinct": 28802, "nu": 28803, "\u0120urges": 28804, "\u0120timed": 28805, "\u0120stripes": 28806, "\u0120Boots": 28807, "\u0120yen": 28808, "Advanced": 28809, "\u0120discrete": 28810, "\u0120Archangel": 28811, "employment": 28812, "Diff": 28813, "\u0120monuments": 28814, "\u0120209": 28815, "worker": 28816, "\u0120196": 28817, "\u0120Ig": 28818, "utterstock": 28819, "TPS": 28820, "Jac": 28821, "\u0120homelessness": 28822, "\u0120commentator": 28823, "\u0120racially": 28824, "fing": 28825, "seed": 28826, "Ele": 28827, "ellation": 28828, "\u0120ethanol": 28829, "\u0120parish": 28830, "\u0120Dong": 28831, "\u0120Awakening": 28832, "\u0120deviation": 28833, "\u0120Bearing": 28834, "\u0120Tsuk": 28835, "\u0120recess": 28836, "\u0120lymph": 28837, "\u0120Cannabis": 28838, "\u00e5\u013e": 28839, "\u0120NEWS": 28840, "\u0120dra": 28841, "\u0120Stefan": 28842, "\u0120Wrong": 28843, "\u0120SAM": 28844, "\u0120loosely": 28845, "\u0120interpreter": 28846, "\u0120Plain": 28847, "Government": 28848, "\u0120bigotry": 28849, "\u0120grenades": 28850, "avez": 28851, "pictured": 28852, "\u0120mandated": 28853, "\u0120Monk": 28854, "\u0120Pedro": 28855, "\u0120lava": 28856, "274": 28857, "\u0120cynical": 28858, "\u0120Scrolls": 28859, "locks": 28860, "Mp": 28861, "\u0120congregation": 28862, "ornings": 28863, "phil": 28864, "\u0120Ibid": 28865, "\u0120ferv": 28866, "\u0120disappearing": 28867, "\u0120arrogant": 28868, "syn": 28869, "\u0120Maver": 28870, "\u0120Suit": 28871, "241": 28872, "\u0120abbre": 28873, "ackers": 28874, "Pa": 28875, "\u0120Yel": 28876, "Whenever": 28877, "\u0120235": 28878, "\u0120Vine": 28879, "\u0120Anat": 28880, "\u0120extinct": 28881, "LET": 28882, "\u0120executable": 28883, "VERS": 28884, "oxide": 28885, "DNA": 28886, "\u0120Prel": 28887, "\u0120resentment": 28888, "\u0120comprise": 28889, "\u0120Aviv": 28890, "\u0120interceptions": 28891, "\u0120prolific": 28892, "INA": 28893, "\u0120Erin": 28894, "thought": 28895, "219": 28896, "\u0120Psychiatry": 28897, "unky": 28898, "chemist": 28899, "Ho": 28900, "\u0120McCoy": 28901, "\u0120bricks": 28902, "Los": 28903, "rily": 28904, "\u0120USSR": 28905, "\u0120rud": 28906, "\u0120laud": 28907, "\u0120Wise": 28908, "\u0120Emerald": 28909, "\u0120revived": 28910, "\u0120damned": 28911, "\u0120Repair": 28912, "idem": 28913, "ctica": 28914, "\u0120patriarch": 28915, "\u0120Nurs": 28916, "meg": 28917, "\u0120cheapest": 28918, "reements": 28919, "empty": 28920, "\u0120Celebr": 28921, "\u0120deprivation": 28922, "chanted": 28923, "\u0120Thumbnails": 28924, "Energy": 28925, "\u0120Ethan": 28926, "\u0120Qing": 28927, "\u0120opposes": 28928, "WIND": 28929, "vik": 28930, "\u0120Mau": 28931, "\u0120SUB": 28932, "667": 28933, "GRE": 28934, "\u0120Volunte": 28935, "nton": 28936, "Cook": 28937, "\u00e5\u0132": 28938, "esque": 28939, "\u0120plummet": 28940, "\u0120suing": 28941, "\u0120pronounce": 28942, "\u0120resisting": 28943, "\u0120Fishing": 28944, "\u0120Trials": 28945, "\u0120yell": 28946, "\u0120310": 28947, "\u0120induct": 28948, "\u0120personalized": 28949, "often": 28950, "Reb": 28951, "EMBER": 28952, "\u0120viewpoint": 28953, "\u0120existential": 28954, "())": 28955, "remove": 28956, "MENTS": 28957, "lasses": 28958, "\u0120evapor": 28959, "\u0120aisle": 28960, "meta": 28961, "\u0120reflective": 28962, "\u0120entitlement": 28963, "\u0120devised": 28964, "music": 28965, "ascade": 28966, "\u0120winding": 28967, "offset": 28968, "\u0120accessibility": 28969, "kered": 28970, "Better": 28971, "\u0120Johnston": 28972, "thinking": 28973, "Snow": 28974, "\u0120Croatia": 28975, "\u0120Atomic": 28976, "271": 28977, "348": 28978, "\u0120textbook": 28979, "\u0120Sixth": 28980, "\u0120\u00d8\u00a7\u00d9\u0126": 28981, "\u0120slider": 28982, "\u0120Burger": 28983, "bol": 28984, "Sync": 28985, "\u0120grandchildren": 28986, "\u0120cerv": 28987, "+)": 28988, "\u0120eternity": 28989, "\u0120tweeting": 28990, "\u0120speculative": 28991, "\u0120pivotal": 28992, "\u0120WP": 28993, "\u0120TER": 28994, "ynamic": 28995, "\u0120upl": 28996, "\u0120Cats": 28997, "perhaps": 28998, "\u0120classmates": 28999, "\u0120blatant": 29000, "'-": 29001, "\u0120lakh": 29002, "antine": 29003, "\u0120Borg": 29004, "iom": 29005, "/(": 29006, "\u0120Athletic": 29007, "\u0120sar": 29008, "OTA": 29009, "\u0120Hoffman": 29010, "Nevertheless": 29011, "\u0120adorable": 29012, "\u0120spawned": 29013, "Associated": 29014, "\u0120Domestic": 29015, "\u0120implant": 29016, "\u0120Luxem": 29017, "\u0120Kens": 29018, "\u0120pumps": 29019, "\u0120SAT": 29020, "Attributes": 29021, "509": 29022, "avour": 29023, "\u0120centralized": 29024, "\u0120TN": 29025, "\u0120freshly": 29026, "\u0120Achieve": 29027, "\u0120outsiders": 29028, "herty": 29029, "\u0120Ree": 29030, "\u0120Towers": 29031, "\u0120Dart": 29032, "akable": 29033, "\u0120mp": 29034, "\u0120Heavenly": 29035, "\u0120ripe": 29036, "\u0120Caroline": 29037, "ryan": 29038, "\u0120classics": 29039, "\u0120retiring": 29040, "\u0120228": 29041, "\u0120ah": 29042, "\u0120dealings": 29043, "\u0120punching": 29044, "\u0120Chapman": 29045, "Options": 29046, "maxwell": 29047, "volume": 29048, "\u0120stal": 29049, "\u0120exported": 29050, "\u0120Quite": 29051, "\u0120numerical": 29052, "Burn": 29053, "Fact": 29054, "\u0120Keystone": 29055, "\u0120trending": 29056, "\u0120altering": 29057, "\u0120Africans": 29058, "478": 29059, "\u0120MN": 29060, "\u0120Knock": 29061, "\u0120temptation": 29062, "\u0120prestige": 29063, "Overview": 29064, "\u0120Traditional": 29065, "\u0120Bahrain": 29066, "Private": 29067, "\u0120HOU": 29068, "\u0120barr": 29069, "\u0120Tat": 29070, "Cube": 29071, "USD": 29072, "\u0120Grande": 29073, "\u0120Gat": 29074, "\u0120Flo": 29075, "\u0120resides": 29076, "\u0120indec": 29077, "volent": 29078, "\u0120perpetual": 29079, "ubes": 29080, "\u0120worldview": 29081, "\u0120Quantum": 29082, "\u0120filtered": 29083, "\u0120ensu": 29084, "orgetown": 29085, "ERSON": 29086, "\u0120Mild": 29087, "379": 29088, "OTT": 29089, "\u00c3\u00a5": 29090, "\u0120vitamins": 29091, "\u0120ribbon": 29092, "\u0120sincerely": 29093, "\u0120Hin": 29094, "\u0120eighteen": 29095, "\u0120contradictory": 29096, "\u0120glaring": 29097, "\u0120expectancy": 29098, "\u0120conspir": 29099, "\u0120monstrous": 29100, "\u0120380": 29101, "reci": 29102, "\u0120handic": 29103, "\u0120pumped": 29104, "\u0120indicative": 29105, "\u0120rapp": 29106, "\u0120avail": 29107, "\u0120LEGO": 29108, "\u0120Marijuana": 29109, "1985": 29110, "erton": 29111, "\u0120twentieth": 29112, "################################": 29113, "\u0120Swamp": 29114, "\u0120valuation": 29115, "\u0120affiliates": 29116, "adjusted": 29117, "\u0120Facility": 29118, "262": 29119, "\u0120enzymes": 29120, "itudinal": 29121, "\u0120imprint": 29122, "Site": 29123, "\u0120installer": 29124, "\u0120TRA": 29125, "mology": 29126, "linear": 29127, "\u0120Collective": 29128, "igating": 29129, "\u0120Token": 29130, "\u0120speculated": 29131, "KN": 29132, "\u0120Cly": 29133, "ority": 29134, "\u0120defer": 29135, "\u0120inspectors": 29136, "approved": 29137, "RM": 29138, "\u0120Suns": 29139, "\u0120informing": 29140, "\u0120Syracuse": 29141, "ibli": 29142, "765": 29143, "\u0120glove": 29144, "\u0120authorize": 29145, "\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6\u00e2\u0122\u00a6": 29146, "\u0120Cruise": 29147, "\u0120contracting": 29148, "shell": 29149, "IFE": 29150, "\u0120Jewel": 29151, "pract": 29152, "\u0120Photoshop": 29153, "\u0120Knowing": 29154, "harm": 29155, "\u0120attractions": 29156, "adan": 29157, "etus": 29158, "018": 29159, "wagen": 29160, "Alt": 29161, "\u0120multiply": 29162, "\u0120equilibrium": 29163, ":{": 29164, "\u0120Fighters": 29165, "\u0120Edgar": 29166, "\u0120fourteen": 29167, "Govern": 29168, "\u0120misuse": 29169, "\u0120abusing": 29170, "\u0120ancestry": 29171, "ramer": 29172, "644": 29173, "\u0120worms": 29174, "\u0120thicker": 29175, "\u0120Combine": 29176, "\u0120peasants": 29177, "\u0120vind": 29178, "\u0120conquest": 29179, "\u0120mocked": 29180, "\u0120cinnamon": 29181, "\u0120Cald": 29182, "\u0120Gallup": 29183, "\u0120avoidance": 29184, "\u0120incarnation": 29185, "\u0120Strat": 29186, "\u0120tasted": 29187, "enta": 29188, "\u0120Neal": 29189, "pared": 29190, "\u0120terminology": 29191, "jection": 29192, "Scientists": 29193, "\u0120INS": 29194, "\u0120Dee": 29195, "\u0120directories": 29196, "Road": 29197, "\u0120Shap": 29198, "bright": 29199, "\u0120Directors": 29200, "\u0120Column": 29201, "\u0120bob": 29202, "\u0120preferably": 29203, "\u0120glitch": 29204, "furt": 29205, "\u0120eg": 29206, "idis": 29207, "CBC": 29208, "\u0120surrendered": 29209, "\u0120testament": 29210, "336": 29211, "uggest": 29212, "\u0120Nil": 29213, "another": 29214, "\u0120pathetic": 29215, "\u0120Donna": 29216, "\u0120218": 29217, "\u0120Avery": 29218, "\u0120whiskey": 29219, "\u0120fixture": 29220, "\u0120Conquest": 29221, "\u0120bets": 29222, "Occ": 29223, "\u0120Leicester": 29224, "].\"": 29225, "\u0120));": 29226, "\u0120flashes": 29227, "456": 29228, "\u0120masked": 29229, "gebra": 29230, "\u0120computed": 29231, "chel": 29232, "auder": 29233, "\u0120defeats": 29234, "\u0120Liberation": 29235, "\u0120Osama": 29236, "\u0120Vive": 29237, "Changes": 29238, "Channel": 29239, "\u0120tariffs": 29240, "\u0120mage": 29241, "\u0120Sax": 29242, "\u0120inadvertently": 29243, "\u0120CRE": 29244, "\u0120Reaper": 29245, "inky": 29246, "grading": 29247, "\u0120stereotyp": 29248, "\u0120curl": 29249, "\u0120FANT": 29250, "\u0120frameworks": 29251, "Mom": 29252, "\u0120Anch": 29253, "\u0120flavour": 29254, "carbon": 29255, "\u0120permitting": 29256, "letcher": 29257, "\u0120Mozilla": 29258, "\u0120Parking": 29259, "\u0120Champ": 29260, "Scroll": 29261, "\u0120murderer": 29262, "\u0120rested": 29263, "\u0120owes": 29264, "\u0120Poss": 29265, "ADD": 29266, "IFF": 29267, "resolution": 29268, "\u0120Mining": 29269, "\u0120comparative": 29270, "Dim": 29271, "\u0120neighbouring": 29272, "\u0120AST": 29273, "\u0120Toxic": 29274, "\u0120biases": 29275, "\u0120gunfire": 29276, "urous": 29277, "\u0120Moment": 29278, "1983": 29279, "\u0120pervasive": 29280, "ttp": 29281, "\u0120Normally": 29282, "rir": 29283, "Sarah": 29284, "\u0120Albany": 29285, "\u0120unsett": 29286, "\u0120SMS": 29287, "ipers": 29288, "layer": 29289, "\u0120Whites": 29290, "uple": 29291, "\u0120turbo": 29292, "\u0120Leeds": 29293, "\u0120thats": 29294, "\u0120Miner": 29295, "MER": 29296, "\u0120Reign": 29297, "\u0120perme": 29298, "\u0120Blitz": 29299, "\u01201934": 29300, "\u0120intimidating": 29301, "tube": 29302, "\u0120eccentric": 29303, "abolic": 29304, "boxes": 29305, "\u0120Associates": 29306, "votes": 29307, "\u0120simulate": 29308, "umbo": 29309, "astery": 29310, "\u0120shipments": 29311, "FFFF": 29312, "anth": 29313, "\u0120seasoned": 29314, "\u0120experimentation": 29315, "\u00e2\u0138\u0142": 29316, "laws": 29317, "Meet": 29318, "iddles": 29319, "antics": 29320, "Rating": 29321, "ISIS": 29322, "hift": 29323, "\u0120fronts": 29324, "buf": 29325, "017": 29326, "\u0120unatt": 29327, "\u0120Dil": 29328, "leases": 29329, "\u0120Gardens": 29330, "777": 29331, "touch": 29332, "vell": 29333, "458": 29334, "\u0120=====": 29335, "saving": 29336, "\u0120erosion": 29337, "\u0120Quin": 29338, "\u0120earns": 29339, "\u0120accomplishment": 29340, "\u0120Wei": 29341, "\u0120<[": 29342, "_____": 29343, "\u0120irrig": 29344, "\u0120Teddy": 29345, "\u0120conquered": 29346, "\u0120Armored": 29347, "\u0120asserts": 29348, "\u0120manipulating": 29349, "r\u00c3\u00a9": 29350, "\u0120transcripts": 29351, "Gallery": 29352, "\u0120plotting": 29353, "Neil": 29354, "\u0120betrayal": 29355, "loader": 29356, "\u0120Sul": 29357, "\u0120displacement": 29358, "\u0120royalty": 29359, "\u0120WI": 29360, "heit": 29361, "\u0120Devices": 29362, "allel": 29363, "\u0120municipalities": 29364, "\u0120canal": 29365, "Stars": 29366, "\u0120UAE": 29367, "\u0120\"\u00e2\u0122\u00a6": 29368, "\u0120CU": 29369, "above": 29370, "\u0120resonance": 29371, "\u0120guiActiveUn": 29372, "added": 29373, "\u0120Braves": 29374, "\u0120Ibn": 29375, "\u0120hereby": 29376, "\u0120BRE": 29377, "\u0120shareholder": 29378, "\u0120Hir": 29379, "\u0120Ji": 29380, "\u0120strangely": 29381, "\u0120admired": 29382, "\u0120plight": 29383, "\u0120bachelor": 29384, "\u0120Pole": 29385, "ciplinary": 29386, "Tony": 29387, "\u0120Armenian": 29388, "\u0120unman": 29389, "\u0120Zionist": 29390, "Stage": 29391, "iscover": 29392, "\u0120automotive": 29393, "\u0120sidelines": 29394, "\u0120slick": 29395, "\u0120Renaissance": 29396, "\u0120FUN": 29397, "Images": 29398, "\u0120Haj": 29399, "\u0120ping": 29400, "\u0120shortcut": 29401, "\u0120Blvd": 29402, "\u0120Looks": 29403, "\u0120bursts": 29404, "\u0120clamp": 29405, "\u0120mish": 29406, "\u0120sorting": 29407, "\u0120patriot": 29408, "\u0120correctness": 29409, "\u0120Scandinav": 29410, "\u0120Cavaliers": 29411, "python": 29412, "azar": 29413, "\u0120375": 29414, "\u0120Jaune": 29415, "409": 29416, "\u0120detrimental": 29417, "\u0120stabbing": 29418, "\u0120poisoned": 29419, "\u0120fountain": 29420, "ocent": 29421, "orst": 29422, "\u0120Mari": 29423, "\u0120rains": 29424, "\u0120Overs": 29425, "\u0120Institution": 29426, "udget": 29427, "AMY": 29428, "tale": 29429, "\u0120KR": 29430, "\u0120Prices": 29431, "\u0120headaches": 29432, "\u0120landsl": 29433, "\u0120Aura": 29434, "Bonus": 29435, "\u0120Zhao": 29436, "\u0120Hip": 29437, "\u0120hops": 29438, "\u0120Kurdistan": 29439, "\u0120exploiting": 29440, "ryn": 29441, "\u0120hypocrisy": 29442, "opening": 29443, "\u0120gunshot": 29444, "\u0120wed": 29445, "interstitial": 29446, "Interstitial": 29447, "\u0120amen": 29448, "Breaking": 29449, "\u0120marketed": 29450, "Wire": 29451, "\u0120Crowd": 29452, "Continue": 29453, "\u0120Known": 29454, "\u0120Effective": 29455, "orean": 29456, "izons": 29457, "Joseph": 29458, "\u0120escalation": 29459, "username": 29460, "\u0120curtain": 29461, "ATES": 29462, "\u0120PAR": 29463, "\u0120Miy": 29464, "\u0120counterfe": 29465, "lene": 29466, "\u0120contenders": 29467, "daily": 29468, "\u0120Asc": 29469, "\u0120Phillip": 29470, "mostly": 29471, "\u0120filename": 29472, "hene": 29473, "\u0120resembling": 29474, "\u0120staging": 29475, "\u0120Chloe": 29476, "\u0120wiring": 29477, "Hon": 29478, "\u0120Renew": 29479, "ottage": 29480, "\u0120Hybrid": 29481, "much": 29482, "\u0120strokes": 29483, "\u0120policymakers": 29484, "APTER": 29485, "\u0120Arkham": 29486, "plot": 29487, "\u0120assistants": 29488, "\u0120deport": 29489, "\u0120Sega": 29490, "\u0120influenza": 29491, "\u0120Cursed": 29492, "\u0120Kobe": 29493, "\u0120skinny": 29494, "Provider": 29495, "\u0120Rip": 29496, "\u0120incremental": 29497, "products": 29498, "BF": 29499, "\u0120dome": 29500, "\u0120Credits": 29501, "\u0120losers": 29502, "ints": 29503, "\u0120Betty": 29504, "\u0120Talent": 29505, "\u0120DAM": 29506, "Lv": 29507, "Ess": 29508, "\u0120dens": 29509, "temp": 29510, "Judge": 29511, "odic": 29512, "\u0120'(": 29513, "URES": 29514, "etsk": 29515, "VO": 29516, "\u0120retrieved": 29517, "\u0120architects": 29518, "\u00d9\u0129": 29519, "\u0120ethic": 29520, "\u0120Secondary": 29521, "stocks": 29522, "adia": 29523, "\u0120325": 29524, "\u0120Opinion": 29525, "\u0120simultaneous": 29526, "\u0120dizz": 29527, "ulp": 29528, "\u0120smuggling": 29529, "ippery": 29530, "Random": 29531, "facing": 29532, "\u0120Das": 29533, "\u0120stockp": 29534, "\u0120disclosures": 29535, "pointer": 29536, "\u0120coral": 29537, "\u0120Selection": 29538, "\u0120Pike": 29539, "ivalent": 29540, "\u0120ruthless": 29541, "\u0120Rim": 29542, "\u0120ensuing": 29543, "\u0120Experiment": 29544, "\u0120congressman": 29545, "\u0120believer": 29546, "\u0120unspecified": 29547, "\u0120Mord": 29548, "\u0120knowledgeable": 29549, "\u0120VERY": 29550, "TX": 29551, "\u0120straps": 29552, "\u0120turf": 29553, "apeshifter": 29554, "\u0120marital": 29555, "\u0120flock": 29556, "\u00e3\u0123\u0128": 29557, "263": 29558, "AMES": 29559, "\u0120Opposition": 29560, "\u0120treasures": 29561, "\u0120GOD": 29562, "\u0120modeled": 29563, "\u0120WORLD": 29564, "\u0120([": 29565, "\u0120Usage": 29566, "HF": 29567, "\u0120$(": 29568, "ussed": 29569, "\u0120pioneer": 29570, "Eight": 29571, "parse": 29572, "bread": 29573, "ritz": 29574, "\u0120Miranda": 29575, "\u0120Kant": 29576, "++)": 29577, "oren": 29578, "\u0120provoked": 29579, "\u0120breeds": 29580, "\u0120Includes": 29581, "\u0120Pastebin": 29582, "\u0120Flip": 29583, "Java": 29584, "\u0120brink": 29585, "\u0120rumored": 29586, "\u0120unseen": 29587, "\u0120garnered": 29588, "\u0120Defin": 29589, "alted": 29590, "\u0120tattoos": 29591, "\u0120hesitation": 29592, "isitions": 29593, "\u0120Weaver": 29594, "\u0120Reporting": 29595, "\u0120therapies": 29596, "\u0120consultants": 29597, "\u0120residual": 29598, "\u0120Mali": 29599, "\u0120Roma": 29600, "iago": 29601, "\u0120Residents": 29602, "ubi": 29603, "\u0120remedies": 29604, "\u0120adaptive": 29605, "\u0120Alive": 29606, "\u0120Barcl": 29607, "\u0120wallets": 29608, "crypt": 29609, "etermination": 29610, "\u0120Pelosi": 29611, "\u0120slipping": 29612, "otonin": 29613, "\u0120alliances": 29614, "patrick": 29615, "iris": 29616, "\u0120orth": 29617, "\u0120Perkins": 29618, "\u0120DeV": 29619, "\u0120Gets": 29620, "\u0120drying": 29621, "gee": 29622, "forest": 29623, "\u0120Forget": 29624, "orem": 29625, "339": 29626, "\u0120vaguely": 29627, "\u0120Dion": 29628, "\u0120Porn": 29629, "\u0120HOW": 29630, "\u0120pneum": 29631, "\u0120rubble": 29632, "\u0120Taste": 29633, "encia": 29634, "\u0120Gel": 29635, "\u0120dst": 29636, "\u0120245": 29637, "\u0120Morocco": 29638, "inflamm": 29639, "\u0120Twins": 29640, "\u0120bots": 29641, "daughter": 29642, "\u0120Balk": 29643, "\u0120brethren": 29644, "\u0120logos": 29645, "\u0120gobl": 29646, "fps": 29647, "\u0120subdivision": 29648, "\u0120pawn": 29649, "\u0120squeezed": 29650, "\u0120morale": 29651, "\u0120DW": 29652, "'\"": 29653, "\u0120knot": 29654, "ooky": 29655, "\u0120divisive": 29656, "\u0120boosted": 29657, "chy": 29658, "\u00e3\u0125\u0132": 29659, "ifact": 29660, "\u0120newcomers": 29661, "\u0120Wrestling": 29662, "\u0120scouts": 29663, "wolves": 29664, "Rat": 29665, "\u0120nineteenth": 29666, "\u0120Osborne": 29667, "Stats": 29668, "\u0120empowered": 29669, "\u0120psychopath": 29670, "\u0120OEM": 29671, "uggage": 29672, "\u0120PK": 29673, "\u0120Mohammad": 29674, "Pak": 29675, "\u0120anarchists": 29676, "\u0120Extract": 29677, "esthes": 29678, "\u0120Stockholm": 29679, "loo": 29680, "\u0120Graph": 29681, "\u0120deploying": 29682, "\u0120Stranger": 29683, "\u0120Mold": 29684, "\u0120staffer": 29685, "\u0120discounted": 29686, "uckle": 29687, "please": 29688, "\u0120Landing": 29689, "\u00c3\u0143a": 29690, "\u0120193": 29691, "\u0120ante": 29692, "\u0120repetition": 29693, "\u0120+/-": 29694, "\u0120parody": 29695, "\u0120lively": 29696, "AAA": 29697, "\u0120Horus": 29698, "\u0120pits": 29699, "inders": 29700, "LOC": 29701, "\u0120Venice": 29702, "406": 29703, "\u0120Discover": 29704, "\u00e2\u0128": 29705, "ellectual": 29706, "\u0120pens": 29707, "\u0120eyel": 29708, "iguous": 29709, "Impl": 29710, "\u0120joking": 29711, "\u0120inval": 29712, "\u0120Belfast": 29713, "\u0120creditors": 29714, "\u0120Skywalker": 29715, "ovsky": 29716, "\u0120ceasefire": 29717, "\u0120seals": 29718, "isoft": 29719, ")).": 29720, "\u0120Felix": 29721, "ITS": 29722, "\u0120tresp": 29723, "\u0120Blockchain": 29724, "eware": 29725, "\u0120Schwar": 29726, "enne": 29727, "mounted": 29728, "\u0120Beacon": 29729, "lesh": 29730, "\u0120immensely": 29731, "\u0120cheering": 29732, "Employ": 29733, "scene": 29734, "ishly": 29735, "atchewan": 29736, "\u0120Nicolas": 29737, "\u0120drained": 29738, "\u0120Exit": 29739, "\u0120Azerb": 29740, "jun": 29741, "\u0120floated": 29742, "uania": 29743, "Deep": 29744, "\u0120superv": 29745, "\u0120mystical": 29746, "\u0120Dollar": 29747, "\u0120Apostle": 29748, "\u0120REL": 29749, "\u0120Provided": 29750, "\u0120Bucks": 29751, "\u00e3\u0125\u00b4": 29752, "cutting": 29753, "\u0120enhancements": 29754, "\u0120Penguins": 29755, "\u0120Isaiah": 29756, "\u0120jerk": 29757, "\u0120Wyn": 29758, "\u0120stalled": 29759, "\u0120cryptocurrencies": 29760, "\u0120Roland": 29761, "single": 29762, "\u0120lumin": 29763, "\u0120Fellow": 29764, "\u0120Capacity": 29765, "\u0120Kazakh": 29766, "WN": 29767, "\u0120financed": 29768, "389": 29769, "\u0120tid": 29770, "\u0120collusion": 29771, "\u0120Myr": 29772, "\u00ee\u0122": 29773, "Senator": 29774, "\u0120pediatric": 29775, "\u0120neatly": 29776, "\u0120sandwiches": 29777, "\u0120Architecture": 29778, "\u0120tucked": 29779, "\u0120balcony": 29780, "\u0120earthquakes": 29781, "quire": 29782, "Future": 29783, "\u0120hefty": 29784, "\u00e9\u0139": 29785, "\u0120specializes": 29786, "\u0120stresses": 29787, "\u0120sender": 29788, "\u0120misunderstanding": 29789, "\u0120epile": 29790, "\u0120provoke": 29791, "\u0120Colors": 29792, "\u0120dismay": 29793, "uko": 29794, "[_": 29795, "586": 29796, "neutral": 29797, "\u0120donating": 29798, "\u0120Randall": 29799, "Multi": 29800, "\u0120conveniently": 29801, "\u0120Sung": 29802, "\u0120Coca": 29803, "\u0120tents": 29804, "\u0120Acceler": 29805, "\u0120partnered": 29806, "272": 29807, "irming": 29808, "\u0120BAS": 29809, "sometimes": 29810, "\u0120objected": 29811, "ubric": 29812, "posed": 29813, "LCS": 29814, "grass": 29815, "\u0120attributable": 29816, "VIS": 29817, "Israeli": 29818, "\u0120repeats": 29819, "\u0120RM": 29820, "vag": 29821, "uta": 29822, "inous": 29823, "\u0120inert": 29824, "\u0120Miguel": 29825, "\u00e6\u0143": 29826, "\u0120Hawaiian": 29827, "Board": 29828, "\u0120artific": 29829, "\u0120Azerbai": 29830, "asio": 29831, "\u0120Rent": 29832, "AIN": 29833, "\u0120appliances": 29834, "\u0120nationality": 29835, "\u0120asshole": 29836, "\u0120Neb": 29837, "\u0120notch": 29838, "hani": 29839, "\u0120Bride": 29840, "Availability": 29841, "\u0120intercepted": 29842, "\u0120continental": 29843, "\u0120swelling": 29844, "\u0120Perspect": 29845, "bies": 29846, ".<": 29847, "ithmetic": 29848, "\u0120Lara": 29849, "\u0120tempting": 29850, "addr": 29851, "\u0120overseeing": 29852, "clad": 29853, "\u0120DV": 29854, "\u0120Gingrich": 29855, "\u0120mun": 29856, "\u0120Appropri": 29857, "\u0120alterations": 29858, "\u0120Patreon": 29859, "\u0120havoc": 29860, "\u0120disciplines": 29861, "\u0120notoriously": 29862, "akuya": 29863, "ieri": 29864, "?).": 29865, "\u0120Went": 29866, "\u0120silicon": 29867, "\u0120tremb": 29868, "Container": 29869, "Known": 29870, "\u0120mortar": 29871, "este": 29872, "icka": 29873, "Arthur": 29874, "\u0120Previously": 29875, "\u0120Marty": 29876, "\u0120sparse": 29877, "gins": 29878, "\u0120inward": 29879, "\u0120Participant": 29880, "Copy": 29881, "\u0120Misc": 29882, "\u0120antibiotic": 29883, "\u0120Retro": 29884, "\u0120elusive": 29885, "\u0120assail": 29886, "\u0120Battalion": 29887, "\u0120Bought": 29888, "\u0120diminish": 29889, "\u0120Europa": 29890, "session": 29891, "\u0120Dangerous": 29892, "iesel": 29893, "\u0120disbelief": 29894, "\u0120blasts": 29895, "extreme": 29896, "\u0120Boyd": 29897, "\u0120Projects": 29898, "\u0120Guys": 29899, "\u0120undergone": 29900, "\u0120grill": 29901, "\u0120Dwight": 29902, "\u0120197": 29903, "USER": 29904, "\u0120filesystem": 29905, "\u0120clocks": 29906, "Taylor": 29907, "\u0120wrapper": 29908, "\u0120folding": 29909, "ousand": 29910, "\u0120Philippine": 29911, "ATIONAL": 29912, "\u0120Perth": 29913, "\u0120ashes": 29914, "\u0120accumulate": 29915, "\u0120Gateway": 29916, "Shop": 29917, "orkshire": 29918, "Han": 29919, "\u0120Barrel": 29920, "\u0120Leh": 29921, "\u0120XV": 29922, "\u0120whim": 29923, "\u0120repo": 29924, "\u0120CG": 29925, "\u0120Mam": 29926, "\u0120incorporating": 29927, "\u0120bailout": 29928, "\u0120linguistic": 29929, "\u0120disinteg": 29930, "CLE": 29931, "\u0120cinematic": 29932, "\u0120Fiber": 29933, "Syn": 29934, "ilion": 29935, "\u0120Compos": 29936, "chens": 29937, "\u0120neoc": 29938, "\u0120boiled": 29939, "FINE": 29940, "ono": 29941, "uncle": 29942, "iken": 29943, "\u0120BM": 29944, "\u00ce\u00b9": 29945, "\u0120receipts": 29946, "\u0120disposed": 29947, "\u0120Thirty": 29948, "\u0120Rough": 29949, "\u0120ABS": 29950, "\u0120notwithstanding": 29951, "ollen": 29952, "#$": 29953, "\u0120unreliable": 29954, "\u0120bloom": 29955, "\u0120mediocre": 29956, "\u0120tram": 29957, "\u0120Tasman": 29958, "\u0120shakes": 29959, "\u0120manifesto": 29960, "\u0120MW": 29961, "\u0120satisfactory": 29962, "\u0120shores": 29963, "\u0120computation": 29964, "\u0120assertions": 29965, "ormons": 29966, "arag": 29967, "abit": 29968, "Democrats": 29969, "\u0120Loot": 29970, "\u0120Volks": 29971, "haired": 29972, "\u0120gravitational": 29973, "Sing": 29974, "\u0120Miz": 29975, "\u0120throttle": 29976, "\u0120tyranny": 29977, "\u0120Views": 29978, "\u0120robber": 29979, "\u0120Minority": 29980, "\u0120shrine": 29981, "scope": 29982, "purpose": 29983, "\u0120nucleus": 29984, "ourcing": 29985, "\u0120USDA": 29986, "\u0120DHS": 29987, "wra": 29988, "\u0120Bowie": 29989, "Scale": 29990, "\u0120BEL": 29991, "xi": 29992, "Iter": 29993, "\u0120(),": 29994, "wright": 29995, "\u0120sailors": 29996, "oused": 29997, "NASA": 29998, "\u0120Proof": 29999, "\u0120Mineral": 30000, "token": 30001, "\u0120FD": 30002, "Rew": 30003, "\u0120ell": 30004, "630": 30005, "\u0120chancellor": 30006, "\u0120Gos": 30007, "\u0120amounted": 30008, "\u0120Recre": 30009, "omez": 30010, "\u0120Optim": 30011, "\u0120Olive": 30012, "\u0120tracker": 30013, "owler": 30014, "\u0120Unique": 30015, "Root": 30016, "\u0120maritime": 30017, "\u0120Quran": 30018, "\u0120Adapt": 30019, "\u0120ecosystems": 30020, "\u0120Repeat": 30021, "\u0120Soy": 30022, "\u0120IMP": 30023, "\u0120graduating": 30024, "andem": 30025, "Pur": 30026, "\u0120Reset": 30027, "\u0120Trick": 30028, "\u0120Philly": 30029, "\u0120Tue": 30030, "\u0120Malaysian": 30031, "\u0120climax": 30032, "\u0120bury": 30033, "\u0120conspic": 30034, "\u0120Southampton": 30035, "\u0120Flowers": 30036, "\u0120escorted": 30037, "\u0120Educational": 30038, "\u0120IRC": 30039, "\u0120brutally": 30040, "eating": 30041, "\u0120pillar": 30042, "\u0120Sang": 30043, "\u0120Jude": 30044, "arling": 30045, "\u0120Amnesty": 30046, "\u0120reminding": 30047, "\u0120Administrative": 30048, "hesda": 30049, "\u0120flashed": 30050, "\u0120PBS": 30051, "perate": 30052, "feature": 30053, "\u0120swipe": 30054, "\u0120graves": 30055, "oultry": 30056, "261": 30057, "breaks": 30058, "\u0120Guer": 30059, "\u0120shrimp": 30060, "\u0120Voting": 30061, "quist": 30062, "\u0120analytical": 30063, "\u0120tablespoons": 30064, "\u0120SOU": 30065, "\u0120researched": 30066, "\u0120disrupted": 30067, "\u0120jour": 30068, "\u0120replica": 30069, "\u0120cartoons": 30070, "bians": 30071, "})": 30072, "copy": 30073, "Got": 30074, "ouched": 30075, "PUT": 30076, "\u0120swarm": 30077, "notations": 30078, "said": 30079, "\u0120rebuilt": 30080, "\u0120collaborate": 30081, "\u0120raging": 30082, "\u0120nar": 30083, "\u0120demographics": 30084, "\u0120DDR": 30085, "\u0120distrust": 30086, "ossier": 30087, "\u0120Kro": 30088, "\u0120pumpkin": 30089, "\u0120regrets": 30090, "\u0120fatalities": 30091, "\u0120Lens": 30092, "\u0120Ole": 30093, "pd": 30094, "\u0120puppet": 30095, "\u0120Outlook": 30096, "\u0120Stam": 30097, "Ol": 30098, "Fair": 30099, "UU": 30100, "\u0120rewritten": 30101, "\u00c4\u00b1": 30102, "\u0120fascinated": 30103, "\u0120vectors": 30104, "\u0120tribunal": 30105, "uay": 30106, "\u0120Mats": 30107, "\u0120Coins": 30108, "[[": 30109, "\u0120181": 30110, "\u0120renders": 30111, "\u0120Kaepernick": 30112, "\u0120espionage": 30113, "\u0120summ": 30114, "\u0120ditch": 30115, "Account": 30116, "\u0120spreadsheet": 30117, "\u0120mutant": 30118, "past": 30119, "407": 30120, "\u0120dye": 30121, "\u0120initiation": 30122, "\u01204000": 30123, "\u0120punishable": 30124, "\u0120thinner": 30125, "\u0120Khal": 30126, "\u0120intermedi": 30127, "Dun": 30128, "\u0120Gotham": 30129, "\u0120eagerly": 30130, "\u0120vaginal": 30131, "powers": 30132, "VW": 30133, "\u0120WATCHED": 30134, "\u0120predator": 30135, "amsung": 30136, "\u0120disparity": 30137, "\u0120[*": 30138, "\u0120amph": 30139, "\u0120outskirts": 30140, "\u0120Spirits": 30141, "\u0120skeletal": 30142, "\u00d0\u00bb": 30143, "\u0120Rear": 30144, "\u0120issuance": 30145, "\u0120Logic": 30146, "released": 30147, "ZZ": 30148, "\u0120Bound": 30149, "Entry": 30150, "\u0120exits": 30151, "isol": 30152, "\u0120Founder": 30153, "\u0120wre": 30154, "\u0120Greenland": 30155, "\u0120MMO": 30156, "taker": 30157, "INC": 30158, "\u00e3\u0123\u00be": 30159, "\u0120hourly": 30160, "henko": 30161, "\u0120fantasies": 30162, "\u0120disob": 30163, "\u0120demolition": 30164, "\u00e3\u0125\u012d": 30165, "\u0120enlisted": 30166, "ratulations": 30167, "\u0120misguided": 30168, "\u0120ensured": 30169, "\u0120discouraged": 30170, "mort": 30171, "\u0120flank": 30172, "\u0120cess": 30173, "\u0120reacts": 30174, "\u0120Sere": 30175, "sensitive": 30176, "\u0120Serpent": 30177, "assad": 30178, "\u0120247": 30179, "\u0120calmly": 30180, "busters": 30181, "\u0120bleed": 30182, "\u0120Stro": 30183, "\u0120amusement": 30184, "\u0120Antarctica": 30185, "\u0120scept": 30186, "\u0120Gaw": 30187, "aq": 30188, "asonic": 30189, "\u0120sprawling": 30190, "native": 30191, "aturated": 30192, "\u0120Battlefield": 30193, "IVERS": 30194, "EB": 30195, "\u0120Gems": 30196, "\u0120Northwestern": 30197, "\u0120Films": 30198, "\u0120Automatic": 30199, "\u0120apprehend": 30200, "\u00e3\u0123\u00a8": 30201, "\u0120guiName": 30202, "\u0120backend": 30203, "\u0120evidenced": 30204, "geant": 30205, "012": 30206, "\u0120Siege": 30207, "\u0120externalTo": 30208, "\u0120unfocusedRange": 30209, "\u0120guiActiveUnfocused": 30210, "\u0120guiIcon": 30211, "\u0120externalToEVA": 30212, "\u0120externalToEVAOnly": 30213, "Fri": 30214, "chard": 30215, "enaries": 30216, "\u0120chiefs": 30217, "\u0120cf": 30218, "\u0120HUD": 30219, "\u0120corrobor": 30220, "\u0120dB": 30221, "\u0120Taken": 30222, "\u0120Patricia": 30223, "rail": 30224, "\u0120Charm": 30225, "\u0120Libertarian": 30226, "rieve": 30227, "Personal": 30228, "\u0120OUR": 30229, "geries": 30230, "\u0120dumping": 30231, "\u0120neurological": 30232, "itimate": 30233, "\u0120Clintons": 30234, "rafted": 30235, "\u0120Molly": 30236, "\u0120terminals": 30237, "register": 30238, "\u0120flare": 30239, "\u0120encoded": 30240, "\u0120autopsy": 30241, "pel": 30242, "machine": 30243, "\u0120exemptions": 30244, "\u0120Royals": 30245, "distance": 30246, "\u0120drafts": 30247, "\u0120lame": 30248, "\u0120Cunning": 30249, "\u0120spouses": 30250, "\u0120Markets": 30251, "\u0120Carrier": 30252, "\u0120implying": 30253, "\u0120Yak": 30254, "sid": 30255, "\u0120loser": 30256, "\u0120vigilant": 30257, "\u0120impeachment": 30258, "\u0120augmented": 30259, "\u0120Employees": 30260, "\u0120unintended": 30261, "ternally": 30262, "\u0120Watt": 30263, "\u0120recognizable": 30264, "essim": 30265, "\u00e6\u013f": 30266, "\u0120coated": 30267, "rha": 30268, "\u0120lieutenant": 30269, "\u0120Legislation": 30270, "published": 30271, "444": 30272, "013": 30273, "\u0120ideally": 30274, "\u0120Password": 30275, "\u0120simplify": 30276, "\u0120Meta": 30277, "\u0120MRI": 30278, "\u0120pleading": 30279, "organized": 30280, "handler": 30281, "\u0120unravel": 30282, "correct": 30283, "\u0120icy": 30284, "\u0120paranoid": 30285, "\u0120passer": 30286, "\u0120inspections": 30287, "ofer": 30288, "\u0120Healthcare": 30289, "283": 30290, "\u0120Brut": 30291, "iola": 30292, "forge": 30293, "\u0120Medieval": 30294, "MSN": 30295, "ievers": 30296, "\u0120Programming": 30297, "\u00e5\u012b": 30298, "\u0120223": 30299, "mu": 30300, "\u0120CLE": 30301, "uga": 30302, "\u0120shoppers": 30303, "\u0120informative": 30304, "\u0120Plans": 30305, "\u0120supplementation": 30306, "\u0120Tests": 30307, "tyard": 30308, "ocytes": 30309, "\u0120Vega": 30310, "\u0120Gujarat": 30311, "ermanent": 30312, "Except": 30313, "\u0120LOT": 30314, "alla": 30315, "\u0120Cumm": 30316, "\u0120Osw": 30317, "\u0120venom": 30318, "\u0120Debt": 30319, "\u0120DOWN": 30320, "\u0120reunion": 30321, "\u0120muc": 30322, "\u0120Relief": 30323, "\u0120geop": 30324, "\u0120\u00f0\u0141\u013a": 30325, "alogue": 30326, "Anth": 30327, "echo": 30328, "\u0120corros": 30329, "\u0120replication": 30330, "\u0120Blazing": 30331, "\u0120Daughter": 30332, "\u0120inflic": 30333, "\u0120Lindsey": 30334, "\u00d9\u012a": 30335, "284": 30336, "Exit": 30337, "\u0120gloom": 30338, "TAIN": 30339, "\u0120undermining": 30340, "\u0120advising": 30341, "hidden": 30342, "\u0120overflow": 30343, "\u0120gor": 30344, "urdue": 30345, "\u0120echoes": 30346, "enhagen": 30347, "\u0120impuls": 30348, "drug": 30349, "cash": 30350, "\u0120async": 30351, "\u0120mirac": 30352, "atts": 30353, "punk": 30354, "\u0120pivot": 30355, "\u0120Legislative": 30356, "\u0120bloggers": 30357, "\u0120Claw": 30358, "sburg": 30359, "dyl": 30360, "\u0120Recommend": 30361, "\u0120verte": 30362, "\u0120prohibiting": 30363, "\u0120Panther": 30364, "Jonathan": 30365, "\u0120omin": 30366, "\u0120hateful": 30367, "281": 30368, "\u0120Orche": 30369, "\u0120Murdoch": 30370, "downs": 30371, "\u0120asymm": 30372, "GER": 30373, "Always": 30374, "\u0120informs": 30375, "\u0120WM": 30376, "\u0120Pony": 30377, "\u0120Appendix": 30378, "\u0120Arlington": 30379, "Jam": 30380, "\u0120medicinal": 30381, "\u0120Slam": 30382, "ITIES": 30383, "\u0120reaff": 30384, "\u0120Ri": 30385, "FG": 30386, "Spring": 30387, "bool": 30388, "\u0120thighs": 30389, "\u0120markings": 30390, "\u0120Raqqa": 30391, "\u0120Lak": 30392, "poll": 30393, "tsky": 30394, "\u0120Morty": 30395, "\u0120Definition": 30396, "\u0120debunk": 30397, "endered": 30398, "\u0120Leone": 30399, "avers": 30400, "\u0120mortgages": 30401, "Apparently": 30402, "Nic": 30403, "haus": 30404, "\u0120Thousands": 30405, "auld": 30406, "\u0120mash": 30407, "shoot": 30408, "\u0120diarr": 30409, "\u0120consciously": 30410, "Hero": 30411, "eas": 30412, "\u0120Naturally": 30413, "\u0120Destroyer": 30414, "\u0120dashboard": 30415, "services": 30416, "Rog": 30417, "\u0120millennials": 30418, "\u0120invade": 30419, "-(": 30420, "\u0120commissions": 30421, "\u0120Auckland": 30422, "\u0120broadcasts": 30423, "\u0120frontal": 30424, "\u0120crank": 30425, "\u0120Historic": 30426, "\u0120rumours": 30427, "CTV": 30428, "\u0120steril": 30429, "\u0120booster": 30430, "rocket": 30431, "\u00e3\u0124\u00bc": 30432, "utsche": 30433, "\u0120PI": 30434, "\u0120233": 30435, "\u0120Producer": 30436, "\u0120Analytics": 30437, "\u0120invaluable": 30438, "\u0120unintention": 30439, "\u0120CY": 30440, "\u0120scrutin": 30441, "\u0120gigg": 30442, "\u0120engulf": 30443, "\u0120proletariat": 30444, "\u0120hacks": 30445, "\u0120Hew": 30446, "arak": 30447, "\u0120Slime": 30448, "ielding": 30449, "agher": 30450, "\u0120Elliot": 30451, "\u0120telecom": 30452, "\u0120219": 30453, "ultan": 30454, "\u0120Arbor": 30455, "\u0120Scouts": 30456, "Ban": 30457, "\u0120lifespan": 30458, "\u0120blasp": 30459, "388": 30460, "\u0120judiciary": 30461, "\u0120Continental": 30462, "asking": 30463, "McC": 30464, "LED": 30465, "\u0120baggage": 30466, "\u0120Sorcerer": 30467, "\u0120remnants": 30468, "\u0120Griffith": 30469, "etsu": 30470, "\u0120Subaru": 30471, "\u0120Personality": 30472, "designed": 30473, "ushima": 30474, "agnar": 30475, "\u0120recoil": 30476, "\u0120passions": 30477, "\\\":": 30478, "\u0120tee": 30479, "\u0120abolition": 30480, "\u0120Creating": 30481, "jac": 30482, "\u0120194": 30483, "019": 30484, "\u0120pillars": 30485, "riched": 30486, "/\"": 30487, "tk": 30488, "\u0120livelihood": 30489, "\u0120roasted": 30490, "ahon": 30491, "\u0120Hutch": 30492, "assert": 30493, "\u0120dividend": 30494, "\u0120knit": 30495, "\u0120daunting": 30496, "\u0120disturbance": 30497, "\u0120shale": 30498, "\u0120cultivated": 30499, "\u0120refrigerator": 30500, "LB": 30501, "\u0120NET": 30502, "\u0120commercials": 30503, "\u0120thinkers": 30504, "455": 30505, "\u0120chop": 30506, "Broad": 30507, "\u0120suspicions": 30508, "\u0120tagged": 30509, "lifting": 30510, "\u0120stylish": 30511, "\u0120Shields": 30512, "Shortly": 30513, "\u0120tails": 30514, "Auth": 30515, "STE": 30516, "\u0120GAME": 30517, "\u0120seism": 30518, "\u0120Kis": 30519, "ologne": 30520, "\u0120cowork": 30521, "\u0120forcibly": 30522, "\u0120thyroid": 30523, "\u0120PB": 30524, "ANE": 30525, "married": 30526, "horse": 30527, "\u0120polymer": 30528, "\u0120Chal": 30529, "odor": 30530, "DEBUG": 30531, "\u0120Context": 30532, "\u0120bliss": 30533, "\u0120pinpoint": 30534, "\u0120Mathemat": 30535, "legram": 30536, "\u0120Weekend": 30537, "\u0120labelled": 30538, "\u0120bart": 30539, "itles": 30540, "\u0120estrogen": 30541, "\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136\u00e2\u0122\u0136": 30542, "\"'": 30543, "\u0120visibly": 30544, "\u0120outsider": 30545, "aida": 30546, "Area": 30547, "\u0120dissemin": 30548, "\u0120dishonest": 30549, "\u0120Closed": 30550, "\u0120Bulletin": 30551, "\u0120Ramsey": 30552, "sword": 30553, "\u0120XI": 30554, "ourced": 30555, "Same": 30556, "346": 30557, "\u0120Repe": 30558, "\u0120Kou": 30559, "cake": 30560, "emis": 30561, "Cache": 30562, "\u0120Meaning": 30563, "\u0120Enlight": 30564, "onomy": 30565, "\u0120manifestation": 30566, "sworth": 30567, "Jay": 30568, "\u0120chore": 30569, "\u00c3\u00b6r": 30570, "Dream": 30571, "\u0120sanctioned": 30572, "\u0120culturally": 30573, "\u0120Ara": 30574, "Nav": 30575, "\u0120theological": 30576, "\u0120strut": 30577, "\u0120VO": 30578, "\u0120Handbook": 30579, "\u0120constructing": 30580, "\u0120\u00c2\u00b6": 30581, "\u0120Benefits": 30582, "\u0120Psychological": 30583, "sac": 30584, "\u00e5\u00b8": 30585, "policy": 30586, "\u0120Matters": 30587, "\u0120Reported": 30588, "\u0120Byte": 30589, "\u0120vitro": 30590, "\u0120Maiden": 30591, "\u0120lam": 30592, "\u0120Jennings": 30593, "\u0120garment": 30594, "\u0120Rutgers": 30595, "\u0120Stafford": 30596, "\u0120Wellington": 30597, "\u0120intermitt": 30598, "\u0120npm": 30599, "\u0120ordeal": 30600, "\u0120plugged": 30601, "ooming": 30602, "inished": 30603, "framework": 30604, "\u0120timber": 30605, "\u0120cass": 30606, "\u0120850": 30607, "iless": 30608, "\u0120Redux": 30609, "768": 30610, "Stre": 30611, "\u0120surpassed": 30612, "whel": 30613, "\u0120parallels": 30614, "\u0120veil": 30615, "\u0120GI": 30616, "\u0120REST": 30617, "\u0120readiness": 30618, "sort": 30619, "\u0120modifying": 30620, "\u0120Slate": 30621, "ruff": 30622, "\u0120marble": 30623, "\u0120infrared": 30624, "\u0120auditor": 30625, "\u0120FANTASY": 30626, "\u0120Poverty": 30627, "\u0120SPD": 30628, "\u0120\"(": 30629, "Ky": 30630, "RAY": 30631, "\u0120executions": 30632, "\u0120Beverly": 30633, "\u0120Marxism": 30634, "\u0120Burst": 30635, "\u0120Kali": 30636, "estones": 30637, "Clearly": 30638, "Ell": 30639, "\u00e3\u0123\u00a7": 30640, "\u0120Proceedings": 30641, "Token": 30642, "IFIC": 30643, "\u00c3\u00b1a": 30644, "Central": 30645, "\u0120Haley": 30646, "\u0120Drama": 30647, "\u0120formations": 30648, "ORN": 30649, "Books": 30650, "\u0120dominating": 30651, "\u0120Flyers": 30652, "\u0120Companion": 30653, "\u0120disciplined": 30654, "\u0120Yugoslav": 30655, "\u0120Spells": 30656, "\u0120vengeance": 30657, "\u0120landlords": 30658, "Len": 30659, "\u0120Ogre": 30660, "anoia": 30661, "\u0120piercing": 30662, "\u0120congreg": 30663, "\u0120scorer": 30664, "obia": 30665, "\u0120nickel": 30666, "\u0120Learns": 30667, "\u0120rejo": 30668, "\u0120masterpiece": 30669, "Flash": 30670, "\u0120inhabited": 30671, "\u0120OpenGL": 30672, "\u0120Dud": 30673, "\u0120ICO": 30674, "\u0120arter": 30675, "\u0120plur": 30676, "\u0120mastery": 30677, "\u0120longstanding": 30678, "sted": 30679, "\u0120wines": 30680, "\u0120televised": 30681, "\u0120Shrine": 30682, "\u0120Bayern": 30683, "\u0120\u00e2\u0135\u013a": 30684, "\u0120enclosure": 30685, "john": 30686, "\u0120prophets": 30687, "\u0120Resurrection": 30688, "\u0120Orders": 30689, "\u0120uneven": 30690, "rals": 30691, "\u0120dwind": 30692, "\u0120Lah": 30693, "\u0120Sloven": 30694, "378": 30695, "\u0120insistence": 30696, "affle": 30697, "\u0120Clone": 30698, "\u0120hardship": 30699, "\u0120Congressman": 30700, "\u0120plead": 30701, "\u0120reviewers": 30702, "\u0120cured": 30703, "\u01201935": 30704, "asley": 30705, "fake": 30706, "\u0120Thinking": 30707, "ydia": 30708, "PART": 30709, "\u0120Dota": 30710, "oit": 30711, "\u0120whipped": 30712, "\u0120bouncing": 30713, "\u0120Hispanics": 30714, "comings": 30715, "\u0120cannabin": 30716, "\u0120Chambers": 30717, "\u0120Zack": 30718, "Optional": 30719, "\u0120coats": 30720, "\u0120prowess": 30721, "\u0120Norton": 30722, "\u0120plainly": 30723, "\u0120freight": 30724, "\u0120inhibition": 30725, "\u0120clam": 30726, "\u0120303": 30727, "kef": 30728, "aleigh": 30729, "Luke": 30730, "\u0120psycho": 30731, "atorium": 30732, "MED": 30733, "\u0120treaties": 30734, "\u0120indisc": 30735, "\u0120dc": 30736, "OPS": 30737, "\u0120resilient": 30738, "\u0120Interstate": 30739, "\u0120slack": 30740, "\u0120mundane": 30741, "\u0120establishes": 30742, "359": 30743, "\u0120strained": 30744, "\u0120nond": 30745, "Sus": 30746, "\u0120caste": 30747, "arate": 30748, "ieving": 30749, "\u0120unfairly": 30750, "\u0120parser": 30751, "onial": 30752, "ursive": 30753, "Via": 30754, "\u0120Otto": 30755, "\u0120Authorities": 30756, "stroke": 30757, "KR": 30758, "\u0120Mercy": 30759, "\u0120furnished": 30760, "\u0120outset": 30761, "\u0120metic": 30762, "1982": 30763, "olithic": 30764, "\u0120Tent": 30765, "ogical": 30766, "\u0120Aircraft": 30767, "\u0120hides": 30768, "\u0120Became": 30769, "\u0120educators": 30770, "reaching": 30771, "\u0120volatility": 30772, "\u0120toddler": 30773, "\u0120NASCAR": 30774, "\u0120Twelve": 30775, "\u0120Highlights": 30776, "\u0120grape": 30777, "\u0120splits": 30778, "\u0120peasant": 30779, "\u0120reneg": 30780, "\u0120MSI": 30781, "Temp": 30782, "stars": 30783, "\u0120trek": 30784, "\u0120Hyde": 30785, "binding": 30786, "\u0120realism": 30787, "\u0120oxide": 30788, "\u0120Hos": 30789, "\u0120mounts": 30790, "\u0120biting": 30791, "\u0120collapsing": 30792, "\u0120postal": 30793, "\u0120museums": 30794, "\u0120detached": 30795, "\u0120respecting": 30796, "\u0120monopol": 30797, "\u0120workflow": 30798, "\u0120Cake": 30799, "Template": 30800, "\u0120Organisation": 30801, "\u0120persistence": 30802, "369": 30803, "Coming": 30804, "Brad": 30805, "\u0120redundant": 30806, "\u0120GTA": 30807, "\u0120bending": 30808, "\u0120revoked": 30809, "\u0120offending": 30810, "\u0120framing": 30811, "\u0120printf": 30812, "Commun": 30813, "members": 30814, "Outside": 30815, "\u0120construed": 30816, "\u0120coded": 30817, "FORE": 30818, "\u0120chast": 30819, "Chat": 30820, "Indian": 30821, "\u0120Yard": 30822, "?!\"": 30823, "\u0120Ports": 30824, "\u0120Xavier": 30825, "\u0120RET": 30826, "'.\"": 30827, "\u0120Boat": 30828, "ivated": 30829, "icht": 30830, "umerable": 30831, "Ds": 30832, "\u0120Dunn": 30833, "\u0120coffin": 30834, "\u0120securely": 30835, "\u0120Raptors": 30836, "\u0120Bes": 30837, "Installation": 30838, "\u0120inception": 30839, "\u0120Healthy": 30840, "endants": 30841, "\u0120psychologists": 30842, "\u0120Sheikh": 30843, "cultural": 30844, "\u0120BlackBerry": 30845, "shift": 30846, "Fred": 30847, "oche": 30848, "\u0120cakes": 30849, "\u0120SEO": 30850, "\u0120Gian": 30851, "\u0120Asians": 30852, "ogging": 30853, "element": 30854, "\u0120pundits": 30855, "\u0120Vaugh": 30856, "\u0120Gavin": 30857, "\u0120hitter": 30858, "\u0120drowned": 30859, "\u0120chalk": 30860, "\u0120Zika": 30861, "\u0120measles": 30862, "802": 30863, "\u00e2\u0122\u00a6..": 30864, "\u0120AWS": 30865, "]\"": 30866, "\u0120distort": 30867, "\u0120Mast": 30868, "\u0120antibodies": 30869, "\u0120Mash": 30870, "Memory": 30871, "\u0120Uganda": 30872, "\u0120Prob": 30873, "\u0120vomiting": 30874, "\u0120Turns": 30875, "\u0120occupying": 30876, "\u0120evasion": 30877, "\u0120Therapy": 30878, "\u0120promo": 30879, "\u0120electr": 30880, "\u0120blueprint": 30881, "\u0120Dre": 30882, "priced": 30883, "\u0120Depot": 30884, "\u0120alleviate": 30885, "\u0120Somali": 30886, "marg": 30887, "nine": 30888, "\u0120nostalgia": 30889, "\u0120Shepherd": 30890, "\u0120cavalry": 30891, "\u0120torped": 30892, "\u0120Bloody": 30893, "xb": 30894, "\u0120sank": 30895, "\u0120goalt": 30896, "reportprint": 30897, "embedreportprint": 30898, "cloneembedreportprint": 30899, "\u0120Initially": 30900, "\u0120Fischer": 30901, "\u0120noteworthy": 30902, "cern": 30903, "\u0120inefficient": 30904, "rawdownload": 30905, "rawdownloadcloneembedreportprint": 30906, "cation": 30907, "\u0120Dynasty": 30908, "lag": 30909, "DES": 30910, "\u0120distinctly": 30911, "\u0120Estonia": 30912, "\u0120openness": 30913, "\u0120gossip": 30914, "ruck": 30915, "Width": 30916, "\u0120Ibrahim": 30917, "\u0120petroleum": 30918, "\u0120avatar": 30919, "\u0120Hed": 30920, "atha": 30921, "\u0120Hogwarts": 30922, "\u0120caves": 30923, "678": 30924, "\u0120safeguard": 30925, "\u0120Mog": 30926, "isson": 30927, "\u0120Durham": 30928, "slaught": 30929, "\u0120Graduate": 30930, "\u0120subconscious": 30931, "\u0120Excellent": 30932, "\u0120Dum": 30933, "-----": 30934, "\u0120piles": 30935, "\u0120WORK": 30936, "\u0120Garn": 30937, "\u0120Fol": 30938, "\u0120ATM": 30939, "\u0120avoids": 30940, "\u0120Tul": 30941, "\u0120bleak": 30942, "ELY": 30943, "ivist": 30944, "lightly": 30945, "Pers": 30946, "\u0120Dob": 30947, "\u0120LS": 30948, "\u0120insanity": 30949, "\u00ce\u00b5": 30950, "atalie": 30951, "Enlarge": 30952, "\u0120twists": 30953, "\u0120faulty": 30954, "\u0120piracy": 30955, "\u0120impover": 30956, "\u0120rugged": 30957, "\u0120Fashion": 30958, "\u0120sands": 30959, "'?": 30960, "swick": 30961, "\u0120natives": 30962, "\u0120hen": 30963, "\u0120Noise": 30964, "\u00e3\u0125\u0139": 30965, "\u0120greens": 30966, "\u0120freezer": 30967, "\u0120dynasty": 30968, "\u0120Fathers": 30969, "\u0120Newark": 30970, "\u0120archaeological": 30971, "\u0120ot": 30972, "obar": 30973, "\u0120blockade": 30974, "\u0120allerg": 30975, "LV": 30976, "\u0120debit": 30977, "\u0120RFC": 30978, "\u0120Milton": 30979, "\u0120Pressure": 30980, "\u0120willingly": 30981, "\u0120disproportionate": 30982, "\u0120oppressive": 30983, "\u0120diamonds": 30984, "\u0120belongings": 30985, "1970": 30986, "\u0120bells": 30987, "\u0120imperialism": 30988, "\u0120227": 30989, "\u0120exploding": 30990, "\u0120Eclipse": 30991, "\u01201919": 30992, "\u0120rant": 30993, "\u0120nominations": 30994, "347": 30995, "\u0120peacefully": 30996, "rica": 30997, "\u0120FUCK": 30998, "\u0120vibration": 30999, "malink": 31000, "\u0120ropes": 31001, "\u0120Ivanka": 31002, "\u0120Brewery": 31003, "\u0120Booker": 31004, "\u0120Owens": 31005, "goers": 31006, "Services": 31007, "\u0120Snape": 31008, "\u0120191": 31009, "395": 31010, "\u0120299": 31011, "justice": 31012, "\u0120bri": 31013, "\u0120discs": 31014, "\u0120prominently": 31015, "\u0120vulgar": 31016, "\u0120skipping": 31017, "lves": 31018, "\u0120tsunami": 31019, "374": 31020, "\u0120Urug": 31021, "\u0120Eid": 31022, "recated": 31023, "phen": 31024, "\u0120faults": 31025, "\u0120Started": 31026, "950": 31027, "\u0120pi": 31028, "\u0120detector": 31029, "\u0120bastard": 31030, "\u0120validated": 31031, "SpaceEngineers": 31032, "OURCE": 31033, "\u0120(~": 31034, "\u0120unsur": 31035, "\u0120affirmed": 31036, "\u0120fascism": 31037, "\u0120resolving": 31038, "\u0120Chavez": 31039, "\u0120Cyn": 31040, "\u0120detract": 31041, "Lost": 31042, "\u0120rigged": 31043, "\u0120homage": 31044, "\u0120Bruno": 31045, "555": 31046, "eca": 31047, "\u0120presses": 31048, "\u0120humour": 31049, "\u0120spacing": 31050, "\u0120'/": 31051, "olkien": 31052, "Coun": 31053, "OPER": 31054, "Tre": 31055, "Son": 31056, "\u0120Cambodia": 31057, "ierre": 31058, "mong": 31059, "ozy": 31060, "\u0120liquidity": 31061, "\u0120Soviets": 31062, "\u0120Fernando": 31063, "\u0120229": 31064, "\u0120slug": 31065, "\u0120Catalan": 31066, "electric": 31067, "\u0120scenery": 31068, "\u0120Hearth": 31069, "\u0120constrained": 31070, "\u0120goalie": 31071, "\u0120Guidelines": 31072, "\u0120Ammo": 31073, "\u0120Pearson": 31074, "\u0120taxed": 31075, "\u0120fetus": 31076, "Response": 31077, "\u0120Alexis": 31078, "thia": 31079, "Guy": 31080, "\u0120reconstruct": 31081, "\u0120extremes": 31082, "\u0120concluding": 31083, "\u0120Peg": 31084, "ooks": 31085, "\u0120deductions": 31086, "Rose": 31087, "\u0120groundbreaking": 31088, "\u0120Targ": 31089, "\u00e3\u0125\u0123": 31090, "\u0120Reve": 31091, "resource": 31092, "\u0120moons": 31093, "\u0120electromagnetic": 31094, "\u0120amidst": 31095, "\u0120Viktor": 31096, "NESS": 31097, "BACK": 31098, "\u0120commute": 31099, "\u0120Anaheim": 31100, "\u0120fluctuations": 31101, "640": 31102, "\u0120noodles": 31103, "\u0120Copenhagen": 31104, "\u0120Tide": 31105, "\u0120Grizz": 31106, "\u0120SEE": 31107, "\u0120pipelines": 31108, "\u0120scars": 31109, "endo": 31110, "agus": 31111, "\u0120ETF": 31112, "/#": 31113, "\u0120Become": 31114, "448": 31115, "\u0120visc": 31116, "\u0120Recommended": 31117, "\u0120jumper": 31118, "\u0120cognition": 31119, "\u0120assassin": 31120, "\u0120witnessing": 31121, "\u0120Setup": 31122, "\u0120lac": 31123, "vim": 31124, "ISM": 31125, "pages": 31126, "SSL": 31127, "358": 31128, "\u0120adject": 31129, "industrial": 31130, "lore": 31131, "chery": 31132, "\u0120glitter": 31133, "\u0120calf": 31134, "Florida": 31135, "\u0120spoilers": 31136, "\u0120succeeds": 31137, "\u0120chanting": 31138, "\u0120slogans": 31139, "\u0120Tracy": 31140, "Visit": 31141, "rology": 31142, "\u0120mornings": 31143, "\u0120lineage": 31144, "\u0120sip": 31145, "\u0120intensely": 31146, "\u0120flourish": 31147, "\u0120Sleeping": 31148, "\u0120Fem": 31149, "orpor": 31150, "\u0120Klan": 31151, "\u0120Darth": 31152, "hack": 31153, "\u0120Nielsen": 31154, "\u0120tumors": 31155, "\u0120procurement": 31156, "\u0120Yorkshire": 31157, "\u0120raided": 31158, "KY": 31159, "Anna": 31160, "\u0120//[": 31161, "\u0120Disorder": 31162, "\u0120Mustang": 31163, "\u0120Wen": 31164, "\u0120Trying": 31165, "sq": 31166, "\u0120deliveries": 31167, "\u0120shutter": 31168, "\u0120cerebral": 31169, "\u0120bipolar": 31170, "\u0120CN": 31171, "lass": 31172, "jet": 31173, "\u0120debating": 31174, ">:": 31175, "\u0120eagle": 31176, "grades": 31177, "\u0120Dixon": 31178, "UGC": 31179, "MAS": 31180, "\u0120Draco": 31181, "\u0120Machines": 31182, "affer": 31183, "\u0120eman": 31184, "\u00c2\u00b2": 31185, "pron": 31186, "\u0120Gym": 31187, "\u0120comparatively": 31188, "\u0120Tribunal": 31189, "PRO": 31190, "\u0120lex": 31191, "\u0120fertile": 31192, "\u0120depressing": 31193, "\u0120superficial": 31194, "essential": 31195, "\u0120Hunters": 31196, "gp": 31197, "\u0120prominence": 31198, "Liber": 31199, "\u0120Ancest": 31200, "otechnology": 31201, "\u0120mocking": 31202, "\u0120Traff": 31203, "\u0138\u013c": 31204, "Medium": 31205, "Iraq": 31206, "\u0120psychiatrist": 31207, "Quantity": 31208, "\u0120Lect": 31209, "\u0120noisy": 31210, "520": 31211, "GY": 31212, "\u0120slapped": 31213, "\u0120MTV": 31214, "\u0120para": 31215, "pull": 31216, "Multiple": 31217, "asher": 31218, "\u0120nour": 31219, "\u0120Seg": 31220, "Spell": 31221, "vous": 31222, "ordial": 31223, "Senior": 31224, "\u0120Goldberg": 31225, "\u0120Plasma": 31226, "need": 31227, "\u0120messenger": 31228, "eret": 31229, "\u0120teamed": 31230, "\u0120literacy": 31231, "\u0120Leah": 31232, "\u0120Doyle": 31233, "\u0120emitted": 31234, "UX": 31235, "\u0120evade": 31236, "\u0120maze": 31237, "\u0120wrongly": 31238, "\u0120Lars": 31239, "\u0120stereotype": 31240, "\u0120pledges": 31241, "\u0120aroma": 31242, "\u0120MET": 31243, "\u0120acre": 31244, "\u0120OD": 31245, "\u0120ff": 31246, "\u0120breweries": 31247, "\u0120Hilton": 31248, "undle": 31249, "\u0120Kak": 31250, "\u0120Thankfully": 31251, "\u0120Canucks": 31252, "inctions": 31253, "\u0120Appears": 31254, "\u0120coer": 31255, "\u0120undermined": 31256, "rovers": 31257, "Andre": 31258, "\u0120blaze": 31259, "umers": 31260, "\u0120famine": 31261, "amphetamine": 31262, "ulkan": 31263, "Amount": 31264, "\u0120desperation": 31265, "wikipedia": 31266, "development": 31267, "\u0120Corinth": 31268, "ussia": 31269, "Jackson": 31270, "LI": 31271, "Native": 31272, "Rs": 31273, "Ohio": 31274, "\u0120Kathleen": 31275, "Fortunately": 31276, "\u0120attendant": 31277, "\u0120Preferred": 31278, "\u0120Didn": 31279, "\u0120Vs": 31280, "Mis": 31281, "\u0120respondent": 31282, "\u0120boun": 31283, "stable": 31284, "\u0120paved": 31285, "\u0120unexpl": 31286, "\u0120Cheney": 31287, "LM": 31288, "\u0120Cull": 31289, "blown": 31290, "\u0120confronting": 31291, "ocese": 31292, "serving": 31293, "Wi": 31294, "\u0120Lithuania": 31295, "anni": 31296, "\u0120stalk": 31297, "hd": 31298, "\u0120vener": 31299, "APH": 31300, "ynchronous": 31301, "URR": 31302, "umably": 31303, "historic": 31304, "Half": 31305, "Hay": 31306, "\u0120resilience": 31307, "spection": 31308, "\u0120abandoning": 31309, "Obs": 31310, "\u0120Debbie": 31311, "\u0120gradient": 31312, "\u0120Plaint": 31313, "\u0120Canal": 31314, "ARCH": 31315, "\u0120expansive": 31316, "\u0120fung": 31317, "\u0120bounced": 31318, "Und": 31319, "\u0120precautions": 31320, "\u0120clarification": 31321, "\u0120dagger": 31322, "\u0120grips": 31323, "\u0120\u00c2\u00b5": 31324, "\u0120Rivera": 31325, "\u0120Undead": 31326, "isites": 31327, "\u0120FIRST": 31328, "\u00c3\u00b1o": 31329, "audi": 31330, "\u0120hostages": 31331, "\u0120compliant": 31332, "\u0120alumni": 31333, "Seven": 31334, "\u0120cybersecurity": 31335, "either": 31336, "Collect": 31337, "\u0120invariably": 31338, "\u0120Soci": 31339, "\u0120lawmaker": 31340, "\u0120ale": 31341, "\u0120Personally": 31342, "Nazi": 31343, "\u0120customization": 31344, "\u0120Proc": 31345, "\u0120Saskatchewan": 31346, "eaturing": 31347, "\u0120spared": 31348, "\u0120discontinued": 31349, "\u0120computational": 31350, "\u0120Motorola": 31351, "\u0120supremacist": 31352, "governmental": 31353, "\u0120paradise": 31354, "\u0120Downing": 31355, "\u0120Nikon": 31356, "\u0120catalyst": 31357, "berra": 31358, "Toronto": 31359, "875": 31360, "beta": 31361, "\u0120Macron": 31362, "\u0120unrealistic": 31363, "vector": 31364, "\u0120Vehicles": 31365, "itiveness": 31366, "\u0120RV": 31367, "\u0120Colbert": 31368, "sin": 31369, "oji": 31370, "entin": 31371, "\u0120Krish": 31372, "hello": 31373, "ffield": 31374, "oky": 31375, "\u0120Tate": 31376, "\u0120maple": 31377, "\u0120aids": 31378, "chemical": 31379, "334": 31380, "nuts": 31381, "\u0120Warp": 31382, "\u0120xx": 31383, "\u0120Robb": 31384, "umerous": 31385, "_-_": 31386, "ftime": 31387, "\u0120VW": 31388, "\u0120winger": 31389, "\u0120Dome": 31390, "tools": 31391, "\u0120PV": 31392, "\u0120Georgetown": 31393, "\u0120geared": 31394, "\u0120jihadists": 31395, "\u0120cp": 31396, "\u0120steroids": 31397, "Mother": 31398, "clerosis": 31399, "\u0120DRM": 31400, "nesia": 31401, "\u0120linger": 31402, "\u0120immersive": 31403, "\u0120COUN": 31404, "\u0120outweigh": 31405, "ensual": 31406, "Band": 31407, "\u0120transforms": 31408, "matched": 31409, "psons": 31410, "\u0120Judicial": 31411, "factor": 31412, "\u0120referral": 31413, "\u0120oddly": 31414, "\u0120Wenger": 31415, "Bring": 31416, "\u0120Bows": 31417, "602": 31418, "ICLE": 31419, "\u0120lions": 31420, "\u0120Academic": 31421, "\u0120Thorn": 31422, "\u0120Raider": 31423, "kefeller": 31424, "Storage": 31425, "Lower": 31426, "\u0120Ort": 31427, "\u0120Equality": 31428, "ALT": 31429, "\u0120SOC": 31430, "Types": 31431, "\u0120lyn": 31432, "\u0120Asset": 31433, "coat": 31434, "TPP": 31435, "CVE": 31436, "\u0120Pioneer": 31437, "application": 31438, "Modern": 31439, "\u0120HK": 31440, "Environment": 31441, "Alright": 31442, "Rain": 31443, "IPP": 31444, "\u0120Shiite": 31445, "\u0120mound": 31446, "\u0120Abilities": 31447, "condition": 31448, "Staff": 31449, "\u0120competence": 31450, "\u0120Moor": 31451, "\u0120Diablo": 31452, "\u0120withheld": 31453, "\u0120ostensibly": 31454, "\u0120Brom": 31455, "\u0120msg": 31456, "\u0120denomin": 31457, "\u0120References": 31458, "\u0120FP": 31459, "\u0120plunged": 31460, "\u0120pamph": 31461, "moving": 31462, "central": 31463, "\u0120downright": 31464, "\u0120fading": 31465, "Tal": 31466, "Typ": 31467, "\u0120Thy": 31468, "ukes": 31469, "ithe": 31470, "\u0120ove": 31471, "\u0120battled": 31472, "\u0120seafood": 31473, "\u0120figur": 31474, "\u0120RD": 31475, "crop": 31476, "\u0120squads": 31477, "{\\": 31478, "\u00e0\u00b9": 31479, "\u0120Eh": 31480, "\u0120interviewing": 31481, "\u0120Qin": 31482, "\u0120aspiring": 31483, "PLIC": 31484, "\u0120clauses": 31485, "\u0120Gast": 31486, "\u0120Nir": 31487, "\u0120luggage": 31488, "\u0120hose": 31489, "\u0120systemd": 31490, "\u0120descending": 31491, "\u0120Revised": 31492, "\u0120Rails": 31493, "align": 31494, "709": 31495, "337": 31496, "\u0120fug": 31497, "charging": 31498, "tags": 31499, "\u0120uter": 31500, "kish": 31501, "WARNING": 31502, "490": 31503, "profits": 31504, "\u0120voyage": 31505, "\u0120ace": 31506, "\u0120Vanguard": 31507, "\u0120Tanks": 31508, "\u0120Muk": 31509, "\u0120226": 31510, "Safe": 31511, "Armor": 31512, "\u0120volcanic": 31513, "\u0120womb": 31514, "\u0120MIL": 31515, "\u0120beginner": 31516, "\u0120Recogn": 31517, "\u0120AAP": 31518, "PLAY": 31519, ")!": 31520, "\u0120detecting": 31521, "cn": 31522, "\u0120breaches": 31523, "Basically": 31524, "\u0120Pag": 31525, "\u0120Municipal": 31526, "\u0120Indie": 31527, "\u0120Laf": 31528, "\u0120Disable": 31529, "\u0120Olson": 31530, "\u0120restrained": 31531, "\u0120rulings": 31532, "\u0120humane": 31533, "events": 31534, "\u0120Cinema": 31535, "displayText": 31536, "\u0120Hatch": 31537, "actionDate": 31538, "onnaissance": 31539, "\u0120assaulting": 31540, "\u0120Lug": 31541, "CHAT": 31542, "\u0120vigorous": 31543, "\u0120Perse": 31544, "\u0120intolerance": 31545, "\u0120Snapchat": 31546, "\u0120Sharks": 31547, "\u0120dummy": 31548, "\u0120Diagn": 31549, "\u0120Guitar": 31550, "imeters": 31551, "403": 31552, "REG": 31553, "Ax": 31554, "\u0120separates": 31555, "\u0120Mahm": 31556, "\u0120tv": 31557, "jah": 31558, "OOL": 31559, "Circ": 31560, "\u0120Windsor": 31561, "ussian": 31562, "\u0120intuition": 31563, "\u0120disdain": 31564, "\u0120Donovan": 31565, "\u0120221": 31566, "Emb": 31567, "\u0120condemning": 31568, "\u0120generosity": 31569, "zzy": 31570, "\u0120panties": 31571, "\u0120Prevent": 31572, "ActionCode": 31573, "ANA": 31574, "342": 31575, "externalActionCode": 31576, "\u0120specifying": 31577, "\u0120crystall": 31578, "Jere": 31579, "\u0120rupt": 31580, "\u0120Apprentice": 31581, "\u0120profiling": 31582, "\u00d0\u00ba": 31583, "Strike": 31584, "\u0120sideline": 31585, "\u0120obligated": 31586, "\u0120occult": 31587, "\u0120bureaucratic": 31588, "antically": 31589, "rupted": 31590, "negative": 31591, "\u0120Ethiopia": 31592, "\u0120Civic": 31593, "\u0120insiders": 31594, "eligible": 31595, "\u0120TVs": 31596, "\u0120BAR": 31597, "\u0120TI": 31598, "iologist": 31599, "\u0120AIR": 31600, "\u0120substituted": 31601, "Arab": 31602, "\u0120Saul": 31603, "\u0120Yog": 31604, "prem": 31605, "\u0120builders": 31606, "\u0120stationary": 31607, "\u0120doubtful": 31608, "\u0120vigorously": 31609, "\u0120thrilling": 31610, "Physical": 31611, "\u0120Carey": 31612, "\u0120Hydra": 31613, "geoning": 31614, "\u0120Sly": 31615, "yton": 31616, "\u0120borrowers": 31617, "\u0120Parkinson": 31618, "\u0120\u00eb": 31619, "\u0120Jamaica": 31620, "\u0120satir": 31621, "\u0120insurgents": 31622, "\u0120Firm": 31623, "\u0120isot": 31624, "\u0120Karn": 31625, "ourning": 31626, "akens": 31627, "docs": 31628, "little": 31629, "\u0120Monaco": 31630, "CLASS": 31631, "Turkey": 31632, "Ly": 31633, "\u0120Conan": 31634, "assic": 31635, "\u0120starred": 31636, "\u0120Pacers": 31637, "eties": 31638, "\u0120tipping": 31639, "Moon": 31640, "\u0120Rw": 31641, "same": 31642, "\u0120cavity": 31643, "\u0120goof": 31644, "\u0120Zo": 31645, "Shock": 31646, "ummer": 31647, "\u0120emphasizes": 31648, "\u0120regrett": 31649, "\u0120novelty": 31650, "\u0120envy": 31651, "\u0120Passive": 31652, "rw": 31653, "505": 31654, "\u0120indifferent": 31655, "\u0120Rica": 31656, "\u0120Himself": 31657, "\u0120Freddie": 31658, "\u0120adip": 31659, "\u00e4\u00b8\u0122": 31660, "\u0120breakout": 31661, "\u0120hurried": 31662, "\u0120Huang": 31663, "\u0120Disk": 31664, "\u0120roaming": 31665, "?????-?????-": 31666, "UV": 31667, "\u0120Ricky": 31668, "\u0120Sigma": 31669, "\u0120marginalized": 31670, "\u0120edits": 31671, "\u0120304": 31672, "memory": 31673, "\u0120specimen": 31674, "293": 31675, "\u00e3\u0123\u00af": 31676, "\u0120vertically": 31677, "\u0120audition": 31678, "\u0120Heck": 31679, "\u0120caster": 31680, "\u0120Holdings": 31681, "adal": 31682, "\u0120Cron": 31683, "\u0120Liam": 31684, "\u0120deflect": 31685, "Pick": 31686, "\u0120Debug": 31687, "REF": 31688, "\u0120versatility": 31689, "othes": 31690, "classified": 31691, "\u0120Mahar": 31692, "\u0120Hort": 31693, "Counter": 31694, "stasy": 31695, "noticed": 31696, "331": 31697, "\u0120Shim": 31698, "fuck": 31699, "\u0120Bie": 31700, "\u0120airing": 31701, "\u0120Protein": 31702, "\u0120Holding": 31703, "\u0120spectators": 31704, "iliated": 31705, "\u0120Thatcher": 31706, "nosis": 31707, "\u00e3\u0125\u00bc\u00e3\u0125\u00b3": 31708, "Tele": 31709, "Boston": 31710, "\u0120Templ": 31711, "stay": 31712, "\u0120declarations": 31713, "479": 31714, "Volume": 31715, "\u0120Designer": 31716, "\u0120Overwatch": 31717, "idae": 31718, "\u0120onwards": 31719, "\u0120nets": 31720, "\u0120Manila": 31721, "particularly": 31722, "\u0120politic": 31723, "oother": 31724, "\u0120portraits": 31725, "\u0120pavement": 31726, "cffff": 31727, "\u0120saints": 31728, "\u0120beginners": 31729, "ESPN": 31730, "\u0120shortcomings": 31731, "\u00e2\u0137\u0132\u00e2\u0137\u0132": 31732, "\u0120comet": 31733, "\u0120Organic": 31734, "quel": 31735, "\u0120hospitalized": 31736, "Break": 31737, "\u0120peel": 31738, "dylib": 31739, "aspx": 31740, "urances": 31741, "\u0120TIM": 31742, "Pg": 31743, "\u0120readable": 31744, "\u0120Malik": 31745, "\u0120muzzle": 31746, "\u0120benchmarks": 31747, "dal": 31748, "\u0120Vacc": 31749, "\u0120Hicks": 31750, "609": 31751, "\u0120Biblical": 31752, "heng": 31753, "\u0120overload": 31754, "\u0120Civilization": 31755, "\u0120immoral": 31756, "\u0120fries": 31757, "\u00e3\u0124\u0134": 31758, "\u0120reproduced": 31759, "\u0120formulation": 31760, "jug": 31761, "irez": 31762, "gear": 31763, "\u0120coached": 31764, "MpServer": 31765, "\u0120SJ": 31766, "\u0120Kw": 31767, "Init": 31768, "deal": 31769, "\u0120Oro": 31770, "\u0120Loki": 31771, "\u0120Songs": 31772, "\u0120232": 31773, "\u0120Louise": 31774, "asionally": 31775, "\u0120uncond": 31776, "ollywood": 31777, "\u0120progressives": 31778, "\u0120Enough": 31779, "\u0120Doe": 31780, "\u0120wreckage": 31781, "\u0120brushed": 31782, "\u0120BaseType": 31783, "\u0120zoning": 31784, "ishable": 31785, "hetically": 31786, "\u0120Caucus": 31787, "\u0120Hue": 31788, "\u0120karma": 31789, "\u0120Sporting": 31790, "\u0120trader": 31791, "\u0120seeming": 31792, "\u0120Capture": 31793, "430": 31794, "bish": 31795, "\u0120tunes": 31796, "\u0120indoors": 31797, "\u0120Sphere": 31798, "\u0120Dancing": 31799, "TERN": 31800, "\u0120nob": 31801, "\u0120GST": 31802, "maps": 31803, "\u0120peppers": 31804, "Fit": 31805, "\u0120oversees": 31806, "\u0120Rabbi": 31807, "\u0120Ruler": 31808, "vertising": 31809, "office": 31810, "xxx": 31811, "\u0120raft": 31812, "Changed": 31813, "\u0120textbooks": 31814, "Links": 31815, "\u0120Omn": 31816, "\u00e3\u0122\u0133": 31817, "\u0120inconvenience": 31818, "\u0120Donetsk": 31819, "=~": 31820, "\u0120implicitly": 31821, "\u0120boosts": 31822, "\u0120Bones": 31823, "\u0120Boom": 31824, "Courtesy": 31825, "\u0120sensational": 31826, "ANY": 31827, "\u0120greedy": 31828, "eden": 31829, "\u0120inexper": 31830, "\u0120Ler": 31831, "\u0120Vale": 31832, "\u0120tighten": 31833, "\u0120EAR": 31834, "\u0120Num": 31835, "\u0120ancestor": 31836, "Sent": 31837, "\u0120Horde": 31838, "urgical": 31839, "allah": 31840, "\u0120sap": 31841, "amba": 31842, "\u0120Spread": 31843, "twitch": 31844, "\u0120grandson": 31845, "\u0120fracture": 31846, "\u0120moderator": 31847, "\u0120Seventh": 31848, "\u0120Reverse": 31849, "\u0120estimation": 31850, "Choose": 31851, "\u0120parach": 31852, "\u0120barric": 31853, "\u00e3\u0122\u0132": 31854, "\u0120compass": 31855, "\u0120allergic": 31856, "\u00e2\u0122\u0137": 31857, "OTHER": 31858, "errilla": 31859, "\u0120wagon": 31860, "\u0120zinc": 31861, "\u0120rubbed": 31862, "\u0120Fuller": 31863, "\u0120Luxembourg": 31864, "\u0120Hoover": 31865, "\u0120liar": 31866, "\u0120Evening": 31867, "\u0120Cobb": 31868, "esteem": 31869, "\u0120selector": 31870, "\u0120Brawl": 31871, "isance": 31872, "\u0120Ek": 31873, "\u0120troop": 31874, "\u0120guts": 31875, "\u0120Appeal": 31876, "\u0120Tibetan": 31877, "\u0120routines": 31878, "\u0120Ment": 31879, "\u0120summarized": 31880, "steamapps": 31881, "\u0120tranqu": 31882, "\u01201929": 31883, "oran": 31884, "\u0120Authent": 31885, "\u0120gmaxwell": 31886, "\u0120apprehens": 31887, "\u0120poems": 31888, "\u0120sausage": 31889, "\u0120Webster": 31890, "urus": 31891, "\u0120themed": 31892, "\u0120lounge": 31893, "\u0120charger": 31894, "Spoiler": 31895, "\u0120spilled": 31896, "hog": 31897, "\u0120Sunder": 31898, "\u0120Ain": 31899, "\u0120Angry": 31900, "\u0120disqual": 31901, "\u0120Frequency": 31902, "\u0120Ethernet": 31903, "\u0120helper": 31904, "Percent": 31905, "\u0120horrifying": 31906, "\u0120ail": 31907, "\u0120Allan": 31908, "EEE": 31909, "\u0120Crossing": 31910, "449": 31911, "\u0120holog": 31912, "\u0120Puzzles": 31913, "\u0120Goes": 31914, "erenn": 31915, "604": 31916, "\u00e3\u0123\u0131": 31917, "\u0120Rafael": 31918, "\u0120atten": 31919, "\u0120Emanuel": 31920, "\u0120upro": 31921, "\u0120Susp": 31922, "Psych": 31923, "\u0120Trainer": 31924, "\u0120NES": 31925, "\u0120Hunts": 31926, "becue": 31927, "\u0120counselor": 31928, "Rule": 31929, "\u0120toxins": 31930, "\u0120banners": 31931, "rifice": 31932, "\u0120greeting": 31933, "\u0120frenzy": 31934, "\u0120allocate": 31935, "\u0120*)": 31936, "expr": 31937, "503": 31938, "\u0120Chick": 31939, "\u0120Torn": 31940, "\u0120consolidation": 31941, "\u0120Fletcher": 31942, "switch": 31943, "frac": 31944, "clips": 31945, "\u0120McKin": 31946, "\u0120Lunar": 31947, "Month": 31948, "ITCH": 31949, "\u0120scholarly": 31950, "raped": 31951, "398": 31952, "\u01201910": 31953, "\u0120egreg": 31954, "\u0120insecure": 31955, "\u0120victorious": 31956, "cffffcc": 31957, "\u0120singled": 31958, "\u0120elves": 31959, "\u0120Wond": 31960, "burst": 31961, "\u0120camoufl": 31962, "\u0120BLACK": 31963, "\u0120conditioned": 31964, "\u00e7\u012b": 31965, "answered": 31966, "\u0120compulsory": 31967, "ascist": 31968, "\u0120podcasts": 31969, "\u0120Frankfurt": 31970, "bnb": 31971, "\u0120neoliberal": 31972, "\u0120Keyboard": 31973, "\u0120Belle": 31974, "warm": 31975, "\u0120trusts": 31976, "\u0120insured": 31977, "\u0120Bucc": 31978, "usable": 31979, "607": 31980, "\u0120Plains": 31981, "\u01201890": 31982, "\u0120sabotage": 31983, "\u0120lodged": 31984, "felt": 31985, "\u0120ga": 31986, "\u0120Narc": 31987, "\u0120Salem": 31988, "\u0120seventy": 31989, "\u0120Blank": 31990, "pocket": 31991, "\u0120whisper": 31992, "\u0120mating": 31993, "omics": 31994, "\u0120Salman": 31995, "\u0120Kad": 31996, "\u0120angered": 31997, "\u0120collisions": 31998, "\u0120extraordinarily": 31999, "\u0120coercion": 32000, "Ghost": 32001, "birds": 32002, "\u00e8\u0122": 32003, "kok": 32004, "\u0120permissible": 32005, "avorable": 32006, "\u0120pointers": 32007, "\u0120dissip": 32008, "aci": 32009, "\u0120theatrical": 32010, "\u0120Cosmic": 32011, "\u0120forgetting": 32012, "\u0120finalized": 32013, "\u00e5\u00a4\u00a7": 32014, "yout": 32015, "library": 32016, "\u0120booming": 32017, "\u0120Believe": 32018, "\u0120Teacher": 32019, "\u0120Liv": 32020, "\u0120GOODMAN": 32021, "\u0120Dominican": 32022, "ORED": 32023, "\u0120Parties": 32024, "\u0120precipitation": 32025, "\u0120Slot": 32026, "Roy": 32027, "\u0120Combined": 32028, "\u0120integrating": 32029, "\u0120chrome": 32030, "\u0120intestinal": 32031, "\u0120Rebell": 32032, "\u0120matchups": 32033, "\u0120blockbuster": 32034, "\u0120Loren": 32035, "\u0120Levy": 32036, "\u0120preaching": 32037, "\u0120Sending": 32038, "\u0120Purpose": 32039, "rax": 32040, "fif": 32041, "\u0120authoritative": 32042, "\u0120PET": 32043, "astical": 32044, "\u0120dishon": 32045, "\u0120chatting": 32046, "\u0120\"$:/": 32047, "Connection": 32048, "\u0120recreate": 32049, "\u0120delinqu": 32050, "\u0120broth": 32051, "\u0120Dirty": 32052, "\u0120Admin": 32053, "zman": 32054, "\u0120scholarships": 32055, "\u0120253": 32056, "contact": 32057, "alsa": 32058, "767": 32059, "creen": 32060, "abbage": 32061, "\u01201915": 32062, "\u0120blended": 32063, "\u0120alarmed": 32064, "Language": 32065, "356": 32066, "\u0120blends": 32067, "\u0120Changed": 32068, "Wolf": 32069, "\u0120hepat": 32070, "Creating": 32071, "\u0120persecut": 32072, "\u0120sweetness": 32073, "arte": 32074, "\u0120forfeiture": 32075, "\u0120Roberto": 32076, "impro": 32077, "NFL": 32078, "\u0120Magnet": 32079, "Detailed": 32080, "\u0120insignificant": 32081, "\u0120POLIT": 32082, "\u0120BBQ": 32083, "\u0120CPS": 32084, "\u0120seaw": 32085, "aminer": 32086, "mL": 32087, "endif": 32088, "finals": 32089, "\u0120265": 32090, "uish": 32091, "\u0120})": 32092, "\u0120Problems": 32093, "\u0120emblem": 32094, "\u0120seriousness": 32095, "\u0120parsing": 32096, "\u0120substitution": 32097, "\u0120pressured": 32098, "\u0120recycled": 32099, "aleb": 32100, "Ruby": 32101, "\u0120proficiency": 32102, "Driver": 32103, "\u0120Wester": 32104, ":'": 32105, "AFTA": 32106, "\u0120mantle": 32107, "\u0120Clayton": 32108, "flag": 32109, "\u0120practitioner": 32110, "covered": 32111, "\u0120Struct": 32112, "addafi": 32113, "425": 32114, "\u0120Township": 32115, "\u0120Hydro": 32116, "Louis": 32117, "343": 32118, "\u0120condo": 32119, "\u0120Tao": 32120, "\u0120utilization": 32121, "\u0120nausea": 32122, "\u0120Dems": 32123, "ridges": 32124, "pause": 32125, "\u0120formulas": 32126, "\u0120challenger": 32127, "376": 32128, "\u0120defective": 32129, "\u0120Railway": 32130, "\u0120PubMed": 32131, "\u0120yogurt": 32132, "lbs": 32133, "\u0120Norfolk": 32134, "OPE": 32135, "\u0120Moody": 32136, "\u0120distributor": 32137, "\u0120scrolls": 32138, "\u0120extracts": 32139, "Stan": 32140, "\u0120viability": 32141, "\u0120exposes": 32142, "\u0120starvation": 32143, "\u0120Steps": 32144, "\u0120Dodd": 32145, "few": 32146, "STD": 32147, "332": 32148, "\u0120closures": 32149, "\u0120complementary": 32150, "\u0120Sasha": 32151, "umpy": 32152, "\u0120monet": 32153, "\u0120articulate": 32154, "\u0120Doct": 32155, "killer": 32156, "\u0120scrim": 32157, "\u0120264": 32158, "\u0120prostitutes": 32159, "\u0120severed": 32160, "\u0120attachments": 32161, "\u0120cooled": 32162, "Lev": 32163, "\u0120Falk": 32164, "fail": 32165, "\u0120policeman": 32166, "\u0120Dag": 32167, "\u0120prayed": 32168, "\u0120Kernel": 32169, "\u0120clut": 32170, "\u0120cath": 32171, "\u0120anomaly": 32172, "Storm": 32173, "emaker": 32174, "\u0120Breakfast": 32175, "uli": 32176, "oire": 32177, "JJ": 32178, "hz": 32179, "Operation": 32180, "\u0120Sick": 32181, "354": 32182, "\u0120Guatemala": 32183, "Rate": 32184, "\u0120exposures": 32185, "faces": 32186, "\u0120Archae": 32187, "raf": 32188, "\u0120Mia": 32189, "\u01202025": 32190, "\u0120opaque": 32191, "\u0120disguised": 32192, "\u0120Headquarters": 32193, "Sah": 32194, "\u0120pots": 32195, "978": 32196, "\u0120Malf": 32197, "\u0120frowned": 32198, "\u0120poisonous": 32199, "\u0120Convers": 32200, "eeks": 32201, "\u0120crab": 32202, ".\"\"": 32203, "\u0120treason": 32204, "\u0120ranc": 32205, "\u0120escalating": 32206, "\u0120warr": 32207, "\u0120mobs": 32208, "\u0120lamps": 32209, "\u0120Sunshine": 32210, "\u0120Brunswick": 32211, "Phones": 32212, "\u0120spelled": 32213, "\u0120Skip": 32214, "\u01202050": 32215, "\u01201911": 32216, "\u0120Pluto": 32217, "\u0120Amend": 32218, "\u0120meats": 32219, "387": 32220, "\u0120stomp": 32221, "\u0120Zhou": 32222, "\u0120Leviathan": 32223, "\u0120Hazard": 32224, "adv": 32225, "\u0120Orwell": 32226, "\u0120aloud": 32227, "\u0120bumper": 32228, "\u0120Anarch": 32229, "ubuntu": 32230, "\u0120Serious": 32231, "fitting": 32232, "\u0120Optional": 32233, "\u0120Cecil": 32234, "REAM": 32235, "\u0120serotonin": 32236, "\u0120cultivate": 32237, "agogue": 32238, "}\\": 32239, "\u0120mosques": 32240, "\u0120Sunny": 32241, "\u0120reactive": 32242, "revolution": 32243, "\u0120Lup": 32244, "\u0120Fedora": 32245, "\u0120defenseman": 32246, "\u0120VID": 32247, "istine": 32248, "\u0120drowning": 32249, "\u0120Broadcasting": 32250, "\u0120thriller": 32251, "\u0120Scy": 32252, "\u0120accelerating": 32253, "\u0120directs": 32254, "odied": 32255, "bike": 32256, "duration": 32257, "\u0120painfully": 32258, "Redd": 32259, "\u0120productions": 32260, "\u0120gag": 32261, "\u0120whist": 32262, "\u0120sock": 32263, "\u0120infinitely": 32264, "\u0120Concern": 32265, "\u0120Citadel": 32266, "\u0120lieu": 32267, "\u0120candles": 32268, "ogeneous": 32269, "arger": 32270, "\u0120heavenly": 32271, "inflammatory": 32272, "Performance": 32273, "Cs": 32274, "ructose": 32275, "azaki": 32276, "\u0120pessim": 32277, "\u0120inference": 32278, "\u0120powd": 32279, "\u0120Zoe": 32280, "\u0120paints": 32281, "\u0120dazz": 32282, "pta": 32283, "-----------": 32284, "\u0120inspir": 32285, "\u0120Experimental": 32286, "\u0120Knife": 32287, "regor": 32288, "bors": 32289, "\u0120showers": 32290, "romeda": 32291, "\u0120saint": 32292, "\u0120benign": 32293, "\u0120Jiang": 32294, "\u0120envisioned": 32295, "\u0120shroud": 32296, "IFT": 32297, "HO": 32298, "\u0120shuff": 32299, "\u0120ICC": 32300, "\u0120segreg": 32301, "\u0120revisit": 32302, "ighthouse": 32303, "Li": 32304, "\u0120substrate": 32305, "\u0120Seas": 32306, "\u0120Reward": 32307, "\u0120Hep": 32308, "\u0120Brass": 32309, "sbm": 32310, "\u0120eliminates": 32311, "\u0120stamina": 32312, "\u0120VAT": 32313, "\u0120Loan": 32314, "\u0120constraint": 32315, "\u0120appropriated": 32316, "\u0120pes": 32317, "\u0120ALE": 32318, "ranging": 32319, "\u0120404": 32320, "392": 32321, "\u0120intellectuals": 32322, "achu": 32323, "\u0120restructuring": 32324, "\u0120Levin": 32325, "\u0120runes": 32326, "\u0120delightful": 32327, "\u0120carbohydrates": 32328, "\u0120Models": 32329, "\u0120Expo": 32330, "\u0120transporting": 32331, "alloc": 32332, "\u0120ringing": 32333, "Samsung": 32334, "\u0120scarcely": 32335, "\u0120URLs": 32336, "\u0120MAS": 32337, "\u0120prototypes": 32338, "\u0120narrator": 32339, "\u0120CPUs": 32340, "cdn": 32341, "\u0120Barton": 32342, "\u0120decidedly": 32343, "\u0120Shu": 32344, "ixir": 32345, "ocious": 32346, "\u0120Myst": 32347, "Nintendo": 32348, "\u0120reuse": 32349, "\u0120forgiven": 32350, "Few": 32351, "inical": 32352, "nat": 32353, "\u0120seamless": 32354, "\u0120Eva": 32355, "\u0120EVE": 32356, "\u0120JO": 32357, "landers": 32358, "\u0120softer": 32359, "negie": 32360, "\u0120transient": 32361, "\u0120orbital": 32362, "\u0120fulfil": 32363, "\u0120Kom": 32364, "Hopefully": 32365, "\u0120dynamically": 32366, "\u0120Hunger": 32367, "\u00e5\u013d": 32368, "\u0120Armenia": 32369, "elman": 32370, "berto": 32371, "\u0120pige": 32372, "\u0120IDs": 32373, "limit": 32374, "\u0120veins": 32375, "\u0120soaring": 32376, "packs": 32377, "Golden": 32378, "\u0120Crab": 32379, "istor": 32380, "\u0120RPM": 32381, "\u0120$$": 32382, "gression": 32383, "\u0120jihadist": 32384, "\u0120gamble": 32385, "\u0120careg": 32386, "\u0120inflated": 32387, "Face": 32388, "\u0120Firearms": 32389, "\u0120Emmanuel": 32390, "\u00e2\u013f": 32391, "\u0120shocks": 32392, "grab": 32393, "\u0120splend": 32394, "\u0120HPV": 32395, "abortion": 32396, "Above": 32397, "Entity": 32398, "players": 32399, "\u0120commenced": 32400, "ulence": 32401, "\u0120fulfillment": 32402, "\u0120embodiments": 32403, "\u0120Welfare": 32404, "\u0120hail": 32405, "\u0120<@": 32406, "tten": 32407, "\u0120catcher": 32408, "\u0120Jazeera": 32409, "\u0120volcano": 32410, "\u0120stabilize": 32411, "\u0120Handler": 32412, "\u0120intensified": 32413, "\u0120Abrams": 32414, "\u0120humiliation": 32415, "paced": 32416, "605": 32417, "\u0120CentOS": 32418, "Specific": 32419, "\u0120heed": 32420, "\u0120CAM": 32421, "\u0120Galile": 32422, "Die": 32423, "\u0120abolished": 32424, "\u0120Thomson": 32425, "\u0120Teachers": 32426, "\u0120Wass": 32427, "jong": 32428, "\u0120ISBN": 32429, "\u0120Allies": 32430, "shake": 32431, "\u00e5\u00b7": 32432, "vict": 32433, "Howard": 32434, "\u0120deem": 32435, "\u0120exceedingly": 32436, "\u0120Smartstocks": 32437, "ibe": 32438, "\u0120doorway": 32439, "\u0120competed": 32440, "igmat": 32441, "\u0120nationalists": 32442, "\u0120groom": 32443, "\u0120Keen": 32444, "\u0120disposable": 32445, "decl": 32446, "\u0120Tolkien": 32447, "\u0120Scheme": 32448, "\u0120biod": 32449, "\u0120avid": 32450, "\u0120Elon": 32451, "agar": 32452, "\u0120TSA": 32453, "Roman": 32454, "\u0120artificially": 32455, "\u0120advisors": 32456, "XL": 32457, "\u0120Inferno": 32458, "366": 32459, "\u0120tedious": 32460, "\u0120Photography": 32461, "\u0120Carrie": 32462, "\u0120trope": 32463, "\u0120Sandra": 32464, "\u0120decimal": 32465, "Queen": 32466, "\u0120Gundam": 32467, "\u0120OM": 32468, "otech": 32469, "NBA": 32470, "\u01201932": 32471, "\u0120entrenched": 32472, "\u0120Marion": 32473, "\u0120fraternity": 32474, "Labour": 32475, "Henry": 32476, "\u0120latitude": 32477, "Either": 32478, "\u0120enhances": 32479, "\u0120Potential": 32480, "\u0120shines": 32481, "idad": 32482, "\u0120breadth": 32483, "\u0120capacities": 32484, "\u0120\u00f0\u0141\u013b\u0124": 32485, "\u0120Bronx": 32486, "\u0120sexes": 32487, "\u0120differentiation": 32488, "\u0120heavyweight": 32489, "\u0120Taj": 32490, "dra": 32491, "\u0120migrate": 32492, "\u0120exhaustion": 32493, "\u0120RUN": 32494, "elsius": 32495, "\u0120Cuomo": 32496, "\u0120guitars": 32497, "\u0120clones": 32498, "\u0120Somew": 32499, "\u0120Pry": 32500, "-------------": 32501, "\u0120warranted": 32502, "cycles": 32503, "\u0120salvage": 32504, "\u0120disks": 32505, "RANT": 32506, "\u0120NGOs": 32507, "\u0120Martian": 32508, "\":[{\"": 32509, "\u0120addicts": 32510, "ojure": 32511, "illet": 32512, "\u0120amazingly": 32513, "artments": 32514, "pixel": 32515, "\u0120GPUs": 32516, "Layout": 32517, "\u00e8\u00a3": 32518, "\u0120Tamil": 32519, "\u0120Basil": 32520, "\u0120impartial": 32521, "\u0120Structure": 32522, "fork": 32523, "bryce": 32524, "\u0120ridge": 32525, "\u0120Hamburg": 32526, "rious": 32527, "\u0120blitz": 32528, "cigarettes": 32529, "\u0120canned": 32530, "402": 32531, "\u0120ironically": 32532, "\u0120compassionate": 32533, "\u0120Hawkins": 32534, ".#": 32535, "\u0120Cathedral": 32536, "\u0120rallied": 32537, "internal": 32538, "\u0120quota": 32539, "stakes": 32540, "TEXT": 32541, "mom": 32542, "\u0120completes": 32543, "\u0120238": 32544, "\u0120shrug": 32545, "\u00e3\u0125\u0133": 32546, "\u0120Ninth": 32547, "\u0120revise": 32548, "\u0120Provider": 32549, "\u0120treacher": 32550, "\u0120quasi": 32551, "\u0120PRES": 32552, "\u0120deposition": 32553, "\u0120confidentiality": 32554, "issors": 32555, "\u0120imbalance": 32556, "\u0120spanning": 32557, "\u0120angular": 32558, "\u0120Cul": 32559, "communication": 32560, "\u0120Nora": 32561, "\u0120Genius": 32562, "opter": 32563, "\u0120sacked": 32564, "Spot": 32565, "\u0120finely": 32566, "\u0120CHR": 32567, "282": 32568, "waves": 32569, "Palest": 32570, "\u0120Rohing": 32571, "NL": 32572, "\u00e8\u00bf": 32573, "\u0120shitty": 32574, "\u0120Scalia": 32575, "475": 32576, "Progress": 32577, "\u0120referencing": 32578, "\u0120classrooms": 32579, "abee": 32580, "\u0120sod": 32581, "hesion": 32582, "708": 32583, "\u0120Zuckerberg": 32584, "\u0120Finish": 32585, "\u0120Scotia": 32586, "\u0120Savior": 32587, "\u0120Installation": 32588, "antha": 32589, "(-": 32590, "\u0120302": 32591, "\u0120Punk": 32592, "\u0120crater": 32593, "youtu": 32594, "\u0120roast": 32595, "\u0120influencing": 32596, "\u0120dup": 32597, "\u0120JR": 32598, "\u0120Grav": 32599, "\u0120stature": 32600, "\u0120bathrooms": 32601, "Aside": 32602, "Wiki": 32603, "mean": 32604, "\u0120Zak": 32605, "\u0120Ones": 32606, "\u0120Nath": 32607, "\u0120hypert": 32608, "\u0120commencement": 32609, "Civil": 32610, "\u0120moderately": 32611, "\u0120distributors": 32612, "\u0120breastfeeding": 32613, "\u0120980": 32614, "\u0120Sik": 32615, "\u0120Cig": 32616, "\u0120AMER": 32617, "RIP": 32618, "\u0120Career": 32619, "usting": 32620, "\u0120messed": 32621, "\u0120eh": 32622, "\u0120Jensen": 32623, "/$": 32624, "\u0120blackmail": 32625, "\u0120conversions": 32626, "\u0120scientifically": 32627, "\u0120mantra": 32628, "paying": 32629, "\u0120ivory": 32630, "\u0120Courts": 32631, "OUGH": 32632, "auntlet": 32633, "Serial": 32634, "Brow": 32635, "\u0120Hundreds": 32636, "323": 32637, "\u0120pee": 32638, "\u0120linux": 32639, "\u0120submer": 32640, "\u0120Principal": 32641, "485": 32642, "\u0120DSL": 32643, "\u0120Cousins": 32644, "\u0120doctrines": 32645, "\u0120Athletics": 32646, "\u0120315": 32647, "\u0120Karma": 32648, "\u0120attent": 32649, "urger": 32650, "\u0120prescribe": 32651, "\u0120encaps": 32652, "\u0120Came": 32653, "\u0120secretive": 32654, "\u0120Crimes": 32655, "dn": 32656, "Clean": 32657, "\u0120Egyptians": 32658, "\u0120Carpenter": 32659, "\u0120ll": 32660, "Hum": 32661, "\u0120Milo": 32662, "\u0120capitalists": 32663, "\u0120briefed": 32664, "Twe": 32665, "\u0120Basin": 32666, "elvet": 32667, "Mos": 32668, "\u0120plunge": 32669, "\u0120Kaiser": 32670, "\u0120Fuj": 32671, "illin": 32672, "\u0120safeguards": 32673, "\u0120oste": 32674, "\u0120Opportunity": 32675, "\u0120Mafia": 32676, "\u0120Calling": 32677, "apa": 32678, "urban": 32679, "brush": 32680, "illard": 32681, "c\u00c3\u00a9": 32682, "intelligence": 32683, "\u0120Lob": 32684, "\u0120Druid": 32685, "\u0120smoother": 32686, "\u0120footing": 32687, "\u0120motorists": 32688, "arcity": 32689, "\u0120masculinity": 32690, "\u0120mism": 32691, "\u0120abdominal": 32692, "\u0120Tavern": 32693, "\u0120Roh": 32694, "\u0120escapes": 32695, "signed": 32696, "Anthony": 32697, "\u0120sacrificing": 32698, "\u0120intimacy": 32699, "\u0120anterior": 32700, "\u0120Kod": 32701, "\u0120motif": 32702, "\u0120graz": 32703, "\u0120visualization": 32704, "\u0120guitarist": 32705, "\u0120Trotsky": 32706, "magic": 32707, "Dar": 32708, "\u0120Mori": 32709, "\u0120wards": 32710, "\u0120toilets": 32711, "lest": 32712, "\u0120teleport": 32713, "\u0120Sundays": 32714, "\u0120Plat": 32715, "ETS": 32716, "\u0120eSports": 32717, "Patrick": 32718, "\u0120Katherine": 32719, "enko": 32720, "\u0120hassle": 32721, "\u0120Mick": 32722, "ggles": 32723, "\u0120hob": 32724, "aintain": 32725, "\u0120airborne": 32726, "\u0120spans": 32727, "\u0120chili": 32728, "\u0120aperture": 32729, "\u0120volunteered": 32730, "\u0120Incident": 32731, "\u0120Fres": 32732, "\u0120Veteran": 32733, "aughtered": 32734, "ingo": 32735, "\u0120uninsured": 32736, "CLOSE": 32737, "\u0120fuse": 32738, "\u0120erotic": 32739, "\u0120advertise": 32740, "raising": 32741, "Texture": 32742, "\u0120attends": 32743, "\u0120REAL": 32744, "uddled": 32745, "\u0120smoot": 32746, "\u0120305": 32747, "\u0120Willis": 32748, "\u0120blond": 32749, "Analysis": 32750, "\u0120VT": 32751, "onica": 32752, "\u0120stronghold": 32753, "RF": 32754, "NM": 32755, ".>>": 32756, "\u0120prosperous": 32757, "\u0120boasted": 32758, "292": 32759, "\u0120Manufacturing": 32760, "PRESS": 32761, "gren": 32762, "\u0120pharmacy": 32763, "\u0120Rockefeller": 32764, "kai": 32765, "\u0120thumbs": 32766, "\u0120Hut": 32767, "\u0120motherboard": 32768, "\u0120guardians": 32769, "\u0120Alter": 32770, "llular": 32771, "\u0120shack": 32772, "\u0120wisely": 32773, "\u0120backbone": 32774, "erva": 32775, "\u0120suicides": 32776, "\u0120McGregor": 32777, "ijah": 32778, "Emer": 32779, "\u0120Brav": 32780, "\u0120designate": 32781, "POST": 32782, "produced": 32783, "\u0120cleansing": 32784, "irlwind": 32785, "existent": 32786, "\u0120Humph": 32787, "\u0120Payne": 32788, "\u0120vested": 32789, "\u00c5\u00a1": 32790, "\u0120stringent": 32791, "iona": 32792, "\u0120unsub": 32793, "\u0120summed": 32794, "\u0120Hercules": 32795, "subject": 32796, "\u0120Ragnar": 32797, "\u0120Nos": 32798, "\u0120characterization": 32799, "\u0120savvy": 32800, "\u0120Dawson": 32801, "\u0120Casino": 32802, "\u0120fri": 32803, "\u0120Barrier": 32804, "\u0120misinformation": 32805, "\u0120insulation": 32806, "\u0120corridors": 32807, "\u0120airplanes": 32808, "\u0120Noct": 32809, "ahi": 32810, "\u01201916": 32811, "kb": 32812, "armac": 32813, "\u0120shun": 32814, "\u0120schema": 32815, "\u0120horrified": 32816, "\u0120239": 32817, "aunders": 32818, "NB": 32819, "iates": 32820, "erity": 32821, "\u0120Shard": 32822, "\u0120rarity": 32823, "\u0120grouped": 32824, "\u0120Ghana": 32825, "against": 32826, "\u0120Biological": 32827, "\u0120Aware": 32828, "owell": 32829, "\u00cf\u0126": 32830, "\u0120Beau": 32831, "shaw": 32832, "Hack": 32833, "\u0120Julius": 32834, "USS": 32835, "olson": 32836, "auna": 32837, "cru": 32838, "\u0120Maurice": 32839, "\u0120Ik": 32840, "\u0120sequencing": 32841, "\u0120radicals": 32842, "\u0120(?,": 32843, "virtual": 32844, "\u0120anyways": 32845, "\u0120reperc": 32846, "\u0120handlers": 32847, "\u0120hesitant": 32848, "\u00e9\u0125": 32849, "\u0120MF": 32850, "plementation": 32851, "associated": 32852, "\u0120campaigned": 32853, "\u0120Yue": 32854, "utations": 32855, "\u0120Yoga": 32856, "\u0120simmer": 32857, "\u0120rods": 32858, "\u0120melody": 32859, "\u0120convoy": 32860, "videos": 32861, "\u0120screened": 32862, "Neg": 32863, "ochemical": 32864, "\u0120())": 32865, "\u0120ultras": 32866, "\u0120antip": 32867, "\u0120Islanders": 32868, "704": 32869, "\u0120fetish": 32870, "\u0120ridiculously": 32871, "\u0120Kart": 32872, "\u0120mitochondrial": 32873, "\u0120interfering": 32874, "Builder": 32875, "\u0120overfl": 32876, "\u0120acne": 32877, "\u0120Mud": 32878, "\u0120Kerr": 32879, "flex": 32880, "\u0120Postal": 32881, "\u0120Baltic": 32882, "477": 32883, "\u0120Persons": 32884, "ourage": 32885, "HB": 32886, "\u0120Muse": 32887, "\u0120Immortal": 32888, "\u0120Driving": 32889, "\u0120petitions": 32890, "\u0120subscript": 32891, "\u0120sorce": 32892, "\u0120Processor": 32893, "uton": 32894, "Sony": 32895, "\u0120phon": 32896, "\u0120raced": 32897, "\u0120Anthrop": 32898, "\u0120daytime": 32899, "\u0120Exercise": 32900, "Adding": 32901, "\u0120engages": 32902, "\u0120Qualcomm": 32903, "\u0120miracles": 32904, "\u0120memes": 32905, "\u0120Drink": 32906, "\u0120Orioles": 32907, "\u0120hairs": 32908, "\u0120Polar": 32909, "athom": 32910, "\u0120slippery": 32911, "\u0120Remy": 32912, "\u0120caramel": 32913, "\u0120YEAR": 32914, "\u0120alk": 32915, "Ign": 32916, "aution": 32917, "\u0120Merlin": 32918, "\u0120Cran": 32919, "\u0120apologies": 32920, "\u0120410": 32921, "\u0120outing": 32922, "\u0120Memories": 32923, "appointed": 32924, "\u0120countered": 32925, "uld": 32926, "posing": 32927, "\u0120firewall": 32928, "\u0120Wast": 32929, "\u0120Wet": 32930, "worked": 32931, "seller": 32932, "\u0120repealed": 32933, "ereo": 32934, "assuming": 32935, "BLIC": 32936, "mite": 32937, "\u0120CEOs": 32938, "\u0120Chapel": 32939, "elligent": 32940, "________________________": 32941, "Dog": 32942, "\u0120wart": 32943, "\u0120subscriber": 32944, "sports": 32945, "\u0120begged": 32946, "\u0120MV": 32947, "\u0120semif": 32948, "ethical": 32949, "\u0120preach": 32950, "\u0120revital": 32951, "\u0120punitive": 32952, "\u0120shortcuts": 32953, "\u0120instituted": 32954, "\u0120Warsaw": 32955, "\u0120abdomen": 32956, "\u0120KING": 32957, "\u0120superintendent": 32958, "\u0120fry": 32959, "\u0120Geo": 32960, "TOR": 32961, "\u0120contradictions": 32962, "aptic": 32963, "\u0120landscapes": 32964, "bugs": 32965, "\u0120clust": 32966, "\u0120volley": 32967, "cribed": 32968, "\u0120tandem": 32969, "\u0120robes": 32970, "WHAT": 32971, "\u0120promoter": 32972, "\u0120eloqu": 32973, "reviewed": 32974, "\u0120DK": 32975, "\u0120Plato": 32976, "\u0120fps": 32977, "Tank": 32978, "\u0120Derrick": 32979, "\u0120prioritize": 32980, "asper": 32981, "\u0120Honduras": 32982, "\u0120Completed": 32983, "nec": 32984, "\u0120mog": 32985, "nir": 32986, "\u0120Mayo": 32987, "DEF": 32988, "stall": 32989, "inness": 32990, "\u0120Volkswagen": 32991, "\u0120precaution": 32992, "\u0120Mell": 32993, "iak": 32994, "istries": 32995, "\u0120248": 32996, "\u0120overlapping": 32997, "Senate": 32998, "\u0120Enhance": 32999, "resy": 33000, "racial": 33001, "ORTS": 33002, "\u0120Mormons": 33003, "Strong": 33004, "\u0120Coch": 33005, "Mexico": 33006, "\u0120Maduro": 33007, "\u0120jars": 33008, "\u0120cane": 33009, "Wik": 33010, "olla": 33011, "ifference": 33012, "\u0120physicist": 33013, "\u0120Maggie": 33014, "\u0120285": 33015, "\u0120depiction": 33016, "\u0120McLaren": 33017, "Ju": 33018, "\u0120slows": 33019, "\u0120commissioners": 33020, "\u0120Willow": 33021, "\u0120Explos": 33022, "hovah": 33023, "\u0120technician": 33024, "\u0120homicides": 33025, "\u0120Flav": 33026, "\u0120Truman": 33027, "\u012010000": 33028, "uctor": 33029, "\u0120shader": 33030, "Newsletter": 33031, "457": 33032, "\u0120rever": 33033, "\u0120hardened": 33034, "\u0120whereabouts": 33035, "\u0120redevelop": 33036, "\u0120carbs": 33037, "\u0120travers": 33038, "\u0120squirrel": 33039, "\u0120follower": 33040, "\u0120sings": 33041, "508": 33042, "\u0120rabbits": 33043, "emonium": 33044, "\u0120documenting": 33045, "\u0120misunderstood": 33046, ")'": 33047, "Rick": 33048, "ggies": 33049, "\u0120premie": 33050, "\u0120skating": 33051, "\u0120passports": 33052, "\u0120fists": 33053, "ageddon": 33054, "Haw": 33055, "ACP": 33056, "080": 33057, "\u0120Thoughts": 33058, "\u0120Carlson": 33059, "\u0120priesthood": 33060, "hua": 33061, "\u0120dungeons": 33062, "\u0120Loans": 33063, "\u0120antis": 33064, "\u0120familiarity": 33065, "\u0120Sabb": 33066, "opal": 33067, "\u0120Ink": 33068, "strike": 33069, "\u0120cram": 33070, "\u0120legalized": 33071, "\u0120cuisine": 33072, "\u0120fibre": 33073, "Travel": 33074, "\u0120Monument": 33075, "ODY": 33076, "ethy": 33077, "\u0120interstate": 33078, "\u0120PUR": 33079, "emporary": 33080, "\u0120Arabian": 33081, "developed": 33082, "\u0120saddle": 33083, "\u0120github": 33084, "\u0120Offer": 33085, "\u0120ISP": 33086, "rolet": 33087, "\u0120SUPER": 33088, "\u0120Denis": 33089, "\u0120multiplier": 33090, "\u0120stirred": 33091, "Interestingly": 33092, "\u0120customary": 33093, "\u0120billed": 33094, "hex": 33095, "\u0120multiplied": 33096, "\u0120flipping": 33097, "\u0120Crosby": 33098, "\u0120fundamentals": 33099, "iae": 33100, "\u0120Played": 33101, "\u0120Atom": 33102, "amazon": 33103, "\u0120Flam": 33104, "eez": 33105, "activated": 33106, "\u0120tablespoon": 33107, "\u0120liberalism": 33108, "\u0120Palin": 33109, "\u0120Patel": 33110, "Num": 33111, "\u0120TAM": 33112, "\u0120surn": 33113, "\u0120Reloaded": 33114, "\u0120coined": 33115, "\"],": 33116, "\u0120Clash": 33117, "\u0120Agu": 33118, "\u0120pragmatic": 33119, "\u0120Activate": 33120, "\u0120802": 33121, "\u0120trailers": 33122, "\u0120silhou": 33123, "\u0120probes": 33124, "\u0120circus": 33125, "\u0120Bain": 33126, "\u0120Lindsay": 33127, "\u0120Abbey": 33128, "Delivery": 33129, "\u0120concession": 33130, "\u0120gastro": 33131, "\u0120Sprite": 33132, "\u00c4\u0141": 33133, "andel": 33134, "\u0120gimm": 33135, "\u0120autobi": 33136, "\u0120Turtle": 33137, "\u0120wonderfully": 33138, "\u0120Haram": 33139, "\u0120Worldwide": 33140, "\u0120Handle": 33141, "\u0120theorists": 33142, "\u0120sleek": 33143, "\u0120Zhu": 33144, "ographically": 33145, "EGA": 33146, "\u0120Owners": 33147, "aths": 33148, "\u0120Antarctic": 33149, "natal": 33150, "=\"\"": 33151, "flags": 33152, "````": 33153, "\u0120sul": 33154, "Kh": 33155, "\u0120potassium": 33156, "\u0120lineman": 33157, "\u0120cereal": 33158, "\u0120Seasons": 33159, "\u01202022": 33160, "\u0120mathematic": 33161, "\u0120astronomers": 33162, "professional": 33163, "\u0120fares": 33164, "cknowled": 33165, "\u0120chi": 33166, "\u0120youngsters": 33167, "\u0120mistakenly": 33168, "\u0120hemisphere": 33169, "\u0120Divinity": 33170, "rone": 33171, "\u0120\",": 33172, "rings": 33173, "\u0120attracts": 33174, "vana": 33175, "\u00e5\u00b9": 33176, "CAP": 33177, "\u0120playlist": 33178, "\u0120porch": 33179, "\u00e3\u0123\u00a3": 33180, "\u0120incorporates": 33181, "\u0120soak": 33182, "\u0120asserting": 33183, "\u0120Terrorism": 33184, "\u0120Pablo": 33185, "Ja": 33186, "cester": 33187, "\u0120fearing": 33188, "\u0120Prayer": 33189, "\u0120escalated": 33190, "GW": 33191, "\u0120robe": 33192, "\u0120Brighton": 33193, "acists": 33194, "\u0120Symphony": 33195, "\u0120Dwarf": 33196, "\u0120Parade": 33197, "\u0120Lego": 33198, "\u0120inexpl": 33199, "\u0120lords": 33200, "leaf": 33201, "RAG": 33202, "liber": 33203, "\u0120cigars": 33204, "\u0120Jehovah": 33205, "606": 33206, "WINDOWS": 33207, "\u0120Liberia": 33208, "ebus": 33209, "Heavy": 33210, "\u0120lubric": 33211, "\u0120RW": 33212, "anguages": 33213, "\u0120narrowed": 33214, "computer": 33215, "\u0120Ember": 33216, "\u0120murdering": 33217, "\u0120downstream": 33218, "\u0120Tuls": 33219, "\u0120Tables": 33220, "Topic": 33221, "\u0120Accuracy": 33222, "=/": 33223, "lost": 33224, "\u0120Rei": 33225, "\u0120progresses": 33226, "bear": 33227, "\u0120establishments": 33228, "Justin": 33229, "\u0120Peach": 33230, "\u0120Gomez": 33231, "\u00e5\u00bf": 33232, "\u0120Triangle": 33233, "Ident": 33234, "\u0120Hive": 33235, "Resources": 33236, "\u0120mixes": 33237, "\u0120Assuming": 33238, "Mu": 33239, "\u0120hypoc": 33240, "\u0120sane": 33241, "\u0120Wan": 33242, "idious": 33243, "Success": 33244, "\u0120io": 33245, "Angel": 33246, "\u0120dangerously": 33247, "\u0120Creature": 33248, "WORK": 33249, ":[": 33250, "\u0120Katrina": 33251, "Listener": 33252, "Miller": 33253, "\u0120Idlib": 33254, "hang": 33255, "\u0120circumvent": 33256, "href": 33257, "\u0120celestial": 33258, "\u0120Weeks": 33259, "\u0120Pug": 33260, "\u0120Dalton": 33261, "\u0120subpoena": 33262, "uku": 33263, "\u0120persisted": 33264, "pei": 33265, "olding": 33266, "\u0120Documents": 33267, "\u0120Hast": 33268, "\u0120CENT": 33269, "\u0120primer": 33270, "\u0120synonymous": 33271, "\u0120nib": 33272, "ombs": 33273, "\u0120notation": 33274, "\u0120Dish": 33275, "\u0120Atmosp": 33276, "\u0120forbid": 33277, "\u0120ANG": 33278, "pattern": 33279, "los": 33280, "\u0120projectiles": 33281, "brown": 33282, ".\",": 33283, "\u0120Venom": 33284, "\u0120fiercely": 33285, "ublished": 33286, "\u0120Uran": 33287, "\u0120Nicarag": 33288, "410": 33289, "\u0120CAL": 33290, "OTOS": 33291, "\u0120Miracle": 33292, "\u0120Enchant": 33293, "\u0120guarding": 33294, "append": 33295, "Attach": 33296, "\u0120leveled": 33297, "\u0120condoms": 33298, "ihilation": 33299, "649": 33300, "\u0120nightmares": 33301, "\u0120THEY": 33302, "\u0120START": 33303, "\u0120Kinn": 33304, "\u0120roommate": 33305, "\u0120hygiene": 33306, "opping": 33307, "Job": 33308, "\u0120lvl": 33309, "\u0120VER": 33310, "\u0120Keeping": 33311, "abetic": 33312, "\u0120formatting": 33313, "erala": 33314, "\u0120revisions": 33315, "\u0120resurg": 33316, "Tel": 33317, "\u0120Goodman": 33318, "353": 33319, "pod": 33320, "\u0120indisp": 33321, "\u0120Translation": 33322, "\u0120gown": 33323, "\u0120Mund": 33324, "\u0120cis": 33325, "\u0120bystand": 33326, "collect": 33327, "\u0120Punjab": 33328, "actively": 33329, "\u0120Gamb": 33330, "tell": 33331, "\u0120importing": 33332, "gencies": 33333, "\u0120locom": 33334, "\u0120Brill": 33335, "Holy": 33336, "\u0120Berger": 33337, "\u0120showdown": 33338, "\u0120responders": 33339, "ILY": 33340, "\u0120takedown": 33341, "leted": 33342, "\u0120mattered": 33343, "\u0120predictive": 33344, "\u0120overlay": 33345, "GPU": 33346, "\u0120Vick": 33347, "\u0120conveyed": 33348, "Tab": 33349, "peer": 33350, "Scan": 33351, "\u0120defensively": 33352, "vae": 33353, "\u0120approving": 33354, "\u0120tiers": 33355, "\u0120Via": 33356, "querade": 33357, "\u0120Saudis": 33358, "\u0120demolished": 33359, "\u0120Prophe": 33360, "\u0120mono": 33361, "\u0120hospitality": 33362, "HAM": 33363, "\u0120Ariel": 33364, "MOD": 33365, "\u0120Torah": 33366, "\u0120blah": 33367, "\u0120Belarus": 33368, "erential": 33369, "\u0120Tuc": 33370, "\u0120banker": 33371, "397": 33372, "\u0120mosquit": 33373, "\u0120Scientist": 33374, "\u0120Musical": 33375, "\u0120hust": 33376, "Shift": 33377, "\u0120torment": 33378, "\u0120standoff": 33379, "Educ": 33380, "\u0120Fog": 33381, "\u0120amplifier": 33382, "Shape": 33383, "Instance": 33384, "\u0120Critics": 33385, "\u0120daemon": 33386, "Houston": 33387, "\u0120mattress": 33388, "\u0120IDF": 33389, "\u0120obscene": 33390, "\u0120Amer": 33391, "hetti": 33392, "\u0120compiling": 33393, "352": 33394, "verett": 33395, "\u0120Reduction": 33396, "istration": 33397, "\u0120Blessed": 33398, "\u0120Bachelor": 33399, "316": 33400, "\u0120prank": 33401, "\u0120Vulcan": 33402, "dding": 33403, "\u0120mourning": 33404, "\u0120Quint": 33405, "\u0120Blaster": 33406, "testing": 33407, "\u0120sediment": 33408, ">>>": 33409, "\u0120Eternity": 33410, "\u0120WHERE": 33411, "\u0120Maze": 33412, "\u0120reacting": 33413, "\u0120Alv": 33414, "omsday": 33415, "\u0120CRA": 33416, "\u0120translator": 33417, "\u0120bogus": 33418, "atu": 33419, "Website": 33420, "olls": 33421, "\u0120baptism": 33422, "\u0120sibling": 33423, "\u0120Autumn": 33424, "vez": 33425, "\u00e3\u0123\u00ae\u00e9": 33426, "guards": 33427, "Georg": 33428, "assadors": 33429, "\u0120Freud": 33430, "\u0120continents": 33431, "\u0120Registry": 33432, "Bernie": 33433, "\u0138\u013c\u00e5\u00a3\u00ab": 33434, "\u0120tolerant": 33435, "\u0120UW": 33436, "\u0120horribly": 33437, "995": 33438, "\u0120MIDI": 33439, "\u0120impatient": 33440, "ocado": 33441, "eri": 33442, "\u0120Worst": 33443, "\u0120Norris": 33444, "\u0120Talking": 33445, "\u0120defends": 33446, "ensable": 33447, "\u01202021": 33448, "\u0120anatomy": 33449, "Lew": 33450, "\u0120drawer": 33451, "\u0120Canberra": 33452, "\u0120patriotic": 33453, "\u00e9\u00be\u012f\u00e5\u0138\u013c\u00e5\u00a3\u00ab": 33454, "\u0120Avg": 33455, "ARM": 33456, "\u0120undisclosed": 33457, "\u0120farewell": 33458, "459": 33459, "bable": 33460, "\u0120Allison": 33461, "OLOG": 33462, "\u0120conco": 33463, "tight": 33464, "\u0120ACPI": 33465, "\u0120Mines": 33466, "lich": 33467, "\u0120\u00e2\u0136\u013e": 33468, "represented": 33469, "200000": 33470, "\u0120enthusiast": 33471, "OTS": 33472, "bil": 33473, "\u0120Ingredients": 33474, "\u0120inventor": 33475, "\u0120MySQL": 33476, "\u00c2\u0142\u00c2\u0142\u00c2\u0142": 33477, "\u0120ABOUT": 33478, "within": 33479, "\u0120mk": 33480, "Bul": 33481, "\u0120Fake": 33482, "\u0120draconian": 33483, "Wa": 33484, "helm": 33485, "\u0120Terran": 33486, "erville": 33487, "\u0120commonplace": 33488, "SIZE": 33489, "\u0120\"<": 33490, "replace": 33491, "ographs": 33492, "\u0120SELECT": 33493, "incible": 33494, "\u0120Mostly": 33495, "\u0120Sheffield": 33496, "\u0120IDE": 33497, "uggle": 33498, "\u0120citations": 33499, "hurst": 33500, "\u0120Unix": 33501, "\u0120unleash": 33502, "\u0120Piper": 33503, "\u0120Nano": 33504, "\u0120succumb": 33505, "\u0120reluctance": 33506, "\u01202500": 33507, "\u0120Merchant": 33508, "\u0120wiret": 33509, "\u0120combos": 33510, "\u0120Birthday": 33511, "\u0120charcoal": 33512, "\u0120UPS": 33513, "\u0120Fairfax": 33514, "\u0120driveway": 33515, "\u0120Tek": 33516, "\u0120Pitch": 33517, "overe": 33518, "\u0120technicians": 33519, "\u0120Actual": 33520, "flation": 33521, "\u0120Fiscal": 33522, "\u0120Empty": 33523, "anamo": 33524, "\u0120magnesium": 33525, "\u0120slut": 33526, "\u0120growers": 33527, "Investigators": 33528, "():": 33529, "\u0120Satellite": 33530, "\u0120Keynes": 33531, "missive": 33532, "lane": 33533, "\u0120borough": 33534, "344": 33535, "\u0120TEAM": 33536, "\u0120Bethesda": 33537, "CV": 33538, "hower": 33539, "\u0120RAD": 33540, "\u0120chant": 33541, "\u0120Riy": 33542, "\u0120compositions": 33543, "\u0120mildly": 33544, "\u0120meddling": 33545, "\u0120agility": 33546, "aneers": 33547, "501": 33548, "\u0120synth": 33549, "linger": 33550, "291": 33551, "\u0120exclaimed": 33552, "Party": 33553, "\u0120contamin": 33554, "\u0120Manor": 33555, "\u0120Respond": 33556, "\u0120praising": 33557, "\u0120manners": 33558, "fleet": 33559, "Summer": 33560, "\u0120Lynd": 33561, "\u0120Definitely": 33562, "grim": 33563, "\u0120bowling": 33564, "stri": 33565, "\u00e7\u013d": 33566, "ynt": 33567, "\u0120mandates": 33568, "DIV": 33569, "\u0120reconcile": 33570, "views": 33571, "\u0120Damon": 33572, "vette": 33573, "Flo": 33574, "\u0120Greatest": 33575, "ilon": 33576, "icia": 33577, "\u0120portrayal": 33578, "\u0120cushion": 33579, "504": 33580, "1979": 33581, "ossal": 33582, "Applic": 33583, "scription": 33584, "\u0120mitigation": 33585, "ATS": 33586, "pac": 33587, "\u0120erased": 33588, "\u0120deficiencies": 33589, "\u0120Hollande": 33590, "\u0120Xu": 33591, "\u0120bred": 33592, "\u0120pregnancies": 33593, "femin": 33594, "\u0120emph": 33595, "\u0120planners": 33596, "\u0120outper": 33597, "uttering": 33598, "\u0120perpetrator": 33599, "\u0120motto": 33600, "\u0120Ellison": 33601, "\u0120NEVER": 33602, "\u0120admittedly": 33603, "ARI": 33604, "\u0120Azerbaijan": 33605, "\u0120millisec": 33606, "\u0120combustion": 33607, "\u0120Bottle": 33608, "\u0120Lund": 33609, "\u0120Ps": 33610, "\u0120Dress": 33611, "\u0120fabricated": 33612, "\u0120battered": 33613, "\u0120sidel": 33614, "\u0120Notting": 33615, "Foreign": 33616, "\u0120Jerome": 33617, "020": 33618, "\u0120Arbit": 33619, "\u0120knots": 33620, "\u0120RIGHT": 33621, "Moving": 33622, "\u00e3\u0123\u013b": 33623, "\u0120surgeries": 33624, "\u0120courthouse": 33625, "\u0120mastered": 33626, "\u0120hovering": 33627, "\u0120Bran": 33628, "\u0120Alison": 33629, "\u0120safest": 33630, "military": 33631, "\u0120bullied": 33632, "\u0120barrage": 33633, "Reader": 33634, "ESE": 33635, "\u0120Geographic": 33636, "Tools": 33637, "314": 33638, "\u0120Geek": 33639, "roth": 33640, "glers": 33641, "\u0120FIN": 33642, "\u00cf\u0123": 33643, "\u0120Aston": 33644, "altern": 33645, "488": 33646, "\u0120veterin": 33647, "Gamer": 33648, "\u0120intel": 33649, "renches": 33650, "Shield": 33651, "\u0120amnesty": 33652, "\u0120Bhar": 33653, "\u0120piled": 33654, "\u0120honorable": 33655, "\u0120Institutes": 33656, "\u0120soaked": 33657, "\u0120coma": 33658, "\u0120EFF": 33659, "341": 33660, "bytes": 33661, "\u0120Gmail": 33662, "lein": 33663, "\u0120Canadiens": 33664, "material": 33665, "Il": 33666, "\u0120instructors": 33667, "\u0120KY": 33668, "\u0120conceive": 33669, "ubb": 33670, "\u0120Possible": 33671, "\u0120easing": 33672, "\u0120Christina": 33673, "\u0120caric": 33674, "\u0120HDR": 33675, "ROM": 33676, "\u0120shovel": 33677, "delete": 33678, "\u0120puff": 33679, "\u0120Changing": 33680, "\u0120seamlessly": 33681, "Attribute": 33682, "\u0120acquisitions": 33683, "akery": 33684, "\u0120EF": 33685, "\u0120autistic": 33686, "\u0120Takes": 33687, "\u0120Powder": 33688, "\u0120Stir": 33689, "510": 33690, "\u0120Bubble": 33691, "settings": 33692, "\u0120Fowler": 33693, "\u0120mustard": 33694, "\u0120moreover": 33695, "\u0120copyrighted": 33696, "\u0120LEDs": 33697, "1500": 33698, "\u00e6\u012b": 33699, "\u0120HIS": 33700, "enf": 33701, "\u0120custod": 33702, "\u0120Huck": 33703, "Gi": 33704, "\u0120img": 33705, "Answer": 33706, "Ct": 33707, "jay": 33708, "\u0120Infrastructure": 33709, "\u0120federally": 33710, "Loc": 33711, "\u0120microbes": 33712, "\u0120overrun": 33713, "dds": 33714, "otent": 33715, "adiator": 33716, ">>>>>>>>": 33717, "\u0120tornado": 33718, "\u0120adjud": 33719, "\u0120intrigued": 33720, "\u0120si": 33721, "\u0120Revelation": 33722, "progress": 33723, "\u0120burglary": 33724, "\u0120Saiyan": 33725, "\u0120Kathy": 33726, "\u0120serpent": 33727, "\u0120Andreas": 33728, "\u0120compel": 33729, "essler": 33730, "\u0120Plastic": 33731, "\u0120Advent": 33732, "\u0120Positive": 33733, "\u0120Qt": 33734, "\u0120Hindus": 33735, "registered": 33736, "ularity": 33737, "\u0120righteousness": 33738, "\u0120demonic": 33739, "uitive": 33740, "\u0120BDS": 33741, "\u0120Gregg": 33742, "cia": 33743, "\u0120Crusade": 33744, "\u0120Sinai": 33745, "WARE": 33746, "+(": 33747, "\u0120mell": 33748, "\u0120derail": 33749, "yards": 33750, "Ast": 33751, "\u0120noticeably": 33752, "\u0120Ober": 33753, "Ram": 33754, "\u0120unnoticed": 33755, "\u0120seq": 33756, "avage": 33757, "Ts": 33758, "\u0120640": 33759, "\u0120concede": 33760, "\u0120])": 33761, "Fill": 33762, "\u0120captivity": 33763, "\u0120Improvement": 33764, "\u0120Crusader": 33765, "araoh": 33766, "MAP": 33767, "\u00e6\u0139": 33768, "\u0120stride": 33769, "always": 33770, "Fly": 33771, "Nit": 33772, "\u0120algae": 33773, "\u0120Cooking": 33774, "\u0120Doors": 33775, "Malley": 33776, "\u0120policemen": 33777, "\u00e3\u0123\u012f": 33778, "\u0120astronaut": 33779, "accessible": 33780, "495": 33781, "\u0120RAW": 33782, "cliffe": 33783, "udicrous": 33784, "\u0120depended": 33785, "alach": 33786, "\u0120ventures": 33787, "rake": 33788, "\u0120tits": 33789, "\u0120Hou": 33790, "\u0120condom": 33791, "ormonal": 33792, "\u0120indent": 33793, "\u0120uploading": 33794, "Footnote": 33795, "Important": 33796, "\u0120271": 33797, "\u0120mindful": 33798, "\u0120contends": 33799, "Cra": 33800, "\u0120calibr": 33801, "\u0120OECD": 33802, "plugin": 33803, "Fat": 33804, "\u0120ISS": 33805, "\u0120Dynamics": 33806, "ansen": 33807, "686": 33808, "'),": 33809, "\u0120sprite": 33810, "\u0120handheld": 33811, "\u0120Hipp": 33812, "=~=~": 33813, "Trust": 33814, "\u0120semantics": 33815, "\u0120Bundes": 33816, "\u0120Reno": 33817, "\u0120Literature": 33818, "sense": 33819, "Gary": 33820, "\u0120Aeg": 33821, "\u0120Trin": 33822, "EEK": 33823, "\u0120cleric": 33824, "\u0120SSH": 33825, "\u0120christ": 33826, "\u0120invading": 33827, "ibu": 33828, "\u0120enum": 33829, "aura": 33830, "\u0120allege": 33831, "\u0120Incredible": 33832, "BBC": 33833, "\u0120thru": 33834, "\u0120sailed": 33835, "\u0120emulate": 33836, "\u0120insecurity": 33837, "\u0120crou": 33838, "\u0120accommodations": 33839, "\u0120incompetent": 33840, "\u0120slips": 33841, "\u0120Earthqu": 33842, "sama": 33843, "ILLE": 33844, "\u0120iPhones": 33845, "asaki": 33846, "\u0120bye": 33847, "\u0120ard": 33848, "\u0120extras": 33849, "\u0120slaughtered": 33850, "\u0120crowdfunding": 33851, "resso": 33852, "\u0120filib": 33853, "\u0120ERROR": 33854, "\u0120TLS": 33855, "egg": 33856, "\u0120Ital": 33857, "\u0120enlist": 33858, "\u0120Catalonia": 33859, "\u0120Scots": 33860, "\u0120sergeant": 33861, "\u0120dissolve": 33862, "NH": 33863, "\u0120standings": 33864, "rique": 33865, "IQ": 33866, "\u0120beneficiary": 33867, "\u0120aquarium": 33868, "YouTube": 33869, "\u0120PowerShell": 33870, "\u0120brightest": 33871, "\u0120Warrant": 33872, "Sold": 33873, "Writing": 33874, "\u0120beginnings": 33875, "\u0120Reserved": 33876, "\u0120Latinos": 33877, "heading": 33878, "\u0120440": 33879, "\u0120rooftop": 33880, "ATING": 33881, "\u0120390": 33882, "VPN": 33883, "Gs": 33884, "kernel": 33885, "turned": 33886, "\u0120preferable": 33887, "\u0120turnovers": 33888, "\u0120Hels": 33889, "Sa": 33890, "\u0120Shinji": 33891, "veh": 33892, "\u0120MODULE": 33893, "Viol": 33894, "\u0120exiting": 33895, "\u0120jab": 33896, "\u0120Vanilla": 33897, "\u0120acron": 33898, "\u0120Gap": 33899, "bern": 33900, "Ak": 33901, "\u0120McGu": 33902, "\u0120endlessly": 33903, "\u0120Farage": 33904, "\u0120Noel": 33905, "Va": 33906, "MK": 33907, "\u0120brute": 33908, "\u0120Kru": 33909, "\u0120ESV": 33910, "\u0120Olivia": 33911, "\u00e2\u0122\u0142": 33912, "\u0120Kaf": 33913, "\u0120trusting": 33914, "\u0120hots": 33915, "324": 33916, "\u0120malaria": 33917, "\u0120json": 33918, "\u0120pounding": 33919, "ortment": 33920, "Country": 33921, "\u0120postponed": 33922, "\u0120unequiv": 33923, "?),": 33924, "\u0120Rooney": 33925, "udding": 33926, "\u0120Leap": 33927, "urrence": 33928, "shapeshifter": 33929, "\u0120HAS": 33930, "osate": 33931, "\u0120cavern": 33932, "\u0120conservatism": 33933, "\u0120BAD": 33934, "\u0120mileage": 33935, "\u0120arresting": 33936, "Vaults": 33937, "\u0120mixer": 33938, "Democratic": 33939, "\u0120Benson": 33940, "\u0120authored": 33941, "8000": 33942, "\u0120proactive": 33943, "\u0120Spiritual": 33944, "tre": 33945, "\u0120incarcerated": 33946, "\u0120Sort": 33947, "\u0120peaked": 33948, "\u0120wielding": 33949, "reciation": 33950, "\u00d7\u013b\u00d7": 33951, "Patch": 33952, "\u0120Emmy": 33953, "\u0120exqu": 33954, "tto": 33955, "\u0120Ratio": 33956, "\u0120Picks": 33957, "\u0120Gry": 33958, "phant": 33959, "\u0120fret": 33960, "\u0120ethn": 33961, "\u0120archived": 33962, "%-": 33963, "cases": 33964, "\u0120Blaze": 33965, "\u0120imb": 33966, "cv": 33967, "yss": 33968, "imony": 33969, "\u0120countdown": 33970, "\u0120awakening": 33971, "\u0120Tunisia": 33972, "\u0120Refer": 33973, "\u0120MJ": 33974, "\u0120unnatural": 33975, "\u0120Carnegie": 33976, "izen": 33977, "\u0120Nuggets": 33978, "hess": 33979, "\u0120evils": 33980, "647": 33981, "\u0120introductory": 33982, "loving": 33983, "\u0120McMahon": 33984, "\u0120ambiguity": 33985, "Label": 33986, "\u0120Almighty": 33987, "\u0120coloring": 33988, "\u0120Claus": 33989, "setting": 33990, "NULL": 33991, "\u0120Favorite": 33992, "\u0120SIG": 33993, ">(": 33994, "\u0120Shiva": 33995, "\u0120Mayer": 33996, "\u0120stormed": 33997, "\u0120Coverage": 33998, "weapons": 33999, "igham": 34000, "\u0120unanswered": 34001, "\u0120leve": 34002, "\u0120coy": 34003, "cas": 34004, "bags": 34005, "asured": 34006, "Seattle": 34007, "\u0120Santorum": 34008, "serious": 34009, "\u0120courageous": 34010, "\u0120Soup": 34011, "\u0120confiscated": 34012, "\u0120///": 34013, "\u0120unconventional": 34014, "\u0120moms": 34015, "\u0120Rohingya": 34016, "\u0120Orchestra": 34017, "\u0120Potion": 34018, "\u0120discredit": 34019, "\u0120FIL": 34020, "fixed": 34021, "\u0120Deer": 34022, "doi": 34023, "\u0120Dimension": 34024, "\u0120bureaucrats": 34025, "eteen": 34026, "\u0120actionGroup": 34027, "ohm": 34028, "\u0120bumps": 34029, "\u0120Utility": 34030, "\u0120submarines": 34031, "renheit": 34032, "research": 34033, "\u0120Shapiro": 34034, "\u0120sketches": 34035, "\u0120deceptive": 34036, "\u0120Vil": 34037, "esame": 34038, "\u0120Essentially": 34039, "\u0120rampage": 34040, "isky": 34041, "\u0120muttered": 34042, "thritis": 34043, "\u0120236": 34044, "fet": 34045, "bars": 34046, "\u0120pupil": 34047, "\u0120Thou": 34048, "oS": 34049, "song": 34050, "\u0120fractured": 34051, "\u0120revert": 34052, "picture": 34053, "\u0120criterion": 34054, "usher": 34055, "\u0120repercussions": 34056, "\u0120Vintage": 34057, "\u0120Superintendent": 34058, "Officers": 34059, "\u0120flagged": 34060, "\u0120blames": 34061, "\u0120inverse": 34062, "ographers": 34063, "\u0120makeshift": 34064, "\u0120devoid": 34065, "\u0120fossils": 34066, "\u0120Aristotle": 34067, "\u0120Funds": 34068, "\u0120depleted": 34069, "\u0120Flu": 34070, "\u0120Yuan": 34071, "\u0120woes": 34072, "\u0120lipid": 34073, "\u0120situ": 34074, "requisites": 34075, "\u0120furnish": 34076, "\u0120Samar": 34077, "\u0120shameful": 34078, "\u0120adversely": 34079, "\u0120adept": 34080, "\u0120remorse": 34081, "\u0120murderous": 34082, "uckles": 34083, "\u0120ESL": 34084, "\u0120314": 34085, "sent": 34086, "\u0120redef": 34087, "\u0120Cache": 34088, "\u0120Purs": 34089, "igans": 34090, "\u0120460": 34091, "\u0120prescriptions": 34092, "\u0120fres": 34093, "Fuck": 34094, "ocrates": 34095, "Twenty": 34096, "\u0120Weird": 34097, "\u0120Toggle": 34098, "\u0120Called": 34099, "itizens": 34100, "\u0120poultry": 34101, "\u0120harvesting": 34102, "\u00e3\u0124\u00a6\u00e3\u0124\u00b9": 34103, "Bottom": 34104, "\u0120cautioned": 34105, "tn": 34106, "396": 34107, "\u0120Nikki": 34108, "\u0120evaluations": 34109, "\u0120harassing": 34110, "\u0120bindings": 34111, "\u0120Monetary": 34112, "\u0120hitters": 34113, "\u0120adversary": 34114, "unts": 34115, "\u0120setback": 34116, "\u0120encrypt": 34117, "\u0120Cait": 34118, "\u0120lows": 34119, "enges": 34120, "\u0120Norn": 34121, "\u0120bulbs": 34122, "\u0120bottled": 34123, "\u0120Voyager": 34124, "317": 34125, "\u0120spheres": 34126, "politics": 34127, "\u0120subtract": 34128, "\u0120sensations": 34129, "\u0120appalling": 34130, "\u0120316": 34131, "\u0120environmentally": 34132, "\u0120STEM": 34133, "\u0120publishes": 34134, "560": 34135, "\u0120diligence": 34136, "484": 34137, "\u0120advises": 34138, "\u0120petrol": 34139, "\u0120imagining": 34140, "\u0120patrols": 34141, "\u0120Integer": 34142, "\u0120Ashes": 34143, "actus": 34144, "\u0120Radiant": 34145, "\u0120LT": 34146, "itability": 34147, "htaking": 34148, "Setting": 34149, "\u0120nuanced": 34150, "\u0120Reef": 34151, "\u0120Developers": 34152, "Ni": 34153, "pieces": 34154, "990": 34155, "License": 34156, "\u0120lowers": 34157, "\u0120Ottoman": 34158, "327": 34159, "ooo": 34160, "\u0120quitting": 34161, "markets": 34162, "Behind": 34163, "\u0120basin": 34164, "\u0120docs": 34165, "anie": 34166, "flash": 34167, "ctl": 34168, "\u0120civilized": 34169, "\u0120Fukushima": 34170, "\"],\"": 34171, "\u0120KS": 34172, "\u0120Honestly": 34173, "arat": 34174, "\u0120constructs": 34175, "\u0120Lans": 34176, "\u0120Dire": 34177, "\u0120LIKE": 34178, "\u0120Trouble": 34179, "\u0120withholding": 34180, "\u0120Oblivion": 34181, "\u0120sanity": 34182, "anya": 34183, "Const": 34184, "\u0120grocer": 34185, "\u0120Celsius": 34186, "\u0120recounted": 34187, "\u0120Wife": 34188, "Border": 34189, "atered": 34190, "happy": 34191, "\u0120spoiler": 34192, "\u0120logically": 34193, "Hall": 34194, "\u0120succeeding": 34195, "\u0120polymorph": 34196, "\u0120axes": 34197, "\u0120Shotgun": 34198, "\u0120Slim": 34199, "\u0120Principles": 34200, "\u0120Leth": 34201, "arta": 34202, "\u0120scor": 34203, "Screenshot": 34204, "\u0120relaxation": 34205, "#$#$": 34206, "\u0120deterrent": 34207, "iddy": 34208, "\u0120powerless": 34209, "\u0120lesbians": 34210, "\u0120chords": 34211, "\u0120Edited": 34212, "selected": 34213, "\u0120separatists": 34214, "0002": 34215, "\u0120airspace": 34216, "\u0120turnaround": 34217, "\u0120cunning": 34218, "PATH": 34219, "Poly": 34220, "\u0120bombed": 34221, "\u0120tion": 34222, "xs": 34223, "\u0120withhold": 34224, "\u0120waged": 34225, "\u0120Liberties": 34226, "Flag": 34227, "\u0120comforting": 34228, "454": 34229, "\u0120Iris": 34230, "arers": 34231, "\u0120rag": 34232, "\u0120relocated": 34233, "\u0120Guarant": 34234, "\u0120strategically": 34235, "\u0120gamma": 34236, "uberty": 34237, "\u0120Lockheed": 34238, "gres": 34239, "\u0120grilled": 34240, "\u0120Lowe": 34241, "stats": 34242, "\u0120Rocks": 34243, "\u0120sensing": 34244, "\u0120renting": 34245, "\u0120Geological": 34246, "\u00d8\u00a7\u00d8": 34247, "otrop": 34248, "\u0120sew": 34249, "\u0120improperly": 34250, "486": 34251, "\u0120\u00e2\u0138\u0142": 34252, "\u0120starving": 34253, "\u0120Bj": 34254, "Discussion": 34255, "328": 34256, "\u0120Combo": 34257, "\u0120Fixes": 34258, "NAT": 34259, "\u0120striving": 34260, "thora": 34261, "\u0120harvested": 34262, "\u0120Ping": 34263, "\u0120playful": 34264, "\u0120avenues": 34265, "\u0120occupational": 34266, "\u0120wakes": 34267, "\u0120Courier": 34268, "\u0120drummer": 34269, "\u0120Browser": 34270, "\u0120Houth": 34271, "itu": 34272, "\u0120apparel": 34273, "paste": 34274, "\u0120hunted": 34275, "\u0120Secondly": 34276, "lain": 34277, "XY": 34278, "\u0120PIN": 34279, "icons": 34280, "\u0120cocktails": 34281, "\u0120sizable": 34282, "\u0120hurdles": 34283, "estinal": 34284, "\u0120Recreation": 34285, "\u0120eco": 34286, "648": 34287, "\u0120Died": 34288, "mint": 34289, "\u0120fingerprints": 34290, "\u0120dispose": 34291, "\u0120Bosnia": 34292, "tsy": 34293, "2200": 34294, "\u0120inspected": 34295, "\u0120Fou": 34296, "\u0120fuss": 34297, "\u0120ambush": 34298, "\u0120Rak": 34299, "\u0120manifested": 34300, "Prosecut": 34301, "\u0120suffice": 34302, "rences": 34303, "\u0120compensated": 34304, "\u0120Cyrus": 34305, "\u0120genus": 34306, "\u0120Wolverine": 34307, "\u0120Trends": 34308, "\u0120hikes": 34309, "\u0120Seen": 34310, "\u0120enrol": 34311, "Cold": 34312, "\u0120politely": 34313, "\u0120Slav": 34314, "\u0120Rupert": 34315, "\u0120eyewitness": 34316, "\u0120Alto": 34317, "\u0120uncomp": 34318, "\u0120posterior": 34319, "Must": 34320, "\u0120Herz": 34321, "\u0120progressively": 34322, "\u0120234": 34323, "\u0120indifference": 34324, "\u0120Cunningham": 34325, "\u0120academia": 34326, "\u0120sewer": 34327, "\u0120astounding": 34328, "\u0120AES": 34329, "rather": 34330, "\u0120eldest": 34331, "\u0120climbs": 34332, "\u0120Adds": 34333, "\u0120outcry": 34334, "\u0120contag": 34335, "\u0120Houses": 34336, "\u0120pept": 34337, "\u0120Melania": 34338, "interested": 34339, "\u0120UCH": 34340, "\u0120Roots": 34341, "\u0120Hubbard": 34342, "\u0120TBD": 34343, "\u0120Romanian": 34344, "filename": 34345, "Stone": 34346, "\u0120Impl": 34347, "\u0120chromosome": 34348, "Cle": 34349, "dx": 34350, "\u0120scrambled": 34351, "\u0120Pt": 34352, "\u0120242": 34353, "OPLE": 34354, "\u0120tremendously": 34355, "Street": 34356, "\u0120craving": 34357, "\u0120bundled": 34358, "\u0120RG": 34359, "pipe": 34360, "\u0120injuring": 34361, "\u0120arcane": 34362, "Particip": 34363, "\u0120Heroic": 34364, "sty": 34365, "\u0120topping": 34366, "\u0120Tempest": 34367, "rentices": 34368, "bh": 34369, "\u0120paranoia": 34370, "\u0120Unicode": 34371, "\u0120egregious": 34372, "\u0120\\'": 34373, "\u0120Oswald": 34374, "\u0120gravel": 34375, "\u0120Simpsons": 34376, "\u0120bland": 34377, "\u0120Guantanamo": 34378, "Writer": 34379, "liners": 34380, "\u0120Dice": 34381, "JC": 34382, "\u0120parity": 34383, "\u0120sided": 34384, "\u0120237": 34385, "\u0120Pyrrha": 34386, "atters": 34387, "dk": 34388, "Fine": 34389, "compan": 34390, "\u0120formulated": 34391, "\u0120Idol": 34392, "ilers": 34393, "hemoth": 34394, "\u0120Fav": 34395, "\u0120intrusion": 34396, "\u0120carrots": 34397, "\u0120Layer": 34398, "\u0120Hacker": 34399, "\u0120----------------": 34400, "\u0120moderation": 34401, "\u00e9\u0123": 34402, "ococ": 34403, "\u0120characterize": 34404, "\u0120Teresa": 34405, "\u0120socioeconomic": 34406, "\u0120perk": 34407, "\u0120Participation": 34408, "training": 34409, "\u0120Paulo": 34410, "phys": 34411, "\u0120trustworthy": 34412, "\u0120embodied": 34413, "\u0120Merch": 34414, "currency": 34415, "\u0120Priority": 34416, "\u0120teasing": 34417, "\u0120absorbing": 34418, "\u0120unfinished": 34419, "\u0120Comparison": 34420, "\u0120disple": 34421, "writers": 34422, "\u0120professions": 34423, "\u0120Penguin": 34424, "\u0120angrily": 34425, "\u0120LINK": 34426, "688": 34427, "\u0120Correspond": 34428, "\u0120prevailed": 34429, "\u0120cartel": 34430, "lp": 34431, "asms": 34432, "\u0120Redemption": 34433, "\u0120Islamists": 34434, "effects": 34435, "dose": 34436, "\u0120Latter": 34437, "\u0120Halifax": 34438, "\u0120vas": 34439, "\u0120Topics": 34440, "\u0120Named": 34441, "advertising": 34442, "zza": 34443, "ICES": 34444, "\u0120retarded": 34445, "achable": 34446, "\u0120Puppet": 34447, "\u0120ItemLevel": 34448, "\u0120retract": 34449, "\u0120identifiable": 34450, "Aaron": 34451, "\u0120Buster": 34452, "sol": 34453, "helle": 34454, "assemb": 34455, "Hope": 34456, "ranged": 34457, "Ba": 34458, "\u0120Purch": 34459, "\u00e9\u0122": 34460, "\u0120Siri": 34461, "\u0120arrivals": 34462, "\u01201912": 34463, "\u0120shortened": 34464, "\u0120312": 34465, "\u0120discrepancy": 34466, "\u0120Temperature": 34467, "\u0120Walton": 34468, "\u0120kinderg": 34469, "polit": 34470, "\u0120remix": 34471, "\u0120connectors": 34472, "\u00e3\u0125\u013a\u00e3\u0125\u00a9": 34473, "\u0120Kazakhstan": 34474, "dominated": 34475, "\u0120sugars": 34476, "imble": 34477, "\u0120Panic": 34478, "\u0120Demand": 34479, "\u0120Colony": 34480, "onen": 34481, "\u0120MER": 34482, "775": 34483, "uria": 34484, "azaar": 34485, "\u0120Degree": 34486, "Pri": 34487, "\u0120sunshine": 34488, "\u0120251": 34489, "\u0120psychedelic": 34490, "\u0120digitally": 34491, "\u0120Braun": 34492, "\u0120shimmer": 34493, "\u0120shave": 34494, "\u0120Telesc": 34495, "\u0120Astral": 34496, "\u0120Venezuelan": 34497, "\u0120OG": 34498, "\u0120crawling": 34499, "Integ": 34500, "\u0120Feather": 34501, "\u0120unfolding": 34502, "\u0120appropriation": 34503, "\u0120\u00e8\u00a3\u0131\u00e8": 34504, "\u0120Mobility": 34505, "\u0120Ney": 34506, "-.": 34507, "bilt": 34508, "LIN": 34509, "\u0120Tube": 34510, "\u0120Conversely": 34511, "\u0120keyboards": 34512, "\u0120Cao": 34513, "\u0120overth": 34514, "\u0120laure": 34515, ">>\\": 34516, "\u0120Viper": 34517, "acha": 34518, "Offset": 34519, "\u0120Raleigh": 34520, "\u0120Jae": 34521, "Jordan": 34522, "jp": 34523, "\u0120totalitarian": 34524, "Connector": 34525, "\u0120observes": 34526, "\u0120Spartan": 34527, "\u0120Immediately": 34528, "\u0120Scal": 34529, "Cool": 34530, "\u0120taps": 34531, "\u0120roar": 34532, "Past": 34533, "\u0120chars": 34534, "\u0120Bender": 34535, "\u0120Sheldon": 34536, "\u0120painter": 34537, "\u0120beacon": 34538, "\u0120Creatures": 34539, "\u0120downturn": 34540, "\u0120hinder": 34541, "\u0120Andromeda": 34542, "\u00c3\u013d": 34543, "ccoli": 34544, "\u0120Fitness": 34545, "etrical": 34546, "\u0120utilizes": 34547, "\u0120senate": 34548, "\u0120ensemble": 34549, "\u0120cheers": 34550, "TW": 34551, "\u0120affluent": 34552, "kil": 34553, "rylic": 34554, "ordering": 34555, "Computer": 34556, "\u0120gruesome": 34557, "ostics": 34558, "\u0120Ubisoft": 34559, "\u0120Kelley": 34560, "\u0120wrench": 34561, "\u0120bourgeoisie": 34562, "IBLE": 34563, "\u0120Preston": 34564, "worn": 34565, "arist": 34566, "reating": 34567, "\u0120stained": 34568, "arine": 34569, "\u0120slime": 34570, "ENN": 34571, "\u0120chests": 34572, "\u0120groundwater": 34573, "annot": 34574, "\u0120Tray": 34575, "\u0120Locke": 34576, "\u0120CTR": 34577, "\u0120dudes": 34578, "\u0120External": 34579, "\u0120Decoder": 34580, "\u0120paramed": 34581, "\u0120Medline": 34582, "809": 34583, "\u0120Dinner": 34584, "rupal": 34585, "gz": 34586, "\u0120Gum": 34587, "\u0120Demo": 34588, "jee": 34589, "\u0120dh": 34590, "berman": 34591, "archs": 34592, "\u0120enqu": 34593, "\u0120Epstein": 34594, "\u0120devastation": 34595, "\u0120friendships": 34596, "\u0120Ard": 34597, "\u0120231": 34598, "\u0120Rubin": 34599, "\u0120Distance": 34600, "\u0120spurred": 34601, "\u0120dossier": 34602, "\u0120overlooking": 34603, "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\": 34604, "Forest": 34605, "\u0120Comes": 34606, "\\\",": 34607, "\u0120Iranians": 34608, "\u0120fixtures": 34609, "Laughs": 34610, "\u0120curry": 34611, "\u0120Kingston": 34612, "\u0120squash": 34613, "\u0120catalogue": 34614, "\u0120abnormalities": 34615, "\u0120digestive": 34616, ".........": 34617, "\u0120subordinate": 34618, "ogly": 34619, "\u0120249": 34620, "Middle": 34621, "\u0120massac": 34622, "\u0120burgers": 34623, "\u0120downstairs": 34624, "\u01201931": 34625, "394": 34626, "\u0120VG": 34627, "\u0120lasers": 34628, "\u0120Sikh": 34629, "\u0120Alexa": 34630, "derived": 34631, "\u0120cyclist": 34632, "\u00e3\u0123\u00ae\u00e9\u0143\u0136": 34633, "oneliness": 34634, "!!!!!!!!": 34635, "\u0120buffs": 34636, "legate": 34637, "\u0120raping": 34638, "\u0120recommending": 34639, "rored": 34640, "\u0120multicultural": 34641, "unique": 34642, "\u0120businessmen": 34643, "\u0120uneasy": 34644, "\u0120MAP": 34645, "\u0120dispersed": 34646, "cipline": 34647, "Jess": 34648, "\u0120Kerala": 34649, "\u00e5\u00a7": 34650, "\u0120abstraction": 34651, "Surv": 34652, "Uh": 34653, "\u0120printers": 34654, "ija": 34655, "owder": 34656, "\u0120analogous": 34657, "\u0120ASP": 34658, "afer": 34659, "\u0120unfolded": 34660, "\u0120leveling": 34661, "\u0120breached": 34662, "\u0120Hearing": 34663, "\u0120nat": 34664, "\u0120translating": 34665, "critical": 34666, "\u0120antagonist": 34667, "\u0120Yesterday": 34668, "\u0120fuzzy": 34669, "wash": 34670, "mere": 34671, "\u0120bewild": 34672, "\u0120Mae": 34673, "Virgin": 34674, "phrase": 34675, "\u0120signaled": 34676, "\u0120HIGH": 34677, "\u0120protester": 34678, "\u0120garner": 34679, "unknown": 34680, "\u0120kay": 34681, "\u0120abducted": 34682, "\u0120stalking": 34683, "amn": 34684, "\u0120deserving": 34685, "\u0120Riv": 34686, "\u0120Jorge": 34687, "\u0120scratching": 34688, "\u0120Saving": 34689, "iping": 34690, "\u0120tease": 34691, "\u0120missionary": 34692, "\u0120Morrow": 34693, "TIME": 34694, "Present": 34695, "\u0120chemotherapy": 34696, "terness": 34697, "\u0120Homes": 34698, "\u0120Purdue": 34699, "\u0120staunch": 34700, "\u0120Whitney": 34701, "\u0120THERE": 34702, "\u00ce\u00bc": 34703, "iatus": 34704, "\u0120Ernest": 34705, "\u0120Deploy": 34706, "\u0120coveted": 34707, "FML": 34708, "\u0120Dialogue": 34709, "\u0120exited": 34710, "fruit": 34711, "\u0120nerd": 34712, "\":\"\",\"": 34713, "\u0120vivo": 34714, "ruly": 34715, "460": 34716, "\u0120Amen": 34717, "rehensible": 34718, "\u0120\u00e2\u013a": 34719, "DIR": 34720, "\u0120adherence": 34721, "\u0120chew": 34722, "\u0120Coke": 34723, "\u0120Sergei": 34724, "digital": 34725, "\u0120Neck": 34726, "gently": 34727, "enthal": 34728, "/)": 34729, "\u0120weary": 34730, "\u0120guise": 34731, "\u0120Concord": 34732, "\u0120Onion": 34733, "atcher": 34734, "\u0120binge": 34735, "\u0120Directive": 34736, "\u0120manned": 34737, "ansk": 34738, "\u0120illusions": 34739, "\u0120billionaires": 34740, "383": 34741, "olyn": 34742, "odynamic": 34743, "\u0120Wheat": 34744, "\u0120Alic": 34745, "\u0120coloured": 34746, "\u0120NAFTA": 34747, "abo": 34748, "\u0120macros": 34749, "independent": 34750, "sweet": 34751, "\u0120spac": 34752, "\u0120Kabul": 34753, "\u0120\u00c4": 34754, "eme": 34755, "\u0120dictated": 34756, "\u0120shouts": 34757, "={": 34758, "\u0120ripping": 34759, "\u0120Shay": 34760, "\u0120Cricket": 34761, "directed": 34762, "\u0120analysed": 34763, "\u0120WARRANT": 34764, "agons": 34765, "\u0120Blazers": 34766, "\u0120cheered": 34767, "\u0120arithmetic": 34768, "\u0120Tanz": 34769, "373": 34770, "\u0120Flags": 34771, "\u0120295": 34772, "\u0120witches": 34773, "\u0120Included": 34774, "\u0120Gained": 34775, "\u0120Blades": 34776, "Gam": 34777, "\u0120Samantha": 34778, "\u0120Atlantis": 34779, "\u0120Pratt": 34780, "\u0120spoiled": 34781, "\u0120IB": 34782, "\u0120Ramirez": 34783, "Probably": 34784, "rero": 34785, "\u0120Ng": 34786, "\u0120Warlock": 34787, "tp": 34788, "\u0120overhe": 34789, "\u0120administrations": 34790, "\u0120tint": 34791, "\u0120regiment": 34792, "\u0120pistols": 34793, "\u0120blankets": 34794, "\u0120epist": 34795, "\u0120bowls": 34796, "\u0120hydraulic": 34797, "\u0120dean": 34798, "\u0120jung": 34799, "\u0120ascend": 34800, "705": 34801, "\u0120Santiago": 34802, "\u00c3\u00ae": 34803, "\u0120unavoid": 34804, "\u0120Shaman": 34805, "reb": 34806, "\u0120stemming": 34807, "998": 34808, "\u0120MG": 34809, "sticks": 34810, "esthesia": 34811, "ERO": 34812, "\u0120morbid": 34813, "\u0120Grill": 34814, "\u0120Poe": 34815, "anyl": 34816, "\u0120deleting": 34817, "\u0120Surveillance": 34818, "\u0120directives": 34819, "\u0120iterations": 34820, "\u0120Rox": 34821, "\u0120Milky": 34822, "Father": 34823, "\u0120patented": 34824, "447": 34825, "\u0120precursor": 34826, "\u0120maiden": 34827, "\u0120Phen": 34828, "\u0120Vegan": 34829, "\u0120Patent": 34830, "Kelly": 34831, "Redditor": 34832, "\u0120nods": 34833, "\u0120ventilation": 34834, "\u0120Schwarz": 34835, "\u0120wizards": 34836, "\u0120ominous": 34837, "\u0120Heads": 34838, "\u0120BG": 34839, "\u0120lumber": 34840, "\u0120Spiel": 34841, "\u0120isEnabled": 34842, "\u0120ancestral": 34843, "\u0120Ships": 34844, "\u0120wrestler": 34845, "phi": 34846, "\u0120yuan": 34847, "\u0120Rebellion": 34848, "\u0120iceberg": 34849, "\u0120magically": 34850, "\u0120diversion": 34851, "arro": 34852, "ythm": 34853, "\u0120Riders": 34854, "\u0120Robbie": 34855, "\u0120Kara": 34856, "\u0120Maintenance": 34857, "\u0120Herb": 34858, "\u0120harms": 34859, "packed": 34860, "\u0120Feinstein": 34861, "\u0120marrying": 34862, "\u0120blending": 34863, "\u0120Rates": 34864, "\u01201880": 34865, "\u0120wrink": 34866, "\u0120Unch": 34867, "\u0120Torch": 34868, "described": 34869, "\u0120humanoid": 34870, "ilitating": 34871, "\u0120Conv": 34872, "\u0120Feld": 34873, "IGHTS": 34874, "\u0120whistleblower": 34875, "ortmund": 34876, "etsy": 34877, "arrett": 34878, "\u0120Mono": 34879, "\u0120Ike": 34880, "\u0120CNBC": 34881, "\u0120WAY": 34882, "\u0120MDMA": 34883, "\u0120Individuals": 34884, "\u0120supplemental": 34885, "\u0120powerhouse": 34886, "\u0120Stru": 34887, "Focus": 34888, "aphael": 34889, "\u0120Colleg": 34890, "atti": 34891, "ZA": 34892, "\u0120perenn": 34893, "\u0120Signature": 34894, "\u0120Rodney": 34895, "\u0120cubes": 34896, "iddled": 34897, "\u0120Dante": 34898, "\u0120INV": 34899, "ilingual": 34900, "\u0120Cth": 34901, "\u0120sofa": 34902, "\u0120intimidate": 34903, "\u0120Roe": 34904, "\u0120Diplom": 34905, "\u0120Countries": 34906, "ayson": 34907, "\u0120extradition": 34908, "\u0120disabling": 34909, "\u0120Cardiff": 34910, "\u0120memorandum": 34911, "\u0120Trace": 34912, "\u0120???": 34913, "sector": 34914, "\u0120Rouhani": 34915, "\u0120Yates": 34916, "\u0120Freeze": 34917, "\u0120bladder": 34918, "Motor": 34919, "\u0120Promise": 34920, "antasy": 34921, "\u0120foreseeable": 34922, "\u0120Cologne": 34923, "container": 34924, "\u0120Trees": 34925, "\u0120Gors": 34926, "\u0120Sinclair": 34927, "\u0120barring": 34928, "keye": 34929, "\u0120slashed": 34930, "\u0120Statistical": 34931, "\u00e9\u0129": 34932, "\u0120\u00e2\u0138\u00ba": 34933, "Allows": 34934, "\u0120humility": 34935, "\u0120drilled": 34936, "\u0120Furn": 34937, "443": 34938, "\u0120sewage": 34939, "\u0120homepage": 34940, "\u0120courtyard": 34941, "\u0120vile": 34942, "\u0120subsidiaries": 34943, "ajo": 34944, "directory": 34945, "\u0120ammon": 34946, "Vers": 34947, "charges": 34948, "\u0120}}": 34949, "\u0120Chains": 34950, "\u0120246": 34951, "nob": 34952, "\u0120percept": 34953, "\u0120grit": 34954, "\u0120fishermen": 34955, "\u0120Iraqis": 34956, "\u0120DISTR": 34957, "\u0120FULL": 34958, "\u0120Evaluation": 34959, "graph": 34960, "atial": 34961, "\u0120cooperating": 34962, "\u0120melan": 34963, "\u0120enlightened": 34964, "\u0120ali": 34965, "tailed": 34966, "\u0120salute": 34967, "\u0120weakest": 34968, "\u0120Bulldogs": 34969, "UA": 34970, "\u0120Alloy": 34971, "\u0120semen": 34972, "ocene": 34973, "\u0120Williamson": 34974, "spr": 34975, ",\u00e2\u0122\u0136": 34976, "\u0120GF": 34977, "ittens": 34978, "Beat": 34979, "\u0120Junk": 34980, "iphate": 34981, "\u0120Farmers": 34982, "\u0120Bitcoins": 34983, "igers": 34984, "dh": 34985, "\u0120Loyal": 34986, "payer": 34987, "\u0120entertained": 34988, "\u0120penned": 34989, "\u0120coupon": 34990, "Queue": 34991, "\u0120weakening": 34992, "carry": 34993, "\u0120underestimate": 34994, "\u0120shootout": 34995, "\u0120charismatic": 34996, "\u0120Procedure": 34997, "\u0120prudent": 34998, "inances": 34999, "\u0120riches": 35000, "\u0120cortical": 35001, "\u0120strides": 35002, "\u0120drib": 35003, "\u0120Oilers": 35004, "540": 35005, "\u0120Perform": 35006, "\u0120Bangkok": 35007, "\u0120euth": 35008, "SER": 35009, "\u0120simplistic": 35010, "tops": 35011, "campaign": 35012, "Quality": 35013, "\u0120impoverished": 35014, "\u0120Eisenhower": 35015, "\u0120augment": 35016, "\u0120Harden": 35017, "\u0120intervened": 35018, "\u0120listens": 35019, "\u0120Kok": 35020, "\u0120sage": 35021, "\u0120rubbish": 35022, "\u0120Ded": 35023, "\u0120mull": 35024, "pelling": 35025, "\u0120videot": 35026, "Production": 35027, "DJ": 35028, "miah": 35029, "\u0120adaptations": 35030, "\u0120medically": 35031, "\u0120boarded": 35032, "\u0120arrogance": 35033, "\u0120scrapped": 35034, "\u0120oppress": 35035, "FORMATION": 35036, "\u0120junction": 35037, "415": 35038, "EEEE": 35039, "Skill": 35040, "\u0120subdu": 35041, "\u0120Suggest": 35042, "\u0120Pett": 35043, "\u0120lett": 35044, "\u0120Manip": 35045, "\u0120Caf": 35046, "\u0120Cooperation": 35047, "Ther": 35048, "\u0120regained": 35049, "\u00b6\u00e6": 35050, "reflect": 35051, "\u0120thugs": 35052, "\u0120Shelby": 35053, "\u0120dictates": 35054, "\u0120Weiner": 35055, "\u0120Hale": 35056, "\u0120battleground": 35057, "schild": 35058, "\u0120condol": 35059, "hunt": 35060, "ositories": 35061, "\u0120accuses": 35062, "Filename": 35063, "\u0120shri": 35064, "\u0120motivate": 35065, "\u0120reflections": 35066, "Null": 35067, "\u0120Lobby": 35068, "\u00a5\u00b5": 35069, "\u0120SATA": 35070, "\u0120Backup": 35071, "\u00d1\u0125": 35072, "nin": 35073, "\u0120Correction": 35074, "\u0120juicy": 35075, "utra": 35076, "\u0120Pric": 35077, "\u0120restraining": 35078, "\u0120Airbnb": 35079, "\u0120Arrest": 35080, "\u0120appropriations": 35081, "\u0120slopes": 35082, "\u0120manslaughter": 35083, "\u0120workings": 35084, "\u0120Huss": 35085, "\u0120Frey": 35086, "Leave": 35087, "\u0120Harmony": 35088, "\u0120Feder": 35089, "\u0120430": 35090, "\u0120trench": 35091, "\u0120gladly": 35092, "\u0120bullpen": 35093, "\u0120Gau": 35094, "bones": 35095, "\u0120groove": 35096, "\u0120pretext": 35097, "\u00e3\u0127\u012d": 35098, "\u0120transmitter": 35099, "\u0120Component": 35100, "\u0120underage": 35101, "\u0120Empires": 35102, "Tile": 35103, "\u0120oy": 35104, "\u0120Marvin": 35105, "\u0120CAS": 35106, "\u0120bloss": 35107, "\u0120replicated": 35108, "\u0120Mariners": 35109, "Marcus": 35110, "\u0120Blocks": 35111, "\u0120liberated": 35112, "\u0120butterfly": 35113, "Feel": 35114, "\u0120fermentation": 35115, "\u0120youtube": 35116, "\u0120offend": 35117, "\u0120Term": 35118, "resist": 35119, "\u0120cessation": 35120, "\u0120insurgency": 35121, "\u0120bir": 35122, "\u0120Raise": 35123, "595": 35124, "\u0120hypotheses": 35125, "502": 35126, "\u0120plaque": 35127, "ocrat": 35128, "\u0120jackets": 35129, "\u0120HuffPost": 35130, "among": 35131, "\u0120confer": 35132, "487": 35133, "\u0120Lilly": 35134, "\u0120adapting": 35135, "\u0120Fay": 35136, "\u0120shoved": 35137, "vec": 35138, "\u0120refine": 35139, "\u0120gon": 35140, "\u0120gunmen": 35141, "zai": 35142, "\u0120Shuttle": 35143, "\u0120Izan": 35144, "\u01201913": 35145, "\u0120plethora": 35146, "\u00c2\u00b7\u00c2\u00b7": 35147, "\u0120510": 35148, "\u0120puberty": 35149, "\u0120241": 35150, "\u0120Wealth": 35151, "\u0120Alma": 35152, "\u0120MEM": 35153, "\u0120Adults": 35154, "Cas": 35155, "prison": 35156, "Race": 35157, "\u0120waterproof": 35158, "\u0120athleticism": 35159, "\u0120capitalize": 35160, "\u0120Juice": 35161, "\u0120illuminated": 35162, "\u0120Pascal": 35163, "\u0120irritation": 35164, "\u0120Witnesses": 35165, "adle": 35166, "\u0120Astro": 35167, "\u0120fax": 35168, "\u0120Elvis": 35169, "Primary": 35170, "\u0120Lich": 35171, "\u0120Elves": 35172, "\u0120residing": 35173, "\u0120stumble": 35174, "319": 35175, "\u0120PKK": 35176, "\u0120adversaries": 35177, "DOS": 35178, "\u0120Ritual": 35179, "\u0120smear": 35180, "\u0120arson": 35181, "idental": 35182, "\u0120scant": 35183, "\u0120monarchy": 35184, "\u0120halftime": 35185, "\u0120residue": 35186, "\u0120indign": 35187, "\u0120Shaun": 35188, "\u0120Elm": 35189, "auri": 35190, "Aff": 35191, "WATCH": 35192, "\u0120Lyon": 35193, "helps": 35194, "361": 35195, "\u0120lobbyist": 35196, "\u0120diminishing": 35197, "\u0120outbreaks": 35198, "\u0120goats": 35199, "favorite": 35200, "\u0120Nah": 35201, "sonian": 35202, "\u0120Booster": 35203, "\u0120sandbox": 35204, "\u0120Fare": 35205, "\u0120Malta": 35206, "\u0120attRot": 35207, "\u0120MOR": 35208, "lde": 35209, "\u0120navigating": 35210, "Touch": 35211, "\u0120untrue": 35212, "\u0120Disaster": 35213, "\u0120ludicrous": 35214, "Password": 35215, "\u0120JFK": 35216, "blogspot": 35217, "416": 35218, "\u0120UNDER": 35219, "ernal": 35220, "\u0120delaying": 35221, "TOP": 35222, "\u0120implants": 35223, "\u0120AVG": 35224, "\u0120Huge": 35225, "attr": 35226, "\u0120journalistic": 35227, "\u0120Peyton": 35228, "\u0120IA": 35229, "Rap": 35230, "goal": 35231, "\u0120Programme": 35232, "\u0120smashing": 35233, "wives": 35234, "println": 35235, "\u0120Plague": 35236, "inus": 35237, "EEP": 35238, "\u0120cruiser": 35239, "\u0120Parish": 35240, "uminium": 35241, "\u0120occupants": 35242, "\u0120Jihad": 35243, "mop": 35244, "\u0120pint": 35245, "\u0120hect": 35246, "\u0120Mecca": 35247, "director": 35248, "\u0120Funding": 35249, "\u0120Mixed": 35250, "\u0120stag": 35251, "Tier": 35252, "\u0120gust": 35253, "\u0120brightly": 35254, "orsi": 35255, "\u0120uphill": 35256, "RD": 35257, "\u0120lesions": 35258, "\u0120Bundy": 35259, "livious": 35260, "\u0120biologist": 35261, "\u0120Faculty": 35262, "\u0120Authorization": 35263, "\u0120244": 35264, "Allow": 35265, "\u00ef\u00b8": 35266, "\u0120Giul": 35267, "\u0120pertinent": 35268, "otaur": 35269, "esse": 35270, "\u0120Roof": 35271, "\u0120unmanned": 35272, "351": 35273, "\u0120Shak": 35274, "\u0120Orient": 35275, "\u0120endanger": 35276, "Dir": 35277, "\u0120replen": 35278, "edient": 35279, "\u0120tailor": 35280, "\u0120gadgets": 35281, "\u0120audible": 35282, "\u00e2\u013a\u0128": 35283, "Nice": 35284, "\u0120bombard": 35285, "\u0120Rape": 35286, "\u0120defiance": 35287, "\u0120TWO": 35288, "\u0120Filipino": 35289, "\u0120unaffected": 35290, "ervatives": 35291, "\u0120soared": 35292, "\u0120Bolton": 35293, "\u0120compromising": 35294, "\u0120Brewers": 35295, "RAL": 35296, "\u0120AHL": 35297, "icycle": 35298, "\u0120vampires": 35299, "\u0120dipped": 35300, "oyer": 35301, "\u0120XIII": 35302, "\u0120sideways": 35303, "\u0120Waste": 35304, "\u0120Diss": 35305, "\u0120\u00e2\u0136\u013e\u00e2\u0136\u0122\u00e2\u0136\u0122": 35306, "$.": 35307, "\u0120habitats": 35308, "\u0120Beef": 35309, "truth": 35310, "trained": 35311, "split": 35312, "Rus": 35313, "Andy": 35314, "\u0120Bram": 35315, "REP": 35316, "pid": 35317, "\u00e8\u00a3\u0127": 35318, "\u0120Mutant": 35319, "Anim": 35320, "\u0120Marina": 35321, "\u0120futile": 35322, "highest": 35323, "frequency": 35324, "\u0120epilepsy": 35325, "\u0120coping": 35326, "\u0120concise": 35327, "\u0120tracing": 35328, "\u0120SUN": 35329, "panel": 35330, "\u0120Sophie": 35331, "\u0120Crowley": 35332, "\u0120Adolf": 35333, "\u0120Shooter": 35334, "\u0120shaky": 35335, "\u0120IG": 35336, "\u0120Lies": 35337, "\u0120Barber": 35338, "pkg": 35339, "\u0120uptake": 35340, "\u0120predatory": 35341, "ULTS": 35342, "/**": 35343, "\u0120intoxicated": 35344, "\u0120Westbrook": 35345, "odder": 35346, "hement": 35347, "\u0120baseman": 35348, "APD": 35349, "storage": 35350, "\u0120Fifty": 35351, "editor": 35352, "GEN": 35353, "UTION": 35354, "irting": 35355, "\u0120sewing": 35356, "rift": 35357, "\u0120agony": 35358, "\u0120Sands": 35359, "\u0120254": 35360, "Cash": 35361, "\u0120lodge": 35362, "\u0120punt": 35363, "Natural": 35364, "\u0120Ideas": 35365, "\u0120erroneous": 35366, "\u0120Sensor": 35367, "\u0120Hannity": 35368, "\u01201921": 35369, "\u0120mould": 35370, "\u0120Gon": 35371, "kaya": 35372, "\u0120anonymously": 35373, "\u0120KEY": 35374, "\u0120simulator": 35375, "Winter": 35376, "\u0120streamed": 35377, "507": 35378, "?\",": 35379, "\u0120teased": 35380, "\u0120coefficient": 35381, "\u0120wartime": 35382, "\u0120THR": 35383, "''.": 35384, "\u0120Banking": 35385, "mpire": 35386, "\u0120fandom": 35387, "\u0120lia": 35388, "Ga": 35389, "\u0120downhill": 35390, "\u0120interpreting": 35391, "Individual": 35392, "Norm": 35393, "\u0120jealousy": 35394, "bitcoin": 35395, "\u0120pleasures": 35396, "\u0120Toys": 35397, "\u0120Chevrolet": 35398, "\u0120Advisor": 35399, "IZE": 35400, "\u0120receptions": 35401, "706": 35402, "Cro": 35403, "\u0120262": 35404, "\u0120citrus": 35405, "iru": 35406, "Reviewer": 35407, "jected": 35408, "UES": 35409, "anz": 35410, "1981": 35411, "\u0120Worker": 35412, "\u0120complied": 35413, "orescent": 35414, "continental": 35415, "Ton": 35416, "\u0120Prism": 35417, "\u0120Sheep": 35418, "\u0120288": 35419, "nox": 35420, "\u0120Vog": 35421, "Ord": 35422, "\u0120realms": 35423, "tek": 35424, "\u0120irrigation": 35425, "\u0120bicycles": 35426, "\u0120electronically": 35427, "poly": 35428, "tall": 35429, "());": 35430, "\u0120aesthetics": 35431, "\u0120Integrated": 35432, "Explore": 35433, "\u0120dunk": 35434, "476": 35435, "pain": 35436, "\u0120Jacques": 35437, "\u0120Dmit": 35438, "Frames": 35439, "\u0120reunited": 35440, "\u0120humid": 35441, "Dro": 35442, "Political": 35443, "\u0120youthful": 35444, "\u0120entails": 35445, "\u0120mosquito": 35446, "363": 35447, "species": 35448, "\u0120coordinating": 35449, "\u0120Mayhem": 35450, "\u0120Magnus": 35451, "Mount": 35452, "Improved": 35453, "\u0120STATE": 35454, "ATTLE": 35455, "\u0120flowed": 35456, "\u0120tackled": 35457, "\u0120fashioned": 35458, "\u0120reorgan": 35459, "ivari": 35460, "finger": 35461, "\u0120reluctantly": 35462, "etting": 35463, "\u0120Vand": 35464, "young": 35465, "\u0120Garland": 35466, "\u0120presumption": 35467, "\u0120amenities": 35468, "\u0120Pleasant": 35469, "onential": 35470, "\u0120Oxy": 35471, "\u0120morals": 35472, "\u0120Yah": 35473, "Ready": 35474, "Simon": 35475, "Enh": 35476, "Demon": 35477, "\u0120clich": 35478, "Monitor": 35479, "\u0120DU": 35480, "\u0120welcomes": 35481, "\u0120standout": 35482, "\u0120dreadful": 35483, "\u0120bananas": 35484, "\u0120balloons": 35485, "hooting": 35486, "basic": 35487, "\u0120suffix": 35488, "\u0120duly": 35489, "cano": 35490, "Chain": 35491, "atos": 35492, "\u0120geopolitical": 35493, "\u0120(&": 35494, "\u0120Gemini": 35495, "\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124\u00c3\u0125\u00c3\u0124": 35496, "\u0120acquitted": 35497, "Luck": 35498, "protect": 35499, "1024": 35500, "\u0120scarcity": 35501, "\u0120mindfulness": 35502, "ecided": 35503, "DN": 35504, "prime": 35505, "\u0120Presidents": 35506, "\u0120VIDEO": 35507, "\u0120(\u00e2\u012a\u0134": 35508, "addock": 35509, "NOR": 35510, "\u0120Pru": 35511, "pun": 35512, "\u0120LOL": 35513, "))))": 35514, "\u0120Liqu": 35515, "\u0120SAS": 35516, "\u0120styling": 35517, "\u0120punishments": 35518, "\u0120numb": 35519, "\u0120ascertain": 35520, "\u0120Rockies": 35521, "flu": 35522, "Thumbnail": 35523, "\u0120perpetrated": 35524, "\u0120Semi": 35525, "\u0120disarm": 35526, "\u0120Older": 35527, "\u0120Exception": 35528, "\u0120exponentially": 35529, "\u0120Communities": 35530, "\u0120abolish": 35531, "\u0120Partner": 35532, "ptoms": 35533, "\u0120777": 35534, "\u0120Foley": 35535, "\u0120Cases": 35536, "\u0120grease": 35537, "\u0120Rebirth": 35538, "Ground": 35539, "\u0120;)": 35540, "\u0120Doctrine": 35541, "ikini": 35542, "Ye": 35543, "\u0120Blossom": 35544, "\u0120persists": 35545, "bill": 35546, "\u0120infusion": 35547, "\u0120buddies": 35548, "911": 35549, "\u0120Patient": 35550, "\u0120demos": 35551, "\u0120acquaintance": 35552, "\u0120Paw": 35553, "atari": 35554, "\u0120xml": 35555, "\u0120fascination": 35556, "\u0120Serve": 35557, "\u00cf\u0124": 35558, "branded": 35559, "\u0120az": 35560, "Returns": 35561, "\u0120overshadow": 35562, "\u0120roam": 35563, "\u0120speedy": 35564, "numbered": 35565, "helial": 35566, "\u0120disciple": 35567, "\u0120assurances": 35568, "given": 35569, "pecting": 35570, "\u0120Natalie": 35571, "\u00e7\u0136\u00b0": 35572, "\u0120mosquitoes": 35573, "rotein": 35574, "\u0120numeric": 35575, "\u0120independents": 35576, "\u0120transitional": 35577, "\u0120reactionary": 35578, "\u0120Mechdragon": 35579, "doctor": 35580, "\u0120shortest": 35581, "\u0120sequential": 35582, "\u0120Bac": 35583, "\u0120Accounts": 35584, "\u00e3\u0123\u012e": 35585, "achy": 35586, "ractive": 35587, "\u0120Regiment": 35588, "\u0120breathtaking": 35589, "fficiency": 35590, "\u0120Bates": 35591, "\u0120311": 35592, "\u0120wardrobe": 35593, "fts": 35594, "\u0120Berk": 35595, "Simply": 35596, "\u0120Riverside": 35597, "ivering": 35598, "idential": 35599, "lucent": 35600, "\u0120enriched": 35601, "\u0120Conver": 35602, "\u0120Giving": 35603, "\u00e3\u0125\u013b": 35604, "\u0120legalize": 35605, "\u0120FTC": 35606, "\u0120freaking": 35607, "Mix": 35608, "\u0120terrestrial": 35609, "esian": 35610, "cients": 35611, "Wing": 35612, "LOAD": 35613, "\u0120ledge": 35614, "\u0120Violent": 35615, "\u0120Metall": 35616, "\u0120308": 35617, "\u0120southeastern": 35618, "hetto": 35619, "Meat": 35620, "\u0120slowdown": 35621, "\u0120retreated": 35622, "Jeremy": 35623, "endas": 35624, "*****": 35625, "eric": 35626, "\u0120reins": 35627, "oppable": 35628, "\u0120Humanity": 35629, "earances": 35630, "rigan": 35631, "Camera": 35632, "\u0120waivers": 35633, "soc": 35634, "\u0120alteration": 35635, "transform": 35636, "\u0120Cemetery": 35637, "506": 35638, "\u0120indefinite": 35639, "\u0120stimulating": 35640, "yg": 35641, "603": 35642, "\u0120Sop": 35643, "\u0120descriptive": 35644, "Phase": 35645, "\u0120Edmund": 35646, "\u0120pneumonia": 35647, "ventus": 35648, "Amb": 35649, "\u0120laboratories": 35650, "\u0120Exclusive": 35651, "ugar": 35652, "Were": 35653, "\u0120malfunction": 35654, "\u0120homosexuals": 35655, "\u0120-------": 35656, "uni": 35657, "\u0120turbines": 35658, "\u0120Equity": 35659, "Du": 35660, "\u0120minded": 35661, "\u0120RH": 35662, "\u0120Blackhawks": 35663, "\u0120feats": 35664, "\u01201700": 35665, "repl": 35666, "362": 35667, "laden": 35668, "\u0120indispensable": 35669, "lyss": 35670, "tti": 35671, "\u0120reel": 35672, "\u0120diverted": 35673, "\u0120likeness": 35674, "\u0120subscriptions": 35675, "\u0120fingert": 35676, "\u0120filthy": 35677, "destruct": 35678, "draft": 35679, "\u0120Bernardino": 35680, "launch": 35681, "\u0120perplex": 35682, "\u0120SUM": 35683, "carb": 35684, "\u0120sweater": 35685, "\u0120Venture": 35686, "\u0120Jag": 35687, "\u0120Celeb": 35688, "\u0120Voters": 35689, "\u0120steadfast": 35690, "\u0120athletics": 35691, "\u0120Hanson": 35692, "\u0120Drac": 35693, "Tracker": 35694, "\u0120commend": 35695, "\u0120Presidency": 35696, "\u0120DID": 35697, "informed": 35698, "\u0120webpage": 35699, "Pretty": 35700, "\u0120forcefully": 35701, "\u00e3\u0125\u0125\u00e3\u0124\u00af": 35702, "\u0120relocation": 35703, "\u0120satire": 35704, "\u00e2\u012b": 35705, "\u0120Sunderland": 35706, "\u00e6\u0126": 35707, "Voice": 35708, "????????": 35709, "\u0120informant": 35710, "\u0120bowel": 35711, "\u0120Uniform": 35712, "\u0120...\"": 35713, "\u0120purge": 35714, "\u0120picnic": 35715, "\u0120Umb": 35716, "\u0120UPDATE": 35717, "\u0120Sapphire": 35718, "\u0120Stall": 35719, "learn": 35720, "\u0120objectively": 35721, "\u0120obliter": 35722, "\u0120loophole": 35723, "\u0120journeys": 35724, "\u0120omission": 35725, "Pros": 35726, "\u0120Sidney": 35727, "ploma": 35728, "\u0120sprayed": 35729, "\u0120guru": 35730, "\u0120traitor": 35731, "\u0120timet": 35732, "\u0120snapping": 35733, "\u0120Sevent": 35734, "urnal": 35735, "\u0120Ukip": 35736, "\u0120bowed": 35737, "poral": 35738, "liberal": 35739, "Ros": 35740, "Questions": 35741, "iOS": 35742, "\u0120summarize": 35743, "STAT": 35744, "\u01201850": 35745, "apest": 35746, "\u0120lender": 35747, "\u0120Variable": 35748, "bringing": 35749, "\u0120LORD": 35750, ",)": 35751, "\u0120collapses": 35752, "xiety": 35753, "\u0120Ned": 35754, "YD": 35755, "\u0120Scha": 35756, "\u0120antibody": 35757, "\u0120disband": 35758, "yre": 35759, "illusion": 35760, "\u0120rover": 35761, "shed": 35762, "\u0120Hirosh": 35763, "cci": 35764, "\u0120calam": 35765, "\u0120Morton": 35766, "Pinterest": 35767, "\u01201928": 35768, "\u0120Euras": 35769, "ordes": 35770, "\u0120fences": 35771, "\u0120Inventory": 35772, "\u0120Valencia": 35773, "\u0120Ud": 35774, "\u0120Tiff": 35775, "\u0120sque": 35776, "\u0120quotation": 35777, "\u0120troublesome": 35778, "erker": 35779, "QUEST": 35780, "\u0120Kingdoms": 35781, "south": 35782, "\u0120levy": 35783, "Prince": 35784, "\u0120Sting": 35785, "\u0120nicknamed": 35786, "\u0120appe": 35787, "\u0120photographic": 35788, "\u0120corpus": 35789, "reference": 35790, "\u0120Trog": 35791, "Unt": 35792, ")=(": 35793, "\u0120Latvia": 35794, "\u0120activating": 35795, "\u0120licensee": 35796, "\u0120disparities": 35797, "\u0120Newsletter": 35798, "\u00e3\u0125\u0125\u00e3\u0125\u012a": 35799, "\u0120freeing": 35800, "\u0120Jeep": 35801, "\u0120Perception": 35802, "insk": 35803, "\u0120silicone": 35804, "\u0120Hayden": 35805, "Lean": 35806, "\u0120Suzuki": 35807, "ibrarian": 35808, "668": 35809, "\u0120spor": 35810, "\u0120correlations": 35811, "aghetti": 35812, "\u0120tuber": 35813, "\u0120IPCC": 35814, "ilus": 35815, "\u0120Vu": 35816, "\u0120wealthiest": 35817, "\u0120Carbuncle": 35818, "anza": 35819, "\u0120fooled": 35820, "\u0120Zur": 35821, "\u0120daddy": 35822, "rano": 35823, "ilian": 35824, "\u0120knockout": 35825, "fman": 35826, "required": 35827, "\u0120Wikileaks": 35828, "\u0120Duffy": 35829, "ONT": 35830, "\u0120insol": 35831, "\u0120Objects": 35832, "\u0120bou": 35833, "\u0120Nordic": 35834, "\u0120Insert": 35835, "scan": 35836, "\u0120dancers": 35837, "\u0120idiots": 35838, "majority": 35839, "\u0120Neville": 35840, "\u0120FreeBSD": 35841, "\u0120tart": 35842, "panic": 35843, "690": 35844, "\u0120cocoa": 35845, "\u0120sampled": 35846, "\u0120lookup": 35847, "Indust": 35848, "\u0120injections": 35849, "genre": 35850, "\u0120au": 35851, "\u0120roadway": 35852, "\u0120genitals": 35853, "Kind": 35854, "\u0120Examiner": 35855, "\u0120Yaz": 35856, "Fresh": 35857, "\u0120paralysis": 35858, "\u0120Aluminum": 35859, "\u0120reap": 35860, "ok\u00c3\u00a9": 35861, "\u0120sloppy": 35862, "\u0120Tunnel": 35863, "posium": 35864, "nery": 35865, "enic": 35866, "\u0120herbal": 35867, "\u0120Outer": 35868, "\u0120Builder": 35869, "\u0120incur": 35870, "\u0120ideologies": 35871, "\u0120backups": 35872, "consuming": 35873, "\u0120Detect": 35874, "deck": 35875, "\u0120KNOW": 35876, "\u0120Gret": 35877, "\u0120MIC": 35878, "\u0120toughness": 35879, "\u0120Exhibit": 35880, "\u0120hive": 35881, "Les": 35882, "\u0120SCHOOL": 35883, "\u0120Atari": 35884, "alde": 35885, "\u0120Null": 35886, "andestine": 35887, "mouse": 35888, "\u0120brigade": 35889, "489": 35890, "\u0120revol": 35891, "\u0120Lawson": 35892, "\u0120Wah": 35893, "opoly": 35894, "ebted": 35895, "\u0120Saunders": 35896, "\u0120313": 35897, "\u0120Winc": 35898, "\u0120taboo": 35899, "\u0120Helmet": 35900, "\u0120wedge": 35901, "chip": 35902, "\u0120Tina": 35903, "bg": 35904, "\u0120infuri": 35905, "rn": 35906, "\u0120anomalies": 35907, "\u0120Sync": 35908, "\u0120Exam": 35909, "\u0120Commit": 35910, "\u0120Diary": 35911, "\u0120ALSO": 35912, "\u0120Debor": 35913, "omedical": 35914, "\u0120comprehension": 35915, "655": 35916, "\u0120empowering": 35917, "\u0120ire": 35918, "\u0120juices": 35919, "\u0120ETH": 35920, "\u0120Boxing": 35921, "=\"/": 35922, "\u0120facilitated": 35923, "poke": 35924, "\u0120Parsons": 35925, "\u0120Moder": 35926, "travel": 35927, "\u0120civilizations": 35928, "\u0120libertarians": 35929, "\u0120rune": 35930, "\u0120Clarks": 35931, "athed": 35932, "\u0120campaigners": 35933, "\u0120Dispatch": 35934, "\u0120Fahrenheit": 35935, "\u0120Capcom": 35936, "----------": 35937, "\u0120lace": 35938, "\u0120draining": 35939, "\u0120liner": 35940, "\u0120Artificial": 35941, "\u00c3\u00a9n": 35942, "task": 35943, "]).": 35944, "\u0120GMO": 35945, "\u0120Operator": 35946, "ordinary": 35947, "\u0120Influence": 35948, "\u0120Ups": 35949, "\u0120potency": 35950, "ussen": 35951, "ospons": 35952, "\u0120Swim": 35953, "\u0120Deadline": 35954, "Unity": 35955, "\u0120culinary": 35956, "\u0120enlightenment": 35957, "\u0120wearer": 35958, "\u0120mined": 35959, "\u0120ply": 35960, "\u0120incest": 35961, "\u0120DVDs": 35962, "Walk": 35963, "BTC": 35964, "Trade": 35965, "\u0120deval": 35966, "iband": 35967, "\u0120Oversight": 35968, "Palestinian": 35969, "\u0120dart": 35970, "\u0120mul": 35971, "LR": 35972, "\u0120removable": 35973, "\u0120Realms": 35974, "\u00ec\u013f": 35975, "\u0120miscar": 35976, "\u0120Vulkan": 35977, "685": 35978, "\u00c3\u00a8re": 35979, "\u0120Sap": 35980, "\u0120merging": 35981, "\u0120Carly": 35982, "chester": 35983, "\u0120brisk": 35984, "\u0120luxurious": 35985, "\u0120Generator": 35986, "\u0120bitterness": 35987, "\u0120edible": 35988, "\u0120243": 35989, "TG": 35990, "\u0120rectangle": 35991, "WithNo": 35992, "below": 35993, "Jenn": 35994, "\u0120darkest": 35995, "\u0120hitch": 35996, "\u0120dosage": 35997, "\u0120scaven": 35998, "\u0120Keller": 35999, "\u0120Illustrated": 36000, "Certainly": 36001, "\u0120Mavericks": 36002, "Marginal": 36003, "\u0120diarrhea": 36004, "\u0120enormously": 36005, "\u0120999": 36006, "shr": 36007, "quart": 36008, "\u0120adamant": 36009, "\u0120Mew": 36010, "\u0120renovation": 36011, "\u0120cervical": 36012, "\u0120Percentage": 36013, "eners": 36014, "\u0120Kimber": 36015, "\u0120floats": 36016, "\u0120dex": 36017, "\u0120Witcher": 36018, "\u0120Swansea": 36019, "dm": 36020, "\u0120salty": 36021, "yellow": 36022, "\u0120cape": 36023, "\u0120Drain": 36024, "\u0120Paula": 36025, "\u0120Toledo": 36026, "lesi": 36027, "Magazine": 36028, "\u0120Wick": 36029, "\u0120Mn": 36030, "\u0120Ack": 36031, "\u0120Riding": 36032, "ASON": 36033, "\u0120homophobic": 36034, "ARP": 36035, "\u0120wandered": 36036, "CPU": 36037, "oodoo": 36038, "\u0120Pipe": 36039, "\u0120tightening": 36040, "\u0120Butt": 36041, "318": 36042, "\u0120deserted": 36043, "Session": 36044, "\u0120facilitating": 36045, "Jump": 36046, "\u0120emergencies": 36047, "OWER": 36048, "\u0120exhaustive": 36049, "\u0120AFTER": 36050, "\u0120heartbeat": 36051, "\u0120Label": 36052, "acky": 36053, "\u0120Certified": 36054, "iltration": 36055, "Ze": 36056, "\u0120Utt": 36057, "\u01201300": 36058, "\u0120presume": 36059, "\u0120Disp": 36060, "\u0120surged": 36061, "\u0120dolls": 36062, "Columb": 36063, "\u0120chimpan": 36064, "\u0120Razor": 36065, "\u0120ticks": 36066, "\u0120councillor": 36067, "\u0120pilgrimage": 36068, "\u0120Rebels": 36069, "\u0120QC": 36070, "\u0120Auction": 36071, "xia": 36072, "ikk": 36073, "bred": 36074, "\u0120insertion": 36075, "\u0120coarse": 36076, "dB": 36077, "SEE": 36078, "\u0120Zap": 36079, "\u0120Foo": 36080, "\u0120contempor": 36081, "\u0120Quarterly": 36082, "otions": 36083, "\u0120Alchemist": 36084, "\u0120Trey": 36085, "\u0120Duo": 36086, "Sweet": 36087, "804": 36088, "\u0120Giov": 36089, "\u0120funn": 36090, "Nin": 36091, "hoff": 36092, "\u0120ramifications": 36093, "\u01201922": 36094, "\u0120Experts": 36095, "azes": 36096, "\u0120garments": 36097, "arial": 36098, "\u0120Nab": 36099, "\u0120257": 36100, "\u0120Ved": 36101, "\u0120humorous": 36102, "\u0120Pompe": 36103, "\u0120nylon": 36104, "\u0120lurking": 36105, "\u0120Sergey": 36106, "\u0120Mattis": 36107, "\u0120misogyny": 36108, "\u0120Components": 36109, "\u0120Watching": 36110, "\u0120Folk": 36111, "ractical": 36112, "Bush": 36113, "\u0120taped": 36114, "\u0120grouping": 36115, "\u0120beads": 36116, "\u01202048": 36117, "\u0120condu": 36118, "querque": 36119, "Reading": 36120, "\u0120grievances": 36121, "Ultra": 36122, "\u0120endpoint": 36123, "Hig": 36124, "\u0120Static": 36125, "\u0120Scarborough": 36126, "Lua": 36127, "\u0120Messi": 36128, "aqu": 36129, "\u0120PsyNet": 36130, "\u0120Rudd": 36131, "\u0120avenue": 36132, "vp": 36133, "Jer": 36134, "\u0120shady": 36135, "\u0120Resist": 36136, "\u0120Artemis": 36137, "\u0120careless": 36138, "\u0120brokers": 36139, "\u0120temperament": 36140, "\u0120520": 36141, "Tags": 36142, "\u0120Turning": 36143, "\u0120uttered": 36144, "\u0120pedd": 36145, "\u0120improvised": 36146, "\u0120:(": 36147, "\u0120tabl": 36148, "\u0120plains": 36149, "1600": 36150, "pressure": 36151, "\u0120Essence": 36152, "margin": 36153, "friends": 36154, "\u0120Restoration": 36155, "\u0120pollut": 36156, "\u0120Poker": 36157, "\u0120Augustine": 36158, "\u0120CIS": 36159, "\u0120SEAL": 36160, "orama": 36161, "\u0120thwart": 36162, "seek": 36163, "\u0120pagan": 36164, "\u00c2\u00ba": 36165, "cpu": 36166, "\u0120garn": 36167, "\u0120assortment": 36168, "\u0120ILCS": 36169, "tower": 36170, "Recommended": 36171, "\u0120unborn": 36172, "\u0120RandomRedditor": 36173, "\u0120RandomRedditorWithNo": 36174, "\u0120paralyzed": 36175, "\u0120eruption": 36176, "\u0120intersect": 36177, "\u0120Stoke": 36178, "\u0120Sco": 36179, "Bind": 36180, "\u00e5\u00be": 36181, "\u0120PNG": 36182, "\u0120Negative": 36183, "\u0120NOAA": 36184, "Leon": 36185, "\u0120alloy": 36186, "\u0120Lama": 36187, "\u0120Diversity": 36188, "575": 36189, "\u0120underestimated": 36190, "\u0120Scor": 36191, "\u0120mural": 36192, "\u0120busted": 36193, "soon": 36194, "lif": 36195, "\u0120nonex": 36196, "\u0120allergy": 36197, "\u0120Underworld": 36198, "\u0120Rays": 36199, "\u0120Blasio": 36200, "\u0120hrs": 36201, "\u0120Dir": 36202, "\u0120327": 36203, "byter": 36204, "\u0120replacements": 36205, "\u0120activates": 36206, "rived": 36207, "MH": 36208, "\u0120pans": 36209, "\u0120HI": 36210, "\u0120longitudinal": 36211, "\u0120nuisance": 36212, "aler": 36213, "\u0120swell": 36214, "\u0120Signed": 36215, "sci": 36216, "\u0120Isles": 36217, "\u0120AGA": 36218, "\u0120defiant": 36219, "\u0120sonic": 36220, "ocon": 36221, "KC": 36222, "\u0120Aim": 36223, "tie": 36224, "ahah": 36225, "\u0120mL": 36226, "DX": 36227, "\u0120bisc": 36228, "\u0120Billboard": 36229, "\u0120SYSTEM": 36230, "NEY": 36231, "gaard": 36232, "\u0120distressed": 36233, "formerly": 36234, "Alan": 36235, "\u0120chefs": 36236, "\u0120optics": 36237, "\u0120Comet": 36238, "\u0120AMC": 36239, "\u0120redesigned": 36240, "irmation": 36241, "\u0120sightings": 36242, "382": 36243, "311": 36244, "\u0120WB": 36245, "\u0120contraction": 36246, "\u0120TOTAL": 36247, "Dual": 36248, "\u0120startled": 36249, "\u0120understandably": 36250, "\u0120sunglasses": 36251, "ETHOD": 36252, "\u0120docker": 36253, "\u0120surfing": 36254, "\u0120HEL": 36255, "\u0120Slack": 36256, "tones": 36257, "\u0120shalt": 36258, "Visual": 36259, "498": 36260, "Department": 36261, "cussion": 36262, "\u0120unrestricted": 36263, "\u0120tad": 36264, "\u0120rename": 36265, "employed": 36266, "\u0120educating": 36267, "\u0120grinned": 36268, "bedroom": 36269, "\u0120Activities": 36270, "\u0120Velvet": 36271, "\u0120SWAT": 36272, "\u0120shuffle": 36273, "igor": 36274, "\u0120saturation": 36275, "Finding": 36276, "cream": 36277, "icter": 36278, "\u0120vodka": 36279, "tracking": 36280, "tec": 36281, "\u0120foreground": 36282, "iesta": 36283, "\u0120vehement": 36284, "\u0120ECB": 36285, "\u0120Tie": 36286, "Ey": 36287, "\u0120turtles": 36288, "\u0120Railroad": 36289, "\u0120Katz": 36290, "\u0120Frames": 36291, "\u0120menace": 36292, "\u0120Fellowship": 36293, "\u0120Essential": 36294, "uggish": 36295, "\u0120drip": 36296, "chwitz": 36297, "\u0120Kyoto": 36298, "sb": 36299, "\u0120Nina": 36300, "Parameter": 36301, "\u0120alarms": 36302, "\u0120Claud": 36303, "\u0120pioneering": 36304, "\u0120chiefly": 36305, "\u0120Scream": 36306, "Collection": 36307, "\u0120thankfully": 36308, "\u0120Ronaldo": 36309, "\u00e5\u0143\u0132": 36310, "strip": 36311, "\u0120Disneyland": 36312, "commercial": 36313, "Seeing": 36314, "Soul": 36315, "\u0120evacuate": 36316, "\u0120civ": 36317, "\u0120Ashe": 36318, "\u0120divides": 36319, "\u0120Dagger": 36320, "rehensive": 36321, "\u0120berries": 36322, "\u0120DF": 36323, "\u0120sushi": 36324, "\u0120plurality": 36325, "WI": 36326, "\u0120disadvantaged": 36327, "\u0120battalion": 36328, "obiles": 36329, "451": 36330, "\u0120cling": 36331, "\u0120undeniable": 36332, "\u0120Lounge": 36333, "\u0120haunt": 36334, "phe": 36335, "\u0120quantify": 36336, "\u0120differed": 36337, "\u0120[*]": 36338, "\u0120Viz": 36339, "cum": 36340, "slave": 36341, "\u0120videog": 36342, "\u0120quar": 36343, "\u0120bundles": 36344, "\u0120Alonso": 36345, "tackle": 36346, "\u0120neuronal": 36347, "\u0120landslide": 36348, "confirmed": 36349, "\u0120Depth": 36350, "\u0120renewables": 36351, "Bear": 36352, "\u0120Macedonia": 36353, "\u0120jerseys": 36354, "\u0120bunk": 36355, "\u0120Spawn": 36356, "\u0120Controls": 36357, "\u0120Buchanan": 36358, "\u0120robotics": 36359, "\u0120emphasizing": 36360, "\u0120Tutorial": 36361, "hyp": 36362, "iston": 36363, "\u0120monumental": 36364, "\u00e6\u00b0": 36365, "\u0120Carry": 36366, "\u0120tbsp": 36367, "enance": 36368, "Hill": 36369, "arthed": 36370, "\u0120rotten": 36371, "Dean": 36372, "\u0120twisting": 36373, "\u0120goodwill": 36374, "\u0120immersion": 36375, "Living": 36376, "\u0120brushes": 36377, "\u0120CGI": 36378, "\u0120Atk": 36379, "traditional": 36380, "\u0120phantom": 36381, "\u0120Stamina": 36382, "\u0120expansions": 36383, "\u0120Marin": 36384, "\u0120embarked": 36385, "\u0120Eg": 36386, "intestinal": 36387, "\u0120PEOPLE": 36388, "\u0120Booth": 36389, "\u0120Appalach": 36390, "\u0120relegated": 36391, "VT": 36392, "MIT": 36393, "\u0120muster": 36394, "\u0120withdrawing": 36395, "\u0120microscope": 36396, "\u0120Gathering": 36397, "\u0120Crescent": 36398, "\u0120Argentine": 36399, "\u0120Decre": 36400, "\u0120Dominic": 36401, "\u0120buds": 36402, "antage": 36403, "\u0120Ion": 36404, "\u0120widened": 36405, "ONSORED": 36406, "\u0120Gloves": 36407, "iannopoulos": 36408, "razen": 36409, "feel": 36410, "\u0120repayment": 36411, "\u0120hindsight": 36412, "\u0120REALLY": 36413, "\u0120Pistol": 36414, "\u0120Brah": 36415, "\u0120watts": 36416, "\u0120survives": 36417, "\u0120flurry": 36418, "issy": 36419, "Alert": 36420, "\u0120Uruguay": 36421, "Phoenix": 36422, "Slow": 36423, "\u0120Grave": 36424, "\u0120Fir": 36425, "\u0120manageable": 36426, "\u0120tariff": 36427, "\u0120UDP": 36428, "\u0120Pistons": 36429, "\u0120Nigerian": 36430, "\u0120strikeouts": 36431, "\u0120cosmetics": 36432, "whelming": 36433, "fab": 36434, "cape": 36435, "proxy": 36436, "\u0120rethink": 36437, "\u0120overcoming": 36438, "simple": 36439, "\u0120woo": 36440, "\u0120distracting": 36441, "\u0120Stanton": 36442, "\u0120Tulsa": 36443, "\u0120Dock": 36444, "659": 36445, "\u0120discord": 36446, "\u0120Emacs": 36447, "\u0120Ves": 36448, "\u0120ROB": 36449, "\u0120reassuring": 36450, "\u0120consortium": 36451, "Muslims": 36452, "321": 36453, "\u0120prompts": 36454, "sei": 36455, "\u0120Hitch": 36456, "imposed": 36457, "\u0120Fool": 36458, "\u0120indiscrim": 36459, "wrong": 36460, "buquerque": 36461, "Davis": 36462, "!]": 36463, "\u0120timeless": 36464, "\u0120NEED": 36465, "\u0120pesticide": 36466, "\u0120rallying": 36467, "\u0120Calder": 36468, "\u0120\u00e5\u00a4": 36469, "\u0120xp": 36470, "\u0120Unle": 36471, "\u0120Export": 36472, "luaj": 36473, "Buff": 36474, ")</": 36475, "Boot": 36476, "\u0120Chrysler": 36477, "orative": 36478, "Mess": 36479, "\u0120negligible": 36480, "ertodd": 36481, "\u0120Mushroom": 36482, "\u0120Gale": 36483, "gc": 36484, "\u0120Cosby": 36485, "\u0120Rural": 36486, "ritical": 36487, "Bell": 36488, "\u0120turbine": 36489, "00200000": 36490, "\u0120legitimately": 36491, "\u0120Animated": 36492, "TED": 36493, "\u0120Theodore": 36494, "conduct": 36495, "\u0120Hier": 36496, "\u0120counterfeit": 36497, "\u0120Algeria": 36498, "\u0120unbeat": 36499, "controller": 36500, "\u0120unres": 36501, "\u0120scrambling": 36502, "\u0120Fallon": 36503, "Tes": 36504, "\u0120amber": 36505, "\u0120royalties": 36506, "\u0120Shelter": 36507, "\u0120Lester": 36508, "\u0120classify": 36509, "Remote": 36510, "\u0120unheard": 36511, "\u0120controversies": 36512, "\u0120enrichment": 36513, "\u0120Yankee": 36514, "gamer": 36515, "\u0120platinum": 36516, "\u0120ecology": 36517, "\u0120Sark": 36518, "\u0120untouched": 36519, "\u0120supervisors": 36520, "\u0120\"%": 36521, "\u0120footh": 36522, "\u0120commons": 36523, "\u0120narcotics": 36524, "\u0120indices": 36525, "\u0120Ply": 36526, "\u0120additionally": 36527, "\u0120Gawker": 36528, "\u0120EQ": 36529, "Playing": 36530, "\u0120caveat": 36531, "\u0120Absolute": 36532, "ossus": 36533, "Baby": 36534, "\u0120ration": 36535, "\u0120resin": 36536, "\u0120calibration": 36537, "\u0120Newport": 36538, "\u0120knocks": 36539, "vt": 36540, "\u0120compost": 36541, "Scene": 36542, "\u0120sarcast": 36543, "\u0120kisses": 36544, "\u0120ns": 36545, "alli": 36546, "\u0120Marcel": 36547, "\u0120Piet": 36548, "iatrics": 36549, "\u0120surrounds": 36550, "\u0120Reprodu": 36551, "\u0120Phillies": 36552, "\u0120uncertainties": 36553, "\u0120Eur": 36554, "\u0120Romance": 36555, "\u0120Hath": 36556, "\u0120Needs": 36557, "\u0120Cloak": 36558, "\u0120crem": 36559, "queue": 36560, "\u0120355": 36561, "\u0120upfront": 36562, "]);": 36563, "\u0120reciproc": 36564, "\u01201927": 36565, "\u01201100": 36566, "utsu": 36567, "\u0120depressive": 36568, "owment": 36569, "Fans": 36570, "\u0120mech": 36571, "\u0120annihil": 36572, "\u0120counterterrorism": 36573, "\u0120Figures": 36574, "bold": 36575, "\u0120Moines": 36576, "\u0120Drivers": 36577, "\u0120manuscripts": 36578, "\u0120Crypto": 36579, "\u0120hypnot": 36580, "reddits": 36581, "\u0120prosecutions": 36582, "\u0120divert": 36583, "CRIP": 36584, "\u0120Bene": 36585, "\u0120Reggie": 36586, "\u0120taxing": 36587, "\u0120Morales": 36588, "enting": 36589, "tur": 36590, "significant": 36591, "\u0120PROV": 36592, "\u0120strands": 36593, "\u0120pouch": 36594, "\u0120Rookie": 36595, "\u00bb\u0134": 36596, "\u0120nicer": 36597, "hemy": 36598, "hw": 36599, "ECA": 36600, "\u0120intimidated": 36601, "\u0120stricter": 36602, "\u0120microbial": 36603, "details": 36604, "\u0120vows": 36605, "\u0120quake": 36606, "hhhh": 36607, "\u0120reinvent": 36608, "Ub": 36609, "\u0120relinqu": 36610, "\u0120Buffett": 36611, "licensed": 36612, "ittered": 36613, "\u0120Picard": 36614, "\u0120chewing": 36615, "ucl": 36616, "organic": 36617, "\u0120localized": 36618, "\u0120Economist": 36619, "\u0120acquainted": 36620, "Definition": 36621, "sed": 36622, "Critics": 36623, "\u0120cc": 36624, "453": 36625, "381": 36626, "\u0120fellows": 36627, "\u0120checkpoints": 36628, "025": 36629, "\u0120reelection": 36630, "\u0120mediated": 36631, "\u0120KDE": 36632, "\u0120hurdle": 36633, "\u0120texting": 36634, "Perfect": 36635, "\u0120trustees": 36636, "fecture": 36637, "\u0120dich": 36638, "monary": 36639, "\u0120distinctions": 36640, "\u01201400": 36641, "\u0120usher": 36642, "\u0120parasites": 36643, "\u0120Sharing": 36644, "\u0120Vim": 36645, "\u0120barbecue": 36646, "\u0120Ministers": 36647, "erella": 36648, "\u0120eb": 36649, "\u0120mc": 36650, "\u0120Somehow": 36651, "\u0120Insect": 36652, "changes": 36653, "broad": 36654, "\u0120Byz": 36655, "\u0120grapes": 36656, "669": 36657, "\u0120=================": 36658, "\u0120assimil": 36659, "\u0120haunting": 36660, "\u0120firepower": 36661, "\u0120defamation": 36662, "emphasis": 36663, "\u0120compose": 36664, "\u0120allergies": 36665, "\u0120strang": 36666, "rollers": 36667, "bang": 36668, "\u0120brewers": 36669, "rongh": 36670, "riot": 36671, "poor": 36672, "cold": 36673, "Sample": 36674, "\u0120buoy": 36675, "040": 36676, "\u0120Courtney": 36677, "\u0120268": 36678, "\u0120Wedding": 36679, "702": 36680, "\u0120obsessive": 36681, "\u0120braking": 36682, "\u0120Lal": 36683, "anical": 36684, "\u00e5\u00a6": 36685, "aten": 36686, "Construction": 36687, "\u0120clinically": 36688, "iership": 36689, "Names": 36690, "\u0120Discuss": 36691, "\u0120Ramos": 36692, "\u0120locale": 36693, "\u0120Agricultural": 36694, "Enable": 36695, "\u0120horsepower": 36696, "enture": 36697, "Pref": 36698, "Court": 36699, "\u0120staffing": 36700, "\u0120futuristic": 36701, "drivers": 36702, "\u0120Marketplace": 36703, "\u00e6\u012a\u00a6": 36704, "Friends": 36705, "\u0120damning": 36706, "\u0120Customers": 36707, "\u0120weeds": 36708, "\u0120Mai": 36709, "\u0120agile": 36710, "\u0120Tatt": 36711, "icent": 36712, "Ranked": 36713, "croft": 36714, "\u0120Katy": 36715, "Extreme": 36716, "\u0120carve": 36717, "\u0120Rover": 36718, "\u0120Byron": 36719, "372": 36720, "\u0120conducts": 36721, "ratch": 36722, "itia": 36723, "\u0120Pumpkin": 36724, "Sadly": 36725, "Reloaded": 36726, "Policy": 36727, "\u0120lick": 36728, "peak": 36729, "isks": 36730, "\u0120CDs": 36731, "\u0120Encyclopedia": 36732, "initial": 36733, "Cos": 36734, "\u0120Awareness": 36735, "\u0120Dram": 36736, "$$$$": 36737, "\u0120riff": 36738, "\u0120scripture": 36739, "runners": 36740, "\u0120boiler": 36741, "onson": 36742, "oin": 36743, "\u0120hamstring": 36744, "\u0120cataly": 36745, "\u0120Archbishop": 36746, "chall": 36747, "\u0120faux": 36748, "okin": 36749, "localhost": 36750, "\u0120NAME": 36751, "adobe": 36752, "SAN": 36753, "amate": 36754, "\u0120scramble": 36755, "\u0120carc": 36756, "\u0120Manifest": 36757, "\u0120Cedar": 36758, "\u0120Sergio": 36759, "later": 36760, "ffer": 36761, "\u0120grappling": 36762, "\u0120Deutsche": 36763, "agonists": 36764, "\u0120Newsp": 36765, "\u0120pretended": 36766, "archment": 36767, "\u0120curated": 36768, "\u0120headphone": 36769, "\u0120Uncommon": 36770, "\u0120SIGN": 36771, "Agent": 36772, "\u0120deadlines": 36773, "\u0120horizontally": 36774, "\u0120MAT": 36775, "\u0120Summers": 36776, "\u0120ordained": 36777, "\u0120Lastly": 36778, "\u0120Kendall": 36779, "\u0120frig": 36780, "\u0120Machina": 36781, "\u0120Waterloo": 36782, "\u0120Mexicans": 36783, "\u0120protector": 36784, "\u0120glare": 36785, "}\"": 36786, "Premium": 36787, "\u0120rift": 36788, "\u0120Telescope": 36789, "Metal": 36790, "\u0120recapt": 36791, "\u0120;;": 36792, "\u0120inclination": 36793, "\u0120imposes": 36794, "ingen": 36795, "^{": 36796, "\u0120haste": 36797, "\u0120dolphins": 36798, "\u0120commuters": 36799, "planned": 36800, "cong": 36801, "mx": 36802, "\u0120Upload": 36803, "\u0120extrap": 36804, "\u0120Tucson": 36805, "\u0120Exploration": 36806, "efeated": 36807, "\u0120slender": 36808, "703": 36809, "\u0120Buk": 36810, "isel": 36811, "\u0120competitiveness": 36812, "chlor": 36813, "\u0120Permanent": 36814, "\u0120Everett": 36815, "\u0120Specialist": 36816, "\u0120SOL": 36817, "\u0120cyan": 36818, "\u0120Exactly": 36819, "UF": 36820, "\u0120LIFE": 36821, "aryl": 36822, "onet": 36823, "\u0120Employee": 36824, "awed": 36825, "\u0120Ratings": 36826, "\u0120extravag": 36827, "ulhu": 36828, "\u0120Plane": 36829, "\u0120elevate": 36830, "\u0120Coordinator": 36831, "\u0120Watkins": 36832, "\u0120excludes": 36833, "\u0120sentient": 36834, "\u0120epoch": 36835, "\u0120alloc": 36836, "Previously": 36837, "\u0120Shy": 36838, "\u0120Slovakia": 36839, "LOCK": 36840, "\u0120markedly": 36841, "\u0120knob": 36842, "\u0120adventurers": 36843, "\u0120Been": 36844, "\u0120Costs": 36845, "ammers": 36846, "\u0120onslaught": 36847, "\u0120Supported": 36848, "\u0120Tau": 36849, "ikarp": 36850, "\u0120Sovere": 36851, "\u0120Hampton": 36852, "\u00e3\u0124\u012b": 36853, "Prev": 36854, "\u0120Worse": 36855, "\u0120cottage": 36856, "\u0120Hades": 36857, "lez": 36858, "bowl": 36859, "\u0120fragrance": 36860, "\u0120Lok": 36861, "EMOTE": 36862, "\u0120Petro": 36863, "\u01201925": 36864, "\u0120Pend": 36865, "producing": 36866, "\u0120relocate": 36867, "vati": 36868, "pole": 36869, "\u0120semin": 36870, "\u0120NUM": 36871, "\u0120rocked": 36872, "buff": 36873, "bly": 36874, "Reply": 36875, "\u0120Hai": 36876, "\u0120articulated": 36877, "\u0120Islamabad": 36878, "665": 36879, "\u0120Claims": 36880, "Desktop": 36881, "\u0120trustee": 36882, "\u0120scripting": 36883, "\u0120Sob": 36884, "\u0120Asylum": 36885, "STDOUT": 36886, "\u0120Clown": 36887, "\u0120Dortmund": 36888, "\u0120Devon": 36889, "lite": 36890, "\u0120Marble": 36891, "\u0120bunker": 36892, "\u0120crest": 36893, "\u0120arousal": 36894, "\u0120Sears": 36895, "\u0120Buddy": 36896, "eredith": 36897, "\u0120Polly": 36898, "\u0120decode": 36899, "\u0120Vish": 36900, "\u0120Reflect": 36901, "anon": 36902, "\u0120refunds": 36903, "immers": 36904, "HM": 36905, "\u0120wiping": 36906, "\u0120puzzled": 36907, "\u0120matte": 36908, "uno": 36909, "Pierre": 36910, ")),": 36911, "\u0120tainted": 36912, "\u0120symbolism": 36913, "\u0120Fraz": 36914, "\u0120protestors": 36915, "etheus": 36916, "%%%%": 36917, "Wra": 36918, "\u0120lax": 36919, "adem": 36920, "aturation": 36921, "\u00e3\u0125\u0135": 36922, "\u0120Trailer": 36923, "\u0120ENG": 36924, "\u0120Bowser": 36925, "\u0120attm": 36926, "Dur": 36927, "807": 36928, "\u0120sidx": 36929, "\u0120cider": 36930, "\u0120Affect": 36931, "\u0120woven": 36932, "\u0120Barker": 36933, "benef": 36934, "\u0120dstg": 36935, "\u0120Ryu": 36936, ">[": 36937, "\u0120sqor": 36938, "Saudi": 36939, "\u0120istg": 36940, "\u0120indulge": 36941, "proc": 36942, "\u0120disgusted": 36943, "\u0120compounded": 36944, "\u0120nem": 36945, "\u0120schooling": 36946, "\u0120Cure": 36947, "processing": 36948, "Sol": 36949, "\u0120proverb": 36950, "itized": 36951, "\u0120Alvarez": 36952, "\u0120scarf": 36953, "\u0120rectangular": 36954, "reve": 36955, "\u0120hormonal": 36956, "\u0120Stress": 36957, "itizen": 36958, "\u0120425": 36959, "girls": 36960, "\u0120Noir": 36961, "\u0120Rapp": 36962, "\u0120marches": 36963, "church": 36964, "\u0120Uses": 36965, "\u0120405": 36966, "\u0120Berm": 36967, "\u0120ordinances": 36968, "\u0120Judgment": 36969, "Charges": 36970, "\u0120Zin": 36971, "\u0120dusty": 36972, "\u0120strawberries": 36973, "\u0120perce": 36974, "\u0120Thur": 36975, "\u0120Deborah": 36976, "netflix": 36977, "\u0120Lambert": 36978, "\u0120amused": 36979, "\u0120Guang": 36980, "YOU": 36981, "RGB": 36982, "\u0120CCTV": 36983, "\u0120fiat": 36984, "rang": 36985, "\u0120federation": 36986, "\u0120Mant": 36987, "\u0120Bust": 36988, "\u0120Mare": 36989, "respective": 36990, "\u0120Migration": 36991, "\u0120BIT": 36992, "590": 36993, "\u0120patriotism": 36994, "\u0120outlining": 36995, "region": 36996, "\u0120Jos\u00c3\u00a9": 36997, "\u0120blasting": 36998, "\u0120Ezra": 36999, "Bs": 37000, "\u0120undermines": 37001, "\u0120Smooth": 37002, "\u0120clashed": 37003, "radio": 37004, "\u0120transitioning": 37005, "\u0120Buccaneers": 37006, "\u0120Owl": 37007, "\u0120plugs": 37008, "\u0120hiatus": 37009, "\u0120Pinball": 37010, "\u0120mig": 37011, "\u0120Nutr": 37012, "\u0120Wolfe": 37013, "\u0120integers": 37014, "\u0120orbits": 37015, "\u0120Edwin": 37016, "\u0120DirectX": 37017, "bite": 37018, "\u0120blazing": 37019, "vr": 37020, "Edge": 37021, "\u0120PID": 37022, "exit": 37023, "\u0120Comed": 37024, "\u0120Pathfinder": 37025, "\u0120Guid": 37026, "\u0120Signs": 37027, "\u0120Zer": 37028, "\u0120Agenda": 37029, "\u0120reimbursement": 37030, "Mesh": 37031, "iPhone": 37032, "\u0120Marcos": 37033, "\u0120Sites": 37034, "hate": 37035, "enburg": 37036, "\u0120sockets": 37037, "pend": 37038, "Batman": 37039, "vir": 37040, "\u0120SHOW": 37041, "\u0120provisional": 37042, "conn": 37043, "\u0120Deaths": 37044, "ATIVE": 37045, "Profile": 37046, "sym": 37047, "JA": 37048, "\u0120ninja": 37049, "installed": 37050, "idates": 37051, "ebra": 37052, "\u0120Omaha": 37053, "\u0120seizing": 37054, "\u0120Beasts": 37055, "\u0120salts": 37056, "Mission": 37057, "Generally": 37058, "\u0120Trilogy": 37059, "heon": 37060, "legates": 37061, "\u0120dime": 37062, "\u0120faire": 37063, "parable": 37064, "Graph": 37065, "\u0120totaling": 37066, "\u0120diagrams": 37067, "\u0120Yanuk": 37068, "plet": 37069, "\u0120Meh": 37070, "\u0120mythical": 37071, "\u0120Stephens": 37072, "autical": 37073, "ochemistry": 37074, "\u0120kilograms": 37075, "\u0120elbows": 37076, "ancock": 37077, "\u0120BCE": 37078, "\u0120Prague": 37079, "\u0120improv": 37080, "\u0120Devin": 37081, "\u0120\"\\": 37082, "paralle": 37083, "\u0120supremacists": 37084, "\u0120Billion": 37085, "\u0120regimen": 37086, "innacle": 37087, "\u0120requisite": 37088, "angan": 37089, "\u0120Burlington": 37090, "ainment": 37091, "\u0120Objective": 37092, "omsky": 37093, "GV": 37094, "\u0120unilateral": 37095, "\u0120tc": 37096, "\u0120hires": 37097, "mental": 37098, "\u0120involuntary": 37099, "\u0120transpl": 37100, "\u0120ASCII": 37101, "\u00c2\u00a8": 37102, "Events": 37103, "\u0120doubted": 37104, "\u0120Kaplan": 37105, "\u0120Courage": 37106, "igon": 37107, "\u0120Managing": 37108, "\u0120Tart": 37109, "\u0120falsehood": 37110, "\u0120Violet": 37111, "\u0120airs": 37112, "\u0120fertilizer": 37113, "Britain": 37114, "\u0120aquatic": 37115, "ouf": 37116, "Words": 37117, "\u0120Hartford": 37118, "\u0120evenings": 37119, "\u0120Vengeance": 37120, "quite": 37121, "Gall": 37122, "\u0120Pret": 37123, "\u0120pdf": 37124, "\u0120LM": 37125, "\u0120Sochi": 37126, "\u0120Intercept": 37127, "920": 37128, "\u0120profitability": 37129, "\u0120Idle": 37130, "\u0120MacDonald": 37131, "\u0120Establishment": 37132, "umsy": 37133, "\u0120gatherings": 37134, "\u0120Naj": 37135, "Charlie": 37136, "\u0120ascent": 37137, "\u0120Protector": 37138, "\u0120algebra": 37139, "\u0120bios": 37140, "forums": 37141, "ELS": 37142, "Introduced": 37143, "\u0120335": 37144, "\u0120astronomy": 37145, "Contribut": 37146, "\u0120Polic": 37147, "Platform": 37148, "\u0120containment": 37149, "wrap": 37150, "\u0120coronary": 37151, "\u0120Jelly": 37152, "manager": 37153, "\u0120heartbreaking": 37154, "cair": 37155, "\u0120Chero": 37156, "cgi": 37157, "Medical": 37158, "\u0120Accountability": 37159, "!!\"": 37160, "ophile": 37161, "\u0120psychotic": 37162, "\u0120Restrict": 37163, "\u0120equitable": 37164, "issues": 37165, "\u01201905": 37166, "\u0120Nek": 37167, "cised": 37168, "\u0120Tracking": 37169, "\u0120ozone": 37170, "\u0120cooker": 37171, "rosis": 37172, "\u0120reopen": 37173, "\u0120infinity": 37174, "\u0120Pharmaceutical": 37175, "ensional": 37176, "Attempt": 37177, "\u0120Rory": 37178, "Marco": 37179, "\u0120awaits": 37180, "HOW": 37181, "treated": 37182, "\u0120bolst": 37183, "\u0120revered": 37184, "\u0120pods": 37185, "oppers": 37186, "0010": 37187, "\u0120amplitude": 37188, "rican": 37189, "SPONSORED": 37190, "\u0120trousers": 37191, "\u0120halves": 37192, "\u0120Kaine": 37193, "\u0120Cutler": 37194, "\u0120AUTH": 37195, "\u0120splendid": 37196, "\u0120preventive": 37197, "\u0120Dudley": 37198, "ifacts": 37199, "uminati": 37200, "\u0120Yin": 37201, "\u0120admon": 37202, "\u0120Vag": 37203, "\u0120inverted": 37204, "\u0120hastily": 37205, "\u0120Hague": 37206, "Lyn": 37207, "\u0120ledger": 37208, "\u0120astronomical": 37209, "getting": 37210, "\u0120circa": 37211, "\u0120Cic": 37212, "\u0120Tennis": 37213, "Limited": 37214, "\u0120dru": 37215, "\u0120BYU": 37216, "\u0120travellers": 37217, "\u0120pane": 37218, "\u0120Intro": 37219, "\u0120patiently": 37220, "\u0120aiding": 37221, "\u0120loos": 37222, "\u0120Tough": 37223, "\u0120293": 37224, "\u0120consumes": 37225, "SourceFile": 37226, "\u0120\"\"\"": 37227, "\u0120bonding": 37228, "\u0120tilted": 37229, "\u0120menstrual": 37230, "\u0120Celestial": 37231, "ULAR": 37232, "Plugin": 37233, "\u0120risking": 37234, "Naz": 37235, "\u0120Riyadh": 37236, "\u0120accredited": 37237, "\u0120skirm": 37238, "\u00e9\u013d": 37239, "\u0120examiner": 37240, "\u0120messing": 37241, "\u0120nearing": 37242, "\u0120Chern": 37243, "\u0120Beckham": 37244, "\u0120swapped": 37245, "\u0120goose": 37246, "Kay": 37247, "\u0120lofty": 37248, "\u0120Wallet": 37249, "\u0120['": 37250, "\u0120apocalypse": 37251, "\u0120bamboo": 37252, "\u0120SPACE": 37253, "\u0120Elena": 37254, "\u0120306": 37255, "acons": 37256, "\u0120tightened": 37257, "\u0120adolescence": 37258, "\u0120rainy": 37259, "\u0120vandalism": 37260, "\u0120Newtown": 37261, "\u0120conject": 37262, "cakes": 37263, "\u0120cheated": 37264, "\u0120moderators": 37265, "params": 37266, "EFF": 37267, "\u0120deceit": 37268, "\u0120STL": 37269, "\u0120Tanzania": 37270, "\u0120RI": 37271, "\u01201923": 37272, "\u0120Exile": 37273, "thel": 37274, "\u0120theolog": 37275, "\u0120quirky": 37276, "\u0120Irvine": 37277, "\u0120needy": 37278, "oris": 37279, "Um": 37280, "Ka": 37281, "\u0120mailbox": 37282, "322": 37283, "\u0120bos": 37284, "\u0120Petra": 37285, "KING": 37286, "\u0120enlarged": 37287, "Often": 37288, "\u0120badass": 37289, "\u0120343": 37290, "\u0120Places": 37291, "\u0120CAD": 37292, "\u0120pristine": 37293, "\u0120intervening": 37294, "direction": 37295, "\u0120laz": 37296, "\u0120DSM": 37297, "\u0120projecting": 37298, "\u0120Funk": 37299, "agog": 37300, "payment": 37301, "nov": 37302, "\u0120chatter": 37303, "ARB": 37304, "\u0120examinations": 37305, "\u0120Household": 37306, "\u0120Gus": 37307, "Ford": 37308, "414": 37309, "Boss": 37310, "\u0120mystic": 37311, "\u0120leaps": 37312, "\u0120Bav": 37313, "ulz": 37314, "budget": 37315, "Football": 37316, "\u0120subsidized": 37317, "\u0120firsthand": 37318, "\u0120coincide": 37319, "ocular": 37320, "Conn": 37321, "\u0120Collabor": 37322, "\u0120fools": 37323, "amura": 37324, "ahar": 37325, "rists": 37326, "\u0120swollen": 37327, "\u0120expended": 37328, "\u0120Pau": 37329, "sup": 37330, "\u0120spar": 37331, "\u0120keynote": 37332, "suff": 37333, "\u0120unequal": 37334, "\u0120progressing": 37335, "strings": 37336, "\u0120Gamergate": 37337, "Disney": 37338, "\u0120Eleven": 37339, "omnia": 37340, "\u0120scripted": 37341, "\u0120earners": 37342, "brother": 37343, "\u0120Enabled": 37344, "\u00e6\u00b3": 37345, "\u0120larvae": 37346, "\u0120LOC": 37347, "mess": 37348, "Wilson": 37349, "\u0120Template": 37350, "successfully": 37351, "\u0120paramount": 37352, "\u0120camouflage": 37353, "\u0120binds": 37354, "\u0120Quiet": 37355, "\u0120Shutterstock": 37356, "rush": 37357, "\u0120mascot": 37358, "fortune": 37359, "\u0120Colt": 37360, "\u0120Beyon": 37361, "habi": 37362, "\u0120hairc": 37363, "\u0120267": 37364, "\u0120Deus": 37365, "\u0120twitch": 37366, "\u0120concentrating": 37367, "\u0120nipples": 37368, "cible": 37369, "\u0120gir": 37370, "NZ": 37371, "Math": 37372, "nih": 37373, "Required": 37374, "\u0120ponder": 37375, "\u0120SAN": 37376, "\u0120weddings": 37377, "\u0120loneliness": 37378, "NES": 37379, "\u0120Mahjong": 37380, "695": 37381, "addle": 37382, "\u0120Garner": 37383, "\u0120COUR": 37384, "Bridge": 37385, "\u0120spree": 37386, "\u0120Caldwell": 37387, "\u0120bribery": 37388, "\u0120\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd": 37389, "plugins": 37390, "\u0120racket": 37391, "\u0120champagne": 37392, "versible": 37393, "Vote": 37394, "\u0120modifiers": 37395, "Mayor": 37396, "680": 37397, "\u0120assemblies": 37398, "\u0120Sultan": 37399, "\u0120Ning": 37400, "\u0120Ladies": 37401, "\u0120sulfur": 37402, "\u0120orbs": 37403, "\u0120-----": 37404, "_______": 37405, "\u0120Journalism": 37406, "\u0120esports": 37407, "\u0120lush": 37408, "\u0120hue": 37409, "\u0120spectral": 37410, "Honest": 37411, "\u00e3\u0125\u0131": 37412, "\u0120bushes": 37413, "\u0120reinforcement": 37414, "\u0120reopened": 37415, "\u0120Wheels": 37416, "\u0120Morg": 37417, "rieving": 37418, "\u0120auxiliary": 37419, "\u0120jQuery": 37420, "\u0120BAT": 37421, "tesque": 37422, "\u0120vertex": 37423, "pure": 37424, "frey": 37425, "\u00e3\u0124\u00ba": 37426, "dos": 37427, "\u0120typh": 37428, "\u0120cull": 37429, "\u0120eq": 37430, "\u0120decon": 37431, "\u0120tossing": 37432, "\u0120disparate": 37433, "\u0120Brigham": 37434, "printf": 37435, "ledged": 37436, "\u0120sund": 37437, "\u0120cozy": 37438, "\u0120hepatitis": 37439, "performing": 37440, "\u0120aval": 37441, "\u0120GG": 37442, "future": 37443, "\u0120petertodd": 37444, "\u0120Kosovo": 37445, "\u0120magnets": 37446, "Already": 37447, "\u0120Edison": 37448, "\u0120Ceres": 37449, "\u0120RAID": 37450, "\u0120brilliance": 37451, "576": 37452, "\u0120derives": 37453, "\u0120hypertension": 37454, "\u0120\u00ce\u0136": 37455, "\u0120lambda": 37456, "\u0120flair": 37457, "\u0120missionaries": 37458, "\u0120rapes": 37459, "\u0120Starter": 37460, "\u0120Months": 37461, "\u0120defy": 37462, "\u0120seismic": 37463, "\u0120Raphael": 37464, "\u0120eurozone": 37465, "656": 37466, "zsche": 37467, "\u0120scratched": 37468, "\u0120bows": 37469, "\u0120Lennon": 37470, "\u0120Gaia": 37471, "\u0120dripping": 37472, "facts": 37473, "Ale": 37474, "\u0120frogs": 37475, "\u0120Breast": 37476, "ogeneity": 37477, "\u0120Prosecutor": 37478, "\u0120amplified": 37479, "\u0120Hodg": 37480, "\u0120Fn": 37481, "Thousands": 37482, "\u0120NIH": 37483, "\u0120Monitoring": 37484, "FTWARE": 37485, "\u0120Priebus": 37486, "\u0120Growing": 37487, "hunter": 37488, "\u0120diagnose": 37489, "\u0120Mald": 37490, "\u0120LR": 37491, "\u0120crowned": 37492, "\u0120bursting": 37493, "\u0120dissolution": 37494, "javascript": 37495, "\u0120usefulness": 37496, "\u0120Execution": 37497, ":(": 37498, "\u0120Ivory": 37499, "aah": 37500, "\u0120persecuted": 37501, "violence": 37502, "istas": 37503, "\u0120Crate": 37504, "\u0120impulses": 37505, "\u0120Spani": 37506, "edes": 37507, "Handle": 37508, "\u0120Zerg": 37509, "thinkable": 37510, "Lastly": 37511, "\u0120spontaneously": 37512, "\u0120inconvenient": 37513, "\u0120dismissing": 37514, "\u0120plotted": 37515, "\u0120eighty": 37516, "\u0120737": 37517, "rish": 37518, "\u0120Thornton": 37519, "atham": 37520, "\u0120sitcom": 37521, "Ven": 37522, "Recipe": 37523, "tel": 37524, "lund": 37525, "\u0120clears": 37526, "\u0120Sasuke": 37527, "\u0120258": 37528, "\u0120opting": 37529, "\u0120enraged": 37530, "esthetic": 37531, "\u0120Ae": 37532, "uchs": 37533, "Prep": 37534, "Flow": 37535, "\u0120runoff": 37536, "\u0120Eating": 37537, "\u0120Giles": 37538, "\u0120Acting": 37539, "resources": 37540, "ibaba": 37541, "\u0120rpm": 37542, "\u0120skewed": 37543, "\u0120Blanc": 37544, "\u0120Sakuya": 37545, "\u0120hotter": 37546, "\u01201924": 37547, "opian": 37548, "cko": 37549, "\u0120crumbling": 37550, "\u0120captains": 37551, "\u0120Appropriations": 37552, "leaders": 37553, "dropping": 37554, "anuts": 37555, "\u0120reversing": 37556, "\u0120Pose": 37557, "\u0120Sek": 37558, "Scot": 37559, "\u0120Idea": 37560, "cise": 37561, "\u0120Slovenia": 37562, "\u0120317": 37563, "Doctor": 37564, "\u0120crocod": 37565, "aldi": 37566, "Sea": 37567, "\u0120Farrell": 37568, "\u0120mercenaries": 37569, "\u0120RNC": 37570, "\u0120Guess": 37571, "\u0120pacing": 37572, "Machine": 37573, "StreamerBot": 37574, "\u0120Charity": 37575, "\u0120298": 37576, "\u0120cannons": 37577, "\u0120Toby": 37578, "TPPStreamerBot": 37579, "\u0120Passion": 37580, "cfg": 37581, "Thom": 37582, "\u0120badges": 37583, "\u0120Bernstein": 37584, ".\u00e2\u0122\u0135": 37585, "\u0120POP": 37586, "\u0120Conj": 37587, "\u0120initialization": 37588, "\u0120biodiversity": 37589, "Dub": 37590, "\u0120feudal": 37591, "\u0120disclaimer": 37592, "\u0120crow": 37593, "\u0120ignition": 37594, "arf": 37595, "SHA": 37596, "\u0120kHz": 37597, "hazard": 37598, "\u0120Artists": 37599, "oeuv": 37600, "679": 37601, "\u0120Rudy": 37602, "Nine": 37603, "\u0120Ramadan": 37604, "\u00e5\u00bd": 37605, "itto": 37606, "\u0120adrenaline": 37607, "Cert": 37608, "\u0120smelled": 37609, "\u0120impunity": 37610, "\u0120agendas": 37611, "\u0120Reborn": 37612, "\u0120Concent": 37613, "\u0120Seems": 37614, "\u0120omega": 37615, "\u0120Dustin": 37616, "\u0120backer": 37617, "\u0120Sauce": 37618, "\u0120Boyle": 37619, "WIN": 37620, "\u0120spins": 37621, "\u0120pauses": 37622, "upt": 37623, "\u0120shredded": 37624, "\u0120strapped": 37625, "\u0120Corruption": 37626, "\u0120scratches": 37627, "\u0120ni": 37628, "\u0120attire": 37629, "\u0120SAF": 37630, "FactoryReloaded": 37631, "\u0120IPS": 37632, "\u0120(%": 37633, "\u0120seminar": 37634, "focus": 37635, "civil": 37636, "\u01201860": 37637, "intosh": 37638, "\u0120continual": 37639, "\u0120abbrevi": 37640, "\u0120Sok": 37641, "ocobo": 37642, "XM": 37643, "\u0120frantic": 37644, "\u0120unavoidable": 37645, "\u0120artery": 37646, "\u0120annotations": 37647, "bath": 37648, "Climate": 37649, "\u0120dors": 37650, "\u0120Slide": 37651, "coord": 37652, "\u0120Reload": 37653, "\u0120LDL": 37654, "\u0120Lovecraft": 37655, "\u0120unimagin": 37656, "\u0120resembled": 37657, "\u0120barracks": 37658, "np": 37659, "\u0120surrogate": 37660, "\u0120categorized": 37661, "\u00e3\u0124\u00a9": 37662, "\u0120vaccinated": 37663, "\u0120drainage": 37664, "\u0120indist": 37665, "\u0120WhatsApp": 37666, "\u01201870": 37667, "olerance": 37668, "invoke": 37669, "amorph": 37670, "\u0120reconnect": 37671, "\u0120emanc": 37672, "\u0120blindness": 37673, "\u01201280": 37674, "internet": 37675, "collar": 37676, "\u0120altru": 37677, "\u0120abyss": 37678, "\u0120TRI": 37679, "657": 37680, "\u0120infused": 37681, "HEAD": 37682, "\u0120forestry": 37683, "\u0120Woody": 37684, "\u0120Ci": 37685, "wi": 37686, "sam": 37687, "784": 37688, "holiday": 37689, "\u0120mogul": 37690, "\u0120Fees": 37691, "\u0120DEN": 37692, "Internal": 37693, "urbed": 37694, "fusc": 37695, "atom": 37696, "\u0120Illusion": 37697, "\u0120polled": 37698, "\u0120flap": 37699, "\u0120coax": 37700, "LGBT": 37701, "Analy": 37702, "\u0120Sections": 37703, "\u0120Californ": 37704, "emn": 37705, "\u0120hither": 37706, "\u0120NIGHT": 37707, "\u0120nailed": 37708, "\u0120Pipeline": 37709, "391": 37710, "oof": 37711, "\u0120Primal": 37712, "verend": 37713, "\u0120slashing": 37714, "\u0120retri": 37715, "aviour": 37716, "\u0120departing": 37717, "gil": 37718, "ISC": 37719, "\u0120midway": 37720, "\u0120ultrasound": 37721, "\u0120behaving": 37722, "\u0120Tara": 37723, "classes": 37724, "Virtual": 37725, "\u0120Colonial": 37726, "\u0120stripping": 37727, "\u0120orchestrated": 37728, "\u0120Graves": 37729, "452": 37730, "\u0120Ironically": 37731, "\u0120Writers": 37732, "\u0120lends": 37733, "\u0120Manz": 37734, "\u0120raven": 37735, "\u0120oxidative": 37736, "\u0120266": 37737, "ELF": 37738, "actually": 37739, "ascar": 37740, "Draft": 37741, "\u0120favourable": 37742, "\u0120humiliating": 37743, "\u0120fidelity": 37744, "\u0120Hof": 37745, "\u0120Xuan": 37746, "496": 37747, "\u0120layered": 37748, "atis": 37749, "790": 37750, "\u0120paycheck": 37751, "iton": 37752, "Kar": 37753, "\u0120VMware": 37754, "\u0120Farmer": 37755, "\u0120servic": 37756, "glomer": 37757, "\u0120slump": 37758, "\u0120Fabric": 37759, "\u0120DOC": 37760, "esting": 37761, "\u0120reassure": 37762, "\u0120phyl": 37763, "volt": 37764, "itory": 37765, "Rules": 37766, "\u0120oxidation": 37767, "\u0120prized": 37768, "\u0120mistress": 37769, "\u0120Django": 37770, "WARN": 37771, "\u00e5\u0133": 37772, "\u0120encode": 37773, "\u0120Feedback": 37774, "\u0120stupidity": 37775, "Ian": 37776, "\u0120Yugoslavia": 37777, "\u00d7\u00a8": 37778, "acl": 37779, "UTE": 37780, "1977": 37781, "\u0120qualifies": 37782, "\u0120pulses": 37783, "pretty": 37784, "\u0120froze": 37785, "\u0120ss": 37786, "Iterator": 37787, "\u0120urgently": 37788, "\u0120mailed": 37789, "\u0120Cham": 37790, "\u0120sustaining": 37791, "\u0120basil": 37792, "\u0120puppies": 37793, "ilant": 37794, "\u0120PLEASE": 37795, "lap": 37796, "aceous": 37797, "Fear": 37798, "\u0120Mastery": 37799, "automatic": 37800, "\u0120TAG": 37801, "\u0120antim": 37802, "agles": 37803, "473": 37804, "frames": 37805, "\u0120whispers": 37806, "\u0120Whoever": 37807, "\u0120bravery": 37808, "\u0120UKIP": 37809, "ractions": 37810, "\"\"\"": 37811, "\u0120tame": 37812, "\u0120parted": 37813, "everything": 37814, "CONT": 37815, "\u0120indebted": 37816, "\u0120addr": 37817, "rek": 37818, "IRED": 37819, "\u0120eminent": 37820, "clinton": 37821, "\u0120ousted": 37822, "\u0120reviewer": 37823, "\u0120meltdown": 37824, "\u0120rearr": 37825, "\u0120Yao": 37826, "thereal": 37827, "abyte": 37828, "\u0120stumbling": 37829, "\u0120batches": 37830, "\u0120259": 37831, "\u0120contraceptive": 37832, "\u0120prostitute": 37833, "ensis": 37834, "Decl": 37835, "\u0120Strikes": 37836, "Military": 37837, "\u0120Oath": 37838, "vacc": 37839, "ppings": 37840, "052": 37841, "\u0120partName": 37842, "amping": 37843, "Reports": 37844, "KI": 37845, "CHR": 37846, "\u0120subtly": 37847, "swers": 37848, "Blake": 37849, "usual": 37850, "\u0120contestants": 37851, "\u0120cartridges": 37852, "\u0120GREAT": 37853, "\u0120blush": 37854, "\u0120\u00e2\u0122\u00ba": 37855, "472": 37856, "\u0120reasoned": 37857, "\u00e3\u0125\u00a4": 37858, "paralleled": 37859, "\u0120dyn": 37860, "agate": 37861, "\u0120nightly": 37862, "\u00e5\u0128": 37863, "556": 37864, "\u0120semantic": 37865, "\u0120Advoc": 37866, "\u0120!!": 37867, "\u0120disagrees": 37868, "\u0120BW": 37869, "Veh": 37870, "\u0120harming": 37871, "\u0120embraces": 37872, "\u0120strives": 37873, "\u0120inland": 37874, "\u0120Kard": 37875, "\u0120heats": 37876, "\u0120Ginny": 37877, "utan": 37878, "ernaut": 37879, "ylene": 37880, "\u0120Elev": 37881, "JD": 37882, "\u0120hars": 37883, "\u0120Starr": 37884, "\u0120skysc": 37885, "\u0120collaborators": 37886, "Usually": 37887, "\u0120revolutions": 37888, "\u0120STATS": 37889, "\u0120dismantle": 37890, "\u0120confidently": 37891, "\u0120kinetic": 37892, "Ali": 37893, "\u0120percentile": 37894, "\u0120extracting": 37895, "illian": 37896, "estead": 37897, "\u0120physicists": 37898, "\u0120Marshal": 37899, "\u0120fellowship": 37900, "\u0120dashed": 37901, "\u0120UR": 37902, "\u0120Sioux": 37903, "\u0120Compact": 37904, "amide": 37905, "Python": 37906, "\u0120Leigh": 37907, "\u0120Pharmac": 37908, "istrates": 37909, "herical": 37910, "\u0120fue": 37911, "\u0120Emin": 37912, "\u0120({": 37913, "\u0120Neighborhood": 37914, "\u0120disrupting": 37915, "\u0120Dup": 37916, "\u0120gland": 37917, "\u0120Sev": 37918, "\u0120Marian": 37919, "argon": 37920, "\u0120Dund": 37921, "\u0120<!--": 37922, "\u0120strand": 37923, "\u0120stadiums": 37924, "zos": 37925, "\u0120psychosis": 37926, "\u0120Rack": 37927, "\u0120brilliantly": 37928, "\u00ef\u00b8\u0131": 37929, "\u0120submerged": 37930, "\u0120Instit": 37931, "\u0120Chow": 37932, "\u0120cages": 37933, "\u0120Hats": 37934, "\u0120Urs": 37935, "\u0120diluted": 37936, "usat": 37937, "ienne": 37938, "\u0120Membership": 37939, "\u0120Burk": 37940, "\u0120ie": 37941, "\u0120archetype": 37942, "Drug": 37943, "ulton": 37944, "\u0120Spock": 37945, "\u0120McKay": 37946, "\u0120Depend": 37947, "Featured": 37948, "Soc": 37949, "1978": 37950, "\u0120Bere": 37951, "\u0120relentlessly": 37952, "\u0120crippling": 37953, "\u0120arthritis": 37954, "\u00e7\u0136\u0141": 37955, "\u0120Tropical": 37956, "\u0120Bulg": 37957, "\u0120Cheryl": 37958, "\u0120admirable": 37959, "\u0120subtitle": 37960, "Override": 37961, "\u0120originating": 37962, "\u0120CCP": 37963, "\u0120swore": 37964, "\u0120Sole": 37965, "\u0120Disorders": 37966, "329": 37967, "\u0120procession": 37968, "\u0120refurb": 37969, "\u0120immersed": 37970, "requently": 37971, "\u0120skeptics": 37972, "\u0120ceramic": 37973, "mitter": 37974, "enstein": 37975, "belt": 37976, "\u0120TIT": 37977, "bidden": 37978, "\u0120fir": 37979, "mist": 37980, ">]": 37981, "\u0120weave": 37982, "\u0120Paradox": 37983, "\u0120entrusted": 37984, "\u0120Barclays": 37985, "\u0120novelist": 37986, "ogie": 37987, "806": 37988, "\u0120ninety": 37989, "\u0120disagreements": 37990, "@@@@@@@@": 37991, "\u0120Auschwitz": 37992, "cars": 37993, "\u0120LET": 37994, "tub": 37995, "arantine": 37996, "POS": 37997, "\u0120backstory": 37998, "\u0120cheerful": 37999, "\u0120Rag": 38000, "eka": 38001, "biased": 38002, "\u0120inexperienced": 38003, "akra": 38004, "\u0120Witt": 38005, "tan": 38006, "\u0120rapist": 38007, "\u0120plateau": 38008, "chal": 38009, "\u0120Inquis": 38010, "expression": 38011, "\u0120cipher": 38012, "\u0120shaving": 38013, "adden": 38014, "rely": 38015, "(\\": 38016, "isma": 38017, "\u0120Regulatory": 38018, "CHAR": 38019, "ilyn": 38020, "NVIDIA": 38021, "GU": 38022, "\u0120murm": 38023, "laus": 38024, "Christopher": 38025, "\u0120contractual": 38026, "\u0120Proxy": 38027, "\u0120Jaime": 38028, "\u0120Methodist": 38029, "\u0120stewards": 38030, "sta": 38031, "peria": 38032, "\u0120physiology": 38033, "\u0120bumped": 38034, "\u0120fructose": 38035, "Australian": 38036, "\u0120Metallic": 38037, "\u0120Masquerade": 38038, "arb": 38039, "\u0120promul": 38040, "\u0120downfall": 38041, "\u0120butcher": 38042, "\u0120bour": 38043, "\u0120INFORMATION": 38044, "\u0120Bis": 38045, "pects": 38046, "adena": 38047, "\u0120contemplating": 38048, "aroo": 38049, "centered": 38050, "\u0120Peaks": 38051, "Used": 38052, "\u0120modem": 38053, "\u0120genders": 38054, "\u01208000": 38055, "371": 38056, "\u0120maternity": 38057, "\u0120Raz": 38058, "\u0120rocking": 38059, "\u0120handguns": 38060, "\u0120DACA": 38061, "Autom": 38062, "\u0120Nile": 38063, "\u0120tumult": 38064, "\u0120Benefit": 38065, "\u0120Approach": 38066, "workshop": 38067, "\u0120Leaving": 38068, "Ger": 38069, "instead": 38070, "\u0120vibrations": 38071, "\u0120repositories": 38072, "497": 38073, "\u0120Aunt": 38074, "\u0120Jub": 38075, "\u0120Expedition": 38076, "Alpha": 38077, "\u0120sans": 38078, "\u0120overdue": 38079, "\u0120overcrowd": 38080, "\u0120legislatures": 38081, "\u0120paternal": 38082, "\u0120Leonardo": 38083, "\u0120expressive": 38084, "\u0120distractions": 38085, "\u0120silenced": 38086, "trust": 38087, "\u0120biking": 38088, "\u0120560": 38089, "\u0120propriet": 38090, "\u0120imposition": 38091, "\u0120conglomer": 38092, "\u0120=================================================================": 38093, "\u0120Teaching": 38094, "\u0120Yose": 38095, "intensive": 38096, "Town": 38097, "\u0120trolling": 38098, "\u0120Grac": 38099, "\u0120ASUS": 38100, "Yo": 38101, "\u0120specials": 38102, "\u0120Neph": 38103, "\u0120Godzilla": 38104, "Database": 38105, "\u0120Hegel": 38106, "\u0120272": 38107, "1976": 38108, "\u0120Gloria": 38109, "\u0120disemb": 38110, "\u0120Investigations": 38111, "\u0120Bane": 38112, "agements": 38113, "Strange": 38114, "\u0120treasury": 38115, "\u0120Plays": 38116, "\u0120undesirable": 38117, "\u0120widening": 38118, "\u0120verbally": 38119, "\u0120infancy": 38120, "\u0120cutter": 38121, "fml": 38122, "\u01202100": 38123, "prototype": 38124, "fine": 38125, "\u0120decriminal": 38126, "\u0120dysfunctional": 38127, "\u0120besie": 38128, "\u0120Ernst": 38129, "zeb": 38130, "\u0120northeastern": 38131, "\u0120aust": 38132, "porate": 38133, "\u0120Marlins": 38134, "\u0120segregated": 38135, "eworld": 38136, "\u0120Maher": 38137, "\u0120traverse": 38138, "\u0120monastery": 38139, "urgy": 38140, "Gear": 38141, "sand": 38142, "Compl": 38143, "\u0120EMP": 38144, "\u0120plent": 38145, "\u0120Mercer": 38146, "\u0120276": 38147, "TABLE": 38148, "Configuration": 38149, "Hundreds": 38150, "\u0120pric": 38151, "\u0120collaborating": 38152, "\u0120Paramount": 38153, "\u0120Cummings": 38154, "\u0120(<": 38155, "\u0120recorder": 38156, "\u0120flats": 38157, "\u0120416": 38158, "whose": 38159, "FontSize": 38160, "\u0120Orbit": 38161, "YR": 38162, "\u0120wrists": 38163, "\u0120bakery": 38164, ")}": 38165, "\u0120Bounty": 38166, "\u0120Lancaster": 38167, "\u0120endings": 38168, "according": 38169, "\u0120Salam": 38170, "easy": 38171, "755": 38172, "\u0120Burr": 38173, "\u0120Barnett": 38174, "onomous": 38175, "Union": 38176, "\u0120precedence": 38177, "\u0120Scholarship": 38178, "\u0120UX": 38179, "\u0120rollout": 38180, "\u0120boon": 38181, "alm": 38182, "\u0120Canter": 38183, "\u00e6\u00b5": 38184, "\u0120rounding": 38185, "\u0120clad": 38186, "\u0120vap": 38187, "\u0120Featured": 38188, "isations": 38189, "\u0120540": 38190, "police": 38191, "\u0120unsettling": 38192, "\u0120drifting": 38193, "\u0120Lumia": 38194, "\u0120ObamaCare": 38195, "\u0120Favor": 38196, "Hyper": 38197, "\u0120Rothschild": 38198, "\u0120Miliband": 38199, "analy": 38200, "\u0120Juliet": 38201, "Hu": 38202, "\u0120recalling": 38203, "ahead": 38204, "696": 38205, "\u0120unfavorable": 38206, "\u0120dances": 38207, "Ox": 38208, "\u0120legality": 38209, "\u0120403": 38210, "romancer": 38211, "\u0120inquire": 38212, "\u0120Moves": 38213, "\\\">": 38214, "\u0120Variant": 38215, "\u0120Messiah": 38216, "\u0120LCS": 38217, "\u0120Bah\u00c3\u00a1": 38218, "756": 38219, "\u0120eyebrow": 38220, "\u0120\u00c2\u00a5": 38221, "\u0120McF": 38222, "\u0120Forty": 38223, "Mas": 38224, "\u0120panicked": 38225, "\u0120transformations": 38226, "qq": 38227, "\u0120revolves": 38228, "ringe": 38229, "\u0120Ai": 38230, "axe": 38231, "\u0120onward": 38232, "\u0120CFR": 38233, "\u0120Bare": 38234, "login": 38235, "\u0120liquids": 38236, "\u0120decomp": 38237, "secondary": 38238, "ilan": 38239, "\u0120Convert": 38240, "amiya": 38241, "\u0120prosecuting": 38242, "\u0120\u00e2\u012b\u00a1": 38243, "\u0120Yorkers": 38244, "\u0120Byrne": 38245, "slow": 38246, "awei": 38247, "Jean": 38248, "\u0120269": 38249, "\u0120Skydragon": 38250, "\u0120\u00c3\u00a9": 38251, "\u0120Nicaragua": 38252, "\u0120Huckabee": 38253, "\u0120Highly": 38254, "\u0120amphib": 38255, "\u0120Pastor": 38256, "\u0120Lets": 38257, "\u0120blurred": 38258, "\u0120visceral": 38259, "\u0120CBO": 38260, "\u0120collaborated": 38261, "zig": 38262, "Legal": 38263, "\u0120apartheid": 38264, "\u0120brid": 38265, "\u0120preset": 38266, "\u0120DET": 38267, "\u0120AMA": 38268, "\u00d7\u0136": 38269, "arching": 38270, "aucuses": 38271, "builder": 38272, "\u0120poetic": 38273, "\u0120emulator": 38274, "\u0120Molecular": 38275, "\u0120honoring": 38276, "iseum": 38277, "\u0120tractor": 38278, "\u0120Cluster": 38279, "\u0120Calm": 38280, "aredevil": 38281, "\u0120sidewalks": 38282, "\u0120violin": 38283, "\u0120generalized": 38284, "\u0120Alec": 38285, "\u0120embargo": 38286, "\u0120fastball": 38287, "\u0120HTTPS": 38288, "\u0120Lack": 38289, "\u0120Chill": 38290, "river": 38291, "Chel": 38292, "\u0120Swarm": 38293, "\u0120Levine": 38294, "roying": 38295, "Launch": 38296, "\u0120kicker": 38297, "\u0120additive": 38298, "\u0120Deals": 38299, "Widget": 38300, "containing": 38301, "\u0120escalate": 38302, "\u0120OPEN": 38303, "\u0120tweaked": 38304, "\u0120stash": 38305, "\u0120sparks": 38306, "\u0120Essex": 38307, "\u0120Ecc": 38308, "\u0120convict": 38309, "\u0120blogging": 38310, "IER": 38311, "\u0120HL": 38312, "\u0120murderers": 38313, "759": 38314, "\u0120Hib": 38315, "\u0120depl": 38316, "\u0120Jord": 38317, "Sac": 38318, "\u0120dissect": 38319, "\u0120Howe": 38320, "osher": 38321, "\u0120customizable": 38322, "\u0120Franz": 38323, "\u0120atro": 38324, "\u00c4\u0129": 38325, "\u01200004": 38326, "\u0120outpost": 38327, "Ross": 38328, "\u0120glyphosate": 38329, "\u0120Hastings": 38330, "\u0120BEFORE": 38331, "\u0120shove": 38332, "opped": 38333, "\u0120Scala": 38334, "\u0120amulet": 38335, "anian": 38336, "\u0120exacerbated": 38337, "\u0120eater": 38338, "471": 38339, "UME": 38340, "\u0120pulp": 38341, "izontal": 38342, "\u0120Zam": 38343, "\u0120ATI": 38344, "immune": 38345, "abytes": 38346, "\u0120unnecessarily": 38347, "\u0120CAT": 38348, "\u0120Axis": 38349, "\u0120visualize": 38350, "\u00c3\u012b": 38351, "\u0120Radical": 38352, "fm": 38353, "Documents": 38354, "\u0120Forrest": 38355, "\u0120contextual": 38356, "\u0120Symbol": 38357, "\u0120tentative": 38358, "\u0120DOES": 38359, "\u0120Goods": 38360, "\u0120intermittent": 38361, "}:": 38362, "mediated": 38363, "\u0120ridicule": 38364, "\u0120atheism": 38365, "\u0120pathogens": 38366, "\u0120Mum": 38367, "\u0120reintrodu": 38368, "\u0120307": 38369, "iHUD": 38370, "\u0120flashlight": 38371, "\u0120swearing": 38372, "\u0120pengu": 38373, "Bu": 38374, "\u0120rotated": 38375, "\u0120Crane": 38376, "\u0120());": 38377, "\u0120fashionable": 38378, "\u0120endorsing": 38379, "463": 38380, ")[": 38381, "\u0120ingestion": 38382, "\u0120cooks": 38383, "\u0120950": 38384, "otomy": 38385, "\u0120Imam": 38386, "\u0120ka": 38387, "\u0120teaser": 38388, "\u0120Ghosts": 38389, "\u0120\u00e3\u0124\u00b5": 38390, "1969": 38391, "\u00cf\u0125": 38392, "ubby": 38393, "\u0120converter": 38394, "zanne": 38395, "ende": 38396, "\u0120Prepar": 38397, "\u0120Nickel": 38398, "\u0120Chimera": 38399, "him": 38400, "\u0120Tyrann": 38401, "\u0120Sabbath": 38402, "\u0120Nichols": 38403, "\u0120rapt": 38404, "ihar": 38405, "\u0120shelling": 38406, "\u0120illuminate": 38407, "\u0120dentist": 38408, "utor": 38409, "\u0120Integration": 38410, "\u0120whims": 38411, "\u0120Literary": 38412, "Beaut": 38413, "\u0120parchment": 38414, "agara": 38415, "Brand": 38416, "\u0120derog": 38417, "\u00e2\u0122\u00a6)": 38418, "\u0120Norse": 38419, "\u0120unwitting": 38420, "\u0120cuc": 38421, "\u0120borderline": 38422, "\u0120upsetting": 38423, "\u0120recourse": 38424, "\u0120draped": 38425, "\u0120Radar": 38426, "\u0120colder": 38427, "\u0120Pepsi": 38428, "iminary": 38429, "],[": 38430, "658": 38431, "Vi": 38432, "\u0120Frem": 38433, "\u0120Pes": 38434, "\u0120veterinary": 38435, "\u0120TED": 38436, "\u0120Epidem": 38437, "nova": 38438, "kid": 38439, "\u0120devout": 38440, "oct": 38441, "jad": 38442, "Moh": 38443, "\u0120PAY": 38444, "\u0120geometric": 38445, "\u0120323": 38446, "\u0120circumference": 38447, "ichick": 38448, "1975": 38449, "\u0120Yuri": 38450, "\u0120Shall": 38451, "\u0120Hover": 38452, "unin": 38453, "Spr": 38454, "\u0120graft": 38455, "\u0120Happiness": 38456, "\u0120disadvantages": 38457, "attacks": 38458, "\u0120hubs": 38459, "\u0120StarCraft": 38460, "\u00e9\u0138": 38461, "\u0120galleries": 38462, "\u0120Korra": 38463, "\u0120groceries": 38464, "\u0120Gorsuch": 38465, "\u0120rapists": 38466, "\u0120fungi": 38467, "\u0120Typhoon": 38468, "Vector": 38469, "\u0120Empress": 38470, "battle": 38471, "468": 38472, "\u0120parasite": 38473, "\u0120Bomber": 38474, "SG": 38475, "exist": 38476, "\u0120Pf": 38477, "\u0120unse": 38478, "\u0120surgeons": 38479, "Birth": 38480, "\u0120Unsure": 38481, "\u0120Printed": 38482, "\u0120Behavioral": 38483, "\u0120Aster": 38484, "Pakistan": 38485, "\u0120unethical": 38486, "\u0120sv": 38487, "\u0120IoT": 38488, "\u0120layouts": 38489, "Pain": 38490, "\u0120constants": 38491, "\u0120LW": 38492, "\u0120Bake": 38493, "\u0120towels": 38494, "\u0120deterioration": 38495, "\u0120Bolivia": 38496, "\u0120blinded": 38497, "\u0120Warden": 38498, "\u0120Mistress": 38499, "\u0120onstage": 38500, "\u0120clans": 38501, "\u0120BEST": 38502, "1960": 38503, "\u0120antique": 38504, "\u0120rhetorical": 38505, "\u0120Percy": 38506, "\u0120Rwanda": 38507, ",.": 38508, "Bruce": 38509, "\u0120traumat": 38510, "\u0120Parliamentary": 38511, "\u0120footnote": 38512, "idia": 38513, "\u0120Learned": 38514, "seeking": 38515, "genic": 38516, "\u0120dimensional": 38517, "Hide": 38518, "\u00e8\u0122\u0127": 38519, "\u0120intrigue": 38520, "inse": 38521, "\u0120leases": 38522, "\u0120apprentices": 38523, "washing": 38524, "\u01201926": 38525, "VILLE": 38526, "\u0120swoop": 38527, "scl": 38528, "\u0120bedrooms": 38529, "onics": 38530, "\u0120Crunch": 38531, "compatible": 38532, "\u0120incapac": 38533, "\u0120Yemeni": 38534, "ashtra": 38535, "zhou": 38536, "danger": 38537, "\u0120manifestations": 38538, "\u0120Demons": 38539, "AAF": 38540, "Secretary": 38541, "ACTED": 38542, "LOD": 38543, "\u0120amy": 38544, "raper": 38545, "ethnic": 38546, "417": 38547, "\u0120positives": 38548, "\u0120273": 38549, "\u0120Refugees": 38550, "\u0120usb": 38551, "\u0120Vald": 38552, "oddy": 38553, "\u0120Mahmoud": 38554, "Asia": 38555, "\u0120skulls": 38556, "\u0120Exodus": 38557, "\u0120Compet": 38558, "\u0120LIC": 38559, "\u0120Mansion": 38560, "\u0120Ame": 38561, "\u0120consolidate": 38562, "storms": 38563, "ontent": 38564, "996": 38565, "\u0120clen": 38566, "\u0120mummy": 38567, "flat": 38568, "758": 38569, "\u0120VOL": 38570, "oteric": 38571, "nen": 38572, "\u0120Minute": 38573, "Sov": 38574, "\u0120finer": 38575, "Rh": 38576, "lycer": 38577, "\u0120reinforcements": 38578, "\u0120Johannes": 38579, "\u0120Gallagher": 38580, "\u0120gymn": 38581, "Suddenly": 38582, "\u0120extortion": 38583, "kr": 38584, "iator": 38585, "Ta": 38586, "\u0120hippocampus": 38587, "NPR": 38588, "\u0120Computing": 38589, "\u0120squarely": 38590, "\u0120modelling": 38591, "\u0120Forums": 38592, "\u0120Lisp": 38593, "\u0120Krishna": 38594, "\u0120324": 38595, "\u0120rushes": 38596, "\u0120ensued": 38597, "\u0120creeping": 38598, "onte": 38599, "nai": 38600, "ilater": 38601, "\u0120Hornets": 38602, "\u0120oblivious": 38603, "INST": 38604, "559": 38605, "\u0120jeopardy": 38606, "\u0120distinguishing": 38607, "jured": 38608, "\u0120begs": 38609, "similar": 38610, "phot": 38611, "530": 38612, "\u0120Parkway": 38613, "\u0120sinks": 38614, "\u0120Hearthstone": 38615, "ibur": 38616, "\u0120Baton": 38617, "Avoid": 38618, "\u0120dancer": 38619, "\u0120magistrate": 38620, "aryn": 38621, "\u0120disturbances": 38622, "\u0120Romero": 38623, "\u0120paraph": 38624, "\u0120mischief": 38625, "\u00e2\u0138\u0135": 38626, "\u0120Sharia": 38627, "\u0120urinary": 38628, "route": 38629, "ivas": 38630, "fitted": 38631, "\u0120ejected": 38632, "\u0120Albuquerque": 38633, "\u0120470": 38634, "\u0120irritated": 38635, "\u0120Zip": 38636, "\u0120Biol": 38637, "\u00c3\u012f": 38638, "\u0120denounce": 38639, "\u0120binaries": 38640, "\u0120Verse": 38641, "\u0120oppos": 38642, "\u0120Kendrick": 38643, "\u0120GPL": 38644, "\u0120spew": 38645, "\u0120Elijah": 38646, "\u0120Eas": 38647, "\u0120drifted": 38648, "sofar": 38649, "\u0120annoyance": 38650, "\u0120BET": 38651, "474": 38652, "\u0120Strongh": 38653, "itates": 38654, "\u0120Cognitive": 38655, "ophone": 38656, "\u0120Identification": 38657, "ocrine": 38658, "connection": 38659, "\u0120boxer": 38660, "\u0120ASD": 38661, "\u0120Areas": 38662, "Yang": 38663, "tch": 38664, "ullah": 38665, "\u0120deceive": 38666, "Combat": 38667, "episode": 38668, "crete": 38669, "Witness": 38670, "\u0120condolences": 38671, "htar": 38672, "\u0120heals": 38673, "\u0120buckets": 38674, "\u0120LAW": 38675, "Blu": 38676, "\u0120slab": 38677, "\u0120ORDER": 38678, "ocl": 38679, "atton": 38680, "\u0120Stevenson": 38681, "\u0120Ginger": 38682, "\u0120Friendly": 38683, "\u0120Vanderbilt": 38684, "spirit": 38685, "igl": 38686, "\u0120Regarding": 38687, "\u0120PROG": 38688, "\u0120sealing": 38689, "starting": 38690, "\u0120cardinal": 38691, "\u0120Vec": 38692, "\u0120Beir": 38693, "\u0120milliseconds": 38694, "weak": 38695, "perse": 38696, "\u0120sterile": 38697, "\u0120Contemporary": 38698, "\u0120Phant": 38699, "\u0120Clo": 38700, "\u0120outp": 38701, "\u0120exiled": 38702, "\u0120277": 38703, "\u0120selfie": 38704, "\u0120manic": 38705, "\u0120nano": 38706, "terms": 38707, "Alexander": 38708, "\u0120resolves": 38709, "\u0120millennia": 38710, "\u0120explodes": 38711, "\u0120constellation": 38712, "\u0120adultery": 38713, "motion": 38714, "DOC": 38715, "\u0120broadcasters": 38716, "\u0120kindergarten": 38717, "\u0120Mayweather": 38718, "\u0120Eco": 38719, "icho": 38720, "\u0120287": 38721, "laun": 38722, "\u0120mute": 38723, "\u0120discreet": 38724, "\u0120preschool": 38725, "\u0120preempt": 38726, "Delete": 38727, "\u0120Freed": 38728, "Pi": 38729, "HK": 38730, "\u0120blocker": 38731, "\u0120Cumber": 38732, "\u0120wrought": 38733, "dating": 38734, "\u0120insurer": 38735, "\u0120quotas": 38736, "\u0120preached": 38737, "\u0120eviction": 38738, "\u0120Regina": 38739, "\u0120Pens": 38740, "\u0120seventeen": 38741, "\u0120Nass": 38742, "Dick": 38743, "\u0120folds": 38744, "\u0120dotted": 38745, "\u0120Aad": 38746, "Universal": 38747, "\u0120pizz": 38748, "\u0120Guru": 38749, "\u0120soils": 38750, "\u0120novice": 38751, "\u0120Neander": 38752, "\u0120stool": 38753, "\u0120detonated": 38754, "\u0120Pikachu": 38755, "\u0120Massive": 38756, "IVER": 38757, "\u0120Abdel": 38758, "\u0120subdued": 38759, "\u0120tallest": 38760, "\u0120precarious": 38761, "\u0120ay": 38762, "rification": 38763, "\u0120Obj": 38764, "cale": 38765, "\u0120unquestion": 38766, "culosis": 38767, "adas": 38768, "igrated": 38769, "Days": 38770, "\u0120queens": 38771, "\u0120Gazette": 38772, "\u0120Colour": 38773, "\u0120Bowman": 38774, "\u0120JJ": 38775, "\u00c3\u00afve": 38776, "\u0120dominates": 38777, "Student": 38778, "\u0120mu": 38779, "\u0120backlog": 38780, "\u0120Electro": 38781, "Truth": 38782, "483": 38783, "\u0120condensed": 38784, "rules": 38785, "\u0120Conspiracy": 38786, "\u0120acronym": 38787, "handled": 38788, "\u0120Matte": 38789, "jri": 38790, "\u0120Impossible": 38791, "lude": 38792, "creation": 38793, "\u0120warmed": 38794, "\u0120Slave": 38795, "\u0120misled": 38796, "\u0120ferment": 38797, "\u0120Kah": 38798, "inki": 38799, "keleton": 38800, "cyl": 38801, "\u0120Karin": 38802, "Hunter": 38803, "Register": 38804, "\u0120Surrey": 38805, "\u0120stares": 38806, "\u0120Width": 38807, "\u0120Nay": 38808, "\u0120Ski": 38809, "\u0120blacklist": 38810, "ucket": 38811, "\u0120expulsion": 38812, "imet": 38813, "\u0120retweet": 38814, "vantage": 38815, "Feature": 38816, "\u0120troopers": 38817, "\u0120homers": 38818, "969": 38819, "\u0120contingency": 38820, "\u0120WTC": 38821, "\u0120Brewer": 38822, "foreign": 38823, "Ware": 38824, "Solar": 38825, "\u0120undue": 38826, "REC": 38827, "ulnerable": 38828, "pathic": 38829, "\u0120Boise": 38830, "\u0120322": 38831, "\u0120aroused": 38832, "\u0120Ying": 38833, "\u00e4\u00b8\u012f": 38834, "ueless": 38835, "\u0120pas": 38836, "\u0120morp": 38837, "\u0120floral": 38838, "Express": 38839, "udging": 38840, "kB": 38841, "\u0120Granted": 38842, "\u00d8\u00af": 38843, "\u0120Micha": 38844, "\u0120Gothic": 38845, "\u0120SPECIAL": 38846, "\u0120Ricardo": 38847, "Fran": 38848, "\u0120administering": 38849, "620": 38850, "pora": 38851, "\u0120\u00c2\u00ae": 38852, "\u0120compromises": 38853, "\u0120bitten": 38854, "Accept": 38855, "Thirty": 38856, "\u00d0\u00b2": 38857, "\u0120materially": 38858, "\u0120Terr": 38859, "igmatic": 38860, "chains": 38861, "\u0120dove": 38862, "stadt": 38863, "Marvel": 38864, "FAULT": 38865, "\u0120windshield": 38866, "\u0120336": 38867, "adier": 38868, "\u0120swapping": 38869, "\u0120flawless": 38870, "\u0120Predator": 38871, "\u0120Michele": 38872, "\u0120propulsion": 38873, "\u0120Psychic": 38874, "\u0120assigning": 38875, "\u0120fabrication": 38876, "\u0120barley": 38877, "lust": 38878, "\u0120towering": 38879, "\u0120altercation": 38880, "\u0120Bentley": 38881, "Sphere": 38882, "\u0120tuna": 38883, "\u0120Classes": 38884, "Freedom": 38885, "uner": 38886, "Lady": 38887, "voice": 38888, "\u0120coolest": 38889, "orr": 38890, "\u0120palp": 38891, "${": 38892, "\u0120hysteria": 38893, "\u0120Metatron": 38894, "pants": 38895, "\u0120spawning": 38896, "Experts": 38897, "\u0120Investors": 38898, "\u0120Anarchy": 38899, "\u0120shrunk": 38900, "\u0120Victim": 38901, "\u0120289": 38902, "\u0120ecstasy": 38903, "\u0120Binding": 38904, "585": 38905, "\u0120Melody": 38906, "578": 38907, "otally": 38908, "\u0120Etsy": 38909, "liga": 38910, "\u0120applauded": 38911, "\u0120sweating": 38912, "\u0120redistributed": 38913, "\u0120popcorn": 38914, "\u0120seminal": 38915, "fur": 38916, "\u0120Neuroscience": 38917, "Rand": 38918, "\u0120Ost": 38919, "\u0120Madden": 38920, "\u0120Increasing": 38921, "\u0120Dawkins": 38922, "\u0120Subway": 38923, "\u0120arsen": 38924, "conserv": 38925, "BUR": 38926, "\u0120spiked": 38927, "\u0120Lyft": 38928, "\u0120Imperium": 38929, "\u0120Dropbox": 38930, "\u0120favoured": 38931, "\u0120encompasses": 38932, "ghost": 38933, "\u0120inspires": 38934, "\u0120burgeoning": 38935, "\u0120Yoshi": 38936, "\u0120Vertical": 38937, "\u0120Auditor": 38938, "\u0120intending": 38939, "\u0120filibuster": 38940, "Bloom": 38941, "fac": 38942, "\u0120Cavs": 38943, "igning": 38944, "\u0120coworkers": 38945, "\u0120Barbarian": 38946, "remember": 38947, "FLAG": 38948, "\u0120auditory": 38949, "asonry": 38950, "College": 38951, "\u0120muted": 38952, "gemony": 38953, "obin": 38954, "\u0120Psycho": 38955, "968": 38956, "\u0120lavish": 38957, "\u0120hierarchical": 38958, "\u0120Drone": 38959, "ouk": 38960, "\u0120crippled": 38961, "\u0120Maxim": 38962, "Slot": 38963, "\u0120quiz": 38964, "\u0120Vid": 38965, "ifling": 38966, "\u0120archaeologists": 38967, "\u0120abandonment": 38968, "dial": 38969, "leon": 38970, "\u0120Fas": 38971, "Ted": 38972, "\u0120raspberry": 38973, "\u0120maneuvers": 38974, "\u0120behaviours": 38975, "\u0120insure": 38976, "\u0120remod": 38977, "Switch": 38978, "hoe": 38979, "\u0120spaced": 38980, "\u0120affordability": 38981, "\u0120Fern": 38982, "notation": 38983, "\u0120Balanced": 38984, "\u0120occupies": 38985, "environment": 38986, "\u0120necklace": 38987, "\u0120sedan": 38988, "FU": 38989, "\u0120Bravo": 38990, "\u0120abusers": 38991, "\u0120Anita": 38992, "metadata": 38993, "\u0120Github": 38994, "aito": 38995, "\u0120Faster": 38996, "\u0120Wasserman": 38997, "\u0120Flesh": 38998, "\u0120thorn": 38999, "rarily": 39000, "\u0120Merry": 39001, "wine": 39002, "\u0120populace": 39003, "\u0120Lann": 39004, "\u0120repairing": 39005, "\u0120psyche": 39006, "\u0120modulation": 39007, "awaru": 39008, "\u00e2\u0122\u012d\u00e2\u0122\u012d": 39009, "arij": 39010, "\u0120decorations": 39011, "\u0120apologise": 39012, "\u0120Garg": 39013, "apply": 39014, "\u0120giveaway": 39015, "\u0120Flan": 39016, "\u0120Wyatt": 39017, "Uber": 39018, "\u0120authorised": 39019, "\u0120Moral": 39020, "HAHAHAHA": 39021, "activate": 39022, "\u0120torpedo": 39023, "\u0120FAR": 39024, "\u0120amassed": 39025, "\u0120Aram": 39026, "arkin": 39027, "\u0120Victims": 39028, "stab": 39029, "\u0120om": 39030, "\u0120ECO": 39031, "\u0120opioids": 39032, "\u0120purposely": 39033, "\u0120Vest": 39034, "\u0120erg": 39035, "atan": 39036, "\u0120Surgery": 39037, "\u0120correcting": 39038, "\u0120Ortiz": 39039, "\u0120Beet": 39040, "\u0120revoke": 39041, "\u0120freeway": 39042, "\u0120Higgins": 39043, "Fail": 39044, "\u0120Farms": 39045, "\u0120ATP": 39046, "hound": 39047, "\u0120poking": 39048, "\u0120Communists": 39049, "monster": 39050, "imentary": 39051, "\u0120unlocking": 39052, "\u0120unfit": 39053, "weed": 39054, "enario": 39055, "atical": 39056, "\u0120Enlightenment": 39057, "\u0120NG": 39058, "\u0120Compensation": 39059, "deen": 39060, "\u0120Widow": 39061, "\u0120Cindy": 39062, "\u0120Afterwards": 39063, "\u01206000": 39064, "ikhail": 39065, "agically": 39066, "\u0120ratified": 39067, "\u0120casualty": 39068, "HOME": 39069, "psey": 39070, "fee": 39071, "\u0120sparkling": 39072, "\u0120d\u00c3\u00a9": 39073, "\u0120concerted": 39074, "Catal": 39075, "\u0120complying": 39076, "\u0120Ares": 39077, "\u0120Dent": 39078, "Shut": 39079, "\u0120skim": 39080, "administ": 39081, "\u0120hostilities": 39082, "\u0120Gins": 39083, "\u0120608": 39084, "\u0120muddy": 39085, "\u0120McInt": 39086, "\u0120Decay": 39087, "525": 39088, "\u0120conspicuous": 39089, "\u0120Exposure": 39090, "\u0120rescind": 39091, "\u0120wearable": 39092, "\u0120328": 39093, "ourmet": 39094, "ahs": 39095, "\u0120Robots": 39096, "\u0120eclips": 39097, "instance": 39098, "\u0120REPORT": 39099, "\u0120Appl": 39100, "030": 39101, "\u0120Skies": 39102, "0100": 39103, "\u0120fallacy": 39104, "Socket": 39105, "\u0120Receiver": 39106, "\u0120solves": 39107, "\u0120Butterfly": 39108, "\u0120Shopping": 39109, "\u0120FIRE": 39110, "654": 39111, "Medic": 39112, "\u0120singers": 39113, "\u0120Needless": 39114, "''''": 39115, "ishers": 39116, "\u0120Dive": 39117, "588": 39118, "\u0120selectively": 39119, "\u0120clumsy": 39120, "889": 39121, "\u0120purchaser": 39122, "earned": 39123, "ardy": 39124, "\u0120benefiting": 39125, "english": 39126, "\u0120yielding": 39127, "\u0120Pour": 39128, "\u0120spinach": 39129, "\u0120delve": 39130, "\u0120Crom": 39131, "610": 39132, "\u0120exporting": 39133, "\u0120MAKE": 39134, "\u0120263": 39135, "\u0120grop": 39136, "\u0120envoy": 39137, "\u0120Inquiry": 39138, "\u0120Luigi": 39139, "dry": 39140, "\u0120Turing": 39141, "ThumbnailImage": 39142, "\u0120Variety": 39143, "\u0120facet": 39144, "\u0120fluffy": 39145, "\u0120excerpts": 39146, "\u0120shorth": 39147, "\u0120Olsen": 39148, "CLUD": 39149, "\u0120reliant": 39150, "\u0120UNC": 39151, "Tour": 39152, "\u0120bathing": 39153, "Company": 39154, "\u0120globalization": 39155, "Pred": 39156, "\u0120Malfoy": 39157, "\u0120hoc": 39158, "jam": 39159, "crafted": 39160, "\u0120Bonds": 39161, "\u0120Kissinger": 39162, "England": 39163, "\u0120orderly": 39164, "catentry": 39165, "\u0120261": 39166, "\u0120exchanging": 39167, "\u0120Intent": 39168, "\u0120Amendments": 39169, "DOM": 39170, "\u0120stout": 39171, "\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142\u00c2\u0142": 39172, "\u0120Airbus": 39173, "\u0120278": 39174, "hyde": 39175, "Poll": 39176, "ItemThumbnailImage": 39177, "\u0120loopholes": 39178, "\u0120Pillar": 39179, "\u0120explor": 39180, "Stretch": 39181, "Apart": 39182, "\u0120unmarried": 39183, "Limit": 39184, "\u0120Transformers": 39185, "\u0120intellectually": 39186, "uncture": 39187, "1800": 39188, "\u0120darn": 39189, "Brazil": 39190, "\u0120leftover": 39191, "berus": 39192, "fred": 39193, "Minecraft": 39194, "326": 39195, "\u0120Forms": 39196, "\u0120proofs": 39197, "\u0120Designed": 39198, "\u0120indexes": 39199, "\u0120Suppose": 39200, "EMS": 39201, "\u0120Loving": 39202, "\u0120Bonnie": 39203, "imating": 39204, "OTUS": 39205, "\u0120conductor": 39206, "\u0120behaved": 39207, "\u0120Fren": 39208, "\u0120synerg": 39209, "\u0120millennium": 39210, "\u0120catering": 39211, "\u0120Lauder": 39212, "Wr": 39213, "\u0120Yiannopoulos": 39214, "\u0120ATF": 39215, "\u0120enslaved": 39216, "\u0120awakened": 39217, "DVD": 39218, "\u0120EDITION": 39219, "\u0120Concert": 39220, "\u0120Challenger": 39221, "\u0120Haku": 39222, "umeric": 39223, "\u0120deprecated": 39224, "\u0120SHAR": 39225, "412": 39226, "\u0120dystop": 39227, "\u0120trembling": 39228, "\u0120dreaded": 39229, "\u0120Spac": 39230, "padding": 39231, "Repl": 39232, "\u0120Garrison": 39233, "Mini": 39234, "\u0120unparalleled": 39235, "amar": 39236, "URRENT": 39237, "wreck": 39238, "certain": 39239, "tal": 39240, "\u0120CLS": 39241, "appings": 39242, "\u0120sensed": 39243, "\u0120fencing": 39244, "\u0120Paso": 39245, "\u0120Desk": 39246, "\u0120scoff": 39247, "\u0120contemplate": 39248, "\u0120Liga": 39249, "liquid": 39250, "757": 39251, "\u0120apprentice": 39252, "\u0120UCHIJ": 39253, "570": 39254, "\u0120Thousand": 39255, "\u0120Illum": 39256, "\u0120championed": 39257, "\u00e3\u0124\u012e": 39258, "\u0120electors": 39259, "\u0120398": 39260, "\u0120Hancock": 39261, "rounded": 39262, "\u0120JOHN": 39263, "\u0120unsatisf": 39264, "\u0120qualifier": 39265, "\u0120Gadget": 39266, "ENE": 39267, "\u0120deadliest": 39268, "\u0120Plants": 39269, "\u0120ions": 39270, "\u0120accents": 39271, "\u0120tweaking": 39272, "\u0120shaved": 39273, "FREE": 39274, "\u0120Chaser": 39275, "Against": 39276, "960": 39277, "\u0120methamphetamine": 39278, "\u0120normalized": 39279, "\u0120$\\": 39280, "\u0120Precision": 39281, "\u0120Guam": 39282, "\u0120choked": 39283, "\u0120XII": 39284, "\u0120Casting": 39285, "Torrent": 39286, "\u0120scalp": 39287, "\u0120Jaguar": 39288, "wit": 39289, "\u0120semic": 39290, "ixie": 39291, "\u0120Gould": 39292, "\u0120confines": 39293, "Nusra": 39294, "\u0120Lon": 39295, "\u0120Jugg": 39296, "ycle": 39297, "\u0120Codec": 39298, "Egypt": 39299, "\u0120restrain": 39300, "\u0120Aliens": 39301, "\u0120choking": 39302, "\u0120Dunk": 39303, "\u0120Bella": 39304, "abc": 39305, "\u0120slang": 39306, "\u0120neurotrans": 39307, "sav": 39308, "\u0120empowerment": 39309, "\u00e2\u0128\u0134": 39310, "\u0120climbers": 39311, "\u0120Mim": 39312, "\u0120Fra": 39313, "rosse": 39314, "Capital": 39315, "\u0120Cthulhu": 39316, "Interface": 39317, "\u0120proficient": 39318, "\u0120INTO": 39319, "\u0120318": 39320, "rontal": 39321, "580": 39322, "\u0120Despair": 39323, "Kenn": 39324, "\u0120scrimmage": 39325, "\u0120Coat": 39326, "asions": 39327, "\u0120wallpaper": 39328, "\u0120Jol": 39329, "\u0120resurgence": 39330, "\u0120antiv": 39331, "\u0120Balls": 39332, "\u00b2\u00be": 39333, "\u0120buffers": 39334, "\u0120subsystem": 39335, "\u0120Stellar": 39336, "\u0120Lung": 39337, "AIDS": 39338, "\u0120eradicate": 39339, "\u0120blatantly": 39340, "\u0120behaves": 39341, "\u0120Nun": 39342, "\u0120antics": 39343, "export": 39344, "DEV": 39345, "wb": 39346, "\u0120php": 39347, "\u0120Integrity": 39348, "\u0120explorer": 39349, "\u0120revolving": 39350, "authored": 39351, "gans": 39352, "\u0120bask": 39353, "\u0120asynchronous": 39354, "\u00e5\u012f": 39355, "THING": 39356, "698": 39357, "Gene": 39358, "\u0120Racer": 39359, "\u0120Nico": 39360, "issued": 39361, "\u0120sermon": 39362, "possibly": 39363, "\u0120sizeof": 39364, "\u0120entrepreneurial": 39365, "oxin": 39366, "\u0120Minerva": 39367, "\u0120platoon": 39368, "nos": 39369, "riks": 39370, "AUT": 39371, "\u0120Avalanche": 39372, "\u0120Desc": 39373, "\u0133\u00e5\u00a3\u00ab": 39374, "\u0120Poc": 39375, "\u0120conferred": 39376, "\u00ce\u00bb": 39377, "\u0120patched": 39378, "FBI": 39379, "662": 39380, "\u0120fractures": 39381, "\u0120detects": 39382, "\u0120dedicate": 39383, "\u0120constituent": 39384, "\u0120cosmos": 39385, "WT": 39386, "\u0120sweats": 39387, "\u0120sprung": 39388, "bara": 39389, "solid": 39390, "\u0120unsus": 39391, "\u0120bulky": 39392, "\u0120Philippe": 39393, "\u0120Fenrir": 39394, "\u0120therapists": 39395, "oreal": 39396, "^^^^": 39397, "\u0120totaled": 39398, "\u0120booze": 39399, "\u0120RPC": 39400, "Prosecutors": 39401, "\u0120diseng": 39402, "\u0120Shared": 39403, "\u0120motorcycles": 39404, "\u0120inventions": 39405, "\u0120lettuce": 39406, "\u0120Merge": 39407, "\u0120JC": 39408, "\u0120spirituality": 39409, "\u0120WARNING": 39410, "\u0120unlucky": 39411, "\u0120Tess": 39412, "\u0120tongues": 39413, "\u0120DUI": 39414, "Tumblr": 39415, "\u0120leans": 39416, "\u0120invaders": 39417, "\u0120canopy": 39418, "\u0120Hurricanes": 39419, "\u0120Bret": 39420, "\u0120APPLIC": 39421, "idine": 39422, "ickle": 39423, "Regarding": 39424, "\u0120veggies": 39425, "\u0120ejac": 39426, "juven": 39427, "Fish": 39428, "DEM": 39429, "\u0120Dino": 39430, "Throw": 39431, "\u0120Checking": 39432, "beard": 39433, "(&": 39434, "\u0120jails": 39435, "\u0120hr": 39436, "transfer": 39437, "ivating": 39438, "\u0120fleets": 39439, "\u0120Imag": 39440, "\u0120McDonnell": 39441, "\u0120snippet": 39442, "Isa": 39443, "\u0120Chatt": 39444, "\u0120Stain": 39445, "\u0120SetFontSize": 39446, "\u0120Oy": 39447, "\u0120Mathematics": 39448, "494": 39449, "\u0120electroly": 39450, "\u0120Gott": 39451, "\u0120Bras": 39452, "BOOK": 39453, "\u0120Finger": 39454, "dump": 39455, "\u0120mutants": 39456, "\u0120rentals": 39457, "\u0120intertw": 39458, "\u0120creek": 39459, "aila": 39460, "Brother": 39461, "\u0120Discord": 39462, "pee": 39463, "rawler": 39464, "\u0120carp": 39465, "\u0120279": 39466, "\u00e3\u0124\u00b7\u00e3\u0125\u00a3": 39467, "relations": 39468, "\u0120contrasts": 39469, "Column": 39470, "\u0120reconnaissance": 39471, "\u0120unknow": 39472, "\u0120looting": 39473, "\u0120regulates": 39474, "\u0120optimum": 39475, "\u0120Cherokee": 39476, "\u0120Ary": 39477, "Latest": 39478, "\u0120roadside": 39479, "\u0120danced": 39480, "\u0120Unicorn": 39481, "Acknowled": 39482, "\u0120uncontroll": 39483, "\u0120MUS": 39484, "atio": 39485, "chance": 39486, "haven": 39487, "VALUE": 39488, "\u0120favourites": 39489, "\u0120ceremonial": 39490, "binary": 39491, "peed": 39492, "woods": 39493, "EMP": 39494, "\u0120vascular": 39495, "\u0120contemplated": 39496, "\u0120barren": 39497, "\u0120LIST": 39498, "Yellow": 39499, "osponsors": 39500, "\u0120whisky": 39501, "\u0120Mamm": 39502, "\u0120DeVos": 39503, "minimum": 39504, "Hung": 39505, "442": 39506, "Pic": 39507, "\u0120Snapdragon": 39508, "776": 39509, "\u0120carving": 39510, "\u0120undecided": 39511, "\u0120advantageous": 39512, "\u0120palms": 39513, "\u0120AQ": 39514, "\u0120starch": 39515, "Loop": 39516, "\u0120paddle": 39517, "\u0120flaming": 39518, "\u0120Horizons": 39519, "Animation": 39520, "boost": 39521, "\u0120probabilities": 39522, "\u0120Mish": 39523, "\u0120exodus": 39524, "\u0120Editorial": 39525, "\u0120fungus": 39526, "\u0120dissenting": 39527, "\u0120Delicious": 39528, "rogram": 39529, "\u0120Dyn": 39530, "disk": 39531, "tom": 39532, "\u0120fabrics": 39533, "\u0120Cove": 39534, "\u0120Bans": 39535, "\u0120soften": 39536, "\u0120CONS": 39537, "\u0120ineligible": 39538, "\u0120estimating": 39539, "\u0120Lexington": 39540, "practice": 39541, "ofi": 39542, "\u0120shedding": 39543, "\u0120Nope": 39544, "\u0120breathed": 39545, "\u0120Corinthians": 39546, "yne": 39547, "eki": 39548, "Bull": 39549, "\u0120attaching": 39550, "reenshots": 39551, "\u0120analyse": 39552, "\u0120Kappa": 39553, "\u0120unsustainable": 39554, "\u0120interpol": 39555, "anky": 39556, "hemer": 39557, "\u0120protagonists": 39558, "\u0120formatted": 39559, "\u0120Bryce": 39560, "\u0120Achilles": 39561, "\u0120Abedin": 39562, "shock": 39563, "\u0120bum": 39564, "bos": 39565, "qua": 39566, "\u0120Warn": 39567, "qt": 39568, "\u0120Diabetes": 39569, "864": 39570, "\u0120Invisible": 39571, "\u0120vanish": 39572, "\u0120transmitting": 39573, "\u0120murky": 39574, "\u0120Fei": 39575, "\u0120awaited": 39576, "\u0120Jurassic": 39577, "ummies": 39578, "\u0120menacing": 39579, "gall": 39580, "Cath": 39581, "Built": 39582, "ildo": 39583, "\u0120Votes": 39584, "\u0120ont": 39585, "\u0120munitions": 39586, "\u0120Freem": 39587, "\u00c3\u0143n": 39588, "\u0120decency": 39589, "lopp": 39590, "ieved": 39591, "\u0120Gord": 39592, "\u0120unthinkable": 39593, "\u0120Newsweek": 39594, "\u0120321": 39595, "Heat": 39596, "\u0120presenter": 39597, "jiang": 39598, "\u0120plank": 39599, "\u0120Avalon": 39600, "\u0120benz": 39601, "\u0120Rout": 39602, "\u0120slamming": 39603, "\u0120Dai": 39604, "outer": 39605, "\u0120Cookie": 39606, "\u0120Alicia": 39607, "gey": 39608, "\u0120vanity": 39609, "\u0120owl": 39610, "\u00e1\u00b5": 39611, "tested": 39612, "\u0120Awakens": 39613, "\u0120canv": 39614, "\u0120blindly": 39615, "\u0120Ridley": 39616, "\u0120Emails": 39617, "Requires": 39618, "\u0120Serbian": 39619, "ographed": 39620, "iframe": 39621, "eteria": 39622, "\u0120alternating": 39623, "quiet": 39624, "\u0120sociology": 39625, "\u0120Unlock": 39626, "\u0120Communism": 39627, "\u0120ops": 39628, "\u0120attribution": 39629, "\u0120abduction": 39630, "\u0120Abram": 39631, "\u0120sidelined": 39632, "\u0120BOOK": 39633, "\u0120refining": 39634, "\u0120Feeling": 39635, "\u0120Oslo": 39636, "\u0120Pruitt": 39637, "rack": 39638, "angible": 39639, "\u0120cautiously": 39640, "\u0120MARK": 39641, "eeds": 39642, "Mouse": 39643, "\u0120Steph": 39644, "\u0120Pair": 39645, "Sab": 39646, "997": 39647, "\u0120Baal": 39648, "Bec": 39649, "\u0120comma": 39650, "\u0120Pall": 39651, "\u0120Gael": 39652, "\u0120misunderstand": 39653, "\u0120Pesh": 39654, "Orderable": 39655, "\u0120dismal": 39656, "\u0120Shiny": 39657, "%\"": 39658, "\u0120realistically": 39659, "\u0120patio": 39660, "\u0120Gw": 39661, "\u0120Virtue": 39662, "\u0120exhausting": 39663, "whatever": 39664, "ophys": 39665, "yip": 39666, "418": 39667, "Adjust": 39668, "\u0120Waiting": 39669, "esson": 39670, "\u0120Mazda": 39671, "\u0120Dozens": 39672, "\u0120streamlined": 39673, "\u0120incompetence": 39674, "\u0120Meth": 39675, "\u0120ethos": 39676, "ONES": 39677, "\u0120incentiv": 39678, "\u0120gritty": 39679, "\u0120Butcher": 39680, "Header": 39681, "\u0120exponential": 39682, "\u00c3\u0141": 39683, "\u0120correlate": 39684, "\u0120consensual": 39685, "sounding": 39686, "Ring": 39687, "Origin": 39688, "\u0120conclusive": 39689, "feet": 39690, "acly": 39691, "\u0120Fernandez": 39692, "Buyable": 39693, "\u0120ducks": 39694, "auntlets": 39695, "\u0120elong": 39696, "\u0120286": 39697, "\u0120simul": 39698, "Gas": 39699, "\u0120Kirst": 39700, "\u0120protr": 39701, "\u0120Robo": 39702, "\u0120AoE": 39703, "opol": 39704, "\u0120psychologically": 39705, "spin": 39706, "ilaterally": 39707, "\u0120Conrad": 39708, "Wave": 39709, "441": 39710, "\u0120Advertisement": 39711, "\u0120Harmon": 39712, "\u0120Oriental": 39713, "isSpecial": 39714, "\u0120presumptive": 39715, "\u0120wil": 39716, "\u0120Kier": 39717, "nea": 39718, "\u0120ppm": 39719, "\u0120harbour": 39720, "\u0120Wired": 39721, "company": 39722, "\u0120coroner": 39723, "aturdays": 39724, "\u0120Proud": 39725, "\u0120NEXT": 39726, "\u0120Flake": 39727, "valued": 39728, "ceiver": 39729, "\u0120fraught": 39730, "\u0120casing": 39731, "\u0120runaway": 39732, "\u0120gin": 39733, "\u0120Laurent": 39734, "\u0120Harlem": 39735, "\u0120Curiosity": 39736, "quished": 39737, "\u0120neuroscience": 39738, "\u0120Hulu": 39739, "\u0120borrower": 39740, "\u0120petitioner": 39741, "\u0120Cooldown": 39742, "WARD": 39743, "\u0120invoking": 39744, "confidence": 39745, "Forward": 39746, "\u0120sts": 39747, "population": 39748, "DeliveryDate": 39749, "Film": 39750, "\u0120Cov": 39751, "quickShip": 39752, "quickShipAvailable": 39753, "primary": 39754, "isSpecialOrderable": 39755, "inventoryQuantity": 39756, "channelAvailability": 39757, "BOX": 39758, "\u0120Multiplayer": 39759, "\u0120Jenner": 39760, "778": 39761, "\u0120Md": 39762, "\u0120~/.": 39763, "MN": 39764, "\u0120childish": 39765, "\u0120antioxidant": 39766, "\u0120Chromebook": 39767, "\u0120274": 39768, "\u0120screenplay": 39769, "\u0120adventurous": 39770, "\u0120Relationship": 39771, "responsive": 39772, "mington": 39773, "\u0120cornerstone": 39774, "\u0120Fey": 39775, "FIR": 39776, "\u0120rookies": 39777, "\u0120Featuring": 39778, "\u0120originate": 39779, "\u0120electrodes": 39780, "antes": 39781, "\u0120scriptures": 39782, "\u0120glued": 39783, "\u0120discontent": 39784, "\u0120afflicted": 39785, "layout": 39786, "Brave": 39787, "\u0120mosa": 39788, "\u0120Quantity": 39789, "\u0120Hik": 39790, "winner": 39791, "Hours": 39792, "\u0120entail": 39793, "\u0120Cells": 39794, "ologue": 39795, "\u0120vil": 39796, "\u0120preacher": 39797, "\u0120decorative": 39798, "different": 39799, "\u0120prejudices": 39800, "\u0120Smoking": 39801, "\u0120Nottingham": 39802, "soType": 39803, "\u0120rhythms": 39804, "\u0120Alph": 39805, "blast": 39806, "Steel": 39807, "\u0120Danielle": 39808, "\u0120strife": 39809, "\u0120rematch": 39810, "soDeliveryDate": 39811, "\u0120Fork": 39812, "trip": 39813, "olulu": 39814, "heses": 39815, "CG": 39816, "\u0120POLITICO": 39817, "osta": 39818, "\u0120Drift": 39819, "\u00e9\u00be\u012f\u00e5\u00a5": 39820, "\u00e9\u00be\u012f\u00e5\u00a5\u0133\u00e5\u00a3\u00ab": 39821, "\u0120vetting": 39822, "\u0120Jinping": 39823, "\u0120Recession": 39824, "Minor": 39825, "\u0120Fraud": 39826, "enfranch": 39827, "\u0120convened": 39828, "\u0120NAACP": 39829, "\u0120Millions": 39830, "\u0120Farming": 39831, "\u0120Woo": 39832, "\u0120Flare": 39833, "rito": 39834, "immigrant": 39835, "\u0120vacancy": 39836, "\u0120HEAD": 39837, "\u0120Vaj": 39838, "egal": 39839, "\u0120Vigil": 39840, "Study": 39841, "\u0120ruining": 39842, "\u0120racks": 39843, "\u0120heater": 39844, "\u0120Randolph": 39845, "\u0120Brush": 39846, "\u0120Tir": 39847, "\u00d8\u00a8": 39848, "\u0120cov": 39849, "%]": 39850, "\u0120recounts": 39851, "\u0120OPT": 39852, "\u0120Melt": 39853, "\u0120truce": 39854, "\u0120casinos": 39855, "\u0120crusade": 39856, "\u0120carnage": 39857, "\u0120stripe": 39858, "\u0120Kyl": 39859, "Textures": 39860, "\u0120698": 39861, "\u0120proclamation": 39862, "\u0120goodies": 39863, "\u0120..........": 39864, "proclaimed": 39865, "Polit": 39866, "\u0120topical": 39867, "\u0120specialize": 39868, "\u0120Amin": 39869, "gm": 39870, "\u0120anchored": 39871, "\u0120bearings": 39872, "sample": 39873, "\u0120Highland": 39874, "\u0120Autism": 39875, "\u0120mercenary": 39876, "\u0120interviewer": 39877, "LER": 39878, "\u0120Somers": 39879, "\u0120embryo": 39880, "\u0120Assy": 39881, "\u0120281": 39882, "\u0120Editing": 39883, "\u0120Chosen": 39884, "660": 39885, "\u0120pci": 39886, "\u0120Thunderbolt": 39887, "BILL": 39888, "\u0120chuckled": 39889, "jriwal": 39890, "hof": 39891, "\u0120earthly": 39892, "(){": 39893, "independence": 39894, "\u0120dispers": 39895, "\u0120Vendor": 39896, "\u0120Gareth": 39897, "\u0120pals": 39898, "Penn": 39899, "\u0120Submit": 39900, "icum": 39901, "Thu": 39902, "\u0120clandestine": 39903, "\u0120cannibal": 39904, "\u0120Clerk": 39905, "EStream": 39906, "galitarian": 39907, "\u00e2\u013b\u00a5": 39908, "gew": 39909, "\u0120horrend": 39910, "\u0120Lov": 39911, "\u0120Reaction": 39912, "ocrin": 39913, "Classic": 39914, "\u0120echoing": 39915, "\u0120disclosing": 39916, "\u0120Insight": 39917, "ogun": 39918, "\u0120Incarn": 39919, "uploads": 39920, "pperc": 39921, "guyen": 39922, "\u01201901": 39923, "\u0120Bars": 39924, "687": 39925, "\u0120bribes": 39926, "\u0120Fresno": 39927, "urat": 39928, "\u0120Reese": 39929, "\u0120intrusive": 39930, "\u0120gripping": 39931, "\u0120Blueprint": 39932, "\u0120Rasm": 39933, "unia": 39934, "managed": 39935, "\u0120Hebdo": 39936, "\u0120345": 39937, "\u0120decoding": 39938, "\u0120poets": 39939, "\u0120jaws": 39940, "\u0120FIGHT": 39941, "ameless": 39942, "\u0120Meadows": 39943, "\u0120Harbaugh": 39944, "Interview": 39945, "\u0120Hosp": 39946, "\u0120BRA": 39947, "\u0120deletion": 39948, "mob": 39949, "Walker": 39950, "\u0120Moonlight": 39951, "\u0120Jed": 39952, "\u0120Sophia": 39953, "\u0120usur": 39954, "\u0120fortunately": 39955, "\u0120Putting": 39956, "\u0120Fold": 39957, "\u0120sanitation": 39958, "\u0120partisans": 39959, "ISON": 39960, "Bow": 39961, "\u0120CONC": 39962, "\u0120Reduced": 39963, "\u0120Sutton": 39964, "\u0120touchscreen": 39965, "\u0120embryos": 39966, "\u00e2\u0122\u00a2\u00e2\u0122\u00a2\u00e2\u0122\u00a2\u00e2\u0122\u00a2": 39967, "\u0120Krug": 39968, "combat": 39969, "\u0120Petroleum": 39970, "\u0120amd": 39971, "\u0120Cosmos": 39972, "\u0120prescribing": 39973, "\u0120conformity": 39974, "ourses": 39975, "\u0120plentiful": 39976, "\u0120disillusion": 39977, "\u0120Ecology": 39978, "ittal": 39979, "\u0120fanc": 39980, "\u0120assassinated": 39981, "regnancy": 39982, "\u0120perennial": 39983, "\u0120Bullets": 39984, "\u0120stale": 39985, "\u0120cached": 39986, "\u0120Judith": 39987, "\u0120Diseases": 39988, "Allen": 39989, "\u0120las": 39990, "\u0120shards": 39991, "\u0120Suarez": 39992, "\u0120Friendship": 39993, "interface": 39994, "\u0120Supporters": 39995, "addons": 39996, "462": 39997, "\u0120Imran": 39998, "\u0120Wim": 39999, "\u0120newfound": 40000, "\u0120Mb": 40001, "Animal": 40002, "\u0120darling": 40003, "ande": 40004, "\u0120rhy": 40005, "\u0120Twisted": 40006, "posal": 40007, "ynski": 40008, "Various": 40009, "\u00d7\u013e": 40010, "\u0120Kiw": 40011, "uyomi": 40012, "\u0120wellbeing": 40013, "\u0120Lau": 40014, "anos": 40015, "\u0120unmist": 40016, "\u0120macOS": 40017, "\u0120restroom": 40018, "\u0120Oliv": 40019, "\u0120Airways": 40020, "\u0120timetable": 40021, "980": 40022, "\u0120radios": 40023, "voy": 40024, "iasco": 40025, "\u0120cloudy": 40026, "\u0120Drawing": 40027, "Anything": 40028, "Syria": 40029, "\u0120Hert": 40030, "staking": 40031, "\u0120unchecked": 40032, "\u0120brazen": 40033, "\u0120NRS": 40034, "697": 40035, "onomic": 40036, "establish": 40037, "\u0120leng": 40038, "\u0120diagonal": 40039, "\u0120Fior": 40040, "Lair": 40041, "\u0120Stard": 40042, "\u0120deficient": 40043, "joining": 40044, "beam": 40045, "\u0120omnip": 40046, "\u0120blender": 40047, "\u0120sunrise": 40048, "Moore": 40049, "\u0120Fault": 40050, "\u0120Costume": 40051, "\u0120Mub": 40052, "Flags": 40053, "anse": 40054, "\u0120payout": 40055, "\u0120Governors": 40056, "\u0120Dillon": 40057, "\u0120Banana": 40058, "Nar": 40059, "\u0120trailed": 40060, "\u0120imperialist": 40061, "umann": 40062, "atsuki": 40063, "435": 40064, "\u0120Roads": 40065, "\u0120slur": 40066, "\u0120Ideally": 40067, "\u0120trenches": 40068, "Ctrl": 40069, "\u0120mirrored": 40070, "\u0120Zel": 40071, "\u0120Crest": 40072, "Compat": 40073, "\u0120Rolls": 40074, "scrib": 40075, "\u0120Trails": 40076, "ometers": 40077, "winter": 40078, "\u0120immortality": 40079, "ilated": 40080, "\u0120contradicts": 40081, "universal": 40082, "illions": 40083, "\u0120Mama": 40084, "optim": 40085, "ATURE": 40086, "\u0120geo": 40087, "etter": 40088, "\u0120Carlo": 40089, "424": 40090, "\u0120canonical": 40091, "\u0120Stronghold": 40092, "near": 40093, "\u0120perfume": 40094, "\u0120orchestra": 40095, "odiac": 40096, "\u0120uphe": 40097, "\u0120reigning": 40098, "versive": 40099, "\u0120caucuses": 40100, "\u0120DEM": 40101, "\u0120insulted": 40102, "\u0120------": 40103, "\u0120Crush": 40104, "\u0120rooting": 40105, "\u0120Wraith": 40106, "\u0120whore": 40107, "\u0120tofu": 40108, "Cmd": 40109, "\u0120Bree": 40110, "\u0120$_": 40111, "\u0120rive": 40112, "\u0120Advertising": 40113, "\u0120watt": 40114, "\u0120HO": 40115, "\u0120persuasive": 40116, "\u0120Parameters": 40117, "\u0120observational": 40118, "\u0120NCT": 40119, "\u0120Moj": 40120, "\u0120Salon": 40121, "\u0120trunc": 40122, "\u0120exquisite": 40123, "\u0120Mara": 40124, "\u0120poop": 40125, "\u0120ANN": 40126, "Exc": 40127, "\u0120Wonderful": 40128, "\u0120Taco": 40129, "\u0120homeowner": 40130, "\u0120Smithsonian": 40131, "orporated": 40132, "mmmm": 40133, "\u0120loaf": 40134, "\u0120Yamato": 40135, "\u0120Indo": 40136, "\u0120clinging": 40137, "\u00c3\u00a1s": 40138, "\u0120immutable": 40139, "hub": 40140, "Orange": 40141, "\u0120fingertips": 40142, "\u0120Wooden": 40143, "\u0120Kidd": 40144, "\u0120JPM": 40145, "\u0120Damn": 40146, "Cow": 40147, "codes": 40148, "482": 40149, "\u0120initiating": 40150, "\u0120Elk": 40151, "\u0120Cutting": 40152, "\u0120absentee": 40153, "\u0120Vance": 40154, "\u0120Lilith": 40155, "GUI": 40156, "\u0120obscured": 40157, "\u0120dwarves": 40158, "\u0120Chop": 40159, "\u0120Boko": 40160, "Values": 40161, "\u0120multimedia": 40162, "\u0120brewed": 40163, "Regular": 40164, "CRIPTION": 40165, "\u0120Mortal": 40166, "\u0120apex": 40167, "\u0120traveler": 40168, "\u0120boils": 40169, "\u0120spraying": 40170, "Represent": 40171, "\u0120Starship": 40172, "428": 40173, "\u0120disapproval": 40174, "\u0120shadowy": 40175, "\u0120lamented": 40176, "\u0120Replace": 40177, "\u0120Fran\u00c3\u00a7": 40178, "677": 40179, "dor": 40180, "\u0120unstoppable": 40181, "\u0120cohorts": 40182, "gyn": 40183, "\u0120Classics": 40184, "\u0120Amph": 40185, "\u0120sluggish": 40186, "\u0120Addiction": 40187, "\u0120Padres": 40188, "\u0120inscription": 40189, "\u0120inhuman": 40190, "minus": 40191, "\u0120Jeremiah": 40192, "atars": 40193, "Terror": 40194, "\u0120Tos": 40195, "\u0120Sharma": 40196, "asta": 40197, "catch": 40198, "\u0120plumbing": 40199, "\u0120Timbers": 40200, "Shar": 40201, "Hal": 40202, "\u0120Osc": 40203, "\u0120coupling": 40204, "humans": 40205, "\u0120sponge": 40206, "\u0120idols": 40207, "\u0120Spa": 40208, "\u0120Advocate": 40209, "\u0120Beats": 40210, "lua": 40211, "\u0120ticking": 40212, "\u0120loader": 40213, "\u0120Gron": 40214, "810": 40215, "\u0120stimulated": 40216, "\u0120sidebar": 40217, "\u0120Manufacturer": 40218, "oreAnd": 40219, "1973": 40220, "\u0120praises": 40221, "\u0120Flores": 40222, "disable": 40223, "\u0120Electrical": 40224, "raise": 40225, "Eth": 40226, "\u0120migrated": 40227, "\u0120lecturer": 40228, "Kids": 40229, "\u0120Cavern": 40230, "\u0120kettle": 40231, "\u0120glyc": 40232, "\u0120Mandela": 40233, "\u0120Fully": 40234, "\u00e5\u00a7\u00ab": 40235, "FINEST": 40236, "\u0120squeezing": 40237, "\u0120Ryder": 40238, "ampoo": 40239, "oreAndOnline": 40240, "InstoreAndOnline": 40241, "BuyableInstoreAndOnline": 40242, "\u0120commemorate": 40243, "\u0120Rampage": 40244, "Austin": 40245, "\u0120Shroud": 40246, "\u0120Ruins": 40247, "915": 40248, "\u0120KH": 40249, "\u0120waterfront": 40250, "\u0120ESC": 40251, "baby": 40252, "\u0120Cout": 40253, "\u0120Emblem": 40254, "\u0120equivalents": 40255, "492": 40256, "Unique": 40257, "\u0120Nietzsche": 40258, "browser": 40259, "\u0120imitation": 40260, "\u0120Werewolf": 40261, "\u0120Kirin": 40262, "acas": 40263, "',\"": 40264, "\u0120\u00c3\u00be": 40265, "Reviewed": 40266, "\u0120cunt": 40267, "\u0120voic": 40268, "\u0120Lenovo": 40269, "\u0120bonded": 40270, "481": 40271, "\u0120inhibitors": 40272, "\u0120endeavors": 40273, "\u0120Havana": 40274, "\u0120Stout": 40275, "\u0120Jolly": 40276, "Actor": 40277, "*/(": 40278, "\u0120occurrences": 40279, "\u0120Tens": 40280, "Increased": 40281, "\u0120ACTION": 40282, "\u0120\u00e3\u0122\u012e": 40283, "\u0120Rankings": 40284, "\u0120Breat": 40285, "\u0120309": 40286, "Dou": 40287, "\u0120impacting": 40288, "\u0120Duchess": 40289, "prefix": 40290, "QB": 40291, "\u0120summoning": 40292, "\u0120bestowed": 40293, "\u0120Kepler": 40294, "\u0120POWER": 40295, "cube": 40296, "\u0120Kits": 40297, "\u0120Grip": 40298, "\u0120opium": 40299, "\u0120reputable": 40300, "toc": 40301, "ichael": 40302, "\u0120Ripple": 40303, "\u0120caf\u00c3\u00a9": 40304, "\u0120Zoom": 40305, "\u0120Burma": 40306, "\u0120waive": 40307, "\u0120stalls": 40308, "\u0120demeanor": 40309, "incerity": 40310, "\u0120fluoride": 40311, "\u0120SHOULD": 40312, "Paris": 40313, "\u0120longing": 40314, "\u0120plat": 40315, "\u0120grossly": 40316, "\u0120bulls": 40317, "\u0120showcasing": 40318, "expected": 40319, "\u0120Gaddafi": 40320, "engineering": 40321, "Repeat": 40322, "\u0120Kut": 40323, "\u0120conceivable": 40324, "\u0120trimmed": 40325, "oscope": 40326, "\u0120Candidate": 40327, "\u0120Tears": 40328, "rolog": 40329, "Lewis": 40330, "SUP": 40331, "\u0120roadmap": 40332, "\u0120saliva": 40333, "\u0120trumpet": 40334, "Jimmy": 40335, "\u0120miraculous": 40336, "\u0120colonization": 40337, "\u0120amput": 40338, "\u0120GNOME": 40339, "atech": 40340, "Different": 40341, "\u0120ELE": 40342, "\u0120Governments": 40343, "\u0120Ahead": 40344, "\u00e3\u0127\u012d\u00e3\u0127\u012d": 40345, "wordpress": 40346, "LIB": 40347, "\u0120Include": 40348, "\u0120Dorothy": 40349, "045": 40350, "\u0120Colombian": 40351, "\u0120leased": 40352, "884": 40353, "\u0120degrading": 40354, "\u0120Daisy": 40355, "iations": 40356, "\u0120baptized": 40357, "\u0120surname": 40358, "cox": 40359, "\u0120blinked": 40360, "\u00e3\u0125\u00a2": 40361, "\u0120pollen": 40362, "\u0120dermat": 40363, "\u0120regex": 40364, "\u0120Nicholson": 40365, "\u0120Eater": 40366, "\u00e7\u013e": 40367, "rador": 40368, "\u0120narrower": 40369, "\u0120hurricanes": 40370, "\u0120hallucinations": 40371, "ridden": 40372, "ISSION": 40373, "\u0120Firefly": 40374, "\u0120attainment": 40375, "\u0120nominate": 40376, "\u0120avocado": 40377, "\u0120Meredith": 40378, "\u0120ts": 40379, "\u0120reverence": 40380, "\u0120euph": 40381, "\u0120crates": 40382, "\u0120TEXT": 40383, "\u0120443": 40384, "\u0120319": 40385, "JSON": 40386, "iquette": 40387, "\u0120shortstop": 40388, "ickey": 40389, "\u0120propelled": 40390, "\u0120api": 40391, "\u0120Thieves": 40392, "779": 40393, "\u0120oversaw": 40394, "\u0120coli": 40395, "\u0120Nicola": 40396, "\u0120overcl": 40397, "ikawa": 40398, "\u0120Cyr": 40399, "\u0120384": 40400, "789": 40401, "\u0120Allows": 40402, "1027": 40403, "Detroit": 40404, "TRY": 40405, "setup": 40406, "\u0120Socialism": 40407, "Soviet": 40408, "susp": 40409, "\u0120APR": 40410, "\u0120Shutdown": 40411, "\u0120aluminium": 40412, "zbek": 40413, "\u0120Lover": 40414, "GGGGGGGG": 40415, "\u0120democracies": 40416, "\u01201908": 40417, "\u0120Merrill": 40418, "\u0120Francois": 40419, "gdala": 40420, "\u0120traffickers": 40421, "\u0120Til": 40422, "\u0120Goat": 40423, "\u0120sped": 40424, "\u0120Reserv": 40425, "\u0120prod": 40426, "552": 40427, "\u0120cac": 40428, "\u0120Univ": 40429, "\u0120Schwe": 40430, "\u0120swirling": 40431, "\u0120Wilderness": 40432, "\u0120Eggs": 40433, "\u0120saddened": 40434, "\u0120archaic": 40435, "Hyd": 40436, "\u0120excessively": 40437, "BRE": 40438, "\u0120aerospace": 40439, "\u0120Voices": 40440, "Craig": 40441, "\u0120ignited": 40442, "Initially": 40443, "\u0120McA": 40444, "\u0120handset": 40445, "\u0120reforming": 40446, "\u0120frustrations": 40447, "\u0120Deadpool": 40448, "\u0120Belichick": 40449, "ractor": 40450, "\u0120Ragnarok": 40451, "\u0120Drupal": 40452, "\u0120Approximately": 40453, "1920": 40454, "\u0120Hubble": 40455, "armor": 40456, "\u0120Saras": 40457, "\u0120Jonas": 40458, "\u0120nostalgic": 40459, "\u0120feasibility": 40460, "Saharan": 40461, "\u0120orbiting": 40462, "\u0120970": 40463, "Ru": 40464, "\u0120shin": 40465, "\u0120Investigators": 40466, "\u0120inconsistencies": 40467, "\u0120PAN": 40468, "BG": 40469, "\u0120grazing": 40470, "\u0120detectors": 40471, "\u0120Startup": 40472, "\u0120Funny": 40473, "\u0120Naomi": 40474, "Considering": 40475, "\u0120hog": 40476, "utf": 40477, "cemic": 40478, "\u0120fortified": 40479, "\u0120Functions": 40480, "\u0120codec": 40481, "nutrition": 40482, "Hat": 40483, "\"!": 40484, "microsoft": 40485, "558": 40486, "\u0120Thin": 40487, "\u0120ACE": 40488, "Alias": 40489, "\u0120OPS": 40490, "papers": 40491, "PK": 40492, "\u00e3\u0122\u0130": 40493, "\u0120improbable": 40494, "Northern": 40495, "equal": 40496, "\u0120lookout": 40497, "\u0120tyres": 40498, "\u0120Modified": 40499, "\u0120Kop": 40500, "Absolutely": 40501, "\u0120buildup": 40502, "silver": 40503, "\u0120audi": 40504, "\u0120grotesque": 40505, "\u0120Saber": 40506, "\u0120Presbyter": 40507, "ONY": 40508, "\u0120glaciers": 40509, "\u0120Shoals": 40510, "\u0120Kass": 40511, "\u0120HRC": 40512, "\u0120Nicol": 40513, "\u0120Lunch": 40514, "\u0120Foss": 40515, "\u00e2\u0138\u0134": 40516, "ADRA": 40517, "\u0120OnePlus": 40518, "oing": 40519, "grounds": 40520, "\u0120incidental": 40521, "\u0120datasets": 40522, "689": 40523, "\u0120Clarkson": 40524, "\u0120assembling": 40525, "\u0120Corrections": 40526, "\u0120drinkers": 40527, "\u0120qualifiers": 40528, "\u0120leash": 40529, "\u0120unfounded": 40530, "\u0120Hundred": 40531, "\u0120kickoff": 40532, "Ti": 40533, "\u0120reconcil": 40534, "\u0120Grants": 40535, "\u0120Compliance": 40536, "\u0120Dexterity": 40537, "\u01201906": 40538, "warn": 40539, "Dallas": 40540, "Maximum": 40541, "nard": 40542, "avia": 40543, "beaut": 40544, "ensitivity": 40545, "trace": 40546, "\u0120pioneers": 40547, "\u0120Fract": 40548, "\u00e3\u0122\u0131": 40549, "\u0120precept": 40550, "\u0120glossy": 40551, "\u0120IEEE": 40552, "Across": 40553, "\u0120680": 40554, "Sleep": 40555, "cheon": 40556, "\u0120satirical": 40557, "\u0120Minotaur": 40558, "\u0120Claude": 40559, "\u0120r\u00c3\u00a9": 40560, "apego": 40561, "\u0120carrot": 40562, "\u0120Semin": 40563, "inoa": 40564, "\u0120zo": 40565, "Independent": 40566, "\u0120diagnoses": 40567, "\u0120Cue": 40568, "MAR": 40569, "\u0120rendition": 40570, "\u0120Kik": 40571, "\u0120pathology": 40572, "\u0120selects": 40573, "LinkedIn": 40574, "\u0120assay": 40575, "\u0120Dres": 40576, "\u0120textual": 40577, "posted": 40578, "ITAL": 40579, "\u0120Maul": 40580, "Neal": 40581, "\u0120interconnected": 40582, "\u0120erratic": 40583, "\u0120Virus": 40584, "\u0120530": 40585, "\u0120environmentalists": 40586, "\u0120Phelps": 40587, "\u0120engagements": 40588, "\u0120INST": 40589, "\u0120economical": 40590, "noxious": 40591, "\u0120gearing": 40592, "izzy": 40593, "\u0120favorably": 40594, "\u0120McGill": 40595, "Term": 40596, "\u0120hanged": 40597, "\u0120ballpark": 40598, "\u0120Reyes": 40599, "\u0120beware": 40600, "\u0120Psal": 40601, "\u0120Massacre": 40602, "qi": 40603, "\u0120inaccessible": 40604, "aclysm": 40605, "\u0120fray": 40606, "illac": 40607, "\u0120bitterly": 40608, "\u0120Certification": 40609, "Michigan": 40610, "\u0120irrespective": 40611, "alore": 40612, "Empty": 40613, "\u0120endorsements": 40614, "\u0120undet": 40615, "fg": 40616, "equipped": 40617, "\u0120merciless": 40618, "\u0120Cust": 40619, "\u0120immature": 40620, "\u0120voucher": 40621, "\u0120Blackwell": 40622, "\u00d1\u0131": 40623, "hawk": 40624, "disciplinary": 40625, "ilee": 40626, "\u0120Makoto": 40627, "\u0120Dude": 40628, "\u00e3\u0125\u0129\u00e3\u0124\u00a3": 40629, "Years": 40630, "\u0120inver": 40631, "\u0120shaman": 40632, "\u0120Yong": 40633, "ipel": 40634, "ellen": 40635, "\u0120Cathy": 40636, "brids": 40637, "\u0120sarc": 40638, "651": 40639, "Near": 40640, "\u0120groundwork": 40641, "\u0120amaz": 40642, "\u0120415": 40643, "\u0120Huntington": 40644, "hews": 40645, "\u0120Bung": 40646, "\u0120arbitrarily": 40647, "\u0120Wit": 40648, "\u0120Alberto": 40649, "\u0120disqualified": 40650, "bestos": 40651, "461": 40652, "\u0120pc": 40653, "\u0120284": 40654, "robat": 40655, "Robin": 40656, "\u0120hugs": 40657, "\u0120Transition": 40658, "\u0120Occasionally": 40659, "\u0120326": 40660, "\u0120Whilst": 40661, "\u0120Ley": 40662, "\u0120spaceship": 40663, "csv": 40664, "\u0120unsuccessfully": 40665, "\u0120Au": 40666, "leck": 40667, "\u0120Winged": 40668, "\u0120Grizzlies": 40669, ".\u00ef\u00bf\u00bd": 40670, "\u0120nearer": 40671, "\u0120Sorceress": 40672, "\u0120Indigo": 40673, "Else": 40674, "840": 40675, "letes": 40676, "Coach": 40677, "\u0120upbringing": 40678, "\u0120Kes": 40679, "\u0120separatist": 40680, "\u0120racists": 40681, "\u0120chained": 40682, "\u0120abstinence": 40683, "learning": 40684, "\u0120reinstated": 40685, "\u0120symmetry": 40686, "\u0120reminders": 40687, "\u0120Chevy": 40688, "\u0120mont": 40689, "\u0120exemplary": 40690, "\u0120TOR": 40691, "ZX": 40692, "\u0120qualitative": 40693, "\u0120Stamp": 40694, "\u0120Savannah": 40695, "\u0120Rossi": 40696, "\u0120paed": 40697, "\u0120dispensaries": 40698, "\u0120Walls": 40699, "\u0120Chronic": 40700, "\u0120complimentary": 40701, "\u0120Beirut": 40702, "\u0120+---": 40703, "igslist": 40704, "\u0120cryptographic": 40705, "masters": 40706, "\u0120Capitals": 40707, "\u0120maximal": 40708, "\u0120entropy": 40709, "Points": 40710, "\u0120combatants": 40711, "lip": 40712, "\u0120Glob": 40713, "\u0120BMC": 40714, "phase": 40715, "thank": 40716, "HTTP": 40717, "\u0120commuter": 40718, "\u0120\\(\\": 40719, "../": 40720, "\u0120Regener": 40721, "\u0120DOI": 40722, "\u0120Activision": 40723, "\u0120slit": 40724, "osal": 40725, "REM": 40726, "\u0120chants": 40727, "Yu": 40728, "Keys": 40729, "Brexit": 40730, "\u0120Forced": 40731, "Arizona": 40732, "\u0120squadron": 40733, "ISO": 40734, "\u0120Malone": 40735, "\u0120338": 40736, "\u0120contrasting": 40737, "\u0120tidal": 40738, "\u0120libel": 40739, "\u0120implanted": 40740, "\u0120uproar": 40741, "\u0120Cater": 40742, "\u0120propositions": 40743, "Manchester": 40744, "\u0120Euros": 40745, "itamin": 40746, "Gil": 40747, "\u0120Elven": 40748, "\u0120Seek": 40749, "\u0120Bai": 40750, "\u0120redevelopment": 40751, "\u0120Towns": 40752, "\u0120Lub": 40753, "!\",": 40754, "alon": 40755, "Krist": 40756, "\u0120measurable": 40757, "\u0120imaginable": 40758, "\u0120apostles": 40759, "YN": 40760, "760": 40761, "\u0120steroid": 40762, "\u0120specificity": 40763, "\u0120Located": 40764, "\u0120Becker": 40765, "\u0120Edu": 40766, "\u0120Dietary": 40767, "utsch": 40768, "\u0120Marilyn": 40769, "\u0120blister": 40770, "\u0120MEP": 40771, "\u0120Koz": 40772, "\u0120CMS": 40773, "yahoo": 40774, "\u0120Carney": 40775, "\u0120boasting": 40776, "\u0120Caleb": 40777, "Byte": 40778, "reads": 40779, "aden": 40780, "Problem": 40781, "\u0120Woodward": 40782, "Swe": 40783, "Sup": 40784, "\u0120KGB": 40785, "Setup": 40786, "\u0120tacit": 40787, "\u0120retribution": 40788, "\u0120dues": 40789, "\u0120M\u00c3\u00bc": 40790, ".?": 40791, "\u00e4\u00b8\u0143": 40792, "pots": 40793, "\u0120cameo": 40794, "\u0120PAL": 40795, "education": 40796, "Amy": 40797, "likely": 40798, "gling": 40799, "\u0120constitutionally": 40800, "\u0120Hamm": 40801, "\u0120Speak": 40802, "\u0120widgets": 40803, "brate": 40804, "\u0120crappy": 40805, "\u0120Iter": 40806, "\u0120anticipating": 40807, "\u0120Bout": 40808, "Pixel": 40809, "\u0120Yep": 40810, "\u0120Laurie": 40811, "\u0120hut": 40812, "\u0120bulletin": 40813, "\u0120Salvation": 40814, "\u0120chats": 40815, "earable": 40816, "Honestly": 40817, "ALTH": 40818, "onsequ": 40819, "cult": 40820, "iscovery": 40821, "ovych": 40822, "\u0120selves": 40823, "\u0120Satoshi": 40824, "Sounds": 40825, "\u0120convergence": 40826, "\u0120Rosenberg": 40827, "1974": 40828, "\u0120nasal": 40829, "\u0120fullest": 40830, "\u0120ferocious": 40831, "xus": 40832, "iste": 40833, "AMS": 40834, "\u0120lobbied": 40835, "\u0120soothing": 40836, "\u0120Gunn": 40837, "today": 40838, "024": 40839, "\u0120inspirational": 40840, "\u0120NBN": 40841, "pb": 40842, "gewater": 40843, "orah": 40844, "allowed": 40845, "\u0120Coliseum": 40846, "\u0120specializing": 40847, "\u0120insanely": 40848, "\u0120Tape": 40849, "delay": 40850, "\u0120tarn": 40851, "\u0120Pound": 40852, "\u0120melanch": 40853, "\u0120deployments": 40854, "iland": 40855, "\u0120lessen": 40856, "\u0120furry": 40857, "\u0120UEFA": 40858, "\u0120bloodshed": 40859, "\u0120Meier": 40860, "ithering": 40861, "\u0120heirs": 40862, "\u0120Jaw": 40863, "axter": 40864, "\u0120Publications": 40865, "\u0120alters": 40866, "intention": 40867, "\u0120Winchester": 40868, "determination": 40869, "\u0120Lifetime": 40870, "thin": 40871, "Monster": 40872, "780": 40873, "\u0120approximation": 40874, "\u0120supermarkets": 40875, "\u0120Seconds": 40876, "oros": 40877, "huge": 40878, "\u0120bribe": 40879, "\u0120LIMITED": 40880, "uned": 40881, "\u0120misinterpret": 40882, "\u0120Injury": 40883, "\u0120367": 40884, "\u0120thresholds": 40885, "\u0120Carnival": 40886, "\u0120gastrointestinal": 40887, "\u0120guideline": 40888, "\u0120deceived": 40889, "features": 40890, "\u0120purportedly": 40891, "\u0120Ronnie": 40892, "\u0120Newt": 40893, "\u0120spacious": 40894, "asus": 40895, "\u0120superheroes": 40896, "\u0120Cynthia": 40897, "legged": 40898, "kamp": 40899, "chio": 40900, "\u0120thumbnail": 40901, "\u0120Shirley": 40902, "illation": 40903, "\u0120sheds": 40904, "\u0120Zy": 40905, "EPA": 40906, "\u0120dams": 40907, "\u0120yawn": 40908, "nah": 40909, "\u0120Peggy": 40910, "\u0120Erie": 40911, "\u0120Juventus": 40912, "\u0120Fountain": 40913, "rx": 40914, "donald": 40915, "album": 40916, "\u0120Comprehensive": 40917, "\u0120caching": 40918, "\u0120Uz": 40919, "ulnerability": 40920, "\u0120Principle": 40921, "\u0120Jian": 40922, "ingers": 40923, "casts": 40924, "\u0120Osiris": 40925, "chart": 40926, "tile": 40927, "\u0120Tiffany": 40928, "\u0120Patton": 40929, "\u0120Whip": 40930, "\u0120oversized": 40931, "Je": 40932, "\u0120Cinderella": 40933, "\u0120Borders": 40934, "\u0120Daesh": 40935, "Mah": 40936, "\u0120dogma": 40937, "\u0120communists": 40938, "vu": 40939, "Council": 40940, "\u0120freshwater": 40941, "\u0120wounding": 40942, "\u0120debacle": 40943, "\u0120youngster": 40944, "\u0120threaded": 40945, "\u0120Bots": 40946, "\u0120Savings": 40947, "\u00e3\u0123\u0124": 40948, "oling": 40949, "oho": 40950, "\u0120illumination": 40951, "MRI": 40952, "\u0120loosen": 40953, "trump": 40954, "agency": 40955, "urion": 40956, "\u0120momentarily": 40957, "\u0120Chun": 40958, "\u0120Budapest": 40959, "\u0120Alley": 40960, "Disk": 40961, "\u0120astonished": 40962, "\u0120Conquer": 40963, "\u0120Accounting": 40964, "having": 40965, "\u0120Wein": 40966, "\u0120Alright": 40967, "\u0120revolver": 40968, "\u0120delusion": 40969, "\u0120relics": 40970, "\u0120adherent": 40971, "quant": 40972, "\u0120handmade": 40973, "orio": 40974, "\u0120combating": 40975, "coded": 40976, "\u0120quadru": 40977, "reth": 40978, "Nik": 40979, "\u0120Tribal": 40980, "\u0120Mysterious": 40981, "\u0120inhal": 40982, "\u0120Winning": 40983, "\u0120Classification": 40984, "changed": 40985, "\u0120unab": 40986, "\u0120scorn": 40987, "icipated": 40988, "wl": 40989, "onductor": 40990, "\u0120reinforcing": 40991, "\u0120Childhood": 40992, "anova": 40993, "\u0120adventurer": 40994, "\u0120doctoral": 40995, "\u0120Strategies": 40996, "\u0120engulfed": 40997, "\u0120Encounter": 40998, "\u0120lashes": 40999, "Critical": 41000, "ricular": 41001, "\u0120UTF": 41002, "ociation": 41003, "checking": 41004, "\u0120Consulting": 41005, "Runtime": 41006, "period": 41007, "\u0120Asgard": 41008, "\u0120distilled": 41009, "\u0120Pasadena": 41010, "\u0120Dying": 41011, "\u0120COUNTY": 41012, "\u0120granite": 41013, "\u0120smack": 41014, "\u0120parachute": 41015, "\u0120SUR": 41016, "Virginia": 41017, "\u0120Furious": 41018, "787": 41019, "\u0120Okin": 41020, "\u0120camel": 41021, "\u0120Mbps": 41022, "1972": 41023, "\u0120Chao": 41024, "\u0120Cyan": 41025, "joice": 41026, "efer": 41027, "\u0120Wrap": 41028, "\u0120Debate": 41029, "Seg": 41030, "\u0120forearm": 41031, "\u0120Ignore": 41032, "\u0120timestamp": 41033, "\u0120probing": 41034, "\u0120Noon": 41035, "\u0120Grail": 41036, "fen": 41037, "\u0120dormant": 41038, "\u0120Firstly": 41039, "\u0120Eighth": 41040, "\u0120HUN": 41041, "\u0120Desire": 41042, "oras": 41043, "Girls": 41044, "\u0120Desmond": 41045, "zar": 41046, "amines": 41047, "OAD": 41048, "execute": 41049, "\u0120boobs": 41050, "\u0120ATL": 41051, "_(": 41052, "Chelsea": 41053, "\u0120masturbation": 41054, "\u0120CoC": 41055, "\u0120destroyer": 41056, "\u0120Chomsky": 41057, "\u0120scatter": 41058, "\u0120Assets": 41059, "796": 41060, "\u0120Cargo": 41061, "\u0120receptive": 41062, "\u0120Scope": 41063, "\u0120marketers": 41064, "\u0120launchers": 41065, "\u0120axle": 41066, "\u0120SEA": 41067, "seq": 41068, "\u0120Moff": 41069, "finding": 41070, "\u0120Gibbs": 41071, "Georgia": 41072, "extremely": 41073, "NJ": 41074, "\u0120laborers": 41075, "stals": 41076, "\u0120mediation": 41077, "\u0120Hedge": 41078, "atown": 41079, "\u0120iod": 41080, "despite": 41081, "vill": 41082, "Jane": 41083, "existence": 41084, "\u0120coincided": 41085, "\u0120Utilities": 41086, "\u0120Cheap": 41087, "\u0120logistical": 41088, "\u0120culmination": 41089, "\u0120Nicotine": 41090, "pak": 41091, "Folder": 41092, "\u0120rodents": 41093, "stuff": 41094, "\u0120lawfully": 41095, "\u0120reperto": 41096, "ioch": 41097, "jj": 41098, "Dialogue": 41099, "HHHH": 41100, "liction": 41101, "Looks": 41102, "\u0120297": 41103, "\u0120turrets": 41104, "\u0120Abandon": 41105, "\u0120incess": 41106, "\u0120Trafford": 41107, "\u0120curled": 41108, "\u0120preferring": 41109, "\u0120privatization": 41110, "\u0120irresist": 41111, "\u0120Panda": 41112, "\u0120Shake": 41113, "\u0120McGr": 41114, "\u00e3\u0125\u0126": 41115, "unders": 41116, "\u0120discriminated": 41117, "\u0120bartender": 41118, "ILE": 41119, "Atlantic": 41120, "\u0120propensity": 41121, "\u0120Wiz": 41122, "\u0120Gim": 41123, "conference": 41124, "\u0120reinforces": 41125, "Gh": 41126, "wagon": 41127, "\u0120eerie": 41128, "Fal": 41129, "\u0120hugged": 41130, "racist": 41131, "RIC": 41132, "Fu": 41133, "\u0120filler": 41134, "\u0120Stub": 41135, "\u0120engraved": 41136, "\u0120Wrestle": 41137, "\u0120imaginative": 41138, "\u0120Peer": 41139, "\u0120Factors": 41140, "anus": 41141, "\u0120Dracula": 41142, "monitor": 41143, "\u0120routers": 41144, "ibia": 41145, "\u0120Boolean": 41146, "endale": 41147, "\u0120Slaughter": 41148, "\u0120Shack": 41149, "RFC": 41150, "\u0120Spielberg": 41151, "Sax": 41152, "\u0120PHOTO": 41153, "\u0120Clover": 41154, "\u0120Rae": 41155, "Depending": 41156, "\u0120Memor": 41157, "aram": 41158, "\u0120pierced": 41159, "\u0120curtains": 41160, "vale": 41161, "\u0120Inquisition": 41162, "\u0120Poke": 41163, "\u0120forecasting": 41164, "\u0120complains": 41165, "Sense": 41166, "\u0120Hermes": 41167, "iscovered": 41168, "\u0120bible": 41169, "\u0120Morph": 41170, "\u0120germ": 41171, "785": 41172, "DON": 41173, "\u0120congen": 41174, "\u0120crane": 41175, "\u0120DPR": 41176, "\u0120respectfully": 41177, "Room": 41178, "\u0120Naw": 41179, "\u0120Dalai": 41180, "reason": 41181, "\u0120Angus": 41182, "Education": 41183, "\u0120Titanic": 41184, "\u00cb\u013e": 41185, "\u0120oval": 41186, "united": 41187, "\u0120thirds": 41188, "\u0120moistur": 41189, "\u0120CPC": 41190, "Miami": 41191, "\u0120tentacles": 41192, "\u0120Polaris": 41193, "exc": 41194, "exclusive": 41195, "\u0120Prairie": 41196, "\u0120colossal": 41197, "\u0120Blend": 41198, "surprisingly": 41199, "\u00c3\u0143s": 41200, "\u0120indoctr": 41201, "\u0120basal": 41202, "\u0120MPEG": 41203, "undo": 41204, "Split": 41205, "Development": 41206, "\u0120lantern": 41207, "1971": 41208, "\u0120provocation": 41209, "\u0120anguish": 41210, "\u0120Bind": 41211, "\u0120Leia": 41212, "ducers": 41213, "ippy": 41214, "conservancy": 41215, "\u0120initialize": 41216, "\u0120Twice": 41217, "\u0120Suk": 41218, "\u0120predic": 41219, "\u0120diploma": 41220, "\u0120sociop": 41221, "Ingredients": 41222, "\u0120hammered": 41223, "\u0120Irma": 41224, "Qaida": 41225, "\u0120glimps": 41226, "\u0120Bian": 41227, "\u0120stacking": 41228, "\u0120fend": 41229, "govtrack": 41230, "\u0120unn": 41231, "democratic": 41232, "igree": 41233, "\u0120580": 41234, "\u0120294": 41235, "\u0120strawberry": 41236, "IDER": 41237, "\u0120cherished": 41238, "\u0120Hots": 41239, "\u0120inferred": 41240, "\u0120808": 41241, "\u0120Socrates": 41242, "Oregon": 41243, "\u0120Roses": 41244, "\u0120FOIA": 41245, "\u0120insensitive": 41246, "\u0120408": 41247, "Recommend": 41248, "\u0120Shine": 41249, "\u0120painstaking": 41250, "UGE": 41251, "\u0120Heller": 41252, "\u0120Enterprises": 41253, "IOR": 41254, "adj": 41255, "NRS": 41256, "LG": 41257, "\u0120alienated": 41258, "\u0120acknowledgement": 41259, "\u0120AUD": 41260, "\u0120Reneg": 41261, "\u0120vouchers": 41262, "\u0120960": 41263, "\u0120moot": 41264, "\u0120Dimensions": 41265, "\u0120cabbage": 41266, "Bright": 41267, "gat": 41268, "\u0120Klu": 41269, "\u0120latent": 41270, "\u0120ze": 41271, "\u0120Meng": 41272, "\u0120disperse": 41273, "\u0120pandemonium": 41274, "HQ": 41275, "\u0120virtuous": 41276, "\u0120Locations": 41277, "eeper": 41278, "provided": 41279, "\u0120seams": 41280, "\u0120WT": 41281, "izo": 41282, "PROV": 41283, "\u0120titanium": 41284, "\u0120recollection": 41285, "\u0120cran": 41286, "\u0120780": 41287, "\u0120NF": 41288, "491": 41289, "642": 41290, "packing": 41291, "598": 41292, "texture": 41293, "Spider": 41294, "freedom": 41295, "cipled": 41296, "\u0120TAMADRA": 41297, "\u00e2\u013b\u00a6": 41298, "authent": 41299, "\u0120WANT": 41300, "rified": 41301, "\u0120rites": 41302, "\u0120uterus": 41303, "kiss": 41304, "\u0120\u00e2\u012b\u00a4": 41305, "\u0120skillet": 41306, "\u0120disenfranch": 41307, "\u0120Gaal": 41308, "Compan": 41309, "\u0120ageing": 41310, "guide": 41311, "Balt": 41312, "\u0120iterator": 41313, "\u0120discretionary": 41314, "tips": 41315, "\u0120primates": 41316, "\u0120Technique": 41317, "\u0120Payments": 41318, "azel": 41319, "\u0120ROCK": 41320, "stantial": 41321, "060": 41322, "\u0120dmg": 41323, "\u0120Jackets": 41324, "\u0120Playoff": 41325, "\u0120nursery": 41326, "\u0120Symb": 41327, "arton": 41328, "\u0120annexation": 41329, "Colorado": 41330, "\u0120coils": 41331, "\u0120Shoes": 41332, "\u00e2\u0126\u00a2:": 41333, "\u0120Roz": 41334, "COMPLE": 41335, "\u0120Everest": 41336, "\u0120Triumph": 41337, "Joy": 41338, "Grid": 41339, "\u00e0\u00bc": 41340, "processor": 41341, "\u0120Prosper": 41342, "\u0120Severus": 41343, "\u0120Selected": 41344, "rg": 41345, "\u0120Tayyip": 41346, "Stra": 41347, "\u0120skiing": 41348, "\u0120?)": 41349, "\u0120peg": 41350, "Tesla": 41351, "\u0120timeframe": 41352, "\u0120mastermind": 41353, "\u0120NB": 41354, "scientific": 41355, "\u0120Shit": 41356, "generic": 41357, "INTER": 41358, "NUM": 41359, "\u0120stroll": 41360, "\u0120Enix": 41361, "\u0120MMR": 41362, "\u0120EMS": 41363, "movie": 41364, "\u0124\u00aa": 41365, "\u0120minimizing": 41366, "iddling": 41367, "\u0120illegitimate": 41368, "\u0120prototyp": 41369, "\u0120prematurely": 41370, "\u0120manuals": 41371, "obbies": 41372, "\u0120Cassidy": 41373, "DEC": 41374, "desktop": 41375, "\u0120aeros": 41376, "\u0120screenings": 41377, "\u0120debilitating": 41378, "\u0120Grind": 41379, "natureconservancy": 41380, "\u0120fades": 41381, "termination": 41382, "assetsadobe": 41383, "Factor": 41384, "\u0120definitively": 41385, "Pok\u00c3\u00a9": 41386, "apult": 41387, "\u0120Lafayette": 41388, "Corn": 41389, "\u0120Coral": 41390, "\u0120stagnant": 41391, "Tue": 41392, "\u0120dissatisfaction": 41393, "Gender": 41394, "\u0120kidneys": 41395, "\u0120Gow": 41396, "\u0120Defeat": 41397, "\u0120Ashton": 41398, "\u0120cartels": 41399, "\u0120foreclosure": 41400, "\u0120Explore": 41401, "strength": 41402, "otin": 41403, "\u0120veterinarian": 41404, "\u0120fumble": 41405, "\u0120parap": 41406, "\u0120Strait": 41407, "rils": 41408, "\u0120prick": 41409, "\u0120Bermuda": 41410, "\u0120Ammunition": 41411, "skinned": 41412, "\u0120abound": 41413, "\u0120Braz": 41414, "\u0120sharper": 41415, "\u0120Ascension": 41416, "\u0120978": 41417, "\u0120previews": 41418, "\u0120communion": 41419, "\u0120XY": 41420, "\u0120phony": 41421, "\u0120newcomer": 41422, "\u0120332": 41423, ".\",\"": 41424, "\u0120redistribution": 41425, "Protect": 41426, "\u0120Sof": 41427, "Kal": 41428, "\u0120lipstick": 41429, "worst": 41430, "\u0120tangled": 41431, "\u0120retrospective": 41432, "integer": 41433, "\u0120volunteering": 41434, "\u01201907": 41435, "\u0120--------------------": 41436, "ichen": 41437, "\u0120unveiling": 41438, "\u0120senseless": 41439, "\u0120fisheries": 41440, "\\-": 41441, "\u0120hinges": 41442, "\u0120calculus": 41443, "Myth": 41444, "\u0120undefeated": 41445, "\u0120optimizations": 41446, "\u0120depress": 41447, "\u0120billboard": 41448, "\u0120Yad": 41449, "\u0120Pyramid": 41450, "Isn": 41451, "Ide": 41452, "\u0120legion": 41453, "\u0120Kramer": 41454, "entanyl": 41455, "\u0120penetrating": 41456, "\u0120Hawth": 41457, "\u0120PRODUCT": 41458, "\u0120Gerard": 41459, "\u0120Pact": 41460, "\u0120Including": 41461, "\u0120Elias": 41462, "\u0120Elaine": 41463, "visual": 41464, "\u0120humming": 41465, "\u0120condesc": 41466, "\u0120Fasc": 41467, "\u00e4\u00b8\u012c": 41468, "\u0120egalitarian": 41469, "\u0120devs": 41470, "\u0120Dahl": 41471, "Ops": 41472, "DH": 41473, "\u0120Bounce": 41474, "idated": 41475, "aldo": 41476, "\u0120republican": 41477, "\u0120hamb": 41478, "\u0120Sett": 41479, "ographies": 41480, "CHAPTER": 41481, "\u0120transsexual": 41482, "\u0120skyrocket": 41483, "answer": 41484, "\u0120markup": 41485, "\u00d8\u00aa": 41486, "\u0120heroine": 41487, "Compare": 41488, "\u0120Tav": 41489, "Beast": 41490, "\u0120successors": 41491, "\u0120na\u00c3\u00afve": 41492, "\u0120Buckley": 41493, "stress": 41494, "meat": 41495, "\u0120downloadable": 41496, "\u0120indexed": 41497, "\u0120scaff": 41498, "\u0120Lump": 41499, "\u0120Homo": 41500, "Studio": 41501, "Insp": 41502, "\u0120racked": 41503, "farious": 41504, "\u0120Petty": 41505, "External": 41506, "\u01201909": 41507, "Wars": 41508, "commit": 41509, "puters": 41510, "\u0120unob": 41511, "\u0120Err": 41512, "\u0120EG": 41513, "\u0120Alam": 41514, "\u0120Siberia": 41515, "\u0120Atmospheric": 41516, "ISTER": 41517, "\u0120Satanic": 41518, "translation": 41519, "\u0120Loud": 41520, "traumatic": 41521, "lique": 41522, "\u0120resonate": 41523, "\u0120Welch": 41524, "\u0120sparking": 41525, "\u0120TOM": 41526, "tone": 41527, "\u0120outl": 41528, "\u0120handcuffed": 41529, "\u0120Serie": 41530, "801": 41531, "\u0120landmarks": 41532, "\u0120Reeves": 41533, "\u0120softened": 41534, "\u0120dazzling": 41535, "\u0120Wanted": 41536, "months": 41537, "Magikarp": 41538, "\u0120untreated": 41539, "\u0120Bedford": 41540, "Mi": 41541, "\u0120Dynamo": 41542, "Ore": 41543, "795": 41544, "\u0120wrongful": 41545, "\u0120lured": 41546, "\u0120cortisol": 41547, "\u0120vex": 41548, "drawn": 41549, "ilet": 41550, "Downloadha": 41551, "\u0120Faction": 41552, "\u0120labyrinth": 41553, "\u0120hijacked": 41554, "waters": 41555, "erick": 41556, "\u0120superiors": 41557, "\u0120Rowling": 41558, "\u0120Guinness": 41559, "\u0120td": 41560, "992": 41561, "\u0120unearthed": 41562, "\u0120centrif": 41563, "\u0120shameless": 41564, "Pod": 41565, "\u0120Fib": 41566, "\u0120icing": 41567, "\u0120predictor": 41568, "\u0120292": 41569, "forestation": 41570, "construct": 41571, "Cand": 41572, "@#": 41573, "\u0120agitated": 41574, "\u0120repr": 41575, "OVA": 41576, "\u0120knitting": 41577, "\u0120Lima": 41578, "\u0120fodder": 41579, "684": 41580, "\u0120Persona": 41581, "kl": 41582, "701": 41583, "\u0120breakup": 41584, "\u00e1\u00b8": 41585, "\u0120appalled": 41586, "\u0120antidepressants": 41587, "\u0120Sussex": 41588, "Harris": 41589, "\u0120Thermal": 41590, "eeee": 41591, "Upload": 41592, "\u0120gulf": 41593, "\u0120doorstep": 41594, "\u0120Shank": 41595, "LU": 41596, "\u0120MEN": 41597, "\u0120Pond": 41598, "sorry": 41599, "\u0120misfortune": 41600, "nance": 41601, "\u0120bona": 41602, "Mut": 41603, "\u0120degraded": 41604, "\u0120LOG": 41605, "\u0120Ness": 41606, "animal": 41607, "\u0120aversion": 41608, "undown": 41609, "\u0120supplemented": 41610, "\u0120Cups": 41611, "\u0120504": 41612, "\u0120deprive": 41613, "\u0120Sparkle": 41614, "\u00c5\u0124": 41615, "\u0120Meditation": 41616, "authors": 41617, "\u0120Saban": 41618, "\u0120Naked": 41619, "aird": 41620, "\u0120Mandarin": 41621, "\u0120Scriptures": 41622, "\u0120Personnel": 41623, "\u0120Maharashtra": 41624, "\u01201903": 41625, "\u0120Pai": 41626, "\u0120Mirage": 41627, "ombat": 41628, "Accessory": 41629, "\u0120fragmented": 41630, "Together": 41631, "\u0120believable": 41632, "\u0120Gladiator": 41633, "aligned": 41634, "\u0120Slug": 41635, "MAT": 41636, "\u0120convertible": 41637, "\u0120Bourbon": 41638, "ameron": 41639, "\u0120Rehab": 41640, "ntax": 41641, "\u0120powdered": 41642, "pillar": 41643, "\u0120smoker": 41644, "\u0120Manson": 41645, "\u0120BF": 41646, "511": 41647, "\u0120Goodell": 41648, "\u0120DAR": 41649, "mud": 41650, "gart": 41651, "\u0120obedient": 41652, "\u0120Transmission": 41653, "\u0120Donation": 41654, "880": 41655, "\u0120bothering": 41656, "Materials": 41657, "\u00e3\u0124\u00b1": 41658, "destroy": 41659, "\u0120foregoing": 41660, "\u0120anarchism": 41661, "\u0120Kry": 41662, "iceps": 41663, "\u0120littered": 41664, "\u0120Schiff": 41665, "\u0120anecdotal": 41666, "units": 41667, "\u0120fian": 41668, "\u0120Stim": 41669, "\u0120SOME": 41670, "\u0120Invaders": 41671, "\u0120behavioural": 41672, "\u0120Ventures": 41673, "\u0120sublime": 41674, "\u0120fruition": 41675, "\u0120Penalty": 41676, "\u0120corrosion": 41677, "\u00b6\u0127": 41678, "\u0120likened": 41679, "\u0120besieged": 41680, "weeney": 41681, "\u0120Creep": 41682, "\u0120linemen": 41683, "multi": 41684, "icably": 41685, "udder": 41686, "\u0120vitality": 41687, "\u0120shortfall": 41688, "\u0120Pants": 41689, "apist": 41690, "Hidden": 41691, "\u0120Drops": 41692, "medical": 41693, "\u0120pronunciation": 41694, "\u0120NRL": 41695, "\u0120insightful": 41696, "JV": 41697, "\u0120Beard": 41698, "\u0120Chou": 41699, "\u0120charms": 41700, "\u0120bins": 41701, "\u0120ambassadors": 41702, "\u0120Saturdays": 41703, "\u0120inhibitor": 41704, "\u0120Franch": 41705, "601": 41706, "','": 41707, "\u0120Conor": 41708, "artney": 41709, "\u0120Xperia": 41710, "grave": 41711, "bees": 41712, "\u0120Protestants": 41713, "\u0120soaking": 41714, "\u0120Mandal": 41715, "\u0120phased": 41716, "\u0120660": 41717, "\u0120scams": 41718, "\u0120buzzing": 41719, "\u0120Italians": 41720, "\u0120Lorenzo": 41721, "\u0120JA": 41722, "\u0120hesitated": 41723, "\u0120cliffs": 41724, "\u0120GOT": 41725, "inguishable": 41726, "\u0120ko": 41727, "\u0120interruption": 41728, "Zip": 41729, "Learning": 41730, "\u0120underscores": 41731, "\u0120Blink": 41732, "Ku": 41733, "579": 41734, "\u0120Autob": 41735, "IRE": 41736, "\u0120watering": 41737, "\u0120pastry": 41738, "820": 41739, "\u0120visionary": 41740, "\u0120Templar": 41741, "awaited": 41742, "\u0120piston": 41743, "\u0120antid": 41744, "currently": 41745, "\u0120pard": 41746, "\u0120waging": 41747, "\u0120nobility": 41748, "\u0120Yus": 41749, "\u0120injecting": 41750, "faith": 41751, "\u0120PASS": 41752, "\u00e5\u00ba": 41753, "\u0120retake": 41754, "\u0120PROC": 41755, "\u0120cathedral": 41756, "bash": 41757, "\u0120wrestlers": 41758, "\u0120partnering": 41759, "\u0120noses": 41760, "\u0120358": 41761, "Transform": 41762, "amen": 41763, "\u0120bouts": 41764, "\u0120Ideal": 41765, "\u0120Constantin": 41766, "\u0120sep": 41767, "\u0120Monarch": 41768, "atten": 41769, "\u0120Peoples": 41770, "modified": 41771, "\u0120moratorium": 41772, "\u0120penchant": 41773, "\u0120offensively": 41774, "\u0120proxies": 41775, "okane": 41776, "\u0120Taiwanese": 41777, "\u0120Poo": 41778, "\u0120HOME": 41779, "usional": 41780, "\u0120verbs": 41781, "\u0120Oman": 41782, "visory": 41783, "\u0120persuasion": 41784, "\u0120multit": 41785, "\u0120scissors": 41786, "Gay": 41787, "oway": 41788, "ophysical": 41789, "lus": 41790, "gnu": 41791, "\u0120apocalyptic": 41792, "\u0120absurdity": 41793, "\u0120playbook": 41794, "\u0120autobiography": 41795, "IUM": 41796, "\u0120sneaking": 41797, "\u0120Simulation": 41798, "pps": 41799, "ellery": 41800, "Planet": 41801, "\u0120rightfully": 41802, "\u0120niece": 41803, "\u0120NEC": 41804, "\u0120IPO": 41805, "\u0120Disclosure": 41806, "leanor": 41807, "ousy": 41808, "STER": 41809, "\u0120282": 41810, "Cruz": 41811, "Chall": 41812, "643": 41813, "\u0120Survive": 41814, "\u0120Fatal": 41815, "\u0120Amid": 41816, "apo": 41817, "Weapons": 41818, "DEN": 41819, "770": 41820, "\u0120Greenwald": 41821, "\u0120linen": 41822, "alos": 41823, "\u0120pollutants": 41824, "\u0120PCIe": 41825, "kat": 41826, "\u0120paw": 41827, "\u0120Kraft": 41828, "Chem": 41829, "\u0120Terminator": 41830, "\u0120reincarn": 41831, "\u0120][": 41832, "\u0120Seeds": 41833, "\u0120silhouette": 41834, "\u0120Stores": 41835, "\u0120grooming": 41836, "\u0120Direction": 41837, "\u0120Isabel": 41838, "\u0120Bridges": 41839, "\u00f0\u0141\u0133": 41840, "EED": 41841, "\u0120Morsi": 41842, "\u0120valves": 41843, "\u0120Ranked": 41844, "\u0120Pharma": 41845, "\u0120Organizations": 41846, "\u0120penetrated": 41847, "\u0120Rodham": 41848, "\u0120Protoss": 41849, "\u0120overest": 41850, "\u0120exasper": 41851, "\u0120TJ": 41852, "\u0120000000": 41853, "\u0120trickle": 41854, "\u0120bourbon": 41855, "WHO": 41856, "\u0120wretched": 41857, "\u0120microscopic": 41858, "\u0120checklist": 41859, "\u0120adorned": 41860, "Royal": 41861, "Administ": 41862, "\u0120Retirement": 41863, "\u0120Highest": 41864, "Weather": 41865, "ilege": 41866, "\u0120increments": 41867, "\u0120Cosponsors": 41868, "\u0120masse": 41869, "\u0120Sinn": 41870, "rf": 41871, "\u0120hordes": 41872, "assembly": 41873, "754": 41874, "\u0120Natasha": 41875, "\u0120TYPE": 41876, "\u0120GENERAL": 41877, "\u0120arranging": 41878, "\u0120407": 41879, "lator": 41880, "\u0120glean": 41881, "\u0120discredited": 41882, "\u0120clinicians": 41883, "UNE": 41884, "\u0120achieves": 41885, "\u0120Emerson": 41886, "complex": 41887, "=[": 41888, "\u0120principally": 41889, "\u0120frail": 41890, "picked": 41891, "\u0120thanking": 41892, "\u0120recl": 41893, "\u0120LAST": 41894, "\u0120suppressing": 41895, "ilic": 41896, "\u0120antidepressant": 41897, "\u0120Lisbon": 41898, "\u0120thor": 41899, "\u0120spa": 41900, "\u0120kingdoms": 41901, "\u0120Pearce": 41902, "emo": 41903, "\u0120plung": 41904, "\u0120divest": 41905, "\u0120********************************": 41906, "bis": 41907, "ospels": 41908, "adr": 41909, "Spirit": 41910, "halla": 41911, "Pink": 41912, "endez": 41913, "\u0120resurrected": 41914, "escape": 41915, "\u0120Rosenstein": 41916, "\u0120geological": 41917, "\u0120necessities": 41918, "\u0120carniv": 41919, "\u0120Elys": 41920, "\u0120Barney": 41921, "\u0120296": 41922, "digy": 41923, "STON": 41924, "DOWN": 41925, "\u0120milestones": 41926, "\u0120ker": 41927, "\u0120dismantling": 41928, "\u0120reprim": 41929, "\u0120crossings": 41930, "1945": 41931, "\u0120patriarchy": 41932, "\u0120blasphemy": 41933, "\u0120359": 41934, "metry": 41935, "\u0120Obesity": 41936, "\u0120Differences": 41937, "blocking": 41938, "\u00e3\u0125\u0137\u00e3\u0124\u00a1": 41939, "ichita": 41940, "\u0120Sabha": 41941, "phalt": 41942, "\u0120Colo": 41943, "uala": 41944, "efficients": 41945, "\u0120Medina": 41946, "console": 41947, "557": 41948, "\u0120Hannibal": 41949, "\u0120Habit": 41950, "\u0120Fever": 41951, "\u0120thence": 41952, "\u0120synagogue": 41953, "\u0120essentials": 41954, "\u0120wink": 41955, "\u0120Trader": 41956, "IDA": 41957, "\u0120Spoiler": 41958, "\u0120Icelandic": 41959, "\u0120Hayward": 41960, "\u0120peac": 41961, "\u0120malice": 41962, "\u0120flashback": 41963, "\u0120thw": 41964, "\u0120layoffs": 41965, "Liquid": 41966, "\u0120trooper": 41967, "\u0120hinge": 41968, "\u0120Readers": 41969, "Phill": 41970, "\u0120Bauer": 41971, "Created": 41972, "\u0120audits": 41973, "accompan": 41974, "\u0120unsuspecting": 41975, "iera": 41976, "66666666": 41977, "\u0120broch": 41978, "\u0120apprehended": 41979, "\u0120Malk": 41980, "cerning": 41981, "\u0120Codex": 41982, "OVER": 41983, "Marsh": 41984, "\u0120Deng": 41985, "\u0120Expression": 41986, "\u0120disrespectful": 41987, "\u0120ascending": 41988, "tests": 41989, "\u0120Plaintiff": 41990, "stery": 41991, "\u0120Alibaba": 41992, "dinand": 41993, "\u0120Dempsey": 41994, "Applications": 41995, "moral": 41996, "\u0120throughput": 41997, "\u0120quarrel": 41998, "\u0120mills": 41999, "\u0120hemor": 42000, "\u0120CASE": 42001, "terrorist": 42002, "stim": 42003, "ifestyle": 42004, "rozen": 42005, "CEPT": 42006, "Ark": 42007, "uci": 42008, "lectic": 42009, "\u0120irritating": 42010, "sheets": 42011, "Ay": 42012, "\u0120redeemed": 42013, "\u0120horny": 42014, "\u0120Teach": 42015, "\u0120Sear": 42016, "democracy": 42017, "465": 42018, "\u0120Restore": 42019, "\u0120standby": 42020, "\u0120Pis": 42021, "iffin": 42022, "\u0120sleepy": 42023, "\u0120extrater": 42024, "\u0120compliments": 42025, "Frameworks": 42026, "\u0120installs": 42027, "\u0120banging": 42028, "surface": 42029, "foundland": 42030, "\u0120metaphysical": 42031, "\u0120283": 42032, "ouls": 42033, "devices": 42034, "Args": 42035, "\u0120Sacrifice": 42036, "\u0120McCorm": 42037, "eson": 42038, "Conservative": 42039, "\u0120Mikhail": 42040, "seeing": 42041, "isively": 42042, "\u0120Rooms": 42043, "\u0120Generic": 42044, "\u0120enthusiastically": 42045, "\u0120gripped": 42046, "\u0120comedic": 42047, "\u0120Electricity": 42048, "\u0120guerrilla": 42049, "\u0120decoration": 42050, "\u0120Perspective": 42051, "\u0120consultations": 42052, "\u0120unamb": 42053, "\u0120plagiar": 42054, "\u0120magician": 42055, "\u0120erection": 42056, "\u0120Tourism": 42057, "oried": 42058, "roxy": 42059, "1100": 42060, "Tam": 42061, "\u012a\u00e8": 42062, "\u00ce\u00b3": 42063, "\u00d7\u00aa": 42064, "\u0120Predators": 42065, "Nitrome": 42066, "\u0120telescopes": 42067, "projects": 42068, "\u0120unprotected": 42069, "\u0120stocked": 42070, "\u0120Entreprene": 42071, "nexpected": 42072, "\u0120wastewater": 42073, "Vill": 42074, "\u0120intimately": 42075, "\u0120iCloud": 42076, "\u0120Constable": 42077, "\u0120spoof": 42078, "\u0120nefarious": 42079, "\u0120fins": 42080, "\u0120censor": 42081, "\u0120Modes": 42082, "\u0120Esper": 42083, "arbon": 42084, "\u0120intersections": 42085, "\u0120lauded": 42086, "\u0120physi": 42087, "\u0120generously": 42088, "\u0120TheNitrome": 42089, "\u0120TheNitromeFan": 42090, "\u0120arisen": 42091, "\u0120\u00d9\u012a": 42092, "\u0120glands": 42093, "\u0120Pavilion": 42094, "\u0120Gupta": 42095, "\u0120uniformly": 42096, "\u0120ramps": 42097, "riet": 42098, "\u0120WHEN": 42099, "\u0120Vanessa": 42100, "\u0120routed": 42101, "\u0120limp": 42102, "\u0120CPI": 42103, "pter": 42104, "intuitive": 42105, "\u0120vaping": 42106, "\u0120experimented": 42107, "\u0120Olympus": 42108, "\u0120Amon": 42109, "\u0120sighting": 42110, "\u0120infiltrate": 42111, "\u0120Gentleman": 42112, "\u0120signings": 42113, "\u0120Meow": 42114, "\u0120Navigation": 42115, "checks": 42116, "433": 42117, "\u0120elapsed": 42118, "\u0120Bulgarian": 42119, "espie": 42120, "\u0120SOM": 42121, "during": 42122, "\u0120spills": 42123, "anca": 42124, "\u0120Plymouth": 42125, "MAL": 42126, "\u0120domestically": 42127, "\u0120Watergate": 42128, "\u0120FAM": 42129, "killed": 42130, "edited": 42131, "\u0120Yourself": 42132, "\u0120synchronization": 42133, "\u0120Practices": 42134, "STEP": 42135, "\u0120genomes": 42136, "\u0120QR": 42137, "notice": 42138, "\u0120locating": 42139, "zin": 42140, "\u0120329": 42141, "alcohol": 42142, "\u0120kitten": 42143, "Vo": 42144, "\u0120rinse": 42145, "\u0120grapple": 42146, "\u0120Screw": 42147, "\u0120Dul": 42148, "AIR": 42149, "\u0120leasing": 42150, "\u0120Caf\u00c3\u00a9": 42151, "\u0120roses": 42152, "\u0120Respect": 42153, "\u0120mislead": 42154, "\u0120perfected": 42155, "\u0120nudity": 42156, "\u0120nonpartisan": 42157, "\u0120Consumption": 42158, "Reporting": 42159, "\u0120nuances": 42160, "\u0120deductible": 42161, "\u0120Shots": 42162, "\u0120377": 42163, "\u0120\u00e6\u013e": 42164, "anooga": 42165, "Benef": 42166, "\u0120Bam": 42167, "\u0120Samp": 42168, "ifix": 42169, "\u0120galvan": 42170, "\u0120Medals": 42171, "radius": 42172, "\u0120nobles": 42173, "\u0120eaves": 42174, "igrate": 42175, "KT": 42176, "\u0120Harbour": 42177, "uers": 42178, "\u0120risked": 42179, "req": 42180, "\u0120neurot": 42181, "gettable": 42182, "aina": 42183, "Romney": 42184, "\u0120underpin": 42185, "\u0120loft": 42186, "\u0120Subcommittee": 42187, "\u0120Mongol": 42188, "biz": 42189, "\u0120manifests": 42190, "assisted": 42191, "\u0120Gaga": 42192, "\u0120synergy": 42193, "\u0120religiously": 42194, "\u0120Pref": 42195, "\u0120Gerry": 42196, "TAG": 42197, "\u0120Choi": 42198, "466": 42199, "behind": 42200, "\u0120Ou": 42201, "GoldMagikarp": 42202, "\u0120hemorrh": 42203, "River": 42204, "\u0120tendon": 42205, "\u0120injure": 42206, "\u0120Fiona": 42207, "\u0120pag": 42208, "\u0120agitation": 42209, "||||": 42210, "uran": 42211, "\u0120ESA": 42212, "\u0120esteem": 42213, "\u0120dodging": 42214, "\u0120412": 42215, "rss": 42216, "\u0120ceases": 42217, "excluding": 42218, "\u0120intakes": 42219, "\u0120inserts": 42220, "\u0120embold": 42221, "\u0120Oral": 42222, "upuncture": 42223, "411": 42224, "\u0120Unified": 42225, "\u0120Dele": 42226, "\u0120furnace": 42227, "\u0120Coyotes": 42228, "\u0120Brach": 42229, "Labor": 42230, "\u0120handshake": 42231, "\u0120bruises": 42232, "Grade": 42233, "\u00e9\u0139\u013a": 42234, "\u0120Grammy": 42235, "ileen": 42236, "States": 42237, "\u0120Scandinavian": 42238, "\u0120Kardash": 42239, "866": 42240, "\u0120effortlessly": 42241, "\u0120DIRECT": 42242, "\u0120THEN": 42243, "\u0120Mei": 42244, "ertation": 42245, "1968": 42246, "\u0120groin": 42247, "witch": 42248, "Requirements": 42249, "985": 42250, "\u0120roofs": 42251, "\u0120estates": 42252, "\u0120HF": 42253, "\u0120haha": 42254, "\u0120densely": 42255, "\u0120OCT": 42256, "\u0120plastics": 42257, "\u0120incidentally": 42258, "\u0120Tracks": 42259, "\u0120Taxes": 42260, "\u0120chanted": 42261, "\u0120forceful": 42262, "\u0120Bieber": 42263, "\u0120Kahn": 42264, "Kent": 42265, "\u0120Cot": 42266, "licts": 42267, "Fed": 42268, "\u0120hideous": 42269, "\u0120Verd": 42270, "\u0120Syndicate": 42271, "\u0120Illegal": 42272, "Jet": 42273, "\u0120DAV": 42274, "reasonable": 42275, "crew": 42276, "\u0120fundamentalist": 42277, "\u0120truthful": 42278, "\u0120Jing": 42279, "\u0120lil": 42280, "\u0120downed": 42281, "\u0120enchanted": 42282, "\u0120Policies": 42283, "\u0120McMaster": 42284, "\u0120Hare": 42285, "ideshow": 42286, "\u0120params": 42287, "encers": 42288, "gorithm": 42289, "\u0120allowances": 42290, "\u0120turbulent": 42291, "\u0120complexities": 42292, "\u0120KT": 42293, "\u0120337": 42294, "\u0120Genetic": 42295, "FUN": 42296, "Doug": 42297, "tick": 42298, "\u0120gigs": 42299, "umenthal": 42300, "\u0120patriarchal": 42301, "\u0120calc": 42302, ",...": 42303, "\u0120cout": 42304, "\u0120Guan": 42305, "\u0120pathological": 42306, "\u0120Rivals": 42307, "\u0120underrated": 42308, "\u0120fluorescent": 42309, "\u0120Jiu": 42310, "arnaev": 42311, "\u0120Quan": 42312, "\u0120429": 42313, "\u0120\u00e0\u00a8": 42314, "Mario": 42315, "Construct": 42316, "\u0120Citation": 42317, "\u0120Racial": 42318, "\u0120RSA": 42319, "\u0120Fidel": 42320, "\u0120395": 42321, "Personally": 42322, "Cause": 42323, "\u00c3\u00bb": 42324, "radical": 42325, "inen": 42326, "\u0120vehemently": 42327, "\u0120Papa": 42328, "\u0120internship": 42329, "\u0120flakes": 42330, "\u0120Reck": 42331, "Luckily": 42332, "Bra": 42333, "2020": 42334, "ravings": 42335, "RN": 42336, "Wonder": 42337, "Seriously": 42338, "\u0120reusable": 42339, "\u0120polluted": 42340, "\u0120Peng": 42341, "leigh": 42342, "indle": 42343, "\u0120circuitry": 42344, "\u0120Madonna": 42345, "\u0120BART": 42346, "Residents": 42347, "attribute": 42348, "Philadelphia": 42349, "Club": 42350, "\u0120planner": 42351, "\u0120frantically": 42352, "\u0120faithfully": 42353, "\u0120Territories": 42354, "\u0120LAT": 42355, "\u0120Andersen": 42356, "anu": 42357, "\u0120PARK": 42358, "\u0120Sora": 42359, "iage": 42360, "\u0120Playoffs": 42361, "\u0120GCC": 42362, "427": 42363, "\u0120abnorm": 42364, "\u0120Lever": 42365, "\u0120disobedience": 42366, "Async": 42367, "\u0120Shea": 42368, "Vert": 42369, "\u0120skirts": 42370, "\u0120Sawyer": 42371, "xp": 42372, "\u0120worsening": 42373, "\u0120scapego": 42374, "\u0120Angle": 42375, "othal": 42376, "\u0120trove": 42377, "\u0120Sty": 42378, "\u0120Nguyen": 42379, "marine": 42380, "ideon": 42381, "Depths": 42382, "Blog": 42383, "\u0120Illuminati": 42384, "\u0120tracts": 42385, "\u0120organise": 42386, "\u0120ostr": 42387, "Fs": 42388, "\u0120leveraging": 42389, "\u0120Daredevil": 42390, "asar": 42391, "\u0120lang": 42392, "\u0120extermin": 42393, "ursions": 42394, "\u0120Romo": 42395, "\u00e3\u0124\u00a4\u00e3\u0125\u012a": 42396, "\u0120contended": 42397, "\u0120encountering": 42398, "\u0120Tablet": 42399, "\u0120Alternate": 42400, "skill": 42401, "\u0120sweets": 42402, "\u0120cohesive": 42403, "capacity": 42404, "\u0120repud": 42405, "\u0120lizard": 42406, "roo": 42407, "\u0120pilgrims": 42408, "\u0120Ruff": 42409, "\u0120Instrument": 42410, "\u0120Logo": 42411, "uitous": 42412, "EH": 42413, "\u0120salesman": 42414, "\u0120ankles": 42415, "Led": 42416, "\u0120Patty": 42417, "udos": 42418, "Owner": 42419, "\u0120discrepancies": 42420, "kj": 42421, "MU": 42422, "\u0120unconditional": 42423, "DragonMagazine": 42424, "iard": 42425, "Oak": 42426, "\u0120Conversation": 42427, "beer": 42428, "\u0120Osaka": 42429, "Delta": 42430, "usky": 42431, "\u0120secretion": 42432, "\u0120plaza": 42433, "\u0120ming": 42434, "\u0120depletion": 42435, "\u0120Mous": 42436, "\u0120ITS": 42437, "\u0120Himal": 42438, "\u0120Fleming": 42439, "\u0120cytok": 42440, "\u0120Hick": 42441, "\u0120batters": 42442, "\u0120Intellectual": 42443, "675": 42444, "\u00c3\u00a9r": 42445, "ISION": 42446, "\u0120Quentin": 42447, "\u0120Chapters": 42448, "ihadi": 42449, "\u0120coaster": 42450, "WAYS": 42451, "\u0120Lizard": 42452, "\u0120Yor": 42453, "andering": 42454, "Skin": 42455, "haust": 42456, "abby": 42457, "\u0120portraying": 42458, "\u0120wielded": 42459, "dash": 42460, "\u0120proponent": 42461, "\u0120ripple": 42462, "\u0120graphene": 42463, "\u0120flyer": 42464, "\u0120recurrent": 42465, "\u0120devils": 42466, "\u0120waterfall": 42467, "\u00e6\u013a\u00af": 42468, "goo": 42469, "TextColor": 42470, "\u0120tampering": 42471, "IVES": 42472, "TRUMP": 42473, "\u0120Abel": 42474, "\u0120SAL": 42475, "\u0120Hendricks": 42476, "\u0120Lucius": 42477, "bots": 42478, "\u01204096": 42479, "ISTORY": 42480, "Guest": 42481, "\u0120NX": 42482, "inant": 42483, "Benz": 42484, "\u0120Loaded": 42485, "\u0120Clever": 42486, "treatment": 42487, "\u0120tavern": 42488, "\u0120339": 42489, "\u0120TNT": 42490, "ificantly": 42491, "Temperature": 42492, "Fel": 42493, "\u0120underworld": 42494, "\u0120Judges": 42495, "\u0120<+": 42496, "\u0120stump": 42497, "\u0120occupancy": 42498, "\u0120aber": 42499, "\u0120Finder": 42500, ")\",": 42501, "\u0120Nunes": 42502, "reset": 42503, "inet": 42504, "ectomy": 42505, "\u0120wellness": 42506, "\u0120Peb": 42507, "quartered": 42508, "andan": 42509, "\u0120negatives": 42510, "\u0120Thiel": 42511, "\u0120Clip": 42512, "\u0120LTD": 42513, "\u0120blight": 42514, "\u0120repertoire": 42515, "Kyle": 42516, "\u0120quer": 42517, "\u0120Ces": 42518, "\u0120hapl": 42519, "989": 42520, "\u0120Thames": 42521, "iscopal": 42522, "Desk": 42523, "ivariate": 42524, "\u0120Excellence": 42525, "foundation": 42526, "\u0120\u00e2\u0129": 42527, "Xi": 42528, "\u0120mysteriously": 42529, "estyles": 42530, "\u0120perish": 42531, "\u0120Engels": 42532, "\u0120DEAD": 42533, "090": 42534, "}}}": 42535, "\u0120Unreal": 42536, "\u0120restless": 42537, "IDES": 42538, "orthodox": 42539, "\u0120Intermediate": 42540, "\u0120dinners": 42541, "\u0120Trout": 42542, "\u0120Seym": 42543, "\u0120Halls": 42544, "ogged": 42545, "\u0120tragedies": 42546, "\u0120didnt": 42547, "676": 42548, "\u0120ailments": 42549, "\u0120observable": 42550, "\u0120Vide": 42551, "adapt": 42552, "\u0120Dusk": 42553, "\u0120professionalism": 42554, "\u0120Prescott": 42555, "\u0120Indies": 42556, "pox": 42557, "\u0120Mehran": 42558, "Wide": 42559, "\u0120endemic": 42560, "\u0120Paran": 42561, "Bird": 42562, "\u0120pedals": 42563, "\u0120IU": 42564, "\u0120Adamant": 42565, "\u0120Hurt": 42566, "\u0120correlates": 42567, "urden": 42568, "\u0120sponsoring": 42569, "climate": 42570, "\u0120Universities": 42571, "\u0120Knot": 42572, "ennes": 42573, "\u0120Damian": 42574, "\u0120Axel": 42575, "Sport": 42576, "\u0120barb": 42577, "\u0120Sno": 42578, "shown": 42579, "steen": 42580, "udence": 42581, "\u0120nonviolent": 42582, "\u0120homophobia": 42583, "\u0120biomass": 42584, "\u0120Detail": 42585, "\u0120srfN": 42586, "\u0120Tune": 42587, "accompanied": 42588, "IENCE": 42589, "Albert": 42590, "\u0120Mongo": 42591, "zx": 42592, "\u0120Cerberus": 42593, "orbit": 42594, "cens": 42595, "\u0120slay": 42596, "SHARE": 42597, "HY": 42598, "\u0120brawl": 42599, "\u0120Probe": 42600, "\u0120nonexistent": 42601, "\u0120Clarence": 42602, "\u0120Blackburn": 42603, "\u0120portals": 42604, "\u0120Rita": 42605, "\u0120Remain": 42606, "\u0120Levant": 42607, "\u0120tricked": 42608, "\u0120Ferry": 42609, "avering": 42610, "\u0120Strawberry": 42611, "\u0120Answers": 42612, "\u0120horrendous": 42613, "\u0120Aman": 42614, "Supplement": 42615, "\u0120Toad": 42616, "\u0120peeled": 42617, "\u0120manoeuv": 42618, "\u0120Uzbek": 42619, "monds": 42620, "\u0120Hector": 42621, "\u0120402": 42622, "pees": 42623, "fixes": 42624, "\u0120dj": 42625, "\u0120resumes": 42626, "\u0120accountant": 42627, "\u0120adversity": 42628, "\u0120hampered": 42629, "\u0120Larson": 42630, "\u0120doping": 42631, "parts": 42632, "Hur": 42633, "\u0120bearded": 42634, "\u0120yr": 42635, "\u0120Plugin": 42636, "\u00e5\u00a5\u00b3": 42637, "\u0120/**": 42638, "rolley": 42639, "\u0120watershed": 42640, "\u0120Submission": 42641, "iflower": 42642, "ASC": 42643, "\u0120choir": 42644, "\u0120sculptures": 42645, "mA": 42646, "increasing": 42647, "aii": 42648, "\u0120sneakers": 42649, "\u0120confronts": 42650, "\u0120Elephant": 42651, "\u0120Elixir": 42652, "\u0120recal": 42653, "\u0120TTL": 42654, "widget": 42655, "\u0120Wax": 42656, "\u0120Grayson": 42657, "\u0120hairst": 42658, "\u0120humiliated": 42659, "\u0120WARN": 42660, "appiness": 42661, "\u0120TTC": 42662, "Fuel": 42663, "\u0120polio": 42664, "\u0120complexes": 42665, "\u0120babe": 42666, "\u0120XIV": 42667, "PF": 42668, ").[": 42669, "Parts": 42670, "\u0120435": 42671, "Meg": 42672, "\u0120Yards": 42673, "\u0120ALP": 42674, "\u0120yells": 42675, "\u0120princes": 42676, "\u0120bullies": 42677, "\u0120Capitalism": 42678, "exempt": 42679, "FAQ": 42680, "\u0120Sponge": 42681, "\u0120Ala": 42682, "\u0120pleasantly": 42683, "\u0120buf": 42684, "\u0120denote": 42685, "\u0120unpublished": 42686, "\u0120kneeling": 42687, "asca": 42688, "\u0120lapse": 42689, "alien": 42690, "994": 42691, "\u0120referees": 42692, "\u0120Lawyers": 42693, "Santa": 42694, "\u0120puzzling": 42695, "\u0120Prometheus": 42696, "\u0120Pharaoh": 42697, "\u0120Delay": 42698, "\u0120facilitates": 42699, "\u0120CES": 42700, "\u0120jewels": 42701, "\u0120booklet": 42702, "onding": 42703, "\u0120polarization": 42704, "\u0120Moran": 42705, "\u0120Salad": 42706, "\u0120SOS": 42707, "\u0120Advice": 42708, "PHOTOS": 42709, "ICAN": 42710, "iatures": 42711, "express": 42712, "\u0120Wonderland": 42713, "\u0120CODE": 42714, "\u0120CLASS": 42715, "975": 42716, "\u0120grep": 42717, "\u0120Diesel": 42718, "\u0120Glac": 42719, "!?\"": 42720, "\u0120rm": 42721, "oine": 42722, "discrimination": 42723, "\u0120Nurse": 42724, "mallow": 42725, "\u0120vortex": 42726, "\u0120Consortium": 42727, "\u0120largeDownload": 42728, "straight": 42729, "aughlin": 42730, "Grad": 42731, "\u0120publicized": 42732, "\u0120Waves": 42733, "\u0120Redd": 42734, "\u0120festivities": 42735, "\u0120Mane": 42736, "arov": 42737, "\u0120fleeting": 42738, "\u0120Drunk": 42739, "ugen": 42740, "Cele": 42741, "\u0120chromosomes": 42742, "\u0120DOT": 42743, "-+-+-+-+": 42744, "\u0120busiest": 42745, "\u0120Beaver": 42746, "Syrian": 42747, "\u0120Kyr": 42748, "kas": 42749, "\u0120CrossRef": 42750, "1950": 42751, "7601": 42752, "\u0120repealing": 42753, "\u0120Winners": 42754, "\u0120Macro": 42755, "\u0120DOD": 42756, "blance": 42757, "Sort": 42758, "641": 42759, "\u0120metre": 42760, "\u0120Dirk": 42761, "\u0120goggles": 42762, "\u0120drawbacks": 42763, "\u0120complainant": 42764, "\u0120authorizing": 42765, "\u0120antitrust": 42766, "operated": 42767, "\u0120mah": 42768, "\u0120exaggeration": 42769, "Amazing": 42770, "\u0120Seraph": 42771, "\u0120haze": 42772, "wow": 42773, "\u0120extinguished": 42774, "\u0120canyon": 42775, "\u0120Bosh": 42776, "\u0120vents": 42777, "\u0120scrape": 42778, "Correct": 42779, "426": 42780, "\u0120avg": 42781, "Demand": 42782, "\u0120\u00e2\u012a\u00bc": 42783, "\u0120microbiota": 42784, "\"}],\"": 42785, "\u0120Stev": 42786, "Bio": 42787, "\u0120Planes": 42788, "\u0120suggestive": 42789, "\u0120decipher": 42790, "\u0120Refugee": 42791, "\u0120Kejriwal": 42792, "\u0120Greenpeace": 42793, "\u0120declass": 42794, "\u0120Sounders": 42795, "\u0120tho": 42796, "\u0120decrypt": 42797, "\u0120brushing": 42798, "\u0120Janeiro": 42799, "ipop": 42800, "Si": 42801, "877": 42802, "\u0120Geoffrey": 42803, "\u0120cpu": 42804, "\u0120Hazel": 42805, "\u0120viewpoints": 42806, "\u0120crispy": 42807, "\u0120Notification": 42808, "\u0120solder": 42809, "\u0120Modest": 42810, "\u0120Hemisphere": 42811, "\u0120cassette": 42812, "includes": 42813, "\u0120identifiers": 42814, "\u0120CALL": 42815, "incent": 42816, "Todd": 42817, "\u0120Sweep": 42818, "\u0120334": 42819, "boss": 42820, "\u0120smir": 42821, "ginx": 42822, "\u0120township": 42823, "\u0120grieving": 42824, "\u0120Mosque": 42825, "Netflix": 42826, "ASED": 42827, "\u0120Millennials": 42828, "ocom": 42829, "1967": 42830, "\u0120boldly": 42831, "sleep": 42832, "\u0120esche": 42833, "arijuana": 42834, "\u0120swirl": 42835, "\u0120Penal": 42836, "\u0120negligent": 42837, "\u0120Stephenson": 42838, "KER": 42839, "\u0120Zoro": 42840, "risis": 42841, "\u0120localization": 42842, "\u0120Seymour": 42843, "\u0120Anglic": 42844, "reditation": 42845, "protection": 42846, "\u0120Paige": 42847, "\u0120omit": 42848, "\u0120Rousse": 42849, "\u0120Tub": 42850, "\u0120invitations": 42851, "tty": 42852, "\u0120moss": 42853, "physical": 42854, "Credits": 42855, "\u0120anarchy": 42856, "\u0120childcare": 42857, "\u0120lull": 42858, "\u0120Mek": 42859, "\u0120Languages": 42860, "latest": 42861, "\u0120Sanford": 42862, "\u0120usability": 42863, "\u0120diffuse": 42864, "\u0120DATA": 42865, "\u0120sprites": 42866, "\u0120Vegeta": 42867, "\u0120Promotion": 42868, "\u00e3\u0125\u00bc\u00e3\u0124\u00af": 42869, "ricting": 42870, "zee": 42871, "Turkish": 42872, "\u0120TDs": 42873, "proven": 42874, "571": 42875, "\u0120smugglers": 42876, "70710": 42877, "\u0120reformed": 42878, "\u0120Lois": 42879, "\u0120unfl": 42880, "\u0120WITHOUT": 42881, "\u0120Returning": 42882, "annie": 42883, "\u0120Tomas": 42884, "Franc": 42885, "\u0120Profit": 42886, "\u0120SERV": 42887, "\u0120Rumble": 42888, "ikuman": 42889, "esan": 42890, "\u0120testers": 42891, "\u0120gadget": 42892, "\u0120bracelet": 42893, "\u0120FSA": 42894, "component": 42895, "\u0120paramedics": 42896, "\u0120jan": 42897, "\u0120Remem": 42898, "\u0120Skinner": 42899, "\u0120lov": 42900, "\u0120Quake": 42901, "roma": 42902, "\u0120flask": 42903, "Princ": 42904, "\u0120overpower": 42905, "\u0120lodging": 42906, "\u0120KKK": 42907, "rette": 42908, "\u0120absorbs": 42909, "wrote": 42910, "\u0120,\"": 42911, "Kings": 42912, "\u0120Hail": 42913, "\u0120Falling": 42914, "xtap": 42915, "\u0120Helena": 42916, "irens": 42917, "Larry": 42918, "\u0120pamphlet": 42919, "\u0120CPR": 42920, "Gro": 42921, "\u0120Hiroshima": 42922, "\u0120holistic": 42923, "\".[": 42924, "\u0120detachment": 42925, "\u0120aspire": 42926, "\u0120complicit": 42927, "\u0120Greenwood": 42928, "\u0120respawn": 42929, "\u0120Stupid": 42930, "\u0120Finished": 42931, "fal": 42932, "bass": 42933, "\u0120abhor": 42934, "\u0120mockery": 42935, "\u0120Feast": 42936, "VIDEO": 42937, "\u0120consec": 42938, "\u0120Hungry": 42939, "Pull": 42940, "\u0120Hust": 42941, "itance": 42942, "?\u00e3\u0122\u012f": 42943, ")--": 42944, "\u0120Parallel": 42945, "conv": 42946, "469": 42947, "haar": 42948, "want": 42949, "Paper": 42950, "mins": 42951, "\u0120Toro": 42952, "\u0120TRUMP": 42953, "\u0120Rai": 42954, "DW": 42955, "\u0120Wicked": 42956, "\u0120Lep": 42957, "\u0120funky": 42958, "\u0120detriment": 42959, "iosis": 42960, "achev": 42961, "\u0120degrade": 42962, "imilation": 42963, "\u0120retard": 42964, "\u0120fragmentation": 42965, "\u0120cowboy": 42966, "\u0120YPG": 42967, "\u0120HAL": 42968, "Parents": 42969, "\u0120Sieg": 42970, "\u0120Strauss": 42971, "\u0120Rubber": 42972, "\u00d7\u0132": 42973, "Frag": 42974, "\u0120pt": 42975, "\u0120optionally": 42976, "\u0120ZIP": 42977, "\u0120Transcript": 42978, "\u0120Dwell": 42979, "882": 42980, "Merc": 42981, "\u0120MOT": 42982, "\u00e3\u0125\u00af\u00e3\u0125\u00b3": 42983, "\u0120hunts": 42984, "\u0120executes": 42985, "Includes": 42986, "\u0120acidic": 42987, "\u0120Responsibility": 42988, "\u0120Dumb": 42989, "wei": 42990, "Anderson": 42991, "\u0120Jasper": 42992, "ighton": 42993, "absolutely": 42994, "Adult": 42995, "\u0120plunder": 42996, "Morning": 42997, "\u0120Tours": 42998, "\u0120Dane": 42999, "\u00ce\u00ba": 43000, "\u0120TEST": 43001, "\u0120Gina": 43002, "\u0120canine": 43003, "awan": 43004, "\u0120socialists": 43005, "\u0120Soda": 43006, "\u0120impetus": 43007, "\u0120Supplementary": 43008, "oliath": 43009, "\u0120Kinnikuman": 43010, "mittedly": 43011, "seconds": 43012, "\u0120organisers": 43013, "\u0120documentaries": 43014, "Variable": 43015, "GREEN": 43016, "\u0120resorts": 43017, "\u0120bragging": 43018, "\u0120368": 43019, "Artist": 43020, "wk": 43021, "blers": 43022, "Uncommon": 43023, "\u0120Retrieved": 43024, "\u0120hectares": 43025, "\u0120toxin": 43026, "rank": 43027, "\u0120faiths": 43028, "\u0120Graphic": 43029, "\u0120vec": 43030, "\u0120LIA": 43031, "African": 43032, "\u0120ardent": 43033, "endiary": 43034, "Lake": 43035, "\u0120DOS": 43036, "cientious": 43037, "\u0120Okawaru": 43038, "\u0120Ally": 43039, "\u0120Timeline": 43040, "Dash": 43041, "\u0120Ic": 43042, "continue": 43043, "\u0120tidy": 43044, "\u0120instinctively": 43045, "\u0120Possibly": 43046, "\u0120Outdoor": 43047, "\u0120Wouldn": 43048, "\u0120lich": 43049, "\u0120Bray": 43050, "\u0120AX": 43051, "\u0120\u00c3\u012b": 43052, "\u0120+#": 43053, "\\'": 43054, "Directory": 43055, "abiding": 43056, "\u0120feral": 43057, "icative": 43058, "butt": 43059, "\u0120perverse": 43060, "Salt": 43061, "\u0120warped": 43062, "\u0120nineteen": 43063, "\u0120cabinets": 43064, "\u0120srfAttach": 43065, "\u0120Sloan": 43066, "\u0120powering": 43067, "regation": 43068, "Flight": 43069, "severe": 43070, "\u0120stren": 43071, "\u0120cog": 43072, "apache": 43073, "\u0120\u00e2\u013f": 43074, "\u0120cafeteria": 43075, "paces": 43076, "\u0120Grimoire": 43077, "utonium": 43078, "\u0120raining": 43079, "\u0120circling": 43080, "\u0120linebackers": 43081, "credit": 43082, "\u0120repatri": 43083, "\u0120Camden": 43084, "license": 43085, "\u0120lyric": 43086, "\u0120descriptor": 43087, "\u0120valleys": 43088, "\u0120req": 43089, "\u0120backstage": 43090, "\u0120Prohibition": 43091, "\u0120Ket": 43092, "Opening": 43093, "Sym": 43094, "\u00e6\u0138\u00b9": 43095, "\u0120servings": 43096, "\u0120overseen": 43097, "\u0120asteroids": 43098, "\u0120Mods": 43099, "\u0120Springer": 43100, "\u0120Container": 43101, "\u00e8\u00bb": 43102, "\u0120Mens": 43103, "\u0120multim": 43104, "\u0120firefighter": 43105, "pec": 43106, "\u0120chlorine": 43107, "\u00d0\u00bc": 43108, "endi": 43109, "\u0120sparing": 43110, "\u0120polygamy": 43111, "\u0120RN": 43112, "\u0120Pell": 43113, "\u0120tigers": 43114, "\u0120flashy": 43115, "\u0120Madame": 43116, "Sword": 43117, "\u0120prefrontal": 43118, "\u0120prerequisite": 43119, "uca": 43120, "\u0120wifi": 43121, "\u0120misconception": 43122, "\u0120harshly": 43123, "\u0120Streaming": 43124, "otom": 43125, "\u0120Giuliani": 43126, "footed": 43127, "\u0120tubing": 43128, "individual": 43129, "zek": 43130, "nuclear": 43131, "mol": 43132, "\u0120rightful": 43133, "493": 43134, "\u0120specialization": 43135, "\u0120passionately": 43136, "\u0120Velocity": 43137, "\u0120Availability": 43138, "Tenn": 43139, "\u0120latch": 43140, "\u0120Somebody": 43141, "\u0120helium": 43142, "claw": 43143, "\u0120dipping": 43144, "XXX": 43145, "\u0120interpersonal": 43146, "710": 43147, "\u0120subter": 43148, "\u0120biologists": 43149, "\u0120Lighting": 43150, "\u0120optic": 43151, "\u0120denim": 43152, "endon": 43153, "\u0120Corm": 43154, "\u0120341": 43155, "\u0120Coup": 43156, "\u0120fearless": 43157, "\u0120alot": 43158, "\u0120Clifford": 43159, "\u0120Runtime": 43160, "\u0120Provision": 43161, "updated": 43162, "leneck": 43163, "\u0120neuron": 43164, "\u0120grading": 43165, "\u0120Ct": 43166, "sequence": 43167, "inia": 43168, "concept": 43169, "\u0120roaring": 43170, "rival": 43171, "\u0120Caucasian": 43172, "\u0120monog": 43173, "keyes": 43174, "\u0120appellate": 43175, "\u0120liaison": 43176, "EStreamFrame": 43177, "\u0120Plum": 43178, "!.": 43179, "\u0120spherical": 43180, "\u0120perished": 43181, "\u0120blot": 43182, "\u0120benches": 43183, "\u0120411": 43184, "\u0120pioneered": 43185, "\u0120hurled": 43186, "Jennifer": 43187, "\u0120Yosemite": 43188, "Chair": 43189, "\u0120reefs": 43190, "\u0120elector": 43191, "\u0120Anthem": 43192, "652": 43193, "\u0120uninstall": 43194, "\u0120impede": 43195, "\u0120blinking": 43196, "\u0120goto": 43197, "Decre": 43198, "Aren": 43199, "\u0120stabilization": 43200, "\u0120Disabled": 43201, "\u0120Yanukovych": 43202, "\u0120outlawed": 43203, "\u0120Ventura": 43204, "teness": 43205, "\u0120plantation": 43206, "\u0120yacht": 43207, "\u0120Huawei": 43208, "\u0120solvent": 43209, "\u0120gracious": 43210, "\u0120curiously": 43211, "\u0120capacitor": 43212, "\u0120cx": 43213, "\u0120Reflex": 43214, "Phys": 43215, "\u0120Cf": 43216, "ptin": 43217, "conservative": 43218, "\u0120invocation": 43219, "cour": 43220, "FN": 43221, "\u0120Newly": 43222, "Hour": 43223, "Asian": 43224, "\u0120Leading": 43225, "\u0120Aerospace": 43226, "Anne": 43227, "\u0120prenatal": 43228, "\u0120deteriorating": 43229, "HCR": 43230, "\u0120Normandy": 43231, "olini": 43232, "\u0120Ambro": 43233, "910": 43234, "\u0120setbacks": 43235, "\u0120TRE": 43236, "\u0120sig": 43237, "\u0120Scourge": 43238, "597": 43239, "798": 43240, "Gameplay": 43241, "\u0120msec": 43242, "MX": 43243, "\u0120pricey": 43244, "\u0120LLP": 43245, "akeru": 43246, "\u0120overarching": 43247, "\u0120Bale": 43248, "\u0120worldly": 43249, "Clark": 43250, "\u0120scenic": 43251, "\u0120disliked": 43252, "\u0120Controlled": 43253, "Tickets": 43254, "\u0120EW": 43255, "abies": 43256, "\u0120Plenty": 43257, "Nonetheless": 43258, "\u0120artisan": 43259, "Transfer": 43260, "\u0120Famous": 43261, "\u0120infield": 43262, "bley": 43263, "\u0120unresolved": 43264, "\u0120MLA": 43265, "\u00e3\u0124\u0124": 43266, "Correction": 43267, "\u0120democrat": 43268, "\u0120Moreno": 43269, "rocal": 43270, "ilings": 43271, "\u0120sailor": 43272, "\u0120rife": 43273, "hung": 43274, "\u0120tropes": 43275, "\u0120snatched": 43276, "\u0120LIN": 43277, "\u0120Bib": 43278, "ESA": 43279, "\u0120Prev": 43280, "\u0120Camel": 43281, "runtime": 43282, "\u0120obnoxious": 43283, "437": 43284, "\u0120summers": 43285, "\u0120unexplained": 43286, "\u0120Walters": 43287, "caliber": 43288, "\u0120gull": 43289, "\u0120Endurance": 43290, "\u00e4\u00bd\u013e": 43291, "\u0120347": 43292, "Irish": 43293, "\u0120aerobic": 43294, "\u0120cramped": 43295, "\u0120Honolulu": 43296, "\u00e0\u00a9": 43297, "userc": 43298, "ecast": 43299, "ACY": 43300, "\u0120Query": 43301, "\u00e3\u0124\u00b9\u00e3\u0125\u012a": 43302, "Beta": 43303, "\u0120susceptibility": 43304, "\u0120Shiv": 43305, "\u0120Limbaugh": 43306, "\u0120\u00c3\u0138": 43307, "\u0120NXT": 43308, "\u0120Muss": 43309, "\u0120Britons": 43310, "ESCO": 43311, "EGIN": 43312, "\u0120%%": 43313, "\u0120secession": 43314, "\u0120Patron": 43315, "\u0120Lua": 43316, "naires": 43317, "\u0120JPMorgan": 43318, "usb": 43319, "ocyte": 43320, "\u0120councillors": 43321, "\u0120Liang": 43322, "farm": 43323, "\u0120nervously": 43324, "\u0120attractiveness": 43325, "\u0120Kov": 43326, "jump": 43327, "Plot": 43328, "\u0120stains": 43329, "\u0120Statue": 43330, "\u0120Apostles": 43331, "heter": 43332, "\u0120SUPPORT": 43333, "\u0120overwhelm": 43334, "YES": 43335, "\u0120291": 43336, "density": 43337, "\u0120trapping": 43338, "Mit": 43339, "\u0120fide": 43340, "\u0120Pamela": 43341, "atlantic": 43342, "Damn": 43343, "\u0120pts": 43344, "OPA": 43345, "\u0120servicing": 43346, "\u0120overflowing": 43347, "ulo": 43348, "\u0120Erit": 43349, "ticket": 43350, "lighting": 43351, "\u0120Hmm": 43352, "\u00e3\u0125\u00bc\u00e3\u0125\u00ab": 43353, "imoto": 43354, "\u0120chuckle": 43355, "423": 43356, "\u00e3\u0123\u0137": 43357, "shape": 43358, "\u0120queues": 43359, "\u0120anchors": 43360, "\u00e3\u0124\u00bc\u00e3\u0124\u00a6\u00e3\u0124\u00b9": 43361, "Fer": 43362, "\u0120awoke": 43363, "\u0120666": 43364, "hands": 43365, "\u0120divergence": 43366, "\u0120505": 43367, "Tips": 43368, "\u0120depot": 43369, "\u0120skew": 43370, "\u0120Deliver": 43371, "opot": 43372, "\u0120divul": 43373, "\u0120EB": 43374, "unsigned": 43375, "\u0120Uni": 43376, "Xbox": 43377, "\u0120forks": 43378, "\u0120702": 43379, "\u00e5\u00af": 43380, "\u0120promoters": 43381, "\u0120Vapor": 43382, "\u0120levied": 43383, "slot": 43384, "\u0120pigment": 43385, "\u0120cylinders": 43386, "CRE": 43387, "\u0120snatch": 43388, "\u0120perpetually": 43389, "\u0120licking": 43390, "\u0120Feet": 43391, "\u0120Kraken": 43392, "\u0120Holden": 43393, "\u0120CLSID": 43394, "mr": 43395, "\u0120projector": 43396, "\u0120denotes": 43397, "\u0120chapel": 43398, "\u0120Torrent": 43399, "bler": 43400, "Route": 43401, "\u0120Defendant": 43402, "\u0120Publishers": 43403, "\u0120Males": 43404, "\u0120Innov": 43405, "\u0120Agility": 43406, "riter": 43407, "tymology": 43408, "stores": 43409, "Lind": 43410, "\u0120folly": 43411, "\u0120Zurich": 43412, "Ble": 43413, "\u0120nurture": 43414, "\u0120coastline": 43415, "uchin": 43416, "Domin": 43417, "\u0120frivol": 43418, "\u0120Consolid": 43419, "results": 43420, "MJ": 43421, "\u0120phylogen": 43422, "\u0120hauled": 43423, "\u0120Wiley": 43424, "\u0120Jessie": 43425, "\u0120Prepare": 43426, "\u0120Eps": 43427, "\u0120treasurer": 43428, "IAS": 43429, "\u0120colonists": 43430, "\u0120inund": 43431, "\u0120WWF": 43432, "\u0120Converted": 43433, "6000": 43434, "outside": 43435, "\u0120Appearance": 43436, "\u0120Relic": 43437, "\u0120Mister": 43438, "saw": 43439, "\u0120resultant": 43440, "\u0120adjective": 43441, "\u0120Laurel": 43442, "\u0120Hindi": 43443, "bda": 43444, "Peace": 43445, "\u0120rebirth": 43446, "\u0120membranes": 43447, "\u0120forwarding": 43448, "\u0120collided": 43449, "\u0120Carolyn": 43450, "Kansas": 43451, "599": 43452, "\u0120SolidGoldMagikarp": 43453, "Beck": 43454, "\u0120stressing": 43455, "\u0120Goo": 43456, "\u0120Cooperative": 43457, "\u0120fs": 43458, "\u0120Archie": 43459, "Liter": 43460, "\u0120Klopp": 43461, "Jerry": 43462, "\u0120footwear": 43463, "Warren": 43464, "\u0120scree": 43465, "hare": 43466, "Understanding": 43467, "Ped": 43468, "\u0120anthology": 43469, "\u0120Announce": 43470, "Mega": 43471, "\u0120fluent": 43472, "\u0120bondage": 43473, "\u0120Discount": 43474, "ilial": 43475, "Cart": 43476, "\u0120Nightmares": 43477, "Sham": 43478, "\u0120Boll": 43479, "ussie": 43480, "Http": 43481, "Atlanta": 43482, "\u0120unrecogn": 43483, "\u0120Bid": 43484, "\u0120undergrad": 43485, "\u0120forgiving": 43486, "\u0120Glover": 43487, "AAAAAAAA": 43488, "445": 43489, "VG": 43490, "paio": 43491, "killers": 43492, "\u0120responsibly": 43493, "\u0120mobilize": 43494, "\u0120effected": 43495, "\u0120Lumin": 43496, "\u0120kale": 43497, "\u0120infringing": 43498, "announced": 43499, "\u0120fitt": 43500, "batch": 43501, "\u0120Tackle": 43502, "\u0120Lime": 43503, "\u0120APP": 43504, "ukemia": 43505, "\u0120ruby": 43506, "\u0120exoner": 43507, "\u0120Casual": 43508, "070": 43509, "\u0120pelvic": 43510, "\u0120automate": 43511, "\u0120Kear": 43512, "\u0120Coastal": 43513, "\u0120creed": 43514, "\u0120boredom": 43515, "\u0120Stun": 43516, "riott": 43517, "\u0124\u0130": 43518, "\u0120regenerate": 43519, "\u0120comedians": 43520, "\u0120OPER": 43521, "Spons": 43522, "idium": 43523, "onis": 43524, "Located": 43525, "057": 43526, "\u0120suspense": 43527, "\u0120Dating": 43528, "Cass": 43529, "\u0120neocons": 43530, "\u0120Shinzo": 43531, "\u0120awoken": 43532, "christ": 43533, "\u0120Messages": 43534, "attled": 43535, "\u0120Spray": 43536, "\u0120Spice": 43537, "CW": 43538, "\u0120shielding": 43539, "\u0120Gaul": 43540, "Amid": 43541, "\u0120paramilitary": 43542, "\u0120multif": 43543, "\u0120Tanner": 43544, "ilk": 43545, "\u0120goddamn": 43546, "gements": 43547, "\u0120befriend": 43548, "mobi": 43549, "\u0120388": 43550, "folder": 43551, "acca": 43552, "\u0120insin": 43553, "gap": 43554, "Nev": 43555, "fifth": 43556, "\u0120psychiatry": 43557, "banks": 43558, "THIS": 43559, "\u0120harb": 43560, "acqu": 43561, "\u0120facade": 43562, "\u0120PowerPoint": 43563, "803": 43564, "\u0120bluff": 43565, "Shares": 43566, "\u0120favoring": 43567, "Elizabeth": 43568, "\u00c3\u012f\u00c3\u012f": 43569, "\u0120ranger": 43570, "772": 43571, "\u0120Arche": 43572, "hak": 43573, "\u0120Genetics": 43574, "\u0120FEMA": 43575, "\u0120evolves": 43576, "\u0120este": 43577, "\u0120Pets": 43578, "\u0120M\u00c3\u00a9": 43579, "\u0120Interesting": 43580, "\u0120Canterbury": 43581, "chapter": 43582, "\u0120Starfleet": 43583, "Spanish": 43584, "\u0120drawback": 43585, "\u0120Norwich": 43586, "970": 43587, "north": 43588, "aganda": 43589, "\u0120transformative": 43590, "ramids": 43591, "biology": 43592, "aday": 43593, "\u0120propagation": 43594, "\u0120Gamma": 43595, "\u0120Denise": 43596, "\u0120Calculator": 43597, "entimes": 43598, "\u0120Bett": 43599, "\u0120appendix": 43600, "\u0120HDD": 43601, "AKING": 43602, "\u0120stigmat": 43603, "\u0120holster": 43604, "\u0120ordinarily": 43605, "Chance": 43606, "\u0120Contrary": 43607, "\u0120adhesive": 43608, "\u0120gathers": 43609, "612": 43610, "reau": 43611, "onyms": 43612, "eways": 43613, "\u0120induces": 43614, "\u0120interchangeable": 43615, "sem": 43616, "Whit": 43617, "\u0120trance": 43618, "\u0120incorporation": 43619, "\u0120Extras": 43620, "Financial": 43621, "\u0120awkwardly": 43622, "\u0120Sturgeon": 43623, "\u0120HY": 43624, "Normally": 43625, "\u0120Ending": 43626, "\u0120Assist": 43627, "encrypted": 43628, "\u0120subjug": 43629, "\u0120nos": 43630, "\u0120fanatic": 43631, "Cub": 43632, "CU": 43633, "?\".": 43634, "\u0120irreversible": 43635, "\u00e5\u0124": 43636, "031": 43637, "\u0120HAR": 43638, "spread": 43639, "ulia": 43640, "=$": 43641, "Scope": 43642, "Lots": 43643, "\u0120lifestyles": 43644, "olon": 43645, "\u0120feds": 43646, "\u0120congratulate": 43647, "webkit": 43648, "\u0120indistinguishable": 43649, "\u0120Swing": 43650, "\u0120commandments": 43651, "quila": 43652, "abella": 43653, "methyl": 43654, "annabin": 43655, "\u0120overe": 43656, "\u0120lobster": 43657, "\u0120QUEST": 43658, "\u0120CONTIN": 43659, "bernatorial": 43660, "::::::::": 43661, "\u0120Trave": 43662, "\u0120Samoa": 43663, "ANI": 43664, "752": 43665, "\u00d0\u00b4": 43666, "usercontent": 43667, "\u0120Moderate": 43668, "yeah": 43669, "\u0120Kitt": 43670, "\u0120wee": 43671, "\u0120stuffing": 43672, "\u0120Intervention": 43673, "\u0120Dign": 43674, "\u0120warehouses": 43675, "\u0120Fiji": 43676, "\u0120pellets": 43677, "\u0120takeaway": 43678, "\u0120TABLE": 43679, "\u0120Classical": 43680, "collection": 43681, "\u0120landfall": 43682, "\u0120Muscle": 43683, "\u0120settles": 43684, "\u0120ADV": 43685, "\u0120344": 43686, "Laura": 43687, "\u0120fared": 43688, "\u0120Partial": 43689, "436": 43690, "ossibility": 43691, "\u0120Daly": 43692, "\u0120Tarant": 43693, "\u0120Fuji": 43694, "aml": 43695, "cence": 43696, "551": 43697, "\u0120Procedures": 43698, "\u0120OCD": 43699, "\u0120UD": 43700, "tin": 43701, "QUI": 43702, "acho": 43703, "438": 43704, "\u0120glitches": 43705, "\u0120enchantment": 43706, "\u0120calculates": 43707, "IRO": 43708, "\u0120Hua": 43709, "alyses": 43710, "\u0120Lift": 43711, "umo": 43712, "\u0120leapt": 43713, "\u0120hypothesized": 43714, "\u0120Gustav": 43715, "itans": 43716, "VERSION": 43717, "\u00e6\u0142": 43718, "Roger": 43719, "\u0120rand": 43720, "\u0120Adapter": 43721, "\u0120331": 43722, "\u0120Petition": 43723, "kies": 43724, "Mars": 43725, "\u0120undercut": 43726, "zees": 43727, "\u0120Lyons": 43728, "\u0120DHCP": 43729, "Missing": 43730, "\u0120retirees": 43731, "\u0120insidious": 43732, "eli": 43733, ">)": 43734, ".\u00e3\u0122\u012f": 43735, "\u0120finalists": 43736, "\u0120Aure": 43737, "\u0120accuser": 43738, "\u0120wastes": 43739, "\u0120Ys": 43740, "\u0120Lori": 43741, "\u0120constituencies": 43742, "\u0120supper": 43743, "\u0120mayhem": 43744, "orange": 43745, "\u0120misplaced": 43746, "\u0120managerial": 43747, "\u0120exce": 43748, "\u0120CLI": 43749, "\u0120primal": 43750, "\u0120Lent": 43751, "Crystal": 43752, "hover": 43753, "\u0120NTS": 43754, "endum": 43755, "\u0120dw": 43756, "\u0120Alc": 43757, "nostic": 43758, "\u0120preserves": 43759, "\u0120Tsarnaev": 43760, "\u0120tripled": 43761, "relative": 43762, "Arcade": 43763, "killing": 43764, "\u0120WEEK": 43765, "\u0120Hanna": 43766, "Dust": 43767, "Completed": 43768, "\u0123\u00ab": 43769, "\u0120approves": 43770, "\u0120Surf": 43771, "\u0120Lutheran": 43772, "venants": 43773, "\u0120robberies": 43774, "weights": 43775, "software": 43776, "atana": 43777, "ugal": 43778, "\u0120gravy": 43779, "\u0120Cance": 43780, "OLOGY": 43781, "lyak": 43782, "Tonight": 43783, "\u0120unveil": 43784, "\u01201904": 43785, "\u0120Minion": 43786, "entious": 43787, "stice": 43788, "packages": 43789, "\u0120GEAR": 43790, "\u0120gol": 43791, "\u0120Hutchinson": 43792, "\u0120Profession": 43793, "\u0120GUN": 43794, "\u0120Difference": 43795, "\u0120Tsukuyomi": 43796, "\u0120Lesbian": 43797, "670": 43798, "\u0120fugitive": 43799, "\u0120Planetary": 43800, "--------------------------------------------------------": 43801, "\u0120accrued": 43802, "\u0120chicks": 43803, "\u0120stopp": 43804, "\u0120blockers": 43805, "Cod": 43806, "\u0120commenters": 43807, "\u0120Somewhere": 43808, "\u0120Photographer": 43809, "theme": 43810, "\u0120mayoral": 43811, "wu": 43812, "\u0120antennas": 43813, "\u0120revamped": 43814, "\u0120Subjects": 43815, "it\u00c3\u00a9": 43816, "imura": 43817, "\u0120entrances": 43818, "literally": 43819, "\u0120tenets": 43820, "\u0120OMG": 43821, "\u0120MPH": 43822, "\u0120Donkey": 43823, "\u0120Offense": 43824, "\u0120\"+": 43825, "Snap": 43826, "\u0120AFB": 43827, "\u0120animate": 43828, "\u0120Sod": 43829, "Hispanic": 43830, "\u0120inconsistency": 43831, "Db": 43832, "FY": 43833, "Export": 43834, "\u0120ape": 43835, "\u0120pearl": 43836, "ibel": 43837, "\u0120PACs": 43838, "\u0120{\\": 43839, "\u0120actu": 43840, "\u0120HSBC": 43841, "campus": 43842, "\u0120payoff": 43843, "\u0120deities": 43844, "\u0120Nato": 43845, "ouple": 43846, "\u0120censored": 43847, "\u0120Clojure": 43848, "\u0120confounding": 43849, "eni": 43850, "\u0120reckon": 43851, "ophe": 43852, "\u0120spotting": 43853, "\u0120signifies": 43854, "\u0120propel": 43855, "\u0120festive": 43856, "Suggest": 43857, "\u0120pledging": 43858, "\u0120Berman": 43859, "\u0120rebellious": 43860, "\u0120overshadowed": 43861, "\u0120infiltrated": 43862, "jobs": 43863, "672": 43864, "\u0120scalable": 43865, "\u0120dominion": 43866, "\u0120Newfoundland": 43867, "\u0120Meadow": 43868, "\u0120partitions": 43869, "AMI": 43870, "\u0120supplementary": 43871, "strument": 43872, "\u0120hairy": 43873, "\u0120perpetuate": 43874, "\u0120nutshell": 43875, "\u0120Potato": 43876, "\u0120Hobbit": 43877, "\u0120curses": 43878, "Float": 43879, "\u0120quieter": 43880, "\u0120fueling": 43881, "\u0120capsules": 43882, "\u0120Lust": 43883, "\u0120Haunted": 43884, "Executive": 43885, "\u0120childbirth": 43886, "Gre": 43887, "\u0120radiant": 43888, "\u00e5\u0130": 43889, "\u0120malls": 43890, "\u0120inept": 43891, "\u0120Warranty": 43892, "\u0120spectator": 43893, "Eh": 43894, "thens": 43895, "\u0120culminating": 43896, "\u00e6\u00a9": 43897, "arya": 43898, "\u00e3\u0124\u00ae": 43899, "ilitarian": 43900, "\u0120ORIG": 43901, "\u0120Spending": 43902, "ptives": 43903, "\u0120Siren": 43904, "\u0120Recording": 43905, "ayne": 43906, "\u0120vim": 43907, "\u0120sprang": 43908, "Tang": 43909, "\u0120MFT": 43910, "morning": 43911, "\u0120Weed": 43912, "mpeg": 43913, "cession": 43914, "\u0120Chung": 43915, "730": 43916, "warning": 43917, "562": 43918, "handedly": 43919, "Poor": 43920, "Politics": 43921, ":#": 43922, "\u0120pian": 43923, "\u0120feces": 43924, "\u0120Documentation": 43925, "\u0120banished": 43926, "\u0120399": 43927, "\u0120ARC": 43928, "\u0120heinous": 43929, "Jake": 43930, "\u0120Amir": 43931, "wayne": 43932, "vre": 43933, "oshenko": 43934, "\u0120notebooks": 43935, "\u0120foundational": 43936, "\u0120marvelous": 43937, "ixtape": 43938, "\u0120withdrawals": 43939, "\u0120horde": 43940, "\u0120Dhabi": 43941, "isable": 43942, "\u0120KD": 43943, "\u0120contagious": 43944, "\u0120Dip": 43945, "\u0120Arrows": 43946, "\u0120pronouns": 43947, "\u0120morphine": 43948, "\u0120BUS": 43949, "682": 43950, "\u0120kosher": 43951, "finished": 43952, "\u0120Instruments": 43953, "\u0120fused": 43954, "yden": 43955, "\u0120Salmon": 43956, "Fab": 43957, "affected": 43958, "KEN": 43959, "CENT": 43960, "Domain": 43961, "\u0120pokemon": 43962, "\u0120Drinking": 43963, "Growing": 43964, "\u0120Investigative": 43965, "\u0120Aether": 43966, "emi": 43967, "\u0120tabloid": 43968, "\u0120repro": 43969, "\u0120Notwithstanding": 43970, "\u0120Berserker": 43971, "\u0120dramas": 43972, "\u0120clich\u00c3\u00a9": 43973, "\u0120bung": 43974, "\u0120URI": 43975, "\u0120Dos": 43976, "044": 43977, "\u0120pastors": 43978, "\u0120ls": 43979, "\u0120acrylic": 43980, "aunts": 43981, "Edward": 43982, "\u0120majorities": 43983, "Bang": 43984, "\u0120fielding": 43985, "\u0120Replacement": 43986, "\u0120Alchemy": 43987, "ppard": 43988, "\u0120Romeo": 43989, "\u0120Sanct": 43990, "\u0120Lavrov": 43991, "ibble": 43992, "Instruct": 43993, "\u0120impractical": 43994, "\u0120Playboy": 43995, "cephal": 43996, "\u0120swaps": 43997, "\u0120kan": 43998, "\u0120Theo": 43999, "\u0120illustrating": 44000, "\u0120dismantled": 44001, "\u0120Transgender": 44002, "\u0120Guth": 44003, "UGH": 44004, "\u0120triumphant": 44005, "\u0120encompass": 44006, "\u0120bookmark": 44007, "uddin": 44008, "jer": 44009, "\u0120predicate": 44010, "ESH": 44011, "\u0120whence": 44012, "\u0120ABE": 44013, "\u0120nonprofits": 44014, "Sequ": 44015, "\u0120diabetic": 44016, "\u0120pend": 44017, "\u0120heartfelt": 44018, "shi": 44019, "\u0120interacts": 44020, "\u0120Telecom": 44021, "\u0120bombardment": 44022, "depending": 44023, "\u0120Lowry": 44024, "\u0120Admission": 44025, "\u0120Blooming": 44026, "ustration": 44027, "enegger": 44028, "Brew": 44029, "\u0120molten": 44030, "\u0120Nerd": 44031, "PIN": 44032, "\u00e2\u0138\u0122": 44033, "avement": 44034, "\u0120toured": 44035, "\u0120coefficients": 44036, "\u0120Trayvon": 44037, "ansson": 44038, "\u0120sandy": 44039, "told": 44040, "flows": 44041, "\u0120populous": 44042, "\u0120Tinder": 44043, "\u0120Bliss": 44044, "Rachel": 44045, "Minimum": 44046, "\u0120contestant": 44047, "\u0120Reduce": 44048, "\u0120Morse": 44049, "\u0120Grassley": 44050, "\u0120Clicker": 44051, "\u0120expr": 44052, "\u0120sincerity": 44053, "\u0120marqu": 44054, "\u0120elicit": 44055, "\u0120Proposition": 44056, "\u0120Demonic": 44057, "\u0120tacos": 44058, "Greek": 44059, "\u0120postwar": 44060, "\u0120insofar": 44061, "\u0120Pork": 44062, "\u0120352": 44063, "doctoral": 44064, "walking": 44065, "\u0120midterm": 44066, "\u0120Sammy": 44067, "sighted": 44068, "\u0120TRANS": 44069, "ici": 44070, "ALD": 44071, "\u0120USL": 44072, "\u0120FISA": 44073, "\u0120Ampl": 44074, "\u0120Alexandra": 44075, "inelli": 44076, "Train": 44077, "\u0120signify": 44078, "\u0120Versus": 44079, "\u0120obfusc": 44080, "\u0120kh": 44081, "\u0120aggro": 44082, "\u0120Renault": 44083, "\u0120348": 44084, "518": 44085, "oxicity": 44086, "022": 44087, "\u0120Twist": 44088, "\u0120goofy": 44089, "Dynamic": 44090, "\u0120briefings": 44091, "might": 44092, "899": 44093, "\u0120derogatory": 44094, "Tro": 44095, "\u0120forging": 44096, "\u0120Koran": 44097, "\u0120Married": 44098, "\u0120Bucs": 44099, "\u0120palate": 44100, "\u0120Conversion": 44101, "mable": 44102, "413": 44103, "\u0120(_": 44104, "\u0120siph": 44105, "\u0120NEO": 44106, "college": 44107, "\u0120marginally": 44108, "\u0120flirt": 44109, "\u0120Traps": 44110, "\u0120Pace": 44111, "\u00e9\u00bb\u0134": 44112, "\u0120goaltender": 44113, "\u0120forbids": 44114, "\u0120clerks": 44115, "\u0120Tant": 44116, "\u0120Robbins": 44117, "\u0120Printing": 44118, "\u0120premiered": 44119, "\u0120magnification": 44120, "\u0120TG": 44121, "\u0120Rouse": 44122, "\u0120Mock": 44123, "odynamics": 44124, "\u0120preclude": 44125, "ismo": 44126, "\u0120Pulitzer": 44127, "\u0120avalanche": 44128, "\u0120Kodi": 44129, "ribune": 44130, "\u0120Lena": 44131, "Electric": 44132, "\u0120refinery": 44133, "\u0120endowed": 44134, "\u0120counselors": 44135, "\u0120dolphin": 44136, "\u0120Mith": 44137, "\u0120armoured": 44138, "hibited": 44139, "Begin": 44140, "\u0120PW": 44141, "Oil": 44142, "\u0120Vor": 44143, "\u0120Sharif": 44144, "\u0120Frazier": 44145, "estate": 44146, "\u0120jams": 44147, "Proxy": 44148, "\u0120bandits": 44149, "\u0120Presbyterian": 44150, "\u0120Premiere": 44151, "tiny": 44152, "\u0120Cruel": 44153, "Testing": 44154, "\u0120homer": 44155, "\u0120VERS": 44156, "\u0120Prol": 44157, "\u0120Deposit": 44158, "\u0120Coffin": 44159, "\u0120seminars": 44160, "\u0120sql": 44161, "\u0120Defendants": 44162, "Alternatively": 44163, "\u0120Rats": 44164, "\u00e7\u00ab": 44165, "ethyst": 44166, "'>": 44167, "\u0120issuer": 44168, "589": 44169, "\u0120chaired": 44170, "\u0120Accessories": 44171, "manent": 44172, "\u0120marrow": 44173, "\u0120Primordial": 44174, "CN": 44175, "\u0120limitless": 44176, "\u0120Carnage": 44177, "\u0120undrafted": 44178, "qv": 44179, "INESS": 44180, "onew": 44181, "\u0120cohesion": 44182, "987": 44183, "\u0120necks": 44184, "\u0120footballer": 44185, "\u0120GER": 44186, "\u0120detectable": 44187, "\u0120Supporting": 44188, "\u0120CSV": 44189, "ocally": 44190, "kHz": 44191, "\u0120unde": 44192, "\u0120shone": 44193, "\u0120budding": 44194, "trak": 44195, "Standing": 44196, "\u0120Starcraft": 44197, "\u0120Kemp": 44198, "Bench": 44199, "\u0120thwarted": 44200, "\u0120Grounds": 44201, "athi": 44202, "Lisa": 44203, "Dialog": 44204, "\u0120SX": 44205, "Vision": 44206, "\u0120ingenious": 44207, "\u00d9\u0132": 44208, "\u0120fostering": 44209, "\u0120Za": 44210, "\u0120Ingram": 44211, "\u0120\"@": 44212, "Naturally": 44213, "616": 44214, "035": 44215, "\u0120FAC": 44216, "Hmm": 44217, "554": 44218, "\u0120accelerator": 44219, "\u0120Vend": 44220, "\u0120sunscreen": 44221, "\u0120tuberculosis": 44222, "raviolet": 44223, "\u0120Functional": 44224, "\u0120Errors": 44225, "edar": 44226, "1966": 44227, "\u0120Spectre": 44228, "\u0120Recipes": 44229, "885": 44230, "\u0120Mankind": 44231, "Liverpool": 44232, "\u0120|--": 44233, "\u0120substitutes": 44234, "\u0120XT": 44235, "wired": 44236, "\u0120inco": 44237, "\u0120Afgh": 44238, "Eva": 44239, "icc": 44240, "Song": 44241, "Knight": 44242, "\u0120diligently": 44243, "\u0120Broadcast": 44244, "Aid": 44245, "\u0120afar": 44246, "\u0120HMS": 44247, "atonin": 44248, "\u0120Grateful": 44249, "\u0120fireplace": 44250, "\u0120Omni": 44251, "euro": 44252, "\u0120FRE": 44253, "\u0120Shib": 44254, "\u0120Digest": 44255, "toggle": 44256, "\u0120headsets": 44257, "\u0120diffusion": 44258, "\u0120Squirrel": 44259, "\u0120FN": 44260, "\u0120darkened": 44261, "outher": 44262, "\u0120sleeps": 44263, "\u0120Xer": 44264, "guns": 44265, "\u0120setups": 44266, "\u0120parsed": 44267, "\u0120mammoth": 44268, "\u0120Curious": 44269, "gob": 44270, "\u0120Fitzpatrick": 44271, "\u0120Emil": 44272, "imov": 44273, ".............": 44274, "\u0120Benny": 44275, "Secondly": 44276, "\u0120hearty": 44277, "\u0120conson": 44278, "stained": 44279, "\u0120galactic": 44280, "clave": 44281, "\u0120plummeted": 44282, "\u0120pests": 44283, "\u0120swat": 44284, "\u0120referrals": 44285, "\u0120Lionel": 44286, "holy": 44287, "\u0120underdog": 44288, "\u0120Slater": 44289, "\u0120Provide": 44290, "\u0120Amar": 44291, "ressor": 44292, "\u00e5\u012e": 44293, "onga": 44294, "\u0120timid": 44295, "\u0120piety": 44296, "\u0120Dek": 44297, "\u0120surging": 44298, "azo": 44299, "\u0120610": 44300, "\u0120desks": 44301, "\u0120Spokane": 44302, "\u0120Anfield": 44303, "\u0120warships": 44304, "\u0120Cobra": 44305, "\u0120arming": 44306, "clusively": 44307, "\u0120Badge": 44308, "agascar": 44309, "\u0120PRESS": 44310, "\u0120McKenzie": 44311, "\u0120Ferdinand": 44312, "burning": 44313, "Afee": 44314, "\u0120tyrann": 44315, "\u0120Iw": 44316, "\u0120Boone": 44317, "1007": 44318, "\u0120Rept": 44319, "\u010a\u00c2\u0142": 44320, "\u0120caravan": 44321, "\u0120Dill": 44322, "\u0120Bundesliga": 44323, "Chuck": 44324, "\u0120healer": 44325, "\u00e3\u0125\u00bc\u00e3\u0125\u0128": 44326, "\u0120Hobby": 44327, "\u0120negate": 44328, "\u0120critiques": 44329, "sectional": 44330, "mopolitan": 44331, "\u0120dx": 44332, "\u0120outsourcing": 44333, "\u0120Cipher": 44334, "tap": 44335, "Sharp": 44336, "\u0120upbeat": 44337, "\u0120hangar": 44338, "\u0120cruising": 44339, "\u0120Niagara": 44340, "\u0120342": 44341, "illus": 44342, "\u0120Sv": 44343, "\u0120subtitles": 44344, "\u0120squared": 44345, "\u0120bookstore": 44346, "\u0120revolutionaries": 44347, "\u0120Carlton": 44348, "abal": 44349, "Utah": 44350, "\u0120despise": 44351, "\u0120UM": 44352, "consider": 44353, "aido": 44354, "\u0120carts": 44355, "\u0120Turtles": 44356, "Training": 44357, "\u0120honorary": 44358, "\u00c2\u00a2": 44359, "\u0120triangles": 44360, "422": 44361, "\u0120reprinted": 44362, "\u0120graceful": 44363, "\u0120Mongolia": 44364, "\u0120disruptions": 44365, "\u0120Boh": 44366, "\u0120349": 44367, "\u0120drains": 44368, "\u0120consulate": 44369, "\u0120bends": 44370, "\u0120mafia": 44371, "uron": 44372, "\u0120Fulton": 44373, "misc": 44374, "\u0120renal": 44375, "\u0120inaction": 44376, "cking": 44377, "\u0120photons": 44378, "\u0120bruised": 44379, "\u0120Codes": 44380, "ogi": 44381, "\u0120nests": 44382, "\u0120Lovely": 44383, "\u0120Libre": 44384, "\u0120Daryl": 44385, "\u0120###": 44386, "Sys": 44387, ".,\"": 44388, "\u0120freezes": 44389, "establishment": 44390, "andowski": 44391, "\u0120cumbers": 44392, "\u0120Starg": 44393, "\u0120Bombs": 44394, "\u0120legions": 44395, "\u0120handwriting": 44396, "\u0120grun": 44397, "\u0120Cah": 44398, "sequent": 44399, "\u0120moth": 44400, "\u0120MSM": 44401, "Insert": 44402, "Fif": 44403, "\u0120motel": 44404, "\u0120dexter": 44405, "\u0120Bild": 44406, "heartedly": 44407, "\u0120prope": 44408, "\u0120Texture": 44409, "\u0120Junction": 44410, "ynthesis": 44411, "ocard": 44412, "\u0120Vera": 44413, "\u0120Barth": 44414, "\u0120\u00ce\u00bcg": 44415, "\u0120lashed": 44416, "\u0120351": 44417, "\u0120Zamb": 44418, "\u0120Staples": 44419, "\u0120Cortex": 44420, "\u0120Corker": 44421, "\u0120continuum": 44422, "\u0120WRITE": 44423, "unta": 44424, "ridor": 44425, "\u0120deems": 44426, "033": 44427, "\u0120GOLD": 44428, "pas": 44429, "\u0120repressive": 44430, "\u00e3\u0125\u0128\u00e3\u0124\u00a3": 44431, "\u0120baffled": 44432, "Scar": 44433, "\u0120crave": 44434, "\u0120______": 44435, "\u0120entrepreneurship": 44436, "\u0120Directorate": 44437, "\u0120'[": 44438, "\u0120vines": 44439, "\u0120ascended": 44440, "\u0120GROUP": 44441, "\u0120Goodbye": 44442, "\u0120dogged": 44443, "\u00e3\u0125\u00b4\u00e3\u0124\u00a1": 44444, "Manufact": 44445, "\u0120unimaginable": 44446, "riots": 44447, "ierrez": 44448, "\u0120relativity": 44449, "\u0120Crafting": 44450, "raught": 44451, "uden": 44452, "cookie": 44453, "\u0120assassins": 44454, "\u0120dissatisfied": 44455, "acci": 44456, "\u0120conduit": 44457, "Spread": 44458, "\u0120Rican": 44459, "nice": 44460, "izzle": 44461, "\u0120scares": 44462, "\u0120WHY": 44463, "phans": 44464, "535": 44465, "\u0120protracted": 44466, "\u0120Kristen": 44467, "536": 44468, "\u0120Scrib": 44469, "\u0120Neh": 44470, "\u0120twenties": 44471, "\u0120predicament": 44472, "\u0120handcuffs": 44473, "\u0120fruitful": 44474, "\u0120UL": 44475, "\u0120Ludwig": 44476, "\u0120attest": 44477, "\u0120Breaker": 44478, "\u0120biologically": 44479, "\u0120Dealer": 44480, "\u0120renovations": 44481, "fw": 44482, "essen": 44483, "Alice": 44484, "\u0120Henri": 44485, "\u0120unilaterally": 44486, "\u0120Sidd": 44487, "hai": 44488, "\u0120Stretch": 44489, "Sales": 44490, "\u0120cumbersome": 44491, "\u0120Javier": 44492, "\u0120trendy": 44493, "\u0120rotting": 44494, "\u0120Challenges": 44495, "\u0120scraps": 44496, "\u0120facets": 44497, "\u0120Veronica": 44498, "\u0120Verge": 44499, "\u0120Sana": 44500, "Alien": 44501, "\u0120Rih": 44502, "\u0120radial": 44503, "ectar": 44504, "\u0120630": 44505, "cli": 44506, "Marie": 44507, "\u0120wildfire": 44508, "\u0120Cato": 44509, "hander": 44510, "\u0120waitress": 44511, "\u0120chops": 44512, "\u0120SECTION": 44513, "\u0120bluntly": 44514, "\u0120Catalog": 44515, "nian": 44516, "study": 44517, "\u0120patrolling": 44518, "\u0120Tenth": 44519, "nexus": 44520, "\u0120NON": 44521, "opsy": 44522, "\u0120scathing": 44523, "sie": 44524, "\u0120deteriorated": 44525, "VB": 44526, "Nazis": 44527, "\u0120depictions": 44528, "\u0120authenticated": 44529, "\u0120Conce": 44530, "krit": 44531, "\u0120promulg": 44532, "\u0120LONG": 44533, "UFC": 44534, "\u0120Visitors": 44535, "\u0120Recall": 44536, "\u0120rehabilit": 44537, "\u0120SLI": 44538, "\u0120glacier": 44539, "\u0120Bite": 44540, "\u0120503": 44541, "\u0120vomit": 44542, "\u0120fermented": 44543, "\u0120Khalid": 44544, "\u0120graded": 44545, "\u0120Magicka": 44546, "\u0120Ichigo": 44547, "powerful": 44548, "icators": 44549, "753": 44550, "\u0120shrew": 44551, "\u0120356": 44552, "\u0120legalizing": 44553, "\u0120allotted": 44554, "\u0120Archdemon": 44555, "ithing": 44556, "iggurat": 44557, "VOL": 44558, "Leod": 44559, "\u0120oily": 44560, "\u0120inducing": 44561, "\u0120amygdala": 44562, "\u0120admins": 44563, "\u0120Acquisition": 44564, "CAN": 44565, "\u0120schematic": 44566, "\u0120moan": 44567, "\u0120Cameroon": 44568, "\u0120tink": 44569, "\u0120merry": 44570, "\u0120butterflies": 44571, "\u0120Goff": 44572, "\u0120workspace": 44573, "\u0120Corona": 44574, "\u0120javascript": 44575, "\u0120Dolphin": 44576, "\u0120Cantor": 44577, "464": 44578, "toe": 44579, "APS": 44580, "\u0120Aging": 44581, "\u0120padded": 44582, "\u0120Zheng": 44583, "\u0120Held": 44584, "\u0120estranged": 44585, "\u0120770": 44586, ".}": 44587, "\u0120Dunham": 44588, "\u0120smokes": 44589, "\u0120capitals": 44590, "undai": 44591, "Shin": 44592, "\u0120Founding": 44593, "\u0120entitle": 44594, "\u0120centerpiece": 44595, "Discover": 44596, "\u0120thereto": 44597, "alert": 44598, "\u0120Nou": 44599, "\u0120Analyst": 44600, "lc": 44601, "FH": 44602, "FIELD": 44603, "\u0120POV": 44604, "gray": 44605, "\u0120arcs": 44606, "\u0120HOT": 44607, "\u0120rs": 44608, "\u0120obligatory": 44609, "\u0120Architects": 44610, "\u0120Sven": 44611, "\u0120FEC": 44612, "0200": 44613, "Christmas": 44614, "\u0120Albania": 44615, "ratom": 44616, "587": 44617, "\u0120hardships": 44618, "\u0120autos": 44619, "\u0120Charges": 44620, "\u0120apes": 44621, "\u0120376": 44622, "wallet": 44623, "\u0120intoxication": 44624, "\u0120goblin": 44625, "\u0120570": 44626, "++++++++++++++++": 44627, "\u0120Yelp": 44628, "\u0120Magnetic": 44629, "\u0120Briggs": 44630, "Rail": 44631, "\u0120spawns": 44632, "\u0120Wiggins": 44633, "\u0120showcased": 44634, "\u0120resorted": 44635, "uben": 44636, "\u0120whipping": 44637, "\u0120imitate": 44638, "\u0120digestion": 44639, "\u0120USPS": 44640, "\u0120Gest": 44641, "\u0120yea": 44642, "\u0120Tight": 44643, "indal": 44644, "icas": 44645, "`.": 44646, "CAST": 44647, "'';": 44648, "\u0120Fet": 44649, "opathic": 44650, "Invalid": 44651, "\u0120regretted": 44652, "\u0120broccoli": 44653, "\u0120Scores": 44654, "eve": 44655, "\u0120postings": 44656, "\u0120accumulating": 44657, "\u0120needless": 44658, "elfth": 44659, "\u0120mayors": 44660, "\u0120scrib": 44661, "\u0120anecdotes": 44662, "\u0120botched": 44663, "\u0120Ribbon": 44664, "\u0120Constantine": 44665, "iuses": 44666, "esses": 44667, "\u0120devise": 44668, "Compared": 44669, "\u0120pudding": 44670, "\u0120garg": 44671, "\u0120evoke": 44672, "797": 44673, "\u0120detox": 44674, "909": 44675, "\u0120Pieces": 44676, "\u0120McCartney": 44677, "\u0120metast": 44678, "\u0120Krypt": 44679, "POR": 44680, "\u0120tending": 44681, "\u0120Merchants": 44682, "Proof": 44683, "\u0120Varg": 44684, "\u0120Portable": 44685, "\u00e3\u0125\u00bc\u00e3\u0125\u0128\u00e3\u0124\u00a3": 44686, "Brain": 44687, "2500": 44688, "\u0120foliage": 44689, "\u00d8\u00b9": 44690, "\u0120mentors": 44691, "\u0120Aires": 44692, "\u0120minimalist": 44693, "\u0120ingested": 44694, "\u0120Trojan": 44695, "\u0120Qian": 44696, "involved": 44697, "027": 44698, "\u0120eroded": 44699, "RAFT": 44700, "\u0120blurry": 44701, "Mob": 44702, "\u0120buffet": 44703, "\u0120Fnatic": 44704, "aea": 44705, "KNOWN": 44706, "\u0120Init": 44707, "safety": 44708, "enum": 44709, "ACTION": 44710, "\u0120Crusher": 44711, "\u0120Dates": 44712, "\u0120................": 44713, "calling": 44714, "akov": 44715, "\u0120ventured": 44716, "\u0120555": 44717, "auga": 44718, "Hart": 44719, "\u0120Aero": 44720, "MAC": 44721, "\u0120thinly": 44722, "\u0120arra": 44723, "STATE": 44724, "ilde": 44725, "\u0120Jacqu": 44726, "\u0120Females": 44727, "\u0120theorem": 44728, "\u0120346": 44729, "\u0120smartest": 44730, "\u0120PUBLIC": 44731, "\u0120Kron": 44732, "\u0120Bits": 44733, "\u0120Vessel": 44734, "\u0120Telephone": 44735, "\u0120decap": 44736, "\u0120adjunct": 44737, "\u0120SEN": 44738, "merga": 44739, "\u0120redacted": 44740, "\u0120prehistoric": 44741, "\u0120explanatory": 44742, "\u0120Runs": 44743, "\u0120Uttar": 44744, "\u0120Manny": 44745, "\u0120AUTHOR": 44746, "\u0120Unleashed": 44747, "\u0120Bowling": 44748, "beans": 44749, "793": 44750, "\u0120universes": 44751, "\u0120sensit": 44752, "\u0120Kung": 44753, "repeat": 44754, "ctrl": 44755, "\u0120paced": 44756, "\u0120fuller": 44757, "Clock": 44758, "\u0120recomb": 44759, "\u0120Faul": 44760, "\u0120Bunker": 44761, "\u0120pooled": 44762, "\u0120ana": 44763, "\u0120Mouth": 44764, "LLOW": 44765, "humane": 44766, "\u0120bulldo": 44767, "\u0120Michaels": 44768, "fam": 44769, "\u0120wrecked": 44770, "\u0120portrays": 44771, "\u0120Whale": 44772, "\u0120Hes": 44773, "\u0120guesses": 44774, "\u0120Browse": 44775, "\u0120LAPD": 44776, "\u0120consequential": 44777, "\u0120Innocent": 44778, "\u0120DRAG": 44779, "\u0120transgress": 44780, "\u0120Oaks": 44781, "\u0120trivia": 44782, "\u0120Reson": 44783, "\u0120ADS": 44784, "--+": 44785, "\u0120Toll": 44786, "\u0120grasping": 44787, "\u0120THEM": 44788, "\u0120Tags": 44789, "\u0120Conclusion": 44790, "\u0120practicable": 44791, "\u0120hoop": 44792, "\u0120unintentionally": 44793, "\u0120ignite": 44794, "\u0120Mov": 44795, "urized": 44796, "lehem": 44797, "Termin": 44798, "\u0120colourful": 44799, "\u0120Linear": 44800, "\u0120Ellie": 44801, "Gy": 44802, "\u0120manpower": 44803, "\u0120js": 44804, "\u0120emoji": 44805, "\u0120SHARES": 44806, "_.": 44807, "00007": 44808, "\u0120sophistication": 44809, "\u0120underscore": 44810, "\u0120practise": 44811, "\u0120blob": 44812, "opens": 44813, "Ukraine": 44814, "Keeping": 44815, "YC": 44816, "JR": 44817, "ultimate": 44818, "Claim": 44819, "\u0120automobiles": 44820, "993": 44821, "steel": 44822, "\u0120parting": 44823, "\u0120Lank": 44824, "...?": 44825, "\u0120385": 44826, "\u0120remembrance": 44827, "\u0120eased": 44828, "\u0120covari": 44829, "\u0120Sind": 44830, "Effective": 44831, "\u0120dissemination": 44832, "\u0120Moose": 44833, "\u0120Clapper": 44834, "brates": 44835, "Apply": 44836, "\u0120invis": 44837, "\u0120worsened": 44838, "\u00e2\u0122\u0136-": 44839, "\u0120legislator": 44840, "\u0120Lol": 44841, "\u0120Rowe": 44842, "\u0120dealership": 44843, "umar": 44844, "idences": 44845, "\u0120investigates": 44846, "\u0120cascade": 44847, "\u0120bidder": 44848, "\u0120BEN": 44849, "Ironically": 44850, "\u0120presiding": 44851, "\u0120ding": 44852, "\u0120contradicted": 44853, "\u0120shuts": 44854, "\u0120FIX": 44855, "\u0120366": 44856, "District": 44857, "\u0120sinful": 44858, "\u0120Charisma": 44859, "oops": 44860, "\u0120totality": 44861, "\u0120restitution": 44862, "\u0120Optimus": 44863, "\u0120Dah": 44864, "\u0120clueless": 44865, "urned": 44866, "\u0120nutrit": 44867, "\u0120landowners": 44868, "\u0120flushed": 44869, "\u0120broaden": 44870, "mie": 44871, "\u0120println": 44872, "\u0120nig": 44873, "\u0120Corpus": 44874, "Jen": 44875, "\u0120proto": 44876, "\u0120Wikimedia": 44877, "\u0120Palo": 44878, "COR": 44879, "\u0120storylines": 44880, "\u0120evangelicals": 44881, "\u0120Darrell": 44882, "\u0120rotor": 44883, "\u0120HW": 44884, "skilled": 44885, "eryl": 44886, "\u0120begg": 44887, "\u0120Blumenthal": 44888, "\u0120weaving": 44889, "\u0120downwards": 44890, "\u0120Jacket": 44891, "\u0120ANGEL": 44892, "Technology": 44893, "\u0120esoteric": 44894, "aldehyde": 44895, "\u0120furiously": 44896, "\u0120foreigner": 44897, "Weak": 44898, "CHO": 44899, "\u0120Hound": 44900, "Experience": 44901, "\u0120Playstation": 44902, "\u0120MIA": 44903, "\u0120Ung": 44904, "cloth": 44905, "agall": 44906, "\u0120calming": 44907, "izens": 44908, "Struct": 44909, "\u0120Witches": 44910, "\u0120Celebration": 44911, "\u0120..............": 44912, "ptroller": 44913, "\u0120TCU": 44914, "\u0120bunny": 44915, "\u00e3\u0125\u012f": 44916, "utorial": 44917, "\u0120upscale": 44918, "\u0120Sta": 44919, "\u0120Colossus": 44920, "\u0120chloride": 44921, "\u0120Zac": 44922, "\u0120Reasons": 44923, "\u0120Brookings": 44924, "\u0120WHITE": 44925, "][/": 44926, "\u0120Lose": 44927, "905": 44928, "\u0120underside": 44929, "ernels": 44930, "\u0120vape": 44931, "dozen": 44932, "uppet": 44933, "\u0120STOP": 44934, "matical": 44935, "\u0120Statements": 44936, "heddar": 44937, "PAC": 44938, "Customer": 44939, "\u0120memos": 44940, "\u0120PJ": 44941, "endars": 44942, "\u0120Limits": 44943, "laugh": 44944, "\u0120stabilized": 44945, "\u0120ALEC": 44946, "YA": 44947, "Upgrade": 44948, "alam": 44949, "\u0120techno": 44950, "\u0120anew": 44951, "foreseen": 44952, "\u0120collegiate": 44953, "\u0120Pyro": 44954, "\u0120Dism": 44955, "\u0120frontline": 44956, "\u0120ammonia": 44957, "IU": 44958, "Quite": 44959, "Johnny": 44960, "assin": 44961, "GOP": 44962, "\u0120Styles": 44963, "\u0120Sovereign": 44964, "acterial": 44965, "549": 44966, "\u0120RIP": 44967, "\u0120Lists": 44968, "\u0120364": 44969, "\u0120Recep": 44970, "socket": 44971, "\u0120Byrd": 44972, "\u0120Candle": 44973, "Ancient": 44974, "\u0120appellant": 44975, "enforcement": 44976, "acea": 44977, "anski": 44978, "\u0120olds": 44979, "886": 44980, "\u0120slurs": 44981, "\u0120empires": 44982, "\u0120buckle": 44983, "\u0120alienation": 44984, "\u0120Aberdeen": 44985, "\u0120unicorn": 44986, "\u0120overriding": 44987, "\u0120LX": 44988, "ppa": 44989, "\u0120despised": 44990, "\u0120Bugs": 44991, "\u0120BST": 44992, "Southern": 44993, "533": 44994, "\u0120hallmark": 44995, "\u0120Poster": 44996, "\u0120stemmed": 44997, "\u0120principals": 44998, "\u0120TECH": 44999, "\u0120Sandwich": 45000, "Italy": 45001, "\u0120cheesy": 45002, "\u0120SetTextColor": 45003, "\u0120Protective": 45004, "\u0120Cohn": 45005, "JO": 45006, "aptop": 45007, "Reason": 45008, "Leader": 45009, "\u0120Understand": 45010, "\u0120Fridays": 45011, "\u0120Continuous": 45012, "\u0120clipping": 45013, "\u0120Rye": 45014, "\u0120berth": 45015, "timer": 45016, "annis": 45017, "react": 45018, "\u0120buffalo": 45019, "\u0120Paras": 45020, "\u0120655": 45021, "\u0120presided": 45022, "\u0120Sunrise": 45023, "\u0120vets": 45024, "\u0120cloves": 45025, "\u0120McCull": 45026, "Strength": 45027, "GAN": 45028, "\u0120illiter": 45029, "\u0120Pricing": 45030, "l\u00c3\u00a9": 45031, "\u0120resistor": 45032, "\u0120brun": 45033, "\u0120Suffolk": 45034, "\u00d1\u012d": 45035, "\u0120Liver": 45036, "Released": 45037, "\u0120whats": 45038, "860": 45039, "\u0120Measures": 45040, "\u0120denouncing": 45041, "\u0120Ryzen": 45042, "\u0120souven": 45043, "\u0120caregivers": 45044, "chini": 45045, "\u0120Scarlett": 45046, "\u0120trough": 45047, "Congratulations": 45048, "\u0120taxis": 45049, "\u0120Tradition": 45050, "jit": 45051, "\u0120tabletop": 45052, "\u0120hitherto": 45053, "\u0120disinformation": 45054, "offensive": 45055, "hra": 45056, "\u0120DISTRICT": 45057, "\u0120complicate": 45058, "chenko": 45059, "\u0120Reconstruction": 45060, "\u0120palpable": 45061, "\u0120ausp": 45062, "\u0120428": 45063, "\u0120showcases": 45064, "\u0120Publication": 45065, "knowledge": 45066, "innon": 45067, "419": 45068, "\u0120retrieval": 45069, "anders": 45070, "\u0120refute": 45071, "\u0120inquired": 45072, "gur": 45073, "\u0120negativity": 45074, "\u0120conserve": 45075, "\u0120afterlife": 45076, "\u0120presupp": 45077, "\u0120Gillespie": 45078, "\u0120mt": 45079, "\u0120DN": 45080, "Tap": 45081, "\u0120perpend": 45082, "\u0120Smy": 45083, "doesn": 45084, "\u0120spilling": 45085, "\u0120hypers": 45086, "Kate": 45087, "\u00c2\u00ae,": 45088, "kept": 45089, "\u0120Powered": 45090, "\u0120ja": 45091, "\u0120Klux": 45092, "arde": 45093, "aban": 45094, "\u0120444": 45095, "\u0120flattened": 45096, "\u0120Improvements": 45097, "urga": 45098, "\u0120Kund": 45099, "\u0120inscribed": 45100, "\u0120facult": 45101, "\u0120unprepared": 45102, "\u0120Consumers": 45103, "\u0120satisfies": 45104, "\u0120pulmonary": 45105, "\u0120infiltration": 45106, "\u0120externally": 45107, "\u0120congratulations": 45108, "aghan": 45109, "\u0120airliner": 45110, "\u0120flung": 45111, "\u0120flyers": 45112, "GD": 45113, "\u0120snippets": 45114, "\u0120recursive": 45115, "\u0120mastering": 45116, "Lex": 45117, "\u0120overtly": 45118, "vg": 45119, "\u0120luckily": 45120, "\u0120encro": 45121, "\u0120Lancet": 45122, "\u0120Abyssal": 45123, "functional": 45124, "\u0120sow": 45125, "\u0120squid": 45126, "\u0120narration": 45127, "\u0120naughty": 45128, "\u0120Honour": 45129, "\u0120Spartans": 45130, "\u0120shatter": 45131, "\u0120Tacoma": 45132, "\u0120Calories": 45133, "\u0120Races": 45134, "Submit": 45135, "\u0120purposefully": 45136, "wav": 45137, "\u0120Yok": 45138, "Fest": 45139, "\u0120Gerr": 45140, "Metro": 45141, "\u0120itiner": 45142, "famous": 45143, "\u0120\"{": 45144, "inline": 45145, "washer": 45146, "Issue": 45147, "\u0120CLIENT": 45148, "ozo": 45149, "Versions": 45150, "725": 45151, "\u0120Glock": 45152, "\u0120shielded": 45153, "\u0120PCR": 45154, "ENCY": 45155, "\u0120Weld": 45156, "\u0120Simpl": 45157, "\u0120redirected": 45158, "\u0120Kham": 45159, "\u0120(>": 45160, "\u0120labou": 45161, "\u0120diapers": 45162, "ssl": 45163, "\u0120cellar": 45164, "organisms": 45165, "oresc": 45166, "\u0120Berks": 45167, "didn": 45168, "Shipping": 45169, "Chest": 45170, "\u0120undone": 45171, "\u0120millionaire": 45172, "\u0120cords": 45173, "\u0120Younger": 45174, "appropriately": 45175, "\u0120sequels": 45176, "uve": 45177, "anticipated": 45178, "\u0120lewd": 45179, "\u0120Shirt": 45180, "\u0120Dmitry": 45181, "Veter": 45182, "\u0120slaying": 45183, "\u0120Yar": 45184, "\u0120complication": 45185, "Iowa": 45186, "\u0120Erica": 45187, "\u0120BLM": 45188, "girlfriend": 45189, "bodied": 45190, "626": 45191, "1963": 45192, "\u0120intermediary": 45193, "\u0120consolation": 45194, "Mask": 45195, "\u0120Siem": 45196, "owan": 45197, "Beginning": 45198, "\u0120fixme": 45199, "\u0120culminated": 45200, "\u0120conduc": 45201, "\u0120Volunteer": 45202, "\u0120positional": 45203, "\u0120greets": 45204, "\u0120Definitions": 45205, "\u0120thinker": 45206, "\u0120ingenuity": 45207, "\u0120freshmen": 45208, "\u0120Moments": 45209, "\u0120357": 45210, "ateurs": 45211, "\u0120FedEx": 45212, "sg": 45213, "694": 45214, "\u0120dwindling": 45215, "\u0120BOX": 45216, "selage": 45217, "\u0120tmp": 45218, "\u0120sten": 45219, "\u0120Sut": 45220, "\u0120neighbourhoods": 45221, "\u0120classmate": 45222, "fledged": 45223, "\u0120leftists": 45224, "\u0120climates": 45225, "ATHER": 45226, "\u0120Scythe": 45227, "uliffe": 45228, "\u0120sag": 45229, "\u0120hopped": 45230, "\u0120Ft": 45231, "\u0120Eck": 45232, "\u0120CK": 45233, "\u0120Doomsday": 45234, "kids": 45235, "\u0120gasped": 45236, "\u0120moniker": 45237, "\u0120Lod": 45238, "\u0120CFL": 45239, "tions": 45240, "rums": 45241, "folios": 45242, "\u0120md": 45243, "\u0120uncanny": 45244, "\u0120transports": 45245, "\u0120Labrador": 45246, "\u0120railways": 45247, "\u0120appliance": 45248, "\u0120CTRL": 45249, "\u00e6\u0122": 45250, "Population": 45251, "\u0120Confederacy": 45252, "\u0120unbearable": 45253, "\u0120dorsal": 45254, "\u0120Inform": 45255, "opted": 45256, "\u0120KILL": 45257, "Marx": 45258, "\u0120hypocritical": 45259, "qus": 45260, "\u0120Numerous": 45261, "\u0120Georgian": 45262, "\u0120Ambrose": 45263, "\u0120Loch": 45264, "\u0120gubernatorial": 45265, "\u0120Xeon": 45266, "\u0120Supports": 45267, "enser": 45268, "eely": 45269, "\u0120Avenger": 45270, "1965": 45271, "Army": 45272, "\u0120juxtap": 45273, "\u0120chopping": 45274, "\u0120Splash": 45275, "\u0120Sustainable": 45276, "\u0120Finch": 45277, "\u01201861": 45278, "ictive": 45279, "atmeal": 45280, "\u0120Gohan": 45281, "\u0120lightsaber": 45282, "\u0120GPA": 45283, "ugu": 45284, "\u0120REPL": 45285, "variable": 45286, "\u0120herpes": 45287, "\u0120deserts": 45288, "aciously": 45289, "\u0120situational": 45290, "weekly": 45291, "obl": 45292, "\u0120textile": 45293, "\u0120Cornwall": 45294, "\u0120contraceptives": 45295, "\u0120Ake": 45296, "]-": 45297, "\u00e4\u00b9\u012d": 45298, ":,": 45299, "\u0120Wem": 45300, "\u0120Bihar": 45301, "\u0120'.": 45302, "\u0120bere": 45303, "\u0120analogue": 45304, "\u0120Cookies": 45305, "\u0120takeoff": 45306, "Wheel": 45307, "\u0120majestic": 45308, "\u0120commuting": 45309, "023": 45310, "\u0120Corpse": 45311, "assment": 45312, "mini": 45313, "\u0120gorilla": 45314, "\u0120Alas": 45315, "eree": 45316, "\u0120acquaintances": 45317, "\u0120Advantage": 45318, "\u0120spiritually": 45319, "\u0120eyed": 45320, "pmwiki": 45321, "\u0120Ender": 45322, "\u0120translucent": 45323, "\u0120nighttime": 45324, "\u0120IMAGES": 45325, "545": 45326, "\u0120Kamp": 45327, "\u0120Freak": 45328, "\u0120ig": 45329, "Portland": 45330, "432": 45331, "\u0120Mata": 45332, "\u0120marines": 45333, "\u0120hors": 45334, "aterasu": 45335, "\u0120Attribution": 45336, "\u0120---------": 45337, "\u0120kins": 45338, "\u0120BELOW": 45339, "+++": 45340, "\u0120reeling": 45341, "oled": 45342, "\u0120clutter": 45343, "\u0120Relative": 45344, "\u0120427": 45345, "BUS": 45346, "\u0120avert": 45347, "\u0120Cheong": 45348, "\u0120Able": 45349, "\u0120Pryor": 45350, "Developer": 45351, "\u0120encyclopedia": 45352, "\u0120USAF": 45353, "\u0120Garry": 45354, "Spain": 45355, "Blocks": 45356, "\u0120exposition": 45357, "\u0120GamerGate": 45358, "WOR": 45359, "\u0120stockpile": 45360, "\u0120clothed": 45361, "\u0120Tone": 45362, "\u0120Rue": 45363, "tumblr": 45364, "\u0120treacherous": 45365, "\u0120frying": 45366, "\u00d1\u012e": 45367, "\u0120Sph": 45368, "\u0120restraints": 45369, "\u0120embodies": 45370, "\u0120Ges": 45371, "Safety": 45372, "\u0120negotiators": 45373, "mining": 45374, "\u0120Appalachian": 45375, "LOS": 45376, "\u0120Jenna": 45377, "\u0120passers": 45378, "\u00e7\u012d": 45379, "snap": 45380, "\u0120shorten": 45381, "creator": 45382, "\u0120innumerable": 45383, "utherland": 45384, "674": 45385, "\u0120WOM": 45386, "\u0120Ascend": 45387, "\u0120Armory": 45388, "\u0120Transaction": 45389, "Kick": 45390, "\u0120suitcase": 45391, "dayName": 45392, "\u0120wasteful": 45393, "marriage": 45394, "\u0120McCabe": 45395, "itech": 45396, "\u0120Oss": 45397, "Closure": 45398, "\u0120Treasurer": 45399, "\u0120indecent": 45400, "\u0120Dull": 45401, "\u0120residences": 45402, "1959": 45403, "\u0120Settlement": 45404, "Hamilton": 45405, "\u0120selfies": 45406, "\u0120Ranking": 45407, "\u0120Barkley": 45408, "\u0120Bore": 45409, "\u0120WCS": 45410, "\u0120Maritime": 45411, "\u0120Huh": 45412, "\u0120Forestry": 45413, "\u0120cultivating": 45414, "\u0120Ballard": 45415, "\u0120garrison": 45416, "\u0120SDL": 45417, "930": 45418, "\u0120nascent": 45419, "\u0120irresistible": 45420, "\u0120awfully": 45421, "\\/\\/": 45422, "\u0120equate": 45423, "\u0120anthropology": 45424, "\u0120Sylvia": 45425, "\u0120intestine": 45426, "\u0120innocuous": 45427, "cessive": 45428, "agra": 45429, "\u0120Metroid": 45430, "Grant": 45431, "855": 45432, "\u0123\u0138": 45433, "\u0120\"_": 45434, "\u00e3\u0125\u0125\u00e3\u0125\u012b": 45435, "\u0120appraisal": 45436, "\u0120Freddy": 45437, "046": 45438, "\u0120406": 45439, "\u01201830": 45440, "\u0120docking": 45441, "Static": 45442, "\u0120pont": 45443, "\u0120Voltage": 45444, "\u0120Stead": 45445, "\u0120Mortgage": 45446, "\u0120Jonah": 45447, "YL": 45448, "CLASSIFIED": 45449, "\u0120asbestos": 45450, "nikov": 45451, "\u0120collagen": 45452, "\u0120Orbital": 45453, "Pocket": 45454, "799": 45455, "\u0120hybrids": 45456, "inches": 45457, "\u0120invoice": 45458, "undy": 45459, "\u0120inequalities": 45460, "Trend": 45461, "washed": 45462, "BALL": 45463, "\u0120lucid": 45464, "\u0120Commentary": 45465, "\u0120witty": 45466, "Brandon": 45467, "\u0120bruising": 45468, "\u0120620": 45469, "escent": 45470, "boxing": 45471, "POL": 45472, "\u0120378": 45473, "Rect": 45474, "\u0120licences": 45475, "\u0120McGee": 45476, "pressed": 45477, "Danny": 45478, "\u0120jammed": 45479, "ordinate": 45480, "\u0120leth": 45481, "\u0120distinguishes": 45482, "\u0120Yamaha": 45483, "ILS": 45484, "\u0120Hume": 45485, "\u0120Categories": 45486, "Roberts": 45487, "Chart": 45488, "\u0120beetle": 45489, "\u0120Graveyard": 45490, "\u0120($)": 45491, "o\u00c4\u0141": 45492, "\u0120twilight": 45493, "arella": 45494, "\u00e1\u00bd": 45495, "\u0120booths": 45496, "\u0120HHS": 45497, "\u0120Feldman": 45498, "\u0120excavation": 45499, "\u0120philosophies": 45500, "atography": 45501, "\u0120Garage": 45502, "technology": 45503, "\u0120unforgettable": 45504, "\u0120verifying": 45505, "\u0120subordinates": 45506, "Els": 45507, "\u0120neb": 45508, "Gaming": 45509, "ENA": 45510, "\u0120Achievement": 45511, "itters": 45512, "\u0120Gabe": 45513, "\u0120dumps": 45514, "forcer": 45515, "\u0120poignant": 45516, "\u0120MBA": 45517, "\u0120Heidi": 45518, "imei": 45519, "\u0120mages": 45520, "\u0120liberate": 45521, "\u0120circumcised": 45522, "\u0120Mermaid": 45523, "\u0120Matth": 45524, "together": 45525, "\u0120Wichita": 45526, "\u0120storefront": 45527, "\u0120Adin": 45528, "VII": 45529, "Fourth": 45530, "\u0120explorers": 45531, "WER": 45532, "Notable": 45533, "Brook": 45534, "mens": 45535, "Faith": 45536, "---------": 45537, "\u0120Jou": 45538, "\u00ac\u00bc": 45539, "\u0120pineapple": 45540, "\u0120amalg": 45541, "eln": 45542, "arkable": 45543, "\u0120\u00e3\u0124\u00b5\u00e3\u0125\u00bc\u00e3\u0125\u0128\u00e3\u0124\u00a3": 45544, "\u0120\u00e3\u0124\u00b5\u00e3\u0125\u00bc\u00e3\u0125\u0128\u00e3\u0124\u00a3\u00e3\u0125\u00af\u00e3\u0125\u00b3": 45545, "\u0120ovarian": 45546, "\u0120Echoes": 45547, "\u0120haircut": 45548, "\u0120pav": 45549, "\u0120chilled": 45550, "anasia": 45551, "\u0120styled": 45552, "\u0120dab": 45553, "niper": 45554, "\u0120ministerial": 45555, "\u0120DUP": 45556, "Tan": 45557, "\u0120sulph": 45558, "\u0120Deter": 45559, "\u0120Bohem": 45560, "odan": 45561, "\u0120educator": 45562, "\u00e2\u0135\u013a": 45563, "spir": 45564, "Chicken": 45565, "\u0120Eleanor": 45566, "\u0120qui": 45567, "\u0120heaviest": 45568, "\u0120grasped": 45569, "URA": 45570, "\u0120crooked": 45571, "Jessica": 45572, "problem": 45573, "\u0120predetermined": 45574, "\u0120maniac": 45575, "\u0120breaths": 45576, "\u0120Lauderdale": 45577, "\u0120hobbies": 45578, "yz": 45579, "Crime": 45580, "\u0120charisma": 45581, "dL": 45582, "\u0120leaping": 45583, "\u0120kittens": 45584, "Angelo": 45585, "\u0120JACK": 45586, "\u0120Suzanne": 45587, "\u0120halting": 45588, "ENTION": 45589, "\u0120swallowing": 45590, "\u0120Earthquake": 45591, "\u0120eighteenth": 45592, "\u0120NIC": 45593, "\u0120INF": 45594, "\u0120Conscious": 45595, "\u0120particulars": 45596, "circle": 45597, "740": 45598, "\u0120benevolent": 45599, "\u0120747": 45600, "\u0120490": 45601, "\u0120rundown": 45602, "\u0120Valerie": 45603, "\u0120BUR": 45604, "\u0120civilisation": 45605, "\u0120Schn": 45606, "WB": 45607, "otide": 45608, "international": 45609, "\u0120john": 45610, "\u01201902": 45611, "\u0120peanuts": 45612, "\u0120flavored": 45613, "kus": 45614, "\u0120roared": 45615, "\u0120cutoff": 45616, "\u00e9\u00a3": 45617, "\u0120ornament": 45618, "\u0120architectures": 45619, "\u0120369": 45620, "olor": 45621, "\u0120Wilde": 45622, "\u0120CRC": 45623, "\u0120Adjusted": 45624, "\u0120provoking": 45625, "landish": 45626, "\u0120rationality": 45627, "\u0120justifies": 45628, "\u0120dispel": 45629, "\u0120americ": 45630, "\u0120Poles": 45631, "\u00d8\u00a9": 45632, "\u0120envis": 45633, "\u0120Doodle": 45634, "\u00e4\u00bd\u00bf": 45635, "igsaw": 45636, "auldron": 45637, "Technical": 45638, "Teen": 45639, "uphem": 45640, "\u0120Xiang": 45641, "\u0120detractors": 45642, "\u0120Zi": 45643, "\u0120Journalists": 45644, "\u0120conducive": 45645, "\u0120Volunteers": 45646, "\u0120sd": 45647, "Knowing": 45648, "\u0120transmissions": 45649, "\u0120PLAN": 45650, "\u0120LIB": 45651, "\u0120alluded": 45652, "\u0120obe": 45653, "\u0120dope": 45654, "\u0120Goldstein": 45655, "\u0120wavelengths": 45656, "\u0120Destination": 45657, "nda": 45658, "ugi": 45659, "\u0120attentive": 45660, "\u0120Lean": 45661, "raltar": 45662, "\u0120mang": 45663, "mbuds": 45664, "akings": 45665, "bender": 45666, "\u0120accol": 45667, "\u0120crawled": 45668, "NOW": 45669, "Minnesota": 45670, "\u0120flourished": 45671, "\u0120Zup": 45672, "\u0120Supervisor": 45673, "\u0120Olivier": 45674, "Excellent": 45675, "\u0120widen": 45676, "Done": 45677, "\u0120wig": 45678, "\u0120misconceptions": 45679, "Corp": 45680, "Wan": 45681, "\u0120venerable": 45682, "\u0120Notably": 45683, "\u0120Klingon": 45684, "animate": 45685, "Boost": 45686, "\u0120SAY": 45687, "missing": 45688, "ibliography": 45689, "melon": 45690, "\u0120payday": 45691, "\u00d8\u00b3": 45692, "bole": 45693, "\u0120veiled": 45694, "\u0120Alphabet": 45695, "Italian": 45696, "\u0120everlasting": 45697, "\u0120RIS": 45698, "\u0120Cree": 45699, "rompt": 45700, "\u0120hating": 45701, "\u0120grinning": 45702, "\u0120geographically": 45703, "OSH": 45704, "\u0120weeping": 45705, "\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142\u0120\u00c2\u0142": 45706, "\u0120impecc": 45707, "Letter": 45708, "\u0120bloated": 45709, "PLA": 45710, "\u0120Fein": 45711, "\u0120persever": 45712, "Thunder": 45713, "\u0120aur": 45714, "\u0120RL": 45715, "\u0120pitfalls": 45716, "\u00e2\u0138\u00ba": 45717, "\u0120predominant": 45718, "\u0120525": 45719, "718": 45720, "APE": 45721, "714": 45722, "\u0120farmland": 45723, "\u0120Qiao": 45724, "\u0120violet": 45725, "\u0120Bahamas": 45726, "\u0120inflicting": 45727, "\u0120Efficiency": 45728, "\u0120homebrew": 45729, "\u0120undertook": 45730, "\u0120curly": 45731, "\u0120Harding": 45732, "mania": 45733, "596": 45734, "\u0120tempered": 45735, "\u0120harrowing": 45736, "\u0120Pledge": 45737, "\u0120Frankenstein": 45738, "\u00e8\u00aa": 45739, "Motion": 45740, "\u0120predictably": 45741, "\u0120Explosion": 45742, "ocusing": 45743, "erd": 45744, "colo": 45745, "FFER": 45746, "\u0120backfield": 45747, "\u0120VIDE": 45748, "uebl": 45749, "Narr": 45750, "\u0120Argument": 45751, "\u0120genomic": 45752, "\u0120boutique": 45753, "\u0120batted": 45754, "\u0120Binary": 45755, "\u0120gamb": 45756, "\u0120Rhythm": 45757, "673": 45758, "\u0120afloat": 45759, "\u0120Olympia": 45760, "YING": 45761, "\u0120endif": 45762, "isin": 45763, "\u0120winters": 45764, "\u0120scattering": 45765, "Iv": 45766, "Distance": 45767, "\u0120tru": 45768, "\u0120Comfort": 45769, "\u0120nexus": 45770, "\u0120airflow": 45771, "\u0120Byzantine": 45772, "payers": 45773, "coni": 45774, "\u0120Betsy": 45775, "Deal": 45776, "\u0120Nug": 45777, "\u0120Continent": 45778, "redibly": 45779, "\u0120optimizing": 45780, "albeit": 45781, "\u0120ecstatic": 45782, "\u0120Proto": 45783, "\u00e7\u00b7": 45784, "ivot": 45785, "\u00e2\u0138\u0126": 45786, "emp": 45787, "rounder": 45788, "\u0120clout": 45789, "\u0120IST": 45790, "663": 45791, "\u0120Dollars": 45792, "\u0120DAC": 45793, "\u0120subscribed": 45794, "\u0120rehearsal": 45795, "\u0120amps": 45796, "\u0120Shang": 45797, "esm": 45798, "\u0120sprinkle": 45799, "\u0120assailant": 45800, "\u0120Oo": 45801, "\u0120Coinbase": 45802, "Tact": 45803, "\u0120retina": 45804, "\u0120nuns": 45805, "RON": 45806, "atto": 45807, "\u0120jug": 45808, "\u0120SVG": 45809, "\u0120bikini": 45810, "\u0120FILE": 45811, "\u0120Founders": 45812, "eport": 45813, "\u0120KP": 45814, "\u0120restores": 45815, "\u0120Thick": 45816, "\u0120ashore": 45817, "\u0120approvals": 45818, "Render": 45819, "MAG": 45820, "Graham": 45821, "\u0120Cortana": 45822, "\u00e3\u0125\u00b3\u00e3\u0124\u00b8": 45823, "ssh": 45824, "orians": 45825, "arsity": 45826, "\u0120Inspired": 45827, "upper": 45828, "\u0120signalling": 45829, "\u0120rebuke": 45830, "\u0120flares": 45831, "\u0120downtime": 45832, "Studies": 45833, "\u0120stagnation": 45834, "\u0120Sequence": 45835, "\u0120grunt": 45836, "\u0120assures": 45837, "\u0120PLA": 45838, "592": 45839, "\u0120intraven": 45840, "depend": 45841, "Susan": 45842, "\u0120Manziel": 45843, "Mania": 45844, "Contract": 45845, "\u0120slams": 45846, "\u0120cultured": 45847, "\u0120creditor": 45848, "LIST": 45849, "\u0120HUM": 45850, "\u0120Chattanooga": 45851, "served": 45852, "\u0120cloaked": 45853, "\u0120FTP": 45854, "powder": 45855, "\u0120Stella": 45856, "uctive": 45857, "\u0120cheaply": 45858, "\u0120MUCH": 45859, "\u0120Galileo": 45860, "\u0120suites": 45861, "speech": 45862, "\u0120deliberations": 45863, "\u0120Chips": 45864, "\u00ab\u013a": 45865, "Balance": 45866, "\u0120Wynne": 45867, "\u0120Akron": 45868, "Asset": 45869, "\u0120honoured": 45870, "\u0120edged": 45871, "Likewise": 45872, "animous": 45873, "\u0120Wage": 45874, "\u0120Ezek": 45875, "advertisement": 45876, "\u0120RTX": 45877, "\u0120MAD": 45878, "\u0120migrating": 45879, "\u0120SQU": 45880, "\u0120475": 45881, "Edited": 45882, "\u0120shorthand": 45883, "\u0120Basics": 45884, "\u0120crotch": 45885, "\u0120EVEN": 45886, "\u0120vm": 45887, "efficiency": 45888, "\u0120calves": 45889, "\u0120Frie": 45890, "\u0120Brilliant": 45891, "\u0120strikers": 45892, "\u0120repentance": 45893, "\u0120arteries": 45894, "rl": 45895, "Bed": 45896, "hap": 45897, "\u0120cryptography": 45898, "\u0120Sabres": 45899, "\u0120414": 45900, "viks": 45901, "ihara": 45902, "apses": 45903, "Talking": 45904, "\u0120intertwined": 45905, "\u0120docks": 45906, "\u0120allele": 45907, "\u0120Artifact": 45908, "\u0120HIM": 45909, "torn": 45910, "\u00e7\u0137": 45911, "\u0120opacity": 45912, "\u0120Ely": 45913, "osuke": 45914, "\u0120nipple": 45915, "\u0120handwritten": 45916, "\u0120VK": 45917, "\u0120Chamberlain": 45918, "\u0120Laos": 45919, "igraph": 45920, "grow": 45921, "\u0120trillions": 45922, "\u0120descendant": 45923, "\u0120Sailor": 45924, "asuring": 45925, "\u0120ceilings": 45926, "\u0120Warehouse": 45927, "flying": 45928, "\u0120Glow": 45929, "\u0120nont": 45930, "\u0120miscarriage": 45931, "\u0120rigs": 45932, "\u0120ministries": 45933, "\u0120elaborated": 45934, "\u0120delusional": 45935, "\u0120Humane": 45936, "\u0120379": 45937, "nets": 45938, "\u0120blackout": 45939, "adders": 45940, "\u0120np": 45941, "\u0120Tire": 45942, "rosc": 45943, "\u0120subdiv": 45944, "\u0120linkage": 45945, "\u0120chronological": 45946, "\u0120HERO": 45947, "\u0120resettlement": 45948, "\u0120Vinyl": 45949, "\u0120pastoral": 45950, "\u0120Mobil": 45951, "\u0120Barbar": 45952, "Cooldown": 45953, "\u0120Fritz": 45954, "criminal": 45955, "repe": 45956, "\u0120bellig": 45957, "\u0120Breed": 45958, "\u0120418": 45959, "\u0120semblance": 45960, "ijk": 45961, "\u0120curtail": 45962, "\u0120clinch": 45963, "contained": 45964, "\u0120Prompt": 45965, "aston": 45966, "\u0120wi": 45967, "\u0120pursuits": 45968, "515": 45969, "\u0120Gloss": 45970, "\u0120flips": 45971, "\u0120coupons": 45972, "\u0120cloning": 45973, "\u0120Likely": 45974, "Removed": 45975, "\u0120Quartz": 45976, "rices": 45977, "\u0120Spears": 45978, "\u0120pious": 45979, "\u0120depreciation": 45980, "\u0120Dare": 45981, "ounces": 45982, "amaz": 45983, "Ont": 45984, "\u0120pinnacle": 45985, "docker": 45986, "026": 45987, "\u0120Wyr": 45988, "\u0120Proper": 45989, "\u00cb\u012a": 45990, "nil": 45991, "Bytes": 45992, "\u0120seeker": 45993, "trial": 45994, "\u0120unfolds": 45995, "\u0120Marse": 45996, "\u0120extravagant": 45997, "\u0120Survivors": 45998, "REDACTED": 45999, "\u0120Speedway": 46000, "\u0120Craigslist": 46001, "submit": 46002, "\u0120Generations": 46003, "\u0120upholding": 46004, "\u0120bloodstream": 46005, "\u0120Missions": 46006, "\u0120Lawn": 46007, "\u0120limbo": 46008, "enei": 46009, "Huh": 46010, "\u0120Wildcats": 46011, "prep": 46012, "\u0120Markus": 46013, "\u0120Forbidden": 46014, "ritic": 46015, "INO": 46016, "\u0120exhibiting": 46017, "requent": 46018, "chuk": 46019, "\u0120habitual": 46020, "\u0120Compatibility": 46021, "Drag": 46022, "RIPT": 46023, "ujah": 46024, "GROUND": 46025, "\u0120delinquent": 46026, "\u0120burner": 46027, "\u0120contemporaries": 46028, "\u0120gimmick": 46029, "loads": 46030, "\u0120nozzle": 46031, "podcast": 46032, "\u0120Wak": 46033, "\u0120Staten": 46034, "\u0120Kuh": 46035, "\u00e3\u0123\u0135": 46036, "interrupted": 46037, "\u0120invincible": 46038, "\u0120Burnett": 46039, "cigarette": 46040, "\u0120Pebble": 46041, "\u0120Temporary": 46042, "\u0120Marino": 46043, "582": 46044, "\u0120wasteland": 46045, "idently": 46046, "Tx": 46047, "\u0120rite": 46048, "\u0120Panasonic": 46049, "\u0120Middles": 46050, "\u0120Horton": 46051, "aeus": 46052, "\u0120curing": 46053, "\u0120mats": 46054, "\u0120adjourn": 46055, "\u0120fearsome": 46056, "pez": 46057, "boats": 46058, "\u0120propell": 46059, "\u0120conflicted": 46060, "\u0120Anger": 46061, "\u0120insurgent": 46062, "Karl": 46063, "\u0120coales": 46064, "\u0120southwestern": 46065, "\u0120dissu": 46066, "\u0120Overt": 46067, "************": 46068, "\u0120boxed": 46069, "\u0120Brune": 46070, "aaa": 46071, "\u0120gardening": 46072, "\u0120Engel": 46073, "tracks": 46074, "\u0120purified": 46075, "\u0120placeholder": 46076, "\u0120Likes": 46077, "\u0120dan": 46078, "Gab": 46079, "\u0120ect": 46080, "\u0120Faw": 46081, "\u0120Eliot": 46082, "\u0120',": 46083, "otropic": 46084, "\u0120Ruin": 46085, "hedon": 46086, "\u0120caul": 46087, "\u0120aft": 46088, "\u0120Cadillac": 46089, "gha": 46090, "assian": 46091, "udeb": 46092, "\u0120Tick": 46093, "\u0120adjusts": 46094, "ARGET": 46095, "537": 46096, "ische": 46097, "anty": 46098, "\u0120Friedrich": 46099, "\u0120Blizz": 46100, "\u0120AOL": 46101, "Campaign": 46102, "\u0120mammal": 46103, "\u0120Veil": 46104, "\u0120Kev": 46105, "\u0120Maurit": 46106, "\u0120Damien": 46107, "Nation": 46108, "Eastern": 46109, "\u0120{:": 46110, "\u0120=================================": 46111, "\u0120stereotypical": 46112, "\u0120attic": 46113, "\u0120Cyborg": 46114, "require": 46115, "\u0120awarding": 46116, "\u0120Papua": 46117, "btn": 46118, "bent": 46119, "Boo": 46120, "\u0120(=": 46121, "\u0120Xander": 46122, "\u0120Somerset": 46123, "\u0120catchy": 46124, "\u0120certify": 46125, "STRUCT": 46126, "\u0120ital": 46127, "\u0120tides": 46128, "\u0120Brands": 46129, "Gray": 46130, "competitive": 46131, "\u0120curator": 46132, "\u0120DG": 46133, "ominium": 46134, "\u0120GMOs": 46135, "ciating": 46136, "\u0120Carmen": 46137, "oward": 46138, "Baltimore": 46139, "\u0120rgb": 46140, "Cu": 46141, "\u0120wipes": 46142, "spell": 46143, "ITNESS": 46144, "\u0120summarizes": 46145, "\u0120Revis": 46146, "\u0120whistleblowers": 46147, "\u0120Breach": 46148, "\u0120crochet": 46149, "kos": 46150, "ewski": 46151, "\u0120repet": 46152, "\u0120crimson": 46153, "\u0120Karachi": 46154, "readable": 46155, "dimension": 46156, "\u0120Igor": 46157, "ilded": 46158, "\u0120Zed": 46159, "\u0120Keane": 46160, "\u0120Cosmetic": 46161, "DEP": 46162, "\u0120retreating": 46163, "\u0120UA": 46164, "ensical": 46165, "\u0120dusk": 46166, "\u0120Dickens": 46167, "\u0120arenas": 46168, "\u0120Passage": 46169, "levels": 46170, "\u0120curv": 46171, "Pope": 46172, "\u0120chores": 46173, "\u0120Elise": 46174, "\u0120Compass": 46175, "bub": 46176, "\u0120mammalian": 46177, "\u0120Sanskrit": 46178, "\u0120ANC": 46179, "\u0120Crack": 46180, "Qual": 46181, "Laun": 46182, "ampunk": 46183, "\u0120learners": 46184, "\u0120glamorous": 46185, "\u0120furthe": 46186, "ermott": 46187, "cand": 46188, "Generic": 46189, "\u0120narrated": 46190, "\u0120disorderly": 46191, "\u0120Transactions": 46192, "\u0120Detention": 46193, "\u0120Roku": 46194, "\u00c4\u012f": 46195, "\u0120understatement": 46196, "\u0120Saur": 46197, "\u0120Rodrigo": 46198, "\u0120ASAP": 46199, "Sin": 46200, "\u0120rejoice": 46201, "Methods": 46202, "\u0120electrode": 46203, "\u0120worshipped": 46204, "\u0120idi": 46205, "\u0120Physicians": 46206, "\u0120popup": 46207, "\u0120deft": 46208, "\u0120Removal": 46209, "\u0120Buenos": 46210, "verbs": 46211, "\u0120funk": 46212, "usha": 46213, "riction": 46214, "orea": 46215, "\u0120Bangalore": 46216, "\u0120Kenobi": 46217, "zzi": 46218, "\u0120normative": 46219, "\u0120goblins": 46220, "\u0120cafes": 46221, "\u0120UNCLASSIFIED": 46222, "\u0120Fired": 46223, "SIGN": 46224, "\u0120sclerosis": 46225, "\u0120Voter": 46226, "\u0120Sonny": 46227, "\u0120Extend": 46228, "\u0120EVs": 46229, "Arsenal": 46230, "\u0120psi": 46231, "\u0120widest": 46232, "\u0120Tus": 46233, "\u0120looms": 46234, "\u0120justifying": 46235, "\u0120Granger": 46236, "\u00e8\u00af": 46237, "Refer": 46238, "583": 46239, "\u0120flourishing": 46240, "abre": 46241, "\u0120rave": 46242, "\u0120Contra": 46243, "\u01201898": 46244, "Adds": 46245, "\u0120ful": 46246, "\u0120Cooke": 46247, "someone": 46248, "=#": 46249, "671": 46250, "\u0120yak": 46251, "\u0120arte": 46252, "\u0120Miscellaneous": 46253, "\u0120Detection": 46254, "\u0120Clancy": 46255, "\u00e2\u0123": 46256, "assies": 46257, "\u0120valiant": 46258, "\u0120Feminist": 46259, "corruption": 46260, "Vel": 46261, "Pear": 46262, "\u0120succinct": 46263, "\u0120quickest": 46264, "kw": 46265, "\u0120spitting": 46266, "\u0120Libraries": 46267, "\u00e5\u0127\u012b": 46268, "antz": 46269, "Dad": 46270, "\u0120Specifications": 46271, "rupulous": 46272, "andr": 46273, "RESULTS": 46274, "\u0120snowball": 46275, "\u0120predis": 46276, "\u0120Baxter": 46277, "\u0120Nursing": 46278, "\u0120Chaff": 46279, "swe": 46280, "\u0120outage": 46281, "\u0120nesting": 46282, "\u0120notoriety": 46283, "trigger": 46284, "onite": 46285, "jon": 46286, "\u0120fou": 46287, "ooked": 46288, "\u0120Celebrity": 46289, "reality": 46290, "\u0120fatig": 46291, "\u0120hugging": 46292, "\u0120bothers": 46293, "\u0120Panzer": 46294, "\u0120Chandra": 46295, "figured": 46296, "\u0120volts": 46297, "\u0120Clouds": 46298, "\u0120feeble": 46299, "\u0120Curve": 46300, "\u0120Asus": 46301, "786": 46302, "absor": 46303, "\u0120VICE": 46304, "\u0120Hess": 46305, "\u0120manufactures": 46306, "\u0120grizz": 46307, "\u0120Powerful": 46308, "acid": 46309, "\u0120subsections": 46310, "\u0120Krugman": 46311, "\u0120Alps": 46312, "isu": 46313, "\u0120sequest": 46314, "\u0120Ultron": 46315, "\u0120Tinker": 46316, "\u0120Goose": 46317, "\u0120mismatch": 46318, "Attorney": 46319, "\u0120morphology": 46320, "\u0120Sixers": 46321, "uttered": 46322, "\u0120ELECT": 46323, "gran": 46324, "Russell": 46325, "\u0120GSL": 46326, "\u0120fortnight": 46327, "\u0120.)": 46328, "\u0120apostle": 46329, "prone": 46330, "elist": 46331, "Untitled": 46332, "\u0120Implementation": 46333, "istors": 46334, "\u0120tanker": 46335, "\u0120plush": 46336, "\u0120attendants": 46337, "\u0120Tik": 46338, "\u0120Greenwich": 46339, "\u0120Yon": 46340, "\u0120SPL": 46341, "cells": 46342, "untled": 46343, "Solution": 46344, "\u0120Qu\u00c3\u00a9": 46345, "\u0120vacated": 46346, "\u0120uptick": 46347, "\u0120Meridian": 46348, "\u00e6\u0125": 46349, "\u0120Drill": 46350, "925": 46351, "584": 46352, "\u0120renovated": 46353, "\u0120Kubrick": 46354, "zyk": 46355, "\u0120lousy": 46356, "ppel": 46357, "ohydrate": 46358, "\u0120Izzy": 46359, "lesiastical": 46360, "CCC": 46361, "\u0120Ajax": 46362, "\u0120adapters": 46363, "\u0120Petraeus": 46364, "\u0120affirmation": 46365, "\u0120STOR": 46366, "lems": 46367, "adoes": 46368, "\u0120Constantinople": 46369, "\u0120ponies": 46370, "\u0120lighthouse": 46371, "\u0120adherents": 46372, "\u0120Brees": 46373, "omorphic": 46374, "Fighting": 46375, "\u0120plaster": 46376, "\u0120PVC": 46377, "\u0120Obst": 46378, "\u0120dearly": 46379, "\u0120Tooth": 46380, "ickson": 46381, "\u0120shaming": 46382, "Plex": 46383, "Agg": 46384, "\u0120\u00e2\u0122\u00a6\"": 46385, "\u0120subreddits": 46386, "\u0120pigeon": 46387, "\u0120Residential": 46388, "\u0120Passing": 46389, "\u0120lum": 46390, "\u0120Pension": 46391, "\u0120pessimistic": 46392, "\u0120432": 46393, "zinski": 46394, "cade": 46395, "075": 46396, "\u0120apologised": 46397, "iyah": 46398, "Putting": 46399, "\u0120gloomy": 46400, "\u0120Lyme": 46401, "=-=-=-=-=-=-=-=-": 46402, "\u0120Tome": 46403, "\u0120Psychiatric": 46404, "\u0120HIT": 46405, "cms": 46406, "apolog": 46407, "\u0120breaker": 46408, "\u0120deepen": 46409, "\u0120theorist": 46410, "\u0120Highlands": 46411, "\u0120baker": 46412, "\u0120staples": 46413, "\u0120interfered": 46414, "\u0120Abortion": 46415, "joined": 46416, "chu": 46417, "\u0120formulate": 46418, "\u0120vaccinations": 46419, "\u0120banter": 46420, "pheus": 46421, "\u0120outfielder": 46422, "\u0120Meter": 46423, "\u0120#####": 46424, "\u01201895": 46425, "\u0120narrowing": 46426, "\u0120STORY": 46427, "fp": 46428, "\u0120CST": 46429, "ignore": 46430, "\u0120proclaiming": 46431, "\u0120RU": 46432, "\u0120BALL": 46433, "yna": 46434, "653": 46435, "\u0120posit": 46436, "PRE": 46437, "594": 46438, "\u0120Registrar": 46439, "\u0120Pilgrim": 46440, "icio": 46441, "\u0120prett": 46442, "\u0120lifeless": 46443, "\u0120___": 46444, "Neigh": 46445, "\u0120Churches": 46446, "orno": 46447, "\u0120orcs": 46448, "\u0120kindred": 46449, "\u0120Audit": 46450, "\u0120millennial": 46451, "\u0120Persia": 46452, "gravity": 46453, "\u0120Disability": 46454, "\u0120DARK": 46455, "Ws": 46456, "odon": 46457, "\u0120granddaughter": 46458, "\u0120Brooke": 46459, "\u0120ADA": 46460, "ERA": 46461, "\u0120pickups": 46462, "\u0120Wilkinson": 46463, "\u0120Shards": 46464, "\u0120NK": 46465, "\u0120expel": 46466, "\u0120Kislyak": 46467, "\u0120jargon": 46468, "\u0120polarized": 46469, "iane": 46470, "Publisher": 46471, "\u0120rebutt": 46472, "\u0120apprehension": 46473, "\u0120Kessler": 46474, "\u0120prism": 46475, "FUL": 46476, "1964": 46477, "\u0120Loll": 46478, "\u00e4\u00bf": 46479, "lethal": 46480, "\u00c5\u0141": 46481, "\u0120ghetto": 46482, "\u0120boulder": 46483, "\u0120Slowly": 46484, "\u0120Oscars": 46485, "\u0120Instruction": 46486, "\u0120Ultr": 46487, "\u0120Moe": 46488, "Nich": 46489, "\u0120PATH": 46490, "(*": 46491, "\u0120RELEASE": 46492, "uning": 46493, "rouse": 46494, "eneg": 46495, "\u0120reimb": 46496, "\u0120Detected": 46497, "DoS": 46498, "\u0120sterling": 46499, "\u0120aggregation": 46500, "\u0120Lonely": 46501, "\u0120Attend": 46502, "higher": 46503, "\u0120airstrike": 46504, "kson": 46505, "SELECT": 46506, "\u0120deflation": 46507, "\u0120Herrera": 46508, "Cole": 46509, "ritch": 46510, "\u0120advisable": 46511, "Fax": 46512, "\u0120workaround": 46513, "\u0120pid": 46514, "mortem": 46515, "ersen": 46516, "\u0120typo": 46517, "\u0120alum": 46518, "782": 46519, "\u0120Jamal": 46520, "scripts": 46521, "\u0120captives": 46522, "\u0120Presence": 46523, "\u0120Lieberman": 46524, "angelo": 46525, "\u0120alcoholism": 46526, "assi": 46527, "\u0120recite": 46528, "\u0120gaping": 46529, "\u0120baskets": 46530, "\u0120Gou": 46531, "Browser": 46532, "neau": 46533, "\u0120corrective": 46534, "unda": 46535, "scoring": 46536, "\u0120XD": 46537, "\u0120filament": 46538, "\u0120deepening": 46539, "\u0120Stainless": 46540, "Integer": 46541, "\u0120buggy": 46542, "\u0120tenancy": 46543, "\u0120Mubarak": 46544, "\u0120tuple": 46545, "\u0120Droid": 46546, "\u0120Sitting": 46547, "\u0120forfeit": 46548, "\u0120Rasmussen": 46549, "ixties": 46550, "esi": 46551, "\u0120Kimmel": 46552, "\u0120meticulously": 46553, "\u0120apopt": 46554, "\u0120Seller": 46555, "088": 46556, "ecake": 46557, "hematically": 46558, "TN": 46559, "\u0120mindless": 46560, "\u0120digs": 46561, "\u0120Accord": 46562, "onsense": 46563, "eming": 46564, "brace": 46565, "\u0120eBook": 46566, "\u0120Distribut": 46567, "\u0120Investments": 46568, "wt": 46569, "]),": 46570, "behavior": 46571, "563": 46572, "\u0120blinding": 46573, "\u0120Protesters": 46574, "topia": 46575, "\u0120reborn": 46576, "\u0120Kelvin": 46577, "\u0120Dover": 46578, "\u0120Dairy": 46579, "\u0120Outs": 46580, "\u0120[/": 46581, "\u00cf\u0122": 46582, "bp": 46583, "\u0120Vanity": 46584, "\u0120Recap": 46585, "\u0120HOUSE": 46586, "\u0120FACE": 46587, "\u0120422": 46588, "692": 46589, "\u0120Antioch": 46590, "cooked": 46591, "\u0120collide": 46592, "\u0120apr": 46593, "\u0120sleeper": 46594, "\u0120Jarvis": 46595, "\u0120alternatively": 46596, "\u0120Leaves": 46597, "\u0120Maw": 46598, "\u0120antiquity": 46599, "\u0120Adinida": 46600, "\u0120abuser": 46601, "Pok\u00c3\u00a9mon": 46602, "\u0120assorted": 46603, "\u0120Revision": 46604, "\u0120Piano": 46605, "\u0120Gideon": 46606, "Ocean": 46607, "\u0120salon": 46608, "\u0120bustling": 46609, "ognitive": 46610, "\u0120Rahman": 46611, "\u0120waiter": 46612, "\u0120presets": 46613, "\u0120Osh": 46614, "\u0120GHC": 46615, "operator": 46616, "\u0120reptiles": 46617, "\u0120413": 46618, "\u0120Garr": 46619, "\u0120Chak": 46620, "\u0120hashes": 46621, "\u0120failings": 46622, "\u0120folklore": 46623, "\u0120abl": 46624, "\u0120Cena": 46625, "\u0120MacArthur": 46626, "\u0120COURT": 46627, "\u0120periphery": 46628, "appers": 46629, "\u0120reckoned": 46630, "\u0120Influ": 46631, "\u0120CET": 46632, "\u0120372": 46633, "\u0120Definitive": 46634, "assault": 46635, "421": 46636, "\u0120reservoirs": 46637, "\u0120dives": 46638, "\u0120Coil": 46639, "DAQ": 46640, "\u0120vividly": 46641, "\u0120RJ": 46642, "\u0120Bellev": 46643, "\u0120eclectic": 46644, "\u0120Showdown": 46645, "\u0120KM": 46646, "iped": 46647, "reetings": 46648, "\u0120Asuka": 46649, "Liberal": 46650, "\u0120\u00cf\u0126": 46651, "\u0120bystanders": 46652, "\u0120Goodwin": 46653, "ukong": 46654, "Sit": 46655, "\u0120Trem": 46656, "\u0120criminally": 46657, "\u0120Circus": 46658, "chrome": 46659, "887": 46660, "\u0120nanop": 46661, "\u0120Obi": 46662, "\u0120LOW": 46663, "ogh": 46664, "\u0120Authors": 46665, "obyl": 46666, "Urban": 46667, "\u0120ti": 46668, "\u0120Weir": 46669, "trap": 46670, "agy": 46671, "\u0120parentheses": 46672, "\u0120outnumbered": 46673, "\u0120counterproductive": 46674, "\u0120Tobias": 46675, "ubis": 46676, "Parser": 46677, "STAR": 46678, "\u0120synaptic": 46679, "\u0120Gears": 46680, "\u0120hiber": 46681, "\u0120debunked": 46682, "\u0120exalted": 46683, "awatts": 46684, "HOU": 46685, "Church": 46686, "\u0120Pixie": 46687, "\u0120Uri": 46688, "\u0120Formation": 46689, "\u0120Prediction": 46690, "CEO": 46691, "\u0120thrott": 46692, "\u0120Britann": 46693, "\u0120Madagascar": 46694, "\u00eb\u012d": 46695, "\u0120billboards": 46696, "\u0120RPGs": 46697, "\u0120Bees": 46698, "completely": 46699, "FIL": 46700, "\u0120doesnt": 46701, "\u0120Greenberg": 46702, "reys": 46703, "\u0120sling": 46704, "\u0120emptied": 46705, "\u0120Pixar": 46706, "\u0120Dharma": 46707, "luck": 46708, "inguished": 46709, "\u0120endot": 46710, "\u0120babys": 46711, "059": 46712, "chest": 46713, "rats": 46714, "\u0120ridden": 46715, "\u0120beetles": 46716, "\u0120illuminating": 46717, "\u0120fictitious": 46718, "\u0120Provincial": 46719, "\u0120768": 46720, "\u0120shepherd": 46721, "\u0120Render": 46722, "\u01201896": 46723, "Crew": 46724, "\u0120molded": 46725, "\u0120Xiaomi": 46726, "\u0120Spiral": 46727, "\u0120delim": 46728, "\u0120organising": 46729, "\u0120hoops": 46730, "\u0120Bei": 46731, "zhen": 46732, "\u0120fuckin": 46733, "\u0120decad": 46734, "\u0120unbiased": 46735, "ammy": 46736, "swing": 46737, "\u0120smuggled": 46738, "\u0120kios": 46739, "\u0120PERSON": 46740, "\u0120Inquisitor": 46741, "\u0120snowy": 46742, "\u0120scraping": 46743, "\u0120Burgess": 46744, "Ptr": 46745, "agame": 46746, "RW": 46747, "\u0120droid": 46748, "\u0120Lys": 46749, "\u0120Cassandra": 46750, "Jacob": 46751, "\u0120354": 46752, "\u0120pasture": 46753, "\u0120franc": 46754, "\u0120Scotch": 46755, "\u0120Ends": 46756, "\u0120IGF": 46757, "definition": 46758, "\u0120hysterical": 46759, "\u0120Browne": 46760, "771": 46761, "\u0120mobilization": 46762, "\u00e6\u0137": 46763, "iqueness": 46764, "Thor": 46765, "\u0120spearheaded": 46766, "\u0120embroiled": 46767, "\u0120conjecture": 46768, "judicial": 46769, "Choice": 46770, "\u0120paperback": 46771, "Pir": 46772, "\u0120recovers": 46773, "\u0120Surge": 46774, "\u0120Shogun": 46775, "\u0120Pediatrics": 46776, "\u00e3\u0123\u0142": 46777, "\u0120sweeps": 46778, "\u0120Laboratories": 46779, "\u0120Packs": 46780, "alus": 46781, "addin": 46782, "\u0120headlights": 46783, "gra": 46784, "Evidence": 46785, "COLOR": 46786, "Admin": 46787, "\u012c\u00b1": 46788, "\u0120concoct": 46789, "sufficient": 46790, "\u0120unmarked": 46791, "\u0120richness": 46792, "\u0120dissertation": 46793, "\u0120seasoning": 46794, "\u0120gib": 46795, "\u0120Mages": 46796, "unctions": 46797, "\u0120Nid": 46798, "cheat": 46799, "\u0120TMZ": 46800, "citizens": 46801, "\u0120Catholicism": 46802, "nb": 46803, "\u0120disembark": 46804, "\u0120PROGRAM": 46805, "aques": 46806, "Tyler": 46807, "Org": 46808, "\u0120Slay": 46809, "\u0120Nero": 46810, "\u0120Townsend": 46811, "INTON": 46812, "tele": 46813, "\u0120mesmer": 46814, "901": 46815, "\u0120fireball": 46816, "evidence": 46817, "affiliated": 46818, "\u0120Frenchman": 46819, "\u0120Augusta": 46820, "021": 46821, "\u0120sled": 46822, "\u0120reused": 46823, "\u0120Immunity": 46824, "\u0120wrestle": 46825, "assembled": 46826, "Maria": 46827, "\u0120gunshots": 46828, "\u0120Barbie": 46829, "\u0120cannabinoids": 46830, "\u0120Toast": 46831, "\u0120Kinder": 46832, "IRD": 46833, "\u0120rejuven": 46834, "\u0120gore": 46835, "\u0120rupture": 46836, "\u0120breaching": 46837, "\u0120Cartoon": 46838, "\u0120455": 46839, "\u0120Paleo": 46840, "614": 46841, "\u0120spears": 46842, "\u0120Ames": 46843, "abus": 46844, "Madison": 46845, "GROUP": 46846, "\u0120aborted": 46847, "yah": 46848, "\u0120felon": 46849, "\u0120causation": 46850, "\u0120prepaid": 46851, "\u0120pitted": 46852, "oplan": 46853, "\u0120Shelley": 46854, "\u0120Russo": 46855, "\u0120Pagan": 46856, "\u0120willfully": 46857, "\u0120Canaver": 46858, "undrum": 46859, "\u0120Salary": 46860, "\u0120Arpaio": 46861, "reader": 46862, "\u0120Rational": 46863, "\u0120Overse": 46864, "\u0120Causes": 46865, "\u0120*.": 46866, "\u0120wob": 46867, "Keith": 46868, "\u0120Consent": 46869, "manac": 46870, "773": 46871, "623": 46872, "\u0120fateful": 46873, "etimes": 46874, "\u0120spirited": 46875, "\u0120Dys": 46876, "\u0120hegemony": 46877, "\u0120boycot": 46878, "\u0120Enrique": 46879, "emouth": 46880, "\u0120timelines": 46881, "\u0120Sahara": 46882, "\u0120Relax": 46883, "\u0120Quincy": 46884, "\u0120Lessons": 46885, "\u0120EQU": 46886, "SEA": 46887, "NK": 46888, "\u0120Costco": 46889, "Increase": 46890, "\u0120motivating": 46891, "\u0120Chong": 46892, "amaru": 46893, "\u0120Divide": 46894, "\u0120pedigree": 46895, "\u0120Tasmania": 46896, "\u0120Prelude": 46897, "Las": 46898, "940": 46899, "574": 46900, "\u0120chau": 46901, "\u0120Spiegel": 46902, "unic": 46903, "-->": 46904, "\u0120Philips": 46905, "\u0120Kafka": 46906, "\u0120upheaval": 46907, "\u0120sentimental": 46908, "\u0120sax": 46909, "\u0120Akira": 46910, "serial": 46911, "Matrix": 46912, "\u0120electing": 46913, "\u0120commenter": 46914, "\u0120Nebula": 46915, "plets": 46916, "\u0120Nadu": 46917, "\u0120Adren": 46918, "\u0120enshr": 46919, "\u0120RAND": 46920, "financial": 46921, "\u0120Clyde": 46922, "utherford": 46923, "\u0120signage": 46924, "\u0120deline": 46925, "\u0120phosphate": 46926, "roversial": 46927, "fascist": 46928, "\u0120Vall": 46929, "\u0120Bethlehem": 46930, "\u0120fors": 46931, "\u0120english": 46932, "Solid": 46933, "Nature": 46934, "\u0120va": 46935, "\u0120Guests": 46936, "\u0120tantal": 46937, "\u0120autoimmune": 46938, ";;;;;;;;;;;;": 46939, "\u0120Totally": 46940, "\u0120Ov": 46941, "\u0120defences": 46942, "\u0120Coconut": 46943, "\u0120tranquil": 46944, "\u0120ploy": 46945, "\u0120flavours": 46946, "\u0120Flask": 46947, "\u00e3\u0124\u00a8\u00e3\u0125\u00ab": 46948, "\u0120Weston": 46949, "\u0120Volvo": 46950, "870": 46951, "\u0120microphones": 46952, "verbal": 46953, "RPG": 46954, "\u0120iii": 46955, ";}": 46956, "028": 46957, "\u0120headlined": 46958, "\u0120primed": 46959, "\u0120hoard": 46960, "\u0120Shad": 46961, "\u0120ENTER": 46962, "\u0120triangular": 46963, "\u0120capit": 46964, "lik": 46965, "\u0120Ancients": 46966, "\u0120lash": 46967, "\u0120convol": 46968, "\u0120colonel": 46969, "enemy": 46970, "Gra": 46971, "\u0120pubs": 46972, "utters": 46973, "\u0120assigns": 46974, "\u0120Penet": 46975, "\u0120Monstrous": 46976, "\u0120Bowen": 46977, "ilver": 46978, "Haunted": 46979, "\u0120Ding": 46980, "started": 46981, "plin": 46982, "\u0120contaminants": 46983, "\u0120DOE": 46984, "ffen": 46985, "\u0120Technician": 46986, "Ry": 46987, "\u0120robbers": 46988, "\u0120hotline": 46989, "\u0120Guardiola": 46990, "\u0120Kaufman": 46991, "rower": 46992, "\u0120Dresden": 46993, "\u0120Alpine": 46994, "Elf": 46995, "\u0120fmt": 46996, "\u0120Sard": 46997, "urses": 46998, "gpu": 46999, "Unix": 47000, "\u0120unequivocally": 47001, "\u0120Citizenship": 47002, "quad": 47003, "mire": 47004, "\u0120Sweeney": 47005, "Battery": 47006, "615": 47007, "\u0120pancakes": 47008, "\u0120oats": 47009, "Maps": 47010, "\u0120Contrast": 47011, "mbudsman": 47012, "\u0120EPS": 47013, "\u0120subcommittee": 47014, "\u0120sourcing": 47015, "\u0120sizing": 47016, "\u0120Buffer": 47017, "\u0120Mandatory": 47018, "\u0120moderates": 47019, "\u0120Patterns": 47020, "\u0120Chocobo": 47021, "\u0120Zan": 47022, "\u0120STATES": 47023, "\u0120Judging": 47024, "\u0120Inher": 47025, "*:": 47026, "\u0120bil": 47027, "\u0120Yen": 47028, "\u0120exhilar": 47029, "ollower": 47030, "zers": 47031, "\u0120snug": 47032, "maximum": 47033, "\u0120despicable": 47034, "\u0120PACK": 47035, "\u0120Annex": 47036, "\u0120sarcastic": 47037, "\u0120latex": 47038, "\u0120tamp": 47039, "\u0120Sao": 47040, "bah": 47041, "\u0120Reverend": 47042, "\u0120Chinatown": 47043, "\u0120AUT": 47044, "documented": 47045, "\u0120GABA": 47046, "\u0120Canaan": 47047, "\u0120\u00d9\u0127": 47048, "\u0120governs": 47049, "prev": 47050, "Esc": 47051, "\u0120Estimates": 47052, "OSP": 47053, "\u0120endeavour": 47054, "\u0120Closing": 47055, "ometime": 47056, "everyone": 47057, "\u0120worsen": 47058, "\u0120scanners": 47059, "\u0120deviations": 47060, "\u0120Robotics": 47061, "\u0120Compton": 47062, "\u0120sorcerer": 47063, "\u0120endogenous": 47064, "\u0120emulation": 47065, "\u0120Piercing": 47066, "\u0120Aph": 47067, "\u0120Socket": 47068, "\u0120bould": 47069, "\u0120OU": 47070, "\u0120Borderlands": 47071, "\u01201863": 47072, "Gordon": 47073, "\u0120WTO": 47074, "\u0120restricts": 47075, "\u0120mosaic": 47076, "\u0120melodies": 47077, "\u00e7\u0126": 47078, "Tar": 47079, "\u0120disson": 47080, "\u0120Provides": 47081, "\u0120......": 47082, "bek": 47083, "FIX": 47084, "\u0120broom": 47085, "anship": 47086, "Doctors": 47087, "\u0120nerds": 47088, "\u0120Regions": 47089, "naissance": 47090, "\u0120mete": 47091, "\u0120crept": 47092, "plings": 47093, "\u0120girlfriends": 47094, "knit": 47095, "igent": 47096, "owe": 47097, "\u0120ushered": 47098, "\u0120Baz": 47099, "Mobil": 47100, "434": 47101, "\u0120Presents": 47102, "origin": 47103, "\u0120insomnia": 47104, "\u0120Aux": 47105, "439": 47106, "\u0120Chili": 47107, "irsch": 47108, "GAME": 47109, "\u0120gestation": 47110, "algia": 47111, "romising": 47112, "$,": 47113, "crow": 47114, "\u0120Inspection": 47115, "atomic": 47116, "Relations": 47117, "JOHN": 47118, "roman": 47119, "\u0120Clockwork": 47120, "\u0120Bakr": 47121, "mone": 47122, "MET": 47123, "\u0120thirsty": 47124, "\u0120bc": 47125, "\u0120faculties": 47126, "Rum": 47127, "\u0120nuance": 47128, "\u0120Darius": 47129, "pleting": 47130, "fters": 47131, "etchup": 47132, "Registration": 47133, "\u0120KE": 47134, "Rah": 47135, "\u0120preferential": 47136, "\u0120Lash": 47137, "\u0120HH": 47138, "Valid": 47139, "\u0120NAV": 47140, "\u0120starve": 47141, "\u0120Gong": 47142, "zynski": 47143, "\u0120Actress": 47144, "\u0120wik": 47145, "\u0120unaccompanied": 47146, "lvl": 47147, "Bride": 47148, "ADS": 47149, "\u0120Commando": 47150, "\u0120Vaughn": 47151, "Wallet": 47152, "\u0120hopping": 47153, "\u0120Vie": 47154, "\u0120caveats": 47155, "\u0120alas": 47156, "ifled": 47157, "abuse": 47158, "661": 47159, "\u0120ibn": 47160, "\u0120gul": 47161, "\u0120robbing": 47162, "til": 47163, "ILA": 47164, "\u0120mitigating": 47165, "\u0120aptly": 47166, "\u0120tyrant": 47167, "\u0120midday": 47168, "\u0120Gilmore": 47169, "\u0120Decker": 47170, "\u0120\u00c2\u00a7\u00c2\u00a7": 47171, "partial": 47172, "Exactly": 47173, "\u0120phenotype": 47174, "\u0120[+]": 47175, "\u0120Plex": 47176, "\u0120Ips": 47177, "versions": 47178, "\u0120ebook": 47179, "\u0120chic": 47180, "gross": 47181, "\":\"\"},{\"": 47182, "\u0120Surprisingly": 47183, "Morgan": 47184, "\u0120residues": 47185, "\u0120Confederation": 47186, "infeld": 47187, "\u0120lyr": 47188, "moderate": 47189, "\u0120perpendicular": 47190, "VK": 47191, "\u0120synchronized": 47192, "\u0120refreshed": 47193, "\u0120adore": 47194, "\u0120Torment": 47195, "olina": 47196, "\u01202600": 47197, "ItemTracker": 47198, "\u0120pies": 47199, "\u0120FAT": 47200, "\u0120RHP": 47201, "048": 47202, "\u0120RESP": 47203, "\u0120BJ": 47204, "allows": 47205, "Pand": 47206, "\u0120unwelcome": 47207, "\u0120Voc": 47208, "\u0120Bastard": 47209, "\u0120OW": 47210, "\u0120LAR": 47211, "\u0120Healer": 47212, "Environmental": 47213, "\u0120Kenyan": 47214, "\u0120Trance": 47215, "\u0120Pats": 47216, "\u0120aliases": 47217, "\u0120Garfield": 47218, "\u0120campaigner": 47219, "\u0120advancements": 47220, "\u0120Okinawa": 47221, "\u0120Coh": 47222, "owsky": 47223, "\u0120starved": 47224, "\u0120sizeable": 47225, "\u0120:-)": 47226, "\u0120mRNA": 47227, "\u0120suspensions": 47228, "istar": 47229, "Scotland": 47230, "Prin": 47231, "------------------------------------------------": 47232, "\u0120502": 47233, "\u0120teaspoons": 47234, "\u01201050": 47235, "\u0120coercive": 47236, "\u0120Masonic": 47237, "edded": 47238, "\u0120Passenger": 47239, "\u0120latt": 47240, "\u0120braces": 47241, "\u0120Steal": 47242, "\u0120NYT": 47243, "\u0120Kats": 47244, "\u0120Celest": 47245, "aez": 47246, "Tu": 47247, "\u0120Coulter": 47248, "\u00f0\u0141\u013a": 47249, "Flickr": 47250, "\u0120Wilmington": 47251, "iths": 47252, "++;": 47253, "\u0120vending": 47254, "\u0120negro": 47255, "\u0120Phi": 47256, "\u0120Yellowstone": 47257, "Callback": 47258, "\u0120shampoo": 47259, "\u0120Shades": 47260, "wat": 47261, "\u0120superhuman": 47262, "\u0120ridiculed": 47263, "\u0120holiest": 47264, "ombo": 47265, "\u0120interns": 47266, "\u0120hone": 47267, "\u0120Paragu": 47268, "URI": 47269, "\u0120dangling": 47270, "\u00e3\u0124\u00bb": 47271, "sov": 47272, "ictional": 47273, "availability": 47274, "\u0120revocation": 47275, "\u0120dow": 47276, "inic": 47277, "\u0120THEIR": 47278, "\u0120iso": 47279, "\u0120outings": 47280, "\u0120Lethal": 47281, "\u0120)))": 47282, "\u0120inaccur": 47283, "\u0120outlandish": 47284, "\u0120anus": 47285, "letico": 47286, "idon": 47287, "lol": 47288, "\u0120unregulated": 47289, "\u0120succumbed": 47290, "\u0120cuff": 47291, "\u0120Wasteland": 47292, "letal": 47293, "\u0120substr": 47294, "\u0120coffers": 47295, "\u0120automakers": 47296, "ovi": 47297, "\u0120Xue": 47298, "\u0120Daytona": 47299, "\u0120jarring": 47300, "\u0120fumes": 47301, "\u0120disbanded": 47302, "zik": 47303, "itton": 47304, "\u0120strikingly": 47305, "\u0120spores": 47306, "Adapter": 47307, ".):": 47308, "\u0120Lyndon": 47309, "ivalry": 47310, "\u0120orally": 47311, "\u0120tumultuous": 47312, "\u0120displeasure": 47313, "\u0120cones": 47314, "orrect": 47315, "\u0120appease": 47316, "\u0120derby": 47317, "\u0120Tripoli": 47318, "\u0120Aless": 47319, "\u0120poked": 47320, "\u0120Guilty": 47321, "vP": 47322, "Enough": 47323, "\u0120originals": 47324, "699": 47325, "\u0120rabbi": 47326, "\u0120proverbial": 47327, "\u0120postpone": 47328, "elope": 47329, "\u0120Misty": 47330, "\u0120staffed": 47331, "\u0120Unemployment": 47332, "reditary": 47333, "\u0120diligent": 47334, "recomm": 47335, "measures": 47336, "asin": 47337, "825": 47338, "\u0120ponds": 47339, "\u0120mmol": 47340, "\u0120SAR": 47341, "\u0120CARE": 47342, "\u0120371": 47343, "\u0120clenched": 47344, "\u0120Corsair": 47345, "\u0120caricature": 47346, "zn": 47347, "attach": 47348, "\u0120Schro": 47349, "speak": 47350, "painted": 47351, "\u0120Suc": 47352, "\u0120ENT": 47353, "\u0120cellul": 47354, "\u0120Paid": 47355, "diagn": 47356, "WHERE": 47357, "\u0120texted": 47358, "Barn": 47359, "\u0120retracted": 47360, "\u0120Referred": 47361, "Sav": 47362, "\u0120upkeep": 47363, "\u0120workplaces": 47364, "\u0120Tokens": 47365, "\u0120amplify": 47366, "clinical": 47367, "\u0120multic": 47368, "mberg": 47369, "\u0120convoluted": 47370, "Region": 47371, "565": 47372, "\u0120Topic": 47373, "\u0120snail": 47374, "\u0120saline": 47375, "\u0120insurrection": 47376, "\u0120Petr": 47377, "forts": 47378, "BAT": 47379, "\u0120Navajo": 47380, "\u0120rudimentary": 47381, "\u0120Laksh": 47382, "ONDON": 47383, "Measure": 47384, "\u0120transformer": 47385, "\u0120Goddard": 47386, "\u0120coincides": 47387, "irin": 47388, "Rex": 47389, "\u0120Bok": 47390, "quit": 47391, "\u0120shotguns": 47392, "\u0120proletarian": 47393, "\u0120scorp": 47394, "\u0120Ada": 47395, "514": 47396, "\u0120slander": 47397, "recorded": 47398, "\u0120embell": 47399, "risome": 47400, "\u0120apologizing": 47401, "\u0120Mulcair": 47402, "\u0120Gibraltar": 47403, "Cla": 47404, "\u0120allot": 47405, "\u0120Attention": 47406, "\u0120433": 47407, "leave": 47408, "\u0120whine": 47409, "\u0120Issa": 47410, "\u0120Faust": 47411, "\u0120Barron": 47412, "heny": 47413, "\u0120victimized": 47414, "Jews": 47415, "\u0120nurturing": 47416, "ettel": 47417, "Winged": 47418, "\u0120Subtle": 47419, "\u0120flavorful": 47420, "\u0120Reps": 47421, "enged": 47422, "callback": 47423, "\u0120directional": 47424, "\u0120clasp": 47425, "\u0120Directions": 47426, "planet": 47427, "iculture": 47428, "Helper": 47429, "icion": 47430, "acia": 47431, "\u0120\u00e7\u00a5\u0140": 47432, "\u0120surges": 47433, "\u0120canoe": 47434, "\u0120Premiership": 47435, "been": 47436, "\u0120defied": 47437, "\u0120Trooper": 47438, "\u0120tripod": 47439, "\u0120gasp": 47440, "\u0120Euph": 47441, "\u0120Ads": 47442, "vernight": 47443, "highly": 47444, "Role": 47445, "\u0120entangled": 47446, "\u0120Zeit": 47447, "618": 47448, "\u0120Rusty": 47449, "\u0120havens": 47450, "\u0120Vaughan": 47451, "HAEL": 47452, "\u0120SERVICE": 47453, "/,": 47454, "\u0120stricken": 47455, "\u0120delusions": 47456, "\u0120bis": 47457, "\u0120Haf": 47458, "\u0120gratification": 47459, "\u0120enticing": 47460, "UNCH": 47461, "Adams": 47462, "\u0120OLED": 47463, "\u0120Beetle": 47464, "\u01201899": 47465, "\u0120SOFTWARE": 47466, "ategor": 47467, "VL": 47468, "\u0120Totem": 47469, "\u0120Gators": 47470, "ATURES": 47471, "\u0120impedance": 47472, "Registered": 47473, "\u0120Cary": 47474, "\u0120Aerial": 47475, "onne": 47476, "enium": 47477, "\u0120dred": 47478, "\u0120Beg": 47479, "\u0120concurrently": 47480, "\u0120superpower": 47481, "\u0120Xan": 47482, "jew": 47483, "imester": 47484, "\u0120Dickinson": 47485, "\u00e2\u0136\u0123": 47486, "Fla": 47487, "\u0120pree": 47488, "\u0120Rollins": 47489, "\u00a9\u00b6\u00e6": 47490, "\u0120denomination": 47491, "\u0120Lana": 47492, "516": 47493, "\u0120inciting": 47494, "scribed": 47495, "juries": 47496, "\u0120Wonders": 47497, "approximately": 47498, "\u0120suspending": 47499, "\u0120mountainous": 47500, "\u0120Laugh": 47501, "oidal": 47502, "Ns": 47503, "Detect": 47504, ")=": 47505, "\u0120Luthor": 47506, "\u0120Schwarzenegger": 47507, "\u0120Muller": 47508, "\u0120Devi": 47509, "ecycle": 47510, "Jar": 47511, "613": 47512, "\u0120Longh": 47513, "Bah": 47514, "\u0120SPORTS": 47515, "nw": 47516, "\u0120refinement": 47517, "\u0120waterways": 47518, "\u0120diner": 47519, "Blade": 47520, "683": 47521, "Fac": 47522, "\u0120initials": 47523, "\u0120rog": 47524, "\u0120paranormal": 47525, "BUT": 47526, "\u0120[(": 47527, "\u0120Swanson": 47528, "\u0120Mesh": 47529, "\u00e2\u0138\u00ac": 47530, "Improve": 47531, "\u0120Radiation": 47532, "\u0120Esther": 47533, "\u0120Esk": 47534, "\u0120Aly": 47535, "iky": 47536, "\u0120irrad": 47537, "\u0120Buckingham": 47538, "\u0120refill": 47539, "\u0120._": 47540, "Repe": 47541, "CONCLUS": 47542, "\u0120differentiated": 47543, "\u0120chirop": 47544, "\u0120Atkins": 47545, "Pattern": 47546, "\u0120excise": 47547, "\u0120cabal": 47548, "NSA": 47549, "\u0120STA": 47550, "\u0120SIL": 47551, "\u0120Paraly": 47552, "\u0120rye": 47553, "\u0120Howell": 47554, "\u0120Countdown": 47555, "nesses": 47556, "alysed": 47557, "\u0120resize": 47558, "\u00e3\u0124\u00bd": 47559, "\u0120budgetary": 47560, "\u0120Stras": 47561, "wang": 47562, "\u0120apiece": 47563, "\u0120precincts": 47564, "\u0120peach": 47565, "\u0120skyline": 47566, "\u0120353": 47567, "popular": 47568, "Appearances": 47569, "\u0120Mechanics": 47570, "\u0120DevOnline": 47571, "Sullivan": 47572, "Zen": 47573, "\u0120pu": 47574, "opolis": 47575, "544": 47576, "\u0120deform": 47577, "\u0120counteract": 47578, "\u0120Lange": 47579, "\u0120417": 47580, "Console": 47581, "774": 47582, "\u0120nodding": 47583, "\u0120populism": 47584, "\u0120hep": 47585, "\u0120counselling": 47586, "compliance": 47587, "UFF": 47588, "\u0120undeniably": 47589, "\u0120railing": 47590, "\u0120Horowitz": 47591, "\u0120Simone": 47592, "\u0120Bungie": 47593, "\u0120ak": 47594, "\u0120Talks": 47595, "xff": 47596, "flake": 47597, "Crash": 47598, "\u0120sweaty": 47599, "\u0120banquet": 47600, "\u0120OFFIC": 47601, "\u0120inventive": 47602, "\u0120astronomer": 47603, "\u0120Stamford": 47604, "\u0120Scare": 47605, "\u0120GREEN": 47606, "olicited": 47607, "\u0120rusher": 47608, "\u0120centrist": 47609, "ighting": 47610, "\u0120subclass": 47611, "\u0120disav": 47612, "\u0120defund": 47613, "\u0120Nanto": 47614, "ociate": 47615, "mast": 47616, "\u0120pacif": 47617, "\u0120mend": 47618, "eers": 47619, "immigration": 47620, "ESSION": 47621, "\u0120numbering": 47622, "\u0120laughable": 47623, "\u0120Ended": 47624, "viation": 47625, "emark": 47626, "Pitt": 47627, "\u0120meticulous": 47628, "\u0120LF": 47629, "\u0120congratulated": 47630, "\u0120Birch": 47631, "\u0120swayed": 47632, "\u0120semifinals": 47633, "\u0120humankind": 47634, "matter": 47635, "\u0120Equip": 47636, "opausal": 47637, "Said": 47638, "\u0120Layout": 47639, "\u0120voicing": 47640, "\u0120thug": 47641, "\u0120pornographic": 47642, "IPS": 47643, "\u0120moaning": 47644, "\u0120grievance": 47645, "\u0120confessions": 47646, "escal": 47647, "TEXTURE": 47648, "Authent": 47649, "osaurus": 47650, "Purchase": 47651, "\u0120relegation": 47652, "alter": 47653, "\u0120\u00c2\u0142\u00c2\u0142": 47654, "\u0120riddled": 47655, "\u0120ogre": 47656, "\u0120Lowell": 47657, "Occup": 47658, "Eat": 47659, "\u0120Hyder": 47660, "\u0120Adviser": 47661, "Commerce": 47662, "Hunt": 47663, "\u0120Orth": 47664, "\u0120Competitive": 47665, "\u0120CLA": 47666, "CDC": 47667, "\u0120salads": 47668, "Fle": 47669, "\u0120industrialized": 47670, "`,": 47671, "\u0120OWN": 47672, "\u0120beck": 47673, "\u0120Particularly": 47674, "oubt": 47675, "\u0120mM": 47676, "\u0120Hussain": 47677, "\u0120Chennai": 47678, "\u0120920": 47679, "\u0120appointing": 47680, "\u0120Cullen": 47681, ",,,,,,,,": 47682, "\u0120pores": 47683, "verified": 47684, "\u0120biochemical": 47685, "emate": 47686, "\u0120cowardly": 47687, "\u0120Helsinki": 47688, "\u0120Ethiopian": 47689, "SOURCE": 47690, "ERC": 47691, "estro": 47692, "\u0120biotech": 47693, "\u0120Sour": 47694, "\u0120brewer": 47695, "Bloomberg": 47696, "\u0120intensify": 47697, "Glass": 47698, "anco": 47699, "\u0120FDR": 47700, "greSQL": 47701, "\u0120Fires": 47702, "\u00a9\u00b6\u00e6\u00a5\u00b5": 47703, "eco": 47704, "1001": 47705, "\u0120Homeless": 47706, "\u0120instantaneous": 47707, "\u0120Haste": 47708, "igel": 47709, "Diamond": 47710, "\u0120paving": 47711, "\u0120landfill": 47712, "\u0120dads": 47713, "houn": 47714, ":]": 47715, "\u0120incendiary": 47716, "\u0120Livingston": 47717, "\u0120Hilbert": 47718, "\u0120Checks": 47719, "styles": 47720, "inators": 47721, "\u0120Clive": 47722, "phrine": 47723, "\u0120chimpanzees": 47724, "\u0120pall": 47725, "\u0120JM": 47726, "\u0120Aadhaar": 47727, "\u00f0\u013f": 47728, "\u0120achievable": 47729, "disabled": 47730, "PET": 47731, "OOOOOOOO": 47732, "Mot": 47733, "\u0120intangible": 47734, "\u0120ballet": 47735, "\u0120Webs": 47736, "\u0120Estimated": 47737, "Effects": 47738, "\u0120bailed": 47739, "Joshua": 47740, "\u0120turbulence": 47741, "\u0120occupant": 47742, "\u0120Daylight": 47743, "\u0120361": 47744, "meet": 47745, "\u0120statically": 47746, "\u0120onlook": 47747, "\u0120ki": 47748, "illegal": 47749, "\u0120velvet": 47750, "\u0120dehydration": 47751, "\u0120acquies": 47752, "\u0120Rez": 47753, "akura": 47754, "\u0120Upton": 47755, "atro": 47756, "\u0120incomprehensible": 47757, "\u0120backdoor": 47758, "\u0120Rhino": 47759, "727": 47760, "\u0120maths": 47761, ")+": 47762, "\u0120heresy": 47763, "\u0120df": 47764, "\u0120Roche": 47765, "\u0120Lydia": 47766, "\u0120pancreat": 47767, "reply": 47768, "arrell": 47769, "\u0120solicitation": 47770, "\u0120circadian": 47771, "BIP": 47772, "\u0120foray": 47773, "\u0120cryptic": 47774, "izu": 47775, "imeo": 47776, "\u0120Tomato": 47777, "\u0120Homs": 47778, "examination": 47779, "\u0120quarry": 47780, "\u0120Valiant": 47781, "\u0120Jericho": 47782, "\u0120INCLUD": 47783, "\u01201840": 47784, "519": 47785, "\u0120resists": 47786, "\u0120snapshots": 47787, "\u0120Spur": 47788, "\u0120Antiqu": 47789, "Login": 47790, "\u0120bestselling": 47791, "\u0120antic": 47792, "\u0120Sutherland": 47793, "\u00e3\u0124\u00a2\u00e3\u0125\u00ab": 47794, "\u0120~/": 47795, "\u0120Parm": 47796, "\u00e8\u0125": 47797, "Pages": 47798, "intensity": 47799, "\u0120immobil": 47800, "\u01201865": 47801, "zzo": 47802, "\u0120nifty": 47803, "\u0120fentanyl": 47804, "\u0120Preservation": 47805, "ophen": 47806, "\u0120darts": 47807, "\u0120Dinosaur": 47808, "pointers": 47809, "\u0120Rite": 47810, "suggest": 47811, "awareness": 47812, "\u0120Sheridan": 47813, "\u0120stances": 47814, "\u0120sorcery": 47815, "\u0120perjury": 47816, "\u0120Nikola": 47817, "iever": 47818, "\u0120fiance": 47819, "\u0120Jordanian": 47820, "\u0120Balloon": 47821, "\u0120nab": 47822, "\u0120kb": 47823, "\u0120humanities": 47824, "\u0120Tanaka": 47825, "hillary": 47826, "\u0120consultancy": 47827, "\u0120Zub": 47828, "\u0120remission": 47829, "\u0120confid": 47830, "CHQ": 47831, "\u0120Fug": 47832, "\u0120improvis": 47833, "Yep": 47834, "/_": 47835, "\u0120unwillingness": 47836, "\u0120portfolios": 47837, "055": 47838, "\u0120Instructor": 47839, "aiman": 47840, "\u0120claimants": 47841, "Mbps": 47842, "\u0120Bye": 47843, "received": 47844, "Tweet": 47845, "\u0120indemn": 47846, "riz": 47847, "amara": 47848, "Nat": 47849, "\u0120evaluates": 47850, "\u0120Lur": 47851, "epad": 47852, "FOX": 47853, "\u0120Thro": 47854, "\u0120rusty": 47855, "\u0120bedrock": 47856, "\u0120Oprah": 47857, "JB": 47858, "\u0120manipulative": 47859, "\u0120willful": 47860, "\u0120relapse": 47861, "\u0120extant": 47862, "Theme": 47863, "Sensor": 47864, "\u0120Stability": 47865, "govern": 47866, "\u0120poppy": 47867, "\u0120knack": 47868, "\u0120insulated": 47869, "\u0120Tile": 47870, "\u0120Extrem": 47871, "\u0120untold": 47872, "\u0120converge": 47873, "\u0120refuel": 47874, "igroup": 47875, "\u0120distortions": 47876, "\u0120ravaged": 47877, "\u0120mechanically": 47878, "\u0120Reilly": 47879, "\u0120Nose": 47880, "\u0120Incarnation": 47881, "\u0120Becky": 47882, "abbling": 47883, "\u0120taco": 47884, "\u0120rake": 47885, "\u0120melancholy": 47886, "\u0120illustrious": 47887, "\u0120Dartmouth": 47888, "Guide": 47889, "\u0120Razer": 47890, "\u0120Benz": 47891, "Ultimate": 47892, "\u0120Surprise": 47893, "\u0120pageant": 47894, "offer": 47895, "Whoever": 47896, "\u0120wiser": 47897, "\u0120chemist": 47898, "\u0120HELL": 47899, "\u0120Bulk": 47900, "\u0120plutonium": 47901, "\u0120COVER": 47902, "\u00d6\u00bc": 47903, "failed": 47904, "\u0120tirelessly": 47905, "\u0120infertility": 47906, "\u0120Trident": 47907, "\u0120Showtime": 47908, "\u0120Civ": 47909, "Vice": 47910, "requires": 47911, "ittance": 47912, "\u0120uncontrolled": 47913, "interesting": 47914, "561": 47915, "\u0120innovate": 47916, "ategic": 47917, "Lie": 47918, "\u0120Selling": 47919, "Ul": 47920, "\u0120savior": 47921, "\u0120Tosh": 47922, "\u0120swast": 47923, "PASS": 47924, "\u0120rink": 47925, "\u0120cardio": 47926, "\u0120Iro": 47927, "udi": 47928, "\u0120vantage": 47929, "\u0120vans": 47930, "\u0120Ni\u00c3\u00b1o": 47931, "+=": 47932, "\u0120propagate": 47933, "<?": 47934, "\u0120methodological": 47935, "20439": 47936, "\u0120triglycer": 47937, "\u0120ingrained": 47938, "\u0120Annotations": 47939, "arranted": 47940, "617": 47941, "\u0120Sodium": 47942, "\u0120AAC": 47943, "technical": 47944, "multipl": 47945, "\u0120373": 47946, "\u00e5\u012d": 47947, "\u0120decisively": 47948, "\u0120boosters": 47949, "\u0120desserts": 47950, "\u0120Grenade": 47951, "\u0120testifying": 47952, "\u0120Scully": 47953, "IDs": 47954, "\u0120lockdown": 47955, "\u0120Scher": 47956, "\u0120R\u00c3\u00a9": 47957, "\u0120Whitman": 47958, "\u0120Ramsay": 47959, "remote": 47960, "\u0120hikers": 47961, "\u0120Hyundai": 47962, "\u0120conscientious": 47963, "\u0120clerics": 47964, "\u0120Siberian": 47965, "uti": 47966, "isbury": 47967, "\u0120relayed": 47968, "\u0120quartz": 47969, "\u0120CBI": 47970, "seekers": 47971, "ulla": 47972, "\u0120welding": 47973, "\u0120Shal": 47974, "bleacher": 47975, "Tai": 47976, "\u0120Samson": 47977, "\u0120tumble": 47978, "\u0120Investor": 47979, "\u0120subcontract": 47980, "\u0120Shinra": 47981, "owicz": 47982, "jandro": 47983, "dad": 47984, "\u0120terminating": 47985, "\u0120Neural": 47986, "\u00e4\u00bb\u00a3": 47987, "\u0120leakage": 47988, "\u0120Midlands": 47989, "\u0120Caucasus": 47990, "\u00ed\u0137": 47991, "cit": 47992, "llan": 47993, "ivably": 47994, "\u0120Albion": 47995, "\u0120457": 47996, "\u0120registrations": 47997, "\u0120comrade": 47998, "\u0120clipboard": 47999, "047": 48000, "\u0120discouraging": 48001, "\u0120Oops": 48002, "Adapt": 48003, "\u0120empath": 48004, "nv": 48005, "\u0120PROT": 48006, "\u0120Donn": 48007, "\u0120Pax": 48008, "\u0120Bayer": 48009, "tis": 48010, "Square": 48011, "\u0120footprints": 48012, "particip": 48013, "\u0120Chilean": 48014, "Brend": 48015, "inducing": 48016, "Magn": 48017, "\u0120clubhouse": 48018, "\u0120Magnum": 48019, "\u0120encamp": 48020, "\u0120Ethnic": 48021, "ucha": 48022, "erey": 48023, "\u0120watered": 48024, "\u0120Calais": 48025, "\u0120complexion": 48026, "\u0120sects": 48027, "\u0120renters": 48028, "\u0120bras": 48029, "o\u00c4\u0141an": 48030, "Timeout": 48031, "Management": 48032, "\u0120infographic": 48033, "Pokemon": 48034, "Clar": 48035, "\u0120locality": 48036, "\u0120flora": 48037, "asel": 48038, "Pont": 48039, "\u0120populate": 48040, "\u0120Ong": 48041, "\u0120subsistence": 48042, "\u0120auctions": 48043, "\u0120McAuliffe": 48044, "\u0120LOOK": 48045, "bringer": 48046, "\u0120titan": 48047, "\u0120manifold": 48048, "\u0120\u00e2\u0139\u0131": 48049, "\u0120calibrated": 48050, "\u0120caliphate": 48051, "\u0120SHE": 48052, "\u0120Commissioners": 48053, "ceivable": 48054, "jc": 48055, "Winner": 48056, "524": 48057, "\u0120condone": 48058, "Otherwise": 48059, "\u0120piling": 48060, "\u0120embody": 48061, "\u0120Crimean": 48062, "utics": 48063, "\u0120Exhibition": 48064, "\u0120426": 48065, "eering": 48066, "\u0120vying": 48067, "\u0120HUGE": 48068, "*=-": 48069, "\u0120principled": 48070, "\u00e0\u00a6": 48071, "\u0120quirks": 48072, "\u0120Editors": 48073, "puting": 48074, "GES": 48075, "\u0120FTA": 48076, "\u00e0\u00a4\u00be": 48077, "addon": 48078, "\u0120HAM": 48079, "\u0120Frieza": 48080, "Woman": 48081, ".$": 48082, "\u0120crib": 48083, "\u0120Herod": 48084, "\u0120timers": 48085, "\u0120Spaces": 48086, "\u0120Macintosh": 48087, "ataka": 48088, "\u0120glide": 48089, "\u0120smelling": 48090, "\u0120BAL": 48091, "\u0120unsu": 48092, "\u0120condos": 48093, "\u0120bicycl": 48094, "\u0120Revival": 48095, "553": 48096, "\u0120juggling": 48097, "Hug": 48098, "\u0120Kardashian": 48099, "\u0120Balkans": 48100, "multiple": 48101, "\u0120nutritious": 48102, "ocry": 48103, "1900": 48104, "\u0120integrates": 48105, "\u0120adjoining": 48106, "\u0120Folder": 48107, "rollment": 48108, "venient": 48109, "\u0120uber": 48110, "yi": 48111, "\u0120whiff": 48112, "\u0120Juven": 48113, "\u0120Borough": 48114, "nette": 48115, "\u0120bilingual": 48116, "\u0120Sparks": 48117, "phthal": 48118, "manufact": 48119, "\u0120touting": 48120, "\u0120PHI": 48121, "Keefe": 48122, "Reward": 48123, "\u0120infall": 48124, "\u0120Temper": 48125, "typically": 48126, "\u0120Nikol": 48127, "\u0120regulars": 48128, "\u0120pseudonym": 48129, "\u0120exhibitions": 48130, "\u0120blaster": 48131, "\u0120409": 48132, "warming": 48133, "\u0120reverber": 48134, "\u0120reciprocal": 48135, "\u0120670": 48136, "ipient": 48137, "bett": 48138, "\u0120Begins": 48139, "\u0120itching": 48140, "\u0120Phar": 48141, "Assuming": 48142, "\u0120emitting": 48143, "\u0120MLG": 48144, "\u0120birthplace": 48145, "\u0120taunt": 48146, "\u0120Luffy": 48147, "\u0120Amit": 48148, "\u0120circled": 48149, "\u0120Nost": 48150, "ennett": 48151, "\u0120deforestation": 48152, "\u0120Historically": 48153, "\u0120Everyday": 48154, "\u0120overtake": 48155, "792": 48156, "\u0120nun": 48157, "\u0120Lucia": 48158, "\u0120accompanies": 48159, "\u0120Seeking": 48160, "\u0120Trash": 48161, "anism": 48162, "Rogue": 48163, "\u0120northwestern": 48164, "\u0120Supplemental": 48165, "\u0120NYU": 48166, "\u0120FRI": 48167, "\u0120Satisf": 48168, "xes": 48169, "517": 48170, "\u0120reassured": 48171, "\u0120sporadic": 48172, "\u0120701": 48173, "\u0120medial": 48174, "\u0120cannabinoid": 48175, "\u0120barbaric": 48176, "\u0120epis": 48177, "\u0120Explosive": 48178, "\u0120Dough": 48179, "\u0120unsolved": 48180, "Supported": 48181, "\u0120acknowledgment": 48182, "spawn": 48183, "\u0120kitchens": 48184, "\u0120-=": 48185, "talking": 48186, "icist": 48187, "\u0120Pegasus": 48188, "\u0120PSU": 48189, "\u0120photon": 48190, "\u0120Authentication": 48191, "RG": 48192, "@#&": 48193, "762": 48194, "\u0120Clair": 48195, "\u0120diaper": 48196, "\u0120brist": 48197, "\u0120Prosecutors": 48198, "\u0120Jem": 48199, "628": 48200, "\u0120Everywhere": 48201, "\u0120Jeanne": 48202, "equality": 48203, "\u00e3\u0125\u00a9\u00e3\u0125\u00b3": 48204, "objects": 48205, "\u0120Pelicans": 48206, "\u0120392": 48207, "\u0120blu": 48208, "bys": 48209, "\u0120Ago": 48210, "\u0120instructional": 48211, "\u0120discriminating": 48212, "\u0120TRAN": 48213, "\u0120Cornel": 48214, "agos": 48215, "\u0120tyre": 48216, "\u0120aspiration": 48217, "\u0120Bridgewater": 48218, "\":-": 48219, "!\".": 48220, "\u0120Ens": 48221, "\u0120Coco": 48222, "Pie": 48223, "\u0120detach": 48224, "\u0120Couch": 48225, "\u0120physique": 48226, "\u0120Occupations": 48227, "oscopic": 48228, "enough": 48229, "Buzz": 48230, "Appearance": 48231, "YP": 48232, "\u0120racer": 48233, "\u0120complicity": 48234, "rpm": 48235, "Toy": 48236, "\u0120interrupts": 48237, "\u0120Catalyst": 48238, "\u0120utilitarian": 48239, "impact": 48240, "\u0120spaghetti": 48241, "\u0120porous": 48242, "\u0120esteemed": 48243, "\u0120inciner": 48244, "\u0120IOC": 48245, "748": 48246, "\u0120espresso": 48247, "\u0120Smile": 48248, "abilia": 48249, "635": 48250, "\u0120mathematician": 48251, "\u0120424": 48252, "\u0120KL": 48253, "\u0120HIP": 48254, "\u0120overheard": 48255, "\u0120Tud": 48256, "\u0120Tec": 48257, "\u0120quizz": 48258, "\u0120flattering": 48259, "\u0120conn": 48260, "\u00e2\u0122\u0130": 48261, "\u0120attaches": 48262, "\u0120ROS": 48263, "\u0120ACS": 48264, "\u0120tcp": 48265, "\u0120Shame": 48266, "skip": 48267, "respected": 48268, "\u0120Trinidad": 48269, "grain": 48270, "\u0120foothold": 48271, "\u0120Uncharted": 48272, "\u0120Julio": 48273, "zl": 48274, "avored": 48275, "\u0120Anxiety": 48276, "errors": 48277, "\u0120Centauri": 48278, "itsch": 48279, "Daddy": 48280, "\u0120clutching": 48281, "\u0120Implement": 48282, "\u0120Gutierrez": 48283, "\u0120760": 48284, "\u0120teleportation": 48285, "endra": 48286, "\u0120reversible": 48287, "stros": 48288, "Adventure": 48289, "083": 48290, "\u0120liberating": 48291, "\u0120asphalt": 48292, "\u0120Spend": 48293, "ARDS": 48294, "imsy": 48295, "PRES": 48296, "\u0120Emerging": 48297, "\u0120wildfires": 48298, "\u0120technologically": 48299, "\u0120emits": 48300, "\u0120ARTICLE": 48301, "\u0120irregularities": 48302, "\u0120cherish": 48303, "\u00e7\u012b\u012a": 48304, "\u0120stink": 48305, "\u0120Rost": 48306, "Economic": 48307, "\u0120coughing": 48308, "\u0120McCann": 48309, "properties": 48310, "ilantro": 48311, "\u0120renegoti": 48312, "Translation": 48313, "\u0120inquest": 48314, "\u0120Grape": 48315, "ooters": 48316, "gui": 48317, "\u0120Swordsman": 48318, "aceae": 48319, "hitting": 48320, "\u0120rc": 48321, "\u0120exerted": 48322, "\u0120SAP": 48323, "itent": 48324, "\u0120perilous": 48325, "\u0120obscurity": 48326, "\u0120assassinate": 48327, "\u0120aboriginal": 48328, "\u0120rescuing": 48329, "\u0120Shattered": 48330, "locking": 48331, "allion": 48332, "Changing": 48333, "\u0120Harrington": 48334, "\u0120Bord": 48335, "\u0120Afghans": 48336, "Jamie": 48337, "aretz": 48338, "\u0120Augustus": 48339, "\u0120386": 48340, "830": 48341, "\u0120jog": 48342, "okingly": 48343, "Trigger": 48344, "\u0120HOR": 48345, "Statistics": 48346, "\u0120viewership": 48347, "\u0120additives": 48348, "hur": 48349, "\u0120maximizing": 48350, "\u0120Rove": 48351, "\u0120Louie": 48352, "\u0120Bucket": 48353, "\u0120CHRIST": 48354, "ousel": 48355, "\u0120streaks": 48356, "irted": 48357, "\u0120tert": 48358, "\u0120colonialism": 48359, "\u0120burying": 48360, "yk": 48361, "Condition": 48362, "\u0120DPRK": 48363, "ById": 48364, "751": 48365, "\u00e2\u0139\u00bc": 48366, "\u0120worrisome": 48367, "\u0120vocational": 48368, "slice": 48369, "\u0120sails": 48370, "\u0120Correctional": 48371, "954": 48372, "\u0120tul": 48373, "Kid": 48374, "luster": 48375, "\u0120familial": 48376, "\u0120Spit": 48377, "\u0120Episcopal": 48378, "Specifically": 48379, "\u0120Volcano": 48380, "runs": 48381, "qs": 48382, "\u0120vetted": 48383, "\u0120crammed": 48384, "trop": 48385, "herer": 48386, "Thankfully": 48387, "\u0120percussion": 48388, "\u0120oranges": 48389, "\u0120roundup": 48390, "\u0120499": 48391, "xious": 48392, "Characters": 48393, "\u0120Zionism": 48394, "\u0120Rao": 48395, "\u00c3\u013d\u00c3\u013d": 48396, "WF": 48397, "\u0120unintentional": 48398, "ONEY": 48399, "Grab": 48400, "Commercial": 48401, "\u0120glutamate": 48402, "\u0120McKenna": 48403, "ruciating": 48404, "nington": 48405, "ihu": 48406, "Chan": 48407, "\u0120Swap": 48408, "\u0120leaflets": 48409, "\u0120functionally": 48410, "erous": 48411, "Farm": 48412, "\u0120caloric": 48413, "\u0120Literally": 48414, "concert": 48415, "\u0120shenan": 48416, "\u0120repaid": 48417, "eyes": 48418, "\u0120bashing": 48419, "\u0120Gorge": 48420, "\u0120collaborations": 48421, "\u0120unaccount": 48422, "itchie": 48423, "\u0120teamwork": 48424, "ppelin": 48425, "\u0120piping": 48426, "\u0120minced": 48427, "\u0120diam": 48428, "rieg": 48429, "\u0120mascara": 48430, "\u0120sucker": 48431, "\u0120Moons": 48432, "Apps": 48433, "\u0120Peck": 48434, "\u0120perv": 48435, "\u0120Float": 48436, "oley": 48437, "\u0120Nish": 48438, "imize": 48439, "\u0120aromatic": 48440, "uin": 48441, "endish": 48442, "!/": 48443, "\u0120Bicycle": 48444, "\u0120ASIC": 48445, "ileged": 48446, "\u0120Quadro": 48447, "iosyn": 48448, "\u0120lockout": 48449, "\u0120Wink": 48450, "SPEC": 48451, "Attempts": 48452, "\u0120seeded": 48453, "redo": 48454, "iasis": 48455, "\u0120snag": 48456, "\u00e3\u0125\u0137\u00e3\u0124\u00a9": 48457, "\u00e3\u0124\u00b6": 48458, "\u0120grounding": 48459, "\u0120reliever": 48460, "\u0120frivolous": 48461, "\u0120Gifts": 48462, "\u0120Faces": 48463, "Especially": 48464, "\u0120microbiome": 48465, "imag": 48466, "\u0120Schl": 48467, "\u0120Ples": 48468, "\u0120Bleach": 48469, "\u0120Irwin": 48470, "\u0120Eaton": 48471, "\u0120Disciple": 48472, "\u0120multiplication": 48473, "\u0120coerced": 48474, "\u0120419": 48475, "sth": 48476, "Evil": 48477, "Bomb": 48478, "\u0120exorc": 48479, "\u0120staggered": 48480, "LESS": 48481, "\u0120inertia": 48482, "\u0120EDIT": 48483, "\u0120gob": 48484, "Traditional": 48485, "\u0120classy": 48486, "Leary": 48487, "\u0120PAGE": 48488, "yrs": 48489, "\u0120transporter": 48490, "\u0120matured": 48491, "\u0120hijab": 48492, "\u0120biome": 48493, "Whereas": 48494, "\u0120extermination": 48495, "\u0120Tues": 48496, "\u0120Takeru": 48497, "\u0120Audrey": 48498, "erial": 48499, "\u0120Aden": 48500, "affles": 48501, "\u0120narcissistic": 48502, "\u0120Baird": 48503, "UTF": 48504, "Ire": 48505, "\u0120Connie": 48506, "Champ": 48507, "\u0120whispering": 48508, "\u0120Hatt": 48509, "DK": 48510, "\u0120disinfect": 48511, "\u0120deducted": 48512, "\u0120partake": 48513, "\u0120downgrade": 48514, "\u0120Esports": 48515, "\u0120Continuing": 48516, "\u0120democratically": 48517, "icrobial": 48518, "itta": 48519, "\u0120limestone": 48520, "\u0120exempted": 48521, "\u0120Frenzy": 48522, "Herm": 48523, "728": 48524, "\u0120fledgling": 48525, "Meta": 48526, "76561": 48527, "693": 48528, "%:": 48529, "wake": 48530, "526": 48531, "\u0120Discipline": 48532, "\u0120virginity": 48533, "\u0120Legions": 48534, "\u0120Frankie": 48535, "intent": 48536, "\u0120restrooms": 48537, "\u0120Router": 48538, "daq": 48539, "\u0120objectionable": 48540, "\u00e2\u0128\u0133": 48541, "wark": 48542, "\u0120Rahul": 48543, "gain": 48544, "activation": 48545, "absolute": 48546, "\u0120Accessed": 48547, "\u01202400": 48548, "oggles": 48549, "\u0120secondly": 48550, "\u0120DEFENSE": 48551, "\u0120postage": 48552, "wrapper": 48553, "sharp": 48554, "729": 48555, "\u0120communicates": 48556, "\u0120addon": 48557, "\u0120Militia": 48558, "Hong": 48559, "\u0120slumped": 48560, "\u0120JPEG": 48561, "\u0120Icar": 48562, "adish": 48563, "681": 48564, "\u0120majesty": 48565, "\u0120Wolfgang": 48566, "\u0120Elastic": 48567, "uper": 48568, "\u0120viz": 48569, "\u0120unconsciously": 48570, "\u0120STD": 48571, "\u0120Sass": 48572, "\u0120flowering": 48573, "\u0120Helic": 48574, "\u0120Draper": 48575, "\u0120Amateur": 48576, "\u0120manure": 48577, "\u0120disingen": 48578, "\u0120Lei": 48579, "bring": 48580, "949": 48581, "\u0120inhibited": 48582, "\u0120headquartered": 48583, "\u0120enigmatic": 48584, "\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd\u00ef\u00bf\u00bd": 48585, "\u0120redress": 48586, "RH": 48587, "\u0120rattled": 48588, "\u0120diction": 48589, "lio": 48590, "\u0120TBA": 48591, "\u0120SNAP": 48592, "Calling": 48593, "\u0120fascists": 48594, "\u0120Dove": 48595, "iewicz": 48596, "036": 48597, "\u0120coasts": 48598, "\u0120Rect": 48599, "\u0120)]": 48600, "Lot": 48601, "629": 48602, "\u0120SEM": 48603, "\u0120Petersen": 48604, "\u0120Explain": 48605, "\u0120Boards": 48606, "\u0120Bezos": 48607, "\u0120Journals": 48608, "\u01202024": 48609, "parser": 48610, "\u0120mistrust": 48611, "\u0120grate": 48612, "\u0120Locked": 48613, "boa": 48614, "Saint": 48615, "gaming": 48616, "\u0120vowel": 48617, "inately": 48618, "blow": 48619, "Allah": 48620, "\u0120unmatched": 48621, "\u0120bordering": 48622, "\u0120Expend": 48623, "nr": 48624, "Oracle": 48625, "rouch": 48626, "\u0120contiguous": 48627, "acus": 48628, "\u0120distraught": 48629, "581": 48630, "\u0120anatomical": 48631, "OX": 48632, "apixel": 48633, "833": 48634, "\u0120PLUS": 48635, "\u0120resusc": 48636, "\u0120abiding": 48637, "573": 48638, "\u0120vacancies": 48639, "Emily": 48640, "\u0120hypothal": 48641, "\u0120Werner": 48642, "\u0120Wee": 48643, "\u0120DJs": 48644, "513": 48645, "\u0120witchcraft": 48646, "\u0120acupuncture": 48647, "entary": 48648, "benefit": 48649, "Products": 48650, "\u0120PSP": 48651, "\u0120MPG": 48652, "\u0120Jinn": 48653, "\u0120Jarrett": 48654, "\u0120445": 48655, "\u0120Imaging": 48656, "\u0120Pyth": 48657, "Finish": 48658, "\u0120tex": 48659, "\u0120juveniles": 48660, "\u0120heroism": 48661, "\u0120doubtless": 48662, "\u0120Aki": 48663, "\u0120Tend": 48664, "\u0120Patriarch": 48665, "\u0120bitters": 48666, "\u0120Telecommunications": 48667, "itatively": 48668, "agna": 48669, "\u0120rg": 48670, "\u0120SOLD": 48671, "\u0120compulsion": 48672, "\u0120Nasa": 48673, "\u0120Kathryn": 48674, "\u0120millionaires": 48675, "\u0120intrinsically": 48676, "\u0120bolstered": 48677, "timeout": 48678, "flo": 48679, "\u0120tutor": 48680, "pour": 48681, "Statement": 48682, "\u0120{*": 48683, "\u0120Rudolph": 48684, "\u0120Kimberly": 48685, "rogens": 48686, "adiq": 48687, "]+": 48688, "\u0120indignation": 48689, "\u0120fracturing": 48690, "\u0120Releases": 48691, "\u0120Grain": 48692, "protein": 48693, "Lago": 48694, "\u0120vacations": 48695, "\u0120booted": 48696, "\u0120THREE": 48697, "\u0120HG": 48698, "orescence": 48699, "\u0120tf": 48700, "\u0120soar": 48701, "iosyncr": 48702, "\u0120glances": 48703, "\u0120Spoon": 48704, "\u0120Jury": 48705, "\u0120Cowboy": 48706, "\u0120creatively": 48707, "Higher": 48708, "\u0120solicitor": 48709, "\u0120hawk": 48710, "acio": 48711, "896": 48712, "\u0120superflu": 48713, "\u0120bombshell": 48714, "cture": 48715, "\u0120brokerage": 48716, "\u0120raiding": 48717, "\u0120french": 48718, "\u0120angled": 48719, "Transaction": 48720, "\u0120Genocide": 48721, "upe": 48722, "\u0120Haitian": 48723, "572": 48724, "!:": 48725, "\u0120unwittingly": 48726, "iterator": 48727, "scroll": 48728, "\u0120tallied": 48729, "\u0120biomedical": 48730, "\u0120CARD": 48731, "\u0120euphem": 48732, "\u0120brainstorm": 48733, "aquin": 48734, "Ko": 48735, "Michelle": 48736, "\u0120Runes": 48737, "\u0120Ballistic": 48738, "uders": 48739, "\u0120modesty": 48740, "\u0120iPads": 48741, "\u0120Ezekiel": 48742, "YE": 48743, "\u0120starship": 48744, "\u0120powerfully": 48745, "\u0120perl": 48746, "\u0120Shade": 48747, "\u0120Quart": 48748, "\u0120EEG": 48749, "\u0120fisherman": 48750, "OSED": 48751, "\u0120Typical": 48752, "dfx": 48753, "\u0120meshes": 48754, "\u0120etched": 48755, "worthiness": 48756, "\u0120toppled": 48757, "\u0120396": 48758, "orius": 48759, "Weiss": 48760, "\u0120mysql": 48761, "\u0120Valhalla": 48762, "\u00d9\u0134": 48763, "leasing": 48764, "\u0120recomp": 48765, "rapnel": 48766, "Sel": 48767, "043": 48768, "\u0120derailed": 48769, "\u0120Guides": 48770, "IRT": 48771, "\u0120dehuman": 48772, "\u0120Brittany": 48773, "\"))": 48774, "\u0120exclaim": 48775, "\u0120balk": 48776, "\u0120840": 48777, "CLAIM": 48778, "intel": 48779, "LAB": 48780, "\u0120pegged": 48781, "\u0120astroph": 48782, "smoking": 48783, "\u0120rigging": 48784, "\u0120fixation": 48785, "\u0120catapult": 48786, "inside": 48787, "\u0120Cascade": 48788, "\u0120Bolshevik": 48789, "Gaza": 48790, "Depth": 48791, "\u0120loudspe": 48792, "\u0120almonds": 48793, "meyer": 48794, "leness": 48795, "jen": 48796, "fresh": 48797, "\u0120unbeaten": 48798, "\u0120Squid": 48799, "\u0120Presumably": 48800, "Timer": 48801, "BW": 48802, "\u0120rosters": 48803, "\u0120ellipt": 48804, "\u0120Harriet": 48805, "database": 48806, "\u0120Mutual": 48807, "\u0120Commodore": 48808, "uked": 48809, "knife": 48810, "\u0120COMMUN": 48811, "hya": 48812, "\u0120melts": 48813, "archives": 48814, "\u0120ratification": 48815, "\u0120multiplying": 48816, "\u0120interoper": 48817, "\u0120ascert": 48818, "wings": 48819, "verting": 48820, "\u0120Scorpion": 48821, "aye": 48822, "\u0120Portsmouth": 48823, "\u0120MTA": 48824, "nit": 48825, "iazep": 48826, "\u0120quarantine": 48827, "\u0120slideshow": 48828, "\u0120centimeters": 48829, "\u0120synopsis": 48830, "\u0120spate": 48831, "thirst": 48832, "\u0120nominating": 48833, "\u0120Melvin": 48834, "Preview": 48835, "\u0120throb": 48836, "\u0120generational": 48837, "\u0120Radius": 48838, "restling": 48839, "putable": 48840, "awar": 48841, "NECT": 48842, "\u0120unlawfully": 48843, "\u0120Revelations": 48844, "Wikipedia": 48845, "surv": 48846, "\u0120eyeing": 48847, "ijn": 48848, "\u0120FW": 48849, "\u0120brunt": 48850, "\u0120interstellar": 48851, "\u0120clitor": 48852, "\u0120Croatian": 48853, "\u0120Chic": 48854, "eva": 48855, "\u0120Disapp": 48856, "\u0120Akin": 48857, "ineries": 48858, "dust": 48859, "Interested": 48860, "\u0120genesis": 48861, "\u0120Eucl": 48862, "\u00c3\u00b6n": 48863, "picking": 48864, "\u0120mutated": 48865, "\u0120disapprove": 48866, "\u0120HDL": 48867, "\u0120625": 48868, "\u00cc\u00b6": 48869, "cancer": 48870, "\u0120squats": 48871, "\u0120levers": 48872, "Discuss": 48873, "=]": 48874, "Dex": 48875, "\u0120VIDEOS": 48876, "AUD": 48877, "\u0120transact": 48878, "\u0120Kinect": 48879, "\u0120Kuala": 48880, "\u0120Cyp": 48881, "747": 48882, "\u0120shattering": 48883, "\u0120arsenic": 48884, "\u0120Intake": 48885, "\u0120Angelo": 48886, "\u0120Quit": 48887, "\u0120Khe": 48888, "\u01201893": 48889, "Maker": 48890, "029": 48891, "\u0120Painting": 48892, "Disable": 48893, "916": 48894, "\u0120analges": 48895, "\u0120tactile": 48896, "\u0120prophes": 48897, "\u0120diced": 48898, "\u0120Travels": 48899, "\u0120Header": 48900, "\u0120Clubs": 48901, "Assistant": 48902, "\u0120incrim": 48903, "\u0120dips": 48904, "\u0120crucifix": 48905, "\u0120Shanahan": 48906, "\u0120Interpret": 48907, "\u01204090": 48908, "alogy": 48909, "abba": 48910, "\u0120simulac": 48911, "husband": 48912, "SIM": 48913, "\u0120recycle": 48914, "ucer": 48915, "edged": 48916, "\u0120renaissance": 48917, "\u0120Bombay": 48918, "Catholic": 48919, "\u0120LINE": 48920, "\u0120Clothing": 48921, "reports": 48922, "\u0120plaus": 48923, "\u0120dag": 48924, "\u0120Mace": 48925, "ZI": 48926, "\u0120intruder": 48927, "\u0120Veterinary": 48928, "gru": 48929, "\u0120sneaky": 48930, "\u0120Sie": 48931, "\u0120Cinnamon": 48932, "POSE": 48933, "\u0120courier": 48934, "\u0120CNS": 48935, "\u0120emancipation": 48936, "sit": 48937, "\u0120playthrough": 48938, "\u0120Facilities": 48939, "virt": 48940, "\u0120Gauntlet": 48941, "Thompson": 48942, "\u0120unbelievably": 48943, "Parameters": 48944, "\u0120stitching": 48945, "igne": 48946, "\u0120THESE": 48947, "Privacy": 48948, "\u0120shenanigans": 48949, "\u0120vitri": 48950, "\u0120Valid": 48951, "591": 48952, "\u0143\u00b7": 48953, "\u0120Prototype": 48954, "inka": 48955, "SCP": 48956, "\u0120Tid": 48957, "\u00e8\u012a": 48958, "olded": 48959, "\u0120individuality": 48960, "\u0120barking": 48961, "\u0120mars": 48962, "\u0120WD": 48963, "\u0120820": 48964, "\u0120tir": 48965, "\u0120slapping": 48966, "\u0120disgruntled": 48967, "\u0120Angola": 48968, "rius": 48969, "\u0120Tornado": 48970, "\u0120Thurs": 48971, "\u0120captcha": 48972, "\u0120angst": 48973, "\u0120Pog": 48974, "\u0120Assassins": 48975, "\u0120Adidas": 48976, "\u0120joyful": 48977, "\u0120whining": 48978, "Emergency": 48979, "\u0120phosphorus": 48980, "\u0120attrition": 48981, "ophon": 48982, "\u0120Timberwolves": 48983, "\u0120Jah": 48984, "\u0120Bringing": 48985, "\u0120Wad": 48986, "\u0120Ensure": 48987, "ohl": 48988, "\u0120Xie": 48989, "ommel": 48990, "cmp": 48991, "\u0120zipper": 48992, "\u0120relat": 48993, "\u0120Corridor": 48994, "milo": 48995, "TING": 48996, "Avg": 48997, "\u0120cropped": 48998, "]}": 48999, "\u0120raged": 49000, "\u0120Lumpur": 49001, "\u0120Guerrero": 49002, "ourke": 49003, "Nut": 49004, "\u0120offsets": 49005, "oglu": 49006, "drm": 49007, "\u0120mortals": 49008, "latable": 49009, "\u0120dismissive": 49010, "\u00e4\u00b8\u012b": 49011, "\u0120throats": 49012, "\u0120chipset": 49013, "\u0120Spotlight": 49014, "Catalog": 49015, "artist": 49016, "Gb": 49017, "\u0120chilly": 49018, "\u0120stoked": 49019, "\u0120374": 49020, "Ward": 49021, "Latin": 49022, "\u0120fiasco": 49023, "\u0120bleach": 49024, "\u0120brav": 49025, "Enhanced": 49026, "\u0120inoc": 49027, "\u0120Fiorina": 49028, "_>": 49029, "\u0120leukemia": 49030, "\u0120eluc": 49031, "\u0120announcer": 49032, "\u0120Lithuan": 49033, "\u0120Armageddon": 49034, "\u00e5\u0129": 49035, "Lenin": 49036, "\u0120Ruk": 49037, "\u0120pepp": 49038, "\u0120Romantic": 49039, "\u0120PIT": 49040, "\u0120Interstellar": 49041, "\u0120Atkinson": 49042, "Raid": 49043, "Js": 49044, "Goal": 49045, "Course": 49046, "\u0120vanishing": 49047, "esley": 49048, "\u0120Rounds": 49049, "Elsa": 49050, "593": 49051, "\u0120redundancy": 49052, "\u0120STAND": 49053, "\u0120prophetic": 49054, "\u0120habitable": 49055, "ryu": 49056, "\u0120faintly": 49057, "MODE": 49058, "\u0120flanked": 49059, "IRC": 49060, "Awesome": 49061, "\u0120spurious": 49062, "\u0120Zah": 49063, "\u0120MSG": 49064, "\u0120shading": 49065, "\u0120motivational": 49066, "\u0120Santana": 49067, "\u0120SPR": 49068, "\u0120excruciating": 49069, "omial": 49070, "\u0120Miko": 49071, "\u0120Leopard": 49072, "Abyss": 49073, "\u0120[|": 49074, "dirty": 49075, "\u0120baths": 49076, "\u0120demoral": 49077, "andre": 49078, "PB": 49079, "\u0120unification": 49080, "\u0120sacrament": 49081, "\u0120[&": 49082, "\u0120priceless": 49083, "\u0120gelatin": 49084, "\u0120emanating": 49085, "\u0120Allaah": 49086, "986": 49087, "\u0120outburst": 49088, "\u0120eras": 49089, "\u0120XVI": 49090, "\u0120SPI": 49091, "Ott": 49092, "\u0120Lazarus": 49093, "PLIED": 49094, "Flying": 49095, "blogs": 49096, "Wisconsin": 49097, "Raven": 49098, "\u0120rebate": 49099, "\u0120creeps": 49100, "\u0120Span": 49101, "\u0120Painter": 49102, "\u0120Kira": 49103, "\u0120Amos": 49104, "\u0120Corvette": 49105, "Consumer": 49106, "\u0120Recover": 49107, "cki": 49108, "\u0120pesky": 49109, "\u0120Invention": 49110, "Companies": 49111, "\u0120challengers": 49112, "ademic": 49113, "\u0120Ukrainians": 49114, "\u0120Neurolog": 49115, "\u0120Forsaken": 49116, "\u0120entrants": 49117, "\u0120embattled": 49118, "\u0120defunct": 49119, "\u0120Glacier": 49120, "\u0120poisons": 49121, "\u0120Horses": 49122, "makes": 49123, "\u0120Dirt": 49124, "\u0120423": 49125, "hhh": 49126, "\u0120Transformation": 49127, "QUIRE": 49128, "..................": 49129, "\u0120traveller": 49130, "\u0120Sexy": 49131, "\u0120Kern": 49132, "ipolar": 49133, "\u0120ransomware": 49134, "oooooooooooooooo": 49135, "Ec": 49136, "ruby": 49137, "Professional": 49138, "\u0120Outbreak": 49139, "argument": 49140, "Grey": 49141, "\u0120Fifa": 49142, "\u0120CHO": 49143, "\u0120FORM": 49144, "\u0120Amtrak": 49145, "-[": 49146, "\u0120cradle": 49147, "\u0120antioxidants": 49148, "\u00e3\u0123\u00ae\u00e5\u00ae": 49149, "736": 49150, "\u0120NASL": 49151, "\u0120Contributions": 49152, "Indiana": 49153, "\u0120STEP": 49154, "CSS": 49155, "\u0120salient": 49156, "\u0120allocations": 49157, "yrights": 49158, "\u0120mashed": 49159, "\u0120Cutter": 49160, "Sexual": 49161, "\u0120pounded": 49162, "\u0120fanbase": 49163, "\u0120casc": 49164, "\u0120Transparency": 49165, "\u0120analytic": 49166, "\u0120Summoner": 49167, "\u00d7\u0140": 49168, "\u0120ADC": 49169, "detail": 49170, "\u0120vanquished": 49171, "\u0120crabs": 49172, "arie": 49173, "Destroy": 49174, "\u0120Sack": 49175, "\u0120transistor": 49176, "Alabama": 49177, "\u0120Koen": 49178, "\u0120Fisheries": 49179, "cone": 49180, "\u0120annexed": 49181, "\u0120MGM": 49182, "esa": 49183, "\u0120faked": 49184, "\u0120Congratulations": 49185, "\u0120hindered": 49186, "\u0120correctional": 49187, "\u0120ITV": 49188, "leeve": 49189, "\u0120inappropriately": 49190, "licks": 49191, "\u0120trespass": 49192, "\u0120paws": 49193, "\u0120negotiator": 49194, "\u0120Christensen": 49195, "limits": 49196, "\u0120Dianne": 49197, "\u0120elegance": 49198, "\u0120Contracts": 49199, "anke": 49200, "Obj": 49201, "\u0120vigilance": 49202, "\u0120castles": 49203, "\u0120NAD": 49204, "\u0120Holo": 49205, "\u0120emphatically": 49206, "\u0120Titus": 49207, "\u0120Serving": 49208, "\u0120Richie": 49209, "\u0120Pigs": 49210, "568": 49211, "\u0120animosity": 49212, "\u0120Attributes": 49213, "\u0120Uriel": 49214, "MQ": 49215, "myra": 49216, "\u0120Applicant": 49217, "\u0120psychiatrists": 49218, "\u0120Vij": 49219, "\u0120Abby": 49220, "agree": 49221, "Push": 49222, "\u0120kWh": 49223, "hiba": 49224, "\u0120incite": 49225, "\u0120Weasley": 49226, "\u0120Taxi": 49227, "ministic": 49228, "hyper": 49229, "\u0120Farn": 49230, "\u0120601": 49231, "\u0120Nationwide": 49232, "Fake": 49233, "952": 49234, "\u0120maize": 49235, "\u0120interacted": 49236, "\u0120transitioned": 49237, "\u0120parasitic": 49238, "\u0120harmonic": 49239, "\u0120decaying": 49240, "\u0120baseless": 49241, "nsics": 49242, "\u0120transpired": 49243, "\u0120abundantly": 49244, "\u0120Forensic": 49245, "\u0120treadmill": 49246, "\u0120Jav": 49247, "aband": 49248, "\u0120sshd": 49249, "\u0120frontman": 49250, "\u0120Jakarta": 49251, "oller": 49252, "drops": 49253, "\u0120SERVICES": 49254, "romptu": 49255, "ophical": 49256, "hospital": 49257, "bledon": 49258, "645": 49259, "\u0120midrange": 49260, "\u0120EVENT": 49261, "culated": 49262, "rawled": 49263, "\u0120perched": 49264, "\u0120overboard": 49265, "\u0120Peel": 49266, "\u0120Pwr": 49267, "\u0120Carth": 49268, "\u0120COMPLE": 49269, "coe": 49270, "shall": 49271, "\u0120deterrence": 49272, "METHOD": 49273, "\u0120Absent": 49274, "MEN": 49275, "\u0120sill": 49276, "\u0120LEVEL": 49277, "York": 49278, "\u0120sinners": 49279, "\u0120OPEC": 49280, "\u0120Nur": 49281, "\u0120Designs": 49282, "selection": 49283, "\u0120unworthy": 49284, "CHA": 49285, "\u0120strengthens": 49286, "883": 49287, "edly": 49288, "\u0120slicing": 49289, "\u0120malnutrition": 49290, "\u0120filmmaking": 49291, "\u0120Polk": 49292, "urated": 49293, "\u0120421": 49294, "breakers": 49295, "!'\"": 49296, "\u0120wetlands": 49297, "\u0120Discrimination": 49298, "\u0120allowable": 49299, "\u0120steered": 49300, "\u0120Sicily": 49301, "SAM": 49302, "\u0120mustache": 49303, "\u0120mids": 49304, "\u0120clipped": 49305, "\u0120circulate": 49306, "\u0120brittle": 49307, "\u0120Buildings": 49308, "raised": 49309, "\u0120Roundup": 49310, "\u0120wealthier": 49311, "\u0120overwrite": 49312, "\u0120overpowered": 49313, "\u0120Gerrard": 49314, "sites": 49315, "PDATED": 49316, "\u0120acutely": 49317, "\u0120Gamble": 49318, "\u0120pim": 49319, "\u0120Kus": 49320, "Typically": 49321, "Deploy": 49322, "\u0120Moroccan": 49323, "potion": 49324, "combe": 49325, "\u0120vigilante": 49326, "\u0120363": 49327, "Stew": 49328, "\u0120Bagg": 49329, "\u0120resided": 49330, "\u0120Spo": 49331, "\u0120remnant": 49332, "\u0120emptiness": 49333, "brainer": 49334, "\u0120outpatient": 49335, "priority": 49336, "\u0120leptin": 49337, "\u0120Payton": 49338, "\u0120Gleaming": 49339, "\u0120Shed": 49340, "\u0120Polo": 49341, "\u0120Mormonism": 49342, "restricted": 49343, "arlane": 49344, "wx": 49345, "\u0120creatine": 49346, "\u0120Anon": 49347, "\u0120STUD": 49348, "\u0120JUL": 49349, "\u0120Tee": 49350, "528": 49351, "089": 49352, "\u0120hatched": 49353, "Dispatch": 49354, "\u0120Composite": 49355, "\u0120451": 49356, "puff": 49357, "\u0120XCOM": 49358, "\u0120Orn": 49359, "\u0120THANK": 49360, "ENDED": 49361, "\u0120Asheville": 49362, "\u0120\u00c3\u013e": 49363, "\u0120mango": 49364, "\u0120Slightly": 49365, "worldly": 49366, "\u0120Wander": 49367, "\u0120Expand": 49368, "\u0120Chr": 49369, "Mist": 49370, "\u0120orthodoxy": 49371, "\u0120UNESCO": 49372, "regate": 49373, "Elsewhere": 49374, "kie": 49375, "irled": 49376, "\u0120topple": 49377, "\u0120adoptive": 49378, "\u0120Legs": 49379, "dress": 49380, "\u0120Sagan": 49381, "bare": 49382, "\u0120Glou": 49383, "Crunch": 49384, "\u0120helpers": 49385, "\u0120chronically": 49386, "\u0120Huma": 49387, "10000": 49388, "\u0120accommodating": 49389, "\u00e4\u00ba\u0136": 49390, "\u0120wrinkles": 49391, "\u0120dodged": 49392, "fourth": 49393, "\u0120precon": 49394, "\u0120compressor": 49395, "\u0120Kare": 49396, "\u0120evict": 49397, "\u0120Warwick": 49398, "imar": 49399, "\u0120modernization": 49400, "\u0120bandwagon": 49401, "\u0120refuted": 49402, "\u0120netted": 49403, "\u0120Naples": 49404, "\u0120Genie": 49405, "perors": 49406, "\u0120fielded": 49407, "\u0120dere": 49408, "\u0120Parables": 49409, "lees": 49410, "\u0120trout": 49411, "aspers": 49412, "\u0120nihil": 49413, "\u0120happiest": 49414, "\u0120floppy": 49415, "\u0120Loft": 49416, "\u0120Heard": 49417, "\u0120unison": 49418, "\u0120lug": 49419, "\u0120Redmond": 49420, "classic": 49421, "Supporters": 49422, "SHIP": 49423, "GMT": 49424, "\u0120fuelled": 49425, "\u00e7\u0132": 49426, "\u0120dd": 49427, "\u0120Eminem": 49428, "\u01201897": 49429, "NYSE": 49430, "\u0120secretaries": 49431, "\u0120FIA": 49432, "\u0120Canaveral": 49433, "Favorite": 49434, "\u0120pomp": 49435, "\u0120detainee": 49436, "ership": 49437, "aimon": 49438, "iour": 49439, "\u0120Apex": 49440, "\u0120plantations": 49441, "amia": 49442, "acion": 49443, "Rust": 49444, "\u0120towed": 49445, "\u0120Truly": 49446, "577": 49447, "\u0120sheltered": 49448, "rider": 49449, "Wo": 49450, "\u0120lair": 49451, "\u0120Intelligent": 49452, "improve": 49453, "matically": 49454, "\u0120etiquette": 49455, "adra": 49456, "allo": 49457, "\u0120Juno": 49458, "anything": 49459, "\u0120Struggle": 49460, "\u0120Predict": 49461, "\u0120Grimes": 49462, "\u0120AMERICA": 49463, "ctx": 49464, "\u0120Situation": 49465, "WOOD": 49466, "\u0120soluble": 49467, "meier": 49468, "\u0120intolerable": 49469, "angering": 49470, "\u0120uninterrupted": 49471, "\u0120tooltip": 49472, "\u0120interrogated": 49473, "\u0120gunned": 49474, "\u0120Sneak": 49475, "\u00e6\u0143\u00a6": 49476, "\u0120tether": 49477, "\u0120crumble": 49478, "Lens": 49479, "\u0120clustered": 49480, "\u0120Syl": 49481, "\u0120Hasan": 49482, "\u0120dystopian": 49483, "wana": 49484, "\u0120joystick": 49485, "\u0120Thib": 49486, "ammu": 49487, "Tomorrow": 49488, "546": 49489, "\u0120overcame": 49490, "\u0120minimized": 49491, "ceptor": 49492, "Runner": 49493, "ENGTH": 49494, "\u0120Brenda": 49495, "\u0120Achievements": 49496, "\u0120torches": 49497, "\u0120rapport": 49498, "\u0120Investigator": 49499, "\u0120Handling": 49500, "relation": 49501, "grey": 49502, "815": 49503, "\u0120kcal": 49504, "\u0120Commands": 49505, "dq": 49506, "\u0120curls": 49507, "\u0120bearer": 49508, "\u0120cynicism": 49509, "itri": 49510, "\u0120Useful": 49511, "Bee": 49512, "DCS": 49513, "\u0120abras": 49514, "Pract": 49515, "BILITIES": 49516, "712": 49517, "\u0120debugger": 49518, "\u0120debtor": 49519, "\u0120Lia": 49520, "\u0120Kers": 49521, "\u0120exacerbate": 49522, "\u0120Stacy": 49523, "\u0120Bland": 49524, "\u0120Scenes": 49525, "\u0120branching": 49526, "\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a\u00e2\u0138\u012a": 49527, "apeake": 49528, "\u0120salsa": 49529, "\u0120mishand": 49530, "\u0120Konami": 49531, "\u0120Nib": 49532, "\u0120anecdote": 49533, "\u0120agreeable": 49534, "\u00cf\u012b": 49535, "\u0120Nathaniel": 49536, "\u0120Heisman": 49537, "\u0120Beware": 49538, "\u01201886": 49539, "spective": 49540, "691": 49541, "522": 49542, "\u0120inhibits": 49543, "\u0120hashing": 49544, "\u01201889": 49545, "\u00e5\u00b0\u0128": 49546, "vich": 49547, "Pure": 49548, "\u0120solidly": 49549, "\u0120aspirin": 49550, "imaru": 49551, "\u0120streetcar": 49552, "\u0120UCS": 49553, "\u0120Judd": 49554, "\u0120flashbacks": 49555, "pins": 49556, "\u01201440": 49557, "\u0120UNHCR": 49558, "\u0120Symptoms": 49559, "TIT": 49560, "538": 49561, "Fra": 49562, "%);": 49563, "\u0120ooz": 49564, "\u0120curfew": 49565, "\u0120calmed": 49566, "\u0120participates": 49567, "TeX": 49568, "\u0120nonsensical": 49569, "\u0120fullback": 49570, "\u0120DeL": 49571, "monkey": 49572, "hari": 49573, "\u0120metabolites": 49574, "\u0120looted": 49575, "\u0120ALWAYS": 49576, "\u0120BCC": 49577, "Lt": 49578, "ochet": 49579, "Bone": 49580, "\u0120vetoed": 49581, "\u0120gcc": 49582, "\u0120CLICK": 49583, "\u01201888": 49584, "saf": 49585, "\u0120stiffness": 49586, "\u0120lowly": 49587, "\u0120Geh": 49588, "verson": 49589, "orset": 49590, "\u0120unforeseen": 49591, "\u0120anesthesia": 49592, "\u0120Optical": 49593, "\u0120reconstructed": 49594, "\u0120Tup": 49595, "shows": 49596, "NEWS": 49597, "\u0120Newspaper": 49598, "\u0120ASA": 49599, "tera": 49600, "Numbers": 49601, "\u0120inexplicable": 49602, "\u00d7\u0133": 49603, "\u0120hardness": 49604, "untarily": 49605, "\u0120Acer": 49606, "gradient": 49607, "ARDIS": 49608, "\u0120woodland": 49609, "\u0120metaphors": 49610, "\u0120Wembley": 49611, "\u0120Pavel": 49612, "philis": 49613, "\u0120rewriting": 49614, "\u0120perceptual": 49615, "\u01201070": 49616, "worms": 49617, "\u0120Downs": 49618, "\u0120unsurprisingly": 49619, "\u0120tagging": 49620, "flame": 49621, "\u0120litres": 49622, "\u0120bounces": 49623, "\u0120Babe": 49624, "shut": 49625, "\u0120overdoses": 49626, "\u0120Sheila": 49627, "\u0120Chau": 49628, "\u0120Bless": 49629, "Capture": 49630, "\u0120Significant": 49631, "\u0120Scion": 49632, "\u0120389": 49633, "\u0120McH": 49634, "\u0120Titanium": 49635, "\u0120Meal": 49636, "ameda": 49637, "agents": 49638, "aggressive": 49639, "Billy": 49640, "763": 49641, "\u0120Saying": 49642, "DERR": 49643, "itone": 49644, "Collins": 49645, "Bound": 49646, "\u0120bolted": 49647, "\u0120DMCA": 49648, "953": 49649, "\u0120uniqueness": 49650, "\u0120epigen": 49651, "unci": 49652, "antam": 49653, "\u0120reckoning": 49654, "chairs": 49655, "OGR": 49656, "\u0120Senegal": 49657, "\u01201862": 49658, "relevant": 49659, "\u0120\u00c2\u00af": 49660, "\u0120pharmacies": 49661, "\u0120Geral": 49662, "vier": 49663, "Yan": 49664, "ORPG": 49665, "\u0120rabid": 49666, "bending": 49667, "\u0120UNITED": 49668, "\u0120465": 49669, "Assembly": 49670, "\u0120weep": 49671, "\u0120behest": 49672, "\u0120Mothers": 49673, "\u0120Jace": 49674, "hid": 49675, "\u0120whirlwind": 49676, "\u0120UNIVERS": 49677, "\u0120utopian": 49678, "\u0120kidnap": 49679, "Philipp": 49680, "Kin": 49681, "893": 49682, "\u0120livestream": 49683, "\u0120MISS": 49684, "\u0120subversive": 49685, "\u0120Techniques": 49686, "\u0120JUSTICE": 49687, "\u0120BASE": 49688, "\u0120387": 49689, "\u0120assailants": 49690, "\u0120Hardcore": 49691, "\u0120sprinkled": 49692, "\u0120Pse": 49693, "\u00e9\u013c": 49694, "printed": 49695, "\u0120Hau": 49696, "ORGE": 49697, "\u0120TOUR": 49698, "\u0120laced": 49699, "\u0120itch": 49700, "Giving": 49701, "\u0120ported": 49702, "781": 49703, "////////////////////////////////": 49704, "breeding": 49705, "\u0120logger": 49706, "\u0120HOL": 49707, "innie": 49708, "Firstly": 49709, "\u0120embryonic": 49710, "\u0120delegated": 49711, "pai": 49712, "OIL": 49713, "\u0120centrally": 49714, "\u0120Rx": 49715, "\u0120Scouting": 49716, "Dutch": 49717, "\u0120hereditary": 49718, "\u0120Cruiser": 49719, "sat": 49720, "529": 49721, "\u0120Marriott": 49722, "othermal": 49723, "\u0120prohibitions": 49724, "Earn": 49725, "\u0120Stab": 49726, "\u0120Colleges": 49727, "\u0120Belief": 49728, "stretched": 49729, "\u0120LH": 49730, "\u0120EntityItem": 49731, "CIA": 49732, "\u0120unrem": 49733, "\u0120laureate": 49734, "\u0120denominations": 49735, "summary": 49736, "hler": 49737, "Spect": 49738, "\u0120Klaus": 49739, "\u0120Beans": 49740, "\u0120insur": 49741, "\u0120PAX": 49742, "\u0120fielder": 49743, "\u0120Vet": 49744, "\u0120Sparrow": 49745, "zie": 49746, "\u0120SQ": 49747, "\u0120Mondays": 49748, "\u0120Offline": 49749, "\u0120Lerner": 49750, "\u0120Extensions": 49751, "Ireland": 49752, "\u0120patronage": 49753, "\u0120contrasted": 49754, "\u0120Mania": 49755, "hirt": 49756, "Moscow": 49757, "\u0120condemns": 49758, "\u0120Ange": 49759, "\u0120composing": 49760, "\u0120Pepe": 49761, "\u0120Paddock": 49762, "\u0120heterogeneity": 49763, "\u0120ideologically": 49764, "\u0120fishes": 49765, "\u0120cursing": 49766, "\u0120Rutherford": 49767, "\u0120Floating": 49768, "\u0120Amelia": 49769, "Tea": 49770, "Synopsis": 49771, "\u0120stunts": 49772, "\u0120bead": 49773, "\u0120stocking": 49774, "\u0120MILL": 49775, "obook": 49776, "massive": 49777, "\\<": 49778, "\u0120hump": 49779, "\u0120Preferences": 49780, "EngineDebug": 49781, "geist": 49782, "\u0120Nieto": 49783, "omever": 49784, "ishy": 49785, "evaluate": 49786, "colonial": 49787, "Alternative": 49788, "\u0120GoPro": 49789, "\u0120Vortex": 49790, "\u0120NETWORK": 49791, "ansky": 49792, "Secure": 49793, "\u0120Thrust": 49794, "Snake": 49795, "\u0120parcels": 49796, "\u0120samurai": 49797, "\u0120actresses": 49798, "Nap": 49799, "MF": 49800, "iferation": 49801, "Beer": 49802, "523": 49803, "\u0120Ily": 49804, "ointment": 49805, "Ping": 49806, "\u0120striped": 49807, "\u0120Mellon": 49808, "ossession": 49809, "\u0120neutron": 49810, "endium": 49811, "\u0120aph": 49812, "\u0120Flavoring": 49813, "\u0120383": 49814, "\u0120responsiveness": 49815, "\u0120Jindal": 49816, "\u0120Hitchcock": 49817, "Denver": 49818, "\u0120DRAGON": 49819, "smanship": 49820, "\u0120Dupl": 49821, "\u0120sly": 49822, "\u0120webcam": 49823, "\u0120Twain": 49824, "\u0120Darling": 49825, "iliate": 49826, "consumer": 49827, "DIT": 49828, "\u0120namesake": 49829, "\u0120unorthodox": 49830, "\u0120funer": 49831, "\u0120PLoS": 49832, "\u0120CONTROL": 49833, "ozyg": 49834, "oglobin": 49835, "FACE": 49836, "ERG": 49837, "\u0120Dia": 49838, "\u0120Fiesta": 49839, "cele": 49840, "034": 49841, "\u0120enclave": 49842, "\u00e2\u0138\u00ac\u00e2\u0138\u00ac": 49843, "onement": 49844, "alist": 49845, "Mand": 49846, "\u0120homegrown": 49847, "\u0120Fancy": 49848, "\u0120conceptions": 49849, "\u0120Contains": 49850, "ureen": 49851, "\u0120reiterate": 49852, "\u0120meager": 49853, "\u0120installments": 49854, "Spawn": 49855, "627": 49856, "\u0120photoc": 49857, "\u0120Cabrera": 49858, "\u0120Rosenthal": 49859, "\u0120Lansing": 49860, "isner": 49861, "\u0120invests": 49862, "\u0120UFOs": 49863, "EXP": 49864, "Hardware": 49865, "\u0120tragically": 49866, "\u0120concedes": 49867, "ieft": 49868, "cham": 49869, "borgh": 49870, "\u0120Schr": 49871, "\u0120Melanie": 49872, "\u0120Hoy": 49873, "\u0120visitation": 49874, "\u0120idiosyncr": 49875, "\u0120fractions": 49876, "\u0120foreskin": 49877, "obos": 49878, "\u0120poaching": 49879, "\u0120VIEW": 49880, "\u0120stimulates": 49881, "\u0120Gork": 49882, "canon": 49883, "MIC": 49884, "\u0120Nemesis": 49885, "\u0120Indra": 49886, "\u0120DMV": 49887, "\u0120529": 49888, "\u0120inspecting": 49889, "\u0120grandma": 49890, "\u0120Whedon": 49891, "\u0120Shant": 49892, "\u0120Purg": 49893, "ikan": 49894, "\u0120Teg": 49895, "\u0120CLR": 49896, "zac": 49897, "Victoria": 49898, "\u0120Verify": 49899, "ionics": 49900, "\u0120partying": 49901, "\u0120Mou": 49902, "colour": 49903, "\u0120testimonies": 49904, "lations": 49905, "\u0120pressuring": 49906, "hiro": 49907, "acers": 49908, "\u0120fid": 49909, "angler": 49910, "\u0120CSI": 49911, "\u0120hereafter": 49912, "\u0120dissidents": 49913, "reporting": 49914, "iphany": 49915, "chev": 49916, "\u0120solitude": 49917, "\u0120lobe": 49918, "\u0120indis": 49919, "\u0120credential": 49920, "recent": 49921, "adult": 49922, "\u0120Nirvana": 49923, "\u0120Franchise": 49924, "Layer": 49925, "Hyp": 49926, "\u0120Berkshire": 49927, "\u0120wills": 49928, "tif": 49929, "\u0120totem": 49930, "\u0120Judah": 49931, "repair": 49932, "Instant": 49933, "548": 49934, "\u0120embassies": 49935, "\u0120bottleneck": 49936, "\u0120bount": 49937, "\u0120typew": 49938, "\u0120Alvin": 49939, "jing": 49940, "imilar": 49941, "Rush": 49942, "\u0120brim": 49943, "\u0120HELP": 49944, "Aim": 49945, "]'": 49946, "\u0120passively": 49947, "\u0120bounded": 49948, "\u0120Rated": 49949, "\u0120criminality": 49950, "\u0120biomark": 49951, "\u0120dispatcher": 49952, "\u0120Towards": 49953, "\u0120+++": 49954, "righteous": 49955, "frog": 49956, "\u0120Panc": 49957, "Carter": 49958, "032": 49959, "\u00e6\u00a9\u0141": 49960, "\u0120ultraviolet": 49961, "\u0120Licensed": 49962, "\u0120Tata": 49963, "\u0120Blessing": 49964, "\u0120GAM": 49965, "\u0120chemically": 49966, "\u0120Seaf": 49967, "\u0120RELE": 49968, "\u0120Mercenary": 49969, "capitalist": 49970, "\u0120formulations": 49971, "\u0120annihilation": 49972, "\u0120Verb": 49973, "\u0120Argon": 49974, "\u0120unloaded": 49975, "\u0120morphed": 49976, "\u0120conquering": 49977, "backer": 49978, "IELD": 49979, "\u0120thefts": 49980, "\u0120frontrunner": 49981, "\u0120Royale": 49982, "\u0120Fundamental": 49983, "elight": 49984, "Chip": 49985, "necessary": 49986, "ayn": 49987, "\u0120Slip": 49988, "\u0120448": 49989, "cerned": 49990, "Pause": 49991, "\u0120shockingly": 49992, "\u0120ABV": 49993, "\u0120composure": 49994, "733": 49995, "\u0120Motorsport": 49996, "ahime": 49997, "Murray": 49998, "Mach": 49999, "\u0120grids": 50000, "\u0120debian": 50001, "\u0120furthermore": 50002, "\u0120dexterity": 50003, "\u0120Collections": 50004, "oslov": 50005, "ilage": 50006, "bj": 50007, "\u0120Monteneg": 50008, "\u0120strutConnector": 50009, "\u0120massacres": 50010, "\u0120briefs": 50011, "fetched": 50012, "uvian": 50013, "olition": 50014, "Failure": 50015, "emonic": 50016, "\u0120flared": 50017, "\u0120claimant": 50018, "\u0120cures": 50019, "\u0120giveaways": 50020, "\u0120Substance": 50021, "alions": 50022, "\u0120cringe": 50023, "\u0120Kul": 50024, "\u0120aristocracy": 50025, "\u0120Ulster": 50026, "olated": 50027, "housing": 50028, "\u0120MIS": 50029, "\u0120glared": 50030, "\u0120Wilhelm": 50031, "needs": 50032, "lambda": 50033, "builders": 50034, "\u0120VIS": 50035, "\u0120radiator": 50036, "\u0120Ghostbusters": 50037, "\u0120436": 50038, "actual": 50039, "\u0120herds": 50040, "\u00c3\u00a7a": 50041, "watching": 50042, "\u0120countering": 50043, "Charge": 50044, "\u0120charred": 50045, "\u0120warheads": 50046, "\u0120iodine": 50047, "\u0120Macy": 50048, "041": 50049, "\u0120departures": 50050, "\u0120Sins": 50051, "\u0120dyed": 50052, "\u0120Concepts": 50053, "gado": 50054, "713": 50055, "\u0120quotations": 50056, "\u0120gist": 50057, "\u0120Christy": 50058, "\u0120antigen": 50059, "\u0120Hemp": 50060, "\u0120Drawn": 50061, "\u0120Barg": 50062, "ezvous": 50063, "\u0120paternity": 50064, "\u0120ardu": 50065, "\u0120Anchorage": 50066, "\u0120Rik": 50067, "\u0120overloaded": 50068, "\u0120Username": 50069, "\u0120Tammy": 50070, "\u0120Nau": 50071, "\u0120Cellular": 50072, "\u0120waning": 50073, "\u0120rodent": 50074, "\u0120Worcester": 50075, "ilts": 50076, "\u0120Tad": 50077, "\u0120dwellings": 50078, "\u0120bullish": 50079, "431": 50080, "\u0120retaliate": 50081, "\u0120migraine": 50082, "\u0120Chevron": 50083, "CHECK": 50084, "\u0120donkey": 50085, "crim": 50086, "SPA": 50087, "\u0120Analog": 50088, "\u0120marquee": 50089, "\u0120Haas": 50090, "Bir": 50091, "\u0120GDDR": 50092, "\u0120Downloads": 50093, "\u0120willpower": 50094, "\u0120Forth": 50095, "\u0120Recorded": 50096, "\u0120impossibility": 50097, "\u0120Logged": 50098, "\u0120Franks": 50099, "\u0120Ratt": 50100, "initions": 50101, "\u0120cleaners": 50102, "\u0120sorely": 50103, "\u0120flickering": 50104, "\u0120Examination": 50105, "catching": 50106, "alloween": 50107, "Msg": 50108, "\u0120dunno": 50109, "Fa": 50110, "\u0120dysph": 50111, "crazy": 50112, ".''.": 50113, "\u0120mainline": 50114, "\u0120cs": 50115, "\u0120ptr": 50116, "\u0120Wally": 50117, "igun": 50118, "951": 50119, "\u0120Bigfoot": 50120, "fights": 50121, "\u0120retrieving": 50122, "Jr": 50123, "\u0120duplication": 50124, "\u0120Explan": 50125, "\u0120relational": 50126, "\u0120quaint": 50127, "\u0120biscuits": 50128, "\u0120ado": 50129, "\u0120shudder": 50130, "\u0120antidote": 50131, "blooded": 50132, "ksh": 50133, "\u0120sauces": 50134, "\u0120reinvest": 50135, "\u0120dispensary": 50136, "\u0120Diver": 50137, "\u01209000": 50138, "student": 50139, "\u0120insepar": 50140, "escap": 50141, "\u0120toddlers": 50142, "\u0120GPIO": 50143, "\u0120Assignment": 50144, "headers": 50145, "\u0120lackluster": 50146, "\u0120aback": 50147, "956": 50148, "\u0120toolbar": 50149, "745": 50150, "\u0120oust": 50151, "\u0120contemplation": 50152, "\u0120PRESIDENT": 50153, "\u0120458": 50154, "======": 50155, "\u0120guaranteeing": 50156, "\u0120Heist": 50157, "\u0120Cannes": 50158, "\u013b\u00bd": 50159, "\u0120collaborator": 50160, "\u0120Amp": 50161, "\u0120gou": 50162, "\u0120SHALL": 50163, "stories": 50164, "783": 50165, "\u0120mobilized": 50166, "\u0120brood": 50167, "\u0120LU": 50168, "\u0120\u00f0\u0141\u0133": 50169, "\u0120refin": 50170, "\u0120Anthropology": 50171, "vind": 50172, "illi": 50173, "\u0120warranties": 50174, "\u0120Babel": 50175, "\u0120swath": 50176, "\u0120caches": 50177, "\u0120antagonists": 50178, "artifacts": 50179, "\u0120hotly": 50180, "\u0120Starts": 50181, "\u0120G\u00c3\u00b6": 50182, "zag": 50183, "!!!!!": 50184, "\u0120scourge": 50185, "\u0120conspiring": 50186, "ruits": 50187, "reverse": 50188, "\u0120Sheen": 50189, "\u0120Jesuit": 50190, "\u0120Giovanni": 50191, "adies": 50192, "\u0120buttocks": 50193, "earcher": 50194, "acan": 50195, "\u0120volleyball": 50196, "\u0120shrouded": 50197, "\u0120scoreboard": 50198, "bats": 50199, "\u0120IPM": 50200, "\u0120asses": 50201, "\u0120deregulation": 50202, "\u0120Telegram": 50203, "\u0120Reboot": 50204, "\u01207000": 50205, "\u0120Canary": 50206, "\u0120kernels": 50207, "\u0120Fran\u00c3\u00a7ois": 50208, "\u0120Duff": 50209, "\u0120Pon": 50210, "\u0120Leica": 50211, "\u0120Garmin": 50212, "\u0120orphans": 50213, "\u0120Claudia": 50214, "\u0120calendars": 50215, "\u0120Leilan": 50216, "ento": 50217, "Rocket": 50218, "\u0120brunch": 50219, "\u0120Hawking": 50220, "ainers": 50221, "\u0120sensibilities": 50222, "\u0120kW": 50223, "\u0120Kand": 50224, "\u0120reclaimed": 50225, "\u0120interestingly": 50226, "\u00d7\u00a9": 50227, "romy": 50228, "JM": 50229, "\u0120Enhancement": 50230, "bush": 50231, "Skip": 50232, "\u0120rappers": 50233, "\u0120gazing": 50234, "pedia": 50235, "athlon": 50236, "Revolution": 50237, "\u0120snipers": 50238, "\u0120reverted": 50239, "\u0120conglomerate": 50240, "Terry": 50241, "794": 50242, "\u0120harsher": 50243, "\u0120desolate": 50244, "\u0120Hitman": 50245, "Commission": 50246, "\u0120(/": 50247, "\u00e2\u0122\u00a6.\"": 50248, "Compar": 50249, "\u0120amplification": 50250, "ominated": 50251, "\u0120regress": 50252, "\u0120Collider": 50253, "\u0120informants": 50254, "\u0120gazed": 50255, "<|endoftext|>": 50256} \ No newline at end of file diff --git a/utils/BPE/vocab.bpe b/utils/BPE/vocab.bpe new file mode 100644 index 0000000000000000000000000000000000000000..226b0752cac7789c48f0cb3ec53eda48b7be36cc --- /dev/null +++ b/utils/BPE/vocab.bpe @@ -0,0 +1,50001 @@ +#version: 0.2 +Ġ t +Ġ a +h e +i n +r e +o n +Ġt he +e r +Ġ s +a t +Ġ w +Ġ o +e n +Ġ c +i t +i s +a n +o r +e s +Ġ b +e d +Ġ f +in g +Ġ p +o u +Ġa n +a l +a r +Ġt o +Ġ m +Ġo f +Ġ in +Ġ d +Ġ h +Ġan d +i c +a s +l e +Ġt h +i on +o m +l l +en t +Ġ n +Ġ l +s t +Ġ re +v e +Ġ e +r o +l y +Ġb e +Ġ g +Ġ T +c t +Ġ S +i d +o t +Ġ I +u t +e t +Ġ A +Ġ is +Ġ on +i m +a m +o w +a y +a d +s e +Ġth at +Ġ C +i g +Ġf or +a c +Ġ y +v er +u r +Ġ u +l d +Ġs t +Ġ M +' s +Ġ he +Ġ it +at ion +it h +i r +c e +Ġy ou +i l +Ġ B +Ġw h +o l +Ġ P +Ġw ith +Ġ 1 +t er +c h +Ġa s +Ġw e +Ġ ( +n d +i ll +Ġ D +i f +Ġ 2 +a g +er s +k e +Ġ " +Ġ H +e m +Ġc on +Ġ W +Ġ R +he r +Ġw as +Ġ r +o d +Ġ F +u l +at e +Ġa t +r i +p p +o re +ĠT he +Ġs e +u s +Ġp ro +Ġh a +u m +Ġa re +Ġd e +a in +an d +Ġo r +ig h +es t +is t +a b +r om +Ġ N +t h +Ġc om +Ġ G +u n +o p +0 0 +Ġ L +Ġn ot +es s +Ġe x +Ġ v +re s +Ġ E +e w +it y +an t +Ġb y +e l +o s +or t +o c +q u +Ġf rom +Ġha ve +Ġs u +i ve +ou ld +Ġs h +Ġth is +n t +r a +p e +igh t +ar t +m ent +Ġa l +u st +en d +- - +al l +Ġ O +ac k +Ġc h +Ġ le +i es +re d +ar d +â Ģ +ou t +Ġ J +Ġa b +e ar +i v +al ly +ou r +o st +g h +p t +Ġp l +as t +Ġc an +a k +om e +u d +T he +Ġh is +Ġd o +Ġg o +Ġh as +g e +' t +Ġ U +r ou +Ġs a +Ġ j +Ġb ut +Ġw or +Ġa ll +e ct +Ġ k +am e +Ġw ill +o k +Ġw he +Ġthe y +id e +0 1 +f f +ic h +p l +t her +Ġt r +. . +Ġin t +i e +u re +ag e +Ġn e +i al +a p +in e +ic e +Ġm e +Ġo ut +an s +on e +on g +ion s +Ġwh o +Ġ K +Ġu p +Ġthe ir +Ġa d +Ġ 3 +Ġu s +at ed +ou s +Ġm ore +u e +o g +ĠS t +in d +i ke +Ġs o +im e +p er +. " +b er +i z +a ct +Ġon e +Ġsa id +Ġ - +a re +Ġyou r +c c +ĠT h +Ġc l +e p +a ke +ab le +i p +Ġcon t +Ġwh ich +i a +Ġ im +Ġab out +Ġwe re +ver y +u b +Ġh ad +Ġ en +Ġcom p +, " +ĠI n +Ġu n +Ġa g +i re +ac e +a u +ar y +Ġw ould +as s +r y +Ġ âĢ +c l +o ok +e re +s o +Ġ V +ig n +i b +Ġof f +Ġt e +v en +Ġ Y +i le +o se +it e +or m +Ġ2 01 +Ġre s +Ġm an +Ġp er +Ġo ther +or d +ul t +Ġbe en +Ġl ike +as e +an ce +k s +ay s +ow n +en ce +Ġd is +ct ion +Ġan y +Ġa pp +Ġs p +in t +res s +ation s +a il +Ġ 4 +ic al +Ġthe m +Ġhe r +ou nt +ĠC h +Ġa r +Ġ if +Ġthe re +Ġp e +Ġy ear +a v +Ġm y +Ġs ome +Ġwhe n +ou gh +ac h +Ġth an +r u +on d +ic k +Ġo ver +ve l +Ġ qu +Ċ Ċ +Ġs c +re at +re e +ĠI t +ou nd +p ort +Ġal so +Ġp art +f ter +Ġk n +Ġbe c +Ġt ime +en s +Ġ 5 +op le +Ġwh at +Ġn o +d u +m er +an g +Ġn ew +-- -- +Ġg et +or y +it ion +ing s +Ġj ust +Ġint o +Ġ 0 +ent s +o ve +t e +Ġpe ople +Ġp re +Ġit s +Ġre c +Ġt w +i an +ir st +ar k +or s +Ġwor k +ad e +o b +Ġs he +Ġo ur +w n +in k +l ic +Ġ1 9 +ĠH e +is h +nd er +au se +Ġh im +on s +Ġ [ +Ġ ro +f orm +i ld +at es +ver s +Ġon ly +o ll +Ġs pe +c k +e ll +am p +Ġa cc +Ġb l +i ous +ur n +f t +o od +Ġh ow +he d +Ġ ' +Ġa fter +a w +Ġat t +o v +n e +Ġpl ay +er v +ic t +Ġc ould +it t +Ġa m +Ġf irst +Ġ 6 +Ġa ct +Ġ $ +e c +h ing +u al +u ll +Ġcom m +o y +o ld +c es +at er +Ġf e +Ġbe t +w e +if f +Ġtw o +oc k +Ġb ack +) . +id ent +Ġu nder +rou gh +se l +x t +Ġm ay +rou nd +Ġp o +p h +is s +Ġd es +Ġm ost +Ġd id +Ġad d +j ect +Ġin c +f ore +Ġp ol +on t +Ġag ain +cl ud +ter n +Ġkn ow +Ġne ed +Ġcon s +Ġc o +Ġ . +Ġw ant +Ġse e +Ġ 7 +n ing +i ew +ĠTh is +c ed +Ġe ven +Ġin d +t y +ĠW e +at h +Ġthe se +Ġp r +Ġu se +Ġbec ause +Ġf l +n g +Ġn ow +ĠâĢ ĵ +c om +is e +Ġm ake +Ġthe n +ow er +Ġe very +ĠU n +Ġse c +os s +u ch +Ġe m +Ġ = +ĠR e +i ed +r it +Ġin v +le ct +Ġsu pp +at ing +Ġl ook +m an +pe ct +Ġ 8 +ro w +Ġb u +Ġwhe re +if ic +Ġyear s +i ly +Ġd iff +Ġsh ould +Ġre m +T h +I n +Ġe v +d ay +' re +ri b +Ġre l +s s +Ġde f +Ġr ight +Ġs y +) , +l es +00 0 +he n +Ġth rough +ĠT r +_ _ +Ġw ay +Ġd on +Ġ , +Ġ1 0 +as ed +Ġas s +ub lic +Ġre g +ĠA nd +i x +Ġ very +Ġin clud +ot her +Ġim p +ot h +Ġsu b +ĠâĢ Ķ +Ġbe ing +ar g +ĠW h += = +ib le +Ġdo es +an ge +r am +Ġ 9 +er t +p s +it ed +ation al +Ġb r +Ġd own +Ġman y +ak ing +Ġc all +ur ing +it ies +Ġp h +ic s +al s +Ġde c +at ive +en er +Ġbe fore +il ity +Ġwe ll +Ġm uch +ers on +Ġth ose +Ġsu ch +Ġ ke +Ġ end +ĠB ut +as on +t ing +Ġl ong +e f +Ġth ink +y s +Ġbe l +Ġs m +it s +a x +Ġo wn +Ġpro v +Ġs et +if e +ment s +b le +w ard +Ġsh ow +Ġp res +m s +om et +Ġo b +Ġs ay +ĠS h +t s +f ul +Ġe ff +Ġg u +Ġin st +u nd +re n +c ess +Ġ ent +ĠY ou +Ġgo od +Ġst art +in ce +Ġm ade +t t +st em +ol og +u p +Ġ | +um p +Ġhe l +ver n +ul ar +u ally +Ġa c +Ġm on +Ġl ast +Ġ2 00 +1 0 +Ġst ud +u res +ĠA r +sel f +ar s +mer ic +u es +c y +Ġm in +oll ow +Ġc ol +i o +Ġm od +Ġc ount +ĠC om +he s +Ġf in +a ir +i er +âĢ Ķ +re ad +an k +at ch +e ver +Ġst r +Ġpo int +or k +ĠN ew +Ġs ur +o ol +al k +em ent +Ġus ed +ra ct +we en +Ġs ame +ou n +ĠA l +c i +Ġdiff ere +Ġwh ile +---- ---- +Ġg ame +ce pt +Ġs im +.. . +Ġin ter +e k +Ġre port +Ġpro du +Ġst ill +l ed +a h +Ġhe re +Ġwor ld +Ġth ough +Ġn um +ar ch +im es +al e +ĠS e +ĠI f +/ / +ĠL e +Ġre t +Ġre f +Ġtr ans +n er +ut ion +ter s +Ġt ake +ĠC l +Ġcon f +w ay +a ve +Ġgo ing +Ġs l +u g +ĠA meric +Ġspe c +Ġh and +Ġbet ween +ist s +ĠD e +o ot +I t +Ġe ar +Ġagain st +Ġh igh +g an +a z +at her +Ġex p +Ġo p +Ġin s +Ġg r +Ġhel p +Ġre qu +et s +in s +ĠP ro +is m +Ġf ound +l and +at a +us s +am es +Ġp erson +Ġg reat +p r +Ġs ign +ĠA n +' ve +Ġs omet +Ġs er +h ip +Ġr un +Ġ : +Ġt er +ire ct +Ġf ollow +Ġd et +ic es +Ġf ind +1 2 +Ġm em +Ġc r +e red +e x +Ġex t +ut h +en se +c o +Ġte am +v ing +ou se +as h +at t +v ed +Ġsy stem +ĠA s +d er +iv es +m in +Ġle ad +ĠB l +c ent +Ġa round +Ġgo vern +Ġc ur +vel op +an y +Ġc our +al th +ag es +iz e +Ġc ar +od e +Ġl aw +Ġre ad +' m +c on +Ġre al +Ġsupp ort +Ġ1 2 +.. .. +Ġre ally +n ess +Ġf act +Ġd ay +Ġb oth +y ing +Ġs erv +ĠF or +Ġth ree +Ġw om +Ġm ed +od y +ĠThe y +5 0 +Ġex per +t on +Ġe ach +ak es +Ġc he +Ġc re +in es +Ġre p +1 9 +g g +ill ion +Ġg rou +ut e +i k +W e +g et +E R +Ġm et +Ġs ays +o x +Ġd uring +er n +iz ed +a red +Ġf am +ic ally +Ġha pp +ĠI s +Ġch ar +m ed +v ent +Ġg ener +i ent +p le +i et +re nt +1 1 +v es +pt ion +Ġ2 0 +form ation +Ġc or +Ġoff ic +ie ld +Ġto o +is ion +Ġin f +Ġ Z +t he +o ad +Ġp ublic +Ġpro g +r ic +* * +Ġw ar +Ġp ower +v iew +Ġf ew +Ġl oc +Ġdiffere nt +Ġst ate +Ġhe ad +' ll +Ġp oss +Ġst at +re t +ant s +Ġv al +Ġis s +Ġc le +i vers +an c +Ġex pl +Ġan other +Ġ Q +Ġa v +th ing +n ce +W h +Ġch ild +Ġs ince +i red +l ess +Ġl ife +Ġde velop +itt le +Ġde p +Ġp ass +ã ĥ +Ġt urn +or n +Th is +b ers +ro ss +ĠA d +Ġf r +Ġres p +Ġsec ond +o h +Ġ / +Ġdis c +Ġ & +Ġsomet hing +Ġcomp le +Ġ ed +Ġf il +Ġmon th +a j +u c +Ġgovern ment +Ġwith out +Ġle g +Ġd ist +Ġp ut +Ġqu est +an n +Ġpro t +2 0 +Ġne ver +i ence +Ġle vel +Ġar t +Ġth ings +Ġm ight +Ġeff ect +Ġcont ro +Ġc ent +Ġ1 8 +Ġall ow +Ġbel ie +ch ool +ot t +Ġinc re +Ġfe el +Ġres ult +Ġl ot +Ġf un +ot e +Ġt y +ere st +Ġcont in +Ġus ing +Ġb ig +2 01 +Ġas k +Ġb est +Ġ ) +I N +Ġo pp +3 0 +Ġnum ber +in ess +S t +le ase +Ġc a +Ġm ust +Ġd irect +Ġg l +Ġ < +Ġop en +Ġp ost +Ġcom e +Ġse em +ord ing +Ġwe ek +ate ly +it al +Ġe l +ri end +Ġf ar +Ġt ra +in al +Ġp ri +ĠU S +Ġpl ace +Ġfor m +Ġto ld +" : +ain s +at ure +ĠTr ump +Ġst and +Ġ # +id er +ĠF r +Ġne xt +Ġs oc +Ġp ur +Ġle t +Ġl ittle +Ġh um +Ġ i +r on +1 5 +Ġ1 5 +Ġcomm un +Ġm ark +ĠThe re +Ġw r +ĠTh at +Ġin formation +w ays +Ġb us +a pp +Ġinv est +m e +Ġh ard +ain ed +e ad +Ġim port +Ġapp ro +Ġt est +Ġt ri +Ġre st +os ed +Ġf ull +Ġc are +ĠS p +Ġc ase +O N +Ġs k +Ġl ess +Ġ + +Ġpart ic +ĠP l +ab ly +u ck +is hed +ch n +b e +Ġl ist +at or +Ġto p +Ġad v +ĠB e +ru ct +Ġd em +r ation +l ing +g y +re en +g er +Ġh ome +Ġle ft +Ġbet ter +Ġd ata +Ġ1 1 +Ġatt ack +Ġpro ble +l ine +ard s +Ġbe h +r al +ĠH ow +ĠS he +ar ge +Ġ -- +: // +Ġb ro +ĠP h +at s +Ġbu ild +w w +id ed +a im +as es +en cy +Ġm ain +in ed +Ġinclud ing +Ġ { +Ġg ot +Ġint erest +Ġke ep +Ġ X +Ġe as +ain ing +Ġcl ass +âĢ ¦ +ĠN o +Ġv ar +Ġsm all +amp le +A T +Ġ ide +ĠS o +Ġre ce +Ġpol it +Ġm ov +Ġpl an +Ġper cent +iv ing +Ġc amp +Ġp ay +1 4 +s c +is ed +Ġu nt +one y +pl oy +== == +Ġdid n +ĠI nd +el s +ert ain +Ġp os +__ __ +i ver +Ġpro cess +Ġprog ram +if ied +ĠR ep +1 6 +u ro +olog y +at ter +in a +Ġn ame +ĠA ll +Ġf our +Ġret urn +v ious +b s +Ġcall ed +Ġm ove +ĠS c +ir d +Ġgrou p +Ġb re +Ġm en +Ġc ap +t en +e e +Ġd ri +le g +he re +uth or +Ġp at +Ġcur rent +id es +Ġp op +t o +ent ion +Ġal ways +Ġm il +Ġwom en +Ġ1 6 +Ġo ld +iv en +ra ph +ĠO r +r or +ent ly +Ġn ear +ĠE x +re am +s h +Ġ1 4 +Ġf ree +iss ion +st and +ĠC on +al ity +us ed +1 3 +Ġdes ign +Ġch ange +Ġch ang +Ġb o +Ġv is +em ber +Ġb ook +read y +Ġk ill +2 5 +pp ed +Ġa way +Ġab le +Ġcount ry +Ġcon st +ar n +Ġor der +A R +i or +i um +or th +1 8 +ail able +Ġs w +Ġm illion +Ġ1 3 +at ic +t ed +ĠG o +Ġo per +en g +Ġth ing +aj or +con om +ĠCom m +Ġwh y +u red +ur al +Ġs chool +b y +ĠM ar +Ġa ff +Ġd ays +Ġan n +us h +an e +I f +e g +Ġpro f +Ġhe alth +ou th +B ut +ion al +. , +Ġs ol +Ġal ready +Ġ3 0 +Ġchar act +H e +Ġf riend +E S +i ans +ic le +' d +ĠO n +Ġle ast +Ġp rom +Ġd r +Ġh ist +it her +Ġ est +i qu +1 7 +s on +Ġte ll +Ġt alk +oh n +o int +le ction +A N +Ġunt il +au gh +Ġl ater +Ġ ve +Ġv iew +end ing +iv ed +Ġwor d +w are +Ġc ost +Ġen ough +Ġg ive +ĠUn ited +Ġte chn +are nt +O R +Ġp ar +ĠD r +Ġ201 6 +r ist +er ing +Ġ  +Ġl arge +s ide +ac y +cc ess +Ġw in +Ġimport ant +Ġ19 9 +Ġdoes n +Ġ1 7 +Ġbus iness +Ġcle ar +Ġre se +" , +ur y +Ġe qu +as ter +al f +ĠAmeric an +n ect +Ġex pect +ivers ity +Ġo cc +ĠF l +Ġk ind +Ġme an +Ġp ast +Ġde v +Ġb as +le t +ra ft +Ġor gan +Ġde l +Ġper form +Ġst ory +Ġse ason +ĠC ol +Ġcl aim +Ġc ame +Ġwith in +Ġl ine +Ġpro ject +ĠA t +Ġcontro l +end ed +ĠS y +Ġa ir +iz ation +Ġ * +le y +Ġm oney +id d +Y ou +f or +Ġfam ily +Ġm aking +Ġb it +Ġpol ice +Ġhapp en +Ġ vers +on y +u ff +ĠW hen +Ġs it +ide o +l f +is on +Ġsu re +g in +Ġapp ear +Ġl ight +Ġ es +o f +Ġw ater +Ġt imes +n ot +Ġg row +Ġcomp any +ĠT e +ow s +Ġm ar +our ce +i ol +ar m +b r +Ġex ample +Ġcon c +Ġf ore +ĠT o +p ro +E N +ri es +Ġ2 5 +ĠC an +ne y +Ġact ually +Ġe ver +ur ity +ak en +ap s +Ġt ax +Ġm ajor +am a +Ġof ten +er al +Ġhum an +Ġj ob +is ter +Ġav ailable +oc r +en n +a id +iv id +Ġrec ord +? " +Ġs ing +ĠA m +id ence +Ġnew s +st er +Ġe conom +Ġfollow ing +ĠB r +is ing +Ġh our +m ost +um ent +Ġse x +Ġdes c +Ġbec ome +ĠE d +Ġto ok +Ġha ving +Ġprodu ct +a ult +A s +ar ing +Ġme ans +Ġh op +un e +Ġch o +Ġc ertain +Ġn on +Ġde al +2 4 +le ment +oc i +en e +Ġs ide +ĠP r +ĠM ay +Ġre ason +u ed +c hed +ul ation +Ġe lect +Ġoffic ial +Ġposs ible +Ġh old +and s +ot s +Ġc ity +or ies +Ġse ver +Ġchild ren +Ġon ce +Ġact iv +l er +Ġn ight +it ions +ĠJ ohn +a pe +pl ay +Ġd one +Ġl im +Ġwork ing +ĠP res +or ld +e b +ĠC o +Ġb ody +ail s +ut es +ĠM r +Ġwhe ther +Ġa uthor +ro p +Ġpro per +Ġse en +) ; +Ġf ac +ĠS u +Ġcon d +it ing +Ġcour se +Ġ } +-------- -------- +a ign +Ġev ent +Ġen g +Ġp ot +Ġin tern +i am +Ġsh ort +em pt +ã Ĥ +ĠG od +il ar +8 0 +Ġor ig +I S +our n +ab ility +it ive +Ġd am +Ġ1 00 +Ġp ress +Ġdo ing +Ġprot ect +r ing +Ġthough t +Ġquest ion +re w +ĠW ar +Ġsever al +ĠSt ate +Ġg iven +Ġf und +ĠT w +Ġw ent +an ces +w ork +p or +m y +4 0 +Ġar g +art ment +ust om +Ġpol ic +Ġme et +Ġc reat +2 2 +ĠSt ates +Ġg ames +ra w +ut ure +Ġunder stand +ur s +ĠO b +l ish +s y +Ġm akes +Ġw on +ag on +Ġh tt +Ġl ove +ent ial +Ġcomple te +p ar +ĠI m +A L +Ġacc ount + ł +ore d +ver t +Ġ ident +Ġ201 5 +Ġother s +ĠM in +i ber +ver age +The re +ition al +d d +Ġpro b +Ġyou ng +Ġal ong +Ġacc ording +Ġy et +Ġmem bers +ĠWh at +o id +ĠM an +A nd +Ġam ong +a i +Ġem ploy +ĠR es +Ġ > +Ġinv ol +Ġl ow +a f +ĠC ar +Ġh ig +ĠO ne +ĠS ec +in ation +Ġlike ly +Ġan t +ag ed +ĠR uss +Ġb en +Ġre le +F or +b ack +ĠN ot +Ġpres ident +b all +Ġacc ess +ivid ual +ĠD em +ĠE uro +6 0 +Ġkn own +ir l +ĠG r +Ġear ly +u se +iet y +âĢ ĵ +Ġf ight +Ġs ent +Ġto day +Ġmark et +" . +Ġb ased +Ġstr ong +ur ther +Ġde b +m ber +Ġproble m +Ġde ath +Ġsoc ial +im ate +A S +ort un +Ġcamp aign +er y +C h +Ġe y +i ally +Ġm us +w h +p os +Ġ er +Ġsa f +Ġmonth s +ir on +Ġv iol +Ġf ive +Ġst re +Ġplay ers +in c +al d +y ear +a un +Ġsu ccess +Ġpres ent +ere nce +Ġ201 4 +Ġsu gg +Ġpartic ular +Ġtr y +Ġsugg est +ĠCh rist +on es +Ġpri v +2 3 +Ġc rit +Ġl and +Ġloc al +if y +2 9 +Ġa ut +E D +ĠG u +Ġm ult +Ġpolit ical +Ġask ed +Ġfor mer +it ter +ri pt +Ġcl ose +Ġp ract +ĠY ork +Ġget ting +Ġac ross +Ġcom b +Ġbelie ve +Ġ z +Ġto get +Ġtoget her +ĠC ent +ir c +Ġind ividual +ĠM c +2 7 +is k +ĠE ng +Ġf ace +Ġ2 4 +Ġval ue +Ġare a +e v +Ġw rit +ĠPres ident +Ġv ot +Ġke y +Ġm om +p ut +Ġany thing +Ġexper ience +att le +Ġm ind +a ff +om m +Ġf uture +g ed +Ġc ut +Ġto t +it ch +Ġv ideo +Ġinvest ig +Ġn et +ĠM y +r ict +i en +. ) +Ġimp ro +th ough +ward s +Ġcon nect +ĠM ed +sel ves +ens ive +m b +o ber +at ors +A n +Ġ5 0 +Ġre du +res ent +Ġab ove +Ġf re +ĠEuro pe +s w +Ġam ount +ĠA pp +Ġe ither +Ġmil it +Ġan al +Ġf ail +ĠE n +al es +Ġspec ial +Ġbl ack +I T +c her +Ġlook ing +Ġf ire +y n +Ġal most +o on +Ġstud y +Ġm iss +c hes +ro wn +Ġt re +Ġcommun ity +Ġmed ia +Ġf ood +Ġcom es +ĠUn iversity +Ġsing le +Wh at +u ly +Ġh alf +ag ue +h od +ĠRep ublic +Ġstart ed +Ġqu ick +ot o +b ook +Ġiss ue +it or +Ġel se +Ġcons ider +2 6 +ro du +Ġt aken +2 8 +9 9 +ĠW ith +Ġtr ue +Ġw a +Ġtr ad +Ġag o +Ġm ess +ie f +Ġadd ed +o ke +Ġb ad +Ġf av +3 3 +Ġsim ilar +as k +ĠD on +Ġcharact er +ort s +ĠH ouse +Ġreport ed +Ġty pe +v al +i od +ĠHow ever +Ġt arg +Ġent ire +pp ing +Ġhist ory +Ġl ive +ff ic +.... .... +ed eral +Ġtr ying +Ġdisc uss +ĠH ar +ac es +l ished +Ġse lf +os p +re st +Ġro om +el t +Ġf all +ol ution +Ġe t +Ġ x +Ġis n +Ġide a +b o +Ġs ound +ĠD ep +Ġsome one +ci ally +ull y +Ġf oc +Ġob ject +if t +ap er +Ġplay er +Ġr ather +Ġserv ice +as hing +ĠD o +ĠP art +ru g +m on +p ly +Ġm or +Ġnot hing +Ġprov ide +I C +un g +Ġpart y +Ġex ist +Ġm ag +7 0 +Ġr ul +Ġh ouse +Ġbeh ind +Ġhow ever +ĠW orld +Ġs um +Ġapp lic +Ġ ; +Ġfun ction +g r +ĠP ol +Ġfr ont +2 00 +Ġser ies +Ġt em +Ġty p +ill s +Ġo pt +Ġpoint s +Ġbel ow +itt ed +Ġspec ific +Ġ201 7 +um b +Ġr a +Ġpre vious +Ġpre t +re me +Ġc ustom +Ġcour t +ĠM e +Ġre pl +Ġwho le +g o +c er +Ġt reat +ĠA ct +Ġprob ably +Ġle arn +end er +ĠA ss +Ġvers ion +n ow +Ġche ck +ĠC al +R E +min ist +O n +our ces +Ġben ef +Ġd oc +Ġdet er +Ġen c +Ġsu per +Ġadd ress +Ġv ict +Ġ201 3 +Ġme as +t r +Ġf ield +W hen +Ġsign ific +u ge +Ġfe at +Ġcomm on +l oad +Ġbe gin +Ġbr ing +Ġa ction +er man +Ġdesc rib +Ġind ust +Ġwant ed +ri ed +m ing +Ġatt empt +4 5 +f er +Ġd ue +ress ion +# # +Ġsh all +Ġs ix +o o +Ġst ep +Ġp ub +Ġhim self +Ġ2 3 +Ġc op +Ġd est +Ġst op +A C +ib ility +Ġl ab +ic ult +Ġhour s +Ġcre ate +Ġf urther +ĠAmeric a +ĠC ity +Ġd ou +he ad +S T +ĠN orth +c ing +Ġn ational +u le +ĠIn st +Ġt aking +ĠQ u +ir t +Ġre d +Ġrese arch +v iron +ĠG e +Ġbre ak +an a +Ġsp ace +ater ial +Ġrec ent +ĠA b +Ġgener al +Ġh it +Ġper iod +Ġevery thing +ive ly +Ġph ys +Ġsay ing +an ks +Ġc ou +Ġc ult +ac ed +e al +u ation +Ġc oun +l u +Ġinclud e +Ġpos ition +ĠA fter +ĠCan ad +ĠE m +Ġim m +ĠR ed +Ġp ick +Ġcom pl +Ġm atter +re g +e xt +ang u +is c +o le +a ut +Ġcomp et +e ed +f ect +Ġ2 1 +ĠS en +ĠThe se +as ing +Ġcan not +Ġin it +Ġrel ations +ac hed +Ġb ar +Ġ4 0 +ĠT H +Ġ201 2 +Ġv ol +Ġg round +Ġsec urity +Ġup d +il t +3 5 +Ġconc ern +ĠJ ust +Ġwh ite +Ġseem s +ĠH er +pe cially +i ents +Ġann oun +Ġf ig +ight s +Ġst ri +l ike +id s +Ġs us +Ġw atch +Ġ â +Ġw ind +ĠC ont +Ġit self +Ġm ass +A l +y le +iqu e +ĠN ational +Ġab s +Ġp ack +Ġout side +Ġan im +Ġp ain +et er +Ġman ag +du ct +og n +Ġ ] +ĠSe pt +se c +o ff +ĠJ an +Ġf oot +ad es +Ġth ird +Ġm ot +Ġev idence +int on +Ġth reat +a pt +pl es +c le +Ġl o +Ġde cl +Ġit em +med i +Ġrep resent +om b +am er +Ġsignific ant +og raph +s u +Ġc al +i res +00 00 +I D +A M +Ġsim ply +Ġlong er +Ġf ile +O T +c he +S o +ate g +or g +ĠH is +Ġen er +Ġd om +Ġup on +il i +": " +Ġthem selves +Ġcom ing +Ġqu ite +Ġdiff icult +ĠB ar +il ities +re l +end s +c ial +6 4 +Ġwom an +ra p +y r +Ġne cess +ip s +Ġte xt +Ġrequ ire +Ġmilit ary +Ġre view +Ġresp ons +7 5 +Ġsub ject +Ġinst ead +Ġiss ues +Ġg en +" ," +Ġmin utes +Ġwe ap +r ay +am ed +t ime +b l +H ow +Ġc ode +ĠS m +Ġhig her +ĠSt e +r is +Ġp age +Ġstud ents +ĠIn tern +Ġmet hod +ĠA ug +ĠP er +ĠA g +Ġpolic y +ĠS w +Ġex ec +Ġac cept +um e +rib ut +Ġword s +Ġfin al +Ġchang es +ĠDem ocr +Ġfriend s +Ġres pect +Ġe p +Ġcomp an +iv il +Ġdam age +** ** +og le +viron ment +Ġne g +ent al +Ġa p +Ġtot al +iv al +! " +l im +Ġneed s +Ġag re +Ġdevelop ment +Ġa ge +ip le +2 1 +Ġresult s +ĠA f +S h +Ġg un +ĠOb ama +ro ll +Ġ @ +Ġright s +ĠB rit +Ġrun ning +Ġwas n +Ġp ort +Ġr ate +Ġpret ty +Ġtarg et +Ġsa w +Ġc irc +Ġwor ks +ic ro +al t +o ver +ww w +Th at +l ier +Ġevery one +ud e +Ġp ie +idd le +ra el +Ġr ad +Ġbl ock +Ġw alk +T o +ã ģ +n es +ĠA ust +a ul +ro te +ĠS outh +ess ion +op h +Ġshow s +Ġs ite +Ġj o +Ġr isk +cl us +l t +Ġin j +id ing +ĠS pe +Ġch all +ir m +Ġ2 2 +itt ing +st r +Ġh y +L E +ke y +Ġbe gan +at ur +ashing ton +l am +ĠD av +b it +Ġs ize +ĠP ar +3 8 +ourn al +f ace +Ġdec ision +Ġl arg +Ġj ud +re ct +Ġcontin ue +ĠO ct +ove red +ĠI nt +==== ==== +Ġp arent +ĠW ill +Ġeas y +Ġd rug +ang er +Ġs ense +Ġd i +id ay +Ġener gy +ist ic +Ġass oci +ar ter +ob al +e ks +ĠE l +ur ch +Ġg irl +o e +it le +Ġ2 8 +ĠC he +Ġrequ est +Ġso on +Ġh ost +k y +Ġst ates +om es +Ġm aterial +le x +Ġmom ent +Ġan sw +on se +Ġes pecially +Ġn orm +Ġserv ices +p ite +r an +Ġro le +4 4 +) : +Ġc red +C l +____ ____ +Ġm at +Ġl og +ĠCl inton +O U +Ġoff ice +Ġ2 6 +Ġch arg +Ġtr ack +m a +Ġhe art +Ġb all +Ġperson al +Ġbuild ing +n a +s et +b ody +ĠBl ack +Ġincre ase +itt en +Ġneed ed +3 6 +3 2 += " +Ġl ost +Ġbec ame +Ġgrou ps +ĠM us +Ġw rote +ĠP e +Ġpro p +j oy +à © +ĠWh ite +Ġde ad +. ' +Ġhtt p +Ġwe bs +O S +Ġins ide +Ġwr ong +Ġstat ement +Ġ ... +y l +Ġfil m +Ġmus ic +Ġsh are +ific ation +Ġre lease +Ġfor ward +Ġst ay +Ġcomp ut +it te +s er +Ġorig inal +Ġc ard +Ġc and +Ġd iv +at ural +Ġfav or +O M +Ġc ases +us es +Ġse ction +Ġle ave +g ing +ov ed +ĠW ashington +3 9 +ĠG l +Ġrequ ired +act ion +ap an +o or +it er +ĠK ing +Ġcount ries +ĠG erman +ll ing +Ġ2 7 +3 4 +Ġquest ions +Ġpr im +Ġc ell +Ġsh oot +Ġany one +ĠW est +Ġaff ect +ep end +Ġon line +ĠIs rael +ĠSept ember +Ġab ility +Ġcont ent +is es +Ġre ve +Ġl aun +Ġind ic +Ġfor ce +c ast +Ġso ld +av ing +f l +Ġso ft +Ġcompan ies +ce ed +Ġart icle +Ġa ud +Ġre v +Ġed uc +Ġplay ing +0 5 +Ġhe ld +ct or +Ġrele ased +Ġf ederal +3 7 +Ġad minist +Ġinter view +Ġinst all +Ġrece ived +Ġs ource +u k +P h +Ġser ious +Ġcre ated +Ġc ause +Ġim medi +Ġdef in +u el +ĠDep artment +ct ions +ĠC our +ĠN ow +z e +it es +it ution +Ġl ate +Ġspe ak +n ers +Ġleg al +ar i +ĠC or +Ġwe eks +Ġmod el +Ġp red +Ġex act +B C +ĠB y +IN G +os ing +Ġt akes +Ġreg ard +Ġopp ortun +Ġpr ice +Ġ19 8 +ĠA pr +f ully +Ġor d +Ġproble ms +ru ction +h am +ĠC ount +le ge +Ġlead ers +E T +le v +Ġde ep +olog ical +es e +h aps +ĠS ome +Ġp ers +Ġcont ract +Ġrelations hip +s p +ou d +Ġb ase +4 8 +m it +A d +anc ial +Ġcons um +Ġpot ential +Ġl angu +re m +et h +Ġrel ig +ress ed +6 6 +Ġl ink +Ġl ower +ay er +ĠJ une +Ġf em +un t +er c +ur d +Ġcont act +Ġ ill +Ġm other +Ġest ab +h tt +ĠM arch +ĠB ro +ĠCh ina +Ġ2 9 +Ġs qu +Ġprov ided +Ġa verage +as ons +Ġ201 1 +Ġex am +l in +5 5 +n ed +Ġper fect +Ġt ou +al se +u x +Ġbu y +Ġsh ot +Ġcol lect +Ġph ot +Ġplay ed +Ġsur pr +Ġofficial s +Ġsim ple +av y +Ġindust ry +Ġhand s +g round +Ġp ull +Ġr ound +Ġus er +Ġr ange +u ary +Ġpriv ate +op s +e es +Ġw ays +ĠM ich +Ġve h +Ġex cept +Ġter ms +im um +pp er +I ON +ore s +ĠDr agon +ou l +Ġd en +Ġperform ance +Ġb ill +c il +4 7 +Ġen vironment +Ġex c +ad d +Ġwor th +Ġp ict +Ġch ance +Ġ201 8 +b or +Ġspe ed +ict ion +Ġal leg +ĠJ apan +at ory +re et +Ġm atch +ĠI I +Ġst ru +ord er +Ġst e +Ġl iving +Ġst ruct +in o +Ġse par +her n +Ġresp onse +Ġen joy +Ġv ia +A D +um ents +ace book +Ġmem ber +ib r +iz ing +Ġto ol +ĠM on +ĠWh ile +h ood +ĠA ng +ĠD ef +Ġoff er +T r +a ur +Ġturn ed +ĠJ uly +d own +an ced +Ġrec ently +ĠE ar +Ġc e +ĠSt ar +ĠC ong +rough t +Ġbl ood +Ġhop e +Ġcom ment +ain t +Ġar ri +il es +Ġpartic ip +ough t +ri ption +0 8 +4 9 +Ġg ave +Ġse lect +Ġkill ed +sy ch +Ġgo es +i j +Ġc oll +Ġimp act +at ives +ĠS er +0 9 +ĠAug ust +Ġb oy +d e +ĠD es +Ġf elt +U S +Ġexpect ed +Ġim age +ĠM ark +cc ording +o ice +E C +ĠM ag +en ed +h old +ĠP ost +Ġpre vent +N o +Ġinvol ved +Ġey es +Ġquick ly +A t +un k +Ġbeh av +Ġ ur +Ġl ed +c ome +e y +Ġcand id +Ġear lier +Ġfoc us +et y +P ro +led ge +ix ed +ill ed +Ġpop ular +A P +Ġset t +l ight +Ġvar ious +in ks +Ġlevel s +Ġro ad +ell ig +ab les +he l +itte e +ĠG ener +y pe +Ġhe ard +ic les +Ġm is +Ġus ers +ĠS an +Ġimpro ve +Ġf ather +Ġse arch +The y +v il +Ġprof ess +Ġkn ew +Ġl oss +Ġev ents +6 5 +Ġb illion +0 7 +0 2 +ĠNew s +ĠA M +Ġco ver +w here +ens ion +Ġb ott +Ġare as +en ces +op e +ĠTw itter +a el +Ġget s +ĠGo ogle +Ġs n +i ant +Ġv ote +Ġnear ly +Ġinclud ed +Ġrec ogn +z z +m m +al ed +Ġhappen ed +0 4 +Ġh ot +Ġwho se +Ġc ivil +Ġsu ff +o es +it iz +ĠSy ri +Ġresp ond +Ġh on +Ġfeat ures +Ġeconom ic +ĠApr il +r im +Ġtechn ology +Ġo ption +ag ing +Ġpur ch +R e +Ġl at +ch ie +is l +Ġrec omm +u f +Ġtr aining +Ġeffect s +Ġf ast +Ġ201 0 +Ġocc ur +Ġwebs ite +Ġem ail +Ġs ens +e ch +Ġo il +Ġinf lu +Ġcurrent ly +ĠS ch +ĠAd d +Ġgo al +Ġsc ient +Ġcon v +1 00 +em y +Ġdec ided +Ġtra vel +Ġm ention +L L +0 3 +Ġe lection +Ġph one +Ġlook s +Ġsit uation +Ġc y +Ġh or +b ed +ĠCour t +a ily +av es +Ġqu ality +ĠCom p +w ise +Ġt able +Ġst aff +ĠW ind +et t +Ġtri ed +ide red +Ġadd ition +Ġb ox +Ġl ack +ar ily +Ġw ide +Ġm id +Ġbo ard +ys is +Ġant i +h a +Ġd ig +en ing +Ġd ro +C on +6 8 +Ġsl ow +b ased +se qu +Ġp ath +E x +ak er +Ġwork ed +Ġp en +Ġeng ine +Ġlook ed +ĠSu per +ĠS erv +Ġvict im +U n +Ġproper ty +Ġint rodu +Ġexec ut +ĠP M +L e +Ġcol or +ĠM ore +Ġ6 0 +Ġnet work +Ġd ate +c ul +id ge +Ġext ra +3 1 +Ġs le +6 7 +Ġw ond +Ġreport s +j ust +ĠAust ral +Ġcap ital +Ġen s +Ġcomm and +Ġallow ed +Ġpre p +Ġca pt +h ib +Ġnum bers +ch an +Ġf air +m p +om s +Ġre ach +W ith +t ain +Ġbro ad +Ġcou ple +ec ause +ly ing +ĠF eb +Ġsc reen +Ġl ives +Ġpri or +ĠCong ress +A r +Ġappro ach +Ġe mer +ar ies +ĠD is +s erv +ĠN e +Ġbu ilt +c ies +Ġre pe +Ġrul es +for ce +ĠP al +Ġfin ancial +Ġcons idered +ĠCh ar +n ces +ĠI S +Ġb rought +Ġb i +i ers +ĠS im +O P +Ġproduct s +Ġvis it +Ġdoc ument +Ġcon duct +Ġcomplete ly +in ing +ĠCal if +ib ly +Ġwr itten +ĠT V +em ents +Ġd raw +O ne +Ġpub lished +Ġsec ret +r ain +he t +ĠF acebook +ond ay +ĠU p +Ġsex ual +Ġth ous +ĠP at +Ġ ess +Ġstand ard +Ġar m +g es +ect ion +Ġf ell +Ġfore ign +an i +ĠFr iday +Ġreg ular +in ary +Ġincre ased +Ġus ually +Ġdem on +Ġd ark +Ġadd itional +ro l +ĠO f +Ġprodu ction +! ! +und red +Ġintern ational +id ents +ĠF ree +rou p +Ġr ace +Ġm ach +Ġh uge +A ll +le ar +ove mber +Ġto wn +Ġatt ention +ĠO ff +y ond +ĠThe n +f ield +Ġter ror +ra z +ĠB o +Ġmeet ing +ĠP ark +Ġar rest +Ġf ear +Ġa w +ĠV al +or ing +' , +Ġext reme +ar r +Ġwork ers +A fter +Ġ3 1 +n et +am ent +Ġdirect ly +Ġpop ulation +ub e +ĠOct ober +ĠI N +ĠJan uary +5 9 +ĠDav id +Ġc ross +ce mber +ĠF irst +Ġmess age +ir it +Ġn ation +Ġp oll +is ions +Ġansw er +n y +is ode +Ġcar ry +ĠRuss ia +Ġhe ar +eng th +ro y +Ġn atural +in ally +Ġdo g +m itted +Ġtr ade +Ġsub st +Ġmult iple +ĠAf ric +Ġf ans +Ġs ort +Ġgl obal +ic ation +ĠW ed +ar a +Ġa chie +Ġlangu age +ve y +Ġt al +Ġnecess ary +Ġdet ails +Ġs en +ĠS und +ĠRe g +ĠR ec +0 6 +Ġs il +ress ive +Ġmed ical +un ch +orn ia +Ġu nd +f ort +oc ks +ĠM onday +ues day +c raft +7 7 +ur t +Ġ ver +ĠH ill +Ġrece ive +Ġmor ning +es tern +Ġb ank +Ġs at +ir th +ĠH igh +Ġdev ice +ĠTH E +ĠCent er +Ġsaf e +Ġp le +ĠCanad a +Ġsystem s +Ġass ist +Ġsur v +Ġb attle +ĠS oc +vert is +S he +Ġp aper +Ġgrow th +Ġc ast +S c +Ġpl ans +ll ed +Ġpart s +Ġw all +Ġmove ment +Ġpract ice +im ately +Ġdis play +Ġsomet imes +om p +ĠP aul +ĠY es +k ing +5 8 +o ly +Ġs on +Ġav oid +ok es +ĠJ ew +Ġto wards +as c +Ġ // +ĠK ore +Ġtalk ing +Ġcor rect +Ġsp ent +ic ks +i able +e ared +Ġter m +Ġwant s +om ing +Ġ ut +Ġdou b +Ġfor ces +Ġp lease +6 9 +ĠN ovember +at form +ond on +Ġon es +Ġimmedi ately +ĠRuss ian +ĠM et +Ġde g +Ġparent s +C H +ĠAmeric ans +al y +ĠM od +Ġsh own +Ġcond itions +Ġst uff +Ġre b +ĠY our +Ġinclud es +n own +ĠS am +Ġexper ien +m ission +ĠE ven +augh t +Ġannoun ced +ĠRepublic an +Ġdeter min +Ġdescrib ed +ĠCount y +( ) +Ġdo or +Ġchang ed +Ġne igh +ĠH ere +Ġcle an +Ġp an +ĠDe cember +ĠEurope an +ir ing +ap ter +Ġcl ub +ĠT uesday +Ġp aid +ĠN et +Ġattack s +Ġcharact ers +Ġal one +Ġdirect or +d om +Ġ3 5 +Ġl oad +Ġr out +ĠCalif ornia +Ġfin ally +Ġr ac +Ġcont r +Ġexact ly +res h +p ri +ĠIs lam +Ġn ature +Ġcare er +Ġlat est +Ġcon vers +ĠS l +p ose +ci ent +ĠIn c +iv ity +8 8 +ĠA tt +ĠM or +nes day +Ġwe ight +k en +Ġnot e +Ġteam s +Ġ \ +air s +ĠG reen +Ġh undred +on ent +Ġstre ng +Ġcons ist +ic ated +Ġreg ul +Ġl ic +ast ic +Ġt en +urs day +ellig ence +ous ly +ĠU K +B I +Ġcost s +Ġind epend +ĠA P +Ġnorm al +Ġh om +Ġob vious +Ġs we +Ġst ar +Ġread y +ac her +Ġimp lement +g est +Ġs ong +ĠG et +ĠL ab +Ġinterest ing +us ing +Ġg iving +ĠSund ay +Ġet c +Ġm iddle +Ġrem ember +r ight +os ition +ut ions +Ġm ax +4 6 +Ġyour self +Ġdem and +Ġtreat ment +Ġd anger +ĠC ons +Ġgu y +ĠBrit ish +Ġphys ical +Ġrel ated +Ġrem ain +Ġcould n +Ġref er +Ġc itiz +b ox +EN T +bo ard +Ġin n +I G +er o +ĠSt reet +osp ital +ren ch +cher s +Ġst ra +O L +ag er +ĠA N +Ġeas ily +I A +en ge +in y +Ġcl os +ock ed +Ġus es +ĠC oun +I m +u ild +? ? +m ore +Ġan g +Ġwr ite +ol ute +5 7 +Ġlead er +Ġread ing +< / +Ġaut om +est s +4 3 +Ġleg isl +ĠG old +Ġdesign ed +ĠS T +ĠLe g +a res +Ġbe aut +ĠT ex +Ġappear s +Ġstru gg +ĠR om +Ġ 00 +Ġcho ice +Ġparticular ly +ĠF rom +op er +ĠL ondon +ann ed +Ġallow s +ob ile +Ġdiffere nce +âĢ ¢ +ĠV iew +ĠWed nesday +Ġal though +Ġrel ative +Ġapplic ation +ate ver +Ġare n +Ġmy self +Ġim ag +Ġdis e +Ġsoc iety +Ġfre qu +ĠEng lish +Ġpo or +ĠD ay +Ġwrit ing +Ġse ven +Ġstart ing +Ġb ud +Ġpr int +ĠTr ans +uf act +ĠSt ud +n ew +Ġcr im +Ġg ives +Ġco ol +a e +i ance +ĠGener al +Ġthink ing +Ġsa ve +Ġlim ited +ĠPart y +Ġmean ing +p en +ow ers +ĠJ ack +E M +Ġn ice +ru pt +Ġg as +Ġe ight +Ġfe et +Ġeff ort +Ġ ign +ic it +B l +co in +Ġop in +Ġbr ain +Wh ile +he st +ĠTh ursday +Ġwould n +augh ter +Ġtou ch +le ments +Ġstud ies +Ġcent er +c ont +or ge +Ġcomput er +Ġinvestig ation +P l +or ks +Ġ200 8 +Ġincre asing +Ġst ore +Ġcom ments +Ġb al +m en +Ġdo ll +Ġl iber +Ġw ife +Ġlaw s +atur day +it ness +Ġmod ern +ĠS k +Ġadminist ration +Ġopportun ity +Ġs al +Ġpower ful +M y +Ġclaim s +ĠEar th +ord s +Ġt itle +Ġes c +n ame +N ot +om en +Ġbe yond +Ġc amer +Ġse ll +it ute +ear ch +Ġapp l +im ent +4 2 +ĠAr t +Ġun f +Ġviol ence +ur g +ĠE ast +Ġcomp ared +Ġopt ions +Ġthrough out +Ġv s +ig r +. [ +ac hes +7 8 +Ġfil es +F L +E L +ar ian +ĠJ ames +ĠA ir +an ch +Ġdet ail +Ġpie ce +P S +Ġn amed +Ġeduc ation +Ġdri ve +Ġitem s +Ġstud ent +ic ed +: : +ic o +Ġth row +Ġsc ene +Ġcomple x +Ġ200 9 +Ġpre c +ĠB re +7 9 +Ġcon cept +Ġstat us +am ing +Ġd ied +Ġknow ledge +Ġbegin ning +O D +ru ary +Ġcertain ly +Ġgu ys +Ġsl ight +in n +ound s +Ġf ine +Ġf at +ic ations +Ġper haps +ĠA nt +Ġinc ome +Ġhtt ps +Ġmajor ity +port s +st on +Ġgreat er +Ġfe ed +ent ially +Ġsaf ety +Ġun ique +and om +Ġg one +Ġshow ed +Ġhist or +Ġcoun ter +i us +id a +Ġlead ing +i pe +Ġs end +ĠDon ald +er ve +Ġdef ense +ines e +Ġy es +ĠF ire +ĠMus lim +ra q +Ġcontin ued +os h +Ġprov ides +Ġpr ison +ĠP re +Ġhapp y +Ġeconom y +Ġtr ust +ag s +ĠG ame +Ġweap ons +um an +ĠC le +it ation +Ġanal ysis +ĠT imes +Ġsc ience +- > +Ġfig ure +Ġdis app +ent y +Ġsoft ware +Ġu lt +Ġoffic ers +N ew +I s +Ġrem ains +ĠInd ia +Ġp sych +ri ef +Ġc at +es c +Ġob serv +Ġst age +ĠD ark +Ġent er +ch ange +Ġpass ed +Ġdes pite +ĠO ut +Ġmov ie +r s +Ġv oice +m ine +ĠPl ay +Ġto ward +ĠT er +Ġreg ion +Ġval ues +or ters +Ġm ount +Ġoffic er +ĠO ther +b an +Ġh ous +w ood +ro om +I V +ĠS un +se e +ĠO ver +ro g +9 0 +Ġl ay +ĠT ur +a wn +Ġpress ure +ĠS ub +Ġbook s +ed om +ĠS and +A A +ag o +Ġre asons +f ord +Ġactiv ity +U T +N ow +ĠSen ate +ce ll +n ight +Ġcall s +in ter +Ġlet ter +ĠR ob +ĠJ e +Ġcho ose +ĠL aw +G et +B e +Ġro b +Ġtyp es +Ġpl atform +Ġqu arter +R A +ĠT ime +Ġmay be +ĠC r +9 5 +p re +Ġmov ing +Ġl if +Ġgo ld +Ġs om +Ġpat ients +Ġtr uth +ĠK e +ur ance +ant ly +m ar +Ġchar ge +ĠG reat +Ġce le +---------------- ---------------- +Ġro ck +ro id +an cy +Ġcred it +a ud +B y +ĠE very +Ġmov ed +ing er +rib ution +Ġn ames +Ġstra ight +ĠHe alth +ĠW ell +Ġfe ature +Ġr ule +Ġsc he +in ated +ĠMich ael +ber g +4 1 +il ed +b and +Ġcl ick +ĠAng el +on ents +Â Ń +ĠI raq +ĠS aturday +Ġa ware +p art +Ġpat tern +O W +ĠL et +Ġgr ad +ign ed +Ġassoci ated +Ġst yle +n o +i ation +a ith +il ies +Ġst ories +ur ation +Ġindividual s +ĠâĢ ¦ +m iss +ĠAss oci +ish ing +ab y +Ġsum mer +ĠB en +Ġ3 2 +Ġar ch +ut y +ĠTex as +h ol +Ġfull y +Ġm ill +Ġfollow ed +ĠB ill +ĠInd ian +ĠSec ret +ĠB el +ĠFeb ruary +Ġjob s +Ġseem ed +ĠGo vern +i pped +Ġreal ity +Ġl ines +Ġp ark +Ġmeas ure +ĠO ur +I M +Ġbro ther +Ġgrow ing +Ġb an +Ġest im +Ġc ry +ĠS chool +Ġme chan +ĠO F +ĠWind ows +Ġr ates +ĠO h +Ġpos itive +Ġcult ure +ist ics +ic a +Ġh ar +y a +ite ly +i pp +Ġm ap +en cies +ĠWill iam +I I +ak ers +5 6 +ĠM art +ĠR em +Ġal tern +it ude +Ġco ach +row d +D on +Ġk ids +Ġj ournal +Ġcor por +Ġf alse +Ġwe b +Ġsle ep +Ġcont ain +Ġst o +Ġb ed +iver se +ĠR ich +ĠCh inese +Ġp un +Ġme ant +k nown +Ġnot ice +Ġfavor ite +a ven +Ġcond ition +Ġpur pose +) ) +Ġorgan ization +Ġchall eng +Ġman ufact +Ġsus p +ĠA c +Ġcrit ic +un es +uc lear +Ġm er +vent ion +Ġ8 0 +Ġm ist +ĠU s +ĠT or +htt p +ol f +Ġlarg er +Ġadv ant +Ġrese ar +Ġact ions +m l +Ġke pt +Ġa im +, ' +c ol +Ġbenef its +if ying +Ġact ual +ĠIntern ational +Ġveh icle +Ġch ief +Ġeff orts +ĠLe ague +ĠM ost +Ġwa it +Ġad ult +Ġover all +Ġspe ech +Ġhigh ly +Ġfem ale +Ġer ror +Ġeffect ive +5 4 +Ġenc our +w ell +Ġfail ed +Ġcons erv +Ġprogram s +Ġt rou +Ġa head +5 00 +vertis ement +I P +ĠF ound +p ir +Ġ % +Ġcr ime +and er +Ġloc ation +ĠI ran +Ġbehav ior +az ing +Ġr are +Ġem b +Ġca used +Ġsh ip +Ġact ive +Ġcont ribut +Ġg reen +Ġac qu +Ġref lect +ven ue +Ġf irm +Ġb irth +] . +Ġclear ly +Ġem ot +Ġag ency +ri age +Ġmem ory +9 8 +S A +ĠSe e +ac ing +C C +Ġbig gest +Ġr ap +Ġbas ic +Ġb and +e at +Ġsus pect +ĠM ac +Ġ9 0 +m ark +ist an +Ġsp read +am s +k i +as y +ra v +ĠR ober +Ġdemon str +r ated +Ġabs olute +Ġpl aces +Ġim pl +ibr ary +Ġc ards +Ġdest roy +Ġv irt +ve re +Ġapp eared +y an +p oint +Ġbe g +Ġtem per +s pe +ant ed +ear s +ĠD irect +Ġl ength +Ġbl og +am b +Ġint eg +Ġres ources +ac c +if ul +Ġsp ot +Ġfor ced +Ġthous ands +ĠMin ister +Ġqu al +ĠF rench +at ically +Ġgener ally +Ġdr ink +Ġth us +I L +od es +Ġappro pri +ĠRe ad +Ġwh om +Ġey e +Ġcol lege +Ġ4 5 +ire ction +Ġens ure +Ġapp arent +id ers +Ġrelig ious +Ġmin or +ol ic +Ġt ro +ĠWh y +rib ute +m et +Ġprim ary +Ġdevelop ed +Ġpe ace +Ġsk in +st e +av a +Ġbl ue +Ġfam ilies +Ġ ir +Ġapp ly +Ġin form +ĠSm ith +C T +i i +Ġlim it +Ġres ist +........ ........ +um n +Ġconf lic +Ġtw e +ud d +ĠT om +Ġl iter +qu e +b on +Ġha ir +Ġevent ually +Ġp us +Ġhelp ed +Ġag g +or ney +ĠApp le +Ġf it +ĠS ur +Ġpre m +Ġs ales +Ġsecond s +Ġstreng th +Ġfeel ing +¿ ½ +Ġt our +Ġknow s +o om +Ġex erc +Ġsom ew +ï ¿½ +> > +Ġsp okes +Ġide as +Ġreg ist +so ft +ĠD el +ĠP C +Ġpro pos +Ġlaun ch +Ġbott om +T H +ĠP lease +v est +it z +ĠIn ter +Ġsc ript +Ġr at +ar ning +Ġ il +ĠJ er +ĠA re +Ġwh atever +ok en +ci ence +Ġmod e +Ġag ree +Ġs ources +Ġinit ial +Ġrest rict +Ġwond er +us ion +## ## +ĠS il +vil le +Ġb urn +t w +as ion +Ġ £ +Ġn or +u ing +Ġre ached +Ġs un +Ġc ateg +ig ration +Ġc ook +Ġprom ot +Ġm ale +Ġcl imate +Ġf ix +Ġalleg ed +U R +all ed +Ġim ages +C ont +ot a +Ġschool s +i os +Ġd rop +Ġst ream +ĠM o +Ġprevious ly +al ing +Ġp et +Ġdou ble +Ġ( @ +ann el +Ġdef ault +t ies +Ġr ank +ĠD ec +ĠCoun cil +Ġweap on +Ġst ock +Ġanal y +ĠSt r +Ġpict ure +ĠPol ice +f erence +Ġcent ury +Ġcitiz ens +Ġon to +Ġexp and +Ġhe ro +ĠS ol +Ġw ild +Ġupd ate +Ġcustom ers +r ont +d ef +Ġl ik +Ġcrim inal +ĠChrist ian +S P +7 6 +Ġle aving +Ġother wise +ĠD ist +Ġbas is +5 2 +5 3 +ic ip +ĠB er +Ġrecomm end +Ġfl oor +Ġc rowd +ol es +Ġ7 0 +Ġcent ral +ĠE v +Ġd ream +Ġdown load +Ġconf ir +ĠTh om +Ġwind ow +Ġhapp ens +Ġun it +Ġt end +Ġs pl +Ġbec omes +Ġfight ing +Ġpred ict +ĠP ress +ĠP ower +Ġhe avy +ak ed +Ġf an +or ter +ate gy +B A +iz es +Ġsp end +H ere +Ġ200 7 +Ġad op +ĠH am +Ġfoot ball +ĠP ort +od ay +5 1 +amp ions +Ġtrans fer +h t +Ġ3 8 +ter m +ac ity +Ġb ur +] , +tern al +r ig +b ut +Ġthere fore +ĠB ecause +res p +re y +Ġm ission +S ome +Ġnot ed +Ġass um +Ġdise ase +Ġed it +Ġprog ress +r d +ĠB rown +oc al +Ġadd ing +Ġra ised +ĠAn y +Ġt ick +Ġsee ing +ĠPe ople +Ġagre ement +Ġser ver +Ġw at +Ġdeb ate +Ġsupp osed +il ing +Ġlarg est +Ġsuccess ful +ĠP ri +ĠDemocr atic +Ġj ump +ĠSyri a +Ġown ers +Ġoff ers +Ġshoot ing +Ġeff ic +se y +Ġha ven +ver se +te red +ĠL ight +im al +ĠB ig +Ġdef end +Ġbe at +Ġrecord s +% ) +Ġsc en +Ġemploy ees +Ġdev ices +he m +Ġcom mer +ĠM ex +Ġbenef it +ĠPro f +Ġil leg +Ġsur face +ĠAl so +Ġh arm +ing ly +w ide +ĠA lex +Ġsh ut +ĠC ur +Ġl ose +p m +Ġchall enge +se mb +Ġst ation +Ġint elligence +Ġacc ur +ĠFl or +Ġrequ ires +ĠM al +b um +Ġh ospital +Ġsp irit +Ġoff ered +Ġprodu ce +ĠComm un +Ġcreat ing +Ġcr is +s pect +Ġend ed +Ġd aily +Ġvot ers +land s +i as +i h +on a +Ġsm art +ĠOff ice +ĠL ord +ri al +ĠIntern et +Ġcirc um +Ġextreme ly +' . +Ġopin ion +ĠM il +Ġg ain +B S +ĠF in +y p +Ġuse ful +Ġbud get +Ġcom fort +is f +Ġback ground +el ine +Ġep isode +Ġen emy +Ġtri al +Ġestab lish +d ate +ĠC ap +Ġcontin ues +Ġshow ing +ĠUn ion +w ith +Ġpost ed +ĠSy stem +Ġe at +ri an +Ġr ise +ĠGerman y +il s +Ġsign ed +Ġv ill +Ġgr and +m or +ĠEng land +Ġproject s +um ber +Ġconf erence +z a +Ġrespons ible +ĠAr ab +Ġlearn ed +âĢĶ âĢĶ +i pping +ĠGe orge +O C +Ġreturn ed +ĠAustral ia +Ġb rief +Q u +Ġbr and +ill ing +ab led +Ġhig hest +Ġtr ain +ĠComm ission +wh ile +Ġn om +cept ion +Ġm ut +ĠBl ue +Ġinc ident +v ant +8 6 +ĠI D +Ġn uclear +7 4 +ĠL ike +ĠR E +ĠM icro +l i +m ail +Ġcharg es +8 9 +Ġad just +ad o +Ġear th +N A +Ġpr ices +P A +Ġd raft +Ġrun s +Ġcandid ate +ens es +Ġmanag ement +ĠPh il +ĠM iss +Ġte ach +g ram +Ġunderstand ing +a it +ic ago +A dd +ĠE p +sec ut +Ġsepar ate +Ġinst ance +Ġe th +Ġun less +**** **** +ĠF ore +in ate +Ġoper ations +S p +Ġf aith +g ar +ĠCh urch +ron ic +Ġconf ig +os ure +Ġactiv ities +Ġtrad itional +Ġ3 6 +Ġd irection +Ġmach ine +Ġsur round +Ġp ush +un ction +ĠE U +Ġeas ier +Ġarg ument +G B +Ġm icro +Ġsp ending +iz ations +Ġthe ory +ad ow +Ġcall ing +ĠL ast +Ġd er +Ġinflu ence +Ġcomm it +Ġph oto +Ġun c +ist ry +g n +ast e +ack s +Ġdis p +ad y +d o +ĠG ood +Ġ ` +Ġw ish +Ġreve aled +Âł Âł +l ig +Ġen force +ĠComm ittee +Ġche m +Ġmil es +Ġinterest ed +Ġsol ution +ic y +in ct +Ġ- > +ĠD et +Ġrem oved +Ġcomp ar +e ah +Ġpl ant +ĠS ince +Ġachie ve +Ġadvant age +Ġslight ly +b ing +Ġpl aced +u nder +201 5 +ĠM ad +Ġt im +os es +Ġc ru +ĠR ock +Ġmost ly +Ġneg ative +Ġset ting +Ġprodu ced +Ġm ur +Ġconnect ion +ĠM er +Ġdri ver +Ġexecut ive +Ġass ault +Ġb orn +ĠV er +t ained +Ġstruct ure +Ġredu ce +Ġdec ades +Ġd ed +u ke +ĠM any +idd en +Ġle ague +S e +Ġjo in +Ġdis co +Ġd ie +c ks +act ions +Ġass ess +ag n +Ġgo als +our s +I R +Ġsen ior +ill er +m od +ip ment +oc ol +u y +ĠQ ue +Ġpart ies +ir gin +Ġle arning +it able +Ġstre et +Ġcamer a +A pp +Ġsk ills +b re +c ious +Ġcele br +ĠFr anc +Ġexist ing +Ġwill ing +l or +Ġ id +ĠSp ace +Ġcrit ical +ĠL a +ortun ately +Ġser ve +Ġc old +Ġspec ies +T S +Ġanim als +ĠB ay +Ġold er +ĠU nder +est ic +ĠT re +Ġte acher +Ġpre fer +v is +Ġth read +ĠM att +Ġmanag er +ãĥ » +Ġprofess ional +ĠV ol +Ġnot es +The se +ul a +Ġf resh +ent ed +u zz +ed y +clus ion +ĠR el +Ġdoub t +E O +Ġopen ed +ĠB it +Ad vertisement +Ġgu ess +ĠU N +Ġse qu +Ġexpl ain +ott en +Ġatt ract +ak s +Ġstr ing +Ġcont ext +oss ible +ĠRepublic ans +Ġsol id +Ġc ities +Ġask ing +Ġr andom +u ps +ur ies +ar ant +dd en +g l +ĠFlor ida +Ġdep end +ĠSc ott +Ġ3 3 +Ġi T +ic on +Ġmention ed +Ġ2 000 +Ġclaim ed +Ġdefin itely +ul f +Ġc ore +Ġopen ing +ĠCon st +wh ich +ĠT ra +A G +7 2 +Ġbelie ved +ad a +Ġ4 8 +ĠSec urity +yr ight +ĠP et +ĠL ou +Ġhold ing +======== ======== +Ġ ice +Ġb row +Ġauthor ities +h ost +w ord +Ġsc ore +ĠD iv +Ġcell s +Ġtrans l +Ġneigh bor +Ġrem ove +u ct +Ġdist rict +ĠA ccording +Ġwor se +Ġconcern s +Ġpresident ial +Ġpolic ies +ĠH all +7 3 +Ġh us +A Y +Ġ200 6 +ĠJ ud +Ġindepend ent +ĠJust ice +ili ar +pr int +igh ter +Ġprotect ion +z en +Ġsu dden +h ouse +ĠJ es +P R +ĠIn f +Ġb ul +Ġ _ +ĠServ ice +ĠP R +Ġstr ategy +ff ect +Ġgirl s +Ġmiss ing +oy al +ĠTe am +ul ated +Ġd at +Ġpolit ics +ab or +A ccording +Ġspe ll +Ġg raph +ort hern +T C +A b +Ġlab or +is her +Ġk ick +ĠiT unes +Ġstep s +pos es +Ġsmall er +E n +ber t +Ġro ll +Ġresear chers +Ġcl osed +Ġtrans port +Ġlaw y +________ ________ +ĠCh icago +Ġas pect +Ġn one +Ġmar riage +9 6 +Ġe lements +ĠF re +ĠS al +Ġd ram +F C +t op +e qu +Ġhe aring +Ġsupport ed +Ġtest ing +co hol +Ġmass ive +Ġst ick +Ġgu ard +is co +ph one +F rom +How ever +Ġb order +Ġcop y +ograph y +l ist +7 1 +Ġown er +cl ass +ru it +r ate +ĠO nce +Ġdig ital +Ġt ask +ER S +Ġinc red +t es ++ + +ĠFr ance +Ġb reat +ow l +Ġiss ued +ĠW estern +Ġdet ect +Ġpart ners +Ġsh ared +ĠC all +Ġcan cer +ac he +rib e +Ġexpl ained +Ġhe at +{ " +Ġinvest ment +ĠB ook +Ġw ood +Ġtool s +ĠAl though +Ġbelie f +Ġcris is +Ġg e +ĠM P +Ġoper ation +ty pe +~ ~ +g a +Ġcont ains +ant a +Ġexp ress +ĠG roup +ĠJ ournal +k a +Ġam b +ĠUS A +Ġfind ing +Ġfund ing +h ow +Ġestab lished +ide os +Ġdeg ree +Ġdanger ous +ang ing +Ġfre edom +pp ort +out hern +Ġch urch +Ġc atch +ĠTw o +Ġpres ence +ĠGu ard +U p +Ġauthor ity +ĠPro ject +Ġbut ton +Ġcon sequ +Ġval id +Ġwe ak +Ġstart s +Ġref erence +ĠM em +" ) +U N +or age +ĠO pen +Ġcol lection +y m +g ency +Ġbeaut iful +ro s +Ġtell s +Ġwa iting +n el +Ġprov iding +ĠDemocr ats +Ġd aughter +Ġm aster +Ġpur poses +ĠJapan ese +Ġequ al +Ġturn s +Ġdoc uments +Ġwatch ing +R es +Ġr an +201 4 +Ġre ject +ĠKore a +Ġvictim s +Le vel +ere nces +Ġw itness +Ġ3 4 +Ġre form +com ing +Ġocc up +Ġc aught +Ġtra ffic +ad ing +Ġmod els +ar io +Ġserv ed +Ġb atter +u ate +ĠSecret ary +Ġagre ed +Ġtr uly +yn am +ĠR et +Ġun its +ĠRes earch +h and +az ine +ĠM ike +Ġvar iety +ot al +Ġam azing +Ġconfir med +Ġentire ly +Ġpurch ase +Ġe lement +Ġc ash +Ġdeter mine +D e +Ġc ars +ĠW all +â ĸ +Ġview s +Ġdrug s +Ġdep artment +ĠSt ep +u it +Ġ3 9 +as ure +ĠCl ass +Ġc overed +ĠB ank +Ġme re +u ana +Ġmult i +Ġm ix +Ġun like +lev ision +Ġsto pped +Ġs em +ĠG al +ul es +Ġwe l +ĠJohn son +l a +Ġsk ill +Ġbec oming +ri e +Ġappropri ate +f e +ell ow +ĠPro t +ul ate +oc ation +Ġweek end +od ies +Ġsit es +Ġanim al +ĠT im +Ġsc ale +Ġcharg ed +Ġinst ruct +ill a +Ġmethod s +Ġc ert +Ġjud ge +ĠH el +Ġdoll ars +Ġstand ing +ĠS qu +Ġdeb t +l iam +Ġdri ving +ĠS um +ĠEd ition +Ġal bum +and on +I F +ĠU k +6 3 +ad er +Ġcommer cial +es h +ĠGovern ment +Ġdisc overed +Ġout put +ĠHill ary +ĠCar ol +Ġ200 5 +Ġab use +anc ing +Ġsw itch +Ġann ual +T w +Ġst ated +ag ement +in ner +Ġdem ocr +Ġres idents +Ġallow ing +Ġfact ors +od d +Ġf uck +em ies +Ġoccur red +ot i +Ġn orth +ĠP ublic +Ġinj ury +Ġins urance +C L +oll y +ã Ģ +Ġrepe ated +Ġar ms +ang ed +Ġconst ruction +Ġf le +P U +ic ians +Ġfor ms +ĠMc C +ant ic +Ġm ental +p ire +Ġequ ipment +Ġf ant +Ġdiscuss ion +Ġregard ing +k in +ar p +Ġch air +og ue +Ġpro ceed +ĠI d +O ur +Ġmur der +M an +Ġ4 9 +as p +Ġsupp ly +Ġin put +Ġwe alth +liam ent +Ġpro ced +or ial +ĠSt at +ĠN FL +hen s +ĠInst itute +Ġput ting +ourn ament +et ic +Ġloc ated +Ġk id +er ia +r un +Ġpr inc +Ġ ! +go ing +ĠB et +Ġcl ot +Ġtell ing +Ġprop osed +i ot +or ry +Ġfund s +g ment +ĠL ife +Ġb aby +ĠB ack +Ġsp oke +Im age +Ġear n +ĠA T +g u +Ġex change +ĠL in +ov ing +Ġp air +M ore +az on +Ġarrest ed +Ġkill ing +c an +ĠC ard +y d +Ġident ified +Ġm obile +Ġthan ks +ony m +ĠF orm +Ġhundred s +ĠCh ris +ĠC at +Ġtre nd +h at +ĠA v +om an +Ġelect ric +ĠW il +S E +O f +Ġrest aur +ot ed +Ġtr ig +Ġn ine +Ġb omb +Wh y + ¯ +Ġco verage +Ġapp eal +ĠRober t +ĠS up +Ġfin ished +Ġfl ow +Ġdel iver +Ġcal cul +Ġphot os +Ġph il +Ġpie ces +Ġapp re +k es +Ġr ough +D o +Ġpart ner +Ġconcern ed +Ġ3 7 +ĠG en +C ol +ct ors +Ġ= > +st ate +Ġsuggest ed +ĠFor ce +C E +Ġher self +ĠPl an +w orks +o oth +ren cy +Ġcor ner +Ġhus band +Ġintern et +ĠA ut +em s +os en +ĠAt l +g en +Ġbal ance +6 2 +Ġsound s +te xt +Ġar r +ov es +Ġmill ions +Ġrad io +Ġsat isf +ĠD am +M r +G o +S pe +Ġcomb at +r ant +ĠG ree +Ġf uel +Ġdist ance +Ġtest s +Ġdec re +ĠE r +Ġman aged +D S +Ġt it +Ġmeas ures +ĠL iber +Ġatt end +as hed +ĠJ ose +ĠN ight +d it +ĠN ov +ĠE nd +out s +Ġgener ation +Ġadv oc +y th +Ġconvers ation +ĠS ky +act ive +ce l +ri er +ĠFr ank +Ġg ender +Ġcon cent +Ġcar ried +and a +ĠV irgin +Ġarri ved +ic ide +ad ed +Ġfail ure +Ġmin imum +le ts +Ġwor st +Ġkeep ing +Ġint ended +Ġilleg al +Ġsub sc +Ġdetermin ed +Ġtri p +Y es +Ġra ise +Ġ ~ +Ġfeel s +Ġpack age +ĠJ o +h i +201 6 +re al +Ġf ra +Ġsy mb +M e +uck y +p ret +ĠK h +ĠEd it +ĠWe b +em ic +ĠCol or +Ġjust ice +I nt +Ġfar m +ck now +" > +el ess +Ġredu ced +Ġ5 00 +x x +ĠR ad +ĠW ood +Ġcl in +Ġhy p +il er +ur a +k ins +8 5 +6 1 +ĠThe ir +ĠM ary +Ġs an +Ġno vel +ĠWh o +Ġcap acity +Ġimp ossible +Ġpl ays +Ġmin ister +ij uana +ic ate +ĠS et +Ġf ram +Ġ ing +Ġcommun ities +ĠF BI +it a +Ġb on +Ġstr ateg +Ġinterest s +l ock +g ers +m as +ĠAN D +Ġconflic t +Ġrequire ments +Ġs ac +Ġoper ating +in i +rel ated +Ġcomm itted +Ġrelative ly +Ġs outh +¯ ¯ +Ġaff ord +Ġident ity +Ġdec isions +Ġacc used +pl ace +Ġvict ory +o ch +i at +N ame +C om +t ion +ed s +Ġsee k +Ġt ight +ĠIm ages +Ġinit i +Ġhum ans +Ġfam iliar +Ġaud ience +Ġintern al +vent ure +Ġs ides +ĠT O +Ġd im +Ġcon clud +Ġapp oint +Ġenforce ment +ĠJ im +ĠAssoci ation +Ġcircum st +ĠCanad ian +Ġjo ined +Ġdiffere nces +ĠL os +Ġprot est +Ġtw ice +w in +Ġgl ass +ars h +ĠAr my +Ġexp ression +Ġdec ide +Ġplan ning +an ia +Ġhand le +ĠMicro soft +ĠN or +Ġmax imum +ĠRe v +Ġse a +Ġev al +Ġhel ps +re f +Ġb ound +Ġm outh +Ġstand ards +Ġcl im +ĠC amp +ĠF ox +cl es +Ġar my +ĠTe chn +ack ing +x y +S S +Ġ4 2 +Ġbu g +ĠUk rain +ĠM ax +ĠJ ones +ĠSh ow +l o +Ġplan et +Ġ7 5 +Ġwin ning +Ġf aster +Ġspe ct +Ġbro ken +T R +Ġdef ined +Ġhealth y +Ġcompet ition +htt ps +ĠIs land +ĠF e +Ġannoun ce +ĠC up +ĠInst ead +Ġcl ient +Ġposs ibly +se ction +ock et +l ook +Ġfin ish +Ġcre w +Ġres erv +Ġed itor +Ġh ate +Ġs ale +Ġcontro vers +Ġp ages +w ing +Ġnum er +Ġopp osition +Ġ200 4 +Ġref uge +Ġfl ight +Ġap art +ĠL at +A meric +ĠAfric a +Ġapplic ations +ĠPal est +ĠB ur +Ġg ar +ĠSoc ial +Ġup gr +Ġsh ape +Ġspe aking +ans ion +a o +ĠS n +Ġwor ry +ĠBrit ain +P lease +rou d +Ġh un +Ġintrodu ced +Ġd iet +I nd +ĠSec ond +Ġfun ctions +ut s +ĠE ach +ĠJe ff +Ġst ress +Ġaccount s +Ġgu arant +ĠAn n +ed ia +Ġhon est +Ġt ree +ĠAfric an +ĠB ush +} , +Ġs ch +ĠOn ly +Ġf if +ig an +Ġexerc ise +ĠEx p +Ġscient ists +Ġlegisl ation +ĠW ork +ĠS pr +à Ĥ +ĠH uman +Ġ è +Ġsur vey +Ġr ich +ri p +Ġmain tain +Ġfl o +Ġleaders hip +st ream +ĠIslam ic +Ġ 01 +ĠCol lege +Ġmag ic +ĠPr ime +Ġfig ures +201 7 +ind er +x ual +ĠDe ad +Ġabsolute ly +Ġfour th +Ġpresent ed +resp ond +rib le +Ġal cohol +at o +ĠD E +por ary +Ġgr ab +Ġvar i +Ġqu ant +ĠPh oto +Ġpl us +r ick +ar ks +Ġaltern ative +Ġp il +Ġappro x +th at +Ġobject s +ĠR o +ĠAnd roid +Ġsignificant ly +ĠR oad +k ay +R ead +av or +Ġa cknow +ĠH D +ĠS ing +O r +ĠM ont +Ġun s +pro f +Ġneg oti +ĠAr ch +ik i +Ġte levision +ĠJew ish +Ġcomm ittee +Ġmot or +Ġappear ance +Ġs itting +Ġstri ke +ĠD own +com p +ĠH ist +Ġf old +ac ement +ĠLou is +Ġbel ong +ĠâĢ ¢ +Ġm ort +Ġprep ared +Ġ6 4 +ĠM aster +Ġind eed +ĠD en +Ġre nt +T A +our ney +ar c +S u +9 7 +Ġadv ice +Ġchang ing +Ġlist ed +Ġlaun ched +is ation +ĠP eter +is hes +Ġl ived +ĠM el +ĠSup reme +ĠF ederal +Ġ) ; +ruct ure +Ġset s +Ġphil os +u ous +Ġ ł +Ġappl ied +ĠN OT +Ġhous ing +ĠM ount +Ġo dd +Ġsu st +D A +ffic ient +Ġ ? +ol ved +Ġp owers +Ġth r +Ġrem aining +ĠW ater +L C +Ġca uses +ãģ ® +Ġman ner +ad s +Ġsuggest s +Ġend s +stand ing +f ig +ĠD un +id th +Ġg ay +Ġter min +ĠAngel es +M S +Ġscient ific +Ġco al +ap ers +b ar +ĠThom as +Ġsy m +ĠR un +th is +P C +igr ants +Ġmin ute +ĠDist rict +cell ent +Ġle aves +Ġcomple ted +am in +Ġfoc used +Ġmon itor +Ġveh icles +M A +ĠM ass +ĠGr and +Ġaffect ed +itution al +Ġconst ruct +Ġfollow s +Ġt on +re ens +Ġh omes +ĠE xt +ĠLe vel +r ast +ĠI r +Ġel im +Ġlarge ly +ĠJ oe +Ġvot es +all s +Ġbusiness es +ĠFound ation +ĠCent ral +Ġy ards +Ġmaterial s +ul ner +Ġgu ide +Ġclos er +um s +Ġsp orts +ed er +J ust +Ġtax es +8 4 +ĠO ld +Ġdec ade +ol a +Ġv ir +Ġdro pped +Ġdel ay +it ect +Ġsec ure +ste in +le vel +Ġtre ated +Ġfil ed +ain e +Ġv an +Ġm ir +Ġcol umn +ict ed +e per +Ġro t +Ġcons ult +Ġent ry +Ġmar ijuana +ĠD ou +Ġapparent ly +ok ing +clus ive +Ġincre ases +an o +Ġspecific ally +Ġte le +ens ions +Ġrelig ion +ab ilities +Ġfr ame +ĠN ote +ĠLe e +Ġhelp ing +Ġed ge +ost on +Ġorgan izations +à ĥ +ĠB oth +hip s +Ġbig ger +Ġbo ost +ĠSt and +Ġro w +ul s +ab ase +Ġr id +L et +are n +ra ve +Ġst ret +P D +Ġv ision +Ġwe aring +Ġappre ci +Ġa ward +ĠU se +Ġfact or +w ar +ul ations +) ( +Ġg od +Ġter rit +Ġpar am +ast s +8 7 +Ġen emies +ĠG ames +F F +Ġacc ident +W ell +ĠMart in +T ER +Ġat h +ĠHe ll +Ġfor g +Ġve ter +ĠMed ic +f ree +Ġst ars +Ġexp ensive +Ġac ad +ra wn +ĠW he +Ġl ock +Ġform at +Ġsold iers +s m +Ġag ent +Ġrespons ibility +or a +ĠS cience +Ġrap id +Ġt ough +ĠJes us +Ġbelie ves +M L +Ġwe ar +le te +Ãĥ ÃĤ +ĠD ri +Ġcomm ission +ĠB ob +O h +ap ed +Ġwar m +ÃĥÃĤ ÃĥÃĤ +Ġ200 3 +ort ion +Ġhas n +ust er +Ġun ivers +ĠI ll +Ġk ing +olog ies +9 4 +ĠT em +ĠM os +Ġpat ient +ĠMex ico +ce an +ĠDe ath +ĠSand ers +y ou +ĠC ast +ĠComp any +pt y +Ġhappen ing +F P +ĠB attle +Ġb ought +A m +M od +U s +ut ers +ĠC re +ĠTh ose +Ġ4 4 +is er +Ġs oul +ĠT op +ĠHar ry +ĠA w +Ġse at +ff ee +Ġrev olution +Ġ( " +ĠD uring +et te +Ġr ing +Ġoff ensive +Ġreturn s +Ġv ideos +Ġdis cl +Ġfam ous +en ced +ĠS ign +ĠR iver +Ġ3 00 +P M +ĠB us +ĠC H +Ġcandid ates +ard en +Ġpercent age +Ġvis ual +Ġthan k +Ġtrou ble +ner gy +Ġ200 1 +Ġpro ve +ash ion +Ġen h +ĠL ong +U M +Ġconnect ed +Ġposs ibility +O ver +Ġexper t +Ġl ibrary +art s +ĠDirect or +Ġfell ow +9 2 +ir ty +Ġd ry +Ġsign s +ĠL ove +Ġqu iet +f oot +Ġp ure +ĠH un +Ġf illed +ph as +ĠE lect +end ment +ĠEx pl +Ġun able +n s +m o +Ġv ast +ob e +Ġident ify +app ing +ĠCarol ina +g ress +Ġpro te +Ġf ish +Ġcircumst ances +raz y +ĠPh ot +Ġb odies +ĠM ur +Ġdevelop ing +ĠA R +Ġexperien ced +Ġsubst ant +ĠBo ard +es ome +Ġdom estic +Ġcomb ined +ĠP ut +Ġchem ical +ĠCh ild +Ġpo ol +ĠC y +Ġe gg +c ons +st ers +Ġh urt +Ġmark ets +Ġconserv ative +Ġsupp orters +Ġag encies +id el +O b +ur b +Ġ4 3 +ĠDef ense +y e +ĠA p +du le +Ġtemper ature +Ġconduct ed +ĠCh ief +Ġpull ed +Ġf ol +L ast +ont o +os is +V ER +D es +ĠP an +F irst +Ġadv ance +Ġlic ense +r ors +ĠJ on +Ġimag ine +Ġhe ll +Ġf ixed +Ġinc or +os ite +ĠL og +ick en +] : +Ġsurpr ise +h ab +Ġc raft +ol t +ĠJ ul +Ġd ial +Ġrele vant +Ġent ered +Ġlead s +ĠA D +ĠCle an +Ġpict ures +ess or +Ġal t +Ġpay ing +P er +ĠMark et +Ġupd ates +am ily +ĠT ype +ĠH ome +Ġ5 5 +semb ly +rom e +8 3 +Ġgreat est +Ġhe ight +Ġhe av +ain ts +Ġlist en +as er +ĠS H +Ġcap able +ac le +Ġpers pect +in ating +Ġoff ering +ry pt +ĠDe velop +ab in +r c +Ġbr ight +al ty +ar row +Ġsupp l +ind ing +ack ed +gy pt +ĠAn other +p g +ĠVirgin ia +ĠL u +Ġpl anned +Ġp it +Ġswe et +T ype +ĠD i +Ġtyp ically +ĠFranc isco +Ġpro spect +ĠD an +Ġte en +re es +Ġsc hed +Ġh ol +Ġsc r +Ġlot s +l ife +Ġnews p +Ġfor get +ĠN one +ĠM iddle +ĠR yan +ed d +Ġse vere +Ġsu it +ll er +9 3 +Ġcor respond +Ġexpl os +u ations +Ġfl ag +g ame +r id +Ġpr in +ĠD ata +Ġde ploy +ĠEn ter +su it +gh an +ĠM en +Ġthough ts +Ġmat ters +Ġad apt +ĠA ri +Ġf ill +Ġfor th +Ġs am +Ġ4 1 +Ġpay ment +ĠH or +Ġsp ring +du c +Ġl osing +Ġbring ing +F O +al a +Ġdist ribution +he red +b our +ĠIsrael i +om a +Ġcomb ination +Ġpl enty +V E +C an +ĠH aw +Ġper man +ĠSpe cial +Ġto w +Ġsee king +Ġexam ples +Ġclass es +c r +Ġbe er +Ġmov es +ĠI P +ĠK n +Ġpan el +E ven +Ġproper ly +Ġr is +Ġpl ug +Ġestim ated +E very +Ġdef ensive +ag raph +Ġpre gn +Ġinst it +ĠV ict +Ġvol ume +Ġpos itions +Ġl inks +ĠPro gram +ĠWe ek +ag ues +Ġtrans form +k er +ĠC EO +Ġc as +Ġopp onent +Ġtwe et +ĠC ode +Ġsh op +Ġf ly +Ġtal ks +Ġb ag +Ph one +Ġa id +Ġpl ants +Ġ6 5 +Ġatt orney +ar ters +qu est +ĠMag ic +Ġbeg ins +Ġmy ster +Ġenvironment al +Ġst orage +N N +Ġm arg +Ġs ke +Ġmet al +ell y +Ġord ered +Ġrem ained +Ġl oved +Ġprom pt +Ġupd ated +Ġexper ts +Ġwalk ing +Ġan cient +Ġperform ed +AT E +Ġne ither +i ency +Ġmanufact ure +ĠP ak +Ġselect ed +Ġm ine +Ġult imately +Ġexpl an +Ġlab el +ĠServ ices +ribut ed +Tr ump +Ġsy n +ĠU lt +S C +Ġme at +Ġg iant +ĠW ars +ĠO N +Ġad m +Ġinter pret +Ġeven ing +Ġev il +ĠB oston +ĠW ild +Ġ à +ĠBit coin +ĠAm azon +D r +ĠIn formation +Ġobvious ly +Ġadv anced +Ph oto +ol ar +Ġwe ather +Ġsymb ol +Ġso le +Ġpot entially +ost er +Ġorig inally +m un +3 00 +az e +ess ions +Ġde ck +Ġst ood +Ġyou th +ĠB ern +R ep +ĠT est +Ġbas ically +ot ic +Ġinvol ve +ol it +ly n +S ee +Ġair craft +Ġconf irm +E W +Ġmess ages +ĠRich ard +Ġk it +Ġpro hib +Ġv ulner +is ters +Ġexist ence +Ġturn ing +ĠS P +Ġdes ire +Ġfl at +Ġm ent +se ason +ang es +Ġneighbor hood +ĠL ake +AT ION +Ġpoint ed +b ur +Ġinn ov +uc ks +U L +Ġprofess or +Ġexp ressed +A B +ic ious +Ġ200 2 +ĠDe v +Ġs ession +Ġb are +s en +Ġdis s +ĠC ath +ĠP ass +ĠP oint +Ġdo ctor +or row +ail ed +ĠR ub +ĠD C +ĠChar l +p erson +Ġwrit er +igh ters +ure au +Ġob lig +Ġrecord ed +Ġbro ke +Ġord ers +il ty +Ġmot ion +in ity +l aw +ad ium +Ġimm igration +Ġcontr ast +Ġb att +Ġex cellent +Ġtechn ical +am i +Ġt un +Ġcl oud +ĠY ear +ge on +Ġcre ation +Ġstr ange +Ġa uth +Ġfor t +b orn +Ġext ent +ĠT oday +ĠCl ub +Ġr ain +Ġs ample +Ġaccept ed +Ġt act +Ġf ired +ĠS on +Ġstand s +Ġb oot +Ġ4 7 +Ġstat ements +Ġvers ions +Ġse lling +ound ed +Ġ199 0 +Ġwere n +ĠW atch +Ġexper iment +P ost +Ġret ail +ul ed +In st +un te +ãĥ ¼ +Ġdep art +Ġb ond +i very +om pl +Ġre action +ĠSyri an +ĠP ac +app ed +ani el +D P +Ġres olution +Ġre act +Ġappro ved +on om +m ond +ĠO ffic +-- - +Ġrepl ace +Ġt ack +Ġsp ort +Ġch ain +Ġemer gency +r ad +ĠPalest in +Ġ4 6 +Ġautom atically +Ġrout e +Ġp al +Ġb anks +ĠPar is +ĠMed ia +ro ad +ic ing +i xt +ist ed +Ġg rew +Ġco ord +ĠW here +om in +Ġsub s +� � +Ġ ± +Ġcorpor ate +Ġse lection +n oon +ĠRep ort +c s +clud ing +ord ers +anc he +ĠIt s +Ġslow ly +ĠE gypt +ĠA cc +Ġcol le +iqu es +E X +Ġattempt s +ur l +ĠC ross +Ġfind ings +ĠS C +ĠO R +Ġind ex +ens ity +ĠW ay +ĠL and +Ġsh ock +d is +Ġd ynam +Ġc art +m osp +S ince +i est +ĠB oy +Ġst orm +ĠCont in +201 3 +he w +il it +Ġess ential +iqu id +O ther +ive red +Ġreason able +A ct +Ġsub sequ +ĠP ack +ĠF ort +Ġconsider ing +Ġun iversity +l og +Ġmar ried +Ġill ust +ĠTr ue +£ ı +Ġnumer ous +rast ructure +Ġserious ly +Ġrefer red +u a +Ġconsist ent +on na +ĠRe al +ru ption +ci ples +Ġfact s +9 1 +ot es +er g +The n +Ġacc ompl +N ote +Ġre venue +Ġpass ing +Ġm al +e en +ĠY et +Ġg ather +ter day +ew ork +ĠA uthor +P e +Ġopt im +Ġr ub +Ġè £ı +Ġun known +st one +Ġun ion +ol ve +Ġopportun ities +Ġbrow ser +ĠW al +ĠC ost +Ġreport ing +st s +p et +Ġs and +Ġsudden ly +Ġsurpr ising +ĠV R +Ġsomew hat +ĠB as +ult ure +iz z +ĠC D +Ġchalleng es +Ġsett ings +Ġexperien ces +ĠF ull +Ġcan n +Ġrece iving +ES T +Ġj oint +Ġcult ural +Ġa st +8 2 +as tern +ce ived +ĠC ru +Ġb ull +p ired +am m +Ġfac ing +p ower +Ġb oss +ĠH ol +Ġinst r +Ġincreasing ly +Ġsh ift +Ġstre ets +ĠWilliam s +ab b +Ġl ie +Ġl augh +ĠC a +P L +Ġadult s +Ġcustom er +Ġob tained +Ġsupport ing +ht ml +f ire +Ġdetail ed +Ġpick ed +ĠR ight +ld er +E E +st ood +ĠK im +Ġw ire +Ġs ight +Ġdevelop ers +Ġpers ons +Ġs ad +Ġc up +Ġwar ning +Ġboy s +l ong +Ġb ird +f o +Ġw al +Ġobserv ed +Ġz one +iven ess +Ġch annel +c ript +Ġref used +ĠAg ain +Ġsu c +Ġspokes man +ĠRe f +r ite +ou ston +ãĥ ³ +ĠS her +Ġact s +ĠN ame +Ġstrugg le +ar ry +omet imes +Ġdisc rim +H T +Ġcateg ory +Ġreal ize +Ġemploy ee +ĠAf ghan +en ger +Ġgun s +ĠSte ve +ĠM ot +ĠO l +ok ed +Ġth ick +Ġfair ly +ill y +Ġsur ve +ĠM at +we ight +â Ķ +Ġtro ops +Ġag ents +Ġbatter y +Ġmot iv +à ¡ +S ec +d en +o very +L S +Ġfl u +Ġconf ident +ĠO per +Ġem pty +Ġp hen +Ġse ctor +Ġexc ited +Ġrem ote +ap h +o en +Ġdestroy ed +Ġmor al +ĠH P +ĠR on +Ġd ress +ĠB at +Ġl it +ĠM S +Ġa f +H L +r um +is ms +Ġshould n +Ġsym pt +ĠTor onto +het ic +Ġcar bon +Ġinstall ed +Ġviol ent +Ġsol ar +j a +Ġpract ices +Ġr ide +ĠP enn +Ġimpro ved +Ġaud io +Ġbehav i +ĠP S +Ġe ating +D ata +ĠRe view +p ass +cl aim +u ated +ang ers +c hen +Ġproper ties +Ġany where +An other +Ġbl ow +ĠJack son +Ġp roud +Ġplan e +l ines +Ġsqu are +Ġpro of +ans as +Ġtalk ed +m akers +Ġs ister +Ġhold s +Ġres ident +Ġ= = +Ġresist ance +Ġspl it +Ġpro secut +Ġconf idence +res ents +Ġcut s +Ġexcept ion +Ġz ero +Get ty +Ġcop yright +Ġtot ally +orm al +ific ations +ĠAustral ian +Ġs ick +Ġ1 50 +Ġhouse hold +Ġfe es +Ġdri vers +og en +ĠN Y +Ġnecess arily +Ġregul ations +ear ing +s l +Ġperspect ive +c are +ic ial +H is +Ġesc ape +Ġsurpr ised +ĠV an +ur rent +Ġv ac +8 1 +ĠTh us +Ġem phas +ĠCh ampions +ĠI ce +Ġn arr +Ġhead s +Ġca using +b el +f ortunately +ĠM a +Ġtarg ets +ci pl +Ġafter noon +Ġadd s +ĠMay be +ĠF our +ess ed +ple te +Ġus ual +ch o +ing u +Ġwith d +ĠE nergy +ĠE conom +O O +Ġart icles +Ġinj ured +Ġman age +Ġexpl ains +Ġdi agn +R ec +at ures +Ġlink ed +Ġdiscuss ed +Ġexpl o +Ġocc asion +ath an +Ġopp osite +Ġfac es +Ġden ied +ĠK night +Ġn ut +Ġapprox imately +Ġdisapp oint +onym ous +ĠB est +ĠL o +ĠH y +ĠA ff +Ġvot ing +an while +ĠII I +Ġinstit utions +ag ram +ĠD aily +Ġdr ag +Ġnear by +Ġgu ilty +Ġcon ver +P re +s hip +Ġre ward +Ġphilos oph +ĠS S +u gh +Ġapp s +f riend +Ġu pper +Ġad vert +Ġs now +Ġfr ust +Ġour selves +F r +ĠD ie +amp ion +Ġdis miss +Ġc ere +Ġsign al +f rom +Ġ ). +Ġ5 2 +Ġcr imes +it ors +est ival +use um +Ġcoun cil +ĠS aud +M ay +ĠG un +ic ian +et her +Ġsu fficient +ĠH en +so le +Ġhistor ical +ĠF ar +ĠT urn +Ġp in +Ġsuc ceed +m at +ly mp +Ġtrad ition +ĠO k +Ġc ro +Ġdesc ription +al le +Ġsk y +T e +Ġwide ly +Ġw ave +Ġdefin ition +ĠJew s +Ġcy cle +Ġref ere +Ġbr ings +us al +Ġal ive +Ġfrequ ently +Ġint ention +ĠCont rol +l v +y stem +Ġpriv acy +g ent +ren ce +ĠQu est +ĠChrist mas +Ġr ail +Ġco oper +Ġtest ed +ĠC apt +as ks +Ġcomfort able +Ġdel ivered +sc ape +Ġdep th +ĠG OP +Ġwrit es +Ġass ets +Ġsa v +im ents +Ġtrans ition +Ġart ist +ĠL ook +Ġl ob +Ġcomp onents +ar ity +Ġwalk ed +Ġro ot +Ġparticip ants +Ġnot iced +Ġres c +Ġn av +ĠAd minist +d a +ut ral +pl ate +Ġimport ance +Ġass ert +ious ly +c ription +Ġinj uries +ĠChe ck +Ġregist ered +Ġint ent +Ġmiss ed +ograph ic +Ġsent ence +oun ter +Ġassist ance +ev in +Ġdat abase +Ġbuild ings +Ġclass ic +Ġth inks +ĠOh io +P r +ug g +Ġfe e +p an +Ġeffect ively +Ġfac ility +Ġbe ar +Ġch apter +Ġdog s +ĠCol umb +Ġl atter +it ial +Ġad mitted +T V +ĠGe org +Ġpost s +\ \ +Ġlawy er +Ġequ ival +Ġm and +Ġcontro lled +ĠW alk +ĠAnd rew +Ġmen u +am ental +Ġprotect ed +v a +Ġadminist r +or al +Ġre in +ĠS ar +Ġamount s +Ġn ative +ĠM oon +Ġrep resents +Ġab andon +Ġcarry ing +Ġt ank +m ary +Ġdecl ared +T ube +Ġh at +Ġpun ish +el lect +m es +Ġun iverse +ĠR od +ph y +Ġinf rastructure +Ġ5 1 +Ġopp osed +ow nt +c a +ĠM ake +Ġhard ware +Ġco ffee +R el +b al +w orld +ĠS af +ĠSe a +in als +Ġown ed +Ġh all +ers ion +Ġdescrib e +ĠP ot +Ġport ion +Ġat mosp +Ġgovern ments +Ġdep ending +Ġoff ense +Ġtr ick +aw a +ĠL ine +ĠV is +ĠH ard +ĠOr ig +ĠCl ick +Ġdes k +ĠVal ley +ĠS ov +Ġmov ies +Ġrem ark +Ġm ail +Ġcons cious +Ġrul ing +ĠR ights +Ġmed ic +he nt +ĠW omen +> < +Ġrepl aced +ĠP rem +ĠTh anks +Ġre new +ĠB all +if orm +Ġsh ots +C omm +Ġar med +Ġconst ant +Ġt aste +Ġreal ized +Ġbu ff +Ġm o +Ġeffic ient +M ost +or ation +if ies +Ġcommun ication +Ġfl ood +Ġconsequ ences +Ġany way +ig g +ĠG M +ĠTh ank +Ġ iron +Ġev olution +ĠC op +tw itter +Ġ9 5 +Ġrelationship s +ad el +ĠYou ng +Ġpropos al +ay ers +uild ing +ĠH ot +OR E +c os +Ġcoll abor +P G +ax y +Ġknow ing +Ġsupport s +ow ed +Ġcontrol s +Ġmere ly +um er +Ġath let +Ġf ashion +p ath +Ġg ift +Ġer a +AN D +Ġkind s +ĠKore an +Ġleg it +ul ous +Ġess entially +Ġthe rap +n ic +Ġsuff ered +Ġh ur +Ġprom ise +Ġex cess +Ġover w +Ġpr ime +ĠH ouston +er ry +ĠM s +R S +201 2 +Ġst ores +ĠO lymp +Ġj ourney +Al though +S ub +ĠE duc +ĠCh apter +Ġrequest s +Ġconsum ers +Ġt iny +Ġis ol +ĠF air +b a +ĠY OU +Ġcr ash +ce ler +Ġemot ional +Ġgood s +Ġelect ed +Ġmod er +ĠLin ux +Ġbl ocks +Ġis land +ĠSoc iety +Ġelect ions +Ġbroad cast +Ġche ap +Ġn ations +Ġse asons +4 00 +Ġwas te +ĠS at +Ġfield s +em ploy +Ġprof ile +Ġauth ors +AL L +ĠG ra +w est +ĠT y +Ġdeath s +Ġv acc +Ġfor med +Ġd u +Ġon going +ĠMuslim s +el f +ig ure +Ġass ume +ĠUkrain e +w ater +Ġco ast +Ġvot ed +g or +ĠA S +ĠMich igan +az a +ĠAr m +i ro +Ġf lex +as ters +' ' +Ġwel come +ar l +Ġloc ations +ig ation +ĠF il +Ġbu ying +Ġarch itect +Ġhard er +ĠC ub +Ġinter face +Ġrestaur ant +Ġdisco ver +Ġex ceed +Ġfav our +ger y +Ġd uty +Ġp itch +ad or +ĠM ach +b oy +Ġrespond ed +Ġext ended +her s +M any +ra id +if er +ĠIn s +S er +Ġmed ium +s he +ĠS ports +Ġmag azine +ut ation +Ġlim its +ĠG all +Ġex ternal +raz il +Ġyoung er +t le +Ġrem ind +ĠC ON +Ġimmedi ate +Ġh idden +Ġvol unte +Ġsim pl +od cast +Ġph ase +d r +Ġpl ot +Ġexp osure +R I +og rap +v in +an ish +ĠAc ad +ĠEng ine +Ġexp ansion +ĠP ay +Y our +Ġpus hed +ĠE ll +ĠHe ad +Ġmarket ing +ĠA C +k et +Ġh its +Ġg ro +ĠA ge +ĠSc ot +] [ +Ġst im +Ġi Phone +Ī Ĵ +Ġn arrow +ĠGet ty +ĠTur key +Ġperfect ly +Ġen able +ut ch +Ġprec ise +Ġreg ime +Ġsh if +Ġcomp ens +g un +d iv +Ġch osen +ĠK en +An y +Ġtre es +Ġrecomm ended +ĠR en +u able +ĠH T +F ollow +E G +ĠH and +ĠK enn +Ġarg uments +Ġex ists +Ġb ike +ĠCons erv +Ġbre aking +ĠG ar +Ġc razy +Ġvirt ual +ay lor +ix el +Ġ19 80 +Ġper mission +ĠSer ies +Ġconsum er +Ġclose ly +c alled +Ġ5 4 +Ġhop es +Ġar ray +ĠW in +ĠLab our +Ġsp ons +ĠI re +Ġp ow +Ġread ers +Ġemploy ment +Ġcreat ure +Ġresult ing +Ġaccur ate +Ġmom ents +Ġarg ued +Ġp ed +D uring +Ġ5 3 +ĠT al +Ġs ought +Ġsuff ering +Ġ icon +le e +Ġ( $ +al ian + ° +Ġp ra +Ġbon us +( " +k o +Ġact ing +D E +f all +Ġcompar ison +Ġsm ooth +ĠN AS +u pp +ĠJose ph +ep ing +ĠT ake +ĠM id +Ġs ending +f ast +ĠF all +Ġdeal ing +us er +ĠOr gan +C o +Ġatt ached +Ġse es +% . +Ġtyp ical +AR T +Ġfind s +ĠAs ia +um in +ĠC ore +ĠE nt +in ent +u ce +ĠBl ood +ĠN ever +Ġem ails +Ġhigh light +Ġconf ront +at us +ut ed +Ġun us +Ġtop ic +ĠAd am +Ġb le +at i +Ġunder stood +S et +st ruct +T P +Ġm ob +a a +ĠSt art +pect ed +se ll +Ġded icated +ĠC A +u an +Ġsong s +esc ription +Ġte ch +Ġr ape +Ġas ide +Ġgr ant +Ġ5 6 +s ub +Ġarg ue +Ġcont aining +Ġsche dule +Ġliber al +Ġpublic ly +Ġheav ily +ĠU t +in er +ĠS ection +ĠC are +we et +l s +D is +âĶ Ģ +ĠF ollow +B ack +ĠI T +Ġb es +j i +ĠH it +est ed +Ġevery body +ĠSw ed +Ġfem in +Ġfac ilities +Ġcon ven +C omp +ĠO S +c ore +Ġan x +Ġdiv ision +ĠC am +ĠSt an +m ates +Ġexpl ore +pl om +Ġsh ares +pl oad +an es +Ġide al +et ers +ĠB ase +Ġpl astic +Ġdist inct +ĠNet work +ĠSe attle +Ġtrad ing +ens us +int end +Ġex hib +Ġinit ially +ĠF ood +Ġthous and +ĠBus iness +act er +Ġpar agraph +Ġrough ly +Ġw ww +Ġcreat ive +ĠCon f +Ġconsum ption +Ġfil ms +ag an +Ġob tain +Ġt all +Ġt or +Ġacknow led +Ġg rown +al o +K E +Ġ4 00 +end ers +t aining +U G +Ġsu icide +Ġwat ched +ĠL ist +al i +re hens +Ġsurround ing +Ġp ip +Ġf lying +ĠJ ava +ord an +Ġserv ing +in ations +p ost +Ġsh o +A v +Ġj ail +z y +Ġ199 9 +Ġ< / +Ġliter ally +ĠS ir +Ġexp osed +Ġl ies +st ar +Ġb at +Ġear ned +ĠD ig +Ġspec ified +ĠSe ason +Ġdeg rees +Don ald +Ġcent re +Ġsh aring +Ġwin ter +ĠC O +C he +Ġ Î +M P +Ġun w +Ġfew er +ĠM ir +Ġsomew here +ĠK ey +Ġattack ed +ĠK ir +Ġdom ain +Ġstrong er +Ġ9 9 +Ġpen alty +I d +Sc ript +Ġdecl ined +Ġne ck +Ġfra ud +Ġcur rency +Ġr ising +R C +âĢ¦ âĢ¦ +H z +Ġt ab +Ġtal ent +n am +ĠN BA +Ġvill age +Ġleg s +ĠN ext +E d +Ġac id +Ġhy d +8 00 +Ġinvol ving +ĠIm age +ĠBe fore +F l +Ġyes terday +S ource +Ġterror ist +Ġsu p +Ġsy nt +ĠSaud i +Ġw est +Ġr u +b urg +Ġvis ible +Ġstru ck +r ison +Ġaw esome +Ġd rawn +Ġansw ers +ĠG irl +ĠR am +Ġthreat s +Ġdef eat +os it +Ġv ent +atur ally +Americ an +end a +ĠH oly +Ġr um +% , +c ase +ĠHist ory +ĠYou Tube +Ġsit uations +ĠD NA +S te +Ġsa ved +It em +Ġrec ip +olog ist +Ġfac ed +Ġel ig +O nce +ĠL i +u h +Ġmist ake +ĠDiv ision +ĠB ell +Ġsympt oms + ® +Ġdom in +Ġfall ing +Ġend ing +as hes +Ġmat ches +ĠOn line +Ġexplan ation +D ef +red it +Ġany more +ĠT otal +ĠF OR +us hed +Ġlet ters +Ġris ks +ĠO K +Ġreported ly +: \ +Ġpl ate +Ġsubject s +Ġattempt ed +if ier +ian a +Ġunlike ly +ĠTh ough +um a +ĠIn vest +ĠPr in +ic an +ĠD ar +ĠColor ado +au g +Ġve get +a os +ri a +Ġshe l +Ġmark ed +Ġ( ) +Ġsp r +p o +ĠL ink +Ġdef e +ĠJ r +Ġthem e +Ġpass ion +ĠP en +Ġinf o +iz er +Ġsh it +ĠC ivil +ap se +c re +Ġpo ly +Ġcomp onent +ĠChar les +ĠIre land +ĠPro v +Ġdo ctors +Ġgr anted +Ġpain t +Ġhon or +Ġsm oke +Ġpay ments +Ġprim arily +ĠKing dom +r ich +ate ll +Ġde als +Ġsched uled +Ġfund amental +Ġprote in +Ġnewsp aper +Ġcl ients +yth on +ĠD ate +h us +Ġfeed back +Ġstret ch +Ġc ock +Ġhot el +ĠQue en +Ġsu gar +Ġj u +Ġmil k +Ġappro val +ĠL ive +Ġequival ent +ef ully +Ġins ert +z ona +Ġext ension +d ri +J ohn +Ġacc omp +S m +ĠF und +Ġconst antly +Ġ` ` +Ġgener ated +ĠA ction +ĠP sych +ĠT ri +Ġrecogn ize +Ġv ary +ph a +ĠR a +d f +et ch +ĠSov iet +Tw o +Ġpattern s +Ġprof ession +an ing +T ime +ĠL im +Ġcol ors +ĠA z +ĠT R +Ġinf ect +Ġphen omen +Ġshe ll +Al so +Ġput s +Ġdel ivery +Ġbro wn +Ġprocess ing +Ġlight s +ess age +ĠBro ok +ĠA ud +l ation +Ġindust rial +L ike +ĠB razil +rou s +ES S +ĠL uc +Ġsome how +Ġ8 5 +Ġpro port +Ġpolit icians +Ġindic ate +Ġh ole +Ġtechn iques +Ġcompet itive +Ġph r +Ġv o +ist ent +ĠD ream +Ġcamp us +Ġaspect s +Ġhelp ful +Ġsh ield +or se +Ġtrig ger +m al +Ġ5 8 +Ġt ort +Ġperson ally +Ġt ag +Ġkeep s +ĠV ideo +Ġben ch +Ġg ap +a ire +Ġe ast +Ġrec overy +per ial +Ġprof it +ĠM ic +Ġ5 7 +Ġcol on +Ġstrong ly +st yle +Ġalleg ations +h an +Ġrep orters +j o +r ine +arg et +and al +Ġ0 3 +Ġfl ash +tr ans +Ġstr ict +Ġpark ing +ĠPak istan +Ġl i +Ġwe ird +ĠE ric +Ġreg ions +ĠJ un +Ġint ellect +ĠW H +od ing +rib utes +up id +ĠT it +Ġf inger +or ia +Ġe lev +ĠF ield +Ġcon clusion +; ; +Ġfeel ings +Ġext ensive +Ġm ixed +Ġne uro +v y +Ġhar ass +ĠC irc +ou ch +Ġterrit ory +Ġsuccess fully +M ar +Ġing red +Ġoverw hel +Ġl ayer +V iew +Ġall ies +ill ance +ĠTh ree +Ġb unch +Ġnorm ally +Ġnet works +Ġsac r +ĠC IA +b les +Ġch ose +Ġopp onents +Ġregard less +Ġfr anch +Ġpre f +ĠP o +Ġbr idge +ann a +ĠSil ver +Ġw age +p age +ri or +Ġrad ical +ĠL ittle +Ġman ip +Ġsecret ary +Ġg ang +D R +F A +Ġdec ent +ĠSp irit +Ġun cle +ĠDevelop ment +Ġinvest ors +Ġwall s +Ġpub lish +Ġgener ate +iss ions +c ar +Ġprom ote +Ġcut ting +Ġche st +Ġdrink ing +Ġcollect ed +Ġ7 2 +Ġhop ing +Ġem br +gor ith +Ġwar ned +Ġinstruct ions +O G +ĠD id +ĠAg ency +Ġg ear +Ġcritic ism +ĠF urther +Ġut il +ann y +R ed +Ġcoun sel +ĠAs ian +Ġredu ction +p ool +Ġteach ing +Ġdeep ly +i y +Ġestim ates +Ġcho ices +Ġperman ent +in em +ke l +Ġf asc +p se +f ile +ĠL ow +ĠP erson +Ġt ournament +st al +Ġm el +U ST +ĠR ay +az i +V al +Ġcont ained +ĠH olly +Ġw ake +Ġreve al +Ġprocess es +ĠIS IS +Ġ0 9 +Ġbl ind +Ġste el +ĠB ad +Ġcare fully +app y +ro it +Ġg aming +Ġhous es +ĠC oll +Ġtr uck +er m +Ġsc ored +Ġocc as +ret urn +b ound +v ar +Ġsh arp +Ġaf raid +ĠE X +am ber +c ific +Ġsche me +N C +ĠPol it +Ġdecl ine +Ġ199 8 +Ġpus hing +Ġposs ession +Ġpriv ile +Ġteacher s +Ġy ield +H A +ĠDav is +it led +#### #### +Ġr ig +ĠD aniel +ac on +Ġh ide +ut en +Ġcolle agues +Ġprin ciples +Ġl oud +Ġs in +ĠDem on +Ġst one +Ġ0 2 +Ġt aught +Ġter rible +Ġst uck +ĠPol icy +te en +Ġimplement ation +ĠB BC +ĠAP I +Ġwhe el +all as +Ġch ampions +ol ars +play er +Ġrepeated ly +ĠSt ill +Ġlik es +ast y +es ter +ĠCath olic +R L +Ġb ath +Ġno ise +t itle +Ġn orthern +P art +Ġmag n +Ġf ab +ĠAs h +Ġdis pl +Ġtick et +Ġm urd +Ġalong side +ĠMus ic +Ġr iver +ĠSte el +ĠC L +ĠPl ayer +ĠM ult +ow ing +re p +s ize +Ġt ur +ĠGeorg ia +isc al +ra ction +Ġc able +Ġ5 9 +Ġw ins +Ġup coming +Ġsurv ive +Ġins pired +ĠEduc ation +Ġstat istics +ĠF oot +iam i +Ġy ellow +ĠP age +. - +ĠH as +Ġur ban +Ġa x +es sel +\ " +Ġquarter back +Ġreg ister +ĠLab or +Ġab ilities +ĠF amily +Ġvar iable +ĠPr ice +Ġcont em +Ġth in +ĠE qu +d ata +Ġg otten +Ġconst it +Ġas ks +Ġt ail +Ġexc iting +ĠE ffect +ĠSp anish +Ġencour age +ins on +ĠA h +Ġcommit ment +C S +Ġr ally +Ġ: : +Ġsubs id +Ġsp in +Ġcapt ured +201 8 +Ġinn oc +Ġalleged ly +ĠC ome +Ġart ists +ĠN umber +Ġelect ronic +Ġreg ional +ap es +Ġw ra +Ġmy th +pr ise +ĠM iller +ĠC reat +ĠEp isode +b ell +Ġdirect ed +Ġext ract +Ġs orry +Ġv ice +ag ger +ĠSu pport +Ġ6 6 +ĠI ron +Ġwonder ful +Ġg ra +N et +ion e +E ng +Ġsh ips +ik es +ĠK evin +it ar +Ġactiv ists +tr ue +ĠAri zona +ent h +ĠDes pite +ĠS E +Ġha bit +ern el +Ġin qu +Ġab ortion +Ġv oid +Ġexpl icit +Ġeng aged +Ġang ry +Ġr ating +Ġfr ag +b ro +ick ing +d ev +Ġwor ried +Ġob ser +Ġap artment +ĠG T +Ġest ate +ĠConst itution +em on +ĠS now +Ġcount y +Ġdis ag +ĠStep hen +Ġimm igrants +w ind +ĠN ations +Ġfol ks +O ut +Ġg all +Ġtarget ed +Ġst ead +ĠB on +ĠL ib +Ġinform ed +Ġ12 0 +ch ain +idel ines +or ough +Ġdri ven +Ġregular ly +Ġbas ket +Ġprinc iple +oc ument +Ġst un +ib ilities +ĠRom an +ĠAb out +Ġal ert +Ġdemocr acy +Ġrepresent ed +H S +c ers +p arent +Ar t +p ack +Ġdi plom +re ts +ĠN O +Ġcapt ure +ĠAd v +Ħ ¢ +Ġannounce ment +ĠL ear +Ġh ook +Ġpur s +ĠS uch +ĠC amer +Ġrefuge es +ĠV e +P ol +Ġrecogn ized +l ib +Ġhad n +A ss +Ġpil ot +us hing +Ġreturn ing +Ġtra il +ĠSt one +Ġrout ine +Ġcour ts +Ġdes per +Ġfriend ly +ĠIt aly +Ġpl ed +Ġbreat h +Ġstud io +N S +Ġimp ressive +ĠAfghan istan +Ġf ing +Ġd ownt +ink ing +ĠR og +i ary +col or +se x +ar on +Ġf ault +ĠN ick +D own +ĠR ose +ĠS outhern +X X +is odes +L ist +6 00 +Ġout come +er r +Ġelse where +Ġret ire +Ġp ounds +ĠGl obal +Pe ople +Ġcommun ications +Ġlo an +Ġrat io +ĠEm pire +Ġg onna +Ġinv ent +D F +Ġ19 70 +ĠComm on +p at +Ġprom ised +Ġd inner +ĠH om +Ġcreat es +Ġoper ate +ver ty +ĠJ ordan +et ime +Ġsust ain +R eg +Ġincred ible +im a +Ġwar rant +Ġm m +A tt +Ġlaw suit +Ġreview s +it ure +ĠS ource +l ights +ĠF ord +Ġ6 3 +g roup +st ore +Ġfeat ured +Ġfore ver +Ġpo verty +ĠP op +ĠC NN +az z +ab is +ach ing +Ġl aid +ĠSu pp +Ġfil ter +en a +ĠCommun ity +Ġcreat ures +u ction +ĠR oyal +Ġassoci ation +ĠCon nect +ĠBr ad +âĸ Ī +l ers +the re +ĠG i +Ġval uable +AC K +ĠT aylor +Ġl iquid +ĠAtt orney +ĠCar l +ĠF inal +ag a +ĠWil son +B ecause +ĠProf essor +ak a +Ġincred ibly +r ance +! ) +R ef +s k +Ġsol utions +Ġatmosp here +Ġbl ame +um es +ĠN ob +C A +um ps +r ical +ĠPut in +ĠD est +or ic +ĠP A +Ġrespect ively +w an +Ġfif th +â Ħ¢ +ĠC ry +Ġgovern or +res ident +Ġpurch ased +Ġh ack +Ġint ense +ob s +Ġorig in +Ġdef ine +Ġcare ful +** * +Ġshould er +Cl ick +Ġt ied +Ġdest ruction +ou red +Ġno body +Ġh o +ĠEx per +Ġt ip +" ; +Ġtechn ique +Ġj ur +ĠP ok +b ow +Ġleg end +Ġacc ord +Ġbus y +ĠInt el +Ġh ang +ak i +. ] +âĢĶâĢĶ âĢĶâĢĶ +Ġsur gery +Ġrep rodu +Ġun iform +Ġscen es +c ode +Ġ6 2 +l isher +ĠH ave +ph ia +Ġcry pt +Ġrec on +Ġsc ream +Ġadop ted +Ġsc ores +N e +ĠIt alian +in cluding +B O +Ġindic ated +Ġent ertain +G u +T ext +i el +Ġtw enty +Ġeng age +off s +ĠPac ific +Ġsm ile +Ġperson nel +Ġto ler +Ġdo ors +Ġt one +Ġmach ines +Ġent ering +ten ance +C O +ĠJer sey +Ġfore st +Ġhor se +Ġcompl aint +ĠSpr ing +y o +ĠPl us +ed ing +ĠRet urn +qu arters +ial s +c ow +Ġacad emic +Ġf ruit +Ġ199 6 +og ether +Ġw ine +Ġpur su +ĠSte ven +Ġlic ens +Wh o +Ġclot hes +re ction +Ġsqu ad +Ġst able +Ġr aw +z ens +St ar +ut ies +anc er +Ġke ys +ĠM u +Ġcompl icated +ig er +ĠTe xt +Ġabs or +Ġ6 8 +Ġfun ny +Ġrel ief +ĠL ew +ĠC ook +Ġch art +Ġdraw ing +G E +Ġmod ule +ĠB ull +I LL +Ġs alt +0000 0000 +il le +Ġres ource +aw ay +adel phia +ĠB ru +Ġ6 7 +Ġsome body +Ġparticip ate +Ġro se +we red +Ġmus cle +Ġcons ent +Ġcontin uing +ĠGuard ian +ĠOr der +reg on +Ġre ar +Ġprov ision +Ġlik ed +ri ent +Ġb ra +Tr ans +Ġmeet ings +Ġto x +Ġcon vent +Ġaut o +Ġrec ording +ĠSo ft +00 1 +ĠR oll +Ġprogram ming +Ġp ic +Ġprov ed +Ġst ab +ĠA st +Ġca ption +ul ating +ĠAtt ack +Ġnew ly +Ġ199 7 +f r +Ġdis cipl +ĠGree k +Ġed ition +ĠDo es +ĠB ox +if le +ack et +Ġpass es +Ġgu est +Ġac celer +it als +U D +Ġaut hent +ĠR est +ov al +t a +u ine +Ġarm or +ĠT own +Ġcomp at +Ġinc hes +Des pite +Ġass ign +he rent +Ġprep are +ĠM eg +oc key +Ġdep ends +Ġtrack s +w atch +Ġl ists +ĠN orthern +Ġal ter +re c +ĠE astern +Ġcond em +Ġevery where +? ' +Ġaff ili +Ġf ought +": {" +Ġm ac +it arian +Ġsc ope +ĠA L +aw s +ar ms +Ġqu e +Ġenjoy ed +nes ota +Ġagg ressive +ĠSt ory +ĠI V +Ġrec ipe +Ġrare ly +ĠMed ical +val ue +ang el +ay ing +omet hing +Ġsub section +Ġs outhern +Ġfrequ ency +re te +roll ed +ult s +ĠN ic +Ġbeh alf +Ġsequ ence +ab et +Ġcontrovers ial +Ġcomp rom +Ġwork er +Ġmain ly +Ġal gorith +ĠM ajor +or ce +g ender +Ġorgan ized +Ġf ake +Ġconclud ed +ĠE D +ĠEx ec +r age +Ġch ances +ber ry +ĠTr ad +Ġconfig uration +Ġwithd raw +Ġf ro +ud es +ĠBro ther +ĠB rian +Ġtri es +Ġsam ples +Ġb id +ĠGold en +Ġphot ograph +if est +ĠD O +ĠPar liament +******** ******** +R em +Ġcont est +Ġsign ing +p x +ĠZ eal +âĶĢ âĶĢ +E ar +Ġex it +Be fore +ĠCor por +n ull +mon th +Ġrac ial +ott ed +ĠV eg +ĠRe uters +Ġsw ord +ps on +ĠRom ney +a ed +Ġt rib +Ġin ner +Ġprot ocol +ĠB i +ĠM iami +ever al +p ress +Ġsh ipping +ĠAm endment +ĠHow ard +con nect +ĠD isc +ĠJ ac +iam ond +ĠThere fore +s es +ĠPrin cess +ĠUS B +ĠAn th +Ġsurve illance +Ġap olog +Ġ6 1 +ow a +Ġf ulf +j s +Ġl uck +ust ed +Ġ § +n i +Ġant icip +em an +Ġwin ner +Ġsil ver +ll a +ic ity +Ġunus ual +Ġcr ack +Ġt ies +e z +Ġpract ical +Ġprov ince +ĠPl ace +Ġprior ity +IC E +Ġdescrib es +Ġbr anch +F orm +ask a +miss ions +b i +Ġp orn +ĠTur k +Ġent hus +Ġf ighters +Ġ0 8 +ĠDet roit +Ġfound ation +av id +A re +Ġjud gment +cl ing +Ġsol ve +ĠDes ign +W here +hes is +ĠT ro +a fter +Ġne utral +ĠPalestin ian +ĠHolly wood +Ġadv is +ĠN on +y es +ol is +Ġrep utation +Ġsm ell +Ġb read +ĠB ul +ĠBe ach +Ġclaim ing +Ġgen etic +Ġtechn ologies +Ġupgr ade +row s +Ġdevelop er +ĠJ osh +ĠDis ney +erv ed +ip al +Ġun ex +Ġbare ly +t hen +ĠP ub +Ġill ness +et ary +ĠB al +Ġp atch +Ġbut t +Ġst upid +ĠD og +ĠD allas +f ront +ie ce +Ġprot ests +Ġch at +oen ix +Ġw ing +Ġpar liament +Ġ7 7 +ose xual +Ġre nder +pt ions +ĠCo ast +os a +ĠG reg +h op +ĠMan agement +Ġbit coin +Ġrec over +Ġincor por +or ne +ĠUs ing +Ġpre ced +Ġthreat ened +Ġspirit ual +ĠE vent +ĠF red +Ġadvert ising +Ġimprove ments +ĠC ustom +Ġer rors +Ġsens itive +ĠN avy +Ġcre am +L ook +Ġex clusive +Ġcomp rehens +Ġde leg +Ġcon ce +Ġrem em +Ġstruct ures +Ġst ored +N D +Ġ1 000 +U P +ĠB udd +A F +w oman +ĠAcad emy +ð Ł +se a +Ġtem porary +Ab out +es ters +Ġtick ets +Ġposs ess +in ch +o z +Ġl a +Ġcontract s +Ġun p +Ġc ig +ĠK at +ult ural +as m +Ġmount ain +ĠCapt ain +St ep +m aking +ĠSp ain +Ġequ ally +Ġl ands +at ers +Ġreject ed +er a +im m +ri x +C D +Ġtrans action +g ener +less ly +Ġ| | +Ġc os +ĠHen ry +Ġprov isions +Ġg ained +Ġdirect ory +Ġra ising +ĠS ep +ol en +ond er +Ġcon sole +in st +Ġb om +Ġunc ertain +1 50 +ock ing +Ġmeas ured +Ġpl ain +Ġse ats +Ġd ict +S L +af e +Ġest imate +iz on +at hered +Ġcontribut ed +Ġep isodes +omm od +G r +AN T +Ġ6 9 +G ener +Ġ2 50 +vious ly +rog en +Ġterror ism +Ġmove ments +ent le +oun ce +ĠS oul +Ġpre v +ĠT able +act s +ri ors +t ab +Ġsuff er +Ġn erv +Ġmain stream +ĠW olf +Ġfranch ise +b at +Ġdem ands +Ġag enda +Ġdo zen +Ġclin ical +iz ard +ĠO p +t d +Ġvis ited +ĠPer haps +Ġact or +Ġde lic +Ġcont ribute +Ġin ject +ĠE s +ac co +Ġlist ening +Ġcon gress +epend ent +Ġprem ium +Ġ7 6 +ĠIr ish +Ġass igned +ĠPh ys +Ġworld wide +Ġnarr ative +ot ype +m ont +b ase +ĠB owl +ĠAdminist ration +Ġrel ation +ĠE V +C P +Ġco vers +Ġ7 8 +Ġcert ific +Ġgr ass +Ġ0 4 +pir acy +ir a +Ġengine ering +ĠM ars +Ġun employ +ĠFore ign +st ract +Ġv en +Ġst eal +Ġrepl ied +Ġult imate +Ġtit les +d ated +Ġj oy +a us +Ġhy per +ak u +Ġoffic ially +ĠPro duct +Ġdifficult y +per or +Ġresult ed +rib ed +l ink +wh o +~~ ~~ +ĠSpe ed +ĠV iet +W ind +ĠBar ack +Ġrestrict ions +ĠSh are +Ġ199 5 +ition ally +Ġbeaut y +op t +Ġm aps +ĠC R +ĠN ation +ĠCru z +W ill +Ġelectric ity +Ġor g +Ġb urd +Ġviol ation +Ġus age +Ġper mit +ĠCh ron +ĠF ant +Ġn aturally +Ġ0 7 +Ġth rown +ĠAw oken +Ġal ien +ĠHer o +ĠK ent +ĠR ick +ri ke +Ġp ace +}, {" +G L +Ġpo ison +ĠT ower +Ġform al +al ysis +Ġgen uine +Ġk il +a ver +Ġproced ure +ĠPro p +intend o +ĠM ain +as ant +Ġtr ained +G ame +ĠL oad +ĠM A +Ġcru cial +Ġle ts +ĠF R +Ġch ampion +1 01 +ĠCon ference +Ġwrit ers +Ġconnect ions +Ġo kay +ir ms +ĠR and +Ġenc ounter +ĠB uff +Ġachie ved +Ġche cks +isc ons +Ġassist ant +Ġwhen ever +ĠA ccess +ĠU r +b in +Ġcl ock +is p +op her +Ġb orrow +Ġm ad +Ġperson ality +on ly +IS T +ab ama +Ġg ains +Ġcommon ly +Ġter r +Ġhyp ot +Ġre ly +Ġt iss +iscons in +Ġrid ic +f unction +ĠO regon +Ġun com +r ating +el and +ĠN C +Ġm oon +ann on +Ġvulner able +ut ive +³³ ³³ +ĠRad io +Ġw estern +se ct +ĠT ony +Ġocc urs +ĠO s +ĠH on +Ã Ń +Ġv essel +ĠScot land +Ġdiscrim ination +Ġsubsequ ent +st ring +Ġfant asy +ĠSh adow +Ġtest im +W E +it i +r as +Ġbo at +Ġmar ks +Ġord inary +Ġre n +Ġrepresent ative +Ġpet ition +Ġ7 3 +Ġad venture +Ġign ore +ĠPhil adelphia +ĠS av +V P +Ġfact ory +Ġt asks +Ġdep ression +z ed +................ ................ +ĠSt orm +Ġc ogn +Ġelig ible +Ġredu cing +v ia +Ġ0 5 +Ġstri king +Ġdoll ar +h o +O V +Ġinstr ument +Ġphilosoph y +ĠMo ore +ĠA venue +Ġrul ed +ĠFr ont +IN E +ĠM ah +Ġscen ario +ĠNAS A +Ġen orm +Ġdeb ut +Ġte a +T oday +Ġabs ence +S im +Ġh am +le ep +Ġt ables +ĠHe art +M I +K e +re qu +V D +m ap +Ġchair man +Ġp ump +Ġrapid ly +v i +Ġsubstant ial +E P +d es +ch ant +ili pp +ĠS anta +ri ers +anche ster +L oad +ĠC ase +Ġsa ving +Ġ7 4 +ĠA FP +er ning +oun ced +ĠMin nesota +ĠW as +Ġrec ru +Ġassess ment +ĠB ron +U E +Ġdynam ic +Ġf urn +ul ator +Ġprop ag +h igh +Ġacc ommod +Ġst ack +ĠS us +w rit +Ġre ven +ĠGod d +ĠZeal and +ab s +Ġbr ut +Ġper pet +h ot +Ġhard ly +ĠB urn +ãĤ ¹ +Ġst y +Ġtrans actions +Ġg ate +Ġsc reens +Ġsub mitted +Ġ1 01 +Ġlangu ages +ugh t +em en +Ġfall s +Ġc oc +Ĥ ¬ +Ġstri kes +p a +Ġdel iber +ĠI M +Ġrel ax +ann els +ĠSen ator +Ġext rem +Ġ} , +ĠDe b +Ġbe ll +Ġdis order +c ut +Ġi OS +Ġl ocked +Ġem issions +Ġshort ly +" ] +ĠJud ge +ĠS ometimes +Ġr ival +Ġd ust +Ġreach ing +F ile +¯¯ ¯¯ +ino is +ĠJ ason +Ġs atell +are t +Ġst ations +Ġag ric +ĠTechn ology +com es +ĠUn fortunately +ĠChild ren +Ġappl ies +ast ed +Ġan ger +ail ability +ĠDam age +Ġcomp are +ĠStand ard +Ġaim ed +ĠB a +angu age +Ġreg ulation +Ġj ury +Ġair port +Ġse ctions +ĠPr ince +em ed +Ġmedic ine +Ġh itting +Ġsp ark +ol ves +Ġad s +St ate +Ġfood s +Ġrepl acement +Ġch icken +Ġlow est +Ġmind s +Ġinvol ves +u i +Ġarr ang +Ġproced ures +ĠWh ich +ivers ary +Ġb ills +Ġimprove ment +Ġin ev +Ġexpect ations +Ġintellect ual +Ġsp aces +Ġmechan ism +2 50 +bre ak +ĠZ e +ĠT enn +ĠB alt +Ġbar rel +Ġstat ic +man n +Pol ice +Ġt ips +Ġhand ling +c us +od ed +il ton +ir y +Ġjournal ists +our se +Ġcom ic +Ġnom ine +IT Y +Ġvers us +Ġlo op +Ġsur f +ĠInd ust +ĠHun ter +Ġbelief s +is an +Ġset up +Ġbre w +im age +Ġcomput ers +f ol +} ," +ĠMed al +Ġtax p +Ġdisplay ed +Ġg rav +Ġf iscal +M on +ĠMos cow +ĠK ong +ĠCent re +Ġcamer as +ĠMr s +ĠH ay +Ġa ver +ĠK elly +p y +Ġrequire ment +Ġent itled +omb ie +Ġsh adow +ag ic +ĠA k +Ġel ite +Ġdiv ided +Ġhead ing +Ġcop ies +Ġloss es +Ġv it +k ed +ĠB ry +Ġan s +ĠSte am +Ġrep orter +he im +ĠIt em +Ġsuper ior +d on +ere nt +à ¶ +Ġtherap y +Ġpe ak +ĠMod el +Ġl ying +Ġg am +z er +r itten +Ġrespons es +Ġconsider ation +ĠB ible +Ġl oyal +Ġinst ant +Ġp m +ĠFore st +à ¼ +Ġext end +Ġconv icted +Ġfound er +Ġconv in +ĠO ak +che ck +Ġsch olars +p ed +Ġover se +T op +c ount +ĠAr k + · +Ġ0 6 +ĠL A +m d +ĠLat in +im ental +ĠC PU +Ġsubst ance +Ġminor ity +Ġmanufact uring +E r +ocol ate +Ġatt ended +ĠMan ager +r ations +Ġappreci ate +om y +GB T +id ency +B L +Ġguarant ee +pos ition +Ġo cean +clud e +Ġhead ed +Ġt ape +Ġlo ose +Ġlog ic +Ġpro ven +Ġsp ir +Ġad mit +is a +Ġinvestig ate +Ġ199 4 +sy lv +ĠL ost +c est +Ġ7 1 +Ġrequest ed +Ġwind ows +ĠPok é +ĠWith out +M et +Ġbehavi our +Ġread er +Ġh ung +ĠKe ep +Ġro les +Ġimplement ed +Ġbl ank +Ġserv es +ĠJ ay +Ġc ited +ĠF riend +prof it +ap on +Ġrep air +it em +arr ass +Ġcrit ics +ad i +ĠF ather +Ġsh out +Ġf ool +Ġ8 8 +Ġprodu cing +Ġl ib +Ġround s +Ġcirc le +Ġpre par +Ġsub mit +Ġn ic +mor row +ãĥ « +U nder +Ġv ital +ater n +Ġpass word +Ġpublic ation +Ġprom inent +Ġspeak s +Ġb ars +Ġde eper +ĠM ill +port ed +Ġw id +Ġbut ter +Ġsm oking +Ġindic ates +K ey +rop ri +ĠF ile +all ing +ast ing +ĠR us +Ġad j +Ġ7 9 +av al +Ġpres um +bur gh +on ic +Ġf ur +Ġpoll s +ik a +Ġsecond ary +Ġmon ster +ig s +ĠCur rent +E vent +Ġowners hip +end ar +Ġarri ve +ĠT ax +Ġn ull +ĠPri v +Ġth ro +Ġk iss +c at +Ġup set +ang le +it ches +ect or +olog ists +ĠGal axy +Ġcor ruption +Ġh int +ent er +ĠH ospital +Ġgreat ly +Ġbeg un +es y +Ġso il +ĠAnt on +Ġmain tenance +ãĥ © +Ġdo zens +Ġhuman ity +ĠAl abama +Ġr om +w orth +ap ing +sylv ania +l ah +Ġg athered +G A +Ġattack ing +f ound +ĠSqu are +Ġar bit +ict ions +ĠW isconsin +Ġd ance +ĠS aint +arch y +Ġbase ball +Ġcontribut ions +Ġliter ature +Ġex ha +per ty +t est +Ġb ab +Ġcontain er +let ter +Ġfall en +Ġwebs ites +Ġbott le +ĠS ac +Ġbre ast +ĠP L +Ġveter an +Ġinterview s +ĠA le +Ġb anned +eng ers +ĠRev olution +in th +Ġconc erning +IV E +Ġexp enses +ĠMatt hew +ĠColumb ia +d s +ist ance +Ġent ity +.. ." +Ġrel iable +Ġpar alle +ĠChrist ians +Ġopin ions +Ġin du +l ow +Ġcompet e +Ġth orough +Ġemploy ed +Ġestablish ment +ig en +ĠC ro +Ġlawy ers +ĠSt ation +T E +ĠL ind +ĠP ur +it ary +Ġeffic iency +âĢ IJ +ĠL y +Ġm ask +Ġdis aster +Ġag es +ER E +es is +ĠH old +Ġcas ual +b led +Ġen abled +ĠEn vironment +ĠInt elligence +i per +ĠM ap +ĠB E +Ġemer ged +is dom +Ġc abin +Ġregist ration +Ġfing ers +Ġro ster +Ġfram ework +ĠDo ctor +et ts +Ġtransport ation +Ġaware ness +H er +Ġattempt ing +O ff +ĠSt ore +ÃĥÃĤÃĥÃĤ ÃĥÃĤÃĥÃĤ +ĠK now +Ġdef ence +Ġsc an +ĠT en +ĠCh air +ĠP H +ĠAtl anta +Ġfuck ing +Ġans wered +b n +ĠK ar +Ġcateg ories +Ġr ational +Ġc ust +Ġrob ot +Ġcorrect ly +Ġg if +Ġgraph ics +m ic +Ġground s +ĠO pp +i ate +Ġdist ributed +Ġsan ctions +Ġchalleng ing +ut o +Ġingred ients +Ġinv ited +Ġfound ed +ĠRe qu +d ed +Ġb owl +Ġbrother s +ĠH a +I O +Ġw ages +im ore +oc ial +Ġse ed +ative ly +Ġaddress es +ĠI owa +ab eth +Ġatt itude +is d +ch ild +Ġm ole +Ġdisco very +y ard +B r +Ġ8 2 +Ġsuppl ies +ell ing +Ġdist ingu +C R +Ġre cept +Ġ vert +Ġsw im +b ec +d oor +ĠY eah +Ġg al +Ġinter act +ĠE SP +ĠC S +amp s +Ġconvin ced +Ġobject ive +Ġdis h +ĠPhot os +l ad +Ġdownt own +o il +in ction +Ġto morrow +ĠC OM +Ġsurv ival +sh ot +Ġsett lement +C ons +ĠX box +int erest +ĠS M +arg o +en ess +Ġeth nic +b ered +M in +ĠT ok +Ġinc ent +ĠComm and +Ġmain tained +Ġbreak s +br idge +at ar +ag g +ĠF inally +un icip +ĠO nt +le ft +Ġrecogn ition +Ġ* / +ĠP ers +Ġwe lf +Ġaddress ed +ĠK ansas +Ġvir us +Ġwhere as +Ġp apers +ram s +ĠMin istry +Ġple asure +Ġacqu ired +Ġd uration +j pg +Ġcal m +ĠN HL +Ġburn ing +Ġfold er +ick ed +ĠP y +ĠIll inois +Cl ass +ĠGodd ess +Ġperform ing +Ġwelf are +j ar +In ter +Ġl in +Ġenh ance +Ġnot ion +f are +yp es +ĠAre a +Ġcann abis +ĠDie go +f s +ĠM anchester +com m +in ite +Ġcover ing +ĠS ound +Ġ19 60 +Ġ8 4 +e lect +z ing +Ġcitiz en +Ġph ones +Ġr aid +Ġign ored +ĠOb ject +Ġu pload +c ard +Ġmod ified +Ġroom s +ia h +r ange +he ast +ach us +Ġsuggest ing +âĢ ĭ +gr ade +E l +Ġclot hing +Ġr h +ĠH an +un ity +en cing +ĠAust in +sec ution +t ra +d em +ĠQ ual +Ġhe aven +Ġst ages +Ġw edd +pl us +ific ial +ĠIm m +ĠH o +iet ies +Ġphr ase +Ġbr ill +act ory +Ġprov iders +Ġsil ence +Ġa er +ĠA I +ĠAd venture +Ġplatform s +Ġdemonstr ated +Ġinter f +ing ton +Ġr aces +Ġgr ade +ult ane +ĠTh rough +f alse +Ġb ow +ĠA B +Ġfl avor +Ġhistor ic +g ov +Ġcol our +Ġview ed +ĠEm ail +el come +Ġinter vention +Ġd iversity +Ġperiod s +Ġre verse +ĠV ery +Ġqu ote +ĠLe ft +th rough +Ġsc rew +Ġland ing +Ġp ill +Ġw et +Ġprot esters +Ġrepe at +av ed +er k +Ġsal ary +ĠPenn sylvania +St ill +Ġmay or +Ġkit chen +Ġfeat uring +ĠM useum +ĠT ournament +ĠF al +Ġser vers +U C +Ġany body +im g +ĠTr ade +ixt ure +the less +Ġfin ance +Ġcl osing +ĠPat ri +i ac +ab el +Ġ> > +or ous +Ġf irms +sc reen +un a +Ġemb arrass +ul se +Ġlet ting +Ġth rew +ile y +Ġch annels +l an +ĠVeg as +Ġse ar +Ġfant astic +ar re +uzz le +ĠD er +Th ose +Ġsw ing +Ġshe et +ind ex +co ver +og an +Ġvari ables +ĠTe ch +Ġsp oken +ac hel +ĠD a +ĠMount ain +Ġload ed +Ġfoot age +vers ion +Ġun l +ĠPh oenix +Ġthrow ing +Ġf iring +Ġtrack ing +Ġw idth +Ġstrugg ling +ro oms +ot ion +Ġmonth ly +ĠSer ver +Ġegg s +op en +M C +Ġ199 3 +Ġh ired +Ġstay ed +ĠAll en +Ġst ro +Ġ9 8 +st ep +ĠTurk ish +Ġfab ric +ist ing +ĠD om +Ġd ates +Ġpr on +Ġbasket ball +Ġl ucky +ĠArab ia +Ġassum ed +est y +Ġaff airs +Ġgl ad +ĠInd eed +ĠF A +ĠW ord +Ġjo ining +if ice +p read +ir ts +ĠSe lect +Ġpop ulations +aw are +Ġn ose +Ġcompl aints +st art +Ġsc oring +Th anks +Ġmin ing +Ġvisit ors +S H +Ġdam aged +Ġcharacter istics +ĠP ent +D C +Ġ8 3 +ĠS ix +r ates +Ġfl ags +ĠB rew +d og +M ark +// // +Ġexec ution +Ġj oke +ph ones +Ġtestim ony +Ġob st +Q L +ĠC ut +Ġstud ied +ĠN intendo +ick et +ĠN BC +Ġl ad +ĠB ra +ĠM oh +Ġk ernel +Ġoverwhel ming +Ġag ed +Ġapplic able +ĠC ond +Ġroad s +ĠBl ock +m ade +od ge +Ġcomm ands +Ġoff ices +vel and +Ġt ut +Ġrece iver +ĠF ro +Ġsho pping +Ġi P +ĠSt re +ĠA BC +Ġentertain ment +ĠB ow +ort ed +M c +Ġread s +gr ad +ĠCol lect +Ġâ ĪĴ +ĠCap ital +eder ation +Ġemploy er +Ġinvolve ment +Ġanx iety +al ia +Ġro of +ĠAm ong +ĠDemocr at +Ġstat s +ĠV ill +Ġconst itutional +Ġrefer ring +itt y +Ġtack le +out ube +Ġback ed +ĠH ong +ĠBro ad +Ġe le +ĠO tt +Ġ199 2 +h our +achus etts +C al +Ġdefe ated +Ġ8 1 +es p +Ġseem ingly +w as +ĠJ enn +ĠK urd +Ġg ene +Ġdisc ount +R et +EC T +( ); +Ġclub s +Ġs id +ĠM arsh +Che ck +Ġp p +ĠE ag +ides pread +Ġbe ings +F T +Ġintrodu ction +ĠCh ange +AR D +Ġ1 10 +ad ows +ier ce +Ġme al +a uthor +ĠB ang +lah oma +Ġr anks +201 1 +?? ?? +m ax +Ġcoll apse +Ġop ens +Ġe cho +Ġs oph +Ġrac ist +Ġenorm ous +Ġw aves +Ġt ap +Ġcomprehens ive +. -- +ĠR oy +Ġfarm ers +Rel ated +a ired +ron es +ĠC rim +Ġproport ion +Ġdesign s +Ġnegoti ations +Ġvirt ually +ĠBat man +Ġwar n +Ġlegit imate +m ate +Ġcon vention +, , +net ic +ĠS D +Ġconsist ently +Ġcompens ation +Ġpunish ment +Ġy e +Ġt ie +ĠB ureau +ir lf +ĠB u +ĠA ren +ĠPh ilipp +Ġkn ife +Ġmem ories +ĠR oss +Ġang le +Ġ8 6 +ĠTh under +Ġre nd +ĠT our +Ġcount s +s ung +ĠIm p +Ġeduc ational +Ġaccess ible +C OM +Ġd rew +y er +G l +am ine +OR T +O B +I B +m aster +Ġtri als +og y +h ar +ĠTr ust +Ġprefer red +irlf riend +ĠN ev +Ġb in +Ġc ow +P age +Ġsign ature +ĠB L +7 00 +Ġret ired +Ġby tes +Ġneigh b +ĠLeg end +Ġdev ast +Ġsuspect ed +is ons +ĠPoké mon +sc ale +Ġcap abilities +Ġre vel +Ġche ese +d y +igr ant +Ġfail ing +b its +ĠHer oes +ĠG host +ĠS cient +Ġappoint ed +ur i +Ġinst itution +Ġexpand ed +g reg +Ġmonitor ing +Ġp odcast +Ġcoal ition +Ġ9 6 +J o +Ġst olen +ĠS ab +Ġstop s +Ġhol iday +Ġint r +C ar +Bl ack +ĠL GBT +Ġwar ming +ĠAnd erson +Ġ8 9 +Ġprodu cer +M ed +Ġaccur acy +ĠMar vel +iz abeth +ĠPat rick +m ony +Ġmin i +ac les +Ġover t +the y +Ġmembers hip +ĠV en +Ġex ch +Ġrem oval +ĠD ave +T Y +m ad +ĠF ind +Ġad equ +Ġe c +Ġte eth +Ġemot ion +Ġper m +Ġsole ly +d b +Ġextra ord +IG HT +c al +Ġgu idelines +Ġd ying +Ġsusp ended +ĠPrem ier +ĠAnth ony +el ve +Ġd ad +ĠE th +ĠFoot ball +Ġabandon ed +Ġ< < +Ġm arch +Ġhor ror +âĢ¦ " +Ġchild hood +Ġcampaign s +Ġl unch +ĠAl bert +bl ock +âĸĪ âĸĪ +ound ing +Ġb one +or gan +ad ers +ĠFl ash +ĠDri ve +Ġton ight +Ġw ars +ĠF L +Ġform ation +con st +New s +Ġcom pe +or ious +ĠSt aff +Ġdiscuss ions +ĠProt ection +ĠJ am +Ġcrit eria +Ġinstall ation +Ġaccompl ish +iz za +Ġpub lisher +Ġresc ue +ĠT ry +U LL +ĠS om +ĠH op +ore t +th s +ord on +Ġp ocket +ĠIn v +Down load +ĠCr ime +Ġb ene +ĠGu ide +ĠAs sembly +Ġparam eters +I E +ĠAlex ander +Ġconc ert +ĠSc he +Ġsh oes +Ġvis iting +Ġrec all +Ġb ub +Ġr ural +Ġconc rete +ĠR os +N ext +R uss +Ġlo ans +ĠSh ield +Ġtre m +hem at +k g +ĠHar ris +is ition +ĠM ove +ĠF C +Ġf ate +ĠCh o +Ġt ired +Ġprinc ipal +h ist +ien ces +ath y +Ġse vent +Ġm ood +Ġstrateg ic +Ġdise ases +Ġfor um +Ġtem por +Ġhead quarters +P ar +ig e +fl ix +Ġgu itar +Ġ9 4 +On ly +Ġrele ases +ro ph +================ ================ +Ġ6 00 +ĠContin ue +ig ate +ĠC rit +sy stem +Ġdis abled +Ġunex pected +ith ub +Ġuncle ar +ĠE st +Ġcontr ad +Ġstrateg ies +vent ures +Ġpass age +AM E +Ġimpro ving +Ġreve als +Ġdecre ase +ov a +Ġann oy +ĠSh ort +ĠL ibrary +Ġcy ber +n ell +ĠH ur +ĠC B +Ġphot ograp +U I +Ġs ed +G e +Ġ8 7 +Ġd iverse +Ġencour aged +Ġcons piracy +Ġbird s +Ġoper ator +Ġhand ful +Ġclass ified +? ) +Ġdram atic +Ġinvestig ators +it o +Ġw idespread +ĠR oom +-------------------------------- -------------------------------- +Ġcollect ive +Ġjournal ist +St ring +Ġtemper atures +il a +Ġgu id +Ġins pect +Ġmiss ile +ĠMay or +Ġman ual +Ġsim ultane +Ġrat ings +Ġsu ck +Ġ9 7 +Ġunivers al +Ġph arm +Ġdis rupt +ian o +A V +Ġf t +Ġstat ist +old s +ĠWalk er +ph p +Ġunder t +ĠL as +ish op +nt il +res hold +ĠWhe ther +M s +Ġden y +ĠCl oud +Ġprov ider +Ġsurv iv +ĠUp date +h as +Ġmist akes +ch arge +pl ed +r ity +Ġn ode +ĠMass achusetts +ool s +lic ation +Ġf ails +em ale +or i +back s +Ġsh irt +Ġ' ' +ĠN AT +Ġwat ers +els on +Ġe ase +Ġsc ar +Ġcont ents +m ind +Ġcont ribution +Ġsh r +Ġhand ed +Ġst ability +Ġtra ve +E m +Ġmir ror +12 3 +Ġwe igh +Ġf iction +ou ver +ist ant +r ition +ĠF ed +Ġphys ically +Ġst ake +ĠArt icle +ĠAr c +ĠLew is +ĠM ind +Ġdemonstr ate +Ġprof its +v ision +om ic +ol id +Ġbatt les +Ġdri ves +Ġeas tern +ĠS ony +!! ! +ar ation +v ard +ĠG L +port ation +Ġ9 2 +Ġlaw makers +Ġprotect ing +ĠE PA +Ġy eah +Ġsh ame +ol ph +e ven +x it +Ġatt ach +Ġrepresent ing +Ġob s +ĠUt ah +iff s +ĠFre edom +à ³ +A K +Ġinc idents +it age +Ġview ers +c d +Ġm ouse +Ġcl ar +Ġaccord ance +Ġb ot +c or +ĠSum mer +he ld +Ġinnoc ent +Ġiniti ative +ol s +________________ ________________ +Ġsp ots +p ace +Ġconvent ional +Ġcorpor ations +Ġblock ed +H D +at tered +Ġref ers +Ġbu ck +ĠDig ital +12 0 +Ġtop ics +T F +Ä ģ +br id +re ement +Ġunder lying +ĠM ember +Ġinvestig ating +Ġpregn ancy +Ġtouch down +ĠB and +ĠCall er +Ġinst ances +P P +w a +G ood +Ġ199 1 +ĠC old +Ġfear s +Ġrem arks +Ĩ Ĵ +at al +Ġm it +Ġexper iments +i pt +Col or +ind u +Up date +Ġ9 3 +A g +Ġ å +anc ouver +B oth +Ġjud ges +Ob ject +Ġst ere +umb n +Ġparticip ation +ĠSt ars +ĠJ ere +Ġweek ly +ĠB an +Ġconvers ations +ĠP itt +u z +ĠIndian a +ĠK ick +Ġinf ection +Ġhero es +Ġsett led +Ġstri p +Ġh al +Ġd ump +ĠS ci +Ġl es +Ġref erences +ĠU RL +ĠBr idge +Ġwant ing +For ce +Ġex clus +Me anwhile +m n +Ġg entle +m aker +sen al +ĠG ro +ou ri +ĠR ain +ĠAll iance +Ġl ift +el a +S D +ĠCle veland +Ġrank ed +Ġst adium +Ġdead ly +ä ¸ +Ġr iding +ar ia +ĠAr mor +Ġdocument ation +ĠGree ce +ree k +Ġl ens +ĠS a +Ġg ross +ĠE mer +ag ers +ĠD ub +ĠR h +ĠAM D +Ġarri val +Ġdes ert +Ġsupp lement +ĠRes p +Ġkn ee +Ġmarg in +f ont +og g +201 0 +ĠP ir +ĠP rom +iv als +Ġint ake +Ġdifferent ly +ug s +Ġb its +clud ed +Ġsearch ing +ĠD u +um ble +Ġfunction al +ĠBalt imore +ĠC ould +Ġdes ired +Ġcirc uit +ĠL yn +ĠG O +ĠF alse +re pre +' : +alt ies +Ġmin im +Ġdro ve +ĠSh ould +Ġh ip +Ġpro s +Ġut ility +ĠN ature +ĠM ode +P resident +o pp +r at +form ance +Ġconcent ration +Ġf ont +ĠB ud +Ġam id +Ġre vers +ĠM L +B ar +Ġinter action +Ġjur isd +Ġspell s +d ep +f il +Ġcivil ians +ut ter +ĠCo oper +ĠBel ow +Ġent rance +Ġcon vert +Ġcontrovers y +ow ered +Ġcontr ary +Ġar c +ĠExec utive +ĠOffic er +Ġpack ages +Ġprog ressive +w idth +Ġreserv ed +v ol +ĠSam sung +Ġprint ed +Ġcent ers +Ġintrodu ce +ĠKenn edy +Ġodd s +Ġsure ly +Ġindepend ence +Ġpass engers +repre ne +ĠBe h +Ġl oves +ĠESP N +Ġfac ilit +Ġident ical +Ġdo ct +Ġpartners hip +con f +ĠH ide +Ġconf used +ĠC ow +M en +Ġw rest +ĠIraq i +Ġh oles +ĠStud ies +Ġpregn ant +h ard +Ġsign als +I X +Ġpull ing +Ġgrad uate +Ġnomine e +D ate +Ġper mitted +Ġâ Ĥ¬ +ĠOk lahoma +St art +Ġauthor ized +Ġal arm +ĠC os +v an +Ġgener ations +c ular +Ġdr agon +ĠSoft ware +ĠEd ward +Ġcontro ller +S en +ge red +ĠV ik +Ġappro ached +Th ank +Ġcan ce +Ġform ula +ĠSm all +Ġweak ness +Ġr amp +it udes +j ud +Ġbrill iant +Ġacc us +s ource +Ġ8 00 +ĠE vil +S w +Ġhom eless +we ek +i ens +r ics +ĠTh ird +T O +Ġorgan ic +Ġpresent ation +ag h +ĠDown load +v ation +Ġas sembly +or able +hold ers +ĠBern ie +ĠHel p +Ġt ong +ĠF ight +Ġbe ach +B ook +ĠL ic +Ġr ush +ĠR ound +ou p +ĠMar x +Ġcalcul ated +ĠDe vil +ĠSar ah +Ġoccasion ally +Ġbul let +Av ailable +g ate +Ġ9 1 +Ġh osp +Ġprom ises +ĠH IV +ĠSt adium +ĠSt ock +ĠCorpor ation +g age +N G +ĠC redit +Ġs ne +ib l +Ġacc um +s uch +Ġterror ists +Ġconscious ness +ĠZ h +Ġdram a +ool a +pir ation +Ġlab our +ĠN in +Ġut ter +Ġdemocr atic +Ġass ass +il ation +Ġg est +Ġab road +Ġmet ab +Ġs orts +Ġfl av +U B +Ġm g +ĠNot hing +ĠO d +Ġmus ical +200 9 +Ġdro ps +oc ated +ater al +0000 00 +Ġg re +Ġequ ality +Ġburd en +Ġv ig +ĠLe ader +-------- ---- +Ġcere mony +Ġf ighter +Ġact ors +Ġ æ +am an +F i +Ġal ign +put er +Ġe lder +ĠN SA +Ġrepresent ation +ĠOnt ario +IT H +usal em +Ġharass ment +itz er +Ġsy mp +Ġbox es +ĠD R +Ġman ifest +at re +Ġ ^ +Ġd ies +le ton +Ġmiss ions +et he +Ġres olve +Ġfollow ers +Ġas c +Ġk m +l ord +am med +Ġsil ent +ĠAssoci ated +Ġtim ing +Ġprison ers +ĠK ings +ĠF ive +Ġtow er +Ġappro aches +Ġprecise ly +Ġb ureau +ĠM other +ĠI ss +Ġkey board +it ual +Ġfund ed +Ġstay ing +Ġpsych ological +Ġm ile +ĠLe on +ĠBar b +w ill +Ġw ider +ĠAtl antic +Ġt ill +ĠR ome +ro t +Ġaccomp an +Ġfl our +ac o +W orld +ĠExp ress +ĠY u +C or +Ġple ased +part y +Ġpoint ing +Ġinf lation +Ġro y +Ġ ), +ain er +Ġwedd ing +orm on +Ġrequ iring +Ġqual ified +Ġse gment +EN D +Ġs izes +e als +Ġcor rupt +ass ador +Ġcele b +Ġdream s +ĠM ess +Ġcheck ing +ĠV ersion +Ġprep aring +Ġact ively +ĠD iff +Ġl ux +ĠW inter +act eria +ĠN E +Ġdep uty +Ġtrans gender +Ġsum mary +Ġin her +er ies +ch ar +ĠY an +Ġkn ock +ĠP ath +Ġl ip +roll er +Ġimp ression +Ġcelebr ate +Ġsl ide +Ġgu ests +Ġcl ip +F S +Ġsav ings +Ġcapt ain +Ġleg acy +ĠDen ver +Ġw ounded +tab oola +AC T +Ġpurs ue +Ġo xy +Ġ q +Ġsem i +ĠN eed +ĠAff airs +Ġob sc +Ġcheck ed +Ġd ual +C ode +ĠM D +le m +ult y +Ġ © +ĠEl izabeth +Ġcent uries +ard ed +s rc +Ġev ident +enn is +at in +Ġunemploy ment +ĠMar io +Ġint im +Ch rist +Ġbi ological +Ġsold ier +ĠAdd ed +Ġm ath +ĠG il +Ġbi as +Ġd ating +ĠO cean +Ġm ice +M us +h ire +ĠT es +Ser ver +lim ited +S ize +Ġmet ers +Ġrock et +es see +Ġcertific ate +ĠIran ian +AS S +Ġgr id +D ec +Ġro lling +com mun +ĠSwed en +b ury +Ġtiss ue +Ġrac ism +ĠL ocal +Ġmyster y +Ġexam ine +Ġst em +Ġs its +Ġhop ed +ot ing +Ġdial ogue +Ġpers u +W atch +l ay +M AN +Ġch ronic +ĠPort land +mark et +ĠS EC +Ġparalle l +Ġsc andal +Ġcar ries +Ġphenomen on +h uman +ack er +ĠO x +Ġretire ment +tain ment +ov ie +ĠG ear +Ġd uties +Ġdo se +Ġsc roll +M B +in f +Ġsa uce +Ġland scape +red dit +ĠChampions hip +ĠRed dit +al id +Ġco in +Ġover s +Ġpost ing +ab out +Ġf el +and y +Ġb old +Ġfocus ing +e ffect +G R +Ġde emed +Ġrecommend ations +Ġste pped +Ġvot er +ĠDe ep +ĠInst agram +Ġmoder ate +ĠMary land +Ġrestrict ed +ĠM B +ĠCh all +Ġto b +Ġc ir +ĠO cc +ĠE ver +Ġcoll aps +IN FO += - +ĠP ict +ĠAcc ount +n c +Ġo ught +Ġex port +Ġdr unk +( ' +Ġw ise +ĠM ort +ne cess +Ġan cest +ĠInc re +Ġfrequ ent +m ir +Ġinterpret ation +Ġdepend ent +Ġco ins +ĠB ol +V ideo +ĠJust in +Ġfat al +Ġcook ing +Ġconf usion +ip her +Ġcust ody +ĠMor gan +om ach +ĠGovern or +Ġrestaur ants +el ing +Ġacknowled ged +Ġthe r +Ġgen es +ch ing +He y +Ġtact ics +ĠMex ican +Ġv end +Ġhe s +qu er +Ġnot ing +ĠCamer on +Ġtarget ing +ro ck +Ġcred its +Ġemot ions +Ġrepresent atives +new s +Ġlegisl ative +Ġrem oving +Ġtweet ed +ĠCar ter +ĠF ixed +Ġfor cing +Ġspeak er +Ġm ales +ĠViet nam +l ined +Ġconcept s +Ġvo ices +o ir +ĠT rib +W he +ĠJer usalem +ĠS ant +Ġc ul +Ġl ady +ĠHaw ai +Ġar ts +ĠIn n +ĠMach ine +ĠEm peror +Ġsl ot +g ly +ĠPro cess +II I +Ġathlet es +ĠTem ple +ĠRep resent +Ġpres c +Ġt ons +Ġgold en +Ġp unch +ĠG R +iver pool +Ġen act +Ġlob by +Ġm os +Ġpick ing +Ġlif etime +Ġcogn itive +E ach +z o +Ġd ub +Ġcons ists +ol n +Ġf estival +am ous +Ġint ellig +w ords +ĠSm art +Ġde le +Ġl apt +Ġmag ical +ĠS in +b us +ur ities +igh th +ĠRub y +ĠS ure +ol ving +Ġj un +O ST +Ġimp osed +Ġast ron +Ġcor rel +ĠN S +ĠK it +ĠF uture +b urn +Ġimm une +oc us +Ġcour ses +ĠSt ring +Ġle an +Ġg host +Ġout comes +Ġexp ense +Ġevery day +Ġaccept able +A h +Ġequ ipped +Ġor ange +F R +ĠD utch +Th ough +ĠR ank +Q U +ĠRober ts +wh at +re nd +Ġdisapp ear +Ġsp awn +ĠL am +o is +Ġdes erve +Ġmin imal +Ġnerv ous +ĠW ould +Ġro ok +ĠV ancouver +Ġres ign +sh ire +ĠW orks +ĠB uild +Ġafford able +ĠG ary +ĠAren a +Ġh anging +Ġimpl ications +ĠS ong +Ġmain taining +Ġgu ards +C ON +Ġder ived +Ġexecut ed +Ġthe ories +Ġqu oted +ĠAnd re +og a +sel ess +in fo +ĠBel g +Ġt ears +ĠSur v +Ġbirth day +ig ious +im mer +Ġspect rum +Ġarchitect ure +Ġrec ruit +arm a +T able +Ġmon sters +ĠG ov +Ġdest ination +Ġattract ive +Ġf oss +ĠMore over +Ġpres ents +TH E +Ġrep ly +pt on +Ġc um +Ġdel ight +Ġaffect s +Ġdon ations +ĠT oy +ĠH im +M ENT +Ġover come +it ched +ĠFant asy +ĠH at +ĠBe ast +b ott +Ġinvestig ations +R un +Ġhun ting +d i +f und +Ġs essions +est yle +Ġport ray +oid s +Y eah +Ġcommun icate +Ġcom edy +ĠY ang +Ġbel t +ĠMar ine +Ġpredict ed +Pl ay +Ġimportant ly +Ġremark able +Ġelim inate +D avid +Ġb ind +V ID +Ġadvoc ates +ĠG aza +im p +D B +ĠN a +ĠSim ilar +I ES +Ġchar ity +v as +m ath +Ġâ ĸ +ok er +nd um +Ġcap s +ĠH al +2 000 +e an +Ġfle et +Ġrec re +R ight +Ġsleep ing +ij ing +k ind +Ġdesign ated +à ¤ +Ġanim ation +ke e +ĠInt rodu +Ġ/ > +Ġdelay ed +Ġtrem end +Ġcur ious +U se +Ġle ct +d am +Ġinnov ation +ĠPoint s +Ġload ing +Ġdisp ute +ct ic +ird s +ĠB Y +Ġn urs +ĠVal ue +ION S +ĠH um +Ġtem plate +m ers +Ġappear ances +ĠEnter tainment +Ġtransl ation +Ġsa ke +Ġbene ath +Ġin hib +Ġe uro +abet es +Ġstud ying +ĠM as +Ġper ceived +Ġexam ined +Ġe ager +Ġco aches +Ġim per +ch i +Ġprodu ces +" ). +ĠEvery one +Ġm unicip +Ġg irlfriend +Ġh ire +ĠV ice +Ġsu itable +op y +Ġin equ +ĠD uke +f ish +f irst +ĠO bs +Ġinter ior +ĠBru ce +ĠR y +Ġanal ys +Ġconsider able +Ġfore cast +Ġf ert +ors hip +ĠD rug +ĠA LL +: " +th ur +ĠM ail +Ġball ot +Ġinst antly +ĠCh annel +Ġp icks +Ġ198 9 +Ġt ent +ol i +Ġcivil ian +b ling +ell o +b u +Ġin ch +Ġlog o +Ġcooper ation +Ġwal ks +Ġinvest ments +Ġimp rison +ĠF estival +ĠK y +Ġleg ally +Ġg ri +ch arg +S l +Ġthreat ening +du ction +fl ow +Ġdismiss ed +ibr aries +c ap +e le +ĠMc G +ĠHar vard +ĠConserv ative +ĠC BS +p ng +Ġro ots +ĠH aving +umb led +ĠF un +\ / +ĠS earch +ple x +Ġdiscuss ing +Ġcontin u +ĠT ai +ĠW ik +F ree +f it +Ġref use +Ġmanag ing +Ġsy nd +ip edia +w alk +Ġprofession als +Ġguid ance +Ġunivers ities +Ġas semb +unt u +F inally +AS E +ĠAut o +ĠH ad +Ġann iversary +L D +ĠD ur +ĠUlt imate +ih ad +pro duct +Ġtrans it +Ġrest ore +Ġexpl aining +Ġass et +Ġtransfer red +Ġbur st +ap olis +ĠMag azine +ĠC ra +ĠB R +gg ed +ĠH E +M ich +b et +ĠL ady +yl um +erv es +Ġme ets +wh ite +L og +Ġcorrespond ing +Ġins isted +G G +Ġsurround ed +Ġt ens +Ġl ane +Ġco inc +h ome +Ġexist ed +ect ed +ĠDou ble +lam m +Ġske pt +ex p +Ġper ception +ie v +ĠBe ing +o ft +Ġadop t +. : +] ; +Wind ows +Ġsatell ite +AS H +Ġinf ant +d escription +ĠMe anwhile +c m +oc a +ĠT reat +act or +Ġtob acco +ĠN orm +em ption +Ġfl esh +Ġj e +o op +ĠHe aven +Ġbe ating +an im +Ġgather ing +Ġcult iv +G O +ab e +ĠJon athan +ĠSaf ety +Ġbad ly +pro t +Ġcho osing +Ġcontact ed +Ġqu it +Ġdist ur +Ġst ir +Ġto ken +D et +ĠP a +Ġfunction ality +00 3 +s ome +Ġlimit ations +Ġmet h +b uild +con fig +N T +re ll +ble m +ĠM om +Ġveter ans +ĠH u +Ġtrend s +are r +ĠG iven +ĠCa ption +m ay +AS T +Ġwond ering +ĠCl ark +n ormal +Ġsepar ated +Ġdes p +st ic +b rew +Ġrel ating +ĠN ik +ĠF arm +Ġenthus i +g ood +d eb +Ġactiv ist +Ġm art +Ġexplos ion +ĠEconom ic +L ink +Ġins ight +Ġconven ient +Ġcounter part +su pport +ĠV irt +ag en +ĠTenn essee +ĠSim on +ĠA ward +OC K +ĠF igure +Ġoverse as +Ġpr ide +ĠC as +n ote +m g +C urrent +Ġdispl ays +cont ent +Ġtravel ing +Ġhosp itals +ĠFin ancial +ĠP ast +Ġdefend ant +Ġstream ing +m ble +ĠBer lin +uk i +Ġdist ribut +Ġant ib +Ġch ocolate +ĠCast le +Ġinter rupt +ĠR ow +Ġconvers ion +Ġbug s +ĠR ather +li est +L Y +ĠJe an +com mon +ak h +Ġ1 30 +ot ton +ĠDe an +Ġam endment +Ġgame play +ĠWar ren +od a +Ġhigh lights +Ġir re +ĠNAT O +Ġball s +Ġdemand ing +U RE +ĠL uke +F igure +st op +on ia +z one +iz ers +ĠW R +Ġaward ed +Ġregul atory +ĠH art +ĠS N +pl ing +Ġs our +ĠP ixel +us ive +Ġf et +ĠS ent +Ġautom atic +Ġf er +vern ment +ĠKh an +T ON +f ather +Ġextraord inary +th rop +ĠP ython +ĠG PU +Ġsex ually +Ġdesk top +it ivity +ĠAnton io +Ġo rient +Ġe ars +ob by +ous es +vertis ements +Ġmanufacture rs +ic ient +min ute +Ġconv iction +Ġg arden +p ublic +Ġsatisf ied +f old +O K +Ġin hab +ĠTh ink +Ġprogram me +Ġst omach +Ġcoord in +Ġh oly +Ġth reshold +Ġr het +Ġser ial +Ġemploy ers +ĠEvery thing +ra h +Ġb other +Ġbr ands +Val ue +ĠT ed +ĠPlan et +Ġp ink +ĠFurther more +s a +P E +re ck +ĠUS D +ot te +Ġ& & +Ġland ed +g ets +Ġprodu cers +Ġhealth care +Ġdomin ant +Ġdest ro +Ġam ended +ch ron +Ġf its +ĠSy d +ĠAuthor ity +AT CH +Ġfight s +ĠL LC +Ġ-- - +ĠCor p +Ġtox ic +spe cific +ĠC orn +ĠChe l +Ġtele phone +ĠP ant +Ġmyster ious +aun ch +od ox +med ia +Ġwitness es +ag u +Ġquestion ed +ĠBre xit +ĠRem ember +ene z +Ġend orse +iat ric +ĠId ent +Ġridic ulous +1 10 +Ġpr ayer +Ġscient ist +Ġ19 50 +ĠA qu +Ġunder ground +ĠU FC +m are +ĠL ater +w ich +Ġsubsc rib +Ġhost s +Ġer r +Ġgr ants +ant om +Ġsum mon +ear ly +ĠC lear +ĠPr im +Ġsusp ension +Ġguarant eed +app er +Ġr ice +ĠSe an +ĠSh in +Ġrefere ndum +Ġfl ed +r ust +Ġ3 60 +ter y +Ġsh ocked +B R +ĠO il +ĠAll ah +Ġpart ly +Ġign or +Ġtrans mission +Ġhom osexual +ivers al +Ġhop efully +ãĤ ¤ +Ġless on +L eg +Ġ .. +Y et +t able +app ropri +re tt +Ġbo ards +Ġincor rect +Ġb acteria +ar u +am ac +Ġsn ap +.' " +Ġpar ad +t em +he art +Ġav ailability +Ġw isdom +Ġ( + +Ġpri est +ĠÂł ĠÂł +O pen +Ġsp an +Ġparam eter +Ġconv ince +Ġ( %) +r ac +Ġf o +Ġsafe ly +Ġconver ted +ĠOlymp ic +Ġres erve +Ġhe aling +ĠM ine +M ax +Ġin herent +ĠGra ham +Ġinteg rated +D em +Ġpip eline +Ġapp lying +Ġem bed +ĠCharl ie +Ġc ave +200 8 +Ġcons ensus +Ġre wards +P al +ĠHT ML +Ġpopular ity +look ing +ĠSw ord +ĠAr ts +' ) +Ġelect ron +clus ions +Ġinteg rity +Ġexclus ively +Ġgr ace +Ġtort ure +Ġburn ed +tw o +Ġ18 0 +P rodu +Ġent reprene +raph ics +Ġg ym +ric ane +ĠT am +Ġadministr ative +Ġmanufacture r +Ġ vel +ĠN i +Ġisol ated +ĠMedic ine +Ġback up +Ġpromot ing +Ġcommand er +Ġfle e +ĠRus sell +Ġforg otten +ĠMiss ouri +Ġres idence +m ons +Ġrese mb +Ġw and +Ġmeaning ful +P T +Ġb ol +Ġhe lic +Ġwealth y +Ġr ifle +str ong +row ing +pl an +as ury +âĢ¦ . +Ġexpand ing +ĠHam ilton +Ġrece ives +S I +eat ures +ĠAn im +RE E +P ut +Ġbrief ly +ri ve +Ġstim ul +Ġ`` ( +Ġ __ +Ġch ip +Ġha z +Ġpri ze +ĠTh ings +AC E +ul in +d ict +ok u +Ġassoci ate +ock ets +y outube +St ory +ateg ory +Ġm ild +ail ing +ĠY e +O rig +ĠK a +or ig +Ġpropag anda +Ġan onymous +Ġstrugg led +Ġout rage +AT ED +ĠBe ijing +r ary +Ġle ather +Ġworld s +Ġbroad er +12 5 +id al +ĠBet ter +Ġt ear +E xt +Ġpropos als +Ġit er +ĠSqu ad +Ġvol unt +m i +D id +ĠP u +p in +Ġspeak ers +Ġb orders +Ġfig ured += ' +Ġsimultane ously +aed a +Ġcharg ing +Ġur ged +Ġcon j +25 6 +ĠG ordon +mer ce +Ġdocument ary +Sh are +it ol +ON E +ĠG arden +h att +ĠThom pson +ane ous +ap ore +Ġt anks +Ġless ons +tr ack +Ġout standing +Ġvolunte ers +Ġsp ray +Ġmanag ers +l arge +Ġcamp s +Ġart ificial +ĠR u +Ġb ags +th al +Ġcompat ible +ĠBl ade +Ġf ed +Ġarg ues +F I +Ġunf air +Ġcor n +Ġoff set +Ġdirect ions +Ġdisappoint ed +ĠCon vention +Ġview ing +M E +oc ity +Ġtown s +Ġlay ers +Ġro lled +Ġjump ed +Ġatt ribute +Ġun necess +inc oln +Ġsupp ose +ĠNet her +ch a +Ġbur ied +Ġsix th +B en +ress ing +OU R +Ġw ound +Ġcy cl +Ġmechan isms +Ġcongress ional +ĠE lement +Ġagre ements +Ġdec or +Ġclos est +ĠM it +Go ogle +} } +Ġm ixture +Ġflu id +S ign +ĠSch olar +Ġp ist +ask et +ab ling +Ġrac ing +he ro +ri el +ass y +Ġche aper +b en +Ġvert ical +amac are +ĠRead ing +g ments +Ġhelic op +Ġsacr ifice +ay a +p aren +V A +ĠL es +ĠStud io +Ġviol ations +ĠAn na +ac er +é ¾ +ĠR at +ĠBe ck +ĠD ick +ĠA CT +Ġcomp osition +Ġtext ure +ĠO wn +Ġsmart phone +ĠN A +Ġfor b +im port +Ġdef ending +il st +re r +Ġo h +ĠJere my +Ġbank ing +cept ions +Ġrespect ive +/ . +Ġdr inks +ĠW i +Ġb ands +ĠL iverpool +Ġg rip +ĠB uy +Ġopen ly +Ġreview ed +per t +Ġver ify +ĠCo le +ĠW ales +M O +Ġun pre +Ġshel ter +ĠIm perial +Ġgu i +ĠD ak +Ġsuggest ions +Ġexplicit ly +Ġsl ave +Ġblock chain +Ġcompet ing +Ġprom ising +S ON +Ġsoc cer +Ġconst itution +4 29 +Ġdist ract +ĠU ser +es ides +ĠMet hod +ĠTok yo +Ġaccompan ied +Cl ient +s ur +al og +Ġident ification +Ġinv asion +as ma +Ġindust ries +pp ers +Ġsub tle +ĠUn it +n atural +Ġsurv ived +Ġfl aw +ĺ ħ +ĠH oll +Ġdef icit +Ġtut orial +ĠCh ance +Ġarg uing +Ġcontem porary +Ġinteg ration +for ward +Ġt um +it is +Ġh iding +ĠD omin +ĠT an +ĠB uilding +ĠV in +Ġspokes person +ĠNot es +Ġemer ging +Ġprepar ation +Ġpro st +Ġsuspect s +Ġaut onom +D escription +Ġdeal t +ĠP ear +Ġstead y +Ġdecre ased +Ġso vere +ĠCl in +Ġgrad ually +ors es +ĠW AR +S erv +ãĤ ¢ +h r +Ġd irty +ĠB arn +ĠB C +Ġd il +Ġcal endar +Ġcompl iance +Ġch amber +b b +Ġpass enger +ate ful +ĠT itle +ĠSyd ney +ĠG ot +Ġdark ness +Ġdef ect +Ġpack ed +ass ion +Ġgod s +Ġh arsh +IC K +le ans +Ġalgorith m +Ġoxy gen +Ġvis its +Ġbl ade +Ġkil omet +ĠKent ucky +Ġkill er +P ack +enn y +Ġdiv ine +Ġnom ination +be ing +Ġeng ines +Ġc ats +Ġbuff er +ĠPh ill +Ġtra ff +AG E +Ġtong ue +Ġrad iation +ere r +m em +ĠExpl icit +é¾ į +Ġcou ples +Ġphys ics +ĠMc K +Ġpolit ically +aw ks +ĠBl oom +Ġwor ship +e ger +ut er +ĠF O +Ġmat hemat +Ġsent enced +Ġdis k +ĠM arg +Ġ/ * +P I +Ġoption al +Ġbab ies +Ġse eds +ĠScott ish +Ġth y +] ] +ĠHit ler +P H +ng th +Ġrec overed +ing e +Ġpow der +Ġl ips +Ġdesign er +Ġdis orders +Ġcour age +Ġch aos +" },{" +Ġcar rier +b ably +H igh +ĠR T +es ity +l en +Ġrout es +u ating +F il +N OT +w all +s burgh +Ġeng aging +ĠJava Script +ore r +li hood +Ġun ions +ĠF ederation +ĠTes la +Ġcomple tion +ĠT a +Ġprivile ge +ĠOr ange +Ġne ur +paren cy +Ġb ones +Ġtit led +Ġprosecut ors +ĠM E +Ġengine er +ĠUn iverse +ĠH ig +n ie +o ard +Ġheart s +ĠG re +uss ion +Ġmin istry +Ġpen et +ĠN ut +ĠO w +ĠX P +in stein +Ġbul k +S ystem +ic ism +ĠMarket able +Ġpre val +Ġpost er +Ġatt ending +ur able +Ġlicens ed +ĠG h +et ry +ĠTrad able +Ġbl ast +à ¤ +ĠTit an +ell ed +d ie +H ave +ĠFl ame +Ġprof ound +Ġparticip ating +Ġan ime +ĠE ss +Ġspec ify +Ġregard ed +ĠSpe ll +Ġs ons +own ed +Ġm erc +Ġexper imental +land o +h s +ĠDun geon +in os +Ġcomp ly +ĠSystem s +ar th +Ġse ized +l ocal +ĠGirl s +ud o +on ed +ĠF le +Ġconstruct ed +Ġhost ed +Ġsc ared +act ic +ĠIs lands +ĠM ORE +Ġbl ess +Ġblock ing +Ġch ips +Ġev ac +P s +Ġcorpor ation +Ġo x +Ġlight ing +Ġneighb ors +ĠU b +ar o +Ġbe ef +ĠU ber +F acebook +ar med +it ate +ĠR ating +ĠQu ick +Ġoccup ied +Ġaim s +ĠAdd itionally +ĠInt erest +Ġdram atically +Ġhe al +Ġpain ting +Ġengine ers +M M +ĠM ust +Ġquant ity +P aul +Ġearn ings +ĠPost s +st ra +ãĥ¼ ãĥ +Ġst ance +Ġdro pping +sc ript +Ġd ressed +M ake +Ġjust ify +ĠL td +Ġprompt ed +Ġscr ut +Ġspeed s +ĠGi ants +om er +ĠEd itor +Ġdescrib ing +ĠL ie +ment ed +Ġnow here +oc aly +Ġinst ruction +fort able +Ġent ities +Ġc m +ĠN atural +Ġinqu iry +Ġpress ed +iz ont +for ced +Ġra ises +ĠNet flix +ĠS ide +Ġout er +Ġamong st +im s +ows ki +Ġclim b +ne ver +Ġcomb ine +d ing +Ġcomp r +Ġsignific ance +Ġremem bered +ĠNev ada +ĠT el +ĠSc ar +ĠWar riors +ĠJ ane +Ġcou p +b as +Ġtermin al +, - +O H +Ġt ension +Ġw ings +ĠMy ster +�� �� +ĠUn like +val id +viron ments +ĠAl i +Ġn aked +book s +ĠM un +ĠG ulf +Ġd ensity +Ġdim in +Ġdesper ate +Ġpres idency +Ġ198 6 +h y +IN D +Ġun lock +im ens +Ġhand led +ĠE b +Ġdisapp eared +Ġgen re +Ġ198 8 +Ġdetermin ation +St ream +ik o +ap ters +Ġacknow ledge +J an +Ġcapital ism +P at +Ġ20 20 +Ġpain ful +Ġcur ve +Ġbom bs +st orm +ĠMet al +en cer +ĠF ig +ĠA aron +anc hes +Ġins piration +Ġexha ust +t ains +ash i +Ġdesc ript +Ġr itual +ĠChel sea +Ġpromot ion +ĠH ung +ĠW ard +iv a +ĠE T +Ġto ss +all ow +ĠFranc is +D ep +Ġhapp iness +ĠGl ass +Ġbet a +Ġstreng then +N E +o a +Ġbutt ons +ĠMur ray +Ġkick ed +Qu est +ĠT alk +ĠS everal +ĠZ ero +Ġdr one +ul k +Ġc am +ĠM obile +Ġprevent ing +Ġret ro +ĠA x +Ġcru el +Ġflo at +. ), +Ġfil ing +ĠGr ant +ĠB or +Ġr ib +Ġchampions hip +ĠM erc +Ġsty les +Ġc ake +Ġbuild s +ĠS elf +io x +Ġep ic +oy d +B el +ĠSt ew +. ( +ah u +ĠBe yond +Ġout s +Ġsol o +ĠT ree +Ġpres erve +Ġt ub +AR E +ro c +ĠIm pro +ĠW right +Ġbu nd +Ġtr aged +Ġoccas ional +b ian +Sec ond +r ons +Ġinter actions +form ed +s ing +Ġown s +Ġh ockey +Gener al +Ġlog ical +Ġexp end +Ġesc al +ĠGr iff +ĠC rown +ĠRes erve +Ġsto pping +Ġexc use +sec ond +Ġoper ated +Ġre aches +ĠMal ays +Ġpoll ution +ĠBrook lyn +Ġde lete +Ġhas h +Bl ock +ah a +âĢ ³ +Ġsh orter +p iece +> </ +Ġh orm +ĠW at +ĠBre ak +Ġprohib ited +Ġint ensity +ĠAl an +Ġli ability +? ! +and ed +Ġneigh bour +ĠCol lection +Ġf ires +Ġrevolution ary +f ly +ĠOr leans +Wh ite +ĠW rit +ĠD awn +Ġsett le +Ġexec ute +B M +Ġspokes woman +Ġlif estyle +Ġclick ing +ĠK ill +ĠLiber al +ĠN azi +Ġtra iler +Ġmount ains +Ġdam n +z es +p es +Ġpress ing +Ġb ail +ĠOrgan ization +Ġp ir +Ġth irty +Ġelect rical +Ġ1 15 +ĠP oly +ĠR ap +ĠSt rike +ĠC ann +Ġdemand ed +Ġback ing +def ault +spe ed +ĠLeg isl +Ġmother s +ĠB ody +Ġvar iation +ced ented +p owered +le ading +N ever +Ġg rave +ĠAnt i +A W +Ġinterview ed +ĠG ab +ĠF at +Ġrook ie +u u +Ġdep os +ix on +Ġam pl +ret ion +ĠHe at +Ġpeace ful +S M +ie ve +Ġd iver +ĠVict oria +Ġm ic +p df +Ġst ating +Ġl ung +Ġcritic ized +Ġvacc ine +ĠLoad ing +ur se +T ake +ĠFr an +ĠS old +ĠRob in +Ġdetect ed +ĠSc ript +Ġadjust ed +Ġsen ator +Ġopp osing +Er ror +C ount +Ġconflic ts +Ġo w +ĠAr gent +Ġmatch ing +h h +ĠTre k +st arter +" ), +ĠA F +od er +xx xx +ĠAl t +ac re +ĠP ick +ĠSol ar +ĠD al +O ct +ĠB att +Ġs rc +Ġeng agement +Ġexecut ives +Ġliber ty +j ava +Ġtal ented +igen ous +Ġcon secut +.. ... +In fo +Ġhor rible +Ġsurprising ly +f eed +ic ating +ĠL ED +Ġfem ales +St ation +ell er +ĠOak land +Ġmechan ical +i ology +ĠV ar +Ġrob ust +ett ings +ott a +Ġthe oret +Ġret ain +k ward +Ġd a +Ġdeploy ed +d el +ĠAnd y +Ġsubsc ribe +we b +Ġn a +ĠMic hel +Ġpart ially +ĠCome y +Ġc rown +ĠM aj +ĠBl u +r ator +D ay +IN T +Ġdocument ed +ĠG DP +g i +che ll +Ġbrut al +ĠB ab +st ration +Ġthe ft +Ġt ube +@ @ +Ġqu ery +ĠL incoln +Ġpublish ing +Ġw ore +or ical +Ġr ic +Ġnot able +Ġsubsequ ently +ne x +Ġobser ve +ĠB oe +Ġc odes +m ain +W H +ĠS L +Ġresident ial +av an +Ġm as +are st +ade on +OU T +Ġsoph istic +ant e +Ġc ens +Ġ ** +Ġmort ality +Ġyour s +Ġoccas ions +Ġrec alled +ĠDri ver +Ġv ocal +Ġbath room +Ġsh ops +Ġcollabor ation +ĠOb amacare +ĠC ell +Ch ar +Su per +C re +Ġt ends +Ġt orn +Ġeconom ics +a very +ĠR aid +ĠS em +Ġshould ers +Ġexpect ing +Ġexam ination +en ame +ĠU I +i ability +ol as +ĠAm b +ĠD ra +Ġmid field +ĠI C +Ġlay out +Ġflo ating +f i +it ative +Ġtremend ous +Ġ Ð +Ġab und +W ork +ĠLight ning +Ġsimilar ly +Ġconserv atives +Ġpr ay +B E +iz arre +Ġt empt +Ġemphas is +ĠMet ro +Ġf ishing +Ġmar ry +ne g +ĠStud y +Ġrec k +Ġdis pos +on ing +bs ite +Ġsusp ic +Ġmer ch +ĠG ib +ĠDes cription +ĠD VD +w he +ĠY emen +Ġen vironments +oot ing +ĠMod ern +e u +Ġreflect s +Ġh oney +Ġanaly st +Ġg ut +d ec +A ction +Ġhousehold s +Ġst er +Ġtem ple +Ġreform s +Ġfavour ite +Ġdead line +ĠL E +Th ree +ĠWith in +A ug +Ġnight s +elt a +Ġinv alid +ĠEx change +ĠDel hi +w hen +inc ome +Ġ ðŁ +Ġwire less +sc ribe +ist a +Ġhost ile +Ġall y +Ġg ig +Ġout lets +ĠD or +EM ENT +Ġas h +Ġab stract +OR D +ĠMot or +Ġadv iser +ist le +Ġb ases +Ġcourt esy +Ġcross ing +Ġcle ared +Ġrefuge e +cos ystem +Ġthrow s +f un +bour ne +d ays +Ġdisag ree +ĠN ative +Ġreflect ed +ĠF ast +ĠY ellow +ĠSing apore +ĠR aven +Ġembr ace +ĠK u +ĠC hen +ĠEar ly +Ġappoint ment +ĠMin i +it ement +Ġpl acing +Ġb icy +S R +Ġwh is +S U +Ġinvestig ated +Ġphotograph s +g ithub +ĠBe at +ĠR ing +ig hed +i ar +Ġev olved +eral d +Ġd un +Ġh ub +I AL +Ġencour aging +ĠPr int +ĠD ays +Ġpro secution +Ġp ants +az y +l ive +Ġfoss il +ĠJ u +Ġro cks +ud ge +ĠR ace +Ġg reet +b ie +Ġf illing +ĠL en +Ġdi abetes +Ġfire arms +um ing +enez uel +ĠB B +Ġaccept ing +AT H +Ġres ort +Ġh unt +ri k +uck er +am ents +Ġsust ained +Ġcross ed +Ġbreak fast +Ġatt ributes +lect ed +at ile +Ġv ibr +ĠK al +ars on +op les +Ġtou ched +Ġdam ages +Ġimp ressed +ru p +Ġan ch +ĠAd ams +H el +ĠVict or +Ġmount ed +ĠC C +Ġdelic ious +sp an +ell a +Ġel abor +am ples +Ġdef ic +Ġconstit u +u ates +ĠM ission +ĠT her +ĠMon ster +b es +Re uters +ĠInd ones +h ill +mun ition +Ġconfirm ation +ĠCons ider +ac ent +Ġj et +ĠEm ploy +ĠGT X +n an +ĠSp ider +Ġprocess or +Ġpat ri +ĠPent agon +ĠRob inson +Ġreal istic +à ± +Ġappear ing +Ġp ipe +om ed +Ġf ru +Ġaw ful +Ġeval uation +Ġintellig ent +ĠC itiz +Ġfund ra +od ium +Ġtwe ets +Ġwor n +pr ing +Ġkid n +Ġreb els +ĠK am +ĠNether lands +ĠS W +Ġacqu isition +ĠM ale +ãĥ ª +omb ies +Ġtrad em +ĠStat us +B re +ĠTH IS +Ġad verse +ĠN EW +s ign +Ġorgan isation +en c +ĠHar per +ap or +ĠMem bers +ĠPe ace +ĠAir port +ĠOther s +Ġscr atch +ĠP il +Ġsens or +Ġadop tion +ĠHot el +ĠDr ag +Ġhonest ly +Ġy ard +ĠFor ces +Ġpat ent +Ġb ass +Ġquiet ly +Ġbreat hing +Ġp ose +i ors +ĠJ ess +st atic +IT E +O ffic +Ġj ew +w cs +Ġ14 0 +Ġpre view +ipp i +Ġunf ortunately +oke mon +Ġh orn +Ġre ass +Ġpe er +ock er +Ġunt o +ĠGr ay +Ġclean ing +Ġattract ed +200 7 +P oint +k ill +ĠAg reement +ur ches +Ġhor r +ĠMiss iss +Ġworth y +Ġfl owers +t own +d ll +Ġre actions +Ġde ce +Ġindic ating +M D +Ġpre ference +ĠM VP +ess ional +ĠT arget +g ence +ĠInd ians +Ġm isc +Ġfree ly +Ġmus cles +Ġline up +Ġimpact s +ous ing +om i +ac ular +Ġcontro lling +ag ine +c ery +he ll +Ġrank ing +ĠN ich +ĠA ve +12 8 +Ġhigh way +Ġinc ons +Ġb inding +Ġstrugg les +ĠPitt sburgh +Ġgr ay +r in +Ġcom ics +ĠS port +Ġrel atives +Ġfr ight +Ġpro be +ĠPort ug +Ġv oc +Ġt u +ĠCor ps +Ġposs ibilities +Ġqual ify +wcs store +Ġl ibraries +Ġm igrants +Ġent ries +Ġconsecut ive +v als +ĠChair man +Ġh ill +IM E +ĠG ard +Ġinequ ality +f ox +ĠS ave +Ġc ort +claim ed +Ġtra its +Ġp our +Ġmiss iles +Ġess ence +Ġs ends +Ġall iance +Ġw ishes +ĠChrist opher +B ig +N Y +ĠJac ob +s an +ur red +ĠS O +ll y +Ġadvoc ate +ĠB ond +Ġ" / +Us ing +Ġdistrict s +ĠG ate +ĠB ir +r idge +ĠN az +ĠR s +bo ards +ĠG a +ĠRe agan +Ġinflu enced +1 000 +ap y +Ġchalleng ed +Ġb arg +Ġfac ulty +ĠF if +Ġacqu ire +A c +Ġin sect +Ġinstr uments +Ġle af +th odox +M essage +Ġt ale +Ġthere by +Ġtra p +Ġstrong est +ĠMil itary +is ible +Ġ198 4 +ethe less +Ġflex ible +Ġkill s +Ġfin ishing +ĠS ize +Ġredu ces +Ġep id +Ġorient ation +f ull +Ġtr ace +Ġl aser +Ġopp ose +Ġed iting +Ġmoment um +ä º +sh ow +V I +ĠL ad +Ġ198 5 +Ġmurd ered +9 00 +ut her +Ġprob ability +ĠP oll +Ġrel uct +ĠChe m +ĠMont real +Ġadequ ate +ĠPol and +ĠSher iff +um ph +Ġo k +Ġ 000 +Ġ" [ +Ġoper ators +ĠF er +Ġmod es +ĠE ve +Ġdiscipl ine +N ET +H and +Ġor al +ĠW E +em ail +J P +ĠPalestin ians +Ġhe nce +ĠL ess +Ġover l +d ig +Ġintim id +ĠCo al +Ġr anging +th a +Ġdist ant +Ġf ib +ĠInd ex +ĠW onder +ĠP el +hatt an +ĠH ug +Ã Ĺ +ra it +Ġwra pped +ĠR PG +Ġchemical s +ĠM oney +Ġfro zen +Ġind irect +ĠAgain st +E nd +Ġuncom fortable +ĠGall ery +ĠPost ed +Ø § +ond uct +Ġconsequ ence +Ġbit ter +Ġ198 7 +p op +Ġcount less +ĠAl aska +ff ff +Ġdepart ure +Ġref und +ĠI an +i ated +Ġsee ks +Ġmechan ics +Ġjurisd iction +lyn n +Ġal ike +ĠH unt +ath on +Ġres olved +Ġc ache +Ġdist inction +d irect +Ġenc ount +ou b +be at +ĠCount ry +se arch +Ġcontin uous +Ġmod est +ĠR ail +th ood +1 30 +B UG +Ġcrim inals +Ġindic ation +Ġencount ered +l ast +ĠW y +Ġide ology +ĠP DF +sec urity +] ) +ĠJim my +ĠE N +Ġh iring +T em +Ġp ig +aun t +ĠCry stal +Ġpen alties +Ġcap ability +Ġp y +Ġproduct ive +Ġbal anced +ĠGe Force +cl ick +olit an +od s +Ġafter wards +Ġplay offs +ĠG ill +U ser +Ġback s +p ub +t ag +Ġabs urd +p iring +Ġc iting +Ġtr illion +Ġoblig ation +Ġmax im +ah oo +c f +um i +ĠAl pha +ĠN elson +Ġpursu ant +in itely +Ġf ract +ent ry +ber y +ĠTh or +Add ed +ĠD J +ĠG ene +Ġaw kward +St ud +Ġwal let +ĠDiv ine +ari os +Ġrele asing +Ġed ited +Ġaccompl ished +B est +Ġed ges +Ġplan es +Ġfeed ing +" }," +Ġdiscl osure +Ġgr ain +air y +o ons +ern and +V R +Ġreason ably +Ġdr um +Ġpart ial +Ġgraph ic +Ġunpre cedented +Ġadv ised +M icro +ĠAss ad +point s +sc ar +ĠZ one +tt es +Ġ7 00 +v o +ĠH amp +Ġfix es +Ġca ution +Ġstr ings +Ġpan els +Ġle ak +Ġpr icing +row th +ĠEr ror +ĠS aints +f ix +Ġobserv ations +ĠA bs +Ġsuggest ion +ĠUkrain ian +Ġbar rier +Ġpain ted +B et +im ir +ĠS pect +p ot +orne ys +Ġcomp ound +Ġbe ars +ĠR ush +Ġlux ury +S um +Ġor bit +ĠMar c +Ġex empt +ĠTra il +ĠM O +ĠH ans +ĠWe apon +oc used +umin um +ĠJer ry +Ġb ust +ĠA G +ĠW iki +Ġend less +ĠV lad +ĠB ah +ĠR adeon +ke ys +ĠSur vey +ĠV iol +def ine +le an +Ġcomm od +Ġreven ues +Å į +Ġfurn iture +Ġcast ing +Ġdiplom atic +ĠPlay ers +ĠK illed +Ġmod ify +Ġinnov ative +ĠAb u +n or +Ġbond s +Ġcoach ing +M er +Ġmod ules +ĠPatri ots +Ġenh anced +Ġproceed ings +Ġteam mates +Ġ12 8 +ard o +Ġcomprom ise +ĠM uch +Ġfle w +ĠEd ge +Ġunnecess ary +Ġdoct rine +re port +ĠOr lando +ĠProf ile +Ġplay off +friend ly +Ġcompl ain +ĠM C +ĠO pt +ĠG B +Ġbeat en +Ġg olf +Ġpl acement +B it +Ġnews letter +Ġ201 9 +vis or +raw l +ĠiP ad +Ġact ed +Ġju ice +Ġdec ks +P N +su ccess +ĠH alf +Ġdele ted +Ġsec rets +Ġas ylum +M art +ĠAct iv +ĠGu y +ĠT s +Ġd ys +Ġassum ing +Ġman a +Ġsub ur +Ġ12 5 +M edia +AR Y +r ide +c p +Ġdifficult ies +Ġcollect ing +Ġbank rupt +n on +Ġcomp osed +Ġvol t +Ġmilit ants +Ġ> >> +ĠM ormon +t or +Ġpartic les +ĠB art +ry ption +Ġad min +Ġsqu ee +VID IA +Ġcreat or +iam eter +ic ular +N BC +Ġgrab bed +Ġn odd +Ġr ated +Ġrot ation +Ġgr asp +Ġexcess ive +ĠE C +ĠWh it +Ġinvent ory +ault s +ĠF B +Ġe cosystem +Ġbill ions +Ġvent ure +n amed +Ġdef ender +out e +Inst ead +ir able +W ar +Ġassum ption +Ġb ite +Ġearth qu +t ail +sp ace +Ġgif ts +boy s +Ġinev itable +Ġstruct ural +Ġbenef icial +Ġcompe lling +h ole +erv ation +Ġco at +o j +inc arn +ĠY ears +Ġdetermin ing +Ġrhet oric +Ġbound aries +Ġwh ites +A nt +add y +) - +ra ham +eter min +Ġhar vest +ĠCon c +Ġlapt op +ĠM atch +Ġenjoy ing +cc a +oll ar +Ġtri ps +Ġadd iction +ĠS ak +Ġpow ered +Ġc ous +ĠRuss ians +ie re +Ġret rie +qu ality +Ġdiff er +Ġking dom +ĠL aur +ĠCap itol +Ġcon clusions +ĠAl tern +ĠN av +Ġtrans parent +B ER +G roup +ĠCom plete +Ġinf er +Ġint rig +Ġins ane +R O +oph ob +is en +qu al +Mich ael +Ġm useum +ĠP ope +Ġres et +r ative +f ive +Ġagg reg +itte es +osit ory +Ġcar b +ĠRec ord +Ġdec ides +ĠF ix +Ġexcept ions +ĠCommission er +un s +ĠEnvironment al +Ġlegend ary +ist ence +Ġtun nel +k m +Ġins ult +Ġt roll +Ġsh ake +Ġdet ention +qu es +ĠCh rome +ĠF iles +Ġsub t +Ġprospect s +Ġpro l +re nder +pro of +Ġperform ances +St r +Ġh ref +ern ame +Ġachieve ment +Ġf ut +F ull +ĠLe ban +go ogle +ãĥ Ī +amp a +May be +Ġproject ed +ĠE mb +Ġcol leg +Ġa wards +Ġâ Ķ +G old +ĠBl ake +ĠR aj +if ting +Ġp ending +Ġinst inct +Ġdevelop ments +Con nect +ĠM and +ĠW ITH +ĠPhilipp ines +prof ile +Ġalt ogether +ĠB und +ĠT D +oo oo +amp ed +ip h +Ġste am +Ġold est +Ġdet ection +ul pt +Ġ ç +ĠWay ne +200 6 +f a +Ġcir cles +ĠF u +Ġdon ors +appropri ate +ĠDak ota +j amin +Ġmotiv ated +Ġpurch ases +ĠLouis iana +ĠS pl +Ġgl obe +Ġ10 5 +z ip +c all +Ġdepart ments +Ġsustain able +10 5 +ĠO P +if iers +Ġprevent ed +Ġinc omp +ĠComm ander +Ġdom inated +Ġ » +Ġinvest ed +Ġcomplex ity +Ġin cl +Ġens uring +Ġreal m +yn c +ĠInd ependent +r ained +ĠJ en +ĠFl ight +Ġat he +Ġspec ulation +ĠT E +oc ate +t ic +Ġpl aint +her ry +Ġto y +Ġ1 11 +Ġpl ates +st atus +ĠIs a +Ġdev oted +C op +ĠE S +25 5 +ur rency +M ain +Ġsl aves +Ġpe pper +Ġqu otes +Ġce iling +ĠF ish +Ġtrans formation +Ġfra ction +Ġadvant ages +Ġto ile +Ġstun ning +Ġmo ist +bre aking +s i +ĠL ocation +ĠMed ium +Ġtext s +Ġu gly +Ġb io +. âĢĶ +ĠB ased +Ġtr ains +ĠW ing +ĠAn cient +ĠRec ords +ĠH ope +Spe cial +ades h +ob i +[ / +Ġtempor arily +V er +h u +os er +Ġover night +Ġm amm +ĠTre asury +ĠV enezuel +ĠMeg a +Ġt ar +Ġexpect s +bl ack +or ph +\\ \\ +Ġaccept ance +Ġrad ar +s is +Ġjun ior +Ġfram es +Ġobserv ation +ac ies +P ower +ĠAdv anced +M ag +olog ically +ĠMe chan +Ġsent ences +Ġanaly sts +augh ters +force ment +Ġv ague +Ġcl ause +Ġdirect ors +Ġeval uate +Ġcabin et +M att +ĠClass ic +A ng +Ġcl er +ĠB uck +Ġresear cher +Ġ16 0 +Ġpoor ly +Ġexperien cing +ĠP ed +ĠMan hattan +Ġfre ed +Ġthem es +ad vant +Ġn in +Ġpra ise +10 4 +ĠLib ya +b est +Ġtrust ed +Ġce ase +Ġd ign +D irect +Ġbomb ing +Ġm igration +ĠSci ences +Ġmunicip al +ĠA verage +Ġgl ory +Ġreve aling +Ġare na +Ġuncertain ty +Ġbattle field +ia o +G od +Ġc inem +ra pe +el le +ap ons +Ġlist ing +Ġwa ited +Ġsp otted +ke ley +ĠAud io +e or +ard ing +idd ing +ig ma +ĠN eg +Ġl one +Ġ ---- +ex e +d eg +Ġtrans f +Ġwas h +Ġsl avery +Ġexpl oring +ĠW W +ats on +Ġen cl +l ies +ĠC reek +Ġwood en +Man ager +ĠBr and +um my +ĠAr thur +Ġbureau cr +Ġbl end +ar ians +F urther +Ġsupposed ly +Ġwind s +Ġ19 79 +Ġgrav ity +Ġanalys es +ĠTra vel +ĠV eter +Ġd umb +Ġaltern ate +g al +Ġconsum ed +Ġeffect iveness +.' ' +Ġpath s +ond a +L A +ĠStr ong +Ġen ables +Ġesc aped +Ġ" " +Ġ1 12 +Ġ198 3 +Ġsm iled +Ġtend ency +F ire +Ġp ars +ĠR oc +Ġl ake +Ġf itness +ĠA th +ĠH orn +Ġh ier +Ġimp ose +m other +Ġp ension +ic ut +bor ne +ic iary +. _ +ĠS U +Ġpol ar +is y +eng u +itial ized +AT A +w rite +Ġexerc ises +ĠD iamond +ot ypes +Ġharm ful +on z +Ġprint ing +st ory +Ġexpert ise +ĠG er +Ġtraged y +ĠF ly +Ġd ivid +amp ire +st ock +M em +Ġre ign +Ġun ve +Ġam end +ĠProp het +Ġmut ual +ĠF ac +Ġrepl acing +H ar +ĠCirc uit +Ġthro at +ĠSh ot +Ġbatter ies +Ġto ll +Ġaddress ing +ĠMedic aid +Ġp upp +ĠN ar +ol k +Ġequ ity +M R +ĠHis pan +ĠL arge +m id +D ev +Ġexp ed +Ġdem o +ĠMarsh all +erg us +Ġf iber +Ġdiv orce +ĠCre ate +Ġsl ower +ĠPark er +ĠStud ent +ĠTr aining +Ret urn +ĠT ru +Ġc ub +ĠRe ached +Ġpan ic +Ġqu arters +Ġre ct +Ġtreat ing +Ġr ats +ĠChristian ity +ol er +Ġsac red +Ġdecl are +ul ative +et ing +Ġdeliver ing +est one +Ġt el +ĠL arry +Ġmet a +ac cept +art z +ĠRog er +hand ed +Ġhead er +Ġtra pped +ĠCent ury +Ġkn ocked +ĠOx ford +Ġsurviv ors +b ot +Ġdemon stration +Ġd irt +Ġass ists +OM E +ĠD raft +ortun ate +fol io +pe red +ust ers +g t +ĠL ock +Ġjud icial +ver ted +Ġsec ured +out ing +ĠBook s +Ġhost ing +Ġlif ted +l ength +Ġj er +Ġwhe els +ĠR ange +umbn ails +Ġdiagn osis +te ch +ĠStew art +ĠP ract +Ġnation wide +Ġde ar +Ġoblig ations +Ġgrow s +Ġmand atory +Ġsusp icious +! ' +A pr +G reat +Ġmort gage +Ġprosecut or +Ġeditor ial +ĠK r +Ġprocess ed +ung le +Ġflex ibility +Ear lier +ĠC art +ĠS ug +Ġfoc uses +Ġstart up +Ġbre ach +ĠT ob +cy cle +ãĢ Į +ro se +Ġb izarre +ãĢ į +Ġveget ables +$ $ +Ġret reat +osh i +ĠSh op +ĠG round +ĠSt op +ĠHawai i +ĠA y +Per haps +ĠBe aut +uff er +enn a +Ġproduct ivity +F ixed +cont rol +Ġabs ent +ĠCamp aign +G reen +Ġident ifying +Ġreg ret +Ġpromot ed +ĠSe ven +Ġer u +ne ath +aug hed +ĠP in +ĠL iving +C ost +om atic +me ga +ĠN ig +oc y +Ġin box +Ġem pire +Ġhor izont +Ġbr anches +Ġmet aph +Act ive +ed i +ĠFil m +ĠS omething +Ġmod s +inc ial +ĠOrig inal +G en +Ġspir its +Ġear ning +H ist +Ġr iders +Ġsacr ific +M T +ĠV A +ĠS alt +Ġoccup ation +ĠM i +Ġdis g +lic t +Ġn it +Ġn odes +e em +ĠP ier +Ġhat red +ps y +ãĥ ī +Ġthe ater +Ġsophistic ated +Ġdef ended +Ġbes ides +Ġthorough ly +ĠMedic are +Ġbl amed +arent ly +Ġcry ing +F OR +pri v +Ġsing ing +ĠI l +Ġc ute +o ided +olit ical +ĠNe uro +å ¤ +Ġdon ation +ĠEag les +ĠG ive +T om +Ġsubstant ially +ĠLic ense +ĠJ a +Ġg rey +ĠAn imal +ĠE R +ĠU nd +Ġke en +Ġconclud e +ĠMississ ippi +Eng ine +ĠStud ios +P ress +o vers +ll ers +Ġ3 50 +ĠR angers +Ġr ou +ert o +E p +iss a +iv an +Ġse al +ĠReg ist +dis play +Ġwe aken +u um +ĠComm ons +ĠS ay +Ġcult ures +Ġl aughed +Ġsl ip +Ġtreat ments +iz able +m art +ĠR ice +Ġbe ast +Ġob esity +ĠLa ure +ig a +Wh ich +hold er +Ġelder ly +Ġp ays +Ġcompl ained +Ġc rop +Ġpro c +Ġexplos ive +ĠF an +ĠAr senal +A uthor +ef ul +Ġme als +Ġ( - +id ays +Ġimag ination +Ġann ually +Ġm s +as ures +H ead +ik h +m atic +Ġboy friend +ĠCom puter +Ġb ump +Ġsur ge +ĠCra ig +ĠKir k +D el +medi ate +Ġscen arios +ĠM ut +ĠSt ream +Ġcompet itors +Ù Ħ +ĠStan ford +ĠRes ources +az ed +b age +Ġorgan is +ĠRe lease +Ġsepar ately +Ġha bits +Ġmeasure ments +ĠCl ose +Ġaccomp any +Ġg ly +Ġt ang +ĠR ou +Ġplug in +Ġcon vey +ĠChall enge +oot s +j an +Ġcur s +ĠRel ations +ke eper +Ġapproach ing +p ing +Spe aking +Ġarrang ement +ĠV I +are ttes +Ġaffect ing +Ġperm its +b ecause +Ġu seless +ĠH us +!! !! +Ġdestro ying +Un fortunately +Ġfasc inating +S em +Ġelect oral +Ġtrans parency +ĠCh aos +Ġvolunte er +Ġstatist ical +Ġactiv ated +ro x +We b +H E +ĠHamp shire +is ive +M ap +Ġtr ash +ĠLaw rence +st ick +C r +Ġr ings +EX T +Ġoper ational +op es +D oes +ĠEv ans +Ġwitness ed +P ort +Ġlaunch ing +ec onom +w ear +ĠPart icip +um m +cul es +ĠR AM +ĠT un +Ġass ured +Ġb inary +Ġbet ray +Ġexpl oration +ĠF el +Ġad mission +it ated +S y +Ġav oided +ĠSim ulator +Ġcelebr ated +ĠElect ric +¥ ŀ +Ġcl uster +itzer land +he alth +L ine +ĠN ash +at on +Ġsp are +Ġenter prise +ĠD IS +clud es +Ġfl ights +Ġreg ards +ĠÃ Ĺ +h alf +Ġtr ucks +Ġcontact s +Ġunc ons +ĠCl imate +Ġimm ense +N EW +oc c +ect ive +Ġemb od +Ġpat rol +Ġbes ide +Ġv iable +Ġcre ep +Ġtrig gered +ver ning +Ġcompar able +q l +Ġg aining +ass es +Ġ( ); +ĠG rey +ĠM LS +s ized +Ġpros per +" ? +Ġpoll ing +Ġsh ar +ĠR C +Ġfire arm +or ient +Ġf ence +Ġvari ations +g iving +ĠP i +osp el +Ġpled ge +Ġc ure +Ġsp y +Ġviol ated +Ġr ushed +Ġstro ke +ĠBl og +sel s +ĠE c +,' ' +Ġp ale +ĠColl ins +ter ror +ĠCanad ians +Ġt une +Ġlabor atory +Ġn ons +t arian +Ġdis ability +ĠG am +Ġsing er +al g +ĠSen ior +Ġtrad ed +ĠWar rior +Ġinf ring +ĠFrank lin +Ġstr ain +ĠSwed ish +Ġsevent h +ĠB enn +ĠT ell +Ġsynd rome +Ġwond ered +id en +++ ++ +ig o +Ġpur ple +Ġjournal ism +Ġreb el +Ġf u +bl og +Ġinv ite +ren cies +ĠCont act +Is rael +ĠCont ent +Ġche er +Ġbed room +ĠEngine ering +ĠQue ens +Ġd well +ĠPlay Station +ĠD im +ĠCol on +l r +Ġoper ates +Ġmotiv ation +US A +ast ered +C ore +ĠTr uth +ol o +OS E +ĠMem ory +Ġpred ec +Ġan arch +Ġ19 20 +ĠY am +à ¨ +b id +Ġgr ateful +Ġexc itement +Ġtre asure +Ġlong est +ct ive +Ġdes erves +Ġreserv es +Ġcop s +ĠOtt awa +ĠEgypt ian +ank ed +Ġart if +Ġhypot hesis +: / +Ġpurch asing +Ġlove ly +H P +Ġdiv ide +Ġstrict ly +Ġquestion ing +Ġtaxp ayers +ĠJ oy +Ġroll s +ĠHe avy +Ġp orts +Ġmag netic +Ġinf lamm +Ġbr ush +t ics +â ĪĴ +Ġbott les +pp y +Ġp add +ãĤ ¯ +m illion +Ġdevast ating +Ġcomp iled +Ġmed ication +Ġtw elve +ĠPer ry +Sp ace +im b +y our +Ġle aked +ĠT ar +Ġun ity +Ġinfect ed +Ġtravel ed +ID E +ĠMc Donald +t xt +ĠPr inc +Ġinter ven +ĠTai wan +ĠP ow +Ġbe aring +ĠTh read +Ġz ones +iz ards +un ks +Ch apter +ll or +Ġ · +Ġw ounds +Ġdisc retion +Ġsucceed ed +ik ing +Ġicon ic +C all +Ġscreen ing +ĠM is +ict s +Ġmin isters +Ġsepar ation +Pl ayer +Ġb ip +Ġbel oved +Ġcount ing +ĠE ye +ar ound +ing ing +Ġtable t +Ġoff ence +in ance +h ave +ĠInf o +ĠNin ja +Ġprotect ive +ĠC ass +M ac +ĠQual ity +N orth +Ġ ic +ĠCub a +ĠChron icle +ĠPro perty +Ġfast est +ot os +ĠG erm +OW N +Ġbo om +ĠStan ley +ergus on +Ġcle ver +Ġent ers +m ode +ter ior +ĠS ens +Ġlin ear +AR K +Ġcomp aring +Ġpure ly +Ġsaf er +ĠPot ter +Ġc ups +R T +Ġgl uc +Ġatt ributed +Ġdu pl +ĠP ap +Ġprec ious +Ġp a +iction ary +ĠT ig +ĠTo o +ol utions +st an +Ġrob ots +Ġlob b +Ġstat ute +Ġprevent ion +w estern +16 0 +ĠAct ive +ĠMar ia +h al +N one +ell ar +ĠK B +ĠPart ners +ĠSing le +ĠFollow ing +ang o +ac ious +Ġth ou +Ġk g +Ġinflu ential +ĠFriend s +S ur +ain ted +Ġfor ums +Ġst arter +Ġcitizens hip +ĠE lection +on ge +ot ation +os ph +;; ;; +ut ical +p ur +ere n +Ġaccus ations +bit ious +ab bit +ĠOr d +Post ed +ir k +Ġsens itivity +ic he +ĠAm y +ĠF ab +Ġsum mit +Ġped est +Ġrub ber +Ġagric ultural +Ġcan cel +A E +Ġin aug +Ġcont am +Ġfirm ly +i w +st age +ĠK an +Ġt ier +Ġinv ention +Ġtransl ated +ĠR ules +B ox +Tw itter +ID S +Ġp izza +Ġdeb ug +ĠD rop +v s +Ġh orses +b ig +Ġb oring +Ġh ood +ĠMcC ain +at ched +ĠBro s +Ġsk ip +Ġess ay +st at +ĠLeg ends +Ġam munition +au c +Ġshoot er +Ġun h +Ġsuppl ied +Ġgener ic +ĠS K +ib an +yr ics +Ġ25 5 +Ġclim bing +Form er +Ġfl ip +Ġjump ing +Ġfrust ration +ĠTer ry +Ġneighborhood s +Ġmed ian +be an +Ġbr ains +Follow ing +Ġsh aped +Ġdraw s +Ġal tered +J ack +Ġrecip es +Ġsk illed +we alth +ach i +e lection +Ġbehavi ors +de als +ĠU ntil +F e +Ġdecl aration +mar ks +ĠBet ween +cel ona +Ġres on +Ġbub ble +Am ong +Ġim perial +G S +Ġfemin ist +200 5 +ĠK yle +Ġaccount ing +ĠTe le +ĠT yr +Ġconnect ing +Ġre hab +ĠP red +s im +Ġmeant ime +Ġphys ician +M W +ĠCamp bell +ĠBr andon +Ġcontribut ing +ĠR ule +ĠWe ight +ĠN ap +Ġinter active +Ġv ag +Ġhel met +ĠCom b +f our +Ġsh ipped +Ġcomple ting +ĠP D +PD ATE +Ġspread ing +Ġsc ary +erv ing +ĠG as +Ġfr ank +s chool +Ġrom antic +Ġstab il +R ob +Ġaccur ately +Ġac ute +ĠH ann +Ġsymbol s +Ġcivil ization +ĠA W +Ġlight ning +Ġcons iders +Ġven ue +Ġ × +Ġo ven +ĠS F +h is +Ġn u +ĠLear n +Ġpe oples +Ġst d +Ġsle e +Ġs lic +ĠStat istics +Ġcor ners +ĠB aker +Ġ: ) +ment ation +ol ver +Ġlaugh ing +ĠT odd +ond e +ĠH ills +Ġn uts +ĠW oman +pl ane +Ġl iver +ĠIn side +S orry +Ġagre es +Ġfund ament +ĠF isher +Ġa uction +Ġthread s +gl as +ĠBas ic +ĠN at +Ġlack ing +Ġceleb ration +j u +Ġs illy +E uro +Ġt att +ight y +cont rolled +T est +ĠSing h +Ġr age +Ġrh yth +o ffic +ĠPh antom +Ġhead lines +Ġrespond ing +ĠMor ning +Ġvit amin +Ġboot s +ĠS ite +al in +p i +Ġvir al +ĠU C +D ER +ĠSe x +Ġst ocks +c urrent +Ġch urches +ĠR are +ĠMur phy +Ġden ial +ĠG aming +Ġtou g +Ġn ick +Ġm akers +ĠRon ald +Ġgener ous +ĠD oc +ĠMor ris +Ġtransform ed +ĠN ormal +Ġ10 4 +ĠKick starter +ĠUp on +On line +ĠI RS +Ġw rap +Ġl oving +Ġarri ves +ĠD ue +Ġhe ter +ĠM ade +Ġrent al +Ġbelong s +Ġatt orneys +Ġcro ps +Ġmat ched +ul um +ol ine +10 9 +Ġdis par +Ġbuy ers +ĠCam bridge +Ġeth ics +rou ps +Ġjust ified +Ġmarg inal +Ġrespect ed +win ning +Ġnodd ed +ĠSer ge +ĠForm er +C raft +######## ######## +ĠWar ner +Ġd ash +et e +Ġent ert +ĠE scape +out heast +Ġkn ees +ĠB omb +Ġr ug +P ass +Ġatt itudes +go vernment +ĠPri or +Ġqual ities +Ġnot ification +ĠPh one +l ie +Ġanticip ated +ĠCom bat +ĠBar ry +Ġ198 2 +Us ers +on er +Ġcomput ing +ĠConnect icut +Ġless er +Ġpe ers +ĠC u +Ġtechn ically +Ġsub mission +ĠUn iversal +Ġman ually +our ge +Ġrespond ents +ĠB TC +ĠH ost +Ġf are +ĠB ird +Ġrece ipt +al so +Ġj ack +Ġagric ulture +Ġsk ull +Ġ! = +Ġpass ive +ĠC I +Ġsoc ieties +Ġremind ed +Ġinter ference +B uy +Ġâ ľ +g on +Ġscrut iny +ĠW itch +Ġconduct ing +Ġ ãĥ +Ġexch anges +ĠMit chell +Ġinhab it +Ġtw ist +B D +Ġwhere ver +group on +Ġj okes +ĠBen jamin +ĠR andom +fr ame +ĠL ions +Ġhighlight ed +ĠArk ansas +E nt +Ġp ile +Ġpre lim +g s +mind ed +Ġfel ony +ĠG A +ĠL uck +Ġpract ically +ĠB os +Ġact ress +D am +ĠB ou +Ġvis a +Ġembed ded +Ġhy brid +Ġear liest +Ġsoon er +s ocial +ĠH A +Ġste ep +Ġdis advant +Ġexplo it +ĠE gg +ĠUlt ra +Ġnecess ity +L ocal +ie ge +Ġd ated +Ġmass es +Ġsubsc ription +pl ess +Ġan onym +Ġpresum ably +Bl ue +The ir +asket ball +ĠPhil ip +Ġcom ed +load ed +r ane +Ġref lection +Ch ina +Ġext ends +Ġform ing +Ġund ers +200 1 +Ġgr at +Ġconcent rations +Ġins ulin +Ġsec ular +Ġwh ilst +Ġwin ners +Ad vertisements +Ġdeliber ately +ĠWork ing +Ġs ink +et ics +d ale +Ġmand ate +Ġg ram +Ġvac ation +Ġwarn ings +ri pp +ĠTH AT +Ġcomment ary +Ġint u +Ġa est +Ġreason ing +Ġbreak down +ĠZ ombie +Ġ-- > +ĠPolit ical +c ott +Ġthr ust +Ġtechn ological +Ġdec iding +Ġtraff icking +L ong +W elcome +pr ising +ĠCommun ications +Ġend ors +Ġsw ift +Ġmetab ol +co ins +res a +ĠHT TP +Ġen roll +ĠH appy +us r +int age +Ġ[ " +u ably +ĠM aterial +Ġrepe al +Se pt +k h +ĠMod i +Ġunder neath +ĠI L +sh ore +Ġdiagn osed +ace utical +Ġsh ower +au x +ĠSw itch +ĠStre ngth +Ġj ihad +n ational +Ġtra uma +uss y +on i +Ġcons olid +Ġcal ories +ĠF lynn +ag ged +16 8 +ĠP ink +Ġfulf ill +Ġch ains +Ġnot ably +ĠA V +L ife +ĠCh uck +m us +ĠUr ban +ĠH end +Ġdep osit +ĠS ad +Ġaff air +OR K +ie val +ĠF DA +Ġt rop +ĠOver all +Ġvirt ue +Ġsatisf action +au nd +Ġl un +ĠSw itzerland +ĠOper ation +pro cess +Ġsh ook +Ġcount ies +le ased +ĠCharl otte +1 12 +Ġtrans cript +Ġre dd +p ush +ĠHe y +ĠAn alysis +[ " +Ġaltern atives +ard less +Ġele ph +Ġpre jud +ĠLe af +H aving +ĠH ub +Ġexpress ions +ĠVol ume +Ġshock ing +ĠRed s +Ġread ily +Ġplan ets +ad ata +Ġcollaps ed +ĠMad rid +Ġir rit +i pper +ĠEn c +ĠW ire +Ġbu zz +ĠG P +ash a +Ġaccident ally +ur u +Ġfrust rated +ĠS A +Ġhung ry +ĠH uff +Ġlab els +ant o +ĠE P +Ġbar riers +) | +ĠBer keley +ĠJ ets +Ġp airs +ĠL an +J ames +ĠB ear +Ġhum or +ĠLiber ty +Ġmagn itude +Ġag ing +ĠM ason +Ġfriends hip +umb ling +Ġemer ge +Ġnewsp apers +Ġam bitious +ĠRich ards +atern al +Ġ198 1 +Ġcook ies +Ġsc ulpt +Ġpur suit +L ocation +Ġscript s +p c +Ġarrang ements +Ġd iameter +Ġl oses +am ation +Ġl iqu +ĠJ ake +aret te +Ġunderstand s +ĠZ en +v m +Ġappro ve +Ġw ip +Ġult ra +Ġint end +ĠD I +asc ular +Ġst ays +ĠK or +ĠK l +Ġinvest ing +L a +Ġbelie ving +b ad +m outh +Ġtaxp ayer +ãĥ ĥ +ĠQue bec +Ġl ap +ĠSw iss +d rop +Ġdr ain +ir i +et c +ft en +ĠN ex +Ġst raw +Ġscream ing +Ġcount ed +Ġdam aging +Ġamb assador +cent ury +Ġpro x +Ġarrest s +u v +il ateral +ĠCh arg +Ġpresc ribed +Ġindepend ently +Ġf ierce +ĠB aby +Ġb rave +Ġsu its += > +Ġbas eline +ĠR ate +Ġis lands +Ġ( ( +g reen +ix els +Ġname ly +ĠVill age +th an +am y +V ersion +g mail +ential s +ĠS ud +ĠMel bourne +Ġarri ving +Ġquant um +e ff +rop olitan +T ri +Ġfun eral +ĠI R +ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ +ĠC ob +it ably +Ġt urb +Ġcomb o +Re view +Ġdeploy ment +u ity +ĠB ott +Ġinv isible +Ġrender ing +Ġunl ocked +Ġa qu +ĠVlad imir +Ġp ad +ĠBr ain +ĠLeg acy +dr agon +ĠKurd ish +Ġsound ed +Ġdet ained +ĠD M +g ary +Ġd aughters +Ġdistur bing +uk a +ĠPar ad +Ġt ast +Ġunf ortunate +Ġu l +em in +Ġattend ance +tr l +Ġpar ks +ĠMem orial +ĠAl ice +oth y +gu ard +ĠD ise +ĠSh an +ĠFor um +R ich +Ġshif ted +ue z +Ġl ighter +ĠMag n +Ġc od +S ch +ham mad +P ub +3 50 +ĠP okemon +Ġprot otype +Ġun re +B ase +ĠStud ents +ĠRep ly +ĠCommun ist +Ġg au +ĠTy ler +I Z +Ġparticip ated +Ġsup rem +ĠDet ails +Ġvessel s +ro d +Ġt ribe +ke ep +Ġassum ptions +Ġp ound +Ġcr ude +ĠAv ailable +Ġswim ming +Ġin clusion +Ġadv ances +c ulation +Ġconserv ation +Ġover d +ĠBuff alo +Art icle +ed ge +Ġaw a +ĠMad ison +Ġsid ew +Ġcat ast +ĠK rist +uc le +ĠHigh way +ĠTer ror +Ġactiv ation +Ġuncons cious +ĠSat an +ĠSus an +ill ery +Ġarr anged +i op +Ġrum ors +ur ring +th ink +ĠKe ith +ĠK ind +Ġavoid ing +by n +n ut +ĠSpe aker +r us +n ames +Ġgu ilt +ĠOlymp ics +Ġsa il +ĠM es +lev ant +ĠColumb us +a ft +C ity +S outh +ĠHar vey +ĠP un +S everal +Ġment ally +Ġimp ress +m ount +ĠUb untu +âĢĶâĢĶâĢĶâĢĶ âĢĶâĢĶâĢĶâĢĶ +ĠSuper man +ĠMP s +Ġintent ions +ĠR acing +Ġlike lihood +Ġ2 40 +T otal +Ġto ys +ĠW atson +Ġur ge +L ear +ĠP aper +Ġoccur ring +ĠB eng +ĠC ert +Ġst ones +T im +ĠTw in +z b +ĠD ynam +Ġpolit ician +k ens +ĠEnter prise +UT ERS +Ġab ol +Ġref resh +Ġarbit rary +pe ction +Ġtrou bles +Ġ} ); +t v +Ġpil ots +Ġdist ribute +Ġaud it +Ġp ause +orig inal +Ġr ivals + £ +F ig +T L +ab il +ry ing +L in +ion ed +l on +Ġf ancy +Ġcr ashed +Ġt ract +Ġshe d +Ġcons ume +B ased +down load +in it +Ġvolt age +Int rodu +Ġcondem ned +ĠFin ance +res pect +Ġex cluded +Ġestablish ing +her ic +Ġher itage +Ġspect acular +Ġun st +ĠSnow den +ĠL ane +S an +Ġprotect ions +st ruction +inc inn +Ġmac ro +C ustom +ios ity +Ġes p +Ġfunction ing +Ġm ush +Ġp uzzle +Ġeth ical +M al +Ġgo verning +ĠF erguson +Ġrest ored +Ġst ressed +ĠCoun ter +ĠK as +cl ip +AN S +Ġse iz +U K +by ss +old own +ap i +Ġperman ently +oun ters +W est +Th rough +L ight +at oes +Ġne at +Ġc ord +ure r +Ġsevere ly +ĠA ven +Ġinter rog +Ġtri ple +G iven +N umber +Ġar ise +Ġs her +pl ant +Ġfl ower +ĠC ou +Ġat e +Ġnew er +b ul +Ġmean while +ĠL air +Ġadjust ment +ĠCop yright +Ġd ivers +i ological +Ġgam ers +o at +Ġhistor ically +Ġanal og +Ġlong time +Ġpres cription +ĠM ist +ĠHy per +ĠM aine +ĠDe ity +Ġmulti pl +ĠRe incarn +ĠH yd +ĠP ic +S il +r ants +ĠC ris +. ; +( { +epend ence +Ġrec y +ate ur +Ġqu ad +Ġgl ob +Ġcon ced +te am +Ġcapital ist +ĠL ot +Ġroy al +ĠCy ber +Ġblack s +met ic +ri v +ĠD anny +Ġsp o +ĠR O +Ġanim ated +rypt ed +ĠDep uty +Ġrend ered +F E +Ġstre ak +Ġcloud s +ĠDou g +~~~~ ~~~~ +Ġdisc our +ĠVe h +Ġpsych ology +ĠJ ourney +Ġcry stal +ĠFro st +Ġsuspic ion +Ġrel ate +or us +ĠC rypt +ĠN VIDIA +com ed +ut ing +incinn ati +Ġvulner ability +ost ic +Ġisol ation +Ġcool ing +ĠCoal ition +Ġ1 19 +F our +ĠDe al +Ġâ ī +se mble +ram ent +ĠBar celona +Ġ10 2 +Ġcoc aine +ocaly pse +F eb +ogen ic +Ġmut ation +Ġcrypt oc +ĠK el +ĠG it +a is +Ġs isters +AN K +Ġactiv ate +T er +Ġd read +yl on +Ġprop ri +A ust +ĠDef ault +Ġout door +Ġshe er +ce ive +Ġg ently +Ð ¾ +Pro gram +Ġâ ĨĴ +Ġve gan +ĠCr us +Ġrespons ibilities +ĠH R +OL D +Ġprev ents +Ġst iff +ĠW ere +Ġathlet ic +ĠSc ore +Ġ) : +Ġcolumn s +ĠL oc +av ailable +ĠF ram +ĠS essions +Ġcompan ion +Ġpack s +14 0 +ĠKn ights +Ġf art +Ġstream s +Ġsh ore +Ġapp eals +ĠPer formance +h aul +ĠSt ra +ĠN ag +10 3 +ĠTrans portation +B B +E v +z an +P ublic +Ġtw in +uls ion +M ult +Ġelect ro +Ġstat ue +ation ally +ĠN ort +Ġins pection +/ * +ig ue +Ġcomp assion +ĠT ales +ĠSte in +ĠSc reen +ĠB ug +ĠL ion +g irl +Ġwithdraw al +Ġobject ives +Ġblood y +Ġprelim inary +Ġj acket +Ġdim ensions +ĠC ool +ĠOcc up +Ġw reck +Ġdoub led +ank ing +Ġ19 75 +Ġglass es +ĠW ang +pro v +P ath +connect ed +ĠMult i +ĠNor way +agon ist +Ġfe ared +Ġtouch ing +Ġarg uably +¯¯¯¯ ¯¯¯¯ +ĠNC AA +che m +Ġsp at +ĠW WE +ĠC el +ig ger +Ġattack er +ĠJo in +ob ject +ett a +Ġelim inated +d et +Ġdest ruct +ĠLuc as +ct uary +18 0 +ĠBr ady +ĠBl ues +B ay +au kee +Ġtim eline +Ġdeleg ates +w ritten +uff icient +Ġsh apes +Cop yright +ou ble +serv ice +Ġp ione +Ġcolleg es +Ġrow s +Ġsp ite +Ġassess ed +3 60 +Ġle ase +Ġconfident ial +ck er +ĠMan ning +ĠV oice +Ġse aled +Ġcalcul ate +N O +ĠAss istant +Ġteen ager +ul ent +ather ine +Ġm ock +Ġd iamond +Ġf est +Ġsw itched +Ġres ume +ĠPu erto +Ġl anes +ir ation +ĠSimilar ly +Ġro d +ĠS el +ĠPal ace +ĠLim ited +e ous +Ġvar iant +Ġw ard +Ġ) ) +Sh ow +OO K +A lex +ĠN ep +br is +ĠWik ipedia +Ġexcept ional +Ġman ages +ĠD raw +Ag ain +Ġco pper +ut t +Ġex ports +Ġport folio +Ġelev ated +R ated +ĠOther wise +ĠT act +ĠShe l +ĠT X +" âĢĶ +Ġres ur +ĠW a +ven ant +Ġmon etary +pe ople +E mail +Ġfif ty +ĠS weet +ĠMalays ia +Ġconf using +ĠR io +ud a +uten ant +" ); +Ġpra ised +Ġvol umes +t urn +Ġm ature +Ġnon profit +Ġpassion ate +ĠPriv ate +Ġ10 3 +Ġdesc end +ç ¥ŀ +uff y +head ed +Whe ther +ri en +ze ch +be it +Ġch rom +ĠMc M +Ġd ancing +Ġe leg +ĠNot iced +11 5 +Ġadvoc acy +ENT S +amb ling +ĠMin or +ĠF inn +Ġprior ities +Ġthere of +ĠSt age +ĠRog ers +Ġsubst itute +ĠJ ar +ĠJeff erson +Ġlight ly +10 2 +ĠL isa +u its +ys ical +Ġshif ts +Ġd rones +Ġwork place +Ġres id +ens ed +ah n +Ġpref erences +ser ver +Ġdeb ates +d oc +ĠGod s +Ġhelicop ter +Ġhon our +Ġconsider ably +ed ed +ĠF emale +ĠAn ne +Ġre un +ĠF ace +ĠHall ow +ĠBud get +Ġcondem n +Ġt ender +Pro f +ocr atic +ĠTurn er +ĠAg ric +Ġ19 76 +Ġa pt +d isc +ĠF ighter +ĠA ur +Ġgar bage +in put +ĠK arl +ĠOl iver +ĠL anguage +k n +N on +ĠCl ar +Ġtrad itions +Ġad vertisement +ĠS or +Ġarch ive +Ġvill ages +7 50 +Ġimplement ing +w aukee +Ġdiet ary +Ġswitch ing +Rep ublic +Ġvel ocity +Ġc it +ĠA wards +Ġfin ancing +Ġlast ed +) ] +Ġrem inder +P erson +Ġprec ision +Ġdesign ers +ĠF ried +ĠB order +Ġtr agic +Ġw ield +Ġiniti atives +ĠT ank +w er +Ġjo ins +R o +in ery +Ġar row +Ġgener ating +found er +Ġsear ches +Ġrandom ly +A ccess +Ġb atch +Ġp osed +l at +Ġpursu ing +as a +Ġtest ified +form ing +ĠSh ar +w iki +ĠE ither +S ometimes +Ġsen ators +ĠJohn ny +ĠTal iban +ĠG PS +":" / +ãģ® å +Ġanaly zed +ĠRub io +ĠMove ment +op ard +ii i +St and +f ight +Ġign oring +i ang +ĠG N +so ever +ĠST AT +Ġref using +Ġswe at +Ġb ay +P ORT +ir med +ak y +Ġdis pro +Ġlabel ed +Ġ10 8 +H ello +Ġple asant +ab a +Ġtri umph +Ġab oard +Ġinc om +ĠC row +le tt +Ġfol k +Ġch ase +` ` +ĠBr us +Ġte ens +c ue +Ġter rain +h yd +il ight +OR Y +Su pport +ew s +ll i +rain ts +ĠC and +Ġab used +ach ment +l arg +B as +ĠC ancer +Ġ19 78 +Ġsupp orter +ac cess +ĠTer min +ĠT ampa +ĠAN Y +Ġnew est +ĠCrim inal +ed u +Ġ19 30 +Ġadm its +Ġend e +Ġfail ures +ur ate +ful ness +cy cl +ĠSub ject +Ġinf inite +th ree +W A +p it +ĠInst all +R ad +ili ation +G M +Ġcontin ent +Ġaccommod ate +ĠCl ay +Ġp up +ĠF unction +Ġham mer +ĠAlbert a +Ġrev ised +Ġminor ities +Ġmeasure ment +Con nell +Ġdis able +ĠM ix +In cre +Ġfor k +ĠR osen +Ġimpl ies +umb lr +AN G +Ġprote ins +Ġagg ression +Ġfacilit ate +S N +Ġilleg ally +u er +Ġacad em +Ġp uzz +ĠSh ift +p ay +oll o +Ġaud iences +B uild +Ġno ble +Ġsynt ax +â ĺħ +Ġbe am +ĠB ed +ĠA ld +Ġorig ins +v ideo +Ġ19 77 +ĠAss ault +Ġgar age +Te am +Ġver dict +Ġd war +ĠVirt ual +e vent +Ke ep +Ġsent iment +Ġwild life +sh irt +Ġb urg +Ġrecommend ation +rep resent +Ġgall ery +own ers +Ġsch olar +Ġconven ience +ĠSw ift +Ġconv inc +C ap +Ġwar fare +ĠVis ual +Ġconst itute +Ġab ort +ĠWe ather +ĠLook ing +ĠH em +Ġmart ial +Ġinc oming +et ition +Ġtoler ance +ĠCre ated +Ġfl ows +ĠE lder +Ġsoul s +Ġf oul +ĠP ain +ĠC AN +Ġ2 20 +b c +he nd +Ġgen ius +R eal +ĠW r +omet er +p ad +Ġlim iting +ĠS i +ĠL ore +ĠAd ventures +Ġvar ied +D isc +f in +ĠPerson al +Ch ris +Ġinv ented +Ġd ive +ĠR ise +Ġo z +ĠCom ics +Ġexp ose +ĠRe b +let ters +s ite +im ated +Ġh acking +Ġeduc ated +ĠNob ody +Ġdep ri +Ġincent ive +ãĤ · +Ġovers ight +Ġtrib es +ĠBelg ium +Ġlicens ing +our t +Produ ct +ah l +ĠG em +Ġspecial ist +Ġc ra +ann ers +ĠCor byn +Ġ19 73 +RE AD +Ġsum mar +Ġover look +ĠApp lication +Ġin appropriate +Ġdownload ed +Q ue +ĠB ears +Ġth umb +ĠChar acter +ĠReincarn ated +ĠS id +Ġdemonstr ates +s ky +ĠBloom berg +ĠAr ray +ĠRes ults +ĠFour th +ĠED T +ĠO scar +c end +Ġ10 6 +ĠN ULL +ĠH ERE +m atch +ĠBr un +Ġgluc ose +ie g +eg u +Ġcert ified +Ġrel ie +Ġhuman itarian +Ġpr ayers +K ing +Ġn an +h ou +10 8 +ul u +Ġrenew able +Ġdistingu ish +Ġd ense +ĠV ent +ĠPack age +ĠB oss +Ġedit ors +Ġm igr +T ra +ĠPet ers +ĠAr ctic +200 4 +ĠC ape +Ġloc ally +Ġlast ing +Ġhand y +. ). +P an +ĠR ES +Ind ex +Ġt ensions +Ġformer ly +Ġide ological +Ġsens ors +Ġdeal ers +Ġdef ines +S k +Ġproceed s +Ġpro xy +az ines +ĠB ash +ĠP ad +ĠC raft +eal ous +Ġshe ets +omet ry +J une +cl ock +T T +ĠThe atre +ĠB uzz +Ġch apters +Ġmill enn +Ġd ough +ĠCongress ional +Ġimag ined +av ior +Ġclin ic +Ġ19 45 +Ġhold er +ro ot +oles ter +Ġrest art +B N +ĠHam as +ĠJ ob +Ġor b +Ġr am +Ġdiscl ose +Ġtransl ate +Ġimm igrant +Ġannoy ing +Ġtreat y +an ium +ĠTe a +ĠLeg ion +Ġcrowd s +ĠB ec +ĠA er +oh yd +B ro +Look ing +Ġl bs +Ġagg ress +Ġse am +Ġinter cept +ĠM I +mer cial +act iv +ĠC it +Ġdim ension +Ġconsist ency +Ġr ushing +ĠDou glas +Ġtr im +Inst all +ick er +Ġsh y +10 6 +Ġment ions +pe lled +ĠT ak +c ost +Ġclass room +Ġfort une +dri ven +Ġun le +ĠWhe el +Ġinvest or +ĠM asters +k it +Ġassoci ations +ĠEv olution +op ing +us cript +Ġprov incial +ĠWal ter +av i +S O +Ġun limited +Eng lish +ĠC ards +ĠEb ola +ne red +Ġreven ge +Ġout right +um per +Ġf itting +ĠSol id +Ġform ally +Ġproblem atic +Ġhaz ard +Ġenc ryption +Ġstraight forward +ĠA K +Ġp se +ĠOr b +ĠCh amber +ĠM ak +Cont ents +Ġloyal ty +Ġl yrics +ĠSy m +Ġwel comed +Ġcook ed +Ġmon op +Ġn urse +Ġmis leading +Ġe ternal +Ġshif ting +Ġ+ = +V is +Ġinst itutional +ill ary +Ġp ant +VER T +ĠA CC +ĠEn h +Ġinc on +ĠRE UTERS +Ġdon ated +âĢ¦âĢ¦ âĢ¦âĢ¦ +In tern +Ġexhib it +Ġt ire +ĠR ic +ĠCh ampion +ĠMu hammad +N ING +ĠSoc cer +Ġmob ility +Ġvary ing +ĠM ovie +Ġl ord +o ak +F ield +Ġve ctor +us ions +Ġsc rap +Ġen abling +m ake +T or +. * +| | +ĠWe bsite +ĠN PC +Ġsocial ist +ĠBill y +ĠAdd itional +Ġc argo +Ġfar ms +ĠSo on +ĠPri ze +Ġmid night +Ġ9 00 +se en +ĠSp ot +Ġshe ep +Ġspons ored +ĠH i +ĠJ ump +Ġ19 67 +Micro soft +ĠAg ent +Ġch arts +d ir +Ġadj acent +Ġtr icks +Ġman ga +Ġex agger +/ > +foot ball +ĠF CC +G C +ĠT ier +and ra +OU ND +% ), +Ġfru its +V C +ĠA A +R ober +Ġmid st +â Ĺ +ank a +Ġlegisl ature +ĠNe il +Ġtour ists +" " +ĠWar ning +ĠNever theless +ĠOffic ial +ĠWh atever +Ġm old +Ġdraft ed +Ġsubst ances +Ġbre ed +Ġt ags +ĠT ask +Ġver b +Ġmanufact ured +com ments +ĠPol ish +Pro v +Ġdetermin es +Ob ama +k ers +Ġutter ly +Ġse ct +sc he +ĠG ates +ĠCh ap +Ġal uminum +Ġz ombie +ĠT ouch +ĠU P +Ġsatisf y +Ġpred omin +asc ript +Ġelabor ate +Ġ19 68 +Ġmeas uring +ĠV ari +any ahu +Ġs ir +ul ates +id ges +ick ets +ĠSp encer +T M +oub ted +Ġpre y +Ġinstall ing +ĠC ab +re ed +re ated +Su pp +Ġwr ist +ĠK erry +10 7 +ĠK le +ĠR achel +Ġc otton +ĠA RE +ĠE le +Cont rol +Ġload s +ĠD od +an as +b one +Ġclass ical +ĠReg ional +ĠInt eg +V M +Ġdes ires +Ġaut ism +support ed +ĠM essage +Ġcomp act +writ er +Ġ10 9 +ĠHur ricane +c ision +Ġcy cles +Ġdr ill +Ġcolle ague +Ġm aker +G erman +Ġmist aken +S un +ĠG ay +Ġwhat soever +Ġsell s +ĠA irl +l iv +ĠO ption +Ġsol ved +Ġse ctors +Ġhorizont al +Ġequ ation +ĠSk ill +ĠB io +g ement +ĠSn ap +ĠLeg al +Ġtradem ark +Ġmake up +Ġassemb led +Ġsa ves +ĠHallow een +ĠVer mont +ĠFR OM +Ġfar ming +ĠP odcast +accept able +ĠHig her +Ġas leep +ull ivan +Ġrefere n +ĠLe v +Ġbul lets +ok o +H C +Ġst airs +Ġmain tains +ĠL ower +ĠV i +Ġmar ine +Ġac res +Ġcoordin ator +ĠJ oh +Ġcounterpart s +ĠBrother s +Ġind ict +b ra +Ġch unk +Ġc ents +H ome +ĠMon th +Ġaccording ly +if les +ĠGerm ans +ĠSy n +H ub +Ġey eb +âĶĢâĶĢ âĶĢâĶĢ +Ġr anges +ĠHoll and +ĠRob ot +f c +M ike +Ġpl asma +Ġsw ap +Ġath lete +ĠR ams +,' " +Ġinfect ions +Ġcor rid +Ġv ib +Ġpat ches +Ġtradition ally +Ġrevel ation +Ġswe ep +Ġgl ance +Ġin ex +200 3 +ĠR aw +work ing +os ures +ĠD at +ĠLyn ch +Ġle verage +ĠRe id +Ġcorrel ation +ian ces +av ascript +Ġrep ository +ret ty +Ġ19 72 +24 0 +Ġo un +p ol +ĠRe ed +Ġtact ical +is ite +App le +ĠQu inn +Ġrap ed +ill o +Euro pe +Ġalgorith ms +ĠRod rig +i u +Ġill um +Ġf ame +Ġintrodu cing +Ġdel ays +ĠRaid ers +Ġwh istle +Ġnovel s +ĠRe ally +Ġder iv +Ġpublic ations +ĠNe ither +ĠCom merce +Ġa ston +l anguage +Not es +ĠR oth +ĠF ear +Ġm ate +Ġpar ade +ĠQ B +Ġman eu +ĠC incinnati +m itting +Ġwa ist +ĠR ew +Ġdisc ont +Ð ° +Ġst aring +Ġal ias +Ġsec urities +Ġtoile t +ĠJ edi +Ġun law +v ised +//// //// +] ( +ĠWe iss +Ġpre st +ĠComp an +Ġmem o +ĠGr ace +J uly +ĠEl ite +cent er +ĠSt ay +Ġgal axy +Ġto oth +ĠS ettings +Ġsubject ed +ãĤ ¦ +Ġline back +Ġretail ers +ĠW ant +Ġd angers +A ir +Ġvolunt ary +ew ay +Ġinterpret ed +ot ine +à § +Ġp el +Serv ice +ĠEvent ually +Ġcare ers +Ġthreat en +Ġmem or +ĠBrad ley +anc ies +s n +ĠUn known +N ational +Ġsh adows +ail and +ĠD ash +Every one +izz ard +M arch += ( +Ġpull s +Ġstr anger +Ġback wards +ĠBern ard +imens ional +Ġch ron +Ġtheoret ical +k top +Ġw are +ĠInvest ig +ĠIn iti +ĠOper ations +o ven +oc ide +* / +Ġfl ames +ĠC ash +sh it +Ġc ab +ĠAn aly +ĠSe ah +Ġdefin ing +Ġorder ing +Ġimm un +Ġpers istent +AC H +Russ ian +m ans +Ġh ind +Ġphot ography + © +Ġh ug +Ġ10 7 +ĠH ence +i ots +ude au +Ġsubsid ies +Ġroutine ly +ĠDev ice +it ic +Ġdisg ust +land er +Ġ19 40 +Ġassign ment +ĠB esides +w ick +ĠD ust +us c +struct ed +11 1 +de velop +Ġf ond +Ġinter section +Ġdign ity +Ġcommission er +With out +re ach +Ġcart oon +Ġsc ales +ãĥ Ń +F IG +Ġsurve ys +ĠIndones ia +Ġart work +Ġun ch +Ġcy cling +un ct +au er +or ate +ĠOb viously +Ġcharacter ized +fe ld +Ġaff irm +Ġinn ings +Ġ é +Ġal iens +Ġcl oth +et ooth +ĠC ertain + § +Ġdig est +k now +ĠX L +Ġpredict ions +Ġd in +W AR +Ġafter math +Ex ample +ĠSu ccess +ĠTh r +IG N +Ġmin er +B us +Ġcl arity +heim er +ĠO UT +ĠS end +ĠCirc le +ĠD iet +Ġpron ounced +Ġcreat ors +Ġearthqu ake +atter y +ge ons +Ġo d +Ġlay ing +or p +U lt +pro ject +Ġunder min +Ġsequ el +S am +ĠDark ness +Ġre ception +b ull +Y S +ĠV ir +Ġsequ ences +ĠCo in +Ġout fit +ĠW ait +1 19 +Ġdel ivers +.... .. +Ġbl own +ĠE sc +ĠM ath +per m +ĠU l +Ġgl im +Ġfac ial +Ġgreen house +Ġto kens +/ - +ĠAnn ual +ĠON E +Ġteen age +ĠPhys ical +ĠL ang +ĠC elt +Ġsu ed +ivid ually +Ġpat ience +ch air +reg ular +Ġa ug +in v +ex cept +ĠL il +Ġn est +f d +s um +ĠCh ase +Russ ia +ĠJenn ifer +Ġoff season +Over all +F ore +Ġr iot +A ud +form er +Ġdefend ers +ĠC T +iot ic +rib ly +Ġautom ated +Ġpen is +Ġins ist +Ġdi agram +ĠS QL +ĠG arc +Ġw itch +cl ient +ier ra +am bers +Ġrec ount +f ar +V ery +oster one +Ġappreci ated +ĠPer fect +S ection +Ġd oses +oca ust +Ġcost ly +Ġg rams +ĠSh i +Ġwrest ling +Ġ19 71 +Ġtro phy +Ġn erve +ĠK az +ĠExper ience +Ġpled ged +Ġplay back +Ġcreat ivity +by e +Ġattack ers +Ġhold ers +ĠCo ach +ĠPh D +Ġtransf ers +Ġcol ored +ĠH indu +Ġd rown +Ġlist ened +ĠW A +ias m +P O +Ġappeal ing +Ġdiscl osed +ĠCh icken +ag ging +Ġple aded +Ġnav igation +ĠReturn s +Ġ[ [ +R OR +E A +Ġphotograp her +ĠR ider +ipp ers +Ġsl ice +Ġe rect +Ġhe d +iss ance +ĠVik ings +ur ious +Ġapp et +oubted ly +Ch ild +Ġauthent ic +o os +ĠM aking +Ġannoun cing +Ġb od +Ġmet er +ĠN ine +ĠR ogue +Ġwork force +Ġrenew ed +Ġorganis ations +ac s +P LE +Sh ort +Ġcomp ounds +ĠVis it +Ġen velop +ear th +Ġsupport ive +gg le +ĠBrus sels +ĠGu ild +Cre ate +RE L +Ġaver aged +Ġ19 69 +ri ages +Ġlength y +Ġforg ot +O kay +ĠE rd +Ġdeal er +Ġrec ession +D D +Ġdesper ately +Ġhun ger +Ġst icks +Ġm ph +ĠF aith +Ġintention ally +Ġdem ol +ue ller +ĠS ale +Ġde bris +s pring +Ġle ap +>> >> +Ġcontain ers +se lling +rane an +atter ing +Ġcomment ed +ĠC M +on ut +Ġwood s +es pecially +Ġorgan ize +iv ic +ĠWood s +ang a +s qu +Ġm aj +am on +Ġax is +Ġ19 74 +ĠDen mark +Ġwar rior +ĠP and +Ġout lined +ĠB O +ins ula +z illa +eb ook +Ġd are +Ġsear ched +Ġnav igate +S n +writ ing +Ġun ited +J apan +ĠHe brew +Ġfl ame +Ġrel ies +Ġcatch ing +ĠSh o +Ġimprison ment +Ġp ockets +Ġclos ure +ĠF am +t im +ade qu +Act ivity +Ġrecru iting +ĠW ATCH +ĠArgent ina +d est +Ġapolog ize +or o +Ġlack s +Ġtun ed +ĠGriff in +Ġinf amous +Ġcelebr ity +ss on +Ġ ---------------------------------------------------------------- +ĠIs is +ĠDis play +Ġcred ibility +Ġeconom ies +Ġhead line +ĠCow boys +Ġind ef +Ġl ately +Ġincent ives +but ton +ĠM ob +A ut +Ġres igned +ĠO m +c amp +Ġprof iles +Ġsche mes +olph ins +ay ed +Cl inton +en h +ĠY ahoo +Ġab st +Ġan k +su its +Ġw ished +ĠMar co +udd en +Ġsp here +ĠB ishop +Ġincorpor ated +ĠPl ant +11 4 +Ġh ated +p ic +Ġdon ate +Ġl ined +Ġbe ans +Ġsteal ing +Ġcost ume +Ġsher iff +Ġfor ty +Ġint act +Ġadapt ed +Ġtrave lling +b art +Ġnice ly +Ġdri ed +Ġsc al +os ity +NOT E +ĠB h +ĠBron cos +ĠI gn +Ġint imate +Ġchem istry +Ġopt imal +D eb +ĠGener ation +Ġ] , +ich i +ĠW ii +ĠYOU R +vent ions +W rite +Ġpop ul +un ning +ĠW or +V ol +Ġqu een +head s +K K +Ġanaly ze +op ic +ear chers +Ġd ot +leg raph +ast ically +Ġupgr ades +Ġca res +Ġext ending +Ġfree ze +Ġin ability +Ġorg ans +Ġpret end +Ġout let +11 3 +ol an +ĠM all +ul ing +t alk +Ġexpress ing +ĠAl ways +ĠBe gin +f iles +Ġlic enses +% % +ĠM itt +Ġfil ters +ĠMil waukee +G N +Ġunf old +M o +Ġnut rition +pp o +B o +Ġfound ing +Ġunder mine +Ġeas iest +ĠC zech +ĠM ack +Ġsexual ity +ĠN ixon +W in +ĠAr n +ĠK in +ãĤ £ +ic er +Ġfort un +Ġsurf aces +agh d +Ġcar riers +ĠP ART +ĠT ib +Ġinter val +Ġfrust rating +ĠSh ip +ĠAr med +ff e +Ġbo ats +ĠAb raham +in is +Ġsu ited +th read +i ov +ab ul +ĠVenezuel a +Ġto m +su per +Ġcast le +alth ough +iox ide +ec hes +Ġevolution ary +Ġnegoti ate +Ġconfront ed +Rem ember +Ġ17 0 +S uch +Ġ9 11 +m ult +ĠA byss +ur ry +ke es +spe c +ĠBarb ara +Ġbelong ing +Ġvill ain +ist ani +Ġaccount able +Ġport ions +ĠDe cl +U r +ĠK ate +g re +Ġmag azines +UC K +Ġregul ate +om on +ĠAl most +Ġover view +Ġsc ram +Ġl oot +ĠF itz +Ġcharacter istic +ĠSn ake +s ay +ĠR ico +Ġtra it +ĠJo ined +au cus +Ġadapt ation +ĠAirl ines +Ġarch ae +ĠI de +Ġb ikes +Ġliter ary +Ġinflu ences +ĠUs ed +C reat +Ġple a +ĠDef ence +ĠAss ass +Ġp ond +UL T +) " +Ġeval uated +Ġob taining +Ġdem ographic +Ġvig il +ale y +Ġsp ouse +ĠSeah awks +resp ons +ĠB elt +um atic +Ġr ises +run ner +ĠMichel le +Ġpot ent +r ace +ĠP AC +F ind +olester ol +IS S +ĠIntrodu ced +ress es +ign ment +O s +ĠT u +ĠDe x +ic ides +Ġspark ed +ĠLaur a +ĠBry ant +Ġsm iling +ĠNex us +Ġdefend ants +ĠCat al +Ġdis hes +sh aped +Ġpro long +m t +( $ +ãĢ Ĥ +Ġcalcul ations +ĠS ame +Ġp iv +H H +Ġcance lled +Ġgr in +Ġterrit ories +ist ically +C ome +ĠP arent +Pro ject +Ġneg lig +ĠPriv acy +Ġam mo +LE CT +olute ly +ĠEp ic +Ġmis under +w al +Apr il +m os +path y +ĠC arson +Ġalbum s +ĠE asy +Ġpist ol +< < +Ġ\ ( +t arget +hel p +Ġinter pre +cons cious +ĠH ousing +ĠJ oint +12 7 +Ġbe ers +s cience +ĠFire fox +effect ive +ĠC abin +ĠO kay +ĠApp lic +Ġspace craft +ĠS R +ve t +ĠStr ange +S B +Ġcor ps +iber al +e fficient +Ġpreval ence +Ġeconom ists +11 8 +Th read +ord able +OD E +ĠC ant +=- =- +if iable +ĠA round +Ġpo le +Ġwilling ness +CL A +ĠK id +Ġcomple ment +Ġsc attered +Ġin mates +Ġble eding +e very +Ġque ue +ĠTr ain +Ġh ij +Ġme lee +ple ted +Ġdig it +Ġg em +offic ial +Ġlif ting +Ð µ +Re qu +it utes +Ġpack aging +ĠWork ers +h ran +ĠLeban on +ol esc +Ġpun ished +ĠJ uan +Ġj am +ĠD ocument +Ġm apping +ic ates +Ġinev itably +Ġvan illa +ĠT on +Ġwat ches +Ġle agues +Ġiniti ated +deg ree +port ion +Ġrec alls +Ġru in +Ġm elt +I AN +Ġhe m +Ex p +Ġb aking +ĠCol omb +at ible +Ġrad ius +pl ug +ĠI F +et ically +Ġf ict +H ER +ĠT ap +atin um +Ġin k +Ġco h +ĠW izard +b oth +te x +Ġsp ends +ĠCurrent ly +ĠP it +Ġneur ons +ig nt +Ġr all +Ġbus es +b uilding +Ġadjust ments +Ġc ried +ibl ical +att ed +ĠZ ion +ĠM atter +Ġmed itation +ĠD ennis +Ġour s +ĠT ab +Ġrank ings +ort al +Ġad vers +Ġsur render +ĠG ob +ci um +om as +im eter +Ġmulti player +Ġhero in +Ġoptim istic +Ġindic ator +ĠBr ig +Ġgro cery +Ġapplic ant +ĠRock et +v id +Ex ception +p ent +Ġorgan izing +Ġenc ounters +ĠT OD +Ġjew el +S ave +ĠChrist ie +Ġhe ating +Ġl azy +ĠC P +Ġcous in +Con fig +Ġreg ener +Ġne arest +Ġachie ving +EN S +th row +ĠRich mond +ant le +200 2 +Ġan ten +b ird +13 3 +Ġn arc +r aint +un ny +ĠHispan ic +ourn aments +Ġprop he +ĠTh ailand +ĠT i +Ġinject ion +Ġinher it +rav is +Ġmed i +Ġwho ever +ĠDE BUG +G P +ĠH ud +C ard +p rom +Ġp or +Ġover head +L aw +Ġviol ate +Ġhe ated +Ġdescript ions +Ġachieve ments +ĠBe er +ĠQu ant +W as +Ġe ighth +ĠI v +Ġspecial ized +U PDATE +ĠD elta +P op +J ul +ĠAs k +oph y +Ġnews letters +ĠT ool +Ġg ard +ĠConf eder +ĠGM T +ĠAb bott +Ġimm unity +ĠV M +Is lam +Ġimpl icit +w d +Ġ19 44 +rav ity +omet ric +Ġsurv iving +ur ai +ĠPr ison +Ġr ust +ĠSk etch +Ġbe es +ĠThe ory +Ġmer it +T ex +ch at +Ġm im +Ġpast e +ĠK och +Ġignor ance +ĠSh oot +Ġbas ement +Un ited +ĠAd vis +he ight +Ġf oster +Ġdet ain +in formation +Ġne ural +' ; +Ġprov es +all ery +Ġinv itation +um bers +Ġc attle +Ġbicy cle +z i +Ġconsult ant +Ġap ology +ĠT iger +Ġ12 3 +99 9 +Ġind ividually +r t +ig ion +ĠBrazil ian +Ġdist urb +Ġentreprene urs +Ġfore sts +cer pt +pl ates +p her +clip se +Ġtw itter +Ġac ids +ograph ical +h um +ĠB ald +if ully +Ġcomp iler +ĠD A +Ġdon or +as i +Ġtrib al +l ash +ĠCon fig +Ġapplic ants +Ġsal aries +13 5 +Put in +ĠF ocus +ir s +Ġmisc onduct +ĠH az +Ġeat en +M obile +Mus lim +ĠMar cus +v iol +Ġfavor able +Ġst ub +ad in +ĠH ob +Ġfaith ful +Ġelectron ics +Ġvac uum +w ait +back ed +econom ic +d ist +Ġten ure +Ġsince re +ĠT ogether +ĠW ave +Ġprog ression +Ġden ying +Ġdist ress +br aska +th ird +Ġmix ing +Ġcolon ial +Ġpriv ately +Ġun rest +atern ity +Ġprem ises +ant i +greg ation +Ġlic ence +ĠH ind +ĠSam uel +Ġconvinc ing +ĠA ce +ĠR ust +ĠNet anyahu +Ġhand les +ĠP atch +orient ed +ah o +ĠG onz +Ġhack ers +claim er +Ġcustom s +ĠGr an +f ighters +Ġl uc +Ġman uscript +aren thood +Ġdev il +Ġwar riors +Ġoff enders +Will iam +Ġhol idays +Ġnight mare +Ġle ver +iff erent +St at +Ġexhib ition +put ed +ĠP ure +Ġal pha +Ġenthus iasm +ĠRepresent atives +E AR +ĠT yp +Ġwhe at +ĠAl f +Ġcor rection +Ġev angel +AT T +M iss +Ġs oup +Ġimpl ied +par am +Ġsex y +ĠL ux +Ġrep ublic +p atch +ab lish +Ġic ons +Ġfather s +ĠG ET +ĠCar ib +Ġregul ated +ĠCo hen +ĠBob by +Ġn er +Ġb ent +vent ory +ĠAl ong +ĠE ST +ĠWall ace +Ġmurd ers +r ise +ke ll +ĠCommon wealth +Ġn asty +et a +ĠM IT +Ġadminist ered +Ġgenuine ly +Ed itor +n ick +Ġhyd ro +**************** **************** +ĠB le +Ġfin es +Ġg orge +aus ible +r h +Ġapp le +ment ioned +Ġro pe +ot yp +H R +Ġdisappoint ing +Ġc age +n ik +Ġdoub ts +ĠF REE +print s +ĠM UST +Ġvend ors +ĠIn qu +Ġliber als +Ġcontract or +Ġup side +child ren +Ġtrick y +Ġregul ators +charg ed +l iter +Ġ *** +Ġreb ell +l ang +Ġloc als +Ġphys icians +Ġhe y +ar se +t m +ĠLe x +Ġbehavior al +success ful +F X +Ġbr ick +ov ic +Ġcon form +Ġreview ing +Ġins ights +Ġbi ology +ĠRem ove +ĠExt ra +Ġcomm itting +indu ced +ignt y +ig m +Ġat omic +Comm on +ĠE M +ĠP ere +ĠIt ems +e h +Ġpres erved +ĠH ood +Ġprison er +Ġbankrupt cy +Ġg ren +us hes +Ġexplo itation +Ġsign atures +Ġfin an +] ," +ĠM R +Ġme g +rem lin +Ġmusic ians +Ġselect ing +Ġexam ining +IN K +l ated +H i +Ġart ic +Ġp ets +Ġimp air +ĠM AN +Ġtable ts +in clude +R ange +Ġca ut +Ġlog s +Ġmount ing +Ġun aware +Ġdynam ics +ĠPalest ine +ĠQu arter +ĠPur ple +Ġm a +ĠIm port +Ġcollect ions +ci ation +Ġsuccess or +Ġcl one +Ġaim ing +Ġposs essed +Ġstick ing +Ġsh aking +Ġloc ate +ĠH ockey +T urn +17 0 +Ġfif teen +ĠHar rison +Ġcontinu ously +ĠT C +ĠVal ent +ĠRes cue +Ġby pass +am ount +Ġm ast +Ġprotect s +Ġart istic +Ġsomet ime +Ġsh oe +Ġshout ed +ific ant +et itive +ĠReg ister +ĠJ in +Ġconcent rated +ling ton +on ies +Ġgener ator +yr im +ĠAr men +Ġclear ing +id o +ĠT W +al ph +Ġlad ies +H ard +Ġdial og +Ġinput s +æ ľ +Ġpos es +Ġsl ots +ĠPrem ium +Ġle aks +Ġboss es +Ġ11 3 +c ourse +A cc +ĠNew ton +ĠAust ria +ĠM age +Ġte aches +ab ad +Ġwe ars +Ġc yl +Ġcur se +ĠS ales +ĠW ings +Ġp sy +Ġg aps +ĠIce land +ĠP interest +Ġland lord +Ġdefin itions +ĠK er +Ġsufficient ly +ĠP ence +ĠArch itect +Ġsur pass +Ġ11 4 +Ġsuper hero +ĠDise ase +Ġpri ests +ĠC ulture +Ġdefin itive +Ġsecret ly +ĠD ance +inst all +ch ief +ĠJess ica +W ould +Up dated +Ġlock er +ĠK ay +Ġmem orial +è ¦ +f at +Ġdis gu +Ġflav ors +ĠBase ball +ĠRes istance +Ġk icks +Ġen v +Ġteen agers +D ark +ĠC AR +Ġh alt +ĠL G +ĠGab riel +Ġfe ver +Ġs atur +Ġm all +Ġaffili ate +ĠS leep +ĠSpe cific +ĠV el +Ġj ar +ĠSac red +ĠEd wards +ĠA CL +Ġret ained +ĠG iant +Ġlim itation +in ces +Ġref usal +ĠT ale +ĠBut ler +Ġacc idents +ĠC SS +Ġimport ed +ĠCop y +Î ± +ER T +z el +Ġdiv isions +h ots +ĠAl b +ĠD S +Load er +W ashington +at isf +ĠCreat ive +\ . +ĠAut om +red ict +Ġrecept or +ĠCarl os +Met hod +ok a +Ġmal icious +Ġste pping +, [ +ĠD ad +Ġatt raction +ĠEffect s +ĠPir ate +ĠC er +ĠIndust ry +ĠR ud +Ġchar ter +Ġd ining +Ġins ists +Ġconfig ure +Ġ( # +ĠSim ple +ĠSc roll +UT C +17 5 +ĠK on +Ġmarket place +Ġ ãĤ +Ġref res +Ġg ates +er red +ĠP od +Ġbeh ave +Fr ank +n ode +Ġendors ed +he tt +as ive +ĠHom eland +Ġr ides +ĠLe ave +er ness +Ġflood ing +A FP +Ġris en +Ġcontin ually +Ġun anim +ĠCont ract +ĠP as +Ġgu ided +ĠCh ile +b d +Ġsu cc +pt ic +Ġcomm ittees +ĠL uther +ĠAny one +Ġs ab +12 4 +Ġp ixel +ĠB ak +ĠT ag +ĠBenn ett +En ter +sm all +ĠPresident ial +Ġp ul +Ġcontr ace +arch ive +Ġcoast al +ĠK ids +19 2 +âĢ ² +ick y +ING TON +Ġw olf +ĠSt alin +T ur +id get +am as +ĠUn less +Ġspons or +Ġmor ph +ĠCho ose +Ġrun ner +Ġun bel +Ġm ud +ĠMan a +Ġdub bed +Ġg odd +ure rs +wind ow +Ġrel ied +Ġcelebr ating +os c +Ġ13 5 +Ġlobb ying +Ġincom plete +Ġrestrict ion +Ġinc ap +it us +Ġexpect ation +ĠAp ollo +Ġint ens +Ġsyn c +G H +Ġmanip ulation +B Y +Ġspe ar +Ġbre asts +Ġvol can +il ia +M aterial +Ġform ats +ĠB ast +Ġparliament ary +Ġsn ake +Ġserv ants +ĠTr udeau +ĠGr im +ĠArab ic +ĠSC P +ĠBoy s +st ation +Ġprospect ive +ord e +in itialized +Ġb ored +AB LE +Ġaccess ed +Ġtax i +ĠShe ll +aid en +urs ed +in ates +ĠIns urance +ĠPet e +Sept ember +6 50 +Ġad ventures +ĠCo ver +Ġt ribute +Ġsk etch +Ġem power +Ġ Ø +ĠGl enn +ĠD aw += \" +ĠPolit ics +Ġgu ides +Ġd ioxide +ĠG ore +ĠBr ight +ĠS ierra +Ġval ued +c ond +Ġpo inter +Se lect +Ġrisk y +Ġabsor b +im ages +Ġref uses +Ġbon uses +__ _ +Ġh ilar +ĠF eatures +2 20 +ĠCollect or +F oot +Ġ19 64 +cul us +Ġd awn +Ġwork out +ĠL O +Ġphilosoph ical +ĠSand y +ĠYou th +Ġl iable +A f +bl ue +Ġovert urn +less ness +ĠTrib une +ĠIn g +Ġfact ories +Ġcat ches +Ġpr one +Ġmat rix +Ġlog in +Ġin acc +Ġex ert +s ys +Ġneed le +ĠQ ur +Ġnot ified +ould er +t x +Ġremind s +Ġpublisher s +Ġn ort +Ġg it +Ġfl ies +ĠEm ily +Ġflow ing +ĠAl ien +ĠStr ateg +Ġhard est +Ġmod ification +AP I +ĠM Y +Ġcr ashes +st airs +n umber +Ġur ging +ch annel +ĠFal con +Ġinhabit ants +Ġterr ifying +Ġutil ize +Ġban ner +Ġcig arettes +Ġsens es +ĠHol mes +Ġpract ition +ĠPhill ips +ott o +Ġcomp ile +Mod el +ĠK o +Ġ[ ] +Americ ans +ĠTer ms +Ġmed ications +ĠAn a +Ġfundament ally +ĠNot ice +Ġwe aker +Ġ 0000 +Ġgar lic +Ġout break +Ġeconom ist +ĠB irth +Ġobst acles +ar cer +ĠOr thodox +Ġplace bo +ĠC rew +asp berry +ĠAng els +Ġdis charge +Ġdestruct ive +11 7 +ĠR ising +Ġd airy +l ate +Ġcoll ision +ĠTig ers +ean or +ocument ed +ĠIn valid +Ġd ont +ĠL iter +ĠV a +Ġhyd rogen +Ġvari ants +ĠBrown s +Ġ19 65 +Ġind igenous +Ġtrad es +Ġremain der +Ġswe pt +ĠImp act +Ġred ist +Ġun int +grad uate +ãĥ ķ +ĠW ILL +ãģ® ç +ĠCrit ical +Ġf isher +Ġv icious +Ġrevers ed +Y ear +ĠS ox +Ġshoot ings +Ġfil ming +Ġtouchdown s +ai res +m el +Ġgrand father +Ġaffect ion +ing le +Ġover ly +Add itional +Ġsup reme +ĠGr ad +Ġsport ing +Ġmer cy +ĠBrook s +ount y +Ġperform s +Ġtight ly +Ġdem ons +Ġkill ings +Ġfact ion +ĠNov a +aut s +Ġund oubtedly +ar in +Ġunder way +ra k +Ġl iv +ĠReg ion +Ġbrief ing +s ers +cl oud +ĠM ik +us p +Ġpred iction +az or +Ġport able +ĠG and +Ġpresent ing +Ġ10 80 + » +ush i +ĠSp ark +there um +Ġjust ification +ĠN y +Ġcontract ors +ming ham +ĠSt yle +å ħ +ĠChron icles +ĠPict ure +Ġprov ing +Ġw ives +set t +Ġmole cules +ĠFair y +Ġconsist ing +Ġp ier +al one +in ition +Ġn ucle +j son +Ġg otta +Ġmob il +Ġver bal +ar ium +Ġmon ument +uck ed +Ġ25 6 +T ech +mine craft +ĠTr ack +Ġt ile +Ġcompat ibility +as is +Ġs add +Ġinstruct ed +ĠM ueller +Ġle thal +Ġhorm one +Ġor che +el se +Ġske let +Ġentert aining +Ġminim ize +ag ain +Ġunder go +Ġconst raints +Ġcig arette +ĠIslam ist +Ġtravel s +ĠPant hers +l ings +C are +Ġlaw suits +ur as +Ġcry st +Ġlow ered +Ġaer ial +Ġcomb inations +Ġha un +Ġch a +Ġv ine +Ġquant ities +Ġlink ing +b ank +Ġso y +B ill +ĠAngel a +Ġrecip ient +ĠProt est +Ġs ocket +Ġsolid arity +Ġâ Ĩ +m ill +Ġvar ies +ĠPak istani +Dr agon +Ġun e +Ġhor izon +³³³³ ³³³³ +Ġprov inces +Ġfrank ly +Ġenact ed +not es +[ ' +Ġ19 2 +ocr acy +Ġendorse ment +Ġover time +Tr ue +L ab +lic ted +ĠD NC +Ġbe ats +ĠJam ie +15 2 +ĠIN T +Cont act +Ġaccount ed +h ash +ĠPack ers +p ires +Ġles bian +Ġamend ments +Ġhop eful +ĠFin land +Ġspot light +Ġconfig ured +Ġtrou bled +Ġg aze +ĠCal gary +Ġrel iability +Ġins urg +sw er +b uy +ĠSk in +Ġp ixels +Ġhand gun +Ġpar as +Ġcateg or +ĠE L +ĠRe x +Ind eed +Ġkind a +Ġconj unction +ĠBry an +ĠMan ufact +y ang +Pl us +S QL +ish ment +Ġdom inate +Ġn ail +Ġo ath +Ġeru pt +ĠF ine +it bart +ĠCh ip +ĠAb d +ĠN am +Ġbuy er +Ġdiss ent +Le aks +Cont in +Ġr ider +ĠSome one +Ġill usion +c in +ĠBoe ing +Ġin adequ +ov ation +i ants +Ġreb uild +4 50 +ĠDest iny +S W +ĠT ill +H it +ia z +ĠBang l +acher s +ĠRe form +Ġse gments +Ġsystem atic +d c +ĠConserv atives +Ġport al +h or +ĠDragon bound +Ġdrag ged +om o +Ġthe e +ad vert +ĠRep orts +ĠE t +Ġbarrel s +Aug ust +Ġcompar isons +Ġhe x +Ġan throp +" [ +bor ough +ab i +Ġpict ured +play ing +ĠAdd ress +ĠMir ror +Sm ith +Ġt ires +ĠN PR +AA AA +Ġclass ification +ĠTh an +ĠH arm +ĠR A +Ġreject ion +min ation +Ġr anged +ĠF alls +D I +H ost +ãĤ ´ +ĠEx ample +list ed +th irds +Ġsaf egu +br and +Ġprob able +Can ada +IT ION +ĠQ aeda +Ġch ick +Ġimport s +h it +l oc +W W +Ġble w +Ġany time +Ġwh oles +ik ed +Ġcal culation +cre ate +ĠO ri +Ġupgr aded +Ġapp ar +ut ory +ĠM ol +B rit +ĠJ ong +IN AL +ĠStart ing +Ġd ice +urt le +Ġre lying +cl osure +Ġprof itable +Ġsl aughter +ĠMan ual +c aster +Ġ" $ +Ġfe ather +ĠSim ply +ie ves +Ġdeter ior +ĠPC I +Ġst amp +Ġfl aws +Ġsh ade +ham mer +Ġpass port +Ġcont ing +am el +Ġobser vers +Ġneg lect +ĠR B +ĠBrother hood +Ġskept ical +f amily +us k +Ġemotion ally +â Ļ +ĠBet a +ason able +id ity +ĠM ul +Ġkick ing +ĠC arm +oll ah +VERT IS +ĠAt hen +Ġlad der +ĠBul let +å £ +00 01 +ĠWild life +ĠM ask +ĠN an +R ev +Ġun acceptable +leg al +Ġcrowd ed +ag i +ĠC ox +j e +Ġmor ality +Ġfu els +Ġc ables +Ġman kind +ĠCarib bean +Ġanch or +Ġby te +ĠO ften +ĠO z +Ġcraft ed +Ġhistor ian +ĠW u +Ġtow ers +ĠCitiz ens +Ġhel m +Ġcred entials +Ġsing ular +ĠJes se +Ġtack les +Ġcont empt +Ġa fore +ĠSh adows +Ġn il +Ġur gent +app le +bl ood +Ġv on +Ġoff line +Ġbreat he +Ġj umps +Ġirre levant +ox ic +om al +import ant +J im +Ġgl oves +arm ing +dep th +Ġtal ents +ook ie +ĠS B +Ġpal m +uff s +est a +IG H +Ġcan on +ĠVer izon +ĠP le +Ġcou pled +vel t +Ġfundra ising +ĠGet ting +ĠD LC +Ġmathemat ical +ĠH S +ĠCard inals +te lling +Ġspons ors +Ġ Ï +ĠBull s +op tion +Ġprop ose +Ġmem orable +Ġembr aced +Ġdecl ining +He alth +ed a +Ġ} ; +Ġsp am +m ile +Ġpit cher +ĠE ight +Ġcar ing +ut ic +ro le +Ġair line +ernand ez +ĠAth let +Ġcert ification +ux e +rig er +Ġem pir +Ġsens ation +Ġdis m +Ġb olt +Ġev olve +H ouse +Ġconsult ation +ĠD uty +Ġtou ches +ĠN athan +Ġf aint +h ad +" ( +ĠCons umer +ĠExt reme +Ġ12 7 +ĠHer m +ĠSac rament +iz oph +Ġanx ious +ul ously +Ġsoc ially +ĠU TC +Ġsol ving +ĠLet ter +Hist ory +ed uc +Pr ice +) ); +Ġrel oad +am ic +Ġp ork +Ġdisc ourse +Ġt ournaments +ai ro +ĠK ur +ĠCost a +Ġviol ating +Ġinterf ere +Ġrecre ational +uff le +Ġspe eches +Ġneed ing +Ġremem bers +Ġcred ited +n ia +f ocused +amer a +Ġb ru +um bs +ĠCub an +Ġpreced ing +Ġnons ense +ac ial +Ġsmart phones +ĠSt ories +S ports +ĠEmer gency +oun cing +ef ined +Ġb er +Ġconsult ing +Ġm asters +he astern +." [ +ĠRun ning +Ġsus cept +ĠF eng +Americ a +pr ises +st itial +ĠWeek ly +ĠGreat er +mod ules +if ter +G raphics +ul er +Ġwho lly +Ġsupp ress +Ġconce aled +Ġhapp ily +Ġaccept s +ĠEn joy +Ġr ivers +ĠEx cept +2 25 +ĠN HS +ĠMc Connell +Ġp ussy +fer red +ut able +Ġatt ain +Ġ> = +Ġdepos its +roph ic +Ġnot orious +ĠSh aw +il itation +Ġepid emic +all ic +Ġsmall est +ov ich +Ġaccess ories +per ties +Ġsur plus +ĠMe ch +Ġamb ig +ĠImm igration +Ġch im +ev al +Ġpract icing +ĠMyster y +Ġdom ains +ĠSil icon +app s +Ġkilomet ers +e a +ĠSm ash +Ġwarrant y +Ġn ost +s il +re v +J on +ĠDub lin +Ġtast es +Ġb out +g reat +er ror +Ġsw itches +ĠB apt +D O +ok i +Ġsour ced +pro du +Ġattach ment +ĠIss ue +ĠQuest ion +Jo in +Ġf itted +Ġunlaw ful +^ ^ +ere k +Ġauthent ication +Ġst ole +Ġaccount ability +l abel +S earch +Ġal beit +atic an +fund ed +ĠAdd ing +ĠI Q +Ġsub mar +l it +a que +ĠLear ning +Ġint eger +M aster +ĠCh rom +Ġprem ier +O p +ĠLi u +Ġbl essed +ĠGl obe +ĠResp onse +Ġlegit im +ĠMer kel +Ġdispos al + ´ +Ġgau ge +pe at +Ġindu ced +Ġquestion able +arth y +ĠV it +ĠF eed +U ntil +U t +worth y +R Y +ĠH erald +ĠHam mer +Ġmed al +ĠR ivers +ĠH ack +Ġclar ify +Ġtrack ed +Ġautonom ous +Ġten ant +ĠQ atar +er ie +Ġgr im +ĠMon itor +Ġresist ant +ĠSpe c +ĠWell s +N AS +14 8 +Ġmin ers +iot ics +Ġmiss es +11 6 +g ian +g it +ĠE yes +p res +Ġgrad uated +Ġang el +Ġsyn chron +Ġefficient ly +Ġtrans mitted +H arry +Ġglob ally +EN CE +ĠMont ana +r aged +ĠPre vention +Ġp iss +ĠL l +Ġshe lf +ĠB JP +ĠTest ament +ĠL ate +ik er +ĠH app +ĠJul ian +h all +Ġsp ont +Ġshut down +Ġincons istent +Ġsubscrib ers +Ġske leton +ĠNe braska +Ġins pire +ĠV oid +F eed +Ġang les +ĠSpr ings +Ġbench mark +Ġvacc ines +izoph ren +se xual +uff ed +Ġsh ine +ĠK ath +Ġgest ure +ine a +Ġr ip +Ġopp ression +Ġcons cience +b t +ĠL um +Ġinc idence +ĠF a +w r +Ġmin eral +ĠSp urs +alk y +Ġth under +Ġop io +Be ing +ĠPal m +Ġwas ted +Ġl b +i aries +ĠIniti ative +Ġcur ric +Ġmark er +ĠMc L +Ġext ensions +ĠP v +ĠAr ms +Ġoffer ings +Ġdef enses +Ġvend or +Ġcontrad ict +ĠCol in +Ġredd it +Ġper ipher +12 2 +Ġs ins +E dit +IC T +So ft +ĠSh ah +Ġadministr ator +ĠT rip +Ġporn ography +Ġtu ition +in ence +ĠPro gress +Ġcat alog +Ġsu ite +Ġh ike +Ġreprodu ctive +eng ine +Ġd rought +ĠNo ah +Ġ2 30 +Ġd ude +Ġrelax ed +Ġpart ition +Ġparticip ant +Ġtel esc +Ġfe as +ĠF F +own er +Ġswe eping +Ġl enses +Ġmatch up +ĠRe pl +ourn als +Ġcred ible +Ġgrand mother +Ġther mal +Ġsubscrib ing +Ġident ities +col m +U CT +Ġreluct ant +us ers +ĠC ort +Ġassist ed +OS S +ATION S +IS H +Ġpharm aceutical +ic able +ad ian +ĠSon ic +ĠF ury +ĠM ong +A H +ĠPsych ology +Ġph osph +Ġtreat s +Ń Ķ +Ġstead ily +ĠHell o +Ġrel ates +Ġcl ue +Ex pl +a uth +Ġrev ision +Ġe ld +os ion +Ġbr on +14 4 +ri kes +Ġmin es +Ġblank et +ĠF ail +el ed +ĠIm agine +ĠPl anned +a ic +Re quest +M ad +ĠHor se +ĠEag le +Ġcap ac +15 7 +Ġl ing +ĠN ice +ĠP arenthood +min ster +og s +ens itive +Not hing +Ġcar n +F in +ĠP E +Ġr ifles +ĠL P +S and +Ġgui Active +Ġtour ist +C NN +Ġunve iled +Ġpredec essor +} { +u ber +Ġoff shore +Ġopt ical +ĠR ot +ĠPear l +et on +Ġst ared +Ġfart her +at ility +cont in +ĠG y +ĠF oster +ĠC oc +ri ents +Ġdesign ing +ĠEconom y +ON G +W omen +ĠN ancy +er ver +Ġmas cul +Ġcasual ties +Ġ2 25 +ĠS ullivan +ĠCh oice +Ġa ster +w s +Ġhot els +Ġconsider ations +Ġcou ch +ĠSt rip +ĠG n +Ġmanip ulate +l ied +Ġsynt hetic +Ġassault ed +Ġoff enses +ĠDra ke +Ġim pe +Oct ober +ĠHer itage +h l +ĠBl air +Un like +Ġg rief +Ġ4 50 +Ġopt ed +Ġresign ation +il o +Ġver se +ĠT omb +Ġu pt +Ġa ired +ĠH ook +ĠML B +Ġassum es +out ed +ĠV ers +Ġinfer ior +Ġbund le +ĠD NS +ograp her +Ġmult ip +ĠSoul s +Ġillust rated +Ġtact ic +Ġdress ing +Ġdu o +Con f +Ġrel ent +Ġc ant +Ġscar ce +Ġcand y +ĠC F +Ġaffili ated +Ġspr int +yl an +ĠGarc ia +Ġj unk +Pr int +ex ec +C rit +Ġport rait +ir ies +ĠOF F +Ġdisp utes +W R +L ove +ãģ Ħ +ĠRe yn +Ġh ipp +op ath +Ġflo ors +ĠFe el +Ġwor ries +Ġsett lements +ĠP os +Ġmos que +Ġfin als +Ġcr ushed +ĠPro bably +ĠB ot +ĠM ans +ĠPer iod +Ġsovere ignty +Ġsell er +Ġap ost +Ġam ateur +Ġd orm +Ġconsum ing +Ġarm our +ĠRo ose +Ġint ensive +Ġelim inating +ĠSun ni +ĠAle ppo +j in +Ġadv ise +p al +ĠH alo +Ġdes cent +Ġsimpl er +Ġbo oth +ST R +L ater +ĠC ave +== = +Ġm ol +Ġf ist +Ġshot gun +su pp +Ġrob bery +E ffect +Ġobsc ure +ĠProf essional +Ġemb assy +Ġmilit ant +Ġinc arcer +Ġgener ates +Ġlaun ches +Ġadministr ators +Ġsh aft +Ġcirc ular +Ġfresh man +ĠW es +ĠJo el +ĠD rew +ĠDun can +ĠApp arently +s ight +ĠIntern al +ĠInd ividual +ĠF E +Ġb ore +ĠM t +Ġbroad ly +ĠO ptions +ount ain +ip es +ĠV ideos +20 4 +Ġh ills +Ġsim ulation +Ġdisappoint ment +it an +ĠLabor atory +Ġup ward +Ġbound ary +Ġdark er +h art +Ġdomin ance +C ong +ĠOr acle +ĠL ords +Ġscholars hip +ĠVin cent +ed e +ĠR ah +Ġencour ages +ro v +Ġqu o +Ġprem ise +ĠCris is +ĠHol ocaust +Ġrhyth m +Ġmet ric +cl ub +Ġtransport ed +Ġn od +ĠP ist +Ġancest ors +ĠFred er +th umbnails +ĠC E +ON D +Ph il +ven ge +ĠProduct s +cast le +Ġqual ifying +ĠK aren +VERTIS EMENT +Ġmight y +Ġexplan ations +Ġfix ing +D i +Ġdecl aring +Ġanonym ity +Ġju ven +ĠN ord +ĠDo om +ĠAct ually +O k +ph is +ĠDes ert +Ġ11 6 +I K +ĠF M +Ġinc omes +V EL +ok ers +Ġpe cul +Ġlight weight +g ue +Ġacc ent +Ġincre ment +ĠCh an +Ġcompl aining +ĠB aghd +Ġmidfield er +Ġover haul +Pro cess +ĠH ollow +ĠTit ans +Sm all +man uel +ĠUn ity +ĠEv ents +S ty +Ġdispro portion +n esty +en es +ĠC od +Ġdemonstr ations +ĠCrim son +ĠO H +Ġen rolled +Ġc el +ĠBre tt +Ġa ide +Ġhe els +Ġbroad band +Ġmark ing +Ġw izard +ĠN J +ĠChief s +Ġingred ient +Ġd ug +ĠSh ut +urch ase +end or +Ġfar mer +ĠGold man +12 9 +15 5 +Or der +Ġl ion +i ably +Ġst ain +ar ray +ilit ary +ĠFA Q +Ġexpl oded +ĠMcC arthy +ĠT weet +ĠG reens +ek ing +l n +ens en +Ġmotor cycle +Ġpartic le +Ġch olesterol +B ron +Ġst air +Ġox id +Ġdes irable +ib les +Ġthe or +for cing +Ġpromot ional +ov o +b oot +ĠBon us +raw ling +Ġshort age +ĠP sy +Ġrecru ited +Ġinf ants +Ġtest osterone +Ġded uct +Ġdistinct ive +Ġfirm ware +bu ilt +14 5 +Ġexpl ored +Ġfact ions +Ġv ide +Ġtatt oo +Ġfinan cially +Ġfat igue +Ġproceed ing +const itutional +Ġmis er +Ġch airs +gg ing +ipp le +Ġd ent +Ġdis reg +ç Ķ +st ant +ll o +b ps +aken ing +Ġab normal +ĠE RA +å£ « +ĠH BO +ĠM AR +Ġcon cess +Ġserv ant +Ġas pir +l av +ĠPan el +am o +Ġprec ip +Ġrecord ings +Ġproceed ed +Ġcol ony +ĠT ang +ab lo +Ġstri pped +Le ft +to o +Ġpot atoes +Ġfin est +% ). +Ġc rap +ĠZ ach +ab ases +ĠG oth +Ġbillion aire +w olf +Ġsan ction +S K +Ġlog ged +P o +ey ed +un al +Ġcr icket +Ġarm ies +Ġunc overed +Cl oud +ó n +Ġreb ounds +Ġm es +O per +P ac +Ġnation ally +Ġinsert ed +p ict +Ġgovern ance +Ð ¸ +Ġprivile ges +G ET +Ġfavor ites +im ity +Ġlo ver +the m +em pl +Ġgorge ous +An n +Ġsl ipped +Ġve to +B ob +Ġsl im +u cc +ĠF ame +udden ly +Ġden ies +ĠM aur +Ġdist ances +Ġw anna +t ar +ĠS ER +Ġâ Ī +Ġle mon +at hetic +Ġlit eral +Ġdistingu ished +Ġansw ering +G I +Ġrelig ions +ĠPhil os +ĠL ay +Ġcomp os +ire ments +ĠK os +ine z +roll ing +Ġyoung est +and ise +ĠB orn +Ġalt ar +am ina +ĠB oot +v oc +Ġdig ging +Ġpress ures +Ġl en +26 4 +Ġassass ination +ĠBir mingham +ĠMy th +Ġsovere ign +ĠArt ist +ĠPhot ograph +Ġdep icted +Ġdisp ens +orth y +Ġamb ul +int eg +ĠC ele +ĠTib et +Ġhier archy +Ġc u +Ġpre season +ĠPet erson +Ġcol ours +Ġworry ing +Ġback ers +ĠPal mer +ĠÎ ¼ +Ġcontribut or +Ġhear ings +Ġur ine +Ġ Ù +ourge ois +Sim ilar +ĠZ immer +s omething +ĠUS C +Ġstrength s +ĠF I +Ġlog ging +As ked +ĠTh ai +in qu +ĠW alt +Ġcrew s +it ism +3 01 +Ġshar ply +um ed +Ġred irect +r ators +In f +ĠWe apons +Ġte asp +19 99 +L ive +ĠEs pecially +ĠS ter +ĠVeter ans +Ġint ro +other apy +Ġmal ware +Ġbre eding +Ġmole cular +ĠR oute +ĠCom ment +oc hem +Ġa in +Se ason +Ġlineback er +Ä « +ĠEconom ics +es ar +ĠL ives +ĠEm ma +Ġk in +ĠTer rit +Ġpl anted +ot on +ĠBut ter +ĠSp ons +P ER +Ġdun geon +Ġsymb olic +Ġfil med +Ġdi ets +Ġconclud es +Ġcertain ty +ĠForm at +Ġstr angers +form at +ĠPh ase +Ġcop ied +Ġmet res +ld a +ĠUs ers +Ġdeliber ate +Ġwas hed +ĠL ance +im ation +Ġimpro per +ĠGen esis +ick r +ĠK ush +Ġreal ise +Ġembarrass ing +alk ing +b ucks +Ġver ified +Ġout line +year s +ĠIn come +20 2 +Ġz ombies +F inal +ĠMill enn +Ġmod ifications +ĠV ision +ĠM oses +ver b +iter ranean +ĠJ et +Ġnav al +ĠA gg +Ġur l +Ġvict ories +Ġnon etheless +Ġinj ust +ĠF act +ç ļ +Ġins ufficient +re view +face book +Ġnegoti ating +Ġguarant ees +im en +uten berg +Ġg ambling +Ġcon gr +Load ing +Ġnever theless +Ġpres idents +ĠIndust rial +Ġ11 8 +Ġp oured +ĠT ory +Ġ17 5 +Ġ: = +Sc ott +ange red +T ok +Ġorgan izers +M at +ĠG rowth +Ġad ul +Ġens ures +Ġ11 7 +é¾į å +Ġmass acre +Ġgr ades +be fore +AD VERTISEMENT +ĠSl ow +ĠM MA +âĢĶ " +ĠV atican +Q aeda +Ġo we +66 66 +ĠS orry +ĠGr ass +Ġbackground s +Ġexha usted +Ġcl an +Ġcomprom ised +ĠE lf +ĠIsa ac +ens on +In vest +IF A +Ġinterrupt ed +ãĥī ãĥ© +Ġtw isted +ĠDrag ons +M ode +ĠK remlin +Ġfert il +he res +ph an +ĠN ode +f ed +ĠOr c +Ġunw illing +C ent +Ġprior it +Ġgrad uates +Ġsubject ive +Ġiss uing +ĠL t +Ġview er +Ġw oke +Th us +bro ok +Ġdep ressed +Ġbr acket +ĠG or +ĠFight ing +Ġstri ker +Rep ort +ĠPortug al +Ġne o +w ed +19 9 +Ġflee ing +sh adow +ident ified +US E +Ste am +Ġstret ched +Ġrevel ations +art ed +ĠD w +Ġalign ment +est on +ĠJ ared +S ep +Ġblog s +up date +g om +r isk +Ġcl ash +ĠH our +Ġrun time +Ġunw anted +Ġsc am +Ġr ack +Ġen light +on est +ĠF err +Ġconv ictions +Ġp iano +Ġcirc ulation +ĠW elcome +Ġback lash +ĠW ade +Ġrece ivers +ot ive +J eff +Ġnetwork ing +ĠPre p +ĠExpl orer +Ġlect ure +Ġupload ed +ĠMe at +B LE +ĠNaz is +ĠSy nd +st ud +ro ots +ri ans +Ġportray ed +Ġ ?? +ĠBudd ha +s un +Rober t +ĠCom plex +Ġover see +Ġste alth +T itle +ĠJ obs +ĠK um +Ġappreci ation +ĠM OD +Ġbas ics +Ġcl ips +Ġnurs ing +Ġpropos ition +Ġreal ised +ĠNY C +Ġall ocated +ri um +ar an +ĠPro duction +ĠV ote +Ġsm ugg +Ġhun ter +az er +ĠCh anges +Ġfl uct +y on +Ar ray +Ġk its +W ater +Ġuncom mon +Ġrest ing +ell s +w ould +Ġpurs ued +Ġassert ion +omet own +ĠMos ul +ĠPl atform +io let +Ġshare holders +Ġtra ils +P ay +ĠEn forcement +ty pes +ĠAn onymous +Ġsatisf ying +il ogy +Ġ( ' +w ave +c ity +Ste ve +Ġconfront ation +ĠE ld +C apt +ah an +ht m +ĠC trl +ON S +2 30 +if a +hold ing +Ġdelic ate +Ġj aw +ĠGo ing +or um +S al +Ġd ull +ĠB eth +Ġpr isons +Ġe go +ĠEl sa +avor ite +ĠG ang +ĠN uclear +Ġsp ider +ats u +Ġsam pling +Ġabsor bed +ĠPh arm +iet h +Ġbuck et +ĠRec omm +O F +ĠF actory +AN CE +Ġb acter +H as +ĠObs erv +12 1 +Ġprem iere +De velop +Ġcur rencies +C ast +Ġaccompany ing +ĠNash ville +Ġfat ty +ĠBre nd +Ġloc ks +Ġcent ered +ĠU T +augh s +or ie +ĠAff ordable +v ance +D L +em et +Ġthr one +ĠBlu etooth +Ġn aming +if ts +AD E +Ġcorrect ed +Ġprompt ly +ĠST R +Ġgen ome +Ġcop e +Ġval ley +Ġround ed +ĠK end +al ion +p ers +Ġtour ism +Ġst ark +v l +Ġblow ing +ĠSche dule +st d +Ġunh appy +Ġlit igation +ced es +Ġand roid +Ġinteg ral +ere rs +ud ed +t ax +Ġre iter +ĠMot ors +oci ated +Ġwond ers +ĠAp ost +uck ing +ĠRoose velt +f ram +Ġyield s +Ġconstit utes +aw k +Int erest +Ġinter im +Ġbreak through +ĠC her +Ġpro sec +ĠD j +ĠM T +Res p +ĠP T +Ġs perm +ed it +B T +Lin ux +count ry +le ague +Ġd ick +Ġo ct +Ġinsert ing +Ġsc ra +ĠBrew ing +Ġ19 66 +Ġrun ners +Ġpl un +id y +ĠD ian +Ġdys function +Ġex clusion +Ġdis gr +Ġincorpor ate +Ġrecon c +Ġnom inated +ĠAr cher +d raw +achel or +Ġwrit ings +Ġshall ow +Ġh ast +ĠB MW +ĠR S +Ġth igh +Ġ19 63 +Ġl amb +Ġfav ored +ag le +Ġcool er +ĠH ours +ĠG U +ĠOrig in +Ġglim pse +---------------- ---- +L im +Ġche ek +Ġj ealous +- ' +Ġhar ness +ĠPo ison +Ġdis abilities +ne apolis +Ġout look +Ġnot ify +ĠIndian apolis +Ġab rupt +ns ic +Ġenc rypted +Ġfor fe +reat h +Ġr abb +Ġfound ations +Ġcompl iment +ĠInter view +ĠS we +Ġad olesc +Ġmon itors +ĠSacrament o +Ġtime ly +Ġcontem pl +Ġposition ed +Ġpost ers +ph ies +iov ascular +v oid +ĠFif th +Ġinvestig ative +OU N +Ġinteg rate +ĠIN C +ish a +ibl ings +ĠRe quest +ĠRodrig uez +Ġsl ides +ĠD X +Ġfemin ism +Ġdat as +Ġb end +ir us +ĠNig eria +F ox +Ch ange +Ġair plane +ĠLad en +Ġpublic ity +ixt y +Ġcommit ments +Ġaggreg ate +Ġdisplay ing +ĠAr row +Ġ12 2 +Ġrespect s +and roid +s ix +ĠSh a +Ġrest oration +) \ +W S +oy s +Ġillust rate +with out +12 6 +ĠâĶ Ĥ +Ġpick up +n els +Ġ .... +f ood +ĠF en +) ? +Ġphenomen a +Ġcompan ions +ĠW rite +Ġsp ill +Ġbr idges +ĠUp dated +ĠF o +Ġinsect s +ASH INGTON +Ġsc are +il tr +ĠZh ang +Ġsever ity +Ġind ul +14 9 +ĠCo ffee +Ġnorm s +Ġp ulse +ĠF T +Ġhorr ific +ĠDest roy +ĠJ SON +Ġo live +Ġdiscuss es +R est +E lect +ĠW inn +ĠSurv iv +ĠH ait +S ure +op ed +Ġro oted +ĠS ke +ĠBron ze +Ġl ol +Def ault +Ġcommod ity +red ited +Ġliber tarian +Ġforb idden +Ġgr an +à ¨ +Ġl ag +en z +dri ve +Ġmathemat ics +Ġw ires +Ġcrit ically +Ġcarb ohyd +ĠChance llor +ĠEd die +Ġban ning +ĠF ri +Ġcompl ications +et ric +ĠBangl adesh +Ġband width +St op +ĠOrig inally +Ġhalf way +yn asty +sh ine +Ġt ales +rit ies +av ier +Ġspin ning +ĠWH O +Ġneighbour hood +b ach +Ġcommer ce +ĠS le +B U +Ġentreprene ur +Ġpecul iar +ĠCom ments +f re +3 20 +IC S +Ġimag ery +ĠCan on +ĠElect ronic +sh ort +( ( +D ig +Ġcomm em +u ced +Ġincl ined +ĠSum mon +Ġcl iff +ĠMed iterranean +Ġpo etry +Ġprosper ity +ĠRe ce +Ġp ills +m ember +Ġfin ale +un c +ĠG ig +ä ½ +Ġl od +Ġback ward +- + +ĠFor ward +Ġth ri +s ure +Ġso ap +ĠF X +R ES +ĠSe xual +oul os +Ġfool ish +Ġright eous +Ġco ff +terror ism +ust ain +ot er +Ġab uses +ne xt +Ġab usive +Ġthere after +Ġprohib ition +ĠS UP +Ġd ip +Ġr ipped +Ġinher ited +Ġb ats +st ru +G T +Ġflaw ed +ph abet +Ġf og +do ors +Ġim aging +Ġdig its +ĠHung ary +Ġar rog +Ġteach ings +Ġprotocol s +ĠB anks +à ¸ +p ound +ĠC urt +." ) +. / +Ġex emption +end ix +ĠM ull +Ġimpro ves +ĠG amer +d imensional +I con +ĠMarg aret +St atus +d ates +Ġint ends +Ġdep ict +Ġpark ed +J oe +ĠMar ines +chn ology +! ). +Ġjud ged +Ġwe ights +R ay +Ġapart ments +he ster +Ġrein force +Ġoff ender +occ up +Ġs ore +e pt +ĠPH P +ĠB row +Ġauthor ization +ĠR isk +ĠDel aware +ĠQ U +Ġnot ifications +Ġsun light +Ġex clude +d at +Ġm esh +ĠSud an +Ġbelong ed +Ġsub way +Ġno on +ĠInter ior +ol ics +ĠL akers +Ġc oding +Dis claimer +Cal if +O ld +Ġdis l +???? ? +Ġconfir ms +Ġrecruit ment +Ġhom icide +Cons ider +ĠJeff rey +ft y +} ; +Ġobject ion +do ing +ĠLe o +W ant +Ġgl ow +ĠClar ke +ĠNorm an +Ġver ification +Ġpack et +ĠForm ula +Ġpl ag +es ville +Ġshout ing +Ġo v +ĠR EC +ĠB ub +Ġn inth +Ġener g +Ġvalid ity +Ġup s +j ack +Ġneighbor ing +ĠN ec +ew orks +ĠH ab +are z +Ġsp ine +Ġevent ual +ĠLe aders +ĠC arn +Ġprob ation +Ġrom ance +ms g +ĠMechan ical +ER Y +R ock +Ġpart isan +N ode +ass ets +min ent +Ġforeign ers +Ġtest ify +ĠUs ually +l ords +ĠG ren +ĠPow ell +BI L +Ġs r +Ġadd ict +Ġshell s +Ġs igh +ĠY ale +tern ity +Ġ7 50 +E U +ĠR ifle +Ġpat ron +em a +ĠB annon +an ity +Ġtrop ical +ĠV II +c ross +Every thing +ĠIS O +Ġhum ble +ass ing +ĠF IG +Ġupd ating +ys on +Ġcal cium +Ġcompet ent +Ġste ering +Pro t +ĠS Y +ĠFin als +ĠR ug +15 9 +13 7 +ĠG olf +Ġ12 6 +Ġaccommod ation +ĠHug hes +Ġaest hetic +art isan +ĠTw ilight +Ġpr ince +ĠAgric ulture +ĠDis co +Ġpreced ent +Ġtyp ing +author ized +O ption +ĠA ub +l ishes +ach t +m ag +P eter +ĠU FO +mont on +ĠL ith +Ġa rom +Ġsec uring +Ġconf ined +priv ate +Ġsw ords +Ġmark ers +Ġmetab olic +se lect +ĠCur se +ĠO t +g ressive +Ġinc umb +ĠS aga +Ġpr iced +Ġclear ance +Cont ent +Ġdr illing +Ġnot ices +Ġb ourgeois +Ġv est +Ġcook ie +ĠGuard ians +ry s +in yl +Ġ12 4 +Ġpl ausible +on gh +ĠOd in +Ġconcept ion +ĠY uk +ĠBaghd ad +ĠFl ag +Aust ral +ĠI BM +Ġintern ationally +ĠWiki Leaks +I ED +Ġc yn +Ġcho oses +ĠP ill +Ġcomb ining +Ġrad i +ĠMoh ammed +def ense +atch ing +Sub ject +ic iency +Fr ame +Ġ{ " +Ġche ss +Ġtim er +19 0 +Ġt in +Ġord inance +emet ery +Ġacc using +Ġnotice able +Ġcent res +Ġl id +ĠM ills +img ur +Ġz oom +erg ic +Ġcomp ression +pr im +f ind +Ġsur g +Ġp and +ĠK ee +ĠCh ad +cell ence +oy le +Ġsocial ism +ĠT ravis +ĠM Hz +Ġgu ild +ALL Y +ĠSub scribe +ĠRel ated +Ġoccur rence +itch ing +Ġfict ional +Ġcr ush +ĠE A +c od +m ix +ĠTri ple +Ġretrie ve +Ġstimul us +Ġpsych iat +ĠDo or +Ġhomosexual ity +Ġelement ary +Ġcell ular +id ian +ĠL aun +Ġintrig uing +Ġfo am +ĠB ass +id i +its u +Ġass ure +Ġcongr at +Ġbusiness man +ĠBo ost +cl ose +Ġl ied +Ġsc iences +ĠO mega +ĠG raphics +Ġ< = +sp oken +Ġconnect ivity +S aturday +ĠAven gers +Ġto ggle +Ġank le +Ġnational ist +mod el +ĠP ool +ophob ia +V ar +ĠM ons +ator ies +Ġaggress ively +C lear +For ge +act ers +Ġhed ge +Ġpip es +Ġbl unt +Ġs q +Ġremote ly +W ed +as ers +Ġref riger +Ġt iles +Ġresc ued +Ġcompr ised +ins ky +Ġman if +avan augh +Ġprol ifer +Ġal igned +x ml +Ġtri v +Ġcoord ination +ĠP ER +ĠQu ote +13 4 +b f +ĠS aw +Ġtermin ation +Ġ19 0 +Ġadd itions +Ġtri o +Ġproject ions +Ġpositive ly +Ġin clusive +Ġmem br +19 90 +old er +Ġpract iced +ink le +Ar ch +Ġstar ters +ari us +Ġinter mediate +ĠBen ef +ĠK iller +Ġinter ventions +ĠK il +ĠF lying +In v +Ġprem ature +Ġpsych iatric +Ġind ie +Ġcoll ar +ĠRain bow +af i +Ġdis ruption +ĠFO X +cast ing +Ġmis dem +c ro +Ġw ipe +ard on +Ġb ast +ĠTom my +ĠRepresent ative +Ġbell y +ĠP O +ĠBre itbart +13 2 +Ġmess aging +Sh ould +Ref erences +ĠG RE +ist ical +L P +ĠC av +ĠC razy +Ġintu itive +ke eping +ĠM oss +Ġdiscont in +ĠMod ule +Ġun related +ĠPract ice +ĠTrans port +Ġstatist ically +orn s +Ġs ized +p u +Ġca f +ĠWorld s +ĠRod gers +ĠL un +ĠCom ic +l iving +Ġc ared +Ġclim bed +) { +Ġconsist ed +Ġmed ieval +fol k +Ġh acked +Ġd ire +ĠHerm ione +Ġt ended +ce ans +D aniel +w ent +Ġlegisl ators +Ġred es +g ames +Ġg n +am iliar +Ġ+ + +gg y +th reat +Ġmag net +Ġper ceive +Ġz ip +Ġindict ment +Ġcrit ique +g ard +ĠSaf e +ĠC ream +Ġad vent +ob a +Ġv owed +ous ands +Ġsk i +Ġabort ions +u art +Ġstun ned +Ġadv ancing +Ġlack ed +Ġ\ " +Ġsch izophren +Ġeleg ant +Ġconf erences +Ġcance led +ĠHud son +ĠHop efully +Ġtr ump +Ġfrequ encies +Ġmet eor +ĠJun ior +ĠFle et +ĠMal colm +ĠT ools +Ġ ........ +Ġh obby +ĠEurope ans +Ġ15 00 +ĠInt o +Ġs way +ĠApp ro +ĠCom pl +Comm unity +Ġt ide +ĠSum mit +ä » +Ġinter vals +ĠE ther +Ġhabit at +ĠSteven s +lish ing +ĠDom ain +Ġtrig gers +Ġch asing +Ġchar m +ĠFl ower +it ored +Ġbless ing +Ġtext ures +F ive +Ġliqu or +R P +F IN +Ġ19 62 +C AR +Un known +Ġres il +ĠL ily +Ġabund ance +Ġpredict able +r ar +Ġbull shit +le en +che t +M or +M uch +ä ¹ +Ġemphas ized +Ġcr ust +Ġprim itive +Ġenjoy able +ĠPict ures +Ġteam mate +pl er +ĠT ol +ĠK ane +Ġsummon ed +th y +ram a +ĠH onda +Ġreal izing +Ġquick er +Ġconcent rate +cle ar +Ġ2 10 +ĠErd ogan +ar is +Ġrespond s +ĠB I +Ġelig ibility +Ġpus hes +ĠId aho +Ġagg rav +Ġru ins +ur ations +Ġb ans +Ġan at +sh are +Ġgr ind +h in +um en +Ġut ilities +ĠYan kees +Ġdat abases +ĠD D +Ġdispl aced +Ġdepend encies +Ġstim ulation +h un +h ouses +ĠP retty +ĠRaven s +ĠTOD AY +Ġassoci ates +Ġthe rape +cl ed +Ġde er +Ġrep airs +rent ice +Ġrecept ors +Ġrem ed +ĠC e +Ġmar riages +Ġball ots +ĠSold ier +Ġhilar ious +op l +13 8 +Ġinherent ly +Ġignor ant +Ġb ounce +ĠE aster +REL ATED +ĠCur rency +E V +ãĥ ŀ +ĠLe ad +Ġdece ased +B rien +ĠMus k +J S +Ġmer ge +heart ed +c reat +m itt +m und +ĠâĢ ĭ +ĠB ag +Ġproject ion +Ġj ava +ĠStand ards +ĠLeon ard +Ġcoc onut +ĠPop ulation +Ġtra ject +Ġimp ly +Ġcur iosity +ĠD B +ĠF resh +ĠP or +Ġheav ier +ne ys +gom ery +Ġdes erved +Ġphr ases +ĠG C +Ġye ast +d esc +De ath +Ġreb oot +Ġmet adata +IC AL +Ġrep ay +ĠInd ependence +Ġsubur ban +ical s +Ġat op +Ġall ocation +gener ation +ĠG ram +Ġmoist ure +Ġp ine +ĠLiber als +Ġa ides +Ġund erest +ĠBer ry +Ġcere mon +3 70 +ast rous +ĠPir ates +Ġt ense +ĠIndust ries +ĠApp eals +ĠN ear +Ġè£ı ç +Ġlo vers +ĠC AP +ĠC raw +Ġg iants +Ġeffic acy +E lement +ĠBeh avior +ĠToy ota +Ġint est +P riv +A I +Ġmaneu ver +Ġperfect ion +Ġb ang +p aper +r ill +Ge orge +b order +in ters +ĠS eth +Ġcl ues +ĠLe vi +ĠRe venue +14 7 +Ġv apor +Ġfortun ate +Ġthreat ens +Ġve t +Ġdepend ency +ers ed +art icle +ĠBl izzard +Ġch lor +Ġmin us +ĠB ills +Ġcryptoc urrency +Ġmetabol ism +ter ing +Ġp estic +step s +ĠTre asure +ract ed +ĠConst ant +Ġtem p +13 9 +ĠDet ective +ur ally +Ġrecover ing +Ġcort ex +Ġ14 4 +cl osed +Ġprejud ice +aun ted +Ġstorm s +ĠN OW +Ġmach inery +Add ress +Ġcompe lled +27 0 +Ġdesp air +b ane +Ġveget able +Ġbed s +Lear n +Ġcolor ful +Ġsp ike +Ġmarg ins +Ġsymp athy +Ġworks hop +ĠC BC +S at +Ġburn s +ĠG ender +Ġ12 9 +ĠC able +Ġdeb ts +ĠThe resa +Ġreflect ing +Ġa irst +Ġr im +ram id +Ġweakness es +W rit +ogg le +t i +ĠCh arge +Ġwe ighed +Ġ( . +Ġl aughter +Ġrou ter +ĠDemocr acy +D ear +Ġhas ht +Ġd y +Ġhint s +run ning +Ġfin ishes +ar us +M ass +res ult +asc us +Ġv intage +Ġcon qu +Ġwild ly +ac ist +Ġl ingu +Ġprot agonist +st rom +te enth +ĠSol o +m ac +f illed +Ġre nown +it ives +Ġmot ive +ĠAnt ar +ĠM ann +ĠAd just +Ġrock ets +Ġtrou bling +e i +Ġorgan isms +ass is +Christ ian +Ġ14 5 +ĠH ass +Ġsw all +Ġw ax +ĠSurv ival +V S +ĠM urd +v d +stand ard +Ġdrag ons +Ġacceler ation +r ational +f inal +Ġp aired +ĠE thereum +Ġinterf aces +Ġres ent +Ġartif acts +Å « +are l +Ġcompet itor +ĠNich olas +ĠSur face +c pp +ĠT ot +Ġeconom ically +Ġorgan ised +Ġen forced +in ho +Ġvar ieties +Ġab dom +ĠBa iley +id av +ĠSal v +p aid +Ġalt itude +ess ert +ĠG utenberg +are a +op oulos +Ġprofess ors +igg s +ĠF ate +he y +Ġ3 000 +D ist +Ġtw ins +c ill +ĠM aps +Ġtra ps +Ġwe ed +ĠK iss +Ġy oga +Ġrecip ients +ĠWest minster +Ġpool s +ĠWal mart +18 8 +ĠSchool s +att ack +ĠAR M +par agraph +W arning +j l +Ġself ish +anche z +ĠHe ights +F re +ĠS oph +Ġ -------------------------------- +t ml +33 3 +Ġraid s +Ġsatell ites +KE Y +Ġlast s +Ñ Ĥ +In s +ĠD ame +Ġunp redict +// / +gh ai +Ġart illery +Ġcru ise +Ġg el +ĠCabin et +Ġbl ows +ĠE sp +Ġprox imity +ot he +ĠSk ills +ĠU pper +ob o +ĠN DP +Ġenjoy s +Ġrepe ating +ĠConst ruction +ĠQuest ions +H illary +Ġu int +Ġprocess ors +ĠGib son +ĠMult iple +q a +ĠB om +ĠM iles +vent ional +Ġhur ts +s kin +ĠA IDS +Ġadvis ers +ĠR oot +Ġmethod ology +ĠD ale +Ġdet on +ĠKnow ledge +sequ ently +Ġ12 1 +Ġconnect s +C y +ĠD anger +Ġcontribut ors +ĠB ent +Ġbr ass +ĠGun s +int o +ĠFort une +Ġbro ker +bal ance +Ġlength s +Ġv ic +Ġaver aging +Ġappropri ately +ĠCamer a +Ġsand wich +ĠCD C +Ġcoord inate +Ġnav ig +Ġgood ness +l aim +Ġbra ke +Ġextrem ist +ĠW ake +ĠM end +ĠT iny +ĠC OL +ĠR F +ĠD ual +ĠW ine +C ase +Ġref ined +Ġl amp +L ead +Ġb apt +ĠCar b +ĠS add +ĠMin neapolis +PD F +Ear ly +ĠH idden +I ts +ĠT IME +Ġp ap +Ġcommission ed +ĠF ew +ĠCol ts +ĠB ren +Ġbot hered +Ġlike wise +Ex per +ĠSch w +c ry +n n +ĠM itch +im on +M G +b m +UM P +r ays +Ġregist ry +Ġ2 70 +ach ine +re lla +ant ing +00 000 +Ġru ined +sp ot +Ġt a +Ġmaxim ize +Ġincon ven +D ead +H uman +En abled +ĠMar ie +Ġch ill +ĠParad ise +Ġstar ring +ĠLat ino +ĠProt ocol +ĠE VER +Ġsuppl iers +m essage +ĠBro ck +Ġser um +âĸĪâĸĪ âĸĪâĸĪ +Ġen comp +Ġamb ition +ues e +Ġar rows +And rew +Ġanten na +Ġ19 61 +ĠB ark +Ġb ool +ãĤ ª +ĠSt orage +Ġrail way +Ġtoug her +ĠC ad +Ġwas hing +P y +' ] +em bed +ĠMem phis +ack le +Ġfam ously +ĠF ortunately +ov ies +Ġmind set +Ġsne ak +ĠD h +RA W +ĠSim pson +Ġliv est +Ġland mark +Ġc ement +L ow +Ġthr illed +ĠCour se +in el +Ġch uck +id ate +gl obal +Ġwh it +Ġ � +ad ays +s ki +ĠS V +Ġvir uses +30 6 +ĠResp ons +Ġthe aters +ĠBr anch +ĠGene va +ĠM K +Ġunbel iev +Ġcommun ist +Orig inal +ĠRe ceived +ĠTrans fer +ĠAr g +In put +ĠStr ategy +Ġpal ace +the ning +D ri +Ġsent encing +umbn ail +Ġp ins +re cy +Ġs iblings +Get ting +ĠB U +ĠNorth west +Ġprolong ed +ĠSak ura +C omb +ĠB our +Ġinadequ ate +ĠK ash +Ġus ername +ĠImpro ve +Ġbatt ling +ĠM AC +Ġcurric ulum +Ġs oda +ĠC annon +Ġsens ible +sp ons +De cember +Ġw icked +ĠP engu +Ġdict ators +ĠHe arts +og yn +Ġsimilar ities +ĠSt ats +Ġh ollow +it ations +": [ +Ġh over +ĠList en +s ch +S und +Ġc ad +ĠPar ks +Ġl ur +Ġhy pe +ĠL em +N AME +is ure +Fr iday +Ġshoot s +Ġclos es +Ġd b +ĠR idge +ĠDiff erent +Ġrepl ies +ĠBroad way +op ers +Ġint oler +ĠZe us +akes pe +Ġpropri etary +Ġrequest ing +Ġcontro llers +ĠM IN +im edia +be cca +Ġexp ans +Ġoil s +B ot +ĠCh and +Ġpr inter +Ġto pped +ĠP OL +ĠEar lier +S ocial +av in +Ġdecre ases +ĠSe b +Ġspecific ations +ĠBl ast +ĠK urt +Ġfre el +B rown +Ġdil ig +ro e +ĠPro blem +ĠQu ad +Ġdecent ral +ĠV ector +an ut +Ġplug ins +ĠGreg ory +Ġfuck ed +el ines +ĠAmb assador +t ake +Ġcle ans +ong yang +An onymous +st ro +" } +al ine +ĠO dd +ĠE ug +2 16 +Ġbo il +ĠP owers +Ġnurs es +Ob viously +ĠTechn ical +Ġexceed ed +OR S +Ġextrem ists +Ġtr aces +ex pl +Ġcom r +ĠS ach +) / +Ġm asks +Ġsc i +B on +Ġreg ression +we gian +Ġadvis or +it ures +ĠV o +ex ample +ĠInst ruct +Ġs iege +Ġredu ctions +pt r +Ġstat utory +Ġrem oves +Ġp uck +red its +Ġbe e +Ġsal ad +Ġpromot ions +ĠJosh ua +with standing +ET H +ĠCh a +im us +Ġexpend iture +aun ting +Ġdelight ed +Ġ15 5 +be h +Ġcar pet +ĠSp art +Ġj ungle +l ists +Ġbull ying +ĠNob el +ĠGl en +Ġreferen ced +Ġintrodu ces +se in +Ġcho pped +gl ass +ĠW rest +Ġneutral ity +Ġâ Ļ +Ġinvestig ator +Ġshel ves +Ġun constitutional +Ġreprodu ction +Ġmer chant +m ia +Ġmet rics +Ġexplos ives +ĠSon ia +Ġbod ily +Ġthick ness +Ġpredomin antly +ĠAb ility +Ġmon itored +IC H +Ġ] . +ĠMart inez +Ġvis ibility +Ġqu eries +Ġgen ocide +ĠWar fare +Qu ery +Ġstud ios +Ġemb ry +Ġcorrid or +Ġclean ed +com plete +ĠM H +Ġenroll ment +ING S +Ġimpact ed +Ġdis astrous +ĠY un +ĠCl aire +ĠBas ically +y t +uster ity +Ġindirect ly +w ik +Ġd od +ĠCar r +Ġam p +Ġprohib it +ĠIn itial +ĠR d +ij i +Ġeduc ate +c orn +i ott +ĠBeaut y +Ġdetect ive +ĠCon n +s ince +Ġst agger +Ġob ese +Ġb ree +olog ic +is se +walk er +Ġbl ades +Ġlaw ful +fun c +ĠBeh ind +Ġappet ite +Ġ( * +Ġt ennis +Ġoff spring +Ġj ets +Ġstruct ured +Ġafore mentioned +N ov +Ġsc aling +f ill +Ġst ew +Ġcur b +ĠStep han +ed In +S F +ob ic +é ŃĶ +ou g +ĠM M +Ġgen etically +ope z +13 6 +Ġu mb +anc ers +Ġcoh ort +Ġmerch andise +Ġimp osing +ĠLegisl ature +ĠArch ive +iv ia +ĠN aval +Ġoff ences +Ġmir acle +Ġsn apped +Ġf oes +Ġextensive ly +ĠR af +Ġc ater +ed ience +K it +ĠB in +Ġrecomm ends +ĠC ities +Ġrig id +ĠRE AD +ĠNob le +ĠT ian +Ġcertific ates +ant is +o iler +ĠBudd hist +d id +Ġsurvey ed +Ġdown ward +Ġprint s +ĠMot ion +ron ics +ĠS ans +oss ibly +u ctions +Ġcolon ies +ĠDan ish +un it +Ġsp oil +Ġadvis ory +ber ries +Pl an +Ġspecific ation +op hers +ĠRes ource +Ġsh irts +prising ly +commun ications +Ġtriv ial +Ġmention ing +ise xual +Ġsupp lements +Ġsuper vision +B P +v or +Ġw it +Ġco oldown +Ġplaint iff +ĠReview s +ĠS ri +ĠM int +ĠSug ar +Ġafter ward +ĠPri est +ĠInvest ment +og ene +ĠT aking +Ġstretch ing +Ġinflamm ation +ĠTe hran +Ġl ining +Ġfree zing +ĠEnt ity +Ġins piring +spe cial +pr ice +Ġsu e +ĠP orter +oun ge +ET A +ĠD erek +ĠLu is +u o +ym ph +Ġex terior +ih il +ĠAsh ley +in ator +Ġnut rients +ĠTh rones +Ġfin ances +ĠIn spect +Ġspe cially +ĠRequ ired +ĠP TS +ĠViol ence +oint ed +sh ots +Ġex cerpt +co on +IN S +ĠG ri +Ġrecogn ised +We ek +You ng +Ġv om +is le +ĠCur ry +ĠBudd h +Ġnot ebook +Ġd urable +/ ? +ĠG ad +ĠP upp +Ġforg ive +p ark +Ġpersonal ities +an alysis +cl amation +Ġelev ator +Ġware house +ĠR ole +un n +Ġillust ration +ĠSc an +Ġatmosp heric +Im port +AN C +rict ed +f u +01 0 +Ġar che +Ġreward ed +akespe are +Ġintern ally +ĠR BI +alk er +Ġeleph ant +ow itz +ĠP izza +Ġbip artisan +é s +Ġslow ed +ĠSt ark +Ġover ride +OU S +Ġ3 20 +undred s +ĠDe ck +ĠC ensus +be e +14 6 +ot or +Ġ ip +Ġu b +oc ations +ĠBut ton +r ice +Ġc ripp +ff f +Ġorig inated +Ġoverwhel med +app a +Ġfore most +âĢ ij +ĠL EG +re lease +eat ured +at ches +Ġre ps +Ġl ending +ĠRe ference +ĠCl ient +16 5 +vent h +Com plete +ĠPat rol +Ġsw orn +c am +Ġshut tle +ĠR alph +Ġh ometown +- , +on al +ĠB P +å ı +Ġpersu ade +ĠAlex and +Ġcomb ines +Ġv ivid +ĠL ag +Ġenc oding +Ġsal vation +w en +ĠRec overy +i ya +Un iversity +ĠB iden +Ġbud gets +ĠTex ans +f its +Ġhon ored +Ġp ython +T D +## # +cl one +Ġbl ink +ĠL iquid +Ġunemploy ed +Ġcl ashes +ĠCoun sel +Ġdirect ing +Ġpun ct +ĠFal cons +Ġsh ark +ĠDam ascus +Ġje ans +Ġemb ark +Ġse ize +Ġup wards +2 80 +ĠE z +ĠAny thing +Ġex otic +l ower +ĠCreat or +ĠU m +Ġsubur bs +ber ger +ĠW end +Ġm int +ĠX X +ĠD ro +Ġsuff ers +Ġher b +t ree +Ġfrag ile +Ġflood ed +ĠAl cohol +ole an +ny der +ĠK O +F ram +Ġ13 6 +Ġow ed +ĠMe lee +ĠH ash +Ġwh isk +Ġsu do +r r +Qu ick +app ro +Ġi i +ĠEx amples +he e +Ġpromot es +per ature +k ar +ĠHon or +Ġs odium +ĠL if +ros so +intend ent +Ġcorrespond ent +F ound +sec ret +Ġident ifies +ag ne +Ġl ou +ĠP P +Ġcoinc idence +m ove +Ġmilit ia +Ġinf iltr +ĠPrim ary +Ġpitch ing +ĠI b +ĠGO OD +ãĤ ¸ +ĠW izards +ir al +ĠVen us +R R +ĠâĢ ķ +ĠCase y +Ġsad ly +Ġadm ire +Ġembarrass ed +c b +M el +Ġtub es +Ġbeaut ifully +ĠQueens land +Bel ow +re z +qu et +ple asant +Ġ « +C amp +Ġdec isive +19 98 +ĠL amb +ut ton +h n +ĠJ agu +au nder +ĠC ord +Ġcl erk +Ġca ffe +Ġwip ed +Ġre im +ĠMount ains +Ġimprison ed +Ġdevelop s +ĠP ra +Ġmodel ing +Any one +ance l +ĠS it +Ġshield s +Ġl awn +Ġcard iovascular +Ġdemonstr ating +Ġpar se +ĠIsrael is +Ġeuro s +14 3 +Ġgl orious +ins ki +ec d +Ġcondition ing +Ġhel pless +Ġmicro sc +ĠHar bor +Ġst akes +Ġ2 60 +Ġun equ +ĠFl oyd +Ġd amp +Ġappar atus +ĠLaw s +Ġcoun ters +Ġindu ce +at able +ĠAh med +Ġsl am +N ovember +Ġpers ist +Ġim minent +á n +Ġsh red +Ġph ases +ĠEd monton +ĠArm strong +ĠMe et +ĠK itty +Ñ Ģ +c irc +ĠAd ult +Ġa rose +ĠX en +D an +g ow +Ġsuper f +ĠAd mir +Ġend ure +Ġkey word +yr us +Ġy arn +Ġpath way +ĠHop kins +mid t +Ġcens orship +d ependent +Ġinstruct or +S ources +Ġto e +Ġball oon +N ob +Ġsw ear +ĠCast ro +Ġgl oss +ĠK avanaugh +Ġremark ably +Ph otos +ĠN om +ĠS outheast +y ers +Ġvalid ation +Ġcann on +ĠVict ory +ĠPier re +Ġcaut ious +Aud io +Ġf etch +ĠG ift +ĠH yp +Ġrem edy +Z E +Ġsc ent +Ġbe ard +ĠR ut +- " +Ġpat ents +H y +Ġun just +Ġpot ato +Ġforth coming +Ġche f +ĠR ift +aff e +ĠR OM +ĠL aunch +Ġp ads +ĠNe o +Ġon set +Ġsquee ze +s afe +Ġpref ix +ĠT M +ĠN early +ĠClin ical +ĠM ental +ot iation +ĠUn ic +ant ry +ĠC ir +Ġep it +à ¦ +Ġextract ed +verse ly +ri ad +Ġstr ains +Ġto ps +Ġpo em +ĠRand y +ĠMap le +TH ER +up iter +ĠSS D +ļ é +Ġun con +per ing +Ġsle pt +in ers +Ġunder water +ĠEv idence +g one +20 5 +Ġhistor ians +Ġsynt hesis +Ġf rog +b asketball +Ġvibr ant +Ġsub ord +Ġ3 65 +ĠD ial +Ġcooper ate +HA HA +Ġgreet ed +15 8 +Ġj azz +Ġinto x +ĠWalk ing +Ġsuper visor +ĠF usion +ĠMer cedes +s end +H am +s d +n l +Ġtour s +ĠF IFA +Ġcul p +g d +30 4 +Ġple as +Ġillust rates +ĠColomb ia +Ġhighlight ing +ĠSum mary +Ġexp osing +ĠD ru +Ġir ony +r itional +ĠCar roll +ĠEll is +P ict +ĠR apt +Ġad apter +Ġun m +Ġcor pse +Ġceleb rities +D en +at um +ĠAp ocalypse +ĠW ag +lin ing +Ġhorm ones +R ub +ĠX i +ĠV aults +20 8 +alky rie +inos aur +Ġfeed s +v ity +Ġdefe ating +W ait +Ġemphas ize +ĠSteel ers +yr inth +le ys +ĠWhe never +Current ly +ĠCl ock +Ġcollect ively +any on +ĠJ P +Ġment ality +Ġdownload s +Ġsurround ings +ĠBarn es +Ġflags hip +Ġindic ators +Ġgra pp +Jan uary +ĠElement al +ĠAthen a +ib al +Ġs ights +Ġcap ita +ĠTreat y +Ġvo iced +ĠG az +let te +Ġy a +Ġexp ired +Leg end +H ot +n ature +Ġunst able +Ġ2 80 +à º +Com ment +AL E +Ġquest s +Ġhand ler +n is +Ġvers atile +Ġconce al +enge ance +ĠInter active +Ġobs essed +ĠDog s +Ġcr acked +S ound +s v +ĠD ylan +ro ads +f x +ĠCath olics +ĠH ag +Ġsl ammed +Ġgl owing +s ale +Ġtiss ues +ĠCh i +ne e +Ġc her +s ic +ur rection +Ġb acon +ul atory +) ." +Ġir regular +FOR M +ass ed +Ġintention al +Ġcompens ate +ĠSpe aking +ĠS ets +15 3 +Ġconvent ions +b ands +em ade +Ġe cc +ĠWin ston +ĠAssass in +ĠBelg ian +Ġdepend ence +Ġnic he +Ġb ark +ĠJ azz +Ġdisadvant age +Ġgas oline +Ġ16 5 +çļ Ħ +ess a +mod ule +ang ular +O Y +ĠTreat ment +it as +ol ation +ĠArn old +Ġfe ud +ĠN est +Ġthe atre +ew ater +Ġmin ors +olic y +ĠH aven +div ision +Ġtr unk +F ar +ĠP ull +Ġcapt uring +Ġ18 00 +ĠTe en +Ġex empl +Ġclin ics +ĠB urg +Ġsubst it +Ġpay load +ĠL av +ĠT roy +ĠW itness +Ġfrag ments +Ġpass words +Ġg ospel +ĠG in +Ġten ants +ol ith +S ix +Pre vious +ĠAg es +ĠDar win +Ġbl at +Ġem pathy +sm ith +b ag +ĠE cho +ĠC amb +ĠM add +ĠB oo +Ġred e +ĠBurn ing +Ġsmooth ly +ĠAd rian +ĠV ampire +ĠMon sters +ste am +Sty le +M a +re a +ĠD war +aly st +urs or +Ġelim ination +Ġcrypt o +ch t +ĠE ternal +âĢ¦ ] +ĠS orce +I ll +N ER +Ġu h +Con clusion +w age +Ġresp ir +Ġrem inis +het ical +Ġg y +Ġutil ized +ic idal +Ġ19 00 +Ġhun ters +ĠSw an +ĠRe act +Ġvis itor +ĠThanks giving +30 8 +Post s +Ġh ips +19 97 +om ers +Ġkn ocking +ĠVeh icle +Ġt il +Ġ13 8 +Ġm i +ĠInvest igation +ĠKen ya +Ġcas ino +Ġmot ives +Ġreg ain +re x +Ġweek ends +Ġstab bed +bor o +Ġexplo ited +ĠHA VE +ĠTe levision +c ock +Ġprepar ations +Ġende av +ĠRem ote +ĠM aker +ĠPro du +ĠEv an +Ġinform ational +ĠLouis ville +15 4 +ĠDream s +Ġpl ots +ĠRun ner +Ġhur ting +Ġacad emy +ĠMont gomery +n m +ĠL anc +ĠAl z +2 10 +el ong +Ġretail er +Ġar ising +Ġrebell ion +Ġbl onde +play ed +Ġinstrument al +C ross +Ġret ention +Ġtherape utic +Ġse as +Ġinfant ry +ĠCl int +Ġprompt ing +Ġbit ch +Ġst ems +ĠK ra +Ġthe sis +ĠB og +ru ed +Ġk ings +Ġcl ay +ific ent +ĠY ES +ĠTh ing +ĠCub s +vey ard +els h +in arily +ĠE y +ĠRoll ing +Ġev olving +Ind ia +Ġrecogn izes +Ġgrad uation +is ers +Ġfert ility +ĠMil an +Comm and +Ġbox ing +Ġ19 43 +Ġgl uten +ĠEm ir +Ġid ol +Ġcon ceived +ĠCre ation +Mer it +udd y +uss ions +ĠLie utenant +iet al +Ġunch anged +ĠSc ale +ĠCrime a +ball s +ator ial +Ġdepth s +Ġempir ical +Ġtrans m +Ġuns afe +miss ible +com fort +15 6 +Ġmechan ic +00 2 +l ins +Ġsm oked +P os +Ġslow ing +Ġl av +Tex as +Ġche ating +ĠMet ropolitan +eth yl +Ġdiscover ing +as se +Ġpen cil +ĠPy ongyang +Ġclos et +ĠShe et +ĠEnt ry +ou stic +Ġmy st +er ate +ari at +Ġminer als +Ġmusic ian +ĠP ul +ĠM az +24 9 +Ġper missions +Ġ iv +en ary +ick ers +ĠB ing +he a +en able +Ġgri ev +Ġassert ed +ĠColon el +Ġaff idav +w o +Ġse ated +ĠR ide +Ġpaint ings +ĠP ix +Ġ13 7 +ish i +umb ai +g otten +ĠEar l +Ġin ning +Ġc ensus +Ġtrave lled +ĠCons ult +18 5 +b ind +Ġsimpl icity +Ġoverlook ed +ĠHelp ful +Ġmon key +Ġoverwhelming ly +Bl ood +ĠFl int +ĠJ ama +ĠPres ent +ĠR age +ĠT A +pt ive +Ġturn out +w ald +ĠD olphins +ĠV PN +Ġon ion +Ġcraft ing +m ma +ĠMerc ury +Ġarr ange +Ġalert s +ĠO T +zb ollah +Ġg ases +ĠRichards on +s al +l ar +Ġfro st +Ġlower ing +Ġacc laim +Ġstart ups +ĠG ain +ess ment +Ġguard ian +äº º +ĠP ie +ĠL inks +Ġmer its +Ġaw ake +Ġparent al +Ġexceed s +Ġid le +ĠPil ot +Ġe Bay +ĠAc cept +ipe g +C am +ĠK ot +Ġtrad ers +olit ics +unk er +ĠP ale +os i +an mar +Ġ19 47 +ĠF ell +est ial +it ating +G F +ĠS r +if ted +Ġconnect or +ĠB one +ill es +2 60 +h ma +Ġoverl ap +ĠGit Hub +Ġclean er +ĠBapt ist +ĠW AS +Ġlung s +Ñ ģ +ĠB UT +Ġc ite +Ġpit ched +reat ment +Ġtro phies +ĠN u +38 6 +ĠPr ide +Ġattend ees +[ ] +17 9 +Ġspat ial +Ġpri zes +ĠRel igion +Ġshow case +ĠC ategory +vid ia +T arget +Pro perty +? , +Ġf usion +p ie +ĠU CLA +Ġsound track +Ġprin cess +ĠC aval +sh ould +Ġlim bs +Back ground +Ġlone ly +Ġc ores +ĠT ail +she et +Ġ13 2 +R a +ãĤ « +ĠB olt +Ġbook ed +Ġadmin ister +Ġequ als +w y +Ġobserv ing +ĠBar on +ĠAd obe +Ġv irgin +ĠSocial ist +M ove +gh azi +ĠLind a +2 12 +Ġbre wing +Ġmerch ants +bur se +Ġdiv or +Ġmet als +ĠN er +Ġsum s +ĠEn emy +Ġen vision +Ġgrant ing +ĠH oney +ĠSk yrim +Ġsoc io +gr aded +Ġselect ive +W ASHINGTON +Ġ19 48 +ĠSir ius +ĠG ross +act ivity +ĠI van +Ġfur ious +BS D +ĠPre vious +Ġrespons ive +Ġchar itable +Ġle aning +ĠP ew +Ġviol ates +\\\\ \\\\ +ĠCom ing +w ire +Ġpo et +Ġres olutions +comm and +ĠPortug uese +Ġnick name +Ġde af +Feb ruary +Ġrecogn ise +Ġentire ty +Ġseason al +pl aced +ĠTe legraph +Ġmicro phone +our ing +Ġgr ains +Ġgovern ed +Ġpost p +ĠW aters +in ement +Ġund ocumented +ĠCom cast +Ġf ox +Ġassault s +re on +man y +ĠJen kins +ĠAny way +Ġassess ments +Ġdown s +ĠM ouse +Ġsuper b +k t +ĠD ow +Ġtax ation +4 01 +Ġsm iles +Ġundert aken +Ġex h +Ġenthusi astic +Ġtw ent +Ġgovernment al +Ġautonom y +ĠTechn ologies +ĠCh ain +Ġpreval ent +f b +Ġnic otine +og ram +j ob +Ġawa iting +ĠMen u +Ġdep uties +k ov +ish ops +But ton +ĠShan ghai +Ġdies el +ĠD uck +R yan +ĠPC s +N F +j ury +ent e +Ġinacc urate +edd y +Wh atever +Ġshow c +ĠN ad +od us +et r +Ġplaint iffs +ĠW OR +ĠAss ange +Ġpriv at +Ġpremium s +Ġt am +UR L +Ġel ites +ĠR anger +otten ham +ĠH off +ĠAt hens +Ġdefin ite +Ġs ighed +Ġeven ly +2 11 +ĠAm ber +ak ia +Ġmail ing +Ġcr ashing +ĠConfeder ate +ru gged +W al +ĠDep ths +Ġjuven ile +Ġreact or +Introdu ction +ĠDel uxe +19 95 +ĠS anchez +ĠM ead +iv able +: - +ĠPlan ning +ĠT rap +qu in +ĠProt ect +ve red +In formation +Ġkid ney +inn amon +l as +Ġpolic ing +Ġtoler ate +ĠQ i +Ġbi ased +F ort +ĠK i +s ave +Ġprivile ged +Ġbe asts +ĠGl as +ĠC inem +Ġcome back +Sund ay +Ġext inction +h ops +Ġtrans mit +Ġdoub les +ĠFl at +16 7 +Ġdis puted +Ġinjust ice +f oo +V ict +role um +ĠJul ie +Con text +ĠR arity +iss ue +Comp onent +Ġcounsel ing +an ne +d ark +Ġobject ions +u ilt +Ġg ast +Ġpl ac +Ġun used +ãĥ ĩ +ĠT rial +ĠJ as +hed ral +ob b +Ġtempor al +ĠPR O +ĠN W +ĠAnn iversary +L arge +Ġther m +Ġd avid +Ġsystem ic +ĠSh ir +m ut +ĠNe pt +add ress +Ġscan ning +Ġunderstand able +Ġcan vas +C at +ĠZ oo +Ġang els +L O +ĠStat ement +ĠS ig +ov able +ĠA way +sh aring +ocr ats +st ated +Ġweigh ing +N or +w ild +B ey +Ġaston ishing +ĠReyn olds +Ġop ener +Ġtrain er +Ġsurg ical +p n +Ġadjust ing +whe el +Ġf rown +erv ative +Ġsusp end +With in +te in +Ġobst acle +Ġliber ties +ym es +Ġur anium +ans om +an ol +ub a +ĠL oss +Ġa rous +ĠHend erson +W ow +s pl +c ur +ĠÂ Ń +Ġtheir s +Dam age +Ġdownload ing +Ġdisc ern +ĠSt o +ĠFl a +Ġh ath +ĠA j +Ġun pleasant +Europe an +exp ensive +Ġscreens hot +ĠU V +Ġall ied +ĠPers ian +Ġmonop oly +Ġat om +ĠReds kins +"> < +Ġcan cell +Ġcinem a +13 1 +f air +ĠAlf red +Ġd uck +arg s +22 3 +ĠIS I +Ġsign aling +in ar +Ġlaugh s +Ġfor wards +Ġreck less +Ġlisten ers +at ivity +Ġvast ly +n ant +L ess +ĠHun ting +ĠScient ific +IT ED +Ġkn ight +ĠH TC +us a +t mp +Ġr ude +ĠLegend ary +Ġar ises +B ad +ĠCl aim +pe g +Ġreal ities +Th ink +Ġ ° +Ġro de +Ġstri ve +Ġan ecd +Ġshort s +Ġhypot hes +Ġcoord inated +ĠGand hi +ĠF PS +R ED +Ġsuscept ible +Ġshr ink +ĠCh art +Hel p +Ġ ion +de ep +rib es +ĠK ai +ĠCustom er +Sum mary +Ġc ough +w ife +Ġl end +Ġposition ing +Ġlot tery +ĠC anyon +Ġf ade +Ġbron ze +ĠKenn y +Ġbo asts +ĠEnh anced +rec ord +Ġemer gence +Ġa kin +ĠB ert +it ous +âĸ ij +Ġst ip +Ġexch anged +om ore +als h +Ġreserv oir +Ġstand point +W M +Ġiniti ate +Ġdec ay +Ġbrew ery +Ġter ribly +Ġmort al +lev ard +Ġrev is +N I +el o +Ġconf ess +ĠMS NBC +Ġsub missions +Cont roller +Ġ20 2 +ĠR uth +} ); +ĠAz ure +Ġ ." +20 6 +ĠMarket ing +Ġl aund +ien cies +Ġrenown ed +ĠT rou +ĠN GO +ble ms +Ġterr ified +Ġwar ns +Ġper t +Ġuns ure +4 80 +ale z +ult z +ĠOut side +Ġst yl +ĠUnder ground +Ġp anc +Ġd ictionary +Ġf oe +rim inal +ĠNor wegian +Ġj ailed +Ġm aternal +é e +ĠLu cy +c op +Ch o +Ġuns igned +ĠZe lda +ĠIns ider +ĠContin ued +Ġ13 3 +ĠNar uto +ĠMajor ity +16 9 +ĠW o +ãĤ ĵ +Ġpast or +Ġinform al +Ð ½ +an throp +jo in +ãģ Ĺ +it ational +N P +ĠWrit ing +f n +ĠB ever +19 5 +Ġy elling +Ġdr astically +Ġe ject +Ġne ut +Ġth rive +ĠFre qu +ou x +Ġpossess es +ĠSen ators +ĠD ES +ĠSh akespeare +ĠFran co +ĠL B +uch i +Ġinc arn +Ġfound ers +F unction +Ġbright ness +ĠB T +Ġwh ale +ĠThe ater +m ass +ĠD oll +S omething +Ġecho ed +ĠHe x +c rit +af ia +Ġgodd ess +Ġele ven +ĠPre view +ĠAur ora +Ġ4 01 +uls ive +ĠLog an +in burgh +ĠCent ers +ĠON LY +ĠA id +Ġparad ox +Ġh urd +ĠL C +D ue +c ourt +Ġoff ended +Ġeval uating +ĠMatthew s +Ġto mb +Ġpay roll +Ġextra ction +ĠH ands +if i +Ġsuper natural +ĠCOM M +] = +dog s +Ġ5 12 +ĠMe eting +Rich ard +ĠMax imum +Ġide als +Th ings +m and +ĠReg ardless +Ġhum ili +b uffer +L ittle +ĠD ani +ĠN ak +Ġliber ation +ĠA be +ĠO L +Ġstuff ed +ac a +ind a +raph ic +Ġmos qu +Ġcampaign ing +Ġoccup y +S qu +r ina +ĠW el +ĠV S +Ġphys ic +Ġp uls +r int +oad ed +ET F +ĠArch ives +Ġven ues +h ner +ĠTur bo +Ġl ust +Ġappeal ed +que z +il ib +ĠTim othy +Ġo mn +d ro +Ġobs ession +ĠSav age +19 96 +Gl obal +J es +2 14 +Ġsl iding +Ġdisapp ro +ĠMag ical +Ġvolunt arily +g b +ane y +Ġprop het +ĠRe in +ĠJul ia +ĠW orth +aur us +Ġb ounds +ie u +)) ) +Ġcro re +ĠCitiz en +S ky +Ġcolumn ist +Ġseek ers +ond o +IS A +ĠL ength +Ġnost alg +Ġnew com +Ġdet rim +ent ric +3 75 +ĠG E +Ġaut op +Ġacadem ics +App Data +ĠS hen +Ġid iot +ĠTrans it +Ġteasp oon +W il +K O +ĠCom edy +> , +Ġpop ulated +W D +Ġp igs +ĠO culus +Ġsymp athetic +Ġmar athon +19 8 +Ġseiz ure +s ided +Ġd op +irt ual +L and +ĠFl oor +osa urs +... ] +Ġl os +Ġsubsid iary +E Y +ĠPart s +ĠSt ef +ĠJud iciary +Ġ13 4 +Ġmir rors +Ġk et +t imes +Ġneuro log +Ġc av +ĠGu est +Ġtum or +sc ill +ĠLl oyd +E st +Ġcle arer +Ġstere otypes +Ġd ur +not hing +Red dit +Ġnegoti ated +---------------- -------- +23 5 +Ġfl own +ĠSe oul +ĠRes ident +ĠS CH +Ġdisappear ance +ĠV ince +g rown +Ġgrab s +r il +ĠInf inite +ĠTw enty +Ġpedest rian +Ġjer sey +ĠF ur +ĠInf inity +ĠEll iott +Ġment or +Ġmor ally +Ġob ey +sec ure +iff e +Ġantib iotics +ang led +ĠFre eman +ĠIntrodu ction +J un +Ġm arsh +ic ans +ĠEV ENTS +och ond +W all +icult y +Ġmisdem eanor +Ġl y +Th omas +ĠRes olution +Ġanim ations +ĠD ry +Ġinter course +ĠNew castle +ĠH og +ĠEqu ipment +17 7 +Ġterrit orial +Ġarch ives +20 3 +Fil ter +ĠMun ich +Ġcommand ed +ĠW and +Ġpit ches +ĠCro at +Ġrat ios +ĠM its +Ġaccum ulated +ĠSpecific ally +Ġgentle man +acer b +Ġp enn +Ġa ka +ĠF uk +Ġinterven e +ĠRef uge +ĠAlz heimer +Ġsuccess ion +oh an +d oes +L ord +Ġsepar at +Ġcorrespond ence +Ġsh iny +P rior +Ġs ulf +Ġmiser able +Ġded ication +( ). +Ġspecial ists +Ġdefect s +ĠC ult +ĠX ia +Ġje opard +ĠO re +Ab ility +Ġle ar +Ġamb itions +ĠB MI +ĠArab s +Ġ19 42 +Ġpres ervation +ific ate +Ġash amed +l oss +ĠRest aur +Ġrese mble +Ġen rich +ĠK N +ĠCl an +fl oat +Ġplay able +IT T +Ġharm ony +arr ison +ĠWe instein +w ere +Ġpoison ing +ĠCom put +ĠWord Press +m ajor +ĠVal ve +F an +ĠTh row +ĠRom ans +ĠDep ression +ad os +Ġtort ured +Ġbal ancing +bott om +Ġacqu iring +ĠMon te +ard i +Ġa ura +Ġ# # +ĠStand ing +ĠAtl as +C F +Ġintr ins +ĠBen ghazi +Ġcamp ing +Ġt apped +bl ade +st rous +ĠR abb +ĠW ritten +t ip +ĠNe igh +ster dam +ĠAll ow +ĠHe aling +ĠR hod +n um +Ġcaffe ine +ĠPer cent +Ġbo o +Ġapp les +30 5 +Ġwel coming +Ġappl aud +Ġa usterity + ± +ĠRe ality +ef e +å ® +Ġsu cks +Ġtab s +ĠPay Pal +Ġback pack +Ġgif ted +abul ary +ĠSc out +ir teen +Ġch in +Ġo mitted +Ġnegative ly +Ġaccess ing +ĠE arn +Ġambul ance +Ġhead phones +Ġ20 5 +ĠRef resh +p resident +ĠKit chen +ĠEnt ered +ĠS nyder +00 5 +om ical +Ġborrow ed +ĠN em +Ġav iation +Ġst all +rim ination +Ġuniform s +it ime +ĠSim mons +ener gy +ab lished +y y +qual ified +Ġrall ies +ĠSt uart +fl ight +Ġgang s +r ag +Ġv ault +lu x +ĠCom par +Ġdesign ation +20 9 +ĠJ os +d ollar +z ero +Ġwell s +30 3 +Ġconstitu ents +Ġhe ck +Ġc ows +Ġcommand ers +Ġdifferent ial +ĠC atherine +29 9 +Ġval ve +Ġbr ace +Ġperspect ives +c ert +f act +icular ly +ĠMc N +pl anes +Ġint ric +Ġpe as +ov an +Ġtoss ed +ret ch +ĠL opez +Ġunf amiliar +de ath +ĠA part +ĠCh ang +Ġrelie ved +rop he +Ġair ports +Ġfre ak +ut il +M ill +ĠCh in +ĠOw en +m ale +ĠBro ken +ĠWind s +ro b +r ising +Ġfire fighters +Ġauthor itarian +Ġ14 8 +Bit coin +ex ternal +Ġbrow sers +iche ver +or ian +Ġun b +Ġpo ke +ĠZ ot +M id +ĠPop ular +Ġco vert +Ġcont ributes +Ġ6 50 +Ġcont ention +G ate +Ġcons oles +Ġchrom os +ĠI X +Ġvis ually +ĠE isen +Ġjewel ry +Ġdeleg ation +Ġacceler ate +ĠR iley +Ġsl ope +Ġind oor +it ially +Ġhuge ly +Ġtun nels +Ġfin ed +Ġdirect ive +Ġfore head +ustom ed +Ġsk ate +Mus ic +g as +Ġrecogn izing +am bo +Ġover weight +ĠGr ade +Ù Ĭ +Ġsound ing +Ġlock ing +ĠR EM +St ore +Ġexc av +ĠLike wise +ĠL ights +Ġel bow +ĠSupp ly +w ic +Ġhands ome +19 94 +C oll +Ġadequ ately +ĠAssoci ate +Ġstri ps +Ġcrack down +Ġmar vel +ĠK un +Ġpass ages +@@ @@ +ĠT all +Ġthought ful +names e +Ġprost itution +bus iness +Ġball istic +person al +c ig +iz ational +R ound +ĠÂłĠÂł ĠÂłĠÂł +ĠCole man +Ġadm itting +ĠPl ug +Ġbit coins +ĠSu z +Ġfair ness +Ġsupp lier +Ġcatast rophic +ĠHel en +o qu +M arc +ĠArt icles +g ie +Ġend angered +Ġdest iny +ĠVol t +ol ia +ax is +Ġche at +Ġun ified +IC O +qu ote +30 2 +ĠS ed +Ġsupp ression +Ġanaly zing +Ġsqu at +Ġfig uring +Ġcoordin ates +Ġch unks +Ġ19 46 +Ġsub p +Ġw iki +ĠFor bes +ĠJ upiter +ĠE rik +im er +ĠCom mercial +\ ) +Ġlegitim acy +Ġd ental +ĠMe an +Ġdefic its +5 50 +Orig inally +ĠHor ror +Ġcontam ination +ll ah +Ġconf isc +ĠCl are +T B +ĠF ailed +an ed +Ġrul er +ĠCont roller +Ġfemin ists +F ix +g ay +20 7 +Ġr abbit +Th ird +ownt own +Ġgl ue +Ġvol atile +Ġsh ining +Ġf oll +Ġimp aired +Ġsup ers +æ Ī +Ġcl utch +ļé ĨĴ +Ġpro let +Ġ( ! +Ġy elled +ĠK iev +ĠEr n +ĠSh ock +K B +Ġsit uated +qu ery +ĠN as +Ġan nex +char acter +ĠHol iday +Ġautom ation +ĠJ ill +ĠRem astered +Ġl inem +Ġwild erness +ĠHor izon +ĠGu inea +A Z +Ġmain land +Ġsec recy +LE ASE +Ġp unk +ĠProv ince +( ), +Spe ed +Ġhand ing +ĠSeb ast +S ir +r ase +Ġj ournals +Ġcon gest +ĠT ut +ir rel +Ġschizophren ia +Ġmis ogyn +health y +I ron +Ġreact ed +- $ +25 2 +Ġpl ural +Ġpl um +Ġbarg ain +Ġground ed +f inder +Ġdis se +ĠL az +O OD +Ġat roc +F actory +Ġmin ions +Ġo ri +ĠB rave +ĠP RE +ĠMy anmar +ĠH od +Ġexped ition +Ġexpl ode +ĠCo ord +Ġext r +ĠB rief +ĠAD HD +Ġhard core +feed ing +Ġd ile +ĠF ruit +Ġvacc ination +ĠM ao +osp here +Ġcont ests +- | +Ġf ren +isp here +R om +ĠSh arp +ĠTre nd +Ġdis connect +âĢ¢ âĢ¢ +Ġper secution +Ear th +Ġhealth ier +38 4 +Ġc ob +ĠTr inity +OW S +AN N +Ġspecial ty +Ġg ru +Ġcooper ative +wh y +Start ing +ĠIss ues +st re +ens or +Ġ18 5 +Ad v +! ? +ĠRe vel +em ia +ĠH ulk +Ġcelebr ations +ĠS ou +ra ud +ĠKle in +Ġun real +con text +Ġpartners hips +Ġadop ting +t ical +Ġspl ash +ĠHe zbollah +c ategory +cycl op +xt on +ĠD ot +urd y +t z +Ġenvelop e +ĠN L +â ķ +Ġwhere in +Spe c +18 4 +Ġte lev +al iation +Ġmyth s +å ° +Ġrig orous +Ġcommun icating +Ġobser ver +Ġre he +ĠW ash +Ġapolog ized +ĠT in +Ġexpend itures +work ers +d ocument +Ġhes itate +ĠLen in +Ġunpredict able +Ġrenew al +cl er +ok ia +ĠCON T +Ġpost season +Tok ens +Ġex acerb +Ġbet ting +Ġ14 7 +Ġelev ation +W ood +ĠSol omon +19 4 +00 4 +out put +Ġredu nd +ĠM umbai +Ġp H +Ġreprodu ce +ĠD uration +MA X +Ġb og +C BS +ĠBal ance +ĠS gt +ĠRec ent +Ġc d +Ġpo pped +Ġincomp et +pro p +ay an +g uy +Pac ific +Ġty r +Ġ{ { +ĠMy stic +ĠD ana +Ġmast urb +Ġge ometry +à ¢ +ĠCor rect +Ġtraject ory +Ġdistract ed +Ġf oo +ĠW elsh +L uc +m ith +Ġrug by +Ġrespir atory +Ġtri angle +Ġ2 15 +Ġunder graduate +ĠSuper ior +ch anging +_ - +Ġright ly +Ġrefere e +Ġluc rative +Ġun authorized +Ġresemb les +ĠGN U +ĠDer by +Ġpath ways +ĠL ed +Ġend urance +Ġst int +Ġcollect or +F ast +Ġd ots +Ġnational s +ĠSec urities +Ġwh ip +Par am +Ġlearn s +M agic +Ġdetail ing +m oon +Ġbroadcast ing +Ġb aked +26 5 +hol m +ĠS ah +ĠHus sein +ĠCourt esy +17 4 +Ġ14 6 +Ġge ographic +pe ace +Ġjud ging +ĠS tern +B ur +Ġstory line +G un +ĠSt ick +24 5 +30 7 +ãĤ´ ãĥ³ +ĠAdminist rator +Ġbur nt +Ġp ave +ch oes +Ex ec +Ġcamp uses +Res ult +Ġmut ations +ĠCh arter +Ġcapt ures +Ġcomp ares +Ġbad ge +S cient +Ġer ad +ier y +o i +ett es +ĠE state +Ġst rap +Ġproud ly +Ġf ried +Ġwithd rawn +ĠV oy +ph ony +It ems +ĠP ierce +b ard +Ġann otation +ant on +ill on +Im pro +... ) +Ġhapp ier +---- -- +ad just +Ġstaff ers +Ġactiv ism +Ġper f +Ġal right +N eed +Ġcomm ence +Ġopio id +ĠAm anda +E s +ĠP ars +ĠK aw +W orks +24 8 +Ġind o +t c +end ant +ĠM oto +Ġlegal ization +OT E +Ġtask ed +Ġt sp +ĠACT IONS +16 6 +Ġrefres hing +ĠN R +ĠPere z +Ġinfring ement +S Y +List en +in ning +k u +Ġrot ate +pro gram +ar ah +Des ign +Ġ( £ +Ġst oring +Ġwar rants +Ġjud gement +ĠB rist +us ually +ph oto +ĠR an +ĠP ine +Ġoutrage ous +ĠValent ine +lu ence +ĠEvery body +Al tern +Ġrele vance +Ġtermin ated +Ġd essert +Ġfulf illed +Ġprosecut ed +ĠW ords +Ġm igrant +Ġcultiv ation +ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ +idel ity +ĠV ern +ĠLog in +Ġmetaph or +ĠT ip +Ġrecru its +ĠP ig +rib ing +Ġenthusi asts +ex per +Ġfright ening +ĠH air +ans on +str ate +Ġh i +He ight +Ġown ing +n one +Ġdis like +Ġkn ives +pher d +Ġloud ly +ĠAP Is +Dis play +ĠL ac +ĠUS S +ab l +ver ages +J ew +Ġ17 2 +ĠHist orical +at oon +ĠPhys ics +in tern +Ġwarm th +Ġto pp +D M +Ġgun man +Ġem peror +od i +ãĥ £ +in atory +ĠR ib +Ġ13 1 +ĠSat urn +ĠSh ining +Ġw aking +Qu otes +Ġcomed ian +en berg + ½ +Ġbelie vers +Ġpaper work +c ustom +Ġle v +Ġl ament +Ġpour ing +22 2 +p olitical +ĠSupp lement +m aid +Ġcruel ty +Ġt read +ys ics +A w +rit es +Ġmod ifier +ĠP osition +Ad am +l b +ub s +Ġimper fect +Ġcl usters +ĠEngine er +ĠC herry +Ġinaug uration +ĠS au +Ġembod iment +ĠUn cle +Ġover r +Ġexplos ions +c ule +ĠPrinc eton +ĠAndre a +Ġincorrect ly +Ġearn est +Ġpil gr +ĠS print +Ġslee ve +Ġhe ars +ĠAm azing +Ġbrow sing +ag in +Ġhom eland +Ġha w +Ġd iving +ist ered +17 8 +Ġbarg aining +ĠArc ade +Ġdeleg ate +ters on +................................ ................................ +ĠJackson ville +27 5 +Ġst agn +Ġad am +ĠSher man +C B +Ġsub urb +ĠFood s +Ġconver ting +ĠAr ist +Ġch ambers +l ove +Ġam ino +ĠG an +Ġmad ness +m c +ĠUS E +def ined +Ġul tr +ind ust +Ġw olves +l ance +Add itionally +Ġcr acks +as ia +ĠRe ason +ĠP ump +Ġaccident al +ĠL aser +ĠR id +Ġinitial ized +ell i +Ġun named +Ġn oun +ĠPass ed +Ġhost age +ĠEth iop +sh irts +Ġun rel +ĠEmb assy +Ġ19 41 +Ġat oms +Ġpur ported +16 4 +ĠF i +Ġgall ons +ĠMon ica +Ġp g +en ment +Ġsort ed +ĠG ospel +Ġhe ights +Ġtr aced +Ġunder going +She ll +Ġs acks +Ġproport ions +Ġhall uc +F ont +ac et +Ġwar mer +ĠIN TER +Ġgrab bing +Pl ug +Ġreal ization +ĠBur ke +Ġen chant +AT ER +ĠSe ed +Ġabund ant +F M +Ġc ivic +V s +is i +Ġv ow +Ġre per +ĠPartners hip +Ġpenet ration +Ġax e +Ġsh attered +ĠZ ombies +Ġv inyl +ĠAl ert +e on +Ġoblig ed +ĠIll ust +ĠPl aza +ĠFront ier +Ġdavid jl +ĠSer ial +ĠH av +ĠNut rition +B i +Ġâĸ Ī +ĠJ ays +lin ux +Ġhur ry +Ġv oy +Ġhop eless +ĠSte alth +Ġ ãģ +ess ors +tt le +b org +ĠSaf ari +f ell +Ġw ary +d ue +ĠAb ove +H a +E LL +Ġnot or +ĠW on +T oo +Ġoccup ations +Ġposs essions +Ġinv iting +Ġpred ators +Ġacceler ated +Ġ15 7 +uter te +ĠC ube +e ast +acc ount +G ive +Ġtrans plant +red ients +id able +Ġscreens hots +ĠG und +ĠF S +Ġtravel ers +Ġsens ory +ĠF iat +ĠRock ets +İ ĭ +_ { +F riend +Ġchar ming +AL S +Ġenjoy ment +m ph +Ġ5 000 +ĠRE G +Ù Ĩ +b ia +Ġcomp ilation +ro st +ĠV P +ĠSch ne +201 9 +Ġcop ying +M ORE +ĠFl ore +f alls +2 15 +t otal +Ġdis ciples +d ouble +Ġexceed ing +Ġsm ashed +Ġconcept ual +ĠRom ania +ĠB rent +ĠI CE +ĠT ou +Ġg rap +Ġn ails +18 9 +ãĥ ĺ +Ġproc ure +e ur +Ġconfir ming +ĠC ec +aw i +ĠEd en +Ġn g +Ġengine ered +at ics +Ġhook ed +Ġdisgust ing +ĠMur der +ãĤ ¿ +L ibrary +Ġ16 8 +Al most +hem atic +Men u +ĠNot re +ĠJ ur +Ġkidn apped +Ġhack er +ĠJ ade +Ġcreep y +Ġdraw ings +ĠSpons or +Ġcycl ists +ĠGob lin +Ġoptim ized +Ġst aged +ĠMc D +bet ween +A ge +en o +S ex +ĠW ide +n ings +av is +Ġincap able +ĠK ob +Ġreward ing +ĠL one +oles cent +Ġcontract ed +Ġstick y +J ose +B all +f est +ĠIn put +ĠRec ently +Ġto mat +squ are +App lication +Ġnit rogen +Ġdupl icate +ĠRec on +ĠD ear +L ondon +Ġint ra +Ġd ock +Ġout reach +ĠM illion +Ġmamm als +am pton +V AL +Ġsn aps +Ġd os +ĠWh ole +ĠRead y +T ry +ĠWinn ipeg +ear ance +Ġinc urred +ren ched +ĠNS W +il ot +rain e +Ġc ube +g ot +Ġrun way +etermin ed +ĠHaw ks +Ġsurviv or +ĠW ish +ĠD in +ĠDE F +ĠV ault +18 7 +Ġmush rooms +Ġcris p +be y +ĠDisco very +Ġdevelopment al +Ġparad igm +Ġcha otic +ĠT su +Ġ3 33 +b ons +Ġbacter ial +Ġcomm its +Ġcos mic +Ġme ga +oc ative +ĠP aint +ophob ic +Ġv ain +Ġcar ved +ĠTh ief +ĠG ul +ows hip +Ġc ites +ĠEd inburgh +Ġdimin ished +Ġacknowled ges +ĠK ills +Ġmic row +ĠHer a +Ġsen iors +Ġwhere by +H op +at ron +Ġun available +ĠN ate +Ġ4 80 +Ġsl ated +ĠRe becca +ĠB attery +Ġgram mar +Ġhead set +Ġcurs or +Ġex cluding +any e +aunder ing +eb in +Ġfeas ible +ĠPub lishing +ĠLab s +ĠCl iff +ĠFerr ari +Ġp ac +vis ible +mark ed +pe ll +Ġpol ite +Ġstagger ing +ĠGal actic +Ġsuper st +Ġpar an +ĠOffic ers +ãĢ ģ +Ġspecific s +ul us +23 9 +ĠP aste +AM P +ĠPan ama +ĠDe lete +angu ard +rest rial +Ġhero ic +ĠD y +ا ÙĦ +Ġincumb ent +Ġcr unch +t ro +Ġsc oop +Ġblog ger +Ġsell ers +ure n +Ġmedic ines +ĠC aps +ĠAnim ation +ox y +Ġout ward +Ġinqu iries +22 9 +Ġpsych ologist +ĠS ask +ev il +Ġcontam inated +ãĤ ¨ +he rence +Ġbrand ed +ĠAbd ul +z h +Ġparagraph s +Ġmin s +Ġcor related +er b +Ġimp art +Ġmil estone +ĠSol utions +ot le +Ġunder cover +Ġmar ched +ĠCharg ers +f ax +ĠSec rets +Ġr uth +we ather +Ġfemin ine +Ġsh am +Ġprest igious +igg ins +Ġs ung +hist ory +ett le +gg ie +Ġout dated +ol and +Ġper ceptions +ĠS ession +ĠDod gers +u j +ĠE ND +D oc +Ġdefic iency +Gr and +ĠJ oker +Ġretro spect +Ġdiagn ostic +Ġharm less +Ġro gue +ĠA val +E qu +Ġtrans c +ĠRoberts on +ĠDep ending +ĠBurn s +iv o +Ġhost ility +F eatures +ĵ ĺ +Ġdis comfort +ĠL CD +spec ified +ĠEx pect +3 40 +Ġimper ative +ĠReg ular +Ch inese +Ġstate wide +Ġsy mm +Ġlo ops +Ġaut umn +N ick +Ġsh aping +Ġqu ot +Ġc herry +ĠCross ref +è¦ ļéĨĴ +Stand ard +he ed +ĠD ell +ĠViet namese +Ġo st +ĠV alkyrie +O A +Ass ad +Ġreb ound +ĠTra ffic +pl aces +æ ĺ +ĠB uc +17 2 +Ġshel ters +Ġins isting +ĠCertain ly +ĠKenn eth +ĠT CP +Ġpen al +ĠRe play +he ard +Ġdial ect +iz a +ĠF Y +it cher +ĠD L +Ġspir al +Ġquarterback s +Ġh ull +Ġgo ogle +Ġto dd +ĠSter ling +ĠPl ate +Ġsp ying +mb ol +ĠReal m +ĠPro ced +ĠCr ash +Ġtermin ate +Ġprotest ing +C enter +gu ided +Ġun cover +Ġboy cott +Ġreal izes +s ound +Ġpret ending +ĠV as +19 80 +Ġfram ed +Ġ13 9 +Ġdesc ended +Ġrehab ilitation +Ġborrow ing +ĠB uch +Ġbl ur +R on +ĠFro zen +en za +Ch ief +ĠP oor +Ġtransl ates +M IN +Ġ2 12 +J ECT +Ġerupt ed +Ġsuccess es +S EC +Ġpl ague +Ġg ems +d oms +Ġstret ches +ĠSp y +Ġstory telling +C redit +ĠP ush +Ġtra ction +Ġin effective +ĠL una +Ġt apes +Ġanaly tics +erc ise +Ġprogram mes +ĠCar bon +Ġbeh old +he avy +ĠConserv ation +ĠF IR +Ġs ack +ter min +ric ks +Ġhous ed +Ġunus ually +I ce +Ġexecut ing +ĠMor oc +ed ay +Ġed itions +Ġsm arter +ĠB A +Ġout law +Ġvan ished +ib a +AL SE +ĠSil va +23 8 +C ould +Ġphilos opher +Ġevac uated +Sec ret +14 2 +Ġvis as +ãĤ ¬ +ĠM alt +ĠClear ly +ĠN iger +ĠC airo +ĠF ist +3 80 +ĠX ML +aut o +it ant +Ġrein forced +Rec ord +ĠSurviv or +G Hz +Ġscrew s +parent s +Ġo ceans +ma res +Ġbra kes +vas ive +Ġhell o +ĠS IM +rim p +Ġo re +ĠArm our +24 7 +Ġterr ific +Ġt ones +14 1 +ĠMin utes +Ep isode +Ġcur ves +Ġinflamm atory +Ġbat ting +ĠBeaut iful +L ay +Ġunp op +v able +Ġr iots +ĠTact ics +b augh +ĠC ock +Ġorg asm +ĠS as +Ġconstruct or +et z +G ov +Ġant agon +Ġthe at +Ġde eds +ha o +c uts +ĠMc Cl +Ġu m +ĠScient ists +Ġgrass roots +ys sey +"] => +Ġsurf aced +Ġsh ades +Ġneighb ours +Ġad vertis +oy a +Ġmer ged +Up on +Ġg ad +Ġanticip ate +Any way +Ġsl ogan +Ġdis respect +I ran +ĠT B +act ed +Ġsubp oen +medi ately +OO OO +Ġwa iver +Ġvulner abilities +ott esville +ĠHuff ington +J osh +ĠD H +M onday +ĠEll en +K now +x on +it ems +22 8 +Ġf ills +ĠN ike +Ġcum ulative +and als +I r +Ġ ì +Ġfr iction +ig ator +Ġsc ans +ĠVi enna +ld om +Ġperform ers +P rim +Ġb idding +M ur +Ġlean ed +ĠPri x +al ks +Ġ[ âĢ¦] +ĠTw itch +ĠDevelop er +ĠG ir +Ġcall back +Ab stract +Ġacc ustomed +Ġfreed oms +ĠP G +ur acy +Ġl ump +is man +,, ,, +19 92 +ĠR ED +Ġwor m +M atch +ĠPl atinum +I J +ĠOwn er +Tri via +com pl +Ġnew born +Ġfant as +O wn +Ġ19 59 +Ġsymp ath +Ġub iqu +Ġoutput s +Ġal lev +Ġpr ag +K evin +Ġfav ors +Ġbur ial +Ġn urt +so lete +c ache +Ġ15 6 +Ġunl ocks +te chn +M aking +Ġcon quer +ad ic +æ ĸ +Ġel f +Ġelect orate +ĠKurd s +ĠSt ack +ĠSam urai +Ġâ ĺħ +Ġ{ } +ĠS aid +ĠFall out +Ġkind ness +ĠCustom s +ĠBou levard +Ġhelicop ters +ot ics +ĠVe get +com ment +Ġcritic ised +Ġpol ished +ĠRem ix +ĠC ultural +Ġrec ons +Ġdo i +at em +Sc reen +Ġbar red +Com ments +ĠGener ally +Ġsl ap +7 20 +V ari +p ine +Ġem pt +Ġh ats +ĠPlay ing +l ab +a verage +form s +ĠC otton +Ġcan s +ĠD ON +ĠSom alia +C rypt +ĠIncre ases +E ver +mod ern +Ġsur geon +3 000 +Ġrandom ized +================================ ================================ +B ern +im pl +ĠC OR +Ġpro claim +th ouse +Ġto es +Ġam ple +Ġpres erving +Ġdis bel +gr and +B esides +Ġsil k +ĠPat tern +h m +Ġenter prises +Ġaffidav it +ĠAdvis ory +Ġadvert ised +ĠRel igious +se ctions +psy ch +ĠField s +aw ays +Ġhasht ag +ĠNight mare +Ġv ampire +Ġfore nsic +rosso ver +n ar +Ġn avy +Ġvac ant +ĠD uel +Ġhall way +Ġface book +ident ally +ĠN RA +Ġm att +Ġhur ricane +ĠKir by +ĠP uzzle +Ġsk irt +ou st +du llah +Ġanal ogy +in ion +Ġtomat oes +ĠN V +ĠPe ak +ĠMe yer +Ġappoint ments +Ġm asc +Ġal ley +re hend +Ġchar ities +Ġund o +Ġdest inations +ĠTest ing +"> </ +Ġdest ined +Ġimp lements +ĠHar old +RE CT +Ġoptim ization +Ġkilomet res +Ġc md +Ġimpair ment +Ġun successful +Ġswift ly +ĠGlas gow +art en +ĠSh ares +ĠAn swer +ĠAl bum +Ġnut ritional +ãĥ ĸ +ĠF ut +Ġbl oc +ĠN FC +Ġwholes ale +ĠC W +Ġneg lected +Ġlaun cher +Ġannounce ments +OU LD +com b +Ġrot ating +Ġrest s +ĠT icket +ched el +L ou +ĠV ic +Ġ" ' +Ġtem plates +Ġrepl aces +Ar c +:: :: +ĠGil bert +Ġillness es +Ġsched ules +Ġheter osexual +L INE +Ġhere in +Ġco erc +Ġdecre asing +Ġde portation +s udo +ĠInd igenous +Ġweigh s +Al ong +' ); +ĠBeng als +70 7 +Ġjoint s +ver ts +Ġ14 9 +na ire +Ġsimpl est +Ġl ore +10 80 +f iction +ĠDat abase +Ġreserv ation +Ġs ou +Ġsan ctuary +aud io +ap le +Ġveget arian +Ġanticip ation +m icro +Ġend uring +Ġdepart ed +Ġsidew alk +Ġprohib its +ĠF ont +Ġcomp ute +ĠS ect +Ġ15 8 +B attle +Ġbom ber +Ġdist raction +Ġend ured +Ġpractition ers +Ġdistur bed +Ġdr ank +ord ered +Ġsurpr ises +se at +Sec urity +ĠW isdom +og o +Ġsub paragraph +ĠPen insula +ĠOrig ins +ire n +ĠP av +igg le +Ġgrat itude +ĠG ravity +over ty +im an +ct r +ĠCa esar +c ould +g em +Ġsk ies +Ġch amp +Ġagree ing +F amily +D iv +17 6 +Ġmess y +um ption +F ederal +ern o +ĠCh at +Bey ond +Ġdev ote +ĠW alsh +Ġdump ed +Ġaccum ulation +st ad +hib ition +Ġsm okers +Ġinspect or +F rench +iss an +ĠV ita +Ġresearch ing +R AM +ĠCelt ics +Ġcl oak +ĠTer ra +M ary +so ld +ĠD OM +mod s +Int el +Ġmult itude +ĠImpro ved +Ġrel iance +Ġartif act +Ġalarm ing +P rom +h on +T ION +med ium +Ġref lex +ĠEx cel +Ġweaken ed +16 3 +2 24 +Ġcost umes +Ġunique ly +Ġs orrow +Ġm ansion +w p +Ġsal v +ĠGro ve +bs p +ĠSn iper +ĠSh ipping +ĠP OW +Ġund is +Ġbrand ing +G irl +ĠAh mad +ĠL akes +ĠCore y +Ġinherit ance +ener y +Ġpack ing +ĠP rest +D est +F W +Ġregul ator +l ocked +Ġcont ested +ĠMel issa +ĠD uc +Ġunpop ular +Ġst acked +Ġ19 17 +Ġyear ly +Ġst are +Ġassess ing +à ¸ +Ġbe verages +Ġcompet itions +Ġstreng thening +al ong +ĠL ud +Ġmel ted +stan bul +Ġb ounty +EN C +ĠL ands +Ġdecl ares +Ġcustom ize +Ġcomp osite +ãĥ ¬ +C M +ograph ics +ĠTem p +Ġcont ender +Ġins ign +ĠL AN +Ġdis asters +ins pired +Ġjud gments +ustain able +urs ion +Ġvar iance +ĠUlt imately +Ġ -------- +u ador +ĠR X +Ġmel ting +ĠExt ended +ĠT we +M ajor +ĠB il +Ġsy rup +qu ick +ĠHold er +Ġinnoc ence +U LE +ĠM ight +99 99 +Ġf al +Ġcontinu ity +Ġ19 53 +ĠB S +st ill +L at +ĠAb use +Ġun supported +xxxx xxxx +Ġinst itute +Ġfrag ment +ĠP ep +W estern +ĠC ause +ĠFr ag +ĠAr s +à ¥ +ast ics +Ġb ishop +Ġcross es +Ġ15 4 +ĠUp grade +Ġmit igate +ĠRay mond +Mod s +Ġtom ato +Ġst umbled +Ġdiff ers +In itial +ĠR aspberry +Ġign ores +Ġt ant +à ł +Ġrel ay +Ġb isexual +Ġconf ession +Ġd ement +in as +ĠHe ather +pl atform +dri ving +bour g +ĠM ush +Ġhy ster +Det ails +Ġdr ift +ĠW ald +ĠLuck ily +or f +Ġexp ire +ĠP unch +zy me +g old +Ġunp aid +ĠT rent +Ġun armed +Ġill icit +ĠT ottenham +Ġsm ash +Intern ational +ink er +Ġst ing +ĠSadd am +ĠAR T +Ġtruth s +b irth +Ġso ber +ĠN it +Ġ ib +Ġus able +Ġst acks +ĠSy lv +Ġnort heast +Ġdom ination +ĠM our +EN SE +ĠMe asure +Ġprogram mer +Ġ< - +18 2 +ĠCond ition +Ġback yard +ir ling +ĠJ eb +ĠCre ed +ĠH ang +ĠCOM P +F ER +ĠIs h +Ġdetect ives +------------ --- +ĠMess enger +Ġlo oph +Ġgate way +15 1 +ĠMaterial s +ĠD T +Ġdo omed +od o +Ġslic es +Ġemail ed +ĠPer l +Ġren ov +UT H +ody nam +ĠSouth west +get ic +ĠT PP +Ġoptim ism +ĠT ow +ul ators +prot ected +y les + « +Ġex ile +en v +P rop +ĠZimmer man +Ù İ +C a +om aly +ãĥ Ĩ +Ġrail road +L ee +23 2 +Ġrepl icate +Ġcomfort ably +act ly +Ġr av +Ġtelesc ope +Ġhonest y +ĠPe pper +ĠBr ing +Ġric hest +Ġout doors +Ġh alls +Ġcont end +IS E +Ġsub mitting +Ġna ive +ar ations +Ġ14 3 +Ġpo ised +respons ible +Ġsoc ks +ĠSk ull +Quest ion +Ġdiscover ies +Jo ined +ĠEn emies +ĠWire less +ĠRe venge +Ġpuzz les +Ġce ased +29 0 +cript ions +ĠCon sole +Ġbo iling +Ġdisc rep +Ġded uction +Ġar senal +XX XX +ĠAm sterdam +rox imately +ĠSh ane +Ġpos ing +ĠACL U +ĠCompan ies +Ġthe ology +ĠU g +qu arter +ĠH ank +Co in +ĠL v +Ġalleg ation +ĠAv oid +Ġindef initely +Ġcommod ities +Ġbr ig +ĠMan it +Ġt enth +met hod +ĠKn icks +ĠâĢ İ +Ġinv oked +D ial +AR A +Ġc aucus +22 7 +ĠJ ab +Ġoun ces +b ay +Ġbud dy +f an +23 4 +ĠH il +ad h +ĠT Y +ĠIN D +Ġ19 39 +Ġiter ation +ĠGonz alez +ĠV ert +ĠI O +em b +re ra +en ch +ĠRequ irements +ĠW ins +Ġlivest ock +h ours +" âĢ¦ +b ral +M arg +ĠD one +Ġwas ting +ing ed +g roups +Ġw ishing +ĠT umblr +Ġt apping +Ġnational ism +ĠB yr +Ġsqu ares +ĠAct ions +ãĥ ¥ +In side +deb ug +Ġapp end +Ġstub born +ĠC ind +T ell +Ġt earing +ĠRe y +or c +ĠDay ton +ĠN H +ĠMad ness +Ch arl +ĠMor rison +fil ter +Ġacc use +Ġ. / +Ġtor rent +Ġdecl ines +g allery +M ine +Ġneg otiation +ĠBash ar +op ia +19 93 +em ort +ĠNo vel +ĠF ang +ers ive +ĠInst ant +Ġroll er +A round +ĠElect ions +G ames +Ġin expensive +Ġwor s +Ġv ul +ĠH ole +Ġunbeliev able +Ġn ause +Ġent r +bo at +ĠST E +Ġbus h +ĠHass an +Ġw o +Ġpa used +ĠM ig +l ived +Ġsc out +Ġl ith +Pub lished +du ino +c ool +Ġcirc ulating +id as +ĠP am +viol ent +ĠCraw ford +udd le +ĠLet ters +Gu ard +mor ph +Ġwand ering +Ġsoph omore +Ġque er +ĠBl ind +r ue +ĠMar riage +D om +Ġpadd ing +Ġfold ers +Ġmeaning less +Ġcandid acy +af ort +Ġwhistle bl +ĠIdent ified +Ġcig ar +Ġh id +ĠDub ai +Ġpost ure +Ġh iking +ĠTermin al +Legend ary +ĠT P +ĠAT K +ĠStar bucks +ĠR iot +19 91 +ĠBott om +e ffic +ĠEug ene +ĠWy oming +ĠRock y +Ġsal mon +Ġmet ro +Ġb ilateral +Ġcelebr ates +L ength +b illion +B at +Ġre leg +Ġpse udo +D T +ĠRh ode +P arent +ple tion +Ġatt ribut +Ġtun ing +ĠNOT E +ĠRe bel +ic us +F und +Ġcock tail +Ġ5 01 +Ġsp oon +Ġbrut ality +Ġun ite +Ġmicro bi +ĠRe ich +pos itive +Ġam azed +ĠN T +D esc +ECT ION +Ġfalse ly +ĠHigh lander +ĠC rist +ĠVictor ian +Ġdistribut ions +the ir +ĠE instein +Ġp od +Ġepid em +Ġhe ap +ĠR anch +Ġan them +Ġre app +ĠAub urn +Ġconc urrent +ĠThrough out +ĠP OST +â ĺ +Ġhom emade +k ick +B eg +Ġch assis +c ounter +Ġmer ger +Ġl aps +2 17 +un ion +ĠTr igger +Ġdeb ated +Ġsil ently +Ġrest raint +B al +0000 000 +Ġform idable +ĠFil ip +Ġsacrific es +F ood +Ġdwar f +ĠSe qu +in ian +More over +Ġtang ible +ops is +ĠMine craft +ĠRegist ration +o an +Ġrepresent ations +Ġth irst +Ġcor p +ire ment +M ade +l oe +> " +c ats +* . +Ġgest ures +gener al +Le ague +Ġpack ets +ĠInspect or +ĠBer g +Ġfraud ulent +Ġcritic ize +F un +Ġbl aming +nd ra +Ġsl ash +ĠE ston +Ġpropos ing +Ġwh ales +Ġtherap ist +Ġsub set +Ġle isure +EL D +ĠC VE +ĠAct ivity +Ġcul min +sh op +ĠD AY +is cher +ĠAdmir al +ĠAtt acks +Ġ19 58 +Ġmem oir +Ġfold ed +Ġsex ist +Ġ15 3 +ĠL I +Ġread ings +Ġembarrass ment +ĠEmploy ment +w art +ch in +Ġcontin uation +l ia +Rec ently +Ġd uel +Ġevac uation +ĠKash mir +Ġdis position +ĠR ig +Ġbol ts +Ġins urers +4 67 +M ex +Ġret aliation +Ġmis ery +Ġunre asonable +r aining +I mm +ĠP U +em er +Ġgen ital +ãĤ ³ +ĠC andy +Ġon ions +ĠP att +lin er +Ġconced ed +Ġf a +Ġfor c +ĠH ernandez +ĠGe off +deb ian +ĠTe ams +Ġc ries +Ġhome owners +23 7 +A BC +Ġst itch +Ġstat istic +Ġhead ers +ĠBi ology +Ġmot ors +ĠG EN +ĠL ip +Ġh ates +Ġhe el +S elf +i pl +ED IT +ort ing +Ġann ot +ĠSpe ech +old emort +ĠJ avascript +ĠLe Bron +Ġfoot print +Ġf n +Ġseiz ures +n as +h ide +Ġ19 54 +ĠBe e +ĠDecl aration +ĠKat ie +Ġreserv ations +N R +f emale +Ġsatur ated +Ġb iblical +Ġtroll s +Dev ice +ph otos +Ġdr ums +ãĥīãĥ© ãĤ´ãĥ³ +N ight +f ighter +ĠH ak +ri ber +Ġc ush +Ġdiscipl inary +ba um +ĠG H +ĠSch midt +ilib rium +Ġs ixty +ĠKush ner +ro ts +Ġp und +ĠR ac +Ġspr ings +Ġcon ve +Bus iness +F all +Ġqual ifications +Ġvers es +Ġnarc iss +ĠK oh +ĠW ow +ĠCharl ottesville +ed o +Ġinterrog ation +ĠW ool +36 5 +B rian +Ġâľ ĵ +Ġalleg es +ond s +id ation +ĠJack ie +y u +Ġl akes +Ġworth while +Ġcryst als +ĠJud a +Ġcomp rehend +Ġfl ush +Ġabsor ption +ĠO C +Ġfright ened +ĠCh ocolate +Mart in +Ġbu ys +Ġbu cks +Ġapp ell +ĠChampions hips +Ġlist ener +ĠDef ensive +Ġc z +ud s +ĠM ate +Ġre play +Ġdecor ated +Ġs unk +ĠV IP +ĠAn k +Ġ19 5 +aa aa +Nob ody +ĠMil k +ĠG ur +ĠM k +ĠS ara +Ġse ating +ĠW id +Tr ack +Ġemploy s +Ġgig antic +AP P +ãĤ § +in ventory +Ġtow el +at che +l asting +ĠT L +Ġlat ency +Ġkn e +B er +me aning +Ġup held +Ġplay ground +Ġm ant +S ide +Ġstere o +Ġnorth west +Ġexception ally +Ġr ays +Ġrec urring +D rive +Ġup right +Ġab duct +ĠMar athon +Ġgood bye +Ġal phabet +h p +Ġcourt room +ring ton +ot hing +T ag +Ġdiplom ats +Ġbar bar +ĠAqu a +18 3 +33 33 +Ġmat urity +Ġinst ability +ĠAp ache +Ġ= == +Ġfast ing +ĠGr id +Mod Loader +Ġ15 2 +A bs +ĠOper ating +ett i +Ġacqu aint +Don nell +ĠK em +ĠFor ge +Ġarm ored +M il +Ġphilos ophers +in vest +Pl ayers +â Ī +Ġmy riad +Ġcomr ades +R ot +Ġremember ing +Ġcorrespond s +Ġprogram mers +ĠLyn n +Ġo lig +Ġco herent +yn chron +ĠChem ical +Ġj ugg +p air +post s +E ye +ĠIn ner +Ġsem ester +ott est +ĠEmir ates +ric anes +or ously +m its +ĠW is +Ġd odge +l ocation +Ġf aded +Am azon +ĠPro ceed +ĠIN FO +j ournal +ĠTru ck +T en +Ġ2 17 +Ġstat utes +m obile +ĠT ypes +Rec omm +b uster +pe x +Ġleg ends +Ġhead ache +f aced +ĠWi Fi +if ty +ĠH ER +Ġcirc uits +ER ROR +22 6 +ol in +Ġcyl inder +osp ace +ik ers +P rem +Qu ant +Ġconflic ting +Ġslight est +Ġfor ged +ion age +Step hen +ĠK ub +ĠOpp ortun +ĠHe al +Ġbl o +Ġrul ers +Ġh uh +Ġsubmar ine +f y +ass er +Ġallow ance +ĠKas ich +ĠT as +ĠAustral ians +Forge ModLoader +ĠâĨ ij +ĠMat rix +am ins +Ġ12 00 +ĠAc qu +23 6 +D ocument +ĠBre aking +19 3 +ĠSub st +ĠRoll er +ĠPro perties +ĠN I +t ier +Ġcr ushing +Ġadvoc ating +Further more +keep ers +Ġsex ism +x d +Ġcall er +ĠS ense +chie ve +ĠT F +Ġfuel ed +Ġreminis cent +Ġobs ess +ur st +Ġup hold +ĠF ans +het ics +Ġâ Ĺ +ĠB ath +Ġbe verage +Ġo scill +25 4 +Ġpol es +Ġgrad ual +Ġex ting +ĠS uff +ĠS uddenly +Ġlik ing +Ġ19 49 +un ciation +am ination +ĠO mar +ĠL V +ĠCon sequently +Ġsynt hes +ĠG IF +Ġp ains +Ġinteract ing +u ously +inc re +Ġrum or +ĠScient ology +19 7 +ĠZ ig +Ġspe lling +ĠA SS +Ġexting u +ms on +Ġg h +Ġremark ed +ĠStrateg ic +ĠM ON +å ¥ +g ae +ĠWH AT +E ric +ĠCamp us +Ġmeth ane +Ġimag in +J UST +ĠAl m +X T +i q +ĠR SS +Ġwrong doing +att a +Ġbig ot +Ġdemonstr ators +ĠCal vin +ĠV illa +Ġmembr ane +ĠAw esome +Ġbenef ic +26 8 +Ġmagn ificent +ĠL ots +G reg +ĠBor is +Ġdetain ees +ĠH erman +Ġwhis pered +Ġa we +Prof essor +fund ing +Ġphys iological +ĠDest ruction +Ġlim b +Ġmanip ulated +Ġbub bles +Ġpse ud +Ġhyd ra +ĠBrist ol +Ġst ellar +ĠExp ansion +ĠK ell +ĠInterest ingly +Ġm ans +Ġdrag ging +Ġec ological +ĠF it +Ġg ent +Ġbenef ited +ĠHait i +Ġpoly g +ãĥ İ +Ġ20 30 +Ġpro w +Ġrecon struction +Ġwas t +Ġpsych ic +ĠGree ks +Hand ler +16 2 +ĠP ulse +Ġsol icit +Ġsy s +Ġinflu x +ĠG entle +per cent +Ġprolifer ation +Ġtax able +Ġdisreg ard +Ġesc aping +Ġg inger +Ġwith stand +Ġdevast ated +ĠD ew +ser ies +Ġinject ed +ela ide +Ġturn over +he at +Ļ Ĥ +H appy +ĠSil ent +ãĤ Ń +iv ism +Ġir rational +AM A +Ġre ef +r ub +Ġ16 2 +Ġbank ers +ĠEth ics +v v +Ġcritic isms +K n +18 6 +M ovie +ĠT ories +Ġno od +Ġdist ortion +F alse +od ore +Ġt asty +Res earch +ĠU ID +- ) +Ġdivor ced +ĠM U +ĠHay es +ĠIs n +ian i +ĠH Q +Ġ" # +ign ant +Ġtra umatic +ĠL ing +H un +Ġsab ot +on line +r andom +Ġren amed +ra red +K A +d ead +é t +ĠAss istance +Ġse af +++++ ++++ +Ġse ldom +ĠWeb b +Ġbo olean +u let +Ġref rain +ĠDI Y +ru le +Ġshut ting +Ġutil izing +load ing +ĠPar am +co al +oot er +Ġattract ing +ĠD ol +Ġher s +ag netic +ĠRe ach +im o +Ġdisc arded +ĠP ip +01 5 +ü r +Ġm ug +Im agine +C OL +Ġcurs ed +ĠSh ows +ĠCurt is +ĠSach s +spe aking +ĠV ista +ĠFram ework +ong o +Ġsub reddit +Ġcr us +ĠO val +R ow +g rowing +Ġinstall ment +Ġgl ac +ĠAdv ance +EC K +ĠLGBT Q +LE Y +Ġac et +Ġsuccess ive +ĠNic ole +Ġ19 57 +Qu ote +Ġcircumst ance +ack ets +Ġ14 2 +ort ium +Ġguess ed +ĠFr ame +Ġperpet rators +ĠAv iation +ĠBen ch +Ġhand c +A p +Ġ19 56 +25 9 +r and +Net Message +d in +urt les +h ig +ĠV III +ff iti +ĠSw ords +b ial +Ġkidn apping +dev ice +Ġb arn +ĠEl i +auc as +S end +Con structed +Ġ ½ +Ġneed les +Ġad vertisements +Ġv ou +Ġexhib ited +ĠFort ress +As k +B erry +TY PE +Ġcan cers +ump ing +ĠTerrit ory +Ġpr ud +Ġn as +Ġathe ist +Ġbal ances +ãģ Ł +ĠSh awn +& & +Ġland sc +ĠR GB +Ġpet ty +Ġex cellence +Ġtransl ations +Ġpar cel +ĠChe v +E ast +ĠOut put +im i +Ġamb ient +ĠTh reat +Ġvill ains +Ġ5 50 +IC A +Ġtall er +Ġle aking +c up +Ġpol ish +Ġinfect ious +ĠK C +Ġ@ @ +back ground +Ġbureaucr acy +ĠS ai +un less +it ious +ĠSky pe +At l +ID ENT +00 8 +Ġhyp ocr +Ġpit chers +Ġguess ing +ĠF INAL +Bet ween +Ġvill agers +Ġ25 2 +f ashion +ĠTun is +Be h +ĠEx c +ĠM ID +28 8 +ĠHas kell +19 6 +ĠN OR +Ġspec s +Ġinv ari +Ġgl ut +ĠC ars +Ġimp ulse +Ġhon ors +g el +Ġjurisd ictions +ĠBund le +ul as +Calif ornia +ĠIncre ase +Ġp ear +Ġsing les +Ġc ues +Ġunder went +ĠW S +Ġexagger ated +Ġdub ious +Ġfl ashing +L OG +) ]. +J ournal +t g +V an +ĠI stanbul +ĠIn sp +ĠFrank en +D raw +Ġsad ness +Ġiron ic +ĠF ry +x c +Ġ16 4 +is ch +W ay +ĠProtest ant +h orn +Ġun aff +ĠV iv +ill as +ĠProduct ions +ĠH ogan +Ġper imeter +ĠS isters +Ġspont aneous +Ġdown side +Ġdescend ants +Ġor n +w orm +Japan ese +Ġ19 55 +Ġ15 1 +ĠDo ing +els en +umb les +Ġrad ically +ĠDr um +ĠB ach +Ġli abilities +ĠO B +ĠElement ary +Ġmem e +yn es +Ġfinger print +ĠGr ab +Ġundert ake +Mem bers +ĠRead er +ĠSim s +g od +Ġhypot hetical +s cient +ĠA J +Ġchar ism +Ġad missions +ĠMiss ile +tr ade +Ġexerc ising +ĠBack ground +W ritten +Ġvoc als +whe ther +Ġv i +ĠW inner +Ġl itter +ĠSh ooting +ST EM +ãĤ ¡ +ĠA FL +Ġvari ability +Ġe ats +ĠD PS +b row +Ġeleph ants +Ġstr at +Ġ Å +Ġsett lers +Matt hew +Ġin advert +H I +ĠIM F +ĠGo al +Ġnerv es +John son +ey e +ablish ment +Th ursday +BIL ITY +H ad +am oto +het amine +ep s +Ġmit ochond +Ġcomp ressed +ĠTre vor +ĠAnim als +T ool +L ock +Ġtwe ak +Ġpin ch +Ġcancell ation +P ot +Ġfoc al +ĠAst ron +17 3 +ĠA SC +ĠO THER +umn i +Ġdem ise +d l +Ù ħ +Sem itism +Ġcr acking +Ġcollabor ative +Ġexpl ores +s ql +Ġher bs +Ġconfig urations +m is +ĠRes ult +ace y +ĠSm oke +Ġsan ct +el ia +Ġdeg ener +Ġdeep est +Ġscream ed +Ġn ap +Soft ware +ĠST AR +E F +ĠX in +spons ored +mans hip +23 3 +Ġprim aries +Ġfilter ing +Ġas semble +m il +ĠMy ers +b ows +Ġpun ched +M ic +Ġinnov ations +Ġfun c +and o +Ġfr acking +ĠV ul +о Ð +osh op +ĠIm mun +Ġsett ling +Ġadolesc ents +Ġreb uilding +Ġtransform ing +Ġpar ole +Ġhar bor +Ġbook ing +ot ional +onge vity +ĠY o +b ug +Ġemer ges +ĠMethod s +ĠCh u +P res +ĠDun geons +Ġtra iling +ĠR um +ĠH ugh +å¤ © +ĠE ra +ĠBatt les +Res ults +ĠTr ading +Ġvers a +c ss +ax ies +he et +Ġgre ed +19 89 +Ġgard ens +Ġconting ent +P ark +ĠLeaf s +h ook +ro be +Ġdiplom acy +ĠF uel +ĠInv asion +Ġupgr ading +M ale +Ġe lic +Ġrelent less +ĠCo venant +ap esh +ĠT rop +T y +pro duction +art y +Ġpun ches +ak o +cyclop edia +ĠR abbit +ĠHD MI +Ġ14 1 +Ġf oil +Item Image +ĠF G +Ġimplement ations +ĠP om +ixt ures +Ġaw ait +Ġ3 30 +am us +Ġumb rella +Ġfore see +se par +Ġcircum cision +Ġperipher al +S ay +ĠExper t +In c +Ġwithd rew +ĠAnd ers +f ried +Ġradio active +ĠOp ening +Ġboard ing +ĠN D +Ġover throw +Act iv +W P +ĠAct s +× Ļ +Ġmot ions +v ic +ĠM ighty +ĠDef ender +a er +Ġthank ful +ĠK illing +ĠBr is +mo il +Ġpredict ing +26 6 +ch oice +Ġkill ers +Ġinc ub +ĠChe st +ather ing +Ġpro claimed +fl ower +oss om +umbled ore +ĠCy cling +ĠOccup y +AG ES +P en +ĠY ug +Ġpack aged +Ġheight ened +c ot +st ack +C ond +Ġst amps +m age +Ġpersu aded +Ġens l +ĠCard inal +Ġsol itary +Ġpossess ing +ĠC ork +Ġev id +ĠT ay +Ġbl ues +Ġextrem ism +Ġlun ar +Ġcl own +Te chn +Ġfest ivals +ĠPv P +ĠL ar +Ġconsequ ently +p resent +Ġsom eday +ç İĭ +ĠMet eor +Ġtour ing +c ulture +Ġbe aches +S hip +c ause +ĠFl ood +ãĥ ¯ +Ġpur ity +th ose +Ġem ission +b olt +Ġch ord +ĠScript ure +L u +Ġ$ { +cre ated +Other s +25 8 +Ġelement al +Ġannoy ed +ĠA E +d an +ĠS ag +Res earchers +Ġfair y +âĢĵ âĢĵ +======== ==== +Sm art +GG GG +Ġskelet ons +Ġpup ils +link ed +Ġur gency +en abled +ĠF uck +Ġcoun cill +r ab +U AL +T I +Ġlif es +Ġconf essed +B ug +Ġharm on +ĠCON FIG +ĠNe utral +D ouble +Ġst aple +ĠSH A +Brit ish +ĠSN P +AT OR +oc o +Ġswing ing +ge x +ole on +pl ain +ĠMiss ing +ĠTro phy +v ari +ran ch +Ġ3 01 +4 40 +00000000 00000000 +Ġrest oring +Ġha ul +uc ing +ner g +Ġfut ures +Ġstrateg ist +quest ion +Ġlater al +ĠB ard +Ġs or +ĠRhod es +ĠD owntown +????? - +ĠL it +ĠB ened +Ġco il +st reet +ĠPort al +FI LE +ĠG ru +* , +23 1 +ne um +Ġsuck ed +Ġr apper +Ġtend encies +ĠLaure n +cell aneous +26 7 +Ġbrow se +Ġover c +head er +o ise +Ġbe et +ĠG le +St ay +Ġm um +Ġtyp ed +Ġdiscount s +T alk +ĠO g +ex isting +ĠS ell +u ph +C I +ĠAust rian +ĠW arm +Ġdismiss al +Ġaver ages +c amera +Ġalleg iance +L AN +=" # +Ġcomment ators +ĠSet ting +ĠMid west +Ġpharm ac +ĠEX P +Ġstain less +Ch icago +Ġt an +24 4 +Ġcountry side +ĠV ac +29 5 +Ġpin ned +Ġcr ises +Ġstandard ized +T ask +ĠJ ail +ĠD ocker +col ored +f orth +" }, +Ġpat rons +Ġsp ice +Ġm ourn +ĠM ood +Ġlaund ry +Ġequ ip +ĠM ole +y ll +ĠTH C +n ation +ĠSher lock +Ġiss u +ĠK re +ĠAmeric as +ĠA AA +Ġsystem atically +Ġcont ra +ĠS ally +Ġrational e +Ġcar riage +Ġpe aks +Ġcontrad iction +ens ation +ĠFail ure +Ġpro ps +Ġnames pace +Ġc ove +field s +ãĤ ĭ +Ġw ool +ĠC atch +Ġpresum ed +ĠD iana +r agon +ig i +Ġh amm +Ġst unt +ĠG UI +ĠObserv atory +ĠSh ore +Ġsmell s +ann ah +Ġcock pit +ĠD uterte +8 50 +Ġopp ressed +bre aker +ĠCont ribut +ĠPer u +ĠMons anto +ĠAtt empt +Ġcommand ing +Ġfr idge +ĠR in +ĠChe ss +ual ity +Ġo l +Republic an +ĠGl ory +ĠW IN +.... ... +ag ent +read ing +Ġin h +J ones +Ġcl icks +al an +Ġ[ ]; +ĠMaj esty +ĠC ed +op us +ate l +à ª +AR C +ĠEc uador +ãĥ ł +ĠK uro +Ġritual s +Ġcapt ive +Ġoun ce +Ġdisag reement +Ġsl og +f uel +P et +M ail +Ġexerc ised +Ġsol ic +Ġrain fall +Ġdev otion +ĠAss essment +Ġrob otic +opt ions +ĠR P +ĠFam ilies +ĠFl ames +Ġassign ments +00 7 +aked own +Ġvoc abulary +Re illy +Ġc aval +g ars +Ġsupp ressed +ĠS ET +ĠJohn s +Ġwar p +bro ken +Ġstat ues +Ġadvoc ated +Ġ2 75 +Ġper il +om orph +ĠF emin +per fect +Ġh atch +L ib +5 12 +Ġlif elong +3 13 +Ġche eks +Ġnum bered +ĠM ug +B ody +ra vel +We ight +ĠJ ak +ĠHe ath +Ġkiss ing +ĠJ UST +Ġw aving +u pload +Ġins ider +ĠPro gressive +ĠFil ter +tt a +ĠBe am +Ġviol ently +ip ation +Ġskept icism +Ġ19 18 +ĠAnn ie +ĠS I +Ġgen etics +Ġon board +at l +ĠFried man +ĠB ri +cept ive +Ġpir ate +ĠRep orter +27 8 +Ġmyth ology +Ġe clipse +Ġsk ins +Ġgly ph +ing ham +F iles +C our +w omen +Ġreg imes +Ġphotograp hed +K at +ĠMA X +Offic ials +Ġunexpected ly +Ġimpress ions +F ront +;;;; ;;;; +Ġsuprem acy +Ġs ang +Ġaggrav ated +Ġabrupt ly +ĠS ector +Ġexc uses +Ġcost ing +ide press +St ack +ĠR NA +ob il +Ġghost s +ld on +at ibility +Top ics +Ġreim burse +ĠH M +ĠDe g +Ġth ief +y et +ogen esis +le aning +ĠK ol +ĠB asketball +Ġf i +ĠSee ing +Ġrecy cling +Ġ[ - +Cong ress +Ġlect ures +P sy +Ġne p +Ġm aid +Ġori ented +A X +Ġrespect ful +re ne +fl ush +ĠUn loaded +re quest +gr id +ĠAltern atively +ĠHug o +Ġdec ree +ĠBuddh ism +and um +And roid +ĠCong o +ĠJoy ce +Ġacknowled ging +hes ive +ĠTom orrow +ĠH iro +th ren +ĠM aced +Ġho ax +ĠIncre ased +ĠPr adesh +W ild +____ __ +16 1 +Ġa unt +Ġdistribut ing +ĠT ucker +ĠSS L +ĠW olves +B uilding +ou lt +ĠLu o +ĠY as +ĠSp ir +ĠSh ape +ĠCamb od +ĠIP v +Ġm l +Ġext rad +39 0 +ĠPenn y +d ream +Ġstation ed +opt ional +ew orthy +. </ +Ġundert aking +Ġchick ens +Ġstimul i +ĠEl se +ig ators +ĠBegin ning +ct ory +Ġprep ares +Ġdel ta +Ġvic inity +t ool +Ġworks hops +M Hz +Ġaccus ation +Ġhist ories +rop olis +ĠChurch ill +Ġne on +Ġb aff +d ies +may be +Ġè£ı è¦ļéĨĴ +Ġsympt om +EC H +ĠMan uel +Ġban ana +ĠH B +Ġ **** +ĠKore ans +c oll +F B +Ġpr aying +ĠCann ot +ĠM ile +Ġembr acing +ĠSil k +39 3 +ot ers +F D +Ġday light +al ias +ĠBrig ade +ĠHann ah +Ġcler gy +Ġs outheast +Ġalcohol ic +Ġpropos es +liv ion +Ġcalcul ating +Ġstim ulate +Ġspl itting +e ight +ĠInd y +pl ays +ĠP ik +Ġdom est +Ġforg iveness +ĠR ings +pat ient +kins on +M ont +ig ible +; " +Ġperiod ically +amm ad +ĠBr itt +p ard +Ġarbit ration +ĠSchne ider +ĠCorpor ate +ĠMay a +Ġsn akes +a um +Ġbl asted +Ġmyster ies +Ġrev ive +oc amp +ĠD odge +ĠOper a +27 9 +Ġor phan +Ġspec ifies +ĠM ets +D uration +H en +Ġfire works +Ġprosec ute +ĠTill erson +d p +us age +l iness +ĠDeb ian +Ġ2 24 +ris es +ĠIn fect +at ra +ĠR R +ĠL or +d iff +ĠCharl eston +Ġac oustic +Ġam use +3 30 +Ġc er +ĠT ac +Ġ[ + +Ġcard iac +ĠRestaur ant +er gy +Ġf uzz +Ġbit es +Ġhazard ous +Ġbr ighter +r ans +ĠStephan ie +ext ra +RE T +ĠChrist ine +ĠS ue +stat ement +Ġbol ster +Ġant it +Rad io +B IT +ãĤ ° +Ġvis ions +ĠCon cept +Ġin line +ĠPhilos ophy +is ans +ĠIr ving +à £ +t aking +Ġincons ist +ĠKum ar +Ġl ig +ĠSch umer +ĠReg ulations +ĠH z +th ro +ĠV oldemort +ĠM ED +ĠFreder ick +P ad +22 1 +Ġalleg ing +ĠCommun ication +Ġ16 7 +Ġforecast s +Ġsp iders +Or gan +ĠParticip ants +ĠO ps +des ign +Cl ose +Ġfact o +Ġbom bers +res istant +ateg ories +S chool +Ġhom ework +Ġcor ro +T uesday +ĠBrend an +ĠM X +ĠT S +ĠSt ri +Ġstake holders +ĠMillenn ium +Ġtransfer ring +J ud +Ġt ac +Ġ16 00 +ĠSD K +r b +Ġinterpret ations +ĠS G +Ġup stairs +ĠHar vest +Ġvag ina +Ġing est +x f +ĠOr ion +ĠJoe y +Ġsand wic +Ġimm ortal +Ġfl ipped +ort ex +threat ening +Ġsn iper +Ġconver ts +Ġinstall ations +ĠBul gar +ors che +m ails +Ġl ure +Ġnarrow ly +Ġgren ade +ĠG ing +Ġunder wear +------------ -- +Ġch ased +ĠV AL +Ġparent ing +ĠH amb +ĠBl az +Ġanarch ist +ĠMed ian +ĠProgram s +Î ½ +Ġob j +ĠN okia +orm an +an qu +at ism +op a +Ġfulf illing +Ġpupp y +Ġent it +ĠSebast ian +Ġshoot ers +Ġric her +è ¡ +Ġtempt ed +ĠAT T +ĠC V +Ġto re +Res ource +ĠDevil s +40 8 +in ational +Ġass urance +ĠDar ren +Ġwh ichever +pos ure +Ġf ury +St ock +Ġunivers ally +resp onse +Ġo ak +Ġwork load +ĠCor ner +ee le +" ... +Ġdepri ved +k owski +Ġcast s +Ġaffili ation +ĠA ch +ĠAs ked +at he +Ġl act +ĠTh u +r m +Ġair lines +Ġnot ions +Form at +ĠF AA +ãĥ Ĭ +dri ver +Ġtrans cend +S ettings +ĠPro secut +Ġsp inal +Ġdefault s +F K +Ġpref ers +rend ered +th us +fil m +Ġt iger +ĠSp icer +rec ogn +ĠRug by +Net work +Ġp ity +Ġcomp artment +c asters +ĠMon roe +Ġ7 20 +Ġcorrect ions +Ġdop amine +ĠA Z +C ut +Ġro omm +Ġspec ulate +H ash +Ġrestrict ive +11 11 +red ible +on el +Ġramp ant +re ported +ĠSu ite +ĠMin imum +al ys +az ard +lo op +Ġl ent +sh a +Ġv andal +men u +ĠBoe hner +Ġnarr atives +Ġauthent icity +26 9 +an ic +d uty +28 5 +Ġthank ed +Ġbetray ed +l ift +Ġsouth west +ĠDex ter +ĠB od +Ġkey words +A verage +D IS +Ġethnic ity +! ), +ĠNational s +á ¹ +ĠT ah +iox id +Ġwid get +Ġpast a +Ġbill ing +Ġtr ilogy +ĠL ines +Ġsn iff +Ġnep hew +L ate +Ġprinc ip +ĠLo op +ĠMarx ist +Ġdiss olved +Ġcontext s +ĠAm ount +ĠSp ike +Ġtot als +Ġorgan izer +Ġup rising +s hips +Y Y +ĠNort heast +m oney +grad ation +Ġgoal keeper +ĠH ear +Ġste ak +ĠBuzz Feed +Ġsole mn +ĠSc and +Ġpo pping +Ġad here +ĠAl leg +by te +ĠW olver +Ġun in +Ġrec ol +it ud +Ġmim ic +ib us +Ġpredict s +ĠKee per +i ating +Ġde ception +Ġlear nt +Ġdi ary +Ġcond itional +Ġre lic +Ġinv oke +ien ced +å Ī +ĠP ont +Ġcell phone +Ġspeed ing +Ġtack ling +Ġn ude +op ened +ĠMan afort +Ġ19 52 +Ġmaj ors +ĠSil ence +Ġlog istics +Ġweight ed +ĠPsych iat +": [" +Ġsick ness +Ġdivid ends +z on +Re lease +ĠKe ys +ĠI ch +Ġen z +ĠF ernand +ĠÎ ± +Ġmean ings +Ġp enny +Ġst ern +Ġl ar +ĠPub lished +Ġback drop +K im +ĠSy nt +Ġdeb uted +w m +ĠIs le +Ġregul ating +ott i +ĠSch olars +ices ter +ĠChe f +Ġpop s +ĠLaun cher +ĠVar ious +Ġcomment ing +os lav +enz ie +Ġrival ry +â Ĥ¬ +Re ally +Ġor c +Ġbe an +ĠJud y +Not ice +ĠB ike +? ] +Ġrent ed +st en +Ġfore front +ĠBald win +Ġyield ed +t ails +Pr ime +ĠS ources +ic ator +Se an +Ġmarch ing +Out put +ĠJ ungle +Ġres ide +zz le +ĠAndrew s +Ġtor que +Bas ic +Act ually +st rap +p enter +Ġexam s +ĠY a +Ġ15 9 +ĠDec ision +Ġr ansom +ete enth +ens ing +2 13 +Ġsun set +40 4 +ĠRap id +ĠHe in +ĠAb original +Ġorgan ism +ĠS ever +Ġcl a +aj i +Sim ple +ĠFl avor +ĠE val +pr us +Ġch orus +D AY +Ġden ounced +Ġbi ography +ĠTurn bull +Rec ent +N ormal +lect ions +W ord +Ġf erry +ĠWag ner +h om +Un it +Ġsuper market +ĠS ith +Ġnomine es +Ġdictators hip +idd ler +Ġannoun ces +ĠThe m +ĠNept une +Ġde ity +ĠY i +Ġmon arch +AR R +Ġinv aded +ĠH ok +unt ary +C ertain +eg a +Ġk idding +ĠReg ulation +Ġtr ay +Ġphotograp hers +ĠArc ane +Ġdis charged +Ġevangel ical +Ġinter change +Ġfilm maker +ĠEnd less +Ġ29 0 +ĠSalv ador +AS Y +ĠSign al +Ġwr ath +â ľ +l ot +' / +Ġproject ile +Ġemploy ing +ĠInter face +19 1 +atell ite +ĠR ath +pack age +Ġindic ations +J ason +Ġarg s +ĠG Hz +Ġt ilt +n ants +w on +ãĤ µ +red d +res cent +ĠCal endar +Ġmod ular +Ġassist ing +Ġred eem +ĠBe an +Ġwor sh +Ġdecentral ized +) ... +37 7 +Ġarr ays +Ġaccomplish ments +Î ¿ +d ot +Ġmut ually +Ġob struct +Ġmis represent +ore st +ion ic +ru ce +% ; +Ġknow ingly +port ing +in ently +A ri +ĠSch ultz +D a +ĠC ere +Ġob solete +ħ ĭ +g ive +Ġb ait +Ġen larg +Ne ill +Ġ19 33 +Ġrecons ider +ĠSerge ant +ĠDian e +ĠC ogn +ĠI con +P osition +Ġf ost +Ġstir ring +se ven +ĠSpace X +ugg ets +Ġmed d +G al +ĠS ister +B oy +Ġtrigger ing +T aking +Ġscream s +Ġca usal +Ġaw aken +Ar m +29 7 +Ġdisp atched +ĠF ALSE +Ġorgan izational +ĠT ong +Ġdile mma +d emon +S pl +Ġhook s +ud ing +Ġvalid ate +Ġpot ion +Ġcl aw +Ġburg l +Ġqu ir +AC A +ĠBren nan +Ġdur ability +Ġbomb ings +ĠWind ow +Ġculp rit +3 25 +There fore +umb ered +per formance +w arts +Ġen forcing +ĠBl ow +Ġre print +if ax +al pha +Ġsin ister +Ġbur ger +fight ing +Sc ore +ĠSt ones +i em +40 5 +che my +Ġvine gar +n om +Ġprev ailing +ĠLat est + ¶ +Ġb a +ĠWrit er +Ġ17 7 +ĠCon way +Ġcollect s +Ġquant itative +Ġhor rors +og ens +ĠSl ov +Ġl ays +h aw +ĠSl ash +Ġnight club +ĠDav ies +Ġbr ide +ĠScar let +y mm +ĠApplic ations +vel ength +Ġrev ival +Ġsoft ly +Ġz oo +ita ire +C ur +Ġelect rom +Ġplant ing +OT O +ĠE lements +Ġsw allow +por ter +Ġlapt ops +Ġpe anut +Ġlobby ists +Î ² +Pan el +ĠJo an +im il +t nc +Ġresist ed +Ġout we +Ġret aining +at ri +Ġpo orer +ĠSyri ans +ĠHam mond +Ġwe ld +ud er +top ic +ĠT T +ric ia +Ġth ieves +L ic +ĠG ust +ĠW ays +are th +24 3 +Ġbroad caster +sh ield +ass ium +ub le +Ġairst rikes +on so +Ġped al +Ġcollect ors +ĠV ander +ĠMes a +Ġdict ator +Ġd ir +ent on +c art +sc ore +ad der +C ry +Ġs sh +gg er +Ġdrunk en +ĠG S +ĠSe at +Ġcorner back +Ġsk ipped +ĠRes earchers +ĠAud i +Ref erence +Ġhaun ted +à « +ĠClin ic +c z +Ġp s +ĠPal adin +ĠRec ipe +Ġst igma +opp y +Ġmon keys +ĠHaw k +S ad +" /> +ĠWorks hop +ĠRet ail +ĠAv atar +6 25 +N a +ĠV C +ĠSec ure +M Y +19 88 +oss ip +Ġpro state +Ġund en +Ġg amer +ĠCont ents +ĠWar hammer +ĠSent inel +3 10 +Ġse gregation +ĠF lex +ĠM AY +Ġdr ills +ĠDrug s +Islam ic +Ġsp ur +Ġca fe +Ġimag inary +Ġgu iding +Ġsw ings +ĠThe me +ob y +Ġn ud +Ġbe gging +Ġstr ongh +Ġreject ing +Ġpedest rians +ĠPro spect +R are +s le +Ġconcess ions +ĠConst itutional +Ġbe ams +Ġfib ers +p oon +Ġinstinct s +pro perty +ĠB IG +Sand ers +im ates +Ġco ating +Ġcorps es +ĠTR UE +check ed +Ġ16 6 +A sh +ĠJ S +ĠF iction +Ġcommun al +Ġener getic +oooo oooo +Ġnow adays +IL D +ib o +ĠSU V +R en +Ġdwell ing +Sil ver +Ġt ally +ĠM oving +Ġcow ard +Ġgener als +Ġhorn s +Ġcirc ulated +Ġrob bed +ĠUn limited +Ġharass ed +Ġinhib it +Ġcomp oser +ĠSpot ify +Ġspread s +3 64 +Ġsu icidal +Ġno ises +ĠSt ur +Ġs aga +ĠK ag +is o +Ġtheoret ically +M oney +Ġsimilar ity +Ġslic ed +ut ils +ing es +" - +Ġan th +Ġimp ed +Mod ule +Through out +Ġmen us +comm ittee +and i +ob j +in av +f ired +ĠAb dullah +Ġund ead +Ġfont s +H old +EN G +Ġsustain ability +Ġfl ick +Ġr azor +ĠF est +ĠChar acters +Ġword ing +Ġpopul ist +Ġcritic izing +Ġm use +v ine +Ġcard board +Ġkind ly +Ġfr inge +ĠThe ft +icult ural +Ġgovern ors +Ġ ���� +Ġ16 3 +Ġtime out +ĠA uth +Child ren +A U +Ġred emption +ĠAl ger +Ġ19 14 +Ġw aved +Ġastron auts +og rams +Ġsw amp +ĠFinn ish +Ġcand le +Ġton nes +ut m +Ġr ay +Ġsp un +Ġfear ful +art icles +Ġca us +or ically +ĠRequ ires +ĠG ol +Ġpop e +Ġinaug ural +Ġg le +AD A +ĠIS IL +ĠOff ensive +Ġwatch dog +Ġbal con +ent ity +ĠH oo +Ġgall on +AC C +Ġdoub ling +Ġimpl ication +ĠS ight +Ġdoct r +---- --- +Ġ\ \ +Ġm alt +R oll +Ġâī ¥ +Ġrec ap +add ing +u ces +ĠB end +fig ure +Ġtur key +Ġsoc ietal +ĠT ickets +Ġcommer cially +Ġsp icy +Ġ2 16 +ĠR amp +Ġsuperior ity +à ¯ +ĠTr acker +C arl +ĠC oy +ĠPatri ot +Ġconsult ed +Ġlist ings +Ġsle w +reens hot +ĠG one +Ġ[ ...] +30 9 +Ġh ottest +Ø ± +Ġrock y +ĠD iaz +Ġmass age +Ġpar aly +Ġp ony +A z +Ġcart ridge +ĠN Z +Ġsn ack +ĠLam ar +ple ment +ĠLes lie +Ġm ater +Ġsn ipp +24 6 +Ġjoint ly +ĠBris bane +ĠiP od +Ġpump ing +Ġgo at +ĠSh aron +eal ing +Ġcor on +Ġan omal +rah im +ĠConnect ion +Ġsculpt ure +Ġsched uling +ĠD addy +at hing +Ġeyeb rows +Ġcur ved +Ġsent iments +Ġdraft ing +D rop +( [ +Ġnom inal +ĠLeaders hip +ĠG row +Ġ17 6 +Ġconstruct ive +iv ation +Ġcorrupt ed +ger ald +ĠC ros +ĠChe ster +ĠL ap +ãģ ª +OT H +D ATA +Ġal mond +pro bably +I mp +Ġfe ast +ĠWar craft +F lor +Ġcheck point +Ġtrans cription +Ġ20 4 +Ġtwe aks +Ġrel ieve +S cience +Ġperform er +Z one +Ġtur moil +ig ated +hib it +ĠC afe +the med +Ġflu or +ben ch +Ġde com +ĠU nt +ĠBar rett +ĠF acts +Ġt asting +ĠPTS D +ĠSe al +ĠJuda ism +ĠDynam ic +ĠC ors +V e +ĠM ing +ĠTrans form +v on +ĠDef enders +ĠTact ical +ĠV on +ĠUn ivers +Ġdist orted +ĠB reath +?' " +Ġag on +ĠDead ly +Ġl an +ĠCy cle +orn ed +Ġrel iably +Ġgl or +ĠMon key +ãĥ ¡ +Ġad ren +Ġmicrow ave +ĠAl ban +irc raft +dig it +sm art +ĠD read +¯¯¯¯¯¯¯¯ ¯¯¯¯¯¯¯¯ +{ { +ĠRoc hester +Ġsimpl ified +Ġinf licted +Ġtake over +Ġyour selves +ad itional +Ġmus cular +K S +Ġing en +T ax +ĠFe ature +27 7 +Ġcru c +Ġcr ate +Ġun identified +Ġacclaim ed +ĠM anga +ĠFr ances +ĠNep al +ĠG erald +ĠKu wait +Ġsl ain +ĠHe b +ĠG oku +ãģ® æ +28 6 +M rs +ĠC ody +ĠSan ctuary +01 6 +Ġdism ant +Ġdatas et +ĠH ond +b uck +ĠPat terson +Ġpal ette +ĠG D +ic ol +ĠL odge +Ġplanet ary +ak in +ĠRegist ered +ab we +ĠPeters burg +Ġha iled +ĠP iece +S che +ĠDO J +Ġen umer +18 1 +ĠObs erver +ĠB old +f ounded +com merce +Ġexplo its +ĠF inding +UR N +ĠS ne +ĠAc id +ay ette +ĠVal ues +Ġdr astic +Ġarchitect ural +Ġ" . +× ķ +ump ed +Ġwra pping +Ġwid ow +ĠSl ayer +l ace +on ce +German y +av oid +Ġtem ples +P AR +à ´ +ĠLuc ifer +ĠFl ickr +l ov +for ces +Ġsc outing +Ġlou der +tes y +Ġbefore hand +Ä ĵ +ĠNe on +ĠW ol +ĠTyp ically +ĠPolit ico +-+ -+ +Ġbuild er +Ġder ive +K ill +Ġp oker +Ġambig uous +Ġlif ts +Ġcy t +Ġrib s +ood le +ĠS ounds +h air +ĠSynd rome +t f +Ġproport ional +u id +Ġper taining +ĠKind le +ĠNeg ro +Ġreiter ated +ĠTon ight +oth s +ĠCorn ell +Ġo wing +Ġ20 8 +elf are +oc ating +ĠB irds +Sub scribe +Ġess ays +Ġburd ens +Ġillust rations +ar ious +ER AL +ĠCal cul +Ġx en +ĠLink edIn +ĠJ ung +Ġredes ign +Con nor +29 6 +Ġrevers al +ĠAd elaide +ĠL L +Ġs inking +Ġg um +US H +c apt +ĠGr imm +Ġfoot steps +ĠCB D +isp ers +Ġpro se +Wed nesday +ĠM ovies +ed in +Ġoverturn ed +Ġcontent ious +US B +~~~~~~~~ ~~~~~~~~ +ĠCo pper +Ġpoint less +N V +val ues +olph in +d ain +Ġdepos ited +ĠG W +Ġpreced ed +ĠCl a +ĠGo lem +ĠN im +ĠÎ ² +ĠEngine ers +m iddle +Ġfl att +oper ative +Ġcouncil s +imb abwe +el in +Ġstress ful +ĠL D +Ġres h +l ake +Ġwheel chair +ĠAltern ative +Ġoptim ize +oper ation +Ġpe ek +Ġones elf +ig il +Ġtrans itions +op athy +bl ank +Ġ16 9 +17 1 +________________________________ ________________________________ +Ġl aundering +En c +ĠD EC +Ġwork outs +Ġsp ikes +Ġdin osaurs +Ġdiscrim inatory +P ool +R ather +38 5 +R NA +tes ters +et o +ĠIdent ity +Ġve in +ĠBur ton +Ġarc ade +4 20 +Ult imately +ĠSad ly +à ° +p ill +Ġcub ic +ĠSpect rum +the se +st ates +Ġun official +h awks +ĠEVER Y +Ġrain bow +Ġincarcer ation +and ing +Ġsy ll +ĠEver ton +Ġ17 9 +ĠSer bia +Ġ18 9 +m eter +ĠMic key +Ġant iqu +Ġfact ual +ne ck +ĠN are +n orm +m ust +Ġhigh ways +Ġgl am +Ġdivid ing +ĠSquad ron +ĠMar tha +Ġbirth s +C over +//////// //////// +ĠW ong +Ph ot +ĠA LS +ri o +ĠNon etheless +ĠL emon +Ġ20 6 +ĠE E +Ġderiv ative +ĠWW II +v ote +Ġthere in +Ġsepar ating +44 6 +sy nc +ĠStre ets +Ġr att +Ġmunicip ality +ĠShort ly +Ġmon k +) ," +Ġscr ub +Ġoper atives +Ne ither +Pl ace +ĠLim it +F emale +ĠAct or +Char acter +Ġconstit uted +35 7 +Ġprotest ed +ĠSt raw +ĠHe ight +ild a +ĠTy ph +Ġflood s +Ġcos metic +W AY +pert ure +up on +t ons +ess ing +ĠP ocket +Ġro oft +ĠC aucas +Ġant idepress +Ġincomp atible +EC D +Ġoper a +ĠCont est +Ġgener ators +l ime +Def ense +19 87 +for um +Ġsav age +ĠHung arian +n z +Ġmet allic +Ġex pelled +Ġres idency +Ġdress es +66 6 +ĠC lement +f ires +C ategory +Ġge ek +al is +Ġc emetery +educ ated +Ġc rawl +ĠUn able +ĠT yson +ak is +Ġp ardon +ĠW ra +Ġstrengthen ed +ĠF ors +33 5 +ĠH C +ĠM ond +Ġvisual s +ĠBeat les +ett lement +Ġ ï +g ro +Ġb ash +Ġpo orest +Ġex cel +Ġaspir ations +ĠM unicip +ens ible +Ġceremon ies +Ġintimid ation +ĠCON TR +be ck +ĠK ap +as u +Ġtradem arks +ĠS ew +ĠComp etition +net work +ĠAr ri +ĠT et +Ro aming +W C +D at +Ġso b +Ġpair ing +Ġoverd ose +SA Y +ab er +Ġrev olt +ĠF ah +act ing +e q +est ation +F ight +ĠMar ks +27 3 +Ġ17 8 +R aw +ãģ ĭ +34 9 +bl ocks +Ġver ge +est ine +ĠPod esta +Ġinv asive +Ġprofound ly +ĠA o +e ach +Ġl est +inter pret +Ġshr inking +Ġerr one +Ġche es +ly s +ĠI vy +ĠDirect ory +Ġhint ed +V ICE +Ġcontact ing +ĠG ent +he i +Ġlabel ing +Ġmerc ury +ĠL ite +Ġexp ires +Ġdest abil +rit is +c u +Ġfeather s +Ġste er +Ġprogram med +ĠV ader +Go ing +ĠE lim +Ġy o +ĠMic he +Ġ20 3 +Ġslee ves +Ġb ully +ĠHum ans +36 8 +Ġcomp ress +ĠBan ner +AR S +Ġa while +Ġcal ib +Ġspons orship +ĠDiff iculty +ĠP apers +Ġident ifier +} . +Ġy og +ĠSh ia +Ġclean up +Ġvib e +int rodu +im ming +Austral ia +Ġout lines +ĠY outube +tr ain +ĠM akes +Ġde ported +Ġcent r +ĠD ug +ĠB oulder +ĠBuff y +Ġinj unction +ĠHar ley +ĠG roups +ĠD umbledore +ĠCl ara +Ġ" - +Ġsacrific ed +ep h +Sh adow +ib ling +Ġfreel ance +Ġevident ly +ph al +Ġret ains +M ir +Ġfin ite +d ar +ĠC ous +Ġrep aired +Ġperiod ic +Ġchampions hips +Ġaster oid +bl ind +Ġexpress ly +ĠAst ros +Ġsc aled +Ġge ographical +ĠRap ids +En joy +Ġel astic +ĠMoh amed +Mark et +be gin +Ġdisco vers +Ġtele communications +Ġscan ner +Ġen large +Ġsh arks +Ġpsy chedel +ĠRou ge +Ġsnap shot +is ine +X P +Ġpestic ides +ĠL SD +ĠDist ribution +re ally +Ġde gradation +Ġdisgu ise +Ġbi om +ĠEX T +Ġequ ations +Ġhaz ards +ĠComp ared +) * +Ġvirt ues +Ġeld ers +Ġenh ancing +ĠAc ross +er os +ang ling +Ġcomb ust +ucc i +Ġconc ussion +Ġcontrace ption +ĠK ang +Ġexpress es +Ġa ux +ĠP ione +Ġexhib its +Deb ug +OT AL +ĠAl ready +ĠWheel er +Ġexp ands +? : +Ġreconc iliation +Ġpir ates +Ġpur se +Ġdiscour age +Ġspect acle +R ank +Ġwra ps +ĠTh ought +Ġimp ending +O pp +ĠAng lo +ĠE UR +Ġscrew ed +ret ched +Ġencour agement +mod els +Ġconf use +mm m +ĠVit amin +âĸij âĸij +C ru +Ġkn ights +Ġdisc ard +Ġb ishops +ĠW ear +ĠGar rett +k an +ãĥ Ł +Ġmascul ine +cap ital +ĠA us +Ġfat ally +th anks +ĠA U +ĠG ut +12 00 +Ġ 00000000 +Ġsur rog +ĠBI OS +ra its +ĠWat ts +Ġresur rection +ĠElect oral +ĠT ips +4 000 +Ġnut rient +Ġdepict ing +Ġspr ink +Ġm uff +ĠL IM +ĠS ample +ps c +ib i +gener ated +Ġspec imens +Ġdiss atisf +Ġtail ored +Ġhold ings +ĠMonth ly +ĠE at +po ons +Ġne c +ĠC age +ĠLot us +ĠLan tern +Ġfront ier +Ġp ensions +Ġj oked +ĠHard y +=-=- =-=- +r ade +U ID +Ġr ails +Ġem it +Ġsl ate +Ġsm ug +Ġsp it +ĠCall s +ĠJac obs +f eat +ĠU E +Ġrest ruct +Ġregener ation +Ġenerg ies +ĠCon nor +OH N +ĠChe ese +Ġg er +Ġresur rect +man agement +N W +Ġpres ently +ĠBru ins +M ember +ĠM ang +id an +Ġboost ing +w yn ++ . +requ isite +ĠNY PD +ĠMe gan +ĠCond itions +Ġp ics +nes ium +ĠR ash +Ġ17 4 +ĠD ucks +Ġemb ro +z u +on ian +rel igious +Ġc raz +ĠAC A +ĠZ ucker +EM A +ĠPro s +We apon +ĠKn ox +ĠAr duino +Ġst ove +Ġheaven s +ĠP urchase +Ġher d +Ġfundra iser +Dig ital +5 000 +Ġprop onents +/ âĢĭ +Ġj elly +ĠVis a +Ġmon ks +Ġadvance ment +ĠW er +Ġ18 7 +e us +ert ility +Ġfet al +Ġ19 36 +L o +Ġout fits +Ġstair case +b omb +Ġcustom ized +cl air +T ree +Ġm apped +ĠConsider ing +ĠTor res +Ġmeth yl +Ġapprox imate +Ġdo om +ĠHans en +Ġc rossover +Ġstand alone +ä ¼ +Ġinv ites +Ġgra veyard +Ġh p +Donald Trump +Ġesc ort +G ar +Ġpredec essors +Ġh ay +Ġen zyme +ĠStra ight +vis ors +I ng +ane ously +ĠApp lied +Ġf ec +ĠDur ant +Ġout spoken +or b +Ġz eal +Ġdisgr ace +' ). +ĠChe ng +28 9 +ĠRen a +ĠSu icide +29 4 +Ġout raged +ĠNew man +ĠN vidia +ĠA ber +ĠB ers +Ġrecre ation +Wind ow +ĠD P +x e +Ġped oph +Ġfall out +ambo o +Ġpresent ations +ĠApp s +Ġh tml +3 45 +ĠX XX +Ġrub bing +ĠLe ather +Ġhum idity +se ys +est ablished +ĠUn its +64 6 +Ġrespect able +A uto +Ġthri ving +ĠInn ovation +ang s +Ext ra +reg ulation +29 8 +p ick +Ex amples +ĠC J +Att ack +Ġdr acon +L T +Ġstick er +re rs +Ġsun ny +I ss +reg ulated +d im +ĠAb stract +Ġhus bands +Off ice +om ination +it ars +AN GE +asc al +ĠK ris +ĠInf antry +Ġm alf +ĠA the +ĠR ally +bal anced +................ ........ +OU P +Ġmole cule +met ics +ĠSpl it +ĠInstruct ions +ĠN ights +c ards +Ġt ug +Ġcon e +å Ń +Ġt x +ĠDisc ussion +Ġcatast rophe +pp e +g io +Ġcommun ism +Ġhal ted +ĠGu ant +cle an +ĠSc hed +ĠK anye +Ġw ander +ĠSer iously +Ġ18 8 +enn ial +f ollow +product ive +ĠFl ow +ĠS ail +Ġc raw +Ġsim ulations +or u +ang les +ĠN olan +Ġmen stru +4 70 +Ġ20 7 +aj a +Ġcas ually +board ing +Ġ2 22 +ov y +ĠN umbers +um at +O E +28 7 +ĠCle mson +Ġcert s +Ġsl id +ĠT ribe +Ġto ast +Ġfort unes +Ġf als +ĠComm ittees +Ġg p +Ġf iery +ĠN ets +ĠAn ime +Pack age +ĠComp are +l aughter +in fect +Ġatroc ities +Ġjust ices +Ġins ults +ĠVern on +Ġsh aken +Ġperson a +est amp +36 7 +br ain +Ġexperiment ing +K en +ĠElect ronics +Ġ16 1 +dom ain +Ġgraph ical +b ishop +Ġwho pping +ĠEv angel +Ġadvertis ers +ĠSpe ar +Ġb ids +Ġdestro ys +ut z +Ġunders c +ĠAD D +Ġan ts +ĠC um +ipp les +ĠF ill +Ġgl anced +Ġind icted +ĠE ff +Ġmis con +ĠDes ktop +Ġab ide +ãĥ Ģ +ĠI o +ĠC oul +Ġcaps ule +ĠCh rys +M ON +Ġund es +ĠI RA +Ġc itation +Ġdict ate +ĠNet works +ĠConf lict +ĠSt uff +x a +is ec +ĠChem istry +Ġquarter ly +William s +an an +O pt +ĠAlexand ria +out heastern +ĠSpring field +ĠBlack s +Ġge ography +24 2 +Ġut most +ĠEx xon +ab outs +E VA +ĠEn able +ĠBar r +Ġdisag reed +ĠCy prus +Ġdement ia +Ġlab s +Ġubiqu itous +ĠLO VE +Ġconsolid ated +s r +Ġcream y +ĠTim ber +Reg ardless +ĠCert ificate +Ġ" ... +ogen ous +Capt ain +Ġinsult ing +ĠSor os +ĠInst r +ĠBulgar ia +bet ter +Ġsuck ing +ĠDavid son +at z +Ġcoll ateral +g if +Ġplag ued +ĠC ancel +ĠGard ner +R B +Ġsix teen +Rem ove +ur istic +c ook +R od +Ġcompr ising +f le +) âĢĶ +ĠVik ing +g rowth +agon al +Ġsr f +af ety +m ot +N early +st own +ĠF actor +Ġautom obile +Ġproced ural +m ask +amp ires +Ġdisapp ears +j ab +3 15 +Ġ19 51 +ne eded +Ġd aring +le ader +Ġp odium +Ġun healthy +Ġm und +Ġpy ramid +oc re +Ġkiss ed +Ġdream ed +ĠFant astic +ĠG ly +å Ĭ +Ġgreat ness +Ġsp ices +Ġmet ropolitan +Ġcomp uls +i ets +101 6 +ĠSh am +ĠP yr +fl ies +ĠMid night +Ġswall owed +Ġgen res +ĠL ucky +ĠRew ards +Ġdisp atch +ĠI PA +ĠApp ly +Ġa ven +al ities +3 12 +th ings +Ġ( ). +Ġm ates +ĠS z +ĠC OP +ol ate +O FF +Ġre charge +c aps +ĠYork er +ic one +Ġgal axies +ile aks +D ave +ĠP uzz +ĠCelt ic +ĠA FC +27 6 +ĠS ons +Ġaffirm ative +H or +Ġtutorial s +ĠC ITY +ĠR osa +ĠExt ension +Ser ies +Ġf ats +Ġr ab +l is +Ġun ic +Ġe ve +ĠSp in +Ġadul thood +ty p +Ġsect arian +Ġcheck out +ĠCy cl +S ingle +Ġmart yr +Ġch illing +88 8 +ou fl +Ġ] ; +Ġcongest ion +m k +ĠWhere as +Ġ19 38 +ur rencies +er ion +Ġbo ast +ĠPat ients +Ġch ap +ĠB D +real DonaldTrump +Ġexam ines +h ov +Ġstart ling +ĠBab ylon +w id +om ew +br ance +ĠOd yssey +w ig +Ġtor ch +ĠV ox +ĠMo z +ĠT roll +ĠAn s +Similar ly +ĠF ul +00 6 +Un less +ĠAl one +st ead +ĠPub lisher +r ights +t u +ĠDoes n +Ġprofession ally +Ġcl o +ic z +Ġste als +Ġ á +19 86 +Ġst urdy +ĠJoh ann +Ġmed als +Ġfil ings +ĠFr aser +d one +Ġmult inational +Ġf eder +Ġworth less +Ġp est +Yes terday +ank ind +Ġg ays +Ġb orne +ĠP OS +Pict ure +Ġpercent ages +25 1 +r ame +Ġpot ions +AM D +ĠLeban ese +Ġr ang +ĠL SU +ong s +Ġpen insula +ĠCl ause +AL K +oh a +ĠMac Book +Ġunanim ous +Ġl enders +Ġhang s +Ġfranch ises +ore rs +ĠUp dates +Ġisol ate +and ro +S oon +Ġdisrupt ive +ĠSur ve +Ġst itches +ĠSc orp +ĠDomin ion +Ġsupp lying +Ar g +Ġtur ret +ĠL uk +Ġbr ackets +* ) +ĠRevolution ary +ĠHon est +Ġnot icing +ĠSh annon +Ġafford ed +Ġth a +ĠJan et +! -- +ĠNare ndra +ĠPl ot +H ol +se ver +e enth +Ġobst ruction +Ġ10 24 +st aff +j as +or get +sc enes +l aughs +ĠF argo +cr ime +Ġorche str +Ġde let +ili ary +rie ved +Ġmilit ar +ĠGreen e +âĹ ı +ãģ ¦ +ĠGu ards +Ġunle ashed +ĠWe ber +Ġadjust able +Ġcal iber +Ġmotiv ations +Ġà ł +m Ah +ĠL anka +hand le +Ġp ent +ĠR av +ĠAng ular +ĠK au +umb ing +Ġphil anthrop +Ġde hyd +Ġtox icity +e er +ĠY ORK +w itz +å ¼ +ĠI E +commun ity +ĠA H +Ġret ali +Ġmass ively +ĠDani els +ĠD EL +Ġcar cin +Ur l +Ġrout ing +ĠNPC s +ĠR AF +ry ce +Ġwa ived +ĠGu atem +Every body +Ġco venant +Ġ17 3 +Ġrelax ing +Ġqu art +al most +Ġguard ed +ĠSold iers +ĠPL AY +Ġout going +L AND +Ġre write +ĠM OV +ĠIm per +ĠS olution +Ġphenomen al +Ġl ongevity +Ġimp at +ĠN issan +ir ie +Ġod or +ĠZ ar +ok s +Ġmilit ias +ĠSP EC +Ġtoler ated +ars er +ĠBrad ford ++ , +Ġsur real +s f +Can adian +Ġresemb lance +Ġcarbohyd rate +VI EW +Ġaccess ory +me al +larg est +ieg el +Some one +Ġtoug hest +os o +Ġfun nel +Ġcondemn ation +lu ent +Ġw ired +ĠSun set +Jes us +ĠP ST +ĠP ages +ĠTy coon +ĠP F +Ġselect ions +Ġ ठ+part isan +Ġhigh s +ĠR une +Ġcraft s +le ad +ĠParent s +Ġre claim +ek er +ĠAll ied +ae per +Ġlo oming +Ġbenefic iaries +ĠH ull +Stud ents +Jew ish +d j +Ġp act +tem plate +ĠOffic ials +ĠBay lor +Ġhe mp +Ġyouth s +ĠLevel s +ĠX iao +ĠC hes +Ġende avor +ĠRem oved +Ġhipp ocamp +H ell +ãĤ Ĭ +80 5 +Ġd inosaur +ĠWr ath +ĠIndones ian +Ġcalcul ator +ĠD ictionary +Ġ4 20 +ĠM AG +( _ +! , +t arians +Ġrestrict ing +rac use +Ġweek day +OU NT +Ġsh rugged +leg round +Ġb ald +ĠDo ctors +Ġt outed +ĠMax well +Ġ2 14 +Ġdiplom at +Ġrep ression +Ġconstitu ency +v ice +r anked +ĠNap oleon +g ang +ĠFore ver +t un +Ġbul b +ĠPD T +ĠC isco +V EN +Ġres umed +Ste ven +ĠManit oba +Ġfab ulous +ĠAg ents +19 84 +Ġam using +ĠMyster ies +Ġor thodox +fl oor +Ġquestion naire +Ġpenet rate +Ġfilm makers +ĠUn c +Ġst amped +Ġth irteen +Ġout field +Ġforward ed +Ġapp ra +Ġa ided +t ry +Ġunf ocused +ĠL iz +ĠWend y +ĠSc ene +Ch arg +Ġreject s +Ġleft ist +ĠProv idence +ĠBr id +reg n +Ġprophe cy +ĠL IVE +4 99 +Ġfor ge +ĠF ML +Ġintrins ic +ĠF rog +Ġw ont +ĠH olt +Ġfam ed +CL US +aeper nick +ĠH ate +ĠC ay +Ġregister ing +ort ality +rop y +ocaly ptic +a an +n av +Ġfasc ist +IF IED +Ġimpl icated +ĠRes ort +ĠChand ler +ĠBr ick +P in +ys c +Us age +ĠHel m +us ra +âĺħ âĺħ +ĠAb bas +Ġunanim ously +Ġke eper +Ġadd icted +?? ? +Ġhelm ets +Ġant ioxid +aps ed +80 8 +gi ene +Ġwa its +Ġmin ion +ra ved +ĠP orsche +Ġdream ing +Ġ17 1 +ĠC ain +Ġun for +ass o +ĠConfig uration +k un +hard t +Ġn ested +ĠL DS +L ES +Ġt ying +en os +Ġc ue +ĠMar qu +sk irts +Ġclick ed +Ġexp iration +ĠAccording ly +ĠW C +Ġbless ings +Ġaddict ive +ĠN arr +y x +ĠJagu ars +Ġrent s +ĠS iber +Ġt ipped +ous se +ĠFitz gerald +Ġhier arch +out ine +Ġwa velength +> . +ch id +ĠProcess ing +/ + +r anking +E asy +ĠConst ruct +Ġt et +ins ured +H UD +Ġqu oting +Ġcommun icated +in x +Ġin mate +Ġerect ed +ĠAbs olutely +ĠSure ly +Ġun im +ĠThr one +he id +Ġcl aws +Ġsuper star +ĠL enn +ĠWh is +U k +ab ol +Ġsk et +ĠN iet +Ġper ks +Ġaff inity +Ġopen ings +phas is +Ġdiscrim inate +T ip +v c +Ġgr inding +ĠJenn y +Ġast hma +hol es +ĠHom er +Ġreg isters +ĠGl ad +Ġcre ations +Ġlith ium +Ġappl ause +unt il +Just ice +ĠTur ks +Ġsc andals +Ġb ake +t ank +M ech +ĠMe ans +ĠM aid +Republic ans +is al +wind ows +ĠSant os +Ġveget ation +33 8 +t ri +Ġfl ux +ins ert +Ġclar ified +Ġmort g +ĠCh im +ĠT ort +Ġdiscl aim +met al +ĠAs ide +Ġindu ction +Ġinf l +Ġathe ists +amp h +Ġe ther +ĠV ital +ĠBu ilt +M ind +Ġweapon ry +S ET +Ġ18 6 +ad min +g am +cont ract +af a +Ġderiv atives +Ġsn acks +Ġch urn +E conom +Ġca pped +ĠUnder standing +ĠH ers +ĠI z +Ġd uct +I ENT +augh ty +Ġâľ Ķ +ĠN P +Ġsa iling +In itialized +Ġt ed +Ġreact ors +ĠL omb +Ġcho ke +ĠW orm +Ġadm iration +Ġsw ung +ens ibly +Ġr ash +ĠGo als +ĠImport ant +Sh ot +ĠR as +Ġtrain ers +ĠB un +Work ing +Ġhar med +ĠPand ora +ĠL TE +Ġmush room +ĠCH AR +ĠF ee +ĠM oy +B orn +ol iberal +ĠMart ial +Ġgentle men +Ġling ering +Offic ial +Ġgra ffiti +ĠN ames +D er +Ġqu int +ist rate +aze era +ĠNOT ICE +ĠFlore nce +Ġpay able +Ġdep icts +ĠSpe cies +He art +âĶĢâĶĢâĶĢâĶĢ âĶĢâĶĢâĶĢâĶĢ +Ġencl osed +Incre ases +D aily +ĠL is +Ġenact ment +ĠB acon +ĠSt eele +dem and +Ġ18 3 +Ġmouth s +Ġstr anded +Ġenhance ment +01 1 +ĠWh ats +Ġhe aled +en y +ĠR ab +Ġ3 40 +ĠLab yrinth +ro ach +ĠY osh +ĠCl ippers +Ġconcert s +Intern et +35 5 +Ġstick ers +Ġter med +ĠAx e +Ġgrand parents +Fr ance +ĠCl im +ĠU h +ul ic +Ġthr ill +cent ric +ĠOver view +ĠCond uct +Ġsubstant ive +Ġ18 2 +m ur +Ġstr ay +ĠCo ff +Ġrep etitive +ĠFor gotten +Ġqual ification +ew itness +ĠZ imbabwe +Ġsim ulated +ĠJ D +25 3 +ĠW are +Ġun sc +T imes +Ġsum mons +Ġdis connected +Ġ18 4 +ci us +ĠGu jar +od ka +Ġer ase +ĠTob acco +elect ed +Ġun cont +ĠShe pard +ĠL amp +Ġalert ed +Ġoper ative +arn a +u int +Ġneglig ence +ac ements +Ġsup ra +Ġprev ail +ĠSh ark +Ġbel ts +ãģ « +Ġt ighter +Engine ers +Ġin active +Ġexp onent +ĠWill ie +a ples +Ġhe ir +ĠH its +ian n +ĠS ays +Ġcurrent s +ĠBeng al +Ġar ist +B uffer +Ġbree ze +ĠWes ley +Col a +Ġpron oun +Ġde ed +ĠK ling +Ġof t +Ġinf lict +Ġpun ishing +Ġn m +ik u +OD UCT +01 4 +Ġsubsid y +ĠDE A +ĠHer bert +ĠJ al +B ank +Ġdef erred +Ġship ment +B ott +Ġal le +b earing +HT ML +Off line +Ġ2 13 +Ġscroll ing +Ġsc anned +ĠLib yan +ĠT OP +ch rom +d t +col umn +Psy NetMessage +Z ero +Ġtor so +0 50 +âķ IJ +Ġimp erson +ĠSchw artz +ud ic +Ġpiss ed +ĠS app +25 7 +ĠIS Ps +og l +Ġsuper vised +Ġad olescent +Ġatt ained +ĠDel ivery +ĠB unny +Ġ19 37 +Ġmini ature +Ġo s +Ġ3 70 +60 8 +ĠMour inho +Ġinn ate +Ġtem po +ĠN M +ĠFall en +00 9 +Ġprov ocative +Stream er +ĠBened ict +ĠBol she +Ġt urtle +ĠPC B +ĠEqu al +Direct or +ĠR end +Ġflu ids +Author ities +Ġcous ins +requ ency +ĠNeigh bor +s ets +sh ared +Char les +pass word +Ġg ears +Ġ2 11 +ĠHard ware +ri ka +Ġup stream +H om +Ġdisproportion ately +iv ities +Ġund efined +Ġelect rons +Ġcommem or +Event ually +Ġ> < +Ġir responsible +2 18 +ĠRe leased +ĠO VER +ĠI GN +ĠB read +st ellar +ĠS age +tt ed +dam age +ed ition +ĠPre c +Ġl ime +Ġconf inement +Ġcal orie +we apon +Ġdiff ering +ĠS ina +m ys +am d +Ġintric ate +k k +ĠP AT +ã o +st ones +lin ks +Ġr anch +Sem itic +Ġdifferent iate +ĠS inger +occup ied +Ġfort ress +c md +Ġinter ception +ĠAnk ara +Ġre pt +ĠSol itaire +Ġrem ake +p red +Ġd ared +aut ions +ĠB ACK +Run ning +Ġdebug ging +Ġgraph s +3 99 +ĠNig el +Ġb un +Ġpill ow +Ġprog ressed +fashion ed +Ġob edience +ER N +Ġrehe ars +C ell +t l +S her +Ġher ald +ĠPay ment +ĠC ory +ĠDe pt +Ġrep ent +ĠWe ak +uck land +Ġple asing +Ġshort ages +Ġjur ors +ĠK ab +q qa +Ant i +Ġw ow +ĠRC MP +Ġt sun +ĠS ic +Ġcomp rises +Ġsp ies +Ġprec inct +n u +Ġur ges +Ġtim ed +Ġstrip es +ĠB oots +Ġy en +Adv anced +Ġdisc rete +ĠArch angel +employ ment +D iff +Ġmon uments +Ġ20 9 +work er +Ġ19 6 +ĠI g +utter stock +T PS +J ac +Ġhomeless ness +Ġcomment ator +Ġrac ially +f ing +se ed +E le +ell ation +Ġeth anol +Ġpar ish +ĠD ong +ĠAw akening +Ġdev iation +ĠB earing +ĠTsu k +Ġrec ess +Ġl ymph +ĠCann abis +å ľ +ĠNEW S +Ġd ra +ĠStef an +ĠWr ong +ĠS AM +Ġloose ly +Ġinterpre ter +ĠPl ain +Go vernment +Ġbigot ry +Ġgren ades +ave z +pict ured +Ġmand ated +ĠMon k +ĠPed ro +Ġl ava +27 4 +Ġcyn ical +ĠScroll s +l ocks +M p +Ġcon gregation +orn ings +ph il +ĠI bid +Ġf erv +Ġdisapp earing +Ġarrog ant +sy n +ĠMa ver +ĠSu it +24 1 +Ġab bre +ack ers +P a +ĠY el +Whe never +Ġ23 5 +ĠV ine +ĠAn at +Ġext inct +LE T +Ġexecut able +V ERS +ox ide +D NA +ĠP rel +Ġresent ment +Ġcompr ise +ĠAv iv +Ġinter ceptions +Ġprol ific +IN A +ĠEr in +though t +2 19 +ĠPsychiat ry +un ky +chem ist +H o +ĠMcC oy +Ġbr icks +L os +ri ly +ĠUS SR +Ġr ud +Ġl aud +ĠW ise +ĠEmer ald +Ġrev ived +Ġdam ned +ĠRep air +id em +ct ica +Ġpatri arch +ĠN urs +me g +Ġcheap est +re ements +empt y +ĠCele br +Ġdepri vation +ch anted +ĠTh umbnails +E nergy +ĠEth an +ĠQ ing +Ġopp oses +W IND +v ik +ĠM au +ĠS UB +66 7 +G RE +ĠVol unte +nt on +C ook +å IJ +es que +Ġplum met +Ġsu ing +Ġpron ounce +Ġresist ing +ĠF ishing +ĠTri als +Ġy ell +Ġ3 10 +Ġin duct +Ġpersonal ized +oft en +R eb +EM BER +Ġview point +Ġexist ential +() ) +rem ove +MENT S +l asses +Ġev apor +Ġa isle +met a +Ġreflect ive +Ġentit lement +Ġdev ised +mus ic +asc ade +Ġwind ing +off set +Ġaccess ibility +ke red +Bet ter +ĠJohn ston +th inking +S now +ĠCroat ia +ĠAt omic +27 1 +34 8 +Ġtext book +ĠSix th +Ġ اÙĦ +Ġsl ider +ĠBur ger +b ol +S ync +Ġgrand children +Ġc erv ++ ) +Ġe ternity +Ġtweet ing +Ġspec ulative +Ġpiv otal +ĠW P +ĠT ER +ynam ic +Ġu pl +ĠC ats +per haps +Ġclass mates +Ġblat ant +' - +Ġl akh +ant ine +ĠB org +i om +/ ( +ĠAthlet ic +Ġs ar +OT A +ĠHoff man +Never theless +Ġad orable +Ġspawn ed +Ass ociated +ĠDom estic +Ġimpl ant +ĠLux em +ĠK ens +Ġp umps +ĠS AT +Att ributes +50 9 +av our +Ġcentral ized +ĠT N +Ġfresh ly +ĠA chieve +Ġouts iders +her ty +ĠRe e +ĠT owers +ĠD art +ak able +Ġm p +ĠHeaven ly +Ġr ipe +ĠCarol ine +ry an +Ġclass ics +Ġret iring +Ġ2 28 +Ġa h +Ġdeal ings +Ġpunch ing +ĠChap man +O ptions +max well +vol ume +Ġst al +Ġex ported +ĠQu ite +Ġnumer ical +B urn +F act +ĠKey stone +Ġtrend ing +Ġalter ing +ĠAfric ans +47 8 +ĠM N +ĠKn ock +Ġtempt ation +Ġprest ige +Over view +ĠTrad itional +ĠBah rain +Priv ate +ĠH OU +Ġbar r +ĠT at +C ube +US D +ĠGrand e +ĠG at +ĠFl o +Ġres ides +Ġind ec +vol ent +Ġperpet ual +ub es +Ġworld view +ĠQuant um +Ġfil tered +Ġen su +orget own +ERS ON +ĠM ild +37 9 +OT T +à ¥ +Ġvit amins +Ġrib bon +Ġsincere ly +ĠH in +Ġeight een +Ġcontradict ory +Ġgl aring +Ġexpect ancy +Ġcons pir +Ġmon strous +Ġ3 80 +re ci +Ġhand ic +Ġpump ed +Ġindic ative +Ġr app +Ġav ail +ĠLEG O +ĠMar ijuana +19 85 +ert on +Ġtwent ieth +################ ################ +ĠSw amp +Ġval uation +Ġaffili ates +adjust ed +ĠFac ility +26 2 +Ġenz ymes +itud inal +Ġimp rint +S ite +Ġinstall er +ĠT RA +m ology +lin ear +ĠCollect ive +ig ating +ĠT oken +Ġspec ulated +K N +ĠC ly +or ity +Ġdef er +Ġinspect ors +appro ved +R M +ĠSun s +Ġinform ing +ĠSy racuse +ib li +7 65 +Ġgl ove +Ġauthor ize +âĢ¦âĢ¦âĢ¦âĢ¦ âĢ¦âĢ¦âĢ¦âĢ¦ +ĠCru ise +Ġcontract ing +she ll +IF E +ĠJew el +p ract +ĠPhot oshop +ĠKnow ing +h arm +Ġattract ions +ad an +et us +01 8 +w agen +Al t +Ġmultip ly +Ġequ ilibrium +: { +ĠF ighters +ĠEd gar +Ġfour teen +Go vern +Ġmis use +Ġab using +Ġancest ry +ram er +64 4 +Ġwor ms +Ġthick er +ĠComb ine +Ġpeas ants +Ġv ind +Ġcon quest +Ġm ocked +Ġc innamon +ĠC ald +ĠGall up +Ġavoid ance +Ġincarn ation +ĠStr at +Ġt asted +ent a +ĠN eal +p ared +Ġtermin ology +ject ion +Scient ists +ĠIN S +ĠDe e +Ġdirect ories +R oad +ĠSh ap +br ight +ĠDirect ors +ĠCol umn +Ġb ob +Ġprefer ably +Ġgl itch +f urt +Ġe g +id is +C BC +Ġsur rendered +Ġtest ament +33 6 +ug gest +ĠN il +an other +Ġpat hetic +ĠDon na +Ġ2 18 +ĠA very +Ġwhis key +Ġf ixture +ĠCon quest +Ġbet s +O cc +ĠLe icester +] ." +Ġ) ); +Ġfl ashes +45 6 +Ġmask ed +ge bra +Ġcomput ed +che l +aud er +Ġdefe ats +ĠLiber ation +ĠOs ama +ĠV ive +Ch anges +Ch annel +Ġtar iffs +Ġm age +ĠS ax +Ġinadvert ently +ĠC RE +ĠRe aper +ink y +gr ading +Ġstere otyp +Ġcur l +ĠF ANT +Ġfram eworks +M om +ĠAn ch +Ġflav our +car bon +Ġperm itting +let cher +ĠMo zilla +ĠPark ing +ĠCh amp +Sc roll +Ġmurd erer +Ġrest ed +Ġow es +ĠP oss +AD D +IF F +res olution +ĠMin ing +Ġcompar ative +D im +Ġneighbour ing +ĠA ST +ĠT oxic +Ġbi ases +Ġgun fire +ur ous +ĠMom ent +19 83 +Ġper vasive +tt p +ĠNorm ally +r ir +S arah +ĠAlb any +Ġun sett +ĠS MS +ip ers +l ayer +ĠWh ites +up le +Ġtur bo +ĠLe eds +Ġthat s +ĠMin er +M ER +ĠRe ign +Ġper me +ĠBl itz +Ġ19 34 +Ġintimid ating +t ube +Ġecc entric +ab olic +box es +ĠAssoci ates +v otes +Ġsim ulate +um bo +aster y +Ġship ments +FF FF +an th +Ġseason ed +Ġexperiment ation +âĸ ł +law s +Me et +idd les +ant ics +R ating +IS IS +h ift +Ġfront s +b uf +01 7 +Ġun att +ĠD il +le ases +ĠGard ens +77 7 +t ouch +ve ll +45 8 +Ġ= ==== +s aving +Ġer osion +ĠQu in +Ġearn s +Ġaccomplish ment +ĠWe i +Ġ< [ +____ _ +Ġir rig +ĠT eddy +Ġconqu ered +ĠArm ored +Ġassert s +Ġmanip ulating +r é +Ġtranscript s +G allery +Ġplot ting +Ne il +Ġbetray al +load er +ĠS ul +Ġdispl acement +Ġroy alty +ĠW I +he it +ĠDev ices +alle l +Ġmunicipal ities +Ġcan al +St ars +ĠU AE +Ġ" âĢ¦ +ĠC U +ab ove +Ġreson ance +ĠguiActive Un +add ed +ĠBra ves +ĠI bn +Ġhere by +ĠB RE +Ġshare holder +ĠH ir +ĠJ i +Ġstrange ly +Ġadm ired +Ġpl ight +Ġb achelor +ĠP ole +cipl inary +T ony +ĠArmen ian +Ġun man +ĠZion ist +St age +isco ver +Ġautom otive +Ġs idelines +Ġsl ick +ĠRena issance +ĠF UN +Im ages +ĠH aj +Ġp ing +Ġshort cut +ĠBl vd +ĠLook s +Ġbur sts +Ġcl amp +Ġm ish +Ġsort ing +Ġpatri ot +Ġcorrect ness +ĠScand inav +ĠCaval iers +p ython +az ar +Ġ3 75 +ĠJa une +40 9 +Ġdetrim ental +Ġstab bing +Ġpoison ed +Ġf ountain +oc ent +or st +ĠMar i +Ġr ains +ĠO vers +ĠInst itution +ud get +AM Y +t ale +ĠK R +ĠPr ices +Ġhead aches +Ġlands l +ĠA ura +Bon us +ĠZ hao +ĠH ip +Ġhop s +ĠKurd istan +Ġexplo iting +ry n +Ġhypocr isy +op ening +Ġgun shot +Ġw ed +inter stitial +Inter stitial +Ġam en +Bre aking +Ġmarket ed +W ire +ĠC rowd +Contin ue +ĠK nown +ĠEffect ive +ore an +iz ons +Jose ph +Ġescal ation +us ername +Ġcur tain +AT ES +ĠP AR +ĠM iy +Ġcounter fe +l ene +Ġcont enders +d aily +ĠAs c +ĠPhill ip +most ly +Ġfil ename +he ne +Ġresemb ling +Ġst aging +ĠCh loe +Ġw iring +H on +ĠRen ew +ott age +ĠHy brid +m uch +Ġstro kes +Ġpolicy makers +AP TER +ĠArk ham +pl ot +Ġassist ants +Ġde port +ĠSe ga +Ġinflu enza +ĠC ursed +ĠK obe +Ġskin ny +Prov ider +ĠR ip +Ġincrement al +product s +B F +Ġd ome +ĠC redits +Ġlos ers +int s +ĠBet ty +ĠTal ent +ĠD AM +L v +E ss +Ġd ens +tem p +J udge +od ic +Ġ' ( +UR ES +ets k +V O +Ġretrie ved +Ġarchitect s +Ù ĩ +Ġeth ic +ĠSecond ary +st ocks +ad ia +Ġ3 25 +ĠOp inion +Ġsimultane ous +Ġd izz +ul p +Ġsmugg ling +ipp ery +R andom +f acing +ĠD as +Ġstock p +Ġdiscl osures +po inter +Ġcor al +ĠSe lection +ĠP ike +ival ent +Ġruth less +ĠR im +Ġensu ing +ĠExper iment +Ġcongress man +Ġbelie ver +Ġun specified +ĠM ord +Ġknowledge able +ĠV ERY +T X +Ġstra ps +Ġtur f +apesh ifter +Ġmar ital +Ġfl ock +ãģ Ĩ +26 3 +AM ES +ĠOpp osition +Ġtre asures +ĠG OD +Ġmodel ed +ĠWOR LD +Ġ( [ +ĠUs age +H F +Ġ$ ( +uss ed +Ġpione er +E ight +par se +b read +rit z +ĠMir anda +ĠK ant +++ ) +ore n +Ġprov oked +Ġbre eds +ĠIn cludes +ĠPast ebin +ĠFl ip +J ava +Ġbr ink +Ġrum ored +Ġun seen +Ġgar nered +ĠDef in +al ted +Ġtatt oos +Ġhes itation +is itions +ĠWe aver +ĠReport ing +Ġtherap ies +Ġconsult ants +Ġresid ual +ĠMal i +ĠRom a +i ago +ĠRes idents +ub i +Ġremed ies +Ġadapt ive +ĠAl ive +ĠBar cl +Ġwal lets +c rypt +etermin ation +ĠPel osi +Ġsl ipping +oton in +Ġall iances +pat rick +ir is +Ġor th +ĠPer kins +ĠDe V +ĠG ets +Ġdry ing +ge e +fore st +ĠFor get +ore m +33 9 +Ġvague ly +ĠD ion +ĠP orn +ĠH OW +Ġp neum +Ġrub ble +ĠT aste +enc ia +ĠG el +Ġd st +Ġ24 5 +ĠMoroc co +inf lamm +ĠTw ins +Ġb ots +d aughter +ĠB alk +Ġbre thren +Ġlog os +Ġgo bl +f ps +Ġsub division +Ġp awn +Ġsquee zed +Ġmor ale +ĠD W +' " +Ġkn ot +ook y +Ġdiv isive +Ġboost ed +ch y +ãĥ IJ +if act +Ġnewcom ers +ĠWrest ling +Ġsc outs +w olves +R at +Ġnin eteenth +ĠOs borne +St ats +Ġem powered +Ġpsych opath +ĠO EM +ugg age +ĠP K +ĠMoh ammad +P ak +Ġanarch ists +ĠExt ract +est hes +ĠStock holm +l oo +ĠG raph +Ġdeploy ing +ĠStr anger +ĠM old +Ġstaff er +Ġdiscount ed +uck le +ple ase +ĠLand ing +ÃŃ a +Ġ19 3 +Ġan te +Ġrep etition +Ġ+ /- +Ġpar ody +Ġlive ly +AA A +ĠHor us +Ġp its +ind ers +L OC +ĠVen ice +40 6 +ĠDis cover +â Ĩ +ellect ual +Ġp ens +Ġey el +ig uous +Im pl +Ġj oking +Ġinv al +ĠBel fast +Ġcredit ors +ĠSky walker +ov sky +Ġcease fire +Ġse als +is oft +) ). +ĠFel ix +IT S +Ġt resp +ĠBlock chain +ew are +ĠSch war +en ne +mount ed +ĠBe acon +les h +Ġimmense ly +Ġche ering +Em ploy +sc ene +ish ly +atche wan +ĠNic olas +Ġdr ained +ĠEx it +ĠAz erb +j un +Ġflo ated +u ania +De ep +Ġsuper v +Ġmyst ical +ĠD ollar +ĠApost le +ĠR EL +ĠProv ided +ĠB ucks +ãĥ ´ +cut ting +Ġenhance ments +ĠPengu ins +ĠIsa iah +Ġj erk +ĠW yn +Ġst alled +Ġcryptoc urrencies +ĠR oland +sing le +Ġl umin +ĠF ellow +ĠCap acity +ĠKaz akh +W N +Ġfin anced +38 9 +Ġt id +Ġcoll usion +ĠMy r +î Ģ +Sen ator +Ġped iatric +Ġneat ly +Ġsandwic hes +ĠArchitect ure +Ġt ucked +Ġbalcon y +Ġearthqu akes +qu ire +F uture +Ġhe fty +é Ĺ +Ġspecial izes +Ġstress es +Ġs ender +Ġmisunder standing +Ġep ile +Ġprov oke +ĠCol ors +Ġdis may +uk o +[ _ +58 6 +ne utral +Ġdon ating +ĠRand all +Mult i +Ġconvenient ly +ĠS ung +ĠC oca +Ġt ents +ĠAc celer +Ġpart nered +27 2 +ir ming +ĠB AS +s ometimes +Ġobject ed +ub ric +p osed +LC S +gr ass +Ġattribut able +V IS +Israel i +Ġrepe ats +ĠR M +v ag +ut a +in ous +Ġin ert +ĠMig uel +æ Ń +ĠHawai ian +B oard +Ġart ific +ĠAzerb ai +as io +ĠR ent +A IN +Ġappl iances +Ġnational ity +Ġass hole +ĠN eb +Ġnot ch +h ani +ĠBr ide +Av ailability +Ġintercept ed +Ġcontin ental +Ġsw elling +ĠPers pect +b ies +. < +ith metic +ĠL ara +Ġtempt ing +add r +Ġoversee ing +cl ad +ĠD V +ĠGing rich +Ġm un +ĠApp ropri +Ġalter ations +ĠPat reon +Ġha voc +Ġdiscipl ines +Ġnotor iously +aku ya +ier i +? ). +ĠW ent +Ġsil icon +Ġtre mb +Cont ainer +K nown +Ġmort ar +est e +ick a +Ar thur +ĠPre viously +ĠMart y +Ġsp arse +g ins +Ġin ward +ĠParticip ant +C opy +ĠM isc +Ġantib iotic +ĠRet ro +Ġel usive +Ġass ail +ĠBatt alion +ĠB ought +Ġdimin ish +ĠEuro pa +s ession +ĠDanger ous +ies el +Ġdisbel ief +Ġbl asts +ext reme +ĠBoy d +ĠProject s +ĠGu ys +Ġunder gone +Ġgr ill +ĠDw ight +Ġ19 7 +US ER +Ġfiles ystem +Ġcl ocks +T aylor +Ġwra pper +Ġfold ing +ous and +ĠPhilipp ine +ATION AL +ĠPer th +Ġas hes +Ġaccum ulate +ĠGate way +Sh op +orks hire +H an +ĠBar rel +ĠLe h +ĠX V +Ġwh im +Ġrep o +ĠC G +ĠM am +Ġincorpor ating +Ġbail out +Ġlingu istic +Ġdis integ +C LE +Ġcinem atic +ĠF iber +S yn +il ion +ĠCom pos +c hens +Ġne oc +Ġbo iled +F INE +on o +un cle +ik en +ĠB M +Î ¹ +Ġreceipt s +Ġdisp osed +ĠTh irty +ĠR ough +ĠA BS +Ġnot withstanding +oll en +# $ +Ġunrel iable +Ġbl oom +Ġmedi ocre +Ġtr am +ĠTas man +Ġsh akes +Ġmanifest o +ĠM W +Ġsatisf actory +Ġsh ores +Ġcomput ation +Ġassert ions +orm ons +ar ag +ab it +Dem ocrats +ĠL oot +ĠVol ks +ha ired +Ġgrav itational +S ing +ĠM iz +Ġthro ttle +Ġtyr anny +ĠView s +Ġrob ber +ĠMinor ity +Ġsh rine +sc ope +pur pose +Ġnucle us +our cing +ĠUS DA +ĠD HS +w ra +ĠBow ie +Sc ale +ĠB EL +x i +I ter +Ġ( ), +w right +Ġsail ors +ous ed +NAS A +ĠPro of +ĠMin eral +t oken +ĠF D +R ew +Ġe ll +6 30 +Ġchance llor +ĠG os +Ġamount ed +ĠRec re +ome z +ĠOpt im +ĠOl ive +Ġtrack er +ow ler +ĠUn ique +R oot +Ġmar itime +ĠQur an +ĠAd apt +Ġecosystem s +ĠRe peat +ĠS oy +ĠI MP +Ġgrad uating +and em +P ur +ĠRes et +ĠTr ick +ĠPh illy +ĠT ue +ĠMalays ian +Ġclim ax +Ġb ury +Ġcons pic +ĠSouth ampton +ĠFl owers +Ġesc orted +ĠEduc ational +ĠI RC +Ġbrut ally +e ating +Ġpill ar +ĠS ang +ĠJ ude +ar ling +ĠAm nesty +Ġrem inding +ĠAdminist rative +hes da +Ġfl ashed +ĠP BS +per ate +fe ature +Ġsw ipe +Ġgra ves +oult ry +26 1 +bre aks +ĠGu er +Ġsh rimp +ĠV oting +qu ist +Ġanaly tical +Ġtables poons +ĠS OU +Ġresear ched +Ġdisrupt ed +Ġj our +Ġrepl ica +Ġcart oons +b ians +} ) +c opy +G ot +ou ched +P UT +Ġsw arm +not ations +s aid +Ġreb uilt +Ġcollabor ate +Ġr aging +Ġn ar +Ġdem ographics +ĠD DR +Ġdist rust +oss ier +ĠK ro +Ġpump kin +Ġreg rets +Ġfatal ities +ĠL ens +ĠO le +p d +Ġpupp et +ĠOut look +ĠSt am +O l +F air +U U +Ġre written +Ä ± +Ġfasc inated +Ġve ctors +Ġtrib unal +u ay +ĠM ats +ĠCo ins +[ [ +Ġ18 1 +Ġrend ers +ĠK aepernick +Ġesp ionage +Ġsum m +Ġd itch +Acc ount +Ġspread sheet +Ġmut ant +p ast +40 7 +Ġd ye +Ġinit iation +Ġ4 000 +Ġpunish able +Ġth inner +ĠKh al +Ġinter medi +D un +ĠGoth am +Ġeager ly +Ġvag inal +p owers +V W +ĠWATCH ED +Ġpred ator +ams ung +Ġdispar ity +Ġ[ * +Ġam ph +Ġout skirts +ĠSpir its +Ġskelet al +Ð » +ĠR ear +Ġissu ance +ĠLog ic +re leased +Z Z +ĠB ound +Ent ry +Ġex its +is ol +ĠFound er +Ġw re +ĠGreen land +ĠM MO +t aker +IN C +ãģ ¾ +Ġhour ly +hen ko +Ġfantas ies +Ġdis ob +Ġdemol ition +ãĥ ĭ +Ġen listed +rat ulations +Ġmis guided +Ġens ured +Ġdiscour aged +m ort +Ġfl ank +Ġc ess +Ġreact s +ĠS ere +s ensitive +ĠSer pent +ass ad +Ġ24 7 +Ġcalm ly +b usters +Ġble ed +ĠSt ro +Ġamuse ment +ĠAntar ctica +Ġs cept +ĠG aw +a q +ason ic +Ġsp rawling +n ative +atur ated +ĠBattle field +IV ERS +E B +ĠG ems +ĠNorth western +ĠFil ms +ĠAut omatic +Ġappre hend +ãģ ¨ +Ġgui Name +Ġback end +Ġevid enced +ge ant +01 2 +ĠS iege +Ġexternal To +Ġunfocused Range +ĠguiActiveUn focused +Ġgui Icon +ĠexternalTo EVA +ĠexternalToEVA Only +F ri +ch ard +en aries +Ġchief s +Ġc f +ĠH UD +Ġcorro bor +Ġd B +ĠT aken +ĠPat ricia +ra il +ĠCh arm +ĠLiber tarian +rie ve +Person al +ĠO UR +ger ies +Ġdump ing +Ġneurolog ical +it imate +ĠClint ons +raft ed +ĠM olly +Ġtermin als +reg ister +Ġfl are +Ġenc oded +Ġautop sy +p el +m achine +Ġexempt ions +ĠRoy als +d istance +Ġdraft s +Ġl ame +ĠC unning +Ġsp ouses +ĠMark ets +ĠCar rier +Ġimp lying +ĠY ak +s id +Ġl oser +Ġvigil ant +Ġimpe achment +Ġaug mented +ĠEmploy ees +Ġunint ended +tern ally +ĠW att +Ġrecogn izable +ess im +æ Ŀ +Ġco ated +r ha +Ġlie utenant +ĠLegisl ation +pub lished +44 4 +01 3 +Ġide ally +ĠPass word +Ġsimpl ify +ĠMet a +ĠM RI +Ġple ading +organ ized +hand ler +Ġun ravel +cor rect +Ġ icy +Ġparan oid +Ġpass er +Ġinspect ions +of er +ĠHealth care +28 3 +ĠBr ut +iol a +for ge +ĠMed ieval +MS N +ie vers +ĠProgram ming +å ī +Ġ2 23 +m u +ĠC LE +ug a +Ġsho ppers +Ġinform ative +ĠPl ans +Ġsupplement ation +ĠT ests +ty ard +ocy tes +ĠVeg a +ĠGujar at +erman ent +Ex cept +ĠL OT +all a +ĠC umm +ĠO sw +Ġven om +ĠDeb t +ĠD OWN +Ġreun ion +Ġm uc +ĠRel ief +Ġge op +ĠðŁ ĺ +al ogue +An th +ech o +Ġcor ros +Ġrepl ication +ĠBl azing +ĠD aughter +Ġinf lic +ĠLind sey +Ù Ī +28 4 +Ex it +Ġgl oom +TA IN +Ġundermin ing +Ġadv ising +h idden +Ġover flow +Ġg or +urd ue +Ġe choes +enh agen +Ġimp uls +d rug +c ash +Ġas ync +Ġmir ac +at ts +p unk +Ġpiv ot +ĠLegisl ative +Ġblog gers +ĠCl aw +s burg +d yl +ĠRecomm end +Ġver te +Ġprohib iting +ĠPant her +Jon athan +Ġo min +Ġhate ful +28 1 +ĠOr che +ĠMurd och +down s +Ġas ymm +G ER +Al ways +Ġinform s +ĠW M +ĠP ony +ĠApp endix +ĠAr lington +J am +Ġmedic inal +ĠS lam +IT IES +Ġre aff +ĠR i +F G +S pring +b ool +Ġthigh s +Ġmark ings +ĠRa qqa +ĠL ak +p oll +ts ky +ĠMort y +ĠDef inition +Ġdeb unk +end ered +ĠLe one +a vers +Ġmortg ages +App arently +N ic +ha us +ĠTh ousands +au ld +Ġm ash +sh oot +Ġdi arr +Ġconscious ly +H ero +e as +ĠN aturally +ĠDestroy er +Ġdash board +serv ices +R og +Ġmillenn ials +Ġinv ade +- ( +Ġcomm issions +ĠA uckland +Ġbroadcast s +Ġfront al +Ġcr ank +ĠHist oric +Ġrum ours +CT V +Ġster il +Ġboost er +rock et +ãĤ ¼ +ut sche +ĠP I +Ġ2 33 +ĠProdu cer +ĠAnaly tics +Ġinval uable +Ġunint ention +ĠC Y +Ġscrut in +Ġg igg +Ġeng ulf +Ġprolet ariat +Ġh acks +ĠH ew +ar ak +ĠSl ime +ield ing +ag her +ĠEll iot +Ġtele com +Ġ2 19 +ult an +ĠAr bor +ĠSc outs +B an +Ġlifes pan +Ġbl asp +38 8 +Ġjud iciary +ĠContin ental +ask ing +Mc C +L ED +Ġbag gage +ĠSorce rer +Ġrem nants +ĠGriff ith +ets u +ĠSub aru +ĠPerson ality +des igned +ush ima +agn ar +Ġrec oil +Ġpass ions +\ ": +Ġte e +Ġabol ition +ĠCreat ing +j ac +Ġ19 4 +01 9 +Ġpill ars +ric hed +/ " +t k +Ġlive lihood +Ġro asted +ah on +ĠH utch +ass ert +Ġdivid end +Ġkn it +Ġd aunting +Ġdisturb ance +Ġsh ale +Ġcultiv ated +Ġrefriger ator +L B +ĠN ET +Ġcommercial s +Ġthink ers +45 5 +Ġch op +B road +Ġsuspic ions +Ġtag ged +l ifting +Ġsty lish +ĠShield s +Short ly +Ġt ails +A uth +ST E +ĠG AME +Ġse ism +ĠK is +olog ne +Ġcow ork +Ġforc ibly +Ġthy roid +ĠP B +AN E +mar ried +h orse +Ġpoly mer +ĠCh al +od or +DE BUG +ĠCon text +Ġbl iss +Ġpin point +ĠMat hemat +leg ram +ĠWeek end +Ġlab elled +Ġb art +it les +Ġest rogen +âĢĶâĢĶâĢĶâĢĶâĢĶâĢĶâĢĶâĢĶ âĢĶâĢĶâĢĶâĢĶâĢĶâĢĶâĢĶâĢĶ +" ' +Ġvis ibly +Ġouts ider +aid a +Are a +Ġdisse min +Ġdish onest +ĠCl osed +ĠBullet in +ĠRam sey +sw ord +ĠX I +our ced +S ame +34 6 +ĠRe pe +ĠK ou +c ake +em is +C ache +ĠMe aning +ĠEn light +onom y +Ġmanifest ation +sw orth +J ay +Ġch ore +ö r +D ream +Ġsanction ed +Ġcult urally +ĠA ra +N av +Ġthe ological +Ġstr ut +ĠV O +ĠHand book +Ġconstruct ing +Ġ ¶ +ĠBenef its +ĠPsych ological +s ac +å ¸ +p olicy +ĠMat ters +ĠReport ed +ĠBy te +Ġvit ro +ĠM aiden +Ġl am +ĠJenn ings +Ġgar ment +ĠRut gers +ĠStaff ord +ĠWell ington +Ġinter mitt +Ġn pm +Ġord eal +Ġplug ged +o oming +in ished +fram ework +Ġtim ber +Ġc ass +Ġ8 50 +il ess +ĠRed ux +7 68 +St re +Ġsurpass ed +w hel +Ġparalle ls +Ġve il +ĠG I +ĠR EST +Ġread iness +s ort +Ġmod ifying +ĠSl ate +ru ff +Ġmar ble +Ġinf rared +Ġaud itor +ĠFANT ASY +ĠP overty +ĠS PD +Ġ" ( +K y +RA Y +Ġexecut ions +ĠBever ly +ĠMarx ism +ĠBur st +ĠK ali +est ones +Clear ly +E ll +ãģ § +ĠProceed ings +T oken +IF IC +ñ a +Cent ral +ĠH aley +ĠD rama +Ġform ations +OR N +Book s +Ġdom inating +ĠFly ers +ĠCompan ion +Ġdiscipl ined +ĠYug oslav +ĠSpell s +Ġv engeance +Ġland lords +L en +ĠO gre +ano ia +Ġpier cing +Ġcon greg +Ġscore r +ob ia +Ġnic kel +ĠLear ns +Ġre jo +Ġmaster piece +Fl ash +Ġinhab ited +ĠOpen GL +ĠD ud +ĠI CO +Ġar ter +Ġpl ur +Ġmaster y +Ġlong standing +st ed +Ġw ines +Ġtelev ised +ĠSh rine +ĠBay ern +Ġâ ĵĺ +Ġencl osure +j ohn +Ġprophe ts +ĠRes urrection +ĠOrd ers +Ġun even +r als +Ġd wind +ĠL ah +ĠSl oven +37 8 +Ġins istence +aff le +ĠCl one +Ġhard ship +ĠCongress man +Ġple ad +Ġreview ers +Ġc ured +Ġ19 35 +as ley +f ake +ĠTh inking +yd ia +P ART +ĠD ota +o it +Ġwh ipped +Ġb ouncing +ĠHispan ics +com ings +Ġcann abin +ĠCh ambers +ĠZ ack +Option al +Ġco ats +Ġprow ess +ĠNort on +Ġplain ly +Ġfre ight +Ġinhib ition +Ġcl am +Ġ30 3 +ke f +ale igh +L uke +Ġpsych o +ator ium +M ED +Ġtreat ies +Ġind isc +Ġd c +OP S +Ġresil ient +ĠInter state +Ġsl ack +Ġmund ane +Ġestab lishes +35 9 +Ġstr ained +Ġn ond +S us +Ġcast e +ar ate +ie ving +Ġunfair ly +Ġpars er +on ial +urs ive +V ia +ĠOtt o +ĠAuthor ities +stro ke +K R +ĠMer cy +Ġfurn ished +Ġout set +Ġmet ic +19 82 +olith ic +ĠT ent +og ical +ĠA ircraft +Ġh ides +ĠBec ame +Ġeduc ators +re aching +Ġvol atility +Ġtodd ler +ĠNAS CAR +ĠTw elve +ĠHigh lights +Ġgra pe +Ġspl its +Ġpe asant +Ġre neg +ĠMS I +Tem p +st ars +Ġtre k +ĠHy de +b inding +Ġreal ism +Ġox ide +ĠH os +Ġmount s +Ġbit ing +Ġcollaps ing +Ġpost al +Ġmuse ums +Ġdet ached +Ġrespect ing +Ġmonop ol +Ġwork flow +ĠC ake +Tem plate +ĠOrgan isation +Ġpers istence +36 9 +C oming +B rad +Ġredund ant +ĠG TA +Ġb ending +Ġrev oked +Ġoff ending +Ġfram ing +Ġprint f +Comm un +mem bers +Out side +Ġconst rued +Ġc oded +F ORE +Ġch ast +Ch at +Ind ian +ĠY ard +? !" +ĠP orts +ĠX avier +ĠR ET +' ." +ĠBo at +iv ated +ich t +umer able +D s +ĠDun n +Ġcoff in +Ġsecure ly +ĠRapt ors +ĠB es +Install ation +Ġin ception +ĠHealth y +end ants +Ġpsych ologists +ĠShe ikh +c ultural +ĠBlack Berry +sh ift +F red +oc he +Ġc akes +ĠS EO +ĠG ian +ĠAs ians +og ging +e lement +Ġpund its +ĠV augh +ĠG avin +Ġh itter +Ġdrown ed +Ġch alk +ĠZ ika +Ġmeas les +80 2 +âĢ¦ .. +ĠAW S +] " +Ġdist ort +ĠM ast +Ġantib odies +ĠM ash +Mem ory +ĠUg anda +ĠPro b +Ġvom iting +ĠTurn s +Ġoccup ying +Ġev asion +ĠTher apy +Ġprom o +Ġelect r +Ġblue print +ĠD re +pr iced +ĠDep ot +Ġallev iate +ĠSom ali +m arg +n ine +Ġnostalg ia +ĠShe pherd +Ġcaval ry +Ġtor ped +ĠBlood y +x b +Ġs ank +Ġgo alt +report print +embed reportprint +clone embedreportprint +ĠIn itially +ĠF ischer +Ġnot eworthy +c ern +Ġin efficient +raw download +rawdownload cloneembedreportprint +c ation +ĠD ynasty +l ag +D ES +Ġdistinct ly +ĠEston ia +Ġopen ness +Ġg ossip +ru ck +W idth +ĠIb rahim +Ġpet roleum +Ġav atar +ĠH ed +ath a +ĠHog warts +Ġc aves +67 8 +Ġsafegu ard +ĠM og +iss on +ĠDur ham +sl aught +ĠGrad uate +Ġsub conscious +ĠEx cellent +ĠD um +---- - +Ġp iles +ĠW ORK +ĠG arn +ĠF ol +ĠAT M +Ġavoid s +ĠT ul +Ġble ak +EL Y +iv ist +light ly +P ers +ĠD ob +ĠL S +Ġins anity +Î µ +atal ie +En large +Ġtw ists +Ġfault y +Ġpir acy +Ġimp over +Ġrug ged +ĠF ashion +Ġs ands +' ? +sw ick +Ġn atives +Ġhe n +ĠNo ise +ãĥ Ĺ +Ġg reens +Ġfree zer +Ġd ynasty +ĠFather s +ĠNew ark +Ġarchae ological +Ġo t +ob ar +Ġblock ade +Ġall erg +L V +Ġdeb it +ĠR FC +ĠMil ton +ĠPress ure +Ġwill ingly +Ġdisproportion ate +Ġopp ressive +Ġdiamond s +Ġbelong ings +19 70 +Ġbell s +Ġimperial ism +Ġ2 27 +Ġexpl oding +ĠE clipse +Ġ19 19 +Ġr ant +Ġnom inations +34 7 +Ġpeace fully +ric a +ĠF UCK +Ġvib ration +mal ink +Ġro pes +ĠIv anka +ĠBrew ery +ĠBook er +ĠOw ens +go ers +Serv ices +ĠSn ape +Ġ19 1 +39 5 +Ġ2 99 +just ice +Ġb ri +Ġdisc s +Ġprom inently +Ġvul gar +Ġsk ipping +l ves +Ġtsun ami +37 4 +ĠU rug +ĠE id +rec ated +p hen +Ġfault s +ĠStart ed +9 50 +Ġp i +Ġdetect or +Ġbast ard +Ġvalid ated +Space Engineers +OUR CE +Ġ( ~ +Ġuns ur +Ġaff irmed +Ġfasc ism +Ġres olving +ĠCh avez +ĠC yn +Ġdet ract +L ost +Ġrig ged +Ġhom age +ĠBrun o +55 5 +ec a +Ġpress es +Ġhum our +Ġsp acing +Ġ' / +olk ien +C oun +OP ER +T re +S on +ĠCambod ia +ier re +m ong +o zy +Ġliquid ity +ĠSov iets +ĠFernand o +Ġ2 29 +Ġsl ug +ĠCatal an +elect ric +Ġsc enery +ĠH earth +Ġconst rained +Ġgoal ie +ĠGu idelines +ĠAm mo +ĠPear son +Ġtax ed +Ġfet us +Resp onse +ĠAlex is +th ia +G uy +Ġrecon struct +Ġextrem es +Ġconclud ing +ĠP eg +ook s +Ġded uctions +R ose +Ġground breaking +ĠT arg +ãĥ ģ +ĠRe ve +res ource +Ġmo ons +Ġelectrom agnetic +Ġamid st +ĠVik tor +N ESS +B ACK +Ġcomm ute +ĠAna heim +Ġfluct uations +6 40 +Ġnood les +ĠCop enhagen +ĠT ide +ĠGri zz +ĠS EE +Ġpip elines +Ġsc ars +end o +ag us +ĠE TF +/ # +ĠBec ome +44 8 +Ġvis c +ĠRecomm ended +Ġj umper +Ġcogn ition +Ġassass in +Ġwitness ing +ĠSet up +Ġl ac +v im +IS M +p ages +SS L +35 8 +Ġad ject +indust rial +l ore +cher y +Ġgl itter +Ġc alf +Flor ida +Ġspoil ers +Ġsucceed s +Ġch anting +Ġslog ans +ĠTr acy +Vis it +rol ogy +Ġm ornings +Ġline age +Ġs ip +Ġintense ly +Ġflour ish +ĠSle eping +ĠF em +or por +ĠK lan +ĠDar th +h ack +ĠNi elsen +Ġtum ors +Ġprocure ment +ĠY orkshire +Ġra ided +K Y +An na +Ġ// [ +ĠDis order +ĠMust ang +ĠW en +ĠTry ing +s q +Ġdeliver ies +Ġshut ter +Ġcere bral +Ġbip olar +ĠC N +l ass +j et +Ġdeb ating +> : +Ġe agle +gr ades +ĠD ixon +UG C +M AS +ĠDr aco +ĠMach ines +aff er +Ġem an + ² +pr on +ĠG ym +Ġcompar atively +ĠTrib unal +PR O +Ġle x +Ġfert ile +Ġdep ressing +Ġsuperf icial +ess ential +ĠHun ters +g p +Ġprom inence +L iber +ĠAn cest +ote chnology +Ġm ocking +ĠTra ff +ĸ ļ +Med ium +I raq +Ġpsychiat rist +Quant ity +ĠL ect +Ġno isy +5 20 +G Y +Ġsl apped +ĠM TV +Ġpar a +p ull +Mult iple +as her +Ġn our +ĠSe g +Spe ll +v ous +ord ial +Sen ior +ĠGold berg +ĠPl asma +ne ed +Ġmess enger +ere t +Ġteam ed +Ġliter acy +ĠLe ah +ĠD oyle +Ġem itted +U X +Ġev ade +Ġm aze +Ġwrong ly +ĠL ars +Ġstere otype +Ġpled ges +Ġarom a +ĠM ET +Ġac re +ĠO D +Ġf f +Ġbrew eries +ĠH ilton +und le +ĠK ak +ĠThank fully +ĠCan ucks +in ctions +ĠApp ears +Ġco er +Ġundermin ed +ro vers +And re +Ġbl aze +um ers +Ġfam ine +amp hetamine +ulk an +Am ount +Ġdesper ation +wik ipedia +develop ment +ĠCor inth +uss ia +Jack son +L I +N ative +R s +Oh io +ĠKath leen +F ortunately +Ġattend ant +ĠPre ferred +ĠDid n +ĠV s +M is +Ġrespond ent +Ġb oun +st able +Ġp aved +Ġunex pl +ĠChe ney +L M +ĠC ull +bl own +Ġconfront ing +oc ese +serv ing +W i +ĠLith uania +ann i +Ġst alk +h d +Ġv ener +AP H +ynchron ous +UR R +um ably +hist oric +H alf +H ay +Ġresil ience +spe ction +Ġabandon ing +O bs +ĠDeb bie +Ġgrad ient +ĠPl aint +ĠCan al +AR CH +Ġexpans ive +Ġfun g +Ġb ounced +U nd +Ġprec autions +Ġclar ification +Ġd agger +Ġgri ps +Ġ µ +ĠRiver a +ĠUnd ead +is ites +ĠFIR ST +ñ o +aud i +Ġhost ages +Ġcompl iant +Ġal umni +Se ven +Ġcyber security +e ither +Col lect +Ġinvari ably +ĠS oci +Ġlaw maker +Ġa le +ĠPerson ally +N azi +Ġcustom ization +ĠPro c +ĠSask atchewan +eat uring +Ġsp ared +Ġdiscontin ued +Ġcomput ational +ĠMotor ola +Ġsuprem acist +government al +Ġparad ise +ĠDown ing +ĠNik on +Ġcat alyst +ber ra +Tor onto +8 75 +bet a +ĠMac ron +Ġunreal istic +ve ctor +ĠVeh icles +it iveness +ĠR V +ĠCol bert +s in +o ji +ent in +ĠKr ish +hell o +ff ield +ok y +ĠT ate +Ġmap le +Ġa ids +chem ical +33 4 +n uts +ĠWar p +Ġx x +ĠRob b +umer ous +_- _ +ft ime +ĠV W +Ġw inger +ĠD ome +t ools +ĠP V +ĠGe orgetown +Ġg eared +Ġjihad ists +Ġc p +Ġster oids +M other +cler osis +ĠDR M +nes ia +Ġl inger +Ġimm ersive +ĠC OUN +Ġoutwe igh +ens ual +B and +Ġtransform s +mat ched +ps ons +ĠJud icial +f actor +Ġrefer ral +Ġodd ly +ĠW enger +B ring +ĠB ows +60 2 +IC LE +Ġl ions +ĠAcad emic +ĠTh orn +ĠRa ider +kef eller +St orage +L ower +ĠOr t +ĠEqu ality +AL T +ĠS OC +T ypes +Ġl yn +ĠAss et +co at +TP P +C VE +ĠPione er +app lication +Mod ern +ĠH K +En vironment +Al right +R ain +IP P +ĠShi ite +Ġm ound +ĠAb ilities +cond ition +St aff +Ġcompet ence +ĠM oor +ĠDi ablo +Ġwith held +Ġost ensibly +ĠB rom +Ġms g +Ġden omin +ĠRef erences +ĠF P +Ġplun ged +Ġp amph +m oving +cent ral +Ġdown right +Ġf ading +T al +T yp +ĠTh y +uk es +it he +Ġo ve +Ġbatt led +Ġseaf ood +Ġfig ur +ĠR D +c rop +Ġsqu ads +{ \ +à ¹ +ĠE h +Ġinterview ing +ĠQ in +Ġas piring +PL IC +Ġcla uses +ĠG ast +ĠN ir +Ġl uggage +Ġh ose +Ġsystem d +Ġdesc ending +ĠRev ised +ĠR ails +al ign +70 9 +33 7 +Ġf ug +charg ing +t ags +Ġut er +k ish +WAR NING +49 0 +prof its +Ġvoy age +Ġa ce +ĠV anguard +ĠT anks +ĠM uk +Ġ2 26 +S afe +Ar mor +Ġvolcan ic +Ġwom b +ĠM IL +Ġbegin ner +ĠRec ogn +ĠA AP +PL AY +) ! +Ġdetect ing +c n +Ġbre aches +Bas ically +ĠP ag +ĠMunicip al +ĠInd ie +ĠL af +ĠDis able +ĠOl son +Ġrest rained +Ġrul ings +Ġhum ane +ev ents +ĠCinem a +display Text +ĠH atch +action Date +onna issance +Ġassault ing +ĠL ug +CH AT +Ġvig orous +ĠPer se +Ġintoler ance +ĠSnap chat +ĠSh arks +Ġd ummy +ĠDi agn +ĠGu itar +im eters +40 3 +RE G +A x +Ġsepar ates +ĠMah m +Ġt v +j ah +O OL +C irc +ĠWinds or +uss ian +Ġintu ition +Ġdis dain +ĠDon ovan +Ġ2 21 +E mb +Ġcondem ning +Ġgener osity +zz y +Ġpant ies +ĠPre vent +Action Code +AN A +34 2 +external ActionCode +Ġspec ifying +Ġcryst all +J ere +Ġru pt +ĠApp rentice +Ġprof iling +Ð º +St rike +Ġsid eline +Ġoblig ated +Ġocc ult +Ġbureaucr atic +ant ically +rupt ed +neg ative +ĠEthiop ia +ĠC ivic +Ġins iders +el igible +ĠTV s +ĠB AR +ĠT I +i ologist +ĠA IR +Ġsubstit uted +Ar ab +ĠS aul +ĠY og +p rem +Ġbuild ers +Ġstation ary +Ġdoubt ful +Ġvig orously +Ġthr illing +Ph ysical +ĠCare y +ĠHyd ra +geon ing +ĠS ly +y ton +Ġborrow ers +ĠPark inson +Ġ ë +ĠJama ica +Ġsat ir +Ġinsurg ents +ĠF irm +Ġis ot +ĠK arn +our ning +ak ens +doc s +l ittle +ĠMon aco +CL ASS +Tur key +L y +ĠCon an +ass ic +Ġstar red +ĠPac ers +et ies +Ġt ipping +M oon +ĠR w +s ame +Ġcav ity +Ġgo of +ĠZ o +Sh ock +um mer +Ġemphas izes +Ġreg rett +Ġnovel ty +Ġen vy +ĠPass ive +r w +50 5 +Ġind ifferent +ĠR ica +ĠHim self +ĠFred die +Ġad ip +ä¸ Ģ +Ġbreak out +Ġhur ried +ĠHu ang +ĠD isk +Ġro aming +?????- ?????- +U V +ĠRick y +ĠS igma +Ġmarginal ized +Ġed its +Ġ30 4 +mem ory +Ġspec imen +29 3 +ãģ ¯ +Ġvert ically +Ġaud ition +ĠHe ck +Ġc aster +ĠHold ings +ad al +ĠC ron +ĠL iam +Ġdef lect +P ick +ĠDeb ug +RE F +Ġvers atility +ot hes +class ified +ĠMah ar +ĠH ort +C ounter +st asy +not iced +33 1 +ĠSh im +f uck +ĠB ie +Ġair ing +ĠPro tein +ĠHold ing +Ġspect ators +ili ated +ĠThat cher +n osis +ãĥ¼ ãĥ³ +Te le +B oston +ĠTem pl +st ay +Ġdecl arations +47 9 +Vol ume +ĠDesign er +ĠOver watch +id ae +Ġon wards +Ġn ets +ĠMan ila +part icularly +Ġpolit ic +o other +Ġport raits +Ġpave ment +c ffff +Ġs aints +Ġbegin ners +ES PN +Ġshort comings +âķIJ âķIJ +Ġcom et +ĠOrgan ic +qu el +Ġhospital ized +Bre ak +Ġpe el +dyl ib +asp x +ur ances +ĠT IM +P g +Ġread able +ĠMal ik +Ġm uzzle +Ġbench marks +d al +ĠV acc +ĠH icks +60 9 +ĠB iblical +he ng +Ġover load +ĠCivil ization +Ġimm oral +Ġf ries +ãĤ Ĵ +Ġreprodu ced +Ġform ulation +j ug +ire z +g ear +Ġco ached +Mp Server +ĠS J +ĠK w +In it +d eal +ĠO ro +ĠL oki +ĠSong s +Ġ23 2 +ĠLou ise +asion ally +Ġunc ond +olly wood +Ġprogress ives +ĠEn ough +ĠDo e +Ġwreck age +Ġbr ushed +ĠBase Type +Ġz oning +ish able +het ically +ĠC aucus +ĠH ue +Ġk arma +ĠSport ing +Ġtrad er +Ġseem ing +ĠCapt ure +4 30 +b ish +Ġt unes +Ġindo ors +ĠSp here +ĠD ancing +TER N +Ġno b +ĠG ST +m aps +Ġpe ppers +F it +Ġoverse es +ĠRabb i +ĠR uler +vert ising +off ice +xx x +Ġra ft +Ch anged +Ġtext books +L inks +ĠO mn +ãĢ ij +Ġinconven ience +ĠDon etsk += ~ +Ġimplicit ly +Ġboost s +ĠB ones +ĠBo om +Cour tesy +Ġsens ational +AN Y +Ġgre edy +ed en +Ġinex per +ĠL er +ĠV ale +Ġtight en +ĠE AR +ĠN um +Ġancest or +S ent +ĠH orde +urg ical +all ah +Ġsa p +amb a +ĠSp read +tw itch +Ġgrand son +Ġfract ure +Ġmoder ator +ĠSe venth +ĠRe verse +Ġestim ation +Cho ose +Ġpar ach +Ġbar ric +ãĢ IJ +Ġcomp ass +Ġall ergic +âĢ ķ +OT HER +err illa +Ġw agon +Ġz inc +Ġrub bed +ĠFull er +ĠLuxem bourg +ĠHoo ver +Ġli ar +ĠEven ing +ĠCob b +est eem +Ġselect or +ĠB rawl +is ance +ĠE k +Ġtro op +Ġg uts +ĠApp eal +ĠTibet an +Ġrout ines +ĠM ent +Ġsummar ized +steam apps +Ġtr anqu +Ġ19 29 +or an +ĠAut hent +Ġg maxwell +Ġappre hens +Ġpo ems +Ġsa usage +ĠWeb ster +ur us +Ġthem ed +Ġl ounge +Ġcharg er +Sp oiler +Ġsp illed +h og +ĠSu nder +ĠA in +ĠAng ry +Ġdis qual +ĠFrequ ency +ĠEther net +Ġhel per +Per cent +Ġhorr ifying +Ġa il +ĠAll an +EE E +ĠCross ing +44 9 +Ġh olog +ĠPuzz les +ĠGo es +eren n +60 4 +ãģ ı +ĠRaf ael +Ġatt en +ĠE manuel +Ġup ro +ĠSus p +P sych +ĠTr ainer +ĠN ES +ĠHun ts +bec ue +Ġcounsel or +R ule +Ġtox ins +Ġb anners +r ifice +Ġgreet ing +Ġfren zy +Ġall ocate +Ġ* ) +ex pr +50 3 +ĠCh ick +ĠT orn +Ġconsolid ation +ĠF letcher +sw itch +fr ac +cl ips +ĠMcK in +ĠLun ar +Mon th +IT CH +Ġscholar ly +rap ed +39 8 +Ġ19 10 +Ġe greg +Ġin secure +Ġvict orious +cffff cc +Ġsing led +Ġel ves +ĠW ond +bur st +Ġcam oufl +ĠBL ACK +Ġcondition ed +ç ī +ans wered +Ġcompuls ory +asc ist +Ġpodcast s +ĠFrank furt +bn b +Ġne oliberal +ĠKey board +ĠBel le +w arm +Ġtrust s +Ġins ured +ĠBu cc +us able +60 7 +ĠPl ains +Ġ18 90 +Ġsabot age +Ġlod ged +f elt +Ġg a +ĠN arc +ĠSal em +Ġsevent y +ĠBl ank +p ocket +Ġwhis per +Ġm ating +om ics +ĠSal man +ĠK ad +Ġan gered +Ġcoll isions +Ġextraord inarily +Ġcoerc ion +G host +b irds +è Ģ +k ok +Ġper missible +avor able +Ġpo inters +Ġdiss ip +ac i +Ġtheat rical +ĠCos mic +Ġforget ting +Ġfinal ized +å¤ § +y out +l ibrary +Ġbo oming +ĠBel ieve +ĠTe acher +ĠL iv +ĠGOOD MAN +ĠDomin ican +OR ED +ĠPart ies +Ġprecip itation +ĠSl ot +R oy +ĠComb ined +Ġinteg rating +Ġch rome +Ġintest inal +ĠRe bell +Ġmatch ups +Ġblock buster +ĠLore n +ĠLe vy +Ġpre aching +ĠS ending +ĠPur pose +ra x +f if +Ġauthor itative +ĠP ET +ast ical +Ġdish on +Ġchat ting +Ġ"$ :/ +Connect ion +Ġrecre ate +Ġdel inqu +Ġbro th +ĠD irty +ĠAd min +z man +Ġscholars hips +Ġ25 3 +cont act +als a +7 67 +c reen +abb age +Ġ19 15 +Ġbl ended +Ġal armed +L anguage +35 6 +Ġbl ends +ĠCh anged +W olf +Ġhe pat +Creat ing +Ġper secut +Ġsweet ness +art e +Ġforfe iture +ĠRober to +im pro +N FL +ĠMag net +Det ailed +Ġinsign ificant +ĠPOL IT +ĠBB Q +ĠC PS +Ġse aw +amin er +m L +end if +f inals +Ġ26 5 +u ish +Ġ} ) +ĠPro blems +Ġem blem +Ġserious ness +Ġpars ing +Ġsubst itution +Ġpress ured +Ġrecy cled +ale b +Rub y +Ġprof iciency +Dri ver +ĠW ester +: ' +AF TA +Ġm antle +ĠClay ton +fl ag +Ġpractition er +c overed +ĠSt ruct +add afi +4 25 +ĠTown ship +ĠHyd ro +Lou is +34 3 +Ġcond o +ĠT ao +Ġutil ization +Ġnause a +ĠDem s +rid ges +p ause +Ġform ulas +Ġchall enger +37 6 +Ġdefect ive +ĠRail way +ĠPub Med +Ġyog urt +l bs +ĠNor folk +OP E +ĠMood y +Ġdistribut or +Ġscroll s +Ġextract s +St an +Ġv iability +Ġexp oses +Ġstar vation +ĠStep s +ĠD odd +f ew +ST D +33 2 +Ġclos ures +Ġcomplement ary +ĠS asha +ump y +Ġmon et +Ġartic ulate +ĠDo ct +k iller +Ġsc rim +Ġ2 64 +Ġprost itutes +Ġse vered +Ġattach ments +Ġcool ed +L ev +ĠF alk +f ail +Ġpolic eman +ĠD ag +Ġpray ed +ĠK ernel +Ġcl ut +Ġc ath +Ġan omaly +St orm +em aker +ĠBreak fast +ul i +o ire +J J +h z +Oper ation +ĠS ick +35 4 +ĠGuatem ala +R ate +Ġexp osures +f aces +ĠArch ae +ra f +ĠM ia +Ġ20 25 +Ġop aque +Ġdisgu ised +ĠHead quarters +S ah +Ġp ots +9 78 +ĠM alf +Ġfrown ed +Ġpoison ous +ĠCon vers +ee ks +Ġcr ab +." " +Ġtre ason +Ġr anc +Ġescal ating +Ġwar r +Ġmob s +Ġl amps +ĠSun shine +ĠBrun swick +Ph ones +Ġspe lled +ĠSk ip +Ġ20 50 +Ġ19 11 +ĠPl uto +ĠAm end +Ġme ats +38 7 +Ġst omp +ĠZh ou +ĠLevi athan +ĠHaz ard +ad v +ĠOr well +Ġal oud +Ġb umper +ĠAn arch +ub untu +ĠSer ious +f itting +ĠOption al +ĠCec il +RE AM +Ġser otonin +Ġcultiv ate +ag ogue +} \ +Ġmos ques +ĠSun ny +Ġre active +rev olution +ĠL up +ĠFed ora +Ġdefense man +ĠV ID +ist ine +Ġdrown ing +ĠBroad casting +Ġthr iller +ĠS cy +Ġacceler ating +Ġdirect s +od ied +b ike +d uration +Ġpain fully +R edd +Ġproduct ions +Ġg ag +Ġwh ist +Ġs ock +Ġinf initely +ĠConc ern +ĠCit adel +Ġlie u +Ġcand les +ogene ous +arg er +Ġheaven ly +inflamm atory +Per formance +C s +ruct ose +az aki +Ġp essim +Ġinf erence +Ġpow d +ĠZ oe +Ġpain ts +Ġd azz +pt a +-------- --- +Ġins pir +ĠExper imental +ĠKn ife +reg or +b ors +Ġshow ers +rom eda +Ġs aint +Ġben ign +ĠJ iang +Ġenvision ed +Ġsh roud +IF T +H O +Ġsh uff +ĠI CC +Ġse greg +Ġrevis it +ighth ouse +L i +Ġsub strate +ĠSe as +ĠRew ard +ĠH ep +ĠBr ass +s bm +Ġelim inates +Ġst amina +ĠV AT +ĠLo an +Ġconst raint +Ġappropri ated +Ġp es +ĠA LE +r anging +Ġ40 4 +39 2 +Ġintellectual s +ach u +Ġrestruct uring +ĠLe vin +Ġrun es +Ġdelight ful +Ġcarbohyd rates +ĠMod els +ĠExp o +Ġtransport ing +all oc +Ġring ing +S amsung +Ġscarce ly +ĠURL s +ĠM AS +Ġprot otypes +Ġnarr ator +ĠCPU s +cd n +ĠBart on +Ġdecided ly +ĠSh u +ix ir +oc ious +ĠMy st +N intendo +Ġre use +Ġforg iven +F ew +in ical +n at +Ġseam less +ĠEv a +ĠE VE +ĠJ O +land ers +Ġso fter +neg ie +Ġtrans ient +Ġorb ital +Ġfulf il +ĠK om +Hop efully +Ġdynam ically +ĠHun ger +å Ľ +ĠArmen ia +el man +ber to +Ġp ige +ĠID s +lim it +Ġve ins +Ġso aring +p acks +Gold en +ĠCr ab +ist or +ĠR PM +Ġ$ $ +g ression +Ġjihad ist +Ġgam ble +Ġcare g +Ġinf lated +F ace +ĠFire arms +ĠEm manuel +â Ŀ +Ġsh ocks +gr ab +Ġspl end +ĠHP V +ab ortion +Ab ove +Ent ity +play ers +Ġcomm enced +ul ence +Ġfulfill ment +Ġembod iments +ĠW elfare +Ġha il +Ġ< @ +tt en +Ġcat cher +ĠJ azeera +Ġvolcan o +Ġstabil ize +ĠHand ler +Ġintens ified +ĠAb rams +Ġhum iliation +p aced +60 5 +ĠCent OS +Spe cific +Ġhe ed +ĠC AM +ĠGal ile +D ie +Ġabol ished +ĠThom son +ĠTe achers +ĠW ass +j ong +ĠIS BN +ĠAll ies +sh ake +å · +v ict +How ard +Ġde em +Ġexceed ingly +ĠSmart stocks +ib e +Ġdoor way +Ġcompet ed +ig mat +Ġnational ists +Ġg room +ĠKe en +Ġdispos able +de cl +ĠT olkien +ĠSche me +Ġb iod +Ġav id +ĠEl on +ag ar +ĠT SA +R oman +Ġartific ially +Ġadvis ors +X L +ĠInf erno +36 6 +Ġted ious +ĠPhot ography +ĠCar rie +Ġtro pe +ĠSand ra +Ġdec imal +Que en +ĠGund am +ĠO M +ote ch +N BA +Ġ19 32 +Ġent renched +ĠMar ion +Ġfr aternity +Lab our +Hen ry +Ġlat itude +E ither +Ġenh ances +ĠPot ential +Ġsh ines +id ad +Ġbread th +Ġcapac ities +ĠðŁ ĻĤ +ĠBron x +Ġsex es +Ġdifferent iation +Ġheavy weight +ĠT aj +d ra +Ġmigr ate +Ġexhaust ion +ĠR UN +els ius +ĠCu omo +Ġgu itars +Ġcl ones +ĠSom ew +ĠP ry +------------ - +Ġwarr anted +cy cles +Ġsalv age +Ġdis ks +R ANT +ĠNGO s +ĠMart ian +":[ {" +Ġadd icts +oj ure +il let +Ġamazing ly +art ments +p ixel +ĠGPU s +Lay out +è £ +ĠTam il +ĠBas il +Ġimpart ial +ĠSt ructure +f ork +b ryce +Ġr idge +ĠHamb urg +ri ous +Ġbl itz +cig arettes +Ġcan ned +40 2 +Ġiron ically +Ġcompassion ate +ĠHaw kins +. # +ĠCat hedral +Ġrall ied +in ternal +Ġqu ota +st akes +T EXT +m om +Ġcomple tes +Ġ23 8 +Ġsh rug +ãĥ ij +ĠN inth +Ġrev ise +ĠProv ider +Ġtre acher +Ġqu asi +ĠPR ES +Ġdep osition +Ġconfidential ity +iss ors +Ġim balance +Ġspan ning +Ġang ular +ĠC ul +commun ication +ĠNor a +ĠGen ius +op ter +Ġs acked +Sp ot +Ġfine ly +ĠCH R +28 2 +w aves +Pal est +ĠRo hing +N L +è ¿ +Ġsh itty +ĠSc alia +4 75 +Pro gress +Ġreferen cing +Ġclass rooms +ab ee +Ġs od +hes ion +70 8 +ĠZucker berg +ĠFin ish +ĠScot ia +ĠSav ior +ĠInstall ation +an tha +( - +Ġ30 2 +ĠP unk +Ġcr ater +yout u +Ġro ast +Ġinflu encing +Ġd up +ĠJ R +ĠG rav +Ġstat ure +Ġbath rooms +A side +W iki +me an +ĠZ ak +ĠOn es +ĠN ath +Ġhyper t +Ġcommence ment +C ivil +Ġmoder ately +Ġdistribut ors +Ġbreast feeding +Ġ9 80 +ĠS ik +ĠC ig +ĠAM ER +R IP +ĠCare er +ust ing +Ġmess ed +Ġe h +ĠJ ensen +/ $ +Ġblack mail +Ġconvers ions +Ġscientific ally +Ġmant ra +p aying +Ġiv ory +ĠCour ts +OU GH +aunt let +Ser ial +B row +ĠH undreds +3 23 +Ġpe e +Ġlin ux +Ġsub mer +ĠPrinc ipal +48 5 +ĠD SL +ĠCous ins +Ġdoctr ines +ĠAthlet ics +Ġ3 15 +ĠK arma +Ġatt ent +ur ger +Ġpresc ribe +Ġenc aps +ĠC ame +Ġsecret ive +ĠCr imes +d n +C lean +ĠEgypt ians +ĠCar penter +Ġ ll +H um +ĠMil o +Ġcapital ists +Ġbrief ed +T we +ĠBas in +elve t +M os +Ġplun ge +ĠKa iser +ĠFu j +ill in +Ġsafegu ards +Ġo ste +ĠOpportun ity +ĠM afia +ĠCall ing +ap a +ur ban +br ush +ill ard +c é +int elligence +ĠL ob +ĠDru id +Ġsm oother +Ġfoot ing +Ġmotor ists +arc ity +Ġmascul inity +Ġm ism +Ġabdom inal +ĠTa vern +ĠR oh +Ġesc apes +s igned +Anth ony +Ġsacrific ing +Ġintim acy +Ġan terior +ĠK od +Ġmot if +Ġg raz +Ġvisual ization +Ġguitar ist +ĠTro tsky +m agic +D ar +ĠMor i +Ġw ards +Ġtoile ts +l est +Ġtele port +ĠSund ays +ĠPl at +ET S +Ġe Sports +Pat rick +ĠK atherine +en ko +Ġhas sle +ĠM ick +gg les +Ġh ob +aint ain +Ġair borne +Ġsp ans +Ġch ili +Ġa perture +Ġvolunte ered +ĠInc ident +ĠF res +ĠVeter an +augh tered +ing o +Ġun insured +CL OSE +Ġf use +Ġer otic +Ġadvert ise +ra ising +Text ure +Ġatt ends +ĠRE AL +udd led +Ġsm oot +Ġ30 5 +ĠWill is +Ġbl ond +An alysis +ĠV T +on ica +Ġstrongh old +R F +N M +. >> +Ġprosper ous +Ġbo asted +29 2 +ĠManufact uring +PR ESS +g ren +Ġpharm acy +ĠRoc kefeller +k ai +Ġth umbs +ĠH ut +Ġmother board +Ġguard ians +ĠAl ter +ll ular +Ġsh ack +Ġwise ly +Ġback bone +erv a +Ġsu icides +ĠMcG regor +ij ah +E mer +ĠB rav +Ġdesign ate +P OST +produ ced +Ġcleans ing +irl wind +ex istent +ĠHum ph +ĠPay ne +Ġv ested +Å ¡ +Ġstring ent +ion a +Ġuns ub +Ġsum med +ĠHer cules +sub ject +ĠR agnar +ĠN os +Ġcharacter ization +Ġsav vy +ĠDaw son +ĠCas ino +Ġf ri +ĠBar rier +Ġmis information +Ġins ulation +Ġcorrid ors +Ġair planes +ĠNo ct +ah i +Ġ19 16 +k b +arm ac +Ġsh un +Ġsche ma +Ġhorr ified +Ġ23 9 +aund ers +N B +i ates +er ity +ĠSh ard +Ġr arity +Ġgroup ed +ĠGh ana +again st +ĠBi ological +ĠA ware +ow ell +Ï Ħ +ĠBe au +sh aw +H ack +ĠJul ius +US S +ol son +aun a +c ru +ĠMaur ice +ĠI k +Ġsequ encing +Ġradical s +Ġ( ?, +v irtual +Ġany ways +Ġreper c +Ġhand lers +Ġhes itant +é ĥ +ĠM F +ple mentation +ass ociated +Ġcampaign ed +ĠY ue +ut ations +ĠY oga +Ġsim mer +Ġro ds +Ġmel ody +Ġconv oy +v ideos +Ġscreen ed +N eg +ochem ical +Ġ( )) +Ġultr as +Ġant ip +ĠIsland ers +70 4 +Ġfet ish +Ġridic ulously +ĠK art +Ġmitochond rial +Ġinterf ering +Build er +Ġover fl +Ġac ne +ĠM ud +ĠK err +f lex +ĠPost al +ĠBalt ic +47 7 +ĠPers ons +our age +H B +ĠM use +ĠImm ortal +ĠDri ving +Ġpet itions +Ġsubsc ript +Ġs orce +ĠProcess or +ut on +S ony +Ġph on +Ġr aced +ĠAnth rop +Ġday time +ĠEx ercise +Add ing +Ġeng ages +ĠQual comm +Ġmir acles +Ġmem es +ĠDr ink +ĠOri oles +Ġhair s +ĠPol ar +ath om +Ġsl ippery +ĠR emy +Ġcar amel +ĠY EAR +Ġal k +I gn +a ution +ĠMer lin +ĠC ran +Ġap ologies +Ġ4 10 +Ġout ing +ĠMem ories +app ointed +Ġcount ered +u ld +pos ing +Ġfire wall +ĠW ast +ĠW et +work ed +se ller +Ġrepe aled +ere o +ass uming +BL IC +m ite +ĠCEO s +ĠChap el +ellig ent +________________ ________ +D og +Ġw art +Ġsubsc riber +s ports +Ġbe gged +ĠM V +Ġsem if +eth ical +Ġpre ach +Ġrev ital +Ġpun itive +Ġshort cuts +Ġinstit uted +ĠWars aw +Ġabdom en +ĠK ING +Ġsuper intendent +Ġf ry +ĠGe o +T OR +Ġcontrad ictions +apt ic +Ġlandsc apes +b ugs +Ġcl ust +Ġvol ley +c ribed +Ġt andem +Ġrob es +WH AT +Ġpromot er +Ġel oqu +review ed +ĠD K +ĠPl ato +Ġf ps +T ank +ĠDer rick +Ġpriorit ize +as per +ĠHond uras +ĠCom pleted +ne c +Ġm og +n ir +ĠMay o +DE F +st all +in ness +ĠVolks wagen +Ġprec aution +ĠM ell +i ak +ist ries +Ġ24 8 +Ġoverl apping +Sen ate +ĠEnh ance +res y +rac ial +OR TS +ĠM ormons +Str ong +ĠCo ch +Mex ico +ĠMad uro +Ġj ars +Ġcan e +W ik +oll a +iff erence +Ġphysic ist +ĠMag gie +Ġ28 5 +Ġdep iction +ĠMcL aren +J u +Ġsl ows +Ġcommission ers +ĠWill ow +ĠExpl os +hov ah +Ġtechn ician +Ġhom icides +ĠFl av +ĠTr uman +Ġ100 00 +u ctor +Ġsh ader +News letter +45 7 +Ġre ver +Ġhard ened +Ġwhere abouts +Ġrede velop +Ġcar bs +Ġtra vers +Ġsqu irrel +Ġfoll ower +Ġs ings +50 8 +Ġrabb its +emon ium +Ġdocument ing +Ġmisunder stood +) ' +R ick +gg ies +Ġprem ie +Ġsk ating +Ġpass ports +Ġf ists +aged don +H aw +AC P +0 80 +ĠThough ts +ĠCarl son +Ġpriest hood +h ua +Ġdun geons +ĠLo ans +Ġant is +Ġfamiliar ity +ĠS abb +op al +ĠIn k +st rike +Ġc ram +Ġlegal ized +Ġcu isine +Ġfib re +Tra vel +ĠMon ument +OD Y +eth y +Ġinter state +ĠP UR +em porary +ĠArab ian +develop ed +Ġsadd le +Ġg ithub +ĠOff er +ĠIS P +ro let +ĠSUP ER +ĠDen is +Ġmultipl ier +Ġstir red +Interest ingly +Ġcustom ary +Ġbill ed +he x +Ġmultipl ied +Ġfl ipping +ĠCros by +Ġfundament als +ia e +ĠPlay ed +ĠAt om +am azon +ĠFl am +ee z +activ ated +Ġtables poon +Ġliberal ism +ĠPal in +ĠP atel +N um +ĠT AM +Ġs urn +ĠRel oaded +Ġco ined +" ], +ĠCl ash +ĠAg u +Ġprag matic +ĠActiv ate +Ġ8 02 +Ġtrail ers +Ġsil hou +Ġprob es +Ġcirc us +ĠB ain +ĠLind say +ĠAb bey +Del ivery +Ġconcess ion +Ġgast ro +ĠSpr ite +Ä Ł +and el +Ġg imm +Ġaut obi +ĠT urtle +Ġwonder fully +ĠHar am +ĠWorld wide +ĠHand le +Ġtheor ists +Ġsle ek +ĠZh u +ograph ically +EG A +ĠOwn ers +ath s +ĠAntar ctic +n atal +=" " +fl ags +`` `` +Ġs ul +K h +Ġpot assium +Ġlinem an +Ġcere al +ĠSe asons +Ġ20 22 +Ġmat hematic +Ġastron omers +prof essional +Ġf ares +cknow led +Ġch i +Ġyoung sters +Ġmistaken ly +Ġhem isphere +ĠDiv inity +r one +Ġ" , +r ings +Ġattract s +v ana +å ¹ +C AP +Ġplay list +Ġpor ch +ãģ £ +Ġincorpor ates +Ġso ak +Ġassert ing +ĠTerror ism +ĠP ablo +J a +ces ter +Ġfear ing +ĠPr ayer +Ġescal ated +G W +Ġro be +ĠBright on +ac ists +ĠSym phony +ĠDwar f +ĠPar ade +ĠLe go +Ġinex pl +Ġl ords +le af +RA G +l iber +Ġcig ars +ĠJe hovah +60 6 +WIND OWS +ĠLiber ia +eb us +He avy +Ġl ubric +ĠR W +angu ages +Ġnarrow ed +com puter +ĠE mber +Ġmurder ing +Ġdown stream +ĠT uls +ĠT ables +Top ic +ĠAcc uracy += / +l ost +ĠRe i +Ġprogress es +b ear +Ġestablish ments +Just in +ĠPe ach +ĠG omez +å ¿ +ĠTri angle +Id ent +ĠH ive +Res ources +Ġmix es +ĠAss uming +M u +Ġhyp oc +Ġs ane +ĠW an +id ious +Su ccess +Ġ io +Ang el +Ġdanger ously +ĠCreat ure +W ORK +: [ +ĠKat rina +List ener +M iller +ĠId lib +h ang +Ġcircum vent +h ref +Ġcel estial +ĠWe eks +ĠP ug +ĠDal ton +Ġsubpoen a +uk u +Ġpers isted +pe i +old ing +ĠDoc uments +ĠH ast +ĠC ENT +Ġprim er +Ġsyn onymous +Ġn ib +om bs +Ġnot ation +ĠD ish +ĠAt mosp +Ġforb id +ĠAN G +pat tern +l os +Ġproject iles +b rown +." , +ĠVen om +Ġfierce ly +ub lished +ĠU ran +ĠNic arag +4 10 +ĠC AL +OT OS +ĠMir acle +ĠEn chant +Ġguard ing +app end +Att ach +Ġlevel ed +Ġcond oms +ih ilation +64 9 +Ġnight mares +ĠTHE Y +ĠST ART +ĠK inn +Ġroomm ate +Ġhy giene +o pping +J ob +Ġl vl +ĠV ER +ĠKe eping +ab etic +Ġformat ting +eral a +Ġrev isions +Ġres urg +T el +ĠGood man +35 3 +p od +Ġind isp +ĠTrans lation +Ġg own +ĠM und +Ġc is +Ġby stand +col lect +ĠPun jab +act ively +ĠG amb +te ll +Ġimport ing +g encies +Ġloc om +ĠBr ill +H oly +ĠBer ger +Ġshow down +Ġrespond ers +IL Y +Ġt akedown +le ted +Ġmat tered +Ġpredict ive +Ġover lay +G PU +ĠV ick +Ġconvey ed +T ab +pe er +Sc an +Ġdefensive ly +v ae +Ġappro ving +Ġt iers +ĠV ia +quer ade +ĠSaud is +Ġdemol ished +ĠProp he +Ġmon o +Ġhospital ity +H AM +ĠAri el +M OD +ĠTor ah +Ġbl ah +ĠBel arus +erent ial +ĠT uc +Ġbank er +39 7 +Ġmosqu it +ĠScient ist +ĠMus ical +Ġh ust +Sh ift +Ġtor ment +Ġstand off +E duc +ĠF og +Ġampl ifier +Sh ape +Inst ance +ĠCrit ics +Ġda emon +H ouston +Ġmatt ress +ĠID F +Ġobsc ene +ĠA mer +hett i +Ġcomp iling +35 2 +vere tt +ĠRed uction +ist ration +ĠBl essed +ĠB achelor +3 16 +Ġpr ank +ĠVul can +dd ing +Ġm ourning +ĠQu int +ĠBl aster +test ing +Ġsed iment +>> > +ĠE ternity +ĠWH ERE +ĠM aze +Ġreact ing +ĠAl v +oms day +ĠC RA +Ġtransl ator +Ġbog us +at u +We bsite +oll s +Ġbapt ism +Ġs ibling +ĠAut umn +ve z +ãģ® é +gu ards +Ge org +assad ors +ĠFre ud +Ġcontin ents +ĠReg istry +Bern ie +ĸļ 士 +Ġtoler ant +ĠU W +Ġhor ribly +99 5 +ĠMID I +Ġimpat ient +oc ado +er i +ĠWor st +ĠNor ris +ĠTalk ing +Ġdef ends +ens able +Ġ20 21 +Ġanat omy +L ew +Ġdraw er +ĠCan berra +Ġpatri otic +é¾įå ĸļ士 +ĠAv g +AR M +Ġundis closed +Ġfare well +45 9 +b able +ĠAll ison +OL OG +Ġcon co +t ight +ĠAC PI +ĠM ines +l ich +ĠâĶ ľ +represent ed +200 000 +Ġenthusi ast +OT S +b il +ĠIng redients +Ġinvent or +ĠMy SQL +³³ Âł +ĠAB OUT +with in +Ġm k +B ul +ĠF ake +Ġdracon ian +W a +hel m +ĠTer ran +erv ille +Ġcommon place +SI ZE +Ġ" < +re place +ograph s +ĠSE LECT +inc ible +ĠMost ly +ĠShe ffield +ĠID E +ugg le +Ġcit ations +h urst +ĠUn ix +Ġunle ash +ĠP iper +ĠN ano +Ġsucc umb +Ġreluct ance +Ġ25 00 +ĠMer chant +Ġwire t +Ġcomb os +ĠBirth day +Ġchar coal +ĠU PS +ĠFair fax +Ġdrive way +ĠT ek +ĠP itch +ove re +Ġtechn icians +ĠAct ual +fl ation +ĠF iscal +ĠEm pty +an amo +Ġmag nesium +Ġsl ut +Ġgrow ers +Invest igators +( ): +ĠS atellite +ĠKe ynes +miss ive +l ane +Ġb orough +3 44 +ĠTE AM +ĠBet hesda +C V +h ower +ĠR AD +Ġch ant +ĠR iy +Ġcompos itions +Ġmild ly +Ġmedd ling +Ġag ility +ane ers +5 01 +Ġsyn th +ling er +29 1 +Ġex claimed +Part y +Ġcont amin +ĠMan or +ĠResp ond +Ġpra ising +Ġman ners +fle et +Sum mer +ĠLy nd +ĠDef initely +gr im +Ġbow ling +st ri +ç Ľ +y nt +Ġmand ates +D IV +Ġreconc ile +view s +ĠDam on +vet te +F lo +ĠGreat est +il on +ic ia +Ġportray al +Ġcush ion +50 4 +19 79 +oss al +App lic +sc ription +Ġmit igation +AT S +p ac +Ġer ased +Ġdefic iencies +ĠHolland e +ĠX u +Ġb red +Ġpregn ancies +f emin +Ġem ph +Ġpl anners +Ġout per +utter ing +Ġperpet rator +Ġm otto +ĠEll ison +ĠNE VER +Ġadmitted ly +AR I +ĠAzerbai jan +Ġmill isec +Ġcombust ion +ĠBott le +ĠL und +ĠP s +ĠD ress +Ġfabric ated +Ġbat tered +Ġs idel +ĠNot ting +Fore ign +ĠJer ome +0 20 +ĠAr bit +Ġkn ots +ĠR IGHT +M oving +ãģ Ļ +Ġsur geries +Ġcour thouse +Ġm astered +Ġhover ing +ĠBr an +ĠAl ison +Ġsaf est +m ilitary +Ġbull ied +Ġbar rage +Read er +ES E +ĠGe ographic +T ools +3 14 +ĠGe ek +ro th +gl ers +ĠF IN +Ï ģ +ĠA ston +al tern +48 8 +Ġveter in +G amer +Ġint el +ren ches +Sh ield +Ġam nesty +ĠB har +Ġp iled +Ġhonor able +ĠInst itutes +Ġso aked +Ġcom a +ĠE FF +34 1 +by tes +ĠG mail +le in +ĠCanad iens +m aterial +I l +Ġinstruct ors +ĠK Y +Ġconce ive +ub b +ĠP ossible +Ġeas ing +ĠChrist ina +Ġcar ic +ĠHD R +R OM +Ġsho vel +de lete +Ġp uff +ĠCh anging +Ġseam lessly +Att ribute +Ġacqu isitions +ak ery +ĠE F +Ġaut istic +ĠT akes +ĠPow der +ĠSt ir +5 10 +ĠBub ble +sett ings +ĠF owler +Ġmust ard +Ġmore over +Ġcopyright ed +ĠLED s +15 00 +æ ī +ĠH IS +en f +Ġcust od +ĠH uck +G i +Ġim g +An swer +C t +j ay +ĠInf rastructure +Ġfeder ally +L oc +Ġmicro bes +Ġover run +dd s +ot ent +adi ator +>>>> >>>> +Ġtorn ado +Ġadj ud +Ġintrig ued +Ġs i +ĠRevel ation +pro gress +Ġburgl ary +ĠSai yan +ĠK athy +Ġser pent +ĠAndre as +Ġcomp el +ess ler +ĠPl astic +ĠAd vent +ĠPos itive +ĠQ t +ĠHind us +reg istered +ular ity +Ġrighteous ness +Ġdemon ic +u itive +ĠB DS +ĠGre gg +c ia +ĠCrus ade +ĠSina i +W ARE ++ ( +Ġme ll +Ġder ail +y ards +A st +Ġnotice ably +ĠO ber +R am +Ġun noticed +Ġse q +av age +T s +Ġ6 40 +Ġconced e +Ġ] ) +F ill +Ġcapt ivity +ĠImprove ment +ĠCrus ader +ara oh +M AP +æ Ĺ +Ġstr ide +al ways +F ly +N it +Ġal gae +ĠCook ing +ĠDo ors +Mal ley +Ġpolic emen +ãģ į +Ġastron aut +access ible +49 5 +ĠR AW +cl iffe +udic rous +Ġdep ended +al ach +Ġvent ures +ra ke +Ġt its +ĠH ou +Ġcond om +ormon al +Ġind ent +Ġupload ing +Foot note +Import ant +Ġ27 1 +Ġmind ful +Ġcont ends +C ra +Ġcal ibr +ĠO ECD +plug in +F at +ĠIS S +ĠDynam ics +ans en +68 6 +' ), +Ġsp rite +Ġhand held +ĠH ipp +=~ =~ +Tr ust +Ġsem antics +ĠBund es +ĠRen o +ĠLiter ature +s ense +G ary +ĠA eg +ĠTr in +EE K +Ġcler ic +ĠSS H +Ġch rist +Ġinv ading +ib u +Ġen um +aur a +Ġal lege +ĠInc redible +B BC +Ġth ru +Ġsa iled +Ġem ulate +Ġin security +Ġc rou +Ġaccommod ations +Ġincompet ent +Ġsl ips +ĠEarth qu +s ama +IL LE +Ġi Phones +as aki +Ġby e +Ġar d +Ġext ras +Ġsl aughtered +Ġcrowd funding +res so +Ġfil ib +ĠER ROR +ĠT LS +e gg +ĠIt al +Ġen list +ĠCatal onia +ĠSc ots +Ġser geant +Ġdiss olve +N H +Ġstand ings +ri que +I Q +Ġbenef iciary +Ġaqu arium +You Tube +ĠPower Shell +Ġbright est +ĠWar rant +S old +Writ ing +Ġbegin nings +ĠRes erved +ĠLatin os +head ing +Ġ4 40 +Ġrooft op +AT ING +Ġ3 90 +VP N +G s +k ernel +turn ed +Ġprefer able +Ġturn overs +ĠH els +S a +ĠShin ji +ve h +ĠMOD ULE +V iol +Ġex iting +Ġj ab +ĠVan illa +Ġac ron +ĠG ap +ber n +A k +ĠMc Gu +Ġend lessly +ĠFar age +ĠNo el +V a +M K +Ġbr ute +ĠK ru +ĠES V +ĠOl ivia +âĢ ł +ĠK af +Ġtrust ing +Ġh ots +3 24 +Ġmal aria +Ġj son +Ġp ounding +ort ment +Count ry +Ġpostp oned +Ġunequ iv +? ), +ĠRo oney +udd ing +ĠLe ap +ur rence +sh apeshifter +ĠH AS +os ate +Ġca vern +Ġconserv atism +ĠB AD +Ġmile age +Ġarrest ing +V aults +Ġmix er +Dem ocratic +ĠB enson +Ġauth ored +8 000 +Ġpro active +ĠSpirit ual +t re +Ġincarcer ated +ĠS ort +Ġpe aked +Ġwield ing +re ciation +×Ļ × +P atch +ĠEm my +Ġex qu +tt o +ĠRat io +ĠP icks +ĠG ry +ph ant +Ġf ret +Ġeth n +Ġarch ived +% - +c ases +ĠBl aze +Ġim b +c v +y ss +im ony +Ġcount down +Ġaw akening +ĠTunis ia +ĠRe fer +ĠM J +Ġun natural +ĠCar negie +iz en +ĠN uggets +he ss +Ġev ils +64 7 +Ġintrodu ctory +l oving +ĠMcM ahon +Ġambig uity +L abel +ĠAlm ighty +Ġcolor ing +ĠCl aus +set ting +N ULL +ĠF avorite +ĠS IG +> ( +ĠSh iva +ĠMay er +Ġstorm ed +ĠCo verage +we apons +igh am +Ġun answered +Ġle ve +Ġc oy +c as +b ags +as ured +Se attle +ĠSant orum +ser ious +Ġcourage ous +ĠS oup +Ġconfisc ated +Ġ// / +Ġuncon ventional +Ġmom s +ĠRohing ya +ĠOrche stra +ĠPot ion +Ġdisc redit +ĠF IL +f ixed +ĠDe er +do i +ĠDim ension +Ġbureaucr ats +et een +Ġaction Group +oh m +Ġb umps +ĠUt ility +Ġsubmar ines +ren heit +re search +ĠShap iro +Ġsket ches +Ġde ceptive +ĠV il +es ame +ĠEss entially +Ġramp age +isk y +Ġmut tered +th ritis +Ġ23 6 +f et +b ars +Ġpup il +ĠTh ou +o S +s ong +Ġfract ured +Ġre vert +pict ure +Ġcrit erion +us her +Ġreperc ussions +ĠV intage +ĠSuper intendent +Offic ers +Ġflag ged +Ġbl ames +Ġin verse +ograp hers +Ġmakes hift +Ġdev oid +Ġfoss ils +ĠArist otle +ĠFund s +Ġde pleted +ĠFl u +ĠY uan +Ġw oes +Ġlip id +Ġsit u +requ isites +Ġfurn ish +ĠSam ar +Ġshame ful +Ġadverse ly +Ġad ept +Ġrem orse +Ġmurder ous +uck les +ĠE SL +Ġ3 14 +s ent +Ġred ef +ĠC ache +ĠP urs +ig ans +Ġ4 60 +Ġpres criptions +Ġf res +F uck +ocr ates +Tw enty +ĠWe ird +ĠT oggle +ĠC alled +itiz ens +Ġp oultry +Ġharvest ing +ãĤ¦ ãĤ¹ +Bott om +Ġcaution ed +t n +39 6 +ĠNik ki +Ġeval uations +Ġharass ing +Ġbind ings +ĠMon etary +Ġhit ters +Ġadvers ary +un ts +Ġset back +Ġenc rypt +ĠC ait +Ġl ows +eng es +ĠN orn +Ġbul bs +Ġbott led +ĠVoy ager +3 17 +Ġsp heres +p olitics +Ġsubt ract +Ġsens ations +Ġapp alling +Ġ3 16 +Ġenvironment ally +ĠST EM +Ġpub lishes +5 60 +Ġdilig ence +48 4 +Ġadv ises +Ġpet rol +Ġimag ining +Ġpatrol s +ĠInt eger +ĠAs hes +act us +ĠRad iant +ĠL T +it ability +ht aking +Set ting +Ġnu anced +ĠRe ef +ĠDevelop ers +N i +pie ces +99 0 +Lic ense +Ġlow ers +ĠOtt oman +3 27 +oo o +Ġqu itting +mark ets +Beh ind +Ġbas in +Ġdoc s +an ie +fl ash +ct l +Ġcivil ized +ĠFuk ushima +"] ," +ĠK S +ĠHonest ly +ar at +Ġconstruct s +ĠL ans +ĠD ire +ĠLI KE +ĠTrou ble +Ġwith holding +ĠOb livion +Ġsan ity +any a +Con st +Ġgro cer +ĠC elsius +Ġrecount ed +ĠW ife +B order +ate red +h appy +Ġspo iler +Ġlog ically +H all +Ġsucceed ing +Ġpoly morph +Ġax es +ĠShot gun +ĠS lim +ĠPrin ciples +ĠL eth +art a +Ġsc or +Sc reenshot +Ġrelax ation +#$ #$ +Ġdeter rent +idd y +Ġpower less +Ġles bians +Ġch ords +ĠEd ited +se lected +Ġseparat ists +000 2 +Ġair space +Ġturn around +Ġc unning +P ATH +P oly +Ġbomb ed +Ġt ion +x s +Ġwith hold +Ġw aged +ĠLiber ties +Fl ag +Ġcomfort ing +45 4 +ĠI ris +are rs +Ġr ag +Ġrel ocated +ĠGu arant +Ġstrateg ically +Ġgam ma +uber ty +ĠLock heed +g res +Ġgr illed +ĠLow e +st ats +ĠR ocks +Ġsens ing +Ġrent ing +ĠGe ological +ا Ø +ot rop +Ġse w +Ġimproper ly +48 6 +Ġâĸ ł +Ġstar ving +ĠB j +Disc ussion +3 28 +ĠCom bo +ĠFix es +N AT +Ġstri ving +th ora +Ġharvest ed +ĠP ing +Ġplay ful +Ġaven ues +Ġoccup ational +Ġw akes +ĠCou rier +Ġdrum mer +ĠBrow ser +ĠH outh +it u +Ġapp arel +p aste +Ġhun ted +ĠSecond ly +l ain +X Y +ĠP IN +ic ons +Ġcock tails +Ġs izable +Ġhurd les +est inal +ĠRecre ation +Ġe co +64 8 +ĠD ied +m int +Ġfinger prints +Ġdis pose +ĠBos nia +ts y +22 00 +Ġins pected +ĠF ou +Ġf uss +Ġamb ush +ĠR ak +Ġmanif ested +Pro secut +Ġsuff ice +ren ces +Ġcompens ated +ĠC yrus +Ġgen us +ĠWolver ine +ĠTrend s +Ġh ikes +ĠSe en +Ġen rol +C old +Ġpol itely +ĠSl av +ĠRu pert +Ġey ewitness +ĠAl to +Ġun comp +Ġposter ior +M ust +ĠHer z +Ġprogress ively +Ġ23 4 +Ġind ifference +ĠCunning ham +Ġacadem ia +Ġse wer +Ġast ounding +ĠA ES +r ather +Ġeld est +Ġclim bs +ĠAdd s +Ġout cry +Ġcont ag +ĠH ouses +Ġpe pt +ĠMel ania +interest ed +ĠU CH +ĠR oots +ĠHub bard +ĠT BD +ĠRoman ian +fil ename +St one +ĠIm pl +Ġchromos ome +C le +d x +Ġscram bled +ĠP t +Ġ24 2 +OP LE +Ġtremend ously +St reet +Ġcra ving +Ġbund led +ĠR G +p ipe +Ġinj uring +Ġarc ane +Part icip +ĠHero ic +st y +Ġto pping +ĠTemp est +rent ices +b h +Ġpar anoia +ĠUnic ode +Ġegreg ious +Ġ\ ' +ĠOsw ald +Ġgra vel +ĠSim psons +Ġbl and +ĠGuant anamo +Writ er +lin ers +ĠD ice +J C +Ġpar ity +Ġs ided +Ġ23 7 +ĠPyr rha +at ters +d k +F ine +comp an +Ġform ulated +ĠId ol +il ers +hem oth +ĠF av +Ġintr usion +Ġcar rots +ĠL ayer +ĠH acker +Ġ ---------------- +Ġmoder ation +é ģ +oc oc +Ġcharacter ize +ĠTe resa +Ġsocio economic +Ġper k +ĠParticip ation +tr aining +ĠPaul o +ph ys +Ġtrust worthy +Ġembod ied +ĠMer ch +c urrency +ĠPrior ity +Ġte asing +Ġabsor bing +Ġunf inished +ĠCompar ison +Ġdis ple +writ ers +Ġprofess ions +ĠPengu in +Ġang rily +ĠL INK +68 8 +ĠCor respond +Ġprev ailed +Ġcart el +l p +as ms +ĠRed emption +ĠIslam ists +effect s +d ose +ĠL atter +ĠHal ifax +Ġv as +ĠTop ics +ĠN amed +advert ising +zz a +IC ES +Ġret arded +ach able +ĠPupp et +ĠItem Level +Ġret ract +Ġident ifiable +A aron +ĠB uster +s ol +hel le +as semb +H ope +r anged +B a +ĠP urch +é Ģ +ĠSir i +Ġarri vals +Ġ19 12 +Ġshort ened +Ġ3 12 +Ġdiscrep ancy +ĠTem perature +ĠWal ton +Ġkind erg +p olit +Ġrem ix +Ġconnect ors +ãĥĺ ãĥ© +ĠKazakh stan +dom inated +Ġsu gars +im ble +ĠPan ic +ĠDem and +ĠCol ony +on en +ĠM ER +7 75 +ur ia +aza ar +ĠDeg ree +P ri +Ġsun shine +Ġ25 1 +Ġpsychedel ic +Ġdigit ally +ĠBra un +Ġsh immer +Ġsh ave +ĠTel esc +ĠAst ral +ĠVenezuel an +ĠO G +Ġc rawling +Int eg +ĠFe ather +Ġunfold ing +Ġappropri ation +Ġè£ı è +ĠMob ility +ĠN ey +- . +b ilt +L IN +ĠT ube +ĠCon versely +Ġkey boards +ĠC ao +Ġover th +Ġla ure +>> \ +ĠV iper +ach a +Off set +ĠR aleigh +ĠJ ae +J ordan +j p +Ġtotal itarian +Connect or +Ġobserv es +ĠSpart an +ĠIm mediately +ĠSc al +C ool +Ġt aps +Ġro ar +P ast +Ġch ars +ĠB ender +ĠShe ldon +Ġpain ter +Ġbe acon +ĠCreat ures +Ġdownt urn +Ġh inder +ĠAnd romeda +à Ľ +cc oli +ĠF itness +et rical +Ġutil izes +Ġsen ate +Ġen semble +Ġche ers +T W +Ġaff luent +k il +ry lic +ord ering +Com puter +Ġgru esome +ost ics +ĠUb isoft +ĠKel ley +Ġw rench +Ġbourgeois ie +IB LE +ĠPrest on +w orn +ar ist +reat ing +Ġst ained +ar ine +Ġsl ime +EN N +Ġche sts +Ġground water +ann ot +ĠTr ay +ĠLoc ke +ĠC TR +Ġd udes +ĠEx ternal +ĠDec oder +Ġpar amed +ĠMed line +80 9 +ĠD inner +rup al +g z +ĠG um +ĠDem o +j ee +Ġd h +ber man +arch s +Ġen qu +ĠEp stein +Ġdevast ation +Ġfriends hips +ĠAr d +Ġ23 1 +ĠRub in +ĠDist ance +Ġsp urred +Ġd ossier +Ġover looking +\\\\\\\\ \\\\\\\\ +Fore st +ĠCom es +\ ", +ĠIran ians +Ġf ixtures +L aughs +Ġcur ry +ĠKing ston +Ġsqu ash +Ġcat alogue +Ġabnormal ities +Ġdigest ive +.... ..... +Ġsubord inate +og ly +Ġ24 9 +M iddle +Ġmass ac +Ġburg ers +Ġdown stairs +Ġ19 31 +39 4 +ĠV G +Ġl asers +ĠS ikh +ĠAlex a +der ived +Ġcycl ist +ãģ® éŃĶ +onel iness +!!!! !!!! +Ġbuff s +leg ate +Ġrap ing +Ġrecomm ending +ro red +Ġmult icultural +un ique +Ġbusiness men +Ġune asy +ĠM AP +Ġdisp ersed +cipl ine +J ess +ĠK erala +å § +Ġabst raction +Sur v +U h +Ġprin ters +ij a +ow der +Ġanalog ous +ĠA SP +af er +Ġunfold ed +Ġlevel ing +Ġbre ached +ĠH earing +Ġn at +Ġtransl ating +crit ical +Ġant agonist +ĠYes terday +Ġfuzz y +w ash +m ere +Ġbe wild +ĠM ae +V irgin +ph rase +Ġsign aled +ĠH IGH +Ġprot ester +Ġgar ner +unk nown +Ġk ay +Ġabduct ed +Ġst alking +am n +Ġdes erving +ĠR iv +ĠJ orge +Ġscratch ing +ĠS aving +ip ing +Ġte ase +Ġmission ary +ĠMor row +T IME +P resent +Ġchem otherapy +tern ess +ĠH omes +ĠP urdue +Ġst aunch +ĠWhit ney +ĠTH ERE +Î ¼ +iat us +ĠErn est +ĠDe ploy +Ġcove ted +F ML +ĠDial ogue +Ġex ited +f ruit +Ġner d +":" "," +Ġv ivo +ru ly +4 60 +ĠAm en +rehens ible +Ġâ ĺ +D IR +Ġad herence +Ġche w +ĠCo ke +ĠSerge i +dig ital +ĠNe ck +g ently +enth al +/ ) +Ġwe ary +Ġgu ise +ĠConc ord +ĠOn ion +at cher +Ġb inge +ĠDirect ive +Ġman ned +ans k +Ġill usions +Ġbillion aires +38 3 +oly n +odynam ic +ĠWhe at +ĠA lic +Ġcol oured +ĠN AFTA +ab o +Ġmac ros +ind ependent +s weet +Ġsp ac +ĠK abul +Ġ Ä +em e +Ġdict ated +Ġsh outs += { +Ġr ipping +ĠSh ay +ĠCr icket +direct ed +Ġanalys ed +ĠWAR RANT +ag ons +ĠBlaz ers +Ġche ered +Ġar ithmetic +ĠTan z +37 3 +ĠFl ags +Ġ29 5 +Ġw itches +ĠIn cluded +ĠG ained +ĠBl ades +G am +ĠSam antha +ĠAtl antis +ĠPr att +Ġspo iled +ĠI B +ĠRam irez +Pro bably +re ro +ĠN g +ĠWar lock +t p +Ġover he +Ġadministr ations +Ġt int +Ġreg iment +Ġpist ols +Ġblank ets +Ġep ist +Ġbowl s +Ġhydra ulic +Ġde an +Ġj ung +Ġasc end +70 5 +ĠSant iago +à ® +Ġun avoid +ĠSh aman +re b +Ġstem ming +99 8 +ĠM G +st icks +esthes ia +ER O +Ġmor bid +ĠGr ill +ĠP oe +any l +Ġdele ting +ĠSurve illance +Ġdirect ives +Ġiter ations +ĠR ox +ĠMil ky +F ather +Ġpat ented +44 7 +Ġprec ursor +Ġm aiden +ĠP hen +ĠVe gan +ĠPat ent +K elly +Redd itor +Ġn ods +Ġvent ilation +ĠSchwar z +Ġw izards +Ġomin ous +ĠHe ads +ĠB G +Ġl umber +ĠSp iel +Ġis Enabled +Ġancest ral +ĠSh ips +Ġwrest ler +ph i +Ġy uan +ĠRebell ion +Ġice berg +Ġmag ically +Ġdivers ion +ar ro +yth m +ĠR iders +ĠRob bie +ĠK ara +ĠMain tenance +ĠHer b +Ġhar ms +p acked +ĠFe instein +Ġmarry ing +Ġbl ending +ĠR ates +Ġ18 80 +Ġwr ink +ĠUn ch +ĠTor ch +desc ribed +Ġhuman oid +ilit ating +ĠCon v +ĠFe ld +IGH TS +Ġwhistlebl ower +ort mund +ets y +arre tt +ĠMon o +ĠI ke +ĠC NBC +ĠW AY +ĠMD MA +ĠIndividual s +Ġsupplement al +Ġpower house +ĠSt ru +F ocus +aph ael +ĠCol leg +att i +Z A +Ġp erenn +ĠSign ature +ĠRod ney +Ġcub es +idd led +ĠD ante +ĠIN V +iling ual +ĠC th +Ġso fa +Ġintimid ate +ĠR oe +ĠDi plom +ĠCount ries +ays on +Ġextrad ition +Ġdis abling +ĠCard iff +Ġmemor andum +ĠTr ace +Ġ?? ? +se ctor +ĠRou hani +ĠY ates +ĠFree ze +Ġbl adder +M otor +ĠProm ise +ant asy +Ġforesee able +ĠC ologne +cont ainer +ĠTre es +ĠG ors +ĠSin clair +Ġbar ring +key e +Ġsl ashed +ĠStat istical +é ĩ +Ġâĸ º +All ows +Ġhum ility +Ġdr illed +ĠF urn +44 3 +Ġse wage +Ġhome page +Ġcour tyard +Ġv ile +Ġsubsid iaries +aj o +direct ory +Ġam mon +V ers +charg es +Ġ} } +ĠCh ains +Ġ24 6 +n ob +Ġper cept +Ġg rit +Ġfisher men +ĠIraq is +ĠDIS TR +ĠF ULL +ĠEval uation +g raph +at ial +Ġcooper ating +Ġmel an +Ġenlight ened +Ġal i +t ailed +Ġsal ute +Ġweak est +ĠBull dogs +U A +ĠAll oy +Ġsem en +oc ene +ĠWilliam son +s pr +, âĢĶ +ĠG F +itt ens +Be at +ĠJ unk +iph ate +ĠFarm ers +ĠBit coins +ig ers +d h +ĠL oyal +p ayer +Ġentert ained +Ġpenn ed +Ġcoup on +Que ue +Ġweaken ing +c arry +Ġunderest imate +Ġshoot out +Ġcharism atic +ĠProced ure +Ġprud ent +in ances +Ġric hes +Ġcort ical +Ġstr ides +Ġd rib +ĠOil ers +5 40 +ĠPer form +ĠBang kok +Ġe uth +S ER +Ġsimpl istic +t ops +camp aign +Q uality +Ġimpover ished +ĠEisen hower +Ġaug ment +ĠH arden +Ġinterven ed +Ġlist ens +ĠK ok +Ġs age +Ġrub bish +ĠD ed +Ġm ull +pe lling +Ġvide ot +Produ ction +D J +m iah +Ġadapt ations +Ġmed ically +Ġboard ed +Ġarrog ance +Ġscra pped +Ġopp ress +FORM ATION +Ġj unction +4 15 +EE EE +S kill +Ġsub du +ĠSug gest +ĠP ett +Ġle tt +ĠMan ip +ĠC af +ĠCooper ation +T her +Ġreg ained +¶ æ +ref lect +Ġth ugs +ĠShel by +Ġdict ates +ĠWe iner +ĠH ale +Ġbatt leground +s child +Ġcond ol +h unt +osit ories +Ġacc uses +Fil ename +Ġsh ri +Ġmotiv ate +Ġreflect ions +N ull +ĠL obby +¥ µ +ĠS ATA +ĠBack up +Ñ ĥ +n in +ĠCor rection +Ġju icy +ut ra +ĠP ric +Ġrest raining +ĠAir bnb +ĠAr rest +Ġappropri ations +Ġsl opes +Ġmans laughter +Ġwork ings +ĠH uss +ĠF rey +Le ave +ĠHarm ony +ĠF eder +Ġ4 30 +Ġt rench +Ġglad ly +Ġbull pen +ĠG au +b ones +Ġgro ove +Ġpre text +ã ħĭ +Ġtransm itter +ĠComp onent +Ġunder age +ĠEm pires +T ile +Ġo y +ĠMar vin +ĠC AS +Ġbl oss +Ġrepl icated +ĠMar iners +Marc us +ĠBl ocks +Ġliber ated +Ġbutter fly +Fe el +Ġfer mentation +Ġyou tube +Ġoff end +ĠTer m +res ist +Ġcess ation +Ġinsurg ency +Ġb ir +ĠRa ise +59 5 +Ġhypothes es +50 2 +Ġpl aque +ocr at +Ġjack ets +ĠHuff Post +am ong +Ġconf er +48 7 +ĠL illy +Ġadapt ing +ĠF ay +Ġsh oved +ve c +Ġref ine +Ġg on +Ġgun men +z ai +ĠShut tle +ĠI zan +Ġ19 13 +Ġple thora +· · +Ġ5 10 +Ġp uberty +Ġ24 1 +ĠWe alth +ĠAl ma +ĠM EM +ĠAd ults +C as +pr ison +R ace +Ġwater proof +Ġathlet icism +Ġcapital ize +ĠJu ice +Ġillum inated +ĠP ascal +Ġirrit ation +ĠWitness es +ad le +ĠAst ro +Ġf ax +ĠEl vis +Prim ary +ĠL ich +ĠEl ves +Ġres iding +Ġst umble +3 19 +ĠP KK +Ġadvers aries +D OS +ĠR itual +Ġsm ear +Ġar son +ident al +Ġsc ant +Ġmon archy +Ġhal ftime +Ġresid ue +Ġind ign +ĠSh aun +ĠEl m +aur i +A ff +W ATCH +ĠLy on +hel ps +36 1 +Ġlobby ist +Ġdimin ishing +Ġout breaks +Ġgo ats +f avorite +ĠN ah +son ian +ĠBo oster +Ġsand box +ĠF are +ĠMalt a +Ġatt Rot +ĠM OR +ld e +Ġnavig ating +T ouch +Ġunt rue +ĠDis aster +Ġl udicrous +Pass word +ĠJ FK +blog spot +4 16 +ĠUN DER +ern al +Ġdelay ing +T OP +Ġimpl ants +ĠAV G +ĠH uge +att r +Ġjournal istic +ĠPe yton +ĠI A +R ap +go al +ĠProgram me +Ġsm ashing +w ives +print ln +ĠPl ague +in us +EE P +Ġcru iser +ĠPar ish +umin ium +Ġoccup ants +ĠJ ihad +m op +Ġp int +Ġhe ct +ĠMe cca +direct or +ĠFund ing +ĠM ixed +Ġst ag +T ier +Ġg ust +Ġbright ly +ors i +Ġup hill +R D +Ġles ions +ĠBund y +liv ious +Ġbi ologist +ĠFac ulty +ĠAuthor ization +Ġ24 4 +All ow +ï ¸ +ĠGi ul +Ġpert inent +ot aur +es se +ĠRo of +Ġunman ned +35 1 +ĠSh ak +ĠO rient +Ġend anger +D ir +Ġrepl en +ed ient +Ġtail or +Ġgad gets +Ġaud ible +âĺ Ĩ +N ice +Ġbomb ard +ĠR ape +Ġdef iance +ĠTW O +ĠFilip ino +Ġunaff ected +erv atives +Ġso ared +ĠBol ton +Ġcomprom ising +ĠBrew ers +R AL +ĠA HL +icy cle +Ġv ampires +Ġdi pped +oy er +ĠX III +Ġsidew ays +ĠW aste +ĠD iss +ĠâĶľ âĶĢâĶĢ +$ . +Ġhabit ats +ĠBe ef +tr uth +tr ained +spl it +R us +And y +ĠB ram +RE P +p id +è£ ħ +ĠMut ant +An im +ĠMar ina +Ġfut ile +hig hest +f requency +Ġepile psy +Ġcop ing +Ġconc ise +Ġtr acing +ĠS UN +pan el +ĠSoph ie +ĠCrow ley +ĠAd olf +ĠShoot er +Ġsh aky +ĠI G +ĠL ies +ĠBar ber +p kg +Ġupt ake +Ġpred atory +UL TS +/ ** +Ġintox icated +ĠWest brook +od der +he ment +Ġbas eman +AP D +st orage +ĠFif ty +ed itor +G EN +UT ION +ir ting +Ġse wing +r ift +Ġag ony +ĠS ands +Ġ25 4 +C ash +Ġl odge +Ġp unt +N atural +ĠIde as +Ġerrone ous +ĠSens or +ĠHann ity +Ġ19 21 +Ġm ould +ĠG on +kay a +Ġanonym ously +ĠK EY +Ġsim ulator +W inter +Ġstream ed +50 7 +? ", +Ġte ased +Ġco efficient +Ġwart ime +ĠTH R +' '. +ĠBank ing +mp ire +Ġf andom +Ġl ia +G a +Ġdown hill +Ġinterpre ting +Ind ividual +N orm +Ġjealous y +bit coin +Ġple asures +ĠToy s +ĠChev rolet +ĠAd visor +IZ E +Ġrecept ions +70 6 +C ro +Ġ26 2 +Ġcit rus +ir u +Review er +ject ed +U ES +an z +19 81 +ĠWork er +Ġcompl ied +ores cent +contin ental +T on +ĠPr ism +ĠShe ep +Ġ28 8 +n ox +ĠV og +O rd +Ġreal ms +te k +Ġirrig ation +Ġbicy cles +Ġelectron ically +p oly +t all +() ); +Ġaest hetics +ĠInteg rated +Expl ore +Ġd unk +47 6 +p ain +ĠJac ques +ĠD mit +Fram es +Ġreun ited +Ġhum id +D ro +P olitical +Ġyouth ful +Ġent ails +Ġmosqu ito +36 3 +spe cies +Ġcoord inating +ĠMay hem +ĠMagn us +M ount +Impro ved +ĠST ATE +ATT LE +Ġflow ed +Ġtack led +Ġfashion ed +Ġre organ +iv ari +f inger +Ġreluct antly +et ting +ĠV and +you ng +ĠGar land +Ġpresum ption +Ġamen ities +ĠPle asant +on ential +ĠO xy +Ġmor als +ĠY ah +Read y +Sim on +En h +D emon +Ġcl ich +Mon itor +ĠD U +Ġwel comes +Ġstand out +Ġdread ful +Ġban anas +Ġball oons +h ooting +bas ic +Ġsuff ix +Ġd uly +can o +Ch ain +at os +Ġgeop olitical +Ġ( & +ĠGem ini +ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ ÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤÃĥÃĤ +Ġacqu itted +L uck +prot ect +10 24 +Ġsc arcity +Ġmind fulness +ec ided +D N +pr ime +ĠPres idents +ĠVID EO +Ġ( âĪĴ +add ock +N OR +ĠP ru +p un +ĠL OL +)) )) +ĠL iqu +ĠS AS +Ġsty ling +Ġpunish ments +Ġnum b +Ġasc ertain +ĠRock ies +f lu +Th umbnail +Ġperpet rated +ĠSem i +Ġdis arm +ĠOld er +ĠEx ception +Ġexponent ially +ĠCommun ities +Ġabol ish +ĠPart ner +pt oms +Ġ7 77 +ĠFo ley +ĠC ases +Ġgre ase +ĠReb irth +G round +Ġ; ) +ĠDoct rine +ik ini +Y e +ĠBl ossom +Ġpers ists +b ill +Ġinf usion +Ġbud dies +9 11 +ĠPat ient +Ġdem os +Ġacquaint ance +ĠP aw +at ari +Ġx ml +Ġfasc ination +ĠSer ve +Ï Ĥ +br anded +Ġa z +Return s +Ġover shadow +Ġro am +Ġspeed y +n umbered +hel ial +Ġdisc iple +Ġass urances +g iven +pect ing +ĠN atalie +çĶ ° +Ġmosquit oes +rote in +Ġnumer ic +Ġindepend ents +Ġtrans itional +Ġreaction ary +ĠMech dragon +do ctor +Ġshort est +Ġsequ ential +ĠB ac +ĠAccount s +ãģ Į +ach y +ract ive +ĠReg iment +Ġbreat htaking +ffic iency +ĠB ates +Ġ3 11 +Ġward robe +ft s +ĠBer k +Sim ply +ĠRivers ide +iver ing +ident ial +lu cent +Ġen riched +ĠCon ver +ĠG iving +ãĥ Ļ +Ġlegal ize +ĠF TC +Ġfre aking +M ix +Ġter restrial +es ian +ci ents +W ing +LO AD +Ġled ge +ĠViol ent +ĠMet all +Ġ30 8 +Ġs outheastern +hett o +M eat +Ġslow down +Ġret reated +Jere my +end as +**** * +er ic +Ġre ins +opp able +ĠHuman ity +ear ances +rig an +C amera +Ġwa ivers +s oc +Ġalter ation +trans form +ĠC emetery +50 6 +Ġindef inite +Ġstim ulating +y g +60 3 +ĠS op +Ġdescript ive +Ph ase +ĠEd mund +Ġpneum onia +vent us +A mb +Ġlabor atories +ĠEx clusive +ug ar +W ere +Ġmalf unction +Ġhomosexual s +Ġ---- --- +un i +Ġturb ines +ĠEqu ity +D u +Ġmind ed +ĠR H +ĠBlack hawks +Ġfe ats +Ġ17 00 +re pl +36 2 +lad en +Ġindisp ensable +ly ss +tt i +Ġre el +Ġdiver ted +Ġlik eness +Ġsubscript ions +Ġfing ert +Ġfil thy +dest ruct +d raft +ĠBernard ino +l aunch +Ġper plex +ĠS UM +car b +Ġswe ater +ĠVent ure +ĠJ ag +ĠCele b +ĠV oters +Ġstead fast +Ġathlet ics +ĠHans on +ĠDr ac +Tr acker +Ġcomm end +ĠPres idency +ĠD ID +in formed +Ġweb page +P retty +Ġforce fully +ãĥĥ ãĤ¯ +Ġrel ocation +Ġsat ire +â ī +ĠSunder land +æ Ħ +V oice +???? ???? +Ġinform ant +Ġbow el +ĠUn iform +Ġ ..." +Ġpur ge +Ġpic nic +ĠU mb +ĠU PDATE +ĠSapp hire +ĠSt all +le arn +Ġobject ively +Ġob liter +Ġlooph ole +Ġjour neys +Ġo mission +Pro s +ĠSid ney +pl oma +Ġspray ed +Ġg uru +Ġtra itor +Ġtim et +Ġsn apping +ĠSe vent +urn al +ĠUk ip +Ġb owed +por al +l iberal +R os +Quest ions +i OS +Ġsummar ize +ST AT +Ġ18 50 +ap est +Ġl ender +ĠVari able +br inging +ĠL ORD +, ) +Ġcollaps es +x iety +ĠN ed +Y D +ĠSch a +Ġantib ody +Ġdis band +y re +ill usion +Ġro ver +s hed +ĠHiro sh +cc i +Ġcal am +ĠMort on +P interest +Ġ19 28 +ĠE uras +ord es +Ġf ences +ĠIn ventory +ĠVal encia +ĠU d +ĠT iff +Ġsqu e +Ġqu otation +Ġtroubles ome +er ker +QU EST +ĠKing doms +s outh +Ġle vy +Pr ince +ĠSt ing +Ġnick named +Ġapp e +Ġphot ographic +Ġcorp us +re ference +ĠT rog +U nt +) =( +ĠLat via +Ġactiv ating +Ġlicense e +Ġdispar ities +ĠNews letter +ãĥĥ ãĥĪ +Ġfree ing +ĠJe ep +ĠPer ception +ins k +Ġsil icone +ĠHay den +Le an +ĠSuz uki +ibr arian +66 8 +Ġsp or +Ġcorrel ations +ag hetti +Ġtu ber +ĠIP CC +il us +ĠV u +Ġwealth iest +ĠCarb uncle +an za +Ġfool ed +ĠZ ur +Ġd addy +ran o +il ian +Ġknock out +f man +requ ired +ĠWik ileaks +ĠD uffy +ON T +Ġins ol +ĠObject s +Ġb ou +ĠNord ic +ĠIns ert +sc an +Ġd ancers +Ġid iots +major ity +ĠNev ille +ĠFree BSD +Ġt art +pan ic +69 0 +Ġcoc oa +Ġsam pled +Ġlook up +Ind ust +Ġinject ions +gen re +Ġa u +Ġroad way +Ġgen itals +K ind +ĠEx aminer +ĠY az +F resh +Ġpar alysis +ĠAl uminum +Ġre ap +ok é +Ġsl oppy +ĠTun nel +pos ium +ner y +en ic +Ġher bal +ĠOut er +ĠBuild er +Ġinc ur +Ġide ologies +Ġback ups +cons uming +ĠDet ect +de ck +ĠKN OW +ĠG ret +ĠM IC +Ġtough ness +ĠEx hibit +Ġh ive +L es +ĠSCH OOL +ĠAt ari +ald e +ĠN ull +and estine +m ouse +Ġbrig ade +48 9 +Ġrev ol +ĠLaw son +ĠW ah +op oly +eb ted +ĠS aunders +Ġ3 13 +ĠW inc +Ġtab oo +ĠHel met +Ġw edge +ch ip +ĠT ina +b g +Ġinf uri +r n +Ġanomal ies +ĠSy nc +ĠEx am +ĠComm it +ĠDi ary +ĠALS O +ĠDe bor +omed ical +Ġcomprehens ion +6 55 +Ġempower ing +Ġ ire +Ġju ices +ĠE TH +ĠBox ing +=" / +Ġfacilit ated +p oke +ĠPars ons +ĠMod er +tra vel +Ġcivil izations +Ġliber tarians +Ġrun e +ĠCl arks +at hed +Ġcampaign ers +ĠDis patch +ĠFah renheit +ĠCap com +-------- -- +Ġl ace +Ġdr aining +Ġl iner +ĠArt ificial +é n +t ask +] ). +ĠGM O +ĠOper ator +ord inary +ĠInf luence +ĠU ps +Ġpot ency +uss en +osp ons +ĠSw im +ĠDead line +Un ity +Ġcul inary +Ġenlight enment +Ġwe arer +Ġmin ed +Ġp ly +Ġinc est +ĠDVD s +W alk +B TC +Tr ade +Ġdev al +ib and +ĠOvers ight +Palest inian +Ġd art +Ġm ul +L R +Ġrem ovable +ĠReal ms +ì Ŀ +Ġmisc ar +ĠV ulkan +68 5 +è re +ĠS ap +Ġmer ging +ĠCar ly +che ster +Ġbr isk +Ġlux urious +ĠGener ator +Ġbit terness +Ġed ible +Ġ24 3 +T G +Ġrect angle +With No +bel ow +J enn +Ġdark est +Ġh itch +Ġdos age +Ġsc aven +ĠK eller +ĠIllust rated +Certain ly +ĠMaver icks +Marg inal +Ġdiarr hea +Ġenorm ously +Ġ9 99 +sh r +qu art +Ġadam ant +ĠM ew +Ġren ovation +Ġcerv ical +ĠPercent age +en ers +ĠKim ber +Ġflo ats +Ġde x +ĠW itcher +ĠSwan sea +d m +Ġsal ty +y ellow +Ġca pe +ĠDr ain +ĠPaul a +ĠTol edo +les i +Mag azine +ĠW ick +ĠM n +ĠA ck +ĠR iding +AS ON +Ġhom ophobic +AR P +Ġwand ered +C PU +ood oo +ĠP ipe +Ġtight ening +ĠBut t +3 18 +Ġdesert ed +S ession +Ġfacilit ating +J ump +Ġemer gencies +OW ER +Ġexhaust ive +ĠAF TER +Ġheart beat +ĠLab el +ack y +ĠCert ified +ilt ration +Z e +ĠU tt +Ġ13 00 +Ġpres ume +ĠDis p +Ġsur ged +Ġdoll s +Col umb +Ġchim pan +ĠR azor +Ġt icks +Ġcouncill or +Ġpilgr image +ĠReb els +ĠQ C +ĠA uction +x ia +ik k +b red +Ġinsert ion +Ġco arse +d B +SE E +ĠZ ap +ĠF oo +Ġcontem por +ĠQuarter ly +ot ions +ĠAl chemist +ĠT rey +ĠDu o +S weet +80 4 +ĠGi ov +Ġfun n +N in +h off +Ġram ifications +Ġ19 22 +ĠExper ts +az es +Ġgar ments +ar ial +ĠN ab +Ġ25 7 +ĠV ed +Ġhum orous +ĠPom pe +Ġn ylon +Ġlur king +ĠSerge y +ĠMatt is +Ġmisogyn y +ĠComp onents +ĠWatch ing +ĠF olk +ract ical +B ush +Ġt aped +Ġgroup ing +Ġbe ads +Ġ20 48 +Ġcon du +quer que +Read ing +Ġgriev ances +Ult ra +Ġend point +H ig +ĠSt atic +ĠScar borough +L ua +ĠMess i +a qu +ĠPsy Net +ĠR udd +Ġa venue +v p +J er +Ġsh ady +ĠRes ist +ĠArt emis +Ġcare less +Ġbro kers +Ġtemper ament +Ġ5 20 +T ags +ĠTurn ing +Ġut tered +Ġp edd +Ġimpro vised +Ġ: ( +Ġtab l +Ġpl ains +16 00 +press ure +ĠEss ence +marg in +friend s +ĠRest oration +Ġpoll ut +ĠPok er +ĠAugust ine +ĠC IS +ĠSE AL +or ama +Ġth wart +se ek +Ġp agan + º +cp u +Ġg arn +Ġass ortment +ĠI LCS +t ower +Recomm ended +Ġun born +ĠRandom Redditor +ĠRandomRedditor WithNo +Ġparaly zed +Ġeru ption +Ġinter sect +ĠSt oke +ĠS co +B ind +å ¾ +ĠP NG +ĠNeg ative +ĠNO AA +Le on +Ġall oy +ĠL ama +ĠD iversity +5 75 +Ġunderest imated +ĠSc or +Ġm ural +Ġb usted +so on +l if +Ġnone x +Ġall ergy +ĠUnder world +ĠR ays +ĠBl asio +Ġh rs +ĠD ir +Ġ3 27 +by ter +Ġrepl acements +Ġactiv ates +ri ved +M H +Ġp ans +ĠH I +Ġlong itudinal +Ġnu isance +al er +Ġsw ell +ĠS igned +s ci +ĠIs les +ĠA GA +Ġdef iant +Ġson ic +oc on +K C +ĠA im +t ie +ah ah +Ġm L +D X +Ġb isc +ĠBill board +ĠSY STEM +NE Y +ga ard +Ġdist ressed +former ly +Al an +Ġche fs +Ġopt ics +ĠC omet +ĠAM C +Ġredes igned +irm ation +Ġsight ings +38 2 +3 11 +ĠW B +Ġcont raction +ĠT OTAL +D ual +Ġstart led +Ġunderstand ably +Ġsung lasses +ETH OD +Ġd ocker +Ġsurf ing +ĠH EL +ĠSl ack +ton es +Ġsh alt +Vis ual +49 8 +Dep artment +c ussion +Ġunrest ricted +Ġt ad +Ġre name +employ ed +Ġeduc ating +Ġgrin ned +bed room +ĠActiv ities +ĠV elvet +ĠSW AT +Ġsh uffle +ig or +Ġsatur ation +F inding +c ream +ic ter +Ġv odka +tr acking +te c +Ġfore ground +iest a +Ġve hement +ĠEC B +ĠT ie +E y +Ġt urtles +ĠRail road +ĠKat z +ĠFram es +Ġmen ace +ĠFell owship +ĠEss ential +ugg ish +Ġdri p +ch witz +ĠKy oto +s b +ĠN ina +Param eter +Ġal arms +ĠCl aud +Ġpione ering +Ġchief ly +ĠSc ream +Col lection +Ġthank fully +ĠRonald o +åŃ IJ +st rip +ĠDisney land +com mercial +See ing +S oul +Ġevac uate +Ġc iv +ĠAs he +Ġdiv ides +ĠD agger +rehens ive +Ġber ries +ĠD F +Ġs ushi +Ġplur ality +W I +Ġdisadvant aged +Ġbatt alion +ob iles +45 1 +Ġcl ing +Ġunden iable +ĠL ounge +Ġha unt +p he +Ġquant ify +Ġdiff ered +Ġ[* ] +ĠV iz +c um +sl ave +Ġvide og +Ġqu ar +Ġbund les +ĠAl onso +t ackle +Ġneur onal +Ġlandsl ide +conf irmed +ĠDep th +Ġrenew ables +B ear +ĠMaced onia +Ġjer seys +Ġb unk +ĠSp awn +ĠControl s +ĠBuch anan +Ġrobot ics +Ġemphas izing +ĠTut orial +h yp +ist on +Ġmonument al +æ ° +ĠCar ry +Ġt bsp +en ance +H ill +art hed +Ġro tten +De an +Ġtw isting +Ġgood will +Ġimm ersion +L iving +Ġbr ushes +ĠC GI +ĠAt k +tr aditional +Ġph antom +ĠSt amina +Ġexpans ions +ĠMar in +Ġembark ed +ĠE g +int estinal +ĠPE OPLE +ĠBo oth +ĠApp alach +Ġreleg ated +V T +M IT +Ġmust er +Ġwithdraw ing +Ġmicrosc ope +ĠG athering +ĠC rescent +ĠArgent ine +ĠDec re +ĠDomin ic +Ġbud s +ant age +ĠI on +Ġwid ened +ONS ORED +ĠGl oves +iann opoulos +raz en +fe el +Ġrepay ment +Ġhind sight +ĠRE ALLY +ĠPist ol +ĠBra h +Ġwat ts +Ġsurv ives +Ġfl urry +iss y +Al ert +ĠUrug uay +Ph oenix +S low +ĠG rave +ĠF ir +Ġmanage able +Ġtar iff +ĠU DP +ĠPist ons +ĠNiger ian +Ġstrike outs +Ġcos metics +whel ming +f ab +c ape +pro xy +Ġre think +Ġover coming +sim ple +Ġw oo +Ġdistract ing +ĠSt anton +ĠTuls a +ĠD ock +65 9 +Ġdisc ord +ĠEm acs +ĠV es +ĠR OB +Ġreass uring +Ġcons ortium +Muslim s +3 21 +Ġprompt s +se i +ĠH itch +imp osed +ĠF ool +Ġindisc rim +wr ong +bu querque +D avis +! ] +Ġtim eless +ĠNE ED +Ġpestic ide +Ġrally ing +ĠCal der +Ġå ¤ +Ġx p +ĠUn le +ĠEx port +lu aj +B uff +) </ +B oot +ĠChrys ler +or ative +M ess +Ġneglig ible +ert odd +ĠMush room +ĠG ale +g c +ĠCos by +ĠR ural +rit ical +B ell +Ġturb ine +00 200000 +Ġlegit imately +ĠAnim ated +T ED +ĠThe odore +c onduct +ĠH ier +Ġcounterfe it +ĠAlger ia +Ġun beat +cont roller +Ġun res +Ġscram bling +ĠFall on +T es +Ġam ber +Ġroy alties +ĠShel ter +ĠL ester +Ġclass ify +Rem ote +Ġun heard +Ġcontrovers ies +Ġenrich ment +ĠYan kee +g amer +Ġpl atinum +Ġec ology +ĠS ark +Ġunt ouched +Ġsuper visors +Ġ" % +Ġf ooth +Ġcomm ons +Ġnarc otics +Ġind ices +ĠP ly +Ġaddition ally +ĠGaw ker +ĠE Q +Pl aying +Ġcave at +ĠAbs olute +oss us +B aby +Ġr ation +Ġres in +Ġcalib ration +ĠNew port +Ġkn ocks +v t +Ġcomp ost +Sc ene +Ġsar cast +Ġkiss es +Ġn s +all i +ĠMar cel +ĠP iet +iat rics +Ġsurround s +ĠRep rodu +ĠPhill ies +Ġuncertain ties +ĠE ur +ĠRom ance +ĠH ath +ĠNeed s +ĠCl oak +Ġcre m +que ue +Ġ3 55 +Ġup front +] ); +Ġrecip roc +Ġ19 27 +Ġ11 00 +ut su +Ġdep ressive +ow ment +F ans +Ġme ch +Ġann ihil +Ġcounter terrorism +ĠFig ures +b old +ĠMo ines +ĠDri vers +Ġmanuscript s +ĠCrypt o +Ġhyp not +redd its +Ġprosec utions +Ġdiver t +CR IP +ĠB ene +ĠRe ggie +Ġtax ing +ĠMor ales +ent ing +t ur +sign ificant +ĠPR OV +Ġstr ands +Ġp ouch +ĠR ookie +» Ĵ +Ġnic er +he my +h w +EC A +Ġintimid ated +Ġstr icter +Ġmicro bial +det ails +Ġv ows +Ġqu ake +hh hh +Ġrein vent +U b +Ġrel inqu +ĠBuff ett +lic ensed +itte red +ĠPic ard +Ġche wing +u cl +organ ic +Ġlocal ized +ĠEconom ist +Ġacqu ainted +Def inition +s ed +Crit ics +Ġc c +45 3 +38 1 +Ġfell ows +Ġcheck points +0 25 +Ġre election +Ġmed iated +ĠK DE +Ġhurd le +Ġtext ing +Per fect +Ġtrust ees +fect ure +Ġd ich +mon ary +Ġdist inctions +Ġ14 00 +Ġus her +Ġparas ites +ĠSh aring +ĠV im +Ġbar becue +ĠMin isters +ere lla +Ġe b +Ġm c +ĠSome how +ĠIn sect +ch anges +b road +ĠBy z +Ġgrap es +66 9 +Ġ= ================ +Ġass imil +Ġhaun ting +Ġfire power +Ġdef amation +em phasis +Ġcomp ose +Ġallerg ies +Ġstr ang +roll ers +b ang +Ġbrew ers +ron gh +ri ot +p oor +c old +S ample +Ġbu oy +0 40 +ĠCourt ney +Ġ26 8 +ĠWed ding +70 2 +Ġobsess ive +Ġbra king +ĠL al +an ical +å ¦ +at en +Con struction +Ġclin ically +iers hip +N ames +ĠDisc uss +ĠRam os +Ġloc ale +ĠAgric ultural +En able +Ġhorse power +ent ure +P ref +C ourt +Ġstaff ing +Ġfut uristic +dri vers +ĠMarket place +æĪ ¦ +Friend s +Ġdam ning +ĠCustom ers +Ġwe eds +ĠM ai +Ġag ile +ĠT att +ic ent +R anked +cro ft +ĠKat y +Ext reme +Ġcar ve +ĠR over +ĠBy ron +37 2 +Ġconduct s +r atch +it ia +ĠPump kin +Sad ly +Rel oaded +P olicy +Ġl ick +pe ak +is ks +ĠCD s +ĠEn cyclopedia +in itial +C os +ĠAware ness +ĠD ram +$$ $$ +Ġr iff +Ġscript ure +run ners +Ġbo iler +ons on +o in +Ġham string +Ġcat aly +ĠArch bishop +ch all +Ġf aux +ok in +local host +ĠN AME +ad obe +S AN +am ate +Ġscram ble +Ġcar c +ĠMan ifest +ĠCed ar +ĠSer gio +l ater +ff er +Ġgrapp ling +ĠDe utsche +agon ists +ĠNew sp +Ġpret ended +arch ment +Ġcur ated +Ġhead phone +ĠUn common +ĠS IGN +A gent +Ġdead lines +Ġhorizont ally +ĠM AT +ĠSum mers +Ġord ained +ĠLast ly +ĠKend all +Ġfr ig +ĠMach ina +ĠWater loo +ĠMex icans +Ġprotect or +Ġgl are +} " +Prem ium +Ġr ift +ĠTelesc ope +Met al +Ġrec apt +Ġ; ; +Ġincl ination +Ġimp oses +ing en +^ { +Ġh aste +Ġd olphins +Ġcomm uters +pl anned +c ong +m x +ĠU pload +Ġext rap +ĠTuc son +ĠExpl oration +efe ated +Ġsl ender +70 3 +ĠB uk +is el +Ġcompet itiveness +ch lor +ĠP ermanent +ĠE verett +ĠSpecial ist +ĠS OL +Ġcy an +ĠEx actly +U F +ĠL IFE +ary l +on et +ĠEmploy ee +aw ed +ĠRat ings +Ġextra vag +ul hu +ĠPl ane +Ġelev ate +ĠCoord inator +ĠWat kins +Ġex cludes +Ġsent ient +Ġep och +Ġall oc +Pre viously +ĠSh y +ĠSlov akia +L OCK +Ġmarked ly +Ġkn ob +Ġadventure rs +ĠBe en +ĠCost s +amm ers +Ġon slaught +ĠSupport ed +ĠT au +ik arp +ĠS overe +ĠHam pton +ãĤ ī +Pre v +ĠW orse +Ġc ottage +ĠH ades +le z +b owl +Ġfrag rance +ĠL ok +EM OTE +ĠPet ro +Ġ19 25 +ĠP end +produ cing +Ġrel ocate +v ati +p ole +Ġsem in +ĠN UM +Ġrock ed +b uff +b ly +Rep ly +ĠH ai +Ġartic ulated +ĠIslam abad +66 5 +ĠClaim s +Des ktop +Ġtrust ee +Ġscript ing +ĠS ob +ĠAs ylum +STD OUT +ĠCl own +ĠD ortmund +ĠDev on +l ite +ĠMar ble +Ġb unker +Ġcre st +Ġarous al +ĠS ears +ĠBudd y +ered ith +ĠP olly +Ġdec ode +ĠV ish +ĠRef lect +an on +Ġrefund s +imm ers +H M +Ġwip ing +Ġpuzz led +Ġmat te +un o +P ierre +) ), +Ġt ainted +Ġsymbol ism +ĠF raz +Ġprotest ors +ethe us +%% %% +W ra +Ġl ax +ad em +atur ation +ãĥ ĵ +ĠTra iler +ĠE NG +ĠBows er +Ġatt m +D ur +80 7 +Ġsid x +Ġc ider +ĠA ffect +Ġw oven +ĠBark er +ben ef +Ġdst g +ĠRy u +> [ +Ġsq or +S audi +Ġis tg +Ġindul ge +pro c +Ġdisg usted +Ġcomp ounded +Ġn em +Ġschool ing +ĠC ure +process ing +S ol +Ġpro verb +it ized +ĠAlv arez +Ġscar f +Ġrect angular +re ve +Ġh ormonal +ĠSt ress +itiz en +Ġ4 25 +girl s +ĠNo ir +ĠR app +Ġmar ches +ch urch +ĠUs es +Ġ40 5 +ĠBer m +Ġord inances +ĠJud gment +Charg es +ĠZ in +Ġdust y +Ġstraw berries +Ġper ce +ĠTh ur +ĠDebor ah +net flix +ĠLam bert +Ġam used +ĠGu ang +Y OU +R GB +ĠC CTV +Ġf iat +r ang +Ġf ederation +ĠM ant +ĠB ust +ĠM are +respect ive +ĠM igration +ĠB IT +59 0 +Ġpatriot ism +Ġout lining +reg ion +ĠJos é +Ġbl asting +ĠEz ra +B s +Ġundermin es +ĠSm ooth +Ġcl ashed +rad io +Ġtransition ing +ĠBucc aneers +ĠOw l +Ġplug s +Ġh iatus +ĠPin ball +Ġm ig +ĠNut r +ĠWolf e +Ġinteg ers +Ġor bits +ĠEd win +ĠDirect X +b ite +Ġbl azing +v r +Ed ge +ĠP ID +ex it +ĠCom ed +ĠPath finder +ĠGu id +ĠSign s +ĠZ er +ĠAg enda +Ġreimburse ment +M esh +i Phone +ĠMar cos +ĠS ites +h ate +en burg +Ġs ockets +p end +Bat man +v ir +ĠSH OW +Ġprovision al +con n +ĠDeath s +AT IVE +Pro file +sy m +J A +Ġnin ja +inst alled +id ates +eb ra +ĠOm aha +Ġse izing +ĠBe asts +Ġsal ts +M ission +Gener ally +ĠTr ilogy +he on +leg ates +Ġd ime +Ġf aire +par able +G raph +Ġtotal ing +Ġdiagram s +ĠYan uk +ple t +ĠMe h +Ġmyth ical +ĠStep hens +aut ical +ochem istry +Ġkil ograms +Ġel bows +anc ock +ĠB CE +ĠPr ague +Ġimpro v +ĠDev in +Ġ" \ +par alle +Ġsuprem acists +ĠB illion +Ġreg imen +inn acle +Ġrequ isite +ang an +ĠBur lington +ain ment +ĠObject ive +oms ky +G V +Ġun ilateral +Ġt c +Ġh ires +ment al +Ġinvol untary +Ġtrans pl +ĠASC II + ¨ +Ev ents +Ġdoub ted +ĠKa plan +ĠCour age +ig on +ĠMan aging +ĠT art +Ġfalse hood +ĠV iolet +Ġair s +Ġfertil izer +Brit ain +Ġaqu atic +ou f +W ords +ĠHart ford +Ġeven ings +ĠV engeance +qu ite +G all +ĠP ret +Ġp df +ĠL M +ĠSo chi +ĠInter cept +9 20 +Ġprofit ability +ĠId le +ĠMac Donald +ĠEst ablishment +um sy +Ġgather ings +ĠN aj +Charl ie +Ġas cent +ĠProt ector +Ġal gebra +Ġbi os +for ums +EL S +Introdu ced +Ġ3 35 +Ġastron omy +Cont ribut +ĠPol ic +Pl atform +Ġcontain ment +w rap +Ġcoron ary +ĠJ elly +man ager +Ġheart breaking +c air +ĠChe ro +c gi +Med ical +ĠAccount ability +! !" +oph ile +Ġpsych otic +ĠRest rict +Ġequ itable +iss ues +Ġ19 05 +ĠN ek +c ised +ĠTr acking +Ġo zone +Ġcook er +ros is +Ġre open +Ġinf inity +ĠPharm aceutical +ens ional +Att empt +ĠR ory +Mar co +Ġawa its +H OW +t reated +Ġbol st +Ġreve red +Ġp ods +opp ers +00 10 +Ġampl itude +ric an +SP ONSORED +Ġtrou sers +Ġhal ves +ĠK aine +ĠCut ler +ĠA UTH +Ġsplend id +Ġprevent ive +ĠDud ley +if acts +umin ati +ĠY in +Ġad mon +ĠV ag +Ġin verted +Ġhast ily +ĠH ague +L yn +Ġled ger +Ġastron omical +get ting +Ġcirc a +ĠC ic +ĠTenn is +Lim ited +Ġd ru +ĠBY U +Ġtrave llers +Ġp ane +ĠInt ro +Ġpatient ly +Ġa iding +Ġlo os +ĠT ough +Ġ29 3 +Ġconsum es +Source File +Ġ"" " +Ġbond ing +Ġtil ted +Ġmenstru al +ĠCel estial +UL AR +Plug in +Ġrisk ing +N az +ĠRiy adh +Ġacc redited +Ġsk irm +é Ľ +Ġexam iner +Ġmess ing +Ġnear ing +ĠC hern +ĠBeck ham +Ġsw apped +Ġgo ose +K ay +Ġlo fty +ĠWal let +Ġ[ ' +Ġap ocalypse +Ġb amboo +ĠSP ACE +ĠEl ena +Ġ30 6 +ac ons +Ġtight ened +Ġadolesc ence +Ġrain y +Ġvandal ism +ĠNew town +Ġcon ject +c akes +Ġche ated +Ġmoder ators +par ams +E FF +Ġdece it +ĠST L +ĠTanz ania +ĠR I +Ġ19 23 +ĠEx ile +the l +Ġthe olog +Ġquir ky +ĠIr vine +Ġneed y +or is +U m +K a +Ġmail box +3 22 +Ġb os +ĠPet ra +K ING +Ġenlarg ed +O ften +Ġbad ass +Ġ3 43 +ĠPl aces +ĠC AD +Ġpr istine +Ġinterven ing +d irection +Ġl az +ĠD SM +Ġproject ing +ĠF unk +ag og +pay ment +n ov +Ġch atter +AR B +Ġexam inations +ĠHouse hold +ĠG us +F ord +4 14 +B oss +Ġmy stic +Ġle aps +ĠB av +ul z +b udget +Foot ball +Ġsubsid ized +Ġfirst hand +Ġcoinc ide +oc ular +Con n +ĠColl abor +Ġfool s +am ura +ah ar +r ists +Ġsw ollen +Ġexp ended +ĠP au +s up +Ġsp ar +Ġkey note +s uff +Ġunequ al +Ġprogress ing +str ings +ĠGamer gate +Dis ney +ĠEle ven +om nia +Ġscript ed +Ġear ners +bro ther +ĠEn abled +æ ³ +Ġlar vae +ĠL OC +m ess +Wil son +ĠTem plate +success fully +Ġparam ount +Ġcamoufl age +Ġbind s +ĠQu iet +ĠSh utterstock +r ush +Ġmasc ot +fort une +ĠCol t +ĠBe yon +hab i +Ġha irc +Ġ26 7 +ĠDe us +Ġtw itch +Ġconcent rating +Ġn ipples +c ible +Ġg ir +N Z +M ath +n ih +Requ ired +Ġp onder +ĠS AN +Ġwedd ings +Ġl oneliness +N ES +ĠMah jong +69 5 +add le +ĠGar ner +ĠC OUR +Br idge +Ġsp ree +ĠCald well +Ġbri bery +Ġ���� ���� +plug ins +Ġr acket +Ġchamp agne +vers ible +V ote +Ġmod ifiers +May or +6 80 +Ġassemb lies +ĠS ultan +ĠN ing +ĠLad ies +Ġsulf ur +Ġor bs +Ġ---- - +____ ___ +ĠJournal ism +Ġes ports +Ġl ush +Ġh ue +Ġspect ral +H onest +ãĥ ı +Ġbus hes +Ġrein forcement +Ġre opened +ĠWhe els +ĠM org +rie ving +Ġaux iliary +Ġj Query +ĠB AT +tes que +Ġver tex +p ure +f rey +ãĤ º +d os +Ġty ph +Ġc ull +Ġe q +Ġdec on +Ġtoss ing +Ġdispar ate +ĠBr igham +print f +led ged +Ġsu nd +Ġco zy +Ġhepat itis +per forming +Ġav al +ĠG G +f uture +Ġpet ertodd +ĠKos ovo +Ġmagn ets +Al ready +ĠEd ison +ĠCe res +ĠRA ID +Ġbrill iance +57 6 +Ġder ives +Ġhypert ension +ĠÎ Ķ +Ġlamb da +Ġfl air +Ġmission aries +Ġrap es +ĠSt arter +ĠMon ths +Ġdef y +Ġseism ic +ĠR aphael +Ġeuro zone +65 6 +z sche +Ġscr atched +Ġb ows +ĠLenn on +ĠGa ia +Ġdri pping +f acts +A le +Ġfrog s +ĠBre ast +ogene ity +ĠProsecut or +Ġampl ified +ĠHod g +ĠF n +Th ousands +ĠNI H +ĠMonitor ing +FT WARE +ĠPri ebus +ĠG rowing +hun ter +Ġdiagn ose +ĠM ald +ĠL R +Ġcrown ed +Ġburst ing +Ġdiss olution +j avascript +Ġuseful ness +ĠExec ution +: ( +ĠIv ory +a ah +Ġpersecut ed +viol ence +ist as +ĠCr ate +Ġimpuls es +ĠSp ani +ed es +Hand le +ĠZ erg +think able +Last ly +Ġspont aneously +Ġinconven ient +Ġdismiss ing +Ġpl otted +Ġeight y +Ġ7 37 +r ish +ĠThor nton +ath am +Ġsit com +V en +Rec ipe +t el +l und +Ġcle ars +ĠSas uke +Ġ25 8 +Ġopt ing +Ġen raged +est hetic +ĠA e +uch s +Pre p +Fl ow +Ġrun off +ĠE ating +ĠG iles +ĠAct ing +res ources +ib aba +Ġr pm +Ġske wed +ĠBl anc +ĠS akuya +Ġhot ter +Ġ19 24 +op ian +ck o +Ġcr umbling +Ġcapt ains +ĠAppropri ations +le aders +dro pping +an uts +Ġrevers ing +ĠP ose +ĠS ek +Sc ot +ĠIde a +c ise +ĠSloven ia +Ġ3 17 +Do ctor +Ġcro cod +ald i +Se a +ĠFar rell +Ġmerc enaries +ĠR NC +ĠGu ess +Ġp acing +M achine +Streamer Bot +ĠChar ity +Ġ29 8 +Ġcann ons +ĠTob y +TPP StreamerBot +ĠPass ion +cf g +Th om +Ġbad ges +ĠBern stein +. âĢĵ +ĠP OP +ĠCon j +Ġinitial ization +Ġbiod iversity +D ub +Ġfeud al +Ġdisclaim er +Ġc row +Ġign ition +ar f +S HA +Ġk Hz +h azard +ĠArt ists +oe uv +67 9 +ĠRud y +N ine +ĠRam adan +å ½ +itt o +Ġadren aline +C ert +Ġsmell ed +Ġimp unity +Ġag endas +ĠRe born +ĠCon cent +ĠSe ems +Ġo mega +ĠDust in +Ġback er +ĠSau ce +ĠBoy le +W IN +Ġsp ins +Ġpa uses +u pt +Ġshred ded +Ġstra pped +ĠCor ruption +Ġscr atches +Ġn i +Ġatt ire +ĠS AF +Factory Reloaded +ĠI PS +Ġ( % +Ġsem inar +f ocus +c ivil +Ġ18 60 +int osh +Ġcontin ual +Ġabbre vi +ĠS ok +oc obo +X M +Ġfr antic +Ġunavoid able +Ġar tery +Ġannot ations +b ath +Cl imate +Ġd ors +ĠSl ide +co ord +ĠRel oad +ĠL DL +ĠLove craft +Ġunim agin +Ġresemb led +Ġbarr acks +n p +Ġsurrog ate +Ġcategor ized +ãĤ © +Ġvacc inated +Ġdrain age +Ġind ist +ĠWhats App +Ġ18 70 +oler ance +inv oke +am orph +Ġrecon nect +Ġem anc +Ġblind ness +Ġ12 80 +intern et +c ollar +Ġalt ru +Ġab yss +ĠT RI +65 7 +Ġinf used +HE AD +Ġforest ry +ĠWood y +ĠC i +w i +s am +78 4 +hol iday +Ġmog ul +ĠF ees +ĠD EN +In ternal +ur bed +f usc +at om +ĠIll usion +Ġpoll ed +Ġfl ap +Ġco ax +L GBT +An aly +ĠSect ions +ĠCalif orn +em n +Ġh ither +ĠN IGHT +Ġn ailed +ĠPip eline +39 1 +o of +ĠPr imal +vere nd +Ġsl ashing +Ġret ri +avi our +Ġdepart ing +g il +IS C +Ġmid way +Ġultras ound +Ġbeh aving +ĠT ara +class es +V irtual +ĠColon ial +Ġstri pping +Ġorchestr ated +ĠGra ves +45 2 +ĠIron ically +ĠWrit ers +Ġl ends +ĠMan z +Ġra ven +Ġoxid ative +Ġ26 6 +EL F +act ually +asc ar +D raft +Ġfavour able +Ġhumili ating +Ġf idelity +ĠH of +ĠX uan +49 6 +Ġlay ered +at is +79 0 +Ġpay check +it on +K ar +ĠVM ware +ĠFar mer +Ġserv ic +gl omer +Ġsl ump +ĠFab ric +ĠD OC +est ing +Ġreass ure +Ġph yl +v olt +it ory +R ules +Ġoxid ation +Ġpri zed +Ġmist ress +ĠDj ango +WAR N +å ij +Ġenc ode +ĠFeed back +Ġstupid ity +I an +ĠYugoslav ia +× ¨ +ac l +UT E +19 77 +Ġqual ifies +Ġpuls es +pret ty +Ġfro ze +Ġs s +Iter ator +Ġur gently +Ġm ailed +ĠCh am +Ġsust aining +Ġbas il +Ġpupp ies +il ant +ĠP LEASE +l ap +ace ous +F ear +ĠMaster y +aut omatic +ĠT AG +Ġant im +ag les +47 3 +fram es +Ġwh ispers +ĠWho ever +Ġbra very +ĠUK IP +ract ions +"" " +Ġt ame +Ġpart ed +every thing +CON T +Ġind ebted +Ġadd r +re k +IR ED +Ġem inent +cl inton +Ġo usted +Ġreview er +Ġmelt down +Ġre arr +ĠY ao +the real +aby te +Ġst umbling +Ġbat ches +Ġ25 9 +Ġcontrace ptive +Ġprost itute +ens is +De cl +ĠSt rikes +M ilitary +ĠO ath +v acc +pp ings +05 2 +Ġpart Name +amp ing +Rep orts +K I +CH R +Ġsubt ly +sw ers +Bl ake +us ual +Ġcontest ants +Ġcart ridges +ĠGRE AT +Ġbl ush +ĠâĢ º +47 2 +Ġreason ed +ãĥ ¤ +paralle led +Ġd yn +ag ate +Ġnight ly +å Ĩ +55 6 +Ġsem antic +ĠAdv oc +Ġ !! +Ġdisag rees +ĠB W +V eh +Ġharm ing +Ġembr aces +Ġstri ves +Ġin land +ĠK ard +Ġhe ats +ĠGin ny +ut an +ern aut +yl ene +ĠE lev +J D +Ġh ars +ĠStar r +Ġsk ysc +Ġcollabor ators +Us ually +Ġrev olutions +ĠSTAT S +Ġdism antle +Ġconfident ly +Ġkin etic +Al i +Ġpercent ile +Ġextract ing +ill ian +est ead +Ġphysic ists +ĠMarsh al +Ġfell owship +Ġd ashed +ĠU R +ĠSi oux +ĠComp act +am ide +P ython +ĠLe igh +ĠPharm ac +ist rates +her ical +Ġf ue +ĠE min +Ġ( { +ĠNeighbor hood +Ġdisrupt ing +ĠD up +Ġg land +ĠSe v +ĠMar ian +arg on +ĠD und +Ġ< !-- +Ġstr and +Ġstadium s +z os +Ġpsych osis +ĠR ack +Ġbrilliant ly +ï¸ ı +Ġsubmer ged +ĠInst it +ĠCh ow +Ġc ages +ĠH ats +ĠU rs +Ġdil uted +us at +ien ne +ĠMembers hip +ĠBur k +Ġ ie +Ġarche type +D rug +ult on +ĠSp ock +ĠMcK ay +ĠDep end +F eatured +S oc +19 78 +ĠB ere +Ġrelent lessly +Ġcripp ling +Ġar thritis +çĶ Ł +ĠTrop ical +ĠBul g +ĠCher yl +Ġadm irable +Ġsub title +Over ride +Ġorig inating +ĠC CP +Ġsw ore +ĠSo le +ĠDis orders +3 29 +Ġprocess ion +Ġref urb +Ġimm ersed +requ ently +Ġskept ics +Ġcer amic +m itter +en stein +b elt +ĠT IT +b idden +Ġf ir +m ist +> ] +Ġwe ave +ĠParad ox +Ġentr usted +ĠBarcl ays +Ġnovel ist +og ie +80 6 +Ġnin ety +Ġdisag reements +@@@@ @@@@ +ĠAus chwitz +c ars +ĠL ET +t ub +arant ine +P OS +Ġback story +Ġcheer ful +ĠR ag +ek a +bi ased +Ġinexper ienced +ak ra +ĠW itt +t an +Ġrap ist +Ġplate au +ch al +ĠInqu is +exp ression +Ġc ipher +Ġsh aving +add en +re ly +( \ +ism a +ĠReg ulatory +CH AR +ily n +N VIDIA +G U +Ġmur m +la us +Christ opher +Ġcontract ual +ĠPro xy +ĠJa ime +ĠMethod ist +Ġstew ards +st a +per ia +Ġphys iology +Ġbump ed +Ġf ructose +Austral ian +ĠMet allic +ĠMas querade +ar b +Ġprom ul +Ġdown fall +Ġbut cher +Ġb our +ĠIN FORMATION +ĠB is +pect s +ad ena +Ġcontempl ating +ar oo +cent ered +ĠPe aks +Us ed +Ġmod em +Ġg enders +Ġ8 000 +37 1 +Ġm aternity +ĠR az +Ġrock ing +Ġhandgun s +ĠD ACA +Aut om +ĠN ile +Ġtum ult +ĠBenef it +ĠAppro ach +works hop +ĠLe aving +G er +inst ead +Ġvibr ations +Ġrep ositories +49 7 +ĠA unt +ĠJ ub +ĠExp edition +Al pha +Ġs ans +Ġoverd ue +Ġoverc rowd +Ġlegisl atures +Ġp aternal +ĠLeon ardo +Ġexp ressive +Ġdistract ions +Ġsil enced +tr ust +Ġb iking +Ġ5 60 +Ġpropri et +Ġimp osition +Ġcon glomer +Ġ= ================================================================ +ĠTe aching +ĠY ose +int ensive +T own +Ġtroll ing +ĠGr ac +ĠAS US +Y o +Ġspecial s +ĠNep h +ĠGod zilla +Dat abase +ĠHe gel +Ġ27 2 +19 76 +ĠGl oria +Ġdis emb +ĠInvestig ations +ĠB ane +ag ements +St range +Ġtre asury +ĠPl ays +Ġundes irable +Ġwid ening +Ġverb ally +Ġinf ancy +Ġcut ter +f ml +Ġ21 00 +prot otype +f ine +Ġdec riminal +Ġdysfunction al +Ġbes ie +ĠErn st +z eb +Ġnort heastern +Ġa ust +por ate +ĠMar lins +Ġsegreg ated +ew orld +ĠMa her +Ġtra verse +Ġmon astery +ur gy +G ear +s and +Com pl +ĠE MP +Ġpl ent +ĠMer cer +Ġ27 6 +TA BLE +Config uration +H undreds +Ġpr ic +Ġcollabor ating +ĠPar amount +ĠCumm ings +Ġ( < +Ġrecord er +Ġfl ats +Ġ4 16 +wh ose +Font Size +ĠOr bit +Y R +Ġwr ists +Ġb akery +) } +ĠB ounty +ĠLanc aster +Ġend ings +acc ording +ĠSal am +e asy +75 5 +ĠBur r +ĠBarn ett +onom ous +Un ion +Ġpreced ence +ĠScholars hip +ĠU X +Ġroll out +Ġbo on +al m +ĠCan ter +æ µ +Ġround ing +Ġcl ad +Ġv ap +ĠF eatured +is ations +Ġ5 40 +pol ice +Ġunsett ling +Ġdr ifting +ĠLum ia +ĠObama Care +ĠF avor +Hy per +ĠRoth schild +ĠMil iband +an aly +ĠJul iet +H u +Ġrec alling +a head +69 6 +Ġunf avorable +Ġd ances +O x +Ġleg ality +Ġ40 3 +rom ancer +Ġinqu ire +ĠM oves +\ "> +ĠVari ant +ĠMess iah +ĠL CS +ĠBah á +75 6 +Ġeyeb row +Ġ ¥ +ĠMc F +ĠFort y +M as +Ġpan icked +Ġtransform ations +q q +Ġrev olves +ring e +ĠA i +ax e +Ġon ward +ĠC FR +ĠB are +log in +Ġliqu ids +Ġde comp +second ary +il an +ĠCon vert +ami ya +Ġprosecut ing +Ġâī ¡ +ĠYork ers +ĠByr ne +sl ow +aw ei +J ean +Ġ26 9 +ĠSky dragon +Ġ é +ĠNicarag ua +ĠHuck abee +ĠHigh ly +Ġamph ib +ĠPast or +ĠL ets +Ġbl urred +Ġvisc eral +ĠC BO +Ġcollabor ated +z ig +Leg al +Ġapart heid +Ġbr id +Ġpres et +ĠD ET +ĠAM A +× Ķ +arch ing +auc uses +build er +Ġpo etic +Ġem ulator +ĠMole cular +Ġhon oring +ise um +Ġtract or +ĠCl uster +ĠCal m +ared evil +Ġsidew alks +Ġviol in +Ġgeneral ized +ĠAle c +Ġemb argo +Ġfast ball +ĠHT TPS +ĠL ack +ĠCh ill +ri ver +C hel +ĠSw arm +ĠLev ine +ro ying +L aunch +Ġkick er +Ġadd itive +ĠDe als +W idget +cont aining +Ġescal ate +ĠOP EN +Ġtwe aked +Ġst ash +Ġsp arks +ĠEs sex +ĠE cc +Ġconv ict +Ġblog ging +I ER +ĠH L +Ġmurd erers +75 9 +ĠH ib +Ġde pl +ĠJ ord +S ac +Ġdis sect +ĠHow e +os her +Ġcustom izable +ĠFran z +Ġat ro +Ä ĩ +Ġ000 4 +Ġout post +R oss +Ġglyph osate +ĠHast ings +ĠBE FORE +Ġsh ove +o pped +ĠSc ala +Ġam ulet +an ian +Ġexacerb ated +Ġe ater +47 1 +UM E +Ġpul p +izont al +ĠZ am +ĠAT I +imm une +aby tes +Ġunnecess arily +ĠC AT +ĠAx is +Ġvisual ize +à ī +ĠRad ical +f m +Doc uments +ĠFor rest +Ġcontext ual +ĠSy mbol +Ġtent ative +ĠDO ES +ĠGood s +Ġintermitt ent +} : +medi ated +Ġridic ule +Ġathe ism +Ġpath ogens +ĠM um +Ġre introdu +Ġ30 7 +i HUD +Ġflash light +Ġsw earing +Ġp engu +B u +Ġrot ated +ĠCr ane +Ġ() ); +Ġfashion able +Ġendors ing +46 3 +) [ +Ġingest ion +Ġcook s +Ġ9 50 +ot omy +ĠIm am +Ġk a +Ġte aser +ĠGhost s +ĠãĤ µ +19 69 +Ï ĥ +ub by +Ġconver ter +zan ne +end e +ĠPre par +ĠNic kel +ĠChim era +h im +ĠTyr ann +ĠSabb ath +ĠNich ols +Ġra pt +ih ar +Ġshe lling +Ġillum inate +Ġdent ist +ut or +ĠInteg ration +Ġwh ims +ĠLiter ary +Be aut +Ġp archment +ag ara +Br and +Ġder og +âĢ¦ ) +ĠNor se +Ġunw itting +Ġc uc +Ġborder line +Ġupset ting +Ġrec ourse +Ġd raped +ĠRad ar +Ġcold er +ĠPep si +im inary +], [ +65 8 +V i +ĠF rem +ĠP es +Ġveter inary +ĠT ED +ĠEp idem +n ova +k id +Ġdev out +o ct +j ad +M oh +ĠP AY +Ġge ometric +Ġ3 23 +Ġcircum ference +ich ick +19 75 +ĠY uri +ĠSh all +ĠH over +un in +S pr +Ġg raft +ĠHapp iness +Ġdisadvant ages +att acks +Ġhub s +ĠStar Craft +é ĸ +Ġgall eries +ĠKor ra +Ġgrocer ies +ĠGors uch +Ġrap ists +Ġfun gi +ĠTyph oon +V ector +ĠEm press +b attle +4 68 +Ġparas ite +ĠBom ber +S G +ex ist +ĠP f +Ġun se +Ġsurge ons +B irth +ĠUn sure +ĠPrint ed +ĠBehavior al +ĠA ster +Pak istan +Ġun ethical +Ġs v +ĠIo T +Ġlay outs +P ain +Ġconst ants +ĠL W +ĠB ake +Ġtow els +Ġdeterior ation +ĠBol ivia +Ġblind ed +ĠW arden +ĠMist ress +Ġon stage +Ġcl ans +ĠB EST +19 60 +Ġant ique +Ġrhet orical +ĠPer cy +ĠRw anda +, . +B ruce +Ġtra umat +ĠParliament ary +Ġfoot note +id ia +ĠLear ned +se eking +gen ic +Ġdim ensional +H ide +èĢ ħ +Ġintrig ue +in se +Ġle ases +Ġapp rentices +w ashing +Ġ19 26 +V ILLE +Ġsw oop +s cl +Ġbed rooms +on ics +ĠCr unch +comp atible +Ġincap ac +ĠYemen i +ash tra +z hou +d anger +Ġmanifest ations +ĠDem ons +AA F +Secret ary +ACT ED +L OD +Ġam y +ra per +eth nic +4 17 +Ġpos itives +Ġ27 3 +ĠRefuge es +Ġus b +ĠV ald +odd y +ĠMahm oud +As ia +Ġskull s +ĠEx odus +ĠComp et +ĠL IC +ĠM ansion +ĠA me +Ġconsolid ate +storm s +ont ent +99 6 +Ġcl en +Ġm ummy +fl at +75 8 +ĠV OL +oter ic +n en +ĠMin ute +S ov +Ġfin er +R h +ly cer +Ġreinforce ments +ĠJohann es +ĠGall agher +Ġgym n +S uddenly +Ġext ortion +k r +i ator +T a +Ġhippocamp us +N PR +ĠComput ing +Ġsquare ly +Ġmod elling +ĠFor ums +ĠL isp +ĠKrish na +Ġ3 24 +Ġr ushes +Ġens ued +Ġcre eping +on te +n ai +il ater +ĠHorn ets +Ġob livious +IN ST +55 9 +Ġjeopard y +Ġdistingu ishing +j ured +Ġbeg s +sim ilar +ph ot +5 30 +ĠPark way +Ġs inks +ĠHearth stone +ib ur +ĠBat on +Av oid +Ġd ancer +Ġmag istrate +ary n +Ġdisturb ances +ĠRom ero +Ġpar aph +Ġmis chief +âĸ ĵ +ĠSh aria +Ġur inary +r oute +iv as +f itted +Ġeject ed +ĠAl buquerque +Ġ4 70 +Ġirrit ated +ĠZ ip +ĠB iol +à į +Ġden ounce +Ġbin aries +ĠVer se +Ġopp os +ĠKend rick +ĠG PL +Ġsp ew +ĠEl ijah +ĠE as +Ġdr ifted +so far +Ġannoy ance +ĠB ET +47 4 +ĠSt rongh +it ates +ĠCogn itive +oph one +ĠIdent ification +ocr ine +connect ion +Ġbox er +ĠAS D +ĠAre as +Y ang +t ch +ull ah +Ġdece ive +Comb at +ep isode +cre te +W itness +Ġcondol ences +ht ar +Ġhe als +Ġbuck ets +ĠLA W +B lu +Ġsl ab +ĠOR DER +oc l +att on +ĠSteven son +ĠG inger +ĠFriend ly +ĠVander bilt +sp irit +ig l +ĠReg arding +ĠPR OG +Ġse aling +start ing +Ġcard inal +ĠV ec +ĠBe ir +Ġmillisec onds +we ak +per se +Ġster ile +ĠCont emporary +ĠPh ant +ĠCl o +Ġout p +Ġex iled +Ġ27 7 +Ġself ie +Ġman ic +Ġn ano +ter ms +Alex ander +Ġres olves +Ġmillenn ia +Ġexpl odes +Ġconst ellation +Ġadul tery +m otion +D OC +Ġbroad casters +Ġkinderg arten +ĠMay weather +ĠE co +ich o +Ġ28 7 +l aun +Ġm ute +Ġdisc reet +Ġpres chool +Ġpre empt +De lete +ĠFre ed +P i +H K +Ġblock er +ĠC umber +Ġw rought +d ating +Ġins urer +Ġquot as +Ġpre ached +Ġev iction +ĠReg ina +ĠP ens +Ġsevent een +ĠN ass +D ick +Ġfold s +Ġd otted +ĠA ad +Un iversal +Ġp izz +ĠG uru +Ġso ils +Ġno vice +ĠNe ander +Ġst ool +Ġdeton ated +ĠPik achu +ĠMass ive +IV ER +ĠAb del +Ġsubdu ed +Ġtall est +Ġprec arious +Ġa y +r ification +ĠOb j +c ale +Ġun question +cul osis +ad as +igr ated +D ays +Ġque ens +ĠGaz ette +ĠCol our +ĠBow man +ĠJ J +ï ve +Ġdomin ates +Stud ent +Ġm u +Ġback log +ĠElect ro +Tr uth +48 3 +Ġcond ensed +r ules +ĠCons piracy +Ġacron ym +hand led +ĠMat te +j ri +ĠImp ossible +l ude +cre ation +Ġwar med +ĠSl ave +Ġmis led +Ġfer ment +ĠK ah +ink i +ke leton +cy l +ĠKar in +Hun ter +Reg ister +ĠSur rey +Ġst ares +ĠW idth +ĠN ay +ĠSk i +Ġblack list +uck et +Ġexp ulsion +im et +Ġret weet +vant age +Fe ature +Ġtro opers +Ġhom ers +9 69 +Ġconting ency +ĠW TC +ĠBrew er +fore ign +W are +S olar +Ġund ue +RE C +ulner able +path ic +ĠBo ise +Ġ3 22 +Ġarous ed +ĠY ing +ä¸ į +uel ess +Ġp as +Ġmor p +Ġfl oral +Ex press +ud ging +k B +ĠGr anted +Ø ¯ +ĠMich a +ĠGoth ic +ĠSPEC IAL +ĠRic ardo +F ran +Ġadminister ing +6 20 +por a +Ġ ® +Ġcomprom ises +Ġb itten +Ac cept +Th irty +Ð ² +Ġmater ially +ĠTer r +ig matic +ch ains +Ġdo ve +stad t +Mar vel +FA ULT +Ġwind shield +Ġ3 36 +ad ier +Ġsw apping +Ġflaw less +ĠPred ator +ĠMiche le +Ġprop ulsion +ĠPsych ic +Ġassign ing +Ġfabric ation +Ġbar ley +l ust +Ġtow ering +Ġalter cation +ĠBent ley +Sp here +Ġtun a +ĠClass es +Fre edom +un er +L ady +v oice +Ġcool est +or r +Ġpal p +$ { +Ġhyster ia +ĠMet atron +p ants +Ġspawn ing +Exper ts +ĠInvest ors +ĠAn archy +Ġshr unk +ĠVict im +Ġ28 9 +Ġec stasy +ĠB inding +58 5 +ĠMel ody +57 8 +ot ally +ĠE tsy +lig a +Ġapplaud ed +Ġswe ating +Ġredist ributed +Ġpop corn +Ġsem inal +f ur +ĠNeuro science +R and +ĠO st +ĠMadd en +ĠIncre asing +ĠDaw kins +ĠSub way +Ġar sen +cons erv +B UR +Ġsp iked +ĠLy ft +ĠImper ium +ĠDrop box +Ġfav oured +Ġencomp asses +gh ost +Ġins pires +Ġbur geoning +ĠY oshi +ĠVert ical +ĠAud itor +Ġint ending +Ġfilib uster +Bl oom +f ac +ĠCav s +ign ing +Ġcowork ers +ĠBarb arian +rem ember +FL AG +Ġaudit ory +ason ry +Col lege +Ġmut ed +gem ony +ob in +ĠPsych o +9 68 +Ġlav ish +Ġhierarch ical +ĠDr one +ou k +Ġcripp led +ĠMax im +Sl ot +Ġqu iz +ĠV id +if ling +Ġarchae ologists +Ġabandon ment +d ial +le on +ĠF as +T ed +Ġr aspberry +Ġmaneu vers +Ġbehavi ours +Ġins ure +Ġrem od +Sw itch +h oe +Ġsp aced +Ġafford ability +ĠF ern +not ation +ĠBal anced +Ġoccup ies +en vironment +Ġneck lace +Ġsed an +F U +ĠBrav o +Ġab users +ĠAn ita +met adata +ĠG ithub +ait o +ĠF aster +ĠWass erman +ĠF lesh +Ġth orn +r arily +ĠMer ry +w ine +Ġpopul ace +ĠL ann +Ġrepair ing +Ġpsy che +Ġmod ulation +aw aru +âĢĭ âĢĭ +ari j +Ġdecor ations +Ġapolog ise +ĠG arg +app ly +Ġgive away +ĠFl an +ĠWy att +U ber +Ġauthor ised +ĠMor al +HAHA HAHA +activ ate +Ġtorped o +ĠF AR +Ġam assed +ĠA ram +ark in +ĠVict ims +st ab +Ġo m +ĠE CO +Ġopio ids +Ġpurpose ly +ĠV est +Ġer g +at an +ĠSur gery +Ġcorrect ing +ĠOrt iz +ĠBe et +Ġrev oke +Ġfre eway +ĠH iggins +F ail +ĠFar ms +ĠAT P +h ound +Ġp oking +ĠCommun ists +mon ster +iment ary +Ġunlock ing +Ġunf it +we ed +en ario +at ical +ĠEnlight enment +ĠN G +ĠComp ensation +de en +ĠWid ow +ĠCind y +ĠAfter wards +Ġ6 000 +ikh ail +ag ically +Ġrat ified +Ġcasual ty +H OME +p sey +f ee +Ġspark ling +Ġd é +Ġconcert ed +C atal +Ġcomp lying +ĠA res +ĠD ent +Sh ut +Ġsk im +ad minist +Ġhost ilities +ĠG ins +Ġ6 08 +Ġm uddy +ĠMc Int +ĠDec ay +5 25 +Ġconspic uous +ĠEx posure +Ġresc ind +Ġwear able +Ġ3 28 +our met +ah s +ĠRob ots +Ġe clips +inst ance +ĠRE PORT +ĠApp l +0 30 +ĠSk ies +01 00 +Ġfall acy +S ocket +ĠRece iver +Ġsol ves +ĠButter fly +ĠSho pping +ĠFI RE +65 4 +Med ic +Ġsing ers +ĠNeed less +'' '' +isher s +ĠD ive +58 8 +Ġselect ively +Ġcl umsy +88 9 +Ġpurch aser +ear ned +ard y +Ġbenef iting +eng lish +Ġyield ing +ĠP our +Ġspin ach +Ġdel ve +ĠC rom +6 10 +Ġexport ing +ĠMA KE +Ġ26 3 +Ġg rop +Ġenv oy +ĠInqu iry +ĠLu igi +d ry +ĠT uring +Thumbnail Image +ĠVar iety +Ġfac et +Ġfl uffy +Ġexcerpt s +Ġsh orth +ĠOl sen +CL UD +Ġrel iant +ĠUN C +T our +Ġbat hing +Comp any +Ġglobal ization +P red +ĠMalf oy +Ġh oc +j am +craft ed +ĠBond s +ĠKiss inger +Eng land +Ġorder ly +cat entry +Ġ26 1 +Ġexch anging +ĠInt ent +ĠAmend ments +D OM +Ġst out +³³³³³³³³ ³³³³³³³³ +ĠAir bus +Ġ27 8 +hy de +P oll +Item ThumbnailImage +Ġlooph oles +ĠPill ar +Ġexpl or +St retch +A part +Ġun married +Lim it +ĠTransform ers +Ġintellect ually +unct ure +18 00 +Ġd arn +B razil +Ġleft over +ber us +f red +Mine craft +3 26 +ĠForm s +Ġproof s +ĠDes igned +Ġindex es +ĠSupp ose +EM S +ĠL oving +ĠBon nie +im ating +OT US +Ġconduct or +Ġbehav ed +ĠF ren +Ġsy nerg +Ġmillenn ium +Ġcater ing +ĠL auder +W r +ĠY iannopoulos +ĠAT F +Ġensl aved +Ġawaken ed +D VD +ĠED ITION +ĠConc ert +ĠChall enger +ĠH aku +umer ic +Ġdep recated +ĠSH AR +4 12 +Ġdy stop +Ġtremb ling +Ġdread ed +ĠSp ac +p adding +Re pl +ĠG arrison +M ini +Ġun paralleled +am ar +URR ENT +w reck +c ertain +t al +ĠC LS +app ings +Ġsens ed +Ġf encing +ĠPas o +ĠDes k +Ġsc off +Ġcontem plate +ĠL iga +l iquid +75 7 +Ġapp rentice +ĠUCH IJ +5 70 +ĠTh ousand +ĠIll um +Ġchampion ed +ãĤ Į +Ġelect ors +Ġ3 98 +ĠH ancock +round ed +ĠJ OHN +Ġuns atisf +Ġqual ifier +ĠGad get +EN E +Ġdead liest +ĠPl ants +Ġ ions +Ġacc ents +Ġtwe aking +Ġsh aved +F REE +ĠCh aser +Again st +9 60 +Ġmeth amphetamine +Ġnormal ized +Ġ$ \ +ĠPre cision +ĠGu am +Ġch oked +ĠX II +ĠCast ing +Tor rent +Ġscal p +ĠJagu ar +w it +Ġsem ic +ix ie +ĠG ould +Ġconf ines +N usra +ĠL on +ĠJ ugg +y cle +ĠCod ec +E gypt +Ġrest rain +ĠAl iens +Ġch oking +ĠD unk +ĠBell a +ab c +Ġsl ang +Ġneuro trans +s av +Ġempower ment +â ĨĴ +Ġclim bers +ĠM im +ĠF ra +ros se +Cap ital +ĠCth ulhu +Inter face +Ġprof icient +ĠIN TO +Ġ3 18 +ront al +5 80 +ĠDes pair +K enn +Ġscrim mage +ĠCo at +as ions +Ġwall paper +ĠJ ol +Ġresurg ence +Ġant iv +ĠB alls +² ¾ +Ġbuff ers +Ġsub system +ĠSt ellar +ĠL ung +A IDS +Ġerad icate +Ġblat antly +Ġbehav es +ĠN un +Ġant ics +ex port +DE V +w b +Ġph p +ĠInteg rity +Ġexplore r +Ġrev olving +auth ored +g ans +Ġbas k +Ġas ynchronous +å į +TH ING +69 8 +G ene +ĠR acer +ĠN ico +iss ued +Ġser mon +p ossibly +Ġsize of +Ġentrepreneur ial +ox in +ĠMin erva +Ġpl atoon +n os +ri ks +A UT +ĠAval anche +ĠDes c +ij 士 +ĠP oc +Ġconf erred +Î » +Ġpat ched +F BI +66 2 +Ġfract ures +Ġdetect s +Ġded icate +Ġconstitu ent +Ġcos mos +W T +Ġswe ats +Ġspr ung +b ara +s olid +Ġuns us +Ġbul ky +ĠPhilipp e +ĠFen rir +Ġtherap ists +ore al +^^ ^^ +Ġtotal ed +Ġboo ze +ĠR PC +Prosecut ors +Ġdis eng +ĠSh ared +Ġmotor cycles +Ġinvent ions +Ġlett uce +ĠMer ge +ĠJ C +Ġspiritual ity +ĠWAR NING +Ġunl ucky +ĠT ess +Ġtong ues +ĠD UI +T umblr +Ġle ans +Ġinv aders +Ġcan opy +ĠHur ricanes +ĠB ret +ĠAP PLIC +id ine +ick le +Reg arding +Ġve ggies +Ġe jac +ju ven +F ish +D EM +ĠD ino +Th row +ĠCheck ing +be ard +( & +Ġj ails +Ġh r +trans fer +iv ating +Ġfle ets +ĠIm ag +ĠMc Donnell +Ġsnipp et +Is a +ĠCh att +ĠSt ain +ĠSet FontSize +ĠO y +ĠMathemat ics +49 4 +Ġelectro ly +ĠG ott +ĠBr as +B OOK +ĠF inger +d ump +Ġmut ants +Ġrent als +Ġinter tw +Ġc reek +ail a +Bro ther +ĠDisc ord +pe e +raw ler +Ġcar p +Ġ27 9 +ãĤ· ãĥ£ +rel ations +Ġcontr asts +Col umn +Ġrec onnaissance +Ġun know +Ġl ooting +Ġregul ates +Ġopt imum +ĠChero kee +ĠA ry +Lat est +Ġroad side +Ġd anced +ĠUnic orn +A cknowled +Ġuncont roll +ĠM US +at io +ch ance +ha ven +VAL UE +Ġfavour ites +Ġceremon ial +b inary +pe ed +wood s +EM P +Ġv ascular +Ġcontempl ated +Ġbar ren +ĠL IST +Y ellow +ospons ors +Ġwhisk y +ĠM amm +ĠDeV os +min imum +H ung +44 2 +P ic +ĠSnap dragon +77 6 +Ġcar ving +Ġund ecided +Ġadvantage ous +Ġpal ms +ĠA Q +Ġst arch +L oop +Ġpadd le +Ġfl aming +ĠHor izons +An imation +bo ost +Ġprob abilities +ĠM ish +Ġex odus +ĠEditor ial +Ġfung us +Ġdissent ing +ĠDel icious +rog ram +ĠD yn +d isk +t om +Ġfab rics +ĠC ove +ĠB ans +Ġsoft en +ĠCON S +Ġin eligible +Ġestim ating +ĠLex ington +pract ice +of i +Ġshe dding +ĠN ope +Ġbreat hed +ĠCorinth ians +y ne +ek i +B ull +Ġatt aching +reens hots +Ġanaly se +ĠK appa +Ġuns ustainable +Ġinter pol +ank y +he mer +Ġprot agonists +Ġform atted +ĠBry ce +ĠAch illes +ĠAb edin +sh ock +Ġb um +b os +qu a +ĠW arn +q t +ĠDi abetes +8 64 +ĠIn visible +Ġvan ish +Ġtrans mitting +Ġmur ky +ĠFe i +Ġawa ited +ĠJur assic +umm ies +Ġmen acing +g all +C ath +B uilt +ild o +ĠV otes +Ġon t +Ġmun itions +ĠFre em +ÃŃ n +Ġdec ency +lo pp +ie ved +ĠG ord +Ġun thinkable +ĠNews week +Ġ3 21 +He at +Ġpresent er +ji ang +Ġpl ank +ĠAval on +Ġben z +ĠR out +Ġslam ming +ĠD ai +ou ter +ĠCook ie +ĠAlic ia +ge y +Ġvan ity +Ġow l +á µ +t ested +ĠAw akens +Ġcan v +Ġblind ly +ĠRid ley +ĠEm ails +Requ ires +ĠSer bian +ograp hed +if rame +eter ia +Ġaltern ating +qu iet +Ġsoc iology +ĠUn lock +ĠCommun ism +Ġo ps +Ġatt ribution +Ġab duction +ĠAb ram +Ġsidel ined +ĠB OOK +Ġref ining +ĠFe eling +ĠOs lo +ĠPru itt +r ack +ang ible +Ġcaut iously +ĠM ARK +eed s +M ouse +ĠStep h +ĠP air +S ab +99 7 +ĠBa al +B ec +Ġcomm a +ĠP all +ĠG ael +Ġmisunder stand +ĠP esh +Order able +Ġdis mal +ĠSh iny +% " +Ġreal istically +Ġpat io +ĠG w +ĠVirt ue +Ġexhaust ing +wh atever +oph ys +y ip +4 18 +Ad just +ĠWa iting +ess on +ĠMaz da +ĠDo zens +Ġstream lined +Ġincompet ence +ĠM eth +Ġeth os +ON ES +Ġincent iv +Ġgr itty +ĠBut cher +Head er +Ġexp onential +à Ł +Ġcorrel ate +Ġcons ensual +s ounding +R ing +Orig in +Ġcon clusive +fe et +ac ly +ĠF ernandez +Buy able +Ġd ucks +aunt lets +Ġel ong +Ġ28 6 +Ġsim ul +G as +ĠK irst +Ġprot r +ĠRob o +ĠAo E +op ol +Ġpsych ologically +sp in +ilater ally +ĠCon rad +W ave +44 1 +ĠAd vertisement +ĠHarm on +ĠOri ental +is Special +Ġpresum ptive +Ġw il +ĠK ier +ne a +Ġp pm +Ġhar bour +ĠW ired +comp any +Ġcor oner +atur days +ĠP roud +ĠN EXT +ĠFl ake +val ued +ce iver +Ġfra ught +Ġc asing +Ġrun away +Ġg in +ĠLaure nt +ĠHar lem +ĠCur iosity +qu ished +Ġneuro science +ĠH ulu +Ġborrow er +Ġpetition er +ĠCo oldown +W ARD +Ġinv oking +conf idence +For ward +Ġst s +pop ulation +Delivery Date +Fil m +ĠC ov +quick Ship +quickShip Available +prim ary +isSpecial Orderable +inventory Quantity +channel Availability +BO X +ĠMulti player +ĠJen ner +77 8 +ĠM d +Ġ~ /. +M N +Ġchild ish +Ġantioxid ant +ĠChrom ebook +Ġ27 4 +Ġscreen play +Ġadvent urous +ĠRelations hip +respons ive +ming ton +Ġcorner stone +ĠF ey +F IR +Ġrook ies +ĠF eaturing +Ġorig inate +Ġelectro des +ant es +Ġscript ures +Ġgl ued +Ġdiscont ent +Ġaff licted +lay out +B rave +Ġm osa +ĠQuant ity +ĠH ik +w inner +H ours +Ġent ail +ĠCell s +olog ue +Ġv il +Ġpre acher +Ġdecor ative +d ifferent +Ġprejud ices +ĠSm oking +ĠNotting ham +so Type +Ġrhyth ms +ĠAl ph +bl ast +Ste el +ĠDaniel le +Ġstr ife +Ġrem atch +so DeliveryDate +ĠF ork +t rip +ol ulu +hes es +C G +ĠPOLIT ICO +ost a +ĠDr ift +é¾įå ¥ +é¾įå¥ ij士 +Ġvet ting +ĠJin ping +ĠRec ession +Min or +ĠF raud +enf ranch +Ġconven ed +ĠNA ACP +ĠMill ions +ĠFarm ing +ĠW oo +ĠFl are +rit o +imm igrant +Ġvac ancy +ĠHE AD +ĠV aj +eg al +ĠV igil +Stud y +Ġru ining +Ġr acks +Ġhe ater +ĠRand olph +ĠBr ush +ĠT ir +Ø ¨ +Ġc ov +% ] +Ġrecount s +ĠO PT +ĠM elt +Ġtr uce +Ġcas inos +Ġcrus ade +Ġcarn age +Ġstri pe +ĠK yl +Text ures +Ġ6 98 +Ġpro clamation +Ġgood ies +Ġ........ .. +pro claimed +P olit +Ġtop ical +Ġspecial ize +ĠA min +g m +Ġanch ored +Ġbear ings +s ample +ĠHigh land +ĠAut ism +Ġmerc enary +Ġinterview er +L ER +ĠSom ers +Ġembry o +ĠAss y +Ġ28 1 +ĠEd iting +ĠCh osen +6 60 +Ġp ci +ĠThunder bolt +BI LL +Ġchuck led +jri wal +h of +Ġearth ly +() { +ind ependence +Ġdisp ers +ĠV endor +ĠG areth +Ġp als +P enn +ĠSub mit +ic um +Th u +Ġcl andestine +Ġcann ibal +ĠCl erk +E Stream +gal itarian +âĻ ¥ +g ew +Ġhor rend +ĠL ov +ĠRe action +ocr in +Class ic +Ġecho ing +Ġdiscl osing +ĠIns ight +og un +ĠInc arn +upload s +pp erc +guy en +Ġ19 01 +ĠB ars +68 7 +Ġb ribes +ĠFres no +ur at +ĠRe ese +Ġintr usive +Ġgri pping +ĠBlue print +ĠR asm +un ia +man aged +ĠHeb do +Ġ3 45 +Ġdec oding +Ġpo ets +Ġj aws +ĠF IGHT +am eless +ĠMead ows +ĠHar baugh +Inter view +ĠH osp +ĠB RA +Ġdelet ion +m ob +W alker +ĠMoon light +ĠJ ed +ĠSoph ia +Ġus ur +Ġfortun ately +ĠPut ting +ĠF old +Ġsan itation +Ġpart isans +IS ON +B ow +ĠCON C +ĠRed uced +ĠS utton +Ġtouch screen +Ġembry os +âĢ¢âĢ¢ âĢ¢âĢ¢ +ĠK rug +com bat +ĠPet roleum +Ġam d +ĠCos mos +Ġpresc ribing +Ġconform ity +ours es +Ġplent iful +Ġdis illusion +ĠEc ology +itt al +Ġf anc +Ġassass inated +regn ancy +Ġperenn ial +ĠBul lets +Ġst ale +Ġc ached +ĠJud ith +ĠDise ases +All en +Ġl as +Ġsh ards +ĠSu arez +ĠFriend ship +inter face +ĠSupp orters +add ons +46 2 +ĠIm ran +ĠW im +Ġnew found +ĠM b +An imal +Ġd arling +and e +Ġrh y +ĠTw isted +pos al +yn ski +Var ious +× ľ +ĠK iw +uy omi +Ġwell being +ĠL au +an os +Ġunm ist +Ġmac OS +Ġrest room +ĠOl iv +ĠAir ways +Ġtimet able +9 80 +Ġrad ios +v oy +ias co +Ġcloud y +ĠDraw ing +Any thing +Sy ria +ĠH ert +st aking +Ġun checked +Ġb razen +ĠN RS +69 7 +onom ic +est ablish +Ġl eng +Ġdi agonal +ĠF ior +L air +ĠSt ard +Ġdef icient +jo ining +be am +Ġomn ip +Ġbl ender +Ġsun rise +Mo ore +ĠF ault +ĠCost ume +ĠM ub +Fl ags +an se +Ġpay out +ĠGovern ors +ĠD illon +ĠBan ana +N ar +Ġtra iled +Ġimperial ist +um ann +ats uki +4 35 +ĠRoad s +Ġsl ur +ĠIde ally +Ġt renches +C trl +Ġmir rored +ĠZ el +ĠC rest +Comp at +ĠRoll s +sc rib +ĠTra ils +omet ers +w inter +Ġimm ortality +il ated +Ġcontrad icts +un iversal +ill ions +ĠM ama +opt im +AT URE +Ġge o +et ter +ĠCar lo +4 24 +Ġcanon ical +ĠStrongh old +n ear +Ġperf ume +Ġorche stra +od iac +Ġup he +Ġreign ing +vers ive +Ġc aucuses +ĠD EM +Ġinsult ed +Ġ---- -- +ĠCr ush +Ġroot ing +ĠWra ith +Ġwh ore +Ġto fu +C md +ĠB ree +Ġ$ _ +Ġr ive +ĠAd vertising +Ġw att +ĠH O +Ġpersu asive +ĠParam eters +Ġobserv ational +ĠN CT +ĠMo j +ĠSal on +Ġtr unc +Ġexqu isite +ĠMar a +Ġpo op +ĠAN N +Ex c +ĠWonder ful +ĠT aco +Ġhome owner +ĠSmith sonian +orpor ated +mm mm +Ġlo af +ĠYam ato +ĠInd o +Ġcl inging +á s +Ġimm utable +h ub +Or ange +Ġfingert ips +ĠWood en +ĠK idd +ĠJ PM +ĠDam n +C ow +c odes +48 2 +Ġiniti ating +ĠEl k +ĠCut ting +Ġabsent ee +ĠV ance +ĠLil ith +G UI +Ġobsc ured +Ġdwar ves +ĠCh op +ĠB oko +Val ues +Ġmult imedia +Ġbrew ed +Reg ular +CRIP TION +ĠMort al +Ġa pex +Ġtravel er +Ġbo ils +Ġspray ing +Rep resent +ĠStars hip +4 28 +Ġdisappro val +Ġshadow y +Ġlament ed +ĠRe place +ĠFran ç +67 7 +d or +Ġunst oppable +Ġcoh orts +gy n +ĠClass ics +ĠAm ph +Ġsl uggish +ĠAdd iction +ĠPad res +Ġins cription +Ġin human +min us +ĠJere miah +at ars +Ter ror +ĠT os +ĠSh arma +ast a +c atch +Ġpl umbing +ĠTim bers +Sh ar +H al +ĠO sc +Ġcou pling +hum ans +Ġsp onge +Ġid ols +ĠSp a +ĠAdv ocate +ĠBe ats +lu a +Ġtick ing +Ġload er +ĠG ron +8 10 +Ġstim ulated +Ġside bar +ĠManufact urer +ore And +19 73 +Ġpra ises +ĠFl ores +dis able +ĠElect rical +ra ise +E th +Ġmigr ated +Ġlect urer +K ids +ĠCa vern +Ġk ettle +Ġgly c +ĠMand ela +ĠF ully +å§ « +FIN EST +Ġsquee zing +ĠRy der +amp oo +oreAnd Online +Inst oreAndOnline +Buyable InstoreAndOnline +Ġcommem orate +ĠRamp age +Aust in +ĠSh roud +ĠRu ins +9 15 +ĠK H +Ġwater front +ĠE SC +b aby +ĠC out +ĠEm blem +Ġequival ents +49 2 +Un ique +ĠNiet zsche +brow ser +Ġim itation +ĠWere wolf +ĠKir in +ac as +' ," +Ġà ¾ +Review ed +Ġc unt +Ġvo ic +ĠLen ovo +Ġbond ed +48 1 +Ġinhib itors +Ġendeav ors +ĠHav ana +ĠSt out +ĠJ olly +A ctor +*/ ( +Ġoccur rences +ĠT ens +Incre ased +ĠACT ION +Ġ ãĢĮ +ĠRank ings +ĠB reat +Ġ30 9 +D ou +Ġimpact ing +ĠDuc hess +pre fix +Q B +Ġsummon ing +Ġbest owed +ĠKe pler +ĠPOW ER +c ube +ĠK its +ĠG rip +Ġop ium +Ġrep utable +t oc +ich ael +ĠR ipple +Ġcaf é +ĠZ oom +ĠBur ma +Ġwa ive +Ġst alls +Ġdem eanor +inc erity +Ġfluor ide +ĠSH OULD +Par is +Ġlong ing +Ġpl at +Ġgross ly +Ġbull s +Ġshowc asing +ex pected +ĠG addafi +engine ering +Re peat +ĠK ut +Ġconce ivable +Ġtrim med +osc ope +ĠCand idate +ĠT ears +rol og +Lew is +S UP +Ġroad map +Ġsal iva +Ġtrump et +Jim my +Ġmirac ulous +Ġcolon ization +Ġam put +ĠGN OME +ate ch +D ifferent +ĠE LE +ĠGovern ments +ĠA head +ãħĭ ãħĭ +word press +L IB +ĠIn clude +ĠDor othy +0 45 +ĠColomb ian +Ġle ased +88 4 +Ġde grading +ĠDa isy +i ations +Ġbapt ized +Ġsurn ame +co x +Ġblink ed +ãĥ ¢ +Ġpoll en +Ġder mat +Ġre gex +ĠNich olson +ĠE ater +ç ľ +rad or +Ġnarrow er +Ġhur ricanes +Ġhalluc inations +r idden +ISS ION +ĠFire fly +Ġattain ment +Ġnom inate +Ġav ocado +ĠM eredith +Ġt s +Ġreve rence +Ġe uph +Ġcr ates +ĠT EXT +Ġ4 43 +Ġ3 19 +J SON +iqu ette +Ġshort stop +ic key +Ġpro pelled +Ġap i +ĠTh ieves +77 9 +Ġovers aw +Ġcol i +ĠNic ola +Ġover cl +ik awa +ĠC yr +Ġ38 4 +78 9 +ĠAll ows +10 27 +Det roit +TR Y +set up +ĠSocial ism +Sov iet +s usp +ĠAP R +ĠShut down +Ġal uminium +zb ek +ĠL over +GGGG GGGG +Ġdemocr acies +Ġ19 08 +ĠMer rill +ĠFranco is +gd ala +Ġtraff ickers +ĠT il +ĠGo at +Ġsp ed +ĠRes erv +Ġpro d +55 2 +Ġc ac +ĠUn iv +ĠSch we +Ġsw irling +ĠWild erness +ĠEgg s +Ġsadd ened +Ġarch aic +H yd +Ġexcess ively +B RE +Ġaer ospace +ĠVo ices +Cra ig +Ġign ited +In itially +ĠMc A +Ġhand set +Ġreform ing +Ġfrust rations +ĠDead pool +ĠBel ichick +ract or +ĠRagnar ok +ĠD rupal +ĠApp roximately +19 20 +ĠHub ble +arm or +ĠSar as +ĠJon as +Ġnostalg ic +Ġfeas ibility +Sah aran +Ġorb iting +Ġ9 70 +R u +Ġsh in +ĠInvestig ators +Ġinconsist encies +ĠP AN +B G +Ġgraz ing +Ġdetect ors +ĠStart up +ĠFun ny +ĠNa omi +Consider ing +Ġh og +ut f +ce mic +Ġfort ified +ĠFun ctions +Ġcod ec +nut rition +H at +" ! +micro soft +55 8 +ĠTh in +ĠA CE +Al ias +ĠO PS +p apers +P K +ãĢ İ +Ġimpro bable +N orthern +equ al +Ġlook out +Ġty res +ĠMod ified +ĠK op +Abs olutely +Ġbuild up +sil ver +Ġaud i +Ġgro tesque +ĠSab er +ĠPres byter +ON Y +Ġglac iers +ĠSho als +ĠK ass +ĠH RC +ĠNic ol +ĠL unch +ĠF oss +âĸ Ĵ +AD RA +ĠOne Plus +o ing +ground s +Ġincident al +Ġdatas ets +68 9 +ĠClarks on +Ġassemb ling +ĠCorrect ions +Ġdrink ers +Ġqual ifiers +Ġle ash +Ġunf ounded +ĠH undred +Ġkick off +T i +Ġrecon cil +ĠGr ants +ĠCompl iance +ĠDexter ity +Ġ19 06 +w arn +D allas +Max imum +n ard +av ia +be aut +ens itivity +tr ace +Ġpione ers +ĠF ract +ãĢ ı +Ġpre cept +Ġgloss y +ĠI EEE +Ac ross +Ġ6 80 +S leep +che on +Ġsatir ical +ĠMin otaur +ĠCla ude +Ġr é +ape go +Ġcar rot +ĠSem in +ino a +Ġz o +Ind ependent +Ġdiagn oses +ĠC ue +M AR +Ġrend ition +ĠK ik +Ġpath ology +Ġselect s +Link edIn +Ġass ay +ĠD res +Ġtext ual +post ed +IT AL +ĠM aul +N eal +Ġinter connected +Ġerr atic +ĠVir us +Ġ5 30 +Ġenvironmental ists +ĠP helps +Ġeng agements +ĠIN ST +Ġeconom ical +nox ious +Ġg earing +izz y +Ġfavor ably +ĠMcG ill +T erm +Ġh anged +Ġball park +ĠRe yes +Ġbe ware +ĠP sal +ĠMass acre +q i +Ġin accessible +acly sm +Ġfr ay +ill ac +Ġbitter ly +ĠCert ification +Mich igan +Ġir respective +al ore +Em pty +Ġendorse ments +Ġund et +f g +equ ipped +Ġmerc iless +ĠC ust +Ġimm ature +Ġvou cher +ĠBlack well +Ñ ı +h awk +dis ciplinary +ile e +ĠMak oto +ĠD ude +ãĥĩ ãĤ£ +Y ears +Ġin ver +Ġsh aman +ĠY ong +ip el +ell en +ĠCath y +br ids +Ġs arc +65 1 +N ear +Ġground work +Ġam az +Ġ4 15 +ĠHunting ton +hew s +ĠB ung +Ġarbit rarily +ĠW it +ĠAl berto +Ġdis qualified +best os +46 1 +Ġp c +Ġ28 4 +ro bat +Rob in +Ġh ugs +ĠTrans ition +ĠOcc asionally +Ġ3 26 +ĠWh ilst +ĠLe y +Ġspaces hip +cs v +Ġun successfully +ĠA u +le ck +ĠWing ed +ĠGrizz lies +. � +Ġne arer +ĠSorce ress +ĠInd igo +El se +8 40 +let es +Co ach +Ġup bringing +ĠK es +Ġseparat ist +Ġrac ists +Ġch ained +Ġabst inence +lear ning +Ġrein stated +Ġsymm etry +Ġremind ers +ĠChe vy +Ġm ont +Ġexempl ary +ĠT OR +Z X +Ġqual itative +ĠSt amp +ĠSav annah +ĠRoss i +Ġp aed +Ġdispens aries +ĠWall s +ĠCh ronic +Ġcompliment ary +ĠBeir ut +Ġ+ --- +igs list +Ġcrypt ographic +mas ters +ĠCap itals +Ġmax imal +Ġent ropy +Point s +Ġcombat ants +l ip +ĠGl ob +ĠB MC +ph ase +th ank +HT TP +Ġcomm uter +Ġ\( \ +.. / +ĠReg ener +ĠDO I +ĠActiv ision +Ġsl it +os al +RE M +Ġch ants +Y u +Ke ys +Bre xit +ĠFor ced +Ari zona +Ġsquad ron +IS O +ĠMal one +Ġ3 38 +Ġcontrast ing +Ġt idal +Ġlib el +Ġimpl anted +Ġupro ar +ĠC ater +Ġpropos itions +M anchester +ĠEuro s +it amin +G il +ĠEl ven +ĠSe ek +ĠB ai +Ġredevelop ment +ĠTown s +ĠL ub +! ", +al on +K rist +Ġmeas urable +Ġimagin able +Ġapost les +Y N +7 60 +Ġster oid +Ġspecific ity +ĠL ocated +ĠBeck er +ĠE du +ĠDiet ary +uts ch +ĠMar ilyn +Ġbl ister +ĠM EP +ĠK oz +ĠC MS +y ahoo +ĠCar ney +Ġbo asting +ĠC aleb +By te +read s +ad en +Pro blem +ĠWood ward +S we +S up +ĠK GB +Set up +Ġtac it +Ġret ribution +Ġd ues +ĠM ü +. ? +ä¸ Ń +p ots +Ġcame o +ĠP AL +educ ation +A my +like ly +g ling +Ġconstitution ally +ĠHam m +ĠSpe ak +Ġwid gets +br ate +Ġcra ppy +ĠI ter +Ġanticip ating +ĠB out +P ixel +ĠY ep +ĠLaur ie +Ġh ut +Ġbullet in +ĠSal vation +Ġch ats +ear able +Honest ly +AL TH +onse qu +c ult +isco very +ovy ch +Ġse lves +ĠSat oshi +S ounds +Ġconver gence +ĠRosen berg +19 74 +Ġnas al +Ġfull est +Ġfer ocious +x us +ist e +AM S +Ġlobb ied +Ġso othing +ĠGun n +t oday +0 24 +Ġinspir ational +ĠN BN +p b +g ewater +or ah +all owed +ĠCol iseum +Ġspecial izing +Ġinsane ly +ĠT ape +del ay +Ġt arn +ĠP ound +Ġmel anch +Ġdeploy ments +il and +Ġless en +Ġfur ry +ĠUE FA +Ġblood shed +ĠMe ier +ither ing +Ġhe irs +ĠJ aw +ax ter +ĠPublic ations +Ġal ters +int ention +ĠWinc hester +d etermination +ĠLif etime +th in +Mon ster +7 80 +Ġapprox imation +Ġsuper markets +ĠSecond s +or os +h uge +Ġb ribe +ĠLIM ITED +un ed +Ġmis interpret +ĠIn jury +Ġ3 67 +Ġthreshold s +ĠCarn ival +Ġgastro intestinal +Ġguid eline +Ġde ceived +f eatures +Ġpurported ly +ĠRon nie +ĠNew t +Ġsp acious +as us +Ġsuperhero es +ĠCyn thia +le gged +k amp +ch io +Ġth umbnail +ĠShir ley +ill ation +Ġshe ds +ĠZ y +E PA +Ġdam s +Ġy awn +n ah +ĠPe ggy +ĠE rie +ĠJu ventus +ĠF ountain +r x +don ald +al bum +ĠComp rehensive +Ġc aching +ĠU z +ulner ability +ĠPrinc iple +ĠJ ian +ing ers +cast s +ĠOs iris +ch art +t ile +ĠTiff any +ĠPatt on +ĠWh ip +Ġovers ized +J e +ĠCind erella +ĠB orders +ĠDa esh +M ah +Ġdog ma +Ġcommun ists +v u +Coun cil +Ġfresh water +Ġw ounding +Ġdeb acle +Ġyoung ster +Ġthread ed +ĠB ots +ĠSav ings +ãģ Ĥ +ol ing +oh o +Ġillum ination +M RI +Ġlo osen +tr ump +ag ency +ur ion +Ġmoment arily +ĠCh un +ĠBud apest +ĠAl ley +D isk +Ġaston ished +ĠCon quer +ĠAccount ing +h aving +ĠWe in +ĠAl right +Ġrev olver +Ġdel usion +Ġrelic s +Ġad herent +qu ant +Ġhand made +or io +Ġcomb ating +c oded +Ġquad ru +re th +N ik +ĠTrib al +ĠMyster ious +Ġin hal +ĠWin ning +ĠClass ification +ch anged +Ġun ab +Ġsc orn +icip ated +w l +ond uctor +Ġrein forcing +ĠChild hood +an ova +Ġadventure r +Ġdoctor al +ĠStrateg ies +Ġengulf ed +ĠEnc ounter +Ġl ashes +Crit ical +ric ular +ĠU TF +oci ation +check ing +ĠConsult ing +Run time +per iod +ĠAs gard +Ġdist illed +ĠPas adena +ĠD ying +ĠCOUN TY +Ġgran ite +Ġsm ack +Ġparach ute +ĠS UR +Virgin ia +ĠF urious +78 7 +ĠO kin +Ġcam el +ĠM bps +19 72 +ĠCh ao +ĠC yan +j oice +ef er +ĠW rap +ĠDeb ate +S eg +Ġfore arm +ĠIgn ore +Ġtim estamp +Ġprob ing +ĠNo on +ĠGra il +f en +Ġdorm ant +ĠFirst ly +ĠE ighth +ĠH UN +ĠDes ire +or as +Girl s +ĠDes mond +z ar +am ines +O AD +exec ute +Ġbo obs +ĠAT L +_ ( +Chel sea +Ġmasturb ation +ĠCo C +Ġdestroy er +ĠCh omsky +Ġsc atter +ĠAss ets +79 6 +ĠC argo +Ġrecept ive +ĠSc ope +Ġmarket ers +Ġlaun chers +Ġax le +ĠSE A +se q +ĠM off +f inding +ĠGib bs +Georg ia +extreme ly +N J +Ġlab orers +st als +Ġmed iation +ĠH edge +at own +Ġi od +des pite +v ill +J ane +ex istence +Ġcoinc ided +ĠUt ilities +ĠChe ap +Ġlog istical +Ġcul mination +ĠNic otine +p ak +F older +Ġrod ents +st uff +Ġlaw fully +Ġreper to +io ch +j j +Dial ogue +HH HH +lic tion +Look s +Ġ29 7 +Ġtur rets +ĠAb andon +Ġinc ess +ĠTraff ord +Ġcur led +Ġprefer ring +Ġprivat ization +Ġir resist +ĠP anda +ĠSh ake +ĠMc Gr +ãĥ Ħ +und ers +Ġdiscrim inated +Ġbart ender +I LE +Atl antic +Ġprop ensity +ĠW iz +ĠG im +con ference +Ġrein forces +G h +w agon +Ġe erie +F al +Ġhug ged +rac ist +R IC +F u +Ġf iller +ĠSt ub +Ġeng raved +ĠWrest le +Ġimagin ative +ĠPe er +ĠFact ors +an us +ĠDrac ula +mon itor +Ġrou ters +ib ia +ĠBoo lean +end ale +ĠSl aughter +ĠSh ack +R FC +ĠSpiel berg +S ax +ĠPH OTO +ĠCl over +ĠR ae +Dep ending +ĠMem or +ar am +Ġpier ced +Ġcur tains +v ale +ĠInqu isition +ĠP oke +Ġforecast ing +Ġcompl ains +S ense +ĠHer mes +isc overed +Ġb ible +ĠMor ph +Ġg erm +78 5 +D ON +Ġcon gen +Ġcr ane +ĠD PR +Ġrespect fully +R oom +ĠN aw +ĠDal ai +re ason +ĠAng us +Educ ation +ĠTitan ic +Ë ľ +Ġo val +un ited +Ġthird s +Ġmoist ur +ĠC PC +M iami +Ġtent acles +ĠPol aris +ex c +ex clusive +ĠPra irie +Ġcol ossal +ĠBl end +sur prisingly +ÃŃ s +Ġindo ctr +Ġbas al +ĠMP EG +und o +Spl it +Develop ment +Ġlan tern +19 71 +Ġprov ocation +Ġang uish +ĠB ind +ĠLe ia +duc ers +ipp y +conserv ancy +Ġinitial ize +ĠTw ice +ĠSu k +Ġpred ic +Ġdi ploma +Ġsoc iop +Ing redients +Ġhamm ered +ĠIr ma +Q aida +Ġglim ps +ĠB ian +Ġst acking +Ġf end +gov track +Ġun n +dem ocratic +ig ree +Ġ5 80 +Ġ29 4 +Ġstraw berry +ID ER +Ġcher ished +ĠH ots +Ġinfer red +Ġ8 08 +ĠS ocrates +O regon +ĠR oses +ĠFO IA +Ġins ensitive +Ġ40 8 +Recomm end +ĠSh ine +Ġpain staking +UG E +ĠHell er +ĠEnter prises +I OR +ad j +N RS +L G +Ġalien ated +Ġacknowled gement +ĠA UD +ĠRen eg +Ġvou chers +Ġ9 60 +Ġm oot +ĠDim ensions +Ġc abbage +B right +g at +ĠK lu +Ġlat ent +Ġz e +ĠM eng +Ġdis perse +Ġpand emonium +H Q +Ġvirt uous +ĠLoc ations +ee per +prov ided +Ġse ams +ĠW T +iz o +PR OV +Ġtit anium +Ġrecol lection +Ġcr an +Ġ7 80 +ĠN F +49 1 +64 2 +p acking +59 8 +text ure +Sp ider +fre edom +cipl ed +ĠTAM ADRA +âĻ ¦ +aut hent +ĠW ANT +r ified +Ġr ites +Ġuter us +k iss +Ġâī ¤ +Ġsk illet +Ġdis enfranch +ĠGa al +Comp an +Ġage ing +gu ide +B alt +Ġiter ator +Ġdiscretion ary +t ips +Ġprim ates +ĠTechn ique +ĠPay ments +az el +ĠR OCK +stant ial +0 60 +Ġd mg +ĠJack ets +ĠPlay off +Ġnurs ery +ĠSy mb +art on +Ġannex ation +Color ado +Ġco ils +ĠSh oes +âĦ¢ : +ĠRo z +COM PLE +ĠEve rest +ĠTri umph +J oy +G rid +à ¼ +process or +ĠPros per +ĠSever us +ĠSelect ed +r g +ĠTay yip +St ra +Ġski ing +Ġ? ) +Ġpe g +Tes la +Ġtime frame +Ġmaster mind +ĠN B +scient ific +ĠSh it +gener ic +IN TER +N UM +Ġst roll +ĠEn ix +ĠM MR +ĠE MS +m ovie +Ĥ ª +Ġminim izing +idd ling +Ġilleg itimate +Ġprot otyp +Ġpremature ly +Ġmanual s +obb ies +ĠCass idy +D EC +des ktop +Ġaer os +Ġscreen ings +Ġdeb ilitating +ĠGr ind +nature conservancy +Ġf ades +ter mination +assets adobe +F actor +Ġdefinitive ly +P oké +ap ult +ĠLaf ayette +C orn +ĠCor al +Ġstagn ant +T ue +Ġdissatisf action +G ender +Ġkid neys +ĠG ow +ĠDef eat +ĠAsh ton +Ġcart els +Ġfore closure +ĠExpl ore +stre ngth +ot in +Ġveterin arian +Ġf umble +Ġpar ap +ĠSt rait +r ils +Ġpr ick +ĠBerm uda +ĠAm munition +skin ned +Ġab ound +ĠB raz +Ġshar per +ĠAsc ension +Ġ9 78 +Ġpreview s +Ġcommun ion +ĠX Y +Ġph ony +Ġnewcom er +Ġ3 32 +." ," +Ġredist ribution +Prot ect +ĠSo f +K al +Ġlip stick +w orst +Ġtang led +Ġretrospect ive +int eger +Ġvolunte ering +Ġ19 07 +Ġ -------------------- +ic hen +Ġunve iling +Ġsen seless +Ġfisher ies +\ - +Ġh inges +Ġcalcul us +My th +Ġund efeated +Ġoptim izations +Ġdep ress +Ġbill board +ĠY ad +ĠPy ramid +Is n +I de +Ġleg ion +ĠK ramer +ent anyl +Ġpenet rating +ĠHaw th +ĠPR ODUCT +ĠGer ard +ĠP act +ĠIn cluding +ĠEl ias +ĠEl aine +vis ual +Ġhum ming +Ġcond esc +ĠF asc +ä¸ Ĭ +Ġe galitarian +Ġdev s +ĠD ahl +O ps +D H +ĠB ounce +id ated +ald o +Ġrepublic an +Ġh amb +ĠS ett +ograph ies +CH APTER +Ġtrans sexual +Ġsky rocket +ans wer +Ġmark up +Ø ª +Ġhero ine +Comp are +ĠT av +Be ast +Ġsuccess ors +Ġna ïve +ĠBuck ley +st ress +me at +Ġdownload able +Ġindex ed +Ġsc aff +ĠL ump +ĠHom o +Stud io +In sp +Ġr acked +far ious +ĠPet ty +Ex ternal +Ġ19 09 +W ars +com mit +put ers +Ġun ob +ĠEr r +ĠE G +ĠAl am +ĠSiber ia +ĠAtmosp heric +IS TER +ĠSatan ic +trans lation +ĠL oud +tra umatic +l ique +Ġreson ate +ĠWel ch +Ġspark ing +ĠT OM +t one +Ġout l +Ġhandc uffed +ĠSer ie +8 01 +Ġland marks +ĠRee ves +Ġsoft ened +Ġdazz ling +ĠW anted +month s +Mag ikarp +Ġunt reated +ĠBed ford +M i +ĠDynam o +O re +79 5 +Ġwrong ful +Ġl ured +Ġcort isol +Ġve x +d rawn +ile t +Download ha +ĠF action +Ġlab yrinth +Ġhij acked +w aters +er ick +Ġsuper iors +ĠRow ling +ĠGu inness +Ġt d +99 2 +Ġune arthed +Ġcentr if +Ġsham eless +P od +ĠF ib +Ġ icing +Ġpredict or +Ġ29 2 +fore station +con struct +C and +@ # +Ġag itated +Ġre pr +OV A +Ġkn itting +ĠLim a +Ġf odder +68 4 +ĠPerson a +k l +7 01 +Ġbreak up +á ¸ +Ġapp alled +Ġantidepress ants +ĠSus sex +Har ris +ĠTher mal +ee ee +U pload +Ġg ulf +Ġdoor step +ĠSh ank +L U +ĠM EN +ĠP ond +s orry +Ġmis fortune +n ance +Ġb ona +M ut +Ġde graded +ĠL OG +ĠN ess +an imal +Ġa version +und own +Ġsupplement ed +ĠC ups +Ġ50 4 +Ġdep rive +ĠSpark le +Å Ĥ +ĠMed itation +auth ors +ĠSab an +ĠN aked +air d +ĠMand arin +ĠScript ures +ĠPerson nel +ĠMahar ashtra +Ġ19 03 +ĠP ai +ĠMir age +omb at +Access ory +Ġfrag mented +T ogether +Ġbelie vable +ĠGl adiator +al igned +ĠSl ug +M AT +Ġconvert ible +ĠBour bon +amer on +ĠRe hab +nt ax +Ġpowd ered +pill ar +Ġsm oker +ĠMans on +ĠB F +5 11 +ĠGood ell +ĠD AR +m ud +g art +Ġob edient +ĠTrans mission +ĠDon ation +8 80 +Ġbother ing +Material s +ãĤ ± +dest roy +Ġfore going +Ġanarch ism +ĠK ry +ice ps +Ġl ittered +ĠSch iff +Ġanecd otal +un its +Ġf ian +ĠSt im +ĠS OME +ĠInv aders +Ġbehaviour al +ĠVent ures +Ġsub lime +Ġfru ition +ĠPen alty +Ġcorros ion +¶ ħ +Ġlik ened +Ġbesie ged +ween ey +ĠCre ep +Ġlinem en +mult i +ic ably +ud der +Ġvital ity +Ġshort fall +ĠP ants +ap ist +H idden +ĠDro ps +med ical +Ġpron unciation +ĠN RL +Ġinsight ful +J V +ĠBe ard +ĠCh ou +Ġchar ms +Ġb ins +Ġamb assadors +ĠS aturdays +Ġinhib itor +ĠFr anch +6 01 +', ' +ĠCon or +art ney +ĠX peria +g rave +be es +ĠProtest ants +Ġso aking +ĠM andal +Ġph ased +Ġ6 60 +Ġsc ams +Ġbuzz ing +ĠItal ians +ĠLoren zo +ĠJ A +Ġhes itated +Ġcl iffs +ĠG OT +ingu ishable +Ġk o +Ġinter ruption +Z ip +Lear ning +Ġundersc ores +ĠBl ink +K u +57 9 +ĠAut ob +I RE +Ġwater ing +Ġpast ry +8 20 +Ġvision ary +ĠTempl ar +awa ited +Ġpist on +Ġant id +current ly +Ġp ard +Ġw aging +Ġnob ility +ĠY us +Ġinject ing +f aith +ĠP ASS +å º +Ġret ake +ĠPR OC +Ġcat hedral +b ash +Ġwrest lers +Ġpartner ing +Ġn oses +Ġ3 58 +Trans form +am en +Ġb outs +ĠId eal +ĠConstant in +Ġse p +ĠMon arch +att en +ĠPe oples +mod ified +Ġmor atorium +Ġpen chant +Ġoffensive ly +Ġprox ies +ok ane +ĠTaiwan ese +ĠP oo +ĠH OME +us ional +Ġver bs +ĠO man +vis ory +Ġpersu asion +Ġmult it +Ġsc issors +G ay +ow ay +oph ysical +l us +gn u +Ġap ocalyptic +Ġabsurd ity +Ġplay book +Ġautobi ography +I UM +Ġsne aking +ĠSim ulation +pp s +ell ery +Plan et +Ġright fully +Ġn iece +ĠN EC +ĠIP O +ĠDis closure +lean or +ous y +ST ER +Ġ28 2 +Cru z +Ch all +64 3 +ĠSurv ive +ĠF atal +ĠAm id +ap o +We apons +D EN +7 70 +ĠGreen wald +Ġlin en +al os +Ġpollut ants +ĠPCI e +k at +Ġp aw +ĠK raft +C hem +ĠTermin ator +Ġre incarn +Ġ] [ +ĠSe eds +Ġsilhou ette +ĠSt ores +Ġgro oming +ĠD irection +ĠIs abel +ĠBr idges +ðŁ ij +E ED +ĠM orsi +Ġval ves +ĠRank ed +ĠPh arma +ĠOrgan izations +Ġpenet rated +ĠRod ham +ĠProt oss +Ġove rest +Ġex asper +ĠT J +Ġ 000000 +Ġtrick le +Ġbour bon +WH O +Ġw retched +Ġmicrosc opic +Ġcheck list +Ġad orned +R oyal +Ad minist +ĠRet irement +ĠHig hest +We ather +ile ge +Ġincre ments +ĠC osponsors +Ġmas se +ĠS inn +r f +Ġh ordes +as sembly +75 4 +ĠNat asha +ĠTY PE +ĠGEN ERAL +Ġarr anging +Ġ40 7 +l ator +Ġg lean +Ġdisc redited +Ġclin icians +UN E +Ġachie ves +ĠEm erson +com plex += [ +Ġprincip ally +Ġfra il +p icked +Ġthan king +Ġre cl +ĠL AST +Ġsupp ressing +il ic +Ġantidepress ant +ĠLis bon +Ġth or +Ġsp a +Ġking doms +ĠPear ce +em o +Ġpl ung +Ġdiv est +Ġ ******************************** +b is +osp els +ad r +Sp irit +hall a +P ink +end ez +Ġresurrect ed +esc ape +ĠRosen stein +Ġge ological +Ġnecess ities +Ġcarn iv +ĠE lys +ĠBar ney +Ġ29 6 +dig y +ST ON +D OWN +Ġmil estones +Ġk er +Ġdismant ling +Ġre prim +Ġcross ings +19 45 +Ġpatri archy +Ġblasp hemy +Ġ3 59 +met ry +ĠOb esity +ĠDiff erences +bl ocking +ãĥķ ãĤ¡ +ich ita +ĠSab ha +ph alt +ĠCol o +ual a +effic ients +ĠMed ina +con sole +55 7 +ĠHann ibal +ĠHab it +ĠF ever +Ġthen ce +Ġsyn agogue +Ġessential s +Ġw ink +ĠTr ader +ID A +ĠSp oiler +ĠIceland ic +ĠHay ward +Ġpe ac +Ġmal ice +Ġflash back +Ġth w +Ġlay offs +L iquid +Ġtro oper +Ġh inge +ĠRead ers +Ph ill +ĠB auer +Cre ated +Ġaud its +ac compan +Ġunsus pecting +ier a +6666 6666 +Ġbro ch +Ġapprehend ed +ĠM alk +cer ning +ĠCod ex +O VER +M arsh +ĠD eng +ĠExp ression +Ġdisrespect ful +Ġasc ending +t ests +ĠPlaint iff +ster y +ĠAl ibaba +din and +ĠDem psey +Applic ations +mor al +Ġthrough put +Ġquar rel +Ġm ills +Ġhe mor +ĠC ASE +terror ist +st im +ifest yle +ro zen +CE PT +Ar k +u ci +lect ic +Ġirrit ating +she ets +A y +Ġrede emed +Ġhorn y +ĠTe ach +ĠS ear +dem ocracy +4 65 +ĠRest ore +Ġstand by +ĠP is +iff in +Ġsleep y +Ġextr ater +Ġcompl iments +Fram eworks +Ġinstall s +Ġb anging +sur face +found land +Ġmetaph ysical +Ġ28 3 +oul s +dev ices +Ar gs +ĠSac rifice +ĠMcC orm +es on +Cons ervative +ĠM ikhail +see ing +is ively +ĠRo oms +ĠGener ic +Ġenthusi astically +Ġgri pped +Ġcomed ic +ĠElectric ity +Ġgu errilla +Ġdec oration +ĠPerspect ive +Ġconsult ations +Ġun amb +Ġplag iar +Ġmagic ian +Ġe rection +ĠTour ism +or ied +ro xy +11 00 +T am +Ī è +Î ³ +× ª +ĠPred ators +Nit rome +Ġtelesc opes +project s +Ġun protected +Ġst ocked +ĠEnt reprene +nex pected +Ġwast ewater +V ill +Ġint imately +Ġi Cloud +ĠConst able +Ġspo of +Ġne farious +Ġfin s +Ġcens or +ĠMod es +ĠEs per +ar bon +Ġinter sections +Ġlaud ed +Ġphys i +Ġgener ously +ĠThe Nitrome +ĠTheNitrome Fan +Ġar isen +ĠÙ Ī +Ġg lands +ĠPav ilion +ĠGu pta +Ġuniform ly +Ġr amps +ri et +ĠWH EN +ĠVan essa +Ġrout ed +Ġlim p +ĠC PI +p ter +int uitive +Ġv aping +Ġexperiment ed +ĠOlymp us +ĠAm on +Ġsight ing +Ġinfiltr ate +ĠGentle man +Ġsign ings +ĠMe ow +ĠNav igation +che cks +4 33 +Ġel apsed +ĠBulg arian +esp ie +ĠS OM +d uring +Ġsp ills +anc a +ĠPly mouth +M AL +Ġdomest ically +ĠWater gate +ĠF AM +k illed +ed ited +ĠYour self +Ġsynchron ization +ĠPract ices +ST EP +Ġgen omes +ĠQ R +not ice +Ġloc ating +z in +Ġ3 29 +al cohol +Ġk itten +V o +Ġr inse +Ġgrapp le +ĠSc rew +ĠD ul +A IR +Ġle asing +ĠCaf é +Ġro ses +ĠRes pect +Ġmis lead +Ġperfect ed +Ġnud ity +Ġnon partisan +ĠCons umption +Report ing +Ġnu ances +Ġdeduct ible +ĠSh ots +Ġ3 77 +Ġæ ľ +ano oga +Ben ef +ĠB am +ĠS amp +if ix +Ġgal van +ĠMed als +rad ius +Ġno bles +Ġe aves +igr ate +K T +ĠHar bour +u ers +Ġrisk ed +re q +Ġneuro t +get table +ain a +Rom ney +Ġunder pin +Ġlo ft +ĠSub committee +ĠMong ol +b iz +Ġmanif ests +ass isted +ĠG aga +Ġsy nergy +Ġreligious ly +ĠPre f +ĠG erry +T AG +ĠCho i +4 66 +beh ind +ĠO u +Gold Magikarp +Ġhemor rh +R iver +Ġtend on +Ġinj ure +ĠF iona +Ġp ag +Ġag itation +|| || +ur an +ĠE SA +Ġest eem +Ġdod ging +Ġ4 12 +r ss +Ġce ases +ex cluding +Ġint akes +Ġinsert s +Ġemb old +ĠO ral +up uncture +4 11 +ĠUn ified +ĠDe le +Ġfurn ace +ĠCoy otes +ĠBr ach +L abor +Ġhand shake +Ġbru ises +Gr ade +éĹ ĺ +ĠGram my +ile en +St ates +ĠScandinav ian +ĠKard ash +8 66 +Ġeffort lessly +ĠDI RECT +ĠTH EN +ĠMe i +ert ation +19 68 +Ġgro in +w itch +Requ irements +98 5 +Ġroof s +Ġest ates +ĠH F +Ġha ha +Ġdense ly +ĠO CT +Ġpl astics +Ġincident ally +ĠTr acks +ĠTax es +Ġch anted +Ġforce ful +ĠBie ber +ĠK ahn +K ent +ĠC ot +lic ts +F ed +Ġhide ous +ĠVer d +ĠSynd icate +ĠIl legal +J et +ĠD AV +re asonable +c rew +Ġfundamental ist +Ġtruth ful +ĠJ ing +Ġl il +Ġdown ed +Ġen chanted +ĠPolic ies +ĠMcM aster +ĠH are +ides how +Ġpar ams +en cers +gorith m +Ġallow ances +Ġturb ulent +Ġcomplex ities +ĠK T +Ġ3 37 +ĠGen etic +F UN +D oug +t ick +Ġg igs +ument hal +Ġpatriarch al +Ġcal c +, ... +Ġc out +ĠGu an +Ġpath ological +ĠR ivals +Ġunder rated +Ġflu orescent +ĠJ iu +arna ev +ĠQu an +Ġ4 29 +Ġ ਠ+M ario +Con struct +ĠC itation +ĠR acial +ĠR SA +ĠF idel +Ġ3 95 +Person ally +C ause +à » +rad ical +in en +Ġvehement ly +ĠPap a +Ġintern ship +Ġfl akes +ĠRe ck +Luck ily +B ra +20 20 +rav ings +R N +W onder +Ser iously +Ġre usable +Ġpoll uted +ĠP eng +le igh +ind le +Ġcircuit ry +ĠMad onna +ĠB ART +Res idents +att ribute +Phil adelphia +Cl ub +Ġplan ner +Ġfr antically +Ġfaith fully +ĠTerrit ories +ĠL AT +ĠAnders en +an u +ĠP ARK +ĠS ora +i age +ĠPlay offs +ĠG CC +4 27 +Ġab norm +ĠL ever +Ġdisob edience +As ync +ĠShe a +V ert +Ġsk irts +ĠSaw yer +x p +Ġwors ening +Ġsc apego +ĠAng le +oth al +Ġtro ve +ĠSt y +ĠN guyen +mar ine +ide on +Dep ths +Bl og +ĠIll uminati +Ġtract s +Ġorgan ise +Ġo str +F s +Ġlever aging +ĠD aredevil +as ar +Ġl ang +Ġex termin +urs ions +ĠRom o +ãĤ¤ ãĥĪ +Ġcont ended +Ġencounter ing +ĠTable t +ĠAltern ate +sk ill +Ġswe ets +Ġco hesive +cap acity +Ġrep ud +Ġl izard +ro o +Ġpilgr ims +ĠR uff +ĠInstr ument +ĠLog o +uit ous +E H +Ġsales man +Ġank les +L ed +ĠPat ty +ud os +Own er +Ġdiscrep ancies +k j +M U +Ġuncond itional +Dragon Magazine +i ard +O ak +ĠConvers ation +be er +ĠOs aka +D elta +us ky +Ġsecret ion +Ġpl aza +Ġm ing +Ġde pletion +ĠM ous +ĠI TS +ĠH imal +ĠFle ming +Ġcyt ok +ĠH ick +Ġbat ters +ĠInt ellectual +6 75 +é r +IS ION +ĠQu entin +ĠCh apters +ih adi +Ġco aster +WAY S +ĠL izard +ĠY or +and ering +S kin +ha ust +ab by +Ġportray ing +Ġwield ed +d ash +Ġprop onent +Ġr ipple +Ġgrap hene +Ġfly er +Ġrec urrent +Ġdev ils +Ġwater fall +æĺ ¯ +go o +Text Color +Ġtam pering +IV ES +TR UMP +ĠAb el +ĠS AL +ĠHend ricks +ĠLu cius +b ots +Ġ40 96 +IST ORY +Gu est +ĠN X +in ant +Ben z +ĠLoad ed +ĠCle ver +t reatment +Ġta vern +Ġ3 39 +ĠT NT +ific antly +Tem perature +F el +Ġunder world +ĠJud ges +Ġ< + +Ġst ump +Ġoccup ancy +Ġab er +ĠF inder +) ", +ĠN unes +res et +in et +ect omy +Ġwell ness +ĠP eb +quart ered +and an +Ġneg atives +ĠTh iel +ĠCl ip +ĠL TD +Ġbl ight +Ġreperto ire +K yle +Ġqu er +ĠC es +Ġha pl +98 9 +ĠTh ames +isc opal +Des k +ivari ate +ĠEx cellence +found ation +Ġâ ĩ +X i +Ġmyster iously +esty les +Ġper ish +ĠEng els +ĠDE AD +09 0 +}} } +ĠUn real +Ġrest less +ID ES +orth odox +ĠInter mediate +Ġdin ners +ĠTr out +ĠSe ym +ĠHall s +og ged +Ġtraged ies +Ġdid nt +67 6 +Ġail ments +Ġobserv able +ĠV ide +ad apt +ĠD usk +Ġprofessional ism +ĠPres cott +ĠInd ies +p ox +ĠMe hran +W ide +Ġend emic +ĠPar an +B ird +Ġped als +ĠI U +ĠAdam ant +ĠH urt +Ġcorrel ates +urd en +Ġspons oring +cl imate +ĠUnivers ities +ĠK not +enn es +ĠDam ian +ĠAx el +S port +Ġbar b +ĠS no +sh own +ste en +ud ence +Ġnon violent +Ġhom ophobia +Ġbiom ass +ĠDet ail +Ġsrf N +ĠT une +accompan ied +I ENCE +Al bert +ĠMong o +z x +ĠCer berus +or bit +c ens +Ġsl ay +SH ARE +H Y +Ġb rawl +ĠPro be +Ġnonex istent +ĠClare nce +ĠBlack burn +Ġport als +ĠR ita +ĠRem ain +ĠLe vant +Ġtrick ed +ĠF erry +aver ing +ĠStraw berry +ĠAn swers +Ġhorrend ous +ĠA man +Supp lement +ĠT oad +Ġpe eled +Ġman oeuv +ĠU zbek +mond s +ĠH ector +Ġ40 2 +pe es +fix es +Ġd j +Ġres umes +Ġaccount ant +Ġadvers ity +Ġham pered +ĠL arson +Ġd oping +part s +H ur +Ġbe arded +Ġy r +ĠPlug in +å¥ ³ +Ġ/ ** +rol ley +Ġwaters hed +ĠSub mission +if lower +AS C +Ġcho ir +Ġsculpt ures +m A +incre asing +ai i +Ġsne akers +Ġconfront s +ĠEle phant +ĠEl ixir +Ġrec al +ĠT TL +w idget +ĠW ax +ĠGr ayson +Ġha irst +Ġhumili ated +ĠWAR N +app iness +ĠT TC +F uel +Ġpol io +Ġcomplex es +Ġbab e +ĠX IV +P F +). [ +P arts +Ġ4 35 +M eg +ĠY ards +ĠAL P +Ġy ells +Ġprin ces +Ġbull ies +ĠCapital ism +ex empt +FA Q +ĠSp onge +ĠAl a +Ġpleas antly +Ġbu f +Ġden ote +Ġunp ublished +Ġkne eling +asc a +Ġl apse +al ien +99 4 +Ġrefere es +ĠLaw yers +S anta +Ġpuzz ling +ĠProm etheus +ĠPh araoh +ĠDel ay +Ġfacilit ates +ĠC ES +Ġjew els +Ġbook let +ond ing +Ġpolar ization +ĠMor an +ĠSal ad +ĠS OS +ĠAdv ice +PH OTOS +IC AN +iat ures +ex press +ĠWonder land +ĠC ODE +ĠCL ASS +9 75 +Ġg rep +ĠD iesel +ĠGl ac +! ?" +Ġr m +o ine +disc rimination +ĠN urse +m allow +Ġv ortex +ĠCons ortium +Ġlarge Download +stra ight +augh lin +G rad +Ġpublic ized +ĠW aves +ĠRed d +Ġfest ivities +ĠM ane +ar ov +Ġfleet ing +ĠDr unk +ug en +C ele +Ġchromos omes +ĠD OT +-+-+ -+-+ +Ġbus iest +ĠBe aver +Sy rian +ĠK yr +k as +ĠCross Ref +19 50 +76 01 +Ġrepe aling +ĠWin ners +ĠMac ro +ĠD OD +bl ance +S ort +64 1 +Ġmet re +ĠD irk +Ġgo ggles +Ġdraw backs +Ġcomplain ant +Ġauthor izing +Ġantit rust +oper ated +Ġm ah +Ġexagger ation +Am azing +ĠSer aph +Ġha ze +w ow +Ġextingu ished +Ġcan yon +ĠB osh +Ġv ents +Ġsc rape +Cor rect +4 26 +Ġav g +Dem and +ĠâĪ ¼ +Ġmicrobi ota +"} ]," +ĠSt ev +B io +ĠPlan es +Ġsuggest ive +Ġdec ipher +ĠRefuge e +ĠKe jriwal +ĠGreen peace +Ġdecl ass +ĠSound ers +Ġth o +Ġdec rypt +Ġbr ushing +ĠJane iro +ip op +S i +8 77 +ĠGeoff rey +Ġc pu +ĠHaz el +Ġview points +Ġcris py +ĠNot ification +Ġsold er +ĠMod est +ĠHem isphere +Ġcass ette +in cludes +Ġident ifiers +ĠC ALL +in cent +T odd +ĠSwe ep +Ġ3 34 +b oss +Ġsm ir +gin x +Ġtown ship +Ġg rieving +ĠMos que +Net flix +AS ED +ĠMillenn ials +oc om +19 67 +Ġbold ly +s leep +Ġes che +arij uana +Ġsw irl +ĠPen al +Ġneglig ent +ĠStephen son +K ER +ĠZ oro +ris is +Ġlocal ization +ĠSeym our +ĠAng lic +red itation +prot ection +ĠPa ige +Ġo mit +ĠR ousse +ĠT ub +Ġinv itations +t ty +Ġm oss +ph ysical +C redits +Ġan archy +Ġchild care +Ġl ull +ĠM ek +ĠL anguages +lat est +ĠSan ford +Ġus ability +Ġdiff use +ĠD ATA +Ġsp rites +ĠVeget a +ĠProm otion +ãĥ¼ ãĤ¯ +rict ing +z ee +Tur kish +ĠTD s +pro ven +57 1 +Ġsmug glers +707 10 +Ġreform ed +ĠLo is +Ġun fl +ĠWITH OUT +ĠReturn ing +ann ie +ĠTom as +Fr anc +ĠProf it +ĠSER V +ĠR umble +ik uman +es an +Ġt esters +Ġgad get +Ġbrace let +ĠF SA +comp onent +Ġparamed ics +Ġj an +ĠRem em +ĠSk inner +Ġl ov +ĠQu ake +rom a +Ġfl ask +Pr inc +Ġover power +Ġlod ging +ĠK KK +ret te +Ġabsor bs +w rote +Ġ ," +K ings +ĠH ail +ĠFall ing +xt ap +ĠHel ena +ire ns +L arry +Ġpamph let +ĠC PR +G ro +ĠHirosh ima +Ġhol istic +". [ +Ġdet achment +Ġas pire +Ġcompl icit +ĠGreen wood +Ġresp awn +ĠSt upid +ĠFin ished +f al +b ass +Ġab hor +Ġmock ery +ĠFe ast +VID EO +Ġcon sec +ĠHung ry +P ull +ĠH ust +it ance +? ãĢį +) -- +ĠPar allel +con v +4 69 +ha ar +w ant +P aper +m ins +ĠTor o +ĠTR UMP +ĠR ai +D W +ĠW icked +ĠL ep +Ġfun ky +Ġdetrim ent +ios is +ache v +Ġde grade +im ilation +Ġret ard +Ġfrag mentation +Ġcow boy +ĠY PG +ĠH AL +Parent s +ĠS ieg +ĠStra uss +ĠRub ber +× IJ +Fr ag +Ġp t +Ġoption ally +ĠZ IP +ĠTrans cript +ĠD well +88 2 +M erc +ĠM OT +ãĥ¯ ãĥ³ +Ġhun ts +Ġexec utes +In cludes +Ġacid ic +ĠRespons ibility +ĠD umb +we i +And erson +ĠJas per +ight on +abs olutely +Ad ult +Ġpl under +Mor ning +ĠT ours +ĠD ane +Î º +ĠT EST +ĠG ina +Ġcan ine +aw an +Ġsocial ists +ĠS oda +Ġimp etus +ĠSupplement ary +oli ath +ĠKinn ikuman +mitted ly +second s +Ġorganis ers +Ġdocument aries +Vari able +GRE EN +Ġres orts +Ġbr agging +Ġ3 68 +Art ist +w k +bl ers +Un common +ĠRet rieved +Ġhect ares +Ġtox in +r ank +Ġfaith s +ĠG raphic +Ġve c +ĠL IA +Af rican +Ġard ent +end iary +L ake +ĠD OS +cient ious +ĠOk awaru +ĠAll y +ĠTim eline +D ash +ĠI c +contin ue +Ġt idy +Ġinstinct ively +ĠP ossibly +ĠOut door +ĠWould n +Ġl ich +ĠBr ay +ĠA X +Ġà ī +Ġ+ # +\ ' +Direct ory +ab iding +Ġf eral +ic ative +but t +Ġper verse +S alt +Ġwar ped +Ġnin eteen +Ġcabin ets +Ġsrf Attach +ĠSl oan +Ġpower ing +reg ation +F light +se vere +Ġst ren +Ġc og +ap ache +Ġâ Ŀ +Ġcaf eteria +p aces +ĠGrim oire +uton ium +Ġr aining +Ġcir cling +Ġlineback ers +c redit +Ġrep atri +ĠCam den +lic ense +Ġly ric +Ġdescript or +Ġval leys +Ġre q +Ġback stage +ĠPro hibition +ĠK et +Op ening +S ym +æĸ ¹ +Ġserv ings +Ġoverse en +Ġaster oids +ĠMod s +ĠSpr inger +ĠCont ainer +è » +ĠM ens +Ġmult im +Ġfire fighter +pe c +Ġchlor ine +Ð ¼ +end i +Ġsp aring +Ġpolyg amy +ĠR N +ĠP ell +Ġt igers +Ġflash y +ĠMad ame +S word +Ġpref rontal +Ġpre requisite +uc a +Ġw ifi +Ġmiscon ception +Ġharsh ly +ĠStream ing +ot om +ĠGiul iani +foot ed +Ġtub ing +ind ividual +z ek +n uclear +m ol +Ġright ful +49 3 +Ġspecial ization +Ġpassion ately +ĠVel ocity +ĠAv ailability +T enn +Ġl atch +ĠSome body +Ġhel ium +cl aw +Ġdi pping +XX X +Ġinter personal +7 10 +Ġsub ter +Ġbi ologists +ĠLight ing +Ġopt ic +Ġden im +end on +ĠC orm +Ġ3 41 +ĠC oup +Ġfear less +Ġal ot +ĠCliff ord +ĠRun time +ĠProv ision +up dated +lene ck +Ġneur on +Ġgrad ing +ĠC t +sequ ence +in ia +con cept +Ġro aring +ri val +ĠCaucas ian +Ġmon og +key es +Ġappell ate +Ġlia ison +EStream Frame +ĠPl um +! . +Ġsp herical +Ġper ished +Ġbl ot +Ġben ches +Ġ4 11 +Ġpione ered +Ġhur led +Jenn ifer +ĠYose mite +Ch air +Ġreef s +Ġelect or +ĠAnt hem +65 2 +Ġun install +Ġimp ede +Ġbl inking +Ġgot o +Dec re +A ren +Ġstabil ization +ĠDis abled +ĠYanuk ovych +Ġoutlaw ed +ĠVent ura +ten ess +Ġplant ation +Ġy acht +ĠHu awei +Ġsol vent +Ġgr acious +Ġcur iously +Ġcapac itor +Ġc x +ĠRef lex +Ph ys +ĠC f +pt in +cons ervative +Ġinv ocation +c our +F N +ĠNew ly +H our +As ian +ĠLe ading +ĠAer ospace +An ne +Ġpre natal +Ġdeterior ating +H CR +ĠNorm andy +ol ini +ĠAm bro +9 10 +Ġset backs +ĠT RE +Ġs ig +ĠSc ourge +59 7 +79 8 +Game play +Ġm sec +M X +Ġprice y +ĠL LP +aker u +Ġover arching +ĠB ale +Ġworld ly +Cl ark +Ġscen ic +Ġdisl iked +ĠCont rolled +T ickets +ĠE W +ab ies +ĠPl enty +Non etheless +Ġart isan +Trans fer +ĠF amous +Ġinf ield +ble y +Ġunres olved +ĠML A +ãĤ Ĥ +Cor rection +Ġdemocr at +ĠMore no +ro cal +il ings +Ġsail or +Ġr ife +h ung +Ġtrop es +Ġsn atched +ĠL IN +ĠB ib +ES A +ĠPre v +ĠCam el +run time +Ġob noxious +4 37 +Ġsum mers +Ġunexpl ained +ĠWal ters +cal iber +Ġg ull +ĠEnd urance +ä½ ľ +Ġ3 47 +Ir ish +Ġaer obic +Ġcr amped +ĠHon olulu +à © +us erc +ec ast +AC Y +ĠQu ery +ãĤ¹ ãĥĪ +Bet a +Ġsuscept ibility +ĠSh iv +ĠLim baugh +Ġà ĸ +ĠN XT +ĠM uss +ĠBrit ons +ES CO +EG IN +Ġ% % +Ġsec ession +ĠPat ron +ĠLu a +n aires +ĠJPM organ +us b +ocy te +Ġcouncill ors +ĠLi ang +f arm +Ġnerv ously +Ġattract iveness +ĠK ov +j ump +Pl ot +Ġst ains +ĠStat ue +ĠApost les +he ter +ĠSUP PORT +Ġoverwhel m +Y ES +Ġ29 1 +d ensity +Ġtra pping +M it +Ġf ide +ĠPam ela +atl antic +Dam n +Ġp ts +OP A +Ġserv icing +Ġoverfl owing +ul o +ĠE rit +t icket +light ing +ĠH mm +ãĥ¼ ãĥ« +im oto +Ġchuck le +4 23 +ãģ ķ +sh ape +Ġque ues +Ġanch ors +ãĤ¼ ãĤ¦ãĤ¹ +F er +Ġaw oke +Ġ6 66 +h ands +Ġdiver gence +Ġ50 5 +T ips +Ġdep ot +Ġske w +ĠDel iver +op ot +Ġdiv ul +ĠE B +uns igned +ĠUn i +X box +Ġfor ks +Ġ7 02 +å ¯ +Ġpromot ers +ĠV apor +Ġlev ied +sl ot +Ġpig ment +Ġcyl inders +C RE +Ġsn atch +Ġperpet ually +Ġl icking +ĠFe et +ĠKra ken +ĠHold en +ĠCLS ID +m r +Ġproject or +Ġden otes +Ġchap el +ĠTor rent +b ler +R oute +ĠDef endant +ĠPublisher s +ĠM ales +ĠInn ov +ĠAg ility +rit er +ty mology +st ores +L ind +Ġf olly +ĠZur ich +B le +Ġnurt ure +Ġcoast line +uch in +D omin +Ġfri vol +ĠCons olid +res ults +M J +Ġphyl ogen +Ġha uled +ĠW iley +ĠJess ie +ĠPrep are +ĠE ps +Ġtreasure r +I AS +Ġcolon ists +Ġin und +ĠWW F +ĠCon verted +6 000 +out side +ĠApp earance +ĠRel ic +ĠM ister +s aw +Ġresult ant +Ġadject ive +ĠLaure l +ĠHind i +b da +Pe ace +Ġreb irth +Ġmembr anes +Ġforward ing +Ġcoll ided +ĠCar olyn +K ansas +5 99 +ĠSolid GoldMagikarp +Be ck +Ġstress ing +ĠGo o +ĠCooper ative +Ġf s +ĠAr chie +L iter +ĠK lopp +J erry +Ġfoot wear +War ren +Ġsc ree +h are +Under standing +P ed +Ġanth ology +ĠAnn ounce +M ega +Ġflu ent +Ġbond age +ĠDisc ount +il ial +C art +ĠNight mares +Sh am +ĠB oll +uss ie +H ttp +Atl anta +Ġun recogn +ĠB id +Ġunder grad +Ġforg iving +ĠGl over +AAAA AAAA +4 45 +V G +pa io +kill ers +Ġrespons ibly +Ġmobil ize +Ġeffect ed +ĠL umin +Ġk ale +Ġinfring ing +ann ounced +Ġf itt +b atch +ĠT ackle +ĠL ime +ĠAP P +uke mia +Ġrub y +Ġex oner +ĠCas ual +0 70 +Ġpel vic +Ġautom ate +ĠK ear +ĠCoast al +Ġcre ed +Ġbored om +ĠSt un +ri ott +Ĥ İ +Ġregener ate +Ġcomed ians +ĠOP ER +Sp ons +id ium +on is +L ocated +05 7 +Ġsusp ense +ĠD ating +C ass +Ġneoc ons +ĠShin zo +Ġaw oken +ch rist +ĠMess ages +att led +ĠSpr ay +ĠSp ice +C W +Ġshield ing +ĠG aul +Am id +Ġparam ilitary +Ġmult if +ĠTan ner +il k +Ġgodd amn +g ements +Ġbe friend +m obi +Ġ3 88 +fold er +acc a +Ġins in +g ap +N ev +fif th +Ġpsychiat ry +b anks +TH IS +Ġhar b +ac qu +Ġfac ade +ĠPower Point +80 3 +Ġbl uff +Sh ares +Ġfavor ing +El izabeth +Ãį Ãį +Ġr anger +77 2 +ĠAr che +h ak +ĠGen etics +ĠF EMA +Ġev olves +Ġest e +ĠP ets +ĠM é +ĠInterest ing +ĠCanter bury +ch apter +ĠStar fleet +Sp anish +Ġdraw back +ĠNor wich +9 70 +n orth +ag anda +Ġtransform ative +ram ids +bi ology +ad ay +Ġpropag ation +ĠGam ma +ĠDen ise +ĠCalcul ator +ent imes +ĠB ett +Ġapp endix +ĠHD D +AK ING +Ġst igmat +Ġhol ster +Ġord inarily +Ch ance +ĠCont rary +Ġad hesive +Ġgather s +6 12 +re au +ony ms +ew ays +Ġindu ces +Ġinterchange able +se m +Wh it +Ġtr ance +Ġincorpor ation +ĠExt ras +Fin ancial +Ġawkward ly +ĠStur geon +ĠH Y +Norm ally +ĠEnd ing +ĠAss ist +enc rypted +Ġsub jug +Ġn os +Ġfan atic +C ub +C U +?" . +Ġirre versible +å Ĥ +03 1 +ĠH AR +sp read +ul ia += $ +Sc ope +L ots +Ġlif estyles +ol on +Ġf eds +Ġcongrat ulate +web kit +Ġindist inguishable +ĠSw ing +Ġcommand ments +qu ila +ab ella +m ethyl +ann abin +Ġo vere +Ġlob ster +ĠQU EST +ĠCONT IN +bern atorial +:::: :::: +ĠTra ve +ĠSam oa +AN I +75 2 +Ð ´ +userc ontent +ĠMod erate +y eah +ĠK itt +Ġwe e +Ġstuff ing +ĠInter vention +ĠD ign +Ġware houses +ĠF iji +Ġpel lets +Ġtake away +ĠT ABLE +ĠClass ical +col lection +Ġland fall +ĠMus cle +Ġsett les +ĠAD V +Ġ3 44 +L aura +Ġf ared +ĠPart ial +4 36 +oss ibility +ĠD aly +ĠT arant +ĠFu ji +am l +c ence +55 1 +ĠProced ures +ĠO CD +ĠU D +t in +Q UI +ach o +4 38 +Ġgl itches +Ġenchant ment +Ġcalcul ates +IR O +ĠH ua +alys es +ĠL ift +um o +Ġle apt +Ġhypothes ized +ĠGust av +it ans +VERS ION +æ ł +Rog er +Ġr and +ĠAd apter +Ġ3 31 +ĠPet ition +k ies +M ars +Ġunder cut +ze es +ĠLy ons +ĠDH CP +Miss ing +Ġretire es +Ġins idious +el i +> ) +. ãĢį +Ġfinal ists +ĠA ure +Ġacc user +Ġwas tes +ĠY s +ĠL ori +Ġconstitu encies +Ġsupp er +Ġmay hem +or ange +Ġmis placed +Ġmanager ial +Ġex ce +ĠCL I +Ġprim al +ĠL ent +Cry stal +h over +ĠN TS +end um +Ġd w +ĠAl c +n ostic +Ġpres erves +ĠTs arnaev +Ġtri pled +rel ative +Arc ade +k illing +ĠW EEK +ĠH anna +D ust +Com pleted +ģ « +Ġappro ves +ĠSur f +ĠLuther an +ven ants +Ġrobber ies +we ights +soft ware +at ana +ug al +Ġgrav y +ĠC ance +OLOG Y +ly ak +Ton ight +Ġunve il +Ġ19 04 +ĠMin ion +ent ious +st ice +pack ages +ĠG EAR +Ġg ol +ĠHutch inson +ĠProf ession +ĠG UN +ĠDiff erence +ĠTsuk uyomi +ĠLes bian +6 70 +Ġfug itive +ĠPlan etary +-------------------------------- ------------------------ +Ġacc rued +Ġch icks +Ġsto pp +Ġblock ers +C od +Ġcomment ers +ĠSomew here +ĠPhot ographer +the me +Ġmay oral +w u +Ġanten nas +Ġrev amped +ĠSubject s +it é +im ura +Ġentr ances +liter ally +Ġten ets +ĠO MG +ĠMP H +ĠDon key +ĠOff ense +Ġ" + +Sn ap +ĠAF B +Ġan imate +ĠS od +His panic +Ġinconsist ency +D b +F Y +Ex port +Ġa pe +Ġpear l +ib el +ĠPAC s +Ġ{ \ +Ġact u +ĠHS BC +camp us +Ġpay off +Ġde ities +ĠN ato +ou ple +Ġcens ored +ĠCl ojure +Ġconf ounding +en i +Ġreck on +op he +Ġspot ting +Ġsign ifies +Ġprop el +Ġfest ive +S uggest +Ġpled ging +ĠB erman +Ġrebell ious +Ġovershadow ed +Ġinfiltr ated +j obs +67 2 +Ġscal able +Ġdomin ion +ĠNew foundland +ĠMead ow +Ġpart itions +AM I +Ġsupplement ary +str ument +Ġhair y +Ġperpet uate +Ġnuts hell +ĠPot ato +ĠHob bit +Ġcur ses +Flo at +Ġquiet er +Ġfuel ing +Ġcaps ules +ĠL ust +ĠH aunted +Exec utive +Ġchild birth +G re +Ġrad iant +å İ +Ġm alls +Ġin ept +ĠWarrant y +Ġspect ator +E h +t hens +Ġculmin ating +æ © +ary a +ãĤ ® +ilit arian +ĠOR IG +ĠSp ending +pt ives +ĠS iren +ĠRec ording +ay ne +Ġv im +Ġspr ang +T ang +ĠM FT +mor ning +ĠWe ed +m peg +cess ion +ĠCh ung +7 30 +w arning +56 2 +handed ly +P oor +P olitics +: # +Ġp ian +Ġfec es +ĠDocument ation +Ġban ished +Ġ3 99 +ĠAR C +Ġhe inous +J ake +ĠAm ir +way ne +v re +os henko +Ġnotebook s +Ġfound ational +Ġmarvel ous +ixt ape +Ġwithdraw als +Ġh orde +ĠD habi +is able +ĠK D +Ġcontag ious +ĠD ip +ĠAr rows +Ġpronoun s +Ġmorph ine +ĠB US +68 2 +Ġk osher +fin ished +ĠInstr uments +Ġf used +yd en +ĠSal mon +F ab +aff ected +K EN +C ENT +Dom ain +Ġpoke mon +ĠDr inking +G rowing +ĠInvestig ative +ĠA ether +em i +Ġtabl oid +Ġrep ro +ĠNot withstanding +ĠBers erker +Ġdram as +Ġclich é +Ġb ung +ĠU RI +ĠD os +0 44 +Ġpast ors +Ġl s +Ġac rylic +aun ts +Ed ward +Ġmajor ities +B ang +Ġfield ing +ĠRepl acement +ĠAl chemy +pp ard +ĠRome o +ĠSan ct +ĠLav rov +ib ble +Inst ruct +Ġimp ractical +ĠPlay boy +ce phal +Ġsw aps +Ġk an +ĠThe o +Ġillust rating +Ġdismant led +ĠTrans gender +ĠG uth +UG H +Ġtriumph ant +Ġencomp ass +Ġbook mark +udd in +j er +Ġpred icate +ES H +Ġwhen ce +ĠAB E +Ġnon profits +Se qu +Ġdi abetic +Ġp end +Ġheart felt +sh i +Ġinter acts +ĠTele com +Ġbombard ment +dep ending +ĠLow ry +ĠAd mission +ĠBl ooming +ust ration +ene gger +B rew +Ġmol ten +ĠNer d +P IN +âĸ Ģ +ave ment +Ġtou red +Ġco efficients +ĠTray von +ans son +Ġsand y +t old +fl ows +Ġpop ulous +ĠT inder +ĠBl iss +R achel +Min imum +Ġcontest ant +ĠRed uce +ĠMor se +ĠGrass ley +ĠClick er +Ġexp r +Ġs incerity +Ġmar qu +Ġelic it +ĠPro position +ĠDemon ic +Ġtac os +G reek +Ġpost war +Ġin sofar +ĠP ork +Ġ35 2 +doctor al +walk ing +Ġmid term +ĠSam my +sight ed +ĠTR ANS +ic i +AL D +ĠUS L +ĠF ISA +ĠAm pl +ĠAlex andra +ine lli +Tr ain +Ġsign ify +ĠVers us +Ġob fusc +Ġk h +Ġagg ro +ĠRen ault +Ġ3 48 +5 18 +ox icity +0 22 +ĠTw ist +Ġgoof y +D ynamic +Ġbrief ings +m ight +8 99 +Ġderog atory +T ro +Ġfor ging +ĠKor an +ĠMar ried +ĠBuc s +Ġpal ate +ĠCon version +m able +4 13 +Ġ( _ +Ġs iph +ĠN EO +col lege +Ġmarg inally +Ġfl irt +ĠTra ps +ĠP ace +é »Ĵ +Ġgoalt ender +Ġforb ids +Ġcler ks +ĠT ant +ĠRobb ins +ĠPrint ing +Ġpremie red +Ġmagn ification +ĠT G +ĠR ouse +ĠM ock +odynam ics +Ġpre clude +ism o +ĠPul itzer +Ġaval anche +ĠK odi +rib une +ĠL ena +Elect ric +Ġref inery +Ġend owed +Ġcounsel ors +Ġd olphin +ĠM ith +Ġarm oured +hib ited +Beg in +ĠP W +O il +ĠV or +ĠShar if +ĠFraz ier +est ate +Ġj ams +Pro xy +Ġband its +ĠPresbyter ian +ĠPrem iere +t iny +ĠCru el +Test ing +Ġhom er +ĠV ERS +ĠPro l +ĠDep osit +ĠCoff in +Ġsemin ars +Ġs ql +ĠDef endants +Altern atively +ĠR ats +ç « +ethy st +' > +Ġiss uer +58 9 +Ġch aired +ĠAccess ories +man ent +Ġmar row +ĠPrim ordial +C N +Ġlimit less +ĠCarn age +Ġund rafted +q v +IN ESS +on ew +Ġco hesion +98 7 +Ġne cks +Ġfootball er +ĠG ER +Ġdetect able +ĠSupport ing +ĠCS V +oc ally +k Hz +Ġund e +Ġsh one +Ġbud ding +tra k +Stand ing +ĠStar craft +ĠKem p +Ben ch +Ġthw arted +ĠGround s +ath i +L isa +Dial og +ĠS X +V ision +Ġingen ious +Ù IJ +Ġfost ering +ĠZ a +ĠIn gram +Ġ" @ +N aturally +6 16 +0 35 +ĠF AC +H mm +55 4 +Ġacceler ator +ĠV end +Ġsun screen +Ġtuber culosis +rav iolet +ĠFunction al +ĠEr rors +ed ar +19 66 +ĠSpect re +ĠRec ipes +88 5 +ĠM ankind +L iverpool +Ġ| -- +Ġsubst itutes +ĠX T +w ired +Ġinc o +ĠAf gh +E va +ic c +S ong +K night +Ġdilig ently +ĠBroad cast +A id +Ġaf ar +ĠH MS +aton in +ĠGr ateful +Ġfire place +ĠOm ni +e uro +ĠF RE +ĠSh ib +ĠDig est +t oggle +Ġheads ets +Ġdiff usion +ĠSqu irrel +ĠF N +Ġdark ened +out her +Ġsleep s +ĠX er +gun s +Ġset ups +Ġpars ed +Ġmamm oth +ĠCur ious +g ob +ĠFitz patrick +ĠEm il +im ov +........ ..... +ĠB enny +Second ly +Ġheart y +Ġcons on +st ained +Ġgal actic +cl ave +Ġplummet ed +Ġp ests +Ġsw at +Ġrefer rals +ĠLion el +h oly +Ġunder dog +ĠSl ater +ĠProv ide +ĠAm ar +ress or +å Į +ong a +Ġtim id +Ġp iety +ĠD ek +Ġsur ging +az o +Ġ6 10 +Ġdes ks +ĠSp okane +ĠAn field +Ġwars hips +ĠCob ra +Ġar ming +clus ively +ĠBad ge +ag ascar +ĠPR ESS +ĠMcK enzie +ĠFer dinand +burn ing +Af ee +Ġtyr ann +ĠI w +ĠBo one +100 7 +ĠRe pt +Ċ Âł +Ġcar avan +ĠD ill +ĠBundes liga +Ch uck +Ġheal er +ãĥ¼ãĥ Ĩ +ĠH obby +Ġneg ate +Ġcrit iques +section al +mop olitan +Ġd x +Ġouts ourcing +ĠC ipher +t ap +Sh arp +Ġup beat +Ġhang ar +Ġcru ising +ĠNi agara +Ġ3 42 +ill us +ĠS v +Ġsubt itles +Ġsqu ared +Ġbook store +Ġrevolution aries +ĠCarl ton +ab al +Ut ah +Ġdesp ise +ĠU M +cons ider +aid o +Ġc arts +ĠT urtles +Tr aining +Ġhonor ary + ¢ +Ġtri angles +4 22 +Ġreprint ed +Ġgrace ful +ĠMong olia +Ġdisrupt ions +ĠB oh +Ġ3 49 +Ġdr ains +Ġcons ulate +Ġb ends +Ġm afia +ur on +ĠF ulton +m isc +Ġren al +Ġin action +ck ing +Ġphot ons +Ġbru ised +ĠC odes +og i +Ġn ests +ĠLove ly +ĠLib re +ĠD aryl +Ġ# ## +S ys +. ," +Ġfree zes +est ablishment +and owski +Ġcum bers +ĠSt arg +ĠBom bs +Ġleg ions +Ġhand writing +Ġgr un +ĠC ah +sequ ent +Ġm oth +ĠMS M +Ins ert +F if +Ġmot el +Ġdex ter +ĠB ild +hearted ly +Ġpro pe +ĠText ure +ĠJ unction +ynt hesis +oc ard +ĠVer a +ĠBar th +Ġμ g +Ġl ashed +Ġ35 1 +ĠZ amb +ĠSt aples +ĠCort ex +ĠCork er +Ġcontinu um +ĠWR ITE +unt a +rid or +Ġde ems +0 33 +ĠG OLD +p as +Ġrep ressive +ãĥĨ ãĤ£ +Ġbaff led +Sc ar +Ġc rave +Ġ ______ +Ġentrepreneurs hip +ĠDirector ate +Ġ' [ +Ġv ines +Ġasc ended +ĠGR OUP +ĠGood bye +Ġdo gged +ãĥ´ ãĤ¡ +Man ufact +Ġunimagin able +ri ots +ier rez +Ġrel ativity +ĠCraft ing +ra ught +ud en +c ookie +Ġassass ins +Ġdissatisf ied +ac ci +Ġcondu it +Sp read +ĠR ican +n ice +izz le +Ġsc ares +ĠWH Y +ph ans +5 35 +Ġprot racted +ĠKrist en +5 36 +ĠSc rib +ĠNe h +Ġtwent ies +Ġpredic ament +Ġhandc uffs +Ġfruit ful +ĠU L +ĠLud wig +Ġatt est +ĠBre aker +Ġbi ologically +ĠDeal er +Ġrenov ations +f w +ess en +Al ice +ĠHen ri +Ġun ilaterally +ĠS idd +h ai +ĠSt retch +S ales +Ġcumbers ome +ĠJ avier +Ġtrend y +Ġrot ting +ĠChall enges +Ġscra ps +Ġfac ets +ĠVer onica +ĠVer ge +ĠS ana +Al ien +ĠR ih +Ġrad ial +ect ar +Ġ6 30 +cl i +Mar ie +Ġwild fire +ĠCat o +h ander +Ġwait ress +Ġch ops +ĠS ECTION +Ġblunt ly +ĠCat alog +n ian +stud y +Ġpat rolling +ĠT enth +nex us +ĠN ON +op sy +Ġsc athing +s ie +Ġdeterior ated +V B +Naz is +Ġdep ictions +Ġauthent icated +ĠCon ce +k rit +Ġpromul g +ĠL ONG +U FC +ĠVis itors +ĠRec all +Ġrehab ilit +ĠSL I +Ġglac ier +ĠB ite +Ġ50 3 +Ġvom it +Ġfer mented +ĠKh alid +Ġgrad ed +ĠMag icka +ĠIch igo +power ful +ic ators +75 3 +Ġsh rew +Ġ35 6 +Ġlegal izing +Ġall otted +ĠArch demon +ith ing +igg urat +V OL +Le od +Ġo ily +Ġindu cing +Ġamy gdala +Ġadm ins +ĠAcqu isition +C AN +Ġsche matic +Ġmo an +ĠCamer oon +Ġt ink +Ġmer ry +Ġbutter flies +ĠGo ff +Ġworks pace +ĠCor ona +Ġj avascript +ĠD olphin +ĠCant or +4 64 +to e +AP S +ĠAg ing +Ġpadd ed +ĠZ heng +ĠHe ld +Ġest ranged +Ġ7 70 +. } +ĠDun ham +Ġsm okes +Ġcap itals +und ai +Sh in +ĠFound ing +Ġent itle +Ġcenter piece +D iscover +Ġthere to +al ert +ĠN ou +ĠAnaly st +l c +F H +FI ELD +ĠP OV +gr ay +Ġar cs +ĠH OT +Ġr s +Ġoblig atory +ĠArchitect s +ĠS ven +ĠF EC +0 200 +Christ mas +ĠAlban ia +rat om +58 7 +Ġhard ships +Ġaut os +ĠCharg es +Ġap es +Ġ3 76 +wal let +Ġintox ication +Ġgobl in +Ġ5 70 +++++++++ ++++++++ +ĠYel p +ĠMag netic +ĠBr iggs +R ail +Ġspawn s +ĠW iggins +Ġshowc ased +Ġres orted +ub en +Ġwh ipping +Ġim itate +Ġdigest ion +ĠUS PS +ĠG est +Ġye a +ĠT ight +ind al +ic as +` . +C AST +'' ; +ĠF et +opath ic +In valid +Ġregrett ed +Ġbro ccoli +ĠSc ores +e ve +Ġpost ings +Ġaccum ulating +Ġneed less +elf th +Ġmay ors +Ġsc rib +Ġanecd otes +Ġbot ched +ĠRib bon +ĠConstant ine +i uses +ess es +Ġdev ise +Comp ared +Ġp udding +Ġg arg +Ġev oke +79 7 +Ġdet ox +9 09 +ĠPie ces +ĠMcC artney +Ġmet ast +ĠK rypt +P OR +Ġt ending +ĠMerch ants +Pro of +ĠV arg +ĠPort able +ãĥ¼ãĥĨ ãĤ£ +B rain +25 00 +Ġfol iage +Ø ¹ +Ġment ors +ĠA ires +Ġminimal ist +Ġing ested +ĠTro jan +ĠQ ian +inv olved +0 27 +Ġer oded +RA FT +Ġbl urry +M ob +Ġbuff et +ĠFn atic +ae a +KN OWN +ĠIn it +s afety +en um +ACT ION +ĠCrus her +ĠD ates +Ġ ................ +c alling +ak ov +Ġvent ured +Ġ5 55 +au ga +H art +ĠA ero +M AC +Ġthin ly +Ġar ra +ST ATE +ild e +ĠJac qu +ĠFem ales +Ġthe orem +Ġ3 46 +Ġsmart est +ĠPU BLIC +ĠK ron +ĠB its +ĠV essel +ĠTele phone +Ġdec ap +Ġadj unct +ĠS EN +mer ga +Ġred acted +Ġpre historic +Ġexplan atory +ĠRun s +ĠUtt ar +ĠM anny +ĠAUTH OR +ĠUnle ashed +ĠBow ling +be ans +79 3 +Ġunivers es +Ġsens it +ĠK ung +re peat +ctr l +Ġp aced +Ġfull er +Cl ock +Ġrec omb +ĠF aul +ĠB unker +Ġpool ed +Ġan a +ĠM outh +LL OW +hum ane +Ġbull do +ĠMicha els +f am +Ġwreck ed +Ġport rays +ĠWh ale +ĠH es +Ġguess es +ĠBrow se +ĠL APD +Ġconsequ ential +ĠInn ocent +ĠD RAG +Ġtrans gress +ĠO aks +Ġtri via +ĠRes on +ĠA DS +-- + +ĠT oll +Ġgrasp ing +ĠTHE M +ĠT ags +ĠCon clusion +Ġpract icable +Ġho op +Ġunintention ally +Ġign ite +ĠM ov +ur ized +le hem +Ter min +Ġcolour ful +ĠLin ear +ĠEll ie +G y +Ġman power +Ġj s +Ġem oji +ĠSHAR ES +_ . +0000 7 +Ġsophistic ation +Ġunders core +Ġpract ise +Ġbl ob +op ens +Uk raine +Ke eping +Y C +J R +ult imate +Cl aim +Ġautom obiles +99 3 +ste el +Ġpart ing +ĠL ank +... ? +Ġ38 5 +Ġremem brance +Ġe ased +Ġcov ari +ĠS ind +Effect ive +Ġdisse mination +ĠMo ose +ĠCl apper +br ates +App ly +Ġinv is +Ġwors ened +âĢĶ - +Ġlegisl ator +ĠL ol +ĠRow e +Ġdealers hip +um ar +id ences +Ġinvestig ates +Ġc ascade +Ġbid der +ĠB EN +Iron ically +Ġpres iding +Ġd ing +Ġcontrad icted +Ġshut s +ĠF IX +Ġ3 66 +Dist rict +Ġsin ful +ĠChar isma +o ops +Ġtot ality +Ġrest itution +ĠOpt imus +ĠD ah +Ġcl ueless +urn ed +Ġnut rit +Ġland owners +Ġfl ushed +Ġbroad en +m ie +Ġprint ln +Ġn ig +ĠCorp us +J en +Ġprot o +ĠWik imedia +ĠPal o +C OR +Ġstory lines +Ġevangel icals +ĠDar rell +Ġrot or +ĠH W +sk illed +ery l +Ġbe gg +ĠBl umenthal +Ġwe aving +Ġdown wards +ĠJack et +ĠANG EL +Te chnology +Ġes oteric +alde hyde +Ġfur iously +Ġforeign er +We ak +CH O +ĠH ound +Exper ience +ĠPlay station +ĠM IA +ĠU ng +cl oth +ag all +Ġcal ming +iz ens +St ruct +ĠW itches +ĠCeleb ration +Ġ........ ...... +pt roller +ĠTC U +Ġb unny +ãĥ į +ut orial +Ġup scale +ĠSt a +ĠCol ossus +Ġchlor ide +ĠZ ac +ĠRe asons +ĠBrook ings +ĠWH ITE +][ / +ĠL ose +9 05 +Ġunders ide +ern els +Ġv ape +do zen +upp et +ĠST OP +mat ical +ĠStat ements +hed dar +P AC +Custom er +Ġmem os +ĠP J +end ars +ĠLim its +l augh +Ġstabil ized +ĠALE C +Y A +Up grade +al am +Ġtechn o +Ġan ew +fore seen +Ġcolleg iate +ĠPy ro +ĠD ism +Ġfront line +Ġammon ia +I U +Qu ite +John ny +ass in +G OP +ĠSt yles +ĠSovere ign +acter ial +5 49 +ĠR IP +ĠL ists +Ġ3 64 +ĠRece p +s ocket +ĠByr d +ĠCand le +An cient +Ġappell ant +en forcement +ace a +ans ki +Ġold s +88 6 +Ġsl urs +Ġem pires +Ġbuck le +Ġalien ation +ĠAber deen +Ġunic orn +Ġoverr iding +ĠL X +pp a +Ġdesp ised +ĠB ugs +ĠB ST +S outhern +5 33 +Ġhall mark +ĠPost er +Ġstem med +Ġprincip als +ĠT ECH +ĠSand wich +It aly +Ġche esy +ĠSet TextColor +ĠProt ective +ĠC ohn +J O +apt op +Re ason +Lead er +ĠUnder stand +ĠFr idays +ĠContin uous +Ġcl ipping +ĠR ye +Ġber th +tim er +ann is +re act +Ġbuff alo +ĠPar as +Ġ6 55 +Ġpres ided +ĠSun rise +Ġve ts +Ġcl oves +ĠMcC ull +Stre ngth +G AN +Ġill iter +ĠPric ing +l é +Ġresist or +Ġbr un +ĠSuff olk +Ñ ĭ +ĠL iver +Re leased +Ġwhat s +8 60 +ĠMe asures +Ġden ouncing +ĠRy zen +Ġsou ven +Ġcareg ivers +ch ini +ĠScar lett +Ġt rough +Cong ratulations +Ġtax is +ĠTrad ition +j it +Ġtable top +Ġhither to +Ġdis information +off ensive +h ra +ĠDISTR ICT +Ġcompl icate +chen ko +ĠRecon struction +Ġpalp able +Ġa usp +Ġ4 28 +Ġshowc ases +ĠPublic ation +know ledge +inn on +4 19 +Ġretri eval +and ers +Ġref ute +Ġinqu ired +g ur +Ġneg ativity +Ġcons erve +Ġafter life +Ġpres upp +ĠGill espie +Ġm t +ĠD N +T ap +Ġper pend +ĠS my +does n +Ġsp illing +Ġhyp ers +K ate +® , +ke pt +ĠP owered +Ġj a +ĠK lux +ard e +ab an +Ġ4 44 +Ġflatt ened +ĠImprove ments +urg a +ĠK und +Ġins cribed +Ġfac ult +Ġunpre pared +ĠCons umers +Ġsatisf ies +Ġpul monary +Ġinf iltration +Ġex ternally +Ġcongrat ulations +ag han +Ġair liner +Ġfl ung +Ġfly ers +G D +Ġsnipp ets +Ġrec ursive +Ġmaster ing +L ex +Ġovert ly +v g +Ġluck ily +Ġenc ro +ĠLanc et +ĠAbyss al +function al +Ġs ow +Ġsqu id +Ġnar ration +Ġn aughty +ĠHon our +ĠSpart ans +Ġsh atter +ĠTac oma +ĠCal ories +ĠR aces +Sub mit +Ġpurpose fully +w av +ĠY ok +F est +ĠG err +Met ro +Ġit iner +f amous +Ġ" { +in line +was her +Iss ue +ĠCL IENT +oz o +Vers ions +7 25 +ĠGl ock +Ġshield ed +ĠPC R +ENC Y +ĠWe ld +ĠSim pl +Ġredirect ed +ĠK ham +Ġ( > +Ġlab ou +Ġdi apers +ss l +Ġcell ar +organ isms +ore sc +ĠBer ks +did n +Sh ipping +C hest +Ġund one +Ġmillion aire +Ġc ords +ĠYoung er +appropri ately +Ġsequ els +u ve +ant icipated +Ġle wd +ĠSh irt +ĠDmit ry +V eter +Ġsl aying +ĠY ar +Ġcompl ication +I owa +ĠEric a +ĠBL M +g irlfriend +b odied +6 26 +19 63 +Ġintermedi ary +Ġcons olation +M ask +ĠSi em +ow an +Beg inning +Ġfix me +Ġculmin ated +Ġcon duc +ĠVolunte er +Ġpos itional +Ġgre ets +ĠDefin itions +Ġthink er +Ġingen uity +Ġfresh men +ĠMom ents +Ġ35 7 +ate urs +ĠFed Ex +s g +69 4 +Ġdwind ling +ĠBO X +sel age +Ġt mp +Ġst en +ĠS ut +Ġneighbourhood s +Ġclass mate +f ledged +Ġleft ists +Ġclim ates +ATH ER +ĠScy the +ul iffe +Ġs ag +Ġho pped +ĠF t +ĠE ck +ĠC K +ĠDo omsday +k ids +Ġgas ped +Ġmon iker +ĠL od +ĠC FL +t ions +r ums +fol ios +Ġm d +Ġunc anny +Ġtrans ports +ĠLab rador +Ġrail ways +Ġappl iance +ĠCTR L +æ Ģ +Pop ulation +ĠConfeder acy +Ġunb earable +Ġdors al +ĠIn form +op ted +ĠK ILL +Mar x +Ġhypoc ritical +q us +ĠN umerous +ĠGeorg ian +ĠAmbro se +ĠL och +Ġgu bernatorial +ĠX eon +ĠSupp orts +ens er +ee ly +ĠAven ger +19 65 +Ar my +Ġju xtap +Ġcho pping +ĠSpl ash +ĠS ustainable +ĠFin ch +Ġ18 61 +ict ive +at meal +ĠG ohan +Ġlights aber +ĠG PA +ug u +ĠRE PL +vari able +Ġher pes +Ġdesert s +ac iously +Ġsitu ational +week ly +ob l +Ġtext ile +ĠCorn wall +Ġcontrace ptives +ĠA ke +] - +ä¹ ĭ +: , +ĠW em +ĠB ihar +Ġ' . +Ġbe re +Ġanal ogue +ĠCook ies +Ġtake off +Whe el +Ġmaj estic +Ġcomm uting +0 23 +ĠCor pse +ass ment +min i +Ġgor illa +ĠAl as +ere e +Ġacquaint ances +ĠAd vantage +Ġspirit ually +Ġey ed +pm wiki +ĠE nder +Ġtrans lucent +Ġnight time +ĠIM AGES +5 45 +ĠK amp +ĠFre ak +Ġ ig +Port land +4 32 +ĠM ata +Ġmar ines +Ġh ors +ater asu +ĠAtt ribution +Ġ-------- - +Ġk ins +ĠBEL OW +++ + +Ġre eling +ol ed +Ġcl utter +ĠRel ative +Ġ4 27 +B US +Ġa vert +ĠChe ong +ĠA ble +ĠPry or +Develop er +Ġen cyclopedia +ĠUSA F +ĠG arry +Sp ain +Bl ocks +Ġexp osition +ĠGamer Gate +W OR +Ġstockp ile +Ġclot hed +ĠT one +ĠR ue +t umblr +Ġtreacher ous +Ġf rying +Ñ Į +ĠS ph +Ġrest raints +Ġemb odies +ĠG es +S afety +Ġnegoti ators +min ing +ĠAppalach ian +L OS +ĠJenn a +Ġpass ers +ç ĭ +sn ap +Ġshort en +creat or +Ġinn umerable +uther land +67 4 +ĠW OM +ĠAs cend +ĠArm ory +ĠTrans action +K ick +Ġsuit case +day Name +Ġwaste ful +mar riage +ĠMcC abe +ite ch +ĠO ss +Cl osure +ĠTreasure r +Ġindec ent +ĠD ull +Ġresid ences +19 59 +ĠS ettlement +Ham ilton +Ġself ies +ĠRank ing +ĠBark ley +ĠB ore +ĠW CS +ĠMar itime +ĠH uh +ĠForest ry +Ġcultiv ating +ĠBall ard +Ġg arrison +ĠSD L +9 30 +Ġnas cent +Ġirresist ible +Ġaw fully +\/ \/ +Ġequ ate +Ġanthrop ology +ĠSylv ia +Ġintest ine +Ġinnoc uous +cess ive +ag ra +ĠMet roid +G rant +8 55 +ģ ĸ +Ġ" _ +ãĥĥ ãĥī +Ġappra isal +ĠFred dy +04 6 +Ġ40 6 +Ġ18 30 +Ġd ocking +St atic +Ġp ont +ĠVolt age +ĠSt ead +ĠMort gage +ĠJon ah +Y L +CLASS IFIED +Ġas bestos +nik ov +Ġcoll agen +ĠOrb ital +P ocket +7 99 +Ġhy brids +inc hes +Ġinv oice +und y +Ġinequ alities +T rend +w ashed +B ALL +Ġluc id +ĠComment ary +Ġw itty +Br andon +Ġbru ising +Ġ6 20 +es cent +box ing +P OL +Ġ3 78 +R ect +Ġlic ences +ĠMcG ee +p ressed +D anny +Ġj ammed +ord inate +Ġle th +Ġdistingu ishes +ĠYam aha +IL S +ĠH ume +ĠC ategories +Rober ts +Ch art +Ġbeet le +ĠGra veyard +Ġ($ ) +o ÄŁ +Ġtw ilight +are lla +á ½ +Ġbooth s +ĠH HS +ĠFeld man +Ġexcav ation +Ġphilosoph ies +at ography +ĠGar age +te chnology +Ġunfor gettable +Ġver ifying +Ġsubord inates +E ls +Ġne b +G aming +EN A +ĠAchieve ment +it ters +ĠG abe +Ġd umps +for cer +Ġpo ignant +ĠM BA +ĠHe idi +ime i +Ġm ages +Ġliber ate +Ġcircum cised +ĠMer maid +ĠMat th +t ogether +ĠW ichita +Ġstore front +ĠAd in +V II +Four th +Ġexplore rs +W ER +Not able +Bro ok +m ens +F aith +-------- - +ĠJ ou +¬ ¼ +Ġpine apple +Ġam alg +el n +ark able +ĠãĤµ ãĥ¼ãĥĨãĤ£ +ĠãĤµãĥ¼ãĥĨãĤ£ ãĥ¯ãĥ³ +Ġov arian +ĠE choes +Ġhairc ut +Ġp av +Ġch illed +anas ia +Ġsty led +Ġd ab +ni per +Ġminister ial +ĠD UP +T an +Ġsul ph +ĠD eter +ĠBo hem +od an +Ġeduc ator +â ĵĺ +sp ir +Ch icken +ĠE leanor +Ġqu i +Ġheav iest +Ġgrasp ed +U RA +Ġcro oked +Jess ica +pro blem +Ġpred etermined +Ġman iac +Ġbreath s +ĠLauder dale +Ġh obbies +y z +Cr ime +Ġcharism a +d L +Ġle aping +Ġk ittens +Ang elo +ĠJ ACK +ĠSu zanne +Ġhal ting +ENT ION +Ġswall owing +ĠEarthqu ake +Ġeight eenth +ĠN IC +ĠIN F +ĠCons cious +Ġparticular s +circ le +7 40 +Ġbene volent +Ġ7 47 +Ġ4 90 +Ġr undown +ĠVal erie +ĠB UR +Ġcivil isation +ĠS chn +W B +ot ide +intern ational +Ġj ohn +Ġ19 02 +Ġpe anuts +Ġflav ored +k us +Ġro ared +Ġcut off +é £ +Ġorn ament +Ġarchitect ures +Ġ3 69 +ol or +ĠWild e +ĠC RC +ĠAdjust ed +Ġprov oking +land ish +Ġrational ity +Ġjust ifies +Ġdisp el +Ġa meric +ĠPol es +Ø © +Ġen vis +ĠD oodle +ä½ ¿ +igs aw +auld ron +Techn ical +T een +up hem +ĠX iang +Ġdetract ors +ĠZ i +ĠJournal ists +Ġconduc ive +ĠVolunte ers +Ġs d +Know ing +Ġtrans missions +ĠPL AN +ĠL IB +Ġall uded +Ġob e +Ġd ope +ĠGold stein +Ġwavelength s +ĠDest ination +nd a +ug i +Ġattent ive +ĠLe an +ral tar +Ġman g +mb uds +ak ings +b ender +Ġacc ol +Ġcraw led +N OW +Min nesota +Ġflour ished +ĠZ up +ĠSuper visor +ĠOliv ier +Ex cellent +Ġwid en +D one +Ġw ig +Ġmiscon ceptions +Cor p +W an +Ġvener able +ĠNot ably +ĠKling on +an imate +Bo ost +ĠS AY +miss ing +ibli ography +mel on +Ġpay day +Ø ³ +bo le +Ġve iled +ĠAl phabet +It alian +Ġever lasting +ĠR IS +ĠC ree +rom pt +Ġh ating +Ġgrin ning +Ġge ographically +OS H +Ġwe eping +ĠÂłĠÂłĠÂłĠÂł ĠÂłĠÂłĠÂłĠÂł +Ġimpe cc +Let ter +Ġblo ated +PL A +ĠFe in +Ġper sever +Th under +Ġa ur +ĠR L +Ġpit falls +âĸ º +Ġpredomin ant +Ġ5 25 +7 18 +AP E +7 14 +Ġfarm land +ĠQ iao +Ġv iolet +ĠBah amas +Ġinflic ting +ĠE fficiency +Ġhome brew +Ġundert ook +Ġcur ly +ĠHard ing +man ia +59 6 +Ġtem pered +Ġhar rowing +ĠP ledge +ĠFranken stein +è ª +M otion +Ġpredict ably +ĠExpl osion +oc using +er d +col o +FF ER +Ġback field +ĠV IDE +ue bl +N arr +ĠArg ument +Ġgen omic +Ġbout ique +Ġbatt ed +ĠB inary +Ġg amb +ĠRh ythm +67 3 +Ġa float +ĠOlymp ia +Y ING +Ġend if +is in +Ġwin ters +Ġsc attering +I v +D istance +Ġtr u +ĠCom fort +Ġne xus +Ġair flow +ĠByz antine +p ayers +con i +ĠB etsy +D eal +ĠN ug +ĠContin ent +red ibly +Ġoptim izing +al beit +Ġec static +ĠPro to +ç · +iv ot +âĸ Ħ +em p +rou nder +Ġcl out +ĠI ST +66 3 +ĠDoll ars +ĠD AC +Ġsubsc ribed +Ġrehears al +Ġam ps +ĠSh ang +es m +Ġspr inkle +Ġassail ant +ĠO o +ĠCoin base +T act +Ġret ina +Ġn uns +R ON +att o +Ġj ug +ĠSV G +Ġb ikini +ĠFI LE +ĠFound ers +ep ort +ĠK P +Ġrest ores +ĠTh ick +Ġash ore +Ġappro vals +R ender +M AG +G raham +ĠCort ana +ãĥ³ ãĤ¸ +ss h +or ians +ars ity +ĠInsp ired +u pper +Ġsign alling +Ġreb uke +Ġfl ares +Ġdownt ime +Stud ies +Ġstagn ation +ĠSequ ence +Ġgr unt +Ġass ures +ĠPL A +59 2 +Ġintra ven +d epend +Sus an +ĠManz iel +Man ia +Cont ract +Ġsl ams +Ġcult ured +Ġcred itor +L IST +ĠH UM +ĠChatt anooga +serv ed +Ġclo aked +ĠF TP +p owder +ĠSt ella +uct ive +Ġcheap ly +ĠMU CH +ĠGalile o +Ġsu ites +spe ech +Ġdeliber ations +ĠCh ips +« ĺ +Bal ance +ĠWyn ne +ĠAk ron +Ass et +Ġhon oured +Ġed ged +Like wise +anim ous +ĠW age +ĠEz ek +ad vertisement +ĠRT X +ĠM AD +Ġmigr ating +ĠS QU +Ġ4 75 +Ed ited +Ġshorth and +ĠBas ics +Ġcro tch +ĠEV EN +Ġv m +effic iency +Ġcal ves +ĠF rie +ĠBrill iant +Ġstri kers +Ġrepent ance +Ġarter ies +r l +B ed +h ap +Ġcrypt ography +ĠSab res +Ġ4 14 +vi ks +ih ara +aps es +T alking +Ġintertw ined +Ġdoc ks +Ġalle le +ĠArt ifact +ĠH IM +t orn +ç ķ +Ġop acity +ĠE ly +os uke +Ġn ipple +Ġhand written +ĠV K +ĠChamber lain +ĠLa os +ig raph +g row +Ġtr illions +Ġdescend ant +ĠSail or +as uring +Ġce ilings +ĠWare house +f lying +ĠGl ow +Ġn ont +Ġmiscar riage +Ġrig s +Ġmin istries +Ġelabor ated +Ġdel usional +ĠHum ane +Ġ3 79 +n ets +Ġblack out +add ers +Ġn p +ĠT ire +ro sc +Ġsub div +Ġlink age +Ġchron ological +ĠHER O +Ġres ettlement +ĠVin yl +Ġpast oral +ĠMob il +ĠBar bar +Co oldown +ĠF ritz +c riminal +re pe +Ġbell ig +ĠBre ed +Ġ4 18 +Ġsem blance +ij k +Ġcur tail +Ġclin ch +cont ained +ĠProm pt +ast on +Ġw i +Ġpursu its +5 15 +ĠGl oss +Ġfl ips +Ġcoup ons +Ġcl oning +ĠLike ly +Rem oved +ĠQu artz +r ices +ĠSpe ars +Ġp ious +Ġdep reciation +ĠD are +oun ces +am az +O nt +Ġp innacle +d ocker +0 26 +ĠW yr +ĠPro per +Ë Ī +n il +By tes +Ġseek er +t rial +Ġunf olds +ĠMar se +Ġextravag ant +ĠSurviv ors +RED ACTED +ĠSpeed way +ĠCra igslist +sub mit +ĠGener ations +Ġup holding +Ġblood stream +ĠMiss ions +ĠL awn +Ġlim bo +ene i +H uh +ĠWild cats +pre p +ĠMark us +ĠFor bidden +rit ic +IN O +Ġexhib iting +requ ent +ch uk +Ġhabit ual +ĠComp atibility +Dr ag +RIP T +uj ah +GR OUND +Ġdelinqu ent +Ġburn er +Ġcontempor aries +Ġgimm ick +load s +Ġno zzle +p odcast +ĠW ak +ĠStat en +ĠK uh +ãģ ĵ +inter rupted +Ġinv incible +ĠBurn ett +cig arette +ĠPeb ble +ĠTem porary +ĠMar ino +58 2 +Ġwast eland +ident ly +T x +Ġr ite +ĠPan asonic +ĠM iddles +ĠHort on +ae us +Ġc uring +Ġm ats +Ġadj ourn +Ġfears ome +pe z +bo ats +Ġpro pell +Ġconflic ted +ĠAng er +Ġinsurg ent +K arl +Ġco ales +Ġsouth western +Ġdis su +ĠO vert +******** **** +Ġbox ed +ĠBr une +aa a +Ġgard ening +ĠEng el +tr acks +Ġpur ified +Ġplace holder +ĠL ikes +Ġd an +G ab +Ġe ct +ĠF aw +ĠEl iot +Ġ' , +otrop ic +ĠRu in +hed on +Ġca ul +Ġa ft +ĠCad illac +gh a +ass ian +ud eb +ĠT ick +Ġadjust s +AR GET +5 37 +isc he +ant y +ĠFried rich +ĠBl izz +ĠA OL +Camp aign +Ġmamm al +ĠVe il +ĠK ev +ĠMaur it +ĠDam ien +N ation +E astern +Ġ{ : +Ġ= ================================ +Ġstereotyp ical +Ġatt ic +ĠCy borg +requ ire +Ġaward ing +ĠPap ua +bt n +b ent +B oo +Ġ( = +ĠX ander +ĠSomers et +Ġcatch y +Ġcert ify +STR UCT +Ġit al +Ġt ides +ĠBr ands +G ray +comp etitive +Ġcur ator +ĠD G +omin ium +ĠGM Os +ci ating +ĠCarm en +ow ard +Balt imore +Ġr gb +C u +Ġwip es +spe ll +IT NESS +Ġsummar izes +ĠRe vis +Ġwhistlebl owers +ĠBre ach +Ġcro chet +k os +ews ki +Ġrep et +Ġcrim son +ĠKar achi +read able +dim ension +ĠI gor +ild ed +ĠZ ed +ĠKe ane +ĠCos metic +DE P +Ġretreat ing +ĠU A +ens ical +Ġd usk +ĠDick ens +Ġaren as +ĠPass age +level s +Ġcur v +P ope +Ġch ores +ĠEl ise +ĠComp ass +b ub +Ġmamm alian +ĠSans krit +ĠAN C +ĠCr ack +Q ual +L aun +amp unk +Ġlearn ers +Ġglam orous +Ġfur the +erm ott +c and +Gener ic +Ġnarr ated +Ġdisorder ly +ĠTrans actions +ĠDet ention +ĠR oku +Ä į +Ġunder statement +ĠS aur +ĠRodrig o +ĠAS AP +S in +Ġre joice +Method s +Ġelectro de +Ġworsh ipped +Ġid i +ĠPhys icians +Ġpop up +Ġde ft +ĠRem oval +ĠBu enos +ver bs +Ġfun k +ush a +rict ion +ore a +ĠBang alore +ĠKen obi +zz i +Ġnorm ative +Ġgobl ins +Ġcaf es +ĠUN CLASSIFIED +ĠF ired +S IGN +Ġs clerosis +ĠV oter +ĠSon ny +ĠExt end +ĠEV s +Ar senal +Ġp si +Ġwid est +ĠT us +Ġlo oms +Ġjust ifying +ĠGr anger +è ¯ +Ref er +58 3 +Ġflour ishing +ab re +Ġr ave +ĠCont ra +Ġ18 98 +Add s +Ġf ul +ĠCo oke +some one += # +67 1 +Ġy ak +Ġar te +ĠMis cellaneous +ĠDet ection +ĠCl ancy +â ģ +ass ies +Ġval iant +ĠFemin ist +cor ruption +V el +P ear +Ġsucc inct +Ġquick est +k w +Ġsp itting +ĠL ibraries +åħ ī +ant z +D ad +ĠSpec ifications +rup ulous +and r +RES ULTS +Ġsnow ball +Ġpred is +ĠB axter +ĠNurs ing +ĠCh aff +s we +Ġout age +Ġnest ing +Ġnotor iety +tr igger +on ite +j on +Ġf ou +ook ed +ĠCelebr ity +re ality +Ġfat ig +Ġhug ging +Ġbother s +ĠPan zer +ĠCh andra +fig ured +Ġvol ts +ĠCloud s +Ġfee ble +ĠCur ve +ĠAs us +78 6 +abs or +ĠV ICE +ĠH ess +Ġmanufact ures +Ġgri zz +ĠPower ful +ac id +Ġsub sections +ĠKrug man +ĠAl ps +is u +Ġsequ est +ĠUlt ron +ĠT inker +ĠGo ose +Ġmism atch +Att orney +Ġmorph ology +ĠSix ers +ut tered +ĠE LECT +gr an +Rus sell +ĠG SL +Ġfort night +Ġ. ) +Ġapost le +pr one +el ist +Unt itled +ĠIm plementation +ist ors +Ġtank er +Ġpl ush +Ġattend ants +ĠT ik +ĠGreen wich +ĠY on +ĠSP L +cell s +unt led +S olution +ĠQu é +Ġvac ated +Ġupt ick +ĠMer idian +æ ĥ +ĠDr ill +9 25 +58 4 +Ġrenov ated +ĠKub rick +zy k +Ġl ousy +pp el +ohyd rate +ĠI zzy +lesi astical +CC C +ĠAj ax +Ġad apters +ĠPetra eus +Ġaffirm ation +ĠST OR +le ms +ad oes +ĠConstantin ople +Ġp onies +Ġl ighthouse +Ġadherent s +ĠBre es +omorph ic +Fight ing +Ġpl aster +ĠP VC +ĠOb st +Ġdear ly +ĠTo oth +icks on +Ġsh aming +P lex +A gg +ĠâĢ¦ " +Ġsub reddits +Ġpige on +ĠResident ial +ĠPass ing +Ġl um +ĠP ension +Ġpessim istic +Ġ4 32 +z inski +c ade +0 75 +Ġapolog ised +iy ah +Put ting +Ġgloom y +ĠLy me +=-=-=-=- =-=-=-=- +ĠT ome +ĠPsych iatric +ĠH IT +c ms +ap olog +Ġbreak er +Ġdeep en +Ġtheor ist +ĠHigh lands +Ġb aker +Ġst aples +Ġinterf ered +ĠAb ortion +jo ined +ch u +Ġform ulate +Ġvacc inations +Ġban ter +phe us +Ġoutfield er +ĠM eter +Ġ# #### +Ġ18 95 +Ġnarrow ing +ĠST ORY +f p +ĠC ST +ign ore +Ġproclaim ing +ĠR U +ĠB ALL +yn a +65 3 +Ġpos it +P RE +59 4 +ĠRegist rar +ĠPil grim +ic io +Ġpre tt +Ġlif eless +Ġ__ _ +Ne igh +ĠCh urches +orn o +Ġor cs +Ġkind red +ĠAud it +Ġmillenn ial +ĠPers ia +g ravity +ĠDis ability +ĠD ARK +W s +od on +Ġgrand daughter +ĠBro oke +ĠA DA +ER A +Ġpick ups +ĠWil kinson +ĠSh ards +ĠN K +Ġexp el +ĠKis lyak +Ġj argon +Ġpolar ized +ian e +Pub lisher +Ġreb utt +Ġapprehens ion +ĠK essler +Ġpr ism +F UL +19 64 +ĠL oll +ä ¿ +le thal +Å Ł +Ġg hetto +Ġb oulder +ĠSlow ly +ĠOsc ars +ĠInst ruction +ĠUl tr +ĠM oe +N ich +ĠP ATH +( * +ĠRE LEASE +un ing +rou se +en eg +Ġre imb +ĠDet ected +Do S +Ġster ling +Ġaggreg ation +ĠLone ly +ĠAtt end +hig her +Ġairst rike +ks on +SE LECT +Ġdef lation +ĠHer rera +C ole +rit ch +Ġadvis able +F ax +Ġwork around +Ġp id +mort em +ers en +Ġtyp o +Ġal um +78 2 +ĠJam al +script s +Ġcapt ives +ĠPres ence +ĠLie berman +angel o +Ġalcohol ism +ass i +Ġrec ite +Ġgap ing +Ġbask ets +ĠG ou +Brow ser +ne au +Ġcorrect ive +und a +sc oring +ĠX D +Ġfil ament +Ġdeep ening +ĠStain less +Int eger +Ġbu ggy +Ġten ancy +ĠMub arak +Ġt uple +ĠD roid +ĠS itting +Ġforfe it +ĠRasm ussen +ixt ies +es i +ĠKim mel +Ġmetic ulously +Ġap opt +ĠS eller +08 8 +ec ake +hem atically +T N +Ġmind less +Ġdig s +ĠAcc ord +ons ense +em ing +br ace +Ġe Book +ĠDist ribut +ĠInvest ments +w t +] ), +beh avior +56 3 +Ġbl inding +ĠPro testers +top ia +Ġreb orn +ĠKel vin +ĠDo ver +ĠD airy +ĠOut s +Ġ[ / +Ï Ģ +b p +ĠVan ity +ĠRec ap +ĠHOU SE +ĠF ACE +Ġ4 22 +69 2 +ĠAnt ioch +cook ed +Ġcoll ide +Ġa pr +Ġsle eper +ĠJar vis +Ġalternative ly +ĠLe aves +ĠM aw +Ġantiqu ity +ĠAdin ida +Ġab user +Poké mon +Ġass orted +ĠRev ision +ĠP iano +ĠG ideon +O cean +Ġsal on +Ġbust ling +ogn itive +ĠRah man +Ġwa iter +Ġpres ets +ĠO sh +ĠG HC +oper ator +Ġrept iles +Ġ4 13 +ĠG arr +ĠCh ak +Ġhas hes +Ġfail ings +Ġfolk lore +Ġab l +ĠC ena +ĠMac Arthur +ĠCOUR T +Ġperipher y +app ers +Ġreck oned +ĠInf lu +ĠC ET +Ġ3 72 +ĠDefin itive +ass ault +4 21 +Ġreservoir s +Ġd ives +ĠCo il +DA Q +Ġvivid ly +ĠR J +ĠBel lev +Ġec lectic +ĠShow down +ĠK M +ip ed +reet ings +ĠAs uka +L iberal +ĠÏ Ħ +Ġbystand ers +ĠGood win +uk ong +S it +ĠT rem +Ġcrim inally +ĠCirc us +ch rome +88 7 +Ġnan op +ĠOb i +ĠL OW +o gh +ĠAuth ors +ob yl +Ur ban +Ġt i +ĠWe ir +t rap +ag y +Ġparent heses +Ġout numbered +Ġcounter productive +ĠTob ias +ub is +P arser +ST AR +Ġsyn aptic +ĠG ears +Ġh iber +Ġdebunk ed +Ġex alted +aw atts +H OU +Ch urch +ĠPix ie +ĠU ri +ĠForm ation +ĠPred iction +C EO +Ġthro tt +ĠBrit ann +ĠMad agascar +ë ĭ +Ġbill boards +ĠRPG s +ĠBe es +complete ly +F IL +Ġdoes nt +ĠGreen berg +re ys +Ġsl ing +Ġempt ied +ĠPix ar +ĠDh arma +l uck +ingu ished +Ġend ot +Ġbab ys +05 9 +che st +r ats +Ġr idden +Ġbeet les +Ġillum inating +Ġfict itious +ĠProv incial +Ġ7 68 +Ġshe pherd +ĠR ender +Ġ18 96 +C rew +Ġmold ed +ĠXia omi +ĠSp iral +Ġdel im +Ġorgan ising +Ġho ops +ĠBe i +z hen +Ġfuck in +Ġdec ad +Ġun biased +am my +sw ing +Ġsmugg led +Ġk ios +ĠP ERSON +ĠInquis itor +Ġsnow y +Ġscrap ing +ĠBurg ess +P tr +ag ame +R W +Ġdro id +ĠL ys +ĠCass andra +Jac ob +Ġ35 4 +Ġpast ure +Ġfr anc +ĠScot ch +ĠEnd s +ĠI GF +def inition +Ġhyster ical +ĠBrown e +77 1 +Ġmobil ization +æ ķ +iqu eness +Th or +Ġspear headed +Ġembro iled +Ġconject ure +jud icial +Ch oice +Ġpaper back +P ir +Ġrec overs +ĠSur ge +ĠSh ogun +ĠPed iatrics +ãģ ł +Ġsweep s +ĠLabor atories +ĠP acks +al us +add in +Ġhead lights +g ra +Ev idence +COL OR +Ad min +Ĭ ± +Ġconco ct +s ufficient +Ġun marked +Ġrich ness +Ġdiss ertation +Ġseason ing +Ġg ib +ĠM ages +un ctions +ĠN id +che at +ĠTM Z +c itizens +ĠCatholic ism +n b +Ġdisemb ark +ĠPROG RAM +a ques +Ty ler +Or g +ĠSl ay +ĠN ero +ĠTown send +IN TON +te le +Ġmes mer +9 01 +Ġfire ball +ev idence +aff iliated +ĠFrench man +ĠAugust a +0 21 +Ġs led +Ġre used +ĠImmun ity +Ġwrest le +assemb led +Mar ia +Ġgun shots +ĠBarb ie +Ġcannabin oids +ĠTo ast +ĠK inder +IR D +Ġre juven +Ġg ore +Ġrupt ure +Ġbre aching +ĠCart oon +Ġ4 55 +ĠPale o +6 14 +Ġspe ars +ĠAm es +ab us +Mad ison +GR OUP +Ġab orted +y ah +Ġfel on +Ġcaus ation +Ġprep aid +Ġp itted +op lan +ĠShel ley +ĠRus so +ĠP agan +Ġwill fully +ĠCan aver +und rum +ĠSal ary +ĠAr paio +read er +ĠR ational +ĠOver se +ĠCa uses +Ġ* . +Ġw ob +Ke ith +ĠCons ent +man ac +77 3 +6 23 +Ġfate ful +et imes +Ġspir ited +ĠD ys +Ġhe gemony +Ġboy cot +ĠEn rique +em outh +Ġtim elines +ĠSah ara +ĠRel ax +ĠQuin cy +ĠLess ons +ĠE QU +SE A +N K +ĠCost co +Incre ase +Ġmotiv ating +ĠCh ong +am aru +ĠDiv ide +Ġped igree +ĠTasman ia +ĠPrel ude +L as +9 40 +57 4 +Ġch au +ĠSp iegel +un ic +-- > +ĠPhil ips +ĠKaf ka +Ġuphe aval +Ġsent imental +Ġsa x +ĠAk ira +ser ial +Mat rix +Ġelect ing +Ġcomment er +ĠNeb ula +ple ts +ĠNad u +ĠAd ren +Ġen shr +ĠR AND +fin ancial +ĠCly de +uther ford +Ġsign age +Ġde line +Ġphosph ate +rovers ial +f ascist +ĠV all +ĠBeth lehem +Ġfor s +Ġeng lish +S olid +N ature +Ġv a +ĠGu ests +Ġtant al +Ġauto immune +;;;;;;;; ;;;; +ĠTot ally +ĠO v +Ġdef ences +ĠCoc onut +Ġtranqu il +Ġpl oy +Ġflav ours +ĠFl ask +ãĤ¨ ãĥ« +ĠWest on +ĠVol vo +8 70 +Ġmicro phones +ver bal +R PG +Ġi ii +; } +0 28 +Ġhead lined +Ġprim ed +Ġho ard +ĠSh ad +ĠEN TER +Ġtri angular +Ġcap it +l ik +ĠAn cients +Ġl ash +Ġconv ol +Ġcolon el +en emy +G ra +Ġpub s +ut ters +Ġassign s +ĠPen et +ĠMon strous +ĠBow en +il ver +H aunted +ĠD ing +start ed +pl in +Ġcontamin ants +ĠDO E +ff en +ĠTechn ician +R y +Ġrob bers +Ġhot line +ĠGuard iola +ĠKau fman +row er +ĠDres den +ĠAl pine +E lf +Ġf mt +ĠS ard +urs es +g pu +Un ix +Ġunequiv ocally +ĠCitizens hip +qu ad +m ire +ĠS weeney +B attery +6 15 +Ġpanc akes +Ġo ats +M aps +ĠCont rast +mbuds man +ĠE PS +Ġsub committee +Ġsour cing +Ġs izing +ĠBuff er +ĠMand atory +Ġmoder ates +ĠPattern s +ĠCh ocobo +ĠZ an +ĠSTAT ES +ĠJud ging +ĠIn her +* : +Ġb il +ĠY en +Ġexh ilar +oll ower +z ers +Ġsn ug +max imum +Ġdesp icable +ĠP ACK +ĠAn nex +Ġsarcast ic +Ġlate x +Ġt amp +ĠS ao +b ah +ĠRe verend +ĠChin atown +ĠA UT +d ocumented +ĠGA BA +ĠCan aan +ĠÙ ħ +Ġgovern s +pre v +E sc +ĠEst imates +OS P +Ġendeav our +ĠCl osing +omet ime +every one +Ġwor sen +Ġsc anners +Ġdev iations +ĠRobot ics +ĠCom pton +Ġsorce rer +Ġend ogenous +Ġem ulation +ĠPier cing +ĠA ph +ĠS ocket +Ġb ould +ĠO U +ĠBorder lands +Ġ18 63 +G ordon +ĠW TO +Ġrestrict s +Ġmosa ic +Ġmel odies +ç Ħ +T ar +Ġdis son +ĠProv ides +Ġ ...... +b ek +F IX +Ġbro om +ans hip +Do ctors +Ġner ds +ĠReg ions +na issance +Ġmet e +Ġcre pt +pl ings +Ġgirlfriend s +kn it +ig ent +ow e +Ġus hered +ĠB az +M obil +4 34 +ĠPres ents +orig in +Ġins omnia +ĠA ux +4 39 +ĠCh ili +irs ch +G AME +Ġgest ation +alg ia +rom ising +$ , +c row +ĠIn spection +at omic +Rel ations +J OHN +rom an +ĠClock work +ĠBak r +m one +M ET +Ġthirst y +Ġb c +Ġfacult ies +R um +Ġnu ance +ĠD arius +ple ting +fter s +etch up +Reg istration +ĠK E +R ah +Ġpref erential +ĠL ash +ĠH H +Val id +ĠN AV +Ġstar ve +ĠG ong +z ynski +ĠAct ress +Ġw ik +Ġun accompanied +lv l +Br ide +AD S +ĠCommand o +ĠVaugh n +Wal let +Ġho pping +ĠV ie +Ġcave ats +Ġal as +if led +ab use +66 1 +Ġib n +Ġg ul +Ġrob bing +t il +IL A +Ġmit igating +Ġapt ly +Ġty rant +Ġmid day +ĠGil more +ĠDe cker +Ġ§ § +part ial +Ex actly +Ġphen otype +Ġ[+ ] +ĠP lex +ĠI ps +vers ions +Ġe book +Ġch ic +g ross +":" "},{" +ĠSur prisingly +M organ +Ġresid ues +ĠConf ederation +in feld +Ġl yr +mod erate +Ġperpend icular +V K +Ġsynchron ized +Ġrefres hed +Ġad ore +ĠTor ment +ol ina +Ġ26 00 +Item Tracker +Ġp ies +ĠF AT +ĠR HP +0 48 +ĠRES P +ĠB J +all ows +P and +Ġunw elcome +ĠV oc +ĠBast ard +ĠO W +ĠL AR +ĠHeal er +Environment al +ĠKen yan +ĠTr ance +ĠP ats +Ġali ases +ĠGar field +Ġcampaign er +Ġadvance ments +ĠOkin awa +ĠC oh +ows ky +Ġstar ved +Ġsize able +Ġ: -) +Ġm RNA +Ġsusp ensions +ist ar +Scot land +Pr in +-------------------------------- ---------------- +Ġ50 2 +Ġteasp oons +Ġ10 50 +Ġcoerc ive +ĠMason ic +edd ed +ĠPass enger +Ġl att +Ġbr aces +ĠSt eal +ĠNY T +ĠK ats +ĠCel est +ae z +T u +ĠCoul ter +ðŁ ĺ +Fl ickr +ĠWil mington +ith s +++ ; +Ġv ending +Ġneg ro +ĠPh i +ĠYellow stone +Call back +Ġsh ampoo +ĠSh ades +w at +Ġsuper human +Ġridic uled +Ġhol iest +om bo +Ġintern s +Ġh one +ĠPar agu +UR I +Ġd angling +ãĤ » +so v +ict ional +av ailability +Ġrev ocation +Ġd ow +in ic +ĠTHE IR +Ġis o +Ġout ings +ĠLeth al +Ġ) )) +Ġinacc ur +Ġout landish +Ġan us +let ico +id on +l ol +Ġun regulated +Ġsuccumb ed +Ġc uff +ĠWast eland +let al +Ġsub str +Ġcoff ers +Ġautom akers +ov i +ĠX ue +ĠDayton a +Ġjar ring +Ġf umes +Ġdisband ed +z ik +itt on +Ġstriking ly +Ġsp ores +Ad apter +.) : +ĠLynd on +ival ry +Ġor ally +Ġtumult uous +Ġdisple asure +Ġcon es +or rect +Ġappe ase +Ġder by +ĠTrip oli +ĠAl ess +Ġp oked +ĠGu ilty +v P +En ough +Ġorig inals +6 99 +Ġrabb i +Ġproverb ial +Ġpostp one +el ope +ĠMist y +Ġstaff ed +ĠUn employment +redit ary +Ġdilig ent +re comm +me asures +as in +8 25 +Ġpond s +Ġmm ol +ĠS AR +ĠC ARE +Ġ3 71 +Ġclen ched +ĠCors air +Ġcaric ature +z n +att ach +ĠSch ro +spe ak +p ainted +ĠS uc +ĠE NT +Ġcell ul +ĠP aid +di agn +WH ERE +Ġtext ed +B arn +Ġret racted +ĠRe ferred +S av +Ġup keep +Ġwork places +ĠTok ens +Ġampl ify +cl inical +Ġmult ic +mber g +Ġconvol uted +Reg ion +5 65 +ĠTop ic +Ġsn ail +Ġsal ine +Ġins urrection +ĠPet r +f orts +B AT +ĠNav ajo +Ġrud imentary +ĠLak sh +OND ON +Me asure +Ġtransform er +ĠGodd ard +Ġcoinc ides +ir in +R ex +ĠB ok +qu it +Ġshotgun s +Ġprolet arian +Ġsc orp +ĠAd a +5 14 +Ġsl ander +record ed +Ġemb ell +ris ome +Ġapolog izing +ĠMul cair +ĠGib raltar +Cl a +Ġall ot +ĠAtt ention +Ġ4 33 +le ave +Ġwh ine +ĠIss a +ĠFa ust +ĠBar ron +hen y +Ġvictim ized +J ews +Ġnurt uring +ett el +W inged +ĠSub tle +Ġflavor ful +ĠRep s +eng ed +call back +Ġdirection al +Ġcl asp +ĠDirect ions +plan et +icult ure +Hel per +ic ion +ac ia +Ġç ¥ŀ +Ġsur ges +Ġcan oe +ĠPrem iership +be en +Ġdef ied +ĠTro oper +Ġtrip od +Ġgas p +ĠE uph +ĠAd s +vern ight +high ly +R ole +Ġent angled +ĠZe it +6 18 +ĠRust y +Ġhaven s +ĠVaugh an +HA EL +ĠSER VICE +/ , +Ġstr icken +Ġdel usions +Ġb is +ĠH af +Ġgrat ification +Ġent icing +UN CH +Ad ams +ĠOL ED +ĠBeet le +Ġ18 99 +ĠSO FTWARE +ateg or +V L +ĠTot em +ĠG ators +AT URES +Ġimped ance +Reg istered +ĠC ary +ĠAer ial +on ne +en ium +Ġd red +ĠBe g +Ġconcurrent ly +Ġsuper power +ĠX an +j ew +imes ter +ĠDick inson +âĶ ģ +F la +Ġp ree +ĠRoll ins +© ¶æ +Ġden omination +ĠL ana +5 16 +Ġinc iting +sc ribed +j uries +ĠWond ers +app roximately +Ġsusp ending +Ġmountain ous +ĠL augh +oid al +N s +Det ect +) = +ĠL uthor +ĠSchwarz enegger +ĠMull er +ĠDev i +ec ycle +J ar +6 13 +ĠL ongh +B ah +ĠSP ORTS +n w +Ġref inement +Ġwater ways +Ġd iner +Bl ade +68 3 +F ac +Ġinitial s +Ġro g +Ġparan ormal +B UT +Ġ[ ( +ĠSw anson +ĠM esh +âĸ ¬ +Impro ve +ĠRad iation +ĠEst her +ĠE sk +ĠA ly +ik y +Ġir rad +ĠBuck ingham +Ġref ill +Ġ. _ +Re pe +CON CLUS +Ġdifferent iated +Ġchi rop +ĠAt kins +Pat tern +Ġexc ise +Ġcab al +N SA +ĠST A +ĠS IL +ĠPar aly +Ġr ye +ĠHow ell +ĠCount down +ness es +alys ed +Ġres ize +ãĤ ½ +Ġbudget ary +ĠStr as +w ang +Ġap iece +Ġprecinct s +Ġpe ach +Ġsky line +Ġ35 3 +pop ular +App earances +ĠMechan ics +ĠDev Online +S ullivan +Z en +Ġp u +op olis +5 44 +Ġde form +Ġcounter act +ĠL ange +Ġ4 17 +Con sole +77 4 +Ġnodd ing +Ġpopul ism +Ġhe p +Ġcoun selling +compl iance +U FF +Ġunden iably +Ġrail ing +ĠHor owitz +ĠSim one +ĠBung ie +Ġa k +ĠTal ks +x ff +fl ake +Cr ash +Ġsweat y +Ġban quet +ĠOFF IC +Ġinvent ive +Ġastron omer +ĠStam ford +ĠSc are +ĠGRE EN +olic ited +Ġr usher +Ġcent rist +ight ing +Ġsub class +Ġdis av +Ġdef und +ĠN anto +oci ate +m ast +Ġpac if +Ġm end +e ers +imm igration +ESS ION +Ġnumber ing +Ġlaugh able +ĠEnd ed +v iation +em ark +P itt +Ġmetic ulous +ĠL F +Ġcongrat ulated +ĠBir ch +Ġsway ed +Ġsemif inals +Ġhum ankind +m atter +ĠEqu ip +opa usal +S aid +ĠLay out +Ġvo icing +Ġth ug +Ġporn ographic +I PS +Ġmo aning +Ġgriev ance +Ġconf essions +esc al +TEXT URE +Aut hent +os aurus +P urchase +Ġreleg ation +al ter +ĠÂł Âł +Ġr iddled +Ġo gre +ĠLow ell +Occ up +E at +ĠHy der +ĠAdvis er +Com merce +H unt +ĠOr th +ĠComp etitive +ĠCL A +CD C +Ġsal ads +F le +Ġindustrial ized +` , +ĠO WN +Ġbec k +ĠPart icularly +oub t +Ġm M +ĠHuss ain +ĠChen nai +Ġ9 20 +Ġappoint ing +ĠCull en +,,,, ,,,, +Ġp ores +ver ified +Ġbi ochemical +em ate +Ġcoward ly +ĠHels inki +ĠEthiop ian +S OURCE +ER C +est ro +Ġbi otech +ĠS our +Ġbrew er +Bloom berg +Ġintens ify +Gl ass +an co +ĠF DR +gre SQL +ĠF ires +©¶æ ¥µ +ec o +100 1 +ĠHom eless +Ġinstant aneous +ĠH aste +ig el +D iamond +Ġp aving +Ġland fill +Ġd ads +h oun +: ] +Ġinc endiary +ĠLiving ston +ĠHil bert +ĠChe cks +st yles +in ators +ĠCl ive +ph rine +Ġchimpan zees +Ġp all +ĠJ M +ĠAad haar +ð Ŀ +Ġachie vable +dis abled +P ET +OOOO OOOO +M ot +Ġint angible +Ġbal let +ĠWe bs +ĠEst imated +Effect s +Ġb ailed +Josh ua +Ġturb ulence +Ġoccup ant +ĠDay light +Ġ36 1 +me et +Ġstat ically +Ġon look +Ġk i +il legal +Ġvel vet +Ġdehyd ration +Ġacqu ies +ĠRe z +ak ura +ĠU pton +at ro +Ġincomp rehensible +Ġback door +ĠRh ino +7 27 +Ġmath s +) + +Ġhe resy +Ġd f +ĠRoc he +ĠL ydia +Ġpanc reat +re ply +arre ll +Ġsolicit ation +Ġcirc adian +BI P +Ġfor ay +Ġcrypt ic +iz u +ime o +ĠTom ato +ĠH oms +ex amination +Ġqu arry +ĠVal iant +ĠJer icho +ĠIN CLUD +Ġ18 40 +5 19 +Ġres ists +Ġsnap shots +ĠSp ur +ĠAnt iqu +Log in +Ġbest selling +Ġant ic +ĠS utherland +ãĤ¢ ãĥ« +Ġ~ / +ĠP arm +è ĥ +P ages +int ensity +Ġimm obil +Ġ18 65 +zz o +Ġn ifty +Ġf entanyl +ĠPres ervation +op hen +Ġd arts +ĠD inosaur +po inters +ĠR ite +s uggest +aware ness +ĠSher idan +Ġst ances +Ġsor cery +Ġper jury +ĠNik ola +ie ver +Ġf iance +ĠJordan ian +ĠBall oon +Ġn ab +Ġk b +Ġhuman ities +ĠTan aka +hill ary +Ġconsult ancy +ĠZ ub +Ġrem ission +Ġconf id +CH Q +ĠF ug +Ġimpro vis +Y ep +/ _ +Ġunwilling ness +Ġport folios +05 5 +ĠInstruct or +aim an +Ġclaim ants +M bps +ĠBy e +re ceived +T weet +Ġind emn +ri z +am ara +N at +Ġeval uates +ĠL ur +ep ad +FO X +ĠTh ro +Ġrust y +Ġbed rock +ĠOp rah +J B +Ġmanip ulative +Ġwill ful +Ġrel apse +Ġext ant +The me +S ensor +ĠSt ability +go vern +Ġpo ppy +Ġkn ack +Ġins ulated +ĠT ile +ĠExt rem +Ġunt old +Ġconver ge +Ġref uel +ig roup +Ġdistort ions +Ġrav aged +Ġmechan ically +ĠRe illy +ĠN ose +ĠIncarn ation +ĠBeck y +abb ling +Ġt aco +Ġr ake +Ġmelanch oly +Ġillust rious +ĠDart mouth +Gu ide +ĠR azer +ĠBen z +Ult imate +ĠSur prise +Ġpage ant +off er +Who ever +Ġw iser +Ġchem ist +ĠHE LL +ĠBul k +Ġpl utonium +ĠCO VER +Ö ¼ +f ailed +Ġtire lessly +Ġinf ertility +ĠTr ident +ĠShow time +ĠC iv +V ice +requ ires +itt ance +Ġun controlled +interest ing +56 1 +Ġinnov ate +ateg ic +L ie +ĠS elling +U l +Ġsav ior +ĠT osh +Ġsw ast +P ASS +Ġr ink +Ġcard io +ĠI ro +ud i +Ġv antage +Ġv ans +ĠNi ño ++ = +Ġpropag ate +< ? +Ġmethod ological +204 39 +Ġtrig lycer +Ġing rained +ĠAn notations +arr anted +6 17 +ĠS odium +ĠA AC +techn ical +mult ipl +Ġ3 73 +å ĭ +Ġdec isively +Ġboost ers +Ġdessert s +ĠGren ade +Ġtest ifying +ĠSc ully +ID s +Ġlock down +ĠSc her +ĠR é +ĠWhit man +ĠRams ay +rem ote +Ġh ikers +ĠHy undai +Ġcons cientious +Ġcler ics +ĠSiber ian +ut i +is bury +Ġrel ayed +Ġqu artz +ĠC BI +seek ers +ull a +Ġweld ing +ĠSh al +ble acher +T ai +ĠSam son +Ġt umble +ĠInvest or +Ġsub contract +ĠShin ra +ow icz +j andro +d ad +Ġtermin ating +ĠNe ural +ä» £ +Ġleak age +ĠMid lands +ĠCaucas us +í ķ +c it +ll an +iv ably +ĠAlb ion +Ġ4 57 +Ġregist rations +Ġcomr ade +Ġclip board +0 47 +Ġdiscour aging +ĠO ops +Ad apt +Ġem path +n v +ĠPR OT +ĠDon n +ĠP ax +ĠB ayer +t is +Squ are +Ġfoot prints +part icip +ĠChile an +B rend +ind ucing +M agn +Ġclub house +ĠMagn um +Ġenc amp +ĠEth nic +uch a +ere y +Ġw atered +ĠCal ais +Ġcomplex ion +Ġsect s +Ġren ters +Ġbr as +oÄŁ an +Time out +Man agement +Ġinf ographic +P okemon +Cl ar +Ġloc ality +Ġfl ora +as el +P ont +Ġpop ulate +ĠO ng +Ġsubs istence +Ġa uctions +ĠMcA uliffe +ĠL OOK +br inger +Ġtit an +Ġmanif old +ĠâĹ ı +Ġcalibr ated +Ġcal iphate +ĠSH E +ĠCommission ers +ce ivable +j c +W inner +5 24 +Ġcond one +Other wise +Ġp iling +Ġem body +ĠCrime an +ut ics +ĠEx hibition +Ġ4 26 +e ering +Ġv ying +ĠH UGE +* =- +Ġprin cipled +à ¦ +Ġquir ks +ĠEdit ors +put ing +G ES +ĠF TA +ठ¾ +add on +ĠH AM +ĠFrie za +W oman +. $ +Ġc rib +ĠHer od +Ġtim ers +ĠSp aces +ĠMac intosh +at aka +Ġgl ide +Ġsmell ing +ĠB AL +Ġun su +Ġcond os +Ġbicy cl +ĠRev ival +55 3 +Ġjugg ling +H ug +ĠKardash ian +ĠBalk ans +mult iple +Ġnutrit ious +oc ry +19 00 +Ġinteg rates +Ġad joining +ĠF older +roll ment +ven ient +Ġu ber +y i +Ġwh iff +ĠJu ven +ĠB orough +net te +Ġb ilingual +ĠSp arks +ph thal +man ufact +Ġt outing +ĠPH I +Ke efe +Rew ard +Ġinf all +ĠTem per +typ ically +ĠNik ol +Ġregular s +Ġpseud onym +Ġexhib itions +Ġbl aster +Ġ40 9 +w arming +Ġrever ber +Ġrecip rocal +Ġ6 70 +ip ient +b ett +ĠBe gins +Ġit ching +ĠPh ar +Ass uming +Ġem itting +ĠML G +Ġbirth place +Ġt aunt +ĠL uffy +ĠAm it +Ġcir cled +ĠN ost +enn ett +Ġde forestation +ĠHist orically +ĠEvery day +Ġovert ake +79 2 +Ġn un +ĠLuc ia +Ġaccompan ies +ĠSe eking +ĠTr ash +an ism +R ogue +Ġnorth western +ĠSupplement al +ĠNY U +ĠF RI +ĠSat isf +x es +5 17 +Ġreass ured +Ġspor adic +Ġ7 01 +Ġmed ial +Ġcannabin oid +Ġbarbar ic +Ġep is +ĠExplos ive +ĠD ough +Ġuns olved +Support ed +Ġacknowled gment +sp awn +Ġkit chens +Ġ- = +talk ing +ic ist +ĠPeg asus +ĠPS U +Ġphot on +ĠAuthent ication +R G +@# & +76 2 +ĠCl air +Ġdi aper +Ġbr ist +ĠProsecut ors +ĠJ em +6 28 +ĠEvery where +ĠJean ne +equ ality +ãĥ© ãĥ³ +object s +ĠPel icans +Ġ39 2 +Ġbl u +b ys +ĠA go +Ġinstruction al +Ġdiscrim inating +ĠTR AN +ĠCorn el +ag os +Ġty re +Ġas piration +ĠBrid gewater +": - +! ". +ĠEn s +ĠCoc o +P ie +Ġdet ach +ĠC ouch +Ġphys ique +ĠOccup ations +osc opic +en ough +B uzz +App earance +Y P +Ġrac er +Ġcompl icity +r pm +T oy +Ġinterrupt s +ĠCat alyst +Ġut ilitarian +imp act +Ġsp aghetti +Ġp orous +Ġeste emed +Ġinc iner +ĠI OC +7 48 +Ġesp resso +ĠSm ile +abil ia +6 35 +Ġmathematic ian +Ġ4 24 +ĠK L +ĠH IP +Ġover heard +ĠT ud +ĠT ec +Ġqu izz +Ġfl attering +Ġcon n +âĢ İ +Ġatt aches +ĠR OS +ĠAC S +Ġt cp +ĠSh ame +sk ip +res pected +ĠTrin idad +gr ain +Ġfooth old +ĠUnch arted +ĠJul io +z l +av ored +ĠAn xiety +er rors +ĠCent auri +its ch +D addy +Ġclutch ing +ĠIm plement +ĠGut ierrez +Ġ7 60 +Ġtele portation +end ra +Ġrevers ible +st ros +Ad venture +08 3 +Ġliber ating +Ġas phalt +ĠSp end +AR DS +im sy +PR ES +ĠEmer ging +Ġwild fires +Ġtechn ologically +Ġem its +ĠART ICLE +Ġirregular ities +Ġcher ish +çī Ī +Ġst ink +ĠR ost +Econom ic +Ġcough ing +ĠMcC ann +pro perties +ilant ro +Ġreneg oti +Trans lation +Ġin quest +ĠGra pe +oot ers +gu i +ĠSwords man +ace ae +h itting +Ġr c +Ġexert ed +ĠS AP +it ent +Ġperil ous +Ġobsc urity +Ġassass inate +Ġab original +Ġresc uing +ĠSh attered +lock ing +all ion +Ch anging +ĠHar rington +ĠB ord +ĠAfgh ans +Jam ie +aret z +ĠAugust us +Ġ38 6 +8 30 +Ġj og +ok ingly +Tr igger +ĠH OR +Stat istics +Ġviewers hip +Ġadd itives +h ur +Ġmaxim izing +ĠR ove +ĠLou ie +ĠBuck et +ĠCHR IST +ou sel +Ġstre aks +ir ted +Ġt ert +Ġcolonial ism +Ġbur ying +y k +Cond ition +ĠDPR K +By Id +75 1 +âĹ ¼ +Ġwor risome +Ġvoc ational +sl ice +Ġsa ils +ĠCorrection al +95 4 +Ġt ul +K id +l uster +Ġfam ilial +ĠSp it +ĠEp iscopal +Specific ally +ĠVol cano +run s +q s +Ġve tted +Ġcram med +t rop +here r +Thank fully +Ġper cussion +Ġor anges +Ġround up +Ġ4 99 +x ious +Char acters +ĠZion ism +ĠR ao +ÃĽ ÃĽ +W F +Ġunintention al +ONE Y +Gr ab +Com mercial +Ġglut amate +ĠMcK enna +ru ciating +ning ton +ih u +Ch an +ĠSw ap +Ġleaf lets +Ġfunction ally +er ous +F arm +Ġcal oric +ĠLiter ally +con cert +Ġshe nan +Ġrep aid +ey es +Ġbas hing +ĠG orge +Ġcollabor ations +Ġun account +itch ie +Ġteam work +pp elin +Ġpip ing +Ġmin ced +Ġd iam +ri eg +Ġmasc ara +Ġsuck er +ĠMo ons +App s +ĠPe ck +Ġper v +ĠFl oat +o ley +ĠN ish +im ize +Ġarom atic +u in +end ish +! / +ĠB icycle +ĠAS IC +ile ged +ĠQuad ro +ios yn +Ġlock out +ĠW ink +SP EC +Attempt s +Ġseed ed +red o +ias is +Ġsn ag +ãĥķ ãĤ© +ãĤ ¶ +Ġground ing +Ġrelie ver +Ġfrivol ous +ĠG ifts +ĠF aces +Es pecially +Ġmicrobi ome +im ag +ĠSch l +ĠP les +ĠBle ach +ĠIr win +ĠE aton +ĠDisc iple +Ġmultipl ication +Ġcoer ced +Ġ4 19 +st h +E vil +B omb +Ġex orc +Ġstag gered +L ESS +Ġinert ia +ĠED IT +Ġgo b +Tr aditional +Ġclass y +Lear y +ĠP AGE +yr s +Ġtrans porter +Ġmat ured +Ġhij ab +Ġbi ome +Where as +Ġex termination +ĠT ues +ĠT akeru +ĠAud rey +er ial +ĠAd en +aff les +Ġnarciss istic +ĠB aird +UT F +I re +ĠCon nie +Ch amp +Ġwhis pering +ĠH att +D K +Ġdis infect +Ġdeduct ed +Ġpart ake +Ġdown grade +ĠEs ports +ĠContin uing +Ġdemocr atically +icro bial +itt a +Ġlim estone +Ġexempt ed +ĠFren zy +H erm +7 28 +Ġfled gling +Met a +765 61 +69 3 +% : +w ake +5 26 +ĠDis cipline +Ġvirgin ity +ĠLeg ions +ĠFrank ie +int ent +Ġrest rooms +ĠRou ter +da q +Ġobjection able +âĨ ij +w ark +ĠRah ul +g ain +activ ation +abs olute +ĠAccess ed +Ġ24 00 +ogg les +Ġsecond ly +ĠDEF ENSE +Ġpost age +wra pper +sh arp +7 29 +Ġcommun icates +Ġadd on +ĠMil itia +H ong +Ġsl umped +ĠJP EG +ĠI car +ad ish +68 1 +Ġmaj esty +ĠWolf gang +ĠEl astic +u per +Ġv iz +Ġunconscious ly +ĠST D +ĠS ass +Ġflower ing +ĠHel ic +ĠDra per +ĠAm ateur +Ġman ure +Ġdis ingen +ĠLe i +br ing +9 49 +Ġinhib ited +Ġhead quartered +Ġen igmatic +�� � +Ġred ress +R H +Ġratt led +Ġd iction +l io +ĠT BA +ĠSN AP +C alling +Ġfasc ists +ĠD ove +iew icz +0 36 +Ġco asts +ĠR ect +Ġ) ] +L ot +6 29 +ĠS EM +ĠPeters en +ĠExpl ain +ĠBo ards +ĠBe zos +ĠJ ournals +Ġ20 24 +p arser +Ġmist rust +Ġgr ate +ĠL ocked +bo a +S aint +g aming +Ġvow el +in ately +bl ow +All ah +Ġun matched +Ġb ordering +ĠExp end +n r +Or acle +rou ch +Ġcont iguous +ac us +Ġdist raught +58 1 +Ġanat omical +O X +ap ixel +8 33 +ĠPL US +Ġres usc +Ġab iding +57 3 +Ġvac ancies +Em ily +Ġhyp othal +ĠWer ner +ĠWe e +ĠDJ s +5 13 +Ġwitch craft +Ġac upuncture +ent ary +benef it +Product s +ĠP SP +ĠMP G +ĠJ inn +ĠJ arrett +Ġ4 45 +ĠIm aging +ĠP yth +Fin ish +Ġte x +Ġjuven iles +Ġhero ism +Ġdoubt less +ĠA ki +ĠT end +ĠPatri arch +Ġbit ters +ĠTele communications +it atively +ag na +Ġr g +ĠS OLD +Ġcomp ulsion +ĠN asa +ĠKath ryn +Ġmillion aires +Ġintrins ically +Ġbolst ered +time out +fl o +Ġtut or +p our +Stat ement +Ġ{ * +ĠRud olph +ĠKimber ly +rog ens +adi q +] + +Ġindign ation +Ġfract uring +ĠRe leases +ĠGr ain +pro tein +L ago +Ġvac ations +Ġboot ed +ĠTH REE +ĠH G +oresc ence +Ġt f +Ġso ar +iosyn cr +Ġgl ances +ĠSp oon +ĠJ ury +ĠCow boy +Ġcreat ively +Hig her +Ġsolic itor +Ġhaw k +ac io +89 6 +Ġsuperf lu +Ġbombs hell +ct ure +Ġbroker age +Ġraid ing +Ġf rench +Ġang led +Trans action +ĠGen ocide +u pe +ĠHait ian +57 2 +! : +Ġunwitting ly +iter ator +sc roll +Ġtall ied +Ġbi omedical +ĠC ARD +Ġe uphem +Ġbrain storm +a quin +K o +Mic helle +ĠR unes +ĠBall istic +ud ers +Ġmod esty +ĠiP ads +ĠEzek iel +Y E +Ġstars hip +Ġpower fully +Ġper l +ĠSh ade +ĠQu art +ĠE EG +Ġfisher man +OS ED +ĠTyp ical +df x +Ġmes hes +Ġet ched +worth iness +Ġtopp led +Ġ3 96 +or ius +We iss +Ġmy sql +ĠVal halla +Ù Ĵ +le asing +Ġrec omp +rap nel +S el +04 3 +Ġder ailed +ĠGu ides +IR T +Ġde human +ĠBritt any +" )) +Ġex claim +Ġb alk +Ġ8 40 +CLA IM +int el +L AB +Ġpe gged +Ġast roph +sm oking +Ġrig ging +Ġfix ation +Ġcat apult +ins ide +ĠC ascade +ĠBolshe vik +G aza +Dep th +Ġloud spe +Ġalmond s +me yer +l eness +j en +f resh +Ġunbeat en +ĠSqu id +ĠPres umably +Tim er +B W +Ġro sters +Ġell ipt +ĠHar riet +dat abase +ĠMut ual +ĠComm odore +uk ed +kn ife +ĠCOMM UN +h ya +Ġmel ts +arch ives +Ġrat ification +Ġmultip lying +Ġinter oper +Ġasc ert +w ings +ver ting +ĠScorp ion +ay e +ĠPorts mouth +ĠM TA +n it +iaz ep +Ġqu arantine +Ġslides how +Ġcent imeters +Ġsyn opsis +Ġsp ate +th irst +Ġnom inating +ĠMel vin +Pre view +Ġthro b +Ġgener ational +ĠRad ius +rest ling +put able +aw ar +N ECT +Ġunlaw fully +ĠRevel ations +Wik ipedia +sur v +Ġeye ing +ij n +ĠF W +Ġbr unt +Ġinter stellar +Ġcl itor +ĠCroat ian +ĠCh ic +ev a +ĠDis app +ĠA kin +iner ies +d ust +Interest ed +Ġgen esis +ĠE ucl +ö n +p icking +Ġmut ated +Ġdisappro ve +ĠHD L +Ġ6 25 +Ì ¶ +c ancer +Ġsqu ats +Ġle vers +Disc uss += ] +D ex +ĠVIDE OS +A UD +Ġtrans act +ĠKin ect +ĠK uala +ĠC yp +7 47 +Ġsh attering +Ġarsen ic +ĠInt ake +ĠAngel o +ĠQu it +ĠK he +Ġ18 93 +M aker +0 29 +ĠPain ting +Dis able +9 16 +Ġanal ges +Ġtact ile +Ġprop hes +Ġd iced +ĠTravel s +ĠHe ader +ĠClub s +Ass istant +Ġinc rim +Ġd ips +Ġcruc ifix +ĠShan ahan +ĠInter pret +Ġ40 90 +al ogy +abb a +Ġsimul ac +hus band +S IM +Ġrecy cle +uc er +ed ged +Ġre naissance +ĠBomb ay +Cath olic +ĠL INE +ĠCl othing +re ports +Ġpl aus +Ġd ag +ĠM ace +Z I +Ġintr uder +ĠVeter inary +g ru +Ġsne aky +ĠS ie +ĠC innamon +P OSE +Ġcou rier +ĠC NS +Ġemanc ipation +s it +Ġplay through +ĠFac ilities +v irt +ĠG auntlet +Thom pson +Ġunbeliev ably +Param eters +Ġst itching +ign e +ĠTH ESE +Priv acy +Ġshenan igans +Ġvit ri +ĠVal id +59 1 +Ń · +ĠProt otype +ink a +SC P +ĠT id +è Ī +old ed +Ġindividual ity +Ġbark ing +Ġm ars +ĠW D +Ġ8 20 +Ġt ir +Ġsl apping +Ġdisgr untled +ĠAng ola +ri us +ĠTorn ado +ĠTh urs +Ġcapt cha +Ġang st +ĠP og +ĠAssass ins +ĠAd idas +Ġjoy ful +Ġwh ining +Emer gency +Ġphosph orus +Ġatt rition +oph on +ĠTimber wolves +ĠJ ah +ĠBr inging +ĠW ad +ĠEn sure +oh l +ĠX ie +omm el +c mp +Ġz ipper +Ġrel at +ĠCor ridor +m ilo +T ING +Av g +Ġcro pped +] } +Ġr aged +ĠLump ur +ĠGuer rero +our ke +N ut +Ġoff sets +og lu +dr m +Ġmort als +lat able +Ġdismiss ive +ä¸ ī +Ġthro ats +Ġchips et +ĠSpot light +Catal og +art ist +G b +Ġch illy +Ġst oked +Ġ3 74 +W ard +L atin +Ġf iasco +Ġble ach +Ġb rav +Enh anced +Ġin oc +ĠFior ina +_ > +Ġle ukemia +Ġel uc +Ġannoun cer +ĠLith uan +ĠArm ageddon +å ĩ +Len in +ĠR uk +Ġpe pp +ĠRom antic +ĠP IT +ĠInter stellar +ĠAt kinson +R aid +J s +Go al +C ourse +Ġvan ishing +es ley +ĠR ounds +Els a +59 3 +Ġredund ancy +ĠST AND +Ġprop hetic +Ġhabit able +ry u +Ġfaint ly +M ODE +Ġfl anked +IR C +Aw esome +Ġsp urious +ĠZ ah +ĠMS G +Ġsh ading +Ġmotiv ational +ĠSant ana +ĠS PR +Ġexc ruciating +om ial +ĠM iko +ĠLe opard +A byss +Ġ[ | +d irty +Ġbath s +Ġdem oral +and re +P B +Ġun ification +Ġsac rament +Ġ[ & +Ġpric eless +Ġgel atin +Ġeman ating +ĠAll aah +98 6 +Ġout burst +Ġer as +ĠX VI +ĠSP I +O tt +ĠLaz arus +PL IED +F lying +blog s +W isconsin +R aven +Ġreb ate +Ġcreep s +ĠSp an +ĠPain ter +ĠKir a +ĠAm os +ĠCor vette +Cons umer +ĠRec over +ck i +Ġpes ky +ĠIn vention +Compan ies +Ġchalleng ers +ad emic +ĠUkrain ians +ĠNeuro log +ĠFors aken +Ġent rants +Ġemb attled +Ġdef unct +ĠGlac ier +Ġpo isons +ĠH orses +m akes +ĠD irt +Ġ4 23 +hh h +ĠTrans formation +QUI RE +................ .. +Ġtrave ller +ĠSe xy +ĠK ern +ip olar +Ġransom ware +oooooooo oooooooo +E c +rub y +Prof essional +ĠOut break +arg ument +G rey +ĠFif a +ĠCH O +ĠFOR M +ĠAm trak +- [ +Ġcr adle +Ġantioxid ants +ãģ®å ® +7 36 +ĠNAS L +ĠContribut ions +Ind iana +ĠST EP +C SS +Ġsal ient +Ġall ocations +yr ights +Ġm ashed +ĠCut ter +Sex ual +Ġp ounded +Ġfan base +Ġc asc +ĠTrans parency +Ġanaly tic +ĠSummon er +× ŀ +ĠAD C +det ail +Ġvan quished +Ġcr abs +ar ie +Dest roy +ĠS ack +Ġtrans istor +Al abama +ĠK oen +ĠFisher ies +c one +Ġannex ed +ĠM GM +es a +Ġf aked +ĠCong ratulations +Ġhind ered +Ġcorrection al +ĠI TV +lee ve +Ġin appropriately +lic ks +Ġtresp ass +Ġp aws +Ġnegoti ator +ĠChrist ensen +lim its +ĠDian ne +Ġeleg ance +ĠContract s +an ke +Ob j +Ġvigil ance +Ġcast les +ĠN AD +ĠHol o +Ġemph atically +ĠTit us +ĠServ ing +ĠRich ie +ĠP igs +5 68 +Ġanim osity +ĠAtt ributes +ĠU riel +M Q +my ra +ĠApplic ant +Ġpsychiat rists +ĠV ij +ĠAb by +ag ree +P ush +Ġk Wh +hib a +Ġinc ite +ĠWe asley +ĠTax i +minist ic +hy per +ĠF arn +Ġ6 01 +ĠNation wide +F ake +95 2 +Ġma ize +Ġinteract ed +Ġtransition ed +Ġparas itic +Ġharm onic +Ġdec aying +Ġbas eless +ns ics +Ġtrans pired +Ġabund antly +ĠFore nsic +Ġtread mill +ĠJ av +ab and +Ġssh d +Ġfront man +ĠJak arta +oll er +dro ps +ĠSERV ICES +rompt u +oph ical +h ospital +bled on +6 45 +Ġmid range +ĠEV ENT +cul ated +raw led +Ġper ched +Ġover board +ĠPe el +ĠP wr +ĠCar th +ĠCOM PLE +co e +sh all +Ġdeter rence +M ETHOD +ĠAbs ent +M EN +Ġs ill +ĠLE VEL +Y ork +Ġsin ners +ĠOP EC +ĠN ur +ĠDesign s +se lection +Ġunw orthy +CH A +Ġstreng thens +88 3 +ed ly +Ġslic ing +Ġmal nutrition +Ġfilm making +ĠPol k +ur ated +Ġ4 21 +bre akers +!' " +Ġwet lands +ĠDisc rimination +Ġallow able +Ġste ered +ĠSic ily +S AM +Ġmust ache +Ġm ids +Ġcl ipped +Ġcirc ulate +Ġbr ittle +ĠBuild ings +ra ised +ĠRound up +Ġwealth ier +Ġoverw rite +Ġover powered +ĠGerr ard +s ites +PD ATED +Ġacute ly +ĠGam ble +Ġp im +ĠK us +Typ ically +De ploy +ĠMoroc can +p otion +com be +Ġvigil ante +Ġ36 3 +St ew +ĠB agg +Ġres ided +ĠSp o +Ġrem nant +Ġempt iness +br ainer +Ġout patient +pri ority +Ġle ptin +ĠPay ton +ĠGle aming +ĠS hed +ĠPol o +ĠMormon ism +rest ricted +arl ane +w x +Ġcreat ine +ĠAn on +ĠST UD +ĠJ UL +ĠT ee +5 28 +08 9 +Ġhat ched +Dis patch +ĠCompos ite +Ġ45 1 +p uff +ĠX COM +ĠOr n +ĠTH ANK +END ED +ĠAshe ville +Ġà ľ +Ġman go +ĠS lightly +world ly +ĠW ander +ĠExp and +ĠCh r +M ist +Ġorthodox y +ĠUN ESCO +reg ate +Else where +k ie +ir led +Ġtopp le +Ġadopt ive +ĠLeg s +d ress +ĠS agan +b are +ĠGl ou +Cr unch +Ġhelp ers +Ġchron ically +ĠH uma +1 0000 +Ġaccommod ating +äº Ķ +Ġwrink les +Ġdod ged +four th +Ġpre con +Ġcompress or +ĠK are +Ġev ict +ĠWar wick +im ar +Ġmodern ization +Ġband wagon +Ġref uted +Ġnet ted +ĠNa ples +ĠGen ie +per ors +Ġfield ed +Ġde re +ĠPar ables +le es +Ġtr out +asp ers +Ġn ihil +Ġhapp iest +Ġflo ppy +ĠLo ft +ĠHe ard +Ġun ison +Ġl ug +ĠRed mond +class ic +Supp orters +SH IP +G MT +Ġfue lled +ç IJ +Ġd d +ĠEmin em +Ġ18 97 +NY SE +Ġsecret aries +ĠF IA +ĠCanaver al +F avorite +Ġp omp +Ġdetain ee +ers hip +aim on +i our +ĠA pex +Ġplant ations +am ia +ac ion +R ust +Ġtow ed +ĠTru ly +5 77 +Ġshel tered +r ider +W o +Ġl air +ĠInt elligent +impro ve +m atically +Ġet iquette +ad ra +all o +ĠJun o +any thing +ĠStru ggle +ĠPred ict +ĠGr imes +ĠAMER ICA +ct x +ĠSit uation +W OOD +Ġsol uble +me ier +Ġintoler able +ang ering +Ġun interrupted +Ġtool tip +Ġinterrog ated +Ġgun ned +ĠSne ak +æŃ ¦ +Ġt ether +Ġcr umble +L ens +Ġclust ered +ĠSy l +ĠHas an +Ġdystop ian +w ana +Ġjoy stick +ĠTh ib +amm u +Tom orrow +5 46 +Ġoverc ame +Ġminim ized +cept or +Run ner +ENG TH +ĠBrend a +ĠAchieve ments +Ġtor ches +Ġrapp ort +ĠInvestig ator +ĠHand ling +rel ation +g rey +8 15 +Ġk cal +ĠComm ands +d q +Ġcur ls +Ġbe arer +Ġcyn icism +it ri +ĠUse ful +B ee +D CS +Ġab ras +P ract +BIL ITIES +7 12 +Ġdebug ger +Ġdebt or +ĠL ia +ĠK ers +Ġexacerb ate +ĠSt acy +ĠB land +ĠSc enes +Ġbranch ing +âĸĪâĸĪâĸĪâĸĪ âĸĪâĸĪâĸĪâĸĪ +ape ake +Ġs alsa +Ġmish and +ĠKon ami +ĠN ib +Ġanecd ote +Ġagree able +Ï ī +ĠNath aniel +ĠHe isman +ĠB eware +Ġ18 86 +spect ive +69 1 +5 22 +Ġinhib its +Ġhas hing +Ġ18 89 +å° Ĩ +v ich +P ure +Ġsolid ly +Ġaspir in +im aru +Ġstreet car +ĠU CS +ĠJ udd +Ġflash backs +p ins +Ġ14 40 +ĠUN HCR +ĠSym ptoms +T IT +5 38 +F ra +% ); +Ġo oz +Ġcur few +Ġcal med +Ġparticip ates +Te X +Ġnons ensical +Ġfull back +ĠDe L +mon key +h ari +Ġmetabol ites +Ġloot ed +ĠAL WAYS +ĠB CC +L t +oc het +B one +Ġveto ed +Ġg cc +ĠCL ICK +Ġ18 88 +s af +Ġstiff ness +Ġlow ly +ĠGe h +vers on +ors et +Ġun foreseen +Ġan esthesia +ĠOpt ical +Ġrecon structed +ĠT up +sh ows +NEW S +ĠNewsp aper +ĠA SA +ter a +N umbers +Ġinexpl icable +× ij +Ġhard ness +unt arily +ĠA cer +grad ient +ARD IS +Ġwood land +Ġmetaph ors +ĠWem bley +ĠPa vel +phil is +Ġre writing +Ġpercept ual +Ġ10 70 +worm s +ĠDown s +Ġunsur prisingly +Ġtag ging +fl ame +Ġlit res +Ġboun ces +ĠB abe +sh ut +Ġoverd oses +ĠShe ila +ĠCh au +ĠBl ess +Capt ure +ĠSign ificant +ĠSc ion +Ġ38 9 +ĠMc H +ĠTitan ium +ĠMe al +amed a +ag ents +agg ressive +B illy +76 3 +ĠS aying +DER R +it one +Coll ins +B ound +Ġbol ted +ĠDM CA +95 3 +Ġun iqueness +Ġep igen +un ci +ant am +Ġreck oning +ch airs +OG R +ĠSen egal +Ġ18 62 +re levant +Ġ ¯ +Ġpharm acies +ĠG eral +v ier +Y an +OR PG +Ġrab id +b ending +ĠUN ITED +Ġ4 65 +As sembly +Ġwe ep +Ġbe hest +ĠMother s +ĠJ ace +h id +Ġwh irlwind +ĠUN IVERS +Ġut opian +Ġkidn ap +Ph ilipp +K in +89 3 +Ġlivest ream +ĠM ISS +Ġsub versive +ĠTechn iques +ĠJUST ICE +ĠB ASE +Ġ38 7 +Ġassail ants +ĠHard core +Ġsprink led +ĠP se +é ļ +print ed +ĠH au +OR GE +ĠT OUR +Ġl aced +Ġit ch +G iving +Ġport ed +78 1 +//////////////// //////////////// +bre eding +Ġlog ger +ĠH OL +inn ie +First ly +Ġembry onic +Ġdeleg ated +p ai +O IL +Ġcentr ally +ĠR x +ĠSc outing +D utch +Ġhe reditary +ĠCru iser +s at +5 29 +ĠMar riott +other mal +Ġprohib itions +E arn +ĠSt ab +ĠColleg es +ĠBel ief +st retched +ĠL H +ĠEntity Item +C IA +Ġun rem +Ġlaure ate +Ġdenomin ations +sum mary +h ler +S pect +ĠK laus +ĠBe ans +Ġins ur +ĠPA X +Ġfield er +ĠV et +ĠSp arrow +z ie +ĠS Q +ĠMond ays +ĠOff line +ĠLer ner +ĠExt ensions +Ire land +Ġpatron age +Ġcontrast ed +ĠMan ia +h irt +Mos cow +Ġcondem ns +ĠAn ge +Ġcomp osing +ĠPe pe +ĠP addock +Ġheter ogeneity +Ġide ologically +Ġf ishes +Ġcur sing +ĠR utherford +ĠFlo ating +ĠAm elia +Te a +Syn opsis +Ġstun ts +Ġbe ad +Ġstock ing +ĠM ILL +ob ook +mass ive +\ < +Ġh ump +ĠPref erences +Engine Debug +ge ist +ĠNiet o +ome ver +ish y +eval uate +col onial +Altern ative +ĠGo Pro +ĠV ortex +ĠNET WORK +ans ky +Sec ure +ĠTh rust +Sn ake +Ġparcel s +Ġsam urai +Ġactress es +N ap +M F +ifer ation +Be er +5 23 +ĠI ly +oint ment +P ing +Ġstri ped +ĠMell on +oss ession +Ġneut ron +end ium +Ġa ph +ĠFlav oring +Ġ38 3 +Ġrespons iveness +ĠJ indal +ĠHitch cock +Den ver +ĠDRAG ON +sm anship +ĠDu pl +Ġs ly +Ġweb cam +ĠTw ain +ĠDar ling +ili ate +cons umer +D IT +Ġnames ake +Ġun orthodox +Ġfun er +ĠPL oS +ĠCONTR OL +ozy g +ogl obin +F ACE +ER G +ĠD ia +ĠF iesta +ce le +0 34 +Ġencl ave +âĸ¬ âĸ¬ +on ement +al ist +M and +Ġhome grown +ĠF ancy +Ġconcept ions +ĠCont ains +ure en +Ġreiter ate +Ġme ager +Ġinstall ments +Sp awn +6 27 +Ġphot oc +ĠCab rera +ĠRos enthal +ĠLans ing +is ner +Ġinvest s +ĠUFO s +EX P +Hard ware +Ġtr agically +Ġconced es +ie ft +ch am +bor gh +ĠSch r +ĠMel anie +ĠH oy +Ġvisit ation +Ġid iosyncr +Ġfract ions +Ġfore skin +ob os +Ġpo aching +ĠVI EW +Ġstimul ates +ĠG ork +can on +M IC +ĠNem esis +ĠInd ra +ĠDM V +Ġ5 29 +Ġinspect ing +Ġgrand ma +ĠW hedon +ĠSh ant +ĠP urg +ik an +ĠT eg +ĠCL R +z ac +Vict oria +ĠVer ify +ion ics +Ġpart ying +ĠM ou +col our +Ġtestim onies +l ations +Ġpress uring +hi ro +ac ers +Ġf id +ang ler +ĠCS I +Ġhere after +Ġdiss idents +report ing +iph any +che v +Ġsol itude +Ġl obe +Ġind is +Ġcred ential +re cent +ad ult +ĠNir vana +ĠFranch ise +L ayer +H yp +ĠBerks hire +Ġwill s +t if +Ġtot em +ĠJud ah +rep air +Inst ant +5 48 +Ġemb assies +Ġbott leneck +Ġb ount +Ġtyp ew +ĠAl vin +j ing +im ilar +R ush +Ġbr im +ĠHEL P +A im +] ' +Ġpass ively +Ġbound ed +ĠR ated +Ġcriminal ity +Ġbiom ark +Ġdisp atcher +ĠTow ards +Ġ+ ++ +right eous +f rog +ĠP anc +C arter +0 32 +æ© Ł +Ġult raviolet +ĠLic ensed +ĠT ata +ĠBl essing +ĠG AM +Ġchem ically +ĠSe af +ĠRE LE +ĠMerc enary +capital ist +Ġform ulations +Ġann ihilation +ĠVer b +ĠAr gon +Ġun loaded +Ġmorp hed +Ġconqu ering +back er +I ELD +Ġtheft s +Ġfront runner +ĠRoy ale +ĠFund amental +el ight +C hip +necess ary +ay n +ĠSl ip +Ġ4 48 +cern ed +P ause +Ġshock ingly +ĠAB V +Ġcomp osure +7 33 +ĠMotors port +ah ime +Mur ray +M ach +Ġgr ids +Ġdeb ian +Ġfurther more +Ġdexter ity +ĠCollect ions +os lov +il age +b j +ĠMont eneg +Ġstrut Connector +Ġmassac res +Ġbrief s +fet ched +uv ian +ol ition +Fail ure +emon ic +Ġfl ared +Ġclaim ant +Ġc ures +Ġgive aways +ĠSubst ance +al ions +Ġcr inge +ĠK ul +Ġarist ocracy +ĠUl ster +ol ated +h ousing +ĠM IS +Ġgl ared +ĠWil helm +ne eds +lam bda +build ers +ĠV IS +Ġradi ator +ĠGhost busters +Ġ4 36 +act ual +Ġher ds +ç a +watch ing +Ġcounter ing +Ch arge +Ġchar red +Ġwar heads +Ġiod ine +ĠM acy +04 1 +Ġdepart ures +ĠS ins +Ġdy ed +ĠConcept s +g ado +7 13 +Ġquot ations +Ġg ist +ĠChrist y +Ġant igen +ĠHem p +ĠD rawn +ĠB arg +ez vous +Ġp aternity +Ġar du +ĠAnch orage +ĠR ik +Ġover loaded +ĠUs ername +ĠTam my +ĠN au +ĠCell ular +Ġw aning +Ġrod ent +ĠWor cester +il ts +ĠT ad +Ġdwell ings +Ġbull ish +4 31 +Ġretali ate +Ġmig raine +ĠChev ron +CH ECK +Ġdon key +c rim +SP A +ĠAn alog +Ġmarqu ee +ĠHa as +B ir +ĠGD DR +ĠDownload s +Ġwill power +ĠFor th +ĠRecord ed +Ġimp ossibility +ĠLog ged +ĠFr anks +ĠR att +in itions +Ġclean ers +Ġsore ly +Ġflick ering +ĠEx amination +c atching +allow een +Ms g +Ġdun no +F a +Ġdys ph +c razy +.' '. +Ġmain line +Ġc s +Ġp tr +ĠW ally +ig un +95 1 +ĠBig foot +f ights +Ġretrie ving +J r +Ġdupl ication +ĠExpl an +Ġrel ational +Ġqu aint +Ġbisc uits +Ġad o +Ġsh udder +Ġantid ote +blood ed +ks h +Ġsa uces +Ġrein vest +Ġdispens ary +ĠD iver +Ġ9 000 +stud ent +Ġin separ +esc ap +Ġtodd lers +ĠGP IO +ĠAss ignment +head ers +Ġlack luster +Ġab ack +95 6 +Ġtool bar +7 45 +Ġo ust +Ġcontempl ation +ĠPRES IDENT +Ġ4 58 +==== == +Ġguarantee ing +ĠHe ist +ĠCann es +Ļ ½ +Ġcollabor ator +ĠAm p +Ġg ou +ĠSH ALL +st ories +78 3 +Ġmobil ized +Ġbro od +ĠL U +ĠðŁ ij +Ġref in +ĠAnthrop ology +v ind +ill i +Ġwarrant ies +ĠB abel +Ġsw ath +Ġc aches +Ġantagon ists +art ifacts +Ġhot ly +ĠSt arts +ĠG ö +z ag +!! !!! +Ġsc ourge +Ġcons piring +ru its +re verse +ĠShe en +ĠJes uit +ĠGiov anni +ad ies +Ġbutt ocks +ear cher +ac an +Ġvolley ball +Ġshroud ed +Ġscore board +b ats +ĠI PM +Ġass es +Ġde regulation +ĠTe legram +ĠReb oot +Ġ7 000 +ĠCan ary +Ġk ernels +ĠFranç ois +ĠD uff +ĠP on +ĠLe ica +ĠGar min +Ġor phans +ĠClaud ia +Ġcal endars +ĠLe ilan +ent o +R ocket +Ġbr unch +ĠHaw king +ain ers +Ġsens ibilities +Ġk W +ĠK and +Ġre claimed +Ġinteresting ly +× © +rom y +J M +ĠEnhance ment +b ush +Sk ip +Ġrapp ers +Ġg azing +p edia +ath lon +Rev olution +Ġsn ipers +Ġre verted +Ġconglomer ate +T erry +79 4 +Ġhars her +Ġdes olate +ĠHit man +Comm ission +Ġ( / +âĢ¦ ." +Com par +Ġampl ification +om inated +Ġreg ress +ĠColl ider +Ġinform ants +Ġg azed diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/utils/__pycache__/__init__.cpython-37.pyc b/utils/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fb48e59aa71d8970e75e063628430cf426f3a1f Binary files /dev/null and b/utils/__pycache__/__init__.cpython-37.pyc differ diff --git a/utils/__pycache__/__init__.cpython-38.pyc b/utils/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e396595c7f4d221c8c26256371067ed92f0b259e Binary files /dev/null and b/utils/__pycache__/__init__.cpython-38.pyc differ diff --git a/utils/__pycache__/__init__.cpython-39.pyc b/utils/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5d16f533a0c2f64ca520bc859beba24642a8bdc Binary files /dev/null and b/utils/__pycache__/__init__.cpython-39.pyc differ diff --git a/utils/__pycache__/checkpoint_utils.cpython-37.pyc b/utils/__pycache__/checkpoint_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ed1d6c1a37c979d00c61a4b4a79a8ac939a9940 Binary files /dev/null and b/utils/__pycache__/checkpoint_utils.cpython-37.pyc differ diff --git a/utils/__pycache__/checkpoint_utils.cpython-38.pyc b/utils/__pycache__/checkpoint_utils.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7949c464e2bbc5c9f15f55fde7d8a97105643a8c Binary files /dev/null and b/utils/__pycache__/checkpoint_utils.cpython-38.pyc differ diff --git a/utils/__pycache__/checkpoint_utils.cpython-39.pyc b/utils/__pycache__/checkpoint_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e50f96612a22b463ba2ba56ff81e73f3a7b0c319 Binary files /dev/null and b/utils/__pycache__/checkpoint_utils.cpython-39.pyc differ diff --git a/utils/__pycache__/eval_utils.cpython-37.pyc b/utils/__pycache__/eval_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1a89d9aef5864b862e98ce57c7c1bad9a7bed52 Binary files /dev/null and b/utils/__pycache__/eval_utils.cpython-37.pyc differ diff --git a/utils/__pycache__/eval_utils.cpython-39.pyc b/utils/__pycache__/eval_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e3d787b68b3d3cbc3fa9b88b5b63aa10b1a697b Binary files /dev/null and b/utils/__pycache__/eval_utils.cpython-39.pyc differ diff --git a/utils/__pycache__/transforms.cpython-37.pyc b/utils/__pycache__/transforms.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b6a308f853721239106b78c482db5376e1e15d9 Binary files /dev/null and b/utils/__pycache__/transforms.cpython-37.pyc differ diff --git a/utils/__pycache__/transforms.cpython-38.pyc b/utils/__pycache__/transforms.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe09fc6df4d8bfbd219b8e4e638fa9e1759697c1 Binary files /dev/null and b/utils/__pycache__/transforms.cpython-38.pyc differ diff --git a/utils/__pycache__/transforms.cpython-39.pyc b/utils/__pycache__/transforms.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa0ebb9d082154a89378634bdc81f7411bf8b77e Binary files /dev/null and b/utils/__pycache__/transforms.cpython-39.pyc differ diff --git a/utils/__pycache__/trie.cpython-37.pyc b/utils/__pycache__/trie.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f9481bd875c141a554523439017a12fa30b3e32 Binary files /dev/null and b/utils/__pycache__/trie.cpython-37.pyc differ diff --git a/utils/__pycache__/trie.cpython-38.pyc b/utils/__pycache__/trie.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d40f6e47c866bb8a3bbaca97f3bd133f84a66b2 Binary files /dev/null and b/utils/__pycache__/trie.cpython-38.pyc differ diff --git a/utils/__pycache__/trie.cpython-39.pyc b/utils/__pycache__/trie.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86f5db038f90ba5f427a61a07099cdc3c0f5a131 Binary files /dev/null and b/utils/__pycache__/trie.cpython-39.pyc differ diff --git a/utils/__pycache__/utils.cpython-37.pyc b/utils/__pycache__/utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..acf30f141f90d3b89a66fe2567811b66e82439a6 Binary files /dev/null and b/utils/__pycache__/utils.cpython-37.pyc differ diff --git a/utils/__pycache__/utils.cpython-39.pyc b/utils/__pycache__/utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..909c6950c51fbb23f6162cdf1280242576fa51b9 Binary files /dev/null and b/utils/__pycache__/utils.cpython-39.pyc differ diff --git a/utils/__pycache__/vision_helper.cpython-37.pyc b/utils/__pycache__/vision_helper.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98642c0523ae4116d44cf26417971d69a61a33e7 Binary files /dev/null and b/utils/__pycache__/vision_helper.cpython-37.pyc differ diff --git a/utils/__pycache__/vision_helper.cpython-38.pyc b/utils/__pycache__/vision_helper.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..151bc32855fb8895f770f109dba204e14ef0c7da Binary files /dev/null and b/utils/__pycache__/vision_helper.cpython-38.pyc differ diff --git a/utils/__pycache__/vision_helper.cpython-39.pyc b/utils/__pycache__/vision_helper.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5fafa258ff91f6603a49e047fc3c5de4f7d94b7f Binary files /dev/null and b/utils/__pycache__/vision_helper.cpython-39.pyc differ diff --git a/utils/__pycache__/zero_shot_utils.cpython-37.pyc b/utils/__pycache__/zero_shot_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fab21efb658bde5138111f654771531877715e97 Binary files /dev/null and b/utils/__pycache__/zero_shot_utils.cpython-37.pyc differ diff --git a/utils/__pycache__/zero_shot_utils.cpython-39.pyc b/utils/__pycache__/zero_shot_utils.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8da9a1c3f999a7ee36e6128ad7965b4521dc7e4a Binary files /dev/null and b/utils/__pycache__/zero_shot_utils.cpython-39.pyc differ diff --git a/utils/checkpoint_utils.py b/utils/checkpoint_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f197e4c1fdcc1dc1f3624cd14652f973d6e87e88 --- /dev/null +++ b/utils/checkpoint_utils.py @@ -0,0 +1,897 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import ast +import collections +import contextlib +import logging +import numpy as np +import os +import re +import time +import traceback +import math +from collections import OrderedDict +from typing import Any, Dict, Optional, Union + +import torch +from fairseq.dataclass.configs import CheckpointConfig +from fairseq.dataclass.utils import ( + convert_namespace_to_omegaconf, + overwrite_args_by_name, +) +from fairseq.distributed.fully_sharded_data_parallel import FSDP, has_FSDP +from fairseq.file_io import PathManager +from fairseq.models import FairseqDecoder, FairseqEncoder +from omegaconf import DictConfig, open_dict, OmegaConf + +from data import data_utils + +logger = logging.getLogger(__name__) + + +def save_checkpoint(cfg: CheckpointConfig, trainer, epoch_itr, val_loss, save_on_cuda=False): + from fairseq import meters + + # only one worker should attempt to create the required dir + if trainer.data_parallel_rank == 0: + os.makedirs(cfg.save_dir, exist_ok=True) + + prev_best = getattr(save_checkpoint, "best", val_loss) + if val_loss is not None: + best_function = max if cfg.maximize_best_checkpoint_metric else min + save_checkpoint.best = best_function(val_loss, prev_best) + + if cfg.no_save: + return + + trainer.consolidate_optimizer() # TODO(SS): do we need this if no_save_optimizer_state + + if not trainer.should_save_checkpoint_on_current_rank: + if trainer.always_call_state_dict_during_save_checkpoint: + trainer.state_dict() + return + + write_timer = meters.StopwatchMeter() + write_timer.start() + + epoch = epoch_itr.epoch + end_of_epoch = epoch_itr.end_of_epoch() + updates = trainer.get_num_updates() + + logger.info(f"Preparing to save checkpoint for epoch {epoch} @ {updates} updates") + + def is_better(a, b): + return a >= b if cfg.maximize_best_checkpoint_metric else a <= b + + suffix = trainer.checkpoint_suffix + checkpoint_conds = collections.OrderedDict() + checkpoint_conds["checkpoint{}{}.pt".format(epoch, suffix)] = ( + end_of_epoch and not cfg.no_epoch_checkpoints and epoch % cfg.save_interval == 0 + ) + checkpoint_conds["checkpoint_{}_{}{}.pt".format(epoch, updates, suffix)] = ( + not end_of_epoch + and cfg.save_interval_updates > 0 + and updates % cfg.save_interval_updates == 0 + ) + checkpoint_conds["checkpoint_best{}.pt".format(suffix)] = val_loss is not None and ( + not hasattr(save_checkpoint, "best") + or is_better(val_loss, save_checkpoint.best) + ) + if val_loss is not None and cfg.keep_best_checkpoints > 0: + worst_best = getattr(save_checkpoint, "best", None) + chkpts = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint\.best_{}_(\d+\.?\d*){}\.pt".format( + cfg.best_checkpoint_metric, suffix + ), + ) + if len(chkpts) > 0: + p = chkpts[-1] if cfg.maximize_best_checkpoint_metric else chkpts[0] + worst_best = float(p.rsplit("_")[-1].replace("{}.pt".format(suffix), "")) + # add random digits to resolve ties + with data_utils.numpy_seed(epoch, updates, val_loss): + rand_sfx = np.random.randint(0, cfg.keep_best_checkpoints) + + checkpoint_conds[ + "checkpoint.best_{}_{:.3f}{}{}.pt".format( + cfg.best_checkpoint_metric, + val_loss, + rand_sfx, + suffix + ) + ] = worst_best is None or is_better(val_loss, worst_best) + checkpoint_conds[ + "checkpoint_last{}.pt".format(suffix) + ] = not cfg.no_last_checkpoints + + extra_state = {"train_iterator": epoch_itr.state_dict(), "val_loss": val_loss} + if hasattr(save_checkpoint, "best"): + extra_state.update({"best": save_checkpoint.best}) + + checkpoints = [ + os.path.join(cfg.save_dir, fn) for fn, cond in checkpoint_conds.items() if cond + ] + if len(checkpoints) > 0: + trainer.save_checkpoint(checkpoints[0], extra_state, save_on_cuda=save_on_cuda) + for cp in checkpoints[1:]: + if cfg.write_checkpoints_asynchronously: + # TODO[ioPath]: Need to implement a delayed asynchronous + # file copying/moving feature. + logger.warning( + f"ioPath is not copying {checkpoints[0]} to {cp} " + "since async write mode is on." + ) + else: + assert PathManager.copy( + checkpoints[0], cp, overwrite=True + ), f"Failed to copy {checkpoints[0]} to {cp}" + + write_timer.stop() + logger.info( + "Saved checkpoint {} (epoch {} @ {} updates, score {}) (writing took {} seconds)".format( + checkpoints[0], epoch, updates, val_loss, write_timer.sum + ) + ) + + if not end_of_epoch and cfg.keep_interval_updates > 0: + # remove old checkpoints; checkpoints are sorted in descending order + if cfg.keep_interval_updates_pattern == -1: + checkpoints = checkpoint_paths( + cfg.save_dir, pattern=r"checkpoint_\d+_(\d+){}\.pt".format(suffix) + ) + else: + checkpoints = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint_\d+_(\d+){}\.pt".format(suffix), + keep_match=True, + ) + checkpoints = [ + x[0] + for x in checkpoints + if x[1] % cfg.keep_interval_updates_pattern != 0 + ] + + for old_chk in checkpoints[cfg.keep_interval_updates :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + if cfg.keep_last_epochs > 0: + # remove old epoch checkpoints; checkpoints are sorted in descending order + checkpoints = checkpoint_paths( + cfg.save_dir, pattern=r"checkpoint(\d+){}\.pt".format(suffix) + ) + for old_chk in checkpoints[cfg.keep_last_epochs :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + if cfg.keep_best_checkpoints > 0: + # only keep the best N checkpoints according to validation metric + checkpoints = checkpoint_paths( + cfg.save_dir, + pattern=r"checkpoint\.best_{}_(\d+\.?\d*){}\.pt".format( + cfg.best_checkpoint_metric, suffix + ), + ) + if not cfg.maximize_best_checkpoint_metric: + checkpoints = checkpoints[::-1] + for old_chk in checkpoints[cfg.keep_best_checkpoints :]: + if os.path.lexists(old_chk): + os.remove(old_chk) + elif PathManager.exists(old_chk): + PathManager.rm(old_chk) + + +def load_checkpoint(cfg: CheckpointConfig, trainer, strict=True, load_on_cuda=False, **passthrough_args): + """ + Load a checkpoint and restore the training iterator. + + *passthrough_args* will be passed through to + ``trainer.get_train_iterator``. + """ + + reset_optimizer = cfg.reset_optimizer + reset_lr_scheduler = cfg.reset_lr_scheduler + optimizer_overrides = ast.literal_eval(cfg.optimizer_overrides) + reset_meters = cfg.reset_meters + reset_dataloader = cfg.reset_dataloader + + if cfg.finetune_from_model is not None and ( + reset_optimizer or reset_lr_scheduler or reset_meters or reset_dataloader + ): + raise ValueError( + "--finetune-from-model can not be set together with either --reset-optimizer" + " or reset_lr_scheduler or reset_meters or reset_dataloader" + ) + + suffix = trainer.checkpoint_suffix + if ( + cfg.restore_file == "checkpoint_last.pt" + ): # default value of restore_file is 'checkpoint_last.pt' + checkpoint_path = os.path.join( + cfg.save_dir, "checkpoint_last{}.pt".format(suffix) + ) + first_launch = not PathManager.exists(checkpoint_path) + if cfg.finetune_from_model is not None and first_launch: + # if there is no last checkpoint to restore, start the finetune from pretrained model + # else just use usual logic to load checkpoint, e.g. restart from last checkpoint and etc. + if PathManager.exists(cfg.finetune_from_model): + checkpoint_path = cfg.finetune_from_model + reset_optimizer = True + reset_lr_scheduler = True + reset_meters = True + reset_dataloader = True + logger.info( + f"loading pretrained model from {checkpoint_path}: " + "optimizer, lr scheduler, meters, dataloader will be reset" + ) + else: + raise ValueError( + f"--funetune-from-model {cfg.finetune_from_model} does not exist" + ) + elif suffix is not None: + checkpoint_path = cfg.restore_file.replace(".pt", suffix + ".pt") + else: + checkpoint_path = cfg.restore_file + + if cfg.restore_file != "checkpoint_last.pt" and cfg.finetune_from_model: + raise ValueError( + "--finetune-from-model and --restore-file (non-default value) " + "can not be specified together: " + str(cfg) + ) + + extra_state = trainer.load_checkpoint( + checkpoint_path, + reset_optimizer, + reset_lr_scheduler, + optimizer_overrides, + reset_meters=reset_meters, + strict=strict, + load_on_cuda=load_on_cuda, + ) + + if ( + extra_state is not None + and "best" in extra_state + and not reset_optimizer + and not reset_meters + ): + save_checkpoint.best = extra_state["best"] + + if extra_state is not None and not reset_dataloader: + # restore iterator from checkpoint + itr_state = extra_state["train_iterator"] + epoch_itr = trainer.get_train_iterator( + epoch=itr_state["epoch"], load_dataset=True, **passthrough_args + ) + epoch_itr.load_state_dict(itr_state) + _n = itr_state['iterations_in_epoch'] + offset = sum(len(_) for _ in epoch_itr.batch_sampler[:_n]) + epoch_itr.dataset.dataset._seek(offset=offset) + true_num = int(math.ceil(len(epoch_itr.dataset) / 8)) * 8 + another_offset = ((epoch_itr.epoch - 1) * true_num + offset) // 8 + if hasattr(epoch_itr.dataset, 'pure_text_dataset') and epoch_itr.dataset.pure_text_dataset is not None: + text_offset = (2 * another_offset) % len(epoch_itr.dataset.pure_text_dataset) + epoch_itr.dataset.pure_text_dataset._seek(offset=text_offset) + if hasattr(epoch_itr.dataset, 'pure_image_dataset') and epoch_itr.dataset.pure_image_dataset is not None: + image_offset = another_offset % len(epoch_itr.dataset.pure_image_dataset) + epoch_itr.dataset.pure_image_dataset._seek(offset=image_offset) + if hasattr(epoch_itr.dataset, 'detection_dataset') and epoch_itr.dataset.detection_dataset is not None: + detection_offset = another_offset % len(epoch_itr.dataset.detection_dataset) + epoch_itr.dataset.detection_dataset._seek(offset=detection_offset) + else: + epoch_itr = trainer.get_train_iterator( + epoch=1, load_dataset=True, **passthrough_args + ) + + trainer.lr_step(epoch_itr.epoch) + + return extra_state, epoch_itr + + +def load_checkpoint_to_cpu(path, arg_overrides=None, load_on_all_ranks=False, strict=True, load_on_cuda=False): + """Loads a checkpoint to CPU (with upgrading for backward compatibility). + + If doing single-GPU training or if the checkpoint is only being loaded by at + most one process on each node (current default behavior is for only rank 0 + to read the checkpoint from disk), load_on_all_ranks should be False to + avoid errors from torch.distributed not having been initialized or + torch.distributed.barrier() hanging. + + If all processes on each node may be loading the checkpoint + simultaneously, load_on_all_ranks should be set to True to avoid I/O + conflicts. + + There's currently no support for > 1 but < all processes loading the + checkpoint on each node. + """ + local_path = PathManager.get_local_path(path) + # The locally cached file returned by get_local_path() may be stale for + # remote files that are periodically updated/overwritten (ex: + # checkpoint_last.pt) - so we remove the local copy, sync across processes + # (if needed), and then download a fresh copy. + if local_path != path and PathManager.path_requires_pathmanager(path): + try: + os.remove(local_path) + except FileNotFoundError: + # With potentially multiple processes removing the same file, the + # file being missing is benign (missing_ok isn't available until + # Python 3.8). + pass + if load_on_all_ranks: + torch.distributed.barrier() + local_path = PathManager.get_local_path(path) + + if load_on_cuda: + map_device = torch.device("cuda") + else: + map_device = torch.device("cpu") + + with open(local_path, "rb") as f: + state = torch.load(f, map_location=map_device) + + if "args" in state and state["args"] is not None and arg_overrides is not None: + args = state["args"] + for arg_name, arg_val in arg_overrides.items(): + setattr(args, arg_name, arg_val) + + if "cfg" in state and state["cfg"] is not None: + + # hack to be able to set Namespace in dict config. this should be removed when we update to newer + # omegaconf version that supports object flags, or when we migrate all existing models + from omegaconf import _utils + + old_primitive = _utils.is_primitive_type + _utils.is_primitive_type = lambda _: True + + state["cfg"] = OmegaConf.create(state["cfg"]) + + _utils.is_primitive_type = old_primitive + OmegaConf.set_struct(state["cfg"], True) + print(arg_overrides) + print(state["cfg"]) + if arg_overrides is not None: + overwrite_args_by_name(state["cfg"], arg_overrides) + if strict: + state = _upgrade_state_dict(state) + return state + + +def load_model_ensemble( + filenames, + arg_overrides: Optional[Dict[str, Any]] = None, + task=None, + strict=True, + suffix="", + num_shards=1, + state=None, +): + """Loads an ensemble of models. + + Args: + filenames (List[str]): checkpoint files to load + arg_overrides (Dict[str,Any], optional): override model args that + were used during model training + task (fairseq.tasks.FairseqTask, optional): task to use for loading + """ + assert not ( + strict and num_shards > 1 + ), "Cannot load state dict with strict=True and checkpoint shards > 1" + ensemble, args, _task = load_model_ensemble_and_task( + filenames, + arg_overrides, + task, + strict, + suffix, + num_shards, + state, + ) + return ensemble, args + + +def get_maybe_sharded_checkpoint_filename( + filename: str, suffix: str, shard_idx: int, num_shards: int +) -> str: + orig_filename = filename + filename = filename.replace(".pt", suffix + ".pt") + fsdp_filename = filename[:-3] + f"-shard{shard_idx}.pt" + model_parallel_filename = orig_filename[:-3] + f"_part{shard_idx}.pt" + if PathManager.exists(fsdp_filename): + return fsdp_filename + elif num_shards > 1: + return model_parallel_filename + else: + return filename + + +def load_model_ensemble_and_task( + filenames, + arg_overrides: Optional[Dict[str, Any]] = None, + task=None, + strict=True, + suffix="", + num_shards=1, + state=None, +): + assert state is None or len(filenames) == 1 + + from fairseq import tasks + + assert not ( + strict and num_shards > 1 + ), "Cannot load state dict with strict=True and checkpoint shards > 1" + ensemble = [] + cfg = None + for filename in filenames: + orig_filename = filename + model_shard_state = {"shard_weights": [], "shard_metadata": []} + assert num_shards > 0 + st = time.time() + for shard_idx in range(num_shards): + filename = get_maybe_sharded_checkpoint_filename( + orig_filename, suffix, shard_idx, num_shards + ) + + if not PathManager.exists(filename): + raise IOError("Model file not found: {}".format(filename)) + if state is None: + state = load_checkpoint_to_cpu(filename, arg_overrides, strict=strict) + if "args" in state and state["args"] is not None: + + cfg = convert_namespace_to_omegaconf(state["args"]) + elif "cfg" in state and state["cfg"] is not None: + cfg = state["cfg"] + else: + raise RuntimeError( + f"Neither args nor cfg exist in state keys = {state.keys()}" + ) + print(cfg) + if task is None: + task = tasks.setup_task(cfg.task) + + if "task_state" in state: + task.load_state_dict(state["task_state"]) + + if "fsdp_metadata" in state and num_shards > 1: + model_shard_state["shard_weights"].append(state["model"]) + model_shard_state["shard_metadata"].append(state["fsdp_metadata"]) + # check FSDP import before the code goes too far + if not has_FSDP: + raise ImportError( + "Cannot find FullyShardedDataParallel. " + "Please install fairscale with: pip install fairscale" + ) + if shard_idx == num_shards - 1: + consolidated_model_state = FSDP.consolidate_shard_weights( + shard_weights=model_shard_state["shard_weights"], + shard_metadata=model_shard_state["shard_metadata"], + ) + model = task.build_model(cfg.model) + model.load_state_dict( + consolidated_model_state, strict=strict, model_cfg=cfg.model + ) + else: + # model parallel checkpoint or unsharded checkpoint + model = task.build_model(cfg.model) + + #### + delete_keys = [] # for audio encoder + for n,p in state["model"].items(): + if "logmel_extractor" in n: + delete_keys.append(n) + for k in delete_keys: + del state["model"][k] + print("delete ;", k) + msg = model.load_state_dict( + state["model"], strict=strict, model_cfg=cfg.model + ) + print(msg) + if "extra_state" in state: + print(state['extra_state'].get("best", None), state['extra_state'].get("train_iterator", None)) + # reset state so it gets loaded for the next model in ensemble + state = None + if shard_idx % 10 == 0 and shard_idx > 0: + elapsed = time.time() - st + logger.info( + f"Loaded {shard_idx} shards in {elapsed:.2f}s, {elapsed / (shard_idx+1):.2f}s/shard" + ) + + # build model for ensemble + ensemble.append(model) + + + return ensemble, cfg, task + + +def checkpoint_paths(path, pattern=r"checkpoint(\d+)\.pt", keep_match=False): + """Retrieves all checkpoints found in `path` directory. + + Checkpoints are identified by matching filename to the specified pattern. If + the pattern contains groups, the result will be sorted by the first group in + descending order. + """ + pt_regexp = re.compile(pattern) + files = PathManager.ls(path) + + entries = [] + for i, f in enumerate(files): + m = pt_regexp.fullmatch(f) + if m is not None: + idx = float(m.group(1)) if len(m.groups()) > 0 else i + entries.append((idx, m.group(0))) + if keep_match: + return [(os.path.join(path, x[1]), x[0]) for x in sorted(entries, reverse=True)] + else: + return [os.path.join(path, x[1]) for x in sorted(entries, reverse=True)] + + +def torch_persistent_save(obj, filename, async_write: bool = False): + if async_write: + with PathManager.opena(filename, "wb") as f: + _torch_persistent_save(obj, f) + else: + with PathManager.open(filename, "wb") as f: + _torch_persistent_save(obj, f) + # if PathManager.supports_rename(filename): + # # do atomic save + # with PathManager.open(filename + ".tmp", "wb") as f: + # _torch_persistent_save(obj, f) + # PathManager.rename(filename + ".tmp", filename) + # else: + # # fallback to non-atomic save + # with PathManager.open(filename, "wb") as f: + # _torch_persistent_save(obj, f) + + +def _torch_persistent_save(obj, f): + if isinstance(f, str): + with PathManager.open(f, "wb") as h: + torch_persistent_save(obj, h) + return + for i in range(3): + try: + return torch.save(obj, f) + except Exception: + if i == 2: + logger.error(traceback.format_exc()) + raise + + +def _upgrade_state_dict(state): + """Helper for upgrading old model checkpoints.""" + + # add optimizer_history + if "optimizer_history" not in state: + state["optimizer_history"] = [ + {"criterion_name": "CrossEntropyCriterion", "best_loss": state.get("best_loss", 0)} + ] + state["last_optimizer_state"] = state["optimizer"] + del state["optimizer"] + del state["best_loss"] + # move extra_state into sub-dictionary + if "epoch" in state and "extra_state" not in state: + state["extra_state"] = { + "epoch": state["epoch"], + "batch_offset": state["batch_offset"], + "val_loss": state["val_loss"], + } + del state["epoch"] + del state["batch_offset"] + del state["val_loss"] + # reduce optimizer history's memory usage (only keep the last state) + if "optimizer" in state["optimizer_history"][-1]: + state["last_optimizer_state"] = state["optimizer_history"][-1]["optimizer"] + for optim_hist in state["optimizer_history"]: + del optim_hist["optimizer"] + # record the optimizer class name + if "optimizer_name" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["optimizer_name"] = "FairseqNAG" + # move best_loss into lr_scheduler_state + if "lr_scheduler_state" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["lr_scheduler_state"] = { + "best": state["optimizer_history"][-1]["best_loss"] + } + del state["optimizer_history"][-1]["best_loss"] + # keep track of number of updates + if "num_updates" not in state["optimizer_history"][-1]: + state["optimizer_history"][-1]["num_updates"] = 0 + # old model checkpoints may not have separate source/target positions + if ( + "args" in state + and hasattr(state["args"], "max_positions") + and not hasattr(state["args"], "max_source_positions") + ): + state["args"].max_source_positions = state["args"].max_positions + state["args"].max_target_positions = state["args"].max_positions + # use stateful training data iterator + if "train_iterator" not in state["extra_state"]: + state["extra_state"]["train_iterator"] = { + "epoch": state["extra_state"]["epoch"], + "iterations_in_epoch": state["extra_state"].get("batch_offset", 0), + } + + # backward compatibility, cfg updates + if "args" in state and state["args"] is not None: + # default to translation task + if not hasattr(state["args"], "task"): + state["args"].task = "translation" + # --raw-text and --lazy-load are deprecated + if getattr(state["args"], "raw_text", False): + state["args"].dataset_impl = "raw" + elif getattr(state["args"], "lazy_load", False): + state["args"].dataset_impl = "lazy" + # epochs start at 1 + if state["extra_state"]["train_iterator"] is not None: + state["extra_state"]["train_iterator"]["epoch"] = max( + state["extra_state"]["train_iterator"].get("epoch", 1), 1 + ) + # --remove-bpe ==> --postprocess + if hasattr(state["args"], "remove_bpe"): + state["args"].post_process = state["args"].remove_bpe + # --min-lr ==> --stop-min-lr + if hasattr(state["args"], "min_lr"): + state["args"].stop_min_lr = state["args"].min_lr + del state["args"].min_lr + # binary_cross_entropy / kd_binary_cross_entropy => wav2vec criterion + if ( + hasattr(state["args"], "criterion") + and state["args"].criterion in [ + "binary_cross_entropy", + "kd_binary_cross_entropy", + ] + ): + state["args"].criterion = "wav2vec" + # remove log_keys if it's None (criteria will supply a default value of []) + if hasattr(state["args"], "log_keys") and state["args"].log_keys is None: + delattr(state["args"], "log_keys") + # speech_pretraining => audio pretraining + if ( + hasattr(state["args"], "task") + and state["args"].task == "speech_pretraining" + ): + state["args"].task = "audio_pretraining" + # audio_cpc => wav2vec + if hasattr(state["args"], "arch") and state["args"].arch == "audio_cpc": + state["args"].arch = "wav2vec" + # convert legacy float learning rate to List[float] + if hasattr(state["args"], "lr") and isinstance(state["args"].lr, float): + state["args"].lr = [state["args"].lr] + # convert task data arg to a string instead of List[string] + if ( + hasattr(state["args"], "data") + and isinstance(state["args"].data, list) + and len(state["args"].data) > 0 + ): + state["args"].data = state["args"].data[0] + # remove keys in state["args"] related to teacher-student learning + for key in [ + "static_teachers", + "static_teacher_weights", + "dynamic_teachers", + "dynamic_teacher_weights", + ]: + if key in state["args"]: + delattr(state["args"], key) + + state["cfg"] = convert_namespace_to_omegaconf(state["args"]) + + if "cfg" in state and state["cfg"] is not None: + cfg = state["cfg"] + with open_dict(cfg): + # any upgrades for Hydra-based configs + if ( + "task" in cfg + and "eval_wer_config" in cfg.task + and isinstance(cfg.task.eval_wer_config.print_alignment, bool) + ): + cfg.task.eval_wer_config.print_alignment = "hard" + if "generation" in cfg and isinstance(cfg.generation.print_alignment, bool): + cfg.generation.print_alignment = "hard" if cfg.generation.print_alignment else None + if ( + "model" in cfg + and "w2v_args" in cfg.model + and cfg.model.w2v_args is not None + and ( + hasattr(cfg.model.w2v_args, "task") or "task" in cfg.model.w2v_args + ) + and hasattr(cfg.model.w2v_args.task, "eval_wer_config") + and cfg.model.w2v_args.task.eval_wer_config is not None + and isinstance( + cfg.model.w2v_args.task.eval_wer_config.print_alignment, bool + ) + ): + cfg.model.w2v_args.task.eval_wer_config.print_alignment = "hard" + + return state + + +def prune_state_dict(state_dict, model_cfg: Optional[DictConfig]): + """Prune the given state_dict if desired for LayerDrop + (https://arxiv.org/abs/1909.11556). + + Training with LayerDrop allows models to be robust to pruning at inference + time. This function prunes state_dict to allow smaller models to be loaded + from a larger model and re-maps the existing state_dict for this to occur. + + It's called by functions that load models from checkpoints and does not + need to be called directly. + """ + arch = None + if model_cfg is not None: + arch = ( + model_cfg._name + if isinstance(model_cfg, DictConfig) + else getattr(model_cfg, "arch", None) + ) + + if not model_cfg or arch is None or arch == "ptt_transformer": + # args should not be none, but don't crash if it is. + return state_dict + + encoder_layers_to_keep = getattr(model_cfg, "encoder_layers_to_keep", None) + decoder_layers_to_keep = getattr(model_cfg, "decoder_layers_to_keep", None) + + if not encoder_layers_to_keep and not decoder_layers_to_keep: + return state_dict + + # apply pruning + logger.info( + "Pruning model to specified layer configuration - this works best if the model was trained with LayerDrop" + ) + + def create_pruning_pass(layers_to_keep, layer_name): + keep_layers = sorted( + int(layer_string) for layer_string in layers_to_keep.split(",") + ) + mapping_dict = {} + for i in range(len(keep_layers)): + mapping_dict[str(keep_layers[i])] = str(i) + + regex = re.compile(r"^{layer}.*\.layers\.(\d+)".format(layer=layer_name)) + return {"substitution_regex": regex, "mapping_dict": mapping_dict} + + pruning_passes = [] + if encoder_layers_to_keep: + pruning_passes.append(create_pruning_pass(encoder_layers_to_keep, "encoder")) + if decoder_layers_to_keep: + pruning_passes.append(create_pruning_pass(decoder_layers_to_keep, "decoder")) + + new_state_dict = {} + for layer_name in state_dict.keys(): + match = re.search(r"\.layers\.(\d+)\.", layer_name) + # if layer has no number in it, it is a supporting layer, such as an + # embedding + if not match: + new_state_dict[layer_name] = state_dict[layer_name] + continue + + # otherwise, layer should be pruned. + original_layer_number = match.group(1) + # figure out which mapping dict to replace from + for pruning_pass in pruning_passes: + if original_layer_number in pruning_pass["mapping_dict"] and pruning_pass[ + "substitution_regex" + ].search(layer_name): + new_layer_number = pruning_pass["mapping_dict"][original_layer_number] + substitution_match = pruning_pass["substitution_regex"].search( + layer_name + ) + new_state_key = ( + layer_name[: substitution_match.start(1)] + + new_layer_number + + layer_name[substitution_match.end(1) :] + ) + new_state_dict[new_state_key] = state_dict[layer_name] + + # Since layers are now pruned, *_layers_to_keep are no longer needed. + # This is more of "It would make it work fix" rather than a proper fix. + if isinstance(model_cfg, DictConfig): + context = open_dict(model_cfg) + else: + context = contextlib.ExitStack() + with context: + if hasattr(model_cfg, "encoder_layers_to_keep"): + model_cfg.encoder_layers_to_keep = None + if hasattr(model_cfg, "decoder_layers_to_keep"): + model_cfg.decoder_layers_to_keep = None + + return new_state_dict + + +def load_pretrained_component_from_model( + component: Union[FairseqEncoder, FairseqDecoder], checkpoint: str +): + """ + Load a pretrained FairseqEncoder or FairseqDecoder from checkpoint into the + provided `component` object. If state_dict fails to load, there may be a + mismatch in the architecture of the corresponding `component` found in the + `checkpoint` file. + """ + if not PathManager.exists(checkpoint): + raise IOError("Model file not found: {}".format(checkpoint)) + state = load_checkpoint_to_cpu(checkpoint) + if isinstance(component, FairseqEncoder): + component_type = "encoder" + elif isinstance(component, FairseqDecoder): + component_type = "decoder" + else: + raise ValueError( + "component to load must be either a FairseqEncoder or " + "FairseqDecoder. Loading other component types are not supported." + ) + component_state_dict = OrderedDict() + for key in state["model"].keys(): + if key.startswith(component_type): + # encoder.input_layers.0.0.weight --> input_layers.0.0.weight + component_subkey = key[len(component_type) + 1 :] + component_state_dict[component_subkey] = state["model"][key] + component.load_state_dict(component_state_dict, strict=True) + return component + + +def verify_checkpoint_directory(save_dir: str) -> None: + if not os.path.exists(save_dir): + os.makedirs(save_dir, exist_ok=True) + temp_file_path = os.path.join(save_dir, "dummy") + try: + with open(temp_file_path, "w"): + pass + except OSError as e: + logger.warning( + "Unable to access checkpoint save directory: {}".format(save_dir) + ) + raise e + else: + os.remove(temp_file_path) + + +def load_ema_from_checkpoint(fpath): + """Loads exponential moving averaged (EMA) checkpoint from input and + returns a model with ema weights. + + Args: + fpath: A string path of checkpoint to load from. + + Returns: + A dict of string keys mapping to various values. The 'model' key + from the returned dict should correspond to an OrderedDict mapping + string parameter names to torch Tensors. + """ + params_dict = collections.OrderedDict() + new_state = None + + with PathManager.open(fpath, 'rb') as f: + new_state = torch.load( + f, + map_location=( + lambda s, _: torch.serialization.default_restore_location(s, 'cpu') + ), + ) + + # EMA model is stored in a separate "extra state" + model_params = new_state['extra_state']['ema'] + + for key in list(model_params.keys()): + p = model_params[key] + if isinstance(p, torch.HalfTensor): + p = p.float() + if key not in params_dict: + params_dict[key] = p.clone() + # NOTE: clone() is needed in case of p is a shared parameter + else: + raise ValueError("Key {} is repeated in EMA model params.".format(key)) + + if len(params_dict) == 0: + raise ValueError( + f"Input checkpoint path '{fpath}' does not contain " + "ema model weights, is this model trained with EMA?" + ) + + new_state['model'] = params_dict + return new_state diff --git a/utils/cider/pyciderevalcap/__init__.py b/utils/cider/pyciderevalcap/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..3f7d85bba884ea8f83fc6ab2a1e6ade80d98d4d9 --- /dev/null +++ b/utils/cider/pyciderevalcap/__init__.py @@ -0,0 +1 @@ +__author__ = 'tylin' diff --git a/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-37.pyc b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be6e7ba91b19557cfc28676a32fd9bb94fbfd9df Binary files /dev/null and b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-37.pyc differ diff --git a/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-38.pyc b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fde262e9ae7a38bb476988a34e07d1770afb240 Binary files /dev/null and b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-38.pyc differ diff --git a/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-39.pyc b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d58be2027d437cdb203c2bb5ae0957462caaef4d Binary files /dev/null and b/utils/cider/pyciderevalcap/__pycache__/__init__.cpython-39.pyc differ diff --git a/utils/cider/pyciderevalcap/cider/__init__.py b/utils/cider/pyciderevalcap/cider/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..3f7d85bba884ea8f83fc6ab2a1e6ade80d98d4d9 --- /dev/null +++ b/utils/cider/pyciderevalcap/cider/__init__.py @@ -0,0 +1 @@ +__author__ = 'tylin' diff --git a/utils/cider/pyciderevalcap/cider/cider.py b/utils/cider/pyciderevalcap/cider/cider.py new file mode 100755 index 0000000000000000000000000000000000000000..5b65978370cb82dd2111500e7f05c4d05306162c --- /dev/null +++ b/utils/cider/pyciderevalcap/cider/cider.py @@ -0,0 +1,65 @@ +# Filename: cider.py +# +# +# Description: Describes the class to compute the CIDEr +# (Consensus-Based Image Description Evaluation) Metric +# by Vedantam, Zitnick, and Parikh (http://arxiv.org/abs/1411.5726) +# +# Creation Date: Sun Feb 8 14:16:54 2015 +# +# Authors: Ramakrishna Vedantam <vrama91@vt.edu> and +# Tsung-Yi Lin <tl483@cornell.edu> +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from .cider_scorer import CiderScorer + + +class Cider: + """ + Main Class to compute the CIDEr metric + + """ + def __init__(self, n=4, df="corpus"): + """ + Initialize the CIDEr scoring function + : param n (int): n-gram size + : param df (string): specifies where to get the IDF values from + takes values 'corpus', 'coco-train' + : return: None + """ + # set cider to sum over 1 to 4-grams + self._n = n + self._df = df + self.cider_scorer = CiderScorer(n=self._n, df_mode=self._df) + + def compute_score(self, gts, res): + """ + Main function to compute CIDEr score + : param gts (dict) : {image:tokenized reference sentence} + : param res (dict) : {image:tokenized candidate sentence} + : return: cider (float) : computed CIDEr score for the corpus + """ + + # clear all the previous hypos and refs + self.cider_scorer.clear() + + for res_id in res: + + hypo = res_id['caption'] + ref = gts[res_id['image_id']] + + # Sanity check. + assert(type(hypo) is list) + assert(len(hypo) == 1) + assert(type(ref) is list) + assert(len(ref) > 0) + self.cider_scorer += (hypo[0], ref) + + (score, scores) = self.cider_scorer.compute_score() + + return score, scores + + def method(self): + return "CIDEr" diff --git a/utils/cider/pyciderevalcap/cider/cider_scorer.py b/utils/cider/pyciderevalcap/cider/cider_scorer.py new file mode 100755 index 0000000000000000000000000000000000000000..d7f9505916f2210617cc529bf3c05acfa06d5a62 --- /dev/null +++ b/utils/cider/pyciderevalcap/cider/cider_scorer.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python +# Tsung-Yi Lin <tl483@cornell.edu> +# Ramakrishna Vedantam <vrama91@vt.edu> +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import copy +import six +from six.moves import cPickle +from collections import defaultdict +import numpy as np +import math +import os + +def precook(s, n=4, out=False): + """ + Takes a string as input and returns an object that can be given to + either cook_refs or cook_test. This is optional: cook_refs and cook_test + can take string arguments as well. + :param s: string : sentence to be converted into ngrams + :param n: int : number of ngrams for which representation is calculated + :return: term frequency vector for occuring ngrams + """ + words = s.split() + counts = defaultdict(int) + for k in range(1,n+1): + for i in range(len(words)-k+1): + ngram = tuple(words[i:i+k]) + counts[ngram] += 1 + return counts + +def cook_refs(refs, n=4): ## lhuang: oracle will call with "average" + '''Takes a list of reference sentences for a single segment + and returns an object that encapsulates everything that BLEU + needs to know about them. + :param refs: list of string : reference sentences for some image + :param n: int : number of ngrams for which (ngram) representation is calculated + :return: result (list of dict) + ''' + return [precook(ref, n) for ref in refs] + +def cook_test(test, n=4): + '''Takes a test sentence and returns an object that + encapsulates everything that BLEU needs to know about it. + :param test: list of string : hypothesis sentence for some image + :param n: int : number of ngrams for which (ngram) representation is calculated + :return: result (dict) + ''' + return precook(test, n, True) + +class CiderScorer(object): + """CIDEr scorer. + """ + + def copy(self): + ''' copy the refs.''' + new = CiderScorer(n=self.n) + new.ctest = copy.copy(self.ctest) + new.crefs = copy.copy(self.crefs) + return new + + def __init__(self, df_mode="corpus", test=None, refs=None, n=4, sigma=6.0): + ''' singular instance ''' + self.n = n + self.sigma = sigma + self.crefs = [] + self.ctest = [] + self.df_mode = df_mode + self.ref_len = None + if self.df_mode != "corpus": + pkl_file = cPickle.load(open(os.path.join('data', df_mode + '.p'),'rb'), **(dict(encoding='latin1') if six.PY3 else {})) + self.ref_len = np.log(float(pkl_file['ref_len'])) + self.document_frequency = pkl_file['document_frequency'] + self.cook_append(test, refs) + + def clear(self): + self.crefs = [] + self.ctest = [] + + def cook_append(self, test, refs): + '''called by constructor and __iadd__ to avoid creating new instances.''' + + if refs is not None: + self.crefs.append(cook_refs(refs)) + if test is not None: + self.ctest.append(cook_test(test)) ## N.B.: -1 + else: + self.ctest.append(None) # lens of crefs and ctest have to match + + def size(self): + assert len(self.crefs) == len(self.ctest), "refs/test mismatch! %d<>%d" % (len(self.crefs), len(self.ctest)) + return len(self.crefs) + + def __iadd__(self, other): + '''add an instance (e.g., from another sentence).''' + + if type(other) is tuple: + ## avoid creating new CiderScorer instances + self.cook_append(other[0], other[1]) + else: + self.ctest.extend(other.ctest) + self.crefs.extend(other.crefs) + + return self + def compute_doc_freq(self): + ''' + Compute term frequency for reference data. + This will be used to compute idf (inverse document frequency later) + The term frequency is stored in the object + :return: None + ''' + for refs in self.crefs: + # refs, k ref captions of one image + for ngram in set([ngram for ref in refs for (ngram,count) in ref.items()]): + self.document_frequency[ngram] += 1 + # maxcounts[ngram] = max(maxcounts.get(ngram,0), count) + + def compute_cider(self): + def counts2vec(cnts): + """ + Function maps counts of ngram to vector of tfidf weights. + The function returns vec, an array of dictionary that store mapping of n-gram and tf-idf weights. + The n-th entry of array denotes length of n-grams. + :param cnts: + :return: vec (array of dict), norm (array of float), length (int) + """ + vec = [defaultdict(float) for _ in range(self.n)] + length = 0 + norm = [0.0 for _ in range(self.n)] + for (ngram,term_freq) in cnts.items(): + # give word count 1 if it doesn't appear in reference corpus + df = np.log(max(1.0, self.document_frequency[ngram])) + # ngram index + n = len(ngram)-1 + # tf (term_freq) * idf (precomputed idf) for n-grams + vec[n][ngram] = float(term_freq)*(self.ref_len - df) + # compute norm for the vector. the norm will be used for + # computing similarity + norm[n] += pow(vec[n][ngram], 2) + + if n == 1: + length += term_freq + norm = [np.sqrt(n) for n in norm] + return vec, norm, length + + def sim(vec_hyp, vec_ref, norm_hyp, norm_ref, length_hyp, length_ref): + ''' + Compute the cosine similarity of two vectors. + :param vec_hyp: array of dictionary for vector corresponding to hypothesis + :param vec_ref: array of dictionary for vector corresponding to reference + :param norm_hyp: array of float for vector corresponding to hypothesis + :param norm_ref: array of float for vector corresponding to reference + :param length_hyp: int containing length of hypothesis + :param length_ref: int containing length of reference + :return: array of score for each n-grams cosine similarity + ''' + delta = float(length_hyp - length_ref) + # measure consine similarity + val = np.array([0.0 for _ in range(self.n)]) + for n in range(self.n): + # ngram + for (ngram,count) in vec_hyp[n].items(): + val[n] += vec_hyp[n][ngram] * vec_ref[n][ngram] + + if (norm_hyp[n] != 0) and (norm_ref[n] != 0): + val[n] /= (norm_hyp[n]*norm_ref[n]) + + assert(not math.isnan(val[n])) + return val + + # compute log reference length + if self.df_mode == "corpus": + self.ref_len = np.log(float(len(self.crefs))) + + scores = [] + for test, refs in zip(self.ctest, self.crefs): + # compute vector for test captions + vec, norm, length = counts2vec(test) + # compute vector for ref captions + score = np.array([0.0 for _ in range(self.n)]) + for ref in refs: + vec_ref, norm_ref, length_ref = counts2vec(ref) + score += sim(vec, vec_ref, norm, norm_ref, length, length_ref) + # change by vrama91 - mean of ngram scores, instead of sum + score_avg = np.mean(score) + # divide by number of references + score_avg /= len(refs) + # multiply score by 10 + score_avg *= 10.0 + # append score of an image to the score list + scores.append(score_avg) + return scores + + def compute_score(self, option=None, verbose=0): + # compute idf + if self.df_mode == "corpus": + self.document_frequency = defaultdict(float) + self.compute_doc_freq() + # assert to check document frequency + assert(len(self.ctest) >= max(self.document_frequency.values())) + # import json for now and write the corresponding files + # compute cider score + score = self.compute_cider() + # debug + # print score + return np.mean(np.array(score)), np.array(score) diff --git a/utils/cider/pyciderevalcap/ciderD/__init__.py b/utils/cider/pyciderevalcap/ciderD/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..3f7d85bba884ea8f83fc6ab2a1e6ade80d98d4d9 --- /dev/null +++ b/utils/cider/pyciderevalcap/ciderD/__init__.py @@ -0,0 +1 @@ +__author__ = 'tylin' diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-37.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e77be48c9e1103c85ba8341788b7cad4e0cf8f48 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-37.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-38.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e172ec786b137557912cdc7f3fc27450db5ec93 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-38.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-39.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d555463a4d09ad9d7bdb77cd1525b4a895acae8 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/__init__.cpython-39.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-37.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..665b48e5e70e30f640662f1c29cf1a5032d32133 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-37.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-38.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a92a7a841b199f980423751c0928a7fc768bb98 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-38.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-39.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be20d7d8c4784ae2005245d24e582e5ee11accc7 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD.cpython-39.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-37.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfa714c1113ddab8f6697af91b891f415359ab1d Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-37.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-38.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c37697e5c4715a189716d1f51d0a981eb62c47c Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-38.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-39.pyc b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2003d5795f036c69a7cf4e8480ee34a2337b4a44 Binary files /dev/null and b/utils/cider/pyciderevalcap/ciderD/__pycache__/ciderD_scorer.cpython-39.pyc differ diff --git a/utils/cider/pyciderevalcap/ciderD/ciderD.py b/utils/cider/pyciderevalcap/ciderD/ciderD.py new file mode 100755 index 0000000000000000000000000000000000000000..a515b56cf116fefc9172be00c3b2a0575ad634ad --- /dev/null +++ b/utils/cider/pyciderevalcap/ciderD/ciderD.py @@ -0,0 +1,58 @@ +# Filename: ciderD.py +# +# Description: Describes the class to compute the CIDEr-D (Consensus-Based Image Description Evaluation) Metric +# by Vedantam, Zitnick, and Parikh (http://arxiv.org/abs/1411.5726) +# +# Creation Date: Sun Feb 8 14:16:54 2015 +# +# Authors: Ramakrishna Vedantam <vrama91@vt.edu> and Tsung-Yi Lin <tl483@cornell.edu> +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from .ciderD_scorer import CiderScorer +import pdb + +class CiderD: + """ + Main Class to compute the CIDEr metric + + """ + def __init__(self, n=4, sigma=6.0, df="corpus"): + # set cider to sum over 1 to 4-grams + self._n = n + # set the standard deviation parameter for gaussian penalty + self._sigma = sigma + # set which where to compute document frequencies from + self._df = df + self.cider_scorer = CiderScorer(n=self._n, df_mode=self._df) + + def compute_score(self, gts, res): + """ + Main function to compute CIDEr score + :param hypo_for_image (dict) : dictionary with key <image> and value <tokenized hypothesis / candidate sentence> + ref_for_image (dict) : dictionary with key <image> and value <tokenized reference sentence> + :return: cider (float) : computed CIDEr score for the corpus + """ + + # clear all the previous hypos and refs + tmp_cider_scorer = self.cider_scorer.copy_empty() + tmp_cider_scorer.clear() + for res_id in res: + + hypo = res_id['caption'] + ref = gts[res_id['image_id']] + # print("hypo:", hypo, "ref", ref) + # Sanity check. + assert(type(hypo) is list) + assert(len(hypo) == 1) + assert(type(ref) is list) + assert(len(ref) > 0) + tmp_cider_scorer += (hypo[0], ref) + + (score, scores) = tmp_cider_scorer.compute_score() + + return score, scores + + def method(self): + return "CIDEr-D" diff --git a/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py b/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py new file mode 100755 index 0000000000000000000000000000000000000000..144f58350322bcae42e152300778f491908a1576 --- /dev/null +++ b/utils/cider/pyciderevalcap/ciderD/ciderD_scorer.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python +# Tsung-Yi Lin <tl483@cornell.edu> +# Ramakrishna Vedantam <vrama91@vt.edu> +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import copy +from collections import defaultdict +import numpy as np +import pdb +import math +import six +from six.moves import cPickle +import os + +def precook(s, n=4, out=False): + """ + Takes a string as input and returns an object that can be given to + either cook_refs or cook_test. This is optional: cook_refs and cook_test + can take string arguments as well. + :param s: string : sentence to be converted into ngrams + :param n: int : number of ngrams for which representation is calculated + :return: term frequency vector for occuring ngrams + """ + words = s.split() + counts = defaultdict(int) + for k in range(1,n+1): + for i in range(len(words)-k+1): + ngram = tuple(words[i:i+k]) + counts[ngram] += 1 + return counts + +def cook_refs(refs, n=4): ## lhuang: oracle will call with "average" + '''Takes a list of reference sentences for a single segment + and returns an object that encapsulates everything that BLEU + needs to know about them. + :param refs: list of string : reference sentences for some image + :param n: int : number of ngrams for which (ngram) representation is calculated + :return: result (list of dict) + ''' + return [precook(ref, n) for ref in refs] + +def cook_test(test, n=4): + '''Takes a test sentence and returns an object that + encapsulates everything that BLEU needs to know about it. + :param test: list of string : hypothesis sentence for some image + :param n: int : number of ngrams for which (ngram) representation is calculated + :return: result (dict) + ''' + return precook(test, n, True) + +class CiderScorer(object): + """CIDEr scorer. + """ + + def copy(self): + ''' copy the refs.''' + new = CiderScorer(n=self.n) + new.ctest = copy.copy(self.ctest) + new.crefs = copy.copy(self.crefs) + return new + + def copy_empty(self): + new = CiderScorer(df_mode="corpus", n=self.n, sigma=self.sigma) + new.df_mode = self.df_mode + new.ref_len = self.ref_len + new.document_frequency = self.document_frequency + return new + + def __init__(self, df_mode="corpus", test=None, refs=None, n=4, sigma=6.0): + ''' singular instance ''' + self.n = n + self.sigma = sigma + self.crefs = [] + self.ctest = [] + self.df_mode = df_mode + self.ref_len = None + if self.df_mode != "corpus": + pkl_file = cPickle.load(open(df_mode,'rb'), **(dict(encoding='latin1') if six.PY3 else {})) + self.ref_len = np.log(float(pkl_file['ref_len'])) + self.document_frequency = pkl_file['document_frequency'] + else: + self.document_frequency = None + self.cook_append(test, refs) + + def clear(self): + self.crefs = [] + self.ctest = [] + + def cook_append(self, test, refs): + '''called by constructor and __iadd__ to avoid creating new instances.''' + + if refs is not None: + self.crefs.append(cook_refs(refs)) + if test is not None: + self.ctest.append(cook_test(test)) ## N.B.: -1 + else: + self.ctest.append(None) # lens of crefs and ctest have to match + + def size(self): + assert len(self.crefs) == len(self.ctest), "refs/test mismatch! %d<>%d" % (len(self.crefs), len(self.ctest)) + return len(self.crefs) + + def __iadd__(self, other): + '''add an instance (e.g., from another sentence).''' + + if type(other) is tuple: + ## avoid creating new CiderScorer instances + self.cook_append(other[0], other[1]) + else: + self.ctest.extend(other.ctest) + self.crefs.extend(other.crefs) + + return self + def compute_doc_freq(self): + ''' + Compute term frequency for reference data. + This will be used to compute idf (inverse document frequency later) + The term frequency is stored in the object + :return: None + ''' + for refs in self.crefs: + # refs, k ref captions of one image + for ngram in set([ngram for ref in refs for (ngram,count) in ref.items()]): + self.document_frequency[ngram] += 1 + # maxcounts[ngram] = max(maxcounts.get(ngram,0), count) + + def compute_cider(self): + def counts2vec(cnts): + """ + Function maps counts of ngram to vector of tfidf weights. + The function returns vec, an array of dictionary that store mapping of n-gram and tf-idf weights. + The n-th entry of array denotes length of n-grams. + :param cnts: + :return: vec (array of dict), norm (array of float), length (int) + """ + vec = [defaultdict(float) for _ in range(self.n)] + length = 0 + norm = [0.0 for _ in range(self.n)] + for (ngram,term_freq) in cnts.items(): + # give word count 1 if it doesn't appear in reference corpus + df = np.log(max(1.0, self.document_frequency[ngram])) + # ngram index + n = len(ngram)-1 + # tf (term_freq) * idf (precomputed idf) for n-grams + vec[n][ngram] = float(term_freq)*(self.ref_len - df) + # compute norm for the vector. the norm will be used for computing similarity + norm[n] += pow(vec[n][ngram], 2) + + if n == 1: + length += term_freq + norm = [np.sqrt(n) for n in norm] + return vec, norm, length + + def sim(vec_hyp, vec_ref, norm_hyp, norm_ref, length_hyp, length_ref): + ''' + Compute the cosine similarity of two vectors. + :param vec_hyp: array of dictionary for vector corresponding to hypothesis + :param vec_ref: array of dictionary for vector corresponding to reference + :param norm_hyp: array of float for vector corresponding to hypothesis + :param norm_ref: array of float for vector corresponding to reference + :param length_hyp: int containing length of hypothesis + :param length_ref: int containing length of reference + :return: array of score for each n-grams cosine similarity + ''' + delta = float(length_hyp - length_ref) + # measure consine similarity + val = np.array([0.0 for _ in range(self.n)]) + for n in range(self.n): + # ngram + for (ngram,count) in vec_hyp[n].items(): + # vrama91 : added clipping + val[n] += min(vec_hyp[n][ngram], vec_ref[n][ngram]) * vec_ref[n][ngram] + + if (norm_hyp[n] != 0) and (norm_ref[n] != 0): + val[n] /= (norm_hyp[n]*norm_ref[n]) + + assert(not math.isnan(val[n])) + # vrama91: added a length based gaussian penalty + val[n] *= np.e**(-(delta**2)/(2*self.sigma**2)) + return val + + # compute log reference length + if self.df_mode == "corpus": + self.ref_len = np.log(float(len(self.crefs))) + #elif self.df_mode == "coco-val-df": + # if coco option selected, use length of coco-val set + # self.ref_len = np.log(float(40504)) + + scores = [] + for test, refs in zip(self.ctest, self.crefs): + # compute vector for test captions + vec, norm, length = counts2vec(test) + # compute vector for ref captions + score = np.array([0.0 for _ in range(self.n)]) + for ref in refs: + vec_ref, norm_ref, length_ref = counts2vec(ref) + score += sim(vec, vec_ref, norm, norm_ref, length, length_ref) + # change by vrama91 - mean of ngram scores, instead of sum + score_avg = np.mean(score) + # divide by number of references + score_avg /= len(refs) + # multiply score by 10 + score_avg *= 10.0 + # append score of an image to the score list + scores.append(score_avg) + return scores + + def compute_score(self, option=None, verbose=0): + # compute idf + if self.df_mode == "corpus": + self.document_frequency = defaultdict(float) + self.compute_doc_freq() + # assert to check document frequency + assert(len(self.ctest) >= max(self.document_frequency.values())) + # import json for now and write the corresponding files + # compute cider score + score = self.compute_cider() + # debug + # print score + return np.mean(np.array(score)), np.array(score) diff --git a/utils/eval_utils.py b/utils/eval_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a8256b8fb774995cd7ff0d60162b3ed1a0ffa11e --- /dev/null +++ b/utils/eval_utils.py @@ -0,0 +1,394 @@ +# Modified from OFA code. +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import string +import math +import json +from itertools import chain +import os + +import torch +import torch.distributed as dist + +from data import data_utils + + + +from functools import partial + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.bos, generator.eos} + + +def decode_fn(x, tgt_dict, bpe, generator, tokenizer=None): + x = tgt_dict.string(x.int().cpu(), extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator)) + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + +def eval_caption(task, generator, models, sample, **kwargs): + transtab = str.maketrans({key: None for key in string.punctuation}) + hypos = task.inference_step(generator, models, sample) + results = [] + for i, sample_id in enumerate(sample["id"].tolist()): + detok_hypo_str = decode_fn(hypos[i][0]["tokens"], task.tgt_dict, task.bpe, generator) + results.append({"image_id": str(sample_id), "caption": detok_hypo_str.translate(transtab).strip()}) + return results, None + + +def eval_vqa_gen(task, generator, models, sample, **kwargs): + if kwargs['beam_search_vqa_eval']: + hypos = task.inference_step(generator, models, sample, prefix_tokens=sample['prefix_tokens']) + results = [] + for i, sample_id in enumerate(sample["id"].tolist()): + prefix_len = sample['prefix_tokens'][i].ne(1).sum().item() + detok_hypo_str = decode_fn(hypos[i][0]["tokens"][prefix_len:], task.tgt_dict, task.bpe, generator) + results.append({"question_id": int(sample_id), "answer": detok_hypo_str.strip()}) + scores = [ref_dict.get(result['answer'], 0) for ref_dict, result in zip(sample['ref_dict'], results)] + return results, scores + + encoder_out = models[0].encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"] + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([task.src_dict.eos()]) + pad = task.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(task.valid_answers_list, task.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat( + [torch.zeros(len(decoder_prompt) - 1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], + dim=0 + ) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = models[0].decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = models[0].get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(task.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [task.index2ans[predict_index] for predict_index in predicts] + results = [{"question_id": int(id), "answer": hyp} for id, hyp in zip(sample["id"].tolist(), hyps)] + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + return results, scores + + +def eval_refcoco(task, generator, models, sample, **kwargs): + + def _calculate_ap_score(hyps, refs, thresh=0.5, min_area_size=None, max_area_size=None): + interacts = torch.cat( + [torch.where(hyps[:, :2] < refs[:, :2], refs[:, :2], hyps[:, :2]), + torch.where(hyps[:, 2:] < refs[:, 2:], hyps[:, 2:], refs[:, 2:])], + dim=1 + ) + area_predictions = (hyps[:, 2] - hyps[:, 0]) * (hyps[:, 3] - hyps[:, 1]) + area_targets = (refs[:, 2] - refs[:, 0]) * (refs[:, 3] - refs[:, 1]) + interacts_w = interacts[:, 2] - interacts[:, 0] + interacts_h = interacts[:, 3] - interacts[:, 1] + area_interacts = interacts_w * interacts_h + ious = area_interacts / (area_predictions + area_targets - area_interacts + 1e-6) + + + + if max_area_size is not None and min_area_size is not None: + + ious = ious * (area_targets > max_area_size).float() * (area_targets < min_area_size).float() + elif min_area_size is not None: + ious = ious * (area_targets > min_area_size).float() + + elif max_area_size is not None: + ious = ious * (area_targets < max_area_size).float() + + + + if thresh is None: + return ious + else: + return ((ious >= thresh) & (interacts_w > 0) & (interacts_h > 0)).float() + + + + + gen_out = task.inference_step(generator, models, sample) + hyps_ = [] + + refs_ = [] + for i in range(len(gen_out)): + hyps_.append(gen_out[i][0]["tokens"][:-1] - len(task.src_dict) + task.cfg.num_bins) + refs_.append(sample["target"][i][:-1] - len(task.src_dict) + task.cfg.num_bins) + + refs_ = torch.stack(refs_, dim=0) + hyps_ = torch.stack(hyps_, dim=0) + + hyps = hyps_ / (task.cfg.num_bins - 1) * task.cfg.max_image_size + hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + + results = [ + {"uniq_id": sample_id, + "box": [hyps[i][0].item(), hyps[i][1].item(), hyps[i][2].item(), hyps[i][3].item()]} + for i, sample_id in enumerate(sample["id"].tolist()) + ] + + scores_list = [] + names = [] + evaluate_cfg = kwargs['evaluate_cfg'] # task.cfg + + threshs = evaluate_cfg.acc_thresh + if threshs is not None: + if ',' in threshs: + threshs = threshs.split(',') + + if not isinstance(threshs, list): + threshs = [threshs] + + threshs = [float(t) for t in threshs] + + for thresh in threshs: + scores = _calculate_ap_score(hyps, sample['region_coords'].float(), thresh=thresh) + names.append(str(thresh)+'acc') + scores_list.append(scores) + if evaluate_cfg.min_area_size is not None: + large_scores = _calculate_ap_score(hyps, sample['region_coords'].float(), thresh=thresh, + min_area_size=evaluate_cfg.min_area_size) + scores_list.append(large_scores) + names.append(str(thresh)+'large_acc') + + if evaluate_cfg.max_area_size is not None: + small_scores = _calculate_ap_score(hyps, sample['region_coords'].float(), thresh=thresh, + max_area_size=evaluate_cfg.max_area_size) + scores_list.append(small_scores) + names.append(str(thresh)+'small_acc') + + if evaluate_cfg.max_area_size is not None and evaluate_cfg.min_area_size is not None: + medium_scores = _calculate_ap_score(hyps, sample['region_coords'].float(), thresh=thresh, + max_area_size=evaluate_cfg.max_area_size, min_area_size=evaluate_cfg.min_area_size) + scores_list.append(medium_scores) + names.append(str(thresh)+'medium_acc') + + + + + + if len(scores_list) > 0: + scores = scores_list #[scores] + scores_list + results = [names, results] + return results, scores + + +def eval_snli_ve(task, generator, models, sample, **kwargs): + encoder_out = models[0].encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"] + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([task.src_dict.eos()]) + pad = task.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(task.valid_answers_list, task.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat( + [torch.zeros(len(decoder_prompt) - 1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], + dim=0 + ) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = models[0].decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = models[0].get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(task.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [task.index2ans[predict_index] for predict_index in predicts] + results = [{"uniq_id": id, "answer": hyp} for id, hyp in zip(sample["id"].tolist(), hyps)] + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + return results, scores + + +def eval_image_gen(task, generator, models, sample, **kwargs): + hypos, _ = task.inference_image(generator, sample, models) + tokens = sample['net_input']['src_tokens'][0].view(-1).tolist() + caption = task.bpe.decode(task.tgt_dict.string([token for token in tokens if token >= 4]))[ + 38:].replace('/', '') + + text_similarity_score, indices = task.compute_text_similarity(hypos, caption, + sample['net_input']['src_tokens'].device) + results = [] + for i, indice in enumerate(indices): + results.append({"sample_id": str(sample["id"][0]), "score": text_similarity_score[i], "image": hypos[indice]}) + scores = [max(text_similarity_score).item()] + sorted_hyps = [hypos[indice] for indice in indices] + # dump results + if task.cfg.gen_images_path: + caption_tokens = sample['net_input']['src_tokens'][0].view(-1).tolist() + caption = task.bpe.decode(task.tgt_dict.string([token for token in caption_tokens if token >= 4]))[ + 38:].replace('/', '') + task.dump_images(sorted_hyps, text=caption, path=os.path.join(task.cfg.gen_images_path, 'all_results')) + task.dump_images(sorted_hyps, text=caption, path=os.path.join(task.cfg.gen_images_path, 'top1'), topk=1) + + return results, scores + + + + + + +def eval_image_classify(task, generator, models, sample, **kwargs): + batch_size = sample["net_input"]["src_tokens"].size(0) + encoder_out = models[0].encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"] + ) + device = sample["net_input"]["src_tokens"].device + valid_result = [] + for valid_tgt, valid_prev_output, valid_constraint_masks in zip(task.valid_tgt_list, + task.valid_prev_output_list, + task.valid_constraint_masks_list): + valid_tgt_size = valid_tgt.size(0) + valid_tgt = valid_tgt.repeat(batch_size, 1).to(device) + valid_prev_output = valid_prev_output.repeat(batch_size, 1).to(device) + valid_constraint_masks = valid_constraint_masks.repeat(batch_size, 1, 1).to(device) + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_tgt_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_tgt_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_tgt_size, dim=0) + ] + + decoder_out = models[0].decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = models[0].get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(task.tgt_dict.pad()), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_tgt_size) + valid_result.append(scores) + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [task.index2ans[predict_index] for predict_index in predicts] + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + results = [{"uniq_id": id, "answer": hyp} for id, hyp in zip(sample["id"].tolist(), hyps)] + return results, scores + + +def eval_step(task, generator, models, sample, **kwargs): + if 'caption' in task.cfg._name: + return eval_caption(task, generator, models, sample, **kwargs) + elif 'vqa_gen' in task.cfg._name: + return eval_vqa_gen(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'refcoco': + return eval_refcoco(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'snli_ve': + return eval_snli_ve(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'image_gen': + return eval_image_gen(task, generator, models, sample, **kwargs) + else: + raise NotImplementedError + + +def merge_results(task, cfg, logger, score_cnt, score_sum, results): + if task.cfg._name == 'image_gen': + if cfg.distributed_training.distributed_world_size > 1: + dist.all_reduce(score_sum.data) + dist.all_reduce(score_cnt.data) + if score_cnt.item() > 0: + logger.info("score_sum: {}, score_cnt: {}, score: {}".format( + score_sum, score_cnt, round(score_sum.item() / score_cnt.item(), 4) + )) + else: + gather_results = None + if cfg.distributed_training.distributed_world_size > 1: + gather_results = [None for _ in range(dist.get_world_size())] + dist.all_gather_object(gather_results, results) + dist.all_reduce(score_sum.data) + dist.all_reduce(score_cnt.data) + if score_cnt.item() > 0: + logger.info("score_sum: {}, score_cnt: {}, score: {}".format( + score_sum, score_cnt, round(score_sum.item() / score_cnt.item(), 4) + )) + + if cfg.distributed_training.distributed_world_size == 1 or dist.get_rank() == 0: + os.makedirs(cfg.common_eval.results_path, exist_ok=True) + output_path = os.path.join(cfg.common_eval.results_path, "{}_predict.json".format(cfg.dataset.gen_subset)) + gather_results = list(chain(*gather_results)) if gather_results is not None else results + with open(output_path, 'w') as fw: + json.dump(gather_results, fw) diff --git a/utils/map_boxes/__init__.py b/utils/map_boxes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d5794ee998b73eefc35ec5b8bee34b28b12eb34 --- /dev/null +++ b/utils/map_boxes/__init__.py @@ -0,0 +1,228 @@ +""" +Author: Roman Solovyev, IPPM RAS +URL: https://github.com/ZFTurbo + +Code based on: https://github.com/fizyr/keras-retinanet/blob/master/keras_retinanet/utils/eval.py +""" + +import numpy as np +import pandas as pd +try: + import pyximport + pyximport.install(setup_args={"include_dirs": np.get_include()}, reload_support=False) + from .compute_overlap import compute_overlap +except: + print("Couldn't import fast version of function compute_overlap, will use slow one. Check cython intallation") + from .compute_overlap_slow import compute_overlap + + +def get_real_annotations(table): + res = dict() + ids = table['ImageID'].values.astype(np.str) + labels = table['LabelName'].values.astype(np.str) + xmin = table['XMin'].values.astype(np.float32) + xmax = table['XMax'].values.astype(np.float32) + ymin = table['YMin'].values.astype(np.float32) + ymax = table['YMax'].values.astype(np.float32) + + for i in range(len(ids)): + id = ids[i] + label = labels[i] + if id not in res: + res[id] = dict() + if label not in res[id]: + res[id][label] = [] + box = [xmin[i], ymin[i], xmax[i], ymax[i]] + res[id][label].append(box) + + return res + + +def get_detections(table): + res = dict() + ids = table['ImageID'].values.astype(np.str) + labels = table['LabelName'].values.astype(np.str) + scores = table['Conf'].values.astype(np.float32) + xmin = table['XMin'].values.astype(np.float32) + xmax = table['XMax'].values.astype(np.float32) + ymin = table['YMin'].values.astype(np.float32) + ymax = table['YMax'].values.astype(np.float32) + + for i in range(len(ids)): + id = ids[i] + label = labels[i] + if id not in res: + res[id] = dict() + if label not in res[id]: + res[id][label] = [] + box = [xmin[i], ymin[i], xmax[i], ymax[i], scores[i]] + res[id][label].append(box) + + return res + + +def _compute_ap(recall, precision): + """ Compute the average precision, given the recall and precision curves. + + Code originally from https://github.com/rbgirshick/py-faster-rcnn. + + # Arguments + recall: The recall curve (list). + precision: The precision curve (list). + # Returns + The average precision as computed in py-faster-rcnn. + """ + # correct AP calculation + # first append sentinel values at the end + mrec = np.concatenate(([0.], recall, [1.])) + mpre = np.concatenate(([0.], precision, [0.])) + + # compute the precision envelope + for i in range(mpre.size - 1, 0, -1): + mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) + + # to calculate area under PR curve, look for points + # where X axis (recall) changes value + i = np.where(mrec[1:] != mrec[:-1])[0] + + # and sum (\Delta recall) * prec + ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) + return ap + + +def mean_average_precision_for_boxes(ann, pred, iou_threshold=0.5, exclude_not_in_annotations=False, verbose=True): + """ + + :param ann: path to CSV-file with annotations or numpy array of shape (N, 6) + :param pred: path to CSV-file with predictions (detections) or numpy array of shape (N, 7) + :param iou_threshold: IoU between boxes which count as 'match'. Default: 0.5 + :param exclude_not_in_annotations: exclude image IDs which are not exist in annotations. Default: False + :param verbose: print detailed run info. Default: True + :return: tuple, where first value is mAP and second values is dict with AP for each class. + """ + + if isinstance(ann, str): + valid = pd.read_csv(ann) + else: + valid = pd.DataFrame(ann, columns=['ImageID', 'LabelName', 'XMin', 'XMax', 'YMin', 'YMax']) + + if isinstance(pred, str): + preds = pd.read_csv(pred) + else: + preds = pd.DataFrame(pred, columns=['ImageID', 'LabelName', 'Conf', 'XMin', 'XMax', 'YMin', 'YMax']) + + ann_unique = valid['ImageID'].unique() + preds_unique = preds['ImageID'].unique() + + if verbose: + print('Number of files in annotations: {}'.format(len(ann_unique))) + print('Number of files in predictions: {}'.format(len(preds_unique))) + + # Exclude files not in annotations! + if exclude_not_in_annotations: + preds = preds[preds['ImageID'].isin(ann_unique)] + preds_unique = preds['ImageID'].unique() + if verbose: + print('Number of files in detection after reduction: {}'.format(len(preds_unique))) + + unique_classes = valid['LabelName'].unique().astype(np.str) + if verbose: + print('Unique classes: {}'.format(len(unique_classes))) + + all_detections = get_detections(preds) + all_annotations = get_real_annotations(valid) + if verbose: + print('Detections length: {}'.format(len(all_detections))) + print('Annotations length: {}'.format(len(all_annotations))) + + average_precisions = {} + for zz, label in enumerate(sorted(unique_classes)): + + # Negative class + if str(label) == 'nan': + continue + + false_positives = [] + true_positives = [] + scores = [] + num_annotations = 0.0 + + for i in range(len(ann_unique)): + detections = [] + annotations = [] + id = ann_unique[i] + if id in all_detections: + if label in all_detections[id]: + detections = all_detections[id][label] + if id in all_annotations: + if label in all_annotations[id]: + annotations = all_annotations[id][label] + + if len(detections) == 0 and len(annotations) == 0: + continue + + num_annotations += len(annotations) + detected_annotations = [] + + annotations = np.array(annotations, dtype=np.float64) + for d in detections: + scores.append(d[4]) + + if len(annotations) == 0: + false_positives.append(1) + true_positives.append(0) + continue + + overlaps = compute_overlap(np.expand_dims(np.array(d, dtype=np.float64), axis=0), annotations) + assigned_annotation = np.argmax(overlaps, axis=1) + max_overlap = overlaps[0, assigned_annotation] + + if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations: + false_positives.append(0) + true_positives.append(1) + detected_annotations.append(assigned_annotation) + else: + false_positives.append(1) + true_positives.append(0) + + if num_annotations == 0: + average_precisions[label] = 0, 0 + continue + + false_positives = np.array(false_positives) + true_positives = np.array(true_positives) + scores = np.array(scores) + + # sort by score + indices = np.argsort(-scores) + false_positives = false_positives[indices] + true_positives = true_positives[indices] + + # compute false positives and true positives + false_positives = np.cumsum(false_positives) + true_positives = np.cumsum(true_positives) + + # compute recall and precision + recall = true_positives / num_annotations + precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps) + + # compute average precision + average_precision = _compute_ap(recall, precision) + average_precisions[label] = average_precision, num_annotations + if verbose: + s1 = "{:30s} | {:.6f} | {:7d}".format(label, average_precision, int(num_annotations)) + print(s1) + + present_classes = 0 + precision = 0 + for label, (average_precision, num_annotations) in average_precisions.items(): + if num_annotations > 0: + present_classes += 1 + precision += average_precision + if present_classes > 0: + mean_ap = precision / present_classes + else: + mean_ap = 0 + if verbose: + print('mAP: {:.6f}'.format(mean_ap)) + return mean_ap, average_precisions diff --git a/utils/map_boxes/compute_overlap.pyx b/utils/map_boxes/compute_overlap.pyx new file mode 100644 index 0000000000000000000000000000000000000000..fa8c91960aaea143e160d0f82a40789a0a386721 --- /dev/null +++ b/utils/map_boxes/compute_overlap.pyx @@ -0,0 +1,54 @@ +# -------------------------------------------------------- +# Fast R-CNN +# Copyright (c) 2015 Microsoft +# Licensed under The MIT License [see LICENSE for details] +# Written by Sergey Karayev +# Modified bt Roman Solovyev to support normalized boxes +# -------------------------------------------------------- + +cimport cython +import numpy as np +cimport numpy as np + + +def compute_overlap( + np.ndarray[double, ndim=2] boxes, + np.ndarray[double, ndim=2] query_boxes +): + """ + Args + a: (N, 4) ndarray of float + b: (K, 4) ndarray of float + + Returns + overlaps: (N, K) ndarray of overlap between boxes and query_boxes + """ + cdef unsigned int N = boxes.shape[0] + cdef unsigned int K = query_boxes.shape[0] + cdef np.ndarray[double, ndim=2] overlaps = np.zeros((N, K), dtype=np.float64) + cdef double iw, ih, box_area + cdef double ua + cdef unsigned int k, n + for k in range(K): + box_area = ( + (query_boxes[k, 2] - query_boxes[k, 0]) * + (query_boxes[k, 3] - query_boxes[k, 1]) + ) + for n in range(N): + iw = ( + min(boxes[n, 2], query_boxes[k, 2]) - + max(boxes[n, 0], query_boxes[k, 0]) + ) + if iw > 0: + ih = ( + min(boxes[n, 3], query_boxes[k, 3]) - + max(boxes[n, 1], query_boxes[k, 1]) + ) + if ih > 0: + ua = np.float64( + (boxes[n, 2] - boxes[n, 0]) * + (boxes[n, 3] - boxes[n, 1]) + + box_area - iw * ih + ) + overlaps[n, k] = iw * ih / ua + return overlaps diff --git a/utils/map_boxes/compute_overlap_slow.py b/utils/map_boxes/compute_overlap_slow.py new file mode 100644 index 0000000000000000000000000000000000000000..4f1d45c21caa9d16af140b84d81af05f891ad848 --- /dev/null +++ b/utils/map_boxes/compute_overlap_slow.py @@ -0,0 +1,43 @@ +""" +Author: Roman Solovyev, IPPM RAS +URL: https://github.com/ZFTurbo +""" + +import numpy as np + + +def compute_overlap(boxes, query_boxes): + """ + Args + a: (N, 4) ndarray of float + b: (K, 4) ndarray of float + + Returns + overlaps: (N, K) ndarray of overlap between boxes and query_boxes + """ + N = boxes.shape[0] + K = query_boxes.shape[0] + overlaps = np.zeros((N, K), dtype=np.float64) + for k in range(K): + box_area = ( + (query_boxes[k, 2] - query_boxes[k, 0]) * + (query_boxes[k, 3] - query_boxes[k, 1]) + ) + for n in range(N): + iw = ( + min(boxes[n, 2], query_boxes[k, 2]) - + max(boxes[n, 0], query_boxes[k, 0]) + ) + if iw > 0: + ih = ( + min(boxes[n, 3], query_boxes[k, 3]) - + max(boxes[n, 1], query_boxes[k, 1]) + ) + if ih > 0: + ua = np.float64( + (boxes[n, 2] - boxes[n, 0]) * + (boxes[n, 3] - boxes[n, 1]) + + box_area - iw * ih + ) + overlaps[n, k] = iw * ih / ua + return overlaps diff --git a/utils/rouge.py b/utils/rouge.py new file mode 100644 index 0000000000000000000000000000000000000000..7d653f029d8b439bfa297af8ee1a6e40d45e58f8 --- /dev/null +++ b/utils/rouge.py @@ -0,0 +1,128 @@ +# coding=utf-8 +# Copyright 2020 The HuggingFace Datasets Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" ROUGE metric from Google Research github repo. """ + +# The dependencies in https://github.com/google-research/google-research/blob/master/rouge/requirements.txt +import absl # Here to have a nice missing dependency error message early on +import nltk # Here to have a nice missing dependency error message early on +import numpy # Here to have a nice missing dependency error message early on +import six # Here to have a nice missing dependency error message early on +from rouge_score import rouge_scorer, scoring + +import datasets + + +_CITATION = """\ +@inproceedings{lin-2004-rouge, + title = "{ROUGE}: A Package for Automatic Evaluation of Summaries", + author = "Lin, Chin-Yew", + booktitle = "Text Summarization Branches Out", + month = jul, + year = "2004", + address = "Barcelona, Spain", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/W04-1013", + pages = "74--81", +} +""" + +_DESCRIPTION = """\ +ROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for +evaluating automatic summarization and machine translation software in natural language processing. +The metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation. +Note that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters. +This metrics is a wrapper around Google Research reimplementation of ROUGE: +https://github.com/google-research/google-research/tree/master/rouge +""" + +_KWARGS_DESCRIPTION = """ +Calculates average rouge scores for a list of hypotheses and references +Args: + predictions: list of predictions to score. Each predictions + should be a string with tokens separated by spaces. + references: list of reference for each prediction. Each + reference should be a string with tokens separated by spaces. + rouge_types: A list of rouge types to calculate. + Valid names: + `"rouge{n}"` (e.g. `"rouge1"`, `"rouge2"`) where: {n} is the n-gram based scoring, + `"rougeL"`: Longest common subsequence based scoring. + `"rougeLSum"`: rougeLsum splits text using `"\n"`. + See details in https://github.com/huggingface/datasets/issues/617 + use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes. + use_agregator: Return aggregates if this is set to True +Returns: + rouge1: rouge_1 (precision, recall, f1), + rouge2: rouge_2 (precision, recall, f1), + rougeL: rouge_l (precision, recall, f1), + rougeLsum: rouge_lsum (precision, recall, f1) +Examples: + >>> rouge = datasets.load_metric('rouge') + >>> predictions = ["hello there", "general kenobi"] + >>> references = ["hello there", "general kenobi"] + >>> results = rouge.compute(predictions=predictions, references=references) + >>> print(list(results.keys())) + ['rouge1', 'rouge2', 'rougeL', 'rougeLsum'] + >>> print(results["rouge1"]) + AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0)) + >>> print(results["rouge1"].mid.fmeasure) + 1.0 +""" + + +@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION) +class Rouge(datasets.Metric): + def _info(self): + return datasets.MetricInfo( + description=_DESCRIPTION, + citation=_CITATION, + inputs_description=_KWARGS_DESCRIPTION, + features=datasets.Features( + { + "predictions": datasets.Value("string", id="sequence"), + "references": datasets.Value("string", id="sequence"), + } + ), + codebase_urls=["https://github.com/google-research/google-research/tree/master/rouge"], + reference_urls=[ + "https://en.wikipedia.org/wiki/ROUGE_(metric)", + "https://github.com/google-research/google-research/tree/master/rouge", + ], + ) + + def _compute(self, predictions, references, rouge_types=None, use_agregator=True, use_stemmer=False): + if rouge_types is None: + rouge_types = ["rouge1", "rouge2", "rougeL", "rougeLsum"] + + scorer = rouge_scorer.RougeScorer(rouge_types=rouge_types, use_stemmer=use_stemmer) + if use_agregator: + aggregator = scoring.BootstrapAggregator() + else: + scores = [] + + for ref, pred in zip(references, predictions): + score = scorer.score(ref, pred) + if use_agregator: + aggregator.add_scores(score) + else: + scores.append(score) + + if use_agregator: + result = aggregator.aggregate() + else: + result = {} + for key in scores[0]: + result[key] = list(score[key] for score in scores) + + return result \ No newline at end of file diff --git a/utils/transforms.py b/utils/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..b1382525f1b07e941618d04aafcafe5995d486c7 --- /dev/null +++ b/utils/transforms.py @@ -0,0 +1,513 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import random + +import torch +import torchvision.transforms as T +import torchvision.transforms.functional as F +import numpy as np +from PIL import Image + + +def crop(image, target, region, delete=True): + cropped_image = F.crop(image, *region) + + target = target.copy() + i, j, h, w = region + + # should we do something wrt the original size? + target["size"] = torch.tensor([h, w]) + + fields = ["labels", "area"] + + if "boxes" in target: + boxes = target["boxes"] + max_size = torch.as_tensor([w, h], dtype=torch.float32) + cropped_boxes = boxes - torch.as_tensor([j, i, j, i]) + cropped_boxes = torch.min(cropped_boxes.reshape(-1, 2, 2), max_size) + cropped_boxes = cropped_boxes.clamp(min=0) + area = (cropped_boxes[:, 1, :] - cropped_boxes[:, 0, :]).prod(dim=1) + target["boxes"] = cropped_boxes.reshape(-1, 4) + target["area"] = area + fields.append("boxes") + + if "polygons" in target: + polygons = target["polygons"] + num_polygons = polygons.shape[0] + max_size = torch.as_tensor([w, h], dtype=torch.float32) + start_coord = torch.cat([torch.tensor([j, i], dtype=torch.float32) + for _ in range(polygons.shape[1] // 2)], dim=0) + cropped_boxes = polygons - start_coord + cropped_boxes = torch.min(cropped_boxes.reshape(num_polygons, -1, 2), max_size) + cropped_boxes = cropped_boxes.clamp(min=0) + target["polygons"] = cropped_boxes.reshape(num_polygons, -1) + fields.append("polygons") + + if "masks" in target: + # FIXME should we update the area here if there are no boxes? + target['masks'] = target['masks'][:, i:i + h, j:j + w] + fields.append("masks") + + # remove elements for which the boxes or masks that have zero area + if delete and ("boxes" in target or "masks" in target): + # favor boxes selection when defining which elements to keep + # this is compatible with previous implementation + if "boxes" in target: + cropped_boxes = target['boxes'].reshape(-1, 2, 2) + keep = torch.all(cropped_boxes[:, 1, :] > cropped_boxes[:, 0, :], dim=1) + else: + keep = target['masks'].flatten(1).any(1) + + for field in fields: + target[field] = target[field][keep.tolist()] + + return cropped_image, target + + +def hflip(image, target): + flipped_image = F.hflip(image) + + w, h = image.size + + target = target.copy() + if "boxes" in target: + boxes = target["boxes"] + boxes = boxes[:, [2, 1, 0, 3]] * torch.as_tensor([-1, 1, -1, 1]) + torch.as_tensor([w, 0, w, 0]) + target["boxes"] = boxes + + if "polygons" in target: + polygons = target["polygons"] + num_polygons = polygons.shape[0] + polygons = polygons.reshape(num_polygons, -1, 2) * torch.as_tensor([-1, 1]) + torch.as_tensor([w, 0]) + target["polygons"] = polygons + + if "masks" in target: + target['masks'] = target['masks'].flip(-1) + + return flipped_image, target + + +def resize(image, target, size, max_size=None): + # size can be min_size (scalar) or (w, h) tuple + + def get_size_with_aspect_ratio(image_size, size, max_size=None): + w, h = image_size + + if (w <= h and w == size) or (h <= w and h == size): + if max_size is not None: + max_size = int(max_size) + h = min(h, max_size) + w = min(w, max_size) + return (h, w) + + if w < h: + ow = size + oh = int(size * h / w) + else: + oh = size + ow = int(size * w / h) + + if max_size is not None: + max_size = int(max_size) + oh = min(oh, max_size) + ow = min(ow, max_size) + + return (oh, ow) + + def get_size(image_size, size, max_size=None): + if isinstance(size, (list, tuple)): + return size[::-1] + else: + return get_size_with_aspect_ratio(image_size, size, max_size) + + size = get_size(image.size, size, max_size) + rescaled_image = F.resize(image, size, interpolation=Image.BICUBIC) + + if target is None: + return rescaled_image + + ratios = tuple(float(s) / float(s_orig) for s, s_orig in zip(rescaled_image.size, image.size)) + ratio_width, ratio_height = ratios + + target = target.copy() + if "boxes" in target: + boxes = target["boxes"] + scaled_boxes = boxes * torch.as_tensor([ratio_width, ratio_height, ratio_width, ratio_height]) + target["boxes"] = scaled_boxes + + if "polygons" in target: + polygons = target["polygons"] + scaled_ratio = torch.cat([torch.tensor([ratio_width, ratio_height]) + for _ in range(polygons.shape[1] // 2)], dim=0) + scaled_polygons = polygons * scaled_ratio + target["polygons"] = scaled_polygons + + if "area" in target: + area = target["area"] + scaled_area = area * (ratio_width * ratio_height) + target["area"] = scaled_area + + h, w = size + target["size"] = torch.tensor([h, w]) + + if "masks" in target: + assert False + # target['masks'] = interpolate( + # target['masks'][:, None].float(), size, mode="nearest")[:, 0] > 0.5 + + return rescaled_image, target + + +class CenterCrop(object): + def __init__(self, size): + self.size = size + + def __call__(self, img, target): + image_width, image_height = img.size + crop_height, crop_width = self.size + crop_top = int(round((image_height - crop_height) / 2.)) + crop_left = int(round((image_width - crop_width) / 2.)) + return crop(img, target, (crop_top, crop_left, crop_height, crop_width)) + + +class ObjectCenterCrop(object): + def __init__(self, size): + self.size = size + + def __call__(self, img, target): + image_width, image_height = img.size + crop_height, crop_width = self.size + + x0 = float(target['boxes'][0][0]) + y0 = float(target['boxes'][0][1]) + x1 = float(target['boxes'][0][2]) + y1 = float(target['boxes'][0][3]) + + center_x = (x0 + x1) / 2 + center_y = (y0 + y1) / 2 + crop_left = max(center_x-crop_width/2 + min(image_width-center_x-crop_width/2, 0), 0) + crop_top = max(center_y-crop_height/2 + min(image_height-center_y-crop_height/2, 0), 0) + + return crop(img, target, (crop_top, crop_left, crop_height, crop_width), delete=False) + + +class RandomHorizontalFlip(object): + def __init__(self, p=0.5): + self.p = p + + def __call__(self, img, target): + if random.random() < self.p: + return hflip(img, target) + return img, target + + +class RandomResize(object): + def __init__(self, sizes, max_size=None, equal=False): + assert isinstance(sizes, (list, tuple)) + self.sizes = sizes + self.max_size = max_size + self.equal = equal + + def __call__(self, img, target=None): + size = random.choice(self.sizes) + if self.equal: + return resize(img, target, size, size) + else: + return resize(img, target, size, self.max_size) + + +class ToTensor(object): + def __call__(self, img, target): + return F.to_tensor(img), target + + +class Normalize(object): + def __init__(self, mean, std, max_image_size=512): + self.mean = mean + self.std = std + self.max_image_size = max_image_size + + def __call__(self, image, target=None): + image = F.normalize(image, mean=self.mean, std=self.std) + if target is None: + return image, None + target = target.copy() + # h, w = image.shape[-2:] + h, w = target["size"][0], target["size"][1] + if "boxes" in target: + boxes = target["boxes"] + boxes = boxes / self.max_image_size + target["boxes"] = boxes + if "polygons" in target: + polygons = target["polygons"] + scale = torch.cat([torch.tensor([w, h], dtype=torch.float32) + for _ in range(polygons.shape[1] // 2)], dim=0) + polygons = polygons / scale + target["polygons"] = polygons + return image, target + + +class Compose(object): + def __init__(self, transforms): + self.transforms = transforms + + def __call__(self, image, target): + for t in self.transforms: + image, target = t(image, target) + return image, target + + def __repr__(self): + format_string = self.__class__.__name__ + "(" + for t in self.transforms: + format_string += "\n" + format_string += " {0}".format(t) + format_string += "\n)" + return format_string + + +class LargeScaleJitter(object): + """ + implementation of large scale jitter from copy_paste + """ + + def __init__(self, output_size=512, aug_scale_min=0.3, aug_scale_max=2.0): + self.desired_size = torch.tensor([output_size]) + self.aug_scale_min = aug_scale_min + self.aug_scale_max = aug_scale_max + + def rescale_target(self, scaled_size, image_size, target): + # compute rescaled targets + image_scale = scaled_size / image_size + ratio_height, ratio_width = image_scale + + target = target.copy() + target["size"] = scaled_size + + if "boxes" in target: + boxes = target["boxes"] + scaled_boxes = boxes * torch.as_tensor([ratio_width, ratio_height, ratio_width, ratio_height]) + target["boxes"] = scaled_boxes + + if "area" in target: + area = target["area"] + scaled_area = area * (ratio_width * ratio_height) + target["area"] = scaled_area + + if "masks" in target: + assert False + masks = target['masks'] + # masks = interpolate( + # masks[:, None].float(), scaled_size, mode="nearest")[:, 0] > 0.5 + target['masks'] = masks + return target + + def crop_target(self, region, target): + i, j, h, w = region + fields = ["labels", "area"] + + target = target.copy() + target["size"] = torch.tensor([h, w]) + + if "boxes" in target: + boxes = target["boxes"] + max_size = torch.as_tensor([w, h], dtype=torch.float32) + cropped_boxes = boxes - torch.as_tensor([j, i, j, i]) + cropped_boxes = torch.min(cropped_boxes.reshape(-1, 2, 2), max_size) + cropped_boxes = cropped_boxes.clamp(min=0) + area = (cropped_boxes[:, 1, :] - cropped_boxes[:, 0, :]).prod(dim=1) + target["boxes"] = cropped_boxes.reshape(-1, 4) + target["area"] = area + fields.append("boxes") + + if "masks" in target: + # FIXME should we update the area here if there are no boxes? + target['masks'] = target['masks'][:, i:i + h, j:j + w] + fields.append("masks") + + # remove elements for which the boxes or masks that have zero area + if "boxes" in target or "masks" in target: + # favor boxes selection when defining which elements to keep + # this is compatible with previous implementation + if "boxes" in target: + cropped_boxes = target['boxes'].reshape(-1, 2, 2) + keep = torch.all(cropped_boxes[:, 1, :] > cropped_boxes[:, 0, :], dim=1) + else: + keep = target['masks'].flatten(1).any(1) + + for field in fields: + target[field] = target[field][keep.tolist()] + return target + + def pad_target(self, padding, target): + target = target.copy() + if "masks" in target: + target['masks'] = torch.nn.functional.pad(target['masks'], (0, padding[1], 0, padding[0])) + return target + + def __call__(self, image, target=None): + image_size = image.size + image_size = torch.tensor(image_size[::-1]) + + random_scale = torch.rand(1) * (self.aug_scale_max - self.aug_scale_min) + self.aug_scale_min + scaled_size = (random_scale * self.desired_size).round() + + scale = torch.maximum(scaled_size / image_size[0], scaled_size / image_size[1]) + scaled_size = (image_size * scale).round().int() + + scaled_image = F.resize(image, scaled_size.tolist(), interpolation=Image.BICUBIC) + + if target is not None: + target = self.rescale_target(scaled_size, image_size, target) + + # randomly crop or pad images + if random_scale >= 1: + # Selects non-zero random offset (x, y) if scaled image is larger than desired_size. + max_offset = scaled_size - self.desired_size + offset = (max_offset * torch.rand(2)).floor().int() + region = (offset[0].item(), offset[1].item(), + self.desired_size[0].item(), self.desired_size[0].item()) + output_image = F.crop(scaled_image, *region) + if target is not None: + target = self.crop_target(region, target) + else: + assert False + padding = self.desired_size - scaled_size + output_image = F.pad(scaled_image, [0, 0, padding[1].item(), padding[0].item()]) + if target is not None: + target = self.pad_target(padding, target) + + return output_image, target + + +class OriginLargeScaleJitter(object): + """ + implementation of large scale jitter from copy_paste + """ + + def __init__(self, output_size=512, aug_scale_min=0.3, aug_scale_max=2.0): + self.desired_size = torch.tensor(output_size) + self.aug_scale_min = aug_scale_min + self.aug_scale_max = aug_scale_max + + def rescale_target(self, scaled_size, image_size, target): + # compute rescaled targets + image_scale = scaled_size / image_size + ratio_height, ratio_width = image_scale + + target = target.copy() + target["size"] = scaled_size + + if "boxes" in target: + boxes = target["boxes"] + scaled_boxes = boxes * torch.as_tensor([ratio_width, ratio_height, ratio_width, ratio_height]) + target["boxes"] = scaled_boxes + + if "area" in target: + area = target["area"] + scaled_area = area * (ratio_width * ratio_height) + target["area"] = scaled_area + + if "masks" in target: + assert False + masks = target['masks'] + # masks = interpolate( + # masks[:, None].float(), scaled_size, mode="nearest")[:, 0] > 0.5 + target['masks'] = masks + return target + + def crop_target(self, region, target): + i, j, h, w = region + fields = ["labels", "area"] + + target = target.copy() + target["size"] = torch.tensor([h, w]) + + if "boxes" in target: + boxes = target["boxes"] + max_size = torch.as_tensor([w, h], dtype=torch.float32) + cropped_boxes = boxes - torch.as_tensor([j, i, j, i]) + cropped_boxes = torch.min(cropped_boxes.reshape(-1, 2, 2), max_size) + cropped_boxes = cropped_boxes.clamp(min=0) + area = (cropped_boxes[:, 1, :] - cropped_boxes[:, 0, :]).prod(dim=1) + target["boxes"] = cropped_boxes.reshape(-1, 4) + target["area"] = area + fields.append("boxes") + + if "masks" in target: + # FIXME should we update the area here if there are no boxes? + target['masks'] = target['masks'][:, i:i + h, j:j + w] + fields.append("masks") + + # remove elements for which the boxes or masks that have zero area + if "boxes" in target or "masks" in target: + # favor boxes selection when defining which elements to keep + # this is compatible with previous implementation + if "boxes" in target: + cropped_boxes = target['boxes'].reshape(-1, 2, 2) + keep = torch.all(cropped_boxes[:, 1, :] > cropped_boxes[:, 0, :], dim=1) + else: + keep = target['masks'].flatten(1).any(1) + + for field in fields: + target[field] = target[field][keep.tolist()] + return target + + def pad_target(self, padding, target): + target = target.copy() + if "masks" in target: + target['masks'] = torch.nn.functional.pad(target['masks'], (0, padding[1], 0, padding[0])) + return target + + def __call__(self, image, target=None): + image_size = image.size + image_size = torch.tensor(image_size[::-1]) + + out_desired_size = (self.desired_size * image_size / max(image_size)).round().int() + + random_scale = torch.rand(1) * (self.aug_scale_max - self.aug_scale_min) + self.aug_scale_min + scaled_size = (random_scale * self.desired_size).round() + + scale = torch.minimum(scaled_size / image_size[0], scaled_size / image_size[1]) + scaled_size = (image_size * scale).round().int() + + scaled_image = F.resize(image, scaled_size.tolist()) + + if target is not None: + target = self.rescale_target(scaled_size, image_size, target) + + # randomly crop or pad images + if random_scale > 1: + # Selects non-zero random offset (x, y) if scaled image is larger than desired_size. + max_offset = scaled_size - out_desired_size + offset = (max_offset * torch.rand(2)).floor().int() + region = (offset[0].item(), offset[1].item(), + out_desired_size[0].item(), out_desired_size[1].item()) + output_image = F.crop(scaled_image, *region) + if target is not None: + target = self.crop_target(region, target) + else: + padding = out_desired_size - scaled_size + output_image = F.pad(scaled_image, [0, 0, padding[1].item(), padding[0].item()]) + if target is not None: + target = self.pad_target(padding, target) + + return output_image, target + + +class RandomDistortion(object): + """ + Distort image w.r.t hue, saturation and exposure. + """ + + def __init__(self, brightness=0, contrast=0, saturation=0, hue=0, prob=0.5): + self.prob = prob + self.tfm = T.ColorJitter(brightness, contrast, saturation, hue) + + def __call__(self, img, target=None): + if np.random.random() < self.prob: + return self.tfm(img), target + else: + return img, target diff --git a/utils/trie.py b/utils/trie.py new file mode 100644 index 0000000000000000000000000000000000000000..0552e8f159d7b86bdbc358ecd24c49b9e0b79790 --- /dev/null +++ b/utils/trie.py @@ -0,0 +1,30 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +from collections import defaultdict + + +class TreeNode(): + def __init__(self): + self.child = defaultdict(TreeNode) + +class Trie: + + def __init__(self, eos): + self.root = TreeNode() + self.eos = eos + + def insert(self, word): + cur = self.root + for c in word: + cur = cur.child[c] + + def get_next_layer(self, word): + cur = self.root + for c in word: + cur = cur.child.get(c) + if cur is None: + return [self.eos] + return list(cur.child.keys()) diff --git a/utils/utils.py b/utils/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..26bf99306fb17dc88c6182fff56915ad7a32e258 --- /dev/null +++ b/utils/utils.py @@ -0,0 +1,34 @@ + + + +def print_trainable_params_percentage(model): + + + orig_param_size = sum(p.numel() for p in model.parameters()) + + def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) + + trainable_size = count_parameters(model) + + percentage = trainable_size / orig_param_size * 100 + + print(f"Trainable param percentage: {percentage:.2f}% ({trainable_size}/{orig_param_size})") + + return percentage + + + +def setup_for_distributed(is_master): + """ + This function disables printing when not in master process + """ + import builtins as __builtin__ + builtin_print = __builtin__.print + + def print(*args, **kwargs): + force = kwargs.pop('force', False) + if is_master or force: + builtin_print(*args, **kwargs) + + __builtin__.print = print \ No newline at end of file diff --git a/utils/vision_helper.py b/utils/vision_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..0fd37248e84b468fc15f19127240f451199318de --- /dev/null +++ b/utils/vision_helper.py @@ -0,0 +1,338 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import cv2 +import numpy as np + +## aug functions +def identity_func(img): + return img + + +def autocontrast_func(img, cutoff=0): + ''' + same output as PIL.ImageOps.autocontrast + ''' + n_bins = 256 + + def tune_channel(ch): + n = ch.size + cut = cutoff * n // 100 + if cut == 0: + high, low = ch.max(), ch.min() + else: + hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins]) + low = np.argwhere(np.cumsum(hist) > cut) + low = 0 if low.shape[0] == 0 else low[0] + high = np.argwhere(np.cumsum(hist[::-1]) > cut) + high = n_bins - 1 if high.shape[0] == 0 else n_bins - 1 - high[0] + if high <= low: + table = np.arange(n_bins) + else: + scale = (n_bins - 1) / (high - low) + offset = -low * scale + table = np.arange(n_bins) * scale + offset + table[table < 0] = 0 + table[table > n_bins - 1] = n_bins - 1 + table = table.clip(0, 255).astype(np.uint8) + return table[ch] + + channels = [tune_channel(ch) for ch in cv2.split(img)] + out = cv2.merge(channels) + return out + + +def equalize_func(img): + ''' + same output as PIL.ImageOps.equalize + PIL's implementation is different from cv2.equalize + ''' + n_bins = 256 + + def tune_channel(ch): + hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins]) + non_zero_hist = hist[hist != 0].reshape(-1) + step = np.sum(non_zero_hist[:-1]) // (n_bins - 1) + if step == 0: return ch + n = np.empty_like(hist) + n[0] = step // 2 + n[1:] = hist[:-1] + table = (np.cumsum(n) // step).clip(0, 255).astype(np.uint8) + return table[ch] + + channels = [tune_channel(ch) for ch in cv2.split(img)] + out = cv2.merge(channels) + return out + + +def rotate_func(img, degree, fill=(0, 0, 0)): + ''' + like PIL, rotate by degree, not radians + ''' + H, W = img.shape[0], img.shape[1] + center = W / 2, H / 2 + M = cv2.getRotationMatrix2D(center, degree, 1) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill) + return out + + +def solarize_func(img, thresh=128): + ''' + same output as PIL.ImageOps.posterize + ''' + table = np.array([el if el < thresh else 255 - el for el in range(256)]) + table = table.clip(0, 255).astype(np.uint8) + out = table[img] + return out + + +def color_func(img, factor): + ''' + same output as PIL.ImageEnhance.Color + ''' + ## implementation according to PIL definition, quite slow + # degenerate = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)[:, :, np.newaxis] + # out = blend(degenerate, img, factor) + # M = ( + # np.eye(3) * factor + # + np.float32([0.114, 0.587, 0.299]).reshape(3, 1) * (1. - factor) + # )[np.newaxis, np.newaxis, :] + M = ( + np.float32([ + [0.886, -0.114, -0.114], + [-0.587, 0.413, -0.587], + [-0.299, -0.299, 0.701]]) * factor + + np.float32([[0.114], [0.587], [0.299]]) + ) + out = np.matmul(img, M).clip(0, 255).astype(np.uint8) + return out + + +def contrast_func(img, factor): + """ + same output as PIL.ImageEnhance.Contrast + """ + mean = np.sum(np.mean(img, axis=(0, 1)) * np.array([0.114, 0.587, 0.299])) + table = np.array([( + el - mean) * factor + mean + for el in range(256) + ]).clip(0, 255).astype(np.uint8) + out = table[img] + return out + + +def brightness_func(img, factor): + ''' + same output as PIL.ImageEnhance.Contrast + ''' + table = (np.arange(256, dtype=np.float32) * factor).clip(0, 255).astype(np.uint8) + out = table[img] + return out + + +def sharpness_func(img, factor): + ''' + The differences the this result and PIL are all on the 4 boundaries, the center + areas are same + ''' + kernel = np.ones((3, 3), dtype=np.float32) + kernel[1][1] = 5 + kernel /= 13 + degenerate = cv2.filter2D(img, -1, kernel) + if factor == 0.0: + out = degenerate + elif factor == 1.0: + out = img + else: + out = img.astype(np.float32) + degenerate = degenerate.astype(np.float32)[1:-1, 1:-1, :] + out[1:-1, 1:-1, :] = degenerate + factor * (out[1:-1, 1:-1, :] - degenerate) + out = out.astype(np.uint8) + return out + + +def shear_x_func(img, factor, fill=(0, 0, 0)): + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, factor, 0], [0, 1, 0]]) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8) + return out + + +def translate_x_func(img, offset, fill=(0, 0, 0)): + ''' + same output as PIL.Image.transform + ''' + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, -offset], [0, 1, 0]]) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8) + return out + + +def translate_y_func(img, offset, fill=(0, 0, 0)): + ''' + same output as PIL.Image.transform + ''' + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, 0], [0, 1, -offset]]) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8) + return out + + +def posterize_func(img, bits): + ''' + same output as PIL.ImageOps.posterize + ''' + out = np.bitwise_and(img, np.uint8(255 << (8 - bits))) + return out + + +def shear_y_func(img, factor, fill=(0, 0, 0)): + H, W = img.shape[0], img.shape[1] + M = np.float32([[1, 0, 0], [factor, 1, 0]]) + out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8) + return out + + +def cutout_func(img, pad_size, replace=(0, 0, 0)): + replace = np.array(replace, dtype=np.uint8) + H, W = img.shape[0], img.shape[1] + rh, rw = np.random.random(2) + pad_size = pad_size // 2 + ch, cw = int(rh * H), int(rw * W) + x1, x2 = max(ch - pad_size, 0), min(ch + pad_size, H) + y1, y2 = max(cw - pad_size, 0), min(cw + pad_size, W) + out = img.copy() + out[x1:x2, y1:y2, :] = replace + return out + + +### level to args +def enhance_level_to_args(MAX_LEVEL): + def level_to_args(level): + return ((level / MAX_LEVEL) * 1.8 + 0.1,) + return level_to_args + + +def shear_level_to_args(MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * 0.3 + if np.random.random() > 0.5: level = -level + return (level, replace_value) + + return level_to_args + + +def translate_level_to_args(translate_const, MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * float(translate_const) + if np.random.random() > 0.5: level = -level + return (level, replace_value) + + return level_to_args + + +def cutout_level_to_args(cutout_const, MAX_LEVEL, replace_value): + def level_to_args(level): + level = int((level / MAX_LEVEL) * cutout_const) + return (level, replace_value) + + return level_to_args + + +def solarize_level_to_args(MAX_LEVEL): + def level_to_args(level): + level = int((level / MAX_LEVEL) * 256) + return (level, ) + return level_to_args + + +def none_level_to_args(level): + return () + + +def posterize_level_to_args(MAX_LEVEL): + def level_to_args(level): + level = int((level / MAX_LEVEL) * 4) + return (level, ) + return level_to_args + + +def rotate_level_to_args(MAX_LEVEL, replace_value): + def level_to_args(level): + level = (level / MAX_LEVEL) * 30 + if np.random.random() < 0.5: + level = -level + return (level, replace_value) + + return level_to_args + + +func_dict = { + 'Identity': identity_func, + 'AutoContrast': autocontrast_func, + 'Equalize': equalize_func, + 'Rotate': rotate_func, + 'Solarize': solarize_func, + 'Color': color_func, + 'Contrast': contrast_func, + 'Brightness': brightness_func, + 'Sharpness': sharpness_func, + 'ShearX': shear_x_func, + 'TranslateX': translate_x_func, + 'TranslateY': translate_y_func, + 'Posterize': posterize_func, + 'ShearY': shear_y_func, +} + +translate_const = 10 +MAX_LEVEL = 10 +replace_value = (128, 128, 128) +arg_dict = { + 'Identity': none_level_to_args, + 'AutoContrast': none_level_to_args, + 'Equalize': none_level_to_args, + 'Rotate': rotate_level_to_args(MAX_LEVEL, replace_value), + 'Solarize': solarize_level_to_args(MAX_LEVEL), + 'Color': enhance_level_to_args(MAX_LEVEL), + 'Contrast': enhance_level_to_args(MAX_LEVEL), + 'Brightness': enhance_level_to_args(MAX_LEVEL), + 'Sharpness': enhance_level_to_args(MAX_LEVEL), + 'ShearX': shear_level_to_args(MAX_LEVEL, replace_value), + 'TranslateX': translate_level_to_args( + translate_const, MAX_LEVEL, replace_value + ), + 'TranslateY': translate_level_to_args( + translate_const, MAX_LEVEL, replace_value + ), + 'Posterize': posterize_level_to_args(MAX_LEVEL), + 'ShearY': shear_level_to_args(MAX_LEVEL, replace_value), +} + + +class RandomAugment(object): + + def __init__(self, N=2, M=10, isPIL=False, augs=[]): + self.N = N + self.M = M + self.isPIL = isPIL + if augs: + self.augs = augs + else: + self.augs = list(arg_dict.keys()) + + def get_random_ops(self): + sampled_ops = np.random.choice(self.augs, self.N) + return [(op, 0.5, self.M) for op in sampled_ops] + + def __call__(self, img): + if self.isPIL: + img = np.array(img) + ops = self.get_random_ops() + for name, prob, level in ops: + if np.random.random() > prob: + continue + args = arg_dict[name](level) + img = func_dict[name](img, *args) + return img diff --git a/utils/zero_shot_utils.py b/utils/zero_shot_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2a1a79cda37ea0f7ae5be6a100f4f10d1e466aab --- /dev/null +++ b/utils/zero_shot_utils.py @@ -0,0 +1,154 @@ +# Copyright 2022 The OFA-Sys Team. +# All rights reserved. +# This source code is licensed under the Apache 2.0 license +# found in the LICENSE file in the root directory. + +import string +import math + +import torch + +from data import data_utils + + +def get_symbols_to_strip_from_output(generator): + if hasattr(generator, "symbols_to_strip_from_output"): + return generator.symbols_to_strip_from_output + else: + return {generator.bos, generator.eos} + + +def decode_fn(x, tgt_dict, bpe, generator, tokenizer=None): + x = tgt_dict.string(x.int().cpu(), extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator)) + if bpe is not None: + x = bpe.decode(x) + if tokenizer is not None: + x = tokenizer.decode(x) + return x + + +def eval_refcoco(task, generator, models, sample, **kwargs): + def _calculate_ap_score(hyps, refs, thresh=0.5): + interacts = torch.cat( + [torch.where(hyps[:, :2] < refs[:, :2], refs[:, :2], hyps[:, :2]), + torch.where(hyps[:, 2:] < refs[:, 2:], hyps[:, 2:], refs[:, 2:])], + dim=1 + ) + area_predictions = (hyps[:, 2] - hyps[:, 0]) * (hyps[:, 3] - hyps[:, 1]) + area_targets = (refs[:, 2] - refs[:, 0]) * (refs[:, 3] - refs[:, 1]) + interacts_w = interacts[:, 2] - interacts[:, 0] + interacts_h = interacts[:, 3] - interacts[:, 1] + area_interacts = interacts_w * interacts_h + ious = area_interacts / (area_predictions + area_targets - area_interacts + 1e-6) + return ((ious >= thresh) & (interacts_w > 0) & (interacts_h > 0)).float() + + gen_out = task.inference_step(generator, models, sample) + hyps = [] + for i in range(len(gen_out)): + hyps.append(gen_out[i][0]["tokens"][:-1] - len(task.src_dict) + task.cfg.num_bins) + hyps = torch.stack(hyps, dim=0) + hyps = hyps / (task.cfg.num_bins - 1) * task.cfg.max_image_size + hyps[:, ::2] /= sample['w_resize_ratios'].unsqueeze(1) + hyps[:, 1::2] /= sample['h_resize_ratios'].unsqueeze(1) + + results = [ + {"uniq_id": sample_id, + "box": [hyps[i][0].item(), hyps[i][1].item(), hyps[i][2].item(), hyps[i][3].item()]} + for i, sample_id in enumerate(sample["id"].tolist()) + ] + scores = _calculate_ap_score(hyps, sample['region_coords'].float()) + return results, scores + + +def eval_snli_ve(task, generator, models, sample, **kwargs): + encoder_out = models[0].encoder( + sample["net_input"]["src_tokens"], + src_lengths=sample["net_input"]["src_lengths"], + patch_images=sample["net_input"]["patch_images"], + patch_masks=sample["net_input"]["patch_masks"] + ) + device = sample["net_input"]["src_tokens"].device + eos_item = torch.tensor([task.src_dict.eos()]) + pad = task.src_dict.pad() + valid_result = [] + for valid_answers, valid_constraint_masks in zip(task.valid_answers_list, task.valid_constraint_masks_list): + valid_size = len(valid_answers) + valid_tgt_items = [ + torch.cat([torch.tensor(decoder_prompt[1:]), valid_answer, eos_item]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_prev_items = [ + torch.cat([torch.tensor(decoder_prompt), valid_answer]) + for decoder_prompt in sample["decoder_prompts"] for valid_answer in valid_answers + ] + valid_constraint_mask_items = [ + torch.cat( + [torch.zeros(len(decoder_prompt) - 1, valid_constraint_mask.size(1)).bool(), valid_constraint_mask], + dim=0 + ) + for decoder_prompt in sample["decoder_prompts"] for valid_constraint_mask in valid_constraint_masks + ] + valid_tgt = data_utils.collate_tokens(valid_tgt_items, pad_idx=pad).to(device) + valid_prev_output = data_utils.collate_tokens(valid_prev_items, pad_idx=pad).to(device) + valid_constraint_masks = data_utils.collate_tokens(valid_constraint_mask_items, pad_idx=pad).to(device) + + new_encoder_out = {} + new_encoder_out["encoder_out"] = [ + encoder_out["encoder_out"][0].repeat_interleave(valid_size, dim=1) + ] + new_encoder_out["encoder_padding_mask"] = [ + encoder_out["encoder_padding_mask"][0].repeat_interleave(valid_size, dim=0) + ] + new_encoder_out["position_embeddings"] = [ + encoder_out["position_embeddings"][0].repeat_interleave(valid_size, dim=0) + ] + + decoder_out = models[0].decoder(valid_prev_output, encoder_out=new_encoder_out) + decoder_out[0].masked_fill_(~valid_constraint_masks, -math.inf) + lprobs = models[0].get_normalized_probs(decoder_out, log_probs=True) + scores = lprobs.gather(dim=-1, index=valid_tgt.unsqueeze(-1)).squeeze(-1) + scores = scores.masked_fill(valid_tgt.eq(task.tgt_dict.pad()), 0) + scores = scores.masked_fill((~valid_constraint_masks).all(2), 0) + scores = scores.sum(1) + scores = scores.view(-1, valid_size) + valid_result.append(scores) + valid_result = torch.cat(valid_result, dim=-1) + predicts = valid_result.argmax(1).tolist() + hyps = [task.index2ans[predict_index] for predict_index in predicts] + results = [{"uniq_id": id, "answer": hyp} for id, hyp in zip(sample["id"].tolist(), hyps)] + scores = [ref_dict.get(hyp, 0) for ref_dict, hyp in zip(sample['ref_dict'], hyps)] + return results, scores + + +def eval_vqa_gen(task, generator, models, sample, **kwargs): + hypos = task.inference_step(generator, models, sample) + results = [] + for i, sample_id in enumerate(sample["id"].tolist()): + detok_hypo_str = decode_fn(hypos[i][0]["tokens"], task.tgt_dict, task.bpe, generator) + results.append({"question_id": sample_id, "answer": detok_hypo_str.strip()}) + scores = [ref_dict.get(result['answer'], 0) for ref_dict, result in zip(sample['ref_dict'], results)] + return results, scores + +def eval_caption(task, generator, models, sample, **kwargs): + transtab = str.maketrans({key: None for key in string.punctuation}) + hypos = task.inference_step(generator, models, sample) + results = [] + for i, sample_id in enumerate(sample["id"].tolist()): + detok_hypo_str = decode_fn(hypos[i][0]["tokens"], task.tgt_dict, task.bpe, generator) + results.append({"image_id": str(sample_id), "caption": detok_hypo_str.translate(transtab).strip()}) + return results, None + +def zero_shot_step(task, generator, models, sample, **kwargs): + generator.zero_shot = True + generator.constraint_trie = None + if task.cfg._name == 'vqa_gen': + return eval_vqa_gen(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'refcoco': + return eval_refcoco(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'snli_ve': + return eval_snli_ve(task, generator, models, sample, **kwargs) + elif task.cfg._name == 'caption': + return eval_caption(task, generator, models, sample, **kwargs) + else: + print(task.cfg._name) + raise NotImplementedError